← Back to branch summary

~ubuntu-branches/ubuntu/saucy/gst-libav1.0/saucy-proposed

« back to all changes in this revision

Viewing changes to gst-libs/ext/libav/libavcodec/wma.c

  • Committer: Package Import Robot
  • Author(s): Sebastian Dröge
  • Date: 2013-07-30 09:00:15 UTC
  • mfrom: (1.1.16) (7.1.7 experimental)
  • Revision ID: package-import@ubuntu.com-20130730090015-sc1ou2yssu7q5w4e
Tags: 1.1.3-1
* New upstream development snapshot:
  + debian/control:
    - Build depend on GStreamer and gst-plugins-base >= 1.1.3.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gst-libs/ext/libav/libavcodec/wma.c
22
22
#include "avcodec.h"
23
23
#include "sinewin.h"
24
24
#include "wma.h"
 
25
#include "wma_common.h"
25
26
#include "wmadata.h"
26
27
 
27
28
#undef NDEBUG
67
68
    av_free(level_table);
68
69
}
69
70
 
70
 
/**
71
 
 *@brief Get the samples per frame for this stream.
72
 
 *@param sample_rate output sample_rate
73
 
 *@param version wma version
74
 
 *@param decode_flags codec compression features
75
 
 *@return log2 of the number of output samples per frame
76
 
 */
77
 
int av_cold ff_wma_get_frame_len_bits(int sample_rate, int version,
78
 
                                      unsigned int decode_flags)
79
 
