mjpegdec.c 104 KB
Newer Older
1 2
/*
 * MJPEG decoder
3
 * Copyright (c) 2000, 2001 Fabrice Bellard
4 5 6
 * Copyright (c) 2003 Alex Beregszaszi
 * Copyright (c) 2003-2004 Michael Niedermayer
 *
7 8 9 10
 * Support for external huffman table, various fixes (AVID workaround),
 * aspecting, new decode_frame mechanism and apple mjpeg-b support
 *                                  by Alex Beregszaszi
 *
11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
29
 * @file
30 31 32
 * MJPEG decoder.
 */

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 49 50
#include "tiff.h"
#include "exif.h"
#include "bytestream.h"
51 52


53 54 55
static int build_vlc(VLC *vlc, const uint8_t *bits_table,
                     const uint8_t *val_table, int nb_codes,
                     int use_static, int is_ac)
56
{
57
    uint8_t huff_size[256] = { 0 };
58 59 60
    uint16_t huff_code[256];
    uint16_t huff_sym[256];
    int i;
61

62
    av_assert0(nb_codes <= 256);
63

64
    ff_mjpeg_build_huffman_codes(huff_size, huff_code, bits_table, val_table);
65

66 67
    for (i = 0; i < 256; i++)
        huff_sym[i] = i + 16 * is_ac;
68

69 70
    if (is_ac)
        huff_sym[0] = 16 * 256;
71

72 73
    return ff_init_vlc_sparse(vlc, 9, nb_codes, huff_size, 1, 1,
                              huff_code, 2, 2, huff_sym, 2, 2, use_static);
74 75
}

76
static int init_default_huffman_tables(MJpegDecodeContext *s)
77
{
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106
    static const struct {
        int class;
        int index;
        const uint8_t *bits;
        const uint8_t *values;
        int codes;
        int length;
    } ht[] = {
        { 0, 0, avpriv_mjpeg_bits_dc_luminance,
                avpriv_mjpeg_val_dc, 12, 12 },
        { 0, 1, avpriv_mjpeg_bits_dc_chrominance,
                avpriv_mjpeg_val_dc, 12, 12 },
        { 1, 0, avpriv_mjpeg_bits_ac_luminance,
                avpriv_mjpeg_val_ac_luminance,   251, 162 },
        { 1, 1, avpriv_mjpeg_bits_ac_chrominance,
                avpriv_mjpeg_val_ac_chrominance, 251, 162 },
        { 2, 0, avpriv_mjpeg_bits_ac_luminance,
                avpriv_mjpeg_val_ac_luminance,   251, 162 },
        { 2, 1, avpriv_mjpeg_bits_ac_chrominance,
                avpriv_mjpeg_val_ac_chrominance, 251, 162 },
    };
    int i, ret;

    for (i = 0; i < FF_ARRAY_ELEMS(ht); i++) {
        ret = build_vlc(&s->vlcs[ht[i].class][ht[i].index],
                        ht[i].bits, ht[i].values, ht[i].codes,
                        0, ht[i].class == 1);
        if (ret < 0)
            return ret;
107

108 109 110 111 112 113 114
        if (ht[i].class < 2) {
            memcpy(s->raw_huffman_lengths[ht[i].class][ht[i].index],
                   ht[i].bits + 1, 16);
            memcpy(s->raw_huffman_values[ht[i].class][ht[i].index],
                   ht[i].values, ht[i].length);
        }
    }
115 116

    return 0;
117 118
}

119 120 121 122 123
static void parse_avid(MJpegDecodeContext *s, uint8_t *buf, int len)
{
    s->buggy_avid = 1;
    if (len > 14 && buf[12] == 1) /* 1 - NTSC */
        s->interlace_polarity = 1;
124 125
    if (len > 14 && buf[12] == 2) /* 2 - PAL */
        s->interlace_polarity = 0;
126 127
    if (s->avctx->debug & FF_DEBUG_PICT_INFO)
        av_log(s->avctx, AV_LOG_INFO, "AVID: len:%d %d\n", len, len > 14 ? buf[12] : -1);
128 129
}

130 131 132 133 134 135 136 137 138
static void init_idct(AVCodecContext *avctx)
{
    MJpegDecodeContext *s = avctx->priv_data;

    ff_idctdsp_init(&s->idsp, avctx);
    ff_init_scantable(s->idsp.idct_permutation, &s->scantable,
                      ff_zigzag_direct);
}

139
av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)
140 141
{
    MJpegDecodeContext *s = avctx->priv_data;
142
    int ret;
143

144 145 146 147 148 149
    if (!s->picture_ptr) {
        s->picture = av_frame_alloc();
        if (!s->picture)
            return AVERROR(ENOMEM);
        s->picture_ptr = s->picture;
    }
150

151
    s->avctx = avctx;
152
    ff_blockdsp_init(&s->bdsp, avctx);
153
    ff_hpeldsp_init(&s->hdsp, avctx->flags);
154
    init_idct(avctx);
155 156 157
    s->buffer_size   = 0;
    s->buffer        = NULL;
    s->start_code    = -1;
158
    s->first_picture = 1;
159
    s->got_picture   = 0;
160
    s->org_height    = avctx->coded_height;
161
    avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
162
    avctx->colorspace = AVCOL_SPC_BT470BG;
163
    s->hwaccel_pix_fmt = s->hwaccel_sw_pix_fmt = AV_PIX_FMT_NONE;
164

165
    if ((ret = init_default_huffman_tables(s)) < 0)
166
        return ret;
167

168
    if (s->extern_huff) {
169
        av_log(avctx, AV_LOG_INFO, "using external huffman table\n");
170 171
        if ((ret = init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8)) < 0)
            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
    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 182 183
    } else if (avctx->field_order == AV_FIELD_UNKNOWN) {
        if (avctx->codec_tag == AV_RL32("MJPG"))
            s->interlace_polarity = 1;
184
    }
185 186 187 188 189 190 191

    if (   avctx->extradata_size > 8
        && AV_RL32(avctx->extradata) == 0x2C
        && AV_RL32(avctx->extradata+4) == 0x18) {
        parse_avid(s, avctx->extradata, avctx->extradata_size);
    }

192
    if (avctx->codec->id == AV_CODEC_ID_AMV)
193
        s->flipped = 1;
194 195 196 197 198 199

    return 0;
}


/* quantize tables */
200
int ff_mjpeg_decode_dqt(MJpegDecodeContext *s)
201
{
202
    int len, index, i;
203 204 205

    len = get_bits(&s->gb, 16) - 2;

206 207 208 209 210
    if (8*len > get_bits_left(&s->gb)) {
        av_log(s->avctx, AV_LOG_ERROR, "dqt: len %d is too large\n", len);
        return AVERROR_INVALIDDATA;
    }

211
    while (len >= 65) {
212 213 214 215
        int pr = get_bits(&s->gb, 4);
        if (pr > 1) {
            av_log(s->avctx, AV_LOG_ERROR, "dqt: invalid precision\n");
            return AVERROR_INVALIDDATA;
216 217 218 219 220 221
        }
        index = get_bits(&s->gb, 4);
        if (index >= 4)
            return -1;
        av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index);
        /* read quant table */
222
        for (i = 0; i < 64; i++) {
223
            s->quant_matrixes[index][i] = get_bits(&s->gb, pr ? 16 : 8);
224 225 226 227
            if (s->quant_matrixes[index][i] == 0) {
                av_log(s->avctx, AV_LOG_ERROR, "dqt: 0 quant value\n");
                return AVERROR_INVALIDDATA;
            }
228 229
        }

230
        // XXX FIXME fine-tune, and perhaps add dc too
231 232
        s->qscale[index] = FFMAX(s->quant_matrixes[index][1],
                                 s->quant_matrixes[index][8]) >> 1;
233 234
        av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n",
               index, s->qscale[index]);
235
        len -= 1 + 64 * (1+pr);
236 237 238 239 240
    }
    return 0;
}

/* decode huffman tables and build VLC decoders */
241
int ff_mjpeg_decode_dht(MJpegDecodeContext *s)
242 243 244 245
{
    int len, index, i, class, n, v, code_max;
    uint8_t bits_table[17];
    uint8_t val_table[256];
246
    int ret = 0;
247 248 249

    len = get_bits(&s->gb, 16) - 2;

250 251 252 253 254
    if (8*len > get_bits_left(&s->gb)) {
        av_log(s->avctx, AV_LOG_ERROR, "dht: len %d is too large\n", len);
        return AVERROR_INVALIDDATA;
    }

255 256
    while (len > 0) {
        if (len < 17)
257
            return AVERROR_INVALIDDATA;
258 259
        class = get_bits(&s->gb, 4);
        if (class >= 2)
260
            return AVERROR_INVALIDDATA;
261 262
        index = get_bits(&s->gb, 4);
        if (index >= 4)
263
            return AVERROR_INVALIDDATA;
264
        n = 0;
265
        for (i = 1; i <= 16; i++) {
266 267 268 269 270
            bits_table[i] = get_bits(&s->gb, 8);
            n += bits_table[i];
        }
        len -= 17;
        if (len < n || n > 256)
271
            return AVERROR_INVALIDDATA;
272 273

        code_max = 0;
274
        for (i = 0; i < n; i++) {
275 276 277 278 279 280 281 282
            v = get_bits(&s->gb, 8);
            if (v > code_max)
                code_max = v;
            val_table[i] = v;
        }
        len -= n;

        /* build VLC and flush previous vlc if present */
283
        ff_free_vlc(&s->vlcs[class][index]);
284 285
        av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
               class, index, code_max + 1);
286 287 288
        if ((ret = build_vlc(&s->vlcs[class][index], bits_table, val_table,
                             code_max + 1, 0, class > 0)) < 0)
            return ret;
289

290
        if (class > 0) {
291
            ff_free_vlc(&s->vlcs[2][index]);
292 293 294
            if ((ret = build_vlc(&s->vlcs[2][index], bits_table, val_table,
                                 code_max + 1, 0, 0)) < 0)
                return ret;
295
        }
296 297 298 299 300

        for (i = 0; i < 16; i++)
            s->raw_huffman_lengths[class][index][i] = bits_table[i + 1];
        for (i = 0; i < 256; i++)
            s->raw_huffman_values[class][index][i] = val_table[i];
301 302 303 304
    }
    return 0;
}

305
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 310
    int h_count[MAX_COMPONENTS] = { 0 };
    int v_count[MAX_COMPONENTS] = { 0 };
311

312
    s->cur_scan = 0;
313 314
    memset(s->upscale_h, 0, sizeof(s->upscale_h));
    memset(s->upscale_v, 0, sizeof(s->upscale_v));
315

316
    len     = get_bits(&s->gb, 16);
317
    bits    = get_bits(&s->gb, 8);
318

319 320 321 322 323
    if (bits > 16 || bits < 1) {
        av_log(s->avctx, AV_LOG_ERROR, "bits %d is invalid\n", bits);
        return AVERROR_INVALIDDATA;
    }

324
    if (s->avctx->bits_per_raw_sample != bits) {
325
        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 327 328
        s->avctx->bits_per_raw_sample = bits;
        init_idct(s->avctx);
    }
329
    if (s->pegasus_rct)
330 331
        bits = 9;
    if (bits == 9 && !s->pegasus_rct)
332
        s->rct  = 1;    // FIXME ugly
333

334 335 336 337 338
    if(s->lossless && s->avctx->lowres){
        av_log(s->avctx, AV_LOG_ERROR, "lowres is not possible with lossless jpeg\n");
        return -1;
    }

339
    height = get_bits(&s->gb, 16);
340
    width  = get_bits(&s->gb, 16);
341

342 343
    // HACK for odd_height.mov
    if (s->interlaced && s->width == width && s->height == height + 1)
344 345 346
        height= s->height;

    av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
347
    if (av_image_check_size(width, height, 0, s->avctx) < 0)
348
        return AVERROR_INVALIDDATA;
349 350
    if (s->buf_size && (width + 7) / 8 * ((height + 7) / 8) > s->buf_size * 4LL)
        return AVERROR_INVALIDDATA;
351 352 353 354 355

    nb_components = get_bits(&s->gb, 8);
    if (nb_components <= 0 ||
        nb_components > MAX_COMPONENTS)
        return -1;
356 357
    if (s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
        if (nb_components != s->nb_components) {
358 359
            av_log(s->avctx, AV_LOG_ERROR,
                   "nb_components changing in interlaced picture\n");
360 361 362
            return AVERROR_INVALIDDATA;
        }
    }
363
    if (s->ls && !(bits <= 8 || nb_components == 1)) {
364 365 366
        avpriv_report_missing_feature(s->avctx,
                                      "JPEG-LS that is not <= 8 "
                                      "bits/component or 16-bit gray");
367
        return AVERROR_PATCHWELCOME;
368
    }
369 370 371 372 373
    if (len != 8 + 3 * nb_components) {
        av_log(s->avctx, AV_LOG_ERROR, "decode_sof0: error, len(%d) mismatch %d components\n", len, nb_components);
        return AVERROR_INVALIDDATA;
    }

374
    s->nb_components = nb_components;
