GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/mjpegdec.c Lines: 901 1781 50.6 %
Date: 2021-04-18 21:26:34 Branches: 644 1633 39.4 %

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/imgutils.h"
34
#include "libavutil/avassert.h"
35
#include "libavutil/opt.h"
36
#include "avcodec.h"
37
#include "blockdsp.h"
38
#include "copy_block.h"
39
#include "decode.h"
40
#include "hwconfig.h"
41
#include "idctdsp.h"
42
#include "internal.h"
43
#include "jpegtables.h"
44
#include "mjpeg.h"
45
#include "mjpegdec.h"
46
#include "jpeglsdec.h"
47
#include "profiles.h"
48
#include "put_bits.h"
49
#include "tiff.h"
50
#include "exif.h"
51
#include "bytestream.h"
52
53
54
158
static int init_default_huffman_tables(MJpegDecodeContext *s)
55
{
56
    static const struct {
57
        int class;
58
        int index;
59
        const uint8_t *bits;
60
        const uint8_t *values;
61
        int length;
62
    } ht[] = {
63
        { 0, 0, avpriv_mjpeg_bits_dc_luminance,
64
                avpriv_mjpeg_val_dc, 12 },
65
        { 0, 1, avpriv_mjpeg_bits_dc_chrominance,
66
                avpriv_mjpeg_val_dc, 12 },
67
        { 1, 0, avpriv_mjpeg_bits_ac_luminance,
68
                avpriv_mjpeg_val_ac_luminance,   162 },
69
        { 1, 1, avpriv_mjpeg_bits_ac_chrominance,
70
                avpriv_mjpeg_val_ac_chrominance, 162 },
71
        { 2, 0, avpriv_mjpeg_bits_ac_luminance,
72
                avpriv_mjpeg_val_ac_luminance,   162 },
73
        { 2, 1, avpriv_mjpeg_bits_ac_chrominance,
74
                avpriv_mjpeg_val_ac_chrominance, 162 },
75
    };
76
    int i, ret;
77
78
1106
    for (i = 0; i < FF_ARRAY_ELEMS(ht); i++) {
79
948
        ff_free_vlc(&s->vlcs[ht[i].class][ht[i].index]);
80
948
        ret = ff_mjpeg_build_vlc(&s->vlcs[ht[i].class][ht[i].index],
81
                                 ht[i].bits, ht[i].values,
82
948
                                 ht[i].class == 1, s->avctx);
83
948
        if (ret < 0)
84
            return ret;
85
86
948
        if (ht[i].class < 2) {
87
632
            memcpy(s->raw_huffman_lengths[ht[i].class][ht[i].index],
88
632
                   ht[i].bits + 1, 16);
89
632
            memcpy(s->raw_huffman_values[ht[i].class][ht[i].index],
90
632
                   ht[i].values, ht[i].length);
91
        }
92
    }
93
94
158
    return 0;
95
}
96
97
11
static void parse_avid(MJpegDecodeContext *s, uint8_t *buf, int len)
98
{
99
11
    s->buggy_avid = 1;
100

11
    if (len > 14 && buf[12] == 1) /* 1 - NTSC */
101
11
        s->interlace_polarity = 1;
102

11
    if (len > 14 && buf[12] == 2) /* 2 - PAL */
103
        s->interlace_polarity = 0;
104
11
    if (s->avctx->debug & FF_DEBUG_PICT_INFO)
105
        av_log(s->avctx, AV_LOG_INFO, "AVID: len:%d %d\n", len, len > 14 ? buf[12] : -1);
106
11
}
107
108
243
static void init_idct(AVCodecContext *avctx)
109
{
110
243
    MJpegDecodeContext *s = avctx->priv_data;
111
112
243
    ff_idctdsp_init(&s->idsp, avctx);
113
243
    ff_init_scantable(s->idsp.idct_permutation, &s->scantable,
114
                      ff_zigzag_direct);
115
243
}
116
117
158
av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)
118
{
119
158
    MJpegDecodeContext *s = avctx->priv_data;
120
    int ret;
121
122
158
    if (!s->picture_ptr) {
123
156
        s->picture = av_frame_alloc();
124
156
        if (!s->picture)
125
            return AVERROR(ENOMEM);
126
156
        s->picture_ptr = s->picture;
127
    }
128
129
158
    s->pkt = av_packet_alloc();
130
158
    if (!s->pkt)
131
        return AVERROR(ENOMEM);
132
133
158
    s->avctx = avctx;
134
158
    ff_blockdsp_init(&s->bdsp, avctx);
135
158
    ff_hpeldsp_init(&s->hdsp, avctx->flags);
136
158
    init_idct(avctx);
137
158
    s->buffer_size   = 0;
138
158
    s->buffer        = NULL;
139
158
    s->start_code    = -1;
140
158
    s->first_picture = 1;
141
158
    s->got_picture   = 0;
142
158
    s->orig_height    = avctx->coded_height;
143
158
    avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
144
158
    avctx->colorspace = AVCOL_SPC_BT470BG;
145
158
    s->hwaccel_pix_fmt = s->hwaccel_sw_pix_fmt = AV_PIX_FMT_NONE;
146
147
158
    if ((ret = init_default_huffman_tables(s)) < 0)
148
        return ret;
149
150
158
    if (s->extern_huff) {
151
        av_log(avctx, AV_LOG_INFO, "using external huffman table\n");
152
        if ((ret = init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8)) < 0)
153
            return ret;
154
        if (ff_mjpeg_decode_dht(s)) {
155
            av_log(avctx, AV_LOG_ERROR,
156
                   "error using external huffman table, switching back to internal\n");
157
            if ((ret = init_default_huffman_tables(s)) < 0)
158
                return ret;
159
        }
160
    }
161
158
    if (avctx->field_order == AV_FIELD_BB) { /* quicktime icefloe 019 */
162
        s->interlace_polarity = 1;           /* bottom field first */
163
        av_log(avctx, AV_LOG_DEBUG, "bottom field first\n");
164
158
    } else if (avctx->field_order == AV_FIELD_UNKNOWN) {
165
156
        if (avctx->codec_tag == AV_RL32("MJPG"))
166
51
            s->interlace_polarity = 1;
167
    }
168
169
158
    if (avctx->codec_id == AV_CODEC_ID_SMVJPEG) {
170
2
        if (avctx->extradata_size >= 4)
171
2
            s->smv_frames_per_jpeg = AV_RL32(avctx->extradata);
172
173
2
        if (s->smv_frames_per_jpeg <= 0) {
174
            av_log(avctx, AV_LOG_ERROR, "Invalid number of frames per jpeg.\n");
175
            return AVERROR_INVALIDDATA;
176
        }
177
178
2
        s->smv_frame = av_frame_alloc();
179
2
        if (!s->smv_frame)
180
            return AVERROR(ENOMEM);
181
156
    } else if (avctx->extradata_size > 8
182
2
        && AV_RL32(avctx->extradata) == 0x2C
183
        && AV_RL32(avctx->extradata+4) == 0x18) {
184
        parse_avid(s, avctx->extradata, avctx->extradata_size);
185
    }
186
187
158
    if (avctx->codec->id == AV_CODEC_ID_AMV)
188
11
        s->flipped = 1;
189
190
158
    return 0;
191
}
192
193
194
/* quantize tables */
195
2547
int ff_mjpeg_decode_dqt(MJpegDecodeContext *s)
196
{
197
    int len, index, i;
198
199
2547
    len = get_bits(&s->gb, 16) - 2;
200
201
2547
    if (8*len > get_bits_left(&s->gb)) {
202
        av_log(s->avctx, AV_LOG_ERROR, "dqt: len %d is too large\n", len);
203
        return AVERROR_INVALIDDATA;
204
    }
205
206
5589
    while (len >= 65) {
207
3042
        int pr = get_bits(&s->gb, 4);
208
3042
        if (pr > 1) {
209
            av_log(s->avctx, AV_LOG_ERROR, "dqt: invalid precision\n");
210
            return AVERROR_INVALIDDATA;
211
        }
212
3042
        index = get_bits(&s->gb, 4);
213
3042
        if (index >= 4)
214
            return -1;
215
3042
        av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index);
216
        /* read quant table */
217
197730
        for (i = 0; i < 64; i++) {
218
194688
            s->quant_matrixes[index][i] = get_bits(&s->gb, pr ? 16 : 8);
219
194688
            if (s->quant_matrixes[index][i] == 0) {
220
                av_log(s->avctx, AV_LOG_ERROR, "dqt: 0 quant value\n");
221
                return AVERROR_INVALIDDATA;
222
            }
223
        }
224
225
        // XXX FIXME fine-tune, and perhaps add dc too
226
3042
        s->qscale[index] = FFMAX(s->quant_matrixes[index][1],
227
3042
                                 s->quant_matrixes[index][8]) >> 1;
228
3042
        av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n",
229
               index, s->qscale[index]);
230
3042
        len -= 1 + 64 * (1+pr);
231
    }
232
2547
    return 0;
233
}
234
235
/* decode huffman tables and build VLC decoders */
236
2556
int ff_mjpeg_decode_dht(MJpegDecodeContext *s)
237
{
238
    int len, index, i, class, n, v;
239
    uint8_t bits_table[17];
240
    uint8_t val_table[256];
241
2556
    int ret = 0;
242
243
2556
    len = get_bits(&s->gb, 16) - 2;
244
245
2556
    if (8*len > get_bits_left(&s->gb)) {
246
        av_log(s->avctx, AV_LOG_ERROR, "dht: len %d is too large\n", len);
247
        return AVERROR_INVALIDDATA;
248
    }
249
250
11698
    while (len > 0) {
251
9142
        if (len < 17)
252
            return AVERROR_INVALIDDATA;
253
9142
        class = get_bits(&s->gb, 4);
254
9142
        if (class >= 2)
255
            return AVERROR_INVALIDDATA;
256
9142
        index = get_bits(&s->gb, 4);
257
9142
        if (index >= 4)
258
            return AVERROR_INVALIDDATA;
259
9142
        n = 0;
260
155414
        for (i = 1; i <= 16; i++) {
261
146272
            bits_table[i] = get_bits(&s->gb, 8);
262
146272
            n += bits_table[i];
263
        }
264
9142
        len -= 17;
265

9142
        if (len < n || n > 256)
266
            return AVERROR_INVALIDDATA;
267
268
459243
        for (i = 0; i < n; i++) {
269
450101
            v = get_bits(&s->gb, 8);
270
450101
            val_table[i] = v;
271
        }
272
9142
        len -= n;
273
274
        /* build VLC and flush previous vlc if present */
275
9142
        ff_free_vlc(&s->vlcs[class][index]);
276
9142
        av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
277
               class, index, n);
278
9142
        if ((ret = ff_mjpeg_build_vlc(&s->vlcs[class][index], bits_table,
279
9142
                                      val_table, class > 0, s->avctx)) < 0)
280
            return ret;
281
282
9142
        if (class > 0) {
283
4571
            ff_free_vlc(&s->vlcs[2][index]);
284
4571
            if ((ret = ff_mjpeg_build_vlc(&s->vlcs[2][index], bits_table,
285
4571
                                          val_table, 0, s->avctx)) < 0)
286
                return ret;
287
        }
288
289
155414
        for (i = 0; i < 16; i++)
290
146272
            s->raw_huffman_lengths[class][index][i] = bits_table[i + 1];
291
2349494
        for (i = 0; i < 256; i++)
292
2340352
            s->raw_huffman_values[class][index][i] = val_table[i];
293
    }
294
2556
    return 0;
295
}
296
297
2565
int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
298
{
299
    int len, nb_components, i, width, height, bits, ret, size_change;
300
    unsigned pix_fmt_id;
301
2565
    int h_count[MAX_COMPONENTS] = { 0 };
302
2565
    int v_count[MAX_COMPONENTS] = { 0 };
303
304
2565
    s->cur_scan = 0;
305
2565
    memset(s->upscale_h, 0, sizeof(s->upscale_h));
306
2565
    memset(s->upscale_v, 0, sizeof(s->upscale_v));
307
308
2565
    len     = get_bits(&s->gb, 16);
309
2565
    bits    = get_bits(&s->gb, 8);
310
311

2565
    if (bits > 16 || bits < 1) {
312
        av_log(s->avctx, AV_LOG_ERROR, "bits %d is invalid\n", bits);
313
        return AVERROR_INVALIDDATA;
314
    }
315
316
2565
    if (s->avctx->bits_per_raw_sample != bits) {
317
85
        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);
318
85
        s->avctx->bits_per_raw_sample = bits;
319
85
        init_idct(s->avctx);
320
    }
321
2565
    if (s->pegasus_rct)
322
        bits = 9;
323

2565
    if (bits == 9 && !s->pegasus_rct)
324
        s->rct  = 1;    // FIXME ugly
325
326

2565
    if(s->lossless && s->avctx->lowres){
327
        av_log(s->avctx, AV_LOG_ERROR, "lowres is not possible with lossless jpeg\n");
328
        return -1;
329
    }
330
331
2565
    height = get_bits(&s->gb, 16);
332
2565
    width  = get_bits(&s->gb, 16);
333
334
    // HACK for odd_height.mov
335

2565
    if (s->interlaced && s->width == width && s->height == height + 1)
336
        height= s->height;
337
338
2565
    av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
339
2565
    if (av_image_check_size(width, height, 0, s->avctx) < 0)
340
        return AVERROR_INVALIDDATA;
341

2565
    if (s->buf_size && (width + 7) / 8 * ((height + 7) / 8) > s->buf_size * 4LL)
342
        return AVERROR_INVALIDDATA;
343
344
2565
    nb_components = get_bits(&s->gb, 8);
345

2565
    if (nb_components <= 0 ||
346
        nb_components > MAX_COMPONENTS)
347
        return -1;
348

2565
    if (s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
349
15
        if (nb_components != s->nb_components) {
350
            av_log(s->avctx, AV_LOG_ERROR,
351
                   "nb_components changing in interlaced picture\n");
352
            return AVERROR_INVALIDDATA;
353
        }
354
    }
355

2565
    if (s->ls && !(bits <= 8 || nb_components == 1)) {
356
        avpriv_report_missing_feature(s->avctx,
357
                                      "JPEG-LS that is not <= 8 "
358
                                      "bits/component or 16-bit gray");
359
        return AVERROR_PATCHWELCOME;
360
    }
361
2565
    if (len != 8 + 3 * nb_components) {
362
        av_log(s->avctx, AV_LOG_ERROR, "decode_sof0: error, len(%d) mismatch %d components\n", len, nb_components);
363
        return AVERROR_INVALIDDATA;
364
    }
365
366
2565
    s->nb_components = nb_components;
367
2565
    s->h_max         = 1;
368
2565
    s->v_max         = 1;
369
10256
    for (i = 0; i < nb_components; i++) {
370
        /* component id */
371
7691
        s->component_id[i] = get_bits(&s->gb, 8) - 1;
372
7691
        h_count[i]         = get_bits(&s->gb, 4);
373
7691
        v_count[i]         = get_bits(&s->gb, 4);
374
        /* compute hmax and vmax (only used in interleaved case) */
375
7691
        if (h_count[i] > s->h_max)
376
2151
            s->h_max = h_count[i];
377
7691
        if (v_count[i] > s->v_max)
378
2312
            s->v_max = v_count[i];
379
7691
        s->quant_index[i] = get_bits(&s->gb, 8);
380
7691
        if (s->quant_index[i] >= 4) {
381
            av_log(s->avctx, AV_LOG_ERROR, "quant_index is invalid\n");
382
            return AVERROR_INVALIDDATA;
383
        }
384

7691
        if (!h_count[i] || !v_count[i]) {
385
            av_log(s->avctx, AV_LOG_ERROR,
386
                   "Invalid sampling factor in component %d %d:%d\n",
387
                   i, h_count[i], v_count[i]);
388
            return AVERROR_INVALIDDATA;
389
        }
390
391
7691
        av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n",
392
               i, h_count[i], v_count[i],
393
               s->component_id[i], s->quant_index[i]);
