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 ff_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       if (stages > 0)\
00199         bit_cache = get_bits (bitbuf, 4*stages);\
00200       /* calculate codebook entries for this vector */\
00201       for (j=0; j < stages; j++) {\
00202         entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\
00203       }\
00204       mean -= (stages * 128);\
00205       n4    = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
00206 
00207 static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
00208   uint32_t    bit_cache;
00209   uint8_t    *list[63];
00210   uint32_t   *dst;
00211   const uint32_t *codebook;
00212   int         entries[6];
00213   int         i, j, m, n;
00214   int         mean, stages;
00215   unsigned    x, y, width, height, level;
00216   uint32_t    n1, n2, n3, n4;
00217 
00218   /* initialize list for breadth first processing of vectors */
00219   list[0] = pixels;
00220 
00221   /* recursively process vector */
00222   for (i=0, m=1, n=1, level=5; i < n; i++) {
00223     SVQ1_PROCESS_VECTOR();
00224 
00225     /* destination address and vector size */
00226     dst = (uint32_t *) list[i];
00227     width = 1 << ((4 + level) /2);
00228     height = 1 << ((3 + level) /2);
00229 
00230     /* get number of stages (-1 skips vector, 0 for mean only) */
00231     stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
00232 
00233     if (stages == -1) {
00234         for (y=0; y < height; y++) {
00235           memset (&dst[y*(pitch / 4)], 0, width);
00236         }
00237       continue;                 /* skip vector */
00238     }
00239 
00240     if ((stages > 0) && (level >= 4)) {
00241       av_dlog(NULL,
00242               "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
00243               stages, level);
00244       return -1;        /* invalid vector */
00245     }
00246 
00247     mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
00248 
00249     if (stages == 0) {
00250       for (y=0; y < height; y++) {
00251         memset (&dst[y*(pitch / 4)], mean, width);
00252       }
00253     } else {
00254       SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
00255       SVQ1_DO_CODEBOOK_INTRA()
00256     }
00257   }
00258 
00259   return 0;
00260 }
00261 
00262 static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
00263   uint32_t    bit_cache;
00264   uint8_t    *list[63];
00265   uint32_t   *dst;
00266   const uint32_t *codebook;
00267   int         entries[6];
00268   int         i, j, m, n;
00269   int         mean, stages;
00270   int         x, y, width, height, level;
00271   uint32_t    n1, n2, n3, n4;
00272 
00273   /* initialize list for breadth first processing of vectors */
00274   list[0] = pixels;
00275 
00276   /* recursively process vector */
00277   for (i=0, m=1, n=1, level=5; i < n; i++) {
00278     SVQ1_PROCESS_VECTOR();
00279 
00280     /* destination address and vector size */
00281     dst = (uint32_t *) list[i];
00282     width = 1 << ((4 + level) /2);
00283     height = 1 << ((3 + level) /2);
00284 
00285     /* get number of stages (-1 skips vector, 0 for mean only) */
00286     stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
00287 
00288     if (stages == -1) continue; /* skip vector */
00289 
00290     if ((stages > 0) && (level >= 4)) {
00291       av_dlog(NULL,
00292               "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
00293               stages, level);
00294       return -1;        /* invalid vector */
00295     }
00296 
00297     mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
00298 
00299     SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
00300     SVQ1_DO_CODEBOOK_NONINTRA()
00301   }
00302   return 0;
00303 }
00304 
00305 static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv *mv, svq1_pmv **pmv) {
00306   int        diff;
00307   int        i;
00308 
00309   for (i=0; i < 2; i++) {
00310 
00311     /* get motion code */
00312     diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
00313     if(diff<0)
00314         return -1;
00315     else if(diff){
00316         if(get_bits1(bitbuf)) diff= -diff;
00317     }
00318 
00319     /* add median of motion vector predictors and clip result */
00320     if (i == 1)
00321       mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
00322     else
00323       mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
00324   }
00325 
00326   return 0;
00327 }
00328 
00329 static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) {
00330   uint8_t *src;
00331   uint8_t *dst;
00332   int      i;
00333 
00334   src = &previous[x + y*pitch];
00335   dst = current;
00336 
00337   for (i=0; i < 16; i++) {
00338     memcpy (dst, src, 16);
00339     src += pitch;
00340     dst += pitch;
00341   }
00342 }
00343 
00344 static int svq1_motion_inter_block (MpegEncContext *s, GetBitContext *bitbuf,
00345                                uint8_t *current, uint8_t *previous, int pitch,
00346                                svq1_pmv *motion, int x, int y) {
00347   uint8_t    *src;
00348   uint8_t    *dst;
00349   svq1_pmv    mv;
00350   svq1_pmv   *pmv[3];
00351   int         result;
00352 
00353   /* predict and decode motion vector */
00354   pmv[0] = &motion[0];
00355   if (y == 0) {
00356     pmv[1] =
00357     pmv[2] = pmv[0];
00358   }
00359   else {
00360     pmv[1] = &motion[(x / 8) + 2];
00361     pmv[2] = &motion[(x / 8) + 4];
00362   }
00363 
00364   result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
00365 
00366   if (result != 0)
00367     return result;
00368 
00369   motion[0].x                =
00370   motion[(x / 8) + 2].x      =
00371   motion[(x / 8) + 3].x      = mv.x;
00372   motion[0].y                =
00373   motion[(x / 8) + 2].y      =
00374   motion[(x / 8) + 3].y      = mv.y;
00375 
00376   if(y + (mv.y >> 1)<0)
00377      mv.y= 0;
00378   if(x + (mv.x >> 1)<0)
00379      mv.x= 0;
00380 
00381   src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
00382   dst = current;
00383 
00384   s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16);
00385 
00386   return 0;
00387 }
00388 
00389 static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
00390                                   uint8_t *current, uint8_t *previous, int pitch,
00391                                   svq1_pmv *motion,int x, int y) {
00392   uint8_t    *src;
00393   uint8_t    *dst;
00394   svq1_pmv    mv;
00395   svq1_pmv   *pmv[4];
00396   int         i, result;
00397 
00398   /* predict and decode motion vector (0) */
00399   pmv[0] = &motion[0];
00400   if (y == 0) {
00401     pmv[1] =
00402     pmv[2] = pmv[0];
00403   }
00404   else {
00405     pmv[1] = &motion[(x / 8) + 2];
00406     pmv[2] = &motion[(x / 8) + 4];
00407   }
00408 
00409   result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
00410 
00411   if (result != 0)
00412     return result;
00413 
00414   /* predict and decode motion vector (1) */
00415   pmv[0] = &mv;
00416   if (y == 0) {
00417     pmv[1] =
00418     pmv[2] = pmv[0];
00419   }
00420   else {
00421     pmv[1] = &motion[(x / 8) + 3];
00422   }
00423   result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
00424 
00425   if (result != 0)
00426     return result;
00427 
00428   /* predict and decode motion vector (2) */
00429   pmv[1] = &motion[0];
00430   pmv[2] = &motion[(x / 8) + 1];
00431 
00432   result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
00433 
00434   if (result != 0)
00435     return result;
00436 
00437   /* predict and decode motion vector (3) */
00438   pmv[2] = &motion[(x / 8) + 2];
00439   pmv[3] = &motion[(x / 8) + 3];
00440 
00441   result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
00442 
00443   if (result != 0)
00444     return result;
00445 
00446   /* form predictions */
00447   for (i=0; i < 4; i++) {
00448     int mvx= pmv[i]->x + (i&1)*16;
00449     int mvy= pmv[i]->y + (i>>1)*16;
00450 
00452     if(y + (mvy >> 1)<0)
00453        mvy= 0;
00454     if(x + (mvx >> 1)<0)
00455        mvx= 0;
00456 
00457     src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch];
00458     dst = current;
00459 
00460     s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
00461 
00462     /* select next block */
00463     if (i & 1) {
00464       current  += 8*(pitch - 1);
00465     } else {
00466       current  += 8;
00467     }
00468   }
00469 
00470   return 0;
00471 }
00472 
00473 static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf,
00474                         uint8_t *current, uint8_t *previous, int pitch,
00475                         svq1_pmv *motion, int x, int y) {
00476   uint32_t block_type;
00477   int      result = 0;
00478 
00479   /* get block type */
00480   block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
00481 
00482   /* reset motion vectors */
00483   if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
00484     motion[0].x                 =
00485     motion[0].y                 =
00486     motion[(x / 8) + 2].x =
00487     motion[(x / 8) + 2].y =
00488     motion[(x / 8) + 3].x =
00489     motion[(x / 8) + 3].y = 0;
00490   }
00491 
00492   switch (block_type) {
00493   case SVQ1_BLOCK_SKIP:
00494     svq1_skip_block (current, previous, pitch, x, y);
00495     break;
00496 
00497   case SVQ1_BLOCK_INTER:
00498     result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y);
00499 
00500     if (result != 0)
00501     {
00502       av_dlog(s->avctx, "Error in svq1_motion_inter_block %i\n", result);
00503       break;
00504     }
00505     result = svq1_decode_block_non_intra (bitbuf, current, pitch);
00506     break;
00507 
00508   case SVQ1_BLOCK_INTER_4V:
00509     result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
00510 
00511     if (result != 0)
00512     {
00513       av_dlog(s->avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
00514       break;
00515     }
00516     result = svq1_decode_block_non_intra (bitbuf, current, pitch);
00517     break;
00518 
00519   case SVQ1_BLOCK_INTRA:
00520     result = svq1_decode_block_intra (bitbuf, current, pitch);
00521     break;
00522   }
00523 
00524   return result;
00525 }
00526 
00527 uint16_t ff_svq1_packet_checksum (const uint8_t *data, const int length, int value) {
00528   int i;
00529 
00530   for (i=0; i < length; i++) {
00531     value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
00532   }
00533 
00534   return value;
00535 }
00536 
00537 static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
00538   uint8_t seed;
00539   int     i;
00540 
00541   out[0] = get_bits (bitbuf, 8);
00542 
00543   seed = string_table[out[0]];
00544 
00545   for (i=1; i <= out[0]; i++) {
00546     out[i] = get_bits (bitbuf, 8) ^ seed;
00547     seed   = string_table[out[i] ^ seed];
00548   }
00549 }
00550 
00551 static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
00552   int frame_size_code;
00553 
00554   skip_bits(bitbuf, 8); /* temporal_reference */
00555 
00556   /* frame type */
00557   s->pict_type= get_bits (bitbuf, 2)+1;
00558   if(s->pict_type==4)
00559       return -1;
00560 
00561   if (s->pict_type == AV_PICTURE_TYPE_I) {
00562 
00563     /* unknown fields */
00564     if (s->f_code == 0x50 || s->f_code == 0x60) {
00565       int csum = get_bits (bitbuf, 16);
00566 
00567       csum = ff_svq1_packet_checksum (bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
00568 
00569 //      av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
00570 //              (csum == 0) ? "correct" : "incorrect", csum);
00571     }
00572 
00573     if ((s->f_code ^ 0x10) >= 0x50) {
00574       uint8_t msg[256];
00575 
00576       svq1_parse_string (bitbuf, msg);
00577 
00578       av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
00579     }
00580 
00581     skip_bits (bitbuf, 2);
00582     skip_bits (bitbuf, 2);
00583     skip_bits1 (bitbuf);
00584 
00585     /* load frame size */
00586     frame_size_code = get_bits (bitbuf, 3);
00587 
00588     if (frame_size_code == 7) {
00589       /* load width, height (12 bits each) */
00590       s->width = get_bits (bitbuf, 12);
00591       s->height = get_bits (bitbuf, 12);
00592 
00593       if (!s->width || !s->height)
00594         return -1;
00595     } else {
00596       /* get width, height from table */
00597       s->width = ff_svq1_frame_size_table[frame_size_code].width;
00598       s->height = ff_svq1_frame_size_table[frame_size_code].height;
00599     }
00600   }
00601 
00602   /* unknown fields */
00603   if (get_bits1 (bitbuf) == 1) {
00604     skip_bits1 (bitbuf);       /* use packet checksum if (1) */
00605     skip_bits1 (bitbuf);       /* component checksums after image data if (1) */
00606 
00607     if (get_bits (bitbuf, 2) != 0)
00608       return -1;
00609   }
00610 
00611   if (get_bits1 (bitbuf) == 1) {
00612     skip_bits1 (bitbuf);
00613     skip_bits (bitbuf, 4);
00614     skip_bits1 (bitbuf);
00615     skip_bits (bitbuf, 2);
00616 
00617     while (get_bits1 (bitbuf) == 1) {
00618       skip_bits (bitbuf, 8);
00619     }
00620   }
00621 
00622   return 0;
00623 }
00624 
00625 static int svq1_decode_frame(AVCodecContext *avctx,
00626                              void *data, int *data_size,
00627                              AVPacket *avpkt)
00628 {
00629   const uint8_t *buf = avpkt->data;
00630   int buf_size = avpkt->size;
00631   MpegEncContext *s=avctx->priv_data;
00632   uint8_t        *current, *previous;
00633   int             result, i, x, y, width, height;
00634   AVFrame *pict = data;
00635   svq1_pmv *pmv;
00636 
00637   /* initialize bit buffer */
00638   init_get_bits(&s->gb,buf,buf_size*8);
00639 
00640   /* decode frame header */
00641   s->f_code = get_bits (&s->gb, 22);
00642 
00643   if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
00644     return -1;
00645 
00646   /* swap some header bytes (why?) */
00647   if (s->f_code != 0x20) {
00648     uint32_t *src = (uint32_t *) (buf + 4);
00649 
00650     for (i=0; i < 4; i++) {
00651       src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
00652     }
00653   }
00654 
00655   result = svq1_decode_frame_header (&s->gb, s);
00656 
00657   if (result != 0)
00658   {
00659     av_dlog(s->avctx, "Error in svq1_decode_frame_header %i\n",result);
00660     return result;
00661   }
00662   avcodec_set_dimensions(avctx, s->width, s->height);
00663 
00664   //FIXME this avoids some confusion for "B frames" without 2 references
00665   //this should be removed after libavcodec can handle more flexible picture types & ordering
00666   if(s->pict_type==AV_PICTURE_TYPE_B && s->last_picture_ptr==NULL) return buf_size;
00667 
00668   if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==AV_PICTURE_TYPE_B)
00669      ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=AV_PICTURE_TYPE_I)
00670      || avctx->skip_frame >= AVDISCARD_ALL)
00671       return buf_size;
00672 
00673   if(MPV_frame_start(s, avctx) < 0)
00674       return -1;
00675 
00676   pmv = av_malloc((FFALIGN(s->width, 16)/8 + 3) * sizeof(*pmv));
00677   if (!pmv)
00678       return -1;
00679 
00680   /* decode y, u and v components */
00681   for (i=0; i < 3; i++) {
00682     int linesize;
00683     if (i == 0) {
00684       width  = FFALIGN(s->width, 16);
00685       height = FFALIGN(s->height, 16);
00686       linesize= s->linesize;
00687     } else {
00688       if(s->flags&CODEC_FLAG_GRAY) break;
00689       width  = FFALIGN(s->width/4, 16);
00690       height = FFALIGN(s->height/4, 16);
00691       linesize= s->uvlinesize;
00692     }
00693 
00694     current = s->current_picture.f.data[i];
00695 
00696     if(s->pict_type==AV_PICTURE_TYPE_B){
00697         previous = s->next_picture.f.data[i];
00698     }else{
00699         previous = s->last_picture.f.data[i];
00700     }
00701 
00702     if (s->pict_type == AV_PICTURE_TYPE_I) {
00703       /* keyframe */
00704       for (y=0; y < height; y+=16) {
00705         for (x=0; x < width; x+=16) {
00706           result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
00707           if (result != 0)
00708           {
00709             av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
00710             goto err;
00711           }
00712         }
00713         current += 16*linesize;
00714       }
00715     } else {
00716       /* delta frame */
00717       memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
00718 
00719       for (y=0; y < height; y+=16) {
00720         for (x=0; x < width; x+=16) {
00721           result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
00722                                             linesize, pmv, x, y);
00723           if (result != 0)
00724           {
00725             av_dlog(s->avctx, "Error in svq1_decode_delta_block %i\n",result);
00726             goto err;
00727           }
00728         }
00729 
00730         pmv[0].x =
00731         pmv[0].y = 0;
00732 
00733         current += 16*linesize;
00734       }
00735     }
00736   }
00737 
00738   *pict = *(AVFrame*)&s->current_picture;
00739 
00740 
00741   MPV_frame_end(s);
00742 
00743   *data_size=sizeof(AVFrame);
00744   result = buf_size;
00745 err:
00746   av_free(pmv);
00747   return result;
00748 }
00749 
00750 static av_cold int svq1_decode_init(AVCodecContext *avctx)
00751 {
00752     MpegEncContext *s = avctx->priv_data;
00753     int i;
00754     int offset = 0;
00755 
00756     MPV_decode_defaults(s);
00757 
00758     s->avctx = avctx;
00759     s->width = (avctx->width+3)&~3;
00760     s->height = (avctx->height+3)&~3;
00761     s->codec_id= avctx->codec->id;
00762     avctx->pix_fmt = PIX_FMT_YUV410P;
00763     avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
00764     s->flags= avctx->flags;
00765     if (MPV_common_init(s) < 0) return -1;
00766 
00767     INIT_VLC_STATIC(&svq1_block_type, 2, 4,
00768         &ff_svq1_block_type_vlc[0][1], 2, 1,
00769         &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
00770 
00771     INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
00772         &ff_mvtab[0][1], 2, 1,
00773         &ff_mvtab[0][0], 2, 1, 176);
00774 
00775     for (i = 0; i < 6; i++) {
00776         static const uint8_t sizes[2][6] = {{14, 10, 14, 18, 16, 18}, {10, 10, 14, 14, 14, 16}};
00777         static VLC_TYPE table[168][2];
00778         svq1_intra_multistage[i].table = &table[offset];
00779         svq1_intra_multistage[i].table_allocated = sizes[0][i];
00780         offset += sizes[0][i];
00781         init_vlc(&svq1_intra_multistage[i], 3, 8,
00782             &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
00783             &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
00784         svq1_inter_multistage[i].table = &table[offset];
00785         svq1_inter_multistage[i].table_allocated = sizes[1][i];
00786         offset += sizes[1][i];
00787         init_vlc(&svq1_inter_multistage[i], 3, 8,
00788             &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
00789             &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
00790     }
00791 
00792     INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
00793         &ff_svq1_intra_mean_vlc[0][1], 4, 2,
00794         &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
00795 
00796     INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
00797         &ff_svq1_inter_mean_vlc[0][1], 4, 2,
00798         &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
00799 
00800     return 0;
00801 }
00802 
00803 static av_cold int svq1_decode_end(AVCodecContext *avctx)
00804 {
00805     MpegEncContext *s = avctx->priv_data;
00806 
00807     MPV_common_end(s);
00808     return 0;
00809 }
00810 
00811 
00812 AVCodec ff_svq1_decoder = {
00813     .name           = "svq1",
00814     .type           = AVMEDIA_TYPE_VIDEO,
00815     .id             = CODEC_ID_SVQ1,
00816     .priv_data_size = sizeof(MpegEncContext),
00817     .init           = svq1_decode_init,
00818     .close          = svq1_decode_end,
00819     .decode         = svq1_decode_frame,
00820     .capabilities   = 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 };