FFmpeg
rv40.c
Go to the documentation of this file.
1 /*
2  * RV40 decoder
3  * Copyright (c) 2007 Konstantin Shishkov
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  */
21 
22 /**
23  * @file
24  * RV40 decoder
25  */
26 
27 #include "config.h"
28 
29 #include "libavutil/imgutils.h"
30 
31 #include "avcodec.h"
32 #include "mpegutils.h"
33 #include "mpegvideo.h"
34 #include "golomb.h"
35 
36 #include "rv34.h"
37 #include "rv40vlc2.h"
38 #include "rv40data.h"
39 
43 
44 static av_cold void rv40_init_table(VLC *vlc, unsigned *offset, int nb_bits,
45  int nb_codes, const uint8_t (*tab)[2])
46 {
47  static VLC_TYPE vlc_buf[11776][2];
48 
49  vlc->table = &vlc_buf[*offset];
50  vlc->table_allocated = 1 << nb_bits;
51  *offset += 1 << nb_bits;
52 
53  ff_init_vlc_from_lengths(vlc, nb_bits, nb_codes,
54  &tab[0][1], 2, &tab[0][0], 2, 1,
56 }
57 
58 /**
59  * Initialize all tables.
60  */
61 static av_cold void rv40_init_tables(void)
62 {
63  int i, offset = 0;
64  static VLC_TYPE aic_mode2_table[11814][2];
65 
66  rv40_init_table(&aic_top_vlc, &offset, AIC_TOP_BITS, AIC_TOP_SIZE,
68  for(i = 0; i < AIC_MODE1_NUM; i++){
69  // Every tenth VLC table is empty
70  if((i % 10) == 9) continue;
71  rv40_init_table(&aic_mode1_vlc[i], &offset, AIC_MODE1_BITS,
73  }
74  for (unsigned i = 0, offset = 0; i < AIC_MODE2_NUM; i++){
75  uint16_t syms[AIC_MODE2_SIZE];
76 
77  for (int j = 0; j < AIC_MODE2_SIZE; j++) {
78  int first = aic_mode2_vlc_syms[i][j] >> 4;
79  int second = aic_mode2_vlc_syms[i][j] & 0xF;
80  if (HAVE_BIGENDIAN)
81  syms[j] = (first << 8) | second;
82  else
83  syms[j] = first | (second << 8);
84  }
85  aic_mode2_vlc[i].table = &aic_mode2_table[offset];
86  aic_mode2_vlc[i].table_allocated = FF_ARRAY_ELEMS(aic_mode2_table) - offset;
87  ff_init_vlc_from_lengths(&aic_mode2_vlc[i], AIC_MODE2_BITS, AIC_MODE2_SIZE,
88  aic_mode2_vlc_bits[i], 1,
89  syms, 2, 2, 0, INIT_VLC_STATIC_OVERLONG, NULL);
90  offset += aic_mode2_vlc[i].table_size;
91  }
92  for(i = 0; i < NUM_PTYPE_VLCS; i++){
93  rv40_init_table(&ptype_vlc[i], &offset, PTYPE_VLC_BITS, PTYPE_VLC_SIZE,
94  ptype_vlc_tabs[i]);
95  }
96  for(i = 0; i < NUM_BTYPE_VLCS; i++){
97  rv40_init_table(&btype_vlc[i], &offset, BTYPE_VLC_BITS, BTYPE_VLC_SIZE,
98  btype_vlc_tabs[i]);
99  }
100 }
101 
102 /**
103  * Get stored dimension from bitstream.
104  *
105  * If the width/height is the standard one then it's coded as a 3-bit index.
106  * Otherwise it is coded as escaped 8-bit portions.
107  */
108 static int get_dimension(GetBitContext *gb, const int *dim)
109 {
110  int t = get_bits(gb, 3);
111  int val = dim[t];
112  if(val < 0)
113  val = dim[get_bits1(gb) - val];
114  if(!val){
115  do{
116  if (get_bits_left(gb) < 8)
117  return AVERROR_INVALIDDATA;
118  t = get_bits(gb, 8);
119  val += t << 2;
120  }while(t == 0xFF);
121  }
122  return val;
123 }
124 
125 /**
126  * Get encoded picture size - usually this is called from rv40_parse_slice_header.
127  */
128 static void rv40_parse_picture_size(GetBitContext *gb, int *w, int *h)
129 {
132 }
133 
135 {
136  int mb_bits;
137  int w = r->s.width, h = r->s.height;
138  int mb_size;
139  int ret;
140 
141  memset(si, 0, sizeof(SliceInfo));
142  if(get_bits1(gb))
143  return AVERROR_INVALIDDATA;
144  si->type = get_bits(gb, 2);
145  if(si->type == 1) si->type = 0;
146  si->quant = get_bits(gb, 5);
147  if(get_bits(gb, 2))
148  return AVERROR_INVALIDDATA;
149  si->vlc_set = get_bits(gb, 2);
150  skip_bits1(gb);
151  si->pts = get_bits(gb, 13);
152  if(!si->type || !get_bits1(gb))
153  rv40_parse_picture_size(gb, &w, &h);
154  if ((ret = av_image_check_size(w, h, 0, r->s.avctx)) < 0)
155  return ret;
156  si->width = w;
157  si->height = h;
158  mb_size = ((w + 15) >> 4) * ((h + 15) >> 4);
159  mb_bits = ff_rv34_get_start_offset(gb, mb_size);
160  si->start = get_bits(gb, mb_bits);
161 
162  return 0;
163 }
164 
165 /**
166  * Decode 4x4 intra types array.
167  */
169 {
170  MpegEncContext *s = &r->s;
171  int i, j, k, v;
172  int A, B, C;
173  int pattern;
174  int8_t *ptr;
175 
176  for(i = 0; i < 4; i++, dst += r->intra_types_stride){
177  if(!i && s->first_slice_line){
178  pattern = get_vlc2(gb, aic_top_vlc.table, AIC_TOP_BITS, 1);
179  dst[0] = (pattern >> 2) & 2;
180  dst[1] = (pattern >> 1) & 2;
181  dst[2] = pattern & 2;
182  dst[3] = (pattern << 1) & 2;
183  continue;
184  }
185  ptr = dst;
186  for(j = 0; j < 4; j++){
187  /* Coefficients are read using VLC chosen by the prediction pattern
188  * The first one (used for retrieving a pair of coefficients) is
189  * constructed from the top, top right and left coefficients
190  * The second one (used for retrieving only one coefficient) is
191  * top + 10 * left.
192  */
193  A = ptr[-r->intra_types_stride + 1]; // it won't be used for the last coefficient in a row
194  B = ptr[-r->intra_types_stride];
195  C = ptr[-1];
196  pattern = A + B * (1 << 4) + C * (1 << 8);
197  for(k = 0; k < MODE2_PATTERNS_NUM; k++)
198  if(pattern == rv40_aic_table_index[k])
199  break;
200  if(j < 3 && k < MODE2_PATTERNS_NUM){ //pattern is found, decoding 2 coefficients
201  AV_WN16(ptr, get_vlc2(gb, aic_mode2_vlc[k].table, AIC_MODE2_BITS, 2));
202  ptr += 2;
203  j++;
204  }else{
205  if(B != -1 && C != -1)
206  v = get_vlc2(gb, aic_mode1_vlc[B + C*10].table, AIC_MODE1_BITS, 1);
207  else{ // tricky decoding
208  v = 0;
209  switch(C){
210  case -1: // code 0 -> 1, 1 -> 0
211  if(B < 2)
212  v = get_bits1(gb) ^ 1;
213  break;
214  case 0:
215  case 2: // code 0 -> 2, 1 -> 0
216  v = (get_bits1(gb) ^ 1) << 1;
217  break;
218  }
219  }
220  *ptr++ = v;
221  }
222  }
223  }
224  return 0;
225 }
226 
227 /**
228  * Decode macroblock information.
229  */
231 {
232  MpegEncContext *s = &r->s;
233  GetBitContext *gb = &s->gb;
234  int q, i;
235  int prev_type = 0;
236  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
237 
238  if(!r->s.mb_skip_run) {
240  if(r->s.mb_skip_run > (unsigned)s->mb_num)
241  return -1;
242  }
243 
244  if(--r->s.mb_skip_run)
245  return RV34_MB_SKIP;
246 
247  if(r->avail_cache[6-4]){
248  int blocks[RV34_MB_TYPES] = {0};
249  int count = 0;
250  if(r->avail_cache[6-1])
251  blocks[r->mb_type[mb_pos - 1]]++;
252  blocks[r->mb_type[mb_pos - s->mb_stride]]++;
253  if(r->avail_cache[6-2])
254  blocks[r->mb_type[mb_pos - s->mb_stride + 1]]++;
255  if(r->avail_cache[6-5])
256  blocks[r->mb_type[mb_pos - s->mb_stride - 1]]++;
257  for(i = 0; i < RV34_MB_TYPES; i++){
258  if(blocks[i] > count){
259  count = blocks[i];
260  prev_type = i;
261  if(count>1)
262  break;
263  }
264  }
265  } else if (r->avail_cache[6-1])
266  prev_type = r->mb_type[mb_pos - 1];
267 
268  if(s->pict_type == AV_PICTURE_TYPE_P){
269  prev_type = block_num_to_ptype_vlc_num[prev_type];
270  q = get_vlc2(gb, ptype_vlc[prev_type].table, PTYPE_VLC_BITS, 1);
271  if(q < PBTYPE_ESCAPE)
272  return q;
273  q = get_vlc2(gb, ptype_vlc[prev_type].table, PTYPE_VLC_BITS, 1);
274  av_log(s->avctx, AV_LOG_ERROR, "Dquant for P-frame\n");
275  }else{
276  prev_type = block_num_to_btype_vlc_num[prev_type];
277  q = get_vlc2(gb, btype_vlc[prev_type].table, BTYPE_VLC_BITS, 1);
278  if(q < PBTYPE_ESCAPE)
279  return q;
280  q = get_vlc2(gb, btype_vlc[prev_type].table, BTYPE_VLC_BITS, 1);
281  av_log(s->avctx, AV_LOG_ERROR, "Dquant for B-frame\n");
282  }
283  return 0;
284 }
285 
291 };
292 
293 #define MASK_CUR 0x0001
294 #define MASK_RIGHT 0x0008
295 #define MASK_BOTTOM 0x0010
296 #define MASK_TOP 0x1000
297 #define MASK_Y_TOP_ROW 0x000F
298 #define MASK_Y_LAST_ROW 0xF000
299 #define MASK_Y_LEFT_COL 0x1111
300 #define MASK_Y_RIGHT_COL 0x8888
301 #define MASK_C_TOP_ROW 0x0003
302 #define MASK_C_LAST_ROW 0x000C
303 #define MASK_C_LEFT_COL 0x0005
304 #define MASK_C_RIGHT_COL 0x000A
305 
306 static const int neighbour_offs_x[4] = { 0, 0, -1, 0 };
307 static const int neighbour_offs_y[4] = { 0, -1, 0, 1 };
308 
310  uint8_t *src, int stride, int dmode,
311  int lim_q1, int lim_p1,
312  int alpha, int beta, int beta2,
313  int chroma, int edge, int dir)
314 {
315  int filter_p1, filter_q1;
316  int strong;
317  int lims;
318 
319  strong = rdsp->rv40_loop_filter_strength[dir](src, stride, beta, beta2,
320  edge, &filter_p1, &filter_q1);
321 
322  lims = filter_p1 + filter_q1 + ((lim_q1 + lim_p1) >> 1) + 1;
323 
324  if (strong) {
326  lims, dmode, chroma);
327  } else if (filter_p1 & filter_q1) {
328  rdsp->rv40_weak_loop_filter[dir](src, stride, 1, 1, alpha, beta,
329  lims, lim_q1, lim_p1);
330  } else if (filter_p1 | filter_q1) {
331  rdsp->rv40_weak_loop_filter[dir](src, stride, filter_p1, filter_q1,
332  alpha, beta, lims >> 1, lim_q1 >> 1,
333  lim_p1 >> 1);
334  }
335 }
336 
337 /**
338  * RV40 loop filtering function
339  */
340 static void rv40_loop_filter(RV34DecContext *r, int row)
341 {
342  MpegEncContext *s = &r->s;
343  int mb_pos, mb_x;
344  int i, j, k;
345  uint8_t *Y, *C;
346  int alpha, beta, betaY, betaC;
347  int q;
348  int mbtype[4]; ///< current macroblock and its neighbours types
349  /**
350  * flags indicating that macroblock can be filtered with strong filter
351  * it is set only for intra coded MB and MB with DCs coded separately
352  */
353  int mb_strong[4];
354  int clip[4]; ///< MB filter clipping value calculated from filtering strength
355  /**
356  * coded block patterns for luma part of current macroblock and its neighbours
357  * Format:
358  * LSB corresponds to the top left block,
359  * each nibble represents one row of subblocks.
360  */
361  int cbp[4];
362  /**
363  * coded block patterns for chroma part of current macroblock and its neighbours
364  * Format is the same as for luma with two subblocks in a row.
365  */
366  int uvcbp[4][2];
367  /**
368  * This mask represents the pattern of luma subblocks that should be filtered
369  * in addition to the coded ones because they lie at the edge of
370  * 8x8 block with different enough motion vectors
371  */
372  unsigned mvmasks[4];
373 
374  mb_pos = row * s->mb_stride;
375  for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){
376  int mbtype = s->current_picture_ptr->mb_type[mb_pos];
377  if(IS_INTRA(mbtype) || IS_SEPARATE_DC(mbtype))
378  r->cbp_luma [mb_pos] = r->deblock_coefs[mb_pos] = 0xFFFF;
379  if(IS_INTRA(mbtype))
380  r->cbp_chroma[mb_pos] = 0xFF;
381  }
382  mb_pos = row * s->mb_stride;
383  for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){
384  int y_h_deblock, y_v_deblock;
385  int c_v_deblock[2], c_h_deblock[2];
386  int clip_left;
387  int avail[4];
388  unsigned y_to_deblock;
389  int c_to_deblock[2];
390 
391  q = s->current_picture_ptr->qscale_table[mb_pos];
392  alpha = rv40_alpha_tab[q];
393  beta = rv40_beta_tab [q];
394  betaY = betaC = beta * 3;
395  if(s->width * s->height <= 176*144)
396  betaY += beta;
397 
398  avail[0] = 1;
399  avail[1] = row;
400  avail[2] = mb_x;
401  avail[3] = row < s->mb_height - 1;
402  for(i = 0; i < 4; i++){
403  if(avail[i]){
404  int pos = mb_pos + neighbour_offs_x[i] + neighbour_offs_y[i]*s->mb_stride;
405  mvmasks[i] = r->deblock_coefs[pos];
406  mbtype [i] = s->current_picture_ptr->mb_type[pos];
407  cbp [i] = r->cbp_luma[pos];
408  uvcbp[i][0] = r->cbp_chroma[pos] & 0xF;
409  uvcbp[i][1] = r->cbp_chroma[pos] >> 4;
410  }else{
411  mvmasks[i] = 0;
412  mbtype [i] = mbtype[0];
413  cbp [i] = 0;
414  uvcbp[i][0] = uvcbp[i][1] = 0;
415  }
416  mb_strong[i] = IS_INTRA(mbtype[i]) || IS_SEPARATE_DC(mbtype[i]);
417  clip[i] = rv40_filter_clip_tbl[mb_strong[i] + 1][q];
418  }
419  y_to_deblock = mvmasks[POS_CUR]
420  | (mvmasks[POS_BOTTOM] << 16);
421  /* This pattern contains bits signalling that horizontal edges of
422  * the current block can be filtered.
423  * That happens when either of adjacent subblocks is coded or lies on
424  * the edge of 8x8 blocks with motion vectors differing by more than
425  * 3/4 pel in any component (any edge orientation for some reason).
426  */
427  y_h_deblock = y_to_deblock
428  | ((cbp[POS_CUR] << 4) & ~MASK_Y_TOP_ROW)
429  | ((cbp[POS_TOP] & MASK_Y_LAST_ROW) >> 12);
430  /* This pattern contains bits signalling that vertical edges of
431  * the current block can be filtered.
432  * That happens when either of adjacent subblocks is coded or lies on
433  * the edge of 8x8 blocks with motion vectors differing by more than
434  * 3/4 pel in any component (any edge orientation for some reason).
435  */
436  y_v_deblock = y_to_deblock
437  | ((cbp[POS_CUR] << 1) & ~MASK_Y_LEFT_COL)
438  | ((cbp[POS_LEFT] & MASK_Y_RIGHT_COL) >> 3);
439  if(!mb_x)
440  y_v_deblock &= ~MASK_Y_LEFT_COL;
441  if(!row)
442  y_h_deblock &= ~MASK_Y_TOP_ROW;
443  if(row == s->mb_height - 1 || (mb_strong[POS_CUR] | mb_strong[POS_BOTTOM]))
444  y_h_deblock &= ~(MASK_Y_TOP_ROW << 16);
445  /* Calculating chroma patterns is similar and easier since there is
446  * no motion vector pattern for them.
447  */
448  for(i = 0; i < 2; i++){
449  c_to_deblock[i] = (uvcbp[POS_BOTTOM][i] << 4) | uvcbp[POS_CUR][i];
450  c_v_deblock[i] = c_to_deblock[i]
451  | ((uvcbp[POS_CUR] [i] << 1) & ~MASK_C_LEFT_COL)
452  | ((uvcbp[POS_LEFT][i] & MASK_C_RIGHT_COL) >> 1);
453  c_h_deblock[i] = c_to_deblock[i]
454  | ((uvcbp[POS_TOP][i] & MASK_C_LAST_ROW) >> 2)
455  | (uvcbp[POS_CUR][i] << 2);
456  if(!mb_x)
457  c_v_deblock[i] &= ~MASK_C_LEFT_COL;
458  if(!row)
459  c_h_deblock[i] &= ~MASK_C_TOP_ROW;
460  if(row == s->mb_height - 1 || (mb_strong[POS_CUR] | mb_strong[POS_BOTTOM]))
461  c_h_deblock[i] &= ~(MASK_C_TOP_ROW << 4);
462  }
463 
464  for(j = 0; j < 16; j += 4){
465  Y = s->current_picture_ptr->f->data[0] + mb_x*16 + (row*16 + j) * s->linesize;
466  for(i = 0; i < 4; i++, Y += 4){
467  int ij = i + j;
468  int clip_cur = y_to_deblock & (MASK_CUR << ij) ? clip[POS_CUR] : 0;
469  int dither = j ? ij : i*4;
470 
471  // if bottom block is coded then we can filter its top edge
472  // (or bottom edge of this block, which is the same)
473  if(y_h_deblock & (MASK_BOTTOM << ij)){
475  s->linesize, dither,
476  y_to_deblock & (MASK_BOTTOM << ij) ? clip[POS_CUR] : 0,
477  clip_cur, alpha, beta, betaY,
478  0, 0, 0);
479  }
480  // filter left block edge in ordinary mode (with low filtering strength)
481  if(y_v_deblock & (MASK_CUR << ij) && (i || !(mb_strong[POS_CUR] | mb_strong[POS_LEFT]))){
482  if(!i)
483  clip_left = mvmasks[POS_LEFT] & (MASK_RIGHT << j) ? clip[POS_LEFT] : 0;
484  else
485  clip_left = y_to_deblock & (MASK_CUR << (ij-1)) ? clip[POS_CUR] : 0;
486  rv40_adaptive_loop_filter(&r->rdsp, Y, s->linesize, dither,
487  clip_cur,
488  clip_left,
489  alpha, beta, betaY, 0, 0, 1);
490  }
491  // filter top edge of the current macroblock when filtering strength is high
492  if(!j && y_h_deblock & (MASK_CUR << i) && (mb_strong[POS_CUR] | mb_strong[POS_TOP])){
493  rv40_adaptive_loop_filter(&r->rdsp, Y, s->linesize, dither,
494  clip_cur,
495  mvmasks[POS_TOP] & (MASK_TOP << i) ? clip[POS_TOP] : 0,
496  alpha, beta, betaY, 0, 1, 0);
497  }
498  // filter left block edge in edge mode (with high filtering strength)
499  if(y_v_deblock & (MASK_CUR << ij) && !i && (mb_strong[POS_CUR] | mb_strong[POS_LEFT])){
500  clip_left = mvmasks[POS_LEFT] & (MASK_RIGHT << j) ? clip[POS_LEFT] : 0;
501  rv40_adaptive_loop_filter(&r->rdsp, Y, s->linesize, dither,
502  clip_cur,
503  clip_left,
504  alpha, beta, betaY, 0, 1, 1);
505  }
506  }
507  }
508  for(k = 0; k < 2; k++){
509  for(j = 0; j < 2; j++){
510  C = s->current_picture_ptr->f->data[k + 1] + mb_x*8 + (row*8 + j*4) * s->uvlinesize;
511  for(i = 0; i < 2; i++, C += 4){
512  int ij = i + j*2;
513  int clip_cur = c_to_deblock[k] & (MASK_CUR << ij) ? clip[POS_CUR] : 0;
514  if(c_h_deblock[k] & (MASK_CUR << (ij+2))){
515  int clip_bot = c_to_deblock[k] & (MASK_CUR << (ij+2)) ? clip[POS_CUR] : 0;
517  clip_bot,
518  clip_cur,
519  alpha, beta, betaC, 1, 0, 0);
520  }
521  if((c_v_deblock[k] & (MASK_CUR << ij)) && (i || !(mb_strong[POS_CUR] | mb_strong[POS_LEFT]))){
522  if(!i)
523  clip_left = uvcbp[POS_LEFT][k] & (MASK_CUR << (2*j+1)) ? clip[POS_LEFT] : 0;
524  else
525  clip_left = c_to_deblock[k] & (MASK_CUR << (ij-1)) ? clip[POS_CUR] : 0;
526  rv40_adaptive_loop_filter(&r->rdsp, C, s->uvlinesize, j*8,
527  clip_cur,
528  clip_left,
529  alpha, beta, betaC, 1, 0, 1);
530  }
531  if(!j && c_h_deblock[k] & (MASK_CUR << ij) && (mb_strong[POS_CUR] | mb_strong[POS_TOP])){
532  int clip_top = uvcbp[POS_TOP][k] & (MASK_CUR << (ij+2)) ? clip[POS_TOP] : 0;
533  rv40_adaptive_loop_filter(&r->rdsp, C, s->uvlinesize, i*8,
534  clip_cur,
535  clip_top,
536  alpha, beta, betaC, 1, 1, 0);
537  }
538  if(c_v_deblock[k] & (MASK_CUR << ij) && !i && (mb_strong[POS_CUR] | mb_strong[POS_LEFT])){
539  clip_left = uvcbp[POS_LEFT][k] & (MASK_CUR << (2*j+1)) ? clip[POS_LEFT] : 0;
540  rv40_adaptive_loop_filter(&r->rdsp, C, s->uvlinesize, j*8,
541  clip_cur,
542  clip_left,
543  alpha, beta, betaC, 1, 1, 1);
544  }
545  }
546  }
547  }
548  }
549 }
550 
551 /**
552  * Initialize decoder.
553  */
555 {
556  RV34DecContext *r = avctx->priv_data;
557  int ret;
558 
559  r->rv30 = 0;
560  if ((ret = ff_rv34_decode_init(avctx)) < 0)
561  return ret;
562  if(!aic_top_vlc.bits)
570  return 0;
571 }
572 
574  .name = "rv40",
575  .long_name = NULL_IF_CONFIG_SMALL("RealVideo 4.0"),
576  .type = AVMEDIA_TYPE_VIDEO,
577  .id = AV_CODEC_ID_RV40,
578  .priv_data_size = sizeof(RV34DecContext),
580  .close = ff_rv34_decode_end,
582  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
584  .flush = ff_mpeg_flush,
585  .pix_fmts = (const enum AVPixelFormat[]) {
588  },
590  .caps_internal = FF_CODEC_CAP_ALLOCATE_PROGRESS,
591 };
#define NULL
Definition: coverity.c:32
int vlc_set
VLCs used for this slice.
Definition: rv34.h:78
int table_size
Definition: vlc.h:29
#define PBTYPE_ESCAPE
Definition: rv40vlc2.h:564
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static av_cold void rv40_init_tables(void)
Initialize all tables.
Definition: rv40.c:61
AVCodec ff_rv40_decoder
Definition: rv40.c:573
static void flush(AVCodecContext *avctx)
#define PTYPE_VLC_BITS
Definition: rv40vlc2.h:570
uint32_t avail_cache[3 *4]
8x8 block available flags (for MV prediction)
Definition: rv34.h:121
#define MASK_CUR
Definition: rv40.c:293
#define IS_SEPARATE_DC(a)
Definition: rv34.h:39
misc image utilities
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
rv40_loop_filter_strength_func rv40_loop_filter_strength[2]
Definition: rv34dsp.h:74
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
MpegEncContext s
Definition: rv34.h:87
#define PTYPE_VLC_SIZE
Definition: rv40vlc2.h:569
int height
coded height
Definition: rv34.h:81
#define BTYPE_VLC_SIZE
Definition: rv40vlc2.h:597
#define AIC_MODE1_SIZE
Definition: rv40vlc2.h:385
#define BTYPE_VLC_BITS
Definition: rv40vlc2.h:598
mpegvideo header.
static const uint8_t btype_vlc_tabs[NUM_BTYPE_VLCS][BTYPE_VLC_SIZE][2]
Definition: rv40vlc2.h:600
#define MODE2_PATTERNS_NUM
Definition: rv40data.h:40
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:128
RV30 and RV40 decoder common data declarations.
int mb_num
number of MBs of a picture
Definition: mpegvideo.h:133
int start
Definition: rv34.h:79
AVCodec.
Definition: codec.h:190
const uint8_t * luma_dc_quant_p
luma subblock DC quantizer for interframes
Definition: rv34.h:93
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
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
static const int neighbour_offs_x[4]
Definition: rv40.c:306
static VLC btype_vlc[NUM_BTYPE_VLCS]
Definition: rv40.c:42
static const uint8_t block_num_to_ptype_vlc_num[12]
Definition: rv40vlc2.h:589
#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:75
uint8_t
#define av_cold
Definition: attributes.h:88
uint16_t * cbp_luma
CBP values for luma subblocks.
Definition: rv34.h:116
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
int width
coded width
Definition: rv34.h:80
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first
#define MASK_C_RIGHT_COL
Definition: rv40.c:304
rv40_weak_loop_filter_func rv40_weak_loop_filter[2]
Definition: rv34dsp.h:72
uint16_t * deblock_coefs
deblock coefficients for each macroblock
Definition: rv34.h:118
static const int rv40_standard_heights[]
Definition: rv40data.h:37
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
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:309
Skipped block.
Definition: rv34.h:51
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:129
#define MASK_Y_LAST_ROW
Definition: rv40.c:298
#define A(x)
Definition: vp56_arith.h:28
#define av_log(a,...)
static const uint8_t aic_mode2_vlc_syms[AIC_MODE2_NUM][AIC_MODE2_SIZE]
Definition: rv40vlc2.h:53
static const uint16_t table[]
Definition: prosumer.c:206
#define FF_CODEC_CAP_ALLOCATE_PROGRESS
Definition: internal.h:75
static VLC aic_mode2_vlc[AIC_MODE2_NUM]
Definition: rv40.c:41
#define src
Definition: vp8dsp.c:255
int quant
quantizer used for this slice
Definition: rv34.h:77
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
static const uint8_t block_num_to_btype_vlc_num[12]
Definition: rv40vlc2.h:615
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:1631
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
#define B
Definition: huffyuvdsp.h:32
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:115
const char * r
Definition: vf_curves.c:114
static const uint8_t dither[8][8]
Definition: vf_fspp.c:59
unsigned int pos
Definition: spdifenc.c:410
static int rv40_decode_mb_info(RV34DecContext *r)
Decode macroblock information.
Definition: rv40.c:230
#define MASK_Y_TOP_ROW
Definition: rv40.c:297
const char * name
Name of the codec implementation.
Definition: codec.h:197
GetBitContext gb
Definition: mpegvideo.h:451
GLsizei count
Definition: opengl_enc.c:108
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:106
#define MASK_BOTTOM
Definition: rv40.c:295
Definition: vlc.h:26
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo.c:2305
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:154
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:317
int(* parse_slice_header)(struct RV34DecContext *r, GetBitContext *gb, SliceInfo *si)
Definition: rv34.h:128
#define MASK_RIGHT
Definition: rv40.c:294
#define Y
Definition: boxblur.h:38
static VLC ptype_vlc[NUM_PTYPE_VLCS]
Definition: rv40.c:42
int * mb_type
internal macroblock types
Definition: rv34.h:99
#define MASK_C_LEFT_COL
Definition: rv40.c:303
uint8_t w
Definition: llviddspenc.c:39
static int rv40_parse_slice_header(RV34DecContext *r, GetBitContext *gb, SliceInfo *si)
Definition: rv40.c:134
#define AIC_MODE2_NUM
codes used for determining a pair of block types
Definition: rv40vlc2.h:49
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:184
static av_cold int rv40_decode_init(AVCodecContext *avctx)
Initialize decoder.
Definition: rv40.c:554
static const uint16_t rv40_aic_table_index[MODE2_PATTERNS_NUM]
intra types table
Definition: rv40data.h:47
#define s(width, name)
Definition: cbs_vp9.c:257
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:797
#define AIC_MODE1_BITS
Definition: rv40vlc2.h:386
static VLC aic_mode1_vlc[AIC_MODE1_NUM]
Definition: rv40.c:41
Definition: rv40.c:288
#define MASK_Y_LEFT_COL
Definition: rv40.c:299
#define FF_ARRAY_ELEMS(a)
#define MASK_TOP
Definition: rv40.c:296
int bits
Definition: vlc.h:27
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
int table_allocated
Definition: vlc.h:29
int(* decode_mb_info)(struct RV34DecContext *r)
Definition: rv34.h:129
int first_slice_line
used in MPEG-4 too to handle resync markers
Definition: mpegvideo.h:436
essential slice information
Definition: rv34.h:75
Libavcodec external API header.
static const uint8_t aic_mode1_vlc_tabs[AIC_MODE1_NUM][AIC_MODE1_SIZE][2]
Definition: rv40vlc2.h:388
ptrdiff_t linesize
line size, in bytes, may be different from width
Definition: mpegvideo.h:134
#define MASK_C_TOP_ROW
Definition: rv40.c:301
static const int16_t alpha[]
Definition: ilbcdata.h:55
main external API structure.
Definition: avcodec.h:531
static const uint8_t ptype_vlc_tabs[NUM_PTYPE_VLCS][PTYPE_VLC_SIZE][2]
Definition: rv40vlc2.h:572
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:100
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
static const uint8_t rv40_aic_top_vlc_tab[AIC_TOP_SIZE][2]
Definition: rv40vlc2.h:38
struct AVFrame * f
Definition: mpegpicture.h:46
int ff_init_vlc_from_lengths(VLC *vlc_arg, 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, void *logctx)
Build VLC decoding tables suitable for use with get_vlc2()
Definition: bitstream.c:381
#define MASK_C_LAST_ROW
Definition: rv40.c:302
av_cold int ff_rv34_decode_init(AVCodecContext *avctx)
Initialize decoder.
Definition: rv34.c:1485
ptrdiff_t uvlinesize
line size, for chroma in bytes, may be different from width
Definition: mpegvideo.h:135
int dim
int ff_rv34_decode_frame(AVCodecContext *avctx, void *data, int *got_picture_ptr, AVPacket *avpkt)
Definition: rv34.c:1605
int intra_types_stride
block types array stride
Definition: rv34.h:91
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:212
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:303
int(* decode_intra_types)(struct RV34DecContext *r, GetBitContext *gb, int8_t *dst)
Definition: rv34.h:130
static const int rv40_standard_widths[]
standard widths and heights coded in RV40
Definition: rv40data.h:36
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:328
static VLC aic_top_vlc
Definition: rv40.c:40
MpegEncContext.
Definition: mpegvideo.h:81
#define AIC_TOP_SIZE
Definition: rv40vlc2.h:37
av_cold int ff_rv34_decode_end(AVCodecContext *avctx)
Definition: rv34.c:1811
int8_t * qscale_table
Definition: mpegpicture.h:50
struct AVCodecContext * avctx
Definition: mpegvideo.h:98
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
#define MASK_Y_RIGHT_COL
Definition: rv40.c:300
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
static int get_dimension(GetBitContext *gb, const int *dim)
Get stored dimension from bitstream.
Definition: rv40.c:108
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
Definition: mpegvideo.h:130
static double clip(void *opaque, double val)
Clip value val in the minval - maxval range.
Definition: vf_lut.c:162
Definition: rv40.c:287
static av_cold void rv40_init_table(VLC *vlc, unsigned *offset, int nb_bits, int nb_codes, const uint8_t(*tab)[2])
Definition: rv40.c:44
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:95
rv40_strong_loop_filter_func rv40_strong_loop_filter[2]
Definition: rv34dsp.h:73
int ff_rv34_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: rv34.c:1524
#define AIC_TOP_BITS
codes used for the first four block types
Definition: rv40vlc2.h:36
#define AIC_MODE2_SIZE
Definition: rv40vlc2.h:50
Definition: rv40.c:289
int ff_rv34_get_start_offset(GetBitContext *gb, int mb_size)
Decode starting slice position.
Definition: rv34.c:322
#define IS_INTRA(x, y)
decoder context
Definition: rv34.h:86
void * priv_data
Definition: avcodec.h:558
#define NUM_BTYPE_VLCS
tables used for P-frame macroblock type decoding
Definition: rv40vlc2.h:596
RV40BlockPos
Definition: rv40.c:286
RV40 VLC tables used for macroblock information decoding.
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
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
#define AIC_MODE1_NUM
Codes used for determining block type.
Definition: rv40vlc2.h:384
static const struct twinvq_data tab
const uint8_t * luma_dc_quant_i
luma subblock DC quantizer for intraframes
Definition: rv34.h:92
static VLC_TYPE vlc_buf[16716][2]
Definition: clearvideo.c:86
static int rv40_decode_intra_types(RV34DecContext *r, GetBitContext *gb, int8_t *dst)
Decode 4x4 intra types array.
Definition: rv40.c:168
#define NUM_PTYPE_VLCS
tables used for P-frame macroblock type decoding
Definition: rv40vlc2.h:568
uint32_t * mb_type
types and macros are defined in mpegutils.h
Definition: mpegpicture.h:56
int type
slice type (intra, inter)
Definition: rv34.h:76
#define AIC_MODE2_BITS
Definition: rv40vlc2.h:51
#define AV_WN16(p, v)
Definition: intreadwrite.h:372
#define VLC_TYPE
Definition: vlc.h:24
static unsigned get_interleaved_ue_golomb(GetBitContext *gb)
Definition: golomb.h:145
miscellaneous RV40 tables
#define stride
static const int neighbour_offs_y[4]
Definition: rv40.c:307
int rv30
indicates which RV variant is currently decoded
Definition: rv34.h:106
exp golomb vlc stuff
#define INIT_VLC_STATIC_OVERLONG
Definition: vlc.h:96
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
static double val(void *priv, double ch)
Definition: aeval.c:76
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
void(* loop_filter)(struct RV34DecContext *r, int row)
Definition: rv34.h:131
RV34DSPContext rdsp
Definition: rv34.h:88
static void rv40_loop_filter(RV34DecContext *r, int row)
RV40 loop filtering function.
Definition: rv40.c:340
int i
Definition: input.c:407
static const uint8_t aic_mode2_vlc_bits[AIC_MODE2_NUM][AIC_MODE2_SIZE]
Definition: rv40vlc2.h:236
Predicted.
Definition: avutil.h:275
int pts
frame timestamp
Definition: rv34.h:82
uint8_t * cbp_chroma
CBP values for chroma subblocks.
Definition: rv34.h:117