mjpegdec.c 75.2 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 "copy_block.h"
38
#include "internal.h"
39
#include "mjpeg.h"
40
#include "mjpegdec.h"
41
#include "jpeglsdec.h"
42 43 44
#include "tiff.h"
#include "exif.h"
#include "bytestream.h"
45 46


47 48 49
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)
50
{
51
    uint8_t huff_size[256] = { 0 };
52 53 54
    uint16_t huff_code[256];
    uint16_t huff_sym[256];
    int i;
55

56
    av_assert0(nb_codes <= 256);
57

58
    ff_mjpeg_build_huffman_codes(huff_size, huff_code, bits_table, val_table);
59

60 61
    for (i = 0; i < 256; i++)
        huff_sym[i] = i + 16 * is_ac;
62

63 64
    if (is_ac)
        huff_sym[0] = 16 * 256;
65

66 67
    return ff_init_vlc_sparse(vlc, 9, nb_codes, huff_size, 1, 1,
                              huff_code, 2, 2, huff_sym, 2, 2, use_static);
68 69
}

70 71
static void build_basic_mjpeg_vlc(MJpegDecodeContext *s)
{
72 73 74 75 76 77 78 79 80 81 82 83
    build_vlc(&s->vlcs[0][0], avpriv_mjpeg_bits_dc_luminance,
              avpriv_mjpeg_val_dc, 12, 0, 0);
    build_vlc(&s->vlcs[0][1], avpriv_mjpeg_bits_dc_chrominance,
              avpriv_mjpeg_val_dc, 12, 0, 0);
    build_vlc(&s->vlcs[1][0], avpriv_mjpeg_bits_ac_luminance,
              avpriv_mjpeg_val_ac_luminance, 251, 0, 1);
    build_vlc(&s->vlcs[1][1], avpriv_mjpeg_bits_ac_chrominance,
              avpriv_mjpeg_val_ac_chrominance, 251, 0, 1);
    build_vlc(&s->vlcs[2][0], avpriv_mjpeg_bits_ac_luminance,
              avpriv_mjpeg_val_ac_luminance, 251, 0, 0);
    build_vlc(&s->vlcs[2][1], avpriv_mjpeg_bits_ac_chrominance,
              avpriv_mjpeg_val_ac_chrominance, 251, 0, 0);
84 85
}

86
av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)
87 88 89
{
    MJpegDecodeContext *s = avctx->priv_data;

90 91 92 93 94 95
    if (!s->picture_ptr) {
        s->picture = av_frame_alloc();
        if (!s->picture)
            return AVERROR(ENOMEM);
        s->picture_ptr = s->picture;
    }
96

97
    s->avctx = avctx;
98
    ff_hpeldsp_init(&s->hdsp, avctx->flags);
99
    ff_dsputil_init(&s->dsp, avctx);
100
    ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct);
101 102 103
    s->buffer_size   = 0;
    s->buffer        = NULL;
    s->start_code    = -1;
104
    s->first_picture = 1;
105
    s->got_picture   = 0;
106
    s->org_height    = avctx->coded_height;
107
    avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
108

109
    build_basic_mjpeg_vlc(s);
110

111
    if (s->extern_huff) {
112
        av_log(avctx, AV_LOG_INFO, "using external huffman table\n");
113
        init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8);
114
        if (ff_mjpeg_decode_dht(s)) {
115
            av_log(avctx, AV_LOG_ERROR,
116
                   "error using external huffman table, switching back to internal\n");
117
            build_basic_mjpeg_vlc(s);
118
        }
119
    }
120
    if (avctx->field_order == AV_FIELD_BB) { /* quicktime icefloe 019 */
121
        s->interlace_polarity = 1;           /* bottom field first */
122
        av_log(avctx, AV_LOG_DEBUG, "bottom field first\n");
123
    }
124
    if (avctx->codec->id == AV_CODEC_ID_AMV)
125
        s->flipped = 1;
126 127 128 129 130 131

    return 0;
}


/* quantize tables */
132
int ff_mjpeg_decode_dqt(MJpegDecodeContext *s)
133 134 135 136 137 138
{
    int len, index, i, j;

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

    while (len >= 65) {
139 140 141 142
        int pr = get_bits(&s->gb, 4);
        if (pr > 1) {
            av_log(s->avctx, AV_LOG_ERROR, "dqt: invalid precision\n");
            return AVERROR_INVALIDDATA;
143 144 145 146 147 148
        }
        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 */
149
        for (i = 0; i < 64; i++) {
150
            j = s->scantable.permutated[i];
151
            s->quant_matrixes[index][j] = get_bits(&s->gb, pr ? 16 : 8);
152 153
        }

154 155 156 157 158
        // XXX FIXME finetune, and perhaps add dc too
        s->qscale[index] = FFMAX(s->quant_matrixes[index][s->scantable.permutated[1]],
                                 s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
        av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n",
               index, s->qscale[index]);
159 160 161 162 163 164
        len -= 65;
    }
    return 0;
}

/* decode huffman tables and build VLC decoders */
165
int ff_mjpeg_decode_dht(MJpegDecodeContext *s)
166 167 168 169
{
    int len, index, i, class, n, v, code_max;
    uint8_t bits_table[17];
    uint8_t val_table[256];
170
    int ret = 0;
171 172 173 174 175

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

    while (len > 0) {
        if (len < 17)
176
            return AVERROR_INVALIDDATA;
177 178
        class = get_bits(&s->gb, 4);
        if (class >= 2)
179
            return AVERROR_INVALIDDATA;
180 181
        index = get_bits(&s->gb, 4);
        if (index >= 4)
182
            return AVERROR_INVALIDDATA;
183
        n = 0;
184
        for (i = 1; i <= 16; i++) {
185 186 187 188 189
            bits_table[i] = get_bits(&s->gb, 8);
            n += bits_table[i];
        }
        len -= 17;
        if (len < n || n > 256)
190
            return AVERROR_INVALIDDATA;
191 192

        code_max = 0;
193
        for (i = 0; i < n; i++) {
194 195 196 197 198 199 200 201
            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 */
202
        ff_free_vlc(&s->vlcs[class][index]);
203 204
        av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
               class, index, code_max + 1);
205 206 207
        if ((ret = build_vlc(&s->vlcs[class][index], bits_table, val_table,
                             code_max + 1, 0, class > 0)) < 0)
            return ret;
208

209
        if (class > 0) {
210
            ff_free_vlc(&s->vlcs[2][index]);
211 212 213
            if ((ret = build_vlc(&s->vlcs[2][index], bits_table, val_table,
                                 code_max + 1, 0, 0)) < 0)
                return ret;
214
        }
215 216 217 218
    }
    return 0;
}

219
int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
220
{
221
    int len, nb_components, i, width, height, pix_fmt_id, ret;
222 223
    int h_count[MAX_COMPONENTS];
    int v_count[MAX_COMPONENTS];
224

225
    s->cur_scan = 0;
226
    s->upscale_h = s->upscale_v = 0;
227

228
    /* XXX: verify len field validity */
229
    len     = get_bits(&s->gb, 16);
230
    s->avctx->bits_per_raw_sample =
231
    s->bits = get_bits(&s->gb, 8);
232

233 234 235 236
    if (s->pegasus_rct)
        s->bits = 9;
    if (s->bits == 9 && !s->pegasus_rct)
        s->rct  = 1;    // FIXME ugly
237

238 239 240 241 242
    if(s->lossless && s->avctx->lowres){
        av_log(s->avctx, AV_LOG_ERROR, "lowres is not possible with lossless jpeg\n");
        return -1;
    }

243
    height = get_bits(&s->gb, 16);
244
    width  = get_bits(&s->gb, 16);
245

246 247
    // HACK for odd_height.mov
    if (s->interlaced && s->width == width && s->height == height + 1)
248 249 250
        height= s->height;

    av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
251
    if (av_image_check_size(width, height, 0, s->avctx))
252
        return AVERROR_INVALIDDATA;
253 254 255 256 257

    nb_components = get_bits(&s->gb, 8);
    if (nb_components <= 0 ||
        nb_components > MAX_COMPONENTS)
        return -1;
258 259
    if (s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
        if (nb_components != s->nb_components) {
260 261
            av_log(s->avctx, AV_LOG_ERROR,
                   "nb_components changing in interlaced picture\n");
262 263 264
            return AVERROR_INVALIDDATA;
        }
    }
265
    if (s->ls && !(s->bits <= 8 || nb_components == 1)) {
266 267 268
        avpriv_report_missing_feature(s->avctx,
                                      "JPEG-LS that is not <= 8 "
                                      "bits/component or 16-bit gray");
269
        return AVERROR_PATCHWELCOME;
270 271
    }
    s->nb_components = nb_components;
272 273
    s->h_max         = 1;
    s->v_max         = 1;
274 275
    memset(h_count, 0, sizeof(h_count));
    memset(v_count, 0, sizeof(v_count));
276
    for (i = 0; i < nb_components; i++) {
277 278
        /* component id */
        s->component_id[i] = get_bits(&s->gb, 8) - 1;
279 280
        h_count[i]         = get_bits(&s->gb, 4);
        v_count[i]         = get_bits(&s->gb, 4);
281
        /* compute hmax and vmax (only used in interleaved case) */
282 283 284 285
        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];
286
        s->quant_index[i] = get_bits(&s->gb, 8);
287 288
        if (s->quant_index[i] >= 4) {
            av_log(s->avctx, AV_LOG_ERROR, "quant_index is invalid\n");
289
            return AVERROR_INVALIDDATA;
290
        }
291
        if (!h_count[i] || !v_count[i]) {
292 293
            av_log(s->avctx, AV_LOG_ERROR,
                   "Invalid sampling factor in component %d %d:%d\n",
294
                   i, h_count[i], v_count[i]);
295 296 297
            return AVERROR_INVALIDDATA;
        }

298
        av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n",
299
               i, h_count[i], v_count[i],
300
               s->component_id[i], s->quant_index[i]);
