#include "../SDL_internal.h"
#include "SDL.h"
#include "SDL_audio.h"
#include "SDL_audio_c.h"
#include "SDL_loadso.h"
#include "SDL_assert.h"
#include "../SDL_dataqueue.h"
#include "SDL_cpuinfo.h"

Include dependency graph for SDL_audiocvt.c:

Data Structures
struct	SDL_AudioStream

Macros
#define	DEBUG_AUDIOSTREAM 0
#define	RESAMPLER_ZERO_CROSSINGS 5
#define	RESAMPLER_BITS_PER_SAMPLE 16
#define	RESAMPLER_SAMPLES_PER_ZERO_CROSSING (1 << ((RESAMPLER_BITS_PER_SAMPLE / 2) + 1))
#define	RESAMPLER_FILTER_SIZE ((RESAMPLER_SAMPLES_PER_ZERO_CROSSING * RESAMPLER_ZERO_CROSSINGS) + 1)
#define	CASESWAP(b)
#define	RESAMPLER_FUNCS(chans)

Typedefs
typedef int(*	SDL_ResampleAudioStreamFunc )(SDL_AudioStream stream, const void inbuf, const int inbuflen, void *outbuf, const int outbuflen)
typedef void(*	SDL_ResetAudioStreamResamplerFunc )(SDL_AudioStream *stream)
typedef void(*	SDL_CleanupAudioStreamResamplerFunc )(SDL_AudioStream *stream)

Functions
static void	SDL_ConvertStereoToMono (SDL_AudioCVT *cvt, SDL_AudioFormat format)
static void	SDL_Convert51ToStereo (SDL_AudioCVT *cvt, SDL_AudioFormat format)
static void	SDL_ConvertQuadToStereo (SDL_AudioCVT *cvt, SDL_AudioFormat format)
static void	SDL_Convert71To51 (SDL_AudioCVT *cvt, SDL_AudioFormat format)
static void	SDL_Convert51ToQuad (SDL_AudioCVT *cvt, SDL_AudioFormat format)
static void	SDL_ConvertMonoToStereo (SDL_AudioCVT *cvt, SDL_AudioFormat format)
static void	SDL_ConvertStereoTo51 (SDL_AudioCVT *cvt, SDL_AudioFormat format)
static void	SDL_ConvertQuadTo51 (SDL_AudioCVT *cvt, SDL_AudioFormat format)
static void	SDL_ConvertStereoToQuad (SDL_AudioCVT *cvt, SDL_AudioFormat format)
static void	SDL_Convert51To71 (SDL_AudioCVT *cvt, SDL_AudioFormat format)
static double	bessel (const double x)
static void	kaiser_and_sinc (float table, float diffs, const int tablelen, const double beta)
int	SDL_PrepareResampleFilter (void)
void	SDL_FreeResampleFilter (void)
static int	ResamplerPadding (const int inrate, const int outrate)
static int	SDL_ResampleAudio (const int chans, const int inrate, const int outrate, const float lpadding, const float rpadding, const float inbuf, const int inbuflen, float outbuf, const int outbuflen)
int	SDL_ConvertAudio (SDL_AudioCVT *cvt)
static void	SDL_Convert_Byteswap (SDL_AudioCVT *cvt, SDL_AudioFormat format)
static int	SDL_AddAudioCVTFilter (SDL_AudioCVT *cvt, const SDL_AudioFilter filter)
static int	SDL_BuildAudioTypeCVTToFloat (SDL_AudioCVT *cvt, const SDL_AudioFormat src_fmt)
static int	SDL_BuildAudioTypeCVTFromFloat (SDL_AudioCVT *cvt, const SDL_AudioFormat dst_fmt)
static void	SDL_ResampleCVT (SDL_AudioCVT *cvt, const int chans, const SDL_AudioFormat format)
static SDL_AudioFilter	ChooseCVTResampler (const int dst_channels)
static int	SDL_BuildAudioResampleCVT (SDL_AudioCVT *cvt, const int dst_channels, const int src_rate, const int dst_rate)
static SDL_bool	SDL_SupportedAudioFormat (const SDL_AudioFormat fmt)
static SDL_bool	SDL_SupportedChannelCount (const int channels)
int	SDL_BuildAudioCVT (SDL_AudioCVT *cvt, SDL_AudioFormat src_fmt, Uint8 src_channels, int src_rate, SDL_AudioFormat dst_fmt, Uint8 dst_channels, int dst_rate)
static Uint8 *	EnsureStreamBufferSize (SDL_AudioStream *stream, const int newlen)
static int	SDL_ResampleAudioStream (SDL_AudioStream stream, const void _inbuf, const int inbuflen, void *_outbuf, const int outbuflen)
static void	SDL_ResetAudioStreamResampler (SDL_AudioStream *stream)
static void	SDL_CleanupAudioStreamResampler (SDL_AudioStream *stream)
SDL_AudioStream *	SDL_NewAudioStream (const SDL_AudioFormat src_format, const Uint8 src_channels, const int src_rate, const SDL_AudioFormat dst_format, const Uint8 dst_channels, const int dst_rate)
static int	SDL_AudioStreamPutInternal (SDL_AudioStream stream, const void buf, int len, int *maxputbytes)
int	SDL_AudioStreamPut (SDL_AudioStream stream, const void buf, int len)
int	SDL_AudioStreamFlush (SDL_AudioStream *stream)
int	SDL_AudioStreamGet (SDL_AudioStream stream, void buf, int len)
int	SDL_AudioStreamAvailable (SDL_AudioStream *stream)
void	SDL_AudioStreamClear (SDL_AudioStream *stream)
void	SDL_FreeAudioStream (SDL_AudioStream *stream)

