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