• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • File List
  • Globals

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

Generated on Fri Sep 16 2011 17:17:43 for FFmpeg by  doxygen 1.7.1