Variables
static SDL_SpinLock	ResampleFilterSpinlock = 0
static float *	ResamplerFilter = NULL
static float *	ResamplerFilterDifference = NULL

Macro Definition Documentation

#define CASESWAP ( b )

Value:

case b: { \
                Uint##b *ptr = (Uint##b *) cvt->buf; \
                int i; \
                for (i = cvt->len_cvt / sizeof (*ptr); i; --i, ++ptr) { \
                    *ptr = SDL_Swap##b(*ptr); \
                } \
                break; \
            }

Referenced by SDL_Convert_Byteswap().

#define DEBUG_AUDIOSTREAM 0

Definition at line 37 of file SDL_audiocvt.c.

Referenced by SDL_AudioStreamFlush().

#define RESAMPLER_BITS_PER_SAMPLE 16

Definition at line 381 of file SDL_audiocvt.c.

#define RESAMPLER_FILTER_SIZE ((RESAMPLER_SAMPLES_PER_ZERO_CROSSING * RESAMPLER_ZERO_CROSSINGS) + 1)

Definition at line 383 of file SDL_audiocvt.c.

Referenced by SDL_PrepareResampleFilter(), and SDL_ResampleAudio().

#define RESAMPLER_FUNCS ( chans )

Value:

static void SDLCALL \
    SDL_ResampleCVT_c##chans(SDL_AudioCVT *cvt, SDL_AudioFormat format) { \
        SDL_ResampleCVT(cvt, chans, format); \
    }

Definition at line 748 of file SDL_audiocvt.c.

#define RESAMPLER_SAMPLES_PER_ZERO_CROSSING (1 << ((RESAMPLER_BITS_PER_SAMPLE / 2) + 1))

Definition at line 382 of file SDL_audiocvt.c.

Referenced by kaiser_and_sinc(), ResamplerPadding(), and SDL_ResampleAudio().

#define RESAMPLER_ZERO_CROSSINGS 5

Definition at line 380 of file SDL_audiocvt.c.

Typedef Documentation

typedef void(* SDL_CleanupAudioStreamResamplerFunc)(SDL_AudioStream *stream)

Definition at line 1081 of file SDL_audiocvt.c.

typedef int(* SDL_ResampleAudioStreamFunc)(SDL_AudioStream *stream, const void *inbuf, const int inbuflen, void *outbuf, const int outbuflen)

Definition at line 1079 of file SDL_audiocvt.c.

typedef void(* SDL_ResetAudioStreamResamplerFunc)(SDL_AudioStream *stream)

Definition at line 1080 of file SDL_audiocvt.c.

Function Documentation

static double bessel ( const double x )

static

Definition at line 387 of file SDL_audiocvt.c.

References e, i, SDL_pow, and SDL_TRUE.

Referenced by kaiser_and_sinc().

{
    const double xdiv2 = x / 2.0;
    double i0 = 1.0f;
    double f = 1.0f;
    int i = 1;
    while (SDL_TRUE) {
        const double diff = SDL_pow(xdiv2, i * 2) / SDL_pow(f, 2);
        if (diff < 1.0e-21f) {
            break;
        }
        i0 += diff;
        i++;
        f *= (double) i;
    }
    return i0;
}

static SDL_AudioFilter ChooseCVTResampler ( const int dst_channels )

static

Definition at line 761 of file SDL_audiocvt.c.

References NULL.

Referenced by SDL_BuildAudioResampleCVT().

{
    switch (dst_channels) {
        case 1: return SDL_ResampleCVT_c1;
        case 2: return SDL_ResampleCVT_c2;
        case 4: return SDL_ResampleCVT_c4;
        case 6: return SDL_ResampleCVT_c6;
        case 8: return SDL_ResampleCVT_c8;
        default: break;
    }
    return NULL;
}

static Uint8* EnsureStreamBufferSize	(	SDL_AudioStream *	stream,
		const int	newlen
	)

static

Definition at line 1114 of file SDL_audiocvt.c.

References NULL, SDL_OutOfMemory, and SDL_realloc.

