FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/huffyuvdec.c
Date: 2026-10-17 12:12:06
Exec Total Coverage
Lines: 463 767 60.4%
Functions: 16 17 94.1%
Branches: 347 597 58.1%
Line Branch Exec Source
1 /*
2 * huffyuv decoder
3 *
4 * Copyright (c) 2002-2014 Michael Niedermayer <michaelni@gmx.at>
5 *
6 * see https://multimedia.cx/huffyuv.txt for a description of
7 * the algorithm used
8 *
9 * This file is part of FFmpeg.
10 *
11 * FFmpeg is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
15 *
16 * FFmpeg is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with FFmpeg; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 *
25 * yuva, gray, 4:4:4, 4:1:1, 4:1:0 and >8 bit per sample support sponsored by NOA
26 */
27
28 /**
29 * @file
30 * huffyuv decoder
31 */
32
33 #define UNCHECKED_BITSTREAM_READER 1
34
35 #include "config_components.h"
36
37 #include "avcodec.h"
38 #include "bswapdsp.h"
39 #include "bytestream.h"
40 #include "codec_internal.h"
41 #include "get_bits.h"
42 #include "huffyuv.h"
43 #include "huffyuvdsp.h"
44 #include "lossless_videodsp.h"
45 #include "thread.h"
46 #include "libavutil/imgutils.h"
47 #include "libavutil/mem.h"
48 #include "libavutil/pixdesc.h"
49
50 #define VLC_BITS 12
51
52 typedef struct HYuvDecContext {
53 GetBitContext gb;
54 Predictor predictor;
55 int interlaced;
56 int decorrelate;
57 int bitstream_bpp;
58 int version;
59 int yuy2; //use yuy2 instead of 422P
60 int bgr32; //use bgr32 instead of bgr24
61 int bps;
62 int n; // 1<<bps
63 int vlc_n; // number of vlc codes (FFMIN(1<<bps, MAX_VLC_N))
64 int alpha;
65 int chroma;
66 int yuv;
67 int chroma_h_shift;
68 int chroma_v_shift;
69 int flags;
70 int context;
71 int last_slice_end;
72
73 union {
74 uint8_t *temp[3];
75 uint16_t *temp16[3];
76 };
77 uint8_t len[4][MAX_VLC_N];
78 uint32_t bits[4][MAX_VLC_N];
79 uint32_t pix_bgr_map[1<<VLC_BITS];
80 VLC vlc[8]; //Y,U,V,A,YY,YU,YV,AA
81 uint8_t *bitstream_buffer;
82 unsigned int bitstream_buffer_size;
83 BswapDSPContext bdsp;
84 HuffYUVDSPContext hdsp;
85 LLVidDSPContext llviddsp;
86 } HYuvDecContext;
87
88
89 static const uint8_t classic_shift_luma[] = {
90 34, 36, 35, 69, 135, 232, 9, 16, 10, 24, 11, 23, 12, 16, 13, 10,
91 14, 8, 15, 8, 16, 8, 17, 20, 16, 10, 207, 206, 205, 236, 11, 8,
92 10, 21, 9, 23, 8, 8, 199, 70, 69, 68,
93 };
94
95 static const uint8_t classic_shift_chroma[] = {
96 66, 36, 37, 38, 39, 40, 41, 75, 76, 77, 110, 239, 144, 81, 82, 83,
97 84, 85, 118, 183, 56, 57, 88, 89, 56, 89, 154, 57, 58, 57, 26, 141,
98 57, 56, 58, 57, 58, 57, 184, 119, 214, 245, 116, 83, 82, 49, 80, 79,
99 78, 77, 44, 75, 41, 40, 39, 38, 37, 36, 34,
100 };
101
102 static const unsigned char classic_add_luma[256] = {
103 3, 9, 5, 12, 10, 35, 32, 29, 27, 50, 48, 45, 44, 41, 39, 37,
104 73, 70, 68, 65, 64, 61, 58, 56, 53, 50, 49, 46, 44, 41, 38, 36,
105 68, 65, 63, 61, 58, 55, 53, 51, 48, 46, 45, 43, 41, 39, 38, 36,
106 35, 33, 32, 30, 29, 27, 26, 25, 48, 47, 46, 44, 43, 41, 40, 39,
107 37, 36, 35, 34, 32, 31, 30, 28, 27, 26, 24, 23, 22, 20, 19, 37,
108 35, 34, 33, 31, 30, 29, 27, 26, 24, 23, 21, 20, 18, 17, 15, 29,
109 27, 26, 24, 22, 21, 19, 17, 16, 14, 26, 25, 23, 21, 19, 18, 16,
110 15, 27, 25, 23, 21, 19, 17, 16, 14, 26, 25, 23, 21, 18, 17, 14,
111 12, 17, 19, 13, 4, 9, 2, 11, 1, 7, 8, 0, 16, 3, 14, 6,
112 12, 10, 5, 15, 18, 11, 10, 13, 15, 16, 19, 20, 22, 24, 27, 15,
113 18, 20, 22, 24, 26, 14, 17, 20, 22, 24, 27, 15, 18, 20, 23, 25,
114 28, 16, 19, 22, 25, 28, 32, 36, 21, 25, 29, 33, 38, 42, 45, 49,
115 28, 31, 34, 37, 40, 42, 44, 47, 49, 50, 52, 54, 56, 57, 59, 60,
116 62, 64, 66, 67, 69, 35, 37, 39, 40, 42, 43, 45, 47, 48, 51, 52,
117 54, 55, 57, 59, 60, 62, 63, 66, 67, 69, 71, 72, 38, 40, 42, 43,
118 46, 47, 49, 51, 26, 28, 30, 31, 33, 34, 18, 19, 11, 13, 7, 8,
119 };
120
121 static const unsigned char classic_add_chroma[256] = {
122 3, 1, 2, 2, 2, 2, 3, 3, 7, 5, 7, 5, 8, 6, 11, 9,
123 7, 13, 11, 10, 9, 8, 7, 5, 9, 7, 6, 4, 7, 5, 8, 7,
124 11, 8, 13, 11, 19, 15, 22, 23, 20, 33, 32, 28, 27, 29, 51, 77,
125 43, 45, 76, 81, 46, 82, 75, 55, 56, 144, 58, 80, 60, 74, 147, 63,
126 143, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
127 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 27, 30, 21, 22,
128 17, 14, 5, 6, 100, 54, 47, 50, 51, 53, 106, 107, 108, 109, 110, 111,
129 112, 113, 114, 115, 4, 117, 118, 92, 94, 121, 122, 3, 124, 103, 2, 1,
130 0, 129, 130, 131, 120, 119, 126, 125, 136, 137, 138, 139, 140, 141, 142, 134,
131 135, 132, 133, 104, 64, 101, 62, 57, 102, 95, 93, 59, 61, 28, 97, 96,
132 52, 49, 48, 29, 32, 25, 24, 46, 23, 98, 45, 44, 43, 20, 42, 41,
133 19, 18, 99, 40, 15, 39, 38, 16, 13, 12, 11, 37, 10, 9, 8, 36,
134 7, 128, 127, 105, 123, 116, 35, 34, 33, 145, 31, 79, 42, 146, 78, 26,
135 83, 48, 49, 50, 44, 47, 26, 31, 30, 18, 17, 19, 21, 24, 25, 13,
136 14, 16, 17, 18, 20, 21, 12, 14, 15, 9, 10, 6, 9, 6, 5, 8,
137 6, 12, 8, 10, 7, 9, 6, 4, 6, 2, 2, 3, 3, 3, 3, 2,
138 };
139
140 255 static int read_len_table(uint8_t *dst, GetByteContext *gb, int n)
141 {
142 int i, val, repeat;
143
144
2/2
✓ Branch 0 taken 9327 times.
✓ Branch 1 taken 255 times.
 9582 for (i = 0; i < n;) {
145
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 9327 times.
 9327 if (bytestream2_get_bytes_left(gb) <= 0)
146 ✗ goto error;
147 9327 repeat = bytestream2_peek_byteu(gb) >> 5;
148 9327 val = bytestream2_get_byteu(gb) & 0x1F;
149
2/2
✓ Branch 0 taken 5055 times.
✓ Branch 1 taken 4272 times.
 9327 if (repeat == 0) {
150
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5055 times.
 5055 if (bytestream2_get_bytes_left(gb) <= 0)
151 ✗ goto error;
152 5055 repeat = bytestream2_get_byteu(gb);
153 }
154
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9327 times.
 9327 if (i + repeat > n)
155 ✗ goto error;
156
2/2
✓ Branch 0 taken 562944 times.
✓ Branch 1 taken 9327 times.
 572271 while (repeat--)
157 562944 dst[i++] = val;
158 }
159 255 return 0;
160
161 ✗ error:
162 ✗ av_log(NULL, AV_LOG_ERROR, "Error reading huffman table\n");
163 ✗ return AVERROR_INVALIDDATA;
164 }
165
166 85 static int generate_joint_tables(HYuvDecContext *s)
167 {
168 int ret;
169 85 uint16_t *symbols = av_mallocz(5 << VLC_BITS);
170 uint16_t *bits;
171 uint8_t *len;
172
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 85 times.
 85 if (!symbols)
173 ✗ return AVERROR(ENOMEM);
174 85 bits = symbols + (1 << VLC_BITS);
175 85 len = (uint8_t *)(bits + (1 << VLC_BITS));
176
177
3/4
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 69 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 16 times.
 154 if (s->bitstream_bpp < 24 || s->version > 2) {
178 69 int count = 1 + s->alpha + 2 * s->chroma;
179 int p, i, y, u;
180
2/2
✓ Branch 0 taken 207 times.
✓ Branch 1 taken 69 times.
 276 for (p = 0; p < count; p++) {
181
2/2
✓ Branch 0 taken 96 times.
✓ Branch 1 taken 111 times.
 207 int p0 = s->version > 2 ? p : 0;
182
2/2
✓ Branch 0 taken 550656 times.
✓ Branch 1 taken 207 times.
 550863 for (i = y = 0; y < s->vlc_n; y++) {
183 550656 int len0 = s->len[p0][y];
184 550656 int limit = VLC_BITS - len0;
185
3/4
✓ Branch 0 taken 13431 times.
✓ Branch 1 taken 537225 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 13431 times.
 550656 if (limit <= 0 || !len0)
186 537225 continue;
187
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13431 times.
 13431 if ((sign_extend(y, 8) & (s->vlc_n-1)) != y)
188 ✗ continue;
189
2/2
✓ Branch 0 taken 35399424 times.
✓ Branch 1 taken 13431 times.
 35412855 for (u = 0; u < s->vlc_n; u++) {
190 35399424 int len1 = s->len[p][u];
191
3/4
✓ Branch 0 taken 77271 times.
✓ Branch 1 taken 35322153 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 77271 times.
 35399424 if (len1 > limit || !len1)
192 35322153 continue;
193
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 77271 times.
 77271 if ((sign_extend(u, 8) & (s->vlc_n-1)) != u)
194 ✗ continue;
195
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 77271 times.
 77271 av_assert0(i < (1 << VLC_BITS));
196 77271 len[i] = len0 + len1;
197 77271 bits[i] = (s->bits[p0][y] << len1) + s->bits[p][u];
198 77271 symbols[i] = (y << 8) + (u & 0xFF);
199 77271 i++;
200 }
201 }
202 207 ff_vlc_free(&s->vlc[4 + p]);
203
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 207 times.
 207 if ((ret = ff_vlc_init_sparse(&s->vlc[4 + p], VLC_BITS, i, len, 1, 1,
204 bits, 2, 2, symbols, 2, 2, 0)) < 0)
205 ✗ goto out;
206 }
207 } else {
208 16 uint8_t (*map)[4] = (uint8_t(*)[4]) s->pix_bgr_map;
209 int i, b, g, r, code;
210 16 int p0 = s->decorrelate;
211 16 int p1 = !s->decorrelate;
212 /* Restrict the range to +/-16 because that's pretty much guaranteed
213 * to cover all the combinations that fit in 11 bits total, and it
214 * does not matter if we miss a few rare codes. */
215
2/2
✓ Branch 0 taken 512 times.
✓ Branch 1 taken 16 times.
 528 for (i = 0, g = -16; g < 16; g++) {
216 512 int len0 = s->len[p0][g & 255];
217 512 int limit0 = VLC_BITS - len0;
218
2/4
✓ Branch 0 taken 512 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 512 times.
 512 if (limit0 < 2 || !len0)
219 ✗ continue;
220
2/2
✓ Branch 0 taken 16384 times.
✓ Branch 1 taken 512 times.
 16896 for (b = -16; b < 16; b++) {
221 16384 int len1 = s->len[p1][b & 255];
222 16384 int limit1 = limit0 - len1;
223
3/4
✓ Branch 0 taken 3728 times.
✓ Branch 1 taken 12656 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 3728 times.
 16384 if (limit1 < 1 || !len1)
224 12656 continue;
225 3728 code = (s->bits[p0][g & 255] << len1) + s->bits[p1][b & 255];
226
2/2
✓ Branch 0 taken 119296 times.
✓ Branch 1 taken 3728 times.
 123024 for (r = -16; r < 16; r++) {
227 119296 int len2 = s->len[2][r & 255];
228
3/4
✓ Branch 0 taken 10928 times.
✓ Branch 1 taken 108368 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 10928 times.
 119296 if (len2 > limit1 || !len2)
229 108368 continue;
230
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10928 times.
 10928 av_assert0(i < (1 << VLC_BITS));
231 10928 len[i] = len0 + len1 + len2;
232 10928 bits[i] = (code << len2) + s->bits[2][r & 255];
233
1/2
✓ Branch 0 taken 10928 times.
✗ Branch 1 not taken.
 10928 if (s->decorrelate) {
234 10928 map[i][G] = g;
235 10928 map[i][B] = g + b;
236 10928 map[i][R] = g + r;
237 } else {
238 ✗ map[i][B] = g;
239 ✗ map[i][G] = b;
240 ✗ map[i][R] = r;
241 }
242 10928 i++;
243 }
244 }
245 }
246 16 ff_vlc_free(&s->vlc[4]);
247
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 16 times.
 16 if ((ret = vlc_init(&s->vlc[4], VLC_BITS, i, len, 1, 1,
248 bits, 2, 2, 0)) < 0)
249 ✗ goto out;
250 }
251 85 ret = 0;
252 85 out:
253 85 av_freep(&symbols);
254 85 return ret;
255 }
256
257 85 static int read_huffman_tables(HYuvDecContext *s, const uint8_t *src, int length)
258 {
259 GetByteContext gb;
260 int i, ret;
261 85 int count = 3;
262
263 85 bytestream2_init(&gb, src, length);
264
265
2/2
✓ Branch 0 taken 32 times.
✓ Branch 1 taken 53 times.
 85 if (s->version > 2)
266 32 count = 1 + s->alpha + 2*s->chroma;
267
268
2/2
✓ Branch 0 taken 255 times.
✓ Branch 1 taken 85 times.
 340 for (i = 0; i < count; i++) {
269
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 255 times.
 255 if ((ret = read_len_table(s->len[i], &gb, s->vlc_n)) < 0)
270 ✗ return ret;
271
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 255 times.
 255 if ((ret = ff_huffyuv_generate_bits_table(s->bits[i], s->len[i], s->vlc_n)) < 0)
272 ✗ return ret;
273 255 ff_vlc_free(&s->vlc[i]);
274
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 255 times.
 255 if ((ret = vlc_init(&s->vlc[i], VLC_BITS, s->vlc_n, s->len[i], 1, 1,
275 s->bits[i], 4, 4, 0)) < 0)
276 ✗ return ret;
277 }
278
279
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 85 times.
 85 if ((ret = generate_joint_tables(s)) < 0)
280 ✗ return ret;
281
282 85 return bytestream2_tell(&gb);
283 }
284
285 ✗ static int read_old_huffman_tables(HYuvDecContext *s)
286 {
287 GetByteContext gb;
288 int i, ret;
289
290 ✗ bytestream2_init(&gb, classic_shift_luma,
291 sizeof(classic_shift_luma));
292 ✗ ret = read_len_table(s->len[0], &gb, 256);
293 av_assert1(ret >= 0);
294
295 ✗ bytestream2_init(&gb, classic_shift_chroma,
296 sizeof(classic_shift_chroma));
297 ✗ ret = read_len_table(s->len[1], &gb, 256);
298 av_assert1(ret >= 0);
299
300 ✗ for (i = 0; i < 256; i++)
301 ✗ s->bits[0][i] = classic_add_luma[i];
302 ✗ for (i = 0; i < 256; i++)
303 ✗ s->bits[1][i] = classic_add_chroma[i];
304
305 ✗ if (s->bitstream_bpp >= 24) {
306 ✗ memcpy(s->bits[1], s->bits[0], 256 * sizeof(uint32_t));
307 ✗ memcpy(s->len[1], s->len[0], 256 * sizeof(uint8_t));
308 }
309 ✗ memcpy(s->bits[2], s->bits[1], 256 * sizeof(uint32_t));
310 ✗ memcpy(s->len[2], s->len[1], 256 * sizeof(uint8_t));
311
312 ✗ for (i = 0; i < 4; i++) {
313 ✗ ff_vlc_free(&s->vlc[i]);
314 ✗ if ((ret = vlc_init(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1,
315 s->bits[i], 4, 4, 0)) < 0)
316 ✗ return ret;
317 }
318
319 ✗ if ((ret = generate_joint_tables(s)) < 0)
320 ✗ return ret;
321
322 ✗ return 0;
323 }
324
325 85 static av_cold int decode_end(AVCodecContext *avctx)
326 {
327 85 HYuvDecContext *s = avctx->priv_data;
328 int i;
329
330
2/2
✓ Branch 0 taken 255 times.
✓ Branch 1 taken 85 times.
 340 for (int i = 0; i < 3; i++)
331 255 av_freep(&s->temp[i]);
332
333 85 av_freep(&s->bitstream_buffer);
334
335
2/2
✓ Branch 0 taken 680 times.
✓ Branch 1 taken 85 times.
 765 for (i = 0; i < 8; i++)
336 680 ff_vlc_free(&s->vlc[i]);
337
338 85 return 0;
339 }
340
341 85 static av_cold int decode_init(AVCodecContext *avctx)
342 {
343 85 HYuvDecContext *s = avctx->priv_data;
344 int ret;
345
346 85 ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
347
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 85 times.
 85 if (ret < 0)
348 ✗ return ret;
349
350 85 s->flags = avctx->flags;
351
352 85 ff_bswapdsp_init(&s->bdsp);
353 85 ff_huffyuvdsp_init(&s->hdsp);
354 85 ff_llviddsp_init(&s->llviddsp);
355
356 85 s->interlaced = avctx->height > 288;
357 85 s->bgr32 = 1;
358
359
1/2
✓ Branch 0 taken 85 times.
✗ Branch 1 not taken.
 85 if (avctx->extradata_size) {
360
2/2
✓ Branch 0 taken 28 times.
✓ Branch 1 taken 57 times.
 85 if ((avctx->bits_per_coded_sample & 7) &&
361
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 28 times.
 28 avctx->bits_per_coded_sample != 12)
362 ✗ s->version = 1; // do such files exist at all?
363
3/4
✓ Branch 0 taken 85 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 53 times.
✓ Branch 3 taken 32 times.
 85 else if (avctx->extradata_size > 3 && avctx->extradata[3] == 0)
364 53 s->version = 2;
365 else
366 32 s->version = 3;
367 } else
368 ✗ s->version = 0;
369
370 85 s->bps = 8;
371 85 s->n = 1<<s->bps;
372 85 s->vlc_n = FFMIN(s->n, MAX_VLC_N);
373 85 s->chroma = 1;
374
1/2
✓ Branch 0 taken 85 times.
✗ Branch 1 not taken.
 85 if (s->version >= 2) {
375 int method, interlace;
376
377
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 85 times.
 85 if (avctx->extradata_size < 4)
378 ✗ return AVERROR_INVALIDDATA;
379
380 85 method = avctx->extradata[0];
381 85 s->decorrelate = method & 64 ? 1 : 0;
382 85 s->predictor = method & 63;
383
2/2
✓ Branch 0 taken 53 times.
✓ Branch 1 taken 32 times.
 85 if (s->version == 2) {
384 53 s->bitstream_bpp = avctx->extradata[1];
385
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 53 times.
 53 if (s->bitstream_bpp == 0)
386 ✗ s->bitstream_bpp = avctx->bits_per_coded_sample & ~7;
387 } else {
388 32 s->bps = (avctx->extradata[1] >> 4) + 1;
389 32 s->n = 1<<s->bps;
390 32 s->vlc_n = FFMIN(s->n, MAX_VLC_N);
391 32 s->chroma_h_shift = avctx->extradata[1] & 3;
392 32 s->chroma_v_shift = (avctx->extradata[1] >> 2) & 3;
393 32 s->yuv = !!(avctx->extradata[2] & 1);
394 32 s->chroma= !!(avctx->extradata[2] & 3);
395 32 s->alpha = !!(avctx->extradata[2] & 4);
396 }
397 85 interlace = (avctx->extradata[2] & 0x30) >> 4;
398
2/4
✓ Branch 0 taken 85 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 85 times.
 85 s->interlaced = (interlace == 1) ? 1 : (interlace == 2) ? 0 : s->interlaced;
399 85 s->context = avctx->extradata[2] & 0x40 ? 1 : 0;
400
401
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 85 times.
 85 if ((ret = read_huffman_tables(s, avctx->extradata + 4,
402 85 avctx->extradata_size - 4)) < 0)
403 ✗ return ret;
404 } else {
405 ✗ switch (avctx->bits_per_coded_sample & 7) {
406 ✗ case 1:
407 ✗ s->predictor = LEFT;
408 ✗ s->decorrelate = 0;
409 ✗ break;
410 ✗ case 2:
411 ✗ s->predictor = LEFT;
412 ✗ s->decorrelate = 1;
413 ✗ break;
414 ✗ case 3:
415 ✗ s->predictor = PLANE;
416 ✗ s->decorrelate = avctx->bits_per_coded_sample >= 24;
417 ✗ break;
418 ✗ case 4:
419 ✗ s->predictor = MEDIAN;
420 ✗ s->decorrelate = 0;
421 ✗ break;
422 ✗ default:
423 ✗ s->predictor = LEFT; // OLD
424 ✗ s->decorrelate = 0;
425 ✗ break;
426 }
427 ✗ s->bitstream_bpp = avctx->bits_per_coded_sample & ~7;
428 ✗ s->context = 0;
429
430 ✗ if ((ret = read_old_huffman_tables(s)) < 0)
431 ✗ return ret;
432 }
433
434
2/2
✓ Branch 0 taken 53 times.
✓ Branch 1 taken 32 times.
 85 if (s->version <= 2) {
435
4/5
✓ Branch 0 taken 28 times.
✓ Branch 1 taken 9 times.
✓ Branch 2 taken 8 times.
✓ Branch 3 taken 8 times.
✗ Branch 4 not taken.
 53 switch (s->bitstream_bpp) {
436 28 case 12:
437 28 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
438 28 s->yuv = 1;
439 28 break;
440 9 case 16:
441
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
 9 if (s->yuy2)
442 ✗ avctx->pix_fmt = AV_PIX_FMT_YUYV422;
443 else
444 9 avctx->pix_fmt = AV_PIX_FMT_YUV422P;
445 9 s->yuv = 1;
446 9 break;
447 8 case 24:
448
1/2
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
 8 if (s->bgr32)
449 8 avctx->pix_fmt = AV_PIX_FMT_0RGB32;
450 else
451 ✗ avctx->pix_fmt = AV_PIX_FMT_BGR24;
452 8 break;
453 8 case 32:
454
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
 8 av_assert0(s->bgr32);
455 8 avctx->pix_fmt = AV_PIX_FMT_RGB32;
456 8 s->alpha = 1;
457 8 break;
458 ✗ default:
459 ✗ return AVERROR_INVALIDDATA;
460 }
461 53 av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt,
462 &s->chroma_h_shift,
463 &s->chroma_v_shift);
464 } else {
465
4/43
✗ Branch 0 not taken.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✓ Branch 9 taken 8 times.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✓ Branch 14 taken 8 times.
✗ Branch 15 not taken.
✗ Branch 16 not taken.
✓ Branch 17 taken 8 times.
✗ Branch 18 not taken.
✗ Branch 19 not taken.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
✗ Branch 22 not taken.
✗ Branch 23 not taken.
✗ Branch 24 not taken.
✗ Branch 25 not taken.
✓ Branch 26 taken 8 times.
✗ Branch 27 not taken.
✗ Branch 28 not taken.
✗ Branch 29 not taken.
✗ Branch 30 not taken.
✗ Branch 31 not taken.
✗ Branch 32 not taken.
✗ Branch 33 not taken.
✗ Branch 34 not taken.
✗ Branch 35 not taken.
✗ Branch 36 not taken.
✗ Branch 37 not taken.
✗ Branch 38 not taken.
✗ Branch 39 not taken.
✗ Branch 40 not taken.
✗ Branch 41 not taken.
✗ Branch 42 not taken.
 32 switch ( (s->chroma<<10) | (s->yuv<<9) | (s->alpha<<8) | ((s->bps-1)<<4) | s->chroma_h_shift | (s->chroma_v_shift<<2)) {
466 ✗ case 0x070:
467 ✗ avctx->pix_fmt = AV_PIX_FMT_GRAY8;
468 ✗ break;
469 ✗ case 0x0F0:
470 ✗ avctx->pix_fmt = AV_PIX_FMT_GRAY16;
471 ✗ break;
472 ✗ case 0x470:
473 ✗ avctx->pix_fmt = AV_PIX_FMT_GBRP;
474 ✗ break;
475 ✗ case 0x480:
476 ✗ avctx->pix_fmt = AV_PIX_FMT_GBRP9;
477 ✗ break;
478 ✗ case 0x490:
479 ✗ avctx->pix_fmt = AV_PIX_FMT_GBRP10;
480 ✗ break;
481 ✗ case 0x4B0:
482 ✗ avctx->pix_fmt = AV_PIX_FMT_GBRP12;
483 ✗ break;
484 ✗ case 0x4D0:
485 ✗ avctx->pix_fmt = AV_PIX_FMT_GBRP14;
486 ✗ break;
487 ✗ case 0x4F0:
488 ✗ avctx->pix_fmt = AV_PIX_FMT_GBRP16;
489 ✗ break;
490 ✗ case 0x570:
491 ✗ avctx->pix_fmt = AV_PIX_FMT_GBRAP;
492 ✗ break;
493 8 case 0x670:
494 8 avctx->pix_fmt = AV_PIX_FMT_YUV444P;
495 8 break;
496 ✗ case 0x680:
497 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV444P9;
498 ✗ break;
499 ✗ case 0x690:
500 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV444P10;
501 ✗ break;
502 ✗ case 0x6B0:
503 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV444P12;
504 ✗ break;
505 ✗ case 0x6D0:
506 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV444P14;
507 ✗ break;
508 8 case 0x6F0:
509 8 avctx->pix_fmt = AV_PIX_FMT_YUV444P16;
510 8 break;
511 ✗ case 0x671:
512 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV422P;
513 ✗ break;
514 ✗ case 0x681:
515 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV422P9;
516 ✗ break;
517 8 case 0x691:
518 8 avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
519 8 break;
520 ✗ case 0x6B1:
521 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV422P12;
522 ✗ break;
523 ✗ case 0x6D1:
524 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV422P14;
525 ✗ break;
526 ✗ case 0x6F1:
527 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV422P16;
528 ✗ break;
529 ✗ case 0x672:
530 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV411P;
531 ✗ break;
532 ✗ case 0x674:
533 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV440P;
534 ✗ break;
535 ✗ case 0x675:
536 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV420P;
537 ✗ break;
538 ✗ case 0x685:
539 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV420P9;
540 ✗ break;
541 ✗ case 0x695:
542 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV420P10;
543 ✗ break;
544 8 case 0x6B5:
545 8 avctx->pix_fmt = AV_PIX_FMT_YUV420P12;
546 8 break;
547 ✗ case 0x6D5:
548 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV420P14;
549 ✗ break;
550 ✗ case 0x6F5:
551 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV420P16;
552 ✗ break;
553 ✗ case 0x67A:
554 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV410P;
555 ✗ break;
556 ✗ case 0x770:
557 ✗ avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
558 ✗ break;
559 ✗ case 0x780:
560 ✗ avctx->pix_fmt = AV_PIX_FMT_YUVA444P9;
561 ✗ break;
562 ✗ case 0x790:
563 ✗ avctx->pix_fmt = AV_PIX_FMT_YUVA444P10;
564 ✗ break;
565 ✗ case 0x7F0:
566 ✗ avctx->pix_fmt = AV_PIX_FMT_YUVA444P16;
567 ✗ break;
568 ✗ case 0x771:
569 ✗ avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
570 ✗ break;
571 ✗ case 0x781:
572 ✗ avctx->pix_fmt = AV_PIX_FMT_YUVA422P9;
573 ✗ break;
574 ✗ case 0x791:
575 ✗ avctx->pix_fmt = AV_PIX_FMT_YUVA422P10;
576 ✗ break;
577 ✗ case 0x7F1:
578 ✗ avctx->pix_fmt = AV_PIX_FMT_YUVA422P16;
579 ✗ break;
580 ✗ case 0x775:
581 ✗ avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
582 ✗ break;
583 ✗ case 0x785:
584 ✗ avctx->pix_fmt = AV_PIX_FMT_YUVA420P9;
585 ✗ break;
586 ✗ case 0x795:
587 ✗ avctx->pix_fmt = AV_PIX_FMT_YUVA420P10;
588 ✗ break;
589 ✗ case 0x7F5:
590 ✗ avctx->pix_fmt = AV_PIX_FMT_YUVA420P16;
591 ✗ break;
592 ✗ default:
593 ✗ return AVERROR_INVALIDDATA;
594 }
595 }
596
597
5/6
✓ Branch 0 taken 76 times.
✓ Branch 1 taken 9 times.
✓ Branch 2 taken 28 times.
✓ Branch 3 taken 48 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 37 times.
 85 if ((avctx->pix_fmt == AV_PIX_FMT_YUV422P || avctx->pix_fmt == AV_PIX_FMT_YUV420P) && avctx->width & 1) {
598 ✗ av_log(avctx, AV_LOG_ERROR, "width must be even for this colorspace\n");
599 ✗ return AVERROR_INVALIDDATA;
600 }
601
4/4
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 75 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 8 times.
 85 if (s->predictor == MEDIAN && avctx->pix_fmt == AV_PIX_FMT_YUV422P &&
602
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 avctx->width % 4) {
603 ✗ av_log(avctx, AV_LOG_ERROR, "width must be a multiple of 4 "
604 "for this combination of colorspace and predictor type.\n");
605 ✗ return AVERROR_INVALIDDATA;
606 }
607
608
2/2
✓ Branch 0 taken 255 times.
✓ Branch 1 taken 85 times.
 340 for (int i = 0; i < 3; i++) {
609 255 s->temp[i] = av_malloc(4 * avctx->width + 16);
610
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 255 times.
 255 if (!s->temp[i])
611 ✗ return AVERROR(ENOMEM);
612 }
613
614 85 return 0;
615 }
616
617 /** Subset of GET_VLC for use in hand-roller VLC code */
618 #define VLC_INTERN(dst, table, gb, name, bits, max_depth) \
619 code = table[index].sym; \
620 n = table[index].len; \
621 if (max_depth > 1 && n < 0) { \
622 LAST_SKIP_BITS(name, gb, bits); \
623 UPDATE_CACHE(name, gb); \
624 \
625 nb_bits = -n; \
626 index = SHOW_UBITS(name, gb, nb_bits) + code; \
627 code = table[index].sym; \
628 n = table[index].len; \
629 if (max_depth > 2 && n < 0) { \
630 LAST_SKIP_BITS(name, gb, nb_bits); \
631 UPDATE_CACHE(name, gb); \
632 \
633 nb_bits = -n; \
634 index = SHOW_UBITS(name, gb, nb_bits) + code; \
635 code = table[index].sym; \
636 n = table[index].len; \
637 } \
638 } \
639 dst = code; \
640 LAST_SKIP_BITS(name, gb, n)
641
642
643 #define GET_VLC_DUAL(dst0, dst1, name, gb, dtable, table1, table2, \
644 bits, max_depth, OP) \
645 do { \
646 unsigned int index = SHOW_UBITS(name, gb, bits); \
647 int code, n = dtable[index].len; \
648 \
649 if (n<=0) { \
650 int nb_bits; \
651 VLC_INTERN(dst0, table1, gb, name, bits, max_depth); \
652 \
653 UPDATE_CACHE(re, gb); \
654 index = SHOW_UBITS(name, gb, bits); \
655 VLC_INTERN(dst1, table2, gb, name, bits, max_depth); \
656 } else { \
657 code = dtable[index].sym; \
658 OP(dst0, dst1, code); \
659 LAST_SKIP_BITS(name, gb, n); \
660 } \
661 } while (0)
662
663 #define OP8bits(dst0, dst1, code) dst0 = code>>8; dst1 = code
664
665 #define READ_2PIX(dst0, dst1, plane1) \
666 UPDATE_CACHE(re, &s->gb); \
667 GET_VLC_DUAL(dst0, dst1, re, &s->gb, s->vlc[4+plane1].table, \
668 s->vlc[0].table, s->vlc[plane1].table, VLC_BITS, 3, OP8bits)
669
670 70440 static void decode_422_bitstream(HYuvDecContext *s, int count)
671 {
672 int i, icount;
673 70440 OPEN_READER(re, &s->gb);
674 70440 count /= 2;
675
676 70440 icount = get_bits_left(&s->gb) / (32 * 4);
677
2/2
✓ Branch 0 taken 1725 times.
✓ Branch 1 taken 68715 times.
 70440 if (count >= icount) {
678
2/2
✓ Branch 0 taken 150135 times.
✓ Branch 1 taken 1725 times.
 151860 for (i = 0; i < icount; i++) {
679
8/10
✓ Branch 1 taken 34340 times.
✓ Branch 2 taken 115795 times.
✓ Branch 3 taken 5290 times.
✓ Branch 4 taken 29050 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 5290 times.
✓ Branch 10 taken 2803 times.
✓ Branch 11 taken 31537 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 2803 times.
 150135 READ_2PIX(s->temp[0][2 * i], s->temp[1][i], 1);
680
8/10
✓ Branch 1 taken 46555 times.
✓ Branch 2 taken 103580 times.
✓ Branch 3 taken 4442 times.
✓ Branch 4 taken 42113 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 4442 times.
✓ Branch 10 taken 2481 times.
✓ Branch 11 taken 44074 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 2481 times.
 150135 READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2);
681 }
682
3/4
✓ Branch 0 taken 125859 times.
✓ Branch 1 taken 1725 times.
✓ Branch 2 taken 125859 times.
✗ Branch 3 not taken.
 127584 for (; i < count && BITS_LEFT(re, &s->gb) > 0; i++) {
683
8/10
✓ Branch 1 taken 28543 times.
✓ Branch 2 taken 97316 times.
✓ Branch 3 taken 3473 times.
✓ Branch 4 taken 25070 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 3473 times.
✓ Branch 10 taken 1390 times.
✓ Branch 11 taken 27153 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 1390 times.
 125859 READ_2PIX(s->temp[0][2 * i ], s->temp[1][i], 1);
684
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 125859 times.
 125859 if (BITS_LEFT(re, &s->gb) <= 0) break;
685
8/10
✓ Branch 1 taken 32576 times.
✓ Branch 2 taken 93283 times.
✓ Branch 3 taken 3484 times.
✓ Branch 4 taken 29092 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 3484 times.
✓ Branch 10 taken 1281 times.
✓ Branch 11 taken 31295 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 1281 times.
 125859 READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2);
686 }
687
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1725 times.
 1725 for (; i < count; i++)
