libavcodec/smacker.c
Go to the documentation of this file.
00001 /*
00002  * Smacker decoder
00003  * Copyright (c) 2006 Konstantin Shishkov
00004  *
00005  * This file is part of Libav.
00006  *
00007  * Libav is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU Lesser General Public
00009  * License as published by the Free Software Foundation; either
00010  * version 2.1 of the License, or (at your option) any later version.
00011  *
00012  * Libav is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015  * Lesser General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU Lesser General Public
00018  * License along with Libav; if not, write to the Free Software
00019  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00020  */
00021 
00027 /*
00028  * Based on http://wiki.multimedia.cx/index.php?title=Smacker
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  * Decoder context
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 /* common parameters used for decode_bigtree */
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 /* possible runs of blocks */
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)){ //Leaf
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 { //Node
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)){ //Leaf
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 { //Node
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){ // (((size + 3) >> 2) + 3) << 2 must not overflow
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         free_vlc(&vlc[0]);
00271     if(vlc[1].table)
00272         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 /* get code and update history */
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     /* make the palette available on the way out */
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')) { // In case of Smacker v4 we have three modes
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     /* always report that the buffer was completely consumed */
00511     return buf_size;
00512 }
00513 
00514 
00515 
00516 /*
00517  *
00518  * Init smacker decoder
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     /* decode huffman trees from extradata */
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  * Uninit smacker decoder
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     /* get output buffer */
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     // Initialize
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) { //decode 16-bit data
00664         for(i = stereo; i >= 0; i--)
00665             pred[i] = av_bswap16(get_bits(&gb, 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 { //8-bit data
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             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