git.sesse.net Git - ffmpeg/blob - libavcodec/mjpegdec.c

   1 /*
   2  * MJPEG decoder
   3  * Copyright (c) 2000, 2001 Fabrice Bellard
   4  * Copyright (c) 2003 Alex Beregszaszi
   5  * Copyright (c) 2003-2004 Michael Niedermayer
   6  *
   7  * Support for external huffman table, various fixes (AVID workaround),
   8  * aspecting, new decode_frame mechanism and apple mjpeg-b support
   9  *                                  by Alex Beregszaszi
  10  *
  11  * This file is part of FFmpeg.
  12  *
  13  * FFmpeg is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU Lesser General Public
  15  * License as published by the Free Software Foundation; either
  16  * version 2.1 of the License, or (at your option) any later version.
  17  *
  18  * FFmpeg is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21  * Lesser General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU Lesser General Public
  24  * License along with FFmpeg; if not, write to the Free Software
  25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  26  */
  27
  28 /**
  29  * @file
  30  * MJPEG decoder.
  31  */
  32
  33 #include "libavutil/imgutils.h"
  34 #include "libavutil/avassert.h"
  35 #include "libavutil/opt.h"
  36 #include "avcodec.h"
  37 #include "blockdsp.h"
  38 #include "copy_block.h"
  39 #include "hwaccel.h"
  40 #include "idctdsp.h"
  41 #include "internal.h"
  42 #include "jpegtables.h"
  43 #include "mjpeg.h"
  44 #include "mjpegdec.h"
  45 #include "jpeglsdec.h"
  46 #include "put_bits.h"
  47 #include "tiff.h"
  48 #include "exif.h"
  49 #include "bytestream.h"
  50
  51
  52 static int build_vlc(VLC *vlc, const uint8_t *bits_table,
  53                      const uint8_t *val_table, int nb_codes,
  54                      int use_static, int is_ac)
  55 {
  56     uint8_t huff_size[256] = { 0 };
  57     uint16_t huff_code[256];
  58     uint16_t huff_sym[256];
  59     int i;
  60
  61     av_assert0(nb_codes <= 256);
  62
  63     ff_mjpeg_build_huffman_codes(huff_size, huff_code, bits_table, val_table);
  64
  65     for (i = 0; i < 256; i++)
  66         huff_sym[i] = i + 16 * is_ac;
  67
  68     if (is_ac)
  69         huff_sym[0] = 16 * 256;
  70
  71     return ff_init_vlc_sparse(vlc, 9, nb_codes, huff_size, 1, 1,
  72                               huff_code, 2, 2, huff_sym, 2, 2, use_static);
  73 }
  74
  75 static int build_basic_mjpeg_vlc(MJpegDecodeContext *s)
  76 {
  77     int ret;
  78
  79     if ((ret = build_vlc(&s->vlcs[0][0], avpriv_mjpeg_bits_dc_luminance,
  80                          avpriv_mjpeg_val_dc, 12, 0, 0)) < 0)
  81         return ret;
  82
  83     if ((ret = build_vlc(&s->vlcs[0][1], avpriv_mjpeg_bits_dc_chrominance,
  84                          avpriv_mjpeg_val_dc, 12, 0, 0)) < 0)
  85         return ret;
  86
  87     if ((ret = build_vlc(&s->vlcs[1][0], avpriv_mjpeg_bits_ac_luminance,
  88                          avpriv_mjpeg_val_ac_luminance, 251, 0, 1)) < 0)
  89         return ret;
  90
  91     if ((ret = build_vlc(&s->vlcs[1][1], avpriv_mjpeg_bits_ac_chrominance,
  92                          avpriv_mjpeg_val_ac_chrominance, 251, 0, 1)) < 0)
  93         return ret;
  94
  95     if ((ret = build_vlc(&s->vlcs[2][0], avpriv_mjpeg_bits_ac_luminance,
  96                          avpriv_mjpeg_val_ac_luminance, 251, 0, 0)) < 0)
  97         return ret;
  98
  99     if ((ret = build_vlc(&s->vlcs[2][1], avpriv_mjpeg_bits_ac_chrominance,
 100                          avpriv_mjpeg_val_ac_chrominance, 251, 0, 0)) < 0)
 101         return ret;
 102
 103
 104     return 0;
 105 }
 106
 107 static void parse_avid(MJpegDecodeContext *s, uint8_t *buf, int len)
 108 {
 109     s->buggy_avid = 1;
 110     if (len > 14 && buf[12] == 1) /* 1 - NTSC */
 111         s->interlace_polarity = 1;
 112     if (len > 14 && buf[12] == 2) /* 2 - PAL */
 113         s->interlace_polarity = 0;
 114     if (s->avctx->debug & FF_DEBUG_PICT_INFO)
 115         av_log(s->avctx, AV_LOG_INFO, "AVID: len:%d %d\n", len, len > 14 ? buf[12] : -1);
 116 }
 117
 118 static void init_idct(AVCodecContext *avctx)
 119 {
 120     MJpegDecodeContext *s = avctx->priv_data;
 121
 122     ff_idctdsp_init(&s->idsp, avctx);
 123     ff_init_scantable(s->idsp.idct_permutation, &s->scantable,
 124                       ff_zigzag_direct);
 125 }
 126
 127 av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)
 128 {
 129     MJpegDecodeContext *s = avctx->priv_data;
 130     int ret;
 131
 132     if (!s->picture_ptr) {
 133         s->picture = av_frame_alloc();
 134         if (!s->picture)
 135             return AVERROR(ENOMEM);
 136         s->picture_ptr = s->picture;
 137     }
 138
 139     s->avctx = avctx;
 140     ff_blockdsp_init(&s->bdsp, avctx);
 141     ff_hpeldsp_init(&s->hdsp, avctx->flags);
 142     init_idct(avctx);
 143     s->buffer_size   = 0;
 144     s->buffer        = NULL;
 145     s->start_code    = -1;
 146     s->first_picture = 1;
 147     s->got_picture   = 0;
 148     s->org_height    = avctx->coded_height;
 149     avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
 150     avctx->colorspace = AVCOL_SPC_BT470BG;
 151     s->hwaccel_pix_fmt = s->hwaccel_sw_pix_fmt = AV_PIX_FMT_NONE;
 152
 153     if ((ret = build_basic_mjpeg_vlc(s)) < 0)
 154         return ret;
 155
 156     if (s->extern_huff) {
 157         av_log(avctx, AV_LOG_INFO, "using external huffman table\n");
 158         if ((ret = init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8)) < 0)
 159             return ret;
 160         if (ff_mjpeg_decode_dht(s)) {
 161             av_log(avctx, AV_LOG_ERROR,
 162                    "error using external huffman table, switching back to internal\n");
 163             build_basic_mjpeg_vlc(s);
 164         }
 165     }
 166     if (avctx->field_order == AV_FIELD_BB) { /* quicktime icefloe 019 */
 167         s->interlace_polarity = 1;           /* bottom field first */
 168         av_log(avctx, AV_LOG_DEBUG, "bottom field first\n");
 169     } else if (avctx->field_order == AV_FIELD_UNKNOWN) {
 170         if (avctx->codec_tag == AV_RL32("MJPG"))
 171             s->interlace_polarity = 1;
 172     }
 173
 174     if (   avctx->extradata_size > 8
 175         && AV_RL32(avctx->extradata) == 0x2C
 176         && AV_RL32(avctx->extradata+4) == 0x18) {
 177         parse_avid(s, avctx->extradata, avctx->extradata_size);
 178     }
 179
 180     if (avctx->codec->id == AV_CODEC_ID_AMV)
 181         s->flipped = 1;
 182
 183     return 0;
 184 }
 185
 186
 187 /* quantize tables */
 188 int ff_mjpeg_decode_dqt(MJpegDecodeContext *s)
 189 {
 190     int len, index, i;
 191
 192     len = get_bits(&s->gb, 16) - 2;
 193
 194     if (8*len > get_bits_left(&s->gb)) {
 195         av_log(s->avctx, AV_LOG_ERROR, "dqt: len %d is too large\n", len);
 196         return AVERROR_INVALIDDATA;
 197     }
 198
 199     while (len >= 65) {
 200         int pr = get_bits(&s->gb, 4);
 201         if (pr > 1) {
 202             av_log(s->avctx, AV_LOG_ERROR, "dqt: invalid precision\n");
 203             return AVERROR_INVALIDDATA;
 204         }
 205         index = get_bits(&s->gb, 4);
 206         if (index >= 4)
 207             return -1;
 208         av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index);
 209         /* read quant table */
 210         for (i = 0; i < 64; i++) {
 211             s->quant_matrixes[index][i] = get_bits(&s->gb, pr ? 16 : 8);
 212             if (s->quant_matrixes[index][i] == 0) {
 213                 av_log(s->avctx, AV_LOG_ERROR, "dqt: 0 quant value\n");
 214                 return AVERROR_INVALIDDATA;
 215             }
 216         }
 217
 218         // XXX FIXME fine-tune, and perhaps add dc too
 219         s->qscale[index] = FFMAX(s->quant_matrixes[index][1],
 220                                  s->quant_matrixes[index][8]) >> 1;
 221         av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n",
 222                index, s->qscale[index]);
 223         len -= 1 + 64 * (1+pr);
 224     }
 225     return 0;
 226 }
 227
 228 /* decode huffman tables and build VLC decoders */
 229 int ff_mjpeg_decode_dht(MJpegDecodeContext *s)
 230 {
 231     int len, index, i, class, n, v, code_max;
 232     uint8_t bits_table[17];
 233     uint8_t val_table[256];
 234     int ret = 0;
 235
 236     len = get_bits(&s->gb, 16) - 2;
 237
 238     if (8*len > get_bits_left(&s->gb)) {
 239         av_log(s->avctx, AV_LOG_ERROR, "dht: len %d is too large\n", len);
 240         return AVERROR_INVALIDDATA;
 241     }
 242
 243     while (len > 0) {
 244         if (len < 17)
 245             return AVERROR_INVALIDDATA;
 246         class = get_bits(&s->gb, 4);
 247         if (class >= 2)
 248             return AVERROR_INVALIDDATA;
 249         index = get_bits(&s->gb, 4);
 250         if (index >= 4)
 251             return AVERROR_INVALIDDATA;
 252         n = 0;
 253         for (i = 1; i <= 16; i++) {
 254             bits_table[i] = get_bits(&s->gb, 8);
 255             n += bits_table[i];
 256         }
 257         len -= 17;
 258         if (len < n || n > 256)
 259             return AVERROR_INVALIDDATA;
 260
 261         code_max = 0;
 262         for (i = 0; i < n; i++) {
 263             v = get_bits(&s->gb, 8);
 264             if (v > code_max)
 265                 code_max = v;
 266             val_table[i] = v;
 267         }
 268         len -= n;
 269
 270         /* build VLC and flush previous vlc if present */
 271         ff_free_vlc(&s->vlcs[class][index]);
 272         av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
 273                class, index, code_max + 1);
 274         if ((ret = build_vlc(&s->vlcs[class][index], bits_table, val_table,
 275                              code_max + 1, 0, class > 0)) < 0)
 276             return ret;
 277
 278         if (class > 0) {
 279             ff_free_vlc(&s->vlcs[2][index]);
 280             if ((ret = build_vlc(&s->vlcs[2][index], bits_table, val_table,
 281                                  code_max + 1, 0, 0)) < 0)
 282                 return ret;
 283         }
 284
 285         for (i = 0; i < 16; i++)
 286             s->raw_huffman_lengths[class][index][i] = bits_table[i + 1];
 287         for (i = 0; i < 256; i++)
 288             s->raw_huffman_values[class][index][i] = val_table[i];
 289     }
 290     return 0;
 291 }
 292
 293 int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
 294 {
 295     int len, nb_components, i, width, height, bits, ret, size_change;
 296     unsigned pix_fmt_id;
 297     int h_count[MAX_COMPONENTS] = { 0 };
 298     int v_count[MAX_COMPONENTS] = { 0 };
 299
 300     s->cur_scan = 0;
 301     memset(s->upscale_h, 0, sizeof(s->upscale_h));
 302     memset(s->upscale_v, 0, sizeof(s->upscale_v));
 303
 304     /* XXX: verify len field validity */
 305     len     = get_bits(&s->gb, 16);
 306     bits    = get_bits(&s->gb, 8);
 307
 308     if (bits > 16 || bits < 1) {
 309         av_log(s->avctx, AV_LOG_ERROR, "bits %d is invalid\n", bits);
 310         return AVERROR_INVALIDDATA;
 311     }
 312
 313     if (s->avctx->bits_per_raw_sample != bits) {
 314         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);
 315         s->avctx->bits_per_raw_sample = bits;
 316         init_idct(s->avctx);
 317     }
 318     if (s->pegasus_rct)
 319         bits = 9;
 320     if (bits == 9 && !s->pegasus_rct)
 321         s->rct  = 1;    // FIXME ugly
 322
 323     if(s->lossless && s->avctx->lowres){
 324         av_log(s->avctx, AV_LOG_ERROR, "lowres is not possible with lossless jpeg\n");
 325         return -1;
 326     }
 327
 328     height = get_bits(&s->gb, 16);
 329     width  = get_bits(&s->gb, 16);
 330
 331     // HACK for odd_height.mov
 332     if (s->interlaced && s->width == width && s->height == height + 1)
 333         height= s->height;
 334
 335     av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
 336     if (av_image_check_size(width, height, 0, s->avctx) < 0)
 337         return AVERROR_INVALIDDATA;
 338     if (s->buf_size && (width + 7) / 8 * ((height + 7) / 8) > s->buf_size * 4LL)
 339         return AVERROR_INVALIDDATA;
 340
 341     nb_components = get_bits(&s->gb, 8);
 342     if (nb_components <= 0 ||
 343         nb_components > MAX_COMPONENTS)
 344         return -1;
 345     if (s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
 346         if (nb_components != s->nb_components) {
 347             av_log(s->avctx, AV_LOG_ERROR,
 348                    "nb_components changing in interlaced picture\n");
 349             return AVERROR_INVALIDDATA;
 350         }
 351     }
 352     if (s->ls && !(bits <= 8 || nb_components == 1)) {
 353         avpriv_report_missing_feature(s->avctx,
 354                                       "JPEG-LS that is not <= 8 "
 355                                       "bits/component or 16-bit gray");
 356         return AVERROR_PATCHWELCOME;
 357     }
 358     s->nb_components = nb_components;
 359     s->h_max         = 1;
 360     s->v_max         = 1;
 361     for (i = 0; i < nb_components; i++) {
 362         /* component id */
 363         s->component_id[i] = get_bits(&s->gb, 8) - 1;
 364         h_count[i]         = get_bits(&s->gb, 4);
 365         v_count[i]         = get_bits(&s->gb, 4);
 366         /* compute hmax and vmax (only used in interleaved case) */
 367         if (h_count[i] > s->h_max)
 368             s->h_max = h_count[i];
 369         if (v_count[i] > s->v_max)
 370             s->v_max = v_count[i];
 371         s->quant_index[i] = get_bits(&s->gb, 8);
 372         if (s->quant_index[i] >= 4) {
 373             av_log(s->avctx, AV_LOG_ERROR, "quant_index is invalid\n");
 374             return AVERROR_INVALIDDATA;
 375         }
 376         if (!h_count[i] || !v_count[i]) {
 377             av_log(s->avctx, AV_LOG_ERROR,
 378                    "Invalid sampling factor in component %d %d:%d\n",
 379                    i, h_count[i], v_count[i]);
 380             return AVERROR_INVALIDDATA;
 381         }
 382
 383         av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n",
 384                i, h_count[i], v_count[i],
 385                s->component_id[i], s->quant_index[i]);
 386     }
 387     if (   nb_components == 4
 388         && s->component_id[0] == 'C' - 1
 389         && s->component_id[1] == 'M' - 1
 390         && s->component_id[2] == 'Y' - 1
 391         && s->component_id[3] == 'K' - 1)
 392         s->adobe_transform = 0;
 393
 394     if (s->ls && (s->h_max > 1 || s->v_max > 1)) {
 395         avpriv_report_missing_feature(s->avctx, "Subsampling in JPEG-LS");
 396         return AVERROR_PATCHWELCOME;
 397     }
 398
 399
 400     /* if different size, realloc/alloc picture */
 401     if (width != s->width || height != s->height || bits != s->bits ||
 402         memcmp(s->h_count, h_count, sizeof(h_count))                ||
 403         memcmp(s->v_count, v_count, sizeof(v_count))) {
 404         size_change = 1;
 405
 406         s->width      = width;
 407         s->height     = height;
 408         s->bits       = bits;
 409         memcpy(s->h_count, h_count, sizeof(h_count));
 410         memcpy(s->v_count, v_count, sizeof(v_count));
 411         s->interlaced = 0;
 412         s->got_picture = 0;
 413
 414         /* test interlaced mode */
 415         if (s->first_picture   &&
 416             (s->multiscope != 2 || s->avctx->time_base.den >= 25 * s->avctx->time_base.num) &&
 417             s->org_height != 0 &&
 418             s->height < ((s->org_height * 3) / 4)) {
 419             s->interlaced                    = 1;
 420             s->bottom_field                  = s->interlace_polarity;
 421             s->picture_ptr->interlaced_frame = 1;
 422             s->picture_ptr->top_field_first  = !s->interlace_polarity;
 423             height *= 2;
 424         }
 425
 426         ret = ff_set_dimensions(s->avctx, width, height);
 427         if (ret < 0)
 428             return ret;
 429
 430         s->first_picture = 0;
 431     } else {
 432         size_change = 0;
 433     }
 434
 435     if (s->got_picture && s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
 436         if (s->progressive) {
 437             avpriv_request_sample(s->avctx, "progressively coded interlaced picture");
 438             return AVERROR_INVALIDDATA;
 439         }
 440     } else{
 441         if (s->v_max == 1 && s->h_max == 1 && s->lossless==1 && (nb_components==3 || nb_components==4))
 442             s->rgb = 1;
 443         else if (!s->lossless)
 444             s->rgb = 0;
 445     /* XXX: not complete test ! */
 446     pix_fmt_id = ((unsigned)s->h_count[0] << 28) | (s->v_count[0] << 24) |
 447                  (s->h_count[1] << 20) | (s->v_count[1] << 16) |
 448                  (s->h_count[2] << 12) | (s->v_count[2] <<  8) |
 449                  (s->h_count[3] <<  4) |  s->v_count[3];
 450     av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);
 451     /* NOTE we do not allocate pictures large enough for the possible
 452      * padding of h/v_count being 4 */
 453     if (!(pix_fmt_id & 0xD0D0D0D0))
 454         pix_fmt_id -= (pix_fmt_id & 0xF0F0F0F0) >> 1;
 455     if (!(pix_fmt_id & 0x0D0D0D0D))
 456         pix_fmt_id -= (pix_fmt_id & 0x0F0F0F0F) >> 1;
 457
 458     for (i = 0; i < 8; i++) {
 459         int j = 6 + (i&1) - (i&6);
 460         int is = (pix_fmt_id >> (4*i)) & 0xF;
 461         int js = (pix_fmt_id >> (4*j)) & 0xF;
 462
 463         if (is == 1 && js != 2 && (i < 2 || i > 5))
 464             js = (pix_fmt_id >> ( 8 + 4*(i&1))) & 0xF;
 465         if (is == 1 && js != 2 && (i < 2 || i > 5))
 466             js = (pix_fmt_id >> (16 + 4*(i&1))) & 0xF;
 467
 468         if (is == 1 && js == 2) {
 469             if (i & 1) s->upscale_h[j/2] = 1;
 470             else       s->upscale_v[j/2] = 1;
 471         }
 472     }
 473
 474     switch (pix_fmt_id) {
 475     case 0x11111100:
 476         if (s->rgb)
 477             s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_BGR48;
 478         else {
 479             if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
 480                 s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_GBRP : AV_PIX_FMT_GBRP16;
 481             } else {
 482                 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
 483                 else              s->avctx->pix_fmt = AV_PIX_FMT_YUV444P16;
 484             s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
 485             }
 486         }
 487         av_assert0(s->nb_components == 3);
 488         break;
 489     case 0x11111111:
 490         if (s->rgb)
 491             s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_ABGR : AV_PIX_FMT_RGBA64;
 492         else {
 493             if (s->adobe_transform == 0 && s->bits <= 8) {
 494                 s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;
 495             } else {
 496                 s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_YUVA444P : AV_PIX_FMT_YUVA444P16;
 497                 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
 498             }
 499         }
 500         av_assert0(s->nb_components == 4);
 501         break;
 502     case 0x22111122:
 503     case 0x22111111:
 504         if (s->adobe_transform == 0 && s->bits <= 8) {
 505             s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;
 506             s->upscale_v[1] = s->upscale_v[2] = 1;
 507             s->upscale_h[1] = s->upscale_h[2] = 1;
 508         } else if (s->adobe_transform == 2 && s->bits <= 8) {
 509             s->avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
 510             s->upscale_v[1] = s->upscale_v[2] = 1;
 511             s->upscale_h[1] = s->upscale_h[2] = 1;
 512             s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
 513         } else {
 514             if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
 515             else              s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P16;
 516             s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
 517         }
 518         av_assert0(s->nb_components == 4);
 519         break;
 520     case 0x12121100:
 521     case 0x22122100:
 522     case 0x21211100:
 523     case 0x22211200:
 524         if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
 525         else
 526             goto unk_pixfmt;
 527         s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
 528         break;
 529     case 0x22221100:
 530     case 0x22112200:
 531     case 0x11222200:
 532         if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
 533         else
 534             goto unk_pixfmt;
 535         s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
 536         break;
 537     case 0x11000000:
 538     case 0x13000000:
 539     case 0x14000000:
 540     case 0x31000000:
 541     case 0x33000000:
 542     case 0x34000000:
 543     case 0x41000000:
 544     case 0x43000000:
 545     case 0x44000000:
 546         if(s->bits <= 8)
 547             s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
 548         else
 549             s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
 550         break;
 551     case 0x12111100:
 552     case 0x14121200:
 553     case 0x14111100:
 554     case 0x22211100:
 555     case 0x22112100:
 556         if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
 557             if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
 558             else
 559                 goto unk_pixfmt;
 560             s->upscale_v[0] = s->upscale_v[1] = 1;
 561         } else {
 562             if (pix_fmt_id == 0x14111100)
 563                 s->upscale_v[1] = s->upscale_v[2] = 1;
 564             if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV440P : AV_PIX_FMT_YUVJ440P;
 565             else
 566                 goto unk_pixfmt;
 567             s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
 568         }
 569         break;
 570     case 0x21111100:
 571         if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
 572             if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
 573             else
 574                 goto unk_pixfmt;
 575             s->upscale_h[0] = s->upscale_h[1] = 1;
 576         } else {
 577             if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
 578             else              s->avctx->pix_fmt = AV_PIX_FMT_YUV422P16;
 579             s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
 580         }
 581         break;
 582     case 0x31111100:
 583         if (s->bits > 8)
 584             goto unk_pixfmt;
 585         s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
 586         s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
 587         s->upscale_h[1] = s->upscale_h[2] = 2;
 588         break;
 589     case 0x22121100:
 590     case 0x22111200:
 591         if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
 592         else
 593             goto unk_pixfmt;
 594         s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
 595         break;
 596     case 0x22111100:
 597     case 0x23111100:
 598     case 0x42111100:
 599     case 0x24111100:
 600         if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUVJ420P;
 601         else              s->avctx->pix_fmt = AV_PIX_FMT_YUV420P16;
 602         s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
 603         if (pix_fmt_id == 0x42111100) {
 604             if (s->bits > 8)
 605                 goto unk_pixfmt;
 606             s->upscale_h[1] = s->upscale_h[2] = 1;
 607         } else if (pix_fmt_id == 0x24111100) {
 608             if (s->bits > 8)
 609                 goto unk_pixfmt;
 610             s->upscale_v[1] = s->upscale_v[2] = 1;
 611         } else if (pix_fmt_id == 0x23111100) {
 612             if (s->bits > 8)
 613                 goto unk_pixfmt;
 614             s->upscale_v[1] = s->upscale_v[2] = 2;
 615         }
 616         break;
 617     case 0x41111100:
 618         if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV411P : AV_PIX_FMT_YUVJ411P;
 619         else
 620             goto unk_pixfmt;
 621         s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
 622         break;
 623     default:
 624 unk_pixfmt:
 625         avpriv_report_missing_feature(s->avctx, "Pixel format 0x%x bits:%d", pix_fmt_id, s->bits);
 626         memset(s->upscale_h, 0, sizeof(s->upscale_h));
 627         memset(s->upscale_v, 0, sizeof(s->upscale_v));
 628         return AVERROR_PATCHWELCOME;
 629     }
 630     if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->avctx->lowres) {
 631         avpriv_report_missing_feature(s->avctx, "Lowres for weird subsampling");
 632         return AVERROR_PATCHWELCOME;
 633     }
 634     if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->progressive && s->avctx->pix_fmt == AV_PIX_FMT_GBRP) {
 635         avpriv_report_missing_feature(s->avctx, "progressive for weird subsampling");
 636         return AVERROR_PATCHWELCOME;
 637     }
 638     if (s->ls) {
 639         memset(s->upscale_h, 0, sizeof(s->upscale_h));
 640         memset(s->upscale_v, 0, sizeof(s->upscale_v));
 641         if (s->nb_components == 3) {
 642             s->avctx->pix_fmt = AV_PIX_FMT_RGB24;
 643         } else if (s->nb_components != 1) {
 644             av_log(s->avctx, AV_LOG_ERROR, "Unsupported number of components %d\n", s->nb_components);
 645             return AVERROR_PATCHWELCOME;
 646         } else if (s->palette_index && s->bits <= 8)
 647             s->avctx->pix_fmt = AV_PIX_FMT_PAL8;
 648         else if (s->bits <= 8)
 649             s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
 650         else
 651             s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
 652     }
 653
 654     s->pix_desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
 655     if (!s->pix_desc) {
 656         av_log(s->avctx, AV_LOG_ERROR, "Could not get a pixel format descriptor.\n");
 657         return AVERROR_BUG;
 658     }
 659
 660     if (s->avctx->pix_fmt == s->hwaccel_sw_pix_fmt && !size_change) {
 661         s->avctx->pix_fmt = s->hwaccel_pix_fmt;
 662     } else {
 663         enum AVPixelFormat pix_fmts[] = {
 664 #if CONFIG_MJPEG_NVDEC_HWACCEL
 665             AV_PIX_FMT_CUDA,
 666 #endif
 667 #if CONFIG_MJPEG_VAAPI_HWACCEL
 668             AV_PIX_FMT_VAAPI,
 669 #endif
 670             s->avctx->pix_fmt,
 671             AV_PIX_FMT_NONE,
 672         };
 673         s->hwaccel_pix_fmt = ff_get_format(s->avctx, pix_fmts);
 674         if (s->hwaccel_pix_fmt < 0)
 675             return AVERROR(EINVAL);
 676
 677         s->hwaccel_sw_pix_fmt = s->avctx->pix_fmt;
 678         s->avctx->pix_fmt     = s->hwaccel_pix_fmt;
 679     }
 680
 681     if (s->avctx->skip_frame == AVDISCARD_ALL) {
 682         s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
 683         s->picture_ptr->key_frame = 1;
 684         s->got_picture            = 1;
 685         return 0;
 686     }
 687
 688     av_frame_unref(s->picture_ptr);
 689     if (ff_get_buffer(s->avctx, s->picture_ptr, AV_GET_BUFFER_FLAG_REF) < 0)
 690         return -1;
 691     s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
 692     s->picture_ptr->key_frame = 1;
 693     s->got_picture            = 1;
 694
 695     for (i = 0; i < 4; i++)
 696         s->linesize[i] = s->picture_ptr->linesize[i] << s->interlaced;
 697
 698     ff_dlog(s->avctx, "%d %d %d %d %d %d\n",
 699             s->width, s->height, s->linesize[0], s->linesize[1],
 700             s->interlaced, s->avctx->height);
 701
 702     if (len != (8 + (3 * nb_components)))
 703         av_log(s->avctx, AV_LOG_DEBUG, "decode_sof0: error, len(%d) mismatch\n", len);
 704     }
 705
 706     if ((s->rgb && !s->lossless && !s->ls) ||
 707         (!s->rgb && s->ls && s->nb_components > 1)) {
 708         av_log(s->avctx, AV_LOG_ERROR, "Unsupported coding and pixel format combination\n");
 709         return AVERROR_PATCHWELCOME;
 710     }
 711
 712     /* totally blank picture as progressive JPEG will only add details to it */
 713     if (s->progressive) {
 714         int bw = (width  + s->h_max * 8 - 1) / (s->h_max * 8);
 715         int bh = (height + s->v_max * 8 - 1) / (s->v_max * 8);
 716         for (i = 0; i < s->nb_components; i++) {
 717             int size = bw * bh * s->h_count[i] * s->v_count[i];
 718             av_freep(&s->blocks[i]);
 719             av_freep(&s->last_nnz[i]);
 720             s->blocks[i]       = av_mallocz_array(size, sizeof(**s->blocks));
 721             s->last_nnz[i]     = av_mallocz_array(size, sizeof(**s->last_nnz));
 722             if (!s->blocks[i] || !s->last_nnz[i])
 723                 return AVERROR(ENOMEM);
 724             s->block_stride[i] = bw * s->h_count[i];
 725         }
 726         memset(s->coefs_finished, 0, sizeof(s->coefs_finished));
 727     }
 728
 729     if (s->avctx->hwaccel) {
 730         s->hwaccel_picture_private =
 731             av_mallocz(s->avctx->hwaccel->frame_priv_data_size);
 732         if (!s->hwaccel_picture_private)
 733             return AVERROR(ENOMEM);
 734
 735         ret = s->avctx->hwaccel->start_frame(s->avctx, s->raw_image_buffer,
 736                                              s->raw_image_buffer_size);
 737         if (ret < 0)
 738             return ret;
 739     }
 740
 741     return 0;
 742 }
 743
 744 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
 745 {
 746     int code;
 747     code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
 748     if (code < 0 || code > 16) {
 749         av_log(s->avctx, AV_LOG_WARNING,
 750                "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
 751                0, dc_index, &s->vlcs[0][dc_index]);
 752         return 0xfffff;
 753     }
 754
 755     if (code)
 756         return get_xbits(&s->gb, code);
 757     else
 758         return 0;
 759 }
 760
 761 /* decode block and dequantize */
 762 static int decode_block(MJpegDecodeContext *s, int16_t *block, int component,
 763                         int dc_index, int ac_index, uint16_t *quant_matrix)
 764 {
 765     int code, i, j, level, val;
 766
 767     /* DC coef */
 768     val = mjpeg_decode_dc(s, dc_index);
 769     if (val == 0xfffff) {
 770         av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
 771         return AVERROR_INVALIDDATA;
 772     }
 773     val = val * (unsigned)quant_matrix[0] + s->last_dc[component];
 774     val = av_clip_int16(val);
 775     s->last_dc[component] = val;
 776     block[0] = val;
 777     /* AC coefs */
 778     i = 0;
 779     {OPEN_READER(re, &s->gb);
 780     do {
 781         UPDATE_CACHE(re, &s->gb);
 782         GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2);
 783
 784         i += ((unsigned)code) >> 4;
 785             code &= 0xf;
 786         if (code) {
 787             if (code > MIN_CACHE_BITS - 16)
 788                 UPDATE_CACHE(re, &s->gb);
 789
 790             {
 791                 int cache = GET_CACHE(re, &s->gb);
 792                 int sign  = (~cache) >> 31;
 793                 level     = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
 794             }
 795
 796             LAST_SKIP_BITS(re, &s->gb, code);
 797
 798             if (i > 63) {
 799                 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
 800                 return AVERROR_INVALIDDATA;
 801             }
 802             j        = s->scantable.permutated[i];
 803             block[j] = level * quant_matrix[i];
 804         }
 805     } while (i < 63);
 806     CLOSE_READER(re, &s->gb);}
 807
 808     return 0;
 809 }
 810
 811 static int decode_dc_progressive(MJpegDecodeContext *s, int16_t *block,
 812                                  int component, int dc_index,
 813                                  uint16_t *quant_matrix, int Al)
 814 {
 815     unsigned val;
 816     s->bdsp.clear_block(block);
 817     val = mjpeg_decode_dc(s, dc_index);
 818     if (val == 0xfffff) {
 819         av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
 820         return AVERROR_INVALIDDATA;
 821     }
 822     val = (val * (quant_matrix[0] << Al)) + s->last_dc[component];
 823     s->last_dc[component] = val;
 824     block[0] = val;
 825     return 0;
 826 }
 827
 828 /* decode block and dequantize - progressive JPEG version */
 829 static int decode_block_progressive(MJpegDecodeContext *s, int16_t *block,
 830                                     uint8_t *last_nnz, int ac_index,
 831                                     uint16_t *quant_matrix,
 832                                     int ss, int se, int Al, int *EOBRUN)
 833 {
 834     int code, i, j, val, run;
 835     unsigned level;
 836
 837     if (*EOBRUN) {
 838         (*EOBRUN)--;
 839         return 0;
 840     }
 841
 842     {
 843         OPEN_READER(re, &s->gb);
 844         for (i = ss; ; i++) {
 845             UPDATE_CACHE(re, &s->gb);
 846             GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
 847
 848             run = ((unsigned) code) >> 4;
 849             code &= 0xF;
 850             if (code) {
 851                 i += run;
 852                 if (code > MIN_CACHE_BITS - 16)
 853                     UPDATE_CACHE(re, &s->gb);
 854
 855                 {
 856                     int cache = GET_CACHE(re, &s->gb);
 857                     int sign  = (~cache) >> 31;
 858                     level     = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
 859                 }
 860
 861                 LAST_SKIP_BITS(re, &s->gb, code);
 862
 863                 if (i >= se) {
 864                     if (i == se) {
 865                         j = s->scantable.permutated[se];
 866                         block[j] = level * (quant_matrix[se] << Al);
 867                         break;
 868                     }
 869                     av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
 870                     return AVERROR_INVALIDDATA;
 871                 }
 872                 j = s->scantable.permutated[i];
 873                 block[j] = level * (quant_matrix[i] << Al);
 874             } else {
 875                 if (run == 0xF) {// ZRL - skip 15 coefficients
 876                     i += 15;
 877                     if (i >= se) {
 878                         av_log(s->avctx, AV_LOG_ERROR, "ZRL overflow: %d\n", i);
 879                         return AVERROR_INVALIDDATA;
 880                     }
 881                 } else {
 882                     val = (1 << run);
 883                     if (run) {
 884                         UPDATE_CACHE(re, &s->gb);
 885                         val += NEG_USR32(GET_CACHE(re, &s->gb), run);
 886                         LAST_SKIP_BITS(re, &s->gb, run);
 887                     }
 888                     *EOBRUN = val - 1;
 889                     break;
 890                 }
 891             }
 892         }
 893         CLOSE_READER(re, &s->gb);
 894     }
 895
 896     if (i > *last_nnz)
 897         *last_nnz = i;
 898
 899     return 0;
 900 }
 901
 902 #define REFINE_BIT(j) {                                             \
 903     UPDATE_CACHE(re, &s->gb);                                       \
 904     sign = block[j] >> 15;                                          \
 905     block[j] += SHOW_UBITS(re, &s->gb, 1) *                         \
 906                 ((quant_matrix[i] ^ sign) - sign) << Al;            \
 907     LAST_SKIP_BITS(re, &s->gb, 1);                                  \
 908 }
 909
 910 #define ZERO_RUN                                                    \
 911 for (; ; i++) {                                                     \
 912     if (i > last) {                                                 \
 913         i += run;                                                   \
 914         if (i > se) {                                               \
 915             av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \
 916             return -1;                                              \
 917         }                                                           \
 918         break;                                                      \
 919     }                                                               \
 920     j = s->scantable.permutated[i];                                 \
 921     if (block[j])                                                   \
 922         REFINE_BIT(j)                                               \
 923     else if (run-- == 0)                                            \
 924         break;                                                      \
 925 }
 926
 927 /* decode block and dequantize - progressive JPEG refinement pass */
 928 static int decode_block_refinement(MJpegDecodeContext *s, int16_t *block,
 929                                    uint8_t *last_nnz,
 930                                    int ac_index, uint16_t *quant_matrix,
 931                                    int ss, int se, int Al, int *EOBRUN)
 932 {
 933     int code, i = ss, j, sign, val, run;
 934     int last    = FFMIN(se, *last_nnz);
 935
 936     OPEN_READER(re, &s->gb);
 937     if (*EOBRUN) {
 938         (*EOBRUN)--;
 939     } else {
 940         for (; ; i++) {
 941             UPDATE_CACHE(re, &s->gb);
 942             GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
 943
 944             if (code & 0xF) {
 945                 run = ((unsigned) code) >> 4;
 946                 UPDATE_CACHE(re, &s->gb);
 947                 val = SHOW_UBITS(re, &s->gb, 1);
 948                 LAST_SKIP_BITS(re, &s->gb, 1);
 949                 ZERO_RUN;
 950                 j = s->scantable.permutated[i];
 951                 val--;
 952                 block[j] = ((quant_matrix[i] << Al) ^ val) - val;
 953                 if (i == se) {
 954                     if (i > *last_nnz)
 955                         *last_nnz = i;
 956                     CLOSE_READER(re, &s->gb);
 957                     return 0;
 958                 }
 959             } else {
 960                 run = ((unsigned) code) >> 4;
 961                 if (run == 0xF) {
 962                     ZERO_RUN;
 963                 } else {
 964                     val = run;
 965                     run = (1 << run);
 966                     if (val) {
 967                         UPDATE_CACHE(re, &s->gb);
 968                         run += SHOW_UBITS(re, &s->gb, val);
 969                         LAST_SKIP_BITS(re, &s->gb, val);
 970                     }
 971                     *EOBRUN = run - 1;
 972                     break;
 973                 }
 974             }
 975         }
 976
 977         if (i > *last_nnz)
 978             *last_nnz = i;
 979     }
 980
 981     for (; i <= last; i++) {
 982         j = s->scantable.permutated[i];
 983         if (block[j])
 984             REFINE_BIT(j)
 985     }
 986     CLOSE_READER(re, &s->gb);
 987
 988     return 0;
 989 }
 990 #undef REFINE_BIT
 991 #undef ZERO_RUN
 992
 993 static int handle_rstn(MJpegDecodeContext *s, int nb_components)
 994 {
 995     int i;
 996     int reset = 0;
 997
 998     if (s->restart_interval) {
 999         s->restart_count--;
1000         if(s->restart_count == 0 && s->avctx->codec_id == AV_CODEC_ID_THP){
1001             align_get_bits(&s->gb);
1002             for (i = 0; i < nb_components; i++) /* reset dc */
1003                 s->last_dc[i] = (4 << s->bits);
1004         }
1005
1006         i = 8 + ((-get_bits_count(&s->gb)) & 7);
1007         /* skip RSTn */
1008         if (s->restart_count == 0) {
1009             if(   show_bits(&s->gb, i) == (1 << i) - 1
1010                || show_bits(&s->gb, i) == 0xFF) {
1011                 int pos = get_bits_count(&s->gb);
1012                 align_get_bits(&s->gb);
1013                 while (get_bits_left(&s->gb) >= 8 && show_bits(&s->gb, 8) == 0xFF)
1014                     skip_bits(&s->gb, 8);
1015                 if (get_bits_left(&s->gb) >= 8 && (get_bits(&s->gb, 8) & 0xF8) == 0xD0) {
1016                     for (i = 0; i < nb_components; i++) /* reset dc */
1017                         s->last_dc[i] = (4 << s->bits);
1018                     reset = 1;
1019                 } else
1020                     skip_bits_long(&s->gb, pos - get_bits_count(&s->gb));
1021             }
1022         }
1023     }
1024     return reset;
1025 }
1026
1027 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int nb_components, int predictor, int point_transform)
1028 {
1029     int i, mb_x, mb_y;
1030     uint16_t (*buffer)[4];
1031     int left[4], top[4], topleft[4];
1032     const int linesize = s->linesize[0];
1033     const int mask     = ((1 << s->bits) - 1) << point_transform;
1034     int resync_mb_y = 0;
1035     int resync_mb_x = 0;
1036
1037     if (s->nb_components != 3 && s->nb_components != 4)
1038         return AVERROR_INVALIDDATA;
1039     if (s->v_max != 1 || s->h_max != 1 || !s->lossless)
1040         return AVERROR_INVALIDDATA;
1041
1042
1043     s->restart_count = s->restart_interval;
1044
1045     av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size,
1046                    (unsigned)s->mb_width * 4 * sizeof(s->ljpeg_buffer[0][0]));
1047     if (!s->ljpeg_buffer)
1048         return AVERROR(ENOMEM);
1049
1050     buffer = s->ljpeg_buffer;
1051
1052     for (i = 0; i < 4; i++)
1053         buffer[0][i] = 1 << (s->bits - 1);
1054
1055     for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1056         uint8_t *ptr = s->picture_ptr->data[0] + (linesize * mb_y);
1057
1058         if (s->interlaced && s->bottom_field)
1059             ptr += linesize >> 1;
1060
1061         for (i = 0; i < 4; i++)
1062             top[i] = left[i] = topleft[i] = buffer[0][i];
1063
1064         for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1065             int modified_predictor = predictor;
1066
1067             if (get_bits_left(&s->gb) < 1) {
1068                 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in rgb_scan\n");
1069                 return AVERROR_INVALIDDATA;
1070             }
1071
1072             if (s->restart_interval && !s->restart_count){
1073                 s->restart_count = s->restart_interval;
1074                 resync_mb_x = mb_x;
1075                 resync_mb_y = mb_y;
1076                 for(i=0; i<4; i++)
1077                     top[i] = left[i]= topleft[i]= 1 << (s->bits - 1);
1078             }
1079             if (mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || !mb_x)
1080                 modified_predictor = 1;
1081
1082             for (i=0;i<nb_components;i++) {
1083                 int pred, dc;
1084
1085                 topleft[i] = top[i];
1086                 top[i]     = buffer[mb_x][i];
1087
1088                 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1089
1090                 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1091                 if(dc == 0xFFFFF)
1092                     return -1;
1093
1094                 left[i] = buffer[mb_x][i] =
1095                     mask & (pred + (unsigned)(dc * (1 << point_transform)));
1096             }
1097
1098             if (s->restart_interval && !--s->restart_count) {
1099                 align_get_bits(&s->gb);
1100                 skip_bits(&s->gb, 16); /* skip RSTn */
1101             }
1102         }
1103         if (s->rct && s->nb_components == 4) {
1104             for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1105                 ptr[4*mb_x + 2] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1106                 ptr[4*mb_x + 1] = buffer[mb_x][1] + ptr[4*mb_x + 2];
1107                 ptr[4*mb_x + 3] = buffer[mb_x][2] + ptr[4*mb_x + 2];
1108                 ptr[4*mb_x + 0] = buffer[mb_x][3];
1109             }
1110         } else if (s->nb_components == 4) {
1111             for(i=0; i<nb_components; i++) {
1112                 int c= s->comp_index[i];
1113                 if (s->bits <= 8) {
1114                     for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1115                         ptr[4*mb_x+3-c] = buffer[mb_x][i];
1116                     }
1117                 } else if(s->bits == 9) {
1118                     return AVERROR_PATCHWELCOME;
1119                 } else {
1120                     for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1121                         ((uint16_t*)ptr)[4*mb_x+c] = buffer[mb_x][i];
1122                     }
1123                 }
1124             }
1125         } else if (s->rct) {
1126             for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1127                 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1128                 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1129                 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1130             }
1131         } else if (s->pegasus_rct) {
1132             for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1133                 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2]) >> 2);
1134                 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1135                 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1136             }
1137         } else {
1138             for(i=0; i<nb_components; i++) {
1139                 int c= s->comp_index[i];
1140                 if (s->bits <= 8) {
1141                     for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1142                         ptr[3*mb_x+2-c] = buffer[mb_x][i];
1143                     }
1144                 } else if(s->bits == 9) {
1145                     return AVERROR_PATCHWELCOME;
1146                 } else {
1147                     for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1148                         ((uint16_t*)ptr)[3*mb_x+2-c] = buffer[mb_x][i];
1149                     }
1150                 }
1151             }
1152         }
1153     }
1154     return 0;
1155 }
1156
1157 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
1158                                  int point_transform, int nb_components)
1159 {
1160     int i, mb_x, mb_y, mask;
1161     int bits= (s->bits+7)&~7;
1162     int resync_mb_y = 0;
1163     int resync_mb_x = 0;
1164
1165     point_transform += bits - s->bits;
1166     mask = ((1 << s->bits) - 1) << point_transform;
1167
1168     av_assert0(nb_components>=1 && nb_components<=4);
1169
1170     for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1171         for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1172             if (get_bits_left(&s->gb) < 1) {
1173                 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in yuv_scan\n");
1174                 return AVERROR_INVALIDDATA;
1175             }
1176             if (s->restart_interval && !s->restart_count){
1177                 s->restart_count = s->restart_interval;
1178                 resync_mb_x = mb_x;
1179                 resync_mb_y = mb_y;
1180             }
1181
1182             if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->interlaced){
1183                 int toprow  = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x;
1184                 int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x;
1185                 for (i = 0; i < nb_components; i++) {
1186                     uint8_t *ptr;
1187                     uint16_t *ptr16;
1188                     int n, h, v, x, y, c, j, linesize;
1189                     n = s->nb_blocks[i];
1190                     c = s->comp_index[i];
1191                     h = s->h_scount[i];
1192                     v = s->v_scount[i];
1193                     x = 0;
1194                     y = 0;
1195                     linesize= s->linesize[c];
1196
1197                     if(bits>8) linesize /= 2;
1198
1199                     for(j=0; j<n; j++) {
1200                         int pred, dc;
1201
1202                         dc = mjpeg_decode_dc(s, s->dc_index[i]);
1203                         if(dc == 0xFFFFF)
1204                             return -1;
1205                         if (   h * mb_x + x >= s->width
1206                             || v * mb_y + y >= s->height) {
1207                             // Nothing to do
1208                         } else if (bits<=8) {
1209                         ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1210                         if(y==0 && toprow){
1211                             if(x==0 && leftcol){
1212                                 pred= 1 << (bits - 1);
1213                             }else{
1214                                 pred= ptr[-1];
1215                             }
1216                         }else{
1217                             if(x==0 && leftcol){
1218                                 pred= ptr[-linesize];
1219                             }else{
1220                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1221                             }
1222                         }
1223
1224                         if (s->interlaced && s->bottom_field)
1225                             ptr += linesize >> 1;
1226                         pred &= mask;
1227                         *ptr= pred + ((unsigned)dc << point_transform);
1228                         }else{
1229                             ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1230                             if(y==0 && toprow){
1231                                 if(x==0 && leftcol){
1232                                     pred= 1 << (bits - 1);
1233                                 }else{
1234                                     pred= ptr16[-1];
1235                                 }
1236                             }else{
1237                                 if(x==0 && leftcol){
1238                                     pred= ptr16[-linesize];
1239                                 }else{
1240                                     PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1241                                 }
1242                             }
1243
1244                             if (s->interlaced && s->bottom_field)
1245                                 ptr16 += linesize >> 1;
1246                             pred &= mask;
1247                             *ptr16= pred + ((unsigned)dc << point_transform);
1248                         }
1249                         if (++x == h) {
1250                             x = 0;
1251                             y++;
1252                         }
1253                     }
1254                 }
1255             } else {
1256                 for (i = 0; i < nb_components; i++) {
1257                     uint8_t *ptr;
1258                     uint16_t *ptr16;
1259                     int n, h, v, x, y, c, j, linesize, dc;
1260                     n        = s->nb_blocks[i];
1261                     c        = s->comp_index[i];
1262                     h        = s->h_scount[i];
1263                     v        = s->v_scount[i];
1264                     x        = 0;
1265                     y        = 0;
1266                     linesize = s->linesize[c];
1267
1268                     if(bits>8) linesize /= 2;
1269
1270                     for (j = 0; j < n; j++) {
1271                         int pred;
1272
1273                         dc = mjpeg_decode_dc(s, s->dc_index[i]);
1274                         if(dc == 0xFFFFF)
1275                             return -1;
1276                         if (   h * mb_x + x >= s->width
1277                             || v * mb_y + y >= s->height) {
1278                             // Nothing to do
1279                         } else if (bits<=8) {
1280                             ptr = s->picture_ptr->data[c] +
1281                               (linesize * (v * mb_y + y)) +
1282                               (h * mb_x + x); //FIXME optimize this crap
1283                             PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1284
1285                             pred &= mask;
1286                             *ptr = pred + ((unsigned)dc << point_transform);
1287                         }else{
1288                             ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1289                             PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1290
1291                             pred &= mask;
1292                             *ptr16= pred + ((unsigned)dc << point_transform);
1293                         }
1294
1295                         if (++x == h) {
1296                             x = 0;
1297                             y++;
1298                         }
1299                     }
1300                 }
1301             }
1302             if (s->restart_interval && !--s->restart_count) {
1303                 align_get_bits(&s->gb);
1304                 skip_bits(&s->gb, 16); /* skip RSTn */
1305             }
1306         }
1307     }
1308     return 0;
1309 }
1310
1311 static av_always_inline void mjpeg_copy_block(MJpegDecodeContext *s,
1312                                               uint8_t *dst, const uint8_t *src,
1313                                               int linesize, int lowres)
1314 {
1315     switch (lowres) {
1316     case 0: s->hdsp.put_pixels_tab[1][0](dst, src, linesize, 8);
1317         break;
1318     case 1: copy_block4(dst, src, linesize, linesize, 4);
1319         break;
1320     case 2: copy_block2(dst, src, linesize, linesize, 2);
1321         break;
1322     case 3: *dst = *src;
1323         break;
1324     }
1325 }
1326
1327 static void shift_output(MJpegDecodeContext *s, uint8_t *ptr, int linesize)
1328 {
1329     int block_x, block_y;
1330     int size = 8 >> s->avctx->lowres;
1331     if (s->bits > 8) {
1332         for (block_y=0; block_y<size; block_y++)
1333             for (block_x=0; block_x<size; block_x++)
1334                 *(uint16_t*)(ptr + 2*block_x + block_y*linesize) <<= 16 - s->bits;
1335     } else {
1336         for (block_y=0; block_y<size; block_y++)
1337             for (block_x=0; block_x<size; block_x++)
1338                 *(ptr + block_x + block_y*linesize) <<= 8 - s->bits;
1339     }
1340 }
1341
1342 static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
1343                              int Al, const uint8_t *mb_bitmask,
1344                              int mb_bitmask_size,
1345                              const AVFrame *reference)
1346 {
1347     int i, mb_x, mb_y, chroma_h_shift, chroma_v_shift, chroma_width, chroma_height;
1348     uint8_t *data[MAX_COMPONENTS];
1349     const uint8_t *reference_data[MAX_COMPONENTS];
1350     int linesize[MAX_COMPONENTS];
1351     GetBitContext mb_bitmask_gb = {0}; // initialize to silence gcc warning
1352     int bytes_per_pixel = 1 + (s->bits > 8);
1353
1354     if (mb_bitmask) {
1355         if (mb_bitmask_size != (s->mb_width * s->mb_height + 7)>>3) {
1356             av_log(s->avctx, AV_LOG_ERROR, "mb_bitmask_size mismatches\n");
1357             return AVERROR_INVALIDDATA;
1358         }
1359         init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
1360     }
1361
1362     s->restart_count = 0;
1363
1364     av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &chroma_h_shift,
1365                                      &chroma_v_shift);
1366     chroma_width  = AV_CEIL_RSHIFT(s->width,  chroma_h_shift);
1367     chroma_height = AV_CEIL_RSHIFT(s->height, chroma_v_shift);
1368
1369     for (i = 0; i < nb_components; i++) {
1370         int c   = s->comp_index[i];
1371         data[c] = s->picture_ptr->data[c];
1372         reference_data[c] = reference ? reference->data[c] : NULL;
1373         linesize[c] = s->linesize[c];
1374         s->coefs_finished[c] |= 1;
1375     }
1376
1377     for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1378         for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1379             const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
1380
1381             if (s->restart_interval && !s->restart_count)
1382                 s->restart_count = s->restart_interval;
1383
1384             if (get_bits_left(&s->gb) < 0) {
1385                 av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",
1386                        -get_bits_left(&s->gb));
1387                 return AVERROR_INVALIDDATA;
1388             }
1389             for (i = 0; i < nb_components; i++) {
1390                 uint8_t *ptr;
1391                 int n, h, v, x, y, c, j;
1392                 int block_offset;
1393                 n = s->nb_blocks[i];
1394                 c = s->comp_index[i];
1395                 h = s->h_scount[i];
1396                 v = s->v_scount[i];
1397                 x = 0;
1398                 y = 0;
1399                 for (j = 0; j < n; j++) {
1400                     block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
1401                                      (h * mb_x + x) * 8 * bytes_per_pixel) >> s->avctx->lowres);
1402
1403                     if (s->interlaced && s->bottom_field)
1404                         block_offset += linesize[c] >> 1;
1405                     if (   8*(h * mb_x + x) < ((c == 1) || (c == 2) ? chroma_width  : s->width)
1406                         && 8*(v * mb_y + y) < ((c == 1) || (c == 2) ? chroma_height : s->height)) {
1407                         ptr = data[c] + block_offset;
1408                     } else
1409                         ptr = NULL;
1410                     if (!s->progressive) {
1411                         if (copy_mb) {
1412                             if (ptr)
1413                                 mjpeg_copy_block(s, ptr, reference_data[c] + block_offset,
1414                                                 linesize[c], s->avctx->lowres);
1415
1416                         } else {
1417                             s->bdsp.clear_block(s->block);
1418                             if (decode_block(s, s->block, i,
1419                                              s->dc_index[i], s->ac_index[i],
1420                                              s->quant_matrixes[s->quant_sindex[i]]) < 0) {
1421                                 av_log(s->avctx, AV_LOG_ERROR,
1422                                        "error y=%d x=%d\n", mb_y, mb_x);
1423                                 return AVERROR_INVALIDDATA;
1424                             }
1425                             if (ptr) {
1426                                 s->idsp.idct_put(ptr, linesize[c], s->block);
1427                                 if (s->bits & 7)
1428                                     shift_output(s, ptr, linesize[c]);
1429                             }
1430                         }
1431                     } else {
1432                         int block_idx  = s->block_stride[c] * (v * mb_y + y) +
1433                                          (h * mb_x + x);
1434                         int16_t *block = s->blocks[c][block_idx];
1435                         if (Ah)
1436                             block[0] += get_bits1(&s->gb) *
1437                                         s->quant_matrixes[s->quant_sindex[i]][0] << Al;
1438                         else if (decode_dc_progressive(s, block, i, s->dc_index[i],
1439                                                        s->quant_matrixes[s->quant_sindex[i]],
1440                                                        Al) < 0) {
1441                             av_log(s->avctx, AV_LOG_ERROR,
1442                                    "error y=%d x=%d\n", mb_y, mb_x);
1443                             return AVERROR_INVALIDDATA;
1444                         }
1445                     }
1446                     ff_dlog(s->avctx, "mb: %d %d processed\n", mb_y, mb_x);
1447                     ff_dlog(s->avctx, "%d %d %d %d %d %d %d %d \n",
1448                             mb_x, mb_y, x, y, c, s->bottom_field,
1449                             (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1450                     if (++x == h) {
1451                         x = 0;
1452                         y++;
1453                     }
1454                 }
1455             }
1456
1457             handle_rstn(s, nb_components);
1458         }
1459     }
1460     return 0;
1461 }
1462
1463 static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss,
1464                                             int se, int Ah, int Al)
1465 {
1466     int mb_x, mb_y;
1467     int EOBRUN = 0;
1468     int c = s->comp_index[0];
1469     uint16_t *quant_matrix = s->quant_matrixes[s->quant_sindex[0]];
1470
1471     av_assert0(ss>=0 && Ah>=0 && Al>=0);
1472     if (se < ss || se > 63) {
1473         av_log(s->avctx, AV_LOG_ERROR, "SS/SE %d/%d is invalid\n", ss, se);
1474         return AVERROR_INVALIDDATA;
1475     }
1476
1477     // s->coefs_finished is a bitmask for coefficients coded
1478     // ss and se are parameters telling start and end coefficients
1479     s->coefs_finished[c] |= (2ULL << se) - (1ULL << ss);
1480
1481     s->restart_count = 0;
1482
1483     for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1484         int block_idx    = mb_y * s->block_stride[c];
1485         int16_t (*block)[64] = &s->blocks[c][block_idx];
1486         uint8_t *last_nnz    = &s->last_nnz[c][block_idx];
1487         if (get_bits_left(&s->gb) <= 0) {
1488             av_log(s->avctx, AV_LOG_ERROR, "bitstream truncated in mjpeg_decode_scan_progressive_ac\n");
1489             return AVERROR_INVALIDDATA;
1490         }
1491         for (mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) {
1492                 int ret;
1493                 if (s->restart_interval && !s->restart_count)
1494                     s->restart_count = s->restart_interval;
1495
1496                 if (Ah)
1497                     ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0],
1498                                                   quant_matrix, ss, se, Al, &EOBRUN);
1499                 else
1500                     ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0],
1501                                                    quant_matrix, ss, se, Al, &EOBRUN);
1502                 if (ret < 0) {
1503                     av_log(s->avctx, AV_LOG_ERROR,
1504                            "error y=%d x=%d\n", mb_y, mb_x);
1505                     return AVERROR_INVALIDDATA;
1506                 }
1507
1508             if (handle_rstn(s, 0))
1509                 EOBRUN = 0;
1510         }
1511     }
1512     return 0;
1513 }
1514
1515 static void mjpeg_idct_scan_progressive_ac(MJpegDecodeContext *s)
1516 {
1517     int mb_x, mb_y;
1518     int c;
1519     const int bytes_per_pixel = 1 + (s->bits > 8);
1520     const int block_size = s->lossless ? 1 : 8;
1521
1522     for (c = 0; c < s->nb_components; c++) {
1523         uint8_t *data = s->picture_ptr->data[c];
1524         int linesize  = s->linesize[c];
1525         int h = s->h_max / s->h_count[c];
1526         int v = s->v_max / s->v_count[c];
1527         int mb_width     = (s->width  + h * block_size - 1) / (h * block_size);
1528         int mb_height    = (s->height + v * block_size - 1) / (v * block_size);
1529
1530         if (~s->coefs_finished[c])
1531             av_log(s->avctx, AV_LOG_WARNING, "component %d is incomplete\n", c);
1532
1533         if (s->interlaced && s->bottom_field)
1534             data += linesize >> 1;
1535
1536         for (mb_y = 0; mb_y < mb_height; mb_y++) {
1537             uint8_t *ptr     = data + (mb_y * linesize * 8 >> s->avctx->lowres);
1538             int block_idx    = mb_y * s->block_stride[c];
1539             int16_t (*block)[64] = &s->blocks[c][block_idx];
1540             for (mb_x = 0; mb_x < mb_width; mb_x++, block++) {
1541                 s->idsp.idct_put(ptr, linesize, *block);
1542                 if (s->bits & 7)
1543                     shift_output(s, ptr, linesize);
1544                 ptr += bytes_per_pixel*8 >> s->avctx->lowres;
1545             }
1546         }
1547     }
1548 }
1549
1550 int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
1551                         int mb_bitmask_size, const AVFrame *reference)
1552 {
1553     int len, nb_components, i, h, v, predictor, point_transform;
1554     int index, id, ret;
1555     const int block_size = s->lossless ? 1 : 8;
1556     int ilv, prev_shift;
1557
1558     if (!s->got_picture) {
1559         av_log(s->avctx, AV_LOG_WARNING,
1560                 "Can not process SOS before SOF, skipping\n");
1561         return -1;
1562     }
1563
1564     if (reference) {
1565         if (reference->width  != s->picture_ptr->width  ||
1566             reference->height != s->picture_ptr->height ||
1567             reference->format != s->picture_ptr->format) {
1568             av_log(s->avctx, AV_LOG_ERROR, "Reference mismatching\n");
1569             return AVERROR_INVALIDDATA;
1570         }
1571     }
1572
1573     /* XXX: verify len field validity */
1574     len = get_bits(&s->gb, 16);
1575     nb_components = get_bits(&s->gb, 8);
1576     if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
1577         avpriv_report_missing_feature(s->avctx,
1578                                       "decode_sos: nb_components (%d)",
1579                                       nb_components);
1580         return AVERROR_PATCHWELCOME;
1581     }
1582     if (len != 6 + 2 * nb_components) {
1583         av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1584         return AVERROR_INVALIDDATA;
1585     }
1586     for (i = 0; i < nb_components; i++) {
1587         id = get_bits(&s->gb, 8) - 1;
1588         av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1589         /* find component index */
1590         for (index = 0; index < s->nb_components; index++)
1591             if (id == s->component_id[index])
1592                 break;
1593         if (index == s->nb_components) {
1594             av_log(s->avctx, AV_LOG_ERROR,
1595                    "decode_sos: index(%d) out of components\n", index);
1596             return AVERROR_INVALIDDATA;
1597         }
1598         /* Metasoft MJPEG codec has Cb and Cr swapped */
1599         if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
1600             && nb_components == 3 && s->nb_components == 3 && i)
1601             index = 3 - i;
1602
1603         s->quant_sindex[i] = s->quant_index[index];
1604         s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1605         s->h_scount[i]  = s->h_count[index];
1606         s->v_scount[i]  = s->v_count[index];
1607
1608         if((nb_components == 1 || nb_components == 3) && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
1609             index = (index+2)%3;
1610
1611         s->comp_index[i] = index;
1612
1613         s->dc_index[i] = get_bits(&s->gb, 4);
1614         s->ac_index[i] = get_bits(&s->gb, 4);
1615
1616         if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1617             s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1618             goto out_of_range;
1619         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))
1620             goto out_of_range;
1621     }
1622
1623     predictor = get_bits(&s->gb, 8);       /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1624     ilv = get_bits(&s->gb, 8);             /* JPEG Se / JPEG-LS ILV */
1625     if(s->avctx->codec_tag != AV_RL32("CJPG")){
1626         prev_shift      = get_bits(&s->gb, 4); /* Ah */
1627         point_transform = get_bits(&s->gb, 4); /* Al */
1628     }else
1629         prev_shift = point_transform = 0;
1630
1631     if (nb_components > 1) {
1632         /* interleaved stream */
1633         s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1634         s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1635     } else if (!s->ls) { /* skip this for JPEG-LS */
1636         h = s->h_max / s->h_scount[0];
1637         v = s->v_max / s->v_scount[0];
1638         s->mb_width     = (s->width  + h * block_size - 1) / (h * block_size);
1639         s->mb_height    = (s->height + v * block_size - 1) / (v * block_size);
1640         s->nb_blocks[0] = 1;
1641         s->h_scount[0]  = 1;
1642         s->v_scount[0]  = 1;
1643     }
1644
1645     if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1646         av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n",
1647                s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",
1648                predictor, point_transform, ilv, s->bits, s->mjpb_skiptosod,
1649                s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), nb_components);
1650
1651
1652     /* mjpeg-b can have padding bytes between sos and image data, skip them */
1653     for (i = s->mjpb_skiptosod; i > 0; i--)
1654         skip_bits(&s->gb, 8);
1655
1656 next_field:
1657     for (i = 0; i < nb_components; i++)
1658         s->last_dc[i] = (4 << s->bits);
1659
1660     if (s->avctx->hwaccel) {
1661         int bytes_to_start = get_bits_count(&s->gb) / 8;
1662         av_assert0(bytes_to_start >= 0 &&
1663                    s->raw_scan_buffer_size >= bytes_to_start);
1664
1665         ret = s->avctx->hwaccel->decode_slice(s->avctx,
1666                                               s->raw_scan_buffer      + bytes_to_start,
1667                                               s->raw_scan_buffer_size - bytes_to_start);
1668         if (ret < 0)
1669             return ret;
1670
1671     } else if (s->lossless) {
1672         av_assert0(s->picture_ptr == s->picture);
1673         if (CONFIG_JPEGLS_DECODER && s->ls) {
1674 //            for () {
1675 //            reset_ls_coding_parameters(s, 0);
1676
1677             if ((ret = ff_jpegls_decode_picture(s, predictor,
1678                                                 point_transform, ilv)) < 0)
1679                 return ret;
1680         } else {
1681             if (s->rgb) {
1682                 if ((ret = ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform)) < 0)
1683                     return ret;
1684             } else {
1685                 if ((ret = ljpeg_decode_yuv_scan(s, predictor,
1686                                                  point_transform,
1687                                                  nb_components)) < 0)
1688                     return ret;
1689             }
1690         }
1691     } else {
1692         if (s->progressive && predictor) {
1693             av_assert0(s->picture_ptr == s->picture);
1694             if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor,
1695                                                         ilv, prev_shift,
1696                                                         point_transform)) < 0)
1697                 return ret;
1698         } else {
1699             if ((ret = mjpeg_decode_scan(s, nb_components,
1700                                          prev_shift, point_transform,
1701                                          mb_bitmask, mb_bitmask_size, reference)) < 0)
1702                 return ret;
1703         }
1704     }
1705
1706     if (s->interlaced &&
1707         get_bits_left(&s->gb) > 32 &&
1708         show_bits(&s->gb, 8) == 0xFF) {
1709         GetBitContext bak = s->gb;
1710         align_get_bits(&bak);
1711         if (show_bits(&bak, 16) == 0xFFD1) {
1712             av_log(s->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n");
1713             s->gb = bak;
1714             skip_bits(&s->gb, 16);
1715             s->bottom_field ^= 1;
1716
1717             goto next_field;
1718         }
1719     }
1720
1721     emms_c();
1722     return 0;
1723  out_of_range:
1724     av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1725     return AVERROR_INVALIDDATA;
1726 }
1727
1728 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1729 {
1730     if (get_bits(&s->gb, 16) != 4)
1731         return AVERROR_INVALIDDATA;
1732     s->restart_interval = get_bits(&s->gb, 16);
1733     s->restart_count    = 0;
1734     av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
1735            s->restart_interval);
1736
1737     return 0;
1738 }
1739
1740 static int mjpeg_decode_app(MJpegDecodeContext *s)
1741 {
1742     int len, id, i;
1743
1744     len = get_bits(&s->gb, 16);
1745     if (len < 6)
1746         return AVERROR_INVALIDDATA;
1747     if (8 * len > get_bits_left(&s->gb))
1748         return AVERROR_INVALIDDATA;
1749
1750     id   = get_bits_long(&s->gb, 32);
1751     len -= 6;
1752
1753     if (s->avctx->debug & FF_DEBUG_STARTCODE)
1754         av_log(s->avctx, AV_LOG_DEBUG, "APPx (%s / %8X) len=%d\n",
1755                av_fourcc2str(av_bswap32(id)), id, len);
1756
1757     /* Buggy AVID, it puts EOI only at every 10th frame. */
1758     /* Also, this fourcc is used by non-avid files too, it holds some
1759        information, but it's always present in AVID-created files. */
1760     if (id == AV_RB32("AVI1")) {
1761         /* structure:
1762             4bytes      AVI1
1763             1bytes      polarity
1764             1bytes      always zero
1765             4bytes      field_size
1766             4bytes      field_size_less_padding
1767         */
1768             s->buggy_avid = 1;
1769         i = get_bits(&s->gb, 8); len--;
1770         av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i);
1771         goto out;
1772     }
1773
1774     if (id == AV_RB32("JFIF")) {
1775         int t_w, t_h, v1, v2;
1776         if (len < 8)
1777             goto out;
1778         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1779         v1 = get_bits(&s->gb, 8);
1780         v2 = get_bits(&s->gb, 8);
1781         skip_bits(&s->gb, 8);
1782
1783         s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 16);
1784         s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16);
1785         if (   s->avctx->sample_aspect_ratio.num <= 0
1786             || s->avctx->sample_aspect_ratio.den <= 0) {
1787             s->avctx->sample_aspect_ratio.num = 0;
1788             s->avctx->sample_aspect_ratio.den = 1;
1789         }
1790
1791         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1792             av_log(s->avctx, AV_LOG_INFO,
1793                    "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1794                    v1, v2,
1795                    s->avctx->sample_aspect_ratio.num,
1796                    s->avctx->sample_aspect_ratio.den);
1797
1798         len -= 8;
1799         if (len >= 2) {
1800             t_w = get_bits(&s->gb, 8);
1801             t_h = get_bits(&s->gb, 8);
1802             if (t_w && t_h) {
1803                 /* skip thumbnail */
1804                 if (len -10 - (t_w * t_h * 3) > 0)
1805                     len -= t_w * t_h * 3;
1806             }
1807             len -= 2;
1808         }
1809         goto out;
1810     }
1811
1812     if (   id == AV_RB32("Adob")
1813         && len >= 7
1814         && show_bits(&s->gb, 8) == 'e'
1815         && show_bits_long(&s->gb, 32) != AV_RB32("e_CM")) {
1816         skip_bits(&s->gb,  8); /* 'e' */
1817         skip_bits(&s->gb, 16); /* version */
1818         skip_bits(&s->gb, 16); /* flags0 */
1819         skip_bits(&s->gb, 16); /* flags1 */
1820         s->adobe_transform = get_bits(&s->gb,  8);
1821         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1822             av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found, transform=%d\n", s->adobe_transform);
1823         len -= 7;
1824         goto out;
1825     }
1826
1827     if (id == AV_RB32("LJIF")) {
1828         int rgb = s->rgb;
1829         int pegasus_rct = s->pegasus_rct;
1830         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1831             av_log(s->avctx, AV_LOG_INFO,
1832                    "Pegasus lossless jpeg header found\n");
1833         skip_bits(&s->gb, 16); /* version ? */
1834         skip_bits(&s->gb, 16); /* unknown always 0? */
1835         skip_bits(&s->gb, 16); /* unknown always 0? */
1836         skip_bits(&s->gb, 16); /* unknown always 0? */
1837         switch (i=get_bits(&s->gb, 8)) {
1838         case 1:
1839             rgb         = 1;
1840             pegasus_rct = 0;
1841             break;
1842         case 2:
1843             rgb         = 1;
1844             pegasus_rct = 1;
1845             break;
1846         default:
1847             av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace %d\n", i);
1848         }
1849
1850         len -= 9;
1851         if (s->got_picture)
1852             if (rgb != s->rgb || pegasus_rct != s->pegasus_rct) {
1853                 av_log(s->avctx, AV_LOG_WARNING, "Mismatching LJIF tag\n");
1854                 goto out;
1855             }
1856
1857         s->rgb = rgb;
1858         s->pegasus_rct = pegasus_rct;
1859
1860         goto out;
1861     }
1862     if (id == AV_RL32("colr") && len > 0) {
1863         s->colr = get_bits(&s->gb, 8);
1864         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1865             av_log(s->avctx, AV_LOG_INFO, "COLR %d\n", s->colr);
1866         len --;
1867         goto out;
1868     }
1869     if (id == AV_RL32("xfrm") && len > 0) {
1870         s->xfrm = get_bits(&s->gb, 8);
1871         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1872             av_log(s->avctx, AV_LOG_INFO, "XFRM %d\n", s->xfrm);
1873         len --;
1874         goto out;
1875     }
1876
1877     /* JPS extension by VRex */
1878     if (s->start_code == APP3 && id == AV_RB32("_JPS") && len >= 10) {
1879         int flags, layout, type;
1880         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1881             av_log(s->avctx, AV_LOG_INFO, "_JPSJPS_\n");
1882
1883         skip_bits(&s->gb, 32); len -= 4;  /* JPS_ */
1884         skip_bits(&s->gb, 16); len -= 2;  /* block length */
1885         skip_bits(&s->gb, 8);             /* reserved */
1886         flags  = get_bits(&s->gb, 8);
1887         layout = get_bits(&s->gb, 8);
1888         type   = get_bits(&s->gb, 8);
1889         len -= 4;
1890
1891         s->stereo3d = av_stereo3d_alloc();
1892         if (!s->stereo3d) {
1893             goto out;
1894         }
1895         if (type == 0) {
1896             s->stereo3d->type = AV_STEREO3D_2D;
1897         } else if (type == 1) {
1898             switch (layout) {
1899             case 0x01:
1900                 s->stereo3d->type = AV_STEREO3D_LINES;
1901                 break;
1902             case 0x02:
1903                 s->stereo3d->type = AV_STEREO3D_SIDEBYSIDE;
1904                 break;
1905             case 0x03:
1906                 s->stereo3d->type = AV_STEREO3D_TOPBOTTOM;
1907                 break;
1908             }
1909             if (!(flags & 0x04)) {
1910                 s->stereo3d->flags = AV_STEREO3D_FLAG_INVERT;
1911             }
1912         }
1913         goto out;
1914     }
1915
1916     /* EXIF metadata */
1917     if (s->start_code == APP1 && id == AV_RB32("Exif") && len >= 2) {
1918         GetByteContext gbytes;
1919         int ret, le, ifd_offset, bytes_read;
1920         const uint8_t *aligned;
1921
1922         skip_bits(&s->gb, 16); // skip padding
1923         len -= 2;
1924
1925         // init byte wise reading
1926         aligned = align_get_bits(&s->gb);
1927         bytestream2_init(&gbytes, aligned, len);
1928
1929         // read TIFF header
1930         ret = ff_tdecode_header(&gbytes, &le, &ifd_offset);
1931         if (ret) {
1932             av_log(s->avctx, AV_LOG_ERROR, "mjpeg: invalid TIFF header in EXIF data\n");
1933         } else {
1934             bytestream2_seek(&gbytes, ifd_offset, SEEK_SET);
1935
1936             // read 0th IFD and store the metadata
1937             // (return values > 0 indicate the presence of subimage metadata)
1938             ret = ff_exif_decode_ifd(s->avctx, &gbytes, le, 0, &s->exif_metadata);
1939             if (ret < 0) {
1940                 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error decoding EXIF data\n");
1941             }
1942         }
1943
1944         bytes_read = bytestream2_tell(&gbytes);
1945         skip_bits(&s->gb, bytes_read << 3);
1946         len -= bytes_read;
1947
1948         goto out;
1949     }
1950
1951     /* Apple MJPEG-A */
1952     if ((s->start_code == APP1) && (len > (0x28 - 8))) {
1953         id   = get_bits_long(&s->gb, 32);
1954         len -= 4;
1955         /* Apple MJPEG-A */
1956         if (id == AV_RB32("mjpg")) {
1957             /* structure:
1958                 4bytes      field size
1959                 4bytes      pad field size
1960                 4bytes      next off
1961                 4bytes      quant off
1962                 4bytes      huff off
1963                 4bytes      image off
1964                 4bytes      scan off
1965                 4bytes      data off
1966             */
1967             if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1968                 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1969         }
1970     }
1971
1972     if (s->start_code == APP2 && id == AV_RB32("ICC_") && len >= 10) {
1973         int id2;
1974         unsigned seqno;
1975         unsigned nummarkers;
1976
1977         id   = get_bits_long(&s->gb, 32);
1978         id2  = get_bits_long(&s->gb, 24);
1979         len -= 7;
1980         if (id != AV_RB32("PROF") || id2 != AV_RB24("ILE")) {
1981             av_log(s->avctx, AV_LOG_WARNING, "Invalid ICC_PROFILE header in APP2\n");
1982             goto out;
1983         }
1984
1985         skip_bits(&s->gb, 8);
1986         seqno  = get_bits(&s->gb, 8);
1987         len   -= 2;
1988         if (seqno == 0) {
1989             av_log(s->avctx, AV_LOG_WARNING, "Invalid sequence number in APP2\n");
1990             goto out;
1991         }
1992
1993         nummarkers  = get_bits(&s->gb, 8);
1994         len        -= 1;
1995         if (nummarkers == 0) {
1996             av_log(s->avctx, AV_LOG_WARNING, "Invalid number of markers coded in APP2\n");
1997             goto out;
1998         } else if (s->iccnum != 0 && nummarkers != s->iccnum) {
1999             av_log(s->avctx, AV_LOG_WARNING, "Mistmatch in coded number of ICC markers between markers\n");
2000             goto out;
2001         } else if (seqno > nummarkers) {
2002             av_log(s->avctx, AV_LOG_WARNING, "Mismatching sequence number and coded number of ICC markers\n");
2003             goto out;
2004         }
2005
2006         /* Allocate if this is the first APP2 we've seen. */
2007         if (s->iccnum == 0) {
2008             s->iccdata     = av_mallocz(nummarkers * sizeof(*(s->iccdata)));
2009             s->iccdatalens = av_mallocz(nummarkers * sizeof(*(s->iccdatalens)));
2010             if (!s->iccdata || !s->iccdatalens) {
2011                 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data arrays\n");
2012                 return AVERROR(ENOMEM);
2013             }
2014             s->iccnum = nummarkers;
2015         }
2016
2017         if (s->iccdata[seqno - 1]) {
2018             av_log(s->avctx, AV_LOG_WARNING, "Duplicate ICC sequence number\n");
2019             goto out;
2020         }
2021
2022         s->iccdatalens[seqno - 1]  = len;
2023         s->iccdata[seqno - 1]      = av_malloc(len);
2024         if (!s->iccdata[seqno - 1]) {
2025             av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data buffer\n");
2026             return AVERROR(ENOMEM);
2027         }
2028
2029         memcpy(s->iccdata[seqno - 1], align_get_bits(&s->gb), len);
2030         skip_bits(&s->gb, len << 3);
2031         len = 0;
2032         s->iccread++;
2033
2034         if (s->iccread > s->iccnum)
2035             av_log(s->avctx, AV_LOG_WARNING, "Read more ICC markers than are supposed to be coded\n");
2036     }
2037
2038 out:
2039     /* slow but needed for extreme adobe jpegs */
2040     if (len < 0)
2041         av_log(s->avctx, AV_LOG_ERROR,
2042                "mjpeg: error, decode_app parser read over the end\n");
2043     while (--len > 0)
2044         skip_bits(&s->gb, 8);
2045
2046     return 0;
2047 }
2048
2049 static int mjpeg_decode_com(MJpegDecodeContext *s)
2050 {
2051     int len = get_bits(&s->gb, 16);
2052     if (len >= 2 && 8 * len - 16 <= get_bits_left(&s->gb)) {
2053         int i;
2054         char *cbuf = av_malloc(len - 1);
2055         if (!cbuf)
2056             return AVERROR(ENOMEM);
2057
2058         for (i = 0; i < len - 2; i++)
2059             cbuf[i] = get_bits(&s->gb, 8);
2060         if (i > 0 && cbuf[i - 1] == '\n')
2061             cbuf[i - 1] = 0;
2062         else
2063             cbuf[i] = 0;
2064
2065         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2066             av_log(s->avctx, AV_LOG_INFO, "comment: '%s'\n", cbuf);
2067
2068         /* buggy avid, it puts EOI only at every 10th frame */
2069         if (!strncmp(cbuf, "AVID", 4)) {
2070             parse_avid(s, cbuf, len);
2071         } else if (!strcmp(cbuf, "CS=ITU601"))
2072             s->cs_itu601 = 1;
2073         else if ((!strncmp(cbuf, "Intel(R) JPEG Library, version 1", 32) && s->avctx->codec_tag) ||
2074                  (!strncmp(cbuf, "Metasoft MJPEG Codec", 20)))
2075             s->flipped = 1;
2076         else if (!strcmp(cbuf, "MULTISCOPE II")) {
2077             s->avctx->sample_aspect_ratio = (AVRational) { 1, 2 };
2078             s->multiscope = 2;
2079         }
2080
2081         av_free(cbuf);
2082     }
2083
2084     return 0;
2085 }
2086
2087 /* return the 8 bit start code value and update the search
2088    state. Return -1 if no start code found */
2089 static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
2090 {
2091     const uint8_t *buf_ptr;
2092     unsigned int v, v2;
2093     int val;
2094     int skipped = 0;
2095
2096     buf_ptr = *pbuf_ptr;
2097     while (buf_end - buf_ptr > 1) {
2098         v  = *buf_ptr++;
2099         v2 = *buf_ptr;
2100         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
2101             val = *buf_ptr++;
2102             goto found;
2103         }
2104         skipped++;
2105     }
2106     buf_ptr = buf_end;
2107     val = -1;
2108 found:
2109     ff_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
2110     *pbuf_ptr = buf_ptr;
2111     return val;
2112 }
2113
2114 int ff_mjpeg_find_marker(MJpegDecodeContext *s,
2115                          const uint8_t **buf_ptr, const uint8_t *buf_end,
2116                          const uint8_t **unescaped_buf_ptr,
2117                          int *unescaped_buf_size)
2118 {
2119     int start_code;
2120     start_code = find_marker(buf_ptr, buf_end);
2121
2122     av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr);
2123     if (!s->buffer)
2124         return AVERROR(ENOMEM);
2125
2126     /* unescape buffer of SOS, use special treatment for JPEG-LS */
2127     if (start_code == SOS && !s->ls) {
2128         const uint8_t *src = *buf_ptr;
2129         const uint8_t *ptr = src;
2130         uint8_t *dst = s->buffer;
2131
2132         #define copy_data_segment(skip) do {       \
2133             ptrdiff_t length = (ptr - src) - (skip);  \
2134             if (length > 0) {                         \
2135                 memcpy(dst, src, length);             \
2136                 dst += length;                        \
2137                 src = ptr;                            \
2138             }                                         \
2139         } while (0)
2140
2141         if (s->avctx->codec_id == AV_CODEC_ID_THP) {
2142             ptr = buf_end;
2143             copy_data_segment(0);
2144         } else {
2145             while (ptr < buf_end) {
2146                 uint8_t x = *(ptr++);
2147
2148                 if (x == 0xff) {
2149                     ptrdiff_t skip = 0;
2150                     while (ptr < buf_end && x == 0xff) {
2151                         x = *(ptr++);
2152                         skip++;
2153                     }
2154
2155                     /* 0xFF, 0xFF, ... */
2156                     if (skip > 1) {
2157                         copy_data_segment(skip);
2158
2159                         /* decrement src as it is equal to ptr after the
2160                          * copy_data_segment macro and we might want to
2161                          * copy the current value of x later on */
2162                         src--;
2163                     }
2164
2165                     if (x < 0xd0 || x > 0xd7) {
2166                         copy_data_segment(1);
2167                         if (x)
2168                             break;
2169                     }
2170                 }
2171             }
2172             if (src < ptr)
2173                 copy_data_segment(0);
2174         }
2175         #undef copy_data_segment
2176
2177         *unescaped_buf_ptr  = s->buffer;
2178         *unescaped_buf_size = dst - s->buffer;
2179         memset(s->buffer + *unescaped_buf_size, 0,
2180                AV_INPUT_BUFFER_PADDING_SIZE);
2181
2182         av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %"PTRDIFF_SPECIFIER" bytes\n",
2183                (buf_end - *buf_ptr) - (dst - s->buffer));
2184     } else if (start_code == SOS && s->ls) {
2185         const uint8_t *src = *buf_ptr;
2186         uint8_t *dst  = s->buffer;
2187         int bit_count = 0;
2188         int t = 0, b = 0;
2189         PutBitContext pb;
2190
2191         /* find marker */
2192         while (src + t < buf_end) {
2193             uint8_t x = src[t++];
2194             if (x == 0xff) {
2195                 while ((src + t < buf_end) && x == 0xff)
2196                     x = src[t++];
2197                 if (x & 0x80) {
2198                     t -= FFMIN(2, t);
2199                     break;
2200                 }
2201             }
2202         }
2203         bit_count = t * 8;
2204         init_put_bits(&pb, dst, t);
2205
2206         /* unescape bitstream */
2207         while (b < t) {
2208             uint8_t x = src[b++];
2209             put_bits(&pb, 8, x);
2210             if (x == 0xFF && b < t) {
2211                 x = src[b++];
2212                 if (x & 0x80) {
2213                     av_log(s->avctx, AV_LOG_WARNING, "Invalid escape sequence\n");
2214                     x &= 0x7f;
2215                 }
2216                 put_bits(&pb, 7, x);
2217                 bit_count--;
2218             }
2219         }
2220         flush_put_bits(&pb);
2221
2222         *unescaped_buf_ptr  = dst;
2223         *unescaped_buf_size = (bit_count + 7) >> 3;
2224         memset(s->buffer + *unescaped_buf_size, 0,
2225                AV_INPUT_BUFFER_PADDING_SIZE);
2226     } else {
2227         *unescaped_buf_ptr  = *buf_ptr;
2228         *unescaped_buf_size = buf_end - *buf_ptr;
2229     }
2230
2231     return start_code;
2232 }
2233
2234 static void reset_icc_profile(MJpegDecodeContext *s)
2235 {
2236     int i;
2237
2238     if (s->iccdata)
2239         for (i = 0; i < s->iccnum; i++)
2240             av_freep(&s->iccdata[i]);
2241     av_freep(&s->iccdata);
2242     av_freep(&s->iccdatalens);
2243
2244     s->iccread = 0;
2245     s->iccnum  = 0;
2246 }
2247
2248 int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
2249                           AVPacket *avpkt)
2250 {
2251     AVFrame     *frame = data;
2252     const uint8_t *buf = avpkt->data;
2253     int buf_size       = avpkt->size;
2254     MJpegDecodeContext *s = avctx->priv_data;
2255     const uint8_t *buf_end, *buf_ptr;
2256     const uint8_t *unescaped_buf_ptr;
2257     int hshift, vshift;
2258     int unescaped_buf_size;
2259     int start_code;
2260     int i, index;
2261     int ret = 0;
2262     int is16bit;
2263
2264     s->buf_size = buf_size;
2265
2266     av_dict_free(&s->exif_metadata);
2267     av_freep(&s->stereo3d);
2268     s->adobe_transform = -1;
2269
2270     if (s->iccnum != 0)
2271         reset_icc_profile(s);
2272
2273     buf_ptr = buf;
2274     buf_end = buf + buf_size;
2275     while (buf_ptr < buf_end) {
2276         /* find start next marker */
2277         start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,
2278                                           &unescaped_buf_ptr,
2279                                           &unescaped_buf_size);
2280         /* EOF */
2281         if (start_code < 0) {
2282             break;
2283         } else if (unescaped_buf_size > INT_MAX / 8) {
2284             av_log(avctx, AV_LOG_ERROR,
2285                    "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
2286                    start_code, unescaped_buf_size, buf_size);
2287             return AVERROR_INVALIDDATA;
2288         }
2289         av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%"PTRDIFF_SPECIFIER"\n",
2290                start_code, buf_end - buf_ptr);
2291
2292         ret = init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);
2293
2294         if (ret < 0) {
2295             av_log(avctx, AV_LOG_ERROR, "invalid buffer\n");
2296             goto fail;
2297         }
2298
2299         s->start_code = start_code;
2300         if (s->avctx->debug & FF_DEBUG_STARTCODE)
2301             av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2302
2303         /* process markers */
2304         if (start_code >= 0xd0 && start_code <= 0xd7) {
2305             av_log(avctx, AV_LOG_DEBUG,
2306                    "restart marker: %d\n", start_code & 0x0f);
2307             /* APP fields */
2308         } else if (start_code >= APP0 && start_code <= APP15) {
2309             if ((ret = mjpeg_decode_app(s)) < 0)
2310                 av_log(avctx, AV_LOG_ERROR, "unable to decode APP fields: %s\n",
2311                        av_err2str(ret));
2312             /* Comment */
2313         } else if (start_code == COM) {
2314             ret = mjpeg_decode_com(s);
2315             if (ret < 0)
2316                 return ret;
2317         } else if (start_code == DQT) {
2318             ret = ff_mjpeg_decode_dqt(s);
2319             if (ret < 0)
2320                 return ret;
2321         }
2322
2323         ret = -1;
2324
2325         if (!CONFIG_JPEGLS_DECODER &&
2326             (start_code == SOF48 || start_code == LSE)) {
2327             av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");
2328             return AVERROR(ENOSYS);
2329         }
2330
2331         if (avctx->skip_frame == AVDISCARD_ALL) {
2332             switch(start_code) {
2333             case SOF0:
2334             case SOF1:
2335             case SOF2:
2336             case SOF3:
2337             case SOF48:
2338             case SOI:
2339             case SOS:
2340             case EOI:
2341                 break;
2342             default:
2343                 goto skip;
2344             }
2345         }
2346
2347         switch (start_code) {
2348         case SOI:
2349             s->restart_interval = 0;
2350             s->restart_count    = 0;
2351             s->raw_image_buffer      = buf_ptr;
2352             s->raw_image_buffer_size = buf_end - buf_ptr;
2353             /* nothing to do on SOI */
2354             break;
2355         case DHT:
2356             if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
2357                 av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2358                 goto fail;
2359             }
2360             break;
2361         case SOF0:
2362         case SOF1:
2363             if (start_code == SOF0)
2364                 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT;
2365             else
2366                 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT;
2367             s->lossless    = 0;
2368             s->ls          = 0;
2369             s->progressive = 0;
2370             if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2371                 goto fail;
2372             break;
2373         case SOF2:
2374             s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT;
2375             s->lossless    = 0;
2376             s->ls          = 0;
2377             s->progressive = 1;
2378             if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2379                 goto fail;
2380             break;
2381         case SOF3:
2382             s->avctx->profile     = FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS;
2383             s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2384             s->lossless    = 1;
2385             s->ls          = 0;
2386             s->progressive = 0;
2387             if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2388                 goto fail;
2389             break;
2390         case SOF48:
2391             s->avctx->profile     = FF_PROFILE_MJPEG_JPEG_LS;
2392             s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2393             s->lossless    = 1;
2394             s->ls          = 1;
2395             s->progressive = 0;
2396             if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2397                 goto fail;
2398             break;
2399         case LSE:
2400             if (!CONFIG_JPEGLS_DECODER ||
2401                 (ret = ff_jpegls_decode_lse(s)) < 0)
2402                 goto fail;
2403             break;
2404         case EOI:
2405 eoi_parser:
2406             if (!avctx->hwaccel && avctx->skip_frame != AVDISCARD_ALL &&
2407                 s->progressive && s->cur_scan && s->got_picture)
2408                 mjpeg_idct_scan_progressive_ac(s);
2409             s->cur_scan = 0;
2410             if (!s->got_picture) {
2411                 av_log(avctx, AV_LOG_WARNING,
2412                        "Found EOI before any SOF, ignoring\n");
2413                 break;
2414             }
2415             if (s->interlaced) {
2416                 s->bottom_field ^= 1;
2417                 /* if not bottom field, do not output image yet */
2418                 if (s->bottom_field == !s->interlace_polarity)
2419                     break;
2420             }
2421             if (avctx->skip_frame == AVDISCARD_ALL) {
2422                 s->got_picture = 0;
2423                 goto the_end_no_picture;
2424             }
2425             if (s->avctx->hwaccel) {
2426                 ret = s->avctx->hwaccel->end_frame(s->avctx);
2427                 if (ret < 0)
2428                     return ret;
2429
2430                 av_freep(&s->hwaccel_picture_private);
2431             }
2432             if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
2433                 return ret;
2434             *got_frame = 1;
2435             s->got_picture = 0;
2436
2437             if (!s->lossless) {
2438                 int qp = FFMAX3(s->qscale[0],
2439                                 s->qscale[1],
2440                                 s->qscale[2]);
2441                 int qpw = (s->width + 15) / 16;
2442                 AVBufferRef *qp_table_buf = av_buffer_alloc(qpw);
2443                 if (qp_table_buf) {
2444                     memset(qp_table_buf->data, qp, qpw);
2445                     av_frame_set_qp_table(data, qp_table_buf, 0, FF_QSCALE_TYPE_MPEG1);
2446                 }
2447
2448                 if(avctx->debug & FF_DEBUG_QP)
2449                     av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);
2450             }
2451
2452             goto the_end;
2453         case SOS:
2454             s->raw_scan_buffer      = buf_ptr;
2455             s->raw_scan_buffer_size = buf_end - buf_ptr;
2456
2457             s->cur_scan++;
2458             if (avctx->skip_frame == AVDISCARD_ALL) {
2459                 skip_bits(&s->gb, get_bits_left(&s->gb));
2460                 break;
2461             }
2462
2463             if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&
2464                 (avctx->err_recognition & AV_EF_EXPLODE))
2465                 goto fail;
2466             break;
2467         case DRI:
2468             if ((ret = mjpeg_decode_dri(s)) < 0)
2469                 return ret;
2470             break;
2471         case SOF5:
2472         case SOF6:
2473         case SOF7:
2474         case SOF9:
2475         case SOF10:
2476         case SOF11:
2477         case SOF13:
2478         case SOF14:
2479         case SOF15:
2480         case JPG:
2481             av_log(avctx, AV_LOG_ERROR,
2482                    "mjpeg: unsupported coding type (%x)\n", start_code);
2483             break;
2484         }
2485
2486 skip:
2487         /* eof process start code */
2488         buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
2489         av_log(avctx, AV_LOG_DEBUG,
2490                "marker parser used %d bytes (%d bits)\n",
2491                (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
2492     }
2493     if (s->got_picture && s->cur_scan) {
2494         av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
2495         goto eoi_parser;
2496     }
2497     av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
2498     return AVERROR_INVALIDDATA;
2499 fail:
2500     s->got_picture = 0;
2501     return ret;
2502 the_end:
2503
2504     is16bit = av_pix_fmt_desc_get(s->avctx->pix_fmt)->comp[0].step > 1;
2505
2506     if (AV_RB32(s->upscale_h)) {
2507         int p;
2508         av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2509                    avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||
2510                    avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2511                    avctx->pix_fmt == AV_PIX_FMT_YUV440P  ||
2512                    avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2513                    avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2514                    avctx->pix_fmt == AV_PIX_FMT_YUV420P  ||
2515                    avctx->pix_fmt == AV_PIX_FMT_YUV420P16||
2516                    avctx->pix_fmt == AV_PIX_FMT_YUVA420P  ||
2517                    avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2518                    avctx->pix_fmt == AV_PIX_FMT_GBRP     ||
2519                    avctx->pix_fmt == AV_PIX_FMT_GBRAP
2520                   );
2521         ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2522         if (ret)
2523             return ret;
2524
2525         av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2526         for (p = 0; p<s->nb_components; p++) {
2527             uint8_t *line = s->picture_ptr->data[p];
2528             int w = s->width;
2529             int h = s->height;
2530             if (!s->upscale_h[p])
2531                 continue;
2532             if (p==1 || p==2) {
2533                 w = AV_CEIL_RSHIFT(w, hshift);
2534                 h = AV_CEIL_RSHIFT(h, vshift);
2535             }
2536             if (s->upscale_v[p] == 1)
2537                 h = (h+1)>>1;
2538             av_assert0(w > 0);
2539             for (i = 0; i < h; i++) {
2540                 if (s->upscale_h[p] == 1) {
2541                     if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];
2542                     else                      line[w - 1] = line[(w - 1) / 2];
2543                     for (index = w - 2; index > 0; index--) {
2544                         if (is16bit)
2545                             ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;
2546                         else
2547                             line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
2548                     }
2549                 } else if (s->upscale_h[p] == 2) {
2550                     if (is16bit) {
2551                         ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3];
2552                         if (w > 1)
2553                             ((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1];
2554                     } else {
2555                         line[w - 1] = line[(w - 1) / 3];
2556                         if (w > 1)
2557                             line[w - 2] = line[w - 1];
2558                     }
2559                     for (index = w - 3; index > 0; index--) {
2560                         line[index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3;
2561                     }
2562                 }
2563                 line += s->linesize[p];
2564             }
2565         }
2566     }
2567     if (AV_RB32(s->upscale_v)) {
2568         int p;
2569         av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2570                    avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||
2571                    avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2572                    avctx->pix_fmt == AV_PIX_FMT_YUV422P  ||
2573                    avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2574                    avctx->pix_fmt == AV_PIX_FMT_YUV420P  ||
2575                    avctx->pix_fmt == AV_PIX_FMT_YUV440P  ||
2576                    avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2577                    avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2578                    avctx->pix_fmt == AV_PIX_FMT_YUVA420P  ||
2579                    avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2580                    avctx->pix_fmt == AV_PIX_FMT_GBRP     ||
2581                    avctx->pix_fmt == AV_PIX_FMT_GBRAP
2582                    );
2583         ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2584         if (ret)
2585             return ret;
2586
2587         av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2588         for (p = 0; p < s->nb_components; p++) {
2589             uint8_t *dst;
2590             int w = s->width;
2591             int h = s->height;
2592             if (!s->upscale_v[p])
2593                 continue;
2594             if (p==1 || p==2) {
2595                 w = AV_CEIL_RSHIFT(w, hshift);
2596                 h = AV_CEIL_RSHIFT(h, vshift);
2597             }
2598             dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];
2599             for (i = h - 1; i; i--) {
2600                 uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2601                 uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2602                 if (s->upscale_v[p] != 2 && (src1 == src2 || i == h - 1)) {
2603                     memcpy(dst, src1, w);
2604                 } else {
2605                     for (index = 0; index < w; index++)
2606                         dst[index] = (src1[index] + src2[index]) >> 1;
2607                 }
2608                 dst -= s->linesize[p];
2609             }
2610         }
2611     }
2612     if (s->flipped && !s->rgb) {
2613         int j;
2614         ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2615         if (ret)
2616             return ret;
2617
2618         av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2619         for (index=0; index<s->nb_components; index++) {
2620             uint8_t *dst = s->picture_ptr->data[index];
2621             int w = s->picture_ptr->width;
2622             int h = s->picture_ptr->height;
2623             if(index && index<3){
2624                 w = AV_CEIL_RSHIFT(w, hshift);
2625                 h = AV_CEIL_RSHIFT(h, vshift);
2626             }
2627             if(dst){
2628                 uint8_t *dst2 = dst + s->picture_ptr->linesize[index]*(h-1);
2629                 for (i=0; i<h/2; i++) {
2630                     for (j=0; j<w; j++)
2631                         FFSWAP(int, dst[j], dst2[j]);
2632                     dst  += s->picture_ptr->linesize[index];
2633                     dst2 -= s->picture_ptr->linesize[index];
2634                 }
2635             }
2636         }
2637     }
2638     if (s->adobe_transform == 0 && s->avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
2639         int w = s->picture_ptr->width;
2640         int h = s->picture_ptr->height;
2641         av_assert0(s->nb_components == 4);
2642         for (i=0; i<h; i++) {
2643             int j;
2644             uint8_t *dst[4];
2645             for (index=0; index<4; index++) {
2646                 dst[index] =   s->picture_ptr->data[index]
2647                              + s->picture_ptr->linesize[index]*i;
2648             }
2649             for (j=0; j<w; j++) {
2650                 int k = dst[3][j];
2651                 int r = dst[0][j] * k;
2652                 int g = dst[1][j] * k;
2653                 int b = dst[2][j] * k;
2654                 dst[0][j] = g*257 >> 16;
2655                 dst[1][j] = b*257 >> 16;
2656                 dst[2][j] = r*257 >> 16;
2657                 dst[3][j] = 255;
2658             }
2659         }
2660     }
2661     if (s->adobe_transform == 2 && s->avctx->pix_fmt == AV_PIX_FMT_YUVA444P) {
2662         int w = s->picture_ptr->width;
2663         int h = s->picture_ptr->height;
2664         av_assert0(s->nb_components == 4);
2665         for (i=0; i<h; i++) {
2666             int j;
2667             uint8_t *dst[4];
2668             for (index=0; index<4; index++) {
2669                 dst[index] =   s->picture_ptr->data[index]
2670                              + s->picture_ptr->linesize[index]*i;
2671             }
2672             for (j=0; j<w; j++) {
2673                 int k = dst[3][j];
2674                 int r = (255 - dst[0][j]) * k;
2675                 int g = (128 - dst[1][j]) * k;
2676                 int b = (128 - dst[2][j]) * k;
2677                 dst[0][j] = r*257 >> 16;
2678                 dst[1][j] = (g*257 >> 16) + 128;
2679                 dst[2][j] = (b*257 >> 16) + 128;
2680                 dst[3][j] = 255;
2681             }
2682         }
2683     }
2684
2685     if (s->stereo3d) {
2686         AVStereo3D *stereo = av_stereo3d_create_side_data(data);
2687         if (stereo) {
2688             stereo->type  = s->stereo3d->type;
2689             stereo->flags = s->stereo3d->flags;
2690         }
2691         av_freep(&s->stereo3d);
2692     }
2693
2694     if (s->iccnum != 0 && s->iccnum == s->iccread) {
2695         AVFrameSideData *sd;
2696         size_t offset = 0;
2697         int total_size = 0;
2698         int i;
2699
2700         /* Sum size of all parts. */
2701         for (i = 0; i < s->iccnum; i++)
2702             total_size += s->iccdatalens[i];
2703
2704         sd = av_frame_new_side_data(data, AV_FRAME_DATA_ICC_PROFILE, total_size);
2705         if (!sd) {
2706             av_log(s->avctx, AV_LOG_ERROR, "Could not allocate frame side data\n");
2707             return AVERROR(ENOMEM);
2708         }
2709
2710         /* Reassemble the parts, which are now in-order. */
2711         for (i = 0; i < s->iccnum; i++) {
2712             memcpy(sd->data + offset, s->iccdata[i], s->iccdatalens[i]);
2713             offset += s->iccdatalens[i];
2714         }
2715     }
2716
2717     av_dict_copy(&((AVFrame *) data)->metadata, s->exif_metadata, 0);
2718     av_dict_free(&s->exif_metadata);
2719
2720 the_end_no_picture:
2721     av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n",
2722            buf_end - buf_ptr);
2723 //  return buf_end - buf_ptr;
2724     return buf_ptr - buf;
2725 }
2726
2727 av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
2728 {
2729     MJpegDecodeContext *s = avctx->priv_data;
2730     int i, j;
2731
2732     if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_number) {
2733         av_log(avctx, AV_LOG_INFO, "Single field\n");
2734     }
2735
2736     if (s->picture) {
2737         av_frame_free(&s->picture);
2738         s->picture_ptr = NULL;
2739     } else if (s->picture_ptr)
2740         av_frame_unref(s->picture_ptr);
2741
2742     av_freep(&s->buffer);
2743     av_freep(&s->stereo3d);
2744     av_freep(&s->ljpeg_buffer);
2745     s->ljpeg_buffer_size = 0;
2746
2747     for (i = 0; i < 3; i++) {
2748         for (j = 0; j < 4; j++)
2749             ff_free_vlc(&s->vlcs[i][j]);
2750     }
2751     for (i = 0; i < MAX_COMPONENTS; i++) {
2752         av_freep(&s->blocks[i]);
2753         av_freep(&s->last_nnz[i]);
2754     }
2755     av_dict_free(&s->exif_metadata);
2756
2757     reset_icc_profile(s);
2758
2759     av_freep(&s->hwaccel_picture_private);
2760
2761     return 0;
2762 }
2763
2764 static void decode_flush(AVCodecContext *avctx)
2765 {
2766     MJpegDecodeContext *s = avctx->priv_data;
2767     s->got_picture = 0;
2768 }
2769
2770 #if CONFIG_MJPEG_DECODER
2771 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
2772 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2773 static const AVOption options[] = {
2774     { "extern_huff", "Use external huffman table.",
2775       OFFSET(extern_huff), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
2776     { NULL },
2777 };
2778
2779 static const AVClass mjpegdec_class = {
2780     .class_name = "MJPEG decoder",
2781     .item_name  = av_default_item_name,
2782     .option     = options,
2783     .version    = LIBAVUTIL_VERSION_INT,
2784 };
2785
2786 AVCodec ff_mjpeg_decoder = {
2787     .name           = "mjpeg",
2788     .long_name      = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
2789     .type           = AVMEDIA_TYPE_VIDEO,
2790     .id             = AV_CODEC_ID_MJPEG,
2791     .priv_data_size = sizeof(MJpegDecodeContext),
2792     .init           = ff_mjpeg_decode_init,
2793     .close          = ff_mjpeg_decode_end,
2794     .decode         = ff_mjpeg_decode_frame,
2795     .flush          = decode_flush,
2796     .capabilities   = AV_CODEC_CAP_DR1,
2797     .max_lowres     = 3,
2798     .priv_class     = &mjpegdec_class,
2799     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
2800                       FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2801     .hw_configs     = (const AVCodecHWConfigInternal*[]) {
2802 #if CONFIG_MJPEG_NVDEC_HWACCEL
2803                         HWACCEL_NVDEC(mjpeg),
2804 #endif
2805 #if CONFIG_MJPEG_VAAPI_HWACCEL
2806                         HWACCEL_VAAPI(mjpeg),
2807 #endif
2808                         NULL
2809                     },
2810 };
2811 #endif
2812 #if CONFIG_THP_DECODER
2813 AVCodec ff_thp_decoder = {
2814     .name           = "thp",
2815     .long_name      = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
2816     .type           = AVMEDIA_TYPE_VIDEO,
2817     .id             = AV_CODEC_ID_THP,
2818     .priv_data_size = sizeof(MJpegDecodeContext),
2819     .init           = ff_mjpeg_decode_init,
2820     .close          = ff_mjpeg_decode_end,
2821     .decode         = ff_mjpeg_decode_frame,
2822     .flush          = decode_flush,
2823     .capabilities   = AV_CODEC_CAP_DR1,
2824     .max_lowres     = 3,
2825     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
2826 };
2827 #endif