375 376 377
    s->h_max         = 1;
    s->v_max         = 1;
    for (i = 0; i < nb_components; i++) {
378 379
        /* component id */
        s->component_id[i] = get_bits(&s->gb, 8) - 1;
380 381
        h_count[i]         = get_bits(&s->gb, 4);
        v_count[i]         = get_bits(&s->gb, 4);
382
        /* compute hmax and vmax (only used in interleaved case) */
383 384 385 386
        if (h_count[i] > s->h_max)
            s->h_max = h_count[i];
        if (v_count[i] > s->v_max)
            s->v_max = v_count[i];
387
        s->quant_index[i] = get_bits(&s->gb, 8);
388 389
        if (s->quant_index[i] >= 4) {
            av_log(s->avctx, AV_LOG_ERROR, "quant_index is invalid\n");
390
            return AVERROR_INVALIDDATA;
391
        }
392
        if (!h_count[i] || !v_count[i]) {
393 394
            av_log(s->avctx, AV_LOG_ERROR,
                   "Invalid sampling factor in component %d %d:%d\n",
395
                   i, h_count[i], v_count[i]);
396 397 398
            return AVERROR_INVALIDDATA;
        }

399
        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 404 405 406 407 408
    if (   nb_components == 4
        && s->component_id[0] == 'C' - 1
        && s->component_id[1] == 'M' - 1
        && s->component_id[2] == 'Y' - 1
        && s->component_id[3] == 'K' - 1)
        s->adobe_transform = 0;
409

410
    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 416 417 418 419 420 421 422 423 424 425
    if (s->bayer) {
        if (nb_components == 2) {
            /* Bayer images embedded in DNGs can contain 2 interleaved components and the
               width stored in their SOF3 markers is the width of each one.  We only output
               a single component, therefore we need to adjust the output image width.  We
               handle the deinterleaving (but not the debayering) in this file. */
            width *= 2;
        }
        /* They can also contain 1 component, which is double the width and half the height
            of the final image (rows are interleaved).  We don't handle the decoding in this
            file, but leave that to the TIFF/DNG decoder. */
426
    }
427 428

    /* if different size, realloc/alloc picture */
429 430 431
    if (width != s->width || height != s->height || bits != s->bits ||
        memcmp(s->h_count, h_count, sizeof(h_count))                ||
        memcmp(s->v_count, v_count, sizeof(v_count))) {
432
        size_change = 1;
433

434 435
        s->width      = width;
        s->height     = height;
436
        s->bits       = bits;
437 438
        memcpy(s->h_count, h_count, sizeof(h_count));
        memcpy(s->v_count, v_count, sizeof(v_count));
439
        s->interlaced = 0;
440
        s->got_picture = 0;
441 442

        /* test interlaced mode */
443
        if (s->first_picture   &&
444
            (s->multiscope != 2 || s->avctx->time_base.den >= 25 * s->avctx->time_base.num) &&
445 446
            s->org_height != 0 &&
            s->height < ((s->org_height * 3) / 4)) {
447 448
            s->interlaced                    = 1;
            s->bottom_field                  = s->interlace_polarity;
449
            s->picture_ptr->interlaced_frame = 1;
450
            s->picture_ptr->top_field_first  = !s->interlace_polarity;
451 452 453
            height *= 2;
        }

454 455 456
        ret = ff_set_dimensions(s->avctx, width, height);
        if (ret < 0)
            return ret;
457 458

        s->first_picture = 0;
459 460
    } else {
        size_change = 0;
461 462
    }

463
    if (s->got_picture && s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
464
        if (s->progressive) {
465
            avpriv_request_sample(s->avctx, "progressively coded interlaced picture");
466 467
            return AVERROR_INVALIDDATA;
        }
468
    } else {
469
        if (s->v_max == 1 && s->h_max == 1 && s->lossless==1 && (nb_components==3 || nb_components==4))
470 471 472
            s->rgb = 1;
        else if (!s->lossless)
            s->rgb = 0;
473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499
        /* XXX: not complete test ! */
        pix_fmt_id = ((unsigned)s->h_count[0] << 28) | (s->v_count[0] << 24) |
                     (s->h_count[1] << 20) | (s->v_count[1] << 16) |
                     (s->h_count[2] << 12) | (s->v_count[2] <<  8) |
                     (s->h_count[3] <<  4) |  s->v_count[3];
        av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);
        /* NOTE we do not allocate pictures large enough for the possible
         * padding of h/v_count being 4 */
        if (!(pix_fmt_id & 0xD0D0D0D0))
            pix_fmt_id -= (pix_fmt_id & 0xF0F0F0F0) >> 1;
        if (!(pix_fmt_id & 0x0D0D0D0D))
            pix_fmt_id -= (pix_fmt_id & 0x0F0F0F0F) >> 1;

        for (i = 0; i < 8; i++) {
            int j = 6 + (i&1) - (i&6);
            int is = (pix_fmt_id >> (4*i)) & 0xF;
            int js = (pix_fmt_id >> (4*j)) & 0xF;

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

            if (is == 1 && js == 2) {
                if (i & 1) s->upscale_h[j/2] = 1;
                else       s->upscale_v[j/2] = 1;
            }
500 501
        }

502
        switch (pix_fmt_id) {
503
        case 0x11110000: /* for bayer-encoded huffman lossless JPEGs embedded in DNGs */
504 505
            if (!s->bayer)
                goto unk_pixfmt;
506 507
            s->avctx->pix_fmt = AV_PIX_FMT_GRAY16LE;
            break;
508 509 510 511 512 513 514 515 516 517 518 519
        case 0x11111100:
            if (s->rgb)
                s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_BGR48;
            else {
                if (   s->adobe_transform == 0
                    || s->component_id[0] == 'R' - 1 && s->component_id[1] == 'G' - 1 && s->component_id[2] == 'B' - 1) {
                    s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_GBRP : AV_PIX_FMT_GBRP16;
                } else {
                    if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
                    else              s->avctx->pix_fmt = AV_PIX_FMT_YUV444P16;
                s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
                }
Michael Niedermayer's avatar
Michael Niedermayer committed
520
            }
521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537
            av_assert0(s->nb_components == 3);
            break;
        case 0x11111111:
            if (s->rgb)
                s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_ABGR : AV_PIX_FMT_RGBA64;
            else {
                if (s->adobe_transform == 0 && s->bits <= 8) {
                    s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;
                } else {
                    s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_YUVA444P : AV_PIX_FMT_YUVA444P16;
                    s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
                }
            }
            av_assert0(s->nb_components == 4);
            break;
        case 0x22111122:
        case 0x22111111:
538 539
            if (s->adobe_transform == 0 && s->bits <= 8) {
                s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;
540 541 542 543 544 545 546
                s->upscale_v[1] = s->upscale_v[2] = 1;
                s->upscale_h[1] = s->upscale_h[2] = 1;
            } else if (s->adobe_transform == 2 && s->bits <= 8) {
                s->avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
                s->upscale_v[1] = s->upscale_v[2] = 1;
                s->upscale_h[1] = s->upscale_h[2] = 1;
                s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
547
            } else {
548 549
                if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
                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 553 554 555 556 557 558 559 560 561 562 563
            av_assert0(s->nb_components == 4);
            break;
        case 0x12121100:
        case 0x22122100:
        case 0x21211100:
        case 0x22211200:
        case 0x22221100:
        case 0x22112200:
        case 0x11222200:
            if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
            else
                goto unk_pixfmt;
564
            s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
565 566 567 568 569 570 571 572 573 574 575 576
            break;
        case 0x11000000:
        case 0x13000000:
        case 0x14000000:
        case 0x31000000:
        case 0x33000000:
        case 0x34000000:
        case 0x41000000:
        case 0x43000000:
        case 0x44000000:
            if(s->bits <= 8)
                s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
577
            else
578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612
                s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
            break;
        case 0x12111100:
        case 0x14121200:
        case 0x14111100:
        case 0x22211100:
        case 0x22112100:
            if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
                if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
                else
                    goto unk_pixfmt;
                s->upscale_v[0] = s->upscale_v[1] = 1;
            } else {
                if (pix_fmt_id == 0x14111100)
                    s->upscale_v[1] = s->upscale_v[2] = 1;
                if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV440P : AV_PIX_FMT_YUVJ440P;
                else
                    goto unk_pixfmt;
                s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
            }
            break;
        case 0x21111100:
            if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
                if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
                else
                    goto unk_pixfmt;
                s->upscale_h[0] = s->upscale_h[1] = 1;
            } else {
                if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
                else              s->avctx->pix_fmt = AV_PIX_FMT_YUV422P16;
                s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
            }
            break;
        case 0x31111100:
            if (s->bits > 8)
613
                goto unk_pixfmt;
614 615 616 617 618 619 620
            s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
            s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
            s->upscale_h[1] = s->upscale_h[2] = 2;
            break;
        case 0x22121100:
        case 0x22111200:
            if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
621 622 623
            else
                goto unk_pixfmt;
            s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647
            break;
        case 0x22111100:
        case 0x23111100:
        case 0x42111100:
        case 0x24111100:
            if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUVJ420P;
            else              s->avctx->pix_fmt = AV_PIX_FMT_YUV420P16;
            s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
            if (pix_fmt_id == 0x42111100) {
                if (s->bits > 8)
                    goto unk_pixfmt;
                s->upscale_h[1] = s->upscale_h[2] = 1;
            } else if (pix_fmt_id == 0x24111100) {
                if (s->bits > 8)
                    goto unk_pixfmt;
                s->upscale_v[1] = s->upscale_v[2] = 1;
            } else if (pix_fmt_id == 0x23111100) {
                if (s->bits > 8)
                    goto unk_pixfmt;
                s->upscale_v[1] = s->upscale_v[2] = 2;
            }
            break;
        case 0x41111100:
            if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV411P : AV_PIX_FMT_YUVJ411P;
648 649 650
            else
                goto unk_pixfmt;
            s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
651 652 653 654 655 656 657
            break;
        default:
    unk_pixfmt:
            avpriv_report_missing_feature(s->avctx, "Pixel format 0x%x bits:%d", pix_fmt_id, s->bits);
            memset(s->upscale_h, 0, sizeof(s->upscale_h));
            memset(s->upscale_v, 0, sizeof(s->upscale_v));
            return AVERROR_PATCHWELCOME;
658
        }
659 660 661
        if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->avctx->lowres) {
            avpriv_report_missing_feature(s->avctx, "Lowres for weird subsampling");
            return AVERROR_PATCHWELCOME;
662
        }
663 664
        if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->progressive && s->avctx->pix_fmt == AV_PIX_FMT_GBRP) {
            avpriv_report_missing_feature(s->avctx, "progressive for weird subsampling");
665
            return AVERROR_PATCHWELCOME;
666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681
        }
        if (s->ls) {
            memset(s->upscale_h, 0, sizeof(s->upscale_h));
            memset(s->upscale_v, 0, sizeof(s->upscale_v));
            if (s->nb_components == 3) {
                s->avctx->pix_fmt = AV_PIX_FMT_RGB24;
            } else if (s->nb_components != 1) {
                av_log(s->avctx, AV_LOG_ERROR, "Unsupported number of components %d\n", s->nb_components);
                return AVERROR_PATCHWELCOME;
            } else if (s->palette_index && s->bits <= 8)
                s->avctx->pix_fmt = AV_PIX_FMT_PAL8;
            else if (s->bits <= 8)
                s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
            else
                s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
        }
682

683 684 685 686 687
        s->pix_desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
        if (!s->pix_desc) {
            av_log(s->avctx, AV_LOG_ERROR, "Could not get a pixel format descriptor.\n");
            return AVERROR_BUG;
        }
688

689 690 691 692
        if (s->avctx->pix_fmt == s->hwaccel_sw_pix_fmt && !size_change) {
            s->avctx->pix_fmt = s->hwaccel_pix_fmt;
        } else {
            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 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715
                s->avctx->pix_fmt,
                AV_PIX_FMT_NONE,
            };
            s->hwaccel_pix_fmt = ff_get_format(s->avctx, pix_fmts);
            if (s->hwaccel_pix_fmt < 0)
                return AVERROR(EINVAL);

            s->hwaccel_sw_pix_fmt = s->avctx->pix_fmt;
            s->avctx->pix_fmt     = s->hwaccel_pix_fmt;
        }

        if (s->avctx->skip_frame == AVDISCARD_ALL) {
            s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
            s->picture_ptr->key_frame = 1;
            s->got_picture            = 1;
            return 0;
        }
716

717 718 719
        av_frame_unref(s->picture_ptr);
        if (ff_get_buffer(s->avctx, s->picture_ptr, AV_GET_BUFFER_FLAG_REF) < 0)
            return -1;
720 721 722
        s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
        s->picture_ptr->key_frame = 1;
        s->got_picture            = 1;
723

724 725
        for (i = 0; i < 4; i++)
            s->linesize[i] = s->picture_ptr->linesize[i] << s->interlaced;
726

727 728 729
        ff_dlog(s->avctx, "%d %d %d %d %d %d\n",
                s->width, s->height, s->linesize[0], s->linesize[1],
                s->interlaced, s->avctx->height);
730

731
    }
732