688 ✗ s->temp[0][2 * i ] = s->temp[1][i] =
689 ✗ s->temp[0][2 * i + 1] = s->temp[2][i] = 0;
690 } else {
691
2/2
✓ Branch 0 taken 12266146 times.
✓ Branch 1 taken 68715 times.
 12334861 for (i = 0; i < count; i++) {
692
8/10
✓ Branch 1 taken 2880766 times.
✓ Branch 2 taken 9385380 times.
✓ Branch 3 taken 419979 times.
✓ Branch 4 taken 2460787 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 419979 times.
✓ Branch 10 taken 219633 times.
✓ Branch 11 taken 2661133 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 219633 times.
 12266146 READ_2PIX(s->temp[0][2 * i], s->temp[1][i], 1);
693
8/10
✓ Branch 1 taken 3749864 times.
✓ Branch 2 taken 8516282 times.
✓ Branch 3 taken 393233 times.
✓ Branch 4 taken 3356631 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 393233 times.
✓ Branch 10 taken 188991 times.
✓ Branch 11 taken 3560873 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 188991 times.
 12266146 READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2);
694 }
695 }
696 70440 CLOSE_READER(re, &s->gb);
697 70440 }
698
699 #define READ_2PIX_PLANE(dst0, dst1, plane, OP) \
700 UPDATE_CACHE(re, &s->gb); \
701 GET_VLC_DUAL(dst0, dst1, re, &s->gb, s->vlc[4+plane].table, \
702 s->vlc[plane].table, s->vlc[plane].table, VLC_BITS, 3, OP)
703
704 #define OP14bits(dst0, dst1, code) dst0 = code>>8; dst1 = sign_extend(code, 8)
705
706 /* TODO instead of restarting the read when the code isn't in the first level
707 * of the joint table, jump into the 2nd level of the individual table. */
708 #define READ_2PIX_PLANE16(dst0, dst1, plane){\
709 dst0 = get_vlc2(&s->gb, s->vlc[plane].table, VLC_BITS, 3)*4;\
710 dst0 += get_bits(&s->gb, 2);\
711 dst1 = get_vlc2(&s->gb, s->vlc[plane].table, VLC_BITS, 3)*4;\
712 dst1 += get_bits(&s->gb, 2);\
713 }
714 493900 static void decode_plane_bitstream(HYuvDecContext *s, int width, int plane)
715 {
716 493900 int i, count = width/2;
717
718
2/2
✓ Branch 0 taken 134700 times.
✓ Branch 1 taken 359200 times.
 493900 if (s->bps <= 8) {
719 134700 OPEN_READER(re, &s->gb);
720
2/2
✓ Branch 1 taken 1387 times.
✓ Branch 2 taken 133313 times.
 134700 if (count >= (get_bits_left(&s->gb)) / (32 * 2)) {
721
3/4
✓ Branch 0 taken 212153 times.
✓ Branch 1 taken 1387 times.
✓ Branch 2 taken 212153 times.
✗ Branch 3 not taken.
 213540 for (i = 0; i < count && BITS_LEFT(re, &s->gb) > 0; i++) {
722
8/10
✓ Branch 1 taken 24131 times.
✓ Branch 2 taken 188022 times.
✓ Branch 3 taken 542 times.
✓ Branch 4 taken 23589 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 542 times.
✓ Branch 10 taken 65 times.
✓ Branch 11 taken 24066 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 65 times.
 212153 READ_2PIX_PLANE(s->temp[0][2 * i], s->temp[0][2 * i + 1], plane, OP8bits);
723 }
724 1387 memset(s->temp[0] + 2 * i, 0, 2 * (count - i));
725 } else {
726
2/2
✓ Branch 0 taken 22684147 times.
✓ Branch 1 taken 133313 times.
 22817460 for(i=0; i<count; i++){
727
8/10
✓ Branch 1 taken 6319215 times.
✓ Branch 2 taken 16364932 times.
✓ Branch 3 taken 350124 times.
✓ Branch 4 taken 5969091 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 350124 times.
✓ Branch 10 taken 266353 times.
✓ Branch 11 taken 6052862 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 266353 times.
 22684147 READ_2PIX_PLANE(s->temp[0][2 * i], s->temp[0][2 * i + 1], plane, OP8bits);
728 }
729 }
730
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 134700 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 134700 if( width&1 && BITS_LEFT(re, &s->gb)>0 ) {
731 unsigned int index;
732 int nb_bits, code, n;
733 ✗ UPDATE_CACHE(re, &s->gb);
734 ✗ index = SHOW_UBITS(re, &s->gb, VLC_BITS);
735 ✗ VLC_INTERN(s->temp[0][width-1], s->vlc[plane].table,
736 &s->gb, re, VLC_BITS, 3);
737
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 134700 times.
 134700 } else if (width & 1)
738 ✗ s->temp[0][width - 1] = 0;
739 134700 CLOSE_READER(re, &s->gb);
740
2/2
✓ Branch 0 taken 224500 times.
✓ Branch 1 taken 134700 times.
 359200 } else if (s->bps <= 14) {
741 224500 OPEN_READER(re, &s->gb);
742
2/2
✓ Branch 1 taken 1169 times.
✓ Branch 2 taken 223331 times.
 224500 if (count >= (get_bits_left(&s->gb)) / (32 * 2)) {
743
3/4
✓ Branch 0 taken 88392 times.
✓ Branch 1 taken 1169 times.
✓ Branch 2 taken 88392 times.
✗ Branch 3 not taken.
 89561 for (i = 0; i < count && BITS_LEFT(re, &s->gb) > 0; i++) {
744
8/10
✓ Branch 1 taken 57537 times.
✓ Branch 2 taken 30855 times.
✓ Branch 3 taken 17985 times.
✓ Branch 4 taken 39552 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 17985 times.
✓ Branch 10 taken 17597 times.
✓ Branch 11 taken 39940 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 17597 times.
 88392 READ_2PIX_PLANE(s->temp16[0][2 * i], s->temp16[0][2 * i + 1], plane, OP14bits);
745 }
746 1169 memset(s->temp16[0] + 2 * i, 0, 4 * (count - i));
747 } else {
748
2/2
✓ Branch 0 taken 26621408 times.
✓ Branch 1 taken 223331 times.
 26844739 for(i=0; i<count; i++){
749
8/10
✓ Branch 1 taken 20442544 times.
✓ Branch 2 taken 6178864 times.
✓ Branch 3 taken 8244628 times.
✓ Branch 4 taken 12197916 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 8244628 times.
✓ Branch 10 taken 8144723 times.
✓ Branch 11 taken 12297821 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 8144723 times.
 26621408 READ_2PIX_PLANE(s->temp16[0][2 * i], s->temp16[0][2 * i + 1], plane, OP14bits);
750 }
751 }
752
3/4
✓ Branch 0 taken 5100 times.
✓ Branch 1 taken 219400 times.
✓ Branch 2 taken 5100 times.
✗ Branch 3 not taken.
 224500 if( width&1 && BITS_LEFT(re, &s->gb)>0 ) {
753 unsigned int index;
754 int nb_bits, code, n;
755 5100 UPDATE_CACHE(re, &s->gb);
756 5100 index = SHOW_UBITS(re, &s->gb, VLC_BITS);
757
3/4
✓ Branch 0 taken 1953 times.
✓ Branch 1 taken 3147 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1953 times.
 5100 VLC_INTERN(s->temp16[0][width-1], s->vlc[plane].table,
758 &s->gb, re, VLC_BITS, 3);
759
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 219400 times.
 219400 } else if (width & 1)
760 ✗ s->temp16[0][width - 1] = 0;
761 224500 CLOSE_READER(re, &s->gb);
762 } else {
763
2/2
✓ Branch 1 taken 372 times.
✓ Branch 2 taken 134328 times.
 134700 if (count >= (get_bits_left(&s->gb)) / (32 * 2)) {
764
3/4
✓ Branch 0 taken 56886 times.
✓ Branch 1 taken 372 times.
✓ Branch 3 taken 56886 times.
✗ Branch 4 not taken.
 57258 for (i = 0; i < count && get_bits_left(&s->gb) > 0; i++) {
765 56886 READ_2PIX_PLANE16(s->temp16[0][2 * i], s->temp16[0][2 * i + 1], plane);
766 }
767 372 memset(s->temp16[0] + 2 * i, 0, 4 * (count - i));
768 } else {
769
2/2
✓ Branch 0 taken 22839414 times.
✓ Branch 1 taken 134328 times.
 22973742 for(i=0; i<count; i++){
770 22839414 READ_2PIX_PLANE16(s->temp16[0][2 * i], s->temp16[0][2 * i + 1], plane);
771 }
772 }
773
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 134700 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 134700 if( width&1 && get_bits_left(&s->gb)>0 ) {
774 ✗ int dst = (unsigned)get_vlc2(&s->gb, s->vlc[plane].table, VLC_BITS, 3)<<2;
775 ✗ s->temp16[0][width-1] = dst + get_bits(&s->gb, 2);
776
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 134700 times.
 134700 } else if (width & 1)
777 ✗ s->temp16[0][width - 1] = 0;
778 }
779 493900 }
780
781 25490 static void decode_gray_bitstream(HYuvDecContext *s, int count)
782 {
783 int i;
784 25490 OPEN_READER(re, &s->gb);
785 25490 count /= 2;
786
787
2/2
✓ Branch 1 taken 427 times.
✓ Branch 2 taken 25063 times.
 25490 if (count >= (get_bits_left(&s->gb)) / (32 * 2)) {
788
3/4
✓ Branch 0 taken 74930 times.
✓ Branch 1 taken 427 times.
✓ Branch 2 taken 74930 times.
✗ Branch 3 not taken.
 75357 for (i = 0; i < count && BITS_LEFT(re, &s->gb) > 0; i++) {
789
8/10
✓ Branch 1 taken 31336 times.
✓ Branch 2 taken 43594 times.
✓ Branch 3 taken 1978 times.
✓ Branch 4 taken 29358 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 1978 times.
✓ Branch 10 taken 1840 times.
✓ Branch 11 taken 29496 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 1840 times.
 74930 READ_2PIX(s->temp[0][2 * i], s->temp[0][2 * i + 1], 0);
790 }
791
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 427 times.
 427 for (; i < count; i++)
792 ✗ s->temp[0][2 * i] = s->temp[0][2 * i + 1] = 0;
793 } else {
794
2/2
✓ Branch 0 taken 4835520 times.
✓ Branch 1 taken 25063 times.
 4860583 for (i = 0; i < count; i++) {
795
8/10
✓ Branch 1 taken 2242950 times.
✓ Branch 2 taken 2592570 times.
✓ Branch 3 taken 144924 times.
✓ Branch 4 taken 2098026 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 144924 times.
✓ Branch 10 taken 134202 times.
✓ Branch 11 taken 2108748 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 134202 times.
 4835520 READ_2PIX(s->temp[0][2 * i], s->temp[0][2 * i + 1], 0);
796 }
797 }
798 25490 CLOSE_READER(re, &s->gb);
799 25490 }
800
801 89800 static av_always_inline void decode_bgr_1(HYuvDecContext *s, int count,
802 int decorrelate, int alpha)
803 {
804 int i;
805 89800 OPEN_READER(re, &s->gb);
806
807
3/4
✓ Branch 0 taken 30528000 times.
✓ Branch 1 taken 89800 times.
✓ Branch 2 taken 30528000 times.
✗ Branch 3 not taken.
 30617800 for (i = 0; i < count && BITS_LEFT(re, &s->gb) > 0; i++) {
808 unsigned int index;
809 int code, n, nb_bits;
810
811 30528000 UPDATE_CACHE(re, &s->gb);
812 30528000 index = SHOW_UBITS(re, &s->gb, VLC_BITS);
813 30528000 n = s->vlc[4].table[index].len;
814
815
2/2
✓ Branch 0 taken 13538088 times.
✓ Branch 1 taken 16989912 times.
 30528000 if (n>0) {
816 13538088 code = s->vlc[4].table[index].sym;
817 13538088 *(uint32_t *) &s->temp[0][4 * i] = s->pix_bgr_map[code];
818 13538088 LAST_SKIP_BITS(re, &s->gb, n);
819 } else {
820
1/2
✓ Branch 0 taken 16989912 times.
✗ Branch 1 not taken.
 16989912 if (decorrelate) {
821
3/4
✓ Branch 0 taken 1469318 times.
✓ Branch 1 taken 15520594 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1469318 times.
 16989912 VLC_INTERN(s->temp[0][4 * i + G], s->vlc[1].table,
822 &s->gb, re, VLC_BITS, 3);
823
824 16989912 UPDATE_CACHE(re, &s->gb);
825 16989912 index = SHOW_UBITS(re, &s->gb, VLC_BITS);
826
3/4
✓ Branch 0 taken 1019554 times.
✓ Branch 1 taken 15970358 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1019554 times.
 16989912 VLC_INTERN(code, s->vlc[0].table, &s->gb, re, VLC_BITS, 3);
827 16989912 s->temp[0][4 * i + B] = code + s->temp[0][4 * i + G];
828
829 16989912 UPDATE_CACHE(re, &s->gb);
830 16989912 index = SHOW_UBITS(re, &s->gb, VLC_BITS);
831
3/4
✓ Branch 0 taken 957442 times.
✓ Branch 1 taken 16032470 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 957442 times.
 16989912 VLC_INTERN(code, s->vlc[2].table, &s->gb, re, VLC_BITS, 3);
832 16989912 s->temp[0][4 * i + R] = code + s->temp[0][4 * i + G];
833 } else {
834 ✗ VLC_INTERN(s->temp[0][4 * i + B], s->vlc[0].table,
835 &s->gb, re, VLC_BITS, 3);
836
837 ✗ UPDATE_CACHE(re, &s->gb);
838 ✗ index = SHOW_UBITS(re, &s->gb, VLC_BITS);
839 ✗ VLC_INTERN(s->temp[0][4 * i + G], s->vlc[1].table,
840 &s->gb, re, VLC_BITS, 3);
841
842 ✗ UPDATE_CACHE(re, &s->gb);
843 ✗ index = SHOW_UBITS(re, &s->gb, VLC_BITS);
844 ✗ VLC_INTERN(s->temp[0][4 * i + R], s->vlc[2].table,
845 &s->gb, re, VLC_BITS, 3);
846 }
847 }
848
2/2
✓ Branch 0 taken 15264000 times.
✓ Branch 1 taken 15264000 times.
 30528000 if (alpha) {
849 15264000 UPDATE_CACHE(re, &s->gb);
850 15264000 index = SHOW_UBITS(re, &s->gb, VLC_BITS);
851
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 15264000 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 15264000 VLC_INTERN(s->temp[0][4 * i + A], s->vlc[2].table,
852 &s->gb, re, VLC_BITS, 3);
853 } else
854 15264000 s->temp[0][4 * i + A] = 0;
855 }
856 89800 CLOSE_READER(re, &s->gb);
857 89800 memset(s->temp[0] + 4 * i, 0, 4 * (count - i));
858 89800 }
859
860 89800 static void decode_bgr_bitstream(HYuvDecContext *s, int count)
861 {
862
1/2
✓ Branch 0 taken 89800 times.
✗ Branch 1 not taken.
 89800 if (s->decorrelate) {
863
2/2
✓ Branch 0 taken 44900 times.
✓ Branch 1 taken 44900 times.
 89800 if (s->bitstream_bpp == 24)
864 44900 decode_bgr_1(s, count, 1, 0);
865 else
866 44900 decode_bgr_1(s, count, 1, 1);
867 } else {
868 ✗ if (s->bitstream_bpp == 24)
869 ✗ decode_bgr_1(s, count, 0, 0);
870 else
871 ✗ decode_bgr_1(s, count, 0, 1);
872 }
873 89800 }
874
875 71540 static void draw_slice(HYuvDecContext *s, AVCodecContext *avctx, AVFrame *frame, int y)
876 {
877 int h, cy, i;
878 int offset[AV_NUM_DATA_POINTERS];
879
880
1/2
✓ Branch 0 taken 71540 times.
✗ Branch 1 not taken.
 71540 if (!avctx->draw_horiz_band)
881 71540 return;
882
883 ✗ h = y - s->last_slice_end;
884 ✗ y -= h;
885
886 ✗ if (s->bitstream_bpp == 12)
887 ✗ cy = y >> 1;
888 else
889 ✗ cy = y;
890
891 ✗ offset[0] = frame->linesize[0] * y;
892 ✗ offset[1] = frame->linesize[1] * cy;
893 ✗ offset[2] = frame->linesize[2] * cy;
894 ✗ for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
895 ✗ offset[i] = 0;
896
897 ✗ avctx->draw_horiz_band(avctx, frame, offset, y, 3, h);
898
899 ✗ s->last_slice_end = y + h;
900 }
901
902 404700 static int left_prediction(HYuvDecContext *s, uint8_t *dst, const uint8_t *src, int w, int acc)
903 {
904
2/2
✓ Branch 0 taken 134700 times.
✓ Branch 1 taken 270000 times.
 404700 if (s->bps <= 8) {
905 134700 return s->llviddsp.add_left_pred(dst, src, w, acc);
906 } else {
907 270000 return s->llviddsp.add_left_pred_int16(( uint16_t *)dst, (const uint16_t *)src, s->n-1, w, acc);
908 }
909 }
910
911 134100 static void add_bytes(HYuvDecContext *s, uint8_t *dst, uint8_t *src, int w)
912 {
913
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 134100 times.
 134100 if (s->bps <= 8) {
914 ✗ s->llviddsp.add_bytes(dst, src, w);
915 } else {
916 134100 s->hdsp.add_int16((uint16_t*)dst, (const uint16_t*)src, s->n - 1, w);
917 }
918 134100 }
919
920 89200 static void add_median_prediction(HYuvDecContext *s, uint8_t *dst, const uint8_t *src, const uint8_t *diff, int w, int *left, int *left_top)
921 {
922
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 89200 times.
 89200 if (s->bps <= 8) {
923 ✗ s->llviddsp.add_median_pred(dst, src, diff, w, left, left_top);
924 } else {
925 89200 s->hdsp.add_hfyu_median_pred_int16((uint16_t *)dst, (const uint16_t *)src, (const uint16_t *)diff, s->n-1, w, left, left_top);
926 }
927 89200 }
928
929 1610 static int decode_slice(AVCodecContext *avctx, AVFrame *p, int height,
930 int buf_size, int y_offset, int table_size)
931 {
932 1610 HYuvDecContext *s = avctx->priv_data;
933 int fake_ystride, fake_ustride, fake_vstride;
934 1610 const int width = avctx->width;
935 1610 const int width2 = avctx->width >> 1;
936 int ret;
937
938
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1610 times.
 1610 if ((ret = init_get_bits8(&s->gb, s->bitstream_buffer + table_size, buf_size - table_size)) < 0)
939 ✗ return ret;
940
941
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1610 times.
 1610 fake_ystride = s->interlaced ? p->linesize[0] * 2 : p->linesize[0];
942
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1610 times.
 1610 fake_ustride = s->interlaced ? p->linesize[1] * 2 : p->linesize[1];
943
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1610 times.
 1610 fake_vstride = s->interlaced ? p->linesize[2] * 2 : p->linesize[2];
944
945
2/2
✓ Branch 0 taken 800 times.
✓ Branch 1 taken 810 times.
 1610 if (s->version > 2) {
946 int plane;
947
2/2
✓ Branch 0 taken 2400 times.
✓ Branch 1 taken 800 times.
 3200 for(plane = 0; plane < 1 + 2*s->chroma + s->alpha; plane++) {
948 int left, lefttop, y;
949 2400 int w = width;
950 2400 int h = height;
951 2400 int fake_stride = fake_ystride;
952
953
5/6
✓ Branch 0 taken 2400 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1600 times.
✓ Branch 3 taken 800 times.
✓ Branch 4 taken 800 times.
✓ Branch 5 taken 800 times.
 2400 if (s->chroma && (plane == 1 || plane == 2)) {
954 1600 w >>= s->chroma_h_shift;
955 1600 h >>= s->chroma_v_shift;
956
2/2
✓ Branch 0 taken 800 times.
✓ Branch 1 taken 800 times.
 1600 fake_stride = plane == 1 ? fake_ustride : fake_vstride;
957 }
958
959
2/3
✓ Branch 0 taken 1800 times.
✓ Branch 1 taken 600 times.
✗ Branch 2 not taken.
 2400 switch (s->predictor) {
960 1800 case LEFT:
961 case PLANE:
962 1800 decode_plane_bitstream(s, w, plane);
963 1800 left = left_prediction(s, p->data[plane], s->temp[0], w, 0);
964
965
2/2
✓ Branch 0 taken 402300 times.
✓ Branch 1 taken 1800 times.
 404100 for (y = 1; y < h; y++) {
966 402300 uint8_t *dst = p->data[plane] + p->linesize[plane]*y;
967
968 402300 decode_plane_bitstream(s, w, plane);
969 402300 left = left_prediction(s, dst, s->temp[0], w, left);
970
2/2
✓ Branch 0 taken 134100 times.
✓ Branch 1 taken 268200 times.
 402300 if (s->predictor == PLANE) {
971
1/2
✓ Branch 0 taken 134100 times.
✗ Branch 1 not taken.
 134100 if (y > s->interlaced) {
972 134100 add_bytes(s, dst, dst - fake_stride, w);
973 }
974 }
975 }
976
977 1800 break;
978 600 case MEDIAN:
979 600 decode_plane_bitstream(s, w, plane);
980 600 left= left_prediction(s, p->data[plane], s->temp[0], w, 0);
981
982 600 y = 1;
983
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 600 times.
 600 if (y >= h)
984 ✗ break;
985
986 /* second line is left predicted for interlaced case */
987
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 600 times.
 600 if (s->interlaced) {
988 ✗ decode_plane_bitstream(s, w, plane);
989 ✗ left = left_prediction(s, p->data[plane] + p->linesize[plane], s->temp[0], w, left);
990 ✗ y++;
991 ✗ if (y >= h)
992 ✗ break;
993 }
994
995
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 600 times.
 600 lefttop = READ_LOWBYTE(p->data[plane], s->bps);
996 600 decode_plane_bitstream(s, w, plane);
997 600 add_median_prediction(s, p->data[plane] + fake_stride, p->data[plane], s->temp[0], w, &left, &lefttop);
998 600 y++;
999
1000
2/2
✓ Branch 0 taken 88600 times.
✓ Branch 1 taken 600 times.
 89200 for (; y<h; y++) {
1001 uint8_t *dst;
1002
1003 88600 decode_plane_bitstream(s, w, plane);
1004
1005 88600 dst = p->data[plane] + p->linesize[plane] * y;
1006
1007 88600 add_median_prediction(s, dst, dst - fake_stride, s->temp[0], w, &left, &lefttop);
1008 }
1009
1010 600 break;
1011 }
1012 }
1013 800 draw_slice(s, avctx, p, height);
1014
2/2
✓ Branch 0 taken 410 times.
✓ Branch 1 taken 400 times.
 810 } else if (s->bitstream_bpp < 24) {
1015 int y, cy;
1016 int lefty, leftu, leftv;
1017 int lefttopy, lefttopu, lefttopv;
1018
1019
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 410 times.
 410 if (s->yuy2) {
1020 ✗ p->data[0][3] = get_bits(&s->gb, 8);
1021 ✗ p->data[0][2] = get_bits(&s->gb, 8);
1022 ✗ p->data[0][1] = get_bits(&s->gb, 8);
1023 ✗ p->data[0][0] = get_bits(&s->gb, 8);
1024
1025 ✗ av_log(avctx, AV_LOG_ERROR,
1026 "YUY2 output is not implemented yet\n");
1027 ✗ return AVERROR_PATCHWELCOME;
1028 } else {
1029 410 leftv =
1030 410 p->data[2][0 + y_offset * p->linesize[2]] = get_bits(&s->gb, 8);
1031 410 lefty =
1032 410 p->data[0][1 + y_offset * p->linesize[0]] = get_bits(&s->gb, 8);
1033 410 leftu =
1034 410 p->data[1][0 + y_offset * p->linesize[1]] = get_bits(&s->gb, 8);
1035 410 p->data[0][0 + y_offset * p->linesize[0]] = get_bits(&s->gb, 8);
1036
1037
2/3
✓ Branch 0 taken 360 times.
✓ Branch 1 taken 50 times.
✗ Branch 2 not taken.
 410 switch (s->predictor) {
1038 360 case LEFT:
1039 case PLANE:
1040 360 decode_422_bitstream(s, width - 2);
1041 720 lefty = s->llviddsp.add_left_pred(p->data[0] + p->linesize[0] * y_offset + 2, s->temp[0],
1042 360 width - 2, lefty);
1043
1/2
✓ Branch 0 taken 360 times.
✗ Branch 1 not taken.
 360 if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1044 360 leftu = s->llviddsp.add_left_pred(p->data[1] + p->linesize[1] * y_offset + 1, s->temp[1], width2 - 1, leftu);
1045 360 leftv = s->llviddsp.add_left_pred(p->data[2] + p->linesize[2] * y_offset + 1, s->temp[2], width2 - 1, leftv);
1046 }
1047
1048
2/2
✓ Branch 0 taken 55840 times.
✓ Branch 1 taken 150 times.
 55990 for (cy = y = 1; y < height; y++, cy++) {
1049 uint8_t *ydst, *udst, *vdst;
1050
1051
2/2
✓ Branch 0 taken 25490 times.
✓ Branch 1 taken 30350 times.
 55840 if (s->bitstream_bpp == 12) {
1052 25490 decode_gray_bitstream(s, width);
1053
1054 25490 ydst = p->data[0] + p->linesize[0] * (y + y_offset);
1055
1056 25490 lefty = s->llviddsp.add_left_pred(ydst, s->temp[0],
1057 width, lefty);
1058
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 25490 times.
 25490 if (s->predictor == PLANE) {
1059 ✗ if (y > s->interlaced)
1060 ✗ s->llviddsp.add_bytes(ydst, ydst - fake_ystride, width);
1061 }
1062 25490 y++;
1063
2/2
✓ Branch 0 taken 210 times.
✓ Branch 1 taken 25280 times.
 25490 if (y >= height)
1064 210 break;
1065 }
1066
1067 55630 draw_slice(s, avctx, p, y);
1068
1069 55630 ydst = p->data[0] + p->linesize[0] * (y + y_offset);
1070 55630 udst = p->data[1] + p->linesize[1] * (cy + y_offset);
1071 55630 vdst = p->data[2] + p->linesize[2] * (cy + y_offset);
1072
1073 55630 decode_422_bitstream(s, width);
1074 55630 lefty = s->llviddsp.add_left_pred(ydst, s->temp[0],
1075 width, lefty);
1076
1/2
✓ Branch 0 taken 55630 times.
✗ Branch 1 not taken.
 55630 if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1077 55630 leftu = s->llviddsp.add_left_pred(udst, s->temp[1], width2, leftu);
1078 55630 leftv = s->llviddsp.add_left_pred(vdst, s->temp[2], width2, leftv);
1079 }
1080
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 55630 times.
 55630 if (s->predictor == PLANE) {
1081 ✗ if (cy > s->interlaced) {
1082 ✗ s->llviddsp.add_bytes(ydst, ydst - fake_ystride, width);
1083 ✗ if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1084 ✗ s->llviddsp.add_bytes(udst, udst - fake_ustride, width2);
1085 ✗ s->llviddsp.add_bytes(vdst, vdst - fake_vstride, width2);
1086 }
1087 }
1088 }
1089 }
1090 360 draw_slice(s, avctx, p, height);
1091
1092 360 break;
1093 50 case MEDIAN:
1094 /* first line except first 2 pixels is left predicted */
1095 50 decode_422_bitstream(s, width - 2);
1096 100 lefty = s->llviddsp.add_left_pred(p->data[0] + 2, s->temp[0],
1097 50 width - 2, lefty);
1098
1/2
✓ Branch 0 taken 50 times.
✗ Branch 1 not taken.
 50 if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1099 50 leftu = s->llviddsp.add_left_pred(p->data[1] + 1, s->temp[1], width2 - 1, leftu);
1100 50 leftv = s->llviddsp.add_left_pred(p->data[2] + 1, s->temp[2], width2 - 1, leftv);
1101 }
1102
1103 50 cy = y = 1;
1104
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 50 times.
 50 if (y >= height)
