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