git.sesse.net Git - ffmpeg/blob - libavcodec/mjpegdec.c

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