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