|
SDL_sound
1.0.1
|
#include "SDL.h"#include "SDL_endian.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... | |
Defines | |
| #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_RWops *rw, const char *ext, Sound_AudioInfo *desired, Uint32 bufferSize) |
| Start decoding a new sound sample. | |
| 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. | |
| 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 | ) |
{ \
(x)->major = SOUND_VER_MAJOR; \
(x)->minor = SOUND_VER_MINOR; \
(x)->patch = SOUND_VER_PATCH; \
}
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:
if (sample->flags & SOUND_SAMPLEFLAG_ERROR) { dosomething(); }
| 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:
Sound_DecoderInfo **i; for (i = Sound_AvailableDecoders(); *i != NULL; i++) { printf("Supported sound format: [%s], which is [%s].\n", i->extension, i->description); // ...and other fields... }
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. |
| 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:
Sound_Version compiled; Sound_Version linked; SOUND_VERSION(&compiled); Sound_GetLinkedVersion(&linked); printf("We compiled against SDL_sound version %d.%d.%d ...\n", compiled.major, compiled.minor, compiled.patch); printf("But we linked against SDL_sound version %d.%d.%d.\n", linked.major, linked.minor, linked.patch);
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_NewSample | ( | SDL_RWops * | rw, |
| const char * | ext, | ||
| Sound_AudioInfo * | desired, | ||
| Uint32 | bufferSize | ||
| ) |
Start decoding a new sound sample.
The data is read via an SDL_RWops structure (see SDL_rwops.h in the SDL include directory), so it may be coming from memory, disk, network stream, etc. The (ext) parameter is merely a hint to determining the correct decoder; if you specify, for example, "mp3" for an extension, and one of the decoders lists that as a handled extension, then that decoder is given first shot at trying to claim the data for decoding. If none of the extensions match (or the extension is NULL), then every decoder examines the data to determine if it can handle it, until one accepts it. In such a case your SDL_RWops will need to be capable of rewinding to the start of the stream.
If no decoders can handle the data, a NULL value is returned, and a human readable error message can be fetched from Sound_GetError().
Optionally, a desired audio format can be specified. If the incoming data is in a different format, SDL_sound will convert it to the desired format on the fly. Note that this can be an expensive operation, so it may be wise to convert data before you need to play it back, if possible, or make sure your data is initially in the format that you need it in. If you don't want to convert the data, you can specify NULL for a desired format. The incoming format of the data, preconversion, can be found in the Sound_Sample structure.
Note that the raw sound data "decoder" needs you to specify both the extension "RAW" and a "desired" format, or it will refuse to handle the data. This is to prevent it from catching all formats unsupported by the other decoders.
Finally, specify an initial buffer size; this is the number of bytes that will be allocated to store each read from the sound buffer. The more you can safely allocate, the more decoding can be done in one block, but the more resources you have to use up, and the longer each decoding call will take. Note that different data formats require more or less space to store. This buffer can be resized via Sound_SetBufferSize() ...
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).
When you are done with this Sound_Sample pointer, you can dispose of it via Sound_FreeSample().
You do not have to keep a reference to (rw) around. If this function suceeds, it stores (rw) internally (and disposes of it during the call to Sound_FreeSample()). If this function fails, it will dispose of the SDL_RWops for you.
| rw | SDL_RWops with sound 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, to allocate for the decoding buffer. |
| 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).
| 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_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 on a 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.7.6.1