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 #include "libavutil/thread.h"
31 
32 #include "avcodec.h"
33 #include "codec_internal.h"
34 #include "mpegutils.h"
35 #include "mpegvideo.h"
36 #include "mpegvideodec.h"
37 #include "golomb.h"
38 
39 #include "rv34.h"
40 #include "rv40vlc2.h"
41 #include "rv40data.h"
42 
43 static VLCElem aic_top_vlc[23590];
46 
47 static av_cold const VLCElem *rv40_init_table(VLCInitState *state, int nb_bits,
48  int nb_codes, const uint8_t (*tab)[2])
49 {
50  return ff_vlc_init_tables_from_lengths(state, nb_bits, nb_codes,
51  &tab[0][1], 2, &tab[0][0], 2, 1,
52  0, 0);
53 }
54 
55 /**
56  * Initialize all tables.
57  */
58 static av_cold void rv40_init_tables(void)
59 {
61  int i;
62 
65  for(i = 0; i < AIC_MODE1_NUM; i++){
66  // Every tenth VLC table is empty
67  if((i % 10) == 9) continue;
68  aic_mode1_vlc[i] =
71  }
72  for (unsigned i = 0; i < AIC_MODE2_NUM; i++){
73  uint16_t syms[AIC_MODE2_SIZE];
74 
75  for (int j = 0; j < AIC_MODE2_SIZE; j++) {
76  int first = aic_mode2_vlc_syms[i][j] >> 4;
77  int second = aic_mode2_vlc_syms[i][j] & 0xF;
78  if (HAVE_BIGENDIAN)
79  syms[j] = (first << 8) | second;
80  else
81  syms[j] = first | (second << 8);
82  }
83  aic_mode2_vlc[i] =
86  syms, 2, 2, 0, 0);
87  }
88  for(i = 0; i < NUM_PTYPE_VLCS; i++){
89  ptype_vlc[i] =
91  ptype_vlc_tabs[i]);
92  }
93  for(i = 0; i < NUM_BTYPE_VLCS; i++){
94  btype_vlc[i] =
96  btype_vlc_tabs[i]);
97  }
98 }
99 
100 /**
101  * Get stored dimension from bitstream.
102  *
103  * If the width/height is the standard one then it's coded as a 3-bit index.
104  * Otherwise it is coded as escaped 8-bit portions.
105  */
106 static int get_dimension(GetBitContext *gb, const int *dim)
107 {
108  int t = get_bits(gb, 3);
109  int val = dim[t];
110  if(val < 0)
111  val = dim[get_bits1(gb) - val];
112  if(!val){
113  do{
114  if (get_bits_left(gb) < 8)
115  return AVERROR_INVALIDDATA;
116  t = get_bits(gb, 8);
117  val += t << 2;
118  }while(t == 0xFF);
119  }
120  return val;
121 }
122 
123 /**
124  * Get encoded picture size - usually this is called from rv40_parse_slice_header.
125  */
126 static void rv40_parse_picture_size(GetBitContext *gb, int *w, int *h)
127 {
130 }
131 
133 {
134  int w = r->s.width, h = r->s.height;
135  int mb_size;
136  int ret;
137 
138  memset(si, 0, sizeof(SliceInfo));
139  if(get_bits1(gb))
140  return AVERROR_INVALIDDATA;
141  si->type = get_bits(gb, 2);
142  if(si->type == 1) si->type = 0;
143  si->quant = get_bits(gb, 5);
144  if(get_bits(gb, 2))
145  return AVERROR_INVALIDDATA;
146  si->vlc_set = get_bits(gb, 2);
147  skip_bits1(gb);
148  si->pts = get_bits(gb, 13);
149  if(!si->type || !get_bits1(gb))
150  rv40_parse_picture_size(gb, &w, &h);
151  if ((ret = av_image_check_size(w, h, 0, r->s.avctx)) < 0)
152  return ret;
153  si->width = w;
154  si->height = h;
155  mb_size = ((w + 15) >> 4) * ((h + 15) >> 4);
156  si->start = ff_rv34_get_start_offset(gb, mb_size);
157 
158  return 0;
159 }
160 
161 /**
162  * Decode 4x4 intra types array.
163  */
165 {
166  MpegEncContext *s = &r->s;
167  int i, j, k, v;
168  int A, B, C;
169  int pattern;
170  int8_t *ptr;
171 
172  for(i = 0; i < 4; i++, dst += r->intra_types_stride){
173  if(!i && s->first_slice_line){
174  pattern = get_vlc2(gb, aic_top_vlc, AIC_TOP_BITS, 1);
175  dst[0] = (pattern >> 2) & 2;
176  dst[1] = (pattern >> 1) & 2;
177  dst[2] = pattern & 2;
178  dst[3] = (pattern << 1) & 2;
179  continue;
180  }
181  ptr = dst;
182  for(j = 0; j < 4; j++){
183  /* Coefficients are read using VLC chosen by the prediction pattern
184  * The first one (used for retrieving a pair of coefficients) is
185  * constructed from the top, top right and left coefficients
186  * The second one (used for retrieving only one coefficient) is
187  * top + 10 * left.
188  */
189  A = ptr[-r->intra_types_stride + 1]; // it won't be used for the last coefficient in a row
190  B = ptr[-r->intra_types_stride];
191  C = ptr[-1];
192  pattern = A + B * (1 << 4) + C * (1 << 8);
193  for(k = 0; k < MODE2_PATTERNS_NUM; k++)
194  if(pattern == rv40_aic_table_index[k])
195  break;
196  if(j < 3 && k < MODE2_PATTERNS_NUM){ //pattern is found, decoding 2 coefficients
197  AV_WN16(ptr, get_vlc2(gb, aic_mode2_vlc[k], AIC_MODE2_BITS, 2));
198  ptr += 2;
199  j++;
200  }else{
201  if(B != -1 && C != -1)
202  v = get_vlc2(gb, aic_mode1_vlc[B + C*10], AIC_MODE1_BITS, 1);
203  else{ // tricky decoding
204  v = 0;
205  switch(C){
206  case -1: // code 0 -> 1, 1 -> 0
207  if(B < 2)
208  v = get_bits1(gb) ^ 1;
209  break;
210  case 0:
211  case 2: // code 0 -> 2, 1 -> 0
212  v = (get_bits1(gb) ^ 1) << 1;
213  break;
214  }
215  }
216  *ptr++ = v;
217  }
218  }
219  }
220  return 0;
221 }
222 
223 /**
224  * Decode macroblock information.
225  */
227 {
228  MpegEncContext *s = &r->s;
229  GetBitContext *gb = &s->gb;
230  int q, i;
231  int prev_type = 0;
232  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
233 
234  if(!r->s.mb_skip_run) {
235  r->s.mb_skip_run = get_interleaved_ue_golomb(gb) + 1;
236  if(r->s.mb_skip_run > (unsigned)s->mb_num)
237  return -1;
238  }
239 
240  if(--r->s.mb_skip_run)
241  return RV34_MB_SKIP;
242 
243  if(r->avail_cache[6-4]){
244  int blocks[RV34_MB_TYPES] = {0};
245  int count = 0;
246  if(r->avail_cache[6-1])
247  blocks[r->mb_type[mb_pos - 1]]++;
248  blocks[r->mb_type[mb_pos - s->mb_stride]]++;
249  if(r->avail_cache[6-2])
250  blocks[r->mb_type[mb_pos - s->mb_stride + 1]]++;
251  if(r->avail_cache[6-5])
252  blocks[r->mb_type[mb_pos - s->mb_stride - 1]]++;
253  for(i = 0; i < RV34_MB_TYPES; i++){
254  if(blocks[i] > count){
255  count = blocks[i];
256  prev_type = i;
257  if(count>1)
258  break;
259  }
260  }
261  } else if (r->avail_cache[6-1])
262  prev_type = r->mb_type[mb_pos - 1];
263 
264  if(s->pict_type == AV_PICTURE_TYPE_P){
265  prev_type = block_num_to_ptype_vlc_num[prev_type];
266  q = get_vlc2(gb, ptype_vlc[prev_type], PTYPE_VLC_BITS, 1);
267  if(q < PBTYPE_ESCAPE)
268  return q;
269  q = get_vlc2(gb, ptype_vlc[prev_type], PTYPE_VLC_BITS, 1);
270  av_log(s->avctx, AV_LOG_ERROR, "Dquant for P-frame\n");
271  }else{
272  prev_type = block_num_to_btype_vlc_num[prev_type];
273  q = get_vlc2(gb, btype_vlc[prev_type], BTYPE_VLC_BITS, 1);
274  if(q < PBTYPE_ESCAPE)
275  return q;
276  q = get_vlc2(gb, btype_vlc[prev_type], BTYPE_VLC_BITS, 1);
277  av_log(s->avctx, AV_LOG_ERROR, "Dquant for B-frame\n");
278  }
279  return 0;
280 }
281 
287 };
288 
289 #define MASK_CUR 0x0001
290 #define MASK_RIGHT 0x0008
291 #define MASK_BOTTOM 0x0010
292 #define MASK_TOP 0x1000
293 #define MASK_Y_TOP_ROW 0x000F
294 #define MASK_Y_LAST_ROW 0xF000
295 #define MASK_Y_LEFT_COL 0x1111
296 #define MASK_Y_RIGHT_COL 0x8888
297 #define MASK_C_TOP_ROW 0x0003
298 #define MASK_C_LAST_ROW 0x000C
299 #define MASK_C_LEFT_COL 0x0005
300 #define MASK_C_RIGHT_COL 0x000A
301 
302 static const int neighbour_offs_x[4] = { 0, 0, -1, 0 };
303 static const int neighbour_offs_y[4] = { 0, -1, 0, 1 };
304 
306  uint8_t *src, int stride, int dmode,
307  int lim_q1, int lim_p1,
308  int alpha, int beta, int beta2,
309  int chroma, int edge, int dir)
310 {
311  int filter_p1, filter_q1;
312  int strong;
313  int lims;
314 
315  strong = rdsp->rv40_loop_filter_strength[dir](src, stride, beta, beta2,
316  edge, &filter_p1, &filter_q1);
317 
318  lims = filter_p1 + filter_q1 + ((lim_q1 + lim_p1) >> 1) + 1;
319 
320  if (strong) {
322  lims, dmode, chroma);
323  } else if (filter_p1 & filter_q1) {
324  rdsp->rv40_weak_loop_filter[dir](src, stride, 1, 1, alpha, beta,
325  lims, lim_q1, lim_p1);
326  } else if (filter_p1 | filter_q1) {
327  rdsp->rv40_weak_loop_filter[dir](src, stride, filter_p1, filter_q1,
328  alpha, beta, lims >> 1, lim_q1 >> 1,
329  lim_p1 >> 1);
330  }
331 }
332 
333 /**
334  * RV40 loop filtering function
335  */
336 static void rv40_loop_filter(RV34DecContext *r, int row)
337 {
338  MpegEncContext *s = &r->s;
339  int mb_pos, mb_x;
340  int i, j, k;
341  uint8_t *Y, *C;
342  int alpha, beta, betaY, betaC;
343  int q;
344  int mbtype[4]; ///< current macroblock and its neighbours types
345  /**
346  * flags indicating that macroblock can be filtered with strong filter
347  * it is set only for intra coded MB and MB with DCs coded separately
348  */
349  int mb_strong[4];
350  int clip[4]; ///< MB filter clipping value calculated from filtering strength
351  /**
352  * coded block patterns for luma part of current macroblock and its neighbours
353  * Format:
354  * LSB corresponds to the top left block,
355  * each nibble represents one row of subblocks.
356  */
357  int cbp[4];
358  /**
359  * coded block patterns for chroma part of current macroblock and its neighbours
360  * Format is the same as for luma with two subblocks in a row.
361  */
362  int uvcbp[4][2];
363  /**
364  * This mask represents the pattern of luma subblocks that should be filtered
365  * in addition to the coded ones because they lie at the edge of
366  * 8x8 block with different enough motion vectors
367  */
368  unsigned mvmasks[4];
369 
370  mb_pos = row * s->mb_stride;
371  for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){
372  int mbtype = s->cur_pic.mb_type[mb_pos];
373  if(IS_INTRA(mbtype) || IS_SEPARATE_DC(mbtype))
374  r->cbp_luma [mb_pos] = r->deblock_coefs[mb_pos] = 0xFFFF;
375  if(IS_INTRA(mbtype))
376  r->cbp_chroma[mb_pos] = 0xFF;
377  }
378  mb_pos = row * s->mb_stride;
379  for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){
380  int y_h_deblock, y_v_deblock;
381  int c_v_deblock[2], c_h_deblock[2];
382  int clip_left;
383  int avail[4];
384  unsigned y_to_deblock;
385  int c_to_deblock[2];
386 
387  q = s->cur_pic.qscale_table[mb_pos];
388  alpha = rv40_alpha_tab[q];
389  beta = rv40_beta_tab [q];
390  betaY = betaC = beta * 3;
391  if(s->width * s->height <= 176*144)
392  betaY += beta;
393 
394  avail[0] = 1;
395  avail[1] = row;
396  avail[2] = mb_x;
397  avail[3] = row < s->mb_height - 1;
398  for(i = 0; i < 4; i++){
399  if(avail[i]){
400  int pos = mb_pos + neighbour_offs_x[i] + neighbour_offs_y[i]*s->mb_stride;
401  mvmasks[i] = r->deblock_coefs[pos];
402  mbtype [i] = s->cur_pic.mb_type[pos];
403  cbp [i] = r->cbp_luma[pos];
404  uvcbp[i][0] = r->cbp_chroma[pos] & 0xF;
405  uvcbp[i][1] = r->cbp_chroma[pos] >> 4;
406  }else{
407  mvmasks[i] = 0;
408  mbtype [i] = mbtype[0];
409  cbp [i] = 0;
410  uvcbp[i][0] = uvcbp[i][1] = 0;
411  }
412  mb_strong[i] = IS_INTRA(mbtype[i]) || IS_SEPARATE_DC(mbtype[i]);
413  clip[i] = rv40_filter_clip_tbl[mb_strong[i] + 1][q];
414  }
415  y_to_deblock = mvmasks[POS_CUR]
416  | (mvmasks[POS_BOTTOM] << 16);
417  /* This pattern contains bits signalling that horizontal edges of
418  * the current block can be filtered.
419  * That happens when either of adjacent subblocks is coded or lies on
420  * the edge of 8x8 blocks with motion vectors differing by more than
421  * 3/4 pel in any component (any edge orientation for some reason).
422  */
423  y_h_deblock = y_to_deblock
424  | ((cbp[POS_CUR] << 4) & ~MASK_Y_TOP_ROW)
425  | ((cbp[POS_TOP] & MASK_Y_LAST_ROW) >> 12);
426  /* This pattern contains bits signalling that vertical edges of
427  * the current block can be filtered.
428  * That happens when either of adjacent subblocks is coded or lies on
429  * the edge of 8x8 blocks with motion vectors differing by more than
430  * 3/4 pel in any component (any edge orientation for some reason).
431  */
432  y_v_deblock = y_to_deblock
433  | ((cbp[POS_CUR] << 1) & ~MASK_Y_LEFT_COL)
434  | ((cbp[POS_LEFT] & MASK_Y_RIGHT_COL) >> 3);
435  if(!mb_x)
436  y_v_deblock &= ~MASK_Y_LEFT_COL;
437  if(!row)
438  y_h_deblock &= ~MASK_Y_TOP_ROW;
439  if(row == s->mb_height - 1 || (mb_strong[POS_CUR] | mb_strong[POS_BOTTOM]))
440  y_h_deblock &= ~(MASK_Y_TOP_ROW << 16);
441  /* Calculating chroma patterns is similar and easier since there is
442  * no motion vector pattern for them.
443  */
444  for(i = 0; i < 2; i++){
445  c_to_deblock[i] = (uvcbp[POS_BOTTOM][i] << 4) | uvcbp[POS_CUR][i];
446  c_v_deblock[i] = c_to_deblock[i]
447  | ((uvcbp[POS_CUR] [i] << 1) & ~MASK_C_LEFT_COL)
448  | ((uvcbp[POS_LEFT][i] & MASK_C_RIGHT_COL) >> 1);
449  c_h_deblock[i] = c_to_deblock[i]
450  | ((uvcbp[POS_TOP][i] & MASK_C_LAST_ROW) >> 2)
451  | (uvcbp[POS_CUR][i] << 2);
452  if(!mb_x)
453  c_v_deblock[i] &= ~MASK_C_LEFT_COL;
454  if(!row)
455  c_h_deblock[i] &= ~MASK_C_TOP_ROW;
456  if(row == s->mb_height - 1 || (mb_strong[POS_CUR] | mb_strong[POS_BOTTOM]))
457  c_h_deblock[i] &= ~(MASK_C_TOP_ROW << 4);
458  }
459 
460  for(j = 0; j < 16; j += 4){
461  Y = s->cur_pic.data[0] + mb_x*16 + (row*16 + j) * s->linesize;
462  for(i = 0; i < 4; i++, Y += 4){
463  int ij = i + j;
464  int clip_cur = y_to_deblock & (MASK_CUR << ij) ? clip[POS_CUR] : 0;
465  int dither = j ? ij : i*4;
466 
467  // if bottom block is coded then we can filter its top edge
468  // (or bottom edge of this block, which is the same)
469  if(y_h_deblock & (MASK_BOTTOM << ij)){
470  rv40_adaptive_loop_filter(&r->rdsp, Y+4*s->linesize,
471  s->linesize, dither,
472  y_to_deblock & (MASK_BOTTOM << ij) ? clip[POS_CUR] : 0,
473  clip_cur, alpha, beta, betaY,
474  0, 0, 0);
475  }
476  // filter left block edge in ordinary mode (with low filtering strength)
477  if(y_v_deblock & (MASK_CUR << ij) && (i || !(mb_strong[POS_CUR] | mb_strong[POS_LEFT]))){
478  if(!i)
479  clip_left = mvmasks[POS_LEFT] & (MASK_RIGHT << j) ? clip[POS_LEFT] : 0;
480  else
481  clip_left = y_to_deblock & (MASK_CUR << (ij-1)) ? clip[POS_CUR] : 0;
482  rv40_adaptive_loop_filter(&r->rdsp, Y, s->linesize, dither,
483  clip_cur,
484  clip_left,
485  alpha, beta, betaY, 0, 0, 1);
486  }
487  // filter top edge of the current macroblock when filtering strength is high
488  if(!j && y_h_deblock & (MASK_CUR << i) && (mb_strong[POS_CUR] | mb_strong[POS_TOP])){
489  rv40_adaptive_loop_filter(&r->rdsp, Y, s->linesize, dither,
490  clip_cur,
491  mvmasks[POS_TOP] & (MASK_TOP << i) ? clip[POS_TOP] : 0,
492  alpha, beta, betaY, 0, 1, 0);
493  }
494  // filter left block edge in edge mode (with high filtering strength)
495  if(y_v_deblock & (MASK_CUR << ij) && !i && (mb_strong[POS_CUR] | mb_strong[POS_LEFT])){
496  clip_left = mvmasks[POS_LEFT] & (MASK_RIGHT << j) ? clip[POS_LEFT] : 0;
497  rv40_adaptive_loop_filter(&r->rdsp, Y, s->linesize, dither,
498  clip_cur,
499  clip_left,
500  alpha, beta, betaY, 0, 1, 1);
501  }
502  }
503  }
504  for(k = 0; k < 2; k++){
505  for(j = 0; j < 2; j++){
506  C = s->cur_pic.data[k + 1] + mb_x*8 + (row*8 + j*4) * s->uvlinesize;
507  for(i = 0; i < 2; i++, C += 4){
508  int ij = i + j*2;
509  int clip_cur = c_to_deblock[k] & (MASK_CUR << ij) ? clip[POS_CUR] : 0;
510  if(c_h_deblock[k] & (MASK_CUR << (ij+2))){
511  int clip_bot = c_to_deblock[k] & (MASK_CUR << (ij+2)) ? clip[POS_CUR] : 0;
512  rv40_adaptive_loop_filter(&r->rdsp, C+4*s->uvlinesize, s->uvlinesize, i*8,
513  clip_bot,
514  clip_cur,
515  alpha, beta, betaC, 1, 0, 0);
516  }
517  if((c_v_deblock[k] & (MASK_CUR << ij)) && (i || !(mb_strong[POS_CUR] | mb_strong[POS_LEFT]))){
518  if(!i)
519  clip_left = uvcbp[POS_LEFT][k] & (MASK_CUR << (2*j+1)) ? clip[POS_LEFT] : 0;
520  else
521  clip_left = c_to_deblock[k] & (MASK_CUR << (ij-1)) ? clip[POS_CUR] : 0;
522  rv40_adaptive_loop_filter(&r->rdsp, C, s->uvlinesize, j*8,
523  clip_cur,
524  clip_left,
525  alpha, beta, betaC, 1, 0, 1);
526  }
527  if(!j && c_h_deblock[k] & (MASK_CUR << ij) && (mb_strong[POS_CUR] | mb_strong[POS_TOP])){
528  int clip_top = uvcbp[POS_TOP][k] & (MASK_CUR << (ij+2)) ? clip[POS_TOP] : 0;
529  rv40_adaptive_loop_filter(&r->rdsp, C, s->uvlinesize, i*8,
530  clip_cur,
531  clip_top,
532  alpha, beta, betaC, 1, 1, 0);
533  }
534  if(c_v_deblock[k] & (MASK_CUR << ij) && !i && (mb_strong[POS_CUR] | mb_strong[POS_LEFT])){
535  clip_left = uvcbp[POS_LEFT][k] & (MASK_CUR << (2*j+1)) ? clip[POS_LEFT] : 0;
536  rv40_adaptive_loop_filter(&r->rdsp, C, s->uvlinesize, j*8,
537  clip_cur,
538  clip_left,
539  alpha, beta, betaC, 1, 1, 1);
540  }
541  }
542  }
543  }
544  }
545 }
546 
547 /**
548  * Initialize decoder.
549  */
551 {
552  static AVOnce init_static_once = AV_ONCE_INIT;
553  RV34DecContext *r = avctx->priv_data;
554  int ret;
555 
556  r->rv30 = 0;
557  if ((ret = ff_rv34_decode_init(avctx)) < 0)
558  return ret;
559  r->parse_slice_header = rv40_parse_slice_header;
560  r->decode_intra_types = rv40_decode_intra_types;
561  r->decode_mb_info = rv40_decode_mb_info;
562  r->loop_filter = rv40_loop_filter;
563  r->luma_dc_quant_i = rv40_luma_dc_quant[0];
564  r->luma_dc_quant_p = rv40_luma_dc_quant[1];
565  ff_rv40dsp_init(&r->rdsp);
566  ff_thread_once(&init_static_once, rv40_init_tables);
567  return 0;
568 }
569 
571  .p.name = "rv40",
572  CODEC_LONG_NAME("RealVideo 4.0"),
573  .p.type = AVMEDIA_TYPE_VIDEO,
574  .p.id = AV_CODEC_ID_RV40,
575  .priv_data_size = sizeof(RV34DecContext),
577  .close = ff_rv34_decode_end,
579  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
581  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
582  .flush = ff_mpeg_flush,
584 };
MASK_C_LAST_ROW
#define MASK_C_LAST_ROW
Definition: rv40.c:298
RV34DecContext
decoder context
Definition: rv34.h:86
A
#define A(x)
Definition: vpx_arith.h:28
AIC_MODE1_BITS
#define AIC_MODE1_BITS
Definition: rv40vlc2.h:386
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
rv40_aic_table_index
static const uint16_t rv40_aic_table_index[MODE2_PATTERNS_NUM]
intra types table
Definition: rv40data.h:47
AIC_MODE1_SIZE
#define AIC_MODE1_SIZE
Definition: rv40vlc2.h:385
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:678
r
const char * r
Definition: vf_curves.c:127
ff_rv34_decode_end
av_cold int ff_rv34_decode_end(AVCodecContext *avctx)
Definition: rv34.c:1824
MASK_Y_TOP_ROW
#define MASK_Y_TOP_ROW
Definition: rv40.c:293
rv40_adaptive_loop_filter
static void rv40_adaptive_loop_filter(RV34DSPContext *rdsp, uint8_t *src, int stride, int dmode, int lim_q1, int lim_p1, int alpha, int beta, int beta2, int chroma, int edge, int dir)
Definition: rv40.c:305
aic_mode2_vlc_bits
static const uint8_t aic_mode2_vlc_bits[AIC_MODE2_NUM][AIC_MODE2_SIZE]
Definition: rv40vlc2.h:236
thread.h
ff_rv34_get_start_offset
int ff_rv34_get_start_offset(GetBitContext *gb, int mb_size)
Decode starting slice position.
Definition: rv34.c:339
get_interleaved_ue_golomb
static unsigned get_interleaved_ue_golomb(GetBitContext *gb)
Definition: golomb.h:143
w
uint8_t w
Definition: llviddspenc.c:38
ff_rv34_decode_update_thread_context
int ff_rv34_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: rv34.c:1538
chroma
static av_always_inline void chroma(WaveformContext *s, AVFrame *in, AVFrame *out, int component, int intensity, int offset_y, int offset_x, int column, int mirror, int jobnr, int nb_jobs)
Definition: vf_waveform.c:1639
rv40_loop_filter
static void rv40_loop_filter(RV34DecContext *r, int row)
RV40 loop filtering function.
Definition: rv40.c:336
AIC_MODE2_SIZE
#define AIC_MODE2_SIZE
Definition: rv40vlc2.h:50
PTYPE_VLC_SIZE
#define PTYPE_VLC_SIZE
Definition: rv40vlc2.h:569
FFCodec
Definition: codec_internal.h:127
mpegvideo.h
RV40BlockPos
RV40BlockPos
Definition: rv40.c:282
mpegutils.h
aic_mode2_vlc_syms
static const uint8_t aic_mode2_vlc_syms[AIC_MODE2_NUM][AIC_MODE2_SIZE]
Definition: rv40vlc2.h:53
MASK_Y_RIGHT_COL
#define MASK_Y_RIGHT_COL
Definition: rv40.c:296
MASK_BOTTOM
#define MASK_BOTTOM
Definition: rv40.c:291
rv40_standard_heights
static const int rv40_standard_heights[]
Definition: rv40data.h:37
MASK_C_LEFT_COL
#define MASK_C_LEFT_COL
Definition: rv40.c:299
golomb.h
exp golomb vlc stuff
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:318
rv40_decode_init
static av_cold int rv40_decode_init(AVCodecContext *avctx)
Initialize decoder.
Definition: rv40.c:550
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
MODE2_PATTERNS_NUM
#define MODE2_PATTERNS_NUM
Definition: rv40data.h:40
ptype_vlc
static const VLCElem * ptype_vlc[NUM_PTYPE_VLCS]
Definition: rv40.c:45
GetBitContext
Definition: get_bits.h:108
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:10345
val
static double val(void *priv, double ch)
Definition: aeval.c:77
MASK_Y_LEFT_COL
#define MASK_Y_LEFT_COL
Definition: rv40.c:295
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
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:205
mpegvideodec.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
AIC_MODE2_NUM
#define AIC_MODE2_NUM
codes used for determining a pair of block types
Definition: rv40vlc2.h:49
av_cold
#define av_cold
Definition: attributes.h:90
ff_rv34_decode_init
av_cold int ff_rv34_decode_init(AVCodecContext *avctx)
Initialize decoder.
Definition: rv34.c:1508
rv40_init_tables
static av_cold void rv40_init_tables(void)
Initialize all tables.
Definition: rv40.c:58
VLCInitState
For static VLCs, the number of bits can often be hardcoded at each get_vlc2() callsite.
Definition: vlc.h:212
clip
clip
Definition: af_crystalizer.c:122
POS_TOP
@ POS_TOP
Definition: rv40.c:284
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:311
s
#define s(width, name)
Definition: cbs_vp9.c:198
rv40_parse_slice_header
static int rv40_parse_slice_header(RV34DecContext *r, GetBitContext *gb, SliceInfo *si)
Definition: rv40.c:132
RV34DSPContext::rv40_loop_filter_strength
rv40_loop_filter_strength_func rv40_loop_filter_strength[2]
Definition: rv34dsp.h:74
B
#define B
Definition: huffyuv.h:42
btype_vlc
static const VLCElem * btype_vlc[NUM_BTYPE_VLCS]
Definition: rv40.c:45
rv40_parse_picture_size
static void rv40_parse_picture_size(GetBitContext *gb, int *w, int *h)
Get encoded picture size - usually this is called from rv40_parse_slice_header.
Definition: rv40.c:126
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:296
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:110
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
RV34_MB_SKIP
@ RV34_MB_SKIP
Skipped block.
Definition: rv34.h:51
MASK_CUR
#define MASK_CUR
Definition: rv40.c:289
AIC_MODE2_BITS
#define AIC_MODE2_BITS
Definition: rv40vlc2.h:51
SliceInfo::type
int type
slice type (intra, inter)
Definition: rv34.h:76
PTYPE_VLC_BITS
#define PTYPE_VLC_BITS
Definition: rv40vlc2.h:570
ff_rv40_decoder
const FFCodec ff_rv40_decoder
Definition: rv40.c:570
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:371
rv40data.h
BTYPE_VLC_SIZE
#define BTYPE_VLC_SIZE
Definition: rv40vlc2.h:597
UPDATE_THREAD_CONTEXT
#define UPDATE_THREAD_CONTEXT(func)
Definition: codec_internal.h:305
NUM_BTYPE_VLCS
#define NUM_BTYPE_VLCS
tables used for P-frame macroblock type decoding
Definition: rv40vlc2.h:596
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:635
rv34.h
AVOnce
#define AVOnce
Definition: thread.h:202
rv40_decode_intra_types
static int rv40_decode_intra_types(RV34DecContext *r, GetBitContext *gb, int8_t *dst)
Decode 4x4 intra types array.
Definition: rv40.c:164
SliceInfo::quant
int quant
quantizer used for this slice
Definition: rv34.h:77
rv40_init_table
static const av_cold VLCElem * rv40_init_table(VLCInitState *state, int nb_bits, int nb_codes, const uint8_t(*tab)[2])
Definition: rv40.c:47
RV34DSPContext
Definition: rv34dsp.h:57
IS_INTRA
#define IS_INTRA(x, y)
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
SliceInfo::vlc_set
int vlc_set
VLCs used for this slice.
Definition: rv34.h: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
state
static struct @474 state
codec_internal.h
ff_rv34_decode_frame
int ff_rv34_decode_frame(AVCodecContext *avctx, AVFrame *pict, int *got_picture_ptr, AVPacket *avpkt)
Definition: rv34.c:1618
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
rv40_decode_mb_info
static int rv40_decode_mb_info(RV34DecContext *r)
Decode macroblock information.
Definition: rv40.c:226
VLCElem
Definition: vlc.h:32
PBTYPE_ESCAPE
#define PBTYPE_ESCAPE
Definition: rv40vlc2.h:564
rv40_alpha_tab
static const uint8_t rv40_alpha_tab[32]
alpha parameter for RV40 loop filter - almost the same as in JVT-A003r1
Definition: rv40data.h:73
rv40_standard_widths
static const int rv40_standard_widths[]
standard widths and heights coded in RV40
Definition: rv40data.h:36
BTYPE_VLC_BITS
#define BTYPE_VLC_BITS
Definition: rv40vlc2.h:598
MASK_Y_LAST_ROW
#define MASK_Y_LAST_ROW
Definition: rv40.c:294
ff_mpeg_flush
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo_dec.c:430
SliceInfo::pts
int pts
frame timestamp
Definition: rv34.h:82
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:396
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:37
get_dimension
static int get_dimension(GetBitContext *gb, const int *dim)
Get stored dimension from bitstream.
Definition: rv40.c:106
RV34DSPContext::rv40_strong_loop_filter
rv40_strong_loop_filter_func rv40_strong_loop_filter[2]
Definition: rv34dsp.h:73
SliceInfo::height
int height
coded height
Definition: rv34.h: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:121
POS_LEFT
@ POS_LEFT
Definition: rv40.c:285
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
rv40_beta_tab
static const uint8_t rv40_beta_tab[32]
beta parameter for RV40 loop filter - almost the same as in JVT-A003r1
Definition: rv40data.h:80
aic_mode2_vlc
static const VLCElem * aic_mode2_vlc[AIC_MODE2_NUM]
Definition: rv40.c:44
RV34_MB_TYPES
@ RV34_MB_TYPES
Definition: rv34.h:57
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
SliceInfo
essential slice information
Definition: rv34.h:75
avcodec.h
stride
#define stride
Definition: h264pred_template.c:536
MASK_TOP
#define MASK_TOP
Definition: rv40.c:292
MASK_RIGHT
#define MASK_RIGHT
Definition: rv40.c:290
dim
int dim
Definition: vorbis_enc_data.h:425
POS_BOTTOM
@ POS_BOTTOM
Definition: rv40.c:286
ret
ret
Definition: filter_design.txt:187
pos
unsigned int pos
Definition: spdifenc.c:414
AIC_TOP_SIZE
#define AIC_TOP_SIZE
Definition: rv40vlc2.h:37
block_num_to_btype_vlc_num
static const uint8_t block_num_to_btype_vlc_num[12]
Definition: rv40vlc2.h:615
neighbour_offs_y
static const int neighbour_offs_y[4]
Definition: rv40.c:303
AVCodecContext
main external API structure.
Definition: avcodec.h:451
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
IS_SEPARATE_DC
#define IS_SEPARATE_DC(a)
Definition: rv34.h:39
rv40vlc2.h
aic_top_vlc
static VLCElem aic_top_vlc[23590]
Definition: rv40.c:43
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:76
ff_vlc_init_tables_from_lengths
const av_cold VLCElem * ff_vlc_init_tables_from_lengths(VLCInitState *state, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags)
Definition: vlc.c:366
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
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
MASK_C_RIGHT_COL
#define MASK_C_RIGHT_COL
Definition: rv40.c:300
VLC_INIT_STATE
#define VLC_INIT_STATE(_table)
Definition: vlc.h:217
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
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:302
aic_mode1_vlc
static const VLCElem * aic_mode1_vlc[AIC_MODE1_NUM]
Definition: rv40.c:44
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:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
h
h
Definition: vp9dsp_template.c:2070
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:318
MASK_C_TOP_ROW
#define MASK_C_TOP_ROW
Definition: rv40.c:297
ff_rv40dsp_init
void ff_rv40dsp_init(RV34DSPContext *c)
Definition: rv40dsp.c:619
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:73
ptype_vlc_tabs
static const uint8_t ptype_vlc_tabs[NUM_PTYPE_VLCS][PTYPE_VLC_SIZE][2]
Definition: rv40vlc2.h:572
src
#define src
Definition: vp8dsp.c:248
POS_CUR
@ POS_CUR
Definition: rv40.c:283
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:368
dither
static const uint8_t dither[8][8]
Definition: vf_fspp.c:62