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