1/* 2 * Smacker decoder 3 * Copyright (c) 2006 Konstantin Shishkov 4 * 5 * This file is part of FFmpeg. 6 * 7 * FFmpeg is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation; either 10 * version 2.1 of the License, or (at your option) any later version. 11 * 12 * FFmpeg is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with FFmpeg; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 */ 21 22/** 23 * @file 24 * Smacker decoder 25 */ 26 27/* 28 * Based on http://wiki.multimedia.cx/index.php?title=Smacker 29 */ 30 31#include <stdio.h> 32#include <stdlib.h> 33 34#include "libavutil/channel_layout.h" 35 36#include "avcodec.h" 37 38#define SMKTREE_BITS 9 39#define SMK_NODE 0x80000000 40 41#define SMKTREE_DECODE_MAX_RECURSION FFMIN(32, 3 * SMKTREE_BITS) 42#define SMKTREE_DECODE_BIG_MAX_RECURSION 500 43 44/* The maximum possible unchecked overread happens in decode_header_trees: 45 * Decoding the MMAP tree can overread by 6 * SMKTREE_BITS + 1, followed by 46 * three get_bits1, followed by at most 2 + 3 * 16 read bits when reading 47 * the TYPE tree before the next check. 64 is because of 64 bit reads. */ 48#if (6 * SMKTREE_BITS + 1 + 3 + (2 + 3 * 16) + 64) <= 8 * AV_INPUT_BUFFER_PADDING_SIZE 49#define UNCHECKED_BITSTREAM_READER 1 50#endif 51#define BITSTREAM_READER_LE 52#include "bytestream.h" 53#include "codec_internal.h" 54#include "get_bits.h" 55#include "internal.h" 56#include "mathops.h" 57 58typedef struct SmackVContext { 59 AVCodecContext *avctx; 60 AVFrame *pic; 61 62 int *mmap_tbl, *mclr_tbl, *full_tbl, *type_tbl; 63 int mmap_last[3], mclr_last[3], full_last[3], type_last[3]; 64} SmackVContext; 65 66typedef struct HuffEntry { 67 uint8_t value; 68 uint8_t length; 69} HuffEntry; 70 71/** 72 * Context used for code reconstructing 73 */ 74typedef struct HuffContext { 75 int current; 76 HuffEntry entries[256]; 77} HuffContext; 78 79/* common parameters used for decode_bigtree */ 80typedef struct DBCtx { 81 int current, length; 82 int *values; 83 VLC *v1, *v2; 84 uint8_t vals[2]; 85 int escapes[3]; 86 int *last; 87} DBCtx; 88 89/* possible runs of blocks */ 90static const int block_runs[64] = { 91 1, 2, 3, 4, 5, 6, 7, 8, 92 9, 10, 11, 12, 13, 14, 15, 16, 93 17, 18, 19, 20, 21, 22, 23, 24, 94 25, 26, 27, 28, 29, 30, 31, 32, 95 33, 34, 35, 36, 37, 38, 39, 40, 96 41, 42, 43, 44, 45, 46, 47, 48, 97 49, 50, 51, 52, 53, 54, 55, 56, 98 57, 58, 59, 128, 256, 512, 1024, 2048 }; 99 100enum SmkBlockTypes { 101 SMK_BLK_MONO = 0, 102 SMK_BLK_FULL = 1, 103 SMK_BLK_SKIP = 2, 104 SMK_BLK_FILL = 3 }; 105 106/** 107 * Decode local frame tree 108 * 109 * Can read SMKTREE_DECODE_MAX_RECURSION before the first check; 110 * does not overread gb on success. 111 */ 112static int smacker_decode_tree(GetBitContext *gb, HuffContext *hc, int length) 113{ 114 if (length > SMKTREE_DECODE_MAX_RECURSION || length > 3 * SMKTREE_BITS) { 115 av_log(NULL, AV_LOG_ERROR, "Maximum tree recursion level exceeded.\n"); 116 return AVERROR_INVALIDDATA; 117 } 118 119 if(!get_bits1(gb)){ //Leaf 120 if (hc->current >= 256) { 121 av_log(NULL, AV_LOG_ERROR, "Tree size exceeded!\n"); 122 return AVERROR_INVALIDDATA; 123 } 124 if (get_bits_left(gb) < 8) 125 return AVERROR_INVALIDDATA; 126 hc->entries[hc->current++] = (HuffEntry){ get_bits(gb, 8), length }; 127 return 0; 128 } else { //Node 129 int r; 130 length++; 131 r = smacker_decode_tree(gb, hc, length); 132 if(r) 133 return r; 134 return smacker_decode_tree(gb, hc, length); 135 } 136} 137 138/** 139 * Decode header tree 140 * 141 * Checks before the first read, can overread by 6 * SMKTREE_BITS on success. 142 */ 143static int smacker_decode_bigtree(GetBitContext *gb, DBCtx *ctx, int length) 144{ 145 // Larger length can cause segmentation faults due to too deep recursion. 146 if (length > SMKTREE_DECODE_BIG_MAX_RECURSION) { 147 av_log(NULL, AV_LOG_ERROR, "Maximum bigtree recursion level exceeded.\n"); 148 return AVERROR_INVALIDDATA; 149 } 150 151 if (ctx->current >= ctx->length) { 152 av_log(NULL, AV_LOG_ERROR, "Tree size exceeded!\n"); 153 return AVERROR_INVALIDDATA; 154 } 155 if (get_bits_left(gb) <= 0) 156 return AVERROR_INVALIDDATA; 157 if(!get_bits1(gb)){ //Leaf 158 int val, i1, i2; 159 i1 = ctx->v1->table ? get_vlc2(gb, ctx->v1->table, SMKTREE_BITS, 3) 160 : ctx->vals[0]; 161 i2 = ctx->v2->table ? get_vlc2(gb, ctx->v2->table, SMKTREE_BITS, 3) 162 : ctx->vals[1]; 163 val = i1 | (i2 << 8); 164 if(val == ctx->escapes[0]) { 165 ctx->last[0] = ctx->current; 166 val = 0; 167 } else if(val == ctx->escapes[1]) { 168 ctx->last[1] = ctx->current; 169 val = 0; 170 } else if(val == ctx->escapes[2]) { 171 ctx->last[2] = ctx->current; 172 val = 0; 173 } 174 175 ctx->values[ctx->current++] = val; 176 return 1; 177 } else { //Node 178 int r = 0, r_new, t; 179 180 t = ctx->current++; 181 r = smacker_decode_bigtree(gb, ctx, length + 1); 182 if(r < 0) 183 return r; 184 ctx->values[t] = SMK_NODE | r; 185 r++; 186 r_new = smacker_decode_bigtree(gb, ctx, length + 1); 187 if (r_new < 0) 188 return r_new; 189 return r + r_new; 190 } 191} 192 193/** 194 * Store large tree as FFmpeg's vlc codes 195 * 196 * Can read FFMAX(1 + SMKTREE_DECODE_MAX_RECURSION, 2 + 3 * 16) bits 197 * before the first check; can overread by 6 * SMKTREE_BITS + 1 on success. 198 */ 199static int smacker_decode_header_tree(SmackVContext *smk, GetBitContext *gb, int **recodes, int *last, int size) 200{ 201 VLC vlc[2] = { { 0 } }; 202 int escapes[3]; 203 DBCtx ctx; 204 int err; 205 206 if(size >= UINT_MAX>>4){ // (((size + 3) >> 2) + 3) << 2 must not overflow 207 av_log(smk->avctx, AV_LOG_ERROR, "size too large\n"); 208 return AVERROR_INVALIDDATA; 209 } 210 211 for (int i = 0; i < 2; i++) { 212 HuffContext h; 213 h.current = 0; 214 if (!get_bits1(gb)) { 215 ctx.vals[i] = 0; 216 av_log(smk->avctx, AV_LOG_ERROR, "Skipping %s bytes tree\n", 217 i ? "high" : "low"); 218 continue; 219 } 220 err = smacker_decode_tree(gb, &h, 0); 221 if (err < 0) 222 goto error; 223 skip_bits1(gb); 224 if (h.current > 1) { 225 err = ff_init_vlc_from_lengths(&vlc[i], SMKTREE_BITS, h.current, 226 &h.entries[0].length, sizeof(*h.entries), 227 &h.entries[0].value, sizeof(*h.entries), 1, 228 0, INIT_VLC_OUTPUT_LE, smk->avctx); 229 if (err < 0) { 230 av_log(smk->avctx, AV_LOG_ERROR, "Cannot build VLC table\n"); 231 goto error; 232 } 233 } else 234 ctx.vals[i] = h.entries[0].value; 235 } 236 237 escapes[0] = get_bits(gb, 16); 238 escapes[1] = get_bits(gb, 16); 239 escapes[2] = get_bits(gb, 16); 240 241 last[0] = last[1] = last[2] = -1; 242 243 ctx.escapes[0] = escapes[0]; 244 ctx.escapes[1] = escapes[1]; 245 ctx.escapes[2] = escapes[2]; 246 ctx.v1 = &vlc[0]; 247 ctx.v2 = &vlc[1]; 248 ctx.last = last; 249 ctx.length = (size + 3) >> 2; 250 ctx.current = 0; 251 ctx.values = av_malloc_array(ctx.length + 3, sizeof(ctx.values[0])); 252 if (!ctx.values) { 253 err = AVERROR(ENOMEM); 254 goto error; 255 } 256 *recodes = ctx.values; 257 258 err = smacker_decode_bigtree(gb, &ctx, 0); 259 if (err < 0) 260 goto error; 261 skip_bits1(gb); 262 if (ctx.last[0] == -1) ctx.last[0] = ctx.current++; 263 if (ctx.last[1] == -1) ctx.last[1] = ctx.current++; 264 if (ctx.last[2] == -1) ctx.last[2] = ctx.current++; 265 266 err = 0; 267error: 268 for (int i = 0; i < 2; i++) { 269 ff_free_vlc(&vlc[i]); 270 } 271 272 return err; 273} 274 275static int decode_header_trees(SmackVContext *smk) { 276 GetBitContext gb; 277 int mmap_size, mclr_size, full_size, type_size, ret; 278 int skip = 0; 279 280 mmap_size = AV_RL32(smk->avctx->extradata); 281 mclr_size = AV_RL32(smk->avctx->extradata + 4); 282 full_size = AV_RL32(smk->avctx->extradata + 8); 283 type_size = AV_RL32(smk->avctx->extradata + 12); 284 285 ret = init_get_bits8(&gb, smk->avctx->extradata + 16, smk->avctx->extradata_size - 16); 286 if (ret < 0) 287 return ret; 288 289 if(!get_bits1(&gb)) { 290 skip ++; 291 av_log(smk->avctx, AV_LOG_INFO, "Skipping MMAP tree\n"); 292 smk->mmap_tbl = av_malloc(sizeof(int) * 2); 293 if (!smk->mmap_tbl) 294 return AVERROR(ENOMEM); 295 smk->mmap_tbl[0] = 0; 296 smk->mmap_last[0] = smk->mmap_last[1] = smk->mmap_last[2] = 1; 297 } else { 298 ret = smacker_decode_header_tree(smk, &gb, &smk->mmap_tbl, smk->mmap_last, mmap_size); 299 if (ret < 0) 300 return ret; 301 } 302 if(!get_bits1(&gb)) { 303 skip ++; 304 av_log(smk->avctx, AV_LOG_INFO, "Skipping MCLR tree\n"); 305 smk->mclr_tbl = av_malloc(sizeof(int) * 2); 306 if (!smk->mclr_tbl) 307 return AVERROR(ENOMEM); 308 smk->mclr_tbl[0] = 0; 309 smk->mclr_last[0] = smk->mclr_last[1] = smk->mclr_last[2] = 1; 310 } else { 311 ret = smacker_decode_header_tree(smk, &gb, &smk->mclr_tbl, smk->mclr_last, mclr_size); 312 if (ret < 0) 313 return ret; 314 } 315 if(!get_bits1(&gb)) { 316 skip ++; 317 av_log(smk->avctx, AV_LOG_INFO, "Skipping FULL tree\n"); 318 smk->full_tbl = av_malloc(sizeof(int) * 2); 319 if (!smk->full_tbl) 320 return AVERROR(ENOMEM); 321 smk->full_tbl[0] = 0; 322 smk->full_last[0] = smk->full_last[1] = smk->full_last[2] = 1; 323 } else { 324 ret = smacker_decode_header_tree(smk, &gb, &smk->full_tbl, smk->full_last, full_size); 325 if (ret < 0) 326 return ret; 327 } 328 if(!get_bits1(&gb)) { 329 skip ++; 330 av_log(smk->avctx, AV_LOG_INFO, "Skipping TYPE tree\n"); 331 smk->type_tbl = av_malloc(sizeof(int) * 2); 332 if (!smk->type_tbl) 333 return AVERROR(ENOMEM); 334 smk->type_tbl[0] = 0; 335 smk->type_last[0] = smk->type_last[1] = smk->type_last[2] = 1; 336 } else { 337 ret = smacker_decode_header_tree(smk, &gb, &smk->type_tbl, smk->type_last, type_size); 338 if (ret < 0) 339 return ret; 340 } 341 if (skip == 4 || get_bits_left(&gb) < 0) 342 return AVERROR_INVALIDDATA; 343 344 return 0; 345} 346 347static av_always_inline void last_reset(int *recode, int *last) { 348 recode[last[0]] = recode[last[1]] = recode[last[2]] = 0; 349} 350 351/* Get code and update history. 352 * Checks before reading, does not overread. */ 353static av_always_inline int smk_get_code(GetBitContext *gb, int *recode, int *last) { 354 register int *table = recode; 355 int v; 356 357 while(*table & SMK_NODE) { 358 if (get_bits_left(gb) < 1) 359 return AVERROR_INVALIDDATA; 360 if(get_bits1(gb)) 361 table += (*table) & (~SMK_NODE); 362 table++; 363 } 364 v = *table; 365 366 if(v != recode[last[0]]) { 367 recode[last[2]] = recode[last[1]]; 368 recode[last[1]] = recode[last[0]]; 369 recode[last[0]] = v; 370 } 371 return v; 372} 373 374static int decode_frame(AVCodecContext *avctx, AVFrame *rframe, 375 int *got_frame, AVPacket *avpkt) 376{ 377 SmackVContext * const smk = avctx->priv_data; 378 uint8_t *out; 379 uint32_t *pal; 380 GetByteContext gb2; 381 GetBitContext gb; 382 int blocks, blk, bw, bh; 383 int i, ret; 384 int stride; 385 int flags; 386 387 if (avpkt->size <= 769) 388 return AVERROR_INVALIDDATA; 389 390 if ((ret = ff_reget_buffer(avctx, smk->pic, 0)) < 0) 391 return ret; 392 393 /* make the palette available on the way out */ 394 pal = (uint32_t*)smk->pic->data[1]; 395 bytestream2_init(&gb2, avpkt->data, avpkt->size); 396 flags = bytestream2_get_byteu(&gb2); 397 smk->pic->palette_has_changed = flags & 1; 398 smk->pic->key_frame = !!(flags & 2); 399 if (smk->pic->key_frame) 400 smk->pic->pict_type = AV_PICTURE_TYPE_I; 401 else 402 smk->pic->pict_type = AV_PICTURE_TYPE_P; 403 404 for(i = 0; i < 256; i++) 405 *pal++ = 0xFFU << 24 | bytestream2_get_be24u(&gb2); 406 407 last_reset(smk->mmap_tbl, smk->mmap_last); 408 last_reset(smk->mclr_tbl, smk->mclr_last); 409 last_reset(smk->full_tbl, smk->full_last); 410 last_reset(smk->type_tbl, smk->type_last); 411 if ((ret = init_get_bits8(&gb, avpkt->data + 769, avpkt->size - 769)) < 0) 412 return ret; 413 414 blk = 0; 415 bw = avctx->width >> 2; 416 bh = avctx->height >> 2; 417 blocks = bw * bh; 418 stride = smk->pic->linesize[0]; 419 while(blk < blocks) { 420 int type, run, mode; 421 uint16_t pix; 422 423 type = smk_get_code(&gb, smk->type_tbl, smk->type_last); 424 if (type < 0) 425 return type; 426 run = block_runs[(type >> 2) & 0x3F]; 427 switch(type & 3){ 428 case SMK_BLK_MONO: 429 while(run-- && blk < blocks){ 430 int clr, map; 431 int hi, lo; 432 clr = smk_get_code(&gb, smk->mclr_tbl, smk->mclr_last); 433 map = smk_get_code(&gb, smk->mmap_tbl, smk->mmap_last); 434 out = smk->pic->data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4; 435 hi = clr >> 8; 436 lo = clr & 0xFF; 437 for(i = 0; i < 4; i++) { 438 if(map & 1) out[0] = hi; else out[0] = lo; 439 if(map & 2) out[1] = hi; else out[1] = lo; 440 if(map & 4) out[2] = hi; else out[2] = lo; 441 if(map & 8) out[3] = hi; else out[3] = lo; 442 map >>= 4; 443 out += stride; 444 } 445 blk++; 446 } 447 break; 448 case SMK_BLK_FULL: 449 mode = 0; 450 if(avctx->codec_tag == MKTAG('S', 'M', 'K', '4')) { // In case of Smacker v4 we have three modes 451 if (get_bits_left(&gb) < 1) 452 return AVERROR_INVALIDDATA; 453 if(get_bits1(&gb)) mode = 1; 454 else if(get_bits1(&gb)) mode = 2; 455 } 456 while(run-- && blk < blocks){ 457 out = smk->pic->data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4; 458 switch(mode){ 459 case 0: 460 for(i = 0; i < 4; i++) { 461 pix = smk_get_code(&gb, smk->full_tbl, smk->full_last); 462 AV_WL16(out+2,pix); 463 pix = smk_get_code(&gb, smk->full_tbl, smk->full_last); 464 AV_WL16(out,pix); 465 out += stride; 466 } 467 break; 468 case 1: 469 pix = smk_get_code(&gb, smk->full_tbl, smk->full_last); 470 out[0] = out[1] = pix & 0xFF; 471 out[2] = out[3] = pix >> 8; 472 out += stride; 473 out[0] = out[1] = pix & 0xFF; 474 out[2] = out[3] = pix >> 8; 475 out += stride; 476 pix = smk_get_code(&gb, smk->full_tbl, smk->full_last); 477 out[0] = out[1] = pix & 0xFF; 478 out[2] = out[3] = pix >> 8; 479 out += stride; 480 out[0] = out[1] = pix & 0xFF; 481 out[2] = out[3] = pix >> 8; 482 break; 483 case 2: 484 for(i = 0; i < 2; i++) { 485 uint16_t pix1, pix2; 486 pix2 = smk_get_code(&gb, smk->full_tbl, smk->full_last); 487 pix1 = smk_get_code(&gb, smk->full_tbl, smk->full_last); 488 AV_WL16(out,pix1); 489 AV_WL16(out+2,pix2); 490 out += stride; 491 AV_WL16(out,pix1); 492 AV_WL16(out+2,pix2); 493 out += stride; 494 } 495 break; 496 } 497 blk++; 498 } 499 break; 500 case SMK_BLK_SKIP: 501 while(run-- && blk < blocks) 502 blk++; 503 break; 504 case SMK_BLK_FILL: 505 mode = type >> 8; 506 while(run-- && blk < blocks){ 507 uint32_t col; 508 out = smk->pic->data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4; 509 col = mode * 0x01010101U; 510 for(i = 0; i < 4; i++) { 511 *((uint32_t*)out) = col; 512 out += stride; 513 } 514 blk++; 515 } 516 break; 517 } 518 519 } 520 521 if ((ret = av_frame_ref(rframe, smk->pic)) < 0) 522 return ret; 523 524 *got_frame = 1; 525 526 /* always report that the buffer was completely consumed */ 527 return avpkt->size; 528} 529 530 531static av_cold int decode_end(AVCodecContext *avctx) 532{ 533 SmackVContext * const smk = avctx->priv_data; 534 535 av_freep(&smk->mmap_tbl); 536 av_freep(&smk->mclr_tbl); 537 av_freep(&smk->full_tbl); 538 av_freep(&smk->type_tbl); 539 540 av_frame_free(&smk->pic); 541 542 return 0; 543} 544 545 546static av_cold int decode_init(AVCodecContext *avctx) 547{ 548 SmackVContext * const c = avctx->priv_data; 549 int ret; 550 551 c->avctx = avctx; 552 553 avctx->pix_fmt = AV_PIX_FMT_PAL8; 554 555 c->pic = av_frame_alloc(); 556 if (!c->pic) 557 return AVERROR(ENOMEM); 558 559 /* decode huffman trees from extradata */ 560 if (avctx->extradata_size <= 16){ 561 av_log(avctx, AV_LOG_ERROR, "Extradata missing!\n"); 562 return AVERROR(EINVAL); 563 } 564 565 ret = decode_header_trees(c); 566 if (ret < 0) { 567 return ret; 568 } 569 570 return 0; 571} 572 573 574static av_cold int smka_decode_init(AVCodecContext *avctx) 575{ 576 int channels = avctx->ch_layout.nb_channels; 577 if (channels < 1 || channels > 2) { 578 av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n"); 579 return AVERROR_INVALIDDATA; 580 } 581 av_channel_layout_uninit(&avctx->ch_layout); 582 av_channel_layout_default(&avctx->ch_layout, channels); 583 avctx->sample_fmt = avctx->bits_per_coded_sample == 8 ? AV_SAMPLE_FMT_U8 : AV_SAMPLE_FMT_S16; 584 585 return 0; 586} 587 588/** 589 * Decode Smacker audio data 590 */ 591static int smka_decode_frame(AVCodecContext *avctx, AVFrame *frame, 592 int *got_frame_ptr, AVPacket *avpkt) 593{ 594 const uint8_t *buf = avpkt->data; 595 int buf_size = avpkt->size; 596 GetBitContext gb; 597 VLC vlc[4] = { { 0 } }; 598 int16_t *samples; 599 uint8_t *samples8; 600 uint8_t values[4]; 601 int i, res, ret; 602 int unp_size; 603 int bits, stereo; 604 unsigned pred[2], val, val2; 605 606 if (buf_size <= 4) { 607 av_log(avctx, AV_LOG_ERROR, "packet is too small\n"); 608 return AVERROR_INVALIDDATA; 609 } 610 611 unp_size = AV_RL32(buf); 612 613 if (unp_size > (1U<<24)) { 614 av_log(avctx, AV_LOG_ERROR, "packet is too big\n"); 615 return AVERROR_INVALIDDATA; 616 } 617 618 if ((ret = init_get_bits8(&gb, buf + 4, buf_size - 4)) < 0) 619 return ret; 620 621 if(!get_bits1(&gb)){ 622 av_log(avctx, AV_LOG_INFO, "Sound: no data\n"); 623 *got_frame_ptr = 0; 624 return 1; 625 } 626 stereo = get_bits1(&gb); 627 bits = get_bits1(&gb); 628 if (stereo ^ (avctx->ch_layout.nb_channels != 1)) { 629 av_log(avctx, AV_LOG_ERROR, "channels mismatch\n"); 630 return AVERROR_INVALIDDATA; 631 } 632 if (bits == (avctx->sample_fmt == AV_SAMPLE_FMT_U8)) { 633 av_log(avctx, AV_LOG_ERROR, "sample format mismatch\n"); 634 return AVERROR_INVALIDDATA; 635 } 636 637 /* get output buffer */ 638 frame->nb_samples = unp_size / (avctx->ch_layout.nb_channels * (bits + 1)); 639 if (unp_size % (avctx->ch_layout.nb_channels * (bits + 1))) { 640 av_log(avctx, AV_LOG_ERROR, 641 "The buffer does not contain an integer number of samples\n"); 642 return AVERROR_INVALIDDATA; 643 } 644 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) 645 return ret; 646 samples = (int16_t *)frame->data[0]; 647 samples8 = frame->data[0]; 648 649 // Initialize 650 for(i = 0; i < (1 << (bits + stereo)); i++) { 651 HuffContext h; 652 h.current = 0; 653 skip_bits1(&gb); 654 if ((ret = smacker_decode_tree(&gb, &h, 0)) < 0) 655 goto error; 656 skip_bits1(&gb); 657 if (h.current > 1) { 658 ret = ff_init_vlc_from_lengths(&vlc[i], SMKTREE_BITS, h.current, 659 &h.entries[0].length, sizeof(*h.entries), 660 &h.entries[0].value, sizeof(*h.entries), 1, 661 0, INIT_VLC_OUTPUT_LE, avctx); 662 if (ret < 0) { 663 av_log(avctx, AV_LOG_ERROR, "Cannot build VLC table\n"); 664 goto error; 665 } 666 } else 667 values[i] = h.entries[0].value; 668 } 669 /* this codec relies on wraparound instead of clipping audio */ 670 if(bits) { //decode 16-bit data 671 for(i = stereo; i >= 0; i--) 672 pred[i] = av_bswap16(get_bits(&gb, 16)); 673 for(i = 0; i <= stereo; i++) 674 *samples++ = pred[i]; 675 unp_size /= 2; 676 677 if (vlc[0 ].table || vlc[ 1].table || 678 vlc[2*stereo].table || vlc[2*stereo+1].table) { 679 for(; i < unp_size ; i++) { 680 unsigned idx = 2 * (i & stereo); 681 if (get_bits_left(&gb) < 0) { 682 ret = AVERROR_INVALIDDATA; 683 goto error; 684 } 685 if (vlc[idx].table) 686 res = get_vlc2(&gb, vlc[idx].table, SMKTREE_BITS, 3); 687 else 688 res = values[idx]; 689 val = res; 690 if (vlc[++idx].table) 691 res = get_vlc2(&gb, vlc[idx].table, SMKTREE_BITS, 3); 692 else 693 res = values[idx]; 694 val |= res << 8; 695 pred[idx / 2] += val; 696 *samples++ = pred[idx / 2]; 697 } 698 } else if (stereo) { 699 val = 256*values[1] + values[0]; 700 val2 = 256*values[3] + values[2]; 701 for(; i < unp_size; i+=2) { 702 pred[0] += val; 703 pred[1] += val2; 704 *samples++ = pred[0]; 705 *samples++ = pred[1]; 706 } 707 } else { 708 val = 256*values[1] + values[0]; 709 for(; i < unp_size; i++) { 710 pred[0] += val; 711 *samples++ = pred[0]; 712 } 713 } 714 } else { //8-bit data 715 for(i = stereo; i >= 0; i--) 716 pred[i] = get_bits(&gb, 8); 717 for(i = 0; i <= stereo; i++) 718 *samples8++ = pred[i]; 719 for(; i < unp_size; i++) { 720 unsigned idx = i & stereo; 721 if (get_bits_left(&gb) < 0) { 722 ret = AVERROR_INVALIDDATA; 723 goto error; 724 } 725 if (vlc[idx].table) 726 val = get_vlc2(&gb, vlc[idx].table, SMKTREE_BITS, 3); 727 else 728 val = values[idx]; 729 pred[idx] += val; 730 *samples8++ = pred[idx]; 731 } 732 } 733 734 *got_frame_ptr = 1; 735 ret = buf_size; 736 737error: 738 for(i = 0; i < 4; i++) { 739 ff_free_vlc(&vlc[i]); 740 } 741 742 return ret; 743} 744 745const FFCodec ff_smacker_decoder = { 746 .p.name = "smackvid", 747 .p.long_name = NULL_IF_CONFIG_SMALL("Smacker video"), 748 .p.type = AVMEDIA_TYPE_VIDEO, 749 .p.id = AV_CODEC_ID_SMACKVIDEO, 750 .priv_data_size = sizeof(SmackVContext), 751 .init = decode_init, 752 .close = decode_end, 753 FF_CODEC_DECODE_CB(decode_frame), 754 .p.capabilities = AV_CODEC_CAP_DR1, 755 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_INIT_THREADSAFE, 756}; 757 758const FFCodec ff_smackaud_decoder = { 759 .p.name = "smackaud", 760 .p.long_name = NULL_IF_CONFIG_SMALL("Smacker audio"), 761 .p.type = AVMEDIA_TYPE_AUDIO, 762 .p.id = AV_CODEC_ID_SMACKAUDIO, 763 .init = smka_decode_init, 764 FF_CODEC_DECODE_CB(smka_decode_frame), 765 .p.capabilities = AV_CODEC_CAP_DR1, 766 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, 767}; 768