FFmpeg coverage


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