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