FFmpeg: libavcodec/rv40.c Source File

FFmpeg

[フレーム]

libavcodec

rv40.c

Go to the documentation of this file.

1 /*

2 * RV40 decoder

4 *

5 * This file is part of FFmpeg.

6 *

7 * FFmpeg is free software; you can redistribute it and/or

8 * modify it under the terms of the GNU Lesser General Public

9 * License as published by the Free Software Foundation; either

10 * version 2.1 of the License, or (at your option) any later version.

11 *

12 * FFmpeg is distributed in the hope that it will be useful,

13 * but WITHOUT ANY WARRANTY; without even the implied warranty of

14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

15 * Lesser General Public License for more details.

16 *

17 * You should have received a copy of the GNU Lesser General Public

18 * License along with FFmpeg; if not, write to the Free Software

19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

20 */

22 /**

23 * @file

24 * RV40 decoder

25 */

27 #include "config.h"

29 #include "libavutil/imgutils.h"

30 #include "libavutil/thread.h"

32 #include "avcodec.h"

33 #include "codec_internal.h"

34 #include "mpegutils.h"

35 #include "mpegvideo.h"

36 #include "mpegvideodec.h"

37 #include "golomb.h"

39 #include "rv34.h"

40 #include "rv40vlc2.h"

41 #include "rv40data.h"

43 static VLCElem aic_top_vlc[23590];

44 static const VLCElem *aic_mode1_vlc[AIC_MODE1_NUM], *aic_mode2_vlc[AIC_MODE2_NUM];

45 static const VLCElem *ptype_vlc[NUM_PTYPE_VLCS], *btype_vlc[NUM_BTYPE_VLCS];

47 static av_cold const VLCElem *rv40_init_table(VLCInitState *state, int nb_bits,

48 int nb_codes, const uint8_t (*tab)[2])

49 {

50 return ff_vlc_init_tables_from_lengths(state, nb_bits, nb_codes,

51 &tab[0][1], 2, &tab[0][0], 2, 1,

52 0, 0);

53 }

55 /**

56 * Initialize all tables.

57 */

58 static av_cold void rv40_init_tables(void)

59 {

60 VLCInitState state = VLC_INIT_STATE(aic_top_vlc);

61 int i;

63 rv40_init_table(&state, AIC_TOP_BITS, AIC_TOP_SIZE,

64 rv40_aic_top_vlc_tab);

65 for(i = 0; i < AIC_MODE1_NUM; i++){

66 // Every tenth VLC table is empty

67 if((i % 10) == 9) continue;

68 aic_mode1_vlc[i] =

69 rv40_init_table(&state, AIC_MODE1_BITS,

70 AIC_MODE1_SIZE, aic_mode1_vlc_tabs[i]);

71 }

72 for (unsigned i = 0; i < AIC_MODE2_NUM; i++){

73 uint16_t syms[AIC_MODE2_SIZE];

75 for (int j = 0; j < AIC_MODE2_SIZE; j++) {

76 int first = aic_mode2_vlc_syms[i][j] >> 4;

77 int second = aic_mode2_vlc_syms[i][j] & 0xF;

78 if (HAVE_BIGENDIAN)

79 syms[j] = (first << 8) | second;

80 else

81 syms[j] = first | (second << 8);

82 }

83 aic_mode2_vlc[i] =

84 ff_vlc_init_tables_from_lengths(&state, AIC_MODE2_BITS, AIC_MODE2_SIZE,

85 aic_mode2_vlc_bits[i], 1,

86 syms, 2, 2, 0, 0);

87 }

88 for(i = 0; i < NUM_PTYPE_VLCS; i++){

89 ptype_vlc[i] =

90 rv40_init_table(&state, PTYPE_VLC_BITS, PTYPE_VLC_SIZE,

91 ptype_vlc_tabs[i]);

92 }

93 for(i = 0; i < NUM_BTYPE_VLCS; i++){

94 btype_vlc[i] =

95 rv40_init_table(&state, BTYPE_VLC_BITS, BTYPE_VLC_SIZE,

96 btype_vlc_tabs[i]);

97 }

98 }

100 /**

101 * Get stored dimension from bitstream.

102 *

103 * If the width/height is the standard one then it's coded as a 3-bit index.

104 * Otherwise it is coded as escaped 8-bit portions.

105 */

106 static int get_dimension(GetBitContext *gb, const int *dim)

107 {

108 int t = get_bits(gb, 3);

109 int val = dim[t];

110 if(val < 0)

111 val = dim[get_bits1(gb) - val];

112 if(!val){

113 do{

114 if (get_bits_left(gb) < 8)

115 return AVERROR_INVALIDDATA;

116 t = get_bits(gb, 8);

117 val += t << 2;

118 }while(t == 0xFF);

119 }

120 return val;

121 }

122

123 /**

124 * Get encoded picture size - usually this is called from rv40_parse_slice_header.

125 */

126 static void rv40_parse_picture_size(GetBitContext *gb, int *w, int *h)

127 {

128 *w = get_dimension(gb, rv40_standard_widths);

129 *h = get_dimension(gb, rv40_standard_heights);

130 }

