FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/mjpegdec.c
Date: 2025-10-30 05:42:18
Exec Total Coverage
Lines: 1216 1809 67.2%
Functions: 32 33 97.0%
Branches: 904 1673 54.0%

Line Branch Exec Source
1 /*
2 * MJPEG decoder
3 * Copyright (c) 2000, 2001 Fabrice Bellard
4 * Copyright (c) 2003 Alex Beregszaszi
5 * Copyright (c) 2003-2004 Michael Niedermayer
6 *
7 * Support for external huffman table, various fixes (AVID workaround),
8 * aspecting, new decode_frame mechanism and apple mjpeg-b support
9 * by Alex Beregszaszi
10 *
11 * This file is part of FFmpeg.
12 *
13 * FFmpeg is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU Lesser General Public
15 * License as published by the Free Software Foundation; either
16 * version 2.1 of the License, or (at your option) any later version.
17 *
18 * FFmpeg is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * Lesser General Public License for more details.
22 *
23 * You should have received a copy of the GNU Lesser General Public
24 * License along with FFmpeg; if not, write to the Free Software
25 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 */
27
28 /**
29 * @file
30 * MJPEG decoder.
31 */
32
33 #include "config_components.h"
34
35 #include "libavutil/attributes.h"
36 #include "libavutil/emms.h"
37 #include "libavutil/imgutils.h"
38 #include "libavutil/avassert.h"
39 #include "libavutil/mem.h"
40 #include "libavutil/opt.h"
41 #include "avcodec.h"
42 #include "blockdsp.h"
43 #include "codec_internal.h"
44 #include "copy_block.h"
45 #include "decode.h"
46 #include "exif.h"
47 #include "hwaccel_internal.h"
48 #include "hwconfig.h"
49 #include "idctdsp.h"
50 #include "internal.h"
51 #include "jpegtables.h"
52 #include "mjpeg.h"
53 #include "mjpegdec.h"
54 #include "jpeglsdec.h"
55 #include "profiles.h"
56 #include "put_bits.h"
57
58
59 236 static int init_default_huffman_tables(MJpegDecodeContext *s)
60 {
61 static const struct {
62 int class;
63 int index;
64 const uint8_t *bits;
65 const uint8_t *values;
66 int length;
67 } ht[] = {
68 { 0, 0, ff_mjpeg_bits_dc_luminance,
69 ff_mjpeg_val_dc, 12 },
70 { 0, 1, ff_mjpeg_bits_dc_chrominance,
71 ff_mjpeg_val_dc, 12 },
72 { 1, 0, ff_mjpeg_bits_ac_luminance,
73 ff_mjpeg_val_ac_luminance, 162 },
74 { 1, 1, ff_mjpeg_bits_ac_chrominance,
75 ff_mjpeg_val_ac_chrominance, 162 },
76 { 2, 0, ff_mjpeg_bits_ac_luminance,
77 ff_mjpeg_val_ac_luminance, 162 },
78 { 2, 1, ff_mjpeg_bits_ac_chrominance,
79 ff_mjpeg_val_ac_chrominance, 162 },
80 };
81 int i, ret;
82
83
2/2
✓ Branch 0 taken 1416 times.
✓ Branch 1 taken 236 times.
1652 for (i = 0; i < FF_ARRAY_ELEMS(ht); i++) {
84 1416 ff_vlc_free(&s->vlcs[ht[i].class][ht[i].index]);
85 1416 ret = ff_mjpeg_build_vlc(&s->vlcs[ht[i].class][ht[i].index],
86 1416 ht[i].bits, ht[i].values,
87 1416 ht[i].class == 1, s->avctx);
88
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1416 times.
1416 if (ret < 0)
89 return ret;
90
91
2/2
✓ Branch 0 taken 944 times.
✓ Branch 1 taken 472 times.
1416 if (ht[i].class < 2) {
92 944 memcpy(s->raw_huffman_lengths[ht[i].class][ht[i].index],
93 944 ht[i].bits + 1, 16);
94 944 memcpy(s->raw_huffman_values[ht[i].class][ht[i].index],
95 944 ht[i].values, ht[i].length);
96 }
97 }
98
99 236 return 0;
100 }
101
102 11 static void parse_avid(MJpegDecodeContext *s, uint8_t *buf, int len)
103 {
104 11 s->buggy_avid = 1;
105
2/4
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✗ Branch 3 not taken.
11 if (len > 14 && buf[12] == 1) /* 1 - NTSC */
106 11 s->interlace_polarity = 1;
107
2/4
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 11 times.
11 if (len > 14 && buf[12] == 2) /* 2 - PAL */
108 s->interlace_polarity = 0;
109
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
11 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
110 av_log(s->avctx, AV_LOG_INFO, "AVID: len:%d %d\n", len, len > 14 ? buf[12] : -1);
111 11 }
112
113 354 static void init_idct(AVCodecContext *avctx)
114 {
115 354 MJpegDecodeContext *s = avctx->priv_data;
116
117 354 ff_idctdsp_init(&s->idsp, avctx);
118 354 ff_permute_scantable(s->permutated_scantable, ff_zigzag_direct,
119 354 s->idsp.idct_permutation);
120 354 }
121
122 236 av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)
123 {
124 236 MJpegDecodeContext *s = avctx->priv_data;
125 int ret;
126
127
2/2
✓ Branch 0 taken 234 times.
✓ Branch 1 taken 2 times.
236 if (!s->picture_ptr) {
128 234 s->picture = av_frame_alloc();
129
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 234 times.
234 if (!s->picture)
130 return AVERROR(ENOMEM);
131 234 s->picture_ptr = s->picture;
132 }
133
134 236 s->avctx = avctx;
135 236 ff_blockdsp_init(&s->bdsp);
136 236 init_idct(avctx);
137 236 s->buffer_size = 0;
138 236 s->buffer = NULL;
139 236 s->start_code = -1;
140 236 s->first_picture = 1;
141 236 s->got_picture = 0;
142 236 s->orig_height = avctx->coded_height;
143 236 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
144 236 avctx->colorspace = AVCOL_SPC_BT470BG;
145 236 s->hwaccel_pix_fmt = s->hwaccel_sw_pix_fmt = AV_PIX_FMT_NONE;
146
147
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 236 times.
236 if ((ret = init_default_huffman_tables(s)) < 0)
148 return ret;
149
150
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 236 times.
236 if (s->extern_huff) {
151 av_log(avctx, AV_LOG_INFO, "using external huffman table\n");
152 if ((ret = init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8)) < 0)
153 return ret;
154 if (ff_mjpeg_decode_dht(s)) {
155 av_log(avctx, AV_LOG_ERROR,
156 "error using external huffman table, switching back to internal\n");
157 if ((ret = init_default_huffman_tables(s)) < 0)
158 return ret;
159 }
160 }
161
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 236 times.
236 if (avctx->field_order == AV_FIELD_BB) { /* quicktime icefloe 019 */
162 s->interlace_polarity = 1; /* bottom field first */
163 av_log(avctx, AV_LOG_DEBUG, "bottom field first\n");
164
2/2
✓ Branch 0 taken 234 times.
✓ Branch 1 taken 2 times.
236 } else if (avctx->field_order == AV_FIELD_UNKNOWN) {
165
2/2
✓ Branch 0 taken 51 times.
✓ Branch 1 taken 183 times.
234 if (avctx->codec_tag == AV_RL32("MJPG"))
166 51 s->interlace_polarity = 1;
167 }
168
169
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 234 times.
236 if (avctx->codec_id == AV_CODEC_ID_SMVJPEG) {
170
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
2 if (avctx->extradata_size >= 4)
171 2 s->smv_frames_per_jpeg = AV_RL32(avctx->extradata);
172
173
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 if (s->smv_frames_per_jpeg <= 0) {
174 av_log(avctx, AV_LOG_ERROR, "Invalid number of frames per jpeg.\n");
175 return AVERROR_INVALIDDATA;
176 }
177
178 2 s->smv_frame = av_frame_alloc();
179
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 if (!s->smv_frame)
180 return AVERROR(ENOMEM);
181
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 232 times.
234 } else if (avctx->extradata_size > 8
182
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 && AV_RL32(avctx->extradata) == 0x2C
183 && AV_RL32(avctx->extradata+4) == 0x18) {
184 parse_avid(s, avctx->extradata, avctx->extradata_size);
185 }
186
187
2/2
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 225 times.
236 if (avctx->codec->id == AV_CODEC_ID_AMV)
188 11 s->flipped = 1;
189
190 236 return 0;
191 }
192
193
194 /* quantize tables */
195 2611 int ff_mjpeg_decode_dqt(MJpegDecodeContext *s)
196 {
197 int len, index, i;
198
199 2611 len = get_bits(&s->gb, 16) - 2;
200
201
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2611 times.
2611 if (8*len > get_bits_left(&s->gb)) {
202 av_log(s->avctx, AV_LOG_ERROR, "dqt: len %d is too large\n", len);
203 return AVERROR_INVALIDDATA;
204 }
205
206
2/2
✓ Branch 0 taken 3144 times.
✓ Branch 1 taken 2611 times.
5755 while (len >= 65) {
207 3144 int pr = get_bits(&s->gb, 4);
208
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3144 times.
3144 if (pr > 1) {
209 av_log(s->avctx, AV_LOG_ERROR, "dqt: invalid precision\n");
210 return AVERROR_INVALIDDATA;
211 }
212 3144 index = get_bits(&s->gb, 4);
213
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3144 times.
3144 if (index >= 4)
214 return -1;
215 3144 av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index);
216 /* read quant table */
217
2/2
✓ Branch 0 taken 201216 times.
✓ Branch 1 taken 3144 times.
204360 for (i = 0; i < 64; i++) {
218
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 201216 times.
201216 s->quant_matrixes[index][i] = get_bits(&s->gb, pr ? 16 : 8);
219
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 201216 times.
201216 if (s->quant_matrixes[index][i] == 0) {
220 int log_level = s->avctx->err_recognition & AV_EF_EXPLODE ? AV_LOG_ERROR : AV_LOG_WARNING;
221 av_log(s->avctx, log_level, "dqt: 0 quant value\n");
222 if (s->avctx->err_recognition & AV_EF_EXPLODE)
223 return AVERROR_INVALIDDATA;
224 }
225 }
226
227 // XXX FIXME fine-tune, and perhaps add dc too
228 3144 s->qscale[index] = FFMAX(s->quant_matrixes[index][1],
229 3144 s->quant_matrixes[index][8]) >> 1;
230 3144 av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n",
231 index, s->qscale[index]);
232 3144 len -= 1 + 64 * (1+pr);
233 }
234 2611 return 0;
235 }
236
237 /* decode huffman tables and build VLC decoders */
238 2627 int ff_mjpeg_decode_dht(MJpegDecodeContext *s)
239 {
240 int len, index, i, class, n, v;
241 uint8_t bits_table[17];
242 uint8_t val_table[256];
243 2627 int ret = 0;
244
245 2627 len = get_bits(&s->gb, 16) - 2;
246
247
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2627 times.
2627 if (8*len > get_bits_left(&s->gb)) {
248 av_log(s->avctx, AV_LOG_ERROR, "dht: len %d is too large\n", len);
249 return AVERROR_INVALIDDATA;
250 }
251
252
2/2
✓ Branch 0 taken 9243 times.
✓ Branch 1 taken 2627 times.
11870 while (len > 0) {
253
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9243 times.
9243 if (len < 17)
254 return AVERROR_INVALIDDATA;
255 9243 class = get_bits(&s->gb, 4);
256
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9243 times.
9243 if (class >= 2)
257 return AVERROR_INVALIDDATA;
258 9243 index = get_bits(&s->gb, 4);
259
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9243 times.
9243 if (index >= 4)
260 return AVERROR_INVALIDDATA;
261 9243 n = 0;
262
2/2
✓ Branch 0 taken 147888 times.
✓ Branch 1 taken 9243 times.
157131 for (i = 1; i <= 16; i++) {
263 147888 bits_table[i] = get_bits(&s->gb, 8);
264 147888 n += bits_table[i];
265 }
266 9243 len -= 17;
267
2/4
✓ Branch 0 taken 9243 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 9243 times.
9243 if (len < n || n > 256)
268 return AVERROR_INVALIDDATA;
269
270
2/2
✓ Branch 0 taken 557617 times.
✓ Branch 1 taken 9243 times.
566860 for (i = 0; i < n; i++) {
271 557617 v = get_bits(&s->gb, 8);
272 557617 val_table[i] = v;
273 }
274 9243 len -= n;
275
276 /* build VLC and flush previous vlc if present */
277 9243 ff_vlc_free(&s->vlcs[class][index]);
278 9243 av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
279 class, index, n);
280
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9243 times.
9243 if ((ret = ff_mjpeg_build_vlc(&s->vlcs[class][index], bits_table,
281 9243 val_table, class > 0, s->avctx)) < 0)
282 return ret;
283
284
2/2
✓ Branch 0 taken 4641 times.
✓ Branch 1 taken 4602 times.
9243 if (class > 0) {
285 4641 ff_vlc_free(&s->vlcs[2][index]);
286
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4641 times.
4641 if ((ret = ff_mjpeg_build_vlc(&s->vlcs[2][index], bits_table,
287 4641 val_table, 0, s->avctx)) < 0)
288 return ret;
289 }
290
291
2/2
✓ Branch 0 taken 147888 times.
✓ Branch 1 taken 9243 times.
157131 for (i = 0; i < 16; i++)
292 147888 s->raw_huffman_lengths[class][index][i] = bits_table[i + 1];
293
2/2
✓ Branch 0 taken 2366208 times.
✓ Branch 1 taken 9243 times.
2375451 for (i = 0; i < 256; i++)
294 2366208 s->raw_huffman_values[class][index][i] = val_table[i];
295 }
296 2627 return 0;
297 }
298
299 2634 int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
300 {
301 int len, nb_components, i, width, height, bits, ret, size_change;
302 unsigned pix_fmt_id;
303 2634 int h_count[MAX_COMPONENTS] = { 0 };
304 2634 int v_count[MAX_COMPONENTS] = { 0 };
305
306 2634 s->cur_scan = 0;
307 2634 memset(s->upscale_h, 0, sizeof(s->upscale_h));
308 2634 memset(s->upscale_v, 0, sizeof(s->upscale_v));
309
310 2634 len = get_bits(&s->gb, 16);
311 2634 bits = get_bits(&s->gb, 8);
312
313
2/4
✓ Branch 0 taken 2634 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2634 times.
2634 if (bits > 16 || bits < 1) {
314 av_log(s->avctx, AV_LOG_ERROR, "bits %d is invalid\n", bits);
315 return AVERROR_INVALIDDATA;
316 }
317
318
2/2
✓ Branch 0 taken 118 times.
✓ Branch 1 taken 2516 times.
2634 if (s->avctx->bits_per_raw_sample != bits) {
319
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 118 times.
118 av_log(s->avctx, s->avctx->bits_per_raw_sample > 0 ? AV_LOG_INFO : AV_LOG_DEBUG, "Changing bps from %d to %d\n", s->avctx->bits_per_raw_sample, bits);
320 118 s->avctx->bits_per_raw_sample = bits;
321 118 init_idct(s->avctx);
322 }
323
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2634 times.
2634 if (s->pegasus_rct)
324 bits = 9;
325
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 2634 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
2634 if (bits == 9 && !s->pegasus_rct)
326 s->rct = 1; // FIXME ugly
327
328
3/4
✓ Branch 0 taken 426 times.
✓ Branch 1 taken 2208 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 426 times.
2634 if(s->lossless && s->avctx->lowres){
329 av_log(s->avctx, AV_LOG_ERROR, "lowres is not possible with lossless jpeg\n");
330 return -1;
331 }
332
333 2634 height = get_bits(&s->gb, 16);
334 2634 width = get_bits(&s->gb, 16);
335
336 // HACK for odd_height.mov
337
4/6
✓ Branch 0 taken 30 times.
✓ Branch 1 taken 2604 times.
✓ Branch 2 taken 30 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 30 times.
2634 if (s->interlaced && s->width == width && s->height == height + 1)
338 height= s->height;
339
340 2634 av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
341
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2634 times.
2634 if (av_image_check_size(width, height, 0, s->avctx) < 0)
342 return AVERROR_INVALIDDATA;
343
344 // A valid frame requires at least 1 bit for DC + 1 bit for AC for each 8x8 block.
345
3/4
✓ Branch 0 taken 2632 times.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2632 times.
2634 if (s->buf_size && (width + 7) / 8 * ((height + 7) / 8) > s->buf_size * 4LL)
346 return AVERROR_INVALIDDATA;
347
348 2634 nb_components = get_bits(&s->gb, 8);
349
2/4
✓ Branch 0 taken 2634 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2634 times.
2634 if (nb_components <= 0 ||
350 nb_components > MAX_COMPONENTS)
351 return -1;
352
4/4
✓ Branch 0 taken 30 times.
✓ Branch 1 taken 2604 times.
✓ Branch 2 taken 19 times.
✓ Branch 3 taken 11 times.
2634 if (s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
353
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19 times.
19 if (nb_components != s->nb_components) {
354 av_log(s->avctx, AV_LOG_ERROR,
355 "nb_components changing in interlaced picture\n");
356 return AVERROR_INVALIDDATA;
357 }
358 }
359
3/6
✓ Branch 0 taken 221 times.
✓ Branch 1 taken 2413 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 221 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
2634 if (s->ls && !(bits <= 8 || nb_components == 1)) {
360 avpriv_report_missing_feature(s->avctx,
361 "JPEG-LS that is not <= 8 "
362 "bits/component or 16-bit gray");
363 return AVERROR_PATCHWELCOME;
364 }
365
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2634 times.
2634 if (len != 8 + 3 * nb_components) {
366 av_log(s->avctx, AV_LOG_ERROR, "decode_sof0: error, len(%d) mismatch %d components\n", len, nb_components);
367 return AVERROR_INVALIDDATA;
368 }
369
370 2634 s->nb_components = nb_components;
371 2634 s->h_max = 1;
372 2634 s->v_max = 1;
373
2/2
✓ Branch 0 taken 7866 times.
✓ Branch 1 taken 2634 times.
10500 for (i = 0; i < nb_components; i++) {
374 /* component id */
375 7866 s->component_id[i] = get_bits(&s->gb, 8);
376 7866 h_count[i] = get_bits(&s->gb, 4);
377 7866 v_count[i] = get_bits(&s->gb, 4);
378 /* compute hmax and vmax (only used in interleaved case) */
379
2/2
✓ Branch 0 taken 2191 times.
✓ Branch 1 taken 5675 times.
7866 if (h_count[i] > s->h_max)
380 2191 s->h_max = h_count[i];
381
2/2
✓ Branch 0 taken 2331 times.
✓ Branch 1 taken 5535 times.
7866 if (v_count[i] > s->v_max)
382 2331 s->v_max = v_count[i];
383 7866 s->quant_index[i] = get_bits(&s->gb, 8);
384
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7866 times.
7866 if (s->quant_index[i] >= 4) {
385 av_log(s->avctx, AV_LOG_ERROR, "quant_index is invalid\n");
386 return AVERROR_INVALIDDATA;
387 }
388
2/4
✓ Branch 0 taken 7866 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 7866 times.
7866 if (!h_count[i] || !v_count[i]) {
389 av_log(s->avctx, AV_LOG_ERROR,
390 "Invalid sampling factor in component %d %d:%d\n",
391 i, h_count[i], v_count[i]);
392 return AVERROR_INVALIDDATA;
393 }
394
395 7866 av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n",
396 i, h_count[i], v_count[i],
397 s->component_id[i], s->quant_index[i]);
398 }
399
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2634 times.
2634 if ( nb_components == 4
400 && s->component_id[0] == 'C'
401 && s->component_id[1] == 'M'
402 && s->component_id[2] == 'Y'
403 && s->component_id[3] == 'K')
404 s->adobe_transform = 0;
405
406
4/6
✓ Branch 0 taken 221 times.
✓ Branch 1 taken 2413 times.
✓ Branch 2 taken 221 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 221 times.
2634 if (s->ls && (s->h_max > 1 || s->v_max > 1)) {
407 avpriv_report_missing_feature(s->avctx, "Subsampling in JPEG-LS");
408 return AVERROR_PATCHWELCOME;
409 }
410
411
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2634 times.
2634 if (s->bayer) {
412 if (nb_components == 2) {
413 /* Bayer images embedded in DNGs can contain 2 interleaved components and the
414 width stored in their SOF3 markers is the width of each one. We only output
415 a single component, therefore we need to adjust the output image width. We
416 handle the deinterleaving (but not the debayering) in this file. */
417 width *= 2;
418 }
419 /* They can also contain 1 component, which is double the width and half the height
420 of the final image (rows are interleaved). We don't handle the decoding in this
421 file, but leave that to the TIFF/DNG decoder. */
422 }
423
424 /* if different size, realloc/alloc picture */
425
5/6
✓ Branch 0 taken 2242 times.
✓ Branch 1 taken 392 times.
✓ Branch 2 taken 2236 times.
✓ Branch 3 taken 6 times.
✓ Branch 4 taken 2236 times.
✗ Branch 5 not taken.
2634 if (width != s->width || height != s->height || bits != s->bits ||
426
1/2
✓ Branch 0 taken 2236 times.
✗ Branch 1 not taken.
2236 memcmp(s->h_count, h_count, sizeof(h_count)) ||
427
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2236 times.
2236 memcmp(s->v_count, v_count, sizeof(v_count))) {
428 398 size_change = 1;
429
430 398 s->width = width;
431 398 s->height = height;
432 398 s->bits = bits;
433 398 memcpy(s->h_count, h_count, sizeof(h_count));
434 398 memcpy(s->v_count, v_count, sizeof(v_count));
435 398 s->interlaced = 0;
436 398 s->got_picture = 0;
437
438 /* test interlaced mode */
439
2/2
✓ Branch 0 taken 195 times.
✓ Branch 1 taken 203 times.
398 if (s->first_picture &&
440
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 195 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
195 (s->multiscope != 2 || s->avctx->pkt_timebase.den >= 25 * s->avctx->pkt_timebase.num) &&
441
2/2
✓ Branch 0 taken 145 times.
✓ Branch 1 taken 50 times.
195 s->orig_height != 0 &&
442
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 136 times.
145 s->height < ((s->orig_height * 3) / 4)) {
443 9 s->interlaced = 1;
444 9 s->bottom_field = s->interlace_polarity;
445 9 s->picture_ptr->flags |= AV_FRAME_FLAG_INTERLACED;
446
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 2 times.
9 s->picture_ptr->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST * !s->interlace_polarity;
447 9 height *= 2;
448 }
449
450 398 ret = ff_set_dimensions(s->avctx, width, height);
451
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 398 times.
398 if (ret < 0)
452 return ret;
453
454
2/2
✓ Branch 0 taken 396 times.
✓ Branch 1 taken 2 times.
398 if (s->avctx->codec_id != AV_CODEC_ID_SMVJPEG &&
455
1/2
✓ Branch 0 taken 396 times.
✗ Branch 1 not taken.
396 (s->avctx->codec_tag == MKTAG('A', 'V', 'R', 'n') ||
456
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 394 times.
396 s->avctx->codec_tag == MKTAG('A', 'V', 'D', 'J')) &&
457
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
2 s->orig_height < height)
458 2 s->avctx->height = AV_CEIL_RSHIFT(s->orig_height, s->avctx->lowres);
459
460 398 s->first_picture = 0;
461 } else {
462 2236 size_change = 0;
463 }
464
465
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 2631 times.
2634 if (s->avctx->codec_id == AV_CODEC_ID_SMVJPEG) {
466 3 s->avctx->height = s->avctx->coded_height / s->smv_frames_per_jpeg;
467
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
3 if (s->avctx->height <= 0)
468 return AVERROR_INVALIDDATA;
469 }
470
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 2634 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
2634 if (s->bayer && s->progressive) {
471 avpriv_request_sample(s->avctx, "progressively coded bayer picture");
472 return AVERROR_INVALIDDATA;
473 }
474
475
5/6
✓ Branch 0 taken 27 times.
✓ Branch 1 taken 2607 times.
✓ Branch 2 taken 19 times.
✓ Branch 3 taken 8 times.
✓ Branch 4 taken 19 times.
✗ Branch 5 not taken.
2634 if (s->got_picture && s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
476
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19 times.
19 if (s->progressive) {
477 avpriv_request_sample(s->avctx, "progressively coded interlaced picture");
478 return AVERROR_INVALIDDATA;
479 }
480 } else {
481
9/10
✓ Branch 0 taken 284 times.
✓ Branch 1 taken 2331 times.
✓ Branch 2 taken 235 times.
✓ Branch 3 taken 49 times.
✓ Branch 4 taken 221 times.
✓ Branch 5 taken 14 times.
✓ Branch 6 taken 16 times.
✓ Branch 7 taken 205 times.
✗ Branch 8 not taken.
✓ Branch 9 taken 16 times.
2615 if (s->v_max == 1 && s->h_max == 1 && s->lossless==1 && (nb_components==3 || nb_components==4))
482 205 s->rgb = 1;
483
2/2
✓ Branch 0 taken 2189 times.
✓ Branch 1 taken 221 times.
2410 else if (!s->lossless)
484 2189 s->rgb = 0;
485 /* XXX: not complete test ! */
486 2615 pix_fmt_id = ((unsigned)s->h_count[0] << 28) | (s->v_count[0] << 24) |
487 2615 (s->h_count[1] << 20) | (s->v_count[1] << 16) |
488 2615 (s->h_count[2] << 12) | (s->v_count[2] << 8) |
489 2615 (s->h_count[3] << 4) | s->v_count[3];
490 2615 av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);
491 /* NOTE we do not allocate pictures large enough for the possible
492 * padding of h/v_count being 4 */
493
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2615 times.
2615 if (!(pix_fmt_id & 0xD0D0D0D0))
494 pix_fmt_id -= (pix_fmt_id & 0xF0F0F0F0) >> 1;
495
2/2
✓ Branch 0 taken 412 times.
✓ Branch 1 taken 2203 times.
2615 if (!(pix_fmt_id & 0x0D0D0D0D))
496 412 pix_fmt_id -= (pix_fmt_id & 0x0F0F0F0F) >> 1;
497
498
2/2
✓ Branch 0 taken 20920 times.
✓ Branch 1 taken 2615 times.
23535 for (i = 0; i < 8; i++) {
499 20920 int j = 6 + (i&1) - (i&6);
500 20920 int is = (pix_fmt_id >> (4*i)) & 0xF;
501 20920 int js = (pix_fmt_id >> (4*j)) & 0xF;
502
503
7/8
✓ Branch 0 taken 11517 times.
✓ Branch 1 taken 9403 times.
✓ Branch 2 taken 11509 times.
✓ Branch 3 taken 8 times.
✓ Branch 4 taken 11509 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1143 times.
✓ Branch 7 taken 10366 times.
20920 if (is == 1 && js != 2 && (i < 2 || i > 5))
504 1143 js = (pix_fmt_id >> ( 8 + 4*(i&1))) & 0xF;
505
7/8
✓ Branch 0 taken 11517 times.
✓ Branch 1 taken 9403 times.
✓ Branch 2 taken 11507 times.
✓ Branch 3 taken 10 times.
✓ Branch 4 taken 11507 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1141 times.
✓ Branch 7 taken 10366 times.
20920 if (is == 1 && js != 2 && (i < 2 || i > 5))
506 1141 js = (pix_fmt_id >> (16 + 4*(i&1))) & 0xF;
507
508
4/4
✓ Branch 0 taken 11517 times.
✓ Branch 1 taken 9403 times.
✓ Branch 2 taken 10 times.
✓ Branch 3 taken 11507 times.
20920 if (is == 1 && js == 2) {
509
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 2 times.
10 if (i & 1) s->upscale_h[j/2] = 1;
510 2 else s->upscale_v[j/2] = 1;
511 }
512 }
513
514
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2615 times.
2615 if (s->bayer) {
515 if (pix_fmt_id != 0x11110000 && pix_fmt_id != 0x11000000)
516 goto unk_pixfmt;
517 }
518
519
9/15
✗ Branch 0 not taken.
✓ Branch 1 taken 425 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 4 times.
✓ Branch 6 taken 18 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 243 times.
✓ Branch 9 taken 2 times.
✓ Branch 10 taken 2 times.
✓ Branch 11 taken 2 times.
✓ Branch 12 taken 1917 times.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
2615 switch (pix_fmt_id) {
520 case 0x11110000: /* for bayer-encoded huffman lossless JPEGs embedded in DNGs */
521 if (!s->bayer)
522 goto unk_pixfmt;
523 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16LE;
524 break;
525 425 case 0x11111100:
526
2/2
✓ Branch 0 taken 205 times.
✓ Branch 1 taken 220 times.
425 if (s->rgb)
527
1/2
✓ Branch 0 taken 205 times.
✗ Branch 1 not taken.
205 s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_BGR48;
528 else {
529
2/2
✓ Branch 0 taken 216 times.
✓ Branch 1 taken 4 times.
220 if ( s->adobe_transform == 0
530
1/6
✗ Branch 0 not taken.
✓ Branch 1 taken 216 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
216 || s->component_id[0] == 'R' && s->component_id[1] == 'G' && s->component_id[2] == 'B') {
531
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
4 s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_GBRP : AV_PIX_FMT_GBRP16;
532 } else {
533
2/4
✓ Branch 0 taken 216 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 216 times.
216 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
534 else s->avctx->pix_fmt = AV_PIX_FMT_YUV444P16;
535
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 216 times.
216 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
536 }
537 }
538
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 425 times.
425 av_assert0(s->nb_components == 3);
539 425 break;
540 case 0x11111111:
541 if (s->rgb)
542 s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_ABGR : AV_PIX_FMT_RGBA64;
543 else {
544 if (s->adobe_transform == 0 && s->bits <= 8) {
545 s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;
546 } else {
547 s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_YUVA444P : AV_PIX_FMT_YUVA444P16;
548 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
549 }
550 }
551 av_assert0(s->nb_components == 4);
552 break;
553 2 case 0x11412100:
554
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 if (s->bits > 8)
555 goto unk_pixfmt;
556
3/6
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
2 if (s->component_id[0] == 'R' && s->component_id[1] == 'G' && s->component_id[2] == 'B') {
557 2 s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
558 2 s->upscale_h[0] = 4;
559 2 s->upscale_h[1] = 0;
560 2 s->upscale_h[2] = 1;
561 } else {
562 goto unk_pixfmt;
563 }
564 2 break;
565 case 0x22111122:
566 case 0x22111111:
567 if (s->adobe_transform == 0 && s->bits <= 8) {
568 s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;
569 s->upscale_v[1] = s->upscale_v[2] = 1;
570 s->upscale_h[1] = s->upscale_h[2] = 1;
571 } else if (s->adobe_transform == 2 && s->bits <= 8) {
572 s->avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
573 s->upscale_v[1] = s->upscale_v[2] = 1;
574 s->upscale_h[1] = s->upscale_h[2] = 1;
575 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
576 } else {
577 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
578 else s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P16;
579 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
580 }
581 av_assert0(s->nb_components == 4);
582 break;
583 4 case 0x12121100:
584 case 0x22122100:
585 case 0x21211100:
586 case 0x21112100:
587 case 0x22211200:
588 case 0x22221100:
589 case 0x22112200:
590 case 0x11222200:
591
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
4 if (s->bits > 8)
592 goto unk_pixfmt;
593
3/4
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 2 times.
4 if (s->adobe_transform == 0 || s->component_id[0] == 'R' &&
594
2/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
2 s->component_id[1] == 'G' && s->component_id[2] == 'B') {
595 2 s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
596 } else {
597
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
598
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
599 }
600 4 break;
601 18 case 0x11000000:
602 case 0x13000000:
603 case 0x14000000:
604 case 0x31000000:
605 case 0x33000000:
606 case 0x34000000:
607 case 0x41000000:
608 case 0x43000000:
609 case 0x44000000:
610
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 2 times.
18 if(s->bits <= 8)
611
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 8 times.
16 s->avctx->pix_fmt = s->force_pal8 ? AV_PIX_FMT_PAL8 : AV_PIX_FMT_GRAY8;
612 else
613 2 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
614 18 break;
615 case 0x12111100:
616 case 0x14121200:
617 case 0x14111100:
618 case 0x22211100:
619 case 0x22112100:
620 if (s->component_id[0] == 'R' && s->component_id[1] == 'G' && s->component_id[2] == 'B') {
621 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
622 else
623 goto unk_pixfmt;
624 s->upscale_v[1] = s->upscale_v[2] = 1;
625 } else {
626 if (pix_fmt_id == 0x14111100)
627 s->upscale_v[1] = s->upscale_v[2] = 1;
628 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV440P : AV_PIX_FMT_YUVJ440P;
629 else
630 goto unk_pixfmt;
631 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
632 }
633 break;
634 243 case 0x21111100:
635
1/6
✗ Branch 0 not taken.
✓ Branch 1 taken 243 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
243 if (s->component_id[0] == 'R' && s->component_id[1] == 'G' && s->component_id[2] == 'B') {
636 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
637 else
638 goto unk_pixfmt;
639 s->upscale_h[1] = s->upscale_h[2] = 1;
640 } else {
641
2/4
✓ Branch 0 taken 243 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 243 times.
243 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
642 else s->avctx->pix_fmt = AV_PIX_FMT_YUV422P16;
643
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 243 times.
243 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
644 }
645 243 break;
646 2 case 0x11311100:
647
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 if (s->bits > 8)
648 goto unk_pixfmt;
649
3/6
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
2 if (s->component_id[0] == 'R' && s->component_id[1] == 'G' && s->component_id[2] == 'B')
650 2 s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
651 else
652 goto unk_pixfmt;
653 2 s->upscale_h[0] = s->upscale_h[2] = 2;
654 2 break;
655 2 case 0x31111100:
656
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 if (s->bits > 8)
657 goto unk_pixfmt;
658
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
659
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
660 2 s->upscale_h[1] = s->upscale_h[2] = 2;
661 2 break;
662 2 case 0x22121100:
663 case 0x22111200:
664 case 0x41211100:
665
2/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
2 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
666 else
667 goto unk_pixfmt;
668
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
669 2 break;
670 1917 case 0x22111100:
671 case 0x23111100:
672 case 0x42111100:
673 case 0x24111100:
674
3/4
✓ Branch 0 taken 1917 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 205 times.
✓ Branch 3 taken 1712 times.
1917 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUVJ420P;
675 else s->avctx->pix_fmt = AV_PIX_FMT_YUV420P16;
676
2/2
✓ Branch 0 taken 205 times.
✓ Branch 1 taken 1712 times.
1917 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
677
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1917 times.
1917 if (pix_fmt_id == 0x42111100) {
678 if (s->bits > 8)
679 goto unk_pixfmt;
680 s->upscale_h[1] = s->upscale_h[2] = 1;
681
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1917 times.
1917 } else if (pix_fmt_id == 0x24111100) {
682 if (s->bits > 8)
683 goto unk_pixfmt;
684 s->upscale_v[1] = s->upscale_v[2] = 1;
685
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1917 times.
1917 } else if (pix_fmt_id == 0x23111100) {
686 if (s->bits > 8)
687 goto unk_pixfmt;
688 s->upscale_v[1] = s->upscale_v[2] = 2;
689 }
690 1917 break;
691 case 0x41111100:
692 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV411P : AV_PIX_FMT_YUVJ411P;
693 else
694 goto unk_pixfmt;
695 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
696 break;
697 default:
698 unk_pixfmt:
699 avpriv_report_missing_feature(s->avctx, "Pixel format 0x%x bits:%d", pix_fmt_id, s->bits);
700 memset(s->upscale_h, 0, sizeof(s->upscale_h));
701 memset(s->upscale_v, 0, sizeof(s->upscale_v));
702 return AVERROR_PATCHWELCOME;
703 }
704
4/6
✓ Branch 0 taken 2603 times.
✓ Branch 1 taken 12 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2603 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 12 times.
2615 if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->avctx->lowres) {
705 avpriv_report_missing_feature(s->avctx, "Lowres for weird subsampling");
706 return AVERROR_PATCHWELCOME;
707 }
708
2/2
✓ Branch 0 taken 221 times.
✓ Branch 1 taken 2394 times.
2615 if (s->ls) {
709 221 memset(s->upscale_h, 0, sizeof(s->upscale_h));
710 221 memset(s->upscale_v, 0, sizeof(s->upscale_v));
711
2/2
✓ Branch 0 taken 205 times.
✓ Branch 1 taken 16 times.
221 if (s->nb_components == 3) {
712 205 s->avctx->pix_fmt = AV_PIX_FMT_RGB24;
713
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
16 } else if (s->nb_components != 1) {
714 av_log(s->avctx, AV_LOG_ERROR, "Unsupported number of components %d\n", s->nb_components);
715 return AVERROR_PATCHWELCOME;
716
4/6
✓ Branch 0 taken 16 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
✓ Branch 3 taken 8 times.
✓ Branch 4 taken 8 times.
✗ Branch 5 not taken.
16 } else if ((s->palette_index || s->force_pal8) && s->bits <= 8)
717 8 s->avctx->pix_fmt = AV_PIX_FMT_PAL8;
718
1/2
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
8 else if (s->bits <= 8)
719 8 s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
720 else
721 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
722 }
723
724 2615 s->pix_desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
725
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2615 times.
2615 if (!s->pix_desc) {
726 av_log(s->avctx, AV_LOG_ERROR, "Could not get a pixel format descriptor.\n");
727 return AVERROR_BUG;
728 }
729
730
4/4
✓ Branch 0 taken 2412 times.
✓ Branch 1 taken 203 times.
✓ Branch 2 taken 2209 times.
✓ Branch 3 taken 203 times.
2615 if (s->avctx->pix_fmt == s->hwaccel_sw_pix_fmt && !size_change) {
731 2209 s->avctx->pix_fmt = s->hwaccel_pix_fmt;
732 } else {
733 406 enum AVPixelFormat pix_fmts[] = {
734 #if CONFIG_MJPEG_NVDEC_HWACCEL
735 AV_PIX_FMT_CUDA,
736 #endif
737 #if CONFIG_MJPEG_VAAPI_HWACCEL
738 AV_PIX_FMT_VAAPI,
739 #endif
740 406 s->avctx->pix_fmt,
741 AV_PIX_FMT_NONE,
742 };
743 406 s->hwaccel_pix_fmt = ff_get_format(s->avctx, pix_fmts);
744
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 406 times.
406 if (s->hwaccel_pix_fmt < 0)
745 return AVERROR(EINVAL);
746
747 406 s->hwaccel_sw_pix_fmt = s->avctx->pix_fmt;
748 406 s->avctx->pix_fmt = s->hwaccel_pix_fmt;
749 }
750
751
2/2
✓ Branch 0 taken 93 times.
✓ Branch 1 taken 2522 times.
2615 if (s->avctx->skip_frame == AVDISCARD_ALL) {
752 93 s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
753 93 s->picture_ptr->flags |= AV_FRAME_FLAG_KEY;
754 93 s->got_picture = 1;
755 93 return 0;
756 }
757
758 2522 av_frame_unref(s->picture_ptr);
759
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2522 times.
2522 if (ff_get_buffer(s->avctx, s->picture_ptr, AV_GET_BUFFER_FLAG_REF) < 0)
760 return -1;
761 2522 s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
762 2522 s->picture_ptr->flags |= AV_FRAME_FLAG_KEY;
763 2522 s->got_picture = 1;
764
765 // Lets clear the palette to avoid leaving uninitialized values in it
766
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 2514 times.
2522 if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
767 8 memset(s->picture_ptr->data[1], 0, 1024);
768
769
2/2
✓ Branch 0 taken 10088 times.
✓ Branch 1 taken 2522 times.
12610 for (i = 0; i < 4; i++)
770 10088 s->linesize[i] = s->picture_ptr->linesize[i] << s->interlaced;
771
772 ff_dlog(s->avctx, "%d %d %d %d %d %d\n",
773 s->width, s->height, s->linesize[0], s->linesize[1],
774 s->interlaced, s->avctx->height);
775
776 }
777
778
3/6
✓ Branch 0 taken 205 times.
✓ Branch 1 taken 2336 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 205 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
2541 if ((s->rgb && !s->lossless && !s->ls) ||
779
5/6
✓ Branch 0 taken 2336 times.
✓ Branch 1 taken 205 times.
✓ Branch 2 taken 16 times.
✓ Branch 3 taken 2320 times.
✓ Branch 4 taken 16 times.
✗ Branch 5 not taken.
2541 (!s->rgb && s->ls && s->nb_components > 1) ||
780
3/4
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 2533 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 8 times.
2541 (s->avctx->pix_fmt == AV_PIX_FMT_PAL8 && !s->ls)
781 ) {
782 av_log(s->avctx, AV_LOG_ERROR, "Unsupported coding and pixel format combination\n");
783 return AVERROR_PATCHWELCOME;
784 }
785
786 /* totally blank picture as progressive JPEG will only add details to it */
787
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 2534 times.
2541 if (s->progressive) {
788 7 int bw = (width + s->h_max * 8 - 1) / (s->h_max * 8);
789 7 int bh = (height + s->v_max * 8 - 1) / (s->v_max * 8);
790
2/2
✓ Branch 0 taken 21 times.
✓ Branch 1 taken 7 times.
28 for (i = 0; i < s->nb_components; i++) {
791 21 int size = bw * bh * s->h_count[i] * s->v_count[i];
792 21 av_freep(&s->blocks[i]);
793 21 av_freep(&s->last_nnz[i]);
794 21 s->blocks[i] = av_calloc(size, sizeof(**s->blocks));
795 21 s->last_nnz[i] = av_calloc(size, sizeof(**s->last_nnz));
796
2/4
✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 21 times.
21 if (!s->blocks[i] || !s->last_nnz[i])
797 return AVERROR(ENOMEM);
798 21 s->block_stride[i] = bw * s->h_count[i];
799 }
800 7 memset(s->coefs_finished, 0, sizeof(s->coefs_finished));
801 }
802
803
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2541 times.
2541 if (s->avctx->hwaccel) {
804 const FFHWAccel *hwaccel = ffhwaccel(s->avctx->hwaccel);
805 s->hwaccel_picture_private =
806 av_mallocz(hwaccel->frame_priv_data_size);
807 if (!s->hwaccel_picture_private)
808 return AVERROR(ENOMEM);
809
810 ret = hwaccel->start_frame(s->avctx, NULL, s->raw_image_buffer,
811 s->raw_image_buffer_size);
812 if (ret < 0)
813 return ret;
814 }
815
816 2541 return 0;
817 }
818
819 26931518 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index, int *val)
820 {
821 int code;
822 26931518 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
823
2/4
✓ Branch 0 taken 26931518 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 26931518 times.
26931518 if (code < 0 || code > 16) {
824 av_log(s->avctx, AV_LOG_ERROR,
825 "mjpeg_decode_dc: bad vlc: %d\n", dc_index);
826 return AVERROR_INVALIDDATA;
827 }
828
829
2/2
✓ Branch 0 taken 23865139 times.
✓ Branch 1 taken 3066379 times.
26931518 *val = code ? get_xbits(&s->gb, code) : 0;
830 26931518 return 0;
831 }
832
833 /* decode block and dequantize */
834 4034342 static int decode_block(MJpegDecodeContext *s, int16_t *block, int component,
835 int dc_index, int ac_index, uint16_t *quant_matrix)
836 {
837 int code, i, j, level, val;
838
839 /* DC coef */
840 4034342 int ret = mjpeg_decode_dc(s, dc_index, &val);
841
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4034342 times.
4034342 if (ret < 0)
842 return ret;
843
844 4034342 val = val * (unsigned)quant_matrix[0] + s->last_dc[component];
845 4034342 s->last_dc[component] = val;
846 4034342 block[0] = av_clip_int16(val);
847 /* AC coefs */
848 4034342 i = 0;
849 4034342 {OPEN_READER(re, &s->gb);
850 do {
851 37963179 UPDATE_CACHE(re, &s->gb);
852
2/2
✓ Branch 1 taken 553914 times.
✓ Branch 2 taken 37409265 times.
37963179 GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2);
853
854 37963179 i += ((unsigned)code) >> 4;
855 37963179 code &= 0xf;
856
2/2
✓ Branch 0 taken 33973130 times.
✓ Branch 1 taken 3990049 times.
37963179 if (code) {
857 // GET_VLC updates the cache if parsing reaches the second stage.
858 // So we have at least MIN_CACHE_BITS - 9 > 15 bits left here
859 // and don't need to refill the cache.
860 {
861 33973130 int cache = GET_CACHE(re, &s->gb);
862 33973130 int sign = (~cache) >> 31;
863 33973130 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
864 }
865
866 33973130 LAST_SKIP_BITS(re, &s->gb, code);
867
868
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 33973130 times.
33973130 if (i > 63) {
869 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
870 return AVERROR_INVALIDDATA;
871 }
872 33973130 j = s->permutated_scantable[i];
873 33973130 block[j] = level * quant_matrix[i];
874 }
875
2/2
✓ Branch 0 taken 33928837 times.
✓ Branch 1 taken 4034342 times.
37963179 } while (i < 63);
876 4034342 CLOSE_READER(re, &s->gb);}
877
878 4034342 return 0;
879 }
880
881 876 static int decode_dc_progressive(MJpegDecodeContext *s, int16_t *block,
882 int component, int dc_index,
883 uint16_t *quant_matrix, int Al)
884 {
885 unsigned val;
886 876 s->bdsp.clear_block(block);
887 876 int ret = mjpeg_decode_dc(s, dc_index, &val);
888
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 876 times.
876 if (ret < 0)
889 return ret;
890
891 876 val = (val * (quant_matrix[0] << Al)) + s->last_dc[component];
892 876 s->last_dc[component] = val;
893 876 block[0] = val;
894 876 return 0;
895 }
896
897 /* decode block and dequantize - progressive JPEG version */
898 1336 static int decode_block_progressive(MJpegDecodeContext *s, int16_t *block,
899 uint8_t *last_nnz, int ac_index,
900 uint16_t *quant_matrix,
901 int ss, int se, int Al, int *EOBRUN)
902 {
903 int code, i, j, val, run;
904 unsigned level;
905
906
2/2
✓ Branch 0 taken 340 times.
✓ Branch 1 taken 996 times.
1336 if (*EOBRUN) {
907 340 (*EOBRUN)--;
908 340 return 0;
909 }
910
911 {
912 996 OPEN_READER(re, &s->gb);
913 996 for (i = ss; ; i++) {
914 5910 UPDATE_CACHE(re, &s->gb);
915
2/2
✓ Branch 1 taken 15 times.
✓ Branch 2 taken 6891 times.
6906 GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
916
917 6906 run = ((unsigned) code) >> 4;
918 6906 code &= 0xF;
919
2/2
✓ Branch 0 taken 6037 times.
✓ Branch 1 taken 869 times.
6906 if (code) {
920 6037 i += run;
921
922 {
923 6037 int cache = GET_CACHE(re, &s->gb);
924 6037 int sign = (~cache) >> 31;
925 6037 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
926 }
927
928 6037 LAST_SKIP_BITS(re, &s->gb, code);
929
930
2/2
✓ Branch 0 taken 139 times.
✓ Branch 1 taken 5898 times.
6037 if (i >= se) {
931
1/2
✓ Branch 0 taken 139 times.
✗ Branch 1 not taken.
139 if (i == se) {
932 139 j = s->permutated_scantable[se];
933 139 block[j] = level * (quant_matrix[se] << Al);
934 139 break;
935 }
936 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
937 return AVERROR_INVALIDDATA;
938 }
939 5898 j = s->permutated_scantable[i];
940 5898 block[j] = level * (quant_matrix[i] << Al);
941 } else {
942
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 857 times.
869 if (run == 0xF) {// ZRL - skip 15 coefficients
943 12 i += 15;
944
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
12 if (i >= se) {
945 av_log(s->avctx, AV_LOG_ERROR, "ZRL overflow: %d\n", i);
946 return AVERROR_INVALIDDATA;
947 }
948 } else {
949 857 val = (1 << run);
950
2/2
✓ Branch 0 taken 149 times.
✓ Branch 1 taken 708 times.
857 if (run) {
951 // Given that GET_VLC reloads internally, we always
952 // have at least 16 bits in the cache here.
953 149 val += NEG_USR32(GET_CACHE(re, &s->gb), run);
954 149 LAST_SKIP_BITS(re, &s->gb, run);
955 }
956 857 *EOBRUN = val - 1;
957 857 break;
958 }
959 }
960 }
961 996 CLOSE_READER(re, &s->gb);
962 }
963
964
1/2
✓ Branch 0 taken 996 times.
✗ Branch 1 not taken.
996 if (i > *last_nnz)
965 996 *last_nnz = i;
966
967 996 return 0;
968 }
969
970 #define REFINE_BIT(j) { \
971 UPDATE_CACHE(re, &s->gb); \
972 sign = block[j] >> 15; \
973 block[j] += SHOW_UBITS(re, &s->gb, 1) * \
974 ((quant_matrix[i] ^ sign) - sign) << Al; \
975 LAST_SKIP_BITS(re, &s->gb, 1); \
976 }
977
978 #define ZERO_RUN \
979 for (; ; i++) { \
980 if (i > last) { \
981 i += run; \
982 if (i > se) { \
983 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \
984 return -1; \
985 } \
986 break; \
987 } \
988 j = s->permutated_scantable[i]; \
989 if (block[j]) \
990 REFINE_BIT(j) \
991 else if (run-- == 0) \
992 break; \
993 }
994
995 /* decode block and dequantize - progressive JPEG refinement pass */
996 1080 static int decode_block_refinement(MJpegDecodeContext *s, int16_t *block,
997 uint8_t *last_nnz,
998 int ac_index, uint16_t *quant_matrix,
999 int ss, int se, int Al, int *EOBRUN)
1000 {
1001 1080 int code, i = ss, j, sign, val, run;
1002 1080 int last = FFMIN(se, *last_nnz);
1003
1004 1080 OPEN_READER(re, &s->gb);
1005
2/2
✓ Branch 0 taken 120 times.
✓ Branch 1 taken 960 times.
1080 if (*EOBRUN) {
1006 120 (*EOBRUN)--;
1007 } else {
1008 9339 for (; ; i++) {
1009 9339 UPDATE_CACHE(re, &s->gb);
1010
2/2
✓ Branch 1 taken 13 times.
✓ Branch 2 taken 10286 times.
10299 GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
1011
1012
2/2
✓ Branch 0 taken 9342 times.
✓ Branch 1 taken 957 times.
10299 if (code & 0xF) {
1013 9342 run = ((unsigned) code) >> 4;
1014 9342 val = SHOW_UBITS(re, &s->gb, 1);
1015 9342 LAST_SKIP_BITS(re, &s->gb, 1);
1016
7/8
✓ Branch 0 taken 3889 times.
✓ Branch 1 taken 21930 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 3889 times.
✓ Branch 5 taken 9094 times.
✓ Branch 6 taken 12836 times.
✓ Branch 8 taken 5453 times.
✓ Branch 9 taken 7383 times.
25819 ZERO_RUN;
1017 9342 j = s->permutated_scantable[i];
1018 9342 val--;
1019 9342 block[j] = ((quant_matrix[i] << Al) ^ val) - val;
1020
2/2
✓ Branch 0 taken 63 times.
✓ Branch 1 taken 9279 times.
9342 if (i == se) {
1021
1/2
✓ Branch 0 taken 63 times.
✗ Branch 1 not taken.
63 if (i > *last_nnz)
1022 63 *last_nnz = i;
1023 63 CLOSE_READER(re, &s->gb);
1024 63 return 0;
1025 }
1026 } else {
1027 957 run = ((unsigned) code) >> 4;
1028
2/2
✓ Branch 0 taken 60 times.
✓ Branch 1 taken 897 times.
957 if (run == 0xF) {
1029
7/8
✓ Branch 0 taken 42 times.
✓ Branch 1 taken 621 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 42 times.
✓ Branch 5 taken 177 times.
✓ Branch 6 taken 444 times.
✓ Branch 8 taken 18 times.
✓ Branch 9 taken 426 times.
663 ZERO_RUN;
1030 } else {
1031 897 val = run;
1032 897 run = (1 << run);
1033
2/2
✓ Branch 0 taken 23 times.
✓ Branch 1 taken 874 times.
897 if (val) {
1034 // Given that GET_VLC reloads internally, we always
1035 // have at least 16 bits in the cache here.
1036 23 run += SHOW_UBITS(re, &s->gb, val);
1037 23 LAST_SKIP_BITS(re, &s->gb, val);
1038 }
1039 897 *EOBRUN = run - 1;
1040 897 break;
1041 }
1042 }
1043 }
1044
1045
2/2
✓ Branch 0 taken 804 times.
✓ Branch 1 taken 93 times.
897 if (i > *last_nnz)
1046 804 *last_nnz = i;
1047 }
1048
1049
2/2
✓ Branch 0 taken 879 times.
✓ Branch 1 taken 1017 times.
1896 for (; i <= last; i++) {
1050 879 j = s->permutated_scantable[i];
1051
2/2
✓ Branch 0 taken 188 times.
✓ Branch 1 taken 691 times.
879 if (block[j])
1052 188 REFINE_BIT(j)
1053 }
1054 1017 CLOSE_READER(re, &s->gb);
1055
1056 1017 return 0;
1057 }
1058 #undef REFINE_BIT
1059 #undef ZERO_RUN
1060
1061 810549 static int handle_rstn(MJpegDecodeContext *s, int nb_components)
1062 {
1063 int i;
1064 810549 int reset = 0;
1065
1066
2/2
✓ Branch 0 taken 59850 times.
✓ Branch 1 taken 750699 times.
810549 if (s->restart_interval) {
1067 59850 s->restart_count--;
1068
3/4
✓ Branch 0 taken 2850 times.
✓ Branch 1 taken 57000 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2850 times.
59850 if(s->restart_count == 0 && s->avctx->codec_id == AV_CODEC_ID_THP){
1069 align_get_bits(&s->gb);
1070 for (i = 0; i < nb_components; i++) /* reset dc */
1071 s->last_dc[i] = (4 << s->bits);
1072 }
1073
1074 59850 i = 8 + ((-get_bits_count(&s->gb)) & 7);
1075 /* skip RSTn */
1076
2/2
✓ Branch 0 taken 2850 times.
✓ Branch 1 taken 57000 times.
59850 if (s->restart_count == 0) {
1077
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2850 times.
2850 if( show_bits(&s->gb, i) == (1 << i) - 1
1078 || show_bits(&s->gb, i) == 0xFF) {
1079 2850 int pos = get_bits_count(&s->gb);
1080 2850 align_get_bits(&s->gb);
1081
4/4
✓ Branch 1 taken 5500 times.
✓ Branch 2 taken 200 times.
✓ Branch 4 taken 2850 times.
✓ Branch 5 taken 2650 times.
5700 while (get_bits_left(&s->gb) >= 8 && show_bits(&s->gb, 8) == 0xFF)
1082 2850 skip_bits(&s->gb, 8);
1083
3/4
✓ Branch 1 taken 2650 times.
✓ Branch 2 taken 200 times.
✓ Branch 4 taken 2650 times.
✗ Branch 5 not taken.
2850 if (get_bits_left(&s->gb) >= 8 && (get_bits(&s->gb, 8) & 0xF8) == 0xD0) {
1084
2/2
✓ Branch 0 taken 7950 times.
✓ Branch 1 taken 2650 times.
10600 for (i = 0; i < nb_components; i++) /* reset dc */
1085 7950 s->last_dc[i] = (4 << s->bits);
1086 2650 reset = 1;
1087 } else
1088 200 skip_bits_long(&s->gb, pos - get_bits_count(&s->gb));
1089 }
1090 }
1091 }
1092 810549 return reset;
1093 }
1094
1095 /* Handles 1 to 4 components */
1096 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int nb_components, int predictor, int point_transform)
1097 {
1098 int i, mb_x, mb_y;
1099 unsigned width;
1100 uint16_t (*buffer)[4];
1101 int left[4], top[4], topleft[4];
1102 const int linesize = s->linesize[0];
1103 const int mask = ((1 << s->bits) - 1) << point_transform;
1104 int resync_mb_y = 0;
1105 int resync_mb_x = 0;
1106 int vpred[6];
1107 int ret;
1108
1109 if (!s->bayer && s->nb_components < 3)
1110 return AVERROR_INVALIDDATA;
1111 if (s->bayer && s->nb_components > 2)
1112 return AVERROR_INVALIDDATA;
1113 if (s->nb_components <= 0 || s->nb_components > 4)
1114 return AVERROR_INVALIDDATA;
1115 if (s->v_max != 1 || s->h_max != 1 || !s->lossless)
1116 return AVERROR_INVALIDDATA;
1117 if (s->bayer) {
1118 if (s->rct || s->pegasus_rct)
1119 return AVERROR_INVALIDDATA;
1120 }
1121
1122
1123 s->restart_count = s->restart_interval;
1124
1125 if (s->restart_interval == 0)
1126 s->restart_interval = INT_MAX;
1127
1128 if (s->bayer)
1129 width = s->mb_width / nb_components; /* Interleaved, width stored is the total so need to divide */
1130 else
1131 width = s->mb_width;
1132
1133 av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size, width * 4 * sizeof(s->ljpeg_buffer[0][0]));
1134 if (!s->ljpeg_buffer)
1135 return AVERROR(ENOMEM);
1136
1137 buffer = s->ljpeg_buffer;
1138
1139 for (i = 0; i < 4; i++)
1140 buffer[0][i] = 1 << (s->bits - 1);
1141
1142 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1143 uint8_t *ptr = s->picture_ptr->data[0] + (linesize * mb_y);
1144
1145 if (s->interlaced && s->bottom_field)
1146 ptr += linesize >> 1;
1147
1148 for (i = 0; i < 4; i++)
1149 top[i] = left[i] = topleft[i] = buffer[0][i];
1150
1151 if ((mb_y * s->width) % s->restart_interval == 0) {
1152 for (i = 0; i < 6; i++)
1153 vpred[i] = 1 << (s->bits-1);
1154 }
1155
1156 for (mb_x = 0; mb_x < width; mb_x++) {
1157 int modified_predictor = predictor;
1158
1159 if (get_bits_left(&s->gb) < 1) {
1160 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in rgb_scan\n");
1161 return AVERROR_INVALIDDATA;
1162 }
1163
1164 if (s->restart_interval && !s->restart_count){
1165 s->restart_count = s->restart_interval;
1166 resync_mb_x = mb_x;
1167 resync_mb_y = mb_y;
1168 for(i=0; i<4; i++)
1169 top[i] = left[i]= topleft[i]= 1 << (s->bits - 1);
1170 }
1171 if (mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || !mb_x)
1172 modified_predictor = 1;
1173
1174 for (i=0;i<nb_components;i++) {
1175 int pred, dc;
1176
1177 topleft[i] = top[i];
1178 top[i] = buffer[mb_x][i];
1179
1180 ret = mjpeg_decode_dc(s, s->dc_index[i], &dc);
1181 if (ret < 0)
1182 return ret;
1183
1184 if (!s->bayer || mb_x) {
1185 pred = left[i];
1186 } else { /* This path runs only for the first line in bayer images */
1187 vpred[i] += dc;
1188 pred = vpred[i] - dc;
1189 }
1190
1191 PREDICT(pred, topleft[i], top[i], pred, modified_predictor);
1192
1193 left[i] = buffer[mb_x][i] =
1194 mask & (pred + (unsigned)(dc * (1 << point_transform)));
1195 }
1196
1197 if (s->restart_interval && !--s->restart_count) {
1198 align_get_bits(&s->gb);
1199 skip_bits(&s->gb, 16); /* skip RSTn */
1200 }
1201 }
1202 if (s->rct && s->nb_components == 4) {
1203 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1204 ptr[4*mb_x + 2] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1205 ptr[4*mb_x + 1] = buffer[mb_x][1] + ptr[4*mb_x + 2];
1206 ptr[4*mb_x + 3] = buffer[mb_x][2] + ptr[4*mb_x + 2];
1207 ptr[4*mb_x + 0] = buffer[mb_x][3];
1208 }
1209 } else if (s->nb_components == 4) {
1210 for(i=0; i<nb_components; i++) {
1211 int c= s->comp_index[i];
1212 if (s->bits <= 8) {
1213 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1214 ptr[4*mb_x+3-c] = buffer[mb_x][i];
1215 }
1216 } else if(s->bits == 9) {
1217 return AVERROR_PATCHWELCOME;
1218 } else {
1219 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1220 ((uint16_t*)ptr)[4*mb_x+c] = buffer[mb_x][i];
1221 }
1222 }
1223 }
1224 } else if (s->rct) {
1225 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1226 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1227 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1228 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1229 }
1230 } else if (s->pegasus_rct) {
1231 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1232 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2]) >> 2);
1233 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1234 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1235 }
1236 } else if (s->bayer) {
1237 if (s->bits <= 8)
1238 return AVERROR_PATCHWELCOME;
1239 if (nb_components == 1) {
1240 /* Leave decoding to the TIFF/DNG decoder (see comment in ff_mjpeg_decode_sof) */
1241 for (mb_x = 0; mb_x < width; mb_x++)
1242 ((uint16_t*)ptr)[mb_x] = buffer[mb_x][0];
1243 } else if (nb_components == 2) {
1244 for (mb_x = 0; mb_x < width; mb_x++) {
1245 ((uint16_t*)ptr)[2*mb_x + 0] = buffer[mb_x][0];
1246 ((uint16_t*)ptr)[2*mb_x + 1] = buffer[mb_x][1];
1247 }
1248 }
1249 } else {
1250 for(i=0; i<nb_components; i++) {
1251 int c= s->comp_index[i];
1252 if (s->bits <= 8) {
1253 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1254 ptr[3*mb_x+2-c] = buffer[mb_x][i];
1255 }
1256 } else if(s->bits == 9) {
1257 return AVERROR_PATCHWELCOME;
1258 } else {
1259 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1260 ((uint16_t*)ptr)[3*mb_x+2-c] = buffer[mb_x][i];
1261 }
1262 }
1263 }
1264 }
1265 }
1266 return 0;
1267 }
1268
1269 200 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
1270 int point_transform, int nb_components)
1271 {
1272 int i, mb_x, mb_y, mask;
1273 200 int bits= (s->bits+7)&~7;
1274 200 int resync_mb_y = 0;
1275 200 int resync_mb_x = 0;
1276 int ret;
1277
1278 200 point_transform += bits - s->bits;
1279 200 mask = ((1 << s->bits) - 1) << point_transform;
1280
1281
2/4
✓ Branch 0 taken 200 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 200 times.
200 av_assert0(nb_components>=1 && nb_components<=4);
1282
1283
2/2
✓ Branch 0 taken 22450 times.
✓ Branch 1 taken 200 times.
22650 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1284
2/2
✓ Branch 0 taken 3816050 times.
✓ Branch 1 taken 22450 times.
3838500 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1285
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3816050 times.
3816050 if (get_bits_left(&s->gb) < 1) {
1286 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in yuv_scan\n");
1287 return AVERROR_INVALIDDATA;
1288 }
1289
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 3816050 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
3816050 if (s->restart_interval && !s->restart_count){
1290 s->restart_count = s->restart_interval;
1291 resync_mb_x = mb_x;
1292 resync_mb_y = mb_y;
1293 }
1294
1295
8/10
✓ Branch 0 taken 3793600 times.
✓ Branch 1 taken 22450 times.
✓ Branch 2 taken 3766550 times.
✓ Branch 3 taken 27050 times.
✓ Branch 4 taken 27050 times.
✓ Branch 5 taken 3739500 times.
✓ Branch 6 taken 27050 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✓ Branch 9 taken 3766550 times.
3865550 if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->interlaced){
1296
5/6
✓ Branch 0 taken 22250 times.
✓ Branch 1 taken 27250 times.
✓ Branch 2 taken 200 times.
✓ Branch 3 taken 22050 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 200 times.
49500 int toprow = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x;
1297
4/6
✓ Branch 0 taken 27050 times.
✓ Branch 1 taken 22450 times.
✓ Branch 2 taken 27050 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 27050 times.
49500 int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x;
1298
2/2
✓ Branch 0 taken 148500 times.
✓ Branch 1 taken 49500 times.
198000 for (i = 0; i < nb_components; i++) {
1299 uint8_t *ptr;
1300 uint16_t *ptr16;
1301 int n, h, v, x, y, c, j, linesize;
1302 148500 n = s->nb_blocks[i];
1303 148500 c = s->comp_index[i];
1304 148500 h = s->h_scount[i];
1305 148500 v = s->v_scount[i];
1306 148500 x = 0;
1307 148500 y = 0;
1308 148500 linesize= s->linesize[c];
1309
1310
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 148500 times.
148500 if(bits>8) linesize /= 2;
1311
1312
2/2
✓ Branch 0 taken 297000 times.
✓ Branch 1 taken 148500 times.
445500 for(j=0; j<n; j++) {
1313 int pred, dc;
1314
1315 297000 ret = mjpeg_decode_dc(s, s->dc_index[i], &dc);
1316
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 297000 times.
297000 if (ret < 0)
1317 return ret;
1318
1319
1/2
✓ Branch 0 taken 297000 times.
✗ Branch 1 not taken.
297000 if ( h * mb_x + x >= s->width
1320
1/2
✓ Branch 0 taken 297000 times.
✗ Branch 1 not taken.
297000 || v * mb_y + y >= s->height) {
1321 // Nothing to do
1322
1/2
✓ Branch 0 taken 297000 times.
✗ Branch 1 not taken.
297000 } else if (bits<=8) {
1323 297000 ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1324
4/4
✓ Branch 0 taken 198000 times.
✓ Branch 1 taken 99000 times.
✓ Branch 2 taken 109000 times.
✓ Branch 3 taken 89000 times.
297000 if(y==0 && toprow){
1325
4/4
✓ Branch 0 taken 81750 times.
✓ Branch 1 taken 27250 times.
✓ Branch 2 taken 600 times.
✓ Branch 3 taken 81150 times.
109000 if(x==0 && leftcol){
1326 600 pred= 1 << (bits - 1);
1327 }else{
1328 108400 pred= ptr[-1];
1329 }
1330 }else{
1331
4/4
✓ Branch 0 taken 116250 times.
✓ Branch 1 taken 71750 times.
✓ Branch 2 taken 89200 times.
✓ Branch 3 taken 27050 times.
188000 if(x==0 && leftcol){
1332 89200 pred= ptr[-linesize];
1333 }else{
1334
1/8
✗ Branch 0 not taken.
✓ Branch 1 taken 98800 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
98800 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1335 }
1336 }
1337
1338
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 297000 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
297000 if (s->interlaced && s->bottom_field)
1339 ptr += linesize >> 1;
1340 297000 pred &= mask;
1341 297000 *ptr= pred + ((unsigned)dc << point_transform);
1342 }else{
1343 ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1344 if(y==0 && toprow){
1345 if(x==0 && leftcol){
1346 pred= 1 << (bits - 1);
1347 }else{
1348 pred= ptr16[-1];
1349 }
1350 }else{
1351 if(x==0 && leftcol){
1352 pred= ptr16[-linesize];
1353 }else{
1354 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1355 }
1356 }
1357
1358 if (s->interlaced && s->bottom_field)
1359 ptr16 += linesize >> 1;
1360 pred &= mask;
1361 *ptr16= pred + ((unsigned)dc << point_transform);
1362 }
1363
2/2
✓ Branch 0 taken 198000 times.
✓ Branch 1 taken 99000 times.
297000 if (++x == h) {
1364 198000 x = 0;
1365 198000 y++;
1366 }
1367 }
1368 }
1369 } else {
1370
2/2
✓ Branch 0 taken 11299650 times.
✓ Branch 1 taken 3766550 times.
15066200 for (i = 0; i < nb_components; i++) {
1371 uint8_t *ptr;
1372 uint16_t *ptr16;
1373 int n, h, v, x, y, c, j, linesize, dc;
1374 11299650 n = s->nb_blocks[i];
1375 11299650 c = s->comp_index[i];
1376 11299650 h = s->h_scount[i];
1377 11299650 v = s->v_scount[i];
1378 11299650 x = 0;
1379 11299650 y = 0;
1380 11299650 linesize = s->linesize[c];
1381
1382
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11299650 times.
11299650 if(bits>8) linesize /= 2;
1383
1384
2/2
✓ Branch 0 taken 22599300 times.
✓ Branch 1 taken 11299650 times.
33898950 for (j = 0; j < n; j++) {
1385 int pred;
1386
1387 22599300 ret = mjpeg_decode_dc(s, s->dc_index[i], &dc);
1388
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 22599300 times.
22599300 if (ret < 0)
1389 return ret;
1390
1391
1/2
✓ Branch 0 taken 22599300 times.
✗ Branch 1 not taken.
22599300 if ( h * mb_x + x >= s->width
1392
1/2
✓ Branch 0 taken 22599300 times.
✗ Branch 1 not taken.
22599300 || v * mb_y + y >= s->height) {
1393 // Nothing to do
1394
1/2
✓ Branch 0 taken 22599300 times.
✗ Branch 1 not taken.
22599300 } else if (bits<=8) {
1395 22599300 ptr = s->picture_ptr->data[c] +
1396 22599300 (linesize * (v * mb_y + y)) +
1397 22599300 (h * mb_x + x); //FIXME optimize this crap
1398
1/8
✗ Branch 0 not taken.
✓ Branch 1 taken 22599300 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
22599300 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1399
1400 22599300 pred &= mask;
1401 22599300 *ptr = pred + ((unsigned)dc << point_transform);
1402 }else{
1403 ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1404 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1405
1406 pred &= mask;
1407 *ptr16= pred + ((unsigned)dc << point_transform);
1408 }
1409
1410
2/2
✓ Branch 0 taken 15066200 times.
✓ Branch 1 taken 7533100 times.
22599300 if (++x == h) {
1411 15066200 x = 0;
1412 15066200 y++;
1413 }
1414 }
1415 }
1416 }
1417
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 3816050 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
3816050 if (s->restart_interval && !--s->restart_count) {
1418 align_get_bits(&s->gb);
1419 skip_bits(&s->gb, 16); /* skip RSTn */
1420 }
1421 }
1422 }
1423 200 return 0;
1424 }
1425
1426 786684 static av_always_inline void mjpeg_copy_block(MJpegDecodeContext *s,
1427 uint8_t *dst, const uint8_t *src,
1428 int linesize, int lowres)
1429 {
1430
1/5
✓ Branch 0 taken 786684 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
786684 switch (lowres) {
1431 786684 case 0: s->copy_block(dst, src, linesize, 8);
1432 786684 break;
1433 case 1: copy_block4(dst, src, linesize, linesize, 4);
1434 break;
1435 case 2: copy_block2(dst, src, linesize, linesize, 2);
1436 break;
1437 case 3: *dst = *src;
1438 break;
1439 }
1440 786684 }
1441
1442 11750 static void shift_output(MJpegDecodeContext *s, uint8_t *ptr, int linesize)
1443 {
1444 int block_x, block_y;
1445 11750 int size = 8 >> s->avctx->lowres;
1446
1/2
✓ Branch 0 taken 11750 times.
✗ Branch 1 not taken.
11750 if (s->bits > 8) {
1447
2/2
✓ Branch 0 taken 94000 times.
✓ Branch 1 taken 11750 times.
105750 for (block_y=0; block_y<size; block_y++)
1448
2/2
✓ Branch 0 taken 752000 times.
✓ Branch 1 taken 94000 times.
846000 for (block_x=0; block_x<size; block_x++)
1449 752000 *(uint16_t*)(ptr + 2*block_x + block_y*linesize) <<= 16 - s->bits;
1450 } else {
1451 for (block_y=0; block_y<size; block_y++)
1452 for (block_x=0; block_x<size; block_x++)
1453 *(ptr + block_x + block_y*linesize) <<= 8 - s->bits;
1454 }
1455 11750 }
1456
1457 2151 static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
1458 int Al, const uint8_t *mb_bitmask,
1459 int mb_bitmask_size,
1460 const AVFrame *reference)
1461 {
1462 int i, mb_x, mb_y, chroma_h_shift, chroma_v_shift, chroma_width, chroma_height;
1463 uint8_t *data[MAX_COMPONENTS];
1464 const uint8_t *reference_data[MAX_COMPONENTS];
1465 int linesize[MAX_COMPONENTS];
1466 2151 GetBitContext mb_bitmask_gb = {0}; // initialize to silence gcc warning
1467
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2150 times.
2151 int bytes_per_pixel = 1 + (s->bits > 8);
1468
1469
2/2
✓ Branch 0 taken 31 times.
✓ Branch 1 taken 2120 times.
2151 if (mb_bitmask) {
1470
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 31 times.
31 if (mb_bitmask_size != (s->mb_width * s->mb_height + 7)>>3) {
1471 av_log(s->avctx, AV_LOG_ERROR, "mb_bitmask_size mismatches\n");
1472 return AVERROR_INVALIDDATA;
1473 }
1474 31 init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
1475 }
1476
1477 2151 s->restart_count = 0;
1478
1479 2151 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &chroma_h_shift,
1480 &chroma_v_shift);
1481 2151 chroma_width = AV_CEIL_RSHIFT(s->width, chroma_h_shift);
1482 2151 chroma_height = AV_CEIL_RSHIFT(s->height, chroma_v_shift);
1483
1484
2/2
✓ Branch 0 taken 6445 times.
✓ Branch 1 taken 2151 times.
8596 for (i = 0; i < nb_components; i++) {
1485 6445 int c = s->comp_index[i];
1486 6445 data[c] = s->picture_ptr->data[c];
1487
2/2
✓ Branch 0 taken 93 times.
✓ Branch 1 taken 6352 times.
6445 reference_data[c] = reference ? reference->data[c] : NULL;
1488 6445 linesize[c] = s->linesize[c];
1489 6445 s->coefs_finished[c] |= 1;
1490 }
1491
1492
2/2
✓ Branch 0 taken 28923 times.
✓ Branch 1 taken 2151 times.
31074 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1493
2/2
✓ Branch 0 taken 808133 times.
✓ Branch 1 taken 28923 times.
837056 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1494
4/4
✓ Branch 0 taken 148800 times.
✓ Branch 1 taken 659333 times.
✓ Branch 3 taken 131114 times.
✓ Branch 4 taken 17686 times.
808133 const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
1495
1496
4/4
✓ Branch 0 taken 59850 times.
✓ Branch 1 taken 748283 times.
✓ Branch 2 taken 2850 times.
✓ Branch 3 taken 57000 times.
808133 if (s->restart_interval && !s->restart_count)
1497 2850 s->restart_count = s->restart_interval;
1498
1499
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 808133 times.
808133 if (get_bits_left(&s->gb) < 0) {
1500 av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",
1501 -get_bits_left(&s->gb));
1502 return AVERROR_INVALIDDATA;
1503 }
1504
2/2
✓ Branch 0 taken 2400683 times.
✓ Branch 1 taken 808133 times.
3208816 for (i = 0; i < nb_components; i++) {
1505 uint8_t *ptr;
1506 int n, h, v, x, y, c, j;
1507 int block_offset;
1508 2400683 n = s->nb_blocks[i];
1509 2400683 c = s->comp_index[i];
1510 2400683 h = s->h_scount[i];
1511 2400683 v = s->v_scount[i];
1512 2400683 x = 0;
1513 2400683 y = 0;
1514
2/2
✓ Branch 0 taken 4821902 times.
✓ Branch 1 taken 2400683 times.
7222585 for (j = 0; j < n; j++) {
1515 4821902 block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
1516 4821902 (h * mb_x + x) * 8 * bytes_per_pixel) >> s->avctx->lowres);
1517
1518
4/4
✓ Branch 0 taken 90560 times.
✓ Branch 1 taken 4731342 times.
✓ Branch 2 taken 45280 times.
✓ Branch 3 taken 45280 times.
4821902 if (s->interlaced && s->bottom_field)
1519 45280 block_offset += linesize[c] >> 1;
1520
6/6
✓ Branch 0 taken 3845811 times.
✓ Branch 1 taken 976091 times.
✓ Branch 2 taken 2869820 times.
✓ Branch 3 taken 975991 times.
✓ Branch 4 taken 4819453 times.
✓ Branch 5 taken 2449 times.
4821902 if ( 8*(h * mb_x + x) < ((c == 1) || (c == 2) ? chroma_width : s->width)
1521
6/6
✓ Branch 0 taken 3843370 times.
✓ Branch 1 taken 976083 times.
✓ Branch 2 taken 2867379 times.
✓ Branch 3 taken 975991 times.
✓ Branch 4 taken 4813344 times.
✓ Branch 5 taken 6109 times.
4819453 && 8*(v * mb_y + y) < ((c == 1) || (c == 2) ? chroma_height : s->height)) {
1522 4813344 ptr = data[c] + block_offset;
1523 } else
1524 8558 ptr = NULL;
1525
2/2
✓ Branch 0 taken 4821026 times.
✓ Branch 1 taken 876 times.
4821902 if (!s->progressive) {
1526
2/2
✓ Branch 0 taken 786684 times.
✓ Branch 1 taken 4034342 times.
4821026 if (copy_mb) {
1527
1/2
✓ Branch 0 taken 786684 times.
✗ Branch 1 not taken.
786684 if (ptr)
1528 786684 mjpeg_copy_block(s, ptr, reference_data[c] + block_offset,
1529 786684 linesize[c], s->avctx->lowres);
1530
1531 } else {
1532 4034342 s->bdsp.clear_block(s->block);
1533
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4034342 times.
4034342 if (decode_block(s, s->block, i,
1534 s->dc_index[i], s->ac_index[i],
1535 4034342 s->quant_matrixes[s->quant_sindex[i]]) < 0) {
1536 av_log(s->avctx, AV_LOG_ERROR,
1537 "error y=%d x=%d\n", mb_y, mb_x);
1538 return AVERROR_INVALIDDATA;
1539 }
1540
3/4
✓ Branch 0 taken 4025800 times.
✓ Branch 1 taken 8542 times.
✓ Branch 2 taken 4025800 times.
✗ Branch 3 not taken.
4034342 if (ptr && linesize[c]) {
1541 4025800 s->idsp.idct_put(ptr, linesize[c], s->block);
1542
2/2
✓ Branch 0 taken 11750 times.
✓ Branch 1 taken 4014050 times.
4025800 if (s->bits & 7)
1543 11750 shift_output(s, ptr, linesize[c]);
1544 }
1545 }
1546 } else {
1547 876 int block_idx = s->block_stride[c] * (v * mb_y + y) +
1548 876 (h * mb_x + x);
1549 876 int16_t *block = s->blocks[c][block_idx];
1550
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 876 times.
876 if (Ah)
1551 block[0] += get_bits1(&s->gb) *
1552 s->quant_matrixes[s->quant_sindex[i]][0] << Al;
1553
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 876 times.
876 else if (decode_dc_progressive(s, block, i, s->dc_index[i],
1554 876 s->quant_matrixes[s->quant_sindex[i]],
1555 Al) < 0) {
1556 av_log(s->avctx, AV_LOG_ERROR,
1557 "error y=%d x=%d\n", mb_y, mb_x);
1558 return AVERROR_INVALIDDATA;
1559 }
1560 }
1561 ff_dlog(s->avctx, "mb: %d %d processed\n", mb_y, mb_x);
1562 ff_dlog(s->avctx, "%d %d %d %d %d %d %d %d \n",
1563 mb_x, mb_y, x, y, c, s->bottom_field,
1564 (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1565
2/2
✓ Branch 0 taken 3512577 times.
✓ Branch 1 taken 1309325 times.
4821902 if (++x == h) {
1566 3512577 x = 0;
1567 3512577 y++;
1568 }
1569 }
1570 }
1571
1572 808133 handle_rstn(s, nb_components);
1573 }
1574 }
1575 2151 return 0;
1576 }
1577
1578 59 static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss,
1579 int se, int Ah, int Al)
1580 {
1581 int mb_x, mb_y;
1582 59 int EOBRUN = 0;
1583 59 int c = s->comp_index[0];
1584 59 uint16_t *quant_matrix = s->quant_matrixes[s->quant_sindex[0]];
1585
1586
3/6
✓ Branch 0 taken 59 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 59 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 59 times.
59 av_assert0(ss>=0 && Ah>=0 && Al>=0);
1587
2/4
✓ Branch 0 taken 59 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 59 times.
59 if (se < ss || se > 63) {
1588 av_log(s->avctx, AV_LOG_ERROR, "SS/SE %d/%d is invalid\n", ss, se);
1589 return AVERROR_INVALIDDATA;
1590 }
1591
1592 // s->coefs_finished is a bitmask for coefficients coded
1593 // ss and se are parameters telling start and end coefficients
1594 59 s->coefs_finished[c] |= (2ULL << se) - (1ULL << ss);
1595
1596 59 s->restart_count = 0;
1597
1598
2/2
✓ Branch 0 taken 412 times.
✓ Branch 1 taken 59 times.
471 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1599 412 int block_idx = mb_y * s->block_stride[c];
1600 412 int16_t (*block)[64] = &s->blocks[c][block_idx];
1601 412 uint8_t *last_nnz = &s->last_nnz[c][block_idx];
1602
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 412 times.
412 if (get_bits_left(&s->gb) <= 0) {
1603 av_log(s->avctx, AV_LOG_ERROR, "bitstream truncated in mjpeg_decode_scan_progressive_ac\n");
1604 return AVERROR_INVALIDDATA;
1605 }
1606
2/2
✓ Branch 0 taken 2416 times.
✓ Branch 1 taken 412 times.
2828 for (mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) {
1607 int ret;
1608
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 2416 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
2416 if (s->restart_interval && !s->restart_count)
1609 s->restart_count = s->restart_interval;
1610
1611
2/2
✓ Branch 0 taken 1080 times.
✓ Branch 1 taken 1336 times.
2416 if (Ah)
1612 1080 ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0],
1613 quant_matrix, ss, se, Al, &EOBRUN);
1614 else
1615 1336 ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0],
1616 quant_matrix, ss, se, Al, &EOBRUN);
1617
1618
2/4
✓ Branch 0 taken 2416 times.
✗ Branch 1 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 2416 times.
2416 if (ret >= 0 && get_bits_left(&s->gb) < 0)
1619 ret = AVERROR_INVALIDDATA;
1620
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2416 times.
2416 if (ret < 0) {
1621 av_log(s->avctx, AV_LOG_ERROR,
1622 "error y=%d x=%d\n", mb_y, mb_x);
1623 return AVERROR_INVALIDDATA;
1624 }
1625
1626
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2416 times.
2416 if (handle_rstn(s, 0))
1627 EOBRUN = 0;
1628 }
1629 }
1630 59 return 0;
1631 }
1632
1633 7 static void mjpeg_idct_scan_progressive_ac(MJpegDecodeContext *s)
1634 {
1635 int mb_x, mb_y;
1636 int c;
1637
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
7 const int bytes_per_pixel = 1 + (s->bits > 8);
1638
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
7 const int block_size = s->lossless ? 1 : 8;
1639
1640
2/2
✓ Branch 0 taken 21 times.
✓ Branch 1 taken 7 times.
28 for (c = 0; c < s->nb_components; c++) {
1641 21 uint8_t *data = s->picture_ptr->data[c];
1642 21 int linesize = s->linesize[c];
1643 21 int h = s->h_max / s->h_count[c];
1644 21 int v = s->v_max / s->v_count[c];
1645 21 int mb_width = (s->width + h * block_size - 1) / (h * block_size);
1646 21 int mb_height = (s->height + v * block_size - 1) / (v * block_size);
1647
1648
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 21 times.
21 if (~s->coefs_finished[c])
1649 av_log(s->avctx, AV_LOG_WARNING, "component %d is incomplete\n", c);
1650
1651
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 21 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
21 if (s->interlaced && s->bottom_field)
1652 data += linesize >> 1;
1653
1654
2/2
✓ Branch 0 taken 153 times.
✓ Branch 1 taken 21 times.
174 for (mb_y = 0; mb_y < mb_height; mb_y++) {
1655 153 uint8_t *ptr = data + (mb_y * linesize * 8 >> s->avctx->lowres);
1656 153 int block_idx = mb_y * s->block_stride[c];
1657 153 int16_t (*block)[64] = &s->blocks[c][block_idx];
1658
2/2
✓ Branch 0 taken 860 times.
✓ Branch 1 taken 153 times.
1013 for (mb_x = 0; mb_x < mb_width; mb_x++, block++) {
1659 860 s->idsp.idct_put(ptr, linesize, *block);
1660
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 860 times.
860 if (s->bits & 7)
1661 shift_output(s, ptr, linesize);
1662 860 ptr += bytes_per_pixel*8 >> s->avctx->lowres;
1663 }
1664 }
1665 }
1666 7 }
1667
1668 2623 int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
1669 int mb_bitmask_size, const AVFrame *reference)
1670 {
1671 int len, nb_components, i, h, v, predictor, point_transform;
1672 int index, id, ret;
1673
2/2
✓ Branch 0 taken 413 times.
✓ Branch 1 taken 2210 times.
2623 const int block_size = s->lossless ? 1 : 8;
1674 int ilv, prev_shift;
1675
1676
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2623 times.
2623 if (!s->got_picture) {
1677 av_log(s->avctx, AV_LOG_WARNING,
1678 "Can not process SOS before SOF, skipping\n");
1679 return -1;
1680 }
1681
1682 /* XXX: verify len field validity */
1683 2623 len = get_bits(&s->gb, 16);
1684 2623 nb_components = get_bits(&s->gb, 8);
1685
2/4
✓ Branch 0 taken 2623 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2623 times.
2623 if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
1686 avpriv_report_missing_feature(s->avctx,
1687 "decode_sos: nb_components (%d)",
1688 nb_components);
1689 return AVERROR_PATCHWELCOME;
1690 }
1691
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2623 times.
2623 if (len != 6 + 2 * nb_components) {
1692 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1693 return AVERROR_INVALIDDATA;
1694 }
1695
2/2
✓ Branch 0 taken 7727 times.
✓ Branch 1 taken 2623 times.
10350 for (i = 0; i < nb_components; i++) {
1696 7727 id = get_bits(&s->gb, 8);
1697 7727 av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1698 /* find component index */
1699
1/2
✓ Branch 0 taken 15443 times.
✗ Branch 1 not taken.
15443 for (index = 0; index < s->nb_components; index++)
1700
2/2
✓ Branch 0 taken 7727 times.
✓ Branch 1 taken 7716 times.
15443 if (id == s->component_id[index])
1701 7727 break;
1702
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7727 times.
7727 if (index == s->nb_components) {
1703 av_log(s->avctx, AV_LOG_ERROR,
1704 "decode_sos: index(%d) out of components\n", index);
1705 return AVERROR_INVALIDDATA;
1706 }
1707 /* Metasoft MJPEG codec has Cb and Cr swapped */
1708
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7727 times.
7727 if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
1709 && nb_components == 3 && s->nb_components == 3 && i)
1710 index = 3 - i;
1711
1712 7727 s->quant_sindex[i] = s->quant_index[index];
1713 7727 s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1714 7727 s->h_scount[i] = s->h_count[index];
1715 7727 s->v_scount[i] = s->v_count[index];
1716
1717 7727 s->comp_index[i] = index;
1718
1719 7727 s->dc_index[i] = get_bits(&s->gb, 4);
1720 7727 s->ac_index[i] = get_bits(&s->gb, 4);
1721
1722
2/4
✓ Branch 0 taken 7727 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7727 times.
✗ Branch 3 not taken.
7727 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1723
2/4
✓ Branch 0 taken 7727 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 7727 times.
7727 s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1724 goto out_of_range;
1725
5/8
✓ Branch 0 taken 7727 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 80 times.
✓ Branch 3 taken 7647 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 80 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 7647 times.
7727 if (!s->vlcs[0][s->dc_index[i]].table || !(s->progressive ? s->vlcs[2][s->ac_index[0]].table : s->vlcs[1][s->ac_index[i]].table))
1726 goto out_of_range;
1727 }
1728
1729 2623 predictor = get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1730 2623 ilv = get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */
1731
1/2
✓ Branch 0 taken 2623 times.
✗ Branch 1 not taken.
2623 if(s->avctx->codec_tag != AV_RL32("CJPG")){
1732 2623 prev_shift = get_bits(&s->gb, 4); /* Ah */
1733 2623 point_transform = get_bits(&s->gb, 4); /* Al */
1734 }else
1735 prev_shift = point_transform = 0;
1736
1737
2/2
✓ Branch 0 taken 2552 times.
✓ Branch 1 taken 71 times.
2623 if (nb_components > 1) {
1738 /* interleaved stream */
1739 2552 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1740 2552 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1741
2/2
✓ Branch 0 taken 63 times.
✓ Branch 1 taken 8 times.
71 } else if (!s->ls) { /* skip this for JPEG-LS */
1742 63 h = s->h_max / s->h_scount[0];
1743 63 v = s->v_max / s->v_scount[0];
1744 63 s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1745 63 s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1746 63 s->nb_blocks[0] = 1;
1747 63 s->h_scount[0] = 1;
1748 63 s->v_scount[0] = 1;
1749 }
1750
1751
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2623 times.
2623 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1752 av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n",
1753 s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",
1754 predictor, point_transform, ilv, s->bits, s->mjpb_skiptosod,
1755 s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), nb_components);
1756
1757
1758 /* mjpeg-b can have padding bytes between sos and image data, skip them */
1759
2/2
✓ Branch 0 taken 1342 times.
✓ Branch 1 taken 2623 times.
3965 for (i = s->mjpb_skiptosod; i > 0; i--)
1760 1342 skip_bits(&s->gb, 8);
1761
1762 2623 next_field:
1763
2/2
✓ Branch 0 taken 7727 times.
✓ Branch 1 taken 2623 times.
10350 for (i = 0; i < nb_components; i++)
1764 7727 s->last_dc[i] = (4 << s->bits);
1765
1766
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2623 times.
2623 if (s->avctx->hwaccel) {
1767 int bytes_to_start = get_bits_count(&s->gb) / 8;
1768 av_assert0(bytes_to_start >= 0 &&
1769 s->raw_scan_buffer_size >= bytes_to_start);
1770
1771 ret = FF_HW_CALL(s->avctx, decode_slice,
1772 s->raw_scan_buffer + bytes_to_start,
1773 s->raw_scan_buffer_size - bytes_to_start);
1774 if (ret < 0)
1775 return ret;
1776
1777
2/2
✓ Branch 0 taken 413 times.
✓ Branch 1 taken 2210 times.
2623 } else if (s->lossless) {
1778
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 413 times.
413 av_assert0(s->picture_ptr == s->picture);
1779
2/2
✓ Branch 0 taken 213 times.
✓ Branch 1 taken 200 times.
413 if (CONFIG_JPEGLS_DECODER && s->ls) {
1780 // for () {
1781 // reset_ls_coding_parameters(s, 0);
1782
1783
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 213 times.
213 if ((ret = ff_jpegls_decode_picture(s, predictor,
1784 point_transform, ilv)) < 0)
1785 return ret;
1786 } else {
1787
2/4
✓ Branch 0 taken 200 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 200 times.
200 if (s->rgb || s->bayer) {
1788 if ((ret = ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform)) < 0)
1789 return ret;
1790 } else {
1791
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 200 times.
200 if ((ret = ljpeg_decode_yuv_scan(s, predictor,
1792 point_transform,
1793 nb_components)) < 0)
1794 return ret;
1795 }
1796 }
1797 } else {
1798
4/4
✓ Branch 0 taken 68 times.
✓ Branch 1 taken 2142 times.
✓ Branch 2 taken 59 times.
✓ Branch 3 taken 9 times.
2210 if (s->progressive && predictor) {
1799
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 59 times.
59 av_assert0(s->picture_ptr == s->picture);
1800
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 59 times.
59 if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor,
1801 ilv, prev_shift,
1802 point_transform)) < 0)
1803 return ret;
1804 } else {
1805
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2151 times.
2151 if ((ret = mjpeg_decode_scan(s, nb_components,
1806 prev_shift, point_transform,
1807 mb_bitmask, mb_bitmask_size, reference)) < 0)
1808 return ret;
1809 }
1810 }
1811
1812
4/4
✓ Branch 0 taken 38 times.
✓ Branch 1 taken 2585 times.
✓ Branch 2 taken 25 times.
✓ Branch 3 taken 13 times.
2661 if (s->interlaced &&
1813
2/2
✓ Branch 1 taken 10 times.
✓ Branch 2 taken 15 times.
63 get_bits_left(&s->gb) > 32 &&
1814 25 show_bits(&s->gb, 8) == 0xFF) {
1815 10 GetBitContext bak = s->gb;
1816 10 align_get_bits(&bak);
1817
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
10 if (show_bits(&bak, 16) == 0xFFD1) {
1818 av_log(s->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n");
1819 s->gb = bak;
1820 skip_bits(&s->gb, 16);
1821 s->bottom_field ^= 1;
1822
1823 goto next_field;
1824 }
1825 }
1826
1827 2623 emms_c();
1828 2623 return 0;
1829 out_of_range:
1830 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1831 return AVERROR_INVALIDDATA;
1832 }
1833
1834 216 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1835 {
1836
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 216 times.
216 if (get_bits(&s->gb, 16) != 4)
1837 return AVERROR_INVALIDDATA;
1838 216 s->restart_interval = get_bits(&s->gb, 16);
1839 216 s->restart_count = 0;
1840 216 av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
1841 s->restart_interval);
1842
1843 216 return 0;
1844 }
1845
1846 227 static int mjpeg_decode_app(MJpegDecodeContext *s)
1847 {
1848 int len, id, i;
1849
1850 227 len = get_bits(&s->gb, 16);
1851
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 227 times.
227 if (len < 2)
1852 return AVERROR_INVALIDDATA;
1853 227 len -= 2;
1854
1855
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 227 times.
227 if (len < 4) {
1856 if (s->avctx->err_recognition & AV_EF_EXPLODE)
1857 return AVERROR_INVALIDDATA;
1858 av_log(s->avctx, AV_LOG_VERBOSE, "skipping APPx stub (len=%" PRId32 ")\n", len);
1859 goto out;
1860 }
1861
1862
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 227 times.
227 if (8 * len > get_bits_left(&s->gb))
1863 return AVERROR_INVALIDDATA;
1864
1865 227 id = get_bits_long(&s->gb, 32);
1866 227 len -= 4;
1867
1868
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 227 times.
227 if (s->avctx->debug & FF_DEBUG_STARTCODE)
1869 av_log(s->avctx, AV_LOG_DEBUG, "APPx (%s / %8X) len=%d\n",
1870 av_fourcc2str(av_bswap32(id)), id, len);
1871
1872 /* Buggy AVID, it puts EOI only at every 10th frame. */
1873 /* Also, this fourcc is used by non-avid files too, it holds some
1874 information, but it's always present in AVID-created files. */
1875
2/2
✓ Branch 0 taken 18 times.
✓ Branch 1 taken 209 times.
227 if (id == AV_RB32("AVI1")) {
1876 /* structure:
1877 4bytes AVI1
1878 1bytes polarity
1879 1bytes always zero
1880 4bytes field_size
1881 4bytes field_size_less_padding
1882 */
1883 18 s->buggy_avid = 1;
1884 18 i = get_bits(&s->gb, 8); len--;
1885 18 av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i);
1886 18 goto out;
1887 }
1888
1889
2/2
✓ Branch 0 taken 148 times.
✓ Branch 1 taken 61 times.
209 if (id == AV_RB32("JFIF")) {
1890 int t_w, t_h, v1, v2;
1891
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 148 times.
148 if (len < 8)
1892 goto out;
1893 148 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1894 148 v1 = get_bits(&s->gb, 8);
1895 148 v2 = get_bits(&s->gb, 8);
1896 148 skip_bits(&s->gb, 8);
1897
1898 148 s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 16);
1899 148 s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16);
1900
1/2
✓ Branch 0 taken 148 times.
✗ Branch 1 not taken.
148 if ( s->avctx->sample_aspect_ratio.num <= 0
1901
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 148 times.
148 || s->avctx->sample_aspect_ratio.den <= 0) {
1902 s->avctx->sample_aspect_ratio.num = 0;
1903 s->avctx->sample_aspect_ratio.den = 1;
1904 }
1905
1906
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 148 times.
148 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1907 av_log(s->avctx, AV_LOG_INFO,
1908 "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1909 v1, v2,
1910 s->avctx->sample_aspect_ratio.num,
1911 s->avctx->sample_aspect_ratio.den);
1912
1913 148 len -= 8;
1914
2/2
✓ Branch 0 taken 146 times.
✓ Branch 1 taken 2 times.
148 if (len >= 2) {
1915 146 t_w = get_bits(&s->gb, 8);
1916 146 t_h = get_bits(&s->gb, 8);
1917
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 146 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
146 if (t_w && t_h) {
1918 /* skip thumbnail */
1919 if (len -10 - (t_w * t_h * 3) > 0)
1920 len -= t_w * t_h * 3;
1921 }
1922 146 len -= 2;
1923 }
1924 148 goto out;
1925 }
1926
1927
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 48 times.
61 if ( id == AV_RB32("Adob")
1928
1/2
✓ Branch 0 taken 13 times.
✗ Branch 1 not taken.
13 && len >= 8
1929
1/2
✓ Branch 1 taken 13 times.
✗ Branch 2 not taken.
13 && show_bits(&s->gb, 8) == 'e'
1930
1/2
✓ Branch 1 taken 13 times.
✗ Branch 2 not taken.
13 && show_bits_long(&s->gb, 32) != AV_RB32("e_CM")) {
1931 13 skip_bits(&s->gb, 8); /* 'e' */
1932 13 skip_bits(&s->gb, 16); /* version */
1933 13 skip_bits(&s->gb, 16); /* flags0 */
1934 13 skip_bits(&s->gb, 16); /* flags1 */
1935 13 s->adobe_transform = get_bits(&s->gb, 8);
1936
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1937 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found, transform=%d\n", s->adobe_transform);
1938 13 len -= 8;
1939 13 goto out;
1940 }
1941
1942
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 48 times.
48 if (id == AV_RB32("LJIF")) {
1943 int rgb = s->rgb;
1944 int pegasus_rct = s->pegasus_rct;
1945 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1946 av_log(s->avctx, AV_LOG_INFO,
1947 "Pegasus lossless jpeg header found\n");
1948 skip_bits(&s->gb, 16); /* version ? */
1949 skip_bits(&s->gb, 16); /* unknown always 0? */
1950 skip_bits(&s->gb, 16); /* unknown always 0? */
1951 skip_bits(&s->gb, 16); /* unknown always 0? */
1952 switch (i=get_bits(&s->gb, 8)) {
1953 case 1:
1954 rgb = 1;
1955 pegasus_rct = 0;
1956 break;
1957 case 2:
1958 rgb = 1;
1959 pegasus_rct = 1;
1960 break;
1961 default:
1962 av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace %d\n", i);
1963 }
1964
1965 len -= 9;
1966 if (s->bayer)
1967 goto out;
1968 if (s->got_picture)
1969 if (rgb != s->rgb || pegasus_rct != s->pegasus_rct) {
1970 av_log(s->avctx, AV_LOG_WARNING, "Mismatching LJIF tag\n");
1971 goto out;
1972 }
1973
1974 s->rgb = rgb;
1975 s->pegasus_rct = pegasus_rct;
1976
1977 goto out;
1978 }
1979
3/4
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 40 times.
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
48 if (id == AV_RL32("colr") && len > 0) {
1980 8 s->colr = get_bits(&s->gb, 8);
1981
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
8 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1982 av_log(s->avctx, AV_LOG_INFO, "COLR %d\n", s->colr);
1983 8 len --;
1984 8 goto out;
1985 }
1986
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 40 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
40 if (id == AV_RL32("xfrm") && len > 0) {
1987 s->xfrm = get_bits(&s->gb, 8);
1988 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1989 av_log(s->avctx, AV_LOG_INFO, "XFRM %d\n", s->xfrm);
1990 len --;
1991 goto out;
1992 }
1993
1994 /* JPS extension by VRex */
1995
1/6
✗ Branch 0 not taken.
✓ Branch 1 taken 40 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
40 if (s->start_code == APP3 && id == AV_RB32("_JPS") && len >= 10) {
1996 int flags, layout, type;
1997 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1998 av_log(s->avctx, AV_LOG_INFO, "_JPSJPS_\n");
1999
2000 skip_bits(&s->gb, 32); len -= 4; /* JPS_ */
2001 skip_bits(&s->gb, 16); len -= 2; /* block length */
2002 skip_bits(&s->gb, 8); /* reserved */
2003 flags = get_bits(&s->gb, 8);
2004 layout = get_bits(&s->gb, 8);
2005 type = get_bits(&s->gb, 8);
2006 len -= 4;
2007
2008 av_freep(&s->stereo3d);
2009 s->stereo3d = av_stereo3d_alloc();
2010 if (!s->stereo3d) {
2011 goto out;
2012 }
2013 if (type == 0) {
2014 s->stereo3d->type = AV_STEREO3D_2D;
2015 } else if (type == 1) {
2016 switch (layout) {
2017 case 0x01:
2018 s->stereo3d->type = AV_STEREO3D_LINES;
2019 break;
2020 case 0x02:
2021 s->stereo3d->type = AV_STEREO3D_SIDEBYSIDE;
2022 break;
2023 case 0x03:
2024 s->stereo3d->type = AV_STEREO3D_TOPBOTTOM;
2025 break;
2026 }
2027 if (!(flags & 0x04)) {
2028 s->stereo3d->flags = AV_STEREO3D_FLAG_INVERT;
2029 }
2030 }
2031 goto out;
2032 }
2033
2034 /* EXIF metadata */
2035
5/6
✓ Branch 0 taken 26 times.
✓ Branch 1 taken 14 times.
✓ Branch 2 taken 24 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 24 times.
✗ Branch 5 not taken.
40 if (s->start_code == APP1 && id == AV_RB32("Exif") && len >= 2) {
2036 int ret;
2037 const uint8_t *aligned;
2038
2039 24 skip_bits(&s->gb, 16); // skip padding
2040 24 len -= 2;
2041
2042 // init byte wise reading
2043 24 aligned = align_get_bits(&s->gb);
2044
2045 24 ret = av_exif_parse_buffer(s->avctx, aligned, len, &s->exif_metadata, AV_EXIF_TIFF_HEADER);
2046
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.
24 if (ret < 0) {
2047 av_log(s->avctx, AV_LOG_WARNING, "unable to parse EXIF buffer\n");
2048 goto out;
2049 }
2050
2051 24 skip_bits(&s->gb, ret << 3);
2052 24 len -= ret;
2053
2054 24 goto out;
2055 }
2056
2057 /* Apple MJPEG-A */
2058
3/4
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 14 times.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
16 if ((s->start_code == APP1) && (len > (0x28 - 8))) {
2059 2 id = get_bits_long(&s->gb, 32);
2060 2 len -= 4;
2061 /* Apple MJPEG-A */
2062
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 if (id == AV_RB32("mjpg")) {
2063 /* structure:
2064 4bytes field size
2065 4bytes pad field size
2066 4bytes next off
2067 4bytes quant off
2068 4bytes huff off
2069 4bytes image off
2070 4bytes scan off
2071 4bytes data off
2072 */
2073 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2074 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
2075 }
2076 }
2077
2078
4/6
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 10 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 10 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 10 times.
16 if (s->start_code == APP2 && id == AV_RB32("ICC_") && len >= 10) {
2079 int id2;
2080 unsigned seqno;
2081 unsigned nummarkers;
2082
2083 10 id = get_bits_long(&s->gb, 32);
2084 10 id2 = get_bits(&s->gb, 24);
2085 10 len -= 7;
2086
2/4
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 10 times.
10 if (id != AV_RB32("PROF") || id2 != AV_RB24("ILE")) {
2087 av_log(s->avctx, AV_LOG_WARNING, "Invalid ICC_PROFILE header in APP2\n");
2088 goto out;
2089 }
2090
2091 10 skip_bits(&s->gb, 8);
2092 10 seqno = get_bits(&s->gb, 8);
2093 10 len -= 2;
2094
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
10 if (seqno == 0) {
2095 av_log(s->avctx, AV_LOG_WARNING, "Invalid sequence number in APP2\n");
2096 goto out;
2097 }
2098
2099 10 nummarkers = get_bits(&s->gb, 8);
2100 10 len -= 1;
2101
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
10 if (nummarkers == 0) {
2102 av_log(s->avctx, AV_LOG_WARNING, "Invalid number of markers coded in APP2\n");
2103 goto out;
2104
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
10 } else if (s->iccnum != 0 && nummarkers != s->iccnum) {
2105 av_log(s->avctx, AV_LOG_WARNING, "Mismatch in coded number of ICC markers between markers\n");
2106 goto out;
2107
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
10 } else if (seqno > nummarkers) {
2108 av_log(s->avctx, AV_LOG_WARNING, "Mismatching sequence number and coded number of ICC markers\n");
2109 goto out;
2110 }
2111
2112 /* Allocate if this is the first APP2 we've seen. */
2113
1/2
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
10 if (s->iccnum == 0) {
2114
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
10 if (!FF_ALLOCZ_TYPED_ARRAY(s->iccentries, nummarkers)) {
2115 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data arrays\n");
2116 return AVERROR(ENOMEM);
2117 }
2118 10 s->iccnum = nummarkers;
2119 }
2120
2121
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
10 if (s->iccentries[seqno - 1].data) {
2122 av_log(s->avctx, AV_LOG_WARNING, "Duplicate ICC sequence number\n");
2123 goto out;
2124 }
2125
2126 10 s->iccentries[seqno - 1].length = len;
2127 10 s->iccentries[seqno - 1].data = av_malloc(len);
2128
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
10 if (!s->iccentries[seqno - 1].data) {
2129 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data buffer\n");
2130 return AVERROR(ENOMEM);
2131 }
2132
2133 10 memcpy(s->iccentries[seqno - 1].data, align_get_bits(&s->gb), len);
2134 10 skip_bits(&s->gb, len << 3);
2135 10 len = 0;
2136 10 s->iccread++;
2137
2138
1/2
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
10 if (s->iccread > s->iccnum)
2139 av_log(s->avctx, AV_LOG_WARNING, "Read more ICC markers than are supposed to be coded\n");
2140 }
2141
2142 16 out:
2143 /* slow but needed for extreme adobe jpegs */
2144
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 227 times.
227 if (len < 0)
2145 av_log(s->avctx, AV_LOG_ERROR,
2146 "mjpeg: error, decode_app parser read over the end\n");
2147
2/2
✓ Branch 0 taken 107580 times.
✓ Branch 1 taken 227 times.
107807 while (len-- > 0)
2148 107580 skip_bits(&s->gb, 8);
2149
2150 227 return 0;
2151 }
2152
2153 240 static int mjpeg_decode_com(MJpegDecodeContext *s)
2154 {
2155 240 int len = get_bits(&s->gb, 16);
2156
2/4
✓ Branch 0 taken 240 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 240 times.
✗ Branch 4 not taken.
240 if (len >= 2 && 8 * len - 16 <= get_bits_left(&s->gb)) {
2157 int i;
2158 240 char *cbuf = av_malloc(len - 1);
2159
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 240 times.
240 if (!cbuf)
2160 return AVERROR(ENOMEM);
2161
2162
2/2
✓ Branch 0 taken 3655 times.
✓ Branch 1 taken 240 times.
3895 for (i = 0; i < len - 2; i++)
2163 3655 cbuf[i] = get_bits(&s->gb, 8);
2164
3/4
✓ Branch 0 taken 240 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
✓ Branch 3 taken 230 times.
240 if (i > 0 && cbuf[i - 1] == '\n')
2165 10 cbuf[i - 1] = 0;
2166 else
2167 230 cbuf[i] = 0;
2168
2169
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 240 times.
240 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2170 av_log(s->avctx, AV_LOG_INFO, "comment: '%s'\n", cbuf);
2171
2172 /* buggy avid, it puts EOI only at every 10th frame */
2173
2/2
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 229 times.
240 if (!strncmp(cbuf, "AVID", 4)) {
2174 11 parse_avid(s, cbuf, len);
2175
2/2
✓ Branch 0 taken 205 times.
✓ Branch 1 taken 24 times.
229 } else if (!strcmp(cbuf, "CS=ITU601"))
2176 205 s->cs_itu601 = 1;
2177
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
24 else if ((!strncmp(cbuf, "Intel(R) JPEG Library, version 1", 32) && s->avctx->codec_tag) ||
2178
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.
24 (!strncmp(cbuf, "Metasoft MJPEG Codec", 20)))
2179 s->flipped = 1;
2180
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.
24 else if (!strcmp(cbuf, "MULTISCOPE II")) {
2181 s->avctx->sample_aspect_ratio = (AVRational) { 1, 2 };
2182 s->multiscope = 2;
2183 }
2184
2185 240 av_free(cbuf);
2186 }
2187
2188 240 return 0;
2189 }
2190
2191 /* return the 8 bit start code value and update the search
2192 state. Return -1 if no start code found */
2193 16380 static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
2194 {
2195 const uint8_t *buf_ptr;
2196 unsigned int v, v2;
2197 int val;
2198 16380 int skipped = 0;
2199
2200 16380 buf_ptr = *pbuf_ptr;
2201
2/2
✓ Branch 0 taken 291923 times.
✓ Branch 1 taken 1 times.
291924 while (buf_end - buf_ptr > 1) {
2202 291923 v = *buf_ptr++;
2203 291923 v2 = *buf_ptr;
2204
7/8
✓ Branch 0 taken 19423 times.
✓ Branch 1 taken 272500 times.
✓ Branch 2 taken 16397 times.
✓ Branch 3 taken 3026 times.
✓ Branch 4 taken 16379 times.
✓ Branch 5 taken 18 times.
✓ Branch 6 taken 16379 times.
✗ Branch 7 not taken.
291923 if ((v == 0xff) && (v2 >= SOF0) && (v2 <= COM) && buf_ptr < buf_end) {
2205 16379 val = *buf_ptr++;
2206 16379 goto found;
2207 }
2208 275544 skipped++;
2209 }
2210 1 buf_ptr = buf_end;
2211 1 val = -1;
2212 16380 found:
2213 ff_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
2214 16380 *pbuf_ptr = buf_ptr;
2215 16380 return val;
2216 }
2217
2218 16380 int ff_mjpeg_find_marker(MJpegDecodeContext *s,
2219 const uint8_t **buf_ptr, const uint8_t *buf_end,
2220 const uint8_t **unescaped_buf_ptr,
2221 int *unescaped_buf_size)
2222 {
2223 int start_code;
2224 16380 start_code = find_marker(buf_ptr, buf_end);
2225
2226 16380 av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr);
2227
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16380 times.
16380 if (!s->buffer)
2228 return AVERROR(ENOMEM);
2229
2230 /* unescape buffer of SOS, use special treatment for JPEG-LS */
2231
4/4
✓ Branch 0 taken 2591 times.
✓ Branch 1 taken 13789 times.
✓ Branch 2 taken 2378 times.
✓ Branch 3 taken 213 times.
18758 if (start_code == SOS && !s->ls) {
2232 2378 const uint8_t *src = *buf_ptr;
2233 2378 const uint8_t *ptr = src;
2234 2378 uint8_t *dst = s->buffer;
2235
2236 #define copy_data_segment(skip) do { \
2237 ptrdiff_t length = (ptr - src) - (skip); \
2238 if (length > 0) { \
2239 memcpy(dst, src, length); \
2240 dst += length; \
2241 src = ptr; \
2242 } \
2243 } while (0)
2244
2245
2/2
✓ Branch 0 taken 74 times.
✓ Branch 1 taken 2304 times.
2378 if (s->avctx->codec_id == AV_CODEC_ID_THP) {
2246 74 ptr = buf_end;
2247
1/2
✓ Branch 0 taken 74 times.
✗ Branch 1 not taken.
74 copy_data_segment(0);
2248 } else {
2249
1/2
✓ Branch 0 taken 42092110 times.
✗ Branch 1 not taken.
42094414 while (ptr < buf_end) {
2250 42092110 uint8_t x = *(ptr++);
2251
2252
2/2
✓ Branch 0 taken 41883384 times.
✓ Branch 1 taken 208726 times.
42092110 if (x == 0xff) {
2253 208726 ptrdiff_t skip = 0;
2254
4/4
✓ Branch 0 taken 415228 times.
✓ Branch 1 taken 2236 times.
✓ Branch 2 taken 208738 times.
✓ Branch 3 taken 206490 times.
417464 while (ptr < buf_end && x == 0xff) {
2255 208738 x = *(ptr++);
2256 208738 skip++;
2257 }
2258
2259 /* 0xFF, 0xFF, ... */
2260
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 208720 times.
208726 if (skip > 1) {
2261
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
6 copy_data_segment(skip);
2262
2263 /* decrement src as it is equal to ptr after the
2264 * copy_data_segment macro and we might want to
2265 * copy the current value of x later on */
2266 6 src--;
2267 }
2268
2269
4/4
✓ Branch 0 taken 4907 times.
✓ Branch 1 taken 203819 times.
✓ Branch 2 taken 2257 times.
✓ Branch 3 taken 2650 times.
208726 if (x < RST0 || x > RST7) {
2270
2/2
✓ Branch 0 taken 206070 times.
✓ Branch 1 taken 6 times.
206076 copy_data_segment(1);
2271
2/2
✓ Branch 0 taken 2304 times.
✓ Branch 1 taken 203772 times.
206076 if (x)
2272 2304 break;
2273 }
2274 }
2275 }
2276
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 2298 times.
2304 if (src < ptr)
2277
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
6 copy_data_segment(0);
2278 }
2279 #undef copy_data_segment
2280
2281 2378 *unescaped_buf_ptr = s->buffer;
2282 2378 *unescaped_buf_size = dst - s->buffer;
2283 2378 memset(s->buffer + *unescaped_buf_size, 0,
2284 AV_INPUT_BUFFER_PADDING_SIZE);
2285
2286 2378 av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %"PTRDIFF_SPECIFIER" bytes\n",
2287 2378 (buf_end - *buf_ptr) - (dst - s->buffer));
2288
3/4
✓ Branch 0 taken 213 times.
✓ Branch 1 taken 13789 times.
✓ Branch 2 taken 213 times.
✗ Branch 3 not taken.
14002 } else if (start_code == SOS && s->ls) {
2289 213 const uint8_t *src = *buf_ptr;
2290 213 uint8_t *dst = s->buffer;
2291 213 int bit_count = 0;
2292 213 int t = 0, b = 0;
2293 PutBitContext pb;
2294
2295 /* find marker */
2296
1/2
✓ Branch 0 taken 27487079 times.
✗ Branch 1 not taken.
27487292 while (src + t < buf_end) {
2297 27487079 uint8_t x = src[t++];
2298
2/2
✓ Branch 0 taken 27333028 times.
✓ Branch 1 taken 154051 times.
27487079 if (x == 0xff) {
2299
4/4
✓ Branch 0 taken 307889 times.
✓ Branch 1 taken 213 times.
✓ Branch 2 taken 154051 times.
✓ Branch 3 taken 153838 times.
308102 while ((src + t < buf_end) && x == 0xff)
2300 154051 x = src[t++];
2301
2/2
✓ Branch 0 taken 213 times.
✓ Branch 1 taken 153838 times.
154051 if (x & 0x80) {
2302 213 t -= FFMIN(2, t);
2303 213 break;
2304 }
2305 }
2306 }
2307 213 bit_count = t * 8;
2308 213 init_put_bits(&pb, dst, t);
2309
2310 /* unescape bitstream */
2311
2/2
✓ Branch 0 taken 27486866 times.
✓ Branch 1 taken 213 times.
27487079 while (b < t) {
2312 27486866 uint8_t x = src[b++];
2313 27486866 put_bits(&pb, 8, x);
2314
3/4
✓ Branch 0 taken 153838 times.
✓ Branch 1 taken 27333028 times.
✓ Branch 2 taken 153838 times.
✗ Branch 3 not taken.
27486866 if (x == 0xFF && b < t) {
2315 153838 x = src[b++];
2316
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 153838 times.
153838 if (x & 0x80) {
2317 av_log(s->avctx, AV_LOG_WARNING, "Invalid escape sequence\n");
2318 x &= 0x7f;
2319 }
2320 153838 put_bits(&pb, 7, x);
2321 153838 bit_count--;
2322 }
2323 }
2324 213 flush_put_bits(&pb);
2325
2326 213 *unescaped_buf_ptr = dst;
2327 213 *unescaped_buf_size = (bit_count + 7) >> 3;
2328 213 memset(s->buffer + *unescaped_buf_size, 0,
2329 AV_INPUT_BUFFER_PADDING_SIZE);
2330 } else {
2331 13789 *unescaped_buf_ptr = *buf_ptr;
2332 13789 *unescaped_buf_size = buf_end - *buf_ptr;
2333 }
2334
2335 16380 return start_code;
2336 }
2337
2338 236 static void reset_icc_profile(MJpegDecodeContext *s)
2339 {
2340 int i;
2341
2342
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 226 times.
236 if (s->iccentries) {
2343
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 10 times.
20 for (i = 0; i < s->iccnum; i++)
2344 10 av_freep(&s->iccentries[i].data);
2345 10 av_freep(&s->iccentries);
2346 }
2347
2348 236 s->iccread = 0;
2349 236 s->iccnum = 0;
2350 236 }
2351
2352 2590 int ff_mjpeg_decode_frame_from_buf(AVCodecContext *avctx, AVFrame *frame,
2353 int *got_frame, const AVPacket *avpkt,
2354 const uint8_t *buf, const int buf_size)
2355 {
2356 2590 MJpegDecodeContext *s = avctx->priv_data;
2357 const uint8_t *buf_end, *buf_ptr;
2358 const uint8_t *unescaped_buf_ptr;
2359 int hshift, vshift;
2360 int unescaped_buf_size;
2361 int start_code;
2362 int index;
2363 2590 int ret = 0;
2364 int is16bit;
2365
2366 2590 s->force_pal8 = 0;
2367
2368 2590 s->buf_size = buf_size;
2369
2370 2590 av_exif_free(&s->exif_metadata);
2371 2590 av_freep(&s->stereo3d);
2372 2590 s->adobe_transform = -1;
2373
2374
1/2
✓ Branch 0 taken 2590 times.
✗ Branch 1 not taken.
2590 if (s->iccnum != 0)
2375 reset_icc_profile(s);
2376
2377 2590 redo_for_pal8:
2378 2598 buf_ptr = buf;
2379 2598 buf_end = buf + buf_size;
2380
1/2
✓ Branch 0 taken 16178 times.
✗ Branch 1 not taken.
16178 while (buf_ptr < buf_end) {
2381 /* find start next marker */
2382 16178 start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,
2383 &unescaped_buf_ptr,
2384 &unescaped_buf_size);
2385 /* EOF */
2386
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 16177 times.
16178 if (start_code < 0) {
2387 1 break;
2388
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16177 times.
16177 } else if (unescaped_buf_size > INT_MAX / 8) {
2389 av_log(avctx, AV_LOG_ERROR,
2390 "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
2391 start_code, unescaped_buf_size, buf_size);
2392 return AVERROR_INVALIDDATA;
2393 }
2394 16177 av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%"PTRDIFF_SPECIFIER"\n",
2395 start_code, buf_end - buf_ptr);
2396
2397 16177 ret = init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);
2398
2399
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16177 times.
16177 if (ret < 0) {
2400 av_log(avctx, AV_LOG_ERROR, "invalid buffer\n");
2401 goto fail;
2402 }
2403
2404 16177 s->start_code = start_code;
2405
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16177 times.
16177 if (avctx->debug & FF_DEBUG_STARTCODE)
2406 av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2407
2408 /* process markers */
2409
3/4
✓ Branch 0 taken 11161 times.
✓ Branch 1 taken 5016 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 11161 times.
16177 if (start_code >= RST0 && start_code <= RST7) {
2410 av_log(avctx, AV_LOG_DEBUG,
2411 "restart marker: %d\n", start_code & 0x0f);
2412 /* APP fields */
2413
4/4
✓ Branch 0 taken 704 times.
✓ Branch 1 taken 15473 times.
✓ Branch 2 taken 227 times.
✓ Branch 3 taken 477 times.
16177 } else if (start_code >= APP0 && start_code <= APP15) {
2414
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 227 times.
227 if ((ret = mjpeg_decode_app(s)) < 0)
2415 av_log(avctx, AV_LOG_ERROR, "unable to decode APP fields: %s\n",
2416 av_err2str(ret));
2417 /* Comment */
2418
2/2
✓ Branch 0 taken 240 times.
✓ Branch 1 taken 15710 times.
15950 } else if (start_code == COM) {
2419 240 ret = mjpeg_decode_com(s);
2420
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 240 times.
240 if (ret < 0)
2421 return ret;
2422
2/2
✓ Branch 0 taken 2575 times.
✓ Branch 1 taken 13135 times.
15710 } else if (start_code == DQT) {
2423 2575 ret = ff_mjpeg_decode_dqt(s);
2424
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2575 times.
2575 if (ret < 0)
2425 return ret;
2426 }
2427
2428 16177 ret = -1;
2429
2430 if (!CONFIG_JPEGLS_DECODER &&
2431 (start_code == SOF48 || start_code == LSE)) {
2432 av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");
2433 return AVERROR(ENOSYS);
2434 }
2435
2436
2/2
✓ Branch 0 taken 468 times.
✓ Branch 1 taken 15709 times.
16177 if (avctx->skip_frame == AVDISCARD_ALL) {
2437
2/2
✓ Branch 0 taken 93 times.
✓ Branch 1 taken 375 times.
468 switch(start_code) {
2438 93 case SOF0:
2439 case SOF1:
2440 case SOF2:
2441 case SOF3:
2442 case SOF48:
2443 93 break;
2444 375 default:
2445 375 goto skip;
2446 }
2447 }
2448
2449
11/12
✓ Branch 0 taken 2507 times.
✓ Branch 1 taken 2597 times.
✓ Branch 2 taken 2160 times.
✓ Branch 3 taken 14 times.
✓ Branch 4 taken 205 times.
✓ Branch 5 taken 221 times.
✓ Branch 6 taken 16 times.
✓ Branch 7 taken 2499 times.
✓ Branch 8 taken 2560 times.
✓ Branch 9 taken 216 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 2807 times.
15802 switch (start_code) {
2450 2507 case SOI:
2451 2507 s->restart_interval = 0;
2452 2507 s->restart_count = 0;
2453 2507 s->raw_image_buffer = buf_ptr;
2454 2507 s->raw_image_buffer_size = buf_end - buf_ptr;
2455 /* nothing to do on SOI */
2456 2507 break;
2457 2597 case DHT:
2458
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2597 times.
2597 if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
2459 av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2460 goto fail;
2461 }
2462 2597 break;
2463 2160 case SOF0:
2464 case SOF1:
2465
2/2
✓ Branch 0 taken 2158 times.
✓ Branch 1 taken 2 times.
2160 if (start_code == SOF0)
2466 2158 avctx->profile = AV_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT;
2467 else
2468 2 avctx->profile = AV_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT;
2469 2160 s->lossless = 0;
2470 2160 s->ls = 0;
2471 2160 s->progressive = 0;
2472
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2160 times.
2160 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2473 goto fail;
2474 2160 break;
2475 14 case SOF2:
2476 14 avctx->profile = AV_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT;
2477 14 s->lossless = 0;
2478 14 s->ls = 0;
2479 14 s->progressive = 1;
2480
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
14 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2481 goto fail;
2482 14 break;
2483 205 case SOF3:
2484 205 avctx->profile = AV_PROFILE_MJPEG_HUFFMAN_LOSSLESS;
2485 #if FF_API_CODEC_PROPS
2486 FF_DISABLE_DEPRECATION_WARNINGS
2487 205 avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2488 FF_ENABLE_DEPRECATION_WARNINGS
2489 #endif
2490 205 s->lossless = 1;
2491 205 s->ls = 0;
2492 205 s->progressive = 0;
2493
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 205 times.
205 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2494 goto fail;
2495 205 break;
2496 221 case SOF48:
2497 221 avctx->profile = AV_PROFILE_MJPEG_JPEG_LS;
2498 #if FF_API_CODEC_PROPS
2499 FF_DISABLE_DEPRECATION_WARNINGS
2500 221 avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2501 FF_ENABLE_DEPRECATION_WARNINGS
2502 #endif
2503 221 s->lossless = 1;
2504 221 s->ls = 1;
2505 221 s->progressive = 0;
2506
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 221 times.
221 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2507 goto fail;
2508 221 break;
2509 16 case LSE:
2510
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
16 if (!CONFIG_JPEGLS_DECODER ||
2511 16 (ret = ff_jpegls_decode_lse(s)) < 0)
2512 goto fail;
2513
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 8 times.
16 if (ret == 1)
2514 8 goto redo_for_pal8;
2515 8 break;
2516 case EOI:
2517 2499 eoi_parser:
2518
1/2
✓ Branch 0 taken 2499 times.
✗ Branch 1 not taken.
2499 if (!avctx->hwaccel &&
2519
4/6
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 2492 times.
✓ Branch 2 taken 7 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 7 times.
✗ Branch 5 not taken.
2499 s->progressive && s->cur_scan && s->got_picture)
2520 7 mjpeg_idct_scan_progressive_ac(s);
2521 2499 s->cur_scan = 0;
2522
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2499 times.
2499 if (!s->got_picture) {
2523 av_log(avctx, AV_LOG_WARNING,
2524 "Found EOI before any SOF, ignoring\n");
2525 break;
2526 }
2527
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 2493 times.
2499 if (s->interlaced) {
2528 6 s->bottom_field ^= 1;
2529 /* if not bottom field, do not output image yet */
2530
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 3 times.
6 if (s->bottom_field == !s->interlace_polarity)
2531 3 break;
2532 }
2533
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2496 times.
2496 if (avctx->hwaccel) {
2534 ret = FF_HW_SIMPLE_CALL(avctx, end_frame);
2535 if (ret < 0)
2536 return ret;
2537
2538 av_freep(&s->hwaccel_picture_private);
2539 }
2540
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2496 times.
2496 if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
2541 return ret;
2542
2/2
✓ Branch 0 taken 413 times.
✓ Branch 1 taken 2083 times.
2496 if (s->lossless)
2543 413 frame->flags |= AV_FRAME_FLAG_LOSSLESS;
2544 2496 *got_frame = 1;
2545 2496 s->got_picture = 0;
2546
2547
3/4
✓ Branch 0 taken 2083 times.
✓ Branch 1 taken 413 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2083 times.
2496 if (!s->lossless && avctx->debug & FF_DEBUG_QP) {
2548 int qp = FFMAX3(s->qscale[0],
2549 s->qscale[1],
2550 s->qscale[2]);
2551
2552 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);
2553 }
2554
2555 2496 goto the_end;
2556 2560 case SOS:
2557 2560 s->raw_scan_buffer = buf_ptr;
2558 2560 s->raw_scan_buffer_size = buf_end - buf_ptr;
2559
2560 2560 s->cur_scan++;
2561
2562
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2560 times.
2560 if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&
2563 (avctx->err_recognition & AV_EF_EXPLODE))
2564 goto fail;
2565 2560 break;
2566 216 case DRI:
2567
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 216 times.
216 if ((ret = mjpeg_decode_dri(s)) < 0)
2568 return ret;
2569 216 break;
2570 case SOF5:
2571 case SOF6:
2572 case SOF7:
2573 case SOF9:
2574 case SOF10:
2575 case SOF11:
2576 case SOF13:
2577 case SOF14:
2578 case SOF15:
2579 case JPG:
2580 av_log(avctx, AV_LOG_ERROR,
2581 "mjpeg: unsupported coding type (%x)\n", start_code);
2582 break;
2583 }
2584
2585
2/2
✓ Branch 0 taken 93 times.
✓ Branch 1 taken 13205 times.
13298 if (avctx->skip_frame == AVDISCARD_ALL) {
2586
1/2
✓ Branch 0 taken 93 times.
✗ Branch 1 not taken.
93 switch(start_code) {
2587 93 case SOF0:
2588 case SOF1:
2589 case SOF2:
2590 case SOF3:
2591 case SOF48:
2592 93 s->got_picture = 0;
2593 93 goto the_end_no_picture;
2594 }
2595 }
2596
2597 13205 skip:
2598 /* eof process start code */
2599 13580 buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
2600 27160 av_log(avctx, AV_LOG_DEBUG,
2601 "marker parser used %d bytes (%d bits)\n",
2602 13580 (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
2603 }
2604
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
1 if (s->got_picture && s->cur_scan) {
2605 av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
2606 goto eoi_parser;
2607 }
2608 1 av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
2609 1 return AVERROR_INVALIDDATA;
2610 fail:
2611 s->got_picture = 0;
2612 return ret;
2613 2496 the_end:
2614
2615 2496 is16bit = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].step > 1;
2616
2617
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 2490 times.
2496 if (AV_RB32(s->upscale_h)) {
2618 int p;
2619
15/28
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 4 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 4 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 4 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 3 times.
✓ Branch 11 taken 1 times.
✓ Branch 12 taken 3 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 3 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 3 times.
✗ Branch 17 not taken.
✓ Branch 18 taken 3 times.
✗ Branch 19 not taken.
✓ Branch 20 taken 3 times.
✗ Branch 21 not taken.
✓ Branch 22 taken 3 times.
✗ Branch 23 not taken.
✗ Branch 24 not taken.
✓ Branch 25 taken 3 times.
✗ Branch 26 not taken.
✗ Branch 27 not taken.
6 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2620 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2621 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2622 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2623 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2624 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2625 avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
2626 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2627 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2628 avctx->pix_fmt == AV_PIX_FMT_YUV420P16||
2629 avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2630 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2631 avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2632 avctx->pix_fmt == AV_PIX_FMT_GBRAP
2633 );
2634 6 ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &hshift, &vshift);
2635
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
6 if (ret)
2636 return ret;
2637
2638
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
6 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2639
2/2
✓ Branch 0 taken 18 times.
✓ Branch 1 taken 6 times.
24 for (p = 0; p<s->nb_components; p++) {
2640 18 uint8_t *line = s->picture_ptr->data[p];
2641 18 int w = s->width;
2642 18 int h = s->height;
2643
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 9 times.
18 if (!s->upscale_h[p])
2644 9 continue;
2645
4/4
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 2 times.
9 if (p==1 || p==2) {
2646 7 w = AV_CEIL_RSHIFT(w, hshift);
2647 7 h = AV_CEIL_RSHIFT(h, vshift);
2648 }
2649
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 8 times.
9 if (s->upscale_v[p] == 1)
2650 1 h = (h+1)>>1;
2651
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
9 av_assert0(w > 0);
2652
2/2
✓ Branch 0 taken 534 times.
✓ Branch 1 taken 9 times.
543 for (int i = 0; i < h; i++) {
2653
2/2
✓ Branch 0 taken 214 times.
✓ Branch 1 taken 320 times.
534 if (s->upscale_h[p] == 1) {
2654
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 214 times.
214 if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];
2655 214 else line[w - 1] = line[(w - 1) / 2];
2656
2/2
✓ Branch 0 taken 11220 times.
✓ Branch 1 taken 214 times.
11434 for (index = w - 2; index > 0; index--) {
2657
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11220 times.
11220 if (is16bit)
2658 ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;
2659 else
2660 11220 line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
2661 }
2662
2/2
✓ Branch 0 taken 256 times.
✓ Branch 1 taken 64 times.
320 } else if (s->upscale_h[p] == 2) {
2663
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 256 times.
256 if (is16bit) {
2664 ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3];
2665 if (w > 1)
2666 ((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1];
2667 } else {
2668 256 line[w - 1] = line[(w - 1) / 3];
2669
1/2
✓ Branch 0 taken 256 times.
✗ Branch 1 not taken.
256 if (w > 1)
2670 256 line[w - 2] = line[w - 1];
2671 }
2672
2/2
✓ Branch 0 taken 15616 times.
✓ Branch 1 taken 256 times.
15872 for (index = w - 3; index > 0; index--) {
2673 15616 line[index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3;
2674 }
2675
1/2
✓ Branch 0 taken 64 times.
✗ Branch 1 not taken.
64 } else if (s->upscale_h[p] == 4){
2676
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 64 times.
64 if (is16bit) {
2677 uint16_t *line16 = (uint16_t *) line;
2678 line16[w - 1] = line16[(w - 1) >> 2];
2679 if (w > 1)
2680 line16[w - 2] = (line16[(w - 1) >> 2] * 3 + line16[(w - 2) >> 2]) >> 2;
2681 if (w > 2)
2682 line16[w - 3] = (line16[(w - 1) >> 2] + line16[(w - 2) >> 2]) >> 1;
2683 } else {
2684 64 line[w - 1] = line[(w - 1) >> 2];
2685
1/2
✓ Branch 0 taken 64 times.
✗ Branch 1 not taken.
64 if (w > 1)
2686 64 line[w - 2] = (line[(w - 1) >> 2] * 3 + line[(w - 2) >> 2]) >> 2;
2687
1/2
✓ Branch 0 taken 64 times.
✗ Branch 1 not taken.
64 if (w > 2)
2688 64 line[w - 3] = (line[(w - 1) >> 2] + line[(w - 2) >> 2]) >> 1;
2689 }
2690
2/2
✓ Branch 0 taken 3840 times.
✓ Branch 1 taken 64 times.
3904 for (index = w - 4; index > 0; index--)
2691 3840 line[index] = (line[(index + 3) >> 2] + line[(index + 2) >> 2]
2692 3840 + line[(index + 1) >> 2] + line[index >> 2]) >> 2;
2693 }
2694 534 line += s->linesize[p];
2695 }
2696 }
2697 }
2698
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2495 times.
2496 if (AV_RB32(s->upscale_v)) {
2699 int p;
2700
12/26
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 1 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 1 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 1 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 1 times.
✗ Branch 17 not taken.
✓ Branch 18 taken 1 times.
✗ Branch 19 not taken.
✓ Branch 20 taken 1 times.
✗ Branch 21 not taken.
✗ Branch 22 not taken.
✓ Branch 23 taken 1 times.
✗ Branch 24 not taken.
✗ Branch 25 not taken.
1 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2701 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2702 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2703 avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
2704 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2705 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2706 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2707 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2708 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2709 avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2710 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2711 avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2712 avctx->pix_fmt == AV_PIX_FMT_GBRAP
2713 );
2714 1 ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &hshift, &vshift);
2715
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
1 if (ret)
2716 return ret;
2717
2718
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
1 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2719
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1 times.
4 for (p = 0; p < s->nb_components; p++) {
2720 uint8_t *dst;
2721 3 int w = s->width;
2722 3 int h = s->height;
2723
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 times.
3 if (!s->upscale_v[p])
2724 2 continue;
2725
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
1 if (p==1 || p==2) {
2726 1 w = AV_CEIL_RSHIFT(w, hshift);
2727 1 h = AV_CEIL_RSHIFT(h, vshift);
2728 }
2729 1 dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];
2730
2/2
✓ Branch 0 taken 42 times.
✓ Branch 1 taken 1 times.
43 for (int i = h - 1; i; i--) {
2731 42 uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2732 42 uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2733
4/6
✓ Branch 0 taken 42 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 21 times.
✓ Branch 3 taken 21 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 21 times.
42 if (s->upscale_v[p] != 2 && (src1 == src2 || i == h - 1)) {
2734 21 memcpy(dst, src1, w);
2735 } else {
2736
2/2
✓ Branch 0 taken 1344 times.
✓ Branch 1 taken 21 times.
1365 for (index = 0; index < w; index++)
2737 1344 dst[index] = (src1[index] + src2[index]) >> 1;
2738 }
2739 42 dst -= s->linesize[p];
2740 }
2741 }
2742 }
2743
3/4
✓ Branch 0 taken 368 times.
✓ Branch 1 taken 2128 times.
✓ Branch 2 taken 368 times.
✗ Branch 3 not taken.
2496 if (s->flipped && !s->rgb) {
2744 368 ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &hshift, &vshift);
2745
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 368 times.
368 if (ret)
2746 return ret;
2747
2748
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 368 times.
368 av_assert0(s->nb_components == av_pix_fmt_count_planes(frame->format));
2749
2/2
✓ Branch 0 taken 1104 times.
✓ Branch 1 taken 368 times.
1472 for (index=0; index<s->nb_components; index++) {
2750 1104 int h = frame->height;
2751
3/4
✓ Branch 0 taken 736 times.
✓ Branch 1 taken 368 times.
✓ Branch 2 taken 736 times.
✗ Branch 3 not taken.
1104 if (index && index < 3)
2752 736 h = AV_CEIL_RSHIFT(h, vshift);
2753
1/2
✓ Branch 0 taken 1104 times.
✗ Branch 1 not taken.
1104 if (frame->data[index]) {
2754 1104 frame->data[index] += (h - 1) * frame->linesize[index];
2755 1104 frame->linesize[index] *= -1;
2756 }
2757 }
2758 }
2759
2760
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 2491 times.
2496 if (avctx->pix_fmt == AV_PIX_FMT_GBRP) {
2761
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
5 av_assert0(s->nb_components == 3);
2762 5 FFSWAP(uint8_t *, frame->data[0], frame->data[2]);
2763 5 FFSWAP(uint8_t *, frame->data[0], frame->data[1]);
2764 5 FFSWAP(int, frame->linesize[0], frame->linesize[2]);
2765 5 FFSWAP(int, frame->linesize[0], frame->linesize[1]);
2766 }
2767
2768
3/4
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 2492 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
2496 if (s->adobe_transform == 0 && avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
2769 int w = s->picture_ptr->width;
2770 int h = s->picture_ptr->height;
2771 av_assert0(s->nb_components == 4);
2772 for (int i = 0; i < h; i++) {
2773 int j;
2774 uint8_t *dst[4];
2775 for (index=0; index<4; index++) {
2776 dst[index] = s->picture_ptr->data[index]
2777 + s->picture_ptr->linesize[index]*i;
2778 }
2779 for (j=0; j<w; j++) {
2780 int k = dst[3][j];
2781 int r = dst[0][j] * k;
2782 int g = dst[1][j] * k;
2783 int b = dst[2][j] * k;
2784 dst[0][j] = g*257 >> 16;
2785 dst[1][j] = b*257 >> 16;
2786 dst[2][j] = r*257 >> 16;
2787 }
2788 memset(dst[3], 255, w);
2789 }
2790 }
2791
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 2496 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
2496 if (s->adobe_transform == 2 && avctx->pix_fmt == AV_PIX_FMT_YUVA444P) {
2792 int w = s->picture_ptr->width;
2793 int h = s->picture_ptr->height;
2794 av_assert0(s->nb_components == 4);
2795 for (int i = 0; i < h; i++) {
2796 int j;
2797 uint8_t *dst[4];
2798 for (index=0; index<4; index++) {
2799 dst[index] = s->picture_ptr->data[index]
2800 + s->picture_ptr->linesize[index]*i;
2801 }
2802 for (j=0; j<w; j++) {
2803 int k = dst[3][j];
2804 int r = (255 - dst[0][j]) * k;
2805 int g = (128 - dst[1][j]) * k;
2806 int b = (128 - dst[2][j]) * k;
2807 dst[0][j] = r*257 >> 16;
2808 dst[1][j] = (g*257 >> 16) + 128;
2809 dst[2][j] = (b*257 >> 16) + 128;
2810 }
2811 memset(dst[3], 255, w);
2812 }
2813 }
2814
2815
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2496 times.
2496 if (s->stereo3d) {
2816 AVStereo3D *stereo = av_stereo3d_create_side_data(frame);
2817 if (stereo) {
2818 stereo->type = s->stereo3d->type;
2819 stereo->flags = s->stereo3d->flags;
2820 }
2821 av_freep(&s->stereo3d);
2822 }
2823
2824
3/4
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 2491 times.
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
2496 if (s->iccnum != 0 && s->iccnum == s->iccread) {
2825 AVFrameSideData *sd;
2826 5 size_t offset = 0;
2827 5 int total_size = 0;
2828
2829 /* Sum size of all parts. */
2830
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 5 times.
10 for (int i = 0; i < s->iccnum; i++)
2831 5 total_size += s->iccentries[i].length;
2832
2833 5 ret = ff_frame_new_side_data(avctx, frame, AV_FRAME_DATA_ICC_PROFILE, total_size, &sd);
2834
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
5 if (ret < 0) {
2835 av_log(avctx, AV_LOG_ERROR, "Could not allocate frame side data\n");
2836 return ret;
2837 }
2838
2839
1/2
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
5 if (sd) {
2840 /* Reassemble the parts, which are now in-order. */
2841
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 5 times.
10 for (int i = 0; i < s->iccnum; i++) {
2842 5 memcpy(sd->data + offset, s->iccentries[i].data, s->iccentries[i].length);
2843 5 offset += s->iccentries[i].length;
2844 }
2845 }
2846 }
2847
2848
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 2489 times.
2496 if (s->exif_metadata.entries) {
2849 7 ret = ff_decode_exif_attach_ifd(avctx, frame, &s->exif_metadata);
2850 7 av_exif_free(&s->exif_metadata);
2851
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
7 if (ret < 0)
2852 av_log(avctx, AV_LOG_WARNING, "couldn't attach EXIF metadata\n");
2853 }
2854
2855
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 2493 times.
2496 if (avctx->codec_id != AV_CODEC_ID_SMVJPEG &&
2856
1/2
✓ Branch 0 taken 2493 times.
✗ Branch 1 not taken.
2493 (avctx->codec_tag == MKTAG('A', 'V', 'R', 'n') ||
2857
2/2
✓ Branch 0 taken 2483 times.
✓ Branch 1 taken 10 times.
2493 avctx->codec_tag == MKTAG('A', 'V', 'D', 'J')) &&
2858
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
10 avctx->coded_height > s->orig_height) {
2859 10 frame->height = AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres);
2860 10 frame->crop_top = frame->height - avctx->height;
2861 }
2862
2863 2486 the_end_no_picture:
2864 2589 av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n",
2865 buf_end - buf_ptr);
2866 2589 return buf_ptr - buf;
2867 }
2868
2869 2211 int ff_mjpeg_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame,
2870 AVPacket *avpkt)
2871 {
2872 4422 return ff_mjpeg_decode_frame_from_buf(avctx, frame, got_frame,
2873 2211 avpkt, avpkt->data, avpkt->size);
2874 }
2875
2876
2877 /* mxpeg may call the following function (with a blank MJpegDecodeContext)
2878 * even without having called ff_mjpeg_decode_init(). */
2879 236 av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
2880 {
2881 236 MJpegDecodeContext *s = avctx->priv_data;
2882 int i, j;
2883
2884
3/8
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 227 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 9 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
236 if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_num) {
2885 av_log(avctx, AV_LOG_INFO, "Single field\n");
2886 }
2887
2888 236 av_frame_free(&s->picture);
2889 236 s->picture_ptr = NULL;
2890
2891 236 av_frame_free(&s->smv_frame);
2892
2893 236 av_freep(&s->buffer);
2894 236 av_freep(&s->stereo3d);
2895 236 av_freep(&s->ljpeg_buffer);
2896 236 s->ljpeg_buffer_size = 0;
2897
2898
2/2
✓ Branch 0 taken 708 times.
✓ Branch 1 taken 236 times.
944 for (i = 0; i < 3; i++) {
2899
2/2
✓ Branch 0 taken 2832 times.
✓ Branch 1 taken 708 times.
3540 for (j = 0; j < 4; j++)
2900 2832 ff_vlc_free(&s->vlcs[i][j]);
2901 }
2902
2/2
✓ Branch 0 taken 944 times.
✓ Branch 1 taken 236 times.
1180 for (i = 0; i < MAX_COMPONENTS; i++) {
2903 944 av_freep(&s->blocks[i]);
2904 944 av_freep(&s->last_nnz[i]);
2905 }
2906 236 av_exif_free(&s->exif_metadata);
2907
2908 236 reset_icc_profile(s);
2909
2910 236 av_freep(&s->hwaccel_picture_private);
2911 236 av_freep(&s->jls_state);
2912
2913 236 return 0;
2914 }
2915
2916 6 static av_cold void decode_flush(AVCodecContext *avctx)
2917 {
2918 6 MJpegDecodeContext *s = avctx->priv_data;
2919 6 s->got_picture = 0;
2920
2921 6 s->smv_next_frame = 0;
2922 6 av_frame_unref(s->smv_frame);
2923 6 }
2924
2925 #if CONFIG_MJPEG_DECODER
2926 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
2927 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2928 static const AVOption options[] = {
2929 { "extern_huff", "Use external huffman table.",
2930 OFFSET(extern_huff), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
2931 { NULL },
2932 };
2933
2934 static const AVClass mjpegdec_class = {
2935 .class_name = "MJPEG decoder",
2936 .item_name = av_default_item_name,
2937 .option = options,
2938 .version = LIBAVUTIL_VERSION_INT,
2939 };
2940
2941 const FFCodec ff_mjpeg_decoder = {
2942 .p.name = "mjpeg",
2943 CODEC_LONG_NAME("MJPEG (Motion JPEG)"),
2944 .p.type = AVMEDIA_TYPE_VIDEO,
2945 .p.id = AV_CODEC_ID_MJPEG,
2946 .priv_data_size = sizeof(MJpegDecodeContext),
2947 .init = ff_mjpeg_decode_init,
2948 .close = ff_mjpeg_decode_end,
2949 FF_CODEC_DECODE_CB(ff_mjpeg_decode_frame),
2950 .flush = decode_flush,
2951 .p.capabilities = AV_CODEC_CAP_DR1,
2952 .p.max_lowres = 3,
2953 .p.priv_class = &mjpegdec_class,
2954 .p.profiles = NULL_IF_CONFIG_SMALL(ff_mjpeg_profiles),
2955 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP |
2956 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM |
2957 FF_CODEC_CAP_ICC_PROFILES,
2958 .hw_configs = (const AVCodecHWConfigInternal *const []) {
2959 #if CONFIG_MJPEG_NVDEC_HWACCEL
2960 HWACCEL_NVDEC(mjpeg),
2961 #endif
2962 #if CONFIG_MJPEG_VAAPI_HWACCEL
2963 HWACCEL_VAAPI(mjpeg),
2964 #endif
2965 NULL
2966 },
2967 };
2968 #endif
2969 #if CONFIG_THP_DECODER
2970 const FFCodec ff_thp_decoder = {
2971 .p.name = "thp",
2972 CODEC_LONG_NAME("Nintendo Gamecube THP video"),
2973 .p.type = AVMEDIA_TYPE_VIDEO,
2974 .p.id = AV_CODEC_ID_THP,
2975 .priv_data_size = sizeof(MJpegDecodeContext),
2976 .init = ff_mjpeg_decode_init,
2977 .close = ff_mjpeg_decode_end,
2978 FF_CODEC_DECODE_CB(ff_mjpeg_decode_frame),
2979 .flush = decode_flush,
2980 .p.capabilities = AV_CODEC_CAP_DR1,
2981 .p.max_lowres = 3,
2982 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
2983 };
2984 #endif
2985
2986 #if CONFIG_SMVJPEG_DECODER
2987 // SMV JPEG just stacks several output frames into one JPEG picture
2988 // we handle that by setting up the cropping parameters appropriately
2989 13 static void smv_process_frame(AVCodecContext *avctx, AVFrame *frame)
2990 {
2991 13 MJpegDecodeContext *s = avctx->priv_data;
2992
2993
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 av_assert0((s->smv_next_frame + 1) * avctx->height <= avctx->coded_height);
2994
2995 13 frame->width = avctx->coded_width;
2996 13 frame->height = avctx->coded_height;
2997 13 frame->crop_top = FFMIN(s->smv_next_frame * avctx->height, frame->height);
2998 13 frame->crop_bottom = frame->height - (s->smv_next_frame + 1) * avctx->height;
2999
3000
1/2
✓ Branch 0 taken 13 times.
✗ Branch 1 not taken.
13 if (s->smv_frame->pts != AV_NOPTS_VALUE)
3001 13 s->smv_frame->pts += s->smv_frame->duration;
3002 13 s->smv_next_frame = (s->smv_next_frame + 1) % s->smv_frames_per_jpeg;
3003
3004
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 11 times.
13 if (s->smv_next_frame == 0)
3005 2 av_frame_unref(s->smv_frame);
3006 13 }
3007
3008 16 static int smvjpeg_receive_frame(AVCodecContext *avctx, AVFrame *frame)
3009 {
3010 16 MJpegDecodeContext *s = avctx->priv_data;
3011 16 AVPacket *const pkt = avctx->internal->in_pkt;
3012 16 int got_frame = 0;
3013 int ret;
3014
3015
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 6 times.
16 if (s->smv_next_frame > 0)
3016 10 goto return_frame;
3017
3018 6 ret = ff_decode_get_packet(avctx, pkt);
3019
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 3 times.
6 if (ret < 0)
3020 3 return ret;
3021
3022 3 av_frame_unref(s->smv_frame);
3023
3024 3 ret = ff_mjpeg_decode_frame(avctx, s->smv_frame, &got_frame, pkt);
3025 3 s->smv_frame->pkt_dts = pkt->dts;
3026 3 av_packet_unref(pkt);
3027
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
3 if (ret < 0)
3028 return ret;
3029
3030
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
3 if (!got_frame)
3031 return AVERROR(EAGAIN);
3032
3033 // packet duration covers all the frames in the packet
3034 3 s->smv_frame->duration /= s->smv_frames_per_jpeg;
3035
3036 13 return_frame:
3037
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 av_assert0(s->smv_frame->buf[0]);
3038 13 ret = av_frame_ref(frame, s->smv_frame);
3039
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 if (ret < 0)
3040 return ret;
3041
3042 13 smv_process_frame(avctx, frame);
3043 13 return 0;
3044 }
3045
3046 const FFCodec ff_smvjpeg_decoder = {
3047 .p.name = "smvjpeg",
3048 CODEC_LONG_NAME("SMV JPEG"),
3049 .p.type = AVMEDIA_TYPE_VIDEO,
3050 .p.id = AV_CODEC_ID_SMVJPEG,
3051 .priv_data_size = sizeof(MJpegDecodeContext),
3052 .init = ff_mjpeg_decode_init,
3053 .close = ff_mjpeg_decode_end,
3054 FF_CODEC_RECEIVE_FRAME_CB(smvjpeg_receive_frame),
3055 .flush = decode_flush,
3056 .p.capabilities = AV_CODEC_CAP_DR1,
3057 .caps_internal = FF_CODEC_CAP_EXPORTS_CROPPING |
3058 FF_CODEC_CAP_INIT_CLEANUP,
3059 };
3060 #endif
3061