394
    }
395
2565
    if (   nb_components == 4
396
        && s->component_id[0] == 'C' - 1
397
        && s->component_id[1] == 'M' - 1
398
        && s->component_id[2] == 'Y' - 1
399
        && s->component_id[3] == 'K' - 1)
400
        s->adobe_transform = 0;
401
402

2565
    if (s->ls && (s->h_max > 1 || s->v_max > 1)) {
403
        avpriv_report_missing_feature(s->avctx, "Subsampling in JPEG-LS");
404
        return AVERROR_PATCHWELCOME;
405
    }
406
407
2565
    if (s->bayer) {
408
        if (nb_components == 2) {
409
            /* Bayer images embedded in DNGs can contain 2 interleaved components and the
410
               width stored in their SOF3 markers is the width of each one.  We only output
411
               a single component, therefore we need to adjust the output image width.  We
412
               handle the deinterleaving (but not the debayering) in this file. */
413
            width *= 2;
414
        }
415
        /* They can also contain 1 component, which is double the width and half the height
416
            of the final image (rows are interleaved).  We don't handle the decoding in this
417
            file, but leave that to the TIFF/DNG decoder. */
418
    }
419
420
    /* if different size, realloc/alloc picture */
421

2565
    if (width != s->width || height != s->height || bits != s->bits ||
422
2222
        memcmp(s->h_count, h_count, sizeof(h_count))                ||
423
2222
        memcmp(s->v_count, v_count, sizeof(v_count))) {
424
343
        size_change = 1;
425
426
343
        s->width      = width;
427
343
        s->height     = height;
428
343
        s->bits       = bits;
429
343
        memcpy(s->h_count, h_count, sizeof(h_count));
430
343
        memcpy(s->v_count, v_count, sizeof(v_count));
431
343
        s->interlaced = 0;
432
343
        s->got_picture = 0;
433
434
        /* test interlaced mode */
435
343
        if (s->first_picture   &&
436

140
            (s->multiscope != 2 || s->avctx->time_base.den >= 25 * s->avctx->time_base.num) &&
437
140
            s->orig_height != 0 &&
438
110
            s->height < ((s->orig_height * 3) / 4)) {
439
4
            s->interlaced                    = 1;
440
4
            s->bottom_field                  = s->interlace_polarity;
441
4
            s->picture_ptr->interlaced_frame = 1;
442
4
            s->picture_ptr->top_field_first  = !s->interlace_polarity;
443
4
            height *= 2;
444
        }
445
446
343
        ret = ff_set_dimensions(s->avctx, width, height);
447
343
        if (ret < 0)
448
            return ret;
449
450
343
        if ((s->avctx->codec_tag == MKTAG('A', 'V', 'R', 'n') ||
451
343
             s->avctx->codec_tag == MKTAG('A', 'V', 'D', 'J')) &&
452
2
            s->orig_height < height)
453
2
            s->avctx->height = AV_CEIL_RSHIFT(s->orig_height, s->avctx->lowres);
454
455
343
        s->first_picture = 0;
456
    } else {
457
2222
        size_change = 0;
458
    }
459
460
2565
    if (s->avctx->codec_id == AV_CODEC_ID_SMVJPEG) {
461
3
        s->avctx->height = s->avctx->coded_height / s->smv_frames_per_jpeg;
462
3
        if (s->avctx->height <= 0)
463
            return AVERROR_INVALIDDATA;
464
    }
465
466

2565
    if (s->got_picture && s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
467
15
        if (s->progressive) {
468
            avpriv_request_sample(s->avctx, "progressively coded interlaced picture");
469
            return AVERROR_INVALIDDATA;
470
        }
471
    } else {
472


2550
        if (s->v_max == 1 && s->h_max == 1 && s->lossless==1 && (nb_components==3 || nb_components==4))
473
205
            s->rgb = 1;
474
2345
        else if (!s->lossless)
475
2140
            s->rgb = 0;
476
        /* XXX: not complete test ! */
477
2550
        pix_fmt_id = ((unsigned)s->h_count[0] << 28) | (s->v_count[0] << 24) |
478
2550
                     (s->h_count[1] << 20) | (s->v_count[1] << 16) |
479
2550
                     (s->h_count[2] << 12) | (s->v_count[2] <<  8) |
480
2550
                     (s->h_count[3] <<  4) |  s->v_count[3];
481
2550
        av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);
482
        /* NOTE we do not allocate pictures large enough for the possible
483
         * padding of h/v_count being 4 */
484
2550
        if (!(pix_fmt_id & 0xD0D0D0D0))
485
            pix_fmt_id -= (pix_fmt_id & 0xF0F0F0F0) >> 1;
486
2550
        if (!(pix_fmt_id & 0x0D0D0D0D))
487
408
            pix_fmt_id -= (pix_fmt_id & 0x0F0F0F0F) >> 1;
488
489
22950
        for (i = 0; i < 8; i++) {
490
20400
            int j = 6 + (i&1) - (i&6);
491
20400
            int is = (pix_fmt_id >> (4*i)) & 0xF;
492
20400
            int js = (pix_fmt_id >> (4*j)) & 0xF;
493
494


20400
            if (is == 1 && js != 2 && (i < 2 || i > 5))
495
1060
                js = (pix_fmt_id >> ( 8 + 4*(i&1))) & 0xF;
496


20400
            if (is == 1 && js != 2 && (i < 2 || i > 5))
497
1060
                js = (pix_fmt_id >> (16 + 4*(i&1))) & 0xF;
498
499

20400
            if (is == 1 && js == 2) {
500
                if (i & 1) s->upscale_h[j/2] = 1;
501
                else       s->upscale_v[j/2] = 1;
502
            }
503
        }
504
505
2550
        if (s->bayer) {
506
            if (pix_fmt_id != 0x11110000 && pix_fmt_id != 0x11000000)
507
                goto unk_pixfmt;
508
        }
509
510



2550
        switch (pix_fmt_id) {
511
        case 0x11110000: /* for bayer-encoded huffman lossless JPEGs embedded in DNGs */
512
            if (!s->bayer)
513
                goto unk_pixfmt;
514
            s->avctx->pix_fmt = AV_PIX_FMT_GRAY16LE;
515
            break;
516
412
        case 0x11111100:
517
412
            if (s->rgb)
518
205
                s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_BGR48;
519
            else {
520
207
                if (   s->adobe_transform == 0
521

207
                    || s->component_id[0] == 'R' - 1 && s->component_id[1] == 'G' - 1 && s->component_id[2] == 'B' - 1) {
522
                    s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_GBRP : AV_PIX_FMT_GBRP16;
523
                } else {
524

207
                    if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
525
                    else              s->avctx->pix_fmt = AV_PIX_FMT_YUV444P16;
526
207
                s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
527
                }
528
            }
529
412
            av_assert0(s->nb_components == 3);
530
412
            break;
531
        case 0x11111111:
532
            if (s->rgb)
533
                s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_ABGR : AV_PIX_FMT_RGBA64;
534
            else {
535
                if (s->adobe_transform == 0 && s->bits <= 8) {
536
                    s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;
537
                } else {
538
                    s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_YUVA444P : AV_PIX_FMT_YUVA444P16;
539
                    s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
540
                }
541
            }
542
            av_assert0(s->nb_components == 4);
543
            break;
544
        case 0x22111122:
545
        case 0x22111111:
546
            if (s->adobe_transform == 0 && s->bits <= 8) {
547
                s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;
548
                s->upscale_v[1] = s->upscale_v[2] = 1;
549
                s->upscale_h[1] = s->upscale_h[2] = 1;
550
            } else if (s->adobe_transform == 2 && s->bits <= 8) {
551
                s->avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
552
                s->upscale_v[1] = s->upscale_v[2] = 1;
553
                s->upscale_h[1] = s->upscale_h[2] = 1;
554
                s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
555
            } else {
556
                if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
557
                else              s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P16;
558
                s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
559
            }
560
            av_assert0(s->nb_components == 4);
561
            break;
562
        case 0x12121100:
563
        case 0x22122100:
564
        case 0x21211100:
565
        case 0x21112100:
566
        case 0x22211200:
567
        case 0x22221100:
568
        case 0x22112200:
569
        case 0x11222200:
570
            if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
571
            else
572
                goto unk_pixfmt;
573
            s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
574
            break;
575
2
        case 0x11000000:
576
        case 0x13000000:
577
        case 0x14000000:
578
        case 0x31000000:
579
        case 0x33000000:
580
        case 0x34000000:
581
        case 0x41000000:
582
        case 0x43000000:
583
        case 0x44000000:
584
2
            if(s->bits <= 8)
585
                s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
586
            else
587
2
                s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
588
2
            break;
589
        case 0x12111100:
590
        case 0x14121200:
591
        case 0x14111100:
592
        case 0x22211100:
593
        case 0x22112100:
594
            if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
595
                if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
596
                else
597
                    goto unk_pixfmt;
598
                s->upscale_v[0] = s->upscale_v[1] = 1;
599
            } else {
600
                if (pix_fmt_id == 0x14111100)
601
                    s->upscale_v[1] = s->upscale_v[2] = 1;
602
                if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV440P : AV_PIX_FMT_YUVJ440P;
603
                else
604
                    goto unk_pixfmt;
605
                s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
606
            }
607
            break;
608
232
        case 0x21111100:
609

232
            if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
610
                if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
611
                else
612
                    goto unk_pixfmt;
613
                s->upscale_h[0] = s->upscale_h[1] = 1;
614
            } else {
615

232
                if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
616
                else              s->avctx->pix_fmt = AV_PIX_FMT_YUV422P16;
617
232
                s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
618
            }
619
232
            break;
620
        case 0x31111100:
621
            if (s->bits > 8)
622
                goto unk_pixfmt;
623
            s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
624
            s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
625
            s->upscale_h[1] = s->upscale_h[2] = 2;
626
            break;
627
        case 0x22121100:
628
        case 0x22111200:
629
            if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
630
            else
631
                goto unk_pixfmt;
632
            s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
633
            break;
634
1904
        case 0x22111100:
635
        case 0x23111100:
636
        case 0x42111100:
637
        case 0x24111100:
638

1904
            if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUVJ420P;
639
            else              s->avctx->pix_fmt = AV_PIX_FMT_YUV420P16;
640
1904
            s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
641
1904
            if (pix_fmt_id == 0x42111100) {
642
                if (s->bits > 8)
643
                    goto unk_pixfmt;
644
                s->upscale_h[1] = s->upscale_h[2] = 1;
645
1904
            } else if (pix_fmt_id == 0x24111100) {
646
                if (s->bits > 8)
647
                    goto unk_pixfmt;
648
                s->upscale_v[1] = s->upscale_v[2] = 1;
649
1904
            } else if (pix_fmt_id == 0x23111100) {
650
                if (s->bits > 8)
651
                    goto unk_pixfmt;
652
                s->upscale_v[1] = s->upscale_v[2] = 2;
653
            }
654
1904
            break;
655
        case 0x41111100:
656
            if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV411P : AV_PIX_FMT_YUVJ411P;
657
            else
658
                goto unk_pixfmt;
659
            s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
660
            break;
661
        default:
662
    unk_pixfmt:
663
            avpriv_report_missing_feature(s->avctx, "Pixel format 0x%x bits:%d", pix_fmt_id, s->bits);
664
            memset(s->upscale_h, 0, sizeof(s->upscale_h));
665
            memset(s->upscale_v, 0, sizeof(s->upscale_v));
666
            return AVERROR_PATCHWELCOME;
667
        }
668

2550
        if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->avctx->lowres) {
669
            avpriv_report_missing_feature(s->avctx, "Lowres for weird subsampling");
670
            return AVERROR_PATCHWELCOME;
671
        }
672


2550
        if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->progressive && s->avctx->pix_fmt == AV_PIX_FMT_GBRP) {
673
            avpriv_report_missing_feature(s->avctx, "progressive for weird subsampling");
674
            return AVERROR_PATCHWELCOME;
675
        }
676
2550
        if (s->ls) {
677
205
            memset(s->upscale_h, 0, sizeof(s->upscale_h));
678
205
            memset(s->upscale_v, 0, sizeof(s->upscale_v));
679
205
            if (s->nb_components == 3) {
680
205
                s->avctx->pix_fmt = AV_PIX_FMT_RGB24;
681
            } else if (s->nb_components != 1) {
682
                av_log(s->avctx, AV_LOG_ERROR, "Unsupported number of components %d\n", s->nb_components);
683
                return AVERROR_PATCHWELCOME;
684
            } else if (s->palette_index && s->bits <= 8)
685
                s->avctx->pix_fmt = AV_PIX_FMT_PAL8;
686
            else if (s->bits <= 8)
687
                s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
688
            else
689
                s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
690
        }
691
692
2550
        s->pix_desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
693
2550
        if (!s->pix_desc) {
694
            av_log(s->avctx, AV_LOG_ERROR, "Could not get a pixel format descriptor.\n");
695
            return AVERROR_BUG;
696
        }
697
698

2550
        if (s->avctx->pix_fmt == s->hwaccel_sw_pix_fmt && !size_change) {
699
2207
            s->avctx->pix_fmt = s->hwaccel_pix_fmt;
700
        } else {
701
343
            enum AVPixelFormat pix_fmts[] = {
702
#if CONFIG_MJPEG_NVDEC_HWACCEL
703
                AV_PIX_FMT_CUDA,
704
#endif
705
#if CONFIG_MJPEG_VAAPI_HWACCEL
706
                AV_PIX_FMT_VAAPI,
707
#endif
708
343
                s->avctx->pix_fmt,
709
                AV_PIX_FMT_NONE,
710
            };
711
343
            s->hwaccel_pix_fmt = ff_get_format(s->avctx, pix_fmts);
712
343
            if (s->hwaccel_pix_fmt < 0)
713
                return AVERROR(EINVAL);
714
715
343
            s->hwaccel_sw_pix_fmt = s->avctx->pix_fmt;
716
343
            s->avctx->pix_fmt     = s->hwaccel_pix_fmt;
717
        }
718
719
2550
        if (s->avctx->skip_frame == AVDISCARD_ALL) {
720
67
            s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
721
67
            s->picture_ptr->key_frame = 1;
722
67
            s->got_picture            = 1;
723
67
            return 0;
724
        }
725
726
2483
        av_frame_unref(s->picture_ptr);
727
2483
        if (ff_get_buffer(s->avctx, s->picture_ptr, AV_GET_BUFFER_FLAG_REF) < 0)
728
            return -1;
729
2483
        s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
730
2483
        s->picture_ptr->key_frame = 1;
731
2483
        s->got_picture            = 1;
732
733
12415
        for (i = 0; i < 4; i++)
734
9932
            s->linesize[i] = s->picture_ptr->linesize[i] << s->interlaced;
735
736
        ff_dlog(s->avctx, "%d %d %d %d %d %d\n",
737
                s->width, s->height, s->linesize[0], s->linesize[1],
738
                s->interlaced, s->avctx->height);
739
740
    }
741
742