Referenced by SDL_AudioStreamPutInternal().

{
    Uint8 *ptr;
    size_t offset;
    if (stream->work_buffer_len >= newlen) {
        ptr = stream->work_buffer_base;
    } else {
        ptr = (Uint8 *) SDL_realloc(stream->work_buffer_base, newlen + 32);
        if (!ptr) {
            SDL_OutOfMemory();
            return NULL;
        }
        /* Make sure we're aligned to 16 bytes for SIMD code. */
        stream->work_buffer_base = ptr;
        stream->work_buffer_len = newlen;
    }
    offset = ((size_t) ptr) & 15;
    return offset ? ptr + (16 - offset) : ptr;
}

static void kaiser_and_sinc	(	float *	table,
		float *	diffs,
		const int	tablelen,
		const double	beta
	)

static

Definition at line 409 of file SDL_audiocvt.c.

References bessel(), i, RESAMPLER_SAMPLES_PER_ZERO_CROSSING, SDL_pow, SDL_sinf, and SDL_sqrt.

Referenced by SDL_PrepareResampleFilter().

{
    const int lenm1 = tablelen - 1;
    const int lenm1div2 = lenm1 / 2;
    int i;
    table[0] = 1.0f;
    for (i = 1; i < tablelen; i++) {
        const double kaiser = bessel(beta * SDL_sqrt(1.0 - SDL_pow(((i - lenm1) / 2.0) / lenm1div2, 2.0))) / bessel(beta);
        table[tablelen - i] = (float) kaiser;
    }
    for (i = 1; i < tablelen; i++) {
        const float x = (((float) i) / ((float) RESAMPLER_SAMPLES_PER_ZERO_CROSSING)) * ((float) M_PI);
        table[i] *= SDL_sinf(x) / x;
        diffs[i - 1] = table[i] - table[i - 1];
    }
    diffs[lenm1] = 0.0f;
}

static int ResamplerPadding	(	const int	inrate,
		const int	outrate
	)

static

Definition at line 473 of file SDL_audiocvt.c.

References RESAMPLER_SAMPLES_PER_ZERO_CROSSING, and SDL_ceil.

Referenced by SDL_NewAudioStream(), SDL_ResampleAudio(), and SDL_ResampleCVT().

{
    if (inrate == outrate) {
        return 0;
    } else if (inrate > outrate) {
        return (int) SDL_ceil(((float) (RESAMPLER_SAMPLES_PER_ZERO_CROSSING * inrate) / ((float) outrate)));
    }
    return RESAMPLER_SAMPLES_PER_ZERO_CROSSING;
}

static int SDL_AddAudioCVTFilter	(	SDL_AudioCVT *	cvt,
		const SDL_AudioFilter	filter
	)

static

Definition at line 601 of file SDL_audiocvt.c.

References SDL_AudioCVT::filter_index, SDL_AudioCVT::filters, NULL, SDL_AUDIOCVT_MAX_FILTERS, and SDL_SetError.

Referenced by SDL_BuildAudioCVT(), SDL_BuildAudioResampleCVT(), SDL_BuildAudioTypeCVTFromFloat(), and SDL_BuildAudioTypeCVTToFloat().

{
    if (cvt->filter_index >= SDL_AUDIOCVT_MAX_FILTERS) {
        return SDL_SetError("Too many filters needed for conversion, exceeded maximum of %d", SDL_AUDIOCVT_MAX_FILTERS);
    }
    if (filter == NULL) {
        return SDL_SetError("Audio filter pointer is NULL");
    }
    cvt->filters[cvt->filter_index++] = filter;
    cvt->filters[cvt->filter_index] = NULL; /* Moving terminator */
    return 0;
}

int SDL_AudioStreamAvailable ( SDL_AudioStream * stream )

Get the number of converted/resampled bytes available. The stream may be buffering data behind the scenes until it has enough to resample correctly, so this number might be lower than what you expect, or even be zero. Add more data or flush the stream if you need the data now.

See Also: SDL_NewAudioStream; SDL_AudioStreamPut; SDL_AudioStreamGet; SDL_AudioStreamFlush; SDL_AudioStreamClear; SDL_FreeAudioStream

Definition at line 1636 of file SDL_audiocvt.c.

References SDL_CountDataQueue().

{
    return stream ? (int) SDL_CountDataQueue(stream->queue) : 0;
}

void SDL_AudioStreamClear ( SDL_AudioStream * stream )

Clear any pending data in the stream without converting it

See Also: SDL_NewAudioStream; SDL_AudioStreamPut; SDL_AudioStreamGet; SDL_AudioStreamAvailable; SDL_AudioStreamFlush; SDL_FreeAudioStream

Definition at line 1642 of file SDL_audiocvt.c.

References SDL_ClearDataQueue(), SDL_InvalidParamError, and SDL_TRUE.

