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