ffv1dec: support decoding older 1.3 bitstream variant
[ffmpeg.git] / libavcodec / wmaenc.c
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 "internal.h"
24 #include "wma.h"
25 #include "libavutil/avassert.h"
26
27
28 static int encode_init(AVCodecContext * avctx){
29     WMACodecContext *s = avctx->priv_data;
30     int i, flags1, flags2;
31     uint8_t *extradata;
32
33     s->avctx = avctx;
34
35     if(avctx->channels > MAX_CHANNELS) {
36         av_log(avctx, AV_LOG_ERROR, "too many channels: got %i, need %i or fewer",
37                avctx->channels, MAX_CHANNELS);
38         return AVERROR(EINVAL);
39     }
40
41     if (avctx->sample_rate > 48000) {
42         av_log(avctx, AV_LOG_ERROR, "sample rate is too high: %d > 48kHz",
43                avctx->sample_rate);
44         return AVERROR(EINVAL);
45     }
46
47     if(avctx->bit_rate < 24*1000) {
48         av_log(avctx, AV_LOG_ERROR, "bitrate too low: got %i, need 24000 or higher\n",
49                avctx->bit_rate);
50         return AVERROR(EINVAL);
51     }
52
53     /* extract flag infos */
54     flags1 = 0;
55     flags2 = 1;
56     if (avctx->codec->id == AV_CODEC_ID_WMAV1) {
57         extradata= av_malloc(4);
58         avctx->extradata_size= 4;
59         AV_WL16(extradata, flags1);
60         AV_WL16(extradata+2, flags2);
61     } else if (avctx->codec->id == AV_CODEC_ID_WMAV2) {
62         extradata= av_mallocz(10);
63         avctx->extradata_size= 10;
64         AV_WL32(extradata, flags1);
65         AV_WL16(extradata+4, flags2);
66     }else
67         av_assert0(0);
68     avctx->extradata= extradata;
69     s->use_exp_vlc = flags2 & 0x0001;
70     s->use_bit_reservoir = flags2 & 0x0002;
71     s->use_variable_block_len = flags2 & 0x0004;
72     if (avctx->channels == 2)
73         s->ms_stereo = 1;
74
75     ff_wma_init(avctx, flags2);
76
77     /* init MDCT */
78     for(i = 0; i < s->nb_block_sizes; i++)
79         ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 0, 1.0);
80
81     s->block_align     = avctx->bit_rate * (int64_t)s->frame_len /
82                          (avctx->sample_rate * 8);
83     s->block_align     = FFMIN(s->block_align, MAX_CODED_SUPERFRAME_SIZE);
84     avctx->block_align = s->block_align;
85 //av_log(NULL, AV_LOG_ERROR, "%d %d %d %d\n", s->block_align, avctx->bit_rate, s->frame_len, avctx->sample_rate);
86     avctx->frame_size = avctx->delay = s->frame_len;
87
88 #if FF_API_OLD_ENCODE_AUDIO
89     avctx->coded_frame = &s->frame;
90     avcodec_get_frame_defaults(avctx->coded_frame);
91 #endif
92
93     return 0;
94 }
95
96
97 static void apply_window_and_mdct(AVCodecContext * avctx, const signed short * audio, int len) {
98     WMACodecContext *s = avctx->priv_data;
99     int window_index= s->frame_len_bits - s->block_len_bits;
100     FFTContext *mdct = &s->mdct_ctx[window_index];
101     int i, j, channel;
102     const float * win = s->windows[window_index];
103     int window_len = 1 << s->block_len_bits;
104     float n = window_len/2;
105
106     for (channel = 0; channel < avctx->channels; channel++) {
107         memcpy(s->output, s->frame_out[channel], sizeof(float)*window_len);
108         j = channel;
109         for (i = 0; i < len; i++, j += avctx->channels){
110             s->output[i+window_len]  = audio[j] / n * win[window_len - i - 1];
111             s->frame_out[channel][i] = audio[j] / n * win[i];
112         }
113         mdct->mdct_calc(mdct, s->coefs[channel], s->output);
114     }
115 }
116
117 //FIXME use for decoding too
118 static void init_exp(WMACodecContext *s, int ch, const int *exp_param){
119     int n;
120     const uint16_t *ptr;
121     float v, *q, max_scale, *q_end;
122
123     ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
124     q = s->exponents[ch];
125     q_end = q + s->block_len;
126     max_scale = 0;
127     while (q < q_end) {
128         /* XXX: use a table */
129         v = pow(10, *exp_param++ * (1.0 / 16.0));
130         max_scale= FFMAX(max_scale, v);
131         n = *ptr++;
132         do {
133             *q++ = v;
134         } while (--n);
135     }
136     s->max_exponent[ch] = max_scale;
137 }
138
139 static void encode_exp_vlc(WMACodecContext *s, int ch, const int *exp_param){
140     int last_exp;
141     const uint16_t *ptr;
142     float *q, *q_end;
143
144     ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
145     q = s->exponents[ch];
146     q_end = q + s->block_len;
147     if (s->version == 1) {
148         last_exp= *exp_param++;
149         av_assert0(last_exp-10 >= 0 && last_exp-10 < 32);
150         put_bits(&s->pb, 5, last_exp - 10);
151         q+= *ptr++;
152     }else
153         last_exp = 36;
154     while (q < q_end) {
155         int exp = *exp_param++;
156         int code = exp - last_exp + 60;
157         av_assert1(code >= 0 && code < 120);
158         put_bits(&s->pb, ff_aac_scalefactor_bits[code], ff_aac_scalefactor_code[code]);
159         /* XXX: use a table */
160         q+= *ptr++;
161         last_exp= exp;
162     }
163 }
164
165 static int encode_block(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE], int total_gain){
166     int v, bsize, ch, coef_nb_bits, parse_exponents;
167     float mdct_norm;
168     int nb_coefs[MAX_CHANNELS];
169     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};
170
171     //FIXME remove duplication relative to decoder
172     if (s->use_variable_block_len) {
173         av_assert0(0); //FIXME not implemented
174     }else{
175         /* fixed block len */
176         s->next_block_len_bits = s->frame_len_bits;
177         s->prev_block_len_bits = s->frame_len_bits;
178         s->block_len_bits = s->frame_len_bits;
179     }
180
181     s->block_len = 1 << s->block_len_bits;
182 //     assert((s->block_pos + s->block_len) <= s->frame_len);
183     bsize = s->frame_len_bits - s->block_len_bits;
184
185     //FIXME factor
186     v = s->coefs_end[bsize] - s->coefs_start;
187     for(ch = 0; ch < s->nb_channels; ch++)
188         nb_coefs[ch] = v;
189     {
190         int n4 = s->block_len / 2;
191         mdct_norm = 1.0 / (float)n4;
192         if (s->version == 1) {
193             mdct_norm *= sqrt(n4);
194         }
195     }
196
197     if (s->nb_channels == 2) {
198         put_bits(&s->pb, 1, !!s->ms_stereo);
199     }
200
201     for(ch = 0; ch < s->nb_channels; ch++) {
202         s->channel_coded[ch] = 1; //FIXME only set channel_coded when needed, instead of always
203         if (s->channel_coded[ch]) {
204             init_exp(s, ch, fixed_exp);
205         }
206     }
207
208     for(ch = 0; ch < s->nb_channels; ch++) {
209         if (s->channel_coded[ch]) {
210             WMACoef *coefs1;
211             float *coefs, *exponents, mult;
212             int i, n;
213
214             coefs1 = s->coefs1[ch];
215             exponents = s->exponents[ch];
216             mult = pow(10, total_gain * 0.05) / s->max_exponent[ch];
217             mult *= mdct_norm;
218             coefs = src_coefs[ch];
219             if (s->use_noise_coding && 0) {
220                 av_assert0(0); //FIXME not implemented
221             } else {
222                 coefs += s->coefs_start;
223                 n = nb_coefs[ch];
224                 for(i = 0;i < n; i++){
225                     double t= *coefs++ / (exponents[i] * mult);
226                     if(t<-32768 || t>32767)
227                         return -1;
228
229                     coefs1[i] = lrint(t);
230                 }
231             }
232         }
233     }
234
235     v = 0;
236     for(ch = 0; ch < s->nb_channels; ch++) {
237         int a = s->channel_coded[ch];
238         put_bits(&s->pb, 1, a);
239         v |= a;
240     }
241
242     if (!v)
243         return 1;
244
245     for(v= total_gain-1; v>=127; v-= 127)
246         put_bits(&s->pb, 7, 127);
247     put_bits(&s->pb, 7, v);
248
249     coef_nb_bits= ff_wma_total_gain_to_bits(total_gain);
250
251     if (s->use_noise_coding) {
252         for(ch = 0; ch < s->nb_channels; ch++) {
253             if (s->channel_coded[ch]) {
254                 int i, n;
255                 n = s->exponent_high_sizes[bsize];
256                 for(i=0;i<n;i++) {
257                     put_bits(&s->pb, 1, s->high_band_coded[ch][i]= 0);
258                     if (0)
259                         nb_coefs[ch] -= s->exponent_high_bands[bsize][i];
260                 }
261             }
262         }
263     }
264
265     parse_exponents = 1;
266     if (s->block_len_bits != s->frame_len_bits) {
267         put_bits(&s->pb, 1, parse_exponents);
268     }
269
270     if (parse_exponents) {
271         for(ch = 0; ch < s->nb_channels; ch++) {
272             if (s->channel_coded[ch]) {
273                 if (s->use_exp_vlc) {
274                     encode_exp_vlc(s, ch, fixed_exp);
275                 } else {
276                     av_assert0(0); //FIXME not implemented
277 //                    encode_exp_lsp(s, ch);
278                 }
279             }
280         }
281     } else {
282         av_assert0(0); //FIXME not implemented
283     }
284
285     for(ch = 0; ch < s->nb_channels; ch++) {
286         if (s->channel_coded[ch]) {
287             int run, tindex;
288             WMACoef *ptr, *eptr;
289             tindex = (ch == 1 && s->ms_stereo);
290             ptr = &s->coefs1[ch][0];
291             eptr = ptr + nb_coefs[ch];
292
293             run=0;
294             for(;ptr < eptr; ptr++){
295                 if(*ptr){
296                     int level= *ptr;
297                     int abs_level= FFABS(level);
298                     int code= 0;
299                     if(abs_level <= s->coef_vlcs[tindex]->max_level){
300                         if(run < s->coef_vlcs[tindex]->levels[abs_level-1])
301                             code= run + s->int_table[tindex][abs_level-1];
302                     }
303
304                     av_assert2(code < s->coef_vlcs[tindex]->n);
305                     put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[code], s->coef_vlcs[tindex]->huffcodes[code]);
306
307                     if(code == 0){
308                         if(1<<coef_nb_bits <= abs_level)
309                             return -1;
310
311                         put_bits(&s->pb, coef_nb_bits, abs_level);
312                         put_bits(&s->pb, s->frame_len_bits, run);
313                     }
314                     put_bits(&s->pb, 1, level < 0); //FIXME the sign is fliped somewhere
315                     run=0;
316                 }else{
317                     run++;
318                 }
319             }
320             if(run)
321                 put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[1], s->coef_vlcs[tindex]->huffcodes[1]);
322         }
323         if (s->version == 1 && s->nb_channels >= 2) {
324             avpriv_align_put_bits(&s->pb);
325         }
326     }
327     return 0;
328 }
329
330 static int encode_frame(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE], uint8_t *buf, int buf_size, int total_gain){
331     init_put_bits(&s->pb, buf, buf_size);
332
333     if (s->use_bit_reservoir) {
334         av_assert0(0);//FIXME not implemented
335     }else{
336         if(encode_block(s, src_coefs, total_gain) < 0)
337             return INT_MAX;
338     }
339
340     avpriv_align_put_bits(&s->pb);
341
342     return put_bits_count(&s->pb)/8 - s->block_align;
343 }
344
345 static int encode_superframe(AVCodecContext *avctx, AVPacket *avpkt,
346                              const AVFrame *frame, int *got_packet_ptr)
347 {
348     WMACodecContext *s = avctx->priv_data;
349     const int16_t *samples = (const int16_t *)frame->data[0];
350     int i, total_gain, ret, error;
351
352     s->block_len_bits= s->frame_len_bits; //required by non variable block len
353     s->block_len = 1 << s->block_len_bits;
354
355     apply_window_and_mdct(avctx, samples, frame->nb_samples);
356
357     if (s->ms_stereo) {
358         float a, b;
359         int i;
360
361         for(i = 0; i < s->block_len; i++) {
362             a = s->coefs[0][i]*0.5;
363             b = s->coefs[1][i]*0.5;
364             s->coefs[0][i] = a + b;
365             s->coefs[1][i] = a - b;
366         }
367     }
368
369     if ((ret = ff_alloc_packet2(avctx, avpkt, 2 * MAX_CODED_SUPERFRAME_SIZE)))
370         return ret;
371
372     total_gain= 128;
373     for(i=64; i; i>>=1){
374         error = encode_frame(s, s->coefs, avpkt->data, avpkt->size,
375                                  total_gain - i);
376         if(error<=0)
377             total_gain-= i;
378     }
379
380     while(total_gain <= 128 && error > 0)
381         error = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain++);
382     av_assert0((put_bits_count(&s->pb) & 7) == 0);
383     i= s->block_align - (put_bits_count(&s->pb)+7)/8;
384     av_assert0(i>=0);
385     while(i--)
386         put_bits(&s->pb, 8, 'N');
387
388     flush_put_bits(&s->pb);
389     av_assert0(put_bits_ptr(&s->pb) - s->pb.buf == s->block_align);
390
391     if (frame->pts != AV_NOPTS_VALUE)
392         avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->delay);
393
394     avpkt->size = s->block_align;
395     *got_packet_ptr = 1;
396     return 0;
397 }
398
399 #if CONFIG_WMAV1_ENCODER
400 AVCodec ff_wmav1_encoder = {
401     .name           = "wmav1",
402     .type           = AVMEDIA_TYPE_AUDIO,
403     .id             = AV_CODEC_ID_WMAV1,
404     .priv_data_size = sizeof(WMACodecContext),
405     .init           = encode_init,
406     .encode2        = encode_superframe,
407     .close          = ff_wma_end,
408     .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
409                                                      AV_SAMPLE_FMT_NONE },
410     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),
411 };
412 #endif
413 #if CONFIG_WMAV2_ENCODER
414 AVCodec ff_wmav2_encoder = {
415     .name           = "wmav2",
416     .type           = AVMEDIA_TYPE_AUDIO,
417     .id             = AV_CODEC_ID_WMAV2,
418     .priv_data_size = sizeof(WMACodecContext),
419     .init           = encode_init,
420     .encode2        = encode_superframe,
421     .close          = ff_wma_end,
422     .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
423                                                      AV_SAMPLE_FMT_NONE },
424     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),
425 };
426 #endif