The MPEG4AAC codec is provided by an external library and will be disabled
[libav.git] / libavcodec / pcm.c
CommitLineData
a96b68b7
FB
1/*
2 * PCM codecs
ff4ec49e 3 * Copyright (c) 2001 Fabrice Bellard.
a96b68b7 4 *
b78e7197
DB
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
ff4ec49e
FB
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
b78e7197 10 * version 2.1 of the License, or (at your option) any later version.
a96b68b7 11 *
b78e7197 12 * FFmpeg is distributed in the hope that it will be useful,
a96b68b7 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
ff4ec49e
FB
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
a96b68b7 16 *
ff4ec49e 17 * You should have received a copy of the GNU Lesser General Public
b78e7197 18 * License along with FFmpeg; if not, write to the Free Software
5509bffa 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
a96b68b7 20 */
115329f1 21
1ab3d669
MN
22/**
23 * @file pcm.c
24 * PCM codecs
25 */
115329f1 26
a96b68b7 27#include "avcodec.h"
b461b3bc 28#include "bitstream.h" // for ff_reverse
5a2f421a 29#include "bytestream.h"
a96b68b7 30
725d86bf
AJ
31#define MAX_CHANNELS 64
32
a96b68b7
FB
33/* from g711.c by SUN microsystems (unrestricted use) */
34
bb270c08
DB
35#define SIGN_BIT (0x80) /* Sign bit for a A-law byte. */
36#define QUANT_MASK (0xf) /* Quantization field mask. */
37#define NSEGS (8) /* Number of A-law segments. */
38#define SEG_SHIFT (4) /* Left shift for segment number. */
39#define SEG_MASK (0x70) /* Segment field mask. */
a96b68b7 40
bb270c08 41#define BIAS (0x84) /* Bias for linear code. */
a96b68b7
FB
42
43/*
44 * alaw2linear() - Convert an A-law value to 16-bit linear PCM
45 *
46 */
98a6fff9 47static av_cold int alaw2linear(unsigned char a_val)
a96b68b7 48{
bb270c08
DB
49 int t;
50 int seg;
a96b68b7 51
bb270c08 52 a_val ^= 0x55;
a96b68b7 53
bb270c08
DB
54 t = a_val & QUANT_MASK;
55 seg = ((unsigned)a_val & SEG_MASK) >> SEG_SHIFT;
56 if(seg) t= (t + t + 1 + 32) << (seg + 2);
57 else t= (t + t + 1 ) << 3;
cd1f22f9 58
ccd425e7 59 return (a_val & SIGN_BIT) ? t : -t;
a96b68b7
FB
60}
61
98a6fff9 62static av_cold int ulaw2linear(unsigned char u_val)
a96b68b7 63{
bb270c08 64 int t;
a96b68b7 65
bb270c08
DB
66 /* Complement to obtain normal u-law value. */
67 u_val = ~u_val;
a96b68b7 68
bb270c08
DB
69 /*
70 * Extract and bias the quantization bits. Then
71 * shift up by the segment number and subtract out the bias.
72 */
73 t = ((u_val & QUANT_MASK) << 3) + BIAS;
74 t <<= ((unsigned)u_val & SEG_MASK) >> SEG_SHIFT;
a96b68b7 75
ccd425e7 76 return (u_val & SIGN_BIT) ? (BIAS - t) : (t - BIAS);
a96b68b7
FB
77}
78
79/* 16384 entries per table */
e2e712e7
MN
80static uint8_t linear_to_alaw[16384];
81static uint8_t linear_to_ulaw[16384];
a96b68b7 82
98a6fff9 83static av_cold void build_xlaw_table(uint8_t *linear_to_xlaw,
a96b68b7 84 int (*xlaw2linear)(unsigned char),
115329f1 85 int mask)
a96b68b7
FB
86{
87 int i, j, v, v1, v2;
88
89 j = 0;
90 for(i=0;i<128;i++) {
91 if (i != 127) {
92 v1 = xlaw2linear(i ^ mask);
93 v2 = xlaw2linear((i + 1) ^ mask);
94 v = (v1 + v2 + 4) >> 3;
95 } else {
96 v = 8192;
97 }
98 for(;j<v;j++) {
99 linear_to_xlaw[8192 + j] = (i ^ mask);
100 if (j > 0)
101 linear_to_xlaw[8192 - j] = (i ^ (mask ^ 0x80));
102 }
103 }
104 linear_to_xlaw[0] = linear_to_xlaw[1];
105}
106
98a6fff9 107static av_cold int pcm_encode_init(AVCodecContext *avctx)
a96b68b7
FB
108{
109 avctx->frame_size = 1;
110 switch(avctx->codec->id) {
111 case CODEC_ID_PCM_ALAW:
e2e712e7 112 build_xlaw_table(linear_to_alaw, alaw2linear, 0xd5);
a96b68b7
FB
113 break;
114 case CODEC_ID_PCM_MULAW:
e2e712e7 115 build_xlaw_table(linear_to_ulaw, ulaw2linear, 0xff);
a96b68b7
FB
116 break;
117 default:
118 break;
119 }
115329f1 120
359fa0fe 121 switch(avctx->codec->id) {
b461b3bc
RD
122 case CODEC_ID_PCM_S32LE:
123 case CODEC_ID_PCM_S32BE:
124 case CODEC_ID_PCM_U32LE:
125 case CODEC_ID_PCM_U32BE:
126 avctx->block_align = 4 * avctx->channels;
127 break;
128 case CODEC_ID_PCM_S24LE:
129 case CODEC_ID_PCM_S24BE:
130 case CODEC_ID_PCM_U24LE:
131 case CODEC_ID_PCM_U24BE:
132 case CODEC_ID_PCM_S24DAUD:
133 avctx->block_align = 3 * avctx->channels;
134 break;
359fa0fe
MN
135 case CODEC_ID_PCM_S16LE:
136 case CODEC_ID_PCM_S16BE:
137 case CODEC_ID_PCM_U16LE:
138 case CODEC_ID_PCM_U16BE:
139 avctx->block_align = 2 * avctx->channels;
140 break;
141 case CODEC_ID_PCM_S8:
142 case CODEC_ID_PCM_U8:
143 case CODEC_ID_PCM_MULAW:
144 case CODEC_ID_PCM_ALAW:
145 avctx->block_align = avctx->channels;
146 break;
147 default:
148 break;
149 }
150
492cd3a9
MN
151 avctx->coded_frame= avcodec_alloc_frame();
152 avctx->coded_frame->key_frame= 1;
115329f1 153
a96b68b7
FB
154 return 0;
155}
156
98a6fff9 157static av_cold int pcm_encode_close(AVCodecContext *avctx)
a96b68b7 158{
492cd3a9
MN
159 av_freep(&avctx->coded_frame);
160
a96b68b7
FB
161 return 0;
162}
163
b461b3bc
RD
164/**
165 * \brief convert samples from 16 bit
166 * \param bps byte per sample for the destination format, must be >= 2
167 * \param le 0 for big-, 1 for little-endian
6c0d6064 168 * \param us 0 for signed, 1 for unsigned output
b461b3bc
RD
169 * \param samples input samples
170 * \param dst output samples
171 * \param n number of samples in samples buffer.
172 */
173static inline void encode_from16(int bps, int le, int us,
174 short **samples, uint8_t **dst, int n) {
7d5aaa04 175 int usum = us ? 0x8000 : 0;
b461b3bc
RD
176 if (bps > 2)
177 memset(*dst, 0, n * bps);
178 if (le) *dst += bps - 2;
179 for(;n>0;n--) {
180 register int v = *(*samples)++;
7d5aaa04 181 v += usum;
b3a257af
RP
182 if (le) AV_WL16(*dst, v);
183 else AV_WB16(*dst, v);
b461b3bc
RD
184 *dst += bps;
185 }
186 if (le) *dst -= bps - 2;
187}
188
cd4af68a 189static int pcm_encode_frame(AVCodecContext *avctx,
bb270c08 190 unsigned char *frame, int buf_size, void *data)
a96b68b7
FB
191{
192 int n, sample_size, v;
193 short *samples;
194 unsigned char *dst;
195
196 switch(avctx->codec->id) {
b461b3bc
RD
197 case CODEC_ID_PCM_S32LE:
198 case CODEC_ID_PCM_S32BE:
199 case CODEC_ID_PCM_U32LE:
200 case CODEC_ID_PCM_U32BE:
201 sample_size = 4;
202 break;
203 case CODEC_ID_PCM_S24LE:
204 case CODEC_ID_PCM_S24BE:
205 case CODEC_ID_PCM_U24LE:
206 case CODEC_ID_PCM_U24BE:
207 case CODEC_ID_PCM_S24DAUD:
208 sample_size = 3;
209 break;
a96b68b7
FB
210 case CODEC_ID_PCM_S16LE:
211 case CODEC_ID_PCM_S16BE:
212 case CODEC_ID_PCM_U16LE:
213 case CODEC_ID_PCM_U16BE:
214 sample_size = 2;
215 break;
216 default:
217 sample_size = 1;
218 break;
219 }
220 n = buf_size / sample_size;
221 samples = data;
222 dst = frame;
223
224 switch(avctx->codec->id) {
b461b3bc
RD
225 case CODEC_ID_PCM_S32LE:
226 encode_from16(4, 1, 0, &samples, &dst, n);
227 break;
228 case CODEC_ID_PCM_S32BE:
229 encode_from16(4, 0, 0, &samples, &dst, n);
230 break;
231 case CODEC_ID_PCM_U32LE:
232 encode_from16(4, 1, 1, &samples, &dst, n);
233 break;
234 case CODEC_ID_PCM_U32BE:
235 encode_from16(4, 0, 1, &samples, &dst, n);
236 break;
237 case CODEC_ID_PCM_S24LE:
238 encode_from16(3, 1, 0, &samples, &dst, n);
239 break;
240 case CODEC_ID_PCM_S24BE:
241 encode_from16(3, 0, 0, &samples, &dst, n);
242 break;
243 case CODEC_ID_PCM_U24LE:
244 encode_from16(3, 1, 1, &samples, &dst, n);
245 break;
246 case CODEC_ID_PCM_U24BE:
247 encode_from16(3, 0, 1, &samples, &dst, n);
248 break;
249 case CODEC_ID_PCM_S24DAUD:
250 for(;n>0;n--) {
251 uint32_t tmp = ff_reverse[*samples >> 8] +
252 (ff_reverse[*samples & 0xff] << 8);
253 tmp <<= 4; // sync flags would go here
5a2f421a 254 bytestream_put_be24(&dst, tmp);
b461b3bc 255 samples++;
b461b3bc
RD
256 }
257 break;
a96b68b7
FB
258 case CODEC_ID_PCM_S16LE:
259 for(;n>0;n--) {
260 v = *samples++;
5a2f421a 261 bytestream_put_le16(&dst, v);
a96b68b7
FB
262 }
263 break;
264 case CODEC_ID_PCM_S16BE:
265 for(;n>0;n--) {
266 v = *samples++;
5a2f421a 267 bytestream_put_be16(&dst, v);
a96b68b7
FB
268 }
269 break;
270 case CODEC_ID_PCM_U16LE:
271 for(;n>0;n--) {
272 v = *samples++;
273 v += 0x8000;
5a2f421a 274 bytestream_put_le16(&dst, v);
a96b68b7
FB
275 }
276 break;
277 case CODEC_ID_PCM_U16BE:
278 for(;n>0;n--) {
279 v = *samples++;
280 v += 0x8000;
5a2f421a 281 bytestream_put_be16(&dst, v);
a96b68b7
FB
282 }
283 break;
284 case CODEC_ID_PCM_S8:
285 for(;n>0;n--) {
286 v = *samples++;
a4461664 287 *dst++ = v >> 8;
a96b68b7
FB
288 }
289 break;
290 case CODEC_ID_PCM_U8:
291 for(;n>0;n--) {
292 v = *samples++;
a4461664 293 *dst++ = (v >> 8) + 128;
a96b68b7
FB
294 }
295 break;
a11c2a2c
MN
296 case CODEC_ID_PCM_ZORK:
297 for(;n>0;n--) {
298 v= *samples++ >> 8;
299 if(v<0) v = -v;
300 else v+= 128;
301 *dst++ = v;
302 }
303 break;
a96b68b7
FB
304 case CODEC_ID_PCM_ALAW:
305 for(;n>0;n--) {
306 v = *samples++;
a4461664 307 *dst++ = linear_to_alaw[(v + 32768) >> 2];
a96b68b7
FB
308 }
309 break;
310 case CODEC_ID_PCM_MULAW:
311 for(;n>0;n--) {
312 v = *samples++;
a4461664 313 *dst++ = linear_to_ulaw[(v + 32768) >> 2];
a96b68b7
FB
314 }
315 break;
316 default:
317 return -1;
318 }
13a0314f 319 //avctx->frame_size = (dst - frame) / (sample_size * avctx->channels);
4c3d2e5f 320
a96b68b7
FB
321 return dst - frame;
322}
323
324typedef struct PCMDecode {
325 short table[256];
326} PCMDecode;
327
98a6fff9 328static av_cold int pcm_decode_init(AVCodecContext * avctx)
a96b68b7
FB
329{
330 PCMDecode *s = avctx->priv_data;
331 int i;
332
333 switch(avctx->codec->id) {
334 case CODEC_ID_PCM_ALAW:
335 for(i=0;i<256;i++)
336 s->table[i] = alaw2linear(i);
337 break;
338 case CODEC_ID_PCM_MULAW:
339 for(i=0;i<256;i++)
340 s->table[i] = ulaw2linear(i);
341 break;
342 default:
343 break;
344 }
345 return 0;
346}
347
b461b3bc
RD
348/**
349 * \brief convert samples to 16 bit
350 * \param bps byte per sample for the source format, must be >= 2
351 * \param le 0 for big-, 1 for little-endian
6c0d6064 352 * \param us 0 for signed, 1 for unsigned input
b461b3bc
RD
353 * \param src input samples
354 * \param samples output samples
355 * \param src_len number of bytes in src
356 */
357static inline void decode_to16(int bps, int le, int us,
7993df65 358 const uint8_t **src, short **samples, int src_len)
b461b3bc 359{
7d5aaa04 360 int usum = us ? -0x8000 : 0;
b461b3bc
RD
361 register int n = src_len / bps;
362 if (le) *src += bps - 2;
363 for(;n>0;n--) {
a32c2ce4
RP
364 register int v;
365 if (le) v = AV_RL16(*src);
366 else v = AV_RB16(*src);
367 v += usum;
368 *(*samples)++ = v;
b461b3bc
RD
369 *src += bps;
370 }
371 if (le) *src -= bps - 2;
372}
373
cd4af68a 374static int pcm_decode_frame(AVCodecContext *avctx,
bb270c08 375 void *data, int *data_size,
7993df65 376 const uint8_t *buf, int buf_size)
a96b68b7
FB
377{
378 PCMDecode *s = avctx->priv_data;
725d86bf 379 int c, n;
a96b68b7 380 short *samples;
7993df65 381 const uint8_t *src, *src2[MAX_CHANNELS];
a96b68b7
FB
382
383 samples = data;
384 src = buf;
385
b2a581dc 386 n= av_get_bits_per_sample(avctx->codec_id)/8;
3426d575 387 if(n && buf_size % n){
b2a581dc
MN
388 av_log(avctx, AV_LOG_ERROR, "invalid PCM packet\n");
389 return -1;
390 }
3426d575 391 if(avctx->channels <= 0 || avctx->channels > MAX_CHANNELS){
392 av_log(avctx, AV_LOG_ERROR, "PCM channels out of bounds\n");
393 return -1;
394 }
b2a581dc 395
ac66834c
MN
396 buf_size= FFMIN(buf_size, *data_size/2);
397 *data_size=0;
a8d02f2b 398
725d86bf
AJ
399 n = buf_size/avctx->channels;
400 for(c=0;c<avctx->channels;c++)
401 src2[c] = &src[c*n];
402
a96b68b7 403 switch(avctx->codec->id) {
b461b3bc
RD
404 case CODEC_ID_PCM_S32LE:
405 decode_to16(4, 1, 0, &src, &samples, buf_size);
406 break;
407 case CODEC_ID_PCM_S32BE:
408 decode_to16(4, 0, 0, &src, &samples, buf_size);
409 break;
410 case CODEC_ID_PCM_U32LE:
411 decode_to16(4, 1, 1, &src, &samples, buf_size);
412 break;
413 case CODEC_ID_PCM_U32BE:
414 decode_to16(4, 0, 1, &src, &samples, buf_size);
415 break;
416 case CODEC_ID_PCM_S24LE:
417 decode_to16(3, 1, 0, &src, &samples, buf_size);
418 break;
419 case CODEC_ID_PCM_S24BE:
420 decode_to16(3, 0, 0, &src, &samples, buf_size);
421 break;
422 case CODEC_ID_PCM_U24LE:
423 decode_to16(3, 1, 1, &src, &samples, buf_size);
424 break;
425 case CODEC_ID_PCM_U24BE:
426 decode_to16(3, 0, 1, &src, &samples, buf_size);
427 break;
428 case CODEC_ID_PCM_S24DAUD:
429 n = buf_size / 3;
430 for(;n>0;n--) {
5a2f421a 431 uint32_t v = bytestream_get_be24(&src);
b461b3bc
RD
432 v >>= 4; // sync flags are here
433 *samples++ = ff_reverse[(v >> 8) & 0xff] +
434 (ff_reverse[v & 0xff] << 8);
b461b3bc
RD
435 }
436 break;
a96b68b7
FB
437 case CODEC_ID_PCM_S16LE:
438 n = buf_size >> 1;
439 for(;n>0;n--) {
5a2f421a 440 *samples++ = bytestream_get_le16(&src);
a96b68b7
FB
441 }
442 break;
725d86bf
AJ
443 case CODEC_ID_PCM_S16LE_PLANAR:
444 for(n>>=1;n>0;n--)
445 for(c=0;c<avctx->channels;c++)
446 *samples++ = bytestream_get_le16(&src2[c]);
447 src = src2[avctx->channels-1];
448 break;
a96b68b7
FB
449 case CODEC_ID_PCM_S16BE:
450 n = buf_size >> 1;
451 for(;n>0;n--) {
5a2f421a 452 *samples++ = bytestream_get_be16(&src);
a96b68b7
FB
453 }
454 break;
455 case CODEC_ID_PCM_U16LE:
456 n = buf_size >> 1;
457 for(;n>0;n--) {
5a2f421a 458 *samples++ = bytestream_get_le16(&src) - 0x8000;
a96b68b7
FB
459 }
460 break;
461 case CODEC_ID_PCM_U16BE:
462 n = buf_size >> 1;
463 for(;n>0;n--) {
5a2f421a 464 *samples++ = bytestream_get_be16(&src) - 0x8000;
a96b68b7
FB
465 }
466 break;
467 case CODEC_ID_PCM_S8:
468 n = buf_size;
469 for(;n>0;n--) {
a4461664 470 *samples++ = *src++ << 8;
a96b68b7
FB
471 }
472 break;
473 case CODEC_ID_PCM_U8:
474 n = buf_size;
475 for(;n>0;n--) {
a4461664 476 *samples++ = ((int)*src++ - 128) << 8;
a96b68b7
FB
477 }
478 break;
a11c2a2c
MN
479 case CODEC_ID_PCM_ZORK:
480 n = buf_size;
481 for(;n>0;n--) {
482 int x= *src++;
483 if(x&128) x-= 128;
484 else x = -x;
485 *samples++ = x << 8;
486 }
487 break;
a96b68b7
FB
488 case CODEC_ID_PCM_ALAW:
489 case CODEC_ID_PCM_MULAW:
490 n = buf_size;
491 for(;n>0;n--) {
a4461664 492 *samples++ = s->table[*src++];
a96b68b7
FB
493 }
494 break;
495 default:
a96b68b7
FB
496 return -1;
497 }
0c1a9eda 498 *data_size = (uint8_t *)samples - (uint8_t *)data;
a96b68b7
FB
499 return src - buf;
500}
501
2b045c9c 502#ifdef CONFIG_ENCODERS
44caa86d 503#define PCM_ENCODER(id,name,long_name_) \
a96b68b7
FB
504AVCodec name ## _encoder = { \
505 #name, \
506 CODEC_TYPE_AUDIO, \
507 id, \
508 0, \
bb270c08
DB
509 pcm_encode_init, \
510 pcm_encode_frame, \
511 pcm_encode_close, \
a96b68b7 512 NULL, \
44caa86d 513 .long_name = long_name_, \
2b045c9c
AJ
514};
515#else
44caa86d 516#define PCM_ENCODER(id,name,long_name_)
2b045c9c
AJ
517#endif
518
519#ifdef CONFIG_DECODERS
44caa86d 520#define PCM_DECODER(id,name,long_name_) \
a96b68b7
FB
521AVCodec name ## _decoder = { \
522 #name, \
523 CODEC_TYPE_AUDIO, \
524 id, \
525 sizeof(PCMDecode), \
bb270c08 526 pcm_decode_init, \
a96b68b7
FB
527 NULL, \
528 NULL, \
cd4af68a 529 pcm_decode_frame, \
44caa86d 530 .long_name = long_name_, \
2b045c9c
AJ
531};
532#else
44caa86d 533#define PCM_DECODER(id,name,long_name_)
2b045c9c
AJ
534#endif
535
44caa86d
DB
536#define PCM_CODEC(id, name, long_name_) \
537 PCM_ENCODER(id,name,long_name_) PCM_DECODER(id,name,long_name_)
538
539PCM_CODEC (CODEC_ID_PCM_ALAW, pcm_alaw, "A-law PCM");
540PCM_CODEC (CODEC_ID_PCM_MULAW, pcm_mulaw, "mu-law PCM");
541PCM_CODEC (CODEC_ID_PCM_S8, pcm_s8, "signed 8-bit PCM");
542PCM_CODEC (CODEC_ID_PCM_S16BE, pcm_s16be, "signed 16-bit big-endian PCM");
51c86db5 543PCM_CODEC (CODEC_ID_PCM_S16LE, pcm_s16le, "signed 16-bit little-endian PCM");
44caa86d
DB
544PCM_DECODER(CODEC_ID_PCM_S16LE_PLANAR, pcm_s16le_planar, "16-bit little-endian planar PCM");
545PCM_CODEC (CODEC_ID_PCM_S24BE, pcm_s24be, "signed 24-bit big-endian PCM");
546PCM_CODEC (CODEC_ID_PCM_S24DAUD, pcm_s24daud, "D-Cinema audio signed 24-bit PCM");
547PCM_CODEC (CODEC_ID_PCM_S24LE, pcm_s24le, "signed 24-bit little-endian PCM");
548PCM_CODEC (CODEC_ID_PCM_S32BE, pcm_s32be, "signed 32-bit big-endian PCM");
549PCM_CODEC (CODEC_ID_PCM_S32LE, pcm_s32le, "signed 32-bit little-endian PCM");
550PCM_CODEC (CODEC_ID_PCM_U8, pcm_u8, "unsigned 8-bit PCM");
551PCM_CODEC (CODEC_ID_PCM_U16BE, pcm_u16be, "unsigned 16-bit big-endian PCM");
552PCM_CODEC (CODEC_ID_PCM_U16LE, pcm_u16le, "unsigned 16-bit little-endian PCM");
553PCM_CODEC (CODEC_ID_PCM_U24BE, pcm_u24be, "unsigned 24-bit big-endian PCM");
554PCM_CODEC (CODEC_ID_PCM_U24LE, pcm_u24le, "unsigned 24-bit little-endian PCM");
555PCM_CODEC (CODEC_ID_PCM_U32BE, pcm_u32be, "unsigned 32-bit big-endian PCM");
556PCM_CODEC (CODEC_ID_PCM_U32LE, pcm_u32le, "unsigned 32-bit little-endian PCM");
557PCM_CODEC (CODEC_ID_PCM_ZORK, pcm_zork, "Zork PCM");