FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/huffyuvdec.c
Date: 2024-04-20 14:10:07
Exec Total Coverage
Lines: 394 757 52.0%
Functions: 15 17 88.2%
Branches: 322 587 54.9%

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