Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * SVQ1 decoder
  3.  * ported to MPlayer by Arpi <arpi@thot.banki.hu>
  4.  * ported to libavcodec by Nick Kurshev <nickols_k@mail.ru>
  5.  *
  6.  * Copyright (C) 2002 the xine project
  7.  * Copyright (C) 2002 the ffmpeg project
  8.  *
  9.  * SVQ1 Encoder (c) 2004 Mike Melanson <melanson@pcisys.net>
  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.  * Sorenson Vector Quantizer #1 (SVQ1) video codec.
  31.  * For more information of the SVQ1 algorithm, visit:
  32.  *   http://www.pcisys.net/~melanson/codecs/
  33.  */
  34.  
  35. #include "avcodec.h"
  36. #include "get_bits.h"
  37. #include "h263.h"
  38. #include "hpeldsp.h"
  39. #include "internal.h"
  40. #include "mathops.h"
  41. #include "svq1.h"
  42.  
  43. #undef NDEBUG
  44. #include <assert.h>
  45.  
  46. static VLC svq1_block_type;
  47. static VLC svq1_motion_component;
  48. static VLC svq1_intra_multistage[6];
  49. static VLC svq1_inter_multistage[6];
  50. static VLC svq1_intra_mean;
  51. static VLC svq1_inter_mean;
  52.  
  53. /* motion vector (prediction) */
  54. typedef struct svq1_pmv_s {
  55.     int x;
  56.     int y;
  57. } svq1_pmv;
  58.  
  59. typedef struct SVQ1Context {
  60.     HpelDSPContext hdsp;
  61.     GetBitContext gb;
  62.     AVFrame *prev;
  63.     int width;
  64.     int height;
  65.     int frame_code;
  66.     int nonref;         // 1 if the current frame won't be referenced
  67. } SVQ1Context;
  68.  
  69. static const uint8_t string_table[256] = {
  70.     0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
  71.     0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
  72.     0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
  73.     0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
  74.     0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
  75.     0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
  76.     0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
  77.     0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
  78.     0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
  79.     0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
  80.     0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
  81.     0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
  82.     0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
  83.     0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
  84.     0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
  85.     0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
  86.     0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
  87.     0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
  88.     0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
  89.     0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
  90.     0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
  91.     0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
  92.     0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
  93.     0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
  94.     0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
  95.     0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
  96.     0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
  97.     0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
  98.     0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
  99.     0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
  100.     0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
  101.     0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
  102. };
  103.  
  104. #define SVQ1_PROCESS_VECTOR()                                           \
  105.     for (; level > 0; i++) {                                            \
  106.         /* process next depth */                                        \
  107.         if (i == m) {                                                   \
  108.             m = n;                                                      \
  109.             if (--level == 0)                                           \
  110.                 break;                                                  \
  111.         }                                                               \
  112.         /* divide block if next bit set */                              \
  113.         if (!get_bits1(bitbuf))                                         \
  114.             break;                                                      \
  115.         /* add child nodes */                                           \
  116.         list[n++] = list[i];                                            \
  117.         list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level >> 1) + 1));\
  118.     }
  119.  
  120. #define SVQ1_ADD_CODEBOOK()                                             \
  121.     /* add codebook entries to vector */                                \
  122.     for (j = 0; j < stages; j++) {                                      \
  123.         n3  = codebook[entries[j]] ^ 0x80808080;                        \
  124.         n1 += (n3 & 0xFF00FF00) >> 8;                                   \
  125.         n2 +=  n3 & 0x00FF00FF;                                         \
  126.     }                                                                   \
  127.                                                                         \
  128.     /* clip to [0..255] */                                              \
  129.     if (n1 & 0xFF00FF00) {                                              \
  130.         n3  = (n1 >> 15  & 0x00010001 | 0x01000100) - 0x00010001;       \
  131.         n1 += 0x7F007F00;                                               \
  132.         n1 |= (~n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001;       \
  133.         n1 &= n3 & 0x00FF00FF;                                          \
  134.     }                                                                   \
  135.                                                                         \
  136.     if (n2 & 0xFF00FF00) {                                              \
  137.         n3  = (n2 >> 15  & 0x00010001 | 0x01000100) - 0x00010001;       \
  138.         n2 += 0x7F007F00;                                               \
  139.         n2 |= (~n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001;       \
  140.         n2 &= n3 & 0x00FF00FF;                                          \
  141.     }
  142.  
  143. #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)                               \
  144.     codebook = (const uint32_t *)cbook[level];                          \
  145.     if (stages > 0)                                                     \
  146.         bit_cache = get_bits(bitbuf, 4 * stages);                       \
  147.     /* calculate codebook entries for this vector */                    \
  148.     for (j = 0; j < stages; j++) {                                      \
  149.         entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) +   \
  150.                       16 * j) << (level + 1);                           \
  151.     }                                                                   \
  152.     mean -= stages * 128;                                               \
  153.     n4    = (mean << 16) + mean;
  154.  
  155. static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels,
  156.                                    int pitch)
  157. {
  158.     uint32_t bit_cache;
  159.     uint8_t *list[63];
  160.     uint32_t *dst;
  161.     const uint32_t *codebook;
  162.     int entries[6];
  163.     int i, j, m, n;
  164.     int mean, stages;
  165.     unsigned x, y, width, height, level;
  166.     uint32_t n1, n2, n3, n4;
  167.  
  168.     /* initialize list for breadth first processing of vectors */
  169.     list[0] = pixels;
  170.  
  171.     /* recursively process vector */
  172.     for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
  173.         SVQ1_PROCESS_VECTOR();
  174.  
  175.         /* destination address and vector size */
  176.         dst    = (uint32_t *)list[i];
  177.         width  = 1 << ((4 + level) / 2);
  178.         height = 1 << ((3 + level) / 2);
  179.  
  180.         /* get number of stages (-1 skips vector, 0 for mean only) */
  181.         stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
  182.  
  183.         if (stages == -1) {
  184.             for (y = 0; y < height; y++)
  185.                 memset(&dst[y * (pitch / 4)], 0, width);
  186.             continue;   /* skip vector */
  187.         }
  188.  
  189.         if (stages > 0 && level >= 4) {
  190.             av_dlog(NULL,
  191.                     "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
  192.                     stages, level);
  193.             return AVERROR_INVALIDDATA;  /* invalid vector */
  194.         }
  195.  
  196.         mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
  197.  
  198.         if (stages == 0) {
  199.             for (y = 0; y < height; y++)
  200.                 memset(&dst[y * (pitch / 4)], mean, width);
  201.         } else {
  202.             SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
  203.  
  204.             for (y = 0; y < height; y++) {
  205.                 for (x = 0; x < width / 4; x++, codebook++) {
  206.                     n1 = n4;
  207.                     n2 = n4;
  208.                     SVQ1_ADD_CODEBOOK()
  209.                     /* store result */
  210.                     dst[x] = n1 << 8 | n2;
  211.                 }
  212.                 dst += pitch / 4;
  213.             }
  214.         }
  215.     }
  216.  
  217.     return 0;
  218. }
  219.  
  220. static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels,
  221.                                        int pitch)
  222. {
  223.     uint32_t bit_cache;
  224.     uint8_t *list[63];
  225.     uint32_t *dst;
  226.     const uint32_t *codebook;
  227.     int entries[6];
  228.     int i, j, m, n;
  229.     int mean, stages;
  230.     int x, y, width, height, level;
  231.     uint32_t n1, n2, n3, n4;
  232.  
  233.     /* initialize list for breadth first processing of vectors */
  234.     list[0] = pixels;
  235.  
  236.     /* recursively process vector */
  237.     for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
  238.         SVQ1_PROCESS_VECTOR();
  239.  
  240.         /* destination address and vector size */
  241.         dst    = (uint32_t *)list[i];
  242.         width  = 1 << ((4 + level) / 2);
  243.         height = 1 << ((3 + level) / 2);
  244.  
  245.         /* get number of stages (-1 skips vector, 0 for mean only) */
  246.         stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
  247.  
  248.         if (stages == -1)
  249.             continue;           /* skip vector */
  250.  
  251.         if ((stages > 0) && (level >= 4)) {
  252.             av_dlog(NULL,
  253.                     "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
  254.                     stages, level);
  255.             return AVERROR_INVALIDDATA;  /* invalid vector */
  256.         }
  257.  
  258.         mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
  259.  
  260.         SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
  261.  
  262.         for (y = 0; y < height; y++) {
  263.             for (x = 0; x < width / 4; x++, codebook++) {
  264.                 n3 = dst[x];
  265.                 /* add mean value to vector */
  266.                 n1 = n4 + ((n3 & 0xFF00FF00) >> 8);
  267.                 n2 = n4 +  (n3 & 0x00FF00FF);
  268.                 SVQ1_ADD_CODEBOOK()
  269.                 /* store result */
  270.                 dst[x] = n1 << 8 | n2;
  271.             }
  272.             dst += pitch / 4;
  273.         }
  274.     }
  275.     return 0;
  276. }
  277.  
  278. static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv,
  279.                                      svq1_pmv **pmv)
  280. {
  281.     int diff;
  282.     int i;
  283.  
  284.     for (i = 0; i < 2; i++) {
  285.         /* get motion code */
  286.         diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
  287.         if (diff < 0)
  288.             return AVERROR_INVALIDDATA;
  289.         else if (diff) {
  290.             if (get_bits1(bitbuf))
  291.                 diff = -diff;
  292.         }
  293.  
  294.         /* add median of motion vector predictors and clip result */
  295.         if (i == 1)
  296.             mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
  297.         else
  298.             mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
  299.     }
  300.  
  301.     return 0;
  302. }
  303.  
  304. static void svq1_skip_block(uint8_t *current, uint8_t *previous,
  305.                             int pitch, int x, int y)
  306. {
  307.     uint8_t *src;
  308.     uint8_t *dst;
  309.     int i;
  310.  
  311.     src = &previous[x + y * pitch];
  312.     dst = current;
  313.  
  314.     for (i = 0; i < 16; i++) {
  315.         memcpy(dst, src, 16);
  316.         src += pitch;
  317.         dst += pitch;
  318.     }
  319. }
  320.  
  321. static int svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
  322.                                    uint8_t *current, uint8_t *previous,
  323.                                    int pitch, svq1_pmv *motion, int x, int y,
  324.                                    int width, int height)
  325. {
  326.     uint8_t *src;
  327.     uint8_t *dst;
  328.     svq1_pmv mv;
  329.     svq1_pmv *pmv[3];
  330.     int result;
  331.  
  332.     /* predict and decode motion vector */
  333.     pmv[0] = &motion[0];
  334.     if (y == 0) {
  335.         pmv[1] =
  336.         pmv[2] = pmv[0];
  337.     } else {
  338.         pmv[1] = &motion[x / 8 + 2];
  339.         pmv[2] = &motion[x / 8 + 4];
  340.     }
  341.  
  342.     result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
  343.     if (result)
  344.         return result;
  345.  
  346.     motion[0].x         =
  347.     motion[x / 8 + 2].x =
  348.     motion[x / 8 + 3].x = mv.x;
  349.     motion[0].y         =
  350.     motion[x / 8 + 2].y =
  351.     motion[x / 8 + 3].y = mv.y;
  352.  
  353.     mv.x = av_clip(mv.x, -2 * x, 2 * (width  - x - 16));
  354.     mv.y = av_clip(mv.y, -2 * y, 2 * (height - y - 16));
  355.  
  356.     src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch];
  357.     dst = current;
  358.  
  359.     hdsp->put_pixels_tab[0][(mv.y & 1) << 1 | (mv.x & 1)](dst, src, pitch, 16);
  360.  
  361.     return 0;
  362. }
  363.  
  364. static int svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
  365.                                       uint8_t *current, uint8_t *previous,
  366.                                       int pitch, svq1_pmv *motion, int x, int y,
  367.                                       int width, int height)
  368. {
  369.     uint8_t *src;
  370.     uint8_t *dst;
  371.     svq1_pmv mv;
  372.     svq1_pmv *pmv[4];
  373.     int i, result;
  374.  
  375.     /* predict and decode motion vector (0) */
  376.     pmv[0] = &motion[0];
  377.     if (y == 0) {
  378.         pmv[1] =
  379.         pmv[2] = pmv[0];
  380.     } else {
  381.         pmv[1] = &motion[(x / 8) + 2];
  382.         pmv[2] = &motion[(x / 8) + 4];
  383.     }
  384.  
  385.     result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
  386.     if (result)
  387.         return result;
  388.  
  389.     /* predict and decode motion vector (1) */
  390.     pmv[0] = &mv;
  391.     if (y == 0) {
  392.         pmv[1] =
  393.         pmv[2] = pmv[0];
  394.     } else {
  395.         pmv[1] = &motion[(x / 8) + 3];
  396.     }
  397.     result = svq1_decode_motion_vector(bitbuf, &motion[0], pmv);
  398.     if (result)
  399.         return result;
  400.  
  401.     /* predict and decode motion vector (2) */
  402.     pmv[1] = &motion[0];
  403.     pmv[2] = &motion[(x / 8) + 1];
  404.  
  405.     result = svq1_decode_motion_vector(bitbuf, &motion[(x / 8) + 2], pmv);
  406.     if (result)
  407.         return result;
  408.  
  409.     /* predict and decode motion vector (3) */
  410.     pmv[2] = &motion[(x / 8) + 2];
  411.     pmv[3] = &motion[(x / 8) + 3];
  412.  
  413.     result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv);
  414.     if (result)
  415.         return result;
  416.  
  417.     /* form predictions */
  418.     for (i = 0; i < 4; i++) {
  419.         int mvx = pmv[i]->x + (i  & 1) * 16;
  420.         int mvy = pmv[i]->y + (i >> 1) * 16;
  421.  
  422.         // FIXME: clipping or padding?
  423.         mvx = av_clip(mvx, -2 * x, 2 * (width  - x - 8));
  424.         mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8));
  425.  
  426.         src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];
  427.         dst = current;
  428.  
  429.         hdsp->put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8);
  430.  
  431.         /* select next block */
  432.         if (i & 1)
  433.             current += 8 * (pitch - 1);
  434.         else
  435.             current += 8;
  436.     }
  437.  
  438.     return 0;
  439. }
  440.  
  441. static int svq1_decode_delta_block(AVCodecContext *avctx, HpelDSPContext *hdsp,
  442.                                    GetBitContext *bitbuf,
  443.                                    uint8_t *current, uint8_t *previous,
  444.                                    int pitch, svq1_pmv *motion, int x, int y,
  445.                                    int width, int height)
  446. {
  447.     uint32_t block_type;
  448.     int result = 0;
  449.  
  450.     /* get block type */
  451.     block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
  452.  
  453.     /* reset motion vectors */
  454.     if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
  455.         motion[0].x         =
  456.         motion[0].y         =
  457.         motion[x / 8 + 2].x =
  458.         motion[x / 8 + 2].y =
  459.         motion[x / 8 + 3].x =
  460.         motion[x / 8 + 3].y = 0;
  461.     }
  462.  
  463.     switch (block_type) {
  464.     case SVQ1_BLOCK_SKIP:
  465.         svq1_skip_block(current, previous, pitch, x, y);
  466.         break;
  467.  
  468.     case SVQ1_BLOCK_INTER:
  469.         result = svq1_motion_inter_block(hdsp, bitbuf, current, previous,
  470.                                          pitch, motion, x, y, width, height);
  471.  
  472.         if (result != 0) {
  473.             av_dlog(avctx, "Error in svq1_motion_inter_block %i\n", result);
  474.             break;
  475.         }
  476.         result = svq1_decode_block_non_intra(bitbuf, current, pitch);
  477.         break;
  478.  
  479.     case SVQ1_BLOCK_INTER_4V:
  480.         result = svq1_motion_inter_4v_block(hdsp, bitbuf, current, previous,
  481.                                             pitch, motion, x, y, width, height);
  482.  
  483.         if (result != 0) {
  484.             av_dlog(avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
  485.             break;
  486.         }
  487.         result = svq1_decode_block_non_intra(bitbuf, current, pitch);
  488.         break;
  489.  
  490.     case SVQ1_BLOCK_INTRA:
  491.         result = svq1_decode_block_intra(bitbuf, current, pitch);
  492.         break;
  493.     }
  494.  
  495.     return result;
  496. }
  497.  
  498. static void svq1_parse_string(GetBitContext *bitbuf, uint8_t *out)
  499. {
  500.     uint8_t seed;
  501.     int i;
  502.  
  503.     out[0] = get_bits(bitbuf, 8);
  504.     seed   = string_table[out[0]];
  505.  
  506.     for (i = 1; i <= out[0]; i++) {
  507.         out[i] = get_bits(bitbuf, 8) ^ seed;
  508.         seed   = string_table[out[i] ^ seed];
  509.     }
  510. }
  511.  
  512. static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame)
  513. {
  514.     SVQ1Context *s = avctx->priv_data;
  515.     GetBitContext *bitbuf = &s->gb;
  516.     int frame_size_code;
  517.     int width  = s->width;
  518.     int height = s->height;
  519.  
  520.     skip_bits(bitbuf, 8); /* temporal_reference */
  521.  
  522.     /* frame type */
  523.     s->nonref = 0;
  524.     switch (get_bits(bitbuf, 2)) {
  525.     case 0:
  526.         frame->pict_type = AV_PICTURE_TYPE_I;
  527.         break;
  528.     case 2:
  529.         s->nonref = 1;
  530.     case 1:
  531.         frame->pict_type = AV_PICTURE_TYPE_P;
  532.         break;
  533.     default:
  534.         av_log(avctx, AV_LOG_ERROR, "Invalid frame type.\n");
  535.         return AVERROR_INVALIDDATA;
  536.     }
  537.  
  538.     if (frame->pict_type == AV_PICTURE_TYPE_I) {
  539.         /* unknown fields */
  540.         if (s->frame_code == 0x50 || s->frame_code == 0x60) {
  541.             int csum = get_bits(bitbuf, 16);
  542.  
  543.             csum = ff_svq1_packet_checksum(bitbuf->buffer,
  544.                                            bitbuf->size_in_bits >> 3,
  545.                                            csum);
  546.  
  547.             av_dlog(avctx, "%s checksum (%02x) for packet data\n",
  548.                     (csum == 0) ? "correct" : "incorrect", csum);
  549.         }
  550.  
  551.         if ((s->frame_code ^ 0x10) >= 0x50) {
  552.             uint8_t msg[256];
  553.  
  554.             svq1_parse_string(bitbuf, msg);
  555.  
  556.             av_log(avctx, AV_LOG_INFO,
  557.                    "embedded message:\n%s\n", (char *)msg);
  558.         }
  559.  
  560.         skip_bits(bitbuf, 2);
  561.         skip_bits(bitbuf, 2);
  562.         skip_bits1(bitbuf);
  563.  
  564.         /* load frame size */
  565.         frame_size_code = get_bits(bitbuf, 3);
  566.  
  567.         if (frame_size_code == 7) {
  568.             /* load width, height (12 bits each) */
  569.             width  = get_bits(bitbuf, 12);
  570.             height = get_bits(bitbuf, 12);
  571.  
  572.             if (!width || !height)
  573.                 return AVERROR_INVALIDDATA;
  574.         } else {
  575.             /* get width, height from table */
  576.             width  = ff_svq1_frame_size_table[frame_size_code][0];
  577.             height = ff_svq1_frame_size_table[frame_size_code][1];
  578.         }
  579.     }
  580.  
  581.     /* unknown fields */
  582.     if (get_bits1(bitbuf)) {
  583.         skip_bits1(bitbuf);    /* use packet checksum if (1) */
  584.         skip_bits1(bitbuf);    /* component checksums after image data if (1) */
  585.  
  586.         if (get_bits(bitbuf, 2) != 0)
  587.             return AVERROR_INVALIDDATA;
  588.     }
  589.  
  590.     if (get_bits1(bitbuf)) {
  591.         skip_bits1(bitbuf);
  592.         skip_bits(bitbuf, 4);
  593.         skip_bits1(bitbuf);
  594.         skip_bits(bitbuf, 2);
  595.  
  596.         while (get_bits1(bitbuf))
  597.             skip_bits(bitbuf, 8);
  598.     }
  599.  
  600.     s->width  = width;
  601.     s->height = height;
  602.     return 0;
  603. }
  604.  
  605. static int svq1_decode_frame(AVCodecContext *avctx, void *data,
  606.                              int *got_frame, AVPacket *avpkt)
  607. {
  608.     const uint8_t *buf = avpkt->data;
  609.     int buf_size       = avpkt->size;
  610.     SVQ1Context     *s = avctx->priv_data;
  611.     AVFrame       *cur = data;
  612.     uint8_t *current;
  613.     int result, i, x, y, width, height;
  614.     svq1_pmv *pmv;
  615.  
  616.     /* initialize bit buffer */
  617.     init_get_bits8(&s->gb, buf, buf_size);
  618.  
  619.     /* decode frame header */
  620.     s->frame_code = get_bits(&s->gb, 22);
  621.  
  622.     if ((s->frame_code & ~0x70) || !(s->frame_code & 0x60))
  623.         return AVERROR_INVALIDDATA;
  624.  
  625.     /* swap some header bytes (why?) */
  626.     if (s->frame_code != 0x20) {
  627.         uint32_t *src = (uint32_t *)(buf + 4);
  628.  
  629.         if (buf_size < 36)
  630.             return AVERROR_INVALIDDATA;
  631.  
  632.         for (i = 0; i < 4; i++)
  633.             src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
  634.     }
  635.  
  636.     result = svq1_decode_frame_header(avctx, cur);
  637.     if (result != 0) {
  638.         av_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result);
  639.         return result;
  640.     }
  641.     avcodec_set_dimensions(avctx, s->width, s->height);
  642.  
  643.     if ((avctx->skip_frame >= AVDISCARD_NONREF && s->nonref) ||
  644.         (avctx->skip_frame >= AVDISCARD_NONKEY &&
  645.          cur->pict_type != AV_PICTURE_TYPE_I) ||
  646.         avctx->skip_frame >= AVDISCARD_ALL)
  647.         return buf_size;
  648.  
  649.     result = ff_get_buffer(avctx, cur, s->nonref ? 0 : AV_GET_BUFFER_FLAG_REF);
  650.     if (result < 0)
  651.         return result;
  652.  
  653.     pmv = av_malloc((FFALIGN(s->width, 16) / 8 + 3) * sizeof(*pmv));
  654.     if (!pmv)
  655.         return AVERROR(ENOMEM);
  656.  
  657.     /* decode y, u and v components */
  658.     for (i = 0; i < 3; i++) {
  659.         int linesize = cur->linesize[i];
  660.         if (i == 0) {
  661.             width    = FFALIGN(s->width,  16);
  662.             height   = FFALIGN(s->height, 16);
  663.         } else {
  664.             if (avctx->flags & CODEC_FLAG_GRAY)
  665.                 break;
  666.             width    = FFALIGN(s->width  / 4, 16);
  667.             height   = FFALIGN(s->height / 4, 16);
  668.         }
  669.  
  670.         current = cur->data[i];
  671.  
  672.         if (cur->pict_type == AV_PICTURE_TYPE_I) {
  673.             /* keyframe */
  674.             for (y = 0; y < height; y += 16) {
  675.                 for (x = 0; x < width; x += 16) {
  676.                     result = svq1_decode_block_intra(&s->gb, &current[x],
  677.                                                      linesize);
  678.                     if (result) {
  679.                         av_log(avctx, AV_LOG_ERROR,
  680.                                "Error in svq1_decode_block %i (keyframe)\n",
  681.                                result);
  682.                         goto err;
  683.                     }
  684.                 }
  685.                 current += 16 * linesize;
  686.             }
  687.         } else {
  688.             /* delta frame */
  689.             uint8_t *previous = s->prev->data[i];
  690.             if (!previous ||
  691.                 s->prev->width != s->width || s->prev->height != s->height) {
  692.                 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
  693.                 result = AVERROR_INVALIDDATA;
  694.                 goto err;
  695.             }
  696.  
  697.             memset(pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
  698.  
  699.             for (y = 0; y < height; y += 16) {
  700.                 for (x = 0; x < width; x += 16) {
  701.                     result = svq1_decode_delta_block(avctx, &s->hdsp,
  702.                                                      &s->gb, &current[x],
  703.                                                      previous, linesize,
  704.                                                      pmv, x, y, width, height);
  705.                     if (result != 0) {
  706.                         av_dlog(avctx,
  707.                                 "Error in svq1_decode_delta_block %i\n",
  708.                                 result);
  709.                         goto err;
  710.                     }
  711.                 }
  712.  
  713.                 pmv[0].x     =
  714.                     pmv[0].y = 0;
  715.  
  716.                 current += 16 * linesize;
  717.             }
  718.         }
  719.     }
  720.  
  721.     if (!s->nonref) {
  722.         av_frame_unref(s->prev);
  723.         result = av_frame_ref(s->prev, cur);
  724.         if (result < 0)
  725.             goto err;
  726.     }
  727.  
  728.     *got_frame = 1;
  729.     result     = buf_size;
  730.  
  731. err:
  732.     av_free(pmv);
  733.     return result;
  734. }
  735.  
  736. static av_cold int svq1_decode_init(AVCodecContext *avctx)
  737. {
  738.     SVQ1Context *s = avctx->priv_data;
  739.     int i;
  740.     int offset = 0;
  741.  
  742.     s->prev = avcodec_alloc_frame();
  743.     if (!s->prev)
  744.         return AVERROR(ENOMEM);
  745.  
  746.     s->width            = avctx->width  + 3 & ~3;
  747.     s->height           = avctx->height + 3 & ~3;
  748.     avctx->pix_fmt      = AV_PIX_FMT_YUV410P;
  749.  
  750.     ff_hpeldsp_init(&s->hdsp, avctx->flags);
  751.  
  752.     INIT_VLC_STATIC(&svq1_block_type, 2, 4,
  753.                     &ff_svq1_block_type_vlc[0][1], 2, 1,
  754.                     &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
  755.  
  756.     INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
  757.                     &ff_mvtab[0][1], 2, 1,
  758.                     &ff_mvtab[0][0], 2, 1, 176);
  759.  
  760.     for (i = 0; i < 6; i++) {
  761.         static const uint8_t sizes[2][6] = { { 14, 10, 14, 18, 16, 18 },
  762.                                              { 10, 10, 14, 14, 14, 16 } };
  763.         static VLC_TYPE table[168][2];
  764.         svq1_intra_multistage[i].table           = &table[offset];
  765.         svq1_intra_multistage[i].table_allocated = sizes[0][i];
  766.         offset                                  += sizes[0][i];
  767.         init_vlc(&svq1_intra_multistage[i], 3, 8,
  768.                  &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
  769.                  &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1,
  770.                  INIT_VLC_USE_NEW_STATIC);
  771.         svq1_inter_multistage[i].table           = &table[offset];
  772.         svq1_inter_multistage[i].table_allocated = sizes[1][i];
  773.         offset                                  += sizes[1][i];
  774.         init_vlc(&svq1_inter_multistage[i], 3, 8,
  775.                  &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
  776.                  &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1,
  777.                  INIT_VLC_USE_NEW_STATIC);
  778.     }
  779.  
  780.     INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
  781.                     &ff_svq1_intra_mean_vlc[0][1], 4, 2,
  782.                     &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
  783.  
  784.     INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
  785.                     &ff_svq1_inter_mean_vlc[0][1], 4, 2,
  786.                     &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
  787.  
  788.     return 0;
  789. }
  790.  
  791. static av_cold int svq1_decode_end(AVCodecContext *avctx)
  792. {
  793.     SVQ1Context *s = avctx->priv_data;
  794.  
  795.     av_frame_free(&s->prev);
  796.  
  797.     return 0;
  798. }
  799.  
  800. static void svq1_flush(AVCodecContext *avctx)
  801. {
  802.     SVQ1Context *s = avctx->priv_data;
  803.  
  804.     av_frame_unref(s->prev);
  805. }
  806.  
  807. AVCodec ff_svq1_decoder = {
  808.     .name           = "svq1",
  809.     .long_name      = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
  810.     .type           = AVMEDIA_TYPE_VIDEO,
  811.     .id             = AV_CODEC_ID_SVQ1,
  812.     .priv_data_size = sizeof(SVQ1Context),
  813.     .init           = svq1_decode_init,
  814.     .close          = svq1_decode_end,
  815.     .decode         = svq1_decode_frame,
  816.     .capabilities   = CODEC_CAP_DR1,
  817.     .flush          = svq1_flush,
  818.     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,
  819.                                                      AV_PIX_FMT_NONE },
  820. };
  821.