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         av_log(s->avctx, AV_LOG_ERROR, "Unhandled pixel format 0x%x bits:%d\n", 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         av_log(s->avctx, AV_LOG_ERROR, "lowres not supported for weird subsampling\n");
 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         av_log(s->avctx, AV_LOG_ERROR,
1487                "decode_sos: nb_components (%d) unsupported\n", nb_components);
1488         return AVERROR_PATCHWELCOME;
1489     }
1490     if (len != 6 + 2 * nb_components) {
1491         av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1492         return AVERROR_INVALIDDATA;
1493     }
1494     for (i = 0; i < nb_components; i++) {
1495         id = get_bits(&s->gb, 8) - 1;
1496         av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1497         /* find component index */
1498         for (index = 0; index < s->nb_components; index++)
1499             if (id == s->component_id[index])
1500                 break;
1501         if (index == s->nb_components) {
1502             av_log(s->avctx, AV_LOG_ERROR,
1503                    "decode_sos: index(%d) out of components\n", index);
1504             return AVERROR_INVALIDDATA;
1505         }
1506         /* Metasoft MJPEG codec has Cb and Cr swapped */
1507         if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
1508             && nb_components == 3 && s->nb_components == 3 && i)
1509             index = 3 - i;
1510
1511         s->quant_sindex[i] = s->quant_index[index];
1512         s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1513         s->h_scount[i]  = s->h_count[index];
1514         s->v_scount[i]  = s->v_count[index];
1515
1516         if(nb_components == 3 && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
1517             index = (i+2)%3;
1518         if(nb_components == 1 && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
1519             index = (index+2)%3;
1520
1521         s->comp_index[i] = index;
1522
1523         s->dc_index[i] = get_bits(&s->gb, 4);
1524         s->ac_index[i] = get_bits(&s->gb, 4);
1525
1526         if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1527             s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1528             goto out_of_range;
1529         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))
1530             goto out_of_range;
1531     }
1532
1533     predictor = get_bits(&s->gb, 8);       /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1534     ilv = get_bits(&s->gb, 8);             /* JPEG Se / JPEG-LS ILV */
1535     if(s->avctx->codec_tag != AV_RL32("CJPG")){
1536         prev_shift      = get_bits(&s->gb, 4); /* Ah */
1537         point_transform = get_bits(&s->gb, 4); /* Al */
1538     }else
1539         prev_shift = point_transform = 0;
1540
1541     if (nb_components > 1) {
1542         /* interleaved stream */
1543         s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1544         s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1545     } else if (!s->ls) { /* skip this for JPEG-LS */
1546         h = s->h_max / s->h_scount[0];
1547         v = s->v_max / s->v_scount[0];
1548         s->mb_width     = (s->width  + h * block_size - 1) / (h * block_size);
1549         s->mb_height    = (s->height + v * block_size - 1) / (v * block_size);
1550         s->nb_blocks[0] = 1;
1551         s->h_scount[0]  = 1;
1552         s->v_scount[0]  = 1;
1553     }
1554
1555     if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1556         av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n",
1557                s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",
1558                predictor, point_transform, ilv, s->bits, s->mjpb_skiptosod,
1559                s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), nb_components);
1560
1561
1562     /* mjpeg-b can have padding bytes between sos and image data, skip them */
1563     for (i = s->mjpb_skiptosod; i > 0; i--)
1564         skip_bits(&s->gb, 8);
1565
1566 next_field:
1567     for (i = 0; i < nb_components; i++)
1568         s->last_dc[i] = (4 << s->bits);
1569
1570     if (s->lossless) {
1571         av_assert0(s->picture_ptr == s->picture);
1572         if (CONFIG_JPEGLS_DECODER && s->ls) {
1573 //            for () {
1574 //            reset_ls_coding_parameters(s, 0);
1575
1576             if ((ret = ff_jpegls_decode_picture(s, predictor,
1577                                                 point_transform, ilv)) < 0)
1578                 return ret;
1579         } else {
1580             if (s->rgb) {
1581                 if ((ret = ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform)) < 0)
1582                     return ret;
1583             } else {
1584                 if ((ret = ljpeg_decode_yuv_scan(s, predictor,
1585                                                  point_transform,
1586                                                  nb_components)) < 0)
1587                     return ret;
1588             }
1589         }
1590     } else {
1591         if (s->progressive && predictor) {
1592             av_assert0(s->picture_ptr == s->picture);
1593             if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor,
1594                                                         ilv, prev_shift,
1595                                                         point_transform)) < 0)
1596                 return ret;
1597         } else {
1598             if ((ret = mjpeg_decode_scan(s, nb_components,
1599                                          prev_shift, point_transform,
1600                                          mb_bitmask, mb_bitmask_size, reference)) < 0)
1601                 return ret;
1602         }
1603     }
1604
1605     if (s->interlaced &&
1606         get_bits_left(&s->gb) > 32 &&
1607         show_bits(&s->gb, 8) == 0xFF) {
1608         GetBitContext bak = s->gb;
1609         align_get_bits(&bak);
1610         if (show_bits(&bak, 16) == 0xFFD1) {
1611             av_log(s->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n");
1612             s->gb = bak;
1613             skip_bits(&s->gb, 16);
1614             s->bottom_field ^= 1;
1615
1616             goto next_field;
1617         }
1618     }
1619
1620     emms_c();
1621     return 0;
1622  out_of_range:
1623     av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1624     return AVERROR_INVALIDDATA;
1625 }
1626
1627 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1628 {
1629     if (get_bits(&s->gb, 16) != 4)
1630         return AVERROR_INVALIDDATA;
1631     s->restart_interval = get_bits(&s->gb, 16);
1632     s->restart_count    = 0;
1633     av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
1634            s->restart_interval);
1635
1636     return 0;
1637 }
1638
1639 static int mjpeg_decode_app(MJpegDecodeContext *s)
1640 {
1641     int len, id, i;
1642
1643     len = get_bits(&s->gb, 16);
1644     if (len < 6)
1645         return AVERROR_INVALIDDATA;
1646     if (8 * len > get_bits_left(&s->gb))
1647         return AVERROR_INVALIDDATA;
1648
1649     id   = get_bits_long(&s->gb, 32);
1650     len -= 6;
1651
1652     if (s->avctx->debug & FF_DEBUG_STARTCODE)
1653         av_log(s->avctx, AV_LOG_DEBUG, "APPx (%s / %8X) len=%d\n",
1654                av_fourcc2str(av_bswap32(id)), id, len);
1655
1656     /* Buggy AVID, it puts EOI only at every 10th frame. */
1657     /* Also, this fourcc is used by non-avid files too, it holds some
1658        information, but it's always present in AVID-created files. */
1659     if (id == AV_RB32("AVI1")) {
1660         /* structure:
1661             4bytes      AVI1
1662             1bytes      polarity
1663             1bytes      always zero
1664             4bytes      field_size
1665             4bytes      field_size_less_padding
1666         */
1667             s->buggy_avid = 1;
1668         i = get_bits(&s->gb, 8); len--;
1669         av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i);
1670         goto out;
1671     }
1672
1673     if (id == AV_RB32("JFIF")) {
1674         int t_w, t_h, v1, v2;
1675         if (len < 8)
1676             goto out;
1677         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1678         v1 = get_bits(&s->gb, 8);
1679         v2 = get_bits(&s->gb, 8);
1680         skip_bits(&s->gb, 8);
1681
1682         s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 16);
1683         s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16);
1684         if (   s->avctx->sample_aspect_ratio.num <= 0
1685             || s->avctx->sample_aspect_ratio.den <= 0) {
1686             s->avctx->sample_aspect_ratio.num = 0;
1687             s->avctx->sample_aspect_ratio.den = 1;
1688         }
1689
1690         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1691             av_log(s->avctx, AV_LOG_INFO,
1692                    "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1693                    v1, v2,
1694                    s->avctx->sample_aspect_ratio.num,
1695                    s->avctx->sample_aspect_ratio.den);
1696
1697         len -= 8;
1698         if (len >= 2) {
1699             t_w = get_bits(&s->gb, 8);
1700             t_h = get_bits(&s->gb, 8);
1701             if (t_w && t_h) {
1702                 /* skip thumbnail */
1703                 if (len -10 - (t_w * t_h * 3) > 0)
1704                     len -= t_w * t_h * 3;
1705             }
1706             len -= 2;
1707         }
1708         goto out;
1709     }
1710
1711     if (   id == AV_RB32("Adob")
1712         && len >= 7
1713         && show_bits(&s->gb, 8) == 'e'
1714         && show_bits_long(&s->gb, 32) != AV_RB32("e_CM")) {
1715         skip_bits(&s->gb,  8); /* 'e' */
1716         skip_bits(&s->gb, 16); /* version */
1717         skip_bits(&s->gb, 16); /* flags0 */
1718         skip_bits(&s->gb, 16); /* flags1 */
1719         s->adobe_transform = get_bits(&s->gb,  8);
1720         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1721             av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found, transform=%d\n", s->adobe_transform);
1722         len -= 7;
1723         goto out;
1724     }
1725
1726     if (id == AV_RB32("LJIF")) {
1727         int rgb = s->rgb;
1728         int pegasus_rct = s->pegasus_rct;
1729         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1730             av_log(s->avctx, AV_LOG_INFO,
1731                    "Pegasus lossless jpeg header found\n");
1732         skip_bits(&s->gb, 16); /* version ? */
1733         skip_bits(&s->gb, 16); /* unknown always 0? */
1734         skip_bits(&s->gb, 16); /* unknown always 0? */
1735         skip_bits(&s->gb, 16); /* unknown always 0? */
1736         switch (i=get_bits(&s->gb, 8)) {
1737         case 1:
1738             rgb         = 1;
1739             pegasus_rct = 0;
1740             break;
1741         case 2:
1742             rgb         = 1;
1743             pegasus_rct = 1;
1744             break;
1745         default:
1746             av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace %d\n", i);
1747         }
1748
1749         len -= 9;
1750         if (s->got_picture)
1751             if (rgb != s->rgb || pegasus_rct != s->pegasus_rct) {
1752                 av_log(s->avctx, AV_LOG_WARNING, "Mismatching LJIF tag\n");
1753                 goto out;
1754             }
1755
1756         s->rgb = rgb;
1757         s->pegasus_rct = pegasus_rct;
1758
1759         goto out;
1760     }
1761     if (id == AV_RL32("colr") && len > 0) {
1762         s->colr = get_bits(&s->gb, 8);
1763         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1764             av_log(s->avctx, AV_LOG_INFO, "COLR %d\n", s->colr);
1765         len --;
1766         goto out;
1767     }
1768     if (id == AV_RL32("xfrm") && len > 0) {
1769         s->xfrm = get_bits(&s->gb, 8);
1770         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1771             av_log(s->avctx, AV_LOG_INFO, "XFRM %d\n", s->xfrm);
1772         len --;
1773         goto out;
1774     }
1775
1776     /* JPS extension by VRex */
1777     if (s->start_code == APP3 && id == AV_RB32("_JPS") && len >= 10) {
1778         int flags, layout, type;
1779         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1780             av_log(s->avctx, AV_LOG_INFO, "_JPSJPS_\n");
1781
1782         skip_bits(&s->gb, 32); len -= 4;  /* JPS_ */
1783         skip_bits(&s->gb, 16); len -= 2;  /* block length */
1784         skip_bits(&s->gb, 8);             /* reserved */
1785         flags  = get_bits(&s->gb, 8);
1786         layout = get_bits(&s->gb, 8);
1787         type   = get_bits(&s->gb, 8);
1788         len -= 4;
1789
1790         s->stereo3d = av_stereo3d_alloc();
1791         if (!s->stereo3d) {
1792             goto out;
1793         }
1794         if (type == 0) {
1795             s->stereo3d->type = AV_STEREO3D_2D;
1796         } else if (type == 1) {
1797             switch (layout) {
1798             case 0x01:
1799                 s->stereo3d->type = AV_STEREO3D_LINES;
1800                 break;
1801             case 0x02:
1802                 s->stereo3d->type = AV_STEREO3D_SIDEBYSIDE;
1803                 break;
1804             case 0x03:
1805                 s->stereo3d->type = AV_STEREO3D_TOPBOTTOM;
1806                 break;
1807             }
1808             if (!(flags & 0x04)) {
1809                 s->stereo3d->flags = AV_STEREO3D_FLAG_INVERT;
1810             }
1811         }
1812         goto out;
1813     }
1814
1815     /* EXIF metadata */
1816     if (s->start_code == APP1 && id == AV_RB32("Exif") && len >= 2) {
1817         GetByteContext gbytes;
1818         int ret, le, ifd_offset, bytes_read;
1819         const uint8_t *aligned;
1820
1821         skip_bits(&s->gb, 16); // skip padding
1822         len -= 2;
1823
1824         // init byte wise reading
1825         aligned = align_get_bits(&s->gb);
1826         bytestream2_init(&gbytes, aligned, len);
1827
1828         // read TIFF header
1829         ret = ff_tdecode_header(&gbytes, &le, &ifd_offset);
1830         if (ret) {
1831             av_log(s->avctx, AV_LOG_ERROR, "mjpeg: invalid TIFF header in EXIF data\n");
1832         } else {
1833             bytestream2_seek(&gbytes, ifd_offset, SEEK_SET);
1834
1835             // read 0th IFD and store the metadata
1836             // (return values > 0 indicate the presence of subimage metadata)
1837             ret = avpriv_exif_decode_ifd(s->avctx, &gbytes, le, 0, &s->exif_metadata);
1838             if (ret < 0) {
1839                 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error decoding EXIF data\n");
1840             }
1841         }
1842
1843         bytes_read = bytestream2_tell(&gbytes);
1844         skip_bits(&s->gb, bytes_read << 3);
1845         len -= bytes_read;
1846
1847         goto out;
1848     }
1849
1850     /* Apple MJPEG-A */
1851     if ((s->start_code == APP1) && (len > (0x28 - 8))) {
1852         id   = get_bits_long(&s->gb, 32);
1853         len -= 4;
1854         /* Apple MJPEG-A */
1855         if (id == AV_RB32("mjpg")) {
1856             /* structure:
1857                 4bytes      field size
1858                 4bytes      pad field size
1859                 4bytes      next off
1860                 4bytes      quant off
1861                 4bytes      huff off
1862                 4bytes      image off
1863                 4bytes      scan off
1864                 4bytes      data off
1865             */
1866             if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1867                 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1868         }
1869     }
1870
1871 out:
1872     /* slow but needed for extreme adobe jpegs */
1873     if (len < 0)
1874         av_log(s->avctx, AV_LOG_ERROR,
1875                "mjpeg: error, decode_app parser read over the end\n");
1876     while (--len > 0)
1877         skip_bits(&s->gb, 8);
1878
1879     return 0;
1880 }
1881
1882 static int mjpeg_decode_com(MJpegDecodeContext *s)
1883 {
1884     int len = get_bits(&s->gb, 16);
1885     if (len >= 2 && 8 * len - 16 <= get_bits_left(&s->gb)) {
1886         int i;
1887         char *cbuf = av_malloc(len - 1);
1888         if (!cbuf)
1889             return AVERROR(ENOMEM);
1890
1891         for (i = 0; i < len - 2; i++)
1892             cbuf[i] = get_bits(&s->gb, 8);
1893         if (i > 0 && cbuf[i - 1] == '\n')
1894             cbuf[i - 1] = 0;
1895         else
1896             cbuf[i] = 0;
1897
1898         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1899             av_log(s->avctx, AV_LOG_INFO, "comment: '%s'\n", cbuf);
1900
1901         /* buggy avid, it puts EOI only at every 10th frame */
1902         if (!strncmp(cbuf, "AVID", 4)) {
1903             parse_avid(s, cbuf, len);
1904         } else if (!strcmp(cbuf, "CS=ITU601"))
1905             s->cs_itu601 = 1;
1906         else if ((!strncmp(cbuf, "Intel(R) JPEG Library, version 1", 32) && s->avctx->codec_tag) ||
1907                  (!strncmp(cbuf, "Metasoft MJPEG Codec", 20)))
1908             s->flipped = 1;
1909         else if (!strcmp(cbuf, "MULTISCOPE II")) {
1910             s->avctx->sample_aspect_ratio = (AVRational) { 1, 2 };
1911             s->multiscope = 2;
1912         }
1913
1914         av_free(cbuf);
1915     }
1916
1917     return 0;
1918 }
1919
1920 /* return the 8 bit start code value and update the search
1921    state. Return -1 if no start code found */
1922 static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
1923 {
1924     const uint8_t *buf_ptr;
1925     unsigned int v, v2;
1926     int val;
1927     int skipped = 0;
1928
1929     buf_ptr = *pbuf_ptr;
1930     while (buf_end - buf_ptr > 1) {
1931         v  = *buf_ptr++;
1932         v2 = *buf_ptr;
1933         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1934             val = *buf_ptr++;
1935             goto found;
1936         }
1937         skipped++;
1938     }
1939     buf_ptr = buf_end;
1940     val = -1;
1941 found:
1942     ff_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
1943     *pbuf_ptr = buf_ptr;
1944     return val;
1945 }
1946
1947 int ff_mjpeg_find_marker(MJpegDecodeContext *s,
1948                          const uint8_t **buf_ptr, const uint8_t *buf_end,
1949                          const uint8_t **unescaped_buf_ptr,
1950                          int *unescaped_buf_size)
1951 {
1952     int start_code;
1953     start_code = find_marker(buf_ptr, buf_end);
1954
1955     av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr);
1956     if (!s->buffer)
1957         return AVERROR(ENOMEM);
1958
1959     /* unescape buffer of SOS, use special treatment for JPEG-LS */
1960     if (start_code == SOS && !s->ls) {
1961         const uint8_t *src = *buf_ptr;
1962         const uint8_t *ptr = src;
1963         uint8_t *dst = s->buffer;
1964
1965         #define copy_data_segment(skip) do {       \
1966             ptrdiff_t length = (ptr - src) - (skip);  \
1967             if (length > 0) {                         \
1968                 memcpy(dst, src, length);             \
1969                 dst += length;                        \
1970                 src = ptr;                            \
1971             }                                         \
1972         } while (0)
1973
1974         if (s->avctx->codec_id == AV_CODEC_ID_THP) {
1975             ptr = buf_end;
1976             copy_data_segment(0);
1977         } else {
1978             while (ptr < buf_end) {
1979                 uint8_t x = *(ptr++);
1980
1981                 if (x == 0xff) {
1982                     ptrdiff_t skip = 0;
1983                     while (ptr < buf_end && x == 0xff) {
1984                         x = *(ptr++);
1985                         skip++;
1986                     }
1987
1988                     /* 0xFF, 0xFF, ... */
1989                     if (skip > 1) {
1990                         copy_data_segment(skip);
1991
1992                         /* decrement src as it is equal to ptr after the
1993                          * copy_data_segment macro and we might want to
1994                          * copy the current value of x later on */
1995                         src--;
1996                     }
1997
1998                     if (x < 0xd0 || x > 0xd7) {
1999                         copy_data_segment(1);
2000                         if (x)
2001                             break;
2002                     }
2003                 }
2004             }
2005             if (src < ptr)
2006                 copy_data_segment(0);
2007         }
2008         #undef copy_data_segment
2009
2010         *unescaped_buf_ptr  = s->buffer;
2011         *unescaped_buf_size = dst - s->buffer;
2012         memset(s->buffer + *unescaped_buf_size, 0,
2013                AV_INPUT_BUFFER_PADDING_SIZE);
2014
2015         av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %"PTRDIFF_SPECIFIER" bytes\n",
2016                (buf_end - *buf_ptr) - (dst - s->buffer));
2017     } else if (start_code == SOS && s->ls) {
2018         const uint8_t *src = *buf_ptr;
2019         uint8_t *dst  = s->buffer;
2020         int bit_count = 0;
2021         int t = 0, b = 0;
2022         PutBitContext pb;
2023
2024         /* find marker */
2025         while (src + t < buf_end) {
2026             uint8_t x = src[t++];
2027             if (x == 0xff) {
2028                 while ((src + t < buf_end) && x == 0xff)
2029                     x = src[t++];
2030                 if (x & 0x80) {
2031                     t -= FFMIN(2, t);
2032                     break;
2033                 }
2034             }
2035         }
2036         bit_count = t * 8;
2037         init_put_bits(&pb, dst, t);
2038
2039         /* unescape bitstream */
2040         while (b < t) {
2041             uint8_t x = src[b++];
2042             put_bits(&pb, 8, x);
2043             if (x == 0xFF && b < t) {
2044                 x = src[b++];
2045                 if (x & 0x80) {
2046                     av_log(s->avctx, AV_LOG_WARNING, "Invalid escape sequence\n");
2047                     x &= 0x7f;
2048                 }
2049                 put_bits(&pb, 7, x);
2050                 bit_count--;
2051             }
2052         }
2053         flush_put_bits(&pb);
2054
2055         *unescaped_buf_ptr  = dst;
2056         *unescaped_buf_size = (bit_count + 7) >> 3;
2057         memset(s->buffer + *unescaped_buf_size, 0,
2058                AV_INPUT_BUFFER_PADDING_SIZE);
2059     } else {
2060         *unescaped_buf_ptr  = *buf_ptr;
2061         *unescaped_buf_size = buf_end - *buf_ptr;
2062     }
2063
2064     return start_code;
2065 }
2066
2067 int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
2068                           AVPacket *avpkt)
2069 {
2070     AVFrame     *frame = data;
2071     const uint8_t *buf = avpkt->data;
2072     int buf_size       = avpkt->size;
2073     MJpegDecodeContext *s = avctx->priv_data;
2074     const uint8_t *buf_end, *buf_ptr;
2075     const uint8_t *unescaped_buf_ptr;
2076     int hshift, vshift;
2077     int unescaped_buf_size;
2078     int start_code;
2079     int i, index;
2080     int ret = 0;
2081     int is16bit;
2082
2083     av_dict_free(&s->exif_metadata);
2084     av_freep(&s->stereo3d);
2085     s->adobe_transform = -1;
2086
2087     buf_ptr = buf;
2088     buf_end = buf + buf_size;
2089     while (buf_ptr < buf_end) {
2090         /* find start next marker */
2091         start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,
2092                                           &unescaped_buf_ptr,
2093                                           &unescaped_buf_size);
2094         /* EOF */
2095         if (start_code < 0) {
2096             break;
2097         } else if (unescaped_buf_size > INT_MAX / 8) {
2098             av_log(avctx, AV_LOG_ERROR,
2099                    "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
2100                    start_code, unescaped_buf_size, buf_size);
2101             return AVERROR_INVALIDDATA;
2102         }
2103         av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%"PTRDIFF_SPECIFIER"\n",
2104                start_code, buf_end - buf_ptr);
2105
2106         ret = init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);
2107
2108         if (ret < 0) {
2109             av_log(avctx, AV_LOG_ERROR, "invalid buffer\n");
2110             goto fail;
2111         }
2112
2113         s->start_code = start_code;
2114         if (s->avctx->debug & FF_DEBUG_STARTCODE)
2115             av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2116
2117         /* process markers */
2118         if (start_code >= 0xd0 && start_code <= 0xd7)
2119             av_log(avctx, AV_LOG_DEBUG,
2120                    "restart marker: %d\n", start_code & 0x0f);
2121             /* APP fields */
2122         else if (start_code >= APP0 && start_code <= APP15)
2123             mjpeg_decode_app(s);
2124             /* Comment */
2125         else if (start_code == COM) {
2126             ret = mjpeg_decode_com(s);
2127             if (ret < 0)
2128                 return ret;
2129         } else if (start_code == DQT) {
2130             ff_mjpeg_decode_dqt(s);
2131         }
2132
2133         ret = -1;
2134
2135         if (!CONFIG_JPEGLS_DECODER &&
2136             (start_code == SOF48 || start_code == LSE)) {
2137             av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");
2138             return AVERROR(ENOSYS);
2139         }
2140
2141         if (avctx->skip_frame == AVDISCARD_ALL) {
2142             switch(start_code) {
2143             case SOF0:
2144             case SOF1:
2145             case SOF2:
2146             case SOF3:
2147             case SOF48:
2148             case SOI:
2149             case SOS:
2150             case EOI:
2151                 break;
2152             default:
2153                 goto skip;
2154             }
2155         }
2156
2157         switch (start_code) {
2158         case SOI:
2159             s->restart_interval = 0;
2160             s->restart_count    = 0;
2161             /* nothing to do on SOI */
2162             break;
2163         case DHT:
2164             if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
2165                 av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2166                 goto fail;
2167             }
2168             break;
2169         case SOF0:
2170         case SOF1:
2171             s->lossless    = 0;
2172             s->ls          = 0;
2173             s->progressive = 0;
2174             if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2175                 goto fail;
2176             break;
2177         case SOF2:
2178             s->lossless    = 0;
2179             s->ls          = 0;
2180             s->progressive = 1;
2181             if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2182                 goto fail;
2183             break;
2184         case SOF3:
2185             s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2186             s->lossless    = 1;
2187             s->ls          = 0;
2188             s->progressive = 0;
2189             if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2190                 goto fail;
2191             break;
2192         case SOF48:
2193             s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2194             s->lossless    = 1;
2195             s->ls          = 1;
2196             s->progressive = 0;
2197             if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2198                 goto fail;
2199             break;
2200         case LSE:
2201             if (!CONFIG_JPEGLS_DECODER ||
2202                 (ret = ff_jpegls_decode_lse(s)) < 0)
2203                 goto fail;
2204             break;
2205         case EOI:
2206 eoi_parser:
2207             if (avctx->skip_frame != AVDISCARD_ALL && s->progressive && s->cur_scan && s->got_picture)
2208                 mjpeg_idct_scan_progressive_ac(s);
2209             s->cur_scan = 0;
2210             if (!s->got_picture) {
2211                 av_log(avctx, AV_LOG_WARNING,
2212                        "Found EOI before any SOF, ignoring\n");
2213                 break;
2214             }
2215             if (s->interlaced) {
2216                 s->bottom_field ^= 1;
2217                 /* if not bottom field, do not output image yet */
2218                 if (s->bottom_field == !s->interlace_polarity)
2219                     break;
2220             }
2221             if (avctx->skip_frame == AVDISCARD_ALL) {
2222                 s->got_picture = 0;
2223                 goto the_end_no_picture;
2224             }
2225             if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
2226                 return ret;
2227             *got_frame = 1;
2228             s->got_picture = 0;
2229
2230             if (!s->lossless) {
2231                 int qp = FFMAX3(s->qscale[0],
2232                                 s->qscale[1],
2233                                 s->qscale[2]);
2234                 int qpw = (s->width + 15) / 16;
2235                 AVBufferRef *qp_table_buf = av_buffer_alloc(qpw);
2236                 if (qp_table_buf) {
2237                     memset(qp_table_buf->data, qp, qpw);
2238                     av_frame_set_qp_table(data, qp_table_buf, 0, FF_QSCALE_TYPE_MPEG1);
2239                 }
2240
2241                 if(avctx->debug & FF_DEBUG_QP)
2242                     av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);
2243             }
2244
2245             goto the_end;
2246         case SOS:
2247             s->cur_scan++;
2248             if (avctx->skip_frame == AVDISCARD_ALL) {
2249                 skip_bits(&s->gb, get_bits_left(&s->gb));
2250                 break;
2251             }
2252
2253             if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&
2254                 (avctx->err_recognition & AV_EF_EXPLODE))
2255                 goto fail;
2256             break;
2257         case DRI:
2258             mjpeg_decode_dri(s);
2259             break;
2260         case SOF5:
2261         case SOF6:
2262         case SOF7:
2263         case SOF9:
2264         case SOF10:
2265         case SOF11:
2266         case SOF13:
2267         case SOF14:
2268         case SOF15:
2269         case JPG:
2270             av_log(avctx, AV_LOG_ERROR,
2271                    "mjpeg: unsupported coding type (%x)\n", start_code);
2272             break;
2273         }
2274
2275 skip:
2276         /* eof process start code */
2277         buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
2278         av_log(avctx, AV_LOG_DEBUG,
2279                "marker parser used %d bytes (%d bits)\n",
2280                (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
2281     }
2282     if (s->got_picture && s->cur_scan) {
2283         av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
2284         goto eoi_parser;
2285     }
2286     av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
2287     return AVERROR_INVALIDDATA;
2288 fail:
2289     s->got_picture = 0;
2290     return ret;
2291 the_end:
2292
2293     is16bit = av_pix_fmt_desc_get(s->avctx->pix_fmt)->comp[0].step > 1;
2294
2295     if (AV_RB32(s->upscale_h)) {
2296         int p;
2297         av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2298                    avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||
2299                    avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2300                    avctx->pix_fmt == AV_PIX_FMT_YUV440P  ||
2301                    avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2302                    avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2303                    avctx->pix_fmt == AV_PIX_FMT_YUV420P  ||
2304                    avctx->pix_fmt == AV_PIX_FMT_YUV420P16||
2305                    avctx->pix_fmt == AV_PIX_FMT_YUVA420P  ||
2306                    avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2307                    avctx->pix_fmt == AV_PIX_FMT_GBRP     ||
2308                    avctx->pix_fmt == AV_PIX_FMT_GBRAP
2309                   );
2310         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2311         av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2312         for (p = 0; p<s->nb_components; p++) {
2313             uint8_t *line = s->picture_ptr->data[p];
2314             int w = s->width;
2315             int h = s->height;
2316             if (!s->upscale_h[p])
2317                 continue;
2318             if (p==1 || p==2) {
2319                 w = AV_CEIL_RSHIFT(w, hshift);
2320                 h = AV_CEIL_RSHIFT(h, vshift);
2321             }
2322             if (s->upscale_v[p])
2323                 h = (h+1)>>1;
2324             av_assert0(w > 0);
2325             for (i = 0; i < h; i++) {
2326                 if (s->upscale_h[p] == 1) {
2327                     if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];
2328                     else                      line[w - 1] = line[(w - 1) / 2];
2329                     for (index = w - 2; index > 0; index--) {
2330                         if (is16bit)
2331                             ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;
2332                         else
2333                             line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
2334                     }
2335                 } else if (s->upscale_h[p] == 2) {
2336                     if (is16bit) {
2337                         ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3];
2338                         if (w > 1)
2339                             ((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1];
2340                     } else {
2341                         line[w - 1] = line[(w - 1) / 3];
2342                         if (w > 1)
2343                             line[w - 2] = line[w - 1];
2344                     }
2345                     for (index = w - 3; index > 0; index--) {
2346                         line[index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3;
2347                     }
2348                 }
2349                 line += s->linesize[p];
2350             }
2351         }
2352     }
2353     if (AV_RB32(s->upscale_v)) {
2354         int p;
2355         av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2356                    avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||
2357                    avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2358                    avctx->pix_fmt == AV_PIX_FMT_YUV422P  ||
2359                    avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2360                    avctx->pix_fmt == AV_PIX_FMT_YUV420P  ||
2361                    avctx->pix_fmt == AV_PIX_FMT_YUV440P  ||
2362                    avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2363                    avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2364                    avctx->pix_fmt == AV_PIX_FMT_YUVA420P  ||
2365                    avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2366                    avctx->pix_fmt == AV_PIX_FMT_GBRP     ||
2367                    avctx->pix_fmt == AV_PIX_FMT_GBRAP
2368                    );
2369         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2370         av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2371         for (p = 0; p < s->nb_components; p++) {
2372             uint8_t *dst;
2373             int w = s->width;
2374             int h = s->height;
2375             if (!s->upscale_v[p])
2376                 continue;
2377             if (p==1 || p==2) {
2378                 w = AV_CEIL_RSHIFT(w, hshift);
2379                 h = AV_CEIL_RSHIFT(h, vshift);
2380             }
2381             dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];
2382             for (i = h - 1; i; i--) {
2383                 uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i / 2 * s->linesize[p]];
2384                 uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) / 2 * s->linesize[p]];
2385                 if (src1 == src2 || i == h - 1) {
2386                     memcpy(dst, src1, w);
2387                 } else {
2388                     for (index = 0; index < w; index++)
2389                         dst[index] = (src1[index] + src2[index]) >> 1;
2390                 }
2391                 dst -= s->linesize[p];
2392             }
2393         }
2394     }
2395     if (s->flipped && !s->rgb) {
2396         int j;
2397         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2398         av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2399         for (index=0; index<s->nb_components; index++) {
2400             uint8_t *dst = s->picture_ptr->data[index];
2401             int w = s->picture_ptr->width;
2402             int h = s->picture_ptr->height;
2403             if(index && index<3){
2404                 w = AV_CEIL_RSHIFT(w, hshift);
2405                 h = AV_CEIL_RSHIFT(h, vshift);
2406             }
2407             if(dst){
2408                 uint8_t *dst2 = dst + s->picture_ptr->linesize[index]*(h-1);
2409                 for (i=0; i<h/2; i++) {
2410                     for (j=0; j<w; j++)
2411                         FFSWAP(int, dst[j], dst2[j]);
2412                     dst  += s->picture_ptr->linesize[index];
2413                     dst2 -= s->picture_ptr->linesize[index];
2414                 }
2415             }
2416         }
2417     }
2418     if (s->adobe_transform == 0 && s->avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
2419         int w = s->picture_ptr->width;
2420         int h = s->picture_ptr->height;
2421         av_assert0(s->nb_components == 4);
2422         for (i=0; i<h; i++) {
2423             int j;
2424             uint8_t *dst[4];
2425             for (index=0; index<4; index++) {
2426                 dst[index] =   s->picture_ptr->data[index]
2427                              + s->picture_ptr->linesize[index]*i;
2428             }
2429             for (j=0; j<w; j++) {
2430                 int k = dst[3][j];
2431                 int r = dst[0][j] * k;
2432                 int g = dst[1][j] * k;
2433                 int b = dst[2][j] * k;
2434                 dst[0][j] = g*257 >> 16;
2435                 dst[1][j] = b*257 >> 16;
2436                 dst[2][j] = r*257 >> 16;
2437                 dst[3][j] = 255;
2438             }
2439         }
2440     }
2441     if (s->adobe_transform == 2 && s->avctx->pix_fmt == AV_PIX_FMT_YUVA444P) {
2442         int w = s->picture_ptr->width;
2443         int h = s->picture_ptr->height;
2444         av_assert0(s->nb_components == 4);
2445         for (i=0; i<h; i++) {
2446             int j;
2447             uint8_t *dst[4];
2448             for (index=0; index<4; index++) {
2449                 dst[index] =   s->picture_ptr->data[index]
2450                              + s->picture_ptr->linesize[index]*i;
2451             }
2452             for (j=0; j<w; j++) {
2453                 int k = dst[3][j];
2454                 int r = (255 - dst[0][j]) * k;
2455                 int g = (128 - dst[1][j]) * k;
2456                 int b = (128 - dst[2][j]) * k;
2457                 dst[0][j] = r*257 >> 16;
2458                 dst[1][j] = (g*257 >> 16) + 128;
2459                 dst[2][j] = (b*257 >> 16) + 128;
2460                 dst[3][j] = 255;
2461             }
2462         }
2463     }
2464
2465     if (s->stereo3d) {
2466         AVStereo3D *stereo = av_stereo3d_create_side_data(data);
2467         if (stereo) {
2468             stereo->type  = s->stereo3d->type;
2469             stereo->flags = s->stereo3d->flags;
2470         }
2471         av_freep(&s->stereo3d);
2472     }
2473
2474     av_dict_copy(avpriv_frame_get_metadatap(data), s->exif_metadata, 0);
2475     av_dict_free(&s->exif_metadata);
2476
2477 the_end_no_picture:
2478     av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n",
2479            buf_end - buf_ptr);
2480 //  return buf_end - buf_ptr;
2481     return buf_ptr - buf;
2482 }
2483
2484 av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
2485 {
2486     MJpegDecodeContext *s = avctx->priv_data;
2487     int i, j;
2488
2489     if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_number) {
2490         av_log(avctx, AV_LOG_INFO, "Single field\n");
2491     }
2492
2493     if (s->picture) {
2494         av_frame_free(&s->picture);
2495         s->picture_ptr = NULL;
2496     } else if (s->picture_ptr)
2497         av_frame_unref(s->picture_ptr);
2498
2499     av_freep(&s->buffer);
2500     av_freep(&s->stereo3d);
2501     av_freep(&s->ljpeg_buffer);
2502     s->ljpeg_buffer_size = 0;
2503
2504     for (i = 0; i < 3; i++) {
2505         for (j = 0; j < 4; j++)
2506             ff_free_vlc(&s->vlcs[i][j]);
2507     }
2508     for (i = 0; i < MAX_COMPONENTS; i++) {
2509         av_freep(&s->blocks[i]);
2510         av_freep(&s->last_nnz[i]);
2511     }
2512     av_dict_free(&s->exif_metadata);
2513     return 0;
2514 }
2515
2516 static void decode_flush(AVCodecContext *avctx)
2517 {
2518     MJpegDecodeContext *s = avctx->priv_data;
2519     s->got_picture = 0;
2520 }
2521
2522 #if CONFIG_MJPEG_DECODER
2523 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
2524 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2525 static const AVOption options[] = {
2526     { "extern_huff", "Use external huffman table.",
2527       OFFSET(extern_huff), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
2528     { NULL },
2529 };
2530
2531 static const AVClass mjpegdec_class = {
2532     .class_name = "MJPEG decoder",
2533     .item_name  = av_default_item_name,
2534     .option     = options,
2535     .version    = LIBAVUTIL_VERSION_INT,
2536 };
2537
2538 AVCodec ff_mjpeg_decoder = {
2539     .name           = "mjpeg",
2540     .long_name      = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
2541     .type           = AVMEDIA_TYPE_VIDEO,
2542     .id             = AV_CODEC_ID_MJPEG,
2543     .priv_data_size = sizeof(MJpegDecodeContext),
2544     .init           = ff_mjpeg_decode_init,
2545     .close          = ff_mjpeg_decode_end,
2546     .decode         = ff_mjpeg_decode_frame,
2547     .flush          = decode_flush,
2548     .capabilities   = AV_CODEC_CAP_DR1,
2549     .max_lowres     = 3,
2550     .priv_class     = &mjpegdec_class,
2551     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
2552                       FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2553 };
2554 #endif
2555 #if CONFIG_THP_DECODER
2556 AVCodec ff_thp_decoder = {
2557     .name           = "thp",
2558     .long_name      = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
2559     .type           = AVMEDIA_TYPE_VIDEO,
2560     .id             = AV_CODEC_ID_THP,
2561     .priv_data_size = sizeof(MJpegDecodeContext),
2562     .init           = ff_mjpeg_decode_init,
2563     .close          = ff_mjpeg_decode_end,
2564     .decode         = ff_mjpeg_decode_frame,
2565     .flush          = decode_flush,
2566     .capabilities   = AV_CODEC_CAP_DR1,
2567     .max_lowres     = 3,
2568     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
2569 };
2570 #endif