301 302
    }

303
    if (s->ls && (s->h_max > 1 || s->v_max > 1)) {
304
        avpriv_report_missing_feature(s->avctx, "Subsampling in JPEG-LS");
305
        return AVERROR_PATCHWELCOME;
306 307 308 309
    }


    /* if different size, realloc/alloc picture */
310
    if (   width != s->width || height != s->height
311 312
        || memcmp(s->h_count, h_count, sizeof(h_count))
        || memcmp(s->v_count, v_count, sizeof(v_count))) {
313

314 315
        s->width      = width;
        s->height     = height;
316 317
        memcpy(s->h_count, h_count, sizeof(h_count));
        memcpy(s->v_count, v_count, sizeof(v_count));
318
        s->interlaced = 0;
319
        s->got_picture = 0;
320 321

        /* test interlaced mode */
322
        if (s->first_picture   &&
323 324
            s->org_height != 0 &&
            s->height < ((s->org_height * 3) / 4)) {
325 326
            s->interlaced                    = 1;
            s->bottom_field                  = s->interlace_polarity;
327
            s->picture_ptr->interlaced_frame = 1;
328
            s->picture_ptr->top_field_first  = !s->interlace_polarity;
329 330 331
            height *= 2;
        }

332 333 334
        ret = ff_set_dimensions(s->avctx, width, height);
        if (ret < 0)
            return ret;
335 336 337 338

        s->first_picture = 0;
    }

339
    if (s->got_picture && s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
340
        if (s->progressive) {
341
            avpriv_request_sample(s->avctx, "progressively coded interlaced picture");
342 343
            return AVERROR_INVALIDDATA;
        }
344
    } else{
345
        if (s->v_max == 1 && s->h_max == 1 && s->lossless==1 && (nb_components==3 || nb_components==4))
346 347 348
            s->rgb = 1;
        else if (!s->lossless)
            s->rgb = 0;
349
    /* XXX: not complete test ! */
350 351 352 353
    pix_fmt_id = (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];
354
    av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);
355 356 357 358 359 360 361 362
    /* 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;

    switch (pix_fmt_id) {
363
    case 0x11111100:
364
        if (s->rgb)
365
            s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_BGR48;
366 367
        else {
            if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
368
                s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_GBRP : AV_PIX_FMT_GBRP16;
369
            } else {
370 371
                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;
Gavin Kinsey's avatar
Gavin Kinsey committed
372
            s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
Michael Niedermayer's avatar
Michael Niedermayer committed
373
            }
Gavin Kinsey's avatar
Gavin Kinsey committed
374
        }
375
        av_assert0(s->nb_components == 3);
376
        break;
377 378
    case 0x11111111:
        if (s->rgb)
379
            s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_ABGR : AV_PIX_FMT_RGBA64;
380
        else {
381
            s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_YUVA444P : AV_PIX_FMT_YUVA444P16;
382 383 384 385
            s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
        }
        av_assert0(s->nb_components == 4);
        break;
386
    case 0x12121100:
387
    case 0x22122100:
388 389 390
        if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
        else
            goto unk_pixfmt;
391
        s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
392 393 394 395 396 397
        s->upscale_v = 2;
        s->upscale_h = (pix_fmt_id == 0x22122100);
        s->chroma_height = s->height;
        break;
    case 0x21211100:
    case 0x22211200:
398 399 400
        if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
        else
            goto unk_pixfmt;
401 402 403 404 405 406
        s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
        s->upscale_v = (pix_fmt_id == 0x22211200);
        s->upscale_h = 2;
        s->chroma_height = s->height;
        break;
    case 0x22221100:
407 408 409
        if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
        else
            goto unk_pixfmt;
410 411 412 413
        s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
        s->upscale_v = 2;
        s->upscale_h = 2;
        s->chroma_height = s->height / 2;
414
        break;
415
    case 0x11000000:
416 417 418 419 420 421 422 423
    case 0x13000000:
    case 0x14000000:
    case 0x31000000:
    case 0x33000000:
    case 0x34000000:
    case 0x41000000:
    case 0x43000000:
    case 0x44000000:
424
        if(s->bits <= 8)
425
            s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
426
        else
427
            s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
428
        break;
429
    case 0x12111100:
430
    case 0x22211100:
431
    case 0x22112100:
432 433 434
        if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV440P : AV_PIX_FMT_YUVJ440P;
        else
            goto unk_pixfmt;
Gavin Kinsey's avatar
Gavin Kinsey committed
435
        s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
436 437
        s->upscale_h = (pix_fmt_id == 0x22211100) * 2 + (pix_fmt_id == 0x22112100);
        s->chroma_height = s->height / 2;
438
        break;
439
    case 0x21111100:
440 441
        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;
Gavin Kinsey's avatar
Gavin Kinsey committed
442
        s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
443
        break;
444 445
    case 0x22121100:
    case 0x22111200:
446 447 448
        if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
        else
            goto unk_pixfmt;
449 450 451
        s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
        s->upscale_v = (pix_fmt_id == 0x22121100) + 1;
        break;
452
    case 0x22111100:
453 454
        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;
Gavin Kinsey's avatar
Gavin Kinsey committed
455
        s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
456
        break;
457
    case 0x41111100:
458 459 460
        if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV411P : AV_PIX_FMT_YUVJ411P;
        else
            goto unk_pixfmt;
461 462
        s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
        break;
463
    default:
464
unk_pixfmt:
465
        av_log(s->avctx, AV_LOG_ERROR, "Unhandled pixel format 0x%x\n", pix_fmt_id);
466
        return AVERROR_PATCHWELCOME;
467
    }
468 469 470 471
    if ((s->upscale_h || s->upscale_v) && s->avctx->lowres) {
        av_log(s->avctx, AV_LOG_ERROR, "lowres not supported for weird subsampling\n");
        return AVERROR_PATCHWELCOME;
    }
472
    if (s->ls) {
473
        s->upscale_h = s->upscale_v = 0;
474
        if (s->nb_components > 1)
475
            s->avctx->pix_fmt = AV_PIX_FMT_RGB24;
476
        else if (s->bits <= 8)
477
            s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
478
        else
479
            s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
480 481
    }

482 483 484 485 486 487
    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;
    }

488
    av_frame_unref(s->picture_ptr);
489
    if (ff_get_buffer(s->avctx, s->picture_ptr, AV_GET_BUFFER_FLAG_REF) < 0)
490
        return -1;
491 492 493
    s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
    s->picture_ptr->key_frame = 1;
    s->got_picture            = 1;
494

495 496
    for (i = 0; i < 3; i++)
        s->linesize[i] = s->picture_ptr->linesize[i] << s->interlaced;
497

498 499 500
    av_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);
501

502
    if (len != (8 + (3 * nb_components)))
503
        av_log(s->avctx, AV_LOG_DEBUG, "decode_sof0: error, len(%d) mismatch\n", len);
504
    }
505

506 507 508 509 510
    if (s->rgb && !s->lossless && !s->ls) {
        av_log(s->avctx, AV_LOG_ERROR, "Unsupported coding and pixel format combination\n");
        return AVERROR_PATCHWELCOME;
    }

511
    /* totally blank picture as progressive JPEG will only add details to it */
512 513 514 515
    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
516 517 518
            int size = bw * bh * s->h_count[i] * s->v_count[i];
            av_freep(&s->blocks[i]);
            av_freep(&s->last_nnz[i]);
519
            s->blocks[i]       = av_mallocz(size * sizeof(**s->blocks));
520
            s->last_nnz[i]     = av_mallocz(size * sizeof(**s->last_nnz));
