|
SDL_sound unknown version (build with 'make docs' next time!)
|
#include <SDL3/SDL.h>Go to the source code of this file.
Data Structures | |
| struct | Sound_AudioInfo |
| Information about an existing sample's format. More... | |
| struct | Sound_DecoderInfo |
| Information about available soudn decoders. More... | |
| struct | Sound_Sample |
| Represents sound data in the process of being decoded. More... | |
| struct | Sound_Version |
| Information the version of SDL_sound in use. More... | |
Macros | |
| #define | SOUND_VERSION(x) |
| Macro to determine SDL_sound version program was compiled against. | |
Enumerations | |
| enum | Sound_SampleFlags { SOUND_SAMPLEFLAG_NONE = 0 , SOUND_SAMPLEFLAG_CANSEEK = 1 , SOUND_SAMPLEFLAG_EOF = 1 << 29 , SOUND_SAMPLEFLAG_ERROR = 1 << 30 , SOUND_SAMPLEFLAG_EAGAIN = 1 << 31 } |
| Flags that are used in a Sound_Sample to show various states. More... | |
Functions | |
| void | Sound_GetLinkedVersion (Sound_Version *ver) |
| Get the version of SDL_sound that is linked against your program. | |
| int | Sound_Init (void) |
| Initialize SDL_sound. | |
| int | Sound_Quit (void) |
| Shutdown SDL_sound. | |
| const Sound_DecoderInfo ** | Sound_AvailableDecoders (void) |
| Get a list of sound formats supported by this version of SDL_sound. | |
| const char * | Sound_GetError (void) |
| Get the last SDL_sound error message as a null-terminated string. | |
| void | Sound_ClearError (void) |
| Clear the current error message. | |
| Sound_Sample * | Sound_NewSample (SDL_IOStream *rw, const char *ext, Sound_AudioInfo *desired, Uint32 bufferSize) |
| Sound_Sample * | Sound_NewSampleFromMem (const Uint8 *data, Uint32 size, const char *ext, Sound_AudioInfo *desired, Uint32 bufferSize) |
| Start decoding a new sound sample from a file on disk. | |
| Sound_Sample * | Sound_NewSampleFromFile (const char *fname, Sound_AudioInfo *desired, Uint32 bufferSize) |
| Start decoding a new sound sample from a file on disk. | |
| void | Sound_FreeSample (Sound_Sample *sample) |
| Dispose of a Sound_Sample. | |
| Sint32 | Sound_GetDuration (Sound_Sample *sample) |
| Retrieve total play time of sample, in milliseconds. | |
| int | Sound_SetBufferSize (Sound_Sample *sample, Uint32 new_size) |
| Change the current buffer size for a sample. | |
| Uint32 | Sound_Decode (Sound_Sample *sample) |
| Decode more of the sound data in a Sound_Sample. | |
| Uint32 | Sound_DecodeAll (Sound_Sample *sample) |
| Decode the remainder of the sound data in a Sound_Sample. | |
| int | Sound_Rewind (Sound_Sample *sample) |
| Rewind a sample to the start. | |
| int | Sound_Seek (Sound_Sample *sample, Uint32 ms) |
| Seek to a different point in a sample. | |
| #define SOUND_VERSION | ( | x | ) |
Macro to determine SDL_sound version program was compiled against.
This macro fills in a Sound_Version structure with the version of the library you compiled against. This is determined by what header the compiler uses. Note that if you dynamically linked the library, you might have a slightly newer or older version at runtime. That version can be determined with Sound_GetLinkedVersion(), which, unlike SOUND_VERSION, is not a macro.
| x | A pointer to a Sound_Version struct to initialize. |
| enum Sound_SampleFlags |
Flags that are used in a Sound_Sample to show various states.
To use:
| const Sound_DecoderInfo ** Sound_AvailableDecoders | ( | void | ) |
Get a list of sound formats supported by this version of SDL_sound.
This is for informational purposes only. Note that the extension listed is merely convention: if we list "MP3", you can open an MPEG-1 Layer 3 audio file with an extension of "XYZ", if you like. The file extensions are informational, and only required as a hint to choosing the correct decoder, since the sound data may not be coming from a file at all, thanks to the abstraction that an SDL_RWops provides.
The returned value is an array of pointers to Sound_DecoderInfo structures, with a NULL entry to signify the end of the list:
The return values are pointers to static internal memory, and should be considered READ ONLY, and never freed.
| void Sound_ClearError | ( | void | ) |
Clear the current error message.
The next call to Sound_GetError() after Sound_ClearError() will return NULL.
| Uint32 Sound_Decode | ( | Sound_Sample * | sample | ) |
Decode more of the sound data in a Sound_Sample.
It will decode at most sample->buffer_size bytes into sample->buffer in the desired format, and return the number of decoded bytes. If sample->buffer_size bytes could not be decoded, then please refer to sample->flags to determine if this was an end-of-stream or error condition.
| sample | Do more decoding to this Sound_Sample. |
| Uint32 Sound_DecodeAll | ( | Sound_Sample * | sample | ) |
Decode the remainder of the sound data in a Sound_Sample.
This will dynamically allocate memory for the ENTIRE remaining sample. sample->buffer_size and sample->buffer will be updated to reflect the new buffer. Please refer to sample->flags to determine if the decoding finished due to an End-of-stream or error condition.
Be aware that sound data can take a large amount of memory, and that this function may block for quite awhile while processing. Also note that a streaming source (for example, from a SDL_RWops that is getting fed from an Internet radio feed that doesn't end) may fill all available memory before giving up...be sure to use this on finite sound sources only!
When decoding the sample in its entirety, the work is done one buffer at a time. That is, sound is decoded in sample->buffer_size blocks, and appended to a continually-growing buffer until the decoding completes. That means that this function will need enough RAM to hold approximately sample->buffer_size bytes plus the complete decoded sample at most. The larger your buffer size, the less overhead this function needs, but beware the possibility of paging to disk. Best to make this user-configurable if the sample isn't specific and small.
| sample | Do all decoding for this Sound_Sample. |
| void Sound_FreeSample | ( | Sound_Sample * | sample | ) |
Dispose of a Sound_Sample.
This will also close/dispose of the SDL_RWops that was used at creation time, so there's no need to keep a reference to that around. The Sound_Sample pointer is invalid after this call, and will almost certainly result in a crash if you attempt to keep using it.
| sample | The Sound_Sample to delete. |
| Sint32 Sound_GetDuration | ( | Sound_Sample * | sample | ) |
Retrieve total play time of sample, in milliseconds.
Report total time length of sample, in milliseconds. This is a fast call. Duration is calculated during Sound_NewSample*, so this is just an accessor into otherwise opaque data.
Please note that not all formats can determine a total time, some can't be exact without fully decoding the data, and thus will estimate the duration. Many decoders will require the ability to seek in the data stream to calculate this, so even if we can tell you how long an .ogg file will be, the same data set may fail if it's, say, streamed over an HTTP connection. Plan accordingly.
Most people won't need this function to just decode and playback, but it can be useful for informational purposes in, say, a music player's UI.
| sample | Sound_Sample from which to retrieve duration information. |
| const char * Sound_GetError | ( | void | ) |
Get the last SDL_sound error message as a null-terminated string.
This will be NULL if there's been no error since the last call to this function. The pointer returned by this call points to an internal buffer, and should not be deallocated. Each thread has a unique error state associated with it, but each time a new error message is set, it will overwrite the previous one associated with that thread. It is safe to call this function at anytime, even before Sound_Init().
| void Sound_GetLinkedVersion | ( | Sound_Version * | ver | ) |
Get the version of SDL_sound that is linked against your program.
If you are using a shared library (DLL) version of SDL_sound, then it is possible that it will be different than the version you compiled against.
This is a real function; the macro SOUND_VERSION tells you what version of SDL_sound you compiled against:
This function may be called safely at any time, even before Sound_Init().
| ver | Sound_Version structure to fill with shared library's version. |
| Sound_Init | ( | void | ) |
Initialize SDL_sound.
This must be called before any other SDL_sound function (except perhaps Sound_GetLinkedVersion()). You should call SDL_Init() before calling this. Sound_Init() will attempt to call SDL_Init(SDL_INIT_AUDIO), just in case. This is a safe behaviour, but it may not configure SDL to your liking by itself.
| Sound_Sample * Sound_NewSampleFromFile | ( | const char * | filename, |
| Sound_AudioInfo * | desired, | ||
| Uint32 | bufferSize ) |
Start decoding a new sound sample from a file on disk.
This is identical to Sound_NewSample(), but it creates an SDL_RWops for you from the file located in (filename). Note that (filename) is specified in platform-dependent notation. ("C:\\music\\mysong.mp3" on windows, and "/home/icculus/music/mysong.mp3" or whatever on Unix, etc.) Sound_NewSample()'s "ext" parameter is gleaned from the contents of (filename).
This can pool RWops structures, so it may fragment the heap less over time than using SDL_RWFromFile().
| filename | file containing sound data. |
| desired | Format to convert sound data into. Can usually be NULL, if you don't need conversion. |
| bufferSize | size, in bytes, of initial read buffer. |
| Sound_Sample * Sound_NewSampleFromMem | ( | const Uint8 * | data, |
| Uint32 | size, | ||
| const char * | ext, | ||
| Sound_AudioInfo * | desired, | ||
| Uint32 | bufferSize ) |
Start decoding a new sound sample from a file on disk.
This is identical to Sound_NewSample(), but it creates an SDL_RWops for you from the (size) bytes of memory referenced by (data).
This can pool RWops structures, so it may fragment the heap less over time than using SDL_RWFromMem().
| data | Buffer of data holding contents of an audio file to decode. |
| size | Size, in bytes, of buffer pointed to by (data). |
| ext | File extension normally associated with a data format. Can usually be NULL. |
| desired | Format to convert sound data into. Can usually be NULL, if you don't need conversion. |
| bufferSize | size, in bytes, of initial read buffer. |
| Sound_Quit | ( | void | ) |
Shutdown SDL_sound.
This closes any SDL_RWops that were being used as sound sources, and frees any resources in use by SDL_sound.
All Sound_Sample pointers you had prior to this call are INVALIDATED.
Once successfully deinitialized, Sound_Init() can be called again to restart the subsystem. All default API states are restored at this point.
You should call this BEFORE SDL_Quit(). This will NOT call SDL_Quit() for you!
| int Sound_Rewind | ( | Sound_Sample * | sample | ) |
Rewind a sample to the start.
Restart a sample at the start of its waveform data, as if newly created with Sound_NewSample(). If successful, the next call to Sound_Decode[All]() will give audio data from the earliest point in the stream.
Beware that this function will fail if the SDL_RWops that feeds the decoder can not be rewound via it's seek method, but this can theoretically be avoided by wrapping it in some sort of buffering SDL_RWops.
This function should ONLY fail if the RWops is not seekable, or SDL_sound is not initialized. Both can be controlled by the application, and thus, it is up to the developer's paranoia to dictate whether this function's return value need be checked at all.
If this function fails, the state of the sample is undefined, but it is still safe to call Sound_FreeSample() to dispose of it.
On success, ERROR, EOF, and EAGAIN are cleared from sample->flags. The ERROR flag is set on error.
| sample | The Sound_Sample to rewind. |
| int Sound_Seek | ( | Sound_Sample * | sample, |
| Uint32 | ms ) |
Seek to a different point in a sample.
Reposition a sample's stream. If successful, the next call to Sound_Decode[All]() will give audio data from the offset you specified.
The offset is specified in milliseconds from the start of the sample.
Beware that this function can fail for several reasons. If the SDL_RWops that feeds the decoder can not seek, this call will almost certainly fail, but this can theoretically be avoided by wrapping it in some sort of buffering SDL_RWops. Some decoders can never seek, others can only seek with certain files. The decoders will set a flag in the sample at creation time to help you determine this.
You should check sample->flags & SOUND_SAMPLEFLAG_CANSEEK before attempting. Sound_Seek() reports failure immediately if this flag isn't set. This function can still fail for other reasons if the flag is set.
This function can be emulated in the application with Sound_Rewind() and predecoding a specific amount of the sample, but this can be extremely inefficient. Sound_Seek() accelerates the seek with decoder-specific code.
If this function fails, the sample should continue to function as if this call was never made. If there was an unrecoverable error, sample->flags & SOUND_SAMPLEFLAG_ERROR will be set, which you regular decoding loop can pick up.
On success, ERROR, EOF, and EAGAIN are cleared from sample->flags.
| sample | The Sound_Sample to seek. |
| ms | The new position, in milliseconds from start of sample. |
| int Sound_SetBufferSize | ( | Sound_Sample * | sample, |
| Uint32 | new_size ) |
Change the current buffer size for a sample.
If the buffer size could be changed, then the sample->buffer and sample->buffer_size fields will reflect that. If they could not be changed, then your original sample state is preserved. If the buffer is shrinking, the data at the end of buffer is truncated. If the buffer is growing, the contents of the new space at the end is undefined until you decode more into it or initialize it yourself.
The buffer size specified must be a multiple of the size of a single sample point. So, if you want 16-bit, stereo samples, then your sample point size is (2 channels * 16 bits), or 32 bits per sample, which is four bytes. In such a case, you could specify 128 or 132 bytes for a buffer, but not 129, 130, or 131 (although in reality, you'll want to specify a MUCH larger buffer).
| sample | The Sound_Sample whose buffer to modify. |
| new_size | The desired size, in bytes, of the new buffer. |
1.10.0