synfig-core/tags/synfig_0_61_04/synfig-core/src/modules/mod_libavcodec/libavcodec/svq1.c

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