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