1105 ✗ break;
1106
1107 /* second line is left predicted for interlaced case */
1108
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 50 times.
 50 if (s->interlaced) {
1109 ✗ decode_422_bitstream(s, width);
1110 ✗ lefty = s->llviddsp.add_left_pred(p->data[0] + p->linesize[0],
1111 ✗ s->temp[0], width, lefty);
1112 ✗ if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1113 ✗ leftu = s->llviddsp.add_left_pred(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
1114 ✗ leftv = s->llviddsp.add_left_pred(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
1115 }
1116 ✗ y++;
1117 ✗ cy++;
1118 ✗ if (y >= height)
1119 ✗ break;
1120 }
1121
1122 /* next 4 pixels are left predicted too */
1123 50 decode_422_bitstream(s, 4);
1124 100 lefty = s->llviddsp.add_left_pred(p->data[0] + fake_ystride,
1125 50 s->temp[0], 4, lefty);
1126
1/2
✓ Branch 0 taken 50 times.
✗ Branch 1 not taken.
 50 if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1127 50 leftu = s->llviddsp.add_left_pred(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
1128 50 leftv = s->llviddsp.add_left_pred(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
1129 }
1130
1131 /* next line except the first 4 pixels is median predicted */
1132 50 lefttopy = p->data[0][3];
1133 50 decode_422_bitstream(s, width - 4);
1134 50 s->llviddsp.add_median_pred(p->data[0] + fake_ystride + 4,
1135 50 p->data[0] + 4, s->temp[0],
1136 50 width - 4, &lefty, &lefttopy);
1137
1/2
✓ Branch 0 taken 50 times.
✗ Branch 1 not taken.
 50 if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1138 50 lefttopu = p->data[1][1];
1139 50 lefttopv = p->data[2][1];
1140 50 s->llviddsp.add_median_pred(p->data[1] + fake_ustride + 2, p->data[1] + 2, s->temp[1], width2 - 2, &leftu, &lefttopu);
1141 50 s->llviddsp.add_median_pred(p->data[2] + fake_vstride + 2, p->data[2] + 2, s->temp[2], width2 - 2, &leftv, &lefttopv);
1142 }
1143 50 y++;
1144 50 cy++;
1145
1146
2/2
✓ Branch 0 taken 14300 times.
✓ Branch 1 taken 50 times.
 14350 for (; y < height; y++, cy++) {
1147 uint8_t *ydst, *udst, *vdst;
1148
1149
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14300 times.
 14300 if (s->bitstream_bpp == 12) {
1150 ✗ while (2 * cy > y) {
1151 ✗ decode_gray_bitstream(s, width);
1152 ✗ ydst = p->data[0] + p->linesize[0] * y;
1153 ✗ s->llviddsp.add_median_pred(ydst, ydst - fake_ystride,
1154 ✗ s->temp[0], width,
1155 &lefty, &lefttopy);
1156 ✗ y++;
1157 }
1158 ✗ if (y >= height)
1159 ✗ break;
1160 }
1161 14300 draw_slice(s, avctx, p, y);
1162
1163 14300 decode_422_bitstream(s, width);
1164
1165 14300 ydst = p->data[0] + p->linesize[0] * y;
1166 14300 udst = p->data[1] + p->linesize[1] * cy;
1167 14300 vdst = p->data[2] + p->linesize[2] * cy;
1168
1169 14300 s->llviddsp.add_median_pred(ydst, ydst - fake_ystride,
1170 14300 s->temp[0], width,
1171 &lefty, &lefttopy);
1172
1/2
✓ Branch 0 taken 14300 times.
✗ Branch 1 not taken.
 14300 if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1173 14300 s->llviddsp.add_median_pred(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
1174 14300 s->llviddsp.add_median_pred(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
1175 }
1176 }
1177
1178 50 draw_slice(s, avctx, p, height);
1179 50 break;
1180 }
1181 }
1182 } else {
1183 int y;
1184 uint8_t left[4];
1185 400 const int last_line = (y_offset + height - 1) * p->linesize[0];
1186
1187
2/2
✓ Branch 0 taken 200 times.
✓ Branch 1 taken 200 times.
 400 if (s->bitstream_bpp == 32) {
1188 200 left[A] = p->data[0][last_line + A] = get_bits(&s->gb, 8);
1189 200 left[R] = p->data[0][last_line + R] = get_bits(&s->gb, 8);
1190 200 left[G] = p->data[0][last_line + G] = get_bits(&s->gb, 8);
1191 200 left[B] = p->data[0][last_line + B] = get_bits(&s->gb, 8);
1192 } else {
1193 200 left[R] = p->data[0][last_line + R] = get_bits(&s->gb, 8);
1194 200 left[G] = p->data[0][last_line + G] = get_bits(&s->gb, 8);
1195 200 left[B] = p->data[0][last_line + B] = get_bits(&s->gb, 8);
1196 200 left[A] = p->data[0][last_line + A] = 255;
1197 200 skip_bits(&s->gb, 8);
1198 }
1199
1200
1/2
✓ Branch 0 taken 400 times.
✗ Branch 1 not taken.
 400 if (s->bgr32) {
1201
1/2
✓ Branch 0 taken 400 times.
✗ Branch 1 not taken.
 400 switch (s->predictor) {
1202 400 case LEFT:
1203 case PLANE:
1204 400 decode_bgr_bitstream(s, width - 1);
1205 400 s->hdsp.add_hfyu_left_pred_bgr32(p->data[0] + last_line + 4,
1206 400 s->temp[0], width - 1, left);
1207
1208
2/2
✓ Branch 0 taken 89400 times.
✓ Branch 1 taken 400 times.
 89800 for (y = height - 2; y >= 0; y--) { // Yes it is stored upside down.
1209 89400 decode_bgr_bitstream(s, width);
1210
1211 89400 s->hdsp.add_hfyu_left_pred_bgr32(p->data[0] + p->linesize[0] * (y + y_offset),
1212 89400 s->temp[0], width, left);
1213
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 89400 times.
 89400 if (s->predictor == PLANE) {
1214 ✗ if (s->bitstream_bpp != 32)
1215 ✗ left[A] = 0;
1216 ✗ if (y < height - 1 - s->interlaced) {
1217 ✗ s->llviddsp.add_bytes(p->data[0] + p->linesize[0] * (y + y_offset),
1218 ✗ p->data[0] + p->linesize[0] * (y + y_offset) +
1219 ✗ fake_ystride, 4 * width);
1220 }
1221 }
1222 }
1223 // just 1 large slice as this is not possible in reverse order
1224 400 draw_slice(s, avctx, p, height);
1225 400 break;
1226 ✗ default:
1227 ✗ av_log(avctx, AV_LOG_ERROR,
1228 "prediction type not supported!\n");
1229 }
1230 } else {
1231 ✗ av_log(avctx, AV_LOG_ERROR,
1232 "BGR24 output is not implemented yet\n");
1233 ✗ return AVERROR_PATCHWELCOME;
1234 }
1235 }
1236
1237 1610 return 0;
1238 }
1239
1240 1610 static int decode_frame(AVCodecContext *avctx, AVFrame *p,
1241 int *got_frame, AVPacket *avpkt)
1242 {
1243 1610 const uint8_t *buf = avpkt->data;
1244 1610 int buf_size = avpkt->size;
1245 1610 HYuvDecContext *s = avctx->priv_data;
1246 1610 const int width = avctx->width;
1247 1610 const int height = avctx->height;
1248 1610 int slice, table_size = 0, ret, nb_slices;
1249 unsigned slices_info_offset;
1250 int slice_height;
1251
1252
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1610 times.
 1610 if (buf_size < (width * height + 7)/8)
1253 ✗ return AVERROR_INVALIDDATA;
1254
1255 1610 av_fast_padded_malloc(&s->bitstream_buffer,
1256 &s->bitstream_buffer_size,
1257 buf_size);
1258
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1610 times.
 1610 if (!s->bitstream_buffer)
1259 ✗ return AVERROR(ENOMEM);
1260
1261 1610 s->bdsp.bswap_buf((uint32_t *) s->bitstream_buffer,
1262 (const uint32_t *) buf, buf_size / 4);
1263
1264
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1610 times.
 1610 if ((ret = ff_thread_get_buffer(avctx, p, 0)) < 0)
1265 ✗ return ret;
1266
1267
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1610 times.
 1610 if (s->context) {
1268 ✗ table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size);
1269 ✗ if (table_size < 0)
1270 ✗ return table_size;
1271 }
1272
1273
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1610 times.
 1610 if ((unsigned) (buf_size - table_size) >= INT_MAX / 8)
