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) + 3;
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
00267 *recodes = huff.values;
00268
00269 if(vlc[0].table)
00270 ff_free_vlc(&vlc[0]);
00271 if(vlc[1].table)
00272 ff_free_vlc(&vlc[1]);
00273 av_free(tmp1.bits);
00274 av_free(tmp1.lengths);
00275 av_free(tmp1.values);
00276 av_free(tmp2.bits);
00277 av_free(tmp2.lengths);
00278 av_free(tmp2.values);
00279
00280 return err;
00281 }
00282
00283 static int decode_header_trees(SmackVContext *smk) {
00284 GetBitContext gb;
00285 int mmap_size, mclr_size, full_size, type_size;
00286
00287 mmap_size = AV_RL32(smk->avctx->extradata);
00288 mclr_size = AV_RL32(smk->avctx->extradata + 4);
00289 full_size = AV_RL32(smk->avctx->extradata + 8);
00290 type_size = AV_RL32(smk->avctx->extradata + 12);
00291
00292 init_get_bits(&gb, smk->avctx->extradata + 16, (smk->avctx->extradata_size - 16) * 8);
00293
00294 if(!get_bits1(&gb)) {
00295 av_log(smk->avctx, AV_LOG_INFO, "Skipping MMAP tree\n");
00296 smk->mmap_tbl = av_malloc(sizeof(int) * 2);
00297 smk->mmap_tbl[0] = 0;
00298 smk->mmap_last[0] = smk->mmap_last[1] = smk->mmap_last[2] = 1;
00299 } else {
00300 if (smacker_decode_header_tree(smk, &gb, &smk->mmap_tbl, smk->mmap_last, mmap_size))
00301 return -1;
00302 }
00303 if(!get_bits1(&gb)) {
00304 av_log(smk->avctx, AV_LOG_INFO, "Skipping MCLR tree\n");
00305 smk->mclr_tbl = av_malloc(sizeof(int) * 2);
00306 smk->mclr_tbl[0] = 0;
00307 smk->mclr_last[0] = smk->mclr_last[1] = smk->mclr_last[2] = 1;
00308 } else {
00309 if (smacker_decode_header_tree(smk, &gb, &smk->mclr_tbl, smk->mclr_last, mclr_size))
00310 return -1;
00311 }
00312 if(!get_bits1(&gb)) {
00313 av_log(smk->avctx, AV_LOG_INFO, "Skipping FULL tree\n");
00314 smk->full_tbl = av_malloc(sizeof(int) * 2);
00315 smk->full_tbl[0] = 0;
00316 smk->full_last[0] = smk->full_last[1] = smk->full_last[2] = 1;
00317 } else {
00318 if (smacker_decode_header_tree(smk, &gb, &smk->full_tbl, smk->full_last, full_size))
00319 return -1;
00320 }
00321 if(!get_bits1(&gb)) {
00322 av_log(smk->avctx, AV_LOG_INFO, "Skipping TYPE tree\n");
00323 smk->type_tbl = av_malloc(sizeof(int) * 2);
00324 smk->type_tbl[0] = 0;
00325 smk->type_last[0] = smk->type_last[1] = smk->type_last[2] = 1;
00326 } else {
00327 if (smacker_decode_header_tree(smk, &gb, &smk->type_tbl, smk->type_last, type_size))
00328 return -1;
00329 }
00330
00331 return 0;
00332 }
00333
00334 static av_always_inline void last_reset(int *recode, int *last) {
00335 recode[last[0]] = recode[last[1]] = recode[last[2]] = 0;
00336 }
00337
00338
00339 static av_always_inline int smk_get_code(GetBitContext *gb, int *recode, int *last) {
00340 register int *table = recode;
00341 int v, b;
00342
00343 b = get_bits_count(gb);
00344 while(*table & SMK_NODE) {
00345 if(get_bits1(gb))
00346 table += (*table) & (~SMK_NODE);
00347 table++;
00348 }
00349 v = *table;
00350 b = get_bits_count(gb) - b;
00351
00352 if(v != recode[last[0]]) {
00353 recode[last[2]] = recode[last[1]];
00354 recode[last[1]] = recode[last[0]];
00355 recode[last[0]] = v;
00356 }
00357 return v;
00358 }
00359
00360 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt)
00361 {
00362 const uint8_t *buf = avpkt->data;
00363 int buf_size = avpkt->size;
00364 SmackVContext * const smk = avctx->priv_data;
00365 uint8_t *out;
00366 uint32_t *pal;
00367 GetBitContext gb;
00368 int blocks, blk, bw, bh;
00369 int i;
00370 int stride;
00371
00372 if(buf_size <= 769)
00373 return 0;
00374
00375 smk->pic.reference = 1;
00376 smk->pic.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;
00377 if(avctx->reget_buffer(avctx, &smk->pic) < 0){
00378 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00379 return -1;
00380 }
00381
00382
00383 pal = (uint32_t*)smk->pic.data[1];
00384 smk->pic.palette_has_changed = buf[0] & 1;
00385 smk->pic.key_frame = !!(buf[0] & 2);
00386 if(smk->pic.key_frame)
00387 smk->pic.pict_type = AV_PICTURE_TYPE_I;
00388 else
00389 smk->pic.pict_type = AV_PICTURE_TYPE_P;
00390
00391 buf++;
00392 for(i = 0; i < 256; i++)
00393 *pal++ = bytestream_get_be24(&buf);
00394 buf_size -= 769;
00395
00396 last_reset(smk->mmap_tbl, smk->mmap_last);
00397 last_reset(smk->mclr_tbl, smk->mclr_last);
00398 last_reset(smk->full_tbl, smk->full_last);
00399 last_reset(smk->type_tbl, smk->type_last);
00400 init_get_bits(&gb, buf, buf_size * 8);
00401
00402 blk = 0;
00403 bw = avctx->width >> 2;
00404 bh = avctx->height >> 2;
00405 blocks = bw * bh;
00406 out = smk->pic.data[0];
00407 stride = smk->pic.linesize[0];
00408 while(blk < blocks) {
00409 int type, run, mode;
00410 uint16_t pix;
00411
00412 type = smk_get_code(&gb, smk->type_tbl, smk->type_last);
00413 run = block_runs[(type >> 2) & 0x3F];
00414 switch(type & 3){
00415 case SMK_BLK_MONO:
00416 while(run-- && blk < blocks){
00417 int clr, map;
00418 int hi, lo;
00419 clr = smk_get_code(&gb, smk->mclr_tbl, smk->mclr_last);
00420 map = smk_get_code(&gb, smk->mmap_tbl, smk->mmap_last);
00421 out = smk->pic.data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
00422 hi = clr >> 8;
00423 lo = clr & 0xFF;
00424 for(i = 0; i < 4; i++) {
00425 if(map & 1) out[0] = hi; else out[0] = lo;
00426 if(map & 2) out[1] = hi; else out[1] = lo;
00427 if(map & 4) out[2] = hi; else out[2] = lo;
00428 if(map & 8) out[3] = hi; else out[3] = lo;
00429 map >>= 4;
00430 out += stride;
00431 }
00432 blk++;
00433 }
00434 break;
00435 case SMK_BLK_FULL:
00436 mode = 0;
00437 if(avctx->codec_tag == MKTAG('S', 'M', 'K', '4')) {
00438 if(get_bits1(&gb)) mode = 1;
00439 else if(get_bits1(&gb)) mode = 2;
00440 }
00441 while(run-- && blk < blocks){
00442 out = smk->pic.data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
00443 switch(mode){
00444 case 0:
00445 for(i = 0; i < 4; i++) {
00446 pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00447 AV_WL16(out+2,pix);
00448 pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00449 AV_WL16(out,pix);
00450 out += stride;
00451 }
00452 break;
00453 case 1:
00454 pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00455 out[0] = out[1] = pix & 0xFF;
00456 out[2] = out[3] = pix >> 8;
00457 out += stride;
00458 out[0] = out[1] = pix & 0xFF;
00459 out[2] = out[3] = pix >> 8;
00460 out += stride;
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 break;
00469 case 2:
00470 for(i = 0; i < 2; i++) {
00471 uint16_t pix1, pix2;
00472 pix2 = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00473 pix1 = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00474 AV_WL16(out,pix1);
00475 AV_WL16(out+2,pix2);
00476 out += stride;
00477 AV_WL16(out,pix1);
00478 AV_WL16(out+2,pix2);
00479 out += stride;
00480 }
00481 break;
00482 }
00483 blk++;
00484 }
00485 break;
00486 case SMK_BLK_SKIP:
00487 while(run-- && blk < blocks)
00488 blk++;
00489 break;
00490 case SMK_BLK_FILL:
00491 mode = type >> 8;
00492 while(run-- && blk < blocks){
00493 uint32_t col;
00494 out = smk->pic.data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
00495 col = mode * 0x01010101;
00496 for(i = 0; i < 4; i++) {
00497 *((uint32_t*)out) = col;
00498 out += stride;
00499 }
00500 blk++;
00501 }
00502 break;
00503 }
00504
00505 }
00506
00507 *data_size = sizeof(AVFrame);
00508 *(AVFrame*)data = smk->pic;
00509
00510
00511 return buf_size;
00512 }
00513
00514
00515
00516
00517
00518
00519
00520
00521 static av_cold int decode_init(AVCodecContext *avctx)
00522 {
00523 SmackVContext * const c = avctx->priv_data;
00524
00525 c->avctx = avctx;
00526
00527 avctx->pix_fmt = PIX_FMT_PAL8;
00528
00529
00530
00531 if(avctx->extradata_size < 16){
00532 av_log(avctx, AV_LOG_ERROR, "Extradata missing!\n");
00533 return -1;
00534 }
00535
00536 if (decode_header_trees(c))
00537 return -1;
00538
00539 return 0;
00540 }
00541
00542
00543
00544
00545
00546
00547
00548
00549 static av_cold int decode_end(AVCodecContext *avctx)
00550 {
00551 SmackVContext * const smk = avctx->priv_data;
00552
00553 av_freep(&smk->mmap_tbl);
00554 av_freep(&smk->mclr_tbl);
00555 av_freep(&smk->full_tbl);
00556 av_freep(&smk->type_tbl);
00557
00558 if (smk->pic.data[0])
00559 avctx->release_buffer(avctx, &smk->pic);
00560
00561 return 0;
00562 }
00563
00564
00565 typedef struct SmackerAudioContext {
00566 AVFrame frame;
00567 } SmackerAudioContext;
00568
00569 static av_cold int smka_decode_init(AVCodecContext *avctx)
00570 {
00571 SmackerAudioContext *s = avctx->priv_data;
00572
00573 if (avctx->channels < 1 || avctx->channels > 2) {
00574 av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
00575 return AVERROR(EINVAL);
00576 }
00577 avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
00578 avctx->sample_fmt = avctx->bits_per_coded_sample == 8 ? AV_SAMPLE_FMT_U8 : AV_SAMPLE_FMT_S16;
00579
00580 avcodec_get_frame_defaults(&s->frame);
00581 avctx->coded_frame = &s->frame;
00582
00583 return 0;
00584 }
00585
00589 static int smka_decode_frame(AVCodecContext *avctx, void *data,
00590 int *got_frame_ptr, AVPacket *avpkt)
00591 {
00592 SmackerAudioContext *s = avctx->priv_data;
00593 const uint8_t *buf = avpkt->data;
00594 int buf_size = avpkt->size;
00595 GetBitContext gb;
00596 HuffContext h[4];
00597 VLC vlc[4];
00598 int16_t *samples;
00599 uint8_t *samples8;
00600 int val;
00601 int i, res, ret;
00602 int unp_size;
00603 int bits, stereo;
00604 int pred[2] = {0, 0};
00605
00606 if (buf_size <= 4) {
00607 av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
00608 return AVERROR(EINVAL);
00609 }
00610
00611 unp_size = AV_RL32(buf);
00612
00613 init_get_bits(&gb, buf + 4, (buf_size - 4) * 8);
00614
00615 if(!get_bits1(&gb)){
00616 av_log(avctx, AV_LOG_INFO, "Sound: no data\n");
00617 *got_frame_ptr = 0;
00618 return 1;
00619 }
00620 stereo = get_bits1(&gb);
00621 bits = get_bits1(&gb);
00622 if (stereo ^ (avctx->channels != 1)) {
00623 av_log(avctx, AV_LOG_ERROR, "channels mismatch\n");
00624 return AVERROR(EINVAL);
00625 }
00626 if (bits && avctx->sample_fmt == AV_SAMPLE_FMT_U8) {
00627 av_log(avctx, AV_LOG_ERROR, "sample format mismatch\n");
00628 return AVERROR(EINVAL);
00629 }
00630
00631
00632 s->frame.nb_samples = unp_size / (avctx->channels * (bits + 1));
00633 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
00634 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00635 return ret;
00636 }
00637 samples = (int16_t *)s->frame.data[0];
00638 samples8 = s->frame.data[0];
00639
00640 memset(vlc, 0, sizeof(VLC) * 4);
00641 memset(h, 0, sizeof(HuffContext) * 4);
00642
00643 for(i = 0; i < (1 << (bits + stereo)); i++) {
00644 h[i].length = 256;
00645 h[i].maxlength = 0;
00646 h[i].current = 0;
00647 h[i].bits = av_mallocz(256 * 4);
00648 h[i].lengths = av_mallocz(256 * sizeof(int));
00649 h[i].values = av_mallocz(256 * sizeof(int));
00650 skip_bits1(&gb);
00651 smacker_decode_tree(&gb, &h[i], 0, 0);
00652 skip_bits1(&gb);
00653 if(h[i].current > 1) {
00654 res = init_vlc(&vlc[i], SMKTREE_BITS, h[i].length,
00655 h[i].lengths, sizeof(int), sizeof(int),
00656 h[i].bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE);
00657 if(res < 0) {
00658 av_log(avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
00659 return -1;
00660 }
00661 }
00662 }
00663 if(bits) {
00664 for(i = stereo; i >= 0; i--)
00665 pred[i] = sign_extend(av_bswap16(get_bits(&gb, 16)), 16);
00666 for(i = 0; i <= stereo; i++)
00667 *samples++ = pred[i];
00668 for(; i < unp_size / 2; i++) {
00669 if(i & stereo) {
00670 if(vlc[2].table)
00671 res = get_vlc2(&gb, vlc[2].table, SMKTREE_BITS, 3);
00672 else
00673 res = 0;
00674 val = h[2].values[res];
00675 if(vlc[3].table)
00676 res = get_vlc2(&gb, vlc[3].table, SMKTREE_BITS, 3);
00677 else
00678 res = 0;
00679 val |= h[3].values[res] << 8;
00680 pred[1] += sign_extend(val, 16);
00681 *samples++ = av_clip_int16(pred[1]);
00682 } else {
00683 if(vlc[0].table)
00684 res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
00685 else
00686 res = 0;
00687 val = h[0].values[res];
00688 if(vlc[1].table)
00689 res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
00690 else
00691 res = 0;
00692 val |= h[1].values[res] << 8;
00693 pred[0] += sign_extend(val, 16);
00694 *samples++ = av_clip_int16(pred[0]);
00695 }
00696 }
00697 } else {
00698 for(i = stereo; i >= 0; i--)
00699 pred[i] = get_bits(&gb, 8);
00700 for(i = 0; i <= stereo; i++)
00701 *samples8++ = pred[i];
00702 for(; i < unp_size; i++) {
00703 if(i & stereo){
00704 if(vlc[1].table)
00705 res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
00706 else
00707 res = 0;
00708 pred[1] += sign_extend(h[1].values[res], 8);
00709 *samples8++ = av_clip_uint8(pred[1]);
00710 } else {
00711 if(vlc[0].table)
00712 res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
00713 else
00714 res = 0;
00715 pred[0] += sign_extend(h[0].values[res], 8);
00716 *samples8++ = av_clip_uint8(pred[0]);
00717 }
00718 }
00719 }
00720
00721 for(i = 0; i < 4; i++) {
00722 if(vlc[i].table)
00723 ff_free_vlc(&vlc[i]);
00724 av_free(h[i].bits);
00725 av_free(h[i].lengths);
00726 av_free(h[i].values);
00727 }
00728
00729 *got_frame_ptr = 1;
00730 *(AVFrame *)data = s->frame;
00731
00732 return buf_size;
00733 }
00734
00735 AVCodec ff_smacker_decoder = {
00736 .name = "smackvid",
00737 .type = AVMEDIA_TYPE_VIDEO,
00738 .id = CODEC_ID_SMACKVIDEO,
00739 .priv_data_size = sizeof(SmackVContext),
00740 .init = decode_init,
00741 .close = decode_end,
00742 .decode = decode_frame,
00743 .capabilities = CODEC_CAP_DR1,
00744 .long_name = NULL_IF_CONFIG_SMALL("Smacker video"),
00745 };
00746
00747 AVCodec ff_smackaud_decoder = {
00748 .name = "smackaud",
00749 .type = AVMEDIA_TYPE_AUDIO,
00750 .id = CODEC_ID_SMACKAUDIO,
00751 .priv_data_size = sizeof(SmackerAudioContext),
00752 .init = smka_decode_init,
00753 .decode = smka_decode_frame,
00754 .capabilities = CODEC_CAP_DR1,
00755 .long_name = NULL_IF_CONFIG_SMALL("Smacker audio"),
00756 };
00757