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 "libavutil/imgutils.h"
28 
29 #include "avcodec.h"
30 #include "mpegutils.h"
31 #include "mpegvideo.h"
32 #include "golomb.h"
33 
34 #include "rv34.h"
35 #include "rv40vlc2.h"
36 #include "rv40data.h"
37 
41 
42 static const int16_t mode2_offs[] = {
43  0, 614, 1222, 1794, 2410, 3014, 3586, 4202, 4792, 5382, 5966, 6542,
44  7138, 7716, 8292, 8864, 9444, 10030, 10642, 11212, 11814
45 };
46 
47 /**
48  * Initialize all tables.
49  */
50 static av_cold void rv40_init_tables(void)
51 {
52  int i;
53  static VLC_TYPE aic_table[1 << AIC_TOP_BITS][2];
54  static VLC_TYPE aic_mode1_table[AIC_MODE1_NUM << AIC_MODE1_BITS][2];
55  static VLC_TYPE aic_mode2_table[11814][2];
56  static VLC_TYPE ptype_table[NUM_PTYPE_VLCS << PTYPE_VLC_BITS][2];
57  static VLC_TYPE btype_table[NUM_BTYPE_VLCS << BTYPE_VLC_BITS][2];
58 
59  aic_top_vlc.table = aic_table;
60  aic_top_vlc.table_allocated = 1 << AIC_TOP_BITS;
61  init_vlc(&aic_top_vlc, AIC_TOP_BITS, AIC_TOP_SIZE,
64  for(i = 0; i < AIC_MODE1_NUM; i++){
65  // Every tenth VLC table is empty
66  if((i % 10) == 9) continue;
67  aic_mode1_vlc[i].table = &aic_mode1_table[i << AIC_MODE1_BITS];
68  aic_mode1_vlc[i].table_allocated = 1 << AIC_MODE1_BITS;
69  init_vlc(&aic_mode1_vlc[i], AIC_MODE1_BITS, AIC_MODE1_SIZE,
70  aic_mode1_vlc_bits[i], 1, 1,
72  }
73  for(i = 0; i < AIC_MODE2_NUM; i++){
74  aic_mode2_vlc[i].table = &aic_mode2_table[mode2_offs[i]];
75  aic_mode2_vlc[i].table_allocated = mode2_offs[i + 1] - mode2_offs[i];
76  init_vlc(&aic_mode2_vlc[i], AIC_MODE2_BITS, AIC_MODE2_SIZE,
77  aic_mode2_vlc_bits[i], 1, 1,
79  }
80  for(i = 0; i < NUM_PTYPE_VLCS; i++){
81  ptype_vlc[i].table = &ptype_table[i << PTYPE_VLC_BITS];
82  ptype_vlc[i].table_allocated = 1 << PTYPE_VLC_BITS;
84  ptype_vlc_bits[i], 1, 1,
85  ptype_vlc_codes[i], 1, 1,
87  }
88  for(i = 0; i < NUM_BTYPE_VLCS; i++){
89  btype_vlc[i].table = &btype_table[i << BTYPE_VLC_BITS];
90  btype_vlc[i].table_allocated = 1 << BTYPE_VLC_BITS;
92  btype_vlc_bits[i], 1, 1,
93  btype_vlc_codes[i], 1, 1,
95  }
96 }
97 
98 /**
99  * Get stored dimension from bitstream.
100  *
101  * If the width/height is the standard one then it's coded as a 3-bit index.
102  * Otherwise it is coded as escaped 8-bit portions.
103  */
104 static int get_dimension(GetBitContext *gb, const int *dim)
105 {
106  int t = get_bits(gb, 3);
107  int val = dim[t];
108  if(val < 0)
109  val = dim[get_bits1(gb) - val];
110  if(!val){
111  do{
112  if (get_bits_left(gb) < 8)
113  return AVERROR_INVALIDDATA;
114  t = get_bits(gb, 8);
115  val += t << 2;
116  }while(t == 0xFF);
117  }
118  return val;
119 }
120 
121 /**
122  * Get encoded picture size - usually this is called from rv40_parse_slice_header.
123  */
124 static void rv40_parse_picture_size(GetBitContext *gb, int *w, int *h)
125 {
128 }
129 
131 {
132  int mb_bits;
133  int w = r->s.width, h = r->s.height;
134  int mb_size;
135  int ret;
136 
137  memset(si, 0, sizeof(SliceInfo));
138  if(get_bits1(gb))
139  return AVERROR_INVALIDDATA;
140  si->type = get_bits(gb, 2);
141  if(si->type == 1) si->type = 0;
142  si->quant = get_bits(gb, 5);
143  if(get_bits(gb, 2))
144  return AVERROR_INVALIDDATA;
145  si->vlc_set = get_bits(gb, 2);
146  skip_bits1(gb);
147  si->pts = get_bits(gb, 13);
148  if(!si->type || !get_bits1(gb))
149  rv40_parse_picture_size(gb, &w, &h);
150  if ((ret = av_image_check_size(w, h, 0, r->s.avctx)) < 0)
151  return ret;
152  si->width = w;
153  si->height = h;
154  mb_size = ((w + 15) >> 4) * ((h + 15) >> 4);
155  mb_bits = ff_rv34_get_start_offset(gb, mb_size);
156  si->start = get_bits(gb, mb_bits);
157 
158  return 0;
159 }
160 
161 /**
162  * Decode 4x4 intra types array.
163  */
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.table, 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  v = get_vlc2(gb, aic_mode2_vlc[k].table, AIC_MODE2_BITS, 2);
198  *ptr++ = v/9;
199  *ptr++ = v%9;
200  j++;
201  }else{
202  if(B != -1 && C != -1)
203  v = get_vlc2(gb, aic_mode1_vlc[B + C*10].table, AIC_MODE1_BITS, 1);
204  else{ // tricky decoding
205  v = 0;
206  switch(C){
207  case -1: // code 0 -> 1, 1 -> 0
208  if(B < 2)
209  v = get_bits1(gb) ^ 1;
210  break;
211  case 0:
212  case 2: // code 0 -> 2, 1 -> 0
213  v = (get_bits1(gb) ^ 1) << 1;
214  break;
215  }
216  }
217  *ptr++ = v;
218  }
219  }
220  }
221  return 0;
222 }
223 
224 /**
225  * Decode macroblock information.
226  */
228 {
229  MpegEncContext *s = &r->s;
230  GetBitContext *gb = &s->gb;
231  int q, i;
232  int prev_type = 0;
233  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
234 
235  if(!r->s.mb_skip_run) {
237  if(r->s.mb_skip_run > (unsigned)s->mb_num)
238  return -1;
239  }
240 
241  if(--r->s.mb_skip_run)
242  return RV34_MB_SKIP;
243 
244  if(r->avail_cache[6-4]){
245  int blocks[RV34_MB_TYPES] = {0};
246  int count = 0;
247  if(r->avail_cache[6-1])
248  blocks[r->mb_type[mb_pos - 1]]++;
249  blocks[r->mb_type[mb_pos - s->mb_stride]]++;
250  if(r->avail_cache[6-2])
251  blocks[r->mb_type[mb_pos - s->mb_stride + 1]]++;
252  if(r->avail_cache[6-5])
253  blocks[r->mb_type[mb_pos - s->mb_stride - 1]]++;
254  for(i = 0; i < RV34_MB_TYPES; i++){
255  if(blocks[i] > count){
256  count = blocks[i];
257  prev_type = i;
258  if(count>1)
259  break;
260  }
261  }
262  } else if (r->avail_cache[6-1])
263  prev_type = r->mb_type[mb_pos - 1];
264 
265  if(s->pict_type == AV_PICTURE_TYPE_P){
266  prev_type = block_num_to_ptype_vlc_num[prev_type];
267  q = get_vlc2(gb, ptype_vlc[prev_type].table, PTYPE_VLC_BITS, 1);
268  if(q < PBTYPE_ESCAPE)
269  return q;
270  q = get_vlc2(gb, ptype_vlc[prev_type].table, PTYPE_VLC_BITS, 1);
271  av_log(s->avctx, AV_LOG_ERROR, "Dquant for P-frame\n");
272  }else{
273  prev_type = block_num_to_btype_vlc_num[prev_type];
274  q = get_vlc2(gb, btype_vlc[prev_type].table, BTYPE_VLC_BITS, 1);
275  if(q < PBTYPE_ESCAPE)
276  return q;
277  q = get_vlc2(gb, btype_vlc[prev_type].table, BTYPE_VLC_BITS, 1);
278  av_log(s->avctx, AV_LOG_ERROR, "Dquant for B-frame\n");
279  }
280  return 0;
281 }
282 
288 };
289 
290 #define MASK_CUR 0x0001
291 #define MASK_RIGHT 0x0008
292 #define MASK_BOTTOM 0x0010
293 #define MASK_TOP 0x1000
294 #define MASK_Y_TOP_ROW 0x000F
295 #define MASK_Y_LAST_ROW 0xF000
296 #define MASK_Y_LEFT_COL 0x1111
297 #define MASK_Y_RIGHT_COL 0x8888
298 #define MASK_C_TOP_ROW 0x0003
299 #define MASK_C_LAST_ROW 0x000C
300 #define MASK_C_LEFT_COL 0x0005
301 #define MASK_C_RIGHT_COL 0x000A
302 
303 static const int neighbour_offs_x[4] = { 0, 0, -1, 0 };
304 static const int neighbour_offs_y[4] = { 0, -1, 0, 1 };
305 
307  uint8_t *src, int stride, int dmode,
308  int lim_q1, int lim_p1,
309  int alpha, int beta, int beta2,
310  int chroma, int edge, int dir)
311 {
312  int filter_p1, filter_q1;
313  int strong;
314  int lims;
315 
316  strong = rdsp->rv40_loop_filter_strength[dir](src, stride, beta, beta2,
317  edge, &filter_p1, &filter_q1);
318 
319  lims = filter_p1 + filter_q1 + ((lim_q1 + lim_p1) >> 1) + 1;
320 
321  if (strong) {
323  lims, dmode, chroma);
324  } else if (filter_p1 & filter_q1) {
325  rdsp->rv40_weak_loop_filter[dir](src, stride, 1, 1, alpha, beta,
326  lims, lim_q1, lim_p1);
327  } else if (filter_p1 | filter_q1) {
328  rdsp->rv40_weak_loop_filter[dir](src, stride, filter_p1, filter_q1,
329  alpha, beta, lims >> 1, lim_q1 >> 1,
330  lim_p1 >> 1);
331  }
332 }
333 
334 /**
335  * RV40 loop filtering function
336  */
337 static void rv40_loop_filter(RV34DecContext *r, int row)
338 {
339  MpegEncContext *s = &r->s;
340  int mb_pos, mb_x;
341  int i, j, k;
342  uint8_t *Y, *C;
343  int alpha, beta, betaY, betaC;
344  int q;
345  int mbtype[4]; ///< current macroblock and its neighbours types
346  /**
347  * flags indicating that macroblock can be filtered with strong filter
348  * it is set only for intra coded MB and MB with DCs coded separately
349  */
350  int mb_strong[4];
351  int clip[4]; ///< MB filter clipping value calculated from filtering strength
352  /**
353  * coded block patterns for luma part of current macroblock and its neighbours
354  * Format:
355  * LSB corresponds to the top left block,
356  * each nibble represents one row of subblocks.
357  */
358  int cbp[4];
359  /**
360  * coded block patterns for chroma part of current macroblock and its neighbours
361  * Format is the same as for luma with two subblocks in a row.
362  */
363  int uvcbp[4][2];
364  /**
365  * This mask represents the pattern of luma subblocks that should be filtered
366  * in addition to the coded ones because they lie at the edge of
367  * 8x8 block with different enough motion vectors
368  */
369  unsigned mvmasks[4];
370 
371  mb_pos = row * s->mb_stride;
372  for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){
373  int mbtype = s->current_picture_ptr->mb_type[mb_pos];
374  if(IS_INTRA(mbtype) || IS_SEPARATE_DC(mbtype))
375  r->cbp_luma [mb_pos] = r->deblock_coefs[mb_pos] = 0xFFFF;
376  if(IS_INTRA(mbtype))
377  r->cbp_chroma[mb_pos] = 0xFF;
378  }
379  mb_pos = row * s->mb_stride;
380  for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){
381  int y_h_deblock, y_v_deblock;
382  int c_v_deblock[2], c_h_deblock[2];
383  int clip_left;
384  int avail[4];
385  unsigned y_to_deblock;
386  int c_to_deblock[2];
387 
388  q = s->current_picture_ptr->qscale_table[mb_pos];
389  alpha = rv40_alpha_tab[q];
390  beta = rv40_beta_tab [q];
391  betaY = betaC = beta * 3;
392  if(s->width * s->height <= 176*144)
393  betaY += beta;
394 
395  avail[0] = 1;
396  avail[1] = row;
397  avail[2] = mb_x;
398  avail[3] = row < s->mb_height - 1;
399  for(i = 0; i < 4; i++){
400  if(avail[i]){
401  int pos = mb_pos + neighbour_offs_x[i] + neighbour_offs_y[i]*s->mb_stride;
402  mvmasks[i] = r->deblock_coefs[pos];
403  mbtype [i] = s->current_picture_ptr->mb_type[pos];
404  cbp [i] = r->cbp_luma[pos];
405  uvcbp[i][0] = r->cbp_chroma[pos] & 0xF;
406  uvcbp[i][1] = r->cbp_chroma[pos] >> 4;
407  }else{
408  mvmasks[i] = 0;
409  mbtype [i] = mbtype[0];
410  cbp [i] = 0;
411  uvcbp[i][0] = uvcbp[i][1] = 0;
412  }
413  mb_strong[i] = IS_INTRA(mbtype[i]) || IS_SEPARATE_DC(mbtype[i]);
414  clip[i] = rv40_filter_clip_tbl[mb_strong[i] + 1][q];
415  }
416  y_to_deblock = mvmasks[POS_CUR]
417  | (mvmasks[POS_BOTTOM] << 16);
418  /* This pattern contains bits signalling that horizontal edges of
419  * the current block can be filtered.
420  * That happens when either of adjacent subblocks is coded or lies on
421  * the edge of 8x8 blocks with motion vectors differing by more than
422  * 3/4 pel in any component (any edge orientation for some reason).
423  */
424  y_h_deblock = y_to_deblock
425  | ((cbp[POS_CUR] << 4) & ~MASK_Y_TOP_ROW)
426  | ((cbp[POS_TOP] & MASK_Y_LAST_ROW) >> 12);
427  /* This pattern contains bits signalling that vertical edges of
428  * the current block can be filtered.
429  * That happens when either of adjacent subblocks is coded or lies on
430  * the edge of 8x8 blocks with motion vectors differing by more than
431  * 3/4 pel in any component (any edge orientation for some reason).
432  */
433  y_v_deblock = y_to_deblock
434  | ((cbp[POS_CUR] << 1) & ~MASK_Y_LEFT_COL)
435  | ((cbp[POS_LEFT] & MASK_Y_RIGHT_COL) >> 3);
436  if(!mb_x)
437  y_v_deblock &= ~MASK_Y_LEFT_COL;
438  if(!row)
439  y_h_deblock &= ~MASK_Y_TOP_ROW;
440  if(row == s->mb_height - 1 || (mb_strong[POS_CUR] | mb_strong[POS_BOTTOM]))
441  y_h_deblock &= ~(MASK_Y_TOP_ROW << 16);
442  /* Calculating chroma patterns is similar and easier since there is
443  * no motion vector pattern for them.
444  */
445  for(i = 0; i < 2; i++){
446  c_to_deblock[i] = (uvcbp[POS_BOTTOM][i] << 4) | uvcbp[POS_CUR][i];
447  c_v_deblock[i] = c_to_deblock[i]
448  | ((uvcbp[POS_CUR] [i] << 1) & ~MASK_C_LEFT_COL)
449  | ((uvcbp[POS_LEFT][i] & MASK_C_RIGHT_COL) >> 1);
450  c_h_deblock[i] = c_to_deblock[i]
451  | ((uvcbp[POS_TOP][i] & MASK_C_LAST_ROW) >> 2)
452  | (uvcbp[POS_CUR][i] << 2);
453  if(!mb_x)
454  c_v_deblock[i] &= ~MASK_C_LEFT_COL;
455  if(!row)
456  c_h_deblock[i] &= ~MASK_C_TOP_ROW;
457  if(row == s->mb_height - 1 || (mb_strong[POS_CUR] | mb_strong[POS_BOTTOM]))
458  c_h_deblock[i] &= ~(MASK_C_TOP_ROW << 4);
459  }
460 
461  for(j = 0; j < 16; j += 4){
462  Y = s->current_picture_ptr->f->data[0] + mb_x*16 + (row*16 + j) * s->linesize;
463  for(i = 0; i < 4; i++, Y += 4){
464  int ij = i + j;
465  int clip_cur = y_to_deblock & (MASK_CUR << ij) ? clip[POS_CUR] : 0;
466  int dither = j ? ij : i*4;
467 
468  // if bottom block is coded then we can filter its top edge
469  // (or bottom edge of this block, which is the same)
470  if(y_h_deblock & (MASK_BOTTOM << ij)){
472  s->linesize, dither,
473  y_to_deblock & (MASK_BOTTOM << ij) ? clip[POS_CUR] : 0,
474  clip_cur, alpha, beta, betaY,
475  0, 0, 0);
476  }
477  // filter left block edge in ordinary mode (with low filtering strength)
478  if(y_v_deblock & (MASK_CUR << ij) && (i || !(mb_strong[POS_CUR] | mb_strong[POS_LEFT]))){
479  if(!i)
480  clip_left = mvmasks[POS_LEFT] & (MASK_RIGHT << j) ? clip[POS_LEFT] : 0;
481  else
482  clip_left = y_to_deblock & (MASK_CUR << (ij-1)) ? clip[POS_CUR] : 0;
483  rv40_adaptive_loop_filter(&r->rdsp, Y, s->linesize, dither,
484  clip_cur,
485  clip_left,
486  alpha, beta, betaY, 0, 0, 1);
487  }
488  // filter top edge of the current macroblock when filtering strength is high
489  if(!j && y_h_deblock & (MASK_CUR << i) && (mb_strong[POS_CUR] | mb_strong[POS_TOP])){
490  rv40_adaptive_loop_filter(&r->rdsp, Y, s->linesize, dither,
491  clip_cur,
492  mvmasks[POS_TOP] & (MASK_TOP << i) ? clip[POS_TOP] : 0,
493  alpha, beta, betaY, 0, 1, 0);
494  }
495  // filter left block edge in edge mode (with high filtering strength)
496  if(y_v_deblock & (MASK_CUR << ij) && !i && (mb_strong[POS_CUR] | mb_strong[POS_LEFT])){
497  clip_left = mvmasks[POS_LEFT] & (MASK_RIGHT << j) ? clip[POS_LEFT] : 0;
498  rv40_adaptive_loop_filter(&r->rdsp, Y, s->linesize, dither,
499  clip_cur,
500  clip_left,
501  alpha, beta, betaY, 0, 1, 1);
502  }
503  }
504  }
505  for(k = 0; k < 2; k++){
506  for(j = 0; j < 2; j++){
507  C = s->current_picture_ptr->f->data[k + 1] + mb_x*8 + (row*8 + j*4) * s->uvlinesize;
508  for(i = 0; i < 2; i++, C += 4){
509  int ij = i + j*2;
510  int clip_cur = c_to_deblock[k] & (MASK_CUR << ij) ? clip[POS_CUR] : 0;
511  if(c_h_deblock[k] & (MASK_CUR << (ij+2))){
512  int clip_bot = c_to_deblock[k] & (MASK_CUR << (ij+2)) ? clip[POS_CUR] : 0;
514  clip_bot,
515  clip_cur,
516  alpha, beta, betaC, 1, 0, 0);
517  }
518  if((c_v_deblock[k] & (MASK_CUR << ij)) && (i || !(mb_strong[POS_CUR] | mb_strong[POS_LEFT]))){
519  if(!i)
520  clip_left = uvcbp[POS_LEFT][k] & (MASK_CUR << (2*j+1)) ? clip[POS_LEFT] : 0;
521  else
522  clip_left = c_to_deblock[k] & (MASK_CUR << (ij-1)) ? clip[POS_CUR] : 0;
523  rv40_adaptive_loop_filter(&r->rdsp, C, s->uvlinesize, j*8,
524  clip_cur,
525  clip_left,
526  alpha, beta, betaC, 1, 0, 1);
527  }
528  if(!j && c_h_deblock[k] & (MASK_CUR << ij) && (mb_strong[POS_CUR] | mb_strong[POS_TOP])){
529  int clip_top = uvcbp[POS_TOP][k] & (MASK_CUR << (ij+2)) ? clip[POS_TOP] : 0;
530  rv40_adaptive_loop_filter(&r->rdsp, C, s->uvlinesize, i*8,
531  clip_cur,
532  clip_top,
533  alpha, beta, betaC, 1, 1, 0);
534  }
535  if(c_v_deblock[k] & (MASK_CUR << ij) && !i && (mb_strong[POS_CUR] | mb_strong[POS_LEFT])){
536  clip_left = uvcbp[POS_LEFT][k] & (MASK_CUR << (2*j+1)) ? clip[POS_LEFT] : 0;
537  rv40_adaptive_loop_filter(&r->rdsp, C, s->uvlinesize, j*8,
538  clip_cur,
539  clip_left,
540  alpha, beta, betaC, 1, 1, 1);
541  }
542  }
543  }
544  }
545  }
546 }
547 
548 /**
549  * Initialize decoder.
550  */
552 {
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  if(!aic_top_vlc.bits)
567  return 0;
568 }
569 
571  .name = "rv40",
572  .long_name = NULL_IF_CONFIG_SMALL("RealVideo 4.0"),
573  .type = AVMEDIA_TYPE_VIDEO,
574  .id = AV_CODEC_ID_RV40,
575  .priv_data_size = sizeof(RV34DecContext),
577  .close = ff_rv34_decode_end,
579  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
581  .flush = ff_mpeg_flush,
582  .pix_fmts = (const enum AVPixelFormat[]) {
585  },
588 };
int vlc_set
VLCs used for this slice.
Definition: rv34.h:76
const char const char void * val
Definition: avisynth_c.h:863
static const uint8_t btype_vlc_codes[NUM_BTYPE_VLCS][BTYPE_VLC_SIZE]
Definition: rv40vlc2.h:679
#define PBTYPE_ESCAPE
Definition: rv40vlc2.h:635
#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:50
AVCodec ff_rv40_decoder
Definition: rv40.c:570
static void flush(AVCodecContext *avctx)
#define PTYPE_VLC_BITS
Definition: rv40vlc2.h:641
uint32_t avail_cache[3 *4]
8x8 block available flags (for MV prediction)
Definition: rv34.h:119
#define MASK_CUR
Definition: rv40.c:290
#define IS_SEPARATE_DC(a)
Definition: rv34.h:37
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:85
#define PTYPE_VLC_SIZE
Definition: rv40vlc2.h:640
int ff_init_vlc_sparse(VLC *vlc_arg, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags)
Definition: bitstream.c:273
int height
coded height
Definition: rv34.h:79
#define BTYPE_VLC_SIZE
Definition: rv40vlc2.h:676
#define AIC_MODE1_SIZE
Definition: rv40vlc2.h:428
#define BTYPE_VLC_BITS
Definition: rv40vlc2.h:677
mpegvideo header.
#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:124
RV30 and RV40 decoder common data declarations.
int mb_num
number of MBs of a picture
Definition: mpegvideo.h:133
#define src
Definition: vp8dsp.c:254
int start
Definition: rv34.h:77
AVCodec.
Definition: avcodec.h:3492
const uint8_t * luma_dc_quant_p
luma subblock DC quantizer for interframes
Definition: rv34.h:91
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 uint8_t btype_vlc_syms[BTYPE_VLC_SIZE]
Definition: rv40vlc2.h:697
static const int neighbour_offs_x[4]
Definition: rv40.c:303
static VLC btype_vlc[NUM_BTYPE_VLCS]
Definition: rv40.c:40
static const uint8_t block_num_to_ptype_vlc_num[12]
reverse of ptype_vlc_syms
Definition: rv40vlc2.h:668
#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: avcodec.h:1009
uint8_t
#define av_cold
Definition: attributes.h:82
uint16_t * cbp_luma
CBP values for luma subblocks.
Definition: rv34.h:114
static const uint8_t aic_mode1_vlc_bits[AIC_MODE1_NUM][AIC_MODE1_SIZE]
Definition: rv40vlc2.h:532
int width
coded width
Definition: rv34.h:78
#define MASK_C_RIGHT_COL
Definition: rv40.c:301
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:116
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:306
Skipped block.
Definition: rv34.h:49
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:129
#define MASK_Y_LAST_ROW
Definition: rv40.c:295
#define A(x)
Definition: vp56_arith.h:28
#define av_log(a,...)
static const uint16_t table[]
Definition: prosumer.c:206
static VLC aic_mode2_vlc[AIC_MODE2_NUM]
Definition: rv40.c:39
int quant
quantizer used for this slice
Definition: rv34.h:75
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static const uint8_t block_num_to_btype_vlc_num[12]
reverse of btype_vlc_syms
Definition: rv40vlc2.h:702
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: vlc.h:38
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:1542
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:186
const char * r
Definition: vf_curves.c:114
static const uint8_t dither[8][8]
Definition: vf_fspp.c:57
static int rv40_decode_mb_info(RV34DecContext *r)
Decode macroblock information.
Definition: rv40.c:227
#define MASK_Y_TOP_ROW
Definition: rv40.c:294
const char * name
Name of the codec implementation.
Definition: avcodec.h:3499
GetBitContext gb
Definition: mpegvideo.h:448
static const uint8_t ptype_vlc_syms[PTYPE_VLC_SIZE]
Definition: rv40vlc2.h:663
GLsizei count
Definition: opengl_enc.c:108
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1040
#define MASK_BOTTOM
Definition: rv40.c:292
Definition: vlc.h:26
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo.c:2307
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:225
static const uint8_t ptype_vlc_bits[NUM_PTYPE_VLCS][PTYPE_VLC_SIZE]
Definition: rv40vlc2.h:653
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:282
int(* parse_slice_header)(struct RV34DecContext *r, GetBitContext *gb, SliceInfo *si)
Definition: rv34.h:126
#define MASK_RIGHT
Definition: rv40.c:291
#define Y
Definition: boxblur.h:38
static VLC ptype_vlc[NUM_PTYPE_VLCS]
Definition: rv40.c:40
int * mb_type
internal macroblock types
Definition: rv34.h:97
#define MASK_C_LEFT_COL
Definition: rv40.c:300
uint8_t w
Definition: llviddspenc.c:38
static int rv40_parse_slice_header(RV34DecContext *r, GetBitContext *gb, SliceInfo *si)
Definition: rv40.c:130
#define AIC_MODE2_NUM
codes used for determining a pair of block types
Definition: rv40vlc2.h:52
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:551
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
static const uint8_t rv40_aic_top_vlc_bits[AIC_TOP_SIZE]
Definition: rv40vlc2.h:43
#define AIC_MODE1_BITS
Definition: rv40vlc2.h:429
static VLC aic_mode1_vlc[AIC_MODE1_NUM]
Definition: rv40.c:39
Definition: rv40.c:285
#define MASK_Y_LEFT_COL
Definition: rv40.c:296
#define MASK_TOP
Definition: rv40.c:293
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
static const uint8_t ptype_vlc_codes[NUM_PTYPE_VLCS][PTYPE_VLC_SIZE]
Definition: rv40vlc2.h:643
int table_allocated
Definition: vlc.h:29
int(* decode_mb_info)(struct RV34DecContext *r)
Definition: rv34.h:127
int first_slice_line
used in MPEG-4 too to handle resync markers
Definition: mpegvideo.h:436
int ff_rv34_decode_init_thread_copy(AVCodecContext *avctx)
Definition: rv34.c:1534
essential slice information
Definition: rv34.h:73
Libavcodec external API header.
ptrdiff_t linesize
line size, in bytes, may be different from width
Definition: mpegvideo.h:134
#define MASK_C_TOP_ROW
Definition: rv40.c:298
static const int16_t alpha[]
Definition: ilbcdata.h:55
main external API structure.
Definition: avcodec.h:1568
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 uint16_t aic_mode2_vlc_codes[AIC_MODE2_NUM][AIC_MODE2_SIZE]
Definition: rv40vlc2.h:56
struct AVFrame * f
Definition: mpegpicture.h:46
#define MASK_C_LAST_ROW
Definition: rv40.c:299
static const int16_t mode2_offs[]
Definition: rv40.c:42
av_cold int ff_rv34_decode_init(AVCodecContext *avctx)
Initialize decoder.
Definition: rv34.c:1492
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:1643
int intra_types_stride
block types array stride
Definition: rv34.h:89
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:275
int(* decode_intra_types)(struct RV34DecContext *r, GetBitContext *gb, int8_t *dst)
Definition: rv34.h:128
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:309
static VLC aic_top_vlc
Definition: rv40.c:38
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:1849
int8_t * qscale_table
Definition: mpegpicture.h:50
struct AVCodecContext * avctx
Definition: mpegvideo.h:98
static const uint8_t aic_mode1_vlc_codes[AIC_MODE1_NUM][AIC_MODE1_SIZE]
Definition: rv40vlc2.h:431
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
#define MASK_Y_RIGHT_COL
Definition: rv40.c:297
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:104
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:284
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:55
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:1562
#define AIC_TOP_BITS
codes used for the first four block types
Definition: rv40vlc2.h:36
#define AIC_MODE2_SIZE
Definition: rv40vlc2.h:53
Definition: rv40.c:286
int ff_rv34_get_start_offset(GetBitContext *gb, int mb_size)
Decode starting slice position.
Definition: rv34.c:330
#define IS_INTRA(x, y)
decoder context
Definition: rv34.h:84
void * priv_data
Definition: avcodec.h:1595
#define NUM_BTYPE_VLCS
tables used for P-frame macroblock type decoding
Definition: rv40vlc2.h:675
RV40BlockPos
Definition: rv40.c:283
RV40 VLC tables used for macroblock information decoding.
static const uint8_t btype_vlc_bits[NUM_BTYPE_VLCS][PTYPE_VLC_SIZE]
Definition: rv40vlc2.h:688
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:427
const uint8_t * luma_dc_quant_i
luma subblock DC quantizer for intraframes
Definition: rv34.h:90
static int rv40_decode_intra_types(RV34DecContext *r, GetBitContext *gb, int8_t *dst)
Decode 4x4 intra types array.
Definition: rv40.c:164
#define NUM_PTYPE_VLCS
tables used for P-frame macroblock type decoding
Definition: rv40vlc2.h:639
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:74
#define AIC_MODE2_BITS
Definition: rv40vlc2.h:54
#define VLC_TYPE
Definition: vlc.h:24
static unsigned get_interleaved_ue_golomb(GetBitContext *gb)
Definition: golomb.h:143
miscellaneous RV40 tables
#define stride
static const int neighbour_offs_y[4]
Definition: rv40.c:304
int rv30
indicates which RV variant is currently decoded
Definition: rv34.h:104
static const uint8_t rv40_aic_top_vlc_codes[AIC_TOP_SIZE]
Definition: rv40vlc2.h:38
exp golomb vlc stuff
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:984
void(* loop_filter)(struct RV34DecContext *r, int row)
Definition: rv34.h:129
RV34DSPContext rdsp
Definition: rv34.h:86
static void rv40_loop_filter(RV34DecContext *r, int row)
RV40 loop filtering function.
Definition: rv40.c:337
static const uint8_t aic_mode2_vlc_bits[AIC_MODE2_NUM][AIC_MODE2_SIZE]
Definition: rv40vlc2.h:239
Predicted.
Definition: avutil.h:275
int pts
frame timestamp
Definition: rv34.h:80
uint8_t * cbp_chroma
CBP values for chroma subblocks.
Definition: rv34.h:115