wma encoder
authorMichael Niedermayer <michaelni@gmx.at>
Tue, 6 Feb 2007 20:19:04 +0000 (20:19 +0000)
committerMichael Niedermayer <michaelni@gmx.at>
Tue, 6 Feb 2007 20:19:04 +0000 (20:19 +0000)
Originally committed as revision 7855 to svn://svn.ffmpeg.org/ffmpeg/trunk

libavcodec/Makefile
libavcodec/allcodecs.c
libavcodec/avcodec.h
libavcodec/wma.c [new file with mode: 0644]
libavcodec/wma.h [new file with mode: 0644]
libavcodec/wmadata.h
libavcodec/wmadec.c
libavcodec/wmaenc.c [new file with mode: 0644]

index 8b3c96b..23bdbf8 100644 (file)
@@ -159,8 +159,10 @@ OBJS-$(CONFIG_VP5_DECODER)             += vp5.o vp56.o vp56data.o
 OBJS-$(CONFIG_VP6_DECODER)             += vp6.o vp56.o vp56data.o
 OBJS-$(CONFIG_VQA_DECODER)             += vqavideo.o
 OBJS-$(CONFIG_WAVPACK_DECODER)         += wavpack.o
-OBJS-$(CONFIG_WMAV1_DECODER)           += wmadec.o
-OBJS-$(CONFIG_WMAV2_DECODER)           += wmadec.o
+OBJS-$(CONFIG_WMAV1_DECODER)           += wmadec.o wma.o
+OBJS-$(CONFIG_WMAV2_DECODER)           += wmadec.o wma.o
+OBJS-$(CONFIG_WMAV1_ENCODER)           += wmaenc.o wma.o
+OBJS-$(CONFIG_WMAV2_ENCODER)           += wmaenc.o wma.o
 OBJS-$(CONFIG_WMV3_DECODER)            += vc1.o vc1dsp.o
 OBJS-$(CONFIG_WNV1_DECODER)            += wnv1.o
 OBJS-$(CONFIG_WS_SND1_DECODER)         += ws-snd1.o
index a2c88c8..3c1d67c 100644 (file)
@@ -187,8 +187,8 @@ void avcodec_register_all(void)
     REGISTER_DECODER(VMDAUDIO, vmdaudio);
     REGISTER_ENCDEC (VORBIS, vorbis);
     REGISTER_DECODER(WAVPACK, wavpack);
-    REGISTER_DECODER(WMAV1, wmav1);
-    REGISTER_DECODER(WMAV2, wmav2);
+    REGISTER_ENCDEC(WMAV1, wmav1);
+    REGISTER_ENCDEC(WMAV2, wmav2);
     REGISTER_DECODER(WS_SND1, ws_snd1);
 
     /* pcm codecs */
