FFmpeg coverage

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