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