GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/mjpegdec.c Lines: 846 1721 49.2 %
Date: 2019-11-18 18:00:01 Branches: 596 1579 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 "hwaccel.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
        switch (pix_fmt_id) {
503
        case 0x11110000: /* for bayer-encoded huffman lossless JPEGs embedded in DNGs */
504
            if (!s->bayer)
505
                goto unk_pixfmt;
506
            s->avctx->pix_fmt = AV_PIX_FMT_GRAY16LE;
507
            break;
508
412
        case 0x11111100:
509
412
            if (s->rgb)
510
205
                s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_BGR48;
511
            else {
512
207
                if (   s->adobe_transform == 0
513

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

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

223
            if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
601
                if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
602
                else
603
                    goto unk_pixfmt;
604
                s->upscale_h[0] = s->upscale_h[1] = 1;
605
            } else {
606

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

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

2527
        if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->avctx->lowres) {
660
            avpriv_report_missing_feature(s->avctx, "Lowres for weird subsampling");
661
            return AVERROR_PATCHWELCOME;
662
        }
663


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

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

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

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

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

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

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

3816050
            if (s->restart_interval && !s->restart_count){
1243
                s->restart_count = s->restart_interval;
1244
                resync_mb_x = mb_x;
1245
                resync_mb_y = mb_y;
1246
            }
1247
1248


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

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

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

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

109000
                                if(x==0 && leftcol){
1278
600
                                    pred= 1 << (bits - 1);
1279
                                }else{
1280
108400
                                    pred= ptr[-1];
1281
                                }
1282
                            }else{
1283

188000
                                if(x==0 && leftcol){
1284
89200
                                    pred= ptr[-linesize];
1285
                                }else{
1286


98800
                                    PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1287
                                }
1288
                            }
1289
1290

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


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

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

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

766835
            const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
1446
1447

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

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

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

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

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


7540
        if((nb_components == 1 || nb_components == 3) && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
1675
            index = (index+2)%3;
1676
1677
7540
        s->comp_index[i] = index;
1678
1679
7540
        s->dc_index[i] = get_bits(&s->gb, 4);
1680
7540
        s->ac_index[i] = get_bits(&s->gb, 4);
1681
1682

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

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


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

200
            if (s->rgb || s->bayer) {
1748
                if ((ret = ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform)) < 0)
1749
                    return ret;
1750
            } else {
1751
200
                if ((ret = ljpeg_decode_yuv_scan(s, predictor,
1752
                                                 point_transform,
1753
                                                 nb_components)) < 0)
1754
                    return ret;
1755
            }
1756
        }
1757
    } else {
1758

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

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

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

18
    if (id == AV_RL32("colr") && len > 0) {
1936
        s->colr = get_bits(&s->gb, 8);
1937
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1938
            av_log(s->avctx, AV_LOG_INFO, "COLR %d\n", s->colr);
1939
        len --;
1940
        goto out;
1941
    }
1942

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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



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

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

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

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

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

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

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

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

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


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