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