00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00036
00037 #include "avcodec.h"
00038 #include "dsputil.h"
00039 #include "mpegvideo.h"
00040
00041 #include "svq1.h"
00042
00043 #undef NDEBUG
00044 #include <assert.h>
00045
00046 extern const uint8_t mvtab[33][2];
00047
00048 static VLC svq1_block_type;
00049 static VLC svq1_motion_component;
00050 static VLC svq1_intra_multistage[6];
00051 static VLC svq1_inter_multistage[6];
00052 static VLC svq1_intra_mean;
00053 static VLC svq1_inter_mean;
00054
00055
00056 typedef struct svq1_pmv_s {
00057 int x;
00058 int y;
00059 } svq1_pmv_t;
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 \
00134 if (i == m) {\
00135 m = n;\
00136 if (--level == 0)\
00137 break;\
00138 }\
00139 \
00140 if (get_bits1 (bitbuf) == 0)\
00141 break;\
00142 \
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 \
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 \
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 \
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 \
00187 n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\
00188 n2 = (n3 & 0x00FF00FF) + n4;\
00189 SVQ1_ADD_CODEBOOK()\
00190 \
00191 dst[x] = (n1 << 8) | n2;\
00192 }\
00193 dst += (pitch / 4);\
00194 }
00195
00196 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\
00197 codebook = (const uint32_t *) cbook[level];\
00198 bit_cache = get_bits (bitbuf, 4*stages);\
00199 \
00200 for (j=0; j < stages; j++) {\
00201 entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\
00202 }\
00203 mean -= (stages * 128);\
00204 n4 = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
00205
00206 static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
00207 uint32_t bit_cache;
00208 uint8_t *list[63];
00209 uint32_t *dst;
00210 const uint32_t *codebook;
00211 int entries[6];
00212 int i, j, m, n;
00213 int mean, stages;
00214 unsigned x, y, width, height, level;
00215 uint32_t n1, n2, n3, n4;
00216
00217
00218 list[0] = pixels;
00219
00220
00221 for (i=0, m=1, n=1, level=5; i < n; i++) {
00222 SVQ1_PROCESS_VECTOR();
00223
00224
00225 dst = (uint32_t *) list[i];
00226 width = 1 << ((4 + level) /2);
00227 height = 1 << ((3 + level) /2);
00228
00229
00230 stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
00231
00232 if (stages == -1) {
00233 for (y=0; y < height; y++) {
00234 memset (&dst[y*(pitch / 4)], 0, width);
00235 }
00236 continue;
00237 }
00238
00239 if ((stages > 0) && (level >= 4)) {
00240 #ifdef DEBUG_SVQ1
00241 av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level);
00242 #endif
00243 return -1;
00244 }
00245
00246 mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
00247
00248 if (stages == 0) {
00249 for (y=0; y < height; y++) {
00250 memset (&dst[y*(pitch / 4)], mean, width);
00251 }
00252 } else {
00253 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
00254 SVQ1_DO_CODEBOOK_INTRA()
00255 }
00256 }
00257
00258 return 0;
00259 }
00260
00261 static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
00262 uint32_t bit_cache;
00263 uint8_t *list[63];
00264 uint32_t *dst;
00265 const uint32_t *codebook;
00266 int entries[6];
00267 int i, j, m, n;
00268 int mean, stages;
00269 int x, y, width, height, level;
00270 uint32_t n1, n2, n3, n4;
00271
00272
00273 list[0] = pixels;
00274
00275
00276 for (i=0, m=1, n=1, level=5; i < n; i++) {
00277 SVQ1_PROCESS_VECTOR();
00278
00279
00280 dst = (uint32_t *) list[i];
00281 width = 1 << ((4 + level) /2);
00282 height = 1 << ((3 + level) /2);
00283
00284
00285 stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
00286
00287 if (stages == -1) continue;
00288
00289 if ((stages > 0) && (level >= 4)) {
00290 #ifdef DEBUG_SVQ1
00291 av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",stages,level);
00292 #endif
00293 return -1;
00294 }
00295
00296 mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
00297
00298 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
00299 SVQ1_DO_CODEBOOK_NONINTRA()
00300 }
00301 return 0;
00302 }
00303
00304 static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv_t *mv, svq1_pmv_t **pmv) {
00305 int diff;
00306 int i;
00307
00308 for (i=0; i < 2; i++) {
00309
00310
00311 diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
00312 if(diff<0)
00313 return -1;
00314 else if(diff){
00315 if(get_bits1(bitbuf)) diff= -diff;
00316 }
00317
00318
00319 if (i == 1)
00320 mv->y = ((diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26;
00321 else
00322 mv->x = ((diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x)) << 26) >> 26;
00323 }
00324
00325 return 0;
00326 }
00327
00328 static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) {
00329 uint8_t *src;
00330 uint8_t *dst;
00331 int i;
00332
00333 src = &previous[x + y*pitch];
00334 dst = current;
00335
00336 for (i=0; i < 16; i++) {
00337 memcpy (dst, src, 16);
00338 src += pitch;
00339 dst += pitch;
00340 }
00341 }
00342
00343 static int svq1_motion_inter_block (MpegEncContext *s, GetBitContext *bitbuf,
00344 uint8_t *current, uint8_t *previous, int pitch,
00345 svq1_pmv_t *motion, int x, int y) {
00346 uint8_t *src;
00347 uint8_t *dst;
00348 svq1_pmv_t mv;
00349 svq1_pmv_t *pmv[3];
00350 int result;
00351
00352
00353 pmv[0] = &motion[0];
00354 if (y == 0) {
00355 pmv[1] =
00356 pmv[2] = pmv[0];
00357 }
00358 else {
00359 pmv[1] = &motion[(x / 8) + 2];
00360 pmv[2] = &motion[(x / 8) + 4];
00361 }
00362
00363 result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
00364
00365 if (result != 0)
00366 return result;
00367
00368 motion[0].x =
00369 motion[(x / 8) + 2].x =
00370 motion[(x / 8) + 3].x = mv.x;
00371 motion[0].y =
00372 motion[(x / 8) + 2].y =
00373 motion[(x / 8) + 3].y = mv.y;
00374
00375 if(y + (mv.y >> 1)<0)
00376 mv.y= 0;
00377 if(x + (mv.x >> 1)<0)
00378 mv.x= 0;
00379
00380 #if 0
00381 int w= (s->width+15)&~15;
00382 int h= (s->height+15)&~15;
00383 if(x + (mv.x >> 1)<0 || y + (mv.y >> 1)<0 || x + (mv.x >> 1) + 16 > w || y + (mv.y >> 1) + 16> h)
00384 av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mv.x >> 1), y + (mv.y >> 1));
00385 #endif
00386
00387 src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
00388 dst = current;
00389
00390 s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16);
00391
00392 return 0;
00393 }
00394
00395 static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
00396 uint8_t *current, uint8_t *previous, int pitch,
00397 svq1_pmv_t *motion,int x, int y) {
00398 uint8_t *src;
00399 uint8_t *dst;
00400 svq1_pmv_t mv;
00401 svq1_pmv_t *pmv[4];
00402 int i, result;
00403
00404
00405 pmv[0] = &motion[0];
00406 if (y == 0) {
00407 pmv[1] =
00408 pmv[2] = pmv[0];
00409 }
00410 else {
00411 pmv[1] = &motion[(x / 8) + 2];
00412 pmv[2] = &motion[(x / 8) + 4];
00413 }
00414
00415 result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
00416
00417 if (result != 0)
00418 return result;
00419
00420
00421 pmv[0] = &mv;
00422 if (y == 0) {
00423 pmv[1] =
00424 pmv[2] = pmv[0];
00425 }
00426 else {
00427 pmv[1] = &motion[(x / 8) + 3];
00428 }
00429 result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
00430
00431 if (result != 0)
00432 return result;
00433
00434
00435 pmv[1] = &motion[0];
00436 pmv[2] = &motion[(x / 8) + 1];
00437
00438 result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
00439
00440 if (result != 0)
00441 return result;
00442
00443
00444 pmv[2] = &motion[(x / 8) + 2];
00445 pmv[3] = &motion[(x / 8) + 3];
00446
00447 result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
00448
00449 if (result != 0)
00450 return result;
00451
00452
00453 for (i=0; i < 4; i++) {
00454 int mvx= pmv[i]->x + (i&1)*16;
00455 int mvy= pmv[i]->y + (i>>1)*16;
00456
00458 if(y + (mvy >> 1)<0)
00459 mvy= 0;
00460 if(x + (mvx >> 1)<0)
00461 mvx= 0;
00462
00463 #if 0
00464 int w= (s->width+15)&~15;
00465 int h= (s->height+15)&~15;
00466 if(x + (mvx >> 1)<0 || y + (mvy >> 1)<0 || x + (mvx >> 1) + 8 > w || y + (mvy >> 1) + 8> h)
00467 av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mvx >> 1), y + (mvy >> 1));
00468 #endif
00469 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch];
00470 dst = current;
00471
00472 s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
00473
00474
00475 if (i & 1) {
00476 current += 8*(pitch - 1);
00477 } else {
00478 current += 8;
00479 }
00480 }
00481
00482 return 0;
00483 }
00484
00485 static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf,
00486 uint8_t *current, uint8_t *previous, int pitch,
00487 svq1_pmv_t *motion, int x, int y) {
00488 uint32_t block_type;
00489 int result = 0;
00490
00491
00492 block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
00493
00494
00495 if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
00496 motion[0].x =
00497 motion[0].y =
00498 motion[(x / 8) + 2].x =
00499 motion[(x / 8) + 2].y =
00500 motion[(x / 8) + 3].x =
00501 motion[(x / 8) + 3].y = 0;
00502 }
00503
00504 switch (block_type) {
00505 case SVQ1_BLOCK_SKIP:
00506 svq1_skip_block (current, previous, pitch, x, y);
00507 break;
00508
00509 case SVQ1_BLOCK_INTER:
00510 result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y);
00511
00512 if (result != 0)
00513 {
00514 #ifdef DEBUG_SVQ1
00515 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_block %i\n",result);
00516 #endif
00517 break;
00518 }
00519 result = svq1_decode_block_non_intra (bitbuf, current, pitch);
00520 break;
00521
00522 case SVQ1_BLOCK_INTER_4V:
00523 result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
00524
00525 if (result != 0)
00526 {
00527 #ifdef DEBUG_SVQ1
00528 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_4v_block %i\n",result);
00529 #endif
00530 break;
00531 }
00532 result = svq1_decode_block_non_intra (bitbuf, current, pitch);
00533 break;
00534
00535 case SVQ1_BLOCK_INTRA:
00536 result = svq1_decode_block_intra (bitbuf, current, pitch);
00537 break;
00538 }
00539
00540 return result;
00541 }
00542
00543 static uint16_t svq1_packet_checksum (const uint8_t *data, const int length, int value) {
00544 int i;
00545
00546 for (i=0; i < length; i++) {
00547 value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
00548 }
00549
00550 return value;
00551 }
00552
00553 static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
00554 uint8_t seed;
00555 int i;
00556
00557 out[0] = get_bits (bitbuf, 8);
00558
00559 seed = string_table[out[0]];
00560
00561 for (i=1; i <= out[0]; i++) {
00562 out[i] = get_bits (bitbuf, 8) ^ seed;
00563 seed = string_table[out[i] ^ seed];
00564 }
00565 }
00566
00567 static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
00568 int frame_size_code;
00569 int temporal_reference;
00570
00571 temporal_reference = get_bits (bitbuf, 8);
00572
00573
00574 s->pict_type= get_bits (bitbuf, 2)+1;
00575 if(s->pict_type==4)
00576 return -1;
00577
00578 if (s->pict_type == I_TYPE) {
00579
00580
00581 if (s->f_code == 0x50 || s->f_code == 0x60) {
00582 int csum = get_bits (bitbuf, 16);
00583
00584 csum = svq1_packet_checksum (bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
00585
00586
00587
00588 }
00589
00590 if ((s->f_code ^ 0x10) >= 0x50) {
00591 uint8_t msg[256];
00592
00593 svq1_parse_string (bitbuf, msg);
00594
00595 av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
00596 }
00597
00598 skip_bits (bitbuf, 2);
00599 skip_bits (bitbuf, 2);
00600 skip_bits1 (bitbuf);
00601
00602
00603 frame_size_code = get_bits (bitbuf, 3);
00604
00605 if (frame_size_code == 7) {
00606
00607 s->width = get_bits (bitbuf, 12);
00608 s->height = get_bits (bitbuf, 12);
00609
00610 if (!s->width || !s->height)
00611 return -1;
00612 } else {
00613
00614 s->width = ff_svq1_frame_size_table[frame_size_code].width;
00615 s->height = ff_svq1_frame_size_table[frame_size_code].height;
00616 }
00617 }
00618
00619
00620 if (get_bits1 (bitbuf) == 1) {
00621 skip_bits1 (bitbuf);
00622 skip_bits1 (bitbuf);
00623
00624 if (get_bits (bitbuf, 2) != 0)
00625 return -1;
00626 }
00627
00628 if (get_bits1 (bitbuf) == 1) {
00629 skip_bits1 (bitbuf);
00630 skip_bits (bitbuf, 4);
00631 skip_bits1 (bitbuf);
00632 skip_bits (bitbuf, 2);
00633
00634 while (get_bits1 (bitbuf) == 1) {
00635 skip_bits (bitbuf, 8);
00636 }
00637 }
00638
00639 return 0;
00640 }
00641
00642 static int svq1_decode_frame(AVCodecContext *avctx,
00643 void *data, int *data_size,
00644 const uint8_t *buf, int buf_size)
00645 {
00646 MpegEncContext *s=avctx->priv_data;
00647 uint8_t *current, *previous;
00648 int result, i, x, y, width, height;
00649 AVFrame *pict = data;
00650
00651
00652 init_get_bits(&s->gb,buf,buf_size*8);
00653
00654
00655 s->f_code = get_bits (&s->gb, 22);
00656
00657 if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
00658 return -1;
00659
00660
00661 if (s->f_code != 0x20) {
00662 uint32_t *src = (uint32_t *) (buf + 4);
00663
00664 for (i=0; i < 4; i++) {
00665 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
00666 }
00667 }
00668
00669 result = svq1_decode_frame_header (&s->gb, s);
00670
00671 if (result != 0)
00672 {
00673 #ifdef DEBUG_SVQ1
00674 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result);
00675 #endif
00676 return result;
00677 }
00678
00679
00680
00681 if(s->pict_type==B_TYPE && s->last_picture_ptr==NULL) return buf_size;
00682
00683 if(avctx->hurry_up && s->pict_type==B_TYPE) return buf_size;
00684 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
00685 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
00686 || avctx->skip_frame >= AVDISCARD_ALL)
00687 return buf_size;
00688
00689 if(MPV_frame_start(s, avctx) < 0)
00690 return -1;
00691
00692
00693 for (i=0; i < 3; i++) {
00694 int linesize;
00695 if (i == 0) {
00696 width = (s->width+15)&~15;
00697 height = (s->height+15)&~15;
00698 linesize= s->linesize;
00699 } else {
00700 if(s->flags&CODEC_FLAG_GRAY) break;
00701 width = (s->width/4+15)&~15;
00702 height = (s->height/4+15)&~15;
00703 linesize= s->uvlinesize;
00704 }
00705
00706 current = s->current_picture.data[i];
00707
00708 if(s->pict_type==B_TYPE){
00709 previous = s->next_picture.data[i];
00710 }else{
00711 previous = s->last_picture.data[i];
00712 }
00713
00714 if (s->pict_type == I_TYPE) {
00715
00716 for (y=0; y < height; y+=16) {
00717 for (x=0; x < width; x+=16) {
00718 result = svq1_decode_block_intra (&s->gb, ¤t[x], linesize);
00719 if (result != 0)
00720 {
00721
00722 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
00723
00724 return result;
00725 }
00726 }
00727 current += 16*linesize;
00728 }
00729 } else {
00730 svq1_pmv_t pmv[width/8+3];
00731
00732 memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv_t));
00733
00734 for (y=0; y < height; y+=16) {
00735 for (x=0; x < width; x+=16) {
00736 result = svq1_decode_delta_block (s, &s->gb, ¤t[x], previous,
00737 linesize, pmv, x, y);
00738 if (result != 0)
00739 {
00740 #ifdef DEBUG_SVQ1
00741 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result);
00742 #endif
00743 return result;
00744 }
00745 }
00746
00747 pmv[0].x =
00748 pmv[0].y = 0;
00749
00750 current += 16*linesize;
00751 }
00752 }
00753 }
00754
00755 *pict = *(AVFrame*)&s->current_picture;
00756
00757
00758 MPV_frame_end(s);
00759
00760 *data_size=sizeof(AVFrame);
00761 return buf_size;
00762 }
00763
00764 static int svq1_decode_init(AVCodecContext *avctx)
00765 {
00766 MpegEncContext *s = avctx->priv_data;
00767 int i;
00768
00769 MPV_decode_defaults(s);
00770
00771 s->avctx = avctx;
00772 s->width = (avctx->width+3)&~3;
00773 s->height = (avctx->height+3)&~3;
00774 s->codec_id= avctx->codec->id;
00775 avctx->pix_fmt = PIX_FMT_YUV410P;
00776 avctx->has_b_frames= 1;
00777 s->flags= avctx->flags;
00778 if (MPV_common_init(s) < 0) return -1;
00779
00780 init_vlc(&svq1_block_type, 2, 4,
00781 &ff_svq1_block_type_vlc[0][1], 2, 1,
00782 &ff_svq1_block_type_vlc[0][0], 2, 1, 1);
00783
00784 init_vlc(&svq1_motion_component, 7, 33,
00785 &mvtab[0][1], 2, 1,
00786 &mvtab[0][0], 2, 1, 1);
00787
00788 for (i = 0; i < 6; i++) {
00789 init_vlc(&svq1_intra_multistage[i], 3, 8,
00790 &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
00791 &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, 1);
00792 init_vlc(&svq1_inter_multistage[i], 3, 8,
00793 &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
00794 &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, 1);
00795 }
00796
00797 init_vlc(&svq1_intra_mean, 8, 256,
00798 &ff_svq1_intra_mean_vlc[0][1], 4, 2,
00799 &ff_svq1_intra_mean_vlc[0][0], 4, 2, 1);
00800
00801 init_vlc(&svq1_inter_mean, 9, 512,
00802 &ff_svq1_inter_mean_vlc[0][1], 4, 2,
00803 &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1);
00804
00805 return 0;
00806 }
00807
00808 static int svq1_decode_end(AVCodecContext *avctx)
00809 {
00810 MpegEncContext *s = avctx->priv_data;
00811
00812 MPV_common_end(s);
00813 return 0;
00814 }
00815
00816
00817 AVCodec svq1_decoder = {
00818 "svq1",
00819 CODEC_TYPE_VIDEO,
00820 CODEC_ID_SVQ1,
00821 sizeof(MpegEncContext),
00822 svq1_decode_init,
00823 NULL,
00824 svq1_decode_end,
00825 svq1_decode_frame,
00826 CODEC_CAP_DR1,
00827 .flush= ff_mpeg_flush,
00828 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1},
00829 };