Skip to content

L
libSDL
Commit c500e6c0 authored by Ryan C. Gordon's avatar Ryan C. Gordon
Browse files
Options

First shot at new audio data types (int32 and float32). 

Notable changes:
 - Converters between types are autogenerated. Instead of making multiple
   passes over the data with seperate filters for endianess, size, signedness,
   etc, converting between data types is always one specialized filter. This
   simplifies SDL_BuildAudioCVT(), which otherwise had a million edge cases
   with the new types, and makes the actually conversions more CPU cache
   friendly. Left a stub for adding specific optimized versions of these
   routines (SSE/MMX/Altivec, assembler, etc)
 - Autogenerated converters are built by SDL/src/audio/sdlgenaudiocvt.pl. This
   does not need to be run unless tweaking the code, and thus doesn't need
   integration into the build system.
 - Went through all the drivers and tried to weed out all the "Uint16"
   references that are better specified with the new SDL_AudioFormat typedef.
 - Cleaned out a bunch of hardcoded bitwise magic numbers and replaced them
   with new SDL_AUDIO_* macros.
 - Added initial float32 and int32 support code. Theoretically, existing
   drivers will push these through converters to get the data they want to
   feed to the hardware.

Still TODO:
 - Optimize and debug new converters.
 - Update the CoreAudio backend to accept float32 data directly.
 - Other backends, too?
 - SDL_LoadWAV() needs to be updated to support int32 and float32 .wav files
   (both of which exist and can be generated by 'sox' for testing purposes).
 - Update the mixer to handle new datatypes.
 - Optionally update SDL_sound and SDL_mixer, etc.

