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 0x42111100:
 598     case 0x24111100:
 599         if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUVJ420P;
 600         else              s->avctx->pix_fmt = AV_PIX_FMT_YUV420P16;
 601         s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
 602         if (pix_fmt_id == 0x42111100) {
 603             if (s->bits > 8)
 604                 goto unk_pixfmt;
 605             s->upscale_h[1] = s->upscale_h[2] = 1;
 606         } else if (pix_fmt_id == 0x24111100) {
 607             if (s->bits > 8)
 608                 goto unk_pixfmt;
 609             s->upscale_v[1] = s->upscale_v[2] = 1;
 610         }
 611         break;
 612     case 0x41111100:
 613         if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV411P : AV_PIX_FMT_YUVJ411P;
 614         else
 615             goto unk_pixfmt;
 616         s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
 617         break;
 618     default:
 619 unk_pixfmt:
 620         avpriv_report_missing_feature(s->avctx, "Pixel format 0x%x bits:%d", pix_fmt_id, s->bits);
 621         memset(s->upscale_h, 0, sizeof(s->upscale_h));
 622         memset(s->upscale_v, 0, sizeof(s->upscale_v));
 623         return AVERROR_PATCHWELCOME;
 624     }
 625     if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->avctx->lowres) {
 626         avpriv_report_missing_feature(s->avctx, "Lowres for weird subsampling");
 627         return AVERROR_PATCHWELCOME;
 628     }
 629     if (s->ls) {
 630         memset(s->upscale_h, 0, sizeof(s->upscale_h));
 631         memset(s->upscale_v, 0, sizeof(s->upscale_v));
 632         if (s->nb_components == 3) {
 633             s->avctx->pix_fmt = AV_PIX_FMT_RGB24;
 634         } else if (s->nb_components != 1) {
 635             av_log(s->avctx, AV_LOG_ERROR, "Unsupported number of components %d\n", s->nb_components);
 636             return AVERROR_PATCHWELCOME;
 637         } else if (s->palette_index && s->bits <= 8)
 638             s->avctx->pix_fmt = AV_PIX_FMT_PAL8;
 639         else if (s->bits <= 8)
 640             s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
 641         else
 642             s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
 643     }
 644
 645     s->pix_desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
 646     if (!s->pix_desc) {
 647         av_log(s->avctx, AV_LOG_ERROR, "Could not get a pixel format descriptor.\n");
 648         return AVERROR_BUG;
 649     }
 650
 651     if (s->avctx->pix_fmt == s->hwaccel_sw_pix_fmt && !size_change) {
 652         s->avctx->pix_fmt = s->hwaccel_pix_fmt;
 653     } else {
 654         enum AVPixelFormat pix_fmts[] = {
 655 #if CONFIG_MJPEG_NVDEC_HWACCEL
 656             AV_PIX_FMT_CUDA,
 657 #endif
 658 #if CONFIG_MJPEG_VAAPI_HWACCEL
 659             AV_PIX_FMT_VAAPI,
 660 #endif
 661             s->avctx->pix_fmt,
 662             AV_PIX_FMT_NONE,
 663         };
 664         s->hwaccel_pix_fmt = ff_get_format(s->avctx, pix_fmts);
 665         if (s->hwaccel_pix_fmt < 0)
 666             return AVERROR(EINVAL);
 667
 668         s->hwaccel_sw_pix_fmt = s->avctx->pix_fmt;
 669         s->avctx->pix_fmt     = s->hwaccel_pix_fmt;
 670     }
 671
 672     if (s->avctx->skip_frame == AVDISCARD_ALL) {
 673         s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
 674         s->picture_ptr->key_frame = 1;
 675         s->got_picture            = 1;
 676         return 0;
 677     }
 678
 679     av_frame_unref(s->picture_ptr);
 680     if (ff_get_buffer(s->avctx, s->picture_ptr, AV_GET_BUFFER_FLAG_REF) < 0)
 681         return -1;
 682     s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
 683     s->picture_ptr->key_frame = 1;
 684     s->got_picture            = 1;
 685
 686     for (i = 0; i < 4; i++)
 687         s->linesize[i] = s->picture_ptr->linesize[i] << s->interlaced;
 688
 689     ff_dlog(s->avctx, "%d %d %d %d %d %d\n",
 690             s->width, s->height, s->linesize[0], s->linesize[1],
 691             s->interlaced, s->avctx->height);
 692
 693     if (len != (8 + (3 * nb_components)))
 694         av_log(s->avctx, AV_LOG_DEBUG, "decode_sof0: error, len(%d) mismatch\n", len);
 695     }
 696
 697     if ((s->rgb && !s->lossless && !s->ls) ||
 698         (!s->rgb && s->ls && s->nb_components > 1)) {
 699         av_log(s->avctx, AV_LOG_ERROR, "Unsupported coding and pixel format combination\n");
 700         return AVERROR_PATCHWELCOME;
 701     }
 702
 703     /* totally blank picture as progressive JPEG will only add details to it */
 704     if (s->progressive) {
 705         int bw = (width  + s->h_max * 8 - 1) / (s->h_max * 8);
 706         int bh = (height + s->v_max * 8 - 1) / (s->v_max * 8);
 707         for (i = 0; i < s->nb_components; i++) {
 708             int size = bw * bh * s->h_count[i] * s->v_count[i];
 709             av_freep(&s->blocks[i]);
 710             av_freep(&s->last_nnz[i]);
 711             s->blocks[i]       = av_mallocz_array(size, sizeof(**s->blocks));
 712             s->last_nnz[i]     = av_mallocz_array(size, sizeof(**s->last_nnz));
 713             if (!s->blocks[i] || !s->last_nnz[i])
 714                 return AVERROR(ENOMEM);
 715             s->block_stride[i] = bw * s->h_count[i];
 716         }
 717         memset(s->coefs_finished, 0, sizeof(s->coefs_finished));
 718     }
 719
 720     if (s->avctx->hwaccel) {
 721         s->hwaccel_picture_private =
 722             av_mallocz(s->avctx->hwaccel->frame_priv_data_size);
 723         if (!s->hwaccel_picture_private)
 724             return AVERROR(ENOMEM);
 725
 726         ret = s->avctx->hwaccel->start_frame(s->avctx, s->raw_image_buffer,
 727                                              s->raw_image_buffer_size);
 728         if (ret < 0)
 729             return ret;
 730     }
 731
 732     return 0;
 733 }
 734
 735 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
 736 {
 737     int code;
 738     code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
 739     if (code < 0 || code > 16) {
 740         av_log(s->avctx, AV_LOG_WARNING,
 741                "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
 742                0, dc_index, &s->vlcs[0][dc_index]);
 743         return 0xfffff;
 744     }
 745
 746     if (code)
 747         return get_xbits(&s->gb, code);
 748     else
 749         return 0;
 750 }
 751
 752 /* decode block and dequantize */
 753 static int decode_block(MJpegDecodeContext *s, int16_t *block, int component,
 754                         int dc_index, int ac_index, uint16_t *quant_matrix)
 755 {
 756     int code, i, j, level, val;
 757
 758     /* DC coef */
 759     val = mjpeg_decode_dc(s, dc_index);
 760     if (val == 0xfffff) {
 761         av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
 762         return AVERROR_INVALIDDATA;
 763     }
 764     val = val * (unsigned)quant_matrix[0] + s->last_dc[component];
 765     val = av_clip_int16(val);
 766     s->last_dc[component] = val;
 767     block[0] = val;
 768     /* AC coefs */
 769     i = 0;
 770     {OPEN_READER(re, &s->gb);
 771     do {
 772         UPDATE_CACHE(re, &s->gb);
 773         GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2);
 774
 775         i += ((unsigned)code) >> 4;
 776             code &= 0xf;
 777         if (code) {
 778             if (code > MIN_CACHE_BITS - 16)
 779                 UPDATE_CACHE(re, &s->gb);
 780
 781             {
 782                 int cache = GET_CACHE(re, &s->gb);
 783                 int sign  = (~cache) >> 31;
 784                 level     = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
 785             }
 786
 787             LAST_SKIP_BITS(re, &s->gb, code);
 788
 789             if (i > 63) {
 790                 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
 791                 return AVERROR_INVALIDDATA;
 792             }
 793             j        = s->scantable.permutated[i];
 794             block[j] = level * quant_matrix[i];
 795         }
 796     } while (i < 63);
 797     CLOSE_READER(re, &s->gb);}
 798
 799     return 0;
 800 }
 801
 802 static int decode_dc_progressive(MJpegDecodeContext *s, int16_t *block,
 803                                  int component, int dc_index,
 804                                  uint16_t *quant_matrix, int Al)
 805 {
 806     unsigned val;
 807     s->bdsp.clear_block(block);
 808     val = mjpeg_decode_dc(s, dc_index);
 809     if (val == 0xfffff) {
 810         av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
 811         return AVERROR_INVALIDDATA;
 812     }
 813     val = (val * (quant_matrix[0] << Al)) + s->last_dc[component];
 814     s->last_dc[component] = val;
 815     block[0] = val;
 816     return 0;
 817 }
 818
 819 /* decode block and dequantize - progressive JPEG version */
 820 static int decode_block_progressive(MJpegDecodeContext *s, int16_t *block,
 821                                     uint8_t *last_nnz, int ac_index,
 822                                     uint16_t *quant_matrix,
 823                                     int ss, int se, int Al, int *EOBRUN)
 824 {
 825     int code, i, j, val, run;
 826     unsigned level;
 827
 828     if (*EOBRUN) {
 829         (*EOBRUN)--;
 830         return 0;
 831     }
 832
 833     {
 834         OPEN_READER(re, &s->gb);
 835         for (i = ss; ; i++) {
 836             UPDATE_CACHE(re, &s->gb);
 837             GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
 838
 839             run = ((unsigned) code) >> 4;
 840             code &= 0xF;
 841             if (code) {
 842                 i += run;
 843                 if (code > MIN_CACHE_BITS - 16)
 844                     UPDATE_CACHE(re, &s->gb);
 845
 846                 {
 847                     int cache = GET_CACHE(re, &s->gb);
 848                     int sign  = (~cache) >> 31;
 849                     level     = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
 850                 }
 851
 852                 LAST_SKIP_BITS(re, &s->gb, code);
 853
 854                 if (i >= se) {
 855                     if (i == se) {
 856                         j = s->scantable.permutated[se];
 857                         block[j] = level * (quant_matrix[se] << Al);
 858                         break;
 859                     }
 860                     av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
 861                     return AVERROR_INVALIDDATA;
 862                 }
 863                 j = s->scantable.permutated[i];
 864                 block[j] = level * (quant_matrix[i] << Al);
 865             } else {
 866                 if (run == 0xF) {// ZRL - skip 15 coefficients
 867                     i += 15;
 868                     if (i >= se) {
 869                         av_log(s->avctx, AV_LOG_ERROR, "ZRL overflow: %d\n", i);
 870                         return AVERROR_INVALIDDATA;
 871                     }
 872                 } else {
 873                     val = (1 << run);
 874                     if (run) {
 875                         UPDATE_CACHE(re, &s->gb);
 876                         val += NEG_USR32(GET_CACHE(re, &s->gb), run);
 877                         LAST_SKIP_BITS(re, &s->gb, run);
 878                     }
 879                     *EOBRUN = val - 1;
 880                     break;
 881                 }
 882             }
 883         }
 884         CLOSE_READER(re, &s->gb);
 885     }
 886
 887     if (i > *last_nnz)
 888         *last_nnz = i;
 889
 890     return 0;
 891 }
 892
 893 #define REFINE_BIT(j) {                                             \
 894     UPDATE_CACHE(re, &s->gb);                                       \
 895     sign = block[j] >> 15;                                          \
 896     block[j] += SHOW_UBITS(re, &s->gb, 1) *                         \
 897                 ((quant_matrix[i] ^ sign) - sign) << Al;            \
 898     LAST_SKIP_BITS(re, &s->gb, 1);                                  \
 899 }
 900
 901 #define ZERO_RUN                                                    \
 902 for (; ; i++) {                                                     \
 903     if (i > last) {                                                 \
 904         i += run;                                                   \
 905         if (i > se) {                                               \
 906             av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \
 907             return -1;                                              \
 908         }                                                           \
 909         break;                                                      \
 910     }                                                               \
 911     j = s->scantable.permutated[i];                                 \
 912     if (block[j])                                                   \
 913         REFINE_BIT(j)                                               \
 914     else if (run-- == 0)                                            \
 915         break;                                                      \
 916 }
 917
 918 /* decode block and dequantize - progressive JPEG refinement pass */
 919 static int decode_block_refinement(MJpegDecodeContext *s, int16_t *block,
 920                                    uint8_t *last_nnz,
 921                                    int ac_index, uint16_t *quant_matrix,
 922                                    int ss, int se, int Al, int *EOBRUN)
 923 {
 924     int code, i = ss, j, sign, val, run;
 925     int last    = FFMIN(se, *last_nnz);
 926
 927     OPEN_READER(re, &s->gb);
 928     if (*EOBRUN) {
 929         (*EOBRUN)--;
 930     } else {
 931         for (; ; i++) {
 932             UPDATE_CACHE(re, &s->gb);
 933             GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
 934
 935             if (code & 0xF) {
 936                 run = ((unsigned) code) >> 4;
 937                 UPDATE_CACHE(re, &s->gb);
 938                 val = SHOW_UBITS(re, &s->gb, 1);
 939                 LAST_SKIP_BITS(re, &s->gb, 1);
 940                 ZERO_RUN;
 941                 j = s->scantable.permutated[i];
 942                 val--;
 943                 block[j] = ((quant_matrix[i] << Al) ^ val) - val;
 944                 if (i == se) {
 945                     if (i > *last_nnz)
 946                         *last_nnz = i;
 947                     CLOSE_READER(re, &s->gb);
 948                     return 0;
 949                 }
 950             } else {
 951                 run = ((unsigned) code) >> 4;
 952                 if (run == 0xF) {
 953                     ZERO_RUN;
 954                 } else {
 955                     val = run;
 956                     run = (1 << run);
 957                     if (val) {
 958                         UPDATE_CACHE(re, &s->gb);
 959                         run += SHOW_UBITS(re, &s->gb, val);
 960                         LAST_SKIP_BITS(re, &s->gb, val);
 961                     }
 962                     *EOBRUN = run - 1;
 963                     break;
 964                 }
 965             }
 966         }
 967
 968         if (i > *last_nnz)
 969             *last_nnz = i;
 970     }
 971
 972     for (; i <= last; i++) {
 973         j = s->scantable.permutated[i];
 974         if (block[j])
 975             REFINE_BIT(j)
 976     }
 977     CLOSE_READER(re, &s->gb);
 978
 979     return 0;
 980 }
 981 #undef REFINE_BIT
 982 #undef ZERO_RUN
 983
 984 static int handle_rstn(MJpegDecodeContext *s, int nb_components)
 985 {
 986     int i;
 987     int reset = 0;
 988
 989     if (s->restart_interval) {
 990         s->restart_count--;
 991         if(s->restart_count == 0 && s->avctx->codec_id == AV_CODEC_ID_THP){
 992             align_get_bits(&s->gb);
 993             for (i = 0; i < nb_components; i++) /* reset dc */
 994                 s->last_dc[i] = (4 << s->bits);
 995         }
 996
 997         i = 8 + ((-get_bits_count(&s->gb)) & 7);
 998         /* skip RSTn */
 999         if (s->restart_count == 0) {
1000             if(   show_bits(&s->gb, i) == (1 << i) - 1
1001                || show_bits(&s->gb, i) == 0xFF) {
1002                 int pos = get_bits_count(&s->gb);
1003                 align_get_bits(&s->gb);
1004                 while (get_bits_left(&s->gb) >= 8 && show_bits(&s->gb, 8) == 0xFF)
1005                     skip_bits(&s->gb, 8);
1006                 if (get_bits_left(&s->gb) >= 8 && (get_bits(&s->gb, 8) & 0xF8) == 0xD0) {
1007                     for (i = 0; i < nb_components; i++) /* reset dc */
1008                         s->last_dc[i] = (4 << s->bits);
1009                     reset = 1;
1010                 } else
1011                     skip_bits_long(&s->gb, pos - get_bits_count(&s->gb));
1012             }
1013         }
1014     }
1015     return reset;
1016 }
1017
1018 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int nb_components, int predictor, int point_transform)
1019 {
1020     int i, mb_x, mb_y;
1021     uint16_t (*buffer)[4];
1022     int left[4], top[4], topleft[4];
1023     const int linesize = s->linesize[0];
1024     const int mask     = ((1 << s->bits) - 1) << point_transform;
1025     int resync_mb_y = 0;
1026     int resync_mb_x = 0;
1027
1028     if (s->nb_components != 3 && s->nb_components != 4)
1029         return AVERROR_INVALIDDATA;
1030     if (s->v_max != 1 || s->h_max != 1 || !s->lossless)
1031         return AVERROR_INVALIDDATA;
1032
1033
1034     s->restart_count = s->restart_interval;
1035
1036     av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size,
1037                    (unsigned)s->mb_width * 4 * sizeof(s->ljpeg_buffer[0][0]));
1038     if (!s->ljpeg_buffer)
1039         return AVERROR(ENOMEM);
1040
1041     buffer = s->ljpeg_buffer;
1042
1043     for (i = 0; i < 4; i++)
1044         buffer[0][i] = 1 << (s->bits - 1);
1045
1046     for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1047         uint8_t *ptr = s->picture_ptr->data[0] + (linesize * mb_y);
1048
1049         if (s->interlaced && s->bottom_field)
1050             ptr += linesize >> 1;
1051
1052         for (i = 0; i < 4; i++)
1053             top[i] = left[i] = topleft[i] = buffer[0][i];
1054
1055         for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1056             int modified_predictor = predictor;
1057
1058             if (get_bits_left(&s->gb) < 1) {
1059                 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in rgb_scan\n");
1060                 return AVERROR_INVALIDDATA;
1061             }
1062
1063             if (s->restart_interval && !s->restart_count){
1064                 s->restart_count = s->restart_interval;
1065                 resync_mb_x = mb_x;
1066                 resync_mb_y = mb_y;
1067                 for(i=0; i<4; i++)
1068                     top[i] = left[i]= topleft[i]= 1 << (s->bits - 1);
1069             }
1070             if (mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || !mb_x)
1071                 modified_predictor = 1;
1072
1073             for (i=0;i<nb_components;i++) {
1074                 int pred, dc;
1075
1076                 topleft[i] = top[i];
1077                 top[i]     = buffer[mb_x][i];
1078
1079                 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1080
1081                 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1082                 if(dc == 0xFFFFF)
1083                     return -1;
1084
1085                 left[i] = buffer[mb_x][i] =
1086                     mask & (pred + (unsigned)(dc * (1 << point_transform)));
1087             }
1088
1089             if (s->restart_interval && !--s->restart_count) {
1090                 align_get_bits(&s->gb);
1091                 skip_bits(&s->gb, 16); /* skip RSTn */
1092             }
1093         }
1094         if (s->rct && s->nb_components == 4) {
1095             for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1096                 ptr[4*mb_x + 2] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1097                 ptr[4*mb_x + 1] = buffer[mb_x][1] + ptr[4*mb_x + 2];
1098                 ptr[4*mb_x + 3] = buffer[mb_x][2] + ptr[4*mb_x + 2];
1099                 ptr[4*mb_x + 0] = buffer[mb_x][3];
1100             }
1101         } else if (s->nb_components == 4) {
1102             for(i=0; i<nb_components; i++) {
1103                 int c= s->comp_index[i];
1104                 if (s->bits <= 8) {
1105                     for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1106                         ptr[4*mb_x+3-c] = buffer[mb_x][i];
1107                     }
1108                 } else if(s->bits == 9) {
1109                     return AVERROR_PATCHWELCOME;
1110                 } else {
1111                     for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1112                         ((uint16_t*)ptr)[4*mb_x+c] = buffer[mb_x][i];
1113                     }
1114                 }
1115             }
1116         } else if (s->rct) {
1117             for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1118                 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1119                 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1120                 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1121             }
1122         } else if (s->pegasus_rct) {
1123             for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1124                 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2]) >> 2);
1125                 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1126                 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1127             }
1128         } else {
1129             for(i=0; i<nb_components; i++) {
1130                 int c= s->comp_index[i];
1131                 if (s->bits <= 8) {
1132                     for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1133                         ptr[3*mb_x+2-c] = buffer[mb_x][i];
1134                     }
1135                 } else if(s->bits == 9) {
1136                     return AVERROR_PATCHWELCOME;
1137                 } else {
1138                     for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1139                         ((uint16_t*)ptr)[3*mb_x+2-c] = buffer[mb_x][i];
1140                     }
1141                 }
1142             }
1143         }
1144     }
1145     return 0;
1146 }
1147
1148 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
1149                                  int point_transform, int nb_components)
1150 {
1151     int i, mb_x, mb_y, mask;
1152     int bits= (s->bits+7)&~7;
1153     int resync_mb_y = 0;
1154     int resync_mb_x = 0;
1155
1156     point_transform += bits - s->bits;
1157     mask = ((1 << s->bits) - 1) << point_transform;
1158
1159     av_assert0(nb_components>=1 && nb_components<=4);
1160
1161     for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1162         for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1163             if (get_bits_left(&s->gb) < 1) {
1164                 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in yuv_scan\n");
1165                 return AVERROR_INVALIDDATA;
1166             }
1167             if (s->restart_interval && !s->restart_count){
1168                 s->restart_count = s->restart_interval;
1169                 resync_mb_x = mb_x;
1170                 resync_mb_y = mb_y;
1171             }
1172
1173             if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->interlaced){
1174                 int toprow  = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x;
1175                 int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x;
1176                 for (i = 0; i < nb_components; i++) {
1177                     uint8_t *ptr;
1178                     uint16_t *ptr16;
1179                     int n, h, v, x, y, c, j, linesize;
1180                     n = s->nb_blocks[i];
1181                     c = s->comp_index[i];
1182                     h = s->h_scount[i];
1183                     v = s->v_scount[i];
1184                     x = 0;
1185                     y = 0;
1186                     linesize= s->linesize[c];
1187
1188                     if(bits>8) linesize /= 2;
1189
1190                     for(j=0; j<n; j++) {
1191                         int pred, dc;
1192
1193                         dc = mjpeg_decode_dc(s, s->dc_index[i]);
1194                         if(dc == 0xFFFFF)
1195                             return -1;
1196                         if (   h * mb_x + x >= s->width
1197                             || v * mb_y + y >= s->height) {
1198                             // Nothing to do
1199                         } else if (bits<=8) {
1200                         ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1201                         if(y==0 && toprow){
1202                             if(x==0 && leftcol){
1203                                 pred= 1 << (bits - 1);
1204                             }else{
1205                                 pred= ptr[-1];
1206                             }
1207                         }else{
1208                             if(x==0 && leftcol){
1209                                 pred= ptr[-linesize];
1210                             }else{
1211                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1212                             }
1213                         }
1214
1215                         if (s->interlaced && s->bottom_field)
1216                             ptr += linesize >> 1;
1217                         pred &= mask;
1218                         *ptr= pred + ((unsigned)dc << point_transform);
1219                         }else{
1220                             ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1221                             if(y==0 && toprow){
1222                                 if(x==0 && leftcol){
1223                                     pred= 1 << (bits - 1);
1224                                 }else{
1225                                     pred= ptr16[-1];
1226                                 }
1227                             }else{
1228                                 if(x==0 && leftcol){
1229                                     pred= ptr16[-linesize];
1230                                 }else{
1231                                     PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1232                                 }
1233                             }
1234
1235                             if (s->interlaced && s->bottom_field)
1236                                 ptr16 += linesize >> 1;
1237                             pred &= mask;
1238                             *ptr16= pred + ((unsigned)dc << point_transform);
1239                         }
1240                         if (++x == h) {
1241                             x = 0;
1242                             y++;
1243                         }
1244                     }
1245                 }
1246             } else {
1247                 for (i = 0; i < nb_components; i++) {
1248                     uint8_t *ptr;
1249                     uint16_t *ptr16;
1250                     int n, h, v, x, y, c, j, linesize, dc;
1251                     n        = s->nb_blocks[i];
1252                     c        = s->comp_index[i];
1253                     h        = s->h_scount[i];
1254                     v        = s->v_scount[i];
1255                     x        = 0;
1256                     y        = 0;
1257                     linesize = s->linesize[c];
1258
1259                     if(bits>8) linesize /= 2;
1260
1261                     for (j = 0; j < n; j++) {
1262                         int pred;
1263
1264                         dc = mjpeg_decode_dc(s, s->dc_index[i]);
1265                         if(dc == 0xFFFFF)
1266                             return -1;
1267                         if (   h * mb_x + x >= s->width
1268                             || v * mb_y + y >= s->height) {
1269                             // Nothing to do
1270                         } else if (bits<=8) {
1271                             ptr = s->picture_ptr->data[c] +
1272                               (linesize * (v * mb_y + y)) +
1273                               (h * mb_x + x); //FIXME optimize this crap
1274                             PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1275
1276                             pred &= mask;
1277                             *ptr = pred + ((unsigned)dc << point_transform);
1278                         }else{
1279                             ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1280                             PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1281
1282                             pred &= mask;
1283                             *ptr16= pred + ((unsigned)dc << point_transform);
1284                         }
1285
1286                         if (++x == h) {
1287                             x = 0;
1288                             y++;
1289                         }
1290                     }
1291                 }
1292             }
1293             if (s->restart_interval && !--s->restart_count) {
1294                 align_get_bits(&s->gb);
1295                 skip_bits(&s->gb, 16); /* skip RSTn */
1296             }
1297         }
1298     }
1299     return 0;
1300 }
1301
1302 static av_always_inline void mjpeg_copy_block(MJpegDecodeContext *s,
1303                                               uint8_t *dst, const uint8_t *src,
1304                                               int linesize, int lowres)
1305 {
1306     switch (lowres) {
1307     case 0: s->hdsp.put_pixels_tab[1][0](dst, src, linesize, 8);
1308         break;
1309     case 1: copy_block4(dst, src, linesize, linesize, 4);
1310         break;
1311     case 2: copy_block2(dst, src, linesize, linesize, 2);
1312         break;
1313     case 3: *dst = *src;
1314         break;
1315     }
1316 }
1317
1318 static void shift_output(MJpegDecodeContext *s, uint8_t *ptr, int linesize)
1319 {
1320     int block_x, block_y;
1321     int size = 8 >> s->avctx->lowres;
1322     if (s->bits > 8) {
1323         for (block_y=0; block_y<size; block_y++)
1324             for (block_x=0; block_x<size; block_x++)
1325                 *(uint16_t*)(ptr + 2*block_x + block_y*linesize) <<= 16 - s->bits;
1326     } else {
1327         for (block_y=0; block_y<size; block_y++)
1328             for (block_x=0; block_x<size; block_x++)
1329                 *(ptr + block_x + block_y*linesize) <<= 8 - s->bits;
1330     }
1331 }
1332
1333 static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
1334                              int Al, const uint8_t *mb_bitmask,
1335                              int mb_bitmask_size,
1336                              const AVFrame *reference)
1337 {
1338     int i, mb_x, mb_y, chroma_h_shift, chroma_v_shift, chroma_width, chroma_height;
1339     uint8_t *data[MAX_COMPONENTS];
1340     const uint8_t *reference_data[MAX_COMPONENTS];
1341     int linesize[MAX_COMPONENTS];
1342     GetBitContext mb_bitmask_gb = {0}; // initialize to silence gcc warning
1343     int bytes_per_pixel = 1 + (s->bits > 8);
1344
1345     if (mb_bitmask) {
1346         if (mb_bitmask_size != (s->mb_width * s->mb_height + 7)>>3) {
1347             av_log(s->avctx, AV_LOG_ERROR, "mb_bitmask_size mismatches\n");
1348             return AVERROR_INVALIDDATA;
1349         }
1350         init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
1351     }
1352
1353     s->restart_count = 0;
1354
1355     av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &chroma_h_shift,
1356                                      &chroma_v_shift);
1357     chroma_width  = AV_CEIL_RSHIFT(s->width,  chroma_h_shift);
1358     chroma_height = AV_CEIL_RSHIFT(s->height, chroma_v_shift);
1359
1360     for (i = 0; i < nb_components; i++) {
1361         int c   = s->comp_index[i];
1362         data[c] = s->picture_ptr->data[c];
1363         reference_data[c] = reference ? reference->data[c] : NULL;
1364         linesize[c] = s->linesize[c];
1365         s->coefs_finished[c] |= 1;
1366     }
1367
1368     for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1369         for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1370             const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
1371
1372             if (s->restart_interval && !s->restart_count)
1373                 s->restart_count = s->restart_interval;
1374
1375             if (get_bits_left(&s->gb) < 0) {
1376                 av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",
1377                        -get_bits_left(&s->gb));
1378                 return AVERROR_INVALIDDATA;
1379             }
1380             for (i = 0; i < nb_components; i++) {
1381                 uint8_t *ptr;
1382                 int n, h, v, x, y, c, j;
1383                 int block_offset;
1384                 n = s->nb_blocks[i];
1385                 c = s->comp_index[i];
1386                 h = s->h_scount[i];
1387                 v = s->v_scount[i];
1388                 x = 0;
1389                 y = 0;
1390                 for (j = 0; j < n; j++) {
1391                     block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
1392                                      (h * mb_x + x) * 8 * bytes_per_pixel) >> s->avctx->lowres);
1393
1394                     if (s->interlaced && s->bottom_field)
1395                         block_offset += linesize[c] >> 1;
1396                     if (   8*(h * mb_x + x) < ((c == 1) || (c == 2) ? chroma_width  : s->width)
1397                         && 8*(v * mb_y + y) < ((c == 1) || (c == 2) ? chroma_height : s->height)) {
1398                         ptr = data[c] + block_offset;
1399                     } else
1400                         ptr = NULL;
1401                     if (!s->progressive) {
1402                         if (copy_mb) {
1403                             if (ptr)
1404                                 mjpeg_copy_block(s, ptr, reference_data[c] + block_offset,
1405                                                 linesize[c], s->avctx->lowres);
1406
1407                         } else {
1408                             s->bdsp.clear_block(s->block);
1409                             if (decode_block(s, s->block, i,
1410                                              s->dc_index[i], s->ac_index[i],
1411                                              s->quant_matrixes[s->quant_sindex[i]]) < 0) {
1412                                 av_log(s->avctx, AV_LOG_ERROR,
1413                                        "error y=%d x=%d\n", mb_y, mb_x);
1414                                 return AVERROR_INVALIDDATA;
1415                             }
1416                             if (ptr) {
1417                                 s->idsp.idct_put(ptr, linesize[c], s->block);
1418                                 if (s->bits & 7)
1419                                     shift_output(s, ptr, linesize[c]);
1420                             }
1421                         }
1422                     } else {
1423                         int block_idx  = s->block_stride[c] * (v * mb_y + y) +
1424                                          (h * mb_x + x);
1425                         int16_t *block = s->blocks[c][block_idx];
1426                         if (Ah)
1427                             block[0] += get_bits1(&s->gb) *
1428                                         s->quant_matrixes[s->quant_sindex[i]][0] << Al;
1429                         else if (decode_dc_progressive(s, block, i, s->dc_index[i],
1430                                                        s->quant_matrixes[s->quant_sindex[i]],
1431                                                        Al) < 0) {
1432                             av_log(s->avctx, AV_LOG_ERROR,
1433                                    "error y=%d x=%d\n", mb_y, mb_x);
1434                             return AVERROR_INVALIDDATA;
1435                         }
1436                     }
1437                     ff_dlog(s->avctx, "mb: %d %d processed\n", mb_y, mb_x);
1438                     ff_dlog(s->avctx, "%d %d %d %d %d %d %d %d \n",
1439                             mb_x, mb_y, x, y, c, s->bottom_field,
1440                             (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1441                     if (++x == h) {
1442                         x = 0;
1443                         y++;
1444                     }
1445                 }
1446             }
1447
1448             handle_rstn(s, nb_components);
1449         }
1450     }
1451     return 0;
1452 }
1453
1454 static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss,
1455                                             int se, int Ah, int Al)
1456 {
1457     int mb_x, mb_y;
1458     int EOBRUN = 0;
1459     int c = s->comp_index[0];
1460     uint16_t *quant_matrix = s->quant_matrixes[s->quant_sindex[0]];
1461
1462     av_assert0(ss>=0 && Ah>=0 && Al>=0);
1463     if (se < ss || se > 63) {
1464         av_log(s->avctx, AV_LOG_ERROR, "SS/SE %d/%d is invalid\n", ss, se);
1465         return AVERROR_INVALIDDATA;
1466     }
1467
1468     // s->coefs_finished is a bitmask for coefficients coded
1469     // ss and se are parameters telling start and end coefficients
1470     s->coefs_finished[c] |= (2ULL << se) - (1ULL << ss);
1471
1472     s->restart_count = 0;
1473
1474     for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1475         int block_idx    = mb_y * s->block_stride[c];
1476         int16_t (*block)[64] = &s->blocks[c][block_idx];
1477         uint8_t *last_nnz    = &s->last_nnz[c][block_idx];
1478         if (get_bits_left(&s->gb) <= 0) {
1479             av_log(s->avctx, AV_LOG_ERROR, "bitstream truncated in mjpeg_decode_scan_progressive_ac\n");
1480             return AVERROR_INVALIDDATA;
1481         }
1482         for (mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) {
1483                 int ret;
1484                 if (s->restart_interval && !s->restart_count)
1485                     s->restart_count = s->restart_interval;
1486
1487                 if (Ah)
1488                     ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0],
1489                                                   quant_matrix, ss, se, Al, &EOBRUN);
1490                 else
1491                     ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0],
1492                                                    quant_matrix, ss, se, Al, &EOBRUN);
1493                 if (ret < 0) {
1494                     av_log(s->avctx, AV_LOG_ERROR,
1495                            "error y=%d x=%d\n", mb_y, mb_x);
1496                     return AVERROR_INVALIDDATA;
1497                 }
1498
1499             if (handle_rstn(s, 0))
1500                 EOBRUN = 0;
1501         }
1502     }
1503     return 0;
1504 }
1505
1506 static void mjpeg_idct_scan_progressive_ac(MJpegDecodeContext *s)
1507 {
1508     int mb_x, mb_y;
1509     int c;
1510     const int bytes_per_pixel = 1 + (s->bits > 8);
1511     const int block_size = s->lossless ? 1 : 8;
1512
1513     for (c = 0; c < s->nb_components; c++) {
1514         uint8_t *data = s->picture_ptr->data[c];
1515         int linesize  = s->linesize[c];
1516         int h = s->h_max / s->h_count[c];
1517         int v = s->v_max / s->v_count[c];
1518         int mb_width     = (s->width  + h * block_size - 1) / (h * block_size);
1519         int mb_height    = (s->height + v * block_size - 1) / (v * block_size);
1520
1521         if (~s->coefs_finished[c])
1522             av_log(s->avctx, AV_LOG_WARNING, "component %d is incomplete\n", c);
1523
1524         if (s->interlaced && s->bottom_field)
1525             data += linesize >> 1;
1526
1527         for (mb_y = 0; mb_y < mb_height; mb_y++) {
1528             uint8_t *ptr     = data + (mb_y * linesize * 8 >> s->avctx->lowres);
1529             int block_idx    = mb_y * s->block_stride[c];
1530             int16_t (*block)[64] = &s->blocks[c][block_idx];
1531             for (mb_x = 0; mb_x < mb_width; mb_x++, block++) {
1532                 s->idsp.idct_put(ptr, linesize, *block);
1533                 if (s->bits & 7)
1534                     shift_output(s, ptr, linesize);
1535                 ptr += bytes_per_pixel*8 >> s->avctx->lowres;
1536             }
1537         }
1538     }
1539 }
1540
1541 int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
1542                         int mb_bitmask_size, const AVFrame *reference)
1543 {
1544     int len, nb_components, i, h, v, predictor, point_transform;
1545     int index, id, ret;
1546     const int block_size = s->lossless ? 1 : 8;
1547     int ilv, prev_shift;
1548
1549     if (!s->got_picture) {
1550         av_log(s->avctx, AV_LOG_WARNING,
1551                 "Can not process SOS before SOF, skipping\n");
1552         return -1;
1553     }
1554
1555     if (reference) {
1556         if (reference->width  != s->picture_ptr->width  ||
1557             reference->height != s->picture_ptr->height ||
1558             reference->format != s->picture_ptr->format) {
1559             av_log(s->avctx, AV_LOG_ERROR, "Reference mismatching\n");
1560             return AVERROR_INVALIDDATA;
1561         }
1562     }
1563
1564     /* XXX: verify len field validity */
1565     len = get_bits(&s->gb, 16);
1566     nb_components = get_bits(&s->gb, 8);
1567     if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
1568         avpriv_report_missing_feature(s->avctx,
1569                                       "decode_sos: nb_components (%d)",
1570                                       nb_components);
1571         return AVERROR_PATCHWELCOME;
1572     }
1573     if (len != 6 + 2 * nb_components) {
1574         av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1575         return AVERROR_INVALIDDATA;
1576     }
1577     for (i = 0; i < nb_components; i++) {
1578         id = get_bits(&s->gb, 8) - 1;
1579         av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1580         /* find component index */
1581         for (index = 0; index < s->nb_components; index++)
1582             if (id == s->component_id[index])
1583                 break;
1584         if (index == s->nb_components) {
1585             av_log(s->avctx, AV_LOG_ERROR,
1586                    "decode_sos: index(%d) out of components\n", index);
1587             return AVERROR_INVALIDDATA;
1588         }
1589         /* Metasoft MJPEG codec has Cb and Cr swapped */
1590         if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
1591             && nb_components == 3 && s->nb_components == 3 && i)
1592             index = 3 - i;
1593
1594         s->quant_sindex[i] = s->quant_index[index];
1595         s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1596         s->h_scount[i]  = s->h_count[index];
1597         s->v_scount[i]  = s->v_count[index];
1598
1599         if(nb_components == 3 && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
1600             index = (i+2)%3;
1601         if(nb_components == 1 && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
1602             index = (index+2)%3;
1603
1604         s->comp_index[i] = index;
1605
1606         s->dc_index[i] = get_bits(&s->gb, 4);
1607         s->ac_index[i] = get_bits(&s->gb, 4);
1608
1609         if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1610             s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1611             goto out_of_range;
1612         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))
1613             goto out_of_range;
1614     }
1615
1616     predictor = get_bits(&s->gb, 8);       /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1617     ilv = get_bits(&s->gb, 8);             /* JPEG Se / JPEG-LS ILV */
1618     if(s->avctx->codec_tag != AV_RL32("CJPG")){
1619         prev_shift      = get_bits(&s->gb, 4); /* Ah */
1620         point_transform = get_bits(&s->gb, 4); /* Al */
1621     }else
1622         prev_shift = point_transform = 0;
1623
1624     if (nb_components > 1) {
1625         /* interleaved stream */
1626         s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1627         s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1628     } else if (!s->ls) { /* skip this for JPEG-LS */
1629         h = s->h_max / s->h_scount[0];
1630         v = s->v_max / s->v_scount[0];
1631         s->mb_width     = (s->width  + h * block_size - 1) / (h * block_size);
1632         s->mb_height    = (s->height + v * block_size - 1) / (v * block_size);
1633         s->nb_blocks[0] = 1;
1634         s->h_scount[0]  = 1;
1635         s->v_scount[0]  = 1;
1636     }
1637
1638     if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1639         av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n",
1640                s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",
1641                predictor, point_transform, ilv, s->bits, s->mjpb_skiptosod,
1642                s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), nb_components);
1643
1644
1645     /* mjpeg-b can have padding bytes between sos and image data, skip them */
1646     for (i = s->mjpb_skiptosod; i > 0; i--)
1647         skip_bits(&s->gb, 8);
1648
1649 next_field:
1650     for (i = 0; i < nb_components; i++)
1651         s->last_dc[i] = (4 << s->bits);
1652
1653     if (s->avctx->hwaccel) {
1654         int bytes_to_start = get_bits_count(&s->gb) / 8;
1655         av_assert0(bytes_to_start >= 0 &&
1656                    s->raw_scan_buffer_size >= bytes_to_start);
1657
1658         ret = s->avctx->hwaccel->decode_slice(s->avctx,
1659                                               s->raw_scan_buffer      + bytes_to_start,
1660                                               s->raw_scan_buffer_size - bytes_to_start);
1661         if (ret < 0)
1662             return ret;
1663
1664     } else if (s->lossless) {
1665         av_assert0(s->picture_ptr == s->picture);
1666         if (CONFIG_JPEGLS_DECODER && s->ls) {
1667 //            for () {
1668 //            reset_ls_coding_parameters(s, 0);
1669
1670             if ((ret = ff_jpegls_decode_picture(s, predictor,
1671                                                 point_transform, ilv)) < 0)
1672                 return ret;
1673         } else {
1674             if (s->rgb) {
1675                 if ((ret = ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform)) < 0)
1676                     return ret;
1677             } else {
1678                 if ((ret = ljpeg_decode_yuv_scan(s, predictor,
1679                                                  point_transform,
1680                                                  nb_components)) < 0)
1681                     return ret;
1682             }
1683         }
1684     } else {
1685         if (s->progressive && predictor) {
1686             av_assert0(s->picture_ptr == s->picture);
1687             if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor,
1688                                                         ilv, prev_shift,
1689                                                         point_transform)) < 0)
1690                 return ret;
1691         } else {
1692             if ((ret = mjpeg_decode_scan(s, nb_components,
1693                                          prev_shift, point_transform,
1694                                          mb_bitmask, mb_bitmask_size, reference)) < 0)
1695                 return ret;
1696         }
1697     }
1698
1699     if (s->interlaced &&
1700         get_bits_left(&s->gb) > 32 &&
1701         show_bits(&s->gb, 8) == 0xFF) {
1702         GetBitContext bak = s->gb;
1703         align_get_bits(&bak);
1704         if (show_bits(&bak, 16) == 0xFFD1) {
1705             av_log(s->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n");
1706             s->gb = bak;
1707             skip_bits(&s->gb, 16);
1708             s->bottom_field ^= 1;
1709
1710             goto next_field;
1711         }
1712     }
1713
1714     emms_c();
1715     return 0;
1716  out_of_range:
1717     av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1718     return AVERROR_INVALIDDATA;
1719 }
1720
1721 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1722 {
1723     if (get_bits(&s->gb, 16) != 4)
1724         return AVERROR_INVALIDDATA;
1725     s->restart_interval = get_bits(&s->gb, 16);
1726     s->restart_count    = 0;
1727     av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
1728            s->restart_interval);
1729
1730     return 0;
1731 }
1732
1733 static int mjpeg_decode_app(MJpegDecodeContext *s)
1734 {
1735     int len, id, i;
1736
1737     len = get_bits(&s->gb, 16);
1738     if (len < 6)
1739         return AVERROR_INVALIDDATA;
1740     if (8 * len > get_bits_left(&s->gb))
1741         return AVERROR_INVALIDDATA;
1742
1743     id   = get_bits_long(&s->gb, 32);
1744     len -= 6;
1745
1746     if (s->avctx->debug & FF_DEBUG_STARTCODE)
1747         av_log(s->avctx, AV_LOG_DEBUG, "APPx (%s / %8X) len=%d\n",
1748                av_fourcc2str(av_bswap32(id)), id, len);
1749
1750     /* Buggy AVID, it puts EOI only at every 10th frame. */
1751     /* Also, this fourcc is used by non-avid files too, it holds some
1752        information, but it's always present in AVID-created files. */
1753     if (id == AV_RB32("AVI1")) {
1754         /* structure:
1755             4bytes      AVI1
1756             1bytes      polarity
1757             1bytes      always zero
1758             4bytes      field_size
1759             4bytes      field_size_less_padding
1760         */
1761             s->buggy_avid = 1;
1762         i = get_bits(&s->gb, 8); len--;
1763         av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i);
1764         goto out;
1765     }
1766
1767     if (id == AV_RB32("JFIF")) {
1768         int t_w, t_h, v1, v2;
1769         if (len < 8)
1770             goto out;
1771         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1772         v1 = get_bits(&s->gb, 8);
1773         v2 = get_bits(&s->gb, 8);
1774         skip_bits(&s->gb, 8);
1775
1776         s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 16);
1777         s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16);
1778         if (   s->avctx->sample_aspect_ratio.num <= 0
1779             || s->avctx->sample_aspect_ratio.den <= 0) {
1780             s->avctx->sample_aspect_ratio.num = 0;
1781             s->avctx->sample_aspect_ratio.den = 1;
1782         }
1783
1784         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1785             av_log(s->avctx, AV_LOG_INFO,
1786                    "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1787                    v1, v2,
1788                    s->avctx->sample_aspect_ratio.num,
1789                    s->avctx->sample_aspect_ratio.den);
1790
1791         len -= 8;
1792         if (len >= 2) {
1793             t_w = get_bits(&s->gb, 8);
1794             t_h = get_bits(&s->gb, 8);
1795             if (t_w && t_h) {
1796                 /* skip thumbnail */
1797                 if (len -10 - (t_w * t_h * 3) > 0)
1798                     len -= t_w * t_h * 3;
1799             }
1800             len -= 2;
1801         }
1802         goto out;
1803     }
1804
1805     if (   id == AV_RB32("Adob")
1806         && len >= 7
1807         && show_bits(&s->gb, 8) == 'e'
1808         && show_bits_long(&s->gb, 32) != AV_RB32("e_CM")) {
1809         skip_bits(&s->gb,  8); /* 'e' */
1810         skip_bits(&s->gb, 16); /* version */
1811         skip_bits(&s->gb, 16); /* flags0 */
1812         skip_bits(&s->gb, 16); /* flags1 */
1813         s->adobe_transform = get_bits(&s->gb,  8);
1814         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1815             av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found, transform=%d\n", s->adobe_transform);
1816         len -= 7;
1817         goto out;
1818     }
1819
1820     if (id == AV_RB32("LJIF")) {
1821         int rgb = s->rgb;
1822         int pegasus_rct = s->pegasus_rct;
1823         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1824             av_log(s->avctx, AV_LOG_INFO,
1825                    "Pegasus lossless jpeg header found\n");
1826         skip_bits(&s->gb, 16); /* version ? */
1827         skip_bits(&s->gb, 16); /* unknown always 0? */
1828         skip_bits(&s->gb, 16); /* unknown always 0? */
1829         skip_bits(&s->gb, 16); /* unknown always 0? */
1830         switch (i=get_bits(&s->gb, 8)) {
1831         case 1:
1832             rgb         = 1;
1833             pegasus_rct = 0;
1834             break;
1835         case 2:
1836             rgb         = 1;
1837             pegasus_rct = 1;
1838             break;
1839         default:
1840             av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace %d\n", i);
1841         }
1842
1843         len -= 9;
1844         if (s->got_picture)
1845             if (rgb != s->rgb || pegasus_rct != s->pegasus_rct) {
1846                 av_log(s->avctx, AV_LOG_WARNING, "Mismatching LJIF tag\n");
1847                 goto out;
1848             }
1849
1850         s->rgb = rgb;
1851         s->pegasus_rct = pegasus_rct;
1852
1853         goto out;
1854     }
1855     if (id == AV_RL32("colr") && len > 0) {
1856         s->colr = get_bits(&s->gb, 8);
1857         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1858             av_log(s->avctx, AV_LOG_INFO, "COLR %d\n", s->colr);
1859         len --;
1860         goto out;
1861     }
1862     if (id == AV_RL32("xfrm") && len > 0) {
1863         s->xfrm = get_bits(&s->gb, 8);
1864         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1865             av_log(s->avctx, AV_LOG_INFO, "XFRM %d\n", s->xfrm);
1866         len --;
1867         goto out;
1868     }
1869
1870     /* JPS extension by VRex */
1871     if (s->start_code == APP3 && id == AV_RB32("_JPS") && len >= 10) {
1872         int flags, layout, type;
1873         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1874             av_log(s->avctx, AV_LOG_INFO, "_JPSJPS_\n");
1875
1876         skip_bits(&s->gb, 32); len -= 4;  /* JPS_ */
1877         skip_bits(&s->gb, 16); len -= 2;  /* block length */
1878         skip_bits(&s->gb, 8);             /* reserved */
1879         flags  = get_bits(&s->gb, 8);
1880         layout = get_bits(&s->gb, 8);
1881         type   = get_bits(&s->gb, 8);
1882         len -= 4;
1883
1884         s->stereo3d = av_stereo3d_alloc();
1885         if (!s->stereo3d) {
1886             goto out;
1887         }
1888         if (type == 0) {
1889             s->stereo3d->type = AV_STEREO3D_2D;
1890         } else if (type == 1) {
1891             switch (layout) {
1892             case 0x01:
1893                 s->stereo3d->type = AV_STEREO3D_LINES;
1894                 break;
1895             case 0x02:
1896                 s->stereo3d->type = AV_STEREO3D_SIDEBYSIDE;
1897                 break;
1898             case 0x03:
1899                 s->stereo3d->type = AV_STEREO3D_TOPBOTTOM;
1900                 break;
1901             }
1902             if (!(flags & 0x04)) {
1903                 s->stereo3d->flags = AV_STEREO3D_FLAG_INVERT;
1904             }
1905         }
1906         goto out;
1907     }
1908
1909     /* EXIF metadata */
1910     if (s->start_code == APP1 && id == AV_RB32("Exif") && len >= 2) {
1911         GetByteContext gbytes;
1912         int ret, le, ifd_offset, bytes_read;
1913         const uint8_t *aligned;
1914
1915         skip_bits(&s->gb, 16); // skip padding
1916         len -= 2;
1917
1918         // init byte wise reading
1919         aligned = align_get_bits(&s->gb);
1920         bytestream2_init(&gbytes, aligned, len);
1921
1922         // read TIFF header
1923         ret = ff_tdecode_header(&gbytes, &le, &ifd_offset);
1924         if (ret) {
1925             av_log(s->avctx, AV_LOG_ERROR, "mjpeg: invalid TIFF header in EXIF data\n");
1926         } else {
1927             bytestream2_seek(&gbytes, ifd_offset, SEEK_SET);
1928
1929             // read 0th IFD and store the metadata
1930             // (return values > 0 indicate the presence of subimage metadata)
1931             ret = ff_exif_decode_ifd(s->avctx, &gbytes, le, 0, &s->exif_metadata);
1932             if (ret < 0) {
1933                 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error decoding EXIF data\n");
1934             }
1935         }
1936
1937         bytes_read = bytestream2_tell(&gbytes);
1938         skip_bits(&s->gb, bytes_read << 3);
1939         len -= bytes_read;
1940
1941         goto out;
1942     }
1943
1944     /* Apple MJPEG-A */
1945     if ((s->start_code == APP1) && (len > (0x28 - 8))) {
1946         id   = get_bits_long(&s->gb, 32);
1947         len -= 4;
1948         /* Apple MJPEG-A */
1949         if (id == AV_RB32("mjpg")) {
1950             /* structure:
1951                 4bytes      field size
1952                 4bytes      pad field size
1953                 4bytes      next off
1954                 4bytes      quant off
1955                 4bytes      huff off
1956                 4bytes      image off
1957                 4bytes      scan off
1958                 4bytes      data off
1959             */
1960             if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1961                 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1962         }
1963     }
1964
1965     if (s->start_code == APP2 && id == AV_RB32("ICC_") && len >= 10) {
1966         int id2;
1967         unsigned seqno;
1968         unsigned nummarkers;
1969
1970         id   = get_bits_long(&s->gb, 32);
1971         id2  = get_bits_long(&s->gb, 24);
1972         len -= 7;
1973         if (id != AV_RB32("PROF") || id2 != AV_RB24("ILE")) {
1974             av_log(s->avctx, AV_LOG_WARNING, "Invalid ICC_PROFILE header in APP2\n");
1975             goto out;
1976         }
1977
1978         skip_bits(&s->gb, 8);
1979         seqno  = get_bits(&s->gb, 8);
1980         len   -= 2;
1981         if (seqno == 0) {
1982             av_log(s->avctx, AV_LOG_WARNING, "Invalid sequence number in APP2\n");
1983             goto out;
1984         }
1985
1986         nummarkers  = get_bits(&s->gb, 8);
1987         len        -= 1;
1988         if (nummarkers == 0) {
1989             av_log(s->avctx, AV_LOG_WARNING, "Invalid number of markers coded in APP2\n");
1990             goto out;
1991         } else if (s->iccnum != 0 && nummarkers != s->iccnum) {
1992             av_log(s->avctx, AV_LOG_WARNING, "Mistmatch in coded number of ICC markers between markers\n");
1993             goto out;
1994         } else if (seqno > nummarkers) {
1995             av_log(s->avctx, AV_LOG_WARNING, "Mismatching sequence number and coded number of ICC markers\n");
1996             goto out;
1997         }
1998
1999         /* Allocate if this is the first APP2 we've seen. */
2000         if (s->iccnum == 0) {
2001             s->iccdata     = av_mallocz(nummarkers * sizeof(*(s->iccdata)));
2002             s->iccdatalens = av_mallocz(nummarkers * sizeof(*(s->iccdatalens)));
2003             if (!s->iccdata || !s->iccdatalens) {
2004                 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data arrays\n");
2005                 return AVERROR(ENOMEM);
2006             }
2007             s->iccnum = nummarkers;
2008         }
2009
2010         if (s->iccdata[seqno - 1]) {
2011             av_log(s->avctx, AV_LOG_WARNING, "Duplicate ICC sequence number\n");
2012             goto out;
2013         }
2014
2015         s->iccdatalens[seqno - 1]  = len;
2016         s->iccdata[seqno - 1]      = av_malloc(len);
2017         if (!s->iccdata[seqno - 1]) {
2018             av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data buffer\n");
2019             return AVERROR(ENOMEM);
2020         }
2021
2022         memcpy(s->iccdata[seqno - 1], align_get_bits(&s->gb), len);
2023         skip_bits(&s->gb, len << 3);
2024         len = 0;
2025         s->iccread++;
2026
2027         if (s->iccread > s->iccnum)
2028             av_log(s->avctx, AV_LOG_WARNING, "Read more ICC markers than are supposed to be coded\n");
2029     }
2030
2031 out:
2032     /* slow but needed for extreme adobe jpegs */
2033     if (len < 0)
2034         av_log(s->avctx, AV_LOG_ERROR,
2035                "mjpeg: error, decode_app parser read over the end\n");
2036     while (--len > 0)
2037         skip_bits(&s->gb, 8);
2038
2039     return 0;
2040 }
2041
2042 static int mjpeg_decode_com(MJpegDecodeContext *s)
2043 {
2044     int len = get_bits(&s->gb, 16);
2045     if (len >= 2 && 8 * len - 16 <= get_bits_left(&s->gb)) {
2046         int i;
2047         char *cbuf = av_malloc(len - 1);
2048         if (!cbuf)
2049             return AVERROR(ENOMEM);
2050
2051         for (i = 0; i < len - 2; i++)
2052             cbuf[i] = get_bits(&s->gb, 8);
2053         if (i > 0 && cbuf[i - 1] == '\n')
2054             cbuf[i - 1] = 0;
2055         else
2056             cbuf[i] = 0;
2057
2058         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2059             av_log(s->avctx, AV_LOG_INFO, "comment: '%s'\n", cbuf);
2060
2061         /* buggy avid, it puts EOI only at every 10th frame */
2062         if (!strncmp(cbuf, "AVID", 4)) {
2063             parse_avid(s, cbuf, len);
2064         } else if (!strcmp(cbuf, "CS=ITU601"))
2065             s->cs_itu601 = 1;
2066         else if ((!strncmp(cbuf, "Intel(R) JPEG Library, version 1", 32) && s->avctx->codec_tag) ||
2067                  (!strncmp(cbuf, "Metasoft MJPEG Codec", 20)))
2068             s->flipped = 1;
2069         else if (!strcmp(cbuf, "MULTISCOPE II")) {
2070             s->avctx->sample_aspect_ratio = (AVRational) { 1, 2 };
2071             s->multiscope = 2;
2072         }
2073
2074         av_free(cbuf);
2075     }
2076
2077     return 0;
2078 }
2079
2080 /* return the 8 bit start code value and update the search
2081    state. Return -1 if no start code found */
2082 static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
2083 {
2084     const uint8_t *buf_ptr;
2085     unsigned int v, v2;
2086     int val;
2087     int skipped = 0;
2088
2089     buf_ptr = *pbuf_ptr;
2090     while (buf_end - buf_ptr > 1) {
2091         v  = *buf_ptr++;
2092         v2 = *buf_ptr;
2093         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
2094             val = *buf_ptr++;
2095             goto found;
2096         }
2097         skipped++;
2098     }
2099     buf_ptr = buf_end;
2100     val = -1;
2101 found:
2102     ff_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
2103     *pbuf_ptr = buf_ptr;
2104     return val;
2105 }
2106
2107 int ff_mjpeg_find_marker(MJpegDecodeContext *s,
2108                          const uint8_t **buf_ptr, const uint8_t *buf_end,
2109                          const uint8_t **unescaped_buf_ptr,
2110                          int *unescaped_buf_size)
2111 {
2112     int start_code;
2113     start_code = find_marker(buf_ptr, buf_end);
2114
2115     av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr);
2116     if (!s->buffer)
2117         return AVERROR(ENOMEM);
2118
2119     /* unescape buffer of SOS, use special treatment for JPEG-LS */
2120     if (start_code == SOS && !s->ls) {
2121         const uint8_t *src = *buf_ptr;
2122         const uint8_t *ptr = src;
2123         uint8_t *dst = s->buffer;
2124
2125         #define copy_data_segment(skip) do {       \
2126             ptrdiff_t length = (ptr - src) - (skip);  \
2127             if (length > 0) {                         \
2128                 memcpy(dst, src, length);             \
2129                 dst += length;                        \
2130                 src = ptr;                            \
2131             }                                         \
2132         } while (0)
2133
2134         if (s->avctx->codec_id == AV_CODEC_ID_THP) {
2135             ptr = buf_end;
2136             copy_data_segment(0);
2137         } else {
2138             while (ptr < buf_end) {
2139                 uint8_t x = *(ptr++);
2140
2141                 if (x == 0xff) {
2142                     ptrdiff_t skip = 0;
2143                     while (ptr < buf_end && x == 0xff) {
2144                         x = *(ptr++);
2145                         skip++;
2146                     }
2147
2148                     /* 0xFF, 0xFF, ... */
2149                     if (skip > 1) {
2150                         copy_data_segment(skip);
2151
2152                         /* decrement src as it is equal to ptr after the
2153                          * copy_data_segment macro and we might want to
2154                          * copy the current value of x later on */
2155                         src--;
2156                     }
2157
2158                     if (x < 0xd0 || x > 0xd7) {
2159                         copy_data_segment(1);
2160                         if (x)
2161                             break;
2162                     }
2163                 }
2164             }
2165             if (src < ptr)
2166                 copy_data_segment(0);
2167         }
2168         #undef copy_data_segment
2169
2170         *unescaped_buf_ptr  = s->buffer;
2171         *unescaped_buf_size = dst - s->buffer;
2172         memset(s->buffer + *unescaped_buf_size, 0,
2173                AV_INPUT_BUFFER_PADDING_SIZE);
2174
2175         av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %"PTRDIFF_SPECIFIER" bytes\n",
2176                (buf_end - *buf_ptr) - (dst - s->buffer));
2177     } else if (start_code == SOS && s->ls) {
2178         const uint8_t *src = *buf_ptr;
2179         uint8_t *dst  = s->buffer;
2180         int bit_count = 0;
2181         int t = 0, b = 0;
2182         PutBitContext pb;
2183
2184         /* find marker */
2185         while (src + t < buf_end) {
2186             uint8_t x = src[t++];
2187             if (x == 0xff) {
2188                 while ((src + t < buf_end) && x == 0xff)
2189                     x = src[t++];
2190                 if (x & 0x80) {
2191                     t -= FFMIN(2, t);
2192                     break;
2193                 }
2194             }
2195         }
2196         bit_count = t * 8;
2197         init_put_bits(&pb, dst, t);
2198
2199         /* unescape bitstream */
2200         while (b < t) {
2201             uint8_t x = src[b++];
2202             put_bits(&pb, 8, x);
2203             if (x == 0xFF && b < t) {
2204                 x = src[b++];
2205                 if (x & 0x80) {
2206                     av_log(s->avctx, AV_LOG_WARNING, "Invalid escape sequence\n");
2207                     x &= 0x7f;
2208                 }
2209                 put_bits(&pb, 7, x);
2210                 bit_count--;
2211             }
2212         }
2213         flush_put_bits(&pb);
2214
2215         *unescaped_buf_ptr  = dst;
2216         *unescaped_buf_size = (bit_count + 7) >> 3;
2217         memset(s->buffer + *unescaped_buf_size, 0,
2218                AV_INPUT_BUFFER_PADDING_SIZE);
2219     } else {
2220         *unescaped_buf_ptr  = *buf_ptr;
2221         *unescaped_buf_size = buf_end - *buf_ptr;
2222     }
2223
2224     return start_code;
2225 }
2226
2227 static void reset_icc_profile(MJpegDecodeContext *s)
2228 {
2229     int i;
2230
2231     if (s->iccdata)
2232         for (i = 0; i < s->iccnum; i++)
2233             av_freep(&s->iccdata[i]);
2234     av_freep(&s->iccdata);
2235     av_freep(&s->iccdatalens);
2236
2237     s->iccread = 0;
2238     s->iccnum  = 0;
2239 }
2240
2241 int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
2242                           AVPacket *avpkt)
2243 {
2244     AVFrame     *frame = data;
2245     const uint8_t *buf = avpkt->data;
2246     int buf_size       = avpkt->size;
2247     MJpegDecodeContext *s = avctx->priv_data;
2248     const uint8_t *buf_end, *buf_ptr;
2249     const uint8_t *unescaped_buf_ptr;
2250     int hshift, vshift;
2251     int unescaped_buf_size;
2252     int start_code;
2253     int i, index;
2254     int ret = 0;
2255     int is16bit;
2256
2257     s->buf_size = buf_size;
2258
2259     av_dict_free(&s->exif_metadata);
2260     av_freep(&s->stereo3d);
2261     s->adobe_transform = -1;
2262
2263     if (s->iccnum != 0)
2264         reset_icc_profile(s);
2265
2266     buf_ptr = buf;
2267     buf_end = buf + buf_size;
2268     while (buf_ptr < buf_end) {
2269         /* find start next marker */
2270         start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,
2271                                           &unescaped_buf_ptr,
2272                                           &unescaped_buf_size);
2273         /* EOF */
2274         if (start_code < 0) {
2275             break;
2276         } else if (unescaped_buf_size > INT_MAX / 8) {
2277             av_log(avctx, AV_LOG_ERROR,
2278                    "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
2279                    start_code, unescaped_buf_size, buf_size);
2280             return AVERROR_INVALIDDATA;
2281         }
2282         av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%"PTRDIFF_SPECIFIER"\n",
2283                start_code, buf_end - buf_ptr);
2284
2285         ret = init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);
2286
2287         if (ret < 0) {
2288             av_log(avctx, AV_LOG_ERROR, "invalid buffer\n");
2289             goto fail;
2290         }
2291
2292         s->start_code = start_code;
2293         if (s->avctx->debug & FF_DEBUG_STARTCODE)
2294             av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2295
2296         /* process markers */
2297         if (start_code >= 0xd0 && start_code <= 0xd7) {
2298             av_log(avctx, AV_LOG_DEBUG,
2299                    "restart marker: %d\n", start_code & 0x0f);
2300             /* APP fields */
2301         } else if (start_code >= APP0 && start_code <= APP15) {
2302             if ((ret = mjpeg_decode_app(s)) < 0)
2303                 av_log(avctx, AV_LOG_ERROR, "unable to decode APP fields: %s\n",
2304                        av_err2str(ret));
2305             /* Comment */
2306         } else if (start_code == COM) {
2307             ret = mjpeg_decode_com(s);
2308             if (ret < 0)
2309                 return ret;
2310         } else if (start_code == DQT) {
2311             ret = ff_mjpeg_decode_dqt(s);
2312             if (ret < 0)
2313                 return ret;
2314         }
2315
2316         ret = -1;
2317
2318         if (!CONFIG_JPEGLS_DECODER &&
2319             (start_code == SOF48 || start_code == LSE)) {
2320             av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");
2321             return AVERROR(ENOSYS);
2322         }
2323
2324         if (avctx->skip_frame == AVDISCARD_ALL) {
2325             switch(start_code) {
2326             case SOF0:
2327             case SOF1:
2328             case SOF2:
2329             case SOF3:
2330             case SOF48:
2331             case SOI:
2332             case SOS:
2333             case EOI:
2334                 break;
2335             default:
2336                 goto skip;
2337             }
2338         }
2339
2340         switch (start_code) {
2341         case SOI:
2342             s->restart_interval = 0;
2343             s->restart_count    = 0;
2344             s->raw_image_buffer      = buf_ptr;
2345             s->raw_image_buffer_size = buf_end - buf_ptr;
2346             /* nothing to do on SOI */
2347             break;
2348         case DHT:
2349             if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
2350                 av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2351                 goto fail;
2352             }
2353             break;
2354         case SOF0:
2355         case SOF1:
2356             if (start_code == SOF0)
2357                 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT;
2358             else
2359                 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT;
2360             s->lossless    = 0;
2361             s->ls          = 0;
2362             s->progressive = 0;
2363             if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2364                 goto fail;
2365             break;
2366         case SOF2:
2367             s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT;
2368             s->lossless    = 0;
2369             s->ls          = 0;
2370             s->progressive = 1;
2371             if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2372                 goto fail;
2373             break;
2374         case SOF3:
2375             s->avctx->profile     = FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS;
2376             s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2377             s->lossless    = 1;
2378             s->ls          = 0;
2379             s->progressive = 0;
2380             if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2381                 goto fail;
2382             break;
2383         case SOF48:
2384             s->avctx->profile     = FF_PROFILE_MJPEG_JPEG_LS;
2385             s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2386             s->lossless    = 1;
2387             s->ls          = 1;
2388             s->progressive = 0;
2389             if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2390                 goto fail;
2391             break;
2392         case LSE:
2393             if (!CONFIG_JPEGLS_DECODER ||
2394                 (ret = ff_jpegls_decode_lse(s)) < 0)
2395                 goto fail;
2396             break;
2397         case EOI:
2398 eoi_parser:
2399             if (!avctx->hwaccel && avctx->skip_frame != AVDISCARD_ALL &&
2400                 s->progressive && s->cur_scan && s->got_picture)
2401                 mjpeg_idct_scan_progressive_ac(s);
2402             s->cur_scan = 0;
2403             if (!s->got_picture) {
2404                 av_log(avctx, AV_LOG_WARNING,
2405                        "Found EOI before any SOF, ignoring\n");
2406                 break;
2407             }
2408             if (s->interlaced) {
2409                 s->bottom_field ^= 1;
2410                 /* if not bottom field, do not output image yet */
2411                 if (s->bottom_field == !s->interlace_polarity)
2412                     break;
2413             }
2414             if (avctx->skip_frame == AVDISCARD_ALL) {
2415                 s->got_picture = 0;
2416                 goto the_end_no_picture;
2417             }
2418             if (s->avctx->hwaccel) {
2419                 ret = s->avctx->hwaccel->end_frame(s->avctx);
2420                 if (ret < 0)
2421                     return ret;
2422
2423                 av_freep(&s->hwaccel_picture_private);
2424             }
2425             if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
2426                 return ret;
2427             *got_frame = 1;
2428             s->got_picture = 0;
2429
2430             if (!s->lossless) {
2431                 int qp = FFMAX3(s->qscale[0],
2432                                 s->qscale[1],
2433                                 s->qscale[2]);
2434                 int qpw = (s->width + 15) / 16;
2435                 AVBufferRef *qp_table_buf = av_buffer_alloc(qpw);
2436                 if (qp_table_buf) {
2437                     memset(qp_table_buf->data, qp, qpw);
2438                     av_frame_set_qp_table(data, qp_table_buf, 0, FF_QSCALE_TYPE_MPEG1);
2439                 }
2440
2441                 if(avctx->debug & FF_DEBUG_QP)
2442                     av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);
2443             }
2444
2445             goto the_end;
2446         case SOS:
2447             s->raw_scan_buffer      = buf_ptr;
2448             s->raw_scan_buffer_size = buf_end - buf_ptr;
2449
2450             s->cur_scan++;
2451             if (avctx->skip_frame == AVDISCARD_ALL) {
2452                 skip_bits(&s->gb, get_bits_left(&s->gb));
2453                 break;
2454             }
2455
2456             if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&
2457                 (avctx->err_recognition & AV_EF_EXPLODE))
2458                 goto fail;
2459             break;
2460         case DRI:
2461             if ((ret = mjpeg_decode_dri(s)) < 0)
2462                 return ret;
2463             break;
2464         case SOF5:
2465         case SOF6:
2466         case SOF7:
2467         case SOF9:
2468         case SOF10:
2469         case SOF11:
2470         case SOF13:
2471         case SOF14:
2472         case SOF15:
2473         case JPG:
2474             av_log(avctx, AV_LOG_ERROR,
2475                    "mjpeg: unsupported coding type (%x)\n", start_code);
2476             break;
2477         }
2478
2479 skip:
2480         /* eof process start code */
2481         buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
2482         av_log(avctx, AV_LOG_DEBUG,
2483                "marker parser used %d bytes (%d bits)\n",
2484                (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
2485     }
2486     if (s->got_picture && s->cur_scan) {
2487         av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
2488         goto eoi_parser;
2489     }
2490     av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
2491     return AVERROR_INVALIDDATA;
2492 fail:
2493     s->got_picture = 0;
2494     return ret;
2495 the_end:
2496
2497     is16bit = av_pix_fmt_desc_get(s->avctx->pix_fmt)->comp[0].step > 1;
2498
2499     if (AV_RB32(s->upscale_h)) {
2500         int p;
2501         av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2502                    avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||
2503                    avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2504                    avctx->pix_fmt == AV_PIX_FMT_YUV440P  ||
2505                    avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2506                    avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2507                    avctx->pix_fmt == AV_PIX_FMT_YUV420P  ||
2508                    avctx->pix_fmt == AV_PIX_FMT_YUV420P16||
2509                    avctx->pix_fmt == AV_PIX_FMT_YUVA420P  ||
2510                    avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2511                    avctx->pix_fmt == AV_PIX_FMT_GBRP     ||
2512                    avctx->pix_fmt == AV_PIX_FMT_GBRAP
2513                   );
2514         ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2515         if (ret)
2516             return ret;
2517
2518         av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2519         for (p = 0; p<s->nb_components; p++) {
2520             uint8_t *line = s->picture_ptr->data[p];
2521             int w = s->width;
2522             int h = s->height;
2523             if (!s->upscale_h[p])
2524                 continue;
2525             if (p==1 || p==2) {
2526                 w = AV_CEIL_RSHIFT(w, hshift);
2527                 h = AV_CEIL_RSHIFT(h, vshift);
2528             }
2529             if (s->upscale_v[p])
2530                 h = (h+1)>>1;
2531             av_assert0(w > 0);
2532             for (i = 0; i < h; i++) {
2533                 if (s->upscale_h[p] == 1) {
2534                     if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];
2535                     else                      line[w - 1] = line[(w - 1) / 2];
2536                     for (index = w - 2; index > 0; index--) {
2537                         if (is16bit)
2538                             ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;
2539                         else
2540                             line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
2541                     }
2542                 } else if (s->upscale_h[p] == 2) {
2543                     if (is16bit) {
2544                         ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3];
2545                         if (w > 1)
2546                             ((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1];
2547                     } else {
2548                         line[w - 1] = line[(w - 1) / 3];
2549                         if (w > 1)
2550                             line[w - 2] = line[w - 1];
2551                     }
2552                     for (index = w - 3; index > 0; index--) {
2553                         line[index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3;
2554                     }
2555                 }
2556                 line += s->linesize[p];
2557             }
2558         }
2559     }
2560     if (AV_RB32(s->upscale_v)) {
2561         int p;
2562         av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2563                    avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||
2564                    avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2565                    avctx->pix_fmt == AV_PIX_FMT_YUV422P  ||
2566                    avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2567                    avctx->pix_fmt == AV_PIX_FMT_YUV420P  ||
2568                    avctx->pix_fmt == AV_PIX_FMT_YUV440P  ||
2569                    avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2570                    avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2571                    avctx->pix_fmt == AV_PIX_FMT_YUVA420P  ||
2572                    avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2573                    avctx->pix_fmt == AV_PIX_FMT_GBRP     ||
2574                    avctx->pix_fmt == AV_PIX_FMT_GBRAP
2575                    );
2576         ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2577         if (ret)
2578             return ret;
2579
2580         av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2581         for (p = 0; p < s->nb_components; p++) {
2582             uint8_t *dst;
2583             int w = s->width;
2584             int h = s->height;
2585             if (!s->upscale_v[p])
2586                 continue;
2587             if (p==1 || p==2) {
2588                 w = AV_CEIL_RSHIFT(w, hshift);
2589                 h = AV_CEIL_RSHIFT(h, vshift);
2590             }
2591             dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];
2592             for (i = h - 1; i; i--) {
2593                 uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i / 2 * s->linesize[p]];
2594                 uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) / 2 * s->linesize[p]];
2595                 if (src1 == src2 || i == h - 1) {
2596                     memcpy(dst, src1, w);
2597                 } else {
2598                     for (index = 0; index < w; index++)
2599                         dst[index] = (src1[index] + src2[index]) >> 1;
2600                 }
2601                 dst -= s->linesize[p];
2602             }
2603         }
2604     }
2605     if (s->flipped && !s->rgb) {
2606         int j;
2607         ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2608         if (ret)
2609             return ret;
2610
2611         av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2612         for (index=0; index<s->nb_components; index++) {
2613             uint8_t *dst = s->picture_ptr->data[index];
2614             int w = s->picture_ptr->width;
2615             int h = s->picture_ptr->height;
2616             if(index && index<3){
2617                 w = AV_CEIL_RSHIFT(w, hshift);
2618                 h = AV_CEIL_RSHIFT(h, vshift);
2619             }
2620             if(dst){
2621                 uint8_t *dst2 = dst + s->picture_ptr->linesize[index]*(h-1);
2622                 for (i=0; i<h/2; i++) {
2623                     for (j=0; j<w; j++)
2624                         FFSWAP(int, dst[j], dst2[j]);
2625                     dst  += s->picture_ptr->linesize[index];
2626                     dst2 -= s->picture_ptr->linesize[index];
2627                 }
2628             }
2629         }
2630     }
2631     if (s->adobe_transform == 0 && s->avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
2632         int w = s->picture_ptr->width;
2633         int h = s->picture_ptr->height;
2634         av_assert0(s->nb_components == 4);
2635         for (i=0; i<h; i++) {
2636             int j;
2637             uint8_t *dst[4];
2638             for (index=0; index<4; index++) {
2639                 dst[index] =   s->picture_ptr->data[index]
2640                              + s->picture_ptr->linesize[index]*i;
2641             }
2642             for (j=0; j<w; j++) {
2643                 int k = dst[3][j];
2644                 int r = dst[0][j] * k;
2645                 int g = dst[1][j] * k;
2646                 int b = dst[2][j] * k;
2647                 dst[0][j] = g*257 >> 16;
2648                 dst[1][j] = b*257 >> 16;
2649                 dst[2][j] = r*257 >> 16;
2650                 dst[3][j] = 255;
2651             }
2652         }
2653     }
2654     if (s->adobe_transform == 2 && s->avctx->pix_fmt == AV_PIX_FMT_YUVA444P) {
2655         int w = s->picture_ptr->width;
2656         int h = s->picture_ptr->height;
2657         av_assert0(s->nb_components == 4);
2658         for (i=0; i<h; i++) {
2659             int j;
2660             uint8_t *dst[4];
2661             for (index=0; index<4; index++) {
2662                 dst[index] =   s->picture_ptr->data[index]
2663                              + s->picture_ptr->linesize[index]*i;
2664             }
2665             for (j=0; j<w; j++) {
2666                 int k = dst[3][j];
2667                 int r = (255 - dst[0][j]) * k;
2668                 int g = (128 - dst[1][j]) * k;
2669                 int b = (128 - dst[2][j]) * k;
2670                 dst[0][j] = r*257 >> 16;
2671                 dst[1][j] = (g*257 >> 16) + 128;
2672                 dst[2][j] = (b*257 >> 16) + 128;
2673                 dst[3][j] = 255;
2674             }
2675         }
2676     }
2677
2678     if (s->stereo3d) {
2679         AVStereo3D *stereo = av_stereo3d_create_side_data(data);
2680         if (stereo) {
2681             stereo->type  = s->stereo3d->type;
2682             stereo->flags = s->stereo3d->flags;
2683         }
2684         av_freep(&s->stereo3d);
2685     }
2686
2687     if (s->iccnum != 0 && s->iccnum == s->iccread) {
2688         AVFrameSideData *sd;
2689         size_t offset = 0;
2690         int total_size = 0;
2691         int i;
2692
2693         /* Sum size of all parts. */
2694         for (i = 0; i < s->iccnum; i++)
2695             total_size += s->iccdatalens[i];
2696
2697         sd = av_frame_new_side_data(data, AV_FRAME_DATA_ICC_PROFILE, total_size);
2698         if (!sd) {
2699             av_log(s->avctx, AV_LOG_ERROR, "Could not allocate frame side data\n");
2700             return AVERROR(ENOMEM);
2701         }
2702
2703         /* Reassemble the parts, which are now in-order. */
2704         for (i = 0; i < s->iccnum; i++) {
2705             memcpy(sd->data + offset, s->iccdata[i], s->iccdatalens[i]);
2706             offset += s->iccdatalens[i];
2707         }
2708     }
2709
2710     av_dict_copy(&((AVFrame *) data)->metadata, s->exif_metadata, 0);
2711     av_dict_free(&s->exif_metadata);
2712
2713 the_end_no_picture:
2714     av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n",
2715            buf_end - buf_ptr);
2716 //  return buf_end - buf_ptr;
2717     return buf_ptr - buf;
2718 }
2719
2720 av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
2721 {
2722     MJpegDecodeContext *s = avctx->priv_data;
2723     int i, j;
2724
2725     if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_number) {
2726         av_log(avctx, AV_LOG_INFO, "Single field\n");
2727     }
2728
2729     if (s->picture) {
2730         av_frame_free(&s->picture);
2731         s->picture_ptr = NULL;
2732     } else if (s->picture_ptr)
2733         av_frame_unref(s->picture_ptr);
2734
2735     av_freep(&s->buffer);
2736     av_freep(&s->stereo3d);
2737     av_freep(&s->ljpeg_buffer);
2738     s->ljpeg_buffer_size = 0;
2739
2740     for (i = 0; i < 3; i++) {
2741         for (j = 0; j < 4; j++)
2742             ff_free_vlc(&s->vlcs[i][j]);
2743     }
2744     for (i = 0; i < MAX_COMPONENTS; i++) {
2745         av_freep(&s->blocks[i]);
2746         av_freep(&s->last_nnz[i]);
2747     }
2748     av_dict_free(&s->exif_metadata);
2749
2750     reset_icc_profile(s);
2751
2752     av_freep(&s->hwaccel_picture_private);
2753
2754     return 0;
2755 }
2756
2757 static void decode_flush(AVCodecContext *avctx)
2758 {
2759     MJpegDecodeContext *s = avctx->priv_data;
2760     s->got_picture = 0;
2761 }
2762
2763 #if CONFIG_MJPEG_DECODER
2764 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
2765 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2766 static const AVOption options[] = {
2767     { "extern_huff", "Use external huffman table.",
2768       OFFSET(extern_huff), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
2769     { NULL },
2770 };
2771
2772 static const AVClass mjpegdec_class = {
2773     .class_name = "MJPEG decoder",
2774     .item_name  = av_default_item_name,
2775     .option     = options,
2776     .version    = LIBAVUTIL_VERSION_INT,
2777 };
2778
2779 AVCodec ff_mjpeg_decoder = {
2780     .name           = "mjpeg",
2781     .long_name      = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
2782     .type           = AVMEDIA_TYPE_VIDEO,
2783     .id             = AV_CODEC_ID_MJPEG,
2784     .priv_data_size = sizeof(MJpegDecodeContext),
2785     .init           = ff_mjpeg_decode_init,
2786     .close          = ff_mjpeg_decode_end,
2787     .decode         = ff_mjpeg_decode_frame,
2788     .flush          = decode_flush,
2789     .capabilities   = AV_CODEC_CAP_DR1,
2790     .max_lowres     = 3,
2791     .priv_class     = &mjpegdec_class,
2792     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
2793                       FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2794     .hw_configs     = (const AVCodecHWConfigInternal*[]) {
2795 #if CONFIG_MJPEG_NVDEC_HWACCEL
2796                         HWACCEL_NVDEC(mjpeg),
2797 #endif
2798 #if CONFIG_MJPEG_VAAPI_HWACCEL
2799                         HWACCEL_VAAPI(mjpeg),
2800 #endif
2801                         NULL
2802                     },
2803 };
2804 #endif
2805 #if CONFIG_THP_DECODER
2806 AVCodec ff_thp_decoder = {
2807     .name           = "thp",
2808     .long_name      = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
2809     .type           = AVMEDIA_TYPE_VIDEO,
2810     .id             = AV_CODEC_ID_THP,
2811     .priv_data_size = sizeof(MJpegDecodeContext),
2812     .init           = ff_mjpeg_decode_init,
2813     .close          = ff_mjpeg_decode_end,
2814     .decode         = ff_mjpeg_decode_frame,
2815     .flush          = decode_flush,
2816     .capabilities   = AV_CODEC_CAP_DR1,
2817     .max_lowres     = 3,
2818     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
2819 };
2820 #endif