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