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