521 522
            if (!s->blocks[i] || !s->last_nnz[i])
                return AVERROR(ENOMEM);
Loren Merritt's avatar
Loren Merritt committed
523 524 525
            s->block_stride[i] = bw * s->h_count[i];
        }
        memset(s->coefs_finished, 0, sizeof(s->coefs_finished));
526 527 528 529 530 531 532 533
    }
    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);
534
    if (code < 0 || code > 16) {
535 536 537
        av_log(s->avctx, AV_LOG_WARNING,
               "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
               0, dc_index, &s->vlcs[0][dc_index]);
538
        return 0xfffff;
539 540
    }

541
    if (code)
542 543 544 545 546 547
        return get_xbits(&s->gb, code);
    else
        return 0;
}

/* decode block and dequantize */
Diego Biurrun's avatar
Diego Biurrun committed
548
static int decode_block(MJpegDecodeContext *s, int16_t *block, int component,
549
                        int dc_index, int ac_index, int16_t *quant_matrix)
550 551 552 553 554
{
    int code, i, j, level, val;

    /* DC coef */
    val = mjpeg_decode_dc(s, dc_index);
555
    if (val == 0xfffff) {
556
        av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
557
        return AVERROR_INVALIDDATA;
558 559 560 561 562 563
    }
    val = val * quant_matrix[0] + s->last_dc[component];
    s->last_dc[component] = val;
    block[0] = val;
    /* AC coefs */
    i = 0;
564
    {OPEN_READER(re, &s->gb);
565
    do {
566
        UPDATE_CACHE(re, &s->gb);
567
        GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2);
568 569 570

        i += ((unsigned)code) >> 4;
            code &= 0xf;
571 572
        if (code) {
            if (code > MIN_CACHE_BITS - 16)
573
                UPDATE_CACHE(re, &s->gb);
574

575
            {
576 577 578
                int cache = GET_CACHE(re, &s->gb);
                int sign  = (~cache) >> 31;
                level     = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
579 580
            }

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

583
            if (i > 63) {
584
                av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
585
                return AVERROR_INVALIDDATA;
586
            }
587
            j        = s->scantable.permutated[i];
588 589
            block[j] = level * quant_matrix[j];
        }
590
    } while (i < 63);
591
    CLOSE_READER(re, &s->gb);}
592 593 594 595

    return 0;
}

Diego Biurrun's avatar
Diego Biurrun committed
596
static int decode_dc_progressive(MJpegDecodeContext *s, int16_t *block,
597 598
                                 int component, int dc_index,
                                 int16_t *quant_matrix, int Al)
Loren Merritt's avatar
Loren Merritt committed
599 600
{
    int val;
Loren Merritt's avatar
Loren Merritt committed
601
    s->dsp.clear_block(block);
Loren Merritt's avatar
Loren Merritt committed
602
    val = mjpeg_decode_dc(s, dc_index);
603
    if (val == 0xfffff) {
Loren Merritt's avatar
Loren Merritt committed
604
        av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
605
        return AVERROR_INVALIDDATA;
Loren Merritt's avatar
Loren Merritt committed
606 607 608 609 610 611 612
    }
    val = (val * quant_matrix[0] << Al) + s->last_dc[component];
    s->last_dc[component] = val;
    block[0] = val;
    return 0;
}

613
/* decode block and dequantize - progressive JPEG version */
Diego Biurrun's avatar
Diego Biurrun committed
614
static int decode_block_progressive(MJpegDecodeContext *s, int16_t *block,
615 616
                                    uint8_t *last_nnz, int ac_index,
                                    int16_t *quant_matrix,
Loren Merritt's avatar
Loren Merritt committed
617
                                    int ss, int se, int Al, int *EOBRUN)
618 619 620
{
    int code, i, j, level, val, run;

621
    if (*EOBRUN) {
622 623 624
        (*EOBRUN)--;
        return 0;
    }
625

626 627 628 629 630
    {
        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);
631

632 633 634 635 636 637
            run = ((unsigned) code) >> 4;
            code &= 0xF;
            if (code) {
                i += run;
                if (code > MIN_CACHE_BITS - 16)
                    UPDATE_CACHE(re, &s->gb);
638

639 640 641 642
                {
                    int cache = GET_CACHE(re, &s->gb);
                    int sign  = (~cache) >> 31;
                    level     = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
643
                }
644 645 646

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

647
                if (i >= se) {
648 649 650 651 652 653
                    if (i == se) {
                        j = s->scantable.permutated[se];
                        block[j] = level * quant_matrix[j] << Al;
                        break;
                    }
                    av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
654
                    return AVERROR_INVALIDDATA;
655
                }
656 657 658 659 660 661 662
                j = s->scantable.permutated[i];
                block[j] = level * quant_matrix[j] << Al;
            } 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);
663
                        return AVERROR_INVALIDDATA;
664 665 666 667 668 669 670 671 672 673
                    }
                } 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;
674
                }
675 676
            }
        }
677
        CLOSE_READER(re, &s->gb);
678
    }
679 680

    if (i > *last_nnz)
Loren Merritt's avatar
Loren Merritt committed
681
        *last_nnz = i;
682

Loren Merritt's avatar
Loren Merritt committed
683 684 685
    return 0;
}

686 687 688 689 690 691
#define REFINE_BIT(j) {                                             \
    UPDATE_CACHE(re, &s->gb);                                       \
    sign = block[j] >> 15;                                          \
    block[j] += SHOW_UBITS(re, &s->gb, 1) *                         \
                ((quant_matrix[j] ^ sign) - sign) << Al;            \
    LAST_SKIP_BITS(re, &s->gb, 1);                                  \
Loren Merritt's avatar
Loren Merritt committed
692 693
}

694 695 696 697 698 699 700 701 702 703 704 705 706 707 708
#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
709 710 711
}

/* decode block and dequantize - progressive JPEG refinement pass */
Diego Biurrun's avatar
Diego Biurrun committed
712
static int decode_block_refinement(MJpegDecodeContext *s, int16_t *block,
713 714 715
                                   uint8_t *last_nnz,
                                   int ac_index, int16_t *quant_matrix,
                                   int ss, int se, int Al, int *EOBRUN)
Loren Merritt's avatar
Loren Merritt committed
716
{
717 718
    int code, i = ss, j, sign, val, run;
    int last    = FFMIN(se, *last_nnz);
Loren Merritt's avatar
Loren Merritt committed
719 720

    OPEN_READER(re, &s->gb);
721
    if (*EOBRUN) {
Loren Merritt's avatar
Loren Merritt committed
722
        (*EOBRUN)--;
723 724
    } else {
        for (; ; i++) {
Loren Merritt's avatar
Loren Merritt committed
725
            UPDATE_CACHE(re, &s->gb);
726
            GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
727

728
            if (code & 0xF) {
Loren Merritt's avatar
Loren Merritt committed
729 730 731 732 733 734 735
                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--;
736 737 738
                block[j] = ((quant_matrix[j]^val) - val) << Al;
                if (i == se) {
                    if (i > *last_nnz)
Loren Merritt's avatar
Loren Merritt committed
739
                        *last_nnz = i;
740
                    CLOSE_READER(re, &s->gb);
Loren Merritt's avatar
Loren Merritt committed
741 742
                    return 0;
                }
743
            } else {
Loren Merritt's avatar
Loren Merritt committed
744
                run = ((unsigned) code) >> 4;
745
                if (run == 0xF) {
Loren Merritt's avatar
Loren Merritt committed
746
                    ZERO_RUN;
747
                } else {
Loren Merritt's avatar
Loren Merritt committed
748 749
                    val = run;
                    run = (1 << run);
750
                    if (val) {
Loren Merritt's avatar
Loren Merritt committed
751 752 753 754 755 756 757 758 759 760
                        UPDATE_CACHE(re, &s->gb);
                        run += SHOW_UBITS(re, &s->gb, val);
                        LAST_SKIP_BITS(re, &s->gb, val);
                    }
                    *EOBRUN = run - 1;
                    break;
                }
            }
        }

761
        if (i > *last_nnz)
Loren Merritt's avatar
Loren Merritt committed
762 763 764
            *last_nnz = i;
    }

765
    for (; i <= last; i++) {
Loren Merritt's avatar
Loren Merritt committed
766
        j = s->scantable.permutated[i];
767
        if (block[j])
Loren Merritt's avatar
Loren Merritt committed
768 769 770
            REFINE_BIT(j)
    }
    CLOSE_READER(re, &s->gb);
771 772 773

    return 0;
}
Loren Merritt's avatar
Loren Merritt committed
774 775
#undef REFINE_BIT
#undef ZERO_RUN
776

