#include "../SDL_internal.h"
#include "SDL.h"
#include "SDL_audio.h"
#include "SDL_audio_c.h"
#include "SDL_loadso.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

◆ CASESWAP

#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; \
            }

◆ DEBUG_AUDIOSTREAM

#define DEBUG_AUDIOSTREAM 0

Definition at line 36 of file SDL_audiocvt.c.

◆ RESAMPLER_BITS_PER_SAMPLE

#define RESAMPLER_BITS_PER_SAMPLE 16

Definition at line 380 of file SDL_audiocvt.c.

◆ RESAMPLER_FILTER_SIZE

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

Definition at line 382 of file SDL_audiocvt.c.

◆ RESAMPLER_FUNCS

#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 753 of file SDL_audiocvt.c.

◆ RESAMPLER_SAMPLES_PER_ZERO_CROSSING

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

Definition at line 381 of file SDL_audiocvt.c.

◆ RESAMPLER_ZERO_CROSSINGS

#define RESAMPLER_ZERO_CROSSINGS 5

Definition at line 379 of file SDL_audiocvt.c.

Typedef Documentation

◆ SDL_CleanupAudioStreamResamplerFunc

typedef void(* SDL_CleanupAudioStreamResamplerFunc) (SDL_AudioStream *stream)

Definition at line 1090 of file SDL_audiocvt.c.

◆ SDL_ResampleAudioStreamFunc

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

Definition at line 1088 of file SDL_audiocvt.c.

◆ SDL_ResetAudioStreamResamplerFunc

typedef void(* SDL_ResetAudioStreamResamplerFunc) (SDL_AudioStream *stream)

Definition at line 1089 of file SDL_audiocvt.c.

Function Documentation

◆ bessel()

static double bessel ( const double x )

static

Definition at line 386 of file SDL_audiocvt.c.

 {
     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;
 }

References i, SDL_pow, and SDL_TRUE.

Referenced by kaiser_and_sinc().

◆ ChooseCVTResampler()

static SDL_AudioFilter ChooseCVTResampler ( const int dst_channels )

static

Definition at line 766 of file SDL_audiocvt.c.

 {
     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;
 }

References NULL.

Referenced by SDL_BuildAudioResampleCVT().

◆ EnsureStreamBufferSize()

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

static

Definition at line 1123 of file SDL_audiocvt.c.

 {
     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;
 }

References NULL, ptr, SDL_OutOfMemory, and SDL_realloc.

Referenced by SDL_AudioStreamPutInternal().

◆ kaiser_and_sinc()

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

static

Definition at line 408 of file SDL_audiocvt.c.

 {
     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;
 }

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

Referenced by SDL_PrepareResampleFilter().

◆ ResamplerPadding()

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

static

Definition at line 472 of file SDL_audiocvt.c.

 {
     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;
 }

References RESAMPLER_SAMPLES_PER_ZERO_CROSSING, and SDL_ceil.

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

◆ SDL_AddAudioCVTFilter()

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

static

Definition at line 600 of file SDL_audiocvt.c.

 {
     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;
 }

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().

◆ SDL_AudioStreamAvailable()

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 1645 of file SDL_audiocvt.c.

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

References int(), and SDL_CountDataQueue().

◆ SDL_AudioStreamClear()

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 1651 of file SDL_audiocvt.c.

 {
     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;
     }
 }

References SDL_ClearDataQueue(), SDL_InvalidParamError, and SDL_TRUE.

◆ SDL_AudioStreamFlush()

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 1570 of file SDL_audiocvt.c.

 {
     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;
 }

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

◆ SDL_AudioStreamGet()

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 1624 of file SDL_audiocvt.c.

 {
     #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);
 }

References SDL_InvalidParamError, SDL_ReadFromDataQueue(), and SDL_SetError.

