2004-02-24 18:06:14 +01:00
|
|
|
/* the Music Player Daemon (MPD)
|
2007-04-05 05:22:33 +02:00
|
|
|
* Copyright (C) 2003-2007 by Warren Dukes (warren.dukes@gmail.com)
|
2004-02-24 18:06:14 +01:00
|
|
|
* This project's homepage is: http://www.musicpd.org
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program 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 General Public License for more details.
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*/
|
|
|
|
|
2004-02-24 00:41:20 +01:00
|
|
|
#include "pcm_utils.h"
|
|
|
|
|
|
|
|
#include "mpd_types.h"
|
|
|
|
#include "log.h"
|
2006-08-26 08:25:57 +02:00
|
|
|
#include "utils.h"
|
2007-02-02 04:51:07 +01:00
|
|
|
#include "conf.h"
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
#include <string.h>
|
|
|
|
#include <math.h>
|
2004-05-10 17:21:40 +02:00
|
|
|
#include <assert.h>
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2007-02-02 04:51:07 +01:00
|
|
|
#ifdef HAVE_LIBSAMPLERATE
|
|
|
|
#include <samplerate.h>
|
|
|
|
#endif
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
void pcm_volumeChange(char *buffer, int bufferSize, AudioFormat * format,
|
2007-05-22 17:02:25 +02:00
|
|
|
int volume)
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
|
|
|
mpd_sint32 temp32;
|
2006-07-20 18:02:40 +02:00
|
|
|
mpd_sint8 *buffer8 = (mpd_sint8 *) buffer;
|
|
|
|
mpd_sint16 *buffer16 = (mpd_sint16 *) buffer;
|
|
|
|
|
|
|
|
if (volume >= 1000)
|
|
|
|
return;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (volume <= 0) {
|
|
|
|
memset(buffer, 0, bufferSize);
|
2004-02-24 00:41:20 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
switch (format->bits) {
|
2004-02-24 00:41:20 +01:00
|
|
|
case 16:
|
2006-07-20 18:02:40 +02:00
|
|
|
while (bufferSize > 0) {
|
2004-02-24 00:41:20 +01:00
|
|
|
temp32 = *buffer16;
|
2006-07-20 18:02:40 +02:00
|
|
|
temp32 *= volume;
|
2007-02-02 04:51:07 +01:00
|
|
|
temp32 += rand() & 511;
|
|
|
|
temp32 -= rand() & 511;
|
|
|
|
temp32 += 500;
|
2006-07-20 18:02:40 +02:00
|
|
|
temp32 /= 1000;
|
|
|
|
*buffer16 = temp32 > 32767 ? 32767 :
|
|
|
|
(temp32 < -32768 ? -32768 : temp32);
|
2004-02-24 00:41:20 +01:00
|
|
|
buffer16++;
|
2006-07-20 18:02:40 +02:00
|
|
|
bufferSize -= 2;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 8:
|
2006-07-20 18:02:40 +02:00
|
|
|
while (bufferSize > 0) {
|
2004-02-24 00:41:20 +01:00
|
|
|
temp32 = *buffer8;
|
2006-07-20 18:02:40 +02:00
|
|
|
temp32 *= volume;
|
2007-02-02 04:51:07 +01:00
|
|
|
temp32 += rand() & 511;
|
|
|
|
temp32 -= rand() & 511;
|
|
|
|
temp32 += 500;
|
2006-07-20 18:02:40 +02:00
|
|
|
temp32 /= 1000;
|
|
|
|
*buffer8 = temp32 > 127 ? 127 :
|
|
|
|
(temp32 < -128 ? -128 : temp32);
|
2004-02-24 00:41:20 +01:00
|
|
|
buffer8++;
|
|
|
|
bufferSize--;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ERROR("%i bits not supported by pcm_volumeChange!\n",
|
2006-07-20 18:02:40 +02:00
|
|
|
format->bits);
|
2004-04-03 01:34:16 +02:00
|
|
|
exit(EXIT_FAILURE);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static void pcm_add(char *buffer1, char *buffer2, size_t bufferSize1,
|
2007-05-22 17:02:25 +02:00
|
|
|
size_t bufferSize2, int vol1, int vol2,
|
|
|
|
AudioFormat * format)
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
|
|
|
mpd_sint32 temp32;
|
2006-07-20 18:02:40 +02:00
|
|
|
mpd_sint8 *buffer8_1 = (mpd_sint8 *) buffer1;
|
|
|
|
mpd_sint8 *buffer8_2 = (mpd_sint8 *) buffer2;
|
|
|
|
mpd_sint16 *buffer16_1 = (mpd_sint16 *) buffer1;
|
|
|
|
mpd_sint16 *buffer16_2 = (mpd_sint16 *) buffer2;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
switch (format->bits) {
|
2004-02-24 00:41:20 +01:00
|
|
|
case 16:
|
2006-07-20 18:02:40 +02:00
|
|
|
while (bufferSize1 > 0 && bufferSize2 > 0) {
|
|
|
|
temp32 =
|
|
|
|
(vol1 * (*buffer16_1) +
|
2007-02-02 04:51:07 +01:00
|
|
|
vol2 * (*buffer16_2));
|
|
|
|
temp32 += rand() & 511;
|
|
|
|
temp32 -= rand() & 511;
|
|
|
|
temp32 += 500;
|
|
|
|
temp32 /= 1000;
|
2006-07-20 18:02:40 +02:00
|
|
|
*buffer16_1 =
|
|
|
|
temp32 > 32767 ? 32767 : (temp32 <
|
|
|
|
-32768 ? -32768 : temp32);
|
2004-02-24 00:41:20 +01:00
|
|
|
buffer16_1++;
|
|
|
|
buffer16_2++;
|
2006-07-20 18:02:40 +02:00
|
|
|
bufferSize1 -= 2;
|
|
|
|
bufferSize2 -= 2;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
if (bufferSize2 > 0)
|
|
|
|
memcpy(buffer16_1, buffer16_2, bufferSize2);
|
2004-02-24 00:41:20 +01:00
|
|
|
break;
|
|
|
|
case 8:
|
2006-07-20 18:02:40 +02:00
|
|
|
while (bufferSize1 > 0 && bufferSize2 > 0) {
|
|
|
|
temp32 =
|
2007-02-02 04:51:07 +01:00
|
|
|
(vol1 * (*buffer8_1) + vol2 * (*buffer8_2));
|
|
|
|
temp32 += rand() & 511;
|
|
|
|
temp32 -= rand() & 511;
|
|
|
|
temp32 += 500;
|
|
|
|
temp32 /= 1000;
|
2006-07-20 18:02:40 +02:00
|
|
|
*buffer8_1 =
|
|
|
|
temp32 > 127 ? 127 : (temp32 <
|
|
|
|
-128 ? -128 : temp32);
|
2004-02-24 00:41:20 +01:00
|
|
|
buffer8_1++;
|
|
|
|
buffer8_2++;
|
|
|
|
bufferSize1--;
|
|
|
|
bufferSize2--;
|
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
if (bufferSize2 > 0)
|
|
|
|
memcpy(buffer8_1, buffer8_2, bufferSize2);
|
2004-02-24 00:41:20 +01:00
|
|
|
break;
|
|
|
|
default:
|
2006-07-20 18:02:40 +02:00
|
|
|
ERROR("%i bits not supported by pcm_add!\n", format->bits);
|
2004-04-03 01:34:16 +02:00
|
|
|
exit(EXIT_FAILURE);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
void pcm_mix(char *buffer1, char *buffer2, size_t bufferSize1,
|
2007-05-22 17:02:25 +02:00
|
|
|
size_t bufferSize2, AudioFormat * format, float portion1)
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2004-03-05 01:19:02 +01:00
|
|
|
int vol1;
|
2006-07-20 18:02:40 +02:00
|
|
|
float s = sin(M_PI_2 * portion1);
|
|
|
|
s *= s;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
vol1 = s * 1000 + 0.5;
|
|
|
|
vol1 = vol1 > 1000 ? 1000 : (vol1 < 0 ? 0 : vol1);
|
2004-05-10 16:06:23 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
pcm_add(buffer1, buffer2, bufferSize1, bufferSize2, vol1, 1000 - vol1,
|
|
|
|
format);
|
|
|
|
}
|
2004-05-10 19:08:46 +02:00
|
|
|
|
2007-02-02 04:51:07 +01:00
|
|
|
#ifdef HAVE_LIBSAMPLERATE
|
2007-05-22 17:02:25 +02:00
|
|
|
static int pcm_getSamplerateConverter(void)
|
|
|
|
{
|
2007-02-02 04:51:07 +01:00
|
|
|
const char *conf, *test;
|
|
|
|
int convalgo = SRC_SINC_FASTEST;
|
|
|
|
int newalgo;
|
|
|
|
size_t len;
|
|
|
|
|
|
|
|
conf = getConfigParamValue(CONF_SAMPLERATE_CONVERTER);
|
|
|
|
if(conf) {
|
|
|
|
newalgo = strtol(conf, (char **)&test, 10);
|
|
|
|
if(*test) {
|
|
|
|
len = strlen(conf);
|
|
|
|
for(newalgo = 0; ; newalgo++) {
|
|
|
|
test = src_get_name(newalgo);
|
|
|
|
if(!test)
|
|
|
|
break; /* FAIL */
|
|
|
|
if(!strncasecmp(test, conf, len)) {
|
|
|
|
convalgo = newalgo;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if(src_get_name(newalgo))
|
|
|
|
convalgo = newalgo;
|
|
|
|
/* else FAIL */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
DEBUG("Selecting samplerate converter '%s'\n", src_get_name(convalgo));
|
|
|
|
return convalgo;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-05-22 17:21:56 +02:00
|
|
|
/* outFormat bits must be 16 and channels must be 1 or 2! */
|
2007-05-22 17:02:25 +02:00
|
|
|
void pcm_convertAudioFormat(AudioFormat * inFormat, char *inBuffer,
|
|
|
|
size_t inSize, AudioFormat * outFormat,
|
|
|
|
char *outBuffer)
|
2004-05-10 16:06:23 +02:00
|
|
|
{
|
2007-01-14 04:07:53 +01:00
|
|
|
static char *bitConvBuffer;
|
|
|
|
static int bitConvBufferLength;
|
|
|
|
static char *channelConvBuffer;
|
|
|
|
static int channelConvBufferLength;
|
2006-07-20 18:02:40 +02:00
|
|
|
char *dataChannelConv;
|
2004-05-10 19:08:46 +02:00
|
|
|
int dataChannelLen;
|
2006-07-20 18:02:40 +02:00
|
|
|
char *dataBitConv;
|
2004-05-10 19:08:46 +02:00
|
|
|
int dataBitLen;
|
2004-05-10 17:21:40 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
assert(outFormat->bits == 16);
|
|
|
|
assert(outFormat->channels == 2 || outFormat->channels == 1);
|
2004-05-10 17:21:40 +02:00
|
|
|
|
2007-05-22 17:21:56 +02:00
|
|
|
/* convert to 16 bit audio */
|
2006-07-20 18:02:40 +02:00
|
|
|
switch (inFormat->bits) {
|
2004-05-10 19:08:46 +02:00
|
|
|
case 8:
|
|
|
|
dataBitLen = inSize << 1;
|
2006-07-20 18:02:40 +02:00
|
|
|
if (dataBitLen > bitConvBufferLength) {
|
2006-08-26 08:25:57 +02:00
|
|
|
bitConvBuffer = xrealloc(bitConvBuffer, dataBitLen);
|
2004-05-10 19:08:46 +02:00
|
|
|
bitConvBufferLength = dataBitLen;
|
|
|
|
}
|
|
|
|
dataBitConv = bitConvBuffer;
|
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
mpd_sint8 *in = (mpd_sint8 *) inBuffer;
|
|
|
|
mpd_sint16 *out = (mpd_sint16 *) dataBitConv;
|
2004-05-10 19:08:46 +02:00
|
|
|
int i;
|
2006-07-20 18:02:40 +02:00
|
|
|
for (i = 0; i < inSize; i++) {
|
2004-05-10 19:08:46 +02:00
|
|
|
*out++ = (*in++) << 8;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 16:
|
|
|
|
dataBitConv = inBuffer;
|
|
|
|
dataBitLen = inSize;
|
|
|
|
break;
|
|
|
|
case 24:
|
|
|
|
/* put dithering code from mp3_decode here */
|
|
|
|
default:
|
|
|
|
ERROR("only 8 or 16 bits are supported for conversion!\n");
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
2004-05-10 17:21:40 +02:00
|
|
|
|
2007-05-22 17:21:56 +02:00
|
|
|
/* convert audio between mono and stereo */
|
2006-07-20 18:02:40 +02:00
|
|
|
if (inFormat->channels == outFormat->channels) {
|
2004-05-10 19:08:46 +02:00
|
|
|
dataChannelConv = dataBitConv;
|
|
|
|
dataChannelLen = dataBitLen;
|
2006-07-20 18:02:40 +02:00
|
|
|
} else {
|
|
|
|
switch (inFormat->channels) {
|
2007-05-22 17:21:56 +02:00
|
|
|
case 1: /* convert from 1 -> 2 channels */
|
2004-10-23 03:04:58 +02:00
|
|
|
dataChannelLen = (dataBitLen >> 1) << 2;
|
2006-07-20 18:02:40 +02:00
|
|
|
if (dataChannelLen > channelConvBufferLength) {
|
2006-08-26 08:25:57 +02:00
|
|
|
channelConvBuffer = xrealloc(channelConvBuffer,
|
2006-07-20 18:02:40 +02:00
|
|
|
dataChannelLen);
|
2004-10-23 03:04:58 +02:00
|
|
|
channelConvBufferLength = dataChannelLen;
|
|
|
|
}
|
|
|
|
dataChannelConv = channelConvBuffer;
|
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
mpd_sint16 *in = (mpd_sint16 *) dataBitConv;
|
|
|
|
mpd_sint16 *out =
|
|
|
|
(mpd_sint16 *) dataChannelConv;
|
2004-10-23 03:04:58 +02:00
|
|
|
int i, inSamples = dataBitLen >> 1;
|
2006-07-20 18:02:40 +02:00
|
|
|
for (i = 0; i < inSamples; i++) {
|
2004-10-23 03:04:58 +02:00
|
|
|
*out++ = *in;
|
|
|
|
*out++ = *in++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2007-05-22 17:21:56 +02:00
|
|
|
case 2: /* convert from 2 -> 1 channels */
|
2004-10-23 03:04:58 +02:00
|
|
|
dataChannelLen = dataBitLen >> 1;
|
2006-07-20 18:02:40 +02:00
|
|
|
if (dataChannelLen > channelConvBufferLength) {
|
2006-08-26 08:25:57 +02:00
|
|
|
channelConvBuffer = xrealloc(channelConvBuffer,
|
2006-07-20 18:02:40 +02:00
|
|
|
dataChannelLen);
|
2004-10-23 03:04:58 +02:00
|
|
|
channelConvBufferLength = dataChannelLen;
|
|
|
|
}
|
|
|
|
dataChannelConv = channelConvBuffer;
|
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
mpd_sint16 *in = (mpd_sint16 *) dataBitConv;
|
|
|
|
mpd_sint16 *out =
|
|
|
|
(mpd_sint16 *) dataChannelConv;
|
2004-10-23 03:04:58 +02:00
|
|
|
int i, inSamples = dataBitLen >> 2;
|
2006-07-20 18:02:40 +02:00
|
|
|
for (i = 0; i < inSamples; i++) {
|
|
|
|
*out = (*in++) / 2;
|
|
|
|
*out++ += (*in++) / 2;
|
2004-10-23 03:04:58 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
2007-05-22 17:21:56 +02:00
|
|
|
ERROR("only 1 or 2 channels are supported for "
|
|
|
|
"conversion!\n");
|
2004-10-23 03:04:58 +02:00
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
2004-05-10 19:08:46 +02:00
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (inFormat->sampleRate == outFormat->sampleRate) {
|
|
|
|
memcpy(outBuffer, dataChannelConv, dataChannelLen);
|
|
|
|
} else {
|
2007-02-02 04:51:07 +01:00
|
|
|
#ifdef HAVE_LIBSAMPLERATE
|
|
|
|
static SRC_STATE *state = NULL;
|
|
|
|
static SRC_DATA data;
|
2007-02-19 08:58:08 +01:00
|
|
|
static size_t data_in_size, data_out_size;
|
2007-02-02 04:51:07 +01:00
|
|
|
int error;
|
|
|
|
static double ratio = 0;
|
|
|
|
double newratio;
|
|
|
|
|
|
|
|
if(!state) {
|
|
|
|
state = src_new(pcm_getSamplerateConverter(), outFormat->channels, &error);
|
|
|
|
if(!state) {
|
|
|
|
ERROR("Cannot create new samplerate state: %s\n", src_strerror(error));
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
} else {
|
|
|
|
DEBUG("Samplerate converter initialized\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
newratio = (double)outFormat->sampleRate / (double)inFormat->sampleRate;
|
|
|
|
if(newratio != ratio) {
|
2007-02-14 00:47:41 +01:00
|
|
|
DEBUG("Setting samplerate conversion ratio to %.2lf\n", newratio);
|
|
|
|
src_set_ratio(state, newratio);
|
|
|
|
ratio = newratio;
|
2007-02-02 04:51:07 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
data.input_frames = dataChannelLen / 2 / outFormat->channels;
|
|
|
|
data.output_frames = pcm_sizeOfOutputBufferForAudioFormatConversion(inFormat, dataChannelLen, outFormat) / 2 / outFormat->channels;
|
|
|
|
data.src_ratio = (double)data.output_frames / (double)data.input_frames;
|
|
|
|
|
2007-02-19 08:58:08 +01:00
|
|
|
if (data_in_size != (data.input_frames *
|
|
|
|
outFormat->channels)) {
|
|
|
|
data_in_size = data.input_frames * outFormat->channels;
|
|
|
|
data.data_in = xrealloc(data.data_in, data_in_size);
|
|
|
|
}
|
|
|
|
if (data_out_size != (data.output_frames *
|
|
|
|
outFormat->channels)) {
|
|
|
|
data_out_size = data.output_frames *
|
|
|
|
outFormat->channels;
|
|
|
|
data.data_out = xrealloc(data.data_out, data_out_size);
|
|
|
|
}
|
2007-02-02 04:51:07 +01:00
|
|
|
|
|
|
|
src_short_to_float_array((short *)dataChannelConv, data.data_in, data.input_frames * outFormat->channels);
|
|
|
|
error = src_process(state, &data);
|
|
|
|
if(error) {
|
|
|
|
ERROR("Cannot process samples: %s\n", src_strerror(error));
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
|
|
|
|
src_float_to_short_array(data.data_out, (short *)outBuffer, data.output_frames * outFormat->channels);
|
|
|
|
#else
|
2004-05-11 00:31:23 +02:00
|
|
|
/* resampling code blatantly ripped from ESD */
|
2006-07-14 22:08:35 +02:00
|
|
|
mpd_uint32 rd_dat = 0;
|
|
|
|
mpd_uint32 wr_dat = 0;
|
|
|
|
mpd_sint16 lsample, rsample;
|
2006-07-20 18:02:40 +02:00
|
|
|
mpd_sint16 *out = (mpd_sint16 *) outBuffer;
|
|
|
|
mpd_sint16 *in = (mpd_sint16 *) dataChannelConv;
|
2007-02-02 04:51:07 +01:00
|
|
|
mpd_uint32 nlen = pcm_sizeOfOutputBufferForAudioFormatConversion(inFormat, inSize, outFormat) / sizeof(mpd_sint16);
|
2004-05-11 00:31:23 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
switch (outFormat->channels) {
|
2004-10-23 04:40:03 +02:00
|
|
|
case 1:
|
2006-07-20 18:02:40 +02:00
|
|
|
while (wr_dat < nlen) {
|
|
|
|
rd_dat = wr_dat * inFormat->sampleRate /
|
|
|
|
outFormat->sampleRate;
|
2004-10-23 04:40:03 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
lsample = in[rd_dat++];
|
2004-10-23 04:40:03 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
out[wr_dat++] = lsample;
|
2006-07-14 22:08:35 +02:00
|
|
|
}
|
2004-10-23 04:40:03 +02:00
|
|
|
break;
|
|
|
|
case 2:
|
2006-07-20 18:02:40 +02:00
|
|
|
while (wr_dat < nlen) {
|
|
|
|
rd_dat = wr_dat * inFormat->sampleRate /
|
|
|
|
outFormat->sampleRate;
|
2006-07-14 22:08:35 +02:00
|
|
|
rd_dat &= ~1;
|
2004-05-11 00:31:23 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
lsample = in[rd_dat++];
|
|
|
|
rsample = in[rd_dat++];
|
2004-05-11 00:31:23 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
out[wr_dat++] = lsample;
|
|
|
|
out[wr_dat++] = rsample;
|
2006-07-14 22:08:35 +02:00
|
|
|
}
|
2004-10-23 04:40:03 +02:00
|
|
|
break;
|
|
|
|
}
|
2007-02-02 04:51:07 +01:00
|
|
|
#endif
|
2004-05-10 17:21:40 +02:00
|
|
|
}
|
2004-05-10 16:06:23 +02:00
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t pcm_sizeOfOutputBufferForAudioFormatConversion(AudioFormat * inFormat,
|
2007-05-22 17:02:25 +02:00
|
|
|
size_t inSize,
|
|
|
|
AudioFormat * outFormat)
|
2004-05-10 16:06:23 +02:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
const int shift = sizeof(mpd_sint16) * outFormat->channels;
|
2004-05-10 19:15:04 +02:00
|
|
|
size_t outSize = inSize;
|
2004-05-10 17:21:40 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
switch (inFormat->bits) {
|
2004-05-10 19:15:04 +02:00
|
|
|
case 8:
|
|
|
|
outSize = outSize << 1;
|
|
|
|
break;
|
|
|
|
case 16:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ERROR("only 8 or 16 bits are supported for conversion!\n");
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
2004-05-10 17:21:40 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (inFormat->channels != outFormat->channels) {
|
|
|
|
switch (inFormat->channels) {
|
2004-10-23 04:40:03 +02:00
|
|
|
case 1:
|
|
|
|
outSize = (outSize >> 1) << 2;
|
|
|
|
break;
|
|
|
|
case 2:
|
2004-10-23 14:58:59 +02:00
|
|
|
outSize >>= 1;
|
2004-10-23 04:40:03 +02:00
|
|
|
break;
|
|
|
|
}
|
2004-05-10 19:15:04 +02:00
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
|
2007-05-22 17:02:25 +02:00
|
|
|
outSize /= shift;
|
2007-02-02 04:51:07 +01:00
|
|
|
outSize = floor(0.5 + (double)outSize *
|
|
|
|
((double)outFormat->sampleRate / (double)inFormat->sampleRate));
|
2004-10-23 04:40:03 +02:00
|
|
|
outSize *= shift;
|
2004-05-10 16:06:23 +02:00
|
|
|
|
2004-05-10 19:15:04 +02:00
|
|
|
return outSize;
|
2004-05-10 16:06:23 +02:00
|
|
|
}
|