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 = ctx->v1->table ? get_vlc2(gb, ctx->v1->table, SMKTREE_BITS, 3) : 0; 00137 b1 = get_bits_count(gb) - b1; 00138 b2 = get_bits_count(gb); 00139 i2 = ctx->v2->table ? get_vlc2(gb, ctx->v2->table, SMKTREE_BITS, 3) : 0; 00140 b2 = get_bits_count(gb) - b2; 00141 if (i1 < 0 || i2 < 0) 00142 return -1; 00143 val = ctx->recode1[i1] | (ctx->recode2[i2] << 8); 00144 if(val == ctx->escapes[0]) { 00145 ctx->last[0] = hc->current; 00146 val = 0; 00147 } else if(val == ctx->escapes[1]) { 00148 ctx->last[1] = hc->current; 00149 val = 0; 00150 } else if(val == ctx->escapes[2]) { 00151 ctx->last[2] = hc->current; 00152 val = 0; 00153 } 00154 00155 hc->values[hc->current++] = val; 00156 return 1; 00157 } else { //Node 00158 int r = 0, t; 00159 00160 t = hc->current++; 00161 r = smacker_decode_bigtree(gb, hc, ctx); 00162 if(r < 0) 00163 return r; 00164 hc->values[t] = SMK_NODE | r; 00165 r++; 00166 r += smacker_decode_bigtree(gb, hc, ctx); 00167 return r; 00168 } 00169 } 00170 00174 static int smacker_decode_header_tree(SmackVContext *smk, GetBitContext *gb, int **recodes, int *last, int size) 00175 { 00176 int res; 00177 HuffContext huff; 00178 HuffContext tmp1, tmp2; 00179 VLC vlc[2]; 00180 int escapes[3]; 00181 DBCtx ctx; 00182 00183 if(size >= UINT_MAX>>4){ // (((size + 3) >> 2) + 3) << 2 must not overflow 00184 av_log(smk->avctx, AV_LOG_ERROR, "size too large\n"); 00185 return -1; 00186 } 00187 00188 tmp1.length = 256; 00189 tmp1.maxlength = 0; 00190 tmp1.current = 0; 00191 tmp1.bits = av_mallocz(256 * 4); 00192 tmp1.lengths = av_mallocz(256 * sizeof(int)); 00193 tmp1.values = av_mallocz(256 * sizeof(int)); 00194 00195 tmp2.length = 256; 00196 tmp2.maxlength = 0; 00197 tmp2.current = 0; 00198 tmp2.bits = av_mallocz(256 * 4); 00199 tmp2.lengths = av_mallocz(256 * sizeof(int)); 00200 tmp2.values = av_mallocz(256 * sizeof(int)); 00201 00202 memset(&vlc[0], 0, sizeof(VLC)); 00203 memset(&vlc[1], 0, sizeof(VLC)); 00204 00205 if(get_bits1(gb)) { 00206 smacker_decode_tree(gb, &tmp1, 0, 0); 00207 skip_bits1(gb); 00208 res = init_vlc(&vlc[0], SMKTREE_BITS, tmp1.length, 00209 tmp1.lengths, sizeof(int), sizeof(int), 00210 tmp1.bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE); 00211 if(res < 0) { 00212 av_log(smk->avctx, AV_LOG_ERROR, "Cannot build VLC table\n"); 00213 return -1; 00214 } 00215 } else { 00216 av_log(smk->avctx, AV_LOG_ERROR, "Skipping low bytes tree\n"); 00217 } 00218 if(get_bits1(gb)){ 00219 smacker_decode_tree(gb, &tmp2, 0, 0); 00220 skip_bits1(gb); 00221 res = init_vlc(&vlc[1], SMKTREE_BITS, tmp2.length, 00222 tmp2.lengths, sizeof(int), sizeof(int), 00223 tmp2.bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE); 00224 if(res < 0) { 00225 av_log(smk->avctx, AV_LOG_ERROR, "Cannot build VLC table\n"); 00226 return -1; 00227 } 00228 } else { 00229 av_log(smk->avctx, AV_LOG_ERROR, "Skipping high bytes tree\n"); 00230 } 00231 00232 escapes[0] = get_bits(gb, 8); 00233 escapes[0] |= get_bits(gb, 8) << 8; 00234 escapes[1] = get_bits(gb, 8); 00235 escapes[1] |= get_bits(gb, 8) << 8; 00236 escapes[2] = get_bits(gb, 8); 00237 escapes[2] |= get_bits(gb, 8) << 8; 00238 00239 last[0] = last[1] = last[2] = -1; 00240 00241 ctx.escapes[0] = escapes[0]; 00242 ctx.escapes[1] = escapes[1]; 00243 ctx.escapes[2] = escapes[2]; 00244 ctx.v1 = &vlc[0]; 00245 ctx.v2 = &vlc[1]; 00246 ctx.recode1 = tmp1.values; 00247 ctx.recode2 = tmp2.values; 00248 ctx.last = last; 00249 00250 huff.length = ((size + 3) >> 2) + 3; 00251 huff.maxlength = 0; 00252 huff.current = 0; 00253 huff.values = av_mallocz(huff.length * sizeof(int)); 00254 00255 smacker_decode_bigtree(gb, &huff, &ctx); 00256 skip_bits1(gb); 00257 if(ctx.last[0] == -1) ctx.last[0] = huff.current++; 00258 if(ctx.last[1] == -1) ctx.last[1] = huff.current++; 00259 if(ctx.last[2] == -1) ctx.last[2] = huff.current++; 00260 00261 *recodes = huff.values; 00262 00263 if(vlc[0].table) 00264 free_vlc(&vlc[0]); 00265 if(vlc[1].table) 00266 free_vlc(&vlc[1]); 00267 av_free(tmp1.bits); 00268 av_free(tmp1.lengths); 00269 av_free(tmp1.values); 00270 av_free(tmp2.bits); 00271 av_free(tmp2.lengths); 00272 av_free(tmp2.values); 00273 00274 return 0; 00275 } 00276 00277 static int decode_header_trees(SmackVContext *smk) { 00278 GetBitContext gb; 00279 int mmap_size, mclr_size, full_size, type_size; 00280 00281 mmap_size = AV_RL32(smk->avctx->extradata); 00282 mclr_size = AV_RL32(smk->avctx->extradata + 4); 00283 full_size = AV_RL32(smk->avctx->extradata + 8); 00284 type_size = AV_RL32(smk->avctx->extradata + 12); 00285 00286 init_get_bits(&gb, smk->avctx->extradata + 16, (smk->avctx->extradata_size - 16) * 8); 00287 00288 if(!get_bits1(&gb)) { 00289 av_log(smk->avctx, AV_LOG_INFO, "Skipping MMAP tree\n"); 00290 smk->mmap_tbl = av_malloc(sizeof(int) * 2); 00291 smk->mmap_tbl[0] = 0; 00292 smk->mmap_last[0] = smk->mmap_last[1] = smk->mmap_last[2] = 1; 00293 } else { 00294 if (smacker_decode_header_tree(smk, &gb, &smk->mmap_tbl, smk->mmap_last, mmap_size)) 00295 return -1; 00296 } 00297 if(!get_bits1(&gb)) { 00298 av_log(smk->avctx, AV_LOG_INFO, "Skipping MCLR tree\n"); 00299 smk->mclr_tbl = av_malloc(sizeof(int) * 2); 00300 smk->mclr_tbl[0] = 0; 00301 smk->mclr_last[0] = smk->mclr_last[1] = smk->mclr_last[2] = 1; 00302 } else { 00303 if (smacker_decode_header_tree(smk, &gb, &smk->mclr_tbl, smk->mclr_last, mclr_size)) 00304 return -1; 00305 } 00306 if(!get_bits1(&gb)) { 00307 av_log(smk->avctx, AV_LOG_INFO, "Skipping FULL tree\n"); 00308 smk->full_tbl = av_malloc(sizeof(int) * 2); 00309 smk->full_tbl[0] = 0; 00310 smk->full_last[0] = smk->full_last[1] = smk->full_last[2] = 1; 00311 } else { 00312 if (smacker_decode_header_tree(smk, &gb, &smk->full_tbl, smk->full_last, full_size)) 00313 return -1; 00314 } 00315 if(!get_bits1(&gb)) { 00316 av_log(smk->avctx, AV_LOG_INFO, "Skipping TYPE tree\n"); 00317 smk->type_tbl = av_malloc(sizeof(int) * 2); 00318 smk->type_tbl[0] = 0; 00319 smk->type_last[0] = smk->type_last[1] = smk->type_last[2] = 1; 00320 } else { 00321 if (smacker_decode_header_tree(smk, &gb, &smk->type_tbl, smk->type_last, type_size)) 00322 return -1; 00323 } 00324 00325 return 0; 00326 } 00327 00328 static av_always_inline void last_reset(int *recode, int *last) { 00329 recode[last[0]] = recode[last[1]] = recode[last[2]] = 0; 00330 } 00331 00332 /* get code and update history */ 00333 static av_always_inline int smk_get_code(GetBitContext *gb, int *recode, int *last) { 00334 register int *table = recode; 00335 int v, b; 00336 00337 b = get_bits_count(gb); 00338 while(*table & SMK_NODE) { 00339 if(get_bits1(gb)) 00340 table += (*table) & (~SMK_NODE); 00341 table++; 00342 } 00343 v = *table; 00344 b = get_bits_count(gb) - b; 00345 00346 if(v != recode[last[0]]) { 00347 recode[last[2]] = recode[last[1]]; 00348 recode[last[1]] = recode[last[0]]; 00349 recode[last[0]] = v; 00350 } 00351 return v; 00352 } 00353 00354 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt) 00355 { 00356 const uint8_t *buf = avpkt->data; 00357 int buf_size = avpkt->size; 00358 SmackVContext * const smk = avctx->priv_data; 00359 uint8_t *out; 00360 uint32_t *pal; 00361 GetBitContext gb; 00362 int blocks, blk, bw, bh; 00363 int i; 00364 int stride; 00365 00366 if(buf_size <= 769) 00367 return 0; 00368 if(smk->pic.data[0]) 00369 avctx->release_buffer(avctx, &smk->pic); 00370 00371 smk->pic.reference = 1; 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 = FF_I_TYPE; 00384 else 00385 smk->pic.pict_type = FF_P_TYPE; 00386 00387 buf++; 00388 for(i = 0; i < 256; i++) 00389 *pal++ = 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 00526 /* decode huffman trees from extradata */ 00527 if(avctx->extradata_size < 16){ 00528 av_log(avctx, AV_LOG_ERROR, "Extradata missing!\n"); 00529 return -1; 00530 } 00531 00532 if (decode_header_trees(c)) 00533 return -1; 00534 00535 return 0; 00536 } 00537 00538 00539 00540 /* 00541 * 00542 * Uninit smacker decoder 00543 * 00544 */ 00545 static av_cold int decode_end(AVCodecContext *avctx) 00546 { 00547 SmackVContext * const smk = avctx->priv_data; 00548 00549 av_freep(&smk->mmap_tbl); 00550 av_freep(&smk->mclr_tbl); 00551 av_freep(&smk->full_tbl); 00552 av_freep(&smk->type_tbl); 00553 00554 if (smk->pic.data[0]) 00555 avctx->release_buffer(avctx, &smk->pic); 00556 00557 return 0; 00558 } 00559 00560 00561 static av_cold int smka_decode_init(AVCodecContext *avctx) 00562 { 00563 avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO; 00564 avctx->sample_fmt = avctx->bits_per_coded_sample == 8 ? SAMPLE_FMT_U8 : SAMPLE_FMT_S16; 00565 return 0; 00566 } 00567 00571 static int smka_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt) 00572 { 00573 const uint8_t *buf = avpkt->data; 00574 int buf_size = avpkt->size; 00575 GetBitContext gb; 00576 HuffContext h[4]; 00577 VLC vlc[4]; 00578 int16_t *samples = data; 00579 int8_t *samples8 = data; 00580 int val; 00581 int i, res; 00582 int unp_size; 00583 int bits, stereo; 00584 int pred[2] = {0, 0}; 00585 00586 unp_size = AV_RL32(buf); 00587 00588 init_get_bits(&gb, buf + 4, (buf_size - 4) * 8); 00589 00590 if(!get_bits1(&gb)){ 00591 av_log(avctx, AV_LOG_INFO, "Sound: no data\n"); 00592 *data_size = 0; 00593 return 1; 00594 } 00595 stereo = get_bits1(&gb); 00596 bits = get_bits1(&gb); 00597 if (unp_size & 0xC0000000 || unp_size > *data_size) { 00598 av_log(avctx, AV_LOG_ERROR, "Frame is too large to fit in buffer\n"); 00599 return -1; 00600 } 00601 00602 memset(vlc, 0, sizeof(VLC) * 4); 00603 memset(h, 0, sizeof(HuffContext) * 4); 00604 // Initialize 00605 for(i = 0; i < (1 << (bits + stereo)); i++) { 00606 h[i].length = 256; 00607 h[i].maxlength = 0; 00608 h[i].current = 0; 00609 h[i].bits = av_mallocz(256 * 4); 00610 h[i].lengths = av_mallocz(256 * sizeof(int)); 00611 h[i].values = av_mallocz(256 * sizeof(int)); 00612 skip_bits1(&gb); 00613 smacker_decode_tree(&gb, &h[i], 0, 0); 00614 skip_bits1(&gb); 00615 if(h[i].current > 1) { 00616 res = init_vlc(&vlc[i], SMKTREE_BITS, h[i].length, 00617 h[i].lengths, sizeof(int), sizeof(int), 00618 h[i].bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE); 00619 if(res < 0) { 00620 av_log(avctx, AV_LOG_ERROR, "Cannot build VLC table\n"); 00621 return -1; 00622 } 00623 } 00624 } 00625 if(bits) { //decode 16-bit data 00626 for(i = stereo; i >= 0; i--) 00627 pred[i] = bswap_16(get_bits(&gb, 16)); 00628 for(i = 0; i <= stereo; i++) 00629 *samples++ = pred[i]; 00630 for(; i < unp_size / 2; i++) { 00631 if(i & stereo) { 00632 if(vlc[2].table) 00633 res = get_vlc2(&gb, vlc[2].table, SMKTREE_BITS, 3); 00634 else 00635 res = 0; 00636 val = h[2].values[res]; 00637 if(vlc[3].table) 00638 res = get_vlc2(&gb, vlc[3].table, SMKTREE_BITS, 3); 00639 else 00640 res = 0; 00641 val |= h[3].values[res] << 8; 00642 pred[1] += (int16_t)val; 00643 *samples++ = pred[1]; 00644 } else { 00645 if(vlc[0].table) 00646 res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3); 00647 else 00648 res = 0; 00649 val = h[0].values[res]; 00650 if(vlc[1].table) 00651 res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3); 00652 else 00653 res = 0; 00654 val |= h[1].values[res] << 8; 00655 pred[0] += val; 00656 *samples++ = pred[0]; 00657 } 00658 } 00659 } else { //8-bit data 00660 for(i = stereo; i >= 0; i--) 00661 pred[i] = get_bits(&gb, 8); 00662 for(i = 0; i <= stereo; i++) 00663 *samples8++ = pred[i]; 00664 for(; i < unp_size; i++) { 00665 if(i & stereo){ 00666 if(vlc[1].table) 00667 res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3); 00668 else 00669 res = 0; 00670 pred[1] += (int8_t)h[1].values[res]; 00671 *samples8++ = pred[1]; 00672 } else { 00673 if(vlc[0].table) 00674 res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3); 00675 else 00676 res = 0; 00677 pred[0] += (int8_t)h[0].values[res]; 00678 *samples8++ = pred[0]; 00679 } 00680 } 00681 } 00682 00683 for(i = 0; i < 4; i++) { 00684 if(vlc[i].table) 00685 free_vlc(&vlc[i]); 00686 if(h[i].bits) 00687 av_free(h[i].bits); 00688 if(h[i].lengths) 00689 av_free(h[i].lengths); 00690 if(h[i].values) 00691 av_free(h[i].values); 00692 } 00693 00694 *data_size = unp_size; 00695 return buf_size; 00696 } 00697 00698 AVCodec smacker_decoder = { 00699 "smackvid", 00700 AVMEDIA_TYPE_VIDEO, 00701 CODEC_ID_SMACKVIDEO, 00702 sizeof(SmackVContext), 00703 decode_init, 00704 NULL, 00705 decode_end, 00706 decode_frame, 00707 CODEC_CAP_DR1, 00708 .long_name = NULL_IF_CONFIG_SMALL("Smacker video"), 00709 }; 00710 00711 AVCodec smackaud_decoder = { 00712 "smackaud", 00713 AVMEDIA_TYPE_AUDIO, 00714 CODEC_ID_SMACKAUDIO, 00715 0, 00716 smka_decode_init, 00717 NULL, 00718 NULL, 00719 smka_decode_frame, 00720 .long_name = NULL_IF_CONFIG_SMALL("Smacker audio"), 00721 }; 00722