{
    if (!stream) {
        SDL_InvalidParamError("stream");
    } else {
        SDL_ClearDataQueue(stream->queue, stream->packetlen * 2);
        if (stream->reset_resampler_func) {
            stream->reset_resampler_func(stream);
        }
        stream->first_run = SDL_TRUE;
        stream->staging_buffer_filled = 0;
    }
}

int SDL_AudioStreamFlush ( SDL_AudioStream * stream )

Tell the stream that you're done sending data, and anything being buffered should be converted/resampled and made available immediately.

It is legal to add more data to a stream after flushing, but there will be audio gaps in the output. Generally this is intended to signal the end of input, so the complete output becomes available.

See Also: SDL_NewAudioStream; SDL_AudioStreamPut; SDL_AudioStreamGet; SDL_AudioStreamAvailable; SDL_AudioStreamClear; SDL_FreeAudioStream

Definition at line 1561 of file SDL_audiocvt.c.

References DEBUG_AUDIOSTREAM, SDL_assert, SDL_AudioStreamPutInternal(), SDL_ceil, SDL_InvalidParamError, SDL_memset, and SDL_TRUE.

{
    if (!stream) {
        return SDL_InvalidParamError("stream");
    }
    #if DEBUG_AUDIOSTREAM
    printf("AUDIOSTREAM: flushing! staging_buffer_filled=%d bytes\n", stream->staging_buffer_filled);
    #endif
    /* shouldn't use a staging buffer if we're not resampling. */
    SDL_assert((stream->dst_rate != stream->src_rate) || (stream->staging_buffer_filled == 0));
    if (stream->staging_buffer_filled > 0) {
        /* push the staging buffer + silence. We need to flush out not just
           the staging buffer, but the piece that the stream was saving off
           for right-side resampler padding. */
        const SDL_bool first_run = stream->first_run;
        const int filled = stream->staging_buffer_filled;
        int actual_input_frames = filled / stream->src_sample_frame_size;
        if (!first_run)
            actual_input_frames += stream->resampler_padding_samples / stream->pre_resample_channels;
        if (actual_input_frames > 0) {  /* don't bother if nothing to flush. */
            /* This is how many bytes we're expecting without silence appended. */
            int flush_remaining = ((int) SDL_ceil(actual_input_frames * stream->rate_incr)) * stream->dst_sample_frame_size;
            #if DEBUG_AUDIOSTREAM
            printf("AUDIOSTREAM: flushing with padding to get max %d bytes!\n", flush_remaining);
            #endif
            SDL_memset(stream->staging_buffer + filled, '\0', stream->staging_buffer_size - filled);
            if (SDL_AudioStreamPutInternal(stream, stream->staging_buffer, stream->staging_buffer_size, &flush_remaining) < 0) {
                return -1;
            }
            /* we have flushed out (or initially filled) the pending right-side
               resampler padding, but we need to push more silence to guarantee
               the staging buffer is fully flushed out, too. */
            SDL_memset(stream->staging_buffer, '\0', filled);
            if (SDL_AudioStreamPutInternal(stream, stream->staging_buffer, stream->staging_buffer_size, &flush_remaining) < 0) {
                return -1;
            }
        }
    }
    stream->staging_buffer_filled = 0;
    stream->first_run = SDL_TRUE;
    return 0;
}

int SDL_AudioStreamGet	(	SDL_AudioStream *	stream,
		void *	buf,
		int	len
	)

Get converted/resampled data from the stream

Parameters

stream	The stream the audio is being requested from
buf	A buffer to fill with audio data
len	The maximum number of bytes to fill

Returns: The number of bytes read from the stream, or -1 on error

See Also: SDL_NewAudioStream; SDL_AudioStreamPut; SDL_AudioStreamAvailable; SDL_AudioStreamFlush; SDL_AudioStreamClear; SDL_FreeAudioStream

Definition at line 1615 of file SDL_audiocvt.c.

References SDL_InvalidParamError, SDL_ReadFromDataQueue(), and SDL_SetError.

{
    #if DEBUG_AUDIOSTREAM
    printf("AUDIOSTREAM: want to get %d converted bytes\n", len);
    #endif
    if (!stream) {
        return SDL_InvalidParamError("stream");
    } else if (!buf) {
        return SDL_InvalidParamError("buf");
    } else if (len <= 0) {
        return 0;  /* nothing to do. */
    } else if ((len % stream->dst_sample_frame_size) != 0) {
        return SDL_SetError("Can't request partial sample frames");
    }
    return (int) SDL_ReadFromDataQueue(stream->queue, buf, len);
}

int SDL_AudioStreamPut	(	SDL_AudioStream *	stream,
		const void *	buf,
		int	len
	)

Add data to be converted/resampled to the stream

Parameters

stream	The stream the audio data is being added to
buf	A pointer to the audio data to add
len	The number of bytes to write to the stream