index 497439b..a340fd7 100644 (file)
@@ -37,8 +37,8 @@ extern "C" {
 #define AV_STRINGIFY(s)         AV_TOSTRING(s)
 #define AV_TOSTRING(s) #s
 
-#define LIBAVCODEC_VERSION_INT  ((51<<16)+(31<<8)+0)
-#define LIBAVCODEC_VERSION      51.31.0
+#define LIBAVCODEC_VERSION_INT  ((51<<16)+(32<<8)+0)
+#define LIBAVCODEC_VERSION      51.32.0
 #define LIBAVCODEC_BUILD        LIBAVCODEC_VERSION_INT
 
 #define LIBAVCODEC_IDENT        "Lavc" AV_STRINGIFY(LIBAVCODEC_VERSION)
@@ -2192,6 +2192,8 @@ extern AVCodec sonic_ls_encoder;
 extern AVCodec svq1_encoder;
 extern AVCodec vcr1_encoder;
 extern AVCodec vorbis_encoder;
+extern AVCodec wmav1_encoder;
+extern AVCodec wmav2_encoder;
 extern AVCodec wmv1_encoder;
 extern AVCodec wmv2_encoder;
 extern AVCodec x264_encoder;
diff --git a/libavcodec/wma.c b/libavcodec/wma.c
new file mode 100644 (file)
index 0000000..31a417a
--- /dev/null
@@ -0,0 +1,386 @@
+/*
+ * WMA compatible codec
+ * Copyright (c) 2002-2007 The FFmpeg Project.
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "avcodec.h"
+#include "wma.h"
+#include "wmadata.h"
+
+#undef NDEBUG
+#include <assert.h>
+
+/* XXX: use same run/length optimization as mpeg decoders */
+//FIXME maybe split decode / encode or pass flag
+static void init_coef_vlc(VLC *vlc,
+                          uint16_t **prun_table, uint16_t **plevel_table, uint16_t **pint_table,
+                          const CoefVLCTable *vlc_table)
+{
+    int n = vlc_table->n;
+    const uint8_t *table_bits = vlc_table->huffbits;
+    const uint32_t *table_codes = vlc_table->huffcodes;
+    const uint16_t *levels_table = vlc_table->levels;
+    uint16_t *run_table, *level_table, *int_table;
+    int i, l, j, k, level;
+
+    init_vlc(vlc, VLCBITS, n, table_bits, 1, 1, table_codes, 4, 4, 0);
+
+    run_table = av_malloc(n * sizeof(uint16_t));
+    level_table = av_malloc(n * sizeof(uint16_t));
+    int_table = av_malloc(n * sizeof(uint16_t));
+    i = 2;
+    level = 1;
+    k = 0;
+    while (i < n) {
+        int_table[k]= i;
+        l = levels_table[k++];
+        for(j=0;j<l;j++) {
+            run_table[i] = j;
+            level_table[i] = level;
+            i++;
+        }
+        level++;
+    }
+    *prun_table = run_table;
+    *plevel_table = level_table;
+    *pint_table= int_table;
+}
+
+int ff_wma_init(AVCodecContext * avctx, int flags2)
+{
+    WMADecodeContext *s = avctx->priv_data;
+    int i;
+    float *window;
+    float bps1, high_freq;
+    volatile float bps;
+    int sample_rate1;
+    int coef_vlc_table;
+
+    s->sample_rate = avctx->sample_rate;
+    s->nb_channels = avctx->channels;
+    s->bit_rate = avctx->bit_rate;
+    s->block_align = avctx->block_align;
+
+    dsputil_init(&s->dsp, avctx);
+
+    if (avctx->codec->id == CODEC_ID_WMAV1) {
+        s->version = 1;
+    } else {
+        s->version = 2;
+    }
+
+    /* compute MDCT block size */
+    if (s->sample_rate <= 16000) {
+        s->frame_len_bits = 9;
+    } else if (s->sample_rate <= 22050 ||
+               (s->sample_rate <= 32000 && s->version == 1)) {
+        s->frame_len_bits = 10;
+    } else {
+        s->frame_len_bits = 11;
+    }
+    s->frame_len = 1 << s->frame_len_bits;
+    if (s->use_variable_block_len) {
+        int nb_max, nb;
+        nb = ((flags2 >> 3) & 3) + 1;
+        if ((s->bit_rate / s->nb_channels) >= 32000)
+            nb += 2;
+        nb_max = s->frame_len_bits - BLOCK_MIN_BITS;
+        if (nb > nb_max)
+            nb = nb_max;
+        s->nb_block_sizes = nb + 1;
+    } else {
+        s->nb_block_sizes = 1;
+    }
+
+    /* init rate dependant parameters */
+    s->use_noise_coding = 1;
+    high_freq = s->sample_rate * 0.5;
+
+    /* if version 2, then the rates are normalized */
+    sample_rate1 = s->sample_rate;
+    if (s->version == 2) {
+        if (sample_rate1 >= 44100)
+            sample_rate1 = 44100;
+        else if (sample_rate1 >= 22050)
+            sample_rate1 = 22050;
+        else if (sample_rate1 >= 16000)
+            sample_rate1 = 16000;
+        else if (sample_rate1 >= 11025)
+            sample_rate1 = 11025;
+        else if (sample_rate1 >= 8000)
+            sample_rate1 = 8000;
+    }
+
+    bps = (float)s->bit_rate / (float)(s->nb_channels * s->sample_rate);
+    s->byte_offset_bits = av_log2((int)(bps * s->frame_len / 8.0 + 0.5)) + 2;
+
+    /* compute high frequency value and choose if noise coding should
+       be activated */
+    bps1 = bps;
+    if (s->nb_channels == 2)
+        bps1 = bps * 1.6;
+    if (sample_rate1 == 44100) {
+        if (bps1 >= 0.61)
+            s->use_noise_coding = 0;
+        else
+            high_freq = high_freq * 0.4;
+    } else if (sample_rate1 == 22050) {
+        if (bps1 >= 1.16)
+            s->use_noise_coding = 0;
+        else if (bps1 >= 0.72)
+            high_freq = high_freq * 0.7;
+        else
+            high_freq = high_freq * 0.6;
+    } else if (sample_rate1 == 16000) {
+        if (bps > 0.5)
+            high_freq = high_freq * 0.5;
+        else
+            high_freq = high_freq * 0.3;
+    } else if (sample_rate1 == 11025) {
+        high_freq = high_freq * 0.7;
+    } else if (sample_rate1 == 8000) {
+        if (bps <= 0.625) {
+            high_freq = high_freq * 0.5;
+        } else if (bps > 0.75) {
+            s->use_noise_coding = 0;
+        } else {
+            high_freq = high_freq * 0.65;
+        }
+    } else {
+        if (bps >= 0.8) {
+            high_freq = high_freq * 0.75;
+        } else if (bps >= 0.6) {
+            high_freq = high_freq * 0.6;
+        } else {
+            high_freq = high_freq * 0.5;
+        }
+    }
+    dprintf("flags1=0x%x flags2=0x%x\n", flags1, flags2);
+    dprintf("version=%d channels=%d sample_rate=%d bitrate=%d block_align=%d\n",
+           s->version, s->nb_channels, s->sample_rate, s->bit_rate,
+           s->block_align);
+    dprintf("bps=%f bps1=%f high_freq=%f bitoffset=%d\n",
+           bps, bps1, high_freq, s->byte_offset_bits);
+    dprintf("use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n",
+           s->use_noise_coding, s->use_exp_vlc, s->nb_block_sizes);
+
+    /* compute the scale factor band sizes for each MDCT block size */
+    {
+        int a, b, pos, lpos, k, block_len, i, j, n;
+        const uint8_t *table;
+
+        if (s->version == 1) {
+            s->coefs_start = 3;
+        } else {
+            s->coefs_start = 0;
+        }
+        for(k = 0; k < s->nb_block_sizes; k++) {
+            block_len = s->frame_len >> k;
+
+            if (s->version == 1) {
+                lpos = 0;
+                for(i=0;i<25;i++) {
+                    a = wma_critical_freqs[i];
+                    b = s->sample_rate;
+                    pos = ((block_len * 2 * a)  + (b >> 1)) / b;
+                    if (pos > block_len)
+                        pos = block_len;
+                    s->exponent_bands[0][i] = pos - lpos;
+                    if (pos >= block_len) {
+                        i++;
+                        break;
+                    }
+                    lpos = pos;
+                }
+                s->exponent_sizes[0] = i;
+            } else {
+                /* hardcoded tables */
+                table = NULL;
+                a = s->frame_len_bits - BLOCK_MIN_BITS - k;
+                if (a < 3) {
+                    if (s->sample_rate >= 44100)
+                        table = exponent_band_44100[a];
+                    else if (s->sample_rate >= 32000)
+                        table = exponent_band_32000[a];
+                    else if (s->sample_rate >= 22050)
+                        table = exponent_band_22050[a];
+                }
+                if (table) {
+                    n = *table++;
+                    for(i=0;i<n;i++)
+                        s->exponent_bands[k][i] = table[i];
+                    s->exponent_sizes[k] = n;
+                } else {
+                    j = 0;
+                    lpos = 0;
+                    for(i=0;i<25;i++) {
+                        a = wma_critical_freqs[i];
+                        b = s->sample_rate;
+                        pos = ((block_len * 2 * a)  + (b << 1)) / (4 * b);
+                        pos <<= 2;
+                        if (pos > block_len)
+                            pos = block_len;
+                        if (pos > lpos)
+                            s->exponent_bands[k][j++] = pos - lpos;
+                        if (pos >= block_len)
+                            break;
+                        lpos = pos;
+                    }
+                    s->exponent_sizes[k] = j;
+                }
+            }
+
+            /* max number of coefs */
+            s->coefs_end[k] = (s->frame_len - ((s->frame_len * 9) / 100)) >> k;
+            /* high freq computation */
+            s->high_band_start[k] = (int)((block_len * 2 * high_freq) /
+                                          s->sample_rate + 0.5);
+            n = s->exponent_sizes[k];
+            j = 0;
+            pos = 0;
+            for(i=0;i<n;i++) {
+                int start, end;
+                start = pos;
+                pos += s->exponent_bands[k][i];
+                end = pos;
+                if (start < s->high_band_start[k])
+                    start = s->high_band_start[k];
+                if (end > s->coefs_end[k])
+                    end = s->coefs_end[k];
+                if (end > start)
+                    s->exponent_high_bands[k][j++] = end - start;
+            }
+            s->exponent_high_sizes[k] = j;
+#if 0
+            tprintf("%5d: coefs_end=%d high_band_start=%d nb_high_bands=%d: ",
+                  s->frame_len >> k,
+                  s->coefs_end[k],
+                  s->high_band_start[k],
+                  s->exponent_high_sizes[k]);
+            for(j=0;j<s->exponent_high_sizes[k];j++)
+                tprintf(" %d", s->exponent_high_bands[k][j]);
+            tprintf("\n");
+#endif
+        }
+    }
+
+#ifdef TRACE
+    {
+        int i, j;
+        for(i = 0; i < s->nb_block_sizes; i++) {
+            tprintf("%5d: n=%2d:",
+                   s->frame_len >> i,
+                   s->exponent_sizes[i]);
+            for(j=0;j<s->exponent_sizes[i];j++)
+                tprintf(" %d", s->exponent_bands[i][j]);
+            tprintf("\n");
+        }
+    }
+#endif
+
+    /* init MDCT windows : simple sinus window */
+    for(i = 0; i < s->nb_block_sizes; i++) {
+        int n, j;
+        float alpha;
+        n = 1 << (s->frame_len_bits - i);
+        window = av_malloc(sizeof(float) * n);
+        alpha = M_PI / (2.0 * n);
+        for(j=0;j<n;j++) {
+            window[n - j - 1] = sin((j + 0.5) * alpha);
+        }
+        s->windows[i] = window;
+    }
+
+    s->reset_block_lengths = 1;
+
+    if (s->use_noise_coding) {
+
+        /* init the noise generator */
+        if (s->use_exp_vlc)
+            s->noise_mult = 0.02;
+        else
+            s->noise_mult = 0.04;
+
+#ifdef TRACE
+        for(i=0;i<NOISE_TAB_SIZE;i++)
+            s->noise_table[i] = 1.0 * s->noise_mult;
+#else
+        {
+            unsigned int seed;
+            float norm;
+            seed = 1;
+            norm = (1.0 / (float)(1LL << 31)) * sqrt(3) * s->noise_mult;
+            for(i=0;i<NOISE_TAB_SIZE;i++) {
+                seed = seed * 314159 + 1;
+                s->noise_table[i] = (float)((int)seed) * norm;
+            }
+        }
+#endif
+    }
+
+    /* choose the VLC tables for the coefficients */
+    coef_vlc_table = 2;
+    if (s->sample_rate >= 32000) {
+        if (bps1 < 0.72)
+            coef_vlc_table = 0;
+        else if (bps1 < 1.16)
+            coef_vlc_table = 1;
+    }
+    s->coef_vlcs[0]= &coef_vlcs[coef_vlc_table * 2    ];
+    s->coef_vlcs[1]= &coef_vlcs[coef_vlc_table * 2 + 1];
+    init_coef_vlc(&s->coef_vlc[0], &s->run_table[0], &s->level_table[0], &s->int_table[0],
+                  s->coef_vlcs[0]);
+    init_coef_vlc(&s->coef_vlc[1], &s->run_table[1], &s->level_table[1], &s->int_table[1],
+                  s->coef_vlcs[1]);
+
+    return 0;
+}
+
+int ff_wma_total_gain_to_bits(int total_gain){
+         if (total_gain < 15) return 13;
+    else if (total_gain < 32) return 12;
+    else if (total_gain < 40) return 11;
+    else if (total_gain < 45) return 10;
+    else                      return  9;
+}
+
+int ff_wma_end(AVCodecContext *avctx)
+{
+    WMADecodeContext *s = avctx->priv_data;
+    int i;
+
+    for(i = 0; i < s->nb_block_sizes; i++)
+        ff_mdct_end(&s->mdct_ctx[i]);
+    for(i = 0; i < s->nb_block_sizes; i++)
+        av_free(s->windows[i]);
+
+    if (s->use_exp_vlc) {
+        free_vlc(&s->exp_vlc);
+    }
+    if (s->use_noise_coding) {
+        free_vlc(&s->hgain_vlc);
+    }
+    for(i = 0;i < 2; i++) {
+        free_vlc(&s->coef_vlc[i]);
+        av_free(s->run_table[i]);
+        av_free(s->level_table[i]);
+    }
+
+    return 0;
+}
diff --git a/libavcodec/wma.h b/libavcodec/wma.h
new file mode 100644 (file)
index 0000000..1db6d53
--- /dev/null
@@ -0,0 +1,149 @@
+/*
+ * WMA compatible codec
+ * Copyright (c) 2002-2007 The FFmpeg Project.
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef WMA_H
+#define WMA_H
+
+#include "bitstream.h"
+#include "dsputil.h"
+
+/* size of blocks */
+#define BLOCK_MIN_BITS 7
+#define BLOCK_MAX_BITS 11
+#define BLOCK_MAX_SIZE (1 << BLOCK_MAX_BITS)
+
+#define BLOCK_NB_SIZES (BLOCK_MAX_BITS - BLOCK_MIN_BITS + 1)
+
+/* XXX: find exact max size */
+#define HIGH_BAND_MAX_SIZE 16
+
+#define NB_LSP_COEFS 10
+
+/* XXX: is it a suitable value ? */
+#define MAX_CODED_SUPERFRAME_SIZE 16384
+
+#define MAX_CHANNELS 2
+
+#define NOISE_TAB_SIZE 8192
+
+#define LSP_POW_BITS 7
+
+//FIXME should be in wmadec
+#define VLCBITS 9
+#define VLCMAX ((22+VLCBITS-1)/VLCBITS)
+
+typedef struct CoefVLCTable {
+    int n; /* total number of codes */
+    int max_level;
+    const uint32_t *huffcodes; /* VLC bit values */
+    const uint8_t *huffbits;   /* VLC bit size */
+    const uint16_t *levels; /* table to build run/level tables */
+} CoefVLCTable;
+
+typedef struct WMADecodeContext {
+    GetBitContext gb;
+    PutBitContext pb;
+    int sample_rate;
+    int nb_channels;
+    int bit_rate;
+    int version; /* 1 = 0x160 (WMAV1), 2 = 0x161 (WMAV2) */
+    int block_align;
+    int use_bit_reservoir;
+    int use_variable_block_len;
+    int use_exp_vlc;  /* exponent coding: 0 = lsp, 1 = vlc + delta */
+    int use_noise_coding; /* true if perceptual noise is added */
+    int byte_offset_bits;
+    VLC exp_vlc;
+    int exponent_sizes[BLOCK_NB_SIZES];
+    uint16_t exponent_bands[BLOCK_NB_SIZES][25];
+    int high_band_start[BLOCK_NB_SIZES]; /* index of first coef in high band */
+    int coefs_start;               /* first coded coef */
+    int coefs_end[BLOCK_NB_SIZES]; /* max number of coded coefficients */
+    int exponent_high_sizes[BLOCK_NB_SIZES];
+    int exponent_high_bands[BLOCK_NB_SIZES][HIGH_BAND_MAX_SIZE];
+    VLC hgain_vlc;
+
+    /* coded values in high bands */
+    int high_band_coded[MAX_CHANNELS][HIGH_BAND_MAX_SIZE];
+    int high_band_values[MAX_CHANNELS][HIGH_BAND_MAX_SIZE];
+
+    /* there are two possible tables for spectral coefficients */
+//FIXME the following 3 tables should be shared between decoders
+    VLC coef_vlc[2];
+    uint16_t *run_table[2];
+    uint16_t *level_table[2];
+    uint16_t *int_table[2];
+    CoefVLCTable *coef_vlcs[2];
+    /* frame info */
+    int frame_len;       /* frame length in samples */
+    int frame_len_bits;  /* frame_len = 1 << frame_len_bits */
+    int nb_block_sizes;  /* number of block sizes */
+    /* block info */
+    int reset_block_lengths;
+    int block_len_bits; /* log2 of current block length */
+    int next_block_len_bits; /* log2 of next block length */
+    int prev_block_len_bits; /* log2 of prev block length */
+    int block_len; /* block length in samples */
+    int block_num; /* block number in current frame */
+    int block_pos; /* current position in frame */
+    uint8_t ms_stereo; /* true if mid/side stereo mode */
+    uint8_t channel_coded[MAX_CHANNELS]; /* true if channel is coded */
+    DECLARE_ALIGNED_16(float, exponents[MAX_CHANNELS][BLOCK_MAX_SIZE]);
+    float max_exponent[MAX_CHANNELS];
+    int16_t coefs1[MAX_CHANNELS][BLOCK_MAX_SIZE];
+    DECLARE_ALIGNED_16(float, coefs[MAX_CHANNELS][BLOCK_MAX_SIZE]);
+    DECLARE_ALIGNED_16(FFTSample, output[BLOCK_MAX_SIZE * 2]);
+    DECLARE_ALIGNED_16(float, window[BLOCK_MAX_SIZE * 2]);
+    MDCTContext mdct_ctx[BLOCK_NB_SIZES];
+    float *windows[BLOCK_NB_SIZES];
+    DECLARE_ALIGNED_16(FFTSample, mdct_tmp[BLOCK_MAX_SIZE]); /* temporary storage for imdct */
+    /* output buffer for one frame and the last for IMDCT windowing */
+    DECLARE_ALIGNED_16(float, frame_out[MAX_CHANNELS][BLOCK_MAX_SIZE * 2]);
+    /* last frame info */
+    uint8_t last_superframe[MAX_CODED_SUPERFRAME_SIZE + 4]; /* padding added */
+    int last_bitoffset;
+    int last_superframe_len;
+    float noise_table[NOISE_TAB_SIZE];
+    int noise_index;
+    float noise_mult; /* XXX: suppress that and integrate it in the noise array */
+    /* lsp_to_curve tables */
+    float lsp_cos_table[BLOCK_MAX_SIZE];
+    float lsp_pow_e_table[256];
+    float lsp_pow_m_table1[(1 << LSP_POW_BITS)];
+    float lsp_pow_m_table2[(1 << LSP_POW_BITS)];
+    DSPContext dsp;
+
+#ifdef TRACE
+    int frame_count;
+#endif
+} WMADecodeContext;
+
+extern const uint16_t ff_wma_hgain_huffcodes[37];
+extern const uint8_t ff_wma_hgain_huffbits[37];
+extern const float ff_wma_lsp_codebook[NB_LSP_COEFS][16];
+extern const uint32_t ff_wma_scale_huffcodes[121];
+extern const uint8_t ff_wma_scale_huffbits[121];
+
+int ff_wma_init(AVCodecContext * avctx, int flags2);
+int ff_wma_total_gain_to_bits(int total_gain);
+int ff_wma_end(AVCodecContext *avctx);
+
+#endif
index 35e545c..31ed89b 100644 (file)
@@ -50,7 +50,7 @@ static const uint8_t exponent_band_44100[3][25] = {
     { 17,  4,   8,   8,   4,  12,  12,   8,   8,  24,  16,  20,  24,  32,  40,  60,  80, 152, },
 };
 
-static const uint16_t hgain_huffcodes[37] = {
+const uint16_t ff_wma_hgain_huffcodes[37] = {
  0x00003, 0x002e7, 0x00001, 0x005cd, 0x0005d, 0x005c9, 0x0005e, 0x00003,
  0x00016, 0x0000b, 0x00001, 0x00006, 0x00001, 0x00006, 0x00004, 0x00005,
  0x00004, 0x00007, 0x00003, 0x00007, 0x00004, 0x0000a, 0x0000a, 0x00002,
@@ -58,7 +58,7 @@ static const uint16_t hgain_huffcodes[37] = {
  0x005c8, 0x000b8, 0x005ca, 0x005cb, 0x005cc,
 };
 
-static const uint8_t hgain_huffbits[37] = {
+const uint8_t ff_wma_hgain_huffbits[37] = {
  10, 12, 10, 13,  9, 13,  9,  8,
   7,  5,  5,  4,  4,  3,  3,  3,
   4,  3,  4,  4,  5,  5,  6,  8,
@@ -66,7 +66,7 @@ static const uint8_t hgain_huffbits[37] = {
  13, 10, 13, 13, 13,
 };
 
-static const float lsp_codebook[NB_LSP_COEFS][16] = {
+const float ff_wma_lsp_codebook[NB_LSP_COEFS][16] = {
  { 1.98732877, 1.97944528, 1.97179088, 1.96260549, 1.95038374, 1.93336114, 1.90719232, 1.86191415, },
  { 1.97260000, 1.96083160, 1.94982586, 1.93806164, 1.92516608, 1.91010199, 1.89232331, 1.87149812,
    1.84564818, 1.81358067, 1.77620070, 1.73265264, 1.67907855, 1.60959081, 1.50829650, 1.33120330, },
@@ -86,7 +86,7 @@ static const float lsp_codebook[NB_LSP_COEFS][16] = {
  { -1.56144989, -1.65944032, -1.72689685, -1.77857740, -1.82203011, -1.86220079, -1.90283983, -1.94820479, },
 };
 
-static const uint32_t scale_huffcodes[121] = {
+const uint32_t ff_wma_scale_huffcodes[121] = {
  0x3ffe8, 0x3ffe6, 0x3ffe7, 0x3ffe5, 0x7fff5, 0x7fff1, 0x7ffed, 0x7fff6,
  0x7ffee, 0x7ffef, 0x7fff0, 0x7fffc, 0x7fffd, 0x7ffff, 0x7fffe, 0x7fff7,
  0x7fff8, 0x7fffb, 0x7fff9, 0x3ffe4, 0x7fffa, 0x3ffe3, 0x1ffef, 0x1fff0,
@@ -105,7 +105,7 @@ static const uint32_t scale_huffcodes[121] = {
  0x7fff3,
 };
 
-static const uint8_t scale_huffbits[121] = {
+const uint8_t ff_wma_scale_huffbits[121] = {
  18, 18, 18, 18, 19, 19, 19, 19,
  19, 19, 19, 19, 19, 19, 19, 19,
  19, 19, 19, 18, 19, 18, 17, 17,
@@ -1413,21 +1413,21 @@ static const uint16_t levels5[40] = {
 
 static const CoefVLCTable coef_vlcs[6] = {
     {
-        sizeof(coef0_huffbits), coef0_huffcodes, coef0_huffbits, levels0,
+        sizeof(coef0_huffbits), sizeof(levels0)/2, coef0_huffcodes, coef0_huffbits, levels0,
     },
     {
-        sizeof(coef1_huffbits), coef1_huffcodes, coef1_huffbits, levels1,
+        sizeof(coef1_huffbits), sizeof(levels1)/2, coef1_huffcodes, coef1_huffbits, levels1,
     },
     {
-        sizeof(coef2_huffbits), coef2_huffcodes, coef2_huffbits, levels2,
+        sizeof(coef2_huffbits), sizeof(levels2)/2, coef2_huffcodes, coef2_huffbits, levels2,
     },
     {
-        sizeof(coef3_huffbits), coef3_huffcodes, coef3_huffbits, levels3,
+        sizeof(coef3_huffbits), sizeof(levels3)/2, coef3_huffcodes, coef3_huffbits, levels3,
     },
     {
-        sizeof(coef4_huffbits), coef4_huffcodes, coef4_huffbits, levels4,
+        sizeof(coef4_huffbits), sizeof(levels4)/2, coef4_huffcodes, coef4_huffbits, levels4,
     },
     {
-        sizeof(coef5_huffbits), coef5_huffcodes, coef5_huffbits, levels5,
+        sizeof(coef5_huffbits), sizeof(levels5)/2, coef5_huffcodes, coef5_huffbits, levels5,
     },
 };
index bbf4970..29a18bd 100644 (file)
  */
 
 #include "avcodec.h"
-#include "bitstream.h"
-#include "dsputil.h"
+#include "wma.h"
 
-/* size of blocks */
-#define BLOCK_MIN_BITS 7
-#define BLOCK_MAX_BITS 11
-#define BLOCK_MAX_SIZE (1 << BLOCK_MAX_BITS)
-
-#define BLOCK_NB_SIZES (BLOCK_MAX_BITS - BLOCK_MIN_BITS + 1)
-
-/* XXX: find exact max size */
-#define HIGH_BAND_MAX_SIZE 16
-
-#define NB_LSP_COEFS 10
-
-/* XXX: is it a suitable value ? */
-#define MAX_CODED_SUPERFRAME_SIZE 16384
-
-#define MAX_CHANNELS 2
-
-#define NOISE_TAB_SIZE 8192
-
-#define LSP_POW_BITS 7
-
-#define VLCBITS 9
-#define VLCMAX ((22+VLCBITS-1)/VLCBITS)
+#undef NDEBUG
+#include <assert.h>
 
 #define EXPVLCBITS 8
 #define EXPMAX ((19+EXPVLCBITS-1)/EXPVLCBITS)
 #define HGAINVLCBITS 9
 #define HGAINMAX ((13+HGAINVLCBITS-1)/HGAINVLCBITS)
 
-typedef struct WMADecodeContext {
-    GetBitContext gb;
-    int sample_rate;
-    int nb_channels;
-    int bit_rate;
-    int version; /* 1 = 0x160 (WMAV1), 2 = 0x161 (WMAV2) */
-    int block_align;
-    int use_bit_reservoir;
-    int use_variable_block_len;
-    int use_exp_vlc;  /* exponent coding: 0 = lsp, 1 = vlc + delta */
-    int use_noise_coding; /* true if perceptual noise is added */
-    int byte_offset_bits;
-    VLC exp_vlc;
-    int exponent_sizes[BLOCK_NB_SIZES];
-    uint16_t exponent_bands[BLOCK_NB_SIZES][25];
-    int high_band_start[BLOCK_NB_SIZES]; /* index of first coef in high band */
-    int coefs_start;               /* first coded coef */
-    int coefs_end[BLOCK_NB_SIZES]; /* max number of coded coefficients */
-    int exponent_high_sizes[BLOCK_NB_SIZES];
-    int exponent_high_bands[BLOCK_NB_SIZES][HIGH_BAND_MAX_SIZE];
-    VLC hgain_vlc;
-
-    /* coded values in high bands */
-    int high_band_coded[MAX_CHANNELS][HIGH_BAND_MAX_SIZE];
-    int high_band_values[MAX_CHANNELS][HIGH_BAND_MAX_SIZE];
-
-    /* there are two possible tables for spectral coefficients */
-    VLC coef_vlc[2];
-    uint16_t *run_table[2];
-    uint16_t *level_table[2];
-    /* frame info */
-    int frame_len;       /* frame length in samples */
-    int frame_len_bits;  /* frame_len = 1 << frame_len_bits */
-    int nb_block_sizes;  /* number of block sizes */
-    /* block info */
-    int reset_block_lengths;
-    int block_len_bits; /* log2 of current block length */
-    int next_block_len_bits; /* log2 of next block length */
-    int prev_block_len_bits; /* log2 of prev block length */
-    int block_len; /* block length in samples */
-    int block_num; /* block number in current frame */
-    int block_pos; /* current position in frame */
-    uint8_t ms_stereo; /* true if mid/side stereo mode */
-    uint8_t channel_coded[MAX_CHANNELS]; /* true if channel is coded */
-    DECLARE_ALIGNED_16(float, exponents[MAX_CHANNELS][BLOCK_MAX_SIZE]);
-    float max_exponent[MAX_CHANNELS];
-    int16_t coefs1[MAX_CHANNELS][BLOCK_MAX_SIZE];
-    DECLARE_ALIGNED_16(float, coefs[MAX_CHANNELS][BLOCK_MAX_SIZE]);
-    DECLARE_ALIGNED_16(FFTSample, output[BLOCK_MAX_SIZE * 2]);
-    DECLARE_ALIGNED_16(float, window[BLOCK_MAX_SIZE * 2]);
-    MDCTContext mdct_ctx[BLOCK_NB_SIZES];
-    float *windows[BLOCK_NB_SIZES];
-    DECLARE_ALIGNED_16(FFTSample, mdct_tmp[BLOCK_MAX_SIZE]); /* temporary storage for imdct */
-    /* output buffer for one frame and the last for IMDCT windowing */
-    DECLARE_ALIGNED_16(float, frame_out[MAX_CHANNELS][BLOCK_MAX_SIZE * 2]);
-    /* last frame info */
-    uint8_t last_superframe[MAX_CODED_SUPERFRAME_SIZE + 4]; /* padding added */
-    int last_bitoffset;
-    int last_superframe_len;
-    float noise_table[NOISE_TAB_SIZE];
-    int noise_index;
-    float noise_mult; /* XXX: suppress that and integrate it in the noise array */
-    /* lsp_to_curve tables */
-    float lsp_cos_table[BLOCK_MAX_SIZE];
-    float lsp_pow_e_table[256];
-    float lsp_pow_m_table1[(1 << LSP_POW_BITS)];
-    float lsp_pow_m_table2[(1 << LSP_POW_BITS)];
-    DSPContext dsp;
-
-#ifdef TRACE
-    int frame_count;
-#endif
-} WMADecodeContext;
-
-typedef struct CoefVLCTable {
-    int n; /* total number of codes */
-    const uint32_t *huffcodes; /* VLC bit values */
-    const uint8_t *huffbits;   /* VLC bit size */
-    const uint16_t *levels; /* table to build run/level tables */
-} CoefVLCTable;
-
 static void wma_lsp_to_curve_init(WMADecodeContext *s, int frame_len);
 
-#include "wmadata.h"
-
 #ifdef TRACE
 static void dump_shorts(const char *name, const short *tab, int n)
 {
@@ -184,356 +79,51 @@ static void dump_floats(const char *name, int prec, const float *tab, int n)
 }
 #endif
 
-/* XXX: use same run/length optimization as mpeg decoders */
-static void init_coef_vlc(VLC *vlc,
-                          uint16_t **prun_table, uint16_t **plevel_table,
-                          const CoefVLCTable *vlc_table)
-{
-    int n = vlc_table->n;
-    const uint8_t *table_bits = vlc_table->huffbits;
-    const uint32_t *table_codes = vlc_table->huffcodes;
-    const uint16_t *levels_table = vlc_table->levels;
-    uint16_t *run_table, *level_table;
-    const uint16_t *p;
-    int i, l, j, level;
-
-    init_vlc(vlc, VLCBITS, n, table_bits, 1, 1, table_codes, 4, 4, 0);
-
-    run_table = av_malloc(n * sizeof(uint16_t));
-    level_table = av_malloc(n * sizeof(uint16_t));
-    p = levels_table;
-    i = 2;
-    level = 1;
-    while (i < n) {
-        l = *p++;
-        for(j=0;j<l;j++) {
-            run_table[i] = j;
-            level_table[i] = level;
-            i++;
-        }
-        level++;
-    }
-    *prun_table = run_table;
-    *plevel_table = level_table;
-}
-
 static int wma_decode_init(AVCodecContext * avctx)
 {
     WMADecodeContext *s = avctx->priv_data;
     int i, flags1, flags2;
-    float *window;
     uint8_t *extradata;
-    float bps1, high_freq;
-    volatile float bps;
-    int sample_rate1;
-    int coef_vlc_table;
-
-    s->sample_rate = avctx->sample_rate;
-    s->nb_channels = avctx->channels;
-    s->bit_rate = avctx->bit_rate;
-    s->block_align = avctx->block_align;
-
-    dsputil_init(&s->dsp, avctx);
-
-    if (avctx->codec->id == CODEC_ID_WMAV1) {
-        s->version = 1;
-    } else {
-        s->version = 2;
-    }
 
     /* extract flag infos */
     flags1 = 0;
     flags2 = 0;
     extradata = avctx->extradata;
-    if (s->version == 1 && avctx->extradata_size >= 4) {
+    if (avctx->codec->id == CODEC_ID_WMAV1 && avctx->extradata_size >= 4) {
         flags1 = extradata[0] | (extradata[1] << 8);
         flags2 = extradata[2] | (extradata[3] << 8);
-    } else if (s->version == 2 && avctx->extradata_size >= 6) {
+    } else if (avctx->codec->id == CODEC_ID_WMAV2 && avctx->extradata_size >= 6) {
         flags1 = extradata[0] | (extradata[1] << 8) |
             (extradata[2] << 16) | (extradata[3] << 24);
         flags2 = extradata[4] | (extradata[5] << 8);
     }
+for(i=0; i<avctx->extradata_size; i++)
+    av_log(NULL, AV_LOG_ERROR, "%02X ", extradata[i]);
+
     s->use_exp_vlc = flags2 & 0x0001;
     s->use_bit_reservoir = flags2 & 0x0002;
     s->use_variable_block_len = flags2 & 0x0004;
 
-    /* compute MDCT block size */
-    if (s->sample_rate <= 16000) {
-        s->frame_len_bits = 9;
-    } else if (s->sample_rate <= 22050 ||
-               (s->sample_rate <= 32000 && s->version == 1)) {
-        s->frame_len_bits = 10;
-    } else {
-        s->frame_len_bits = 11;
-    }
-    s->frame_len = 1 << s->frame_len_bits;
-    if (s->use_variable_block_len) {
-        int nb_max, nb;
-        nb = ((flags2 >> 3) & 3) + 1;
-        if ((s->bit_rate / s->nb_channels) >= 32000)
-            nb += 2;
-        nb_max = s->frame_len_bits - BLOCK_MIN_BITS;
-        if (nb > nb_max)
-            nb = nb_max;
-        s->nb_block_sizes = nb + 1;
-    } else {
-        s->nb_block_sizes = 1;
-    }
-
-    /* init rate dependant parameters */
-    s->use_noise_coding = 1;
-    high_freq = s->sample_rate * 0.5;
-
-    /* if version 2, then the rates are normalized */
-    sample_rate1 = s->sample_rate;
-    if (s->version == 2) {
-        if (sample_rate1 >= 44100)
-            sample_rate1 = 44100;
-        else if (sample_rate1 >= 22050)
-            sample_rate1 = 22050;
-        else if (sample_rate1 >= 16000)
-            sample_rate1 = 16000;
-        else if (sample_rate1 >= 11025)
-            sample_rate1 = 11025;
-        else if (sample_rate1 >= 8000)
-            sample_rate1 = 8000;
-    }
-
-    bps = (float)s->bit_rate / (float)(s->nb_channels * s->sample_rate);
-    s->byte_offset_bits = av_log2((int)(bps * s->frame_len / 8.0 + 0.5)) + 2;
-
-    /* compute high frequency value and choose if noise coding should
-       be activated */
-    bps1 = bps;
-    if (s->nb_channels == 2)
-        bps1 = bps * 1.6;
-    if (sample_rate1 == 44100) {
-        if (bps1 >= 0.61)
-            s->use_noise_coding = 0;
-        else
-            high_freq = high_freq * 0.4;
-    } else if (sample_rate1 == 22050) {
-        if (bps1 >= 1.16)
-            s->use_noise_coding = 0;
-        else if (bps1 >= 0.72)
-            high_freq = high_freq * 0.7;
-        else
-            high_freq = high_freq * 0.6;
-    } else if (sample_rate1 == 16000) {
-        if (bps > 0.5)
-            high_freq = high_freq * 0.5;
-        else
-            high_freq = high_freq * 0.3;
-    } else if (sample_rate1 == 11025) {
-        high_freq = high_freq * 0.7;
-    } else if (sample_rate1 == 8000) {
-        if (bps <= 0.625) {
-            high_freq = high_freq * 0.5;
-        } else if (bps > 0.75) {
-            s->use_noise_coding = 0;
-        } else {
-            high_freq = high_freq * 0.65;
-        }
-    } else {
-        if (bps >= 0.8) {
-            high_freq = high_freq * 0.75;
-        } else if (bps >= 0.6) {
-            high_freq = high_freq * 0.6;
-        } else {
-            high_freq = high_freq * 0.5;
-        }
-    }
-    dprintf("flags1=0x%x flags2=0x%x\n", flags1, flags2);
-    dprintf("version=%d channels=%d sample_rate=%d bitrate=%d block_align=%d\n",
-           s->version, s->nb_channels, s->sample_rate, s->bit_rate,
-           s->block_align);
-    dprintf("bps=%f bps1=%f high_freq=%f bitoffset=%d\n",
-           bps, bps1, high_freq, s->byte_offset_bits);
-    dprintf("use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n",
-           s->use_noise_coding, s->use_exp_vlc, s->nb_block_sizes);
-
-    /* compute the scale factor band sizes for each MDCT block size */
-    {
-        int a, b, pos, lpos, k, block_len, i, j, n;
-        const uint8_t *table;
-
-        if (s->version == 1) {
-            s->coefs_start = 3;
-        } else {
-            s->coefs_start = 0;
-        }
-        for(k = 0; k < s->nb_block_sizes; k++) {
-            block_len = s->frame_len >> k;
-
-            if (s->version == 1) {
-                lpos = 0;
-                for(i=0;i<25;i++) {
-                    a = wma_critical_freqs[i];
-                    b = s->sample_rate;
-                    pos = ((block_len * 2 * a)  + (b >> 1)) / b;
-                    if (pos > block_len)
-                        pos = block_len;
-                    s->exponent_bands[0][i] = pos - lpos;
-                    if (pos >= block_len) {
-                        i++;
-                        break;
-                    }
-                    lpos = pos;
-                }
-                s->exponent_sizes[0] = i;
-            } else {
-                /* hardcoded tables */
-                table = NULL;
-                a = s->frame_len_bits - BLOCK_MIN_BITS - k;
-                if (a < 3) {
-                    if (s->sample_rate >= 44100)
-                        table = exponent_band_44100[a];
-                    else if (s->sample_rate >= 32000)
-                        table = exponent_band_32000[a];
-                    else if (s->sample_rate >= 22050)
-                        table = exponent_band_22050[a];
-                }
-                if (table) {
-                    n = *table++;
-                    for(i=0;i<n;i++)
-                        s->exponent_bands[k][i] = table[i];
-                    s->exponent_sizes[k] = n;
-                } else {
-                    j = 0;
-                    lpos = 0;
-                    for(i=0;i<25;i++) {
-                        a = wma_critical_freqs[i];
-                        b = s->sample_rate;
-                        pos = ((block_len * 2 * a)  + (b << 1)) / (4 * b);
-                        pos <<= 2;
-                        if (pos > block_len)
-                            pos = block_len;
-                        if (pos > lpos)
-                            s->exponent_bands[k][j++] = pos - lpos;
-                        if (pos >= block_len)
-                            break;
-                        lpos = pos;
-                    }
-                    s->exponent_sizes[k] = j;
-                }
-            }
-
-            /* max number of coefs */
-            s->coefs_end[k] = (s->frame_len - ((s->frame_len * 9) / 100)) >> k;
-            /* high freq computation */
-            s->high_band_start[k] = (int)((block_len * 2 * high_freq) /
-                                          s->sample_rate + 0.5);
-            n = s->exponent_sizes[k];
-            j = 0;
-            pos = 0;
-            for(i=0;i<n;i++) {
-                int start, end;
-                start = pos;
-                pos += s->exponent_bands[k][i];
-                end = pos;
-                if (start < s->high_band_start[k])
-                    start = s->high_band_start[k];
-                if (end > s->coefs_end[k])
-                    end = s->coefs_end[k];
-                if (end > start)
-                    s->exponent_high_bands[k][j++] = end - start;
-            }
-            s->exponent_high_sizes[k] = j;
-#if 0
-            tprintf("%5d: coefs_end=%d high_band_start=%d nb_high_bands=%d: ",
-                  s->frame_len >> k,
-                  s->coefs_end[k],
-                  s->high_band_start[k],
-                  s->exponent_high_sizes[k]);
-            for(j=0;j<s->exponent_high_sizes[k];j++)
-                tprintf(" %d", s->exponent_high_bands[k][j]);
-            tprintf("\n");
-#endif
-        }
-    }
-
-#ifdef TRACE
-    {
-        int i, j;
-        for(i = 0; i < s->nb_block_sizes; i++) {
-            tprintf("%5d: n=%2d:",
-                   s->frame_len >> i,
-                   s->exponent_sizes[i]);
-            for(j=0;j<s->exponent_sizes[i];j++)
-                tprintf(" %d", s->exponent_bands[i][j]);
-            tprintf("\n");
-        }
-    }
-#endif
+    ff_wma_init(avctx, flags2);
 
     /* init MDCT */
     for(i = 0; i < s->nb_block_sizes; i++)
         ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 1);
 
-    /* init MDCT windows : simple sinus window */
-    for(i = 0; i < s->nb_block_sizes; i++) {
-        int n, j;
-        float alpha;
-        n = 1 << (s->frame_len_bits - i);
-        window = av_malloc(sizeof(float) * n);
-        alpha = M_PI / (2.0 * n);
-        for(j=0;j<n;j++) {
-            window[n - j - 1] = sin((j + 0.5) * alpha);
-        }
-        s->windows[i] = window;
-    }
-
-    s->reset_block_lengths = 1;
-
     if (s->use_noise_coding) {
-
-        /* init the noise generator */
-        if (s->use_exp_vlc)
-            s->noise_mult = 0.02;
-        else
-            s->noise_mult = 0.04;
-
-#ifdef TRACE
-        for(i=0;i<NOISE_TAB_SIZE;i++)
-            s->noise_table[i] = 1.0 * s->noise_mult;
-#else
-        {
-            unsigned int seed;
-            float norm;
-            seed = 1;
-            norm = (1.0 / (float)(1LL << 31)) * sqrt(3) * s->noise_mult;
-            for(i=0;i<NOISE_TAB_SIZE;i++) {
-                seed = seed * 314159 + 1;
-                s->noise_table[i] = (float)((int)seed) * norm;
-            }
-        }
-#endif
-        init_vlc(&s->hgain_vlc, HGAINVLCBITS, sizeof(hgain_huffbits),
-                 hgain_huffbits, 1, 1,
-                 hgain_huffcodes, 2, 2, 0);
+        init_vlc(&s->hgain_vlc, HGAINVLCBITS, sizeof(ff_wma_hgain_huffbits),
+                 ff_wma_hgain_huffbits, 1, 1,
+                 ff_wma_hgain_huffcodes, 2, 2, 0);
     }
 
     if (s->use_exp_vlc) {
-        init_vlc(&s->exp_vlc, EXPVLCBITS, sizeof(scale_huffbits),
-                 scale_huffbits, 1, 1,
-                 scale_huffcodes, 4, 4, 0);
+        init_vlc(&s->exp_vlc, EXPVLCBITS, sizeof(ff_wma_scale_huffbits), //FIXME move out of context
+                 ff_wma_scale_huffbits, 1, 1,
+                 ff_wma_scale_huffcodes, 4, 4, 0);
     } else {
         wma_lsp_to_curve_init(s, s->frame_len);
     }
 
-    /* choose the VLC tables for the coefficients */
-    coef_vlc_table = 2;
-    if (s->sample_rate >= 32000) {
-        if (bps1 < 0.72)
-            coef_vlc_table = 0;
-        else if (bps1 < 1.16)
-            coef_vlc_table = 1;
-    }
-
-    init_coef_vlc(&s->coef_vlc[0], &s->run_table[0], &s->level_table[0],
-                  &coef_vlcs[coef_vlc_table * 2]);
-    init_coef_vlc(&s->coef_vlc[1], &s->run_table[1], &s->level_table[1],
-                  &coef_vlcs[coef_vlc_table * 2 + 1]);
     return 0;
 }
 
@@ -664,7 +254,7 @@ static void decode_exp_lsp(WMADecodeContext *s, int ch)
             val = get_bits(&s->gb, 3);
         else
             val = get_bits(&s->gb, 4);
-        lsp_coefs[i] = lsp_codebook[i][val];
+        lsp_coefs[i] = ff_wma_lsp_codebook[i][val];
     }
 
     wma_lsp_to_curve(s, s->exponents[ch], &s->max_exponent[ch],
@@ -692,8 +282,9 @@ static int decode_exp_vlc(WMADecodeContext *s, int ch)
         do {
             *q++ = v;
         } while (--n);
-    }
-    last_exp = 36;
+    }else
+        last_exp = 36;
+
     while (q < q_end) {
         code = get_vlc2(&s->gb, s->exp_vlc.table, EXPVLCBITS, EXPMAX);
         if (code < 0)
@@ -787,16 +378,7 @@ static int wma_decode_block(WMADecodeContext *s)
             break;
     }
 
-    if (total_gain < 15)
-        coef_nb_bits = 13;
-    else if (total_gain < 32)
-        coef_nb_bits = 12;
-    else if (total_gain < 40)
-        coef_nb_bits = 11;
-    else if (total_gain < 45)
-        coef_nb_bits = 10;
-    else
-        coef_nb_bits = 9;
+    coef_nb_bits= ff_wma_total_gain_to_bits(total_gain);
 
     /* compute number of coefficients */
     n = s->coefs_end[bsize] - s->coefs_start;
@@ -1279,6 +861,9 @@ static int wma_decode_superframe(AVCodecContext *avctx,
             goto fail;
         samples += s->nb_channels * s->frame_len;
     }
+
+//av_log(NULL, AV_LOG_ERROR, "%d %d %d %d outbytes:%d eaten:%d\n", s->frame_len_bits, s->block_len_bits, s->frame_len, s->block_len,        (int8_t *)samples - (int8_t *)data, s->block_align);
+
     *data_size = (int8_t *)samples - (int8_t *)data;
     return s->block_align;
  fail:
@@ -1287,31 +872,6 @@ static int wma_decode_superframe(AVCodecContext *avctx,
     return -1;
 }
 
-static int wma_decode_end(AVCodecContext *avctx)
-{
-    WMADecodeContext *s = avctx->priv_data;
-    int i;
-
-    for(i = 0; i < s->nb_block_sizes; i++)
-        ff_mdct_end(&s->mdct_ctx[i]);
-    for(i = 0; i < s->nb_block_sizes; i++)
-        av_free(s->windows[i]);
-
-    if (s->use_exp_vlc) {
-        free_vlc(&s->exp_vlc);
-    }
-    if (s->use_noise_coding) {
-        free_vlc(&s->hgain_vlc);
-    }
-    for(i = 0;i < 2; i++) {
-        free_vlc(&s->coef_vlc[i]);
-        av_free(s->run_table[i]);
-        av_free(s->level_table[i]);
-    }
-
-    return 0;
-}
-
 AVCodec wmav1_decoder =
 {
     "wmav1",
@@ -1320,7 +880,7 @@ AVCodec wmav1_decoder =
     sizeof(WMADecodeContext),
     wma_decode_init,
     NULL,
-    wma_decode_end,
+    ff_wma_end,
     wma_decode_superframe,
 };
 
@@ -1332,6 +892,6 @@ AVCodec wmav2_decoder =
     sizeof(WMADecodeContext),
     wma_decode_init,
     NULL,
-    wma_decode_end,
+    ff_wma_end,
     wma_decode_superframe,
 };
diff --git a/libavcodec/wmaenc.c b/libavcodec/wmaenc.c
new file mode 100644 (file)
index 0000000..c09ba4d
--- /dev/null
@@ -0,0 +1,402 @@
+/*
+ * WMA compatible encoder
+ * Copyright (c) 2007 Michael Niedermayer
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "avcodec.h"
+#include "wma.h"
+
+#undef NDEBUG
+#include <assert.h>
+
+
+static int encode_init(AVCodecContext * avctx){
+    WMADecodeContext *s = avctx->priv_data;
+    int i, flags1, flags2;
+    uint8_t *extradata;
+
+    if(avctx->channels > MAX_CHANNELS)
+        return -1;
+
+    /* extract flag infos */
+    flags1 = 0;
+    flags2 = 1;
+    if (avctx->codec->id == CODEC_ID_WMAV1) {
+        extradata= av_malloc(4);
+        avctx->extradata_size= 4;
+        extradata[0] = flags1;
+        extradata[1] = flags1>>8;
+        extradata[2] = flags2;
+        extradata[3] = flags2>>8;
+    } else if (avctx->codec->id == CODEC_ID_WMAV2) {
+        extradata= av_mallocz(10);
+        avctx->extradata_size= 10;
+        extradata[0] = flags1;
+        extradata[1] = flags1>>8;
+        extradata[2] = flags1>>16;
+        extradata[3] = flags1>>24;
+        extradata[4] = flags2;
+        extradata[5] = flags2>>8;
+    }else
+        assert(0);
+    avctx->extradata= extradata;
+    s->use_exp_vlc = flags2 & 0x0001;
+    s->use_bit_reservoir = flags2 & 0x0002;
+    s->use_variable_block_len = flags2 & 0x0004;
+
+    ff_wma_init(avctx, flags2);
+
+    /* init MDCT */
+    for(i = 0; i < s->nb_block_sizes; i++)
+        ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 0);
+
+    avctx->block_align=
+    s->block_align= avctx->bit_rate*(int64_t)s->frame_len / (avctx->sample_rate*8);
+//av_log(NULL, AV_LOG_ERROR, "%d %d %d %d\n", s->block_align, avctx->bit_rate, s->frame_len, avctx->sample_rate);
+    avctx->frame_size= s->frame_len;
+
+    return 0;
+}
+
+
+static void apply_window_and_mdct(AVCodecContext * avctx, signed short * audio, int len) {
+    WMADecodeContext *s = avctx->priv_data;
+    int window_index= s->frame_len_bits - s->block_len_bits;
+    int i, j, channel;
+    const float * win = s->windows[window_index];
+    int window_len = 1 << s->block_len_bits;
+    float n = window_len/2;
+
+    for (channel = 0; channel < avctx->channels; channel++) {
+        memcpy(s->output, s->frame_out[channel], sizeof(float)*window_len);
+        j = channel;
+        for (i = 0; i < len; i++, j += avctx->channels){
+            s->output[i+window_len]  = audio[j] / n * win[i];
+            s->frame_out[channel][i] = audio[j] / n * win[window_len - i - 1];
+        }
+        ff_mdct_calc(&s->mdct_ctx[window_index], s->coefs[channel], s->output, s->mdct_tmp);
+    }
+}
+
+//FIXME use for decoding too
+static void init_exp(WMADecodeContext *s, int ch, int *exp_param){
+    int n;
+    const uint16_t *ptr;
+    float v, *q, max_scale, *q_end;
+
+    ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
+    q = s->exponents[ch];
+    q_end = q + s->block_len;
+    max_scale = 0;
+    while (q < q_end) {
+        /* XXX: use a table */
+        v = pow(10, *exp_param++ * (1.0 / 16.0));
+        max_scale= FFMAX(max_scale, v);
+        n = *ptr++;
+        do {
+            *q++ = v;
+        } while (--n);
+    }
+    s->max_exponent[ch] = max_scale;
+}
+
+static void encode_exp_vlc(WMADecodeContext *s, int ch, const int *exp_param){
+    int last_exp;
+    const uint16_t *ptr;
+    float *q, *q_end;
+
+    ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
+    q = s->exponents[ch];
+    q_end = q + s->block_len;
+    if (s->version == 1) {
+        last_exp= *exp_param++;
+        assert(last_exp-10 >= 0 && last_exp-10 < 32);
+        put_bits(&s->pb, 5, last_exp - 10);
+        q+= *ptr++;
+    }else
+        last_exp = 36;
+    while (q < q_end) {
+        int exp = *exp_param++;
+        int code = exp - last_exp + 60;
+        assert(code >= 0 && code < 120);
+        put_bits(&s->pb, ff_wma_scale_huffbits[code], ff_wma_scale_huffcodes[code]);
+        /* XXX: use a table */
+        q+= *ptr++;
+        last_exp= exp;
+    }
+}
+
+static int encode_block(WMADecodeContext *s, float (*src_coefs)[BLOCK_MAX_SIZE], int total_gain){
+    int v, bsize, ch, coef_nb_bits, parse_exponents;
+    float mdct_norm;
+    int nb_coefs[MAX_CHANNELS];
+    static const int fixed_exp[25]={20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20};
+
+    //FIXME remove duplication relative to decoder
+    if (s->use_variable_block_len) {
+        assert(0); //FIXME not implemented
+    }else{
+        /* fixed block len */
+        s->next_block_len_bits = s->frame_len_bits;
+        s->prev_block_len_bits = s->frame_len_bits;
+        s->block_len_bits = s->frame_len_bits;
+    }
+
+    s->block_len = 1 << s->block_len_bits;
+//     assert((s->block_pos + s->block_len) <= s->frame_len);
+    bsize = s->frame_len_bits - s->block_len_bits;
+
+    //FIXME factor
+    v = s->coefs_end[bsize] - s->coefs_start;
+    for(ch = 0; ch < s->nb_channels; ch++)
+        nb_coefs[ch] = v;
+    {
+        int n4 = s->block_len / 2;
+        mdct_norm = 1.0 / (float)n4;
+        if (s->version == 1) {
+            mdct_norm *= sqrt(n4);
+        }
+    }
+
+    if (s->nb_channels == 2) {
+        put_bits(&s->pb, 1, s->ms_stereo= 1);
+    }
+
+    for(ch = 0; ch < s->nb_channels; ch++) {
+        if (s->channel_coded[ch]) {
+            init_exp(s, ch, fixed_exp);
+        }
+    }
+
+    for(ch = 0; ch < s->nb_channels; ch++) {
+        if (s->channel_coded[ch]) {
+            int16_t *coefs1;
+            float *coefs, *exponents, mult;
+            int i, n;
+
+            coefs1 = s->coefs1[ch];
+            exponents = s->exponents[ch];
+            mult = pow(10, total_gain * 0.05) / s->max_exponent[ch];
+            mult *= mdct_norm;
+            coefs = src_coefs[ch];
+            if (s->use_noise_coding && 0) {
+                assert(0); //FIXME not implemented
+            } else {
+                coefs += s->coefs_start;
+                n = nb_coefs[ch];
+                for(i = 0;i < n; i++){
+                    double t= *coefs++ / (exponents[i] * mult);
+                    if(t<-32768 || t>32767)
+                        return -1;
+
+                    coefs1[i] = lrint(t);
+                }
+            }
+        }
+    }
+
+    v = 0;
+    for(ch = 0; ch < s->nb_channels; ch++) {
+        int a = s->channel_coded[ch]=1; //FIXME
+        put_bits(&s->pb, 1, a);
+        v |= a;
+    }
+
+    if (!v)
+        return 1;
+
+    for(v= total_gain-1; v>=127; v-= 127)
+        put_bits(&s->pb, 7, 127);
+    put_bits(&s->pb, 7, v);
+
+    coef_nb_bits= ff_wma_total_gain_to_bits(total_gain);
+
+    if (s->use_noise_coding) {
+        for(ch = 0; ch < s->nb_channels; ch++) {
+            if (s->channel_coded[ch]) {
+                int i, n;
+                n = s->exponent_high_sizes[bsize];
+                for(i=0;i<n;i++) {
+                    put_bits(&s->pb, 1, s->high_band_coded[ch][i]= 0);
+                    if (0)
+                        nb_coefs[ch] -= s->exponent_high_bands[bsize][i];
+                }
+            }
+        }
+    }
+
+    parse_exponents = 1;
+    if (s->block_len_bits != s->frame_len_bits) {
+        put_bits(&s->pb, 1, parse_exponents);
+    }
+
+    if (parse_exponents) {
+        for(ch = 0; ch < s->nb_channels; ch++) {
+            if (s->channel_coded[ch]) {
+                if (s->use_exp_vlc) {
+                    encode_exp_vlc(s, ch, fixed_exp);
+                } else {
+                    assert(0); //FIXME not implemented
+//                    encode_exp_lsp(s, ch);
+                }
+            }
+        }
+    } else {
+        assert(0); //FIXME not implemented
+    }
+
+    for(ch = 0; ch < s->nb_channels; ch++) {
+        if (s->channel_coded[ch]) {
+            int run, tindex;
+            int16_t *ptr, *eptr;
+            tindex = (ch == 1 && s->ms_stereo);
+            ptr = &s->coefs1[ch][0];
+            eptr = ptr + nb_coefs[ch];
+
+            run=0;
+            for(;ptr < eptr; ptr++){
+                if(*ptr){
+                    int level= *ptr;
+                    int abs_level= FFABS(level);
+                    int code= 0;
+                    if(abs_level <= s->coef_vlcs[tindex]->max_level){
+                        if(run < s->coef_vlcs[tindex]->levels[abs_level-1])
+                            code= run + s->int_table[tindex][abs_level-1];
+                    }
+
+                    assert(code < s->coef_vlcs[tindex]->n);
+                    put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[code], s->coef_vlcs[tindex]->huffcodes[code]);
+
+                    if(code == 0){
+                        if(1<<coef_nb_bits <= abs_level)
+                            return -1;
+
+                        put_bits(&s->pb, coef_nb_bits, abs_level);
+                        put_bits(&s->pb, s->frame_len_bits, run);
+                    }
+                    put_bits(&s->pb, 1, level > 0);
+                    run=0;
+                }else{
+                    run++;
+                }
+            }
+            if(run)
+                put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[1], s->coef_vlcs[tindex]->huffcodes[1]);
+        }
+        if (s->version == 1 && s->nb_channels >= 2) {
+            align_put_bits(&s->pb);
+        }
+    }
+    return 0;
+}
+
+static int encode_frame(WMADecodeContext *s, float (*src_coefs)[BLOCK_MAX_SIZE], uint8_t *buf, int buf_size, int total_gain){
+    init_put_bits(&s->pb, buf, buf_size);
+
+    if (s->use_bit_reservoir) {
+        assert(0);//FIXME not implemented
+    }else{
+        if(encode_block(s, src_coefs, total_gain) < 0)
+            return INT_MAX;
+    }
+
+    align_put_bits(&s->pb);
+
+    return put_bits_count(&s->pb)/8 - s->block_align;
+}
+
+static int encode_superframe(AVCodecContext *avctx,
+                            unsigned char *buf, int buf_size, void *data){
+    WMADecodeContext *s = avctx->priv_data;
+    short *samples = data;
+    int i, total_gain, best;
+
+    s->block_len_bits= s->frame_len_bits; //required by non variable block len
+    s->block_len = 1 << s->block_len_bits;
+
+    apply_window_and_mdct(avctx, samples, avctx->frame_size);
+
+    if (s->ms_stereo) {
+        float a, b;
+        int i;
+
+        for(i = 0; i < s->block_len; i++) {
+            a = s->coefs[0][i]*0.5;
+            b = s->coefs[1][i]*0.5;
+            s->coefs[0][i] = a + b;
+            s->coefs[1][i] = a - b;
+        }
+    }
+
+#if 1
+    total_gain= 128;
+    for(i=64; i; i>>=1){
+        int error= encode_frame(s, s->coefs, buf, buf_size, total_gain-i);
+        if(error<0)
+            total_gain-= i;
+    }
+#else
+    total_gain= 90;
+    best= encode_frame(s, s->coefs, buf, buf_size, total_gain);
+    for(i=32; i; i>>=1){
+        int scoreL= encode_frame(s, s->coefs, buf, buf_size, total_gain-i);
+        int scoreR= encode_frame(s, s->coefs, buf, buf_size, total_gain+i);
+        av_log(NULL, AV_LOG_ERROR, "%d %d %d (%d)\n", scoreL, best, scoreR, total_gain);
+        if(scoreL < FFMIN(best, scoreR)){
+            best = scoreL;
+            total_gain -= i;
+        }else if(scoreR < best){
+            best = scoreR;
+            total_gain += i;
+        }
+    }
+#endif
+
+    encode_frame(s, s->coefs, buf, buf_size, total_gain);
+    assert((put_bits_count(&s->pb) & 7) == 0);
+    i= s->block_align - (put_bits_count(&s->pb)+7)/8;
+    assert(i>=0);
+    while(i--)
+        put_bits(&s->pb, 8, 'N');
+
+    flush_put_bits(&s->pb);
+    return pbBufPtr(&s->pb) - s->pb.buf;
+}
+
+AVCodec wmav1_encoder =
+{
+    "wmav1",
+    CODEC_TYPE_AUDIO,
+    CODEC_ID_WMAV1,
+    sizeof(WMADecodeContext),
+    encode_init,
+    encode_superframe,
+    ff_wma_end,
+};
+
+AVCodec wmav2_encoder =
+{
+    "wmav2",
+    CODEC_TYPE_AUDIO,
+    CODEC_ID_WMAV2,
+    sizeof(WMADecodeContext),
+    encode_init,
+    encode_superframe,
+    ff_wma_end,
+};