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