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 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 libavcodec/svq1.c
  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 #if 0
 382   int w= (s->width+15)&~15;
 383   int h= (s->height+15)&~15;
 384   if(x + (mv.x >> 1)<0 || y + (mv.y >> 1)<0 || x + (mv.x >> 1) + 16 > w || y + (mv.y >> 1) + 16> h)
 385       av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mv.x >> 1), y + (mv.y >> 1));
 386 #endif
 387
 388   src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
 389   dst = current;
 390
 391   s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16);
 392
 393   return 0;
 394 }
 395
 396 static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
 397                                   uint8_t *current, uint8_t *previous, int pitch,
 398                                   svq1_pmv *motion,int x, int y) {
 399   uint8_t    *src;
 400   uint8_t    *dst;
 401   svq1_pmv    mv;
 402   svq1_pmv   *pmv[4];
 403   int         i, result;
 404
 405   /* predict and decode motion vector (0) */
 406   pmv[0] = &motion[0];
 407   if (y == 0) {
 408     pmv[1] =
 409     pmv[2] = pmv[0];
 410   }
 411   else {
 412     pmv[1] = &motion[(x / 8) + 2];
 413     pmv[2] = &motion[(x / 8) + 4];
 414   }
 415
 416   result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
 417
 418   if (result != 0)
 419     return result;
 420
 421   /* predict and decode motion vector (1) */
 422   pmv[0] = &mv;
 423   if (y == 0) {
 424     pmv[1] =
 425     pmv[2] = pmv[0];
 426   }
 427   else {
 428     pmv[1] = &motion[(x / 8) + 3];
 429   }
 430   result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
 431
 432   if (result != 0)
 433     return result;
 434
 435   /* predict and decode motion vector (2) */
 436   pmv[1] = &motion[0];
 437   pmv[2] = &motion[(x / 8) + 1];
 438
 439   result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
 440
 441   if (result != 0)
 442     return result;
 443
 444   /* predict and decode motion vector (3) */
 445   pmv[2] = &motion[(x / 8) + 2];
 446   pmv[3] = &motion[(x / 8) + 3];
 447
 448   result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
 449
 450   if (result != 0)
 451     return result;
 452
 453   /* form predictions */
 454   for (i=0; i < 4; i++) {
 455     int mvx= pmv[i]->x + (i&1)*16;
 456     int mvy= pmv[i]->y + (i>>1)*16;
 457
 458     ///XXX /FIXME clipping or padding?
 459     if(y + (mvy >> 1)<0)
 460        mvy= 0;
 461     if(x + (mvx >> 1)<0)
 462        mvx= 0;
 463
 464 #if 0
 465   int w= (s->width+15)&~15;
 466   int h= (s->height+15)&~15;
 467   if(x + (mvx >> 1)<0 || y + (mvy >> 1)<0 || x + (mvx >> 1) + 8 > w || y + (mvy >> 1) + 8> h)
 468       av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mvx >> 1), y + (mvy >> 1));
 469 #endif
 470     src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch];
 471     dst = current;
 472
 473     s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
 474
 475     /* select next block */
 476     if (i & 1) {
 477       current  += 8*(pitch - 1);
 478     } else {
 479       current  += 8;
 480     }
 481   }
 482
 483   return 0;
 484 }
 485
 486 static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf,
 487                         uint8_t *current, uint8_t *previous, int pitch,
 488                         svq1_pmv *motion, int x, int y) {
 489   uint32_t block_type;
 490   int      result = 0;
 491
 492   /* get block type */
 493   block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
 494
 495   /* reset motion vectors */
 496   if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
 497     motion[0].x                 =
 498     motion[0].y                 =
 499     motion[(x / 8) + 2].x =
 500     motion[(x / 8) + 2].y =
 501     motion[(x / 8) + 3].x =
 502     motion[(x / 8) + 3].y = 0;
 503   }
 504
 505   switch (block_type) {
 506   case SVQ1_BLOCK_SKIP:
 507     svq1_skip_block (current, previous, pitch, x, y);
 508     break;
 509
 510   case SVQ1_BLOCK_INTER:
 511     result = svq1_motion_inter_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_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_INTER_4V:
 524     result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
 525
 526     if (result != 0)
 527     {
 528 #ifdef DEBUG_SVQ1
 529     av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_4v_block %i\n",result);
 530 #endif
 531       break;
 532     }
 533     result = svq1_decode_block_non_intra (bitbuf, current, pitch);
 534     break;
 535
 536   case SVQ1_BLOCK_INTRA:
 537     result = svq1_decode_block_intra (bitbuf, current, pitch);
 538     break;
 539   }
 540
 541   return result;
 542 }
 543
 544 uint16_t ff_svq1_packet_checksum (const uint8_t *data, const int length, int value) {
 545   int i;
 546
 547   for (i=0; i < length; i++) {
 548     value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
 549   }
 550
 551   return value;
 552 }
 553
 554 static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
 555   uint8_t seed;
 556   int     i;
 557
 558   out[0] = get_bits (bitbuf, 8);
 559
 560   seed = string_table[out[0]];
 561
 562   for (i=1; i <= out[0]; i++) {
 563     out[i] = get_bits (bitbuf, 8) ^ seed;
 564     seed   = string_table[out[i] ^ seed];
 565   }
 566 }
 567
 568 static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
 569   int frame_size_code;
 570   int temporal_reference;
 571
 572   temporal_reference = get_bits (bitbuf, 8);
 573
 574   /* frame type */
 575   s->pict_type= get_bits (bitbuf, 2)+1;
 576   if(s->pict_type==4)
 577       return -1;
 578
 579   if (s->pict_type == FF_I_TYPE) {
 580
 581     /* unknown fields */
 582     if (s->f_code == 0x50 || s->f_code == 0x60) {
 583       int csum = get_bits (bitbuf, 16);
 584
 585       csum = ff_svq1_packet_checksum (bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
 586
 587 //      av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
 588 //              (csum == 0) ? "correct" : "incorrect", csum);
 589     }
 590
 591     if ((s->f_code ^ 0x10) >= 0x50) {
 592       uint8_t msg[256];
 593
 594       svq1_parse_string (bitbuf, msg);
 595
 596       av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
 597     }
 598
 599     skip_bits (bitbuf, 2);
 600     skip_bits (bitbuf, 2);
 601     skip_bits1 (bitbuf);
 602
 603     /* load frame size */
 604     frame_size_code = get_bits (bitbuf, 3);
 605
 606     if (frame_size_code == 7) {
 607       /* load width, height (12 bits each) */
 608       s->width = get_bits (bitbuf, 12);
 609       s->height = get_bits (bitbuf, 12);
 610
 611       if (!s->width || !s->height)
 612         return -1;
 613     } else {
 614       /* get width, height from table */
 615       s->width = ff_svq1_frame_size_table[frame_size_code].width;
 616       s->height = ff_svq1_frame_size_table[frame_size_code].height;
 617     }
 618   }
 619
 620   /* unknown fields */
 621   if (get_bits1 (bitbuf) == 1) {
 622     skip_bits1 (bitbuf);       /* use packet checksum if (1) */
 623     skip_bits1 (bitbuf);       /* component checksums after image data if (1) */
 624
 625     if (get_bits (bitbuf, 2) != 0)
 626       return -1;
 627   }
 628
 629   if (get_bits1 (bitbuf) == 1) {
 630     skip_bits1 (bitbuf);
 631     skip_bits (bitbuf, 4);
 632     skip_bits1 (bitbuf);
 633     skip_bits (bitbuf, 2);
 634
 635     while (get_bits1 (bitbuf) == 1) {
 636       skip_bits (bitbuf, 8);
 637     }
 638   }
 639
 640   return 0;
 641 }
 642
 643 static int svq1_decode_frame(AVCodecContext *avctx,
 644                              void *data, int *data_size,
 645                              AVPacket *avpkt)
 646 {
 647   const uint8_t *buf = avpkt->data;
 648   int buf_size = avpkt->size;
 649   MpegEncContext *s=avctx->priv_data;
 650   uint8_t        *current, *previous;
 651   int             result, i, x, y, width, height;
 652   AVFrame *pict = data;
 653
 654   /* initialize bit buffer */
 655   init_get_bits(&s->gb,buf,buf_size*8);
 656
 657   /* decode frame header */
 658   s->f_code = get_bits (&s->gb, 22);
 659
 660   if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
 661     return -1;
 662
 663   /* swap some header bytes (why?) */
 664   if (s->f_code != 0x20) {
 665     uint32_t *src = (uint32_t *) (buf + 4);
 666
 667     for (i=0; i < 4; i++) {
 668       src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
 669     }
 670   }
 671
 672   result = svq1_decode_frame_header (&s->gb, s);
 673
 674   if (result != 0)
 675   {
 676 #ifdef DEBUG_SVQ1
 677     av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result);
 678 #endif
 679     return result;
 680   }
 681
 682   //FIXME this avoids some confusion for "B frames" without 2 references
 683   //this should be removed after libavcodec can handle more flexible picture types & ordering
 684   if(s->pict_type==FF_B_TYPE && s->last_picture_ptr==NULL) return buf_size;
 685
 686   if(avctx->hurry_up && s->pict_type==FF_B_TYPE) return buf_size;
 687   if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE)
 688      ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE)
 689      || avctx->skip_frame >= AVDISCARD_ALL)
 690       return buf_size;
 691
 692   if(MPV_frame_start(s, avctx) < 0)
 693       return -1;
 694
 695   /* decode y, u and v components */
 696   for (i=0; i < 3; i++) {
 697     int linesize;
 698     if (i == 0) {
 699       width  = FFALIGN(s->width, 16);
 700       height = FFALIGN(s->height, 16);
 701       linesize= s->linesize;
 702     } else {
 703       if(s->flags&CODEC_FLAG_GRAY) break;
 704       width  = FFALIGN(s->width/4, 16);
 705       height = FFALIGN(s->height/4, 16);
 706       linesize= s->uvlinesize;
 707     }
 708
 709     current  = s->current_picture.data[i];
 710
 711     if(s->pict_type==FF_B_TYPE){
 712         previous = s->next_picture.data[i];
 713     }else{
 714         previous = s->last_picture.data[i];
 715     }
 716
 717     if (s->pict_type == FF_I_TYPE) {
 718       /* keyframe */
 719       for (y=0; y < height; y+=16) {
 720         for (x=0; x < width; x+=16) {
 721           result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
 722           if (result != 0)
 723           {
 724 //#ifdef DEBUG_SVQ1
 725             av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
 726 //#endif
 727             return result;
 728           }
 729         }
 730         current += 16*linesize;
 731       }
 732     } else {
 733       svq1_pmv pmv[width/8+3];
 734       /* delta frame */
 735       memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
 736
 737       for (y=0; y < height; y+=16) {
 738         for (x=0; x < width; x+=16) {
 739           result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
 740                                             linesize, pmv, x, y);
 741           if (result != 0)
 742           {
 743 #ifdef DEBUG_SVQ1
 744     av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result);
 745 #endif
 746             return result;
 747           }
 748         }
 749
 750         pmv[0].x =
 751         pmv[0].y = 0;
 752
 753         current += 16*linesize;
 754       }
 755     }
 756   }
 757
 758   *pict = *(AVFrame*)&s->current_picture;
 759
 760
 761   MPV_frame_end(s);
 762
 763   *data_size=sizeof(AVFrame);
 764   return buf_size;
 765 }
 766
 767 static av_cold int svq1_decode_init(AVCodecContext *avctx)
 768 {
 769     MpegEncContext *s = avctx->priv_data;
 770     int i;
 771
 772     MPV_decode_defaults(s);
 773
 774     s->avctx = avctx;
 775     s->width = (avctx->width+3)&~3;
 776     s->height = (avctx->height+3)&~3;
 777     s->codec_id= avctx->codec->id;
 778     avctx->pix_fmt = PIX_FMT_YUV410P;
 779     avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
 780     s->flags= avctx->flags;
 781     if (MPV_common_init(s) < 0) return -1;
 782
 783     init_vlc(&svq1_block_type, 2, 4,
 784         &ff_svq1_block_type_vlc[0][1], 2, 1,
 785         &ff_svq1_block_type_vlc[0][0], 2, 1, INIT_VLC_USE_STATIC);
 786
 787     init_vlc(&svq1_motion_component, 7, 33,
 788         &mvtab[0][1], 2, 1,
 789         &mvtab[0][0], 2, 1, INIT_VLC_USE_STATIC);
 790
 791     for (i = 0; i < 6; i++) {
 792         init_vlc(&svq1_intra_multistage[i], 3, 8,
 793             &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
 794             &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_STATIC);
 795         init_vlc(&svq1_inter_multistage[i], 3, 8,
 796             &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
 797             &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_STATIC);
 798     }
 799
 800     init_vlc(&svq1_intra_mean, 8, 256,
 801         &ff_svq1_intra_mean_vlc[0][1], 4, 2,
 802         &ff_svq1_intra_mean_vlc[0][0], 4, 2, INIT_VLC_USE_STATIC);
 803
 804     init_vlc(&svq1_inter_mean, 9, 512,
 805         &ff_svq1_inter_mean_vlc[0][1], 4, 2,
 806         &ff_svq1_inter_mean_vlc[0][0], 4, 2, INIT_VLC_USE_STATIC);
 807
 808     return 0;
 809 }
 810
 811 static av_cold int svq1_decode_end(AVCodecContext *avctx)
 812 {
 813     MpegEncContext *s = avctx->priv_data;
 814
 815     MPV_common_end(s);
 816     return 0;
 817 }
 818
 819
 820 AVCodec svq1_decoder = {
 821     "svq1",
 822     CODEC_TYPE_VIDEO,
 823     CODEC_ID_SVQ1,
 824     sizeof(MpegEncContext),
 825     svq1_decode_init,
 826     NULL,
 827     svq1_decode_end,
 828     svq1_decode_frame,
 829     CODEC_CAP_DR1,
 830     .flush= ff_mpeg_flush,
 831     .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE},
 832     .long_name= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1"),
 833 };