2498
    if ((s->rgb && !s->lossless && !s->ls) ||
743

2498
        (!s->rgb && s->ls && s->nb_components > 1) ||
744

2498
        (s->avctx->pix_fmt == AV_PIX_FMT_PAL8 && !s->ls)
745
    ) {
746
        av_log(s->avctx, AV_LOG_ERROR, "Unsupported coding and pixel format combination\n");
747
        return AVERROR_PATCHWELCOME;
748
    }
749
750
    /* totally blank picture as progressive JPEG will only add details to it */
751
2498
    if (s->progressive) {
752
        int bw = (width  + s->h_max * 8 - 1) / (s->h_max * 8);
753
        int bh = (height + s->v_max * 8 - 1) / (s->v_max * 8);
754
        for (i = 0; i < s->nb_components; i++) {
755
            int size = bw * bh * s->h_count[i] * s->v_count[i];
756
            av_freep(&s->blocks[i]);
757
            av_freep(&s->last_nnz[i]);
758
            s->blocks[i]       = av_mallocz_array(size, sizeof(**s->blocks));
759
            s->last_nnz[i]     = av_mallocz_array(size, sizeof(**s->last_nnz));
760
            if (!s->blocks[i] || !s->last_nnz[i])
761
                return AVERROR(ENOMEM);
762
            s->block_stride[i] = bw * s->h_count[i];
763
        }
764
        memset(s->coefs_finished, 0, sizeof(s->coefs_finished));
765
    }
766
767
2498
    if (s->avctx->hwaccel) {
768
        s->hwaccel_picture_private =
769
            av_mallocz(s->avctx->hwaccel->frame_priv_data_size);
770
        if (!s->hwaccel_picture_private)
771
            return AVERROR(ENOMEM);
772
773
        ret = s->avctx->hwaccel->start_frame(s->avctx, s->raw_image_buffer,
774
                                             s->raw_image_buffer_size);
775
        if (ret < 0)
776
            return ret;
777
    }
778
779
2498
    return 0;
780
}
781
782
26793158
static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
783
{
784
    int code;
785
26793158
    code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
786

26793158
    if (code < 0 || code > 16) {
787
        av_log(s->avctx, AV_LOG_WARNING,
788
               "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
789
               0, dc_index, &s->vlcs[0][dc_index]);
790
        return 0xfffff;
791
    }
792
793
26793158
    if (code)
794
23754762
        return get_xbits(&s->gb, code);
795
    else
796
3038396
        return 0;
797
}
798
799
/* decode block and dequantize */
800
3896858
static int decode_block(MJpegDecodeContext *s, int16_t *block, int component,
801
                        int dc_index, int ac_index, uint16_t *quant_matrix)
802
{
803
    int code, i, j, level, val;
804
805
    /* DC coef */
806
3896858
    val = mjpeg_decode_dc(s, dc_index);
807
3896858
    if (val == 0xfffff) {
808
        av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
809
        return AVERROR_INVALIDDATA;
810
    }
811
3896858
    val = val * (unsigned)quant_matrix[0] + s->last_dc[component];
812
3896858
    val = av_clip_int16(val);
813
3896858
    s->last_dc[component] = val;
814
3896858
    block[0] = val;
815
    /* AC coefs */
816
3896858
    i = 0;
817
3896858
    {OPEN_READER(re, &s->gb);
818
    do {
819
36066577
        UPDATE_CACHE(re, &s->gb);
820
36066577
        GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2);
821
822
36066577
        i += ((unsigned)code) >> 4;
823
36066577
            code &= 0xf;
824
36066577
        if (code) {
825
32220502
            if (code > MIN_CACHE_BITS - 16)
826
485
                UPDATE_CACHE(re, &s->gb);
827
828
            {
829
32220502
                int cache = GET_CACHE(re, &s->gb);
830
32220502
                int sign  = (~cache) >> 31;
831
32220502
                level     = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
832
            }
833
834
32220502
            LAST_SKIP_BITS(re, &s->gb, code);
835
836
32220502
            if (i > 63) {
837
                av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
838
                return AVERROR_INVALIDDATA;
839
            }
840
32220502
            j        = s->scantable.permutated[i];
841
32220502
            block[j] = level * quant_matrix[i];
842
        }
843
36066577
    } while (i < 63);
844
3896858
    CLOSE_READER(re, &s->gb);}
845
846
3896858
    return 0;
847
}
848
849
static int decode_dc_progressive(MJpegDecodeContext *s, int16_t *block,
850
                                 int component, int dc_index,
851
                                 uint16_t *quant_matrix, int Al)
852
{
853
    unsigned val;
854
    s->bdsp.clear_block(block);
855
    val = mjpeg_decode_dc(s, dc_index);
856
    if (val == 0xfffff) {
857
        av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
858
        return AVERROR_INVALIDDATA;
859
    }
860
    val = (val * (quant_matrix[0] << Al)) + s->last_dc[component];
861
    s->last_dc[component] = val;
862
    block[0] = val;
863
    return 0;
864
}
865
866
/* decode block and dequantize - progressive JPEG version */
867
static int decode_block_progressive(MJpegDecodeContext *s, int16_t *block,
868
                                    uint8_t *last_nnz, int ac_index,
869
                                    uint16_t *quant_matrix,
870
                                    int ss, int se, int Al, int *EOBRUN)
871
{
872
    int code, i, j, val, run;
873
    unsigned level;
874
875
    if (*EOBRUN) {
876
        (*EOBRUN)--;
877
        return 0;
878
    }
879
880
    {
881
        OPEN_READER(re, &s->gb);
882
        for (i = ss; ; i++) {
883
            UPDATE_CACHE(re, &s->gb);
884
            GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
885
886
            run = ((unsigned) code) >> 4;
887
            code &= 0xF;
888
            if (code) {
889
                i += run;
890
                if (code > MIN_CACHE_BITS - 16)
891
                    UPDATE_CACHE(re, &s->gb);
892
893
                {
894
                    int cache = GET_CACHE(re, &s->gb);
895
                    int sign  = (~cache) >> 31;
896
                    level     = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
897
                }
898
899
                LAST_SKIP_BITS(re, &s->gb, code);
900
901
                if (i >= se) {
902
                    if (i == se) {
903
                        j = s->scantable.permutated[se];
904
                        block[j] = level * (quant_matrix[se] << Al);
905
                        break;
906
                    }
907
                    av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
908
                    return AVERROR_INVALIDDATA;
909
                }
910
                j = s->scantable.permutated[i];
911
                block[j] = level * (quant_matrix[i] << Al);
912
            } else {
913
                if (run == 0xF) {// ZRL - skip 15 coefficients
914
                    i += 15;
915
                    if (i >= se) {
916
                        av_log(s->avctx, AV_LOG_ERROR, "ZRL overflow: %d\n", i);
917
                        return AVERROR_INVALIDDATA;
918
                    }
919
                } else {
920
                    val = (1 << run);
921
                    if (run) {
922
                        UPDATE_CACHE(re, &s->gb);
923
                        val += NEG_USR32(GET_CACHE(re, &s->gb), run);
924
                        LAST_SKIP_BITS(re, &s->gb, run);
925
                    }
926
                    *EOBRUN = val - 1;
927
                    break;
928
                }
929
            }
930
        }
931
        CLOSE_READER(re, &s->gb);
932
    }
933
934
    if (i > *last_nnz)
935
        *last_nnz = i;
936
937
    return 0;
938
}
939
940
#define REFINE_BIT(j) {                                             \
941
    UPDATE_CACHE(re, &s->gb);                                       \
942
    sign = block[j] >> 15;                                          \
943
    block[j] += SHOW_UBITS(re, &s->gb, 1) *                         \
944
                ((quant_matrix[i] ^ sign) - sign) << Al;            \
945
    LAST_SKIP_BITS(re, &s->gb, 1);                                  \
946
}
947
948
#define ZERO_RUN                                                    \
949
for (; ; i++) {                                                     \
950
    if (i > last) {                                                 \
951
        i += run;                                                   \
952
        if (i > se) {                                               \
953
            av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \
954
            return -1;                                              \
955
        }                                                           \
956
        break;                                                      \
957
    }                                                               \
958
    j = s->scantable.permutated[i];                                 \
959
    if (block[j])                                                   \
960
        REFINE_BIT(j)                                               \
961
    else if (run-- == 0)                                            \
962
        break;                                                      \
963
}
964
965
/* decode block and dequantize - progressive JPEG refinement pass */
966
static int decode_block_refinement(MJpegDecodeContext *s, int16_t *block,
967
                                   uint8_t *last_nnz,
968
                                   int ac_index, uint16_t *quant_matrix,
969
                                   int ss, int se, int Al, int *EOBRUN)
970
{
971
    int code, i = ss, j, sign, val, run;
972
    int last    = FFMIN(se, *last_nnz);
973
974
    OPEN_READER(re, &s->gb);
975
    if (*EOBRUN) {
976
        (*EOBRUN)--;
977
    } else {
978
        for (; ; i++) {
979
            UPDATE_CACHE(re, &s->gb);
980
            GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
981
982
            if (code & 0xF) {
983
                run = ((unsigned) code) >> 4;
984
                UPDATE_CACHE(re, &s->gb);
985
                val = SHOW_UBITS(re, &s->gb, 1);
986
                LAST_SKIP_BITS(re, &s->gb, 1);
987
                ZERO_RUN;
988
                j = s->scantable.permutated[i];
989
                val--;
990
                block[j] = ((quant_matrix[i] << Al) ^ val) - val;
991
                if (i == se) {
992
                    if (i > *last_nnz)
993
                        *last_nnz = i;
994
                    CLOSE_READER(re, &s->gb);
995
                    return 0;
996
                }
997
            } else {
998
                run = ((unsigned) code) >> 4;
999
                if (run == 0xF) {
1000
                    ZERO_RUN;
1001
                } else {
1002
                    val = run;
1003
                    run = (1 << run);
1004
                    if (val) {
1005
                        UPDATE_CACHE(re, &s->gb);
1006
                        run += SHOW_UBITS(re, &s->gb, val);
1007
                        LAST_SKIP_BITS(re, &s->gb, val);
1008
                    }
1009
                    *EOBRUN = run - 1;
1010
                    break;
1011
                }
1012
            }
1013
        }
1014
1015
        if (i > *last_nnz)
1016
            *last_nnz = i;
1017
    }
1018
1019
    for (; i <= last; i++) {
1020
        j = s->scantable.permutated[i];
1021
        if (block[j])
1022
            REFINE_BIT(j)
1023
    }
1024
    CLOSE_READER(re, &s->gb);
1025
1026
    return 0;
1027
}
1028
#undef REFINE_BIT
1029
#undef ZERO_RUN
1030
1031
774527
static int handle_rstn(MJpegDecodeContext *s, int nb_components)
1032
{
1033
    int i;
1034
774527
    int reset = 0;
1035
1036
774527
    if (s->restart_interval) {
1037
        s->restart_count--;
1038
        if(s->restart_count == 0 && s->avctx->codec_id == AV_CODEC_ID_THP){
1039
            align_get_bits(&s->gb);
1040
            for (i = 0; i < nb_components; i++) /* reset dc */
1041
                s->last_dc[i] = (4 << s->bits);
1042
        }
1043
1044
        i = 8 + ((-get_bits_count(&s->gb)) & 7);
1045
        /* skip RSTn */
1046
        if (s->restart_count == 0) {
1047
            if(   show_bits(&s->gb, i) == (1 << i) - 1
1048
               || show_bits(&s->gb, i) == 0xFF) {
1049
                int pos = get_bits_count(&s->gb);
1050
                align_get_bits(&s->gb);
1051
                while (get_bits_left(&s->gb) >= 8 && show_bits(&s->gb, 8) == 0xFF)
1052
                    skip_bits(&s->gb, 8);
1053
                if (get_bits_left(&s->gb) >= 8 && (get_bits(&s->gb, 8) & 0xF8) == 0xD0) {
1054
                    for (i = 0; i < nb_components; i++) /* reset dc */
1055
                        s->last_dc[i] = (4 << s->bits);
1056
                    reset = 1;
1057
                } else
1058
                    skip_bits_long(&s->gb, pos - get_bits_count(&s->gb));
1059
            }
1060
        }
1061
    }
1062
774527
    return reset;
1063
}
1064
1065
/* Handles 1 to 4 components */
1066
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int nb_components, int predictor, int point_transform)
1067
{
1068
    int i, mb_x, mb_y;
1069
    unsigned width;
1070
    uint16_t (*buffer)[4];
1071
    int left[4], top[4], topleft[4];
1072
    const int linesize = s->linesize[0];
1073
    const int mask     = ((1 << s->bits) - 1) << point_transform;
1074
    int resync_mb_y = 0;
1075
    int resync_mb_x = 0;
1076
    int vpred[6];
1077
1078
    if (!s->bayer && s->nb_components < 3)
1079
        return AVERROR_INVALIDDATA;
1080
    if (s->bayer && s->nb_components > 2)
1081
        return AVERROR_INVALIDDATA;
1082
    if (s->nb_components <= 0 || s->nb_components > 4)
1083
        return AVERROR_INVALIDDATA;
1084
    if (s->v_max != 1 || s->h_max != 1 || !s->lossless)
1085
        return AVERROR_INVALIDDATA;
1086
1087
1088
    s->restart_count = s->restart_interval;
1089
1090
    if (s->restart_interval == 0)
1091
        s->restart_interval = INT_MAX;
1092
1093
    if (s->bayer)
1094
        width = s->mb_width / nb_components; /* Interleaved, width stored is the total so need to divide */
1095
    else
1096
        width = s->mb_width;
1097
1098
    av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size, width * 4 * sizeof(s->ljpeg_buffer[0][0]));
1099
    if (!s->ljpeg_buffer)
1100
        return AVERROR(ENOMEM);
1101
1102
    buffer = s->ljpeg_buffer;
1103
1104
    for (i = 0; i < 4; i++)
1105
        buffer[0][i] = 1 << (s->bits - 1);
1106
1107
    for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1108
        uint8_t *ptr = s->picture_ptr->data[0] + (linesize * mb_y);
1109
1110
        if (s->interlaced && s->bottom_field)
1111
            ptr += linesize >> 1;
1112
1113
        for (i = 0; i < 4; i++)
1114
            top[i] = left[i] = topleft[i] = buffer[0][i];
1115
1116
        if ((mb_y * s->width) % s->restart_interval == 0) {
1117
            for (i = 0; i < 6; i++)
1118
                vpred[i] = 1 << (s->bits-1);
1119
        }
1120
1121
        for (mb_x = 0; mb_x < width; mb_x++) {
1122
            int modified_predictor = predictor;
1123
1124
            if (get_bits_left(&s->gb) < 1) {
1125
                av_log(s->avctx, AV_LOG_ERROR, "bitstream end in rgb_scan\n");
1126
                return AVERROR_INVALIDDATA;
1127
            }
1128
1129
            if (s->restart_interval && !s->restart_count){
1130
                s->restart_count = s->restart_interval;
1131
                resync_mb_x = mb_x;
1132
                resync_mb_y = mb_y;
1133
                for(i=0; i<4; i++)
1134
                    top[i] = left[i]= topleft[i]= 1 << (s->bits - 1);
1135
            }
1136
            if (mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || !mb_x)
1137
                modified_predictor = 1;
1138
1139
            for (i=0;i<nb_components;i++) {
1140
                int pred, dc;
1141
1142
                topleft[i] = top[i];
1143
                top[i]     = buffer[mb_x][i];
1144
1145
                dc = mjpeg_decode_dc(s, s->dc_index[i]);
1146
                if(dc == 0xFFFFF)
1147
                    return -1;
1148
1149
                if (!s->bayer || mb_x) {
1150
                    pred = left[i];
1151
                } else { /* This path runs only for the first line in bayer images */
1152
                    vpred[i] += dc;
1153
                    pred = vpred[i] - dc;
1154
                }
1155
1156
                PREDICT(pred, topleft[i], top[i], pred, modified_predictor);
1157
1158
                left[i] = buffer[mb_x][i] =
1159
                    mask & (pred + (unsigned)(dc * (1 << point_transform)));
1160
            }
1161
1162
            if (s->restart_interval && !--s->restart_count) {
1163
                align_get_bits(&s->gb);
1164
                skip_bits(&s->gb, 16); /* skip RSTn */
1165
            }
1166
        }
