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.
67442 Commits
32 Branches
293MB
Tree: c53a1507aa
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c53a1507aa'
${ noResults }
FFmpeg/libavcodec/mjpegdec.c

2330 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.         } else if (s->adobe_transform == 2 && s->bits <= 8) {

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

  449.             s->upscale_v = 6;

  450.             s->upscale_h = 6;

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

  452.         } else {

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

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

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

  456.         }

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

  458.         break;

  459.     case 0x12121100:

  460.     case 0x22122100:

  461.     case 0x21211100:

  462.     case 0x22211200:

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

  464.         else

  465.             goto unk_pixfmt;

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

  467.         break;

  468.     case 0x22221100:

  469.     case 0x22112200:

  470.     case 0x11222200:

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

  472.         else

  473.             goto unk_pixfmt;

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

  475.         break;

  476.     case 0x11000000:

  477.     case 0x13000000:

  478.     case 0x14000000:

  479.     case 0x31000000:

  480.     case 0x33000000:

  481.     case 0x34000000:

  482.     case 0x41000000:

  483.     case 0x43000000:

  484.     case 0x44000000:

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

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

  487.         else

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

  489.         break;

  490.     case 0x12111100:

  491.     case 0x14121200:

  492.     case 0x22211100:

  493.     case 0x22112100:

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

  495.         else

  496.             goto unk_pixfmt;

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

  498.         break;

  499.     case 0x21111100:

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

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

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

  503.         break;

  504.     case 0x22121100:

  505.     case 0x22111200:

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

  507.         else

  508.             goto unk_pixfmt;

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

  510.         break;

  511.     case 0x22111100:

  512.     case 0x42111100:

  513.     case 0x24111100:

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

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

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

  517.         if (pix_fmt_id == 0x42111100) {

  518.             s->upscale_h = 6;

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

  520.             s->upscale_v = 6;

  521.         }

  522.         break;

  523.     case 0x41111100:

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

  525.         else

  526.             goto unk_pixfmt;

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

  528.         break;

  529.     default:

  530. unk_pixfmt:

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

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

  533.         return AVERROR_PATCHWELCOME;

  534.     }

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

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

  537.         return AVERROR_PATCHWELCOME;

  538.     }

  539.     if (s->ls) {

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

  541.         if (s->nb_components > 1)

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

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

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

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

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

  547.         else

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

  549.     }

  550. 

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

  552.     if (!s->pix_desc) {

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

  554.         return AVERROR_BUG;

  555.     }

  556. 

  557.     av_frame_unref(s->picture_ptr);

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

  559.         return -1;

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

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

  562.     s->got_picture            = 1;

  563. 

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

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

  566. 

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

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

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

  570. 

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

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

  573.     }

  574. 

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

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

  577.         return AVERROR_PATCHWELCOME;

  578.     }

  579. 

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

  581.     if (s->progressive) {

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

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

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

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

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

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

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

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

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

  591.                 return AVERROR(ENOMEM);

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

  593.         }

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

  595.     }

  596.     return 0;

  597. }

  598. 

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

  600. {

  601.     int code;

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

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

  604.         av_log(s->avctx, AV_LOG_WARNING,

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

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

  607.         return 0xfffff;

  608.     }

  609. 

  610.     if (code)

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

  612.     else

  613.         return 0;

  614. }

  615. 

  616. /* decode block and dequantize */

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

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

  619. {

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

  621. 

  622.     /* DC coef */

  623.     val = mjpeg_decode_dc(s, dc_index);

  624.     if (val == 0xfffff) {

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

  626.         return AVERROR_INVALIDDATA;

  627.     }

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

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

  630.     block[0] = val;

  631.     /* AC coefs */

  632.     i = 0;

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

  634.     do {

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

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

  637. 

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

  639.             code &= 0xf;

  640.         if (code) {

  641.             if (code > MIN_CACHE_BITS - 16)

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

  643. 

  644.             {

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

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

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

  648.             }

  649. 

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

  651. 

  652.             if (i > 63) {

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

  654.                 return AVERROR_INVALIDDATA;

  655.             }

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

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

  658.         }

  659.     } while (i < 63);

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

  661. 

  662.     return 0;

  663. }

  664. 

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

  666.                                  int component, int dc_index,

  667.                                  int16_t *quant_matrix, int Al)

  668. {

  669.     int val;

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

  671.     val = mjpeg_decode_dc(s, dc_index);

  672.     if (val == 0xfffff) {

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

  674.         return AVERROR_INVALIDDATA;

  675.     }

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

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

  678.     block[0] = val;

  679.     return 0;

  680. }

  681. 

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

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

  684.                                     uint8_t *last_nnz, int ac_index,

  685.                                     int16_t *quant_matrix,

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

  687. {

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

  689. 

  690.     if (*EOBRUN) {

  691.         (*EOBRUN)--;

  692.         return 0;

  693.     }

  694. 

  695.     {

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

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

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

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

  700. 

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

  702.             code &= 0xF;

  703.             if (code) {

  704.                 i += run;

  705.                 if (code > MIN_CACHE_BITS - 16)

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

  707. 

  708.                 {

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

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

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

  712.                 }

  713. 

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

  715. 

  716.                 if (i >= se) {

  717.                     if (i == se) {

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

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

  720.                         break;

  721.                     }

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

  723.                     return AVERROR_INVALIDDATA;

  724.                 }

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

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

  727.             } else {

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

  729.                     i += 15;

  730.                     if (i >= se) {

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

  732.                         return AVERROR_INVALIDDATA;

  733.                     }

  734.                 } else {

  735.                     val = (1 << run);

  736.                     if (run) {

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

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

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

  740.                     }

  741.                     *EOBRUN = val - 1;

  742.                     break;

  743.                 }

  744.             }

  745.         }

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

  747.     }

  748. 

  749.     if (i > *last_nnz)

  750.         *last_nnz = i;

  751. 

  752.     return 0;

  753. }

  754. 

  755. #define REFINE_BIT(j) {                                             \

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

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

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

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

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

  761. }

  762. 

  763. #define ZERO_RUN                                                    \

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

  765.     if (i > last) {                                                 \

  766.         i += run;                                                   \

  767.         if (i > se) {                                               \

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

  769.             return -1;                                              \

  770.         }                                                           \

  771.         break;                                                      \

  772.     }                                                               \

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

  774.     if (block[j])                                                   \

  775.         REFINE_BIT(j)                                               \

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

  777.         break;                                                      \

  778. }

  779. 

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

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

  782.                                    uint8_t *last_nnz,

  783.                                    int ac_index, int16_t *quant_matrix,

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

  785. {

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

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

  788. 

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

  790.     if (*EOBRUN) {

  791.         (*EOBRUN)--;

  792.     } else {

  793.         for (; ; i++) {

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

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

  796. 

  797.             if (code & 0xF) {

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

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

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

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

  802.                 ZERO_RUN;

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

  804.                 val--;

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

  806.                 if (i == se) {

  807.                     if (i > *last_nnz)

  808.                         *last_nnz = i;

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

  810.                     return 0;

  811.                 }

  812.             } else {

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

  814.                 if (run == 0xF) {

  815.                     ZERO_RUN;

  816.                 } else {

  817.                     val = run;

  818.                     run = (1 << run);

  819.                     if (val) {

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

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

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

  823.                     }

  824.                     *EOBRUN = run - 1;

  825.                     break;

  826.                 }

  827.             }

  828.         }

  829. 

  830.         if (i > *last_nnz)

  831.             *last_nnz = i;

  832.     }

  833. 

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

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

  836.         if (block[j])

  837.             REFINE_BIT(j)

  838.     }

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

  840. 

  841.     return 0;

  842. }

  843. #undef REFINE_BIT

  844. #undef ZERO_RUN

  845. 

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

  847. {

  848.     int i;

  849.     int reset = 0;

  850. 

  851.     if (s->restart_interval) {

  852.         s->restart_count--;

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

  854.             align_get_bits(&s->gb);

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

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

  857.         }

  858. 

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

  860.         /* skip RSTn */

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

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

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

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

  865.                 align_get_bits(&s->gb);

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

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

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

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

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

  871.                     reset = 1;

  872.                 } else

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

  874.             }

  875.         }

  876.     }

  877.     return reset;

  878. }

  879. 

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

  881. {

  882.     int i, mb_x, mb_y;

  883.     uint16_t (*buffer)[4];

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

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

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

  887.     int resync_mb_y = 0;

  888.     int resync_mb_x = 0;

  889. 

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

  891.         return AVERROR_INVALIDDATA;

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

  893.         return AVERROR_INVALIDDATA;

  894. 

  895. 

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

  897. 

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

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

  900.     buffer = s->ljpeg_buffer;

  901. 

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

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

  904. 

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

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

  907. 

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

  909.             ptr += linesize >> 1;

  910. 

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

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

  913. 

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

  915.             int modified_predictor = predictor;

  916. 

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

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

  919.                 resync_mb_x = mb_x;

  920.                 resync_mb_y = mb_y;

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

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

  923.             }

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

  925.                 modified_predictor = 1;

  926. 

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

  928.                 int pred, dc;

  929. 

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

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

  932. 

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

  934. 

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

  936.                 if(dc == 0xFFFFF)

  937.                     return -1;

  938. 

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

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

  941.             }

  942. 

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

  944.                 align_get_bits(&s->gb);

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

  946.             }

  947.         }

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

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

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

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

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

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

  954.                     }

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

  956.                     return AVERROR_PATCHWELCOME;

  957.                 } else {

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

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

  960.                     }

  961.                 }

  962.             }

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

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

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

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

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

  968.             }

  969.         } else if (s->pegasus_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]) >> 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 {

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

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

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

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

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

  981.                     }

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

  983.                     return AVERROR_PATCHWELCOME;

  984.                 } else {

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

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

  987.                     }

  988.                 }

  989.             }

  990.         }

  991.     }

  992.     return 0;

  993. }

  994. 

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

  996.                                  int point_transform, int nb_components)

  997. {

  998.     int i, mb_x, mb_y, mask;

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

  1000.     int resync_mb_y = 0;

  1001.     int resync_mb_x = 0;

  1002. 

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

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

  1005. 

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

  1007. 

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

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

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

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

  1012.                 resync_mb_x = mb_x;

  1013.                 resync_mb_y = mb_y;

  1014.             }

  1015. 

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

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

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

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

  1020.                     uint8_t *ptr;

  1021.                     uint16_t *ptr16;

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

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

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

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

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

  1027.                     x = 0;

  1028.                     y = 0;

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

  1030. 

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

  1032. 

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

  1034.                         int pred, dc;

  1035. 

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

  1037.                         if(dc == 0xFFFFF)

  1038.                             return -1;

  1039.                         if(bits<=8){

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

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

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

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

  1044.                             }else{

  1045.                                 pred= ptr[-1];

  1046.                             }

  1047.                         }else{

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

  1049.                                 pred= ptr[-linesize];

  1050.                             }else{

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

  1052.                             }

  1053.                         }

  1054. 

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

  1056.                             ptr += linesize >> 1;

  1057.                         pred &= mask;

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

  1059.                         }else{

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

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

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

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

  1064.                                 }else{

  1065.                                     pred= ptr16[-1];

  1066.                                 }

  1067.                             }else{

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

  1069.                                     pred= ptr16[-linesize];

  1070.                                 }else{

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

  1072.                                 }

  1073.                             }

  1074. 

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

  1076.                                 ptr16 += linesize >> 1;

  1077.                             pred &= mask;

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

  1079.                         }

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

  1081.                             x = 0;

  1082.                             y++;

  1083.                         }

  1084.                     }

  1085.                 }

  1086.             } else {

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

  1088.                     uint8_t *ptr;

  1089.                     uint16_t *ptr16;

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

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

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

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

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

  1095.                     x        = 0;

  1096.                     y        = 0;

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

  1098. 

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

  1100. 

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

  1102.                         int pred;

  1103. 

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

  1105.                         if(dc == 0xFFFFF)

  1106.                             return -1;

  1107.                         if(bits<=8){

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

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

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

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

  1112. 

  1113.                             pred &= mask;

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

  1115.                         }else{

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

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

  1118. 

  1119.                             pred &= mask;

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

  1121.                         }

  1122. 

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

  1124.                             x = 0;

  1125.                             y++;

  1126.                         }

  1127.                     }

  1128.                 }

  1129.             }

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

  1131.                 align_get_bits(&s->gb);

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

  1133.             }

  1134.         }

  1135.     }

  1136.     return 0;

  1137. }

  1138. 

  1139. static av_always_inline void mjpeg_copy_block(MJpegDecodeContext *s,

  1140.                                               uint8_t *dst, const uint8_t *src,

  1141.                                               int linesize, int lowres)

  1142. {

  1143.     switch (lowres) {

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

  1145.         break;

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

  1147.         break;

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

  1149.         break;

  1150.     case 3: *dst = *src;

  1151.         break;

  1152.     }

  1153. }

  1154. 

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

  1156. {

  1157.     int block_x, block_y;

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

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

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

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

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

  1163.     } else {

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

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

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

  1167.     }

  1168. }

  1169. 

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

  1171.                              int Al, const uint8_t *mb_bitmask,

  1172.                              int mb_bitmask_size,

  1173.                              const AVFrame *reference)

  1174. {

  1175.     int i, mb_x, mb_y;

  1176.     uint8_t *data[MAX_COMPONENTS];

  1177.     const uint8_t *reference_data[MAX_COMPONENTS];

  1178.     int linesize[MAX_COMPONENTS];

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

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

  1181. 

  1182.     if (mb_bitmask) {

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

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

  1185.             return AVERROR_INVALIDDATA;

  1186.         }

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

  1188.     }

  1189. 

  1190.     s->restart_count = 0;

  1191. 

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

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

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

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

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

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

  1198.     }

  1199. 

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

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

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

  1203. 

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

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

  1206. 

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

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

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

  1210.                 return AVERROR_INVALIDDATA;

  1211.             }

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

  1213.                 uint8_t *ptr;

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

  1215.                 int block_offset;

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

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

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

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

  1220.                 x = 0;

  1221.                 y = 0;

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

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

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

  1225. 

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

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

  1228.                     ptr = data[c] + block_offset;

  1229.                     if (!s->progressive) {

  1230.                         if (copy_mb)

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

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

  1233. 

  1234.                         else {

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

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

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

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

  1239.                                 av_log(s->avctx, AV_LOG_ERROR,

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

  1241.                                 return AVERROR_INVALIDDATA;

  1242.                             }

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

  1244.                             if (s->bits & 7)

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

  1246.                         }

  1247.                     } else {

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

  1249.                                          (h * mb_x + x);

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

  1251.                         if (Ah)

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

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

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

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

  1256.                                                        Al) < 0) {

  1257.                             av_log(s->avctx, AV_LOG_ERROR,

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

  1259.                             return AVERROR_INVALIDDATA;

  1260.                         }

  1261.                     }

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

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

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

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

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

  1267.                         x = 0;

  1268.                         y++;

  1269.                     }

  1270.                 }

  1271.             }

  1272. 

  1273.             handle_rstn(s, nb_components);

  1274.         }

  1275.     }

  1276.     return 0;

  1277. }

  1278. 

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

  1280.                                             int se, int Ah, int Al)

  1281. {

  1282.     int mb_x, mb_y;

  1283.     int EOBRUN = 0;

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

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

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

  1287.     int last_scan = 0;

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

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

  1290. 

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

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

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

  1294.         return AVERROR_INVALIDDATA;

  1295.     }

  1296. 

  1297.     if (!Al) {

  1298.         // s->coefs_finished is a bitmask for coefficients coded

  1299.         // ss and se are parameters telling start and end coefficients

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

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

  1302.     }

  1303. 

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

  1305.         data += linesize >> 1;

  1306. 

  1307.     s->restart_count = 0;

  1308. 

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

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

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

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

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

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

  1315.                 int ret;

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

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

  1318. 

  1319.                 if (Ah)

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

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

  1322.                 else

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

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

  1325.                 if (ret < 0) {

  1326.                     av_log(s->avctx, AV_LOG_ERROR,

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

  1328.                     return AVERROR_INVALIDDATA;

  1329.                 }

  1330. 

  1331.             if (last_scan) {

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

  1333.                     if (s->bits & 7)

  1334.                         shift_output(s, ptr, linesize);

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

  1336.             }

  1337.             if (handle_rstn(s, 0))

  1338.                 EOBRUN = 0;

  1339.         }

  1340.     }

  1341.     return 0;

  1342. }

  1343. 

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

  1345.                         int mb_bitmask_size, const AVFrame *reference)

  1346. {

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

  1348.     int index, id, ret;

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

  1350.     int ilv, prev_shift;

  1351. 

  1352.     if (!s->got_picture) {

  1353.         av_log(s->avctx, AV_LOG_WARNING,

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

  1355.         return -1;

  1356.     }

  1357. 

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

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

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

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

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

  1363.         av_log(s->avctx, AV_LOG_ERROR,

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

  1365.         return AVERROR_PATCHWELCOME;

  1366.     }

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

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

  1369.         return AVERROR_INVALIDDATA;

  1370.     }

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

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

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

  1374.         /* find component index */

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

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

  1377.                 break;

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

  1379.             av_log(s->avctx, AV_LOG_ERROR,

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

  1381.             return AVERROR_INVALIDDATA;

  1382.         }

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

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

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

  1386.             index = 3 - i;

  1387. 

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

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

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

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

  1392. 

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

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

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

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

  1397. 

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

  1399. 

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

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

  1402. 

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

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

  1405.             goto out_of_range;

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

  1407.             goto out_of_range;

  1408.     }

  1409. 

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

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

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

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

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

  1415.     }else

  1416.         prev_shift = point_transform = 0;

  1417. 

  1418.     if (nb_components > 1) {

  1419.         /* interleaved stream */

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

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

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

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

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

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

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

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

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

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

  1430.     }

  1431. 

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

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

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

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

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

  1437. 

  1438. 

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

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

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

  1442. 

  1443. next_field:

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

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

  1446. 

  1447.     if (s->lossless) {

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

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

  1450. //            for () {

  1451. //            reset_ls_coding_parameters(s, 0);

  1452. 

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

  1454.                                                 point_transform, ilv)) < 0)

  1455.                 return ret;

  1456.         } else {

  1457.             if (s->rgb) {

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

  1459.                     return ret;

  1460.             } else {

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

  1462.                                                  point_transform,

  1463.                                                  nb_components)) < 0)

  1464.                     return ret;

  1465.             }

  1466.         }

  1467.     } else {

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

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

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

  1471.                                                         ilv, prev_shift,

  1472.                                                         point_transform)) < 0)

  1473.                 return ret;

  1474.         } else {

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

  1476.                                          prev_shift, point_transform,

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

  1478.                 return ret;

  1479.         }

  1480.     }

  1481. 

  1482.     if (s->interlaced &&

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

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

  1485.         GetBitContext bak = s->gb;

  1486.         align_get_bits(&bak);

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

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

  1489.             s->gb = bak;

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

  1491.             s->bottom_field ^= 1;

  1492. 

  1493.             goto next_field;

  1494.         }

  1495.     }

  1496. 

  1497.     emms_c();

  1498.     return 0;

  1499.  out_of_range:

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

  1501.     return AVERROR_INVALIDDATA;

  1502. }

  1503. 

  1504. static int mjpeg_decode_dri(MJpegDecodeContext *s)

  1505. {

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

  1507.         return AVERROR_INVALIDDATA;

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

  1509.     s->restart_count    = 0;

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

  1511.            s->restart_interval);

  1512. 

  1513.     return 0;

  1514. }

  1515. 

  1516. static int mjpeg_decode_app(MJpegDecodeContext *s)

  1517. {

  1518.     int len, id, i;

  1519. 

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

  1521.     if (len < 6)

  1522.         return AVERROR_INVALIDDATA;

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

  1524.         return AVERROR_INVALIDDATA;

  1525. 

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

  1527.     len -= 6;

  1528. 

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

  1530.         char id_str[32];

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

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

  1533.     }

  1534. 

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

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

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

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

  1539.         /* structure:

  1540.             4bytes      AVI1

  1541.             1bytes      polarity

  1542.             1bytes      always zero

  1543.             4bytes      field_size

  1544.             4bytes      field_size_less_padding

  1545.         */

  1546.             s->buggy_avid = 1;

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

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

  1549. #if 0

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

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

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

  1553.         len -= 10;

  1554. #endif

  1555.         goto out;

  1556.     }

  1557. 

  1558. //    len -= 2;

  1559. 

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

  1561.         int t_w, t_h, v1, v2;

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

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

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

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

  1566. 

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

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

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

  1570. 

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

  1572.             av_log(s->avctx, AV_LOG_INFO,

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

  1574.                    v1, v2,

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

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

  1577. 

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

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

  1580.         if (t_w && t_h) {

  1581.             /* skip thumbnail */

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

  1583.                 len -= t_w * t_h * 3;

  1584.         }

  1585.         len -= 10;

  1586.         goto out;

  1587.     }

  1588. 

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

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

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

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

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

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

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

  1596.         len -= 7;

  1597.         goto out;

  1598.     }

  1599. 

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

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

  1602.             av_log(s->avctx, AV_LOG_INFO,

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

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

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

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

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

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

  1609.         case 1:

  1610.             s->rgb         = 1;

  1611.             s->pegasus_rct = 0;

  1612.             break;

  1613.         case 2:

  1614.             s->rgb         = 1;

  1615.             s->pegasus_rct = 1;

  1616.             break;

  1617.         default:

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

  1619.         }

  1620.         len -= 9;

  1621.         goto out;

  1622.     }

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

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

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

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

  1627.         len --;

  1628.         goto out;

  1629.     }

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

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

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

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

  1634.         len --;

  1635.         goto out;

  1636.     }

  1637. 

  1638.     /* JPS extension by VRex */

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

  1640.         int flags, layout, type;

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

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

  1643. 

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

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

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

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

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

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

  1650.         len -= 4;

  1651. 

  1652.         s->stereo3d = av_stereo3d_alloc();

  1653.         if (!s->stereo3d) {

  1654.             goto out;

  1655.         }

  1656.         if (type == 0) {

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

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

  1659.             switch (layout) {

  1660.             case 0x01:

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

  1662.                 break;

  1663.             case 0x02:

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

  1665.                 break;

  1666.             case 0x03:

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

  1668.                 break;

  1669.             }

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

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

  1672.             }

  1673.         }

  1674.         goto out;

  1675.     }

  1676. 

  1677.     /* EXIF metadata */

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

  1679.         GetByteContext gbytes;

  1680.         int ret, le, ifd_offset, bytes_read;

  1681.         const uint8_t *aligned;

  1682. 

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

  1684.         len -= 2;

  1685. 

  1686.         // init byte wise reading

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

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

  1689. 

  1690.         // read TIFF header

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

  1692.         if (ret) {

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

  1694.         } else {

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

  1696. 

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

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

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

  1700.             if (ret < 0) {

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

  1702.             }

  1703.         }

  1704. 

  1705.         bytes_read = bytestream2_tell(&gbytes);

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

  1707.         len -= bytes_read;

  1708. 

  1709.         goto out;

  1710.     }

  1711. 

  1712.     /* Apple MJPEG-A */

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

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

  1715.         len -= 4;

  1716.         /* Apple MJPEG-A */

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

  1718. #if 0

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

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

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

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

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

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

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

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

  1727. #endif

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

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

  1730.         }

  1731.     }

  1732. 

  1733. out:

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

  1735.     if (len < 0)

  1736.         av_log(s->avctx, AV_LOG_ERROR,

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

  1738.     while (--len > 0)

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

  1740. 

  1741.     return 0;

  1742. }

  1743. 

  1744. static int mjpeg_decode_com(MJpegDecodeContext *s)

  1745. {

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

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

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

  1749.         if (cbuf) {

  1750.             int i;

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

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

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

  1754.                 cbuf[i - 1] = 0;

  1755.             else

  1756.                 cbuf[i] = 0;

  1757. 

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

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

  1760. 

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

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

  1763.                 parse_avid(s, cbuf, len);

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

  1765.                 s->cs_itu601 = 1;

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

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

  1768.                 s->flipped = 1;

  1769. 

  1770.             av_free(cbuf);

  1771.         }

  1772.     }

  1773. 

  1774.     return 0;

  1775. }

  1776. 

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

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

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

  1780. {

  1781.     const uint8_t *buf_ptr;

  1782.     unsigned int v, v2;

  1783.     int val;

  1784.     int skipped = 0;

  1785. 

  1786.     buf_ptr = *pbuf_ptr;

  1787.     while (buf_end - buf_ptr > 1) {

  1788.         v  = *buf_ptr++;

  1789.         v2 = *buf_ptr;

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

  1791.             val = *buf_ptr++;

  1792.             goto found;

  1793.         }

  1794.         skipped++;

  1795.     }

  1796.     buf_ptr = buf_end;

  1797.     val = -1;

  1798. found:

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

  1800.     *pbuf_ptr = buf_ptr;

  1801.     return val;

  1802. }

  1803. 

  1804. int ff_mjpeg_find_marker(MJpegDecodeContext *s,

  1805.                          const uint8_t **buf_ptr, const uint8_t *buf_end,

  1806.                          const uint8_t **unescaped_buf_ptr,

  1807.                          int *unescaped_buf_size)

  1808. {

  1809.     int start_code;

  1810.     start_code = find_marker(buf_ptr, buf_end);

  1811. 

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

  1813.     if (!s->buffer)

  1814.         return AVERROR(ENOMEM);

  1815. 

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

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

  1818.         const uint8_t *src = *buf_ptr;

  1819.         uint8_t *dst = s->buffer;

  1820. 

  1821.         while (src < buf_end) {

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

  1823. 

  1824.             *(dst++) = x;

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

  1826.                 if (x == 0xff) {

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

  1828.                         x = *(src++);

  1829. 

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

  1831.                         *(dst++) = x;

  1832.                     else if (x)

  1833.                         break;

  1834.                 }

  1835.             }

  1836.         }

  1837.         *unescaped_buf_ptr  = s->buffer;

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

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

  1840.                FF_INPUT_BUFFER_PADDING_SIZE);

  1841. 

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

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

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

  1845.         const uint8_t *src = *buf_ptr;

  1846.         uint8_t *dst  = s->buffer;

  1847.         int bit_count = 0;

  1848.         int t = 0, b = 0;

  1849.         PutBitContext pb;

  1850. 

  1851.         /* find marker */

  1852.         while (src + t < buf_end) {

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

  1854.             if (x == 0xff) {

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

  1856.                     x = src[t++];

  1857.                 if (x & 0x80) {

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

  1859.                     break;

  1860.                 }

  1861.             }

  1862.         }

  1863.         bit_count = t * 8;

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

  1865. 

  1866.         /* unescape bitstream */

  1867.         while (b < t) {

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

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

  1870.             if (x == 0xFF) {

  1871.                 x = src[b++];

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

  1873.                 bit_count--;

  1874.             }

  1875.         }

  1876.         flush_put_bits(&pb);

  1877. 

  1878.         *unescaped_buf_ptr  = dst;

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

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

  1881.                FF_INPUT_BUFFER_PADDING_SIZE);

  1882.     } else {

  1883.         *unescaped_buf_ptr  = *buf_ptr;

  1884.         *unescaped_buf_size = buf_end - *buf_ptr;

  1885.     }

  1886. 

  1887.     return start_code;

  1888. }

  1889. 

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

  1891.                           AVPacket *avpkt)

  1892. {

  1893.     AVFrame     *frame = data;

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

  1895.     int buf_size       = avpkt->size;

  1896.     MJpegDecodeContext *s = avctx->priv_data;

  1897.     const uint8_t *buf_end, *buf_ptr;

  1898.     const uint8_t *unescaped_buf_ptr;

  1899.     int hshift, vshift;

  1900.     int unescaped_buf_size;

  1901.     int start_code;

  1902.     int i, index;

  1903.     int ret = 0;

  1904.     int is16bit;

  1905. 

  1906.     av_dict_free(&s->exif_metadata);

  1907.     av_freep(&s->stereo3d);

  1908.     s->adobe_transform = -1;

  1909. 

  1910.     buf_ptr = buf;

  1911.     buf_end = buf + buf_size;

  1912.     while (buf_ptr < buf_end) {

  1913.         /* find start next marker */

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

  1915.                                           &unescaped_buf_ptr,

  1916.                                           &unescaped_buf_size);

  1917.         /* EOF */

  1918.         if (start_code < 0) {

  1919.             break;

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

  1921.             av_log(avctx, AV_LOG_ERROR,

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

  1923.                    start_code, unescaped_buf_size, buf_size);

  1924.             return AVERROR_INVALIDDATA;

  1925.         }

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

  1927.                start_code, buf_end - buf_ptr);

  1928. 

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

  1930. 

  1931.         if (ret < 0) {

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

  1933.             goto fail;

  1934.         }

  1935. 

  1936.         s->start_code = start_code;

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

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

  1939. 

  1940.         /* process markers */

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

  1942.             av_log(avctx, AV_LOG_DEBUG,

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

  1944.             /* APP fields */

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

  1946.             mjpeg_decode_app(s);

  1947.             /* Comment */

  1948.         else if (start_code == COM)

  1949.             mjpeg_decode_com(s);

  1950. 

  1951.         ret = -1;

  1952. 

  1953.         if (!CONFIG_JPEGLS_DECODER &&

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

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

  1956.             return AVERROR(ENOSYS);

  1957.         }

  1958. 

  1959.         switch (start_code) {

  1960.         case SOI:

  1961.             s->restart_interval = 0;

  1962.             s->restart_count    = 0;

  1963.             /* nothing to do on SOI */

  1964.             break;

  1965.         case DQT:

  1966.             ff_mjpeg_decode_dqt(s);

  1967.             break;

  1968.         case DHT:

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

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

  1971.                 goto fail;

  1972.             }

  1973.             break;

  1974.         case SOF0:

  1975.         case SOF1:

  1976.             s->lossless    = 0;

  1977.             s->ls          = 0;

  1978.             s->progressive = 0;

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

  1980.                 goto fail;

  1981.             break;

  1982.         case SOF2:

  1983.             s->lossless    = 0;

  1984.             s->ls          = 0;

  1985.             s->progressive = 1;

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

  1987.                 goto fail;

  1988.             break;

  1989.         case SOF3:

  1990.             s->lossless    = 1;

  1991.             s->ls          = 0;

  1992.             s->progressive = 0;

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

  1994.                 goto fail;

  1995.             break;

  1996.         case SOF48:

  1997.             s->lossless    = 1;

  1998.             s->ls          = 1;

  1999.             s->progressive = 0;

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

  2001.                 goto fail;

  2002.             break;

  2003.         case LSE:

  2004.             if (!CONFIG_JPEGLS_DECODER ||

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

  2006.                 goto fail;

  2007.             break;

  2008.         case EOI:

  2009. eoi_parser:

  2010.             s->cur_scan = 0;

  2011.             if (!s->got_picture) {

  2012.                 av_log(avctx, AV_LOG_WARNING,

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

  2014.                 break;

  2015.             }

  2016.             if (s->interlaced) {

  2017.                 s->bottom_field ^= 1;

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

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

  2020.                     break;

  2021.             }

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

  2023.                 return ret;

  2024.             *got_frame = 1;

  2025.             s->got_picture = 0;

  2026. 

  2027.             if (!s->lossless) {

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

  2029.                                 s->qscale[1],

  2030.                                 s->qscale[2]);

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

  2032.                 AVBufferRef *qp_table_buf = av_buffer_alloc(qpw);

  2033.                 if (qp_table_buf) {

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

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

  2036.                 }

  2037. 

  2038.                 if(avctx->debug & FF_DEBUG_QP)

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

  2040.             }

  2041. 

  2042.             goto the_end;

  2043.         case SOS:

  2044.             s->cur_scan++;

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

  2046.                 (avctx->err_recognition & AV_EF_EXPLODE))

  2047.                 goto fail;

  2048.             break;

  2049.         case DRI:

  2050.             mjpeg_decode_dri(s);

  2051.             break;

  2052.         case SOF5:

  2053.         case SOF6:

  2054.         case SOF7:

  2055.         case SOF9:

  2056.         case SOF10:

  2057.         case SOF11:

  2058.         case SOF13:

  2059.         case SOF14:

  2060.         case SOF15:

  2061.         case JPG:

  2062.             av_log(avctx, AV_LOG_ERROR,

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

  2064.             break;

  2065.         }

  2066. 

  2067.         /* eof process start code */

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

  2069.         av_log(avctx, AV_LOG_DEBUG,

  2070.                "marker parser used %d bytes (%d bits)\n",

  2071.                (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));

  2072.     }

  2073.     if (s->got_picture && s->cur_scan) {

  2074.         av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");

  2075.         goto eoi_parser;

  2076.     }

  2077.     av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");

  2078.     return AVERROR_INVALIDDATA;

  2079. fail:

  2080.     s->got_picture = 0;

  2081.     return ret;

  2082. the_end:

  2083. 

  2084.     is16bit = av_pix_fmt_desc_get(s->avctx->pix_fmt)->comp[0].step_minus1;

  2085. 

  2086.     if (s->upscale_h) {

  2087.         int p;

  2088.         av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||

  2089.                    avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||

  2090.                    avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||

  2091.                    avctx->pix_fmt == AV_PIX_FMT_YUV440P  ||

  2092.                    avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||

  2093.                    avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||

  2094.                    avctx->pix_fmt == AV_PIX_FMT_YUV420P  ||

  2095.                    avctx->pix_fmt == AV_PIX_FMT_YUV420P16||

  2096.                    avctx->pix_fmt == AV_PIX_FMT_GBRAP

  2097.                   );

  2098.         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);

  2099.         for (p = 0; p<4; p++) {

  2100.             uint8_t *line = s->picture_ptr->data[p];

  2101.             int w = s->width;

  2102.             int h = s->height;

  2103.             if (!(s->upscale_h & (1<<p)))

  2104.                 continue;

  2105.             if (p==1 || p==2) {

  2106.                 w = FF_CEIL_RSHIFT(w, hshift);

  2107.                 h = FF_CEIL_RSHIFT(h, vshift);

  2108.             }

  2109.             if (s->upscale_v & (1<<p))

  2110.                 h = (h+1)>>1;

  2111.             av_assert0(w > 0);

  2112.             for (i = 0; i < h; i++) {

  2113.                 if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];

  2114.                 else                      line[w - 1] = line[(w - 1) / 2];

  2115.                 for (index = w - 2; index > 0; index--) {

  2116.                     if (is16bit)

  2117.                         ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;

  2118.                     else

  2119.                         line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;

  2120.                 }

  2121.                 line += s->linesize[p];

  2122.             }

  2123.         }

  2124.     }

  2125.     if (s->upscale_v) {

  2126.         int p;

  2127.         av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||

  2128.                    avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||

  2129.                    avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||

  2130.                    avctx->pix_fmt == AV_PIX_FMT_YUV422P  ||

  2131.                    avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||

  2132.                    avctx->pix_fmt == AV_PIX_FMT_YUV420P  ||

  2133.                    avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||

  2134.                    avctx->pix_fmt == AV_PIX_FMT_GBRAP

  2135.                    );

  2136.         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);

  2137.         for (p = 0; p < 4; p++) {

  2138.             uint8_t *dst;

  2139.             int w = s->width;

  2140.             int h = s->height;

  2141.             if (!(s->upscale_v & (1<<p)))

  2142.                 continue;

  2143.             if (p==1 || p==2) {

  2144.                 w = FF_CEIL_RSHIFT(w, hshift);

  2145.                 h = FF_CEIL_RSHIFT(h, vshift);

  2146.             }

  2147.             dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];

  2148.             for (i = h - 1; i; i--) {

  2149.                 uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i / 2 * s->linesize[p]];

  2150.                 uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) / 2 * s->linesize[p]];

  2151.                 if (src1 == src2 || i == h - 1) {

  2152.                     memcpy(dst, src1, w);

  2153.                 } else {

  2154.                     for (index = 0; index < w; index++)

  2155.                         dst[index] = (src1[index] + src2[index]) >> 1;

  2156.                 }

  2157.                 dst -= s->linesize[p];

  2158.             }

  2159.         }

  2160.     }

  2161.     if (s->flipped) {

  2162.         int j;

  2163.         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);

  2164.         for (index=0; index<4; index++) {

  2165.             uint8_t *dst = s->picture_ptr->data[index];

  2166.             int w = s->picture_ptr->width;

  2167.             int h = s->picture_ptr->height;

  2168.             if(index && index<3){

  2169.                 w = FF_CEIL_RSHIFT(w, hshift);

  2170.                 h = FF_CEIL_RSHIFT(h, vshift);

  2171.             }

  2172.             if(dst){

  2173.                 uint8_t *dst2 = dst + s->picture_ptr->linesize[index]*(h-1);

  2174.                 for (i=0; i<h/2; i++) {

  2175.                     for (j=0; j<w; j++)

  2176.                         FFSWAP(int, dst[j], dst2[j]);

  2177.                     dst  += s->picture_ptr->linesize[index];

  2178.                     dst2 -= s->picture_ptr->linesize[index];

  2179.                 }

  2180.             }

  2181.         }

  2182.     }

  2183.     if (s->adobe_transform == 0 && s->avctx->pix_fmt == AV_PIX_FMT_GBRAP) {

  2184.         int w = s->picture_ptr->width;

  2185.         int h = s->picture_ptr->height;

  2186.         for (i=0; i<h; i++) {

  2187.             int j;

  2188.             uint8_t *dst[4];

  2189.             for (index=0; index<4; index++) {

  2190.                 dst[index] =   s->picture_ptr->data[index]

  2191.                              + s->picture_ptr->linesize[index]*i;

  2192.             }

  2193.             for (j=0; j<w; j++) {

  2194.                 int k = dst[3][j];

  2195.                 int r = dst[0][j] * k;

  2196.                 int g = dst[1][j] * k;

  2197.                 int b = dst[2][j] * k;

  2198.                 dst[0][j] = g*257 >> 16;

  2199.                 dst[1][j] = b*257 >> 16;

  2200.                 dst[2][j] = r*257 >> 16;

  2201.                 dst[3][j] = 255;

  2202.             }

  2203.         }

  2204.     }

  2205.     if (s->adobe_transform == 2 && s->avctx->pix_fmt == AV_PIX_FMT_YUVA444P) {

  2206.         int w = s->picture_ptr->width;

  2207.         int h = s->picture_ptr->height;

  2208.         for (i=0; i<h; i++) {

  2209.             int j;

  2210.             uint8_t *dst[4];

  2211.             for (index=0; index<4; index++) {

  2212.                 dst[index] =   s->picture_ptr->data[index]

  2213.                              + s->picture_ptr->linesize[index]*i;

  2214.             }

  2215.             for (j=0; j<w; j++) {

  2216.                 int k = dst[3][j];

  2217.                 int r = (255 - dst[0][j]) * k;

  2218.                 int g = (128 - dst[1][j]) * k;

  2219.                 int b = (128 - dst[2][j]) * k;

  2220.                 dst[0][j] = r*257 >> 16;

  2221.                 dst[1][j] = (g*257 >> 16) + 128;

  2222.                 dst[2][j] = (b*257 >> 16) + 128;

  2223.                 dst[3][j] = 255;

  2224.             }

  2225.         }

  2226.     }

  2227. 

  2228.     if (s->stereo3d) {

  2229.         AVStereo3D *stereo = av_stereo3d_create_side_data(data);

  2230.         if (stereo) {

  2231.             stereo->type  = s->stereo3d->type;

  2232.             stereo->flags = s->stereo3d->flags;

  2233.         }

  2234.         av_freep(&s->stereo3d);

  2235.     }

  2236. 

  2237.     av_dict_copy(avpriv_frame_get_metadatap(data), s->exif_metadata, 0);

  2238.     av_dict_free(&s->exif_metadata);

  2239. 

  2240.     av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n",

  2241.            buf_end - buf_ptr);

  2242. //  return buf_end - buf_ptr;

  2243.     return buf_ptr - buf;

  2244. }

  2245. 

  2246. av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)

  2247. {

  2248.     MJpegDecodeContext *s = avctx->priv_data;

  2249.     int i, j;

  2250. 

  2251.     if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_number) {

  2252.         av_log(avctx, AV_LOG_INFO, "Single field\n");

  2253.     }

  2254. 

  2255.     if (s->picture) {

  2256.         av_frame_free(&s->picture);

  2257.         s->picture_ptr = NULL;

  2258.     } else if (s->picture_ptr)

  2259.         av_frame_unref(s->picture_ptr);

  2260. 

  2261.     av_freep(&s->buffer);

  2262.     av_freep(&s->stereo3d);

  2263.     av_freep(&s->ljpeg_buffer);

  2264.     s->ljpeg_buffer_size = 0;

  2265. 

  2266.     for (i = 0; i < 3; i++) {

  2267.         for (j = 0; j < 4; j++)

  2268.             ff_free_vlc(&s->vlcs[i][j]);

  2269.     }

  2270.     for (i = 0; i < MAX_COMPONENTS; i++) {

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

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

  2273.     }

  2274.     av_dict_free(&s->exif_metadata);

  2275.     return 0;

  2276. }

  2277. 

  2278. static void decode_flush(AVCodecContext *avctx)

  2279. {

  2280.     MJpegDecodeContext *s = avctx->priv_data;

  2281.     s->got_picture = 0;

  2282. }

  2283. 

  2284. #if CONFIG_MJPEG_DECODER

  2285. #define OFFSET(x) offsetof(MJpegDecodeContext, x)

  2286. #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM

  2287. static const AVOption options[] = {

  2288.     { "extern_huff", "Use external huffman table.",

  2289.       OFFSET(extern_huff), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VD },

  2290.     { NULL },

  2291. };

  2292. 

  2293. static const AVClass mjpegdec_class = {

  2294.     .class_name = "MJPEG decoder",

  2295.     .item_name  = av_default_item_name,

  2296.     .option     = options,

  2297.     .version    = LIBAVUTIL_VERSION_INT,

  2298. };

  2299. 

  2300. AVCodec ff_mjpeg_decoder = {

  2301.     .name           = "mjpeg",

  2302.     .long_name      = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),

  2303.     .type           = AVMEDIA_TYPE_VIDEO,

  2304.     .id             = AV_CODEC_ID_MJPEG,

  2305.     .priv_data_size = sizeof(MJpegDecodeContext),

  2306.     .init           = ff_mjpeg_decode_init,

  2307.     .close          = ff_mjpeg_decode_end,

  2308.     .decode         = ff_mjpeg_decode_frame,

  2309.     .flush          = decode_flush,

  2310.     .capabilities   = CODEC_CAP_DR1,

  2311.     .max_lowres     = 3,

  2312.     .priv_class     = &mjpegdec_class,

  2313. };

  2314. #endif

  2315. #if CONFIG_THP_DECODER

  2316. AVCodec ff_thp_decoder = {

  2317.     .name           = "thp",

  2318.     .long_name      = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),

  2319.     .type           = AVMEDIA_TYPE_VIDEO,

  2320.     .id             = AV_CODEC_ID_THP,

  2321.     .priv_data_size = sizeof(MJpegDecodeContext),

  2322.     .init           = ff_mjpeg_decode_init,

  2323.     .close          = ff_mjpeg_decode_end,

  2324.     .decode         = ff_mjpeg_decode_frame,

  2325.     .flush          = decode_flush,

  2326.     .capabilities   = CODEC_CAP_DR1,

  2327.     .max_lowres     = 3,

  2328. };

  2329. #endif