• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • File List
  • Globals

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

Generated on Fri Sep 16 2011 17:17:43 for FFmpeg by  doxygen 1.7.1