131

132 static int rv40_parse_slice_header(RV34DecContext *r, GetBitContext *gb, SliceInfo *si)

133 {

134 int w = r->s.width, h = r->s.height;

135 int mb_size;

136 int ret;

137

138 memset(si, 0, sizeof(SliceInfo));

139 if(get_bits1(gb))

140 return AVERROR_INVALIDDATA;

141 si->type = get_bits(gb, 2);

142 if(si->type == 1) si->type = 0;

143 si->quant = get_bits(gb, 5);

144 if(get_bits(gb, 2))

145 return AVERROR_INVALIDDATA;

146 si->vlc_set = get_bits(gb, 2);

147 skip_bits1(gb);

148 si->pts = get_bits(gb, 13);

149 if(!si->type || !get_bits1(gb))

150 rv40_parse_picture_size(gb, &w, &h);

151 if ((ret = av_image_check_size(w, h, 0, r->s.avctx)) < 0)

152 return ret;

153 si->width = w;

154 si->height = h;

155 mb_size = ((w + 15) >> 4) * ((h + 15) >> 4);

156 si->start = ff_rv34_get_start_offset(gb, mb_size);

157

158 return 0;

159 }

160

161 /**

162 * Decode 4x4 intra types array.

163 */

164 static int rv40_decode_intra_types(RV34DecContext *r, GetBitContext *gb, int8_t *dst)

165 {

166 MpegEncContext *s = &r->s;

167 int i, j, k, v;

168 int A, B, C;

169 int pattern;

170 int8_t *ptr;

171

172 for(i = 0; i < 4; i++, dst += r->intra_types_stride){

173 if(!i && s->first_slice_line){

174 pattern = get_vlc2(gb, aic_top_vlc, AIC_TOP_BITS, 1);

175 dst[0] = (pattern >> 2) & 2;

176 dst[1] = (pattern >> 1) & 2;

177 dst[2] = pattern & 2;

178 dst[3] = (pattern << 1) & 2;

179 continue;

180 }

181 ptr = dst;

182 for(j = 0; j < 4; j++){

183 /* Coefficients are read using VLC chosen by the prediction pattern

184 * The first one (used for retrieving a pair of coefficients) is

185 * constructed from the top, top right and left coefficients

186 * The second one (used for retrieving only one coefficient) is

187 * top + 10 * left.

188 */

189 A = ptr[-r->intra_types_stride + 1]; // it won't be used for the last coefficient in a row

190 B = ptr[-r->intra_types_stride];

191 C = ptr[-1];

192 pattern = A + B * (1 << 4) + C * (1 << 8);

193 for(k = 0; k < MODE2_PATTERNS_NUM; k++)

194 if(pattern == rv40_aic_table_index[k])

195 break;

196 if(j < 3 && k < MODE2_PATTERNS_NUM){ //pattern is found, decoding 2 coefficients

197 AV_WN16(ptr, get_vlc2(gb, aic_mode2_vlc[k], AIC_MODE2_BITS, 2));

198 ptr += 2;

199 j++;

200 }else{

201 if(B != -1 && C != -1)

202 v = get_vlc2(gb, aic_mode1_vlc[B + C*10], AIC_MODE1_BITS, 1);

203 else{ // tricky decoding

204 v = 0;

205 switch(C){

206 case -1: // code 0 -> 1, 1 -> 0

207 if(B < 2)

208 v = get_bits1(gb) ^ 1;

209 break;

210 case 0:

211 case 2: // code 0 -> 2, 1 -> 0

212 v = (get_bits1(gb) ^ 1) << 1;

213 break;

214 }

215 }

216 *ptr++ = v;

217 }

218 }

219 }

220 return 0;

221 }

222

223 /**

224 * Decode macroblock information.

225 */

226 static int rv40_decode_mb_info(RV34DecContext *r)

