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;
00649 
00650         if (buf_size < 9 * 4) {
00651             av_log(avctx, AV_LOG_ERROR, "Input packet too small\n");
00652             return AVERROR_INVALIDDATA;
00653         }
00654 
00655         av_fast_malloc(s->pkt_swapped, &s->pkt_swapped_allocated,
00656                        buf_size);
00657         if (!s->pkt_swapped)
00658             return AVERROR(ENOMEM);
00659 
00660         memcpy(s->pkt_swapped, buf, buf_size);
00661         buf = s->pkt_swapped;
00662         init_get_bits(&s->gb, buf, buf_size * 8);
00663         skip_bits(&s->gb, 22);
00664 
00665         src = (uint32_t *)(s->pkt_swapped + 4);
00666 
00667         for (i = 0; i < 4; i++)
00668             src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
00669     }
00670 
00671   result = svq1_decode_frame_header (&s->gb, s);
00672 
00673   if (result != 0)
00674   {
00675     av_dlog(s->avctx, "Error in svq1_decode_frame_header %i\n",result);
00676     return result;
00677   }
00678   avcodec_set_dimensions(avctx, s->width, s->height);
00679 
00680   //FIXME this avoids some confusion for "B frames" without 2 references
00681   //this should be removed after libavcodec can handle more flexible picture types & ordering
00682   if(s->pict_type==AV_PICTURE_TYPE_B && s->last_picture_ptr==NULL) return buf_size;
00683 
00684   if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==AV_PICTURE_TYPE_B)
00685      ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=AV_PICTURE_TYPE_I)
00686      || avctx->skip_frame >= AVDISCARD_ALL)
00687       return buf_size;
00688 
00689   if(MPV_frame_start(s, avctx) < 0)
00690       return -1;
00691 
00692   pmv = av_malloc((FFALIGN(s->width, 16)/8 + 3) * sizeof(*pmv));
00693   if (!pmv)
00694       return -1;
00695 
00696   /* decode y, u and v components */
00697   for (i=0; i < 3; i++) {
00698     int linesize;
00699     if (i == 0) {
00700       width  = FFALIGN(s->width, 16);
00701       height = FFALIGN(s->height, 16);
00702       linesize= s->linesize;
00703     } else {
00704       if(s->flags&CODEC_FLAG_GRAY) break;
00705       width  = FFALIGN(s->width/4, 16);
00706       height = FFALIGN(s->height/4, 16);
00707       linesize= s->uvlinesize;
00708     }
00709 
00710     current = s->current_picture.f.data[i];
00711 
00712     if(s->pict_type==AV_PICTURE_TYPE_B){
00713         previous = s->next_picture.f.data[i];
00714     }else{
00715         previous = s->last_picture.f.data[i];
00716     }
00717 
00718     if (s->pict_type == AV_PICTURE_TYPE_I) {
00719       /* keyframe */
00720       for (y=0; y < height; y+=16) {
00721         for (x=0; x < width; x+=16) {
00722           result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
00723           if (result != 0)
00724           {
00725             av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
00726             goto err;
00727           }
00728         }
00729         current += 16*linesize;
00730       }
00731     } else {
00732       /* delta frame */
00733       memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
00734 
00735       for (y=0; y < height; y+=16) {
00736         for (x=0; x < width; x+=16) {
00737           result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
00738                                             linesize, pmv, x, y);
00739           if (result != 0)
00740           {
00741             av_dlog(s->avctx, "Error in svq1_decode_delta_block %i\n",result);
00742             goto err;
00743           }
00744         }
00745 
00746         pmv[0].x =
00747         pmv[0].y = 0;
00748 
00749         current += 16*linesize;
00750       }
00751     }
00752   }
00753 
00754   *pict = *(AVFrame*)&s->current_picture;
00755 
00756 
00757   MPV_frame_end(s);
00758 
00759   *data_size=sizeof(AVFrame);
00760   result = buf_size;
00761 err:
00762   av_free(pmv);
00763   return result;
00764 }
00765 
00766 static av_cold int svq1_decode_init(AVCodecContext *avctx)
00767 {
00768     MpegEncContext *s = avctx->priv_data;
00769     int i;
00770     int offset = 0;
00771 
00772     MPV_decode_defaults(s);
00773 
00774     s->avctx = avctx;
00775     s->width = (avctx->width+3)&~3;
00776     s->height = (avctx->height+3)&~3;
00777     s->codec_id= avctx->codec->id;
00778     avctx->pix_fmt = PIX_FMT_YUV410P;
00779     avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
00780     s->flags= avctx->flags;
00781     if (MPV_common_init(s) < 0) return -1;
00782 
00783     INIT_VLC_STATIC(&svq1_block_type, 2, 4,
00784         &ff_svq1_block_type_vlc[0][1], 2, 1,
00785         &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
00786 
00787     INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
00788         &ff_mvtab[0][1], 2, 1,
00789         &ff_mvtab[0][0], 2, 1, 176);
00790 
00791     for (i = 0; i < 6; i++) {
00792         static const uint8_t sizes[2][6] = {{14, 10, 14, 18, 16, 18}, {10, 10, 14, 14, 14, 16}};
00793         static VLC_TYPE table[168][2];
00794         svq1_intra_multistage[i].table = &table[offset];
00795         svq1_intra_multistage[i].table_allocated = sizes[0][i];
00796         offset += sizes[0][i];
00797         init_vlc(&svq1_intra_multistage[i], 3, 8,
00798             &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
00799             &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
00800         svq1_inter_multistage[i].table = &table[offset];
00801         svq1_inter_multistage[i].table_allocated = sizes[1][i];
00802         offset += sizes[1][i];
00803         init_vlc(&svq1_inter_multistage[i], 3, 8,
00804             &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
00805             &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
00806     }
00807 
00808     INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
00809         &ff_svq1_intra_mean_vlc[0][1], 4, 2,
00810         &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
00811 
00812     INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
00813         &ff_svq1_inter_mean_vlc[0][1], 4, 2,
00814         &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
00815 
00816     return 0;
00817 }
00818 
00819 static av_cold int svq1_decode_end(AVCodecContext *avctx)
00820 {
00821     MpegEncContext *s = avctx->priv_data;
00822 
00823     av_freep(&s->pkt_swapped);
00824 
00825     MPV_common_end(s);
00826     return 0;
00827 }
00828 
00829 
00830 AVCodec ff_svq1_decoder = {
00831     .name           = "svq1",
00832     .type           = AVMEDIA_TYPE_VIDEO,
00833     .id             = CODEC_ID_SVQ1,
00834     .priv_data_size = sizeof(MpegEncContext),
00835     .init           = svq1_decode_init,
00836     .close          = svq1_decode_end,
00837     .decode         = svq1_decode_frame,
00838     .capabilities   = CODEC_CAP_DR1,
00839     .flush= ff_mpeg_flush,
00840     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE},
00841     .long_name= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
00842 };