733
    if ((s->rgb && !s->lossless && !s->ls) ||
734 735 736
        (!s->rgb && s->ls && s->nb_components > 1) ||
        (s->avctx->pix_fmt == AV_PIX_FMT_PAL8 && !s->ls)
    ) {
737 738 739 740
        av_log(s->avctx, AV_LOG_ERROR, "Unsupported coding and pixel format combination\n");
        return AVERROR_PATCHWELCOME;
    }

741
    /* totally blank picture as progressive JPEG will only add details to it */
742 743 744 745
    if (s->progressive) {
        int bw = (width  + s->h_max * 8 - 1) / (s->h_max * 8);
        int bh = (height + s->v_max * 8 - 1) / (s->v_max * 8);
        for (i = 0; i < s->nb_components; i++) {
Loren Merritt's avatar
Loren Merritt committed
746 747 748
            int size = bw * bh * s->h_count[i] * s->v_count[i];
            av_freep(&s->blocks[i]);
            av_freep(&s->last_nnz[i]);
749 750
            s->blocks[i]       = av_mallocz_array(size, sizeof(**s->blocks));
            s->last_nnz[i]     = av_mallocz_array(size, sizeof(**s->last_nnz));
751 752
            if (!s->blocks[i] || !s->last_nnz[i])
                return AVERROR(ENOMEM);
Loren Merritt's avatar
Loren Merritt committed
753 754 755
            s->block_stride[i] = bw * s->h_count[i];
        }
        memset(s->coefs_finished, 0, sizeof(s->coefs_finished));
756
    }
757 758 759 760 761 762 763 764 765 766 767 768 769

    if (s->avctx->hwaccel) {
        s->hwaccel_picture_private =
            av_mallocz(s->avctx->hwaccel->frame_priv_data_size);
        if (!s->hwaccel_picture_private)
            return AVERROR(ENOMEM);

        ret = s->avctx->hwaccel->start_frame(s->avctx, s->raw_image_buffer,
                                             s->raw_image_buffer_size);
        if (ret < 0)
            return ret;
    }

770 771 772 773 774 775 776
    return 0;
}

static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
{
    int code;
    code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
777
    if (code < 0 || code > 16) {
778 779 780
        av_log(s->avctx, AV_LOG_WARNING,
               "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
               0, dc_index, &s->vlcs[0][dc_index]);
781
        return 0xfffff;
782 783
    }

784
    if (code)
785 786 787 788 789 790
        return get_xbits(&s->gb, code);
    else
        return 0;
}

/* decode block and dequantize */
Diego Biurrun's avatar
Diego Biurrun committed
791
static int decode_block(MJpegDecodeContext *s, int16_t *block, int component,
792
                        int dc_index, int ac_index, uint16_t *quant_matrix)
793 794 795 796 797
{
    int code, i, j, level, val;

    /* DC coef */
    val = mjpeg_decode_dc(s, dc_index);
798
    if (val == 0xfffff) {
799
        av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
800
        return AVERROR_INVALIDDATA;
801
    }
802
    val = val * (unsigned)quant_matrix[0] + s->last_dc[component];
803
    val = av_clip_int16(val);
804 805 806 807
    s->last_dc[component] = val;
    block[0] = val;
    /* AC coefs */
    i = 0;
808
    {OPEN_READER(re, &s->gb);
809
    do {
810
        UPDATE_CACHE(re, &s->gb);
811
        GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2);
812 813 814

        i += ((unsigned)code) >> 4;
            code &= 0xf;
815 816
        if (code) {
            if (code > MIN_CACHE_BITS - 16)
817
                UPDATE_CACHE(re, &s->gb);
818

819
            {
820 821 822
                int cache = GET_CACHE(re, &s->gb);
                int sign  = (~cache) >> 31;
                level     = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
823 824
            }

825
            LAST_SKIP_BITS(re, &s->gb, code);
826

827
            if (i > 63) {
828
                av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
829
                return AVERROR_INVALIDDATA;
830
            }
831
            j        = s->scantable.permutated[i];
832
            block[j] = level * quant_matrix[i];
833
        }
834
    } while (i < 63);
835
    CLOSE_READER(re, &s->gb);}
836 837 838 839

    return 0;
}

Diego Biurrun's avatar
Diego Biurrun committed
840
static int decode_dc_progressive(MJpegDecodeContext *s, int16_t *block,
841
                                 int component, int dc_index,
842
                                 uint16_t *quant_matrix, int Al)
Loren Merritt's avatar
Loren Merritt committed
843
{
844
    unsigned val;
845
    s->bdsp.clear_block(block);
Loren Merritt's avatar
Loren Merritt committed
846
    val = mjpeg_decode_dc(s, dc_index);
847
    if (val == 0xfffff) {
Loren Merritt's avatar
Loren Merritt committed
848
        av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
849
        return AVERROR_INVALIDDATA;
Loren Merritt's avatar
Loren Merritt committed
850
    }
851
    val = (val * (quant_matrix[0] << Al)) + s->last_dc[component];
Loren Merritt's avatar
Loren Merritt committed
852 853 854 855 856
    s->last_dc[component] = val;
    block[0] = val;
    return 0;
}

857
/* decode block and dequantize - progressive JPEG version */
Diego Biurrun's avatar
Diego Biurrun committed
858
static int decode_block_progressive(MJpegDecodeContext *s, int16_t *block,
859
                                    uint8_t *last_nnz, int ac_index,
860
                                    uint16_t *quant_matrix,
Loren Merritt's avatar
Loren Merritt committed
861
                                    int ss, int se, int Al, int *EOBRUN)
862
{
863 864
    int code, i, j, val, run;
    unsigned level;
865

866
    if (*EOBRUN) {
867 868 869
        (*EOBRUN)--;
        return 0;
    }
870

871 872 873 874 875
    {
        OPEN_READER(re, &s->gb);
        for (i = ss; ; i++) {
            UPDATE_CACHE(re, &s->gb);
            GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
876

877 878 879 880 881 882
            run = ((unsigned) code) >> 4;
            code &= 0xF;
            if (code) {
                i += run;
                if (code > MIN_CACHE_BITS - 16)
                    UPDATE_CACHE(re, &s->gb);
883

884 885 886 887
                {
                    int cache = GET_CACHE(re, &s->gb);
                    int sign  = (~cache) >> 31;
                    level     = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
888
                }
889 890 891

                LAST_SKIP_BITS(re, &s->gb, code);

892
                if (i >= se) {
893 894
                    if (i == se) {
                        j = s->scantable.permutated[se];
895
                        block[j] = level * (quant_matrix[se] << Al);
896 897 898
                        break;
                    }
                    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 904 905 906 907
            } else {
                if (run == 0xF) {// ZRL - skip 15 coefficients
                    i += 15;
                    if (i >= se) {
                        av_log(s->avctx, AV_LOG_ERROR, "ZRL overflow: %d\n", i);
908
                        return AVERROR_INVALIDDATA;
909 910 911 912 913 914 915 916 917 918
                    }
                } else {
                    val = (1 << run);
                    if (run) {
                        UPDATE_CACHE(re, &s->gb);
                        val += NEG_USR32(GET_CACHE(re, &s->gb), run);
                        LAST_SKIP_BITS(re, &s->gb, run);
                    }
                    *EOBRUN = val - 1;
                    break;
919
                }
920 921
            }
        }
922
        CLOSE_READER(re, &s->gb);
923
    }
924 925

    if (i > *last_nnz)
Loren Merritt's avatar
Loren Merritt committed
926
        *last_nnz = i;
927

Loren Merritt's avatar
Loren Merritt committed
928 929 930
    return 0;
}

931 932 933 934
#define REFINE_BIT(j) {                                             \
    UPDATE_CACHE(re, &s->gb);                                       \
    sign = block[j] >> 15;                                          \
    block[j] += SHOW_UBITS(re, &s->gb, 1) *                         \
935
                ((quant_matrix[i] ^ sign) - sign) << Al;            \
936
    LAST_SKIP_BITS(re, &s->gb, 1);                                  \
Loren Merritt's avatar
Loren Merritt committed
937 938
}

939 940 941 942 943 944 945 946 947 948 949 950 951 952 953
#define ZERO_RUN                                                    \
for (; ; i++) {                                                     \
    if (i > last) {                                                 \
        i += run;                                                   \
        if (i > se) {                                               \
            av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \
            return -1;                                              \
        }                                                           \
        break;                                                      \
    }                                                               \
    j = s->scantable.permutated[i];                                 \
    if (block[j])                                                   \
        REFINE_BIT(j)                                               \
    else if (run-- == 0)                                            \
        break;                                                      \
Loren Merritt's avatar
Loren Merritt committed
954 955 956
}

/* decode block and dequantize - progressive JPEG refinement pass */
Diego Biurrun's avatar
Diego Biurrun committed
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)
Loren Merritt's avatar
Loren Merritt committed
961
{
962 963
    int code, i = ss, j, sign, val, run;
    int last    = FFMIN(se, *last_nnz);
Loren Merritt's avatar
Loren Merritt committed
964 965

    OPEN_READER(re, &s->gb);
966
    if (*EOBRUN) {
Loren Merritt's avatar
Loren Merritt committed
967
        (*EOBRUN)--;
968 969
    } else {
        for (; ; i++) {
Loren Merritt's avatar
Loren Merritt committed
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) {
Loren Merritt's avatar
Loren Merritt committed
974 975 976 977 978 979 980
                run = ((unsigned) code) >> 4;
                UPDATE_CACHE(re, &s->gb);
                val = SHOW_UBITS(re, &s->gb, 1);
                LAST_SKIP_BITS(re, &s->gb, 1);
                ZERO_RUN;
                j = s->scantable.permutated[i];
                val--;
981
                block[j] = ((quant_matrix[i] << Al) ^ val) - val;
982 983
                if (i == se) {
                    if (i > *last_nnz)
Loren Merritt's avatar
Loren Merritt committed
984
                        *last_nnz = i;
985
                    CLOSE_READER(re, &s->gb);
Loren Merritt's avatar
Loren Merritt committed
986 987
                    return 0;
                }
988
            } else {
Loren Merritt's avatar
Loren Merritt committed
989
                run = ((unsigned) code) >> 4;
990
                if (run == 0xF) {
Loren Merritt's avatar
Loren Merritt committed
991
                    ZERO_RUN;
992
                } else {
Loren Merritt's avatar
Loren Merritt committed
993 994
                    val = run;
                    run = (1 << run);
995
                    if (val) {
Loren Merritt's avatar
Loren Merritt committed
996 997 998 999 1000 1001 1002 1003 1004 1005
                        UPDATE_CACHE(re, &s->gb);
                        run += SHOW_UBITS(re, &s->gb, val);
                        LAST_SKIP_BITS(re, &s->gb, val);
                    }
                    *EOBRUN = run - 1;
                    break;
                }
            }
        }

1006
        if (i > *last_nnz)
Loren Merritt's avatar
Loren Merritt committed
1007 1008 1009
            *last_nnz = i;
    }

1010
    for (; i <= last; i++) {
Loren Merritt's avatar
Loren Merritt committed
1011
        j = s->scantable.permutated[i];
1012
        if (block[j])
Loren Merritt's avatar
Loren Merritt committed
1013 1014 1015
            REFINE_BIT(j)
    }
    CLOSE_READER(re, &s->gb);
1016 1017 1018

    return 0;
}
Loren Merritt's avatar
Loren Merritt committed
1019 1020
#undef REFINE_BIT
#undef ZERO_RUN
1021

1022
static int handle_rstn(MJpegDecodeContext *s, int nb_components)
1023 1024
{
    int i;
1025 1026
    int reset = 0;

1027 1028 1029 1030 1031
    if (s->restart_interval) {
        s->restart_count--;
        if(s->restart_count == 0 && s->avctx->codec_id == AV_CODEC_ID_THP){
            align_get_bits(&s->gb);
            for (i = 0; i < nb_components; i++) /* reset dc */
1032
                s->last_dc[i] = (4 << s->bits);
1033 1034 1035 1036
        }

        i = 8 + ((-get_bits_count(&s->gb)) & 7);
        /* skip RSTn */
1037
        if (s->restart_count == 0) {
1038 1039 1040 1041 1042 1043 1044 1045
            if(   show_bits(&s->gb, i) == (1 << i) - 1
               || show_bits(&s->gb, i) == 0xFF) {
                int pos = get_bits_count(&s->gb);
                align_get_bits(&s->gb);
                while (get_bits_left(&s->gb) >= 8 && show_bits(&s->gb, 8) == 0xFF)
                    skip_bits(&s->gb, 8);
                if (get_bits_left(&s->gb) >= 8 && (get_bits(&s->gb, 8) & 0xF8) == 0xD0) {
                    for (i = 0; i < nb_components; i++) /* reset dc */
1046
                        s->last_dc[i] = (4 << s->bits);
1047
                    reset = 1;
1048 1049 1050
                } else
                    skip_bits_long(&s->gb, pos - get_bits_count(&s->gb));
            }
1051 1052
        }
    }
1053
    return reset;
1054 1055
}