227 {

228 MpegEncContext *s = &r->s;

229 GetBitContext *const gb = &r->gb;

230 int q, i;

231 int prev_type = 0;

232 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;

233

234 if (!r->mb_skip_run) {

235 r->mb_skip_run = get_interleaved_ue_golomb(gb) + 1;

236 if (r->mb_skip_run > (unsigned)s->mb_num)

237 return -1;

238 }

239

240 if (--r->mb_skip_run)

241 return RV34_MB_SKIP;

242

243 if(r->avail_cache[6-4]){

244 int blocks[RV34_MB_TYPES] = {0};

245 int count = 0;

246 if(r->avail_cache[6-1])

247 blocks[r->mb_type[mb_pos - 1]]++;

248 blocks[r->mb_type[mb_pos - s->mb_stride]]++;

249 if(r->avail_cache[6-2])

250 blocks[r->mb_type[mb_pos - s->mb_stride + 1]]++;

251 if(r->avail_cache[6-5])

252 blocks[r->mb_type[mb_pos - s->mb_stride - 1]]++;

253 for(i = 0; i < RV34_MB_TYPES; i++){

254 if(blocks[i] > count){

255 count = blocks[i];

256 prev_type = i;

257 if(count>1)

258 break;

259 }

260 }

261 } else if (r->avail_cache[6-1])

262 prev_type = r->mb_type[mb_pos - 1];

263

264 if(s->pict_type == AV_PICTURE_TYPE_P){

265 prev_type = block_num_to_ptype_vlc_num[prev_type];

266 q = get_vlc2(gb, ptype_vlc[prev_type], PTYPE_VLC_BITS, 1);

267 if(q < PBTYPE_ESCAPE)

268 return q;

269 q = get_vlc2(gb, ptype_vlc[prev_type], PTYPE_VLC_BITS, 1);

270 av_log(s->avctx, AV_LOG_ERROR, "Dquant for P-frame\n");

271 }else{

272 prev_type = block_num_to_btype_vlc_num[prev_type];

273 q = get_vlc2(gb, btype_vlc[prev_type], BTYPE_VLC_BITS, 1);

274 if(q < PBTYPE_ESCAPE)

275 return q;

276 q = get_vlc2(gb, btype_vlc[prev_type], BTYPE_VLC_BITS, 1);

277 av_log(s->avctx, AV_LOG_ERROR, "Dquant for B-frame\n");

278 }

279 return 0;

280 }

281

282 enum RV40BlockPos{

283 POS_CUR,

284 POS_TOP,

285 POS_LEFT,

286 POS_BOTTOM,

287 };

288

289 #define MASK_CUR 0x0001

290 #define MASK_RIGHT 0x0008

291 #define MASK_BOTTOM 0x0010

292 #define MASK_TOP 0x1000

293 #define MASK_Y_TOP_ROW 0x000F

294 #define MASK_Y_LAST_ROW 0xF000

295 #define MASK_Y_LEFT_COL 0x1111

296 #define MASK_Y_RIGHT_COL 0x8888

297 #define MASK_C_TOP_ROW 0x0003

298 #define MASK_C_LAST_ROW 0x000C

299 #define MASK_C_LEFT_COL 0x0005

300 #define MASK_C_RIGHT_COL 0x000A

301

302 static const int neighbour_offs_x[4] = { 0, 0, -1, 0 };

303 static const int neighbour_offs_y[4] = { 0, -1, 0, 1 };

304

305 static void rv40_adaptive_loop_filter(RV34DSPContext *rdsp,

306 uint8_t *src, int stride, int dmode,

307 int lim_q1, int lim_p1,

308 int alpha, int beta, int beta2,

309 int chroma, int edge, int dir)

310 {

311 int filter_p1, filter_q1;

312 int strong;

313 int lims;

314

315 strong = rdsp->rv40_loop_filter_strength[dir](src, stride, beta, beta2,

316 edge, &filter_p1, &filter_q1);

317

318 lims = filter_p1 + filter_q1 + ((lim_q1 + lim_p1) >> 1) + 1;

319

320 if (strong) {

321 rdsp->rv40_strong_loop_filter[dir](src, stride, alpha,

322 lims, dmode, chroma);

323 } else if (filter_p1 & filter_q1) {

324 rdsp->rv40_weak_loop_filter[dir](src, stride, 1, 1, alpha, beta,

325 lims, lim_q1, lim_p1);

326 } else if (filter_p1 | filter_q1) {

327 rdsp->rv40_weak_loop_filter[dir](src, stride, filter_p1, filter_q1,

328 alpha, beta, lims >> 1, lim_q1 >> 1,

329 lim_p1 >> 1);

330 }

331 }

332

333 /**

334 * RV40 loop filtering function

335 */

336 static void rv40_loop_filter(RV34DecContext *r, int row)

337 {

338 MpegEncContext *s = &r->s;

339 int mb_pos, mb_x;

340 int i, j, k;

341 uint8_t *Y, *C;

342 int alpha, beta, betaY, betaC;

343 int q;

344 int mbtype[4]; ///< current macroblock and its neighbours types

345 /**

346 * flags indicating that macroblock can be filtered with strong filter

347 * it is set only for intra coded MB and MB with DCs coded separately

348 */

349 int mb_strong[4];

350 int clip[4]; ///< MB filter clipping value calculated from filtering strength

351 /**

352 * coded block patterns for luma part of current macroblock and its neighbours

353 * Format:

354 * LSB corresponds to the top left block,

355 * each nibble represents one row of subblocks.

356 */

357 int cbp[4];

358 /**

359 * coded block patterns for chroma part of current macroblock and its neighbours

360 * Format is the same as for luma with two subblocks in a row.

361 */

362 int uvcbp[4][2];

363 /**

364 * This mask represents the pattern of luma subblocks that should be filtered

365 * in addition to the coded ones because they lie at the edge of

366 * 8x8 block with different enough motion vectors

367 */

368 unsigned mvmasks[4];

369

370 mb_pos = row * s->mb_stride;

371 for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){

372 int mbtype = s->cur_pic.mb_type[mb_pos];

373 if(IS_INTRA(mbtype) || IS_SEPARATE_DC(mbtype))

374 r->cbp_luma [mb_pos] = r->deblock_coefs[mb_pos] = 0xFFFF;

375 if(IS_INTRA(mbtype))

376 r->cbp_chroma[mb_pos] = 0xFF;

377 }

