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