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

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