• 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 "bitstream.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, const uint8_t *buf, int buf_size)
00349 {
00350     SmackVContext * const smk = avctx->priv_data;
00351     uint8_t *out;
00352     uint32_t *pal;
00353     GetBitContext gb;
00354     int blocks, blk, bw, bh;
00355     int i;
00356     int stride;
00357 
00358     if(buf_size <= 769)
00359         return 0;
00360     if(smk->pic.data[0])
00361             avctx->release_buffer(avctx, &smk->pic);
00362 
00363     smk->pic.reference = 1;
00364     smk->pic.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;
00365     if(avctx->reget_buffer(avctx, &smk->pic) < 0){
00366         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00367         return -1;
00368     }
00369 
00370     /* make the palette available on the way out */
00371     pal = (uint32_t*)smk->pic.data[1];
00372     smk->pic.palette_has_changed = buf[0] & 1;
00373     smk->pic.key_frame = !!(buf[0] & 2);
00374     if(smk->pic.key_frame)
00375         smk->pic.pict_type = FF_I_TYPE;
00376     else
00377         smk->pic.pict_type = FF_P_TYPE;
00378 
00379     buf++;
00380     for(i = 0; i < 256; i++)
00381         *pal++ = bytestream_get_be24(&buf);
00382     buf_size -= 769;
00383 
00384     last_reset(smk->mmap_tbl, smk->mmap_last);
00385     last_reset(smk->mclr_tbl, smk->mclr_last);
00386     last_reset(smk->full_tbl, smk->full_last);
00387     last_reset(smk->type_tbl, smk->type_last);
00388     init_get_bits(&gb, buf, buf_size * 8);
00389 
00390     blk = 0;
00391     bw = avctx->width >> 2;
00392     bh = avctx->height >> 2;
00393     blocks = bw * bh;
00394     out = smk->pic.data[0];
00395     stride = smk->pic.linesize[0];
00396     while(blk < blocks) {
00397         int type, run, mode;
00398         uint16_t pix;
00399 
00400         type = smk_get_code(&gb, smk->type_tbl, smk->type_last);
00401         run = block_runs[(type >> 2) & 0x3F];
00402         switch(type & 3){
00403         case SMK_BLK_MONO:
00404             while(run-- && blk < blocks){
00405                 int clr, map;
00406                 int hi, lo;
00407                 clr = smk_get_code(&gb, smk->mclr_tbl, smk->mclr_last);
00408                 map = smk_get_code(&gb, smk->mmap_tbl, smk->mmap_last);
00409                 out = smk->pic.data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
00410                 hi = clr >> 8;
00411                 lo = clr & 0xFF;
00412                 for(i = 0; i < 4; i++) {
00413                     if(map & 1) out[0] = hi; else out[0] = lo;
00414                     if(map & 2) out[1] = hi; else out[1] = lo;
00415                     if(map & 4) out[2] = hi; else out[2] = lo;
00416                     if(map & 8) out[3] = hi; else out[3] = lo;
00417                     map >>= 4;
00418                     out += stride;
00419                 }
00420                 blk++;
00421             }
00422             break;
00423         case SMK_BLK_FULL:
00424             mode = 0;
00425             if(avctx->codec_tag == MKTAG('S', 'M', 'K', '4')) { // In case of Smacker v4 we have three modes
00426                 if(get_bits1(&gb)) mode = 1;
00427                 else if(get_bits1(&gb)) mode = 2;
00428             }
00429             while(run-- && blk < blocks){
00430                 out = smk->pic.data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
00431                 switch(mode){
00432                 case 0:
00433                     for(i = 0; i < 4; i++) {
00434                         pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00435                         AV_WL16(out+2,pix);
00436                         pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00437                         AV_WL16(out,pix);
00438                         out += stride;
00439                     }
00440                     break;
00441                 case 1:
00442                     pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00443                     out[0] = out[1] = pix & 0xFF;
00444                     out[2] = out[3] = pix >> 8;
00445                     out += stride;
00446                     out[0] = out[1] = pix & 0xFF;
00447                     out[2] = out[3] = pix >> 8;
00448                     out += stride;
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                     break;
00457                 case 2:
00458                     for(i = 0; i < 2; i++) {
00459                         uint16_t pix1, pix2;
00460                         pix2 = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00461                         pix1 = smk_get_code(&gb, smk->full_tbl, smk->full_last);
00462                         AV_WL16(out,pix1);
00463                         AV_WL16(out+2,pix2);
00464                         out += stride;
00465                         AV_WL16(out,pix1);
00466                         AV_WL16(out+2,pix2);
00467                         out += stride;
00468                     }
00469                     break;
00470                 }
00471                 blk++;
00472             }
00473             break;
00474         case SMK_BLK_SKIP:
00475             while(run-- && blk < blocks)
00476                 blk++;
00477             break;
00478         case SMK_BLK_FILL:
00479             mode = type >> 8;
00480             while(run-- && blk < blocks){
00481                 uint32_t col;
00482                 out = smk->pic.data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
00483                 col = mode * 0x01010101;
00484                 for(i = 0; i < 4; i++) {
00485                     *((uint32_t*)out) = col;
00486                     out += stride;
00487                 }
00488                 blk++;
00489             }
00490             break;
00491         }
00492 
00493     }
00494 
00495     *data_size = sizeof(AVFrame);
00496     *(AVFrame*)data = smk->pic;
00497 
00498     /* always report that the buffer was completely consumed */
00499     return buf_size;
00500 }
00501 
00502 
00503 
00504 /*
00505  *
00506  * Init smacker decoder
00507  *
00508  */
00509 static av_cold int decode_init(AVCodecContext *avctx)
00510 {
00511     SmackVContext * const c = avctx->priv_data;
00512 
00513     c->avctx = avctx;
00514 
00515     c->pic.data[0] = NULL;
00516 
00517     if (avcodec_check_dimensions(avctx, avctx->width, avctx->height) < 0) {
00518         return 1;
00519     }
00520 
00521     avctx->pix_fmt = PIX_FMT_PAL8;
00522 
00523 
00524     /* decode huffman trees from extradata */
00525     if(avctx->extradata_size < 16){
00526         av_log(avctx, AV_LOG_ERROR, "Extradata missing!\n");
00527         return -1;
00528     }
00529 
00530     decode_header_trees(c);
00531 
00532 
00533     return 0;
00534 }
00535 
00536 
00537 
00538 /*
00539  *
00540  * Uninit smacker decoder
00541  *
00542  */
00543 static av_cold int decode_end(AVCodecContext *avctx)
00544 {
00545     SmackVContext * const smk = avctx->priv_data;
00546 
00547     av_freep(&smk->mmap_tbl);
00548     av_freep(&smk->mclr_tbl);
00549     av_freep(&smk->full_tbl);
00550     av_freep(&smk->type_tbl);
00551 
00552     if (smk->pic.data[0])
00553         avctx->release_buffer(avctx, &smk->pic);
00554 
00555     return 0;
00556 }
00557 
00558 
00559 static av_cold int smka_decode_init(AVCodecContext *avctx)
00560 {
00561     avctx->sample_fmt = SAMPLE_FMT_S16;
00562     avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO;
00563     return 0;
00564 }
00565 
00569 static int smka_decode_frame(AVCodecContext *avctx, void *data, int *data_size, const uint8_t *buf, int buf_size)
00570 {
00571     GetBitContext gb;
00572     HuffContext h[4];
00573     VLC vlc[4];
00574     int16_t *samples = data;
00575     int val;
00576     int i, res;
00577     int unp_size;
00578     int bits, stereo;
00579     int pred[2] = {0, 0};
00580 
00581     unp_size = AV_RL32(buf);
00582 
00583     init_get_bits(&gb, buf + 4, (buf_size - 4) * 8);
00584 
00585     if(!get_bits1(&gb)){
00586         av_log(avctx, AV_LOG_INFO, "Sound: no data\n");
00587         *data_size = 0;
00588         return 1;
00589     }
00590     stereo = get_bits1(&gb);
00591     bits = get_bits1(&gb);
00592     if (unp_size & 0xC0000000 || (unp_size << !bits) > *data_size) {
00593         av_log(avctx, AV_LOG_ERROR, "Frame is too large to fit in buffer\n");
00594         return -1;
00595     }
00596 
00597     memset(vlc, 0, sizeof(VLC) * 4);
00598     memset(h, 0, sizeof(HuffContext) * 4);
00599     // Initialize
00600     for(i = 0; i < (1 << (bits + stereo)); i++) {
00601         h[i].length = 256;
00602         h[i].maxlength = 0;
00603         h[i].current = 0;
00604         h[i].bits = av_mallocz(256 * 4);
00605         h[i].lengths = av_mallocz(256 * sizeof(int));
00606         h[i].values = av_mallocz(256 * sizeof(int));
00607         skip_bits1(&gb);
00608         smacker_decode_tree(&gb, &h[i], 0, 0);
00609         skip_bits1(&gb);
00610         if(h[i].current > 1) {
00611             res = init_vlc(&vlc[i], SMKTREE_BITS, h[i].length,
00612                     h[i].lengths, sizeof(int), sizeof(int),
00613                     h[i].bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE);
00614             if(res < 0) {
00615                 av_log(avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
00616                 return -1;
00617             }
00618         }
00619     }
00620     if(bits) { //decode 16-bit data
00621         for(i = stereo; i >= 0; i--)
00622             pred[i] = bswap_16(get_bits(&gb, 16));
00623         for(i = 0; i < stereo; i++)
00624             *samples++ = pred[i];
00625         for(i = 0; i < unp_size / 2; i++) {
00626             if(i & stereo) {
00627                 if(vlc[2].table)
00628                     res = get_vlc2(&gb, vlc[2].table, SMKTREE_BITS, 3);
00629                 else
00630                     res = 0;
00631                 val  = h[2].values[res];
00632                 if(vlc[3].table)
00633                     res = get_vlc2(&gb, vlc[3].table, SMKTREE_BITS, 3);
00634                 else
00635                     res = 0;
00636                 val |= h[3].values[res] << 8;
00637                 pred[1] += (int16_t)val;
00638                 *samples++ = pred[1];
00639             } else {
00640                 if(vlc[0].table)
00641                     res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
00642                 else
00643                     res = 0;
00644                 val  = h[0].values[res];
00645                 if(vlc[1].table)
00646                     res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
00647                 else
00648                     res = 0;
00649                 val |= h[1].values[res] << 8;
00650                 pred[0] += val;
00651                 *samples++ = pred[0];
00652             }
00653         }
00654     } else { //8-bit data
00655         for(i = stereo; i >= 0; i--)
00656             pred[i] = get_bits(&gb, 8);
00657         for(i = 0; i < stereo; i++)
00658             *samples++ = (pred[i] - 0x80) << 8;
00659         for(i = 0; i < unp_size; i++) {
00660             if(i & stereo){
00661                 if(vlc[1].table)
00662                     res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
00663                 else
00664                     res = 0;
00665                 pred[1] += (int8_t)h[1].values[res];
00666                 *samples++ = (pred[1] - 0x80) << 8;
00667             } else {
00668                 if(vlc[0].table)
00669                     res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
00670                 else
00671                     res = 0;
00672                 pred[0] += (int8_t)h[0].values[res];
00673                 *samples++ = (pred[0] - 0x80) << 8;
00674             }
00675         }
00676         unp_size *= 2;
00677     }
00678 
00679     for(i = 0; i < 4; i++) {
00680         if(vlc[i].table)
00681             free_vlc(&vlc[i]);
00682         if(h[i].bits)
00683             av_free(h[i].bits);
00684         if(h[i].lengths)
00685             av_free(h[i].lengths);
00686         if(h[i].values)
00687             av_free(h[i].values);
00688     }
00689 
00690     *data_size = unp_size;
00691     return buf_size;
00692 }
00693 
00694 AVCodec smacker_decoder = {
00695     "smackvid",
00696     CODEC_TYPE_VIDEO,
00697     CODEC_ID_SMACKVIDEO,
00698     sizeof(SmackVContext),
00699     decode_init,
00700     NULL,
00701     decode_end,
00702     decode_frame,
00703     .long_name = NULL_IF_CONFIG_SMALL("Smacker video"),
00704 };
00705 
00706 AVCodec smackaud_decoder = {
00707     "smackaud",
00708     CODEC_TYPE_AUDIO,
00709     CODEC_ID_SMACKAUDIO,
00710     0,
00711     smka_decode_init,
00712     NULL,
00713     NULL,
00714     smka_decode_frame,
00715     .long_name = NULL_IF_CONFIG_SMALL("Smacker audio"),
00716 };
00717 

Generated on Tue Nov 4 2014 12:59:22 for ffmpeg by  doxygen 1.7.1