378 mb_pos = row * s->mb_stride;

379 for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){

380 int y_h_deblock, y_v_deblock;

381 int c_v_deblock[2], c_h_deblock[2];

382 int clip_left;

383 int avail[4];

384 unsigned y_to_deblock;

385 int c_to_deblock[2];

386

387 q = s->cur_pic.qscale_table[mb_pos];

388 alpha = rv40_alpha_tab[q];

389 beta = rv40_beta_tab [q];

390 betaY = betaC = beta * 3;

391 if(s->width * s->height <= 176*144)

392 betaY += beta;

393

394 avail[0] = 1;

395 avail[1] = row;

396 avail[2] = mb_x;

397 avail[3] = row < s->mb_height - 1;

398 for(i = 0; i < 4; i++){

399 if(avail[i]){

400 int pos = mb_pos + neighbour_offs_x[i] + neighbour_offs_y[i]*s->mb_stride;

401 mvmasks[i] = r->deblock_coefs[pos];

402 mbtype [i] = s->cur_pic.mb_type[pos];

403 cbp [i] = r->cbp_luma[pos];

404 uvcbp[i][0] = r->cbp_chroma[pos] & 0xF;

405 uvcbp[i][1] = r->cbp_chroma[pos] >> 4;

406 }else{

407 mvmasks[i] = 0;

408 mbtype [i] = mbtype[0];

409 cbp [i] = 0;

410 uvcbp[i][0] = uvcbp[i][1] = 0;

411 }

412 mb_strong[i] = IS_INTRA(mbtype[i]) || IS_SEPARATE_DC(mbtype[i]);

413 clip[i] = rv40_filter_clip_tbl[mb_strong[i] + 1][q];

414 }

415 y_to_deblock = mvmasks[POS_CUR]

416 | (mvmasks[POS_BOTTOM] << 16);

417 /* This pattern contains bits signalling that horizontal edges of

418 * the current block can be filtered.

419 * That happens when either of adjacent subblocks is coded or lies on

420 * the edge of 8x8 blocks with motion vectors differing by more than

421 * 3/4 pel in any component (any edge orientation for some reason).

422 */

423 y_h_deblock = y_to_deblock

424 | ((cbp[POS_CUR] << 4) & ~MASK_Y_TOP_ROW)

425 | ((cbp[POS_TOP] & MASK_Y_LAST_ROW) >> 12);

426 /* This pattern contains bits signalling that vertical edges of

427 * the current block can be filtered.

428 * That happens when either of adjacent subblocks is coded or lies on

429 * the edge of 8x8 blocks with motion vectors differing by more than

430 * 3/4 pel in any component (any edge orientation for some reason).

431 */

432 y_v_deblock = y_to_deblock

433 | ((cbp[POS_CUR] << 1) & ~MASK_Y_LEFT_COL)

434 | ((cbp[POS_LEFT] & MASK_Y_RIGHT_COL) >> 3);

435 if(!mb_x)

436 y_v_deblock &= ~MASK_Y_LEFT_COL;

437 if(!row)

438 y_h_deblock &= ~MASK_Y_TOP_ROW;

439 if(row == s->mb_height - 1 || (mb_strong[POS_CUR] | mb_strong[POS_BOTTOM]))

440 y_h_deblock &= ~(MASK_Y_TOP_ROW << 16);

441 /* Calculating chroma patterns is similar and easier since there is

442 * no motion vector pattern for them.

443 */

444 for(i = 0; i < 2; i++){

445 c_to_deblock[i] = (uvcbp[POS_BOTTOM][i] << 4) | uvcbp[POS_CUR][i];

446 c_v_deblock[i] = c_to_deblock[i]

447 | ((uvcbp[POS_CUR] [i] << 1) & ~MASK_C_LEFT_COL)

448 | ((uvcbp[POS_LEFT][i] & MASK_C_RIGHT_COL) >> 1);

449 c_h_deblock[i] = c_to_deblock[i]

450 | ((uvcbp[POS_TOP][i] & MASK_C_LAST_ROW) >> 2)

451 | (uvcbp[POS_CUR][i] << 2);

452 if(!mb_x)

453 c_v_deblock[i] &= ~MASK_C_LEFT_COL;

454 if(!row)

455 c_h_deblock[i] &= ~MASK_C_TOP_ROW;

456 if(row == s->mb_height - 1 || (mb_strong[POS_CUR] | mb_strong[POS_BOTTOM]))

457 c_h_deblock[i] &= ~(MASK_C_TOP_ROW << 4);

458 }

459

460 for(j = 0; j < 16; j += 4){

461 Y = s->cur_pic.data[0] + mb_x*16 + (row*16 + j) * s->linesize;

462 for(i = 0; i < 4; i++, Y += 4){

463 int ij = i + j;

464 int clip_cur = y_to_deblock & (MASK_CUR << ij) ? clip[POS_CUR] : 0;

465 int dither = j ? ij : i*4;

466

467 // if bottom block is coded then we can filter its top edge

468 // (or bottom edge of this block, which is the same)

469 if(y_h_deblock & (MASK_BOTTOM << ij)){

470 rv40_adaptive_loop_filter(&r->rdsp, Y+4*s->linesize,

471 s->linesize, dither,

472 y_to_deblock & (MASK_BOTTOM << ij) ? clip[POS_CUR] : 0,

473 clip_cur, alpha, beta, betaY,

474 0, 0, 0);

475 }

476 // filter left block edge in ordinary mode (with low filtering strength)

477 if(y_v_deblock & (MASK_CUR << ij) && (i || !(mb_strong[POS_CUR] | mb_strong[POS_LEFT]))){

478 if(!i)

479 clip_left = mvmasks[POS_LEFT] & (MASK_RIGHT << j) ? clip[POS_LEFT] : 0;

480 else

481 clip_left = y_to_deblock & (MASK_CUR << (ij-1)) ? clip[POS_CUR] : 0;

482 rv40_adaptive_loop_filter(&r->rdsp, Y, s->linesize, dither,

483 clip_cur,

484 clip_left,

485 alpha, beta, betaY, 0, 0, 1);

486 }

487 // filter top edge of the current macroblock when filtering strength is high

488 if(!j && y_h_deblock & (MASK_CUR << i) && (mb_strong[POS_CUR] | mb_strong[POS_TOP])){

489 rv40_adaptive_loop_filter(&r->rdsp, Y, s->linesize, dither,

490 clip_cur,

491 mvmasks[POS_TOP] & (MASK_TOP << i) ? clip[POS_TOP] : 0,

492 alpha, beta, betaY, 0, 1, 0);

493 }

494 // filter left block edge in edge mode (with high filtering strength)

495 if(y_v_deblock & (MASK_CUR << ij) && !i && (mb_strong[POS_CUR] | mb_strong[POS_LEFT])){

496 clip_left = mvmasks[POS_LEFT] & (MASK_RIGHT << j) ? clip[POS_LEFT] : 0;

497 rv40_adaptive_loop_filter(&r->rdsp, Y, s->linesize, dither,

498 clip_cur,

499 clip_left,

500 alpha, beta, betaY, 0, 1, 1);

501 }

502 }

503 }

504 for(k = 0; k < 2; k++){

505 for(j = 0; j < 2; j++){

506 C = s->cur_pic.data[k + 1] + mb_x*8 + (row*8 + j*4) * s->uvlinesize;

507 for(i = 0; i < 2; i++, C += 4){

508 int ij = i + j*2;

509 int clip_cur = c_to_deblock[k] & (MASK_CUR << ij) ? clip[POS_CUR] : 0;

510 if(c_h_deblock[k] & (MASK_CUR << (ij+2))){

511 int clip_bot = c_to_deblock[k] & (MASK_CUR << (ij+2)) ? clip[POS_CUR] : 0;

512 rv40_adaptive_loop_filter(&r->rdsp, C+4*s->uvlinesize, s->uvlinesize, i*8,

513 clip_bot,

514 clip_cur,

515 alpha, beta, betaC, 1, 0, 0);

516 }

517 if((c_v_deblock[k] & (MASK_CUR << ij)) && (i || !(mb_strong[POS_CUR] | mb_strong[POS_LEFT]))){

518 if(!i)

519 clip_left = uvcbp[POS_LEFT][k] & (MASK_CUR << (2*j+1)) ? clip[POS_LEFT] : 0;

520 else

521 clip_left = c_to_deblock[k] & (MASK_CUR << (ij-1)) ? clip[POS_CUR] : 0;

522 rv40_adaptive_loop_filter(&r->rdsp, C, s->uvlinesize, j*8,

523 clip_cur,

524 clip_left,

525 alpha, beta, betaC, 1, 0, 1);

526 }

527 if(!j && c_h_deblock[k] & (MASK_CUR << ij) && (mb_strong[POS_CUR] | mb_strong[POS_TOP])){

528 int clip_top = uvcbp[POS_TOP][k] & (MASK_CUR << (ij+2)) ? clip[POS_TOP] : 0;

529 rv40_adaptive_loop_filter(&r->rdsp, C, s->uvlinesize, i*8,

530 clip_cur,

531 clip_top,

532 alpha, beta, betaC, 1, 1, 0);

533 }

534 if(c_v_deblock[k] & (MASK_CUR << ij) && !i && (mb_strong[POS_CUR] | mb_strong[POS_LEFT])){

535 clip_left = uvcbp[POS_LEFT][k] & (MASK_CUR << (2*j+1)) ? clip[POS_LEFT] : 0;

536 rv40_adaptive_loop_filter(&r->rdsp, C, s->uvlinesize, j*8,

537 clip_cur,

538 clip_left,

539 alpha, beta, betaC, 1, 1, 1);

540 }

541 }

542 }

543 }

544 }

