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