Statistics
| Branch: | Revision:

ffmpeg / libavcodec / wmaenc.c @ 1890c2ac

History | View | Annotate | Download (12 KB)

1
/*
2
 * WMA compatible encoder
3
 * Copyright (c) 2007 Michael Niedermayer
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
#include "avcodec.h"
23
#include "wma.h"
24

    
25
#undef NDEBUG
26
#include <assert.h>
27

    
28

    
29
static int encode_init(AVCodecContext * avctx){
30
    WMACodecContext *s = avctx->priv_data;
31
    int i, flags1, flags2;
32
    uint8_t *extradata;
33

    
34
    s->avctx = avctx;
35

    
36
    if(avctx->channels > MAX_CHANNELS)
37
        return -1;
38

    
39
    if(avctx->bit_rate < 24*1000)
40
        return -1;
41

    
42
    /* extract flag infos */
43
    flags1 = 0;
44
    flags2 = 1;
45
    if (avctx->codec->id == CODEC_ID_WMAV1) {
46
        extradata= av_malloc(4);
47
        avctx->extradata_size= 4;
48
        extradata[0] = flags1;
49
        extradata[1] = flags1>>8;
50
        extradata[2] = flags2;
51
        extradata[3] = flags2>>8;
52
    } else if (avctx->codec->id == CODEC_ID_WMAV2) {
53
        extradata= av_mallocz(10);
54
        avctx->extradata_size= 10;
55
        extradata[0] = flags1;
56
        extradata[1] = flags1>>8;
57
        extradata[2] = flags1>>16;
58
        extradata[3] = flags1>>24;
59
        extradata[4] = flags2;
60
        extradata[5] = flags2>>8;
61
    }else
62
        assert(0);
63
    avctx->extradata= extradata;
64
    s->use_exp_vlc = flags2 & 0x0001;
65
    s->use_bit_reservoir = flags2 & 0x0002;
66
    s->use_variable_block_len = flags2 & 0x0004;
67

    
68
    ff_wma_init(avctx, flags2);
69

    
70
    /* init MDCT */
71
    for(i = 0; i < s->nb_block_sizes; i++)
72
        ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 0);
73

    
74
    avctx->block_align=
75
    s->block_align= avctx->bit_rate*(int64_t)s->frame_len / (avctx->sample_rate*8);
76
//av_log(NULL, AV_LOG_ERROR, "%d %d %d %d\n", s->block_align, avctx->bit_rate, s->frame_len, avctx->sample_rate);
77
    avctx->frame_size= s->frame_len;
78

    
79
    return 0;
80
}
81

    
82

    
83
static void apply_window_and_mdct(AVCodecContext * avctx, signed short * audio, int len) {
84
    WMACodecContext *s = avctx->priv_data;
85
    int window_index= s->frame_len_bits - s->block_len_bits;
86
    int i, j, channel;
87
    const float * win = s->windows[window_index];
88
    int window_len = 1 << s->block_len_bits;
89
    float n = window_len/2;
90

    
91
    for (channel = 0; channel < avctx->channels; channel++) {
92
        memcpy(s->output, s->frame_out[channel], sizeof(float)*window_len);
93
        j = channel;
94
        for (i = 0; i < len; i++, j += avctx->channels){
95
            s->output[i+window_len]  = audio[j] / n * win[window_len - i - 1];
96
            s->frame_out[channel][i] = audio[j] / n * win[i];
97
        }
98
        ff_mdct_calc(&s->mdct_ctx[window_index], s->coefs[channel], s->output, s->mdct_tmp);
99
    }
100
}
101

    
102
//FIXME use for decoding too
103
static void init_exp(WMACodecContext *s, int ch, int *exp_param){
104
    int n;
105
    const uint16_t *ptr;
106
    float v, *q, max_scale, *q_end;
107

    
108
    ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
109
    q = s->exponents[ch];
110
    q_end = q + s->block_len;
111
    max_scale = 0;
112
    while (q < q_end) {
113
        /* XXX: use a table */
114
        v = pow(10, *exp_param++ * (1.0 / 16.0));
115
        max_scale= FFMAX(max_scale, v);
116
        n = *ptr++;
117
        do {
118
            *q++ = v;
119
        } while (--n);
120
    }
121
    s->max_exponent[ch] = max_scale;
122
}
123

    
124
static void encode_exp_vlc(WMACodecContext *s, int ch, const int *exp_param){
125
    int last_exp;
126
    const uint16_t *ptr;
127
    float *q, *q_end;
128

    
129
    ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
130
    q = s->exponents[ch];
131
    q_end = q + s->block_len;
132
    if (s->version == 1) {
133
        last_exp= *exp_param++;
134
        assert(last_exp-10 >= 0 && last_exp-10 < 32);
135
        put_bits(&s->pb, 5, last_exp - 10);
136
        q+= *ptr++;
137
    }else
138
        last_exp = 36;
139
    while (q < q_end) {
140
        int exp = *exp_param++;
141
        int code = exp - last_exp + 60;
142
        assert(code >= 0 && code < 120);
143
        put_bits(&s->pb, ff_wma_scale_huffbits[code], ff_wma_scale_huffcodes[code]);
144
        /* XXX: use a table */
145
        q+= *ptr++;
146
        last_exp= exp;
147
    }
148
}
149

    
150
static int encode_block(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE], int total_gain){
151
    int v, bsize, ch, coef_nb_bits, parse_exponents;
152
    float mdct_norm;
153
    int nb_coefs[MAX_CHANNELS];
154
    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};
