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