GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/mjpegdec.c Lines: 847 1724 49.1 %
Date: 2020-09-25 23:16:12 Branches: 597 1585 37.7 %

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 "hwconfig.h"
40
#include "idctdsp.h"
41
#include "internal.h"
42
#include "jpegtables.h"
43
#include "mjpeg.h"
44
#include "mjpegdec.h"
45
#include "jpeglsdec.h"
46
#include "profiles.h"
47
#include "put_bits.h"
48
#include "tiff.h"
49
#include "exif.h"
50
#include "bytestream.h"
51
52
53
14481
static int build_vlc(VLC *vlc, const uint8_t *bits_table,
54
                     const uint8_t *val_table, int nb_codes,
55
                     int use_static, int is_ac)
56
{
57
14481
    uint8_t huff_size[256] = { 0 };
58
    uint16_t huff_code[256];
59
    uint16_t huff_sym[256];
60
    int i;
61
62
14481
    av_assert0(nb_codes <= 256);
63
64
14481
    ff_mjpeg_build_huffman_codes(huff_size, huff_code, bits_table, val_table);
65
66
3721617
    for (i = 0; i < 256; i++)
67
3707136
        huff_sym[i] = i + 16 * is_ac;
68
69
14481
    if (is_ac)
70
4827
        huff_sym[0] = 16 * 256;
71
72
14481
    return ff_init_vlc_sparse(vlc, 9, nb_codes, huff_size, 1, 1,
73
                              huff_code, 2, 2, huff_sym, 2, 2, use_static);
74
}
75
76
140
static int init_default_huffman_tables(MJpegDecodeContext *s)
77
{
78
    static const struct {
79
        int class;
80
        int index;
81
        const uint8_t *bits;
82
        const uint8_t *values;
83
        int codes;
84
        int length;
85
    } ht[] = {
86
        { 0, 0, avpriv_mjpeg_bits_dc_luminance,
87
                avpriv_mjpeg_val_dc, 12, 12 },
88
        { 0, 1, avpriv_mjpeg_bits_dc_chrominance,
89
                avpriv_mjpeg_val_dc, 12, 12 },
90
        { 1, 0, avpriv_mjpeg_bits_ac_luminance,
91
                avpriv_mjpeg_val_ac_luminance,   251, 162 },
92
        { 1, 1, avpriv_mjpeg_bits_ac_chrominance,
93
                avpriv_mjpeg_val_ac_chrominance, 251, 162 },
94
        { 2, 0, avpriv_mjpeg_bits_ac_luminance,
95
                avpriv_mjpeg_val_ac_luminance,   251, 162 },
96
        { 2, 1, avpriv_mjpeg_bits_ac_chrominance,
97
                avpriv_mjpeg_val_ac_chrominance, 251, 162 },
98
    };
99
    int i, ret;
100
101
980
    for (i = 0; i < FF_ARRAY_ELEMS(ht); i++) {
102
840
        ret = build_vlc(&s->vlcs[ht[i].class][ht[i].index],
103
                        ht[i].bits, ht[i].values, ht[i].codes,
104
840
                        0, ht[i].class == 1);
105
840
        if (ret < 0)
106
            return ret;
107
108
840
        if (ht[i].class < 2) {
109
560
            memcpy(s->raw_huffman_lengths[ht[i].class][ht[i].index],
110
560
                   ht[i].bits + 1, 16);
111
560
            memcpy(s->raw_huffman_values[ht[i].class][ht[i].index],
112
560
                   ht[i].values, ht[i].length);
113
        }
114
    }
115
116
140
    return 0;
117
}
118
119
static void parse_avid(MJpegDecodeContext *s, uint8_t *buf, int len)
120
{
121
    s->buggy_avid = 1;
122
    if (len > 14 && buf[12] == 1) /* 1 - NTSC */
123
        s->interlace_polarity = 1;
124
    if (len > 14 && buf[12] == 2) /* 2 - PAL */
125
        s->interlace_polarity = 0;
126
    if (s->avctx->debug & FF_DEBUG_PICT_INFO)
127
        av_log(s->avctx, AV_LOG_INFO, "AVID: len:%d %d\n", len, len > 14 ? buf[12] : -1);
128
}
129
130
216
static void init_idct(AVCodecContext *avctx)
131
{
132
216
    MJpegDecodeContext *s = avctx->priv_data;
133
134
216
    ff_idctdsp_init(&s->idsp, avctx);
135
216
    ff_init_scantable(s->idsp.idct_permutation, &s->scantable,
136
                      ff_zigzag_direct);
137
216
}
138
139
140
av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)
140
{
141
140
    MJpegDecodeContext *s = avctx->priv_data;
142
    int ret;
143
144
140
    if (!s->picture_ptr) {
145
138
        s->picture = av_frame_alloc();
146
138
        if (!s->picture)
147
            return AVERROR(ENOMEM);
148
138
        s->picture_ptr = s->picture;
149
    }
150
151
140
    s->avctx = avctx;
152
140
    ff_blockdsp_init(&s->bdsp, avctx);
153
140
    ff_hpeldsp_init(&s->hdsp, avctx->flags);
154
140
    init_idct(avctx);
155
140
    s->buffer_size   = 0;
156
140
    s->buffer        = NULL;
157
140
    s->start_code    = -1;
158
140
    s->first_picture = 1;
159
140
    s->got_picture   = 0;
160
140
    s->org_height    = avctx->coded_height;
161
140
    avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
162
140
    avctx->colorspace = AVCOL_SPC_BT470BG;
163
140
    s->hwaccel_pix_fmt = s->hwaccel_sw_pix_fmt = AV_PIX_FMT_NONE;
164
165
140
    if ((ret = init_default_huffman_tables(s)) < 0)
166
        return ret;
167
168
140
    if (s->extern_huff) {
169
        av_log(avctx, AV_LOG_INFO, "using external huffman table\n");
170
        if ((ret = init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8)) < 0)
171
            return ret;
172
        if (ff_mjpeg_decode_dht(s)) {
173
            av_log(avctx, AV_LOG_ERROR,
174
                   "error using external huffman table, switching back to internal\n");
175
            init_default_huffman_tables(s);
176
        }
177
    }
