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