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         av_freep(&s->stereo3d);
1907         s->stereo3d = av_stereo3d_alloc();
1908         if (!s->stereo3d) {
1909             goto out;
1910         }
1911         if (type == 0) {
1912             s->stereo3d->type = AV_STEREO3D_2D;
1913         } else if (type == 1) {
1914             switch (layout) {
1915             case 0x01:
1916                 s->stereo3d->type = AV_STEREO3D_LINES;
1917                 break;
1918             case 0x02:
1919                 s->stereo3d->type = AV_STEREO3D_SIDEBYSIDE;
1920                 break;
1921             case 0x03:
1922                 s->stereo3d->type = AV_STEREO3D_TOPBOTTOM;
1923                 break;
1924             }
1925             if (!(flags & 0x04)) {
1926                 s->stereo3d->flags = AV_STEREO3D_FLAG_INVERT;
1927             }
1928         }
1929         goto out;
1930     }
1931
1932     /* EXIF metadata */
1933     if (s->start_code == APP1 && id == AV_RB32("Exif") && len >= 2) {
1934         GetByteContext gbytes;
1935         int ret, le, ifd_offset, bytes_read;
1936         const uint8_t *aligned;
1937
1938         skip_bits(&s->gb, 16); // skip padding
1939         len -= 2;
1940
1941         // init byte wise reading
1942         aligned = align_get_bits(&s->gb);
1943         bytestream2_init(&gbytes, aligned, len);
1944
1945         // read TIFF header
1946         ret = ff_tdecode_header(&gbytes, &le, &ifd_offset);
1947         if (ret) {
1948             av_log(s->avctx, AV_LOG_ERROR, "mjpeg: invalid TIFF header in EXIF data\n");
1949         } else {
1950             bytestream2_seek(&gbytes, ifd_offset, SEEK_SET);
1951
1952             // read 0th IFD and store the metadata
1953             // (return values > 0 indicate the presence of subimage metadata)
1954             ret = ff_exif_decode_ifd(s->avctx, &gbytes, le, 0, &s->exif_metadata);
1955             if (ret < 0) {
1956                 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error decoding EXIF data\n");
1957             }
1958         }
1959
1960         bytes_read = bytestream2_tell(&gbytes);
1961         skip_bits(&s->gb, bytes_read << 3);
1962         len -= bytes_read;
1963
1964         goto out;
1965     }
1966
1967     /* Apple MJPEG-A */
1968     if ((s->start_code == APP1) && (len > (0x28 - 8))) {
1969         id   = get_bits_long(&s->gb, 32);
1970         len -= 4;
1971         /* Apple MJPEG-A */
1972         if (id == AV_RB32("mjpg")) {
1973             /* structure:
1974                 4bytes      field size
1975                 4bytes      pad field size
1976                 4bytes      next off
1977                 4bytes      quant off
1978                 4bytes      huff off
1979                 4bytes      image off
1980                 4bytes      scan off
1981                 4bytes      data off
1982             */
1983             if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1984                 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1985         }
1986     }
1987
1988     if (s->start_code == APP2 && id == AV_RB32("ICC_") && len >= 10) {
1989         int id2;
1990         unsigned seqno;
1991         unsigned nummarkers;
1992
1993         id   = get_bits_long(&s->gb, 32);
1994         id2  = get_bits_long(&s->gb, 24);
1995         len -= 7;
1996         if (id != AV_RB32("PROF") || id2 != AV_RB24("ILE")) {
1997             av_log(s->avctx, AV_LOG_WARNING, "Invalid ICC_PROFILE header in APP2\n");
1998             goto out;
1999         }
2000
2001         skip_bits(&s->gb, 8);
2002         seqno  = get_bits(&s->gb, 8);
2003         len   -= 2;
2004         if (seqno == 0) {
2005             av_log(s->avctx, AV_LOG_WARNING, "Invalid sequence number in APP2\n");
2006             goto out;
2007         }
2008
2009         nummarkers  = get_bits(&s->gb, 8);
2010         len        -= 1;
2011         if (nummarkers == 0) {
2012             av_log(s->avctx, AV_LOG_WARNING, "Invalid number of markers coded in APP2\n");
2013             goto out;
2014         } else if (s->iccnum != 0 && nummarkers != s->iccnum) {
2015             av_log(s->avctx, AV_LOG_WARNING, "Mistmatch in coded number of ICC markers between markers\n");
2016             goto out;
2017         } else if (seqno > nummarkers) {
2018             av_log(s->avctx, AV_LOG_WARNING, "Mismatching sequence number and coded number of ICC markers\n");
2019             goto out;
2020         }
2021
2022         /* Allocate if this is the first APP2 we've seen. */
2023         if (s->iccnum == 0) {
2024             s->iccdata     = av_mallocz(nummarkers * sizeof(*(s->iccdata)));
2025             s->iccdatalens = av_mallocz(nummarkers * sizeof(*(s->iccdatalens)));
2026             if (!s->iccdata || !s->iccdatalens) {
2027                 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data arrays\n");
2028                 return AVERROR(ENOMEM);
2029             }
2030             s->iccnum = nummarkers;
2031         }
2032
2033         if (s->iccdata[seqno - 1]) {
2034             av_log(s->avctx, AV_LOG_WARNING, "Duplicate ICC sequence number\n");
2035             goto out;
2036         }
2037
2038         s->iccdatalens[seqno - 1]  = len;
2039         s->iccdata[seqno - 1]      = av_malloc(len);
2040         if (!s->iccdata[seqno - 1]) {
2041             av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data buffer\n");
2042             return AVERROR(ENOMEM);
2043         }
2044
2045         memcpy(s->iccdata[seqno - 1], align_get_bits(&s->gb), len);
2046         skip_bits(&s->gb, len << 3);
2047         len = 0;
2048         s->iccread++;
2049
2050         if (s->iccread > s->iccnum)
2051             av_log(s->avctx, AV_LOG_WARNING, "Read more ICC markers than are supposed to be coded\n");
2052     }
2053
2054 out:
2055     /* slow but needed for extreme adobe jpegs */
2056     if (len < 0)
2057         av_log(s->avctx, AV_LOG_ERROR,
2058                "mjpeg: error, decode_app parser read over the end\n");
2059     while (--len > 0)
2060         skip_bits(&s->gb, 8);
2061
2062     return 0;
2063 }
2064
2065 static int mjpeg_decode_com(MJpegDecodeContext *s)
2066 {
2067     int len = get_bits(&s->gb, 16);
2068     if (len >= 2 && 8 * len - 16 <= get_bits_left(&s->gb)) {
2069         int i;
2070         char *cbuf = av_malloc(len - 1);
2071         if (!cbuf)
2072             return AVERROR(ENOMEM);
2073
2074         for (i = 0; i < len - 2; i++)
2075             cbuf[i] = get_bits(&s->gb, 8);
2076         if (i > 0 && cbuf[i - 1] == '\n')
2077             cbuf[i - 1] = 0;
2078         else
2079             cbuf[i] = 0;
2080
2081         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2082             av_log(s->avctx, AV_LOG_INFO, "comment: '%s'\n", cbuf);
2083
2084         /* buggy avid, it puts EOI only at every 10th frame */
2085         if (!strncmp(cbuf, "AVID", 4)) {
2086             parse_avid(s, cbuf, len);
2087         } else if (!strcmp(cbuf, "CS=ITU601"))
2088             s->cs_itu601 = 1;
2089         else if ((!strncmp(cbuf, "Intel(R) JPEG Library, version 1", 32) && s->avctx->codec_tag) ||
2090                  (!strncmp(cbuf, "Metasoft MJPEG Codec", 20)))
2091             s->flipped = 1;
2092         else if (!strcmp(cbuf, "MULTISCOPE II")) {
2093             s->avctx->sample_aspect_ratio = (AVRational) { 1, 2 };
2094             s->multiscope = 2;
2095         }
2096
2097         av_free(cbuf);
2098     }
2099
2100     return 0;
2101 }
2102
2103 /* return the 8 bit start code value and update the search
2104    state. Return -1 if no start code found */
2105 static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
2106 {
2107     const uint8_t *buf_ptr;
2108     unsigned int v, v2;
2109     int val;
2110     int skipped = 0;
2111
2112     buf_ptr = *pbuf_ptr;
2113     while (buf_end - buf_ptr > 1) {
2114         v  = *buf_ptr++;
2115         v2 = *buf_ptr;
2116         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
2117             val = *buf_ptr++;
2118             goto found;
2119         }
2120         skipped++;
2121     }
2122     buf_ptr = buf_end;
2123     val = -1;
2124 found:
2125     ff_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
2126     *pbuf_ptr = buf_ptr;
2127     return val;
2128 }
2129
2130 int ff_mjpeg_find_marker(MJpegDecodeContext *s,
2131                          const uint8_t **buf_ptr, const uint8_t *buf_end,
2132                          const uint8_t **unescaped_buf_ptr,
2133                          int *unescaped_buf_size)
2134 {
2135     int start_code;
2136     start_code = find_marker(buf_ptr, buf_end);
2137
2138     av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr);
2139     if (!s->buffer)
2140         return AVERROR(ENOMEM);
2141
2142     /* unescape buffer of SOS, use special treatment for JPEG-LS */
2143     if (start_code == SOS && !s->ls) {
2144         const uint8_t *src = *buf_ptr;
2145         const uint8_t *ptr = src;
2146         uint8_t *dst = s->buffer;
2147
2148         #define copy_data_segment(skip) do {       \
2149             ptrdiff_t length = (ptr - src) - (skip);  \
2150             if (length > 0) {                         \
2151                 memcpy(dst, src, length);             \
2152                 dst += length;                        \
2153                 src = ptr;                            \
2154             }                                         \
2155         } while (0)
2156
2157         if (s->avctx->codec_id == AV_CODEC_ID_THP) {
2158             ptr = buf_end;
2159             copy_data_segment(0);
2160         } else {
2161             while (ptr < buf_end) {
2162                 uint8_t x = *(ptr++);
2163
2164                 if (x == 0xff) {
2165                     ptrdiff_t skip = 0;
2166                     while (ptr < buf_end && x == 0xff) {
2167                         x = *(ptr++);
2168                         skip++;
2169                     }
2170
2171                     /* 0xFF, 0xFF, ... */
2172                     if (skip > 1) {
2173                         copy_data_segment(skip);
2174
2175                         /* decrement src as it is equal to ptr after the
2176                          * copy_data_segment macro and we might want to
2177                          * copy the current value of x later on */
2178                         src--;
2179                     }
2180
2181                     if (x < 0xd0 || x > 0xd7) {
2182                         copy_data_segment(1);
2183                         if (x)
2184                             break;
2185                     }
2186                 }
2187             }
2188             if (src < ptr)
2189                 copy_data_segment(0);
2190         }
2191         #undef copy_data_segment
2192
2193         *unescaped_buf_ptr  = s->buffer;
2194         *unescaped_buf_size = dst - s->buffer;
2195         memset(s->buffer + *unescaped_buf_size, 0,
2196                AV_INPUT_BUFFER_PADDING_SIZE);
2197
2198         av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %"PTRDIFF_SPECIFIER" bytes\n",
2199                (buf_end - *buf_ptr) - (dst - s->buffer));
2200     } else if (start_code == SOS && s->ls) {
2201         const uint8_t *src = *buf_ptr;
2202         uint8_t *dst  = s->buffer;
2203         int bit_count = 0;
2204         int t = 0, b = 0;
2205         PutBitContext pb;
2206
2207         /* find marker */
2208         while (src + t < buf_end) {
2209             uint8_t x = src[t++];
2210             if (x == 0xff) {
2211                 while ((src + t < buf_end) && x == 0xff)
2212                     x = src[t++];
2213                 if (x & 0x80) {
2214                     t -= FFMIN(2, t);
2215                     break;
2216                 }
2217             }
2218         }
2219         bit_count = t * 8;
2220         init_put_bits(&pb, dst, t);
2221
2222         /* unescape bitstream */
2223         while (b < t) {
2224             uint8_t x = src[b++];
2225             put_bits(&pb, 8, x);
2226             if (x == 0xFF && b < t) {
2227                 x = src[b++];
2228                 if (x & 0x80) {
2229                     av_log(s->avctx, AV_LOG_WARNING, "Invalid escape sequence\n");
2230                     x &= 0x7f;
2231                 }
2232                 put_bits(&pb, 7, x);
2233                 bit_count--;
2234             }
2235         }
2236         flush_put_bits(&pb);
2237
2238         *unescaped_buf_ptr  = dst;
2239         *unescaped_buf_size = (bit_count + 7) >> 3;
2240         memset(s->buffer + *unescaped_buf_size, 0,
2241                AV_INPUT_BUFFER_PADDING_SIZE);
2242     } else {
2243         *unescaped_buf_ptr  = *buf_ptr;
2244         *unescaped_buf_size = buf_end - *buf_ptr;
2245     }
2246
2247     return start_code;
2248 }
2249
2250 static void reset_icc_profile(MJpegDecodeContext *s)
2251 {
2252     int i;
2253
2254     if (s->iccdata)
2255         for (i = 0; i < s->iccnum; i++)
2256             av_freep(&s->iccdata[i]);
2257     av_freep(&s->iccdata);
2258     av_freep(&s->iccdatalens);
2259
2260     s->iccread = 0;
2261     s->iccnum  = 0;
2262 }
2263
2264 int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
2265                           AVPacket *avpkt)
2266 {
2267     AVFrame     *frame = data;
2268     const uint8_t *buf = avpkt->data;
2269     int buf_size       = avpkt->size;
2270     MJpegDecodeContext *s = avctx->priv_data;
2271     const uint8_t *buf_end, *buf_ptr;
2272     const uint8_t *unescaped_buf_ptr;
2273     int hshift, vshift;
2274     int unescaped_buf_size;
2275     int start_code;
2276     int i, index;
2277     int ret = 0;
2278     int is16bit;
2279
2280     s->buf_size = buf_size;
2281
2282     av_dict_free(&s->exif_metadata);
2283     av_freep(&s->stereo3d);
2284     s->adobe_transform = -1;
2285
2286     if (s->iccnum != 0)
2287         reset_icc_profile(s);
2288
2289     buf_ptr = buf;
2290     buf_end = buf + buf_size;
2291     while (buf_ptr < buf_end) {
2292         /* find start next marker */
2293         start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,
2294                                           &unescaped_buf_ptr,
2295                                           &unescaped_buf_size);
2296         /* EOF */
2297         if (start_code < 0) {
2298             break;
2299         } else if (unescaped_buf_size > INT_MAX / 8) {
2300             av_log(avctx, AV_LOG_ERROR,
2301                    "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
2302                    start_code, unescaped_buf_size, buf_size);
2303             return AVERROR_INVALIDDATA;
2304         }
2305         av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%"PTRDIFF_SPECIFIER"\n",
2306                start_code, buf_end - buf_ptr);
2307
2308         ret = init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);
2309
2310         if (ret < 0) {
2311             av_log(avctx, AV_LOG_ERROR, "invalid buffer\n");
2312             goto fail;
2313         }
2314
2315         s->start_code = start_code;
2316         if (s->avctx->debug & FF_DEBUG_STARTCODE)
2317             av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2318
2319         /* process markers */
2320         if (start_code >= 0xd0 && start_code <= 0xd7) {
2321             av_log(avctx, AV_LOG_DEBUG,
2322                    "restart marker: %d\n", start_code & 0x0f);
2323             /* APP fields */
2324         } else if (start_code >= APP0 && start_code <= APP15) {
2325             if ((ret = mjpeg_decode_app(s)) < 0)
2326                 av_log(avctx, AV_LOG_ERROR, "unable to decode APP fields: %s\n",
2327                        av_err2str(ret));
2328             /* Comment */
2329         } else if (start_code == COM) {
2330             ret = mjpeg_decode_com(s);
2331             if (ret < 0)
2332                 return ret;
2333         } else if (start_code == DQT) {
2334             ret = ff_mjpeg_decode_dqt(s);
2335             if (ret < 0)
2336                 return ret;
2337         }
2338
2339         ret = -1;
2340
2341         if (!CONFIG_JPEGLS_DECODER &&
2342             (start_code == SOF48 || start_code == LSE)) {
2343             av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");
2344             return AVERROR(ENOSYS);
2345         }
2346
2347         if (avctx->skip_frame == AVDISCARD_ALL) {
2348             switch(start_code) {
2349             case SOF0:
2350             case SOF1:
2351             case SOF2:
2352             case SOF3:
2353             case SOF48:
2354             case SOI:
2355             case SOS:
2356             case EOI:
2357                 break;
2358             default:
2359                 goto skip;
2360             }
2361         }
2362
2363         switch (start_code) {
2364         case SOI:
2365             s->restart_interval = 0;
2366             s->restart_count    = 0;
2367             s->raw_image_buffer      = buf_ptr;
2368             s->raw_image_buffer_size = buf_end - buf_ptr;
2369             /* nothing to do on SOI */
2370             break;
2371         case DHT:
2372             if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
2373                 av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2374                 goto fail;
2375             }
2376             break;
2377         case SOF0:
2378         case SOF1:
2379             if (start_code == SOF0)
2380                 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT;
2381             else
2382                 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT;
2383             s->lossless    = 0;
2384             s->ls          = 0;
2385             s->progressive = 0;
2386             if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2387                 goto fail;
2388             break;
2389         case SOF2:
2390             s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT;
2391             s->lossless    = 0;
2392             s->ls          = 0;
2393             s->progressive = 1;
2394             if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2395                 goto fail;
2396             break;
2397         case SOF3:
2398             s->avctx->profile     = FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS;
2399             s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2400             s->lossless    = 1;
2401             s->ls          = 0;
2402             s->progressive = 0;
2403             if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2404                 goto fail;
2405             break;
2406         case SOF48:
2407             s->avctx->profile     = FF_PROFILE_MJPEG_JPEG_LS;
2408             s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2409             s->lossless    = 1;
2410             s->ls          = 1;
2411             s->progressive = 0;
2412             if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2413                 goto fail;
2414             break;
2415         case LSE:
2416             if (!CONFIG_JPEGLS_DECODER ||
2417                 (ret = ff_jpegls_decode_lse(s)) < 0)
2418                 goto fail;
2419             break;
2420         case EOI:
2421 eoi_parser:
2422             if (!avctx->hwaccel && avctx->skip_frame != AVDISCARD_ALL &&
2423                 s->progressive && s->cur_scan && s->got_picture)
2424                 mjpeg_idct_scan_progressive_ac(s);
2425             s->cur_scan = 0;
2426             if (!s->got_picture) {
2427                 av_log(avctx, AV_LOG_WARNING,
2428                        "Found EOI before any SOF, ignoring\n");
2429                 break;
2430             }
2431             if (s->interlaced) {
2432                 s->bottom_field ^= 1;
2433                 /* if not bottom field, do not output image yet */
2434                 if (s->bottom_field == !s->interlace_polarity)
2435                     break;
2436             }
2437             if (avctx->skip_frame == AVDISCARD_ALL) {
2438                 s->got_picture = 0;
2439                 goto the_end_no_picture;
2440             }
2441             if (s->avctx->hwaccel) {
2442                 ret = s->avctx->hwaccel->end_frame(s->avctx);
2443                 if (ret < 0)
2444                     return ret;
2445
2446                 av_freep(&s->hwaccel_picture_private);
2447             }
2448             if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
2449                 return ret;
2450             *got_frame = 1;
2451             s->got_picture = 0;
2452
2453             if (!s->lossless) {
2454                 int qp = FFMAX3(s->qscale[0],
2455                                 s->qscale[1],
2456                                 s->qscale[2]);
2457                 int qpw = (s->width + 15) / 16;
2458                 AVBufferRef *qp_table_buf = av_buffer_alloc(qpw);
2459                 if (qp_table_buf) {
2460                     memset(qp_table_buf->data, qp, qpw);
2461                     av_frame_set_qp_table(data, qp_table_buf, 0, FF_QSCALE_TYPE_MPEG1);
2462                 }
2463
2464                 if(avctx->debug & FF_DEBUG_QP)
2465                     av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);
2466             }
2467
2468             goto the_end;
2469         case SOS:
2470             s->raw_scan_buffer      = buf_ptr;
2471             s->raw_scan_buffer_size = buf_end - buf_ptr;
2472
2473             s->cur_scan++;
2474             if (avctx->skip_frame == AVDISCARD_ALL) {
2475                 skip_bits(&s->gb, get_bits_left(&s->gb));
2476                 break;
2477             }
2478
2479             if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&
2480                 (avctx->err_recognition & AV_EF_EXPLODE))
2481                 goto fail;
2482             break;
2483         case DRI:
2484             if ((ret = mjpeg_decode_dri(s)) < 0)
2485                 return ret;
2486             break;
2487         case SOF5:
2488         case SOF6:
2489         case SOF7:
2490         case SOF9:
2491         case SOF10:
2492         case SOF11:
2493         case SOF13:
2494         case SOF14:
2495         case SOF15:
2496         case JPG:
2497             av_log(avctx, AV_LOG_ERROR,
2498                    "mjpeg: unsupported coding type (%x)\n", start_code);
2499             break;
2500         }
2501
2502 skip:
2503         /* eof process start code */
2504         buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
2505         av_log(avctx, AV_LOG_DEBUG,
2506                "marker parser used %d bytes (%d bits)\n",
2507                (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
2508     }
2509     if (s->got_picture && s->cur_scan) {
2510         av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
2511         goto eoi_parser;
2512     }
2513     av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
2514     return AVERROR_INVALIDDATA;
2515 fail:
2516     s->got_picture = 0;
2517     return ret;
2518 the_end:
2519
2520     is16bit = av_pix_fmt_desc_get(s->avctx->pix_fmt)->comp[0].step > 1;
2521
2522     if (AV_RB32(s->upscale_h)) {
2523         int p;
2524         av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2525                    avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||
2526                    avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2527                    avctx->pix_fmt == AV_PIX_FMT_YUV440P  ||
2528                    avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2529                    avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2530                    avctx->pix_fmt == AV_PIX_FMT_YUV420P  ||
2531                    avctx->pix_fmt == AV_PIX_FMT_YUV420P16||
2532                    avctx->pix_fmt == AV_PIX_FMT_YUVA420P  ||
2533                    avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2534                    avctx->pix_fmt == AV_PIX_FMT_GBRP     ||
2535                    avctx->pix_fmt == AV_PIX_FMT_GBRAP
2536                   );
2537         ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2538         if (ret)
2539             return ret;
2540
2541         av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2542         for (p = 0; p<s->nb_components; p++) {
2543             uint8_t *line = s->picture_ptr->data[p];
2544             int w = s->width;
2545             int h = s->height;
2546             if (!s->upscale_h[p])
2547                 continue;
2548             if (p==1 || p==2) {
2549                 w = AV_CEIL_RSHIFT(w, hshift);
2550                 h = AV_CEIL_RSHIFT(h, vshift);
2551             }
2552             if (s->upscale_v[p] == 1)
2553                 h = (h+1)>>1;
2554             av_assert0(w > 0);
2555             for (i = 0; i < h; i++) {
2556                 if (s->upscale_h[p] == 1) {
2557                     if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];
2558                     else                      line[w - 1] = line[(w - 1) / 2];
2559                     for (index = w - 2; index > 0; index--) {
2560                         if (is16bit)
2561                             ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;
2562                         else
2563                             line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
2564                     }
2565                 } else if (s->upscale_h[p] == 2) {
2566                     if (is16bit) {
2567                         ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3];
2568                         if (w > 1)
2569                             ((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1];
2570                     } else {
2571                         line[w - 1] = line[(w - 1) / 3];
2572                         if (w > 1)
2573                             line[w - 2] = line[w - 1];
2574                     }
2575                     for (index = w - 3; index > 0; index--) {
2576                         line[index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3;
2577                     }
2578                 }
2579                 line += s->linesize[p];
2580             }
2581         }
2582     }
2583     if (AV_RB32(s->upscale_v)) {
2584         int p;
2585         av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2586                    avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||
2587                    avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2588                    avctx->pix_fmt == AV_PIX_FMT_YUV422P  ||
2589                    avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2590                    avctx->pix_fmt == AV_PIX_FMT_YUV420P  ||
2591                    avctx->pix_fmt == AV_PIX_FMT_YUV440P  ||
2592                    avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2593                    avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2594                    avctx->pix_fmt == AV_PIX_FMT_YUVA420P  ||
2595                    avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2596                    avctx->pix_fmt == AV_PIX_FMT_GBRP     ||
2597                    avctx->pix_fmt == AV_PIX_FMT_GBRAP
2598                    );
2599         ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2600         if (ret)
2601             return ret;
2602
2603         av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2604         for (p = 0; p < s->nb_components; p++) {
2605             uint8_t *dst;
2606             int w = s->width;
2607             int h = s->height;
2608             if (!s->upscale_v[p])
2609                 continue;
2610             if (p==1 || p==2) {
2611                 w = AV_CEIL_RSHIFT(w, hshift);
2612                 h = AV_CEIL_RSHIFT(h, vshift);
2613             }
2614             dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];
2615             for (i = h - 1; i; i--) {
2616                 uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2617                 uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2618                 if (s->upscale_v[p] != 2 && (src1 == src2 || i == h - 1)) {
2619                     memcpy(dst, src1, w);
2620                 } else {
2621                     for (index = 0; index < w; index++)
2622                         dst[index] = (src1[index] + src2[index]) >> 1;
2623                 }
2624                 dst -= s->linesize[p];
2625             }
2626         }
2627     }
2628     if (s->flipped && !s->rgb) {
2629         int j;
2630         ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2631         if (ret)
2632             return ret;
2633
2634         av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2635         for (index=0; index<s->nb_components; index++) {
2636             uint8_t *dst = s->picture_ptr->data[index];
2637             int w = s->picture_ptr->width;
2638             int h = s->picture_ptr->height;
2639             if(index && index<3){
2640                 w = AV_CEIL_RSHIFT(w, hshift);
2641                 h = AV_CEIL_RSHIFT(h, vshift);
2642             }
2643             if(dst){
2644                 uint8_t *dst2 = dst + s->picture_ptr->linesize[index]*(h-1);
2645                 for (i=0; i<h/2; i++) {
2646                     for (j=0; j<w; j++)
2647                         FFSWAP(int, dst[j], dst2[j]);
2648                     dst  += s->picture_ptr->linesize[index];
2649                     dst2 -= s->picture_ptr->linesize[index];
2650                 }
2651             }
2652         }
2653     }
2654     if (s->adobe_transform == 0 && s->avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
2655         int w = s->picture_ptr->width;
2656         int h = s->picture_ptr->height;
2657         av_assert0(s->nb_components == 4);
2658         for (i=0; i<h; i++) {
2659             int j;
2660             uint8_t *dst[4];
2661             for (index=0; index<4; index++) {
2662                 dst[index] =   s->picture_ptr->data[index]
2663                              + s->picture_ptr->linesize[index]*i;
2664             }
2665             for (j=0; j<w; j++) {
2666                 int k = dst[3][j];
2667                 int r = dst[0][j] * k;
2668                 int g = dst[1][j] * k;
2669                 int b = dst[2][j] * k;
2670                 dst[0][j] = g*257 >> 16;
2671                 dst[1][j] = b*257 >> 16;
2672                 dst[2][j] = r*257 >> 16;
2673                 dst[3][j] = 255;
2674             }
2675         }
2676     }
2677     if (s->adobe_transform == 2 && s->avctx->pix_fmt == AV_PIX_FMT_YUVA444P) {
2678         int w = s->picture_ptr->width;
2679         int h = s->picture_ptr->height;
2680         av_assert0(s->nb_components == 4);
2681         for (i=0; i<h; i++) {
2682             int j;
2683             uint8_t *dst[4];
2684             for (index=0; index<4; index++) {
2685                 dst[index] =   s->picture_ptr->data[index]
2686                              + s->picture_ptr->linesize[index]*i;
2687             }
2688             for (j=0; j<w; j++) {
2689                 int k = dst[3][j];
2690                 int r = (255 - dst[0][j]) * k;
2691                 int g = (128 - dst[1][j]) * k;
2692                 int b = (128 - dst[2][j]) * k;
2693                 dst[0][j] = r*257 >> 16;
2694                 dst[1][j] = (g*257 >> 16) + 128;
2695                 dst[2][j] = (b*257 >> 16) + 128;
2696                 dst[3][j] = 255;
2697             }
2698         }
2699     }
2700
2701     if (s->stereo3d) {
2702         AVStereo3D *stereo = av_stereo3d_create_side_data(data);
2703         if (stereo) {
2704             stereo->type  = s->stereo3d->type;
2705             stereo->flags = s->stereo3d->flags;
2706         }
2707         av_freep(&s->stereo3d);
2708     }
2709
2710     if (s->iccnum != 0 && s->iccnum == s->iccread) {
2711         AVFrameSideData *sd;
2712         size_t offset = 0;
2713         int total_size = 0;
2714         int i;
2715
2716         /* Sum size of all parts. */
2717         for (i = 0; i < s->iccnum; i++)
2718             total_size += s->iccdatalens[i];
2719
2720         sd = av_frame_new_side_data(data, AV_FRAME_DATA_ICC_PROFILE, total_size);
2721         if (!sd) {
2722             av_log(s->avctx, AV_LOG_ERROR, "Could not allocate frame side data\n");
2723             return AVERROR(ENOMEM);
2724         }
2725
2726         /* Reassemble the parts, which are now in-order. */
2727         for (i = 0; i < s->iccnum; i++) {
2728             memcpy(sd->data + offset, s->iccdata[i], s->iccdatalens[i]);
2729             offset += s->iccdatalens[i];
2730         }
2731     }
2732
2733     av_dict_copy(&((AVFrame *) data)->metadata, s->exif_metadata, 0);
2734     av_dict_free(&s->exif_metadata);
2735
2736 the_end_no_picture:
2737     av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n",
2738            buf_end - buf_ptr);
2739 //  return buf_end - buf_ptr;
2740     return buf_ptr - buf;
2741 }
2742
2743 av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
2744 {
2745     MJpegDecodeContext *s = avctx->priv_data;
2746     int i, j;
2747
2748     if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_number) {
2749         av_log(avctx, AV_LOG_INFO, "Single field\n");
2750     }
2751
2752     if (s->picture) {
2753         av_frame_free(&s->picture);
2754         s->picture_ptr = NULL;
2755     } else if (s->picture_ptr)
2756         av_frame_unref(s->picture_ptr);
2757
2758     av_freep(&s->buffer);
2759     av_freep(&s->stereo3d);
2760     av_freep(&s->ljpeg_buffer);
2761     s->ljpeg_buffer_size = 0;
2762
2763     for (i = 0; i < 3; i++) {
2764         for (j = 0; j < 4; j++)
2765             ff_free_vlc(&s->vlcs[i][j]);
2766     }
2767     for (i = 0; i < MAX_COMPONENTS; i++) {
2768         av_freep(&s->blocks[i]);
2769         av_freep(&s->last_nnz[i]);
2770     }
2771     av_dict_free(&s->exif_metadata);
2772
2773     reset_icc_profile(s);
2774
2775     av_freep(&s->hwaccel_picture_private);
2776
2777     return 0;
2778 }
2779
2780 static void decode_flush(AVCodecContext *avctx)
2781 {
2782     MJpegDecodeContext *s = avctx->priv_data;
2783     s->got_picture = 0;
2784 }
2785
2786 #if CONFIG_MJPEG_DECODER
2787 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
2788 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2789 static const AVOption options[] = {
2790     { "extern_huff", "Use external huffman table.",
2791       OFFSET(extern_huff), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
2792     { NULL },
2793 };
2794
2795 static const AVClass mjpegdec_class = {
2796     .class_name = "MJPEG decoder",
2797     .item_name  = av_default_item_name,
2798     .option     = options,
2799     .version    = LIBAVUTIL_VERSION_INT,
2800 };
2801
2802 AVCodec ff_mjpeg_decoder = {
2803     .name           = "mjpeg",
2804     .long_name      = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
2805     .type           = AVMEDIA_TYPE_VIDEO,
2806     .id             = AV_CODEC_ID_MJPEG,
2807     .priv_data_size = sizeof(MJpegDecodeContext),
2808     .init           = ff_mjpeg_decode_init,
2809     .close          = ff_mjpeg_decode_end,
2810     .decode         = ff_mjpeg_decode_frame,
2811     .flush          = decode_flush,
2812     .capabilities   = AV_CODEC_CAP_DR1,
2813     .max_lowres     = 3,
2814     .priv_class     = &mjpegdec_class,
2815     .profiles       = NULL_IF_CONFIG_SMALL(ff_mjpeg_profiles),
2816     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
2817                       FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2818     .hw_configs     = (const AVCodecHWConfigInternal*[]) {
2819 #if CONFIG_MJPEG_NVDEC_HWACCEL
2820                         HWACCEL_NVDEC(mjpeg),
2821 #endif
2822 #if CONFIG_MJPEG_VAAPI_HWACCEL
2823                         HWACCEL_VAAPI(mjpeg),
2824 #endif
2825                         NULL
2826                     },
2827 };
2828 #endif
2829 #if CONFIG_THP_DECODER
2830 AVCodec ff_thp_decoder = {
2831     .name           = "thp",
2832     .long_name      = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
2833     .type           = AVMEDIA_TYPE_VIDEO,
2834     .id             = AV_CODEC_ID_THP,
2835     .priv_data_size = sizeof(MJpegDecodeContext),
2836     .init           = ff_mjpeg_decode_init,
2837     .close          = ff_mjpeg_decode_end,
2838     .decode         = ff_mjpeg_decode_frame,
2839     .flush          = decode_flush,
2840     .capabilities   = AV_CODEC_CAP_DR1,
2841     .max_lowres     = 3,
2842     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
2843 };
2844 #endif