178
140
    if (avctx->field_order == AV_FIELD_BB) { /* quicktime icefloe 019 */
179
        s->interlace_polarity = 1;           /* bottom field first */
180
        av_log(avctx, AV_LOG_DEBUG, "bottom field first\n");
181
140
    } else if (avctx->field_order == AV_FIELD_UNKNOWN) {
182
138
        if (avctx->codec_tag == AV_RL32("MJPG"))
183
51
            s->interlace_polarity = 1;
184
    }
185
186
140
    if (   avctx->extradata_size > 8
187
        && AV_RL32(avctx->extradata) == 0x2C
188
        && AV_RL32(avctx->extradata+4) == 0x18) {
189
        parse_avid(s, avctx->extradata, avctx->extradata_size);
190
    }
191
192
140
    if (avctx->codec->id == AV_CODEC_ID_AMV)
193
11
        s->flipped = 1;
194
195
140
    return 0;
196
}
197
198
199
/* quantize tables */
200
2512
int ff_mjpeg_decode_dqt(MJpegDecodeContext *s)
201
{
202
    int len, index, i;
203
204
2512
    len = get_bits(&s->gb, 16) - 2;
205
206
2512
    if (8*len > get_bits_left(&s->gb)) {
207
        av_log(s->avctx, AV_LOG_ERROR, "dqt: len %d is too large\n", len);
208
        return AVERROR_INVALIDDATA;
209
    }
210
211
5508
    while (len >= 65) {
212
2996
        int pr = get_bits(&s->gb, 4);
213
2996
        if (pr > 1) {
214
            av_log(s->avctx, AV_LOG_ERROR, "dqt: invalid precision\n");
215
            return AVERROR_INVALIDDATA;
216
        }
217
2996
        index = get_bits(&s->gb, 4);
218
2996
        if (index >= 4)
219
            return -1;
220
2996
        av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index);
221
        /* read quant table */
222
194740
        for (i = 0; i < 64; i++) {
223
191744
            s->quant_matrixes[index][i] = get_bits(&s->gb, pr ? 16 : 8);
224
191744
            if (s->quant_matrixes[index][i] == 0) {
225
                av_log(s->avctx, AV_LOG_ERROR, "dqt: 0 quant value\n");
226
                return AVERROR_INVALIDDATA;
227
            }
228
        }
229
230
        // XXX FIXME fine-tune, and perhaps add dc too
231
2996
        s->qscale[index] = FFMAX(s->quant_matrixes[index][1],
232
2996
                                 s->quant_matrixes[index][8]) >> 1;
233
2996
        av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n",
234
               index, s->qscale[index]);
235
2996
        len -= 1 + 64 * (1+pr);
236
    }
237
2512
    return 0;
238
}
239
240
/* decode huffman tables and build VLC decoders */
241
2538
int ff_mjpeg_decode_dht(MJpegDecodeContext *s)
242
{
243
    int len, index, i, class, n, v, code_max;
244
    uint8_t bits_table[17];
245
    uint8_t val_table[256];
246
2538
    int ret = 0;
247
248
2538
    len = get_bits(&s->gb, 16) - 2;
249
250
2538
    if (8*len > get_bits_left(&s->gb)) {
251
        av_log(s->avctx, AV_LOG_ERROR, "dht: len %d is too large\n", len);
252
        return AVERROR_INVALIDDATA;
253
    }
254
255
11632
    while (len > 0) {
256
9094
        if (len < 17)
257
            return AVERROR_INVALIDDATA;
258
9094
        class = get_bits(&s->gb, 4);
259
9094
        if (class >= 2)
260
            return AVERROR_INVALIDDATA;
261
9094
        index = get_bits(&s->gb, 4);
262
9094
        if (index >= 4)
263
            return AVERROR_INVALIDDATA;
264
9094
        n = 0;
265
154598
        for (i = 1; i <= 16; i++) {
266
145504
            bits_table[i] = get_bits(&s->gb, 8);
267
145504
            n += bits_table[i];
268
        }
269
9094
        len -= 17;
270

9094
        if (len < n || n > 256)
271
            return AVERROR_INVALIDDATA;
272
273
9094
        code_max = 0;
274
454786
        for (i = 0; i < n; i++) {
275
445692
            v = get_bits(&s->gb, 8);
276
445692
            if (v > code_max)
277
111627
                code_max = v;
278
445692
            val_table[i] = v;
279
        }
280
9094
        len -= n;
281
282
        /* build VLC and flush previous vlc if present */
283
9094
        ff_free_vlc(&s->vlcs[class][index]);
284
9094
        av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
285
               class, index, code_max + 1);
286
9094
        if ((ret = build_vlc(&s->vlcs[class][index], bits_table, val_table,
287
                             code_max + 1, 0, class > 0)) < 0)
288
            return ret;
289
290
9094
        if (class > 0) {
291
4547
            ff_free_vlc(&s->vlcs[2][index]);
292
4547
            if ((ret = build_vlc(&s->vlcs[2][index], bits_table, val_table,
293
                                 code_max + 1, 0, 0)) < 0)
294
                return ret;
295
        }
296
297
154598
        for (i = 0; i < 16; i++)
298
145504
            s->raw_huffman_lengths[class][index][i] = bits_table[i + 1];
299
2337158
        for (i = 0; i < 256; i++)
300
2328064
            s->raw_huffman_values[class][index][i] = val_table[i];
301
    }
