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);
339  return type ? &inter_vlcs[rv34_quant_to_vlc_set[1][quant]]
340  : &intra_vlcs[rv34_quant_to_vlc_set[0][quant]];
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){
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  }
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;
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;
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,
781 }
782 
783 static void rv4_weight(RV34DecContext *r)
784 {
786  r->tmp_b_block_y[0],
787  r->tmp_b_block_y[1],
788  r->weight1,
789  r->weight2,
790  r->s.linesize);
792  r->tmp_b_block_uv[0],
793  r->tmp_b_block_uv[2],
794  r->weight1,
795  r->weight2,
796  r->s.uvlinesize);
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,
812  if(!weighted){
813  rv34_mc(r, block_type, 0, 0, 0, 2, 2, 1, r->rv30, 0,
814  r->rdsp.avg_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,
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,
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,
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))
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
899  rv34_mc_2mv_skip(r);
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 
1008 static inline void rv34_process_block(RV34DecContext *r,
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 {
1360  r->intra_types = NULL;
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));
1378  sizeof(*r->deblock_coefs));
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  rv34_decoder_free(r);
1387  return AVERROR(ENOMEM);
1388  }
1389 
1391 
1392  return 0;
1393 }
1394 
1395 
1397 {
1398  rv34_decoder_free(r);
1399  return rv34_decoder_alloc(r);
1400 }
1401 
1402 
1403 static int rv34_decode_slice(RV34DecContext *r, int end, const uint8_t* buf, int buf_size)
1404 {
1405  MpegEncContext *s = &r->s;
1406  GetBitContext *gb = &s->gb;
1407  int mb_pos, slice_type;
1408  int res;
1409 
1410  init_get_bits(&r->s.gb, buf, buf_size*8);
1411  res = r->parse_slice_header(r, gb, &r->si);
1412  if(res < 0){
1413  av_log(s->avctx, AV_LOG_ERROR, "Incorrect or unknown slice header\n");
1414  return -1;
1415  }
1416 
1417  slice_type = r->si.type ? r->si.type : AV_PICTURE_TYPE_I;
1418  if (slice_type != s->pict_type) {
1419  av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
1420  return AVERROR_INVALIDDATA;
1421  }
1422  if (s->width != r->si.width || s->height != r->si.height) {
1423  av_log(s->avctx, AV_LOG_ERROR, "Size mismatch\n");
1424  return AVERROR_INVALIDDATA;
1425  }
1426 
1427  r->si.end = end;
1428  s->qscale = r->si.quant;
1429  s->mb_num_left = r->si.end - r->si.start;
1430  r->s.mb_skip_run = 0;
1431 
1432  mb_pos = s->mb_x + s->mb_y * s->mb_width;
1433  if(r->si.start != mb_pos){
1434  av_log(s->avctx, AV_LOG_ERROR, "Slice indicates MB offset %d, got %d\n", r->si.start, mb_pos);
1435  s->mb_x = r->si.start % s->mb_width;
1436  s->mb_y = r->si.start / s->mb_width;
1437  }
1438  memset(r->intra_types_hist, -1, r->intra_types_stride * 4 * 2 * sizeof(*r->intra_types_hist));
1439  s->first_slice_line = 1;
1440  s->resync_mb_x = s->mb_x;
1441  s->resync_mb_y = s->mb_y;
1442 
1444  while(!check_slice_end(r, s)) {
1446 
1447  if(r->si.type)
1448  res = rv34_decode_inter_macroblock(r, r->intra_types + s->mb_x * 4 + 4);
1449  else
1450  res = rv34_decode_intra_macroblock(r, r->intra_types + s->mb_x * 4 + 4);
1451  if(res < 0){
1452  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_ERROR);
1453  return -1;
1454  }
1455  if (++s->mb_x == s->mb_width) {
1456  s->mb_x = 0;
1457  s->mb_y++;
1459 
1460  memmove(r->intra_types_hist, r->intra_types, r->intra_types_stride * 4 * sizeof(*r->intra_types_hist));
1461  memset(r->intra_types, -1, r->intra_types_stride * 4 * sizeof(*r->intra_types_hist));
1462 
1463  if(r->loop_filter && s->mb_y >= 2)
1464  r->loop_filter(r, s->mb_y - 2);
1465 
1466  if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME))
1468  s->mb_y - 2, 0);
1469 
1470  }
1471  if(s->mb_x == s->resync_mb_x)
1472  s->first_slice_line=0;
1473  s->mb_num_left--;
1474  }
1475  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END);
1476 
1477  return s->mb_y == s->mb_height;
1478 }
1479 
1480 /** @} */ // reconstruction group end
1481 
1482 /**
1483  * Initialize decoder.
1484  */
1486 {
1487  static AVOnce init_static_once = AV_ONCE_INIT;
1488  RV34DecContext *r = avctx->priv_data;
1489  MpegEncContext *s = &r->s;
1490  int ret;
1491 
1492  ff_mpv_decode_init(s, avctx);
1493  s->out_format = FMT_H263;
1494 
1495  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
1496  avctx->has_b_frames = 1;
1497  s->low_delay = 0;
1498 
1499  ff_mpv_idct_init(s);
1500  if ((ret = ff_mpv_common_init(s)) < 0)
1501  return ret;
1502 
1503  ff_h264_pred_init(&r->h, AV_CODEC_ID_RV40, 8, 1);
1504 
1505 #if CONFIG_RV30_DECODER
1506  if (avctx->codec_id == AV_CODEC_ID_RV30)
1507  ff_rv30dsp_init(&r->rdsp);
1508 #endif
1509 #if CONFIG_RV40_DECODER
1510  if (avctx->codec_id == AV_CODEC_ID_RV40)
1511  ff_rv40dsp_init(&r->rdsp);
1512 #endif
1513 
1514  if ((ret = rv34_decoder_alloc(r)) < 0) {
1515  ff_mpv_common_end(&r->s);
1516  return ret;
1517  }
1518 
1519  ff_thread_once(&init_static_once, rv34_init_tables);
1520 
1521  return 0;
1522 }
1523 
1525 {
1526  RV34DecContext *r = dst->priv_data, *r1 = src->priv_data;
1527  MpegEncContext * const s = &r->s, * const s1 = &r1->s;
1528  int err;
1529 
1530  if (dst == src || !s1->context_initialized)
1531  return 0;
1532 
1533  if (s->height != s1->height || s->width != s1->width) {
1534  s->height = s1->height;
1535  s->width = s1->width;
1536  if ((err = ff_mpv_common_frame_size_change(s)) < 0)
1537  return err;
1538  if ((err = rv34_decoder_realloc(r)) < 0)
1539  return err;
1540  }
1541 
1542  r->cur_pts = r1->cur_pts;
1543  r->last_pts = r1->last_pts;
1544  r->next_pts = r1->next_pts;
1545 
1546  memset(&r->si, 0, sizeof(r->si));
1547 
1548  // Do no call ff_mpeg_update_thread_context on a partially initialized
1549  // decoder context.
1550  if (!s1->context_initialized)
1551  return 0;
1552 
1553  return ff_mpeg_update_thread_context(dst, src);
1554 }
1555 
1556 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n, int slice_count, int buf_size)
1557 {
1558  if (n < slice_count) {
1559  if(avctx->slice_count) return avctx->slice_offset[n];
1560  else return AV_RL32(buf + n*8 - 4) == 1 ? AV_RL32(buf + n*8) : AV_RB32(buf + n*8);
1561  } else
1562  return buf_size;
1563 }
1564 
1565 static int finish_frame(AVCodecContext *avctx, AVFrame *pict)
1566 {
1567  RV34DecContext *r = avctx->priv_data;
1568  MpegEncContext *s = &r->s;
1569  int got_picture = 0, ret;
1570 
1571  ff_er_frame_end(&s->er);
1572  ff_mpv_frame_end(s);
1573  s->mb_num_left = 0;
1574 
1575  if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME))
1577 
1578  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1579  if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
1580  return ret;
1583  got_picture = 1;
1584  } else if (s->last_picture_ptr) {
1585  if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
1586  return ret;
1589  got_picture = 1;
1590  }
1591 
1592  return got_picture;
1593 }
1594 
1595 static AVRational update_sar(int old_w, int old_h, AVRational sar, int new_w, int new_h)
1596 {
1597  // attempt to keep aspect during typical resolution switches
1598  if (!sar.num)
1599  sar = (AVRational){1, 1};
1600 
1601  sar = av_mul_q(sar, av_mul_q((AVRational){new_h, new_w}, (AVRational){old_w, old_h}));
1602  return sar;
1603 }
1604 
1606  void *data, int *got_picture_ptr,
1607  AVPacket *avpkt)
1608 {
1609  const uint8_t *buf = avpkt->data;
1610  int buf_size = avpkt->size;
1611  RV34DecContext *r = avctx->priv_data;
1612  MpegEncContext *s = &r->s;
1613  AVFrame *pict = data;
1614  SliceInfo si;
1615  int i, ret;
1616  int slice_count;
1617  const uint8_t *slices_hdr = NULL;
1618  int last = 0;
1619  int faulty_b = 0;
1620  int offset;
1621 
1622  /* no supplementary picture */
1623  if (buf_size == 0) {
1624  /* special case for last picture */
1625  if (s->low_delay==0 && s->next_picture_ptr) {
1626  if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
1627  return ret;
1628  s->next_picture_ptr = NULL;
1629 
1630  *got_picture_ptr = 1;
1631  }
1632  return 0;
1633  }
1634 
1635  if(!avctx->slice_count){
1636  slice_count = (*buf++) + 1;
1637  slices_hdr = buf + 4;
1638  buf += 8 * slice_count;
1639  buf_size -= 1 + 8 * slice_count;
1640  }else
1641  slice_count = avctx->slice_count;
1642 
1643  offset = get_slice_offset(avctx, slices_hdr, 0, slice_count, buf_size);
1644  //parse first slice header to check whether this frame can be decoded
1645  if(offset < 0 || offset > buf_size){
1646  av_log(avctx, AV_LOG_ERROR, "Slice offset is invalid\n");
1647  return AVERROR_INVALIDDATA;
1648  }
1649  init_get_bits(&s->gb, buf+offset, (buf_size-offset)*8);
1650  if(r->parse_slice_header(r, &r->s.gb, &si) < 0 || si.start){
1651  av_log(avctx, AV_LOG_ERROR, "First slice header is incorrect\n");
1652  return AVERROR_INVALIDDATA;
1653  }
1654  if ((!s->last_picture_ptr || !s->last_picture_ptr->f->data[0]) &&
1655  si.type == AV_PICTURE_TYPE_B) {
1656  av_log(avctx, AV_LOG_ERROR, "Invalid decoder state: B-frame without "
1657  "reference data.\n");
1658  faulty_b = 1;
1659  }
1660  if( (avctx->skip_frame >= AVDISCARD_NONREF && si.type==AV_PICTURE_TYPE_B)
1661  || (avctx->skip_frame >= AVDISCARD_NONKEY && si.type!=AV_PICTURE_TYPE_I)
1662  || avctx->skip_frame >= AVDISCARD_ALL)
1663  return avpkt->size;
1664 
1665  /* first slice */
1666  if (si.start == 0) {
1667  if (s->mb_num_left > 0 && s->current_picture_ptr) {
1668  av_log(avctx, AV_LOG_ERROR, "New frame but still %d MB left.\n",
1669  s->mb_num_left);
1670  ff_er_frame_end(&s->er);
1671  ff_mpv_frame_end(s);
1672  }
1673 
1674  if (s->width != si.width || s->height != si.height) {
1675  int err;
1676 
1677  av_log(s->avctx, AV_LOG_WARNING, "Changing dimensions to %dx%d\n",
1678  si.width, si.height);
1679 
1680  if (av_image_check_size(si.width, si.height, 0, s->avctx))
1681  return AVERROR_INVALIDDATA;
1682 
1684  s->width, s->height, s->avctx->sample_aspect_ratio,
1685  si.width, si.height);
1686  s->width = si.width;
1687  s->height = si.height;
1688 
1689  err = ff_set_dimensions(s->avctx, s->width, s->height);
1690  if (err < 0)
1691  return err;
1692 
1693  if ((err = ff_mpv_common_frame_size_change(s)) < 0)
1694  return err;
1695  if ((err = rv34_decoder_realloc(r)) < 0)
1696  return err;
1697  }
1698  if (faulty_b)
1699  return AVERROR_INVALIDDATA;
1700  s->pict_type = si.type ? si.type : AV_PICTURE_TYPE_I;
1701  if (ff_mpv_frame_start(s, s->avctx) < 0)
1702  return -1;
1704  if (!r->tmp_b_block_base) {
1705  int i;
1706 
1707  r->tmp_b_block_base = av_malloc(s->linesize * 48);
1708  for (i = 0; i < 2; i++)
1709  r->tmp_b_block_y[i] = r->tmp_b_block_base
1710  + i * 16 * s->linesize;
1711  for (i = 0; i < 4; i++)
1712  r->tmp_b_block_uv[i] = r->tmp_b_block_base + 32 * s->linesize
1713  + (i >> 1) * 8 * s->uvlinesize
1714  + (i & 1) * 16;
1715  }
1716  r->cur_pts = si.pts;
1717  if (s->pict_type != AV_PICTURE_TYPE_B) {
1718  r->last_pts = r->next_pts;
1719  r->next_pts = r->cur_pts;
1720  } else {
1721  int refdist = GET_PTS_DIFF(r->next_pts, r->last_pts);
1722  int dist0 = GET_PTS_DIFF(r->cur_pts, r->last_pts);
1723  int dist1 = GET_PTS_DIFF(r->next_pts, r->cur_pts);
1724 
1725  if(!refdist){
1726  r->mv_weight1 = r->mv_weight2 = r->weight1 = r->weight2 = 8192;
1727  r->scaled_weight = 0;
1728  }else{
1729  if (FFMAX(dist0, dist1) > refdist)
1730  av_log(avctx, AV_LOG_TRACE, "distance overflow\n");
1731 
1732  r->mv_weight1 = (dist0 << 14) / refdist;
1733  r->mv_weight2 = (dist1 << 14) / refdist;
1734  if((r->mv_weight1|r->mv_weight2) & 511){
1735  r->weight1 = r->mv_weight1;
1736  r->weight2 = r->mv_weight2;
1737  r->scaled_weight = 0;
1738  }else{
1739  r->weight1 = r->mv_weight1 >> 9;
1740  r->weight2 = r->mv_weight2 >> 9;
1741  r->scaled_weight = 1;
1742  }
1743  }
1744  }
1745  s->mb_x = s->mb_y = 0;
1747  } else if (HAVE_THREADS &&
1749  av_log(s->avctx, AV_LOG_ERROR, "Decoder needs full frames in frame "
1750  "multithreading mode (start MB is %d).\n", si.start);
1751  return AVERROR_INVALIDDATA;
1752  }
1753 
1754  for(i = 0; i < slice_count; i++){
1755  int offset = get_slice_offset(avctx, slices_hdr, i , slice_count, buf_size);
1756  int offset1 = get_slice_offset(avctx, slices_hdr, i+1, slice_count, buf_size);
1757  int size;
1758 
1759  if(offset < 0 || offset > offset1 || offset1 > buf_size){
1760  av_log(avctx, AV_LOG_ERROR, "Slice offset is invalid\n");
1761  break;
1762  }
1763  size = offset1 - offset;
1764 
1765  r->si.end = s->mb_width * s->mb_height;
1766  s->mb_num_left = r->s.mb_x + r->s.mb_y*r->s.mb_width - r->si.start;
1767 
1768  if(i+1 < slice_count){
1769  int offset2 = get_slice_offset(avctx, slices_hdr, i+2, slice_count, buf_size);
1770  if (offset2 < offset1 || offset2 > buf_size) {
1771  av_log(avctx, AV_LOG_ERROR, "Slice offset is invalid\n");
1772  break;
1773  }
1774  init_get_bits(&s->gb, buf+offset1, (buf_size-offset1)*8);
1775  if(r->parse_slice_header(r, &r->s.gb, &si) < 0){
1776  size = offset2 - offset;
1777  }else
1778  r->si.end = si.start;
1779  }
1780  av_assert0 (size >= 0 && size <= buf_size - offset);
1781  last = rv34_decode_slice(r, r->si.end, buf + offset, size);
1782  if(last)
1783  break;
1784  }
1785 
1786  if (s->current_picture_ptr) {
1787  if (last) {
1788  if(r->loop_filter)
1789  r->loop_filter(r, s->mb_height - 1);
1790 
1791  ret = finish_frame(avctx, pict);
1792  if (ret < 0)
1793  return ret;
1794  *got_picture_ptr = ret;
1795  } else if (HAVE_THREADS &&
1797  av_log(avctx, AV_LOG_INFO, "marking unfished frame as finished\n");
1798  /* always mark the current frame as finished, frame-mt supports
1799  * only complete frames */
1800  ff_er_frame_end(&s->er);
1801  ff_mpv_frame_end(s);
1802  s->mb_num_left = 0;
1804  return AVERROR_INVALIDDATA;
1805  }
1806  }
1807 
1808  return avpkt->size;
1809 }
1810 
1812 {
1813  RV34DecContext *r = avctx->priv_data;
1814 
1815  ff_mpv_common_end(&r->s);
1816  rv34_decoder_free(r);
1817 
1818  return 0;
1819 }
qpel_mc_func put_pixels_tab[4][16]
Definition: rv34dsp.h:58
P-frame macroblock with DCs in a separate 4x4 block, one motion vector.
Definition: rv34.h:56
void ff_rv40dsp_init(RV34DSPContext *c)
Definition: rv40dsp.c:620
#define VERT_PRED8x8
Definition: h264pred.h:70
#define NULL
Definition: coverity.c:32
int vlc_set
VLCs used for this slice.
Definition: rv34.h:78
VLC second_pattern[2]
VLCs used for decoding coefficients in the subblocks 2 and 3.
Definition: rv34.h:69
int table_size
Definition: vlc.h:29
discard all frames except keyframes
Definition: avcodec.h:235
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:2272
Definition: vp9.h:47
#define MB_TYPE_L1
Definition: mpegutils.h:68
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static const uint8_t rv34_table_inter_secondpat[NUM_INTER_TABLES][2][OTHERBLK_VLC_SIZE]
Definition: rv34vlc.h:3737
#define DC_128_PRED8x8
Definition: h264pred.h:76
int last_pts
Definition: rv34.h:109
P-frame macroblock, 16x8 motion compensation partitions.
Definition: rv34.h:53
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
static void rv34_output_i16x16(RV34DecContext *r, int8_t *intra_types, int cbp)
Definition: rv34.c:1024
uint8_t * tmp_b_block_y[2]
temporary blocks for RV4 weighted MC
Definition: rv34.h:124
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
#define MB_TYPE_DIRECT2
Definition: mpegutils.h:59
uint32_t avail_cache[3 *4]
8x8 block available flags (for MV prediction)
Definition: rv34.h:121
uint8_t * edge_emu_buffer
temporary buffer for if MVs point to out-of-frame data
Definition: mpegpicture.h:36
misc image utilities
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define ER_MB_END
static const int ittrans[9]
mapping of RV30/40 intra prediction types to standard H.264 types
Definition: rv34.c:952
B-frame macroblock, forward prediction.
Definition: rv34.h:49
int dmv[4][2]
differential motion vectors for the current macroblock
Definition: rv34.h:104
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:106
Bidirectionally predicted B-frame macroblock, two motion vectors.
Definition: rv34.h:55
MpegEncContext s
Definition: rv34.h:87
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
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
int v_edge_pos
horizontal / vertical position of the right/bottom edge (pixel replication)
Definition: mpegvideo.h:132
void ff_er_frame_end(ERContext *s)
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
static const uint8_t rv34_chroma_quant[2][32]
quantizer values used for AC and DC coefficients in chroma blocks
Definition: rv34data.h:74
int height
coded height
Definition: rv34.h:81
int num
Numerator.
Definition: rational.h:59
int size
Definition: packet.h:364
Bidirectionally predicted B-frame macroblock, no motion vectors.
Definition: rv34.h:52
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:910
#define INVALID_VLC
Definition: golomb.h:38
#define MB_TYPE_INTRA
Definition: mpegutils.h:73
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:741
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
#define MB_TYPE_16x8
Definition: mpegutils.h:55
GLint GLenum type
Definition: opengl_enc.c:104
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:411
mpegvideo header.
#define FF_ARRAY_ELEMS(a)
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
VLC cbppattern[2]
VLCs used for pattern of coded block patterns decoding.
Definition: rv34.h:66
static int finish_frame(AVCodecContext *avctx, AVFrame *pict)
Definition: rv34.c:1565
int weight2
B-frame distance fractions (0.14) used in motion compensation.
Definition: rv34.h:111
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
#define GET_PTS_DIFF(a, b)
Definition: rv34.c:508
RV30 and RV40 decoder common data declarations.
discard all
Definition: avcodec.h:236
static int rv34_decode_slice(RV34DecContext *r, int end, const uint8_t *buf, int buf_size)
Definition: rv34.c:1403
#define SUINT
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
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
int start
Definition: rv34.h:79
#define HOR_PRED8x8
Definition: h264pred.h:69
static const int rv34_mb_type_to_lavc[12]
translation of RV30/40 macroblock types to lavc ones
Definition: rv34.c:57
#define NUM_INTRA_TABLES
Definition: rv34vlc.h:32
int qscale
QP.
Definition: mpegvideo.h:204
#define DIAG_DOWN_LEFT_PRED_RV40_NODOWN
Definition: h264pred.h:54
const uint8_t * luma_dc_quant_p
luma subblock DC quantizer for interframes
Definition: rv34.h:93
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
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1997
#define LOCAL_ALIGNED_16(t, v,...)
Definition: mem_internal.h:130
#define PLANE_PRED8x8
Definition: h264pred.h:71
void(* emulated_edge_mc)(uint8_t *dst, const uint8_t *src, ptrdiff_t dst_linesize, ptrdiff_t src_linesize, int block_w, int block_h, int src_x, int src_y, int w, int h)
Copy a rectangular area of samples to a temporary buffer and replicate the border samples...
Definition: videodsp.h:63
#define CBPPAT_VLC_SIZE
Definition: rv34vlc.h:35
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
uint8_t * tmp_b_block_base
Definition: rv34.h:126
int mb_num_left
number of MBs left in this video packet (for partitioned Slices only)
Definition: mpegvideo.h:359
#define MB_TYPE_INTRA16x16
Definition: mpegutils.h:52
ScratchpadContext sc
Definition: mpegvideo.h:202
uint8_t
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
static const uint8_t rv34_table_intra_firstpat[NUM_INTRA_TABLES][4][FIRSTBLK_VLC_SIZE]
Definition: rv34vlc.h:940
#define av_cold
Definition: attributes.h:88
#define av_malloc(s)
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
#define DC_PRED8x8
Definition: h264pred.h:68
int scaled_weight
Definition: rv34.h:110
uint16_t * cbp_luma
CBP values for luma subblocks.
Definition: rv34.h:116
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
enum OutputFormat out_format
output format
Definition: mpegvideo.h:104
static const int chroma_coeffs[3]
Definition: rv34.c:641
static void rv34_mc_2mv_skip(RV34DecContext *r)
Definition: rv34.c:824
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:220
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
#define f(width, name)
Definition: cbs_vp9.c:255
int ff_mpv_common_frame_size_change(MpegEncContext *s)
Definition: mpegvideo.c:1034
Multithreading support functions.
Definition: vp9.h:46
int width
coded width
Definition: rv34.h:80
#define TOP_DC_PRED8x8
Definition: h264pred.h:75
#define ER_MB_ERROR
#define HOR_UP_PRED_RV40_NODOWN
Definition: h264pred.h:55
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:443
#define MB_TYPE_SEPARATE_DC
Definition: rv34.h:38
#define MB_TYPE_16x16
Definition: mpegutils.h:54
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:264
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:91
rv40_weight_func rv40_weight_pixels_tab[2][2]
Biweight functions, first dimension is transform size (16/8), second is whether the weight is prescal...
Definition: rv34dsp.h:67
uint16_t * deblock_coefs
deblock coefficients for each macroblock
Definition: rv34.h:118
void(* pred8x8[4+3+4])(uint8_t *src, ptrdiff_t stride)
Definition: h264pred.h:97
quarterpel DSP functions
static const uint8_t part_sizes_h[RV34_MB_TYPES]
macroblock partition height in 8x8 blocks
Definition: rv34.c:447
#define height
static RV34VLC inter_vlcs[NUM_INTER_TABLES]
Definition: rv34.c:73
uint8_t * data
Definition: packet.h:363
static int is_mv_diff_gt_3(int16_t(*motion_val)[2], int step)
Definition: rv34.c:1151
Skipped block.
Definition: rv34.h:51
static VLC_TYPE table_data[117592][2]
Definition: rv34.c:82
av_cold void ff_mpv_idct_init(MpegEncContext *s)
Definition: mpegvideo.c:331
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:129
static const uint16_t rv34_qscale_tab[32]
This table is used for dequantizing.
Definition: rv34data.h:84
ptrdiff_t size
Definition: opengl_enc.c:100
static void rv34_output_intra(RV34DecContext *r, int8_t *intra_types, int cbp)
Definition: rv34.c:1087
void(* pred4x4[9+3+3])(uint8_t *src, const uint8_t *topright, ptrdiff_t stride)
Definition: h264pred.h:93
rv34_idct_add_func rv34_idct_add
Definition: rv34dsp.h:70
#define AVOnce
Definition: thread.h:172
P-frame macroblock, 8x16 motion compensation partitions.
Definition: rv34.h:54
#define A(x)
Definition: vp56_arith.h:28
#define av_log(a,...)
static void ff_update_block_index(MpegEncContext *s)
Definition: mpegvideo.h:742
static const uint16_t table[]
Definition: prosumer.c:206
static void decode_subblock1(int16_t *dst, int code, GetBitContext *gb, VLC *vlc, int q)
Decode a single coefficient.
Definition: rv34.c:251
int slice_count
slice count
Definition: avcodec.h:885
ThreadFrame tf
Definition: mpegpicture.h:47
#define U(x)
Definition: vp56_arith.h:37
#define src
Definition: vp8dsp.c:255
int quant
quantizer used for this slice
Definition: rv34.h:77
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:551
qpel_mc_func avg_pixels_tab[4][16]
Definition: rv34dsp.h:59
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:821
static void rv4_weight(RV34DecContext *r)
Definition: rv34.c:783
#define MB_TYPE_8x16
Definition: mpegutils.h:56
#define chroma_mc(a)
Definition: vc1dsp.c:783
static const int ittrans16[4]
mapping of RV30/40 intra 16x16 prediction types to standard H.264 types
Definition: rv34.c:958
void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status)
Add a slice.
static const uint16_t mask[17]
Definition: lzw.c:38
void(* qpel_mc_func)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)
Definition: qpeldsp.h:65
rv34_idct_dc_add_func rv34_idct_dc_add
Definition: rv34dsp.h:71
av_cold void ff_rv30dsp_init(RV34DSPContext *c)
Definition: rv30dsp.c:265
#define B
Definition: huffyuvdsp.h:32
ERContext er
Definition: mpegvideo.h:569
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1787
static void rv34_mc_2mv(RV34DecContext *r, const int block_type)
Definition: rv34.c:805
static void rv34_pred_mv(RV34DecContext *r, int block_type, int subblock_no, int dmv_no)
motion vector prediction
Definition: rv34.c:459
const char * r
Definition: vf_curves.c:116
int luma_vlc
which VLC set will be used for decoding of luma blocks
Definition: rv34.h:101
void(* h264_chroma_mc_func)(uint8_t *dst, uint8_t *src, ptrdiff_t srcStride, int h, int x, int y)
Definition: h264chroma.h:25
#define COEFF_VLC_SIZE
Definition: rv34vlc.h:39
static AVRational update_sar(int old_w, int old_h, AVRational sar, int new_w, int new_h)
Definition: rv34.c:1595
simple assert() macros that are a bit more flexible than ISO C assert().
static int get_interleaved_se_golomb(GetBitContext *gb)
Definition: golomb.h:303
#define IS_SKIP(a)
Definition: mpegutils.h:81
static int rv34_decoder_realloc(RV34DecContext *r)
Definition: rv34.c:1396
uint8_t bits
Definition: vp3data.h:141
int low_delay
no reordering needed / has no B-frames
Definition: mpegvideo.h:406
GetBitContext gb
Definition: mpegvideo.h:451
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:1109
#define FFMAX(a, b)
Definition: common.h:103
#define CBP_VLC_SIZE
Definition: rv34vlc.h:36
rv34_inv_transform_func rv34_inv_transform_dc
Definition: rv34dsp.h:69
VLC tables used by the decoder.
Definition: rv34.h:65
static float mul(float src0, float src1)
Definition: vlc.h:26
int end
start and end macroblocks of the slice
Definition: rv34.h:79
int resync_mb_x
x position of last resync marker
Definition: mpegvideo.h:356
static int rv34_set_deblock_coef(RV34DecContext *r)
Definition: rv34.c:1163
common internal API header
useful rectangle filling function
static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n, int slice_count, int buf_size)
Definition: rv34.c:1556
static void ZERO8x2(void *dst, int stride)
Definition: rv34.c:50
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:317
int(* parse_slice_header)(struct RV34DecContext *r, GetBitContext *gb, SliceInfo *si)
Definition: rv34.h:128
int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
Definition: mpegvideo.c:1425
Intra macroblock with DCs in a separate 4x4 block.
Definition: rv34.h:46
#define IS_16X8(a)
Definition: mpegutils.h:87
#define Y
Definition: boxblur.h:38
static void rv34_pred_mv_b(RV34DecContext *r, int block_type, int dir)
motion vector prediction for B-frames
Definition: rv34.c:543
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1779
#define FFMIN(a, b)
Definition: common.h:105
int * mb_type
internal macroblock types
Definition: rv34.h:99
#define width
static int adjust_pred16(int itype, int up, int left)
Definition: rv34.c:992
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
int16_t(*[2] motion_val)[2]
Definition: mpegpicture.h:53
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:184
void ff_mpeg_er_frame_start(MpegEncContext *s)
Definition: mpeg_er.c:46
Picture.
Definition: mpegpicture.h:45
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
H264PredContext h
functions for 4x4 and 16x16 intra block prediction
Definition: rv34.h:96
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
VLC coefficient
VLCs used for decoding big coefficients.
Definition: rv34.h:71
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
static int rv34_decoder_alloc(RV34DecContext *r)
Definition: rv34.c:1369
VLC first_pattern[4]
VLCs used for decoding coefficients in the first subblock.
Definition: rv34.h:68
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:446
#define FIRSTBLK_VLC_SIZE
Definition: rv34vlc.h:37
int mv_weight1
Definition: rv34.h:112
#define s(width, name)
Definition: cbs_vp9.c:257
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:797
static const uint8_t rv34_table_intra_secondpat[NUM_INTRA_TABLES][2][OTHERBLK_VLC_SIZE]
Definition: rv34vlc.h:2074
static void fill_rectangle(int x, int y, int w, int h)
Definition: ffplay.c:828
static const uint8_t rv34_table_intra_thirdpat[NUM_INTRA_TABLES][2][OTHERBLK_VLC_SIZE]
Definition: rv34vlc.h:2177
static const uint8_t rv34_inter_coeff[NUM_INTER_TABLES][COEFF_VLC_SIZE]
Definition: rv34vlc.h:4024
int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: mpegvideo.c:493
#define LEFT_DC_PRED8x8
Definition: h264pred.h:74
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
#define IS_INTRA16x16(a)
Definition: mpegutils.h:76
int bits
Definition: vlc.h:27
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going which in turn will define variables for the build system and the C
RV30/40 VLC tables.
int table_allocated
Definition: vlc.h:29
int(* decode_mb_info)(struct RV34DecContext *r)
Definition: rv34.h:129
#define MB_TYPE_8x8
Definition: mpegutils.h:57
int first_slice_line
used in MPEG-4 too to handle resync markers
Definition: mpegvideo.h:436
static const uint8_t rv34_inter_cbp[NUM_INTER_TABLES][4][CBP_VLC_SIZE]
Definition: rv34vlc.h:2890
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
static int rv34_decode_intra_macroblock(RV34DecContext *r, int8_t *intra_types)
Definition: rv34.c:1301
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
#define AV_ONCE_INIT
Definition: thread.h:173
essential slice information
Definition: rv34.h:75
Libavcodec external API header.
ptrdiff_t linesize
line size, in bytes, may be different from width
Definition: mpegvideo.h:134
enum AVCodecID codec_id
Definition: avcodec.h:541
static const uint8_t rv34_table_inter_firstpat[NUM_INTER_TABLES][2][FIRSTBLK_VLC_SIZE]
Definition: rv34vlc.h:2936
static const uint8_t rv34_table_intra_cbppat[NUM_INTRA_TABLES][2][CBPPAT_VLC_SIZE]
Definition: rv34vlc.h:42
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
static int mod(int a, int b)
Modulo operation with only positive remainders.
Definition: vf_v360.c:747
main external API structure.
Definition: avcodec.h:531
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
static const uint8_t part_sizes_w[RV34_MB_TYPES]
macroblock partition width in 8x8 blocks
Definition: rv34.c:444
#define MAX_VLC_SIZE
Definition: rv34vlc.h:40
RV34VLC * cur_vlcs
VLC set used for current frame decoding.
Definition: rv34.h:95
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:100
static const uint8_t rv34_inter_cbppat[NUM_INTER_TABLES][CBPPAT_VLC_SIZE]
Definition: rv34vlc.h:2305
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:206
SliceInfo si
current slice information
Definition: rv34.h:97
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
Definition: mpegvideo.c:1418
void(* pred16x16[4+3+2])(uint8_t *src, ptrdiff_t stride)
Definition: h264pred.h:98
P-frame macroblock, 8x8 motion compensation partitions.
Definition: rv34.h:48
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static void rv34_decoder_free(RV34DecContext *r)
Definition: rv34.c:1357
VLC cbp[2][4]
VLCs used for coded block patterns decoding.
Definition: rv34.h:67
Rational number (pair of numerator and denominator).
Definition: rational.h:58
struct AVFrame * f
Definition: mpegpicture.h:46
#define IS_8X16(a)
Definition: mpegutils.h:88
static av_cold void rv34_init_tables(void)
Initialize all tables.
Definition: rv34.c:125
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
av_cold int ff_rv34_decode_init(AVCodecContext *avctx)
Initialize decoder.
Definition: rv34.c:1485
#define mid_pred
Definition: mathops.h:97
ptrdiff_t uvlinesize
line size, for chroma in bytes, may be different from width
Definition: mpegvideo.h:135
int ff_rv34_decode_frame(AVCodecContext *avctx, void *data, int *got_picture_ptr, AVPacket *avpkt)
Definition: rv34.c:1605
#define s1
Definition: regdef.h:38
static const uint8_t rv34_table_inter_thirdpat[NUM_INTER_TABLES][2][OTHERBLK_VLC_SIZE]
Definition: rv34vlc.h:3880
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:1186
static int rv34_decode_inter_macroblock(RV34DecContext *r, int8_t *intra_types)
Definition: rv34.c:1193
#define MB_TYPE_SKIP
Definition: mpegutils.h:62
int intra_types_stride
block types array stride
Definition: rv34.h:91
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:212
miscellaneous RV30/40 tables
int(* decode_intra_types)(struct RV34DecContext *r, GetBitContext *gb, int8_t *dst)
Definition: rv34.h:130
const uint8_t * quant
static void rv34_pred_mv_rv3(RV34DecContext *r, int block_type, int dir)
motion vector prediction - RV3 version
Definition: rv34.c:595
static int check_slice_end(RV34DecContext *r, MpegEncContext *s)
Definition: rv34.c:1341
int is16
current block has additional 16x16 specific features or not
Definition: rv34.h:103
#define flags(name, subs,...)
Definition: cbs_av1.c:561
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
int8_t * intra_types
block types
Definition: rv34.h:90
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
static const uint8_t rv34_table_intra_cbp[NUM_INTRA_TABLES][8][CBP_VLC_SIZE]
Definition: rv34vlc.h:886
P-frame macroblock, one motion frame.
Definition: rv34.h:47
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:328
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
Definition: mpegvideo.h:131
int cur_pts
Definition: rv34.h:109
Definition: vp9.h:48
static int rv34_decode_cbp(GetBitContext *gb, RV34VLC *vlc, int table)
Decode coded block pattern.
Definition: rv34.c:180
MpegEncContext.
Definition: mpegvideo.h:81
Picture * next_picture_ptr
pointer to the next picture (for bidir pred)
Definition: mpegvideo.h:183
av_cold int ff_rv34_decode_end(AVCodecContext *avctx)
Definition: rv34.c:1811
int8_t * qscale_table
Definition: mpegpicture.h:50
struct AVCodecContext * avctx
Definition: mpegvideo.h:98
static const uint8_t rv34_cbp_code[16]
values used to reconstruct coded block pattern
Definition: rv34data.h:42
int weight1
Definition: rv34.h:111
#define VERT_LEFT_PRED_RV40_NODOWN
Definition: h264pred.h:56
discard all non reference
Definition: avcodec.h:232
#define OTHERBLK_VLC_SIZE
Definition: rv34vlc.h:38
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
#define MB_TYPE_L0L1
Definition: mpegutils.h:69
static const uint8_t avail_indexes[4]
availability index for subblocks
Definition: rv34.c:450
uint8_t * tmp_b_block_uv[4]
Definition: rv34.h:125
common internal api header.
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
Definition: mpegvideo.h:130
void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Initialize the given MpegEncContext for decoding.
Definition: mpegvideo.c:669
int mv_weight2
Definition: rv34.h:112
uint8_t * dest[3]
Definition: mpegvideo.h:295
B-frame macroblock, backward prediction.
Definition: rv34.h:50
static const uint8_t rv34_mb_bits_sizes[6]
bits needed to code the slice offset for the given size
Definition: rv34data.h:111
int ff_rv34_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: rv34.c:1524
static const uint8_t shifts[2][12]
Definition: camellia.c:174
Picture * last_picture_ptr
pointer to the previous picture.
Definition: mpegvideo.h:182
Bi-dir predicted.
Definition: avutil.h:276
VLC third_pattern[2]
VLCs used for decoding coefficients in the last subblock.
Definition: rv34.h:70
static const int num_mvs[RV34_MB_TYPES]
number of motion vectors in each macroblock type
Definition: rv34.c:845
int ff_rv34_get_start_offset(GetBitContext *gb, int mb_size)
Decode starting slice position.
Definition: rv34.c:322
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
#define IS_INTRA(x, y)
#define NUM_INTER_TABLES
Definition: rv34vlc.h:33
decoder context
Definition: rv34.h:86
void * priv_data
Definition: avcodec.h:558
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:883
VideoDSPContext vdsp
Definition: mpegvideo.h:236
#define IS_8X8(a)
Definition: mpegutils.h:89
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1410
int resync_mb_y
y position of last resync marker
Definition: mpegvideo.h:357
int16_t(* block)[64]
points to one of the following blocks
Definition: mpegvideo.h:511
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
int block_type
current block type
Definition: rv34.h:100
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
static const double coeff[2][5]
Definition: vf_owdenoise.c:73
int next_pts
Definition: rv34.h:109
const uint8_t * luma_dc_quant_i
luma subblock DC quantizer for intraframes
Definition: rv34.h:92
static const uint8_t rv34_count_ones[16]
number of ones in nibble minus one
Definition: rv34data.h:35
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
int * slice_offset
slice offsets in the frame in bytes
Definition: avcodec.h:901
int8_t * intra_types_hist
old block types, used for prediction
Definition: rv34.h:89
rv34_inv_transform_func rv34_inv_transform
Definition: rv34dsp.h:68
uint32_t * mb_type
types and macros are defined in mpegutils.h
Definition: mpegpicture.h:56
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
#define av_freep(p)
int type
slice type (intra, inter)
Definition: rv34.h:76
h264_chroma_mc_func avg_chroma_pixels_tab[3]
Definition: rv34dsp.h:61
#define VLC_TYPE
Definition: vlc.h:24
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
#define stride
#define FF_QSCALE_TYPE_MPEG1
Definition: internal.h:92
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
static RV34VLC intra_vlcs[NUM_INTRA_TABLES]
Definition: rv34.c:73
int rv30
indicates which RV variant is currently decoded
Definition: rv34.h:106
exp golomb vlc stuff
#define INIT_VLC_STATIC_OVERLONG
Definition: vlc.h:96
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:91
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:340
h264_chroma_mc_func put_chroma_pixels_tab[3]
Definition: rv34dsp.h:60
Intra macroblock.
Definition: rv34.h:45
void(* loop_filter)(struct RV34DecContext *r, int row)
Definition: rv34.h:131
int chroma_vlc
which VLC set will be used for decoding of chroma blocks
Definition: rv34.h:102
#define MB_TYPE_L0
Definition: mpegutils.h:67
for(j=16;j >0;--j)
RV34DSPContext rdsp
Definition: rv34.h:88
int i
Definition: input.c:407
Predicted.
Definition: avutil.h:275
int pts
frame timestamp
Definition: rv34.h:82
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
static const uint8_t rv34_intra_coeff[NUM_INTRA_TABLES][COEFF_VLC_SIZE]
Definition: rv34vlc.h:2281
#define V
Definition: avdct.c:30
uint8_t * cbp_chroma
CBP values for chroma subblocks.
Definition: rv34.h:117
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