Returns: 0 on success, or -1 on error.

See Also: SDL_NewAudioStream; SDL_AudioStreamGet; SDL_AudioStreamAvailable; SDL_AudioStreamFlush; SDL_AudioStreamClear; SDL_FreeAudioStream

Definition at line 1497 of file SDL_audiocvt.c.

References NULL, SDL_assert, SDL_AudioStreamPutInternal(), SDL_InvalidParamError, SDL_memcpy, SDL_SetError, and SDL_WriteToDataQueue().

{
    /* !!! FIXME: several converters can take advantage of SIMD, but only
       !!! FIXME:  if the data is aligned to 16 bytes. EnsureStreamBufferSize()
       !!! FIXME:  guarantees the buffer will align, but the
       !!! FIXME:  converters will iterate over the data backwards if
       !!! FIXME:  the output grows, and this means we won't align if buflen
       !!! FIXME:  isn't a multiple of 16. In these cases, we should chop off
       !!! FIXME:  a few samples at the end and convert them separately. */
    #if DEBUG_AUDIOSTREAM
    printf("AUDIOSTREAM: wants to put %d preconverted bytes\n", buflen);
    #endif
    if (!stream) {
        return SDL_InvalidParamError("stream");
    } else if (!buf) {
        return SDL_InvalidParamError("buf");
    } else if (len == 0) {
        return 0;  /* nothing to do. */
    } else if ((len % stream->src_sample_frame_size) != 0) {
        return SDL_SetError("Can't add partial sample frames");
    }
    if (!stream->cvt_before_resampling.needed &&
        (stream->dst_rate == stream->src_rate) &&
        !stream->cvt_after_resampling.needed) {
        #if DEBUG_AUDIOSTREAM
        printf("AUDIOSTREAM: no conversion needed at all, queueing %d bytes.\n", len);
        #endif
        return SDL_WriteToDataQueue(stream->queue, buf, len);
    }
    while (len > 0) {
        int amount;
        /* If we don't have a staging buffer or we're given enough data that
           we don't need to store it for later, skip the staging process.
         */
        if (!stream->staging_buffer_filled && len >= stream->staging_buffer_size) {
            return SDL_AudioStreamPutInternal(stream, buf, len, NULL);
        }
        /* If there's not enough data to fill the staging buffer, just save it */
        if ((stream->staging_buffer_filled + len) < stream->staging_buffer_size) {
            SDL_memcpy(stream->staging_buffer + stream->staging_buffer_filled, buf, len);
            stream->staging_buffer_filled += len;
            return 0;
        }
 
        /* Fill the staging buffer, process it, and continue */
        amount = (stream->staging_buffer_size - stream->staging_buffer_filled);
        SDL_assert(amount > 0);
        SDL_memcpy(stream->staging_buffer + stream->staging_buffer_filled, buf, amount);
        stream->staging_buffer_filled = 0;
        if (SDL_AudioStreamPutInternal(stream, stream->staging_buffer, stream->staging_buffer_size, NULL) < 0) {
            return -1;
        }
        buf = (void *)((Uint8 *)buf + amount);
        len -= amount;
    }
    return 0;
}

static int SDL_AudioStreamPutInternal	(	SDL_AudioStream *	stream,
		const void *	buf,
		int	len,
		int *	maxputbytes
	)

static

Definition at line 1368 of file SDL_audiocvt.c.

References EnsureStreamBufferSize(), NULL, SDL_assert, SDL_ceil, SDL_ConvertAudio, SDL_FALSE, SDL_memcpy, and SDL_WriteToDataQueue().

Referenced by SDL_AudioStreamFlush(), and SDL_AudioStreamPut().