777
static int handle_rstn(MJpegDecodeContext *s, int nb_components)
778 779
{
    int i;
780 781
    int reset = 0;

782 783 784 785 786
    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 */
787
                s->last_dc[i] = (4 << s->bits);
788 789 790 791
        }

        i = 8 + ((-get_bits_count(&s->gb)) & 7);
        /* skip RSTn */
792
        if (s->restart_count == 0) {
793 794 795 796 797 798 799 800
            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 */
801
                        s->last_dc[i] = (4 << s->bits);
802
                    reset = 1;
803 804 805
                } else
                    skip_bits_long(&s->gb, pos - get_bits_count(&s->gb));
            }
806 807
        }
    }
808
    return reset;
809 810
}

811 812
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int nb_components, int predictor, int point_transform)
{
813
    int i, mb_x, mb_y;
814
    uint16_t (*buffer)[4];
815
    int left[4], top[4], topleft[4];
816
    const int linesize = s->linesize[0];
817
    const int mask     = ((1 << s->bits) - 1) << point_transform;
818 819
    int resync_mb_y = 0;
    int resync_mb_x = 0;
820

821 822 823 824 825 826
    if (s->nb_components != 3 && s->nb_components != 4)
        return AVERROR_INVALIDDATA;
    if (s->v_max != 1 || s->h_max != 1 || !s->lossless)
        return AVERROR_INVALIDDATA;


827 828
    s->restart_count = s->restart_interval;

829 830 831
    av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size,
                   (unsigned)s->mb_width * 4 * sizeof(s->ljpeg_buffer[0][0]));
    buffer = s->ljpeg_buffer;
832

833
    for (i = 0; i < 4; i++)
834 835 836
        buffer[0][i] = 1 << (s->bits - 1);

    for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
837
        uint8_t *ptr = s->picture_ptr->data[0] + (linesize * mb_y);
838 839 840 841

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

842
        for (i = 0; i < 4; i++)
843 844 845
            top[i] = left[i] = topleft[i] = buffer[0][i];

        for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
846 847 848
            int modified_predictor = predictor;

            if (s->restart_interval && !s->restart_count){
849
                s->restart_count = s->restart_interval;
850 851
                resync_mb_x = mb_x;
                resync_mb_y = mb_y;
852
                for(i=0; i<4; i++)
853
                    top[i] = left[i]= topleft[i]= 1 << (s->bits - 1);
854
            }
855
            if (mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || !mb_x)
856
                modified_predictor = 1;
857

858
            for (i=0;i<nb_components;i++) {
859
                int pred, dc;
860

861 862
                topleft[i] = top[i];
                top[i]     = buffer[mb_x][i];
863 864 865

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

866
                dc = mjpeg_decode_dc(s, s->dc_index[i]);
867
                if(dc == 0xFFFFF)
868 869
                    return -1;

870 871
                left[i] = buffer[mb_x][i] =
                    mask & (pred + (dc << point_transform));
872 873 874 875 876 877 878
            }

            if (s->restart_interval && !--s->restart_count) {
                align_get_bits(&s->gb);
                skip_bits(&s->gb, 16); /* skip RSTn */
            }
        }
879 880 881
        if (s->nb_components == 4) {
            for(i=0; i<nb_components; i++) {
                int c= s->comp_index[i];
882 883 884 885
                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];
                    }
886 887
                } else if(s->bits == 9) {
                    return AVERROR_PATCHWELCOME;
888 889 890 891
                } else {
                    for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
                        ((uint16_t*)ptr)[4*mb_x+c] = buffer[mb_x][i];
                    }
892 893 894
                }
            }
        } else if (s->rct) {
895 896 897 898
            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];
899
            }
900 901 902 903 904
        } 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];
905
            }
906 907
        } else {
            for(i=0; i<nb_components; i++) {
908
                int c= s->comp_index[i];
909 910 911 912
                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];
                    }
913 914
                } else if(s->bits == 9) {
                    return AVERROR_PATCHWELCOME;
915 916 917 918
                } else {
                    for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
                        ((uint16_t*)ptr)[3*mb_x+2-c] = buffer[mb_x][i];
                    }
919
                }
920 921 922 923 924 925
            }
        }
    }
    return 0;
}

926
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
927
                                 int point_transform, int nb_components)
928
{
929
    int i, mb_x, mb_y, mask;
930
    int bits= (s->bits+7)&~7;
931 932
    int resync_mb_y = 0;
    int resync_mb_x = 0;
933 934

    point_transform += bits - s->bits;
935
    mask = ((1 << s->bits) - 1) << point_transform;
936

937
    av_assert0(nb_components>=1 && nb_components<=4);
938

939 940
    for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
        for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
941
            if (s->restart_interval && !s->restart_count){
942
                s->restart_count = s->restart_interval;
943 944 945
                resync_mb_x = mb_x;
                resync_mb_y = mb_y;
            }
946

947 948 949
            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;
950
                for (i = 0; i < nb_components; i++) {
951
                    uint8_t *ptr;
952
                    uint16_t *ptr16;
953 954 955 956 957 958 959 960 961
                    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];

962 963
                    if(bits>8) linesize /= 2;

964
                    for(j=0; j<n; j++) {
965
                        int pred, dc;
966

967
                        dc = mjpeg_decode_dc(s, s->dc_index[i]);
968
                        if(dc == 0xFFFFF)
969 970
                            return -1;
                        if(bits<=8){
971
                        ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
972 973
                        if(y==0 && toprow){
                            if(x==0 && leftcol){
974
                                pred= 1 << (bits - 1);
975 976 977 978
                            }else{
                                pred= ptr[-1];
                            }
                        }else{
979
                            if(x==0 && leftcol){
980 981 982 983 984 985 986 987
                                pred= ptr[-linesize];
                            }else{
                                PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
                            }
                        }

                        if (s->interlaced && s->bottom_field)
                            ptr += linesize >> 1;
988
                        pred &= mask;
989
                        *ptr= pred + (dc << point_transform);
990
                        }else{
991
                            ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
992 993
                            if(y==0 && toprow){
                                if(x==0 && leftcol){
994 995 996 997 998
                                    pred= 1 << (bits - 1);
                                }else{
                                    pred= ptr16[-1];
                                }
                            }else{
999
                                if(x==0 && leftcol){
1000 1001 1002 1003 1004
                                    pred= ptr16[-linesize];
                                }else{
                                    PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
                                }
                            }
1005

1006 1007
                            if (s->interlaced && s->bottom_field)
                                ptr16 += linesize >> 1;
1008
                            pred &= mask;
1009 1010
                            *ptr16= pred + (dc << point_transform);
                        }
1011 1012 1013 1014 1015 1016
                        if (++x == h) {
                            x = 0;
                            y++;
                        }
                    }
                }
1017 1018
            } else {
                for (i = 0; i < nb_components; i++) {
1019
                    uint8_t *ptr;
1020
                    uint16_t *ptr16;
1021
                    int n, h, v, x, y, c, j, linesize, dc;
1022 1023 1024 1025 1026 1027 1028
                    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];
1029

1030 1031
                    if(bits>8) linesize /= 2;

1032
                    for (j = 0; j < n; j++) {
1033 1034
                        int pred;

1035
                        dc = mjpeg_decode_dc(s, s->dc_index[i]);
1036
                        if(dc == 0xFFFFF)
1037
                            return -1;
1038
                        if(bits<=8){
1039
                            ptr = s->picture_ptr->data[c] +
1040 1041 1042
                              (linesize * (v * mb_y + y)) +
                              (h * mb_x + x); //FIXME optimize this crap
                            PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1043

1044
                            pred &= mask;
1045
                            *ptr = pred + (dc << point_transform);
1046
                        }else{
1047
                            ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1048 1049
                            PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);

1050
                            pred &= mask;
1051 1052
                            *ptr16= pred + (dc << point_transform);
                        }
1053

1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069
                        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;
}

1070 1071
static av_always_inline void mjpeg_copy_block(MJpegDecodeContext *s,
                                              uint8_t *dst, const uint8_t *src,
1072 1073 1074
                                              int linesize, int lowres)
{
    switch (lowres) {
1075
    case 0: s->hdsp.put_pixels_tab[1][0](dst, src, linesize, 8);
1076 1077 1078 1079 1080 1081 1082 1083 1084 1085
        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;
    }
}

1086 1087 1088
static void shift_output(MJpegDecodeContext *s, uint8_t *ptr, int linesize)
{
    int block_x, block_y;
1089
    int size = 8 >> s->avctx->lowres;
1090
    if (s->bits > 8) {
1091 1092
        for (block_y=0; block_y<size; block_y++)
            for (block_x=0; block_x<size; block_x++)
1093 1094
                *(uint16_t*)(ptr + 2*block_x + block_y*linesize) <<= 16 - s->bits;
    } else {
1095 1096
        for (block_y=0; block_y<size; block_y++)
            for (block_x=0; block_x<size; block_x++)
1097 1098 1099 1100
                *(ptr + block_x + block_y*linesize) <<= 8 - s->bits;
    }
}

