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