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 Libav. 12 * 13 * Libav 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 * Libav 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 Libav; 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#include "avcodec.h" 37#include "dsputil.h" 38#include "mpegvideo.h" 39#include "mathops.h" 40 41#include "svq1.h" 42 43#undef NDEBUG 44#include <assert.h> 45 46extern const uint8_t ff_mvtab[33][2]; 47 48static VLC svq1_block_type; 49static VLC svq1_motion_component; 50static VLC svq1_intra_multistage[6]; 51static VLC svq1_inter_multistage[6]; 52static VLC svq1_intra_mean; 53static VLC svq1_inter_mean; 54 55/* motion vector (prediction) */ 56typedef struct svq1_pmv_s { 57 int x; 58 int y; 59} svq1_pmv; 60 61static const uint16_t checksum_table[256] = { 62 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, 63 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, 64 0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, 65 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, 66 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485, 67 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D, 68 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4, 69 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC, 70 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823, 71 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, 72 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, 73 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, 74 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, 75 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49, 76 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70, 77 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78, 78 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F, 79 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067, 80 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, 81 0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, 82 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, 83 0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 84 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C, 85 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634, 86 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB, 87 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3, 88 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A, 89 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, 90 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, 91 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, 92 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, 93 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0 94}; 95 96static const uint8_t string_table[256] = { 97 0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54, 98 0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D, 99 0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06, 100 0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F, 101 0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0, 102 0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9, 103 0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2, 104 0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B, 105 0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9, 106 0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0, 107 0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B, 108 0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2, 109 0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D, 110 0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44, 111 0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F, 112 0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16, 113 0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB, 114 0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92, 115 0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9, 116 0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0, 117 0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F, 118 0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36, 119 0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D, 120 0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64, 121 0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26, 122 0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F, 123 0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74, 124 0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D, 125 0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82, 126 0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB, 127 0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0, 128 0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9 129}; 130 131#define SVQ1_PROCESS_VECTOR()\ 132 for (; level > 0; i++) {\ 133 /* process next depth */\ 134 if (i == m) {\ 135 m = n;\ 136 if (--level == 0)\ 137 break;\ 138 }\ 139 /* divide block if next bit set */\ 140 if (get_bits1 (bitbuf) == 0)\ 141 break;\ 142 /* add child nodes */\ 143 list[n++] = list[i];\ 144 list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));\ 145 } 146 147#define SVQ1_ADD_CODEBOOK()\ 148 /* add codebook entries to vector */\ 149 for (j=0; j < stages; j++) {\ 150 n3 = codebook[entries[j]] ^ 0x80808080;\ 151 n1 += ((n3 & 0xFF00FF00) >> 8);\ 152 n2 += (n3 & 0x00FF00FF);\ 153 }\ 154\ 155 /* clip to [0..255] */\ 156 if (n1 & 0xFF00FF00) {\ 157 n3 = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\ 158 n1 += 0x7F007F00;\ 159 n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\ 160 n1 &= (n3 & 0x00FF00FF);\ 161 }\ 162\ 163 if (n2 & 0xFF00FF00) {\ 164 n3 = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\ 165 n2 += 0x7F007F00;\ 166 n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\ 167 n2 &= (n3 & 0x00FF00FF);\ 168 } 169 170#define SVQ1_DO_CODEBOOK_INTRA()\ 171 for (y=0; y < height; y++) {\ 172 for (x=0; x < (width / 4); x++, codebook++) {\ 173 n1 = n4;\ 174 n2 = n4;\ 175 SVQ1_ADD_CODEBOOK()\ 176 /* store result */\ 177 dst[x] = (n1 << 8) | n2;\ 178 }\ 179 dst += (pitch / 4);\ 180 } 181 182#define SVQ1_DO_CODEBOOK_NONINTRA()\ 183 for (y=0; y < height; y++) {\ 184 for (x=0; x < (width / 4); x++, codebook++) {\ 185 n3 = dst[x];\ 186 /* add mean value to vector */\ 187 n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\ 188 n2 = (n3 & 0x00FF00FF) + n4;\ 189 SVQ1_ADD_CODEBOOK()\ 190 /* store result */\ 191 dst[x] = (n1 << 8) | n2;\ 192 }\ 193 dst += (pitch / 4);\ 194 } 195 196#define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\ 197 codebook = (const uint32_t *) cbook[level];\ 198 if (stages > 0)\ 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 av_dlog(NULL, 242 "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n", 243 stages, level); 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 av_dlog(NULL, 292 "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n", 293 stages, level); 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 = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6); 322 else 323 mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6); 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 src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch]; 382 dst = current; 383 384 s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16); 385 386 return 0; 387} 388 389static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf, 390 uint8_t *current, uint8_t *previous, int pitch, 391 svq1_pmv *motion,int x, int y) { 392 uint8_t *src; 393 uint8_t *dst; 394 svq1_pmv mv; 395 svq1_pmv *pmv[4]; 396 int i, result; 397 398 /* predict and decode motion vector (0) */ 399 pmv[0] = &motion[0]; 400 if (y == 0) { 401 pmv[1] = 402 pmv[2] = pmv[0]; 403 } 404 else { 405 pmv[1] = &motion[(x / 8) + 2]; 406 pmv[2] = &motion[(x / 8) + 4]; 407 } 408 409 result = svq1_decode_motion_vector (bitbuf, &mv, pmv); 410 411 if (result != 0) 412 return result; 413 414 /* predict and decode motion vector (1) */ 415 pmv[0] = &mv; 416 if (y == 0) { 417 pmv[1] = 418 pmv[2] = pmv[0]; 419 } 420 else { 421 pmv[1] = &motion[(x / 8) + 3]; 422 } 423 result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv); 424 425 if (result != 0) 426 return result; 427 428 /* predict and decode motion vector (2) */ 429 pmv[1] = &motion[0]; 430 pmv[2] = &motion[(x / 8) + 1]; 431 432 result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv); 433 434 if (result != 0) 435 return result; 436 437 /* predict and decode motion vector (3) */ 438 pmv[2] = &motion[(x / 8) + 2]; 439 pmv[3] = &motion[(x / 8) + 3]; 440 441 result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv); 442 443 if (result != 0) 444 return result; 445 446 /* form predictions */ 447 for (i=0; i < 4; i++) { 448 int mvx= pmv[i]->x + (i&1)*16; 449 int mvy= pmv[i]->y + (i>>1)*16; 450 451 ///XXX /FIXME clipping or padding? 452 if(y + (mvy >> 1)<0) 453 mvy= 0; 454 if(x + (mvx >> 1)<0) 455 mvx= 0; 456 457 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch]; 458 dst = current; 459 460 s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8); 461 462 /* select next block */ 463 if (i & 1) { 464 current += 8*(pitch - 1); 465 } else { 466 current += 8; 467 } 468 } 469 470 return 0; 471} 472 473static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf, 474 uint8_t *current, uint8_t *previous, int pitch, 475 svq1_pmv *motion, int x, int y) { 476 uint32_t block_type; 477 int result = 0; 478 479 /* get block type */ 480 block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2); 481 482 /* reset motion vectors */ 483 if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) { 484 motion[0].x = 485 motion[0].y = 486 motion[(x / 8) + 2].x = 487 motion[(x / 8) + 2].y = 488 motion[(x / 8) + 3].x = 489 motion[(x / 8) + 3].y = 0; 490 } 491 492 switch (block_type) { 493 case SVQ1_BLOCK_SKIP: 494 svq1_skip_block (current, previous, pitch, x, y); 495 break; 496 497 case SVQ1_BLOCK_INTER: 498 result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y); 499 500 if (result != 0) 501 { 502 av_dlog(s->avctx, "Error in svq1_motion_inter_block %i\n", result); 503 break; 504 } 505 result = svq1_decode_block_non_intra (bitbuf, current, pitch); 506 break; 507 508 case SVQ1_BLOCK_INTER_4V: 509 result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y); 510 511 if (result != 0) 512 { 513 av_dlog(s->avctx, "Error in svq1_motion_inter_4v_block %i\n", result); 514 break; 515 } 516 result = svq1_decode_block_non_intra (bitbuf, current, pitch); 517 break; 518 519 case SVQ1_BLOCK_INTRA: 520 result = svq1_decode_block_intra (bitbuf, current, pitch); 521 break; 522 } 523 524 return result; 525} 526 527uint16_t ff_svq1_packet_checksum (const uint8_t *data, const int length, int value) { 528 int i; 529 530 for (i=0; i < length; i++) { 531 value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8); 532 } 533 534 return value; 535} 536 537static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) { 538 uint8_t seed; 539 int i; 540 541 out[0] = get_bits (bitbuf, 8); 542 543 seed = string_table[out[0]]; 544 545 for (i=1; i <= out[0]; i++) { 546 out[i] = get_bits (bitbuf, 8) ^ seed; 547 seed = string_table[out[i] ^ seed]; 548 } 549} 550 551static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) { 552 int frame_size_code; 553 554 skip_bits(bitbuf, 8); /* temporal_reference */ 555 556 /* frame type */ 557 s->pict_type= get_bits (bitbuf, 2)+1; 558 if(s->pict_type==4) 559 return -1; 560 561 if (s->pict_type == AV_PICTURE_TYPE_I) { 562 563 /* unknown fields */ 564 if (s->f_code == 0x50 || s->f_code == 0x60) { 565 int csum = get_bits (bitbuf, 16); 566 567 csum = ff_svq1_packet_checksum (bitbuf->buffer, bitbuf->size_in_bits>>3, csum); 568 569// av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n", 570// (csum == 0) ? "correct" : "incorrect", csum); 571 } 572 573 if ((s->f_code ^ 0x10) >= 0x50) { 574 uint8_t msg[256]; 575 576 svq1_parse_string (bitbuf, msg); 577 578 av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg); 579 } 580 581 skip_bits (bitbuf, 2); 582 skip_bits (bitbuf, 2); 583 skip_bits1 (bitbuf); 584 585 /* load frame size */ 586 frame_size_code = get_bits (bitbuf, 3); 587 588 if (frame_size_code == 7) { 589 /* load width, height (12 bits each) */ 590 s->width = get_bits (bitbuf, 12); 591 s->height = get_bits (bitbuf, 12); 592 593 if (!s->width || !s->height) 594 return -1; 595 } else { 596 /* get width, height from table */ 597 s->width = ff_svq1_frame_size_table[frame_size_code].width; 598 s->height = ff_svq1_frame_size_table[frame_size_code].height; 599 } 600 } 601 602 /* unknown fields */ 603 if (get_bits1 (bitbuf) == 1) { 604 skip_bits1 (bitbuf); /* use packet checksum if (1) */ 605 skip_bits1 (bitbuf); /* component checksums after image data if (1) */ 606 607 if (get_bits (bitbuf, 2) != 0) 608 return -1; 609 } 610 611 if (get_bits1 (bitbuf) == 1) { 612 skip_bits1 (bitbuf); 613 skip_bits (bitbuf, 4); 614 skip_bits1 (bitbuf); 615 skip_bits (bitbuf, 2); 616 617 while (get_bits1 (bitbuf) == 1) { 618 skip_bits (bitbuf, 8); 619 } 620 } 621 622 return 0; 623} 624 625static int svq1_decode_frame(AVCodecContext *avctx, 626 void *data, int *data_size, 627 AVPacket *avpkt) 628{ 629 const uint8_t *buf = avpkt->data; 630 int buf_size = avpkt->size; 631 MpegEncContext *s=avctx->priv_data; 632 uint8_t *current, *previous; 633 int result, i, x, y, width, height; 634 AVFrame *pict = data; 635 svq1_pmv *pmv; 636 637 /* initialize bit buffer */ 638 init_get_bits(&s->gb,buf,buf_size*8); 639 640 /* decode frame header */ 641 s->f_code = get_bits (&s->gb, 22); 642 643 if ((s->f_code & ~0x70) || !(s->f_code & 0x60)) 644 return -1; 645 646 /* swap some header bytes (why?) */ 647 if (s->f_code != 0x20) { 648 uint32_t *src = (uint32_t *) (buf + 4); 649 650 for (i=0; i < 4; i++) { 651 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i]; 652 } 653 } 654 655 result = svq1_decode_frame_header (&s->gb, s); 656 657 if (result != 0) 658 { 659 av_dlog(s->avctx, "Error in svq1_decode_frame_header %i\n",result); 660 return result; 661 } 662 avcodec_set_dimensions(avctx, s->width, s->height); 663 664 //FIXME this avoids some confusion for "B frames" without 2 references 665 //this should be removed after libavcodec can handle more flexible picture types & ordering 666 if(s->pict_type==AV_PICTURE_TYPE_B && s->last_picture_ptr==NULL) return buf_size; 667 668 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==AV_PICTURE_TYPE_B) 669 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=AV_PICTURE_TYPE_I) 670 || avctx->skip_frame >= AVDISCARD_ALL) 671 return buf_size; 672 673 if(MPV_frame_start(s, avctx) < 0) 674 return -1; 675 676 pmv = av_malloc((FFALIGN(s->width, 16)/8 + 3) * sizeof(*pmv)); 677 if (!pmv) 678 return -1; 679 680 /* decode y, u and v components */ 681 for (i=0; i < 3; i++) { 682 int linesize; 683 if (i == 0) { 684 width = FFALIGN(s->width, 16); 685 height = FFALIGN(s->height, 16); 686 linesize= s->linesize; 687 } else { 688 if(s->flags&CODEC_FLAG_GRAY) break; 689 width = FFALIGN(s->width/4, 16); 690 height = FFALIGN(s->height/4, 16); 691 linesize= s->uvlinesize; 692 } 693 694 current = s->current_picture.f.data[i]; 695 696 if(s->pict_type==AV_PICTURE_TYPE_B){ 697 previous = s->next_picture.f.data[i]; 698 }else{ 699 previous = s->last_picture.f.data[i]; 700 } 701 702 if (s->pict_type == AV_PICTURE_TYPE_I) { 703 /* keyframe */ 704 for (y=0; y < height; y+=16) { 705 for (x=0; x < width; x+=16) { 706 result = svq1_decode_block_intra (&s->gb, ¤t[x], linesize); 707 if (result != 0) 708 { 709 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result); 710 goto err; 711 } 712 } 713 current += 16*linesize; 714 } 715 } else { 716 /* delta frame */ 717 memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv)); 718 719 for (y=0; y < height; y+=16) { 720 for (x=0; x < width; x+=16) { 721 result = svq1_decode_delta_block (s, &s->gb, ¤t[x], previous, 722 linesize, pmv, x, y); 723 if (result != 0) 724 { 725 av_dlog(s->avctx, "Error in svq1_decode_delta_block %i\n",result); 726 goto err; 727 } 728 } 729 730 pmv[0].x = 731 pmv[0].y = 0; 732 733 current += 16*linesize; 734 } 735 } 736 } 737 738 *pict = *(AVFrame*)&s->current_picture; 739 740 741 MPV_frame_end(s); 742 743 *data_size=sizeof(AVFrame); 744 result = buf_size; 745err: 746 av_free(pmv); 747 return result; 748} 749 750static av_cold int svq1_decode_init(AVCodecContext *avctx) 751{ 752 MpegEncContext *s = avctx->priv_data; 753 int i; 754 int offset = 0; 755 756 MPV_decode_defaults(s); 757 758 s->avctx = avctx; 759 s->width = (avctx->width+3)&~3; 760 s->height = (avctx->height+3)&~3; 761 s->codec_id= avctx->codec->id; 762 avctx->pix_fmt = PIX_FMT_YUV410P; 763 avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames 764 s->flags= avctx->flags; 765 if (MPV_common_init(s) < 0) return -1; 766 767 INIT_VLC_STATIC(&svq1_block_type, 2, 4, 768 &ff_svq1_block_type_vlc[0][1], 2, 1, 769 &ff_svq1_block_type_vlc[0][0], 2, 1, 6); 770 771 INIT_VLC_STATIC(&svq1_motion_component, 7, 33, 772 &ff_mvtab[0][1], 2, 1, 773 &ff_mvtab[0][0], 2, 1, 176); 774 775 for (i = 0; i < 6; i++) { 776 static const uint8_t sizes[2][6] = {{14, 10, 14, 18, 16, 18}, {10, 10, 14, 14, 14, 16}}; 777 static VLC_TYPE table[168][2]; 778 svq1_intra_multistage[i].table = &table[offset]; 779 svq1_intra_multistage[i].table_allocated = sizes[0][i]; 780 offset += sizes[0][i]; 781 init_vlc(&svq1_intra_multistage[i], 3, 8, 782 &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1, 783 &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC); 784 svq1_inter_multistage[i].table = &table[offset]; 785 svq1_inter_multistage[i].table_allocated = sizes[1][i]; 786 offset += sizes[1][i]; 787 init_vlc(&svq1_inter_multistage[i], 3, 8, 788 &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1, 789 &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC); 790 } 791 792 INIT_VLC_STATIC(&svq1_intra_mean, 8, 256, 793 &ff_svq1_intra_mean_vlc[0][1], 4, 2, 794 &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632); 795 796 INIT_VLC_STATIC(&svq1_inter_mean, 9, 512, 797 &ff_svq1_inter_mean_vlc[0][1], 4, 2, 798 &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434); 799 800 return 0; 801} 802 803static av_cold int svq1_decode_end(AVCodecContext *avctx) 804{ 805 MpegEncContext *s = avctx->priv_data; 806 807 MPV_common_end(s); 808 return 0; 809} 810 811 812AVCodec ff_svq1_decoder = { 813 .name = "svq1", 814 .type = AVMEDIA_TYPE_VIDEO, 815 .id = CODEC_ID_SVQ1, 816 .priv_data_size = sizeof(MpegEncContext), 817 .init = svq1_decode_init, 818 .close = svq1_decode_end, 819 .decode = svq1_decode_frame, 820 .capabilities = CODEC_CAP_DR1, 821 .flush= ff_mpeg_flush, 822 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE}, 823 .long_name= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"), 824}; 825