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

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