545 }

546

547 /**

548 * Initialize decoder.

549 */

550 static av_cold int rv40_decode_init(AVCodecContext *avctx)

551 {

552 static AVOnce init_static_once = AV_ONCE_INIT;

553 RV34DecContext *r = avctx->priv_data;

554 int ret;

555

556 r->rv30 = 0;

557 if ((ret = ff_rv34_decode_init(avctx)) < 0)

558 return ret;

559 r->parse_slice_header = rv40_parse_slice_header;

560 r->decode_intra_types = rv40_decode_intra_types;

561 r->decode_mb_info = rv40_decode_mb_info;

562 r->loop_filter = rv40_loop_filter;

563 r->luma_dc_quant_i = rv40_luma_dc_quant[0];

564 r->luma_dc_quant_p = rv40_luma_dc_quant[1];

565 ff_rv40dsp_init(&r->rdsp);

566 ff_thread_once(&init_static_once, rv40_init_tables);

567 return 0;

568 }

569

570 const FFCodec ff_rv40_decoder = {

571 .p.name = "rv40",

572 CODEC_LONG_NAME("RealVideo 4.0"),

573 .p.type = AVMEDIA_TYPE_VIDEO,

574 .p.id = AV_CODEC_ID_RV40,

575 .priv_data_size = sizeof(RV34DecContext),

576 .init = rv40_decode_init,

577 .close = ff_rv34_decode_end,

578 FF_CODEC_DECODE_CB(ff_rv34_decode_frame),

579 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |

580 AV_CODEC_CAP_FRAME_THREADS,

581 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

582 .flush = ff_mpeg_flush,

583 UPDATE_THREAD_CONTEXT(ff_rv34_decode_update_thread_context),

584 };

