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#include "libavutil/crc.h" 36#include "libavutil/thread.h" 37 38#include "avcodec.h" 39#include "codec_internal.h" 40#include "get_bits.h" 41#include "h263data.h" 42#include "hpeldsp.h" 43#include "internal.h" 44#include "mathops.h" 45#include "svq1.h" 46 47#define SVQ1_BLOCK_TYPE_VLC_BITS 3 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 61typedef struct SVQ1Context { 62 HpelDSPContext hdsp; 63 GetBitContext gb; 64 AVFrame *prev; 65 66 uint8_t *pkt_swapped; 67 int pkt_swapped_allocated; 68 69 svq1_pmv *pmv; 70 int pmv_allocated; 71 72 int width; 73 int height; 74 int frame_code; 75 int nonref; // 1 if the current frame won't be referenced 76} SVQ1Context; 77 78static const uint8_t string_table[256] = { 79 0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54, 80 0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D, 81 0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06, 82 0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F, 83 0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0, 84 0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9, 85 0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2, 86 0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B, 87 0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9, 88 0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0, 89 0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B, 90 0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2, 91 0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D, 92 0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44, 93 0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F, 94 0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16, 95 0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB, 96 0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92, 97 0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9, 98 0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0, 99 0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F, 100 0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36, 101 0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D, 102 0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64, 103 0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26, 104 0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F, 105 0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74, 106 0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D, 107 0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82, 108 0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB, 109 0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0, 110 0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9 111}; 112 113#define SVQ1_PROCESS_VECTOR() \ 114 for (; level > 0; i++) { \ 115 /* process next depth */ \ 116 if (i == m) { \ 117 m = n; \ 118 if (--level == 0) \ 119 break; \ 120 } \ 121 /* divide block if next bit set */ \ 122 if (!get_bits1(bitbuf)) \ 123 break; \ 124 /* add child nodes */ \ 125 list[n++] = list[i]; \ 126 list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level >> 1) + 1));\ 127 } 128 129#define SVQ1_ADD_CODEBOOK() \ 130 /* add codebook entries to vector */ \ 131 for (j = 0; j < stages; j++) { \ 132 n3 = codebook[entries[j]] ^ 0x80808080; \ 133 n1 += (n3 & 0xFF00FF00) >> 8; \ 134 n2 += n3 & 0x00FF00FF; \ 135 } \ 136 \ 137 /* clip to [0..255] */ \ 138 if (n1 & 0xFF00FF00) { \ 139 n3 = (n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \ 140 n1 += 0x7F007F00; \ 141 n1 |= (~n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \ 142 n1 &= n3 & 0x00FF00FF; \ 143 } \ 144 \ 145 if (n2 & 0xFF00FF00) { \ 146 n3 = (n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \ 147 n2 += 0x7F007F00; \ 148 n2 |= (~n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \ 149 n2 &= n3 & 0x00FF00FF; \ 150 } 151 152#define SVQ1_CALC_CODEBOOK_ENTRIES(cbook) \ 153 codebook = (const uint32_t *)cbook[level]; \ 154 if (stages > 0) \ 155 bit_cache = get_bits(bitbuf, 4 * stages); \ 156 /* calculate codebook entries for this vector */ \ 157 for (j = 0; j < stages; j++) { \ 158 entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) + \ 159 16 * j) << (level + 1); \ 160 } \ 161 mean -= stages * 128; \ 162 n4 = (mean << 16) + mean; 163 164static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels, 165 ptrdiff_t pitch) 166{ 167 uint32_t bit_cache; 168 uint8_t *list[63]; 169 uint32_t *dst; 170 const uint32_t *codebook; 171 int entries[6]; 172 int i, j, m, n; 173 int stages; 174 unsigned mean; 175 unsigned x, y, width, height, level; 176 uint32_t n1, n2, n3, n4; 177 178 /* initialize list for breadth first processing of vectors */ 179 list[0] = pixels; 180 181 /* recursively process vector */ 182 for (i = 0, m = 1, n = 1, level = 5; i < n; i++) { 183 SVQ1_PROCESS_VECTOR(); 184 185 /* destination address and vector size */ 186 dst = (uint32_t *)list[i]; 187 width = 1 << ((4 + level) / 2); 188 height = 1 << ((3 + level) / 2); 189 190 /* get number of stages (-1 skips vector, 0 for mean only) */ 191 stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1; 192 193 if (stages == -1) { 194 for (y = 0; y < height; y++) 195 memset(&dst[y * (pitch / 4)], 0, width); 196 continue; /* skip vector */ 197 } 198 199 if ((stages > 0 && level >= 4)) { 200 ff_dlog(NULL, 201 "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n", 202 stages, level); 203 return AVERROR_INVALIDDATA; /* invalid vector */ 204 } 205 av_assert0(stages >= 0); 206 207 mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3); 208 209 if (stages == 0) { 210 for (y = 0; y < height; y++) 211 memset(&dst[y * (pitch / 4)], mean, width); 212 } else { 213 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks); 214 215 for (y = 0; y < height; y++) { 216 for (x = 0; x < width / 4; x++, codebook++) { 217 n1 = n4; 218 n2 = n4; 219 SVQ1_ADD_CODEBOOK() 220 /* store result */ 221 dst[x] = n1 << 8 | n2; 222 } 223 dst += pitch / 4; 224 } 225 } 226 } 227 228 return 0; 229} 230 231static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels, 232 ptrdiff_t pitch) 233{ 234 uint32_t bit_cache; 235 uint8_t *list[63]; 236 uint32_t *dst; 237 const uint32_t *codebook; 238 int entries[6]; 239 int i, j, m, n; 240 int stages; 241 unsigned mean; 242 int x, y, width, height, level; 243 uint32_t n1, n2, n3, n4; 244 245 /* initialize list for breadth first processing of vectors */ 246 list[0] = pixels; 247 248 /* recursively process vector */ 249 for (i = 0, m = 1, n = 1, level = 5; i < n; i++) { 250 SVQ1_PROCESS_VECTOR(); 251 252 /* destination address and vector size */ 253 dst = (uint32_t *)list[i]; 254 width = 1 << ((4 + level) / 2); 255 height = 1 << ((3 + level) / 2); 256 257 /* get number of stages (-1 skips vector, 0 for mean only) */ 258 stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1; 259 260 if (stages == -1) 261 continue; /* skip vector */ 262 263 if ((stages > 0 && level >= 4)) { 264 ff_dlog(NULL, 265 "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n", 266 stages, level); 267 return AVERROR_INVALIDDATA; /* invalid vector */ 268 } 269 av_assert0(stages >= 0); 270 271 mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256; 272 273 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks); 274 275 for (y = 0; y < height; y++) { 276 for (x = 0; x < width / 4; x++, codebook++) { 277 n3 = dst[x]; 278 /* add mean value to vector */ 279 n1 = n4 + ((n3 & 0xFF00FF00) >> 8); 280 n2 = n4 + (n3 & 0x00FF00FF); 281 SVQ1_ADD_CODEBOOK() 282 /* store result */ 283 dst[x] = n1 << 8 | n2; 284 } 285 dst += pitch / 4; 286 } 287 } 288 return 0; 289} 290 291static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv, 292 svq1_pmv **pmv) 293{ 294 int diff; 295 int i; 296 297 for (i = 0; i < 2; i++) { 298 /* get motion code */ 299 diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2); 300 if (diff < 0) 301 return AVERROR_INVALIDDATA; 302 else if (diff) { 303 if (get_bits1(bitbuf)) 304 diff = -diff; 305 } 306 307 /* add median of motion vector predictors and clip result */ 308 if (i == 1) 309 mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6); 310 else 311 mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6); 312 } 313 314 return 0; 315} 316 317static void svq1_skip_block(uint8_t *current, uint8_t *previous, 318 ptrdiff_t pitch, int x, int y) 319{ 320 uint8_t *src; 321 uint8_t *dst; 322 int i; 323 324 src = &previous[x + y * pitch]; 325 dst = current; 326 327 for (i = 0; i < 16; i++) { 328 memcpy(dst, src, 16); 329 src += pitch; 330 dst += pitch; 331 } 332} 333 334static int svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf, 335 uint8_t *current, uint8_t *previous, 336 ptrdiff_t pitch, svq1_pmv *motion, int x, int y, 337 int width, int height) 338{ 339 uint8_t *src; 340 uint8_t *dst; 341 svq1_pmv mv; 342 svq1_pmv *pmv[3]; 343 int result; 344 345 /* predict and decode motion vector */ 346 pmv[0] = &motion[0]; 347 if (y == 0) { 348 pmv[1] = 349 pmv[2] = pmv[0]; 350 } else { 351 pmv[1] = &motion[x / 8 + 2]; 352 pmv[2] = &motion[x / 8 + 4]; 353 } 354 355 result = svq1_decode_motion_vector(bitbuf, &mv, pmv); 356 if (result) 357 return result; 358 359 motion[0].x = 360 motion[x / 8 + 2].x = 361 motion[x / 8 + 3].x = mv.x; 362 motion[0].y = 363 motion[x / 8 + 2].y = 364 motion[x / 8 + 3].y = mv.y; 365 366 mv.x = av_clip(mv.x, -2 * x, 2 * (width - x - 16)); 367 mv.y = av_clip(mv.y, -2 * y, 2 * (height - y - 16)); 368 369 src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch]; 370 dst = current; 371 372 hdsp->put_pixels_tab[0][(mv.y & 1) << 1 | (mv.x & 1)](dst, src, pitch, 16); 373 374 return 0; 375} 376 377static int svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbuf, 378 uint8_t *current, uint8_t *previous, 379 ptrdiff_t pitch, svq1_pmv *motion, int x, int y, 380 int width, int height) 381{ 382 uint8_t *src; 383 uint8_t *dst; 384 svq1_pmv mv; 385 svq1_pmv *pmv[4]; 386 int i, result; 387 388 /* predict and decode motion vector (0) */ 389 pmv[0] = &motion[0]; 390 if (y == 0) { 391 pmv[1] = 392 pmv[2] = pmv[0]; 393 } else { 394 pmv[1] = &motion[(x / 8) + 2]; 395 pmv[2] = &motion[(x / 8) + 4]; 396 } 397 398 result = svq1_decode_motion_vector(bitbuf, &mv, pmv); 399 if (result) 400 return result; 401 402 /* predict and decode motion vector (1) */ 403 pmv[0] = &mv; 404 if (y == 0) { 405 pmv[1] = 406 pmv[2] = pmv[0]; 407 } else { 408 pmv[1] = &motion[(x / 8) + 3]; 409 } 410 result = svq1_decode_motion_vector(bitbuf, &motion[0], pmv); 411 if (result) 412 return result; 413 414 /* predict and decode motion vector (2) */ 415 pmv[1] = &motion[0]; 416 pmv[2] = &motion[(x / 8) + 1]; 417 418 result = svq1_decode_motion_vector(bitbuf, &motion[(x / 8) + 2], pmv); 419 if (result) 420 return result; 421 422 /* predict and decode motion vector (3) */ 423 pmv[2] = &motion[(x / 8) + 2]; 424 pmv[3] = &motion[(x / 8) + 3]; 425 426 result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv); 427 if (result) 428 return result; 429 430 /* form predictions */ 431 for (i = 0; i < 4; i++) { 432 int mvx = pmv[i]->x + (i & 1) * 16; 433 int mvy = pmv[i]->y + (i >> 1) * 16; 434 435 // FIXME: clipping or padding? 436 mvx = av_clip(mvx, -2 * x, 2 * (width - x - 8)); 437 mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8)); 438 439 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch]; 440 dst = current; 441 442 hdsp->put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8); 443 444 /* select next block */ 445 if (i & 1) 446 current += 8 * (pitch - 1); 447 else 448 current += 8; 449 } 450 451 return 0; 452} 453 454static int svq1_decode_delta_block(AVCodecContext *avctx, HpelDSPContext *hdsp, 455 GetBitContext *bitbuf, 456 uint8_t *current, uint8_t *previous, 457 ptrdiff_t pitch, svq1_pmv *motion, int x, int y, 458 int width, int height) 459{ 460 uint32_t block_type; 461 int result = 0; 462 463 /* get block type */ 464 block_type = get_vlc2(bitbuf, svq1_block_type.table, 465 SVQ1_BLOCK_TYPE_VLC_BITS, 1); 466 467 /* reset motion vectors */ 468 if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) { 469 motion[0].x = 470 motion[0].y = 471 motion[x / 8 + 2].x = 472 motion[x / 8 + 2].y = 473 motion[x / 8 + 3].x = 474 motion[x / 8 + 3].y = 0; 475 } 476 477 switch (block_type) { 478 case SVQ1_BLOCK_SKIP: 479 svq1_skip_block(current, previous, pitch, x, y); 480 break; 481 482 case SVQ1_BLOCK_INTER: 483 result = svq1_motion_inter_block(hdsp, bitbuf, current, previous, 484 pitch, motion, x, y, width, height); 485 486 if (result != 0) { 487 ff_dlog(avctx, "Error in svq1_motion_inter_block %i\n", result); 488 break; 489 } 490 result = svq1_decode_block_non_intra(bitbuf, current, pitch); 491 break; 492 493 case SVQ1_BLOCK_INTER_4V: 494 result = svq1_motion_inter_4v_block(hdsp, bitbuf, current, previous, 495 pitch, motion, x, y, width, height); 496 497 if (result != 0) { 498 ff_dlog(avctx, "Error in svq1_motion_inter_4v_block %i\n", result); 499 break; 500 } 501 result = svq1_decode_block_non_intra(bitbuf, current, pitch); 502 break; 503 504 case SVQ1_BLOCK_INTRA: 505 result = svq1_decode_block_intra(bitbuf, current, pitch); 506 break; 507 } 508 509 return result; 510} 511 512static void svq1_parse_string(GetBitContext *bitbuf, uint8_t out[257]) 513{ 514 uint8_t seed; 515 int i; 516 517 out[0] = get_bits(bitbuf, 8); 518 seed = string_table[out[0]]; 519 520 for (i = 1; i <= out[0]; i++) { 521 out[i] = get_bits(bitbuf, 8) ^ seed; 522 seed = string_table[out[i] ^ seed]; 523 } 524 out[i] = 0; 525} 526 527static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame) 528{ 529 SVQ1Context *s = avctx->priv_data; 530 GetBitContext *bitbuf = &s->gb; 531 int frame_size_code; 532 int width = s->width; 533 int height = s->height; 534 535 skip_bits(bitbuf, 8); /* temporal_reference */ 536 537 /* frame type */ 538 s->nonref = 0; 539 switch (get_bits(bitbuf, 2)) { 540 case 0: 541 frame->pict_type = AV_PICTURE_TYPE_I; 542 break; 543 case 2: 544 s->nonref = 1; 545 case 1: 546 frame->pict_type = AV_PICTURE_TYPE_P; 547 break; 548 default: 549 av_log(avctx, AV_LOG_ERROR, "Invalid frame type.\n"); 550 return AVERROR_INVALIDDATA; 551 } 552 553 if (frame->pict_type == AV_PICTURE_TYPE_I) { 554 /* unknown fields */ 555 if (s->frame_code == 0x50 || s->frame_code == 0x60) { 556 int csum = get_bits(bitbuf, 16); 557 558 csum = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_CCITT), av_bswap16(csum), bitbuf->buffer, bitbuf->size_in_bits >> 3)); 559 560 ff_dlog(avctx, "%s checksum (%02x) for packet data\n", 561 (csum == 0) ? "correct" : "incorrect", csum); 562 } 563 564 if ((s->frame_code ^ 0x10) >= 0x50) { 565 uint8_t msg[257]; 566 567 svq1_parse_string(bitbuf, msg); 568 569 av_log(avctx, AV_LOG_INFO, 570 "embedded message:\n%s\n", ((char *)msg) + 1); 571 } 572 573 skip_bits(bitbuf, 2); 574 skip_bits(bitbuf, 2); 575 skip_bits1(bitbuf); 576 577 /* load frame size */ 578 frame_size_code = get_bits(bitbuf, 3); 579 580 if (frame_size_code == 7) { 581 /* load width, height (12 bits each) */ 582 width = get_bits(bitbuf, 12); 583 height = get_bits(bitbuf, 12); 584 585 if (!width || !height) 586 return AVERROR_INVALIDDATA; 587 } else { 588 /* get width, height from table */ 589 width = ff_svq1_frame_size_table[frame_size_code][0]; 590 height = ff_svq1_frame_size_table[frame_size_code][1]; 591 } 592 } 593 594 /* unknown fields */ 595 if (get_bits1(bitbuf)) { 596 skip_bits1(bitbuf); /* use packet checksum if (1) */ 597 skip_bits1(bitbuf); /* component checksums after image data if (1) */ 598 599 if (get_bits(bitbuf, 2) != 0) 600 return AVERROR_INVALIDDATA; 601 } 602 603 if (get_bits1(bitbuf)) { 604 skip_bits1(bitbuf); 605 skip_bits(bitbuf, 4); 606 skip_bits1(bitbuf); 607 skip_bits(bitbuf, 2); 608 609 if (skip_1stop_8data_bits(bitbuf) < 0) 610 return AVERROR_INVALIDDATA; 611 } 612 if (get_bits_left(bitbuf) <= 0) 613 return AVERROR_INVALIDDATA; 614 615 s->width = width; 616 s->height = height; 617 return 0; 618} 619 620static int svq1_decode_frame(AVCodecContext *avctx, AVFrame *cur, 621 int *got_frame, AVPacket *avpkt) 622{ 623 const uint8_t *buf = avpkt->data; 624 int buf_size = avpkt->size; 625 SVQ1Context *s = avctx->priv_data; 626 uint8_t *current; 627 int result, i, x, y, width, height; 628 int ret; 629 630 /* initialize bit buffer */ 631 ret = init_get_bits8(&s->gb, buf, buf_size); 632 if (ret < 0) 633 return ret; 634 635 /* decode frame header */ 636 s->frame_code = get_bits(&s->gb, 22); 637 638 if ((s->frame_code & ~0x70) || !(s->frame_code & 0x60)) 639 return AVERROR_INVALIDDATA; 640 641 /* swap some header bytes (why?) */ 642 if (s->frame_code != 0x20) { 643 uint32_t *src; 644 645 if (buf_size < 9 * 4) { 646 av_log(avctx, AV_LOG_ERROR, "Input packet too small\n"); 647 return AVERROR_INVALIDDATA; 648 } 649 650 av_fast_padded_malloc(&s->pkt_swapped, 651 &s->pkt_swapped_allocated, 652 buf_size); 653 if (!s->pkt_swapped) 654 return AVERROR(ENOMEM); 655 656 memcpy(s->pkt_swapped, buf, buf_size); 657 buf = s->pkt_swapped; 658 init_get_bits(&s->gb, buf, buf_size * 8); 659 skip_bits(&s->gb, 22); 660 661 src = (uint32_t *)(s->pkt_swapped + 4); 662 663 for (i = 0; i < 4; i++) 664 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i]; 665 } 666 667 result = svq1_decode_frame_header(avctx, cur); 668 if (result != 0) { 669 ff_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result); 670 return result; 671 } 672 673 result = ff_set_dimensions(avctx, s->width, s->height); 674 if (result < 0) 675 return result; 676 677 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->nonref) || 678 (avctx->skip_frame >= AVDISCARD_NONKEY && 679 cur->pict_type != AV_PICTURE_TYPE_I) || 680 avctx->skip_frame >= AVDISCARD_ALL) 681 return buf_size; 682 683 result = ff_get_buffer(avctx, cur, s->nonref ? 0 : AV_GET_BUFFER_FLAG_REF); 684 if (result < 0) 685 return result; 686 687 av_fast_padded_malloc(&s->pmv, &s->pmv_allocated, (FFALIGN(s->width, 16) / 8 + 3) * sizeof(*s->pmv)); 688 if (!s->pmv) 689 return AVERROR(ENOMEM); 690 691 /* decode y, u and v components */ 692 for (i = 0; i < 3; i++) { 693 int linesize = cur->linesize[i]; 694 if (i == 0) { 695 width = FFALIGN(s->width, 16); 696 height = FFALIGN(s->height, 16); 697 } else { 698 if (avctx->flags & AV_CODEC_FLAG_GRAY) 699 break; 700 width = FFALIGN(s->width / 4, 16); 701 height = FFALIGN(s->height / 4, 16); 702 } 703 704 current = cur->data[i]; 705 706 if (cur->pict_type == AV_PICTURE_TYPE_I) { 707 /* keyframe */ 708 for (y = 0; y < height; y += 16) { 709 for (x = 0; x < width; x += 16) { 710 result = svq1_decode_block_intra(&s->gb, ¤t[x], 711 linesize); 712 if (result) { 713 av_log(avctx, AV_LOG_ERROR, 714 "Error in svq1_decode_block %i (keyframe)\n", 715 result); 716 return result; 717 } 718 } 719 current += 16 * linesize; 720 } 721 } else { 722 /* delta frame */ 723 uint8_t *previous = s->prev->data[i]; 724 if (!previous || 725 s->prev->width != s->width || s->prev->height != s->height) { 726 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n"); 727 return AVERROR_INVALIDDATA; 728 } 729 730 memset(s->pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv)); 731 732 for (y = 0; y < height; y += 16) { 733 for (x = 0; x < width; x += 16) { 734 result = svq1_decode_delta_block(avctx, &s->hdsp, 735 &s->gb, ¤t[x], 736 previous, linesize, 737 s->pmv, x, y, width, height); 738 if (result != 0) { 739 ff_dlog(avctx, 740 "Error in svq1_decode_delta_block %i\n", 741 result); 742 return result; 743 } 744 } 745 746 s->pmv[0].x = 747 s->pmv[0].y = 0; 748 749 current += 16 * linesize; 750 } 751 } 752 } 753 754 if (!s->nonref) { 755 av_frame_unref(s->prev); 756 result = av_frame_ref(s->prev, cur); 757 if (result < 0) 758 return result; 759 } 760 761 *got_frame = 1; 762 result = buf_size; 763 764 return result; 765} 766 767static av_cold void svq1_static_init(void) 768{ 769 INIT_VLC_STATIC(&svq1_block_type, SVQ1_BLOCK_TYPE_VLC_BITS, 4, 770 &ff_svq1_block_type_vlc[0][1], 2, 1, 771 &ff_svq1_block_type_vlc[0][0], 2, 1, 8); 772 773 INIT_VLC_STATIC(&svq1_motion_component, 7, 33, 774 &ff_mvtab[0][1], 2, 1, 775 &ff_mvtab[0][0], 2, 1, 176); 776 777 for (int i = 0, offset = 0; i < 6; i++) { 778 static const uint8_t sizes[2][6] = { { 14, 10, 14, 18, 16, 18 }, 779 { 10, 10, 14, 14, 14, 16 } }; 780 static VLCElem table[168]; 781 svq1_intra_multistage[i].table = &table[offset]; 782 svq1_intra_multistage[i].table_allocated = sizes[0][i]; 783 offset += sizes[0][i]; 784 init_vlc(&svq1_intra_multistage[i], 3, 8, 785 &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1, 786 &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, 787 INIT_VLC_USE_NEW_STATIC); 788 svq1_inter_multistage[i].table = &table[offset]; 789 svq1_inter_multistage[i].table_allocated = sizes[1][i]; 790 offset += sizes[1][i]; 791 init_vlc(&svq1_inter_multistage[i], 3, 8, 792 &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1, 793 &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, 794 INIT_VLC_USE_NEW_STATIC); 795 } 796 797 INIT_VLC_STATIC(&svq1_intra_mean, 8, 256, 798 &ff_svq1_intra_mean_vlc[0][1], 4, 2, 799 &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632); 800 801 INIT_VLC_STATIC(&svq1_inter_mean, 9, 512, 802 &ff_svq1_inter_mean_vlc[0][1], 4, 2, 803 &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434); 804} 805 806static av_cold int svq1_decode_init(AVCodecContext *avctx) 807{ 808 static AVOnce init_static_once = AV_ONCE_INIT; 809 SVQ1Context *s = avctx->priv_data; 810 811 s->prev = av_frame_alloc(); 812 if (!s->prev) 813 return AVERROR(ENOMEM); 814 815 s->width = avctx->width + 3 & ~3; 816 s->height = avctx->height + 3 & ~3; 817 avctx->pix_fmt = AV_PIX_FMT_YUV410P; 818 819 ff_hpeldsp_init(&s->hdsp, avctx->flags); 820 821 ff_thread_once(&init_static_once, svq1_static_init); 822 823 return 0; 824} 825 826static av_cold int svq1_decode_end(AVCodecContext *avctx) 827{ 828 SVQ1Context *s = avctx->priv_data; 829 830 av_frame_free(&s->prev); 831 av_freep(&s->pkt_swapped); 832 s->pkt_swapped_allocated = 0; 833 av_freep(&s->pmv); 834 s->pmv_allocated = 0; 835 836 return 0; 837} 838 839static void svq1_flush(AVCodecContext *avctx) 840{ 841 SVQ1Context *s = avctx->priv_data; 842 843 av_frame_unref(s->prev); 844} 845 846const FFCodec ff_svq1_decoder = { 847 .p.name = "svq1", 848 .p.long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"), 849 .p.type = AVMEDIA_TYPE_VIDEO, 850 .p.id = AV_CODEC_ID_SVQ1, 851 .priv_data_size = sizeof(SVQ1Context), 852 .init = svq1_decode_init, 853 .close = svq1_decode_end, 854 FF_CODEC_DECODE_CB(svq1_decode_frame), 855 .p.capabilities = AV_CODEC_CAP_DR1, 856 .flush = svq1_flush, 857 .p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P, 858 AV_PIX_FMT_NONE }, 859 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, 860}; 861