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