302
2538
    return 0;
303
}
304
305
2542
int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
306
{
307
    int len, nb_components, i, width, height, bits, ret, size_change;
308
    unsigned pix_fmt_id;
309
2542
    int h_count[MAX_COMPONENTS] = { 0 };
310
2542
    int v_count[MAX_COMPONENTS] = { 0 };
311
312
2542
    s->cur_scan = 0;
313
2542
    memset(s->upscale_h, 0, sizeof(s->upscale_h));
314
2542
    memset(s->upscale_v, 0, sizeof(s->upscale_v));
315
316
2542
    len     = get_bits(&s->gb, 16);
317
2542
    bits    = get_bits(&s->gb, 8);
318
319

2542
    if (bits > 16 || bits < 1) {
320
        av_log(s->avctx, AV_LOG_ERROR, "bits %d is invalid\n", bits);
321
        return AVERROR_INVALIDDATA;
322
    }
323
324
2542
    if (s->avctx->bits_per_raw_sample != bits) {
325
76
        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);
326
76
        s->avctx->bits_per_raw_sample = bits;
327
76
        init_idct(s->avctx);
328
    }
329
2542
    if (s->pegasus_rct)
330
        bits = 9;
331

2542
    if (bits == 9 && !s->pegasus_rct)
332
        s->rct  = 1;    // FIXME ugly
333
334

2542
    if(s->lossless && s->avctx->lowres){
335
        av_log(s->avctx, AV_LOG_ERROR, "lowres is not possible with lossless jpeg\n");
336
        return -1;
337
    }
338
339
2542
    height = get_bits(&s->gb, 16);
340
2542
    width  = get_bits(&s->gb, 16);
341
342
    // HACK for odd_height.mov
343

2542
    if (s->interlaced && s->width == width && s->height == height + 1)
344
        height= s->height;
345
346
2542
    av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
347
2542
    if (av_image_check_size(width, height, 0, s->avctx) < 0)
348
        return AVERROR_INVALIDDATA;
349

2542
    if (s->buf_size && (width + 7) / 8 * ((height + 7) / 8) > s->buf_size * 4LL)
350
        return AVERROR_INVALIDDATA;
351
352
2542
    nb_components = get_bits(&s->gb, 8);
353

2542
    if (nb_components <= 0 ||
354
        nb_components > MAX_COMPONENTS)
355
        return -1;
356

2542
    if (s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
357
15
        if (nb_components != s->nb_components) {
358
            av_log(s->avctx, AV_LOG_ERROR,
359
                   "nb_components changing in interlaced picture\n");
360
            return AVERROR_INVALIDDATA;
361
        }
362
    }
363

2542
    if (s->ls && !(bits <= 8 || nb_components == 1)) {
364
        avpriv_report_missing_feature(s->avctx,
365
                                      "JPEG-LS that is not <= 8 "
366
                                      "bits/component or 16-bit gray");
367
        return AVERROR_PATCHWELCOME;
368
    }
369
2542
    if (len != 8 + 3 * nb_components) {
370
        av_log(s->avctx, AV_LOG_ERROR, "decode_sof0: error, len(%d) mismatch %d components\n", len, nb_components);
371
        return AVERROR_INVALIDDATA;
372
    }
373
374
2542
    s->nb_components = nb_components;
375
2542
    s->h_max         = 1;
376
2542
    s->v_max         = 1;
377
10164
    for (i = 0; i < nb_components; i++) {
378
        /* component id */
379
7622
        s->component_id[i] = get_bits(&s->gb, 8) - 1;
380
7622
        h_count[i]         = get_bits(&s->gb, 4);
381
7622
        v_count[i]         = get_bits(&s->gb, 4);
382
        /* compute hmax and vmax (only used in interleaved case) */
383
7622
        if (h_count[i] > s->h_max)
384
2128
            s->h_max = h_count[i];
385
7622
        if (v_count[i] > s->v_max)
386
2298
            s->v_max = v_count[i];
387
7622
        s->quant_index[i] = get_bits(&s->gb, 8);
388
7622
        if (s->quant_index[i] >= 4) {
389
            av_log(s->avctx, AV_LOG_ERROR, "quant_index is invalid\n");
390
            return AVERROR_INVALIDDATA;
391
        }
392

7622
        if (!h_count[i] || !v_count[i]) {
393
            av_log(s->avctx, AV_LOG_ERROR,
394
                   "Invalid sampling factor in component %d %d:%d\n",
395
                   i, h_count[i], v_count[i]);
396
            return AVERROR_INVALIDDATA;
397
        }
398
399
7622
        av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n",
400
               i, h_count[i], v_count[i],
401
               s->component_id[i], s->quant_index[i]);
402
    }
403
2542
    if (   nb_components == 4
404
        && s->component_id[0] == 'C' - 1
405
        && s->component_id[1] == 'M' - 1
406
        && s->component_id[2] == 'Y' - 1
407
        && s->component_id[3] == 'K' - 1)
408
        s->adobe_transform = 0;
409
410

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

2542
    if (width != s->width || height != s->height || bits != s->bits ||
430
2213
        memcmp(s->h_count, h_count, sizeof(h_count))                ||
431
2213
        memcmp(s->v_count, v_count, sizeof(v_count))) {
432
329
        size_change = 1;
433
434
329
        s->width      = width;
435
329
        s->height     = height;
436
329
        s->bits       = bits;
437
329
        memcpy(s->h_count, h_count, sizeof(h_count));
438
329
        memcpy(s->v_count, v_count, sizeof(v_count));
439
329
        s->interlaced = 0;
440
329
        s->got_picture = 0;
441
442
        /* test interlaced mode */
443
329
        if (s->first_picture   &&
444

126
            (s->multiscope != 2 || s->avctx->time_base.den >= 25 * s->avctx->time_base.num) &&
445
126
            s->org_height != 0 &&
446
103
            s->height < ((s->org_height * 3) / 4)) {
447
4
            s->interlaced                    = 1;
448
4
            s->bottom_field                  = s->interlace_polarity;
449
4
            s->picture_ptr->interlaced_frame = 1;
450
4
            s->picture_ptr->top_field_first  = !s->interlace_polarity;
451
4
            height *= 2;
452
        }
453
454
329
        ret = ff_set_dimensions(s->avctx, width, height);
455
329
        if (ret < 0)
456
            return ret;
457
458
329
        s->first_picture = 0;
459
    } else {
460
2213
        size_change = 0;
461
    }
