FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/huffyuvdec.c
Date: 2022-11-26 13:19:19
Exec Total Coverage
Lines: 389 750 51.9%
Branches: 320 587 54.5%

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