1056
/* Handles 1 to 4 components */
1057 1058
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int nb_components, int predictor, int point_transform)
{
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 1066
    int resync_mb_y = 0;
    int resync_mb_x = 0;
1067
    int vpred[6];
1068

1069 1070 1071 1072
    if (!s->bayer && s->nb_components < 3)
        return AVERROR_INVALIDDATA;
    if (s->bayer && s->nb_components > 2)
        return AVERROR_INVALIDDATA;
1073
    if (s->nb_components <= 0 || s->nb_components > 4)
1074 1075 1076 1077 1078
        return AVERROR_INVALIDDATA;
    if (s->v_max != 1 || s->h_max != 1 || !s->lossless)
        return AVERROR_INVALIDDATA;


1079 1080
    s->restart_count = s->restart_interval;

1081 1082 1083 1084 1085 1086 1087 1088 1089
    if (s->restart_interval == 0)
        s->restart_interval = INT_MAX;

    if (s->bayer)
        width = s->mb_width / nb_components; /* Interleaved, width stored is the total so need to divide */
    else
        width = s->mb_width;

    av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size, width * 4 * sizeof(s->ljpeg_buffer[0][0]));
1090 1091 1092
    if (!s->ljpeg_buffer)
        return AVERROR(ENOMEM);

1093
    buffer = s->ljpeg_buffer;
1094

1095
    for (i = 0; i < 4; i++)
1096 1097 1098
        buffer[0][i] = 1 << (s->bits - 1);

    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 1102 1103

        if (s->interlaced && s->bottom_field)
            ptr += linesize >> 1;

1104
        for (i = 0; i < 4; i++)
1105 1106
            top[i] = left[i] = topleft[i] = buffer[0][i];

1107 1108 1109 1110 1111 1112
        if ((mb_y * s->width) % s->restart_interval == 0) {
            for (i = 0; i < 6; i++)
                vpred[i] = 1 << (s->bits-1);
        }

        for (mb_x = 0; mb_x < width; mb_x++) {
1113 1114
            int modified_predictor = predictor;

1115 1116 1117 1118 1119
            if (get_bits_left(&s->gb) < 1) {
                av_log(s->avctx, AV_LOG_ERROR, "bitstream end in rgb_scan\n");
                return AVERROR_INVALIDDATA;
            }

1120
            if (s->restart_interval && !s->restart_count){
1121
                s->restart_count = s->restart_interval;
1122 1123
                resync_mb_x = mb_x;
                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 1134
                topleft[i] = top[i];
                top[i]     = buffer[mb_x][i];
1135

1136
                dc = mjpeg_decode_dc(s, s->dc_index[i]);
1137
                if(dc == 0xFFFFF)
1138 1139
                    return -1;

1140 1141 1142 1143 1144 1145 1146 1147 1148
                if (!s->bayer || mb_x) {
                    pred = left[i];
                } else { /* This path runs only for the first line in bayer images */
                    vpred[i] += dc;
                    pred = vpred[i] - dc;
                }

                PREDICT(pred, topleft[i], top[i], pred, modified_predictor);

1149
                left[i] = buffer[mb_x][i] =
1150
                    mask & (pred + (unsigned)(dc * (1 << point_transform)));
1151 1152 1153 1154 1155 1156 1157
            }

            if (s->restart_interval && !--s->restart_count) {
                align_get_bits(&s->gb);
                skip_bits(&s->gb, 16); /* skip RSTn */
            }
        }
1158 1159 1160 1161 1162 1163 1164 1165
        if (s->rct && s->nb_components == 4) {
            for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
                ptr[4*mb_x + 2] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
                ptr[4*mb_x + 1] = buffer[mb_x][1] + ptr[4*mb_x + 2];
                ptr[4*mb_x + 3] = buffer[mb_x][2] + ptr[4*mb_x + 2];
                ptr[4*mb_x + 0] = buffer[mb_x][3];
            }
        } else if (s->nb_components == 4) {
1166 1167
            for(i=0; i<nb_components; i++) {
                int c= s->comp_index[i];
1168 1169 1170 1171
                if (s->bits <= 8) {
                    for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
                        ptr[4*mb_x+3-c] = buffer[mb_x][i];
                    }
1172 1173
                } else if(s->bits == 9) {
                    return AVERROR_PATCHWELCOME;
1174 1175 1176 1177
                } else {
                    for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
                        ((uint16_t*)ptr)[4*mb_x+c] = buffer[mb_x][i];
                    }
1178 1179 1180
                }
            }
        } else if (s->rct) {
1181 1182 1183 1184
            for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
                ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
                ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
                ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1185
            }
1186 1187 1188 1189 1190
        } else if (s->pegasus_rct) {
            for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
                ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2]) >> 2);
                ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
                ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1191
            }
1192 1193 1194 1195 1196 1197 1198 1199 1200 1201
        } else if (s->bayer) {
            if (nb_components == 1) {
                /* Leave decoding to the TIFF/DNG decoder (see comment in ff_mjpeg_decode_sof) */
                for (mb_x = 0; mb_x < width; mb_x++)
                    ((uint16_t*)ptr)[mb_x] = buffer[mb_x][0];
            } else if (nb_components == 2) {
                for (mb_x = 0; mb_x < width; mb_x++) {
                    ((uint16_t*)ptr)[2*mb_x + 0] = buffer[mb_x][0];
                    ((uint16_t*)ptr)[2*mb_x + 1] = buffer[mb_x][1];
                }
1202
            }
1203 1204
        } else {
            for(i=0; i<nb_components; i++) {
1205
                int c= s->comp_index[i];
1206 1207 1208 1209
                if (s->bits <= 8) {
                    for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
                        ptr[3*mb_x+2-c] = buffer[mb_x][i];
                    }
1210 1211
                } else if(s->bits == 9) {
                    return AVERROR_PATCHWELCOME;
1212 1213 1214 1215
                } else {
                    for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
                        ((uint16_t*)ptr)[3*mb_x+2-c] = buffer[mb_x][i];
                    }
1216
                }
1217 1218 1219 1220 1221 1222
            }
        }
    }
    return 0;
}

1223
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
    int bits= (s->bits+7)&~7;
1228 1229
    int resync_mb_y = 0;
    int resync_mb_x = 0;
1230 1231

    point_transform += bits - s->bits;
1232
    mask = ((1 << s->bits) - 1) << point_transform;
1233

1234
    av_assert0(nb_components>=1 && nb_components<=4);
1235

1236 1237
    for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
        for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1238 1239 1240 1241
            if (get_bits_left(&s->gb) < 1) {
                av_log(s->avctx, AV_LOG_ERROR, "bitstream end in yuv_scan\n");
                return AVERROR_INVALIDDATA;
            }
1242
            if (s->restart_interval && !s->restart_count){
1243
                s->restart_count = s->restart_interval;
1244 1245 1246
                resync_mb_x = mb_x;
                resync_mb_y = mb_y;
            }
1247

1248 1249 1250
            if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->interlaced){
                int toprow  = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x;
                int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x;
1251
                for (i = 0; i < nb_components; i++) {
1252
                    uint8_t *ptr;
1253
                    uint16_t *ptr16;
1254 1255 1256 1257 1258 1259 1260 1261 1262
                    int n, h, v, x, y, c, j, linesize;
                    n = s->nb_blocks[i];
                    c = s->comp_index[i];
                    h = s->h_scount[i];
                    v = s->v_scount[i];
                    x = 0;
                    y = 0;
                    linesize= s->linesize[c];

1263 1264
                    if(bits>8) linesize /= 2;

1265
                    for(j=0; j<n; j++) {
1266
                        int pred, dc;
1267

1268
                        dc = mjpeg_decode_dc(s, s->dc_index[i]);
1269
                        if(dc == 0xFFFFF)
1270
                            return -1;
1271 1272 1273 1274
                        if (   h * mb_x + x >= s->width
                            || v * mb_y + y >= s->height) {
                            // Nothing to do
                        } else if (bits<=8) {
1275 1276 1277 1278 1279 1280 1281
                            ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
                            if(y==0 && toprow){
                                if(x==0 && leftcol){
                                    pred= 1 << (bits - 1);
                                }else{
                                    pred= ptr[-1];
                                }
1282
                            }else{
1283 1284 1285 1286 1287
                                if(x==0 && leftcol){
                                    pred= ptr[-linesize];
                                }else{
                                    PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
                                }
1288 1289
                            }

1290 1291 1292 1293
                            if (s->interlaced && s->bottom_field)
                                ptr += linesize >> 1;
                            pred &= mask;
                            *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 1297
                            if(y==0 && toprow){
                                if(x==0 && leftcol){
1298 1299 1300 1301 1302
                                    pred= 1 << (bits - 1);
                                }else{
                                    pred= ptr16[-1];
                                }
                            }else{
1303
                                if(x==0 && leftcol){
1304 1305 1306 1307 1308
                                    pred= ptr16[-linesize];
                                }else{
                                    PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
                                }
                            }
1309

1310 1311
                            if (s->interlaced && s->bottom_field)
                                ptr16 += linesize >> 1;
1312
                            pred &= mask;
1313
                            *ptr16= pred + ((unsigned)dc << point_transform);
1314
                        }
1315 1316 1317 1318 1319 1320
                        if (++x == h) {
                            x = 0;
                            y++;
                        }
                    }
                }
1321 1322
            } else {
                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 1327 1328 1329 1330 1331 1332
                    n        = s->nb_blocks[i];
                    c        = s->comp_index[i];
                    h        = s->h_scount[i];
                    v        = s->v_scount[i];
                    x        = 0;
                    y        = 0;
                    linesize = s->linesize[c];
1333

1334 1335
                    if(bits>8) linesize /= 2;

1336
                    for (j = 0; j < n; j++) {
1337 1338
                        int pred;

1339
                        dc = mjpeg_decode_dc(s, s->dc_index[i]);
1340
                        if(dc == 0xFFFFF)
1341
                            return -1;
1342 1343 1344 1345
                        if (   h * mb_x + x >= s->width
                            || v * mb_y + y >= s->height) {
                            // Nothing to do
                        } else if (bits<=8) {
1346
                            ptr = s->picture_ptr->data[c] +
1347 1348 1349
                              (linesize * (v * mb_y + y)) +
                              (h * mb_x + x); //FIXME optimize this crap
                            PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1350

1351
                            pred &= mask;
1352
                            *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 1356
                            PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);

1357
                            pred &= mask;
1358
                            *ptr16= pred + ((unsigned)dc << point_transform);
1359
                        }
1360

1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376
                        if (++x == h) {
                            x = 0;
                            y++;
                        }
                    }
                }
            }
            if (s->restart_interval && !--s->restart_count) {
                align_get_bits(&s->gb);
                skip_bits(&s->gb, 16); /* skip RSTn */
            }
        }
    }
    return 0;
}

1377 1378
static av_always_inline void mjpeg_copy_block(MJpegDecodeContext *s,
                                              uint8_t *dst, const uint8_t *src,
1379 1380 1381
                                              int linesize, int lowres)
{
    switch (lowres) {
1382
    case 0: s->hdsp.put_pixels_tab[1][0](dst, src, linesize, 8);
1383 1384 1385 1386 1387 1388 1389 1390 1391 1392
        break;
    case 1: copy_block4(dst, src, linesize, linesize, 4);
        break;
    case 2: copy_block2(dst, src, linesize, linesize, 2);
        break;
    case 3: *dst = *src;
        break;
    }
}

1393 1394 1395
static void shift_output(MJpegDecodeContext *s, uint8_t *ptr, int linesize)
{
    int block_x, block_y;
1396
    int size = 8 >> s->avctx->lowres;
1397
    if (s->bits > 8) {
1398 1399
        for (block_y=0; block_y<size; block_y++)
            for (block_x=0; block_x<size; block_x++)
1400 1401
                *(uint16_t*)(ptr + 2*block_x + block_y*linesize) <<= 16 - s->bits;
    } else {
1402 1403
        for (block_y=0; block_y<size; block_y++)
            for (block_x=0; block_x<size; block_x++)
1404 1405 1406 1407
                *(ptr + block_x + block_y*linesize) <<= 8 - s->bits;
    }
}

1408 1409
static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
                             int Al, const uint8_t *mb_bitmask,
1410
                             int mb_bitmask_size,
1411 1412
                             const AVFrame *reference)
{
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
    GetBitContext mb_bitmask_gb = {0}; // initialize to silence gcc warning
1418
    int bytes_per_pixel = 1 + (s->bits > 8);
1419

1420 1421 1422 1423 1424
    if (mb_bitmask) {
        if (mb_bitmask_size != (s->mb_width * s->mb_height + 7)>>3) {
            av_log(s->avctx, AV_LOG_ERROR, "mb_bitmask_size mismatches\n");
            return AVERROR_INVALIDDATA;
        }
1425
        init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
1426
    }
1427

1428
    s->restart_count = 0;
1429

1430 1431
    av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &chroma_h_shift,
                                     &chroma_v_shift);
1432 1433
    chroma_width  = AV_CEIL_RSHIFT(s->width,  chroma_h_shift);
    chroma_height = AV_CEIL_RSHIFT(s->height, chroma_v_shift);
1434

1435 1436
    for (i = 0; i < nb_components; i++) {
        int c   = s->comp_index[i];
1437
        data[c] = s->picture_ptr->data[c];
1438
        reference_data[c] = reference ? reference->data[c] : NULL;
1439
        linesize[c] = s->linesize[c];
Loren Merritt's avatar
Loren Merritt committed
1440
        s->coefs_finished[c] |= 1;
1441 1442
    }

