LCOV - code coverage report
Current view: top level - libavcodec - svq1dec.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 291 345 84.3 %
Date: 2017-12-18 20:14:19 Functions: 11 13 84.6 %

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

Generated by: LCOV version 1.13