◆ SDL_AudioStreamPut()

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 1506 of file SDL_audiocvt.c.

 {
     /* !!! 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;
 }

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

◆ SDL_AudioStreamPutInternal()

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

static

Definition at line 1377 of file SDL_audiocvt.c.

 {
     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;
 }

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

Referenced by SDL_AudioStreamFlush(), and SDL_AudioStreamPut().

◆ SDL_BuildAudioCVT()

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 877 of file SDL_audiocvt.c.

 {
     /* 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 equal to or less than zero");
     } else if (dst_rate <= 0) {
         return SDL_SetError("Destination rate is equal to or less than zero");
     } else if (src_rate >= SDL_MAX_SINT32 / RESAMPLER_SAMPLES_PER_ZERO_CROSSING) {
         return SDL_SetError("Source rate is too high");
     } else if (dst_rate >= SDL_MAX_SINT32 / RESAMPLER_SAMPLES_PER_ZERO_CROSSING) {
         return SDL_SetError("Destination rate is too high");
     }
  
 #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_zeroa(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);
 }

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, RESAMPLER_SAMPLES_PER_ZERO_CROSSING, 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_MAX_SINT32, SDL_SetError, SDL_SupportedAudioFormat(), SDL_SupportedChannelCount(), SDL_zeroa, SDL_zerop, and SDL_AudioCVT::src_format.

Referenced by SDL_NewAudioStream().

◆ SDL_BuildAudioResampleCVT()

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

static

Definition at line 781 of file SDL_audiocvt.c.

 {
     SDL_AudioFilter filter;
  
     if (src_rate == dst_rate) {
         return 0;  /* no conversion necessary. */
     }
  
     filter = ChooseCVTResampler(dst_channels);
     if (filter == NULL) {
         return SDL_SetError("No conversion available for these rates");
     }
  
     if (SDL_PrepareResampleFilter() < 0) {
         return -1;
     }
  
     /* Update (cvt) with filter details... */
     if (SDL_AddAudioCVTFilter(cvt, filter) < 0) {
         return -1;
     }
  
     /* !!! FIXME in 2.1: there are ten slots in the filter list, and the theoretical maximum we use is six (seven with NULL terminator).
        !!! FIXME in 2.1:   We need to store data for this resampler, because the cvt structure doesn't store the original sample rates,
        !!! FIXME in 2.1:   so we steal the ninth and tenth slot.  :( */
     if (cvt->filter_index >= (SDL_AUDIOCVT_MAX_FILTERS-2)) {
         return SDL_SetError("Too many filters needed for conversion, exceeded maximum of %d", SDL_AUDIOCVT_MAX_FILTERS-2);
     }
     cvt->filters[SDL_AUDIOCVT_MAX_FILTERS-1] = (SDL_AudioFilter) (size_t) src_rate;
     cvt->filters[SDL_AUDIOCVT_MAX_FILTERS] = (SDL_AudioFilter) (size_t) dst_rate;
  
     if (src_rate < dst_rate) {
         const double mult = ((double) dst_rate) / ((double) src_rate);
         cvt->len_mult *= (int) SDL_ceil(mult);
         cvt->len_ratio *= mult;
     } else {
         cvt->len_ratio /= ((double) src_rate) / ((double) dst_rate);
     }
  
     /* !!! FIXME: remove this if we can get the resampler to work in-place again. */
     /* the buffer is big enough to hold the destination now, but
        we need it large enough to hold a separate scratch buffer. */
     cvt->len_mult *= 2;
  
     return 1;               /* added a converter. */
 }

References ChooseCVTResampler(), SDL_AudioCVT::filter_index, SDL_AudioCVT::filters, int(), 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

◆ CASESWAP

◆ DEBUG_AUDIOSTREAM

◆ RESAMPLER_BITS_PER_SAMPLE

◆ RESAMPLER_FILTER_SIZE

◆ RESAMPLER_FUNCS

◆ RESAMPLER_SAMPLES_PER_ZERO_CROSSING

◆ RESAMPLER_ZERO_CROSSINGS

Typedef Documentation

◆ SDL_CleanupAudioStreamResamplerFunc

◆ SDL_ResampleAudioStreamFunc

◆ SDL_ResetAudioStreamResamplerFunc

Function Documentation

◆ bessel()

◆ ChooseCVTResampler()

◆ EnsureStreamBufferSize()

◆ kaiser_and_sinc()

◆ ResamplerPadding()

◆ SDL_AddAudioCVTFilter()

◆ SDL_AudioStreamAvailable()

◆ SDL_AudioStreamClear()

◆ SDL_AudioStreamFlush()

◆ SDL_AudioStreamGet()

◆ SDL_AudioStreamPut()

◆ SDL_AudioStreamPutInternal()

◆ SDL_BuildAudioCVT()

◆ SDL_BuildAudioResampleCVT()

◆ SDL_BuildAudioTypeCVTFromFloat()

◆ SDL_BuildAudioTypeCVTToFloat()

◆ SDL_CleanupAudioStreamResampler()

◆ SDL_Convert51To71()

◆ SDL_Convert51ToQuad()

◆ SDL_Convert51ToStereo()

◆ SDL_Convert71To51()

◆ SDL_Convert_Byteswap()

◆ SDL_ConvertAudio()

◆ SDL_ConvertMonoToStereo()

◆ SDL_ConvertQuadTo51()

◆ SDL_ConvertQuadToStereo()

◆ SDL_ConvertStereoTo51()

◆ SDL_ConvertStereoToMono()

◆ SDL_ConvertStereoToQuad()

◆ SDL_FreeAudioStream()

◆ SDL_FreeResampleFilter()

◆ SDL_NewAudioStream()

◆ SDL_PrepareResampleFilter()

◆ SDL_ResampleAudio()

◆ SDL_ResampleAudioStream()

◆ SDL_ResampleCVT()

◆ SDL_ResetAudioStreamResampler()

◆ SDL_SupportedAudioFormat()

◆ SDL_SupportedChannelCount()

Variable Documentation

◆ ResampleFilterSpinlock

◆ ResamplerFilter

◆ ResamplerFilterDifference