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 #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 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;
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 >> 1) + 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 if (stages > 0)\
00199 bit_cache = get_bits (bitbuf, 4*stages);\
00200 \
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 << 16) + mean;
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
00219 list[0] = pixels;
00220
00221
00222 for (i=0, m=1, n=1, level=5; i < n; i++) {
00223 SVQ1_PROCESS_VECTOR();
00224
00225
00226 dst = (uint32_t *) list[i];
00227 width = 1 << ((4 + level) /2);
00228 height = 1 << ((3 + level) /2);
00229
00230
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;
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;
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
00274 list[0] = pixels;
00275
00276
00277 for (i=0, m=1, n=1, level=5; i < n; i++) {
00278 SVQ1_PROCESS_VECTOR();
00279
00280
00281 dst = (uint32_t *) list[i];
00282 width = 1 << ((4 + level) /2);
00283 height = 1 << ((3 + level) /2);
00284
00285
00286 stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
00287
00288 if (stages == -1) continue;
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;
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
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
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
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
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
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
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
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
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
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
00480 block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
00481
00482
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);
00555
00556
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
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
00570
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
00586 frame_size_code = get_bits (bitbuf, 3);
00587
00588 if (frame_size_code == 7) {
00589
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
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
00603 if (get_bits1 (bitbuf) == 1) {
00604 skip_bits1 (bitbuf);
00605 skip_bits1 (bitbuf);
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
00638 init_get_bits(&s->gb,buf,buf_size*8);
00639
00640
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
00647 if (s->f_code != 0x20) {
00648 uint32_t *src = (uint32_t *) (buf + 4);
00649
00650 for (i=0; i < 4; i++) {
00651 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
00652 }
00653 }
00654
00655 result = svq1_decode_frame_header (&s->gb, s);
00656
00657 if (result != 0)
00658 {
00659 av_dlog(s->avctx, "Error in svq1_decode_frame_header %i\n",result);
00660 return result;
00661 }
00662 avcodec_set_dimensions(avctx, s->width, s->height);
00663
00664
00665
00666 if(s->pict_type==AV_PICTURE_TYPE_B && s->last_picture_ptr==NULL) return buf_size;
00667
00668 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==AV_PICTURE_TYPE_B)
00669 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=AV_PICTURE_TYPE_I)
00670 || avctx->skip_frame >= AVDISCARD_ALL)
00671 return buf_size;
00672
00673 if(MPV_frame_start(s, avctx) < 0)
00674 return -1;
00675
00676 pmv = av_malloc((FFALIGN(s->width, 16)/8 + 3) * sizeof(*pmv));
00677 if (!pmv)
00678 return -1;
00679
00680
00681 for (i=0; i < 3; i++) {
00682 int linesize;
00683 if (i == 0) {
00684 width = FFALIGN(s->width, 16);
00685 height = FFALIGN(s->height, 16);
00686 linesize= s->linesize;
00687 } else {
00688 if(s->flags&CODEC_FLAG_GRAY) break;
00689 width = FFALIGN(s->width/4, 16);
00690 height = FFALIGN(s->height/4, 16);
00691 linesize= s->uvlinesize;
00692 }
00693
00694 current = s->current_picture.f.data[i];
00695
00696 if(s->pict_type==AV_PICTURE_TYPE_B){
00697 previous = s->next_picture.f.data[i];
00698 }else{
00699 previous = s->last_picture.f.data[i];
00700 }
00701
00702 if (s->pict_type == AV_PICTURE_TYPE_I) {
00703
00704 for (y=0; y < height; y+=16) {
00705 for (x=0; x < width; x+=16) {
00706 result = svq1_decode_block_intra (&s->gb, ¤t[x], linesize);
00707 if (result != 0)
00708 {
00709 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
00710 goto err;
00711 }
00712 }
00713 current += 16*linesize;
00714 }
00715 } else {
00716
00717 memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
00718
00719 for (y=0; y < height; y+=16) {
00720 for (x=0; x < width; x+=16) {
00721 result = svq1_decode_delta_block (s, &s->gb, ¤t[x], previous,
00722 linesize, pmv, x, y);
00723 if (result != 0)
00724 {
00725 av_dlog(s->avctx, "Error in svq1_decode_delta_block %i\n",result);
00726 goto err;
00727 }
00728 }
00729
00730 pmv[0].x =
00731 pmv[0].y = 0;
00732
00733 current += 16*linesize;
00734 }
00735 }
00736 }
00737
00738 *pict = *(AVFrame*)&s->current_picture;
00739
00740
00741 MPV_frame_end(s);
00742
00743 *data_size=sizeof(AVFrame);
00744 result = buf_size;
00745 err:
00746 av_free(pmv);
00747 return result;
00748 }
00749
00750 static av_cold int svq1_decode_init(AVCodecContext *avctx)
00751 {
00752 MpegEncContext *s = avctx->priv_data;
00753 int i;
00754 int offset = 0;
00755
00756 MPV_decode_defaults(s);
00757
00758 s->avctx = avctx;
00759 s->width = (avctx->width+3)&~3;
00760 s->height = (avctx->height+3)&~3;
00761 s->codec_id= avctx->codec->id;
00762 avctx->pix_fmt = PIX_FMT_YUV410P;
00763 avctx->has_b_frames= 1;
00764 s->flags= avctx->flags;
00765 if (MPV_common_init(s) < 0) return -1;
00766
00767 INIT_VLC_STATIC(&svq1_block_type, 2, 4,
00768 &ff_svq1_block_type_vlc[0][1], 2, 1,
00769 &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
00770
00771 INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
00772 &mvtab[0][1], 2, 1,
00773 &mvtab[0][0], 2, 1, 176);
00774
00775 for (i = 0; i < 6; i++) {
00776 static const uint8_t sizes[2][6] = {{14, 10, 14, 18, 16, 18}, {10, 10, 14, 14, 14, 16}};
00777 static VLC_TYPE table[168][2];
00778 svq1_intra_multistage[i].table = &table[offset];
00779 svq1_intra_multistage[i].table_allocated = sizes[0][i];
00780 offset += sizes[0][i];
00781 init_vlc(&svq1_intra_multistage[i], 3, 8,
00782 &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
00783 &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
00784 svq1_inter_multistage[i].table = &table[offset];
00785 svq1_inter_multistage[i].table_allocated = sizes[1][i];
00786 offset += sizes[1][i];
00787 init_vlc(&svq1_inter_multistage[i], 3, 8,
00788 &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
00789 &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
00790 }
00791
00792 INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
00793 &ff_svq1_intra_mean_vlc[0][1], 4, 2,
00794 &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
00795
00796 INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
00797 &ff_svq1_inter_mean_vlc[0][1], 4, 2,
00798 &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
00799
00800 return 0;
00801 }
00802
00803 static av_cold int svq1_decode_end(AVCodecContext *avctx)
00804 {
00805 MpegEncContext *s = avctx->priv_data;
00806
00807 MPV_common_end(s);
00808 return 0;
00809 }
00810
00811
00812 AVCodec ff_svq1_decoder = {
00813 .name = "svq1",
00814 .type = AVMEDIA_TYPE_VIDEO,
00815 .id = CODEC_ID_SVQ1,
00816 .priv_data_size = sizeof(MpegEncContext),
00817 .init = svq1_decode_init,
00818 .close = svq1_decode_end,
00819 .decode = svq1_decode_frame,
00820 .capabilities = CODEC_CAP_DR1,
00821 .flush= ff_mpeg_flush,
00822 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE},
00823 .long_name= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
00824 };