MASK_C_LAST_ROW

#define MASK_C_LAST_ROW

Definition: rv40.c:298

RV34DecContext

decoder context

Definition: rv34.h:87

#define A(x)

Definition: vpx_arith.h:28

AIC_MODE1_BITS

#define AIC_MODE1_BITS

Definition: rv40vlc2.h:386

FF_CODEC_CAP_INIT_CLEANUP

#define FF_CODEC_CAP_INIT_CLEANUP

The codec allows calling the close function for deallocation even if the init function returned a fai...

Definition: codec_internal.h:42

rv40_aic_table_index

static const uint16_t rv40_aic_table_index[MODE2_PATTERNS_NUM]

intra types table

Definition: rv40data.h:47

AIC_MODE1_SIZE

#define AIC_MODE1_SIZE

Definition: rv40vlc2.h:385

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:689

const char * r

Definition: vf_curves.c:127

ff_rv34_decode_end

av_cold int ff_rv34_decode_end(AVCodecContext *avctx)

Definition: rv34.c:1816

MASK_Y_TOP_ROW

#define MASK_Y_TOP_ROW

Definition: rv40.c:293

rv40_adaptive_loop_filter

static void rv40_adaptive_loop_filter(RV34DSPContext *rdsp, uint8_t *src, int stride, int dmode, int lim_q1, int lim_p1, int alpha, int beta, int beta2, int chroma, int edge, int dir)

Definition: rv40.c:305

aic_mode2_vlc_bits

static const uint8_t aic_mode2_vlc_bits[AIC_MODE2_NUM][AIC_MODE2_SIZE]

Definition: rv40vlc2.h:236

thread.h

ff_rv34_get_start_offset

int ff_rv34_get_start_offset(GetBitContext *gb, int mb_size)

Decode starting slice position.

Definition: rv34.c:339

get_interleaved_ue_golomb

static unsigned get_interleaved_ue_golomb(GetBitContext *gb)

Definition: golomb.h:143

uint8_t w

Definition: llviddspenc.c:38

ff_rv34_decode_update_thread_context

int ff_rv34_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)

Definition: rv34.c:1537

chroma

static av_always_inline void chroma(WaveformContext *s, AVFrame *in, AVFrame *out, int component, int intensity, int offset_y, int offset_x, int column, int mirror, int jobnr, int nb_jobs)

Definition: vf_waveform.c:1639

rv40_loop_filter

static void rv40_loop_filter(RV34DecContext *r, int row)

RV40 loop filtering function.

Definition: rv40.c:336

AIC_MODE2_SIZE

#define AIC_MODE2_SIZE

Definition: rv40vlc2.h:50

PTYPE_VLC_SIZE

#define PTYPE_VLC_SIZE

Definition: rv40vlc2.h:569

FFCodec

Definition: codec_internal.h:127

mpegvideo.h

RV40BlockPos

Definition: rv40.c:282

mpegutils.h

aic_mode2_vlc_syms

static const uint8_t aic_mode2_vlc_syms[AIC_MODE2_NUM][AIC_MODE2_SIZE]

Definition: rv40vlc2.h:53

MASK_Y_RIGHT_COL

#define MASK_Y_RIGHT_COL

Definition: rv40.c:296

MASK_BOTTOM

#define MASK_BOTTOM

Definition: rv40.c:291

rv40_standard_heights

static const int rv40_standard_heights[]

Definition: rv40data.h:37

MASK_C_LEFT_COL

#define MASK_C_LEFT_COL

Definition: rv40.c:299

