Directory: | ../../../ffmpeg/ |
---|---|
File: | src/libavcodec/rv34.c |
Date: | 2022-07-07 01:21:54 |
Exec | Total | Coverage | |
---|---|---|---|
Lines: | 927 | 1042 | 89.0% |
Branches: | 544 | 669 | 81.3% |
Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * RV30/40 decoder common data | ||
3 | * Copyright (c) 2007 Mike Melanson, Konstantin Shishkov | ||
4 | * | ||
5 | * This file is part of FFmpeg. | ||
6 | * | ||
7 | * FFmpeg is free software; you can redistribute it and/or | ||
8 | * modify it under the terms of the GNU Lesser General Public | ||
9 | * License as published by the Free Software Foundation; either | ||
10 | * version 2.1 of the License, or (at your option) any later version. | ||
11 | * | ||
12 | * FFmpeg is distributed in the hope that it will be useful, | ||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
15 | * Lesser General Public License for more details. | ||
16 | * | ||
17 | * You should have received a copy of the GNU Lesser General Public | ||
18 | * License along with FFmpeg; if not, write to the Free Software | ||
19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
20 | */ | ||
21 | |||
22 | /** | ||
23 | * @file | ||
24 | * RV30/40 decoder common data | ||
25 | */ | ||
26 | |||
27 | #include "libavutil/avassert.h" | ||
28 | #include "libavutil/imgutils.h" | ||
29 | #include "libavutil/internal.h" | ||
30 | #include "libavutil/mem_internal.h" | ||
31 | #include "libavutil/thread.h" | ||
32 | #include "libavutil/video_enc_params.h" | ||
33 | |||
34 | #include "avcodec.h" | ||
35 | #include "error_resilience.h" | ||
36 | #include "mpegutils.h" | ||
37 | #include "mpegvideo.h" | ||
38 | #include "mpegvideodec.h" | ||
39 | #include "golomb.h" | ||
40 | #include "internal.h" | ||
41 | #include "mathops.h" | ||
42 | #include "mpeg_er.h" | ||
43 | #include "qpeldsp.h" | ||
44 | #include "rectangle.h" | ||
45 | #include "thread.h" | ||
46 | #include "threadframe.h" | ||
47 | |||
48 | #include "rv34vlc.h" | ||
49 | #include "rv34data.h" | ||
50 | #include "rv34.h" | ||
51 | |||
52 | 454602 | static inline void ZERO8x2(void* dst, int stride) | |
53 | { | ||
54 | 454602 | fill_rectangle(dst, 1, 2, stride, 0, 4); | |
55 | 454602 | fill_rectangle(((uint8_t*)(dst))+4, 1, 2, stride, 0, 4); | |
56 | 454602 | } | |
57 | |||
58 | /** translation of RV30/40 macroblock types to lavc ones */ | ||
59 | static const int rv34_mb_type_to_lavc[12] = { | ||
60 | MB_TYPE_INTRA, | ||
61 | MB_TYPE_INTRA16x16 | MB_TYPE_SEPARATE_DC, | ||
62 | MB_TYPE_16x16 | MB_TYPE_L0, | ||
63 | MB_TYPE_8x8 | MB_TYPE_L0, | ||
64 | MB_TYPE_16x16 | MB_TYPE_L0, | ||
65 | MB_TYPE_16x16 | MB_TYPE_L1, | ||
66 | MB_TYPE_SKIP, | ||
67 | MB_TYPE_DIRECT2 | MB_TYPE_16x16, | ||
68 | MB_TYPE_16x8 | MB_TYPE_L0, | ||
69 | MB_TYPE_8x16 | MB_TYPE_L0, | ||
70 | MB_TYPE_16x16 | MB_TYPE_L0L1, | ||
71 | MB_TYPE_16x16 | MB_TYPE_L0 | MB_TYPE_SEPARATE_DC | ||
72 | }; | ||
73 | |||
74 | |||
75 | static RV34VLC intra_vlcs[NUM_INTRA_TABLES], inter_vlcs[NUM_INTER_TABLES]; | ||
76 | |||
77 | static int rv34_decode_mv(RV34DecContext *r, int block_type); | ||
78 | |||
79 | /** | ||
80 | * @name RV30/40 VLC generating functions | ||
81 | * @{ | ||
82 | */ | ||
83 | |||
84 | static VLCElem table_data[117592]; | ||
85 | |||
86 | /** | ||
87 | * Generate VLC from codeword lengths. | ||
88 | * @param bits codeword lengths (zeroes are accepted) | ||
89 | * @param size length of input data | ||
90 | * @param vlc output VLC | ||
91 | * @param insyms symbols for input codes (NULL for default ones) | ||
92 | * @param num VLC table number (for static initialization) | ||
93 | */ | ||
94 | 895 | static void rv34_gen_vlc(const uint8_t *bits, int size, VLC *vlc, const uint8_t *syms, | |
95 | int *offset) | ||
96 | { | ||
97 | 895 | int counts[17] = {0}, codes[17]; | |
98 | uint16_t cw[MAX_VLC_SIZE]; | ||
99 | int maxbits; | ||
100 | |||
101 |
2/2✓ Branch 0 taken 290320 times.
✓ Branch 1 taken 895 times.
|
291215 | for (int i = 0; i < size; i++) |
102 | 290320 | counts[bits[i]]++; | |
103 | |||
104 | /* bits[0] is zero for some tables, i.e. syms actually starts at 1. | ||
105 | * So we reset it here. The code assigned to this element is 0x00. */ | ||
106 | 895 | codes[0] = counts[0] = 0; | |
107 |
2/2✓ Branch 0 taken 14320 times.
✓ Branch 1 taken 895 times.
|
15215 | for (int i = 0; i < 16; i++) { |
108 | 14320 | codes[i+1] = (codes[i] + counts[i]) << 1; | |
109 |
2/2✓ Branch 0 taken 8095 times.
✓ Branch 1 taken 6225 times.
|
14320 | if (counts[i]) |
110 | 8095 | maxbits = i; | |
111 | } | ||
112 |
2/2✓ Branch 0 taken 290320 times.
✓ Branch 1 taken 895 times.
|
291215 | for (int i = 0; i < size; i++) |
113 | 290320 | cw[i] = codes[bits[i]]++; | |
114 | |||
115 | 895 | vlc->table = &table_data[*offset]; | |
116 | 895 | vlc->table_allocated = FF_ARRAY_ELEMS(table_data) - *offset; | |
117 | 895 | ff_init_vlc_sparse(vlc, FFMIN(maxbits, 9), size, | |
118 | bits, 1, 1, | ||
119 | cw, 2, 2, | ||
120 | syms, !!syms, !!syms, INIT_VLC_STATIC_OVERLONG); | ||
121 | 895 | *offset += vlc->table_size; | |
122 | 895 | } | |
123 | |||
124 | /** | ||
125 | * Initialize all tables. | ||
126 | */ | ||
127 | 5 | static av_cold void rv34_init_tables(void) | |
128 | { | ||
129 | 5 | int i, j, k, offset = 0; | |
130 | |||
131 |
2/2✓ Branch 0 taken 25 times.
✓ Branch 1 taken 5 times.
|
30 | for(i = 0; i < NUM_INTRA_TABLES; i++){ |
132 |
2/2✓ Branch 0 taken 50 times.
✓ Branch 1 taken 25 times.
|
75 | for(j = 0; j < 2; j++){ |
133 | 50 | rv34_gen_vlc(rv34_table_intra_cbppat [i][j], CBPPAT_VLC_SIZE, | |
134 | &intra_vlcs[i].cbppattern[j], NULL, &offset); | ||
135 | 50 | rv34_gen_vlc(rv34_table_intra_secondpat[i][j], OTHERBLK_VLC_SIZE, | |
136 | &intra_vlcs[i].second_pattern[j], NULL, &offset); | ||
137 | 50 | rv34_gen_vlc(rv34_table_intra_thirdpat [i][j], OTHERBLK_VLC_SIZE, | |
138 | &intra_vlcs[i].third_pattern[j], NULL, &offset); | ||
139 |
2/2✓ Branch 0 taken 200 times.
✓ Branch 1 taken 50 times.
|
250 | for(k = 0; k < 4; k++){ |
140 | 200 | rv34_gen_vlc(rv34_table_intra_cbp[i][j+k*2], CBP_VLC_SIZE, | |
141 | &intra_vlcs[i].cbp[j][k], rv34_cbp_code, &offset); | ||
142 | } | ||
143 | } | ||
144 |
2/2✓ Branch 0 taken 100 times.
✓ Branch 1 taken 25 times.
|
125 | for(j = 0; j < 4; j++){ |
145 | 100 | rv34_gen_vlc(rv34_table_intra_firstpat[i][j], FIRSTBLK_VLC_SIZE, | |
146 | &intra_vlcs[i].first_pattern[j], NULL, &offset); | ||
147 | } | ||
148 | 25 | rv34_gen_vlc(rv34_intra_coeff[i], COEFF_VLC_SIZE, | |
149 | &intra_vlcs[i].coefficient, NULL, &offset); | ||
150 | } | ||
151 | |||
152 |
2/2✓ Branch 0 taken 35 times.
✓ Branch 1 taken 5 times.
|
40 | for(i = 0; i < NUM_INTER_TABLES; i++){ |
153 | 35 | rv34_gen_vlc(rv34_inter_cbppat[i], CBPPAT_VLC_SIZE, | |
154 | &inter_vlcs[i].cbppattern[0], NULL, &offset); | ||
155 |
2/2✓ Branch 0 taken 140 times.
✓ Branch 1 taken 35 times.
|
175 | for(j = 0; j < 4; j++){ |
156 | 140 | rv34_gen_vlc(rv34_inter_cbp[i][j], CBP_VLC_SIZE, | |
157 | &inter_vlcs[i].cbp[0][j], rv34_cbp_code, &offset); | ||
158 | } | ||
159 |
2/2✓ Branch 0 taken 70 times.
✓ Branch 1 taken 35 times.
|
105 | for(j = 0; j < 2; j++){ |
160 | 70 | rv34_gen_vlc(rv34_table_inter_firstpat [i][j], FIRSTBLK_VLC_SIZE, | |
161 | &inter_vlcs[i].first_pattern[j], NULL, &offset); | ||
162 | 70 | rv34_gen_vlc(rv34_table_inter_secondpat[i][j], OTHERBLK_VLC_SIZE, | |
163 | &inter_vlcs[i].second_pattern[j], NULL, &offset); | ||
164 | 70 | rv34_gen_vlc(rv34_table_inter_thirdpat [i][j], OTHERBLK_VLC_SIZE, | |
165 | &inter_vlcs[i].third_pattern[j], NULL, &offset); | ||
166 | } | ||
167 | 35 | rv34_gen_vlc(rv34_inter_coeff[i], COEFF_VLC_SIZE, | |
168 | &inter_vlcs[i].coefficient, NULL, &offset); | ||
169 | } | ||
170 | 5 | } | |
171 | |||
172 | /** @} */ // vlc group | ||
173 | |||
174 | /** | ||
175 | * @name RV30/40 4x4 block decoding functions | ||
176 | * @{ | ||
177 | */ | ||
178 | |||
179 | /** | ||
180 | * Decode coded block pattern. | ||
181 | */ | ||
182 | 129189 | static int rv34_decode_cbp(GetBitContext *gb, RV34VLC *vlc, int table) | |
183 | { | ||
184 | 129189 | int pattern, code, cbp=0; | |
185 | int ones; | ||
186 | static const int cbp_masks[3] = {0x100000, 0x010000, 0x110000}; | ||
187 | static const int shifts[4] = { 0, 2, 8, 10 }; | ||
188 | 129189 | const int *curshift = shifts; | |
189 | int i, t, mask; | ||
190 | |||
191 | 129189 | code = get_vlc2(gb, vlc->cbppattern[table].table, 9, 2); | |
192 | 129189 | pattern = code & 0xF; | |
193 | 129189 | code >>= 4; | |
194 | |||
195 | 129189 | ones = rv34_count_ones[pattern]; | |
196 | |||
197 |
2/2✓ Branch 0 taken 516756 times.
✓ Branch 1 taken 129189 times.
|
645945 | for(mask = 8; mask; mask >>= 1, curshift++){ |
198 |
2/2✓ Branch 0 taken 181416 times.
✓ Branch 1 taken 335340 times.
|
516756 | if(pattern & mask) |
199 | 181416 | cbp |= get_vlc2(gb, vlc->cbp[table][ones].table, vlc->cbp[table][ones].bits, 1) << curshift[0]; | |
200 | } | ||
201 | |||
202 |
2/2✓ Branch 0 taken 516756 times.
✓ Branch 1 taken 129189 times.
|
645945 | for(i = 0; i < 4; i++){ |
203 | 516756 | t = (modulo_three_table[code] >> (6 - 2*i)) & 3; | |
204 |
2/2✓ Branch 0 taken 121158 times.
✓ Branch 1 taken 395598 times.
|
516756 | if(t == 1) |
205 | 121158 | cbp |= cbp_masks[get_bits1(gb)] << i; | |
206 |
2/2✓ Branch 0 taken 59165 times.
✓ Branch 1 taken 457591 times.
|
516756 | if(t == 2) |
207 | 59165 | cbp |= cbp_masks[2] << i; | |
208 | } | ||
209 | 129189 | return cbp; | |
210 | } | ||
211 | |||
212 | /** | ||
213 | * Get one coefficient value from the bitstream and store it. | ||
214 | */ | ||
215 | 2269770 | static inline void decode_coeff(int16_t *dst, int coef, int esc, GetBitContext *gb, VLC* vlc, int q) | |
216 | { | ||
217 |
2/2✓ Branch 0 taken 1158695 times.
✓ Branch 1 taken 1111075 times.
|
2269770 | if(coef){ |
218 |
2/2✓ Branch 0 taken 158483 times.
✓ Branch 1 taken 1000212 times.
|
1158695 | if(coef == esc){ |
219 | 158483 | coef = get_vlc2(gb, vlc->table, 9, 2); | |
220 |
2/2✓ Branch 0 taken 139 times.
✓ Branch 1 taken 158344 times.
|
158483 | if(coef > 23){ |
221 | 139 | coef -= 23; | |
222 | 139 | coef = 22 + ((1 << coef) | get_bits(gb, coef)); | |
223 | } | ||
224 | 158483 | coef += esc; | |
225 | } | ||
226 |
2/2✓ Branch 1 taken 572454 times.
✓ Branch 2 taken 586241 times.
|
1158695 | if(get_bits1(gb)) |
227 | 572454 | coef = -coef; | |
228 | 1158695 | *dst = (coef*q + 8) >> 4; | |
229 | } | ||
230 | 2269770 | } | |
231 | |||
232 | /** | ||
233 | * Decode 2x2 subblock of coefficients. | ||
234 | */ | ||
235 | 134059 | static inline void decode_subblock(int16_t *dst, int code, const int is_block2, GetBitContext *gb, VLC *vlc, int q) | |
236 | { | ||
237 | 134059 | int flags = modulo_three_table[code]; | |
238 | |||
239 | 134059 | decode_coeff( dst+0*4+0, (flags >> 6) , 3, gb, vlc, q); | |
240 |
2/2✓ Branch 0 taken 83261 times.
✓ Branch 1 taken 50798 times.
|
134059 | if(is_block2){ |
241 | 83261 | decode_coeff(dst+1*4+0, (flags >> 4) & 3, 2, gb, vlc, q); | |
242 | 83261 | decode_coeff(dst+0*4+1, (flags >> 2) & 3, 2, gb, vlc, q); | |
243 | }else{ | ||
244 | 50798 | decode_coeff(dst+0*4+1, (flags >> 4) & 3, 2, gb, vlc, q); | |
245 | 50798 | decode_coeff(dst+1*4+0, (flags >> 2) & 3, 2, gb, vlc, q); | |
246 | } | ||
247 | 134059 | decode_coeff( dst+1*4+1, (flags >> 0) & 3, 2, gb, vlc, q); | |
248 | 134059 | } | |
249 | |||
250 | /** | ||
251 | * Decode a single coefficient. | ||
252 | */ | ||
253 | 404286 | static inline void decode_subblock1(int16_t *dst, int code, GetBitContext *gb, VLC *vlc, int q) | |
254 | { | ||
255 | 404286 | int coeff = modulo_three_table[code] >> 6; | |
256 | 404286 | decode_coeff(dst, coeff, 3, gb, vlc, q); | |
257 | 404286 | } | |
258 | |||
259 | 332312 | static inline void decode_subblock3(int16_t *dst, int code, GetBitContext *gb, VLC *vlc, | |
260 | int q_dc, int q_ac1, int q_ac2) | ||
261 | { | ||
262 | 332312 | int flags = modulo_three_table[code]; | |
263 | |||
264 | 332312 | decode_coeff(dst+0*4+0, (flags >> 6) , 3, gb, vlc, q_dc); | |
265 | 332312 | decode_coeff(dst+0*4+1, (flags >> 4) & 3, 2, gb, vlc, q_ac1); | |
266 | 332312 | decode_coeff(dst+1*4+0, (flags >> 2) & 3, 2, gb, vlc, q_ac1); | |
267 | 332312 | decode_coeff(dst+1*4+1, (flags >> 0) & 3, 2, gb, vlc, q_ac2); | |
268 | 332312 | } | |
269 | |||
270 | /** | ||
271 | * Decode coefficients for 4x4 block. | ||
272 | * | ||
273 | * This is done by filling 2x2 subblocks with decoded coefficients | ||
274 | * in this order (the same for subblocks and subblock coefficients): | ||
275 | * o--o | ||
276 | * / | ||
277 | * / | ||
278 | * o--o | ||
279 | */ | ||
280 | |||
281 | 736598 | static int rv34_decode_block(int16_t *dst, GetBitContext *gb, RV34VLC *rvlc, int fc, int sc, int q_dc, int q_ac1, int q_ac2) | |
282 | { | ||
283 | 736598 | int code, pattern, has_ac = 1; | |
284 | |||
285 | 736598 | code = get_vlc2(gb, rvlc->first_pattern[fc].table, 9, 2); | |
286 | |||
287 | 736598 | pattern = code & 0x7; | |
288 | |||
289 | 736598 | code >>= 3; | |
290 | |||
291 |
2/2✓ Branch 0 taken 332312 times.
✓ Branch 1 taken 404286 times.
|
736598 | if (modulo_three_table[code] & 0x3F) { |
292 | 332312 | decode_subblock3(dst, code, gb, &rvlc->coefficient, q_dc, q_ac1, q_ac2); | |
293 | } else { | ||
294 | 404286 | decode_subblock1(dst, code, gb, &rvlc->coefficient, q_dc); | |
295 |
2/2✓ Branch 0 taken 363407 times.
✓ Branch 1 taken 40879 times.
|
404286 | if (!pattern) |
296 | 363407 | return 0; | |
297 | 40879 | has_ac = 0; | |
298 | } | ||
299 | |||
300 |
2/2✓ Branch 0 taken 44632 times.
✓ Branch 1 taken 328559 times.
|
373191 | if(pattern & 4){ |
301 | 44632 | code = get_vlc2(gb, rvlc->second_pattern[sc].table, 9, 2); | |
302 | 44632 | decode_subblock(dst + 4*0+2, code, 0, gb, &rvlc->coefficient, q_ac2); | |
303 | } | ||
304 |
2/2✓ Branch 0 taken 83261 times.
✓ Branch 1 taken 289930 times.
|
373191 | if(pattern & 2){ // Looks like coefficients 1 and 2 are swapped for this block |
305 | 83261 | code = get_vlc2(gb, rvlc->second_pattern[sc].table, 9, 2); | |
306 | 83261 | decode_subblock(dst + 4*2+0, code, 1, gb, &rvlc->coefficient, q_ac2); | |
307 | } | ||
308 |
2/2✓ Branch 0 taken 6166 times.
✓ Branch 1 taken 367025 times.
|
373191 | if(pattern & 1){ |
309 | 6166 | code = get_vlc2(gb, rvlc->third_pattern[sc].table, 9, 2); | |
310 | 6166 | decode_subblock(dst + 4*2+2, code, 0, gb, &rvlc->coefficient, q_ac2); | |
311 | } | ||
312 | 373191 | return has_ac | pattern; | |
313 | } | ||
314 | |||
315 | /** | ||
316 | * @name RV30/40 bitstream parsing | ||
317 | * @{ | ||
318 | */ | ||
319 | |||
320 | /** | ||
321 | * Decode starting slice position. | ||
322 | * @todo Maybe replace with ff_h263_decode_mba() ? | ||
323 | */ | ||
324 | 2770 | int ff_rv34_get_start_offset(GetBitContext *gb, int mb_size) | |
325 | { | ||
326 | int i; | ||
327 |
1/2✓ Branch 0 taken 10368 times.
✗ Branch 1 not taken.
|
10368 | for(i = 0; i < 5; i++) |
328 |
2/2✓ Branch 0 taken 2770 times.
✓ Branch 1 taken 7598 times.
|
10368 | if(rv34_mb_max_sizes[i] >= mb_size - 1) |
329 | 2770 | break; | |
330 | 2770 | return rv34_mb_bits_sizes[i]; | |
331 | } | ||
332 | |||
333 | /** | ||
334 | * Select VLC set for decoding from current quantizer, modifier and frame type. | ||
335 | */ | ||
336 | 130283 | static inline RV34VLC* choose_vlc_set(int quant, int mod, int type) | |
337 | { | ||
338 |
4/4✓ Branch 0 taken 60544 times.
✓ Branch 1 taken 69739 times.
✓ Branch 2 taken 60067 times.
✓ Branch 3 taken 477 times.
|
130283 | if(mod == 2 && quant < 19) quant += 10; |
339 |
3/4✓ Branch 0 taken 24166 times.
✓ Branch 1 taken 46050 times.
✓ Branch 2 taken 24166 times.
✗ Branch 3 not taken.
|
70216 | else if(mod && quant < 26) quant += 5; |
340 | av_assert2(quant >= 0 && quant < 32); | ||
341 | 97819 | return type ? &inter_vlcs[rv34_quant_to_vlc_set[1][quant]] | |
342 |
2/2✓ Branch 0 taken 97819 times.
✓ Branch 1 taken 32464 times.
|
130283 | : &intra_vlcs[rv34_quant_to_vlc_set[0][quant]]; |
343 | } | ||
344 | |||
345 | /** | ||
346 | * Decode intra macroblock header and return CBP in case of success, -1 otherwise. | ||
347 | */ | ||
348 | 7640 | static int rv34_decode_intra_mb_header(RV34DecContext *r, int8_t *intra_types) | |
349 | { | ||
350 | 7640 | MpegEncContext *s = &r->s; | |
351 | 7640 | GetBitContext *gb = &s->gb; | |
352 | 7640 | int mb_pos = s->mb_x + s->mb_y * s->mb_stride; | |
353 | int t; | ||
354 | |||
355 | 7640 | r->is16 = get_bits1(gb); | |
356 |
2/2✓ Branch 0 taken 5830 times.
✓ Branch 1 taken 1810 times.
|
7640 | if(r->is16){ |
357 | 5830 | s->current_picture_ptr->mb_type[mb_pos] = MB_TYPE_INTRA16x16; | |
358 | 5830 | r->block_type = RV34_MB_TYPE_INTRA16x16; | |
359 | 5830 | t = get_bits(gb, 2); | |
360 | 5830 | fill_rectangle(intra_types, 4, 4, r->intra_types_stride, t, sizeof(intra_types[0])); | |
361 | 5830 | r->luma_vlc = 2; | |
362 | }else{ | ||
363 |
2/2✓ Branch 0 taken 467 times.
✓ Branch 1 taken 1343 times.
|
1810 | if(!r->rv30){ |
364 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 467 times.
|
467 | if(!get_bits1(gb)) |
365 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Need DQUANT\n"); | |
366 | } | ||
367 | 1810 | s->current_picture_ptr->mb_type[mb_pos] = MB_TYPE_INTRA; | |
368 | 1810 | r->block_type = RV34_MB_TYPE_INTRA; | |
369 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1810 times.
|
1810 | if(r->decode_intra_types(r, gb, intra_types) < 0) |
370 | ✗ | return -1; | |
371 | 1810 | r->luma_vlc = 1; | |
372 | } | ||
373 | |||
374 | 7640 | r->chroma_vlc = 0; | |
375 | 7640 | r->cur_vlcs = choose_vlc_set(r->si.quant, r->si.vlc_set, 0); | |
376 | |||
377 | 7640 | return rv34_decode_cbp(gb, r->cur_vlcs, r->is16); | |
378 | } | ||
379 | |||
380 | /** | ||
381 | * Decode inter macroblock header and return CBP in case of success, -1 otherwise. | ||
382 | */ | ||
383 | 284640 | static int rv34_decode_inter_mb_header(RV34DecContext *r, int8_t *intra_types) | |
384 | { | ||
385 | 284640 | MpegEncContext *s = &r->s; | |
386 | 284640 | GetBitContext *gb = &s->gb; | |
387 | 284640 | int mb_pos = s->mb_x + s->mb_y * s->mb_stride; | |
388 | int i, t; | ||
389 | |||
390 | 284640 | r->block_type = r->decode_mb_info(r); | |
391 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 284640 times.
|
284640 | if(r->block_type == -1) |
392 | ✗ | return -1; | |
393 | 284640 | s->current_picture_ptr->mb_type[mb_pos] = rv34_mb_type_to_lavc[r->block_type]; | |
394 | 284640 | r->mb_type[mb_pos] = r->block_type; | |
395 |
2/2✓ Branch 0 taken 163091 times.
✓ Branch 1 taken 121549 times.
|
284640 | if(r->block_type == RV34_MB_SKIP){ |
396 |
2/2✓ Branch 0 taken 31305 times.
✓ Branch 1 taken 131786 times.
|
163091 | if(s->pict_type == AV_PICTURE_TYPE_P) |
397 | 31305 | r->mb_type[mb_pos] = RV34_MB_P_16x16; | |
398 |
2/2✓ Branch 0 taken 131786 times.
✓ Branch 1 taken 31305 times.
|
163091 | if(s->pict_type == AV_PICTURE_TYPE_B) |
399 | 131786 | r->mb_type[mb_pos] = RV34_MB_B_DIRECT; | |
400 | } | ||
401 | 284640 | r->is16 = !!IS_INTRA16x16(s->current_picture_ptr->mb_type[mb_pos]); | |
402 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 284640 times.
|
284640 | if (rv34_decode_mv(r, r->block_type) < 0) |
403 | ✗ | return -1; | |
404 |
2/2✓ Branch 0 taken 163091 times.
✓ Branch 1 taken 121549 times.
|
284640 | if(r->block_type == RV34_MB_SKIP){ |
405 | 163091 | fill_rectangle(intra_types, 4, 4, r->intra_types_stride, 0, sizeof(intra_types[0])); | |
406 | 163091 | return 0; | |
407 | } | ||
408 | 121549 | r->chroma_vlc = 1; | |
409 | 121549 | r->luma_vlc = 0; | |
410 | |||
411 |
2/2✓ Branch 0 taken 24277 times.
✓ Branch 1 taken 97272 times.
|
121549 | if(IS_INTRA(s->current_picture_ptr->mb_type[mb_pos])){ |
412 |
2/2✓ Branch 0 taken 10976 times.
✓ Branch 1 taken 13301 times.
|
24277 | if(r->is16){ |
413 | 10976 | t = get_bits(gb, 2); | |
414 | 10976 | fill_rectangle(intra_types, 4, 4, r->intra_types_stride, t, sizeof(intra_types[0])); | |
415 | 10976 | r->luma_vlc = 2; | |
416 | }else{ | ||
417 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 13301 times.
|
13301 | if(r->decode_intra_types(r, gb, intra_types) < 0) |
418 | ✗ | return -1; | |
419 | 13301 | r->luma_vlc = 1; | |
420 | } | ||
421 | 24277 | r->chroma_vlc = 0; | |
422 | 24277 | r->cur_vlcs = choose_vlc_set(r->si.quant, r->si.vlc_set, 0); | |
423 | }else{ | ||
424 |
2/2✓ Branch 0 taken 1556352 times.
✓ Branch 1 taken 97272 times.
|
1653624 | for(i = 0; i < 16; i++) |
425 | 1556352 | intra_types[(i & 3) + (i>>2) * r->intra_types_stride] = 0; | |
426 | 97272 | r->cur_vlcs = choose_vlc_set(r->si.quant, r->si.vlc_set, 1); | |
427 |
2/2✓ Branch 0 taken 547 times.
✓ Branch 1 taken 96725 times.
|
97272 | if(r->mb_type[mb_pos] == RV34_MB_P_MIX16x16){ |
428 | 547 | r->is16 = 1; | |
429 | 547 | r->chroma_vlc = 1; | |
430 | 547 | r->luma_vlc = 2; | |
431 | 547 | r->cur_vlcs = choose_vlc_set(r->si.quant, r->si.vlc_set, 0); | |
432 | } | ||
433 | } | ||
434 | |||
435 | 121549 | return rv34_decode_cbp(gb, r->cur_vlcs, r->is16); | |
436 | } | ||
437 | |||
438 | /** @} */ //bitstream functions | ||
439 | |||
440 | /** | ||
441 | * @name motion vector related code (prediction, reconstruction, motion compensation) | ||
442 | * @{ | ||
443 | */ | ||
444 | |||
445 | /** macroblock partition width in 8x8 blocks */ | ||
446 | static const uint8_t part_sizes_w[RV34_MB_TYPES] = { 2, 2, 2, 1, 2, 2, 2, 2, 2, 1, 2, 2 }; | ||
447 | |||
448 | /** macroblock partition height in 8x8 blocks */ | ||
449 | static const uint8_t part_sizes_h[RV34_MB_TYPES] = { 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2 }; | ||
450 | |||
451 | /** availability index for subblocks */ | ||
452 | static const uint8_t avail_indexes[4] = { 6, 7, 10, 11 }; | ||
453 | |||
454 | /** | ||
455 | * motion vector prediction | ||
456 | * | ||
457 | * Motion prediction performed for the block by using median prediction of | ||
458 | * motion vectors from the left, top and right top blocks but in corner cases | ||
459 | * some other vectors may be used instead. | ||
460 | */ | ||
461 | 42620 | static void rv34_pred_mv(RV34DecContext *r, int block_type, int subblock_no, int dmv_no) | |
462 | { | ||
463 | 42620 | MpegEncContext *s = &r->s; | |
464 | 42620 | int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride; | |
465 | 42620 | int A[2] = {0}, B[2], C[2]; | |
466 | int i, j; | ||
467 | int mx, my; | ||
468 | 42620 | int* avail = r->avail_cache + avail_indexes[subblock_no]; | |
469 | 42620 | int c_off = part_sizes_w[block_type]; | |
470 | |||
471 | 42620 | mv_pos += (subblock_no & 1) + (subblock_no >> 1)*s->b8_stride; | |
472 |
2/2✓ Branch 0 taken 4526 times.
✓ Branch 1 taken 38094 times.
|
42620 | if(subblock_no == 3) |
473 | 4526 | c_off = -1; | |
474 | |||
475 |
2/2✓ Branch 0 taken 41140 times.
✓ Branch 1 taken 1480 times.
|
42620 | if(avail[-1]){ |
476 | 41140 | A[0] = s->current_picture_ptr->motion_val[0][mv_pos-1][0]; | |
477 | 41140 | A[1] = s->current_picture_ptr->motion_val[0][mv_pos-1][1]; | |
478 | } | ||
479 |
2/2✓ Branch 0 taken 30363 times.
✓ Branch 1 taken 12257 times.
|
42620 | if(avail[-4]){ |
480 | 30363 | B[0] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride][0]; | |
481 | 30363 | B[1] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride][1]; | |
482 | }else{ | ||
483 | 12257 | B[0] = A[0]; | |
484 | 12257 | B[1] = A[1]; | |
485 | } | ||
486 |
2/2✓ Branch 0 taken 13924 times.
✓ Branch 1 taken 28696 times.
|
42620 | if(!avail[c_off-4]){ |
487 |
5/6✓ Branch 0 taken 1865 times.
✓ Branch 1 taken 12059 times.
✓ Branch 2 taken 52 times.
✓ Branch 3 taken 1813 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 52 times.
|
13924 | if(avail[-4] && (avail[-1] || r->rv30)){ |
488 | 1813 | C[0] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride-1][0]; | |
489 | 1813 | C[1] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride-1][1]; | |
490 | }else{ | ||
491 | 12111 | C[0] = A[0]; | |
492 | 12111 | C[1] = A[1]; | |
493 | } | ||
494 | }else{ | ||
495 | 28696 | C[0] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride+c_off][0]; | |
496 | 28696 | C[1] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride+c_off][1]; | |
497 | } | ||
498 | 42620 | mx = mid_pred(A[0], B[0], C[0]); | |
499 | 42620 | my = mid_pred(A[1], B[1], C[1]); | |
500 | 42620 | mx += r->dmv[dmv_no][0]; | |
501 | 42620 | my += r->dmv[dmv_no][1]; | |
502 |
2/2✓ Branch 0 taken 64444 times.
✓ Branch 1 taken 42620 times.
|
107064 | for(j = 0; j < part_sizes_h[block_type]; j++){ |
503 |
2/2✓ Branch 0 taken 100892 times.
✓ Branch 1 taken 64444 times.
|
165336 | for(i = 0; i < part_sizes_w[block_type]; i++){ |
504 | 100892 | s->current_picture_ptr->motion_val[0][mv_pos + i + j*s->b8_stride][0] = mx; | |
505 | 100892 | s->current_picture_ptr->motion_val[0][mv_pos + i + j*s->b8_stride][1] = my; | |
506 | } | ||
507 | } | ||
508 | 42620 | } | |
509 | |||
510 | #define GET_PTS_DIFF(a, b) (((a) - (b) + 8192) & 0x1FFF) | ||
511 | |||
512 | /** | ||
513 | * Calculate motion vector component that should be added for direct blocks. | ||
514 | */ | ||
515 | 802736 | static int calc_add_mv(RV34DecContext *r, int dir, int val) | |
516 | { | ||
517 |
2/2✓ Branch 0 taken 401368 times.
✓ Branch 1 taken 401368 times.
|
802736 | int mul = dir ? -r->mv_weight2 : r->mv_weight1; |
518 | |||
519 | 802736 | return (int)(val * (SUINT)mul + 0x2000) >> 14; | |
520 | } | ||
521 | |||
522 | /** | ||
523 | * Predict motion vector for B-frame macroblock. | ||
524 | */ | ||
525 | 47002 | static inline void rv34_pred_b_vector(int A[2], int B[2], int C[2], | |
526 | int A_avail, int B_avail, int C_avail, | ||
527 | int *mx, int *my) | ||
528 | { | ||
529 |
2/2✓ Branch 0 taken 34307 times.
✓ Branch 1 taken 12695 times.
|
47002 | if(A_avail + B_avail + C_avail != 3){ |
530 | 34307 | *mx = A[0] + B[0] + C[0]; | |
531 | 34307 | *my = A[1] + B[1] + C[1]; | |
532 |
2/2✓ Branch 0 taken 11581 times.
✓ Branch 1 taken 22726 times.
|
34307 | if(A_avail + B_avail + C_avail == 2){ |
533 | 11581 | *mx /= 2; | |
534 | 11581 | *my /= 2; | |
535 | } | ||
536 | }else{ | ||
537 | 12695 | *mx = mid_pred(A[0], B[0], C[0]); | |
538 | 12695 | *my = mid_pred(A[1], B[1], C[1]); | |
539 | } | ||
540 | 47002 | } | |
541 | |||
542 | /** | ||
543 | * motion vector prediction for B-frames | ||
544 | */ | ||
545 | 47002 | static void rv34_pred_mv_b(RV34DecContext *r, int block_type, int dir) | |
546 | { | ||
547 | 47002 | MpegEncContext *s = &r->s; | |
548 | 47002 | int mb_pos = s->mb_x + s->mb_y * s->mb_stride; | |
549 | 47002 | int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride; | |
550 | 47002 | int A[2] = { 0 }, B[2] = { 0 }, C[2] = { 0 }; | |
551 | 47002 | int has_A = 0, has_B = 0, has_C = 0; | |
552 | int mx, my; | ||
553 | int i, j; | ||
554 | 47002 | Picture *cur_pic = s->current_picture_ptr; | |
555 |
2/2✓ Branch 0 taken 24420 times.
✓ Branch 1 taken 22582 times.
|
47002 | const int mask = dir ? MB_TYPE_L1 : MB_TYPE_L0; |
556 | 47002 | int type = cur_pic->mb_type[mb_pos]; | |
557 | |||
558 |
2/2✓ Branch 0 taken 29561 times.
✓ Branch 1 taken 17441 times.
|
47002 | if((r->avail_cache[6-1] & type) & mask){ |
559 | 29561 | A[0] = cur_pic->motion_val[dir][mv_pos - 1][0]; | |
560 | 29561 | A[1] = cur_pic->motion_val[dir][mv_pos - 1][1]; | |
561 | 29561 | has_A = 1; | |
562 | } | ||
563 |
2/2✓ Branch 0 taken 24041 times.
✓ Branch 1 taken 22961 times.
|
47002 | if((r->avail_cache[6-4] & type) & mask){ |
564 | 24041 | B[0] = cur_pic->motion_val[dir][mv_pos - s->b8_stride][0]; | |
565 | 24041 | B[1] = cur_pic->motion_val[dir][mv_pos - s->b8_stride][1]; | |
566 | 24041 | has_B = 1; | |
567 | } | ||
568 |
4/4✓ Branch 0 taken 40457 times.
✓ Branch 1 taken 6545 times.
✓ Branch 2 taken 21963 times.
✓ Branch 3 taken 18494 times.
|
47002 | if(r->avail_cache[6-4] && (r->avail_cache[6-2] & type) & mask){ |
569 | 21963 | C[0] = cur_pic->motion_val[dir][mv_pos - s->b8_stride + 2][0]; | |
570 | 21963 | C[1] = cur_pic->motion_val[dir][mv_pos - s->b8_stride + 2][1]; | |
571 | 21963 | has_C = 1; | |
572 |
4/4✓ Branch 0 taken 906 times.
✓ Branch 1 taken 24133 times.
✓ Branch 2 taken 386 times.
✓ Branch 3 taken 520 times.
|
25039 | }else if((s->mb_x+1) == s->mb_width && (r->avail_cache[6-5] & type) & mask){ |
573 | 386 | C[0] = cur_pic->motion_val[dir][mv_pos - s->b8_stride - 1][0]; | |
574 | 386 | C[1] = cur_pic->motion_val[dir][mv_pos - s->b8_stride - 1][1]; | |
575 | 386 | has_C = 1; | |
576 | } | ||
577 | |||
578 | 47002 | rv34_pred_b_vector(A, B, C, has_A, has_B, has_C, &mx, &my); | |
579 | |||
580 | 47002 | mx += r->dmv[dir][0]; | |
581 | 47002 | my += r->dmv[dir][1]; | |
582 | |||
583 |
2/2✓ Branch 0 taken 94004 times.
✓ Branch 1 taken 47002 times.
|
141006 | for(j = 0; j < 2; j++){ |
584 |
2/2✓ Branch 0 taken 188008 times.
✓ Branch 1 taken 94004 times.
|
282012 | for(i = 0; i < 2; i++){ |
585 | 188008 | cur_pic->motion_val[dir][mv_pos + i + j*s->b8_stride][0] = mx; | |
586 | 188008 | cur_pic->motion_val[dir][mv_pos + i + j*s->b8_stride][1] = my; | |
587 | } | ||
588 | } | ||
589 |
4/4✓ Branch 0 taken 31845 times.
✓ Branch 1 taken 15157 times.
✓ Branch 2 taken 13319 times.
✓ Branch 3 taken 18526 times.
|
47002 | if(block_type == RV34_MB_B_BACKWARD || block_type == RV34_MB_B_FORWARD){ |
590 | 28476 | ZERO8x2(cur_pic->motion_val[!dir][mv_pos], s->b8_stride); | |
591 | } | ||
592 | 47002 | } | |
593 | |||
594 | /** | ||
595 | * motion vector prediction - RV3 version | ||
596 | */ | ||
597 | 9134 | static void rv34_pred_mv_rv3(RV34DecContext *r, int block_type, int dir) | |
598 | { | ||
599 | 9134 | MpegEncContext *s = &r->s; | |
600 | 9134 | int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride; | |
601 | 9134 | int A[2] = {0}, B[2], C[2]; | |
602 | int i, j, k; | ||
603 | int mx, my; | ||
604 | 9134 | int* avail = r->avail_cache + avail_indexes[0]; | |
605 | |||
606 |
2/2✓ Branch 0 taken 8666 times.
✓ Branch 1 taken 468 times.
|
9134 | if(avail[-1]){ |
607 | 8666 | A[0] = s->current_picture_ptr->motion_val[0][mv_pos - 1][0]; | |
608 | 8666 | A[1] = s->current_picture_ptr->motion_val[0][mv_pos - 1][1]; | |
609 | } | ||
610 |
2/2✓ Branch 0 taken 8618 times.
✓ Branch 1 taken 516 times.
|
9134 | if(avail[-4]){ |
611 | 8618 | B[0] = s->current_picture_ptr->motion_val[0][mv_pos - s->b8_stride][0]; | |
612 | 8618 | B[1] = s->current_picture_ptr->motion_val[0][mv_pos - s->b8_stride][1]; | |
613 | }else{ | ||
614 | 516 | B[0] = A[0]; | |
615 | 516 | B[1] = A[1]; | |
616 | } | ||
617 |
2/2✓ Branch 0 taken 950 times.
✓ Branch 1 taken 8184 times.
|
9134 | if(!avail[-4 + 2]){ |
618 |
3/4✓ Branch 0 taken 434 times.
✓ Branch 1 taken 516 times.
✓ Branch 2 taken 434 times.
✗ Branch 3 not taken.
|
950 | if(avail[-4] && (avail[-1])){ |
619 | 434 | C[0] = s->current_picture_ptr->motion_val[0][mv_pos - s->b8_stride - 1][0]; | |
620 | 434 | C[1] = s->current_picture_ptr->motion_val[0][mv_pos - s->b8_stride - 1][1]; | |
621 | }else{ | ||
622 | 516 | C[0] = A[0]; | |
623 | 516 | C[1] = A[1]; | |
624 | } | ||
625 | }else{ | ||
626 | 8184 | C[0] = s->current_picture_ptr->motion_val[0][mv_pos - s->b8_stride + 2][0]; | |
627 | 8184 | C[1] = s->current_picture_ptr->motion_val[0][mv_pos - s->b8_stride + 2][1]; | |
628 | } | ||
629 | 9134 | mx = mid_pred(A[0], B[0], C[0]); | |
630 | 9134 | my = mid_pred(A[1], B[1], C[1]); | |
631 | 9134 | mx += r->dmv[0][0]; | |
632 | 9134 | my += r->dmv[0][1]; | |
633 |
2/2✓ Branch 0 taken 18268 times.
✓ Branch 1 taken 9134 times.
|
27402 | for(j = 0; j < 2; j++){ |
634 |
2/2✓ Branch 0 taken 36536 times.
✓ Branch 1 taken 18268 times.
|
54804 | for(i = 0; i < 2; i++){ |
635 |
2/2✓ Branch 0 taken 73072 times.
✓ Branch 1 taken 36536 times.
|
109608 | for(k = 0; k < 2; k++){ |
636 | 73072 | s->current_picture_ptr->motion_val[k][mv_pos + i + j*s->b8_stride][0] = mx; | |
637 | 73072 | s->current_picture_ptr->motion_val[k][mv_pos + i + j*s->b8_stride][1] = my; | |
638 | } | ||
639 | } | ||
640 | } | ||
641 | 9134 | } | |
642 | |||
643 | static const int chroma_coeffs[3] = { 0, 3, 5 }; | ||
644 | |||
645 | /** | ||
646 | * generic motion compensation function | ||
647 | * | ||
648 | * @param r decoder context | ||
649 | * @param block_type type of the current block | ||
650 | * @param xoff horizontal offset from the start of the current block | ||
651 | * @param yoff vertical offset from the start of the current block | ||
652 | * @param mv_off offset to the motion vector information | ||
653 | * @param width width of the current partition in 8x8 blocks | ||
654 | * @param height height of the current partition in 8x8 blocks | ||
655 | * @param dir motion compensation direction (i.e. from the last or the next reference frame) | ||
656 | * @param thirdpel motion vectors are specified in 1/3 of pixel | ||
657 | * @param qpel_mc a set of functions used to perform luma motion compensation | ||
658 | * @param chroma_mc a set of functions used to perform chroma motion compensation | ||
659 | */ | ||
660 | 511743 | static inline void rv34_mc(RV34DecContext *r, const int block_type, | |
661 | const int xoff, const int yoff, int mv_off, | ||
662 | const int width, const int height, int dir, | ||
663 | const int thirdpel, int weighted, | ||
664 | qpel_mc_func (*qpel_mc)[16], | ||
665 | h264_chroma_mc_func (*chroma_mc)) | ||
666 | { | ||
667 | 511743 | MpegEncContext *s = &r->s; | |
668 | uint8_t *Y, *U, *V, *srcY, *srcU, *srcV; | ||
669 | int dxy, mx, my, umx, umy, lx, ly, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y; | ||
670 | 511743 | int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride + mv_off; | |
671 | 511743 | int is16x16 = 1; | |
672 | 511743 | int emu = 0; | |
673 | |||
674 |
2/2✓ Branch 0 taken 127708 times.
✓ Branch 1 taken 384035 times.
|
511743 | if(thirdpel){ |
675 | int chroma_mx, chroma_my; | ||
676 | 127708 | mx = (s->current_picture_ptr->motion_val[dir][mv_pos][0] + (3 << 24)) / 3 - (1 << 24); | |
677 | 127708 | my = (s->current_picture_ptr->motion_val[dir][mv_pos][1] + (3 << 24)) / 3 - (1 << 24); | |
678 | 127708 | lx = (s->current_picture_ptr->motion_val[dir][mv_pos][0] + (3 << 24)) % 3; | |
679 | 127708 | ly = (s->current_picture_ptr->motion_val[dir][mv_pos][1] + (3 << 24)) % 3; | |
680 | 127708 | chroma_mx = s->current_picture_ptr->motion_val[dir][mv_pos][0] / 2; | |
681 | 127708 | chroma_my = s->current_picture_ptr->motion_val[dir][mv_pos][1] / 2; | |
682 | 127708 | umx = (chroma_mx + (3 << 24)) / 3 - (1 << 24); | |
683 | 127708 | umy = (chroma_my + (3 << 24)) / 3 - (1 << 24); | |
684 | 127708 | uvmx = chroma_coeffs[(chroma_mx + (3 << 24)) % 3]; | |
685 | 127708 | uvmy = chroma_coeffs[(chroma_my + (3 << 24)) % 3]; | |
686 | }else{ | ||
687 | int cx, cy; | ||
688 | 384035 | mx = s->current_picture_ptr->motion_val[dir][mv_pos][0] >> 2; | |
689 | 384035 | my = s->current_picture_ptr->motion_val[dir][mv_pos][1] >> 2; | |
690 | 384035 | lx = s->current_picture_ptr->motion_val[dir][mv_pos][0] & 3; | |
691 | 384035 | ly = s->current_picture_ptr->motion_val[dir][mv_pos][1] & 3; | |
692 | 384035 | cx = s->current_picture_ptr->motion_val[dir][mv_pos][0] / 2; | |
693 | 384035 | cy = s->current_picture_ptr->motion_val[dir][mv_pos][1] / 2; | |
694 | 384035 | umx = cx >> 2; | |
695 | 384035 | umy = cy >> 2; | |
696 | 384035 | uvmx = (cx & 3) << 1; | |
697 | 384035 | uvmy = (cy & 3) << 1; | |
698 | //due to some flaw RV40 uses the same MC compensation routine for H2V2 and H3V3 | ||
699 |
4/4✓ Branch 0 taken 34455 times.
✓ Branch 1 taken 349580 times.
✓ Branch 2 taken 7377 times.
✓ Branch 3 taken 27078 times.
|
384035 | if(uvmx == 6 && uvmy == 6) |
700 | 7377 | uvmx = uvmy = 4; | |
701 | } | ||
702 | |||
703 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 511743 times.
|
511743 | if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME)) { |
704 | /* wait for the referenced mb row to be finished */ | ||
705 | ✗ | int mb_row = s->mb_y + ((yoff + my + 5 + 8 * height) >> 4); | |
706 | ✗ | ThreadFrame *f = dir ? &s->next_picture_ptr->tf : &s->last_picture_ptr->tf; | |
707 | ✗ | ff_thread_await_progress(f, mb_row, 0); | |
708 | } | ||
709 | |||
710 | 511743 | dxy = ly*4 + lx; | |
711 |
2/2✓ Branch 0 taken 220681 times.
✓ Branch 1 taken 291062 times.
|
511743 | srcY = dir ? s->next_picture_ptr->f->data[0] : s->last_picture_ptr->f->data[0]; |
712 |
2/2✓ Branch 0 taken 220681 times.
✓ Branch 1 taken 291062 times.
|
511743 | srcU = dir ? s->next_picture_ptr->f->data[1] : s->last_picture_ptr->f->data[1]; |
713 |
2/2✓ Branch 0 taken 220681 times.
✓ Branch 1 taken 291062 times.
|
511743 | srcV = dir ? s->next_picture_ptr->f->data[2] : s->last_picture_ptr->f->data[2]; |
714 | 511743 | src_x = s->mb_x * 16 + xoff + mx; | |
715 | 511743 | src_y = s->mb_y * 16 + yoff + my; | |
716 | 511743 | uvsrc_x = s->mb_x * 8 + (xoff >> 1) + umx; | |
717 | 511743 | uvsrc_y = s->mb_y * 8 + (yoff >> 1) + umy; | |
718 | 511743 | srcY += src_y * s->linesize + src_x; | |
719 | 511743 | srcU += uvsrc_y * s->uvlinesize + uvsrc_x; | |
720 | 511743 | srcV += uvsrc_y * s->uvlinesize + uvsrc_x; | |
721 |
2/4✓ Branch 0 taken 511743 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 511743 times.
✗ Branch 3 not taken.
|
511743 | if(s->h_edge_pos - (width << 3) < 6 || s->v_edge_pos - (height << 3) < 6 || |
722 |
6/6✓ Branch 0 taken 165520 times.
✓ Branch 1 taken 346223 times.
✓ Branch 2 taken 165520 times.
✓ Branch 3 taken 346223 times.
✓ Branch 4 taken 495678 times.
✓ Branch 5 taken 16065 times.
|
511743 | (unsigned)(src_x - !!lx*2) > s->h_edge_pos - !!lx*2 - (width <<3) - 4 || |
723 |
6/6✓ Branch 0 taken 142815 times.
✓ Branch 1 taken 352863 times.
✓ Branch 2 taken 142815 times.
✓ Branch 3 taken 352863 times.
✓ Branch 4 taken 27587 times.
✓ Branch 5 taken 468091 times.
|
495678 | (unsigned)(src_y - !!ly*2) > s->v_edge_pos - !!ly*2 - (height<<3) - 4) { |
724 | 43652 | srcY -= 2 + 2*s->linesize; | |
725 | 43652 | s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, srcY, | |
726 | s->linesize, s->linesize, | ||
727 | 43652 | (width << 3) + 6, (height << 3) + 6, | |
728 | src_x - 2, src_y - 2, | ||
729 | s->h_edge_pos, s->v_edge_pos); | ||
730 | 43652 | srcY = s->sc.edge_emu_buffer + 2 + 2*s->linesize; | |
731 | 43652 | emu = 1; | |
732 | } | ||
733 |
2/2✓ Branch 0 taken 230597 times.
✓ Branch 1 taken 281146 times.
|
511743 | if(!weighted){ |
734 | 230597 | Y = s->dest[0] + xoff + yoff *s->linesize; | |
735 | 230597 | U = s->dest[1] + (xoff>>1) + (yoff>>1)*s->uvlinesize; | |
736 | 230597 | V = s->dest[2] + (xoff>>1) + (yoff>>1)*s->uvlinesize; | |
737 | }else{ | ||
738 | 281146 | Y = r->tmp_b_block_y [dir] + xoff + yoff *s->linesize; | |
739 | 281146 | U = r->tmp_b_block_uv[dir*2] + (xoff>>1) + (yoff>>1)*s->uvlinesize; | |
740 | 281146 | V = r->tmp_b_block_uv[dir*2+1] + (xoff>>1) + (yoff>>1)*s->uvlinesize; | |
741 | } | ||
742 | |||
743 |
2/2✓ Branch 0 taken 2692 times.
✓ Branch 1 taken 509051 times.
|
511743 | if(block_type == RV34_MB_P_16x8){ |
744 | 2692 | qpel_mc[1][dxy](Y, srcY, s->linesize); | |
745 | 2692 | Y += 8; | |
746 | 2692 | srcY += 8; | |
747 |
2/2✓ Branch 0 taken 4946 times.
✓ Branch 1 taken 504105 times.
|
509051 | }else if(block_type == RV34_MB_P_8x16){ |
748 | 4946 | qpel_mc[1][dxy](Y, srcY, s->linesize); | |
749 | 4946 | Y += 8 * s->linesize; | |
750 | 4946 | srcY += 8 * s->linesize; | |
751 | } | ||
752 |
6/6✓ Branch 0 taken 403295 times.
✓ Branch 1 taken 108448 times.
✓ Branch 2 taken 400603 times.
✓ Branch 3 taken 2692 times.
✓ Branch 4 taken 395657 times.
✓ Branch 5 taken 4946 times.
|
511743 | is16x16 = (block_type != RV34_MB_P_8x8) && (block_type != RV34_MB_P_16x8) && (block_type != RV34_MB_P_8x16); |
753 |
2/2✓ Branch 0 taken 116086 times.
✓ Branch 1 taken 395657 times.
|
511743 | qpel_mc[!is16x16][dxy](Y, srcY, s->linesize); |
754 |
2/2✓ Branch 0 taken 43652 times.
✓ Branch 1 taken 468091 times.
|
511743 | if (emu) { |
755 | 43652 | uint8_t *uvbuf = s->sc.edge_emu_buffer; | |
756 | |||
757 | 43652 | s->vdsp.emulated_edge_mc(uvbuf, srcU, | |
758 | s->uvlinesize, s->uvlinesize, | ||
759 | 43652 | (width << 2) + 1, (height << 2) + 1, | |
760 | uvsrc_x, uvsrc_y, | ||
761 | 43652 | s->h_edge_pos >> 1, s->v_edge_pos >> 1); | |
762 | 43652 | srcU = uvbuf; | |
763 | 43652 | uvbuf += 9*s->uvlinesize; | |
764 | |||
765 | 43652 | s->vdsp.emulated_edge_mc(uvbuf, srcV, | |
766 | s->uvlinesize, s->uvlinesize, | ||
767 | 43652 | (width << 2) + 1, (height << 2) + 1, | |
768 | uvsrc_x, uvsrc_y, | ||
769 | 43652 | s->h_edge_pos >> 1, s->v_edge_pos >> 1); | |
770 | 43652 | srcV = uvbuf; | |
771 | } | ||
772 | 511743 | chroma_mc[2-width] (U, srcU, s->uvlinesize, height*4, uvmx, uvmy); | |
773 | 511743 | chroma_mc[2-width] (V, srcV, s->uvlinesize, height*4, uvmx, uvmy); | |
774 | 511743 | } | |
775 | |||
776 | 111535 | static void rv34_mc_1mv(RV34DecContext *r, const int block_type, | |
777 | const int xoff, const int yoff, int mv_off, | ||
778 | const int width, const int height, int dir) | ||
779 | { | ||
780 | 111535 | rv34_mc(r, block_type, xoff, yoff, mv_off, width, height, dir, r->rv30, 0, | |
781 | 111535 | r->rdsp.put_pixels_tab, | |
782 | 111535 | r->rdsp.put_chroma_pixels_tab); | |
783 | 111535 | } | |
784 | |||
785 | 115964 | static void rv4_weight(RV34DecContext *r) | |
786 | { | ||
787 | 115964 | r->rdsp.rv40_weight_pixels_tab[r->scaled_weight][0](r->s.dest[0], | |
788 | r->tmp_b_block_y[0], | ||
789 | r->tmp_b_block_y[1], | ||
790 | r->weight1, | ||
791 | r->weight2, | ||
792 | r->s.linesize); | ||
793 | 115964 | r->rdsp.rv40_weight_pixels_tab[r->scaled_weight][1](r->s.dest[1], | |
794 | r->tmp_b_block_uv[0], | ||
795 | r->tmp_b_block_uv[2], | ||
796 | r->weight1, | ||
797 | r->weight2, | ||
798 | r->s.uvlinesize); | ||
799 | 115964 | r->rdsp.rv40_weight_pixels_tab[r->scaled_weight][1](r->s.dest[2], | |
800 | r->tmp_b_block_uv[1], | ||
801 | r->tmp_b_block_uv[3], | ||
802 | r->weight1, | ||
803 | r->weight2, | ||
804 | r->s.uvlinesize); | ||
805 | 115964 | } | |
806 | |||
807 | 154932 | static void rv34_mc_2mv(RV34DecContext *r, const int block_type) | |
808 | { | ||
809 |
5/6✓ Branch 0 taken 117024 times.
✓ Branch 1 taken 37908 times.
✓ Branch 2 taken 107761 times.
✓ Branch 3 taken 9263 times.
✓ Branch 4 taken 107761 times.
✗ Branch 5 not taken.
|
154932 | int weighted = !r->rv30 && block_type != RV34_MB_B_BIDIR && r->weight1 != 8192; |
810 | |||
811 | 154932 | rv34_mc(r, block_type, 0, 0, 0, 2, 2, 0, r->rv30, weighted, | |
812 | 154932 | r->rdsp.put_pixels_tab, | |
813 | 154932 | r->rdsp.put_chroma_pixels_tab); | |
814 |
2/2✓ Branch 0 taken 47171 times.
✓ Branch 1 taken 107761 times.
|
154932 | if(!weighted){ |
815 | 47171 | rv34_mc(r, block_type, 0, 0, 0, 2, 2, 1, r->rv30, 0, | |
816 | 47171 | r->rdsp.avg_pixels_tab, | |
817 | 47171 | r->rdsp.avg_chroma_pixels_tab); | |
818 | }else{ | ||
819 | 107761 | rv34_mc(r, block_type, 0, 0, 0, 2, 2, 1, r->rv30, 1, | |
820 | 107761 | r->rdsp.put_pixels_tab, | |
821 | 107761 | r->rdsp.put_chroma_pixels_tab); | |
822 | 107761 | rv4_weight(r); | |
823 | } | ||
824 | 154932 | } | |
825 | |||
826 | 11293 | static void rv34_mc_2mv_skip(RV34DecContext *r) | |
827 | { | ||
828 | int i, j; | ||
829 |
3/4✓ Branch 0 taken 8203 times.
✓ Branch 1 taken 3090 times.
✓ Branch 2 taken 8203 times.
✗ Branch 3 not taken.
|
11293 | int weighted = !r->rv30 && r->weight1 != 8192; |
830 | |||
831 |
2/2✓ Branch 0 taken 22586 times.
✓ Branch 1 taken 11293 times.
|
33879 | for(j = 0; j < 2; j++) |
832 |
2/2✓ Branch 0 taken 45172 times.
✓ Branch 1 taken 22586 times.
|
67758 | for(i = 0; i < 2; i++){ |
833 | 45172 | rv34_mc(r, RV34_MB_P_8x8, i*8, j*8, i+j*r->s.b8_stride, 1, 1, 0, r->rv30, | |
834 | weighted, | ||
835 | 45172 | r->rdsp.put_pixels_tab, | |
836 | 45172 | r->rdsp.put_chroma_pixels_tab); | |
837 |
4/4✓ Branch 0 taken 32812 times.
✓ Branch 1 taken 12360 times.
✓ Branch 2 taken 32812 times.
✓ Branch 3 taken 12360 times.
|
45172 | rv34_mc(r, RV34_MB_P_8x8, i*8, j*8, i+j*r->s.b8_stride, 1, 1, 1, r->rv30, |
838 | weighted, | ||
839 | weighted ? r->rdsp.put_pixels_tab : r->rdsp.avg_pixels_tab, | ||
840 | weighted ? r->rdsp.put_chroma_pixels_tab : r->rdsp.avg_chroma_pixels_tab); | ||
841 | } | ||
842 |
2/2✓ Branch 0 taken 8203 times.
✓ Branch 1 taken 3090 times.
|
11293 | if(weighted) |
843 | 8203 | rv4_weight(r); | |
844 | 11293 | } | |
845 | |||
846 | /** number of motion vectors in each macroblock type */ | ||
847 | static const int num_mvs[RV34_MB_TYPES] = { 0, 0, 1, 4, 1, 1, 0, 0, 2, 2, 2, 1 }; | ||
848 | |||
849 | /** | ||
850 | * Decode motion vector differences | ||
851 | * and perform motion vector reconstruction and motion compensation. | ||
852 | */ | ||
853 | 284640 | static int rv34_decode_mv(RV34DecContext *r, int block_type) | |
854 | { | ||
855 | 284640 | MpegEncContext *s = &r->s; | |
856 | 284640 | GetBitContext *gb = &s->gb; | |
857 | int i, j, k, l; | ||
858 | 284640 | int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride; | |
859 | int next_bt; | ||
860 | |||
861 | 284640 | memset(r->dmv, 0, sizeof(r->dmv)); | |
862 |
2/2✓ Branch 0 taken 98756 times.
✓ Branch 1 taken 284640 times.
|
383396 | for(i = 0; i < num_mvs[block_type]; i++){ |
863 | 98756 | r->dmv[i][0] = get_interleaved_se_golomb(gb); | |
864 | 98756 | r->dmv[i][1] = get_interleaved_se_golomb(gb); | |
865 |
1/2✓ Branch 0 taken 98756 times.
✗ Branch 1 not taken.
|
98756 | if (r->dmv[i][0] == INVALID_VLC || |
866 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 98756 times.
|
98756 | r->dmv[i][1] == INVALID_VLC) { |
867 | ✗ | r->dmv[i][0] = r->dmv[i][1] = 0; | |
868 | ✗ | return AVERROR_INVALIDDATA; | |
869 | } | ||
870 | } | ||
871 |
8/9✓ Branch 0 taken 24277 times.
✓ Branch 1 taken 163091 times.
✓ Branch 2 taken 25176 times.
✓ Branch 3 taken 16878 times.
✓ Branch 4 taken 37610 times.
✓ Branch 5 taken 3819 times.
✓ Branch 6 taken 9263 times.
✓ Branch 7 taken 4526 times.
✗ Branch 8 not taken.
|
284640 | switch(block_type){ |
872 | 24277 | case RV34_MB_TYPE_INTRA: | |
873 | case RV34_MB_TYPE_INTRA16x16: | ||
874 | 24277 | ZERO8x2(s->current_picture_ptr->motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride); | |
875 | 24277 | return 0; | |
876 | 163091 | case RV34_MB_SKIP: | |
877 |
2/2✓ Branch 0 taken 31305 times.
✓ Branch 1 taken 131786 times.
|
163091 | if(s->pict_type == AV_PICTURE_TYPE_P){ |
878 | 31305 | ZERO8x2(s->current_picture_ptr->motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride); | |
879 | 31305 | rv34_mc_1mv (r, block_type, 0, 0, 0, 2, 2, 0); | |
880 | 31305 | break; | |
881 | } | ||
882 | case RV34_MB_B_DIRECT: | ||
883 | //surprisingly, it uses motion scheme from next reference frame | ||
884 | /* wait for the current mb row to be finished */ | ||
885 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 156962 times.
|
156962 | if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME)) |
886 | ✗ | ff_thread_await_progress(&s->next_picture_ptr->tf, FFMAX(0, s->mb_y-1), 0); | |
887 | |||
888 | 156962 | next_bt = s->next_picture_ptr->mb_type[s->mb_x + s->mb_y * s->mb_stride]; | |
889 |
4/4✓ Branch 0 taken 143300 times.
✓ Branch 1 taken 13662 times.
✓ Branch 2 taken 93129 times.
✓ Branch 3 taken 50171 times.
|
156962 | if(IS_INTRA(next_bt) || IS_SKIP(next_bt)){ |
890 | 106791 | ZERO8x2(s->current_picture_ptr->motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride); | |
891 | 106791 | ZERO8x2(s->current_picture_ptr->motion_val[1][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride); | |
892 | }else | ||
893 |
2/2✓ Branch 0 taken 100342 times.
✓ Branch 1 taken 50171 times.
|
150513 | for(j = 0; j < 2; j++) |
894 |
2/2✓ Branch 0 taken 200684 times.
✓ Branch 1 taken 100342 times.
|
301026 | for(i = 0; i < 2; i++) |
895 |
2/2✓ Branch 0 taken 401368 times.
✓ Branch 1 taken 200684 times.
|
602052 | for(k = 0; k < 2; k++) |
896 |
2/2✓ Branch 0 taken 802736 times.
✓ Branch 1 taken 401368 times.
|
1204104 | for(l = 0; l < 2; l++) |
897 | 802736 | s->current_picture_ptr->motion_val[l][mv_pos + i + j*s->b8_stride][k] = calc_add_mv(r, l, s->next_picture_ptr->motion_val[0][mv_pos + i + j*s->b8_stride][k]); | |
898 |
6/6✓ Branch 0 taken 154875 times.
✓ Branch 1 taken 2087 times.
✓ Branch 2 taken 151756 times.
✓ Branch 3 taken 3119 times.
✓ Branch 4 taken 145669 times.
✓ Branch 5 taken 6087 times.
|
156962 | if(!(IS_16X8(next_bt) || IS_8X16(next_bt) || IS_8X8(next_bt))) //we can use whole macroblock MC |
899 | 145669 | rv34_mc_2mv(r, block_type); | |
900 | else | ||
901 | 11293 | rv34_mc_2mv_skip(r); | |
902 | 156962 | ZERO8x2(s->current_picture_ptr->motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride); | |
903 | 156962 | break; | |
904 | 16878 | case RV34_MB_P_16x16: | |
905 | case RV34_MB_P_MIX16x16: | ||
906 | 16878 | rv34_pred_mv(r, block_type, 0, 0); | |
907 | 16878 | rv34_mc_1mv (r, block_type, 0, 0, 0, 2, 2, 0); | |
908 | 16878 | break; | |
909 | 37610 | case RV34_MB_B_FORWARD: | |
910 | case RV34_MB_B_BACKWARD: | ||
911 | 37610 | r->dmv[1][0] = r->dmv[0][0]; | |
912 | 37610 | r->dmv[1][1] = r->dmv[0][1]; | |
913 |
2/2✓ Branch 0 taken 9134 times.
✓ Branch 1 taken 28476 times.
|
37610 | if(r->rv30) |
914 | 9134 | rv34_pred_mv_rv3(r, block_type, block_type == RV34_MB_B_BACKWARD); | |
915 | else | ||
916 | 28476 | rv34_pred_mv_b (r, block_type, block_type == RV34_MB_B_BACKWARD); | |
917 | 37610 | rv34_mc_1mv (r, block_type, 0, 0, 0, 2, 2, block_type == RV34_MB_B_BACKWARD); | |
918 | 37610 | break; | |
919 | 3819 | case RV34_MB_P_16x8: | |
920 | case RV34_MB_P_8x16: | ||
921 | 3819 | rv34_pred_mv(r, block_type, 0, 0); | |
922 |
2/2✓ Branch 0 taken 1346 times.
✓ Branch 1 taken 2473 times.
|
3819 | rv34_pred_mv(r, block_type, 1 + (block_type == RV34_MB_P_16x8), 1); |
923 |
2/2✓ Branch 0 taken 1346 times.
✓ Branch 1 taken 2473 times.
|
3819 | if(block_type == RV34_MB_P_16x8){ |
924 | 1346 | rv34_mc_1mv(r, block_type, 0, 0, 0, 2, 1, 0); | |
925 | 1346 | rv34_mc_1mv(r, block_type, 0, 8, s->b8_stride, 2, 1, 0); | |
926 | } | ||
927 |
2/2✓ Branch 0 taken 2473 times.
✓ Branch 1 taken 1346 times.
|
3819 | if(block_type == RV34_MB_P_8x16){ |
928 | 2473 | rv34_mc_1mv(r, block_type, 0, 0, 0, 1, 2, 0); | |
929 | 2473 | rv34_mc_1mv(r, block_type, 8, 0, 1, 1, 2, 0); | |
930 | } | ||
931 | 3819 | break; | |
932 | 9263 | case RV34_MB_B_BIDIR: | |
933 | 9263 | rv34_pred_mv_b (r, block_type, 0); | |
934 | 9263 | rv34_pred_mv_b (r, block_type, 1); | |
935 | 9263 | rv34_mc_2mv (r, block_type); | |
936 | 9263 | break; | |
937 | 4526 | case RV34_MB_P_8x8: | |
938 |
2/2✓ Branch 0 taken 18104 times.
✓ Branch 1 taken 4526 times.
|
22630 | for(i=0;i< 4;i++){ |
939 | 18104 | rv34_pred_mv(r, block_type, i, i); | |
940 | 18104 | rv34_mc_1mv (r, block_type, (i&1)<<3, (i&2)<<2, (i&1)+(i>>1)*s->b8_stride, 1, 1, 0); | |
941 | } | ||
942 | 4526 | break; | |
943 | } | ||
944 | |||
945 | 260363 | return 0; | |
946 | } | ||
947 | /** @} */ // mv group | ||
948 | |||
949 | /** | ||
950 | * @name Macroblock reconstruction functions | ||
951 | * @{ | ||
952 | */ | ||
953 | /** mapping of RV30/40 intra prediction types to standard H.264 types */ | ||
954 | static const int ittrans[9] = { | ||
955 | DC_PRED, VERT_PRED, HOR_PRED, DIAG_DOWN_RIGHT_PRED, DIAG_DOWN_LEFT_PRED, | ||
956 | VERT_RIGHT_PRED, VERT_LEFT_PRED, HOR_UP_PRED, HOR_DOWN_PRED, | ||
957 | }; | ||
958 | |||
959 | /** mapping of RV30/40 intra 16x16 prediction types to standard H.264 types */ | ||
960 | static const int ittrans16[4] = { | ||
961 | DC_PRED8x8, VERT_PRED8x8, HOR_PRED8x8, PLANE_PRED8x8, | ||
962 | }; | ||
963 | |||
964 | /** | ||
965 | * Perform 4x4 intra prediction. | ||
966 | */ | ||
967 | 362664 | static void rv34_pred_4x4_block(RV34DecContext *r, uint8_t *dst, int stride, int itype, int up, int left, int down, int right) | |
968 | { | ||
969 | 362664 | uint8_t *prev = dst - stride + 4; | |
970 | uint32_t topleft; | ||
971 | |||
972 |
4/4✓ Branch 0 taken 44608 times.
✓ Branch 1 taken 318056 times.
✓ Branch 2 taken 906 times.
✓ Branch 3 taken 43702 times.
|
362664 | if(!up && !left) |
973 | 906 | itype = DC_128_PRED; | |
974 |
2/2✓ Branch 0 taken 43702 times.
✓ Branch 1 taken 318056 times.
|
361758 | else if(!up){ |
975 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 43702 times.
|
43702 | if(itype == VERT_PRED) itype = HOR_PRED; |
976 |
2/2✓ Branch 0 taken 25536 times.
✓ Branch 1 taken 18166 times.
|
43702 | if(itype == DC_PRED) itype = LEFT_DC_PRED; |
977 |
2/2✓ Branch 0 taken 5318 times.
✓ Branch 1 taken 312738 times.
|
318056 | }else if(!left){ |
978 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5318 times.
|
5318 | if(itype == HOR_PRED) itype = VERT_PRED; |
979 |
2/2✓ Branch 0 taken 3700 times.
✓ Branch 1 taken 1618 times.
|
5318 | if(itype == DC_PRED) itype = TOP_DC_PRED; |
980 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5318 times.
|
5318 | if(itype == DIAG_DOWN_LEFT_PRED) itype = DIAG_DOWN_LEFT_PRED_RV40_NODOWN; |
981 | } | ||
982 |
2/2✓ Branch 0 taken 289443 times.
✓ Branch 1 taken 73221 times.
|
362664 | if(!down){ |
983 |
2/2✓ Branch 0 taken 16269 times.
✓ Branch 1 taken 273174 times.
|
289443 | if(itype == DIAG_DOWN_LEFT_PRED) itype = DIAG_DOWN_LEFT_PRED_RV40_NODOWN; |
984 |
2/2✓ Branch 0 taken 9066 times.
✓ Branch 1 taken 280377 times.
|
289443 | if(itype == HOR_UP_PRED) itype = HOR_UP_PRED_RV40_NODOWN; |
985 |
2/2✓ Branch 0 taken 23196 times.
✓ Branch 1 taken 266247 times.
|
289443 | if(itype == VERT_LEFT_PRED) itype = VERT_LEFT_PRED_RV40_NODOWN; |
986 | } | ||
987 |
4/4✓ Branch 0 taken 120271 times.
✓ Branch 1 taken 242393 times.
✓ Branch 2 taken 76047 times.
✓ Branch 3 taken 44224 times.
|
362664 | if(!right && up){ |
988 | 76047 | topleft = dst[-stride + 3] * 0x01010101u; | |
989 | 76047 | prev = (uint8_t*)&topleft; | |
990 | } | ||
991 | 362664 | r->h.pred4x4[itype](dst, prev, stride); | |
992 | 362664 | } | |
993 | |||
994 | 33612 | static inline int adjust_pred16(int itype, int up, int left) | |
995 | { | ||
996 |
4/4✓ Branch 0 taken 5808 times.
✓ Branch 1 taken 27804 times.
✓ Branch 2 taken 54 times.
✓ Branch 3 taken 5754 times.
|
33612 | if(!up && !left) |
997 | 54 | itype = DC_128_PRED8x8; | |
998 |
2/2✓ Branch 0 taken 5754 times.
✓ Branch 1 taken 27804 times.
|
33558 | else if(!up){ |
999 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5754 times.
|
5754 | if(itype == PLANE_PRED8x8)itype = HOR_PRED8x8; |
1000 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5754 times.
|
5754 | if(itype == VERT_PRED8x8) itype = HOR_PRED8x8; |
1001 |
2/2✓ Branch 0 taken 3756 times.
✓ Branch 1 taken 1998 times.
|
5754 | if(itype == DC_PRED8x8) itype = LEFT_DC_PRED8x8; |
1002 |
2/2✓ Branch 0 taken 836 times.
✓ Branch 1 taken 26968 times.
|
27804 | }else if(!left){ |
1003 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 836 times.
|
836 | if(itype == PLANE_PRED8x8)itype = VERT_PRED8x8; |
1004 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 836 times.
|
836 | if(itype == HOR_PRED8x8) itype = VERT_PRED8x8; |
1005 |
2/2✓ Branch 0 taken 680 times.
✓ Branch 1 taken 156 times.
|
836 | if(itype == DC_PRED8x8) itype = TOP_DC_PRED8x8; |
1006 | } | ||
1007 | 33612 | return itype; | |
1008 | } | ||
1009 | |||
1010 | 704977 | static inline void rv34_process_block(RV34DecContext *r, | |
1011 | uint8_t *pdst, int stride, | ||
1012 | int fc, int sc, int q_dc, int q_ac) | ||
1013 | { | ||
1014 | 704977 | MpegEncContext *s = &r->s; | |
1015 | 704977 | int16_t *ptr = s->block[0]; | |
1016 | 704977 | int has_ac = rv34_decode_block(ptr, &s->gb, r->cur_vlcs, | |
1017 | fc, sc, q_dc, q_ac, q_ac); | ||
1018 |
2/2✓ Branch 0 taken 350745 times.
✓ Branch 1 taken 354232 times.
|
704977 | if(has_ac){ |
1019 | 350745 | r->rdsp.rv34_idct_add(pdst, stride, ptr); | |
1020 | }else{ | ||
1021 | 354232 | r->rdsp.rv34_idct_dc_add(pdst, stride, ptr[0]); | |
1022 | 354232 | ptr[0] = 0; | |
1023 | } | ||
1024 | 704977 | } | |
1025 | |||
1026 | 16806 | static void rv34_output_i16x16(RV34DecContext *r, int8_t *intra_types, int cbp) | |
1027 | { | ||
1028 | 16806 | LOCAL_ALIGNED_16(int16_t, block16, [16]); | |
1029 | 16806 | MpegEncContext *s = &r->s; | |
1030 | 16806 | GetBitContext *gb = &s->gb; | |
1031 | 16806 | int q_dc = rv34_qscale_tab[ r->luma_dc_quant_i[s->qscale] ], | |
1032 | 16806 | q_ac = rv34_qscale_tab[s->qscale]; | |
1033 | 16806 | uint8_t *dst = s->dest[0]; | |
1034 | 16806 | int16_t *ptr = s->block[0]; | |
1035 | int i, j, itype, has_ac; | ||
1036 | |||
1037 | 16806 | memset(block16, 0, 16 * sizeof(*block16)); | |
1038 | |||
1039 | 16806 | has_ac = rv34_decode_block(block16, gb, r->cur_vlcs, 3, 0, q_dc, q_dc, q_ac); | |
1040 |
2/2✓ Branch 0 taken 7912 times.
✓ Branch 1 taken 8894 times.
|
16806 | if(has_ac) |
1041 | 7912 | r->rdsp.rv34_inv_transform(block16); | |
1042 | else | ||
1043 | 8894 | r->rdsp.rv34_inv_transform_dc(block16); | |
1044 | |||
1045 | 16806 | itype = ittrans16[intra_types[0]]; | |
1046 | 16806 | itype = adjust_pred16(itype, r->avail_cache[6-4], r->avail_cache[6-1]); | |
1047 | 16806 | r->h.pred16x16[itype](dst, s->linesize); | |
1048 | |||
1049 |
2/2✓ Branch 0 taken 67224 times.
✓ Branch 1 taken 16806 times.
|
84030 | for(j = 0; j < 4; j++){ |
1050 |
2/2✓ Branch 0 taken 268896 times.
✓ Branch 1 taken 67224 times.
|
336120 | for(i = 0; i < 4; i++, cbp >>= 1){ |
1051 | 268896 | int dc = block16[i + j*4]; | |
1052 | |||
1053 |
2/2✓ Branch 0 taken 14262 times.
✓ Branch 1 taken 254634 times.
|
268896 | if(cbp & 1){ |
1054 | 14262 | has_ac = rv34_decode_block(ptr, gb, r->cur_vlcs, r->luma_vlc, 0, q_ac, q_ac, q_ac); | |
1055 | }else | ||
1056 | 254634 | has_ac = 0; | |
1057 | |||
1058 |
2/2✓ Branch 0 taken 14262 times.
✓ Branch 1 taken 254634 times.
|
268896 | if(has_ac){ |
1059 | 14262 | ptr[0] = dc; | |
1060 | 14262 | r->rdsp.rv34_idct_add(dst+4*i, s->linesize, ptr); | |
1061 | }else | ||
1062 | 254634 | r->rdsp.rv34_idct_dc_add(dst+4*i, s->linesize, dc); | |
1063 | } | ||
1064 | |||
1065 | 67224 | dst += 4*s->linesize; | |
1066 | } | ||
1067 | |||
1068 | 16806 | itype = ittrans16[intra_types[0]]; | |
1069 |
2/2✓ Branch 0 taken 1213 times.
✓ Branch 1 taken 15593 times.
|
16806 | if(itype == PLANE_PRED8x8) itype = DC_PRED8x8; |
1070 | 16806 | itype = adjust_pred16(itype, r->avail_cache[6-4], r->avail_cache[6-1]); | |
1071 | |||
1072 | 16806 | q_dc = rv34_qscale_tab[rv34_chroma_quant[1][s->qscale]]; | |
1073 | 16806 | q_ac = rv34_qscale_tab[rv34_chroma_quant[0][s->qscale]]; | |
1074 | |||
1075 |
2/2✓ Branch 0 taken 33612 times.
✓ Branch 1 taken 16806 times.
|
50418 | for(j = 1; j < 3; j++){ |
1076 | 33612 | dst = s->dest[j]; | |
1077 | 33612 | r->h.pred8x8[itype](dst, s->uvlinesize); | |
1078 |
2/2✓ Branch 0 taken 134448 times.
✓ Branch 1 taken 33612 times.
|
168060 | for(i = 0; i < 4; i++, cbp >>= 1){ |
1079 | uint8_t *pdst; | ||
1080 |
2/2✓ Branch 0 taken 109783 times.
✓ Branch 1 taken 24665 times.
|
134448 | if(!(cbp & 1)) continue; |
1081 | 24665 | pdst = dst + (i&1)*4 + (i&2)*2*s->uvlinesize; | |
1082 | |||
1083 | 24665 | rv34_process_block(r, pdst, s->uvlinesize, | |
1084 | r->chroma_vlc, 1, q_dc, q_ac); | ||
1085 | } | ||
1086 | } | ||
1087 | 16806 | } | |
1088 | |||
1089 | 15111 | static void rv34_output_intra(RV34DecContext *r, int8_t *intra_types, int cbp) | |
1090 | { | ||
1091 | 15111 | MpegEncContext *s = &r->s; | |
1092 | 15111 | uint8_t *dst = s->dest[0]; | |
1093 | 15111 | int avail[6*8] = {0}; | |
1094 | int i, j, k; | ||
1095 | int idx, q_ac, q_dc; | ||
1096 | |||
1097 | // Set neighbour information. | ||
1098 |
2/2✓ Branch 0 taken 8914 times.
✓ Branch 1 taken 6197 times.
|
15111 | if(r->avail_cache[1]) |
1099 | 8914 | avail[0] = 1; | |
1100 |
2/2✓ Branch 0 taken 9535 times.
✓ Branch 1 taken 5576 times.
|
15111 | if(r->avail_cache[2]) |
1101 | 9535 | avail[1] = avail[2] = 1; | |
1102 |
2/2✓ Branch 0 taken 9535 times.
✓ Branch 1 taken 5576 times.
|
15111 | if(r->avail_cache[3]) |
1103 | 9535 | avail[3] = avail[4] = 1; | |
1104 |
2/2✓ Branch 0 taken 9499 times.
✓ Branch 1 taken 5612 times.
|
15111 | if(r->avail_cache[4]) |
1105 | 9499 | avail[5] = 1; | |
1106 |
2/2✓ Branch 0 taken 14333 times.
✓ Branch 1 taken 778 times.
|
15111 | if(r->avail_cache[5]) |
1107 | 14333 | avail[8] = avail[16] = 1; | |
1108 |
2/2✓ Branch 0 taken 14333 times.
✓ Branch 1 taken 778 times.
|
15111 | if(r->avail_cache[9]) |
1109 | 14333 | avail[24] = avail[32] = 1; | |
1110 | |||
1111 | 15111 | q_ac = rv34_qscale_tab[s->qscale]; | |
1112 |
2/2✓ Branch 0 taken 60444 times.
✓ Branch 1 taken 15111 times.
|
75555 | for(j = 0; j < 4; j++){ |
1113 | 60444 | idx = 9 + j*8; | |
1114 |
2/2✓ Branch 0 taken 241776 times.
✓ Branch 1 taken 60444 times.
|
302220 | for(i = 0; i < 4; i++, cbp >>= 1, dst += 4, idx++){ |
1115 | 241776 | rv34_pred_4x4_block(r, dst, s->linesize, ittrans[intra_types[i]], avail[idx-8], avail[idx-1], avail[idx+7], avail[idx-7]); | |
1116 | 241776 | avail[idx] = 1; | |
1117 |
2/2✓ Branch 0 taken 93365 times.
✓ Branch 1 taken 148411 times.
|
241776 | if(!(cbp & 1)) continue; |
1118 | |||
1119 | 148411 | rv34_process_block(r, dst, s->linesize, | |
1120 | r->luma_vlc, 0, q_ac, q_ac); | ||
1121 | } | ||
1122 | 60444 | dst += s->linesize * 4 - 4*4; | |
1123 | 60444 | intra_types += r->intra_types_stride; | |
1124 | } | ||
1125 | |||
1126 | 15111 | intra_types -= r->intra_types_stride * 4; | |
1127 | |||
1128 | 15111 | q_dc = rv34_qscale_tab[rv34_chroma_quant[1][s->qscale]]; | |
1129 | 15111 | q_ac = rv34_qscale_tab[rv34_chroma_quant[0][s->qscale]]; | |
1130 | |||
1131 |
2/2✓ Branch 0 taken 30222 times.
✓ Branch 1 taken 15111 times.
|
45333 | for(k = 0; k < 2; k++){ |
1132 | 30222 | dst = s->dest[1+k]; | |
1133 | 30222 | fill_rectangle(r->avail_cache + 6, 2, 2, 4, 0, 4); | |
1134 | |||
1135 |
2/2✓ Branch 0 taken 60444 times.
✓ Branch 1 taken 30222 times.
|
90666 | for(j = 0; j < 2; j++){ |
1136 | 60444 | int* acache = r->avail_cache + 6 + j*4; | |
1137 |
2/2✓ Branch 0 taken 120888 times.
✓ Branch 1 taken 60444 times.
|
181332 | for(i = 0; i < 2; i++, cbp >>= 1, acache++){ |
1138 | 120888 | int itype = ittrans[intra_types[i*2+j*2*r->intra_types_stride]]; | |
1139 |
4/4✓ Branch 0 taken 60444 times.
✓ Branch 1 taken 60444 times.
✓ Branch 2 taken 30222 times.
✓ Branch 3 taken 30222 times.
|
120888 | rv34_pred_4x4_block(r, dst+4*i, s->uvlinesize, itype, acache[-4], acache[-1], !i && !j, acache[-3]); |
1140 | 120888 | acache[0] = 1; | |
1141 | |||
1142 |
2/2✓ Branch 0 taken 49821 times.
✓ Branch 1 taken 71067 times.
|
120888 | if(!(cbp&1)) continue; |
1143 | |||
1144 | 71067 | rv34_process_block(r, dst + 4*i, s->uvlinesize, | |
1145 | r->chroma_vlc, 1, q_dc, q_ac); | ||
1146 | } | ||
1147 | |||
1148 | 60444 | dst += 4*s->uvlinesize; | |
1149 | } | ||
1150 | } | ||
1151 | 15111 | } | |
1152 | |||
1153 | 2246368 | static int is_mv_diff_gt_3(int16_t (*motion_val)[2], int step) | |
1154 | { | ||
1155 | int d; | ||
1156 | 2246368 | d = motion_val[0][0] - motion_val[-step][0]; | |
1157 |
4/4✓ Branch 0 taken 2153955 times.
✓ Branch 1 taken 92413 times.
✓ Branch 2 taken 95839 times.
✓ Branch 3 taken 2058116 times.
|
2246368 | if(d < -3 || d > 3) |
1158 | 188252 | return 1; | |
1159 | 2058116 | d = motion_val[0][1] - motion_val[-step][1]; | |
1160 |
4/4✓ Branch 0 taken 2043765 times.
✓ Branch 1 taken 14351 times.
✓ Branch 2 taken 17501 times.
✓ Branch 3 taken 2026264 times.
|
2058116 | if(d < -3 || d > 3) |
1161 | 31852 | return 1; | |
1162 | 2026264 | return 0; | |
1163 | } | ||
1164 | |||
1165 | 284640 | static int rv34_set_deblock_coef(RV34DecContext *r) | |
1166 | { | ||
1167 | 284640 | MpegEncContext *s = &r->s; | |
1168 | 284640 | int hmvmask = 0, vmvmask = 0, i, j; | |
1169 | 284640 | int midx = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride; | |
1170 | 284640 | int16_t (*motion_val)[2] = &s->current_picture_ptr->motion_val[0][midx]; | |
1171 |
2/2✓ Branch 0 taken 569280 times.
✓ Branch 1 taken 284640 times.
|
853920 | for(j = 0; j < 16; j += 8){ |
1172 |
2/2✓ Branch 0 taken 1138560 times.
✓ Branch 1 taken 569280 times.
|
1707840 | for(i = 0; i < 2; i++){ |
1173 |
2/2✓ Branch 1 taken 106472 times.
✓ Branch 2 taken 1032088 times.
|
1138560 | if(is_mv_diff_gt_3(motion_val + i, 1)) |
1174 | 106472 | vmvmask |= 0x11 << (j + i*2); | |
1175 |
6/6✓ Branch 0 taken 569280 times.
✓ Branch 1 taken 569280 times.
✓ Branch 2 taken 538528 times.
✓ Branch 3 taken 30752 times.
✓ Branch 5 taken 113632 times.
✓ Branch 6 taken 994176 times.
|
1138560 | if((j || s->mb_y) && is_mv_diff_gt_3(motion_val + i, s->b8_stride)) |
1176 | 113632 | hmvmask |= 0x03 << (j + i*2); | |
1177 | } | ||
1178 | 569280 | motion_val += s->b8_stride; | |
1179 | } | ||
1180 |
2/2✓ Branch 0 taken 42347 times.
✓ Branch 1 taken 242293 times.
|
284640 | if(s->first_slice_line) |
1181 | 42347 | hmvmask &= ~0x000F; | |
1182 |
2/2✓ Branch 0 taken 9120 times.
✓ Branch 1 taken 275520 times.
|
284640 | if(!s->mb_x) |
1183 | 9120 | vmvmask &= ~0x1111; | |
1184 |
2/2✓ Branch 0 taken 68640 times.
✓ Branch 1 taken 216000 times.
|
284640 | if(r->rv30){ //RV30 marks both subblocks on the edge for filtering |
1185 | 68640 | vmvmask |= (vmvmask & 0x4444) >> 1; | |
1186 | 68640 | hmvmask |= (hmvmask & 0x0F00) >> 4; | |
1187 |
2/2✓ Branch 0 taken 65520 times.
✓ Branch 1 taken 3120 times.
|
68640 | if(s->mb_x) |
1188 | 65520 | r->deblock_coefs[s->mb_x - 1 + s->mb_y*s->mb_stride] |= (vmvmask & 0x1111) << 3; | |
1189 |
2/2✓ Branch 0 taken 61878 times.
✓ Branch 1 taken 6762 times.
|
68640 | if(!s->first_slice_line) |
1190 | 61878 | r->deblock_coefs[s->mb_x + (s->mb_y - 1)*s->mb_stride] |= (hmvmask & 0xF) << 12; | |
1191 | } | ||
1192 | 284640 | return hmvmask | vmvmask; | |
1193 | } | ||
1194 | |||
1195 | 284640 | static int rv34_decode_inter_macroblock(RV34DecContext *r, int8_t *intra_types) | |
1196 | { | ||
1197 | 284640 | MpegEncContext *s = &r->s; | |
1198 | 284640 | GetBitContext *gb = &s->gb; | |
1199 | 284640 | uint8_t *dst = s->dest[0]; | |
1200 | 284640 | int16_t *ptr = s->block[0]; | |
1201 | 284640 | int mb_pos = s->mb_x + s->mb_y * s->mb_stride; | |
1202 | int cbp, cbp2; | ||
1203 | int q_dc, q_ac, has_ac; | ||
1204 | int i, j; | ||
1205 | int dist; | ||
1206 | |||
1207 | // Calculate which neighbours are available. Maybe it's worth optimizing too. | ||
1208 | 284640 | memset(r->avail_cache, 0, sizeof(r->avail_cache)); | |
1209 | 284640 | fill_rectangle(r->avail_cache + 6, 2, 2, 4, 1, 4); | |
1210 | 284640 | dist = (s->mb_x - s->resync_mb_x) + (s->mb_y - s->resync_mb_y) * s->mb_width; | |
1211 |
4/4✓ Branch 0 taken 275520 times.
✓ Branch 1 taken 9120 times.
✓ Branch 2 taken 275017 times.
✓ Branch 3 taken 503 times.
|
284640 | if(s->mb_x && dist) |
1212 | 275017 | r->avail_cache[5] = | |
1213 | 275017 | r->avail_cache[9] = s->current_picture_ptr->mb_type[mb_pos - 1]; | |
1214 |
2/2✓ Branch 0 taken 242293 times.
✓ Branch 1 taken 42347 times.
|
284640 | if(dist >= s->mb_width) |
1215 | 242293 | r->avail_cache[2] = | |
1216 | 242293 | r->avail_cache[3] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride]; | |
1217 |
4/4✓ Branch 0 taken 275520 times.
✓ Branch 1 taken 9120 times.
✓ Branch 2 taken 234929 times.
✓ Branch 3 taken 40591 times.
|
284640 | if(((s->mb_x+1) < s->mb_width) && dist >= s->mb_width - 1) |
1218 | 234929 | r->avail_cache[4] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride + 1]; | |
1219 |
4/4✓ Branch 0 taken 275520 times.
✓ Branch 1 taken 9120 times.
✓ Branch 2 taken 234004 times.
✓ Branch 3 taken 41516 times.
|
284640 | if(s->mb_x && dist > s->mb_width) |
1220 | 234004 | r->avail_cache[1] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride - 1]; | |
1221 | |||
1222 | 284640 | s->qscale = r->si.quant; | |
1223 | 284640 | cbp = cbp2 = rv34_decode_inter_mb_header(r, intra_types); | |
1224 | 284640 | r->cbp_luma [mb_pos] = cbp; | |
1225 | 284640 | r->cbp_chroma[mb_pos] = cbp >> 16; | |
1226 | 284640 | r->deblock_coefs[mb_pos] = rv34_set_deblock_coef(r) | r->cbp_luma[mb_pos]; | |
1227 | 284640 | s->current_picture_ptr->qscale_table[mb_pos] = s->qscale; | |
1228 | |||
1229 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 284640 times.
|
284640 | if(cbp == -1) |
1230 | ✗ | return -1; | |
1231 | |||
1232 |
2/2✓ Branch 0 taken 24277 times.
✓ Branch 1 taken 260363 times.
|
284640 | if (IS_INTRA(s->current_picture_ptr->mb_type[mb_pos])){ |
1233 |
2/2✓ Branch 0 taken 10976 times.
✓ Branch 1 taken 13301 times.
|
24277 | if(r->is16) rv34_output_i16x16(r, intra_types, cbp); |
1234 | 13301 | else rv34_output_intra(r, intra_types, cbp); | |
1235 | 24277 | return 0; | |
1236 | } | ||
1237 | |||
1238 |
2/2✓ Branch 0 taken 547 times.
✓ Branch 1 taken 259816 times.
|
260363 | if(r->is16){ |
1239 | // Only for RV34_MB_P_MIX16x16 | ||
1240 | 547 | LOCAL_ALIGNED_16(int16_t, block16, [16]); | |
1241 | 547 | memset(block16, 0, 16 * sizeof(*block16)); | |
1242 | 547 | q_dc = rv34_qscale_tab[ r->luma_dc_quant_p[s->qscale] ]; | |
1243 | 547 | q_ac = rv34_qscale_tab[s->qscale]; | |
1244 |
2/2✓ Branch 1 taken 266 times.
✓ Branch 2 taken 281 times.
|
547 | if (rv34_decode_block(block16, gb, r->cur_vlcs, 3, 0, q_dc, q_dc, q_ac)) |
1245 | 266 | r->rdsp.rv34_inv_transform(block16); | |
1246 | else | ||
1247 | 281 | r->rdsp.rv34_inv_transform_dc(block16); | |
1248 | |||
1249 | 547 | q_ac = rv34_qscale_tab[s->qscale]; | |
1250 | |||
1251 |
2/2✓ Branch 0 taken 2188 times.
✓ Branch 1 taken 547 times.
|
2735 | for(j = 0; j < 4; j++){ |
1252 |
2/2✓ Branch 0 taken 8752 times.
✓ Branch 1 taken 2188 times.
|
10940 | for(i = 0; i < 4; i++, cbp >>= 1){ |
1253 | 8752 | int dc = block16[i + j*4]; | |
1254 | |||
1255 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 8746 times.
|
8752 | if(cbp & 1){ |
1256 | 6 | has_ac = rv34_decode_block(ptr, gb, r->cur_vlcs, r->luma_vlc, 0, q_ac, q_ac, q_ac); | |
1257 | }else | ||
1258 | 8746 | has_ac = 0; | |
1259 | |||
1260 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 8746 times.
|
8752 | if(has_ac){ |
1261 | 6 | ptr[0] = dc; | |
1262 | 6 | r->rdsp.rv34_idct_add(dst+4*i, s->linesize, ptr); | |
1263 | }else | ||
1264 | 8746 | r->rdsp.rv34_idct_dc_add(dst+4*i, s->linesize, dc); | |
1265 | } | ||
1266 | |||
1267 | 2188 | dst += 4*s->linesize; | |
1268 | } | ||
1269 | |||
1270 | 547 | r->cur_vlcs = choose_vlc_set(r->si.quant, r->si.vlc_set, 1); | |
1271 | }else{ | ||
1272 | 259816 | q_ac = rv34_qscale_tab[s->qscale]; | |
1273 | |||
1274 |
2/2✓ Branch 0 taken 1039264 times.
✓ Branch 1 taken 259816 times.
|
1299080 | for(j = 0; j < 4; j++){ |
1275 |
2/2✓ Branch 0 taken 4157056 times.
✓ Branch 1 taken 1039264 times.
|
5196320 | for(i = 0; i < 4; i++, cbp >>= 1){ |
1276 |
2/2✓ Branch 0 taken 3839978 times.
✓ Branch 1 taken 317078 times.
|
4157056 | if(!(cbp & 1)) continue; |
1277 | |||
1278 | 317078 | rv34_process_block(r, dst + 4*i, s->linesize, | |
1279 | r->luma_vlc, 0, q_ac, q_ac); | ||
1280 | } | ||
1281 | 1039264 | dst += 4*s->linesize; | |
1282 | } | ||
1283 | } | ||
1284 | |||
1285 | 260363 | q_dc = rv34_qscale_tab[rv34_chroma_quant[1][s->qscale]]; | |
1286 | 260363 | q_ac = rv34_qscale_tab[rv34_chroma_quant[0][s->qscale]]; | |
1287 | |||
1288 |
2/2✓ Branch 0 taken 520726 times.
✓ Branch 1 taken 260363 times.
|
781089 | for(j = 1; j < 3; j++){ |
1289 | 520726 | dst = s->dest[j]; | |
1290 |
2/2✓ Branch 0 taken 2082904 times.
✓ Branch 1 taken 520726 times.
|
2603630 | for(i = 0; i < 4; i++, cbp >>= 1){ |
1291 | uint8_t *pdst; | ||
1292 |
2/2✓ Branch 0 taken 1939148 times.
✓ Branch 1 taken 143756 times.
|
2082904 | if(!(cbp & 1)) continue; |
1293 | 143756 | pdst = dst + (i&1)*4 + (i&2)*2*s->uvlinesize; | |
1294 | |||
1295 | 143756 | rv34_process_block(r, pdst, s->uvlinesize, | |
1296 | r->chroma_vlc, 1, q_dc, q_ac); | ||
1297 | } | ||
1298 | } | ||
1299 | |||
1300 | 260363 | return 0; | |
1301 | } | ||
1302 | |||
1303 | 7640 | static int rv34_decode_intra_macroblock(RV34DecContext *r, int8_t *intra_types) | |
1304 | { | ||
1305 | 7640 | MpegEncContext *s = &r->s; | |
1306 | int cbp, dist; | ||
1307 | 7640 | int mb_pos = s->mb_x + s->mb_y * s->mb_stride; | |
1308 | |||
1309 | // Calculate which neighbours are available. Maybe it's worth optimizing too. | ||
1310 | 7640 | memset(r->avail_cache, 0, sizeof(r->avail_cache)); | |
1311 | 7640 | fill_rectangle(r->avail_cache + 6, 2, 2, 4, 1, 4); | |
1312 | 7640 | dist = (s->mb_x - s->resync_mb_x) + (s->mb_y - s->resync_mb_y) * s->mb_width; | |
1313 |
4/4✓ Branch 0 taken 7352 times.
✓ Branch 1 taken 288 times.
✓ Branch 2 taken 7325 times.
✓ Branch 3 taken 27 times.
|
7640 | if(s->mb_x && dist) |
1314 | 7325 | r->avail_cache[5] = | |
1315 | 7325 | r->avail_cache[9] = s->current_picture_ptr->mb_type[mb_pos - 1]; | |
1316 |
2/2✓ Branch 0 taken 6133 times.
✓ Branch 1 taken 1507 times.
|
7640 | if(dist >= s->mb_width) |
1317 | 6133 | r->avail_cache[2] = | |
1318 | 6133 | r->avail_cache[3] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride]; | |
1319 |
4/4✓ Branch 0 taken 7352 times.
✓ Branch 1 taken 288 times.
✓ Branch 2 taken 5928 times.
✓ Branch 3 taken 1424 times.
|
7640 | if(((s->mb_x+1) < s->mb_width) && dist >= s->mb_width - 1) |
1320 | 5928 | r->avail_cache[4] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride + 1]; | |
1321 |
4/4✓ Branch 0 taken 7352 times.
✓ Branch 1 taken 288 times.
✓ Branch 2 taken 5878 times.
✓ Branch 3 taken 1474 times.
|
7640 | if(s->mb_x && dist > s->mb_width) |
1322 | 5878 | r->avail_cache[1] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride - 1]; | |
1323 | |||
1324 | 7640 | s->qscale = r->si.quant; | |
1325 | 7640 | cbp = rv34_decode_intra_mb_header(r, intra_types); | |
1326 | 7640 | r->cbp_luma [mb_pos] = cbp; | |
1327 | 7640 | r->cbp_chroma[mb_pos] = cbp >> 16; | |
1328 | 7640 | r->deblock_coefs[mb_pos] = 0xFFFF; | |
1329 | 7640 | s->current_picture_ptr->qscale_table[mb_pos] = s->qscale; | |
1330 | |||
1331 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7640 times.
|
7640 | if(cbp == -1) |
1332 | ✗ | return -1; | |
1333 | |||
1334 |
2/2✓ Branch 0 taken 5830 times.
✓ Branch 1 taken 1810 times.
|
7640 | if(r->is16){ |
1335 | 5830 | rv34_output_i16x16(r, intra_types, cbp); | |
1336 | 5830 | return 0; | |
1337 | } | ||
1338 | |||
1339 | 1810 | rv34_output_intra(r, intra_types, cbp); | |
1340 | 1810 | return 0; | |
1341 | } | ||
1342 | |||
1343 | 293665 | static int check_slice_end(RV34DecContext *r, MpegEncContext *s) | |
1344 | { | ||
1345 | int bits; | ||
1346 |
2/2✓ Branch 0 taken 526 times.
✓ Branch 1 taken 293139 times.
|
293665 | if(s->mb_y >= s->mb_height) |
1347 | 526 | return 1; | |
1348 |
2/2✓ Branch 0 taken 859 times.
✓ Branch 1 taken 292280 times.
|
293139 | if(!s->mb_num_left) |
1349 | 859 | return 1; | |
1350 |
2/2✓ Branch 0 taken 128319 times.
✓ Branch 1 taken 163961 times.
|
292280 | if(r->s.mb_skip_run > 1) |
1351 | 128319 | return 0; | |
1352 | 163961 | bits = get_bits_left(&s->gb); | |
1353 |
4/6✓ Branch 0 taken 163961 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 169 times.
✓ Branch 3 taken 163792 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 169 times.
|
163961 | if(bits <= 0 || (bits < 8 && !show_bits(&s->gb, bits))) |
1354 | ✗ | return 1; | |
1355 | 163961 | return 0; | |
1356 | } | ||
1357 | |||
1358 | |||
1359 | 9 | static void rv34_decoder_free(RV34DecContext *r) | |
1360 | { | ||
1361 | 9 | av_freep(&r->intra_types_hist); | |
1362 | 9 | r->intra_types = NULL; | |
1363 | 9 | av_freep(&r->tmp_b_block_base); | |
1364 | 9 | av_freep(&r->mb_type); | |
1365 | 9 | av_freep(&r->cbp_luma); | |
1366 | 9 | av_freep(&r->cbp_chroma); | |
1367 | 9 | av_freep(&r->deblock_coefs); | |
1368 | 9 | } | |
1369 | |||
1370 | |||
1371 | 9 | static int rv34_decoder_alloc(RV34DecContext *r) | |
1372 | { | ||
1373 | 9 | r->intra_types_stride = r->s.mb_width * 4 + 4; | |
1374 | |||
1375 | 9 | r->cbp_chroma = av_mallocz(r->s.mb_stride * r->s.mb_height * | |
1376 | sizeof(*r->cbp_chroma)); | ||
1377 | 9 | r->cbp_luma = av_mallocz(r->s.mb_stride * r->s.mb_height * | |
1378 | sizeof(*r->cbp_luma)); | ||
1379 | 9 | r->deblock_coefs = av_mallocz(r->s.mb_stride * r->s.mb_height * | |
1380 | sizeof(*r->deblock_coefs)); | ||
1381 | 9 | r->intra_types_hist = av_malloc(r->intra_types_stride * 4 * 2 * | |
1382 | sizeof(*r->intra_types_hist)); | ||
1383 | 9 | r->mb_type = av_mallocz(r->s.mb_stride * r->s.mb_height * | |
1384 | sizeof(*r->mb_type)); | ||
1385 | |||
1386 |
3/6✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 9 times.
✗ Branch 5 not taken.
|
9 | if (!(r->cbp_chroma && r->cbp_luma && r->deblock_coefs && |
1387 |
2/4✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 9 times.
|
9 | r->intra_types_hist && r->mb_type)) { |
1388 | ✗ | r->s.context_reinit = 1; | |
1389 | ✗ | rv34_decoder_free(r); | |
1390 | ✗ | return AVERROR(ENOMEM); | |
1391 | } | ||
1392 | |||
1393 | 9 | r->intra_types = r->intra_types_hist + r->intra_types_stride * 4; | |
1394 | |||
1395 | 9 | return 0; | |
1396 | } | ||
1397 | |||
1398 | |||
1399 | ✗ | static int rv34_decoder_realloc(RV34DecContext *r) | |
1400 | { | ||
1401 | ✗ | rv34_decoder_free(r); | |
1402 | ✗ | return rv34_decoder_alloc(r); | |
1403 | } | ||
1404 | |||
1405 | |||
1406 | 1385 | static int rv34_decode_slice(RV34DecContext *r, int end, const uint8_t* buf, int buf_size) | |
1407 | { | ||
1408 | 1385 | MpegEncContext *s = &r->s; | |
1409 | 1385 | GetBitContext *gb = &s->gb; | |
1410 | int mb_pos, slice_type; | ||
1411 | int res; | ||
1412 | |||
1413 | 1385 | init_get_bits(&r->s.gb, buf, buf_size*8); | |
1414 | 1385 | res = r->parse_slice_header(r, gb, &r->si); | |
1415 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1385 times.
|
1385 | if(res < 0){ |
1416 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Incorrect or unknown slice header\n"); | |
1417 | ✗ | return -1; | |
1418 | } | ||
1419 | |||
1420 |
2/2✓ Branch 0 taken 1326 times.
✓ Branch 1 taken 59 times.
|
1385 | slice_type = r->si.type ? r->si.type : AV_PICTURE_TYPE_I; |
1421 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1385 times.
|
1385 | if (slice_type != s->pict_type) { |
1422 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n"); | |
1423 | ✗ | return AVERROR_INVALIDDATA; | |
1424 | } | ||
1425 |
2/4✓ Branch 0 taken 1385 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1385 times.
|
1385 | if (s->width != r->si.width || s->height != r->si.height) { |
1426 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Size mismatch\n"); | |
1427 | ✗ | return AVERROR_INVALIDDATA; | |
1428 | } | ||
1429 | |||
1430 | 1385 | r->si.end = end; | |
1431 | 1385 | s->qscale = r->si.quant; | |
1432 | 1385 | s->mb_num_left = r->si.end - r->si.start; | |
1433 | 1385 | r->s.mb_skip_run = 0; | |
1434 | |||
1435 | 1385 | mb_pos = s->mb_x + s->mb_y * s->mb_width; | |
1436 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1385 times.
|
1385 | if(r->si.start != mb_pos){ |
1437 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Slice indicates MB offset %d, got %d\n", r->si.start, mb_pos); | |
1438 | ✗ | s->mb_x = r->si.start % s->mb_width; | |
1439 | ✗ | s->mb_y = r->si.start / s->mb_width; | |
1440 | } | ||
1441 | 1385 | memset(r->intra_types_hist, -1, r->intra_types_stride * 4 * 2 * sizeof(*r->intra_types_hist)); | |
1442 | 1385 | s->first_slice_line = 1; | |
1443 | 1385 | s->resync_mb_x = s->mb_x; | |
1444 | 1385 | s->resync_mb_y = s->mb_y; | |
1445 | |||
1446 | 1385 | ff_init_block_index(s); | |
1447 |
2/2✓ Branch 1 taken 292280 times.
✓ Branch 2 taken 1385 times.
|
293665 | while(!check_slice_end(r, s)) { |
1448 | 292280 | ff_update_block_index(s); | |
1449 | |||
1450 |
2/2✓ Branch 0 taken 284640 times.
✓ Branch 1 taken 7640 times.
|
292280 | if(r->si.type) |
1451 | 284640 | res = rv34_decode_inter_macroblock(r, r->intra_types + s->mb_x * 4 + 4); | |
1452 | else | ||
1453 | 7640 | res = rv34_decode_intra_macroblock(r, r->intra_types + s->mb_x * 4 + 4); | |
1454 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 292280 times.
|
292280 | if(res < 0){ |
1455 | ✗ | ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_ERROR); | |
1456 | ✗ | return -1; | |
1457 | } | ||
1458 |
2/2✓ Branch 0 taken 9408 times.
✓ Branch 1 taken 282872 times.
|
292280 | if (++s->mb_x == s->mb_width) { |
1459 | 9408 | s->mb_x = 0; | |
1460 | 9408 | s->mb_y++; | |
1461 | 9408 | ff_init_block_index(s); | |
1462 | |||
1463 | 9408 | memmove(r->intra_types_hist, r->intra_types, r->intra_types_stride * 4 * sizeof(*r->intra_types_hist)); | |
1464 | 9408 | memset(r->intra_types, -1, r->intra_types_stride * 4 * sizeof(*r->intra_types_hist)); | |
1465 | |||
1466 |
3/4✓ Branch 0 taken 9408 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8882 times.
✓ Branch 3 taken 526 times.
|
9408 | if(r->loop_filter && s->mb_y >= 2) |
1467 | 8882 | r->loop_filter(r, s->mb_y - 2); | |
1468 | |||
1469 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9408 times.
|
9408 | if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME)) |
1470 | ✗ | ff_thread_report_progress(&s->current_picture_ptr->tf, | |
1471 | ✗ | s->mb_y - 2, 0); | |
1472 | |||
1473 | } | ||
1474 |
2/2✓ Branch 0 taken 9031 times.
✓ Branch 1 taken 283249 times.
|
292280 | if(s->mb_x == s->resync_mb_x) |
1475 | 9031 | s->first_slice_line=0; | |
1476 | 292280 | s->mb_num_left--; | |
1477 | } | ||
1478 | 1385 | ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END); | |
1479 | |||
1480 | 1385 | return s->mb_y == s->mb_height; | |
1481 | } | ||
1482 | |||
1483 | /** @} */ // reconstruction group end | ||
1484 | |||
1485 | /** | ||
1486 | * Initialize decoder. | ||
1487 | */ | ||
1488 | 9 | av_cold int ff_rv34_decode_init(AVCodecContext *avctx) | |
1489 | { | ||
1490 | static AVOnce init_static_once = AV_ONCE_INIT; | ||
1491 | 9 | RV34DecContext *r = avctx->priv_data; | |
1492 | 9 | MpegEncContext *s = &r->s; | |
1493 | int ret; | ||
1494 | |||
1495 | 9 | ff_mpv_decode_init(s, avctx); | |
1496 | 9 | s->out_format = FMT_H263; | |
1497 | |||
1498 | 9 | avctx->pix_fmt = AV_PIX_FMT_YUV420P; | |
1499 | 9 | avctx->has_b_frames = 1; | |
1500 | 9 | s->low_delay = 0; | |
1501 | |||
1502 | 9 | ff_mpv_idct_init(s); | |
1503 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
|
9 | if ((ret = ff_mpv_common_init(s)) < 0) |
1504 | ✗ | return ret; | |
1505 | |||
1506 | 9 | ff_h264_pred_init(&r->h, AV_CODEC_ID_RV40, 8, 1); | |
1507 | |||
1508 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
|
9 | if ((ret = rv34_decoder_alloc(r)) < 0) { |
1509 | ✗ | ff_mpv_common_end(&r->s); | |
1510 | ✗ | return ret; | |
1511 | } | ||
1512 | |||
1513 | 9 | ff_thread_once(&init_static_once, rv34_init_tables); | |
1514 | |||
1515 | 9 | return 0; | |
1516 | } | ||
1517 | |||
1518 | ✗ | int ff_rv34_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src) | |
1519 | { | ||
1520 | ✗ | RV34DecContext *r = dst->priv_data, *r1 = src->priv_data; | |
1521 | ✗ | MpegEncContext * const s = &r->s, * const s1 = &r1->s; | |
1522 | int err; | ||
1523 | |||
1524 | ✗ | if (dst == src || !s1->context_initialized) | |
1525 | ✗ | return 0; | |
1526 | |||
1527 | ✗ | if (s->height != s1->height || s->width != s1->width || s->context_reinit) { | |
1528 | ✗ | s->height = s1->height; | |
1529 | ✗ | s->width = s1->width; | |
1530 | ✗ | if ((err = ff_mpv_common_frame_size_change(s)) < 0) | |
1531 | ✗ | return err; | |
1532 | ✗ | if ((err = rv34_decoder_realloc(r)) < 0) | |
1533 | ✗ | return err; | |
1534 | } | ||
1535 | |||
1536 | ✗ | r->cur_pts = r1->cur_pts; | |
1537 | ✗ | r->last_pts = r1->last_pts; | |
1538 | ✗ | r->next_pts = r1->next_pts; | |
1539 | |||
1540 | ✗ | memset(&r->si, 0, sizeof(r->si)); | |
1541 | |||
1542 | // Do no call ff_mpeg_update_thread_context on a partially initialized | ||
1543 | // decoder context. | ||
1544 | ✗ | if (!s1->context_initialized) | |
1545 | ✗ | return 0; | |
1546 | |||
1547 | ✗ | return ff_mpeg_update_thread_context(dst, src); | |
1548 | } | ||
1549 | |||
1550 | 4156 | static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n, int slice_count, int buf_size) | |
1551 | { | ||
1552 |
2/2✓ Branch 0 taken 3273 times.
✓ Branch 1 taken 883 times.
|
4156 | if (n < slice_count) { |
1553 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3273 times.
|
3273 | if(avctx->slice_count) return avctx->slice_offset[n]; |
1554 |
1/2✓ Branch 0 taken 3273 times.
✗ Branch 1 not taken.
|
3273 | else return AV_RL32(buf + n*8 - 4) == 1 ? AV_RL32(buf + n*8) : AV_RB32(buf + n*8); |
1555 | } else | ||
1556 | 883 | return buf_size; | |
1557 | } | ||
1558 | |||
1559 | 526 | static int finish_frame(AVCodecContext *avctx, AVFrame *pict) | |
1560 | { | ||
1561 | 526 | RV34DecContext *r = avctx->priv_data; | |
1562 | 526 | MpegEncContext *s = &r->s; | |
1563 | 526 | int got_picture = 0, ret; | |
1564 | |||
1565 | 526 | ff_er_frame_end(&s->er); | |
1566 | 526 | ff_mpv_frame_end(s); | |
1567 | 526 | s->mb_num_left = 0; | |
1568 | |||
1569 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 526 times.
|
526 | if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME)) |
1570 | ✗ | ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0); | |
1571 | |||
1572 |
3/4✓ Branch 0 taken 139 times.
✓ Branch 1 taken 387 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 139 times.
|
526 | if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) { |
1573 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 387 times.
|
387 | if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0) |
1574 | ✗ | return ret; | |
1575 | 387 | ff_print_debug_info(s, s->current_picture_ptr, pict); | |
1576 | 387 | ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_MPV_QSCALE_TYPE_MPEG1); | |
1577 | 387 | got_picture = 1; | |
1578 |
2/2✓ Branch 0 taken 130 times.
✓ Branch 1 taken 9 times.
|
139 | } else if (s->last_picture_ptr) { |
1579 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 130 times.
|
130 | if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0) |
1580 | ✗ | return ret; | |
1581 | 130 | ff_print_debug_info(s, s->last_picture_ptr, pict); | |
1582 | 130 | ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_MPV_QSCALE_TYPE_MPEG1); | |
1583 | 130 | got_picture = 1; | |
1584 | } | ||
1585 | |||
1586 | 526 | return got_picture; | |
1587 | } | ||
1588 | |||
1589 | ✗ | static AVRational update_sar(int old_w, int old_h, AVRational sar, int new_w, int new_h) | |
1590 | { | ||
1591 | // attempt to keep aspect during typical resolution switches | ||
1592 | ✗ | if (!sar.num) | |
1593 | ✗ | sar = (AVRational){1, 1}; | |
1594 | |||
1595 | ✗ | sar = av_mul_q(sar, av_mul_q((AVRational){new_h, new_w}, (AVRational){old_w, old_h})); | |
1596 | ✗ | return sar; | |
1597 | } | ||
1598 | |||
1599 | 532 | int ff_rv34_decode_frame(AVCodecContext *avctx, AVFrame *pict, | |
1600 | int *got_picture_ptr, AVPacket *avpkt) | ||
1601 | { | ||
1602 | 532 | const uint8_t *buf = avpkt->data; | |
1603 | 532 | int buf_size = avpkt->size; | |
1604 | 532 | RV34DecContext *r = avctx->priv_data; | |
1605 | 532 | MpegEncContext *s = &r->s; | |
1606 | SliceInfo si; | ||
1607 | int i, ret; | ||
1608 | int slice_count; | ||
1609 | 532 | const uint8_t *slices_hdr = NULL; | |
1610 | 532 | int last = 0; | |
1611 | 532 | int faulty_b = 0; | |
1612 | int offset; | ||
1613 | |||
1614 | /* no supplementary picture */ | ||
1615 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 526 times.
|
532 | if (buf_size == 0) { |
1616 | /* special case for last picture */ | ||
1617 |
3/4✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 2 times.
|
6 | if (s->low_delay==0 && s->next_picture_ptr) { |
1618 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
|
4 | if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0) |
1619 | ✗ | return ret; | |
1620 | 4 | s->next_picture_ptr = NULL; | |
1621 | |||
1622 | 4 | *got_picture_ptr = 1; | |
1623 | } | ||
1624 | 6 | return 0; | |
1625 | } | ||
1626 | |||
1627 |
1/2✓ Branch 0 taken 526 times.
✗ Branch 1 not taken.
|
526 | if(!avctx->slice_count){ |
1628 | 526 | slice_count = (*buf++) + 1; | |
1629 | 526 | slices_hdr = buf + 4; | |
1630 | 526 | buf += 8 * slice_count; | |
1631 | 526 | buf_size -= 1 + 8 * slice_count; | |
1632 | }else | ||
1633 | ✗ | slice_count = avctx->slice_count; | |
1634 | |||
1635 | 526 | offset = get_slice_offset(avctx, slices_hdr, 0, slice_count, buf_size); | |
1636 | //parse first slice header to check whether this frame can be decoded | ||
1637 |
2/4✓ Branch 0 taken 526 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 526 times.
|
526 | if(offset < 0 || offset > buf_size){ |
1638 | ✗ | av_log(avctx, AV_LOG_ERROR, "Slice offset is invalid\n"); | |
1639 | ✗ | return AVERROR_INVALIDDATA; | |
1640 | } | ||
1641 | 526 | init_get_bits(&s->gb, buf+offset, (buf_size-offset)*8); | |
1642 |
2/4✓ Branch 1 taken 526 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 526 times.
|
526 | if(r->parse_slice_header(r, &r->s.gb, &si) < 0 || si.start){ |
1643 | ✗ | av_log(avctx, AV_LOG_ERROR, "First slice header is incorrect\n"); | |
1644 | ✗ | return AVERROR_INVALIDDATA; | |
1645 | } | ||
1646 |
3/4✓ Branch 0 taken 513 times.
✓ Branch 1 taken 13 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 513 times.
|
526 | if ((!s->last_picture_ptr || !s->last_picture_ptr->f->data[0]) && |
1647 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
|
13 | si.type == AV_PICTURE_TYPE_B) { |
1648 | ✗ | av_log(avctx, AV_LOG_ERROR, "Invalid decoder state: B-frame without " | |
1649 | "reference data.\n"); | ||
1650 | ✗ | faulty_b = 1; | |
1651 | } | ||
1652 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 526 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
526 | if( (avctx->skip_frame >= AVDISCARD_NONREF && si.type==AV_PICTURE_TYPE_B) |
1653 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 526 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
526 | || (avctx->skip_frame >= AVDISCARD_NONKEY && si.type!=AV_PICTURE_TYPE_I) |
1654 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 526 times.
|
526 | || avctx->skip_frame >= AVDISCARD_ALL) |
1655 | ✗ | return avpkt->size; | |
1656 | |||
1657 | /* first slice */ | ||
1658 |
1/2✓ Branch 0 taken 526 times.
✗ Branch 1 not taken.
|
526 | if (si.start == 0) { |
1659 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 526 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
526 | if (s->mb_num_left > 0 && s->current_picture_ptr) { |
1660 | ✗ | av_log(avctx, AV_LOG_ERROR, "New frame but still %d MB left.\n", | |
1661 | s->mb_num_left); | ||
1662 | ✗ | if (!s->context_reinit) | |
1663 | ✗ | ff_er_frame_end(&s->er); | |
1664 | ✗ | ff_mpv_frame_end(s); | |
1665 | } | ||
1666 | |||
1667 |
3/6✓ Branch 0 taken 526 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 526 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 526 times.
|
526 | if (s->width != si.width || s->height != si.height || s->context_reinit) { |
1668 | int err; | ||
1669 | |||
1670 | ✗ | av_log(s->avctx, AV_LOG_WARNING, "Changing dimensions to %dx%d\n", | |
1671 | si.width, si.height); | ||
1672 | |||
1673 | ✗ | if (av_image_check_size(si.width, si.height, 0, s->avctx)) | |
1674 | ✗ | return AVERROR_INVALIDDATA; | |
1675 | |||
1676 | ✗ | s->avctx->sample_aspect_ratio = update_sar( | |
1677 | ✗ | s->width, s->height, s->avctx->sample_aspect_ratio, | |
1678 | si.width, si.height); | ||
1679 | ✗ | s->width = si.width; | |
1680 | ✗ | s->height = si.height; | |
1681 | |||
1682 | ✗ | err = ff_set_dimensions(s->avctx, s->width, s->height); | |
1683 | ✗ | if (err < 0) | |
1684 | ✗ | return err; | |
1685 | ✗ | if ((err = ff_mpv_common_frame_size_change(s)) < 0) | |
1686 | ✗ | return err; | |
1687 | ✗ | if ((err = rv34_decoder_realloc(r)) < 0) | |
1688 | ✗ | return err; | |
1689 | } | ||
1690 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 526 times.
|
526 | if (faulty_b) |
1691 | ✗ | return AVERROR_INVALIDDATA; | |
1692 |
2/2✓ Branch 0 taken 508 times.
✓ Branch 1 taken 18 times.
|
526 | s->pict_type = si.type ? si.type : AV_PICTURE_TYPE_I; |
1693 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 526 times.
|
526 | if (ff_mpv_frame_start(s, s->avctx) < 0) |
1694 | ✗ | return -1; | |
1695 | 526 | ff_mpeg_er_frame_start(s); | |
1696 |
2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 517 times.
|
526 | if (!r->tmp_b_block_base) { |
1697 | int i; | ||
1698 | |||
1699 | 9 | r->tmp_b_block_base = av_malloc(s->linesize * 48); | |
1700 |
2/2✓ Branch 0 taken 18 times.
✓ Branch 1 taken 9 times.
|
27 | for (i = 0; i < 2; i++) |
1701 | 18 | r->tmp_b_block_y[i] = r->tmp_b_block_base | |
1702 | 18 | + i * 16 * s->linesize; | |
1703 |
2/2✓ Branch 0 taken 36 times.
✓ Branch 1 taken 9 times.
|
45 | for (i = 0; i < 4; i++) |
1704 | 36 | r->tmp_b_block_uv[i] = r->tmp_b_block_base + 32 * s->linesize | |
1705 | 36 | + (i >> 1) * 8 * s->uvlinesize | |
1706 | 36 | + (i & 1) * 16; | |
1707 | } | ||
1708 | 526 | r->cur_pts = si.pts; | |
1709 |
2/2✓ Branch 0 taken 139 times.
✓ Branch 1 taken 387 times.
|
526 | if (s->pict_type != AV_PICTURE_TYPE_B) { |
1710 | 139 | r->last_pts = r->next_pts; | |
1711 | 139 | r->next_pts = r->cur_pts; | |
1712 | } else { | ||
1713 | 387 | int refdist = GET_PTS_DIFF(r->next_pts, r->last_pts); | |
1714 | 387 | int dist0 = GET_PTS_DIFF(r->cur_pts, r->last_pts); | |
1715 | 387 | int dist1 = GET_PTS_DIFF(r->next_pts, r->cur_pts); | |
1716 | |||
1717 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 387 times.
|
387 | if(!refdist){ |
1718 | ✗ | r->mv_weight1 = r->mv_weight2 = r->weight1 = r->weight2 = 8192; | |
1719 | ✗ | r->scaled_weight = 0; | |
1720 | }else{ | ||
1721 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 387 times.
|
387 | if (FFMAX(dist0, dist1) > refdist) |
1722 | ✗ | av_log(avctx, AV_LOG_TRACE, "distance overflow\n"); | |
1723 | |||
1724 | 387 | r->mv_weight1 = (dist0 << 14) / refdist; | |
1725 | 387 | r->mv_weight2 = (dist1 << 14) / refdist; | |
1726 |
2/2✓ Branch 0 taken 349 times.
✓ Branch 1 taken 38 times.
|
387 | if((r->mv_weight1|r->mv_weight2) & 511){ |
1727 | 349 | r->weight1 = r->mv_weight1; | |
1728 | 349 | r->weight2 = r->mv_weight2; | |
1729 | 349 | r->scaled_weight = 0; | |
1730 | }else{ | ||
1731 | 38 | r->weight1 = r->mv_weight1 >> 9; | |
1732 | 38 | r->weight2 = r->mv_weight2 >> 9; | |
1733 | 38 | r->scaled_weight = 1; | |
1734 | } | ||
1735 | } | ||
1736 | } | ||
1737 | 526 | s->mb_x = s->mb_y = 0; | |
1738 | 526 | ff_thread_finish_setup(s->avctx); | |
1739 | ✗ | } else if (s->context_reinit) { | |
1740 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Decoder needs full frames to " | |
1741 | "reinitialize (start MB is %d).\n", si.start); | ||
1742 | ✗ | return AVERROR_INVALIDDATA; | |
1743 | ✗ | } else if (HAVE_THREADS && | |
1744 | ✗ | (s->avctx->active_thread_type & FF_THREAD_FRAME)) { | |
1745 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Decoder needs full frames in frame " | |
1746 | "multithreading mode (start MB is %d).\n", si.start); | ||
1747 | ✗ | return AVERROR_INVALIDDATA; | |
1748 | } | ||
1749 | |||
1750 |
1/2✓ Branch 0 taken 1385 times.
✗ Branch 1 not taken.
|
1385 | for(i = 0; i < slice_count; i++){ |
1751 | 1385 | int offset = get_slice_offset(avctx, slices_hdr, i , slice_count, buf_size); | |
1752 | 1385 | int offset1 = get_slice_offset(avctx, slices_hdr, i+1, slice_count, buf_size); | |
1753 | int size; | ||
1754 | |||
1755 |
3/6✓ Branch 0 taken 1385 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1385 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 1385 times.
|
1385 | if(offset < 0 || offset > offset1 || offset1 > buf_size){ |
1756 | ✗ | av_log(avctx, AV_LOG_ERROR, "Slice offset is invalid\n"); | |
1757 | ✗ | break; | |
1758 | } | ||
1759 | 1385 | size = offset1 - offset; | |
1760 | |||
1761 | 1385 | r->si.end = s->mb_width * s->mb_height; | |
1762 | 1385 | s->mb_num_left = r->s.mb_x + r->s.mb_y*r->s.mb_width - r->si.start; | |
1763 | |||
1764 |
2/2✓ Branch 0 taken 860 times.
✓ Branch 1 taken 525 times.
|
1385 | if(i+1 < slice_count){ |
1765 | 860 | int offset2 = get_slice_offset(avctx, slices_hdr, i+2, slice_count, buf_size); | |
1766 |
2/4✓ Branch 0 taken 860 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 860 times.
|
860 | if (offset2 < offset1 || offset2 > buf_size) { |
1767 | ✗ | av_log(avctx, AV_LOG_ERROR, "Slice offset is invalid\n"); | |
1768 | ✗ | break; | |
1769 | } | ||
1770 | 860 | init_get_bits(&s->gb, buf+offset1, (buf_size-offset1)*8); | |
1771 |
2/2✓ Branch 1 taken 1 times.
✓ Branch 2 taken 859 times.
|
860 | if(r->parse_slice_header(r, &r->s.gb, &si) < 0){ |
1772 | 1 | size = offset2 - offset; | |
1773 | }else | ||
1774 | 859 | r->si.end = si.start; | |
1775 | } | ||
1776 |
2/4✓ Branch 0 taken 1385 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1385 times.
|
1385 | av_assert0 (size >= 0 && size <= buf_size - offset); |
1777 | 1385 | last = rv34_decode_slice(r, r->si.end, buf + offset, size); | |
1778 |
2/2✓ Branch 0 taken 526 times.
✓ Branch 1 taken 859 times.
|
1385 | if(last) |
1779 | 526 | break; | |
1780 | } | ||
1781 | |||
1782 |
1/2✓ Branch 0 taken 526 times.
✗ Branch 1 not taken.
|
526 | if (s->current_picture_ptr) { |
1783 |
1/2✓ Branch 0 taken 526 times.
✗ Branch 1 not taken.
|
526 | if (last) { |
1784 |
1/2✓ Branch 0 taken 526 times.
✗ Branch 1 not taken.
|
526 | if(r->loop_filter) |
1785 | 526 | r->loop_filter(r, s->mb_height - 1); | |
1786 | |||
1787 | 526 | ret = finish_frame(avctx, pict); | |
1788 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 526 times.
|
526 | if (ret < 0) |
1789 | ✗ | return ret; | |
1790 | 526 | *got_picture_ptr = ret; | |
1791 | ✗ | } else if (HAVE_THREADS && | |
1792 | ✗ | (s->avctx->active_thread_type & FF_THREAD_FRAME)) { | |
1793 | ✗ | av_log(avctx, AV_LOG_INFO, "marking unfished frame as finished\n"); | |
1794 | /* always mark the current frame as finished, frame-mt supports | ||
1795 | * only complete frames */ | ||
1796 | ✗ | ff_er_frame_end(&s->er); | |
1797 | ✗ | ff_mpv_frame_end(s); | |
1798 | ✗ | s->mb_num_left = 0; | |
1799 | ✗ | ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0); | |
1800 | ✗ | return AVERROR_INVALIDDATA; | |
1801 | } | ||
1802 | } | ||
1803 | |||
1804 | 526 | return avpkt->size; | |
1805 | } | ||
1806 | |||
1807 | 9 | av_cold int ff_rv34_decode_end(AVCodecContext *avctx) | |
1808 | { | ||
1809 | 9 | RV34DecContext *r = avctx->priv_data; | |
1810 | |||
1811 | 9 | ff_mpv_common_end(&r->s); | |
1812 | 9 | rv34_decoder_free(r); | |
1813 | |||
1814 | 9 | return 0; | |
1815 | } | ||
1816 |