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

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