golomb.h

exp golomb vlc stuff

static av_cold void close(AVCodecParserContext *s)

Definition: apv_parser.c:135

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:333

rv40_decode_init

static av_cold int rv40_decode_init(AVCodecContext *avctx)

Initialize decoder.

Definition: rv40.c:550

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

MODE2_PATTERNS_NUM

#define MODE2_PATTERNS_NUM

Definition: rv40data.h:40

ptype_vlc

static const VLCElem * ptype_vlc[NUM_PTYPE_VLCS]

Definition: rv40.c:45

GetBitContext

Definition: get_bits.h:109

tab

static const struct twinvq_data tab

Definition: twinvq_data.h:10345

val

static double val(void *priv, double ch)

Definition: aeval.c:77

MASK_Y_LEFT_COL

#define MASK_Y_LEFT_COL

Definition: rv40.c:295

s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going which in turn will define variables for the build system and the C

Definition: writing_filters.txt:58

first

trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first

Definition: rate_distortion.txt:12

ff_thread_once

static int ff_thread_once(char *control, void(*routine)(void))

Definition: thread.h:205

mpegvideodec.h

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

AIC_MODE2_NUM

#define AIC_MODE2_NUM

codes used for determining a pair of block types

Definition: rv40vlc2.h:49

av_cold

#define av_cold

Definition: attributes.h:106

ff_rv34_decode_init

av_cold int ff_rv34_decode_init(AVCodecContext *avctx)

Initialize decoder.

Definition: rv34.c:1507

rv40_init_tables

static av_cold void rv40_init_tables(void)

Initialize all tables.

Definition: rv40.c:58

VLCInitState

For static VLCs, the number of bits can often be hardcoded at each get_vlc2() callsite.

Definition: vlc.h:220

clip

Definition: af_crystalizer.c:122

POS_TOP

@ POS_TOP

Definition: rv40.c:284

ff_mpeg_flush

av_cold void ff_mpeg_flush(AVCodecContext *avctx)

Definition: mpegvideo_dec.c:411

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:346

#define s(width, name)

Definition: cbs_vp9.c:198

rv40_parse_slice_header

static int rv40_parse_slice_header(RV34DecContext *r, GetBitContext *gb, SliceInfo *si)

Definition: rv40.c:132

RV34DSPContext::rv40_loop_filter_strength

rv40_loop_filter_strength_func rv40_loop_filter_strength[2]

Definition: rv34dsp.h:74

#define B

Definition: huffyuv.h:42

btype_vlc

static const VLCElem * btype_vlc[NUM_BTYPE_VLCS]

Definition: rv40.c:45

rv40_parse_picture_size

static void rv40_parse_picture_size(GetBitContext *gb, int *w, int *h)

Get encoded picture size - usually this is called from rv40_parse_slice_header.

Definition: rv40.c:126

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:331

AV_CODEC_CAP_FRAME_THREADS

#define AV_CODEC_CAP_FRAME_THREADS

Codec supports frame-level multithreading.

Definition: codec.h:95

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:203

RV34_MB_SKIP

@ RV34_MB_SKIP

Skipped block.

Definition: rv34.h:52

MASK_CUR

#define MASK_CUR

Definition: rv40.c:289

AIC_MODE2_BITS

#define AIC_MODE2_BITS

Definition: rv40vlc2.h:51

SliceInfo::type

int type

slice type (intra, inter)

Definition: rv34.h:77

PTYPE_VLC_BITS

#define PTYPE_VLC_BITS

Definition: rv40vlc2.h:570

ff_rv40_decoder

const FFCodec ff_rv40_decoder

Definition: rv40.c:570

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:386

rv40data.h

BTYPE_VLC_SIZE

#define BTYPE_VLC_SIZE

Definition: rv40vlc2.h:597

UPDATE_THREAD_CONTEXT

#define UPDATE_THREAD_CONTEXT(func)

Definition: codec_internal.h:340

NUM_BTYPE_VLCS

#define NUM_BTYPE_VLCS

tables used for P-frame macroblock type decoding

Definition: rv40vlc2.h:596

get_vlc2

static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)

Parse a vlc code.

Definition: get_bits.h:646

rv34.h

AVOnce

#define AVOnce

Definition: thread.h:202

rv40_decode_intra_types

static int rv40_decode_intra_types(RV34DecContext *r, GetBitContext *gb, int8_t *dst)

Decode 4x4 intra types array.

Definition: rv40.c:164

SliceInfo::quant

int quant

quantizer used for this slice

Definition: rv34.h:78

rv40_init_table

static const av_cold VLCElem * rv40_init_table(VLCInitState *state, int nb_bits, int nb_codes, const uint8_t(*tab)[2])

Definition: rv40.c:47

RV34DSPContext

Definition: rv34dsp.h:57

IS_INTRA

#define IS_INTRA(x, y)

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:368

SliceInfo::vlc_set

int vlc_set

VLCs used for this slice.

Definition: rv34.h:79

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.

Definition: codec.h:52

codec_internal.h

ff_rv34_decode_frame

