1/* 2 * SVQ1 decoder 3 * ported to MPlayer by Arpi <arpi@thot.banki.hu> 4 * ported to libavcodec by Nick Kurshev <nickols_k@mail.ru> 5 * 6 * Copyright (C) 2002 the xine project 7 * Copyright (C) 2002 the ffmpeg project 8 * 9 * SVQ1 Encoder (c) 2004 Mike Melanson <melanson@pcisys.net> 10 * 11 * This file is part of FFmpeg. 12 * 13 * FFmpeg is free software; you can redistribute it and/or 14 * modify it under the terms of the GNU Lesser General Public 15 * License as published by the Free Software Foundation; either 16 * version 2.1 of the License, or (at your option) any later version. 17 * 18 * FFmpeg is distributed in the hope that it will be useful, 19 * but WITHOUT ANY WARRANTY; without even the implied warranty of 20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 21 * Lesser General Public License for more details. 22 * 23 * You should have received a copy of the GNU Lesser General Public 24 * License along with FFmpeg; if not, write to the Free Software 25 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 26 */ 27 28/** 29 * @file 30 * Sorenson Vector Quantizer #1 (SVQ1) video codec. 31 * For more information of the SVQ1 algorithm, visit: 32 * http://www.pcisys.net/~melanson/codecs/ 33 */ 34 35 36//#define DEBUG_SVQ1 37#include "avcodec.h" 38#include "dsputil.h" 39#include "mpegvideo.h" 40#include "mathops.h" 41 42#include "svq1.h" 43 44#undef NDEBUG 45#include <assert.h> 46 47extern const uint8_t mvtab[33][2]; 48 49static VLC svq1_block_type; 50static VLC svq1_motion_component; 51static VLC svq1_intra_multistage[6]; 52static VLC svq1_inter_multistage[6]; 53static VLC svq1_intra_mean; 54static VLC svq1_inter_mean; 55 56/* motion vector (prediction) */ 57typedef struct svq1_pmv_s { 58 int x; 59 int y; 60} svq1_pmv; 61 62static const uint16_t checksum_table[256] = { 63 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, 64 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, 65 0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, 66 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, 67 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485, 68 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D, 69 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4, 70 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC, 71 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823, 72 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, 73 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, 74 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, 75 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, 76 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49, 77 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70, 78 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78, 79 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F, 80 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067, 81 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, 82 0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, 83 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, 84 0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 85 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C, 86 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634, 87 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB, 88 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3, 89 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A, 90 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, 91 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, 92 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, 93 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, 94 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0 95}; 96 97static const uint8_t string_table[256] = { 98 0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54, 99 0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D, 100 0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06, 101 0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F, 102 0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0, 103 0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9, 104 0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2, 105 0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B, 106 0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9, 107 0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0, 108 0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B, 109 0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2, 110 0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D, 111 0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44, 112 0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F, 113 0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16, 114 0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB, 115 0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92, 116 0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9, 117 0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0, 118 0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F, 119 0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36, 120 0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D, 121 0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64, 122 0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26, 123 0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F, 124 0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74, 125 0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D, 126 0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82, 127 0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB, 128 0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0, 129 0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9 130}; 131 132#define SVQ1_PROCESS_VECTOR()\ 133 for (; level > 0; i++) {\ 134 /* process next depth */\ 135 if (i == m) {\ 136 m = n;\ 137 if (--level == 0)\ 138 break;\ 139 }\ 140 /* divide block if next bit set */\ 141 if (get_bits1 (bitbuf) == 0)\ 142 break;\ 143 /* add child nodes */\ 144 list[n++] = list[i];\ 145 list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));\ 146 } 147 148#define SVQ1_ADD_CODEBOOK()\ 149 /* add codebook entries to vector */\ 150 for (j=0; j < stages; j++) {\ 151 n3 = codebook[entries[j]] ^ 0x80808080;\ 152 n1 += ((n3 & 0xFF00FF00) >> 8);\ 153 n2 += (n3 & 0x00FF00FF);\ 154 }\ 155\ 156 /* clip to [0..255] */\ 157 if (n1 & 0xFF00FF00) {\ 158 n3 = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\ 159 n1 += 0x7F007F00;\ 160 n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\ 161 n1 &= (n3 & 0x00FF00FF);\ 162 }\ 163\ 164 if (n2 & 0xFF00FF00) {\ 165 n3 = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\ 166 n2 += 0x7F007F00;\ 167 n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\ 168 n2 &= (n3 & 0x00FF00FF);\ 169 } 170 171#define SVQ1_DO_CODEBOOK_INTRA()\ 172 for (y=0; y < height; y++) {\ 173 for (x=0; x < (width / 4); x++, codebook++) {\ 174 n1 = n4;\ 175 n2 = n4;\ 176 SVQ1_ADD_CODEBOOK()\ 177 /* store result */\ 178 dst[x] = (n1 << 8) | n2;\ 179 }\ 180 dst += (pitch / 4);\ 181 } 182 183#define SVQ1_DO_CODEBOOK_NONINTRA()\ 184 for (y=0; y < height; y++) {\ 185 for (x=0; x < (width / 4); x++, codebook++) {\ 186 n3 = dst[x];\ 187 /* add mean value to vector */\ 188 n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\ 189 n2 = (n3 & 0x00FF00FF) + n4;\ 190 SVQ1_ADD_CODEBOOK()\ 191 /* store result */\ 192 dst[x] = (n1 << 8) | n2;\ 193 }\ 194 dst += (pitch / 4);\ 195 } 196 197#define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\ 198 codebook = (const uint32_t *) cbook[level];\ 199 bit_cache = get_bits (bitbuf, 4*stages);\ 200 /* calculate codebook entries for this vector */\ 201 for (j=0; j < stages; j++) {\ 202 entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\ 203 }\ 204 mean -= (stages * 128);\ 205 n4 = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF); 206 207static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) { 208 uint32_t bit_cache; 209 uint8_t *list[63]; 210 uint32_t *dst; 211 const uint32_t *codebook; 212 int entries[6]; 213 int i, j, m, n; 214 int mean, stages; 215 unsigned x, y, width, height, level; 216 uint32_t n1, n2, n3, n4; 217 218 /* initialize list for breadth first processing of vectors */ 219 list[0] = pixels; 220 221 /* recursively process vector */ 222 for (i=0, m=1, n=1, level=5; i < n; i++) { 223 SVQ1_PROCESS_VECTOR(); 224 225 /* destination address and vector size */ 226 dst = (uint32_t *) list[i]; 227 width = 1 << ((4 + level) /2); 228 height = 1 << ((3 + level) /2); 229 230 /* get number of stages (-1 skips vector, 0 for mean only) */ 231 stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1; 232 233 if (stages == -1) { 234 for (y=0; y < height; y++) { 235 memset (&dst[y*(pitch / 4)], 0, width); 236 } 237 continue; /* skip vector */ 238 } 239 240 if ((stages > 0) && (level >= 4)) { 241#ifdef DEBUG_SVQ1 242 av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level); 243#endif 244 return -1; /* invalid vector */ 245 } 246 247 mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3); 248 249 if (stages == 0) { 250 for (y=0; y < height; y++) { 251 memset (&dst[y*(pitch / 4)], mean, width); 252 } 253 } else { 254 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks); 255 SVQ1_DO_CODEBOOK_INTRA() 256 } 257 } 258 259 return 0; 260} 261 262static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) { 263 uint32_t bit_cache; 264 uint8_t *list[63]; 265 uint32_t *dst; 266 const uint32_t *codebook; 267 int entries[6]; 268 int i, j, m, n; 269 int mean, stages; 270 int x, y, width, height, level; 271 uint32_t n1, n2, n3, n4; 272 273 /* initialize list for breadth first processing of vectors */ 274 list[0] = pixels; 275 276 /* recursively process vector */ 277 for (i=0, m=1, n=1, level=5; i < n; i++) { 278 SVQ1_PROCESS_VECTOR(); 279 280 /* destination address and vector size */ 281 dst = (uint32_t *) list[i]; 282 width = 1 << ((4 + level) /2); 283 height = 1 << ((3 + level) /2); 284 285 /* get number of stages (-1 skips vector, 0 for mean only) */ 286 stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1; 287 288 if (stages == -1) continue; /* skip vector */ 289 290 if ((stages > 0) && (level >= 4)) { 291#ifdef DEBUG_SVQ1 292 av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",stages,level); 293#endif 294 return -1; /* invalid vector */ 295 } 296 297 mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256; 298 299 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks); 300 SVQ1_DO_CODEBOOK_NONINTRA() 301 } 302 return 0; 303} 304 305static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv *mv, svq1_pmv **pmv) { 306 int diff; 307 int i; 308 309 for (i=0; i < 2; i++) { 310 311 /* get motion code */ 312 diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2); 313 if(diff<0) 314 return -1; 315 else if(diff){ 316 if(get_bits1(bitbuf)) diff= -diff; 317 } 318 319 /* add median of motion vector predictors and clip result */ 320 if (i == 1) 321 mv->y = ((diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26; 322 else 323 mv->x = ((diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x)) << 26) >> 26; 324 } 325 326 return 0; 327} 328 329static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) { 330 uint8_t *src; 331 uint8_t *dst; 332 int i; 333 334 src = &previous[x + y*pitch]; 335 dst = current; 336 337 for (i=0; i < 16; i++) { 338 memcpy (dst, src, 16); 339 src += pitch; 340 dst += pitch; 341 } 342} 343 344static int svq1_motion_inter_block (MpegEncContext *s, GetBitContext *bitbuf, 345 uint8_t *current, uint8_t *previous, int pitch, 346 svq1_pmv *motion, int x, int y) { 347 uint8_t *src; 348 uint8_t *dst; 349 svq1_pmv mv; 350 svq1_pmv *pmv[3]; 351 int result; 352 353 /* predict and decode motion vector */ 354 pmv[0] = &motion[0]; 355 if (y == 0) { 356 pmv[1] = 357 pmv[2] = pmv[0]; 358 } 359 else { 360 pmv[1] = &motion[(x / 8) + 2]; 361 pmv[2] = &motion[(x / 8) + 4]; 362 } 363 364 result = svq1_decode_motion_vector (bitbuf, &mv, pmv); 365 366 if (result != 0) 367 return result; 368 369 motion[0].x = 370 motion[(x / 8) + 2].x = 371 motion[(x / 8) + 3].x = mv.x; 372 motion[0].y = 373 motion[(x / 8) + 2].y = 374 motion[(x / 8) + 3].y = mv.y; 375 376 if(y + (mv.y >> 1)<0) 377 mv.y= 0; 378 if(x + (mv.x >> 1)<0) 379 mv.x= 0; 380 381#if 0 382 int w= (s->width+15)&~15; 383 int h= (s->height+15)&~15; 384 if(x + (mv.x >> 1)<0 || y + (mv.y >> 1)<0 || x + (mv.x >> 1) + 16 > w || y + (mv.y >> 1) + 16> h) 385 av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mv.x >> 1), y + (mv.y >> 1)); 386#endif 387 388 src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch]; 389 dst = current; 390 391 s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16); 392 393 return 0; 394} 395 396static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf, 397 uint8_t *current, uint8_t *previous, int pitch, 398 svq1_pmv *motion,int x, int y) { 399 uint8_t *src; 400 uint8_t *dst; 401 svq1_pmv mv; 402 svq1_pmv *pmv[4]; 403 int i, result; 404 405 /* predict and decode motion vector (0) */ 406 pmv[0] = &motion[0]; 407 if (y == 0) { 408 pmv[1] = 409 pmv[2] = pmv[0]; 410 } 411 else { 412 pmv[1] = &motion[(x / 8) + 2]; 413 pmv[2] = &motion[(x / 8) + 4]; 414 } 415 416 result = svq1_decode_motion_vector (bitbuf, &mv, pmv); 417 418 if (result != 0) 419 return result; 420 421 /* predict and decode motion vector (1) */ 422 pmv[0] = &mv; 423 if (y == 0) { 424 pmv[1] = 425 pmv[2] = pmv[0]; 426 } 427 else { 428 pmv[1] = &motion[(x / 8) + 3]; 429 } 430 result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv); 431 432 if (result != 0) 433 return result; 434 435 /* predict and decode motion vector (2) */ 436 pmv[1] = &motion[0]; 437 pmv[2] = &motion[(x / 8) + 1]; 438 439 result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv); 440 441 if (result != 0) 442 return result; 443 444 /* predict and decode motion vector (3) */ 445 pmv[2] = &motion[(x / 8) + 2]; 446 pmv[3] = &motion[(x / 8) + 3]; 447 448 result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv); 449 450 if (result != 0) 451 return result; 452 453 /* form predictions */ 454 for (i=0; i < 4; i++) { 455 int mvx= pmv[i]->x + (i&1)*16; 456 int mvy= pmv[i]->y + (i>>1)*16; 457 458 ///XXX /FIXME clipping or padding? 459 if(y + (mvy >> 1)<0) 460 mvy= 0; 461 if(x + (mvx >> 1)<0) 462 mvx= 0; 463 464#if 0 465 int w= (s->width+15)&~15; 466 int h= (s->height+15)&~15; 467 if(x + (mvx >> 1)<0 || y + (mvy >> 1)<0 || x + (mvx >> 1) + 8 > w || y + (mvy >> 1) + 8> h) 468 av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mvx >> 1), y + (mvy >> 1)); 469#endif 470 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch]; 471 dst = current; 472 473 s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8); 474 475 /* select next block */ 476 if (i & 1) { 477 current += 8*(pitch - 1); 478 } else { 479 current += 8; 480 } 481 } 482 483 return 0; 484} 485 486static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf, 487 uint8_t *current, uint8_t *previous, int pitch, 488 svq1_pmv *motion, int x, int y) { 489 uint32_t block_type; 490 int result = 0; 491 492 /* get block type */ 493 block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2); 494 495 /* reset motion vectors */ 496 if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) { 497 motion[0].x = 498 motion[0].y = 499 motion[(x / 8) + 2].x = 500 motion[(x / 8) + 2].y = 501 motion[(x / 8) + 3].x = 502 motion[(x / 8) + 3].y = 0; 503 } 504 505 switch (block_type) { 506 case SVQ1_BLOCK_SKIP: 507 svq1_skip_block (current, previous, pitch, x, y); 508 break; 509 510 case SVQ1_BLOCK_INTER: 511 result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y); 512 513 if (result != 0) 514 { 515#ifdef DEBUG_SVQ1 516 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_block %i\n",result); 517#endif 518 break; 519 } 520 result = svq1_decode_block_non_intra (bitbuf, current, pitch); 521 break; 522 523 case SVQ1_BLOCK_INTER_4V: 524 result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y); 525 526 if (result != 0) 527 { 528#ifdef DEBUG_SVQ1 529 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_4v_block %i\n",result); 530#endif 531 break; 532 } 533 result = svq1_decode_block_non_intra (bitbuf, current, pitch); 534 break; 535 536 case SVQ1_BLOCK_INTRA: 537 result = svq1_decode_block_intra (bitbuf, current, pitch); 538 break; 539 } 540 541 return result; 542} 543 544uint16_t ff_svq1_packet_checksum (const uint8_t *data, const int length, int value) { 545 int i; 546 547 for (i=0; i < length; i++) { 548 value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8); 549 } 550 551 return value; 552} 553 554static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) { 555 uint8_t seed; 556 int i; 557 558 out[0] = get_bits (bitbuf, 8); 559 560 seed = string_table[out[0]]; 561 562 for (i=1; i <= out[0]; i++) { 563 out[i] = get_bits (bitbuf, 8) ^ seed; 564 seed = string_table[out[i] ^ seed]; 565 } 566} 567 568static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) { 569 int frame_size_code; 570 int temporal_reference; 571 572 temporal_reference = get_bits (bitbuf, 8); 573 574 /* frame type */ 575 s->pict_type= get_bits (bitbuf, 2)+1; 576 if(s->pict_type==4) 577 return -1; 578 579 if (s->pict_type == FF_I_TYPE) { 580 581 /* unknown fields */ 582 if (s->f_code == 0x50 || s->f_code == 0x60) { 583 int csum = get_bits (bitbuf, 16); 584 585 csum = ff_svq1_packet_checksum (bitbuf->buffer, bitbuf->size_in_bits>>3, csum); 586 587// av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n", 588// (csum == 0) ? "correct" : "incorrect", csum); 589 } 590 591 if ((s->f_code ^ 0x10) >= 0x50) { 592 uint8_t msg[256]; 593 594 svq1_parse_string (bitbuf, msg); 595 596 av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg); 597 } 598 599 skip_bits (bitbuf, 2); 600 skip_bits (bitbuf, 2); 601 skip_bits1 (bitbuf); 602 603 /* load frame size */ 604 frame_size_code = get_bits (bitbuf, 3); 605 606 if (frame_size_code == 7) { 607 /* load width, height (12 bits each) */ 608 s->width = get_bits (bitbuf, 12); 609 s->height = get_bits (bitbuf, 12); 610 611 if (!s->width || !s->height) 612 return -1; 613 } else { 614 /* get width, height from table */ 615 s->width = ff_svq1_frame_size_table[frame_size_code].width; 616 s->height = ff_svq1_frame_size_table[frame_size_code].height; 617 } 618 } 619 620 /* unknown fields */ 621 if (get_bits1 (bitbuf) == 1) { 622 skip_bits1 (bitbuf); /* use packet checksum if (1) */ 623 skip_bits1 (bitbuf); /* component checksums after image data if (1) */ 624 625 if (get_bits (bitbuf, 2) != 0) 626 return -1; 627 } 628 629 if (get_bits1 (bitbuf) == 1) { 630 skip_bits1 (bitbuf); 631 skip_bits (bitbuf, 4); 632 skip_bits1 (bitbuf); 633 skip_bits (bitbuf, 2); 634 635 while (get_bits1 (bitbuf) == 1) { 636 skip_bits (bitbuf, 8); 637 } 638 } 639 640 return 0; 641} 642 643static int svq1_decode_frame(AVCodecContext *avctx, 644 void *data, int *data_size, 645 AVPacket *avpkt) 646{ 647 const uint8_t *buf = avpkt->data; 648 int buf_size = avpkt->size; 649 MpegEncContext *s=avctx->priv_data; 650 uint8_t *current, *previous; 651 int result, i, x, y, width, height; 652 AVFrame *pict = data; 653 654 /* initialize bit buffer */ 655 init_get_bits(&s->gb,buf,buf_size*8); 656 657 /* decode frame header */ 658 s->f_code = get_bits (&s->gb, 22); 659 660 if ((s->f_code & ~0x70) || !(s->f_code & 0x60)) 661 return -1; 662 663 /* swap some header bytes (why?) */ 664 if (s->f_code != 0x20) { 665 uint32_t *src = (uint32_t *) (buf + 4); 666 667 for (i=0; i < 4; i++) { 668 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i]; 669 } 670 } 671 672 result = svq1_decode_frame_header (&s->gb, s); 673 674 if (result != 0) 675 { 676#ifdef DEBUG_SVQ1 677 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result); 678#endif 679 return result; 680 } 681 682 //FIXME this avoids some confusion for "B frames" without 2 references 683 //this should be removed after libavcodec can handle more flexible picture types & ordering 684 if(s->pict_type==FF_B_TYPE && s->last_picture_ptr==NULL) return buf_size; 685 686 if(avctx->hurry_up && s->pict_type==FF_B_TYPE) return buf_size; 687 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE) 688 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE) 689 || avctx->skip_frame >= AVDISCARD_ALL) 690 return buf_size; 691 692 if(MPV_frame_start(s, avctx) < 0) 693 return -1; 694 695 /* decode y, u and v components */ 696 for (i=0; i < 3; i++) { 697 int linesize; 698 if (i == 0) { 699 width = FFALIGN(s->width, 16); 700 height = FFALIGN(s->height, 16); 701 linesize= s->linesize; 702 } else { 703 if(s->flags&CODEC_FLAG_GRAY) break; 704 width = FFALIGN(s->width/4, 16); 705 height = FFALIGN(s->height/4, 16); 706 linesize= s->uvlinesize; 707 } 708 709 current = s->current_picture.data[i]; 710 711 if(s->pict_type==FF_B_TYPE){ 712 previous = s->next_picture.data[i]; 713 }else{ 714 previous = s->last_picture.data[i]; 715 } 716 717 if (s->pict_type == FF_I_TYPE) { 718 /* keyframe */ 719 for (y=0; y < height; y+=16) { 720 for (x=0; x < width; x+=16) { 721 result = svq1_decode_block_intra (&s->gb, ¤t[x], linesize); 722 if (result != 0) 723 { 724//#ifdef DEBUG_SVQ1 725 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result); 726//#endif 727 return result; 728 } 729 } 730 current += 16*linesize; 731 } 732 } else { 733 svq1_pmv pmv[width/8+3]; 734 /* delta frame */ 735 memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv)); 736 737 for (y=0; y < height; y+=16) { 738 for (x=0; x < width; x+=16) { 739 result = svq1_decode_delta_block (s, &s->gb, ¤t[x], previous, 740 linesize, pmv, x, y); 741 if (result != 0) 742 { 743#ifdef DEBUG_SVQ1 744 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result); 745#endif 746 return result; 747 } 748 } 749 750 pmv[0].x = 751 pmv[0].y = 0; 752 753 current += 16*linesize; 754 } 755 } 756 } 757 758 *pict = *(AVFrame*)&s->current_picture; 759 760 761 MPV_frame_end(s); 762 763 *data_size=sizeof(AVFrame); 764 return buf_size; 765} 766 767static av_cold int svq1_decode_init(AVCodecContext *avctx) 768{ 769 MpegEncContext *s = avctx->priv_data; 770 int i; 771 int offset = 0; 772 773 MPV_decode_defaults(s); 774 775 s->avctx = avctx; 776 s->width = (avctx->width+3)&~3; 777 s->height = (avctx->height+3)&~3; 778 s->codec_id= avctx->codec->id; 779 avctx->pix_fmt = PIX_FMT_YUV410P; 780 avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames 781 s->flags= avctx->flags; 782 if (MPV_common_init(s) < 0) return -1; 783 784 INIT_VLC_STATIC(&svq1_block_type, 2, 4, 785 &ff_svq1_block_type_vlc[0][1], 2, 1, 786 &ff_svq1_block_type_vlc[0][0], 2, 1, 6); 787 788 INIT_VLC_STATIC(&svq1_motion_component, 7, 33, 789 &mvtab[0][1], 2, 1, 790 &mvtab[0][0], 2, 1, 176); 791 792 for (i = 0; i < 6; i++) { 793 static const uint8_t sizes[2][6] = {{14, 10, 14, 18, 16, 18}, {10, 10, 14, 14, 14, 16}}; 794 static VLC_TYPE table[168][2]; 795 svq1_intra_multistage[i].table = &table[offset]; 796 svq1_intra_multistage[i].table_allocated = sizes[0][i]; 797 offset += sizes[0][i]; 798 init_vlc(&svq1_intra_multistage[i], 3, 8, 799 &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1, 800 &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC); 801 svq1_inter_multistage[i].table = &table[offset]; 802 svq1_inter_multistage[i].table_allocated = sizes[1][i]; 803 offset += sizes[1][i]; 804 init_vlc(&svq1_inter_multistage[i], 3, 8, 805 &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1, 806 &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC); 807 } 808 809 INIT_VLC_STATIC(&svq1_intra_mean, 8, 256, 810 &ff_svq1_intra_mean_vlc[0][1], 4, 2, 811 &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632); 812 813 INIT_VLC_STATIC(&svq1_inter_mean, 9, 512, 814 &ff_svq1_inter_mean_vlc[0][1], 4, 2, 815 &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434); 816 817 return 0; 818} 819 820static av_cold int svq1_decode_end(AVCodecContext *avctx) 821{ 822 MpegEncContext *s = avctx->priv_data; 823 824 MPV_common_end(s); 825 return 0; 826} 827 828 829AVCodec svq1_decoder = { 830 "svq1", 831 AVMEDIA_TYPE_VIDEO, 832 CODEC_ID_SVQ1, 833 sizeof(MpegEncContext), 834 svq1_decode_init, 835 NULL, 836 svq1_decode_end, 837 svq1_decode_frame, 838 CODEC_CAP_DR1, 839 .flush= ff_mpeg_flush, 840 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE}, 841 .long_name= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"), 842}; 843