{

/* This is a block of info about your decoder. See SDL_sound.h. */

const Sound_DecoderInfo info;

/*

* Returns non-zero if (sample) has a valid fileformat that this

* driver can handle. Zero if this driver can NOT handle the data.

*

* Extension, which may be NULL, is just a hint as to the form of

* data that is being passed in. Most decoders should determine if

* they can handle the data by the data itself, but others, like

* the raw data handler, need this hint to know if they should

* accept the data in the first place.

*

* (sample)'s (opaque) field should be cast to a Sound_SampleInternal

* pointer:

*

* Sound_SampleInternal *internal;

* internal = (Sound_SampleInternal *) sample->opaque;

*

* Certain fields of sample will be filled in for the decoder before

* this call, and others should be filled in by the decoder. Some

* fields are offlimits, and should NOT be modified. The list:

*

* in Sound_SampleInternal section:

* Sound_Sample *next; (offlimits)

* Sound_Sample *prev; (offlimits)

* SDL_RWops *rw; (can use, but do NOT close it)

* const Sound_DecoderFunctions *funcs; (that's this structure)

* SDL_AudioCVT sdlcvt; (offlimits)

* void *buffer; (offlimits until read() method)

* Uint32 buffer_size; (offlimits until read() method)

* void *decoder_private; (read and write access)

*

* in rest of Sound_Sample:

* void *opaque; (this was internal section, above)

* const Sound_DecoderInfo *decoder; (read only)

* Sound_AudioInfo desired; (read only, usually not needed here)

* Sound_AudioInfo actual; (please fill this in)

* void *buffer; (offlimits)

* Uint32 buffer_size; (offlimits)

* Sound_SampleFlags flags; (set appropriately)

*/

int (*open)(Sound_Sample *sample, const char *ext);

/*

* Clean up. SDL_sound is done with this sample, so the decoder should

* clean up any resources it allocated. Anything that wasn't

* explicitly allocated by the decoder should be LEFT ALONE, since

* the higher-level SDL_sound layer will clean up its own mess.

*/

void (*close)(Sound_Sample *sample);

/*

* Get more data from (sample). The decoder should get a pointer to

* the internal structure...

*

* Sound_SampleInternal *internal;

* internal = (Sound_SampleInternal *) sample->opaque;

*

* ...and then start decoding. Fill in up to internal->buffer_size

* bytes of decoded sound in the space pointed to by

* internal->buffer. The encoded data is read in from internal->rw.

* Data should be decoded in the format specified during the

* decoder's open() method in the sample->actual field. The

* conversion to the desired format is done at a higher level.

*

* The return value is the number of bytes decoded into

* internal->buffer, which can be no more than internal->buffer_size,

* but can be less. If it is less, you should set a state flag:

*

* If there's just no more data (end of file, etc), then do:

* sample->flags |= SOUND_SAMPLEFLAG_EOF;

*

* If there's an unrecoverable error, then do:

* Sound_SetError(ERR_EXPLAIN_WHAT_WENT_WRONG);

* sample->flags |= SOUND_SAMPLEFLAG_ERROR;

*

* If there's more data, but you'd have to block for considerable

* amounts of time to get at it, or there's a recoverable error,

* then do:

* Sound_SetError(ERR_EXPLAIN_WHAT_WENT_WRONG);

* sample->flags |= SOUND_SAMPLEFLAG_EAGAIN;

*

* SDL_sound will not call your read() method for any samples with

* SOUND_SAMPLEFLAG_EOF or SOUND_SAMPLEFLAG_ERROR set. The

* SOUND_SAMPLEFLAG_EAGAIN flag is reset before each call to this

* method.

*/

Uint32 (*read)(Sound_Sample *sample);

{

Sound_Sample *next;

Sound_Sample *prev;

SDL_RWops *rw;

const Sound_DecoderFunctions *funcs;

SDL_AudioCVT sdlcvt;

void *buffer;

Uint32 buffer_size;

void *decoder_private;