int ff_rv34_decode_frame(AVCodecContext *avctx, AVFrame *pict, int *got_picture_ptr, AVPacket *avpkt)

Definition: rv34.c:1611

dst

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst

Definition: dsp.h:87

rv40_decode_mb_info

static int rv40_decode_mb_info(RV34DecContext *r)

Decode macroblock information.

Definition: rv40.c:226

VLCElem

Definition: vlc.h:32

PBTYPE_ESCAPE

#define PBTYPE_ESCAPE

Definition: rv40vlc2.h:564

rv40_alpha_tab

static const uint8_t rv40_alpha_tab[32]

alpha parameter for RV40 loop filter - almost the same as in JVT-A003r1

Definition: rv40data.h:73

rv40_standard_widths

static const int rv40_standard_widths[]

standard widths and heights coded in RV40

Definition: rv40data.h:36

BTYPE_VLC_BITS

#define BTYPE_VLC_BITS

Definition: rv40vlc2.h:598

MASK_Y_LAST_ROW

#define MASK_Y_LAST_ROW

Definition: rv40.c:294

SliceInfo::pts

int pts

frame timestamp

Definition: rv34.h:83

btype_vlc_tabs

static const uint8_t btype_vlc_tabs[NUM_BTYPE_VLCS][BTYPE_VLC_SIZE][2]

Definition: rv40vlc2.h:600

skip_bits1

static void skip_bits1(GetBitContext *s)

Definition: get_bits.h:411

AIC_MODE1_NUM

#define AIC_MODE1_NUM

Codes used for determining block type.

Definition: rv40vlc2.h:384

NUM_PTYPE_VLCS

#define NUM_PTYPE_VLCS

tables used for P-frame macroblock type decoding

Definition: rv40vlc2.h:568

#define Y

Definition: boxblur.h:37

get_dimension

static int get_dimension(GetBitContext *gb, const int *dim)

Get stored dimension from bitstream.

Definition: rv40.c:106

RV34DSPContext::rv40_strong_loop_filter

rv40_strong_loop_filter_func rv40_strong_loop_filter[2]

Definition: rv34dsp.h:73

SliceInfo::height

int height

coded height

Definition: rv34.h:82

rv40_filter_clip_tbl

static const uint8_t rv40_filter_clip_tbl[3][32]

clip table for RV40 loop filter - the same as in JVT-A003r1

Definition: rv40data.h:85

AV_CODEC_ID_RV40

@ AV_CODEC_ID_RV40

Definition: codec_id.h:121

POS_LEFT

@ POS_LEFT

Definition: rv40.c:285

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

rv40_beta_tab

static const uint8_t rv40_beta_tab[32]

beta parameter for RV40 loop filter - almost the same as in JVT-A003r1

Definition: rv40data.h:80

aic_mode2_vlc

static const VLCElem * aic_mode2_vlc[AIC_MODE2_NUM]

Definition: rv40.c:44

RV34_MB_TYPES

@ RV34_MB_TYPES

Definition: rv34.h:58

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:179

SliceInfo

essential slice information

Definition: rv34.h:76

avcodec.h

stride

#define stride

Definition: h264pred_template.c:536

MASK_TOP

#define MASK_TOP

Definition: rv40.c:292

MASK_RIGHT

#define MASK_RIGHT

Definition: rv40.c:290

dim

int dim

Definition: vorbis_enc_data.h:425

POS_BOTTOM

@ POS_BOTTOM

Definition: rv40.c:286

state

static struct @531 state

ret

Definition: filter_design.txt:187

pos

unsigned int pos

Definition: spdifenc.c:414

AIC_TOP_SIZE

#define AIC_TOP_SIZE

Definition: rv40vlc2.h:37

block_num_to_btype_vlc_num

static const uint8_t block_num_to_btype_vlc_num[12]

Definition: rv40vlc2.h:615

neighbour_offs_y

static const int neighbour_offs_y[4]

Definition: rv40.c:303

AVCodecContext

main external API structure.

Definition: avcodec.h:431

SliceInfo::start

int start

Definition: rv34.h:80

RV34DSPContext::rv40_weak_loop_filter

rv40_weak_loop_filter_func rv40_weak_loop_filter[2]

Definition: rv34dsp.h:72

IS_SEPARATE_DC

#define IS_SEPARATE_DC(a)

Definition: rv34.h:40

rv40vlc2.h

aic_top_vlc

static VLCElem aic_top_vlc[23590]

Definition: rv40.c:43

AV_CODEC_CAP_DELAY

#define AV_CODEC_CAP_DELAY

Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...

Definition: codec.h:76

ff_vlc_init_tables_from_lengths

const av_cold VLCElem * ff_vlc_init_tables_from_lengths(VLCInitState *state, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags)

Definition: vlc.c:366

AV_PICTURE_TYPE_P

@ AV_PICTURE_TYPE_P

Predicted.

Definition: avutil.h:279

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:200

rv40_luma_dc_quant

static const uint8_t rv40_luma_dc_quant[2][32]

luma quantizer values The second table is used for inter blocks.

Definition: rv40data.h:60