1443 1444
    for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
        for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1445 1446
            const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);

1447 1448 1449
            if (s->restart_interval && !s->restart_count)
                s->restart_count = s->restart_interval;

1450
            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
            for (i = 0; i < nb_components; i++) {
1456 1457
                uint8_t *ptr;
                int n, h, v, x, y, c, j;
1458
                int block_offset;
1459 1460 1461 1462 1463 1464
                n = s->nb_blocks[i];
                c = s->comp_index[i];
                h = s->h_scount[i];
                v = s->v_scount[i];
                x = 0;
                y = 0;
1465
                for (j = 0; j < n; j++) {
Michael Niedermayer's avatar
Michael Niedermayer committed
1466
                    block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
1467
                                     (h * mb_x + x) * 8 * bytes_per_pixel) >> s->avctx->lowres);
1468

1469
                    if (s->interlaced && s->bottom_field)
1470
                        block_offset += linesize[c] >> 1;
1471 1472
                    if (   8*(h * mb_x + x) < ((c == 1) || (c == 2) ? chroma_width  : s->width)
                        && 8*(v * mb_y + y) < ((c == 1) || (c == 2) ? chroma_height : s->height)) {
1473 1474 1475
                        ptr = data[c] + block_offset;
                    } else
                        ptr = NULL;
1476
                    if (!s->progressive) {
1477 1478 1479 1480
                        if (copy_mb) {
                            if (ptr)
                                mjpeg_copy_block(s, ptr, reference_data[c] + block_offset,
                                                linesize[c], s->avctx->lowres);
1481

1482
                        } else {
1483
                            s->bdsp.clear_block(s->block);
1484 1485
                            if (decode_block(s, s->block, i,
                                             s->dc_index[i], s->ac_index[i],
1486
                                             s->quant_matrixes[s->quant_sindex[i]]) < 0) {
1487 1488
                                av_log(s->avctx, AV_LOG_ERROR,
                                       "error y=%d x=%d\n", mb_y, mb_x);
1489
                                return AVERROR_INVALIDDATA;
1490
                            }
1491 1492 1493 1494 1495
                            if (ptr) {
                                s->idsp.idct_put(ptr, linesize[c], s->block);
                                if (s->bits & 7)
                                    shift_output(s, ptr, linesize[c]);
                            }
1496
                        }
Loren Merritt's avatar
Loren Merritt committed
1497
                    } else {
1498 1499
                        int block_idx  = s->block_stride[c] * (v * mb_y + y) +
                                         (h * mb_x + x);
Diego Biurrun's avatar
Diego Biurrun committed
1500
                        int16_t *block = s->blocks[c][block_idx];
1501 1502
                        if (Ah)
                            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 1507 1508
                                                       Al) < 0) {
                            av_log(s->avctx, AV_LOG_ERROR,
                                   "error y=%d x=%d\n", mb_y, mb_x);
1509
                            return AVERROR_INVALIDDATA;
Loren Merritt's avatar
Loren Merritt committed
1510 1511
                        }
                    }
1512 1513
                    ff_dlog(s->avctx, "mb: %d %d processed\n", mb_y, mb_x);
                    ff_dlog(s->avctx, "%d %d %d %d %d %d %d %d \n",
1514 1515
                            mb_x, mb_y, x, y, c, s->bottom_field,
                            (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1516 1517 1518 1519 1520 1521
                    if (++x == h) {
                        x = 0;
                        y++;
                    }
                }
            }
1522

1523
            handle_rstn(s, nb_components);
1524 1525 1526 1527 1528
        }
    }
    return 0;
}

1529 1530 1531
static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss,
                                            int se, int Ah, int Al)
{
Loren Merritt's avatar
Loren Merritt committed
1532 1533 1534
    int mb_x, mb_y;
    int EOBRUN = 0;
    int c = s->comp_index[0];
1535
    uint16_t *quant_matrix = s->quant_matrixes[s->quant_sindex[0]];
Loren Merritt's avatar
Loren Merritt committed
1536

1537 1538 1539
    av_assert0(ss>=0 && Ah>=0 && Al>=0);
    if (se < ss || se > 63) {
        av_log(s->avctx, AV_LOG_ERROR, "SS/SE %d/%d is invalid\n", ss, se);
1540 1541 1542
        return AVERROR_INVALIDDATA;
    }

1543 1544 1545
    // s->coefs_finished is a bitmask for coefficients coded
    // ss and se are parameters telling start and end coefficients
    s->coefs_finished[c] |= (2ULL << se) - (1ULL << ss);
Loren Merritt's avatar
Loren Merritt committed
1546

1547 1548
    s->restart_count = 0;

1549 1550
    for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
        int block_idx    = mb_y * s->block_stride[c];
Diego Biurrun's avatar
Diego Biurrun committed
1551
        int16_t (*block)[64] = &s->blocks[c][block_idx];
1552
        uint8_t *last_nnz    = &s->last_nnz[c][block_idx];
1553 1554 1555 1556
        if (get_bits_left(&s->gb) <= 0) {
            av_log(s->avctx, AV_LOG_ERROR, "bitstream truncated in mjpeg_decode_scan_progressive_ac\n");
            return AVERROR_INVALIDDATA;
        }
1557 1558
        for (mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) {
                int ret;
1559 1560 1561
                if (s->restart_interval && !s->restart_count)
                    s->restart_count = s->restart_interval;

1562 1563 1564 1565 1566 1567 1568 1569 1570
                if (Ah)
                    ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0],
                                                  quant_matrix, ss, se, Al, &EOBRUN);
                else
                    ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0],
                                                   quant_matrix, ss, se, Al, &EOBRUN);
                if (ret < 0) {
                    av_log(s->avctx, AV_LOG_ERROR,
                           "error y=%d x=%d\n", mb_y, mb_x);
1571
                    return AVERROR_INVALIDDATA;
1572 1573
                }

1574 1575
            if (handle_rstn(s, 0))
                EOBRUN = 0;
Loren Merritt's avatar
Loren Merritt committed
1576 1577 1578 1579 1580
        }
    }
    return 0;
}

1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615
static void mjpeg_idct_scan_progressive_ac(MJpegDecodeContext *s)
{
    int mb_x, mb_y;
    int c;
    const int bytes_per_pixel = 1 + (s->bits > 8);
    const int block_size = s->lossless ? 1 : 8;

    for (c = 0; c < s->nb_components; c++) {
        uint8_t *data = s->picture_ptr->data[c];
        int linesize  = s->linesize[c];
        int h = s->h_max / s->h_count[c];
        int v = s->v_max / s->v_count[c];
        int mb_width     = (s->width  + h * block_size - 1) / (h * block_size);
        int mb_height    = (s->height + v * block_size - 1) / (v * block_size);

        if (~s->coefs_finished[c])
            av_log(s->avctx, AV_LOG_WARNING, "component %d is incomplete\n", c);

        if (s->interlaced && s->bottom_field)
            data += linesize >> 1;

        for (mb_y = 0; mb_y < mb_height; mb_y++) {
            uint8_t *ptr     = data + (mb_y * linesize * 8 >> s->avctx->lowres);
            int block_idx    = mb_y * s->block_stride[c];
            int16_t (*block)[64] = &s->blocks[c][block_idx];
            for (mb_x = 0; mb_x < mb_width; mb_x++, block++) {
                s->idsp.idct_put(ptr, linesize, *block);
                if (s->bits & 7)
                    shift_output(s, ptr, linesize);
                ptr += bytes_per_pixel*8 >> s->avctx->lowres;
            }
        }
    }
}

1616
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
    const int block_size = s->lossless ? 1 : 8;
1622 1623
    int ilv, prev_shift;

1624 1625 1626 1627 1628 1629
    if (!s->got_picture) {
        av_log(s->avctx, AV_LOG_WARNING,
                "Can not process SOS before SOF, skipping\n");
        return -1;
    }

1630 1631 1632 1633 1634 1635 1636 1637 1638
    if (reference) {
        if (reference->width  != s->picture_ptr->width  ||
            reference->height != s->picture_ptr->height ||
            reference->format != s->picture_ptr->format) {
            av_log(s->avctx, AV_LOG_ERROR, "Reference mismatching\n");
            return AVERROR_INVALIDDATA;
        }
    }

1639 1640 1641
    /* XXX: verify len field validity */
    len = get_bits(&s->gb, 16);
    nb_components = get_bits(&s->gb, 8);
1642
    if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
1643 1644 1645
        avpriv_report_missing_feature(s->avctx,
                                      "decode_sos: nb_components (%d)",
                                      nb_components);
1646
        return AVERROR_PATCHWELCOME;
1647
    }
1648
    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
    for (i = 0; i < nb_components; i++) {
1653 1654 1655
        id = get_bits(&s->gb, 8) - 1;
        av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
        /* find component index */
1656
        for (index = 0; index < s->nb_components; index++)
1657 1658
            if (id == s->component_id[index])
                break;
1659 1660 1661
        if (index == s->nb_components) {
            av_log(s->avctx, AV_LOG_ERROR,
                   "decode_sos: index(%d) out of components\n", index);
1662
            return AVERROR_INVALIDDATA;
1663
        }
1664 1665 1666 1667
        /* Metasoft MJPEG codec has Cb and Cr swapped */
        if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
            && nb_components == 3 && s->nb_components == 3 && i)
            index = 3 - i;
1668

1669
        s->quant_sindex[i] = s->quant_index[index];
1670 1671 1672 1673
        s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
        s->h_scount[i]  = s->h_count[index];
        s->v_scount[i]  = s->v_count[index];

1674
        if((nb_components == 1 || nb_components == 3) && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
1675
            index = (index+2)%3;
Michael Niedermayer's avatar
Michael Niedermayer committed
1676

1677 1678 1679 1680 1681 1682 1683 1684
        s->comp_index[i] = index;

        s->dc_index[i] = get_bits(&s->gb, 4);
        s->ac_index[i] = get_bits(&s->gb, 4);

        if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
            s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
            goto out_of_range;
1685
        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 1690
    predictor = get_bits(&s->gb, 8);       /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
    ilv = get_bits(&s->gb, 8);             /* JPEG Se / JPEG-LS ILV */
1691
    if(s->avctx->codec_tag != AV_RL32("CJPG")){
1692 1693
        prev_shift      = get_bits(&s->gb, 4); /* Ah */
        point_transform = get_bits(&s->gb, 4); /* Al */
1694
    }else
1695
        prev_shift = point_transform = 0;
1696 1697 1698 1699 1700

    if (nb_components > 1) {
        /* interleaved stream */
        s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
        s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1701
    } else if (!s->ls) { /* skip this for JPEG-LS */
1702 1703
        h = s->h_max / s->h_scount[0];
        v = s->v_max / s->v_scount[0];
1704 1705
        s->mb_width     = (s->width  + h * block_size - 1) / (h * block_size);
        s->mb_height    = (s->height + v * block_size - 1) / (v * block_size);
1706
        s->nb_blocks[0] = 1;
1707 1708
        s->h_scount[0]  = 1;
        s->v_scount[0]  = 1;
1709 1710
    }

1711 1712 1713
    if (s->avctx->debug & FF_DEBUG_PICT_INFO)
        av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n",
               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 1719 1720 1721


    /* mjpeg-b can have padding bytes between sos and image data, skip them */
    for (i = s->mjpb_skiptosod; i > 0; i--)
        skip_bits(&s->gb, 8);

1722 1723
next_field:
    for (i = 0; i < nb_components; i++)
1724
        s->last_dc[i] = (4 << s->bits);
1725

1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737
    if (s->avctx->hwaccel) {
        int bytes_to_start = get_bits_count(&s->gb) / 8;
        av_assert0(bytes_to_start >= 0 &&
                   s->raw_scan_buffer_size >= bytes_to_start);

        ret = s->avctx->hwaccel->decode_slice(s->avctx,
                                              s->raw_scan_buffer      + bytes_to_start,
                                              s->raw_scan_buffer_size - bytes_to_start);
        if (ret < 0)
            return ret;

    } else if (s->lossless) {
1738
        av_assert0(s->picture_ptr == s->picture);
1739 1740
        if (CONFIG_JPEGLS_DECODER && s->ls) {
//            for () {
1741 1742
//            reset_ls_coding_parameters(s, 0);

1743 1744 1745
            if ((ret = ff_jpegls_decode_picture(s, predictor,
                                                point_transform, ilv)) < 0)
                return ret;
1746
        } else {
1747
            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
                if ((ret = ljpeg_decode_yuv_scan(s, predictor,
1752 1753
                                                 point_transform,
                                                 nb_components)) < 0)
1754
                    return ret;
1755 1756
            }
        }
1757 1758
    } else {
        if (s->progressive && predictor) {
1759
            av_assert0(s->picture_ptr == s->picture);
1760 1761
            if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor,
                                                        ilv, prev_shift,
1762
                                                        point_transform)) < 0)
1763
                return ret;
Loren Merritt's avatar
Loren Merritt committed
1764
        } else {
1765 1766
            if ((ret = mjpeg_decode_scan(s, nb_components,
                                         prev_shift, point_transform,
1767
                                         mb_bitmask, mb_bitmask_size, reference)) < 0)
1768
                return ret;
Loren Merritt's avatar
Loren Merritt committed
1769
        }