1101 1102
static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
                             int Al, const uint8_t *mb_bitmask,
1103
                             int mb_bitmask_size,
1104 1105
                             const AVFrame *reference)
{
1106
    int i, mb_x, mb_y;
1107
    uint8_t *data[MAX_COMPONENTS];
1108
    const uint8_t *reference_data[MAX_COMPONENTS];
1109
    int linesize[MAX_COMPONENTS];
1110
    GetBitContext mb_bitmask_gb;
1111
    int bytes_per_pixel = 1 + (s->bits > 8);
1112

1113 1114 1115 1116 1117
    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;
        }
1118
        init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
1119
    }
1120

1121
    s->restart_count = 0;
1122

1123 1124
    for (i = 0; i < nb_components; i++) {
        int c   = s->comp_index[i];
1125
        data[c] = s->picture_ptr->data[c];
1126
        reference_data[c] = reference ? reference->data[c] : NULL;
1127
        linesize[c] = s->linesize[c];
Loren Merritt's avatar
Loren Merritt committed
1128
        s->coefs_finished[c] |= 1;
1129 1130
    }

1131 1132
    for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
        for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1133 1134
            const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);

1135 1136 1137
            if (s->restart_interval && !s->restart_count)
                s->restart_count = s->restart_interval;

1138
            if (get_bits_left(&s->gb) < 0) {
1139
                av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",
1140
                       -get_bits_left(&s->gb));
1141
                return AVERROR_INVALIDDATA;
1142
            }
1143
            for (i = 0; i < nb_components; i++) {
1144 1145
                uint8_t *ptr;
                int n, h, v, x, y, c, j;
1146
                int block_offset;
1147 1148 1149 1150 1151 1152
                n = s->nb_blocks[i];
                c = s->comp_index[i];
                h = s->h_scount[i];
                v = s->v_scount[i];
                x = 0;
                y = 0;
1153
                for (j = 0; j < n; j++) {
Michael Niedermayer's avatar
Michael Niedermayer committed
1154
                    block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
1155
                                     (h * mb_x + x) * 8 * bytes_per_pixel) >> s->avctx->lowres);
1156

1157
                    if (s->interlaced && s->bottom_field)
1158 1159
                        block_offset += linesize[c] >> 1;
                    ptr = data[c] + block_offset;
1160 1161
                    if (!s->progressive) {
                        if (copy_mb)
1162
                            mjpeg_copy_block(s, ptr, reference_data[c] + block_offset,
1163
                                             linesize[c], s->avctx->lowres);
1164

1165 1166 1167 1168
                        else {
                            s->dsp.clear_block(s->block);
                            if (decode_block(s, s->block, i,
                                             s->dc_index[i], s->ac_index[i],
1169
                                             s->quant_matrixes[s->quant_sindex[i]]) < 0) {
1170 1171
                                av_log(s->avctx, AV_LOG_ERROR,
                                       "error y=%d x=%d\n", mb_y, mb_x);
1172
                                return AVERROR_INVALIDDATA;
1173 1174
                            }
                            s->dsp.idct_put(ptr, linesize[c], s->block);
1175 1176
                            if (s->bits & 7)
                                shift_output(s, ptr, linesize[c]);
1177
                        }
Loren Merritt's avatar
Loren Merritt committed
1178
                    } else {
1179 1180
                        int block_idx  = s->block_stride[c] * (v * mb_y + y) +
                                         (h * mb_x + x);
Diego Biurrun's avatar
Diego Biurrun committed
1181
                        int16_t *block = s->blocks[c][block_idx];
1182 1183
                        if (Ah)
                            block[0] += get_bits1(&s->gb) *
1184
                                        s->quant_matrixes[s->quant_sindex[i]][0] << Al;
1185
                        else if (decode_dc_progressive(s, block, i, s->dc_index[i],
1186
                                                       s->quant_matrixes[s->quant_sindex[i]],
1187 1188 1189
                                                       Al) < 0) {
                            av_log(s->avctx, AV_LOG_ERROR,
                                   "error y=%d x=%d\n", mb_y, mb_x);
1190
                            return AVERROR_INVALIDDATA;
Loren Merritt's avatar
Loren Merritt committed
1191 1192
                        }
                    }
1193 1194 1195 1196
                    av_dlog(s->avctx, "mb: %d %d processed\n", mb_y, mb_x);
                    av_dlog(s->avctx, "%d %d %d %d %d %d %d %d \n",
                            mb_x, mb_y, x, y, c, s->bottom_field,
                            (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1197 1198 1199 1200 1201 1202
                    if (++x == h) {
                        x = 0;
                        y++;
                    }
                }
            }
1203

1204
            handle_rstn(s, nb_components);
1205 1206 1207 1208 1209
        }
    }
    return 0;
}

1210 1211 1212
static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss,
                                            int se, int Ah, int Al)
{
Loren Merritt's avatar
Loren Merritt committed
1213 1214 1215
    int mb_x, mb_y;
    int EOBRUN = 0;
    int c = s->comp_index[0];
1216
    uint8_t *data = s->picture_ptr->data[c];
1217
    int linesize  = s->linesize[c];
Loren Merritt's avatar
Loren Merritt committed
1218
    int last_scan = 0;
1219
    int16_t *quant_matrix = s->quant_matrixes[s->quant_sindex[0]];
1220
    int bytes_per_pixel = 1 + (s->bits > 8);
Loren Merritt's avatar
Loren Merritt committed
1221

1222 1223 1224
    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);
1225 1226 1227
        return AVERROR_INVALIDDATA;
    }

1228 1229
    if (!Al) {
        s->coefs_finished[c] |= (1LL << (se + 1)) - (1LL << ss);
Loren Merritt's avatar
Loren Merritt committed
1230 1231 1232
        last_scan = !~s->coefs_finished[c];
    }

1233
    if (s->interlaced && s->bottom_field)
Loren Merritt's avatar
Loren Merritt committed
1234 1235
        data += linesize >> 1;

1236 1237
    s->restart_count = 0;

1238 1239 1240
    for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
        uint8_t *ptr     = data + (mb_y * linesize * 8 >> s->avctx->lowres);
        int block_idx    = mb_y * s->block_stride[c];
Diego Biurrun's avatar
Diego Biurrun committed
1241
        int16_t (*block)[64] = &s->blocks[c][block_idx];
1242 1243 1244
        uint8_t *last_nnz    = &s->last_nnz[c][block_idx];
        for (mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) {
                int ret;
1245 1246 1247
                if (s->restart_interval && !s->restart_count)
                    s->restart_count = s->restart_interval;

1248 1249 1250 1251 1252 1253 1254 1255 1256
                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);
1257
                    return AVERROR_INVALIDDATA;
1258 1259 1260 1261
                }

            if (last_scan) {
                    s->dsp.idct_put(ptr, linesize, *block);
1262 1263 1264
                    if (s->bits & 7)
                        shift_output(s, ptr, linesize);
                    ptr += bytes_per_pixel*8 >> s->avctx->lowres;
Loren Merritt's avatar
Loren Merritt committed
1265
            }
1266 1267
            if (handle_rstn(s, 0))
                EOBRUN = 0;
Loren Merritt's avatar
Loren Merritt committed
1268 1269 1270 1271 1272
        }
    }
    return 0;
}

1273
int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
1274
                        int mb_bitmask_size, const AVFrame *reference)
1275 1276
{
    int len, nb_components, i, h, v, predictor, point_transform;
1277
    int index, id, ret;
1278
    const int block_size = s->lossless ? 1 : 8;
1279 1280
    int ilv, prev_shift;

1281 1282 1283 1284 1285 1286 1287
    if (!s->got_picture) {
        av_log(s->avctx, AV_LOG_WARNING,
                "Can not process SOS before SOF, skipping\n");
        return -1;
    }

    av_assert0(s->picture_ptr->data[0]);
1288 1289 1290
    /* XXX: verify len field validity */
    len = get_bits(&s->gb, 16);
    nb_components = get_bits(&s->gb, 8);
1291 1292 1293
    if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
        av_log(s->avctx, AV_LOG_ERROR,
               "decode_sos: nb_components (%d) unsupported\n", nb_components);
1294
        return AVERROR_PATCHWELCOME;
1295
    }
1296
    if (len != 6 + 2 * nb_components) {
1297
        av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1298
        return AVERROR_INVALIDDATA;
1299
    }