1167
        if (s->rct && s->nb_components == 4) {
1168
            for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1169
                ptr[4*mb_x + 2] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1170
                ptr[4*mb_x + 1] = buffer[mb_x][1] + ptr[4*mb_x + 2];
1171
                ptr[4*mb_x + 3] = buffer[mb_x][2] + ptr[4*mb_x + 2];
1172
                ptr[4*mb_x + 0] = buffer[mb_x][3];
1173
            }
1174
        } else if (s->nb_components == 4) {
1175
            for(i=0; i<nb_components; i++) {
1176
                int c= s->comp_index[i];
1177
                if (s->bits <= 8) {
1178
                    for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1179
                        ptr[4*mb_x+3-c] = buffer[mb_x][i];
1180
                    }
1181
                } else if(s->bits == 9) {
1182
                    return AVERROR_PATCHWELCOME;
1183
                } else {
1184
                    for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1185
                        ((uint16_t*)ptr)[4*mb_x+c] = buffer[mb_x][i];
1186
                    }
1187
                }
1188
            }
1189
        } else if (s->rct) {
1190
            for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1191
                ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1192
                ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1193
                ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1194
            }
1195
        } else if (s->pegasus_rct) {
1196
            for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1197
                ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2]) >> 2);
1198
                ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1199
                ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1200
            }
1201
        } else if (s->bayer) {
1202
            if (nb_components == 1) {
1203
                /* Leave decoding to the TIFF/DNG decoder (see comment in ff_mjpeg_decode_sof) */
1204
                for (mb_x = 0; mb_x < width; mb_x++)
1205
                    ((uint16_t*)ptr)[mb_x] = buffer[mb_x][0];
1206
            } else if (nb_components == 2) {
1207
                for (mb_x = 0; mb_x < width; mb_x++) {
1208
                    ((uint16_t*)ptr)[2*mb_x + 0] = buffer[mb_x][0];
1209
                    ((uint16_t*)ptr)[2*mb_x + 1] = buffer[mb_x][1];
1210
                }
1211
            }
1212
        } else {
1213
            for(i=0; i<nb_components; i++) {
1214
                int c= s->comp_index[i];
1215
                if (s->bits <= 8) {
1216
                    for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1217
                        ptr[3*mb_x+2-c] = buffer[mb_x][i];
1218
                    }
1219
                } else if(s->bits == 9) {
1220
                    return AVERROR_PATCHWELCOME;
1221
                } else {
1222
                    for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1223
                        ((uint16_t*)ptr)[3*mb_x+2-c] = buffer[mb_x][i];
1224
                    }
1225
                }
1226
            }
1227
        }
1228
    }
1229
    return 0;
1230
}
1231
1232
200
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
1233
                                 int point_transform, int nb_components)
1234
{
1235
    int i, mb_x, mb_y, mask;
1236
200
    int bits= (s->bits+7)&~7;
1237
200
    int resync_mb_y = 0;
1238
200
    int resync_mb_x = 0;
1239
1240
200
    point_transform += bits - s->bits;
1241
200
    mask = ((1 << s->bits) - 1) << point_transform;
1242
1243

200
    av_assert0(nb_components>=1 && nb_components<=4);
1244
1245
22650
    for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1246
3838500
        for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1247
3816050
            if (get_bits_left(&s->gb) < 1) {
1248
                av_log(s->avctx, AV_LOG_ERROR, "bitstream end in yuv_scan\n");
1249
                return AVERROR_INVALIDDATA;
1250
            }
1251

3816050
            if (s->restart_interval && !s->restart_count){
1252
                s->restart_count = s->restart_interval;
1253
                resync_mb_x = mb_x;
1254
                resync_mb_y = mb_y;
1255
            }
1256
1257


3865550
            if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->interlaced){
1258

49500
                int toprow  = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x;
1259

49500
                int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x;
1260
198000
                for (i = 0; i < nb_components; i++) {
1261
                    uint8_t *ptr;
1262
                    uint16_t *ptr16;
1263
                    int n, h, v, x, y, c, j, linesize;
1264
148500
                    n = s->nb_blocks[i];
1265
148500
                    c = s->comp_index[i];
1266
148500
                    h = s->h_scount[i];
1267
148500
                    v = s->v_scount[i];
1268
148500
                    x = 0;
1269
148500
                    y = 0;
1270
148500
                    linesize= s->linesize[c];
1271
1272
148500
                    if(bits>8) linesize /= 2;
1273
1274
445500
                    for(j=0; j<n; j++) {
1275
                        int pred, dc;
1276
1277
297000
                        dc = mjpeg_decode_dc(s, s->dc_index[i]);
1278
297000
                        if(dc == 0xFFFFF)
1279
                            return -1;
1280
297000
                        if (   h * mb_x + x >= s->width
1281
297000
                            || v * mb_y + y >= s->height) {
1282
                            // Nothing to do
1283
297000
                        } else if (bits<=8) {
1284
297000
                            ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1285

297000
                            if(y==0 && toprow){
1286

109000
                                if(x==0 && leftcol){
1287
600
                                    pred= 1 << (bits - 1);
1288
                                }else{
1289
108400
                                    pred= ptr[-1];
1290
                                }
1291
                            }else{
1292

188000
                                if(x==0 && leftcol){
1293
89200
                                    pred= ptr[-linesize];
1294
                                }else{
1295


98800
                                    PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1296
                                }
1297
                            }
1298
1299

297000
                            if (s->interlaced && s->bottom_field)
1300
                                ptr += linesize >> 1;
1301
297000
                            pred &= mask;
1302
297000
                            *ptr= pred + ((unsigned)dc << point_transform);
1303
                        }else{
1304
                            ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1305
                            if(y==0 && toprow){
1306
                                if(x==0 && leftcol){
1307
                                    pred= 1 << (bits - 1);
1308
                                }else{
1309
                                    pred= ptr16[-1];
1310
                                }
1311
                            }else{
1312
                                if(x==0 && leftcol){
1313
                                    pred= ptr16[-linesize];
1314
                                }else{
1315
                                    PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1316
                                }
1317
                            }
1318
1319
                            if (s->interlaced && s->bottom_field)
1320
                                ptr16 += linesize >> 1;
1321
                            pred &= mask;
1322
                            *ptr16= pred + ((unsigned)dc << point_transform);
1323
                        }
1324
297000
                        if (++x == h) {
1325
198000
                            x = 0;
1326
198000
                            y++;
1327
                        }
1328
                    }
1329
                }
1330
            } else {
1331
15066200
                for (i = 0; i < nb_components; i++) {
1332
                    uint8_t *ptr;
1333
                    uint16_t *ptr16;
1334
                    int n, h, v, x, y, c, j, linesize, dc;
1335
11299650
                    n        = s->nb_blocks[i];
1336
11299650
                    c        = s->comp_index[i];
1337
11299650
                    h        = s->h_scount[i];
1338
11299650
                    v        = s->v_scount[i];
1339
11299650
                    x        = 0;
1340
11299650
                    y        = 0;
1341
11299650
                    linesize = s->linesize[c];
1342
1343
11299650
                    if(bits>8) linesize /= 2;
1344
1345
33898950
                    for (j = 0; j < n; j++) {
1346
                        int pred;
1347
1348
22599300
                        dc = mjpeg_decode_dc(s, s->dc_index[i]);
1349
22599300
                        if(dc == 0xFFFFF)
1350
                            return -1;
1351
22599300
                        if (   h * mb_x + x >= s->width
1352
22599300
                            || v * mb_y + y >= s->height) {
1353
                            // Nothing to do
1354
22599300
                        } else if (bits<=8) {
1355
22599300
                            ptr = s->picture_ptr->data[c] +
1356
22599300
                              (linesize * (v * mb_y + y)) +
1357
22599300
                              (h * mb_x + x); //FIXME optimize this crap
1358


22599300
                            PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1359
1360
22599300
                            pred &= mask;
1361
22599300
                            *ptr = pred + ((unsigned)dc << point_transform);
1362
                        }else{
1363
                            ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1364
                            PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1365
1366
                            pred &= mask;
1367
                            *ptr16= pred + ((unsigned)dc << point_transform);
1368
                        }
1369
1370
22599300
                        if (++x == h) {
1371
15066200
                            x = 0;
1372
15066200
                            y++;
1373
                        }
1374
                    }
1375
                }
1376
            }
1377

3816050
            if (s->restart_interval && !--s->restart_count) {
1378
                align_get_bits(&s->gb);
1379
                skip_bits(&s->gb, 16); /* skip RSTn */
1380
            }
1381
        }
1382
    }
1383
200
    return 0;
1384
}
1385
1386
786684
static av_always_inline void mjpeg_copy_block(MJpegDecodeContext *s,
1387
                                              uint8_t *dst, const uint8_t *src,
1388
                                              int linesize, int lowres)
1389
{
1390

786684
    switch (lowres) {
1391
786684
    case 0: s->hdsp.put_pixels_tab[1][0](dst, src, linesize, 8);
1392
786684
        break;
1393
    case 1: copy_block4(dst, src, linesize, linesize, 4);
1394
        break;
1395
    case 2: copy_block2(dst, src, linesize, linesize, 2);
1396
        break;
1397
    case 3: *dst = *src;
1398
        break;
1399
    }
1400
786684
}
1401
1402
11750
static void shift_output(MJpegDecodeContext *s, uint8_t *ptr, int linesize)
1403
{
1404
    int block_x, block_y;
1405
11750
    int size = 8 >> s->avctx->lowres;
1406
11750
    if (s->bits > 8) {
1407
105750
        for (block_y=0; block_y<size; block_y++)
1408
846000
            for (block_x=0; block_x<size; block_x++)
1409
752000
                *(uint16_t*)(ptr + 2*block_x + block_y*linesize) <<= 16 - s->bits;
1410
    } else {
1411
        for (block_y=0; block_y<size; block_y++)
1412
            for (block_x=0; block_x<size; block_x++)
1413
                *(ptr + block_x + block_y*linesize) <<= 8 - s->bits;
1414
    }
1415
11750
}
1416
1417
2121
static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
1418
                             int Al, const uint8_t *mb_bitmask,
1419
                             int mb_bitmask_size,
1420
                             const AVFrame *reference)
1421
{
1422
    int i, mb_x, mb_y, chroma_h_shift, chroma_v_shift, chroma_width, chroma_height;
1423
    uint8_t *data[MAX_COMPONENTS];
1424
    const uint8_t *reference_data[MAX_COMPONENTS];
1425
    int linesize[MAX_COMPONENTS];
1426
2121
    GetBitContext mb_bitmask_gb = {0}; // initialize to silence gcc warning
1427
2121
    int bytes_per_pixel = 1 + (s->bits > 8);
1428
1429
2121
    if (mb_bitmask) {
1430
31
        if (mb_bitmask_size != (s->mb_width * s->mb_height + 7)>>3) {
1431
            av_log(s->avctx, AV_LOG_ERROR, "mb_bitmask_size mismatches\n");
1432
            return AVERROR_INVALIDDATA;
1433
        }
1434
31
        init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
1435
    }
1436
1437
2121
    s->restart_count = 0;
1438
1439
2121
    av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &chroma_h_shift,
1440
                                     &chroma_v_shift);
1441
2121
    chroma_width  = AV_CEIL_RSHIFT(s->width,  chroma_h_shift);
1442
2121
    chroma_height = AV_CEIL_RSHIFT(s->height, chroma_v_shift);
1443
1444
8482
    for (i = 0; i < nb_components; i++) {
1445
6361
        int c   = s->comp_index[i];
1446
6361
        data[c] = s->picture_ptr->data[c];
1447
6361
        reference_data[c] = reference ? reference->data[c] : NULL;
1448
6361
        linesize[c] = s->linesize[c];
1449
6361
        s->coefs_finished[c] |= 1;
1450
    }
1451
1452
30348
    for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1453
802754
        for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1454

774527
            const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
1455
1456

774527
            if (s->restart_interval && !s->restart_count)
1457
                s->restart_count = s->restart_interval;
1458
1459
774527
            if (get_bits_left(&s->gb) < 0) {
1460
                av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",
1461
                       -get_bits_left(&s->gb));
1462
                return AVERROR_INVALIDDATA;
1463
            }
1464
3074608
            for (i = 0; i < nb_components; i++) {
1465
                uint8_t *ptr;
1466
                int n, h, v, x, y, c, j;
1467
                int block_offset;
1468
2300081
                n = s->nb_blocks[i];
1469
2300081
                c = s->comp_index[i];
1470
2300081
                h = s->h_scount[i];
1471
2300081
                v = s->v_scount[i];
1472
2300081
                x = 0;
1473
2300081
                y = 0;
1474
6983623
                for (j = 0; j < n; j++) {
1475
4683542
                    block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
1476
4683542
                                     (h * mb_x + x) * 8 * bytes_per_pixel) >> s->avctx->lowres);
1477
1478

4683542
                    if (s->interlaced && s->bottom_field)
1479
10720
                        block_offset += linesize[c] >> 1;
1480

4683542
                    if (   8*(h * mb_x + x) < ((c == 1) || (c == 2) ? chroma_width  : s->width)
1481

4681404
                        && 8*(v * mb_y + y) < ((c == 1) || (c == 2) ? chroma_height : s->height)) {
1482
4675376
                        ptr = data[c] + block_offset;
1483
                    } else
1484
8166
                        ptr = NULL;
1485
4683542
                    if (!s->progressive) {
1486
4683542
                        if (copy_mb) {
1487
786684
                            if (ptr)
1488
786684
                                mjpeg_copy_block(s, ptr, reference_data[c] + block_offset,
1489
786684
                                                linesize[c], s->avctx->lowres);
1490
1491
                        } else {
1492
3896858
                            s->bdsp.clear_block(s->block);
1493
3896858
                            if (decode_block(s, s->block, i,
1494
                                             s->dc_index[i], s->ac_index[i],
1495
3896858
                                             s->quant_matrixes[s->quant_sindex[i]]) < 0) {
1496
                                av_log(s->avctx, AV_LOG_ERROR,
1497
                                       "error y=%d x=%d\n", mb_y, mb_x);
1498
                                return AVERROR_INVALIDDATA;
1499
                            }
1500
3896858
                            if (ptr) {
1501
3888692
                                s->idsp.idct_put(ptr, linesize[c], s->block);
1502
3888692
                                if (s->bits & 7)
1503
11750
                                    shift_output(s, ptr, linesize[c]);
1504
                            }
1505
                        }
1506
                    } else {
1507
                        int block_idx  = s->block_stride[c] * (v * mb_y + y) +
1508
                                         (h * mb_x + x);
1509
                        int16_t *block = s->blocks[c][block_idx];
1510
                        if (Ah)
1511
                            block[0] += get_bits1(&s->gb) *
1512
                                        s->quant_matrixes[s->quant_sindex[i]][0] << Al;
1513
                        else if (decode_dc_progressive(s, block, i, s->dc_index[i],
1514
                                                       s->quant_matrixes[s->quant_sindex[i]],
1515
                                                       Al) < 0) {
1516
                            av_log(s->avctx, AV_LOG_ERROR,
1517
                                   "error y=%d x=%d\n", mb_y, mb_x);
1518
                            return AVERROR_INVALIDDATA;
1519
                        }
1520
                    }
