Libav 0.7.1
libavcodec/svq1dec.c
Go to the documentation of this file.
00001 /*
00002  * SVQ1 decoder
00003  * ported to MPlayer by Arpi <arpi@thot.banki.hu>
00004  * ported to libavcodec by Nick Kurshev <nickols_k@mail.ru>
00005  *
00006  * Copyright (C) 2002 the xine project
00007  * Copyright (C) 2002 the ffmpeg project
00008  *
00009  * SVQ1 Encoder (c) 2004 Mike Melanson <melanson@pcisys.net>
00010  *
00011  * This file is part of Libav.
00012  *
00013  * Libav is free software; you can redistribute it and/or
00014  * modify it under the terms of the GNU Lesser General Public
00015  * License as published by the Free Software Foundation; either
00016  * version 2.1 of the License, or (at your option) any later version.
00017  *
00018  * Libav is distributed in the hope that it will be useful,
00019  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00020  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00021  * Lesser General Public License for more details.
00022  *
00023  * You should have received a copy of the GNU Lesser General Public
00024  * License along with Libav; if not, write to the Free Software
00025  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00026  */
00027 
00036 #include "avcodec.h"
00037 #include "dsputil.h"
00038 #include "mpegvideo.h"
00039 #include "mathops.h"
00040 
00041 #include "svq1.h"
00042 
00043 #undef NDEBUG
00044 #include <assert.h>
00045 
00046 extern const uint8_t mvtab[33][2];
00047 
00048 static VLC svq1_block_type;
00049 static VLC svq1_motion_component;
00050 static VLC svq1_intra_multistage[6];
00051 static VLC svq1_inter_multistage[6];
00052 static VLC svq1_intra_mean;
00053 static VLC svq1_inter_mean;
00054 
00055 /* motion vector (prediction) */
00056 typedef struct svq1_pmv_s {
00057   int           x;
00058   int           y;
00059 } svq1_pmv;
00060 
00061 static const uint16_t checksum_table[256] = {
00062   0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
00063   0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
00064   0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
00065   0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
00066   0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
00067   0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
00068   0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
00069   0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
00070   0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
00071   0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
00072   0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
00073   0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
00074   0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
00075   0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
00076   0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
00077   0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
00078   0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
00079   0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
00080   0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
00081   0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
00082   0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
00083   0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
00084   0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
00085   0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
00086   0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
00087   0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
00088   0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
00089   0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
00090   0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
00091   0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
00092   0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
00093   0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
00094 };
00095 
00096 static const uint8_t string_table[256] = {
00097   0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
00098   0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
00099   0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
00100   0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
00101   0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
00102   0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
00103   0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
00104   0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
00105   0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
00106   0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
00107   0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
00108   0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
00109   0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
00110   0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
00111   0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
00112   0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
00113   0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
00114   0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
00115   0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
00116   0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
00117   0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
00118   0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
00119   0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
00120   0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
00121   0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
00122   0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
00123   0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
00124   0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
00125   0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
00126   0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
00127   0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
00128   0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
00129 };
00130 
00131 #define SVQ1_PROCESS_VECTOR()\
00132     for (; level > 0; i++) {\
00133       /* process next depth */\
00134       if (i == m) {\
00135         m = n;\
00136         if (--level == 0)\
00137           break;\
00138       }\
00139       /* divide block if next bit set */\
00140       if (get_bits1 (bitbuf) == 0)\
00141         break;\
00142       /* add child nodes */\
00143       list[n++] = list[i];\
00144       list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));\
00145     }
00146 
00147 #define SVQ1_ADD_CODEBOOK()\
00148           /* add codebook entries to vector */\
00149           for (j=0; j < stages; j++) {\
00150             n3  = codebook[entries[j]] ^ 0x80808080;\
00151             n1 += ((n3 & 0xFF00FF00) >> 8);\
00152             n2 +=  (n3 & 0x00FF00FF);\
00153           }\
00154 \
00155           /* clip to [0..255] */\
00156           if (n1 & 0xFF00FF00) {\
00157             n3  = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
00158             n1 += 0x7F007F00;\
00159             n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
00160             n1 &= (n3 & 0x00FF00FF);\
00161           }\
00162 \
00163           if (n2 & 0xFF00FF00) {\
00164             n3  = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
00165             n2 += 0x7F007F00;\
00166             n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
00167             n2 &= (n3 & 0x00FF00FF);\
00168           }
00169 
00170 #define SVQ1_DO_CODEBOOK_INTRA()\
00171       for (y=0; y < height; y++) {\
00172         for (x=0; x < (width / 4); x++, codebook++) {\
00173         n1 = n4;\
00174         n2 = n4;\
00175         SVQ1_ADD_CODEBOOK()\
00176         /* store result */\
00177         dst[x] = (n1 << 8) | n2;\
00178         }\
00179         dst += (pitch / 4);\
00180       }
00181 
00182 #define SVQ1_DO_CODEBOOK_NONINTRA()\
00183       for (y=0; y < height; y++) {\
00184         for (x=0; x < (width / 4); x++, codebook++) {\
00185         n3 = dst[x];\
00186         /* add mean value to vector */\
00187         n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\
00188         n2 =  (n3 & 0x00FF00FF)          + n4;\
00189         SVQ1_ADD_CODEBOOK()\
00190         /* store result */\
00191         dst[x] = (n1 << 8) | n2;\
00192         }\
00193         dst += (pitch / 4);\
00194       }
00195 
00196 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\
00197       codebook = (const uint32_t *) cbook[level];\
00198       bit_cache = get_bits (bitbuf, 4*stages);\
00199       /* calculate codebook entries for this vector */\
00200       for (j=0; j < stages; j++) {\
00201         entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\
00202       }\
00203       mean -= (stages * 128);\
00204       n4    = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
00205 
00206 static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
00207   uint32_t    bit_cache;
00208   uint8_t    *list[63];
00209   uint32_t   *dst;
00210   const uint32_t *codebook;
00211   int         entries[6];
00212   int         i, j, m, n;
00213   int         mean, stages;
00214   unsigned    x, y, width, height, level;
00215   uint32_t    n1, n2, n3, n4;
00216 
00217   /* initialize list for breadth first processing of vectors */
00218   list[0] = pixels;
00219 
00220   /* recursively process vector */
00221   for (i=0, m=1, n=1, level=5; i < n; i++) {
00222     SVQ1_PROCESS_VECTOR();
00223 
00224     /* destination address and vector size */
00225     dst = (uint32_t *) list[i];
00226     width = 1 << ((4 + level) /2);
00227     height = 1 << ((3 + level) /2);
00228 
00229     /* get number of stages (-1 skips vector, 0 for mean only) */
00230     stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
00231 
00232     if (stages == -1) {
00233         for (y=0; y < height; y++) {
00234           memset (&dst[y*(pitch / 4)], 0, width);
00235         }
00236       continue;                 /* skip vector */
00237     }
00238 
00239     if ((stages > 0) && (level >= 4)) {
00240       av_dlog(NULL,
00241               "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
00242               stages, level);
00243       return -1;        /* invalid vector */
00244     }
00245 
00246     mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
00247 
00248     if (stages == 0) {
00249       for (y=0; y < height; y++) {
00250         memset (&dst[y*(pitch / 4)], mean, width);
00251       }
00252     } else {
00253       SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
00254       SVQ1_DO_CODEBOOK_INTRA()
00255     }
00256   }
00257 
00258   return 0;
00259 }
00260 
00261 static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
00262   uint32_t    bit_cache;
00263   uint8_t    *list[63];
00264   uint32_t   *dst;
00265   const uint32_t *codebook;
00266   int         entries[6];
00267   int         i, j, m, n;
00268   int         mean, stages;
00269   int         x, y, width, height, level;
00270   uint32_t    n1, n2, n3, n4;
00271 
00272   /* initialize list for breadth first processing of vectors */
00273   list[0] = pixels;
00274 
00275   /* recursively process vector */
00276   for (i=0, m=1, n=1, level=5; i < n; i++) {
00277     SVQ1_PROCESS_VECTOR();
00278 
00279     /* destination address and vector size */
00280     dst = (uint32_t *) list[i];
00281     width = 1 << ((4 + level) /2);
00282     height = 1 << ((3 + level) /2);
00283 
00284     /* get number of stages (-1 skips vector, 0 for mean only) */
00285     stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
00286 
00287     if (stages == -1) continue; /* skip vector */
00288 
00289     if ((stages > 0) && (level >= 4)) {
00290       av_dlog(NULL,
00291               "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
00292               stages, level);
00293       return -1;        /* invalid vector */
00294     }
00295 
00296     mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
00297 
00298     SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
00299     SVQ1_DO_CODEBOOK_NONINTRA()
00300   }
00301   return 0;
00302 }
00303 
00304 static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv *mv, svq1_pmv **pmv) {
00305   int        diff;
00306   int        i;
00307 
00308   for (i=0; i < 2; i++) {
00309 
00310     /* get motion code */
00311     diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
00312     if(diff<0)
00313         return -1;
00314     else if(diff){
00315         if(get_bits1(bitbuf)) diff= -diff;
00316     }
00317 
00318     /* add median of motion vector predictors and clip result */
00319     if (i == 1)
00320       mv->y = ((diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26;
00321     else
00322       mv->x = ((diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x)) << 26) >> 26;
00323   }
00324 
00325   return 0;
00326 }
00327 
00328 static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) {
00329   uint8_t *src;
00330   uint8_t *dst;
00331   int      i;
00332 
00333   src = &previous[x + y*pitch];
00334   dst = current;
00335 
00336   for (i=0; i < 16; i++) {
00337     memcpy (dst, src, 16);
00338     src += pitch;
00339     dst += pitch;
00340   }
00341 }
00342 
00343 static int svq1_motion_inter_block (MpegEncContext *s, GetBitContext *bitbuf,
00344                                uint8_t *current, uint8_t *previous, int pitch,
00345                                svq1_pmv *motion, int x, int y) {
00346   uint8_t    *src;
00347   uint8_t    *dst;
00348   svq1_pmv    mv;
00349   svq1_pmv   *pmv[3];
00350   int         result;
00351 
00352   /* predict and decode motion vector */
00353   pmv[0] = &motion[0];
00354   if (y == 0) {
00355     pmv[1] =
00356     pmv[2] = pmv[0];
00357   }
00358   else {
00359     pmv[1] = &motion[(x / 8) + 2];
00360     pmv[2] = &motion[(x / 8) + 4];
00361   }
00362 
00363   result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
00364 
00365   if (result != 0)
00366     return result;
00367 
00368   motion[0].x                =
00369   motion[(x / 8) + 2].x      =
00370   motion[(x / 8) + 3].x      = mv.x;
00371   motion[0].y                =
00372   motion[(x / 8) + 2].y      =
00373   motion[(x / 8) + 3].y      = mv.y;
00374 
00375   if(y + (mv.y >> 1)<0)
00376      mv.y= 0;
00377   if(x + (mv.x >> 1)<0)
00378      mv.x= 0;
00379 
00380   src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
00381   dst = current;
00382 
00383   s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16);
00384 
00385   return 0;
00386 }
00387 
00388 static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
00389                                   uint8_t *current, uint8_t *previous, int pitch,
00390                                   svq1_pmv *motion,int x, int y) {
00391   uint8_t    *src;
00392   uint8_t    *dst;
00393   svq1_pmv    mv;
00394   svq1_pmv   *pmv[4];
00395   int         i, result;
00396 
00397   /* predict and decode motion vector (0) */
00398   pmv[0] = &motion[0];
00399   if (y == 0) {
00400     pmv[1] =
00401     pmv[2] = pmv[0];
00402   }
00403   else {
00404     pmv[1] = &motion[(x / 8) + 2];
00405     pmv[2] = &motion[(x / 8) + 4];
00406   }
00407 
00408   result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
00409 
00410   if (result != 0)
00411     return result;
00412 
00413   /* predict and decode motion vector (1) */
00414   pmv[0] = &mv;
00415   if (y == 0) {
00416     pmv[1] =
00417     pmv[2] = pmv[0];
00418   }
00419   else {
00420     pmv[1] = &motion[(x / 8) + 3];
00421   }
00422   result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
00423 
00424   if (result != 0)
00425     return result;
00426 
00427   /* predict and decode motion vector (2) */
00428   pmv[1] = &motion[0];
00429   pmv[2] = &motion[(x / 8) + 1];
00430 
00431   result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
00432 
00433   if (result != 0)
00434     return result;
00435 
00436   /* predict and decode motion vector (3) */
00437   pmv[2] = &motion[(x / 8) + 2];
00438   pmv[3] = &motion[(x / 8) + 3];
00439 
00440   result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
00441 
00442   if (result != 0)
00443     return result;
00444 
00445   /* form predictions */
00446   for (i=0; i < 4; i++) {
00447     int mvx= pmv[i]->x + (i&1)*16;
00448     int mvy= pmv[i]->y + (i>>1)*16;
00449 
00451     if(y + (mvy >> 1)<0)
00452        mvy= 0;
00453     if(x + (mvx >> 1)<0)
00454        mvx= 0;
00455 
00456     src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch];
00457     dst = current;
00458 
00459     s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
00460 
00461     /* select next block */
00462     if (i & 1) {
00463       current  += 8*(pitch - 1);
00464     } else {
00465       current  += 8;
00466     }
00467   }
00468 
00469   return 0;
00470 }
00471 
00472 static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf,
00473                         uint8_t *current, uint8_t *previous, int pitch,
00474                         svq1_pmv *motion, int x, int y) {
00475   uint32_t block_type;
00476   int      result = 0;
00477 
00478   /* get block type */
00479   block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
00480 
00481   /* reset motion vectors */
00482   if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
00483     motion[0].x                 =
00484     motion[0].y                 =
00485     motion[(x / 8) + 2].x =
00486     motion[(x / 8) + 2].y =
00487     motion[(x / 8) + 3].x =
00488     motion[(x / 8) + 3].y = 0;
00489   }
00490 
00491   switch (block_type) {
00492   case SVQ1_BLOCK_SKIP:
00493     svq1_skip_block (current, previous, pitch, x, y);
00494     break;
00495 
00496   case SVQ1_BLOCK_INTER:
00497     result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y);
00498 
00499     if (result != 0)
00500     {
00501       av_dlog(s->avctx, "Error in svq1_motion_inter_block %i\n", result);
00502       break;
00503     }
00504     result = svq1_decode_block_non_intra (bitbuf, current, pitch);
00505     break;
00506 
00507   case SVQ1_BLOCK_INTER_4V:
00508     result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
00509 
00510     if (result != 0)
00511     {
00512       av_dlog(s->avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
00513       break;
00514     }
00515     result = svq1_decode_block_non_intra (bitbuf, current, pitch);
00516     break;
00517 
00518   case SVQ1_BLOCK_INTRA:
00519     result = svq1_decode_block_intra (bitbuf, current, pitch);
00520     break;
00521   }
00522 
00523   return result;
00524 }
00525 
00526 uint16_t ff_svq1_packet_checksum (const uint8_t *data, const int length, int value) {
00527   int i;
00528 
00529   for (i=0; i < length; i++) {
00530     value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
00531   }
00532 
00533   return value;
00534 }
00535 
00536 static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
00537   uint8_t seed;
00538   int     i;
00539 
00540   out[0] = get_bits (bitbuf, 8);
00541 
00542   seed = string_table[out[0]];
00543 
00544   for (i=1; i <= out[0]; i++) {
00545     out[i] = get_bits (bitbuf, 8) ^ seed;
00546     seed   = string_table[out[i] ^ seed];
00547   }
00548 }
00549 
00550 static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
00551   int frame_size_code;
00552 
00553   skip_bits(bitbuf, 8); /* temporal_reference */
00554 
00555   /* frame type */
00556   s->pict_type= get_bits (bitbuf, 2)+1;
00557   if(s->pict_type==4)
00558       return -1;
00559 
00560   if (s->pict_type == AV_PICTURE_TYPE_I) {
00561 
00562     /* unknown fields */
00563     if (s->f_code == 0x50 || s->f_code == 0x60) {
00564       int csum = get_bits (bitbuf, 16);
00565 
00566       csum = ff_svq1_packet_checksum (bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
00567 
00568 //      av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
00569 //              (csum == 0) ? "correct" : "incorrect", csum);
00570     }
00571 
00572     if ((s->f_code ^ 0x10) >= 0x50) {
00573       uint8_t msg[256];
00574 
00575       svq1_parse_string (bitbuf, msg);
00576 
00577       av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
00578     }
00579 
00580     skip_bits (bitbuf, 2);
00581     skip_bits (bitbuf, 2);
00582     skip_bits1 (bitbuf);
00583 
00584     /* load frame size */
00585     frame_size_code = get_bits (bitbuf, 3);
00586 
00587     if (frame_size_code == 7) {
00588       /* load width, height (12 bits each) */
00589       s->width = get_bits (bitbuf, 12);
00590       s->height = get_bits (bitbuf, 12);
00591 
00592       if (!s->width || !s->height)
00593         return -1;
00594     } else {
00595       /* get width, height from table */
00596       s->width = ff_svq1_frame_size_table[frame_size_code].width;
00597       s->height = ff_svq1_frame_size_table[frame_size_code].height;
00598     }
00599   }
00600 
00601   /* unknown fields */
00602   if (get_bits1 (bitbuf) == 1) {
00603     skip_bits1 (bitbuf);       /* use packet checksum if (1) */
00604     skip_bits1 (bitbuf);       /* component checksums after image data if (1) */
00605 
00606     if (get_bits (bitbuf, 2) != 0)
00607       return -1;
00608   }
00609 
00610   if (get_bits1 (bitbuf) == 1) {
00611     skip_bits1 (bitbuf);
00612     skip_bits (bitbuf, 4);
00613     skip_bits1 (bitbuf);
00614     skip_bits (bitbuf, 2);
00615 
00616     while (get_bits1 (bitbuf) == 1) {
00617       skip_bits (bitbuf, 8);
00618     }
00619   }
00620 
00621   return 0;
00622 }
00623 
00624 static int svq1_decode_frame(AVCodecContext *avctx,
00625                              void *data, int *data_size,
00626                              AVPacket *avpkt)
00627 {
00628   const uint8_t *buf = avpkt->data;
00629   int buf_size = avpkt->size;
00630   MpegEncContext *s=avctx->priv_data;
00631   uint8_t        *current, *previous;
00632   int             result, i, x, y, width, height;
00633   AVFrame *pict = data;
00634   svq1_pmv *pmv;
00635 
00636   /* initialize bit buffer */
00637   init_get_bits(&s->gb,buf,buf_size*8);
00638 
00639   /* decode frame header */
00640   s->f_code = get_bits (&s->gb, 22);
00641 
00642   if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
00643     return -1;
00644 
00645   /* swap some header bytes (why?) */
00646   if (s->f_code != 0x20) {
00647     uint32_t *src = (uint32_t *) (buf + 4);
00648 
00649     for (i=0; i < 4; i++) {
00650       src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
00651     }
00652   }
00653 
00654   result = svq1_decode_frame_header (&s->gb, s);
00655 
00656   if (result != 0)
00657   {
00658     av_dlog(s->avctx, "Error in svq1_decode_frame_header %i\n",result);
00659     return result;
00660   }
00661   avcodec_set_dimensions(avctx, s->width, s->height);
00662 
00663   //FIXME this avoids some confusion for "B frames" without 2 references
00664   //this should be removed after libavcodec can handle more flexible picture types & ordering
00665   if(s->pict_type==AV_PICTURE_TYPE_B && s->last_picture_ptr==NULL) return buf_size;
00666 
00667   if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==AV_PICTURE_TYPE_B)
00668      ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=AV_PICTURE_TYPE_I)
00669      || avctx->skip_frame >= AVDISCARD_ALL)
00670       return buf_size;
00671 
00672   if(MPV_frame_start(s, avctx) < 0)
00673       return -1;
00674 
00675   pmv = av_malloc((FFALIGN(s->width, 16)/8 + 3) * sizeof(*pmv));
00676   if (!pmv)
00677       return -1;
00678 
00679   /* decode y, u and v components */
00680   for (i=0; i < 3; i++) {
00681     int linesize;
00682     if (i == 0) {
00683       width  = FFALIGN(s->width, 16);
00684       height = FFALIGN(s->height, 16);
00685       linesize= s->linesize;
00686     } else {
00687       if(s->flags&CODEC_FLAG_GRAY) break;
00688       width  = FFALIGN(s->width/4, 16);
00689       height = FFALIGN(s->height/4, 16);
00690       linesize= s->uvlinesize;
00691     }
00692 
00693     current  = s->current_picture.data[i];
00694 
00695     if(s->pict_type==AV_PICTURE_TYPE_B){
00696         previous = s->next_picture.data[i];
00697     }else{
00698         previous = s->last_picture.data[i];
00699     }
00700 
00701     if (s->pict_type == AV_PICTURE_TYPE_I) {
00702       /* keyframe */
00703       for (y=0; y < height; y+=16) {
00704         for (x=0; x < width; x+=16) {
00705           result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
00706           if (result != 0)
00707           {
00708             av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
00709             goto err;
00710           }
00711         }
00712         current += 16*linesize;
00713       }
00714     } else {
00715       /* delta frame */
00716       memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
00717 
00718       for (y=0; y < height; y+=16) {
00719         for (x=0; x < width; x+=16) {
00720           result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
00721                                             linesize, pmv, x, y);
00722           if (result != 0)
00723           {
00724             av_dlog(s->avctx, "Error in svq1_decode_delta_block %i\n",result);
00725             goto err;
00726           }
00727         }
00728 
00729         pmv[0].x =
00730         pmv[0].y = 0;
00731 
00732         current += 16*linesize;
00733       }
00734     }
00735   }
00736 
00737   *pict = *(AVFrame*)&s->current_picture;
00738 
00739 
00740   MPV_frame_end(s);
00741 
00742   *data_size=sizeof(AVFrame);
00743   result = buf_size;
00744 err:
00745   av_free(pmv);
00746   return result;
00747 }
00748 
00749 static av_cold int svq1_decode_init(AVCodecContext *avctx)
00750 {
00751     MpegEncContext *s = avctx->priv_data;
00752     int i;
00753     int offset = 0;
00754 
00755     MPV_decode_defaults(s);
00756 
00757     s->avctx = avctx;
00758     s->width = (avctx->width+3)&~3;
00759     s->height = (avctx->height+3)&~3;
00760     s->codec_id= avctx->codec->id;
00761     avctx->pix_fmt = PIX_FMT_YUV410P;
00762     avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
00763     s->flags= avctx->flags;
00764     if (MPV_common_init(s) < 0) return -1;
00765 
00766     INIT_VLC_STATIC(&svq1_block_type, 2, 4,
00767         &ff_svq1_block_type_vlc[0][1], 2, 1,
00768         &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
00769 
00770     INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
00771         &mvtab[0][1], 2, 1,
00772         &mvtab[0][0], 2, 1, 176);
00773 
00774     for (i = 0; i < 6; i++) {
00775         static const uint8_t sizes[2][6] = {{14, 10, 14, 18, 16, 18}, {10, 10, 14, 14, 14, 16}};
00776         static VLC_TYPE table[168][2];
00777         svq1_intra_multistage[i].table = &table[offset];
00778         svq1_intra_multistage[i].table_allocated = sizes[0][i];
00779         offset += sizes[0][i];
00780         init_vlc(&svq1_intra_multistage[i], 3, 8,
00781             &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
00782             &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
00783         svq1_inter_multistage[i].table = &table[offset];
00784         svq1_inter_multistage[i].table_allocated = sizes[1][i];
00785         offset += sizes[1][i];
00786         init_vlc(&svq1_inter_multistage[i], 3, 8,
00787             &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
00788             &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
00789     }
00790 
00791     INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
00792         &ff_svq1_intra_mean_vlc[0][1], 4, 2,
00793         &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
00794 
00795     INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
00796         &ff_svq1_inter_mean_vlc[0][1], 4, 2,
00797         &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
00798 
00799     return 0;
00800 }
00801 
00802 static av_cold int svq1_decode_end(AVCodecContext *avctx)
00803 {
00804     MpegEncContext *s = avctx->priv_data;
00805 
00806     MPV_common_end(s);
00807     return 0;
00808 }
00809 
00810 
00811 AVCodec ff_svq1_decoder = {
00812     "svq1",
00813     AVMEDIA_TYPE_VIDEO,
00814     CODEC_ID_SVQ1,
00815     sizeof(MpegEncContext),
00816     svq1_decode_init,
00817     NULL,
00818     svq1_decode_end,
00819     svq1_decode_frame,
00820     CODEC_CAP_DR1,
00821     .flush= ff_mpeg_flush,
00822     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE},
00823     .long_name= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
00824 };