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