2 * RV30/40 decoder common data
3 * Copyright (c) 2007 Mike Melanson, Konstantin Shishkov
5 * This file is part of Libav.
7 * Libav 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 * Libav 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 Libav; 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
27 #include "libavutil/internal.h"
31 #include "mpegvideo.h"
35 #include "rectangle.h"
44 static inline void ZERO8x2(void* dst
, int stride
)
46 fill_rectangle(dst
, 1, 2, stride
, 0, 4);
47 fill_rectangle(((uint8_t*)(dst
))+4, 1, 2, stride
, 0, 4);
50 /** translation of RV30/40 macroblock types to lavc ones */
51 static const int rv34_mb_type_to_lavc
[12] = {
53 MB_TYPE_INTRA16x16
| MB_TYPE_SEPARATE_DC
,
54 MB_TYPE_16x16
| MB_TYPE_L0
,
55 MB_TYPE_8x8
| MB_TYPE_L0
,
56 MB_TYPE_16x16
| MB_TYPE_L0
,
57 MB_TYPE_16x16
| MB_TYPE_L1
,
59 MB_TYPE_DIRECT2
| MB_TYPE_16x16
,
60 MB_TYPE_16x8
| MB_TYPE_L0
,
61 MB_TYPE_8x16
| MB_TYPE_L0
,
62 MB_TYPE_16x16
| MB_TYPE_L0L1
,
63 MB_TYPE_16x16
| MB_TYPE_L0
| MB_TYPE_SEPARATE_DC
67 static RV34VLC intra_vlcs
[NUM_INTRA_TABLES
], inter_vlcs
[NUM_INTER_TABLES
];
69 static int rv34_decode_mv(RV34DecContext
*r
, int block_type
);
72 * @name RV30/40 VLC generating functions
76 static const int table_offs
[] = {
77 0, 1818, 3622, 4144, 4698, 5234, 5804, 5868, 5900, 5932,
78 5996, 6252, 6316, 6348, 6380, 7674, 8944, 10274, 11668, 12250,
79 14060, 15846, 16372, 16962, 17512, 18148, 18180, 18212, 18244, 18308,
80 18564, 18628, 18660, 18692, 20036, 21314, 22648, 23968, 24614, 26384,
81 28190, 28736, 29366, 29938, 30608, 30640, 30672, 30704, 30768, 31024,
82 31088, 31120, 31184, 32570, 33898, 35236, 36644, 37286, 39020, 40802,
83 41368, 42052, 42692, 43348, 43380, 43412, 43444, 43476, 43604, 43668,
84 43700, 43732, 45100, 46430, 47778, 49160, 49802, 51550, 53340, 53972,
85 54648, 55348, 55994, 56122, 56154, 56186, 56218, 56346, 56410, 56442,
86 56474, 57878, 59290, 60636, 62036, 62682, 64460, 64524, 64588, 64716,
87 64844, 66076, 67466, 67978, 68542, 69064, 69648, 70296, 72010, 72074,
88 72138, 72202, 72330, 73572, 74936, 75454, 76030, 76566, 77176, 77822,
89 79582, 79646, 79678, 79742, 79870, 81180, 82536, 83064, 83672, 84242,
90 84934, 85576, 87384, 87448, 87480, 87544, 87672, 88982, 90340, 90902,
91 91598, 92182, 92846, 93488, 95246, 95278, 95310, 95374, 95502, 96878,
92 98266, 98848, 99542, 100234, 100884, 101524, 103320, 103352, 103384, 103416,
93 103480, 104874, 106222, 106910, 107584, 108258, 108902, 109544, 111366, 111398,
94 111430, 111462, 111494, 112878, 114320, 114988, 115660, 116310, 116950, 117592
97 static VLC_TYPE table_data
[117592][2];
100 * Generate VLC from codeword lengths.
101 * @param bits codeword lengths (zeroes are accepted)
102 * @param size length of input data
103 * @param vlc output VLC
104 * @param insyms symbols for input codes (NULL for default ones)
105 * @param num VLC table number (for static initialization)
107 static void rv34_gen_vlc(const uint8_t *bits
, int size
, VLC
*vlc
, const uint8_t *insyms
,
111 int counts
[17] = {0}, codes
[17];
112 uint16_t cw
[MAX_VLC_SIZE
], syms
[MAX_VLC_SIZE
];
113 uint8_t bits2
[MAX_VLC_SIZE
];
114 int maxbits
= 0, realsize
= 0;
116 for(i
= 0; i
< size
; i
++){
118 bits2
[realsize
] = bits
[i
];
119 syms
[realsize
] = insyms
? insyms
[i
] : i
;
121 maxbits
= FFMAX(maxbits
, bits
[i
]);
127 for(i
= 0; i
< 16; i
++)
128 codes
[i
+1] = (codes
[i
] + counts
[i
]) << 1;
129 for(i
= 0; i
< realsize
; i
++)
130 cw
[i
] = codes
[bits2
[i
]]++;
132 vlc
->table
= &table_data
[table_offs
[num
]];
133 vlc
->table_allocated
= table_offs
[num
+ 1] - table_offs
[num
];
134 ff_init_vlc_sparse(vlc
, FFMIN(maxbits
, 9), realsize
,
137 syms
, 2, 2, INIT_VLC_USE_NEW_STATIC
);
141 * Initialize all tables.
143 static av_cold
void rv34_init_tables(void)
147 for(i
= 0; i
< NUM_INTRA_TABLES
; i
++){
148 for(j
= 0; j
< 2; j
++){
149 rv34_gen_vlc(rv34_table_intra_cbppat
[i
][j
], CBPPAT_VLC_SIZE
, &intra_vlcs
[i
].cbppattern
[j
], NULL
, 19*i
+ 0 + j
);
150 rv34_gen_vlc(rv34_table_intra_secondpat
[i
][j
], OTHERBLK_VLC_SIZE
, &intra_vlcs
[i
].second_pattern
[j
], NULL
, 19*i
+ 2 + j
);
151 rv34_gen_vlc(rv34_table_intra_thirdpat
[i
][j
], OTHERBLK_VLC_SIZE
, &intra_vlcs
[i
].third_pattern
[j
], NULL
, 19*i
+ 4 + j
);
152 for(k
= 0; k
< 4; k
++){
153 rv34_gen_vlc(rv34_table_intra_cbp
[i
][j
+k
*2], CBP_VLC_SIZE
, &intra_vlcs
[i
].cbp
[j
][k
], rv34_cbp_code
, 19*i
+ 6 + j
*4 + k
);
156 for(j
= 0; j
< 4; j
++){
157 rv34_gen_vlc(rv34_table_intra_firstpat
[i
][j
], FIRSTBLK_VLC_SIZE
, &intra_vlcs
[i
].first_pattern
[j
], NULL
, 19*i
+ 14 + j
);
159 rv34_gen_vlc(rv34_intra_coeff
[i
], COEFF_VLC_SIZE
, &intra_vlcs
[i
].coefficient
, NULL
, 19*i
+ 18);
162 for(i
= 0; i
< NUM_INTER_TABLES
; i
++){
163 rv34_gen_vlc(rv34_inter_cbppat
[i
], CBPPAT_VLC_SIZE
, &inter_vlcs
[i
].cbppattern
[0], NULL
, i
*12 + 95);
164 for(j
= 0; j
< 4; j
++){
165 rv34_gen_vlc(rv34_inter_cbp
[i
][j
], CBP_VLC_SIZE
, &inter_vlcs
[i
].cbp
[0][j
], rv34_cbp_code
, i
*12 + 96 + j
);
167 for(j
= 0; j
< 2; j
++){
168 rv34_gen_vlc(rv34_table_inter_firstpat
[i
][j
], FIRSTBLK_VLC_SIZE
, &inter_vlcs
[i
].first_pattern
[j
], NULL
, i
*12 + 100 + j
);
169 rv34_gen_vlc(rv34_table_inter_secondpat
[i
][j
], OTHERBLK_VLC_SIZE
, &inter_vlcs
[i
].second_pattern
[j
], NULL
, i
*12 + 102 + j
);
170 rv34_gen_vlc(rv34_table_inter_thirdpat
[i
][j
], OTHERBLK_VLC_SIZE
, &inter_vlcs
[i
].third_pattern
[j
], NULL
, i
*12 + 104 + j
);
172 rv34_gen_vlc(rv34_inter_coeff
[i
], COEFF_VLC_SIZE
, &inter_vlcs
[i
].coefficient
, NULL
, i
*12 + 106);
176 /** @} */ // vlc group
179 * @name RV30/40 4x4 block decoding functions
184 * Decode coded block pattern.
186 static int rv34_decode_cbp(GetBitContext
*gb
, RV34VLC
*vlc
, int table
)
188 int pattern
, code
, cbp
=0;
190 static const int cbp_masks
[3] = {0x100000, 0x010000, 0x110000};
191 static const int shifts
[4] = { 0, 2, 8, 10 };
192 const int *curshift
= shifts
;
195 code
= get_vlc2(gb
, vlc
->cbppattern
[table
].table
, 9, 2);
196 pattern
= code
& 0xF;
199 ones
= rv34_count_ones
[pattern
];
201 for(mask
= 8; mask
; mask
>>= 1, curshift
++){
203 cbp
|= get_vlc2(gb
, vlc
->cbp
[table
][ones
].table
, vlc
->cbp
[table
][ones
].bits
, 1) << curshift
[0];
206 for(i
= 0; i
< 4; i
++){
207 t
= (modulo_three_table
[code
] >> (6 - 2*i
)) & 3;
209 cbp
|= cbp_masks
[get_bits1(gb
)] << i
;
211 cbp
|= cbp_masks
[2] << i
;
217 * Get one coefficient value from the bistream and store it.
219 static inline void decode_coeff(DCTELEM
*dst
, int coef
, int esc
, GetBitContext
*gb
, VLC
* vlc
, int q
)
223 coef
= get_vlc2(gb
, vlc
->table
, 9, 2);
226 coef
= 22 + ((1 << coef
) | get_bits(gb
, coef
));
232 *dst
= (coef
*q
+ 8) >> 4;
237 * Decode 2x2 subblock of coefficients.
239 static inline void decode_subblock(DCTELEM
*dst
, int code
, const int is_block2
, GetBitContext
*gb
, VLC
*vlc
, int q
)
241 int flags
= modulo_three_table
[code
];
243 decode_coeff( dst
+0*4+0, (flags
>> 6) , 3, gb
, vlc
, q
);
245 decode_coeff(dst
+1*4+0, (flags
>> 4) & 3, 2, gb
, vlc
, q
);
246 decode_coeff(dst
+0*4+1, (flags
>> 2) & 3, 2, gb
, vlc
, q
);
248 decode_coeff(dst
+0*4+1, (flags
>> 4) & 3, 2, gb
, vlc
, q
);
249 decode_coeff(dst
+1*4+0, (flags
>> 2) & 3, 2, gb
, vlc
, q
);
251 decode_coeff( dst
+1*4+1, (flags
>> 0) & 3, 2, gb
, vlc
, q
);
255 * Decode a single coefficient.
257 static inline void decode_subblock1(DCTELEM
*dst
, int code
, GetBitContext
*gb
, VLC
*vlc
, int q
)
259 int coeff
= modulo_three_table
[code
] >> 6;
260 decode_coeff(dst
, coeff
, 3, gb
, vlc
, q
);
263 static inline void decode_subblock3(DCTELEM
*dst
, int code
, GetBitContext
*gb
, VLC
*vlc
,
264 int q_dc
, int q_ac1
, int q_ac2
)
266 int flags
= modulo_three_table
[code
];
268 decode_coeff(dst
+0*4+0, (flags
>> 6) , 3, gb
, vlc
, q_dc
);
269 decode_coeff(dst
+0*4+1, (flags
>> 4) & 3, 2, gb
, vlc
, q_ac1
);
270 decode_coeff(dst
+1*4+0, (flags
>> 2) & 3, 2, gb
, vlc
, q_ac1
);
271 decode_coeff(dst
+1*4+1, (flags
>> 0) & 3, 2, gb
, vlc
, q_ac2
);
275 * Decode coefficients for 4x4 block.
277 * This is done by filling 2x2 subblocks with decoded coefficients
278 * in this order (the same for subblocks and subblock coefficients):
285 static int rv34_decode_block(DCTELEM
*dst
, GetBitContext
*gb
, RV34VLC
*rvlc
, int fc
, int sc
, int q_dc
, int q_ac1
, int q_ac2
)
287 int code
, pattern
, has_ac
= 1;
289 code
= get_vlc2(gb
, rvlc
->first_pattern
[fc
].table
, 9, 2);
291 pattern
= code
& 0x7;
295 if (modulo_three_table
[code
] & 0x3F) {
296 decode_subblock3(dst
, code
, gb
, &rvlc
->coefficient
, q_dc
, q_ac1
, q_ac2
);
298 decode_subblock1(dst
, code
, gb
, &rvlc
->coefficient
, q_dc
);
305 code
= get_vlc2(gb
, rvlc
->second_pattern
[sc
].table
, 9, 2);
306 decode_subblock(dst
+ 4*0+2, code
, 0, gb
, &rvlc
->coefficient
, q_ac2
);
308 if(pattern
& 2){ // Looks like coefficients 1 and 2 are swapped for this block
309 code
= get_vlc2(gb
, rvlc
->second_pattern
[sc
].table
, 9, 2);
310 decode_subblock(dst
+ 4*2+0, code
, 1, gb
, &rvlc
->coefficient
, q_ac2
);
313 code
= get_vlc2(gb
, rvlc
->third_pattern
[sc
].table
, 9, 2);
314 decode_subblock(dst
+ 4*2+2, code
, 0, gb
, &rvlc
->coefficient
, q_ac2
);
316 return has_ac
| pattern
;
320 * @name RV30/40 bitstream parsing
325 * Decode starting slice position.
326 * @todo Maybe replace with ff_h263_decode_mba() ?
328 int ff_rv34_get_start_offset(GetBitContext
*gb
, int mb_size
)
331 for(i
= 0; i
< 5; i
++)
332 if(rv34_mb_max_sizes
[i
] >= mb_size
- 1)
334 return rv34_mb_bits_sizes
[i
];
338 * Select VLC set for decoding from current quantizer, modifier and frame type.
340 static inline RV34VLC
* choose_vlc_set(int quant
, int mod
, int type
)
342 if(mod
== 2 && quant
< 19) quant
+= 10;
343 else if(mod
&& quant
< 26) quant
+= 5;
344 return type
? &inter_vlcs
[rv34_quant_to_vlc_set
[1][av_clip(quant
, 0, 30)]]
345 : &intra_vlcs
[rv34_quant_to_vlc_set
[0][av_clip(quant
, 0, 30)]];
349 * Decode intra macroblock header and return CBP in case of success, -1 otherwise.
351 static int rv34_decode_intra_mb_header(RV34DecContext
*r
, int8_t *intra_types
)
353 MpegEncContext
*s
= &r
->s
;
354 GetBitContext
*gb
= &s
->gb
;
355 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
358 r
->is16
= get_bits1(gb
);
360 s
->current_picture_ptr
->f
.mb_type
[mb_pos
] = MB_TYPE_INTRA16x16
;
361 r
->block_type
= RV34_MB_TYPE_INTRA16x16
;
363 fill_rectangle(intra_types
, 4, 4, r
->intra_types_stride
, t
, sizeof(intra_types
[0]));
368 av_log(s
->avctx
, AV_LOG_ERROR
, "Need DQUANT\n");
370 s
->current_picture_ptr
->f
.mb_type
[mb_pos
] = MB_TYPE_INTRA
;
371 r
->block_type
= RV34_MB_TYPE_INTRA
;
372 if(r
->decode_intra_types(r
, gb
, intra_types
) < 0)
378 r
->cur_vlcs
= choose_vlc_set(r
->si
.quant
, r
->si
.vlc_set
, 0);
380 return rv34_decode_cbp(gb
, r
->cur_vlcs
, r
->is16
);
384 * Decode inter macroblock header and return CBP in case of success, -1 otherwise.
386 static int rv34_decode_inter_mb_header(RV34DecContext
*r
, int8_t *intra_types
)
388 MpegEncContext
*s
= &r
->s
;
389 GetBitContext
*gb
= &s
->gb
;
390 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
393 r
->block_type
= r
->decode_mb_info(r
);
394 if(r
->block_type
== -1)
396 s
->current_picture_ptr
->f
.mb_type
[mb_pos
] = rv34_mb_type_to_lavc
[r
->block_type
];
397 r
->mb_type
[mb_pos
] = r
->block_type
;
398 if(r
->block_type
== RV34_MB_SKIP
){
399 if(s
->pict_type
== AV_PICTURE_TYPE_P
)
400 r
->mb_type
[mb_pos
] = RV34_MB_P_16x16
;
401 if(s
->pict_type
== AV_PICTURE_TYPE_B
)
402 r
->mb_type
[mb_pos
] = RV34_MB_B_DIRECT
;
404 r
->is16
= !!IS_INTRA16x16(s
->current_picture_ptr
->f
.mb_type
[mb_pos
]);
405 rv34_decode_mv(r
, r
->block_type
);
406 if(r
->block_type
== RV34_MB_SKIP
){
407 fill_rectangle(intra_types
, 4, 4, r
->intra_types_stride
, 0, sizeof(intra_types
[0]));
413 if(IS_INTRA(s
->current_picture_ptr
->f
.mb_type
[mb_pos
])){
416 fill_rectangle(intra_types
, 4, 4, r
->intra_types_stride
, t
, sizeof(intra_types
[0]));
419 if(r
->decode_intra_types(r
, gb
, intra_types
) < 0)
424 r
->cur_vlcs
= choose_vlc_set(r
->si
.quant
, r
->si
.vlc_set
, 0);
426 for(i
= 0; i
< 16; i
++)
427 intra_types
[(i
& 3) + (i
>>2) * r
->intra_types_stride
] = 0;
428 r
->cur_vlcs
= choose_vlc_set(r
->si
.quant
, r
->si
.vlc_set
, 1);
429 if(r
->mb_type
[mb_pos
] == RV34_MB_P_MIX16x16
){
433 r
->cur_vlcs
= choose_vlc_set(r
->si
.quant
, r
->si
.vlc_set
, 0);
437 return rv34_decode_cbp(gb
, r
->cur_vlcs
, r
->is16
);
440 /** @} */ //bitstream functions
443 * @name motion vector related code (prediction, reconstruction, motion compensation)
447 /** macroblock partition width in 8x8 blocks */
448 static const uint8_t part_sizes_w
[RV34_MB_TYPES
] = { 2, 2, 2, 1, 2, 2, 2, 2, 2, 1, 2, 2 };
450 /** macroblock partition height in 8x8 blocks */
451 static const uint8_t part_sizes_h
[RV34_MB_TYPES
] = { 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2 };
453 /** availability index for subblocks */
454 static const uint8_t avail_indexes
[4] = { 6, 7, 10, 11 };
457 * motion vector prediction
459 * Motion prediction performed for the block by using median prediction of
460 * motion vectors from the left, top and right top blocks but in corner cases
461 * some other vectors may be used instead.
463 static void rv34_pred_mv(RV34DecContext
*r
, int block_type
, int subblock_no
, int dmv_no
)
465 MpegEncContext
*s
= &r
->s
;
466 int mv_pos
= s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
;
467 int A
[2] = {0}, B
[2], C
[2];
470 int* avail
= r
->avail_cache
+ avail_indexes
[subblock_no
];
471 int c_off
= part_sizes_w
[block_type
];
473 mv_pos
+= (subblock_no
& 1) + (subblock_no
>> 1)*s
->b8_stride
;
478 A
[0] = s
->current_picture_ptr
->f
.motion_val
[0][mv_pos
-1][0];
479 A
[1] = s
->current_picture_ptr
->f
.motion_val
[0][mv_pos
-1][1];
482 B
[0] = s
->current_picture_ptr
->f
.motion_val
[0][mv_pos
-s
->b8_stride
][0];
483 B
[1] = s
->current_picture_ptr
->f
.motion_val
[0][mv_pos
-s
->b8_stride
][1];
489 if(avail
[-4] && (avail
[-1] || r
->rv30
)){
490 C
[0] = s
->current_picture_ptr
->f
.motion_val
[0][mv_pos
-s
->b8_stride
-1][0];
491 C
[1] = s
->current_picture_ptr
->f
.motion_val
[0][mv_pos
-s
->b8_stride
-1][1];
497 C
[0] = s
->current_picture_ptr
->f
.motion_val
[0][mv_pos
-s
->b8_stride
+c_off
][0];
498 C
[1] = s
->current_picture_ptr
->f
.motion_val
[0][mv_pos
-s
->b8_stride
+c_off
][1];
500 mx
= mid_pred(A
[0], B
[0], C
[0]);
501 my
= mid_pred(A
[1], B
[1], C
[1]);
502 mx
+= r
->dmv
[dmv_no
][0];
503 my
+= r
->dmv
[dmv_no
][1];
504 for(j
= 0; j
< part_sizes_h
[block_type
]; j
++){
505 for(i
= 0; i
< part_sizes_w
[block_type
]; i
++){
506 s
->current_picture_ptr
->f
.motion_val
[0][mv_pos
+ i
+ j
*s
->b8_stride
][0] = mx
;
507 s
->current_picture_ptr
->f
.motion_val
[0][mv_pos
+ i
+ j
*s
->b8_stride
][1] = my
;
512 #define GET_PTS_DIFF(a, b) ((a - b + 8192) & 0x1FFF)
515 * Calculate motion vector component that should be added for direct blocks.
517 static int calc_add_mv(RV34DecContext
*r
, int dir
, int val
)
519 int mul
= dir
? -r
->mv_weight2
: r
->mv_weight1
;
521 return (val
* mul
+ 0x2000) >> 14;
525 * Predict motion vector for B-frame macroblock.
527 static inline void rv34_pred_b_vector(int A
[2], int B
[2], int C
[2],
528 int A_avail
, int B_avail
, int C_avail
,
531 if(A_avail
+ B_avail
+ C_avail
!= 3){
532 *mx
= A
[0] + B
[0] + C
[0];
533 *my
= A
[1] + B
[1] + C
[1];
534 if(A_avail
+ B_avail
+ C_avail
== 2){
539 *mx
= mid_pred(A
[0], B
[0], C
[0]);
540 *my
= mid_pred(A
[1], B
[1], C
[1]);
545 * motion vector prediction for B-frames
547 static void rv34_pred_mv_b(RV34DecContext
*r
, int block_type
, int dir
)
549 MpegEncContext
*s
= &r
->s
;
550 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
551 int mv_pos
= s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
;
552 int A
[2] = { 0 }, B
[2] = { 0 }, C
[2] = { 0 };
553 int has_A
= 0, has_B
= 0, has_C
= 0;
556 Picture
*cur_pic
= s
->current_picture_ptr
;
557 const int mask
= dir
? MB_TYPE_L1
: MB_TYPE_L0
;
558 int type
= cur_pic
->f
.mb_type
[mb_pos
];
560 if((r
->avail_cache
[6-1] & type
) & mask
){
561 A
[0] = cur_pic
->f
.motion_val
[dir
][mv_pos
- 1][0];
562 A
[1] = cur_pic
->f
.motion_val
[dir
][mv_pos
- 1][1];
565 if((r
->avail_cache
[6-4] & type
) & mask
){
566 B
[0] = cur_pic
->f
.motion_val
[dir
][mv_pos
- s
->b8_stride
][0];
567 B
[1] = cur_pic
->f
.motion_val
[dir
][mv_pos
- s
->b8_stride
][1];
570 if(r
->avail_cache
[6-4] && (r
->avail_cache
[6-2] & type
) & mask
){
571 C
[0] = cur_pic
->f
.motion_val
[dir
][mv_pos
- s
->b8_stride
+ 2][0];
572 C
[1] = cur_pic
->f
.motion_val
[dir
][mv_pos
- s
->b8_stride
+ 2][1];
574 }else if((s
->mb_x
+1) == s
->mb_width
&& (r
->avail_cache
[6-5] & type
) & mask
){
575 C
[0] = cur_pic
->f
.motion_val
[dir
][mv_pos
- s
->b8_stride
- 1][0];
576 C
[1] = cur_pic
->f
.motion_val
[dir
][mv_pos
- s
->b8_stride
- 1][1];
580 rv34_pred_b_vector(A
, B
, C
, has_A
, has_B
, has_C
, &mx
, &my
);
582 mx
+= r
->dmv
[dir
][0];
583 my
+= r
->dmv
[dir
][1];
585 for(j
= 0; j
< 2; j
++){
586 for(i
= 0; i
< 2; i
++){
587 cur_pic
->f
.motion_val
[dir
][mv_pos
+ i
+ j
*s
->b8_stride
][0] = mx
;
588 cur_pic
->f
.motion_val
[dir
][mv_pos
+ i
+ j
*s
->b8_stride
][1] = my
;
591 if(block_type
== RV34_MB_B_BACKWARD
|| block_type
== RV34_MB_B_FORWARD
){
592 ZERO8x2(cur_pic
->f
.motion_val
[!dir
][mv_pos
], s
->b8_stride
);
597 * motion vector prediction - RV3 version
599 static void rv34_pred_mv_rv3(RV34DecContext
*r
, int block_type
, int dir
)
601 MpegEncContext
*s
= &r
->s
;
602 int mv_pos
= s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
;
603 int A
[2] = {0}, B
[2], C
[2];
606 int* avail
= r
->avail_cache
+ avail_indexes
[0];
609 A
[0] = s
->current_picture_ptr
->f
.motion_val
[0][mv_pos
- 1][0];
610 A
[1] = s
->current_picture_ptr
->f
.motion_val
[0][mv_pos
- 1][1];
613 B
[0] = s
->current_picture_ptr
->f
.motion_val
[0][mv_pos
- s
->b8_stride
][0];
614 B
[1] = s
->current_picture_ptr
->f
.motion_val
[0][mv_pos
- s
->b8_stride
][1];
620 if(avail
[-4] && (avail
[-1])){
621 C
[0] = s
->current_picture_ptr
->f
.motion_val
[0][mv_pos
- s
->b8_stride
- 1][0];
622 C
[1] = s
->current_picture_ptr
->f
.motion_val
[0][mv_pos
- s
->b8_stride
- 1][1];
628 C
[0] = s
->current_picture_ptr
->f
.motion_val
[0][mv_pos
- s
->b8_stride
+ 2][0];
629 C
[1] = s
->current_picture_ptr
->f
.motion_val
[0][mv_pos
- s
->b8_stride
+ 2][1];
631 mx
= mid_pred(A
[0], B
[0], C
[0]);
632 my
= mid_pred(A
[1], B
[1], C
[1]);
635 for(j
= 0; j
< 2; j
++){
636 for(i
= 0; i
< 2; i
++){
637 for(k
= 0; k
< 2; k
++){
638 s
->current_picture_ptr
->f
.motion_val
[k
][mv_pos
+ i
+ j
*s
->b8_stride
][0] = mx
;
639 s
->current_picture_ptr
->f
.motion_val
[k
][mv_pos
+ i
+ j
*s
->b8_stride
][1] = my
;
645 static const int chroma_coeffs
[3] = { 0, 3, 5 };
648 * generic motion compensation function
650 * @param r decoder context
651 * @param block_type type of the current block
652 * @param xoff horizontal offset from the start of the current block
653 * @param yoff vertical offset from the start of the current block
654 * @param mv_off offset to the motion vector information
655 * @param width width of the current partition in 8x8 blocks
656 * @param height height of the current partition in 8x8 blocks
657 * @param dir motion compensation direction (i.e. from the last or the next reference frame)
658 * @param thirdpel motion vectors are specified in 1/3 of pixel
659 * @param qpel_mc a set of functions used to perform luma motion compensation
660 * @param chroma_mc a set of functions used to perform chroma motion compensation
662 static inline void rv34_mc(RV34DecContext
*r
, const int block_type
,
663 const int xoff
, const int yoff
, int mv_off
,
664 const int width
, const int height
, int dir
,
665 const int thirdpel
, int weighted
,
666 qpel_mc_func (*qpel_mc
)[16],
667 h264_chroma_mc_func (*chroma_mc
))
669 MpegEncContext
*s
= &r
->s
;
670 uint8_t *Y
, *U
, *V
, *srcY
, *srcU
, *srcV
;
671 int dxy
, mx
, my
, umx
, umy
, lx
, ly
, uvmx
, uvmy
, src_x
, src_y
, uvsrc_x
, uvsrc_y
;
672 int mv_pos
= s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
+ mv_off
;
676 int chroma_mx
, chroma_my
;
677 mx
= (s
->current_picture_ptr
->f
.motion_val
[dir
][mv_pos
][0] + (3 << 24)) / 3 - (1 << 24);
678 my
= (s
->current_picture_ptr
->f
.motion_val
[dir
][mv_pos
][1] + (3 << 24)) / 3 - (1 << 24);
679 lx
= (s
->current_picture_ptr
->f
.motion_val
[dir
][mv_pos
][0] + (3 << 24)) % 3;
680 ly
= (s
->current_picture_ptr
->f
.motion_val
[dir
][mv_pos
][1] + (3 << 24)) % 3;
681 chroma_mx
= s
->current_picture_ptr
->f
.motion_val
[dir
][mv_pos
][0] / 2;
682 chroma_my
= s
->current_picture_ptr
->f
.motion_val
[dir
][mv_pos
][1] / 2;
683 umx
= (chroma_mx
+ (3 << 24)) / 3 - (1 << 24);
684 umy
= (chroma_my
+ (3 << 24)) / 3 - (1 << 24);
685 uvmx
= chroma_coeffs
[(chroma_mx
+ (3 << 24)) % 3];
686 uvmy
= chroma_coeffs
[(chroma_my
+ (3 << 24)) % 3];
689 mx
= s
->current_picture_ptr
->f
.motion_val
[dir
][mv_pos
][0] >> 2;
690 my
= s
->current_picture_ptr
->f
.motion_val
[dir
][mv_pos
][1] >> 2;
691 lx
= s
->current_picture_ptr
->f
.motion_val
[dir
][mv_pos
][0] & 3;
692 ly
= s
->current_picture_ptr
->f
.motion_val
[dir
][mv_pos
][1] & 3;
693 cx
= s
->current_picture_ptr
->f
.motion_val
[dir
][mv_pos
][0] / 2;
694 cy
= s
->current_picture_ptr
->f
.motion_val
[dir
][mv_pos
][1] / 2;
697 uvmx
= (cx
& 3) << 1;
698 uvmy
= (cy
& 3) << 1;
699 //due to some flaw RV40 uses the same MC compensation routine for H2V2 and H3V3
700 if(uvmx
== 6 && uvmy
== 6)
704 if (HAVE_THREADS
&& (s
->avctx
->active_thread_type
& FF_THREAD_FRAME
)) {
705 /* wait for the referenced mb row to be finished */
706 int mb_row
= s
->mb_y
+ ((yoff
+ my
+ 5 + 8 * height
) >> 4);
707 AVFrame
*f
= dir
? &s
->next_picture_ptr
->f
: &s
->last_picture_ptr
->f
;
708 ff_thread_await_progress(f
, mb_row
, 0);
712 srcY
= dir
? s
->next_picture_ptr
->f
.data
[0] : s
->last_picture_ptr
->f
.data
[0];
713 srcU
= dir
? s
->next_picture_ptr
->f
.data
[1] : s
->last_picture_ptr
->f
.data
[1];
714 srcV
= dir
? s
->next_picture_ptr
->f
.data
[2] : s
->last_picture_ptr
->f
.data
[2];
715 src_x
= s
->mb_x
* 16 + xoff
+ mx
;
716 src_y
= s
->mb_y
* 16 + yoff
+ my
;
717 uvsrc_x
= s
->mb_x
* 8 + (xoff
>> 1) + umx
;
718 uvsrc_y
= s
->mb_y
* 8 + (yoff
>> 1) + umy
;
719 srcY
+= src_y
* s
->linesize
+ src_x
;
720 srcU
+= uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
721 srcV
+= uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
722 if(s
->h_edge_pos
- (width
<< 3) < 6 || s
->v_edge_pos
- (height
<< 3) < 6 ||
723 (unsigned)(src_x
- !!lx
*2) > s
->h_edge_pos
- !!lx
*2 - (width
<<3) - 4 ||
724 (unsigned)(src_y
- !!ly
*2) > s
->v_edge_pos
- !!ly
*2 - (height
<<3) - 4) {
725 uint8_t *uvbuf
= s
->edge_emu_buffer
+ 22 * s
->linesize
;
727 srcY
-= 2 + 2*s
->linesize
;
728 s
->dsp
.emulated_edge_mc(s
->edge_emu_buffer
, srcY
, s
->linesize
, (width
<<3)+6, (height
<<3)+6,
729 src_x
- 2, src_y
- 2, s
->h_edge_pos
, s
->v_edge_pos
);
730 srcY
= s
->edge_emu_buffer
+ 2 + 2*s
->linesize
;
731 s
->dsp
.emulated_edge_mc(uvbuf
, srcU
, s
->uvlinesize
, (width
<<2)+1, (height
<<2)+1,
732 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
733 s
->dsp
.emulated_edge_mc(uvbuf
+ 16, srcV
, s
->uvlinesize
, (width
<<2)+1, (height
<<2)+1,
734 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
739 Y
= s
->dest
[0] + xoff
+ yoff
*s
->linesize
;
740 U
= s
->dest
[1] + (xoff
>>1) + (yoff
>>1)*s
->uvlinesize
;
741 V
= s
->dest
[2] + (xoff
>>1) + (yoff
>>1)*s
->uvlinesize
;
743 Y
= r
->tmp_b_block_y
[dir
] + xoff
+ yoff
*s
->linesize
;
744 U
= r
->tmp_b_block_uv
[dir
*2] + (xoff
>>1) + (yoff
>>1)*s
->uvlinesize
;
745 V
= r
->tmp_b_block_uv
[dir
*2+1] + (xoff
>>1) + (yoff
>>1)*s
->uvlinesize
;
748 if(block_type
== RV34_MB_P_16x8
){
749 qpel_mc
[1][dxy
](Y
, srcY
, s
->linesize
);
752 }else if(block_type
== RV34_MB_P_8x16
){
753 qpel_mc
[1][dxy
](Y
, srcY
, s
->linesize
);
754 Y
+= 8 * s
->linesize
;
755 srcY
+= 8 * s
->linesize
;
757 is16x16
= (block_type
!= RV34_MB_P_8x8
) && (block_type
!= RV34_MB_P_16x8
) && (block_type
!= RV34_MB_P_8x16
);
758 qpel_mc
[!is16x16
][dxy
](Y
, srcY
, s
->linesize
);
759 chroma_mc
[2-width
] (U
, srcU
, s
->uvlinesize
, height
*4, uvmx
, uvmy
);
760 chroma_mc
[2-width
] (V
, srcV
, s
->uvlinesize
, height
*4, uvmx
, uvmy
);
763 static void rv34_mc_1mv(RV34DecContext
*r
, const int block_type
,
764 const int xoff
, const int yoff
, int mv_off
,
765 const int width
, const int height
, int dir
)
767 rv34_mc(r
, block_type
, xoff
, yoff
, mv_off
, width
, height
, dir
, r
->rv30
, 0,
768 r
->rdsp
.put_pixels_tab
,
769 r
->rdsp
.put_chroma_pixels_tab
);
772 static void rv4_weight(RV34DecContext
*r
)
774 r
->rdsp
.rv40_weight_pixels_tab
[r
->scaled_weight
][0](r
->s
.dest
[0],
780 r
->rdsp
.rv40_weight_pixels_tab
[r
->scaled_weight
][1](r
->s
.dest
[1],
781 r
->tmp_b_block_uv
[0],
782 r
->tmp_b_block_uv
[2],
786 r
->rdsp
.rv40_weight_pixels_tab
[r
->scaled_weight
][1](r
->s
.dest
[2],
787 r
->tmp_b_block_uv
[1],
788 r
->tmp_b_block_uv
[3],
794 static void rv34_mc_2mv(RV34DecContext
*r
, const int block_type
)
796 int weighted
= !r
->rv30
&& block_type
!= RV34_MB_B_BIDIR
&& r
->weight1
!= 8192;
798 rv34_mc(r
, block_type
, 0, 0, 0, 2, 2, 0, r
->rv30
, weighted
,
799 r
->rdsp
.put_pixels_tab
,
800 r
->rdsp
.put_chroma_pixels_tab
);
802 rv34_mc(r
, block_type
, 0, 0, 0, 2, 2, 1, r
->rv30
, 0,
803 r
->rdsp
.avg_pixels_tab
,
804 r
->rdsp
.avg_chroma_pixels_tab
);
806 rv34_mc(r
, block_type
, 0, 0, 0, 2, 2, 1, r
->rv30
, 1,
807 r
->rdsp
.put_pixels_tab
,
808 r
->rdsp
.put_chroma_pixels_tab
);
813 static void rv34_mc_2mv_skip(RV34DecContext
*r
)
816 int weighted
= !r
->rv30
&& r
->weight1
!= 8192;
818 for(j
= 0; j
< 2; j
++)
819 for(i
= 0; i
< 2; i
++){
820 rv34_mc(r
, RV34_MB_P_8x8
, i
*8, j
*8, i
+j
*r
->s
.b8_stride
, 1, 1, 0, r
->rv30
,
822 r
->rdsp
.put_pixels_tab
,
823 r
->rdsp
.put_chroma_pixels_tab
);
824 rv34_mc(r
, RV34_MB_P_8x8
, i
*8, j
*8, i
+j
*r
->s
.b8_stride
, 1, 1, 1, r
->rv30
,
826 weighted
? r
->rdsp
.put_pixels_tab
: r
->rdsp
.avg_pixels_tab
,
827 weighted
? r
->rdsp
.put_chroma_pixels_tab
: r
->rdsp
.avg_chroma_pixels_tab
);
833 /** number of motion vectors in each macroblock type */
834 static const int num_mvs
[RV34_MB_TYPES
] = { 0, 0, 1, 4, 1, 1, 0, 0, 2, 2, 2, 1 };
837 * Decode motion vector differences
838 * and perform motion vector reconstruction and motion compensation.
840 static int rv34_decode_mv(RV34DecContext
*r
, int block_type
)
842 MpegEncContext
*s
= &r
->s
;
843 GetBitContext
*gb
= &s
->gb
;
845 int mv_pos
= s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
;
848 memset(r
->dmv
, 0, sizeof(r
->dmv
));
849 for(i
= 0; i
< num_mvs
[block_type
]; i
++){
850 r
->dmv
[i
][0] = svq3_get_se_golomb(gb
);
851 r
->dmv
[i
][1] = svq3_get_se_golomb(gb
);
854 case RV34_MB_TYPE_INTRA
:
855 case RV34_MB_TYPE_INTRA16x16
:
856 ZERO8x2(s
->current_picture_ptr
->f
.motion_val
[0][s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
], s
->b8_stride
);
859 if(s
->pict_type
== AV_PICTURE_TYPE_P
){
860 ZERO8x2(s
->current_picture_ptr
->f
.motion_val
[0][s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
], s
->b8_stride
);
861 rv34_mc_1mv (r
, block_type
, 0, 0, 0, 2, 2, 0);
864 case RV34_MB_B_DIRECT
:
865 //surprisingly, it uses motion scheme from next reference frame
866 /* wait for the current mb row to be finished */
867 if (HAVE_THREADS
&& (s
->avctx
->active_thread_type
& FF_THREAD_FRAME
))
868 ff_thread_await_progress(&s
->next_picture_ptr
->f
, FFMAX(0, s
->mb_y
-1), 0);
870 next_bt
= s
->next_picture_ptr
->f
.mb_type
[s
->mb_x
+ s
->mb_y
* s
->mb_stride
];
871 if(IS_INTRA(next_bt
) || IS_SKIP(next_bt
)){
872 ZERO8x2(s
->current_picture_ptr
->f
.motion_val
[0][s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
], s
->b8_stride
);
873 ZERO8x2(s
->current_picture_ptr
->f
.motion_val
[1][s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
], s
->b8_stride
);
875 for(j
= 0; j
< 2; j
++)
876 for(i
= 0; i
< 2; i
++)
877 for(k
= 0; k
< 2; k
++)
878 for(l
= 0; l
< 2; l
++)
879 s
->current_picture_ptr
->f
.motion_val
[l
][mv_pos
+ i
+ j
*s
->b8_stride
][k
] = calc_add_mv(r
, l
, s
->next_picture_ptr
->f
.motion_val
[0][mv_pos
+ i
+ j
*s
->b8_stride
][k
]);
880 if(!(IS_16X8(next_bt
) || IS_8X16(next_bt
) || IS_8X8(next_bt
))) //we can use whole macroblock MC
881 rv34_mc_2mv(r
, block_type
);
884 ZERO8x2(s
->current_picture_ptr
->f
.motion_val
[0][s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
], s
->b8_stride
);
886 case RV34_MB_P_16x16
:
887 case RV34_MB_P_MIX16x16
:
888 rv34_pred_mv(r
, block_type
, 0, 0);
889 rv34_mc_1mv (r
, block_type
, 0, 0, 0, 2, 2, 0);
891 case RV34_MB_B_FORWARD
:
892 case RV34_MB_B_BACKWARD
:
893 r
->dmv
[1][0] = r
->dmv
[0][0];
894 r
->dmv
[1][1] = r
->dmv
[0][1];
896 rv34_pred_mv_rv3(r
, block_type
, block_type
== RV34_MB_B_BACKWARD
);
898 rv34_pred_mv_b (r
, block_type
, block_type
== RV34_MB_B_BACKWARD
);
899 rv34_mc_1mv (r
, block_type
, 0, 0, 0, 2, 2, block_type
== RV34_MB_B_BACKWARD
);
903 rv34_pred_mv(r
, block_type
, 0, 0);
904 rv34_pred_mv(r
, block_type
, 1 + (block_type
== RV34_MB_P_16x8
), 1);
905 if(block_type
== RV34_MB_P_16x8
){
906 rv34_mc_1mv(r
, block_type
, 0, 0, 0, 2, 1, 0);
907 rv34_mc_1mv(r
, block_type
, 0, 8, s
->b8_stride
, 2, 1, 0);
909 if(block_type
== RV34_MB_P_8x16
){
910 rv34_mc_1mv(r
, block_type
, 0, 0, 0, 1, 2, 0);
911 rv34_mc_1mv(r
, block_type
, 8, 0, 1, 1, 2, 0);
914 case RV34_MB_B_BIDIR
:
915 rv34_pred_mv_b (r
, block_type
, 0);
916 rv34_pred_mv_b (r
, block_type
, 1);
917 rv34_mc_2mv (r
, block_type
);
921 rv34_pred_mv(r
, block_type
, i
, i
);
922 rv34_mc_1mv (r
, block_type
, (i
&1)<<3, (i
&2)<<2, (i
&1)+(i
>>1)*s
->b8_stride
, 1, 1, 0);
929 /** @} */ // mv group
932 * @name Macroblock reconstruction functions
935 /** mapping of RV30/40 intra prediction types to standard H.264 types */
936 static const int ittrans
[9] = {
937 DC_PRED
, VERT_PRED
, HOR_PRED
, DIAG_DOWN_RIGHT_PRED
, DIAG_DOWN_LEFT_PRED
,
938 VERT_RIGHT_PRED
, VERT_LEFT_PRED
, HOR_UP_PRED
, HOR_DOWN_PRED
,
941 /** mapping of RV30/40 intra 16x16 prediction types to standard H.264 types */
942 static const int ittrans16
[4] = {
943 DC_PRED8x8
, VERT_PRED8x8
, HOR_PRED8x8
, PLANE_PRED8x8
,
947 * Perform 4x4 intra prediction.
949 static void rv34_pred_4x4_block(RV34DecContext
*r
, uint8_t *dst
, int stride
, int itype
, int up
, int left
, int down
, int right
)
951 uint8_t *prev
= dst
- stride
+ 4;
957 if(itype
== VERT_PRED
) itype
= HOR_PRED
;
958 if(itype
== DC_PRED
) itype
= LEFT_DC_PRED
;
960 if(itype
== HOR_PRED
) itype
= VERT_PRED
;
961 if(itype
== DC_PRED
) itype
= TOP_DC_PRED
;
962 if(itype
== DIAG_DOWN_LEFT_PRED
) itype
= DIAG_DOWN_LEFT_PRED_RV40_NODOWN
;
965 if(itype
== DIAG_DOWN_LEFT_PRED
) itype
= DIAG_DOWN_LEFT_PRED_RV40_NODOWN
;
966 if(itype
== HOR_UP_PRED
) itype
= HOR_UP_PRED_RV40_NODOWN
;
967 if(itype
== VERT_LEFT_PRED
) itype
= VERT_LEFT_PRED_RV40_NODOWN
;
970 topleft
= dst
[-stride
+ 3] * 0x01010101u
;
971 prev
= (uint8_t*)&topleft
;
973 r
->h
.pred4x4
[itype
](dst
, prev
, stride
);
976 static inline int adjust_pred16(int itype
, int up
, int left
)
979 itype
= DC_128_PRED8x8
;
981 if(itype
== PLANE_PRED8x8
)itype
= HOR_PRED8x8
;
982 if(itype
== VERT_PRED8x8
) itype
= HOR_PRED8x8
;
983 if(itype
== DC_PRED8x8
) itype
= LEFT_DC_PRED8x8
;
985 if(itype
== PLANE_PRED8x8
)itype
= VERT_PRED8x8
;
986 if(itype
== HOR_PRED8x8
) itype
= VERT_PRED8x8
;
987 if(itype
== DC_PRED8x8
) itype
= TOP_DC_PRED8x8
;
992 static inline void rv34_process_block(RV34DecContext
*r
,
993 uint8_t *pdst
, int stride
,
994 int fc
, int sc
, int q_dc
, int q_ac
)
996 MpegEncContext
*s
= &r
->s
;
997 DCTELEM
*ptr
= s
->block
[0];
998 int has_ac
= rv34_decode_block(ptr
, &s
->gb
, r
->cur_vlcs
,
999 fc
, sc
, q_dc
, q_ac
, q_ac
);
1001 r
->rdsp
.rv34_idct_add(pdst
, stride
, ptr
);
1003 r
->rdsp
.rv34_idct_dc_add(pdst
, stride
, ptr
[0]);
1008 static void rv34_output_i16x16(RV34DecContext
*r
, int8_t *intra_types
, int cbp
)
1010 LOCAL_ALIGNED_16(DCTELEM
, block16
, [16]);
1011 MpegEncContext
*s
= &r
->s
;
1012 GetBitContext
*gb
= &s
->gb
;
1013 int q_dc
= rv34_qscale_tab
[ r
->luma_dc_quant_i
[s
->qscale
] ],
1014 q_ac
= rv34_qscale_tab
[s
->qscale
];
1015 uint8_t *dst
= s
->dest
[0];
1016 DCTELEM
*ptr
= s
->block
[0];
1017 int i
, j
, itype
, has_ac
;
1019 memset(block16
, 0, 16 * sizeof(*block16
));
1021 has_ac
= rv34_decode_block(block16
, gb
, r
->cur_vlcs
, 3, 0, q_dc
, q_dc
, q_ac
);
1023 r
->rdsp
.rv34_inv_transform(block16
);
1025 r
->rdsp
.rv34_inv_transform_dc(block16
);
1027 itype
= ittrans16
[intra_types
[0]];
1028 itype
= adjust_pred16(itype
, r
->avail_cache
[6-4], r
->avail_cache
[6-1]);
1029 r
->h
.pred16x16
[itype
](dst
, s
->linesize
);
1031 for(j
= 0; j
< 4; j
++){
1032 for(i
= 0; i
< 4; i
++, cbp
>>= 1){
1033 int dc
= block16
[i
+ j
*4];
1036 has_ac
= rv34_decode_block(ptr
, gb
, r
->cur_vlcs
, r
->luma_vlc
, 0, q_ac
, q_ac
, q_ac
);
1042 r
->rdsp
.rv34_idct_add(dst
+4*i
, s
->linesize
, ptr
);
1044 r
->rdsp
.rv34_idct_dc_add(dst
+4*i
, s
->linesize
, dc
);
1047 dst
+= 4*s
->linesize
;
1050 itype
= ittrans16
[intra_types
[0]];
1051 if(itype
== PLANE_PRED8x8
) itype
= DC_PRED8x8
;
1052 itype
= adjust_pred16(itype
, r
->avail_cache
[6-4], r
->avail_cache
[6-1]);
1054 q_dc
= rv34_qscale_tab
[rv34_chroma_quant
[1][s
->qscale
]];
1055 q_ac
= rv34_qscale_tab
[rv34_chroma_quant
[0][s
->qscale
]];
1057 for(j
= 1; j
< 3; j
++){
1059 r
->h
.pred8x8
[itype
](dst
, s
->uvlinesize
);
1060 for(i
= 0; i
< 4; i
++, cbp
>>= 1){
1062 if(!(cbp
& 1)) continue;
1063 pdst
= dst
+ (i
&1)*4 + (i
&2)*2*s
->uvlinesize
;
1065 rv34_process_block(r
, pdst
, s
->uvlinesize
,
1066 r
->chroma_vlc
, 1, q_dc
, q_ac
);
1071 static void rv34_output_intra(RV34DecContext
*r
, int8_t *intra_types
, int cbp
)
1073 MpegEncContext
*s
= &r
->s
;
1074 uint8_t *dst
= s
->dest
[0];
1075 int avail
[6*8] = {0};
1077 int idx
, q_ac
, q_dc
;
1079 // Set neighbour information.
1080 if(r
->avail_cache
[1])
1082 if(r
->avail_cache
[2])
1083 avail
[1] = avail
[2] = 1;
1084 if(r
->avail_cache
[3])
1085 avail
[3] = avail
[4] = 1;
1086 if(r
->avail_cache
[4])
1088 if(r
->avail_cache
[5])
1089 avail
[8] = avail
[16] = 1;
1090 if(r
->avail_cache
[9])
1091 avail
[24] = avail
[32] = 1;
1093 q_ac
= rv34_qscale_tab
[s
->qscale
];
1094 for(j
= 0; j
< 4; j
++){
1096 for(i
= 0; i
< 4; i
++, cbp
>>= 1, dst
+= 4, idx
++){
1097 rv34_pred_4x4_block(r
, dst
, s
->linesize
, ittrans
[intra_types
[i
]], avail
[idx
-8], avail
[idx
-1], avail
[idx
+7], avail
[idx
-7]);
1099 if(!(cbp
& 1)) continue;
1101 rv34_process_block(r
, dst
, s
->linesize
,
1102 r
->luma_vlc
, 0, q_ac
, q_ac
);
1104 dst
+= s
->linesize
* 4 - 4*4;
1105 intra_types
+= r
->intra_types_stride
;
1108 intra_types
-= r
->intra_types_stride
* 4;
1110 q_dc
= rv34_qscale_tab
[rv34_chroma_quant
[1][s
->qscale
]];
1111 q_ac
= rv34_qscale_tab
[rv34_chroma_quant
[0][s
->qscale
]];
1113 for(k
= 0; k
< 2; k
++){
1115 fill_rectangle(r
->avail_cache
+ 6, 2, 2, 4, 0, 4);
1117 for(j
= 0; j
< 2; j
++){
1118 int* acache
= r
->avail_cache
+ 6 + j
*4;
1119 for(i
= 0; i
< 2; i
++, cbp
>>= 1, acache
++){
1120 int itype
= ittrans
[intra_types
[i
*2+j
*2*r
->intra_types_stride
]];
1121 rv34_pred_4x4_block(r
, dst
+4*i
, s
->uvlinesize
, itype
, acache
[-4], acache
[-1], !i
&& !j
, acache
[-3]);
1124 if(!(cbp
&1)) continue;
1126 rv34_process_block(r
, dst
+ 4*i
, s
->uvlinesize
,
1127 r
->chroma_vlc
, 1, q_dc
, q_ac
);
1130 dst
+= 4*s
->uvlinesize
;
1135 static int is_mv_diff_gt_3(int16_t (*motion_val
)[2], int step
)
1138 d
= motion_val
[0][0] - motion_val
[-step
][0];
1141 d
= motion_val
[0][1] - motion_val
[-step
][1];
1147 static int rv34_set_deblock_coef(RV34DecContext
*r
)
1149 MpegEncContext
*s
= &r
->s
;
1150 int hmvmask
= 0, vmvmask
= 0, i
, j
;
1151 int midx
= s
->mb_x
* 2 + s
->mb_y
* 2 * s
->b8_stride
;
1152 int16_t (*motion_val
)[2] = &s
->current_picture_ptr
->f
.motion_val
[0][midx
];
1153 for(j
= 0; j
< 16; j
+= 8){
1154 for(i
= 0; i
< 2; i
++){
1155 if(is_mv_diff_gt_3(motion_val
+ i
, 1))
1156 vmvmask
|= 0x11 << (j
+ i
*2);
1157 if((j
|| s
->mb_y
) && is_mv_diff_gt_3(motion_val
+ i
, s
->b8_stride
))
1158 hmvmask
|= 0x03 << (j
+ i
*2);
1160 motion_val
+= s
->b8_stride
;
1162 if(s
->first_slice_line
)
1166 if(r
->rv30
){ //RV30 marks both subblocks on the edge for filtering
1167 vmvmask
|= (vmvmask
& 0x4444) >> 1;
1168 hmvmask
|= (hmvmask
& 0x0F00) >> 4;
1170 r
->deblock_coefs
[s
->mb_x
- 1 + s
->mb_y
*s
->mb_stride
] |= (vmvmask
& 0x1111) << 3;
1171 if(!s
->first_slice_line
)
1172 r
->deblock_coefs
[s
->mb_x
+ (s
->mb_y
- 1)*s
->mb_stride
] |= (hmvmask
& 0xF) << 12;
1174 return hmvmask
| vmvmask
;
1177 static int rv34_decode_inter_macroblock(RV34DecContext
*r
, int8_t *intra_types
)
1179 MpegEncContext
*s
= &r
->s
;
1180 GetBitContext
*gb
= &s
->gb
;
1181 uint8_t *dst
= s
->dest
[0];
1182 DCTELEM
*ptr
= s
->block
[0];
1183 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
1185 int q_dc
, q_ac
, has_ac
;
1189 // Calculate which neighbours are available. Maybe it's worth optimizing too.
1190 memset(r
->avail_cache
, 0, sizeof(r
->avail_cache
));
1191 fill_rectangle(r
->avail_cache
+ 6, 2, 2, 4, 1, 4);
1192 dist
= (s
->mb_x
- s
->resync_mb_x
) + (s
->mb_y
- s
->resync_mb_y
) * s
->mb_width
;
1195 r
->avail_cache
[9] = s
->current_picture_ptr
->f
.mb_type
[mb_pos
- 1];
1196 if(dist
>= s
->mb_width
)
1198 r
->avail_cache
[3] = s
->current_picture_ptr
->f
.mb_type
[mb_pos
- s
->mb_stride
];
1199 if(((s
->mb_x
+1) < s
->mb_width
) && dist
>= s
->mb_width
- 1)
1200 r
->avail_cache
[4] = s
->current_picture_ptr
->f
.mb_type
[mb_pos
- s
->mb_stride
+ 1];
1201 if(s
->mb_x
&& dist
> s
->mb_width
)
1202 r
->avail_cache
[1] = s
->current_picture_ptr
->f
.mb_type
[mb_pos
- s
->mb_stride
- 1];
1204 s
->qscale
= r
->si
.quant
;
1205 cbp
= cbp2
= rv34_decode_inter_mb_header(r
, intra_types
);
1206 r
->cbp_luma
[mb_pos
] = cbp
;
1207 r
->cbp_chroma
[mb_pos
] = cbp
>> 16;
1208 r
->deblock_coefs
[mb_pos
] = rv34_set_deblock_coef(r
) | r
->cbp_luma
[mb_pos
];
1209 s
->current_picture_ptr
->f
.qscale_table
[mb_pos
] = s
->qscale
;
1214 if (IS_INTRA(s
->current_picture_ptr
->f
.mb_type
[mb_pos
])){
1215 if(r
->is16
) rv34_output_i16x16(r
, intra_types
, cbp
);
1216 else rv34_output_intra(r
, intra_types
, cbp
);
1221 // Only for RV34_MB_P_MIX16x16
1222 LOCAL_ALIGNED_16(DCTELEM
, block16
, [16]);
1223 memset(block16
, 0, 16 * sizeof(*block16
));
1224 q_dc
= rv34_qscale_tab
[ r
->luma_dc_quant_p
[s
->qscale
] ];
1225 q_ac
= rv34_qscale_tab
[s
->qscale
];
1226 if (rv34_decode_block(block16
, gb
, r
->cur_vlcs
, 3, 0, q_dc
, q_dc
, q_ac
))
1227 r
->rdsp
.rv34_inv_transform(block16
);
1229 r
->rdsp
.rv34_inv_transform_dc(block16
);
1231 q_ac
= rv34_qscale_tab
[s
->qscale
];
1233 for(j
= 0; j
< 4; j
++){
1234 for(i
= 0; i
< 4; i
++, cbp
>>= 1){
1235 int dc
= block16
[i
+ j
*4];
1238 has_ac
= rv34_decode_block(ptr
, gb
, r
->cur_vlcs
, r
->luma_vlc
, 0, q_ac
, q_ac
, q_ac
);
1244 r
->rdsp
.rv34_idct_add(dst
+4*i
, s
->linesize
, ptr
);
1246 r
->rdsp
.rv34_idct_dc_add(dst
+4*i
, s
->linesize
, dc
);
1249 dst
+= 4*s
->linesize
;
1252 r
->cur_vlcs
= choose_vlc_set(r
->si
.quant
, r
->si
.vlc_set
, 1);
1254 q_ac
= rv34_qscale_tab
[s
->qscale
];
1256 for(j
= 0; j
< 4; j
++){
1257 for(i
= 0; i
< 4; i
++, cbp
>>= 1){
1258 if(!(cbp
& 1)) continue;
1260 rv34_process_block(r
, dst
+ 4*i
, s
->linesize
,
1261 r
->luma_vlc
, 0, q_ac
, q_ac
);
1263 dst
+= 4*s
->linesize
;
1267 q_dc
= rv34_qscale_tab
[rv34_chroma_quant
[1][s
->qscale
]];
1268 q_ac
= rv34_qscale_tab
[rv34_chroma_quant
[0][s
->qscale
]];
1270 for(j
= 1; j
< 3; j
++){
1272 for(i
= 0; i
< 4; i
++, cbp
>>= 1){
1274 if(!(cbp
& 1)) continue;
1275 pdst
= dst
+ (i
&1)*4 + (i
&2)*2*s
->uvlinesize
;
1277 rv34_process_block(r
, pdst
, s
->uvlinesize
,
1278 r
->chroma_vlc
, 1, q_dc
, q_ac
);
1285 static int rv34_decode_intra_macroblock(RV34DecContext
*r
, int8_t *intra_types
)
1287 MpegEncContext
*s
= &r
->s
;
1289 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
1291 // Calculate which neighbours are available. Maybe it's worth optimizing too.
1292 memset(r
->avail_cache
, 0, sizeof(r
->avail_cache
));
1293 fill_rectangle(r
->avail_cache
+ 6, 2, 2, 4, 1, 4);
1294 dist
= (s
->mb_x
- s
->resync_mb_x
) + (s
->mb_y
- s
->resync_mb_y
) * s
->mb_width
;
1297 r
->avail_cache
[9] = s
->current_picture_ptr
->f
.mb_type
[mb_pos
- 1];
1298 if(dist
>= s
->mb_width
)
1300 r
->avail_cache
[3] = s
->current_picture_ptr
->f
.mb_type
[mb_pos
- s
->mb_stride
];
1301 if(((s
->mb_x
+1) < s
->mb_width
) && dist
>= s
->mb_width
- 1)
1302 r
->avail_cache
[4] = s
->current_picture_ptr
->f
.mb_type
[mb_pos
- s
->mb_stride
+ 1];
1303 if(s
->mb_x
&& dist
> s
->mb_width
)
1304 r
->avail_cache
[1] = s
->current_picture_ptr
->f
.mb_type
[mb_pos
- s
->mb_stride
- 1];
1306 s
->qscale
= r
->si
.quant
;
1307 cbp
= rv34_decode_intra_mb_header(r
, intra_types
);
1308 r
->cbp_luma
[mb_pos
] = cbp
;
1309 r
->cbp_chroma
[mb_pos
] = cbp
>> 16;
1310 r
->deblock_coefs
[mb_pos
] = 0xFFFF;
1311 s
->current_picture_ptr
->f
.qscale_table
[mb_pos
] = s
->qscale
;
1317 rv34_output_i16x16(r
, intra_types
, cbp
);
1321 rv34_output_intra(r
, intra_types
, cbp
);
1325 static int check_slice_end(RV34DecContext
*r
, MpegEncContext
*s
)
1328 if(s
->mb_y
>= s
->mb_height
)
1332 if(r
->s
.mb_skip_run
> 1)
1334 bits
= get_bits_left(&s
->gb
);
1335 if(bits
< 0 || (bits
< 8 && !show_bits(&s
->gb
, bits
)))
1341 static void rv34_decoder_free(RV34DecContext
*r
)
1343 av_freep(&r
->intra_types_hist
);
1344 r
->intra_types
= NULL
;
1345 av_freep(&r
->tmp_b_block_base
);
1346 av_freep(&r
->mb_type
);
1347 av_freep(&r
->cbp_luma
);
1348 av_freep(&r
->cbp_chroma
);
1349 av_freep(&r
->deblock_coefs
);
1353 static int rv34_decoder_alloc(RV34DecContext
*r
)
1355 r
->intra_types_stride
= r
->s
.mb_width
* 4 + 4;
1357 r
->cbp_chroma
= av_malloc(r
->s
.mb_stride
* r
->s
.mb_height
*
1358 sizeof(*r
->cbp_chroma
));
1359 r
->cbp_luma
= av_malloc(r
->s
.mb_stride
* r
->s
.mb_height
*
1360 sizeof(*r
->cbp_luma
));
1361 r
->deblock_coefs
= av_malloc(r
->s
.mb_stride
* r
->s
.mb_height
*
1362 sizeof(*r
->deblock_coefs
));
1363 r
->intra_types_hist
= av_malloc(r
->intra_types_stride
* 4 * 2 *
1364 sizeof(*r
->intra_types_hist
));
1365 r
->mb_type
= av_mallocz(r
->s
.mb_stride
* r
->s
.mb_height
*
1366 sizeof(*r
->mb_type
));
1368 if (!(r
->cbp_chroma
&& r
->cbp_luma
&& r
->deblock_coefs
&&
1369 r
->intra_types_hist
&& r
->mb_type
)) {
1370 rv34_decoder_free(r
);
1371 return AVERROR(ENOMEM
);
1374 r
->intra_types
= r
->intra_types_hist
+ r
->intra_types_stride
* 4;
1380 static int rv34_decoder_realloc(RV34DecContext
*r
)
1382 rv34_decoder_free(r
);
1383 return rv34_decoder_alloc(r
);
1387 static int rv34_decode_slice(RV34DecContext
*r
, int end
, const uint8_t* buf
, int buf_size
)
1389 MpegEncContext
*s
= &r
->s
;
1390 GetBitContext
*gb
= &s
->gb
;
1391 int mb_pos
, slice_type
;
1394 init_get_bits(&r
->s
.gb
, buf
, buf_size
*8);
1395 res
= r
->parse_slice_header(r
, gb
, &r
->si
);
1397 av_log(s
->avctx
, AV_LOG_ERROR
, "Incorrect or unknown slice header\n");
1401 slice_type
= r
->si
.type
? r
->si
.type
: AV_PICTURE_TYPE_I
;
1402 if (slice_type
!= s
->pict_type
) {
1403 av_log(s
->avctx
, AV_LOG_ERROR
, "Slice type mismatch\n");
1404 return AVERROR_INVALIDDATA
;
1408 s
->qscale
= r
->si
.quant
;
1409 s
->mb_num_left
= r
->si
.end
- r
->si
.start
;
1410 r
->s
.mb_skip_run
= 0;
1412 mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_width
;
1413 if(r
->si
.start
!= mb_pos
){
1414 av_log(s
->avctx
, AV_LOG_ERROR
, "Slice indicates MB offset %d, got %d\n", r
->si
.start
, mb_pos
);
1415 s
->mb_x
= r
->si
.start
% s
->mb_width
;
1416 s
->mb_y
= r
->si
.start
/ s
->mb_width
;
1418 memset(r
->intra_types_hist
, -1, r
->intra_types_stride
* 4 * 2 * sizeof(*r
->intra_types_hist
));
1419 s
->first_slice_line
= 1;
1420 s
->resync_mb_x
= s
->mb_x
;
1421 s
->resync_mb_y
= s
->mb_y
;
1423 ff_init_block_index(s
);
1424 while(!check_slice_end(r
, s
)) {
1425 ff_update_block_index(s
);
1428 res
= rv34_decode_inter_macroblock(r
, r
->intra_types
+ s
->mb_x
* 4 + 4);
1430 res
= rv34_decode_intra_macroblock(r
, r
->intra_types
+ s
->mb_x
* 4 + 4);
1432 ff_er_add_slice(s
, s
->resync_mb_x
, s
->resync_mb_y
, s
->mb_x
-1, s
->mb_y
, ER_MB_ERROR
);
1435 if (++s
->mb_x
== s
->mb_width
) {
1438 ff_init_block_index(s
);
1440 memmove(r
->intra_types_hist
, r
->intra_types
, r
->intra_types_stride
* 4 * sizeof(*r
->intra_types_hist
));
1441 memset(r
->intra_types
, -1, r
->intra_types_stride
* 4 * sizeof(*r
->intra_types_hist
));
1443 if(r
->loop_filter
&& s
->mb_y
>= 2)
1444 r
->loop_filter(r
, s
->mb_y
- 2);
1446 if (HAVE_THREADS
&& (s
->avctx
->active_thread_type
& FF_THREAD_FRAME
))
1447 ff_thread_report_progress(&s
->current_picture_ptr
->f
,
1451 if(s
->mb_x
== s
->resync_mb_x
)
1452 s
->first_slice_line
=0;
1455 ff_er_add_slice(s
, s
->resync_mb_x
, s
->resync_mb_y
, s
->mb_x
-1, s
->mb_y
, ER_MB_END
);
1457 return s
->mb_y
== s
->mb_height
;
1460 /** @} */ // recons group end
1463 * Initialize decoder.
1465 av_cold
int ff_rv34_decode_init(AVCodecContext
*avctx
)
1467 RV34DecContext
*r
= avctx
->priv_data
;
1468 MpegEncContext
*s
= &r
->s
;
1471 ff_MPV_decode_defaults(s
);
1473 s
->out_format
= FMT_H263
;
1474 s
->codec_id
= avctx
->codec_id
;
1476 s
->width
= avctx
->width
;
1477 s
->height
= avctx
->height
;
1480 avctx
->flags
|= CODEC_FLAG_EMU_EDGE
;
1481 r
->s
.flags
|= CODEC_FLAG_EMU_EDGE
;
1482 avctx
->pix_fmt
= PIX_FMT_YUV420P
;
1483 avctx
->has_b_frames
= 1;
1486 if ((ret
= ff_MPV_common_init(s
)) < 0)
1489 ff_h264_pred_init(&r
->h
, CODEC_ID_RV40
, 8, 1);
1491 #if CONFIG_RV30_DECODER
1492 if (avctx
->codec_id
== CODEC_ID_RV30
)
1493 ff_rv30dsp_init(&r
->rdsp
, &r
->s
.dsp
);
1495 #if CONFIG_RV40_DECODER
1496 if (avctx
->codec_id
== CODEC_ID_RV40
)
1497 ff_rv40dsp_init(&r
->rdsp
, &r
->s
.dsp
);
1500 if ((ret
= rv34_decoder_alloc(r
)) < 0)
1503 if(!intra_vlcs
[0].cbppattern
[0].bits
)
1509 int ff_rv34_decode_init_thread_copy(AVCodecContext
*avctx
)
1512 RV34DecContext
*r
= avctx
->priv_data
;
1516 if (avctx
->internal
->is_copy
) {
1517 r
->tmp_b_block_base
= NULL
;
1518 if ((err
= ff_MPV_common_init(&r
->s
)) < 0)
1520 if ((err
= rv34_decoder_alloc(r
)) < 0)
1526 int ff_rv34_decode_update_thread_context(AVCodecContext
*dst
, const AVCodecContext
*src
)
1528 RV34DecContext
*r
= dst
->priv_data
, *r1
= src
->priv_data
;
1529 MpegEncContext
* const s
= &r
->s
, * const s1
= &r1
->s
;
1532 if (dst
== src
|| !s1
->context_initialized
)
1535 if (s
->height
!= s1
->height
|| s
->width
!= s1
->width
) {
1536 ff_MPV_common_end(s
);
1537 s
->height
= s1
->height
;
1538 s
->width
= s1
->width
;
1539 if ((err
= ff_MPV_common_init(s
)) < 0)
1541 if ((err
= rv34_decoder_realloc(r
)) < 0)
1545 if ((err
= ff_mpeg_update_thread_context(dst
, src
)))
1548 r
->cur_pts
= r1
->cur_pts
;
1549 r
->last_pts
= r1
->last_pts
;
1550 r
->next_pts
= r1
->next_pts
;
1552 memset(&r
->si
, 0, sizeof(r
->si
));
1557 static int get_slice_offset(AVCodecContext
*avctx
, const uint8_t *buf
, int n
)
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);
1563 static int finish_frame(AVCodecContext
*avctx
, AVFrame
*pict
)
1565 RV34DecContext
*r
= avctx
->priv_data
;
1566 MpegEncContext
*s
= &r
->s
;
1567 int got_picture
= 0;
1570 ff_MPV_frame_end(s
);
1573 if (HAVE_THREADS
&& (s
->avctx
->active_thread_type
& FF_THREAD_FRAME
))
1574 ff_thread_report_progress(&s
->current_picture_ptr
->f
, INT_MAX
, 0);
1576 if (s
->pict_type
== AV_PICTURE_TYPE_B
|| s
->low_delay
) {
1577 *pict
= s
->current_picture_ptr
->f
;
1579 } else if (s
->last_picture_ptr
!= NULL
) {
1580 *pict
= s
->last_picture_ptr
->f
;
1584 ff_print_debug_info(s
, pict
);
1589 int ff_rv34_decode_frame(AVCodecContext
*avctx
,
1590 void *data
, int *got_picture_ptr
,
1593 const uint8_t *buf
= avpkt
->data
;
1594 int buf_size
= avpkt
->size
;
1595 RV34DecContext
*r
= avctx
->priv_data
;
1596 MpegEncContext
*s
= &r
->s
;
1597 AVFrame
*pict
= data
;
1601 const uint8_t *slices_hdr
= NULL
;
1604 /* no supplementary picture */
1605 if (buf_size
== 0) {
1606 /* special case for last picture */
1607 if (s
->low_delay
==0 && s
->next_picture_ptr
) {
1608 *pict
= s
->next_picture_ptr
->f
;
1609 s
->next_picture_ptr
= NULL
;
1611 *got_picture_ptr
= 1;
1616 if(!avctx
->slice_count
){
1617 slice_count
= (*buf
++) + 1;
1618 slices_hdr
= buf
+ 4;
1619 buf
+= 8 * slice_count
;
1620 buf_size
-= 1 + 8 * slice_count
;
1622 slice_count
= avctx
->slice_count
;
1624 //parse first slice header to check whether this frame can be decoded
1625 if(get_slice_offset(avctx
, slices_hdr
, 0) < 0 ||
1626 get_slice_offset(avctx
, slices_hdr
, 0) > buf_size
){
1627 av_log(avctx
, AV_LOG_ERROR
, "Slice offset is invalid\n");
1628 return AVERROR_INVALIDDATA
;
1630 init_get_bits(&s
->gb
, buf
+get_slice_offset(avctx
, slices_hdr
, 0), (buf_size
-get_slice_offset(avctx
, slices_hdr
, 0))*8);
1631 if(r
->parse_slice_header(r
, &r
->s
.gb
, &si
) < 0 || si
.start
){
1632 av_log(avctx
, AV_LOG_ERROR
, "First slice header is incorrect\n");
1633 return AVERROR_INVALIDDATA
;
1635 if ((!s
->last_picture_ptr
|| !s
->last_picture_ptr
->f
.data
[0]) &&
1636 si
.type
== AV_PICTURE_TYPE_B
) {
1637 av_log(avctx
, AV_LOG_ERROR
, "Invalid decoder state: B-frame without "
1638 "reference data.\n");
1639 return AVERROR_INVALIDDATA
;
1641 if( (avctx
->skip_frame
>= AVDISCARD_NONREF
&& si
.type
==AV_PICTURE_TYPE_B
)
1642 || (avctx
->skip_frame
>= AVDISCARD_NONKEY
&& si
.type
!=AV_PICTURE_TYPE_I
)
1643 || avctx
->skip_frame
>= AVDISCARD_ALL
)
1647 if (si
.start
== 0) {
1648 if (s
->mb_num_left
> 0) {
1649 av_log(avctx
, AV_LOG_ERROR
, "New frame but still %d MB left.",
1652 ff_MPV_frame_end(s
);
1655 if (s
->width
!= si
.width
|| s
->height
!= si
.height
) {
1659 (s
->avctx
->active_thread_type
& FF_THREAD_FRAME
)) {
1660 av_log_missing_feature(s
->avctx
, "Width/height changing with "
1661 "frame threading is", 0);
1662 return AVERROR_PATCHWELCOME
;
1665 av_log(s
->avctx
, AV_LOG_WARNING
, "Changing dimensions to %dx%d\n",
1666 si
.width
, si
.height
);
1667 ff_MPV_common_end(s
);
1668 s
->width
= si
.width
;
1669 s
->height
= si
.height
;
1670 avcodec_set_dimensions(s
->avctx
, s
->width
, s
->height
);
1671 if ((err
= ff_MPV_common_init(s
)) < 0)
1673 if ((err
= rv34_decoder_realloc(r
)) < 0)
1676 s
->pict_type
= si
.type
? si
.type
: AV_PICTURE_TYPE_I
;
1677 if (ff_MPV_frame_start(s
, s
->avctx
) < 0)
1679 ff_er_frame_start(s
);
1680 if (!r
->tmp_b_block_base
) {
1683 r
->tmp_b_block_base
= av_malloc(s
->linesize
* 48);
1684 for (i
= 0; i
< 2; i
++)
1685 r
->tmp_b_block_y
[i
] = r
->tmp_b_block_base
1686 + i
* 16 * s
->linesize
;
1687 for (i
= 0; i
< 4; i
++)
1688 r
->tmp_b_block_uv
[i
] = r
->tmp_b_block_base
+ 32 * s
->linesize
1689 + (i
>> 1) * 8 * s
->uvlinesize
1692 r
->cur_pts
= si
.pts
;
1693 if (s
->pict_type
!= AV_PICTURE_TYPE_B
) {
1694 r
->last_pts
= r
->next_pts
;
1695 r
->next_pts
= r
->cur_pts
;
1697 int refdist
= GET_PTS_DIFF(r
->next_pts
, r
->last_pts
);
1698 int dist0
= GET_PTS_DIFF(r
->cur_pts
, r
->last_pts
);
1699 int dist1
= GET_PTS_DIFF(r
->next_pts
, r
->cur_pts
);
1702 r
->mv_weight1
= r
->mv_weight2
= r
->weight1
= r
->weight2
= 8192;
1703 r
->scaled_weight
= 0;
1705 r
->mv_weight1
= (dist0
<< 14) / refdist
;
1706 r
->mv_weight2
= (dist1
<< 14) / refdist
;
1707 if((r
->mv_weight1
|r
->mv_weight2
) & 511){
1708 r
->weight1
= r
->mv_weight1
;
1709 r
->weight2
= r
->mv_weight2
;
1710 r
->scaled_weight
= 0;
1712 r
->weight1
= r
->mv_weight1
>> 9;
1713 r
->weight2
= r
->mv_weight2
>> 9;
1714 r
->scaled_weight
= 1;
1718 s
->mb_x
= s
->mb_y
= 0;
1719 ff_thread_finish_setup(s
->avctx
);
1720 } else if (HAVE_THREADS
&&
1721 (s
->avctx
->active_thread_type
& FF_THREAD_FRAME
)) {
1722 av_log(s
->avctx
, AV_LOG_ERROR
, "Decoder needs full frames in frame "
1723 "multithreading mode (start MB is %d).\n", si
.start
);
1724 return AVERROR_INVALIDDATA
;
1727 for(i
= 0; i
< slice_count
; i
++){
1728 int offset
= get_slice_offset(avctx
, slices_hdr
, i
);
1730 if(i
+1 == slice_count
)
1731 size
= buf_size
- offset
;
1733 size
= get_slice_offset(avctx
, slices_hdr
, i
+1) - offset
;
1735 if(offset
< 0 || offset
> buf_size
){
1736 av_log(avctx
, AV_LOG_ERROR
, "Slice offset is invalid\n");
1740 r
->si
.end
= s
->mb_width
* s
->mb_height
;
1741 s
->mb_num_left
= r
->s
.mb_x
+ r
->s
.mb_y
*r
->s
.mb_width
- r
->si
.start
;
1743 if(i
+1 < slice_count
){
1744 if (get_slice_offset(avctx
, slices_hdr
, i
+1) < 0 ||
1745 get_slice_offset(avctx
, slices_hdr
, i
+1) > buf_size
) {
1746 av_log(avctx
, AV_LOG_ERROR
, "Slice offset is invalid\n");
1749 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);
1750 if(r
->parse_slice_header(r
, &r
->s
.gb
, &si
) < 0){
1751 if(i
+2 < slice_count
)
1752 size
= get_slice_offset(avctx
, slices_hdr
, i
+2) - offset
;
1754 size
= buf_size
- offset
;
1756 r
->si
.end
= si
.start
;
1758 if (size
< 0 || size
> buf_size
- offset
) {
1759 av_log(avctx
, AV_LOG_ERROR
, "Slice size is invalid\n");
1762 last
= rv34_decode_slice(r
, r
->si
.end
, buf
+ offset
, size
);
1767 if (s
->current_picture_ptr
) {
1770 r
->loop_filter(r
, s
->mb_height
- 1);
1772 *got_picture_ptr
= finish_frame(avctx
, pict
);
1773 } else if (HAVE_THREADS
&&
1774 (s
->avctx
->active_thread_type
& FF_THREAD_FRAME
)) {
1775 av_log(avctx
, AV_LOG_INFO
, "marking unfished frame as finished\n");
1776 /* always mark the current frame as finished, frame-mt supports
1777 * only complete frames */
1779 ff_MPV_frame_end(s
);
1781 ff_thread_report_progress(&s
->current_picture_ptr
->f
, INT_MAX
, 0);
1782 return AVERROR_INVALIDDATA
;
1789 av_cold
int ff_rv34_decode_end(AVCodecContext
*avctx
)
1791 RV34DecContext
*r
= avctx
->priv_data
;
1793 ff_MPV_common_end(&r
->s
);
1794 rv34_decoder_free(r
);