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) + 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 /* get code and update history */
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     /* make the palette available on the way out */
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')) { // In case of Smacker v4 we have three modes
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     /* always report that the buffer was completely consumed */
00517     return buf_size;
00518 }
00519 
00520 
00521 
00522 /*
00523  *
00524  * Init smacker decoder
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     /* decode huffman trees from extradata */
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  * Uninit smacker decoder
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     /* get output buffer */
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     // Initialize
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) { //decode 16-bit data
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 { //8-bit data
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