falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
67069 Commits
32 Branches
303MB
Tree: 059c842818
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '059c842818'
${ noResults }
FFmpeg/libavcodec/mjpegdec.c

2329 lines
81KB
Raw Blame History 

  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 "mjpeg.h"

  42. #include "mjpegdec.h"

  43. #include "jpeglsdec.h"

  44. #include "tiff.h"

  45. #include "exif.h"

  46. #include "bytestream.h"

  47. 

  48. 

  49. static int build_vlc(VLC *vlc, const uint8_t *bits_table,

  50.                      const uint8_t *val_table, int nb_codes,

  51.                      int use_static, int is_ac)

  52. {

  53.     uint8_t huff_size[256] = { 0 };

  54.     uint16_t huff_code[256];

  55.     uint16_t huff_sym[256];

  56.     int i;

  57. 

  58.     av_assert0(nb_codes <= 256);

  59. 

  60.     ff_mjpeg_build_huffman_codes(huff_size, huff_code, bits_table, val_table);

  61. 

  62.     for (i = 0; i < 256; i++)

  63.         huff_sym[i] = i + 16 * is_ac;

  64. 

  65.     if (is_ac)

  66.         huff_sym[0] = 16 * 256;

  67. 

  68.     return ff_init_vlc_sparse(vlc, 9, nb_codes, huff_size, 1, 1,

  69.                               huff_code, 2, 2, huff_sym, 2, 2, use_static);

  70. }

  71. 

  72. static void build_basic_mjpeg_vlc(MJpegDecodeContext *s)

  73. {

  74.     build_vlc(&s->vlcs[0][0], avpriv_mjpeg_bits_dc_luminance,

  75.               avpriv_mjpeg_val_dc, 12, 0, 0);

  76.     build_vlc(&s->vlcs[0][1], avpriv_mjpeg_bits_dc_chrominance,

  77.               avpriv_mjpeg_val_dc, 12, 0, 0);

  78.     build_vlc(&s->vlcs[1][0], avpriv_mjpeg_bits_ac_luminance,

  79.               avpriv_mjpeg_val_ac_luminance, 251, 0, 1);

  80.     build_vlc(&s->vlcs[1][1], avpriv_mjpeg_bits_ac_chrominance,

  81.               avpriv_mjpeg_val_ac_chrominance, 251, 0, 1);

  82.     build_vlc(&s->vlcs[2][0], avpriv_mjpeg_bits_ac_luminance,

  83.               avpriv_mjpeg_val_ac_luminance, 251, 0, 0);

  84.     build_vlc(&s->vlcs[2][1], avpriv_mjpeg_bits_ac_chrominance,

  85.               avpriv_mjpeg_val_ac_chrominance, 251, 0, 0);

  86. }

  87. 

  88. static void parse_avid(MJpegDecodeContext *s, uint8_t *buf, int len)

  89. {

  90.     s->buggy_avid = 1;

  91.     if (len > 14 && buf[12] == 1) /* 1 - NTSC */

  92.         s->interlace_polarity = 1;

  93.     if (len > 14 && buf[12] == 2) /* 2 - PAL */

  94.         s->interlace_polarity = 0;

  95.     if (s->avctx->debug & FF_DEBUG_PICT_INFO)

  96.         av_log(s->avctx, AV_LOG_INFO, "AVID: len:%d %d\n", len, len > 14 ? buf[12] : -1);

  97. }

  98. 

  99. av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)

  100. {

  101.     MJpegDecodeContext *s = avctx->priv_data;

  102. 

  103.     if (!s->picture_ptr) {

  104.         s->picture = av_frame_alloc();

  105.         if (!s->picture)

  106.             return AVERROR(ENOMEM);

  107.         s->picture_ptr = s->picture;

  108.     }

  109. 

  110.     s->avctx = avctx;

  111.     ff_blockdsp_init(&s->bdsp, avctx);

  112.     ff_hpeldsp_init(&s->hdsp, avctx->flags);

  113.     ff_idctdsp_init(&s->idsp, avctx);

  114.     ff_init_scantable(s->idsp.idct_permutation, &s->scantable,

  115.                       ff_zigzag_direct);

  116.     s->buffer_size   = 0;

  117.     s->buffer        = NULL;

  118.     s->start_code    = -1;

  119.     s->first_picture = 1;

  120.     s->got_picture   = 0;

  121.     s->org_height    = avctx->coded_height;

  122.     avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;

  123.     avctx->colorspace = AVCOL_SPC_BT470BG;

  124. 

  125.     build_basic_mjpeg_vlc(s);

  126. 

  127.     if (s->extern_huff) {

  128.         av_log(avctx, AV_LOG_INFO, "using external huffman table\n");

  129.         init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8);

  130.         if (ff_mjpeg_decode_dht(s)) {

  131.             av_log(avctx, AV_LOG_ERROR,

  132.                    "error using external huffman table, switching back to internal\n");

  133.             build_basic_mjpeg_vlc(s);

  134.         }

  135.     }

  136.     if (avctx->field_order == AV_FIELD_BB) { /* quicktime icefloe 019 */

  137.         s->interlace_polarity = 1;           /* bottom field first */

  138.         av_log(avctx, AV_LOG_DEBUG, "bottom field first\n");

  139.     } else if (avctx->field_order == AV_FIELD_UNKNOWN) {

  140.         if (avctx->codec_tag == AV_RL32("MJPG"))

  141.             s->interlace_polarity = 1;

  142.     }

  143. 

  144.     if (   avctx->extradata_size > 8

  145.         && AV_RL32(avctx->extradata) == 0x2C

  146.         && AV_RL32(avctx->extradata+4) == 0x18) {

  147.         parse_avid(s, avctx->extradata, avctx->extradata_size);

  148.     }

  149. 

  150.     if (avctx->codec->id == AV_CODEC_ID_AMV)

  151.         s->flipped = 1;

  152. 

  153.     return 0;

  154. }

  155. 

  156. 

  157. /* quantize tables */

  158. int ff_mjpeg_decode_dqt(MJpegDecodeContext *s)

  159. {

  160.     int len, index, i, j;

  161. 

  162.     len = get_bits(&s->gb, 16) - 2;

  163. 

  164.     while (len >= 65) {

  165.         int pr = get_bits(&s->gb, 4);

  166.         if (pr > 1) {

  167.             av_log(s->avctx, AV_LOG_ERROR, "dqt: invalid precision\n");

  168.             return AVERROR_INVALIDDATA;

  169.         }

  170.         index = get_bits(&s->gb, 4);

  171.         if (index >= 4)

  172.             return -1;

  173.         av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index);

  174.         /* read quant table */

  175.         for (i = 0; i < 64; i++) {

  176.             j = s->scantable.permutated[i];

  177.             s->quant_matrixes[index][j] = get_bits(&s->gb, pr ? 16 : 8);

  178.         }

  179. 

  180.         // XXX FIXME finetune, and perhaps add dc too

  181.         s->qscale[index] = FFMAX(s->quant_matrixes[index][s->scantable.permutated[1]],

  182.                                  s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;

  183.         av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n",

  184.                index, s->qscale[index]);

  185.         len -= 65;

  186.     }

  187.     return 0;

  188. }

  189. 

  190. /* decode huffman tables and build VLC decoders */

  191. int ff_mjpeg_decode_dht(MJpegDecodeContext *s)

  192. {

  193.     int len, index, i, class, n, v, code_max;

  194.     uint8_t bits_table[17];

  195.     uint8_t val_table[256];

  196.     int ret = 0;

  197. 

  198.     len = get_bits(&s->gb, 16) - 2;

  199. 

  200.     while (len > 0) {

  201.         if (len < 17)

  202.             return AVERROR_INVALIDDATA;

  203.         class = get_bits(&s->gb, 4);

  204.         if (class >= 2)

  205.             return AVERROR_INVALIDDATA;

  206.         index = get_bits(&s->gb, 4);

  207.         if (index >= 4)

  208.             return AVERROR_INVALIDDATA;

  209.         n = 0;

  210.         for (i = 1; i <= 16; i++) {

  211.             bits_table[i] = get_bits(&s->gb, 8);

  212.             n += bits_table[i];

  213.         }

  214.         len -= 17;

  215.         if (len < n || n > 256)

  216.             return AVERROR_INVALIDDATA;

  217. 

  218.         code_max = 0;

  219.         for (i = 0; i < n; i++) {

  220.             v = get_bits(&s->gb, 8);

  221.             if (v > code_max)

  222.                 code_max = v;

  223.             val_table[i] = v;

  224.         }

  225.         len -= n;

  226. 

  227.         /* build VLC and flush previous vlc if present */

  228.         ff_free_vlc(&s->vlcs[class][index]);

  229.         av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",

  230.                class, index, code_max + 1);

  231.         if ((ret = build_vlc(&s->vlcs[class][index], bits_table, val_table,

  232.                              code_max + 1, 0, class > 0)) < 0)

  233.             return ret;

  234. 

  235.         if (class > 0) {

  236.             ff_free_vlc(&s->vlcs[2][index]);

  237.             if ((ret = build_vlc(&s->vlcs[2][index], bits_table, val_table,

  238.                                  code_max + 1, 0, 0)) < 0)

  239.                 return ret;

  240.         }

  241.     }

  242.     return 0;

  243. }

  244. 

  245. int ff_mjpeg_decode_sof(MJpegDecodeContext *s)

  246. {

  247.     int len, nb_components, i, width, height, bits, pix_fmt_id, ret;

  248.     int h_count[MAX_COMPONENTS];

  249.     int v_count[MAX_COMPONENTS];

  250. 

  251.     s->cur_scan = 0;

  252.     s->upscale_h = s->upscale_v = 0;

  253. 

  254.     /* XXX: verify len field validity */

  255.     len     = get_bits(&s->gb, 16);

  256.     s->avctx->bits_per_raw_sample =

  257.     bits = get_bits(&s->gb, 8);

  258. 

  259.     if (bits > 16 || bits < 1) {

  260.         av_log(s->avctx, AV_LOG_ERROR, "bits %d is invalid\n", bits);

  261.         return AVERROR_INVALIDDATA;

  262.     }

  263. 

  264.     if (s->pegasus_rct)

  265.         bits = 9;

  266.     if (bits == 9 && !s->pegasus_rct)

  267.         s->rct  = 1;    // FIXME ugly

  268. 

  269.     if(s->lossless && s->avctx->lowres){

  270.         av_log(s->avctx, AV_LOG_ERROR, "lowres is not possible with lossless jpeg\n");

  271.         return -1;

  272.     }

  273. 

  274.     height = get_bits(&s->gb, 16);

  275.     width  = get_bits(&s->gb, 16);

  276. 

  277.     if (s->avctx->codec_id == AV_CODEC_ID_AMV && (height&15))

  278.         avpriv_request_sample(s->avctx, "non mod 16 height AMV\n");

  279. 

  280.     // HACK for odd_height.mov

  281.     if (s->interlaced && s->width == width && s->height == height + 1)

  282.         height= s->height;

  283. 

  284.     av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);

  285.     if (av_image_check_size(width, height, 0, s->avctx))

  286.         return AVERROR_INVALIDDATA;

  287. 

  288.     nb_components = get_bits(&s->gb, 8);

  289.     if (nb_components <= 0 ||

  290.         nb_components > MAX_COMPONENTS)

  291.         return -1;

  292.     if (s->interlaced && (s->bottom_field == !s->interlace_polarity)) {

  293.         if (nb_components != s->nb_components) {

  294.             av_log(s->avctx, AV_LOG_ERROR,

  295.                    "nb_components changing in interlaced picture\n");

  296.             return AVERROR_INVALIDDATA;

  297.         }

  298.     }

  299.     if (s->ls && !(bits <= 8 || nb_components == 1)) {

  300.         avpriv_report_missing_feature(s->avctx,

  301.                                       "JPEG-LS that is not <= 8 "

  302.                                       "bits/component or 16-bit gray");

  303.         return AVERROR_PATCHWELCOME;

  304.     }

  305.     s->nb_components = nb_components;

  306.     s->h_max         = 1;

  307.     s->v_max         = 1;

  308.     memset(h_count, 0, sizeof(h_count));

  309.     memset(v_count, 0, sizeof(v_count));

  310.     for (i = 0; i < nb_components; i++) {

  311.         /* component id */

  312.         s->component_id[i] = get_bits(&s->gb, 8) - 1;

  313.         h_count[i]         = get_bits(&s->gb, 4);

  314.         v_count[i]         = get_bits(&s->gb, 4);

  315.         /* compute hmax and vmax (only used in interleaved case) */

  316.         if (h_count[i] > s->h_max)

  317.             s->h_max = h_count[i];

  318.         if (v_count[i] > s->v_max)

  319.             s->v_max = v_count[i];

  320.         s->quant_index[i] = get_bits(&s->gb, 8);

  321.         if (s->quant_index[i] >= 4) {

  322.             av_log(s->avctx, AV_LOG_ERROR, "quant_index is invalid\n");

  323.             return AVERROR_INVALIDDATA;

  324.         }

  325.         if (!h_count[i] || !v_count[i]) {

  326.             av_log(s->avctx, AV_LOG_ERROR,

  327.                    "Invalid sampling factor in component %d %d:%d\n",

  328.                    i, h_count[i], v_count[i]);

  329.             return AVERROR_INVALIDDATA;

  330.         }

  331. 

  332.         av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n",

  333.                i, h_count[i], v_count[i],

  334.                s->component_id[i], s->quant_index[i]);

  335.     }

  336. 

  337.     if (s->ls && (s->h_max > 1 || s->v_max > 1)) {

  338.         avpriv_report_missing_feature(s->avctx, "Subsampling in JPEG-LS");

  339.         return AVERROR_PATCHWELCOME;

  340.     }

  341. 

  342. 

  343.     /* if different size, realloc/alloc picture */

  344.     if (   width != s->width || height != s->height

  345.         || bits != s->bits

  346.         || memcmp(s->h_count, h_count, sizeof(h_count))

  347.         || memcmp(s->v_count, v_count, sizeof(v_count))) {

  348. 

  349.         s->width      = width;

  350.         s->height     = height;

  351.         s->bits       = bits;

  352.         memcpy(s->h_count, h_count, sizeof(h_count));

  353.         memcpy(s->v_count, v_count, sizeof(v_count));

  354.         s->interlaced = 0;

  355.         s->got_picture = 0;

  356. 

  357.         /* test interlaced mode */

  358.         if (s->first_picture   &&

  359.             s->org_height != 0 &&

  360.             s->height < ((s->org_height * 3) / 4)) {

  361.             s->interlaced                    = 1;

  362.             s->bottom_field                  = s->interlace_polarity;

  363.             s->picture_ptr->interlaced_frame = 1;

  364.             s->picture_ptr->top_field_first  = !s->interlace_polarity;

  365.             height *= 2;

  366.         }

  367. 

  368.         ret = ff_set_dimensions(s->avctx, width, height);

  369.         if (ret < 0)

  370.             return ret;

  371. 

  372.         s->first_picture = 0;

  373.     }

  374. 

  375.     if (s->got_picture && s->interlaced && (s->bottom_field == !s->interlace_polarity)) {

  376.         if (s->progressive) {

  377.             avpriv_request_sample(s->avctx, "progressively coded interlaced picture");

  378.             return AVERROR_INVALIDDATA;

  379.         }

  380.     } else{

  381.         if (s->v_max == 1 && s->h_max == 1 && s->lossless==1 && (nb_components==3 || nb_components==4))

  382.             s->rgb = 1;

  383.         else if (!s->lossless)

  384.             s->rgb = 0;

  385.     /* XXX: not complete test ! */

  386.     pix_fmt_id = (s->h_count[0] << 28) | (s->v_count[0] << 24) |

  387.                  (s->h_count[1] << 20) | (s->v_count[1] << 16) |

  388.                  (s->h_count[2] << 12) | (s->v_count[2] <<  8) |

  389.                  (s->h_count[3] <<  4) |  s->v_count[3];

  390.     av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);

  391.     /* NOTE we do not allocate pictures large enough for the possible

  392.      * padding of h/v_count being 4 */

  393.     if (!(pix_fmt_id & 0xD0D0D0D0))

  394.         pix_fmt_id -= (pix_fmt_id & 0xF0F0F0F0) >> 1;

  395.     if (!(pix_fmt_id & 0x0D0D0D0D))

  396.         pix_fmt_id -= (pix_fmt_id & 0x0F0F0F0F) >> 1;

  397. 

  398.     for (i = 0; i < 8; i++) {

  399.         int j = 6 + (i&1) - (i&6);

  400.         int is = (pix_fmt_id >> (4*i)) & 0xF;

  401.         int js = (pix_fmt_id >> (4*j)) & 0xF;

  402. 

  403.         if (is == 1 && js != 2 && (i < 2 || i > 5))

  404.             js = (pix_fmt_id >> ( 8 + 4*(i&1))) & 0xF;

  405.         if (is == 1 && js != 2 && (i < 2 || i > 5))

  406.             js = (pix_fmt_id >> (16 + 4*(i&1))) & 0xF;

  407. 

  408.         if (is == 1 && js == 2) {

  409.             if (i & 1) s->upscale_h |= 1 << (j/2);

  410.             else       s->upscale_v |= 1 << (j/2);

  411.         }

  412.     }

  413. 

  414.     switch (pix_fmt_id) {

  415.     case 0x11111100:

  416.         if (s->rgb)

  417.             s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_BGR48;

  418.         else {

  419.             if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {

  420.                 s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_GBRP : AV_PIX_FMT_GBRP16;

  421.             } else {

  422.                 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;

  423.                 else              s->avctx->pix_fmt = AV_PIX_FMT_YUV444P16;

  424.             s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;

  425.             }

  426.         }

  427.         av_assert0(s->nb_components == 3);

  428.         break;

  429.     case 0x11111111:

  430.         if (s->rgb)

  431.             s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_ABGR : AV_PIX_FMT_RGBA64;

  432.         else {

  433.             if (s->adobe_transform == 0 && s->bits <= 8) {

  434.                 s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;

  435.             } else {

  436.                 s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_YUVA444P : AV_PIX_FMT_YUVA444P16;

  437.                 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;

  438.             }

  439.         }

  440.         av_assert0(s->nb_components == 4);

  441.         break;

  442.     case 0x22111122:

  443.         if (s->adobe_transform == 0 && s->bits <= 8) {

  444.             s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;

  445.             s->upscale_v = 6;

  446.             s->upscale_h = 6;

  447.             s->chroma_height = s->height;

  448.         } else if (s->adobe_transform == 2 && s->bits <= 8) {

  449.             s->avctx->pix_fmt = AV_PIX_FMT_YUVA444P;

  450.             s->upscale_v = 6;

  451.             s->upscale_h = 6;

  452.             s->chroma_height = s->height;

  453.             s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;

  454.         } else {

  455.             if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;

  456.             else              s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P16;

  457.             s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;

  458.         }

  459.         av_assert0(s->nb_components == 4);

  460.         break;

  461.     case 0x12121100:

  462.     case 0x22122100:

  463.     case 0x21211100:

  464.     case 0x22211200:

  465.         if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;

  466.         else

  467.             goto unk_pixfmt;

  468.         s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;

  469.         s->chroma_height = s->height;

  470.         break;

  471.     case 0x22221100:

  472.     case 0x22112200:

  473.     case 0x11222200:

  474.         if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;

  475.         else

  476.             goto unk_pixfmt;

  477.         s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;

  478.         s->chroma_height = (s->height + 1) / 2;

  479.         break;

  480.     case 0x11000000:

  481.     case 0x13000000:

  482.     case 0x14000000:

  483.     case 0x31000000:

  484.     case 0x33000000:

  485.     case 0x34000000:

  486.     case 0x41000000:

  487.     case 0x43000000:

  488.     case 0x44000000:

  489.         if(s->bits <= 8)

  490.             s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;

  491.         else

  492.             s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;

  493.         break;

  494.     case 0x12111100:

  495.     case 0x14121200:

  496.     case 0x22211100:

  497.     case 0x22112100:

  498.         if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV440P : AV_PIX_FMT_YUVJ440P;

  499.         else

  500.             goto unk_pixfmt;

  501.         s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;

  502.         s->chroma_height = (s->height + 1) / 2;

  503.         break;

  504.     case 0x21111100:

  505.         if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;

  506.         else              s->avctx->pix_fmt = AV_PIX_FMT_YUV422P16;

  507.         s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;

  508.         break;

  509.     case 0x22121100:

  510.     case 0x22111200:

  511.         if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;

  512.         else

  513.             goto unk_pixfmt;

  514.         s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;

  515.         break;

  516.     case 0x22111100:

  517.     case 0x42111100:

  518.     case 0x24111100:

  519.         if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUVJ420P;

  520.         else              s->avctx->pix_fmt = AV_PIX_FMT_YUV420P16;

  521.         s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;

  522.         if (pix_fmt_id == 0x42111100) {

  523.             s->upscale_h = 6;

  524.             s->chroma_height = (s->height + 1) / 2;

  525.         } else if (pix_fmt_id == 0x24111100) {

  526.             s->upscale_v = 6;

  527.         }

  528.         break;

  529.     case 0x41111100:

  530.         if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV411P : AV_PIX_FMT_YUVJ411P;

  531.         else

  532.             goto unk_pixfmt;

  533.         s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;

  534.         break;

  535.     default:

  536. unk_pixfmt:

  537.         av_log(s->avctx, AV_LOG_ERROR, "Unhandled pixel format 0x%x\n", pix_fmt_id);

  538.         s->upscale_h = s->upscale_v = 0;

  539.         return AVERROR_PATCHWELCOME;

  540.     }

  541.     if ((s->upscale_h || s->upscale_v) && s->avctx->lowres) {

  542.         av_log(s->avctx, AV_LOG_ERROR, "lowres not supported for weird subsampling\n");

  543.         return AVERROR_PATCHWELCOME;

  544.     }

  545.     if (s->ls) {

  546.         s->upscale_h = s->upscale_v = 0;

  547.         if (s->nb_components > 1)

  548.             s->avctx->pix_fmt = AV_PIX_FMT_RGB24;

  549.         else if (s->palette_index && s->bits <= 8)

  550.             s->avctx->pix_fmt = AV_PIX_FMT_PAL8;

  551.         else if (s->bits <= 8)

  552.             s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;

  553.         else

  554.             s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;

  555.     }

  556. 

  557.     s->pix_desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);

  558.     if (!s->pix_desc) {

  559.         av_log(s->avctx, AV_LOG_ERROR, "Could not get a pixel format descriptor.\n");

  560.         return AVERROR_BUG;

  561.     }

  562. 

  563.     av_frame_unref(s->picture_ptr);

  564.     if (ff_get_buffer(s->avctx, s->picture_ptr, AV_GET_BUFFER_FLAG_REF) < 0)

  565.         return -1;

  566.     s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;

  567.     s->picture_ptr->key_frame = 1;

  568.     s->got_picture            = 1;

  569. 

  570.     for (i = 0; i < 4; i++)

  571.         s->linesize[i] = s->picture_ptr->linesize[i] << s->interlaced;

  572. 

  573.     av_dlog(s->avctx, "%d %d %d %d %d %d\n",

  574.             s->width, s->height, s->linesize[0], s->linesize[1],

  575.             s->interlaced, s->avctx->height);

  576. 

  577.     if (len != (8 + (3 * nb_components)))

  578.         av_log(s->avctx, AV_LOG_DEBUG, "decode_sof0: error, len(%d) mismatch\n", len);

  579.     }

  580. 

  581.     if (s->rgb && !s->lossless && !s->ls) {

  582.         av_log(s->avctx, AV_LOG_ERROR, "Unsupported coding and pixel format combination\n");

  583.         return AVERROR_PATCHWELCOME;

  584.     }

  585. 

  586.     /* totally blank picture as progressive JPEG will only add details to it */

  587.     if (s->progressive) {

  588.         int bw = (width  + s->h_max * 8 - 1) / (s->h_max * 8);

  589.         int bh = (height + s->v_max * 8 - 1) / (s->v_max * 8);

  590.         for (i = 0; i < s->nb_components; i++) {

  591.             int size = bw * bh * s->h_count[i] * s->v_count[i];

  592.             av_freep(&s->blocks[i]);

  593.             av_freep(&s->last_nnz[i]);

  594.             s->blocks[i]       = av_mallocz_array(size, sizeof(**s->blocks));

  595.             s->last_nnz[i]     = av_mallocz_array(size, sizeof(**s->last_nnz));

  596.             if (!s->blocks[i] || !s->last_nnz[i])

  597.                 return AVERROR(ENOMEM);

  598.             s->block_stride[i] = bw * s->h_count[i];

  599.         }

  600.         memset(s->coefs_finished, 0, sizeof(s->coefs_finished));

  601.     }

  602.     return 0;

  603. }

  604. 

  605. static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)

  606. {

  607.     int code;

  608.     code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);

  609.     if (code < 0 || code > 16) {

  610.         av_log(s->avctx, AV_LOG_WARNING,

  611.                "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",

  612.                0, dc_index, &s->vlcs[0][dc_index]);

  613.         return 0xfffff;

  614.     }

  615. 

  616.     if (code)

  617.         return get_xbits(&s->gb, code);

  618.     else

  619.         return 0;

  620. }

  621. 

  622. /* decode block and dequantize */

  623. static int decode_block(MJpegDecodeContext *s, int16_t *block, int component,

  624.                         int dc_index, int ac_index, int16_t *quant_matrix)

  625. {

  626.     int code, i, j, level, val;

  627. 

  628.     /* DC coef */

  629.     val = mjpeg_decode_dc(s, dc_index);

  630.     if (val == 0xfffff) {

  631.         av_log(s->avctx, AV_LOG_ERROR, "error dc\n");

  632.         return AVERROR_INVALIDDATA;

  633.     }

  634.     val = val * quant_matrix[0] + s->last_dc[component];

  635.     s->last_dc[component] = val;

  636.     block[0] = val;

  637.     /* AC coefs */

  638.     i = 0;

  639.     {OPEN_READER(re, &s->gb);

  640.     do {

  641.         UPDATE_CACHE(re, &s->gb);

  642.         GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2);

  643. 

  644.         i += ((unsigned)code) >> 4;

  645.             code &= 0xf;

  646.         if (code) {

  647.             if (code > MIN_CACHE_BITS - 16)

  648.                 UPDATE_CACHE(re, &s->gb);

  649. 

  650.             {

  651.                 int cache = GET_CACHE(re, &s->gb);

  652.                 int sign  = (~cache) >> 31;

  653.                 level     = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;

  654.             }

  655. 

  656.             LAST_SKIP_BITS(re, &s->gb, code);

  657. 

  658.             if (i > 63) {

  659.                 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);

  660.                 return AVERROR_INVALIDDATA;

  661.             }

  662.             j        = s->scantable.permutated[i];

  663.             block[j] = level * quant_matrix[j];

  664.         }

  665.     } while (i < 63);

  666.     CLOSE_READER(re, &s->gb);}

  667. 

  668.     return 0;

  669. }

  670. 

  671. static int decode_dc_progressive(MJpegDecodeContext *s, int16_t *block,

  672.                                  int component, int dc_index,

  673.                                  int16_t *quant_matrix, int Al)

  674. {

  675.     int val;

  676.     s->bdsp.clear_block(block);

  677.     val = mjpeg_decode_dc(s, dc_index);

  678.     if (val == 0xfffff) {

  679.         av_log(s->avctx, AV_LOG_ERROR, "error dc\n");

  680.         return AVERROR_INVALIDDATA;

  681.     }

  682.     val = (val * quant_matrix[0] << Al) + s->last_dc[component];

  683.     s->last_dc[component] = val;

  684.     block[0] = val;

  685.     return 0;

  686. }

  687. 

  688. /* decode block and dequantize - progressive JPEG version */

  689. static int decode_block_progressive(MJpegDecodeContext *s, int16_t *block,

  690.                                     uint8_t *last_nnz, int ac_index,

  691.                                     int16_t *quant_matrix,

  692.                                     int ss, int se, int Al, int *EOBRUN)

  693. {

  694.     int code, i, j, level, val, run;

  695. 

  696.     if (*EOBRUN) {

  697.         (*EOBRUN)--;

  698.         return 0;

  699.     }

  700. 

  701.     {

  702.         OPEN_READER(re, &s->gb);

  703.         for (i = ss; ; i++) {

  704.             UPDATE_CACHE(re, &s->gb);

  705.             GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);

  706. 

  707.             run = ((unsigned) code) >> 4;

  708.             code &= 0xF;

  709.             if (code) {

  710.                 i += run;

  711.                 if (code > MIN_CACHE_BITS - 16)

  712.                     UPDATE_CACHE(re, &s->gb);

  713. 

  714.                 {

  715.                     int cache = GET_CACHE(re, &s->gb);

  716.                     int sign  = (~cache) >> 31;

  717.                     level     = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;

  718.                 }

  719. 

  720.                 LAST_SKIP_BITS(re, &s->gb, code);

  721. 

  722.                 if (i >= se) {

  723.                     if (i == se) {

  724.                         j = s->scantable.permutated[se];

  725.                         block[j] = level * quant_matrix[j] << Al;

  726.                         break;

  727.                     }

  728.                     av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);

  729.                     return AVERROR_INVALIDDATA;

  730.                 }

  731.                 j = s->scantable.permutated[i];

  732.                 block[j] = level * quant_matrix[j] << Al;

  733.             } else {

  734.                 if (run == 0xF) {// ZRL - skip 15 coefficients

  735.                     i += 15;

  736.                     if (i >= se) {

  737.                         av_log(s->avctx, AV_LOG_ERROR, "ZRL overflow: %d\n", i);

  738.                         return AVERROR_INVALIDDATA;

  739.                     }

  740.                 } else {

  741.                     val = (1 << run);

  742.                     if (run) {

  743.                         UPDATE_CACHE(re, &s->gb);

  744.                         val += NEG_USR32(GET_CACHE(re, &s->gb), run);

  745.                         LAST_SKIP_BITS(re, &s->gb, run);

  746.                     }

  747.                     *EOBRUN = val - 1;

  748.                     break;

  749.                 }

  750.             }

  751.         }

  752.         CLOSE_READER(re, &s->gb);

  753.     }

  754. 

  755.     if (i > *last_nnz)

  756.         *last_nnz = i;

  757. 

  758.     return 0;

  759. }

  760. 

  761. #define REFINE_BIT(j) {                                             \

  762.     UPDATE_CACHE(re, &s->gb);                                       \

  763.     sign = block[j] >> 15;                                          \

  764.     block[j] += SHOW_UBITS(re, &s->gb, 1) *                         \

  765.                 ((quant_matrix[j] ^ sign) - sign) << Al;            \

  766.     LAST_SKIP_BITS(re, &s->gb, 1);                                  \

  767. }

  768. 

  769. #define ZERO_RUN                                                    \

  770. for (; ; i++) {                                                     \

  771.     if (i > last) {                                                 \

  772.         i += run;                                                   \

  773.         if (i > se) {                                               \

  774.             av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \

  775.             return -1;                                              \

  776.         }                                                           \

  777.         break;                                                      \

  778.     }                                                               \

  779.     j = s->scantable.permutated[i];                                 \

  780.     if (block[j])                                                   \

  781.         REFINE_BIT(j)                                               \

  782.     else if (run-- == 0)                                            \

  783.         break;                                                      \

  784. }

  785. 

  786. /* decode block and dequantize - progressive JPEG refinement pass */

  787. static int decode_block_refinement(MJpegDecodeContext *s, int16_t *block,

  788.                                    uint8_t *last_nnz,

  789.                                    int ac_index, int16_t *quant_matrix,

  790.                                    int ss, int se, int Al, int *EOBRUN)

  791. {

  792.     int code, i = ss, j, sign, val, run;

  793.     int last    = FFMIN(se, *last_nnz);

  794. 

  795.     OPEN_READER(re, &s->gb);

  796.     if (*EOBRUN) {

  797.         (*EOBRUN)--;

  798.     } else {

  799.         for (; ; i++) {

  800.             UPDATE_CACHE(re, &s->gb);

  801.             GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);

  802. 

  803.             if (code & 0xF) {

  804.                 run = ((unsigned) code) >> 4;

  805.                 UPDATE_CACHE(re, &s->gb);

  806.                 val = SHOW_UBITS(re, &s->gb, 1);

  807.                 LAST_SKIP_BITS(re, &s->gb, 1);

  808.                 ZERO_RUN;

  809.                 j = s->scantable.permutated[i];

  810.                 val--;

  811.                 block[j] = ((quant_matrix[j]^val) - val) << Al;

  812.                 if (i == se) {

  813.                     if (i > *last_nnz)

  814.                         *last_nnz = i;

  815.                     CLOSE_READER(re, &s->gb);

  816.                     return 0;

  817.                 }

  818.             } else {

  819.                 run = ((unsigned) code) >> 4;

  820.                 if (run == 0xF) {

  821.                     ZERO_RUN;

  822.                 } else {

  823.                     val = run;

  824.                     run = (1 << run);

  825.                     if (val) {

  826.                         UPDATE_CACHE(re, &s->gb);

  827.                         run += SHOW_UBITS(re, &s->gb, val);

  828.                         LAST_SKIP_BITS(re, &s->gb, val);

  829.                     }

  830.                     *EOBRUN = run - 1;

  831.                     break;

  832.                 }

  833.             }

  834.         }

  835. 

  836.         if (i > *last_nnz)

  837.             *last_nnz = i;

  838.     }

  839. 

  840.     for (; i <= last; i++) {

  841.         j = s->scantable.permutated[i];

  842.         if (block[j])

  843.             REFINE_BIT(j)

  844.     }

  845.     CLOSE_READER(re, &s->gb);

  846. 

  847.     return 0;

  848. }

  849. #undef REFINE_BIT

  850. #undef ZERO_RUN

  851. 

  852. static int handle_rstn(MJpegDecodeContext *s, int nb_components)

  853. {

  854.     int i;

  855.     int reset = 0;

  856. 

  857.     if (s->restart_interval) {

  858.         s->restart_count--;

  859.         if(s->restart_count == 0 && s->avctx->codec_id == AV_CODEC_ID_THP){

  860.             align_get_bits(&s->gb);

  861.             for (i = 0; i < nb_components; i++) /* reset dc */

  862.                 s->last_dc[i] = (4 << s->bits);

  863.         }

  864. 

  865.         i = 8 + ((-get_bits_count(&s->gb)) & 7);

  866.         /* skip RSTn */

  867.         if (s->restart_count == 0) {

  868.             if(   show_bits(&s->gb, i) == (1 << i) - 1

  869.                || show_bits(&s->gb, i) == 0xFF) {

  870.                 int pos = get_bits_count(&s->gb);

  871.                 align_get_bits(&s->gb);

  872.                 while (get_bits_left(&s->gb) >= 8 && show_bits(&s->gb, 8) == 0xFF)

  873.                     skip_bits(&s->gb, 8);

  874.                 if (get_bits_left(&s->gb) >= 8 && (get_bits(&s->gb, 8) & 0xF8) == 0xD0) {

  875.                     for (i = 0; i < nb_components; i++) /* reset dc */

  876.                         s->last_dc[i] = (4 << s->bits);

  877.                     reset = 1;

  878.                 } else

  879.                     skip_bits_long(&s->gb, pos - get_bits_count(&s->gb));

  880.             }

  881.         }

  882.     }

  883.     return reset;

  884. }

  885. 

  886. static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int nb_components, int predictor, int point_transform)

  887. {

  888.     int i, mb_x, mb_y;

  889.     uint16_t (*buffer)[4];

  890.     int left[4], top[4], topleft[4];

  891.     const int linesize = s->linesize[0];

  892.     const int mask     = ((1 << s->bits) - 1) << point_transform;

  893.     int resync_mb_y = 0;

  894.     int resync_mb_x = 0;

  895. 

  896.     if (s->nb_components != 3 && s->nb_components != 4)

  897.         return AVERROR_INVALIDDATA;

  898.     if (s->v_max != 1 || s->h_max != 1 || !s->lossless)

  899.         return AVERROR_INVALIDDATA;

  900. 

  901. 

  902.     s->restart_count = s->restart_interval;

  903. 

  904.     av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size,

  905.                    (unsigned)s->mb_width * 4 * sizeof(s->ljpeg_buffer[0][0]));

  906.     buffer = s->ljpeg_buffer;

  907. 

  908.     for (i = 0; i < 4; i++)

  909.         buffer[0][i] = 1 << (s->bits - 1);

  910. 

  911.     for (mb_y = 0; mb_y < s->mb_height; mb_y++) {

  912.         uint8_t *ptr = s->picture_ptr->data[0] + (linesize * mb_y);

  913. 

  914.         if (s->interlaced && s->bottom_field)

  915.             ptr += linesize >> 1;

  916. 

  917.         for (i = 0; i < 4; i++)

  918.             top[i] = left[i] = topleft[i] = buffer[0][i];

  919. 

  920.         for (mb_x = 0; mb_x < s->mb_width; mb_x++) {

  921.             int modified_predictor = predictor;

  922. 

  923.             if (s->restart_interval && !s->restart_count){

  924.                 s->restart_count = s->restart_interval;

  925.                 resync_mb_x = mb_x;

  926.                 resync_mb_y = mb_y;

  927.                 for(i=0; i<4; i++)

  928.                     top[i] = left[i]= topleft[i]= 1 << (s->bits - 1);

  929.             }

  930.             if (mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || !mb_x)

  931.                 modified_predictor = 1;

  932. 

  933.             for (i=0;i<nb_components;i++) {

  934.                 int pred, dc;

  935. 

  936.                 topleft[i] = top[i];

  937.                 top[i]     = buffer[mb_x][i];

  938. 

  939.                 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);

  940. 

  941.                 dc = mjpeg_decode_dc(s, s->dc_index[i]);

  942.                 if(dc == 0xFFFFF)

  943.                     return -1;

  944. 

  945.                 left[i] = buffer[mb_x][i] =

  946.                     mask & (pred + (dc << point_transform));

  947.             }

  948. 

  949.             if (s->restart_interval && !--s->restart_count) {

  950.                 align_get_bits(&s->gb);

  951.                 skip_bits(&s->gb, 16); /* skip RSTn */

  952.             }

  953.         }

  954.         if (s->nb_components == 4) {

  955.             for(i=0; i<nb_components; i++) {

  956.                 int c= s->comp_index[i];

  957.                 if (s->bits <= 8) {

  958.                     for(mb_x = 0; mb_x < s->mb_width; mb_x++) {

  959.                         ptr[4*mb_x+3-c] = buffer[mb_x][i];

  960.                     }

  961.                 } else if(s->bits == 9) {

  962.                     return AVERROR_PATCHWELCOME;

  963.                 } else {

  964.                     for(mb_x = 0; mb_x < s->mb_width; mb_x++) {

  965.                         ((uint16_t*)ptr)[4*mb_x+c] = buffer[mb_x][i];

  966.                     }

  967.                 }

  968.             }

  969.         } else if (s->rct) {

  970.             for (mb_x = 0; mb_x < s->mb_width; mb_x++) {

  971.                 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);

  972.                 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];

  973.                 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];

  974.             }

  975.         } else if (s->pegasus_rct) {

  976.             for (mb_x = 0; mb_x < s->mb_width; mb_x++) {

  977.                 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2]) >> 2);

  978.                 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];

  979.                 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];

  980.             }

  981.         } else {

  982.             for(i=0; i<nb_components; i++) {

  983.                 int c= s->comp_index[i];

  984.                 if (s->bits <= 8) {

  985.                     for(mb_x = 0; mb_x < s->mb_width; mb_x++) {

  986.                         ptr[3*mb_x+2-c] = buffer[mb_x][i];

  987.                     }

  988.                 } else if(s->bits == 9) {

  989.                     return AVERROR_PATCHWELCOME;

  990.                 } else {

  991.                     for(mb_x = 0; mb_x < s->mb_width; mb_x++) {

  992.                         ((uint16_t*)ptr)[3*mb_x+2-c] = buffer[mb_x][i];

  993.                     }

  994.                 }

  995.             }

  996.         }

  997.     }

  998.     return 0;

  999. }

  1000. 

  1001. static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,

  1002.                                  int point_transform, int nb_components)

  1003. {

  1004.     int i, mb_x, mb_y, mask;

  1005.     int bits= (s->bits+7)&~7;

  1006.     int resync_mb_y = 0;

  1007.     int resync_mb_x = 0;

  1008. 

  1009.     point_transform += bits - s->bits;

  1010.     mask = ((1 << s->bits) - 1) << point_transform;

  1011. 

  1012.     av_assert0(nb_components>=1 && nb_components<=4);

  1013. 

  1014.     for (mb_y = 0; mb_y < s->mb_height; mb_y++) {

  1015.         for (mb_x = 0; mb_x < s->mb_width; mb_x++) {

  1016.             if (s->restart_interval && !s->restart_count){

  1017.                 s->restart_count = s->restart_interval;

  1018.                 resync_mb_x = mb_x;

  1019.                 resync_mb_y = mb_y;

  1020.             }

  1021. 

  1022.             if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->interlaced){

  1023.                 int toprow  = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x;

  1024.                 int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x;

  1025.                 for (i = 0; i < nb_components; i++) {

  1026.                     uint8_t *ptr;

  1027.                     uint16_t *ptr16;

  1028.                     int n, h, v, x, y, c, j, linesize;

  1029.                     n = s->nb_blocks[i];

  1030.                     c = s->comp_index[i];

  1031.                     h = s->h_scount[i];

  1032.                     v = s->v_scount[i];

  1033.                     x = 0;

  1034.                     y = 0;

  1035.                     linesize= s->linesize[c];

  1036. 

  1037.                     if(bits>8) linesize /= 2;

  1038. 

  1039.                     for(j=0; j<n; j++) {

  1040.                         int pred, dc;

  1041. 

  1042.                         dc = mjpeg_decode_dc(s, s->dc_index[i]);

  1043.                         if(dc == 0xFFFFF)

  1044.                             return -1;

  1045.                         if(bits<=8){

  1046.                         ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap

  1047.                         if(y==0 && toprow){

  1048.                             if(x==0 && leftcol){

  1049.                                 pred= 1 << (bits - 1);

  1050.                             }else{

  1051.                                 pred= ptr[-1];

  1052.                             }

  1053.                         }else{

  1054.                             if(x==0 && leftcol){

  1055.                                 pred= ptr[-linesize];

  1056.                             }else{

  1057.                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);

  1058.                             }

  1059.                         }

  1060. 

  1061.                         if (s->interlaced && s->bottom_field)

  1062.                             ptr += linesize >> 1;

  1063.                         pred &= mask;

  1064.                         *ptr= pred + (dc << point_transform);

  1065.                         }else{

  1066.                             ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap

  1067.                             if(y==0 && toprow){

  1068.                                 if(x==0 && leftcol){

  1069.                                     pred= 1 << (bits - 1);

  1070.                                 }else{

  1071.                                     pred= ptr16[-1];

  1072.                                 }

  1073.                             }else{

  1074.                                 if(x==0 && leftcol){

  1075.                                     pred= ptr16[-linesize];

  1076.                                 }else{

  1077.                                     PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);

  1078.                                 }

  1079.                             }

  1080. 

  1081.                             if (s->interlaced && s->bottom_field)

  1082.                                 ptr16 += linesize >> 1;

  1083.                             pred &= mask;

  1084.                             *ptr16= pred + (dc << point_transform);

  1085.                         }

  1086.                         if (++x == h) {

  1087.                             x = 0;

  1088.                             y++;

  1089.                         }

  1090.                     }

  1091.                 }

  1092.             } else {

  1093.                 for (i = 0; i < nb_components; i++) {

  1094.                     uint8_t *ptr;

  1095.                     uint16_t *ptr16;

  1096.                     int n, h, v, x, y, c, j, linesize, dc;

  1097.                     n        = s->nb_blocks[i];

  1098.                     c        = s->comp_index[i];

  1099.                     h        = s->h_scount[i];

  1100.                     v        = s->v_scount[i];

  1101.                     x        = 0;

  1102.                     y        = 0;

  1103.                     linesize = s->linesize[c];

  1104. 

  1105.                     if(bits>8) linesize /= 2;

  1106. 

  1107.                     for (j = 0; j < n; j++) {

  1108.                         int pred;

  1109. 

  1110.                         dc = mjpeg_decode_dc(s, s->dc_index[i]);

  1111.                         if(dc == 0xFFFFF)

  1112.                             return -1;

  1113.                         if(bits<=8){

  1114.                             ptr = s->picture_ptr->data[c] +

  1115.                               (linesize * (v * mb_y + y)) +

  1116.                               (h * mb_x + x); //FIXME optimize this crap

  1117.                             PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);

  1118. 

  1119.                             pred &= mask;

  1120.                             *ptr = pred + (dc << point_transform);

  1121.                         }else{

  1122.                             ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap

  1123.                             PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);

  1124. 

  1125.                             pred &= mask;

  1126.                             *ptr16= pred + (dc << point_transform);

  1127.                         }

  1128. 

  1129.                         if (++x == h) {

  1130.                             x = 0;

  1131.                             y++;

  1132.                         }

  1133.                     }

  1134.                 }

  1135.             }

  1136.             if (s->restart_interval && !--s->restart_count) {

  1137.                 align_get_bits(&s->gb);

  1138.                 skip_bits(&s->gb, 16); /* skip RSTn */

  1139.             }

  1140.         }

  1141.     }

  1142.     return 0;

  1143. }

  1144. 

  1145. static av_always_inline void mjpeg_copy_block(MJpegDecodeContext *s,

  1146.                                               uint8_t *dst, const uint8_t *src,

  1147.                                               int linesize, int lowres)

  1148. {

  1149.     switch (lowres) {

  1150.     case 0: s->hdsp.put_pixels_tab[1][0](dst, src, linesize, 8);

  1151.         break;

  1152.     case 1: copy_block4(dst, src, linesize, linesize, 4);

  1153.         break;

  1154.     case 2: copy_block2(dst, src, linesize, linesize, 2);

  1155.         break;

  1156.     case 3: *dst = *src;

  1157.         break;

  1158.     }

  1159. }

  1160. 

  1161. static void shift_output(MJpegDecodeContext *s, uint8_t *ptr, int linesize)

  1162. {

  1163.     int block_x, block_y;

  1164.     int size = 8 >> s->avctx->lowres;

  1165.     if (s->bits > 8) {

  1166.         for (block_y=0; block_y<size; block_y++)

  1167.             for (block_x=0; block_x<size; block_x++)

  1168.                 *(uint16_t*)(ptr + 2*block_x + block_y*linesize) <<= 16 - s->bits;

  1169.     } else {

  1170.         for (block_y=0; block_y<size; block_y++)

  1171.             for (block_x=0; block_x<size; block_x++)

  1172.                 *(ptr + block_x + block_y*linesize) <<= 8 - s->bits;

  1173.     }

  1174. }

  1175. 

  1176. static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,

  1177.                              int Al, const uint8_t *mb_bitmask,

  1178.                              int mb_bitmask_size,

  1179.                              const AVFrame *reference)

  1180. {

  1181.     int i, mb_x, mb_y;

  1182.     uint8_t *data[MAX_COMPONENTS];

  1183.     const uint8_t *reference_data[MAX_COMPONENTS];

  1184.     int linesize[MAX_COMPONENTS];

  1185.     GetBitContext mb_bitmask_gb = {0}; // initialize to silence gcc warning

  1186.     int bytes_per_pixel = 1 + (s->bits > 8);

  1187. 

  1188.     if (mb_bitmask) {

  1189.         if (mb_bitmask_size != (s->mb_width * s->mb_height + 7)>>3) {

  1190.             av_log(s->avctx, AV_LOG_ERROR, "mb_bitmask_size mismatches\n");

  1191.             return AVERROR_INVALIDDATA;

  1192.         }

  1193.         init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);

  1194.     }

  1195. 

  1196.     s->restart_count = 0;

  1197. 

  1198.     for (i = 0; i < nb_components; i++) {

  1199.         int c   = s->comp_index[i];

  1200.         data[c] = s->picture_ptr->data[c];

  1201.         reference_data[c] = reference ? reference->data[c] : NULL;

  1202.         linesize[c] = s->linesize[c];

  1203.         s->coefs_finished[c] |= 1;

  1204.     }

  1205. 

  1206.     for (mb_y = 0; mb_y < s->mb_height; mb_y++) {

  1207.         for (mb_x = 0; mb_x < s->mb_width; mb_x++) {

  1208.             const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);

  1209. 

  1210.             if (s->restart_interval && !s->restart_count)

  1211.                 s->restart_count = s->restart_interval;

  1212. 

  1213.             if (get_bits_left(&s->gb) < 0) {

  1214.                 av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",

  1215.                        -get_bits_left(&s->gb));

  1216.                 return AVERROR_INVALIDDATA;

  1217.             }

  1218.             for (i = 0; i < nb_components; i++) {

  1219.                 uint8_t *ptr;

  1220.                 int n, h, v, x, y, c, j;

  1221.                 int block_offset;

  1222.                 n = s->nb_blocks[i];

  1223.                 c = s->comp_index[i];

  1224.                 h = s->h_scount[i];

  1225.                 v = s->v_scount[i];

  1226.                 x = 0;

  1227.                 y = 0;

  1228.                 for (j = 0; j < n; j++) {

  1229.                     block_offset = (((linesize[c] * (v * mb_y + y) * 8) +

  1230.                                      (h * mb_x + x) * 8 * bytes_per_pixel) >> s->avctx->lowres);

  1231. 

  1232.                     if (s->interlaced && s->bottom_field)

  1233.                         block_offset += linesize[c] >> 1;

  1234.                     ptr = data[c] + block_offset;

  1235.                     if (!s->progressive) {

  1236.                         if (copy_mb)

  1237.                             mjpeg_copy_block(s, ptr, reference_data[c] + block_offset,

  1238.                                              linesize[c], s->avctx->lowres);

  1239. 

  1240.                         else {

  1241.                             s->bdsp.clear_block(s->block);

  1242.                             if (decode_block(s, s->block, i,

  1243.                                              s->dc_index[i], s->ac_index[i],

  1244.                                              s->quant_matrixes[s->quant_sindex[i]]) < 0) {

  1245.                                 av_log(s->avctx, AV_LOG_ERROR,

  1246.                                        "error y=%d x=%d\n", mb_y, mb_x);

  1247.                                 return AVERROR_INVALIDDATA;

  1248.                             }

  1249.                             s->idsp.idct_put(ptr, linesize[c], s->block);

  1250.                             if (s->bits & 7)

  1251.                                 shift_output(s, ptr, linesize[c]);

  1252.                         }

  1253.                     } else {

  1254.                         int block_idx  = s->block_stride[c] * (v * mb_y + y) +

  1255.                                          (h * mb_x + x);

  1256.                         int16_t *block = s->blocks[c][block_idx];

  1257.                         if (Ah)

  1258.                             block[0] += get_bits1(&s->gb) *

  1259.                                         s->quant_matrixes[s->quant_sindex[i]][0] << Al;

  1260.                         else if (decode_dc_progressive(s, block, i, s->dc_index[i],

  1261.                                                        s->quant_matrixes[s->quant_sindex[i]],

  1262.                                                        Al) < 0) {

  1263.                             av_log(s->avctx, AV_LOG_ERROR,

  1264.                                    "error y=%d x=%d\n", mb_y, mb_x);

  1265.                             return AVERROR_INVALIDDATA;

  1266.                         }

  1267.                     }

  1268.                     av_dlog(s->avctx, "mb: %d %d processed\n", mb_y, mb_x);

  1269.                     av_dlog(s->avctx, "%d %d %d %d %d %d %d %d \n",

  1270.                             mb_x, mb_y, x, y, c, s->bottom_field,

  1271.                             (v * mb_y + y) * 8, (h * mb_x + x) * 8);

  1272.                     if (++x == h) {

  1273.                         x = 0;

  1274.                         y++;

  1275.                     }

  1276.                 }

  1277.             }

  1278. 

  1279.             handle_rstn(s, nb_components);

  1280.         }

  1281.     }

  1282.     return 0;

  1283. }

  1284. 

  1285. static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss,

  1286.                                             int se, int Ah, int Al)

  1287. {

  1288.     int mb_x, mb_y;

  1289.     int EOBRUN = 0;

  1290.     int c = s->comp_index[0];

  1291.     uint8_t *data = s->picture_ptr->data[c];

  1292.     int linesize  = s->linesize[c];

  1293.     int last_scan = 0;

  1294.     int16_t *quant_matrix = s->quant_matrixes[s->quant_sindex[0]];

  1295.     int bytes_per_pixel = 1 + (s->bits > 8);

  1296. 

  1297.     av_assert0(ss>=0 && Ah>=0 && Al>=0);

  1298.     if (se < ss || se > 63) {

  1299.         av_log(s->avctx, AV_LOG_ERROR, "SS/SE %d/%d is invalid\n", ss, se);

  1300.         return AVERROR_INVALIDDATA;

  1301.     }

  1302. 

  1303.     if (!Al) {

  1304.         s->coefs_finished[c] |= (2ULL << se) - (1ULL << ss);

  1305.         last_scan = !~s->coefs_finished[c];

  1306.     }

  1307. 

  1308.     if (s->interlaced && s->bottom_field)

  1309.         data += linesize >> 1;

  1310. 

  1311.     s->restart_count = 0;

  1312. 

  1313.     for (mb_y = 0; mb_y < s->mb_height; mb_y++) {

  1314.         uint8_t *ptr     = data + (mb_y * linesize * 8 >> s->avctx->lowres);

  1315.         int block_idx    = mb_y * s->block_stride[c];

  1316.         int16_t (*block)[64] = &s->blocks[c][block_idx];

  1317.         uint8_t *last_nnz    = &s->last_nnz[c][block_idx];

  1318.         for (mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) {

  1319.                 int ret;

  1320.                 if (s->restart_interval && !s->restart_count)

  1321.                     s->restart_count = s->restart_interval;

  1322. 

  1323.                 if (Ah)

  1324.                     ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0],

  1325.                                                   quant_matrix, ss, se, Al, &EOBRUN);

  1326.                 else

  1327.                     ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0],

  1328.                                                    quant_matrix, ss, se, Al, &EOBRUN);

  1329.                 if (ret < 0) {

  1330.                     av_log(s->avctx, AV_LOG_ERROR,

  1331.                            "error y=%d x=%d\n", mb_y, mb_x);

  1332.                     return AVERROR_INVALIDDATA;

  1333.                 }

  1334. 

  1335.             if (last_scan) {

  1336.                     s->idsp.idct_put(ptr, linesize, *block);

  1337.                     if (s->bits & 7)

  1338.                         shift_output(s, ptr, linesize);

  1339.                     ptr += bytes_per_pixel*8 >> s->avctx->lowres;

  1340.             }

  1341.             if (handle_rstn(s, 0))

  1342.                 EOBRUN = 0;

  1343.         }

  1344.     }

  1345.     return 0;

  1346. }

  1347. 

  1348. int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,

  1349.                         int mb_bitmask_size, const AVFrame *reference)

  1350. {

  1351.     int len, nb_components, i, h, v, predictor, point_transform;

  1352.     int index, id, ret;

  1353.     const int block_size = s->lossless ? 1 : 8;

  1354.     int ilv, prev_shift;

  1355. 

  1356.     if (!s->got_picture) {

  1357.         av_log(s->avctx, AV_LOG_WARNING,

  1358.                 "Can not process SOS before SOF, skipping\n");

  1359.         return -1;

  1360.     }

  1361. 

  1362.     av_assert0(s->picture_ptr->data[0]);

  1363.     /* XXX: verify len field validity */

  1364.     len = get_bits(&s->gb, 16);

  1365.     nb_components = get_bits(&s->gb, 8);

  1366.     if (nb_components == 0 || nb_components > MAX_COMPONENTS) {

  1367.         av_log(s->avctx, AV_LOG_ERROR,

  1368.                "decode_sos: nb_components (%d) unsupported\n", nb_components);

  1369.         return AVERROR_PATCHWELCOME;

  1370.     }

  1371.     if (len != 6 + 2 * nb_components) {

  1372.         av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);

  1373.         return AVERROR_INVALIDDATA;

  1374.     }

  1375.     for (i = 0; i < nb_components; i++) {

  1376.         id = get_bits(&s->gb, 8) - 1;

  1377.         av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);

  1378.         /* find component index */

  1379.         for (index = 0; index < s->nb_components; index++)

  1380.             if (id == s->component_id[index])

  1381.                 break;

  1382.         if (index == s->nb_components) {

  1383.             av_log(s->avctx, AV_LOG_ERROR,

  1384.                    "decode_sos: index(%d) out of components\n", index);

  1385.             return AVERROR_INVALIDDATA;

  1386.         }

  1387.         /* Metasoft MJPEG codec has Cb and Cr swapped */

  1388.         if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')

  1389.             && nb_components == 3 && s->nb_components == 3 && i)

  1390.             index = 3 - i;

  1391. 

  1392.         s->quant_sindex[i] = s->quant_index[index];

  1393.         s->nb_blocks[i] = s->h_count[index] * s->v_count[index];

  1394.         s->h_scount[i]  = s->h_count[index];

  1395.         s->v_scount[i]  = s->v_count[index];

  1396. 

  1397.         if(nb_components == 3 && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)

  1398.             index = (i+2)%3;

  1399.         if(nb_components == 1 && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)

  1400.             index = (index+2)%3;

  1401. 

  1402.         s->comp_index[i] = index;

  1403. 

  1404.         s->dc_index[i] = get_bits(&s->gb, 4);

  1405.         s->ac_index[i] = get_bits(&s->gb, 4);

  1406. 

  1407.         if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||

  1408.             s->dc_index[i] >= 4 || s->ac_index[i] >= 4)

  1409.             goto out_of_range;

  1410.         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))

  1411.             goto out_of_range;

  1412.     }

  1413. 

  1414.     predictor = get_bits(&s->gb, 8);       /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */

  1415.     ilv = get_bits(&s->gb, 8);             /* JPEG Se / JPEG-LS ILV */

  1416.     if(s->avctx->codec_tag != AV_RL32("CJPG")){

  1417.         prev_shift      = get_bits(&s->gb, 4); /* Ah */

  1418.         point_transform = get_bits(&s->gb, 4); /* Al */

  1419.     }else

  1420.         prev_shift = point_transform = 0;

  1421. 

  1422.     if (nb_components > 1) {

  1423.         /* interleaved stream */

  1424.         s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);

  1425.         s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);

  1426.     } else if (!s->ls) { /* skip this for JPEG-LS */

  1427.         h = s->h_max / s->h_scount[0];

  1428.         v = s->v_max / s->v_scount[0];

  1429.         s->mb_width     = (s->width  + h * block_size - 1) / (h * block_size);

  1430.         s->mb_height    = (s->height + v * block_size - 1) / (v * block_size);

  1431.         s->nb_blocks[0] = 1;

  1432.         s->h_scount[0]  = 1;

  1433.         s->v_scount[0]  = 1;

  1434.     }

  1435. 

  1436.     if (s->avctx->debug & FF_DEBUG_PICT_INFO)

  1437.         av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n",

  1438.                s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",

  1439.                predictor, point_transform, ilv, s->bits, s->mjpb_skiptosod,

  1440.                s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), nb_components);

  1441. 

  1442. 

  1443.     /* mjpeg-b can have padding bytes between sos and image data, skip them */

  1444.     for (i = s->mjpb_skiptosod; i > 0; i--)

  1445.         skip_bits(&s->gb, 8);

  1446. 

  1447. next_field:

  1448.     for (i = 0; i < nb_components; i++)

  1449.         s->last_dc[i] = (4 << s->bits);

  1450. 

  1451.     if (s->lossless) {

  1452.         av_assert0(s->picture_ptr == s->picture);

  1453.         if (CONFIG_JPEGLS_DECODER && s->ls) {

  1454. //            for () {

  1455. //            reset_ls_coding_parameters(s, 0);

  1456. 

  1457.             if ((ret = ff_jpegls_decode_picture(s, predictor,

  1458.                                                 point_transform, ilv)) < 0)

  1459.                 return ret;

  1460.         } else {

  1461.             if (s->rgb) {

  1462.                 if ((ret = ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform)) < 0)

  1463.                     return ret;

  1464.             } else {

  1465.                 if ((ret = ljpeg_decode_yuv_scan(s, predictor,

  1466.                                                  point_transform,

  1467.                                                  nb_components)) < 0)

  1468.                     return ret;

  1469.             }

  1470.         }

  1471.     } else {

  1472.         if (s->progressive && predictor) {

  1473.             av_assert0(s->picture_ptr == s->picture);

  1474.             if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor,

  1475.                                                         ilv, prev_shift,

  1476.                                                         point_transform)) < 0)

  1477.                 return ret;

  1478.         } else {

  1479.             if ((ret = mjpeg_decode_scan(s, nb_components,

  1480.                                          prev_shift, point_transform,

  1481.                                          mb_bitmask, mb_bitmask_size, reference)) < 0)

  1482.                 return ret;

  1483.         }

  1484.     }

  1485. 

  1486.     if (s->interlaced &&

  1487.         get_bits_left(&s->gb) > 32 &&

  1488.         show_bits(&s->gb, 8) == 0xFF) {

  1489.         GetBitContext bak = s->gb;

  1490.         align_get_bits(&bak);

  1491.         if (show_bits(&bak, 16) == 0xFFD1) {

  1492.             av_log(s->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n");

  1493.             s->gb = bak;

  1494.             skip_bits(&s->gb, 16);

  1495.             s->bottom_field ^= 1;

  1496. 

  1497.             goto next_field;

  1498.         }

  1499.     }

  1500. 

  1501.     emms_c();

  1502.     return 0;

  1503.  out_of_range:

  1504.     av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");

  1505.     return AVERROR_INVALIDDATA;

  1506. }

  1507. 

  1508. static int mjpeg_decode_dri(MJpegDecodeContext *s)

  1509. {

  1510.     if (get_bits(&s->gb, 16) != 4)

  1511.         return AVERROR_INVALIDDATA;

  1512.     s->restart_interval = get_bits(&s->gb, 16);

  1513.     s->restart_count    = 0;

  1514.     av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",

  1515.            s->restart_interval);

  1516. 

  1517.     return 0;

  1518. }

  1519. 

  1520. static int mjpeg_decode_app(MJpegDecodeContext *s)

  1521. {

  1522.     int len, id, i;

  1523. 

  1524.     len = get_bits(&s->gb, 16);

  1525.     if (len < 6)

  1526.         return AVERROR_INVALIDDATA;

  1527.     if (8 * len > get_bits_left(&s->gb))

  1528.         return AVERROR_INVALIDDATA;

  1529. 

  1530.     id   = get_bits_long(&s->gb, 32);

  1531.     len -= 6;

  1532. 

  1533.     if (s->avctx->debug & FF_DEBUG_STARTCODE) {

  1534.         char id_str[32];

  1535.         av_get_codec_tag_string(id_str, sizeof(id_str), av_bswap32(id));

  1536.         av_log(s->avctx, AV_LOG_DEBUG, "APPx (%s / %8X) len=%d\n", id_str, id, len);

  1537.     }

  1538. 

  1539.     /* Buggy AVID, it puts EOI only at every 10th frame. */

  1540.     /* Also, this fourcc is used by non-avid files too, it holds some

  1541.        information, but it's always present in AVID-created files. */

  1542.     if (id == AV_RB32("AVI1")) {

  1543.         /* structure:

  1544.             4bytes      AVI1

  1545.             1bytes      polarity

  1546.             1bytes      always zero

  1547.             4bytes      field_size

  1548.             4bytes      field_size_less_padding

  1549.         */

  1550.             s->buggy_avid = 1;

  1551.         i = get_bits(&s->gb, 8); len--;

  1552.         av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i);

  1553. #if 0

  1554.         skip_bits(&s->gb, 8);

  1555.         skip_bits(&s->gb, 32);

  1556.         skip_bits(&s->gb, 32);

  1557.         len -= 10;

  1558. #endif

  1559.         goto out;

  1560.     }

  1561. 

  1562. //    len -= 2;

  1563. 

  1564.     if (id == AV_RB32("JFIF")) {

  1565.         int t_w, t_h, v1, v2;

  1566.         skip_bits(&s->gb, 8); /* the trailing zero-byte */

  1567.         v1 = get_bits(&s->gb, 8);

  1568.         v2 = get_bits(&s->gb, 8);

  1569.         skip_bits(&s->gb, 8);

  1570. 

  1571.         s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 16);

  1572.         s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16);

  1573.         ff_set_sar(s->avctx, s->avctx->sample_aspect_ratio);

  1574. 

  1575.         if (s->avctx->debug & FF_DEBUG_PICT_INFO)

  1576.             av_log(s->avctx, AV_LOG_INFO,

  1577.                    "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",

  1578.                    v1, v2,

  1579.                    s->avctx->sample_aspect_ratio.num,

  1580.                    s->avctx->sample_aspect_ratio.den);

  1581. 

  1582.         t_w = get_bits(&s->gb, 8);

  1583.         t_h = get_bits(&s->gb, 8);

  1584.         if (t_w && t_h) {

  1585.             /* skip thumbnail */

  1586.             if (len -10 - (t_w * t_h * 3) > 0)

  1587.                 len -= t_w * t_h * 3;

  1588.         }

  1589.         len -= 10;

  1590.         goto out;

  1591.     }

  1592. 

  1593.     if (id == AV_RB32("Adob") && (get_bits(&s->gb, 8) == 'e')) {

  1594.         skip_bits(&s->gb, 16); /* version */

  1595.         skip_bits(&s->gb, 16); /* flags0 */

  1596.         skip_bits(&s->gb, 16); /* flags1 */

  1597.         s->adobe_transform = get_bits(&s->gb,  8);

  1598.         if (s->avctx->debug & FF_DEBUG_PICT_INFO)

  1599.             av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found, transform=%d\n", s->adobe_transform);

  1600.         len -= 7;

  1601.         goto out;

  1602.     }

  1603. 

  1604.     if (id == AV_RB32("LJIF")) {

  1605.         if (s->avctx->debug & FF_DEBUG_PICT_INFO)

  1606.             av_log(s->avctx, AV_LOG_INFO,

  1607.                    "Pegasus lossless jpeg header found\n");

  1608.         skip_bits(&s->gb, 16); /* version ? */

  1609.         skip_bits(&s->gb, 16); /* unknown always 0? */

  1610.         skip_bits(&s->gb, 16); /* unknown always 0? */

  1611.         skip_bits(&s->gb, 16); /* unknown always 0? */

  1612.         switch (i=get_bits(&s->gb, 8)) {

  1613.         case 1:

  1614.             s->rgb         = 1;

  1615.             s->pegasus_rct = 0;

  1616.             break;

  1617.         case 2:

  1618.             s->rgb         = 1;

  1619.             s->pegasus_rct = 1;

  1620.             break;

  1621.         default:

  1622.             av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace %d\n", i);

  1623.         }

  1624.         len -= 9;

  1625.         goto out;

  1626.     }

  1627.     if (id == AV_RL32("colr") && len > 0) {

  1628.         s->colr = get_bits(&s->gb, 8);

  1629.         if (s->avctx->debug & FF_DEBUG_PICT_INFO)

  1630.             av_log(s->avctx, AV_LOG_INFO, "COLR %d\n", s->colr);

  1631.         len --;

  1632.         goto out;

  1633.     }

  1634.     if (id == AV_RL32("xfrm") && len > 0) {

  1635.         s->xfrm = get_bits(&s->gb, 8);

  1636.         if (s->avctx->debug & FF_DEBUG_PICT_INFO)

  1637.             av_log(s->avctx, AV_LOG_INFO, "XFRM %d\n", s->xfrm);

  1638.         len --;

  1639.         goto out;

  1640.     }

  1641. 

  1642.     /* JPS extension by VRex */

  1643.     if (s->start_code == APP3 && id == AV_RB32("_JPS") && len >= 10) {

  1644.         int flags, layout, type;

  1645.         if (s->avctx->debug & FF_DEBUG_PICT_INFO)

  1646.             av_log(s->avctx, AV_LOG_INFO, "_JPSJPS_\n");

  1647. 

  1648.         skip_bits(&s->gb, 32); len -= 4;  /* JPS_ */

  1649.         skip_bits(&s->gb, 16); len -= 2;  /* block length */

  1650.         skip_bits(&s->gb, 8);             /* reserved */

  1651.         flags  = get_bits(&s->gb, 8);

  1652.         layout = get_bits(&s->gb, 8);

  1653.         type   = get_bits(&s->gb, 8);

  1654.         len -= 4;

  1655. 

  1656.         s->stereo3d = av_stereo3d_alloc();

  1657.         if (!s->stereo3d) {

  1658.             goto out;

  1659.         }

  1660.         if (type == 0) {

  1661.             s->stereo3d->type = AV_STEREO3D_2D;

  1662.         } else if (type == 1) {

  1663.             switch (layout) {

  1664.             case 0x01:

  1665.                 s->stereo3d->type = AV_STEREO3D_LINES;

  1666.                 break;

  1667.             case 0x02:

  1668.                 s->stereo3d->type = AV_STEREO3D_SIDEBYSIDE;

  1669.                 break;

  1670.             case 0x03:

  1671.                 s->stereo3d->type = AV_STEREO3D_TOPBOTTOM;

  1672.                 break;

  1673.             }

  1674.             if (!(flags & 0x04)) {

  1675.                 s->stereo3d->flags = AV_STEREO3D_FLAG_INVERT;

  1676.             }

  1677.         }

  1678.         goto out;

  1679.     }

  1680. 

  1681.     /* EXIF metadata */

  1682.     if (s->start_code == APP1 && id == AV_RB32("Exif") && len >= 2) {

  1683.         GetByteContext gbytes;

  1684.         int ret, le, ifd_offset, bytes_read;

  1685.         const uint8_t *aligned;

  1686. 

  1687.         skip_bits(&s->gb, 16); // skip padding

  1688.         len -= 2;

  1689. 

  1690.         // init byte wise reading

  1691.         aligned = align_get_bits(&s->gb);

  1692.         bytestream2_init(&gbytes, aligned, len);

  1693. 

  1694.         // read TIFF header

  1695.         ret = ff_tdecode_header(&gbytes, &le, &ifd_offset);

  1696.         if (ret) {

  1697.             av_log(s->avctx, AV_LOG_ERROR, "mjpeg: invalid TIFF header in EXIF data\n");

  1698.         } else {

  1699.             bytestream2_seek(&gbytes, ifd_offset, SEEK_SET);

  1700. 

  1701.             // read 0th IFD and store the metadata

  1702.             // (return values > 0 indicate the presence of subimage metadata)

  1703.             ret = avpriv_exif_decode_ifd(s->avctx, &gbytes, le, 0, &s->exif_metadata);

  1704.             if (ret < 0) {

  1705.                 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error decoding EXIF data\n");

  1706.             }

  1707.         }

  1708. 

  1709.         bytes_read = bytestream2_tell(&gbytes);

  1710.         skip_bits(&s->gb, bytes_read << 3);

  1711.         len -= bytes_read;

  1712. 

  1713.         goto out;

  1714.     }

  1715. 

  1716.     /* Apple MJPEG-A */

  1717.     if ((s->start_code == APP1) && (len > (0x28 - 8))) {

  1718.         id   = get_bits_long(&s->gb, 32);

  1719.         len -= 4;

  1720.         /* Apple MJPEG-A */

  1721.         if (id == AV_RB32("mjpg")) {

  1722. #if 0

  1723.             skip_bits(&s->gb, 32); /* field size */

  1724.             skip_bits(&s->gb, 32); /* pad field size */

  1725.             skip_bits(&s->gb, 32); /* next off */

  1726.             skip_bits(&s->gb, 32); /* quant off */

  1727.             skip_bits(&s->gb, 32); /* huff off */

  1728.             skip_bits(&s->gb, 32); /* image off */

  1729.             skip_bits(&s->gb, 32); /* scan off */

  1730.             skip_bits(&s->gb, 32); /* data off */

  1731. #endif

  1732.             if (s->avctx->debug & FF_DEBUG_PICT_INFO)

  1733.                 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");

  1734.         }

  1735.     }

  1736. 

  1737. out:

  1738.     /* slow but needed for extreme adobe jpegs */

  1739.     if (len < 0)

  1740.         av_log(s->avctx, AV_LOG_ERROR,

  1741.                "mjpeg: error, decode_app parser read over the end\n");

  1742.     while (--len > 0)

  1743.         skip_bits(&s->gb, 8);

  1744. 

  1745.     return 0;

  1746. }

  1747. 

  1748. static int mjpeg_decode_com(MJpegDecodeContext *s)

  1749. {

  1750.     int len = get_bits(&s->gb, 16);

  1751.     if (len >= 2 && 8 * len - 16 <= get_bits_left(&s->gb)) {

  1752.         char *cbuf = av_malloc(len - 1);

  1753.         if (cbuf) {

  1754.             int i;

  1755.             for (i = 0; i < len - 2; i++)

  1756.                 cbuf[i] = get_bits(&s->gb, 8);

  1757.             if (i > 0 && cbuf[i - 1] == '\n')

  1758.                 cbuf[i - 1] = 0;

  1759.             else

  1760.                 cbuf[i] = 0;

  1761. 

  1762.             if (s->avctx->debug & FF_DEBUG_PICT_INFO)

  1763.                 av_log(s->avctx, AV_LOG_INFO, "comment: '%s'\n", cbuf);

  1764. 

  1765.             /* buggy avid, it puts EOI only at every 10th frame */

  1766.             if (!strncmp(cbuf, "AVID", 4)) {

  1767.                 parse_avid(s, cbuf, len);

  1768.             } else if (!strcmp(cbuf, "CS=ITU601"))

  1769.                 s->cs_itu601 = 1;

  1770.             else if ((!strncmp(cbuf, "Intel(R) JPEG Library, version 1", 32) && s->avctx->codec_tag) ||

  1771.                      (!strncmp(cbuf, "Metasoft MJPEG Codec", 20)))

  1772.                 s->flipped = 1;

  1773. 

  1774.             av_free(cbuf);

  1775.         }

  1776.     }

  1777. 

  1778.     return 0;

  1779. }

  1780. 

  1781. /* return the 8 bit start code value and update the search

  1782.    state. Return -1 if no start code found */

  1783. static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)

  1784. {

  1785.     const uint8_t *buf_ptr;

  1786.     unsigned int v, v2;

  1787.     int val;

  1788.     int skipped = 0;

  1789. 

  1790.     buf_ptr = *pbuf_ptr;

  1791.     while (buf_end - buf_ptr > 1) {

  1792.         v  = *buf_ptr++;

  1793.         v2 = *buf_ptr;

  1794.         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {

  1795.             val = *buf_ptr++;

  1796.             goto found;

  1797.         }

  1798.         skipped++;

  1799.     }

  1800.     buf_ptr = buf_end;

  1801.     val = -1;

  1802. found:

  1803.     av_dlog(NULL, "find_marker skipped %d bytes\n", skipped);

  1804.     *pbuf_ptr = buf_ptr;

  1805.     return val;

  1806. }

  1807. 

  1808. int ff_mjpeg_find_marker(MJpegDecodeContext *s,

  1809.                          const uint8_t **buf_ptr, const uint8_t *buf_end,

  1810.                          const uint8_t **unescaped_buf_ptr,

  1811.                          int *unescaped_buf_size)

  1812. {

  1813.     int start_code;

  1814.     start_code = find_marker(buf_ptr, buf_end);

  1815. 

  1816.     av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr);

  1817.     if (!s->buffer)

  1818.         return AVERROR(ENOMEM);

  1819. 

  1820.     /* unescape buffer of SOS, use special treatment for JPEG-LS */

  1821.     if (start_code == SOS && !s->ls) {

  1822.         const uint8_t *src = *buf_ptr;

  1823.         uint8_t *dst = s->buffer;

  1824. 

  1825.         while (src < buf_end) {

  1826.             uint8_t x = *(src++);

  1827. 

  1828.             *(dst++) = x;

  1829.             if (s->avctx->codec_id != AV_CODEC_ID_THP) {

  1830.                 if (x == 0xff) {

  1831.                     while (src < buf_end && x == 0xff)

  1832.                         x = *(src++);

  1833. 

  1834.                     if (x >= 0xd0 && x <= 0xd7)

  1835.                         *(dst++) = x;

  1836.                     else if (x)

  1837.                         break;

  1838.                 }

  1839.             }

  1840.         }

  1841.         *unescaped_buf_ptr  = s->buffer;

  1842.         *unescaped_buf_size = dst - s->buffer;

  1843.         memset(s->buffer + *unescaped_buf_size, 0,

  1844.                FF_INPUT_BUFFER_PADDING_SIZE);

  1845. 

  1846.         av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %"PTRDIFF_SPECIFIER" bytes\n",

  1847.                (buf_end - *buf_ptr) - (dst - s->buffer));

  1848.     } else if (start_code == SOS && s->ls) {

  1849.         const uint8_t *src = *buf_ptr;

  1850.         uint8_t *dst  = s->buffer;

  1851.         int bit_count = 0;

  1852.         int t = 0, b = 0;

  1853.         PutBitContext pb;

  1854. 

  1855.         /* find marker */

  1856.         while (src + t < buf_end) {

  1857.             uint8_t x = src[t++];

  1858.             if (x == 0xff) {

  1859.                 while ((src + t < buf_end) && x == 0xff)

  1860.                     x = src[t++];

  1861.                 if (x & 0x80) {

  1862.                     t -= FFMIN(2, t);

  1863.                     break;

  1864.                 }

  1865.             }

  1866.         }

  1867.         bit_count = t * 8;

  1868.         init_put_bits(&pb, dst, t);

  1869. 

  1870.         /* unescape bitstream */

  1871.         while (b < t) {

  1872.             uint8_t x = src[b++];

  1873.             put_bits(&pb, 8, x);

  1874.             if (x == 0xFF) {

  1875.                 x = src[b++];

  1876.                 put_bits(&pb, 7, x);

  1877.                 bit_count--;

  1878.             }

  1879.         }

  1880.         flush_put_bits(&pb);

  1881. 

  1882.         *unescaped_buf_ptr  = dst;

  1883.         *unescaped_buf_size = (bit_count + 7) >> 3;

  1884.         memset(s->buffer + *unescaped_buf_size, 0,

  1885.                FF_INPUT_BUFFER_PADDING_SIZE);

  1886.     } else {

  1887.         *unescaped_buf_ptr  = *buf_ptr;

  1888.         *unescaped_buf_size = buf_end - *buf_ptr;

  1889.     }

  1890. 

  1891.     return start_code;

  1892. }

  1893. 

  1894. int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,

  1895.                           AVPacket *avpkt)

  1896. {

  1897.     AVFrame     *frame = data;

  1898.     const uint8_t *buf = avpkt->data;

  1899.     int buf_size       = avpkt->size;

  1900.     MJpegDecodeContext *s = avctx->priv_data;

  1901.     const uint8_t *buf_end, *buf_ptr;

  1902.     const uint8_t *unescaped_buf_ptr;

  1903.     int hshift, vshift;

  1904.     int unescaped_buf_size;

  1905.     int start_code;

  1906.     int i, index;

  1907.     int ret = 0;

  1908.     int is16bit;

  1909. 

  1910.     av_dict_free(&s->exif_metadata);

  1911.     av_freep(&s->stereo3d);

  1912.     s->adobe_transform = -1;

  1913. 

  1914.     buf_ptr = buf;

  1915.     buf_end = buf + buf_size;

  1916.     while (buf_ptr < buf_end) {

  1917.         /* find start next marker */

  1918.         start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,

  1919.                                           &unescaped_buf_ptr,

  1920.                                           &unescaped_buf_size);

  1921.         /* EOF */

  1922.         if (start_code < 0) {

  1923.             break;

  1924.         } else if (unescaped_buf_size > INT_MAX / 8) {

  1925.             av_log(avctx, AV_LOG_ERROR,

  1926.                    "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",

  1927.                    start_code, unescaped_buf_size, buf_size);

  1928.             return AVERROR_INVALIDDATA;

  1929.         }

  1930.         av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%"PTRDIFF_SPECIFIER"\n",

  1931.                start_code, buf_end - buf_ptr);

  1932. 

  1933.         ret = init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);

  1934. 

  1935.         if (ret < 0) {

  1936.             av_log(avctx, AV_LOG_ERROR, "invalid buffer\n");

  1937.             goto fail;

  1938.         }

  1939. 

  1940.         s->start_code = start_code;

  1941.         if (s->avctx->debug & FF_DEBUG_STARTCODE)

  1942.             av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);

  1943. 

  1944.         /* process markers */

  1945.         if (start_code >= 0xd0 && start_code <= 0xd7)

  1946.             av_log(avctx, AV_LOG_DEBUG,

  1947.                    "restart marker: %d\n", start_code & 0x0f);

  1948.             /* APP fields */

  1949.         else if (start_code >= APP0 && start_code <= APP15)

  1950.             mjpeg_decode_app(s);

  1951.             /* Comment */

  1952.         else if (start_code == COM)

  1953.             mjpeg_decode_com(s);

  1954. 

  1955.         ret = -1;

  1956. 

  1957.         if (!CONFIG_JPEGLS_DECODER &&

  1958.             (start_code == SOF48 || start_code == LSE)) {

  1959.             av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");

  1960.             return AVERROR(ENOSYS);

  1961.         }

  1962. 

  1963.         switch (start_code) {

  1964.         case SOI:

  1965.             s->restart_interval = 0;

  1966.             s->restart_count    = 0;

  1967.             /* nothing to do on SOI */

  1968.             break;

  1969.         case DQT:

  1970.             ff_mjpeg_decode_dqt(s);

  1971.             break;

  1972.         case DHT:

  1973.             if ((ret = ff_mjpeg_decode_dht(s)) < 0) {

  1974.                 av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");

  1975.                 goto fail;

  1976.             }

  1977.             break;

  1978.         case SOF0:

  1979.         case SOF1:

  1980.             s->lossless    = 0;

  1981.             s->ls          = 0;

  1982.             s->progressive = 0;

  1983.             if ((ret = ff_mjpeg_decode_sof(s)) < 0)

  1984.                 goto fail;

  1985.             break;

  1986.         case SOF2:

  1987.             s->lossless    = 0;

  1988.             s->ls          = 0;

  1989.             s->progressive = 1;

  1990.             if ((ret = ff_mjpeg_decode_sof(s)) < 0)

  1991.                 goto fail;

  1992.             break;

  1993.         case SOF3:

  1994.             s->lossless    = 1;

  1995.             s->ls          = 0;

  1996.             s->progressive = 0;

  1997.             if ((ret = ff_mjpeg_decode_sof(s)) < 0)

  1998.                 goto fail;

  1999.             break;

  2000.         case SOF48:

  2001.             s->lossless    = 1;

  2002.             s->ls          = 1;

  2003.             s->progressive = 0;

  2004.             if ((ret = ff_mjpeg_decode_sof(s)) < 0)

  2005.                 goto fail;

  2006.             break;

  2007.         case LSE:

  2008.             if (!CONFIG_JPEGLS_DECODER ||

  2009.                 (ret = ff_jpegls_decode_lse(s)) < 0)

  2010.                 goto fail;

  2011.             break;

  2012.         case EOI:

  2013. eoi_parser:

  2014.             s->cur_scan = 0;

  2015.             if (!s->got_picture) {

  2016.                 av_log(avctx, AV_LOG_WARNING,

  2017.                        "Found EOI before any SOF, ignoring\n");

  2018.                 break;

  2019.             }

  2020.             if (s->interlaced) {

  2021.                 s->bottom_field ^= 1;

  2022.                 /* if not bottom field, do not output image yet */

  2023.                 if (s->bottom_field == !s->interlace_polarity)

  2024.                     break;

  2025.             }

  2026.             if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)

  2027.                 return ret;

  2028.             *got_frame = 1;

  2029.             s->got_picture = 0;

  2030. 

  2031.             if (!s->lossless) {

  2032.                 int qp = FFMAX3(s->qscale[0],

  2033.                                 s->qscale[1],

  2034.                                 s->qscale[2]);

  2035.                 int qpw = (s->width + 15) / 16;

  2036.                 AVBufferRef *qp_table_buf = av_buffer_alloc(qpw);

  2037.                 if (qp_table_buf) {

  2038.                     memset(qp_table_buf->data, qp, qpw);

  2039.                     av_frame_set_qp_table(data, qp_table_buf, 0, FF_QSCALE_TYPE_MPEG1);

  2040.                 }

  2041. 

  2042.                 if(avctx->debug & FF_DEBUG_QP)

  2043.                     av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);

  2044.             }

  2045. 

  2046.             goto the_end;

  2047.         case SOS:

  2048.             s->cur_scan++;

  2049.             if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&

  2050.                 (avctx->err_recognition & AV_EF_EXPLODE))

  2051.                 goto fail;

  2052.             break;

  2053.         case DRI:

  2054.             mjpeg_decode_dri(s);

  2055.             break;

  2056.         case SOF5:

  2057.         case SOF6:

  2058.         case SOF7:

  2059.         case SOF9:

  2060.         case SOF10:

  2061.         case SOF11:

  2062.         case SOF13:

  2063.         case SOF14:

  2064.         case SOF15:

  2065.         case JPG:

  2066.             av_log(avctx, AV_LOG_ERROR,

  2067.                    "mjpeg: unsupported coding type (%x)\n", start_code);

  2068.             break;

  2069.         }

  2070. 

  2071.         /* eof process start code */

  2072.         buf_ptr += (get_bits_count(&s->gb) + 7) / 8;

  2073.         av_log(avctx, AV_LOG_DEBUG,

  2074.                "marker parser used %d bytes (%d bits)\n",

  2075.                (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));

  2076.     }

  2077.     if (s->got_picture && s->cur_scan) {

  2078.         av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");

  2079.         goto eoi_parser;

  2080.     }

  2081.     av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");

  2082.     return AVERROR_INVALIDDATA;

  2083. fail:

  2084.     s->got_picture = 0;

  2085.     return ret;

  2086. the_end:

  2087. 

  2088.     is16bit = av_pix_fmt_desc_get(s->avctx->pix_fmt)->comp[0].step_minus1;

  2089. 

  2090.     if (s->upscale_h) {

  2091.         int p;

  2092.         av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||

  2093.                    avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||

  2094.                    avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||

  2095.                    avctx->pix_fmt == AV_PIX_FMT_YUV440P  ||

  2096.                    avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||

  2097.                    avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||

  2098.                    avctx->pix_fmt == AV_PIX_FMT_YUV420P  ||

  2099.                    avctx->pix_fmt == AV_PIX_FMT_YUV420P16||

  2100.                    avctx->pix_fmt == AV_PIX_FMT_GBRAP

  2101.                   );

  2102.         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);

  2103.         for (p = 0; p<4; p++) {

  2104.             uint8_t *line = s->picture_ptr->data[p];

  2105.             int w = s->width;

  2106.             if (!(s->upscale_h & (1<<p)))

  2107.                 continue;

  2108.             if (p==1 || p==2)

  2109.                 w >>= hshift;

  2110.             av_assert0(w > 0);

  2111.             for (i = 0; i < s->chroma_height; i++) {

  2112.                 if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];

  2113.                 else                      line[w - 1] = line[(w - 1) / 2];

  2114.                 for (index = w - 2; index > 0; index--) {

  2115.                     if (is16bit)

  2116.                         ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;

  2117.                     else

  2118.                         line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;

  2119.                 }

  2120.                 line += s->linesize[p];

  2121.             }

  2122.         }

  2123.     }

  2124.     if (s->upscale_v) {

  2125.         int p;

  2126.         av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||

  2127.                    avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||

  2128.                    avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||

  2129.                    avctx->pix_fmt == AV_PIX_FMT_YUV422P  ||

  2130.                    avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||

  2131.                    avctx->pix_fmt == AV_PIX_FMT_YUV420P  ||

  2132.                    avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||

  2133.                    avctx->pix_fmt == AV_PIX_FMT_GBRAP

  2134.                    );

  2135.         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);

  2136.         for (p = 0; p < 4; p++) {

  2137.             uint8_t *dst;

  2138.             int w = s->width;

  2139.             int h = s->height;

  2140.             if (!(s->upscale_v & (1<<p)))

  2141.                 continue;

  2142.             if (p==1 || p==2) {

  2143.                 w = FF_CEIL_RSHIFT(w, hshift);

  2144.                 h = FF_CEIL_RSHIFT(h, vshift);

  2145.             }

  2146.             dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];

  2147.             for (i = h - 1; i; i--) {

  2148.                 uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i / 2 * s->linesize[p]];

  2149.                 uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) / 2 * s->linesize[p]];

  2150.                 if (src1 == src2 || i == h - 1) {

  2151.                     memcpy(dst, src1, w);

  2152.                 } else {

  2153.                     for (index = 0; index < w; index++)

  2154.                         dst[index] = (src1[index] + src2[index]) >> 1;

  2155.                 }

  2156.                 dst -= s->linesize[p];

  2157.             }

  2158.         }

  2159.     }

  2160.     if (s->flipped) {

  2161.         int j;

  2162.         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);

  2163.         for (index=0; index<4; index++) {

  2164.             uint8_t *dst = s->picture_ptr->data[index];

  2165.             int w = s->picture_ptr->width;

  2166.             int h = s->picture_ptr->height;

  2167.             if(index && index<3){

  2168.                 w = FF_CEIL_RSHIFT(w, hshift);

  2169.                 h = FF_CEIL_RSHIFT(h, vshift);

  2170.             }

  2171.             if(dst){

  2172.                 uint8_t *dst2 = dst + s->picture_ptr->linesize[index]*(h-1);

  2173.                 for (i=0; i<h/2; i++) {

  2174.                     for (j=0; j<w; j++)

  2175.                         FFSWAP(int, dst[j], dst2[j]);

  2176.                     dst  += s->picture_ptr->linesize[index];

  2177.                     dst2 -= s->picture_ptr->linesize[index];

  2178.                 }

  2179.             }

  2180.         }

  2181.     }

  2182.     if (s->adobe_transform == 0 && s->avctx->pix_fmt == AV_PIX_FMT_GBRAP) {

  2183.         int w = s->picture_ptr->width;

  2184.         int h = s->picture_ptr->height;

  2185.         for (i=0; i<h; i++) {

  2186.             int j;

  2187.             uint8_t *dst[4];

  2188.             for (index=0; index<4; index++) {

  2189.                 dst[index] =   s->picture_ptr->data[index]

  2190.                              + s->picture_ptr->linesize[index]*i;

  2191.             }

  2192.             for (j=0; j<w; j++) {

  2193.                 int k = dst[3][j];

  2194.                 int r = dst[0][j] * k;

  2195.                 int g = dst[1][j] * k;

  2196.                 int b = dst[2][j] * k;

  2197.                 dst[0][j] = g*257 >> 16;

  2198.                 dst[1][j] = b*257 >> 16;

  2199.                 dst[2][j] = r*257 >> 16;

  2200.                 dst[3][j] = 255;

  2201.             }

  2202.         }

  2203.     }

  2204.     if (s->adobe_transform == 2 && s->avctx->pix_fmt == AV_PIX_FMT_YUVA444P) {

  2205.         int w = s->picture_ptr->width;

  2206.         int h = s->picture_ptr->height;

  2207.         for (i=0; i<h; i++) {

  2208.             int j;

  2209.             uint8_t *dst[4];

  2210.             for (index=0; index<4; index++) {

  2211.                 dst[index] =   s->picture_ptr->data[index]

  2212.                              + s->picture_ptr->linesize[index]*i;

  2213.             }

  2214.             for (j=0; j<w; j++) {

  2215.                 int k = dst[3][j];

  2216.                 int r = (255 - dst[0][j]) * k;

  2217.                 int g = (128 - dst[1][j]) * k;

  2218.                 int b = (128 - dst[2][j]) * k;

  2219.                 dst[0][j] = r*257 >> 16;

  2220.                 dst[1][j] = (g*257 >> 16) + 128;

  2221.                 dst[2][j] = (b*257 >> 16) + 128;

  2222.                 dst[3][j] = 255;

  2223.             }

  2224.         }

  2225.     }

  2226. 

  2227.     if (s->stereo3d) {

  2228.         AVStereo3D *stereo = av_stereo3d_create_side_data(data);

  2229.         if (stereo) {

  2230.             stereo->type  = s->stereo3d->type;

  2231.             stereo->flags = s->stereo3d->flags;

  2232.         }

  2233.         av_freep(&s->stereo3d);

  2234.     }

  2235. 

  2236.     av_dict_copy(avpriv_frame_get_metadatap(data), s->exif_metadata, 0);

  2237.     av_dict_free(&s->exif_metadata);

  2238. 

  2239.     av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n",

  2240.            buf_end - buf_ptr);

  2241. //  return buf_end - buf_ptr;

  2242.     return buf_ptr - buf;

  2243. }

  2244. 

  2245. av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)

  2246. {

  2247.     MJpegDecodeContext *s = avctx->priv_data;

  2248.     int i, j;

  2249. 

  2250.     if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_number) {

  2251.         av_log(avctx, AV_LOG_INFO, "Single field\n");

  2252.     }

  2253. 

  2254.     if (s->picture) {

  2255.         av_frame_free(&s->picture);

  2256.         s->picture_ptr = NULL;

  2257.     } else if (s->picture_ptr)

  2258.         av_frame_unref(s->picture_ptr);

  2259. 

  2260.     av_freep(&s->buffer);

  2261.     av_freep(&s->stereo3d);

  2262.     av_freep(&s->ljpeg_buffer);

  2263.     s->ljpeg_buffer_size = 0;

  2264. 

  2265.     for (i = 0; i < 3; i++) {

  2266.         for (j = 0; j < 4; j++)

  2267.             ff_free_vlc(&s->vlcs[i][j]);

  2268.     }

  2269.     for (i = 0; i < MAX_COMPONENTS; i++) {

  2270.         av_freep(&s->blocks[i]);

  2271.         av_freep(&s->last_nnz[i]);

  2272.     }

  2273.     av_dict_free(&s->exif_metadata);

  2274.     return 0;

  2275. }

  2276. 

  2277. static void decode_flush(AVCodecContext *avctx)

  2278. {

  2279.     MJpegDecodeContext *s = avctx->priv_data;

  2280.     s->got_picture = 0;

  2281. }

  2282. 

  2283. #if CONFIG_MJPEG_DECODER

  2284. #define OFFSET(x) offsetof(MJpegDecodeContext, x)

  2285. #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM

  2286. static const AVOption options[] = {

  2287.     { "extern_huff", "Use external huffman table.",

  2288.       OFFSET(extern_huff), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VD },

  2289.     { NULL },

  2290. };

  2291. 

  2292. static const AVClass mjpegdec_class = {

  2293.     .class_name = "MJPEG decoder",

  2294.     .item_name  = av_default_item_name,

  2295.     .option     = options,

  2296.     .version    = LIBAVUTIL_VERSION_INT,

  2297. };

  2298. 

  2299. AVCodec ff_mjpeg_decoder = {

  2300.     .name           = "mjpeg",

  2301.     .long_name      = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),

  2302.     .type           = AVMEDIA_TYPE_VIDEO,

  2303.     .id             = AV_CODEC_ID_MJPEG,

  2304.     .priv_data_size = sizeof(MJpegDecodeContext),

  2305.     .init           = ff_mjpeg_decode_init,

  2306.     .close          = ff_mjpeg_decode_end,

  2307.     .decode         = ff_mjpeg_decode_frame,

  2308.     .flush          = decode_flush,

  2309.     .capabilities   = CODEC_CAP_DR1,

  2310.     .max_lowres     = 3,

  2311.     .priv_class     = &mjpegdec_class,

  2312. };

  2313. #endif

  2314. #if CONFIG_THP_DECODER

  2315. AVCodec ff_thp_decoder = {

  2316.     .name           = "thp",

  2317.     .long_name      = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),

  2318.     .type           = AVMEDIA_TYPE_VIDEO,

  2319.     .id             = AV_CODEC_ID_THP,

  2320.     .priv_data_size = sizeof(MJpegDecodeContext),

  2321.     .init           = ff_mjpeg_decode_init,

  2322.     .close          = ff_mjpeg_decode_end,

  2323.     .decode         = ff_mjpeg_decode_frame,

  2324.     .flush          = decode_flush,

  2325.     .capabilities   = CODEC_CAP_DR1,

  2326.     .max_lowres     = 3,

  2327. };

  2328. #endif