1274 ✗ return AVERROR_INVALIDDATA;
1275
1276 1610 s->last_slice_end = 0;
1277
1278
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1610 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 1610 if (avctx->codec_id == AV_CODEC_ID_HYMT &&
1279 ✗ (buf_size > 32 && AV_RL32(avpkt->data + buf_size - 16) == 0)) {
1280 ✗ slices_info_offset = AV_RL32(avpkt->data + buf_size - 4);
1281 ✗ slice_height = AV_RL32(avpkt->data + buf_size - 8);
1282 ✗ nb_slices = AV_RL32(avpkt->data + buf_size - 12);
1283 ✗ if (nb_slices * 8LL + slices_info_offset > buf_size - 16 ||
1284 ✗ s->chroma_v_shift ||
1285 ✗ slice_height <= 0 || nb_slices * (uint64_t)slice_height > height)
1286 ✗ return AVERROR_INVALIDDATA;
1287 } else {
1288 1610 slice_height = height;
1289 1610 nb_slices = 1;
1290 }
1291
1292
2/2
✓ Branch 0 taken 1610 times.
✓ Branch 1 taken 1610 times.
 3220 for (slice = 0; slice < nb_slices; slice++) {
1293 int y_offset, slice_offset, slice_size;
1294
1295
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1610 times.
 1610 if (nb_slices > 1) {
1296 ✗ slice_offset = AV_RL32(avpkt->data + slices_info_offset + slice * 8);
1297 ✗ slice_size = AV_RL32(avpkt->data + slices_info_offset + slice * 8 + 4);
1298
1299 ✗ if (slice_offset < 0 || slice_size <= 0 || (slice_offset&3) ||
1300 ✗ slice_offset + (int64_t)slice_size > buf_size)
1301 ✗ return AVERROR_INVALIDDATA;
1302
1303 ✗ y_offset = height - (slice + 1) * slice_height;
1304 ✗ s->bdsp.bswap_buf((uint32_t *)s->bitstream_buffer,
1305 ✗ (const uint32_t *)(buf + slice_offset), slice_size / 4);
1306 } else {
1307 1610 y_offset = 0;
1308 1610 slice_offset = 0;
1309 1610 slice_size = buf_size;
1310 }
1311
1312 1610 ret = decode_slice(avctx, p, slice_height, slice_size, y_offset, table_size);
1313
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1610 times.
 1610 if (ret < 0)
1314 ✗ return ret;
1315 }
1316
1317 1610 *got_frame = 1;
1318
1319 1610 return (get_bits_count(&s->gb) + 31) / 32 * 4 + table_size;
1320 }
1321
1322 const FFCodec ff_huffyuv_decoder = {
1323 .p.name = "huffyuv",
1324 CODEC_LONG_NAME("Huffyuv / HuffYUV"),
1325 .p.type = AVMEDIA_TYPE_VIDEO,
1326 .p.id = AV_CODEC_ID_HUFFYUV,
1327 .priv_data_size = sizeof(HYuvDecContext),
1328 .init = decode_init,
1329 .close = decode_end,
1330 FF_CODEC_DECODE_CB(decode_frame),
1331 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DRAW_HORIZ_BAND |
1332 AV_CODEC_CAP_FRAME_THREADS,
1333 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1334 };
1335
1336 #if CONFIG_FFVHUFF_DECODER
1337 const FFCodec ff_ffvhuff_decoder = {
1338 .p.name = "ffvhuff",
1339 CODEC_LONG_NAME("Huffyuv FFmpeg variant"),
1340 .p.type = AVMEDIA_TYPE_VIDEO,
1341 .p.id = AV_CODEC_ID_FFVHUFF,
1342 .priv_data_size = sizeof(HYuvDecContext),
1343 .init = decode_init,
1344 .close = decode_end,
1345 FF_CODEC_DECODE_CB(decode_frame),
1346 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DRAW_HORIZ_BAND |
1347 AV_CODEC_CAP_FRAME_THREADS,
1348 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1349 };
1350 #endif /* CONFIG_FFVHUFF_DECODER */
1351
1352 #if CONFIG_HYMT_DECODER
1353 const FFCodec ff_hymt_decoder = {
1354 .p.name = "hymt",
1355 CODEC_LONG_NAME("HuffYUV MT"),
1356 .p.type = AVMEDIA_TYPE_VIDEO,
1357 .p.id = AV_CODEC_ID_HYMT,
1358 .priv_data_size = sizeof(HYuvDecContext),
1359 .init = decode_init,
1360 .close = decode_end,
1361 FF_CODEC_DECODE_CB(decode_frame),
1362 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DRAW_HORIZ_BAND |
1363 AV_CODEC_CAP_FRAME_THREADS,
1364 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1365 };
1366 #endif /* CONFIG_HYMT_DECODER */
1367