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(!get_bits1(gb)){ //Leaf
00131         int val, i1, i2, b1, b2;
00132         if(hc->current >= hc->length){
00133             av_log(NULL, AV_LOG_ERROR, "Tree size exceeded!\n");
00134             return -1;
00135         }
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, 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 += smacker_decode_bigtree(gb, hc, ctx);
00168         return r;
00169     }
00170 }
00171 
00175 static int smacker_decode_header_tree(SmackVContext *smk, GetBitContext *gb, int **recodes, int *last, int size)
00176 {
00177     int res;
00178     HuffContext huff;
00179     HuffContext tmp1, tmp2;
00180     VLC vlc[2];
00181     int escapes[3];
00182     DBCtx ctx;
00183 
00184     if(size >= UINT_MAX>>4){ // (((size + 3) >> 2) + 3) << 2 must not overflow
00185         av_log(smk->avctx, AV_LOG_ERROR, "size too large\n");
00186         return -1;
00187     }
00188 
00189     tmp1.length = 256;
00190     tmp1.maxlength = 0;
00191     tmp1.current = 0;
00192     tmp1.bits = av_mallocz(256 * 4);
00193     tmp1.lengths = av_mallocz(256 * sizeof(int));
00194     tmp1.values = av_mallocz(256 * sizeof(int));
00195 
00196     tmp2.length = 256;
00197     tmp2.maxlength = 0;
00198     tmp2.current = 0;
00199     tmp2.bits = av_mallocz(256 * 4);
00200     tmp2.lengths = av_mallocz(256 * sizeof(int));
00201     tmp2.values = av_mallocz(256 * sizeof(int));
00202 
00203     memset(&vlc[0], 0, sizeof(VLC));
00204     memset(&vlc[1], 0, sizeof(VLC));
00205 
00206     if(get_bits1(gb)) {
00207         smacker_decode_tree(gb, &tmp1, 0, 0);
00208         skip_bits1(gb);
00209         res = init_vlc(&vlc[0], SMKTREE_BITS, tmp1.length,
00210                     tmp1.lengths, sizeof(int), sizeof(int),
00211                     tmp1.bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE);
00212         if(res < 0) {
00213             av_log(smk->avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
00214             return -1;
00215         }
00216     } else {
00217         av_log(smk->avctx, AV_LOG_ERROR, "Skipping low bytes tree\n");
00218     }
00219     if(get_bits1(gb)){
00220         smacker_decode_tree(gb, &tmp2, 0, 0);
00221         skip_bits1(gb);
00222         res = init_vlc(&vlc[1], SMKTREE_BITS, tmp2.length,
00223                     tmp2.lengths, sizeof(int), sizeof(int),
00224                     tmp2.bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE);
00225         if(res < 0) {
00226             av_log(smk->avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
00227             return -1;
00228         }
00229     } else {
00230         av_log(smk->avctx, AV_LOG_ERROR, "Skipping high bytes tree\n");
00231     }
00232 
00233     escapes[0]  = get_bits(gb, 8);
00234     escapes[0] |= get_bits(gb, 8) << 8;
00235     escapes[1]  = get_bits(gb, 8);
00236     escapes[1] |= get_bits(gb, 8) << 8;
00237     escapes[2]  = get_bits(gb, 8);
00238     escapes[2] |= get_bits(gb, 8) << 8;
00239 
00240     last[0] = last[1] = last[2] = -1;
00241 
00242     ctx.escapes[0] = escapes[0];
00243     ctx.escapes[1] = escapes[1];
00244     ctx.escapes[2] = escapes[2];
00245     ctx.v1 = &vlc[0];
00246     ctx.v2 = &vlc[1];
00247     ctx.recode1 = tmp1.values;
00248     ctx.recode2 = tmp2.values;
00249     ctx.last = last;
00250 
00251     huff.length = ((size + 3) >> 2) + 3;
00252     huff.maxlength = 0;
00253     huff.current = 0;
00254     huff.values = av_mallocz(huff.length * sizeof(int));
00255 
00256     smacker_decode_bigtree(gb, &huff, &ctx);
00257     skip_bits1(gb);
00258     if(ctx.last[0] == -1) ctx.last[0] = huff.current++;
00259     if(ctx.last[1] == -1) ctx.last[1] = huff.current++;
00260     if(ctx.last[2] == -1) ctx.last[2] = huff.current++;
00261 
00262     *recodes = huff.values;
00263 
00264     if(vlc[0].table)
00265         free_vlc(&vlc[0]);
00266     if(vlc[1].table)
00267         free_vlc(&vlc[1]);
00268     av_free(tmp1.bits);
00269     av_free(tmp1.lengths);
00270     av_free(tmp1.values);
00271     av_free(tmp2.bits);
00272     av_free(tmp2.lengths);
00273     av_free(tmp2.values);
00274 
00275     return 0;
00276 }
00277 
00278 static int decode_header_trees(SmackVContext *smk) {
00279     GetBitContext gb;
00280     int mmap_size, mclr_size, full_size, type_size;
00281 
00282     mmap_size = AV_RL32(smk->avctx->extradata);
00283     mclr_size = AV_RL32(smk->avctx->extradata + 4);
00284     full_size = AV_RL32(smk->avctx->extradata + 8);
00285     type_size = AV_RL32(smk->avctx->extradata + 12);
00286 
00287     init_get_bits(&gb, smk->avctx->extradata + 16, (smk->avctx->extradata_size - 16) * 8);
00288 
00289     if(!get_bits1(&gb)) {
00290         av_log(smk->avctx, AV_LOG_INFO, "Skipping MMAP tree\n");
00291         smk->mmap_tbl = av_malloc(sizeof(int) * 2);
00292         smk->mmap_tbl[0] = 0;
00293         smk->mmap_last[0] = smk->mmap_last[1] = smk->mmap_last[2] = 1;
00294     } else {
00295         if (smacker_decode_header_tree(smk, &gb, &smk->mmap_tbl, smk->mmap_last, mmap_size))
00296             return -1;
00297     }
00298     if(!get_bits1(&gb)) {
00299         av_log(smk->avctx, AV_LOG_INFO, "Skipping MCLR tree\n");
00300         smk->mclr_tbl = av_malloc(sizeof(int) * 2);
00301         smk->mclr_tbl[0] = 0;
00302         smk->mclr_last[0] = smk->mclr_last[1] = smk->mclr_last[2] = 1;
00303     } else {
00304         if (smacker_decode_header_tree(smk, &gb, &smk->mclr_tbl, smk->mclr_last, mclr_size))
00305             return -1;
00306     }
00307     if(!get_bits1(&gb)) {
00308         av_log(smk->avctx, AV_LOG_INFO, "Skipping FULL tree\n");
00309         smk->full_tbl = av_malloc(sizeof(int) * 2);
00310         smk->full_tbl[0] = 0;
00311         smk->full_last[0] = smk->full_last[1] = smk->full_last[2] = 1;
00312     } else {
00313         if (smacker_decode_header_tree(smk, &gb, &smk->full_tbl, smk->full_last, full_size))
00314             return -1;
00315     }
00316     if(!get_bits1(&gb)) {
00317         av_log(smk->avctx, AV_LOG_INFO, "Skipping TYPE tree\n");
00318         smk->type_tbl = av_malloc(sizeof(int) * 2);
00319         smk->type_tbl[0] = 0;
00320         smk->type_last[0] = smk->type_last[1] = smk->type_last[2] = 1;
00321     } else {
00322         if (smacker_decode_header_tree(smk, &gb, &smk->type_tbl, smk->type_last, type_size))
00323             return -1;
00324     }
00325 
00326     return 0;
00327 }
00328 
00329 static av_always_inline void last_reset(int *recode, int *last) {
00330     recode[last[0]] = recode[last[1]] = recode[last[2]] = 0;
00331 }
00332 
00333 /* get code and update history */
00334 static av_always_inline int smk_get_code(GetBitContext *gb, int *recode, int *last) {
00335     register int *table = recode;
00336     int v, b;
00337 
00338     b = get_bits_count(gb);
00339     while(*table & SMK_NODE) {
00340         if(get_bits1(gb))
00341             table += (*table) & (~SMK_NODE);
00342         table++;
00343     }
00344     v = *table;
00345     b = get_bits_count(gb) - b;
00346 
00347     if(v != recode[last[0]]) {
00348         recode[last[2]] = recode[last[1]];
00349         recode[last[1]] = recode[last[0]];
00350         recode[last[0]] = v;
00351     }
00352     return v;
00353 }
00354 
00355 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt)
00356 {
00357     const uint8_t *buf = avpkt->data;
00358     int buf_size = avpkt->size;
00359     SmackVContext * const smk = avctx->priv_data;
00360     uint8_t *out;
00361     uint32_t *pal;
00362     GetBitContext gb;
00363     int blocks, blk, bw, bh;
00364     int i;
00365     int stride;
00366 
00367     if(buf_size <= 769)
00368         return 0;
00369 
00370     smk->pic.reference = 1;
00371     smk->pic.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;
00372     if(avctx->reget_buffer(avctx, &smk->pic) < 0){
00373         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00374         return -1;
00375     }
00376 
00377     /* make the palette available on the way out */
00378     pal = (uint32_t*)smk->pic.data[1];
00379     smk->pic.palette_has_changed = buf[0] & 1;
00380     smk->pic.key_frame = !!(buf[0] & 2);
00381     if(smk->pic.key_frame)
00382         smk->pic.pict_type = AV_PICTURE_TYPE_I;
00383     else
00384         smk->pic.pict_type = AV_PICTURE_TYPE_P;
00385 
00386     buf++;
00387     for(i = 0; i < 256; i++)
00388         *pal++ = bytestream_get_be24(&buf);
00389     buf_size -= 769;
00390 
00391     last_reset(smk->mmap_tbl, smk->mmap_last);
00392     last_reset(smk->mclr_tbl, smk->mclr_last);
00393     last_reset(smk->full_tbl, smk->full_last);
00394     last_reset(smk->type_tbl, smk->type_last);
00395     init_get_bits(&gb, buf, buf_size * 8);
00396 
00397     blk = 0;
00398     bw = avctx->width >> 2;
00399     bh = avctx->height >> 2;
00400     blocks = bw * bh;
00401     out = smk->pic.data[0];
00402     stride = smk->pic.linesize[0];
00403     while(blk < blocks) {
00404         int type, run, mode;
00405         uint16_t pix;
00406 
00407         type = smk_get_code(&gb, smk->type_tbl, smk->type_last);
00408         run = block_runs[(type >> 2) & 0x3F];
00409         switch(type & 3){
00410         case SMK_BLK_MONO:
00411             while(run-- && blk < blocks){
00412                 int clr, map;
00413                 int hi, lo;
00414                 clr = smk_get_code(&gb, smk->mclr_tbl, smk->mclr_last);
00415                 map = smk_get_code(&gb, smk->mmap_tbl, smk->mmap_last);
00416                 out = smk->pic.data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
00417                 hi = clr >> 8;
00418                 lo = clr & 0xFF;
00419                 for(i = 0; i < 4; i++) {
00420                     if(map & 1) out[0] = hi; else out[0] = lo;
00421                     if(map & 2) out[1] = hi; else out[1] = lo;
00422                     if(map & 4) out[2] = hi; else out[2] = lo;
00423                     if(map & 8) out[3] = hi; else out[3] = lo;
00424                     map >>= 4;
00425                     out += stride;
00426                 }
00427                 blk++;
00428             }
00429             break;
00430         case SMK_BLK_FULL:
00431             mode = 0;
00432             if(avctx->codec_tag == MKTAG('S', 'M', 'K', '4')) { // In case of Smacker v4 we have three modes
00433                 if(get_bits1(&gb)) mode = 1;
00434                 else if(get_bits1(&gb)) mode = 2;
00435             }
00436             while(run-- && blk < blocks){
00437                 out = smk->pic.data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
00438                 switch(mode){
00439                 case 0:
00440                     for(i = 0; i < 4; i++) {
00441                         pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00442                         AV_WL16(out+2,pix);
00443                         pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00444                         AV_WL16(out,pix);
00445                         out += stride;
00446                     }
00447                     break;
00448                 case 1:
00449                     pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00450                     out[0] = out[1] = pix & 0xFF;
00451                     out[2] = out[3] = pix >> 8;
00452                     out += stride;
00453                     out[0] = out[1] = pix & 0xFF;
00454                     out[2] = out[3] = pix >> 8;
00455                     out += stride;
00456                     pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00457                     out[0] = out[1] = pix & 0xFF;
00458                     out[2] = out[3] = pix >> 8;
00459                     out += stride;
00460                     out[0] = out[1] = pix & 0xFF;
00461                     out[2] = out[3] = pix >> 8;
00462                     out += stride;
00463                     break;
00464                 case 2:
00465                     for(i = 0; i < 2; i++) {
00466                         uint16_t pix1, pix2;
00467                         pix2 = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00468                         pix1 = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00469                         AV_WL16(out,pix1);
00470                         AV_WL16(out+2,pix2);
00471                         out += stride;
00472                         AV_WL16(out,pix1);
00473                         AV_WL16(out+2,pix2);
00474                         out += stride;
00475                     }
00476                     break;
00477                 }
00478                 blk++;
00479             }
00480             break;
00481         case SMK_BLK_SKIP:
00482             while(run-- && blk < blocks)
00483                 blk++;
00484             break;
00485         case SMK_BLK_FILL:
00486             mode = type >> 8;
00487             while(run-- && blk < blocks){
00488                 uint32_t col;
00489                 out = smk->pic.data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
00490                 col = mode * 0x01010101;
00491                 for(i = 0; i < 4; i++) {
00492                     *((uint32_t*)out) = col;
00493                     out += stride;
00494                 }
00495                 blk++;
00496             }
00497             break;
00498         }
00499 
00500     }
00501 
00502     *data_size = sizeof(AVFrame);
00503     *(AVFrame*)data = smk->pic;
00504 
00505     /* always report that the buffer was completely consumed */
00506     return buf_size;
00507 }
00508 
00509 
00510 
00511 /*
00512  *
00513  * Init smacker decoder
00514  *
00515  */
00516 static av_cold int decode_init(AVCodecContext *avctx)
00517 {
00518     SmackVContext * const c = avctx->priv_data;
00519 
00520     c->avctx = avctx;
00521 
00522     avctx->pix_fmt = PIX_FMT_PAL8;
00523 
00524 
00525     /* decode huffman trees from extradata */
00526     if(avctx->extradata_size < 16){
00527         av_log(avctx, AV_LOG_ERROR, "Extradata missing!\n");
00528         return -1;
00529     }
00530 
00531     if (decode_header_trees(c))
00532         return -1;
00533 
00534     return 0;
00535 }
00536 
00537 
00538 
00539 /*
00540  *
00541  * Uninit smacker decoder
00542  *
00543  */
00544 static av_cold int decode_end(AVCodecContext *avctx)
00545 {
00546     SmackVContext * const smk = avctx->priv_data;
00547 
00548     av_freep(&smk->mmap_tbl);
00549     av_freep(&smk->mclr_tbl);
00550     av_freep(&smk->full_tbl);
00551     av_freep(&smk->type_tbl);
00552 
00553     if (smk->pic.data[0])
00554         avctx->release_buffer(avctx, &smk->pic);
00555 
00556     return 0;
00557 }
00558 
00559 
00560 static av_cold int smka_decode_init(AVCodecContext *avctx)
00561 {
00562     avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
00563     avctx->sample_fmt = avctx->bits_per_coded_sample == 8 ? AV_SAMPLE_FMT_U8 : AV_SAMPLE_FMT_S16;
00564     return 0;
00565 }
00566 
00570 static int smka_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt)
00571 {
00572     const uint8_t *buf = avpkt->data;
00573     int buf_size = avpkt->size;
00574     GetBitContext gb;
00575     HuffContext h[4];
00576     VLC vlc[4];
00577     int16_t *samples = data;
00578     int8_t *samples8 = data;
00579     int val;
00580     int i, res;
00581     int unp_size;
00582     int bits, stereo;
00583     int pred[2] = {0, 0};
00584 
00585     unp_size = AV_RL32(buf);
00586 
00587     init_get_bits(&gb, buf + 4, (buf_size - 4) * 8);
00588 
00589     if(!get_bits1(&gb)){
00590         av_log(avctx, AV_LOG_INFO, "Sound: no data\n");
00591         *data_size = 0;
00592         return 1;
00593     }
00594     stereo = get_bits1(&gb);
00595     bits = get_bits1(&gb);
00596     if (unp_size & 0xC0000000 || unp_size > *data_size) {
00597         av_log(avctx, AV_LOG_ERROR, "Frame is too large to fit in buffer\n");
00598         return -1;
00599     }
00600 
00601     memset(vlc, 0, sizeof(VLC) * 4);
00602     memset(h, 0, sizeof(HuffContext) * 4);
00603     // Initialize
00604     for(i = 0; i < (1 << (bits + stereo)); i++) {
00605         h[i].length = 256;
00606         h[i].maxlength = 0;
00607         h[i].current = 0;
00608         h[i].bits = av_mallocz(256 * 4);
00609         h[i].lengths = av_mallocz(256 * sizeof(int));
00610         h[i].values = av_mallocz(256 * sizeof(int));
00611         skip_bits1(&gb);
00612         smacker_decode_tree(&gb, &h[i], 0, 0);
00613         skip_bits1(&gb);
00614         if(h[i].current > 1) {
00615             res = init_vlc(&vlc[i], SMKTREE_BITS, h[i].length,
00616                     h[i].lengths, sizeof(int), sizeof(int),
00617                     h[i].bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE);
00618             if(res < 0) {
00619                 av_log(avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
00620                 return -1;
00621             }
00622         }
00623     }
00624     if(bits) { //decode 16-bit data
00625         for(i = stereo; i >= 0; i--)
00626             pred[i] = av_bswap16(get_bits(&gb, 16));
00627         for(i = 0; i <= stereo; i++)
00628             *samples++ = pred[i];
00629         for(; i < unp_size / 2; i++) {
00630             if(i & stereo) {
00631                 if(vlc[2].table)
00632                     res = get_vlc2(&gb, vlc[2].table, SMKTREE_BITS, 3);
00633                 else
00634                     res = 0;
00635                 val  = h[2].values[res];
00636                 if(vlc[3].table)
00637                     res = get_vlc2(&gb, vlc[3].table, SMKTREE_BITS, 3);
00638                 else
00639                     res = 0;
00640                 val |= h[3].values[res] << 8;
00641                 pred[1] += (int16_t)val;
00642                 *samples++ = pred[1];
00643             } else {
00644                 if(vlc[0].table)
00645                     res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
00646                 else
00647                     res = 0;
00648                 val  = h[0].values[res];
00649                 if(vlc[1].table)
00650                     res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
00651                 else
00652                     res = 0;
00653                 val |= h[1].values[res] << 8;
00654                 pred[0] += val;
00655                 *samples++ = pred[0];
00656             }
00657         }
00658     } else { //8-bit data
00659         for(i = stereo; i >= 0; i--)
00660             pred[i] = get_bits(&gb, 8);
00661         for(i = 0; i <= stereo; i++)
00662             *samples8++ = pred[i];
00663         for(; i < unp_size; i++) {
00664             if(i & stereo){
00665                 if(vlc[1].table)
00666                     res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
00667                 else
00668                     res = 0;
00669                 pred[1] += (int8_t)h[1].values[res];
00670                 *samples8++ = pred[1];
00671             } else {
00672                 if(vlc[0].table)
00673                     res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
00674                 else
00675                     res = 0;
00676                 pred[0] += (int8_t)h[0].values[res];
00677                 *samples8++ = pred[0];
00678             }
00679         }
00680     }
00681 
00682     for(i = 0; i < 4; i++) {
00683         if(vlc[i].table)
00684             free_vlc(&vlc[i]);
00685         av_free(h[i].bits);
00686         av_free(h[i].lengths);
00687         av_free(h[i].values);
00688     }
00689 
00690     *data_size = unp_size;
00691     return buf_size;
00692 }
00693 
00694 AVCodec ff_smacker_decoder = {
00695     "smackvid",
00696     AVMEDIA_TYPE_VIDEO,
00697     CODEC_ID_SMACKVIDEO,
00698     sizeof(SmackVContext),
00699     decode_init,
00700     NULL,
00701     decode_end,
00702     decode_frame,
00703     CODEC_CAP_DR1,
00704     .long_name = NULL_IF_CONFIG_SMALL("Smacker video"),
00705 };
00706 
00707 AVCodec ff_smackaud_decoder = {
00708     "smackaud",
00709     AVMEDIA_TYPE_AUDIO,
00710     CODEC_ID_SMACKAUDIO,
00711     0,
00712     smka_decode_init,
00713     NULL,
00714     NULL,
00715     smka_decode_frame,
00716     .long_name = NULL_IF_CONFIG_SMALL("Smacker audio"),
00717 };
00718