1521
                    ff_dlog(s->avctx, "mb: %d %d processed\n", mb_y, mb_x);
1522
                    ff_dlog(s->avctx, "%d %d %d %d %d %d %d %d \n",
1523
                            mb_x, mb_y, x, y, c, s->bottom_field,
1524
                            (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1525
4683542
                    if (++x == h) {
1526
3409373
                        x = 0;
1527
3409373
                        y++;
1528
                    }
1529
                }
1530
            }
1531
1532
774527
            handle_rstn(s, nb_components);
1533
        }
1534
    }
1535
2121
    return 0;
1536
}
1537
1538
static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss,
1539
                                            int se, int Ah, int Al)
1540
{
1541
    int mb_x, mb_y;
1542
    int EOBRUN = 0;
1543
    int c = s->comp_index[0];
1544
    uint16_t *quant_matrix = s->quant_matrixes[s->quant_sindex[0]];
1545
1546
    av_assert0(ss>=0 && Ah>=0 && Al>=0);
1547
    if (se < ss || se > 63) {
1548
        av_log(s->avctx, AV_LOG_ERROR, "SS/SE %d/%d is invalid\n", ss, se);
1549
        return AVERROR_INVALIDDATA;
1550
    }
1551
1552
    // s->coefs_finished is a bitmask for coefficients coded
1553
    // ss and se are parameters telling start and end coefficients
1554
    s->coefs_finished[c] |= (2ULL << se) - (1ULL << ss);
1555
1556
    s->restart_count = 0;
1557
1558
    for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1559
        int block_idx    = mb_y * s->block_stride[c];
1560
        int16_t (*block)[64] = &s->blocks[c][block_idx];
1561
        uint8_t *last_nnz    = &s->last_nnz[c][block_idx];
1562
        if (get_bits_left(&s->gb) <= 0) {
1563
            av_log(s->avctx, AV_LOG_ERROR, "bitstream truncated in mjpeg_decode_scan_progressive_ac\n");
1564
            return AVERROR_INVALIDDATA;
1565
        }
1566
        for (mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) {
1567
                int ret;
1568
                if (s->restart_interval && !s->restart_count)
1569
                    s->restart_count = s->restart_interval;
1570
1571
                if (Ah)
1572
                    ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0],
1573
                                                  quant_matrix, ss, se, Al, &EOBRUN);
1574
                else
1575
                    ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0],
1576
                                                   quant_matrix, ss, se, Al, &EOBRUN);
1577
                if (ret < 0) {
1578
                    av_log(s->avctx, AV_LOG_ERROR,
1579
                           "error y=%d x=%d\n", mb_y, mb_x);
1580
                    return AVERROR_INVALIDDATA;
1581
                }
1582
1583
            if (handle_rstn(s, 0))
1584
                EOBRUN = 0;
1585
        }
1586
    }
1587
    return 0;
1588
}
1589
1590
static void mjpeg_idct_scan_progressive_ac(MJpegDecodeContext *s)
1591
{
1592
    int mb_x, mb_y;
1593
    int c;
1594
    const int bytes_per_pixel = 1 + (s->bits > 8);
1595
    const int block_size = s->lossless ? 1 : 8;
1596
1597
    for (c = 0; c < s->nb_components; c++) {
1598
        uint8_t *data = s->picture_ptr->data[c];
1599
        int linesize  = s->linesize[c];
1600
        int h = s->h_max / s->h_count[c];
1601
        int v = s->v_max / s->v_count[c];
1602
        int mb_width     = (s->width  + h * block_size - 1) / (h * block_size);
1603
        int mb_height    = (s->height + v * block_size - 1) / (v * block_size);
1604
1605
        if (~s->coefs_finished[c])
1606
            av_log(s->avctx, AV_LOG_WARNING, "component %d is incomplete\n", c);
1607
1608
        if (s->interlaced && s->bottom_field)
1609
            data += linesize >> 1;
1610
1611
        for (mb_y = 0; mb_y < mb_height; mb_y++) {
1612
            uint8_t *ptr     = data + (mb_y * linesize * 8 >> s->avctx->lowres);
1613
            int block_idx    = mb_y * s->block_stride[c];
1614
            int16_t (*block)[64] = &s->blocks[c][block_idx];
1615
            for (mb_x = 0; mb_x < mb_width; mb_x++, block++) {
1616
                s->idsp.idct_put(ptr, linesize, *block);
1617
                if (s->bits & 7)
1618
                    shift_output(s, ptr, linesize);
1619
                ptr += bytes_per_pixel*8 >> s->avctx->lowres;
1620
            }
1621
        }
1622
    }
1623
}
1624
1625
2526
int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
1626
                        int mb_bitmask_size, const AVFrame *reference)
1627
{
1628
    int len, nb_components, i, h, v, predictor, point_transform;
1629
    int index, id, ret;
1630
2526
    const int block_size = s->lossless ? 1 : 8;
1631
    int ilv, prev_shift;
1632
1633
2526
    if (!s->got_picture) {
1634
        av_log(s->avctx, AV_LOG_WARNING,
1635
                "Can not process SOS before SOF, skipping\n");
1636
        return -1;
1637
    }
1638
1639
2526
    if (reference) {
1640
31
        if (reference->width  != s->picture_ptr->width  ||
1641
31
            reference->height != s->picture_ptr->height ||
1642
31
            reference->format != s->picture_ptr->format) {
1643
            av_log(s->avctx, AV_LOG_ERROR, "Reference mismatching\n");
1644
            return AVERROR_INVALIDDATA;
1645
        }
1646
    }
1647
1648
    /* XXX: verify len field validity */
1649
2526
    len = get_bits(&s->gb, 16);
1650
2526
    nb_components = get_bits(&s->gb, 8);
1651

2526
    if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
1652
        avpriv_report_missing_feature(s->avctx,
1653
                                      "decode_sos: nb_components (%d)",
1654
                                      nb_components);
1655
        return AVERROR_PATCHWELCOME;
1656
    }
1657
2526
    if (len != 6 + 2 * nb_components) {
1658
        av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1659
        return AVERROR_INVALIDDATA;
1660
    }
1661
10102
    for (i = 0; i < nb_components; i++) {
1662
7576
        id = get_bits(&s->gb, 8) - 1;
1663
7576
        av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1664
        /* find component index */
1665
15151
        for (index = 0; index < s->nb_components; index++)
1666
15151
            if (id == s->component_id[index])
1667
7576
                break;
1668
7576
        if (index == s->nb_components) {
1669
            av_log(s->avctx, AV_LOG_ERROR,
1670
                   "decode_sos: index(%d) out of components\n", index);
1671
            return AVERROR_INVALIDDATA;
1672
        }
1673
        /* Metasoft MJPEG codec has Cb and Cr swapped */
1674
7576
        if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
1675
            && nb_components == 3 && s->nb_components == 3 && i)
1676
            index = 3 - i;
1677
1678
7576
        s->quant_sindex[i] = s->quant_index[index];
1679
7576
        s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1680
7576
        s->h_scount[i]  = s->h_count[index];
1681
7576
        s->v_scount[i]  = s->v_count[index];
1682
1683


7576
        if((nb_components == 1 || nb_components == 3) && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
1684
            index = (index+2)%3;
1685
1686
7576
        s->comp_index[i] = index;
1687
1688
7576
        s->dc_index[i] = get_bits(&s->gb, 4);
1689
7576
        s->ac_index[i] = get_bits(&s->gb, 4);
1690
1691

7576
        if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1692

7576
            s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1693
            goto out_of_range;
1694


7576
        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))
1695
            goto out_of_range;
1696
    }
1697
1698
2526
    predictor = get_bits(&s->gb, 8);       /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1699
2526
    ilv = get_bits(&s->gb, 8);             /* JPEG Se / JPEG-LS ILV */
1700
2526
    if(s->avctx->codec_tag != AV_RL32("CJPG")){
1701
2526
        prev_shift      = get_bits(&s->gb, 4); /* Ah */
1702
2526
        point_transform = get_bits(&s->gb, 4); /* Al */
1703
    }else
1704
        prev_shift = point_transform = 0;
1705
1706
2526
    if (nb_components > 1) {
1707
        /* interleaved stream */
1708
2525
        s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1709
2525
        s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1710
1
    } else if (!s->ls) { /* skip this for JPEG-LS */
1711
1
        h = s->h_max / s->h_scount[0];
1712
1
        v = s->v_max / s->v_scount[0];
1713
1
        s->mb_width     = (s->width  + h * block_size - 1) / (h * block_size);
1714
1
        s->mb_height    = (s->height + v * block_size - 1) / (v * block_size);
1715
1
        s->nb_blocks[0] = 1;
1716
1
        s->h_scount[0]  = 1;
1717
1
        s->v_scount[0]  = 1;
1718
    }
1719
1720
2526
    if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1721
        av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n",
1722
               s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",
1723
               predictor, point_transform, ilv, s->bits, s->mjpb_skiptosod,
1724
               s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), nb_components);
1725
1726
1727
    /* mjpeg-b can have padding bytes between sos and image data, skip them */
1728
2548
    for (i = s->mjpb_skiptosod; i > 0; i--)
1729
22
        skip_bits(&s->gb, 8);
1730
1731
2526
next_field:
1732
10102
    for (i = 0; i < nb_components; i++)
1733
7576
        s->last_dc[i] = (4 << s->bits);
1734
1735
2526
    if (s->avctx->hwaccel) {
1736
        int bytes_to_start = get_bits_count(&s->gb) / 8;
1737
        av_assert0(bytes_to_start >= 0 &&
1738
                   s->raw_scan_buffer_size >= bytes_to_start);
1739
1740
        ret = s->avctx->hwaccel->decode_slice(s->avctx,
1741
                                              s->raw_scan_buffer      + bytes_to_start,
1742
                                              s->raw_scan_buffer_size - bytes_to_start);
1743
        if (ret < 0)
1744
            return ret;
1745
1746
2526
    } else if (s->lossless) {
1747
405
        av_assert0(s->picture_ptr == s->picture);
1748
405
        if (CONFIG_JPEGLS_DECODER && s->ls) {
1749
//            for () {
1750
//            reset_ls_coding_parameters(s, 0);
1751
1752
205
            if ((ret = ff_jpegls_decode_picture(s, predictor,
1753
                                                point_transform, ilv)) < 0)
1754
                return ret;
1755
        } else {
1756

200
            if (s->rgb || s->bayer) {
1757
                if ((ret = ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform)) < 0)
1758
                    return ret;
1759
            } else {
1760
200
                if ((ret = ljpeg_decode_yuv_scan(s, predictor,
1761
                                                 point_transform,
1762
                                                 nb_components)) < 0)
1763
                    return ret;
1764
            }
1765
        }
1766
    } else {
1767

2121
        if (s->progressive && predictor) {
1768
            av_assert0(s->picture_ptr == s->picture);
1769
            if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor,
1770
                                                        ilv, prev_shift,
1771
                                                        point_transform)) < 0)
1772
                return ret;
1773
        } else {
1774
2121
            if ((ret = mjpeg_decode_scan(s, nb_components,
1775
                                         prev_shift, point_transform,
1776
                                         mb_bitmask, mb_bitmask_size, reference)) < 0)
1777
                return ret;
1778
        }
1779
    }
1780
1781

2554
    if (s->interlaced &&
1782
43
        get_bits_left(&s->gb) > 32 &&
1783
15
        show_bits(&s->gb, 8) == 0xFF) {
1784
        GetBitContext bak = s->gb;
1785
        align_get_bits(&bak);
1786
        if (show_bits(&bak, 16) == 0xFFD1) {
1787
            av_log(s->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n");
1788
            s->gb = bak;
1789
            skip_bits(&s->gb, 16);
1790
            s->bottom_field ^= 1;
1791
1792
            goto next_field;
1793
        }
1794
    }
1795
1796
2526
    emms_c();
1797
2526
    return 0;
1798
 out_of_range:
1799
    av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1800
    return AVERROR_INVALIDDATA;
1801
}
1802
1803
16
static int mjpeg_decode_dri(MJpegDecodeContext *s)
1804
{
1805
16
    if (get_bits(&s->gb, 16) != 4)
1806
        return AVERROR_INVALIDDATA;
1807
16
    s->restart_interval = get_bits(&s->gb, 16);
1808
16
    s->restart_count    = 0;
1809
16
    av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
1810
           s->restart_interval);
1811
1812
16
    return 0;
1813
}
1814
1815
169
static int mjpeg_decode_app(MJpegDecodeContext *s)
1816
{
1817
    int len, id, i;
1818
1819
169
    len = get_bits(&s->gb, 16);
1820
169
    if (len < 6) {
1821
        if (s->bayer) {
1822
            // Pentax K-1 (digital camera) JPEG images embedded in DNG images contain unknown APP0 markers
1823
            av_log(s->avctx, AV_LOG_WARNING, "skipping APPx (len=%"PRId32") for bayer-encoded image\n", len);
1824
            skip_bits(&s->gb, len);
1825
            return 0;
1826
        } else
1827
            return AVERROR_INVALIDDATA;
1828
    }
1829
169
    if (8 * len > get_bits_left(&s->gb))
1830
        return AVERROR_INVALIDDATA;
1831
1832
169
    id   = get_bits_long(&s->gb, 32);
1833
169
    len -= 6;
1834
1835
169
    if (s->avctx->debug & FF_DEBUG_STARTCODE)
1836
        av_log(s->avctx, AV_LOG_DEBUG, "APPx (%s / %8X) len=%d\n",
1837
               av_fourcc2str(av_bswap32(id)), id, len);
1838
1839
    /* Buggy AVID, it puts EOI only at every 10th frame. */
1840
    /* Also, this fourcc is used by non-avid files too, it holds some
1841
       information, but it's always present in AVID-created files. */
1842
169
    if (id == AV_RB32("AVI1")) {
1843
        /* structure:
1844
            4bytes      AVI1
1845
            1bytes      polarity
1846
            1bytes      always zero
1847
            4bytes      field_size
1848
            4bytes      field_size_less_padding
1849
        */
1850
19
            s->buggy_avid = 1;
1851
19
        i = get_bits(&s->gb, 8); len--;
1852
19
        av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i);
1853
19
        goto out;
1854
    }
1855
1856
150
    if (id == AV_RB32("JFIF")) {
1857
        int t_w, t_h, v1, v2;
1858
121
        if (len < 8)
1859
            goto out;
1860
121
        skip_bits(&s->gb, 8); /* the trailing zero-byte */
1861
121
        v1 = get_bits(&s->gb, 8);
1862
121
        v2 = get_bits(&s->gb, 8);
1863
121
        skip_bits(&s->gb, 8);
1864
1865
121
        s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 16);
1866
121
        s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16);
1867
121
        if (   s->avctx->sample_aspect_ratio.num <= 0
1868
121
            || s->avctx->sample_aspect_ratio.den <= 0) {
1869
            s->avctx->sample_aspect_ratio.num = 0;
1870
            s->avctx->sample_aspect_ratio.den = 1;
1871
        }