462
463

2542
    if (s->got_picture && s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
464
15
        if (s->progressive) {
465
            avpriv_request_sample(s->avctx, "progressively coded interlaced picture");
466
            return AVERROR_INVALIDDATA;
467
        }
468
    } else {
469


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


20216
            if (is == 1 && js != 2 && (i < 2 || i > 5))
492
1051
                js = (pix_fmt_id >> ( 8 + 4*(i&1))) & 0xF;
493


20216
            if (is == 1 && js != 2 && (i < 2 || i > 5))
494
1051
                js = (pix_fmt_id >> (16 + 4*(i&1))) & 0xF;
495
496

20216
            if (is == 1 && js == 2) {
497
                if (i & 1) s->upscale_h[j/2] = 1;
498
                else       s->upscale_v[j/2] = 1;
499
            }
500
        }
501
502
2527
        if (s->bayer) {
503
            if (pix_fmt_id != 0x11110000 && pix_fmt_id != 0x11000000)
504
                goto unk_pixfmt;
505
        }
506
507



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

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

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

223
            if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
606
                if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
607
                else
608
                    goto unk_pixfmt;
609
                s->upscale_h[0] = s->upscale_h[1] = 1;
610
            } else {
611

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

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

2527
        if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->avctx->lowres) {
665
            avpriv_report_missing_feature(s->avctx, "Lowres for weird subsampling");
666
            return AVERROR_PATCHWELCOME;
667
        }
668


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

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

2486
    if ((s->rgb && !s->lossless && !s->ls) ||
739

2486
        (!s->rgb && s->ls && s->nb_components > 1) ||
740

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

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

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

3816050
            if (s->restart_interval && !s->restart_count){
1248
                s->restart_count = s->restart_interval;
1249
                resync_mb_x = mb_x;
1250
                resync_mb_y = mb_y;
1251
            }
1252
1253


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

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

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

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

109000
                                if(x==0 && leftcol){
1283
600
                                    pred= 1 << (bits - 1);
1284
                                }else{
1285
108400
                                    pred= ptr[-1];
1286
                                }
1287
                            }else{
1288

188000
                                if(x==0 && leftcol){
1289
89200
                                    pred= ptr[-linesize];
1290
                                }else{
1291


98800
                                    PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1292
                                }
1293
                            }
1294
1295

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


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

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

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

766835
            const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
1451
1452

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

4648340
                    if (s->interlaced && s->bottom_field)
1475
10720
                        block_offset += linesize[c] >> 1;
1476

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

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

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


7540
        if((nb_components == 1 || nb_components == 3) && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
1680
            index = (index+2)%3;
1681
1682
7540
        s->comp_index[i] = index;
1683
1684
7540
        s->dc_index[i] = get_bits(&s->gb, 4);
1685
7540
        s->ac_index[i] = get_bits(&s->gb, 4);
1686
1687

7540
        if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1688

7540
            s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1689
            goto out_of_range;
1690


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

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

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

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

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

18
    if (id == AV_RL32("colr") && len > 0) {
1941
        s->colr = get_bits(&s->gb, 8);
1942
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1943
            av_log(s->avctx, AV_LOG_INFO, "COLR %d\n", s->colr);
1944
        len --;
1945
        goto out;
1946
    }
1947

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

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

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

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

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

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

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

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


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

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

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

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

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

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

26357130
            if (x == 0xFF && b < t) {
2290
147726
                x = src[b++];
2291
147726
                if (x & 0x80) {
2292
                    av_log(s->avctx, AV_LOG_WARNING, "Invalid escape sequence\n");
2293
                    x &= 0x7f;
2294
                }
2295
147726
                put_bits(&pb, 7, x);
2296
147726
                bit_count--;
2297
            }
2298
        }
2299
205
        flush_put_bits(&pb);
2300
2301
205
        *unescaped_buf_ptr  = dst;
2302
205
        *unescaped_buf_size = (bit_count + 7) >> 3;
2303
205
        memset(s->buffer + *unescaped_buf_size, 0,
2304
               AV_INPUT_BUFFER_PADDING_SIZE);
2305
    } else {
2306
13193
        *unescaped_buf_ptr  = *buf_ptr;
2307
13193
        *unescaped_buf_size = buf_end - *buf_ptr;
2308
    }
2309
2310
15742
    return start_code;
2311
}
2312
2313
140
static void reset_icc_profile(MJpegDecodeContext *s)
2314
{
2315
    int i;
2316
2317
140
    if (s->iccdata)
2318
        for (i = 0; i < s->iccnum; i++)
2319
            av_freep(&s->iccdata[i]);
2320
140
    av_freep(&s->iccdata);
2321
140
    av_freep(&s->iccdatalens);
2322
2323
140
    s->iccread = 0;
2324
140
    s->iccnum  = 0;
2325
140
}
2326
2327
2515
int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
2328
                          AVPacket *avpkt)