--HG--
extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%402029
parent 03794d9b
Hide whitespace changes
Inline Side-by-side
Showing with 3465 additions and 693 deletions
src/audio/SDL_audio.c
View file @ c500e6c0
......@@ -286,10 +286,10 @@ SDL_UnlockAudio_Default(SDL_AudioDevice * audio)
SDL_mutexV(audio->mixer_lock);
}
static Uint16
static SDL_AudioFormat
SDL_ParseAudioFormat(const char *string)
{
Uint16 format = 0;
SDL_AudioFormat format = 0;
switch (*string) {
case 'U':
......@@ -740,26 +740,34 @@ SDL_AudioQuit(void)
}
}
#define NUM_FORMATS 6
#define NUM_FORMATS 10
static int format_idx;
static int format_idx_sub;
static Uint16 format_list[NUM_FORMATS][NUM_FORMATS] = {
static SDL_AudioFormat format_list[NUM_FORMATS][NUM_FORMATS] = {
{AUDIO_U8, AUDIO_S8, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U16LSB,
AUDIO_U16MSB},
AUDIO_U16MSB, AUDIO_S32LSB, AUDIO_S32MSB, AUDIO_F32LSB, AUDIO_F32MSB},
{AUDIO_S8, AUDIO_U8, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U16LSB,
AUDIO_U16MSB},
{AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_U8,
AUDIO_S8},
{AUDIO_S16MSB, AUDIO_S16LSB, AUDIO_U16MSB, AUDIO_U16LSB, AUDIO_U8,
AUDIO_S8},
{AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U8,
AUDIO_S8},
{AUDIO_U16MSB, AUDIO_U16LSB, AUDIO_S16MSB, AUDIO_S16LSB, AUDIO_U8,
AUDIO_S8},
AUDIO_U16MSB, AUDIO_S32LSB, AUDIO_S32MSB, AUDIO_F32LSB, AUDIO_F32MSB},
{AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_S32LSB,
AUDIO_S32MSB, AUDIO_F32LSB, AUDIO_F32MSB, AUDIO_U8, AUDIO_S8},
{AUDIO_S16MSB, AUDIO_S16LSB, AUDIO_U16MSB, AUDIO_U16LSB, AUDIO_S32MSB,
AUDIO_S32LSB, AUDIO_F32MSB, AUDIO_F32LSB, AUDIO_U8, AUDIO_S8},
{AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_S32LSB,
AUDIO_S32MSB, AUDIO_F32LSB, AUDIO_F32MSB, AUDIO_U8, AUDIO_S8},
{AUDIO_U16MSB, AUDIO_U16LSB, AUDIO_S16MSB, AUDIO_S16LSB, AUDIO_S32MSB,
AUDIO_S32LSB, AUDIO_F32MSB, AUDIO_F32LSB, AUDIO_U8, AUDIO_S8},
{AUDIO_S32LSB, AUDIO_S32MSB, AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_S16LSB,
AUDIO_S16MSB, AUDIO_F32LSB, AUDIO_F32MSB, AUDIO_U8, AUDIO_S8},
{AUDIO_S32MSB, AUDIO_S32LSB, AUDIO_U16MSB, AUDIO_U16LSB, AUDIO_S16MSB,
AUDIO_S16LSB, AUDIO_F32LSB, AUDIO_F32MSB, AUDIO_U8, AUDIO_S8},
{AUDIO_F32LSB, AUDIO_F32MSB, AUDIO_S32LSB, AUDIO_S32MSB, AUDIO_U16LSB,
AUDIO_U16MSB, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U8, AUDIO_S8},
{AUDIO_F32MSB, AUDIO_F32LSB, AUDIO_S32MSB, AUDIO_S32LSB, AUDIO_U16MSB,
AUDIO_U16LSB, AUDIO_S16MSB, AUDIO_S16LSB, AUDIO_U8, AUDIO_S8},
};
Uint16
SDL_FirstAudioFormat(Uint16 format)
SDL_AudioFormat
SDL_FirstAudioFormat(SDL_AudioFormat format)
{
for (format_idx = 0; format_idx < NUM_FORMATS; ++format_idx) {
if (format_list[format_idx][0] == format) {
......@@ -770,7 +778,7 @@ SDL_FirstAudioFormat(Uint16 format)
return (SDL_NextAudioFormat());
}
Uint16
SDL_AudioFormat
SDL_NextAudioFormat(void)
{
if ((format_idx == NUM_FORMATS) || (format_idx_sub == NUM_FORMATS)) {
......
src/audio/SDL_audio_c.h
View file @ c500e6c0
......@@ -24,12 +24,22 @@
/* Functions and variables exported from SDL_audio.c for SDL_sysaudio.c */
/* Functions to get a list of "close" audio formats */
extern Uint16 SDL_FirstAudioFormat(Uint16 format);
extern Uint16 SDL_NextAudioFormat(void);
extern SDL_AudioFormat SDL_FirstAudioFormat(SDL_AudioFormat format);
extern SDL_AudioFormat SDL_NextAudioFormat(void);
/* Function to calculate the size and silence for a SDL_AudioSpec */
extern void SDL_CalculateAudioSpec(SDL_AudioSpec * spec);
/* The actual mixing thread function */
extern int SDLCALL SDL_RunAudio(void *audiop);
/* this is used internally to access some autogenerated code. */
typedef struct
{
SDL_AudioFormat src_fmt;
SDL_AudioFormat dst_fmt;
SDL_AudioFilter filter;
} SDL_AudioTypeFilters;
extern const SDL_AudioTypeFilters sdl_audio_type_filters[];
/* vi: set ts=4 sw=4 expandtab: */
src/audio/SDL_audiocvt.c
View file @ c500e6c0
......@@ -24,11 +24,11 @@
/* Functions for audio drivers to perform runtime conversion of audio format */
#include "SDL_audio.h"
#include "SDL_audio_c.h"
/* Effectively mix right and left channels into a single channel */
void SDLCALL
SDL_ConvertMono(SDL_AudioCVT * cvt, Uint16 format)
static void SDLCALL
SDL_ConvertMono(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
Sint32 sample;
......@@ -36,8 +36,7 @@ SDL_ConvertMono(SDL_AudioCVT * cvt, Uint16 format)
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting to mono\n");
#endif
switch (format & 0x8018) {
switch (format & (SDL_AUDIO_MASK_SIGNED|SDL_AUDIO_MASK_BITSIZE)) {
case AUDIO_U8:
{
Uint8 *src, *dst;
......@@ -84,7 +83,7 @@ SDL_ConvertMono(SDL_AudioCVT * cvt, Uint16 format)
src = cvt->buf;
dst = cvt->buf;
if ((format & 0x1000) == 0x1000) {
if (SDL_AUDIO_ISBIGENDIAN(format)) {
for (i = cvt->len_cvt / 4; i; --i) {
sample = (Uint16) ((src[0] << 8) | src[1]) +
(Uint16) ((src[2] << 8) | src[3]);
......@@ -124,7 +123,7 @@ SDL_ConvertMono(SDL_AudioCVT * cvt, Uint16 format)
src = cvt->buf;
dst = cvt->buf;
if ((format & 0x1000) == 0x1000) {
if (SDL_AUDIO_ISBIGENDIAN(format)) {
for (i = cvt->len_cvt / 4; i; --i) {
sample = (Sint16) ((src[0] << 8) | src[1]) +
(Sint16) ((src[2] << 8) | src[3]);
......@@ -163,286 +162,195 @@ SDL_ConvertMono(SDL_AudioCVT * cvt, Uint16 format)
}
}
break;
}
cvt->len_cvt /= 2;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
/* Discard top 4 channels */
void SDLCALL
SDL_ConvertStrip(SDL_AudioCVT * cvt, Uint16 format)
{
int i;
Sint32 lsample, rsample;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting down to stereo\n");
#endif
switch (format & 0x8018) {
case AUDIO_U8:
case AUDIO_S32:
{
Uint8 *src, *dst;
src = cvt->buf;
dst = cvt->buf;
for (i = cvt->len_cvt / 6; i; --i) {
dst[0] = src[0];
dst[1] = src[1];
src += 6;
dst += 2;
}
}
break;
case AUDIO_S8:
{
Sint8 *src, *dst;
src = (Sint8 *) cvt->buf;
dst = (Sint8 *) cvt->buf;
for (i = cvt->len_cvt / 6; i; --i) {
dst[0] = src[0];
dst[1] = src[1];
src += 6;
dst += 2;
}
}
break;
case AUDIO_U16:
{
Uint8 *src, *dst;
src = cvt->buf;
dst = cvt->buf;
if ((format & 0x1000) == 0x1000) {
for (i = cvt->len_cvt / 12; i; --i) {
lsample = (Uint16) ((src[0] << 8) | src[1]);
rsample = (Uint16) ((src[2] << 8) | src[3]);
dst[1] = (lsample & 0xFF);
lsample >>= 8;
dst[0] = (lsample & 0xFF);
dst[3] = (rsample & 0xFF);
rsample >>= 8;
dst[2] = (rsample & 0xFF);
src += 12;
dst += 4;
const Uint32 *src = (const Uint32 *) cvt->buf;
Uint32 *dst = (Uint32 *) cvt->buf;
if (SDL_AUDIO_ISBIGENDIAN(format)) {
for (i = cvt->len_cvt / 8; i; --i, src += 2) {
const Sint64 added =
(((Sint64) (Sint32) SDL_SwapBE32(src[0])) +
((Sint64) (Sint32) SDL_SwapBE32(src[1])));
*(dst++) = SDL_SwapBE32((Uint32) ((Sint32) (added >> 1)));
}
} else {
for (i = cvt->len_cvt / 12; i; --i) {
lsample = (Uint16) ((src[1] << 8) | src[0]);
rsample = (Uint16) ((src[3] << 8) | src[2]);
dst[0] = (lsample & 0xFF);
lsample >>= 8;
dst[1] = (lsample & 0xFF);
dst[2] = (rsample & 0xFF);
rsample >>= 8;
dst[3] = (rsample & 0xFF);
src += 12;
dst += 4;
for (i = cvt->len_cvt / 8; i; --i, src += 2) {
const Sint64 added =
(((Sint64) (Sint32) SDL_SwapLE32(src[0])) +
((Sint64) (Sint32) SDL_SwapLE32(src[1])));
*(dst++) = SDL_SwapLE32((Uint32) ((Sint32) (added >> 1)));
}
}
}
break;
case AUDIO_S16:
case AUDIO_F32:
{
Uint8 *src, *dst;
src = cvt->buf;
dst = cvt->buf;
if ((format & 0x1000) == 0x1000) {
for (i = cvt->len_cvt / 12; i; --i) {
lsample = (Sint16) ((src[0] << 8) | src[1]);
rsample = (Sint16) ((src[2] << 8) | src[3]);
dst[1] = (lsample & 0xFF);
lsample >>= 8;
dst[0] = (lsample & 0xFF);
dst[3] = (rsample & 0xFF);
rsample >>= 8;
dst[2] = (rsample & 0xFF);
src += 12;
dst += 4;
/* !!! FIXME: this convert union is nasty. */
union { float f; Uint32 ui32; } f2i;
const Uint32 *src = (const Uint32 *) cvt->buf;
Uint32 *dst = (Uint32 *) cvt->buf;
if (SDL_AUDIO_ISBIGENDIAN(format)) {
for (i = cvt->len_cvt / 8; i; --i, src += 2) {
float src1, src2;
f2i.ui32 = SDL_SwapBE32(src[0]);
src1 = f2i.f;
f2i.ui32 = SDL_SwapBE32(src[1]);
src2 = f2i.f;
const double added = ((double) src1) + ((double) src2);
f2i.f = (float) (added * 0.5);
*(dst++) = SDL_SwapBE32(f2i.ui32);
}
} else {
for (i = cvt->len_cvt / 12; i; --i) {
lsample = (Sint16) ((src[1] << 8) | src[0]);
rsample = (Sint16) ((src[3] << 8) | src[2]);
dst[0] = (lsample & 0xFF);
lsample >>= 8;
dst[1] = (lsample & 0xFF);
dst[2] = (rsample & 0xFF);
rsample >>= 8;
dst[3] = (rsample & 0xFF);
src += 12;
dst += 4;
for (i = cvt->len_cvt / 8; i; --i, src += 2) {
float src1, src2;
f2i.ui32 = SDL_SwapLE32(src[0]);
src1 = f2i.f;
f2i.ui32 = SDL_SwapLE32(src[1]);
src2 = f2i.f;
const double added = ((double) src1) + ((double) src2);
f2i.f = (float) (added * 0.5);
*(dst++) = SDL_SwapLE32(f2i.ui32);
}
}
}
break;
}
cvt->len_cvt /= 3;
cvt->len_cvt /= 2;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
/* Discard top 2 channels of 6 */
void SDLCALL
SDL_ConvertStrip_2(SDL_AudioCVT * cvt, Uint16 format)
/* Discard top 4 channels */
static void SDLCALL
SDL_ConvertStrip(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
Sint32 lsample, rsample;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting 6 down to quad\n");
fprintf(stderr, "Converting down from 6 channels to stereo\n");
#endif
switch (format & 0x8018) {
case AUDIO_U8:
{
Uint8 *src, *dst;
#define strip_chans_6_to_2(type) \
{ \
const type *src = (const type *) cvt->buf; \
type *dst = (type *) cvt->buf; \
for (i = cvt->len_cvt / (sizeof (type) * 6); i; --i) { \
dst[0] = src[0]; \
dst[1] = src[1]; \
src += 6; \
dst += 2; \
} \
}
src = cvt->buf;
dst = cvt->buf;
for (i = cvt->len_cvt / 4; i; --i) {
dst[0] = src[0];
dst[1] = src[1];
src += 4;
dst += 2;
}
}
break;
/* this function only cares about typesize, and data as a block of bits. */
switch (SDL_AUDIO_BITSIZE(format)) {
case 8:
strip_chans_6_to_2(Uint8);
break;
case 16:
strip_chans_6_to_2(Uint16);
break;
case 32:
strip_chans_6_to_2(Uint32);
break;
}
case AUDIO_S8:
{
Sint8 *src, *dst;
#undef strip_chans_6_to_2
src = (Sint8 *) cvt->buf;
dst = (Sint8 *) cvt->buf;
for (i = cvt->len_cvt / 4; i; --i) {
dst[0] = src[0];
dst[1] = src[1];
src += 4;
dst += 2;
}
}
break;
cvt->len_cvt /= 3;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
case AUDIO_U16:
{
Uint8 *src, *dst;
src = cvt->buf;
dst = cvt->buf;
if ((format & 0x1000) == 0x1000) {
for (i = cvt->len_cvt / 8; i; --i) {
lsample = (Uint16) ((src[0] << 8) | src[1]);
rsample = (Uint16) ((src[2] << 8) | src[3]);
dst[1] = (lsample & 0xFF);
lsample >>= 8;
dst[0] = (lsample & 0xFF);
dst[3] = (rsample & 0xFF);
rsample >>= 8;
dst[2] = (rsample & 0xFF);
src += 8;
dst += 4;
}
} else {
for (i = cvt->len_cvt / 8; i; --i) {
lsample = (Uint16) ((src[1] << 8) | src[0]);
rsample = (Uint16) ((src[3] << 8) | src[2]);
dst[0] = (lsample & 0xFF);
lsample >>= 8;
dst[1] = (lsample & 0xFF);
dst[2] = (rsample & 0xFF);
rsample >>= 8;
dst[3] = (rsample & 0xFF);
src += 8;
dst += 4;
}
}
}
break;
/* Discard top 2 channels of 6 */
static void SDLCALL
SDL_ConvertStrip_2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
case AUDIO_S16:
{
Uint8 *src, *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting 6 down to quad\n");
#endif
src = cvt->buf;
dst = cvt->buf;
if ((format & 0x1000) == 0x1000) {
for (i = cvt->len_cvt / 8; i; --i) {
lsample = (Sint16) ((src[0] << 8) | src[1]);
rsample = (Sint16) ((src[2] << 8) | src[3]);
dst[1] = (lsample & 0xFF);
lsample >>= 8;
dst[0] = (lsample & 0xFF);
dst[3] = (rsample & 0xFF);
rsample >>= 8;
dst[2] = (rsample & 0xFF);
src += 8;
dst += 4;
}
} else {
for (i = cvt->len_cvt / 8; i; --i) {
lsample = (Sint16) ((src[1] << 8) | src[0]);
rsample = (Sint16) ((src[3] << 8) | src[2]);
dst[0] = (lsample & 0xFF);
lsample >>= 8;
dst[1] = (lsample & 0xFF);
dst[2] = (rsample & 0xFF);
rsample >>= 8;
dst[3] = (rsample & 0xFF);
src += 8;
dst += 4;
}
}
}
break;
#define strip_chans_6_to_4(type) \
{ \
const type *src = (const type *) cvt->buf; \
type *dst = (type *) cvt->buf; \
for (i = cvt->len_cvt / (sizeof (type) * 6); i; --i) { \
dst[0] = src[0]; \
dst[1] = src[1]; \
dst[2] = src[2]; \
dst[3] = src[3]; \
src += 6; \
dst += 4; \
} \
}
cvt->len_cvt /= 2;
/* this function only cares about typesize, and data as a block of bits. */
switch (SDL_AUDIO_BITSIZE(format)) {
case 8:
strip_chans_6_to_4(Uint8);
break;
case 16:
strip_chans_6_to_4(Uint16);
break;
case 32:
strip_chans_6_to_4(Uint32);
break;
}
#undef strip_chans_6_to_4
cvt->len_cvt /= 6;
cvt->len_cvt *= 4;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
/* Duplicate a mono channel to both stereo channels */
void SDLCALL
SDL_ConvertStereo(SDL_AudioCVT * cvt, Uint16 format)
static void SDLCALL
SDL_ConvertStereo(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting to stereo\n");
#endif
if ((format & 0xFF) == 16) {
Uint16 *src, *dst;
src = (Uint16 *) (cvt->buf + cvt->len_cvt);
dst = (Uint16 *) (cvt->buf + cvt->len_cvt * 2);
for (i = cvt->len_cvt / 2; i; --i) {
dst -= 2;
src -= 1;
dst[0] = src[0];
dst[1] = src[0];
}
} else {
Uint8 *src, *dst;
src = cvt->buf + cvt->len_cvt;
dst = cvt->buf + cvt->len_cvt * 2;
for (i = cvt->len_cvt; i; --i) {
dst -= 2;
src -= 1;
dst[0] = src[0];
dst[1] = src[0];
}
#define dup_chans_1_to_2(type) \
{ \
const type *src = (const type *) (cvt->buf + cvt->len_cvt); \
type *dst = (type *) (cvt->buf + cvt->len_cvt * 2); \
for (i = cvt->len_cvt / 2; i; --i, --src) { \
const type val = *src; \
dst -= 2; \
dst[0] = dst[1] = val; \
} \
}
/* this function only cares about typesize, and data as a block of bits. */
switch (SDL_AUDIO_BITSIZE(format)) {
case 8:
dup_chans_1_to_2(Uint8);
break;
case 16:
dup_chans_1_to_2(Uint16);
break;
case 32:
dup_chans_1_to_2(Uint32);
break;
}
#undef dup_chans_1_to_2
cvt->len_cvt *= 2;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
......@@ -451,16 +359,16 @@ SDL_ConvertStereo(SDL_AudioCVT * cvt, Uint16 format)
/* Duplicate a stereo channel to a pseudo-5.1 stream */
void SDLCALL
SDL_ConvertSurround(SDL_AudioCVT * cvt, Uint16 format)
static void SDLCALL
SDL_ConvertSurround(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting stereo to surround\n");
#endif
switch (format & 0x8018) {
switch (format & (SDL_AUDIO_MASK_SIGNED|SDL_AUDIO_MASK_BITSIZE)) {
case AUDIO_U8:
{
Uint8 *src, *dst, lf, rf, ce;
......@@ -513,7 +421,7 @@ SDL_ConvertSurround(SDL_AudioCVT * cvt, Uint16 format)
src = cvt->buf + cvt->len_cvt;
dst = cvt->buf + cvt->len_cvt * 3;
if ((format & 0x1000) == 0x1000) {
if (SDL_AUDIO_ISBIGENDIAN(format)) {
for (i = cvt->len_cvt / 4; i; --i) {
dst -= 12;
src -= 4;
......@@ -573,7 +481,7 @@ SDL_ConvertSurround(SDL_AudioCVT * cvt, Uint16 format)
src = cvt->buf + cvt->len_cvt;
dst = cvt->buf + cvt->len_cvt * 3;
if ((format & 0x1000) == 0x1000) {
if (SDL_AUDIO_ISBIGENDIAN(format)) {
for (i = cvt->len_cvt / 4; i; --i) {
dst -= 12;
src -= 4;
......@@ -624,6 +532,96 @@ SDL_ConvertSurround(SDL_AudioCVT * cvt, Uint16 format)
}
}
break;
case AUDIO_S32:
{
Sint32 lf, rf, ce;
const Uint32 *src = (const Uint32 *) cvt->buf + cvt->len_cvt;
Uint32 *dst = (Uint32 *) cvt->buf + cvt->len_cvt * 3;
if (SDL_AUDIO_ISBIGENDIAN(format)) {
for (i = cvt->len_cvt / 8; i; --i) {
dst -= 6;
src -= 2;
lf = (Sint32) SDL_SwapBE32(src[0]);
rf = (Sint32) SDL_SwapBE32(src[1]);
ce = (lf / 2) + (rf / 2);
dst[0] = SDL_SwapBE32((Uint32) lf);
dst[1] = SDL_SwapBE32((Uint32) rf);
dst[2] = SDL_SwapBE32((Uint32) (lf - ce));
dst[3] = SDL_SwapBE32((Uint32) (rf - ce));
dst[4] = SDL_SwapBE32((Uint32) ce);
dst[5] = SDL_SwapBE32((Uint32) ce);
}
} else {
for (i = cvt->len_cvt / 8; i; --i) {
dst -= 6;
src -= 2;
lf = (Sint32) SDL_SwapLE32(src[0]);
rf = (Sint32) SDL_SwapLE32(src[1]);
ce = (lf / 2) + (rf / 2);
dst[0] = src[0];
dst[1] = src[1];
dst[2] = SDL_SwapLE32((Uint32) (lf - ce));
dst[3] = SDL_SwapLE32((Uint32) (rf - ce));
dst[4] = SDL_SwapLE32((Uint32) ce);
dst[5] = SDL_SwapLE32((Uint32) ce);
}
}
}
break;
case AUDIO_F32:
{
union { float f; Uint32 ui32; } f2i; /* !!! FIXME: lame. */
float lf, rf, ce;
const Uint32 *src = (const Uint32 *) cvt->buf + cvt->len_cvt;
Uint32 *dst = (Uint32 *) cvt->buf + cvt->len_cvt * 3;
if (SDL_AUDIO_ISBIGENDIAN(format)) {
for (i = cvt->len_cvt / 8; i; --i) {
dst -= 6;
src -= 2;
f2i.ui32 = SDL_SwapBE32(src[0]);
lf = f2i.f;
f2i.ui32 = SDL_SwapBE32(src[1]);
rf = f2i.f;
ce = (lf * 0.5f) + (rf * 0.5f);
dst[0] = src[0];
dst[1] = src[1];
f2i.f = (lf - ce);
dst[2] = SDL_SwapBE32(f2i.ui32);
f2i.f = (rf - ce);
dst[3] = SDL_SwapBE32(f2i.ui32);
f2i.f = ce;
f2i.ui32 = SDL_SwapBE32(f2i.ui32);
dst[4] = f2i.ui32;
dst[5] = f2i.ui32;
}
} else {
for (i = cvt->len_cvt / 8; i; --i) {
dst -= 6;
src -= 2;
f2i.ui32 = SDL_SwapLE32(src[0]);
lf = f2i.f;
f2i.ui32 = SDL_SwapLE32(src[1]);
rf = f2i.f;
ce = (lf * 0.5f) + (rf * 0.5f);
dst[0] = src[0];
dst[1] = src[1];
f2i.f = (lf - ce);
dst[2] = SDL_SwapLE32(f2i.ui32);
f2i.f = (rf - ce);
dst[3] = SDL_SwapLE32(f2i.ui32);
f2i.f = ce;
f2i.ui32 = SDL_SwapLE32(f2i.ui32);
dst[4] = f2i.ui32;
dst[5] = f2i.ui32;
}
}
}
break;
}
cvt->len_cvt *= 3;
if (cvt->filters[++cvt->filter_index]) {
......@@ -633,16 +631,16 @@ SDL_ConvertSurround(SDL_AudioCVT * cvt, Uint16 format)
/* Duplicate a stereo channel to a pseudo-4.0 stream */
void SDLCALL
SDL_ConvertSurround_4(SDL_AudioCVT * cvt, Uint16 format)
static void SDLCALL
SDL_ConvertSurround_4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting stereo to quad\n");
#endif
switch (format & 0x8018) {
switch (format & (SDL_AUDIO_MASK_SIGNED|SDL_AUDIO_MASK_BITSIZE)) {
case AUDIO_U8:
{
Uint8 *src, *dst, lf, rf, ce;
......@@ -691,7 +689,7 @@ SDL_ConvertSurround_4(SDL_AudioCVT * cvt, Uint16 format)
src = cvt->buf + cvt->len_cvt;
dst = cvt->buf + cvt->len_cvt * 2;
if ((format & 0x1000) == 0x1000) {
if (SDL_AUDIO_ISBIGENDIAN(format)) {
for (i = cvt->len_cvt / 4; i; --i) {
dst -= 8;
src -= 4;
......@@ -741,7 +739,7 @@ SDL_ConvertSurround_4(SDL_AudioCVT * cvt, Uint16 format)
src = cvt->buf + cvt->len_cvt;
dst = cvt->buf + cvt->len_cvt * 2;
if ((format & 0x1000) == 0x1000) {
if (SDL_AUDIO_ISBIGENDIAN(format)) {
for (i = cvt->len_cvt / 4; i; --i) {
dst -= 8;
src -= 4;
......@@ -782,176 +780,81 @@ SDL_ConvertSurround_4(SDL_AudioCVT * cvt, Uint16 format)
}
}
break;
}
cvt->len_cvt *= 2;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
/* Convert 8-bit to 16-bit - LSB */
void SDLCALL
SDL_Convert16LSB(SDL_AudioCVT * cvt, Uint16 format)
{
int i;
Uint8 *src, *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting to 16-bit LSB\n");
#endif
src = cvt->buf + cvt->len_cvt;
dst = cvt->buf + cvt->len_cvt * 2;
for (i = cvt->len_cvt; i; --i) {
src -= 1;
dst -= 2;
dst[1] = *src;
dst[0] = 0;
}
format = ((format & ~0x0008) | AUDIO_U16LSB);
cvt->len_cvt *= 2;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
/* Convert 8-bit to 16-bit - MSB */
void SDLCALL
SDL_Convert16MSB(SDL_AudioCVT * cvt, Uint16 format)
{
int i;
Uint8 *src, *dst;
case AUDIO_S32:
{
const Uint32 *src = (const Uint32 *) (cvt->buf + cvt->len_cvt);
Uint32 *dst = (Uint32 *) (cvt->buf + cvt->len_cvt * 2);
Sint32 lf, rf, ce;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting to 16-bit MSB\n");
#endif
src = cvt->buf + cvt->len_cvt;
dst = cvt->buf + cvt->len_cvt * 2;
for (i = cvt->len_cvt; i; --i) {
src -= 1;
dst -= 2;
dst[0] = *src;
dst[1] = 0;
if (SDL_AUDIO_ISBIGENDIAN(format)) {
for (i = cvt->len_cvt / 8; i; --i) {
dst -= 4;
src -= 2;
lf = (Sint32) SDL_SwapBE32(src[0]);
rf = (Sint32) SDL_SwapBE32(src[1]);
ce = (lf / 2) + (rf / 2);
dst[0] = src[0];
dst[1] = src[1];
dst[2] = SDL_SwapBE32((Uint32) (lf - ce));
dst[3] = SDL_SwapBE32((Uint32) (rf - ce));
}
} else {
for (i = cvt->len_cvt / 8; i; --i) {
dst -= 4;
src -= 2;
lf = (Sint32) SDL_SwapLE32(src[0]);
rf = (Sint32) SDL_SwapLE32(src[1]);
ce = (lf / 2) + (rf / 2);
dst[0] = src[0];
dst[1] = src[1];
dst[2] = SDL_SwapLE32((Uint32) (lf - ce));
dst[3] = SDL_SwapLE32((Uint32) (rf - ce));
}
}
}
break;
}
format = ((format & ~0x0008) | AUDIO_U16MSB);
cvt->len_cvt *= 2;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
/* Convert 16-bit to 8-bit */
void SDLCALL
SDL_Convert8(SDL_AudioCVT * cvt, Uint16 format)
/* Convert rate up by multiple of 2 */
static void SDLCALL
SDL_RateMUL2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
Uint8 *src, *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting to 8-bit\n");
fprintf(stderr, "Converting audio rate * 2 (mono)\n");
#endif
src = cvt->buf;
dst = cvt->buf;
if ((format & 0x1000) != 0x1000) { /* Little endian */
++src;
}
for (i = cvt->len_cvt / 2; i; --i) {
*dst = *src;
src += 2;
dst += 1;
}
format = ((format & ~0x9010) | AUDIO_U8);
cvt->len_cvt /= 2;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
/* Toggle signed/unsigned */
void SDLCALL
SDL_ConvertSign(SDL_AudioCVT * cvt, Uint16 format)
{
int i;
Uint8 *data;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting audio signedness\n");
#endif
data = cvt->buf;
if ((format & 0xFF) == 16) {
if ((format & 0x1000) != 0x1000) { /* Little endian */
++data;
}
for (i = cvt->len_cvt / 2; i; --i) {
*data ^= 0x80;
data += 2;
}
} else {
for (i = cvt->len_cvt; i; --i) {
*data++ ^= 0x80;
}
}
format = (format ^ 0x8000);
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
#define mul2_mono(type) { \
const type *src = (const type *) (cvt->buf + cvt->len_cvt); \
type *dst = (type *) (cvt->buf + (cvt->len_cvt * 2)); \
for (i = cvt->len_cvt / sizeof (type); i; --i) { \
src--; \
dst[-1] = dst[-2] = src[0]; \
dst -= 2; \
} \
}
}
/* Toggle endianness */
void SDLCALL
SDL_ConvertEndian(SDL_AudioCVT * cvt, Uint16 format)
{
int i;
Uint8 *data, tmp;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting audio endianness\n");
#endif
data = cvt->buf;
for (i = cvt->len_cvt / 2; i; --i) {
tmp = data[0];
data[0] = data[1];
data[1] = tmp;
data += 2;
}
format = (format ^ 0x1000);
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
/* Convert rate up by multiple of 2 */
void SDLCALL
SDL_RateMUL2(SDL_AudioCVT * cvt, Uint16 format)
{
int i;
Uint8 *src, *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting audio rate * 2\n");
#endif
src = cvt->buf + cvt->len_cvt;
dst = cvt->buf + cvt->len_cvt * 2;
switch (format & 0xFF) {
switch (SDL_AUDIO_BITSIZE(format)) {
case 8:
for (i = cvt->len_cvt; i; --i) {
src -= 1;
dst -= 2;
dst[0] = src[0];
dst[1] = src[0];
}
mul2_mono(Uint8);
break;
case 16:
for (i = cvt->len_cvt / 2; i; --i) {
src -= 2;
dst -= 4;
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[0];
dst[3] = src[1];
}
mul2_mono(Uint16);
break;
case 32:
mul2_mono(Uint32);
break;
}
#undef mul2_mono
cvt->len_cvt *= 2;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
......@@ -960,43 +863,44 @@ SDL_RateMUL2(SDL_AudioCVT * cvt, Uint16 format)
/* Convert rate up by multiple of 2, for stereo */
void SDLCALL
SDL_RateMUL2_c2(SDL_AudioCVT * cvt, Uint16 format)
static void SDLCALL
SDL_RateMUL2_c2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
Uint8 *src, *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting audio rate * 2\n");
fprintf(stderr, "Converting audio rate * 2 (stereo)\n");
#endif
src = cvt->buf + cvt->len_cvt;
dst = cvt->buf + cvt->len_cvt * 2;
switch (format & 0xFF) {
#define mul2_stereo(type) { \
const type *src = (const type *) (cvt->buf + cvt->len_cvt); \
type *dst = (type *) (cvt->buf + (cvt->len_cvt * 2)); \
for (i = cvt->len_cvt / (sizeof (type) * 2); i; --i) { \
const type r = src[-1]; \
const type l = src[-2]; \
src -= 2; \
dst[-1] = r; \
dst[-2] = l; \
dst[-3] = r; \
dst[-4] = l; \
dst -= 4; \
} \
}
switch (SDL_AUDIO_BITSIZE(format)) {
case 8:
for (i = cvt->len_cvt / 2; i; --i) {
src -= 2;
dst -= 4;
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[0];
dst[3] = src[1];
}
mul2_stereo(Uint8);
break;
case 16:
for (i = cvt->len_cvt / 4; i; --i) {
src -= 4;
dst -= 8;
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
dst[3] = src[3];
dst[4] = src[0];
dst[5] = src[1];
dst[6] = src[2];
dst[7] = src[3];
}
mul2_stereo(Uint16);
break;
case 32:
mul2_stereo(Uint32);
break;
}
#undef mul2_stereo
cvt->len_cvt *= 2;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
......@@ -1004,55 +908,50 @@ SDL_RateMUL2_c2(SDL_AudioCVT * cvt, Uint16 format)
}
/* Convert rate up by multiple of 2, for quad */
void SDLCALL
SDL_RateMUL2_c4(SDL_AudioCVT * cvt, Uint16 format)
static void SDLCALL
SDL_RateMUL2_c4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
Uint8 *src, *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting audio rate * 2\n");
fprintf(stderr, "Converting audio rate * 2 (quad)\n");
#endif
src = cvt->buf + cvt->len_cvt;
dst = cvt->buf + cvt->len_cvt * 2;
switch (format & 0xFF) {
#define mul2_quad(type) { \
const type *src = (const type *) (cvt->buf + cvt->len_cvt); \
type *dst = (type *) (cvt->buf + (cvt->len_cvt * 2)); \
for (i = cvt->len_cvt / (sizeof (type) * 4); i; --i) { \
const type c1 = src[-1]; \
const type c2 = src[-2]; \
const type c3 = src[-3]; \
const type c4 = src[-4]; \
src -= 4; \
dst[-1] = c1; \
dst[-2] = c2; \
dst[-3] = c3; \
dst[-4] = c4; \
dst[-5] = c1; \
dst[-6] = c2; \
dst[-7] = c3; \
dst[-8] = c4; \
dst -= 8; \
} \
}
switch (SDL_AUDIO_BITSIZE(format)) {
case 8:
for (i = cvt->len_cvt / 4; i; --i) {
src -= 4;
dst -= 8;
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
dst[3] = src[3];
dst[4] = src[0];
dst[5] = src[1];
dst[6] = src[2];
dst[7] = src[3];
}
mul2_quad(Uint8);
break;
case 16:
for (i = cvt->len_cvt / 8; i; --i) {
src -= 8;
dst -= 16;
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
dst[3] = src[3];
dst[4] = src[4];
dst[5] = src[5];
dst[6] = src[6];
dst[7] = src[7];
dst[8] = src[0];
dst[9] = src[1];
dst[10] = src[2];
dst[11] = src[3];
dst[12] = src[4];
dst[13] = src[5];
dst[14] = src[6];
dst[15] = src[7];
}
mul2_quad(Uint16);
break;
case 32:
mul2_quad(Uint32);
break;
}
#undef mul2_quad
cvt->len_cvt *= 2;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
......@@ -1061,67 +960,56 @@ SDL_RateMUL2_c4(SDL_AudioCVT * cvt, Uint16 format)
/* Convert rate up by multiple of 2, for 5.1 */
void SDLCALL
SDL_RateMUL2_c6(SDL_AudioCVT * cvt, Uint16 format)
static void SDLCALL
SDL_RateMUL2_c6(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
Uint8 *src, *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting audio rate * 2\n");
fprintf(stderr, "Converting audio rate * 2 (six channels)\n");
#endif
src = cvt->buf + cvt->len_cvt;
dst = cvt->buf + cvt->len_cvt * 2;
switch (format & 0xFF) {
#define mul2_chansix(type) { \
const type *src = (const type *) (cvt->buf + cvt->len_cvt); \
type *dst = (type *) (cvt->buf + (cvt->len_cvt * 2)); \
for (i = cvt->len_cvt / (sizeof (type) * 6); i; --i) { \
const type c1 = src[-1]; \
const type c2 = src[-2]; \
const type c3 = src[-3]; \
const type c4 = src[-4]; \
const type c5 = src[-5]; \
const type c6 = src[-6]; \
src -= 6; \
dst[-1] = c1; \
dst[-2] = c2; \
dst[-3] = c3; \
dst[-4] = c4; \
dst[-5] = c5; \
dst[-6] = c6; \
dst[-7] = c1; \
dst[-8] = c2; \
dst[-9] = c3; \
dst[-10] = c4; \
dst[-11] = c5; \
dst[-12] = c6; \
dst -= 12; \
} \
}
switch (SDL_AUDIO_BITSIZE(format)) {
case 8:
for (i = cvt->len_cvt / 6; i; --i) {
src -= 6;
dst -= 12;
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
dst[3] = src[3];
dst[4] = src[4];
dst[5] = src[5];
dst[6] = src[0];
dst[7] = src[1];
dst[8] = src[2];
dst[9] = src[3];
dst[10] = src[4];
dst[11] = src[5];
}
mul2_chansix(Uint8);
break;
case 16:
for (i = cvt->len_cvt / 12; i; --i) {
src -= 12;
dst -= 24;
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
dst[3] = src[3];
dst[4] = src[4];
dst[5] = src[5];
dst[6] = src[6];
dst[7] = src[7];
dst[8] = src[8];
dst[9] = src[9];
dst[10] = src[10];
dst[11] = src[11];
dst[12] = src[0];
dst[13] = src[1];
dst[14] = src[2];
dst[15] = src[3];
dst[16] = src[4];
dst[17] = src[5];
dst[18] = src[6];
dst[19] = src[7];
dst[20] = src[8];
dst[21] = src[9];
dst[22] = src[10];
dst[23] = src[11];
}
mul2_chansix(Uint16);
break;
case 32:
mul2_chansix(Uint32);
break;
}
#undef mul2_chansix
cvt->len_cvt *= 2;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
......@@ -1129,34 +1017,39 @@ SDL_RateMUL2_c6(SDL_AudioCVT * cvt, Uint16 format)
}
/* Convert rate down by multiple of 2 */
void SDLCALL
SDL_RateDIV2(SDL_AudioCVT * cvt, Uint16 format)
static void SDLCALL
SDL_RateDIV2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
Uint8 *src, *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting audio rate / 2\n");
fprintf(stderr, "Converting audio rate / 2 (mono)\n");
#endif
src = cvt->buf;
dst = cvt->buf;
switch (format & 0xFF) {
#define div2_mono(type) { \
const type *src = (const type *) cvt->buf; \
type *dst = (type *) cvt->buf; \
for (i = cvt->len_cvt / (sizeof (type) * 2); i; --i) { \
dst[0] = src[0]; \
src += 2; \
dst++; \
} \
}
switch (SDL_AUDIO_BITSIZE(format)) {
case 8:
for (i = cvt->len_cvt / 2; i; --i) {
dst[0] = src[0];
src += 2;
dst += 1;
}
div2_mono(Uint8);
break;
case 16:
for (i = cvt->len_cvt / 4; i; --i) {
dst[0] = src[0];
dst[1] = src[1];
src += 4;
dst += 2;
}
div2_mono(Uint16);
break;
case 32:
div2_mono(Uint32);
break;
}
#undef div2_mono
cvt->len_cvt /= 2;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
......@@ -1165,37 +1058,40 @@ SDL_RateDIV2(SDL_AudioCVT * cvt, Uint16 format)
/* Convert rate down by multiple of 2, for stereo */
void SDLCALL
SDL_RateDIV2_c2(SDL_AudioCVT * cvt, Uint16 format)
static void SDLCALL
SDL_RateDIV2_c2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
Uint8 *src, *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting audio rate / 2\n");
fprintf(stderr, "Converting audio rate / 2 (stereo)\n");
#endif
src = cvt->buf;
dst = cvt->buf;
switch (format & 0xFF) {
#define div2_stereo(type) { \
const type *src = (const type *) cvt->buf; \
type *dst = (type *) cvt->buf; \
for (i = cvt->len_cvt / (sizeof (type) * 4); i; --i) { \
dst[0] = src[0]; \
dst[1] = src[1]; \
src += 4; \
dst += 2; \
} \
}
switch (SDL_AUDIO_BITSIZE(format)) {
case 8:
for (i = cvt->len_cvt / 4; i; --i) {
dst[0] = src[0];
dst[1] = src[1];
src += 4;
dst += 2;
}
div2_stereo(Uint8);
break;
case 16:
for (i = cvt->len_cvt / 8; i; --i) {
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
dst[3] = src[3];
src += 8;
dst += 4;
}
div2_stereo(Uint16);
break;
case 32:
div2_stereo(Uint32);
break;
}
#undef div2_stereo
cvt->len_cvt /= 2;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
......@@ -1204,43 +1100,42 @@ SDL_RateDIV2_c2(SDL_AudioCVT * cvt, Uint16 format)
/* Convert rate down by multiple of 2, for quad */
void SDLCALL
SDL_RateDIV2_c4(SDL_AudioCVT * cvt, Uint16 format)
static void SDLCALL
SDL_RateDIV2_c4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
Uint8 *src, *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting audio rate / 2\n");
fprintf(stderr, "Converting audio rate / 2 (quad)\n");
#endif
src = cvt->buf;
dst = cvt->buf;
switch (format & 0xFF) {
#define div2_quad(type) { \
const type *src = (const type *) cvt->buf; \
type *dst = (type *) cvt->buf; \
for (i = cvt->len_cvt / (sizeof (type) * 8); i; --i) { \
dst[0] = src[0]; \
dst[1] = src[1]; \
dst[2] = src[2]; \
dst[3] = src[3]; \
src += 8; \
dst += 4; \
} \
}
switch (SDL_AUDIO_BITSIZE(format)) {
case 8:
for (i = cvt->len_cvt / 8; i; --i) {
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
dst[3] = src[3];
src += 8;
dst += 4;
}
div2_quad(Uint8);
break;
case 16:
for (i = cvt->len_cvt / 16; i; --i) {
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
dst[3] = src[3];
dst[4] = src[4];
dst[5] = src[5];
dst[6] = src[6];
dst[7] = src[7];
src += 16;
dst += 8;
}
div2_quad(Uint16);
break;
case 32:
div2_quad(Uint32);
break;
}
#undef div2_quad
cvt->len_cvt /= 2;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
......@@ -1248,49 +1143,44 @@ SDL_RateDIV2_c4(SDL_AudioCVT * cvt, Uint16 format)
}
/* Convert rate down by multiple of 2, for 5.1 */
void SDLCALL
SDL_RateDIV2_c6(SDL_AudioCVT * cvt, Uint16 format)
static void SDLCALL
SDL_RateDIV2_c6(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
Uint8 *src, *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting audio rate / 2\n");
fprintf(stderr, "Converting audio rate / 2 (six channels)\n");
#endif
src = cvt->buf;
dst = cvt->buf;
switch (format & 0xFF) {
#define div2_chansix(type) { \
const type *src = (const type *) cvt->buf; \
type *dst = (type *) cvt->buf; \
for (i = cvt->len_cvt / (sizeof (type) * 12); i; --i) { \
dst[0] = src[0]; \
dst[1] = src[1]; \
dst[2] = src[2]; \
dst[3] = src[3]; \
dst[4] = src[4]; \
dst[5] = src[5]; \
src += 12; \
dst += 6; \
} \
}
switch (SDL_AUDIO_BITSIZE(format)) {
case 8:
for (i = cvt->len_cvt / 12; i; --i) {
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
dst[3] = src[3];
dst[4] = src[4];
dst[5] = src[5];
src += 12;
dst += 6;
}
div2_chansix(Uint8);
break;
case 16:
for (i = cvt->len_cvt / 24; i; --i) {
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
dst[3] = src[3];
dst[4] = src[4];
dst[5] = src[5];
dst[6] = src[6];
dst[7] = src[7];
dst[8] = src[8];
dst[9] = src[9];
dst[10] = src[10];
dst[11] = src[11];
src += 24;
dst += 12;
}
div2_chansix(Uint16);
break;
case 32:
div2_chansix(Uint32);
break;
}
#undef div_chansix
cvt->len_cvt /= 2;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
......@@ -1298,8 +1188,8 @@ SDL_RateDIV2_c6(SDL_AudioCVT * cvt, Uint16 format)
}
/* Very slow rate conversion routine */
void SDLCALL
SDL_RateSLOW(SDL_AudioCVT * cvt, Uint16 format)
static void SDLCALL
SDL_RateSLOW(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
double ipos;
int i, clen;
......@@ -1309,7 +1199,7 @@ SDL_RateSLOW(SDL_AudioCVT * cvt, Uint16 format)
#endif
clen = (int) ((double) cvt->len_cvt / cvt->rate_incr);
if (cvt->rate_incr > 1.0) {
switch (format & 0xFF) {
switch (SDL_AUDIO_BITSIZE(format)) {
case 8:
{
Uint8 *output;
......@@ -1338,9 +1228,15 @@ SDL_RateSLOW(SDL_AudioCVT * cvt, Uint16 format)
}
}
break;
case 32:
{
/* !!! FIXME: need 32-bit converter here! */
fprintf(stderr, "FIXME: need 32-bit converter here!\n");
}
}
} else {
switch (format & 0xFF) {
switch (SDL_AUDIO_BITSIZE(format)) {
case 8:
{
Uint8 *output;
......@@ -1369,8 +1265,15 @@ SDL_RateSLOW(SDL_AudioCVT * cvt, Uint16 format)
}
}
break;
case 32:
{
/* !!! FIXME: need 32-bit converter here! */
fprintf(stderr, "FIXME: need 32-bit converter here!\n");
}
}
}
cvt->len_cvt = clen;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
......@@ -1397,57 +1300,106 @@ SDL_ConvertAudio(SDL_AudioCVT * cvt)
return (0);
}
/* Creates a set of audio filters to convert from one format to another.
Returns -1 if the format conversion is not supported, or 1 if the
audio filter is set up.
static SDL_AudioFilter
SDL_HandTunedTypeCVT(SDL_AudioFormat src_fmt, SDL_AudioFormat dst_fmt)
{
/*
* Fill in any future conversions that are specialized to a
* processor, platform, compiler, or library here.
*/
return NULL; /* no specialized converter code available. */
}
/*
* Find a converter between two data types. We try to select a hand-tuned
* asm/vectorized/optimized function first, and then fallback to an
* autogenerated function that is customized to convert between two
* specific data types.
*/
static int
SDL_BuildAudioTypeCVT(SDL_AudioCVT * cvt,
SDL_AudioFormat src_fmt, SDL_AudioFormat dst_fmt)
{
if (src_fmt != dst_fmt) {
const Uint16 src_bitsize = SDL_AUDIO_BITSIZE(src_fmt);
const Uint16 dst_bitsize = SDL_AUDIO_BITSIZE(dst_fmt);
SDL_AudioFilter filter = SDL_HandTunedTypeCVT(src_fmt, dst_fmt);
/* No hand-tuned converter? Try the autogenerated ones. */
if (filter == NULL) {
int i;
for (i = 0; sdl_audio_type_filters[i].filter != NULL; i++) {
const SDL_AudioTypeFilters *filt = &sdl_audio_type_filters[i];
if ((filt->src_fmt == src_fmt) && (filt->dst_fmt == dst_fmt)) {
filter = filt->filter;
break;
}
}
if (filter == NULL) {
return -1; /* Still no matching converter?! */
}
}
/* Update (cvt) with filter details... */
cvt->filters[cvt->filter_index++] = filter;
if (src_bitsize < dst_bitsize) {
const int mult = (dst_bitsize / src_bitsize);
cvt->len_mult *= mult;
cvt->len_ratio *= mult;
} else if (src_bitsize > dst_bitsize) {
cvt->len_ratio /= (src_bitsize / dst_bitsize);
}
return 1; /* added a converter. */
}
return 0; /* no conversion necessary. */
}
/* Creates a set of audio filters to convert from one format to another.
Returns -1 if the format conversion is not supported, 0 if there's
no conversion needed, or 1 if the audio filter is set up.
*/
int
SDL_BuildAudioCVT(SDL_AudioCVT * cvt,
Uint16 src_format, Uint8 src_channels, int src_rate,
Uint16 dst_format, Uint8 dst_channels, int dst_rate)
SDL_AudioFormat src_fmt, Uint8 src_channels, int src_rate,
SDL_AudioFormat dst_fmt, Uint8 dst_channels, int dst_rate)
{
/*printf("Build format %04x->%04x, channels %u->%u, rate %d->%d\n",
src_format, dst_format, src_channels, dst_channels, src_rate, dst_rate);*/
/* there are no unsigned types over 16 bits, so catch this upfront. */
if ((SDL_AUDIO_BITSIZE(src_fmt) > 16) && (!SDL_AUDIO_ISSIGNED(src_fmt))) {
return -1;
}
if ((SDL_AUDIO_BITSIZE(dst_fmt) > 16) && (!SDL_AUDIO_ISSIGNED(dst_fmt))) {
return -1;
}
#ifdef DEBUG_CONVERT
printf("Build format %04x->%04x, channels %u->%u, rate %d->%d\n",
src_fmt, dst_fmt, src_channels, dst_channels, src_rate, dst_rate);
#endif
/* Start off with no conversion necessary */
cvt->src_format = src_fmt;
cvt->dst_format = dst_fmt;
cvt->needed = 0;
cvt->filter_index = 0;
cvt->filters[0] = NULL;
cvt->len_mult = 1;
cvt->len_ratio = 1.0;
/* First filter: Endian conversion from src to dst */
if ((src_format & 0x1000) != (dst_format & 0x1000)
&& ((src_format & 0xff) != 8)) {
cvt->filters[cvt->filter_index++] = SDL_ConvertEndian;
}
/* Second filter: Sign conversion -- signed/unsigned */
if ((src_format & 0x8000) != (dst_format & 0x8000)) {
cvt->filters[cvt->filter_index++] = SDL_ConvertSign;
}
/* Next filter: Convert 16 bit <--> 8 bit PCM */
if ((src_format & 0xFF) != (dst_format & 0xFF)) {
switch (dst_format & 0x10FF) {
case AUDIO_U8:
cvt->filters[cvt->filter_index++] = SDL_Convert8;
cvt->len_ratio /= 2;
break;
case AUDIO_U16LSB:
cvt->filters[cvt->filter_index++] = SDL_Convert16LSB;
cvt->len_mult *= 2;
cvt->len_ratio *= 2;
break;
case AUDIO_U16MSB:
cvt->filters[cvt->filter_index++] = SDL_Convert16MSB;
cvt->len_mult *= 2;
cvt->len_ratio *= 2;
break;
}
}
/* Convert data types, if necessary. Updates (cvt). */
if (SDL_BuildAudioTypeCVT(cvt, src_fmt, dst_fmt) == -1)
return -1; /* shouldn't happen, but just in case... */
/* Last filter: Mono/Stereo conversion */
/* Channel conversion */
if (src_channels != dst_channels) {
if ((src_channels == 1) && (dst_channels > 1)) {
cvt->filters[cvt->filter_index++] = SDL_ConvertStereo;
......@@ -1504,7 +1456,7 @@ SDL_BuildAudioCVT(SDL_AudioCVT * cvt,
Uint32 hi_rate, lo_rate;
int len_mult;
double len_ratio;
void (SDLCALL * rate_cvt) (SDL_AudioCVT * cvt, Uint16 format);
SDL_AudioFilter rate_cvt = NULL;
if (src_rate > dst_rate) {
hi_rate = src_rate;
......@@ -1583,8 +1535,8 @@ SDL_BuildAudioCVT(SDL_AudioCVT * cvt,
/* Set up the filter information */
if (cvt->filter_index != 0) {
cvt->needed = 1;
cvt->src_format = src_format;
cvt->dst_format = dst_format;
cvt->src_format = src_fmt;
cvt->dst_format = dst_fmt;
cvt->len = 0;
cvt->buf = NULL;
cvt->filters[cvt->filter_index] = NULL;
......
src/audio/SDL_audiotypecvt.c 0 → 100644
View file @ c500e6c0
/* DO NOT EDIT THIS FILE! It is generated code. */
/* Please modify SDL/src/audio/sdlgenaudiocvt.pl instead. */
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library 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.
This library 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 this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#include "SDL_audio.h"
#include "SDL_audio_c.h"
/* Now the generated code... */
#define DIVBY127 0.0078740157480315f
#define DIVBY255 0.00392156862745098f
#define DIVBY32767 3.05185094759972e-05f
#define DIVBY65535 1.52590218966964e-05f
#define DIVBY2147483647 4.6566128752458e-10f
static void SDLCALL
SDL_Convert_U8_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint8 *src;
Sint8 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S8.\n");
#endif
src = (const Uint8 *) cvt->buf;
dst = (Sint8 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint8); i; --i, ++src, ++dst) {
const Sint8 val = ((*src) ^ 0x80);
*dst = ((Sint8) val);
}
format = AUDIO_S8;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U8_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint8 *src;
Uint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U8 to AUDIO_U16LSB.\n");
#endif
src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
dst = (Uint16 *) (cvt->buf + cvt->len_cvt * 2);
for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
const Uint16 val = (((Uint16) *src) << 8);
*dst = SDL_SwapLE16(val);
}
cvt->len_cvt *= 2;
format = AUDIO_U16LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U8_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint8 *src;
Sint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S16LSB.\n");
#endif
src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
dst = (Sint16 *) (cvt->buf + cvt->len_cvt * 2);
for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
const Sint16 val = (((Sint16) ((*src) ^ 0x80)) << 8);
*dst = ((Sint16) SDL_SwapLE16(val));
}
cvt->len_cvt *= 2;
format = AUDIO_S16LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U8_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint8 *src;
Uint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U8 to AUDIO_U16MSB.\n");
#endif
src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
dst = (Uint16 *) (cvt->buf + cvt->len_cvt * 2);
for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
const Uint16 val = (((Uint16) *src) << 8);
*dst = SDL_SwapBE16(val);
}
cvt->len_cvt *= 2;
format = AUDIO_U16MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U8_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint8 *src;
Sint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S16MSB.\n");
#endif
src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
dst = (Sint16 *) (cvt->buf + cvt->len_cvt * 2);
for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
const Sint16 val = (((Sint16) ((*src) ^ 0x80)) << 8);
*dst = ((Sint16) SDL_SwapBE16(val));
}
cvt->len_cvt *= 2;
format = AUDIO_S16MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U8_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint8 *src;
Sint32 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S32LSB.\n");
#endif
src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 4);
for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
const Sint32 val = (((Sint32) ((*src) ^ 0x80)) << 24);
*dst = ((Sint32) SDL_SwapLE32(val));
}
cvt->len_cvt *= 4;
format = AUDIO_S32LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U8_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint8 *src;
Sint32 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S32MSB.\n");
#endif
src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 4);
for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
const Sint32 val = (((Sint32) ((*src) ^ 0x80)) << 24);
*dst = ((Sint32) SDL_SwapBE32(val));
}
cvt->len_cvt *= 4;
format = AUDIO_S32MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U8_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint8 *src;
float *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U8 to AUDIO_F32LSB.\n");
#endif
src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
dst = (float *) (cvt->buf + cvt->len_cvt * 4);
for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
const float val = (((float) *src) * DIVBY255);
*dst = SDL_SwapFloatLE(val);
}
cvt->len_cvt *= 4;
format = AUDIO_F32LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U8_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint8 *src;
float *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U8 to AUDIO_F32MSB.\n");
#endif
src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
dst = (float *) (cvt->buf + cvt->len_cvt * 4);
for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
const float val = (((float) *src) * DIVBY255);
*dst = SDL_SwapFloatBE(val);
}
cvt->len_cvt *= 4;
format = AUDIO_F32MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S8_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint8 *src;
Uint8 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S8 to AUDIO_U8.\n");
#endif
src = (const Uint8 *) cvt->buf;
dst = (Uint8 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint8); i; --i, ++src, ++dst) {
const Uint8 val = ((((Sint8) *src)) ^ 0x80);
*dst = val;
}
format = AUDIO_U8;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S8_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint8 *src;
Uint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S8 to AUDIO_U16LSB.\n");
#endif
src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
dst = (Uint16 *) (cvt->buf + cvt->len_cvt * 2);
for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
const Uint16 val = (((Uint16) ((((Sint8) *src)) ^ 0x80)) << 8);
*dst = SDL_SwapLE16(val);
}
cvt->len_cvt *= 2;
format = AUDIO_U16LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S8_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint8 *src;
Sint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S8 to AUDIO_S16LSB.\n");
#endif
src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
dst = (Sint16 *) (cvt->buf + cvt->len_cvt * 2);
for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
const Sint16 val = (((Sint16) ((Sint8) *src)) << 8);
*dst = ((Sint16) SDL_SwapLE16(val));
}
cvt->len_cvt *= 2;
format = AUDIO_S16LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S8_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint8 *src;
Uint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S8 to AUDIO_U16MSB.\n");
#endif
src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
dst = (Uint16 *) (cvt->buf + cvt->len_cvt * 2);
for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
const Uint16 val = (((Uint16) ((((Sint8) *src)) ^ 0x80)) << 8);
*dst = SDL_SwapBE16(val);
}
cvt->len_cvt *= 2;
format = AUDIO_U16MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S8_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint8 *src;
Sint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S8 to AUDIO_S16MSB.\n");
#endif
src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
dst = (Sint16 *) (cvt->buf + cvt->len_cvt * 2);
for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
const Sint16 val = (((Sint16) ((Sint8) *src)) << 8);
*dst = ((Sint16) SDL_SwapBE16(val));
}
cvt->len_cvt *= 2;
format = AUDIO_S16MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S8_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint8 *src;
Sint32 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S8 to AUDIO_S32LSB.\n");
#endif
src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 4);
for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
const Sint32 val = (((Sint32) ((Sint8) *src)) << 24);
*dst = ((Sint32) SDL_SwapLE32(val));
}
cvt->len_cvt *= 4;
format = AUDIO_S32LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S8_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint8 *src;
Sint32 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S8 to AUDIO_S32MSB.\n");
#endif
src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 4);
for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
const Sint32 val = (((Sint32) ((Sint8) *src)) << 24);
*dst = ((Sint32) SDL_SwapBE32(val));
}
cvt->len_cvt *= 4;
format = AUDIO_S32MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S8_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint8 *src;
float *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S8 to AUDIO_F32LSB.\n");
#endif
src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
dst = (float *) (cvt->buf + cvt->len_cvt * 4);
for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
const float val = (((float) ((Sint8) *src)) * DIVBY127);
*dst = SDL_SwapFloatLE(val);
}
cvt->len_cvt *= 4;
format = AUDIO_F32LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S8_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint8 *src;
float *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S8 to AUDIO_F32MSB.\n");
#endif
src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
dst = (float *) (cvt->buf + cvt->len_cvt * 4);
for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
const float val = (((float) ((Sint8) *src)) * DIVBY127);
*dst = SDL_SwapFloatBE(val);
}
cvt->len_cvt *= 4;
format = AUDIO_F32MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U16LSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Uint8 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_U8.\n");
#endif
src = (const Uint16 *) cvt->buf;
dst = (Uint8 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
const Uint8 val = ((Uint8) (SDL_SwapLE16(*src) >> 8));
*dst = val;
}
cvt->len_cvt /= 2;
format = AUDIO_U8;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U16LSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Sint8 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S8.\n");
#endif
src = (const Uint16 *) cvt->buf;
dst = (Sint8 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
const Sint8 val = ((Sint8) (((SDL_SwapLE16(*src)) ^ 0x8000) >> 8));
*dst = ((Sint8) val);
}
cvt->len_cvt /= 2;
format = AUDIO_S8;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U16LSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Sint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S16LSB.\n");
#endif
src = (const Uint16 *) cvt->buf;
dst = (Sint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
const Sint16 val = ((SDL_SwapLE16(*src)) ^ 0x8000);
*dst = ((Sint16) SDL_SwapLE16(val));
}
format = AUDIO_S16LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U16LSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Uint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_U16MSB.\n");
#endif
src = (const Uint16 *) cvt->buf;
dst = (Uint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
const Uint16 val = SDL_SwapLE16(*src);
*dst = SDL_SwapBE16(val);
}
format = AUDIO_U16MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U16LSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Sint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S16MSB.\n");
#endif
src = (const Uint16 *) cvt->buf;
dst = (Sint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
const Sint16 val = ((SDL_SwapLE16(*src)) ^ 0x8000);
*dst = ((Sint16) SDL_SwapBE16(val));
}
format = AUDIO_S16MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U16LSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Sint32 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S32LSB.\n");
#endif
src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
const Sint32 val = (((Sint32) ((SDL_SwapLE16(*src)) ^ 0x8000)) << 16);
*dst = ((Sint32) SDL_SwapLE32(val));
}
cvt->len_cvt *= 2;
format = AUDIO_S32LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U16LSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Sint32 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S32MSB.\n");
#endif
src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
const Sint32 val = (((Sint32) ((SDL_SwapLE16(*src)) ^ 0x8000)) << 16);
*dst = ((Sint32) SDL_SwapBE32(val));
}
cvt->len_cvt *= 2;
format = AUDIO_S32MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U16LSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
float *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_F32LSB.\n");
#endif
src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
dst = (float *) (cvt->buf + cvt->len_cvt * 2);
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
const float val = (((float) SDL_SwapLE16(*src)) * DIVBY65535);
*dst = SDL_SwapFloatLE(val);
}
cvt->len_cvt *= 2;
format = AUDIO_F32LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U16LSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
float *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_F32MSB.\n");
#endif
src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
dst = (float *) (cvt->buf + cvt->len_cvt * 2);
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
const float val = (((float) SDL_SwapLE16(*src)) * DIVBY65535);
*dst = SDL_SwapFloatBE(val);
}
cvt->len_cvt *= 2;
format = AUDIO_F32MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S16LSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Uint8 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_U8.\n");
#endif
src = (const Uint16 *) cvt->buf;
dst = (Uint8 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
const Uint8 val = ((Uint8) (((((Sint16) SDL_SwapLE16(*src))) ^ 0x8000) >> 8));
*dst = val;
}
cvt->len_cvt /= 2;
format = AUDIO_U8;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S16LSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Sint8 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_S8.\n");
#endif
src = (const Uint16 *) cvt->buf;
dst = (Sint8 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
const Sint8 val = ((Sint8) (((Sint16) SDL_SwapLE16(*src)) >> 8));
*dst = ((Sint8) val);
}
cvt->len_cvt /= 2;
format = AUDIO_S8;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S16LSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Uint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_U16LSB.\n");
#endif
src = (const Uint16 *) cvt->buf;
dst = (Uint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
const Uint16 val = ((((Sint16) SDL_SwapLE16(*src))) ^ 0x8000);
*dst = SDL_SwapLE16(val);
}
format = AUDIO_U16LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S16LSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Uint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_U16MSB.\n");
#endif
src = (const Uint16 *) cvt->buf;
dst = (Uint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
const Uint16 val = ((((Sint16) SDL_SwapLE16(*src))) ^ 0x8000);
*dst = SDL_SwapBE16(val);
}
format = AUDIO_U16MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S16LSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Sint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_S16MSB.\n");
#endif
src = (const Uint16 *) cvt->buf;
dst = (Sint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
const Sint16 val = ((Sint16) SDL_SwapLE16(*src));
*dst = ((Sint16) SDL_SwapBE16(val));
}
format = AUDIO_S16MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S16LSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Sint32 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_S32LSB.\n");
#endif
src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
const Sint32 val = (((Sint32) ((Sint16) SDL_SwapLE16(*src))) << 16);
*dst = ((Sint32) SDL_SwapLE32(val));
}
cvt->len_cvt *= 2;
format = AUDIO_S32LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S16LSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Sint32 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_S32MSB.\n");
#endif
src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
const Sint32 val = (((Sint32) ((Sint16) SDL_SwapLE16(*src))) << 16);
*dst = ((Sint32) SDL_SwapBE32(val));
}
cvt->len_cvt *= 2;
format = AUDIO_S32MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S16LSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
float *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_F32LSB.\n");
#endif
src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
dst = (float *) (cvt->buf + cvt->len_cvt * 2);
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
const float val = (((float) ((Sint16) SDL_SwapLE16(*src))) * DIVBY32767);
*dst = SDL_SwapFloatLE(val);
}
cvt->len_cvt *= 2;
format = AUDIO_F32LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S16LSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
float *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_F32MSB.\n");
#endif
src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
dst = (float *) (cvt->buf + cvt->len_cvt * 2);
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
const float val = (((float) ((Sint16) SDL_SwapLE16(*src))) * DIVBY32767);
*dst = SDL_SwapFloatBE(val);
}
cvt->len_cvt *= 2;
format = AUDIO_F32MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U16MSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Uint8 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_U8.\n");
#endif
src = (const Uint16 *) cvt->buf;
dst = (Uint8 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
const Uint8 val = ((Uint8) (SDL_SwapBE16(*src) >> 8));
*dst = val;
}
cvt->len_cvt /= 2;
format = AUDIO_U8;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U16MSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Sint8 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S8.\n");
#endif
src = (const Uint16 *) cvt->buf;
dst = (Sint8 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
const Sint8 val = ((Sint8) (((SDL_SwapBE16(*src)) ^ 0x8000) >> 8));
*dst = ((Sint8) val);
}
cvt->len_cvt /= 2;
format = AUDIO_S8;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U16MSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Uint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_U16LSB.\n");
#endif
src = (const Uint16 *) cvt->buf;
dst = (Uint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
const Uint16 val = SDL_SwapBE16(*src);
*dst = SDL_SwapLE16(val);
}
format = AUDIO_U16LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U16MSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Sint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S16LSB.\n");
#endif
src = (const Uint16 *) cvt->buf;
dst = (Sint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
const Sint16 val = ((SDL_SwapBE16(*src)) ^ 0x8000);
*dst = ((Sint16) SDL_SwapLE16(val));
}
format = AUDIO_S16LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U16MSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Sint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S16MSB.\n");
#endif
src = (const Uint16 *) cvt->buf;
dst = (Sint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
const Sint16 val = ((SDL_SwapBE16(*src)) ^ 0x8000);
*dst = ((Sint16) SDL_SwapBE16(val));
}
format = AUDIO_S16MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U16MSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Sint32 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S32LSB.\n");
#endif
src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
const Sint32 val = (((Sint32) ((SDL_SwapBE16(*src)) ^ 0x8000)) << 16);
*dst = ((Sint32) SDL_SwapLE32(val));
}
cvt->len_cvt *= 2;
format = AUDIO_S32LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U16MSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Sint32 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S32MSB.\n");
#endif
src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
const Sint32 val = (((Sint32) ((SDL_SwapBE16(*src)) ^ 0x8000)) << 16);
*dst = ((Sint32) SDL_SwapBE32(val));
}
cvt->len_cvt *= 2;
format = AUDIO_S32MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U16MSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
float *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_F32LSB.\n");
#endif
src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
dst = (float *) (cvt->buf + cvt->len_cvt * 2);
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
const float val = (((float) SDL_SwapBE16(*src)) * DIVBY65535);
*dst = SDL_SwapFloatLE(val);
}
cvt->len_cvt *= 2;
format = AUDIO_F32LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_U16MSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
float *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_F32MSB.\n");
#endif
src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
dst = (float *) (cvt->buf + cvt->len_cvt * 2);
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
const float val = (((float) SDL_SwapBE16(*src)) * DIVBY65535);
*dst = SDL_SwapFloatBE(val);
}
cvt->len_cvt *= 2;
format = AUDIO_F32MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S16MSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Uint8 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_U8.\n");
#endif
src = (const Uint16 *) cvt->buf;
dst = (Uint8 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
const Uint8 val = ((Uint8) (((((Sint16) SDL_SwapBE16(*src))) ^ 0x8000) >> 8));
*dst = val;
}
cvt->len_cvt /= 2;
format = AUDIO_U8;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S16MSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Sint8 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_S8.\n");
#endif
src = (const Uint16 *) cvt->buf;
dst = (Sint8 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
const Sint8 val = ((Sint8) (((Sint16) SDL_SwapBE16(*src)) >> 8));
*dst = ((Sint8) val);
}
cvt->len_cvt /= 2;
format = AUDIO_S8;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S16MSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Uint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_U16LSB.\n");
#endif
src = (const Uint16 *) cvt->buf;
dst = (Uint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
const Uint16 val = ((((Sint16) SDL_SwapBE16(*src))) ^ 0x8000);
*dst = SDL_SwapLE16(val);
}
format = AUDIO_U16LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S16MSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Sint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_S16LSB.\n");
#endif
src = (const Uint16 *) cvt->buf;
dst = (Sint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
const Sint16 val = ((Sint16) SDL_SwapBE16(*src));
*dst = ((Sint16) SDL_SwapLE16(val));
}
format = AUDIO_S16LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S16MSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Uint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_U16MSB.\n");
#endif
src = (const Uint16 *) cvt->buf;
dst = (Uint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
const Uint16 val = ((((Sint16) SDL_SwapBE16(*src))) ^ 0x8000);
*dst = SDL_SwapBE16(val);
}
format = AUDIO_U16MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S16MSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Sint32 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_S32LSB.\n");
#endif
src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
const Sint32 val = (((Sint32) ((Sint16) SDL_SwapBE16(*src))) << 16);
*dst = ((Sint32) SDL_SwapLE32(val));
}
cvt->len_cvt *= 2;
format = AUDIO_S32LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S16MSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
Sint32 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_S32MSB.\n");
#endif
src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
const Sint32 val = (((Sint32) ((Sint16) SDL_SwapBE16(*src))) << 16);
*dst = ((Sint32) SDL_SwapBE32(val));
}
cvt->len_cvt *= 2;
format = AUDIO_S32MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S16MSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
float *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_F32LSB.\n");
#endif
src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
dst = (float *) (cvt->buf + cvt->len_cvt * 2);
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
const float val = (((float) ((Sint16) SDL_SwapBE16(*src))) * DIVBY32767);
*dst = SDL_SwapFloatLE(val);
}
cvt->len_cvt *= 2;
format = AUDIO_F32LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S16MSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint16 *src;
float *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_F32MSB.\n");
#endif
src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
dst = (float *) (cvt->buf + cvt->len_cvt * 2);
for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
const float val = (((float) ((Sint16) SDL_SwapBE16(*src))) * DIVBY32767);
*dst = SDL_SwapFloatBE(val);
}
cvt->len_cvt *= 2;
format = AUDIO_F32MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S32LSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint32 *src;
Uint8 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_U8.\n");
#endif
src = (const Uint32 *) cvt->buf;
dst = (Uint8 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
const Uint8 val = ((Uint8) (((((Sint32) SDL_SwapLE32(*src))) ^ 0x80000000) >> 24));
*dst = val;
}
cvt->len_cvt /= 4;
format = AUDIO_U8;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S32LSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint32 *src;
Sint8 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_S8.\n");
#endif
src = (const Uint32 *) cvt->buf;
dst = (Sint8 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
const Sint8 val = ((Sint8) (((Sint32) SDL_SwapLE32(*src)) >> 24));
*dst = ((Sint8) val);
}
cvt->len_cvt /= 4;
format = AUDIO_S8;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S32LSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint32 *src;
Uint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_U16LSB.\n");
#endif
src = (const Uint32 *) cvt->buf;
dst = (Uint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
const Uint16 val = ((Uint16) (((((Sint32) SDL_SwapLE32(*src))) ^ 0x80000000) >> 16));
*dst = SDL_SwapLE16(val);
}
cvt->len_cvt /= 2;
format = AUDIO_U16LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S32LSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint32 *src;
Sint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_S16LSB.\n");
#endif
src = (const Uint32 *) cvt->buf;
dst = (Sint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
const Sint16 val = ((Sint16) (((Sint32) SDL_SwapLE32(*src)) >> 16));
*dst = ((Sint16) SDL_SwapLE16(val));
}
cvt->len_cvt /= 2;
format = AUDIO_S16LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S32LSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint32 *src;
Uint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_U16MSB.\n");
#endif
src = (const Uint32 *) cvt->buf;
dst = (Uint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
const Uint16 val = ((Uint16) (((((Sint32) SDL_SwapLE32(*src))) ^ 0x80000000) >> 16));
*dst = SDL_SwapBE16(val);
}
cvt->len_cvt /= 2;
format = AUDIO_U16MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S32LSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint32 *src;
Sint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_S16MSB.\n");
#endif
src = (const Uint32 *) cvt->buf;
dst = (Sint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
const Sint16 val = ((Sint16) (((Sint32) SDL_SwapLE32(*src)) >> 16));
*dst = ((Sint16) SDL_SwapBE16(val));
}
cvt->len_cvt /= 2;
format = AUDIO_S16MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S32LSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint32 *src;
Sint32 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_S32MSB.\n");
#endif
src = (const Uint32 *) cvt->buf;
dst = (Sint32 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
const Sint32 val = ((Sint32) SDL_SwapLE32(*src));
*dst = ((Sint32) SDL_SwapBE32(val));
}
format = AUDIO_S32MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S32LSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint32 *src;
float *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_F32LSB.\n");
#endif
src = (const Uint32 *) cvt->buf;
dst = (float *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
const float val = (((float) ((Sint32) SDL_SwapLE32(*src))) * DIVBY2147483647);
*dst = SDL_SwapFloatLE(val);
}
format = AUDIO_F32LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S32LSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint32 *src;
float *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_F32MSB.\n");
#endif
src = (const Uint32 *) cvt->buf;
dst = (float *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
const float val = (((float) ((Sint32) SDL_SwapLE32(*src))) * DIVBY2147483647);
*dst = SDL_SwapFloatBE(val);
}
format = AUDIO_F32MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S32MSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint32 *src;
Uint8 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_U8.\n");
#endif
src = (const Uint32 *) cvt->buf;
dst = (Uint8 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
const Uint8 val = ((Uint8) (((((Sint32) SDL_SwapBE32(*src))) ^ 0x80000000) >> 24));
*dst = val;
}
cvt->len_cvt /= 4;
format = AUDIO_U8;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S32MSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint32 *src;
Sint8 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_S8.\n");
#endif
src = (const Uint32 *) cvt->buf;
dst = (Sint8 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
const Sint8 val = ((Sint8) (((Sint32) SDL_SwapBE32(*src)) >> 24));
*dst = ((Sint8) val);
}
cvt->len_cvt /= 4;
format = AUDIO_S8;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S32MSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint32 *src;
Uint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_U16LSB.\n");
#endif
src = (const Uint32 *) cvt->buf;
dst = (Uint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
const Uint16 val = ((Uint16) (((((Sint32) SDL_SwapBE32(*src))) ^ 0x80000000) >> 16));
*dst = SDL_SwapLE16(val);
}
cvt->len_cvt /= 2;
format = AUDIO_U16LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S32MSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint32 *src;
Sint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_S16LSB.\n");
#endif
src = (const Uint32 *) cvt->buf;
dst = (Sint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
const Sint16 val = ((Sint16) (((Sint32) SDL_SwapBE32(*src)) >> 16));
*dst = ((Sint16) SDL_SwapLE16(val));
}
cvt->len_cvt /= 2;
format = AUDIO_S16LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S32MSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint32 *src;
Uint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_U16MSB.\n");
#endif
src = (const Uint32 *) cvt->buf;
dst = (Uint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
const Uint16 val = ((Uint16) (((((Sint32) SDL_SwapBE32(*src))) ^ 0x80000000) >> 16));
*dst = SDL_SwapBE16(val);
}
cvt->len_cvt /= 2;
format = AUDIO_U16MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S32MSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint32 *src;
Sint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_S16MSB.\n");
#endif
src = (const Uint32 *) cvt->buf;
dst = (Sint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
const Sint16 val = ((Sint16) (((Sint32) SDL_SwapBE32(*src)) >> 16));
*dst = ((Sint16) SDL_SwapBE16(val));
}
cvt->len_cvt /= 2;
format = AUDIO_S16MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S32MSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint32 *src;
Sint32 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_S32LSB.\n");
#endif
src = (const Uint32 *) cvt->buf;
dst = (Sint32 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
const Sint32 val = ((Sint32) SDL_SwapBE32(*src));
*dst = ((Sint32) SDL_SwapLE32(val));
}
format = AUDIO_S32LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S32MSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint32 *src;
float *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_F32LSB.\n");
#endif
src = (const Uint32 *) cvt->buf;
dst = (float *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
const float val = (((float) ((Sint32) SDL_SwapBE32(*src))) * DIVBY2147483647);
*dst = SDL_SwapFloatLE(val);
}
format = AUDIO_F32LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_S32MSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const Uint32 *src;
float *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_F32MSB.\n");
#endif
src = (const Uint32 *) cvt->buf;
dst = (float *) cvt->buf;
for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
const float val = (((float) ((Sint32) SDL_SwapBE32(*src))) * DIVBY2147483647);
*dst = SDL_SwapFloatBE(val);
}
format = AUDIO_F32MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_F32LSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const float *src;
Uint8 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_U8.\n");
#endif
src = (const float *) cvt->buf;
dst = (Uint8 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
const Uint8 val = ((Uint8) (SDL_SwapFloatLE(*src) * 255.0f));
*dst = val;
}
cvt->len_cvt /= 4;
format = AUDIO_U8;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_F32LSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const float *src;
Sint8 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_S8.\n");
#endif
src = (const float *) cvt->buf;
dst = (Sint8 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
const Sint8 val = ((Sint8) (SDL_SwapFloatLE(*src) * 127.0f));
*dst = ((Sint8) val);
}
cvt->len_cvt /= 4;
format = AUDIO_S8;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_F32LSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const float *src;
Uint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_U16LSB.\n");
#endif
src = (const float *) cvt->buf;
dst = (Uint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
const Uint16 val = ((Uint16) (SDL_SwapFloatLE(*src) * 65535.0f));
*dst = SDL_SwapLE16(val);
}
cvt->len_cvt /= 2;
format = AUDIO_U16LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_F32LSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const float *src;
Sint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_S16LSB.\n");
#endif
src = (const float *) cvt->buf;
dst = (Sint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
const Sint16 val = ((Sint16) (SDL_SwapFloatLE(*src) * 32767.0f));
*dst = ((Sint16) SDL_SwapLE16(val));
}
cvt->len_cvt /= 2;
format = AUDIO_S16LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_F32LSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const float *src;
Uint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_U16MSB.\n");
#endif
src = (const float *) cvt->buf;
dst = (Uint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
const Uint16 val = ((Uint16) (SDL_SwapFloatLE(*src) * 65535.0f));
*dst = SDL_SwapBE16(val);
}
cvt->len_cvt /= 2;
format = AUDIO_U16MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_F32LSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const float *src;
Sint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_S16MSB.\n");
#endif
src = (const float *) cvt->buf;
dst = (Sint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
const Sint16 val = ((Sint16) (SDL_SwapFloatLE(*src) * 32767.0f));
*dst = ((Sint16) SDL_SwapBE16(val));
}
cvt->len_cvt /= 2;
format = AUDIO_S16MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_F32LSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const float *src;
Sint32 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_S32LSB.\n");
#endif
src = (const float *) cvt->buf;
dst = (Sint32 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
const Sint32 val = ((Sint32) (SDL_SwapFloatLE(*src) * 2147483647.0));
*dst = ((Sint32) SDL_SwapLE32(val));
}
format = AUDIO_S32LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_F32LSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const float *src;
Sint32 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_S32MSB.\n");
#endif
src = (const float *) cvt->buf;
dst = (Sint32 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
const Sint32 val = ((Sint32) (SDL_SwapFloatLE(*src) * 2147483647.0));
*dst = ((Sint32) SDL_SwapBE32(val));
}
format = AUDIO_S32MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_F32LSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const float *src;
float *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_F32MSB.\n");
#endif
src = (const float *) cvt->buf;
dst = (float *) cvt->buf;
for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
const float val = SDL_SwapFloatLE(*src);
*dst = SDL_SwapFloatBE(val);
}
format = AUDIO_F32MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_F32MSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const float *src;
Uint8 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_U8.\n");
#endif
src = (const float *) cvt->buf;
dst = (Uint8 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
const Uint8 val = ((Uint8) (SDL_SwapFloatBE(*src) * 255.0f));
*dst = val;
}
cvt->len_cvt /= 4;
format = AUDIO_U8;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_F32MSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const float *src;
Sint8 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_S8.\n");
#endif
src = (const float *) cvt->buf;
dst = (Sint8 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
const Sint8 val = ((Sint8) (SDL_SwapFloatBE(*src) * 127.0f));
*dst = ((Sint8) val);
}
cvt->len_cvt /= 4;
format = AUDIO_S8;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_F32MSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const float *src;
Uint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_U16LSB.\n");
#endif
src = (const float *) cvt->buf;
dst = (Uint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
const Uint16 val = ((Uint16) (SDL_SwapFloatBE(*src) * 65535.0f));
*dst = SDL_SwapLE16(val);
}
cvt->len_cvt /= 2;
format = AUDIO_U16LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_F32MSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const float *src;
Sint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_S16LSB.\n");
#endif
src = (const float *) cvt->buf;
dst = (Sint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
const Sint16 val = ((Sint16) (SDL_SwapFloatBE(*src) * 32767.0f));
*dst = ((Sint16) SDL_SwapLE16(val));
}
cvt->len_cvt /= 2;
format = AUDIO_S16LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_F32MSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const float *src;
Uint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_U16MSB.\n");
#endif
src = (const float *) cvt->buf;
dst = (Uint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
const Uint16 val = ((Uint16) (SDL_SwapFloatBE(*src) * 65535.0f));
*dst = SDL_SwapBE16(val);
}
cvt->len_cvt /= 2;
format = AUDIO_U16MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_F32MSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const float *src;
Sint16 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_S16MSB.\n");
#endif
src = (const float *) cvt->buf;
dst = (Sint16 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
const Sint16 val = ((Sint16) (SDL_SwapFloatBE(*src) * 32767.0f));
*dst = ((Sint16) SDL_SwapBE16(val));
}
cvt->len_cvt /= 2;
format = AUDIO_S16MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_F32MSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const float *src;
Sint32 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_S32LSB.\n");
#endif
src = (const float *) cvt->buf;
dst = (Sint32 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
const Sint32 val = ((Sint32) (SDL_SwapFloatBE(*src) * 2147483647.0));
*dst = ((Sint32) SDL_SwapLE32(val));
}
format = AUDIO_S32LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_F32MSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const float *src;
Sint32 *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_S32MSB.\n");
#endif
src = (const float *) cvt->buf;
dst = (Sint32 *) cvt->buf;
for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
const Sint32 val = ((Sint32) (SDL_SwapFloatBE(*src) * 2147483647.0));
*dst = ((Sint32) SDL_SwapBE32(val));
}
format = AUDIO_S32MSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
static void SDLCALL
SDL_Convert_F32MSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const float *src;
float *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_F32LSB.\n");
#endif
src = (const float *) cvt->buf;
dst = (float *) cvt->buf;
for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
const float val = SDL_SwapFloatBE(*src);
*dst = SDL_SwapFloatLE(val);
}
format = AUDIO_F32LSB;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
const SDL_AudioTypeFilters sdl_audio_type_filters[] =
{
{ AUDIO_U8, AUDIO_S8, SDL_Convert_U8_to_S8 },
{ AUDIO_U8, AUDIO_U16LSB, SDL_Convert_U8_to_U16LSB },
{ AUDIO_U8, AUDIO_S16LSB, SDL_Convert_U8_to_S16LSB },
{ AUDIO_U8, AUDIO_U16MSB, SDL_Convert_U8_to_U16MSB },
{ AUDIO_U8, AUDIO_S16MSB, SDL_Convert_U8_to_S16MSB },
{ AUDIO_U8, AUDIO_S32LSB, SDL_Convert_U8_to_S32LSB },
{ AUDIO_U8, AUDIO_S32MSB, SDL_Convert_U8_to_S32MSB },
{ AUDIO_U8, AUDIO_F32LSB, SDL_Convert_U8_to_F32LSB },
{ AUDIO_U8, AUDIO_F32MSB, SDL_Convert_U8_to_F32MSB },
{ AUDIO_S8, AUDIO_U8, SDL_Convert_S8_to_U8 },
{ AUDIO_S8, AUDIO_U16LSB, SDL_Convert_S8_to_U16LSB },
{ AUDIO_S8, AUDIO_S16LSB, SDL_Convert_S8_to_S16LSB },
{ AUDIO_S8, AUDIO_U16MSB, SDL_Convert_S8_to_U16MSB },
{ AUDIO_S8, AUDIO_S16MSB, SDL_Convert_S8_to_S16MSB },
{ AUDIO_S8, AUDIO_S32LSB, SDL_Convert_S8_to_S32LSB },
{ AUDIO_S8, AUDIO_S32MSB, SDL_Convert_S8_to_S32MSB },
{ AUDIO_S8, AUDIO_F32LSB, SDL_Convert_S8_to_F32LSB },
{ AUDIO_S8, AUDIO_F32MSB, SDL_Convert_S8_to_F32MSB },
{ AUDIO_U16LSB, AUDIO_U8, SDL_Convert_U16LSB_to_U8 },
{ AUDIO_U16LSB, AUDIO_S8, SDL_Convert_U16LSB_to_S8 },
{ AUDIO_U16LSB, AUDIO_S16LSB, SDL_Convert_U16LSB_to_S16LSB },
{ AUDIO_U16LSB, AUDIO_U16MSB, SDL_Convert_U16LSB_to_U16MSB },
{ AUDIO_U16LSB, AUDIO_S16MSB, SDL_Convert_U16LSB_to_S16MSB },
{ AUDIO_U16LSB, AUDIO_S32LSB, SDL_Convert_U16LSB_to_S32LSB },
{ AUDIO_U16LSB, AUDIO_S32MSB, SDL_Convert_U16LSB_to_S32MSB },
{ AUDIO_U16LSB, AUDIO_F32LSB, SDL_Convert_U16LSB_to_F32LSB },
{ AUDIO_U16LSB, AUDIO_F32MSB, SDL_Convert_U16LSB_to_F32MSB },
{ AUDIO_S16LSB, AUDIO_U8, SDL_Convert_S16LSB_to_U8 },
{ AUDIO_S16LSB, AUDIO_S8, SDL_Convert_S16LSB_to_S8 },
{ AUDIO_S16LSB, AUDIO_U16LSB, SDL_Convert_S16LSB_to_U16LSB },
{ AUDIO_S16LSB, AUDIO_U16MSB, SDL_Convert_S16LSB_to_U16MSB },
{ AUDIO_S16LSB, AUDIO_S16MSB, SDL_Convert_S16LSB_to_S16MSB },
{ AUDIO_S16LSB, AUDIO_S32LSB, SDL_Convert_S16LSB_to_S32LSB },
{ AUDIO_S16LSB, AUDIO_S32MSB, SDL_Convert_S16LSB_to_S32MSB },
{ AUDIO_S16LSB, AUDIO_F32LSB, SDL_Convert_S16LSB_to_F32LSB },
{ AUDIO_S16LSB, AUDIO_F32MSB, SDL_Convert_S16LSB_to_F32MSB },
{ AUDIO_U16MSB, AUDIO_U8, SDL_Convert_U16MSB_to_U8 },
{ AUDIO_U16MSB, AUDIO_S8, SDL_Convert_U16MSB_to_S8 },
{ AUDIO_U16MSB, AUDIO_U16LSB, SDL_Convert_U16MSB_to_U16LSB },
{ AUDIO_U16MSB, AUDIO_S16LSB, SDL_Convert_U16MSB_to_S16LSB },
{ AUDIO_U16MSB, AUDIO_S16MSB, SDL_Convert_U16MSB_to_S16MSB },
{ AUDIO_U16MSB, AUDIO_S32LSB, SDL_Convert_U16MSB_to_S32LSB },
{ AUDIO_U16MSB, AUDIO_S32MSB, SDL_Convert_U16MSB_to_S32MSB },
{ AUDIO_U16MSB, AUDIO_F32LSB, SDL_Convert_U16MSB_to_F32LSB },
{ AUDIO_U16MSB, AUDIO_F32MSB, SDL_Convert_U16MSB_to_F32MSB },
{ AUDIO_S16MSB, AUDIO_U8, SDL_Convert_S16MSB_to_U8 },
{ AUDIO_S16MSB, AUDIO_S8, SDL_Convert_S16MSB_to_S8 },
{ AUDIO_S16MSB, AUDIO_U16LSB, SDL_Convert_S16MSB_to_U16LSB },
{ AUDIO_S16MSB, AUDIO_S16LSB, SDL_Convert_S16MSB_to_S16LSB },
{ AUDIO_S16MSB, AUDIO_U16MSB, SDL_Convert_S16MSB_to_U16MSB },
{ AUDIO_S16MSB, AUDIO_S32LSB, SDL_Convert_S16MSB_to_S32LSB },
{ AUDIO_S16MSB, AUDIO_S32MSB, SDL_Convert_S16MSB_to_S32MSB },
{ AUDIO_S16MSB, AUDIO_F32LSB, SDL_Convert_S16MSB_to_F32LSB },
{ AUDIO_S16MSB, AUDIO_F32MSB, SDL_Convert_S16MSB_to_F32MSB },
{ AUDIO_S32LSB, AUDIO_U8, SDL_Convert_S32LSB_to_U8 },
{ AUDIO_S32LSB, AUDIO_S8, SDL_Convert_S32LSB_to_S8 },
{ AUDIO_S32LSB, AUDIO_U16LSB, SDL_Convert_S32LSB_to_U16LSB },
{ AUDIO_S32LSB, AUDIO_S16LSB, SDL_Convert_S32LSB_to_S16LSB },
{ AUDIO_S32LSB, AUDIO_U16MSB, SDL_Convert_S32LSB_to_U16MSB },
{ AUDIO_S32LSB, AUDIO_S16MSB, SDL_Convert_S32LSB_to_S16MSB },
{ AUDIO_S32LSB, AUDIO_S32MSB, SDL_Convert_S32LSB_to_S32MSB },
{ AUDIO_S32LSB, AUDIO_F32LSB, SDL_Convert_S32LSB_to_F32LSB },
{ AUDIO_S32LSB, AUDIO_F32MSB, SDL_Convert_S32LSB_to_F32MSB },
{ AUDIO_S32MSB, AUDIO_U8, SDL_Convert_S32MSB_to_U8 },
{ AUDIO_S32MSB, AUDIO_S8, SDL_Convert_S32MSB_to_S8 },
{ AUDIO_S32MSB, AUDIO_U16LSB, SDL_Convert_S32MSB_to_U16LSB },
{ AUDIO_S32MSB, AUDIO_S16LSB, SDL_Convert_S32MSB_to_S16LSB },
{ AUDIO_S32MSB, AUDIO_U16MSB, SDL_Convert_S32MSB_to_U16MSB },
{ AUDIO_S32MSB, AUDIO_S16MSB, SDL_Convert_S32MSB_to_S16MSB },
{ AUDIO_S32MSB, AUDIO_S32LSB, SDL_Convert_S32MSB_to_S32LSB },
{ AUDIO_S32MSB, AUDIO_F32LSB, SDL_Convert_S32MSB_to_F32LSB },
{ AUDIO_S32MSB, AUDIO_F32MSB, SDL_Convert_S32MSB_to_F32MSB },
{ AUDIO_F32LSB, AUDIO_U8, SDL_Convert_F32LSB_to_U8 },
{ AUDIO_F32LSB, AUDIO_S8, SDL_Convert_F32LSB_to_S8 },
{ AUDIO_F32LSB, AUDIO_U16LSB, SDL_Convert_F32LSB_to_U16LSB },
{ AUDIO_F32LSB, AUDIO_S16LSB, SDL_Convert_F32LSB_to_S16LSB },
{ AUDIO_F32LSB, AUDIO_U16MSB, SDL_Convert_F32LSB_to_U16MSB },
{ AUDIO_F32LSB, AUDIO_S16MSB, SDL_Convert_F32LSB_to_S16MSB },
{ AUDIO_F32LSB, AUDIO_S32LSB, SDL_Convert_F32LSB_to_S32LSB },
{ AUDIO_F32LSB, AUDIO_S32MSB, SDL_Convert_F32LSB_to_S32MSB },
{ AUDIO_F32LSB, AUDIO_F32MSB, SDL_Convert_F32LSB_to_F32MSB },
{ AUDIO_F32MSB, AUDIO_U8, SDL_Convert_F32MSB_to_U8 },
{ AUDIO_F32MSB, AUDIO_S8, SDL_Convert_F32MSB_to_S8 },
{ AUDIO_F32MSB, AUDIO_U16LSB, SDL_Convert_F32MSB_to_U16LSB },
{ AUDIO_F32MSB, AUDIO_S16LSB, SDL_Convert_F32MSB_to_S16LSB },
{ AUDIO_F32MSB, AUDIO_U16MSB, SDL_Convert_F32MSB_to_U16MSB },
{ AUDIO_F32MSB, AUDIO_S16MSB, SDL_Convert_F32MSB_to_S16MSB },
{ AUDIO_F32MSB, AUDIO_S32LSB, SDL_Convert_F32MSB_to_S32LSB },
{ AUDIO_F32MSB, AUDIO_S32MSB, SDL_Convert_F32MSB_to_S32MSB },
{ AUDIO_F32MSB, AUDIO_F32LSB, SDL_Convert_F32MSB_to_F32LSB },
};
src/audio/SDL_mixer.c
View file @ c500e6c0
......@@ -92,22 +92,27 @@ static const Uint8 mix8[] = {
void
SDL_MixAudio(Uint8 * dst, const Uint8 * src, Uint32 len, int volume)
{
Uint16 format;
if (volume == 0) {
return;
}
/* Mix the user-level audio format */
if (current_audio) {
SDL_AudioFormat format;
if (current_audio->convert.needed) {
format = current_audio->convert.src_format;
} else {
format = current_audio->spec.format;
}
} else {
/* HACK HACK HACK */
format = AUDIO_S16;
SDL_MixAudioFormat(dst, src, format, len, volume);
}
}
void
SDL_MixAudioFormat(Uint8 * dst, const Uint8 * src, SDL_AudioFormat format,
Uint32 len, int volume)
{
if (volume == 0) {
return;
}
switch (format) {
case AUDIO_U8:
......@@ -252,6 +257,134 @@ SDL_MixAudio(Uint8 * dst, const Uint8 * src, Uint32 len, int volume)
}
break;
case AUDIO_S32LSB:
{
const Uint32 *src32 = (Uint32 *) src;
Uint32 *dst32 = (Uint32 *) dst;
Sint32 src1, src2;
Sint64 dst_sample;
const Sint64 max_audioval = ((((Sint64)1) << (32 - 1)) - 1);
const Sint64 min_audioval = -(((Sint64)1) << (32 - 1));
len /= 4;
while (len--) {
src1 = (Sint32) SDL_SwapLE32(*src32);
src32++;
ADJUST_VOLUME(src1, volume);
src2 = (Sint32) SDL_SwapLE32(*dst32);
dst_sample = src1 + src2;
if (dst_sample > max_audioval) {
dst_sample = max_audioval;
} else if (dst_sample < min_audioval) {
dst_sample = min_audioval;
}
*(dst32++) = SDL_SwapLE32((Uint32) ((Sint32) dst_sample));
}
}
break;
case AUDIO_S32MSB:
{
const Uint32 *src32 = (Uint32 *) src;
Uint32 *dst32 = (Uint32 *) dst;
Sint32 src1, src2;
Sint64 dst_sample;
const Sint64 max_audioval = ((((Sint64)1) << (32 - 1)) - 1);
const Sint64 min_audioval = -(((Sint64)1) << (32 - 1));
len /= 4;
while (len--) {
src1 = (Sint32) SDL_SwapBE32(*src32);
src32++;
ADJUST_VOLUME(src1, volume);
src2 = (Sint32) SDL_SwapBE32(*dst32);
dst_sample = src1 + src2;
if (dst_sample > max_audioval) {
dst_sample = max_audioval;
} else if (dst_sample < min_audioval) {
dst_sample = min_audioval;
}
*(dst32++) = SDL_SwapBE32((Uint32) ((Sint32) dst_sample));
}
}
break;
case AUDIO_F32LSB:
{
const float fmaxvolume = 1.0f / ((float) SDL_MIX_MAXVOLUME);
const float fvolume = (float) volume;
const float *src32 = (float *) src;
float *dst32 = (float *) dst;
float src1, src2;
double dst_sample;
/* !!! FIXME: are these right? */
const double max_audioval = 3.40282347e+38F;
const double min_audioval = -3.40282347e+38F;
/* !!! FIXME: this is a little nasty. */
union { float f; Uint32 ui32; } cvt;
len /= 4;
while (len--) {
cvt.f = *(src32++);
cvt.ui32 = SDL_SwapLE32(cvt.ui32);
src1 = ((cvt.f * fvolume) * fmaxvolume);
cvt.f = *dst32;
cvt.ui32 = SDL_SwapLE32(cvt.ui32);
src2 = cvt.f;
dst_sample = src1 + src2;
if (dst_sample > max_audioval) {
dst_sample = max_audioval;
} else if (dst_sample < min_audioval) {
dst_sample = min_audioval;
}
cvt.f = ((float) dst_sample);
cvt.ui32 = SDL_SwapLE32(cvt.ui32);
*(dst32++) = cvt.f;
}
}
break;
case AUDIO_F32MSB:
{
const float fmaxvolume = 1.0f / ((float) SDL_MIX_MAXVOLUME);
const float fvolume = (float) volume;
const float *src32 = (float *) src;
float *dst32 = (float *) dst;
float src1, src2;
double dst_sample;
/* !!! FIXME: are these right? */
const double max_audioval = 3.40282347e+38F;
const double min_audioval = -3.40282347e+38F;
/* !!! FIXME: this is a little nasty. */
union { float f; Uint32 ui32; } cvt;
len /= 4;
while (len--) {
cvt.f = *(src32++);
cvt.ui32 = SDL_SwapBE32(cvt.ui32);
src1 = ((cvt.f * fvolume) * fmaxvolume);
cvt.f = *dst32;
cvt.ui32 = SDL_SwapBE32(cvt.ui32);
src2 = cvt.f;
dst_sample = src1 + src2;
if (dst_sample > max_audioval) {
dst_sample = max_audioval;
} else if (dst_sample < min_audioval) {
dst_sample = min_audioval;
}
cvt.f = ((float) dst_sample);
cvt.ui32 = SDL_SwapBE32(cvt.ui32);
*(dst32++) = cvt.f;
}
}
break;
default: /* If this happens... FIXME! */
SDL_SetError("SDL_MixAudio(): unknown audio format");
return;
......
src/audio/alsa/SDL_alsa_audio.c
View file @ c500e6c0
......@@ -483,7 +483,7 @@ ALSA_OpenAudio(_THIS, SDL_AudioSpec * spec)
snd_pcm_sw_params_t *swparams;
snd_pcm_format_t format;
snd_pcm_uframes_t frames;
Uint16 test_format;
SDL_AudioFormat test_format;
/* Open the audio device */
/* Name of device should depend on # channels in spec */
......
src/audio/arts/SDL_artsaudio.c
View file @ c500e6c0
......@@ -274,7 +274,7 @@ static int
ARTS_OpenAudio(_THIS, SDL_AudioSpec * spec)
{
int bits, frag_spec;
Uint16 test_format, format;
SDL_AudioFormat test_format, format;
/* Reset the timer synchronization flag */
frame_ticks = 0.0;
......
src/audio/bsd/SDL_bsdaudio.c
View file @ c500e6c0
......@@ -331,7 +331,7 @@ static int
OBSD_OpenAudio(_THIS, SDL_AudioSpec * spec)
{
char audiodev[64];
Uint16 format;
SDL_AudioFormat format;
audio_info_t info;
AUDIO_INITINFO(&info);
......
src/audio/dma/SDL_dmaaudio.c
View file @ c500e6c0
......@@ -321,7 +321,7 @@ DMA_OpenAudio(_THIS, SDL_AudioSpec * spec)
int format;
int stereo;
int value;
Uint16 test_format;
SDL_AudioFormat test_format;
struct audio_buf_info info;
/* Reset the timer synchronization flag */
......
src/audio/dsp/SDL_dspaudio.c
View file @ c500e6c0
......@@ -172,7 +172,7 @@ DSP_OpenAudio(_THIS, SDL_AudioSpec * spec)
int format;
int value;
int frag_spec;
Uint16 test_format;
SDL_AudioFormat test_format;
/* Open the audio device */
audio_fd = SDL_OpenAudioPath(audiodev, sizeof(audiodev), OPEN_FLAGS, 0);
......
src/audio/nas/SDL_nasaudio.c
View file @ c500e6c0
......@@ -237,7 +237,7 @@ NAS_OpenAudio(_THIS, SDL_AudioSpec * spec)
{
AuElement elms[3];
int buffer_size;
Uint16 test_format, format;
SDL_AudioFormat test_format, format;
this->hidden->mixbuf = NULL;
......
src/audio/nto/SDL_nto_audio.c
View file @ c500e6c0
......@@ -348,7 +348,7 @@ NTO_OpenAudio(_THIS, SDL_AudioSpec * spec)
{
int rval;
int format;
Uint16 test_format;
SDL_AudioFormat test_format;
int found;
audio_handle = NULL;
......
src/audio/paudio/SDL_paudio.c
View file @ c500e6c0
......@@ -244,7 +244,7 @@ Paud_OpenAudio(_THIS, SDL_AudioSpec * spec)
char audiodev[1024];
int format;
int bytes_per_sample;
Uint16 test_format;
SDL_AudioFormat test_format;
audio_init paud_init;
audio_buffer paud_bufinfo;
audio_status paud_status;
......
src/audio/sdlgenaudiocvt.pl 0 → 100755
View file @ c500e6c0
#!/usr/bin/perl -w
use warnings;
use strict;
my @audiotypes = qw(
U8
S8
U16LSB
S16LSB
U16MSB
S16MSB
S32LSB
S32MSB
F32LSB
F32MSB
);
my %funcs;
my $custom_converters = 0;
sub outputHeader {
print <<EOF;
/* DO NOT EDIT THIS FILE! It is generated code. */
/* Please modify SDL/src/audio/sdlgenaudiocvt.pl instead. */
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library 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.
This library 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 this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken\@libsdl.org
*/
#include "SDL_config.h"
#include "SDL_audio.h"
#include "SDL_audio_c.h"
/* Now the generated code... */
EOF
my @vals = ( 127, 255, 32767, 65535, 2147483647 );
foreach (@vals) {
my $val = $_;
my $fval = 1.0 / $val;
print("#define DIVBY${val} ${fval}f\n");
}
print("\n");
}
sub splittype {
my $t = shift;
my ($signed, $size, $endian) = $t =~ /([USF])(\d+)([LM]SB|)/;
my $float = ($signed eq 'F') ? 1 : 0;
$signed = (($float) or ($signed eq 'S')) ? 1 : 0;
$endian = 'NONE' if ($endian eq '');
my $ctype = '';
if ($float) {
$ctype = (($size == 32) ? 'float' : 'double');
} else {
$ctype = (($signed) ? 'S' : 'U') . "int${size}";
}
return ($signed, $float, $size, $endian, $ctype);
}
sub getSwapFunc {
my ($size, $signed, $float, $endian, $val) = @_;
my $BEorLE = (($endian eq 'MSB') ? 'BE' : 'LE');
my $code = '';
if ($float) {
$code = "SDL_SwapFloat${BEorLE}($val)";
} else {
if ($size > 8) {
$code = "SDL_Swap${BEorLE}${size}($val)";
} else {
$code = $val;
}
if (($signed) and (!$float)) {
$code = "((Sint${size}) $code)";
}
}
return "${code}";
}
sub maxIntVal {
my ($signed, $size) = @_;
if ($signed) {
if ($size == 8) {
return 0x7F;
} elsif ($size == 16) {
return 0x7FFF;
} elsif ($size == 32) {
return 0x7FFFFFFF;
}
} else {
if ($size == 8) {
return 0xFF;
} elsif ($size == 16) {
return 0xFFFF;
} elsif ($size == 32) {
return 0xFFFFFFFF;
}
}
die("bug in script.\n");
}
sub getFloatToIntMult {
my ($signed, $size) = @_;
my $val = maxIntVal($signed, $size) . '.0';
$val .= 'f' if ($size < 32);
return $val;
}
sub getIntToFloatDivBy {
my ($signed, $size) = @_;
return 'DIVBY' . maxIntVal($signed, $size);
}
sub getSignFlipVal {
my $size = shift;
if ($size == 8) {
return '0x80';
} elsif ($size == 16) {
return '0x8000';
} elsif ($size == 32) {
return '0x80000000';
}
die("bug in script.\n");
}
sub buildCvtFunc {
my ($from, $to) = @_;
my ($fsigned, $ffloat, $fsize, $fendian, $fctype) = splittype($from);
my ($tsigned, $tfloat, $tsize, $tendian, $tctype) = splittype($to);
my $diffs = 0;
$diffs++ if ($fsize != $tsize);
$diffs++ if ($fsigned != $tsigned);
$diffs++ if ($ffloat != $tfloat);
$diffs++ if ($fendian ne $tendian);
return if ($diffs == 0);
my $hashid = "$from/$to";
if (1) { # !!! FIXME: if ($diffs > 1) {
my $sym = "SDL_Convert_${from}_to_${to}";
$funcs{$hashid} = $sym;
$custom_converters++;
# Always unsigned for ints, for possible byteswaps.
my $srctype = (($ffloat) ? 'float' : "Uint${fsize}");
print <<EOF;
static void SDLCALL
${sym}(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
const $srctype *src;
$tctype *dst;
#ifdef DEBUG_CONVERT
fprintf(stderr, "Converting AUDIO_${from} to AUDIO_${to}.\\n");
#endif
EOF
if ($fsize < $tsize) {
my $mult = $tsize / $fsize;
print <<EOF;
src = (const $srctype *) (cvt->buf + cvt->len_cvt);
dst = ($tctype *) (cvt->buf + cvt->len_cvt * $mult);
for (i = cvt->len_cvt / sizeof ($srctype); i; --i, --src, --dst) {
EOF
} else {
print <<EOF;
src = (const $srctype *) cvt->buf;
dst = ($tctype *) cvt->buf;
for (i = cvt->len_cvt / sizeof ($srctype); i; --i, ++src, ++dst) {
EOF
}
# Have to convert to/from float/int.
# !!! FIXME: cast through double for int32<->float?
my $code = getSwapFunc($fsize, $fsigned, $ffloat, $fendian, '*src');
if ($ffloat != $tfloat) {
if ($ffloat) {
my $mult = getFloatToIntMult($tsigned, $tsize);
$code = "(($tctype) ($code * $mult))";
} else {
# $divby will be the reciprocal, to avoid pipeline stalls
# from floating point division...so multiply it.
my $divby = getIntToFloatDivBy($fsigned, $fsize);
$code = "(((float) $code) * $divby)";
}
} else {
# All integer conversions here.
if ($fsigned != $tsigned) {
my $signflipval = getSignFlipVal($fsize);
$code = "(($code) ^ $signflipval)";
}
my $shiftval = abs($fsize - $tsize);
if ($fsize < $tsize) {
$code = "((($tctype) $code) << $shiftval)";
} elsif ($fsize > $tsize) {
$code = "(($tctype) ($code >> $shiftval))";
}
}
my $swap = getSwapFunc($tsize, $tsigned, $tfloat, $tendian, 'val');
print <<EOF;
const $tctype val = $code;
*dst = ${swap};
}
EOF
if ($fsize > $tsize) {
my $divby = $fsize / $tsize;
print(" cvt->len_cvt /= $divby;\n");
} elsif ($fsize < $tsize) {
my $mult = $tsize / $fsize;
print(" cvt->len_cvt *= $mult;\n");
}
print <<EOF;
format = AUDIO_$to;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
EOF
} else {
if ($fsigned != $tsigned) {
$funcs{$hashid} = 'SDL_ConvertSigned';
} elsif ($ffloat != $tfloat) {
$funcs{$hashid} = 'SDL_ConvertFloat';
} elsif ($fsize != $tsize) {
$funcs{$hashid} = 'SDL_ConvertSize';
} elsif ($fendian ne $tendian) {
$funcs{$hashid} = 'SDL_ConvertEndian';
} else {
die("error in script.\n");
}
}
}
outputHeader();
foreach (@audiotypes) {
my $from = $_;
foreach (@audiotypes) {
my $to = $_;
buildCvtFunc($from, $to);
}
}
print <<EOF;
const SDL_AudioTypeFilters sdl_audio_type_filters[] =
{
EOF
foreach (@audiotypes) {
my $from = $_;
foreach (@audiotypes) {
my $to = $_;
if ($from ne $to) {
my $hashid = "$from/$to";
my $sym = $funcs{$hashid};
print(" { AUDIO_$from, AUDIO_$to, $sym },\n");
}
}
}
print <<EOF;
};
EOF
exit 0;
# end of sdlaudiocvt.pl ...
src/audio/sun/SDL_sunaudio.h
View file @ c500e6c0
......@@ -34,7 +34,7 @@ struct SDL_PrivateAudioData
/* The file descriptor for the audio device */
int audio_fd;
Uint16 audio_fmt; /* The app audio format */
SDL_AudioFormat audio_fmt; /* The app audio format */
Uint8 *mixbuf; /* The app mixing buffer */
int ulaw_only; /* Flag -- does hardware only output U-law? */
Uint8 *ulaw_buf; /* The U-law mixing buffer */
......
src/audio/ums/SDL_umsaudio.c
View file @ c500e6c0
......@@ -250,7 +250,7 @@ UMS_OpenAudio(_THIS, SDL_AudioSpec * spec)
long bitsPerSample;
long samplesPerSec;
long success;
Uint16 test_format;
SDL_AudioFormat test_format;
int frag_spec;
UMSAudioDevice_ReturnCode rc;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment