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