2329
{
2330
2515
    AVFrame     *frame = data;
2331
2515
    const uint8_t *buf = avpkt->data;
2332
2515
    int buf_size       = avpkt->size;
2333
2515
    MJpegDecodeContext *s = avctx->priv_data;
2334
    const uint8_t *buf_end, *buf_ptr;
2335
    const uint8_t *unescaped_buf_ptr;
2336
    int hshift, vshift;
2337
    int unescaped_buf_size;
2338
    int start_code;
2339
    int i, index;
2340
2515
    int ret = 0;
2341
    int is16bit;
2342
2343
2515
    s->buf_size = buf_size;
2344
2345
2515
    av_dict_free(&s->exif_metadata);
2346
2515
    av_freep(&s->stereo3d);
2347
2515
    s->adobe_transform = -1;
2348
2349
2515
    if (s->iccnum != 0)
2350
        reset_icc_profile(s);
2351
2352
2515
    buf_ptr = buf;
2353
2515
    buf_end = buf + buf_size;
2354
15540
    while (buf_ptr < buf_end) {
2355
        /* find start next marker */
2356
15540
        start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,
2357
                                          &unescaped_buf_ptr,
2358
                                          &unescaped_buf_size);
2359
        /* EOF */
2360
15540
        if (start_code < 0) {
2361
5
            break;
2362
15535
        } else if (unescaped_buf_size > INT_MAX / 8) {
2363
            av_log(avctx, AV_LOG_ERROR,
2364
                   "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
2365
                   start_code, unescaped_buf_size, buf_size);
2366
            return AVERROR_INVALIDDATA;
2367
        }
2368
15535
        av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%"PTRDIFF_SPECIFIER"\n",
2369
               start_code, buf_end - buf_ptr);
2370
2371
15535
        ret = init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);
2372
2373
15535
        if (ret < 0) {
2374
            av_log(avctx, AV_LOG_ERROR, "invalid buffer\n");
2375
            goto fail;
2376
        }
2377
2378
15535
        s->start_code = start_code;
2379
15535
        if (s->avctx->debug & FF_DEBUG_STARTCODE)
2380
            av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2381
2382
        /* process markers */
2383

15535
        if (start_code >= RST0 && start_code <= RST7) {
2384
2
            av_log(avctx, AV_LOG_DEBUG,
2385
                   "restart marker: %d\n", start_code & 0x0f);
2386
            /* APP fields */
2387

15533
        } else if (start_code >= APP0 && start_code <= APP15) {
2388
140
            if ((ret = mjpeg_decode_app(s)) < 0)
2389
                av_log(avctx, AV_LOG_ERROR, "unable to decode APP fields: %s\n",
2390
                       av_err2str(ret));
2391
            /* Comment */
2392
15393
        } else if (start_code == COM) {
2393
209
            ret = mjpeg_decode_com(s);
2394
209
            if (ret < 0)
2395
                return ret;
2396
15184
        } else if (start_code == DQT) {
2397
2486
            ret = ff_mjpeg_decode_dqt(s);
2398
2486
            if (ret < 0)
2399
                return ret;
2400
        }
2401
2402
15535
        ret = -1;
2403
2404
        if (!CONFIG_JPEGLS_DECODER &&
2405
            (start_code == SOF48 || start_code == LSE)) {
2406
            av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");
2407
            return AVERROR(ENOSYS);
2408
        }
2409
2410
15535
        if (avctx->skip_frame == AVDISCARD_ALL) {
2411
461
            switch(start_code) {
2412
224
            case SOF0:
2413
            case SOF1:
2414
            case SOF2:
2415
            case SOF3:
2416
            case SOF48:
2417
            case SOI:
2418
            case SOS:
2419
            case EOI:
2420
224
                break;
2421
237
            default:
2422
237
                goto skip;
2423
            }
2424
15074
        }
2425
2426



15298
        switch (start_code) {
2427
2518
        case SOI:
2428
2518
            s->restart_interval = 0;
2429
2518
            s->restart_count    = 0;
2430
2518
            s->raw_image_buffer      = buf_ptr;
2431
2518
            s->raw_image_buffer_size = buf_end - buf_ptr;
2432
            /* nothing to do on SOI */
2433
2518
            break;
2434
2508
        case DHT:
2435
2508
            if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
2436
                av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2437
                goto fail;
2438
            }
2439
2508
            break;
2440
2108
        case SOF0:
2441
        case SOF1:
2442
2108
            if (start_code == SOF0)
2443
2106
                s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT;
2444
            else
2445
2
                s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT;
2446
2108
            s->lossless    = 0;
2447
2108
            s->ls          = 0;
2448
2108
            s->progressive = 0;
2449
2108
            if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2450
                goto fail;
2451
2108
            break;
2452
        case SOF2:
2453
            s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT;
2454
            s->lossless    = 0;
2455
            s->ls          = 0;
2456
            s->progressive = 1;
2457
            if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2458
                goto fail;
2459
            break;
2460
205
        case SOF3:
2461
205
            s->avctx->profile     = FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS;
2462
205
            s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2463
205
            s->lossless    = 1;
2464
205
            s->ls          = 0;
2465
205
            s->progressive = 0;
2466
205
            if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2467
                goto fail;
2468
205
            break;
2469
205
        case SOF48:
2470
205
            s->avctx->profile     = FF_PROFILE_MJPEG_JPEG_LS;
2471
205
            s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2472
205
            s->lossless    = 1;
2473
205
            s->ls          = 1;
2474
205
            s->progressive = 0;
2475
205
            if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2476
                goto fail;
2477
205
            break;
2478
        case LSE:
2479
            if (!CONFIG_JPEGLS_DECODER ||
2480
                (ret = ff_jpegls_decode_lse(s)) < 0)
2481
                goto fail;
2482
            break;
2483
        case EOI:
2484
2518
eoi_parser:
2485

2518
            if (!avctx->hwaccel && avctx->skip_frame != AVDISCARD_ALL &&
2486

2461
                s->progressive && s->cur_scan && s->got_picture)
2487
                mjpeg_idct_scan_progressive_ac(s);
2488
2518
            s->cur_scan = 0;
2489
2518
            if (!s->got_picture) {
2490
                av_log(avctx, AV_LOG_WARNING,
2491
                       "Found EOI before any SOF, ignoring\n");
2492
                break;
2493
            }
2494
2518
            if (s->interlaced) {
2495
8
                s->bottom_field ^= 1;
2496
                /* if not bottom field, do not output image yet */
2497
8
                if (s->bottom_field == !s->interlace_polarity)
2498
4
                    break;
2499
            }
2500
2514
            if (avctx->skip_frame == AVDISCARD_ALL) {
2501
56
                s->got_picture = 0;
2502
56
                goto the_end_no_picture;
2503
            }
2504
2458
            if (s->avctx->hwaccel) {
2505
                ret = s->avctx->hwaccel->end_frame(s->avctx);
2506
                if (ret < 0)
2507
                    return ret;
2508
2509
                av_freep(&s->hwaccel_picture_private);
2510
            }
2511
2458
            if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
2512
                return ret;
2513
2458
            *got_frame = 1;
2514
2458
            s->got_picture = 0;
2515
2516
2458
            if (!s->lossless) {
2517
2053
                int qp = FFMAX3(s->qscale[0],
2518
                                s->qscale[1],
2519
                                s->qscale[2]);
2520
2053
                int qpw = (s->width + 15) / 16;
2521
2053
                AVBufferRef *qp_table_buf = av_buffer_alloc(qpw);
2522
2053
                if (qp_table_buf) {
2523
2053
                    memset(qp_table_buf->data, qp, qpw);
2524
2053
                    av_frame_set_qp_table(data, qp_table_buf, 0, FF_QSCALE_TYPE_MPEG1);
2525
                }
2526
2527
2053
                if(avctx->debug & FF_DEBUG_QP)
2528
                    av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);
2529
            }
2530
2531
2458
            goto the_end;
2532
2518
        case SOS:
2533
2518
            s->raw_scan_buffer      = buf_ptr;
2534
2518
            s->raw_scan_buffer_size = buf_end - buf_ptr;
2535
2536
2518
            s->cur_scan++;
2537
2518
            if (avctx->skip_frame == AVDISCARD_ALL) {
2538
57
                skip_bits(&s->gb, get_bits_left(&s->gb));
2539
57
                break;
2540
            }
2541
2542
2461
            if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&
2543
                (avctx->err_recognition & AV_EF_EXPLODE))
2544
                goto fail;
2545
2461
            break;
2546
6
        case DRI:
2547
6
            if ((ret = mjpeg_decode_dri(s)) < 0)
2548
                return ret;
2549
6
            break;
2550
        case SOF5:
2551
        case SOF6:
2552
        case SOF7:
2553
        case SOF9:
2554
        case SOF10:
2555
        case SOF11:
2556
        case SOF13:
2557
        case SOF14:
2558
        case SOF15:
2559
        case JPG:
2560
            av_log(avctx, AV_LOG_ERROR,
2561
                   "mjpeg: unsupported coding type (%x)\n", start_code);
2562
            break;
2563
        }
2564
2565
13025
skip:
2566
        /* eof process start code */
2567
13025
        buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
2568
26050
        av_log(avctx, AV_LOG_DEBUG,
2569
               "marker parser used %d bytes (%d bits)\n",
2570
13025
               (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
2571
    }
2572

5
    if (s->got_picture && s->cur_scan) {
2573
4
        av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
2574
4
        goto eoi_parser;
2575
    }
2576
1
    av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
2577
1
    return AVERROR_INVALIDDATA;
2578
fail:
2579
    s->got_picture = 0;
2580
    return ret;
2581
2458
the_end:
2582
2583
2458
    is16bit = av_pix_fmt_desc_get(s->avctx->pix_fmt)->comp[0].step > 1;
2584
2585
2458
    if (AV_RB32(s->upscale_h)) {
2586
        int p;
2587
        av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2588
                   avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||
2589
                   avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2590
                   avctx->pix_fmt == AV_PIX_FMT_YUV440P  ||
2591
                   avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2592
                   avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2593
                   avctx->pix_fmt == AV_PIX_FMT_YUV420P  ||
2594
                   avctx->pix_fmt == AV_PIX_FMT_YUV420P16||
2595
                   avctx->pix_fmt == AV_PIX_FMT_YUVA420P  ||
2596
                   avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2597
                   avctx->pix_fmt == AV_PIX_FMT_GBRP     ||
2598
                   avctx->pix_fmt == AV_PIX_FMT_GBRAP
2599
                  );
2600
        ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2601
        if (ret)
2602
            return ret;
2603
2604
        av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2605
        for (p = 0; p<s->nb_components; p++) {
2606
            uint8_t *line = s->picture_ptr->data[p];
2607
            int w = s->width;
2608
            int h = s->height;
2609
            if (!s->upscale_h[p])
2610
                continue;
2611
            if (p==1 || p==2) {
2612
                w = AV_CEIL_RSHIFT(w, hshift);
2613
                h = AV_CEIL_RSHIFT(h, vshift);
2614
            }
2615
            if (s->upscale_v[p] == 1)
2616
                h = (h+1)>>1;
2617
            av_assert0(w > 0);
2618
            for (i = 0; i < h; i++) {
2619
                if (s->upscale_h[p] == 1) {
2620
                    if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];
2621
                    else                      line[w - 1] = line[(w - 1) / 2];
2622
                    for (index = w - 2; index > 0; index--) {
2623
                        if (is16bit)
2624
                            ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;
2625
                        else
2626
                            line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
2627
                    }
2628
                } else if (s->upscale_h[p] == 2) {
2629
                    if (is16bit) {
2630
                        ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3];
2631
                        if (w > 1)
2632
                            ((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1];
2633
                    } else {
2634
                        line[w - 1] = line[(w - 1) / 3];
2635
                        if (w > 1)
2636
                            line[w - 2] = line[w - 1];
2637
                    }
2638
                    for (index = w - 3; index > 0; index--) {
2639
                        line[index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3;
2640
                    }
2641
                }
2642
                line += s->linesize[p];
2643
            }
2644
        }
2645
    }