155

    
156
    //FIXME remove duplication relative to decoder
157
    if (s->use_variable_block_len) {
158
        assert(0); //FIXME not implemented
159
    }else{
160
        /* fixed block len */
161
        s->next_block_len_bits = s->frame_len_bits;
162
        s->prev_block_len_bits = s->frame_len_bits;
163
        s->block_len_bits = s->frame_len_bits;
164
    }
165

    
166
    s->block_len = 1 << s->block_len_bits;
167
//     assert((s->block_pos + s->block_len) <= s->frame_len);
168
    bsize = s->frame_len_bits - s->block_len_bits;
169

    
170
    //FIXME factor
171
    v = s->coefs_end[bsize] - s->coefs_start;
172
    for(ch = 0; ch < s->nb_channels; ch++)
173
        nb_coefs[ch] = v;
174
    {
175
        int n4 = s->block_len / 2;
176
        mdct_norm = 1.0 / (float)n4;
177
        if (s->version == 1) {
178
            mdct_norm *= sqrt(n4);
179
        }
180
    }
181

    
182
    if (s->nb_channels == 2) {
183
        put_bits(&s->pb, 1, s->ms_stereo= 1);
184
    }
185

    
186
    for(ch = 0; ch < s->nb_channels; ch++) {
187
        if (s->channel_coded[ch]= 1) { //FIXME
188
            init_exp(s, ch, fixed_exp);
189
        }
190
    }
191

    
192
    for(ch = 0; ch < s->nb_channels; ch++) {
193
        if (s->channel_coded[ch]) {
194
            int16_t *coefs1;
195
            float *coefs, *exponents, mult;
196
            int i, n;
197

    
198
            coefs1 = s->coefs1[ch];
199
            exponents = s->exponents[ch];
200
            mult = pow(10, total_gain * 0.05) / s->max_exponent[ch];
201
            mult *= mdct_norm;
202
            coefs = src_coefs[ch];
203
            if (s->use_noise_coding && 0) {
204
                assert(0); //FIXME not implemented
205
            } else {
206
                coefs += s->coefs_start;
207
                n = nb_coefs[ch];
208
                for(i = 0;i < n; i++){
209
                    double t= *coefs++ / (exponents[i] * mult);
210
                    if(t<-32768 || t>32767)
211
                        return -1;
212

    
213
                    coefs1[i] = lrint(t);
214
                }
215
            }
216
        }
217
    }
218

    
219
    v = 0;
220
    for(ch = 0; ch < s->nb_channels; ch++) {
221
        int a = s->channel_coded[ch];
222
        put_bits(&s->pb, 1, a);
223
        v |= a;
224
    }
225

    
226
    if (!v)
227
        return 1;
228

    
229
    for(v= total_gain-1; v>=127; v-= 127)
230
        put_bits(&s->pb, 7, 127);
231
    put_bits(&s->pb, 7, v);
232

    
233
    coef_nb_bits= ff_wma_total_gain_to_bits(total_gain);
234

    
235
    if (s->use_noise_coding) {
236
        for(ch = 0; ch < s->nb_channels; ch++) {
237
            if (s->channel_coded[ch]) {
238
                int i, n;
239
                n = s->exponent_high_sizes[bsize];
240
                for(i=0;i<n;i++) {
241
                    put_bits(&s->pb, 1, s->high_band_coded[ch][i]= 0);
242
                    if (0)
243
                        nb_coefs[ch] -= s->exponent_high_bands[bsize][i];
244
                }
245
            }
246
        }
247
    }
248

    
249
    parse_exponents = 1;
250
    if (s->block_len_bits != s->frame_len_bits) {
251
        put_bits(&s->pb, 1, parse_exponents);
252
    }
253

    
254
    if (parse_exponents) {
255
        for(ch = 0; ch < s->nb_channels; ch++) {
256
            if (s->channel_coded[ch]) {
257
                if (s->use_exp_vlc) {
258
                    encode_exp_vlc(s, ch, fixed_exp);
259
                } else {
260
                    assert(0); //FIXME not implemented
261
//                    encode_exp_lsp(s, ch);
262
                }
263
            }
264
        }
265
    } else {
266
        assert(0); //FIXME not implemented
267
    }