1872
1873
121
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1874
            av_log(s->avctx, AV_LOG_INFO,
1875
                   "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1876
                   v1, v2,
1877
                   s->avctx->sample_aspect_ratio.num,
1878
                   s->avctx->sample_aspect_ratio.den);
1879
1880
121
        len -= 8;
1881
121
        if (len >= 2) {
1882
119
            t_w = get_bits(&s->gb, 8);
1883
119
            t_h = get_bits(&s->gb, 8);
1884

119
            if (t_w && t_h) {
1885
                /* skip thumbnail */
1886
                if (len -10 - (t_w * t_h * 3) > 0)
1887
                    len -= t_w * t_h * 3;
1888
            }
1889
119
            len -= 2;
1890
        }
1891
121
        goto out;
1892
    }
1893
1894
29
    if (   id == AV_RB32("Adob")
1895
5
        && len >= 7
1896
5
        && show_bits(&s->gb, 8) == 'e'
1897
5
        && show_bits_long(&s->gb, 32) != AV_RB32("e_CM")) {
1898
5
        skip_bits(&s->gb,  8); /* 'e' */
1899
5
        skip_bits(&s->gb, 16); /* version */
1900
5
        skip_bits(&s->gb, 16); /* flags0 */
1901
5
        skip_bits(&s->gb, 16); /* flags1 */
1902
5
        s->adobe_transform = get_bits(&s->gb,  8);
1903
5
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1904
            av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found, transform=%d\n", s->adobe_transform);
1905
5
        len -= 7;
1906
5
        goto out;
1907
    }
1908
1909
24
    if (id == AV_RB32("LJIF")) {
1910
        int rgb = s->rgb;
1911
        int pegasus_rct = s->pegasus_rct;
1912
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1913
            av_log(s->avctx, AV_LOG_INFO,
1914
                   "Pegasus lossless jpeg header found\n");
1915
        skip_bits(&s->gb, 16); /* version ? */
1916
        skip_bits(&s->gb, 16); /* unknown always 0? */
1917
        skip_bits(&s->gb, 16); /* unknown always 0? */
1918
        skip_bits(&s->gb, 16); /* unknown always 0? */
1919
        switch (i=get_bits(&s->gb, 8)) {
1920
        case 1:
1921
            rgb         = 1;
1922
            pegasus_rct = 0;
1923
            break;
1924
        case 2:
1925
            rgb         = 1;
1926
            pegasus_rct = 1;
1927
            break;
1928
        default:
1929
            av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace %d\n", i);
1930
        }
1931
1932
        len -= 9;
1933
        if (s->got_picture)
1934
            if (rgb != s->rgb || pegasus_rct != s->pegasus_rct) {
1935
                av_log(s->avctx, AV_LOG_WARNING, "Mismatching LJIF tag\n");
1936
                goto out;
1937
            }
1938
1939
        s->rgb = rgb;
1940
        s->pegasus_rct = pegasus_rct;
1941
1942
        goto out;
1943
    }
1944

24
    if (id == AV_RL32("colr") && len > 0) {
1945
        s->colr = get_bits(&s->gb, 8);
1946
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1947
            av_log(s->avctx, AV_LOG_INFO, "COLR %d\n", s->colr);
1948
        len --;
1949
        goto out;
1950
    }
1951

24
    if (id == AV_RL32("xfrm") && len > 0) {
1952
        s->xfrm = get_bits(&s->gb, 8);
1953
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1954
            av_log(s->avctx, AV_LOG_INFO, "XFRM %d\n", s->xfrm);
1955
        len --;
1956
        goto out;
1957
    }
1958
1959
    /* JPS extension by VRex */
1960

24
    if (s->start_code == APP3 && id == AV_RB32("_JPS") && len >= 10) {
1961
        int flags, layout, type;
1962
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1963
            av_log(s->avctx, AV_LOG_INFO, "_JPSJPS_\n");
1964
1965
        skip_bits(&s->gb, 32); len -= 4;  /* JPS_ */
1966
        skip_bits(&s->gb, 16); len -= 2;  /* block length */
1967
        skip_bits(&s->gb, 8);             /* reserved */
1968
        flags  = get_bits(&s->gb, 8);
1969
        layout = get_bits(&s->gb, 8);
1970
        type   = get_bits(&s->gb, 8);
1971
        len -= 4;
1972
1973
        av_freep(&s->stereo3d);
1974
        s->stereo3d = av_stereo3d_alloc();
1975
        if (!s->stereo3d) {
1976
            goto out;
1977
        }
1978
        if (type == 0) {
1979
            s->stereo3d->type = AV_STEREO3D_2D;
1980
        } else if (type == 1) {
1981
            switch (layout) {
1982
            case 0x01:
1983
                s->stereo3d->type = AV_STEREO3D_LINES;
1984
                break;
1985
            case 0x02:
1986
                s->stereo3d->type = AV_STEREO3D_SIDEBYSIDE;
1987
                break;
1988
            case 0x03:
1989
                s->stereo3d->type = AV_STEREO3D_TOPBOTTOM;
1990
                break;
1991
            }
1992
            if (!(flags & 0x04)) {
1993
                s->stereo3d->flags = AV_STEREO3D_FLAG_INVERT;
1994
            }
1995
        }
1996
        goto out;
1997
    }
1998
1999
    /* EXIF metadata */
2000

24
    if (s->start_code == APP1 && id == AV_RB32("Exif") && len >= 2) {
2001
        GetByteContext gbytes;
2002
        int ret, le, ifd_offset, bytes_read;
2003
        const uint8_t *aligned;
2004
2005
18
        skip_bits(&s->gb, 16); // skip padding
2006
18
        len -= 2;
2007
2008
        // init byte wise reading
2009
18
        aligned = align_get_bits(&s->gb);
2010
18
        bytestream2_init(&gbytes, aligned, len);
2011
2012
        // read TIFF header
2013
18
        ret = ff_tdecode_header(&gbytes, &le, &ifd_offset);
2014
18
        if (ret) {
2015
            av_log(s->avctx, AV_LOG_ERROR, "mjpeg: invalid TIFF header in EXIF data\n");
2016
        } else {
2017
18
            bytestream2_seek(&gbytes, ifd_offset, SEEK_SET);
2018
2019
            // read 0th IFD and store the metadata
2020
            // (return values > 0 indicate the presence of subimage metadata)
2021
18
            ret = ff_exif_decode_ifd(s->avctx, &gbytes, le, 0, &s->exif_metadata);
2022
18
            if (ret < 0) {
2023
                av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error decoding EXIF data\n");
2024
            }
2025
        }
2026
2027
18
        bytes_read = bytestream2_tell(&gbytes);
2028
18
        skip_bits(&s->gb, bytes_read << 3);
2029
18
        len -= bytes_read;
2030
2031
18
        goto out;
2032
    }
2033
2034
    /* Apple MJPEG-A */
2035

6
    if ((s->start_code == APP1) && (len > (0x28 - 8))) {
2036
2
        id   = get_bits_long(&s->gb, 32);
2037
2
        len -= 4;
2038
        /* Apple MJPEG-A */
2039
2
        if (id == AV_RB32("mjpg")) {
2040
            /* structure:
2041
                4bytes      field size
2042
                4bytes      pad field size
2043
                4bytes      next off
2044
                4bytes      quant off
2045
                4bytes      huff off
2046
                4bytes      image off
2047
                4bytes      scan off
2048
                4bytes      data off
2049
            */
2050
            if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2051
                av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
2052
        }
2053
    }
2054
2055

6
    if (s->start_code == APP2 && id == AV_RB32("ICC_") && len >= 10) {
2056
        int id2;
2057
        unsigned seqno;
2058
        unsigned nummarkers;
2059
2060
        id   = get_bits_long(&s->gb, 32);
2061
        id2  = get_bits(&s->gb, 24);
2062
        len -= 7;
2063
        if (id != AV_RB32("PROF") || id2 != AV_RB24("ILE")) {
2064
            av_log(s->avctx, AV_LOG_WARNING, "Invalid ICC_PROFILE header in APP2\n");
2065
            goto out;
2066
        }
2067
2068
        skip_bits(&s->gb, 8);
2069
        seqno  = get_bits(&s->gb, 8);
2070
        len   -= 2;
2071
        if (seqno == 0) {
2072
            av_log(s->avctx, AV_LOG_WARNING, "Invalid sequence number in APP2\n");
2073
            goto out;
2074
        }
2075
2076
        nummarkers  = get_bits(&s->gb, 8);
2077
        len        -= 1;
2078
        if (nummarkers == 0) {
2079
            av_log(s->avctx, AV_LOG_WARNING, "Invalid number of markers coded in APP2\n");
2080
            goto out;
2081
        } else if (s->iccnum != 0 && nummarkers != s->iccnum) {
2082
            av_log(s->avctx, AV_LOG_WARNING, "Mistmatch in coded number of ICC markers between markers\n");
2083
            goto out;
2084
        } else if (seqno > nummarkers) {
2085
            av_log(s->avctx, AV_LOG_WARNING, "Mismatching sequence number and coded number of ICC markers\n");
2086
            goto out;
2087
        }
2088
2089
        /* Allocate if this is the first APP2 we've seen. */
2090
        if (s->iccnum == 0) {
2091
            if (!FF_ALLOCZ_TYPED_ARRAY(s->iccentries, nummarkers)) {
2092
                av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data arrays\n");
2093
                return AVERROR(ENOMEM);
2094
            }
2095
            s->iccnum = nummarkers;
2096
        }
2097
2098
        if (s->iccentries[seqno - 1].data) {
2099
            av_log(s->avctx, AV_LOG_WARNING, "Duplicate ICC sequence number\n");
2100
            goto out;
2101
        }
2102
2103
        s->iccentries[seqno - 1].length = len;
2104
        s->iccentries[seqno - 1].data   = av_malloc(len);
2105
        if (!s->iccentries[seqno - 1].data) {
2106
            av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data buffer\n");
2107
            return AVERROR(ENOMEM);
2108
        }
2109
2110
        memcpy(s->iccentries[seqno - 1].data, align_get_bits(&s->gb), len);
2111
        skip_bits(&s->gb, len << 3);
2112
        len = 0;
2113
        s->iccread++;
2114
2115
        if (s->iccread > s->iccnum)
2116
            av_log(s->avctx, AV_LOG_WARNING, "Read more ICC markers than are supposed to be coded\n");
2117
    }
2118
2119
6
out:
2120
    /* slow but needed for extreme adobe jpegs */
2121
169
    if (len < 0)
2122
        av_log(s->avctx, AV_LOG_ERROR,
2123
               "mjpeg: error, decode_app parser read over the end\n");
2124
107619
    while (--len > 0)
2125
107450
        skip_bits(&s->gb, 8);
2126
2127
169
    return 0;
2128
}
2129
2130
226
static int mjpeg_decode_com(MJpegDecodeContext *s)
2131
{
2132
226
    int len = get_bits(&s->gb, 16);
2133

226
    if (len >= 2 && 8 * len - 16 <= get_bits_left(&s->gb)) {
2134
        int i;
2135
226
        char *cbuf = av_malloc(len - 1);
2136
226
        if (!cbuf)
2137
            return AVERROR(ENOMEM);
2138
2139
3401
        for (i = 0; i < len - 2; i++)
2140
3175
            cbuf[i] = get_bits(&s->gb, 8);
2141

226
        if (i > 0 && cbuf[i - 1] == '\n')
2142
7
            cbuf[i - 1] = 0;
2143
        else
2144
219
            cbuf[i] = 0;
2145
2146
226
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2147
            av_log(s->avctx, AV_LOG_INFO, "comment: '%s'\n", cbuf);
2148
2149
        /* buggy avid, it puts EOI only at every 10th frame */
2150
226
        if (!strncmp(cbuf, "AVID", 4)) {
2151
11
            parse_avid(s, cbuf, len);
2152
215
        } else if (!strcmp(cbuf, "CS=ITU601"))
2153
205
            s->cs_itu601 = 1;
2154

10
        else if ((!strncmp(cbuf, "Intel(R) JPEG Library, version 1", 32) && s->avctx->codec_tag) ||
2155
10
                 (!strncmp(cbuf, "Metasoft MJPEG Codec", 20)))
2156
            s->flipped = 1;
2157
10
        else if (!strcmp(cbuf, "MULTISCOPE II")) {
2158
            s->avctx->sample_aspect_ratio = (AVRational) { 1, 2 };
2159
            s->multiscope = 2;
2160
        }
2161
2162
226
        av_free(cbuf);
2163
    }
2164
2165
226
    return 0;
2166
}
2167
2168
/* return the 8 bit start code value and update the search
2169
   state. Return -1 if no start code found */
2170
15985
static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
2171
{
2172
    const uint8_t *buf_ptr;
2173
    unsigned int v, v2;
2174
    int val;
2175
15985
    int skipped = 0;
2176
2177
15985
    buf_ptr = *pbuf_ptr;
2178
276517
    while (buf_end - buf_ptr > 1) {
2179
276512
        v  = *buf_ptr++;
2180
276512
        v2 = *buf_ptr;
2181


276512
        if ((v == 0xff) && (v2 >= SOF0) && (v2 <= COM) && buf_ptr < buf_end) {
2182
15980
            val = *buf_ptr++;
2183
15980
            goto found;
2184
        }
2185
260532
        skipped++;
2186
    }
2187
5
    buf_ptr = buf_end;
2188
5
    val = -1;
2189
15985
found:
2190
    ff_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
2191
15985
    *pbuf_ptr = buf_ptr;
2192
15985
    return val;
2193
}
2194
2195
15985
int ff_mjpeg_find_marker(MJpegDecodeContext *s,
2196
                         const uint8_t **buf_ptr, const uint8_t *buf_end,
2197
                         const uint8_t **unescaped_buf_ptr,
2198
                         int *unescaped_buf_size)
2199
{
2200
    int start_code;
2201
15985
    start_code = find_marker(buf_ptr, buf_end);
2202
2203
15985
    av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr);
2204
15985
    if (!s->buffer)
2205
        return AVERROR(ENOMEM);
2206
2207
    /* unescape buffer of SOS, use special treatment for JPEG-LS */
2208

18352
    if (start_code == SOS && !s->ls) {
2209
2367
        const uint8_t *src = *buf_ptr;
2210
2367
        const uint8_t *ptr = src;
2211
2367
        uint8_t *dst = s->buffer;
2212
2213
        #define copy_data_segment(skip) do {       \
2214
            ptrdiff_t length = (ptr - src) - (skip);  \
2215
            if (length > 0) {                         \
2216
                memcpy(dst, src, length);             \
2217
                dst += length;                        \
2218
                src = ptr;                            \
2219
            }                                         \
2220
        } while (0)
2221
2222
2367
        if (s->avctx->codec_id == AV_CODEC_ID_THP) {
2223
74
            ptr = buf_end;
2224
74
            copy_data_segment(0);
2225
        } else {
2226
42910437
            while (ptr < buf_end) {
2227
42910437
                uint8_t x = *(ptr++);
2228
2229
42910437
                if (x == 0xff) {
2230
184533
                    ptrdiff_t skip = 0;
2231

369080
                    while (ptr < buf_end && x == 0xff) {
2232
184547
                        x = *(ptr++);
2233
184547
                        skip++;
2234
                    }
2235
2236
                    /* 0xFF, 0xFF, ... */
2237
184533
                    if (skip > 1) {
2238
7
                        copy_data_segment(skip);
2239
2240
                        /* decrement src as it is equal to ptr after the
2241
                         * copy_data_segment macro and we might want to
2242
                         * copy the current value of x later on */
2243
7
                        src--;
2244
                    }
2245
2246

184533
                    if (x < RST0 || x > RST7) {
2247
184457
                        copy_data_segment(1);
2248
184457
                        if (x)
2249
2293
                            break;
2250
                    }
2251
                }
2252
            }
2253
2293
            if (src < ptr)
2254
7
                copy_data_segment(0);
2255
        }
