Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * This file is part of FFmpeg. | ||
3 | * | ||
4 | * FFmpeg is free software; you can redistribute it and/or | ||
5 | * modify it under the terms of the GNU Lesser General Public | ||
6 | * License as published by the Free Software Foundation; either | ||
7 | * version 2.1 of the License, or (at your option) any later version. | ||
8 | * | ||
9 | * FFmpeg is distributed in the hope that it will be useful, | ||
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
12 | * Lesser General Public License for more details. | ||
13 | * | ||
14 | * You should have received a copy of the GNU Lesser General Public | ||
15 | * License along with FFmpeg; if not, write to the Free Software | ||
16 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
17 | */ | ||
18 | |||
19 | /** | ||
20 | * @file | ||
21 | * @brief IntraX8 (J-Frame) subdecoder, used by WMV2 and VC-1 | ||
22 | */ | ||
23 | |||
24 | #include "libavutil/avassert.h" | ||
25 | #include "libavutil/thread.h" | ||
26 | #include "avcodec.h" | ||
27 | #include "get_bits.h" | ||
28 | #include "idctdsp.h" | ||
29 | #include "msmpeg4_vc1_data.h" | ||
30 | #include "intrax8huf.h" | ||
31 | #include "intrax8.h" | ||
32 | #include "intrax8dsp.h" | ||
33 | #include "mpegutils.h" | ||
34 | |||
35 | #define VLC_BUFFER_SIZE 28150 | ||
36 | |||
37 | #define MAX_TABLE_DEPTH(table_bits, max_bits) \ | ||
38 | ((max_bits + table_bits - 1) / table_bits) | ||
39 | |||
40 | #define DC_VLC_BITS 9 | ||
41 | #define AC_VLC_BITS 9 | ||
42 | #define OR_VLC_BITS 7 | ||
43 | |||
44 | #define DC_VLC_MTD MAX_TABLE_DEPTH(DC_VLC_BITS, MAX_DC_VLC_BITS) | ||
45 | #define AC_VLC_MTD MAX_TABLE_DEPTH(AC_VLC_BITS, MAX_AC_VLC_BITS) | ||
46 | #define OR_VLC_MTD MAX_TABLE_DEPTH(OR_VLC_BITS, MAX_OR_VLC_BITS) | ||
47 | |||
48 | static VLC j_ac_vlc[2][2][8]; // [quant < 13], [intra / inter], [select] | ||
49 | static VLC j_dc_vlc[2][8]; // [quant], [select] | ||
50 | static VLC j_orient_vlc[2][4]; // [quant], [select] | ||
51 | |||
52 | 1242 | static av_cold void x8_init_vlc(VLC *vlc, int nb_bits, int nb_codes, | |
53 | int *offset, const uint8_t table[][2]) | ||
54 | { | ||
55 | static VLCElem vlc_buf[VLC_BUFFER_SIZE]; | ||
56 | |||
57 | 1242 | vlc->table = &vlc_buf[*offset]; | |
58 | 1242 | vlc->table_allocated = VLC_BUFFER_SIZE - *offset; | |
59 | 1242 | ff_init_vlc_from_lengths(vlc, nb_bits, nb_codes, &table[0][1], 2, | |
60 | 1242 | &table[0][0], 2, 1, 0, INIT_VLC_STATIC_OVERLONG, NULL); | |
61 | 1242 | *offset += vlc->table_size; | |
62 | 1242 | } | |
63 | |||
64 | 23 | static av_cold void x8_vlc_init(void) | |
65 | { | ||
66 | int i; | ||
67 | 23 | int offset = 0; | |
68 | |||
69 | // set ac tables | ||
70 |
2/2✓ Branch 0 taken 46 times.
✓ Branch 1 taken 23 times.
|
69 | for (int i = 0; i < 2; i++) |
71 |
2/2✓ Branch 0 taken 92 times.
✓ Branch 1 taken 46 times.
|
138 | for (int j = 0; j < 2; j++) |
72 |
2/2✓ Branch 0 taken 736 times.
✓ Branch 1 taken 92 times.
|
828 | for (int k = 0; k < 8; k++) |
73 | 736 | x8_init_vlc(&j_ac_vlc[i][j][k], AC_VLC_BITS, 77, | |
74 | 736 | &offset, x8_ac_quant_table[i][j][k]); | |
75 | |||
76 | // set dc tables | ||
77 |
2/2✓ Branch 0 taken 46 times.
✓ Branch 1 taken 23 times.
|
69 | for (int i = 0; i < 2; i++) |
78 |
2/2✓ Branch 0 taken 368 times.
✓ Branch 1 taken 46 times.
|
414 | for (int j = 0; j < 8; j++) |
79 | 368 | x8_init_vlc(&j_dc_vlc[i][j], DC_VLC_BITS, 34, &offset, | |
80 | 368 | x8_dc_quant_table[i][j]); | |
81 | |||
82 | // set orient tables | ||
83 |
2/2✓ Branch 0 taken 46 times.
✓ Branch 1 taken 23 times.
|
69 | for (i = 0; i < 2; i++) |
84 | 46 | x8_init_vlc(&j_orient_vlc[0][i], OR_VLC_BITS, 12, | |
85 | 46 | &offset, x8_orient_highquant_table[i]); | |
86 |
2/2✓ Branch 0 taken 92 times.
✓ Branch 1 taken 23 times.
|
115 | for (i = 0; i < 4; i++) |
87 | 92 | x8_init_vlc(&j_orient_vlc[1][i], OR_VLC_BITS, 12, | |
88 | 92 | &offset, x8_orient_lowquant_table[i]); | |
89 | |||
90 | av_assert2(offset == VLC_BUFFER_SIZE); | ||
91 | 23 | } | |
92 | |||
93 | 3 | static void x8_reset_vlc_tables(IntraX8Context *w) | |
94 | { | ||
95 | 3 | memset(w->j_dc_vlc_table, 0, sizeof(w->j_dc_vlc_table)); | |
96 | 3 | memset(w->j_ac_vlc_table, 0, sizeof(w->j_ac_vlc_table)); | |
97 | 3 | w->j_orient_vlc_table = NULL; | |
98 | 3 | } | |
99 | |||
100 | 3909 | static inline void x8_select_ac_table(IntraX8Context *const w, int mode) | |
101 | { | ||
102 | int table_index; | ||
103 | |||
104 | av_assert2(mode < 4); | ||
105 | |||
106 |
2/2✓ Branch 0 taken 3897 times.
✓ Branch 1 taken 12 times.
|
3909 | if (w->j_ac_vlc_table[mode]) |
107 | 3897 | return; | |
108 | |||
109 | 12 | table_index = get_bits(w->gb, 3); | |
110 | // 2 modes use same tables | ||
111 | 12 | w->j_ac_vlc_table[mode] = j_ac_vlc[w->quant < 13][mode >> 1][table_index].table; | |
112 | av_assert2(w->j_ac_vlc[mode]); | ||
113 | } | ||
114 | |||
115 | 1304 | static inline int x8_get_orient_vlc(IntraX8Context *w) | |
116 | { | ||
117 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1301 times.
|
1304 | if (!w->j_orient_vlc_table) { |
118 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2 times.
|
3 | int table_index = get_bits(w->gb, 1 + (w->quant < 13)); |
119 | 3 | w->j_orient_vlc_table = j_orient_vlc[w->quant < 13][table_index].table; | |
120 | } | ||
121 | |||
122 | 1304 | return get_vlc2(w->gb, w->j_orient_vlc_table, OR_VLC_BITS, OR_VLC_MTD); | |
123 | } | ||
124 | |||
125 | #define extra_bits(eb) (eb) // 3 bits | ||
126 | #define extra_run (0xFF << 8) // 1 bit | ||
127 | #define extra_level (0x00 << 8) // 1 bit | ||
128 | #define run_offset(r) ((r) << 16) // 6 bits | ||
129 | #define level_offset(l) ((l) << 24) // 5 bits | ||
130 | static const uint32_t ac_decode_table[] = { | ||
131 | /* 46 */ extra_bits(3) | extra_run | run_offset(16) | level_offset(0), | ||
132 | /* 47 */ extra_bits(3) | extra_run | run_offset(24) | level_offset(0), | ||
133 | /* 48 */ extra_bits(2) | extra_run | run_offset(4) | level_offset(1), | ||
134 | /* 49 */ extra_bits(3) | extra_run | run_offset(8) | level_offset(1), | ||
135 | |||
136 | /* 50 */ extra_bits(5) | extra_run | run_offset(32) | level_offset(0), | ||
137 | /* 51 */ extra_bits(4) | extra_run | run_offset(16) | level_offset(1), | ||
138 | |||
139 | /* 52 */ extra_bits(2) | extra_level | run_offset(0) | level_offset(4), | ||
140 | /* 53 */ extra_bits(2) | extra_level | run_offset(0) | level_offset(8), | ||
141 | /* 54 */ extra_bits(2) | extra_level | run_offset(0) | level_offset(12), | ||
142 | /* 55 */ extra_bits(3) | extra_level | run_offset(0) | level_offset(16), | ||
143 | /* 56 */ extra_bits(3) | extra_level | run_offset(0) | level_offset(24), | ||
144 | |||
145 | /* 57 */ extra_bits(2) | extra_level | run_offset(1) | level_offset(3), | ||
146 | /* 58 */ extra_bits(3) | extra_level | run_offset(1) | level_offset(7), | ||
147 | |||
148 | /* 59 */ extra_bits(2) | extra_run | run_offset(16) | level_offset(0), | ||
149 | /* 60 */ extra_bits(2) | extra_run | run_offset(20) | level_offset(0), | ||
150 | /* 61 */ extra_bits(2) | extra_run | run_offset(24) | level_offset(0), | ||
151 | /* 62 */ extra_bits(2) | extra_run | run_offset(28) | level_offset(0), | ||
152 | /* 63 */ extra_bits(4) | extra_run | run_offset(32) | level_offset(0), | ||
153 | /* 64 */ extra_bits(4) | extra_run | run_offset(48) | level_offset(0), | ||
154 | |||
155 | /* 65 */ extra_bits(2) | extra_run | run_offset(4) | level_offset(1), | ||
156 | /* 66 */ extra_bits(3) | extra_run | run_offset(8) | level_offset(1), | ||
157 | /* 67 */ extra_bits(4) | extra_run | run_offset(16) | level_offset(1), | ||
158 | |||
159 | /* 68 */ extra_bits(2) | extra_level | run_offset(0) | level_offset(4), | ||
160 | /* 69 */ extra_bits(3) | extra_level | run_offset(0) | level_offset(8), | ||
161 | /* 70 */ extra_bits(4) | extra_level | run_offset(0) | level_offset(16), | ||
162 | |||
163 | /* 71 */ extra_bits(2) | extra_level | run_offset(1) | level_offset(3), | ||
164 | /* 72 */ extra_bits(3) | extra_level | run_offset(1) | level_offset(7), | ||
165 | }; | ||
166 | #undef extra_bits | ||
167 | #undef extra_run | ||
168 | #undef extra_level | ||
169 | #undef run_offset | ||
170 | #undef level_offset | ||
171 | |||
172 | 8932 | static void x8_get_ac_rlf(IntraX8Context *const w, const int mode, | |
173 | int *const run, int *const level, int *const final) | ||
174 | { | ||
175 | int i, e; | ||
176 | |||
177 | // x8_select_ac_table(w, mode); | ||
178 | 8932 | i = get_vlc2(w->gb, w->j_ac_vlc_table[mode], AC_VLC_BITS, AC_VLC_MTD); | |
179 | |||
180 |
2/2✓ Branch 0 taken 7635 times.
✓ Branch 1 taken 1297 times.
|
8932 | if (i < 46) { // [0-45] |
181 | int t, l; | ||
182 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7635 times.
|
7635 | if (i < 0) { |
183 | ✗ | *level = | |
184 | ✗ | *final = // prevent 'may be used uninitialized' | |
185 | ✗ | *run = 64; // this would cause error exit in the ac loop | |
186 | ✗ | return; | |
187 | } | ||
188 | |||
189 | /* | ||
190 | * i == 0-15 r = 0-15 l = 0; r = i & %01111 | ||
191 | * i == 16-19 r = 0-3 l = 1; r = i & %00011 | ||
192 | * i == 20-21 r = 0-1 l = 2; r = i & %00001 | ||
193 | * i == 22 r = 0 l = 3; r = i & %00000 | ||
194 | */ | ||
195 | |||
196 | 7635 | *final = | |
197 | 7635 | t = i > 22; | |
198 | 7635 | i -= 23 * t; | |
199 | |||
200 | /* l = lut_l[i / 2] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 3 }[i >> 1]; | ||
201 | * 11 10'01 01'00 00'00 00'00 00'00 00 => 0xE50000 */ | ||
202 | 7635 | l = (0xE50000 >> (i & 0x1E)) & 3; // 0x1E or ~1 or (i >> 1 << 1) | |
203 | |||
204 | /* t = lut_mask[l] = { 0x0f, 0x03, 0x01, 0x00 }[l]; | ||
205 | * as i < 256 the higher bits do not matter */ | ||
206 | 7635 | t = 0x01030F >> (l << 3); | |
207 | |||
208 | 7635 | *run = i & t; | |
209 | 7635 | *level = l; | |
210 |
2/2✓ Branch 0 taken 1057 times.
✓ Branch 1 taken 240 times.
|
1297 | } else if (i < 73) { // [46-72] |
211 | uint32_t sm; | ||
212 | uint32_t mask; | ||
213 | |||
214 | 1057 | i -= 46; | |
215 | 1057 | sm = ac_decode_table[i]; | |
216 | |||
217 | 1057 | e = get_bits(w->gb, sm & 0xF); | |
218 | 1057 | sm >>= 8; // 3 bits | |
219 | 1057 | mask = sm & 0xff; | |
220 | 1057 | sm >>= 8; // 1 bit | |
221 | |||
222 | 1057 | *run = (sm & 0xff) + (e & mask); // 6 bits | |
223 | 1057 | *level = (sm >> 8) + (e & ~mask); // 5 bits | |
224 | 1057 | *final = i > (58 - 46); | |
225 |
2/2✓ Branch 0 taken 234 times.
✓ Branch 1 taken 6 times.
|
240 | } else if (i < 75) { // [73-74] |
226 | static const uint8_t crazy_mix_runlevel[32] = { | ||
227 | 0x22, 0x32, 0x33, 0x53, 0x23, 0x42, 0x43, 0x63, | ||
228 | 0x24, 0x52, 0x34, 0x73, 0x25, 0x62, 0x44, 0x83, | ||
229 | 0x26, 0x72, 0x35, 0x54, 0x27, 0x82, 0x45, 0x64, | ||
230 | 0x28, 0x92, 0x36, 0x74, 0x29, 0xa2, 0x46, 0x84, | ||
231 | }; | ||
232 | |||
233 | 234 | *final = !(i & 1); | |
234 | 234 | e = get_bits(w->gb, 5); // get the extra bits | |
235 | 234 | *run = crazy_mix_runlevel[e] >> 4; | |
236 | 234 | *level = crazy_mix_runlevel[e] & 0x0F; | |
237 | } else { | ||
238 | 6 | *level = get_bits(w->gb, 7 - 3 * (i & 1)); | |
239 | 6 | *run = get_bits(w->gb, 6); | |
240 | 6 | *final = get_bits1(w->gb); | |
241 | } | ||
242 | 8932 | return; | |
243 | } | ||
244 | |||
245 | /* static const uint8_t dc_extra_sbits[] = { | ||
246 | * 0, 1, 1, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, | ||
247 | * }; */ | ||
248 | static const uint8_t dc_index_offset[] = { | ||
249 | 0, 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, | ||
250 | }; | ||
251 | |||
252 | 5400 | static int x8_get_dc_rlf(IntraX8Context *const w, const int mode, | |
253 | int *const level, int *const final) | ||
254 | { | ||
255 | int i, e, c; | ||
256 | |||
257 | av_assert2(mode < 3); | ||
258 |
2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 5391 times.
|
5400 | if (!w->j_dc_vlc_table[mode]) { |
259 | 9 | int table_index = get_bits(w->gb, 3); | |
260 | // 4 modes, same table | ||
261 | 9 | w->j_dc_vlc_table[mode] = j_dc_vlc[w->quant < 13][table_index].table; | |
262 | } | ||
263 | |||
264 | 5400 | i = get_vlc2(w->gb, w->j_dc_vlc_table[mode], DC_VLC_BITS, DC_VLC_MTD); | |
265 | |||
266 | /* (i >= 17) { i -= 17; final =1; } */ | ||
267 | 5400 | c = i > 16; | |
268 | 5400 | *final = c; | |
269 | 5400 | i -= 17 * c; | |
270 | |||
271 |
2/2✓ Branch 0 taken 1320 times.
✓ Branch 1 taken 4080 times.
|
5400 | if (i <= 0) { |
272 | 1320 | *level = 0; | |
273 | 1320 | return -i; | |
274 | } | ||
275 | 4080 | c = (i + 1) >> 1; // hackish way to calculate dc_extra_sbits[] | |
276 | 4080 | c -= c > 1; | |
277 | |||
278 | 4080 | e = get_bits(w->gb, c); // get the extra bits | |
279 | 4080 | i = dc_index_offset[i] + (e >> 1); | |
280 | |||
281 | 4080 | e = -(e & 1); // 0, 0xffffff | |
282 | 4080 | *level = (i ^ e) - e; // (i ^ 0) - 0, (i ^ 0xff) - (-1) | |
283 | 4080 | return 0; | |
284 | } | ||
285 | |||
286 | // end of huffman | ||
287 | |||
288 | 5400 | static int x8_setup_spatial_predictor(IntraX8Context *const w, const int chroma) | |
289 | { | ||
290 | int range; | ||
291 | int sum; | ||
292 | int quant; | ||
293 | |||
294 | 5400 | w->dsp.setup_spatial_compensation(w->dest[chroma], w->scratchpad, | |
295 | 5400 | w->frame->linesize[chroma > 0], | |
296 | &range, &sum, w->edges); | ||
297 |
2/2✓ Branch 0 taken 1800 times.
✓ Branch 1 taken 3600 times.
|
5400 | if (chroma) { |
298 | 1800 | w->orient = w->chroma_orient; | |
299 | 1800 | quant = w->quant_dc_chroma; | |
300 | } else { | ||
301 | 3600 | quant = w->quant; | |
302 | } | ||
303 | |||
304 | 5400 | w->flat_dc = 0; | |
305 |
3/4✓ Branch 0 taken 2014 times.
✓ Branch 1 taken 3386 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2014 times.
|
5400 | if (range < quant || range < 3) { |
306 | 3386 | w->orient = 0; | |
307 | |||
308 | // yep you read right, a +-1 idct error may break decoding! | ||
309 |
2/2✓ Branch 0 taken 1365 times.
✓ Branch 1 taken 2021 times.
|
3386 | if (range < 3) { |
310 | 1365 | w->flat_dc = 1; | |
311 | 1365 | sum += 9; | |
312 | // ((1 << 17) + 9) / (8 + 8 + 1 + 2) = 6899 | ||
313 | 1365 | w->predicted_dc = sum * 6899 >> 17; | |
314 | } | ||
315 | } | ||
316 |
2/2✓ Branch 0 taken 1800 times.
✓ Branch 1 taken 3600 times.
|
5400 | if (chroma) |
317 | 1800 | return 0; | |
318 | |||
319 | av_assert2(w->orient < 3); | ||
320 |
2/2✓ Branch 0 taken 2296 times.
✓ Branch 1 taken 1304 times.
|
3600 | if (range < 2 * w->quant) { |
321 |
2/2✓ Branch 0 taken 2102 times.
✓ Branch 1 taken 194 times.
|
2296 | if ((w->edges & 3) == 0) { |
322 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 2096 times.
|
2102 | if (w->orient == 1) |
323 | 6 | w->orient = 11; | |
324 |
2/2✓ Branch 0 taken 16 times.
✓ Branch 1 taken 2086 times.
|
2102 | if (w->orient == 2) |
325 | 16 | w->orient = 10; | |
326 | } else { | ||
327 | 194 | w->orient = 0; | |
328 | } | ||
329 | 2296 | w->raw_orient = 0; | |
330 | } else { | ||
331 | static const uint8_t prediction_table[3][12] = { | ||
332 | { 0, 8, 4, 10, 11, 2, 6, 9, 1, 3, 5, 7 }, | ||
333 | { 4, 0, 8, 11, 10, 3, 5, 2, 6, 9, 1, 7 }, | ||
334 | { 8, 0, 4, 10, 11, 1, 7, 2, 6, 9, 3, 5 }, | ||
335 | }; | ||
336 | 1304 | w->raw_orient = x8_get_orient_vlc(w); | |
337 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1304 times.
|
1304 | if (w->raw_orient < 0) |
338 | ✗ | return -1; | |
339 | av_assert2(w->raw_orient < 12); | ||
340 | av_assert2(w->orient < 3); | ||
341 | 1304 | w->orient=prediction_table[w->orient][w->raw_orient]; | |
342 | } | ||
343 | 3600 | return 0; | |
344 | } | ||
345 | |||
346 | 3600 | static void x8_update_predictions(IntraX8Context *const w, const int orient, | |
347 | const int est_run) | ||
348 | { | ||
349 |
2/2✓ Branch 0 taken 469 times.
✓ Branch 1 taken 3131 times.
|
3600 | w->prediction_table[w->mb_x * 2 + (w->mb_y & 1)] = (est_run << 2) + 1 * (orient == 4) + 2 * (orient == 8); |
350 | /* | ||
351 | * y = 2n + 0 -> // 0 2 4 | ||
352 | * y = 2n + 1 -> // 1 3 5 | ||
353 | */ | ||
354 | 3600 | } | |
355 | |||
356 | 900 | static void x8_get_prediction_chroma(IntraX8Context *const w) | |
357 | { | ||
358 | 900 | w->edges = 1 * !(w->mb_x >> 1); | |
359 |
2/2✓ Branch 0 taken 60 times.
✓ Branch 1 taken 840 times.
|
900 | w->edges |= 2 * !(w->mb_y >> 1); |
360 |
2/2✓ Branch 0 taken 45 times.
✓ Branch 1 taken 855 times.
|
900 | w->edges |= 4 * (w->mb_x >= (2 * w->mb_width - 1)); // mb_x for chroma would always be odd |
361 | |||
362 | 900 | w->raw_orient = 0; | |
363 | // lut_co[8] = {inv,4,8,8, inv,4,8,8} <- => {1,1,0,0;1,1,0,0} => 0xCC | ||
364 |
2/2✓ Branch 0 taken 102 times.
✓ Branch 1 taken 798 times.
|
900 | if (w->edges & 3) { |
365 | 102 | w->chroma_orient = 4 << ((0xCC >> w->edges) & 1); | |
366 | 102 | return; | |
367 | } | ||
368 | // block[x - 1][y | 1 - 1)] | ||
369 | 798 | w->chroma_orient = (w->prediction_table[2 * w->mb_x - 2] & 0x03) << 2; | |
370 | } | ||
371 | |||
372 | 3600 | static void x8_get_prediction(IntraX8Context *const w) | |
373 | { | ||
374 | int a, b, c, i; | ||
375 | |||
376 | 3600 | w->edges = 1 * !w->mb_x; | |
377 |
2/2✓ Branch 0 taken 120 times.
✓ Branch 1 taken 3480 times.
|
3600 | w->edges |= 2 * !w->mb_y; |
378 |
2/2✓ Branch 0 taken 90 times.
✓ Branch 1 taken 3510 times.
|
3600 | w->edges |= 4 * (w->mb_x >= (2 * w->mb_width - 1)); |
379 | |||
380 |
4/5✓ Branch 0 taken 3393 times.
✓ Branch 1 taken 87 times.
✓ Branch 2 taken 117 times.
✓ Branch 3 taken 3 times.
✗ Branch 4 not taken.
|
3600 | switch (w->edges & 3) { |
381 | 3393 | case 0: | |
382 | 3393 | break; | |
383 | 87 | case 1: | |
384 | // take the one from the above block[0][y - 1] | ||
385 | 87 | w->est_run = w->prediction_table[!(w->mb_y & 1)] >> 2; | |
386 | 87 | w->orient = 1; | |
387 | 87 | return; | |
388 | 117 | case 2: | |
389 | // take the one from the previous block[x - 1][0] | ||
390 | 117 | w->est_run = w->prediction_table[2 * w->mb_x - 2] >> 2; | |
391 | 117 | w->orient = 2; | |
392 | 117 | return; | |
393 | 3 | case 3: | |
394 | 3 | w->est_run = 16; | |
395 | 3 | w->orient = 0; | |
396 | 3 | return; | |
397 | } | ||
398 | // no edge cases | ||
399 | 3393 | b = w->prediction_table[2 * w->mb_x + !(w->mb_y & 1)]; // block[x ][y - 1] | |
400 | 3393 | a = w->prediction_table[2 * w->mb_x - 2 + (w->mb_y & 1)]; // block[x - 1][y ] | |
401 | 3393 | c = w->prediction_table[2 * w->mb_x - 2 + !(w->mb_y & 1)]; // block[x - 1][y - 1] | |
402 | |||
403 | 3393 | w->est_run = FFMIN(b, a); | |
404 | /* This condition has nothing to do with w->edges, even if it looks | ||
405 | * similar it would trigger if e.g. x = 3; y = 2; | ||
406 | * I guess somebody wrote something wrong and it became standard. */ | ||
407 |
2/2✓ Branch 0 taken 2565 times.
✓ Branch 1 taken 828 times.
|
3393 | if ((w->mb_x & w->mb_y) != 0) |
408 | 2565 | w->est_run = FFMIN(c, w->est_run); | |
409 | 3393 | w->est_run >>= 2; | |
410 | |||
411 | 3393 | a &= 3; | |
412 | 3393 | b &= 3; | |
413 | 3393 | c &= 3; | |
414 | |||
415 | 3393 | i = (0xFFEAF4C4 >> (2 * b + 8 * a)) & 3; | |
416 |
2/2✓ Branch 0 taken 3373 times.
✓ Branch 1 taken 20 times.
|
3393 | if (i != 3) |
417 | 3373 | w->orient = i; | |
418 | else | ||
419 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 16 times.
|
20 | w->orient = (0xFFEAD8 >> (2 * c + 8 * (w->quant > 12))) & 3; |
420 | /* | ||
421 | * lut1[b][a] = { | ||
422 | * ->{ 0, 1, 0, pad }, | ||
423 | * { 0, 1, X, pad }, | ||
424 | * { 2, 2, 2, pad } | ||
425 | * } | ||
426 | * pad 2 2 2; | ||
427 | * pad X 1 0; | ||
428 | * pad 0 1 0 <- | ||
429 | * -> 11 10 '10 10 '11 11'01 00 '11 00'01 00 => 0xEAF4C4 | ||
430 | * | ||
431 | * lut2[q>12][c] = { | ||
432 | * ->{ 0, 2, 1, pad}, | ||
433 | * { 2, 2, 2, pad} | ||
434 | * } | ||
435 | * pad 2 2 2; | ||
436 | * pad 1 2 0 <- | ||
437 | * -> 11 10'10 10 '11 01'10 00 => 0xEAD8 | ||
438 | */ | ||
439 | } | ||
440 | |||
441 | 2761 | static void x8_ac_compensation(IntraX8Context *const w, const int direction, | |
442 | const int dc_level) | ||
443 | { | ||
444 | int t; | ||
445 | #define B(x,y) w->block[0][w->idct_permutation[(x) + (y) * 8]] | ||
446 | #define T(x) ((x) * dc_level + 0x8000) >> 16; | ||
447 |
3/4✓ Branch 0 taken 1946 times.
✓ Branch 1 taken 312 times.
✓ Branch 2 taken 503 times.
✗ Branch 3 not taken.
|
2761 | switch (direction) { |
448 | 1946 | case 0: | |
449 | 1946 | t = T(3811); // h | |
450 | 1946 | B(1, 0) -= t; | |
451 | 1946 | B(0, 1) -= t; | |
452 | |||
453 | 1946 | t = T(487); // e | |
454 | 1946 | B(2, 0) -= t; | |
455 | 1946 | B(0, 2) -= t; | |
456 | |||
457 | 1946 | t = T(506); // f | |
458 | 1946 | B(3, 0) -= t; | |
459 | 1946 | B(0, 3) -= t; | |
460 | |||
461 | 1946 | t = T(135); // c | |
462 | 1946 | B(4, 0) -= t; | |
463 | 1946 | B(0, 4) -= t; | |
464 | 1946 | B(2, 1) += t; | |
465 | 1946 | B(1, 2) += t; | |
466 | 1946 | B(3, 1) += t; | |
467 | 1946 | B(1, 3) += t; | |
468 | |||
469 | 1946 | t = T(173); // d | |
470 | 1946 | B(5, 0) -= t; | |
471 | 1946 | B(0, 5) -= t; | |
472 | |||
473 | 1946 | t = T(61); // b | |
474 | 1946 | B(6, 0) -= t; | |
475 | 1946 | B(0, 6) -= t; | |
476 | 1946 | B(5, 1) += t; | |
477 | 1946 | B(1, 5) += t; | |
478 | |||
479 | 1946 | t = T(42); // a | |
480 | 1946 | B(7, 0) -= t; | |
481 | 1946 | B(0, 7) -= t; | |
482 | 1946 | B(4, 1) += t; | |
483 | 1946 | B(1, 4) += t; | |
484 | 1946 | B(4, 4) += t; | |
485 | |||
486 | 1946 | t = T(1084); // g | |
487 | 1946 | B(1, 1) += t; | |
488 | |||
489 | 1946 | w->block_last_index[0] = FFMAX(w->block_last_index[0], 7 * 8); | |
490 | 1946 | break; | |
491 | 312 | case 1: | |
492 | 312 | B(0, 1) -= T(6269); | |
493 | 312 | B(0, 3) -= T(708); | |
494 | 312 | B(0, 5) -= T(172); | |
495 | 312 | B(0, 7) -= T(73); | |
496 | |||
497 | 312 | w->block_last_index[0] = FFMAX(w->block_last_index[0], 7 * 8); | |
498 | 312 | break; | |
499 | 503 | case 2: | |
500 | 503 | B(1, 0) -= T(6269); | |
501 | 503 | B(3, 0) -= T(708); | |
502 | 503 | B(5, 0) -= T(172); | |
503 | 503 | B(7, 0) -= T(73); | |
504 | |||
505 | 503 | w->block_last_index[0] = FFMAX(w->block_last_index[0], 7); | |
506 | 503 | break; | |
507 | } | ||
508 | #undef B | ||
509 | #undef T | ||
510 | 2761 | } | |
511 | |||
512 | 1365 | static void dsp_x8_put_solidcolor(const uint8_t pix, uint8_t *dst, | |
513 | const ptrdiff_t linesize) | ||
514 | { | ||
515 | int k; | ||
516 |
2/2✓ Branch 0 taken 10920 times.
✓ Branch 1 taken 1365 times.
|
12285 | for (k = 0; k < 8; k++) { |
517 | 10920 | memset(dst, pix, 8); | |
518 | 10920 | dst += linesize; | |
519 | } | ||
520 | 1365 | } | |
521 | |||
522 | static const int16_t quant_table[64] = { | ||
523 | 256, 256, 256, 256, 256, 256, 259, 262, | ||
524 | 265, 269, 272, 275, 278, 282, 285, 288, | ||
525 | 292, 295, 299, 303, 306, 310, 314, 317, | ||
526 | 321, 325, 329, 333, 337, 341, 345, 349, | ||
527 | 353, 358, 362, 366, 371, 375, 379, 384, | ||
528 | 389, 393, 398, 403, 408, 413, 417, 422, | ||
529 | 428, 433, 438, 443, 448, 454, 459, 465, | ||
530 | 470, 476, 482, 488, 493, 499, 505, 511, | ||
531 | }; | ||
532 | |||
533 | 5400 | static int x8_decode_intra_mb(IntraX8Context *const w, const int chroma) | |
534 | { | ||
535 | uint8_t *scantable; | ||
536 | int final, run, level; | ||
537 | int ac_mode, dc_mode, est_run, dc_level; | ||
538 | int pos, n; | ||
539 | int zeros_only; | ||
540 | int use_quant_matrix; | ||
541 | int sign; | ||
542 | |||
543 | av_assert2(w->orient < 12); | ||
544 | 5400 | w->bdsp.clear_block(w->block[0]); | |
545 | |||
546 |
2/2✓ Branch 0 taken 1800 times.
✓ Branch 1 taken 3600 times.
|
5400 | if (chroma) |
547 | 1800 | dc_mode = 2; | |
548 | else | ||
549 | 3600 | dc_mode = !!w->est_run; // 0, 1 | |
550 | |||
551 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 5400 times.
|
5400 | if (x8_get_dc_rlf(w, dc_mode, &dc_level, &final)) |
552 | ✗ | return -1; | |
553 | 5400 | n = 0; | |
554 | 5400 | zeros_only = 0; | |
555 |
2/2✓ Branch 0 taken 1693 times.
✓ Branch 1 taken 3707 times.
|
5400 | if (!final) { // decode ac |
556 | 1693 | use_quant_matrix = w->use_quant_matrix; | |
557 |
2/2✓ Branch 0 taken 368 times.
✓ Branch 1 taken 1325 times.
|
1693 | if (chroma) { |
558 | 368 | ac_mode = 1; | |
559 | 368 | est_run = 64; // not used | |
560 | } else { | ||
561 |
2/2✓ Branch 0 taken 905 times.
✓ Branch 1 taken 420 times.
|
1325 | if (w->raw_orient < 3) |
562 | 905 | use_quant_matrix = 0; | |
563 | |||
564 |
2/2✓ Branch 0 taken 124 times.
✓ Branch 1 taken 1201 times.
|
1325 | if (w->raw_orient > 4) { |
565 | 124 | ac_mode = 0; | |
566 | 124 | est_run = 64; | |
567 | } else { | ||
568 |
2/2✓ Branch 0 taken 540 times.
✓ Branch 1 taken 661 times.
|
1201 | if (w->est_run > 1) { |
569 | 540 | ac_mode = 2; | |
570 | 540 | est_run = w->est_run; | |
571 | } else { | ||
572 | 661 | ac_mode = 3; | |
573 | 661 | est_run = 64; | |
574 | } | ||
575 | } | ||
576 | } | ||
577 | 1693 | x8_select_ac_table(w, ac_mode); | |
578 | /* scantable_selector[12] = { 0, 2, 0, 1, 1, 1, 0, 2, 2, 0, 1, 2 }; <- | ||
579 | * -> 10'01' 00'10' 10'00' 01'01' 01'00' 10'00 => 0x928548 */ | ||
580 | 1693 | scantable = w->permutated_scantable[(0x928548 >> (2 * w->orient)) & 3]; | |
581 | 1693 | pos = 0; | |
582 | do { | ||
583 | 8932 | n++; | |
584 |
2/2✓ Branch 0 taken 2216 times.
✓ Branch 1 taken 6716 times.
|
8932 | if (n >= est_run) { |
585 | 2216 | ac_mode = 3; | |
586 | 2216 | x8_select_ac_table(w, 3); | |
587 | } | ||
588 | |||
589 | 8932 | x8_get_ac_rlf(w, ac_mode, &run, &level, &final); | |
590 | |||
591 | 8932 | pos += run + 1; | |
592 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8932 times.
|
8932 | if (pos > 63) { |
593 | // this also handles vlc error in x8_get_ac_rlf | ||
594 | ✗ | return -1; | |
595 | } | ||
596 | 8932 | level = (level + 1) * w->dquant; | |
597 | 8932 | level += w->qsum; | |
598 | |||
599 | 8932 | sign = -get_bits1(w->gb); | |
600 | 8932 | level = (level ^ sign) - sign; | |
601 | |||
602 |
2/2✓ Branch 0 taken 4784 times.
✓ Branch 1 taken 4148 times.
|
8932 | if (use_quant_matrix) |
603 | 4784 | level = (level * quant_table[pos]) >> 8; | |
604 | |||
605 | 8932 | w->block[0][scantable[pos]] = level; | |
606 |
2/2✓ Branch 0 taken 7239 times.
✓ Branch 1 taken 1693 times.
|
8932 | } while (!final); |
607 | |||
608 | 1693 | w->block_last_index[0] = pos; | |
609 | } else { // DC only | ||
610 | 3707 | w->block_last_index[0] = 0; | |
611 |
4/4✓ Branch 0 taken 1321 times.
✓ Branch 1 taken 2386 times.
✓ Branch 2 taken 1189 times.
✓ Branch 3 taken 132 times.
|
3707 | if (w->flat_dc && ((unsigned) (dc_level + 1)) < 3) { // [-1; 1] |
612 | 1189 | int32_t divide_quant = !chroma ? w->divide_quant_dc_luma | |
613 |
2/2✓ Branch 0 taken 529 times.
✓ Branch 1 taken 660 times.
|
1189 | : w->divide_quant_dc_chroma; |
614 | 1189 | int32_t dc_quant = !chroma ? w->quant | |
615 |
2/2✓ Branch 0 taken 529 times.
✓ Branch 1 taken 660 times.
|
1189 | : w->quant_dc_chroma; |
616 | |||
617 | // original intent dc_level += predicted_dc/quant; | ||
618 | // but it got lost somewhere in the rounding | ||
619 | 1189 | dc_level += (w->predicted_dc * divide_quant + (1 << 12)) >> 13; | |
620 | |||
621 | 1189 | dsp_x8_put_solidcolor(av_clip_uint8((dc_level * dc_quant + 4) >> 3), | |
622 | w->dest[chroma], | ||
623 | 1189 | w->frame->linesize[!!chroma]); | |
624 | |||
625 | 1189 | goto block_placed; | |
626 | } | ||
627 | 2518 | zeros_only = dc_level == 0; | |
628 | } | ||
629 |
2/2✓ Branch 0 taken 3071 times.
✓ Branch 1 taken 1140 times.
|
4211 | if (!chroma) |
630 | 3071 | w->block[0][0] = dc_level * w->quant; | |
631 | else | ||
632 | 1140 | w->block[0][0] = dc_level * w->quant_dc_chroma; | |
633 | |||
634 | // there is !zero_only check in the original, but dc_level check is enough | ||
635 |
4/4✓ Branch 0 taken 2783 times.
✓ Branch 1 taken 1428 times.
✓ Branch 2 taken 2780 times.
✓ Branch 3 taken 3 times.
|
4211 | if ((unsigned int) (dc_level + 1) >= 3 && (w->edges & 3) != 3) { |
636 | int direction; | ||
637 | /* ac_comp_direction[orient] = { 0, 3, 3, 1, 1, 0, 0, 0, 2, 2, 2, 1 }; <- | ||
638 | * -> 01'10' 10'10' 00'00' 00'01' 01'11' 11'00 => 0x6A017C */ | ||
639 | 2780 | direction = (0x6A017C >> (w->orient * 2)) & 3; | |
640 |
2/2✓ Branch 0 taken 2761 times.
✓ Branch 1 taken 19 times.
|
2780 | if (direction != 3) { |
641 | // modify block_last[] | ||
642 | 2761 | x8_ac_compensation(w, direction, w->block[0][0]); | |
643 | } | ||
644 | } | ||
645 | |||
646 |
2/2✓ Branch 0 taken 176 times.
✓ Branch 1 taken 4035 times.
|
4211 | if (w->flat_dc) { |
647 | 176 | dsp_x8_put_solidcolor(w->predicted_dc, w->dest[chroma], | |
648 | 176 | w->frame->linesize[!!chroma]); | |
649 | } else { | ||
650 | 4035 | w->dsp.spatial_compensation[w->orient](w->scratchpad, | |
651 | w->dest[chroma], | ||
652 | 4035 | w->frame->linesize[!!chroma]); | |
653 | } | ||
654 |
2/2✓ Branch 0 taken 386 times.
✓ Branch 1 taken 3825 times.
|
4211 | if (!zeros_only) |
655 | 3825 | w->wdsp.idct_add(w->dest[chroma], | |
656 | 3825 | w->frame->linesize[!!chroma], | |
657 | 3825 | w->block[0]); | |
658 | |||
659 | 386 | block_placed: | |
660 |
2/2✓ Branch 0 taken 3600 times.
✓ Branch 1 taken 1800 times.
|
5400 | if (!chroma) |
661 | 3600 | x8_update_predictions(w, w->orient, n); | |
662 | |||
663 |
1/2✓ Branch 0 taken 5400 times.
✗ Branch 1 not taken.
|
5400 | if (w->loopfilter) { |
664 | 5400 | uint8_t *ptr = w->dest[chroma]; | |
665 | 5400 | ptrdiff_t linesize = w->frame->linesize[!!chroma]; | |
666 | |||
667 |
6/6✓ Branch 0 taken 5160 times.
✓ Branch 1 taken 240 times.
✓ Branch 2 taken 386 times.
✓ Branch 3 taken 4774 times.
✓ Branch 4 taken 62 times.
✓ Branch 5 taken 324 times.
|
5400 | if (!((w->edges & 2) || (zeros_only && (w->orient | 4) == 4))) |
668 | 4836 | w->dsp.h_loop_filter(ptr, linesize, w->quant); | |
669 | |||
670 |
6/6✓ Branch 0 taken 5220 times.
✓ Branch 1 taken 180 times.
✓ Branch 2 taken 383 times.
✓ Branch 3 taken 4837 times.
✓ Branch 4 taken 12 times.
✓ Branch 5 taken 371 times.
|
5400 | if (!((w->edges & 1) || (zeros_only && (w->orient | 8) == 8))) |
671 | 4849 | w->dsp.v_loop_filter(ptr, linesize, w->quant); | |
672 | } | ||
673 | 5400 | return 0; | |
674 | } | ||
675 | |||
676 | // FIXME maybe merge with ff_* | ||
677 | 90 | static void x8_init_block_index(IntraX8Context *w, AVFrame *frame) | |
678 | { | ||
679 | // not parent codec linesize as this would be wrong for field pics | ||
680 | // not that IntraX8 has interlacing support ;) | ||
681 | 90 | const ptrdiff_t linesize = frame->linesize[0]; | |
682 | 90 | const ptrdiff_t uvlinesize = frame->linesize[1]; | |
683 | |||
684 | 90 | w->dest[0] = frame->data[0]; | |
685 | 90 | w->dest[1] = frame->data[1]; | |
686 | 90 | w->dest[2] = frame->data[2]; | |
687 | |||
688 | 90 | w->dest[0] += w->mb_y * linesize << 3; | |
689 | // chroma blocks are on add rows | ||
690 | 90 | w->dest[1] += (w->mb_y & ~1) * uvlinesize << 2; | |
691 | 90 | w->dest[2] += (w->mb_y & ~1) * uvlinesize << 2; | |
692 | 90 | } | |
693 | |||
694 | 34 | av_cold int ff_intrax8_common_init(AVCodecContext *avctx, | |
695 | IntraX8Context *w, | ||
696 | int16_t (*block)[64], | ||
697 | int block_last_index[12], | ||
698 | int mb_width, int mb_height) | ||
699 | { | ||
700 | static AVOnce init_static_once = AV_ONCE_INIT; | ||
701 | |||
702 | 34 | w->avctx = avctx; | |
703 | 34 | w->mb_width = mb_width; | |
704 | 34 | w->mb_height = mb_height; | |
705 | 34 | w->block = block; | |
706 | 34 | w->block_last_index = block_last_index; | |
707 | |||
708 | // two rows, 2 blocks per cannon mb | ||
709 | 34 | w->prediction_table = av_mallocz(w->mb_width * 2 * 2); | |
710 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 34 times.
|
34 | if (!w->prediction_table) |
711 | ✗ | return AVERROR(ENOMEM); | |
712 | |||
713 | 34 | ff_wmv2dsp_init(&w->wdsp); | |
714 | |||
715 | 34 | ff_init_scantable_permutation(w->idct_permutation, | |
716 | 34 | w->wdsp.idct_perm); | |
717 | |||
718 | 34 | ff_permute_scantable(w->permutated_scantable[0], ff_wmv1_scantable[0], | |
719 | 34 | w->idct_permutation); | |
720 | 34 | ff_permute_scantable(w->permutated_scantable[1], ff_wmv1_scantable[2], | |
721 | 34 | w->idct_permutation); | |
722 | 34 | ff_permute_scantable(w->permutated_scantable[2], ff_wmv1_scantable[3], | |
723 | 34 | w->idct_permutation); | |
724 | |||
725 | 34 | ff_intrax8dsp_init(&w->dsp); | |
726 | 34 | ff_blockdsp_init(&w->bdsp); | |
727 | |||
728 | 34 | ff_thread_once(&init_static_once, x8_vlc_init); | |
729 | |||
730 | 34 | return 0; | |
731 | } | ||
732 | |||
733 | 46 | av_cold void ff_intrax8_common_end(IntraX8Context *w) | |
734 | { | ||
735 | 46 | av_freep(&w->prediction_table); | |
736 | 46 | } | |
737 | |||
738 | 3 | int ff_intrax8_decode_picture(IntraX8Context *w, Picture *pict, | |
739 | GetBitContext *gb, int *mb_x, int *mb_y, | ||
740 | int dquant, int quant_offset, | ||
741 | int loopfilter, int lowdelay) | ||
742 | { | ||
743 | int mb_xy; | ||
744 | |||
745 | 3 | w->gb = gb; | |
746 | 3 | w->dquant = dquant; | |
747 | 3 | w->quant = dquant >> 1; | |
748 | 3 | w->qsum = quant_offset; | |
749 | 3 | w->frame = pict->f; | |
750 | 3 | w->loopfilter = loopfilter; | |
751 | 3 | w->use_quant_matrix = get_bits1(w->gb); | |
752 | |||
753 | 3 | w->mb_x = *mb_x; | |
754 | 3 | w->mb_y = *mb_y; | |
755 | |||
756 | 3 | w->divide_quant_dc_luma = ((1 << 16) + (w->quant >> 1)) / w->quant; | |
757 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
|
3 | if (w->quant < 5) { |
758 | ✗ | w->quant_dc_chroma = w->quant; | |
759 | ✗ | w->divide_quant_dc_chroma = w->divide_quant_dc_luma; | |
760 | } else { | ||
761 | 3 | w->quant_dc_chroma = w->quant + ((w->quant + 3) >> 3); | |
762 | 3 | w->divide_quant_dc_chroma = ((1 << 16) + (w->quant_dc_chroma >> 1)) / w->quant_dc_chroma; | |
763 | } | ||
764 | 3 | x8_reset_vlc_tables(w); | |
765 | |||
766 |
2/2✓ Branch 0 taken 90 times.
✓ Branch 1 taken 3 times.
|
93 | for (w->mb_y = 0; w->mb_y < w->mb_height * 2; w->mb_y++) { |
767 | 90 | x8_init_block_index(w, w->frame); | |
768 | 90 | mb_xy = (w->mb_y >> 1) * (w->mb_width + 1); | |
769 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 90 times.
|
90 | if (get_bits_left(gb) < 1) |
770 | ✗ | goto error; | |
771 |
2/2✓ Branch 0 taken 3600 times.
✓ Branch 1 taken 90 times.
|
3690 | for (w->mb_x = 0; w->mb_x < w->mb_width * 2; w->mb_x++) { |
772 | 3600 | x8_get_prediction(w); | |
773 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 3600 times.
|
3600 | if (x8_setup_spatial_predictor(w, 0)) |
774 | ✗ | goto error; | |
775 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 3600 times.
|
3600 | if (x8_decode_intra_mb(w, 0)) |
776 | ✗ | goto error; | |
777 | |||
778 |
2/2✓ Branch 0 taken 900 times.
✓ Branch 1 taken 2700 times.
|
3600 | if (w->mb_x & w->mb_y & 1) { |
779 | 900 | x8_get_prediction_chroma(w); | |
780 | |||
781 | /* when setting up chroma, no vlc is read, | ||
782 | * so no error condition can be reached */ | ||
783 | 900 | x8_setup_spatial_predictor(w, 1); | |
784 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 900 times.
|
900 | if (x8_decode_intra_mb(w, 1)) |
785 | ✗ | goto error; | |
786 | |||
787 | 900 | x8_setup_spatial_predictor(w, 2); | |
788 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 900 times.
|
900 | if (x8_decode_intra_mb(w, 2)) |
789 | ✗ | goto error; | |
790 | |||
791 | 900 | w->dest[1] += 8; | |
792 | 900 | w->dest[2] += 8; | |
793 | |||
794 | 900 | pict->qscale_table[mb_xy] = w->quant; | |
795 | 900 | mb_xy++; | |
796 | } | ||
797 | 3600 | w->dest[0] += 8; | |
798 | } | ||
799 |
2/2✓ Branch 0 taken 45 times.
✓ Branch 1 taken 45 times.
|
90 | if (w->mb_y & 1) |
800 | 45 | ff_draw_horiz_band(w->avctx, w->frame, w->frame, | |
801 | 45 | (w->mb_y - 1) * 8, 16, | |
802 | PICT_FRAME, 0, lowdelay); | ||
803 | } | ||
804 | |||
805 | 3 | error: | |
806 | 3 | *mb_x = w->mb_x; | |
807 | 3 | *mb_y = w->mb_y; | |
808 | |||
809 | 3 | return 0; | |
810 | } | ||
811 |