• Main Page
• Related Pages
• Modules
• Data Structures
• Files

• File List
• Globals

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