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