{
80
 
 
81
 
    int frame_len_bits;
82
 
 
83
 
    if (sample_rate <= 16000) {
84
 
        frame_len_bits = 9;
85
 
    } else if (sample_rate <= 22050 ||
86
 
             (sample_rate <= 32000 && version == 1)) {
87
 
        frame_len_bits = 10;
88
 
    } else if (sample_rate <= 48000 || version < 3) {
89
 
        frame_len_bits = 11;
90
 
    } else if (sample_rate <= 96000) {
91
 
        frame_len_bits = 12;
92
 
    } else {
93
 
        frame_len_bits = 13;
94
 
    }
95
 
 
96
 
    if (version == 3) {
97
 
        int tmp = decode_flags & 0x6;
98
 
        if (tmp == 0x2) {
99
 
            ++frame_len_bits;
100
 
        } else if (tmp == 0x4) {
101
 
            --frame_len_bits;
102
 
        } else if (tmp == 0x6) {
103
 
            frame_len_bits -= 2;
104
 
        }
105
 
    }
106
 
 
107
 
    return frame_len_bits;
108
 
}
109
 
 
110
71
int ff_wma_init(AVCodecContext *avctx, int flags2)
111
72
{
112
73
    WMACodecContext *s = avctx->priv_data;
117
78
    int coef_vlc_table;
118
79
 
119
80
    if (   avctx->sample_rate <= 0 || avctx->sample_rate > 50000
120
 
        || avctx->channels    <= 0 || avctx->channels    > 8
 
81
        || avctx->channels    <= 0 || avctx->channels    > 2
121
82
        || avctx->bit_rate    <= 0)
122
83
        return -1;
123
84
 
124
 
    s->sample_rate = avctx->sample_rate;
125
 
    s->nb_channels = avctx->channels;
126
 
    s->bit_rate    = avctx->bit_rate;
127
 
    s->block_align = avctx->block_align;
128
 
 
129
 
    dsputil_init(&s->dsp, avctx);
 
85
    ff_dsputil_init(&s->dsp, avctx);
130
86
    ff_fmt_convert_init(&s->fmt_conv, avctx);
 
87
    avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
131
88
 
132
 
    if (avctx->codec->id == CODEC_ID_WMAV1) {
 
89
    if (avctx->codec->id == AV_CODEC_ID_WMAV1) {
133
90
        s->version = 1;
134
91
    } else {
135
92
        s->version = 2;
136
93
    }
137
94
 
138
95
    /* compute MDCT block size */
139
 
    s->frame_len_bits = ff_wma_get_frame_len_bits(s->sample_rate, s->version, 0);
 
96
    s->frame_len_bits = ff_wma_get_frame_len_bits(avctx->sample_rate,
 
97
                                                  s->version, 0);
140
98
    s->next_block_len_bits = s->frame_len_bits;
141
99
    s->prev_block_len_bits = s->frame_len_bits;
142
100
    s->block_len_bits      = s->frame_len_bits;
145
103
    if (s->use_variable_block_len) {
146
104
        int nb_max, nb;
147
105
        nb = ((flags2 >> 3) & 3) + 1;
148
 
        if ((s->bit_rate / s->nb_channels) >= 32000)
 
106
        if ((avctx->bit_rate / avctx->channels) >= 32000)
149
107
            nb += 2;
150
108
        nb_max = s->frame_len_bits - BLOCK_MIN_BITS;
151
109
        if (nb > nb_max)
157
115
 
158
116
    /* init rate dependent parameters */
159
117
    s->use_noise_coding = 1;
160
 
    high_freq = s->sample_rate * 0.5;
 
118
    high_freq = avctx->sample_rate * 0.5;
161
119
 
162
120
    /* if version 2, then the rates are normalized */
163
 
    sample_rate1 = s->sample_rate;
 
121
    sample_rate1 = avctx->sample_rate;
164
122
    if (s->version == 2) {
165
123
        if (sample_rate1 >= 44100) {
166
124
            sample_rate1 = 44100;
175
133
        }
176
134
    }
177
135
 
178
 
    bps = (float)s->bit_rate / (float)(s->nb_channels * s->sample_rate);
 
136
    bps = (float)avctx->bit_rate / (float)(avctx->channels * avctx->sample_rate);
179
137
    s->byte_offset_bits = av_log2((int)(bps * s->frame_len / 8.0 + 0.5)) + 2;
180
138
 
181
139
    /* compute high frequency value and choose if noise coding should
182
140
       be activated */
183
141
    bps1 = bps;
184
 
    if (s->nb_channels == 2)
 
142
    if (avctx->channels == 2)
185
143
        bps1 = bps * 1.6;
186
144
    if (sample_rate1 == 44100) {
187
145
        if (bps1 >= 0.61) {
224
182
    }
225
183
    av_dlog(s->avctx, "flags2=0x%x\n", flags2);
226
184
    av_dlog(s->avctx, "version=%d channels=%d sample_rate=%d bitrate=%d block_align=%d\n",
227
 
            s->version, s->nb_channels, s->sample_rate, s->bit_rate,
228
 
            s->block_align);
 
185
            s->version, avctx->channels, avctx->sample_rate, avctx->bit_rate,
 
186
            avctx->block_align);
229
187
    av_dlog(s->avctx, "bps=%f bps1=%f high_freq=%f bitoffset=%d\n",
230
188
            bps, bps1, high_freq, s->byte_offset_bits);
231
189
    av_dlog(s->avctx, "use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n",
248
206
                lpos = 0;
249
207
                for (i = 0; i < 25; i++) {
250
208
                    a = ff_wma_critical_freqs[i];
251
 
                    b = s->sample_rate;
 
209
                    b = avctx->sample_rate;
252
210
                    pos = ((block_len * 2 * a) + (b >> 1)) / b;
253
211
                    if (pos > block_len)
254
212
                        pos = block_len;
265
223
                table = NULL;
266
224
                a = s->frame_len_bits - BLOCK_MIN_BITS - k;
267
225
                if (a < 3) {
268
 
                    if (s->sample_rate >= 44100) {
 
226
                    if (avctx->sample_rate >= 44100) {
269
227
                        table = exponent_band_44100[a];
270
 
                    } else if (s->sample_rate >= 32000) {
 
228
                    } else if (avctx->sample_rate >= 32000) {
271
229
                        table = exponent_band_32000[a];
272
 
                    } else if (s->sample_rate >= 22050) {
 
230
                    } else if (avctx->sample_rate >= 22050) {
273
231
                        table = exponent_band_22050[a];
274
232
                    }
275
233
                }
283
241
                    lpos = 0;
284
242
                    for (i = 0; i < 25; i++) {
285
243
                        a = ff_wma_critical_freqs[i];
286
 
                        b = s->sample_rate;
 
244
                        b = avctx->sample_rate;
287
245
                        pos = ((block_len * 2 * a) + (b << 1)) / (4 * b);
288
246
                        pos <<= 2;
289
247
                        if (pos > block_len)
302
260
            s->coefs_end[k] = (s->frame_len - ((s->frame_len * 9) / 100)) >> k;
303
261
            /* high freq computation */
304
262
            s->high_band_start[k] = (int)((block_len * 2 * high_freq) /
305
 
                                          s->sample_rate + 0.5);
 
263
                                          avctx->sample_rate + 0.5);
306
264
            n = s->exponent_sizes[k];
307
265
            j = 0;
308
266
            pos = 0;
382
340
 
383
341
    /* choose the VLC tables for the coefficients */
384
342
    coef_vlc_table = 2;
385
 
    if (s->sample_rate >= 32000) {
 
343
    if (avctx->sample_rate >= 32000) {
386
344
        if (bps1 < 0.72) {
387
345
            coef_vlc_table = 0;
388
346
        } else if (bps1 < 1.16) {
525
483
 
526
484
    return 0;
527
485
}
528