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