"Fossies" - the Fresh Open Source Software Archive

Member "ffmpeg-3.4.2/libavcodec/4xm.c" (31 Dec 2017, 34433 Bytes) of package /linux/misc/ffmpeg-3.4.2.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "4xm.c" see the Fossies "Dox" file reference documentation.

    1 /*
    2  * 4XM codec
    3  * Copyright (c) 2003 Michael Niedermayer
    4  *
    5  * This file is part of FFmpeg.
    6  *
    7  * FFmpeg is free software; you can redistribute it and/or
    8  * modify it under the terms of the GNU Lesser General Public
    9  * License as published by the Free Software Foundation; either
   10  * version 2.1 of the License, or (at your option) any later version.
   11  *
   12  * FFmpeg is distributed in the hope that it will be useful,
   13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   15  * Lesser General Public License for more details.
   16  *
   17  * You should have received a copy of the GNU Lesser General Public
   18  * License along with FFmpeg; if not, write to the Free Software
   19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   20  */
   21 
   22 /**
   23  * @file
   24  * 4XM codec.
   25  */
   26 
   27 #include <inttypes.h>
   28 
   29 #include "libavutil/avassert.h"
   30 #include "libavutil/frame.h"
   31 #include "libavutil/imgutils.h"
   32 #include "libavutil/intreadwrite.h"
   33 #include "avcodec.h"
   34 #include "blockdsp.h"
   35 #include "bswapdsp.h"
   36 #include "bytestream.h"
   37 #include "get_bits.h"
   38 #include "internal.h"
   39 
   40 
   41 #define BLOCK_TYPE_VLC_BITS 5
   42 #define ACDC_VLC_BITS 9
   43 
   44 #define CFRAME_BUFFER_COUNT 100
   45 
   46 static const uint8_t block_type_tab[2][4][8][2] = {
   47     {
   48         {    // { 8, 4, 2 } x { 8, 4, 2}
   49             { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
   50         }, { // { 8, 4 } x 1
   51             { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
   52         }, { // 1 x { 8, 4 }
   53             { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
   54         }, { // 1 x 2, 2 x 1
   55             { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
   56         }
   57     }, {
   58         {   // { 8, 4, 2 } x { 8, 4, 2}
   59             { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
   60         }, {// { 8, 4 } x 1
   61             { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
   62         }, {// 1 x { 8, 4 }
   63             { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
   64         }, {// 1 x 2, 2 x 1
   65             { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
   66       }
   67     }
   68 };
   69 
   70 static const uint8_t size2index[4][4] = {
   71     { -1, 3, 1, 1 },
   72     {  3, 0, 0, 0 },
   73     {  2, 0, 0, 0 },
   74     {  2, 0, 0, 0 },
   75 };
   76 
   77 static const int8_t mv[256][2] = {
   78     {   0,   0 }, {   0,  -1 }, {  -1,   0 }, {   1,   0 }, {   0,   1 }, {  -1,  -1 }, {   1,  -1 }, {  -1,   1 },
   79     {   1,   1 }, {   0,  -2 }, {  -2,   0 }, {   2,   0 }, {   0,   2 }, {  -1,  -2 }, {   1,  -2 }, {  -2,  -1 },
   80     {   2,  -1 }, {  -2,   1 }, {   2,   1 }, {  -1,   2 }, {   1,   2 }, {  -2,  -2 }, {   2,  -2 }, {  -2,   2 },
   81     {   2,   2 }, {   0,  -3 }, {  -3,   0 }, {   3,   0 }, {   0,   3 }, {  -1,  -3 }, {   1,  -3 }, {  -3,  -1 },
   82     {   3,  -1 }, {  -3,   1 }, {   3,   1 }, {  -1,   3 }, {   1,   3 }, {  -2,  -3 }, {   2,  -3 }, {  -3,  -2 },
   83     {   3,  -2 }, {  -3,   2 }, {   3,   2 }, {  -2,   3 }, {   2,   3 }, {   0,  -4 }, {  -4,   0 }, {   4,   0 },
   84     {   0,   4 }, {  -1,  -4 }, {   1,  -4 }, {  -4,  -1 }, {   4,  -1 }, {   4,   1 }, {  -1,   4 }, {   1,   4 },
   85     {  -3,  -3 }, {  -3,   3 }, {   3,   3 }, {  -2,  -4 }, {  -4,  -2 }, {   4,  -2 }, {  -4,   2 }, {  -2,   4 },
   86     {   2,   4 }, {  -3,  -4 }, {   3,  -4 }, {   4,  -3 }, {  -5,   0 }, {  -4,   3 }, {  -3,   4 }, {   3,   4 },
   87     {  -1,  -5 }, {  -5,  -1 }, {  -5,   1 }, {  -1,   5 }, {  -2,  -5 }, {   2,  -5 }, {   5,  -2 }, {   5,   2 },
   88     {  -4,  -4 }, {  -4,   4 }, {  -3,  -5 }, {  -5,  -3 }, {  -5,   3 }, {   3,   5 }, {  -6,   0 }, {   0,   6 },
   89     {  -6,  -1 }, {  -6,   1 }, {   1,   6 }, {   2,  -6 }, {  -6,   2 }, {   2,   6 }, {  -5,  -4 }, {   5,   4 },
   90     {   4,   5 }, {  -6,  -3 }, {   6,   3 }, {  -7,   0 }, {  -1,  -7 }, {   5,  -5 }, {  -7,   1 }, {  -1,   7 },
   91     {   4,  -6 }, {   6,   4 }, {  -2,  -7 }, {  -7,   2 }, {  -3,  -7 }, {   7,  -3 }, {   3,   7 }, {   6,  -5 },
   92     {   0,  -8 }, {  -1,  -8 }, {  -7,  -4 }, {  -8,   1 }, {   4,   7 }, {   2,  -8 }, {  -2,   8 }, {   6,   6 },
   93     {  -8,   3 }, {   5,  -7 }, {  -5,   7 }, {   8,  -4 }, {   0,  -9 }, {  -9,  -1 }, {   1,   9 }, {   7,  -6 },
   94     {  -7,   6 }, {  -5,  -8 }, {  -5,   8 }, {  -9,   3 }, {   9,  -4 }, {   7,  -7 }, {   8,  -6 }, {   6,   8 },
   95     {  10,   1 }, { -10,   2 }, {   9,  -5 }, {  10,  -3 }, {  -8,  -7 }, { -10,  -4 }, {   6,  -9 }, { -11,   0 },
   96     {  11,   1 }, { -11,  -2 }, {  -2,  11 }, {   7,  -9 }, {  -7,   9 }, {  10,   6 }, {  -4,  11 }, {   8,  -9 },
   97     {   8,   9 }, {   5,  11 }, {   7, -10 }, {  12,  -3 }, {  11,   6 }, {  -9,  -9 }, {   8,  10 }, {   5,  12 },
   98     { -11,   7 }, {  13,   2 }, {   6, -12 }, {  10,   9 }, { -11,   8 }, {  -7,  12 }, {   0,  14 }, {  14,  -2 },
   99     {  -9,  11 }, {  -6,  13 }, { -14,  -4 }, {  -5, -14 }, {   5,  14 }, { -15,  -1 }, { -14,  -6 }, {   3, -15 },
  100     {  11, -11 }, {  -7,  14 }, {  -5,  15 }, {   8, -14 }, {  15,   6 }, {   3,  16 }, {   7, -15 }, { -16,   5 },
  101     {   0,  17 }, { -16,  -6 }, { -10,  14 }, { -16,   7 }, {  12,  13 }, { -16,   8 }, { -17,   6 }, { -18,   3 },
  102     {  -7,  17 }, {  15,  11 }, {  16,  10 }, {   2, -19 }, {   3, -19 }, { -11, -16 }, { -18,   8 }, { -19,  -6 },
  103     {   2, -20 }, { -17, -11 }, { -10, -18 }, {   8,  19 }, { -21,  -1 }, { -20,   7 }, {  -4,  21 }, {  21,   5 },
  104     {  15,  16 }, {   2, -22 }, { -10, -20 }, { -22,   5 }, {  20, -11 }, {  -7, -22 }, { -12,  20 }, {  23,  -5 },
  105     {  13, -20 }, {  24,  -2 }, { -15,  19 }, { -11,  22 }, {  16,  19 }, {  23, -10 }, { -18, -18 }, {  -9, -24 },
  106     {  24, -10 }, {  -3,  26 }, { -23,  13 }, { -18, -20 }, {  17,  21 }, {  -4,  27 }, {  27,   6 }, {   1, -28 },
  107     { -11,  26 }, { -17, -23 }, {   7,  28 }, {  11, -27 }, {  29,   5 }, { -23, -19 }, { -28, -11 }, { -21,  22 },
  108     { -30,   7 }, { -17,  26 }, { -27,  16 }, {  13,  29 }, {  19, -26 }, {  10, -31 }, { -14, -30 }, {  20, -27 },
  109     { -29,  18 }, { -16, -31 }, { -28, -22 }, {  21, -30 }, { -25,  28 }, {  26, -29 }, {  25, -32 }, { -32, -32 }
  110 };
  111 
  112 /* This is simply the scaled down elementwise product of the standard JPEG
  113  * quantizer table and the AAN premul table. */
  114 static const uint8_t dequant_table[64] = {
  115     16, 15, 13, 19, 24, 31, 28, 17,
  116     17, 23, 25, 31, 36, 63, 45, 21,
  117     18, 24, 27, 37, 52, 59, 49, 20,
  118     16, 28, 34, 40, 60, 80, 51, 20,
  119     18, 31, 48, 66, 68, 86, 56, 21,
  120     19, 38, 56, 59, 64, 64, 48, 20,
  121     27, 48, 55, 55, 56, 51, 35, 15,
  122     20, 35, 34, 32, 31, 22, 15,  8,
  123 };
  124 
  125 static VLC block_type_vlc[2][4];
  126 
  127 
  128 typedef struct CFrameBuffer {
  129     unsigned int allocated_size;
  130     unsigned int size;
  131     int id;
  132     uint8_t *data;
  133 } CFrameBuffer;
  134 
  135 typedef struct FourXContext {
  136     AVCodecContext *avctx;
  137     BlockDSPContext bdsp;
  138     BswapDSPContext bbdsp;
  139     uint16_t *frame_buffer;
  140     uint16_t *last_frame_buffer;
  141     GetBitContext pre_gb;          ///< ac/dc prefix
  142     GetBitContext gb;
  143     GetByteContext g;
  144     GetByteContext g2;
  145     int mv[256];
  146     VLC pre_vlc;
  147     int last_dc;
  148     DECLARE_ALIGNED(16, int16_t, block)[6][64];
  149     void *bitstream_buffer;
  150     unsigned int bitstream_buffer_size;
  151     int version;
  152     CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
  153 } FourXContext;
  154 
  155 
  156 #define FIX_1_082392200  70936
  157 #define FIX_1_414213562  92682
  158 #define FIX_1_847759065 121095
  159 #define FIX_2_613125930 171254
  160 
  161 #define MULTIPLY(var, const) (((var) * (const)) >> 16)
  162 
  163 static void idct(int16_t block[64])
  164 {
  165     int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
  166     int tmp10, tmp11, tmp12, tmp13;
  167     int z5, z10, z11, z12, z13;
  168     int i;
  169     int temp[64];
  170 
  171     for (i = 0; i < 8; i++) {
  172         tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
  173         tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
  174 
  175         tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
  176         tmp12 = MULTIPLY(block[8 * 2 + i] - block[8 * 6 + i], FIX_1_414213562) - tmp13;
  177 
  178         tmp0 = tmp10 + tmp13;
  179         tmp3 = tmp10 - tmp13;
  180         tmp1 = tmp11 + tmp12;
  181         tmp2 = tmp11 - tmp12;
  182 
  183         z13 = block[8 * 5 + i] + block[8 * 3 + i];
  184         z10 = block[8 * 5 + i] - block[8 * 3 + i];
  185         z11 = block[8 * 1 + i] + block[8 * 7 + i];
  186         z12 = block[8 * 1 + i] - block[8 * 7 + i];
  187 
  188         tmp7  =          z11 + z13;
  189         tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
  190 
  191         z5    = MULTIPLY(z10 + z12, FIX_1_847759065);
  192         tmp10 = MULTIPLY(z12,  FIX_1_082392200) - z5;
  193         tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
  194 
  195         tmp6 = tmp12 - tmp7;
  196         tmp5 = tmp11 - tmp6;
  197         tmp4 = tmp10 + tmp5;
  198 
  199         temp[8 * 0 + i] = tmp0 + tmp7;
  200         temp[8 * 7 + i] = tmp0 - tmp7;
  201         temp[8 * 1 + i] = tmp1 + tmp6;
  202         temp[8 * 6 + i] = tmp1 - tmp6;
  203         temp[8 * 2 + i] = tmp2 + tmp5;
  204         temp[8 * 5 + i] = tmp2 - tmp5;
  205         temp[8 * 4 + i] = tmp3 + tmp4;
  206         temp[8 * 3 + i] = tmp3 - tmp4;
  207     }
  208 
  209     for (i = 0; i < 8 * 8; i += 8) {
  210         tmp10 = temp[0 + i] + temp[4 + i];
  211         tmp11 = temp[0 + i] - temp[4 + i];
  212 
  213         tmp13 = temp[2 + i] + temp[6 + i];
  214         tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
  215 
  216         tmp0 = tmp10 + tmp13;
  217         tmp3 = tmp10 - tmp13;
  218         tmp1 = tmp11 + tmp12;
  219         tmp2 = tmp11 - tmp12;
  220 
  221         z13 = temp[5 + i] + temp[3 + i];
  222         z10 = temp[5 + i] - temp[3 + i];
  223         z11 = temp[1 + i] + temp[7 + i];
  224         z12 = temp[1 + i] - temp[7 + i];
  225 
  226         tmp7  = z11 + z13;
  227         tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
  228 
  229         z5    = MULTIPLY(z10 + z12, FIX_1_847759065);
  230         tmp10 = MULTIPLY(z12,  FIX_1_082392200) - z5;
  231         tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
  232 
  233         tmp6 = tmp12 - tmp7;
  234         tmp5 = tmp11 - tmp6;
  235         tmp4 = tmp10 + tmp5;
  236 
  237         block[0 + i] = (tmp0 + tmp7) >> 6;
  238         block[7 + i] = (tmp0 - tmp7) >> 6;
  239         block[1 + i] = (tmp1 + tmp6) >> 6;
  240         block[6 + i] = (tmp1 - tmp6) >> 6;
  241         block[2 + i] = (tmp2 + tmp5) >> 6;
  242         block[5 + i] = (tmp2 - tmp5) >> 6;
  243         block[4 + i] = (tmp3 + tmp4) >> 6;
  244         block[3 + i] = (tmp3 - tmp4) >> 6;
  245     }
  246 }
  247 
  248 static av_cold void init_vlcs(FourXContext *f)
  249 {
  250     static VLC_TYPE table[2][4][32][2];
  251     int i, j;
  252 
  253     for (i = 0; i < 2; i++) {
  254         for (j = 0; j < 4; j++) {
  255             block_type_vlc[i][j].table           = table[i][j];
  256             block_type_vlc[i][j].table_allocated = 32;
  257             init_vlc(&block_type_vlc[i][j], BLOCK_TYPE_VLC_BITS, 7,
  258                      &block_type_tab[i][j][0][1], 2, 1,
  259                      &block_type_tab[i][j][0][0], 2, 1,
  260                      INIT_VLC_USE_NEW_STATIC);
  261         }
  262     }
  263 }
  264 
  265 static void init_mv(FourXContext *f, int linesize)
  266 {
  267     int i;
  268 
  269     for (i = 0; i < 256; i++) {
  270         if (f->version > 1)
  271             f->mv[i] = mv[i][0] + mv[i][1] * linesize / 2;
  272         else
  273             f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
  274     }
  275 }
  276 
  277 #if HAVE_BIGENDIAN
  278 #define LE_CENTRIC_MUL(dst, src, scale, dc)             \
  279     {                                                   \
  280         unsigned tmpval = AV_RN32(src);                 \
  281         tmpval = (tmpval << 16) | (tmpval >> 16);       \
  282         tmpval = tmpval * (scale) + (dc);               \
  283         tmpval = (tmpval << 16) | (tmpval >> 16);       \
  284         AV_WN32A(dst, tmpval);                          \
  285     }
  286 #else
  287 #define LE_CENTRIC_MUL(dst, src, scale, dc)              \
  288     {                                                    \
  289         unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
  290         AV_WN32A(dst, tmpval);                           \
  291     }
  292 #endif
  293 
  294 static inline void mcdc(uint16_t *dst, const uint16_t *src, int log2w,
  295                         int h, int stride, int scale, unsigned dc)
  296 {
  297     int i;
  298     dc *= 0x10001;
  299 
  300     switch (log2w) {
  301     case 0:
  302         for (i = 0; i < h; i++) {
  303             dst[0] = scale * src[0] + dc;
  304             if (scale)
  305                 src += stride;
  306             dst += stride;
  307         }
  308         break;
  309     case 1:
  310         for (i = 0; i < h; i++) {
  311             LE_CENTRIC_MUL(dst, src, scale, dc);
  312             if (scale)
  313                 src += stride;
  314             dst += stride;
  315         }
  316         break;
  317     case 2:
  318         for (i = 0; i < h; i++) {
  319             LE_CENTRIC_MUL(dst, src, scale, dc);
  320             LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
  321             if (scale)
  322                 src += stride;
  323             dst += stride;
  324         }
  325         break;
  326     case 3:
  327         for (i = 0; i < h; i++) {
  328             LE_CENTRIC_MUL(dst,     src,     scale, dc);
  329             LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
  330             LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
  331             LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
  332             if (scale)
  333                 src += stride;
  334             dst += stride;
  335         }
  336         break;
  337     default:
  338         av_assert0(0);
  339     }
  340 }
  341 
  342 static int decode_p_block(FourXContext *f, uint16_t *dst, const uint16_t *src,
  343                           int log2w, int log2h, int stride)
  344 {
  345     int index, h, code, ret, scale = 1;
  346     uint16_t *start, *end;
  347     unsigned dc = 0;
  348 
  349     av_assert0(log2w >= 0 && log2h >= 0);
  350 
  351     index = size2index[log2h][log2w];
  352     av_assert0(index >= 0);
  353 
  354     h     = 1 << log2h;
  355     code  = get_vlc2(&f->gb, block_type_vlc[1 - (f->version > 1)][index].table,
  356                      BLOCK_TYPE_VLC_BITS, 1);
  357     av_assert0(code >= 0 && code <= 6);
  358 
  359     start = f->last_frame_buffer;
  360     end   = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
  361 
  362     if (code == 1) {
  363         log2h--;
  364         if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
  365             return ret;
  366         return decode_p_block(f, dst + (stride << log2h),
  367                               src + (stride << log2h),
  368                               log2w, log2h, stride);
  369     } else if (code == 2) {
  370         log2w--;
  371         if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
  372             return ret;
  373         return decode_p_block(f, dst + (1 << log2w),
  374                               src + (1 << log2w),
  375                               log2w, log2h, stride);
  376     } else if (code == 6) {
  377         if (bytestream2_get_bytes_left(&f->g2) < 4) {
  378             av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
  379             return AVERROR_INVALIDDATA;
  380         }
  381         if (log2w) {
  382             dst[0]      = bytestream2_get_le16u(&f->g2);
  383             dst[1]      = bytestream2_get_le16u(&f->g2);
  384         } else {
  385             dst[0]      = bytestream2_get_le16u(&f->g2);
  386             dst[stride] = bytestream2_get_le16u(&f->g2);
  387         }
  388         return 0;
  389     }
  390 
  391     if ((code&3)==0 && bytestream2_get_bytes_left(&f->g) < 1) {
  392         av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
  393         return AVERROR_INVALIDDATA;
  394     }
  395 
  396     if (code == 0) {
  397         src  += f->mv[bytestream2_get_byte(&f->g)];
  398     } else if (code == 3 && f->version >= 2) {
  399         return 0;
  400     } else if (code == 4) {
  401         src  += f->mv[bytestream2_get_byte(&f->g)];
  402         if (bytestream2_get_bytes_left(&f->g2) < 2){
  403             av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
  404             return AVERROR_INVALIDDATA;
  405         }
  406         dc    = bytestream2_get_le16(&f->g2);
  407     } else if (code == 5) {
  408         if (bytestream2_get_bytes_left(&f->g2) < 2){
  409             av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
  410             return AVERROR_INVALIDDATA;
  411         }
  412         av_assert0(start <= src && src <= end);
  413         scale = 0;
  414         dc    = bytestream2_get_le16(&f->g2);
  415     }
  416 
  417     if (start > src || src > end) {
  418         av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
  419         return AVERROR_INVALIDDATA;
  420     }
  421 
  422     mcdc(dst, src, log2w, h, stride, scale, dc);
  423 
  424     return 0;
  425 }
  426 
  427 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
  428 {
  429     int x, y;
  430     const int width  = f->avctx->width;
  431     const int height = f->avctx->height;
  432     uint16_t *dst    = f->frame_buffer;
  433     uint16_t *src;
  434     unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
  435                  bytestream_offset, wordstream_offset;
  436     int ret;
  437 
  438     src = f->last_frame_buffer;
  439 
  440     if (f->version > 1) {
  441         extra           = 20;
  442         if (length < extra)
  443             return AVERROR_INVALIDDATA;
  444         bitstream_size  = AV_RL32(buf + 8);
  445         wordstream_size = AV_RL32(buf + 12);
  446         bytestream_size = AV_RL32(buf + 16);
  447     } else {
  448         extra           = 0;
  449         bitstream_size  = AV_RL16(buf - 4);
  450         wordstream_size = AV_RL16(buf - 2);
  451         bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
  452     }
  453 
  454     if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
  455         bytestream_size > length - bitstream_size ||
  456         wordstream_size > length - bytestream_size - bitstream_size ||
  457         extra > length - bytestream_size - bitstream_size - wordstream_size) {
  458         av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
  459         bitstream_size+ bytestream_size+ wordstream_size - length);
  460         return AVERROR_INVALIDDATA;
  461     }
  462 
  463     av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
  464                           bitstream_size);
  465     if (!f->bitstream_buffer)
  466         return AVERROR(ENOMEM);
  467     f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) (buf + extra),
  468                        bitstream_size / 4);
  469     init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
  470 
  471     wordstream_offset = extra + bitstream_size;
  472     bytestream_offset = extra + bitstream_size + wordstream_size;
  473     bytestream2_init(&f->g2, buf + wordstream_offset,
  474                      length - wordstream_offset);
  475     bytestream2_init(&f->g, buf + bytestream_offset,
  476                      length - bytestream_offset);
  477 
  478     init_mv(f, width * 2);
  479 
  480     for (y = 0; y < height; y += 8) {
  481         for (x = 0; x < width; x += 8)
  482             if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, width)) < 0)
  483                 return ret;
  484         src += 8 * width;
  485         dst += 8 * width;
  486     }
  487 
  488     return 0;
  489 }
  490 
  491 /**
  492  * decode block and dequantize.
  493  * Note this is almost identical to MJPEG.
  494  */
  495 static int decode_i_block(FourXContext *f, int16_t *block)
  496 {
  497     int code, i, j, level, val;
  498 
  499     if (get_bits_left(&f->gb) < 2){
  500         av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
  501         return -1;
  502     }
  503 
  504     /* DC coef */
  505     val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
  506     if (val >> 4) {
  507         av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
  508         return AVERROR_INVALIDDATA;
  509     }
  510 
  511     if (val)
  512         val = get_xbits(&f->gb, val);
  513 
  514     val        = val * dequant_table[0] + f->last_dc;
  515     f->last_dc = block[0] = val;
  516     /* AC coefs */
  517     i = 1;
  518     for (;;) {
  519         code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
  520 
  521         /* EOB */
  522         if (code == 0)
  523             break;
  524         if (code == 0xf0) {
  525             i += 16;
  526         } else {
  527             if (code & 0xf) {
  528                 level = get_xbits(&f->gb, code & 0xf);
  529             } else {
  530                 av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
  531                 return AVERROR_INVALIDDATA;
  532             }
  533             i    += code >> 4;
  534             if (i >= 64) {
  535                 av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
  536                 return 0;
  537             }
  538 
  539             j = ff_zigzag_direct[i];
  540             block[j] = level * dequant_table[j];
  541             i++;
  542             if (i >= 64)
  543                 break;
  544         }
  545     }
  546 
  547     return 0;
  548 }
  549 
  550 static inline void idct_put(FourXContext *f, int x, int y)
  551 {
  552     int16_t (*block)[64] = f->block;
  553     int stride           = f->avctx->width;
  554     int i;
  555     uint16_t *dst = f->frame_buffer + y * stride + x;
  556 
  557     for (i = 0; i < 4; i++) {
  558         block[i][0] += 0x80 * 8 * 8;
  559         idct(block[i]);
  560     }
  561 
  562     if (!(f->avctx->flags & AV_CODEC_FLAG_GRAY)) {
  563         for (i = 4; i < 6; i++)
  564             idct(block[i]);
  565     }
  566 
  567     /* Note transform is:
  568      * y  = ( 1b + 4g + 2r) / 14
  569      * cb = ( 3b - 2g - 1r) / 14
  570      * cr = (-1b - 4g + 5r) / 14 */
  571     for (y = 0; y < 8; y++) {
  572         for (x = 0; x < 8; x++) {
  573             int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
  574                             2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
  575             int cb = block[4][x + 8 * y];
  576             int cr = block[5][x + 8 * y];
  577             int cg = (cb + cr) >> 1;
  578             int y;
  579 
  580             cb += cb;
  581 
  582             y               = temp[0];
  583             dst[0]          = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
  584             y               = temp[1];
  585             dst[1]          = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
  586             y               = temp[8];
  587             dst[stride]     = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
  588             y               = temp[9];
  589             dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
  590             dst            += 2;
  591         }
  592         dst += 2 * stride - 2 * 8;
  593     }
  594 }
  595 
  596 static int decode_i_mb(FourXContext *f)
  597 {
  598     int ret;
  599     int i;
  600 
  601     f->bdsp.clear_blocks(f->block[0]);
  602 
  603     for (i = 0; i < 6; i++)
  604         if ((ret = decode_i_block(f, f->block[i])) < 0)
  605             return ret;
  606 
  607     return 0;
  608 }
  609 
  610 static const uint8_t *read_huffman_tables(FourXContext *f,
  611                                           const uint8_t * const buf,
  612                                           int buf_size)
  613 {
  614     int frequency[512] = { 0 };
  615     uint8_t flag[512];
  616     int up[512];
  617     uint8_t len_tab[257];
  618     int bits_tab[257];
  619     int start, end;
  620     const uint8_t *ptr = buf;
  621     const uint8_t *ptr_end = buf + buf_size;
  622     int j;
  623 
  624     memset(up, -1, sizeof(up));
  625 
  626     start = *ptr++;
  627     end   = *ptr++;
  628     for (;;) {
  629         int i;
  630 
  631         if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
  632             av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
  633             return NULL;
  634         }
  635 
  636         for (i = start; i <= end; i++)
  637             frequency[i] = *ptr++;
  638         start = *ptr++;
  639         if (start == 0)
  640             break;
  641 
  642         end = *ptr++;
  643     }
  644     frequency[256] = 1;
  645 
  646     while ((ptr - buf) & 3)
  647         ptr++; // 4byte align
  648 
  649     if (ptr > ptr_end) {
  650         av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
  651         return NULL;
  652     }
  653 
  654     for (j = 257; j < 512; j++) {
  655         int min_freq[2] = { 256 * 256, 256 * 256 };
  656         int smallest[2] = { 0, 0 };
  657         int i;
  658         for (i = 0; i < j; i++) {
  659             if (frequency[i] == 0)
  660                 continue;
  661             if (frequency[i] < min_freq[1]) {
  662                 if (frequency[i] < min_freq[0]) {
  663                     min_freq[1] = min_freq[0];
  664                     smallest[1] = smallest[0];
  665                     min_freq[0] = frequency[i];
  666                     smallest[0] = i;
  667                 } else {
  668                     min_freq[1] = frequency[i];
  669                     smallest[1] = i;
  670                 }
  671             }
  672         }
  673         if (min_freq[1] == 256 * 256)
  674             break;
  675 
  676         frequency[j]           = min_freq[0] + min_freq[1];
  677         flag[smallest[0]]      = 0;
  678         flag[smallest[1]]      = 1;
  679         up[smallest[0]]        =
  680         up[smallest[1]]        = j;
  681         frequency[smallest[0]] = frequency[smallest[1]] = 0;
  682     }
  683 
  684     for (j = 0; j < 257; j++) {
  685         int node, len = 0, bits = 0;
  686 
  687         for (node = j; up[node] != -1; node = up[node]) {
  688             bits += flag[node] << len;
  689             len++;
  690             if (len > 31)
  691                 // can this happen at all ?
  692                 av_log(f->avctx, AV_LOG_ERROR,
  693                        "vlc length overflow\n");
  694         }
  695 
  696         bits_tab[j] = bits;
  697         len_tab[j]  = len;
  698     }
  699 
  700     if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
  701                  bits_tab, 4, 4, 0))
  702         return NULL;
  703 
  704     return ptr;
  705 }
  706 
  707 static int mix(int c0, int c1)
  708 {
  709     int blue  =  2 * (c0 & 0x001F) + (c1 & 0x001F);
  710     int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
  711     int red   =  2 * (c0 >> 10)    + (c1 >> 10);
  712     return red / 3 * 1024 + green / 3 * 32 + blue / 3;
  713 }
  714 
  715 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
  716 {
  717     int x, y, x2, y2;
  718     const int width  = f->avctx->width;
  719     const int height = f->avctx->height;
  720     const int mbs    = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
  721     uint16_t *dst    = f->frame_buffer;
  722     const uint8_t *buf_end = buf + length;
  723     GetByteContext g3;
  724 
  725     if (length < mbs * 8) {
  726         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
  727         return AVERROR_INVALIDDATA;
  728     }
  729     bytestream2_init(&g3, buf, length);
  730 
  731     for (y = 0; y < height; y += 16) {
  732         for (x = 0; x < width; x += 16) {
  733             unsigned int color[4] = { 0 }, bits;
  734             if (buf_end - buf < 8)
  735                 return -1;
  736             // warning following is purely guessed ...
  737             color[0] = bytestream2_get_le16u(&g3);
  738             color[1] = bytestream2_get_le16u(&g3);
  739 
  740             if (color[0] & 0x8000)
  741                 av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
  742             if (color[1] & 0x8000)
  743                 av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
  744 
  745             color[2] = mix(color[0], color[1]);
  746             color[3] = mix(color[1], color[0]);
  747 
  748             bits = bytestream2_get_le32u(&g3);
  749             for (y2 = 0; y2 < 16; y2++) {
  750                 for (x2 = 0; x2 < 16; x2++) {
  751                     int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
  752                     dst[y2 * width + x2] = color[(bits >> index) & 3];
  753                 }
  754             }
  755             dst += 16;
  756         }
  757         dst += 16 * width - x;
  758     }
  759 
  760     return 0;
  761 }
  762 
  763 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
  764 {
  765     int x, y, ret;
  766     const int width  = f->avctx->width;
  767     const int height = f->avctx->height;
  768     const unsigned int bitstream_size = AV_RL32(buf);
  769     unsigned int prestream_size;
  770     const uint8_t *prestream;
  771 
  772     if (bitstream_size > (1 << 26))
  773         return AVERROR_INVALIDDATA;
  774 
  775     if (length < bitstream_size + 12) {
  776         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
  777         return AVERROR_INVALIDDATA;
  778     }
  779 
  780     prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
  781     prestream      =             buf + bitstream_size + 12;
  782 
  783     if (prestream_size + bitstream_size + 12 != length
  784         || prestream_size > (1 << 26)) {
  785         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
  786                prestream_size, bitstream_size, length);
  787         return AVERROR_INVALIDDATA;
  788     }
  789 
  790     prestream = read_huffman_tables(f, prestream, prestream_size);
  791     if (!prestream) {
  792         av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
  793         return AVERROR_INVALIDDATA;
  794     }
  795 
  796     av_assert0(prestream <= buf + length);
  797 
  798     init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
  799 
  800     prestream_size = length + buf - prestream;
  801 
  802     av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
  803                           prestream_size);
  804     if (!f->bitstream_buffer)
  805         return AVERROR(ENOMEM);
  806     f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) prestream,
  807                        prestream_size / 4);
  808     init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
  809 
  810     f->last_dc = 0 * 128 * 8 * 8;
  811 
  812     for (y = 0; y < height; y += 16) {
  813         for (x = 0; x < width; x += 16) {
  814             if ((ret = decode_i_mb(f)) < 0)
  815                 return ret;
  816 
  817             idct_put(f, x, y);
  818         }
  819     }
  820 
  821     if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
  822         av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
  823 
  824     return 0;
  825 }
  826 
  827 static int decode_frame(AVCodecContext *avctx, void *data,
  828                         int *got_frame, AVPacket *avpkt)
  829 {
  830     const uint8_t *buf    = avpkt->data;
  831     int buf_size          = avpkt->size;
  832     FourXContext *const f = avctx->priv_data;
  833     AVFrame *picture      = data;
  834     int i, frame_4cc, frame_size, ret;
  835 
  836     if (buf_size < 20)
  837         return AVERROR_INVALIDDATA;
  838 
  839     av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
  840 
  841     if (buf_size < AV_RL32(buf + 4) + 8) {
  842         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %"PRIu32"\n",
  843                buf_size, AV_RL32(buf + 4));
  844         return AVERROR_INVALIDDATA;
  845     }
  846 
  847     frame_4cc = AV_RL32(buf);
  848 
  849     if (frame_4cc == AV_RL32("cfrm")) {
  850         int free_index       = -1;
  851         int id, whole_size;
  852         const int data_size  = buf_size - 20;
  853         CFrameBuffer *cfrm;
  854 
  855         if (f->version <= 1) {
  856             av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
  857             return AVERROR_INVALIDDATA;
  858         }
  859 
  860         id         = AV_RL32(buf + 12);
  861         whole_size = AV_RL32(buf + 16);
  862 
  863         if (data_size < 0 || whole_size < 0) {
  864             av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
  865             return AVERROR_INVALIDDATA;
  866         }
  867 
  868         for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
  869             if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
  870                 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
  871                        f->cfrm[i].id);
  872 
  873         for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
  874             if (f->cfrm[i].id == id)
  875                 break;
  876             if (f->cfrm[i].size == 0)
  877                 free_index = i;
  878         }
  879 
  880         if (i >= CFRAME_BUFFER_COUNT) {
  881             i             = free_index;
  882             f->cfrm[i].id = id;
  883         }
  884         cfrm = &f->cfrm[i];
  885 
  886         if (data_size > UINT_MAX -  cfrm->size - AV_INPUT_BUFFER_PADDING_SIZE)
  887             return AVERROR_INVALIDDATA;
  888 
  889         cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
  890                                      cfrm->size + data_size + AV_INPUT_BUFFER_PADDING_SIZE);
  891         // explicit check needed as memcpy below might not catch a NULL
  892         if (!cfrm->data) {
  893             av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
  894             return AVERROR(ENOMEM);
  895         }
  896 
  897         memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
  898         cfrm->size += data_size;
  899 
  900         if (cfrm->size >= whole_size) {
  901             buf        = cfrm->data;
  902             frame_size = cfrm->size;
  903 
  904             if (id != avctx->frame_number)
  905                 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
  906                        id, avctx->frame_number);
  907 
  908             if (f->version <= 1)
  909                 return AVERROR_INVALIDDATA;
  910 
  911             cfrm->size = cfrm->id = 0;
  912             frame_4cc  = AV_RL32("pfrm");
  913         } else
  914             return buf_size;
  915     } else {
  916         buf        = buf      + 12;
  917         frame_size = buf_size - 12;
  918     }
  919 
  920     if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
  921         return ret;
  922 
  923     if (frame_4cc == AV_RL32("ifr2")) {
  924         picture->pict_type = AV_PICTURE_TYPE_I;
  925         if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0) {
  926             av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
  927             return ret;
  928         }
  929     } else if (frame_4cc == AV_RL32("ifrm")) {
  930         picture->pict_type = AV_PICTURE_TYPE_I;
  931         if ((ret = decode_i_frame(f, buf, frame_size)) < 0) {
  932             av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
  933             return ret;
  934         }
  935     } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
  936         picture->pict_type = AV_PICTURE_TYPE_P;
  937         if ((ret = decode_p_frame(f, buf, frame_size)) < 0) {
  938             av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
  939             return ret;
  940         }
  941     } else if (frame_4cc == AV_RL32("snd_")) {
  942         av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
  943                buf_size);
  944     } else {
  945         av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
  946                buf_size);
  947     }
  948 
  949     picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
  950 
  951     av_image_copy_plane(picture->data[0], picture->linesize[0],
  952                         (const uint8_t*)f->frame_buffer,  avctx->width * 2,
  953                         avctx->width * 2, avctx->height);
  954     FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
  955 
  956     *got_frame = 1;
  957 
  958     emms_c();
  959 
  960     return buf_size;
  961 }
  962 
  963 static av_cold int decode_end(AVCodecContext *avctx)
  964 {
  965     FourXContext * const f = avctx->priv_data;
  966     int i;
  967 
  968     av_freep(&f->frame_buffer);
  969     av_freep(&f->last_frame_buffer);
  970     av_freep(&f->bitstream_buffer);
  971     f->bitstream_buffer_size = 0;
  972     for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
  973         av_freep(&f->cfrm[i].data);
  974         f->cfrm[i].allocated_size = 0;
  975     }
  976     ff_free_vlc(&f->pre_vlc);
  977 
  978     return 0;
  979 }
  980 
  981 static av_cold int decode_init(AVCodecContext *avctx)
  982 {
  983     FourXContext * const f = avctx->priv_data;
  984     int ret;
  985 
  986     if (avctx->extradata_size != 4 || !avctx->extradata) {
  987         av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
  988         return AVERROR_INVALIDDATA;
  989     }
  990     if((avctx->width % 16) || (avctx->height % 16)) {
  991         av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
  992         return AVERROR_INVALIDDATA;
  993     }
  994 
  995     ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
  996     if (ret < 0)
  997         return ret;
  998 
  999     f->frame_buffer      = av_mallocz(avctx->width * avctx->height * 2);
 1000     f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
 1001     if (!f->frame_buffer || !f->last_frame_buffer) {
 1002         decode_end(avctx);
 1003         return AVERROR(ENOMEM);
 1004     }
 1005 
 1006     f->version = AV_RL32(avctx->extradata) >> 16;
 1007     ff_blockdsp_init(&f->bdsp, avctx);
 1008     ff_bswapdsp_init(&f->bbdsp);
 1009     f->avctx = avctx;
 1010     init_vlcs(f);
 1011 
 1012     if (f->version > 2)
 1013         avctx->pix_fmt = AV_PIX_FMT_RGB565;
 1014     else
 1015         avctx->pix_fmt = AV_PIX_FMT_BGR555;
 1016 
 1017     return 0;
 1018 }
 1019 
 1020 AVCodec ff_fourxm_decoder = {
 1021     .name           = "4xm",
 1022     .long_name      = NULL_IF_CONFIG_SMALL("4X Movie"),
 1023     .type           = AVMEDIA_TYPE_VIDEO,
 1024     .id             = AV_CODEC_ID_4XM,
 1025     .priv_data_size = sizeof(FourXContext),
 1026     .init           = decode_init,
 1027     .close          = decode_end,
 1028     .decode         = decode_frame,
 1029     .capabilities   = AV_CODEC_CAP_DR1,
 1030 };