FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/mjpegdec.c
Date: 2025-10-10 03:51:19
Exec Total Coverage
Lines: 1222 1816 67.3%
Functions: 32 33 97.0%
Branches: 907 1677 54.1%

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
2/2
✓ Branch 0 taken 485 times.
✓ Branch 1 taken 33972645 times.
33973130 if (code > MIN_CACHE_BITS - 16)
858 485 UPDATE_CACHE(re, &s->gb);
859
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
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6037 times.
6037 if (code > MIN_CACHE_BITS - 16)
922 UPDATE_CACHE(re, &s->gb);
923
924 {
925 6037 int cache = GET_CACHE(re, &s->gb);
926 6037 int sign = (~cache) >> 31;
927 6037 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
928 }
929
930 6037 LAST_SKIP_BITS(re, &s->gb, code);
931
932
2/2
✓ Branch 0 taken 139 times.
✓ Branch 1 taken 5898 times.
6037 if (i >= se) {
933
1/2
✓ Branch 0 taken 139 times.
✗ Branch 1 not taken.
139 if (i == se) {
934 139 j = s->permutated_scantable[se];
935 139 block[j] = level * (quant_matrix[se] << Al);
936 139 break;
937 }
938 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
939 return AVERROR_INVALIDDATA;
940 }
941 5898 j = s->permutated_scantable[i];
942 5898 block[j] = level * (quant_matrix[i] << Al);
943 } else {
944
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 857 times.
869 if (run == 0xF) {// ZRL - skip 15 coefficients
945 12 i += 15;
946
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
12 if (i >= se) {
947 av_log(s->avctx, AV_LOG_ERROR, "ZRL overflow: %d\n", i);
948 return AVERROR_INVALIDDATA;
949 }
950 } else {
951 857 val = (1 << run);
952
2/2
✓ Branch 0 taken 149 times.
✓ Branch 1 taken 708 times.
857 if (run) {
953 149 UPDATE_CACHE(re, &s->gb);
954 149 val += NEG_USR32(GET_CACHE(re, &s->gb), run);
955 149 LAST_SKIP_BITS(re, &s->gb, run);
956 }
957 857 *EOBRUN = val - 1;
958 857 break;
959 }
960 }
961 }
962 996 CLOSE_READER(re, &s->gb);
963 }
964
965
1/2
✓ Branch 0 taken 996 times.
✗ Branch 1 not taken.
996 if (i > *last_nnz)
966 996 *last_nnz = i;
967
968 996 return 0;
969 }
970
971 #define REFINE_BIT(j) { \
972 UPDATE_CACHE(re, &s->gb); \
973 sign = block[j] >> 15; \
974 block[j] += SHOW_UBITS(re, &s->gb, 1) * \
975 ((quant_matrix[i] ^ sign) - sign) << Al; \
976 LAST_SKIP_BITS(re, &s->gb, 1); \
977 }
978
979 #define ZERO_RUN \
980 for (; ; i++) { \
981 if (i > last) { \
982 i += run; \
983 if (i > se) { \
984 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \
985 return -1; \
986 } \
987 break; \
988 } \
989 j = s->permutated_scantable[i]; \
990 if (block[j]) \
991 REFINE_BIT(j) \
992 else if (run-- == 0) \
993 break; \
994 }
995
996 /* decode block and dequantize - progressive JPEG refinement pass */
997 1080 static int decode_block_refinement(MJpegDecodeContext *s, int16_t *block,
998 uint8_t *last_nnz,
999 int ac_index, uint16_t *quant_matrix,
1000 int ss, int se, int Al, int *EOBRUN)
1001 {
1002 1080 int code, i = ss, j, sign, val, run;
1003 1080 int last = FFMIN(se, *last_nnz);
1004
1005 1080 OPEN_READER(re, &s->gb);
1006
2/2
✓ Branch 0 taken 120 times.
✓ Branch 1 taken 960 times.
1080 if (*EOBRUN) {
1007 120 (*EOBRUN)--;
1008 } else {
1009 9339 for (; ; i++) {
1010 9339 UPDATE_CACHE(re, &s->gb);
1011
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);
1012
1013
2/2
✓ Branch 0 taken 9342 times.
✓ Branch 1 taken 957 times.
10299 if (code & 0xF) {
1014 9342 run = ((unsigned) code) >> 4;
1015 9342 UPDATE_CACHE(re, &s->gb);
1016 9342 val = SHOW_UBITS(re, &s->gb, 1);
1017 9342 LAST_SKIP_BITS(re, &s->gb, 1);
1018
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;
1019 9342 j = s->permutated_scantable[i];
1020 9342 val--;
1021 9342 block[j] = ((quant_matrix[i] << Al) ^ val) - val;
1022
2/2
✓ Branch 0 taken 63 times.
✓ Branch 1 taken 9279 times.
9342 if (i == se) {
1023
1/2
✓ Branch 0 taken 63 times.
✗ Branch 1 not taken.
63 if (i > *last_nnz)
1024 63 *last_nnz = i;
1025 63 CLOSE_READER(re, &s->gb);
1026 63 return 0;
1027 }
1028 } else {
1029 957 run = ((unsigned) code) >> 4;
1030
2/2
✓ Branch 0 taken 60 times.
✓ Branch 1 taken 897 times.
957 if (run == 0xF) {
1031
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;
1032 } else {
1033 897 val = run;
1034 897 run = (1 << run);
1035
2/2
✓ Branch 0 taken 23 times.
✓ Branch 1 taken 874 times.
897 if (val) {
1036 23 UPDATE_CACHE(re, &s->gb);
1037 23 run += SHOW_UBITS(re, &s->gb, val);
1038 23 LAST_SKIP_BITS(re, &s->gb, val);
1039 }
1040 897 *EOBRUN = run - 1;
1041 897 break;
1042 }
1043 }
1044 }
1045
1046
2/2
✓ Branch 0 taken 804 times.
✓ Branch 1 taken 93 times.
897 if (i > *last_nnz)
1047 804 *last_nnz = i;
1048 }
1049
1050
2/2
✓ Branch 0 taken 879 times.
✓ Branch 1 taken 1017 times.
1896 for (; i <= last; i++) {
1051 879 j = s->permutated_scantable[i];
1052
2/2
✓ Branch 0 taken 188 times.
✓ Branch 1 taken 691 times.
879 if (block[j])
1053 188 REFINE_BIT(j)
1054 }
1055 1017 CLOSE_READER(re, &s->gb);
1056
1057 1017 return 0;
1058 }
1059 #undef REFINE_BIT
1060 #undef ZERO_RUN
1061
1062 810549 static int handle_rstn(MJpegDecodeContext *s, int nb_components)
1063 {
1064 int i;
1065 810549 int reset = 0;
1066
1067
2/2
✓ Branch 0 taken 59850 times.
✓ Branch 1 taken 750699 times.
810549 if (s->restart_interval) {
1068 59850 s->restart_count--;
1069
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){
1070 align_get_bits(&s->gb);
1071 for (i = 0; i < nb_components; i++) /* reset dc */
1072 s->last_dc[i] = (4 << s->bits);
1073 }
1074
1075 59850 i = 8 + ((-get_bits_count(&s->gb)) & 7);
1076 /* skip RSTn */
1077
2/2
✓ Branch 0 taken 2850 times.
✓ Branch 1 taken 57000 times.
59850 if (s->restart_count == 0) {
1078
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2850 times.
2850 if( show_bits(&s->gb, i) == (1 << i) - 1
1079 || show_bits(&s->gb, i) == 0xFF) {
1080 2850 int pos = get_bits_count(&s->gb);
1081 2850 align_get_bits(&s->gb);
1082
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)
1083 2850 skip_bits(&s->gb, 8);
1084
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) {
1085
2/2
✓ Branch 0 taken 7950 times.
✓ Branch 1 taken 2650 times.
10600 for (i = 0; i < nb_components; i++) /* reset dc */
1086 7950 s->last_dc[i] = (4 << s->bits);
1087 2650 reset = 1;
1088 } else
1089 200 skip_bits_long(&s->gb, pos - get_bits_count(&s->gb));
1090 }
1091 }
1092 }
1093 810549 return reset;
1094 }
1095
1096 /* Handles 1 to 4 components */
1097 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int nb_components, int predictor, int point_transform)
1098 {
1099 int i, mb_x, mb_y;
1100 unsigned width;
1101 uint16_t (*buffer)[4];
1102 int left[4], top[4], topleft[4];
1103 const int linesize = s->linesize[0];
1104 const int mask = ((1 << s->bits) - 1) << point_transform;
1105 int resync_mb_y = 0;
1106 int resync_mb_x = 0;
1107 int vpred[6];
1108 int ret;
1109
1110 if (!s->bayer && s->nb_components < 3)
1111 return AVERROR_INVALIDDATA;
1112 if (s->bayer && s->nb_components > 2)
1113 return AVERROR_INVALIDDATA;
1114 if (s->nb_components <= 0 || s->nb_components > 4)
1115 return AVERROR_INVALIDDATA;
1116 if (s->v_max != 1 || s->h_max != 1 || !s->lossless)
1117 return AVERROR_INVALIDDATA;
1118 if (s->bayer) {
1119 if (s->rct || s->pegasus_rct)
1120 return AVERROR_INVALIDDATA;
1121 }
1122
1123
1124 s->restart_count = s->restart_interval;
1125
1126 if (s->restart_interval == 0)
1127 s->restart_interval = INT_MAX;
1128
1129 if (s->bayer)
1130 width = s->mb_width / nb_components; /* Interleaved, width stored is the total so need to divide */
1131 else
1132 width = s->mb_width;
1133
1134 av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size, width * 4 * sizeof(s->ljpeg_buffer[0][0]));
1135 if (!s->ljpeg_buffer)
1136 return AVERROR(ENOMEM);
1137
1138 buffer = s->ljpeg_buffer;
1139
1140 for (i = 0; i < 4; i++)
1141 buffer[0][i] = 1 << (s->bits - 1);
1142
1143 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1144 uint8_t *ptr = s->picture_ptr->data[0] + (linesize * mb_y);
1145
1146 if (s->interlaced && s->bottom_field)
1147 ptr += linesize >> 1;
1148
1149 for (i = 0; i < 4; i++)
1150 top[i] = left[i] = topleft[i] = buffer[0][i];
1151
1152 if ((mb_y * s->width) % s->restart_interval == 0) {
1153 for (i = 0; i < 6; i++)
1154 vpred[i] = 1 << (s->bits-1);
1155 }
1156
1157 for (mb_x = 0; mb_x < width; mb_x++) {
1158 int modified_predictor = predictor;
1159
1160 if (get_bits_left(&s->gb) < 1) {
1161 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in rgb_scan\n");
1162 return AVERROR_INVALIDDATA;
1163 }
1164
1165 if (s->restart_interval && !s->restart_count){
1166 s->restart_count = s->restart_interval;
1167 resync_mb_x = mb_x;
1168 resync_mb_y = mb_y;
1169 for(i=0; i<4; i++)
1170 top[i] = left[i]= topleft[i]= 1 << (s->bits - 1);
1171 }
1172 if (mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || !mb_x)
1173 modified_predictor = 1;
1174
1175 for (i=0;i<nb_components;i++) {
1176 int pred, dc;
1177
1178 topleft[i] = top[i];
1179 top[i] = buffer[mb_x][i];
1180
1181 ret = mjpeg_decode_dc(s, s->dc_index[i], &dc);
1182 if (ret < 0)
1183 return ret;
1184
1185 if (!s->bayer || mb_x) {
1186 pred = left[i];
1187 } else { /* This path runs only for the first line in bayer images */
1188 vpred[i] += dc;
1189 pred = vpred[i] - dc;
1190 }
1191
1192 PREDICT(pred, topleft[i], top[i], pred, modified_predictor);
1193
1194 left[i] = buffer[mb_x][i] =
1195 mask & (pred + (unsigned)(dc * (1 << point_transform)));
1196 }
1197
1198 if (s->restart_interval && !--s->restart_count) {
1199 align_get_bits(&s->gb);
1200 skip_bits(&s->gb, 16); /* skip RSTn */
1201 }
1202 }
1203 if (s->rct && s->nb_components == 4) {
1204 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1205 ptr[4*mb_x + 2] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1206 ptr[4*mb_x + 1] = buffer[mb_x][1] + ptr[4*mb_x + 2];
1207 ptr[4*mb_x + 3] = buffer[mb_x][2] + ptr[4*mb_x + 2];
1208 ptr[4*mb_x + 0] = buffer[mb_x][3];
1209 }
1210 } else if (s->nb_components == 4) {
1211 for(i=0; i<nb_components; i++) {
1212 int c= s->comp_index[i];
1213 if (s->bits <= 8) {
1214 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1215 ptr[4*mb_x+3-c] = buffer[mb_x][i];
1216 }
1217 } else if(s->bits == 9) {
1218 return AVERROR_PATCHWELCOME;
1219 } else {
1220 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1221 ((uint16_t*)ptr)[4*mb_x+c] = buffer[mb_x][i];
1222 }
1223 }
1224 }
1225 } else if (s->rct) {
1226 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1227 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1228 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1229 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1230 }
1231 } else if (s->pegasus_rct) {
1232 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1233 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2]) >> 2);
1234 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1235 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1236 }
1237 } else if (s->bayer) {
1238 if (s->bits <= 8)
1239 return AVERROR_PATCHWELCOME;
1240 if (nb_components == 1) {
1241 /* Leave decoding to the TIFF/DNG decoder (see comment in ff_mjpeg_decode_sof) */
1242 for (mb_x = 0; mb_x < width; mb_x++)
1243 ((uint16_t*)ptr)[mb_x] = buffer[mb_x][0];
1244 } else if (nb_components == 2) {
1245 for (mb_x = 0; mb_x < width; mb_x++) {
1246 ((uint16_t*)ptr)[2*mb_x + 0] = buffer[mb_x][0];
1247 ((uint16_t*)ptr)[2*mb_x + 1] = buffer[mb_x][1];
1248 }
1249 }
1250 } else {
1251 for(i=0; i<nb_components; i++) {
1252 int c= s->comp_index[i];
1253 if (s->bits <= 8) {
1254 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1255 ptr[3*mb_x+2-c] = buffer[mb_x][i];
1256 }
1257 } else if(s->bits == 9) {
1258 return AVERROR_PATCHWELCOME;
1259 } else {
1260 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1261 ((uint16_t*)ptr)[3*mb_x+2-c] = buffer[mb_x][i];
1262 }
1263 }
1264 }
1265 }
1266 }
1267 return 0;
1268 }
1269
1270 200 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
1271 int point_transform, int nb_components)
1272 {
1273 int i, mb_x, mb_y, mask;
1274 200 int bits= (s->bits+7)&~7;
1275 200 int resync_mb_y = 0;
1276 200 int resync_mb_x = 0;
1277 int ret;
1278
1279 200 point_transform += bits - s->bits;
1280 200 mask = ((1 << s->bits) - 1) << point_transform;
1281
1282
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);
1283
1284
2/2
✓ Branch 0 taken 22450 times.
✓ Branch 1 taken 200 times.
22650 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1285
2/2
✓ Branch 0 taken 3816050 times.
✓ Branch 1 taken 22450 times.
3838500 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1286
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3816050 times.
3816050 if (get_bits_left(&s->gb) < 1) {
1287 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in yuv_scan\n");
1288 return AVERROR_INVALIDDATA;
1289 }
1290
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){
1291 s->restart_count = s->restart_interval;
1292 resync_mb_x = mb_x;
1293 resync_mb_y = mb_y;
1294 }
1295
1296
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){
1297
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;
1298
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;
1299
2/2
✓ Branch 0 taken 148500 times.
✓ Branch 1 taken 49500 times.
198000 for (i = 0; i < nb_components; i++) {
1300 uint8_t *ptr;
1301 uint16_t *ptr16;
1302 int n, h, v, x, y, c, j, linesize;
1303 148500 n = s->nb_blocks[i];
1304 148500 c = s->comp_index[i];
1305 148500 h = s->h_scount[i];
1306 148500 v = s->v_scount[i];
1307 148500 x = 0;
1308 148500 y = 0;
1309 148500 linesize= s->linesize[c];
1310
1311
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 148500 times.
148500 if(bits>8) linesize /= 2;
1312
1313
2/2
✓ Branch 0 taken 297000 times.
✓ Branch 1 taken 148500 times.
445500 for(j=0; j<n; j++) {
1314 int pred, dc;
1315
1316 297000 ret = mjpeg_decode_dc(s, s->dc_index[i], &dc);
1317
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 297000 times.
297000 if (ret < 0)
1318 return ret;
1319
1320
1/2
✓ Branch 0 taken 297000 times.
✗ Branch 1 not taken.
297000 if ( h * mb_x + x >= s->width
1321
1/2
✓ Branch 0 taken 297000 times.
✗ Branch 1 not taken.
297000 || v * mb_y + y >= s->height) {
1322 // Nothing to do
1323
1/2
✓ Branch 0 taken 297000 times.
✗ Branch 1 not taken.
297000 } else if (bits<=8) {
1324 297000 ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1325
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){
1326
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){
1327 600 pred= 1 << (bits - 1);
1328 }else{
1329 108400 pred= ptr[-1];
1330 }
1331 }else{
1332
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){
1333 89200 pred= ptr[-linesize];
1334 }else{
1335
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);
1336 }
1337 }
1338
1339
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)
1340 ptr += linesize >> 1;
1341 297000 pred &= mask;
1342 297000 *ptr= pred + ((unsigned)dc << point_transform);
1343 }else{
1344 ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1345 if(y==0 && toprow){
1346 if(x==0 && leftcol){
1347 pred= 1 << (bits - 1);
1348 }else{
1349 pred= ptr16[-1];
1350 }
1351 }else{
1352 if(x==0 && leftcol){
1353 pred= ptr16[-linesize];
1354 }else{
1355 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1356 }
1357 }
1358
1359 if (s->interlaced && s->bottom_field)
1360 ptr16 += linesize >> 1;
1361 pred &= mask;
1362 *ptr16= pred + ((unsigned)dc << point_transform);
1363 }
1364
2/2
✓ Branch 0 taken 198000 times.
✓ Branch 1 taken 99000 times.
297000 if (++x == h) {
1365 198000 x = 0;
1366 198000 y++;
1367 }
1368 }
1369 }
1370 } else {
1371
2/2
✓ Branch 0 taken 11299650 times.
✓ Branch 1 taken 3766550 times.
15066200 for (i = 0; i < nb_components; i++) {
1372 uint8_t *ptr;
1373 uint16_t *ptr16;
1374 int n, h, v, x, y, c, j, linesize, dc;
1375 11299650 n = s->nb_blocks[i];
1376 11299650 c = s->comp_index[i];
1377 11299650 h = s->h_scount[i];
1378 11299650 v = s->v_scount[i];
1379 11299650 x = 0;
1380 11299650 y = 0;
1381 11299650 linesize = s->linesize[c];
1382
1383
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11299650 times.
11299650 if(bits>8) linesize /= 2;
1384
1385
2/2
✓ Branch 0 taken 22599300 times.
✓ Branch 1 taken 11299650 times.
33898950 for (j = 0; j < n; j++) {
1386 int pred;
1387
1388 22599300 ret = mjpeg_decode_dc(s, s->dc_index[i], &dc);
1389
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 22599300 times.
22599300 if (ret < 0)
1390 return ret;
1391
1392
1/2
✓ Branch 0 taken 22599300 times.
✗ Branch 1 not taken.
22599300 if ( h * mb_x + x >= s->width
1393
1/2
✓ Branch 0 taken 22599300 times.
✗ Branch 1 not taken.
22599300 || v * mb_y + y >= s->height) {
1394 // Nothing to do
1395
1/2
✓ Branch 0 taken 22599300 times.
✗ Branch 1 not taken.
22599300 } else if (bits<=8) {
1396 22599300 ptr = s->picture_ptr->data[c] +
1397 22599300 (linesize * (v * mb_y + y)) +
1398 22599300 (h * mb_x + x); //FIXME optimize this crap
1399
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);
1400
1401 22599300 pred &= mask;
1402 22599300 *ptr = pred + ((unsigned)dc << point_transform);
1403 }else{
1404 ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1405 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1406
1407 pred &= mask;
1408 *ptr16= pred + ((unsigned)dc << point_transform);
1409 }
1410
1411
2/2
✓ Branch 0 taken 15066200 times.
✓ Branch 1 taken 7533100 times.
22599300 if (++x == h) {
1412 15066200 x = 0;
1413 15066200 y++;
1414 }
1415 }
1416 }
1417 }
1418
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) {
1419 align_get_bits(&s->gb);
1420 skip_bits(&s->gb, 16); /* skip RSTn */
1421 }
1422 }
1423 }
1424 200 return 0;
1425 }
1426
1427 786684 static av_always_inline void mjpeg_copy_block(MJpegDecodeContext *s,
1428 uint8_t *dst, const uint8_t *src,
1429 int linesize, int lowres)
1430 {
1431
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) {
1432 786684 case 0: s->copy_block(dst, src, linesize, 8);
1433 786684 break;
1434 case 1: copy_block4(dst, src, linesize, linesize, 4);
1435 break;
1436 case 2: copy_block2(dst, src, linesize, linesize, 2);
1437 break;
1438 case 3: *dst = *src;
1439 break;
1440 }
1441 786684 }
1442
1443 11750 static void shift_output(MJpegDecodeContext *s, uint8_t *ptr, int linesize)
1444 {
1445 int block_x, block_y;
1446 11750 int size = 8 >> s->avctx->lowres;
1447
1/2
✓ Branch 0 taken 11750 times.
✗ Branch 1 not taken.
11750 if (s->bits > 8) {
1448
2/2
✓ Branch 0 taken 94000 times.
✓ Branch 1 taken 11750 times.
105750 for (block_y=0; block_y<size; block_y++)
1449
2/2
✓ Branch 0 taken 752000 times.
✓ Branch 1 taken 94000 times.
846000 for (block_x=0; block_x<size; block_x++)
1450 752000 *(uint16_t*)(ptr + 2*block_x + block_y*linesize) <<= 16 - s->bits;
1451 } else {
1452 for (block_y=0; block_y<size; block_y++)
1453 for (block_x=0; block_x<size; block_x++)
1454 *(ptr + block_x + block_y*linesize) <<= 8 - s->bits;
1455 }
1456 11750 }
1457
1458 2151 static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
1459 int Al, const uint8_t *mb_bitmask,
1460 int mb_bitmask_size,
1461 const AVFrame *reference)
1462 {
1463 int i, mb_x, mb_y, chroma_h_shift, chroma_v_shift, chroma_width, chroma_height;
1464 uint8_t *data[MAX_COMPONENTS];
1465 const uint8_t *reference_data[MAX_COMPONENTS];
1466 int linesize[MAX_COMPONENTS];
1467 2151 GetBitContext mb_bitmask_gb = {0}; // initialize to silence gcc warning
1468
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2150 times.
2151 int bytes_per_pixel = 1 + (s->bits > 8);
1469
1470
2/2
✓ Branch 0 taken 31 times.
✓ Branch 1 taken 2120 times.
2151 if (mb_bitmask) {
1471
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 31 times.
31 if (mb_bitmask_size != (s->mb_width * s->mb_height + 7)>>3) {
1472 av_log(s->avctx, AV_LOG_ERROR, "mb_bitmask_size mismatches\n");
1473 return AVERROR_INVALIDDATA;
1474 }
1475 31 init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
1476 }
1477
1478 2151 s->restart_count = 0;
1479
1480 2151 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &chroma_h_shift,
1481 &chroma_v_shift);
1482 2151 chroma_width = AV_CEIL_RSHIFT(s->width, chroma_h_shift);
1483 2151 chroma_height = AV_CEIL_RSHIFT(s->height, chroma_v_shift);
1484
1485
2/2
✓ Branch 0 taken 6445 times.
✓ Branch 1 taken 2151 times.
8596 for (i = 0; i < nb_components; i++) {
1486 6445 int c = s->comp_index[i];
1487 6445 data[c] = s->picture_ptr->data[c];
1488
2/2
✓ Branch 0 taken 93 times.
✓ Branch 1 taken 6352 times.
6445 reference_data[c] = reference ? reference->data[c] : NULL;
1489 6445 linesize[c] = s->linesize[c];
1490 6445 s->coefs_finished[c] |= 1;
1491 }
1492
1493
2/2
✓ Branch 0 taken 28923 times.
✓ Branch 1 taken 2151 times.
31074 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1494
2/2
✓ Branch 0 taken 808133 times.
✓ Branch 1 taken 28923 times.
837056 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1495
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);
1496
1497
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)
1498 2850 s->restart_count = s->restart_interval;
1499
1500
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 808133 times.
808133 if (get_bits_left(&s->gb) < 0) {
1501 av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",
1502 -get_bits_left(&s->gb));
1503 return AVERROR_INVALIDDATA;
1504 }
1505
2/2
✓ Branch 0 taken 2400683 times.
✓ Branch 1 taken 808133 times.
3208816 for (i = 0; i < nb_components; i++) {
1506 uint8_t *ptr;
1507 int n, h, v, x, y, c, j;
1508 int block_offset;
1509 2400683 n = s->nb_blocks[i];
1510 2400683 c = s->comp_index[i];
1511 2400683 h = s->h_scount[i];
1512 2400683 v = s->v_scount[i];
1513 2400683 x = 0;
1514 2400683 y = 0;
1515
2/2
✓ Branch 0 taken 4821902 times.
✓ Branch 1 taken 2400683 times.
7222585 for (j = 0; j < n; j++) {
1516 4821902 block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
1517 4821902 (h * mb_x + x) * 8 * bytes_per_pixel) >> s->avctx->lowres);
1518
1519
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)
1520 45280 block_offset += linesize[c] >> 1;
1521
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)
1522
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)) {
1523 4813344 ptr = data[c] + block_offset;
1524 } else
1525 8558 ptr = NULL;
1526
2/2
✓ Branch 0 taken 4821026 times.
✓ Branch 1 taken 876 times.
4821902 if (!s->progressive) {
1527
2/2
✓ Branch 0 taken 786684 times.
✓ Branch 1 taken 4034342 times.
4821026 if (copy_mb) {
1528
1/2
✓ Branch 0 taken 786684 times.
✗ Branch 1 not taken.
786684 if (ptr)
1529 786684 mjpeg_copy_block(s, ptr, reference_data[c] + block_offset,
1530 786684 linesize[c], s->avctx->lowres);
1531
1532 } else {
1533 4034342 s->bdsp.clear_block(s->block);
1534
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4034342 times.
4034342 if (decode_block(s, s->block, i,
1535 s->dc_index[i], s->ac_index[i],
1536 4034342 s->quant_matrixes[s->quant_sindex[i]]) < 0) {
1537 av_log(s->avctx, AV_LOG_ERROR,
1538 "error y=%d x=%d\n", mb_y, mb_x);
1539 return AVERROR_INVALIDDATA;
1540 }
1541
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]) {
1542 4025800 s->idsp.idct_put(ptr, linesize[c], s->block);
1543
2/2
✓ Branch 0 taken 11750 times.
✓ Branch 1 taken 4014050 times.
4025800 if (s->bits & 7)
1544 11750 shift_output(s, ptr, linesize[c]);
1545 }
1546 }
1547 } else {
1548 876 int block_idx = s->block_stride[c] * (v * mb_y + y) +
1549 876 (h * mb_x + x);
1550 876 int16_t *block = s->blocks[c][block_idx];
1551
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 876 times.
876 if (Ah)
1552 block[0] += get_bits1(&s->gb) *
1553 s->quant_matrixes[s->quant_sindex[i]][0] << Al;
1554
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 876 times.
876 else if (decode_dc_progressive(s, block, i, s->dc_index[i],
1555 876 s->quant_matrixes[s->quant_sindex[i]],
1556 Al) < 0) {
1557 av_log(s->avctx, AV_LOG_ERROR,
1558 "error y=%d x=%d\n", mb_y, mb_x);
1559 return AVERROR_INVALIDDATA;
1560 }
1561 }
1562 ff_dlog(s->avctx, "mb: %d %d processed\n", mb_y, mb_x);
1563 ff_dlog(s->avctx, "%d %d %d %d %d %d %d %d \n",
1564 mb_x, mb_y, x, y, c, s->bottom_field,
1565 (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1566
2/2
✓ Branch 0 taken 3512577 times.
✓ Branch 1 taken 1309325 times.
4821902 if (++x == h) {
1567 3512577 x = 0;
1568 3512577 y++;
1569 }
1570 }
1571 }
1572
1573 808133 handle_rstn(s, nb_components);
1574 }
1575 }
1576 2151 return 0;
1577 }
1578
1579 59 static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss,
1580 int se, int Ah, int Al)
1581 {
1582 int mb_x, mb_y;
1583 59 int EOBRUN = 0;
1584 59 int c = s->comp_index[0];
1585 59 uint16_t *quant_matrix = s->quant_matrixes[s->quant_sindex[0]];
1586
1587
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);
1588
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) {
1589 av_log(s->avctx, AV_LOG_ERROR, "SS/SE %d/%d is invalid\n", ss, se);
1590 return AVERROR_INVALIDDATA;
1591 }
1592
1593 // s->coefs_finished is a bitmask for coefficients coded
1594 // ss and se are parameters telling start and end coefficients
1595 59 s->coefs_finished[c] |= (2ULL << se) - (1ULL << ss);
1596
1597 59 s->restart_count = 0;
1598
1599
2/2
✓ Branch 0 taken 412 times.
✓ Branch 1 taken 59 times.
471 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1600 412 int block_idx = mb_y * s->block_stride[c];
1601 412 int16_t (*block)[64] = &s->blocks[c][block_idx];
1602 412 uint8_t *last_nnz = &s->last_nnz[c][block_idx];
1603
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 412 times.
412 if (get_bits_left(&s->gb) <= 0) {
1604 av_log(s->avctx, AV_LOG_ERROR, "bitstream truncated in mjpeg_decode_scan_progressive_ac\n");
1605 return AVERROR_INVALIDDATA;
1606 }
1607
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++) {
1608 int ret;
1609
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)
1610 s->restart_count = s->restart_interval;
1611
1612
2/2
✓ Branch 0 taken 1080 times.
✓ Branch 1 taken 1336 times.
2416 if (Ah)
1613 1080 ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0],
1614 quant_matrix, ss, se, Al, &EOBRUN);
1615 else
1616 1336 ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0],
1617 quant_matrix, ss, se, Al, &EOBRUN);
1618
1619
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)
1620 ret = AVERROR_INVALIDDATA;
1621
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2416 times.
2416 if (ret < 0) {
1622 av_log(s->avctx, AV_LOG_ERROR,
1623 "error y=%d x=%d\n", mb_y, mb_x);
1624 return AVERROR_INVALIDDATA;
1625 }
1626
1627
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2416 times.
2416 if (handle_rstn(s, 0))
1628 EOBRUN = 0;
1629 }
1630 }
1631 59 return 0;
1632 }
1633
1634 7 static void mjpeg_idct_scan_progressive_ac(MJpegDecodeContext *s)
1635 {
1636 int mb_x, mb_y;
1637 int c;
1638
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
7 const int bytes_per_pixel = 1 + (s->bits > 8);
1639
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
7 const int block_size = s->lossless ? 1 : 8;
1640
1641
2/2
✓ Branch 0 taken 21 times.
✓ Branch 1 taken 7 times.
28 for (c = 0; c < s->nb_components; c++) {
1642 21 uint8_t *data = s->picture_ptr->data[c];
1643 21 int linesize = s->linesize[c];
1644 21 int h = s->h_max / s->h_count[c];
1645 21 int v = s->v_max / s->v_count[c];
1646 21 int mb_width = (s->width + h * block_size - 1) / (h * block_size);
1647 21 int mb_height = (s->height + v * block_size - 1) / (v * block_size);
1648
1649
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 21 times.
21 if (~s->coefs_finished[c])
1650 av_log(s->avctx, AV_LOG_WARNING, "component %d is incomplete\n", c);
1651
1652
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)
1653 data += linesize >> 1;
1654
1655
2/2
✓ Branch 0 taken 153 times.
✓ Branch 1 taken 21 times.
174 for (mb_y = 0; mb_y < mb_height; mb_y++) {
1656 153 uint8_t *ptr = data + (mb_y * linesize * 8 >> s->avctx->lowres);
1657 153 int block_idx = mb_y * s->block_stride[c];
1658 153 int16_t (*block)[64] = &s->blocks[c][block_idx];
1659
2/2
✓ Branch 0 taken 860 times.
✓ Branch 1 taken 153 times.
1013 for (mb_x = 0; mb_x < mb_width; mb_x++, block++) {
1660 860 s->idsp.idct_put(ptr, linesize, *block);
1661
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 860 times.
860 if (s->bits & 7)
1662 shift_output(s, ptr, linesize);
1663 860 ptr += bytes_per_pixel*8 >> s->avctx->lowres;
1664 }
1665 }
1666 }
1667 7 }
1668
1669 2623 int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
1670 int mb_bitmask_size, const AVFrame *reference)
1671 {
1672 int len, nb_components, i, h, v, predictor, point_transform;
1673 int index, id, ret;
1674
2/2
✓ Branch 0 taken 413 times.
✓ Branch 1 taken 2210 times.
2623 const int block_size = s->lossless ? 1 : 8;
1675 int ilv, prev_shift;
1676
1677
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2623 times.
2623 if (!s->got_picture) {
1678 av_log(s->avctx, AV_LOG_WARNING,
1679 "Can not process SOS before SOF, skipping\n");
1680 return -1;
1681 }
1682
1683 /* XXX: verify len field validity */
1684 2623 len = get_bits(&s->gb, 16);
1685 2623 nb_components = get_bits(&s->gb, 8);
1686
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) {
1687 avpriv_report_missing_feature(s->avctx,
1688 "decode_sos: nb_components (%d)",
1689 nb_components);
1690 return AVERROR_PATCHWELCOME;
1691 }
1692
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2623 times.
2623 if (len != 6 + 2 * nb_components) {
1693 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1694 return AVERROR_INVALIDDATA;
1695 }
1696
2/2
✓ Branch 0 taken 7727 times.
✓ Branch 1 taken 2623 times.
10350 for (i = 0; i < nb_components; i++) {
1697 7727 id = get_bits(&s->gb, 8);
1698 7727 av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1699 /* find component index */
1700
1/2
✓ Branch 0 taken 15443 times.
✗ Branch 1 not taken.
15443 for (index = 0; index < s->nb_components; index++)
1701
2/2
✓ Branch 0 taken 7727 times.
✓ Branch 1 taken 7716 times.
15443 if (id == s->component_id[index])
1702 7727 break;
1703
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7727 times.
7727 if (index == s->nb_components) {
1704 av_log(s->avctx, AV_LOG_ERROR,
1705 "decode_sos: index(%d) out of components\n", index);
1706 return AVERROR_INVALIDDATA;
1707 }
1708 /* Metasoft MJPEG codec has Cb and Cr swapped */
1709
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7727 times.
7727 if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
1710 && nb_components == 3 && s->nb_components == 3 && i)
1711 index = 3 - i;
1712
1713 7727 s->quant_sindex[i] = s->quant_index[index];
1714 7727 s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1715 7727 s->h_scount[i] = s->h_count[index];
1716 7727 s->v_scount[i] = s->v_count[index];
1717
1718 7727 s->comp_index[i] = index;
1719
1720 7727 s->dc_index[i] = get_bits(&s->gb, 4);
1721 7727 s->ac_index[i] = get_bits(&s->gb, 4);
1722
1723
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 ||
1724
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)
1725 goto out_of_range;
1726
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))
1727 goto out_of_range;
1728 }
1729
1730 2623 predictor = get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1731 2623 ilv = get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */
1732
1/2
✓ Branch 0 taken 2623 times.
✗ Branch 1 not taken.
2623 if(s->avctx->codec_tag != AV_RL32("CJPG")){
1733 2623 prev_shift = get_bits(&s->gb, 4); /* Ah */
1734 2623 point_transform = get_bits(&s->gb, 4); /* Al */
1735 }else
1736 prev_shift = point_transform = 0;
1737
1738
2/2
✓ Branch 0 taken 2552 times.
✓ Branch 1 taken 71 times.
2623 if (nb_components > 1) {
1739 /* interleaved stream */
1740 2552 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1741 2552 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1742
2/2
✓ Branch 0 taken 63 times.
✓ Branch 1 taken 8 times.
71 } else if (!s->ls) { /* skip this for JPEG-LS */
1743 63 h = s->h_max / s->h_scount[0];
1744 63 v = s->v_max / s->v_scount[0];
1745 63 s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1746 63 s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1747 63 s->nb_blocks[0] = 1;
1748 63 s->h_scount[0] = 1;
1749 63 s->v_scount[0] = 1;
1750 }
1751
1752
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2623 times.
2623 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1753 av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n",
1754 s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",
1755 predictor, point_transform, ilv, s->bits, s->mjpb_skiptosod,
1756 s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), nb_components);
1757
1758
1759 /* mjpeg-b can have padding bytes between sos and image data, skip them */
1760
2/2
✓ Branch 0 taken 1342 times.
✓ Branch 1 taken 2623 times.
3965 for (i = s->mjpb_skiptosod; i > 0; i--)
1761 1342 skip_bits(&s->gb, 8);
1762
1763 2623 next_field:
1764
2/2
✓ Branch 0 taken 7727 times.
✓ Branch 1 taken 2623 times.
10350 for (i = 0; i < nb_components; i++)
1765 7727 s->last_dc[i] = (4 << s->bits);
1766
1767
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2623 times.
2623 if (s->avctx->hwaccel) {
1768 int bytes_to_start = get_bits_count(&s->gb) / 8;
1769 av_assert0(bytes_to_start >= 0 &&
1770 s->raw_scan_buffer_size >= bytes_to_start);
1771
1772 ret = FF_HW_CALL(s->avctx, decode_slice,
1773 s->raw_scan_buffer + bytes_to_start,
1774 s->raw_scan_buffer_size - bytes_to_start);
1775 if (ret < 0)
1776 return ret;
1777
1778
2/2
✓ Branch 0 taken 413 times.
✓ Branch 1 taken 2210 times.
2623 } else if (s->lossless) {
1779
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 413 times.
413 av_assert0(s->picture_ptr == s->picture);
1780
2/2
✓ Branch 0 taken 213 times.
✓ Branch 1 taken 200 times.
413 if (CONFIG_JPEGLS_DECODER && s->ls) {
1781 // for () {
1782 // reset_ls_coding_parameters(s, 0);
1783
1784
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 213 times.
213 if ((ret = ff_jpegls_decode_picture(s, predictor,
1785 point_transform, ilv)) < 0)
1786 return ret;
1787 } else {
1788
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) {
1789 if ((ret = ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform)) < 0)
1790 return ret;
1791 } else {
1792
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 200 times.
200 if ((ret = ljpeg_decode_yuv_scan(s, predictor,
1793 point_transform,
1794 nb_components)) < 0)
1795 return ret;
1796 }
1797 }
1798 } else {
1799
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) {
1800
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 59 times.
59 av_assert0(s->picture_ptr == s->picture);
1801
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 59 times.
59 if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor,
1802 ilv, prev_shift,
1803 point_transform)) < 0)
1804 return ret;
1805 } else {
1806
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2151 times.
2151 if ((ret = mjpeg_decode_scan(s, nb_components,
1807 prev_shift, point_transform,
1808 mb_bitmask, mb_bitmask_size, reference)) < 0)
1809 return ret;
1810 }
1811 }
1812
1813
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 &&
1814
2/2
✓ Branch 1 taken 10 times.
✓ Branch 2 taken 15 times.
63 get_bits_left(&s->gb) > 32 &&
1815 25 show_bits(&s->gb, 8) == 0xFF) {
1816 10 GetBitContext bak = s->gb;
1817 10 align_get_bits(&bak);
1818
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
10 if (show_bits(&bak, 16) == 0xFFD1) {
1819 av_log(s->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n");
1820 s->gb = bak;
1821 skip_bits(&s->gb, 16);
1822 s->bottom_field ^= 1;
1823
1824 goto next_field;
1825 }
1826 }
1827
1828 2623 emms_c();
1829 2623 return 0;
1830 out_of_range:
1831 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1832 return AVERROR_INVALIDDATA;
1833 }
1834
1835 216 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1836 {
1837
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 216 times.
216 if (get_bits(&s->gb, 16) != 4)
1838 return AVERROR_INVALIDDATA;
1839 216 s->restart_interval = get_bits(&s->gb, 16);
1840 216 s->restart_count = 0;
1841 216 av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
1842 s->restart_interval);
1843
1844 216 return 0;
1845 }
1846
1847 227 static int mjpeg_decode_app(MJpegDecodeContext *s)
1848 {
1849 int len, id, i;
1850
1851 227 len = get_bits(&s->gb, 16);
1852
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 227 times.
227 if (len < 2)
1853 return AVERROR_INVALIDDATA;
1854 227 len -= 2;
1855
1856
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 227 times.
227 if (len < 4) {
1857 if (s->avctx->err_recognition & AV_EF_EXPLODE)
1858 return AVERROR_INVALIDDATA;
1859 av_log(s->avctx, AV_LOG_VERBOSE, "skipping APPx stub (len=%" PRId32 ")\n", len);
1860 goto out;
1861 }
1862
1863
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 227 times.
227 if (8 * len > get_bits_left(&s->gb))
1864 return AVERROR_INVALIDDATA;
1865
1866 227 id = get_bits_long(&s->gb, 32);
1867 227 len -= 4;
1868
1869
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 227 times.
227 if (s->avctx->debug & FF_DEBUG_STARTCODE)
1870 av_log(s->avctx, AV_LOG_DEBUG, "APPx (%s / %8X) len=%d\n",
1871 av_fourcc2str(av_bswap32(id)), id, len);
1872
1873 /* Buggy AVID, it puts EOI only at every 10th frame. */
1874 /* Also, this fourcc is used by non-avid files too, it holds some
1875 information, but it's always present in AVID-created files. */
1876
2/2
✓ Branch 0 taken 18 times.
✓ Branch 1 taken 209 times.
227 if (id == AV_RB32("AVI1")) {
1877 /* structure:
1878 4bytes AVI1
1879 1bytes polarity
1880 1bytes always zero
1881 4bytes field_size
1882 4bytes field_size_less_padding
1883 */
1884 18 s->buggy_avid = 1;
1885 18 i = get_bits(&s->gb, 8); len--;
1886 18 av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i);
1887 18 goto out;
1888 }
1889
1890
2/2
✓ Branch 0 taken 148 times.
✓ Branch 1 taken 61 times.
209 if (id == AV_RB32("JFIF")) {
1891 int t_w, t_h, v1, v2;
1892
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 148 times.
148 if (len < 8)
1893 goto out;
1894 148 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1895 148 v1 = get_bits(&s->gb, 8);
1896 148 v2 = get_bits(&s->gb, 8);
1897 148 skip_bits(&s->gb, 8);
1898
1899 148 s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 16);
1900 148 s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16);
1901
1/2
✓ Branch 0 taken 148 times.
✗ Branch 1 not taken.
148 if ( s->avctx->sample_aspect_ratio.num <= 0
1902
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 148 times.
148 || s->avctx->sample_aspect_ratio.den <= 0) {
1903 s->avctx->sample_aspect_ratio.num = 0;
1904 s->avctx->sample_aspect_ratio.den = 1;
1905 }
1906
1907
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 148 times.
148 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1908 av_log(s->avctx, AV_LOG_INFO,
1909 "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1910 v1, v2,
1911 s->avctx->sample_aspect_ratio.num,
1912 s->avctx->sample_aspect_ratio.den);
1913
1914 148 len -= 8;
1915
2/2
✓ Branch 0 taken 146 times.
✓ Branch 1 taken 2 times.
148 if (len >= 2) {
1916 146 t_w = get_bits(&s->gb, 8);
1917 146 t_h = get_bits(&s->gb, 8);
1918
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) {
1919 /* skip thumbnail */
1920 if (len -10 - (t_w * t_h * 3) > 0)
1921 len -= t_w * t_h * 3;
1922 }
1923 146 len -= 2;
1924 }
1925 148 goto out;
1926 }
1927
1928
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 48 times.
61 if ( id == AV_RB32("Adob")
1929
1/2
✓ Branch 0 taken 13 times.
✗ Branch 1 not taken.
13 && len >= 8
1930
1/2
✓ Branch 1 taken 13 times.
✗ Branch 2 not taken.
13 && show_bits(&s->gb, 8) == 'e'
1931
1/2
✓ Branch 1 taken 13 times.
✗ Branch 2 not taken.
13 && show_bits_long(&s->gb, 32) != AV_RB32("e_CM")) {
1932 13 skip_bits(&s->gb, 8); /* 'e' */
1933 13 skip_bits(&s->gb, 16); /* version */
1934 13 skip_bits(&s->gb, 16); /* flags0 */
1935 13 skip_bits(&s->gb, 16); /* flags1 */
1936 13 s->adobe_transform = get_bits(&s->gb, 8);
1937
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1938 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found, transform=%d\n", s->adobe_transform);
1939 13 len -= 8;
1940 13 goto out;
1941 }
1942
1943
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 48 times.
48 if (id == AV_RB32("LJIF")) {
1944 int rgb = s->rgb;
1945 int pegasus_rct = s->pegasus_rct;
1946 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1947 av_log(s->avctx, AV_LOG_INFO,
1948 "Pegasus lossless jpeg header found\n");
1949 skip_bits(&s->gb, 16); /* version ? */
1950 skip_bits(&s->gb, 16); /* unknown always 0? */
1951 skip_bits(&s->gb, 16); /* unknown always 0? */
1952 skip_bits(&s->gb, 16); /* unknown always 0? */
1953 switch (i=get_bits(&s->gb, 8)) {
1954 case 1:
1955 rgb = 1;
1956 pegasus_rct = 0;
1957 break;
1958 case 2:
1959 rgb = 1;
1960 pegasus_rct = 1;
1961 break;
1962 default:
1963 av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace %d\n", i);
1964 }
1965
1966 len -= 9;
1967 if (s->bayer)
1968 goto out;
1969 if (s->got_picture)
1970 if (rgb != s->rgb || pegasus_rct != s->pegasus_rct) {
1971 av_log(s->avctx, AV_LOG_WARNING, "Mismatching LJIF tag\n");
1972 goto out;
1973 }
1974
1975 s->rgb = rgb;
1976 s->pegasus_rct = pegasus_rct;
1977
1978 goto out;
1979 }
1980
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) {
1981 8 s->colr = get_bits(&s->gb, 8);
1982
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
8 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1983 av_log(s->avctx, AV_LOG_INFO, "COLR %d\n", s->colr);
1984 8 len --;
1985 8 goto out;
1986 }
1987
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) {
1988 s->xfrm = get_bits(&s->gb, 8);
1989 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1990 av_log(s->avctx, AV_LOG_INFO, "XFRM %d\n", s->xfrm);
1991 len --;
1992 goto out;
1993 }
1994
1995 /* JPS extension by VRex */
1996
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) {
1997 int flags, layout, type;
1998 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1999 av_log(s->avctx, AV_LOG_INFO, "_JPSJPS_\n");
2000
2001 skip_bits(&s->gb, 32); len -= 4; /* JPS_ */
2002 skip_bits(&s->gb, 16); len -= 2; /* block length */
2003 skip_bits(&s->gb, 8); /* reserved */
2004 flags = get_bits(&s->gb, 8);
2005 layout = get_bits(&s->gb, 8);
2006 type = get_bits(&s->gb, 8);
2007 len -= 4;
2008
2009 av_freep(&s->stereo3d);
2010 s->stereo3d = av_stereo3d_alloc();
2011 if (!s->stereo3d) {
2012 goto out;
2013 }
2014 if (type == 0) {
2015 s->stereo3d->type = AV_STEREO3D_2D;
2016 } else if (type == 1) {
2017 switch (layout) {
2018 case 0x01:
2019 s->stereo3d->type = AV_STEREO3D_LINES;
2020 break;
2021 case 0x02:
2022 s->stereo3d->type = AV_STEREO3D_SIDEBYSIDE;
2023 break;
2024 case 0x03:
2025 s->stereo3d->type = AV_STEREO3D_TOPBOTTOM;
2026 break;
2027 }
2028 if (!(flags & 0x04)) {
2029 s->stereo3d->flags = AV_STEREO3D_FLAG_INVERT;
2030 }
2031 }
2032 goto out;
2033 }
2034
2035 /* EXIF metadata */
2036
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) {
2037 int ret;
2038 const uint8_t *aligned;
2039
2040 24 skip_bits(&s->gb, 16); // skip padding
2041 24 len -= 2;
2042
2043 // init byte wise reading
2044 24 aligned = align_get_bits(&s->gb);
2045
2046 24 ret = av_exif_parse_buffer(s->avctx, aligned, len, &s->exif_metadata, AV_EXIF_TIFF_HEADER);
2047
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.
24 if (ret < 0) {
2048 av_log(s->avctx, AV_LOG_WARNING, "unable to parse EXIF buffer\n");
2049 goto out;
2050 }
2051
2052 24 skip_bits(&s->gb, ret << 3);
2053 24 len -= ret;
2054
2055 24 goto out;
2056 }
2057
2058 /* Apple MJPEG-A */
2059
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))) {
2060 2 id = get_bits_long(&s->gb, 32);
2061 2 len -= 4;
2062 /* Apple MJPEG-A */
2063
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 if (id == AV_RB32("mjpg")) {
2064 /* structure:
2065 4bytes field size
2066 4bytes pad field size
2067 4bytes next off
2068 4bytes quant off
2069 4bytes huff off
2070 4bytes image off
2071 4bytes scan off
2072 4bytes data off
2073 */
2074 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2075 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
2076 }
2077 }
2078
2079
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) {
2080 int id2;
2081 unsigned seqno;
2082 unsigned nummarkers;
2083
2084 10 id = get_bits_long(&s->gb, 32);
2085 10 id2 = get_bits(&s->gb, 24);
2086 10 len -= 7;
2087
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")) {
2088 av_log(s->avctx, AV_LOG_WARNING, "Invalid ICC_PROFILE header in APP2\n");
2089 goto out;
2090 }
2091
2092 10 skip_bits(&s->gb, 8);
2093 10 seqno = get_bits(&s->gb, 8);
2094 10 len -= 2;
2095
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
10 if (seqno == 0) {
2096 av_log(s->avctx, AV_LOG_WARNING, "Invalid sequence number in APP2\n");
2097 goto out;
2098 }
2099
2100 10 nummarkers = get_bits(&s->gb, 8);
2101 10 len -= 1;
2102
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
10 if (nummarkers == 0) {
2103 av_log(s->avctx, AV_LOG_WARNING, "Invalid number of markers coded in APP2\n");
2104 goto out;
2105
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) {
2106 av_log(s->avctx, AV_LOG_WARNING, "Mismatch in coded number of ICC markers between markers\n");
2107 goto out;
2108
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
10 } else if (seqno > nummarkers) {
2109 av_log(s->avctx, AV_LOG_WARNING, "Mismatching sequence number and coded number of ICC markers\n");
2110 goto out;
2111 }
2112
2113 /* Allocate if this is the first APP2 we've seen. */
2114
1/2
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
10 if (s->iccnum == 0) {
2115
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
10 if (!FF_ALLOCZ_TYPED_ARRAY(s->iccentries, nummarkers)) {
2116 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data arrays\n");
2117 return AVERROR(ENOMEM);
2118 }
2119 10 s->iccnum = nummarkers;
2120 }
2121
2122
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
10 if (s->iccentries[seqno - 1].data) {
2123 av_log(s->avctx, AV_LOG_WARNING, "Duplicate ICC sequence number\n");
2124 goto out;
2125 }
2126
2127 10 s->iccentries[seqno - 1].length = len;
2128 10 s->iccentries[seqno - 1].data = av_malloc(len);
2129
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
10 if (!s->iccentries[seqno - 1].data) {
2130 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data buffer\n");
2131 return AVERROR(ENOMEM);
2132 }
2133
2134 10 memcpy(s->iccentries[seqno - 1].data, align_get_bits(&s->gb), len);
2135 10 skip_bits(&s->gb, len << 3);
2136 10 len = 0;
2137 10 s->iccread++;
2138
2139
1/2
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
10 if (s->iccread > s->iccnum)
2140 av_log(s->avctx, AV_LOG_WARNING, "Read more ICC markers than are supposed to be coded\n");
2141 }
2142
2143 16 out:
2144 /* slow but needed for extreme adobe jpegs */
2145
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 227 times.
227 if (len < 0)
2146 av_log(s->avctx, AV_LOG_ERROR,
2147 "mjpeg: error, decode_app parser read over the end\n");
2148
2/2
✓ Branch 0 taken 107580 times.
✓ Branch 1 taken 227 times.
107807 while (len-- > 0)
2149 107580 skip_bits(&s->gb, 8);
2150
2151 227 return 0;
2152 }
2153
2154 240 static int mjpeg_decode_com(MJpegDecodeContext *s)
2155 {
2156 240 int len = get_bits(&s->gb, 16);
2157
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)) {
2158 int i;
2159 240 char *cbuf = av_malloc(len - 1);
2160
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 240 times.
240 if (!cbuf)
2161 return AVERROR(ENOMEM);
2162
2163
2/2
✓ Branch 0 taken 3655 times.
✓ Branch 1 taken 240 times.
3895 for (i = 0; i < len - 2; i++)
2164 3655 cbuf[i] = get_bits(&s->gb, 8);
2165
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')
2166 10 cbuf[i - 1] = 0;
2167 else
2168 230 cbuf[i] = 0;
2169
2170
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 240 times.
240 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2171 av_log(s->avctx, AV_LOG_INFO, "comment: '%s'\n", cbuf);
2172
2173 /* buggy avid, it puts EOI only at every 10th frame */
2174
2/2
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 229 times.
240 if (!strncmp(cbuf, "AVID", 4)) {
2175 11 parse_avid(s, cbuf, len);
2176
2/2
✓ Branch 0 taken 205 times.
✓ Branch 1 taken 24 times.
229 } else if (!strcmp(cbuf, "CS=ITU601"))
2177 205 s->cs_itu601 = 1;
2178
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) ||
2179
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.
24 (!strncmp(cbuf, "Metasoft MJPEG Codec", 20)))
2180 s->flipped = 1;
2181
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.
24 else if (!strcmp(cbuf, "MULTISCOPE II")) {
2182 s->avctx->sample_aspect_ratio = (AVRational) { 1, 2 };
2183 s->multiscope = 2;
2184 }
2185
2186 240 av_free(cbuf);
2187 }
2188
2189 240 return 0;
2190 }
2191
2192 /* return the 8 bit start code value and update the search
2193 state. Return -1 if no start code found */
2194 16380 static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
2195 {
2196 const uint8_t *buf_ptr;
2197 unsigned int v, v2;
2198 int val;
2199 16380 int skipped = 0;
2200
2201 16380 buf_ptr = *pbuf_ptr;
2202
2/2
✓ Branch 0 taken 291923 times.
✓ Branch 1 taken 1 times.
291924 while (buf_end - buf_ptr > 1) {
2203 291923 v = *buf_ptr++;
2204 291923 v2 = *buf_ptr;
2205
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) {
2206 16379 val = *buf_ptr++;
2207 16379 goto found;
2208 }
2209 275544 skipped++;
2210 }
2211 1 buf_ptr = buf_end;
2212 1 val = -1;
2213 16380 found:
2214 ff_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
2215 16380 *pbuf_ptr = buf_ptr;
2216 16380 return val;
2217 }
2218
2219 16380 int ff_mjpeg_find_marker(MJpegDecodeContext *s,
2220 const uint8_t **buf_ptr, const uint8_t *buf_end,
2221 const uint8_t **unescaped_buf_ptr,
2222 int *unescaped_buf_size)
2223 {
2224 int start_code;
2225 16380 start_code = find_marker(buf_ptr, buf_end);
2226
2227 16380 av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr);
2228
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16380 times.
16380 if (!s->buffer)
2229 return AVERROR(ENOMEM);
2230
2231 /* unescape buffer of SOS, use special treatment for JPEG-LS */
2232
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) {
2233 2378 const uint8_t *src = *buf_ptr;
2234 2378 const uint8_t *ptr = src;
2235 2378 uint8_t *dst = s->buffer;
2236
2237 #define copy_data_segment(skip) do { \
2238 ptrdiff_t length = (ptr - src) - (skip); \
2239 if (length > 0) { \
2240 memcpy(dst, src, length); \
2241 dst += length; \
2242 src = ptr; \
2243 } \
2244 } while (0)
2245
2246
2/2
✓ Branch 0 taken 74 times.
✓ Branch 1 taken 2304 times.
2378 if (s->avctx->codec_id == AV_CODEC_ID_THP) {
2247 74 ptr = buf_end;
2248
1/2
✓ Branch 0 taken 74 times.
✗ Branch 1 not taken.
74 copy_data_segment(0);
2249 } else {
2250
1/2
✓ Branch 0 taken 42092110 times.
✗ Branch 1 not taken.
42094414 while (ptr < buf_end) {
2251 42092110 uint8_t x = *(ptr++);
2252
2253
2/2
✓ Branch 0 taken 41883384 times.
✓ Branch 1 taken 208726 times.
42092110 if (x == 0xff) {
2254 208726 ptrdiff_t skip = 0;
2255
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) {
2256 208738 x = *(ptr++);
2257 208738 skip++;
2258 }
2259
2260 /* 0xFF, 0xFF, ... */
2261
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 208720 times.
208726 if (skip > 1) {
2262
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
6 copy_data_segment(skip);
2263
2264 /* decrement src as it is equal to ptr after the
2265 * copy_data_segment macro and we might want to
2266 * copy the current value of x later on */
2267 6 src--;
2268 }
2269
2270
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) {
2271
2/2
✓ Branch 0 taken 206070 times.
✓ Branch 1 taken 6 times.
206076 copy_data_segment(1);
2272
2/2
✓ Branch 0 taken 2304 times.
✓ Branch 1 taken 203772 times.
206076 if (x)
2273 2304 break;
2274 }
2275 }
2276 }
2277
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 2298 times.
2304 if (src < ptr)
2278
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
6 copy_data_segment(0);
2279 }
2280 #undef copy_data_segment
2281
2282 2378 *unescaped_buf_ptr = s->buffer;
2283 2378 *unescaped_buf_size = dst - s->buffer;
2284 2378 memset(s->buffer + *unescaped_buf_size, 0,
2285 AV_INPUT_BUFFER_PADDING_SIZE);
2286
2287 2378 av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %"PTRDIFF_SPECIFIER" bytes\n",
2288 2378 (buf_end - *buf_ptr) - (dst - s->buffer));
2289
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) {
2290 213 const uint8_t *src = *buf_ptr;
2291 213 uint8_t *dst = s->buffer;
2292 213 int bit_count = 0;
2293 213 int t = 0, b = 0;
2294 PutBitContext pb;
2295
2296 /* find marker */
2297
1/2
✓ Branch 0 taken 27487079 times.
✗ Branch 1 not taken.
27487292 while (src + t < buf_end) {
2298 27487079 uint8_t x = src[t++];
2299
2/2
✓ Branch 0 taken 27333028 times.
✓ Branch 1 taken 154051 times.
27487079 if (x == 0xff) {
2300
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)
2301 154051 x = src[t++];
2302
2/2
✓ Branch 0 taken 213 times.
✓ Branch 1 taken 153838 times.
154051 if (x & 0x80) {
2303 213 t -= FFMIN(2, t);
2304 213 break;
2305 }
2306 }
2307 }
2308 213 bit_count = t * 8;
2309 213 init_put_bits(&pb, dst, t);
2310
2311 /* unescape bitstream */
2312
2/2
✓ Branch 0 taken 27486866 times.
✓ Branch 1 taken 213 times.
27487079 while (b < t) {
2313 27486866 uint8_t x = src[b++];
2314 27486866 put_bits(&pb, 8, x);
2315
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) {
2316 153838 x = src[b++];
2317
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 153838 times.
153838 if (x & 0x80) {
2318 av_log(s->avctx, AV_LOG_WARNING, "Invalid escape sequence\n");
2319 x &= 0x7f;
2320 }
2321 153838 put_bits(&pb, 7, x);
2322 153838 bit_count--;
2323 }
2324 }
2325 213 flush_put_bits(&pb);
2326
2327 213 *unescaped_buf_ptr = dst;
2328 213 *unescaped_buf_size = (bit_count + 7) >> 3;
2329 213 memset(s->buffer + *unescaped_buf_size, 0,
2330 AV_INPUT_BUFFER_PADDING_SIZE);
2331 } else {
2332 13789 *unescaped_buf_ptr = *buf_ptr;
2333 13789 *unescaped_buf_size = buf_end - *buf_ptr;
2334 }
2335
2336 16380 return start_code;
2337 }
2338
2339 236 static void reset_icc_profile(MJpegDecodeContext *s)
2340 {
2341 int i;
2342
2343
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 226 times.
236 if (s->iccentries) {
2344
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 10 times.
20 for (i = 0; i < s->iccnum; i++)
2345 10 av_freep(&s->iccentries[i].data);
2346 10 av_freep(&s->iccentries);
2347 }
2348
2349 236 s->iccread = 0;
2350 236 s->iccnum = 0;
2351 236 }
2352
2353 2590 int ff_mjpeg_decode_frame_from_buf(AVCodecContext *avctx, AVFrame *frame,
2354 int *got_frame, const AVPacket *avpkt,
2355 const uint8_t *buf, const int buf_size)
2356 {
2357 2590 MJpegDecodeContext *s = avctx->priv_data;
2358 const uint8_t *buf_end, *buf_ptr;
2359 const uint8_t *unescaped_buf_ptr;
2360 int hshift, vshift;
2361 int unescaped_buf_size;
2362 int start_code;
2363 int index;
2364 2590 int ret = 0;
2365 int is16bit;
2366
2367 2590 s->force_pal8 = 0;
2368
2369 2590 s->buf_size = buf_size;
2370
2371 2590 av_exif_free(&s->exif_metadata);
2372 2590 av_freep(&s->stereo3d);
2373 2590 s->adobe_transform = -1;
2374
2375
1/2
✓ Branch 0 taken 2590 times.
✗ Branch 1 not taken.
2590 if (s->iccnum != 0)
2376 reset_icc_profile(s);
2377
2378 2590 redo_for_pal8:
2379 2598 buf_ptr = buf;
2380 2598 buf_end = buf + buf_size;
2381
1/2
✓ Branch 0 taken 16178 times.
✗ Branch 1 not taken.
16178 while (buf_ptr < buf_end) {
2382 /* find start next marker */
2383 16178 start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,
2384 &unescaped_buf_ptr,
2385 &unescaped_buf_size);
2386 /* EOF */
2387
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 16177 times.
16178 if (start_code < 0) {
2388 1 break;
2389
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16177 times.
16177 } else if (unescaped_buf_size > INT_MAX / 8) {
2390 av_log(avctx, AV_LOG_ERROR,
2391 "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
2392 start_code, unescaped_buf_size, buf_size);
2393 return AVERROR_INVALIDDATA;
2394 }
2395 16177 av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%"PTRDIFF_SPECIFIER"\n",
2396 start_code, buf_end - buf_ptr);
2397
2398 16177 ret = init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);
2399
2400
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16177 times.
16177 if (ret < 0) {
2401 av_log(avctx, AV_LOG_ERROR, "invalid buffer\n");
2402 goto fail;
2403 }
2404
2405 16177 s->start_code = start_code;
2406
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16177 times.
16177 if (avctx->debug & FF_DEBUG_STARTCODE)
2407 av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2408
2409 /* process markers */
2410
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) {
2411 av_log(avctx, AV_LOG_DEBUG,
2412 "restart marker: %d\n", start_code & 0x0f);
2413 /* APP fields */
2414
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) {
2415
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 227 times.
227 if ((ret = mjpeg_decode_app(s)) < 0)
2416 av_log(avctx, AV_LOG_ERROR, "unable to decode APP fields: %s\n",
2417 av_err2str(ret));
2418 /* Comment */
2419
2/2
✓ Branch 0 taken 240 times.
✓ Branch 1 taken 15710 times.
15950 } else if (start_code == COM) {
2420 240 ret = mjpeg_decode_com(s);
2421
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 240 times.
240 if (ret < 0)
2422 return ret;
2423
2/2
✓ Branch 0 taken 2575 times.
✓ Branch 1 taken 13135 times.
15710 } else if (start_code == DQT) {
2424 2575 ret = ff_mjpeg_decode_dqt(s);
2425
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2575 times.
2575 if (ret < 0)
2426 return ret;
2427 }
2428
2429 16177 ret = -1;
2430
2431 if (!CONFIG_JPEGLS_DECODER &&
2432 (start_code == SOF48 || start_code == LSE)) {
2433 av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");
2434 return AVERROR(ENOSYS);
2435 }
2436
2437
2/2
✓ Branch 0 taken 468 times.
✓ Branch 1 taken 15709 times.
16177 if (avctx->skip_frame == AVDISCARD_ALL) {
2438
2/2
✓ Branch 0 taken 93 times.
✓ Branch 1 taken 375 times.
468 switch(start_code) {
2439 93 case SOF0:
2440 case SOF1:
2441 case SOF2:
2442 case SOF3:
2443 case SOF48:
2444 93 break;
2445 375 default:
2446 375 goto skip;
2447 }
2448 }
2449
2450
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) {
2451 2507 case SOI:
2452 2507 s->restart_interval = 0;
2453 2507 s->restart_count = 0;
2454 2507 s->raw_image_buffer = buf_ptr;
2455 2507 s->raw_image_buffer_size = buf_end - buf_ptr;
2456 /* nothing to do on SOI */
2457 2507 break;
2458 2597 case DHT:
2459
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2597 times.
2597 if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
2460 av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2461 goto fail;
2462 }
2463 2597 break;
2464 2160 case SOF0:
2465 case SOF1:
2466
2/2
✓ Branch 0 taken 2158 times.
✓ Branch 1 taken 2 times.
2160 if (start_code == SOF0)
2467 2158 avctx->profile = AV_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT;
2468 else
2469 2 avctx->profile = AV_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT;
2470 2160 s->lossless = 0;
2471 2160 s->ls = 0;
2472 2160 s->progressive = 0;
2473
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2160 times.
2160 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2474 goto fail;
2475 2160 break;
2476 14 case SOF2:
2477 14 avctx->profile = AV_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT;
2478 14 s->lossless = 0;
2479 14 s->ls = 0;
2480 14 s->progressive = 1;
2481
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
14 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2482 goto fail;
2483 14 break;
2484 205 case SOF3:
2485 205 avctx->profile = AV_PROFILE_MJPEG_HUFFMAN_LOSSLESS;
2486 #if FF_API_CODEC_PROPS
2487 FF_DISABLE_DEPRECATION_WARNINGS
2488 205 avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2489 FF_ENABLE_DEPRECATION_WARNINGS
2490 #endif
2491 205 s->lossless = 1;
2492 205 s->ls = 0;
2493 205 s->progressive = 0;
2494
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 205 times.
205 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2495 goto fail;
2496 205 break;
2497 221 case SOF48:
2498 221 avctx->profile = AV_PROFILE_MJPEG_JPEG_LS;
2499 #if FF_API_CODEC_PROPS
2500 FF_DISABLE_DEPRECATION_WARNINGS
2501 221 avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2502 FF_ENABLE_DEPRECATION_WARNINGS
2503 #endif
2504 221 s->lossless = 1;
2505 221 s->ls = 1;
2506 221 s->progressive = 0;
2507
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 221 times.
221 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2508 goto fail;
2509 221 break;
2510 16 case LSE:
2511
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
16 if (!CONFIG_JPEGLS_DECODER ||
2512 16 (ret = ff_jpegls_decode_lse(s)) < 0)
2513 goto fail;
2514
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 8 times.
16 if (ret == 1)
2515 8 goto redo_for_pal8;
2516 8 break;
2517 case EOI:
2518 2499 eoi_parser:
2519
1/2
✓ Branch 0 taken 2499 times.
✗ Branch 1 not taken.
2499 if (!avctx->hwaccel &&
2520
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)
2521 7 mjpeg_idct_scan_progressive_ac(s);
2522 2499 s->cur_scan = 0;
2523
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2499 times.
2499 if (!s->got_picture) {
2524 av_log(avctx, AV_LOG_WARNING,
2525 "Found EOI before any SOF, ignoring\n");
2526 break;
2527 }
2528
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 2493 times.
2499 if (s->interlaced) {
2529 6 s->bottom_field ^= 1;
2530 /* if not bottom field, do not output image yet */
2531
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 3 times.
6 if (s->bottom_field == !s->interlace_polarity)
2532 3 break;
2533 }
2534
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2496 times.
2496 if (avctx->hwaccel) {
2535 ret = FF_HW_SIMPLE_CALL(avctx, end_frame);
2536 if (ret < 0)
2537 return ret;
2538
2539 av_freep(&s->hwaccel_picture_private);
2540 }
2541
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2496 times.
2496 if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
2542 return ret;
2543
2/2
✓ Branch 0 taken 413 times.
✓ Branch 1 taken 2083 times.
2496 if (s->lossless)
2544 413 frame->flags |= AV_FRAME_FLAG_LOSSLESS;
2545 2496 *got_frame = 1;
2546 2496 s->got_picture = 0;
2547
2548
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) {
2549 int qp = FFMAX3(s->qscale[0],
2550 s->qscale[1],
2551 s->qscale[2]);
2552
2553 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);
2554 }
2555
2556 2496 goto the_end;
2557 2560 case SOS:
2558 2560 s->raw_scan_buffer = buf_ptr;
2559 2560 s->raw_scan_buffer_size = buf_end - buf_ptr;
2560
2561 2560 s->cur_scan++;
2562
2563
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2560 times.
2560 if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&
2564 (avctx->err_recognition & AV_EF_EXPLODE))
2565 goto fail;
2566 2560 break;
2567 216 case DRI:
2568
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 216 times.
216 if ((ret = mjpeg_decode_dri(s)) < 0)
2569 return ret;
2570 216 break;
2571 case SOF5:
2572 case SOF6:
2573 case SOF7:
2574 case SOF9:
2575 case SOF10:
2576 case SOF11:
2577 case SOF13:
2578 case SOF14:
2579 case SOF15:
2580 case JPG:
2581 av_log(avctx, AV_LOG_ERROR,
2582 "mjpeg: unsupported coding type (%x)\n", start_code);
2583 break;
2584 }
2585
2586
2/2
✓ Branch 0 taken 93 times.
✓ Branch 1 taken 13205 times.
13298 if (avctx->skip_frame == AVDISCARD_ALL) {
2587
1/2
✓ Branch 0 taken 93 times.
✗ Branch 1 not taken.
93 switch(start_code) {
2588 93 case SOF0:
2589 case SOF1:
2590 case SOF2:
2591 case SOF3:
2592 case SOF48:
2593 93 s->got_picture = 0;
2594 93 goto the_end_no_picture;
2595 }
2596 }
2597
2598 13205 skip:
2599 /* eof process start code */
2600 13580 buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
2601 27160 av_log(avctx, AV_LOG_DEBUG,
2602 "marker parser used %d bytes (%d bits)\n",
2603 13580 (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
2604 }
2605
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) {
2606 av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
2607 goto eoi_parser;
2608 }
2609 1 av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
2610 1 return AVERROR_INVALIDDATA;
2611 fail:
2612 s->got_picture = 0;
2613 return ret;
2614 2496 the_end:
2615
2616 2496 is16bit = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].step > 1;
2617
2618
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 2490 times.
2496 if (AV_RB32(s->upscale_h)) {
2619 int p;
2620
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 ||
2621 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2622 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2623 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2624 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2625 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2626 avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
2627 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2628 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2629 avctx->pix_fmt == AV_PIX_FMT_YUV420P16||
2630 avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2631 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2632 avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2633 avctx->pix_fmt == AV_PIX_FMT_GBRAP
2634 );
2635 6 ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &hshift, &vshift);
2636
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
6 if (ret)
2637 return ret;
2638
2639
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));
2640
2/2
✓ Branch 0 taken 18 times.
✓ Branch 1 taken 6 times.
24 for (p = 0; p<s->nb_components; p++) {
2641 18 uint8_t *line = s->picture_ptr->data[p];
2642 18 int w = s->width;
2643 18 int h = s->height;
2644
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 9 times.
18 if (!s->upscale_h[p])
2645 9 continue;
2646
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) {
2647 7 w = AV_CEIL_RSHIFT(w, hshift);
2648 7 h = AV_CEIL_RSHIFT(h, vshift);
2649 }
2650
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 8 times.
9 if (s->upscale_v[p] == 1)
2651 1 h = (h+1)>>1;
2652
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
9 av_assert0(w > 0);
2653
2/2
✓ Branch 0 taken 534 times.
✓ Branch 1 taken 9 times.
543 for (int i = 0; i < h; i++) {
2654
2/2
✓ Branch 0 taken 214 times.
✓ Branch 1 taken 320 times.
534 if (s->upscale_h[p] == 1) {
2655
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];
2656 214 else line[w - 1] = line[(w - 1) / 2];
2657
2/2
✓ Branch 0 taken 11220 times.
✓ Branch 1 taken 214 times.
11434 for (index = w - 2; index > 0; index--) {
2658
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11220 times.
11220 if (is16bit)
2659 ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;
2660 else
2661 11220 line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
2662 }
2663
2/2
✓ Branch 0 taken 256 times.
✓ Branch 1 taken 64 times.
320 } else if (s->upscale_h[p] == 2) {
2664
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 256 times.
256 if (is16bit) {
2665 ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3];
2666 if (w > 1)
2667 ((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1];
2668 } else {
2669 256 line[w - 1] = line[(w - 1) / 3];
2670
1/2
✓ Branch 0 taken 256 times.
✗ Branch 1 not taken.
256 if (w > 1)
2671 256 line[w - 2] = line[w - 1];
2672 }
2673
2/2
✓ Branch 0 taken 15616 times.
✓ Branch 1 taken 256 times.
15872 for (index = w - 3; index > 0; index--) {
2674 15616 line[index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3;
2675 }
2676
1/2
✓ Branch 0 taken 64 times.
✗ Branch 1 not taken.
64 } else if (s->upscale_h[p] == 4){
2677
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 64 times.
64 if (is16bit) {
2678 uint16_t *line16 = (uint16_t *) line;
2679 line16[w - 1] = line16[(w - 1) >> 2];
2680 if (w > 1)
2681 line16[w - 2] = (line16[(w - 1) >> 2] * 3 + line16[(w - 2) >> 2]) >> 2;
2682 if (w > 2)
2683 line16[w - 3] = (line16[(w - 1) >> 2] + line16[(w - 2) >> 2]) >> 1;
2684 } else {
2685 64 line[w - 1] = line[(w - 1) >> 2];
2686
1/2
✓ Branch 0 taken 64 times.
✗ Branch 1 not taken.
64 if (w > 1)
2687 64 line[w - 2] = (line[(w - 1) >> 2] * 3 + line[(w - 2) >> 2]) >> 2;
2688
1/2
✓ Branch 0 taken 64 times.
✗ Branch 1 not taken.
64 if (w > 2)
2689 64 line[w - 3] = (line[(w - 1) >> 2] + line[(w - 2) >> 2]) >> 1;
2690 }
2691
2/2
✓ Branch 0 taken 3840 times.
✓ Branch 1 taken 64 times.
3904 for (index = w - 4; index > 0; index--)
2692 3840 line[index] = (line[(index + 3) >> 2] + line[(index + 2) >> 2]
2693 3840 + line[(index + 1) >> 2] + line[index >> 2]) >> 2;
2694 }
2695 534 line += s->linesize[p];
2696 }
2697 }
2698 }
2699
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2495 times.
2496 if (AV_RB32(s->upscale_v)) {
2700 int p;
2701
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 ||
2702 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2703 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2704 avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
2705 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2706 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2707 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2708 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2709 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2710 avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2711 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2712 avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2713 avctx->pix_fmt == AV_PIX_FMT_GBRAP
2714 );
2715 1 ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &hshift, &vshift);
2716
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
1 if (ret)
2717 return ret;
2718
2719
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));
2720
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1 times.
4 for (p = 0; p < s->nb_components; p++) {
2721 uint8_t *dst;
2722 3 int w = s->width;
2723 3 int h = s->height;
2724
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 times.
3 if (!s->upscale_v[p])
2725 2 continue;
2726
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) {
2727 1 w = AV_CEIL_RSHIFT(w, hshift);
2728 1 h = AV_CEIL_RSHIFT(h, vshift);
2729 }
2730 1 dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];
2731
2/2
✓ Branch 0 taken 42 times.
✓ Branch 1 taken 1 times.
43 for (int i = h - 1; i; i--) {
2732 42 uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2733 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]];
2734
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)) {
2735 21 memcpy(dst, src1, w);
2736 } else {
2737
2/2
✓ Branch 0 taken 1344 times.
✓ Branch 1 taken 21 times.
1365 for (index = 0; index < w; index++)
2738 1344 dst[index] = (src1[index] + src2[index]) >> 1;
2739 }
2740 42 dst -= s->linesize[p];
2741 }
2742 }
2743 }
2744
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) {
2745 368 ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &hshift, &vshift);
2746
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 368 times.
368 if (ret)
2747 return ret;
2748
2749
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 368 times.
368 av_assert0(s->nb_components == av_pix_fmt_count_planes(frame->format));
2750
2/2
✓ Branch 0 taken 1104 times.
✓ Branch 1 taken 368 times.
1472 for (index=0; index<s->nb_components; index++) {
2751 1104 int h = frame->height;
2752
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)
2753 736 h = AV_CEIL_RSHIFT(h, vshift);
2754
1/2
✓ Branch 0 taken 1104 times.
✗ Branch 1 not taken.
1104 if (frame->data[index]) {
2755 1104 frame->data[index] += (h - 1) * frame->linesize[index];
2756 1104 frame->linesize[index] *= -1;
2757 }
2758 }
2759 }
2760
2761
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 2491 times.
2496 if (avctx->pix_fmt == AV_PIX_FMT_GBRP) {
2762
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
5 av_assert0(s->nb_components == 3);
2763 5 FFSWAP(uint8_t *, frame->data[0], frame->data[2]);
2764 5 FFSWAP(uint8_t *, frame->data[0], frame->data[1]);
2765 5 FFSWAP(int, frame->linesize[0], frame->linesize[2]);
2766 5 FFSWAP(int, frame->linesize[0], frame->linesize[1]);
2767 }
2768
2769
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) {
2770 int w = s->picture_ptr->width;
2771 int h = s->picture_ptr->height;
2772 av_assert0(s->nb_components == 4);
2773 for (int i = 0; i < h; i++) {
2774 int j;
2775 uint8_t *dst[4];
2776 for (index=0; index<4; index++) {
2777 dst[index] = s->picture_ptr->data[index]
2778 + s->picture_ptr->linesize[index]*i;
2779 }
2780 for (j=0; j<w; j++) {
2781 int k = dst[3][j];
2782 int r = dst[0][j] * k;
2783 int g = dst[1][j] * k;
2784 int b = dst[2][j] * k;
2785 dst[0][j] = g*257 >> 16;
2786 dst[1][j] = b*257 >> 16;
2787 dst[2][j] = r*257 >> 16;
2788 }
2789 memset(dst[3], 255, w);
2790 }
2791 }
2792
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) {
2793 int w = s->picture_ptr->width;
2794 int h = s->picture_ptr->height;
2795 av_assert0(s->nb_components == 4);
2796 for (int i = 0; i < h; i++) {
2797 int j;
2798 uint8_t *dst[4];
2799 for (index=0; index<4; index++) {
2800 dst[index] = s->picture_ptr->data[index]
2801 + s->picture_ptr->linesize[index]*i;
2802 }
2803 for (j=0; j<w; j++) {
2804 int k = dst[3][j];
2805 int r = (255 - dst[0][j]) * k;
2806 int g = (128 - dst[1][j]) * k;
2807 int b = (128 - dst[2][j]) * k;
2808 dst[0][j] = r*257 >> 16;
2809 dst[1][j] = (g*257 >> 16) + 128;
2810 dst[2][j] = (b*257 >> 16) + 128;
2811 }
2812 memset(dst[3], 255, w);
2813 }
2814 }
2815
2816
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2496 times.
2496 if (s->stereo3d) {
2817 AVStereo3D *stereo = av_stereo3d_create_side_data(frame);
2818 if (stereo) {
2819 stereo->type = s->stereo3d->type;
2820 stereo->flags = s->stereo3d->flags;
2821 }
2822 av_freep(&s->stereo3d);
2823 }
2824
2825
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) {
2826 AVFrameSideData *sd;
2827 5 size_t offset = 0;
2828 5 int total_size = 0;
2829
2830 /* Sum size of all parts. */
2831
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 5 times.
10 for (int i = 0; i < s->iccnum; i++)
2832 5 total_size += s->iccentries[i].length;
2833
2834 5 ret = ff_frame_new_side_data(avctx, frame, AV_FRAME_DATA_ICC_PROFILE, total_size, &sd);
2835
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
5 if (ret < 0) {
2836 av_log(avctx, AV_LOG_ERROR, "Could not allocate frame side data\n");
2837 return ret;
2838 }
2839
2840
1/2
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
5 if (sd) {
2841 /* Reassemble the parts, which are now in-order. */
2842
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 5 times.
10 for (int i = 0; i < s->iccnum; i++) {
2843 5 memcpy(sd->data + offset, s->iccentries[i].data, s->iccentries[i].length);
2844 5 offset += s->iccentries[i].length;
2845 }
2846 }
2847 }
2848
2849
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 2489 times.
2496 if (s->exif_metadata.entries) {
2850 7 ret = ff_decode_exif_attach_ifd(avctx, frame, &s->exif_metadata);
2851 7 av_exif_free(&s->exif_metadata);
2852
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
7 if (ret < 0)
2853 av_log(avctx, AV_LOG_WARNING, "couldn't attach EXIF metadata\n");
2854 }
2855
2856
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 2493 times.
2496 if (avctx->codec_id != AV_CODEC_ID_SMVJPEG &&
2857
1/2
✓ Branch 0 taken 2493 times.
✗ Branch 1 not taken.
2493 (avctx->codec_tag == MKTAG('A', 'V', 'R', 'n') ||
2858
2/2
✓ Branch 0 taken 2483 times.
✓ Branch 1 taken 10 times.
2493 avctx->codec_tag == MKTAG('A', 'V', 'D', 'J')) &&
2859
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
10 avctx->coded_height > s->orig_height) {
2860 10 frame->height = AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres);
2861 10 frame->crop_top = frame->height - avctx->height;
2862 }
2863
2864 2486 the_end_no_picture:
2865 2589 av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n",
2866 buf_end - buf_ptr);
2867 2589 return buf_ptr - buf;
2868 }
2869
2870 2211 int ff_mjpeg_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame,
2871 AVPacket *avpkt)
2872 {
2873 4422 return ff_mjpeg_decode_frame_from_buf(avctx, frame, got_frame,
2874 2211 avpkt, avpkt->data, avpkt->size);
2875 }
2876
2877
2878 /* mxpeg may call the following function (with a blank MJpegDecodeContext)
2879 * even without having called ff_mjpeg_decode_init(). */
2880 236 av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
2881 {
2882 236 MJpegDecodeContext *s = avctx->priv_data;
2883 int i, j;
2884
2885
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) {
2886 av_log(avctx, AV_LOG_INFO, "Single field\n");
2887 }
2888
2889 236 av_frame_free(&s->picture);
2890 236 s->picture_ptr = NULL;
2891
2892 236 av_frame_free(&s->smv_frame);
2893
2894 236 av_freep(&s->buffer);
2895 236 av_freep(&s->stereo3d);
2896 236 av_freep(&s->ljpeg_buffer);
2897 236 s->ljpeg_buffer_size = 0;
2898
2899
2/2
✓ Branch 0 taken 708 times.
✓ Branch 1 taken 236 times.
944 for (i = 0; i < 3; i++) {
2900
2/2
✓ Branch 0 taken 2832 times.
✓ Branch 1 taken 708 times.
3540 for (j = 0; j < 4; j++)
2901 2832 ff_vlc_free(&s->vlcs[i][j]);
2902 }
2903
2/2
✓ Branch 0 taken 944 times.
✓ Branch 1 taken 236 times.
1180 for (i = 0; i < MAX_COMPONENTS; i++) {
2904 944 av_freep(&s->blocks[i]);
2905 944 av_freep(&s->last_nnz[i]);
2906 }
2907 236 av_exif_free(&s->exif_metadata);
2908
2909 236 reset_icc_profile(s);
2910
2911 236 av_freep(&s->hwaccel_picture_private);
2912 236 av_freep(&s->jls_state);
2913
2914 236 return 0;
2915 }
2916
2917 6 static av_cold void decode_flush(AVCodecContext *avctx)
2918 {
2919 6 MJpegDecodeContext *s = avctx->priv_data;
2920 6 s->got_picture = 0;
2921
2922 6 s->smv_next_frame = 0;
2923 6 av_frame_unref(s->smv_frame);
2924 6 }
2925
2926 #if CONFIG_MJPEG_DECODER
2927 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
2928 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2929 static const AVOption options[] = {
2930 { "extern_huff", "Use external huffman table.",
2931 OFFSET(extern_huff), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
2932 { NULL },
2933 };
2934
2935 static const AVClass mjpegdec_class = {
2936 .class_name = "MJPEG decoder",
2937 .item_name = av_default_item_name,
2938 .option = options,
2939 .version = LIBAVUTIL_VERSION_INT,
2940 };
2941
2942 const FFCodec ff_mjpeg_decoder = {
2943 .p.name = "mjpeg",
2944 CODEC_LONG_NAME("MJPEG (Motion JPEG)"),
2945 .p.type = AVMEDIA_TYPE_VIDEO,
2946 .p.id = AV_CODEC_ID_MJPEG,
2947 .priv_data_size = sizeof(MJpegDecodeContext),
2948 .init = ff_mjpeg_decode_init,
2949 .close = ff_mjpeg_decode_end,
2950 FF_CODEC_DECODE_CB(ff_mjpeg_decode_frame),
2951 .flush = decode_flush,
2952 .p.capabilities = AV_CODEC_CAP_DR1,
2953 .p.max_lowres = 3,
2954 .p.priv_class = &mjpegdec_class,
2955 .p.profiles = NULL_IF_CONFIG_SMALL(ff_mjpeg_profiles),
2956 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP |
2957 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM |
2958 FF_CODEC_CAP_ICC_PROFILES,
2959 .hw_configs = (const AVCodecHWConfigInternal *const []) {
2960 #if CONFIG_MJPEG_NVDEC_HWACCEL
2961 HWACCEL_NVDEC(mjpeg),
2962 #endif
2963 #if CONFIG_MJPEG_VAAPI_HWACCEL
2964 HWACCEL_VAAPI(mjpeg),
2965 #endif
2966 NULL
2967 },
2968 };
2969 #endif
2970 #if CONFIG_THP_DECODER
2971 const FFCodec ff_thp_decoder = {
2972 .p.name = "thp",
2973 CODEC_LONG_NAME("Nintendo Gamecube THP video"),
2974 .p.type = AVMEDIA_TYPE_VIDEO,
2975 .p.id = AV_CODEC_ID_THP,
2976 .priv_data_size = sizeof(MJpegDecodeContext),
2977 .init = ff_mjpeg_decode_init,
2978 .close = ff_mjpeg_decode_end,
2979 FF_CODEC_DECODE_CB(ff_mjpeg_decode_frame),
2980 .flush = decode_flush,
2981 .p.capabilities = AV_CODEC_CAP_DR1,
2982 .p.max_lowres = 3,
2983 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
2984 };
2985 #endif
2986
2987 #if CONFIG_SMVJPEG_DECODER
2988 // SMV JPEG just stacks several output frames into one JPEG picture
2989 // we handle that by setting up the cropping parameters appropriately
2990 13 static void smv_process_frame(AVCodecContext *avctx, AVFrame *frame)
2991 {
2992 13 MJpegDecodeContext *s = avctx->priv_data;
2993
2994
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 av_assert0((s->smv_next_frame + 1) * avctx->height <= avctx->coded_height);
2995
2996 13 frame->width = avctx->coded_width;
2997 13 frame->height = avctx->coded_height;
2998 13 frame->crop_top = FFMIN(s->smv_next_frame * avctx->height, frame->height);
2999 13 frame->crop_bottom = frame->height - (s->smv_next_frame + 1) * avctx->height;
3000
3001
1/2
✓ Branch 0 taken 13 times.
✗ Branch 1 not taken.
13 if (s->smv_frame->pts != AV_NOPTS_VALUE)
3002 13 s->smv_frame->pts += s->smv_frame->duration;
3003 13 s->smv_next_frame = (s->smv_next_frame + 1) % s->smv_frames_per_jpeg;
3004
3005
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 11 times.
13 if (s->smv_next_frame == 0)
3006 2 av_frame_unref(s->smv_frame);
3007 13 }
3008
3009 16 static int smvjpeg_receive_frame(AVCodecContext *avctx, AVFrame *frame)
3010 {
3011 16 MJpegDecodeContext *s = avctx->priv_data;
3012 16 AVPacket *const pkt = avctx->internal->in_pkt;
3013 16 int got_frame = 0;
3014 int ret;
3015
3016
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 6 times.
16 if (s->smv_next_frame > 0)
3017 10 goto return_frame;
3018
3019 6 ret = ff_decode_get_packet(avctx, pkt);
3020
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 3 times.
6 if (ret < 0)
3021 3 return ret;
3022
3023 3 av_frame_unref(s->smv_frame);
3024
3025 3 ret = ff_mjpeg_decode_frame(avctx, s->smv_frame, &got_frame, pkt);
3026 3 s->smv_frame->pkt_dts = pkt->dts;
3027 3 av_packet_unref(pkt);
3028
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
3 if (ret < 0)
3029 return ret;
3030
3031
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
3 if (!got_frame)
3032 return AVERROR(EAGAIN);
3033
3034 // packet duration covers all the frames in the packet
3035 3 s->smv_frame->duration /= s->smv_frames_per_jpeg;
3036
3037 13 return_frame:
3038
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 av_assert0(s->smv_frame->buf[0]);
3039 13 ret = av_frame_ref(frame, s->smv_frame);
3040
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 if (ret < 0)
3041 return ret;
3042
3043 13 smv_process_frame(avctx, frame);
3044 13 return 0;
3045 }
3046
3047 const FFCodec ff_smvjpeg_decoder = {
3048 .p.name = "smvjpeg",
3049 CODEC_LONG_NAME("SMV JPEG"),
3050 .p.type = AVMEDIA_TYPE_VIDEO,
3051 .p.id = AV_CODEC_ID_SMVJPEG,
3052 .priv_data_size = sizeof(MJpegDecodeContext),
3053 .init = ff_mjpeg_decode_init,
3054 .close = ff_mjpeg_decode_end,
3055 FF_CODEC_RECEIVE_FRAME_CB(smvjpeg_receive_frame),
3056 .flush = decode_flush,
3057 .p.capabilities = AV_CODEC_CAP_DR1,
3058 .caps_internal = FF_CODEC_CAP_EXPORTS_CROPPING |
3059 FF_CODEC_CAP_INIT_CLEANUP,
3060 };
3061 #endif
3062