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