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
24 * RV30/40 decoder common data
29 #include "mpegvideo.h"
31 #include "rectangle.h"
39 /** translation of RV30/40 macroblock types to lavc ones */
40 static const int rv34_mb_type_to_lavc
[12] = {
43 MB_TYPE_16x16
| MB_TYPE_L0
,
44 MB_TYPE_8x8
| MB_TYPE_L0
,
45 MB_TYPE_16x16
| MB_TYPE_L0
,
46 MB_TYPE_16x16
| MB_TYPE_L1
,
48 MB_TYPE_DIRECT2
| MB_TYPE_16x16
,
49 MB_TYPE_16x8
| MB_TYPE_L0
,
50 MB_TYPE_8x16
| MB_TYPE_L0
,
51 MB_TYPE_16x16
| MB_TYPE_L0L1
,
52 MB_TYPE_16x16
| MB_TYPE_L0
56 static RV34VLC intra_vlcs
[NUM_INTRA_TABLES
], inter_vlcs
[NUM_INTER_TABLES
];
59 * @defgroup vlc RV30/40 VLC generating functions
64 * Generate VLC from codeword lengths.
65 * @param bits codeword lengths (zeroes are accepted)
66 * @param size length of input data
67 * @param insyms symbols for input codes (NULL for default ones)
69 static void rv34_gen_vlc(const uint8_t *bits
, int size
, VLC
*vlc
, const uint8_t *insyms
)
72 int counts
[17] = {0}, codes
[17];
73 uint16_t cw
[size
], syms
[size
];
75 int maxbits
= 0, realsize
= 0;
77 for(i
= 0; i
< size
; i
++){
79 bits2
[realsize
] = bits
[i
];
80 syms
[realsize
] = insyms
? insyms
[i
] : i
;
82 maxbits
= FFMAX(maxbits
, bits
[i
]);
88 for(i
= 0; i
< 16; i
++)
89 codes
[i
+1] = (codes
[i
] + counts
[i
]) << 1;
90 for(i
= 0; i
< realsize
; i
++)
91 cw
[i
] = codes
[bits2
[i
]]++;
93 init_vlc_sparse(vlc
, FFMIN(maxbits
, 9), realsize
,
96 syms
, 2, 2, INIT_VLC_USE_STATIC
);
100 * Initialize all tables.
102 static void rv34_init_tables()
106 for(i
= 0; i
< NUM_INTRA_TABLES
; i
++){
107 for(j
= 0; j
< 2; j
++){
108 rv34_gen_vlc(rv34_table_intra_cbppat
[i
][j
], CBPPAT_VLC_SIZE
, &intra_vlcs
[i
].cbppattern
[j
], NULL
);
109 rv34_gen_vlc(rv34_table_intra_secondpat
[i
][j
], OTHERBLK_VLC_SIZE
, &intra_vlcs
[i
].second_pattern
[j
], NULL
);
110 rv34_gen_vlc(rv34_table_intra_thirdpat
[i
][j
], OTHERBLK_VLC_SIZE
, &intra_vlcs
[i
].third_pattern
[j
], NULL
);
111 for(k
= 0; k
< 4; k
++)
112 rv34_gen_vlc(rv34_table_intra_cbp
[i
][j
+k
*2], CBP_VLC_SIZE
, &intra_vlcs
[i
].cbp
[j
][k
], rv34_cbp_code
);
114 for(j
= 0; j
< 4; j
++)
115 rv34_gen_vlc(rv34_table_intra_firstpat
[i
][j
], FIRSTBLK_VLC_SIZE
, &intra_vlcs
[i
].first_pattern
[j
], NULL
);
116 rv34_gen_vlc(rv34_intra_coeff
[i
], COEFF_VLC_SIZE
, &intra_vlcs
[i
].coefficient
, NULL
);
119 for(i
= 0; i
< NUM_INTER_TABLES
; i
++){
120 rv34_gen_vlc(rv34_inter_cbppat
[i
], CBPPAT_VLC_SIZE
, &inter_vlcs
[i
].cbppattern
[0], NULL
);
121 for(j
= 0; j
< 4; j
++)
122 rv34_gen_vlc(rv34_inter_cbp
[i
][j
], CBP_VLC_SIZE
, &inter_vlcs
[i
].cbp
[0][j
], rv34_cbp_code
);
123 for(j
= 0; j
< 2; j
++){
124 rv34_gen_vlc(rv34_table_inter_firstpat
[i
][j
], FIRSTBLK_VLC_SIZE
, &inter_vlcs
[i
].first_pattern
[j
], NULL
);
125 rv34_gen_vlc(rv34_table_inter_secondpat
[i
][j
], OTHERBLK_VLC_SIZE
, &inter_vlcs
[i
].second_pattern
[j
], NULL
);
126 rv34_gen_vlc(rv34_table_inter_thirdpat
[i
][j
], OTHERBLK_VLC_SIZE
, &inter_vlcs
[i
].third_pattern
[j
], NULL
);
128 rv34_gen_vlc(rv34_inter_coeff
[i
], COEFF_VLC_SIZE
, &inter_vlcs
[i
].coefficient
, NULL
);
132 /** @} */ // vlc group
136 * @defgroup transform RV30/40 inverse transform functions
140 static av_always_inline
void rv34_row_transform(int temp
[16], DCTELEM
*block
)
145 const int z0
= 13*(block
[i
+8*0] + block
[i
+8*2]);
146 const int z1
= 13*(block
[i
+8*0] - block
[i
+8*2]);
147 const int z2
= 7* block
[i
+8*1] - 17*block
[i
+8*3];
148 const int z3
= 17* block
[i
+8*1] + 7*block
[i
+8*3];
158 * Real Video 3.0/4.0 inverse transform
159 * Code is almost the same as in SVQ3, only scaling is different.
161 static void rv34_inv_transform(DCTELEM
*block
){
165 rv34_row_transform(temp
, block
);
168 const int z0
= 13*(temp
[4*0+i
] + temp
[4*2+i
]) + 0x200;
169 const int z1
= 13*(temp
[4*0+i
] - temp
[4*2+i
]) + 0x200;
170 const int z2
= 7* temp
[4*1+i
] - 17*temp
[4*3+i
];
171 const int z3
= 17* temp
[4*1+i
] + 7*temp
[4*3+i
];
173 block
[i
*8+0]= (z0
+ z3
)>>10;
174 block
[i
*8+1]= (z1
+ z2
)>>10;
175 block
[i
*8+2]= (z1
- z2
)>>10;
176 block
[i
*8+3]= (z0
- z3
)>>10;
182 * RealVideo 3.0/4.0 inverse transform for DC block
184 * Code is almost the same as rv34_inv_transform()
185 * but final coefficients are multiplied by 1.5 and have no rounding.
187 static void rv34_inv_transform_noround(DCTELEM
*block
){
191 rv34_row_transform(temp
, block
);
194 const int z0
= 13*(temp
[4*0+i
] + temp
[4*2+i
]);
195 const int z1
= 13*(temp
[4*0+i
] - temp
[4*2+i
]);
196 const int z2
= 7* temp
[4*1+i
] - 17*temp
[4*3+i
];
197 const int z3
= 17* temp
[4*1+i
] + 7*temp
[4*3+i
];
199 block
[i
*8+0]= ((z0
+ z3
)*3)>>11;
200 block
[i
*8+1]= ((z1
+ z2
)*3)>>11;
201 block
[i
*8+2]= ((z1
- z2
)*3)>>11;
202 block
[i
*8+3]= ((z0
- z3
)*3)>>11;
207 /** @} */ // transform
211 * @defgroup block RV30/40 4x4 block decoding functions
216 * Decode coded block pattern.
218 static int rv34_decode_cbp(GetBitContext
*gb
, RV34VLC
*vlc
, int table
)
220 int pattern
, code
, cbp
=0;
222 static const int cbp_masks
[3] = {0x100000, 0x010000, 0x110000};
223 static const int shifts
[4] = { 0, 2, 8, 10 };
224 int *curshift
= shifts
;
227 code
= get_vlc2(gb
, vlc
->cbppattern
[table
].table
, 9, 2);
228 pattern
= code
& 0xF;
231 ones
= rv34_count_ones
[pattern
];
233 for(mask
= 8; mask
; mask
>>= 1, curshift
++){
235 cbp
|= get_vlc2(gb
, vlc
->cbp
[table
][ones
].table
, vlc
->cbp
[table
][ones
].bits
, 1) << curshift
[0];
238 for(i
= 0; i
< 4; i
++){
239 t
= modulo_three_table
[code
][i
];
241 cbp
|= cbp_masks
[get_bits1(gb
)] << i
;
243 cbp
|= cbp_masks
[2] << i
;
249 * Get one coefficient value from the bistream and store it.
251 static inline void decode_coeff(DCTELEM
*dst
, int coef
, int esc
, GetBitContext
*gb
, VLC
* vlc
)
255 coef
= get_vlc2(gb
, vlc
->table
, 9, 2);
258 coef
= 22 + ((1 << coef
) | get_bits(gb
, coef
));
269 * Decode 2x2 subblock of coefficients.
271 static inline void decode_subblock(DCTELEM
*dst
, int code
, const int is_block2
, GetBitContext
*gb
, VLC
*vlc
)
275 coeffs
[0] = modulo_three_table
[code
][0];
276 coeffs
[1] = modulo_three_table
[code
][1];
277 coeffs
[2] = modulo_three_table
[code
][2];
278 coeffs
[3] = modulo_three_table
[code
][3];
279 decode_coeff(dst
, coeffs
[0], 3, gb
, vlc
);
281 decode_coeff(dst
+8, coeffs
[1], 2, gb
, vlc
);
282 decode_coeff(dst
+1, coeffs
[2], 2, gb
, vlc
);
284 decode_coeff(dst
+1, coeffs
[1], 2, gb
, vlc
);
285 decode_coeff(dst
+8, coeffs
[2], 2, gb
, vlc
);
287 decode_coeff(dst
+9, coeffs
[3], 2, gb
, vlc
);
291 * Decode coefficients for 4x4 block.
293 * This is done by filling 2x2 subblocks with decoded coefficients
294 * in this order (the same for subblocks and subblock coefficients):
301 static inline void rv34_decode_block(DCTELEM
*dst
, GetBitContext
*gb
, RV34VLC
*rvlc
, int fc
, int sc
)
305 code
= get_vlc2(gb
, rvlc
->first_pattern
[fc
].table
, 9, 2);
307 pattern
= code
& 0x7;
310 decode_subblock(dst
, code
, 0, gb
, &rvlc
->coefficient
);
313 code
= get_vlc2(gb
, rvlc
->second_pattern
[sc
].table
, 9, 2);
314 decode_subblock(dst
+ 2, code
, 0, gb
, &rvlc
->coefficient
);
316 if(pattern
& 2){ // Looks like coefficients 1 and 2 are swapped for this block
317 code
= get_vlc2(gb
, rvlc
->second_pattern
[sc
].table
, 9, 2);
318 decode_subblock(dst
+ 8*2, code
, 1, gb
, &rvlc
->coefficient
);
321 code
= get_vlc2(gb
, rvlc
->third_pattern
[sc
].table
, 9, 2);
322 decode_subblock(dst
+ 8*2+2, code
, 0, gb
, &rvlc
->coefficient
);
328 * Dequantize ordinary 4x4 block.
331 static inline void rv34_dequant4x4(DCTELEM
*block
, int Qdc
, int Q
)
335 block
[0] = (block
[0] * Qdc
+ 8) >> 4;
336 for(i
= 0; i
< 4; i
++)
337 for(j
= !i
; j
< 4; j
++)
338 block
[j
+ i
*8] = (block
[j
+ i
*8] * Q
+ 8) >> 4;
342 * Dequantize 4x4 block of DC values for 16x16 macroblock.
345 static inline void rv34_dequant4x4_16x16(DCTELEM
*block
, int Qdc
, int Q
)
349 for(i
= 0; i
< 3; i
++)
350 block
[rv34_dezigzag
[i
]] = (block
[rv34_dezigzag
[i
]] * Qdc
+ 8) >> 4;
352 block
[rv34_dezigzag
[i
]] = (block
[rv34_dezigzag
[i
]] * Q
+ 8) >> 4;
354 /** @} */ //block functions
358 * @defgroup bitstream RV30/40 bitstream parsing
363 * Decode starting slice position.
364 * @todo Maybe replace with ff_h263_decode_mba() ?
366 int ff_rv34_get_start_offset(GetBitContext
*gb
, int mb_size
)
369 for(i
= 0; i
< 5; i
++)
370 if(rv34_mb_max_sizes
[i
] > mb_size
)
372 return rv34_mb_bits_sizes
[i
];
376 * Select VLC set for decoding from current quantizer, modifier and frame type.
378 static inline RV34VLC
* choose_vlc_set(int quant
, int mod
, int type
)
380 if(mod
== 2 && quant
< 19) quant
+= 10;
381 else if(mod
&& quant
< 26) quant
+= 5;
382 return type
? &inter_vlcs
[rv34_quant_to_vlc_set
[1][av_clip(quant
, 0, 30)]]
383 : &intra_vlcs
[rv34_quant_to_vlc_set
[0][av_clip(quant
, 0, 30)]];
387 * Decode quantizer difference and return modified quantizer.
389 static inline int rv34_decode_dquant(GetBitContext
*gb
, int quant
)
392 return rv34_dquant_tab
[get_bits1(gb
)][quant
];
394 return get_bits(gb
, 5);
397 /** @} */ //bitstream functions
400 * @defgroup mv motion vector related code (prediction, reconstruction, motion compensation)
404 /** macroblock partition width in 8x8 blocks */
405 static const uint8_t part_sizes_w
[RV34_MB_TYPES
] = { 2, 2, 2, 1, 2, 2, 2, 2, 2, 1, 2, 2 };
407 /** macroblock partition height in 8x8 blocks */
408 static const uint8_t part_sizes_h
[RV34_MB_TYPES
] = { 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2 };
410 /** availability index for subblocks */
411 static const uint8_t avail_indexes
[4] = { 5, 6, 9, 10 };
414 * motion vector prediction
416 * Motion prediction performed for the block by using median prediction of
417 * motion vectors from the left, top and right top blocks but in corner cases
418 * some other vectors may be used instead.
420 static void rv34_pred_mv(RV34DecContext
*r
, int block_type
, int subblock_no
, int dmv_no
)
422 MpegEncContext
*s
= &r
->s
;
423 int mv_pos
= s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
;
424 int A
[2] = {0}, B
[2], C
[2];
427 int avail_index
= avail_indexes
[subblock_no
];
428 int c_off
= part_sizes_w
[block_type
];
430 mv_pos
+= (subblock_no
& 1) + (subblock_no
>> 1)*s
->b8_stride
;
434 if(r
->avail_cache
[avail_index
- 1]){
435 A
[0] = s
->current_picture_ptr
->motion_val
[0][mv_pos
-1][0];
436 A
[1] = s
->current_picture_ptr
->motion_val
[0][mv_pos
-1][1];
438 if(r
->avail_cache
[avail_index
- 4]){
439 B
[0] = s
->current_picture_ptr
->motion_val
[0][mv_pos
-s
->b8_stride
][0];
440 B
[1] = s
->current_picture_ptr
->motion_val
[0][mv_pos
-s
->b8_stride
][1];
445 if(!r
->avail_cache
[avail_index
- 4 + c_off
]){
446 if(r
->avail_cache
[avail_index
- 4] && (r
->avail_cache
[avail_index
- 1] || r
->rv30
)){
447 C
[0] = s
->current_picture_ptr
->motion_val
[0][mv_pos
-s
->b8_stride
-1][0];
448 C
[1] = s
->current_picture_ptr
->motion_val
[0][mv_pos
-s
->b8_stride
-1][1];
454 C
[0] = s
->current_picture_ptr
->motion_val
[0][mv_pos
-s
->b8_stride
+c_off
][0];
455 C
[1] = s
->current_picture_ptr
->motion_val
[0][mv_pos
-s
->b8_stride
+c_off
][1];
457 mx
= mid_pred(A
[0], B
[0], C
[0]);
458 my
= mid_pred(A
[1], B
[1], C
[1]);
459 mx
+= r
->dmv
[dmv_no
][0];
460 my
+= r
->dmv
[dmv_no
][1];
461 for(j
= 0; j
< part_sizes_h
[block_type
]; j
++){
462 for(i
= 0; i
< part_sizes_w
[block_type
]; i
++){
463 s
->current_picture_ptr
->motion_val
[0][mv_pos
+ i
+ j
*s
->b8_stride
][0] = mx
;
464 s
->current_picture_ptr
->motion_val
[0][mv_pos
+ i
+ j
*s
->b8_stride
][1] = my
;
470 * Calculate motion vector component that should be added for direct blocks.
472 static int calc_add_mv(MpegEncContext
*s
, int dir
, int component
)
474 int mv_pos
= s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
;
477 sum
= (s
->next_picture_ptr
->motion_val
[0][mv_pos
][component
] +
478 s
->next_picture_ptr
->motion_val
[0][mv_pos
+ 1][component
] +
479 s
->next_picture_ptr
->motion_val
[0][mv_pos
+ s
->b8_stride
][component
] +
480 s
->next_picture_ptr
->motion_val
[0][mv_pos
+ s
->b8_stride
+ 1][component
]) >> 2;
481 return dir
? -(sum
>> 1) : ((sum
+ 1) >> 1);
485 * Predict motion vector for B-frame macroblock.
487 static inline void rv34_pred_b_vector(int A
[2], int B
[2], int C
[2],
488 int A_avail
, int B_avail
, int C_avail
,
491 if(A_avail
+ B_avail
+ C_avail
!= 3){
492 *mx
= A
[0] + B
[0] + C
[0];
493 *my
= A
[1] + B
[1] + C
[1];
494 if(A_avail
+ B_avail
+ C_avail
== 2){
499 *mx
= mid_pred(A
[0], B
[0], C
[0]);
500 *my
= mid_pred(A
[1], B
[1], C
[1]);
505 * motion vector prediction for B-frames
507 static void rv34_pred_mv_b(RV34DecContext
*r
, int block_type
, int dir
)
509 MpegEncContext
*s
= &r
->s
;
510 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
511 int mv_pos
= s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
;
512 int A
[2], B
[2], C
[2];
513 int has_A
= 0, has_B
= 0, has_C
= 0;
516 Picture
*cur_pic
= s
->current_picture_ptr
;
517 const int mask
= dir
? MB_TYPE_L1
: MB_TYPE_L0
;
518 int type
= cur_pic
->mb_type
[mb_pos
];
520 memset(A
, 0, sizeof(A
));
521 memset(B
, 0, sizeof(B
));
522 memset(C
, 0, sizeof(C
));
523 if((r
->avail_cache
[5-1] & type
) & mask
){
524 A
[0] = cur_pic
->motion_val
[dir
][mv_pos
- 1][0];
525 A
[1] = cur_pic
->motion_val
[dir
][mv_pos
- 1][1];
528 if((r
->avail_cache
[5-4] & type
) & mask
){
529 B
[0] = cur_pic
->motion_val
[dir
][mv_pos
- s
->b8_stride
][0];
530 B
[1] = cur_pic
->motion_val
[dir
][mv_pos
- s
->b8_stride
][1];
533 if((r
->avail_cache
[5-2] & type
) & mask
){
534 C
[0] = cur_pic
->motion_val
[dir
][mv_pos
- s
->b8_stride
+ 2][0];
535 C
[1] = cur_pic
->motion_val
[dir
][mv_pos
- s
->b8_stride
+ 2][1];
537 }else if((s
->mb_x
+1) == s
->mb_width
&& (r
->avail_cache
[5-5] & type
) & mask
){
538 C
[0] = cur_pic
->motion_val
[dir
][mv_pos
- s
->b8_stride
- 1][0];
539 C
[1] = cur_pic
->motion_val
[dir
][mv_pos
- s
->b8_stride
- 1][1];
543 rv34_pred_b_vector(A
, B
, C
, has_A
, has_B
, has_C
, &mx
, &my
);
545 mx
+= r
->dmv
[dir
][0];
546 my
+= r
->dmv
[dir
][1];
548 if(block_type
== RV34_MB_B_DIRECT
){
549 mx
+= calc_add_mv(s
, dir
, 0);
550 my
+= calc_add_mv(s
, dir
, 1);
552 for(j
= 0; j
< 2; j
++){
553 for(i
= 0; i
< 2; i
++){
554 cur_pic
->motion_val
[dir
][mv_pos
+ i
+ j
*s
->b8_stride
][0] = mx
;
555 cur_pic
->motion_val
[dir
][mv_pos
+ i
+ j
*s
->b8_stride
][1] = my
;
558 if(block_type
== RV34_MB_B_BACKWARD
|| block_type
== RV34_MB_B_FORWARD
)
559 fill_rectangle(cur_pic
->motion_val
[!dir
][mv_pos
], 2, 2, s
->b8_stride
, 0, 4);
562 static const int chroma_coeffs
[3] = { 8, 5, 3 };
565 * generic motion compensation function
567 * @param r decoder context
568 * @param block_type type of the current block
569 * @param xoff horizontal offset from the start of the current block
570 * @param yoff vertical offset from the start of the current block
571 * @param mv_off offset to the motion vector information
572 * @param width width of the current partition in 8x8 blocks
573 * @param height height of the current partition in 8x8 blocks
575 static inline void rv34_mc(RV34DecContext
*r
, const int block_type
,
576 const int xoff
, const int yoff
, int mv_off
,
577 const int width
, const int height
, int dir
,
579 qpel_mc_func (*qpel_mc
)[16],
580 h264_chroma_mc_func (*chroma_mc
))
582 MpegEncContext
*s
= &r
->s
;
583 uint8_t *Y
, *U
, *V
, *srcY
, *srcU
, *srcV
;
584 int dxy
, mx
, my
, lx
, ly
, uvmx
, uvmy
, src_x
, src_y
, uvsrc_x
, uvsrc_y
;
585 int mv_pos
= s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
+ mv_off
;
589 mx
= (s
->current_picture_ptr
->motion_val
[dir
][mv_pos
][0] + (3 << 24)) / 3 - (1 << 24);
590 my
= (s
->current_picture_ptr
->motion_val
[dir
][mv_pos
][1] + (3 << 24)) / 3 - (1 << 24);
591 lx
= (s
->current_picture_ptr
->motion_val
[dir
][mv_pos
][0] + (3 << 24)) % 3;
592 ly
= (s
->current_picture_ptr
->motion_val
[dir
][mv_pos
][1] + (3 << 24)) % 3;
593 uvmx
= chroma_coeffs
[(3*(mx
&1) + lx
) >> 1];
594 uvmy
= chroma_coeffs
[(3*(my
&1) + ly
) >> 1];
596 mx
= s
->current_picture_ptr
->motion_val
[dir
][mv_pos
][0] >> 2;
597 my
= s
->current_picture_ptr
->motion_val
[dir
][mv_pos
][1] >> 2;
598 lx
= s
->current_picture_ptr
->motion_val
[dir
][mv_pos
][0] & 3;
599 ly
= s
->current_picture_ptr
->motion_val
[dir
][mv_pos
][1] & 3;
604 srcY
= dir
? s
->next_picture_ptr
->data
[0] : s
->last_picture_ptr
->data
[0];
605 srcU
= dir
? s
->next_picture_ptr
->data
[1] : s
->last_picture_ptr
->data
[1];
606 srcV
= dir
? s
->next_picture_ptr
->data
[2] : s
->last_picture_ptr
->data
[2];
607 src_x
= s
->mb_x
* 16 + xoff
+ mx
;
608 src_y
= s
->mb_y
* 16 + yoff
+ my
;
609 uvsrc_x
= s
->mb_x
* 8 + (xoff
>> 1) + (mx
>> 1);
610 uvsrc_y
= s
->mb_y
* 8 + (yoff
>> 1) + (my
>> 1);
611 srcY
+= src_y
* s
->linesize
+ src_x
;
612 srcU
+= uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
613 srcV
+= uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
614 if( (unsigned)(src_x
- !!lx
*2) > s
->h_edge_pos
- !!lx
*2 - (width
<<3) - 3
615 || (unsigned)(src_y
- !!ly
*2) > s
->v_edge_pos
- !!ly
*2 - (height
<<3) - 3){
616 uint8_t *uvbuf
= s
->edge_emu_buffer
+ 20 * s
->linesize
;
618 srcY
-= 2 + 2*s
->linesize
;
619 ff_emulated_edge_mc(s
->edge_emu_buffer
, srcY
, s
->linesize
, (width
<<3)+4, (height
<<3)+4,
620 src_x
- 2, src_y
- 2, s
->h_edge_pos
, s
->v_edge_pos
);
621 srcY
= s
->edge_emu_buffer
+ 2 + 2*s
->linesize
;
622 ff_emulated_edge_mc(uvbuf
, srcU
, s
->uvlinesize
, (width
<<2)+1, (height
<<2)+1,
623 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
624 ff_emulated_edge_mc(uvbuf
+ 16, srcV
, s
->uvlinesize
, (width
<<2)+1, (height
<<2)+1,
625 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
629 Y
= s
->dest
[0] + xoff
+ yoff
*s
->linesize
;
630 U
= s
->dest
[1] + (xoff
>>1) + (yoff
>>1)*s
->uvlinesize
;
631 V
= s
->dest
[2] + (xoff
>>1) + (yoff
>>1)*s
->uvlinesize
;
633 if(block_type
== RV34_MB_P_16x8
){
634 qpel_mc
[1][dxy
](Y
, srcY
, s
->linesize
);
637 }else if(block_type
== RV34_MB_P_8x16
){
638 qpel_mc
[1][dxy
](Y
, srcY
, s
->linesize
);
639 Y
+= 8 * s
->linesize
;
640 srcY
+= 8 * s
->linesize
;
642 is16x16
= (block_type
!= RV34_MB_P_8x8
) && (block_type
!= RV34_MB_P_16x8
) && (block_type
!= RV34_MB_P_8x16
);
643 qpel_mc
[!is16x16
][dxy
](Y
, srcY
, s
->linesize
);
644 chroma_mc
[2-width
] (U
, srcU
, s
->uvlinesize
, height
*4, uvmx
, uvmy
);
645 chroma_mc
[2-width
] (V
, srcV
, s
->uvlinesize
, height
*4, uvmx
, uvmy
);
648 static void rv34_mc_1mv(RV34DecContext
*r
, const int block_type
,
649 const int xoff
, const int yoff
, int mv_off
,
650 const int width
, const int height
, int dir
)
652 rv34_mc(r
, block_type
, xoff
, yoff
, mv_off
, width
, height
, dir
, r
->rv30
,
653 r
->rv30
? r
->s
.dsp
.put_rv30_tpel_pixels_tab
654 : r
->s
.dsp
.put_h264_qpel_pixels_tab
,
655 r
->s
.dsp
.put_h264_chroma_pixels_tab
);
658 static void rv34_mc_2mv(RV34DecContext
*r
, const int block_type
)
660 rv34_mc(r
, block_type
, 0, 0, 0, 2, 2, 0, r
->rv30
,
661 r
->rv30
? r
->s
.dsp
.put_rv30_tpel_pixels_tab
662 : r
->s
.dsp
.put_h264_qpel_pixels_tab
,
663 r
->s
.dsp
.put_h264_chroma_pixels_tab
);
664 rv34_mc(r
, block_type
, 0, 0, 0, 2, 2, 1, r
->rv30
,
665 r
->rv30
? r
->s
.dsp
.avg_rv30_tpel_pixels_tab
666 : r
->s
.dsp
.avg_h264_qpel_pixels_tab
,
667 r
->s
.dsp
.avg_h264_chroma_pixels_tab
);
670 /** number of motion vectors in each macroblock type */
671 static const int num_mvs
[RV34_MB_TYPES
] = { 0, 0, 1, 4, 1, 1, 0, 0, 2, 2, 2, 1 };
674 * Decode motion vector differences
675 * and perform motion vector reconstruction and motion compensation.
677 static int rv34_decode_mv(RV34DecContext
*r
, int block_type
)
679 MpegEncContext
*s
= &r
->s
;
680 GetBitContext
*gb
= &s
->gb
;
683 memset(r
->dmv
, 0, sizeof(r
->dmv
));
684 for(i
= 0; i
< num_mvs
[block_type
]; i
++){
685 r
->dmv
[i
][0] = svq3_get_se_golomb(gb
);
686 r
->dmv
[i
][1] = svq3_get_se_golomb(gb
);
689 case RV34_MB_TYPE_INTRA
:
690 case RV34_MB_TYPE_INTRA16x16
:
691 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);
694 if(s
->pict_type
== P_TYPE
){
695 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);
696 rv34_mc_1mv (r
, block_type
, 0, 0, 0, 2, 2, 0);
699 case RV34_MB_B_DIRECT
:
700 rv34_pred_mv_b (r
, RV34_MB_B_DIRECT
, 0);
701 rv34_pred_mv_b (r
, RV34_MB_B_DIRECT
, 1);
702 rv34_mc_2mv (r
, RV34_MB_B_DIRECT
);
704 case RV34_MB_P_16x16
:
705 case RV34_MB_P_MIX16x16
:
706 rv34_pred_mv(r
, block_type
, 0, 0);
707 rv34_mc_1mv (r
, block_type
, 0, 0, 0, 2, 2, 0);
709 case RV34_MB_B_FORWARD
:
710 case RV34_MB_B_BACKWARD
:
711 r
->dmv
[1][0] = r
->dmv
[0][0];
712 r
->dmv
[1][1] = r
->dmv
[0][1];
713 rv34_pred_mv_b (r
, block_type
, block_type
== RV34_MB_B_BACKWARD
);
714 rv34_mc_1mv (r
, block_type
, 0, 0, 0, 2, 2, block_type
== RV34_MB_B_BACKWARD
);
718 rv34_pred_mv(r
, block_type
, 0, 0);
719 rv34_pred_mv(r
, block_type
, 1 + (block_type
== RV34_MB_P_16x8
), 1);
720 if(block_type
== RV34_MB_P_16x8
){
721 rv34_mc_1mv(r
, block_type
, 0, 0, 0, 2, 1, 0);
722 rv34_mc_1mv(r
, block_type
, 0, 8, s
->b8_stride
, 2, 1, 0);
724 if(block_type
== RV34_MB_P_8x16
){
725 rv34_mc_1mv(r
, block_type
, 0, 0, 0, 1, 2, 0);
726 rv34_mc_1mv(r
, block_type
, 8, 0, 1, 1, 2, 0);
729 case RV34_MB_B_BIDIR
:
730 rv34_pred_mv_b (r
, block_type
, 0);
731 rv34_pred_mv_b (r
, block_type
, 1);
732 rv34_mc_2mv (r
, block_type
);
736 rv34_pred_mv(r
, block_type
, i
, i
);
737 rv34_mc_1mv (r
, block_type
, (i
&1)<<3, (i
&2)<<2, (i
&1)+(i
>>1)*s
->b8_stride
, 1, 1, 0);
744 /** @} */ // mv group
747 * @defgroup recons Macroblock reconstruction functions
750 /** mapping of RV30/40 intra prediction types to standard H.264 types */
751 static const int ittrans
[9] = {
752 DC_PRED
, VERT_PRED
, HOR_PRED
, DIAG_DOWN_RIGHT_PRED
, DIAG_DOWN_LEFT_PRED
,
753 VERT_RIGHT_PRED
, VERT_LEFT_PRED
, HOR_UP_PRED
, HOR_DOWN_PRED
,
756 /** mapping of RV30/40 intra 16x16 prediction types to standard H.264 types */
757 static const int ittrans16
[4] = {
758 DC_PRED8x8
, VERT_PRED8x8
, HOR_PRED8x8
, PLANE_PRED8x8
,
762 * Perform 4x4 intra prediction.
764 static void rv34_pred_4x4_block(RV34DecContext
*r
, uint8_t *dst
, int stride
, int itype
, int up
, int left
, int down
, int right
)
766 uint8_t *prev
= dst
- stride
+ 4;
772 if(itype
== VERT_PRED
) itype
= HOR_PRED
;
773 if(itype
== DC_PRED
) itype
= LEFT_DC_PRED
;
775 if(itype
== HOR_PRED
) itype
= VERT_PRED
;
776 if(itype
== DC_PRED
) itype
= TOP_DC_PRED
;
777 if(itype
== DIAG_DOWN_LEFT_PRED
) itype
= DIAG_DOWN_LEFT_PRED_RV40_NODOWN
;
780 if(itype
== DIAG_DOWN_LEFT_PRED
) itype
= DIAG_DOWN_LEFT_PRED_RV40_NODOWN
;
781 if(itype
== HOR_UP_PRED
) itype
= HOR_UP_PRED_RV40_NODOWN
;
782 if(itype
== VERT_LEFT_PRED
) itype
= VERT_LEFT_PRED_RV40_NODOWN
;
785 topleft
= dst
[-stride
+ 3] * 0x01010101;
788 r
->h
.pred4x4
[itype
](dst
, prev
, stride
);
791 /** add_pixels_clamped for 4x4 block */
792 static void rv34_add_4x4_block(uint8_t *dst
, int stride
, DCTELEM block
[64], int off
)
795 for(y
= 0; y
< 4; y
++)
796 for(x
= 0; x
< 4; x
++)
797 dst
[x
+ y
*stride
] = av_clip_uint8(dst
[x
+ y
*stride
] + block
[off
+ x
+y
*8]);
800 static inline int adjust_pred16(int itype
, int up
, int left
)
803 itype
= DC_128_PRED8x8
;
805 if(itype
== PLANE_PRED8x8
)itype
= HOR_PRED8x8
;
806 if(itype
== VERT_PRED8x8
) itype
= HOR_PRED8x8
;
807 if(itype
== DC_PRED8x8
) itype
= LEFT_DC_PRED8x8
;
809 if(itype
== PLANE_PRED8x8
)itype
= VERT_PRED8x8
;
810 if(itype
== HOR_PRED8x8
) itype
= VERT_PRED8x8
;
811 if(itype
== DC_PRED8x8
) itype
= TOP_DC_PRED8x8
;
816 static void rv34_output_macroblock(RV34DecContext
*r
, int8_t *intra_types
, int cbp
, int is16
)
818 MpegEncContext
*s
= &r
->s
;
819 DSPContext
*dsp
= &s
->dsp
;
823 int avail
[6*8] = {0};
826 // Set neighbour information.
827 if(r
->avail_cache
[0])
829 if(r
->avail_cache
[1])
830 avail
[1] = avail
[2] = 1;
831 if(r
->avail_cache
[2])
832 avail
[3] = avail
[4] = 1;
833 if(r
->avail_cache
[3])
835 if(r
->avail_cache
[4])
836 avail
[8] = avail
[16] = 1;
837 if(r
->avail_cache
[8])
838 avail
[24] = avail
[32] = 1;
844 for(j
= 0; j
< 4; j
++){
846 for(i
= 0; i
< 4; i
++, cbp
>>= 1, Y
+= 4, idx
++){
847 rv34_pred_4x4_block(r
, Y
, s
->linesize
, ittrans
[intra_types
[i
]], avail
[idx
-8], avail
[idx
-1], avail
[idx
+7], avail
[idx
-7]);
850 rv34_add_4x4_block(Y
, s
->linesize
, s
->block
[(i
>>1)+(j
&2)], (i
&1)*4+(j
&1)*32);
852 Y
+= s
->linesize
* 4 - 4*4;
853 intra_types
+= s
->b4_stride
;
855 intra_types
-= s
->b4_stride
* 4;
856 fill_rectangle(r
->avail_cache
+ 5, 2, 2, 4, 0, 4);
857 for(j
= 0; j
< 2; j
++){
859 for(i
= 0; i
< 2; i
++, cbp
>>= 1, idx
++){
860 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]);
861 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]);
862 r
->avail_cache
[idx
] = 1;
864 rv34_add_4x4_block(U
+ i
*4 + j
*4*s
->uvlinesize
, s
->uvlinesize
, s
->block
[4], i
*4+j
*32);
866 rv34_add_4x4_block(V
+ i
*4 + j
*4*s
->uvlinesize
, s
->uvlinesize
, s
->block
[5], i
*4+j
*32);
870 itype
= ittrans16
[intra_types
[0]];
871 itype
= adjust_pred16(itype
, r
->avail_cache
[5-4], r
->avail_cache
[5-1]);
872 r
->h
.pred16x16
[itype
](Y
, s
->linesize
);
873 dsp
->add_pixels_clamped(s
->block
[0], Y
, s
->current_picture
.linesize
[0]);
874 dsp
->add_pixels_clamped(s
->block
[1], Y
+ 8, s
->current_picture
.linesize
[0]);
875 Y
+= s
->current_picture
.linesize
[0] * 8;
876 dsp
->add_pixels_clamped(s
->block
[2], Y
, s
->current_picture
.linesize
[0]);
877 dsp
->add_pixels_clamped(s
->block
[3], Y
+ 8, s
->current_picture
.linesize
[0]);
879 itype
= ittrans16
[intra_types
[0]];
880 if(itype
== PLANE_PRED8x8
) itype
= DC_PRED8x8
;
881 itype
= adjust_pred16(itype
, r
->avail_cache
[5-4], r
->avail_cache
[5-1]);
882 r
->h
.pred8x8
[itype
](U
, s
->uvlinesize
);
883 dsp
->add_pixels_clamped(s
->block
[4], U
, s
->uvlinesize
);
884 r
->h
.pred8x8
[itype
](V
, s
->uvlinesize
);
885 dsp
->add_pixels_clamped(s
->block
[5], V
, s
->uvlinesize
);
889 /** @} */ // recons group
892 * @addtogroup bitstream
893 * Decode macroblock header and return CBP in case of success, -1 otherwise.
895 static int rv34_decode_mb_header(RV34DecContext
*r
, int8_t *intra_types
)
897 MpegEncContext
*s
= &r
->s
;
898 GetBitContext
*gb
= &s
->gb
;
899 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
903 r
->is16
= get_bits1(gb
);
904 if(!r
->is16
&& !r
->rv30
){
906 av_log(s
->avctx
, AV_LOG_ERROR
, "Need DQUANT\n");
908 s
->current_picture_ptr
->mb_type
[mb_pos
] = r
->is16
? MB_TYPE_INTRA16x16
: MB_TYPE_INTRA
;
909 r
->block_type
= r
->is16
? RV34_MB_TYPE_INTRA16x16
: RV34_MB_TYPE_INTRA
;
911 r
->block_type
= r
->decode_mb_info(r
);
912 if(r
->block_type
== -1)
914 s
->current_picture_ptr
->mb_type
[mb_pos
] = rv34_mb_type_to_lavc
[r
->block_type
];
915 r
->mb_type
[mb_pos
] = r
->block_type
;
916 if(r
->block_type
== RV34_MB_SKIP
){
917 if(s
->pict_type
== P_TYPE
)
918 r
->mb_type
[mb_pos
] = RV34_MB_P_16x16
;
919 if(s
->pict_type
== B_TYPE
)
920 r
->mb_type
[mb_pos
] = RV34_MB_B_DIRECT
;
922 r
->is16
= !!IS_INTRA16x16(s
->current_picture_ptr
->mb_type
[mb_pos
]);
923 rv34_decode_mv(r
, r
->block_type
);
924 if(r
->block_type
== RV34_MB_SKIP
){
925 fill_rectangle(intra_types
, 4, 4, s
->b4_stride
, 0, sizeof(intra_types
[0]));
931 if(IS_INTRA(s
->current_picture_ptr
->mb_type
[mb_pos
])){
934 fill_rectangle(intra_types
, 4, 4, s
->b4_stride
, t
, sizeof(intra_types
[0]));
937 if(r
->decode_intra_types(r
, gb
, intra_types
) < 0)
942 r
->cur_vlcs
= choose_vlc_set(r
->si
.quant
, r
->si
.vlc_set
, 0);
944 for(i
= 0; i
< 16; i
++)
945 intra_types
[(i
& 3) + (i
>>2) * s
->b4_stride
] = 0;
946 r
->cur_vlcs
= choose_vlc_set(r
->si
.quant
, r
->si
.vlc_set
, 1);
947 if(r
->mb_type
[mb_pos
] == RV34_MB_P_MIX16x16
){
951 r
->cur_vlcs
= choose_vlc_set(r
->si
.quant
, r
->si
.vlc_set
, 0);
955 return rv34_decode_cbp(gb
, r
->cur_vlcs
, r
->is16
);
963 * mask for retrieving all bits in coded block pattern
964 * corresponding to one 8x8 block
966 #define LUMA_CBP_BLOCK_MASK 0x303
968 #define U_CBP_MASK 0x0F0000
969 #define V_CBP_MASK 0xF00000
972 static void rv34_apply_differences(RV34DecContext
*r
, int cbp
)
974 static const int shifts
[4] = { 0, 2, 8, 10 };
975 MpegEncContext
*s
= &r
->s
;
978 for(i
= 0; i
< 4; i
++)
979 if(cbp
& (LUMA_CBP_BLOCK_MASK
<< shifts
[i
]))
980 s
->dsp
.add_pixels_clamped(s
->block
[i
], s
->dest
[0] + (i
& 1)*8 + (i
&2)*4*s
->linesize
, s
->linesize
);
982 s
->dsp
.add_pixels_clamped(s
->block
[4], s
->dest
[1], s
->uvlinesize
);
984 s
->dsp
.add_pixels_clamped(s
->block
[5], s
->dest
[2], s
->uvlinesize
);
987 static int rv34_decode_macroblock(RV34DecContext
*r
, int8_t *intra_types
)
989 MpegEncContext
*s
= &r
->s
;
990 GetBitContext
*gb
= &s
->gb
;
992 int i
, blknum
, blkoff
;
996 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
998 // Calculate which neighbours are available. Maybe it's worth optimizing too.
999 memset(r
->avail_cache
, 0, sizeof(r
->avail_cache
));
1000 fill_rectangle(r
->avail_cache
+ 5, 2, 2, 4, 1, 4);
1001 dist
= (s
->mb_x
- s
->resync_mb_x
) + (s
->mb_y
- s
->resync_mb_y
) * s
->mb_width
;
1004 r
->avail_cache
[8] = s
->current_picture_ptr
->mb_type
[mb_pos
- 1];
1005 if(dist
>= s
->mb_width
)
1007 r
->avail_cache
[2] = s
->current_picture_ptr
->mb_type
[mb_pos
- s
->mb_stride
];
1008 if(((s
->mb_x
+1) < s
->mb_width
) && dist
>= s
->mb_width
- 1)
1009 r
->avail_cache
[3] = s
->current_picture_ptr
->mb_type
[mb_pos
- s
->mb_stride
+ 1];
1010 if(s
->mb_x
&& dist
> s
->mb_width
)
1011 r
->avail_cache
[0] = s
->current_picture_ptr
->mb_type
[mb_pos
- s
->mb_stride
- 1];
1013 s
->qscale
= r
->si
.quant
;
1014 cbp
= cbp2
= rv34_decode_mb_header(r
, intra_types
);
1015 r
->cbp_luma
[s
->mb_x
+ s
->mb_y
* s
->mb_stride
] = cbp
;
1016 r
->cbp_chroma
[s
->mb_x
+ s
->mb_y
* s
->mb_stride
] = cbp
>> 16;
1017 s
->current_picture
.qscale_table
[s
->mb_x
+ s
->mb_y
* s
->mb_stride
] = s
->qscale
;
1022 luma_dc_quant
= r
->si
.type
? r
->luma_dc_quant_p
[s
->qscale
] : r
->luma_dc_quant_i
[s
->qscale
];
1024 memset(block16
, 0, sizeof(block16
));
1025 rv34_decode_block(block16
, gb
, r
->cur_vlcs
, 3, 0);
1026 rv34_dequant4x4_16x16(block16
, rv34_qscale_tab
[luma_dc_quant
],rv34_qscale_tab
[s
->qscale
]);
1027 rv34_inv_transform_noround(block16
);
1030 for(i
= 0; i
< 16; i
++, cbp
>>= 1){
1031 if(!r
->is16
&& !(cbp
& 1)) continue;
1032 blknum
= ((i
& 2) >> 1) + ((i
& 8) >> 2);
1033 blkoff
= ((i
& 1) << 2) + ((i
& 4) << 3);
1035 rv34_decode_block(s
->block
[blknum
] + blkoff
, gb
, r
->cur_vlcs
, r
->luma_vlc
, 0);
1036 rv34_dequant4x4(s
->block
[blknum
] + blkoff
, rv34_qscale_tab
[luma_dc_quant
],rv34_qscale_tab
[s
->qscale
]);
1037 if(r
->is16
) //FIXME: optimize
1038 s
->block
[blknum
][blkoff
] = block16
[(i
& 3) | ((i
& 0xC) << 1)];
1039 rv34_inv_transform(s
->block
[blknum
] + blkoff
);
1041 if(r
->block_type
== RV34_MB_P_MIX16x16
)
1042 r
->cur_vlcs
= choose_vlc_set(r
->si
.quant
, r
->si
.vlc_set
, 1);
1043 for(; i
< 24; i
++, cbp
>>= 1){
1044 if(!(cbp
& 1)) continue;
1045 blknum
= ((i
& 4) >> 2) + 4;
1046 blkoff
= ((i
& 1) << 2) + ((i
& 2) << 4);
1047 rv34_decode_block(s
->block
[blknum
] + blkoff
, gb
, r
->cur_vlcs
, r
->chroma_vlc
, 1);
1048 rv34_dequant4x4(s
->block
[blknum
] + blkoff
, rv34_qscale_tab
[rv34_chroma_quant
[1][s
->qscale
]],rv34_qscale_tab
[rv34_chroma_quant
[0][s
->qscale
]]);
1049 rv34_inv_transform(s
->block
[blknum
] + blkoff
);
1051 if(IS_INTRA(s
->current_picture_ptr
->mb_type
[s
->mb_x
+ s
->mb_y
*s
->mb_stride
]))
1052 rv34_output_macroblock(r
, intra_types
, cbp2
, r
->is16
);
1054 rv34_apply_differences(r
, cbp2
);
1059 static int check_slice_end(RV34DecContext
*r
, MpegEncContext
*s
)
1062 if(s
->mb_y
>= s
->mb_height
)
1066 if(r
->s
.mb_skip_run
> 1)
1068 bits
= r
->bits
- get_bits_count(&s
->gb
);
1069 if(bits
< 0 || (bits
< 8 && !show_bits(&s
->gb
, bits
)))
1074 static inline int slice_compare(SliceInfo
*si1
, SliceInfo
*si2
)
1076 return si1
->type
!= si2
->type
||
1077 si1
->start
>= si2
->start
||
1078 si1
->width
!= si2
->width
||
1079 si1
->height
!= si2
->height
;
1082 static int rv34_decode_slice(RV34DecContext
*r
, int end
, uint8_t* buf
, int buf_size
)
1084 MpegEncContext
*s
= &r
->s
;
1085 GetBitContext
*gb
= &s
->gb
;
1089 init_get_bits(&r
->s
.gb
, buf
, buf_size
*8);
1090 res
= r
->parse_slice_header(r
, gb
, &r
->si
);
1092 av_log(s
->avctx
, AV_LOG_ERROR
, "Incorrect or unknown slice header\n");
1096 if ((s
->mb_x
== 0 && s
->mb_y
== 0) || s
->current_picture_ptr
==NULL
) {
1097 if(s
->width
!= r
->si
.width
|| s
->height
!= r
->si
.height
){
1098 av_log(s
->avctx
, AV_LOG_DEBUG
, "Changing dimensions to %dx%d\n", r
->si
.width
,r
->si
.height
);
1100 s
->width
= r
->si
.width
;
1101 s
->height
= r
->si
.height
;
1102 if(MPV_common_init(s
) < 0)
1104 r
->intra_types_hist
= av_realloc(r
->intra_types_hist
, s
->b4_stride
* 4 * 2 * sizeof(*r
->intra_types_hist
));
1105 r
->intra_types
= r
->intra_types_hist
+ s
->b4_stride
* 4;
1106 r
->mb_type
= av_realloc(r
->mb_type
, r
->s
.mb_stride
* r
->s
.mb_height
* sizeof(*r
->mb_type
));
1107 r
->cbp_luma
= av_realloc(r
->cbp_luma
, r
->s
.mb_stride
* r
->s
.mb_height
* sizeof(*r
->cbp_luma
));
1108 r
->cbp_chroma
= av_realloc(r
->cbp_chroma
, r
->s
.mb_stride
* r
->s
.mb_height
* sizeof(*r
->cbp_chroma
));
1110 s
->pict_type
= r
->si
.type
? r
->si
.type
: I_TYPE
;
1111 if(MPV_frame_start(s
, s
->avctx
) < 0)
1113 ff_er_frame_start(s
);
1114 s
->current_picture_ptr
= &s
->current_picture
;
1115 s
->mb_x
= s
->mb_y
= 0;
1119 s
->qscale
= r
->si
.quant
;
1120 r
->bits
= buf_size
*8;
1121 s
->mb_num_left
= r
->si
.end
- r
->si
.start
;
1122 r
->s
.mb_skip_run
= 0;
1124 mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_width
;
1125 if(r
->si
.start
!= mb_pos
){
1126 av_log(s
->avctx
, AV_LOG_ERROR
, "Slice indicates MB offset %d, got %d\n", r
->si
.start
, mb_pos
);
1127 s
->mb_x
= r
->si
.start
% s
->mb_width
;
1128 s
->mb_y
= r
->si
.start
/ s
->mb_width
;
1130 memset(r
->intra_types_hist
, -1, s
->b4_stride
* 4 * 2 * sizeof(*r
->intra_types_hist
));
1131 s
->first_slice_line
= 1;
1132 s
->resync_mb_x
= s
->mb_x
;
1133 s
->resync_mb_y
= s
->mb_y
;
1135 ff_init_block_index(s
);
1136 while(!check_slice_end(r
, s
)) {
1137 ff_update_block_index(s
);
1138 s
->dsp
.clear_blocks(s
->block
[0]);
1140 if(rv34_decode_macroblock(r
, r
->intra_types
+ s
->mb_x
* 4 + 1) < 0){
1141 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
);
1144 if (++s
->mb_x
== s
->mb_width
) {
1147 ff_init_block_index(s
);
1149 memmove(r
->intra_types_hist
, r
->intra_types
, s
->b4_stride
* 4 * sizeof(*r
->intra_types_hist
));
1150 memset(r
->intra_types
, -1, s
->b4_stride
* 4 * sizeof(*r
->intra_types_hist
));
1152 if(s
->mb_x
== s
->resync_mb_x
)
1153 s
->first_slice_line
=0;
1156 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
);
1158 return (s
->mb_y
== s
->mb_height
);
1161 /** @} */ // recons group end
1164 * Initialize decoder.
1166 int ff_rv34_decode_init(AVCodecContext
*avctx
)
1168 RV34DecContext
*r
= avctx
->priv_data
;
1169 MpegEncContext
*s
= &r
->s
;
1171 MPV_decode_defaults(s
);
1173 s
->out_format
= FMT_H263
;
1174 s
->codec_id
= avctx
->codec_id
;
1176 s
->width
= avctx
->width
;
1177 s
->height
= avctx
->height
;
1180 avctx
->flags
|= CODEC_FLAG_EMU_EDGE
;
1181 r
->s
.flags
|= CODEC_FLAG_EMU_EDGE
;
1182 avctx
->pix_fmt
= PIX_FMT_YUV420P
;
1183 avctx
->has_b_frames
= 1;
1186 if (MPV_common_init(s
) < 0)
1189 ff_h264_pred_init(&r
->h
, CODEC_ID_RV40
);
1191 r
->intra_types_hist
= av_malloc(s
->b4_stride
* 4 * 2 * sizeof(*r
->intra_types_hist
));
1192 r
->intra_types
= r
->intra_types_hist
+ s
->b4_stride
* 4;
1194 r
->mb_type
= av_mallocz(r
->s
.mb_stride
* r
->s
.mb_height
* sizeof(*r
->mb_type
));
1196 r
->cbp_luma
= av_malloc(r
->s
.mb_stride
* r
->s
.mb_height
* sizeof(*r
->cbp_luma
));
1197 r
->cbp_chroma
= av_malloc(r
->s
.mb_stride
* r
->s
.mb_height
* sizeof(*r
->cbp_chroma
));
1199 if(!intra_vlcs
[0].cbppattern
[0].bits
)
1205 static int get_slice_offset(AVCodecContext
*avctx
, uint8_t *buf
, int n
)
1207 if(avctx
->slice_count
) return avctx
->slice_offset
[n
];
1208 else return AV_RL32(buf
+ n
*8 - 4) == 1 ? AV_RL32(buf
+ n
*8) : AV_RB32(buf
+ n
*8);
1211 int ff_rv34_decode_frame(AVCodecContext
*avctx
,
1212 void *data
, int *data_size
,
1213 uint8_t *buf
, int buf_size
)
1215 RV34DecContext
*r
= avctx
->priv_data
;
1216 MpegEncContext
*s
= &r
->s
;
1217 AVFrame
*pict
= data
;
1221 uint8_t *slices_hdr
= NULL
;
1224 /* no supplementary picture */
1225 if (buf_size
== 0) {
1226 /* special case for last picture */
1227 if (s
->low_delay
==0 && s
->next_picture_ptr
) {
1228 *pict
= *(AVFrame
*)s
->next_picture_ptr
;
1229 s
->next_picture_ptr
= NULL
;
1231 *data_size
= sizeof(AVFrame
);
1236 if(!avctx
->slice_count
){
1237 slice_count
= (*buf
++) + 1;
1238 slices_hdr
= buf
+ 4;
1239 buf
+= 8 * slice_count
;
1241 slice_count
= avctx
->slice_count
;
1243 for(i
=0; i
<slice_count
; i
++){
1244 int offset
= get_slice_offset(avctx
, slices_hdr
, i
);
1246 if(i
+1 == slice_count
)
1247 size
= buf_size
- offset
;
1249 size
= get_slice_offset(avctx
, slices_hdr
, i
+1) - offset
;
1251 r
->si
.end
= s
->mb_width
* s
->mb_height
;
1252 if(i
+1 < slice_count
){
1253 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);
1254 if(r
->parse_slice_header(r
, &r
->s
.gb
, &si
) < 0){
1255 if(i
+2 < slice_count
)
1256 size
= get_slice_offset(avctx
, slices_hdr
, i
+2) - offset
;
1258 size
= buf_size
- offset
;
1260 r
->si
.end
= si
.start
;
1262 last
= rv34_decode_slice(r
, r
->si
.end
, buf
+ offset
, size
);
1263 s
->mb_num_left
= r
->s
.mb_x
+ r
->s
.mb_y
*r
->s
.mb_width
- r
->si
.start
;
1273 if (s
->pict_type
== B_TYPE
|| s
->low_delay
) {
1274 *pict
= *(AVFrame
*)s
->current_picture_ptr
;
1275 } else if (s
->last_picture_ptr
!= NULL
) {
1276 *pict
= *(AVFrame
*)s
->last_picture_ptr
;
1279 if(s
->last_picture_ptr
|| s
->low_delay
){
1280 *data_size
= sizeof(AVFrame
);
1281 ff_print_debug_info(s
, pict
);
1283 s
->current_picture_ptr
= NULL
; //so we can detect if frame_end wasnt called (find some nicer solution...)
1288 int ff_rv34_decode_end(AVCodecContext
*avctx
)
1290 RV34DecContext
*r
= avctx
->priv_data
;
1292 MPV_common_end(&r
->s
);
1294 av_freep(&r
->intra_types_hist
);
1295 r
->intra_types
= NULL
;
1296 av_freep(&r
->mb_type
);