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 
68  for(i = 0; i < AIC_MODE1_NUM; i++){
69  // Every tenth VLC table is empty
70  if((i % 10) == 9) continue;
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;
89  syms, 2, 2, 0, INIT_VLC_STATIC_OVERLONG, NULL);
91  }
92  for(i = 0; i < NUM_PTYPE_VLCS; i++){
94  ptype_vlc_tabs[i]);
95  }
96  for(i = 0; i < NUM_BTYPE_VLCS; i++){
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
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) {
239  r->s.mb_skip_run = get_interleaved_ue_golomb(gb) + 1;
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)){
474  rv40_adaptive_loop_filter(&r->rdsp, Y+4*s->linesize,
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;
516  rv40_adaptive_loop_filter(&r->rdsp, C+4*s->uvlinesize, s->uvlinesize, i*8,
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)
564  r->parse_slice_header = rv40_parse_slice_header;
565  r->decode_intra_types = rv40_decode_intra_types;
566  r->decode_mb_info = rv40_decode_mb_info;
567  r->loop_filter = rv40_loop_filter;
568  r->luma_dc_quant_i = rv40_luma_dc_quant[0];
569  r->luma_dc_quant_p = rv40_luma_dc_quant[1];
570  ff_rv40dsp_init(&r->rdsp);
571  return 0;
572 }
573 
575  .name = "rv40",
576  .long_name = NULL_IF_CONFIG_SMALL("RealVideo 4.0"),
577  .type = AVMEDIA_TYPE_VIDEO,
578  .id = AV_CODEC_ID_RV40,
579  .priv_data_size = sizeof(RV34DecContext),
581  .close = ff_rv34_decode_end,
583  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
585  .flush = ff_mpeg_flush,
586  .pix_fmts = (const enum AVPixelFormat[]) {
589  },
591  .caps_internal = FF_CODEC_CAP_ALLOCATE_PROGRESS,
592 };
MASK_C_LAST_ROW
#define MASK_C_LAST_ROW
Definition: rv40.c:302
RV34DecContext
decoder context
Definition: rv34.h:86
AVCodec
AVCodec.
Definition: codec.h:197
stride
int stride
Definition: mace.c:144
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AIC_MODE1_BITS
#define AIC_MODE1_BITS
Definition: rv40vlc2.h:386
rv40_aic_table_index
static const uint16_t rv40_aic_table_index[MODE2_PATTERNS_NUM]
intra types table
Definition: rv40data.h:47
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
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:849
r
const char * r
Definition: vf_curves.c:116
ff_rv34_decode_end
av_cold int ff_rv34_decode_end(AVCodecContext *avctx)
Definition: rv34.c:1807
MASK_Y_TOP_ROW
#define MASK_Y_TOP_ROW
Definition: rv40.c:297
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:309
aic_mode2_vlc_bits
static const uint8_t aic_mode2_vlc_bits[AIC_MODE2_NUM][AIC_MODE2_SIZE]
Definition: rv40vlc2.h:236
aic_top_vlc
static VLC aic_top_vlc
Definition: rv40.c:40
ff_rv34_get_start_offset
int ff_rv34_get_start_offset(GetBitContext *gb, int mb_size)
Decode starting slice position.
Definition: rv34.c:322
get_interleaved_ue_golomb
static unsigned get_interleaved_ue_golomb(GetBitContext *gb)
Definition: golomb.h:145
w
uint8_t w
Definition: llviddspenc.c:39
ff_rv34_decode_update_thread_context
int ff_rv34_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: rv34.c:1516
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:1624
table
static const uint16_t table[]
Definition: prosumer.c:206
rv40_loop_filter
static void rv40_loop_filter(RV34DecContext *r, int row)
RV40 loop filtering function.
Definition: rv40.c:340
AIC_MODE2_SIZE
#define AIC_MODE2_SIZE
Definition: rv40vlc2.h:50
PTYPE_VLC_SIZE
#define PTYPE_VLC_SIZE
Definition: rv40vlc2.h:569
get_vlc2
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
mpegvideo.h
RV40BlockPos
RV40BlockPos
Definition: rv40.c:286
mpegutils.h
aic_mode2_vlc_syms
static const uint8_t aic_mode2_vlc_syms[AIC_MODE2_NUM][AIC_MODE2_SIZE]
Definition: rv40vlc2.h:53
aic_mode1_vlc
static VLC aic_mode1_vlc[AIC_MODE1_NUM]
Definition: rv40.c:41
MASK_Y_RIGHT_COL
#define MASK_Y_RIGHT_COL
Definition: rv40.c:300
MASK_BOTTOM
#define MASK_BOTTOM
Definition: rv40.c:295
rv40_standard_heights
static const int rv40_standard_heights[]
Definition: rv40data.h:37
A
#define A(x)
Definition: vp56_arith.h:28
rv40_init_table
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
MASK_C_LEFT_COL
#define MASK_C_LEFT_COL
Definition: rv40.c:303
golomb.h
exp golomb vlc stuff
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
rv40_decode_init
static av_cold int rv40_decode_init(AVCodecContext *avctx)
Initialize decoder.
Definition: rv40.c:554
MODE2_PATTERNS_NUM
#define MODE2_PATTERNS_NUM
Definition: rv40data.h:40
VLC_TYPE
#define VLC_TYPE
Definition: vlc.h:24
GetBitContext
Definition: get_bits.h:61
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:10345
val
static double val(void *priv, double ch)
Definition: aeval.c:76
ff_init_vlc_from_lengths
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:370
MASK_Y_LEFT_COL
#define MASK_Y_LEFT_COL
Definition: rv40.c:299
C
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
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:181
AIC_MODE2_NUM
#define AIC_MODE2_NUM
codes used for determining a pair of block types
Definition: rv40vlc2.h:49
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
ff_rv34_decode_init
av_cold int ff_rv34_decode_init(AVCodecContext *avctx)
Initialize decoder.
Definition: rv34.c:1486
rv40_init_tables
static av_cold void rv40_init_tables(void)
Initialize all tables.
Definition: rv40.c:61
POS_TOP
@ POS_TOP
Definition: rv40.c:288
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
s
#define s(width, name)
Definition: cbs_vp9.c:257
rv40_parse_slice_header
static int rv40_parse_slice_header(RV34DecContext *r, GetBitContext *gb, SliceInfo *si)
Definition: rv40.c:134
RV34DSPContext::rv40_loop_filter_strength
rv40_loop_filter_strength_func rv40_loop_filter_strength[2]
Definition: rv34dsp.h:74
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:289
IS_INTRA
#define IS_INTRA(x, y)
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
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:128
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:108
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:592
NULL
#define NULL
Definition: coverity.c:32
RV34_MB_SKIP
@ RV34_MB_SKIP
Skipped block.
Definition: rv34.h:51
MASK_CUR
#define MASK_CUR
Definition: rv40.c:293
AIC_MODE2_BITS
#define AIC_MODE2_BITS
Definition: rv40vlc2.h:51
SliceInfo::type
int type
slice type (intra, inter)
Definition: rv34.h:76
PTYPE_VLC_BITS
#define PTYPE_VLC_BITS
Definition: rv40vlc2.h:570
ff_rv34_decode_frame
int ff_rv34_decode_frame(AVCodecContext *avctx, void *data, int *got_picture_ptr, AVPacket *avpkt)
Definition: rv34.c:1597
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
src
#define src
Definition: vp8dsp.c:255
INIT_VLC_USE_NEW_STATIC
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:95
rv40data.h
BTYPE_VLC_SIZE
#define BTYPE_VLC_SIZE
Definition: rv40vlc2.h:597
ONLY_IF_THREADS_ENABLED
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:156
NUM_BTYPE_VLCS
#define NUM_BTYPE_VLCS
tables used for P-frame macroblock type decoding
Definition: rv40vlc2.h:596
rv34.h
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:168
SliceInfo::quant
int quant
quantizer used for this slice
Definition: rv34.h:77
RV34DSPContext
Definition: rv34dsp.h:57
VLC::table_allocated
int table_allocated
Definition: vlc.h:29
SliceInfo::vlc_set
int vlc_set
VLCs used for this slice.
Definition: rv34.h:78
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
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
rv40_decode_mb_info
static int rv40_decode_mb_info(RV34DecContext *r)
Decode macroblock information.
Definition: rv40.c:230
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
ff_mpeg_flush
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo.c:2300
aic_mode2_vlc
static VLC aic_mode2_vlc[AIC_MODE2_NUM]
Definition: rv40.c:41
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:298
SliceInfo::pts
int pts
frame timestamp
Definition: rv34.h:82
offset
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
Definition: writing_filters.txt:86
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:538
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
Y
#define Y
Definition: boxblur.h:38
get_dimension
static int get_dimension(GetBitContext *gb, const int *dim)
Get stored dimension from bitstream.
Definition: rv40.c:108
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:81
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:118
i
int i
Definition: input.c:407
POS_LEFT
@ POS_LEFT
Definition: rv40.c:289
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
RV34_MB_TYPES
@ RV34_MB_TYPES
Definition: rv34.h:57
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
SliceInfo
essential slice information
Definition: rv34.h:75
avcodec.h
MASK_TOP
#define MASK_TOP
Definition: rv40.c:296
MASK_RIGHT
#define MASK_RIGHT
Definition: rv40.c:294
dim
int dim
Definition: vorbis_enc_data.h:425
POS_BOTTOM
@ POS_BOTTOM
Definition: rv40.c:290
VLC::bits
int bits
Definition: vlc.h:27
ret
ret
Definition: filter_design.txt:187
INIT_VLC_STATIC_OVERLONG
#define INIT_VLC_STATIC_OVERLONG
Definition: vlc.h:96
pos
unsigned int pos
Definition: spdifenc.c:412
AIC_TOP_SIZE
#define AIC_TOP_SIZE
Definition: rv40vlc2.h:37
vlc_buf
static VLC_TYPE vlc_buf[16716][2]
Definition: clearvideo.c:86
block_num_to_btype_vlc_num
static const uint8_t block_num_to_btype_vlc_num[12]
Definition: rv40vlc2.h:615
ff_rv40_decoder
const AVCodec ff_rv40_decoder
Definition: rv40.c:574
B
#define B
Definition: huffyuvdsp.h:32
neighbour_offs_y
static const int neighbour_offs_y[4]
Definition: rv40.c:307
AVCodecContext
main external API structure.
Definition: avcodec.h:501
SliceInfo::start
int start
Definition: rv34.h:79
RV34DSPContext::rv40_weak_loop_filter
rv40_weak_loop_filter_func rv40_weak_loop_filter[2]
Definition: rv34dsp.h:72
btype_vlc
static VLC btype_vlc[NUM_BTYPE_VLCS]
Definition: rv40.c:42
IS_SEPARATE_DC
#define IS_SEPARATE_DC(a)
Definition: rv34.h:39
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
rv40vlc2.h
VLC
Definition: vlc.h:26
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:77
VLC::table_size
int table_size
Definition: vlc.h:29
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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
FF_CODEC_CAP_ALLOCATE_PROGRESS
#define FF_CODEC_CAP_ALLOCATE_PROGRESS
Definition: internal.h:76
MASK_C_RIGHT_COL
#define MASK_C_RIGHT_COL
Definition: rv40.c:304
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:528
ptype_vlc
static VLC ptype_vlc[NUM_PTYPE_VLCS]
Definition: rv40.c:42
AIC_TOP_BITS
#define AIC_TOP_BITS
codes used for the first four block types
Definition: rv40vlc2.h:36
neighbour_offs_x
static const int neighbour_offs_x[4]
Definition: rv40.c:306
rv40_aic_top_vlc_tab
static const uint8_t rv40_aic_top_vlc_tab[AIC_TOP_SIZE][2]
Definition: rv40vlc2.h:38
SliceInfo::width
int width
coded width
Definition: rv34.h:80
imgutils.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
h
h
Definition: vp9dsp_template.c:2038
av_image_check_size
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:315
MASK_C_TOP_ROW
#define MASK_C_TOP_ROW
Definition: rv40.c:301
ff_rv40dsp_init
void ff_rv40dsp_init(RV34DSPContext *c)
Definition: rv40dsp.c:620
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:81
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
clip
static double clip(void *opaque, double val)
Clip value val in the minval - maxval range.
Definition: vf_lut.c:162
ptype_vlc_tabs
static const uint8_t ptype_vlc_tabs[NUM_PTYPE_VLCS][PTYPE_VLC_SIZE][2]
Definition: rv40vlc2.h:572
POS_CUR
@ POS_CUR
Definition: rv40.c:287
block_num_to_ptype_vlc_num
static const uint8_t block_num_to_ptype_vlc_num[12]
Definition: rv40vlc2.h:589
aic_mode1_vlc_tabs
static const uint8_t aic_mode1_vlc_tabs[AIC_MODE1_NUM][AIC_MODE1_SIZE][2]
Definition: rv40vlc2.h:388
AV_WN16
#define AV_WN16(p, v)
Definition: intreadwrite.h:372
dither
static const uint8_t dither[8][8]
Definition: vf_fspp.c:59