2646
2458
    if (AV_RB32(s->upscale_v)) {
2647
        int p;
2648
        av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2649
                   avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||
2650
                   avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2651
                   avctx->pix_fmt == AV_PIX_FMT_YUV422P  ||
2652
                   avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2653
                   avctx->pix_fmt == AV_PIX_FMT_YUV420P  ||
2654
                   avctx->pix_fmt == AV_PIX_FMT_YUV440P  ||
2655
                   avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2656
                   avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2657
                   avctx->pix_fmt == AV_PIX_FMT_YUVA420P  ||
2658
                   avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2659
                   avctx->pix_fmt == AV_PIX_FMT_GBRP     ||
2660
                   avctx->pix_fmt == AV_PIX_FMT_GBRAP
2661
                   );
2662
        ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2663
        if (ret)
2664
            return ret;
2665
2666
        av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2667
        for (p = 0; p < s->nb_components; p++) {
2668
            uint8_t *dst;
2669
            int w = s->width;
2670
            int h = s->height;
2671
            if (!s->upscale_v[p])
2672
                continue;
2673
            if (p==1 || p==2) {
2674
                w = AV_CEIL_RSHIFT(w, hshift);
2675
                h = AV_CEIL_RSHIFT(h, vshift);
2676
            }
2677
            dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];
2678
            for (i = h - 1; i; i--) {
2679
                uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2680
                uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2681
                if (s->upscale_v[p] != 2 && (src1 == src2 || i == h - 1)) {
2682
                    memcpy(dst, src1, w);
2683
                } else {
2684
                    for (index = 0; index < w; index++)
2685
                        dst[index] = (src1[index] + src2[index]) >> 1;
2686
                }
2687
                dst -= s->linesize[p];
2688
            }
2689
        }
2690
    }
2691

2458
    if (s->flipped && !s->rgb) {
2692
        int j;
2693
367
        ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2694
367
        if (ret)
2695
            return ret;
2696
2697
367
        av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2698
1468
        for (index=0; index<s->nb_components; index++) {
2699
1101
            uint8_t *dst = s->picture_ptr->data[index];
2700
1101
            int w = s->picture_ptr->width;
2701
1101
            int h = s->picture_ptr->height;
2702

1101
            if(index && index<3){
2703
734
                w = AV_CEIL_RSHIFT(w, hshift);
2704
734
                h = AV_CEIL_RSHIFT(h, vshift);
2705
            }
2706
1101
            if(dst){
2707
1101
                uint8_t *dst2 = dst + s->picture_ptr->linesize[index]*(h-1);
2708
66408
                for (i=0; i<h/2; i++) {
2709
14088753
                    for (j=0; j<w; j++)
2710
14023446
                        FFSWAP(int, dst[j], dst2[j]);
2711
65307
                    dst  += s->picture_ptr->linesize[index];
2712
65307
                    dst2 -= s->picture_ptr->linesize[index];
2713
                }
2714
            }
2715
        }
2716
    }
2717

2458
    if (s->adobe_transform == 0 && s->avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
2718
        int w = s->picture_ptr->width;
2719
        int h = s->picture_ptr->height;
2720
        av_assert0(s->nb_components == 4);
2721
        for (i=0; i<h; i++) {
2722
            int j;
2723
            uint8_t *dst[4];
2724
            for (index=0; index<4; index++) {
2725
                dst[index] =   s->picture_ptr->data[index]
2726
                             + s->picture_ptr->linesize[index]*i;
2727
            }
2728
            for (j=0; j<w; j++) {
2729
                int k = dst[3][j];
2730
                int r = dst[0][j] * k;
2731
                int g = dst[1][j] * k;
2732
                int b = dst[2][j] * k;
2733
                dst[0][j] = g*257 >> 16;
2734
                dst[1][j] = b*257 >> 16;
2735
                dst[2][j] = r*257 >> 16;
2736
                dst[3][j] = 255;
2737
            }
2738
        }
2739
    }
2740

2458
    if (s->adobe_transform == 2 && s->avctx->pix_fmt == AV_PIX_FMT_YUVA444P) {
2741
        int w = s->picture_ptr->width;
2742
        int h = s->picture_ptr->height;
2743
        av_assert0(s->nb_components == 4);
2744
        for (i=0; i<h; i++) {
2745
            int j;
2746
            uint8_t *dst[4];
2747
            for (index=0; index<4; index++) {
2748
                dst[index] =   s->picture_ptr->data[index]
2749
                             + s->picture_ptr->linesize[index]*i;
2750
            }
2751
            for (j=0; j<w; j++) {
2752
                int k = dst[3][j];
2753
                int r = (255 - dst[0][j]) * k;
2754
                int g = (128 - dst[1][j]) * k;
2755
                int b = (128 - dst[2][j]) * k;
2756
                dst[0][j] = r*257 >> 16;
2757
                dst[1][j] = (g*257 >> 16) + 128;
2758
                dst[2][j] = (b*257 >> 16) + 128;
2759
                dst[3][j] = 255;
2760
            }
2761
        }
2762
    }
2763
2764
2458
    if (s->stereo3d) {
2765
        AVStereo3D *stereo = av_stereo3d_create_side_data(data);
2766
        if (stereo) {
2767
            stereo->type  = s->stereo3d->type;
2768
            stereo->flags = s->stereo3d->flags;
2769
        }
2770
        av_freep(&s->stereo3d);
2771
    }
