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

1937 lines
67KB
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 "copy_block.h"

  38. #include "dsputil.h"

  39. #include "internal.h"

  40. #include "mjpeg.h"

  41. #include "mjpegdec.h"

  42. #include "jpeglsdec.h"

  43. 

  44. 

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

  46.                      const uint8_t *val_table, int nb_codes,

  47.                      int use_static, int is_ac)

  48. {

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

  50.     uint16_t huff_code[256];

  51.     uint16_t huff_sym[256];

  52.     int i;

  53. 

  54.     av_assert0(nb_codes <= 256);

  55. 

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

  57. 

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

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

  60. 

  61.     if (is_ac)

  62.         huff_sym[0] = 16 * 256;

  63. 

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

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

  66. }

  67. 

  68. static void build_basic_mjpeg_vlc(MJpegDecodeContext *s)

  69. {

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

  71.               avpriv_mjpeg_val_dc, 12, 0, 0);

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

  73.               avpriv_mjpeg_val_dc, 12, 0, 0);

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

  75.               avpriv_mjpeg_val_ac_luminance, 251, 0, 1);

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

  77.               avpriv_mjpeg_val_ac_chrominance, 251, 0, 1);

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

  79.               avpriv_mjpeg_val_ac_luminance, 251, 0, 0);

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

  81.               avpriv_mjpeg_val_ac_chrominance, 251, 0, 0);

  82. }

  83. 

  84. av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)

  85. {

  86.     MJpegDecodeContext *s = avctx->priv_data;

  87. 

  88.     if (!s->picture_ptr)

  89.         s->picture_ptr = &s->picture;

  90.     avcodec_get_frame_defaults(&s->picture);

  91. 

  92.     s->avctx = avctx;

  93.     ff_dsputil_init(&s->dsp, avctx);

  94.     ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct);

  95.     s->buffer_size   = 0;

  96.     s->buffer        = NULL;

  97.     s->start_code    = -1;

  98.     s->first_picture = 1;

  99.     s->got_picture   = 0;

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

  101.     avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;

  102. 

  103.     build_basic_mjpeg_vlc(s);

  104. 

  105.     if (s->extern_huff) {

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

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

  108.         if (ff_mjpeg_decode_dht(s)) {

  109.             av_log(avctx, AV_LOG_ERROR,

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

  111.             build_basic_mjpeg_vlc(s);

  112.         }

  113.     }

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

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

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

  117.     }

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

  119.         s->flipped = 1;

  120. 

  121.     return 0;

  122. }

  123. 

  124. 

  125. /* quantize tables */

  126. int ff_mjpeg_decode_dqt(MJpegDecodeContext *s)

  127. {

  128.     int len, index, i, j;

  129. 

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

  131. 

  132.     while (len >= 65) {

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

  134.         if (pr > 1) {

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

  136.             return AVERROR_INVALIDDATA;

  137.         }

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

  139.         if (index >= 4)

  140.             return -1;

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

  142.         /* read quant table */

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

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

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

  146.         }

  147. 

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

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

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

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

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

  153.         len -= 65;

  154.     }

  155.     return 0;

  156. }

  157. 

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

  159. int ff_mjpeg_decode_dht(MJpegDecodeContext *s)

  160. {

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

  162.     uint8_t bits_table[17];

  163.     uint8_t val_table[256];

  164.     int ret = 0;

  165. 

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

  167. 

  168.     while (len > 0) {

  169.         if (len < 17)

  170.             return AVERROR_INVALIDDATA;

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

  172.         if (class >= 2)

  173.             return AVERROR_INVALIDDATA;

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

  175.         if (index >= 4)

  176.             return AVERROR_INVALIDDATA;

  177.         n = 0;

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

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

  180.             n += bits_table[i];

  181.         }

  182.         len -= 17;

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

  184.             return AVERROR_INVALIDDATA;

  185. 

  186.         code_max = 0;

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

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

  189.             if (v > code_max)

  190.                 code_max = v;

  191.             val_table[i] = v;

  192.         }

  193.         len -= n;

  194. 

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

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

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

  198.                class, index, code_max + 1);

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

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

  201.             return ret;

  202. 

  203.         if (class > 0) {

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

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

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

  207.                 return ret;

  208.         }

  209.     }

  210.     return 0;

  211. }

  212. 

  213. int ff_mjpeg_decode_sof(MJpegDecodeContext *s)

  214. {

  215.     int len, nb_components, i, width, height, pix_fmt_id;

  216.     int h_count[MAX_COMPONENTS];

  217.     int v_count[MAX_COMPONENTS];

  218. 

  219.     s->cur_scan = 0;

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

  221. 

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

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

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

  225. 

  226.     if (s->pegasus_rct)

  227.         s->bits = 9;

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

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

  230. 

  231.     if (s->bits != 8 && !s->lossless) {

  232.         av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");

  233.         return -1;

  234.     }

  235. 

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

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

  238.         return -1;

  239.     }

  240. 

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

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

  243. 

  244.     // HACK for odd_height.mov

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

  246.         height= s->height;

  247. 

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

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

  250.         return AVERROR_INVALIDDATA;

  251. 

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

  253.     if (nb_components <= 0 ||

  254.         nb_components > MAX_COMPONENTS)

  255.         return -1;

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

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

  258.             av_log(s->avctx, AV_LOG_ERROR, "nb_components changing in interlaced picture\n");

  259.             return AVERROR_INVALIDDATA;

  260.         }

  261.     }

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

  263.         av_log_missing_feature(s->avctx,

  264.                                "For JPEG-LS anything except <= 8 bits/component"

  265.                                " or 16-bit gray", 0);

  266.         return AVERROR_PATCHWELCOME;

  267.     }

  268.     s->nb_components = nb_components;

  269.     s->h_max         = 1;

  270.     s->v_max         = 1;

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

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

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

  274.         /* component id */

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

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

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

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

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

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

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

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

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

  284.             av_log(s->avctx, AV_LOG_ERROR, "h/v_count is 0\n");

  285.             return -1;

  286.         }

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

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

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

  290.             return AVERROR_INVALIDDATA;

  291.         }

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

  293.                i, h_count[i], v_count[i],

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

  295.     }

  296. 

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

  298.         av_log_missing_feature(s->avctx, "Subsampling in JPEG-LS", 0);

  299.         return AVERROR_PATCHWELCOME;

  300.     }

  301. 

  302.     if (s->v_max == 1 && s->h_max == 1 && s->lossless==1 && nb_components==3)

  303.         s->rgb = 1;

  304.     else if (!s->lossless)

  305.         s->rgb = 0;

  306. 

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

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

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

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

  311.         av_freep(&s->qscale_table);

  312. 

  313.         s->width      = width;

  314.         s->height     = height;

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

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

  317.         s->interlaced = 0;

  318.         s->got_picture = 0;

  319. 

  320.         /* test interlaced mode */

  321.         if (s->first_picture   &&

  322.             s->org_height != 0 &&

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

  324.             s->interlaced                    = 1;

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

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

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

  328.             height *= 2;

  329.         }

  330. 

  331.         avcodec_set_dimensions(s->avctx, width, height);

  332. 

  333.         s->qscale_table  = av_mallocz((s->width + 15) / 16);

  334.         s->first_picture = 0;

  335.     }

  336. 

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

  338.         if (s->progressive) {

  339.             av_log_ask_for_sample(s->avctx, "progressively coded interlaced pictures not supported\n");

  340.             return AVERROR_INVALIDDATA;

  341.         }

  342.     } else{

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

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

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

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

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

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

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

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

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

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

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

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

  355. 

  356.     switch (pix_fmt_id) {

  357.     case 0x11111100:

  358.         if (s->rgb)

  359.             s->avctx->pix_fmt = AV_PIX_FMT_BGR24;

  360.         else {

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

  362.                 s->avctx->pix_fmt = AV_PIX_FMT_GBR24P;

  363.             } else {

  364.             s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;

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

  366.             }

  367.         }

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

  369.         break;

  370.     case 0x12121100:

  371.     case 0x22122100:

  372.         s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;

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

  374.         s->upscale_v = 2;

  375.         s->upscale_h = (pix_fmt_id == 0x22122100);

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

  377.         break;

  378.     case 0x21211100:

  379.     case 0x22211200:

  380.         s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;

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

  382.         s->upscale_v = (pix_fmt_id == 0x22211200);

  383.         s->upscale_h = 2;

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

  385.         break;

  386.     case 0x22221100:

  387.         s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;

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

  389.         s->upscale_v = 2;

  390.         s->upscale_h = 2;

  391.         s->chroma_height = s->height / 2;

  392.         break;

  393.     case 0x11000000:

  394.     case 0x13000000:

  395.     case 0x14000000:

  396.     case 0x31000000:

  397.     case 0x33000000:

  398.     case 0x34000000:

  399.     case 0x41000000:

  400.     case 0x43000000:

  401.     case 0x44000000:

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

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

  404.         else

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

  406.         break;

  407.     case 0x12111100:

  408.     case 0x22211100:

  409.     case 0x22112100:

  410.         s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV440P : AV_PIX_FMT_YUVJ440P;

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

  412.         s->upscale_h = (pix_fmt_id == 0x22211100) * 2 + (pix_fmt_id == 0x22112100);

  413.         s->chroma_height = s->height / 2;

  414.         break;

  415.     case 0x21111100:

  416.         s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;

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

  418.         break;

  419.     case 0x22121100:

  420.     case 0x22111200:

  421.         s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;

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

  423.         s->upscale_v = (pix_fmt_id == 0x22121100) + 1;

  424.         break;

  425.     case 0x22111100:

  426.         s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUVJ420P;

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

  428.         break;

  429.     default:

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

  431.         return AVERROR_PATCHWELCOME;

  432.     }

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

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

  435.         return AVERROR_PATCHWELCOME;

  436.     }

  437.     if (s->ls) {

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

  439.         if (s->nb_components > 1)

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

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

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

  443.         else

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

  445.     }

  446. 

  447.     if (s->picture_ptr->data[0])

  448.         s->avctx->release_buffer(s->avctx, s->picture_ptr);

  449. 

  450.     if (ff_get_buffer(s->avctx, s->picture_ptr) < 0) {

  451.         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");

  452.         return -1;

  453.     }

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

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

  456.     s->got_picture            = 1;

  457. 

  458.     for (i = 0; i < 3; i++)

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

  460. 

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

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

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

  464. 

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

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

  467.     }

  468. 

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

  470.     if (s->progressive) {

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

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

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

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

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

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

  477.             s->blocks[i]       = av_malloc(size * sizeof(**s->blocks));

  478.             s->last_nnz[i]     = av_mallocz(size * sizeof(**s->last_nnz));

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

  480.         }

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

  482.     }

  483.     return 0;

  484. }

  485. 

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

  487. {

  488.     int code;

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

  490.     if (code < 0) {

  491.         av_log(s->avctx, AV_LOG_WARNING,

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

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

  494.         return 0xffff;

  495.     }

  496. 

  497.     if (code)

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

  499.     else

  500.         return 0;

  501. }

  502. 

  503. /* decode block and dequantize */

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

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

  506. {

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

  508. 

  509.     /* DC coef */

  510.     val = mjpeg_decode_dc(s, dc_index);

  511.     if (val == 0xffff) {

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

  513.         return AVERROR_INVALIDDATA;

  514.     }

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

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

  517.     block[0] = val;

  518.     /* AC coefs */

  519.     i = 0;

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

  521.     do {

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

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

  524. 

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

  526.             code &= 0xf;

  527.         if (code) {

  528.             if (code > MIN_CACHE_BITS - 16)

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

  530. 

  531.             {

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

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

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

  535.             }

  536. 

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

  538. 

  539.             if (i > 63) {

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

  541.                 return AVERROR_INVALIDDATA;

  542.             }

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

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

  545.         }

  546.     } while (i < 63);

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

  548. 

  549.     return 0;

  550. }

  551. 

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

  553.                                  int component, int dc_index,

  554.                                  int16_t *quant_matrix, int Al)

  555. {

  556.     int val;

  557.     s->dsp.clear_block(block);

  558.     val = mjpeg_decode_dc(s, dc_index);

  559.     if (val == 0xffff) {

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

  561.         return AVERROR_INVALIDDATA;

  562.     }

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

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

  565.     block[0] = val;

  566.     return 0;

  567. }

  568. 

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

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

  571.                                     uint8_t *last_nnz, int ac_index,

  572.                                     int16_t *quant_matrix,

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

  574. {

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

  576. 

  577.     if (*EOBRUN) {

  578.         (*EOBRUN)--;

  579.         return 0;

  580.     }

  581. 

  582.     {

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

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

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

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

  587. 

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

  589.             code &= 0xF;

  590.             if (code) {

  591.                 i += run;

  592.                 if (code > MIN_CACHE_BITS - 16)

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

  594. 

  595.                 {

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

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

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

  599.                 }

  600. 

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

  602. 

  603.                 if (i >= se) {

  604.                     if (i == se) {

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

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

  607.                         break;

  608.                     }

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

  610.                     return AVERROR_INVALIDDATA;

  611.                 }

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

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

  614.             } else {

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

  616.                     i += 15;

  617.                     if (i >= se) {

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

  619.                         return AVERROR_INVALIDDATA;

  620.                     }

  621.                 } else {

  622.                     val = (1 << run);

  623.                     if (run) {

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

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

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

  627.                     }

  628.                     *EOBRUN = val - 1;

  629.                     break;

  630.                 }

  631.             }

  632.         }

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

  634.     }

  635. 

  636.     if (i > *last_nnz)

  637.         *last_nnz = i;

  638. 

  639.     return 0;

  640. }

  641. 

  642. #define REFINE_BIT(j) {                                             \

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

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

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

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

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

  648. }

  649. 

  650. #define ZERO_RUN                                                    \

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

  652.     if (i > last) {                                                 \

  653.         i += run;                                                   \

  654.         if (i > se) {                                               \

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

  656.             return -1;                                              \

  657.         }                                                           \

  658.         break;                                                      \

  659.     }                                                               \

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

  661.     if (block[j])                                                   \

  662.         REFINE_BIT(j)                                               \

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

  664.         break;                                                      \

  665. }

  666. 

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

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

  669.                                    uint8_t *last_nnz,

  670.                                    int ac_index, int16_t *quant_matrix,

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

  672. {

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

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

  675. 

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

  677.     if (*EOBRUN) {

  678.         (*EOBRUN)--;

  679.     } else {

  680.         for (; ; i++) {

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

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

  683. 

  684.             if (code & 0xF) {

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

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

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

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

  689.                 ZERO_RUN;

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

  691.                 val--;

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

  693.                 if (i == se) {

  694.                     if (i > *last_nnz)

  695.                         *last_nnz = i;

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

  697.                     return 0;

  698.                 }

  699.             } else {

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

  701.                 if (run == 0xF) {

  702.                     ZERO_RUN;

  703.                 } else {

  704.                     val = run;

  705.                     run = (1 << run);

  706.                     if (val) {

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

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

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

  710.                     }

  711.                     *EOBRUN = run - 1;

  712.                     break;

  713.                 }

  714.             }

  715.         }

  716. 

  717.         if (i > *last_nnz)

  718.             *last_nnz = i;

  719.     }

  720. 

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

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

  723.         if (block[j])

  724.             REFINE_BIT(j)

  725.     }

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

  727. 

  728.     return 0;

  729. }

  730. #undef REFINE_BIT

  731. #undef ZERO_RUN

  732. 

  733. static void handle_rstn(MJpegDecodeContext *s, int nb_components)

  734. {

  735.     int i;

  736.     if (s->restart_interval) {

  737.         s->restart_count--;

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

  739.             align_get_bits(&s->gb);

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

  741.                 s->last_dc[i] = 1024;

  742.         }

  743. 

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

  745.         /* skip RSTn */

  746.         if (s->restart_count == 0 && show_bits(&s->gb, i) == (1 << i) - 1) {

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

  748.             align_get_bits(&s->gb);

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

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

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

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

  753.                     s->last_dc[i] = 1024;

  754.             } else

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

  756.         }

  757.     }

  758. }

  759. 

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

  761. {

  762.     int i, mb_x, mb_y;

  763.     uint16_t (*buffer)[4];

  764.     int left[3], top[3], topleft[3];

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

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

  767.     int resync_mb_y = 0;

  768.     int resync_mb_x = 0;

  769. 

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

  771. 

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

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

  774.     buffer = s->ljpeg_buffer;

  775. 

  776.     for (i = 0; i < 3; i++)

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

  778. 

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

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

  781. 

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

  783.             ptr += linesize >> 1;

  784. 

  785.         for (i = 0; i < 3; i++)

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

  787. 

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

  789.             int modified_predictor = predictor;

  790. 

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

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

  793.                 resync_mb_x = mb_x;

  794.                 resync_mb_y = mb_y;

  795.                 for(i=0; i<3; i++)

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

  797.             }

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

  799.                 modified_predictor = 1;

  800. 

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

  802.                 int pred, dc;

  803. 

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

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

  806. 

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

  808. 

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

  810.                 if(dc == 0xFFFF)

  811.                     return -1;

  812. 

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

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

  815.             }

  816. 

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

  818.                 align_get_bits(&s->gb);

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

  820.             }

  821.         }

  822. 

  823.         if (s->rct) {

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

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

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

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

  828.             }

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

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

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

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

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

  834.             }

  835.         } else {

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

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

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

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

  840.                 }

  841.             }

  842.         }

  843.     }

  844.     return 0;

  845. }

  846. 

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

  848.                                  int point_transform)

  849. {

  850.     int i, mb_x, mb_y;

  851.     const int nb_components=s->nb_components;

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

  853.     int resync_mb_y = 0;

  854.     int resync_mb_x = 0;

  855. 

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

  857. 

  858.     av_assert0(nb_components>=1 && nb_components<=3);

  859. 

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

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

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

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

  864.                 resync_mb_x = mb_x;

  865.                 resync_mb_y = mb_y;

  866.             }

  867. 

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

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

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

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

  872.                     uint8_t *ptr;

  873.                     uint16_t *ptr16;

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

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

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

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

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

  879.                     x = 0;

  880.                     y = 0;

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

  882. 

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

  884. 

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

  886.                         int pred, dc;

  887. 

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

  889.                         if(dc == 0xFFFF)

  890.                             return -1;

  891.                         if(bits<=8){

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

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

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

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

  896.                             }else{

  897.                                 pred= ptr[-1];

  898.                             }

  899.                         }else{

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

  901.                                 pred= ptr[-linesize];

  902.                             }else{

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

  904.                             }

  905.                         }

  906. 

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

  908.                             ptr += linesize >> 1;

  909.                         pred &= (-1)<<(8-s->bits);

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

  911.                         }else{

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

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

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

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

  916.                                 }else{

  917.                                     pred= ptr16[-1];

  918.                                 }

  919.                             }else{

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

  921.                                     pred= ptr16[-linesize];

  922.                                 }else{

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

  924.                                 }

  925.                             }

  926. 

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

  928.                                 ptr16 += linesize >> 1;

  929.                             pred &= (-1)<<(16-s->bits);

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

  931.                         }

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

  933.                             x = 0;

  934.                             y++;

  935.                         }

  936.                     }

  937.                 }

  938.             } else {

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

  940.                     uint8_t *ptr;

  941.                     uint16_t *ptr16;

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

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

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

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

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

  947.                     x        = 0;

  948.                     y        = 0;

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

  950. 

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

  952. 

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

  954.                         int pred;

  955. 

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

  957.                         if(dc == 0xFFFF)

  958.                             return -1;

  959.                         if(bits<=8){

  960.                             ptr = s->picture.data[c] +

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

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

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

  964. 

  965.                             pred &= (-1)<<(8-s->bits);

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

  967.                         }else{

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

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

  970. 

  971.                             pred &= (-1)<<(16-s->bits);

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

  973.                         }

  974. 

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

  976.                             x = 0;

  977.                             y++;

  978.                         }

  979.                     }

  980.                 }

  981.             }

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

  983.                 align_get_bits(&s->gb);

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

  985.             }

  986.         }

  987.     }

  988.     return 0;

  989. }

  990. 

  991. static av_always_inline void mjpeg_copy_block(MJpegDecodeContext *s,

  992.                                               uint8_t *dst, const uint8_t *src,

  993.                                               int linesize, int lowres)

  994. {

  995.     switch (lowres) {

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

  997.         break;

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

  999.         break;

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

  1001.         break;

  1002.     case 3: *dst = *src;

  1003.         break;

  1004.     }

  1005. }

  1006. 

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

  1008.                              int Al, const uint8_t *mb_bitmask,

  1009.                              const AVFrame *reference)

  1010. {

  1011.     int i, mb_x, mb_y;

  1012.     uint8_t *data[MAX_COMPONENTS];

  1013.     const uint8_t *reference_data[MAX_COMPONENTS];

  1014.     int linesize[MAX_COMPONENTS];

  1015.     GetBitContext mb_bitmask_gb;

  1016. 

  1017.     if (mb_bitmask)

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

  1019. 

  1020.     if (s->flipped && s->avctx->lowres) {

  1021.         av_log(s->avctx, AV_LOG_ERROR, "Can not flip image with lowres\n");

  1022.         s->flipped = 0;

  1023.     }

  1024. 

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

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

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

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

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

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

  1031.         if (s->flipped && !(s->avctx->flags & CODEC_FLAG_EMU_EDGE)) {

  1032.             // picture should be flipped upside-down for this codec

  1033.             int offset = (linesize[c] * (s->v_scount[i] *

  1034.                          (8 * s->mb_height - ((s->height / s->v_max) & 7)) - 1));

  1035.             data[c]           += offset;

  1036.             reference_data[c] += offset;

  1037.             linesize[c]       *= -1;

  1038.         }

  1039.     }

  1040. 

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

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

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

  1044. 

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

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

  1047. 

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

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

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

  1051.                 return AVERROR_INVALIDDATA;

  1052.             }

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

  1054.                 uint8_t *ptr;

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

  1056.                 int block_offset;

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

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

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

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

  1061.                 x = 0;

  1062.                 y = 0;

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

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

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

  1066. 

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

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

  1069.                     ptr = data[c] + block_offset;

  1070.                     if (!s->progressive) {

  1071.                         if (copy_mb)

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

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

  1074. 

  1075.                         else {

  1076.                             s->dsp.clear_block(s->block);

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

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

  1079.                                              s->quant_matrixes[s->quant_index[c]]) < 0) {

  1080.                                 av_log(s->avctx, AV_LOG_ERROR,

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

  1082.                                 return AVERROR_INVALIDDATA;

  1083.                             }

  1084.                             s->dsp.idct_put(ptr, linesize[c], s->block);

  1085.                         }

  1086.                     } else {

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

  1088.                                          (h * mb_x + x);

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

  1090.                         if (Ah)

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

  1092.                                         s->quant_matrixes[s->quant_index[c]][0] << Al;

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

  1094.                                                        s->quant_matrixes[s->quant_index[c]],

  1095.                                                        Al) < 0) {

  1096.                             av_log(s->avctx, AV_LOG_ERROR,

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

  1098.                             return AVERROR_INVALIDDATA;

  1099.                         }

  1100.                     }

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

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

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

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

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

  1106.                         x = 0;

  1107.                         y++;

  1108.                     }

  1109.                 }

  1110.             }

  1111. 

  1112.             handle_rstn(s, nb_components);

  1113.         }

  1114.     }

  1115.     return 0;

  1116. }

  1117. 

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

  1119.                                             int se, int Ah, int Al)

  1120. {

  1121.     int mb_x, mb_y;

  1122.     int EOBRUN = 0;

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

  1124.     uint8_t *data = s->picture.data[c];

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

  1126.     int last_scan = 0;

  1127.     int16_t *quant_matrix = s->quant_matrixes[s->quant_index[c]];

  1128. 

  1129.     if (se > 63) {

  1130.         av_log(s->avctx, AV_LOG_ERROR, "SE %d is too large\n", se);

  1131.         return AVERROR_INVALIDDATA;

  1132.     }

  1133. 

  1134.     if (!Al) {

  1135.         s->coefs_finished[c] |= (1LL << (se + 1)) - (1LL << ss);

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

  1137.     }

  1138. 

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

  1140.         data += linesize >> 1;

  1141. 

  1142.     s->restart_count = 0;

  1143. 

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

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

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

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

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

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

  1150.                 int ret;

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

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

  1153. 

  1154.                 if (Ah)

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

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

  1157.                 else

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

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

  1160.                 if (ret < 0) {

  1161.                     av_log(s->avctx, AV_LOG_ERROR,

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

  1163.                     return AVERROR_INVALIDDATA;

  1164.                 }

  1165. 

  1166.             if (last_scan) {

  1167.                     s->dsp.idct_put(ptr, linesize, *block);

  1168.                     ptr += 8 >> s->avctx->lowres;

  1169.             }

  1170.             handle_rstn(s, 0);

  1171.         }

  1172.     }

  1173.     return 0;

  1174. }

  1175. 

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

  1177.                         const AVFrame *reference)

  1178. {

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

  1180.     int index, id, ret;

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

  1182.     int ilv, prev_shift;

  1183. 

  1184.     if (!s->got_picture) {

  1185.         av_log(s->avctx, AV_LOG_WARNING,

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

  1187.         return -1;

  1188.     }

  1189. 

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

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

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

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

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

  1195.         av_log(s->avctx, AV_LOG_ERROR,

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

  1197.         return AVERROR_PATCHWELCOME;

  1198.     }

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

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

  1201.         return AVERROR_INVALIDDATA;

  1202.     }

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

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

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

  1206.         /* find component index */

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

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

  1209.                 break;

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

  1211.             av_log(s->avctx, AV_LOG_ERROR,

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

  1213.             return AVERROR_INVALIDDATA;

  1214.         }

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

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

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

  1218.             index = 3 - i;

  1219. 

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

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

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

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

  1224. 

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

  1226. 

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

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

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

  1230. 

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

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

  1233. 

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

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

  1236.             goto out_of_range;

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

  1238.             goto out_of_range;

  1239.     }

  1240. 

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

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

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

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

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

  1246.     }else

  1247.         prev_shift = point_transform = 0;

  1248. 

  1249.     if (nb_components > 1) {

  1250.         /* interleaved stream */

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

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

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

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

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

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

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

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

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

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

  1261.     }

  1262. 

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

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

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

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

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

  1268. 

  1269. 

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

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

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

  1273. 

  1274. next_field:

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

  1276.         s->last_dc[i] = 1024;

  1277. 

  1278.     if (s->lossless) {

  1279.         av_assert0(s->picture_ptr == &s->picture);

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

  1281. //            for () {

  1282. //            reset_ls_coding_parameters(s, 0);

  1283. 

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

  1285.                                                 point_transform, ilv)) < 0)

  1286.                 return ret;

  1287.         } else {

  1288.             if (s->rgb) {

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

  1290.                     return ret;

  1291.             } else {

  1292.                 if ((ret = ljpeg_decode_yuv_scan(s, predictor, point_transform)) < 0)

  1293.                     return ret;

  1294.             }

  1295.         }

  1296.     } else {

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

  1298.             av_assert0(s->picture_ptr == &s->picture);

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

  1300.                                                         ilv, prev_shift,

  1301.                                                         point_transform)) < 0)

  1302.                 return ret;

  1303.         } else {

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

  1305.                                          prev_shift, point_transform,

  1306.                                          mb_bitmask, reference)) < 0)

  1307.                 return ret;

  1308.         }

  1309.     }

  1310. 

  1311.     if (s->interlaced &&

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

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

  1314.         GetBitContext bak = s->gb;

  1315.         align_get_bits(&bak);

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

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

  1318.             s->gb = bak;

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

  1320.             s->bottom_field ^= 1;

  1321. 

  1322.             goto next_field;

  1323.         }

  1324.     }

  1325. 

  1326.     emms_c();

  1327.     return 0;

  1328.  out_of_range:

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

  1330.     return AVERROR_INVALIDDATA;

  1331. }

  1332. 

  1333. static int mjpeg_decode_dri(MJpegDecodeContext *s)

  1334. {

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

  1336.         return AVERROR_INVALIDDATA;

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

  1338.     s->restart_count    = 0;

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

  1340.            s->restart_interval);

  1341. 

  1342.     return 0;

  1343. }

  1344. 

  1345. static int mjpeg_decode_app(MJpegDecodeContext *s)

  1346. {

  1347.     int len, id, i;

  1348. 

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

  1350.     if (len < 5)

  1351.         return AVERROR_INVALIDDATA;

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

  1353.         return AVERROR_INVALIDDATA;

  1354. 

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

  1356.     id   = av_be2ne32(id);

  1357.     len -= 6;

  1358. 

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

  1360.         av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);

  1361. 

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

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

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

  1365.     if (id == AV_RL32("AVI1")) {

  1366.         /* structure:

  1367.             4bytes      AVI1

  1368.             1bytes      polarity

  1369.             1bytes      always zero

  1370.             4bytes      field_size

  1371.             4bytes      field_size_less_padding

  1372.         */

  1373.             s->buggy_avid = 1;

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

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

  1376. #if 0

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

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

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

  1380.         len -= 10;

  1381. #endif

  1382.         goto out;

  1383.     }

  1384. 

  1385. //    len -= 2;

  1386. 

  1387.     if (id == AV_RL32("JFIF")) {

  1388.         int t_w, t_h, v1, v2;

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

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

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

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

  1393. 

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

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

  1396. 

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

  1398.             av_log(s->avctx, AV_LOG_INFO,

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

  1400.                    v1, v2,

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

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

  1403. 

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

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

  1406.         if (t_w && t_h) {

  1407.             /* skip thumbnail */

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

  1409.                 len -= t_w * t_h * 3;

  1410.         }

  1411.         len -= 10;

  1412.         goto out;

  1413.     }

  1414. 

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

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

  1417.             av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");

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

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

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

  1421.         skip_bits(&s->gb,  8); /* transform */

  1422.         len -= 7;

  1423.         goto out;

  1424.     }

  1425. 

  1426.     if (id == AV_RL32("LJIF")) {

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

  1428.             av_log(s->avctx, AV_LOG_INFO,

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

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

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

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

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

  1434.         switch (get_bits(&s->gb, 8)) {

  1435.         case 1:

  1436.             s->rgb         = 1;

  1437.             s->pegasus_rct = 0;

  1438.             break;

  1439.         case 2:

  1440.             s->rgb         = 1;

  1441.             s->pegasus_rct = 1;

  1442.             break;

  1443.         default:

  1444.             av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");

  1445.         }

  1446.         len -= 9;

  1447.         goto out;

  1448.     }

  1449. 

  1450.     /* Apple MJPEG-A */

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

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

  1453.         id   = av_be2ne32(id);

  1454.         len -= 4;

  1455.         /* Apple MJPEG-A */

  1456.         if (id == AV_RL32("mjpg")) {

  1457. #if 0

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

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

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

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

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

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

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

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

  1466. #endif

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

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

  1469.         }

  1470.     }

  1471. 

  1472. out:

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

  1474.     if (len < 0)

  1475.         av_log(s->avctx, AV_LOG_ERROR,

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

  1477.     while (--len > 0)

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

  1479. 

  1480.     return 0;

  1481. }

  1482. 

  1483. static int mjpeg_decode_com(MJpegDecodeContext *s)

  1484. {

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

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

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

  1488.         if (cbuf) {

  1489.             int i;

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

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

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

  1493.                 cbuf[i - 1] = 0;

  1494.             else

  1495.                 cbuf[i] = 0;

  1496. 

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

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

  1499. 

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

  1501.             if (!strcmp(cbuf, "AVID")) {

  1502.                 s->buggy_avid = 1;

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

  1504.                 s->cs_itu601 = 1;

  1505.             else if ((len > 31 && !strncmp(cbuf, "Intel(R) JPEG Library, version 1", 32)) ||

  1506.                      (len > 19 && !strncmp(cbuf, "Metasoft MJPEG Codec", 20)))

  1507.                 s->flipped = 1;

  1508. 

  1509.             av_free(cbuf);

  1510.         }

  1511.     }

  1512. 

  1513.     return 0;

  1514. }

  1515. 

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

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

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

  1519. {

  1520.     const uint8_t *buf_ptr;

  1521.     unsigned int v, v2;

  1522.     int val;

  1523.     int skipped = 0;

  1524. 

  1525.     buf_ptr = *pbuf_ptr;

  1526.     while (buf_ptr < buf_end) {

  1527.         v  = *buf_ptr++;

  1528.         v2 = *buf_ptr;

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

  1530.             val = *buf_ptr++;

  1531.             goto found;

  1532.         }

  1533.         skipped++;

  1534.     }

  1535.     val = -1;

  1536. found:

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

  1538.     *pbuf_ptr = buf_ptr;

  1539.     return val;

  1540. }

  1541. 

  1542. int ff_mjpeg_find_marker(MJpegDecodeContext *s,

  1543.                          const uint8_t **buf_ptr, const uint8_t *buf_end,

  1544.                          const uint8_t **unescaped_buf_ptr,

  1545.                          int *unescaped_buf_size)

  1546. {

  1547.     int start_code;

  1548.     start_code = find_marker(buf_ptr, buf_end);

  1549. 

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

  1551.     if (!s->buffer)

  1552.         return AVERROR(ENOMEM);

  1553. 

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

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

  1556.         const uint8_t *src = *buf_ptr;

  1557.         uint8_t *dst = s->buffer;

  1558. 

  1559.         while (src < buf_end) {

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

  1561. 

  1562.             *(dst++) = x;

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

  1564.                 if (x == 0xff) {

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

  1566.                         x = *(src++);

  1567. 

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

  1569.                         *(dst++) = x;

  1570.                     else if (x)

  1571.                         break;

  1572.                 }

  1573.             }

  1574.         }

  1575.         *unescaped_buf_ptr  = s->buffer;

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

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

  1578.                FF_INPUT_BUFFER_PADDING_SIZE);

  1579. 

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

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

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

  1583.         const uint8_t *src = *buf_ptr;

  1584.         uint8_t *dst  = s->buffer;

  1585.         int bit_count = 0;

  1586.         int t = 0, b = 0;

  1587.         PutBitContext pb;

  1588. 

  1589.         s->cur_scan++;

  1590. 

  1591.         /* find marker */

  1592.         while (src + t < buf_end) {

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

  1594.             if (x == 0xff) {

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

  1596.                     x = src[t++];

  1597.                 if (x & 0x80) {

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

  1599.                     break;

  1600.                 }

  1601.             }

  1602.         }

  1603.         bit_count = t * 8;

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

  1605. 

  1606.         /* unescape bitstream */

  1607.         while (b < t) {

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

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

  1610.             if (x == 0xFF) {

  1611.                 x = src[b++];

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

  1613.                 bit_count--;

  1614.             }

  1615.         }

  1616.         flush_put_bits(&pb);

  1617. 

  1618.         *unescaped_buf_ptr  = dst;

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

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

  1621.                FF_INPUT_BUFFER_PADDING_SIZE);

  1622.     } else {

  1623.         *unescaped_buf_ptr  = *buf_ptr;

  1624.         *unescaped_buf_size = buf_end - *buf_ptr;

  1625.     }

  1626. 

  1627.     return start_code;

  1628. }

  1629. 

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

  1631.                           AVPacket *avpkt)

  1632. {

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

  1634.     int buf_size       = avpkt->size;

  1635.     MJpegDecodeContext *s = avctx->priv_data;

  1636.     const uint8_t *buf_end, *buf_ptr;

  1637.     const uint8_t *unescaped_buf_ptr;

  1638.     int unescaped_buf_size;

  1639.     int start_code;

  1640.     int i, index;

  1641.     int ret = 0;

  1642.     AVFrame *picture = data;

  1643. 

  1644.     buf_ptr = buf;

  1645.     buf_end = buf + buf_size;

  1646.     while (buf_ptr < buf_end) {

  1647.         /* find start next marker */

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

  1649.                                           &unescaped_buf_ptr,

  1650.                                           &unescaped_buf_size);

  1651.         /* EOF */

  1652.         if (start_code < 0) {

  1653.             goto the_end;

  1654.         } else if (unescaped_buf_size > (1U<<28)) {

  1655.             av_log(avctx, AV_LOG_ERROR, "MJPEG packet 0x%x too big (0x%x/0x%x), corrupt data?\n",

  1656.                    start_code, unescaped_buf_size, buf_size);

  1657.             return AVERROR_INVALIDDATA;

  1658.         } else {

  1659.             av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%td\n",

  1660.                    start_code, buf_end - buf_ptr);

  1661. 

  1662.             init_get_bits(&s->gb, unescaped_buf_ptr, unescaped_buf_size * 8);

  1663. 

  1664.             s->start_code = start_code;

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

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

  1667. 

  1668.             /* process markers */

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

  1670.                 av_log(avctx, AV_LOG_DEBUG,

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

  1672.                 /* APP fields */

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

  1674.                 mjpeg_decode_app(s);

  1675.                 /* Comment */

  1676.             else if (start_code == COM)

  1677.                 mjpeg_decode_com(s);

  1678. 

  1679.             ret = -1;

  1680.             switch (start_code) {

  1681.             case SOI:

  1682.                 s->restart_interval = 0;

  1683.                 s->restart_count    = 0;

  1684.                 /* nothing to do on SOI */

  1685.                 break;

  1686.             case DQT:

  1687.                 ff_mjpeg_decode_dqt(s);

  1688.                 break;

  1689.             case DHT:

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

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

  1692.                     goto fail;

  1693.                 }

  1694.                 break;

  1695.             case SOF0:

  1696.             case SOF1:

  1697.                 s->lossless    = 0;

  1698.                 s->ls          = 0;

  1699.                 s->progressive = 0;

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

  1701.                     goto fail;

  1702.                 break;

  1703.             case SOF2:

  1704.                 s->lossless    = 0;

  1705.                 s->ls          = 0;

  1706.                 s->progressive = 1;

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

  1708.                     goto fail;

  1709.                 break;

  1710.             case SOF3:

  1711.                 s->lossless    = 1;

  1712.                 s->ls          = 0;

  1713.                 s->progressive = 0;

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

  1715.                     goto fail;

  1716.                 break;

  1717.             case SOF48:

  1718.                 s->lossless    = 1;

  1719.                 s->ls          = 1;

  1720.                 s->progressive = 0;

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

  1722.                     goto fail;

  1723.                 break;

  1724.             case LSE:

  1725.                 if (!CONFIG_JPEGLS_DECODER ||

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

  1727.                     goto fail;

  1728.                 break;

  1729.             case EOI:

  1730. eoi_parser:

  1731.                 s->cur_scan = 0;

  1732.                 if (!s->got_picture) {

  1733.                     av_log(avctx, AV_LOG_WARNING,

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

  1735.                     break;

  1736.                 }

  1737.                 if (s->interlaced) {

  1738.                     s->bottom_field ^= 1;

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

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

  1741.                         break;

  1742.                 }

  1743.                 *picture   = *s->picture_ptr;

  1744.                 *got_frame = 1;

  1745.                 s->got_picture = 0;

  1746. 

  1747.                 if (!s->lossless) {

  1748.                     picture->quality      = FFMAX3(s->qscale[0],

  1749.                                                    s->qscale[1],

  1750.                                                    s->qscale[2]);

  1751.                     picture->qstride      = 0;

  1752.                     picture->qscale_table = s->qscale_table;

  1753.                     memset(picture->qscale_table, picture->quality,

  1754.                            (s->width + 15) / 16);

  1755.                     if (avctx->debug & FF_DEBUG_QP)

  1756.                         av_log(avctx, AV_LOG_DEBUG,

  1757.                                "QP: %d\n", picture->quality);

  1758.                     picture->quality *= FF_QP2LAMBDA;

  1759.                 }

  1760. 

  1761.                 goto the_end;

  1762.             case SOS:

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

  1764.                     (avctx->err_recognition & AV_EF_EXPLODE))

  1765.                     goto fail;

  1766.                 break;

  1767.             case DRI:

  1768.                 mjpeg_decode_dri(s);

  1769.                 break;

  1770.             case SOF5:

  1771.             case SOF6:

  1772.             case SOF7:

  1773.             case SOF9:

  1774.             case SOF10:

  1775.             case SOF11:

  1776.             case SOF13:

  1777.             case SOF14:

  1778.             case SOF15:

  1779.             case JPG:

  1780.                 av_log(avctx, AV_LOG_ERROR,

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

  1782.                 break;

  1783.             }

  1784. 

  1785.             /* eof process start code */

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

  1787.             av_log(avctx, AV_LOG_DEBUG,

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

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

  1790.         }

  1791.     }

  1792.     if (s->got_picture) {

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

  1794.         goto eoi_parser;

  1795.     }

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

  1797.     return AVERROR_INVALIDDATA;

  1798. fail:

  1799.     s->got_picture = 0;

  1800.     return ret;

  1801. the_end:

  1802.     if (s->upscale_h) {

  1803.         uint8_t *line = s->picture_ptr->data[s->upscale_h];

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

  1805.                    avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||

  1806.                    avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||

  1807.                    avctx->pix_fmt == AV_PIX_FMT_YUV440P);

  1808.         for (i = 0; i < s->chroma_height; i++) {

  1809.             for (index = s->width - 1; index; index--)

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

  1811.             line += s->linesize[s->upscale_h];

  1812.         }

  1813.     }

  1814.     if (s->upscale_v) {

  1815.         uint8_t *dst = &((uint8_t *)s->picture_ptr->data[s->upscale_v])[(s->height - 1) * s->linesize[s->upscale_v]];

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

  1817.                    avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||

  1818.                    avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||

  1819.                    avctx->pix_fmt == AV_PIX_FMT_YUV422P);

  1820.         for (i = s->height - 1; i; i--) {

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

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

  1823.             if (src1 == src2) {

  1824.                 memcpy(dst, src1, s->width);

  1825.             } else {

  1826.                 for (index = 0; index < s->width; index++)

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

  1828.             }

  1829.             dst -= s->linesize[s->upscale_v];

  1830.         }

  1831.     }

  1832.     if (s->flipped && (s->avctx->flags & CODEC_FLAG_EMU_EDGE)) {

  1833.         int hshift, vshift, j;

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

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

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

  1837.             int w = s->width;

  1838.             int h = s->height;

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

  1840.                 w = -((-w) >> hshift);

  1841.                 h = -((-h) >> vshift);

  1842.             }

  1843.             if(dst){

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

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

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

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

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

  1849.                     dst2 -= s->linesize[index];

  1850.                 }

  1851.             }

  1852.         }

  1853.     }

  1854. 

  1855.     av_log(avctx, AV_LOG_DEBUG, "decode frame unused %td bytes\n",

  1856.            buf_end - buf_ptr);

  1857. //  return buf_end - buf_ptr;

  1858.     return buf_ptr - buf;

  1859. }

  1860. 

  1861. av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)

  1862. {

  1863.     MJpegDecodeContext *s = avctx->priv_data;

  1864.     int i, j;

  1865. 

  1866.     if (s->picture_ptr && s->picture_ptr->data[0])

  1867.         avctx->release_buffer(avctx, s->picture_ptr);

  1868. 

  1869.     av_free(s->buffer);

  1870.     av_free(s->qscale_table);

  1871.     av_freep(&s->ljpeg_buffer);

  1872.     s->ljpeg_buffer_size = 0;

  1873. 

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

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

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

  1877.     }

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

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

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

  1881.     }

  1882.     return 0;

  1883. }

  1884. 

  1885. static void decode_flush(AVCodecContext *avctx)

  1886. {

  1887.     MJpegDecodeContext *s = avctx->priv_data;

  1888.     s->got_picture = 0;

  1889. }

  1890. 

  1891. #if CONFIG_MJPEG_DECODER

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

  1893. #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM

  1894. static const AVOption options[] = {

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

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

  1897.     { NULL },

  1898. };

  1899. 

  1900. static const AVClass mjpegdec_class = {

  1901.     .class_name = "MJPEG decoder",

  1902.     .item_name  = av_default_item_name,

  1903.     .option     = options,

  1904.     .version    = LIBAVUTIL_VERSION_INT,

  1905. };

  1906. 

  1907. AVCodec ff_mjpeg_decoder = {

  1908.     .name           = "mjpeg",

  1909.     .type           = AVMEDIA_TYPE_VIDEO,

  1910.     .id             = AV_CODEC_ID_MJPEG,

  1911.     .priv_data_size = sizeof(MJpegDecodeContext),

  1912.     .init           = ff_mjpeg_decode_init,

  1913.     .close          = ff_mjpeg_decode_end,

  1914.     .decode         = ff_mjpeg_decode_frame,

  1915.     .flush          = decode_flush,

  1916.     .capabilities   = CODEC_CAP_DR1,

  1917.     .max_lowres     = 3,

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

  1919.     .priv_class     = &mjpegdec_class,

  1920. };

  1921. #endif

  1922. #if CONFIG_THP_DECODER

  1923. AVCodec ff_thp_decoder = {

  1924.     .name           = "thp",

  1925.     .type           = AVMEDIA_TYPE_VIDEO,

  1926.     .id             = AV_CODEC_ID_THP,

  1927.     .priv_data_size = sizeof(MJpegDecodeContext),

  1928.     .init           = ff_mjpeg_decode_init,

  1929.     .close          = ff_mjpeg_decode_end,

  1930.     .decode         = ff_mjpeg_decode_frame,

  1931.     .flush          = decode_flush,

  1932.     .capabilities   = CODEC_CAP_DR1,

  1933.     .max_lowres     = 3,

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

  1935. };

  1936. #endif