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