2772
2773

2458
    if (s->iccnum != 0 && s->iccnum == s->iccread) {
2774
        AVFrameSideData *sd;
2775
        size_t offset = 0;
2776
        int total_size = 0;
2777
        int i;
2778
2779
        /* Sum size of all parts. */
2780
        for (i = 0; i < s->iccnum; i++)
2781
            total_size += s->iccdatalens[i];
2782
2783
        sd = av_frame_new_side_data(data, AV_FRAME_DATA_ICC_PROFILE, total_size);
2784
        if (!sd) {
2785
            av_log(s->avctx, AV_LOG_ERROR, "Could not allocate frame side data\n");
2786
            return AVERROR(ENOMEM);
2787
        }
2788
2789
        /* Reassemble the parts, which are now in-order. */
2790
        for (i = 0; i < s->iccnum; i++) {
2791
            memcpy(sd->data + offset, s->iccdata[i], s->iccdatalens[i]);
2792
            offset += s->iccdatalens[i];
2793
        }
2794
    }
2795
2796
2458
    av_dict_copy(&((AVFrame *) data)->metadata, s->exif_metadata, 0);
2797
2458
    av_dict_free(&s->exif_metadata);
2798
2799
2514
the_end_no_picture:
2800
2514
    av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n",
2801
           buf_end - buf_ptr);
2802
//  return buf_end - buf_ptr;
2803
2514
    return buf_ptr - buf;
2804
}
2805
2806
140
av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
2807
{
2808
140
    MJpegDecodeContext *s = avctx->priv_data;
2809
    int i, j;
2810
2811


140
    if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_number) {
2812
        av_log(avctx, AV_LOG_INFO, "Single field\n");
2813
    }
2814
2815
140
    if (s->picture) {
2816
138
        av_frame_free(&s->picture);
2817
138
        s->picture_ptr = NULL;
2818
2
    } else if (s->picture_ptr)
2819
        av_frame_unref(s->picture_ptr);
2820
2821
140
    av_freep(&s->buffer);
2822
140
    av_freep(&s->stereo3d);
2823
140
    av_freep(&s->ljpeg_buffer);
2824
140
    s->ljpeg_buffer_size = 0;
2825
2826
560
    for (i = 0; i < 3; i++) {
2827
2100
        for (j = 0; j < 4; j++)
2828
1680
            ff_free_vlc(&s->vlcs[i][j]);
2829
    }
2830
700
    for (i = 0; i < MAX_COMPONENTS; i++) {
2831
560
        av_freep(&s->blocks[i]);
2832
560
        av_freep(&s->last_nnz[i]);
2833
    }
2834
140
    av_dict_free(&s->exif_metadata);
2835
2836
140
    reset_icc_profile(s);
2837
2838
140
    av_freep(&s->hwaccel_picture_private);
2839
2840
140
    return 0;
2841
}
2842
2843
static void decode_flush(AVCodecContext *avctx)
2844
{
2845
    MJpegDecodeContext *s = avctx->priv_data;
2846
    s->got_picture = 0;
2847
}
2848
2849
#if CONFIG_MJPEG_DECODER
2850
#define OFFSET(x) offsetof(MJpegDecodeContext, x)
2851
#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2852
static const AVOption options[] = {
2853
    { "extern_huff", "Use external huffman table.",
2854
      OFFSET(extern_huff), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
2855
    { NULL },
2856
};
2857
2858
static const AVClass mjpegdec_class = {
2859
    .class_name = "MJPEG decoder",
2860
    .item_name  = av_default_item_name,
2861
    .option     = options,
2862
    .version    = LIBAVUTIL_VERSION_INT,
2863
};
2864
2865
AVCodec ff_mjpeg_decoder = {
2866
    .name           = "mjpeg",
2867
    .long_name      = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
2868
    .type           = AVMEDIA_TYPE_VIDEO,
2869
    .id             = AV_CODEC_ID_MJPEG,
2870
    .priv_data_size = sizeof(MJpegDecodeContext),
2871
    .init           = ff_mjpeg_decode_init,
2872
    .close          = ff_mjpeg_decode_end,
2873
    .decode         = ff_mjpeg_decode_frame,
2874
    .flush          = decode_flush,
2875
    .capabilities   = AV_CODEC_CAP_DR1,
2876
    .max_lowres     = 3,
2877
    .priv_class     = &mjpegdec_class,
2878
    .profiles       = NULL_IF_CONFIG_SMALL(ff_mjpeg_profiles),
2879
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
2880
                      FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2881
    .hw_configs     = (const AVCodecHWConfigInternal*[]) {
2882
#if CONFIG_MJPEG_NVDEC_HWACCEL
2883
                        HWACCEL_NVDEC(mjpeg),
2884
#endif
2885
#if CONFIG_MJPEG_VAAPI_HWACCEL
2886
                        HWACCEL_VAAPI(mjpeg),
2887
#endif
2888
                        NULL
2889
                    },
2890
};
2891
#endif
2892
#if CONFIG_THP_DECODER
2893
AVCodec ff_thp_decoder = {
2894
    .name           = "thp",
2895
    .long_name      = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
2896
    .type           = AVMEDIA_TYPE_VIDEO,
2897
    .id             = AV_CODEC_ID_THP,
2898
    .priv_data_size = sizeof(MJpegDecodeContext),
2899
    .init           = ff_mjpeg_decode_init,
2900
    .close          = ff_mjpeg_decode_end,
2901
    .decode         = ff_mjpeg_decode_frame,
2902
    .flush          = decode_flush,
2903
    .capabilities   = AV_CODEC_CAP_DR1,
2904
    .max_lowres     = 3,
2905
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
2906
};
2907
#endif