FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/4xm.c
Date: 2021-09-24 20:55:06
Exec Total Coverage
Lines: 452 536 84.3%
Branches: 209 285 73.3%

Line Branch Exec Source
1 /*
2 * 4XM codec
3 * Copyright (c) 2003 Michael Niedermayer
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 * 4XM codec.
25 */
26
27 #include <inttypes.h>
28
29 #include "libavutil/avassert.h"
30 #include "libavutil/frame.h"
31 #include "libavutil/imgutils.h"
32 #include "libavutil/intreadwrite.h"
33 #include "libavutil/mem_internal.h"
34 #include "libavutil/thread.h"
35 #include "avcodec.h"
36 #include "blockdsp.h"
37 #include "bswapdsp.h"
38 #include "bytestream.h"
39 #include "get_bits.h"
40 #include "internal.h"
41
42
43 #define BLOCK_TYPE_VLC_BITS 5
44 #define ACDC_VLC_BITS 9
45
46 #define CFRAME_BUFFER_COUNT 100
47
48 static const uint8_t block_type_tab[2][4][8][2] = {
49 {
50 { // { 8, 4, 2 } x { 8, 4, 2}
51 { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
52 }, { // { 8, 4 } x 1
53 { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
54 }, { // 1 x { 8, 4 }
55 { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
56 }, { // 1 x 2, 2 x 1
57 { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
58 }
59 }, {
60 { // { 8, 4, 2 } x { 8, 4, 2}
61 { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
62 }, {// { 8, 4 } x 1
63 { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
64 }, {// 1 x { 8, 4 }
65 { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
66 }, {// 1 x 2, 2 x 1
67 { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
68 }
69 }
70 };
71
72 static const uint8_t size2index[4][4] = {
73 { -1, 3, 1, 1 },
74 { 3, 0, 0, 0 },
75 { 2, 0, 0, 0 },
76 { 2, 0, 0, 0 },
77 };
78
79 static const int8_t mv[256][2] = {
80 { 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },
81 { 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },
82 { 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },
83 { 2, 2 }, { 0, -3 }, { -3, 0 }, { 3, 0 }, { 0, 3 }, { -1, -3 }, { 1, -3 }, { -3, -1 },
84 { 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },
85 { 3, -2 }, { -3, 2 }, { 3, 2 }, { -2, 3 }, { 2, 3 }, { 0, -4 }, { -4, 0 }, { 4, 0 },
86 { 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },
87 { -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },
88 { 2, 4 }, { -3, -4 }, { 3, -4 }, { 4, -3 }, { -5, 0 }, { -4, 3 }, { -3, 4 }, { 3, 4 },
89 { -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },
90 { -4, -4 }, { -4, 4 }, { -3, -5 }, { -5, -3 }, { -5, 3 }, { 3, 5 }, { -6, 0 }, { 0, 6 },
91 { -6, -1 }, { -6, 1 }, { 1, 6 }, { 2, -6 }, { -6, 2 }, { 2, 6 }, { -5, -4 }, { 5, 4 },
92 { 4, 5 }, { -6, -3 }, { 6, 3 }, { -7, 0 }, { -1, -7 }, { 5, -5 }, { -7, 1 }, { -1, 7 },
93 { 4, -6 }, { 6, 4 }, { -2, -7 }, { -7, 2 }, { -3, -7 }, { 7, -3 }, { 3, 7 }, { 6, -5 },
94 { 0, -8 }, { -1, -8 }, { -7, -4 }, { -8, 1 }, { 4, 7 }, { 2, -8 }, { -2, 8 }, { 6, 6 },
95 { -8, 3 }, { 5, -7 }, { -5, 7 }, { 8, -4 }, { 0, -9 }, { -9, -1 }, { 1, 9 }, { 7, -6 },
96 { -7, 6 }, { -5, -8 }, { -5, 8 }, { -9, 3 }, { 9, -4 }, { 7, -7 }, { 8, -6 }, { 6, 8 },
97 { 10, 1 }, { -10, 2 }, { 9, -5 }, { 10, -3 }, { -8, -7 }, { -10, -4 }, { 6, -9 }, { -11, 0 },
98 { 11, 1 }, { -11, -2 }, { -2, 11 }, { 7, -9 }, { -7, 9 }, { 10, 6 }, { -4, 11 }, { 8, -9 },
99 { 8, 9 }, { 5, 11 }, { 7, -10 }, { 12, -3 }, { 11, 6 }, { -9, -9 }, { 8, 10 }, { 5, 12 },
100 { -11, 7 }, { 13, 2 }, { 6, -12 }, { 10, 9 }, { -11, 8 }, { -7, 12 }, { 0, 14 }, { 14, -2 },
101 { -9, 11 }, { -6, 13 }, { -14, -4 }, { -5, -14 }, { 5, 14 }, { -15, -1 }, { -14, -6 }, { 3, -15 },
102 { 11, -11 }, { -7, 14 }, { -5, 15 }, { 8, -14 }, { 15, 6 }, { 3, 16 }, { 7, -15 }, { -16, 5 },
103 { 0, 17 }, { -16, -6 }, { -10, 14 }, { -16, 7 }, { 12, 13 }, { -16, 8 }, { -17, 6 }, { -18, 3 },
104 { -7, 17 }, { 15, 11 }, { 16, 10 }, { 2, -19 }, { 3, -19 }, { -11, -16 }, { -18, 8 }, { -19, -6 },
105 { 2, -20 }, { -17, -11 }, { -10, -18 }, { 8, 19 }, { -21, -1 }, { -20, 7 }, { -4, 21 }, { 21, 5 },
106 { 15, 16 }, { 2, -22 }, { -10, -20 }, { -22, 5 }, { 20, -11 }, { -7, -22 }, { -12, 20 }, { 23, -5 },
107 { 13, -20 }, { 24, -2 }, { -15, 19 }, { -11, 22 }, { 16, 19 }, { 23, -10 }, { -18, -18 }, { -9, -24 },
108 { 24, -10 }, { -3, 26 }, { -23, 13 }, { -18, -20 }, { 17, 21 }, { -4, 27 }, { 27, 6 }, { 1, -28 },
109 { -11, 26 }, { -17, -23 }, { 7, 28 }, { 11, -27 }, { 29, 5 }, { -23, -19 }, { -28, -11 }, { -21, 22 },
110 { -30, 7 }, { -17, 26 }, { -27, 16 }, { 13, 29 }, { 19, -26 }, { 10, -31 }, { -14, -30 }, { 20, -27 },
111 { -29, 18 }, { -16, -31 }, { -28, -22 }, { 21, -30 }, { -25, 28 }, { 26, -29 }, { 25, -32 }, { -32, -32 }
112 };
113
114 /* This is simply the scaled down elementwise product of the standard JPEG
115 * quantizer table and the AAN premul table. */
116 static const uint8_t dequant_table[64] = {
117 16, 15, 13, 19, 24, 31, 28, 17,
118 17, 23, 25, 31, 36, 63, 45, 21,
119 18, 24, 27, 37, 52, 59, 49, 20,
120 16, 28, 34, 40, 60, 80, 51, 20,
121 18, 31, 48, 66, 68, 86, 56, 21,
122 19, 38, 56, 59, 64, 64, 48, 20,
123 27, 48, 55, 55, 56, 51, 35, 15,
124 20, 35, 34, 32, 31, 22, 15, 8,
125 };
126
127 static VLC block_type_vlc[2][4];
128
129
130 typedef struct CFrameBuffer {
131 unsigned int allocated_size;
132 unsigned int size;
133 int id;
134 uint8_t *data;
135 } CFrameBuffer;
136
137 typedef struct FourXContext {
138 AVCodecContext *avctx;
139 BlockDSPContext bdsp;
140 BswapDSPContext bbdsp;
141 uint16_t *frame_buffer;
142 uint16_t *last_frame_buffer;
143 GetBitContext pre_gb; ///< ac/dc prefix
144 GetBitContext gb;
145 GetByteContext g;
146 GetByteContext g2;
147 int mv[256];
148 VLC pre_vlc;
149 int last_dc;
150 DECLARE_ALIGNED(32, int16_t, block)[6][64];
151 void *bitstream_buffer;
152 unsigned int bitstream_buffer_size;
153 int version;
154 CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
155 } FourXContext;
156
157
158 #define FIX_1_082392200 70936
159 #define FIX_1_414213562 92682
160 #define FIX_1_847759065 121095
161 #define FIX_2_613125930 171254
162
163 #define MULTIPLY(var, const) ((int)((var) * (unsigned)(const)) >> 16)
164
165 7200 static void idct(int16_t block[64])
166 {
167 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
168 int tmp10, tmp11, tmp12, tmp13;
169 int z5, z10, z11, z12, z13;
170 int i;
171 int temp[64];
172
173
2/2
✓ Branch 0 taken 57600 times.
✓ Branch 1 taken 7200 times.
64800 for (i = 0; i < 8; i++) {
174 57600 tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
175 57600 tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
176
177 57600 tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
178 57600 tmp12 = MULTIPLY(block[8 * 2 + i] - block[8 * 6 + i], FIX_1_414213562) - tmp13;
179
180 57600 tmp0 = tmp10 + tmp13;
181 57600 tmp3 = tmp10 - tmp13;
182 57600 tmp1 = tmp11 + tmp12;
183 57600 tmp2 = tmp11 - tmp12;
184
185 57600 z13 = block[8 * 5 + i] + block[8 * 3 + i];
186 57600 z10 = block[8 * 5 + i] - block[8 * 3 + i];
187 57600 z11 = block[8 * 1 + i] + block[8 * 7 + i];
188 57600 z12 = block[8 * 1 + i] - block[8 * 7 + i];
189
190 57600 tmp7 = z11 + z13;
191 57600 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
192
193 57600 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
194 57600 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
195 57600 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
196
197 57600 tmp6 = tmp12 - tmp7;
198 57600 tmp5 = tmp11 - tmp6;
199 57600 tmp4 = tmp10 + tmp5;
200
201 57600 temp[8 * 0 + i] = tmp0 + tmp7;
202 57600 temp[8 * 7 + i] = tmp0 - tmp7;
203 57600 temp[8 * 1 + i] = tmp1 + tmp6;
204 57600 temp[8 * 6 + i] = tmp1 - tmp6;
205 57600 temp[8 * 2 + i] = tmp2 + tmp5;
206 57600 temp[8 * 5 + i] = tmp2 - tmp5;
207 57600 temp[8 * 4 + i] = tmp3 + tmp4;
208 57600 temp[8 * 3 + i] = tmp3 - tmp4;
209 }
210
211
2/2
✓ Branch 0 taken 57600 times.
✓ Branch 1 taken 7200 times.
64800 for (i = 0; i < 8 * 8; i += 8) {
212 57600 tmp10 = temp[0 + i] + temp[4 + i];
213 57600 tmp11 = temp[0 + i] - temp[4 + i];
214
215 57600 tmp13 = temp[2 + i] + temp[6 + i];
216 57600 tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
217
218 57600 tmp0 = tmp10 + tmp13;
219 57600 tmp3 = tmp10 - tmp13;
220 57600 tmp1 = tmp11 + tmp12;
221 57600 tmp2 = tmp11 - tmp12;
222
223 57600 z13 = temp[5 + i] + temp[3 + i];
224 57600 z10 = temp[5 + i] - temp[3 + i];
225 57600 z11 = temp[1 + i] + temp[7 + i];
226 57600 z12 = temp[1 + i] - temp[7 + i];
227
228 57600 tmp7 = z11 + z13;
229 57600 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
230
231 57600 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
232 57600 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
233 57600 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
234
235 57600 tmp6 = tmp12 - tmp7;
236 57600 tmp5 = tmp11 - tmp6;
237 57600 tmp4 = tmp10 + tmp5;
238
239 57600 block[0 + i] = (tmp0 + tmp7) >> 6;
240 57600 block[7 + i] = (tmp0 - tmp7) >> 6;
241 57600 block[1 + i] = (tmp1 + tmp6) >> 6;
242 57600 block[6 + i] = (tmp1 - tmp6) >> 6;
243 57600 block[2 + i] = (tmp2 + tmp5) >> 6;
244 57600 block[5 + i] = (tmp2 - tmp5) >> 6;
245 57600 block[4 + i] = (tmp3 + tmp4) >> 6;
246 57600 block[3 + i] = (tmp3 - tmp4) >> 6;
247 }
248 7200 }
249
250 3 static av_cold void init_vlcs(void)
251 {
252 static VLC_TYPE table[2][4][32][2];
253 int i, j;
254
255
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 3 times.
9 for (i = 0; i < 2; i++) {
256
2/2
✓ Branch 0 taken 24 times.
✓ Branch 1 taken 6 times.
30 for (j = 0; j < 4; j++) {
257 24 block_type_vlc[i][j].table = table[i][j];
258 24 block_type_vlc[i][j].table_allocated = 32;
259 24 init_vlc(&block_type_vlc[i][j], BLOCK_TYPE_VLC_BITS, 7,
260 &block_type_tab[i][j][0][1], 2, 1,
261 &block_type_tab[i][j][0][0], 2, 1,
262 INIT_VLC_USE_NEW_STATIC);
263 }
264 }
265 3 }
266
267 183 static void init_mv(FourXContext *f, int linesize)
268 {
269 int i;
270
271
2/2
✓ Branch 0 taken 46848 times.
✓ Branch 1 taken 183 times.
47031 for (i = 0; i < 256; i++) {
272
2/2
✓ Branch 0 taken 3584 times.
✓ Branch 1 taken 43264 times.
46848 if (f->version > 1)
273 3584 f->mv[i] = mv[i][0] + mv[i][1] * linesize / 2;
274 else
275 43264 f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
276 }
277 183 }
278
279 #if HAVE_BIGENDIAN
280 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
281 { \
282 unsigned tmpval = AV_RN32(src); \
283 tmpval = (tmpval << 16) | (tmpval >> 16); \
284 tmpval = tmpval * (scale) + (dc); \
285 tmpval = (tmpval << 16) | (tmpval >> 16); \
286 AV_WN32A(dst, tmpval); \
287 }
288 #else
289 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
290 { \
291 unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
292 AV_WN32A(dst, tmpval); \
293 }
294 #endif
295
296 257504 static inline void mcdc(uint16_t *dst, const uint16_t *src, int log2w,
297 int h, int stride, int scale, unsigned dc)
298 {
299 int i;
300 257504 dc *= 0x10001;
301
302
4/5
✓ Branch 0 taken 55650 times.
✓ Branch 1 taken 46051 times.
✓ Branch 2 taken 46050 times.
✓ Branch 3 taken 109753 times.
✗ Branch 4 not taken.
257504 switch (log2w) {
303 55650 case 0:
304
2/2
✓ Branch 0 taken 278382 times.
✓ Branch 1 taken 55650 times.
334032 for (i = 0; i < h; i++) {
305 278382 dst[0] = scale * src[0] + dc;
306
2/2
✓ Branch 0 taken 276226 times.
✓ Branch 1 taken 2156 times.
278382 if (scale)
307 276226 src += stride;
308 278382 dst += stride;
309 }
310 55650 break;
311 46051 case 1:
312
2/2
✓ Branch 0 taken 167495 times.
✓ Branch 1 taken 46051 times.
213546 for (i = 0; i < h; i++) {
313 167495 LE_CENTRIC_MUL(dst, src, scale, dc);
314
2/2
✓ Branch 0 taken 161189 times.
✓ Branch 1 taken 6306 times.
167495 if (scale)
315 161189 src += stride;
316 167495 dst += stride;
317 }
318 46051 break;
319 46050 case 2:
320
2/2
✓ Branch 0 taken 144220 times.
✓ Branch 1 taken 46050 times.
190270 for (i = 0; i < h; i++) {
321 144220 LE_CENTRIC_MUL(dst, src, scale, dc);
322 144220 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
323
2/2
✓ Branch 0 taken 136750 times.
✓ Branch 1 taken 7470 times.
144220 if (scale)
324 136750 src += stride;
325 144220 dst += stride;
326 }
327 46050 break;
328 109753 case 3:
329
2/2
✓ Branch 0 taken 694635 times.
✓ Branch 1 taken 109753 times.
804388 for (i = 0; i < h; i++) {
330 694635 LE_CENTRIC_MUL(dst, src, scale, dc);
331 694635 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
332 694635 LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
333 694635 LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
334
2/2
✓ Branch 0 taken 656084 times.
✓ Branch 1 taken 38551 times.
694635 if (scale)
335 656084 src += stride;
336 694635 dst += stride;
337 }
338 109753 break;
339 default:
340 av_assert0(0);
341 }
342 257504 }
343
344 458368 static int decode_p_block(FourXContext *f, uint16_t *dst, const uint16_t *src,
345 int log2w, int log2h, int stride)
346 {
347 458368 int index, h, code, ret, scale = 1;
348 uint16_t *start, *end;
349 458368 unsigned dc = 0;
350
351
2/4
✓ Branch 0 taken 458368 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 458368 times.
458368 av_assert0(log2w >= 0 && log2h >= 0);
352
353 458368 index = size2index[log2h][log2w];
354
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 458368 times.
458368 av_assert0(index >= 0);
355
356
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 458368 times.
458368 if (get_bits_left(&f->gb) < 1)
357 return AVERROR_INVALIDDATA;
358 458368 h = 1 << log2h;
359 458368 code = get_vlc2(&f->gb, block_type_vlc[1 - (f->version > 1)][index].table,
360 BLOCK_TYPE_VLC_BITS, 1);
361
2/4
✓ Branch 0 taken 458368 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 458368 times.
458368 av_assert0(code >= 0 && code <= 6);
362
363 458368 start = f->last_frame_buffer;
364 458368 end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
365
366
2/2
✓ Branch 0 taken 72772 times.
✓ Branch 1 taken 385596 times.
458368 if (code == 1) {
367 72772 log2h--;
368
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 72772 times.
72772 if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
369 return ret;
370 72772 return decode_p_block(f, dst + (stride << log2h),
371 72772 src + (stride << log2h),
372 log2w, log2h, stride);
373
2/2
✓ Branch 0 taken 87322 times.
✓ Branch 1 taken 298274 times.
385596 } else if (code == 2) {
374 87322 log2w--;
375
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 87322 times.
87322 if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
376 return ret;
377 87322 return decode_p_block(f, dst + (1 << log2w),
378 87322 src + (1 << log2w),
379 log2w, log2h, stride);
380
2/2
✓ Branch 0 taken 3858 times.
✓ Branch 1 taken 294416 times.
298274 } else if (code == 6) {
381
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3858 times.
3858 if (bytestream2_get_bytes_left(&f->g2) < 4) {
382 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
383 return AVERROR_INVALIDDATA;
384 }
385
2/2
✓ Branch 0 taken 2594 times.
✓ Branch 1 taken 1264 times.
3858 if (log2w) {
386 2594 dst[0] = bytestream2_get_le16u(&f->g2);
387 2594 dst[1] = bytestream2_get_le16u(&f->g2);
388 } else {
389 1264 dst[0] = bytestream2_get_le16u(&f->g2);
390 1264 dst[stride] = bytestream2_get_le16u(&f->g2);
391 }
392 3858 return 0;
393 }
394
395
3/4
✓ Branch 0 taken 197273 times.
✓ Branch 1 taken 97143 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 197273 times.
294416 if ((code&3)==0 && bytestream2_get_bytes_left(&f->g) < 1) {
396 av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
397 return AVERROR_INVALIDDATA;
398 }
399
400
2/2
✓ Branch 0 taken 165799 times.
✓ Branch 1 taken 128617 times.
294416 if (code == 0) {
401 165799 src += f->mv[bytestream2_get_byte(&f->g)];
402
4/4
✓ Branch 0 taken 88291 times.
✓ Branch 1 taken 40326 times.
✓ Branch 2 taken 36912 times.
✓ Branch 3 taken 51379 times.
128617 } else if (code == 3 && f->version >= 2) {
403 36912 return 0;
404
2/2
✓ Branch 0 taken 31474 times.
✓ Branch 1 taken 60231 times.
91705 } else if (code == 4) {
405 31474 src += f->mv[bytestream2_get_byte(&f->g)];
406
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 31474 times.
31474 if (bytestream2_get_bytes_left(&f->g2) < 2){
407 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
408 return AVERROR_INVALIDDATA;
409 }
410 31474 dc = bytestream2_get_le16(&f->g2);
411
2/2
✓ Branch 0 taken 8852 times.
✓ Branch 1 taken 51379 times.
60231 } else if (code == 5) {
412
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 8852 times.
8852 if (bytestream2_get_bytes_left(&f->g2) < 2){
413 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
414 return AVERROR_INVALIDDATA;
415 }
416
2/4
✓ Branch 0 taken 8852 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 8852 times.
8852 av_assert0(start <= src && src <= end);
417 8852 scale = 0;
418 8852 dc = bytestream2_get_le16(&f->g2);
419 }
420
421
2/4
✓ Branch 0 taken 257504 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 257504 times.
257504 if (start > src || src > end) {
422 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
423 return AVERROR_INVALIDDATA;
424 }
425
426 257504 mcdc(dst, src, log2w, h, stride, scale, dc);
427
428 257504 return 0;
429 }
430
431 183 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
432 {
433 int x, y;
434 183 const int width = f->avctx->width;
435 183 const int height = f->avctx->height;
436 183 uint16_t *dst = f->frame_buffer;
437 uint16_t *src;
438 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
439 bytestream_offset, wordstream_offset;
440 int ret;
441
442 183 src = f->last_frame_buffer;
443
444
2/2
✓ Branch 0 taken 14 times.
✓ Branch 1 taken 169 times.
183 if (f->version > 1) {
445 14 extra = 20;
446
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
14 if (length < extra)
447 return AVERROR_INVALIDDATA;
448 14 bitstream_size = AV_RL32(buf + 8);
449 14 wordstream_size = AV_RL32(buf + 12);
450 14 bytestream_size = AV_RL32(buf + 16);
451 } else {
452 169 extra = 0;
453 169 bitstream_size = AV_RL16(buf - 4);
454 169 wordstream_size = AV_RL16(buf - 2);
455
2/2
✓ Branch 0 taken 162 times.
✓ Branch 1 taken 7 times.
169 bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
456 }
457
458
2/4
✓ Branch 0 taken 183 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 183 times.
✗ Branch 3 not taken.
183 if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
459
1/2
✓ Branch 0 taken 183 times.
✗ Branch 1 not taken.
183 bytestream_size > length - bitstream_size ||
460
1/2
✓ Branch 0 taken 183 times.
✗ Branch 1 not taken.
183 wordstream_size > length - bytestream_size - bitstream_size ||
461
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 183 times.
183 extra > length - bytestream_size - bitstream_size - wordstream_size) {
462 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
463 bitstream_size+ bytestream_size+ wordstream_size - length);
464 return AVERROR_INVALIDDATA;
465 }
466
467 183 av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
468 bitstream_size);
469
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 183 times.
183 if (!f->bitstream_buffer)
470 return AVERROR(ENOMEM);
471 183 f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) (buf + extra),
472 183 bitstream_size / 4);
473 183 init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
474
475 183 wordstream_offset = extra + bitstream_size;
476 183 bytestream_offset = extra + bitstream_size + wordstream_size;
477 183 bytestream2_init(&f->g2, buf + wordstream_offset,
478 183 length - wordstream_offset);
479 183 bytestream2_init(&f->g, buf + bytestream_offset,
480 183 length - bytestream_offset);
481
482 183 init_mv(f, width * 2);
483
484
2/2
✓ Branch 0 taken 3206 times.
✓ Branch 1 taken 183 times.
3389 for (y = 0; y < height; y += 8) {
485
2/2
✓ Branch 0 taken 138180 times.
✓ Branch 1 taken 3206 times.
141386 for (x = 0; x < width; x += 8)
486
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 138180 times.
138180 if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, width)) < 0)
487 return ret;
488 3206 src += 8 * width;
489 3206 dst += 8 * width;
490 }
491
492 183 return 0;
493 }
494
495 /**
496 * decode block and dequantize.
497 * Note this is almost identical to MJPEG.
498 */
499 7200 static int decode_i_block(FourXContext *f, int16_t *block)
500 {
501 int code, i, j, level, val;
502
503
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 7200 times.
7200 if (get_bits_left(&f->pre_gb) < 2) {
504 av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->pre_gb));
505 return AVERROR_INVALIDDATA;
506 }
507
508 /* DC coef */
509 7200 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
510
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7200 times.
7200 if (val >> 4) {
511 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
512 return AVERROR_INVALIDDATA;
513 }
514
515
2/2
✓ Branch 0 taken 6688 times.
✓ Branch 1 taken 512 times.
7200 if (val)
516 6688 val = get_xbits(&f->gb, val);
517
518 7200 val = val * dequant_table[0] + f->last_dc;
519 7200 f->last_dc = block[0] = val;
520 /* AC coefs */
521 7200 i = 1;
522 for (;;) {
523 80423 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
524
525 /* EOB */
526
2/2
✓ Branch 0 taken 7068 times.
✓ Branch 1 taken 73355 times.
80423 if (code == 0)
527 7068 break;
528
2/2
✓ Branch 0 taken 56 times.
✓ Branch 1 taken 73299 times.
73355 if (code == 0xf0) {
529 56 i += 16;
530
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 56 times.
56 if (i >= 64) {
531 av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
532 return 0;
533 }
534 } else {
535
1/2
✓ Branch 0 taken 73299 times.
✗ Branch 1 not taken.
73299 if (code & 0xf) {
536 73299 level = get_xbits(&f->gb, code & 0xf);
537 } else {
538 av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
539 return AVERROR_INVALIDDATA;
540 }
541 73299 i += code >> 4;
542
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 73299 times.
73299 if (i >= 64) {
543 av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
544 return 0;
545 }
546
547 73299 j = ff_zigzag_direct[i];
548 73299 block[j] = level * dequant_table[j];
549 73299 i++;
550
2/2
✓ Branch 0 taken 132 times.
✓ Branch 1 taken 73167 times.
73299 if (i >= 64)
551 132 break;
552 }
553 }
554
555 7200 return 0;
556 }
557
558 1200 static inline void idct_put(FourXContext *f, int x, int y)
559 {
560 1200 int16_t (*block)[64] = f->block;
561 1200 int stride = f->avctx->width;
562 int i;
563 1200 uint16_t *dst = f->frame_buffer + y * stride + x;
564
565
2/2
✓ Branch 0 taken 4800 times.
✓ Branch 1 taken 1200 times.
6000 for (i = 0; i < 4; i++) {
566 4800 block[i][0] += 0x80 * 8 * 8;
567 4800 idct(block[i]);
568 }
569
570
1/2
✓ Branch 0 taken 1200 times.
✗ Branch 1 not taken.
1200 if (!(f->avctx->flags & AV_CODEC_FLAG_GRAY)) {
571
2/2
✓ Branch 0 taken 2400 times.
✓ Branch 1 taken 1200 times.
3600 for (i = 4; i < 6; i++)
572 2400 idct(block[i]);
573 }
574
575 /* Note transform is:
576 * y = ( 1b + 4g + 2r) / 14
577 * cb = ( 3b - 2g - 1r) / 14
578 * cr = (-1b - 4g + 5r) / 14 */
579
2/2
✓ Branch 0 taken 9600 times.
✓ Branch 1 taken 1200 times.
10800 for (y = 0; y < 8; y++) {
580
2/2
✓ Branch 0 taken 76800 times.
✓ Branch 1 taken 9600 times.
86400 for (x = 0; x < 8; x++) {
581 76800 int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
582 76800 2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
583 76800 int cb = block[4][x + 8 * y];
584 76800 int cr = block[5][x + 8 * y];
585 76800 int cg = (cb + cr) >> 1;
586 int y;
587
588 76800 cb += cb;
589
590 76800 y = temp[0];
591 76800 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
592 76800 y = temp[1];
593 76800 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
594 76800 y = temp[8];
595 76800 dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
596 76800 y = temp[9];
597 76800 dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
598 76800 dst += 2;
599 }
600 9600 dst += 2 * stride - 2 * 8;
601 }
602 1200 }
603
604 1200 static int decode_i_mb(FourXContext *f)
605 {
606 int ret;
607 int i;
608
609 1200 f->bdsp.clear_blocks(f->block[0]);
610
611
2/2
✓ Branch 0 taken 7200 times.
✓ Branch 1 taken 1200 times.
8400 for (i = 0; i < 6; i++)
612
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 7200 times.
7200 if ((ret = decode_i_block(f, f->block[i])) < 0)
613 return ret;
614
615 1200 return 0;
616 }
617
618 1 static const uint8_t *read_huffman_tables(FourXContext *f,
619 const uint8_t * const buf,
620 int buf_size)
621 {
622 1 int frequency[512] = { 0 };
623 uint8_t flag[512];
624 int up[512];
625 uint8_t len_tab[257];
626 int bits_tab[257];
627 int start, end;
628 1 const uint8_t *ptr = buf;
629 1 const uint8_t *ptr_end = buf + buf_size;
630 int j;
631
632 1 memset(up, -1, sizeof(up));
633
634 1 start = *ptr++;
635 1 end = *ptr++;
636 15 for (;;) {
637 int i;
638
639
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
16 if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
640 av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
641 return NULL;
642 }
643
644
2/2
✓ Branch 0 taken 61 times.
✓ Branch 1 taken 16 times.
77 for (i = start; i <= end; i++)
645 61 frequency[i] = *ptr++;
646 16 start = *ptr++;
647
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 15 times.
16 if (start == 0)
648 1 break;
649
650 15 end = *ptr++;
651 }
652 1 frequency[256] = 1;
653
654
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 times.
3 while ((ptr - buf) & 3)
655 2 ptr++; // 4byte align
656
657
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
1 if (ptr > ptr_end) {
658 av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
659 return NULL;
660 }
661
662
1/2
✓ Branch 0 taken 61 times.
✗ Branch 1 not taken.
61 for (j = 257; j < 512; j++) {
663 61 int min_freq[2] = { 256 * 256, 256 * 256 };
664 61 int smallest[2] = { 0, 0 };
665 int i;
666
2/2
✓ Branch 0 taken 17507 times.
✓ Branch 1 taken 61 times.
17568 for (i = 0; i < j; i++) {
667
2/2
✓ Branch 0 taken 15616 times.
✓ Branch 1 taken 1891 times.
17507 if (frequency[i] == 0)
668 15616 continue;
669
2/2
✓ Branch 0 taken 722 times.
✓ Branch 1 taken 1169 times.
1891 if (frequency[i] < min_freq[1]) {
670
2/2
✓ Branch 0 taken 406 times.
✓ Branch 1 taken 316 times.
722 if (frequency[i] < min_freq[0]) {
671 406 min_freq[1] = min_freq[0];
672 406 smallest[1] = smallest[0];
673 406 min_freq[0] = frequency[i];
674 406 smallest[0] = i;
675 } else {
676 316 min_freq[1] = frequency[i];
677 316 smallest[1] = i;
678 }
679 }
680 }
681
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 60 times.
61 if (min_freq[1] == 256 * 256)
682 1 break;
683
684 60 frequency[j] = min_freq[0] + min_freq[1];
685 60 flag[smallest[0]] = 0;
686 60 flag[smallest[1]] = 1;
687 60 up[smallest[0]] =
688 60 up[smallest[1]] = j;
689 60 frequency[smallest[0]] = frequency[smallest[1]] = 0;
690 }
691
692
2/2
✓ Branch 0 taken 257 times.
✓ Branch 1 taken 1 times.
258 for (j = 0; j < 257; j++) {
693 257 int node, len = 0, bits = 0;
694
695
2/2
✓ Branch 0 taken 510 times.
✓ Branch 1 taken 257 times.
767 for (node = j; up[node] != -1; node = up[node]) {
696 510 bits += flag[node] << len;
697 510 len++;
698
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 510 times.
510 if (len > 31)
699 // can this happen at all ?
700 av_log(f->avctx, AV_LOG_ERROR,
701 "vlc length overflow\n");
702 }
703
704 257 bits_tab[j] = bits;
705 257 len_tab[j] = len;
706 }
707
708 1 ff_free_vlc(&f->pre_vlc);
709
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
1 if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
710 bits_tab, 4, 4, 0))
711 return NULL;
712
713 1 return ptr;
714 }
715
716 1050 static int mix(int c0, int c1)
717 {
718 1050 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
719 1050 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
720 1050 int red = 2 * (c0 >> 10) + (c1 >> 10);
721 1050 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
722 }
723
724 5 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
725 {
726 int x, y, x2, y2;
727 5 const int width = f->avctx->width;
728 5 const int height = f->avctx->height;
729 5 const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
730 5 uint16_t *dst = f->frame_buffer;
731 5 const uint8_t *buf_end = buf + length;
732 GetByteContext g3;
733
734
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
5 if (length < mbs * 8) {
735 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
736 return AVERROR_INVALIDDATA;
737 }
738 5 bytestream2_init(&g3, buf, length);
739
740
2/2
✓ Branch 0 taken 35 times.
✓ Branch 1 taken 5 times.
40 for (y = 0; y < height; y += 16) {
741
2/2
✓ Branch 0 taken 525 times.
✓ Branch 1 taken 35 times.
560 for (x = 0; x < width; x += 16) {
742 525 unsigned int color[4] = { 0 }, bits;
743
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 525 times.
525 if (buf_end - buf < 8)
744 return AVERROR_INVALIDDATA;
745 // warning following is purely guessed ...
746 525 color[0] = bytestream2_get_le16u(&g3);
747 525 color[1] = bytestream2_get_le16u(&g3);
748
749
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 525 times.
525 if (color[0] & 0x8000)
750 av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
751
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 525 times.
525 if (color[1] & 0x8000)
752 av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
753
754 525 color[2] = mix(color[0], color[1]);
755 525 color[3] = mix(color[1], color[0]);
756
757 525 bits = bytestream2_get_le32u(&g3);
758
2/2
✓ Branch 0 taken 8400 times.
✓ Branch 1 taken 525 times.
8925 for (y2 = 0; y2 < 16; y2++) {
759
2/2
✓ Branch 0 taken 134400 times.
✓ Branch 1 taken 8400 times.
142800 for (x2 = 0; x2 < 16; x2++) {
760 134400 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
761 134400 dst[y2 * width + x2] = color[(bits >> index) & 3];
762 }
763 }
764 525 dst += 16;
765 }
766 35 dst += 16 * width - x;
767 }
768
769 5 return 0;
770 }
771
772 1 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
773 {
774 int x, y, ret;
775 1 const int width = f->avctx->width;
776 1 const int height = f->avctx->height;
777 1 const unsigned int bitstream_size = AV_RL32(buf);
778 unsigned int prestream_size;
779 const uint8_t *prestream;
780
781
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
1 if (bitstream_size > (1 << 26))
782 return AVERROR_INVALIDDATA;
783
784
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
1 if (length < bitstream_size + 12) {
785 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
786 return AVERROR_INVALIDDATA;
787 }
788
789 1 prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
790 1 prestream = buf + bitstream_size + 12;
791
792
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
1 if (prestream_size + bitstream_size + 12 != length
793
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
1 || prestream_size > (1 << 26)) {
794 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
795 prestream_size, bitstream_size, length);
796 return AVERROR_INVALIDDATA;
797 }
798
799 1 prestream = read_huffman_tables(f, prestream, prestream_size);
800
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
1 if (!prestream) {
801 av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
802 return AVERROR_INVALIDDATA;
803 }
804
805
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
1 av_assert0(prestream <= buf + length);
806
807 1 init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
808
809 1 prestream_size = length + buf - prestream;
810
811 1 av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
812 prestream_size);
813
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
1 if (!f->bitstream_buffer)
814 return AVERROR(ENOMEM);
815 1 f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) prestream,
816 1 prestream_size / 4);
817 1 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
818
819 1 f->last_dc = 0 * 128 * 8 * 8;
820
821
2/2
✓ Branch 0 taken 30 times.
✓ Branch 1 taken 1 times.
31 for (y = 0; y < height; y += 16) {
822
2/2
✓ Branch 0 taken 1200 times.
✓ Branch 1 taken 30 times.
1230 for (x = 0; x < width; x += 16) {
823
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1200 times.
1200 if ((ret = decode_i_mb(f)) < 0)
824 return ret;
825
826 1200 idct_put(f, x, y);
827 }
828 }
829
830
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
1 if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
831 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
832
833 1 return 0;
834 }
835
836 201 static int decode_frame(AVCodecContext *avctx, void *data,
837 int *got_frame, AVPacket *avpkt)
838 {
839 201 const uint8_t *buf = avpkt->data;
840 201 int buf_size = avpkt->size;
841 201 FourXContext *const f = avctx->priv_data;
842 201 AVFrame *picture = data;
843 int i, frame_4cc, frame_size, ret;
844
845
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 201 times.
201 if (buf_size < 20)
846 return AVERROR_INVALIDDATA;
847
848
2/4
✓ Branch 0 taken 201 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 201 times.
201 av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
849
850
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 201 times.
201 if (buf_size < AV_RL32(buf + 4) + 8) {
851 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %"PRIu32"\n",
852 buf_size, AV_RL32(buf + 4));
853 return AVERROR_INVALIDDATA;
854 }
855
856 201 frame_4cc = AV_RL32(buf);
857
858
2/2
✓ Branch 0 taken 14 times.
✓ Branch 1 taken 187 times.
201 if (frame_4cc == AV_RL32("cfrm")) {
859 14 int free_index = -1;
860 int id, whole_size;
861 14 const int data_size = buf_size - 20;
862 CFrameBuffer *cfrm;
863
864
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
14 if (f->version <= 1) {
865 av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
866 return AVERROR_INVALIDDATA;
867 }
868
869 14 id = AV_RL32(buf + 12);
870 14 whole_size = AV_RL32(buf + 16);
871
872
2/4
✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 14 times.
14 if (data_size < 0 || whole_size < 0) {
873 av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
874 return AVERROR_INVALIDDATA;
875 }
876
877
2/2
✓ Branch 0 taken 1400 times.
✓ Branch 1 taken 14 times.
1414 for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
878
3/4
✓ Branch 0 taken 15 times.
✓ Branch 1 taken 1385 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 15 times.
1400 if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
879 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
880 f->cfrm[i].id);
881
882
2/2
✓ Branch 0 taken 1396 times.
✓ Branch 1 taken 2 times.
1398 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
883
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 1384 times.
1396 if (f->cfrm[i].id == id)
884 12 break;
885
2/2
✓ Branch 0 taken 1382 times.
✓ Branch 1 taken 2 times.
1384 if (f->cfrm[i].size == 0)
886 1382 free_index = i;
887 }
888
889
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 12 times.
14 if (i >= CFRAME_BUFFER_COUNT) {
890 2 i = free_index;
891 2 f->cfrm[i].id = id;
892 }
893 14 cfrm = &f->cfrm[i];
894
895
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
14 if (data_size > UINT_MAX - cfrm->size - AV_INPUT_BUFFER_PADDING_SIZE)
896 return AVERROR_INVALIDDATA;
897
898 28 cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
899 14 cfrm->size + data_size + AV_INPUT_BUFFER_PADDING_SIZE);
900 // explicit check needed as memcpy below might not catch a NULL
901
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
14 if (!cfrm->data) {
902 av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
903 return AVERROR(ENOMEM);
904 }
905
906 14 memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
907 14 cfrm->size += data_size;
908
909
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 12 times.
14 if (cfrm->size >= whole_size) {
910 2 buf = cfrm->data;
911 2 frame_size = cfrm->size;
912
913
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 if (id != avctx->frame_number)
914 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
915 id, avctx->frame_number);
916
917
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 if (f->version <= 1)
918 return AVERROR_INVALIDDATA;
919
920 2 cfrm->size = cfrm->id = 0;
921 2 frame_4cc = AV_RL32("pfrm");
922 } else
923 12 return buf_size;
924 } else {
925 187 buf = buf + 12;
926 187 frame_size = buf_size - 12;
927 }
928
929
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 189 times.
189 if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
930 return ret;
931
932
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 184 times.
189 if (frame_4cc == AV_RL32("ifr2")) {
933 5 picture->pict_type = AV_PICTURE_TYPE_I;
934
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
5 if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0) {
935 av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
936 return ret;
937 }
938
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 183 times.
184 } else if (frame_4cc == AV_RL32("ifrm")) {
939 1 picture->pict_type = AV_PICTURE_TYPE_I;
940
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
1 if ((ret = decode_i_frame(f, buf, frame_size)) < 0) {
941 av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
942 return ret;
943 }
944
3/4
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 171 times.
✓ Branch 2 taken 12 times.
✗ Branch 3 not taken.
183 } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
945 183 picture->pict_type = AV_PICTURE_TYPE_P;
946
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 183 times.
183 if ((ret = decode_p_frame(f, buf, frame_size)) < 0) {
947 av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
948 return ret;
949 }
950 } else if (frame_4cc == AV_RL32("snd_")) {
951 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
952 buf_size);
953 } else {
954 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
955 buf_size);
956 }
957
958 189 picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
959
960 189 av_image_copy_plane(picture->data[0], picture->linesize[0],
961 189 (const uint8_t*)f->frame_buffer, avctx->width * 2,
962 189 avctx->width * 2, avctx->height);
963 189 FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
964
965 189 *got_frame = 1;
966
967 189 emms_c();
968
969 189 return buf_size;
970 }
971
972 5 static av_cold int decode_end(AVCodecContext *avctx)
973 {
974 5 FourXContext * const f = avctx->priv_data;
975 int i;
976
977 5 av_freep(&f->frame_buffer);
978 5 av_freep(&f->last_frame_buffer);
979 5 av_freep(&f->bitstream_buffer);
980 5 f->bitstream_buffer_size = 0;
981
2/2
✓ Branch 0 taken 500 times.
✓ Branch 1 taken 5 times.
505 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
982 500 av_freep(&f->cfrm[i].data);
983 500 f->cfrm[i].allocated_size = 0;
984 }
985 5 ff_free_vlc(&f->pre_vlc);
986
987 5 return 0;
988 }
989
990 5 static av_cold int decode_init(AVCodecContext *avctx)
991 {
992 static AVOnce init_static_once = AV_ONCE_INIT;
993 5 FourXContext * const f = avctx->priv_data;
994 int ret;
995
996
2/4
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5 times.
5 if (avctx->extradata_size != 4 || !avctx->extradata) {
997 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
998 return AVERROR_INVALIDDATA;
999 }
1000
2/4
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5 times.
5 if((avctx->width % 16) || (avctx->height % 16)) {
1001 av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
1002 return AVERROR_INVALIDDATA;
1003 }
1004
1005 5 ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
1006
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
5 if (ret < 0)
1007 return ret;
1008
1009 5 f->frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1010 5 f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1011
2/4
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5 times.
5 if (!f->frame_buffer || !f->last_frame_buffer) {
1012 decode_end(avctx);
1013 return AVERROR(ENOMEM);
1014 }
1015
1016 5 f->version = AV_RL32(avctx->extradata) >> 16;
1017 5 ff_blockdsp_init(&f->bdsp, avctx);
1018 5 ff_bswapdsp_init(&f->bbdsp);
1019 5 f->avctx = avctx;
1020
1021
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 2 times.
5 if (f->version > 2)
1022 3 avctx->pix_fmt = AV_PIX_FMT_RGB565;
1023 else
1024 2 avctx->pix_fmt = AV_PIX_FMT_BGR555;
1025
1026 5 ff_thread_once(&init_static_once, init_vlcs);
1027
1028 5 return 0;
1029 }
1030
1031 const AVCodec ff_fourxm_decoder = {
1032 .name = "4xm",
1033 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
1034 .type = AVMEDIA_TYPE_VIDEO,
1035 .id = AV_CODEC_ID_4XM,
1036 .priv_data_size = sizeof(FourXContext),
1037 .init = decode_init,
1038 .close = decode_end,
1039 .decode = decode_frame,
1040 .capabilities = AV_CODEC_CAP_DR1,
1041 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
1042 };
1043