1300
    for (i = 0; i < nb_components; i++) {
1301 1302 1303
        id = get_bits(&s->gb, 8) - 1;
        av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
        /* find component index */
1304
        for (index = 0; index < s->nb_components; index++)
1305 1306
            if (id == s->component_id[index])
                break;
1307 1308 1309
        if (index == s->nb_components) {
            av_log(s->avctx, AV_LOG_ERROR,
                   "decode_sos: index(%d) out of components\n", index);
1310
            return AVERROR_INVALIDDATA;
1311
        }
1312 1313 1314 1315
        /* 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;
1316

1317
        s->quant_sindex[i] = s->quant_index[index];
1318 1319 1320 1321
        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];

1322
        if(nb_components == 3 && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
Michael Niedermayer's avatar
Michael Niedermayer committed
1323
            index = (i+2)%3;
1324
        if(nb_components == 1 && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
1325
            index = (index+2)%3;
Michael Niedermayer's avatar
Michael Niedermayer committed
1326

1327 1328 1329 1330 1331 1332 1333 1334
        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;
1335
        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))
1336
            goto out_of_range;
1337 1338
    }

1339 1340
    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 */
1341
    if(s->avctx->codec_tag != AV_RL32("CJPG")){
1342 1343
        prev_shift      = get_bits(&s->gb, 4); /* Ah */
        point_transform = get_bits(&s->gb, 4); /* Al */
1344
    }else
1345
        prev_shift = point_transform = 0;
1346 1347 1348 1349 1350

    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);
1351
    } else if (!s->ls) { /* skip this for JPEG-LS */
1352 1353
        h = s->h_max / s->h_scount[0];
        v = s->v_max / s->v_scount[0];
1354 1355
        s->mb_width     = (s->width  + h * block_size - 1) / (h * block_size);
        s->mb_height    = (s->height + v * block_size - 1) / (v * block_size);
1356
        s->nb_blocks[0] = 1;
1357 1358
        s->h_scount[0]  = 1;
        s->v_scount[0]  = 1;
1359 1360
    }

1361 1362 1363
    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" : "",
1364
               predictor, point_transform, ilv, s->bits, s->mjpb_skiptosod,
1365
               s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), nb_components);
1366 1367 1368 1369 1370 1371


    /* 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);

1372 1373
next_field:
    for (i = 0; i < nb_components; i++)
1374
        s->last_dc[i] = (4 << s->bits);
1375

1376
    if (s->lossless) {
1377
        av_assert0(s->picture_ptr == s->picture);
1378 1379
        if (CONFIG_JPEGLS_DECODER && s->ls) {
//            for () {
1380 1381
//            reset_ls_coding_parameters(s, 0);

1382 1383 1384
            if ((ret = ff_jpegls_decode_picture(s, predictor,
                                                point_transform, ilv)) < 0)
                return ret;
1385 1386
        } else {
            if (s->rgb) {
1387
                if ((ret = ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform)) < 0)
1388
                    return ret;
1389
            } else {
1390
                if ((ret = ljpeg_decode_yuv_scan(s, predictor,
1391 1392
                                                 point_transform,
                                                 nb_components)) < 0)
1393
                    return ret;
1394 1395
            }
        }
1396 1397
    } else {
        if (s->progressive && predictor) {
1398
            av_assert0(s->picture_ptr == s->picture);
1399 1400
            if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor,
                                                        ilv, prev_shift,
1401
                                                        point_transform)) < 0)
1402
                return ret;
Loren Merritt's avatar
Loren Merritt committed
1403
        } else {
1404 1405
            if ((ret = mjpeg_decode_scan(s, nb_components,
                                         prev_shift, point_transform,
1406
                                         mb_bitmask, mb_bitmask_size, reference)) < 0)
1407
                return ret;
Loren Merritt's avatar
Loren Merritt committed
1408
        }
1409
    }
1410 1411 1412 1413 1414

    if (s->interlaced &&
        get_bits_left(&s->gb) > 32 &&
        show_bits(&s->gb, 8) == 0xFF) {
        GetBitContext bak = s->gb;
1415
        align_get_bits(&bak);
1416
        if (show_bits(&bak, 16) == 0xFFD1) {
1417
            av_log(s->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n");
1418 1419 1420 1421 1422 1423 1424 1425
            s->gb = bak;
            skip_bits(&s->gb, 16);
            s->bottom_field ^= 1;

            goto next_field;
        }
    }

1426 1427 1428 1429
    emms_c();
    return 0;
 out_of_range:
    av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1430
    return AVERROR_INVALIDDATA;
1431 1432 1433 1434 1435
}

static int mjpeg_decode_dri(MJpegDecodeContext *s)
{
    if (get_bits(&s->gb, 16) != 4)
1436
        return AVERROR_INVALIDDATA;
1437
    s->restart_interval = get_bits(&s->gb, 16);
1438 1439 1440
    s->restart_count    = 0;
    av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
           s->restart_interval);
1441 1442 1443 1444 1445 1446 1447 1448 1449

    return 0;
}

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

    len = get_bits(&s->gb, 16);
1450
    if (len < 6)
1451
        return AVERROR_INVALIDDATA;
1452
    if (8 * len > get_bits_left(&s->gb))
1453
        return AVERROR_INVALIDDATA;
1454

1455
    id   = get_bits_long(&s->gb, 32);
1456 1457
    len -= 6;

1458
    if (s->avctx->debug & FF_DEBUG_STARTCODE)
1459
        av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X len=%d\n", id, len);
1460

1461 1462 1463
    /* 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. */
1464
    if (id == AV_RB32("AVI1")) {
1465 1466 1467 1468 1469 1470 1471 1472
        /* structure:
            4bytes      AVI1
            1bytes      polarity
            1bytes      always zero
            4bytes      field_size
            4bytes      field_size_less_padding
        */
            s->buggy_avid = 1;
1473
        i = get_bits(&s->gb, 8); len--;
1474
        av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i);
1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485
#if 0
        skip_bits(&s->gb, 8);
        skip_bits(&s->gb, 32);
        skip_bits(&s->gb, 32);
        len -= 10;
#endif
        goto out;
    }

//    len -= 2;

1486
    if (id == AV_RB32("JFIF")) {
1487 1488
        int t_w, t_h, v1, v2;
        skip_bits(&s->gb, 8); /* the trailing zero-byte */
1489 1490
        v1 = get_bits(&s->gb, 8);
        v2 = get_bits(&s->gb, 8);
1491 1492
        skip_bits(&s->gb, 8);

1493 1494
        s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 16);
        s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16);
1495 1496

        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1497 1498 1499 1500 1501
            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);
1502 1503 1504

        t_w = get_bits(&s->gb, 8);
        t_h = get_bits(&s->gb, 8);
1505
        if (t_w && t_h) {
1506
            /* skip thumbnail */
1507 1508
            if (len -10 - (t_w * t_h * 3) > 0)
                len -= t_w * t_h * 3;
1509 1510 1511 1512 1513
        }
        len -= 10;
        goto out;
    }

1514
    if (id == AV_RB32("Adob") && (get_bits(&s->gb, 8) == 'e')) {
1515 1516 1517 1518 1519
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
            av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
        skip_bits(&s->gb, 16); /* version */
        skip_bits(&s->gb, 16); /* flags0 */
        skip_bits(&s->gb, 16); /* flags1 */
1520
        skip_bits(&s->gb,  8); /* transform */
1521 1522 1523 1524
        len -= 7;
        goto out;
    }

1525
    if (id == AV_RB32("LJIF")) {
1526
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1527 1528
            av_log(s->avctx, AV_LOG_INFO,
                   "Pegasus lossless jpeg header found\n");
1529
        skip_bits(&s->gb, 16); /* version ? */
1530 1531 1532
        skip_bits(&s->gb, 16); /* unknown always 0? */
        skip_bits(&s->gb, 16); /* unknown always 0? */
        skip_bits(&s->gb, 16); /* unknown always 0? */
1533
        switch (i=get_bits(&s->gb, 8)) {
1534
        case 1:
1535 1536
            s->rgb         = 1;
            s->pegasus_rct = 0;
1537 1538
            break;
        case 2:
1539 1540
            s->rgb         = 1;
            s->pegasus_rct = 1;
1541 1542
            break;
        default:
1543
            av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace %d\n", i);
1544 1545 1546 1547
        }
        len -= 9;
        goto out;
    }
1548 1549 1550 1551 1552 1553 1554
    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;
    }
1555 1556 1557 1558 1559 1560 1561
    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;
    }
1562

1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601
    /* 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;

        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;
    }

1602
    /* EXIF metadata */
1603
    if (s->start_code == APP1 && id == AV_RB32("Exif") && len >= 2) {
1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638
        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");
            return ret;
        }

        bytestream2_seek(&gbytes, ifd_offset, SEEK_SET);

        // read 0th IFD and store the metadata
        // (return values > 0 indicate the presence of subimage metadata)
        ret = ff_exif_decode_ifd(s->avctx, &gbytes, le, 0, &s->exif_metadata);
        if (ret < 0) {
            av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error decoding EXIF data\n");
            return ret;
        }

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

        goto out;
    }

