2 * RV30/40 decoder common data
3 * Copyright (c) 2007 Mike Melanson, Konstantin Shishkov
5 * This file is part of FFmpeg.
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.
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.
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
23 * @file libavcodec/rv34.c
24 * RV30/40 decoder common data
29 #include "mpegvideo.h"
32 #include "rectangle.h"
40 /** translation of RV30/40 macroblock types to lavc ones */
41 static const int rv34_mb_type_to_lavc
[12] = {
43 MB_TYPE_INTRA16x16
| MB_TYPE_SEPARATE_DC
,
44 MB_TYPE_16x16
| MB_TYPE_L0
,
45 MB_TYPE_8x8
| MB_TYPE_L0
,
46 MB_TYPE_16x16
| MB_TYPE_L0
,
47 MB_TYPE_16x16
| MB_TYPE_L1
,
49 MB_TYPE_DIRECT2
| MB_TYPE_16x16
,
50 MB_TYPE_16x8
| MB_TYPE_L0
,
51 MB_TYPE_8x16
| MB_TYPE_L0
,
52 MB_TYPE_16x16
| MB_TYPE_L0L1
,
53 MB_TYPE_16x16
| MB_TYPE_L0
| MB_TYPE_SEPARATE_DC
57 static RV34VLC intra_vlcs
[NUM_INTRA_TABLES
], inter_vlcs
[NUM_INTER_TABLES
];
60 * @defgroup vlc RV30/40 VLC generating functions
65 * Generate VLC from codeword lengths.
66 * @param bits codeword lengths (zeroes are accepted)
67 * @param size length of input data
68 * @param vlc output VLC
69 * @param insyms symbols for input codes (NULL for default ones)
71 static void rv34_gen_vlc(const uint8_t *bits
, int size
, VLC
*vlc
, const uint8_t *insyms
)
74 int counts
[17] = {0}, codes
[17];
75 uint16_t cw
[size
], syms
[size
];
77 int maxbits
= 0, realsize
= 0;
79 for(i
= 0; i
< size
; i
++){
81 bits2
[realsize
] = bits
[i
];
82 syms
[realsize
] = insyms
? insyms
[i
] : i
;
84 maxbits
= FFMAX(maxbits
, bits
[i
]);
90 for(i
= 0; i
< 16; i
++)
91 codes
[i
+1] = (codes
[i
] + counts
[i
]) << 1;
92 for(i
= 0; i
< realsize
; i
++)
93 cw
[i
] = codes
[bits2
[i
]]++;
95 init_vlc_sparse(vlc
, FFMIN(maxbits
, 9), realsize
,
98 syms
, 2, 2, INIT_VLC_USE_STATIC
);
102 * Initialize all tables.
104 static av_cold
void rv34_init_tables(void)
108 for(i
= 0; i
< NUM_INTRA_TABLES
; i
++){
109 for(j
= 0; j
< 2; j
++){
110 rv34_gen_vlc(rv34_table_intra_cbppat
[i
][j
], CBPPAT_VLC_SIZE
, &intra_vlcs
[i
].cbppattern
[j
], NULL
);
111 rv34_gen_vlc(rv34_table_intra_secondpat
[i
][j
], OTHERBLK_VLC_SIZE
, &intra_vlcs
[i
].second_pattern
[j
], NULL
);
112 rv34_gen_vlc(rv34_table_intra_thirdpat
[i
][j
], OTHERBLK_VLC_SIZE
, &intra_vlcs
[i
].third_pattern
[j
], NULL
);
113 for(k
= 0; k
< 4; k
++)
114 rv34_gen_vlc(rv34_table_intra_cbp
[i
][j
+k
*2], CBP_VLC_SIZE
, &intra_vlcs
[i
].cbp
[j
][k
], rv34_cbp_code
);
116 for(j
= 0; j
< 4; j
++)
117 rv34_gen_vlc(rv34_table_intra_firstpat
[i
][j
], FIRSTBLK_VLC_SIZE
, &intra_vlcs
[i
].first_pattern
[j
], NULL
);
118 rv34_gen_vlc(rv34_intra_coeff
[i
], COEFF_VLC_SIZE
, &intra_vlcs
[i
].coefficient
, NULL
);
121 for(i
= 0; i
< NUM_INTER_TABLES
; i
++){
122 rv34_gen_vlc(rv34_inter_cbppat
[i
], CBPPAT_VLC_SIZE
, &inter_vlcs
[i
].cbppattern
[0], NULL
);
123 for(j
= 0; j
< 4; j
++)
124 rv34_gen_vlc(rv34_inter_cbp
[i
][j
], CBP_VLC_SIZE
, &inter_vlcs
[i
].cbp
[0][j
], rv34_cbp_code
);
125 for(j
= 0; j
< 2; j
++){
126 rv34_gen_vlc(rv34_table_inter_firstpat
[i
][j
], FIRSTBLK_VLC_SIZE
, &inter_vlcs
[i
].first_pattern
[j
], NULL
);
127 rv34_gen_vlc(rv34_table_inter_secondpat
[i
][j
], OTHERBLK_VLC_SIZE
, &inter_vlcs
[i
].second_pattern
[j
], NULL
);
128 rv34_gen_vlc(rv34_table_inter_thirdpat
[i
][j
], OTHERBLK_VLC_SIZE
, &inter_vlcs
[i
].third_pattern
[j
], NULL
);
130 rv34_gen_vlc(rv34_inter_coeff
[i
], COEFF_VLC_SIZE
, &inter_vlcs
[i
].coefficient
, NULL
);
134 /** @} */ // vlc group
138 * @defgroup transform RV30/40 inverse transform functions
142 static av_always_inline
void rv34_row_transform(int temp
[16], DCTELEM
*block
)
147 const int z0
= 13*(block
[i
+8*0] + block
[i
+8*2]);
148 const int z1
= 13*(block
[i
+8*0] - block
[i
+8*2]);
149 const int z2
= 7* block
[i
+8*1] - 17*block
[i
+8*3];
150 const int z3
= 17* block
[i
+8*1] + 7*block
[i
+8*3];
160 * Real Video 3.0/4.0 inverse transform
161 * Code is almost the same as in SVQ3, only scaling is different.
163 static void rv34_inv_transform(DCTELEM
*block
){
167 rv34_row_transform(temp
, block
);
170 const int z0
= 13*(temp
[4*0+i
] + temp
[4*2+i
]) + 0x200;
171 const int z1
= 13*(temp
[4*0+i
] - temp
[4*2+i
]) + 0x200;
172 const int z2
= 7* temp
[4*1+i
] - 17*temp
[4*3+i
];
173 const int z3
= 17* temp
[4*1+i
] + 7*temp
[4*3+i
];
175 block
[i
*8+0]= (z0
+ z3
)>>10;
176 block
[i
*8+1]= (z1
+ z2
)>>10;
177 block
[i
*8+2]= (z1
- z2
)>>10;
178 block
[i
*8+3]= (z0
- z3
)>>10;
184 * RealVideo 3.0/4.0 inverse transform for DC block
186 * Code is almost the same as rv34_inv_transform()
187 * but final coefficients are multiplied by 1.5 and have no rounding.
189 static void rv34_inv_transform_noround(DCTELEM
*block
){
193 rv34_row_transform(temp
, block
);
196 const int z0
= 13*(temp
[4*0+i
] + temp
[4*2+i
]);
197 const int z1
= 13*(temp
[4*0+i
] - temp
[4*2+i
]);
198 const int z2
= 7* temp
[4*1+i
] - 17*temp
[4*3+i
];
199 const int z3
= 17* temp
[4*1+i
] + 7*temp
[4*3+i
];
201 block
[i
*8+0]= ((z0
+ z3
)*3)>>11;
202 block
[i
*8+1]= ((z1
+ z2
)*3)>>11;
203 block
[i
*8+2]= ((z1
- z2
)*3)>>11;
204 block
[i
*8+3]= ((z0
- z3
)*3)>>11;
209 /** @} */ // transform
213 * @defgroup block RV30/40 4x4 block decoding functions
218 * Decode coded block pattern.
220 static int rv34_decode_cbp(GetBitContext
*gb
, RV34VLC
*vlc
, int table
)
222 int pattern
, code
, cbp
=0;
224 static const int cbp_masks
[3] = {0x100000, 0x010000, 0x110000};
225 static const int shifts
[4] = { 0, 2, 8, 10 };
226 const int *curshift
= shifts
;
229 code
= get_vlc2(gb
, vlc
->cbppattern
[table
].table
, 9, 2);
230 pattern
= code
& 0xF;
233 ones
= rv34_count_ones
[pattern
];
235 for(mask
= 8; mask
; mask
>>= 1, curshift
++){
237 cbp
|= get_vlc2(gb
, vlc
->cbp
[table
][ones
].table
, vlc
->cbp
[table
][ones
].bits
, 1) << curshift
[0];
240 for(i
= 0; i
< 4; i
++){
241 t
= modulo_three_table
[code
][i
];
243 cbp
|= cbp_masks
[get_bits1(gb
)] << i
;
245 cbp
|= cbp_masks
[2] << i
;
251 * Get one coefficient value from the bistream and store it.
253 static inline void decode_coeff(DCTELEM
*dst
, int coef
, int esc
, GetBitContext
*gb
, VLC
* vlc
)
257 coef
= get_vlc2(gb
, vlc
->table
, 9, 2);
260 coef
= 22 + ((1 << coef
) | get_bits(gb
, coef
));
271 * Decode 2x2 subblock of coefficients.
273 static inline void decode_subblock(DCTELEM
*dst
, int code
, const int is_block2
, GetBitContext
*gb
, VLC
*vlc
)
277 coeffs
[0] = modulo_three_table
[code
][0];
278 coeffs
[1] = modulo_three_table
[code
][1];
279 coeffs
[2] = modulo_three_table
[code
][2];
280 coeffs
[3] = modulo_three_table
[code
][3];
281 decode_coeff(dst
, coeffs
[0], 3, gb
, vlc
);
283 decode_coeff(dst
+8, coeffs
[1], 2, gb
, vlc
);
284 decode_coeff(dst
+1, coeffs
[2], 2, gb
, vlc
);
286 decode_coeff(dst
+1, coeffs
[1], 2, gb
, vlc
);
287 decode_coeff(dst
+8, coeffs
[2], 2, gb
, vlc
);
289 decode_coeff(dst
+9, coeffs
[3], 2, gb
, vlc
);
293 * Decode coefficients for 4x4 block.
295 * This is done by filling 2x2 subblocks with decoded coefficients
296 * in this order (the same for subblocks and subblock coefficients):
303 static inline void rv34_decode_block(DCTELEM
*dst
, GetBitContext
*gb
, RV34VLC
*rvlc
, int fc
, int sc
)
307 code
= get_vlc2(gb
, rvlc
->first_pattern
[fc
].table
, 9, 2);
309 pattern
= code
& 0x7;
312 decode_subblock(dst
, code
, 0, gb
, &rvlc
->coefficient
);
315 code
= get_vlc2(gb
, rvlc
->second_pattern
[sc
].table
, 9, 2);
316 decode_subblock(dst
+ 2, code
, 0, gb
, &rvlc
->coefficient
);
318 if(pattern
& 2){ // Looks like coefficients 1 and 2 are swapped for this block
319 code
= get_vlc2(gb
, rvlc
->second_pattern
[sc
].table
, 9, 2);
320 decode_subblock(dst
+ 8*2, code
, 1, gb
, &rvlc
->coefficient
);
323 code
= get_vlc2(gb
, rvlc
->third_pattern
[sc
].table
, 9, 2);
324 decode_subblock(dst
+ 8*2+2, code
, 0, gb
, &rvlc
->coefficient
);
330 * Dequantize ordinary 4x4 block.
333 static inline void rv34_dequant4x4(DCTELEM
*block
, int Qdc
, int Q
)
337 block
[0] = (block
[0] * Qdc
+ 8) >> 4;
338 for(i
= 0; i
< 4; i
++)
339 for(j
= !i
; j
< 4; j
++)
340 block
[j
+ i
*8] = (block
[j
+ i
*8] * Q
+ 8) >> 4;
344 * Dequantize 4x4 block of DC values for 16x16 macroblock.
347 static inline void rv34_dequant4x4_16x16(DCTELEM
*block
, int Qdc
, int Q
)
351 for(i
= 0; i
< 3; i
++)
352 block
[rv34_dezigzag
[i
]] = (block
[rv34_dezigzag
[i
]] * Qdc
+ 8) >> 4;
354 block
[rv34_dezigzag
[i
]] = (block
[rv34_dezigzag
[i
]] * Q
+ 8) >> 4;
356 /** @} */ //block functions
360 * @defgroup bitstream RV30/40 bitstream parsing
365 * Decode starting slice position.
366 * @todo Maybe replace with ff_h263_decode_mba() ?
368 int ff_rv34_get_start_offset(GetBitContext
*gb
, int mb_size
)
371 for(i
= 0; i
< 5; i
++)
372 if(rv34_mb_max_sizes
[i
] >= mb_size
- 1)
374 return rv34_mb_bits_sizes
[i
];
378 * Select VLC set for decoding from current quantizer, modifier and frame type.
380 static inline RV34VLC
* choose_vlc_set(int quant
, int mod
, int type
)
382 if(mod
== 2 && quant
< 19) quant
+= 10;
383 else if(mod
&& quant
< 26) quant
+= 5;
384 return type
? &inter_vlcs
[rv34_quant_to_vlc_set
[1][av_clip(quant
, 0, 30)]]
385 : &intra_vlcs
[rv34_quant_to_vlc_set
[0][av_clip(quant
, 0, 30)]];
389 * Decode quantizer difference and return modified quantizer.
391 static inline int rv34_decode_dquant(GetBitContext
*gb
, int quant
)
394 return rv34_dquant_tab
[get_bits1(gb
)][quant
];
396 return get_bits(gb
, 5);
399 /** @} */ //bitstream functions
402 * @defgroup mv motion vector related code (prediction, reconstruction, motion compensation)
406 /** macroblock partition width in 8x8 blocks */
407 static const uint8_t part_sizes_w
[RV34_MB_TYPES
] = { 2, 2, 2, 1, 2, 2, 2, 2, 2, 1, 2, 2 };
409 /** macroblock partition height in 8x8 blocks */
410 static const uint8_t part_sizes_h
[RV34_MB_TYPES
] = { 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2 };
412 /** availability index for subblocks */
413 static const uint8_t avail_indexes
[4] = { 5, 6, 9, 10 };
416 * motion vector prediction
418 * Motion prediction performed for the block by using median prediction of
419 * motion vectors from the left, top and right top blocks but in corner cases
420 * some other vectors may be used instead.
422 static void rv34_pred_mv(RV34DecContext
*r
, int block_type
, int subblock_no
, int dmv_no
)
424 MpegEncContext
*s
= &r
->s
;
425 int mv_pos
= s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
;
426 int A
[2] = {0}, B
[2], C
[2];
429 int avail_index
= avail_indexes
[subblock_no
];
430 int c_off
= part_sizes_w
[block_type
];
432 mv_pos
+= (subblock_no
& 1) + (subblock_no
>> 1)*s
->b8_stride
;
436 if(r
->avail_cache
[avail_index
- 1]){
437 A
[0] = s
->current_picture_ptr
->motion_val
[0][mv_pos
-1][0];
438 A
[1] = s
->current_picture_ptr
->motion_val
[0][mv_pos
-1][1];
440 if(r
->avail_cache
[avail_index
- 4]){
441 B
[0] = s
->current_picture_ptr
->motion_val
[0][mv_pos
-s
->b8_stride
][0];
442 B
[1] = s
->current_picture_ptr
->motion_val
[0][mv_pos
-s
->b8_stride
][1];
447 if(!r
->avail_cache
[avail_index
- 4 + c_off
]){
448 if(r
->avail_cache
[avail_index
- 4] && (r
->avail_cache
[avail_index
- 1] || r
->rv30
)){
449 C
[0] = s
->current_picture_ptr
->motion_val
[0][mv_pos
-s
->b8_stride
-1][0];
450 C
[1] = s
->current_picture_ptr
->motion_val
[0][mv_pos
-s
->b8_stride
-1][1];
456 C
[0] = s
->current_picture_ptr
->motion_val
[0][mv_pos
-s
->b8_stride
+c_off
][0];
457 C
[1] = s
->current_picture_ptr
->motion_val
[0][mv_pos
-s
->b8_stride
+c_off
][1];
459 mx
= mid_pred(A
[0], B
[0], C
[0]);
460 my
= mid_pred(A
[1], B
[1], C
[1]);
461 mx
+= r
->dmv
[dmv_no
][0];
462 my
+= r
->dmv
[dmv_no
][1];
463 for(j
= 0; j
< part_sizes_h
[block_type
]; j
++){
464 for(i
= 0; i
< part_sizes_w
[block_type
]; i
++){
465 s
->current_picture_ptr
->motion_val
[0][mv_pos
+ i
+ j
*s
->b8_stride
][0] = mx
;
466 s
->current_picture_ptr
->motion_val
[0][mv_pos
+ i
+ j
*s
->b8_stride
][1] = my
;
471 #define GET_PTS_DIFF(a, b) ((a - b + 8192) & 0x1FFF)
474 * Calculate motion vector component that should be added for direct blocks.
476 static int calc_add_mv(RV34DecContext
*r
, int dir
, int val
)
478 int refdist
= GET_PTS_DIFF(r
->next_pts
, r
->last_pts
);
479 int dist
= dir
? -GET_PTS_DIFF(r
->next_pts
, r
->cur_pts
) : GET_PTS_DIFF(r
->cur_pts
, r
->last_pts
);
482 if(!refdist
) return 0;
483 mul
= (dist
<< 14) / refdist
;
484 return (val
* mul
+ 0x2000) >> 14;
488 * Predict motion vector for B-frame macroblock.
490 static inline void rv34_pred_b_vector(int A
[2], int B
[2], int C
[2],
491 int A_avail
, int B_avail
, int C_avail
,
494 if(A_avail
+ B_avail
+ C_avail
!= 3){
495 *mx
= A
[0] + B
[0] + C
[0];
496 *my
= A
[1] + B
[1] + C
[1];
497 if(A_avail
+ B_avail
+ C_avail
== 2){
502 *mx
= mid_pred(A
[0], B
[0], C
[0]);
503 *my
= mid_pred(A
[1], B
[1], C
[1]);
508 * motion vector prediction for B-frames
510 static void rv34_pred_mv_b(RV34DecContext
*r
, int block_type
, int dir
)
512 MpegEncContext
*s
= &r
->s
;
513 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
514 int mv_pos
= s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
;
515 int A
[2], B
[2], C
[2];
516 int has_A
= 0, has_B
= 0, has_C
= 0;
519 Picture
*cur_pic
= s
->current_picture_ptr
;
520 const int mask
= dir
? MB_TYPE_L1
: MB_TYPE_L0
;
521 int type
= cur_pic
->mb_type
[mb_pos
];
523 memset(A
, 0, sizeof(A
));
524 memset(B
, 0, sizeof(B
));
525 memset(C
, 0, sizeof(C
));
526 if((r
->avail_cache
[5-1] & type
) & mask
){
527 A
[0] = cur_pic
->motion_val
[dir
][mv_pos
- 1][0];
528 A
[1] = cur_pic
->motion_val
[dir
][mv_pos
- 1][1];
531 if((r
->avail_cache
[5-4] & type
) & mask
){
532 B
[0] = cur_pic
->motion_val
[dir
][mv_pos
- s
->b8_stride
][0];
533 B
[1] = cur_pic
->motion_val
[dir
][mv_pos
- s
->b8_stride
][1];
536 if(r
->avail_cache
[5-4] && (r
->avail_cache
[5-2] & type
) & mask
){
537 C
[0] = cur_pic
->motion_val
[dir
][mv_pos
- s
->b8_stride
+ 2][0];
538 C
[1] = cur_pic
->motion_val
[dir
][mv_pos
- s
->b8_stride
+ 2][1];
540 }else if((s
->mb_x
+1) == s
->mb_width
&& (r
->avail_cache
[5-5] & type
) & mask
){
541 C
[0] = cur_pic
->motion_val
[dir
][mv_pos
- s
->b8_stride
- 1][0];
542 C
[1] = cur_pic
->motion_val
[dir
][mv_pos
- s
->b8_stride
- 1][1];
546 rv34_pred_b_vector(A
, B
, C
, has_A
, has_B
, has_C
, &mx
, &my
);
548 mx
+= r
->dmv
[dir
][0];
549 my
+= r
->dmv
[dir
][1];
551 for(j
= 0; j
< 2; j
++){
552 for(i
= 0; i
< 2; i
++){
553 cur_pic
->motion_val
[dir
][mv_pos
+ i
+ j
*s
->b8_stride
][0] = mx
;
554 cur_pic
->motion_val
[dir
][mv_pos
+ i
+ j
*s
->b8_stride
][1] = my
;
557 if(block_type
== RV34_MB_B_BACKWARD
|| block_type
== RV34_MB_B_FORWARD
)
558 fill_rectangle(cur_pic
->motion_val
[!dir
][mv_pos
], 2, 2, s
->b8_stride
, 0, 4);
562 * motion vector prediction - RV3 version
564 static void rv34_pred_mv_rv3(RV34DecContext
*r
, int block_type
, int dir
)
566 MpegEncContext
*s
= &r
->s
;
567 int mv_pos
= s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
;
568 int A
[2] = {0}, B
[2], C
[2];
571 int avail_index
= avail_indexes
[0];
573 if(r
->avail_cache
[avail_index
- 1]){
574 A
[0] = s
->current_picture_ptr
->motion_val
[0][mv_pos
-1][0];
575 A
[1] = s
->current_picture_ptr
->motion_val
[0][mv_pos
-1][1];
577 if(r
->avail_cache
[avail_index
- 4]){
578 B
[0] = s
->current_picture_ptr
->motion_val
[0][mv_pos
-s
->b8_stride
][0];
579 B
[1] = s
->current_picture_ptr
->motion_val
[0][mv_pos
-s
->b8_stride
][1];
584 if(!r
->avail_cache
[avail_index
- 4 + 2]){
585 if(r
->avail_cache
[avail_index
- 4] && (r
->avail_cache
[avail_index
- 1])){
586 C
[0] = s
->current_picture_ptr
->motion_val
[0][mv_pos
-s
->b8_stride
-1][0];
587 C
[1] = s
->current_picture_ptr
->motion_val
[0][mv_pos
-s
->b8_stride
-1][1];
593 C
[0] = s
->current_picture_ptr
->motion_val
[0][mv_pos
-s
->b8_stride
+2][0];
594 C
[1] = s
->current_picture_ptr
->motion_val
[0][mv_pos
-s
->b8_stride
+2][1];
596 mx
= mid_pred(A
[0], B
[0], C
[0]);
597 my
= mid_pred(A
[1], B
[1], C
[1]);
600 for(j
= 0; j
< 2; j
++){
601 for(i
= 0; i
< 2; i
++){
602 for(k
= 0; k
< 2; k
++){
603 s
->current_picture_ptr
->motion_val
[k
][mv_pos
+ i
+ j
*s
->b8_stride
][0] = mx
;
604 s
->current_picture_ptr
->motion_val
[k
][mv_pos
+ i
+ j
*s
->b8_stride
][1] = my
;
610 static const int chroma_coeffs
[3] = { 0, 3, 5 };
613 * generic motion compensation function
615 * @param r decoder context
616 * @param block_type type of the current block
617 * @param xoff horizontal offset from the start of the current block
618 * @param yoff vertical offset from the start of the current block
619 * @param mv_off offset to the motion vector information
620 * @param width width of the current partition in 8x8 blocks
621 * @param height height of the current partition in 8x8 blocks
622 * @param dir motion compensation direction (i.e. from the last or the next reference frame)
623 * @param thirdpel motion vectors are specified in 1/3 of pixel
624 * @param qpel_mc a set of functions used to perform luma motion compensation
625 * @param chroma_mc a set of functions used to perform chroma motion compensation
627 static inline void rv34_mc(RV34DecContext
*r
, const int block_type
,
628 const int xoff
, const int yoff
, int mv_off
,
629 const int width
, const int height
, int dir
,
631 qpel_mc_func (*qpel_mc
)[16],
632 h264_chroma_mc_func (*chroma_mc
))
634 MpegEncContext
*s
= &r
->s
;
635 uint8_t *Y
, *U
, *V
, *srcY
, *srcU
, *srcV
;
636 int dxy
, mx
, my
, umx
, umy
, lx
, ly
, uvmx
, uvmy
, src_x
, src_y
, uvsrc_x
, uvsrc_y
;
637 int mv_pos
= s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
+ mv_off
;
641 int chroma_mx
, chroma_my
;
642 mx
= (s
->current_picture_ptr
->motion_val
[dir
][mv_pos
][0] + (3 << 24)) / 3 - (1 << 24);
643 my
= (s
->current_picture_ptr
->motion_val
[dir
][mv_pos
][1] + (3 << 24)) / 3 - (1 << 24);
644 lx
= (s
->current_picture_ptr
->motion_val
[dir
][mv_pos
][0] + (3 << 24)) % 3;
645 ly
= (s
->current_picture_ptr
->motion_val
[dir
][mv_pos
][1] + (3 << 24)) % 3;
646 chroma_mx
= (s
->current_picture_ptr
->motion_val
[dir
][mv_pos
][0] + 1) >> 1;
647 chroma_my
= (s
->current_picture_ptr
->motion_val
[dir
][mv_pos
][1] + 1) >> 1;
648 umx
= (chroma_mx
+ (3 << 24)) / 3 - (1 << 24);
649 umy
= (chroma_my
+ (3 << 24)) / 3 - (1 << 24);
650 uvmx
= chroma_coeffs
[(chroma_mx
+ (3 << 24)) % 3];
651 uvmy
= chroma_coeffs
[(chroma_my
+ (3 << 24)) % 3];
654 mx
= s
->current_picture_ptr
->motion_val
[dir
][mv_pos
][0] >> 2;
655 my
= s
->current_picture_ptr
->motion_val
[dir
][mv_pos
][1] >> 2;
656 lx
= s
->current_picture_ptr
->motion_val
[dir
][mv_pos
][0] & 3;
657 ly
= s
->current_picture_ptr
->motion_val
[dir
][mv_pos
][1] & 3;
658 cx
= s
->current_picture_ptr
->motion_val
[dir
][mv_pos
][0] / 2;
659 cy
= s
->current_picture_ptr
->motion_val
[dir
][mv_pos
][1] / 2;
662 uvmx
= (cx
& 3) << 1;
663 uvmy
= (cy
& 3) << 1;
664 //due to some flaw RV40 uses the same MC compensation routine for H2V2 and H3V3
665 if(uvmx
== 6 && uvmy
== 6)
669 srcY
= dir
? s
->next_picture_ptr
->data
[0] : s
->last_picture_ptr
->data
[0];
670 srcU
= dir
? s
->next_picture_ptr
->data
[1] : s
->last_picture_ptr
->data
[1];
671 srcV
= dir
? s
->next_picture_ptr
->data
[2] : s
->last_picture_ptr
->data
[2];
672 src_x
= s
->mb_x
* 16 + xoff
+ mx
;
673 src_y
= s
->mb_y
* 16 + yoff
+ my
;
674 uvsrc_x
= s
->mb_x
* 8 + (xoff
>> 1) + umx
;
675 uvsrc_y
= s
->mb_y
* 8 + (yoff
>> 1) + umy
;
676 srcY
+= src_y
* s
->linesize
+ src_x
;
677 srcU
+= uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
678 srcV
+= uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
679 if( (unsigned)(src_x
- !!lx
*2) > s
->h_edge_pos
- !!lx
*2 - (width
<<3) - 4
680 || (unsigned)(src_y
- !!ly
*2) > s
->v_edge_pos
- !!ly
*2 - (height
<<3) - 4){
681 uint8_t *uvbuf
= s
->edge_emu_buffer
+ 22 * s
->linesize
;
683 srcY
-= 2 + 2*s
->linesize
;
684 ff_emulated_edge_mc(s
->edge_emu_buffer
, srcY
, s
->linesize
, (width
<<3)+6, (height
<<3)+6,
685 src_x
- 2, src_y
- 2, s
->h_edge_pos
, s
->v_edge_pos
);
686 srcY
= s
->edge_emu_buffer
+ 2 + 2*s
->linesize
;
687 ff_emulated_edge_mc(uvbuf
, srcU
, s
->uvlinesize
, (width
<<2)+1, (height
<<2)+1,
688 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
689 ff_emulated_edge_mc(uvbuf
+ 16, srcV
, s
->uvlinesize
, (width
<<2)+1, (height
<<2)+1,
690 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
694 Y
= s
->dest
[0] + xoff
+ yoff
*s
->linesize
;
695 U
= s
->dest
[1] + (xoff
>>1) + (yoff
>>1)*s
->uvlinesize
;
696 V
= s
->dest
[2] + (xoff
>>1) + (yoff
>>1)*s
->uvlinesize
;
698 if(block_type
== RV34_MB_P_16x8
){
699 qpel_mc
[1][dxy
](Y
, srcY
, s
->linesize
);
702 }else if(block_type
== RV34_MB_P_8x16
){
703 qpel_mc
[1][dxy
](Y
, srcY
, s
->linesize
);
704 Y
+= 8 * s
->linesize
;
705 srcY
+= 8 * s
->linesize
;
707 is16x16
= (block_type
!= RV34_MB_P_8x8
) && (block_type
!= RV34_MB_P_16x8
) && (block_type
!= RV34_MB_P_8x16
);
708 qpel_mc
[!is16x16
][dxy
](Y
, srcY
, s
->linesize
);
709 chroma_mc
[2-width
] (U
, srcU
, s
->uvlinesize
, height
*4, uvmx
, uvmy
);
710 chroma_mc
[2-width
] (V
, srcV
, s
->uvlinesize
, height
*4, uvmx
, uvmy
);
713 static void rv34_mc_1mv(RV34DecContext
*r
, const int block_type
,
714 const int xoff
, const int yoff
, int mv_off
,
715 const int width
, const int height
, int dir
)
717 rv34_mc(r
, block_type
, xoff
, yoff
, mv_off
, width
, height
, dir
, r
->rv30
,
718 r
->rv30
? r
->s
.dsp
.put_rv30_tpel_pixels_tab
719 : r
->s
.dsp
.put_rv40_qpel_pixels_tab
,
720 r
->rv30
? r
->s
.dsp
.put_h264_chroma_pixels_tab
721 : r
->s
.dsp
.put_rv40_chroma_pixels_tab
);
724 static void rv34_mc_2mv(RV34DecContext
*r
, const int block_type
)
726 rv34_mc(r
, block_type
, 0, 0, 0, 2, 2, 0, r
->rv30
,
727 r
->rv30
? r
->s
.dsp
.put_rv30_tpel_pixels_tab
728 : r
->s
.dsp
.put_rv40_qpel_pixels_tab
,
729 r
->rv30
? r
->s
.dsp
.put_h264_chroma_pixels_tab
730 : r
->s
.dsp
.put_rv40_chroma_pixels_tab
);
731 rv34_mc(r
, block_type
, 0, 0, 0, 2, 2, 1, r
->rv30
,
732 r
->rv30
? r
->s
.dsp
.avg_rv30_tpel_pixels_tab
733 : r
->s
.dsp
.avg_rv40_qpel_pixels_tab
,
734 r
->rv30
? r
->s
.dsp
.avg_h264_chroma_pixels_tab
735 : r
->s
.dsp
.avg_rv40_chroma_pixels_tab
);
738 static void rv34_mc_2mv_skip(RV34DecContext
*r
)
741 for(j
= 0; j
< 2; j
++)
742 for(i
= 0; i
< 2; i
++){
743 rv34_mc(r
, RV34_MB_P_8x8
, i
*8, j
*8, i
+j
*r
->s
.b8_stride
, 1, 1, 0, r
->rv30
,
744 r
->rv30
? r
->s
.dsp
.put_rv30_tpel_pixels_tab
745 : r
->s
.dsp
.put_rv40_qpel_pixels_tab
,
746 r
->rv30
? r
->s
.dsp
.put_h264_chroma_pixels_tab
747 : r
->s
.dsp
.put_rv40_chroma_pixels_tab
);
748 rv34_mc(r
, RV34_MB_P_8x8
, i
*8, j
*8, i
+j
*r
->s
.b8_stride
, 1, 1, 1, r
->rv30
,
749 r
->rv30
? r
->s
.dsp
.avg_rv30_tpel_pixels_tab
750 : r
->s
.dsp
.avg_rv40_qpel_pixels_tab
,
751 r
->rv30
? r
->s
.dsp
.avg_h264_chroma_pixels_tab
752 : r
->s
.dsp
.avg_rv40_chroma_pixels_tab
);
756 /** number of motion vectors in each macroblock type */
757 static const int num_mvs
[RV34_MB_TYPES
] = { 0, 0, 1, 4, 1, 1, 0, 0, 2, 2, 2, 1 };
760 * Decode motion vector differences
761 * and perform motion vector reconstruction and motion compensation.
763 static int rv34_decode_mv(RV34DecContext
*r
, int block_type
)
765 MpegEncContext
*s
= &r
->s
;
766 GetBitContext
*gb
= &s
->gb
;
768 int mv_pos
= s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
;
771 memset(r
->dmv
, 0, sizeof(r
->dmv
));
772 for(i
= 0; i
< num_mvs
[block_type
]; i
++){
773 r
->dmv
[i
][0] = svq3_get_se_golomb(gb
);
774 r
->dmv
[i
][1] = svq3_get_se_golomb(gb
);
777 case RV34_MB_TYPE_INTRA
:
778 case RV34_MB_TYPE_INTRA16x16
:
779 fill_rectangle(s
->current_picture_ptr
->motion_val
[0][s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
], 2, 2, s
->b8_stride
, 0, 4);
782 if(s
->pict_type
== FF_P_TYPE
){
783 fill_rectangle(s
->current_picture_ptr
->motion_val
[0][s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
], 2, 2, s
->b8_stride
, 0, 4);
784 rv34_mc_1mv (r
, block_type
, 0, 0, 0, 2, 2, 0);
787 case RV34_MB_B_DIRECT
:
788 //surprisingly, it uses motion scheme from next reference frame
789 next_bt
= s
->next_picture_ptr
->mb_type
[s
->mb_x
+ s
->mb_y
* s
->mb_stride
];
790 if(IS_INTRA(next_bt
) || IS_SKIP(next_bt
)){
791 fill_rectangle(s
->current_picture_ptr
->motion_val
[0][s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
], 2, 2, s
->b8_stride
, 0, 4);
792 fill_rectangle(s
->current_picture_ptr
->motion_val
[1][s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
], 2, 2, s
->b8_stride
, 0, 4);
794 for(j
= 0; j
< 2; j
++)
795 for(i
= 0; i
< 2; i
++)
796 for(k
= 0; k
< 2; k
++)
797 for(l
= 0; l
< 2; l
++)
798 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
]);
799 if(!(IS_16X8(next_bt
) || IS_8X16(next_bt
) || IS_8X8(next_bt
))) //we can use whole macroblock MC
800 rv34_mc_2mv(r
, block_type
);
803 fill_rectangle(s
->current_picture_ptr
->motion_val
[0][s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
], 2, 2, s
->b8_stride
, 0, 4);
805 case RV34_MB_P_16x16
:
806 case RV34_MB_P_MIX16x16
:
807 rv34_pred_mv(r
, block_type
, 0, 0);
808 rv34_mc_1mv (r
, block_type
, 0, 0, 0, 2, 2, 0);
810 case RV34_MB_B_FORWARD
:
811 case RV34_MB_B_BACKWARD
:
812 r
->dmv
[1][0] = r
->dmv
[0][0];
813 r
->dmv
[1][1] = r
->dmv
[0][1];
815 rv34_pred_mv_rv3(r
, block_type
, block_type
== RV34_MB_B_BACKWARD
);
817 rv34_pred_mv_b (r
, block_type
, block_type
== RV34_MB_B_BACKWARD
);
818 rv34_mc_1mv (r
, block_type
, 0, 0, 0, 2, 2, block_type
== RV34_MB_B_BACKWARD
);
822 rv34_pred_mv(r
, block_type
, 0, 0);
823 rv34_pred_mv(r
, block_type
, 1 + (block_type
== RV34_MB_P_16x8
), 1);
824 if(block_type
== RV34_MB_P_16x8
){
825 rv34_mc_1mv(r
, block_type
, 0, 0, 0, 2, 1, 0);
826 rv34_mc_1mv(r
, block_type
, 0, 8, s
->b8_stride
, 2, 1, 0);
828 if(block_type
== RV34_MB_P_8x16
){
829 rv34_mc_1mv(r
, block_type
, 0, 0, 0, 1, 2, 0);
830 rv34_mc_1mv(r
, block_type
, 8, 0, 1, 1, 2, 0);
833 case RV34_MB_B_BIDIR
:
834 rv34_pred_mv_b (r
, block_type
, 0);
835 rv34_pred_mv_b (r
, block_type
, 1);
836 rv34_mc_2mv (r
, block_type
);
840 rv34_pred_mv(r
, block_type
, i
, i
);
841 rv34_mc_1mv (r
, block_type
, (i
&1)<<3, (i
&2)<<2, (i
&1)+(i
>>1)*s
->b8_stride
, 1, 1, 0);
848 /** @} */ // mv group
851 * @defgroup recons Macroblock reconstruction functions
854 /** mapping of RV30/40 intra prediction types to standard H.264 types */
855 static const int ittrans
[9] = {
856 DC_PRED
, VERT_PRED
, HOR_PRED
, DIAG_DOWN_RIGHT_PRED
, DIAG_DOWN_LEFT_PRED
,
857 VERT_RIGHT_PRED
, VERT_LEFT_PRED
, HOR_UP_PRED
, HOR_DOWN_PRED
,
860 /** mapping of RV30/40 intra 16x16 prediction types to standard H.264 types */
861 static const int ittrans16
[4] = {
862 DC_PRED8x8
, VERT_PRED8x8
, HOR_PRED8x8
, PLANE_PRED8x8
,
866 * Perform 4x4 intra prediction.
868 static void rv34_pred_4x4_block(RV34DecContext
*r
, uint8_t *dst
, int stride
, int itype
, int up
, int left
, int down
, int right
)
870 uint8_t *prev
= dst
- stride
+ 4;
876 if(itype
== VERT_PRED
) itype
= HOR_PRED
;
877 if(itype
== DC_PRED
) itype
= LEFT_DC_PRED
;
879 if(itype
== HOR_PRED
) itype
= VERT_PRED
;
880 if(itype
== DC_PRED
) itype
= TOP_DC_PRED
;
881 if(itype
== DIAG_DOWN_LEFT_PRED
) itype
= DIAG_DOWN_LEFT_PRED_RV40_NODOWN
;
884 if(itype
== DIAG_DOWN_LEFT_PRED
) itype
= DIAG_DOWN_LEFT_PRED_RV40_NODOWN
;
885 if(itype
== HOR_UP_PRED
) itype
= HOR_UP_PRED_RV40_NODOWN
;
886 if(itype
== VERT_LEFT_PRED
) itype
= VERT_LEFT_PRED_RV40_NODOWN
;
889 topleft
= dst
[-stride
+ 3] * 0x01010101;
890 prev
= (uint8_t*)&topleft
;
892 r
->h
.pred4x4
[itype
](dst
, prev
, stride
);
895 /** add_pixels_clamped for 4x4 block */
896 static void rv34_add_4x4_block(uint8_t *dst
, int stride
, DCTELEM block
[64], int off
)
899 for(y
= 0; y
< 4; y
++)
900 for(x
= 0; x
< 4; x
++)
901 dst
[x
+ y
*stride
] = av_clip_uint8(dst
[x
+ y
*stride
] + block
[off
+ x
+y
*8]);
904 static inline int adjust_pred16(int itype
, int up
, int left
)
907 itype
= DC_128_PRED8x8
;
909 if(itype
== PLANE_PRED8x8
)itype
= HOR_PRED8x8
;
910 if(itype
== VERT_PRED8x8
) itype
= HOR_PRED8x8
;
911 if(itype
== DC_PRED8x8
) itype
= LEFT_DC_PRED8x8
;
913 if(itype
== PLANE_PRED8x8
)itype
= VERT_PRED8x8
;
914 if(itype
== HOR_PRED8x8
) itype
= VERT_PRED8x8
;
915 if(itype
== DC_PRED8x8
) itype
= TOP_DC_PRED8x8
;
920 static void rv34_output_macroblock(RV34DecContext
*r
, int8_t *intra_types
, int cbp
, int is16
)
922 MpegEncContext
*s
= &r
->s
;
923 DSPContext
*dsp
= &s
->dsp
;
927 int avail
[6*8] = {0};
930 // Set neighbour information.
931 if(r
->avail_cache
[0])
933 if(r
->avail_cache
[1])
934 avail
[1] = avail
[2] = 1;
935 if(r
->avail_cache
[2])
936 avail
[3] = avail
[4] = 1;
937 if(r
->avail_cache
[3])
939 if(r
->avail_cache
[4])
940 avail
[8] = avail
[16] = 1;
941 if(r
->avail_cache
[8])
942 avail
[24] = avail
[32] = 1;
948 for(j
= 0; j
< 4; j
++){
950 for(i
= 0; i
< 4; i
++, cbp
>>= 1, Y
+= 4, idx
++){
951 rv34_pred_4x4_block(r
, Y
, s
->linesize
, ittrans
[intra_types
[i
]], avail
[idx
-8], avail
[idx
-1], avail
[idx
+7], avail
[idx
-7]);
954 rv34_add_4x4_block(Y
, s
->linesize
, s
->block
[(i
>>1)+(j
&2)], (i
&1)*4+(j
&1)*32);
956 Y
+= s
->linesize
* 4 - 4*4;
957 intra_types
+= s
->b4_stride
;
959 intra_types
-= s
->b4_stride
* 4;
960 fill_rectangle(r
->avail_cache
+ 5, 2, 2, 4, 0, 4);
961 for(j
= 0; j
< 2; j
++){
963 for(i
= 0; i
< 2; i
++, cbp
>>= 1, idx
++){
964 rv34_pred_4x4_block(r
, U
+ i
*4 + j
*4*s
->uvlinesize
, s
->uvlinesize
, ittrans
[intra_types
[i
*2+j
*2*s
->b4_stride
]], r
->avail_cache
[idx
-4], r
->avail_cache
[idx
-1], !i
&& !j
, r
->avail_cache
[idx
-3]);
965 rv34_pred_4x4_block(r
, V
+ i
*4 + j
*4*s
->uvlinesize
, s
->uvlinesize
, ittrans
[intra_types
[i
*2+j
*2*s
->b4_stride
]], r
->avail_cache
[idx
-4], r
->avail_cache
[idx
-1], !i
&& !j
, r
->avail_cache
[idx
-3]);
966 r
->avail_cache
[idx
] = 1;
968 rv34_add_4x4_block(U
+ i
*4 + j
*4*s
->uvlinesize
, s
->uvlinesize
, s
->block
[4], i
*4+j
*32);
970 rv34_add_4x4_block(V
+ i
*4 + j
*4*s
->uvlinesize
, s
->uvlinesize
, s
->block
[5], i
*4+j
*32);
974 itype
= ittrans16
[intra_types
[0]];
975 itype
= adjust_pred16(itype
, r
->avail_cache
[5-4], r
->avail_cache
[5-1]);
976 r
->h
.pred16x16
[itype
](Y
, s
->linesize
);
977 dsp
->add_pixels_clamped(s
->block
[0], Y
, s
->linesize
);
978 dsp
->add_pixels_clamped(s
->block
[1], Y
+ 8, s
->linesize
);
979 Y
+= s
->linesize
* 8;
980 dsp
->add_pixels_clamped(s
->block
[2], Y
, s
->linesize
);
981 dsp
->add_pixels_clamped(s
->block
[3], Y
+ 8, s
->linesize
);
983 itype
= ittrans16
[intra_types
[0]];
984 if(itype
== PLANE_PRED8x8
) itype
= DC_PRED8x8
;
985 itype
= adjust_pred16(itype
, r
->avail_cache
[5-4], r
->avail_cache
[5-1]);
986 r
->h
.pred8x8
[itype
](U
, s
->uvlinesize
);
987 dsp
->add_pixels_clamped(s
->block
[4], U
, s
->uvlinesize
);
988 r
->h
.pred8x8
[itype
](V
, s
->uvlinesize
);
989 dsp
->add_pixels_clamped(s
->block
[5], V
, s
->uvlinesize
);
993 /** @} */ // recons group
996 * @addtogroup bitstream
997 * Decode macroblock header and return CBP in case of success, -1 otherwise.
999 static int rv34_decode_mb_header(RV34DecContext
*r
, int8_t *intra_types
)
1001 MpegEncContext
*s
= &r
->s
;
1002 GetBitContext
*gb
= &s
->gb
;
1003 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
1007 r
->is16
= get_bits1(gb
);
1008 if(!r
->is16
&& !r
->rv30
){
1010 av_log(s
->avctx
, AV_LOG_ERROR
, "Need DQUANT\n");
1012 s
->current_picture_ptr
->mb_type
[mb_pos
] = r
->is16
? MB_TYPE_INTRA16x16
: MB_TYPE_INTRA
;
1013 r
->block_type
= r
->is16
? RV34_MB_TYPE_INTRA16x16
: RV34_MB_TYPE_INTRA
;
1015 r
->block_type
= r
->decode_mb_info(r
);
1016 if(r
->block_type
== -1)
1018 s
->current_picture_ptr
->mb_type
[mb_pos
] = rv34_mb_type_to_lavc
[r
->block_type
];
1019 r
->mb_type
[mb_pos
] = r
->block_type
;
1020 if(r
->block_type
== RV34_MB_SKIP
){
1021 if(s
->pict_type
== FF_P_TYPE
)
1022 r
->mb_type
[mb_pos
] = RV34_MB_P_16x16
;
1023 if(s
->pict_type
== FF_B_TYPE
)
1024 r
->mb_type
[mb_pos
] = RV34_MB_B_DIRECT
;
1026 r
->is16
= !!IS_INTRA16x16(s
->current_picture_ptr
->mb_type
[mb_pos
]);
1027 rv34_decode_mv(r
, r
->block_type
);
1028 if(r
->block_type
== RV34_MB_SKIP
){
1029 fill_rectangle(intra_types
, 4, 4, s
->b4_stride
, 0, sizeof(intra_types
[0]));
1035 if(IS_INTRA(s
->current_picture_ptr
->mb_type
[mb_pos
])){
1037 t
= get_bits(gb
, 2);
1038 fill_rectangle(intra_types
, 4, 4, s
->b4_stride
, t
, sizeof(intra_types
[0]));
1041 if(r
->decode_intra_types(r
, gb
, intra_types
) < 0)
1046 r
->cur_vlcs
= choose_vlc_set(r
->si
.quant
, r
->si
.vlc_set
, 0);
1048 for(i
= 0; i
< 16; i
++)
1049 intra_types
[(i
& 3) + (i
>>2) * s
->b4_stride
] = 0;
1050 r
->cur_vlcs
= choose_vlc_set(r
->si
.quant
, r
->si
.vlc_set
, 1);
1051 if(r
->mb_type
[mb_pos
] == RV34_MB_P_MIX16x16
){
1055 r
->cur_vlcs
= choose_vlc_set(r
->si
.quant
, r
->si
.vlc_set
, 0);
1059 return rv34_decode_cbp(gb
, r
->cur_vlcs
, r
->is16
);
1063 * @addtogroup recons
1067 * mask for retrieving all bits in coded block pattern
1068 * corresponding to one 8x8 block
1070 #define LUMA_CBP_BLOCK_MASK 0x33
1072 #define U_CBP_MASK 0x0F0000
1073 #define V_CBP_MASK 0xF00000
1076 static void rv34_apply_differences(RV34DecContext
*r
, int cbp
)
1078 static const int shifts
[4] = { 0, 2, 8, 10 };
1079 MpegEncContext
*s
= &r
->s
;
1082 for(i
= 0; i
< 4; i
++)
1083 if((cbp
& (LUMA_CBP_BLOCK_MASK
<< shifts
[i
])) || r
->block_type
== RV34_MB_P_MIX16x16
)
1084 s
->dsp
.add_pixels_clamped(s
->block
[i
], s
->dest
[0] + (i
& 1)*8 + (i
&2)*4*s
->linesize
, s
->linesize
);
1085 if(cbp
& U_CBP_MASK
)
1086 s
->dsp
.add_pixels_clamped(s
->block
[4], s
->dest
[1], s
->uvlinesize
);
1087 if(cbp
& V_CBP_MASK
)
1088 s
->dsp
.add_pixels_clamped(s
->block
[5], s
->dest
[2], s
->uvlinesize
);
1091 static int is_mv_diff_gt_3(int16_t (*motion_val
)[2], int step
)
1094 d
= motion_val
[0][0] - motion_val
[-step
][0];
1097 d
= motion_val
[0][1] - motion_val
[-step
][1];
1103 static int rv34_set_deblock_coef(RV34DecContext
*r
)
1105 MpegEncContext
*s
= &r
->s
;
1106 int hmvmask
= 0, vmvmask
= 0, i
, j
;
1107 int midx
= s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
;
1108 int16_t (*motion_val
)[2] = s
->current_picture_ptr
->motion_val
[0][midx
];
1109 for(j
= 0; j
< 16; j
+= 8){
1110 for(i
= 0; i
< 2; i
++){
1111 if(is_mv_diff_gt_3(motion_val
+ i
, 1))
1112 vmvmask
|= 0x11 << (j
+ i
*2);
1113 if((j
|| s
->mb_y
) && is_mv_diff_gt_3(motion_val
+ i
, s
->b8_stride
))
1114 hmvmask
|= 0x03 << (j
+ i
*2);
1116 motion_val
+= s
->b8_stride
;
1118 if(s
->first_slice_line
)
1122 if(r
->rv30
){ //RV30 marks both subblocks on the edge for filtering
1123 vmvmask
|= (vmvmask
& 0x4444) >> 1;
1124 hmvmask
|= (hmvmask
& 0x0F00) >> 4;
1126 r
->deblock_coefs
[s
->mb_x
- 1 + s
->mb_y
*s
->mb_stride
] |= (vmvmask
& 0x1111) << 3;
1127 if(!s
->first_slice_line
)
1128 r
->deblock_coefs
[s
->mb_x
+ (s
->mb_y
- 1)*s
->mb_stride
] |= (hmvmask
& 0xF) << 12;
1130 return hmvmask
| vmvmask
;
1133 static int rv34_decode_macroblock(RV34DecContext
*r
, int8_t *intra_types
)
1135 MpegEncContext
*s
= &r
->s
;
1136 GetBitContext
*gb
= &s
->gb
;
1138 int i
, blknum
, blkoff
;
1139 DCTELEM block16
[64];
1142 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
1144 // Calculate which neighbours are available. Maybe it's worth optimizing too.
1145 memset(r
->avail_cache
, 0, sizeof(r
->avail_cache
));
1146 fill_rectangle(r
->avail_cache
+ 5, 2, 2, 4, 1, 4);
1147 dist
= (s
->mb_x
- s
->resync_mb_x
) + (s
->mb_y
- s
->resync_mb_y
) * s
->mb_width
;
1150 r
->avail_cache
[8] = s
->current_picture_ptr
->mb_type
[mb_pos
- 1];
1151 if(dist
>= s
->mb_width
)
1153 r
->avail_cache
[2] = s
->current_picture_ptr
->mb_type
[mb_pos
- s
->mb_stride
];
1154 if(((s
->mb_x
+1) < s
->mb_width
) && dist
>= s
->mb_width
- 1)
1155 r
->avail_cache
[3] = s
->current_picture_ptr
->mb_type
[mb_pos
- s
->mb_stride
+ 1];
1156 if(s
->mb_x
&& dist
> s
->mb_width
)
1157 r
->avail_cache
[0] = s
->current_picture_ptr
->mb_type
[mb_pos
- s
->mb_stride
- 1];
1159 s
->qscale
= r
->si
.quant
;
1160 cbp
= cbp2
= rv34_decode_mb_header(r
, intra_types
);
1161 r
->cbp_luma
[mb_pos
] = cbp
;
1162 r
->cbp_chroma
[mb_pos
] = cbp
>> 16;
1163 if(s
->pict_type
== FF_I_TYPE
)
1164 r
->deblock_coefs
[mb_pos
] = 0xFFFF;
1166 r
->deblock_coefs
[mb_pos
] = rv34_set_deblock_coef(r
) | r
->cbp_luma
[mb_pos
];
1167 s
->current_picture_ptr
->qscale_table
[mb_pos
] = s
->qscale
;
1172 luma_dc_quant
= r
->block_type
== RV34_MB_P_MIX16x16
? r
->luma_dc_quant_p
[s
->qscale
] : r
->luma_dc_quant_i
[s
->qscale
];
1174 memset(block16
, 0, sizeof(block16
));
1175 rv34_decode_block(block16
, gb
, r
->cur_vlcs
, 3, 0);
1176 rv34_dequant4x4_16x16(block16
, rv34_qscale_tab
[luma_dc_quant
],rv34_qscale_tab
[s
->qscale
]);
1177 rv34_inv_transform_noround(block16
);
1180 for(i
= 0; i
< 16; i
++, cbp
>>= 1){
1181 if(!r
->is16
&& !(cbp
& 1)) continue;
1182 blknum
= ((i
& 2) >> 1) + ((i
& 8) >> 2);
1183 blkoff
= ((i
& 1) << 2) + ((i
& 4) << 3);
1185 rv34_decode_block(s
->block
[blknum
] + blkoff
, gb
, r
->cur_vlcs
, r
->luma_vlc
, 0);
1186 rv34_dequant4x4(s
->block
[blknum
] + blkoff
, rv34_qscale_tab
[s
->qscale
],rv34_qscale_tab
[s
->qscale
]);
1187 if(r
->is16
) //FIXME: optimize
1188 s
->block
[blknum
][blkoff
] = block16
[(i
& 3) | ((i
& 0xC) << 1)];
1189 rv34_inv_transform(s
->block
[blknum
] + blkoff
);
1191 if(r
->block_type
== RV34_MB_P_MIX16x16
)
1192 r
->cur_vlcs
= choose_vlc_set(r
->si
.quant
, r
->si
.vlc_set
, 1);
1193 for(; i
< 24; i
++, cbp
>>= 1){
1194 if(!(cbp
& 1)) continue;
1195 blknum
= ((i
& 4) >> 2) + 4;
1196 blkoff
= ((i
& 1) << 2) + ((i
& 2) << 4);
1197 rv34_decode_block(s
->block
[blknum
] + blkoff
, gb
, r
->cur_vlcs
, r
->chroma_vlc
, 1);
1198 rv34_dequant4x4(s
->block
[blknum
] + blkoff
, rv34_qscale_tab
[rv34_chroma_quant
[1][s
->qscale
]],rv34_qscale_tab
[rv34_chroma_quant
[0][s
->qscale
]]);
1199 rv34_inv_transform(s
->block
[blknum
] + blkoff
);
1201 if(IS_INTRA(s
->current_picture_ptr
->mb_type
[mb_pos
]))
1202 rv34_output_macroblock(r
, intra_types
, cbp2
, r
->is16
);
1204 rv34_apply_differences(r
, cbp2
);
1209 static int check_slice_end(RV34DecContext
*r
, MpegEncContext
*s
)
1212 if(s
->mb_y
>= s
->mb_height
)
1216 if(r
->s
.mb_skip_run
> 1)
1218 bits
= r
->bits
- get_bits_count(&s
->gb
);
1219 if(bits
< 0 || (bits
< 8 && !show_bits(&s
->gb
, bits
)))
1224 static inline int slice_compare(SliceInfo
*si1
, SliceInfo
*si2
)
1226 return si1
->type
!= si2
->type
||
1227 si1
->start
>= si2
->start
||
1228 si1
->width
!= si2
->width
||
1229 si1
->height
!= si2
->height
||
1230 si1
->pts
!= si2
->pts
;
1233 static int rv34_decode_slice(RV34DecContext
*r
, int end
, const uint8_t* buf
, int buf_size
)
1235 MpegEncContext
*s
= &r
->s
;
1236 GetBitContext
*gb
= &s
->gb
;
1240 init_get_bits(&r
->s
.gb
, buf
, buf_size
*8);
1241 res
= r
->parse_slice_header(r
, gb
, &r
->si
);
1243 av_log(s
->avctx
, AV_LOG_ERROR
, "Incorrect or unknown slice header\n");
1247 if ((s
->mb_x
== 0 && s
->mb_y
== 0) || s
->current_picture_ptr
==NULL
) {
1248 if(s
->width
!= r
->si
.width
|| s
->height
!= r
->si
.height
){
1249 av_log(s
->avctx
, AV_LOG_DEBUG
, "Changing dimensions to %dx%d\n", r
->si
.width
,r
->si
.height
);
1251 s
->width
= r
->si
.width
;
1252 s
->height
= r
->si
.height
;
1253 if(MPV_common_init(s
) < 0)
1255 r
->intra_types_hist
= av_realloc(r
->intra_types_hist
, s
->b4_stride
* 4 * 2 * sizeof(*r
->intra_types_hist
));
1256 r
->intra_types
= r
->intra_types_hist
+ s
->b4_stride
* 4;
1257 r
->mb_type
= av_realloc(r
->mb_type
, r
->s
.mb_stride
* r
->s
.mb_height
* sizeof(*r
->mb_type
));
1258 r
->cbp_luma
= av_realloc(r
->cbp_luma
, r
->s
.mb_stride
* r
->s
.mb_height
* sizeof(*r
->cbp_luma
));
1259 r
->cbp_chroma
= av_realloc(r
->cbp_chroma
, r
->s
.mb_stride
* r
->s
.mb_height
* sizeof(*r
->cbp_chroma
));
1260 r
->deblock_coefs
= av_realloc(r
->deblock_coefs
, r
->s
.mb_stride
* r
->s
.mb_height
* sizeof(*r
->deblock_coefs
));
1262 s
->pict_type
= r
->si
.type
? r
->si
.type
: FF_I_TYPE
;
1263 if(MPV_frame_start(s
, s
->avctx
) < 0)
1265 ff_er_frame_start(s
);
1266 r
->cur_pts
= r
->si
.pts
;
1267 if(s
->pict_type
!= FF_B_TYPE
){
1268 r
->last_pts
= r
->next_pts
;
1269 r
->next_pts
= r
->cur_pts
;
1271 s
->mb_x
= s
->mb_y
= 0;
1275 s
->qscale
= r
->si
.quant
;
1276 r
->bits
= buf_size
*8;
1277 s
->mb_num_left
= r
->si
.end
- r
->si
.start
;
1278 r
->s
.mb_skip_run
= 0;
1280 mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_width
;
1281 if(r
->si
.start
!= mb_pos
){
1282 av_log(s
->avctx
, AV_LOG_ERROR
, "Slice indicates MB offset %d, got %d\n", r
->si
.start
, mb_pos
);
1283 s
->mb_x
= r
->si
.start
% s
->mb_width
;
1284 s
->mb_y
= r
->si
.start
/ s
->mb_width
;
1286 memset(r
->intra_types_hist
, -1, s
->b4_stride
* 4 * 2 * sizeof(*r
->intra_types_hist
));
1287 s
->first_slice_line
= 1;
1288 s
->resync_mb_x
= s
->mb_x
;
1289 s
->resync_mb_y
= s
->mb_y
;
1291 ff_init_block_index(s
);
1292 while(!check_slice_end(r
, s
)) {
1293 ff_update_block_index(s
);
1294 s
->dsp
.clear_blocks(s
->block
[0]);
1296 if(rv34_decode_macroblock(r
, r
->intra_types
+ s
->mb_x
* 4 + 1) < 0){
1297 ff_er_add_slice(s
, s
->resync_mb_x
, s
->resync_mb_y
, s
->mb_x
-1, s
->mb_y
, AC_ERROR
|DC_ERROR
|MV_ERROR
);
1300 if (++s
->mb_x
== s
->mb_width
) {
1303 ff_init_block_index(s
);
1305 memmove(r
->intra_types_hist
, r
->intra_types
, s
->b4_stride
* 4 * sizeof(*r
->intra_types_hist
));
1306 memset(r
->intra_types
, -1, s
->b4_stride
* 4 * sizeof(*r
->intra_types_hist
));
1308 if(r
->loop_filter
&& s
->mb_y
>= 2)
1309 r
->loop_filter(r
, s
->mb_y
- 2);
1311 if(s
->mb_x
== s
->resync_mb_x
)
1312 s
->first_slice_line
=0;
1315 ff_er_add_slice(s
, s
->resync_mb_x
, s
->resync_mb_y
, s
->mb_x
-1, s
->mb_y
, AC_END
|DC_END
|MV_END
);
1317 return s
->mb_y
== s
->mb_height
;
1320 /** @} */ // recons group end
1323 * Initialize decoder.
1325 av_cold
int ff_rv34_decode_init(AVCodecContext
*avctx
)
1327 RV34DecContext
*r
= avctx
->priv_data
;
1328 MpegEncContext
*s
= &r
->s
;
1330 MPV_decode_defaults(s
);
1332 s
->out_format
= FMT_H263
;
1333 s
->codec_id
= avctx
->codec_id
;
1335 s
->width
= avctx
->width
;
1336 s
->height
= avctx
->height
;
1339 avctx
->flags
|= CODEC_FLAG_EMU_EDGE
;
1340 r
->s
.flags
|= CODEC_FLAG_EMU_EDGE
;
1341 avctx
->pix_fmt
= PIX_FMT_YUV420P
;
1342 avctx
->has_b_frames
= 1;
1345 if (MPV_common_init(s
) < 0)
1348 ff_h264_pred_init(&r
->h
, CODEC_ID_RV40
);
1350 r
->intra_types_hist
= av_malloc(s
->b4_stride
* 4 * 2 * sizeof(*r
->intra_types_hist
));
1351 r
->intra_types
= r
->intra_types_hist
+ s
->b4_stride
* 4;
1353 r
->mb_type
= av_mallocz(r
->s
.mb_stride
* r
->s
.mb_height
* sizeof(*r
->mb_type
));
1355 r
->cbp_luma
= av_malloc(r
->s
.mb_stride
* r
->s
.mb_height
* sizeof(*r
->cbp_luma
));
1356 r
->cbp_chroma
= av_malloc(r
->s
.mb_stride
* r
->s
.mb_height
* sizeof(*r
->cbp_chroma
));
1357 r
->deblock_coefs
= av_malloc(r
->s
.mb_stride
* r
->s
.mb_height
* sizeof(*r
->deblock_coefs
));
1359 if(!intra_vlcs
[0].cbppattern
[0].bits
)
1365 static int get_slice_offset(AVCodecContext
*avctx
, const uint8_t *buf
, int n
)
1367 if(avctx
->slice_count
) return avctx
->slice_offset
[n
];
1368 else return AV_RL32(buf
+ n
*8 - 4) == 1 ? AV_RL32(buf
+ n
*8) : AV_RB32(buf
+ n
*8);
1371 int ff_rv34_decode_frame(AVCodecContext
*avctx
,
1372 void *data
, int *data_size
,
1375 const uint8_t *buf
= avpkt
->data
;
1376 int buf_size
= avpkt
->size
;
1377 RV34DecContext
*r
= avctx
->priv_data
;
1378 MpegEncContext
*s
= &r
->s
;
1379 AVFrame
*pict
= data
;
1383 const uint8_t *slices_hdr
= NULL
;
1386 /* no supplementary picture */
1387 if (buf_size
== 0) {
1388 /* special case for last picture */
1389 if (s
->low_delay
==0 && s
->next_picture_ptr
) {
1390 *pict
= *(AVFrame
*)s
->next_picture_ptr
;
1391 s
->next_picture_ptr
= NULL
;
1393 *data_size
= sizeof(AVFrame
);
1398 if(!avctx
->slice_count
){
1399 slice_count
= (*buf
++) + 1;
1400 slices_hdr
= buf
+ 4;
1401 buf
+= 8 * slice_count
;
1403 slice_count
= avctx
->slice_count
;
1405 //parse first slice header to check whether this frame can be decoded
1406 if(get_slice_offset(avctx
, slices_hdr
, 0) > buf_size
){
1407 av_log(avctx
, AV_LOG_ERROR
, "Slice offset is greater than frame size\n");
1410 init_get_bits(&s
->gb
, buf
+get_slice_offset(avctx
, slices_hdr
, 0), buf_size
-get_slice_offset(avctx
, slices_hdr
, 0));
1411 if(r
->parse_slice_header(r
, &r
->s
.gb
, &si
) < 0 || si
.start
){
1412 av_log(avctx
, AV_LOG_ERROR
, "First slice header is incorrect\n");
1415 if((!s
->last_picture_ptr
|| !s
->last_picture_ptr
->data
[0]) && si
.type
== FF_B_TYPE
)
1417 /* skip b frames if we are in a hurry */
1418 if(avctx
->hurry_up
&& si
.type
==FF_B_TYPE
) return buf_size
;
1419 if( (avctx
->skip_frame
>= AVDISCARD_NONREF
&& si
.type
==FF_B_TYPE
)
1420 || (avctx
->skip_frame
>= AVDISCARD_NONKEY
&& si
.type
!=FF_I_TYPE
)
1421 || avctx
->skip_frame
>= AVDISCARD_ALL
)
1423 /* skip everything if we are in a hurry>=5 */
1424 if(avctx
->hurry_up
>=5)
1427 for(i
=0; i
<slice_count
; i
++){
1428 int offset
= get_slice_offset(avctx
, slices_hdr
, i
);
1430 if(i
+1 == slice_count
)
1431 size
= buf_size
- offset
;
1433 size
= get_slice_offset(avctx
, slices_hdr
, i
+1) - offset
;
1435 if(offset
> buf_size
){
1436 av_log(avctx
, AV_LOG_ERROR
, "Slice offset is greater than frame size\n");
1440 r
->si
.end
= s
->mb_width
* s
->mb_height
;
1441 if(i
+1 < slice_count
){
1442 init_get_bits(&s
->gb
, buf
+get_slice_offset(avctx
, slices_hdr
, i
+1), (buf_size
-get_slice_offset(avctx
, slices_hdr
, i
+1))*8);
1443 if(r
->parse_slice_header(r
, &r
->s
.gb
, &si
) < 0){
1444 if(i
+2 < slice_count
)
1445 size
= get_slice_offset(avctx
, slices_hdr
, i
+2) - offset
;
1447 size
= buf_size
- offset
;
1449 r
->si
.end
= si
.start
;
1451 last
= rv34_decode_slice(r
, r
->si
.end
, buf
+ offset
, size
);
1452 s
->mb_num_left
= r
->s
.mb_x
+ r
->s
.mb_y
*r
->s
.mb_width
- r
->si
.start
;
1459 r
->loop_filter(r
, s
->mb_height
- 1);
1462 if (s
->pict_type
== FF_B_TYPE
|| s
->low_delay
) {
1463 *pict
= *(AVFrame
*)s
->current_picture_ptr
;
1464 } else if (s
->last_picture_ptr
!= NULL
) {
1465 *pict
= *(AVFrame
*)s
->last_picture_ptr
;
1468 if(s
->last_picture_ptr
|| s
->low_delay
){
1469 *data_size
= sizeof(AVFrame
);
1470 ff_print_debug_info(s
, pict
);
1472 s
->current_picture_ptr
= NULL
; //so we can detect if frame_end wasnt called (find some nicer solution...)
1477 av_cold
int ff_rv34_decode_end(AVCodecContext
*avctx
)
1479 RV34DecContext
*r
= avctx
->priv_data
;
1481 MPV_common_end(&r
->s
);
1483 av_freep(&r
->intra_types_hist
);
1484 r
->intra_types
= NULL
;
1485 av_freep(&r
->mb_type
);
1486 av_freep(&r
->cbp_luma
);
1487 av_freep(&r
->cbp_chroma
);
1488 av_freep(&r
->deblock_coefs
);