00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00027
00028
00029
00030
00031 #include <stdio.h>
00032 #include <stdlib.h>
00033
00034 #include "avcodec.h"
00035
00036 #define ALT_BITSTREAM_READER_LE
00037 #include "bitstream.h"
00038 #include "bytestream.h"
00039
00040 #define SMKTREE_BITS 9
00041 #define SMK_NODE 0x80000000
00042
00043
00044
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
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
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)){
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 {
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)){
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 {
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){
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
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, const uint8_t *buf, int buf_size)
00349 {
00350 SmackVContext * const smk = avctx->priv_data;
00351 uint8_t *out;
00352 uint32_t *pal;
00353 GetBitContext gb;
00354 int blocks, blk, bw, bh;
00355 int i;
00356 int stride;
00357
00358 if(buf_size <= 769)
00359 return 0;
00360 if(smk->pic.data[0])
00361 avctx->release_buffer(avctx, &smk->pic);
00362
00363 smk->pic.reference = 1;
00364 smk->pic.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;
00365 if(avctx->reget_buffer(avctx, &smk->pic) < 0){
00366 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00367 return -1;
00368 }
00369
00370
00371 pal = (uint32_t*)smk->pic.data[1];
00372 smk->pic.palette_has_changed = buf[0] & 1;
00373 smk->pic.key_frame = !!(buf[0] & 2);
00374 if(smk->pic.key_frame)
00375 smk->pic.pict_type = FF_I_TYPE;
00376 else
00377 smk->pic.pict_type = FF_P_TYPE;
00378
00379 buf++;
00380 for(i = 0; i < 256; i++)
00381 *pal++ = bytestream_get_be24(&buf);
00382 buf_size -= 769;
00383
00384 last_reset(smk->mmap_tbl, smk->mmap_last);
00385 last_reset(smk->mclr_tbl, smk->mclr_last);
00386 last_reset(smk->full_tbl, smk->full_last);
00387 last_reset(smk->type_tbl, smk->type_last);
00388 init_get_bits(&gb, buf, buf_size * 8);
00389
00390 blk = 0;
00391 bw = avctx->width >> 2;
00392 bh = avctx->height >> 2;
00393 blocks = bw * bh;
00394 out = smk->pic.data[0];
00395 stride = smk->pic.linesize[0];
00396 while(blk < blocks) {
00397 int type, run, mode;
00398 uint16_t pix;
00399
00400 type = smk_get_code(&gb, smk->type_tbl, smk->type_last);
00401 run = block_runs[(type >> 2) & 0x3F];
00402 switch(type & 3){
00403 case SMK_BLK_MONO:
00404 while(run-- && blk < blocks){
00405 int clr, map;
00406 int hi, lo;
00407 clr = smk_get_code(&gb, smk->mclr_tbl, smk->mclr_last);
00408 map = smk_get_code(&gb, smk->mmap_tbl, smk->mmap_last);
00409 out = smk->pic.data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
00410 hi = clr >> 8;
00411 lo = clr & 0xFF;
00412 for(i = 0; i < 4; i++) {
00413 if(map & 1) out[0] = hi; else out[0] = lo;
00414 if(map & 2) out[1] = hi; else out[1] = lo;
00415 if(map & 4) out[2] = hi; else out[2] = lo;
00416 if(map & 8) out[3] = hi; else out[3] = lo;
00417 map >>= 4;
00418 out += stride;
00419 }
00420 blk++;
00421 }
00422 break;
00423 case SMK_BLK_FULL:
00424 mode = 0;
00425 if(avctx->codec_tag == MKTAG('S', 'M', 'K', '4')) {
00426 if(get_bits1(&gb)) mode = 1;
00427 else if(get_bits1(&gb)) mode = 2;
00428 }
00429 while(run-- && blk < blocks){
00430 out = smk->pic.data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
00431 switch(mode){
00432 case 0:
00433 for(i = 0; i < 4; i++) {
00434 pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00435 AV_WL16(out+2,pix);
00436 pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00437 AV_WL16(out,pix);
00438 out += stride;
00439 }
00440 break;
00441 case 1:
00442 pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00443 out[0] = out[1] = pix & 0xFF;
00444 out[2] = out[3] = pix >> 8;
00445 out += stride;
00446 out[0] = out[1] = pix & 0xFF;
00447 out[2] = out[3] = pix >> 8;
00448 out += stride;
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 break;
00457 case 2:
00458 for(i = 0; i < 2; i++) {
00459 uint16_t pix1, pix2;
00460 pix1 = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00461 pix2 = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00462 AV_WL16(out,pix1);
00463 AV_WL16(out+2,pix2);
00464 out += stride;
00465 AV_WL16(out,pix1);
00466 AV_WL16(out+2,pix2);
00467 out += stride;
00468 }
00469 break;
00470 }
00471 blk++;
00472 }
00473 break;
00474 case SMK_BLK_SKIP:
00475 while(run-- && blk < blocks)
00476 blk++;
00477 break;
00478 case SMK_BLK_FILL:
00479 mode = type >> 8;
00480 while(run-- && blk < blocks){
00481 uint32_t col;
00482 out = smk->pic.data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
00483 col = mode * 0x01010101;
00484 for(i = 0; i < 4; i++) {
00485 *((uint32_t*)out) = col;
00486 out += stride;
00487 }
00488 blk++;
00489 }
00490 break;
00491 }
00492
00493 }
00494
00495 *data_size = sizeof(AVFrame);
00496 *(AVFrame*)data = smk->pic;
00497
00498
00499 return buf_size;
00500 }
00501
00502
00503
00504
00505
00506
00507
00508
00509 static int decode_init(AVCodecContext *avctx)
00510 {
00511 SmackVContext * const c = avctx->priv_data;
00512
00513 c->avctx = avctx;
00514
00515 c->pic.data[0] = NULL;
00516
00517 if (avcodec_check_dimensions(avctx, avctx->width, avctx->height) < 0) {
00518 return 1;
00519 }
00520
00521 avctx->pix_fmt = PIX_FMT_PAL8;
00522
00523
00524
00525 if(avctx->extradata_size < 16){
00526 av_log(avctx, AV_LOG_ERROR, "Extradata missing!\n");
00527 return -1;
00528 }
00529
00530 decode_header_trees(c);
00531
00532
00533 return 0;
00534 }
00535
00536
00537
00538
00539
00540
00541
00542
00543 static int decode_end(AVCodecContext *avctx)
00544 {
00545 SmackVContext * const smk = avctx->priv_data;
00546
00547 av_freep(&smk->mmap_tbl);
00548 av_freep(&smk->mclr_tbl);
00549 av_freep(&smk->full_tbl);
00550 av_freep(&smk->type_tbl);
00551
00552 if (smk->pic.data[0])
00553 avctx->release_buffer(avctx, &smk->pic);
00554
00555 return 0;
00556 }
00557
00558
00559 static int smka_decode_init(AVCodecContext *avctx)
00560 {
00561 return 0;
00562 }
00563
00567 static int smka_decode_frame(AVCodecContext *avctx, void *data, int *data_size, const uint8_t *buf, int buf_size)
00568 {
00569 GetBitContext gb;
00570 HuffContext h[4];
00571 VLC vlc[4];
00572 int16_t *samples = data;
00573 int val;
00574 int i, res;
00575 int unp_size;
00576 int bits, stereo;
00577 int pred[2] = {0, 0};
00578
00579 unp_size = AV_RL32(buf);
00580
00581 init_get_bits(&gb, buf + 4, (buf_size - 4) * 8);
00582
00583 if(!get_bits1(&gb)){
00584 av_log(avctx, AV_LOG_INFO, "Sound: no data\n");
00585 *data_size = 0;
00586 return 1;
00587 }
00588 stereo = get_bits1(&gb);
00589 bits = get_bits1(&gb);
00590 if (unp_size & 0xC0000000 || (unp_size << !bits) > *data_size) {
00591 av_log(avctx, AV_LOG_ERROR, "Frame is too large to fit in buffer\n");
00592 return -1;
00593 }
00594
00595 memset(vlc, 0, sizeof(VLC) * 4);
00596 memset(h, 0, sizeof(HuffContext) * 4);
00597
00598 for(i = 0; i < (1 << (bits + stereo)); i++) {
00599 h[i].length = 256;
00600 h[i].maxlength = 0;
00601 h[i].current = 0;
00602 h[i].bits = av_mallocz(256 * 4);
00603 h[i].lengths = av_mallocz(256 * sizeof(int));
00604 h[i].values = av_mallocz(256 * sizeof(int));
00605 skip_bits1(&gb);
00606 smacker_decode_tree(&gb, &h[i], 0, 0);
00607 skip_bits1(&gb);
00608 if(h[i].current > 1) {
00609 res = init_vlc(&vlc[i], SMKTREE_BITS, h[i].length,
00610 h[i].lengths, sizeof(int), sizeof(int),
00611 h[i].bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE);
00612 if(res < 0) {
00613 av_log(avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
00614 return -1;
00615 }
00616 }
00617 }
00618 if(bits) {
00619 for(i = stereo; i >= 0; i--)
00620 pred[i] = bswap_16(get_bits(&gb, 16));
00621 for(i = 0; i < stereo; i++)
00622 *samples++ = pred[i];
00623 for(i = 0; i < unp_size / 2; i++) {
00624 if(i & stereo) {
00625 if(vlc[2].table)
00626 res = get_vlc2(&gb, vlc[2].table, SMKTREE_BITS, 3);
00627 else
00628 res = 0;
00629 val = h[2].values[res];
00630 if(vlc[3].table)
00631 res = get_vlc2(&gb, vlc[3].table, SMKTREE_BITS, 3);
00632 else
00633 res = 0;
00634 val |= h[3].values[res] << 8;
00635 pred[1] += (int16_t)val;
00636 *samples++ = pred[1];
00637 } else {
00638 if(vlc[0].table)
00639 res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
00640 else
00641 res = 0;
00642 val = h[0].values[res];
00643 if(vlc[1].table)
00644 res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
00645 else
00646 res = 0;
00647 val |= h[1].values[res] << 8;
00648 pred[0] += val;
00649 *samples++ = pred[0];
00650 }
00651 }
00652 } else {
00653 for(i = stereo; i >= 0; i--)
00654 pred[i] = get_bits(&gb, 8);
00655 for(i = 0; i < stereo; i++)
00656 *samples++ = (pred[i] - 0x80) << 8;
00657 for(i = 0; i < unp_size; i++) {
00658 if(i & stereo){
00659 if(vlc[1].table)
00660 res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
00661 else
00662 res = 0;
00663 pred[1] += (int8_t)h[1].values[res];
00664 *samples++ = (pred[1] - 0x80) << 8;
00665 } else {
00666 if(vlc[0].table)
00667 res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
00668 else
00669 res = 0;
00670 pred[0] += (int8_t)h[0].values[res];
00671 *samples++ = (pred[0] - 0x80) << 8;
00672 }
00673 }
00674 unp_size *= 2;
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 CODEC_TYPE_VIDEO,
00695 CODEC_ID_SMACKVIDEO,
00696 sizeof(SmackVContext),
00697 decode_init,
00698 NULL,
00699 decode_end,
00700 decode_frame
00701 };
00702
00703 AVCodec smackaud_decoder = {
00704 "smackaud",
00705 CODEC_TYPE_AUDIO,
00706 CODEC_ID_SMACKAUDIO,
00707 0,
00708 smka_decode_init,
00709 NULL,
00710 NULL,
00711 smka_decode_frame
00712 };
00713