mirror of
https://github.com/FFmpeg/FFmpeg.git
synced 2024-12-02 03:06:28 +02:00
ac66834c75
difference to avcodec_decode_audio() is that the user can pass the allocated size of the output buffer to the decoder and the decoder can check if theres enough space Originally committed as revision 7518 to svn://svn.ffmpeg.org/ffmpeg/trunk
549 lines
15 KiB
C
549 lines
15 KiB
C
/*
|
|
* PCM codecs
|
|
* Copyright (c) 2001 Fabrice Bellard.
|
|
*
|
|
* This file is part of FFmpeg.
|
|
*
|
|
* FFmpeg is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with FFmpeg; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
/**
|
|
* @file pcm.c
|
|
* PCM codecs
|
|
*/
|
|
|
|
#include "avcodec.h"
|
|
#include "bitstream.h" // for ff_reverse
|
|
|
|
/* from g711.c by SUN microsystems (unrestricted use) */
|
|
|
|
#define SIGN_BIT (0x80) /* Sign bit for a A-law byte. */
|
|
#define QUANT_MASK (0xf) /* Quantization field mask. */
|
|
#define NSEGS (8) /* Number of A-law segments. */
|
|
#define SEG_SHIFT (4) /* Left shift for segment number. */
|
|
#define SEG_MASK (0x70) /* Segment field mask. */
|
|
|
|
#define BIAS (0x84) /* Bias for linear code. */
|
|
|
|
/*
|
|
* alaw2linear() - Convert an A-law value to 16-bit linear PCM
|
|
*
|
|
*/
|
|
static int alaw2linear(unsigned char a_val)
|
|
{
|
|
int t;
|
|
int seg;
|
|
|
|
a_val ^= 0x55;
|
|
|
|
t = a_val & QUANT_MASK;
|
|
seg = ((unsigned)a_val & SEG_MASK) >> SEG_SHIFT;
|
|
if(seg) t= (t + t + 1 + 32) << (seg + 2);
|
|
else t= (t + t + 1 ) << 3;
|
|
|
|
return ((a_val & SIGN_BIT) ? t : -t);
|
|
}
|
|
|
|
static int ulaw2linear(unsigned char u_val)
|
|
{
|
|
int t;
|
|
|
|
/* Complement to obtain normal u-law value. */
|
|
u_val = ~u_val;
|
|
|
|
/*
|
|
* Extract and bias the quantization bits. Then
|
|
* shift up by the segment number and subtract out the bias.
|
|
*/
|
|
t = ((u_val & QUANT_MASK) << 3) + BIAS;
|
|
t <<= ((unsigned)u_val & SEG_MASK) >> SEG_SHIFT;
|
|
|
|
return ((u_val & SIGN_BIT) ? (BIAS - t) : (t - BIAS));
|
|
}
|
|
|
|
/* 16384 entries per table */
|
|
static uint8_t *linear_to_alaw = NULL;
|
|
static int linear_to_alaw_ref = 0;
|
|
|
|
static uint8_t *linear_to_ulaw = NULL;
|
|
static int linear_to_ulaw_ref = 0;
|
|
|
|
static void build_xlaw_table(uint8_t *linear_to_xlaw,
|
|
int (*xlaw2linear)(unsigned char),
|
|
int mask)
|
|
{
|
|
int i, j, v, v1, v2;
|
|
|
|
j = 0;
|
|
for(i=0;i<128;i++) {
|
|
if (i != 127) {
|
|
v1 = xlaw2linear(i ^ mask);
|
|
v2 = xlaw2linear((i + 1) ^ mask);
|
|
v = (v1 + v2 + 4) >> 3;
|
|
} else {
|
|
v = 8192;
|
|
}
|
|
for(;j<v;j++) {
|
|
linear_to_xlaw[8192 + j] = (i ^ mask);
|
|
if (j > 0)
|
|
linear_to_xlaw[8192 - j] = (i ^ (mask ^ 0x80));
|
|
}
|
|
}
|
|
linear_to_xlaw[0] = linear_to_xlaw[1];
|
|
}
|
|
|
|
static int pcm_encode_init(AVCodecContext *avctx)
|
|
{
|
|
avctx->frame_size = 1;
|
|
switch(avctx->codec->id) {
|
|
case CODEC_ID_PCM_ALAW:
|
|
if (linear_to_alaw_ref == 0) {
|
|
linear_to_alaw = av_malloc(16384);
|
|
if (!linear_to_alaw)
|
|
return -1;
|
|
build_xlaw_table(linear_to_alaw, alaw2linear, 0xd5);
|
|
}
|
|
linear_to_alaw_ref++;
|
|
break;
|
|
case CODEC_ID_PCM_MULAW:
|
|
if (linear_to_ulaw_ref == 0) {
|
|
linear_to_ulaw = av_malloc(16384);
|
|
if (!linear_to_ulaw)
|
|
return -1;
|
|
build_xlaw_table(linear_to_ulaw, ulaw2linear, 0xff);
|
|
}
|
|
linear_to_ulaw_ref++;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
switch(avctx->codec->id) {
|
|
case CODEC_ID_PCM_S32LE:
|
|
case CODEC_ID_PCM_S32BE:
|
|
case CODEC_ID_PCM_U32LE:
|
|
case CODEC_ID_PCM_U32BE:
|
|
avctx->block_align = 4 * avctx->channels;
|
|
break;
|
|
case CODEC_ID_PCM_S24LE:
|
|
case CODEC_ID_PCM_S24BE:
|
|
case CODEC_ID_PCM_U24LE:
|
|
case CODEC_ID_PCM_U24BE:
|
|
case CODEC_ID_PCM_S24DAUD:
|
|
avctx->block_align = 3 * avctx->channels;
|
|
break;
|
|
case CODEC_ID_PCM_S16LE:
|
|
case CODEC_ID_PCM_S16BE:
|
|
case CODEC_ID_PCM_U16LE:
|
|
case CODEC_ID_PCM_U16BE:
|
|
avctx->block_align = 2 * avctx->channels;
|
|
break;
|
|
case CODEC_ID_PCM_S8:
|
|
case CODEC_ID_PCM_U8:
|
|
case CODEC_ID_PCM_MULAW:
|
|
case CODEC_ID_PCM_ALAW:
|
|
avctx->block_align = avctx->channels;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
avctx->coded_frame= avcodec_alloc_frame();
|
|
avctx->coded_frame->key_frame= 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int pcm_encode_close(AVCodecContext *avctx)
|
|
{
|
|
av_freep(&avctx->coded_frame);
|
|
|
|
switch(avctx->codec->id) {
|
|
case CODEC_ID_PCM_ALAW:
|
|
if (--linear_to_alaw_ref == 0)
|
|
av_free(linear_to_alaw);
|
|
break;
|
|
case CODEC_ID_PCM_MULAW:
|
|
if (--linear_to_ulaw_ref == 0)
|
|
av_free(linear_to_ulaw);
|
|
break;
|
|
default:
|
|
/* nothing to free */
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* \brief convert samples from 16 bit
|
|
* \param bps byte per sample for the destination format, must be >= 2
|
|
* \param le 0 for big-, 1 for little-endian
|
|
* \param us 0 for signed, 1 for unsigned output
|
|
* \param samples input samples
|
|
* \param dst output samples
|
|
* \param n number of samples in samples buffer.
|
|
*/
|
|
static inline void encode_from16(int bps, int le, int us,
|
|
short **samples, uint8_t **dst, int n) {
|
|
if (bps > 2)
|
|
memset(*dst, 0, n * bps);
|
|
if (le) *dst += bps - 2;
|
|
for(;n>0;n--) {
|
|
register int v = *(*samples)++;
|
|
if (us) v += 0x8000;
|
|
(*dst)[le] = v >> 8;
|
|
(*dst)[1 - le] = v;
|
|
*dst += bps;
|
|
}
|
|
if (le) *dst -= bps - 2;
|
|
}
|
|
|
|
static int pcm_encode_frame(AVCodecContext *avctx,
|
|
unsigned char *frame, int buf_size, void *data)
|
|
{
|
|
int n, sample_size, v;
|
|
short *samples;
|
|
unsigned char *dst;
|
|
|
|
switch(avctx->codec->id) {
|
|
case CODEC_ID_PCM_S32LE:
|
|
case CODEC_ID_PCM_S32BE:
|
|
case CODEC_ID_PCM_U32LE:
|
|
case CODEC_ID_PCM_U32BE:
|
|
sample_size = 4;
|
|
break;
|
|
case CODEC_ID_PCM_S24LE:
|
|
case CODEC_ID_PCM_S24BE:
|
|
case CODEC_ID_PCM_U24LE:
|
|
case CODEC_ID_PCM_U24BE:
|
|
case CODEC_ID_PCM_S24DAUD:
|
|
sample_size = 3;
|
|
break;
|
|
case CODEC_ID_PCM_S16LE:
|
|
case CODEC_ID_PCM_S16BE:
|
|
case CODEC_ID_PCM_U16LE:
|
|
case CODEC_ID_PCM_U16BE:
|
|
sample_size = 2;
|
|
break;
|
|
default:
|
|
sample_size = 1;
|
|
break;
|
|
}
|
|
n = buf_size / sample_size;
|
|
samples = data;
|
|
dst = frame;
|
|
|
|
switch(avctx->codec->id) {
|
|
case CODEC_ID_PCM_S32LE:
|
|
encode_from16(4, 1, 0, &samples, &dst, n);
|
|
break;
|
|
case CODEC_ID_PCM_S32BE:
|
|
encode_from16(4, 0, 0, &samples, &dst, n);
|
|
break;
|
|
case CODEC_ID_PCM_U32LE:
|
|
encode_from16(4, 1, 1, &samples, &dst, n);
|
|
break;
|
|
case CODEC_ID_PCM_U32BE:
|
|
encode_from16(4, 0, 1, &samples, &dst, n);
|
|
break;
|
|
case CODEC_ID_PCM_S24LE:
|
|
encode_from16(3, 1, 0, &samples, &dst, n);
|
|
break;
|
|
case CODEC_ID_PCM_S24BE:
|
|
encode_from16(3, 0, 0, &samples, &dst, n);
|
|
break;
|
|
case CODEC_ID_PCM_U24LE:
|
|
encode_from16(3, 1, 1, &samples, &dst, n);
|
|
break;
|
|
case CODEC_ID_PCM_U24BE:
|
|
encode_from16(3, 0, 1, &samples, &dst, n);
|
|
break;
|
|
case CODEC_ID_PCM_S24DAUD:
|
|
for(;n>0;n--) {
|
|
uint32_t tmp = ff_reverse[*samples >> 8] +
|
|
(ff_reverse[*samples & 0xff] << 8);
|
|
tmp <<= 4; // sync flags would go here
|
|
dst[2] = tmp & 0xff;
|
|
tmp >>= 8;
|
|
dst[1] = tmp & 0xff;
|
|
dst[0] = tmp >> 8;
|
|
samples++;
|
|
dst += 3;
|
|
}
|
|
break;
|
|
case CODEC_ID_PCM_S16LE:
|
|
for(;n>0;n--) {
|
|
v = *samples++;
|
|
dst[0] = v & 0xff;
|
|
dst[1] = v >> 8;
|
|
dst += 2;
|
|
}
|
|
break;
|
|
case CODEC_ID_PCM_S16BE:
|
|
for(;n>0;n--) {
|
|
v = *samples++;
|
|
dst[0] = v >> 8;
|
|
dst[1] = v;
|
|
dst += 2;
|
|
}
|
|
break;
|
|
case CODEC_ID_PCM_U16LE:
|
|
for(;n>0;n--) {
|
|
v = *samples++;
|
|
v += 0x8000;
|
|
dst[0] = v & 0xff;
|
|
dst[1] = v >> 8;
|
|
dst += 2;
|
|
}
|
|
break;
|
|
case CODEC_ID_PCM_U16BE:
|
|
for(;n>0;n--) {
|
|
v = *samples++;
|
|
v += 0x8000;
|
|
dst[0] = v >> 8;
|
|
dst[1] = v;
|
|
dst += 2;
|
|
}
|
|
break;
|
|
case CODEC_ID_PCM_S8:
|
|
for(;n>0;n--) {
|
|
v = *samples++;
|
|
dst[0] = v >> 8;
|
|
dst++;
|
|
}
|
|
break;
|
|
case CODEC_ID_PCM_U8:
|
|
for(;n>0;n--) {
|
|
v = *samples++;
|
|
dst[0] = (v >> 8) + 128;
|
|
dst++;
|
|
}
|
|
break;
|
|
case CODEC_ID_PCM_ALAW:
|
|
for(;n>0;n--) {
|
|
v = *samples++;
|
|
dst[0] = linear_to_alaw[(v + 32768) >> 2];
|
|
dst++;
|
|
}
|
|
break;
|
|
case CODEC_ID_PCM_MULAW:
|
|
for(;n>0;n--) {
|
|
v = *samples++;
|
|
dst[0] = linear_to_ulaw[(v + 32768) >> 2];
|
|
dst++;
|
|
}
|
|
break;
|
|
default:
|
|
return -1;
|
|
}
|
|
//avctx->frame_size = (dst - frame) / (sample_size * avctx->channels);
|
|
|
|
return dst - frame;
|
|
}
|
|
|
|
typedef struct PCMDecode {
|
|
short table[256];
|
|
} PCMDecode;
|
|
|
|
static int pcm_decode_init(AVCodecContext * avctx)
|
|
{
|
|
PCMDecode *s = avctx->priv_data;
|
|
int i;
|
|
|
|
switch(avctx->codec->id) {
|
|
case CODEC_ID_PCM_ALAW:
|
|
for(i=0;i<256;i++)
|
|
s->table[i] = alaw2linear(i);
|
|
break;
|
|
case CODEC_ID_PCM_MULAW:
|
|
for(i=0;i<256;i++)
|
|
s->table[i] = ulaw2linear(i);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* \brief convert samples to 16 bit
|
|
* \param bps byte per sample for the source format, must be >= 2
|
|
* \param le 0 for big-, 1 for little-endian
|
|
* \param us 0 for signed, 1 for unsigned input
|
|
* \param src input samples
|
|
* \param samples output samples
|
|
* \param src_len number of bytes in src
|
|
*/
|
|
static inline void decode_to16(int bps, int le, int us,
|
|
uint8_t **src, short **samples, int src_len)
|
|
{
|
|
register int n = src_len / bps;
|
|
if (le) *src += bps - 2;
|
|
for(;n>0;n--) {
|
|
*(*samples)++ = ((*src)[le] << 8 | (*src)[1 - le]) - (us?0x8000:0);
|
|
*src += bps;
|
|
}
|
|
if (le) *src -= bps - 2;
|
|
}
|
|
|
|
static int pcm_decode_frame(AVCodecContext *avctx,
|
|
void *data, int *data_size,
|
|
uint8_t *buf, int buf_size)
|
|
{
|
|
PCMDecode *s = avctx->priv_data;
|
|
int n;
|
|
short *samples;
|
|
uint8_t *src;
|
|
|
|
samples = data;
|
|
src = buf;
|
|
|
|
buf_size= FFMIN(buf_size, *data_size/2);
|
|
*data_size=0;
|
|
|
|
switch(avctx->codec->id) {
|
|
case CODEC_ID_PCM_S32LE:
|
|
decode_to16(4, 1, 0, &src, &samples, buf_size);
|
|
break;
|
|
case CODEC_ID_PCM_S32BE:
|
|
decode_to16(4, 0, 0, &src, &samples, buf_size);
|
|
break;
|
|
case CODEC_ID_PCM_U32LE:
|
|
decode_to16(4, 1, 1, &src, &samples, buf_size);
|
|
break;
|
|
case CODEC_ID_PCM_U32BE:
|
|
decode_to16(4, 0, 1, &src, &samples, buf_size);
|
|
break;
|
|
case CODEC_ID_PCM_S24LE:
|
|
decode_to16(3, 1, 0, &src, &samples, buf_size);
|
|
break;
|
|
case CODEC_ID_PCM_S24BE:
|
|
decode_to16(3, 0, 0, &src, &samples, buf_size);
|
|
break;
|
|
case CODEC_ID_PCM_U24LE:
|
|
decode_to16(3, 1, 1, &src, &samples, buf_size);
|
|
break;
|
|
case CODEC_ID_PCM_U24BE:
|
|
decode_to16(3, 0, 1, &src, &samples, buf_size);
|
|
break;
|
|
case CODEC_ID_PCM_S24DAUD:
|
|
n = buf_size / 3;
|
|
for(;n>0;n--) {
|
|
uint32_t v = src[0] << 16 | src[1] << 8 | src[2];
|
|
v >>= 4; // sync flags are here
|
|
*samples++ = ff_reverse[(v >> 8) & 0xff] +
|
|
(ff_reverse[v & 0xff] << 8);
|
|
src += 3;
|
|
}
|
|
break;
|
|
case CODEC_ID_PCM_S16LE:
|
|
n = buf_size >> 1;
|
|
for(;n>0;n--) {
|
|
*samples++ = src[0] | (src[1] << 8);
|
|
src += 2;
|
|
}
|
|
break;
|
|
case CODEC_ID_PCM_S16BE:
|
|
n = buf_size >> 1;
|
|
for(;n>0;n--) {
|
|
*samples++ = (src[0] << 8) | src[1];
|
|
src += 2;
|
|
}
|
|
break;
|
|
case CODEC_ID_PCM_U16LE:
|
|
n = buf_size >> 1;
|
|
for(;n>0;n--) {
|
|
*samples++ = (src[0] | (src[1] << 8)) - 0x8000;
|
|
src += 2;
|
|
}
|
|
break;
|
|
case CODEC_ID_PCM_U16BE:
|
|
n = buf_size >> 1;
|
|
for(;n>0;n--) {
|
|
*samples++ = ((src[0] << 8) | src[1]) - 0x8000;
|
|
src += 2;
|
|
}
|
|
break;
|
|
case CODEC_ID_PCM_S8:
|
|
n = buf_size;
|
|
for(;n>0;n--) {
|
|
*samples++ = src[0] << 8;
|
|
src++;
|
|
}
|
|
break;
|
|
case CODEC_ID_PCM_U8:
|
|
n = buf_size;
|
|
for(;n>0;n--) {
|
|
*samples++ = ((int)src[0] - 128) << 8;
|
|
src++;
|
|
}
|
|
break;
|
|
case CODEC_ID_PCM_ALAW:
|
|
case CODEC_ID_PCM_MULAW:
|
|
n = buf_size;
|
|
for(;n>0;n--) {
|
|
*samples++ = s->table[src[0]];
|
|
src++;
|
|
}
|
|
break;
|
|
default:
|
|
return -1;
|
|
}
|
|
*data_size = (uint8_t *)samples - (uint8_t *)data;
|
|
return src - buf;
|
|
}
|
|
|
|
#define PCM_CODEC(id, name) \
|
|
AVCodec name ## _encoder = { \
|
|
#name, \
|
|
CODEC_TYPE_AUDIO, \
|
|
id, \
|
|
0, \
|
|
pcm_encode_init, \
|
|
pcm_encode_frame, \
|
|
pcm_encode_close, \
|
|
NULL, \
|
|
}; \
|
|
AVCodec name ## _decoder = { \
|
|
#name, \
|
|
CODEC_TYPE_AUDIO, \
|
|
id, \
|
|
sizeof(PCMDecode), \
|
|
pcm_decode_init, \
|
|
NULL, \
|
|
NULL, \
|
|
pcm_decode_frame, \
|
|
}
|
|
|
|
PCM_CODEC(CODEC_ID_PCM_S32LE, pcm_s32le);
|
|
PCM_CODEC(CODEC_ID_PCM_S32BE, pcm_s32be);
|
|
PCM_CODEC(CODEC_ID_PCM_U32LE, pcm_u32le);
|
|
PCM_CODEC(CODEC_ID_PCM_U32BE, pcm_u32be);
|
|
PCM_CODEC(CODEC_ID_PCM_S24LE, pcm_s24le);
|
|
PCM_CODEC(CODEC_ID_PCM_S24BE, pcm_s24be);
|
|
PCM_CODEC(CODEC_ID_PCM_U24LE, pcm_u24le);
|
|
PCM_CODEC(CODEC_ID_PCM_U24BE, pcm_u24be);
|
|
PCM_CODEC(CODEC_ID_PCM_S24DAUD, pcm_s24daud);
|
|
PCM_CODEC(CODEC_ID_PCM_S16LE, pcm_s16le);
|
|
PCM_CODEC(CODEC_ID_PCM_S16BE, pcm_s16be);
|
|
PCM_CODEC(CODEC_ID_PCM_U16LE, pcm_u16le);
|
|
PCM_CODEC(CODEC_ID_PCM_U16BE, pcm_u16be);
|
|
PCM_CODEC(CODEC_ID_PCM_S8, pcm_s8);
|
|
PCM_CODEC(CODEC_ID_PCM_U8, pcm_u8);
|
|
PCM_CODEC(CODEC_ID_PCM_ALAW, pcm_alaw);
|
|
PCM_CODEC(CODEC_ID_PCM_MULAW, pcm_mulaw);
|
|
|
|
#undef PCM_CODEC
|