1770
    }
1771 1772 1773 1774 1775

    if (s->interlaced &&
        get_bits_left(&s->gb) > 32 &&
        show_bits(&s->gb, 8) == 0xFF) {
        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 1780 1781 1782 1783 1784 1785 1786
            s->gb = bak;
            skip_bits(&s->gb, 16);
            s->bottom_field ^= 1;

            goto next_field;
        }
    }

1787 1788 1789 1790
    emms_c();
    return 0;
 out_of_range:
    av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1791
    return AVERROR_INVALIDDATA;
1792 1793 1794 1795 1796
}

static int mjpeg_decode_dri(MJpegDecodeContext *s)
{
    if (get_bits(&s->gb, 16) != 4)
1797
        return AVERROR_INVALIDDATA;
1798
    s->restart_interval = get_bits(&s->gb, 16);
1799 1800 1801
    s->restart_count    = 0;
    av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
           s->restart_interval);
1802 1803 1804 1805 1806 1807 1808 1809 1810

    return 0;
}

static int mjpeg_decode_app(MJpegDecodeContext *s)
{
    int len, id, i;

    len = get_bits(&s->gb, 16);
1811 1812 1813 1814 1815 1816 1817 1818 1819
    if (len < 6) {
        if (s->bayer) {
            // Pentax K-1 (digital camera) JPEG images embedded in DNG images contain unknown APP0 markers
            av_log(s->avctx, AV_LOG_WARNING, "skipping APPx (len=%"PRId32") for bayer-encoded image\n", len);
            skip_bits(&s->gb, len);
            return 0;
        } else
            return AVERROR_INVALIDDATA;
    }
1820
    if (8 * len > get_bits_left(&s->gb))
1821
        return AVERROR_INVALIDDATA;
1822

1823
    id   = get_bits_long(&s->gb, 32);
1824 1825
    len -= 6;

1826 1827 1828
    if (s->avctx->debug & FF_DEBUG_STARTCODE)
        av_log(s->avctx, AV_LOG_DEBUG, "APPx (%s / %8X) len=%d\n",
               av_fourcc2str(av_bswap32(id)), id, len);
1829

1830 1831 1832
    /* Buggy AVID, it puts EOI only at every 10th frame. */
    /* Also, this fourcc is used by non-avid files too, it holds some
       information, but it's always present in AVID-created files. */
1833
    if (id == AV_RB32("AVI1")) {
1834 1835 1836 1837 1838 1839 1840 1841
        /* structure:
            4bytes      AVI1
            1bytes      polarity
            1bytes      always zero
            4bytes      field_size
            4bytes      field_size_less_padding
        */
            s->buggy_avid = 1;
1842
        i = get_bits(&s->gb, 8); len--;
1843
        av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i);
1844 1845 1846
        goto out;
    }

1847
    if (id == AV_RB32("JFIF")) {
1848
        int t_w, t_h, v1, v2;
1849 1850
        if (len < 8)
            goto out;
1851
        skip_bits(&s->gb, 8); /* the trailing zero-byte */
1852 1853
        v1 = get_bits(&s->gb, 8);
        v2 = get_bits(&s->gb, 8);
1854 1855
        skip_bits(&s->gb, 8);

1856 1857
        s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 16);
        s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16);
1858 1859 1860 1861 1862
        if (   s->avctx->sample_aspect_ratio.num <= 0
            || s->avctx->sample_aspect_ratio.den <= 0) {
            s->avctx->sample_aspect_ratio.num = 0;
            s->avctx->sample_aspect_ratio.den = 1;
        }
1863 1864

        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1865 1866 1867 1868 1869
            av_log(s->avctx, AV_LOG_INFO,
                   "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
                   v1, v2,
                   s->avctx->sample_aspect_ratio.num,
                   s->avctx->sample_aspect_ratio.den);
1870

1871 1872
        len -= 8;
        if (len >= 2) {
1873 1874 1875 1876 1877 1878 1879 1880
            t_w = get_bits(&s->gb, 8);
            t_h = get_bits(&s->gb, 8);
            if (t_w && t_h) {
                /* skip thumbnail */
                if (len -10 - (t_w * t_h * 3) > 0)
                    len -= t_w * t_h * 3;
            }
            len -= 2;
1881
        }
1882 1883 1884
        goto out;
    }

1885 1886 1887 1888 1889
    if (   id == AV_RB32("Adob")
        && len >= 7
        && show_bits(&s->gb, 8) == 'e'
        && show_bits_long(&s->gb, 32) != AV_RB32("e_CM")) {
        skip_bits(&s->gb,  8); /* 'e' */
1890 1891 1892
        skip_bits(&s->gb, 16); /* version */
        skip_bits(&s->gb, 16); /* flags0 */
        skip_bits(&s->gb, 16); /* flags1 */
1893 1894 1895
        s->adobe_transform = get_bits(&s->gb,  8);
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
            av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found, transform=%d\n", s->adobe_transform);
1896 1897 1898 1899
        len -= 7;
        goto out;
    }

1900
    if (id == AV_RB32("LJIF")) {
1901 1902
        int rgb = s->rgb;
        int pegasus_rct = s->pegasus_rct;
1903
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1904 1905
            av_log(s->avctx, AV_LOG_INFO,
                   "Pegasus lossless jpeg header found\n");
1906
        skip_bits(&s->gb, 16); /* version ? */
1907 1908 1909
        skip_bits(&s->gb, 16); /* unknown always 0? */
        skip_bits(&s->gb, 16); /* unknown always 0? */
        skip_bits(&s->gb, 16); /* unknown always 0? */
1910
        switch (i=get_bits(&s->gb, 8)) {
1911
        case 1:
1912 1913
            rgb         = 1;
            pegasus_rct = 0;
1914 1915
            break;
        case 2:
1916 1917
            rgb         = 1;
            pegasus_rct = 1;
1918 1919
            break;
        default:
1920
            av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace %d\n", i);
1921
        }
1922

1923
        len -= 9;
1924 1925 1926 1927 1928 1929 1930 1931 1932
        if (s->got_picture)
            if (rgb != s->rgb || pegasus_rct != s->pegasus_rct) {
                av_log(s->avctx, AV_LOG_WARNING, "Mismatching LJIF tag\n");
                goto out;
            }

        s->rgb = rgb;
        s->pegasus_rct = pegasus_rct;

1933 1934
        goto out;
    }
1935 1936 1937 1938 1939 1940 1941
    if (id == AV_RL32("colr") && len > 0) {
        s->colr = get_bits(&s->gb, 8);
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
            av_log(s->avctx, AV_LOG_INFO, "COLR %d\n", s->colr);
        len --;
        goto out;
    }
1942 1943 1944 1945 1946 1947 1948
    if (id == AV_RL32("xfrm") && len > 0) {
        s->xfrm = get_bits(&s->gb, 8);
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
            av_log(s->avctx, AV_LOG_INFO, "XFRM %d\n", s->xfrm);
        len --;
        goto out;
    }
1949

1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963
    /* JPS extension by VRex */
    if (s->start_code == APP3 && id == AV_RB32("_JPS") && len >= 10) {
        int flags, layout, type;
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
            av_log(s->avctx, AV_LOG_INFO, "_JPSJPS_\n");

        skip_bits(&s->gb, 32); len -= 4;  /* JPS_ */
        skip_bits(&s->gb, 16); len -= 2;  /* block length */
        skip_bits(&s->gb, 8);             /* reserved */
        flags  = get_bits(&s->gb, 8);
        layout = get_bits(&s->gb, 8);
        type   = get_bits(&s->gb, 8);
        len -= 4;

1964
        av_freep(&s->stereo3d);
1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989
        s->stereo3d = av_stereo3d_alloc();
        if (!s->stereo3d) {
            goto out;
        }
        if (type == 0) {
            s->stereo3d->type = AV_STEREO3D_2D;
        } else if (type == 1) {
            switch (layout) {
            case 0x01:
                s->stereo3d->type = AV_STEREO3D_LINES;
                break;
            case 0x02:
                s->stereo3d->type = AV_STEREO3D_SIDEBYSIDE;
                break;
            case 0x03:
                s->stereo3d->type = AV_STEREO3D_TOPBOTTOM;
                break;
            }
            if (!(flags & 0x04)) {
                s->stereo3d->flags = AV_STEREO3D_FLAG_INVERT;
            }
        }
        goto out;
    }

1990
    /* EXIF metadata */
1991
    if (s->start_code == APP1 && id == AV_RB32("Exif") && len >= 2) {
1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006
        GetByteContext gbytes;
        int ret, le, ifd_offset, bytes_read;
        const uint8_t *aligned;

        skip_bits(&s->gb, 16); // skip padding
        len -= 2;

        // init byte wise reading
        aligned = align_get_bits(&s->gb);
        bytestream2_init(&gbytes, aligned, len);

        // read TIFF header
        ret = ff_tdecode_header(&gbytes, &le, &ifd_offset);
        if (ret) {
            av_log(s->avctx, AV_LOG_ERROR, "mjpeg: invalid TIFF header in EXIF data\n");
2007
        } else {
2008
            bytestream2_seek(&gbytes, ifd_offset, SEEK_SET);
2009

2010 2011
            // read 0th IFD and store the metadata
            // (return values > 0 indicate the presence of subimage metadata)
2012
            ret = ff_exif_decode_ifd(s->avctx, &gbytes, le, 0, &s->exif_metadata);
2013 2014 2015
            if (ret < 0) {
                av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error decoding EXIF data\n");
            }
2016 2017 2018 2019 2020 2021 2022 2023 2024
        }

        bytes_read = bytestream2_tell(&gbytes);
        skip_bits(&s->gb, bytes_read << 3);
        len -= bytes_read;

        goto out;
    }

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

2046 2047 2048 2049 2050 2051
    if (s->start_code == APP2 && id == AV_RB32("ICC_") && len >= 10) {
        int id2;
        unsigned seqno;
        unsigned nummarkers;

        id   = get_bits_long(&s->gb, 32);
2052
        id2  = get_bits(&s->gb, 24);
2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111
        len -= 7;
        if (id != AV_RB32("PROF") || id2 != AV_RB24("ILE")) {
            av_log(s->avctx, AV_LOG_WARNING, "Invalid ICC_PROFILE header in APP2\n");
            goto out;
        }

        skip_bits(&s->gb, 8);
        seqno  = get_bits(&s->gb, 8);
        len   -= 2;
        if (seqno == 0) {
            av_log(s->avctx, AV_LOG_WARNING, "Invalid sequence number in APP2\n");
            goto out;
        }

        nummarkers  = get_bits(&s->gb, 8);
        len        -= 1;
        if (nummarkers == 0) {
            av_log(s->avctx, AV_LOG_WARNING, "Invalid number of markers coded in APP2\n");
            goto out;
        } else if (s->iccnum != 0 && nummarkers != s->iccnum) {
            av_log(s->avctx, AV_LOG_WARNING, "Mistmatch in coded number of ICC markers between markers\n");
            goto out;
        } else if (seqno > nummarkers) {
            av_log(s->avctx, AV_LOG_WARNING, "Mismatching sequence number and coded number of ICC markers\n");
            goto out;
        }

        /* Allocate if this is the first APP2 we've seen. */
        if (s->iccnum == 0) {
            s->iccdata     = av_mallocz(nummarkers * sizeof(*(s->iccdata)));
            s->iccdatalens = av_mallocz(nummarkers * sizeof(*(s->iccdatalens)));
            if (!s->iccdata || !s->iccdatalens) {
                av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data arrays\n");
                return AVERROR(ENOMEM);
            }
            s->iccnum = nummarkers;
        }

        if (s->iccdata[seqno - 1]) {
            av_log(s->avctx, AV_LOG_WARNING, "Duplicate ICC sequence number\n");
            goto out;
        }

        s->iccdatalens[seqno - 1]  = len;
        s->iccdata[seqno - 1]      = av_malloc(len);
        if (!s->iccdata[seqno - 1]) {
            av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data buffer\n");
            return AVERROR(ENOMEM);
        }

        memcpy(s->iccdata[seqno - 1], align_get_bits(&s->gb), len);
        skip_bits(&s->gb, len << 3);
        len = 0;
        s->iccread++;

        if (s->iccread > s->iccnum)
            av_log(s->avctx, AV_LOG_WARNING, "Read more ICC markers than are supposed to be coded\n");
    }

2112 2113 2114
out:
    /* slow but needed for extreme adobe jpegs */
    if (len < 0)
2115 2116 2117
        av_log(s->avctx, AV_LOG_ERROR,
               "mjpeg: error, decode_app parser read over the end\n");
    while (--len > 0)
2118 2119 2120 2121 2122 2123 2124 2125
        skip_bits(&s->gb, 8);

    return 0;
}

