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 "libavutil/channel_layout.h"
00035 #include "avcodec.h"
00036 #include "internal.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(length > 32 || length > 3*SMKTREE_BITS) {
00101 av_log(NULL, AV_LOG_ERROR, "length too long\n");
00102 return AVERROR_INVALIDDATA;
00103 }
00104 if(!get_bits1(gb)){
00105 if(hc->current >= 256){
00106 av_log(NULL, AV_LOG_ERROR, "Tree size exceeded!\n");
00107 return AVERROR_INVALIDDATA;
00108 }
00109 if(length){
00110 hc->bits[hc->current] = prefix;
00111 hc->lengths[hc->current] = length;
00112 } else {
00113 hc->bits[hc->current] = 0;
00114 hc->lengths[hc->current] = 0;
00115 }
00116 hc->values[hc->current] = get_bits(gb, 8);
00117 hc->current++;
00118 if(hc->maxlength < length)
00119 hc->maxlength = length;
00120 return 0;
00121 } else {
00122 int r;
00123 length++;
00124 r = smacker_decode_tree(gb, hc, prefix, length);
00125 if(r)
00126 return r;
00127 return smacker_decode_tree(gb, hc, prefix | (1 << (length - 1)), length);
00128 }
00129 }
00130
00134 static int smacker_decode_bigtree(GetBitContext *gb, HuffContext *hc, DBCtx *ctx)
00135 {
00136 if (hc->current + 1 >= hc->length) {
00137 av_log(NULL, AV_LOG_ERROR, "Tree size exceeded!\n");
00138 return AVERROR_INVALIDDATA;
00139 }
00140 if(!get_bits1(gb)){
00141 int val, i1, i2;
00142 i1 = ctx->v1->table ? get_vlc2(gb, ctx->v1->table, SMKTREE_BITS, 3) : 0;
00143 i2 = ctx->v2->table ? get_vlc2(gb, ctx->v2->table, SMKTREE_BITS, 3) : 0;
00144 if (i1 < 0 || i2 < 0)
00145 return AVERROR_INVALIDDATA;
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] = { { 0 } };
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 AVERROR_INVALIDDATA;
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 if(get_bits1(gb)) {
00209 res = smacker_decode_tree(gb, &tmp1, 0, 0);
00210 if (res < 0)
00211 return res;
00212 skip_bits1(gb);
00213 if(tmp1.current > 1) {
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 AVERROR_INVALIDDATA;
00220 }
00221 }
00222 }
00223 if (!vlc[0].table) {
00224 av_log(smk->avctx, AV_LOG_ERROR, "Skipping low bytes tree\n");
00225 }
00226 if(get_bits1(gb)){
00227 res = smacker_decode_tree(gb, &tmp2, 0, 0);
00228 if (res < 0)
00229 return res;
00230 skip_bits1(gb);
00231 if(tmp2.current > 1) {
00232 res = init_vlc(&vlc[1], SMKTREE_BITS, tmp2.length,
00233 tmp2.lengths, sizeof(int), sizeof(int),
00234 tmp2.bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE);
00235 if(res < 0) {
00236 av_log(smk->avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
00237 return AVERROR_INVALIDDATA;
00238 }
00239 }
00240 }
00241 if (!vlc[1].table) {
00242 av_log(smk->avctx, AV_LOG_ERROR, "Skipping high bytes tree\n");
00243 }
00244
00245 escapes[0] = get_bits(gb, 16);
00246 escapes[1] = get_bits(gb, 16);
00247 escapes[2] = get_bits(gb, 16);
00248
00249 last[0] = last[1] = last[2] = -1;
00250
00251 ctx.escapes[0] = escapes[0];
00252 ctx.escapes[1] = escapes[1];
00253 ctx.escapes[2] = escapes[2];
00254 ctx.v1 = &vlc[0];
00255 ctx.v2 = &vlc[1];
00256 ctx.recode1 = tmp1.values;
00257 ctx.recode2 = tmp2.values;
00258 ctx.last = last;
00259
00260 huff.length = ((size + 3) >> 2) + 3;
00261 huff.maxlength = 0;
00262 huff.current = 0;
00263 huff.values = av_mallocz(huff.length * sizeof(int));
00264
00265 if (smacker_decode_bigtree(gb, &huff, &ctx) < 0)
00266 err = -1;
00267 skip_bits1(gb);
00268 if(ctx.last[0] == -1) ctx.last[0] = huff.current++;
00269 if(ctx.last[1] == -1) ctx.last[1] = huff.current++;
00270 if(ctx.last[2] == -1) ctx.last[2] = huff.current++;
00271 if(huff.current > huff.length){
00272 ctx.last[0] = ctx.last[1] = ctx.last[2] = 1;
00273 av_log(smk->avctx, AV_LOG_ERROR, "bigtree damaged\n");
00274 return AVERROR_INVALIDDATA;
00275 }
00276
00277 *recodes = huff.values;
00278
00279 if(vlc[0].table)
00280 ff_free_vlc(&vlc[0]);
00281 if(vlc[1].table)
00282 ff_free_vlc(&vlc[1]);
00283 av_free(tmp1.bits);
00284 av_free(tmp1.lengths);
00285 av_free(tmp1.values);
00286 av_free(tmp2.bits);
00287 av_free(tmp2.lengths);
00288 av_free(tmp2.values);
00289
00290 return err;
00291 }
00292
00293 static int decode_header_trees(SmackVContext *smk) {
00294 GetBitContext gb;
00295 int mmap_size, mclr_size, full_size, type_size;
00296
00297 mmap_size = AV_RL32(smk->avctx->extradata);
00298 mclr_size = AV_RL32(smk->avctx->extradata + 4);
00299 full_size = AV_RL32(smk->avctx->extradata + 8);
00300 type_size = AV_RL32(smk->avctx->extradata + 12);
00301
00302 init_get_bits(&gb, smk->avctx->extradata + 16, (smk->avctx->extradata_size - 16) * 8);
00303
00304 if(!get_bits1(&gb)) {
00305 av_log(smk->avctx, AV_LOG_INFO, "Skipping MMAP tree\n");
00306 smk->mmap_tbl = av_malloc(sizeof(int) * 2);
00307 smk->mmap_tbl[0] = 0;
00308 smk->mmap_last[0] = smk->mmap_last[1] = smk->mmap_last[2] = 1;
00309 } else {
00310 if (smacker_decode_header_tree(smk, &gb, &smk->mmap_tbl, smk->mmap_last, mmap_size))
00311 return AVERROR_INVALIDDATA;
00312 }
00313 if(!get_bits1(&gb)) {
00314 av_log(smk->avctx, AV_LOG_INFO, "Skipping MCLR tree\n");
00315 smk->mclr_tbl = av_malloc(sizeof(int) * 2);
00316 smk->mclr_tbl[0] = 0;
00317 smk->mclr_last[0] = smk->mclr_last[1] = smk->mclr_last[2] = 1;
00318 } else {
00319 if (smacker_decode_header_tree(smk, &gb, &smk->mclr_tbl, smk->mclr_last, mclr_size))
00320 return AVERROR_INVALIDDATA;
00321 }
00322 if(!get_bits1(&gb)) {
00323 av_log(smk->avctx, AV_LOG_INFO, "Skipping FULL tree\n");
00324 smk->full_tbl = av_malloc(sizeof(int) * 2);
00325 smk->full_tbl[0] = 0;
00326 smk->full_last[0] = smk->full_last[1] = smk->full_last[2] = 1;
00327 } else {
00328 if (smacker_decode_header_tree(smk, &gb, &smk->full_tbl, smk->full_last, full_size))
00329 return AVERROR_INVALIDDATA;
00330 }
00331 if(!get_bits1(&gb)) {
00332 av_log(smk->avctx, AV_LOG_INFO, "Skipping TYPE tree\n");
00333 smk->type_tbl = av_malloc(sizeof(int) * 2);
00334 smk->type_tbl[0] = 0;
00335 smk->type_last[0] = smk->type_last[1] = smk->type_last[2] = 1;
00336 } else {
00337 if (smacker_decode_header_tree(smk, &gb, &smk->type_tbl, smk->type_last, type_size))
00338 return AVERROR_INVALIDDATA;
00339 }
00340
00341 return 0;
00342 }
00343
00344 static av_always_inline void last_reset(int *recode, int *last) {
00345 recode[last[0]] = recode[last[1]] = recode[last[2]] = 0;
00346 }
00347
00348
00349 static av_always_inline int smk_get_code(GetBitContext *gb, int *recode, int *last) {
00350 register int *table = recode;
00351 int v;
00352
00353 while(*table & SMK_NODE) {
00354 if(get_bits1(gb))
00355 table += (*table) & (~SMK_NODE);
00356 table++;
00357 }
00358 v = *table;
00359
00360 if(v != recode[last[0]]) {
00361 recode[last[2]] = recode[last[1]];
00362 recode[last[1]] = recode[last[0]];
00363 recode[last[0]] = v;
00364 }
00365 return v;
00366 }
00367
00368 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
00369 AVPacket *avpkt)
00370 {
00371 SmackVContext * const smk = avctx->priv_data;
00372 uint8_t *out;
00373 uint32_t *pal;
00374 GetByteContext gb2;
00375 GetBitContext gb;
00376 int blocks, blk, bw, bh;
00377 int i, ret;
00378 int stride;
00379 int flags;
00380
00381 if (avpkt->size <= 769)
00382 return AVERROR_INVALIDDATA;
00383
00384 smk->pic.reference = 3;
00385 smk->pic.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;
00386 if((ret = avctx->reget_buffer(avctx, &smk->pic)) < 0){
00387 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00388 return ret;
00389 }
00390
00391
00392 pal = (uint32_t*)smk->pic.data[1];
00393 bytestream2_init(&gb2, avpkt->data, avpkt->size);
00394 flags = bytestream2_get_byteu(&gb2);
00395 smk->pic.palette_has_changed = flags & 1;
00396 smk->pic.key_frame = !!(flags & 2);
00397 if(smk->pic.key_frame)
00398 smk->pic.pict_type = AV_PICTURE_TYPE_I;
00399 else
00400 smk->pic.pict_type = AV_PICTURE_TYPE_P;
00401
00402 for(i = 0; i < 256; i++)
00403 *pal++ = 0xFFU << 24 | bytestream2_get_be24u(&gb2);
00404
00405 last_reset(smk->mmap_tbl, smk->mmap_last);
00406 last_reset(smk->mclr_tbl, smk->mclr_last);
00407 last_reset(smk->full_tbl, smk->full_last);
00408 last_reset(smk->type_tbl, smk->type_last);
00409 init_get_bits(&gb, avpkt->data + 769, (avpkt->size - 769) * 8);
00410
00411 blk = 0;
00412 bw = avctx->width >> 2;
00413 bh = avctx->height >> 2;
00414 blocks = bw * bh;
00415 out = smk->pic.data[0];
00416 stride = smk->pic.linesize[0];
00417 while(blk < blocks) {
00418 int type, run, mode;
00419 uint16_t pix;
00420
00421 type = smk_get_code(&gb, smk->type_tbl, smk->type_last);
00422 run = block_runs[(type >> 2) & 0x3F];
00423 switch(type & 3){
00424 case SMK_BLK_MONO:
00425 while(run-- && blk < blocks){
00426 int clr, map;
00427 int hi, lo;
00428 clr = smk_get_code(&gb, smk->mclr_tbl, smk->mclr_last);
00429 map = smk_get_code(&gb, smk->mmap_tbl, smk->mmap_last);
00430 out = smk->pic.data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
00431 hi = clr >> 8;
00432 lo = clr & 0xFF;
00433 for(i = 0; i < 4; i++) {
00434 if(map & 1) out[0] = hi; else out[0] = lo;
00435 if(map & 2) out[1] = hi; else out[1] = lo;
00436 if(map & 4) out[2] = hi; else out[2] = lo;
00437 if(map & 8) out[3] = hi; else out[3] = lo;
00438 map >>= 4;
00439 out += stride;
00440 }
00441 blk++;
00442 }
00443 break;
00444 case SMK_BLK_FULL:
00445 mode = 0;
00446 if(avctx->codec_tag == MKTAG('S', 'M', 'K', '4')) {
00447 if(get_bits1(&gb)) mode = 1;
00448 else if(get_bits1(&gb)) mode = 2;
00449 }
00450 while(run-- && blk < blocks){
00451 out = smk->pic.data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
00452 switch(mode){
00453 case 0:
00454 for(i = 0; i < 4; i++) {
00455 pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00456 AV_WL16(out+2,pix);
00457 pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00458 AV_WL16(out,pix);
00459 out += stride;
00460 }
00461 break;
00462 case 1:
00463 pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00464 out[0] = out[1] = pix & 0xFF;
00465 out[2] = out[3] = pix >> 8;
00466 out += stride;
00467 out[0] = out[1] = pix & 0xFF;
00468 out[2] = out[3] = pix >> 8;
00469 out += stride;
00470 pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00471 out[0] = out[1] = pix & 0xFF;
00472 out[2] = out[3] = pix >> 8;
00473 out += stride;
00474 out[0] = out[1] = pix & 0xFF;
00475 out[2] = out[3] = pix >> 8;
00476 out += stride;
00477 break;
00478 case 2:
00479 for(i = 0; i < 2; i++) {
00480 uint16_t pix1, pix2;
00481 pix2 = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00482 pix1 = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00483 AV_WL16(out,pix1);
00484 AV_WL16(out+2,pix2);
00485 out += stride;
00486 AV_WL16(out,pix1);
00487 AV_WL16(out+2,pix2);
00488 out += stride;
00489 }
00490 break;
00491 }
00492 blk++;
00493 }
00494 break;
00495 case SMK_BLK_SKIP:
00496 while(run-- && blk < blocks)
00497 blk++;
00498 break;
00499 case SMK_BLK_FILL:
00500 mode = type >> 8;
00501 while(run-- && blk < blocks){
00502 uint32_t col;
00503 out = smk->pic.data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
00504 col = mode * 0x01010101;
00505 for(i = 0; i < 4; i++) {
00506 *((uint32_t*)out) = col;
00507 out += stride;
00508 }
00509 blk++;
00510 }
00511 break;
00512 }
00513
00514 }
00515
00516 *got_frame = 1;
00517 *(AVFrame*)data = smk->pic;
00518
00519
00520 return avpkt->size;
00521 }
00522
00523
00524
00525
00526
00527
00528
00529
00530 static av_cold int decode_init(AVCodecContext *avctx)
00531 {
00532 SmackVContext * const c = avctx->priv_data;
00533
00534 c->avctx = avctx;
00535
00536 avctx->pix_fmt = AV_PIX_FMT_PAL8;
00537
00538 avcodec_get_frame_defaults(&c->pic);
00539
00540
00541 if(avctx->extradata_size < 16){
00542 av_log(avctx, AV_LOG_ERROR, "Extradata missing!\n");
00543 return AVERROR(EINVAL);
00544 }
00545
00546 if (decode_header_trees(c))
00547 return AVERROR_INVALIDDATA;
00548
00549 return 0;
00550 }
00551
00552
00553
00554
00555
00556
00557
00558
00559 static av_cold int decode_end(AVCodecContext *avctx)
00560 {
00561 SmackVContext * const smk = avctx->priv_data;
00562
00563 av_freep(&smk->mmap_tbl);
00564 av_freep(&smk->mclr_tbl);
00565 av_freep(&smk->full_tbl);
00566 av_freep(&smk->type_tbl);
00567
00568 if (smk->pic.data[0])
00569 avctx->release_buffer(avctx, &smk->pic);
00570
00571 return 0;
00572 }
00573
00574
00575 typedef struct SmackerAudioContext {
00576 AVFrame frame;
00577 } SmackerAudioContext;
00578
00579 static av_cold int smka_decode_init(AVCodecContext *avctx)
00580 {
00581 SmackerAudioContext *s = avctx->priv_data;
00582
00583 if (avctx->channels < 1 || avctx->channels > 2) {
00584 av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
00585 return AVERROR(EINVAL);
00586 }
00587 avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
00588 avctx->sample_fmt = avctx->bits_per_coded_sample == 8 ? AV_SAMPLE_FMT_U8 : AV_SAMPLE_FMT_S16;
00589
00590 avcodec_get_frame_defaults(&s->frame);
00591 avctx->coded_frame = &s->frame;
00592
00593 return 0;
00594 }
00595
00599 static int smka_decode_frame(AVCodecContext *avctx, void *data,
00600 int *got_frame_ptr, AVPacket *avpkt)
00601 {
00602 SmackerAudioContext *s = avctx->priv_data;
00603 const uint8_t *buf = avpkt->data;
00604 int buf_size = avpkt->size;
00605 GetBitContext gb;
00606 HuffContext h[4] = { { 0 } };
00607 VLC vlc[4] = { { 0 } };
00608 int16_t *samples;
00609 uint8_t *samples8;
00610 int val;
00611 int i, res, ret;
00612 int unp_size;
00613 int bits, stereo;
00614 int pred[2] = {0, 0};
00615
00616 if (buf_size <= 4) {
00617 av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
00618 return AVERROR(EINVAL);
00619 }
00620
00621 unp_size = AV_RL32(buf);
00622
00623 if (unp_size > (1U<<24)) {
00624 av_log(avctx, AV_LOG_ERROR, "packet is too big\n");
00625 return AVERROR_INVALIDDATA;
00626 }
00627
00628 init_get_bits(&gb, buf + 4, (buf_size - 4) * 8);
00629
00630 if(!get_bits1(&gb)){
00631 av_log(avctx, AV_LOG_INFO, "Sound: no data\n");
00632 *got_frame_ptr = 0;
00633 return 1;
00634 }
00635 stereo = get_bits1(&gb);
00636 bits = get_bits1(&gb);
00637 if (stereo ^ (avctx->channels != 1)) {
00638 av_log(avctx, AV_LOG_ERROR, "channels mismatch\n");
00639 return AVERROR(EINVAL);
00640 }
00641 if (bits && avctx->sample_fmt == AV_SAMPLE_FMT_U8) {
00642 av_log(avctx, AV_LOG_ERROR, "sample format mismatch\n");
00643 return AVERROR(EINVAL);
00644 }
00645
00646
00647 s->frame.nb_samples = unp_size / (avctx->channels * (bits + 1));
00648 if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
00649 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00650 return ret;
00651 }
00652 samples = (int16_t *)s->frame.data[0];
00653 samples8 = s->frame.data[0];
00654
00655
00656 for(i = 0; i < (1 << (bits + stereo)); i++) {
00657 h[i].length = 256;
00658 h[i].maxlength = 0;
00659 h[i].current = 0;
00660 h[i].bits = av_mallocz(256 * 4);
00661 h[i].lengths = av_mallocz(256 * sizeof(int));
00662 h[i].values = av_mallocz(256 * sizeof(int));
00663 skip_bits1(&gb);
00664 res = smacker_decode_tree(&gb, &h[i], 0, 0);
00665 if (res < 0)
00666 return res;
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 AVERROR_INVALIDDATA;
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(get_bits_left(&gb)<0)
00685 return AVERROR_INVALIDDATA;
00686 if(i & stereo) {
00687 if(vlc[2].table)
00688 res = get_vlc2(&gb, vlc[2].table, SMKTREE_BITS, 3);
00689 else
00690 res = 0;
00691 if (res < 0) {
00692 av_log(avctx, AV_LOG_ERROR, "invalid vlc\n");
00693 return AVERROR_INVALIDDATA;
00694 }
00695 val = h[2].values[res];
00696 if(vlc[3].table)
00697 res = get_vlc2(&gb, vlc[3].table, SMKTREE_BITS, 3);
00698 else
00699 res = 0;
00700 if (res < 0) {
00701 av_log(avctx, AV_LOG_ERROR, "invalid vlc\n");
00702 return AVERROR_INVALIDDATA;
00703 }
00704 val |= h[3].values[res] << 8;
00705 pred[1] += sign_extend(val, 16);
00706 *samples++ = av_clip_int16(pred[1]);
00707 } else {
00708 if(vlc[0].table)
00709 res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
00710 else
00711 res = 0;
00712 if (res < 0) {
00713 av_log(avctx, AV_LOG_ERROR, "invalid vlc\n");
00714 return AVERROR_INVALIDDATA;
00715 }
00716 val = h[0].values[res];
00717 if(vlc[1].table)
00718 res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
00719 else
00720 res = 0;
00721 if (res < 0) {
00722 av_log(avctx, AV_LOG_ERROR, "invalid vlc\n");
00723 return AVERROR_INVALIDDATA;
00724 }
00725 val |= h[1].values[res] << 8;
00726 pred[0] += sign_extend(val, 16);
00727 *samples++ = av_clip_int16(pred[0]);
00728 }
00729 }
00730 } else {
00731 for(i = stereo; i >= 0; i--)
00732 pred[i] = get_bits(&gb, 8);
00733 for(i = 0; i <= stereo; i++)
00734 *samples8++ = pred[i];
00735 for(; i < unp_size; i++) {
00736 if(get_bits_left(&gb)<0)
00737 return AVERROR_INVALIDDATA;
00738 if(i & stereo){
00739 if(vlc[1].table)
00740 res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
00741 else
00742 res = 0;
00743 if (res < 0) {
00744 av_log(avctx, AV_LOG_ERROR, "invalid vlc\n");
00745 return AVERROR_INVALIDDATA;
00746 }
00747 pred[1] += sign_extend(h[1].values[res], 8);
00748 *samples8++ = av_clip_uint8(pred[1]);
00749 } else {
00750 if(vlc[0].table)
00751 res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
00752 else
00753 res = 0;
00754 if (res < 0) {
00755 av_log(avctx, AV_LOG_ERROR, "invalid vlc\n");
00756 return AVERROR_INVALIDDATA;
00757 }
00758 pred[0] += sign_extend(h[0].values[res], 8);
00759 *samples8++ = av_clip_uint8(pred[0]);
00760 }
00761 }
00762 }
00763
00764 for(i = 0; i < 4; i++) {
00765 if(vlc[i].table)
00766 ff_free_vlc(&vlc[i]);
00767 av_free(h[i].bits);
00768 av_free(h[i].lengths);
00769 av_free(h[i].values);
00770 }
00771
00772 *got_frame_ptr = 1;
00773 *(AVFrame *)data = s->frame;
00774
00775 return buf_size;
00776 }
00777
00778 AVCodec ff_smacker_decoder = {
00779 .name = "smackvid",
00780 .type = AVMEDIA_TYPE_VIDEO,
00781 .id = AV_CODEC_ID_SMACKVIDEO,
00782 .priv_data_size = sizeof(SmackVContext),
00783 .init = decode_init,
00784 .close = decode_end,
00785 .decode = decode_frame,
00786 .capabilities = CODEC_CAP_DR1,
00787 .long_name = NULL_IF_CONFIG_SMALL("Smacker video"),
00788 };
00789
00790 AVCodec ff_smackaud_decoder = {
00791 .name = "smackaud",
00792 .type = AVMEDIA_TYPE_AUDIO,
00793 .id = AV_CODEC_ID_SMACKAUDIO,
00794 .priv_data_size = sizeof(SmackerAudioContext),
00795 .init = smka_decode_init,
00796 .decode = smka_decode_frame,
00797 .capabilities = CODEC_CAP_DR1,
00798 .long_name = NULL_IF_CONFIG_SMALL("Smacker audio"),
00799 };