{
    int buflen = len;
    int workbuflen;
    Uint8 *workbuf;
    Uint8 *resamplebuf = NULL;
    int resamplebuflen = 0;
    int neededpaddingbytes;
    int paddingbytes;
    /* !!! FIXME: several converters can take advantage of SIMD, but only
       !!! FIXME:  if the data is aligned to 16 bytes. EnsureStreamBufferSize()
       !!! FIXME:  guarantees the buffer will align, but the
       !!! FIXME:  converters will iterate over the data backwards if
       !!! FIXME:  the output grows, and this means we won't align if buflen
       !!! FIXME:  isn't a multiple of 16. In these cases, we should chop off
       !!! FIXME:  a few samples at the end and convert them separately. */
    /* no padding prepended on first run. */
    neededpaddingbytes = stream->resampler_padding_samples * sizeof (float);
    paddingbytes = stream->first_run ? 0 : neededpaddingbytes;
    stream->first_run = SDL_FALSE;
    /* Make sure the work buffer can hold all the data we need at once... */
    workbuflen = buflen;
    if (stream->cvt_before_resampling.needed) {
        workbuflen *= stream->cvt_before_resampling.len_mult;
    }
    if (stream->dst_rate != stream->src_rate) {
        /* resamples can't happen in place, so make space for second buf. */
        const int framesize = stream->pre_resample_channels * sizeof (float);
        const int frames = workbuflen / framesize;
        resamplebuflen = ((int) SDL_ceil(frames * stream->rate_incr)) * framesize;
        #if DEBUG_AUDIOSTREAM
        printf("AUDIOSTREAM: will resample %d bytes to %d (ratio=%.6f)\n", workbuflen, resamplebuflen, stream->rate_incr);
        #endif
        workbuflen += resamplebuflen;
    }
    if (stream->cvt_after_resampling.needed) {
        /* !!! FIXME: buffer might be big enough already? */
        workbuflen *= stream->cvt_after_resampling.len_mult;
    }
    workbuflen += neededpaddingbytes;
    #if DEBUG_AUDIOSTREAM
    printf("AUDIOSTREAM: Putting %d bytes of preconverted audio, need %d byte work buffer\n", buflen, workbuflen);
    #endif
    workbuf = EnsureStreamBufferSize(stream, workbuflen);
    if (!workbuf) {
        return -1;  /* probably out of memory. */
    }
    resamplebuf = workbuf;  /* default if not resampling. */
    SDL_memcpy(workbuf + paddingbytes, buf, buflen);
    if (stream->cvt_before_resampling.needed) {
        stream->cvt_before_resampling.buf = workbuf + paddingbytes;
        stream->cvt_before_resampling.len = buflen;
        if (SDL_ConvertAudio(&stream->cvt_before_resampling) == -1) {
            return -1;   /* uhoh! */
        }
        buflen = stream->cvt_before_resampling.len_cvt;
        #if DEBUG_AUDIOSTREAM
        printf("AUDIOSTREAM: After initial conversion we have %d bytes\n", buflen);
        #endif
    }
    if (stream->dst_rate != stream->src_rate) {
        /* save off some samples at the end; they are used for padding now so
           the resampler is coherent and then used at the start of the next
           put operation. Prepend last put operation's padding, too. */
        /* prepend prior put's padding. :P */
        if (paddingbytes) {
            SDL_memcpy(workbuf, stream->resampler_padding, paddingbytes);
            buflen += paddingbytes;
        }
        /* save off the data at the end for the next run. */
        SDL_memcpy(stream->resampler_padding, workbuf + (buflen - neededpaddingbytes), neededpaddingbytes);
        resamplebuf = workbuf + buflen;  /* skip to second piece of workbuf. */
        SDL_assert(buflen >= neededpaddingbytes);
        if (buflen > neededpaddingbytes) {
            buflen = stream->resampler_func(stream, workbuf, buflen - neededpaddingbytes, resamplebuf, resamplebuflen);
        } else {
            buflen = 0;
        }
        #if DEBUG_AUDIOSTREAM
        printf("AUDIOSTREAM: After resampling we have %d bytes\n", buflen);
        #endif
    }
    if (stream->cvt_after_resampling.needed && (buflen > 0)) {
        stream->cvt_after_resampling.buf = resamplebuf;
        stream->cvt_after_resampling.len = buflen;
        if (SDL_ConvertAudio(&stream->cvt_after_resampling) == -1) {
            return -1;   /* uhoh! */
        }
        buflen = stream->cvt_after_resampling.len_cvt;
        #if DEBUG_AUDIOSTREAM
        printf("AUDIOSTREAM: After final conversion we have %d bytes\n", buflen);
        #endif
    }
    #if DEBUG_AUDIOSTREAM
    printf("AUDIOSTREAM: Final output is %d bytes\n", buflen);
    #endif
    if (maxputbytes) {
        const int maxbytes = *maxputbytes;
        if (buflen > maxbytes)
            buflen = maxbytes;
        *maxputbytes -= buflen;
    }
    /* resamplebuf holds the final output, even if we didn't resample. */
    return buflen ? SDL_WriteToDataQueue(stream->queue, resamplebuf, buflen) : 0;
}

int SDL_BuildAudioCVT	(	SDL_AudioCVT *	cvt,
		SDL_AudioFormat	src_format,
		Uint8	src_channels,
		int	src_rate,
		SDL_AudioFormat	dst_format,
		Uint8	dst_channels,
		int	dst_rate
	)

This function takes a source format and rate and a destination format and rate, and initializes the cvt structure with information needed by SDL_ConvertAudio() to convert a buffer of audio data from one format to the other. An unsupported format causes an error and -1 will be returned.

Returns: 0 if no conversion is needed, 1 if the audio filter is set up, or -1 on error.

Definition at line 872 of file SDL_audiocvt.c.

