FFmpeg
rv34.c
Go to the documentation of this file.
1 /*
2  * RV30/40 decoder common data
3  * Copyright (c) 2007 Mike Melanson, 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  * RV30/40 decoder common data
25  */
26 
27 #include "libavutil/avassert.h"
28 #include "libavutil/imgutils.h"
29 #include "libavutil/internal.h"
30 #include "libavutil/mem_internal.h"
31 #include "libavutil/thread.h"
33 
34 #include "avcodec.h"
35 #include "error_resilience.h"
36 #include "mpegutils.h"
37 #include "mpegvideo.h"
38 #include "golomb.h"
39 #include "internal.h"
40 #include "mathops.h"
41 #include "mpeg_er.h"
42 #include "qpeldsp.h"
43 #include "rectangle.h"
44 #include "thread.h"
45 
46 #include "rv34vlc.h"
47 #include "rv34data.h"
48 #include "rv34.h"
49 
50 static inline void ZERO8x2(void* dst, int stride)
51 {
52  fill_rectangle(dst, 1, 2, stride, 0, 4);
53  fill_rectangle(((uint8_t*)(dst))+4, 1, 2, stride, 0, 4);
54 }
55 
56 /** translation of RV30/40 macroblock types to lavc ones */
57 static const int rv34_mb_type_to_lavc[12] = {
70 };
71 
72 
74 
75 static int rv34_decode_mv(RV34DecContext *r, int block_type);
76 
77 /**
78  * @name RV30/40 VLC generating functions
79  * @{
80  */
81 
82 static VLC_TYPE table_data[117592][2];
83 
84 /**
85  * Generate VLC from codeword lengths.
86  * @param bits codeword lengths (zeroes are accepted)
87  * @param size length of input data
88  * @param vlc output VLC
89  * @param insyms symbols for input codes (NULL for default ones)
90  * @param num VLC table number (for static initialization)
91  */
92 static void rv34_gen_vlc(const uint8_t *bits, int size, VLC *vlc, const uint8_t *syms,
93  int *offset)
94 {
95  int counts[17] = {0}, codes[17];
96  uint16_t cw[MAX_VLC_SIZE];
97  int maxbits;
98 
99  for (int i = 0; i < size; i++)
100  counts[bits[i]]++;
101 
102  /* bits[0] is zero for some tables, i.e. syms actually starts at 1.
103  * So we reset it here. The code assigned to this element is 0x00. */
104  codes[0] = counts[0] = 0;
105  for (int i = 0; i < 16; i++) {
106  codes[i+1] = (codes[i] + counts[i]) << 1;
107  if (counts[i])
108  maxbits = i;
109  }
110  for (int i = 0; i < size; i++)
111  cw[i] = codes[bits[i]]++;
112 
113  vlc->table = &table_data[*offset];
115  ff_init_vlc_sparse(vlc, FFMIN(maxbits, 9), size,
116  bits, 1, 1,
117  cw, 2, 2,
118  syms, !!syms, !!syms, INIT_VLC_STATIC_OVERLONG);
119  *offset += vlc->table_size;
120 }
121 
122 /**
123  * Initialize all tables.
124  */
125 static av_cold void rv34_init_tables(void)
126 {
127  int i, j, k, offset = 0;
128 
129  for(i = 0; i < NUM_INTRA_TABLES; i++){
130  for(j = 0; j < 2; j++){
132  &intra_vlcs[i].cbppattern[j], NULL, &offset);
134  &intra_vlcs[i].second_pattern[j], NULL, &offset);
136  &intra_vlcs[i].third_pattern[j], NULL, &offset);
137  for(k = 0; k < 4; k++){
139  &intra_vlcs[i].cbp[j][k], rv34_cbp_code, &offset);
140  }
141  }
142  for(j = 0; j < 4; j++){
144  &intra_vlcs[i].first_pattern[j], NULL, &offset);
145  }
147  &intra_vlcs[i].coefficient, NULL, &offset);
148  }
149 
150  for(i = 0; i < NUM_INTER_TABLES; i++){
152  &inter_vlcs[i].cbppattern[0], NULL, &offset);
153  for(j = 0; j < 4; j++){
155  &inter_vlcs[i].cbp[0][j], rv34_cbp_code, &offset);
156  }
157  for(j = 0; j < 2; j++){
159  &inter_vlcs[i].first_pattern[j], NULL, &offset);
161  &inter_vlcs[i].second_pattern[j], NULL, &offset);
163  &inter_vlcs[i].third_pattern[j], NULL, &offset);
164  }
166  &inter_vlcs[i].coefficient, NULL, &offset);
167  }
168 }
169 
170 /** @} */ // vlc group
171 
172 /**
173  * @name RV30/40 4x4 block decoding functions
174  * @{
175  */
176 
177 /**
178  * Decode coded block pattern.
179  */
180 static int rv34_decode_cbp(GetBitContext *gb, RV34VLC *vlc, int table)
181 {
182  int pattern, code, cbp=0;
183  int ones;
184  static const int cbp_masks[3] = {0x100000, 0x010000, 0x110000};
185  static const int shifts[4] = { 0, 2, 8, 10 };
186  const int *curshift = shifts;
187  int i, t, mask;
188 
189  code = get_vlc2(gb, vlc->cbppattern[table].table, 9, 2);
190  pattern = code & 0xF;
191  code >>= 4;
192 
193  ones = rv34_count_ones[pattern];
194 
195  for(mask = 8; mask; mask >>= 1, curshift++){
196  if(pattern & mask)
197  cbp |= get_vlc2(gb, vlc->cbp[table][ones].table, vlc->cbp[table][ones].bits, 1) << curshift[0];
198  }
199 
200  for(i = 0; i < 4; i++){
201  t = (modulo_three_table[code] >> (6 - 2*i)) & 3;
202  if(t == 1)
203  cbp |= cbp_masks[get_bits1(gb)] << i;
204  if(t == 2)
205  cbp |= cbp_masks[2] << i;
206  }
207  return cbp;
208 }
209 
210 /**
211  * Get one coefficient value from the bitstream and store it.
212  */
213 static inline void decode_coeff(int16_t *dst, int coef, int esc, GetBitContext *gb, VLC* vlc, int q)
214 {
215  if(coef){
216  if(coef == esc){
217  coef = get_vlc2(gb, vlc->table, 9, 2);
218  if(coef > 23){
219  coef -= 23;
220  coef = 22 + ((1 << coef) | get_bits(gb, coef));
221  }
222  coef += esc;
223  }
224  if(get_bits1(gb))
225  coef = -coef;
226  *dst = (coef*q + 8) >> 4;
227  }
228 }
229 
230 /**
231  * Decode 2x2 subblock of coefficients.
232  */
233 static inline void decode_subblock(int16_t *dst, int code, const int is_block2, GetBitContext *gb, VLC *vlc, int q)
234 {
236 
237  decode_coeff( dst+0*4+0, (flags >> 6) , 3, gb, vlc, q);
238  if(is_block2){
239  decode_coeff(dst+1*4+0, (flags >> 4) & 3, 2, gb, vlc, q);
240  decode_coeff(dst+0*4+1, (flags >> 2) & 3, 2, gb, vlc, q);
241  }else{
242  decode_coeff(dst+0*4+1, (flags >> 4) & 3, 2, gb, vlc, q);
243  decode_coeff(dst+1*4+0, (flags >> 2) & 3, 2, gb, vlc, q);
244  }
245  decode_coeff( dst+1*4+1, (flags >> 0) & 3, 2, gb, vlc, q);
246 }
247 
248 /**
249  * Decode a single coefficient.
250  */
251 static inline void decode_subblock1(int16_t *dst, int code, GetBitContext *gb, VLC *vlc, int q)
252 {
253  int coeff = modulo_three_table[code] >> 6;
254  decode_coeff(dst, coeff, 3, gb, vlc, q);
255 }
256 
257 static inline void decode_subblock3(int16_t *dst, int code, GetBitContext *gb, VLC *vlc,
258  int q_dc, int q_ac1, int q_ac2)
259 {
261 
262  decode_coeff(dst+0*4+0, (flags >> 6) , 3, gb, vlc, q_dc);
263  decode_coeff(dst+0*4+1, (flags >> 4) & 3, 2, gb, vlc, q_ac1);
264  decode_coeff(dst+1*4+0, (flags >> 2) & 3, 2, gb, vlc, q_ac1);
265  decode_coeff(dst+1*4+1, (flags >> 0) & 3, 2, gb, vlc, q_ac2);
266 }
267 
268 /**
269  * Decode coefficients for 4x4 block.
270  *
271  * This is done by filling 2x2 subblocks with decoded coefficients
272  * in this order (the same for subblocks and subblock coefficients):
273  * o--o
274  * /
275  * /
276  * o--o
277  */
278 
279 static int rv34_decode_block(int16_t *dst, GetBitContext *gb, RV34VLC *rvlc, int fc, int sc, int q_dc, int q_ac1, int q_ac2)
280 {
281  int code, pattern, has_ac = 1;
282 
283  code = get_vlc2(gb, rvlc->first_pattern[fc].table, 9, 2);
284 
285  pattern = code & 0x7;
286 
287  code >>= 3;
288 
289  if (modulo_three_table[code] & 0x3F) {
290  decode_subblock3(dst, code, gb, &rvlc->coefficient, q_dc, q_ac1, q_ac2);
291  } else {
292  decode_subblock1(dst, code, gb, &rvlc->coefficient, q_dc);
293  if (!pattern)
294  return 0;
295  has_ac = 0;
296  }
297 
298  if(pattern & 4){
299  code = get_vlc2(gb, rvlc->second_pattern[sc].table, 9, 2);
300  decode_subblock(dst + 4*0+2, code, 0, gb, &rvlc->coefficient, q_ac2);
301  }
302  if(pattern & 2){ // Looks like coefficients 1 and 2 are swapped for this block
303  code = get_vlc2(gb, rvlc->second_pattern[sc].table, 9, 2);
304  decode_subblock(dst + 4*2+0, code, 1, gb, &rvlc->coefficient, q_ac2);
305  }
306  if(pattern & 1){
307  code = get_vlc2(gb, rvlc->third_pattern[sc].table, 9, 2);
308  decode_subblock(dst + 4*2+2, code, 0, gb, &rvlc->coefficient, q_ac2);
309  }
310  return has_ac | pattern;
311 }
312 
313 /**
314  * @name RV30/40 bitstream parsing
315  * @{
316  */
317 
318 /**
319  * Decode starting slice position.
320  * @todo Maybe replace with ff_h263_decode_mba() ?
321  */
323 {
324  int i;
325  for(i = 0; i < 5; i++)
326  if(rv34_mb_max_sizes[i] >= mb_size - 1)
327  break;
328  return rv34_mb_bits_sizes[i];
329 }
330 
331 /**
332  * Select VLC set for decoding from current quantizer, modifier and frame type.
333  */
334 static inline RV34VLC* choose_vlc_set(int quant, int mod, int type)
335 {
336  if(mod == 2 && quant < 19) quant += 10;
337  else if(mod && quant < 26) quant += 5;
338  av_assert2(quant >= 0 && quant < 32);
341 }
342 
343 /**
344  * Decode intra macroblock header and return CBP in case of success, -1 otherwise.
345  */
346 static int rv34_decode_intra_mb_header(RV34DecContext *r, int8_t *intra_types)
347 {
348  MpegEncContext *s = &r->s;
349  GetBitContext *gb = &s->gb;
350  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
351  int t;
352 
353  r->is16 = get_bits1(gb);
354  if(r->is16){
355  s->current_picture_ptr->mb_type[mb_pos] = MB_TYPE_INTRA16x16;
356  r->block_type = RV34_MB_TYPE_INTRA16x16;
357  t = get_bits(gb, 2);
358  fill_rectangle(intra_types, 4, 4, r->intra_types_stride, t, sizeof(intra_types[0]));
359  r->luma_vlc = 2;
360  }else{
361  if(!r->rv30){
362  if(!get_bits1(gb))
363  av_log(s->avctx, AV_LOG_ERROR, "Need DQUANT\n");
364  }
365  s->current_picture_ptr->mb_type[mb_pos] = MB_TYPE_INTRA;
366  r->block_type = RV34_MB_TYPE_INTRA;
367  if(r->decode_intra_types(r, gb, intra_types) < 0)
368  return -1;
369  r->luma_vlc = 1;
370  }
371 
372  r->chroma_vlc = 0;
373  r->cur_vlcs = choose_vlc_set(r->si.quant, r->si.vlc_set, 0);
374 
375  return rv34_decode_cbp(gb, r->cur_vlcs, r->is16);
376 }
377 
378 /**
379  * Decode inter macroblock header and return CBP in case of success, -1 otherwise.
380  */
381 static int rv34_decode_inter_mb_header(RV34DecContext *r, int8_t *intra_types)
382 {
383  MpegEncContext *s = &r->s;
384  GetBitContext *gb = &s->gb;
385  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
386  int i, t;
387 
388  r->block_type = r->decode_mb_info(r);
389  if(r->block_type == -1)
390  return -1;
391  s->current_picture_ptr->mb_type[mb_pos] = rv34_mb_type_to_lavc[r->block_type];
392  r->mb_type[mb_pos] = r->block_type;
393  if(r->block_type == RV34_MB_SKIP){
394  if(s->pict_type == AV_PICTURE_TYPE_P)
395  r->mb_type[mb_pos] = RV34_MB_P_16x16;
396  if(s->pict_type == AV_PICTURE_TYPE_B)
397  r->mb_type[mb_pos] = RV34_MB_B_DIRECT;
398  }
399  r->is16 = !!IS_INTRA16x16(s->current_picture_ptr->mb_type[mb_pos]);
400  if (rv34_decode_mv(r, r->block_type) < 0)
401  return -1;
402  if(r->block_type == RV34_MB_SKIP){
403  fill_rectangle(intra_types, 4, 4, r->intra_types_stride, 0, sizeof(intra_types[0]));
404  return 0;
405  }
406  r->chroma_vlc = 1;
407  r->luma_vlc = 0;
408 
409  if(IS_INTRA(s->current_picture_ptr->mb_type[mb_pos])){
410  if(r->is16){
411  t = get_bits(gb, 2);
412  fill_rectangle(intra_types, 4, 4, r->intra_types_stride, t, sizeof(intra_types[0]));
413  r->luma_vlc = 2;
414  }else{
415  if(r->decode_intra_types(r, gb, intra_types) < 0)
416  return -1;
417  r->luma_vlc = 1;
418  }
419  r->chroma_vlc = 0;
420  r->cur_vlcs = choose_vlc_set(r->si.quant, r->si.vlc_set, 0);
421  }else{
422  for(i = 0; i < 16; i++)
423  intra_types[(i & 3) + (i>>2) * r->intra_types_stride] = 0;
424  r->cur_vlcs = choose_vlc_set(r->si.quant, r->si.vlc_set, 1);
425  if(r->mb_type[mb_pos] == RV34_MB_P_MIX16x16){
426  r->is16 = 1;
427  r->chroma_vlc = 1;
428  r->luma_vlc = 2;
429  r->cur_vlcs = choose_vlc_set(r->si.quant, r->si.vlc_set, 0);
430  }
431  }
432 
433  return rv34_decode_cbp(gb, r->cur_vlcs, r->is16);
434 }
435 
436 /** @} */ //bitstream functions
437 
438 /**
439  * @name motion vector related code (prediction, reconstruction, motion compensation)
440  * @{
441  */
442 
443 /** macroblock partition width in 8x8 blocks */
444 static const uint8_t part_sizes_w[RV34_MB_TYPES] = { 2, 2, 2, 1, 2, 2, 2, 2, 2, 1, 2, 2 };
445 
446 /** macroblock partition height in 8x8 blocks */
447 static const uint8_t part_sizes_h[RV34_MB_TYPES] = { 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2 };
448 
449 /** availability index for subblocks */
450 static const uint8_t avail_indexes[4] = { 6, 7, 10, 11 };
451 
452 /**
453  * motion vector prediction
454  *
455  * Motion prediction performed for the block by using median prediction of
456  * motion vectors from the left, top and right top blocks but in corner cases
457  * some other vectors may be used instead.
458  */
459 static void rv34_pred_mv(RV34DecContext *r, int block_type, int subblock_no, int dmv_no)
460 {
461  MpegEncContext *s = &r->s;
462  int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride;
463  int A[2] = {0}, B[2], C[2];
464  int i, j;
465  int mx, my;
466  int* avail = r->avail_cache + avail_indexes[subblock_no];
467  int c_off = part_sizes_w[block_type];
468 
469  mv_pos += (subblock_no & 1) + (subblock_no >> 1)*s->b8_stride;
470  if(subblock_no == 3)
471  c_off = -1;
472 
473  if(avail[-1]){
474  A[0] = s->current_picture_ptr->motion_val[0][mv_pos-1][0];
475  A[1] = s->current_picture_ptr->motion_val[0][mv_pos-1][1];
476  }
477  if(avail[-4]){
478  B[0] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride][0];
479  B[1] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride][1];
480  }else{
481  B[0] = A[0];
482  B[1] = A[1];
483  }
484  if(!avail[c_off-4]){
485  if(avail[-4] && (avail[-1] || r->rv30)){
486  C[0] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride-1][0];
487  C[1] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride-1][1];
488  }else{
489  C[0] = A[0];
490  C[1] = A[1];
491  }
492  }else{
493  C[0] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride+c_off][0];
494  C[1] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride+c_off][1];
495  }
496  mx = mid_pred(A[0], B[0], C[0]);
497  my = mid_pred(A[1], B[1], C[1]);
498  mx += r->dmv[dmv_no][0];
499  my += r->dmv[dmv_no][1];
500  for(j = 0; j < part_sizes_h[block_type]; j++){
501  for(i = 0; i < part_sizes_w[block_type]; i++){
502  s->current_picture_ptr->motion_val[0][mv_pos + i + j*s->b8_stride][0] = mx;
503  s->current_picture_ptr->motion_val[0][mv_pos + i + j*s->b8_stride][1] = my;
504  }
505  }
506 }
507 
508 #define GET_PTS_DIFF(a, b) (((a) - (b) + 8192) & 0x1FFF)
509 
510 /**
511  * Calculate motion vector component that should be added for direct blocks.
512  */
513 static int calc_add_mv(RV34DecContext *r, int dir, int val)
514 {
515  int mul = dir ? -r->mv_weight2 : r->mv_weight1;
516 
517  return (int)(val * (SUINT)mul + 0x2000) >> 14;
518 }
519 
520 /**
521  * Predict motion vector for B-frame macroblock.
522  */
523 static inline void rv34_pred_b_vector(int A[2], int B[2], int C[2],
524  int A_avail, int B_avail, int C_avail,
525  int *mx, int *my)
526 {
527  if(A_avail + B_avail + C_avail != 3){
528  *mx = A[0] + B[0] + C[0];
529  *my = A[1] + B[1] + C[1];
530  if(A_avail + B_avail + C_avail == 2){
531  *mx /= 2;
532  *my /= 2;
533  }
534  }else{
535  *mx = mid_pred(A[0], B[0], C[0]);
536  *my = mid_pred(A[1], B[1], C[1]);
537  }
538 }
539 
540 /**
541  * motion vector prediction for B-frames
542  */
543 static void rv34_pred_mv_b(RV34DecContext *r, int block_type, int dir)
544 {
545  MpegEncContext *s = &r->s;
546  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
547  int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride;
548  int A[2] = { 0 }, B[2] = { 0 }, C[2] = { 0 };
549  int has_A = 0, has_B = 0, has_C = 0;
550  int mx, my;
551  int i, j;
552  Picture *cur_pic = s->current_picture_ptr;
553  const int mask = dir ? MB_TYPE_L1 : MB_TYPE_L0;
554  int type = cur_pic->mb_type[mb_pos];
555 
556  if((r->avail_cache[6-1] & type) & mask){
557  A[0] = cur_pic->motion_val[dir][mv_pos - 1][0];
558  A[1] = cur_pic->motion_val[dir][mv_pos - 1][1];
559  has_A = 1;
560  }
561  if((r->avail_cache[6-4] & type) & mask){
562  B[0] = cur_pic->motion_val[dir][mv_pos - s->b8_stride][0];
563  B[1] = cur_pic->motion_val[dir][mv_pos - s->b8_stride][1];
564  has_B = 1;
565  }
566  if(r->avail_cache[6-4] && (r->avail_cache[6-2] & type) & mask){
567  C[0] = cur_pic->motion_val[dir][mv_pos - s->b8_stride + 2][0];
568  C[1] = cur_pic->motion_val[dir][mv_pos - s->b8_stride + 2][1];
569  has_C = 1;
570  }else if((s->mb_x+1) == s->mb_width && (r->avail_cache[6-5] & type) & mask){
571  C[0] = cur_pic->motion_val[dir][mv_pos - s->b8_stride - 1][0];
572  C[1] = cur_pic->motion_val[dir][mv_pos - s->b8_stride - 1][1];
573  has_C = 1;
574  }
575 
576  rv34_pred_b_vector(A, B, C, has_A, has_B, has_C, &mx, &my);
577 
578  mx += r->dmv[dir][0];
579  my += r->dmv[dir][1];
580 
581  for(j = 0; j < 2; j++){
582  for(i = 0; i < 2; i++){
583  cur_pic->motion_val[dir][mv_pos + i + j*s->b8_stride][0] = mx;
584  cur_pic->motion_val[dir][mv_pos + i + j*s->b8_stride][1] = my;
585  }
586  }
587  if(block_type == RV34_MB_B_BACKWARD || block_type == RV34_MB_B_FORWARD){
588  ZERO8x2(cur_pic->motion_val[!dir][mv_pos], s->b8_stride);
589  }
590 }
591 
592 /**
593  * motion vector prediction - RV3 version
594  */
595 static void rv34_pred_mv_rv3(RV34DecContext *r, int block_type, int dir)
596 {
597  MpegEncContext *s = &r->s;
598  int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride;
599  int A[2] = {0}, B[2], C[2];
600  int i, j, k;
601  int mx, my;
602  int* avail = r->avail_cache + avail_indexes[0];
603 
604  if(avail[-1]){
605  A[0] = s->current_picture_ptr->motion_val[0][mv_pos - 1][0];
606  A[1] = s->current_picture_ptr->motion_val[0][mv_pos - 1][1];
607  }
608  if(avail[-4]){
609  B[0] = s->current_picture_ptr->motion_val[0][mv_pos - s->b8_stride][0];
610  B[1] = s->current_picture_ptr->motion_val[0][mv_pos - s->b8_stride][1];
611  }else{
612  B[0] = A[0];
613  B[1] = A[1];
614  }
615  if(!avail[-4 + 2]){
616  if(avail[-4] && (avail[-1])){
617  C[0] = s->current_picture_ptr->motion_val[0][mv_pos - s->b8_stride - 1][0];
618  C[1] = s->current_picture_ptr->motion_val[0][mv_pos - s->b8_stride - 1][1];
619  }else{
620  C[0] = A[0];
621  C[1] = A[1];
622  }
623  }else{
624  C[0] = s->current_picture_ptr->motion_val[0][mv_pos - s->b8_stride + 2][0];
625  C[1] = s->current_picture_ptr->motion_val[0][mv_pos - s->b8_stride + 2][1];
626  }
627  mx = mid_pred(A[0], B[0], C[0]);
628  my = mid_pred(A[1], B[1], C[1]);
629  mx += r->dmv[0][0];
630  my += r->dmv[0][1];
631  for(j = 0; j < 2; j++){
632  for(i = 0; i < 2; i++){
633  for(k = 0; k < 2; k++){
634  s->current_picture_ptr->motion_val[k][mv_pos + i + j*s->b8_stride][0] = mx;
635  s->current_picture_ptr->motion_val[k][mv_pos + i + j*s->b8_stride][1] = my;
636  }
637  }
638  }
639 }
640 
641 static const int chroma_coeffs[3] = { 0, 3, 5 };
642 
643 /**
644  * generic motion compensation function
645  *
646  * @param r decoder context
647  * @param block_type type of the current block
648  * @param xoff horizontal offset from the start of the current block
649  * @param yoff vertical offset from the start of the current block
650  * @param mv_off offset to the motion vector information
651  * @param width width of the current partition in 8x8 blocks
652  * @param height height of the current partition in 8x8 blocks
653  * @param dir motion compensation direction (i.e. from the last or the next reference frame)
654  * @param thirdpel motion vectors are specified in 1/3 of pixel
655  * @param qpel_mc a set of functions used to perform luma motion compensation
656  * @param chroma_mc a set of functions used to perform chroma motion compensation
657  */
658 static inline void rv34_mc(RV34DecContext *r, const int block_type,
659  const int xoff, const int yoff, int mv_off,
660  const int width, const int height, int dir,
661  const int thirdpel, int weighted,
662  qpel_mc_func (*qpel_mc)[16],
664 {
665  MpegEncContext *s = &r->s;
666  uint8_t *Y, *U, *V, *srcY, *srcU, *srcV;
667  int dxy, mx, my, umx, umy, lx, ly, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
668  int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride + mv_off;
669  int is16x16 = 1;
670  int emu = 0;
671 
672  if(thirdpel){
673  int chroma_mx, chroma_my;
674  mx = (s->current_picture_ptr->motion_val[dir][mv_pos][0] + (3 << 24)) / 3 - (1 << 24);
675  my = (s->current_picture_ptr->motion_val[dir][mv_pos][1] + (3 << 24)) / 3 - (1 << 24);
676  lx = (s->current_picture_ptr->motion_val[dir][mv_pos][0] + (3 << 24)) % 3;
677  ly = (s->current_picture_ptr->motion_val[dir][mv_pos][1] + (3 << 24)) % 3;
678  chroma_mx = s->current_picture_ptr->motion_val[dir][mv_pos][0] / 2;
679  chroma_my = s->current_picture_ptr->motion_val[dir][mv_pos][1] / 2;
680  umx = (chroma_mx + (3 << 24)) / 3 - (1 << 24);
681  umy = (chroma_my + (3 << 24)) / 3 - (1 << 24);
682  uvmx = chroma_coeffs[(chroma_mx + (3 << 24)) % 3];
683  uvmy = chroma_coeffs[(chroma_my + (3 << 24)) % 3];
684  }else{
685  int cx, cy;
686  mx = s->current_picture_ptr->motion_val[dir][mv_pos][0] >> 2;
687  my = s->current_picture_ptr->motion_val[dir][mv_pos][1] >> 2;
688  lx = s->current_picture_ptr->motion_val[dir][mv_pos][0] & 3;
689  ly = s->current_picture_ptr->motion_val[dir][mv_pos][1] & 3;
690  cx = s->current_picture_ptr->motion_val[dir][mv_pos][0] / 2;
691  cy = s->current_picture_ptr->motion_val[dir][mv_pos][1] / 2;
692  umx = cx >> 2;
693  umy = cy >> 2;
694  uvmx = (cx & 3) << 1;
695  uvmy = (cy & 3) << 1;
696  //due to some flaw RV40 uses the same MC compensation routine for H2V2 and H3V3
697  if(uvmx == 6 && uvmy == 6)
698  uvmx = uvmy = 4;
699  }
700 
701  if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME)) {
702  /* wait for the referenced mb row to be finished */
703  int mb_row = s->mb_y + ((yoff + my + 5 + 8 * height) >> 4);
704  ThreadFrame *f = dir ? &s->next_picture_ptr->tf : &s->last_picture_ptr->tf;
705  ff_thread_await_progress(f, mb_row, 0);
706  }
707 
708  dxy = ly*4 + lx;
709  srcY = dir ? s->next_picture_ptr->f->data[0] : s->last_picture_ptr->f->data[0];
710  srcU = dir ? s->next_picture_ptr->f->data[1] : s->last_picture_ptr->f->data[1];
711  srcV = dir ? s->next_picture_ptr->f->data[2] : s->last_picture_ptr->f->data[2];
712  src_x = s->mb_x * 16 + xoff + mx;
713  src_y = s->mb_y * 16 + yoff + my;
714  uvsrc_x = s->mb_x * 8 + (xoff >> 1) + umx;
715  uvsrc_y = s->mb_y * 8 + (yoff >> 1) + umy;
716  srcY += src_y * s->linesize + src_x;
717  srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
718  srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
719  if(s->h_edge_pos - (width << 3) < 6 || s->v_edge_pos - (height << 3) < 6 ||
720  (unsigned)(src_x - !!lx*2) > s->h_edge_pos - !!lx*2 - (width <<3) - 4 ||
721  (unsigned)(src_y - !!ly*2) > s->v_edge_pos - !!ly*2 - (height<<3) - 4) {
722  srcY -= 2 + 2*s->linesize;
723  s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, srcY,
724  s->linesize, s->linesize,
725  (width << 3) + 6, (height << 3) + 6,
726  src_x - 2, src_y - 2,
727  s->h_edge_pos, s->v_edge_pos);
728  srcY = s->sc.edge_emu_buffer + 2 + 2*s->linesize;
729  emu = 1;
730  }
731  if(!weighted){
732  Y = s->dest[0] + xoff + yoff *s->linesize;
733  U = s->dest[1] + (xoff>>1) + (yoff>>1)*s->uvlinesize;
734  V = s->dest[2] + (xoff>>1) + (yoff>>1)*s->uvlinesize;
735  }else{
736  Y = r->tmp_b_block_y [dir] + xoff + yoff *s->linesize;
737  U = r->tmp_b_block_uv[dir*2] + (xoff>>1) + (yoff>>1)*s->uvlinesize;
738  V = r->tmp_b_block_uv[dir*2+1] + (xoff>>1) + (yoff>>1)*s->uvlinesize;
739  }
740 
741  if(block_type == RV34_MB_P_16x8){
742  qpel_mc[1][dxy](Y, srcY, s->linesize);
743  Y += 8;
744  srcY += 8;
745  }else if(block_type == RV34_MB_P_8x16){
746  qpel_mc[1][dxy](Y, srcY, s->linesize);
747  Y += 8 * s->linesize;
748  srcY += 8 * s->linesize;
749  }
750  is16x16 = (block_type != RV34_MB_P_8x8) && (block_type != RV34_MB_P_16x8) && (block_type != RV34_MB_P_8x16);
751  qpel_mc[!is16x16][dxy](Y, srcY, s->linesize);
752  if (emu) {
753  uint8_t *uvbuf = s->sc.edge_emu_buffer;
754 
755  s->vdsp.emulated_edge_mc(uvbuf, srcU,
756  s->uvlinesize, s->uvlinesize,
757  (width << 2) + 1, (height << 2) + 1,
758  uvsrc_x, uvsrc_y,
759  s->h_edge_pos >> 1, s->v_edge_pos >> 1);
760  srcU = uvbuf;
761  uvbuf += 9*s->uvlinesize;
762 
763  s->vdsp.emulated_edge_mc(uvbuf, srcV,
764  s->uvlinesize, s->uvlinesize,
765  (width << 2) + 1, (height << 2) + 1,
766  uvsrc_x, uvsrc_y,
767  s->h_edge_pos >> 1, s->v_edge_pos >> 1);
768  srcV = uvbuf;
769  }
770  chroma_mc[2-width] (U, srcU, s->uvlinesize, height*4, uvmx, uvmy);
771  chroma_mc[2-width] (V, srcV, s->uvlinesize, height*4, uvmx, uvmy);
772 }
773 
774 static void rv34_mc_1mv(RV34DecContext *r, const int block_type,
775  const int xoff, const int yoff, int mv_off,
776  const int width, const int height, int dir)
777 {
778  rv34_mc(r, block_type, xoff, yoff, mv_off, width, height, dir, r->rv30, 0,
779  r->rdsp.put_pixels_tab,
780  r->rdsp.put_chroma_pixels_tab);
781 }
782 
784 {
785  r->rdsp.rv40_weight_pixels_tab[r->scaled_weight][0](r->s.dest[0],
786  r->tmp_b_block_y[0],
787  r->tmp_b_block_y[1],
788  r->weight1,
789  r->weight2,
790  r->s.linesize);
791  r->rdsp.rv40_weight_pixels_tab[r->scaled_weight][1](r->s.dest[1],
792  r->tmp_b_block_uv[0],
793  r->tmp_b_block_uv[2],
794  r->weight1,
795  r->weight2,
796  r->s.uvlinesize);
797  r->rdsp.rv40_weight_pixels_tab[r->scaled_weight][1](r->s.dest[2],
798  r->tmp_b_block_uv[1],
799  r->tmp_b_block_uv[3],
800  r->weight1,
801  r->weight2,
802  r->s.uvlinesize);
803 }
804 
805 static void rv34_mc_2mv(RV34DecContext *r, const int block_type)
806 {
807  int weighted = !r->rv30 && block_type != RV34_MB_B_BIDIR && r->weight1 != 8192;
808 
809  rv34_mc(r, block_type, 0, 0, 0, 2, 2, 0, r->rv30, weighted,
810  r->rdsp.put_pixels_tab,
811  r->rdsp.put_chroma_pixels_tab);
812  if(!weighted){
813  rv34_mc(r, block_type, 0, 0, 0, 2, 2, 1, r->rv30, 0,
814  r->rdsp.avg_pixels_tab,
815  r->rdsp.avg_chroma_pixels_tab);
816  }else{
817  rv34_mc(r, block_type, 0, 0, 0, 2, 2, 1, r->rv30, 1,
818  r->rdsp.put_pixels_tab,
819  r->rdsp.put_chroma_pixels_tab);
820  rv4_weight(r);
821  }
822 }
823 
825 {
826  int i, j;
827  int weighted = !r->rv30 && r->weight1 != 8192;
828 
829  for(j = 0; j < 2; j++)
830  for(i = 0; i < 2; i++){
831  rv34_mc(r, RV34_MB_P_8x8, i*8, j*8, i+j*r->s.b8_stride, 1, 1, 0, r->rv30,
832  weighted,
833  r->rdsp.put_pixels_tab,
834  r->rdsp.put_chroma_pixels_tab);
835  rv34_mc(r, RV34_MB_P_8x8, i*8, j*8, i+j*r->s.b8_stride, 1, 1, 1, r->rv30,
836  weighted,
837  weighted ? r->rdsp.put_pixels_tab : r->rdsp.avg_pixels_tab,
838  weighted ? r->rdsp.put_chroma_pixels_tab : r->rdsp.avg_chroma_pixels_tab);
839  }
840  if(weighted)
841  rv4_weight(r);
842 }
843 
844 /** number of motion vectors in each macroblock type */
845 static const int num_mvs[RV34_MB_TYPES] = { 0, 0, 1, 4, 1, 1, 0, 0, 2, 2, 2, 1 };
846 
847 /**
848  * Decode motion vector differences
849  * and perform motion vector reconstruction and motion compensation.
850  */
851 static int rv34_decode_mv(RV34DecContext *r, int block_type)
852 {
853  MpegEncContext *s = &r->s;
854  GetBitContext *gb = &s->gb;
855  int i, j, k, l;
856  int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride;
857  int next_bt;
858 
859  memset(r->dmv, 0, sizeof(r->dmv));
860  for(i = 0; i < num_mvs[block_type]; i++){
861  r->dmv[i][0] = get_interleaved_se_golomb(gb);
862  r->dmv[i][1] = get_interleaved_se_golomb(gb);
863  if (r->dmv[i][0] == INVALID_VLC ||
864  r->dmv[i][1] == INVALID_VLC) {
865  r->dmv[i][0] = r->dmv[i][1] = 0;
866  return AVERROR_INVALIDDATA;
867  }
868  }
869  switch(block_type){
870  case RV34_MB_TYPE_INTRA:
872  ZERO8x2(s->current_picture_ptr->motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride);
873  return 0;
874  case RV34_MB_SKIP:
875  if(s->pict_type == AV_PICTURE_TYPE_P){
876  ZERO8x2(s->current_picture_ptr->motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride);
877  rv34_mc_1mv (r, block_type, 0, 0, 0, 2, 2, 0);
878  break;
879  }
880  case RV34_MB_B_DIRECT:
881  //surprisingly, it uses motion scheme from next reference frame
882  /* wait for the current mb row to be finished */
883  if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME))
884  ff_thread_await_progress(&s->next_picture_ptr->tf, FFMAX(0, s->mb_y-1), 0);
885 
886  next_bt = s->next_picture_ptr->mb_type[s->mb_x + s->mb_y * s->mb_stride];
887  if(IS_INTRA(next_bt) || IS_SKIP(next_bt)){
888  ZERO8x2(s->current_picture_ptr->motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride);
889  ZERO8x2(s->current_picture_ptr->motion_val[1][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride);
890  }else
891  for(j = 0; j < 2; j++)
892  for(i = 0; i < 2; i++)
893  for(k = 0; k < 2; k++)
894  for(l = 0; l < 2; l++)
895  s->current_picture_ptr->motion_val[l][mv_pos + i + j*s->b8_stride][k] = calc_add_mv(r, l, s->next_picture_ptr->motion_val[0][mv_pos + i + j*s->b8_stride][k]);
896  if(!(IS_16X8(next_bt) || IS_8X16(next_bt) || IS_8X8(next_bt))) //we can use whole macroblock MC
897  rv34_mc_2mv(r, block_type);
898  else
900  ZERO8x2(s->current_picture_ptr->motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride);
901  break;
902  case RV34_MB_P_16x16:
903  case RV34_MB_P_MIX16x16:
904  rv34_pred_mv(r, block_type, 0, 0);
905  rv34_mc_1mv (r, block_type, 0, 0, 0, 2, 2, 0);
906  break;
907  case RV34_MB_B_FORWARD:
908  case RV34_MB_B_BACKWARD:
909  r->dmv[1][0] = r->dmv[0][0];
910  r->dmv[1][1] = r->dmv[0][1];
911  if(r->rv30)
912  rv34_pred_mv_rv3(r, block_type, block_type == RV34_MB_B_BACKWARD);
913  else
914  rv34_pred_mv_b (r, block_type, block_type == RV34_MB_B_BACKWARD);
915  rv34_mc_1mv (r, block_type, 0, 0, 0, 2, 2, block_type == RV34_MB_B_BACKWARD);
916  break;
917  case RV34_MB_P_16x8:
918  case RV34_MB_P_8x16:
919  rv34_pred_mv(r, block_type, 0, 0);
920  rv34_pred_mv(r, block_type, 1 + (block_type == RV34_MB_P_16x8), 1);
921  if(block_type == RV34_MB_P_16x8){
922  rv34_mc_1mv(r, block_type, 0, 0, 0, 2, 1, 0);
923  rv34_mc_1mv(r, block_type, 0, 8, s->b8_stride, 2, 1, 0);
924  }
925  if(block_type == RV34_MB_P_8x16){
926  rv34_mc_1mv(r, block_type, 0, 0, 0, 1, 2, 0);
927  rv34_mc_1mv(r, block_type, 8, 0, 1, 1, 2, 0);
928  }
929  break;
930  case RV34_MB_B_BIDIR:
931  rv34_pred_mv_b (r, block_type, 0);
932  rv34_pred_mv_b (r, block_type, 1);
933  rv34_mc_2mv (r, block_type);
934  break;
935  case RV34_MB_P_8x8:
936  for(i=0;i< 4;i++){
937  rv34_pred_mv(r, block_type, i, i);
938  rv34_mc_1mv (r, block_type, (i&1)<<3, (i&2)<<2, (i&1)+(i>>1)*s->b8_stride, 1, 1, 0);
939  }
940  break;
941  }
942 
943  return 0;
944 }
945 /** @} */ // mv group
946 
947 /**
948  * @name Macroblock reconstruction functions
949  * @{
950  */
951 /** mapping of RV30/40 intra prediction types to standard H.264 types */
952 static const int ittrans[9] = {
955 };
956 
957 /** mapping of RV30/40 intra 16x16 prediction types to standard H.264 types */
958 static const int ittrans16[4] = {
960 };
961 
962 /**
963  * Perform 4x4 intra prediction.
964  */
965 static void rv34_pred_4x4_block(RV34DecContext *r, uint8_t *dst, int stride, int itype, int up, int left, int down, int right)
966 {
967  uint8_t *prev = dst - stride + 4;
968  uint32_t topleft;
969 
970  if(!up && !left)
971  itype = DC_128_PRED;
972  else if(!up){
973  if(itype == VERT_PRED) itype = HOR_PRED;
974  if(itype == DC_PRED) itype = LEFT_DC_PRED;
975  }else if(!left){
976  if(itype == HOR_PRED) itype = VERT_PRED;
977  if(itype == DC_PRED) itype = TOP_DC_PRED;
979  }
980  if(!down){
982  if(itype == HOR_UP_PRED) itype = HOR_UP_PRED_RV40_NODOWN;
983  if(itype == VERT_LEFT_PRED) itype = VERT_LEFT_PRED_RV40_NODOWN;
984  }
985  if(!right && up){
986  topleft = dst[-stride + 3] * 0x01010101u;
987  prev = (uint8_t*)&topleft;
988  }
989  r->h.pred4x4[itype](dst, prev, stride);
990 }
991 
992 static inline int adjust_pred16(int itype, int up, int left)
993 {
994  if(!up && !left)
995  itype = DC_128_PRED8x8;
996  else if(!up){
997  if(itype == PLANE_PRED8x8)itype = HOR_PRED8x8;
998  if(itype == VERT_PRED8x8) itype = HOR_PRED8x8;
999  if(itype == DC_PRED8x8) itype = LEFT_DC_PRED8x8;
1000  }else if(!left){
1001  if(itype == PLANE_PRED8x8)itype = VERT_PRED8x8;
1002  if(itype == HOR_PRED8x8) itype = VERT_PRED8x8;
1003  if(itype == DC_PRED8x8) itype = TOP_DC_PRED8x8;
1004  }
1005  return itype;
1006 }
1007 
1009  uint8_t *pdst, int stride,
1010  int fc, int sc, int q_dc, int q_ac)
1011 {
1012  MpegEncContext *s = &r->s;
1013  int16_t *ptr = s->block[0];
1014  int has_ac = rv34_decode_block(ptr, &s->gb, r->cur_vlcs,
1015  fc, sc, q_dc, q_ac, q_ac);
1016  if(has_ac){
1017  r->rdsp.rv34_idct_add(pdst, stride, ptr);
1018  }else{
1019  r->rdsp.rv34_idct_dc_add(pdst, stride, ptr[0]);
1020  ptr[0] = 0;
1021  }
1022 }
1023 
1024 static void rv34_output_i16x16(RV34DecContext *r, int8_t *intra_types, int cbp)
1025 {
1026  LOCAL_ALIGNED_16(int16_t, block16, [16]);
1027  MpegEncContext *s = &r->s;
1028  GetBitContext *gb = &s->gb;
1029  int q_dc = rv34_qscale_tab[ r->luma_dc_quant_i[s->qscale] ],
1030  q_ac = rv34_qscale_tab[s->qscale];
1031  uint8_t *dst = s->dest[0];
1032  int16_t *ptr = s->block[0];
1033  int i, j, itype, has_ac;
1034 
1035  memset(block16, 0, 16 * sizeof(*block16));
1036 
1037  has_ac = rv34_decode_block(block16, gb, r->cur_vlcs, 3, 0, q_dc, q_dc, q_ac);
1038  if(has_ac)
1039  r->rdsp.rv34_inv_transform(block16);
1040  else
1041  r->rdsp.rv34_inv_transform_dc(block16);
1042 
1043  itype = ittrans16[intra_types[0]];
1044  itype = adjust_pred16(itype, r->avail_cache[6-4], r->avail_cache[6-1]);
1045  r->h.pred16x16[itype](dst, s->linesize);
1046 
1047  for(j = 0; j < 4; j++){
1048  for(i = 0; i < 4; i++, cbp >>= 1){
1049  int dc = block16[i + j*4];
1050 
1051  if(cbp & 1){
1052  has_ac = rv34_decode_block(ptr, gb, r->cur_vlcs, r->luma_vlc, 0, q_ac, q_ac, q_ac);
1053  }else
1054  has_ac = 0;
1055 
1056  if(has_ac){
1057  ptr[0] = dc;
1058  r->rdsp.rv34_idct_add(dst+4*i, s->linesize, ptr);
1059  }else
1060  r->rdsp.rv34_idct_dc_add(dst+4*i, s->linesize, dc);
1061  }
1062 
1063  dst += 4*s->linesize;
1064  }
1065 
1066  itype = ittrans16[intra_types[0]];
1067  if(itype == PLANE_PRED8x8) itype = DC_PRED8x8;
1068  itype = adjust_pred16(itype, r->avail_cache[6-4], r->avail_cache[6-1]);
1069 
1070  q_dc = rv34_qscale_tab[rv34_chroma_quant[1][s->qscale]];
1071  q_ac = rv34_qscale_tab[rv34_chroma_quant[0][s->qscale]];
1072 
1073  for(j = 1; j < 3; j++){
1074  dst = s->dest[j];
1075  r->h.pred8x8[itype](dst, s->uvlinesize);
1076  for(i = 0; i < 4; i++, cbp >>= 1){
1077  uint8_t *pdst;
1078  if(!(cbp & 1)) continue;
1079  pdst = dst + (i&1)*4 + (i&2)*2*s->uvlinesize;
1080 
1081  rv34_process_block(r, pdst, s->uvlinesize,
1082  r->chroma_vlc, 1, q_dc, q_ac);
1083  }
1084  }
1085 }
1086 
1087 static void rv34_output_intra(RV34DecContext *r, int8_t *intra_types, int cbp)
1088 {
1089  MpegEncContext *s = &r->s;
1090  uint8_t *dst = s->dest[0];
1091  int avail[6*8] = {0};
1092  int i, j, k;
1093  int idx, q_ac, q_dc;
1094 
1095  // Set neighbour information.
1096  if(r->avail_cache[1])
1097  avail[0] = 1;
1098  if(r->avail_cache[2])
1099  avail[1] = avail[2] = 1;
1100  if(r->avail_cache[3])
1101  avail[3] = avail[4] = 1;
1102  if(r->avail_cache[4])
1103  avail[5] = 1;
1104  if(r->avail_cache[5])
1105  avail[8] = avail[16] = 1;
1106  if(r->avail_cache[9])
1107  avail[24] = avail[32] = 1;
1108 
1109  q_ac = rv34_qscale_tab[s->qscale];
1110  for(j = 0; j < 4; j++){
1111  idx = 9 + j*8;
1112  for(i = 0; i < 4; i++, cbp >>= 1, dst += 4, idx++){
1113  rv34_pred_4x4_block(r, dst, s->linesize, ittrans[intra_types[i]], avail[idx-8], avail[idx-1], avail[idx+7], avail[idx-7]);
1114  avail[idx] = 1;
1115  if(!(cbp & 1)) continue;
1116 
1117  rv34_process_block(r, dst, s->linesize,
1118  r->luma_vlc, 0, q_ac, q_ac);
1119  }
1120  dst += s->linesize * 4 - 4*4;
1121  intra_types += r->intra_types_stride;
1122  }
1123 
1124  intra_types -= r->intra_types_stride * 4;
1125 
1126  q_dc = rv34_qscale_tab[rv34_chroma_quant[1][s->qscale]];
1127  q_ac = rv34_qscale_tab[rv34_chroma_quant[0][s->qscale]];
1128 
1129  for(k = 0; k < 2; k++){
1130  dst = s->dest[1+k];
1131  fill_rectangle(r->avail_cache + 6, 2, 2, 4, 0, 4);
1132 
1133  for(j = 0; j < 2; j++){
1134  int* acache = r->avail_cache + 6 + j*4;
1135  for(i = 0; i < 2; i++, cbp >>= 1, acache++){
1136  int itype = ittrans[intra_types[i*2+j*2*r->intra_types_stride]];
1137  rv34_pred_4x4_block(r, dst+4*i, s->uvlinesize, itype, acache[-4], acache[-1], !i && !j, acache[-3]);
1138  acache[0] = 1;
1139 
1140  if(!(cbp&1)) continue;
1141 
1142  rv34_process_block(r, dst + 4*i, s->uvlinesize,
1143  r->chroma_vlc, 1, q_dc, q_ac);
1144  }
1145 
1146  dst += 4*s->uvlinesize;
1147  }
1148  }
1149 }
1150 
1151 static int is_mv_diff_gt_3(int16_t (*motion_val)[2], int step)
1152 {
1153  int d;
1154  d = motion_val[0][0] - motion_val[-step][0];
1155  if(d < -3 || d > 3)
1156  return 1;
1157  d = motion_val[0][1] - motion_val[-step][1];
1158  if(d < -3 || d > 3)
1159  return 1;
1160  return 0;
1161 }
1162 
1164 {
1165  MpegEncContext *s = &r->s;
1166  int hmvmask = 0, vmvmask = 0, i, j;
1167  int midx = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride;
1168  int16_t (*motion_val)[2] = &s->current_picture_ptr->motion_val[0][midx];
1169  for(j = 0; j < 16; j += 8){
1170  for(i = 0; i < 2; i++){
1171  if(is_mv_diff_gt_3(motion_val + i, 1))
1172  vmvmask |= 0x11 << (j + i*2);
1173  if((j || s->mb_y) && is_mv_diff_gt_3(motion_val + i, s->b8_stride))
1174  hmvmask |= 0x03 << (j + i*2);
1175  }
1176  motion_val += s->b8_stride;
1177  }
1178  if(s->first_slice_line)
1179  hmvmask &= ~0x000F;
1180  if(!s->mb_x)
1181  vmvmask &= ~0x1111;
1182  if(r->rv30){ //RV30 marks both subblocks on the edge for filtering
1183  vmvmask |= (vmvmask & 0x4444) >> 1;
1184  hmvmask |= (hmvmask & 0x0F00) >> 4;
1185  if(s->mb_x)
1186  r->deblock_coefs[s->mb_x - 1 + s->mb_y*s->mb_stride] |= (vmvmask & 0x1111) << 3;
1187  if(!s->first_slice_line)
1188  r->deblock_coefs[s->mb_x + (s->mb_y - 1)*s->mb_stride] |= (hmvmask & 0xF) << 12;
1189  }
1190  return hmvmask | vmvmask;
1191 }
1192 
1193 static int rv34_decode_inter_macroblock(RV34DecContext *r, int8_t *intra_types)
1194 {
1195  MpegEncContext *s = &r->s;
1196  GetBitContext *gb = &s->gb;
1197  uint8_t *dst = s->dest[0];
1198  int16_t *ptr = s->block[0];
1199  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1200  int cbp, cbp2;
1201  int q_dc, q_ac, has_ac;
1202  int i, j;
1203  int dist;
1204 
1205  // Calculate which neighbours are available. Maybe it's worth optimizing too.
1206  memset(r->avail_cache, 0, sizeof(r->avail_cache));
1207  fill_rectangle(r->avail_cache + 6, 2, 2, 4, 1, 4);
1208  dist = (s->mb_x - s->resync_mb_x) + (s->mb_y - s->resync_mb_y) * s->mb_width;
1209  if(s->mb_x && dist)
1210  r->avail_cache[5] =
1211  r->avail_cache[9] = s->current_picture_ptr->mb_type[mb_pos - 1];
1212  if(dist >= s->mb_width)
1213  r->avail_cache[2] =
1214  r->avail_cache[3] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride];
1215  if(((s->mb_x+1) < s->mb_width) && dist >= s->mb_width - 1)
1216  r->avail_cache[4] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride + 1];
1217  if(s->mb_x && dist > s->mb_width)
1218  r->avail_cache[1] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride - 1];
1219 
1220  s->qscale = r->si.quant;
1221  cbp = cbp2 = rv34_decode_inter_mb_header(r, intra_types);
1222  r->cbp_luma [mb_pos] = cbp;
1223  r->cbp_chroma[mb_pos] = cbp >> 16;
1224  r->deblock_coefs[mb_pos] = rv34_set_deblock_coef(r) | r->cbp_luma[mb_pos];
1225  s->current_picture_ptr->qscale_table[mb_pos] = s->qscale;
1226 
1227  if(cbp == -1)
1228  return -1;
1229 
1230  if (IS_INTRA(s->current_picture_ptr->mb_type[mb_pos])){
1231  if(r->is16) rv34_output_i16x16(r, intra_types, cbp);
1232  else rv34_output_intra(r, intra_types, cbp);
1233  return 0;
1234  }
1235 
1236  if(r->is16){
1237  // Only for RV34_MB_P_MIX16x16
1238  LOCAL_ALIGNED_16(int16_t, block16, [16]);
1239  memset(block16, 0, 16 * sizeof(*block16));
1240  q_dc = rv34_qscale_tab[ r->luma_dc_quant_p[s->qscale] ];
1241  q_ac = rv34_qscale_tab[s->qscale];
1242  if (rv34_decode_block(block16, gb, r->cur_vlcs, 3, 0, q_dc, q_dc, q_ac))
1243  r->rdsp.rv34_inv_transform(block16);
1244  else
1245  r->rdsp.rv34_inv_transform_dc(block16);
1246 
1247  q_ac = rv34_qscale_tab[s->qscale];
1248 
1249  for(j = 0; j < 4; j++){
1250  for(i = 0; i < 4; i++, cbp >>= 1){
1251  int dc = block16[i + j*4];
1252 
1253  if(cbp & 1){
1254  has_ac = rv34_decode_block(ptr, gb, r->cur_vlcs, r->luma_vlc, 0, q_ac, q_ac, q_ac);
1255  }else
1256  has_ac = 0;
1257 
1258  if(has_ac){
1259  ptr[0] = dc;
1260  r->rdsp.rv34_idct_add(dst+4*i, s->linesize, ptr);
1261  }else
1262  r->rdsp.rv34_idct_dc_add(dst+4*i, s->linesize, dc);
1263  }
1264 
1265  dst += 4*s->linesize;
1266  }
1267 
1268  r->cur_vlcs = choose_vlc_set(r->si.quant, r->si.vlc_set, 1);
1269  }else{
1270  q_ac = rv34_qscale_tab[s->qscale];
1271 
1272  for(j = 0; j < 4; j++){
1273  for(i = 0; i < 4; i++, cbp >>= 1){
1274  if(!(cbp & 1)) continue;
1275 
1276  rv34_process_block(r, dst + 4*i, s->linesize,
1277  r->luma_vlc, 0, q_ac, q_ac);
1278  }
1279  dst += 4*s->linesize;
1280  }
1281  }
1282 
1283  q_dc = rv34_qscale_tab[rv34_chroma_quant[1][s->qscale]];
1284  q_ac = rv34_qscale_tab[rv34_chroma_quant[0][s->qscale]];
1285 
1286  for(j = 1; j < 3; j++){
1287  dst = s->dest[j];
1288  for(i = 0; i < 4; i++, cbp >>= 1){
1289  uint8_t *pdst;
1290  if(!(cbp & 1)) continue;
1291  pdst = dst + (i&1)*4 + (i&2)*2*s->uvlinesize;
1292 
1293  rv34_process_block(r, pdst, s->uvlinesize,
1294  r->chroma_vlc, 1, q_dc, q_ac);
1295  }
1296  }
1297 
1298  return 0;
1299 }
1300 
1301 static int rv34_decode_intra_macroblock(RV34DecContext *r, int8_t *intra_types)
1302 {
1303  MpegEncContext *s = &r->s;
1304  int cbp, dist;
1305  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1306 
1307  // Calculate which neighbours are available. Maybe it's worth optimizing too.
1308  memset(r->avail_cache, 0, sizeof(r->avail_cache));
1309  fill_rectangle(r->avail_cache + 6, 2, 2, 4, 1, 4);
1310  dist = (s->mb_x - s->resync_mb_x) + (s->mb_y - s->resync_mb_y) * s->mb_width;
1311  if(s->mb_x && dist)
1312  r->avail_cache[5] =
1313  r->avail_cache[9] = s->current_picture_ptr->mb_type[mb_pos - 1];
1314  if(dist >= s->mb_width)
1315  r->avail_cache[2] =
1316  r->avail_cache[3] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride];
1317  if(((s->mb_x+1) < s->mb_width) && dist >= s->mb_width - 1)
1318  r->avail_cache[4] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride + 1];
1319  if(s->mb_x && dist > s->mb_width)
1320  r->avail_cache[1] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride - 1];
1321 
1322  s->qscale = r->si.quant;
1323  cbp = rv34_decode_intra_mb_header(r, intra_types);
1324  r->cbp_luma [mb_pos] = cbp;
1325  r->cbp_chroma[mb_pos] = cbp >> 16;
1326  r->deblock_coefs[mb_pos] = 0xFFFF;
1327  s->current_picture_ptr->qscale_table[mb_pos] = s->qscale;
1328 
1329  if(cbp == -1)
1330  return -1;
1331 
1332  if(r->is16){
1333  rv34_output_i16x16(r, intra_types, cbp);
1334  return 0;
1335  }
1336 
1337  rv34_output_intra(r, intra_types, cbp);
1338  return 0;
1339 }
1340 
1342 {
1343  int bits;
1344  if(s->mb_y >= s->mb_height)
1345  return 1;
1346  if(!s->mb_num_left)
1347  return 1;
1348  if(r->s.mb_skip_run > 1)
1349  return 0;
1350  bits = get_bits_left(&s->gb);
1351  if(bits <= 0 || (bits < 8 && !show_bits(&s->gb, bits)))
1352  return 1;
1353  return 0;
1354 }
1355 
1356 
1358 {
1359  av_freep(&r->intra_types_hist);
1360  r->intra_types = NULL;
1361  av_freep(&r->tmp_b_block_base);
1362  av_freep(&r->mb_type);
1363  av_freep(&r->cbp_luma);
1364  av_freep(&r->cbp_chroma);
1365  av_freep(&r->deblock_coefs);
1366 }
1367 
1368 
1370 {
1371  r->intra_types_stride = r->s.mb_width * 4 + 4;
1372 
1373  r->cbp_chroma = av_mallocz(r->s.mb_stride * r->s.mb_height *
1374  sizeof(*r->cbp_chroma));
1375  r->cbp_luma = av_mallocz(r->s.mb_stride * r->s.mb_height *
1376  sizeof(*r->cbp_luma));
1377  r->deblock_coefs = av_mallocz(r->s.mb_stride * r->s.mb_height *
1378  sizeof(*r->deblock_coefs));
1379  r->intra_types_hist = av_malloc(r->intra_types_stride * 4 * 2 *
1380  sizeof(*r->intra_types_hist));
1381  r->mb_type = av_mallocz(r->s.mb_stride * r->s.mb_height *
1382  sizeof(*r->mb_type));
1383 
1384  if (!(r->cbp_chroma && r->cbp_luma && r->deblock_coefs &&
1385  r->intra_types_hist && r->mb_type)) {
1386  r->s.context_reinit = 1;
1388  return AVERROR(ENOMEM);
1389  }
1390 
1391  r->intra_types = r->intra_types_hist + r->intra_types_stride * 4;
1392 
1393  return 0;
1394 }
1395 
1396 
1398 {
1400  return rv34_decoder_alloc(r);
1401 }
1402 
1403 
1404 static int rv34_decode_slice(RV34DecContext *r, int end, const uint8_t* buf, int buf_size)
1405 {
1406  MpegEncContext *s = &r->s;
1407  GetBitContext *gb = &s->gb;
1408  int mb_pos, slice_type;
1409  int res;
1410 
1411  init_get_bits(&r->s.gb, buf, buf_size*8);
1412  res = r->parse_slice_header(r, gb, &r->si);
1413  if(res < 0){
1414  av_log(s->avctx, AV_LOG_ERROR, "Incorrect or unknown slice header\n");
1415  return -1;
1416  }
1417 
1418  slice_type = r->si.type ? r->si.type : AV_PICTURE_TYPE_I;
1419  if (slice_type != s->pict_type) {
1420  av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
1421  return AVERROR_INVALIDDATA;
1422  }
1423  if (s->width != r->si.width || s->height != r->si.height) {
1424  av_log(s->avctx, AV_LOG_ERROR, "Size mismatch\n");
1425  return AVERROR_INVALIDDATA;
1426  }
1427 
1428  r->si.end = end;
1429  s->qscale = r->si.quant;
1430  s->mb_num_left = r->si.end - r->si.start;
1431  r->s.mb_skip_run = 0;
1432 
1433  mb_pos = s->mb_x + s->mb_y * s->mb_width;
1434  if(r->si.start != mb_pos){
1435  av_log(s->avctx, AV_LOG_ERROR, "Slice indicates MB offset %d, got %d\n", r->si.start, mb_pos);
1436  s->mb_x = r->si.start % s->mb_width;
1437  s->mb_y = r->si.start / s->mb_width;
1438  }
1439  memset(r->intra_types_hist, -1, r->intra_types_stride * 4 * 2 * sizeof(*r->intra_types_hist));
1440  s->first_slice_line = 1;
1441  s->resync_mb_x = s->mb_x;
1442  s->resync_mb_y = s->mb_y;
1443 
1445  while(!check_slice_end(r, s)) {
1447 
1448  if(r->si.type)
1449  res = rv34_decode_inter_macroblock(r, r->intra_types + s->mb_x * 4 + 4);
1450  else
1451  res = rv34_decode_intra_macroblock(r, r->intra_types + s->mb_x * 4 + 4);
1452  if(res < 0){
1453  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_ERROR);
1454  return -1;
1455  }
1456  if (++s->mb_x == s->mb_width) {
1457  s->mb_x = 0;
1458  s->mb_y++;
1460 
1461  memmove(r->intra_types_hist, r->intra_types, r->intra_types_stride * 4 * sizeof(*r->intra_types_hist));
1462  memset(r->intra_types, -1, r->intra_types_stride * 4 * sizeof(*r->intra_types_hist));
1463 
1464  if(r->loop_filter && s->mb_y >= 2)
1465  r->loop_filter(r, s->mb_y - 2);
1466 
1467  if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME))
1468  ff_thread_report_progress(&s->current_picture_ptr->tf,
1469  s->mb_y - 2, 0);
1470 
1471  }
1472  if(s->mb_x == s->resync_mb_x)
1473  s->first_slice_line=0;
1474  s->mb_num_left--;
1475  }
1476  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END);
1477 
1478  return s->mb_y == s->mb_height;
1479 }
1480 
1481 /** @} */ // reconstruction group end
1482 
1483 /**
1484  * Initialize decoder.
1485  */
1487 {
1488  static AVOnce init_static_once = AV_ONCE_INIT;
1489  RV34DecContext *r = avctx->priv_data;
1490  MpegEncContext *s = &r->s;
1491  int ret;
1492 
1493  ff_mpv_decode_init(s, avctx);
1494  s->out_format = FMT_H263;
1495 
1496  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
1497  avctx->has_b_frames = 1;
1498  s->low_delay = 0;
1499 
1501  if ((ret = ff_mpv_common_init(s)) < 0)
1502  return ret;
1503 
1504  ff_h264_pred_init(&r->h, AV_CODEC_ID_RV40, 8, 1);
1505 
1506  if ((ret = rv34_decoder_alloc(r)) < 0) {
1507  ff_mpv_common_end(&r->s);
1508  return ret;
1509  }
1510 
1511  ff_thread_once(&init_static_once, rv34_init_tables);
1512 
1513  return 0;
1514 }
1515 
1517 {
1518  RV34DecContext *r = dst->priv_data, *r1 = src->priv_data;
1519  MpegEncContext * const s = &r->s, * const s1 = &r1->s;
1520  int err;
1521 
1522  if (dst == src || !s1->context_initialized)
1523  return 0;
1524 
1525  if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
1526  s->height = s1->height;
1527  s->width = s1->width;
1528  if ((err = ff_mpv_common_frame_size_change(s)) < 0)
1529  return err;
1530  if ((err = rv34_decoder_realloc(r)) < 0)
1531  return err;
1532  }
1533 
1534  r->cur_pts = r1->cur_pts;
1535  r->last_pts = r1->last_pts;
1536  r->next_pts = r1->next_pts;
1537 
1538  memset(&r->si, 0, sizeof(r->si));
1539 
1540  // Do no call ff_mpeg_update_thread_context on a partially initialized
1541  // decoder context.
1542  if (!s1->context_initialized)
1543  return 0;
1544 
1545  return ff_mpeg_update_thread_context(dst, src);
1546 }
1547 
1548 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n, int slice_count, int buf_size)
1549 {
1550  if (n < slice_count) {
1551  if(avctx->slice_count) return avctx->slice_offset[n];
1552  else return AV_RL32(buf + n*8 - 4) == 1 ? AV_RL32(buf + n*8) : AV_RB32(buf + n*8);
1553  } else
1554  return buf_size;
1555 }
1556 
1557 static int finish_frame(AVCodecContext *avctx, AVFrame *pict)
1558 {
1559  RV34DecContext *r = avctx->priv_data;
1560  MpegEncContext *s = &r->s;
1561  int got_picture = 0, ret;
1562 
1563  ff_er_frame_end(&s->er);
1565  s->mb_num_left = 0;
1566 
1567  if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME))
1568  ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
1569 
1570  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1571  if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
1572  return ret;
1573  ff_print_debug_info(s, s->current_picture_ptr, pict);
1574  ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);
1575  got_picture = 1;
1576  } else if (s->last_picture_ptr) {
1577  if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
1578  return ret;
1579  ff_print_debug_info(s, s->last_picture_ptr, pict);
1580  ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);
1581  got_picture = 1;
1582  }
1583 
1584  return got_picture;
1585 }
1586 
1587 static AVRational update_sar(int old_w, int old_h, AVRational sar, int new_w, int new_h)
1588 {
1589  // attempt to keep aspect during typical resolution switches
1590  if (!sar.num)
1591  sar = (AVRational){1, 1};
1592 
1593  sar = av_mul_q(sar, av_mul_q((AVRational){new_h, new_w}, (AVRational){old_w, old_h}));
1594  return sar;
1595 }
1596 
1598  void *data, int *got_picture_ptr,
1599  AVPacket *avpkt)
1600 {
1601  const uint8_t *buf = avpkt->data;
1602  int buf_size = avpkt->size;
1603  RV34DecContext *r = avctx->priv_data;
1604  MpegEncContext *s = &r->s;
1605  AVFrame *pict = data;
1606  SliceInfo si;
1607  int i, ret;
1608  int slice_count;
1609  const uint8_t *slices_hdr = NULL;
1610  int last = 0;
1611  int faulty_b = 0;
1612  int offset;
1613 
1614  /* no supplementary picture */
1615  if (buf_size == 0) {
1616  /* special case for last picture */
1617  if (s->low_delay==0 && s->next_picture_ptr) {
1618  if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
1619  return ret;
1620  s->next_picture_ptr = NULL;
1621 
1622  *got_picture_ptr = 1;
1623  }
1624  return 0;
1625  }
1626 
1627  if(!avctx->slice_count){
1628  slice_count = (*buf++) + 1;
1629  slices_hdr = buf + 4;
1630  buf += 8 * slice_count;
1631  buf_size -= 1 + 8 * slice_count;
1632  }else
1633  slice_count = avctx->slice_count;
1634 
1635  offset = get_slice_offset(avctx, slices_hdr, 0, slice_count, buf_size);
1636  //parse first slice header to check whether this frame can be decoded
1637  if(offset < 0 || offset > buf_size){
1638  av_log(avctx, AV_LOG_ERROR, "Slice offset is invalid\n");
1639  return AVERROR_INVALIDDATA;
1640  }
1641  init_get_bits(&s->gb, buf+offset, (buf_size-offset)*8);
1642  if(r->parse_slice_header(r, &r->s.gb, &si) < 0 || si.start){
1643  av_log(avctx, AV_LOG_ERROR, "First slice header is incorrect\n");
1644  return AVERROR_INVALIDDATA;
1645  }
1646  if ((!s->last_picture_ptr || !s->last_picture_ptr->f->data[0]) &&
1647  si.type == AV_PICTURE_TYPE_B) {
1648  av_log(avctx, AV_LOG_ERROR, "Invalid decoder state: B-frame without "
1649  "reference data.\n");
1650  faulty_b = 1;
1651  }
1652  if( (avctx->skip_frame >= AVDISCARD_NONREF && si.type==AV_PICTURE_TYPE_B)
1653  || (avctx->skip_frame >= AVDISCARD_NONKEY && si.type!=AV_PICTURE_TYPE_I)
1654  || avctx->skip_frame >= AVDISCARD_ALL)
1655  return avpkt->size;
1656 
1657  /* first slice */
1658  if (si.start == 0) {
1659  if (s->mb_num_left > 0 && s->current_picture_ptr) {
1660  av_log(avctx, AV_LOG_ERROR, "New frame but still %d MB left.\n",
1661  s->mb_num_left);
1662  if (!s->context_reinit)
1663  ff_er_frame_end(&s->er);
1665  }
1666 
1667  if (s->width != si.width || s->height != si.height || s->context_reinit) {
1668  int err;
1669 
1670  av_log(s->avctx, AV_LOG_WARNING, "Changing dimensions to %dx%d\n",
1671  si.width, si.height);
1672 
1673  if (av_image_check_size(si.width, si.height, 0, s->avctx))
1674  return AVERROR_INVALIDDATA;
1675 
1676  s->avctx->sample_aspect_ratio = update_sar(
1677  s->width, s->height, s->avctx->sample_aspect_ratio,
1678  si.width, si.height);
1679  s->width = si.width;
1680  s->height = si.height;
1681 
1682  err = ff_set_dimensions(s->avctx, s->width, s->height);
1683  if (err < 0)
1684  return err;
1685  if ((err = ff_mpv_common_frame_size_change(s)) < 0)
1686  return err;
1687  if ((err = rv34_decoder_realloc(r)) < 0)
1688  return err;
1689  }
1690  if (faulty_b)
1691  return AVERROR_INVALIDDATA;
1692  s->pict_type = si.type ? si.type : AV_PICTURE_TYPE_I;
1693  if (ff_mpv_frame_start(s, s->avctx) < 0)
1694  return -1;
1696  if (!r->tmp_b_block_base) {
1697  int i;
1698 
1699  r->tmp_b_block_base = av_malloc(s->linesize * 48);
1700  for (i = 0; i < 2; i++)
1701  r->tmp_b_block_y[i] = r->tmp_b_block_base
1702  + i * 16 * s->linesize;
1703  for (i = 0; i < 4; i++)
1704  r->tmp_b_block_uv[i] = r->tmp_b_block_base + 32 * s->linesize
1705  + (i >> 1) * 8 * s->uvlinesize
1706  + (i & 1) * 16;
1707  }
1708  r->cur_pts = si.pts;
1709  if (s->pict_type != AV_PICTURE_TYPE_B) {
1710  r->last_pts = r->next_pts;
1711  r->next_pts = r->cur_pts;
1712  } else {
1713  int refdist = GET_PTS_DIFF(r->next_pts, r->last_pts);
1714  int dist0 = GET_PTS_DIFF(r->cur_pts, r->last_pts);
1715  int dist1 = GET_PTS_DIFF(r->next_pts, r->cur_pts);
1716 
1717  if(!refdist){
1718  r->mv_weight1 = r->mv_weight2 = r->weight1 = r->weight2 = 8192;
1719  r->scaled_weight = 0;
1720  }else{
1721  if (FFMAX(dist0, dist1) > refdist)
1722  av_log(avctx, AV_LOG_TRACE, "distance overflow\n");
1723 
1724  r->mv_weight1 = (dist0 << 14) / refdist;
1725  r->mv_weight2 = (dist1 << 14) / refdist;
1726  if((r->mv_weight1|r->mv_weight2) & 511){
1727  r->weight1 = r->mv_weight1;
1728  r->weight2 = r->mv_weight2;
1729  r->scaled_weight = 0;
1730  }else{
1731  r->weight1 = r->mv_weight1 >> 9;
1732  r->weight2 = r->mv_weight2 >> 9;
1733  r->scaled_weight = 1;
1734  }
1735  }
1736  }
1737  s->mb_x = s->mb_y = 0;
1738  ff_thread_finish_setup(s->avctx);
1739  } else if (s->context_reinit) {
1740  av_log(s->avctx, AV_LOG_ERROR, "Decoder needs full frames to "
1741  "reinitialize (start MB is %d).\n", si.start);
1742  return AVERROR_INVALIDDATA;
1743  } else if (HAVE_THREADS &&
1744  (s->avctx->active_thread_type & FF_THREAD_FRAME)) {
1745  av_log(s->avctx, AV_LOG_ERROR, "Decoder needs full frames in frame "
1746  "multithreading mode (start MB is %d).\n", si.start);
1747  return AVERROR_INVALIDDATA;
1748  }
1749 
1750  for(i = 0; i < slice_count; i++){
1751  int offset = get_slice_offset(avctx, slices_hdr, i , slice_count, buf_size);
1752  int offset1 = get_slice_offset(avctx, slices_hdr, i+1, slice_count, buf_size);
1753  int size;
1754 
1755  if(offset < 0 || offset > offset1 || offset1 > buf_size){
1756  av_log(avctx, AV_LOG_ERROR, "Slice offset is invalid\n");
1757  break;
1758  }
1759  size = offset1 - offset;
1760 
1761  r->si.end = s->mb_width * s->mb_height;
1762  s->mb_num_left = r->s.mb_x + r->s.mb_y*r->s.mb_width - r->si.start;
1763 
1764  if(i+1 < slice_count){
1765  int offset2 = get_slice_offset(avctx, slices_hdr, i+2, slice_count, buf_size);
1766  if (offset2 < offset1 || offset2 > buf_size) {
1767  av_log(avctx, AV_LOG_ERROR, "Slice offset is invalid\n");
1768  break;
1769  }
1770  init_get_bits(&s->gb, buf+offset1, (buf_size-offset1)*8);
1771  if(r->parse_slice_header(r, &r->s.gb, &si) < 0){
1772  size = offset2 - offset;
1773  }else
1774  r->si.end = si.start;
1775  }
1776  av_assert0 (size >= 0 && size <= buf_size - offset);
1777  last = rv34_decode_slice(r, r->si.end, buf + offset, size);
1778  if(last)
1779  break;
1780  }
1781 
1782  if (s->current_picture_ptr) {
1783  if (last) {
1784  if(r->loop_filter)
1785  r->loop_filter(r, s->mb_height - 1);
1786 
1787  ret = finish_frame(avctx, pict);
1788  if (ret < 0)
1789  return ret;
1790  *got_picture_ptr = ret;
1791  } else if (HAVE_THREADS &&
1792  (s->avctx->active_thread_type & FF_THREAD_FRAME)) {
1793  av_log(avctx, AV_LOG_INFO, "marking unfished frame as finished\n");
1794  /* always mark the current frame as finished, frame-mt supports
1795  * only complete frames */
1796  ff_er_frame_end(&s->er);
1798  s->mb_num_left = 0;
1799  ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
1800  return AVERROR_INVALIDDATA;
1801  }
1802  }
1803 
1804  return avpkt->size;
1805 }
1806 
1808 {
1809  RV34DecContext *r = avctx->priv_data;
1810 
1811  ff_mpv_common_end(&r->s);
1813 
1814  return 0;
1815 }
RV34DecContext
decoder context
Definition: rv34.h:86
ff_mpv_common_init
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:913
IS_8X8
#define IS_8X8(a)
Definition: mpegutils.h:88
rv34_mb_type_to_lavc
static const int rv34_mb_type_to_lavc[12]
translation of RV30/40 macroblock types to lavc ones
Definition: rv34.c:57
HOR_PRED8x8
#define HOR_PRED8x8
Definition: h264pred.h:69
MB_TYPE_L0
#define MB_TYPE_L0
Definition: mpegutils.h:66
stride
int stride
Definition: mace.c:144
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
rv34_qscale_tab
static const uint16_t rv34_qscale_tab[32]
This table is used for dequantizing.
Definition: rv34data.h:84
rv34_output_intra
static void rv34_output_intra(RV34DecContext *r, int8_t *intra_types, int cbp)
Definition: rv34.c:1087
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:850
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
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
DC_PRED8x8
#define DC_PRED8x8
Definition: h264pred.h:68
rv34_pred_mv_rv3
static void rv34_pred_mv_rv3(RV34DecContext *r, int block_type, int dir)
motion vector prediction - RV3 version
Definition: rv34.c:595
mem_internal.h
DC_128_PRED
@ DC_128_PRED
Definition: vp9.h:58
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:264
RV34VLC::third_pattern
VLC third_pattern[2]
VLCs used for decoding coefficients in the last subblock.
Definition: rv34.h:70
thread.h
rv34_table_inter_secondpat
static const uint8_t rv34_table_inter_secondpat[NUM_INTER_TABLES][2][OTHERBLK_VLC_SIZE]
Definition: rv34vlc.h:3737
ittrans16
static const int ittrans16[4]
mapping of RV30/40 intra 16x16 prediction types to standard H.264 types
Definition: rv34.c:958
num_mvs
static const int num_mvs[RV34_MB_TYPES]
number of motion vectors in each macroblock type
Definition: rv34.c:845
MB_TYPE_16x8
#define MB_TYPE_16x8
Definition: mpegutils.h:54
chroma_coeffs
static const int chroma_coeffs[3]
Definition: rv34.c:641
ff_rv34_get_start_offset
int ff_rv34_get_start_offset(GetBitContext *gb, int mb_size)
Decode starting slice position.
Definition: rv34.c:322
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:310
step
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
Definition: rate_distortion.txt:58
ff_mpv_common_frame_size_change
int ff_mpv_common_frame_size_change(MpegEncContext *s)
Definition: mpegvideo.c:1057
AVCodecContext::slice_offset
int * slice_offset
slice offsets in the frame in bytes
Definition: avcodec.h:744
ff_rv34_decode_update_thread_context
int ff_rv34_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: rv34.c:1516
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
DC_PRED
@ DC_PRED
Definition: vp9.h:48
table
static const uint16_t table[]
Definition: prosumer.c:206
data
const char data[16]
Definition: mxf.c:143
rv34_decoder_realloc
static int rv34_decoder_realloc(RV34DecContext *r)
Definition: rv34.c:1397
VERT_LEFT_PRED
@ VERT_LEFT_PRED
Definition: vp9.h:53
MB_TYPE_16x16
#define MB_TYPE_16x16
Definition: mpegutils.h:53
check_slice_end
static int check_slice_end(RV34DecContext *r, MpegEncContext *s)
Definition: rv34.c:1341
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:798
table_data
static VLC_TYPE table_data[117592][2]
Definition: rv34.c:82
fc
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:551
ff_er_add_slice
void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status)
Add a slice.
Definition: error_resilience.c:829
ff_init_block_index
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:2271
mpegvideo.h
MB_TYPE_L1
#define MB_TYPE_L1
Definition: mpegutils.h:67
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
Picture
Picture.
Definition: mpegpicture.h:45
rv34_set_deblock_coef
static int rv34_set_deblock_coef(RV34DecContext *r)
Definition: rv34.c:1163
mpegutils.h
MB_TYPE_INTRA16x16
#define MB_TYPE_INTRA16x16
Definition: mpegutils.h:51
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:660
thread.h
ff_thread_await_progress
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before ff_thread_await_progress() has been called on them. reget_buffer() and buffer age optimizations no longer work. *The contents of buffers must not be written to after ff_thread_report_progress() has been called on them. This includes draw_edges(). Porting codecs to frame threading
avail_indexes
static const uint8_t avail_indexes[4]
availability index for subblocks
Definition: rv34.c:450
AVCodecContext::slice_count
int slice_count
slice count
Definition: avcodec.h:737
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
A
#define A(x)
Definition: vp56_arith.h:28
decode_subblock
static void decode_subblock(int16_t *dst, int code, const int is_block2, GetBitContext *gb, VLC *vlc, int q)
Decode 2x2 subblock of coefficients.
Definition: rv34.c:233
golomb.h
exp golomb vlc stuff
NUM_INTRA_TABLES
#define NUM_INTRA_TABLES
Definition: rv34vlc.h:32
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
adjust_pred16
static int adjust_pred16(int itype, int up, int left)
Definition: rv34.c:992
RV34_MB_B_FORWARD
@ RV34_MB_B_FORWARD
B-frame macroblock, forward prediction.
Definition: rv34.h:49
VLC_TYPE
#define VLC_TYPE
Definition: vlc.h:24
rv34_decoder_alloc
static int rv34_decoder_alloc(RV34DecContext *r)
Definition: rv34.c:1369
U
#define U(x)
Definition: vp56_arith.h:37
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1673
VERT_PRED
@ VERT_PRED
Definition: vp9.h:46
rv34_pred_mv
static void rv34_pred_mv(RV34DecContext *r, int block_type, int subblock_no, int dmv_no)
motion vector prediction
Definition: rv34.c:459
GetBitContext
Definition: get_bits.h:62
h264_chroma_mc_func
void(* h264_chroma_mc_func)(uint8_t *dst, uint8_t *src, ptrdiff_t srcStride, int h, int x, int y)
Definition: h264chroma.h:25
DIAG_DOWN_RIGHT_PRED
@ DIAG_DOWN_RIGHT_PRED
Definition: vp9.h:50
RV34_MB_B_DIRECT
@ RV34_MB_B_DIRECT
Bidirectionally predicted B-frame macroblock, no motion vectors.
Definition: rv34.h:52
val
static double val(void *priv, double ch)
Definition: aeval.c:76
type
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 type
Definition: writing_filters.txt:86
rv34_count_ones
static const uint8_t rv34_count_ones[16]
number of ones in nibble minus one
Definition: rv34data.h:35
AVRational::num
int num
Numerator.
Definition: rational.h:59
quant
static int quant(float coef, const float Q, const float rounding)
Quantize one coefficient.
Definition: aacenc_utils.h:59
rv34_table_intra_firstpat
static const uint8_t rv34_table_intra_firstpat[NUM_INTRA_TABLES][4][FIRSTBLK_VLC_SIZE]
Definition: rv34vlc.h:940
rv34data.h
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
ff_mpv_common_end
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:1113
avassert.h
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:206
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
HOR_PRED
@ HOR_PRED
Definition: vp9.h:47
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
rv34_pred_4x4_block
static void rv34_pred_4x4_block(RV34DecContext *r, uint8_t *dst, int stride, int itype, int up, int left, int down, int right)
Perform 4x4 intra prediction.
Definition: rv34.c:965
rv34_decode_intra_macroblock
static int rv34_decode_intra_macroblock(RV34DecContext *r, int8_t *intra_types)
Definition: rv34.c:1301
ff_thread_report_progress
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
Definition: pthread_frame.c:588
ZERO8x2
static void ZERO8x2(void *dst, int stride)
Definition: rv34.c:50
mask
static const uint16_t mask[17]
Definition: lzw.c:38
RV34VLC
VLC tables used by the decoder.
Definition: rv34.h:65
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:679
width
#define width
rv34_mc_1mv
static void rv34_mc_1mv(RV34DecContext *r, const int block_type, const int xoff, const int yoff, int mv_off, const int width, const int height, int dir)
Definition: rv34.c:774
rv34_decode_inter_macroblock
static int rv34_decode_inter_macroblock(RV34DecContext *r, int8_t *intra_types)
Definition: rv34.c:1193
intra_vlcs
static RV34VLC intra_vlcs[NUM_INTRA_TABLES]
Definition: rv34.c:73
s
#define s(width, name)
Definition: cbs_vp9.c:257
RV34VLC::second_pattern
VLC second_pattern[2]
VLCs used for decoding coefficients in the subblocks 2 and 3.
Definition: rv34.h:69
IS_16X8
#define IS_16X8(a)
Definition: mpegutils.h:86
s1
#define s1
Definition: regdef.h:38
VERT_LEFT_PRED_RV40_NODOWN
#define VERT_LEFT_PRED_RV40_NODOWN
Definition: h264pred.h:56
RV34VLC::cbp
VLC cbp[2][4]
VLCs used for coded block patterns decoding.
Definition: rv34.h:67
CBPPAT_VLC_SIZE
#define CBPPAT_VLC_SIZE
Definition: rv34vlc.h:35
ff_mpeg_er_frame_start
void ff_mpeg_er_frame_start(MpegEncContext *s)
Definition: mpeg_er.c:46
calc_add_mv
static int calc_add_mv(RV34DecContext *r, int dir, int val)
Calculate motion vector component that should be added for direct blocks.
Definition: rv34.c:513
bits
uint8_t bits
Definition: vp3data.h:141
LOCAL_ALIGNED_16
#define LOCAL_ALIGNED_16(t, v,...)
Definition: mem_internal.h:130
LEFT_DC_PRED
@ LEFT_DC_PRED
Definition: vp9.h:56
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
IS_SKIP
#define IS_SKIP(a)
Definition: mpegutils.h:80
CBP_VLC_SIZE
#define CBP_VLC_SIZE
Definition: rv34vlc.h:36
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
finish_frame
static int finish_frame(AVCodecContext *avctx, AVFrame *pict)
Definition: rv34.c:1557
rv34_mb_max_sizes
static const uint16_t rv34_mb_max_sizes[6]
maximum number of macroblocks for each of the possible slice offset sizes
Definition: rv34data.h:106
f
#define f(width, name)
Definition: cbs_vp9.c:255
mul
static float mul(float src0, float src1)
Definition: dnn_backend_native_layer_mathbinary.c:39
MB_TYPE_8x16
#define MB_TYPE_8x16
Definition: mpegutils.h:55
TOP_DC_PRED8x8
#define TOP_DC_PRED8x8
Definition: h264pred.h:75
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:54
rv34_inter_coeff
static const uint8_t rv34_inter_coeff[NUM_INTER_TABLES][COEFF_VLC_SIZE]
Definition: rv34vlc.h:4024
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:173
decode_subblock3
static void decode_subblock3(int16_t *dst, int code, GetBitContext *gb, VLC *vlc, int q_dc, int q_ac1, int q_ac2)
Definition: rv34.c:257
NULL
#define NULL
Definition: coverity.c:32
GET_PTS_DIFF
#define GET_PTS_DIFF(a, b)
Definition: rv34.c:508
chroma_mc
#define chroma_mc(a)
Definition: vc1dsp.c:783
rv34_decode_slice
static int rv34_decode_slice(RV34DecContext *r, int end, const uint8_t *buf, int buf_size)
Definition: rv34.c:1404
rv34_init_tables
static av_cold void rv34_init_tables(void)
Initialize all tables.
Definition: rv34.c:125
ff_mpv_idct_init
av_cold void ff_mpv_idct_init(MpegEncContext *s)
Definition: mpegvideo.c:331
RV34_MB_SKIP
@ RV34_MB_SKIP
Skipped block.
Definition: rv34.h:51
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
COEFF_VLC_SIZE
#define COEFF_VLC_SIZE
Definition: rv34vlc.h:39
rv34_table_intra_cbppat
static const uint8_t rv34_table_intra_cbppat[NUM_INTRA_TABLES][2][CBPPAT_VLC_SIZE]
Definition: rv34vlc.h:42
MB_TYPE_8x8
#define MB_TYPE_8x8
Definition: mpegutils.h:56
SliceInfo::type
int type
slice type (intra, inter)
Definition: rv34.h:76
ER_MB_ERROR
#define ER_MB_ERROR
Definition: error_resilience.h:38
ff_rv34_decode_frame
int ff_rv34_decode_frame(AVCodecContext *avctx, void *data, int *got_picture_ptr, AVPacket *avpkt)
Definition: rv34.c:1597
V
#define V
Definition: avdct.c:30
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:499
src
#define src
Definition: vp8dsp.c:255
RV34VLC::cbppattern
VLC cbppattern[2]
VLCs used for pattern of coded block patterns decoding.
Definition: rv34.h:66
mathops.h
VERT_PRED8x8
#define VERT_PRED8x8
Definition: h264pred.h:70
qpeldsp.h
ff_init_vlc_sparse
int ff_init_vlc_sparse(VLC *vlc_arg, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags)
Definition: bitstream.c:323
rv34_table_intra_secondpat
static const uint8_t rv34_table_intra_secondpat[NUM_INTRA_TABLES][2][OTHERBLK_VLC_SIZE]
Definition: rv34vlc.h:2074
MAX_VLC_SIZE
#define MAX_VLC_SIZE
Definition: rv34vlc.h:40
rv34.h
AVOnce
#define AVOnce
Definition: thread.h:172
rv34_decode_mv
static int rv34_decode_mv(RV34DecContext *r, int block_type)
Decode motion vector differences and perform motion vector reconstruction and motion compensation.
Definition: rv34.c:851
qpel_mc_func
void(* qpel_mc_func)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)
Definition: qpeldsp.h:65
RV34_MB_P_8x8
@ RV34_MB_P_8x8
P-frame macroblock, 8x8 motion compensation partitions.
Definition: rv34.h:48
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
rv34_table_intra_thirdpat
static const uint8_t rv34_table_intra_thirdpat[NUM_INTRA_TABLES][2][OTHERBLK_VLC_SIZE]
Definition: rv34vlc.h:2177
VLC::table_allocated
int table_allocated
Definition: vlc.h:29
decode_coeff
static void decode_coeff(int16_t *dst, int coef, int esc, GetBitContext *gb, VLC *vlc, int q)
Get one coefficient value from the bitstream and store it.
Definition: rv34.c:213
rv34_mc_2mv_skip
static void rv34_mc_2mv_skip(RV34DecContext *r)
Definition: rv34.c:824
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:53
rv34_cbp_code
static const uint8_t rv34_cbp_code[16]
values used to reconstruct coded block pattern
Definition: rv34data.h:42
is_mv_diff_gt_3
static int is_mv_diff_gt_3(int16_t(*motion_val)[2], int step)
Definition: rv34.c:1151
AVPacket::size
int size
Definition: packet.h:374
dc
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
Definition: snow.txt:400
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:327
RV34_MB_B_BACKWARD
@ RV34_MB_B_BACKWARD
B-frame macroblock, backward prediction.
Definition: rv34.h:50
FF_QSCALE_TYPE_MPEG1
#define FF_QSCALE_TYPE_MPEG1
Definition: internal.h:96
rectangle.h
update_sar
static AVRational update_sar(int old_w, int old_h, AVRational sar, int new_w, int new_h)
Definition: rv34.c:1587
FIRSTBLK_VLC_SIZE
#define FIRSTBLK_VLC_SIZE
Definition: rv34vlc.h:37
get_interleaved_se_golomb
static int get_interleaved_se_golomb(GetBitContext *gb)
Definition: golomb.h:303
RV34_MB_P_8x16
@ RV34_MB_P_8x16
P-frame macroblock, 8x16 motion compensation partitions.
Definition: rv34.h:54
size
int size
Definition: twinvq_data.h:10344
VERT_RIGHT_PRED
@ VERT_RIGHT_PRED
Definition: vp9.h:51
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
DC_128_PRED8x8
#define DC_128_PRED8x8
Definition: h264pred.h:76
MB_TYPE_SKIP
#define MB_TYPE_SKIP
Definition: mpegutils.h:61
rv34_inter_cbppat
static const uint8_t rv34_inter_cbppat[NUM_INTER_TABLES][CBPPAT_VLC_SIZE]
Definition: rv34vlc.h:2305
height
#define height
SliceInfo::pts
int pts
frame timestamp
Definition: rv34.h:82
ff_mpeg_update_thread_context
int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: mpegvideo.c:524
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
ff_mpv_export_qp_table
int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
Definition: mpegvideo.c:1424
OTHERBLK_VLC_SIZE
#define OTHERBLK_VLC_SIZE
Definition: rv34vlc.h:38
ff_print_debug_info
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
Definition: mpegvideo.c:1417
IS_INTRA16x16
#define IS_INTRA16x16(a)
Definition: mpegutils.h:75
Picture::motion_val
int16_t(*[2] motion_val)[2]
Definition: mpegpicture.h:53
PLANE_PRED8x8
#define PLANE_PRED8x8
Definition: h264pred.h:71
Y
#define Y
Definition: boxblur.h:37
rv34_output_i16x16
static void rv34_output_i16x16(RV34DecContext *r, int8_t *intra_types, int cbp)
Definition: rv34.c:1024
RV34_MB_TYPE_INTRA16x16
@ RV34_MB_TYPE_INTRA16x16
Intra macroblock with DCs in a separate 4x4 block.
Definition: rv34.h:46
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
rv34_pred_mv_b
static void rv34_pred_mv_b(RV34DecContext *r, int block_type, int dir)
motion vector prediction for B-frames
Definition: rv34.c:543
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1451
rv34_table_inter_thirdpat
static const uint8_t rv34_table_inter_thirdpat[NUM_INTER_TABLES][2][OTHERBLK_VLC_SIZE]
Definition: rv34vlc.h:3880
DIAG_DOWN_LEFT_PRED_RV40_NODOWN
#define DIAG_DOWN_LEFT_PRED_RV40_NODOWN
Definition: h264pred.h:54
SliceInfo::height
int height
coded height
Definition: rv34.h:81
ff_update_block_index
static void ff_update_block_index(MpegEncContext *s)
Definition: mpegvideo.h:742
MB_TYPE_L0L1
#define MB_TYPE_L0L1
Definition: mpegutils.h:68
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
AV_CODEC_ID_RV40
@ AV_CODEC_ID_RV40
Definition: codec_id.h:119
FMT_H263
@ FMT_H263
Definition: mpegutils.h:125
part_sizes_h
static const uint8_t part_sizes_h[RV34_MB_TYPES]
macroblock partition height in 8x8 blocks
Definition: rv34.c:447
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:447
rv34_table_inter_firstpat
static const uint8_t rv34_table_inter_firstpat[NUM_INTER_TABLES][2][FIRSTBLK_VLC_SIZE]
Definition: rv34vlc.h:2936
internal.h
HOR_UP_PRED_RV40_NODOWN
#define HOR_UP_PRED_RV40_NODOWN
Definition: h264pred.h:55
rv34_mc_2mv
static void rv34_mc_2mv(RV34DecContext *r, const int block_type)
Definition: rv34.c:805
rv34_gen_vlc
static void rv34_gen_vlc(const uint8_t *bits, int size, VLC *vlc, const uint8_t *syms, int *offset)
Generate VLC from codeword lengths.
Definition: rv34.c:92
rv34_table_intra_cbp
static const uint8_t rv34_table_intra_cbp[NUM_INTRA_TABLES][8][CBP_VLC_SIZE]
Definition: rv34vlc.h:886
RV34_MB_TYPE_INTRA
@ RV34_MB_TYPE_INTRA
Intra macroblock.
Definition: rv34.h:45
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
SUINT
#define SUINT
Definition: dct32_template.c:30
RV34_MB_TYPES
@ RV34_MB_TYPES
Definition: rv34.h:57
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:263
rv34_quant_to_vlc_set
static const uint8_t rv34_quant_to_vlc_set[2][32]
tables used to translate a quantizer value into a VLC set for decoding The first table is used for in...
Definition: rv34data.h:95
SliceInfo
essential slice information
Definition: rv34.h:75
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:593
ff_mpv_frame_end
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1409
get_slice_offset
static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n, int slice_count, int buf_size)
Definition: rv34.c:1548
mod
static int mod(int a, int b)
Modulo operation with only positive remainders.
Definition: vf_v360.c:749
LEFT_DC_PRED8x8
#define LEFT_DC_PRED8x8
Definition: h264pred.h:74
decode_subblock1
static void decode_subblock1(int16_t *dst, int code, GetBitContext *gb, VLC *vlc, int q)
Decode a single coefficient.
Definition: rv34.c:251
avcodec.h
VLC::bits
int bits
Definition: vlc.h:27
mid_pred
#define mid_pred
Definition: mathops.h:97
ret
ret
Definition: filter_design.txt:187
INIT_VLC_STATIC_OVERLONG
#define INIT_VLC_STATIC_OVERLONG
Definition: vlc.h:96
INVALID_VLC
#define INVALID_VLC
Definition: golomb.h:38
rv4_weight
static void rv4_weight(RV34DecContext *r)
Definition: rv34.c:783
ff_mpv_frame_start
int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function called after decoding the header and before a frame is decoded.
Definition: mpegvideo.c:1185
ff_thread_finish_setup
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call ff_thread_finish_setup() afterwards. If some code can 't be moved
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
rv34_inter_cbp
static const uint8_t rv34_inter_cbp[NUM_INTER_TABLES][4][CBP_VLC_SIZE]
Definition: rv34vlc.h:2890
B
#define B
Definition: huffyuvdsp.h:32
AVCodecContext
main external API structure.
Definition: avcodec.h:383
SliceInfo::start
int start
Definition: rv34.h:79
Picture::mb_type
uint32_t * mb_type
types and macros are defined in mpegutils.h
Definition: mpegpicture.h:56
ThreadFrame
Definition: thread.h:34
rv34_decode_inter_mb_header
static int rv34_decode_inter_mb_header(RV34DecContext *r, int8_t *intra_types)
Decode inter macroblock header and return CBP in case of success, -1 otherwise.
Definition: rv34.c:381
ff_h264_pred_init
av_cold void ff_h264_pred_init(H264PredContext *h, int codec_id, const int bit_depth, int chroma_format_idc)
Set the intra prediction function pointers.
Definition: h264pred.c:413
HOR_UP_PRED
@ HOR_UP_PRED
Definition: vp9.h:54
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
rv34_intra_coeff
static const uint8_t rv34_intra_coeff[NUM_INTRA_TABLES][COEFF_VLC_SIZE]
Definition: rv34vlc.h:2281
error_resilience.h
part_sizes_w
static const uint8_t part_sizes_w[RV34_MB_TYPES]
macroblock partition width in 8x8 blocks
Definition: rv34.c:444
VLC
Definition: vlc.h:26
ittrans
static const int ittrans[9]
mapping of RV30/40 intra prediction types to standard H.264 types
Definition: rv34.c:952
fill_rectangle
static void fill_rectangle(int x, int y, int w, int h)
Definition: ffplay.c:826
rv34_chroma_quant
static const uint8_t rv34_chroma_quant[2][32]
quantizer values used for AC and DC coefficients in chroma blocks
Definition: rv34data.h:74
rv34_decode_block
static int rv34_decode_block(int16_t *dst, GetBitContext *gb, RV34VLC *rvlc, int fc, int sc, int q_dc, int q_ac1, int q_ac2)
Decode coefficients for 4x4 block.
Definition: rv34.c:279
rv34_decode_intra_mb_header
static int rv34_decode_intra_mb_header(RV34DecContext *r, int8_t *intra_types)
Decode intra macroblock header and return CBP in case of success, -1 otherwise.
Definition: rv34.c:346
HOR_DOWN_PRED
@ HOR_DOWN_PRED
Definition: vp9.h:52
rv34_mb_bits_sizes
static const uint8_t rv34_mb_bits_sizes[6]
bits needed to code the slice offset for the given size
Definition: rv34data.h:111
IS_8X16
#define IS_8X16(a)
Definition: mpegutils.h:87
rv34_process_block
static void rv34_process_block(RV34DecContext *r, uint8_t *pdst, int stride, int fc, int sc, int q_dc, int q_ac)
Definition: rv34.c:1008
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
RV34_MB_P_MIX16x16
@ RV34_MB_P_MIX16x16
P-frame macroblock with DCs in a separate 4x4 block, one motion vector.
Definition: rv34.h:56
rv34vlc.h
VLC::table_size
int table_size
Definition: vlc.h:29
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
RV34VLC::coefficient
VLC coefficient
VLCs used for decoding big coefficients.
Definition: rv34.h:71
RV34VLC::first_pattern
VLC first_pattern[4]
VLCs used for decoding coefficients in the first subblock.
Definition: rv34.h:68
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:86
rv34_mc
static void rv34_mc(RV34DecContext *r, const int block_type, const int xoff, const int yoff, int mv_off, const int width, const int height, int dir, const int thirdpel, int weighted, qpel_mc_func(*qpel_mc)[16], h264_chroma_mc_func(*chroma_mc))
generic motion compensation function
Definition: rv34.c:658
ER_MB_END
#define ER_MB_END
Definition: error_resilience.h:39
MB_TYPE_SEPARATE_DC
#define MB_TYPE_SEPARATE_DC
Definition: rv34.h:38
RV34_MB_P_16x8
@ RV34_MB_P_16x8
P-frame macroblock, 16x8 motion compensation partitions.
Definition: rv34.h:53
TOP_DC_PRED
@ TOP_DC_PRED
Definition: vp9.h:57
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
ff_er_frame_end
void ff_er_frame_end(ERContext *s)
Definition: error_resilience.c:899
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
inter_vlcs
static RV34VLC inter_vlcs[NUM_INTER_TABLES]
Definition: rv34.c:73
mpeg_er.h
d
d
Definition: ffmpeg_filter.c:156
DIAG_DOWN_LEFT_PRED
@ DIAG_DOWN_LEFT_PRED
Definition: vp9.h:49
SliceInfo::width
int width
coded width
Definition: rv34.h:80
imgutils.h
MB_TYPE_DIRECT2
#define MB_TYPE_DIRECT2
Definition: mpegutils.h:58
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
RV34_MB_P_16x16
@ RV34_MB_P_16x16
P-frame macroblock, one motion frame.
Definition: rv34.h:47
choose_vlc_set
static RV34VLC * choose_vlc_set(int quant, int mod, int type)
Select VLC set for decoding from current quantizer, modifier and frame type.
Definition: rv34.c:334
coeff
static const double coeff[2][5]
Definition: vf_owdenoise.c:78
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:61
RV34_MB_B_BIDIR
@ RV34_MB_B_BIDIR
Bidirectionally predicted B-frame macroblock, two motion vectors.
Definition: rv34.h:55
modulo_three_table
static const uint8_t modulo_three_table[108]
precalculated results of division by three and modulo three for values 0-107
Definition: rv34data.h:53
rv34_decode_cbp
static int rv34_decode_cbp(GetBitContext *gb, RV34VLC *vlc, int table)
Decode coded block pattern.
Definition: rv34.c:180
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
ff_mpv_decode_init
void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Initialize the given MpegEncContext for decoding.
Definition: mpegvideo.c:699
AVDISCARD_NONREF
@ AVDISCARD_NONREF
discard all non reference
Definition: defs.h:50
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:71
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
video_enc_params.h
rv34_decoder_free
static void rv34_decoder_free(RV34DecContext *r)
Definition: rv34.c:1357
shifts
static const uint8_t shifts[2][12]
Definition: camellia.c:174
MB_TYPE_INTRA
#define MB_TYPE_INTRA
Definition: mpegutils.h:72
NUM_INTER_TABLES
#define NUM_INTER_TABLES
Definition: rv34vlc.h:33
rv34_pred_b_vector
static void rv34_pred_b_vector(int A[2], int B[2], int C[2], int A_avail, int B_avail, int C_avail, int *mx, int *my)
Predict motion vector for B-frame macroblock.
Definition: rv34.c:523