static int mjpeg_decode_com(MJpegDecodeContext *s)
{
    int len = get_bits(&s->gb, 16);
2126
    if (len >= 2 && 8 * len - 16 <= get_bits_left(&s->gb)) {
2127
        int i;
2128
        char *cbuf = av_malloc(len - 1);
2129 2130
        if (!cbuf)
            return AVERROR(ENOMEM);
2131

2132 2133 2134 2135 2136 2137
        for (i = 0; i < len - 2; i++)
            cbuf[i] = get_bits(&s->gb, 8);
        if (i > 0 && cbuf[i - 1] == '\n')
            cbuf[i - 1] = 0;
        else
            cbuf[i] = 0;
2138

2139
        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 2144
        if (!strncmp(cbuf, "AVID", 4)) {
            parse_avid(s, cbuf, len);
2145 2146
        } else if (!strcmp(cbuf, "CS=ITU601"))
            s->cs_itu601 = 1;
2147 2148
        else if ((!strncmp(cbuf, "Intel(R) JPEG Library, version 1", 32) && s->avctx->codec_tag) ||
                 (!strncmp(cbuf, "Metasoft MJPEG Codec", 20)))
2149
            s->flipped = 1;
2150 2151 2152
        else if (!strcmp(cbuf, "MULTISCOPE II")) {
            s->avctx->sample_aspect_ratio = (AVRational) { 1, 2 };
            s->multiscope = 2;
2153
        }
2154 2155

        av_free(cbuf);
2156 2157 2158 2159 2160 2161 2162
    }

    return 0;
}

/* return the 8 bit start code value and update the search
   state. Return -1 if no start code found */
Michael Niedermayer's avatar
Michael Niedermayer committed
2163
static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
2164
{
Michael Niedermayer's avatar
Michael Niedermayer committed
2165
    const uint8_t *buf_ptr;
2166 2167
    unsigned int v, v2;
    int val;
2168
    int skipped = 0;
2169 2170

    buf_ptr = *pbuf_ptr;
2171
    while (buf_end - buf_ptr > 1) {
2172
        v  = *buf_ptr++;
2173
        v2 = *buf_ptr;
2174
        if ((v == 0xff) && (v2 >= SOF0) && (v2 <= COM) && buf_ptr < buf_end) {
2175 2176 2177 2178 2179
            val = *buf_ptr++;
            goto found;
        }
        skipped++;
    }
2180
    buf_ptr = buf_end;
2181 2182
    val = -1;
found:
2183
    ff_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
2184 2185 2186 2187
    *pbuf_ptr = buf_ptr;
    return val;
}

2188 2189
int ff_mjpeg_find_marker(MJpegDecodeContext *s,
                         const uint8_t **buf_ptr, const uint8_t *buf_end,
2190 2191
                         const uint8_t **unescaped_buf_ptr,
                         int *unescaped_buf_size)
2192 2193
{
    int start_code;
2194
    start_code = find_marker(buf_ptr, buf_end);
2195

2196 2197 2198
    av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr);
    if (!s->buffer)
        return AVERROR(ENOMEM);
2199

2200 2201 2202
    /* unescape buffer of SOS, use special treatment for JPEG-LS */
    if (start_code == SOS && !s->ls) {
        const uint8_t *src = *buf_ptr;
2203
        const uint8_t *ptr = src;
2204
        uint8_t *dst = s->buffer;
2205

2206
        #define copy_data_segment(skip) do {       \
2207
            ptrdiff_t length = (ptr - src) - (skip);  \
2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220
            if (length > 0) {                         \
                memcpy(dst, src, length);             \
                dst += length;                        \
                src = ptr;                            \
            }                                         \
        } while (0)

        if (s->avctx->codec_id == AV_CODEC_ID_THP) {
            ptr = buf_end;
            copy_data_segment(0);
        } else {
            while (ptr < buf_end) {
                uint8_t x = *(ptr++);
2221

2222
                if (x == 0xff) {
2223
                    ptrdiff_t skip = 0;
2224 2225 2226 2227
                    while (ptr < buf_end && x == 0xff) {
                        x = *(ptr++);
                        skip++;
                    }
2228

2229 2230 2231 2232 2233 2234 2235 2236 2237 2238
                    /* 0xFF, 0xFF, ... */
                    if (skip > 1) {
                        copy_data_segment(skip);

                        /* decrement src as it is equal to ptr after the
                         * copy_data_segment macro and we might want to
                         * copy the current value of x later on */
                        src--;
                    }

2239
                    if (x < RST0 || x > RST7) {
2240 2241 2242 2243
                        copy_data_segment(1);
                        if (x)
                            break;
                    }
2244
                }
2245
            }
2246 2247
            if (src < ptr)
                copy_data_segment(0);
2248
        }
2249 2250
        #undef copy_data_segment

2251 2252
        *unescaped_buf_ptr  = s->buffer;
        *unescaped_buf_size = dst - s->buffer;
2253
        memset(s->buffer + *unescaped_buf_size, 0,
2254
               AV_INPUT_BUFFER_PADDING_SIZE);
2255

2256
        av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %"PTRDIFF_SPECIFIER" bytes\n",
2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271
               (buf_end - *buf_ptr) - (dst - s->buffer));
    } else if (start_code == SOS && s->ls) {
        const uint8_t *src = *buf_ptr;
        uint8_t *dst  = s->buffer;
        int bit_count = 0;
        int t = 0, b = 0;
        PutBitContext pb;

        /* find marker */
        while (src + t < buf_end) {
            uint8_t x = src[t++];
            if (x == 0xff) {
                while ((src + t < buf_end) && x == 0xff)
                    x = src[t++];
                if (x & 0x80) {
2272
                    t -= FFMIN(2, t);
2273
                    break;
2274
                }
2275 2276 2277 2278 2279 2280 2281 2282 2283
            }
        }
        bit_count = t * 8;
        init_put_bits(&pb, dst, t);

        /* unescape bitstream */
        while (b < t) {
            uint8_t x = src[b++];
            put_bits(&pb, 8, x);
2284
            if (x == 0xFF && b < t) {
2285
                x = src[b++];
2286 2287 2288 2289
                if (x & 0x80) {
                    av_log(s->avctx, AV_LOG_WARNING, "Invalid escape sequence\n");
                    x &= 0x7f;
                }
2290 2291 2292 2293 2294 2295 2296 2297
                put_bits(&pb, 7, x);
                bit_count--;
            }
        }
        flush_put_bits(&pb);

        *unescaped_buf_ptr  = dst;
        *unescaped_buf_size = (bit_count + 7) >> 3;
2298
        memset(s->buffer + *unescaped_buf_size, 0,
2299
               AV_INPUT_BUFFER_PADDING_SIZE);
2300 2301 2302 2303
    } else {
        *unescaped_buf_ptr  = *buf_ptr;
        *unescaped_buf_size = buf_end - *buf_ptr;
    }
2304 2305 2306 2307

    return start_code;
}

2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321
static void reset_icc_profile(MJpegDecodeContext *s)
{
    int i;

    if (s->iccdata)
        for (i = 0; i < s->iccnum; i++)
            av_freep(&s->iccdata[i]);
    av_freep(&s->iccdata);
    av_freep(&s->iccdatalens);

    s->iccread = 0;
    s->iccnum  = 0;
}

2322
int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
2323
                          AVPacket *avpkt)
2324
{
2325
    AVFrame     *frame = data;
2326
    const uint8_t *buf = avpkt->data;
2327
    int buf_size       = avpkt->size;
2328 2329 2330
    MJpegDecodeContext *s = avctx->priv_data;
    const uint8_t *buf_end, *buf_ptr;
    const uint8_t *unescaped_buf_ptr;
2331
    int hshift, vshift;
2332 2333
    int unescaped_buf_size;
    int start_code;
2334
    int i, index;
2335
    int ret = 0;
2336
    int is16bit;
2337

2338 2339
    s->buf_size = buf_size;

2340
    av_dict_free(&s->exif_metadata);
2341
    av_freep(&s->stereo3d);
2342
    s->adobe_transform = -1;
2343

2344 2345 2346
    if (s->iccnum != 0)
        reset_icc_profile(s);

2347 2348 2349 2350 2351
    buf_ptr = buf;
    buf_end = buf + buf_size;
    while (buf_ptr < buf_end) {
        /* find start next marker */
        start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,
2352 2353 2354 2355
                                          &unescaped_buf_ptr,
                                          &unescaped_buf_size);
        /* EOF */
        if (start_code < 0) {
2356
            break;
2357 2358 2359
        } else if (unescaped_buf_size > INT_MAX / 8) {
            av_log(avctx, AV_LOG_ERROR,
                   "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
        av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%"PTRDIFF_SPECIFIER"\n",
2364
               start_code, buf_end - buf_ptr);
2365

2366 2367 2368
        ret = init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);

        if (ret < 0) {
2369 2370 2371
            av_log(avctx, AV_LOG_ERROR, "invalid buffer\n");
            goto fail;
        }
2372

2373 2374 2375
        s->start_code = start_code;
        if (s->avctx->debug & FF_DEBUG_STARTCODE)
            av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2376

2377
        /* process markers */
2378
        if (start_code >= RST0 && start_code <= RST7) {
2379 2380 2381
            av_log(avctx, AV_LOG_DEBUG,
                   "restart marker: %d\n", start_code & 0x0f);
            /* APP fields */
2382 2383
        } else if (start_code >= APP0 && start_code <= APP15) {
            if ((ret = mjpeg_decode_app(s)) < 0)
2384 2385
                av_log(avctx, AV_LOG_ERROR, "unable to decode APP fields: %s\n",
                       av_err2str(ret));
2386
            /* Comment */
2387
        } else if (start_code == COM) {
2388 2389 2390
            ret = mjpeg_decode_com(s);
            if (ret < 0)
                return ret;
2391
        } else if (start_code == DQT) {
2392 2393 2394
            ret = ff_mjpeg_decode_dqt(s);
            if (ret < 0)
                return ret;
2395
        }
2396

2397 2398
        ret = -1;

2399 2400 2401 2402 2403
        if (!CONFIG_JPEGLS_DECODER &&
            (start_code == SOF48 || start_code == LSE)) {
            av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");
            return AVERROR(ENOSYS);
        }
2404

2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420
        if (avctx->skip_frame == AVDISCARD_ALL) {
            switch(start_code) {
            case SOF0:
            case SOF1:
            case SOF2:
            case SOF3:
            case SOF48:
            case SOI:
            case SOS:
            case EOI:
                break;
            default:
                goto skip;
            }
        }

2421 2422 2423 2424
        switch (start_code) {
        case SOI:
            s->restart_interval = 0;
            s->restart_count    = 0;
2425 2426
            s->raw_image_buffer      = buf_ptr;
            s->raw_image_buffer_size = buf_end - buf_ptr;
2427 2428 2429 2430 2431
            /* nothing to do on SOI */
            break;
        case DHT:
            if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
                av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2432
                goto fail;
2433 2434 2435 2436
            }
            break;
        case SOF0:
        case SOF1:
2437 2438 2439 2440
            if (start_code == SOF0)
                s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT;
            else
                s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT;
2441 2442 2443 2444
            s->lossless    = 0;
            s->ls          = 0;
            s->progressive = 0;
            if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2445
                goto fail;
2446 2447
            break;
        case SOF2:
2448
            s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT;
2449 2450 2451 2452
            s->lossless    = 0;
            s->ls          = 0;
            s->progressive = 1;
            if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2453
                goto fail;
2454 2455
            break;
        case SOF3:
2456
            s->avctx->profile     = FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS;
2457
            s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2458 2459 2460 2461
            s->lossless    = 1;
            s->ls          = 0;
            s->progressive = 0;
            if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2462
                goto fail;
2463 2464
            break;
        case SOF48:
2465
            s->avctx->profile     = FF_PROFILE_MJPEG_JPEG_LS;
2466
            s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2467 2468 2469 2470
            s->lossless    = 1;
            s->ls          = 1;
            s->progressive = 0;
            if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2471
                goto fail;
2472 2473 2474 2475
            break;
        case LSE:
            if (!CONFIG_JPEGLS_DECODER ||
                (ret = ff_jpegls_decode_lse(s)) < 0)
2476
                goto fail;
2477 2478
            break;
        case EOI:
2479
eoi_parser:
2480 2481
            if (!avctx->hwaccel && avctx->skip_frame != AVDISCARD_ALL &&
                s->progressive && s->cur_scan && s->got_picture)
2482
                mjpeg_idct_scan_progressive_ac(s);
2483
            s->cur_scan = 0;
2484 2485 2486
            if (!s->got_picture) {
                av_log(avctx, AV_LOG_WARNING,
                       "Found EOI before any SOF, ignoring\n");
2487 2488
                break;
            }
2489 2490 2491 2492
            if (s->interlaced) {
                s->bottom_field ^= 1;
                /* if not bottom field, do not output image yet */
                if (s->bottom_field == !s->interlace_polarity)
2493
                    break;
2494
            }
2495 2496 2497 2498
            if (avctx->skip_frame == AVDISCARD_ALL) {
                s->got_picture = 0;
                goto the_end_no_picture;
            }
2499 2500 2501 2502 2503 2504 2505
            if (s->avctx->hwaccel) {
                ret = s->avctx->hwaccel->end_frame(s->avctx);
                if (ret < 0)
                    return ret;

                av_freep(&s->hwaccel_picture_private);
            }
2506
            if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
2507 2508
                return ret;
            *got_frame = 1;
2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519
            s->got_picture = 0;

            if (!s->lossless) {
                int qp = FFMAX3(s->qscale[0],
                                s->qscale[1],
                                s->qscale[2]);
                int qpw = (s->width + 15) / 16;
                AVBufferRef *qp_table_buf = av_buffer_alloc(qpw);
                if (qp_table_buf) {
                    memset(qp_table_buf->data, qp, qpw);
                    av_frame_set_qp_table(data, qp_table_buf, 0, FF_QSCALE_TYPE_MPEG1);
2520
                }
2521

2522 2523
                if(avctx->debug & FF_DEBUG_QP)
                    av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);
2524
            }
