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