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 libavcodec/svq1.c 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 const uint8_t *buf, int buf_size) 646{ 647 MpegEncContext *s=avctx->priv_data; 648 uint8_t *current, *previous; 649 int result, i, x, y, width, height; 650 AVFrame *pict = data; 651 652 /* initialize bit buffer */ 653 init_get_bits(&s->gb,buf,buf_size*8); 654 655 /* decode frame header */ 656 s->f_code = get_bits (&s->gb, 22); 657 658 if ((s->f_code & ~0x70) || !(s->f_code & 0x60)) 659 return -1; 660 661 /* swap some header bytes (why?) */ 662 if (s->f_code != 0x20) { 663 uint32_t *src = (uint32_t *) (buf + 4); 664 665 for (i=0; i < 4; i++) { 666 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i]; 667 } 668 } 669 670 result = svq1_decode_frame_header (&s->gb, s); 671 672 if (result != 0) 673 { 674#ifdef DEBUG_SVQ1 675 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result); 676#endif 677 return result; 678 } 679 680 //FIXME this avoids some confusion for "B frames" without 2 references 681 //this should be removed after libavcodec can handle more flexible picture types & ordering 682 if(s->pict_type==FF_B_TYPE && s->last_picture_ptr==NULL) return buf_size; 683 684 if(avctx->hurry_up && s->pict_type==FF_B_TYPE) return buf_size; 685 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE) 686 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE) 687 || avctx->skip_frame >= AVDISCARD_ALL) 688 return buf_size; 689 690 if(MPV_frame_start(s, avctx) < 0) 691 return -1; 692 693 /* decode y, u and v components */ 694 for (i=0; i < 3; i++) { 695 int linesize; 696 if (i == 0) { 697 width = (s->width+15)&~15; 698 height = (s->height+15)&~15; 699 linesize= s->linesize; 700 } else { 701 if(s->flags&CODEC_FLAG_GRAY) break; 702 width = (s->width/4+15)&~15; 703 height = (s->height/4+15)&~15; 704 linesize= s->uvlinesize; 705 } 706 707 current = s->current_picture.data[i]; 708 709 if(s->pict_type==FF_B_TYPE){ 710 previous = s->next_picture.data[i]; 711 }else{ 712 previous = s->last_picture.data[i]; 713 } 714 715 if (s->pict_type == FF_I_TYPE) { 716 /* keyframe */ 717 for (y=0; y < height; y+=16) { 718 for (x=0; x < width; x+=16) { 719 result = svq1_decode_block_intra (&s->gb, ¤t[x], linesize); 720 if (result != 0) 721 { 722//#ifdef DEBUG_SVQ1 723 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result); 724//#endif 725 return result; 726 } 727 } 728 current += 16*linesize; 729 } 730 } else { 731 svq1_pmv pmv[width/8+3]; 732 /* delta frame */ 733 memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv)); 734 735 for (y=0; y < height; y+=16) { 736 for (x=0; x < width; x+=16) { 737 result = svq1_decode_delta_block (s, &s->gb, ¤t[x], previous, 738 linesize, pmv, x, y); 739 if (result != 0) 740 { 741#ifdef DEBUG_SVQ1 742 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result); 743#endif 744 return result; 745 } 746 } 747 748 pmv[0].x = 749 pmv[0].y = 0; 750 751 current += 16*linesize; 752 } 753 } 754 } 755 756 *pict = *(AVFrame*)&s->current_picture; 757 758 759 MPV_frame_end(s); 760 761 *data_size=sizeof(AVFrame); 762 return buf_size; 763} 764 765static av_cold int svq1_decode_init(AVCodecContext *avctx) 766{ 767 MpegEncContext *s = avctx->priv_data; 768 int i; 769 770 MPV_decode_defaults(s); 771 772 s->avctx = avctx; 773 s->width = (avctx->width+3)&~3; 774 s->height = (avctx->height+3)&~3; 775 s->codec_id= avctx->codec->id; 776 avctx->pix_fmt = PIX_FMT_YUV410P; 777 avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames 778 s->flags= avctx->flags; 779 if (MPV_common_init(s) < 0) return -1; 780 781 init_vlc(&svq1_block_type, 2, 4, 782 &ff_svq1_block_type_vlc[0][1], 2, 1, 783 &ff_svq1_block_type_vlc[0][0], 2, 1, 1); 784 785 init_vlc(&svq1_motion_component, 7, 33, 786 &mvtab[0][1], 2, 1, 787 &mvtab[0][0], 2, 1, 1); 788 789 for (i = 0; i < 6; i++) { 790 init_vlc(&svq1_intra_multistage[i], 3, 8, 791 &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1, 792 &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, 1); 793 init_vlc(&svq1_inter_multistage[i], 3, 8, 794 &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1, 795 &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, 1); 796 } 797 798 init_vlc(&svq1_intra_mean, 8, 256, 799 &ff_svq1_intra_mean_vlc[0][1], 4, 2, 800 &ff_svq1_intra_mean_vlc[0][0], 4, 2, 1); 801 802 init_vlc(&svq1_inter_mean, 9, 512, 803 &ff_svq1_inter_mean_vlc[0][1], 4, 2, 804 &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1); 805 806 return 0; 807} 808 809static av_cold int svq1_decode_end(AVCodecContext *avctx) 810{ 811 MpegEncContext *s = avctx->priv_data; 812 813 MPV_common_end(s); 814 return 0; 815} 816 817 818AVCodec svq1_decoder = { 819 "svq1", 820 CODEC_TYPE_VIDEO, 821 CODEC_ID_SVQ1, 822 sizeof(MpegEncContext), 823 svq1_decode_init, 824 NULL, 825 svq1_decode_end, 826 svq1_decode_frame, 827 CODEC_CAP_DR1, 828 .flush= ff_mpeg_flush, 829 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE}, 830 .long_name= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1"), 831}; 832