1639
    /* Apple MJPEG-A */
1640 1641
    if ((s->start_code == APP1) && (len > (0x28 - 8))) {
        id   = get_bits_long(&s->gb, 32);
1642
        len -= 4;
1643
        /* Apple MJPEG-A */
1644
        if (id == AV_RB32("mjpg")) {
1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662
#if 0
            skip_bits(&s->gb, 32); /* field size */
            skip_bits(&s->gb, 32); /* pad field size */
            skip_bits(&s->gb, 32); /* next off */
            skip_bits(&s->gb, 32); /* quant off */
            skip_bits(&s->gb, 32); /* huff off */
            skip_bits(&s->gb, 32); /* image off */
            skip_bits(&s->gb, 32); /* scan off */
            skip_bits(&s->gb, 32); /* data off */
#endif
            if (s->avctx->debug & FF_DEBUG_PICT_INFO)
                av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
        }
    }

out:
    /* slow but needed for extreme adobe jpegs */
    if (len < 0)
1663 1664 1665
        av_log(s->avctx, AV_LOG_ERROR,
               "mjpeg: error, decode_app parser read over the end\n");
    while (--len > 0)
1666 1667 1668 1669 1670 1671 1672 1673
        skip_bits(&s->gb, 8);

    return 0;
}

static int mjpeg_decode_com(MJpegDecodeContext *s)
{
    int len = get_bits(&s->gb, 16);
1674
    if (len >= 2 && 8 * len - 16 <= get_bits_left(&s->gb)) {
1675 1676 1677 1678 1679
        char *cbuf = av_malloc(len - 1);
        if (cbuf) {
            int i;
            for (i = 0; i < len - 2; i++)
                cbuf[i] = get_bits(&s->gb, 8);
1680 1681
            if (i > 0 && cbuf[i - 1] == '\n')
                cbuf[i - 1] = 0;
1682 1683 1684
            else
                cbuf[i] = 0;

1685
            if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1686
                av_log(s->avctx, AV_LOG_INFO, "comment: '%s'\n", cbuf);
1687 1688

            /* buggy avid, it puts EOI only at every 10th frame */
1689
            if (!strncmp(cbuf, "AVID", 4)) {
1690
                s->buggy_avid = 1;
1691 1692
                if (len > 14 && cbuf[12] == 1) /* 1 - NTSC, 2 - PAL */
                    s->interlace_polarity = 1;
1693 1694
            } else if (!strcmp(cbuf, "CS=ITU601"))
                s->cs_itu601 = 1;
1695 1696
            else if ((!strncmp(cbuf, "Intel(R) JPEG Library, version 1", 32)) ||
                     (!strncmp(cbuf, "Metasoft MJPEG Codec", 20)))
1697
                s->flipped = 1;
1698 1699 1700 1701 1702 1703 1704 1705 1706 1707

            av_free(cbuf);
        }
    }

    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
1708
static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
1709
{
Michael Niedermayer's avatar
Michael Niedermayer committed
1710
    const uint8_t *buf_ptr;
1711 1712
    unsigned int v, v2;
    int val;
1713
    int skipped = 0;
1714 1715

    buf_ptr = *pbuf_ptr;
1716
    while (buf_end - buf_ptr > 1) {
1717
        v  = *buf_ptr++;
1718 1719 1720 1721 1722 1723 1724
        v2 = *buf_ptr;
        if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
            val = *buf_ptr++;
            goto found;
        }
        skipped++;
    }
1725
    buf_ptr = buf_end;
1726 1727
    val = -1;
found:
1728
    av_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
1729 1730 1731 1732
    *pbuf_ptr = buf_ptr;
    return val;
}

1733 1734
int ff_mjpeg_find_marker(MJpegDecodeContext *s,
                         const uint8_t **buf_ptr, const uint8_t *buf_end,
1735 1736
                         const uint8_t **unescaped_buf_ptr,
                         int *unescaped_buf_size)
1737 1738
{
    int start_code;
1739
    start_code = find_marker(buf_ptr, buf_end);
1740

1741 1742 1743
    av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr);
    if (!s->buffer)
        return AVERROR(ENOMEM);
1744

1745 1746 1747 1748
    /* unescape buffer of SOS, use special treatment for JPEG-LS */
    if (start_code == SOS && !s->ls) {
        const uint8_t *src = *buf_ptr;
        uint8_t *dst = s->buffer;
1749

1750 1751
        while (src < buf_end) {
            uint8_t x = *(src++);
1752

1753
            *(dst++) = x;
1754
            if (s->avctx->codec_id != AV_CODEC_ID_THP) {
1755 1756 1757
                if (x == 0xff) {
                    while (src < buf_end && x == 0xff)
                        x = *(src++);
1758

1759 1760 1761 1762
                    if (x >= 0xd0 && x <= 0xd7)
                        *(dst++) = x;
                    else if (x)
                        break;
1763
                }
1764 1765 1766 1767
            }
        }
        *unescaped_buf_ptr  = s->buffer;
        *unescaped_buf_size = dst - s->buffer;
1768 1769
        memset(s->buffer + *unescaped_buf_size, 0,
               FF_INPUT_BUFFER_PADDING_SIZE);
1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786

        av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %td bytes\n",
               (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) {
1787
                    t -= FFMIN(2, t);
1788
                    break;
1789
                }
1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808
            }
        }
        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);
            if (x == 0xFF) {
                x = src[b++];
                put_bits(&pb, 7, x);
                bit_count--;
            }
        }
        flush_put_bits(&pb);

        *unescaped_buf_ptr  = dst;
        *unescaped_buf_size = (bit_count + 7) >> 3;
1809 1810
        memset(s->buffer + *unescaped_buf_size, 0,
               FF_INPUT_BUFFER_PADDING_SIZE);
1811 1812 1813 1814
    } else {
        *unescaped_buf_ptr  = *buf_ptr;
        *unescaped_buf_size = buf_end - *buf_ptr;
    }
1815 1816 1817 1818

    return start_code;
}

1819
int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
1820
                          AVPacket *avpkt)
1821
{
1822
    AVFrame     *frame = data;
1823
    const uint8_t *buf = avpkt->data;
1824
    int buf_size       = avpkt->size;
1825 1826 1827
    MJpegDecodeContext *s = avctx->priv_data;
    const uint8_t *buf_end, *buf_ptr;
    const uint8_t *unescaped_buf_ptr;
1828
    int hshift, vshift;
1829 1830
    int unescaped_buf_size;
    int start_code;
1831
    int i, index;
1832
    int ret = 0;
1833

1834
    av_dict_free(&s->exif_metadata);
1835
    av_freep(&s->stereo3d);
1836

1837 1838 1839 1840 1841
    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,
1842 1843 1844 1845
                                          &unescaped_buf_ptr,
                                          &unescaped_buf_size);
        /* EOF */
        if (start_code < 0) {
1846
            break;
1847 1848 1849
        } 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",
1850
                   start_code, unescaped_buf_size, buf_size);
1851
            return AVERROR_INVALIDDATA;
1852 1853 1854
        }
        av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%td\n",
               start_code, buf_end - buf_ptr);
1855

1856 1857 1858
        ret = init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);

        if (ret < 0) {
1859 1860 1861
            av_log(avctx, AV_LOG_ERROR, "invalid buffer\n");
            goto fail;
        }
1862

1863 1864 1865
        s->start_code = start_code;
        if (s->avctx->debug & FF_DEBUG_STARTCODE)
            av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1866

1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877
        /* process markers */
        if (start_code >= 0xd0 && start_code <= 0xd7)
            av_log(avctx, AV_LOG_DEBUG,
                   "restart marker: %d\n", start_code & 0x0f);
            /* APP fields */
        else if (start_code >= APP0 && start_code <= APP15)
            mjpeg_decode_app(s);
            /* Comment */
        else if (start_code == COM)
            mjpeg_decode_com(s);

1878 1879
        ret = -1;

1880 1881 1882 1883 1884
        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);
        }
1885

1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897
        switch (start_code) {
        case SOI:
            s->restart_interval = 0;
            s->restart_count    = 0;
            /* nothing to do on SOI */
            break;
        case DQT:
            ff_mjpeg_decode_dqt(s);
            break;
        case DHT:
            if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
                av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
1898
                goto fail;
1899 1900 1901 1902 1903 1904 1905 1906
            }
            break;
        case SOF0:
        case SOF1:
            s->lossless    = 0;
            s->ls          = 0;
            s->progressive = 0;
            if ((ret = ff_mjpeg_decode_sof(s)) < 0)
