00001 /* 00002 * Smacker decoder 00003 * Copyright (c) 2006 Konstantin Shishkov 00004 * 00005 * This file is part of FFmpeg. 00006 * 00007 * FFmpeg is free software; you can redistribute it and/or 00008 * modify it under the terms of the GNU Lesser General Public 00009 * License as published by the Free Software Foundation; either 00010 * version 2.1 of the License, or (at your option) any later version. 00011 * 00012 * FFmpeg is distributed in the hope that it will be useful, 00013 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00014 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00015 * Lesser General Public License for more details. 00016 * 00017 * You should have received a copy of the GNU Lesser General Public 00018 * License along with FFmpeg; if not, write to the Free Software 00019 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 00020 */ 00021 00027 /* 00028 * Based on http://wiki.multimedia.cx/index.php?title=Smacker 00029 */ 00030 00031 #include <stdio.h> 00032 #include <stdlib.h> 00033 00034 #include "avcodec.h" 00035 #include "libavutil/audioconvert.h" 00036 #include "mathops.h" 00037 00038 #define ALT_BITSTREAM_READER_LE 00039 #include "get_bits.h" 00040 #include "bytestream.h" 00041 00042 #define SMKTREE_BITS 9 00043 #define SMK_NODE 0x80000000 00044 00045 /* 00046 * Decoder context 00047 */ 00048 typedef struct SmackVContext { 00049 AVCodecContext *avctx; 00050 AVFrame pic; 00051 00052 int *mmap_tbl, *mclr_tbl, *full_tbl, *type_tbl; 00053 int mmap_last[3], mclr_last[3], full_last[3], type_last[3]; 00054 } SmackVContext; 00055 00059 typedef struct HuffContext { 00060 int length; 00061 int maxlength; 00062 int current; 00063 uint32_t *bits; 00064 int *lengths; 00065 int *values; 00066 } HuffContext; 00067 00068 /* common parameters used for decode_bigtree */ 00069 typedef struct DBCtx { 00070 VLC *v1, *v2; 00071 int *recode1, *recode2; 00072 int escapes[3]; 00073 int *last; 00074 int lcur; 00075 } DBCtx; 00076 00077 /* possible runs of blocks */ 00078 static const int block_runs[64] = { 00079 1, 2, 3, 4, 5, 6, 7, 8, 00080 9, 10, 11, 12, 13, 14, 15, 16, 00081 17, 18, 19, 20, 21, 22, 23, 24, 00082 25, 26, 27, 28, 29, 30, 31, 32, 00083 33, 34, 35, 36, 37, 38, 39, 40, 00084 41, 42, 43, 44, 45, 46, 47, 48, 00085 49, 50, 51, 52, 53, 54, 55, 56, 00086 57, 58, 59, 128, 256, 512, 1024, 2048 }; 00087 00088 enum SmkBlockTypes { 00089 SMK_BLK_MONO = 0, 00090 SMK_BLK_FULL = 1, 00091 SMK_BLK_SKIP = 2, 00092 SMK_BLK_FILL = 3 }; 00093 00097 static int smacker_decode_tree(GetBitContext *gb, HuffContext *hc, uint32_t prefix, int length) 00098 { 00099 if(!get_bits1(gb)){ //Leaf 00100 if(hc->current >= 256){ 00101 av_log(NULL, AV_LOG_ERROR, "Tree size exceeded!\n"); 00102 return -1; 00103 } 00104 if(length){ 00105 hc->bits[hc->current] = prefix; 00106 hc->lengths[hc->current] = length; 00107 } else { 00108 hc->bits[hc->current] = 0; 00109 hc->lengths[hc->current] = 0; 00110 } 00111 hc->values[hc->current] = get_bits(gb, 8); 00112 hc->current++; 00113 if(hc->maxlength < length) 00114 hc->maxlength = length; 00115 return 0; 00116 } else { //Node 00117 int r; 00118 length++; 00119 r = smacker_decode_tree(gb, hc, prefix, length); 00120 if(r) 00121 return r; 00122 return smacker_decode_tree(gb, hc, prefix | (1 << (length - 1)), length); 00123 } 00124 } 00125 00129 static int smacker_decode_bigtree(GetBitContext *gb, HuffContext *hc, DBCtx *ctx) 00130 { 00131 if(!get_bits1(gb)){ //Leaf 00132 int val, i1, i2, b1, b2; 00133 if(hc->current >= hc->length){ 00134 av_log(NULL, AV_LOG_ERROR, "Tree size exceeded!\n"); 00135 return -1; 00136 } 00137 b1 = get_bits_count(gb); 00138 i1 = ctx->v1->table ? get_vlc2(gb, ctx->v1->table, SMKTREE_BITS, 3) : 0; 00139 b1 = get_bits_count(gb) - b1; 00140 b2 = get_bits_count(gb); 00141 i2 = ctx->v2->table ? get_vlc2(gb, ctx->v2->table, SMKTREE_BITS, 3) : 0; 00142 b2 = get_bits_count(gb) - b2; 00143 if (i1 < 0 || i2 < 0) 00144 return -1; 00145 val = ctx->recode1[i1] | (ctx->recode2[i2] << 8); 00146 if(val == ctx->escapes[0]) { 00147 ctx->last[0] = hc->current; 00148 val = 0; 00149 } else if(val == ctx->escapes[1]) { 00150 ctx->last[1] = hc->current; 00151 val = 0; 00152 } else if(val == ctx->escapes[2]) { 00153 ctx->last[2] = hc->current; 00154 val = 0; 00155 } 00156 00157 hc->values[hc->current++] = val; 00158 return 1; 00159 } else { //Node 00160 int r = 0, t; 00161 00162 t = hc->current++; 00163 r = smacker_decode_bigtree(gb, hc, ctx); 00164 if(r < 0) 00165 return r; 00166 hc->values[t] = SMK_NODE | r; 00167 r++; 00168 r += smacker_decode_bigtree(gb, hc, ctx); 00169 return r; 00170 } 00171 } 00172 00176 static int smacker_decode_header_tree(SmackVContext *smk, GetBitContext *gb, int **recodes, int *last, int size) 00177 { 00178 int res; 00179 HuffContext huff; 00180 HuffContext tmp1, tmp2; 00181 VLC vlc[2]; 00182 int escapes[3]; 00183 DBCtx ctx; 00184 00185 if(size >= UINT_MAX>>4){ // (((size + 3) >> 2) + 3) << 2 must not overflow 00186 av_log(smk->avctx, AV_LOG_ERROR, "size too large\n"); 00187 return -1; 00188 } 00189 00190 tmp1.length = 256; 00191 tmp1.maxlength = 0; 00192 tmp1.current = 0; 00193 tmp1.bits = av_mallocz(256 * 4); 00194 tmp1.lengths = av_mallocz(256 * sizeof(int)); 00195 tmp1.values = av_mallocz(256 * sizeof(int)); 00196 00197 tmp2.length = 256; 00198 tmp2.maxlength = 0; 00199 tmp2.current = 0; 00200 tmp2.bits = av_mallocz(256 * 4); 00201 tmp2.lengths = av_mallocz(256 * sizeof(int)); 00202 tmp2.values = av_mallocz(256 * sizeof(int)); 00203 00204 memset(&vlc[0], 0, sizeof(VLC)); 00205 memset(&vlc[1], 0, sizeof(VLC)); 00206 00207 if(get_bits1(gb)) { 00208 smacker_decode_tree(gb, &tmp1, 0, 0); 00209 skip_bits1(gb); 00210 res = init_vlc(&vlc[0], SMKTREE_BITS, tmp1.length, 00211 tmp1.lengths, sizeof(int), sizeof(int), 00212 tmp1.bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE); 00213 if(res < 0) { 00214 av_log(smk->avctx, AV_LOG_ERROR, "Cannot build VLC table\n"); 00215 return -1; 00216 } 00217 } else { 00218 av_log(smk->avctx, AV_LOG_ERROR, "Skipping low bytes tree\n"); 00219 } 00220 if(get_bits1(gb)){ 00221 smacker_decode_tree(gb, &tmp2, 0, 0); 00222 skip_bits1(gb); 00223 res = init_vlc(&vlc[1], SMKTREE_BITS, tmp2.length, 00224 tmp2.lengths, sizeof(int), sizeof(int), 00225 tmp2.bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE); 00226 if(res < 0) { 00227 av_log(smk->avctx, AV_LOG_ERROR, "Cannot build VLC table\n"); 00228 return -1; 00229 } 00230 } else { 00231 av_log(smk->avctx, AV_LOG_ERROR, "Skipping high bytes tree\n"); 00232 } 00233 00234 escapes[0] = get_bits(gb, 8); 00235 escapes[0] |= get_bits(gb, 8) << 8; 00236 escapes[1] = get_bits(gb, 8); 00237 escapes[1] |= get_bits(gb, 8) << 8; 00238 escapes[2] = get_bits(gb, 8); 00239 escapes[2] |= get_bits(gb, 8) << 8; 00240 00241 last[0] = last[1] = last[2] = -1; 00242 00243 ctx.escapes[0] = escapes[0]; 00244 ctx.escapes[1] = escapes[1]; 00245 ctx.escapes[2] = escapes[2]; 00246 ctx.v1 = &vlc[0]; 00247 ctx.v2 = &vlc[1]; 00248 ctx.recode1 = tmp1.values; 00249 ctx.recode2 = tmp2.values; 00250 ctx.last = last; 00251 00252 huff.length = ((size + 3) >> 2) + 3; 00253 huff.maxlength = 0; 00254 huff.current = 0; 00255 huff.values = av_mallocz(huff.length * sizeof(int)); 00256 00257 smacker_decode_bigtree(gb, &huff, &ctx); 00258 skip_bits1(gb); 00259 if(ctx.last[0] == -1) ctx.last[0] = huff.current++; 00260 if(ctx.last[1] == -1) ctx.last[1] = huff.current++; 00261 if(ctx.last[2] == -1) ctx.last[2] = huff.current++; 00262 00263 *recodes = huff.values; 00264 00265 if(vlc[0].table) 00266 free_vlc(&vlc[0]); 00267 if(vlc[1].table) 00268 free_vlc(&vlc[1]); 00269 av_free(tmp1.bits); 00270 av_free(tmp1.lengths); 00271 av_free(tmp1.values); 00272 av_free(tmp2.bits); 00273 av_free(tmp2.lengths); 00274 av_free(tmp2.values); 00275 00276 return 0; 00277 } 00278 00279 static int decode_header_trees(SmackVContext *smk) { 00280 GetBitContext gb; 00281 int mmap_size, mclr_size, full_size, type_size; 00282 00283 mmap_size = AV_RL32(smk->avctx->extradata); 00284 mclr_size = AV_RL32(smk->avctx->extradata + 4); 00285 full_size = AV_RL32(smk->avctx->extradata + 8); 00286 type_size = AV_RL32(smk->avctx->extradata + 12); 00287 00288 init_get_bits(&gb, smk->avctx->extradata + 16, (smk->avctx->extradata_size - 16) * 8); 00289 00290 if(!get_bits1(&gb)) { 00291 av_log(smk->avctx, AV_LOG_INFO, "Skipping MMAP tree\n"); 00292 smk->mmap_tbl = av_malloc(sizeof(int) * 2); 00293 smk->mmap_tbl[0] = 0; 00294 smk->mmap_last[0] = smk->mmap_last[1] = smk->mmap_last[2] = 1; 00295 } else { 00296 if (smacker_decode_header_tree(smk, &gb, &smk->mmap_tbl, smk->mmap_last, mmap_size)) 00297 return -1; 00298 } 00299 if(!get_bits1(&gb)) { 00300 av_log(smk->avctx, AV_LOG_INFO, "Skipping MCLR tree\n"); 00301 smk->mclr_tbl = av_malloc(sizeof(int) * 2); 00302 smk->mclr_tbl[0] = 0; 00303 smk->mclr_last[0] = smk->mclr_last[1] = smk->mclr_last[2] = 1; 00304 } else { 00305 if (smacker_decode_header_tree(smk, &gb, &smk->mclr_tbl, smk->mclr_last, mclr_size)) 00306 return -1; 00307 } 00308 if(!get_bits1(&gb)) { 00309 av_log(smk->avctx, AV_LOG_INFO, "Skipping FULL tree\n"); 00310 smk->full_tbl = av_malloc(sizeof(int) * 2); 00311 smk->full_tbl[0] = 0; 00312 smk->full_last[0] = smk->full_last[1] = smk->full_last[2] = 1; 00313 } else { 00314 if (smacker_decode_header_tree(smk, &gb, &smk->full_tbl, smk->full_last, full_size)) 00315 return -1; 00316 } 00317 if(!get_bits1(&gb)) { 00318 av_log(smk->avctx, AV_LOG_INFO, "Skipping TYPE tree\n"); 00319 smk->type_tbl = av_malloc(sizeof(int) * 2); 00320 smk->type_tbl[0] = 0; 00321 smk->type_last[0] = smk->type_last[1] = smk->type_last[2] = 1; 00322 } else { 00323 if (smacker_decode_header_tree(smk, &gb, &smk->type_tbl, smk->type_last, type_size)) 00324 return -1; 00325 } 00326 00327 return 0; 00328 } 00329 00330 static av_always_inline void last_reset(int *recode, int *last) { 00331 recode[last[0]] = recode[last[1]] = recode[last[2]] = 0; 00332 } 00333 00334 /* get code and update history */ 00335 static av_always_inline int smk_get_code(GetBitContext *gb, int *recode, int *last) { 00336 register int *table = recode; 00337 int v, b; 00338 00339 b = get_bits_count(gb); 00340 while(*table & SMK_NODE) { 00341 if(get_bits1(gb)) 00342 table += (*table) & (~SMK_NODE); 00343 table++; 00344 } 00345 v = *table; 00346 b = get_bits_count(gb) - b; 00347 00348 if(v != recode[last[0]]) { 00349 recode[last[2]] = recode[last[1]]; 00350 recode[last[1]] = recode[last[0]]; 00351 recode[last[0]] = v; 00352 } 00353 return v; 00354 } 00355 00356 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt) 00357 { 00358 const uint8_t *buf = avpkt->data; 00359 int buf_size = avpkt->size; 00360 SmackVContext * const smk = avctx->priv_data; 00361 uint8_t *out; 00362 uint32_t *pal; 00363 GetBitContext gb; 00364 int blocks, blk, bw, bh; 00365 int i; 00366 int stride; 00367 00368 if(buf_size <= 769) 00369 return 0; 00370 00371 smk->pic.reference = 3; 00372 smk->pic.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE; 00373 if(avctx->reget_buffer(avctx, &smk->pic) < 0){ 00374 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); 00375 return -1; 00376 } 00377 00378 /* make the palette available on the way out */ 00379 pal = (uint32_t*)smk->pic.data[1]; 00380 smk->pic.palette_has_changed = buf[0] & 1; 00381 smk->pic.key_frame = !!(buf[0] & 2); 00382 if(smk->pic.key_frame) 00383 smk->pic.pict_type = AV_PICTURE_TYPE_I; 00384 else 00385 smk->pic.pict_type = AV_PICTURE_TYPE_P; 00386 00387 buf++; 00388 for(i = 0; i < 256; i++) 00389 *pal++ = 0xFF << 24 | bytestream_get_be24(&buf); 00390 buf_size -= 769; 00391 00392 last_reset(smk->mmap_tbl, smk->mmap_last); 00393 last_reset(smk->mclr_tbl, smk->mclr_last); 00394 last_reset(smk->full_tbl, smk->full_last); 00395 last_reset(smk->type_tbl, smk->type_last); 00396 init_get_bits(&gb, buf, buf_size * 8); 00397 00398 blk = 0; 00399 bw = avctx->width >> 2; 00400 bh = avctx->height >> 2; 00401 blocks = bw * bh; 00402 out = smk->pic.data[0]; 00403 stride = smk->pic.linesize[0]; 00404 while(blk < blocks) { 00405 int type, run, mode; 00406 uint16_t pix; 00407 00408 type = smk_get_code(&gb, smk->type_tbl, smk->type_last); 00409 run = block_runs[(type >> 2) & 0x3F]; 00410 switch(type & 3){ 00411 case SMK_BLK_MONO: 00412 while(run-- && blk < blocks){ 00413 int clr, map; 00414 int hi, lo; 00415 clr = smk_get_code(&gb, smk->mclr_tbl, smk->mclr_last); 00416 map = smk_get_code(&gb, smk->mmap_tbl, smk->mmap_last); 00417 out = smk->pic.data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4; 00418 hi = clr >> 8; 00419 lo = clr & 0xFF; 00420 for(i = 0; i < 4; i++) { 00421 if(map & 1) out[0] = hi; else out[0] = lo; 00422 if(map & 2) out[1] = hi; else out[1] = lo; 00423 if(map & 4) out[2] = hi; else out[2] = lo; 00424 if(map & 8) out[3] = hi; else out[3] = lo; 00425 map >>= 4; 00426 out += stride; 00427 } 00428 blk++; 00429 } 00430 break; 00431 case SMK_BLK_FULL: 00432 mode = 0; 00433 if(avctx->codec_tag == MKTAG('S', 'M', 'K', '4')) { // In case of Smacker v4 we have three modes 00434 if(get_bits1(&gb)) mode = 1; 00435 else if(get_bits1(&gb)) mode = 2; 00436 } 00437 while(run-- && blk < blocks){ 00438 out = smk->pic.data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4; 00439 switch(mode){ 00440 case 0: 00441 for(i = 0; i < 4; i++) { 00442 pix = smk_get_code(&gb, smk->full_tbl, smk->full_last); 00443 AV_WL16(out+2,pix); 00444 pix = smk_get_code(&gb, smk->full_tbl, smk->full_last); 00445 AV_WL16(out,pix); 00446 out += stride; 00447 } 00448 break; 00449 case 1: 00450 pix = smk_get_code(&gb, smk->full_tbl, smk->full_last); 00451 out[0] = out[1] = pix & 0xFF; 00452 out[2] = out[3] = pix >> 8; 00453 out += stride; 00454 out[0] = out[1] = pix & 0xFF; 00455 out[2] = out[3] = pix >> 8; 00456 out += stride; 00457 pix = smk_get_code(&gb, smk->full_tbl, smk->full_last); 00458 out[0] = out[1] = pix & 0xFF; 00459 out[2] = out[3] = pix >> 8; 00460 out += stride; 00461 out[0] = out[1] = pix & 0xFF; 00462 out[2] = out[3] = pix >> 8; 00463 out += stride; 00464 break; 00465 case 2: 00466 for(i = 0; i < 2; i++) { 00467 uint16_t pix1, pix2; 00468 pix2 = smk_get_code(&gb, smk->full_tbl, smk->full_last); 00469 pix1 = smk_get_code(&gb, smk->full_tbl, smk->full_last); 00470 AV_WL16(out,pix1); 00471 AV_WL16(out+2,pix2); 00472 out += stride; 00473 AV_WL16(out,pix1); 00474 AV_WL16(out+2,pix2); 00475 out += stride; 00476 } 00477 break; 00478 } 00479 blk++; 00480 } 00481 break; 00482 case SMK_BLK_SKIP: 00483 while(run-- && blk < blocks) 00484 blk++; 00485 break; 00486 case SMK_BLK_FILL: 00487 mode = type >> 8; 00488 while(run-- && blk < blocks){ 00489 uint32_t col; 00490 out = smk->pic.data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4; 00491 col = mode * 0x01010101; 00492 for(i = 0; i < 4; i++) { 00493 *((uint32_t*)out) = col; 00494 out += stride; 00495 } 00496 blk++; 00497 } 00498 break; 00499 } 00500 00501 } 00502 00503 *data_size = sizeof(AVFrame); 00504 *(AVFrame*)data = smk->pic; 00505 00506 /* always report that the buffer was completely consumed */ 00507 return buf_size; 00508 } 00509 00510 00511 00512 /* 00513 * 00514 * Init smacker decoder 00515 * 00516 */ 00517 static av_cold int decode_init(AVCodecContext *avctx) 00518 { 00519 SmackVContext * const c = avctx->priv_data; 00520 00521 c->avctx = avctx; 00522 00523 avctx->pix_fmt = PIX_FMT_PAL8; 00524 00525 avcodec_get_frame_defaults(&c->pic); 00526 00527 /* decode huffman trees from extradata */ 00528 if(avctx->extradata_size < 16){ 00529 av_log(avctx, AV_LOG_ERROR, "Extradata missing!\n"); 00530 return -1; 00531 } 00532 00533 if (decode_header_trees(c)) 00534 return -1; 00535 00536 return 0; 00537 } 00538 00539 00540 00541 /* 00542 * 00543 * Uninit smacker decoder 00544 * 00545 */ 00546 static av_cold int decode_end(AVCodecContext *avctx) 00547 { 00548 SmackVContext * const smk = avctx->priv_data; 00549 00550 av_freep(&smk->mmap_tbl); 00551 av_freep(&smk->mclr_tbl); 00552 av_freep(&smk->full_tbl); 00553 av_freep(&smk->type_tbl); 00554 00555 if (smk->pic.data[0]) 00556 avctx->release_buffer(avctx, &smk->pic); 00557 00558 return 0; 00559 } 00560 00561 00562 typedef struct SmackerAudioContext { 00563 AVFrame frame; 00564 } SmackerAudioContext; 00565 00566 static av_cold int smka_decode_init(AVCodecContext *avctx) 00567 { 00568 SmackerAudioContext *s = avctx->priv_data; 00569 00570 if (avctx->channels < 1 || avctx->channels > 2) { 00571 av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n"); 00572 return AVERROR(EINVAL); 00573 } 00574 avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO; 00575 avctx->sample_fmt = avctx->bits_per_coded_sample == 8 ? AV_SAMPLE_FMT_U8 : AV_SAMPLE_FMT_S16; 00576 00577 avcodec_get_frame_defaults(&s->frame); 00578 avctx->coded_frame = &s->frame; 00579 00580 return 0; 00581 } 00582 00586 static int smka_decode_frame(AVCodecContext *avctx, void *data, 00587 int *got_frame_ptr, AVPacket *avpkt) 00588 { 00589 SmackerAudioContext *s = avctx->priv_data; 00590 const uint8_t *buf = avpkt->data; 00591 int buf_size = avpkt->size; 00592 GetBitContext gb; 00593 HuffContext h[4]; 00594 VLC vlc[4]; 00595 int16_t *samples; 00596 uint8_t *samples8; 00597 int val; 00598 int i, res, ret; 00599 int unp_size; 00600 int bits, stereo; 00601 int pred[2] = {0, 0}; 00602 00603 if (buf_size <= 4) { 00604 av_log(avctx, AV_LOG_ERROR, "packet is too small\n"); 00605 return AVERROR(EINVAL); 00606 } 00607 00608 unp_size = AV_RL32(buf); 00609 00610 init_get_bits(&gb, buf + 4, (buf_size - 4) * 8); 00611 00612 if(!get_bits1(&gb)){ 00613 av_log(avctx, AV_LOG_INFO, "Sound: no data\n"); 00614 *got_frame_ptr = 0; 00615 return 1; 00616 } 00617 stereo = get_bits1(&gb); 00618 bits = get_bits1(&gb); 00619 if (stereo ^ (avctx->channels != 1)) { 00620 av_log(avctx, AV_LOG_ERROR, "channels mismatch\n"); 00621 return AVERROR(EINVAL); 00622 } 00623 if (bits && avctx->sample_fmt == AV_SAMPLE_FMT_U8) { 00624 av_log(avctx, AV_LOG_ERROR, "sample format mismatch\n"); 00625 return AVERROR(EINVAL); 00626 } 00627 00628 /* get output buffer */ 00629 s->frame.nb_samples = unp_size / (avctx->channels * (bits + 1)); 00630 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) { 00631 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); 00632 return ret; 00633 } 00634 samples = (int16_t *)s->frame.data[0]; 00635 samples8 = s->frame.data[0]; 00636 00637 memset(vlc, 0, sizeof(VLC) * 4); 00638 memset(h, 0, sizeof(HuffContext) * 4); 00639 // Initialize 00640 for(i = 0; i < (1 << (bits + stereo)); i++) { 00641 h[i].length = 256; 00642 h[i].maxlength = 0; 00643 h[i].current = 0; 00644 h[i].bits = av_mallocz(256 * 4); 00645 h[i].lengths = av_mallocz(256 * sizeof(int)); 00646 h[i].values = av_mallocz(256 * sizeof(int)); 00647 skip_bits1(&gb); 00648 smacker_decode_tree(&gb, &h[i], 0, 0); 00649 skip_bits1(&gb); 00650 if(h[i].current > 1) { 00651 res = init_vlc(&vlc[i], SMKTREE_BITS, h[i].length, 00652 h[i].lengths, sizeof(int), sizeof(int), 00653 h[i].bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE); 00654 if(res < 0) { 00655 av_log(avctx, AV_LOG_ERROR, "Cannot build VLC table\n"); 00656 return -1; 00657 } 00658 } 00659 } 00660 if(bits) { //decode 16-bit data 00661 for(i = stereo; i >= 0; i--) 00662 pred[i] = sign_extend(av_bswap16(get_bits(&gb, 16)), 16); 00663 for(i = 0; i <= stereo; i++) 00664 *samples++ = pred[i]; 00665 for(; i < unp_size / 2; i++) { 00666 if(get_bits_left(&gb)<0) 00667 return -1; 00668 if(i & stereo) { 00669 if(vlc[2].table) 00670 res = get_vlc2(&gb, vlc[2].table, SMKTREE_BITS, 3); 00671 else 00672 res = 0; 00673 val = h[2].values[res]; 00674 if(vlc[3].table) 00675 res = get_vlc2(&gb, vlc[3].table, SMKTREE_BITS, 3); 00676 else 00677 res = 0; 00678 val |= h[3].values[res] << 8; 00679 pred[1] += sign_extend(val, 16); 00680 *samples++ = av_clip_int16(pred[1]); 00681 } else { 00682 if(vlc[0].table) 00683 res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3); 00684 else 00685 res = 0; 00686 val = h[0].values[res]; 00687 if(vlc[1].table) 00688 res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3); 00689 else 00690 res = 0; 00691 val |= h[1].values[res] << 8; 00692 pred[0] += sign_extend(val, 16); 00693 *samples++ = av_clip_int16(pred[0]); 00694 } 00695 } 00696 } else { //8-bit data 00697 for(i = stereo; i >= 0; i--) 00698 pred[i] = get_bits(&gb, 8); 00699 for(i = 0; i <= stereo; i++) 00700 *samples8++ = pred[i]; 00701 for(; i < unp_size; i++) { 00702 if(get_bits_left(&gb)<0) 00703 return -1; 00704 if(i & stereo){ 00705 if(vlc[1].table) 00706 res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3); 00707 else 00708 res = 0; 00709 pred[1] += sign_extend(h[1].values[res], 8); 00710 *samples8++ = av_clip_uint8(pred[1]); 00711 } else { 00712 if(vlc[0].table) 00713 res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3); 00714 else 00715 res = 0; 00716 pred[0] += sign_extend(h[0].values[res], 8); 00717 *samples8++ = av_clip_uint8(pred[0]); 00718 } 00719 } 00720 } 00721 00722 for(i = 0; i < 4; i++) { 00723 if(vlc[i].table) 00724 free_vlc(&vlc[i]); 00725 av_free(h[i].bits); 00726 av_free(h[i].lengths); 00727 av_free(h[i].values); 00728 } 00729 00730 *got_frame_ptr = 1; 00731 *(AVFrame *)data = s->frame; 00732 00733 return buf_size; 00734 } 00735 00736 AVCodec ff_smacker_decoder = { 00737 .name = "smackvid", 00738 .type = AVMEDIA_TYPE_VIDEO, 00739 .id = CODEC_ID_SMACKVIDEO, 00740 .priv_data_size = sizeof(SmackVContext), 00741 .init = decode_init, 00742 .close = decode_end, 00743 .decode = decode_frame, 00744 .capabilities = CODEC_CAP_DR1, 00745 .long_name = NULL_IF_CONFIG_SMALL("Smacker video"), 00746 }; 00747 00748 AVCodec ff_smackaud_decoder = { 00749 .name = "smackaud", 00750 .type = AVMEDIA_TYPE_AUDIO, 00751 .id = CODEC_ID_SMACKAUDIO, 00752 .priv_data_size = sizeof(SmackerAudioContext), 00753 .init = smka_decode_init, 00754 .decode = smka_decode_frame, 00755 .capabilities = CODEC_CAP_DR1, 00756 .long_name = NULL_IF_CONFIG_SMALL("Smacker audio"), 00757 }; 00758