2256
        #undef copy_data_segment
2257
2258
2367
        *unescaped_buf_ptr  = s->buffer;
2259
2367
        *unescaped_buf_size = dst - s->buffer;
2260
2367
        memset(s->buffer + *unescaped_buf_size, 0,
2261
               AV_INPUT_BUFFER_PADDING_SIZE);
2262
2263
2367
        av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %"PTRDIFF_SPECIFIER" bytes\n",
2264
2367
               (buf_end - *buf_ptr) - (dst - s->buffer));
2265

13618
    } else if (start_code == SOS && s->ls) {
2266
205
        const uint8_t *src = *buf_ptr;
2267
205
        uint8_t *dst  = s->buffer;
2268
205
        int bit_count = 0;
2269
205
        int t = 0, b = 0;
2270
        PutBitContext pb;
2271
2272
        /* find marker */
2273
26357335
        while (src + t < buf_end) {
2274
26357335
            uint8_t x = src[t++];
2275
26357335
            if (x == 0xff) {
2276

295862
                while ((src + t < buf_end) && x == 0xff)
2277
147931
                    x = src[t++];
2278
147931
                if (x & 0x80) {
2279
205
                    t -= FFMIN(2, t);
2280
205
                    break;
2281
                }
2282
            }
2283
        }
2284
205
        bit_count = t * 8;
2285
205
        init_put_bits(&pb, dst, t);
2286
2287
        /* unescape bitstream */
2288
26357335
        while (b < t) {
2289
26357130
            uint8_t x = src[b++];
2290
26357130
            put_bits(&pb, 8, x);
2291

26357130
            if (x == 0xFF && b < t) {
2292
147726
                x = src[b++];
2293
147726
                if (x & 0x80) {
2294
                    av_log(s->avctx, AV_LOG_WARNING, "Invalid escape sequence\n");
2295
                    x &= 0x7f;
2296
                }
2297
147726
                put_bits(&pb, 7, x);
2298
147726
                bit_count--;
2299
            }
2300
        }
2301
205
        flush_put_bits(&pb);
2302
2303
205
        *unescaped_buf_ptr  = dst;
2304
205
        *unescaped_buf_size = (bit_count + 7) >> 3;
2305
205
        memset(s->buffer + *unescaped_buf_size, 0,
2306
               AV_INPUT_BUFFER_PADDING_SIZE);
2307
    } else {
2308
13413
        *unescaped_buf_ptr  = *buf_ptr;
2309
13413
        *unescaped_buf_size = buf_end - *buf_ptr;
2310
    }
2311
2312
15985
    return start_code;
2313
}
2314
2315
158
static void reset_icc_profile(MJpegDecodeContext *s)
2316
{
2317
    int i;
2318
2319
158
    if (s->iccentries) {
2320
        for (i = 0; i < s->iccnum; i++)
2321
            av_freep(&s->iccentries[i].data);
2322
        av_freep(&s->iccentries);
2323
    }
2324
2325
158
    s->iccread = 0;
2326
158
    s->iccnum  = 0;
2327
158
}
2328
2329
// SMV JPEG just stacks several output frames into one JPEG picture
2330
// we handle that by setting up the cropping parameters appropriately
2331
13
static int smv_process_frame(AVCodecContext *avctx, AVFrame *frame)
2332
{
2333
13
    MJpegDecodeContext *s = avctx->priv_data;
2334
    int ret;
2335
2336
13
    if (s->smv_next_frame > 0) {
2337
10
        av_assert0(s->smv_frame->buf[0]);
2338
10
        av_frame_unref(frame);
2339
10
        ret = av_frame_ref(frame, s->smv_frame);
2340
10
        if (ret < 0)
2341
            return ret;
2342
    } else {
2343
3
        av_assert0(frame->buf[0]);
2344
3
        av_frame_unref(s->smv_frame);
2345
3
        ret = av_frame_ref(s->smv_frame, frame);
2346
3
        if (ret < 0)
2347
            return ret;
2348
    }
2349
2350
13
    av_assert0((s->smv_next_frame + 1) * avctx->height <= avctx->coded_height);
2351
2352
13
    frame->width       = avctx->coded_width;
2353
13
    frame->height      = avctx->coded_height;
2354
13
    frame->crop_top    = FFMIN(s->smv_next_frame * avctx->height, frame->height);
2355
13
    frame->crop_bottom = frame->height - (s->smv_next_frame + 1) * avctx->height;
2356
2357
13
    s->smv_next_frame = (s->smv_next_frame + 1) % s->smv_frames_per_jpeg;
2358
2359
13
    if (s->smv_next_frame == 0)
2360
2
        av_frame_unref(s->smv_frame);
2361
2362
13
    return 0;
2363
}
2364
2365
4897
static int mjpeg_get_packet(AVCodecContext *avctx)
2366
{
2367
4897
    MJpegDecodeContext *s = avctx->priv_data;
2368
    int ret;
2369
2370
4897
    av_packet_unref(s->pkt);
2371
4897
    ret = ff_decode_get_packet(avctx, s->pkt);
2372
4897
    if (ret < 0)
2373
2359
        return ret;
2374
2375
#if CONFIG_SP5X_DECODER || CONFIG_AMV_DECODER
2376
2538
    if (avctx->codec_id == AV_CODEC_ID_SP5X ||
2377
2527
        avctx->codec_id == AV_CODEC_ID_AMV) {
2378
378
        ret = ff_sp5x_process_packet(avctx, s->pkt);
2379
378
        if (ret < 0)
2380
            return ret;
2381
    }
2382
#endif
2383
2384
2538
    s->buf_size = s->pkt->size;
2385
2386
2538
    return 0;
2387
}
2388
2389
4907
int ff_mjpeg_receive_frame(AVCodecContext *avctx, AVFrame *frame)
2390
{
2391
4907
    MJpegDecodeContext *s = avctx->priv_data;
2392
    const uint8_t *buf_end, *buf_ptr;
2393
    const uint8_t *unescaped_buf_ptr;
2394
    int hshift, vshift;
2395
    int unescaped_buf_size;
2396
    int start_code;
2397
    int i, index;
2398
4907
    int ret = 0;
2399
    int is16bit;
2400
2401

4907
    if (avctx->codec_id == AV_CODEC_ID_SMVJPEG && s->smv_next_frame > 0)
2402
10
        return smv_process_frame(avctx, frame);
2403
2404
4897
    av_dict_free(&s->exif_metadata);
2405
4897
    av_freep(&s->stereo3d);
2406
4897
    s->adobe_transform = -1;
2407
2408
4897
    if (s->iccnum != 0)
2409
        reset_icc_profile(s);
2410
2411
4897
    ret = mjpeg_get_packet(avctx);
2412
4897
    if (ret < 0)
2413
2359
        return ret;
2414
2415
2538
    buf_ptr = s->pkt->data;
2416
2538
    buf_end = s->pkt->data + s->pkt->size;
2417
15783
    while (buf_ptr < buf_end) {
2418
        /* find start next marker */
2419
15783
        start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,
2420
                                          &unescaped_buf_ptr,
2421
                                          &unescaped_buf_size);
2422
        /* EOF */
2423
15783
        if (start_code < 0) {
2424
5
            break;
2425
15778
        } else if (unescaped_buf_size > INT_MAX / 8) {
2426
            av_log(avctx, AV_LOG_ERROR,
2427
                   "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
2428
                   start_code, unescaped_buf_size, s->pkt->size);
2429
            return AVERROR_INVALIDDATA;
2430
        }
2431
15778
        av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%"PTRDIFF_SPECIFIER"\n",
2432
               start_code, buf_end - buf_ptr);
2433
2434
15778
        ret = init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);
2435
2436
15778
        if (ret < 0) {
2437
            av_log(avctx, AV_LOG_ERROR, "invalid buffer\n");
2438
            goto fail;
2439
        }
2440
2441
15778
        s->start_code = start_code;
2442
15778
        if (s->avctx->debug & FF_DEBUG_STARTCODE)
2443
            av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2444
2445
        /* process markers */
2446

15778
        if (start_code >= RST0 && start_code <= RST7) {
2447
2
            av_log(avctx, AV_LOG_DEBUG,
2448
                   "restart marker: %d\n", start_code & 0x0f);
2449
            /* APP fields */
2450

15776
        } else if (start_code >= APP0 && start_code <= APP15) {
2451
169
            if ((ret = mjpeg_decode_app(s)) < 0)
2452
                av_log(avctx, AV_LOG_ERROR, "unable to decode APP fields: %s\n",
2453
                       av_err2str(ret));
2454
            /* Comment */
2455
15607
        } else if (start_code == COM) {
2456
226
            ret = mjpeg_decode_com(s);
2457
226
            if (ret < 0)
2458
                return ret;
2459
15381
        } else if (start_code == DQT) {
2460
2521
            ret = ff_mjpeg_decode_dqt(s);
2461
2521
            if (ret < 0)
2462
                return ret;
2463
        }
2464
2465
15778
        ret = -1;
2466
2467
        if (!CONFIG_JPEGLS_DECODER &&
2468
            (start_code == SOF48 || start_code == LSE)) {
2469
            av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");
2470
            return AVERROR(ENOSYS);
2471
        }
2472
2473
15778
        if (avctx->skip_frame == AVDISCARD_ALL) {
2474
590
            switch(start_code) {
2475
268
            case SOF0:
2476
            case SOF1:
2477
            case SOF2:
2478
            case SOF3:
2479
            case SOF48:
2480
            case SOI:
2481
            case SOS:
2482
            case EOI:
2483
268
                break;
2484
322
            default:
2485
322
                goto skip;
2486
            }
2487
15188
        }
2488
2489



15456
        switch (start_code) {
2490
2541
        case SOI:
2491
2541
            s->restart_interval = 0;
2492
2541
            s->restart_count    = 0;
2493
2541
            s->raw_image_buffer      = buf_ptr;
2494
2541
            s->raw_image_buffer_size = buf_end - buf_ptr;
2495
            /* nothing to do on SOI */
2496
2541
            break;
2497
2526
        case DHT:
2498
2526
            if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
2499
                av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2500
                goto fail;
2501
            }
2502
2526
            break;
2503
2131
        case SOF0:
2504
        case SOF1:
2505
2131
            if (start_code == SOF0)
2506
2129
                s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT;
2507
            else
2508
2
                s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT;
2509
2131
            s->lossless    = 0;
2510
2131
            s->ls          = 0;
2511
2131
            s->progressive = 0;
2512
2131
            if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2513
                goto fail;
2514
2131
            break;
2515
        case SOF2:
2516
            s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT;
2517
            s->lossless    = 0;
2518
            s->ls          = 0;
2519
            s->progressive = 1;
2520
            if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2521
                goto fail;
2522
            break;
2523
205
        case SOF3:
2524
205
            s->avctx->profile     = FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS;
2525
205
            s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2526
205
            s->lossless    = 1;
2527
205
            s->ls          = 0;
2528
205
            s->progressive = 0;
2529
205
            if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2530
                goto fail;
2531
205
            break;
2532
205
        case SOF48:
2533
205
            s->avctx->profile     = FF_PROFILE_MJPEG_JPEG_LS;
2534
205
            s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2535
205
            s->lossless    = 1;
2536
205
            s->ls          = 1;
2537
205
            s->progressive = 0;
2538
205
            if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2539
                goto fail;
2540
205
            break;
2541
        case LSE:
2542
            if (!CONFIG_JPEGLS_DECODER ||
2543
                (ret = ff_jpegls_decode_lse(s)) < 0)
2544
                goto fail;
2545
            break;
2546
        case EOI:
2547
2541
eoi_parser:
2548

2541
            if (!avctx->hwaccel && avctx->skip_frame != AVDISCARD_ALL &&
2549

2473
                s->progressive && s->cur_scan && s->got_picture)
2550
                mjpeg_idct_scan_progressive_ac(s);
2551
2541
            s->cur_scan = 0;
2552
2541
            if (!s->got_picture) {
2553
                av_log(avctx, AV_LOG_WARNING,
2554
                       "Found EOI before any SOF, ignoring\n");
2555
                break;
2556
            }
2557
2541
            if (s->interlaced) {
2558
8
                s->bottom_field ^= 1;
2559
                /* if not bottom field, do not output image yet */
2560
8
                if (s->bottom_field == !s->interlace_polarity)
2561
4
                    break;
2562
            }
2563
2537
            if (avctx->skip_frame == AVDISCARD_ALL) {
2564
67
                s->got_picture = 0;
2565
67
                ret = AVERROR(EAGAIN);
2566
67
                goto the_end_no_picture;
2567
            }
2568
2470
            if (s->avctx->hwaccel) {
2569
                ret = s->avctx->hwaccel->end_frame(s->avctx);
2570
                if (ret < 0)
2571
                    return ret;
2572
2573
                av_freep(&s->hwaccel_picture_private);
2574
            }
2575
2470
            if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
2576
                return ret;
2577
2470
            s->got_picture = 0;
2578
2579
2470
            frame->pkt_dts = s->pkt->dts;
2580
2581

2470
            if (!s->lossless && avctx->debug & FF_DEBUG_QP) {
2582
                int qp = FFMAX3(s->qscale[0],
2583
                                s->qscale[1],
2584
                                s->qscale[2]);
2585
2586
                av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);
2587
            }
2588
2589
2470
            goto the_end;
2590
2541
        case SOS:
2591
2541
            s->raw_scan_buffer      = buf_ptr;
2592
2541
            s->raw_scan_buffer_size = buf_end - buf_ptr;
2593
2594
2541
            s->cur_scan++;
2595
2541
            if (avctx->skip_frame == AVDISCARD_ALL) {
2596
68
                skip_bits(&s->gb, get_bits_left(&s->gb));
2597
68
                break;
2598
            }
2599
2600
2473
            if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&
2601
                (avctx->err_recognition & AV_EF_EXPLODE))
2602
                goto fail;
2603
2473
            break;
2604
16
        case DRI:
2605
16
            if ((ret = mjpeg_decode_dri(s)) < 0)
2606
                return ret;
2607
16
            break;
2608
        case SOF5:
2609
        case SOF6:
2610
        case SOF7:
2611
        case SOF9:
2612
        case SOF10:
2613
        case SOF11:
2614
        case SOF13:
2615
        case SOF14:
2616
        case SOF15:
2617
        case JPG:
2618
            av_log(avctx, AV_LOG_ERROR,
2619
                   "mjpeg: unsupported coding type (%x)\n", start_code);
2620
            break;
2621
        }
2622
2623
13245
skip:
2624
        /* eof process start code */
2625
13245
        buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