1907
                goto fail;
1908 1909 1910 1911 1912 1913
            break;
        case SOF2:
            s->lossless    = 0;
            s->ls          = 0;
            s->progressive = 1;
            if ((ret = ff_mjpeg_decode_sof(s)) < 0)
1914
                goto fail;
1915 1916 1917 1918 1919 1920
            break;
        case SOF3:
            s->lossless    = 1;
            s->ls          = 0;
            s->progressive = 0;
            if ((ret = ff_mjpeg_decode_sof(s)) < 0)
1921
                goto fail;
1922 1923 1924 1925 1926 1927
            break;
        case SOF48:
            s->lossless    = 1;
            s->ls          = 1;
            s->progressive = 0;
            if ((ret = ff_mjpeg_decode_sof(s)) < 0)
1928
                goto fail;
1929 1930 1931 1932
            break;
        case LSE:
            if (!CONFIG_JPEGLS_DECODER ||
                (ret = ff_jpegls_decode_lse(s)) < 0)
1933
                goto fail;
1934 1935
            break;
        case EOI:
1936
eoi_parser:
1937
            s->cur_scan = 0;
1938 1939 1940
            if (!s->got_picture) {
                av_log(avctx, AV_LOG_WARNING,
                       "Found EOI before any SOF, ignoring\n");
1941 1942
                break;
            }
1943 1944 1945 1946
            if (s->interlaced) {
                s->bottom_field ^= 1;
                /* if not bottom field, do not output image yet */
                if (s->bottom_field == !s->interlace_polarity)
1947
                    break;
1948
            }
1949
            if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
1950 1951
                return ret;
            *got_frame = 1;
1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962
            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);
1963
                }
1964

1965 1966
                if(avctx->debug & FF_DEBUG_QP)
                    av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);
1967
            }
1968

1969 1970
            goto the_end;
        case SOS:
1971
            s->cur_scan++;
1972
            if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&
1973
                (avctx->err_recognition & AV_EF_EXPLODE))
1974
                goto fail;
1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991
            break;
        case DRI:
            mjpeg_decode_dri(s);
            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;
1992
        }
1993 1994 1995 1996 1997 1998

        /* 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));
1999
    }
2000
    if (s->got_picture && s->cur_scan) {
2001 2002 2003
        av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
        goto eoi_parser;
    }
2004
    av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
2005
    return AVERROR_INVALIDDATA;
2006
fail:
2007
    s->got_picture = 0;
2008
    return ret;
2009
the_end:
2010 2011
    if (s->upscale_h) {
        uint8_t *line = s->picture_ptr->data[s->upscale_h];
2012 2013 2014 2015
        av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
                   avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||
                   avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
                   avctx->pix_fmt == AV_PIX_FMT_YUV440P);
2016 2017 2018 2019 2020 2021 2022 2023
        for (i = 0; i < s->chroma_height; i++) {
            for (index = s->width - 1; index; index--)
                line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
            line += s->linesize[s->upscale_h];
        }
    }
    if (s->upscale_v) {
        uint8_t *dst = &((uint8_t *)s->picture_ptr->data[s->upscale_v])[(s->height - 1) * s->linesize[s->upscale_v]];
2024 2025 2026
        int w;
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
        w = s->width >> hshift;
2027 2028 2029 2030
        av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
                   avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||
                   avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
                   avctx->pix_fmt == AV_PIX_FMT_YUV422P);
2031 2032 2033 2034
        for (i = s->height - 1; i; i--) {
            uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[s->upscale_v])[i / 2 * s->linesize[s->upscale_v]];
            uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[s->upscale_v])[(i + 1) / 2 * s->linesize[s->upscale_v]];
            if (src1 == src2) {
2035
                memcpy(dst, src1, w);
2036
            } else {
2037
                for (index = 0; index < w; index++)
2038 2039 2040 2041 2042
                    dst[index] = (src1[index] + src2[index]) >> 1;
            }
            dst -= s->linesize[s->upscale_v];
        }
    }
2043
    if (s->flipped) {
2044
        int j;
2045 2046 2047
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
        for (index=0; index<4; index++) {
            uint8_t *dst = s->picture_ptr->data[index];
2048 2049
            int w = s->picture_ptr->width;
            int h = s->picture_ptr->height;
2050
            if(index && index<3){
2051 2052
                w = FF_CEIL_RSHIFT(w, hshift);
                h = FF_CEIL_RSHIFT(h, vshift);
2053 2054
            }
            if(dst){
2055
                uint8_t *dst2 = dst + s->picture_ptr->linesize[index]*(h-1);
2056 2057 2058
                for (i=0; i<h/2; i++) {
                    for (j=0; j<w; j++)
                        FFSWAP(int, dst[j], dst2[j]);
2059 2060
                    dst  += s->picture_ptr->linesize[index];
                    dst2 -= s->picture_ptr->linesize[index];
2061 2062 2063 2064 2065
                }
            }
        }
    }

2066 2067 2068 2069 2070 2071 2072 2073 2074
    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);
    }

2075 2076 2077
    av_dict_copy(avpriv_frame_get_metadatap(data), s->exif_metadata, 0);
    av_dict_free(&s->exif_metadata);

2078
    av_log(avctx, AV_LOG_DEBUG, "decode frame unused %td bytes\n",
2079 2080
           buf_end - buf_ptr);
//  return buf_end - buf_ptr;
2081 2082 2083
    return buf_ptr - buf;
}

2084
av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
2085 2086 2087 2088
{
    MJpegDecodeContext *s = avctx->priv_data;
    int i, j;

2089 2090 2091 2092
    if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_number) {
        av_log(avctx, AV_LOG_INFO, "Single field\n");
    }

2093 2094 2095 2096
    if (s->picture) {
        av_frame_free(&s->picture);
        s->picture_ptr = NULL;
    } else if (s->picture_ptr)
2097
        av_frame_unref(s->picture_ptr);
2098

2099
    av_freep(&s->buffer);
2100
    av_freep(&s->stereo3d);
2101
    av_freep(&s->ljpeg_buffer);
2102
    s->ljpeg_buffer_size = 0;
2103

2104 2105
    for (i = 0; i < 3; i++) {
        for (j = 0; j < 4; j++)
2106
            ff_free_vlc(&s->vlcs[i][j]);
2107
    }
2108
    for (i = 0; i < MAX_COMPONENTS; i++) {
Loren Merritt's avatar
Loren Merritt committed
2109 2110 2111
        av_freep(&s->blocks[i]);
        av_freep(&s->last_nnz[i]);
    }
2112
    av_dict_free(&s->exif_metadata);
2113 2114 2115
    return 0;
}

2116 2117 2118 2119 2120 2121
static void decode_flush(AVCodecContext *avctx)
{
    MJpegDecodeContext *s = avctx->priv_data;
    s->got_picture = 0;
}

2122
#if CONFIG_MJPEG_DECODER
2123 2124 2125
#define OFFSET(x) offsetof(MJpegDecodeContext, x)
#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
static const AVOption options[] = {
2126
    { "extern_huff", "Use external huffman table.",
2127
      OFFSET(extern_huff), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VD },
2128 2129 2130 2131 2132 2133 2134 2135 2136 2137
    { NULL },
};

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

2138
AVCodec ff_mjpeg_decoder = {
2139
    .name           = "mjpeg",
2140
    .long_name      = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
2141
    .type           = AVMEDIA_TYPE_VIDEO,
2142
    .id             = AV_CODEC_ID_MJPEG,
2143 2144 2145 2146
    .priv_data_size = sizeof(MJpegDecodeContext),
    .init           = ff_mjpeg_decode_init,
    .close          = ff_mjpeg_decode_end,
    .decode         = ff_mjpeg_decode_frame,
2147
    .flush          = decode_flush,
2148
    .capabilities   = CODEC_CAP_DR1,
Michael Niedermayer's avatar
Michael Niedermayer committed
2149
    .max_lowres     = 3,
2150
    .priv_class     = &mjpegdec_class,
2151
};
2152 2153
#endif
#if CONFIG_THP_DECODER
2154
AVCodec ff_thp_decoder = {
2155
    .name           = "thp",
2156
    .long_name      = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
2157
    .type           = AVMEDIA_TYPE_VIDEO,
2158
    .id             = AV_CODEC_ID_THP,
2159 2160 2161 2162
    .priv_data_size = sizeof(MJpegDecodeContext),
    .init           = ff_mjpeg_decode_init,
    .close          = ff_mjpeg_decode_end,
    .decode         = ff_mjpeg_decode_frame,
2163
    .flush          = decode_flush,
2164
    .capabilities   = CODEC_CAP_DR1,
Michael Niedermayer's avatar
Michael Niedermayer committed
2165
    .max_lowres     = 3,
2166
};
2167
#endif