FFmpeg  4.4
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  return 0;
571 }
572 
574  .name = "rv40",
575  .long_name = NULL_IF_CONFIG_SMALL("RealVideo 4.0"),
576  .type = AVMEDIA_TYPE_VIDEO,
577  .id = AV_CODEC_ID_RV40,
578  .priv_data_size = sizeof(RV34DecContext),
580  .close = ff_rv34_decode_end,
582  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
584  .flush = ff_mpeg_flush,
585  .pix_fmts = (const enum AVPixelFormat[]) {
588  },
590  .caps_internal = FF_CODEC_CAP_ALLOCATE_PROGRESS,
591 };
static void flush(AVCodecContext *avctx)
static double val(void *priv, double ch)
Definition: aeval.c:76
#define A(x)
Definition: vp56_arith.h:28
#define av_cold
Definition: attributes.h:88
uint8_t
Libavcodec external API header.
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
int ff_init_vlc_from_lengths(VLC *vlc_arg, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags, void *logctx)
Build VLC decoding tables suitable for use with get_vlc2()
Definition: bitstream.c:381
#define Y
Definition: boxblur.h:38
#define s(width, name)
Definition: cbs_vp9.c:257
static VLC_TYPE vlc_buf[16716][2]
Definition: clearvideo.c:86
#define HAVE_BIGENDIAN
Definition: config.h:200
#define NULL
Definition: coverity.c:32
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
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 int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
exp golomb vlc stuff
static unsigned get_interleaved_ue_golomb(GetBitContext *gb)
Definition: golomb.h:145
#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
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:108
@ AV_CODEC_ID_RV40
Definition: codec_id.h:118
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:317
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
#define IS_INTRA(x, y)
#define B
Definition: huffyuvdsp.h:32
static const int16_t alpha[]
Definition: ilbcdata.h:55
misc image utilities
int i
Definition: input.c:407
#define AV_WN16(p, v)
Definition: intreadwrite.h:372
#define C
#define FF_CODEC_CAP_ALLOCATE_PROGRESS
Definition: internal.h:76
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:156
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:303
uint8_t w
Definition: llviddspenc.c:39
int stride
Definition: mace.c:144
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo.c:2300
mpegvideo header.
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
static const uint16_t table[]
Definition: prosumer.c:206
av_cold int ff_rv34_decode_end(AVCodecContext *avctx)
Definition: rv34.c:1816
int ff_rv34_get_start_offset(GetBitContext *gb, int mb_size)
Decode starting slice position.
Definition: rv34.c:322
int ff_rv34_decode_frame(AVCodecContext *avctx, void *data, int *got_picture_ptr, AVPacket *avpkt)
Definition: rv34.c:1606
av_cold int ff_rv34_decode_init(AVCodecContext *avctx)
Initialize decoder.
Definition: rv34.c:1486
int ff_rv34_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: rv34.c:1525
RV30 and RV40 decoder common data declarations.
#define IS_SEPARATE_DC(a)
Definition: rv34.h:39
@ RV34_MB_TYPES
Definition: rv34.h:57
@ RV34_MB_SKIP
Skipped block.
Definition: rv34.h:51
static int rv40_decode_mb_info(RV34DecContext *r)
Decode macroblock information.
Definition: rv40.c:230
static void rv40_loop_filter(RV34DecContext *r, int row)
RV40 loop filtering function.
Definition: rv40.c:340
static VLC aic_top_vlc
Definition: rv40.c:40
#define MASK_RIGHT
Definition: rv40.c:294
#define MASK_C_LAST_ROW
Definition: rv40.c:302
static int rv40_decode_intra_types(RV34DecContext *r, GetBitContext *gb, int8_t *dst)
Decode 4x4 intra types array.
Definition: rv40.c:168
static av_cold int rv40_decode_init(AVCodecContext *avctx)
Initialize decoder.
Definition: rv40.c:554
static VLC aic_mode2_vlc[AIC_MODE2_NUM]
Definition: rv40.c:41
static const int neighbour_offs_x[4]
Definition: rv40.c:306
#define MASK_C_LEFT_COL
Definition: rv40.c:303
static av_cold void rv40_init_tables(void)
Initialize all tables.
Definition: rv40.c:61
static VLC ptype_vlc[NUM_PTYPE_VLCS]
Definition: rv40.c:42
static const int neighbour_offs_y[4]
Definition: rv40.c:307
#define MASK_TOP
Definition: rv40.c:296
#define MASK_Y_TOP_ROW
Definition: rv40.c:297
#define MASK_Y_LEFT_COL
Definition: rv40.c:299
RV40BlockPos
Definition: rv40.c:286
@ POS_LEFT
Definition: rv40.c:289
@ POS_BOTTOM
Definition: rv40.c:290
@ POS_CUR
Definition: rv40.c:287
@ POS_TOP
Definition: rv40.c:288
#define MASK_BOTTOM
Definition: rv40.c:295
AVCodec ff_rv40_decoder
Definition: rv40.c:573
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
#define MASK_Y_LAST_ROW
Definition: rv40.c:298
#define MASK_C_TOP_ROW
Definition: rv40.c:301
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
static VLC aic_mode1_vlc[AIC_MODE1_NUM]
Definition: rv40.c:41
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
static VLC btype_vlc[NUM_BTYPE_VLCS]
Definition: rv40.c:42
#define MASK_Y_RIGHT_COL
Definition: rv40.c:300
#define MASK_C_RIGHT_COL
Definition: rv40.c:304
static int get_dimension(GetBitContext *gb, const int *dim)
Get stored dimension from bitstream.
Definition: rv40.c:108
#define MASK_CUR
Definition: rv40.c:293
static int rv40_parse_slice_header(RV34DecContext *r, GetBitContext *gb, SliceInfo *si)
Definition: rv40.c:134
miscellaneous RV40 tables
#define MODE2_PATTERNS_NUM
Definition: rv40data.h:40
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
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
static const uint16_t rv40_aic_table_index[MODE2_PATTERNS_NUM]
intra types table
Definition: rv40data.h:47
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 const int rv40_standard_heights[]
Definition: rv40data.h:37
static const uint8_t rv40_beta_tab[32]
beta parameter for RV40 loop filter - almost the same as in JVT-A003r1
Definition: rv40data.h:80
static const int rv40_standard_widths[]
standard widths and heights coded in RV40
Definition: rv40data.h:36
RV40 VLC tables used for macroblock information decoding.
static const uint8_t ptype_vlc_tabs[NUM_PTYPE_VLCS][PTYPE_VLC_SIZE][2]
Definition: rv40vlc2.h:572
#define NUM_PTYPE_VLCS
tables used for P-frame macroblock type decoding
Definition: rv40vlc2.h:568
#define BTYPE_VLC_SIZE
Definition: rv40vlc2.h:597
#define PTYPE_VLC_BITS
Definition: rv40vlc2.h:570
#define AIC_TOP_SIZE
Definition: rv40vlc2.h:37
#define AIC_MODE2_NUM
codes used for determining a pair of block types
Definition: rv40vlc2.h:49
static const uint8_t aic_mode2_vlc_syms[AIC_MODE2_NUM][AIC_MODE2_SIZE]
Definition: rv40vlc2.h:53
#define BTYPE_VLC_BITS
Definition: rv40vlc2.h:598
#define PTYPE_VLC_SIZE
Definition: rv40vlc2.h:569
static const uint8_t aic_mode1_vlc_tabs[AIC_MODE1_NUM][AIC_MODE1_SIZE][2]
Definition: rv40vlc2.h:388
#define AIC_MODE2_BITS
Definition: rv40vlc2.h:51
#define PBTYPE_ESCAPE
Definition: rv40vlc2.h:564
#define AIC_MODE1_BITS
Definition: rv40vlc2.h:386
#define AIC_MODE1_NUM
Codes used for determining block type.
Definition: rv40vlc2.h:384
static const uint8_t rv40_aic_top_vlc_tab[AIC_TOP_SIZE][2]
Definition: rv40vlc2.h:38
static const uint8_t btype_vlc_tabs[NUM_BTYPE_VLCS][BTYPE_VLC_SIZE][2]
Definition: rv40vlc2.h:600
#define AIC_MODE1_SIZE
Definition: rv40vlc2.h:385
#define AIC_TOP_BITS
codes used for the first four block types
Definition: rv40vlc2.h:36
static const uint8_t block_num_to_ptype_vlc_num[12]
Definition: rv40vlc2.h:589
static const uint8_t block_num_to_btype_vlc_num[12]
Definition: rv40vlc2.h:615
static const uint8_t aic_mode2_vlc_bits[AIC_MODE2_NUM][AIC_MODE2_SIZE]
Definition: rv40vlc2.h:236
#define NUM_BTYPE_VLCS
tables used for P-frame macroblock type decoding
Definition: rv40vlc2.h:596
#define AIC_MODE2_SIZE
Definition: rv40vlc2.h:50
#define FF_ARRAY_ELEMS(a)
unsigned int pos
Definition: spdifenc.c:412
main external API structure.
Definition: avcodec.h:536
void * priv_data
Definition: avcodec.h:563
AVCodec.
Definition: codec.h:197
const char * name
Name of the codec implementation.
Definition: codec.h:204
MpegEncContext.
Definition: mpegvideo.h:81
rv40_loop_filter_strength_func rv40_loop_filter_strength[2]
Definition: rv34dsp.h:74
rv40_strong_loop_filter_func rv40_strong_loop_filter[2]
Definition: rv34dsp.h:73
rv40_weak_loop_filter_func rv40_weak_loop_filter[2]
Definition: rv34dsp.h:72
decoder context
Definition: rv34.h:86
essential slice information
Definition: rv34.h:75
int vlc_set
VLCs used for this slice.
Definition: rv34.h:78
int pts
frame timestamp
Definition: rv34.h:82
int start
Definition: rv34.h:79
int width
coded width
Definition: rv34.h:80
int height
coded height
Definition: rv34.h:81
int quant
quantizer used for this slice
Definition: rv34.h:77
int type
slice type (intra, inter)
Definition: rv34.h:76
Definition: vlc.h:26
int table_size
Definition: vlc.h:29
int table_allocated
Definition: vlc.h:29
int bits
Definition: vlc.h:27
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
#define av_log(a,...)
#define src
Definition: vp8dsp.c:255
static const struct twinvq_data tab
const char * r
Definition: vf_curves.c:116
static const uint8_t dither[8][8]
Definition: vf_fspp.c:59
static double clip(void *opaque, double val)
Clip value val in the minval - maxval range.
Definition: vf_lut.c:162
static const uint8_t offset[127][2]
Definition: vf_spp.c:107
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
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:95
#define INIT_VLC_STATIC_OVERLONG
Definition: vlc.h:96
#define VLC_TYPE
Definition: vlc.h:24
int dim