2626
26490
        av_log(avctx, AV_LOG_DEBUG,
2627
               "marker parser used %d bytes (%d bits)\n",
2628
13245
               (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
2629
    }
2630

5
    if (s->got_picture && s->cur_scan) {
2631
4
        av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
2632
4
        goto eoi_parser;
2633
    }
2634
1
    av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
2635
1
    return AVERROR_INVALIDDATA;
2636
fail:
2637
    s->got_picture = 0;
2638
    return ret;
2639
2470
the_end:
2640
2641
2470
    is16bit = av_pix_fmt_desc_get(s->avctx->pix_fmt)->comp[0].step > 1;
2642
2643
2470
    if (AV_RB32(s->upscale_h)) {
2644
        int p;
2645
        av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2646
                   avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||
2647
                   avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2648
                   avctx->pix_fmt == AV_PIX_FMT_YUV440P  ||
2649
                   avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2650
                   avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2651
                   avctx->pix_fmt == AV_PIX_FMT_YUV420P  ||
2652
                   avctx->pix_fmt == AV_PIX_FMT_YUV420P16||
2653
                   avctx->pix_fmt == AV_PIX_FMT_YUVA420P  ||
2654
                   avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2655
                   avctx->pix_fmt == AV_PIX_FMT_GBRP     ||
2656
                   avctx->pix_fmt == AV_PIX_FMT_GBRAP
2657
                  );
2658
        ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2659
        if (ret)
2660
            return ret;
2661
2662
        av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2663
        for (p = 0; p<s->nb_components; p++) {
2664
            uint8_t *line = s->picture_ptr->data[p];
2665
            int w = s->width;
2666
            int h = s->height;
2667
            if (!s->upscale_h[p])
2668
                continue;
2669
            if (p==1 || p==2) {
2670
                w = AV_CEIL_RSHIFT(w, hshift);
2671
                h = AV_CEIL_RSHIFT(h, vshift);
2672
            }
2673
            if (s->upscale_v[p] == 1)
2674
                h = (h+1)>>1;
2675
            av_assert0(w > 0);
2676
            for (i = 0; i < h; i++) {
2677
                if (s->upscale_h[p] == 1) {
2678
                    if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];
2679
                    else                      line[w - 1] = line[(w - 1) / 2];
2680
                    for (index = w - 2; index > 0; index--) {
2681
                        if (is16bit)
2682
                            ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;
2683
                        else
2684
                            line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
2685
                    }
2686
                } else if (s->upscale_h[p] == 2) {
2687
                    if (is16bit) {
2688
                        ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3];
2689
                        if (w > 1)
2690
                            ((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1];
2691
                    } else {
2692
                        line[w - 1] = line[(w - 1) / 3];
2693
                        if (w > 1)
2694
                            line[w - 2] = line[w - 1];
2695
                    }
2696
                    for (index = w - 3; index > 0; index--) {
2697
                        line[index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3;
2698
                    }
2699
                }
2700
                line += s->linesize[p];
2701
            }
2702
        }
2703
    }
2704
2470
    if (AV_RB32(s->upscale_v)) {
2705
        int p;
2706
        av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2707
                   avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||
2708
                   avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2709
                   avctx->pix_fmt == AV_PIX_FMT_YUV422P  ||
2710
                   avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2711
                   avctx->pix_fmt == AV_PIX_FMT_YUV420P  ||
2712
                   avctx->pix_fmt == AV_PIX_FMT_YUV440P  ||
2713
                   avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2714
                   avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2715
                   avctx->pix_fmt == AV_PIX_FMT_YUVA420P  ||
2716
                   avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2717
                   avctx->pix_fmt == AV_PIX_FMT_GBRP     ||
2718
                   avctx->pix_fmt == AV_PIX_FMT_GBRAP
2719
                   );
2720
        ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2721
        if (ret)
2722
            return ret;
2723
2724
        av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2725
        for (p = 0; p < s->nb_components; p++) {
2726
            uint8_t *dst;
2727
            int w = s->width;
2728
            int h = s->height;
2729
            if (!s->upscale_v[p])
2730
                continue;
2731
            if (p==1 || p==2) {
2732
                w = AV_CEIL_RSHIFT(w, hshift);
2733
                h = AV_CEIL_RSHIFT(h, vshift);
2734
            }
2735
            dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];
2736
            for (i = h - 1; i; i--) {
2737
                uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2738
                uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2739
                if (s->upscale_v[p] != 2 && (src1 == src2 || i == h - 1)) {
2740
                    memcpy(dst, src1, w);
2741
                } else {
2742
                    for (index = 0; index < w; index++)
2743
                        dst[index] = (src1[index] + src2[index]) >> 1;
2744
                }
2745
                dst -= s->linesize[p];
2746
            }
2747
        }
2748
    }
2749

2470
    if (s->flipped && !s->rgb) {
2750
        int j;
2751
367
        ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2752
367
        if (ret)
2753
            return ret;
2754
2755
367
        av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2756
1468
        for (index=0; index<s->nb_components; index++) {
2757
1101
            uint8_t *dst = s->picture_ptr->data[index];
2758
1101
            int w = s->picture_ptr->width;
2759
1101
            int h = s->picture_ptr->height;
2760

1101
            if(index && index<3){
2761
734
                w = AV_CEIL_RSHIFT(w, hshift);
2762
734
                h = AV_CEIL_RSHIFT(h, vshift);
2763
            }
2764
1101
            if(dst){
2765
1101
                uint8_t *dst2 = dst + s->picture_ptr->linesize[index]*(h-1);
2766
66408
                for (i=0; i<h/2; i++) {
2767
14088753
                    for (j=0; j<w; j++)
2768
14023446
                        FFSWAP(int, dst[j], dst2[j]);
2769
65307
                    dst  += s->picture_ptr->linesize[index];
2770
65307
                    dst2 -= s->picture_ptr->linesize[index];
2771
                }
2772
            }
2773
        }
2774
    }
2775

2470
    if (s->adobe_transform == 0 && s->avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
2776
        int w = s->picture_ptr->width;
2777
        int h = s->picture_ptr->height;
2778
        av_assert0(s->nb_components == 4);
2779
        for (i=0; i<h; i++) {
2780
            int j;
2781
            uint8_t *dst[4];
2782
            for (index=0; index<4; index++) {
2783
                dst[index] =   s->picture_ptr->data[index]
2784
                             + s->picture_ptr->linesize[index]*i;
2785
            }
2786
            for (j=0; j<w; j++) {
2787
                int k = dst[3][j];
2788
                int r = dst[0][j] * k;
2789
                int g = dst[1][j] * k;
2790
                int b = dst[2][j] * k;
2791
                dst[0][j] = g*257 >> 16;
2792
                dst[1][j] = b*257 >> 16;
2793
                dst[2][j] = r*257 >> 16;
2794
                dst[3][j] = 255;
2795
            }
2796
        }
2797
    }
2798

2470
    if (s->adobe_transform == 2 && s->avctx->pix_fmt == AV_PIX_FMT_YUVA444P) {
2799
        int w = s->picture_ptr->width;
2800
        int h = s->picture_ptr->height;
2801
        av_assert0(s->nb_components == 4);
2802
        for (i=0; i<h; i++) {
2803
            int j;
2804
            uint8_t *dst[4];
2805
            for (index=0; index<4; index++) {
2806
                dst[index] =   s->picture_ptr->data[index]
2807
                             + s->picture_ptr->linesize[index]*i;
2808
            }
2809
            for (j=0; j<w; j++) {
2810
                int k = dst[3][j];
2811
                int r = (255 - dst[0][j]) * k;
2812
                int g = (128 - dst[1][j]) * k;
2813
                int b = (128 - dst[2][j]) * k;
2814
                dst[0][j] = r*257 >> 16;
2815
                dst[1][j] = (g*257 >> 16) + 128;
2816
                dst[2][j] = (b*257 >> 16) + 128;
2817
                dst[3][j] = 255;
2818
            }
2819
        }
2820
    }
2821
2822
2470
    if (s->stereo3d) {
2823
        AVStereo3D *stereo = av_stereo3d_create_side_data(frame);
2824
        if (stereo) {
2825
            stereo->type  = s->stereo3d->type;
2826
            stereo->flags = s->stereo3d->flags;
2827
        }
2828
        av_freep(&s->stereo3d);
2829
    }
2830
2831

2470
    if (s->iccnum != 0 && s->iccnum == s->iccread) {
2832
        AVFrameSideData *sd;
2833
        size_t offset = 0;
2834
        int total_size = 0;
2835
        int i;
2836
2837
        /* Sum size of all parts. */
2838
        for (i = 0; i < s->iccnum; i++)
2839
            total_size += s->iccentries[i].length;
2840
2841
        sd = av_frame_new_side_data(frame, AV_FRAME_DATA_ICC_PROFILE, total_size);
2842
        if (!sd) {
2843
            av_log(s->avctx, AV_LOG_ERROR, "Could not allocate frame side data\n");
2844
            return AVERROR(ENOMEM);
2845
        }
2846
2847
        /* Reassemble the parts, which are now in-order. */
2848
        for (i = 0; i < s->iccnum; i++) {
2849
            memcpy(sd->data + offset, s->iccentries[i].data, s->iccentries[i].length);
2850
            offset += s->iccentries[i].length;
2851
        }
2852
    }
2853
2854
2470
    av_dict_copy(&frame->metadata, s->exif_metadata, 0);
2855
2470
    av_dict_free(&s->exif_metadata);
2856
2857
2470
    if (avctx->codec_id == AV_CODEC_ID_SMVJPEG) {
2858
3
        ret = smv_process_frame(avctx, frame);
2859
3
        if (ret < 0) {
2860
            av_frame_unref(frame);
2861
            return ret;
2862
        }
2863
    }
2864
2470
    if ((avctx->codec_tag == MKTAG('A', 'V', 'R', 'n') ||
2865
2470
         avctx->codec_tag == MKTAG('A', 'V', 'D', 'J')) &&
2866
10
        avctx->coded_height > s->orig_height) {
2867
10
        frame->height   = AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres);
2868
10
        frame->crop_top = frame->height - avctx->height;
2869
    }
2870
2871
2470
    ret = 0;
2872
2873
2537
the_end_no_picture:
2874
2537
    av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n",
2875
           buf_end - buf_ptr);
2876
2877
2537
    return ret;
2878
}
2879
2880
/* mxpeg may call the following function (with a blank MJpegDecodeContext)
2881
 * even without having called ff_mjpeg_decode_init(). */
2882
158
av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
2883
{
2884
158
    MJpegDecodeContext *s = avctx->priv_data;
2885
    int i, j;
2886
2887


158
    if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_number) {
2888
        av_log(avctx, AV_LOG_INFO, "Single field\n");
2889
    }
2890
2891
158
    if (s->picture) {
2892
156
        av_frame_free(&s->picture);
2893
156
        s->picture_ptr = NULL;
2894
2
    } else if (s->picture_ptr)
2895
        av_frame_unref(s->picture_ptr);
2896
2897
158
    av_packet_free(&s->pkt);
2898
2899
158
    av_frame_free(&s->smv_frame);
2900
2901
158
    av_freep(&s->buffer);
2902
158
    av_freep(&s->stereo3d);
2903
158
    av_freep(&s->ljpeg_buffer);
2904
158
    s->ljpeg_buffer_size = 0;
2905
2906
632
    for (i = 0; i < 3; i++) {
2907
2370
        for (j = 0; j < 4; j++)
2908
1896
            ff_free_vlc(&s->vlcs[i][j]);
2909
    }
2910
790
    for (i = 0; i < MAX_COMPONENTS; i++) {
2911
632
        av_freep(&s->blocks[i]);
2912
632
        av_freep(&s->last_nnz[i]);
2913
    }
2914
158
    av_dict_free(&s->exif_metadata);
2915
2916
158
    reset_icc_profile(s);
2917
2918
158
    av_freep(&s->hwaccel_picture_private);
2919
2920
158
    return 0;
2921
}
2922
2923
static void decode_flush(AVCodecContext *avctx)
2924
{
2925
    MJpegDecodeContext *s = avctx->priv_data;
2926
    s->got_picture = 0;
2927
2928
    s->smv_next_frame = 0;
2929
    av_frame_unref(s->smv_frame);
2930
}
2931
2932
#if CONFIG_MJPEG_DECODER
2933
#define OFFSET(x) offsetof(MJpegDecodeContext, x)
2934
#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2935
static const AVOption options[] = {
2936
    { "extern_huff", "Use external huffman table.",
2937
      OFFSET(extern_huff), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
2938
    { NULL },
2939
};
2940
2941
static const AVClass mjpegdec_class = {
2942
    .class_name = "MJPEG decoder",
2943
    .item_name  = av_default_item_name,
2944
    .option     = options,
2945
    .version    = LIBAVUTIL_VERSION_INT,
2946
};
2947
2948
AVCodec ff_mjpeg_decoder = {
2949
    .name           = "mjpeg",
2950
    .long_name      = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
2951
    .type           = AVMEDIA_TYPE_VIDEO,
2952
    .id             = AV_CODEC_ID_MJPEG,
2953
    .priv_data_size = sizeof(MJpegDecodeContext),
2954
    .init           = ff_mjpeg_decode_init,
2955
    .close          = ff_mjpeg_decode_end,
2956
    .receive_frame  = ff_mjpeg_receive_frame,
2957
    .flush          = decode_flush,
2958
    .capabilities   = AV_CODEC_CAP_DR1,
2959
    .max_lowres     = 3,
2960
    .priv_class     = &mjpegdec_class,
2961
    .profiles       = NULL_IF_CONFIG_SMALL(ff_mjpeg_profiles),
2962
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP |
2963
                      FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM | FF_CODEC_CAP_SETS_PKT_DTS,
2964
    .hw_configs     = (const AVCodecHWConfigInternal *const []) {
2965
#if CONFIG_MJPEG_NVDEC_HWACCEL
2966
                        HWACCEL_NVDEC(mjpeg),
2967
#endif
2968
#if CONFIG_MJPEG_VAAPI_HWACCEL
2969
                        HWACCEL_VAAPI(mjpeg),
2970
#endif
2971
                        NULL
2972
                    },
2973
};
2974
#endif
2975
#if CONFIG_THP_DECODER
2976
AVCodec ff_thp_decoder = {
2977
    .name           = "thp",
2978
    .long_name      = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
2979
    .type           = AVMEDIA_TYPE_VIDEO,
2980
    .id             = AV_CODEC_ID_THP,
2981
    .priv_data_size = sizeof(MJpegDecodeContext),
2982
    .init           = ff_mjpeg_decode_init,
2983
    .close          = ff_mjpeg_decode_end,
2984
    .receive_frame  = ff_mjpeg_receive_frame,
2985
    .flush          = decode_flush,
2986
    .capabilities   = AV_CODEC_CAP_DR1,
2987
    .max_lowres     = 3,
2988
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP |
2989
                      FF_CODEC_CAP_SETS_PKT_DTS,
2990
};
2991
#endif
2992
2993
#if CONFIG_SMVJPEG_DECODER
2994
AVCodec ff_smvjpeg_decoder = {
2995
    .name           = "smvjpeg",
2996
    .long_name      = NULL_IF_CONFIG_SMALL("SMV JPEG"),
2997
    .type           = AVMEDIA_TYPE_VIDEO,
2998
    .id             = AV_CODEC_ID_SMVJPEG,
2999
    .priv_data_size = sizeof(MJpegDecodeContext),
3000
    .init           = ff_mjpeg_decode_init,
3001
    .close          = ff_mjpeg_decode_end,
3002
    .receive_frame  = ff_mjpeg_receive_frame,
3003
    .flush          = decode_flush,
3004
    .capabilities   = AV_CODEC_CAP_DR1,
3005
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_EXPORTS_CROPPING |
3006
                      FF_CODEC_CAP_SETS_PKT_DTS | FF_CODEC_CAP_INIT_CLEANUP,
3007
};
3008
#endif