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 #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 ff_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       if (stages > 0)\
 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       av_dlog(NULL,
 242               "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
 243               stages, level);
 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       av_dlog(NULL,
 292               "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
 293               stages, level);
 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 = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
 322     else
 323       mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
 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       av_dlog(s->avctx, "Error in svq1_motion_inter_block %i\n", result);
 503       break;
 504     }
 505     result = svq1_decode_block_non_intra (bitbuf, current, pitch);
 506     break;
 507
 508   case SVQ1_BLOCK_INTER_4V:
 509     result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
 510
 511     if (result != 0)
 512     {
 513       av_dlog(s->avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
 514       break;
 515     }
 516     result = svq1_decode_block_non_intra (bitbuf, current, pitch);
 517     break;
 518
 519   case SVQ1_BLOCK_INTRA:
 520     result = svq1_decode_block_intra (bitbuf, current, pitch);
 521     break;
 522   }
 523
 524   return result;
 525 }
 526
 527 uint16_t ff_svq1_packet_checksum (const uint8_t *data, const int length, int value) {
 528   int i;
 529
 530   for (i=0; i < length; i++) {
 531     value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
 532   }
 533
 534   return value;
 535 }
 536
 537 static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
 538   uint8_t seed;
 539   int     i;
 540
 541   out[0] = get_bits (bitbuf, 8);
 542
 543   seed = string_table[out[0]];
 544
 545   for (i=1; i <= out[0]; i++) {
 546     out[i] = get_bits (bitbuf, 8) ^ seed;
 547     seed   = string_table[out[i] ^ seed];
 548   }
 549 }
 550
 551 static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
 552   int frame_size_code;
 553
 554   skip_bits(bitbuf, 8); /* temporal_reference */
 555
 556   /* frame type */
 557   s->pict_type= get_bits (bitbuf, 2)+1;
 558   if(s->pict_type==4)
 559       return -1;
 560
 561   if (s->pict_type == AV_PICTURE_TYPE_I) {
 562
 563     /* unknown fields */
 564     if (s->f_code == 0x50 || s->f_code == 0x60) {
 565       int csum = get_bits (bitbuf, 16);
 566
 567       csum = ff_svq1_packet_checksum (bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
 568
 569 //      av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
 570 //              (csum == 0) ? "correct" : "incorrect", csum);
 571     }
 572
 573     if ((s->f_code ^ 0x10) >= 0x50) {
 574       uint8_t msg[256];
 575
 576       svq1_parse_string (bitbuf, msg);
 577
 578       av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
 579     }
 580
 581     skip_bits (bitbuf, 2);
 582     skip_bits (bitbuf, 2);
 583     skip_bits1 (bitbuf);
 584
 585     /* load frame size */
 586     frame_size_code = get_bits (bitbuf, 3);
 587
 588     if (frame_size_code == 7) {
 589       /* load width, height (12 bits each) */
 590       s->width = get_bits (bitbuf, 12);
 591       s->height = get_bits (bitbuf, 12);
 592
 593       if (!s->width || !s->height)
 594         return -1;
 595     } else {
 596       /* get width, height from table */
 597       s->width = ff_svq1_frame_size_table[frame_size_code].width;
 598       s->height = ff_svq1_frame_size_table[frame_size_code].height;
 599     }
 600   }
 601
 602   /* unknown fields */
 603   if (get_bits1 (bitbuf) == 1) {
 604     skip_bits1 (bitbuf);       /* use packet checksum if (1) */
 605     skip_bits1 (bitbuf);       /* component checksums after image data if (1) */
 606
 607     if (get_bits (bitbuf, 2) != 0)
 608       return -1;
 609   }
 610
 611   if (get_bits1 (bitbuf) == 1) {
 612     skip_bits1 (bitbuf);
 613     skip_bits (bitbuf, 4);
 614     skip_bits1 (bitbuf);
 615     skip_bits (bitbuf, 2);
 616
 617     while (get_bits1 (bitbuf) == 1) {
 618       skip_bits (bitbuf, 8);
 619     }
 620   }
 621
 622   return 0;
 623 }
 624
 625 static int svq1_decode_frame(AVCodecContext *avctx,
 626                              void *data, int *data_size,
 627                              AVPacket *avpkt)
 628 {
 629   const uint8_t *buf = avpkt->data;
 630   int buf_size = avpkt->size;
 631   MpegEncContext *s=avctx->priv_data;
 632   uint8_t        *current, *previous;
 633   int             result, i, x, y, width, height;
 634   AVFrame *pict = data;
 635   svq1_pmv *pmv;
 636
 637   /* initialize bit buffer */
 638   init_get_bits(&s->gb,buf,buf_size*8);
 639
 640   /* decode frame header */
 641   s->f_code = get_bits (&s->gb, 22);
 642
 643   if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
 644     return -1;
 645
 646   /* swap some header bytes (why?) */
 647   if (s->f_code != 0x20) {
 648     uint32_t *src = (uint32_t *) (buf + 4);
 649
 650     for (i=0; i < 4; i++) {
 651       src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
 652     }
 653   }
 654
 655   result = svq1_decode_frame_header (&s->gb, s);
 656
 657   if (result != 0)
 658   {
 659     av_dlog(s->avctx, "Error in svq1_decode_frame_header %i\n",result);
 660     return result;
 661   }
 662   avcodec_set_dimensions(avctx, s->width, s->height);
 663
 664   //FIXME this avoids some confusion for "B frames" without 2 references
 665   //this should be removed after libavcodec can handle more flexible picture types & ordering
 666   if(s->pict_type==AV_PICTURE_TYPE_B && s->last_picture_ptr==NULL) return buf_size;
 667
 668   if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==AV_PICTURE_TYPE_B)
 669      ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=AV_PICTURE_TYPE_I)
 670      || avctx->skip_frame >= AVDISCARD_ALL)
 671       return buf_size;
 672
 673   if(ff_MPV_frame_start(s, avctx) < 0)
 674       return -1;
 675
 676   pmv = av_malloc((FFALIGN(s->width, 16)/8 + 3) * sizeof(*pmv));
 677   if (!pmv)
 678       return -1;
 679
 680   /* decode y, u and v components */
 681   for (i=0; i < 3; i++) {
 682     int linesize;
 683     if (i == 0) {
 684       width  = FFALIGN(s->width, 16);
 685       height = FFALIGN(s->height, 16);
 686       linesize= s->linesize;
 687     } else {
 688       if(s->flags&CODEC_FLAG_GRAY) break;
 689       width  = FFALIGN(s->width/4, 16);
 690       height = FFALIGN(s->height/4, 16);
 691       linesize= s->uvlinesize;
 692     }
 693
 694     current = s->current_picture.f.data[i];
 695
 696     if(s->pict_type==AV_PICTURE_TYPE_B){
 697         previous = s->next_picture.f.data[i];
 698     }else{
 699         previous = s->last_picture.f.data[i];
 700     }
 701
 702     if (s->pict_type == AV_PICTURE_TYPE_I) {
 703       /* keyframe */
 704       for (y=0; y < height; y+=16) {
 705         for (x=0; x < width; x+=16) {
 706           result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
 707           if (result != 0)
 708           {
 709             av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
 710             goto err;
 711           }
 712         }
 713         current += 16*linesize;
 714       }
 715     } else {
 716       /* delta frame */
 717       memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
 718
 719       for (y=0; y < height; y+=16) {
 720         for (x=0; x < width; x+=16) {
 721           result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
 722                                             linesize, pmv, x, y);
 723           if (result != 0)
 724           {
 725             av_dlog(s->avctx, "Error in svq1_decode_delta_block %i\n",result);
 726             goto err;
 727           }
 728         }
 729
 730         pmv[0].x =
 731         pmv[0].y = 0;
 732
 733         current += 16*linesize;
 734       }
 735     }
 736   }
 737
 738   *pict = s->current_picture.f;
 739
 740
 741   ff_MPV_frame_end(s);
 742
 743   *data_size=sizeof(AVFrame);
 744   result = buf_size;
 745 err:
 746   av_free(pmv);
 747   return result;
 748 }
 749
 750 static av_cold int svq1_decode_init(AVCodecContext *avctx)
 751 {
 752     MpegEncContext *s = avctx->priv_data;
 753     int i;
 754     int offset = 0;
 755
 756     ff_MPV_decode_defaults(s);
 757
 758     s->avctx = avctx;
 759     s->width = (avctx->width+3)&~3;
 760     s->height = (avctx->height+3)&~3;
 761     s->codec_id= avctx->codec->id;
 762     avctx->pix_fmt = PIX_FMT_YUV410P;
 763     avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
 764     s->flags= avctx->flags;
 765     if (ff_MPV_common_init(s) < 0) return -1;
 766
 767     INIT_VLC_STATIC(&svq1_block_type, 2, 4,
 768         &ff_svq1_block_type_vlc[0][1], 2, 1,
 769         &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
 770
 771     INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
 772         &ff_mvtab[0][1], 2, 1,
 773         &ff_mvtab[0][0], 2, 1, 176);
 774
 775     for (i = 0; i < 6; i++) {
 776         static const uint8_t sizes[2][6] = {{14, 10, 14, 18, 16, 18}, {10, 10, 14, 14, 14, 16}};
 777         static VLC_TYPE table[168][2];
 778         svq1_intra_multistage[i].table = &table[offset];
 779         svq1_intra_multistage[i].table_allocated = sizes[0][i];
 780         offset += sizes[0][i];
 781         init_vlc(&svq1_intra_multistage[i], 3, 8,
 782             &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
 783             &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
 784         svq1_inter_multistage[i].table = &table[offset];
 785         svq1_inter_multistage[i].table_allocated = sizes[1][i];
 786         offset += sizes[1][i];
 787         init_vlc(&svq1_inter_multistage[i], 3, 8,
 788             &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
 789             &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
 790     }
 791
 792     INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
 793         &ff_svq1_intra_mean_vlc[0][1], 4, 2,
 794         &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
 795
 796     INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
 797         &ff_svq1_inter_mean_vlc[0][1], 4, 2,
 798         &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
 799
 800     return 0;
 801 }
 802
 803 static av_cold int svq1_decode_end(AVCodecContext *avctx)
 804 {
 805     MpegEncContext *s = avctx->priv_data;
 806
 807     ff_MPV_common_end(s);
 808     return 0;
 809 }
 810
 811
 812 AVCodec ff_svq1_decoder = {
 813     .name           = "svq1",
 814     .type           = AVMEDIA_TYPE_VIDEO,
 815     .id             = CODEC_ID_SVQ1,
 816     .priv_data_size = sizeof(MpegEncContext),
 817     .init           = svq1_decode_init,
 818     .close          = svq1_decode_end,
 819     .decode         = svq1_decode_frame,
 820     .capabilities   = CODEC_CAP_DR1,
 821     .flush          = ff_mpeg_flush,
 822     .pix_fmts       = (const enum PixelFormat[]){ PIX_FMT_YUV410P, PIX_FMT_NONE },
 823     .long_name      = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
 824 };