268

    
269
    for(ch = 0; ch < s->nb_channels; ch++) {
270
        if (s->channel_coded[ch]) {
271
            int run, tindex;
272
            int16_t *ptr, *eptr;
273
            tindex = (ch == 1 && s->ms_stereo);
274
            ptr = &s->coefs1[ch][0];
275
            eptr = ptr + nb_coefs[ch];
276

    
277
            run=0;
278
            for(;ptr < eptr; ptr++){
279
                if(*ptr){
280
                    int level= *ptr;
281
                    int abs_level= FFABS(level);
282
                    int code= 0;
283
                    if(abs_level <= s->coef_vlcs[tindex]->max_level){
284
                        if(run < s->coef_vlcs[tindex]->levels[abs_level-1])
285
                            code= run + s->int_table[tindex][abs_level-1];
286
                    }
287

    
288
                    assert(code < s->coef_vlcs[tindex]->n);
289
                    put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[code], s->coef_vlcs[tindex]->huffcodes[code]);
290

    
291
                    if(code == 0){
292
                        if(1<<coef_nb_bits <= abs_level)
293
                            return -1;
294

    
295
                        put_bits(&s->pb, coef_nb_bits, abs_level);
296
                        put_bits(&s->pb, s->frame_len_bits, run);
297
                    }
298
                    put_bits(&s->pb, 1, level < 0); //FIXME the sign is fliped somewhere
299
                    run=0;
300
                }else{
301
                    run++;
302
                }
303
            }
304
            if(run)
305
                put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[1], s->coef_vlcs[tindex]->huffcodes[1]);
306
        }
307
        if (s->version == 1 && s->nb_channels >= 2) {
308
            align_put_bits(&s->pb);
309
        }
310
    }
311
    return 0;
312
}
313

    
314
static int encode_frame(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE], uint8_t *buf, int buf_size, int total_gain){
315
    init_put_bits(&s->pb, buf, buf_size);
316

    
317
    if (s->use_bit_reservoir) {
318
        assert(0);//FIXME not implemented
319
    }else{
320
        if(encode_block(s, src_coefs, total_gain) < 0)
321
            return INT_MAX;
322
    }
323

    
324
    align_put_bits(&s->pb);
325

    
326
    return put_bits_count(&s->pb)/8 - s->block_align;
327
}
328

    
329
static int encode_superframe(AVCodecContext *avctx,
330
                            unsigned char *buf, int buf_size, void *data){
331
    WMACodecContext *s = avctx->priv_data;
332
    short *samples = data;
333
    int i, total_gain, best;
334

    
335
    s->block_len_bits= s->frame_len_bits; //required by non variable block len
336
    s->block_len = 1 << s->block_len_bits;
337

    
338
    apply_window_and_mdct(avctx, samples, avctx->frame_size);
339

    
340
    if (s->ms_stereo) {
341
        float a, b;
342
        int i;
343

    
344
        for(i = 0; i < s->block_len; i++) {
345
            a = s->coefs[0][i]*0.5;
346
            b = s->coefs[1][i]*0.5;
347
            s->coefs[0][i] = a + b;
348
            s->coefs[1][i] = a - b;
349
        }
350
    }
351

    
352
#if 1
353
    total_gain= 128;
354
    for(i=64; i; i>>=1){
355
        int error= encode_frame(s, s->coefs, buf, buf_size, total_gain-i);
356
        if(error<0)
357
            total_gain-= i;
358
    }
359
#else
360
    total_gain= 90;
361
    best= encode_frame(s, s->coefs, buf, buf_size, total_gain);
362
    for(i=32; i; i>>=1){
363
        int scoreL= encode_frame(s, s->coefs, buf, buf_size, total_gain-i);
364
        int scoreR= encode_frame(s, s->coefs, buf, buf_size, total_gain+i);
365
        av_log(NULL, AV_LOG_ERROR, "%d %d %d (%d)\n", scoreL, best, scoreR, total_gain);
366
        if(scoreL < FFMIN(best, scoreR)){
367
            best = scoreL;
368
            total_gain -= i;
369
        }else if(scoreR < best){
370
            best = scoreR;
371
            total_gain += i;
372
        }
373
    }
374
#endif
375

    
376
    encode_frame(s, s->coefs, buf, buf_size, total_gain);
377
    assert((put_bits_count(&s->pb) & 7) == 0);
378
    i= s->block_align - (put_bits_count(&s->pb)+7)/8;
379
    assert(i>=0);
380
    while(i--)
381
        put_bits(&s->pb, 8, 'N');
382

    
383
    flush_put_bits(&s->pb);
384
    return pbBufPtr(&s->pb) - s->pb.buf;
385
}
386

    
387
AVCodec wmav1_encoder =
388
{
389
    "wmav1",
390
    CODEC_TYPE_AUDIO,
391
    CODEC_ID_WMAV1,
392
    sizeof(WMACodecContext),
393
    encode_init,
394
    encode_superframe,
395
    ff_wma_end,
396
};
397

    
398
AVCodec wmav2_encoder =
399
{
400
    "wmav2",
401
    CODEC_TYPE_AUDIO,
402
    CODEC_ID_WMAV2,
403
    sizeof(WMACodecContext),
404
    encode_init,
405
    encode_superframe,
406
    ff_wma_end,
407
};