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