References SDL_AudioCVT::dst_format, SDL_AudioCVT::filter_index, SDL_AudioCVT::filters, SDL_AudioCVT::len_mult, SDL_AudioCVT::len_ratio, SDL_AudioCVT::needed, NULL, SDL_AudioCVT::rate_incr, SDL_AddAudioCVTFilter(), SDL_AUDIO_MASK_ENDIAN, SDL_BuildAudioResampleCVT(), SDL_BuildAudioTypeCVTFromFloat(), SDL_BuildAudioTypeCVTToFloat(), SDL_ChooseAudioConverters(), SDL_Convert51To71(), SDL_Convert51ToQuad(), SDL_Convert51ToStereo(), SDL_Convert71To51(), SDL_Convert_Byteswap(), SDL_ConvertMonoToStereo(), SDL_ConvertQuadTo51(), SDL_ConvertQuadToStereo(), SDL_ConvertStereoTo51(), SDL_ConvertStereoToMono(), SDL_ConvertStereoToQuad(), SDL_HasSSE3, SDL_InvalidParamError, SDL_SetError, SDL_SupportedAudioFormat(), SDL_SupportedChannelCount(), SDL_zero, SDL_zerop, and SDL_AudioCVT::src_format.

{
    /* Sanity check target pointer */
    if (cvt == NULL) {
        return SDL_InvalidParamError("cvt");
    }
    /* Make sure we zero out the audio conversion before error checking */
    SDL_zerop(cvt);
    if (!SDL_SupportedAudioFormat(src_fmt)) {
        return SDL_SetError("Invalid source format");
    } else if (!SDL_SupportedAudioFormat(dst_fmt)) {
        return SDL_SetError("Invalid destination format");
    } else if (!SDL_SupportedChannelCount(src_channels)) {
        return SDL_SetError("Invalid source channels");
    } else if (!SDL_SupportedChannelCount(dst_channels)) {
        return SDL_SetError("Invalid destination channels");
    } else if (src_rate == 0) {
        return SDL_SetError("Source rate is zero");
    } else if (dst_rate == 0) {
        return SDL_SetError("Destination rate is zero");
    }
#if 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;
    SDL_zero(cvt->filters);
    cvt->len_mult = 1;
    cvt->len_ratio = 1.0;
    cvt->rate_incr = ((double) dst_rate) / ((double) src_rate);
    /* Make sure we've chosen audio conversion functions (MMX, scalar, etc.) */
    SDL_ChooseAudioConverters();
    /* Type conversion goes like this now:
        - byteswap to CPU native format first if necessary.
        - convert to native Float32 if necessary.
        - resample and change channel count if necessary.
        - convert back to native format.
        - byteswap back to foreign format if necessary.
       The expectation is we can process data faster in float32
       (possibly with SIMD), and making several passes over the same
       buffer is likely to be CPU cache-friendly, avoiding the
       biggest performance hit in modern times. Previously we had
       (script-generated) custom converters for every data type and
       it was a bloat on SDL compile times and final library size. */
    /* see if we can skip float conversion entirely. */
    if (src_rate == dst_rate && src_channels == dst_channels) {
        if (src_fmt == dst_fmt) {
            return 0;
        }
        /* just a byteswap needed? */
        if ((src_fmt & ~SDL_AUDIO_MASK_ENDIAN) == (dst_fmt & ~SDL_AUDIO_MASK_ENDIAN)) {
            if (SDL_AddAudioCVTFilter(cvt, SDL_Convert_Byteswap) < 0) {
                return -1;
            }
            cvt->needed = 1;
            return 1;
        }
    }
    /* Convert data types, if necessary. Updates (cvt). */
    if (SDL_BuildAudioTypeCVTToFloat(cvt, src_fmt) < 0) {
        return -1;              /* shouldn't happen, but just in case... */
    }
    /* Channel conversion */
    if (src_channels < dst_channels) {
        /* Upmixing */
        /* Mono -> Stereo [-> ...] */
        if ((src_channels == 1) && (dst_channels > 1)) {
            if (SDL_AddAudioCVTFilter(cvt, SDL_ConvertMonoToStereo) < 0) {
                return -1;
            }
            cvt->len_mult *= 2;
            src_channels = 2;
            cvt->len_ratio *= 2;
        }
        /* [Mono ->] Stereo -> 5.1 [-> 7.1] */
        if ((src_channels == 2) && (dst_channels >= 6)) {
            if (SDL_AddAudioCVTFilter(cvt, SDL_ConvertStereoTo51) < 0) {
                return -1;
            }
            src_channels = 6;
            cvt->len_mult *= 3;
            cvt->len_ratio *= 3;
        }
        /* Quad -> 5.1 [-> 7.1] */
        if ((src_channels == 4) && (dst_channels >= 6)) {
            if (SDL_AddAudioCVTFilter(cvt, SDL_ConvertQuadTo51) < 0) {
                return -1;
            }
            src_channels = 6;
            cvt->len_mult = (cvt->len_mult * 3 + 1) / 2;
            cvt->len_ratio *= 1.5;
        }
        /* [[Mono ->] Stereo ->] 5.1 -> 7.1 */
        if ((src_channels == 6) && (dst_channels == 8)) {
            if (SDL_AddAudioCVTFilter(cvt, SDL_Convert51To71) < 0) {
                return -1;
            }
            src_channels = 8;
            cvt->len_mult = (cvt->len_mult * 4 + 2) / 3;
            /* Should be numerically exact with every valid input to this
               function */
            cvt->len_ratio = cvt->len_ratio * 4 / 3;
        }
        /* [Mono ->] Stereo -> Quad */
        if ((src_channels == 2) && (dst_channels == 4)) {
            if (SDL_AddAudioCVTFilter(cvt, SDL_ConvertStereoToQuad) < 0) {
                return -1;
            }
            src_channels = 4;
            cvt->len_mult *= 2;
            cvt->len_ratio *= 2;
        }
    } else if (src_channels > dst_channels) {
        /* Downmixing */
        /* 7.1 -> 5.1 [-> Stereo [-> Mono]] */
        /* 7.1 -> 5.1 [-> Quad] */
        if ((src_channels == 8) && (dst_channels <= 6)) {
            if (SDL_AddAudioCVTFilter(cvt, SDL_Convert71To51) < 0) {
                return -1;
            }
            src_channels = 6;
            cvt->len_ratio *= 0.75;
        }
        /* [7.1 ->] 5.1 -> Stereo [-> Mono] */
        if ((src_channels == 6) && (dst_channels <= 2)) {
            if (SDL_AddAudioCVTFilter(cvt, SDL_Convert51ToStereo) < 0) {
                return -1;
            }
            src_channels = 2;
            cvt->len_ratio /= 3;
        }
        /* 5.1 -> Quad */
        if ((src_channels == 6) && (dst_channels == 4)) {
            if (SDL_AddAudioCVTFilter(cvt, SDL_Convert51ToQuad) < 0) {
                return -1;
            }
            src_channels = 4;
            cvt->len_ratio = cvt->len_ratio * 2 / 3;
        }
        /* Quad -> Stereo [-> Mono] */
        if ((src_channels == 4) && (dst_channels <= 2)) {
            if (SDL_AddAudioCVTFilter(cvt, SDL_ConvertQuadToStereo) < 0) {
                return -1;
            }
            src_channels = 2;
            cvt->len_ratio /= 2;
        }
        /* [... ->] Stereo -> Mono */
        if ((src_channels == 2) && (dst_channels == 1)) {
            SDL_AudioFilter filter = NULL;
            #if HAVE_SSE3_INTRINSICS
            if (SDL_HasSSE3()) {
                filter = SDL_ConvertStereoToMono_SSE3;
            }
            #endif
            if (!filter) {
                filter = SDL_ConvertStereoToMono;
            }
            if (SDL_AddAudioCVTFilter(cvt, filter) < 0) {
                return -1;
            }
            src_channels = 1;
            cvt->len_ratio /= 2;
        }
    }
    if (src_channels != dst_channels) {
        /* All combinations of supported channel counts should have been
           handled by now, but let's be defensive */
      return SDL_SetError("Invalid channel combination");
    }
    
    /* Do rate conversion, if necessary. Updates (cvt). */
    if (SDL_BuildAudioResampleCVT(cvt, dst_channels, src_rate, dst_rate) < 0) {
        return -1;              /* shouldn't happen, but just in case... */
    }
    /* Move to final data type. */
    if (SDL_BuildAudioTypeCVTFromFloat(cvt, dst_fmt) < 0) {
        return -1;              /* shouldn't happen, but just in case... */
    }
    cvt->needed = (cvt->filter_index != 0);
    return (cvt->needed);
}

static int SDL_BuildAudioResampleCVT	(	SDL_AudioCVT *	cvt,
		const int	dst_channels,
		const int	src_rate,
		const int	dst_rate
	)

static

Definition at line 776 of file SDL_audiocvt.c.

References ChooseCVTResampler(), SDL_AudioCVT::filter_index, SDL_AudioCVT::filters, SDL_AudioCVT::len_mult, SDL_AudioCVT::len_ratio, NULL, SDL_AddAudioCVTFilter(), SDL_AUDIOCVT_MAX_FILTERS, SDL_ceil, SDL_PrepareResampleFilter(), and SDL_SetError.

SDL_AudioStream* SDL_NewAudioStream	(	const SDL_AudioFormat	src_format,
		const Uint8	src_channels,
		const int	src_rate,
		const SDL_AudioFormat	dst_format,
		const Uint8	dst_channels,
		const int	dst_rate
	)

src_format	The format of the source audio
src_channels	The number of channels of the source audio
src_rate	The sampling rate of the source audio
dst_format	The format of the desired audio output
dst_channels	The number of channels of the desired audio output
dst_rate	The sampling rate of the desired audio output

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Function Documentation

Variable Documentation