git.sesse.net Git - ffmpeg/blob - libavcodec/svq1dec.c

   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 Libav.
  12  *
  13  * Libav 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  * Libav 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 Libav; 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
  36 //#define DEBUG_SVQ1
  37 #include "avcodec.h"
  38 #include "dsputil.h"
  39 #include "mpegvideo.h"
  40 #include "mathops.h"
  41
  42 #include "svq1.h"
  43
  44 #undef NDEBUG
  45 #include <assert.h>
  46
  47 extern const uint8_t mvtab[33][2];
  48
  49 static VLC svq1_block_type;
  50 static VLC svq1_motion_component;
  51 static VLC svq1_intra_multistage[6];
  52 static VLC svq1_inter_multistage[6];
  53 static VLC svq1_intra_mean;
  54 static VLC svq1_inter_mean;
  55
  56 /* motion vector (prediction) */
  57 typedef struct svq1_pmv_s {
  58   int           x;
  59   int           y;
  60 } svq1_pmv;
  61
  62 static const uint16_t checksum_table[256] = {
  63   0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
  64   0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
  65   0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
  66   0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
  67   0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
  68   0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
  69   0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
  70   0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
  71   0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
  72   0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
  73   0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
  74   0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
  75   0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
  76   0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
  77   0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
  78   0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
  79   0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
  80   0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
  81   0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
  82   0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
  83   0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
  84   0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
  85   0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
  86   0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
  87   0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
  88   0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
  89   0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
  90   0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
  91   0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
  92   0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
  93   0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
  94   0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
  95 };
  96
  97 static const uint8_t string_table[256] = {
  98   0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
  99   0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
 100   0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
 101   0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
 102   0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
 103   0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
 104   0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
 105   0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
 106   0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
 107   0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
 108   0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
 109   0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
 110   0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
 111   0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
 112   0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
 113   0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
 114   0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
 115   0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
 116   0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
 117   0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
 118   0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
 119   0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
 120   0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
 121   0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
 122   0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
 123   0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
 124   0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
 125   0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
 126   0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
 127   0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
 128   0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
 129   0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
 130 };
 131
 132 #define SVQ1_PROCESS_VECTOR()\
 133     for (; level > 0; i++) {\
 134       /* process next depth */\
 135       if (i == m) {\
 136         m = n;\
 137         if (--level == 0)\
 138           break;\
 139       }\
 140       /* divide block if next bit set */\
 141       if (get_bits1 (bitbuf) == 0)\
 142         break;\
 143       /* add child nodes */\
 144       list[n++] = list[i];\
 145       list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));\
 146     }
 147
 148 #define SVQ1_ADD_CODEBOOK()\
 149           /* add codebook entries to vector */\
 150           for (j=0; j < stages; j++) {\
 151             n3  = codebook[entries[j]] ^ 0x80808080;\
 152             n1 += ((n3 & 0xFF00FF00) >> 8);\
 153             n2 +=  (n3 & 0x00FF00FF);\
 154           }\
 155 \
 156           /* clip to [0..255] */\
 157           if (n1 & 0xFF00FF00) {\
 158             n3  = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
 159             n1 += 0x7F007F00;\
 160             n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
 161             n1 &= (n3 & 0x00FF00FF);\
 162           }\
 163 \
 164           if (n2 & 0xFF00FF00) {\
 165             n3  = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
 166             n2 += 0x7F007F00;\
 167             n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
 168             n2 &= (n3 & 0x00FF00FF);\
 169           }
 170
 171 #define SVQ1_DO_CODEBOOK_INTRA()\
 172       for (y=0; y < height; y++) {\
 173         for (x=0; x < (width / 4); x++, codebook++) {\
 174         n1 = n4;\
 175         n2 = n4;\
 176         SVQ1_ADD_CODEBOOK()\
 177         /* store result */\
 178         dst[x] = (n1 << 8) | n2;\
 179         }\
 180         dst += (pitch / 4);\
 181       }
 182
 183 #define SVQ1_DO_CODEBOOK_NONINTRA()\
 184       for (y=0; y < height; y++) {\
 185         for (x=0; x < (width / 4); x++, codebook++) {\
 186         n3 = dst[x];\
 187         /* add mean value to vector */\
 188         n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\
 189         n2 =  (n3 & 0x00FF00FF)          + n4;\
 190         SVQ1_ADD_CODEBOOK()\
 191         /* store result */\
 192         dst[x] = (n1 << 8) | n2;\
 193         }\
 194         dst += (pitch / 4);\
 195       }
 196
 197 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\
 198       codebook = (const uint32_t *) cbook[level];\
 199       bit_cache = get_bits (bitbuf, 4*stages);\
 200       /* calculate codebook entries for this vector */\
 201       for (j=0; j < stages; j++) {\
 202         entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\
 203       }\
 204       mean -= (stages * 128);\
 205       n4    = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
 206
 207 static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
 208   uint32_t    bit_cache;
 209   uint8_t    *list[63];
 210   uint32_t   *dst;
 211   const uint32_t *codebook;
 212   int         entries[6];
 213   int         i, j, m, n;
 214   int         mean, stages;
 215   unsigned    x, y, width, height, level;
 216   uint32_t    n1, n2, n3, n4;
 217
 218   /* initialize list for breadth first processing of vectors */
 219   list[0] = pixels;
 220
 221   /* recursively process vector */
 222   for (i=0, m=1, n=1, level=5; i < n; i++) {
 223     SVQ1_PROCESS_VECTOR();
 224
 225     /* destination address and vector size */
 226     dst = (uint32_t *) list[i];
 227     width = 1 << ((4 + level) /2);
 228     height = 1 << ((3 + level) /2);
 229
 230     /* get number of stages (-1 skips vector, 0 for mean only) */
 231     stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
 232
 233     if (stages == -1) {
 234         for (y=0; y < height; y++) {
 235           memset (&dst[y*(pitch / 4)], 0, width);
 236         }
 237       continue;                 /* skip vector */
 238     }
 239
 240     if ((stages > 0) && (level >= 4)) {
 241 #ifdef DEBUG_SVQ1
 242     av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level);
 243 #endif
 244       return -1;        /* invalid vector */
 245     }
 246
 247     mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
 248
 249     if (stages == 0) {
 250       for (y=0; y < height; y++) {
 251         memset (&dst[y*(pitch / 4)], mean, width);
 252       }
 253     } else {
 254       SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
 255       SVQ1_DO_CODEBOOK_INTRA()
 256     }
 257   }
 258
 259   return 0;
 260 }
 261
 262 static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
 263   uint32_t    bit_cache;
 264   uint8_t    *list[63];
 265   uint32_t   *dst;
 266   const uint32_t *codebook;
 267   int         entries[6];
 268   int         i, j, m, n;
 269   int         mean, stages;
 270   int         x, y, width, height, level;
 271   uint32_t    n1, n2, n3, n4;
 272
 273   /* initialize list for breadth first processing of vectors */
 274   list[0] = pixels;
 275
 276   /* recursively process vector */
 277   for (i=0, m=1, n=1, level=5; i < n; i++) {
 278     SVQ1_PROCESS_VECTOR();
 279
 280     /* destination address and vector size */
 281     dst = (uint32_t *) list[i];
 282     width = 1 << ((4 + level) /2);
 283     height = 1 << ((3 + level) /2);
 284
 285     /* get number of stages (-1 skips vector, 0 for mean only) */
 286     stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
 287
 288     if (stages == -1) continue; /* skip vector */
 289
 290     if ((stages > 0) && (level >= 4)) {
 291 #ifdef DEBUG_SVQ1
 292     av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",stages,level);
 293 #endif
 294       return -1;        /* invalid vector */
 295     }
 296
 297     mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
 298
 299     SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
 300     SVQ1_DO_CODEBOOK_NONINTRA()
 301   }
 302   return 0;
 303 }
 304
 305 static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv *mv, svq1_pmv **pmv) {
 306   int        diff;
 307   int        i;
 308
 309   for (i=0; i < 2; i++) {
 310
 311     /* get motion code */
 312     diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
 313     if(diff<0)
 314         return -1;
 315     else if(diff){
 316         if(get_bits1(bitbuf)) diff= -diff;
 317     }
 318
 319     /* add median of motion vector predictors and clip result */
 320     if (i == 1)
 321       mv->y = ((diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26;
 322     else
 323       mv->x = ((diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x)) << 26) >> 26;
 324   }
 325
 326   return 0;
 327 }
 328
 329 static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) {
 330   uint8_t *src;
 331   uint8_t *dst;
 332   int      i;
 333
 334   src = &previous[x + y*pitch];
 335   dst = current;
 336
 337   for (i=0; i < 16; i++) {
 338     memcpy (dst, src, 16);
 339     src += pitch;
 340     dst += pitch;
 341   }
 342 }
 343
 344 static int svq1_motion_inter_block (MpegEncContext *s, GetBitContext *bitbuf,
 345                                uint8_t *current, uint8_t *previous, int pitch,
 346                                svq1_pmv *motion, int x, int y) {
 347   uint8_t    *src;
 348   uint8_t    *dst;
 349   svq1_pmv    mv;
 350   svq1_pmv   *pmv[3];
 351   int         result;
 352
 353   /* predict and decode motion vector */
 354   pmv[0] = &motion[0];
 355   if (y == 0) {
 356     pmv[1] =
 357     pmv[2] = pmv[0];
 358   }
 359   else {
 360     pmv[1] = &motion[(x / 8) + 2];
 361     pmv[2] = &motion[(x / 8) + 4];
 362   }
 363
 364   result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
 365
 366   if (result != 0)
 367     return result;
 368
 369   motion[0].x                =
 370   motion[(x / 8) + 2].x      =
 371   motion[(x / 8) + 3].x      = mv.x;
 372   motion[0].y                =
 373   motion[(x / 8) + 2].y      =
 374   motion[(x / 8) + 3].y      = mv.y;
 375
 376   if(y + (mv.y >> 1)<0)
 377      mv.y= 0;
 378   if(x + (mv.x >> 1)<0)
 379      mv.x= 0;
 380
 381   src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
 382   dst = current;
 383
 384   s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16);
 385
 386   return 0;
 387 }
 388
 389 static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
 390                                   uint8_t *current, uint8_t *previous, int pitch,
 391                                   svq1_pmv *motion,int x, int y) {
 392   uint8_t    *src;
 393   uint8_t    *dst;
 394   svq1_pmv    mv;
 395   svq1_pmv   *pmv[4];
 396   int         i, result;
 397
 398   /* predict and decode motion vector (0) */
 399   pmv[0] = &motion[0];
 400   if (y == 0) {
 401     pmv[1] =
 402     pmv[2] = pmv[0];
 403   }
 404   else {
 405     pmv[1] = &motion[(x / 8) + 2];
 406     pmv[2] = &motion[(x / 8) + 4];
 407   }
 408
 409   result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
 410
 411   if (result != 0)
 412     return result;
 413
 414   /* predict and decode motion vector (1) */
 415   pmv[0] = &mv;
 416   if (y == 0) {
 417     pmv[1] =
 418     pmv[2] = pmv[0];
 419   }
 420   else {
 421     pmv[1] = &motion[(x / 8) + 3];
 422   }
 423   result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
 424
 425   if (result != 0)
 426     return result;
 427
 428   /* predict and decode motion vector (2) */
 429   pmv[1] = &motion[0];
 430   pmv[2] = &motion[(x / 8) + 1];
 431
 432   result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
 433
 434   if (result != 0)
 435     return result;
 436
 437   /* predict and decode motion vector (3) */
 438   pmv[2] = &motion[(x / 8) + 2];
 439   pmv[3] = &motion[(x / 8) + 3];
 440
 441   result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
 442
 443   if (result != 0)
 444     return result;
 445
 446   /* form predictions */
 447   for (i=0; i < 4; i++) {
 448     int mvx= pmv[i]->x + (i&1)*16;
 449     int mvy= pmv[i]->y + (i>>1)*16;
 450
 451     ///XXX /FIXME clipping or padding?
 452     if(y + (mvy >> 1)<0)
 453        mvy= 0;
 454     if(x + (mvx >> 1)<0)
 455        mvx= 0;
 456
 457     src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch];
 458     dst = current;
 459
 460     s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
 461
 462     /* select next block */
 463     if (i & 1) {
 464       current  += 8*(pitch - 1);
 465     } else {
 466       current  += 8;
 467     }
 468   }
 469
 470   return 0;
 471 }
 472
 473 static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf,
 474                         uint8_t *current, uint8_t *previous, int pitch,
 475                         svq1_pmv *motion, int x, int y) {
 476   uint32_t block_type;
 477   int      result = 0;
 478
 479   /* get block type */
 480   block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
 481
 482   /* reset motion vectors */
 483   if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
 484     motion[0].x                 =
 485     motion[0].y                 =
 486     motion[(x / 8) + 2].x =
 487     motion[(x / 8) + 2].y =
 488     motion[(x / 8) + 3].x =
 489     motion[(x / 8) + 3].y = 0;
 490   }
 491
 492   switch (block_type) {
 493   case SVQ1_BLOCK_SKIP:
 494     svq1_skip_block (current, previous, pitch, x, y);
 495     break;
 496
 497   case SVQ1_BLOCK_INTER:
 498     result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y);
 499
 500     if (result != 0)
 501     {
 502 #ifdef DEBUG_SVQ1
 503     av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_block %i\n",result);
 504 #endif
 505       break;
 506     }
 507     result = svq1_decode_block_non_intra (bitbuf, current, pitch);
 508     break;
 509
 510   case SVQ1_BLOCK_INTER_4V:
 511     result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
 512
 513     if (result != 0)
 514     {
 515 #ifdef DEBUG_SVQ1
 516     av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_4v_block %i\n",result);
 517 #endif
 518       break;
 519     }
 520     result = svq1_decode_block_non_intra (bitbuf, current, pitch);
 521     break;
 522
 523   case SVQ1_BLOCK_INTRA:
 524     result = svq1_decode_block_intra (bitbuf, current, pitch);
 525     break;
 526   }
 527
 528   return result;
 529 }
 530
 531 uint16_t ff_svq1_packet_checksum (const uint8_t *data, const int length, int value) {
 532   int i;
 533
 534   for (i=0; i < length; i++) {
 535     value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
 536   }
 537
 538   return value;
 539 }
 540
 541 static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
 542   uint8_t seed;
 543   int     i;
 544
 545   out[0] = get_bits (bitbuf, 8);
 546
 547   seed = string_table[out[0]];
 548
 549   for (i=1; i <= out[0]; i++) {
 550     out[i] = get_bits (bitbuf, 8) ^ seed;
 551     seed   = string_table[out[i] ^ seed];
 552   }
 553 }
 554
 555 static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
 556   int frame_size_code;
 557   int temporal_reference;
 558
 559   temporal_reference = get_bits (bitbuf, 8);
 560
 561   /* frame type */
 562   s->pict_type= get_bits (bitbuf, 2)+1;
 563   if(s->pict_type==4)
 564       return -1;
 565
 566   if (s->pict_type == AV_PICTURE_TYPE_I) {
 567
 568     /* unknown fields */
 569     if (s->f_code == 0x50 || s->f_code == 0x60) {
 570       int csum = get_bits (bitbuf, 16);
 571
 572       csum = ff_svq1_packet_checksum (bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
 573
 574 //      av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
 575 //              (csum == 0) ? "correct" : "incorrect", csum);
 576     }
 577
 578     if ((s->f_code ^ 0x10) >= 0x50) {
 579       uint8_t msg[256];
 580
 581       svq1_parse_string (bitbuf, msg);
 582
 583       av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
 584     }
 585
 586     skip_bits (bitbuf, 2);
 587     skip_bits (bitbuf, 2);
 588     skip_bits1 (bitbuf);
 589
 590     /* load frame size */
 591     frame_size_code = get_bits (bitbuf, 3);
 592
 593     if (frame_size_code == 7) {
 594       /* load width, height (12 bits each) */
 595       s->width = get_bits (bitbuf, 12);
 596       s->height = get_bits (bitbuf, 12);
 597
 598       if (!s->width || !s->height)
 599         return -1;
 600     } else {
 601       /* get width, height from table */
 602       s->width = ff_svq1_frame_size_table[frame_size_code].width;
 603       s->height = ff_svq1_frame_size_table[frame_size_code].height;
 604     }
 605   }
 606
 607   /* unknown fields */
 608   if (get_bits1 (bitbuf) == 1) {
 609     skip_bits1 (bitbuf);       /* use packet checksum if (1) */
 610     skip_bits1 (bitbuf);       /* component checksums after image data if (1) */
 611
 612     if (get_bits (bitbuf, 2) != 0)
 613       return -1;
 614   }
 615
 616   if (get_bits1 (bitbuf) == 1) {
 617     skip_bits1 (bitbuf);
 618     skip_bits (bitbuf, 4);
 619     skip_bits1 (bitbuf);
 620     skip_bits (bitbuf, 2);
 621
 622     while (get_bits1 (bitbuf) == 1) {
 623       skip_bits (bitbuf, 8);
 624     }
 625   }
 626
 627   return 0;
 628 }
 629
 630 static int svq1_decode_frame(AVCodecContext *avctx,
 631                              void *data, int *data_size,
 632                              AVPacket *avpkt)
 633 {
 634   const uint8_t *buf = avpkt->data;
 635   int buf_size = avpkt->size;
 636   MpegEncContext *s=avctx->priv_data;
 637   uint8_t        *current, *previous;
 638   int             result, i, x, y, width, height;
 639   AVFrame *pict = data;
 640   svq1_pmv *pmv;
 641
 642   /* initialize bit buffer */
 643   init_get_bits(&s->gb,buf,buf_size*8);
 644
 645   /* decode frame header */
 646   s->f_code = get_bits (&s->gb, 22);
 647
 648   if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
 649     return -1;
 650
 651   /* swap some header bytes (why?) */
 652   if (s->f_code != 0x20) {
 653     uint32_t *src = (uint32_t *) (buf + 4);
 654
 655     for (i=0; i < 4; i++) {
 656       src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
 657     }
 658   }
 659
 660   result = svq1_decode_frame_header (&s->gb, s);
 661
 662   if (result != 0)
 663   {
 664 #ifdef DEBUG_SVQ1
 665     av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result);
 666 #endif
 667     return result;
 668   }
 669
 670   //FIXME this avoids some confusion for "B frames" without 2 references
 671   //this should be removed after libavcodec can handle more flexible picture types & ordering
 672   if(s->pict_type==AV_PICTURE_TYPE_B && s->last_picture_ptr==NULL) return buf_size;
 673
 674   if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==AV_PICTURE_TYPE_B)
 675      ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=AV_PICTURE_TYPE_I)
 676      || avctx->skip_frame >= AVDISCARD_ALL)
 677       return buf_size;
 678
 679   if(MPV_frame_start(s, avctx) < 0)
 680       return -1;
 681
 682   pmv = av_malloc((FFALIGN(s->width, 16)/8 + 3) * sizeof(*pmv));
 683   if (!pmv)
 684       return -1;
 685
 686   /* decode y, u and v components */
 687   for (i=0; i < 3; i++) {
 688     int linesize;
 689     if (i == 0) {
 690       width  = FFALIGN(s->width, 16);
 691       height = FFALIGN(s->height, 16);
 692       linesize= s->linesize;
 693     } else {
 694       if(s->flags&CODEC_FLAG_GRAY) break;
 695       width  = FFALIGN(s->width/4, 16);
 696       height = FFALIGN(s->height/4, 16);
 697       linesize= s->uvlinesize;
 698     }
 699
 700     current  = s->current_picture.data[i];
 701
 702     if(s->pict_type==AV_PICTURE_TYPE_B){
 703         previous = s->next_picture.data[i];
 704     }else{
 705         previous = s->last_picture.data[i];
 706     }
 707
 708     if (s->pict_type == AV_PICTURE_TYPE_I) {
 709       /* keyframe */
 710       for (y=0; y < height; y+=16) {
 711         for (x=0; x < width; x+=16) {
 712           result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
 713           if (result != 0)
 714           {
 715 //#ifdef DEBUG_SVQ1
 716             av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
 717 //#endif
 718             goto err;
 719           }
 720         }
 721         current += 16*linesize;
 722       }
 723     } else {
 724       /* delta frame */
 725       memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
 726
 727       for (y=0; y < height; y+=16) {
 728         for (x=0; x < width; x+=16) {
 729           result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
 730                                             linesize, pmv, x, y);
 731           if (result != 0)
 732           {
 733 #ifdef DEBUG_SVQ1
 734     av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result);
 735 #endif
 736             goto err;
 737           }
 738         }
 739
 740         pmv[0].x =
 741         pmv[0].y = 0;
 742
 743         current += 16*linesize;
 744       }
 745     }
 746   }
 747
 748   *pict = *(AVFrame*)&s->current_picture;
 749
 750
 751   MPV_frame_end(s);
 752
 753   *data_size=sizeof(AVFrame);
 754   result = buf_size;
 755 err:
 756   av_free(pmv);
 757   return result;
 758 }
 759
 760 static av_cold int svq1_decode_init(AVCodecContext *avctx)
 761 {
 762     MpegEncContext *s = avctx->priv_data;
 763     int i;
 764     int offset = 0;
 765
 766     MPV_decode_defaults(s);
 767
 768     s->avctx = avctx;
 769     s->width = (avctx->width+3)&~3;
 770     s->height = (avctx->height+3)&~3;
 771     s->codec_id= avctx->codec->id;
 772     avctx->pix_fmt = PIX_FMT_YUV410P;
 773     avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
 774     s->flags= avctx->flags;
 775     if (MPV_common_init(s) < 0) return -1;
 776
 777     INIT_VLC_STATIC(&svq1_block_type, 2, 4,
 778         &ff_svq1_block_type_vlc[0][1], 2, 1,
 779         &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
 780
 781     INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
 782         &mvtab[0][1], 2, 1,
 783         &mvtab[0][0], 2, 1, 176);
 784
 785     for (i = 0; i < 6; i++) {
 786         static const uint8_t sizes[2][6] = {{14, 10, 14, 18, 16, 18}, {10, 10, 14, 14, 14, 16}};
 787         static VLC_TYPE table[168][2];
 788         svq1_intra_multistage[i].table = &table[offset];
 789         svq1_intra_multistage[i].table_allocated = sizes[0][i];
 790         offset += sizes[0][i];
 791         init_vlc(&svq1_intra_multistage[i], 3, 8,
 792             &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
 793             &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
 794         svq1_inter_multistage[i].table = &table[offset];
 795         svq1_inter_multistage[i].table_allocated = sizes[1][i];
 796         offset += sizes[1][i];
 797         init_vlc(&svq1_inter_multistage[i], 3, 8,
 798             &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
 799             &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
 800     }
 801
 802     INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
 803         &ff_svq1_intra_mean_vlc[0][1], 4, 2,
 804         &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
 805
 806     INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
 807         &ff_svq1_inter_mean_vlc[0][1], 4, 2,
 808         &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
 809
 810     return 0;
 811 }
 812
 813 static av_cold int svq1_decode_end(AVCodecContext *avctx)
 814 {
 815     MpegEncContext *s = avctx->priv_data;
 816
 817     MPV_common_end(s);
 818     return 0;
 819 }
 820
 821
 822 AVCodec ff_svq1_decoder = {
 823     "svq1",
 824     AVMEDIA_TYPE_VIDEO,
 825     CODEC_ID_SVQ1,
 826     sizeof(MpegEncContext),
 827     svq1_decode_init,
 828     NULL,
 829     svq1_decode_end,
 830     svq1_decode_frame,
 831     CODEC_CAP_DR1,
 832     .flush= ff_mpeg_flush,
 833     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE},
 834     .long_name= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
 835 };