FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/mjpegdec.c
Date: 2022-01-22 23:30:28
Exec Total Coverage
Lines: 927 1829 50.7%
Branches: 674 1665 40.5%

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