2525

2526 2527
            goto the_end;
        case SOS:
2528 2529 2530
            s->raw_scan_buffer      = buf_ptr;
            s->raw_scan_buffer_size = buf_end - buf_ptr;

2531
            s->cur_scan++;
2532 2533
            if (avctx->skip_frame == AVDISCARD_ALL) {
                skip_bits(&s->gb, get_bits_left(&s->gb));
2534
                break;
2535
            }
2536

2537
            if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&
2538
                (avctx->err_recognition & AV_EF_EXPLODE))
2539
                goto fail;
2540 2541
            break;
        case DRI:
2542 2543
            if ((ret = mjpeg_decode_dri(s)) < 0)
                return ret;
2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557
            break;
        case SOF5:
        case SOF6:
        case SOF7:
        case SOF9:
        case SOF10:
        case SOF11:
        case SOF13:
        case SOF14:
        case SOF15:
        case JPG:
            av_log(avctx, AV_LOG_ERROR,
                   "mjpeg: unsupported coding type (%x)\n", start_code);
            break;
2558
        }
2559

2560
skip:
2561 2562 2563 2564 2565
        /* eof process start code */
        buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
        av_log(avctx, AV_LOG_DEBUG,
               "marker parser used %d bytes (%d bits)\n",
               (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
2566
    }
2567
    if (s->got_picture && s->cur_scan) {
2568 2569 2570
        av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
        goto eoi_parser;
    }
2571
    av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
2572
    return AVERROR_INVALIDDATA;
2573
fail:
2574
    s->got_picture = 0;
2575
    return ret;
2576
the_end:
2577

2578
    is16bit = av_pix_fmt_desc_get(s->avctx->pix_fmt)->comp[0].step > 1;
2579

2580
    if (AV_RB32(s->upscale_h)) {
2581
        int p;
2582 2583 2584
        av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
                   avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||
                   avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2585
                   avctx->pix_fmt == AV_PIX_FMT_YUV440P  ||
2586
                   avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2587 2588
                   avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
                   avctx->pix_fmt == AV_PIX_FMT_YUV420P  ||
2589
                   avctx->pix_fmt == AV_PIX_FMT_YUV420P16||
2590 2591
                   avctx->pix_fmt == AV_PIX_FMT_YUVA420P  ||
                   avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2592
                   avctx->pix_fmt == AV_PIX_FMT_GBRP     ||
2593 2594
                   avctx->pix_fmt == AV_PIX_FMT_GBRAP
                  );
2595 2596 2597 2598
        ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
        if (ret)
            return ret;

2599 2600
        av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
        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 2608
                w = AV_CEIL_RSHIFT(w, hshift);
                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 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624
                if (s->upscale_h[p] == 1) {
                    if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];
                    else                      line[w - 1] = line[(w - 1) / 2];
                    for (index = w - 2; index > 0; index--) {
                        if (is16bit)
                            ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;
                        else
                            line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
                    }
                } else if (s->upscale_h[p] == 2) {
                    if (is16bit) {
2625 2626 2627
                        ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3];
                        if (w > 1)
                            ((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1];
2628
                    } else {
2629 2630 2631
                        line[w - 1] = line[(w - 1) / 3];
                        if (w > 1)
                            line[w - 2] = line[w - 1];
2632 2633 2634 2635
                    }
                    for (index = w - 3; index > 0; index--) {
                        line[index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3;
                    }
2636
                }
2637 2638
                line += s->linesize[p];
            }
2639 2640
        }
    }
2641
    if (AV_RB32(s->upscale_v)) {
2642
        int p;
2643 2644 2645
        av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
                   avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||
                   avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2646
                   avctx->pix_fmt == AV_PIX_FMT_YUV422P  ||
2647 2648
                   avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
                   avctx->pix_fmt == AV_PIX_FMT_YUV420P  ||
2649 2650
                   avctx->pix_fmt == AV_PIX_FMT_YUV440P  ||
                   avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2651
                   avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2652 2653
                   avctx->pix_fmt == AV_PIX_FMT_YUVA420P  ||
                   avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2654
                   avctx->pix_fmt == AV_PIX_FMT_GBRP     ||
2655 2656
                   avctx->pix_fmt == AV_PIX_FMT_GBRAP
                   );
2657 2658 2659 2660
        ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
        if (ret)
            return ret;

2661 2662
        av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
        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 2670
                w = AV_CEIL_RSHIFT(w, hshift);
                h = AV_CEIL_RSHIFT(h, vshift);
2671 2672 2673
            }
            dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];
            for (i = h - 1; i; i--) {
2674 2675 2676
                uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
                uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
                if (s->upscale_v[p] != 2 && (src1 == src2 || i == h - 1)) {
2677 2678 2679 2680 2681 2682
                    memcpy(dst, src1, w);
                } else {
                    for (index = 0; index < w; index++)
                        dst[index] = (src1[index] + src2[index]) >> 1;
                }
                dst -= s->linesize[p];
2683 2684 2685
            }
        }
    }
2686
    if (s->flipped && !s->rgb) {
2687
        int j;
2688 2689 2690 2691
        ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
        if (ret)
            return ret;

2692 2693
        av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
        for (index=0; index<s->nb_components; index++) {
2694
            uint8_t *dst = s->picture_ptr->data[index];
2695 2696
            int w = s->picture_ptr->width;
            int h = s->picture_ptr->height;
2697
            if(index && index<3){
2698 2699
                w = AV_CEIL_RSHIFT(w, hshift);
                h = AV_CEIL_RSHIFT(h, vshift);
2700 2701
            }
            if(dst){
2702
                uint8_t *dst2 = dst + s->picture_ptr->linesize[index]*(h-1);
2703 2704 2705
                for (i=0; i<h/2; i++) {
                    for (j=0; j<w; j++)
                        FFSWAP(int, dst[j], dst2[j]);
2706 2707
                    dst  += s->picture_ptr->linesize[index];
                    dst2 -= s->picture_ptr->linesize[index];
2708 2709 2710
                }
            }
        }
2711 2712 2713 2714
    }
    if (s->adobe_transform == 0 && s->avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
        int w = s->picture_ptr->width;
        int h = s->picture_ptr->height;
2715
        av_assert0(s->nb_components == 4);
2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733
        for (i=0; i<h; i++) {
            int j;
            uint8_t *dst[4];
            for (index=0; index<4; index++) {
                dst[index] =   s->picture_ptr->data[index]
                             + s->picture_ptr->linesize[index]*i;
            }
            for (j=0; j<w; j++) {
                int k = dst[3][j];
                int r = dst[0][j] * k;
                int g = dst[1][j] * k;
                int b = dst[2][j] * k;
                dst[0][j] = g*257 >> 16;
                dst[1][j] = b*257 >> 16;
                dst[2][j] = r*257 >> 16;
                dst[3][j] = 255;
            }
        }
2734 2735 2736 2737
    }
    if (s->adobe_transform == 2 && s->avctx->pix_fmt == AV_PIX_FMT_YUVA444P) {
        int w = s->picture_ptr->width;
        int h = s->picture_ptr->height;
2738
        av_assert0(s->nb_components == 4);
2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756
        for (i=0; i<h; i++) {
            int j;
            uint8_t *dst[4];
            for (index=0; index<4; index++) {
                dst[index] =   s->picture_ptr->data[index]
                             + s->picture_ptr->linesize[index]*i;
            }
            for (j=0; j<w; j++) {
                int k = dst[3][j];
                int r = (255 - dst[0][j]) * k;
                int g = (128 - dst[1][j]) * k;
                int b = (128 - dst[2][j]) * k;
                dst[0][j] = r*257 >> 16;
                dst[1][j] = (g*257 >> 16) + 128;
                dst[2][j] = (b*257 >> 16) + 128;
                dst[3][j] = 255;
            }
        }
2757 2758
    }

2759 2760 2761 2762 2763 2764 2765 2766 2767
    if (s->stereo3d) {
        AVStereo3D *stereo = av_stereo3d_create_side_data(data);
        if (stereo) {
            stereo->type  = s->stereo3d->type;
            stereo->flags = s->stereo3d->flags;
        }
        av_freep(&s->stereo3d);
    }

2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790
    if (s->iccnum != 0 && s->iccnum == s->iccread) {
        AVFrameSideData *sd;
        size_t offset = 0;
        int total_size = 0;
        int i;

        /* Sum size of all parts. */
        for (i = 0; i < s->iccnum; i++)
            total_size += s->iccdatalens[i];

        sd = av_frame_new_side_data(data, AV_FRAME_DATA_ICC_PROFILE, total_size);
        if (!sd) {
            av_log(s->avctx, AV_LOG_ERROR, "Could not allocate frame side data\n");
            return AVERROR(ENOMEM);
        }

        /* Reassemble the parts, which are now in-order. */
        for (i = 0; i < s->iccnum; i++) {
            memcpy(sd->data + offset, s->iccdata[i], s->iccdatalens[i]);
            offset += s->iccdatalens[i];
        }
    }

2791
    av_dict_copy(&((AVFrame *) data)->metadata, s->exif_metadata, 0);
2792 2793
    av_dict_free(&s->exif_metadata);

2794
the_end_no_picture:
2795
    av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n",
2796 2797
           buf_end - buf_ptr);
//  return buf_end - buf_ptr;
2798 2799 2800
    return buf_ptr - buf;
}

2801
av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
2802 2803 2804 2805
{
    MJpegDecodeContext *s = avctx->priv_data;
    int i, j;

2806 2807 2808 2809
    if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_number) {
        av_log(avctx, AV_LOG_INFO, "Single field\n");
    }

2810 2811 2812 2813
    if (s->picture) {
        av_frame_free(&s->picture);
        s->picture_ptr = NULL;
    } else if (s->picture_ptr)
2814
        av_frame_unref(s->picture_ptr);
2815

2816
    av_freep(&s->buffer);
2817
    av_freep(&s->stereo3d);
2818
    av_freep(&s->ljpeg_buffer);
2819
    s->ljpeg_buffer_size = 0;
2820

2821 2822
    for (i = 0; i < 3; i++) {
        for (j = 0; j < 4; j++)
2823
            ff_free_vlc(&s->vlcs[i][j]);
2824
    }
2825
    for (i = 0; i < MAX_COMPONENTS; i++) {
Loren Merritt's avatar
Loren Merritt committed
2826 2827 2828
        av_freep(&s->blocks[i]);
        av_freep(&s->last_nnz[i]);
    }
2829
    av_dict_free(&s->exif_metadata);
2830 2831 2832

    reset_icc_profile(s);

2833 2834
    av_freep(&s->hwaccel_picture_private);

2835 2836 2837
    return 0;
}

2838 2839 2840 2841 2842 2843
static void decode_flush(AVCodecContext *avctx)
{
    MJpegDecodeContext *s = avctx->priv_data;
    s->got_picture = 0;
}

2844
#if CONFIG_MJPEG_DECODER
2845 2846 2847
#define OFFSET(x) offsetof(MJpegDecodeContext, x)
#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
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 2851 2852 2853 2854 2855 2856 2857 2858 2859
    { NULL },
};

static const AVClass mjpegdec_class = {
    .class_name = "MJPEG decoder",
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
};

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 2866 2867 2868
    .priv_data_size = sizeof(MJpegDecodeContext),
    .init           = ff_mjpeg_decode_init,
    .close          = ff_mjpeg_decode_end,
    .decode         = ff_mjpeg_decode_frame,
2869
    .flush          = decode_flush,
2870
    .capabilities   = AV_CODEC_CAP_DR1,
Michael Niedermayer's avatar
Michael Niedermayer committed
2871
    .max_lowres     = 3,
2872
    .priv_class     = &mjpegdec_class,
2873
    .profiles       = NULL_IF_CONFIG_SMALL(ff_mjpeg_profiles),
2874 2875
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
                      FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2876
    .hw_configs     = (const AVCodecHWConfigInternal*[]) {
2877 2878 2879
#if CONFIG_MJPEG_NVDEC_HWACCEL
                        HWACCEL_NVDEC(mjpeg),
#endif
2880 2881 2882
#if CONFIG_MJPEG_VAAPI_HWACCEL
                        HWACCEL_VAAPI(mjpeg),
#endif
2883 2884
                        NULL
                    },
2885
};
2886 2887
#endif
#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 2894 2895 2896
    .priv_data_size = sizeof(MJpegDecodeContext),
    .init           = ff_mjpeg_decode_init,
    .close          = ff_mjpeg_decode_end,
    .decode         = ff_mjpeg_decode_frame,
2897
    .flush          = decode_flush,
2898
    .capabilities   = AV_CODEC_CAP_DR1,
Michael Niedermayer's avatar
Michael Niedermayer committed
2899
    .max_lowres     = 3,
2900
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
2901
};
2902
#endif