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

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