#****************************************************************************** # Copy of SDL_Mixer without smpeg dependency and mp3 support #****************************************************************************** import sdl when defined(windows): const SDL_MixerLibName = "SDL_mixer.dll" elif defined(macosx): const SDL_MixerLibName = "libSDL_mixer-1.2.0.dylib" else: const SDL_MixerLibName = "libSDL_mixer.so" const SDL_MIXER_MAJOR_VERSION* = 1'i8 SDL_MIXER_MINOR_VERSION* = 2'i8 SDL_MIXER_PATCHLEVEL* = 7'i8 # Backwards compatibility MIX_MAJOR_VERSION* = SDL_MIXER_MAJOR_VERSION MIX_MINOR_VERSION* = SDL_MIXER_MINOR_VERSION MIX_PATCHLEVEL* = SDL_MIXER_PATCHLEVEL # SDL_Mixer.h constants # The default mixer has 8 simultaneous mixing channels MIX_CHANNELS* = 8 # Good default values for a PC soundcard MIX_DEFAULT_FREQUENCY* = 22050 when defined(IA32): const MIX_DEFAULT_FORMAT* = AUDIO_S16LSB else: const MIX_DEFAULT_FORMAT* = AUDIO_S16MSB const MIX_DEFAULT_CHANNELS* = 2 MIX_MAX_VOLUME* = 128 # Volume of a chunk PATH_MAX* = 255 # mikmod.h constants #* # * Library version # * LIBMIKMOD_VERSION_MAJOR* = 3 LIBMIKMOD_VERSION_MINOR* = 1 LIBMIKMOD_REVISION* = 8 LIBMIKMOD_VERSION* = ((LIBMIKMOD_VERSION_MAJOR shl 16) or (LIBMIKMOD_VERSION_MINOR shl 8) or (LIBMIKMOD_REVISION)) type #music_cmd.h types PMusicCMD* = ptr TMusicCMD TMusicCMD*{.final.} = object #wavestream.h types filename*: array[0..PATH_MAX - 1, char] cmd*: array[0..PATH_MAX - 1, char] pid*: TSYS_ThreadHandle PWAVStream* = ptr TWAVStream TWAVStream*{.final.} = object #playmidi.h types wavefp*: Pointer start*: int32 stop*: int32 cvt*: TSDL_AudioCVT PMidiEvent* = ptr TMidiEvent TMidiEvent*{.final.} = object time*: int32 channel*: uint8 typ*: uint8 a*: uint8 b*: uint8 PMidiSong* = ptr TMidiSong TMidiSong*{.final.} = object #music_ogg.h types samples*: int32 events*: PMidiEvent POGG_Music* = ptr TOGG_Music TOGG_Music*{.final.} = object # mikmod.h types #* # * Error codes # * playing*: int volume*: int #vf: OggVorbis_File; section*: int cvt*: TSDL_AudioCVT len_available*: int snd_available*: PUint8 TErrorEnum* = enum MMERR_OPENING_FILE, MMERR_OUT_OF_MEMORY, MMERR_DYNAMIC_LINKING, MMERR_SAMPLE_TOO_BIG, MMERR_OUT_OF_HANDLES, MMERR_UNKNOWN_WAVE_TYPE, MMERR_LOADING_PATTERN, MMERR_LOADING_TRACK, MMERR_LOADING_HEADER, MMERR_LOADING_SAMPLEINFO, MMERR_NOT_A_MODULE, MMERR_NOT_A_STREAM, MMERR_MED_SYNTHSAMPLES, MMERR_ITPACK_INVALID_DATA, MMERR_DETECTING_DEVICE, MMERR_INVALID_DEVICE, MMERR_INITIALIZING_MIXER, MMERR_OPENING_AUDIO, MMERR_8BIT_ONLY, MMERR_16BIT_ONLY, MMERR_STEREO_ONLY, MMERR_ULAW, MMERR_NON_BLOCK, MMERR_AF_AUDIO_PORT, MMERR_AIX_CONFIG_INIT, MMERR_AIX_CONFIG_CONTROL, MMERR_AIX_CONFIG_START, MMERR_GUS_SETTINGS, MMERR_GUS_RESET, MMERR_GUS_TIMER, MMERR_HP_SETSAMPLESIZE, MMERR_HP_SETSPEED, MMERR_HP_CHANNELS, MMERR_HP_AUDIO_OUTPUT, MMERR_HP_AUDIO_DESC, MMERR_HP_BUFFERSIZE, MMERR_OSS_SETFRAGMENT, MMERR_OSS_SETSAMPLESIZE, MMERR_OSS_SETSTEREO, MMERR_OSS_SETSPEED, MMERR_SGI_SPEED, MMERR_SGI_16BIT, MMERR_SGI_8BIT, MMERR_SGI_STEREO, MMERR_SGI_MONO, MMERR_SUN_INIT, MMERR_OS2_MIXSETUP, MMERR_OS2_SEMAPHORE, MMERR_OS2_TIMER, MMERR_OS2_THREAD, MMERR_DS_PRIORITY, MMERR_DS_BUFFER, MMERR_DS_FORMAT, MMERR_DS_NOTIFY, MMERR_DS_EVENT, MMERR_DS_THREAD, MMERR_DS_UPDATE, MMERR_WINMM_HANDLE, MMERR_WINMM_ALLOCATED, MMERR_WINMM_DEVICEID, MMERR_WINMM_FORMAT, MMERR_WINMM_UNKNOWN, MMERR_MAC_SPEED, MMERR_MAC_START, MMERR_MAX PMODULE* = ptr TMODULE TMODULE*{.final.} = object PUNIMOD* = ptr TUNIMOD TUNIMOD* = TMODULE #SDL_mixer.h types # The internal format for an audio chunk PMix_Chunk* = ptr TMix_Chunk TMix_Chunk*{.final.} = object allocated*: int abuf*: PUint8 alen*: Uint32 volume*: Uint8 # Per-sample volume, 0-128 Mix_Chunk* = TMix_Chunk # The different fading types supported TMix_Fading* = enum MIX_NO_FADING, MIX_FADING_OUT, MIX_FADING_IN Mix_Fading* = TMix_Fading TMix_MusicType* = enum MUS_NONE, MUS_CMD, MUS_WAV, MUS_MOD, MUS_MID, MUS_OGG PMix_Music* = ptr TMix_Music TMix_Music*{.final.} = object typ*: TMix_MusicType TMixFunction* = proc (udata: Pointer, stream: PUint8, length: int): Pointer{. cdecl.} # This macro can be used to fill a version structure with the compile-time # version of the SDL_mixer library. proc SDL_MIXER_VERSION*(X: var TSDL_Version) # This function gets the version of the dynamically linked SDL_mixer library. # It should NOT be used to fill a version structure, instead you should use the # SDL_MIXER_VERSION() macro. proc Mix_Linked_Version*(): PSDL_version{.cdecl, importc, dynlib: SDL_MixerLibName.} # Open the mixer with a certain audio format proc Mix_OpenAudio*(frequency: int, format: Uint16, channels: int, chunksize: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} # Dynamically change the number of channels managed by the mixer. # If decreasing the number of channels, the upper channels are # stopped. # This function returns the new number of allocated channels. # proc Mix_AllocateChannels*(numchannels: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} # Find out what the actual audio device parameters are. # This function returns 1 if the audio has been opened, 0 otherwise. # proc Mix_QuerySpec*(frequency: var int, format: var Uint16, channels: var int): int{. cdecl, importc, dynlib: SDL_MixerLibName.} # Load a wave file or a music (.mod .s3m .it .xm) file proc Mix_LoadWAV_RW*(src: PSDL_RWops, freesrc: int): PMix_Chunk{.cdecl, importc, dynlib: SDL_MixerLibName.} proc Mix_LoadWAV*(filename: cstring): PMix_Chunk proc Mix_LoadMUS*(filename: cstring): PMix_Music{.cdecl, importc, dynlib: SDL_MixerLibName.} # Load a wave file of the mixer format from a memory buffer proc Mix_QuickLoad_WAV*(mem: PUint8): PMix_Chunk{.cdecl, importc, dynlib: SDL_MixerLibName.} # Free an audio chunk previously loaded proc Mix_FreeChunk*(chunk: PMix_Chunk){.cdecl, importc, dynlib: SDL_MixerLibName.} proc Mix_FreeMusic*(music: PMix_Music){.cdecl, importc, dynlib: SDL_MixerLibName.} # Find out the music format of a mixer music, or the currently playing # music, if 'music' is NULL. proc Mix_GetMusicType*(music: PMix_Music): TMix_MusicType{.cdecl, importc, dynlib: SDL_MixerLibName.} # Set a function that is called after all mixing is performed. # This can be used to provide real-time visual display of the audio stream # or add a custom mixer filter for the stream data. # proc Mix_SetPostMix*(mix_func: TMixFunction, arg: Pointer){.cdecl, importc, dynlib: SDL_MixerLibName.} # Add your own music player or additional mixer function. # If 'mix_func' is NULL, the default music player is re-enabled. # proc Mix_HookMusic*(mix_func: TMixFunction, arg: Pointer){.cdecl, importc, dynlib: SDL_MixerLibName.} # Add your own callback when the music has finished playing. # proc Mix_HookMusicFinished*(music_finished: Pointer){.cdecl, importc, dynlib: SDL_MixerLibName.} # Get a pointer to the user data for the current music hook proc Mix_GetMusicHookData*(): Pointer{.cdecl, importc, dynlib: SDL_MixerLibName.} #* Add your own callback when a channel has finished playing. NULL # * to disable callback.* type TChannel_finished* = proc (channel: int){.cdecl.} proc Mix_ChannelFinished*(channel_finished: TChannel_finished){.cdecl, importc, dynlib: SDL_MixerLibName.} const MIX_CHANNEL_POST* = - 2 #* This is the format of a special effect callback: # * # * myeffect(int chan, void *stream, int len, void *udata); # * # * (chan) is the channel number that your effect is affecting. (stream) is # * the buffer of data to work upon. (len) is the size of (stream), and # * (udata) is a user-defined bit of data, which you pass as the last arg of # * Mix_RegisterEffect(), and is passed back unmolested to your callback. # * Your effect changes the contents of (stream) based on whatever parameters # * are significant, or just leaves it be, if you prefer. You can do whatever # * you like to the buffer, though, and it will continue in its changed state # * down the mixing pipeline, through any other effect functions, then finally # * to be mixed with the rest of the channels and music for the final output # * stream. # * type TMix_EffectFunc* = proc (chan: int, stream: Pointer, length: int, udata: Pointer): Pointer{.cdecl.} # * This is a callback that signifies that a channel has finished all its # * loops and has completed playback. This gets called if the buffer # * plays out normally, or if you call Mix_HaltChannel(), implicitly stop # * a channel via Mix_AllocateChannels(), or unregister a callback while # * it's still playing. TMix_EffectDone* = proc (chan: int, udata: Pointer): Pointer{.cdecl.} #* Register a special effect function. At mixing time, the channel data is # * copied into a buffer and passed through each registered effect function. # * After it passes through all the functions, it is mixed into the final # * output stream. The copy to buffer is performed once, then each effect # * function performs on the output of the previous effect. Understand that # * this extra copy to a buffer is not performed if there are no effects # * registered for a given chunk, which saves CPU cycles, and any given # * effect will be extra cycles, too, so it is crucial that your code run # * fast. Also note that the data that your function is given is in the # * format of the sound device, and not the format you gave to Mix_OpenAudio(), # * although they may in reality be the same. This is an unfortunate but # * necessary speed concern. Use Mix_QuerySpec() to determine if you can # * handle the data before you register your effect, and take appropriate # * actions. # * You may also specify a callback (Mix_EffectDone_t) that is called when # * the channel finishes playing. This gives you a more fine-grained control # * than Mix_ChannelFinished(), in case you need to free effect-specific # * resources, etc. If you don't need this, you can specify NULL. # * You may set the callbacks before or after calling Mix_PlayChannel(). # * Things like Mix_SetPanning() are just internal special effect functions, # * so if you are using that, you've already incurred the overhead of a copy # * to a separate buffer, and that these effects will be in the queue with # * any functions you've registered. The list of registered effects for a # * channel is reset when a chunk finishes playing, so you need to explicitly # * set them with each call to Mix_PlayChannel*(). # * You may also register a special effect function that is to be run after # * final mixing occurs. The rules for these callbacks are identical to those # * in Mix_RegisterEffect, but they are run after all the channels and the # * music have been mixed into a single stream, whereas channel-specific # * effects run on a given channel before any other mixing occurs. These # * global effect callbacks are call "posteffects". Posteffects only have # * their Mix_EffectDone_t function called when they are unregistered (since # * the main output stream is never "done" in the same sense as a channel). # * You must unregister them manually when you've had enough. Your callback # * will be told that the channel being mixed is (MIX_CHANNEL_POST) if the # * processing is considered a posteffect. # * # * After all these effects have finished processing, the callback registered # * through Mix_SetPostMix() runs, and then the stream goes to the audio # * device. # * # * returns zero if error (no such channel), nonzero if added. # * Error messages can be retrieved from Mix_GetError(). proc Mix_RegisterEffect*(chan: int, f: TMix_EffectFunc, d: TMix_EffectDone, arg: Pointer): int{.cdecl, importc, dynlib: SDL_MixerLibName.} #* You may not need to call this explicitly, unless you need to stop an # * effect from processing in the middle of a chunk's playback. # * Posteffects are never implicitly unregistered as they are for channels, # * but they may be explicitly unregistered through this function by # * specifying MIX_CHANNEL_POST for a channel. # * returns zero if error (no such channel or effect), nonzero if removed. # * Error messages can be retrieved from Mix_GetError(). # * proc Mix_UnregisterEffect*(channel: int, f: TMix_EffectFunc): int{.cdecl, importc, dynlib: SDL_MixerLibName.} #* You may not need to call this explicitly, unless you need to stop all # * effects from processing in the middle of a chunk's playback. Note that # * this will also shut off some internal effect processing, since # * Mix_SetPanning( ) and others may use this API under the hood.This is # * called internally when a channel completes playback. # * Posteffects are never implicitly unregistered as they are for channels, # * but they may be explicitly unregistered through this function by # * specifying MIX_CHANNEL_POST for a channel. # * returns zero if error( no such channel ), nonzero if all effects removed. # * Error messages can be retrieved from Mix_GetError( ). # * proc Mix_UnregisterAllEffects*(channel: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} const MIX_EFFECTSMAXSPEED* = "MIX_EFFECTSMAXSPEED" # * These are the internally - defined mixing effects.They use the same API that # * effects defined in the application use, but are provided here as a # * convenience.Some effects can reduce their quality or use more memory in # * the name of speed; to enable this, make sure the environment variable # * MIX_EFFECTSMAXSPEED( see above ) is defined before you call # * Mix_OpenAudio( ). # * #* set the panning of a channel.The left and right channels are specified # * as integers between 0 and 255, quietest to loudest, respectively. # * # * Technically, this is just individual volume control for a sample with # * two( stereo )channels, so it can be used for more than just panning. # * if you want real panning, call it like this : # * # * Mix_SetPanning( channel, left, 255 - left ); # * # * ...which isn't so hard. # * # * Setting( channel ) to MIX_CHANNEL_POST registers this as a posteffect, and # * the panning will be done to the final mixed stream before passing it on # * to the audio device. # * # * This uses the Mix_RegisterEffect( )API internally, and returns without # * registering the effect function if the audio device is not configured # * for stereo output.Setting both( left ) and ( right ) to 255 causes this # * effect to be unregistered, since that is the data's normal state. # * # * returns zero if error( no such channel or Mix_RegisterEffect( )fails ), # * nonzero if panning effect enabled.Note that an audio device in mono # * mode is a no - op, but this call will return successful in that case . # * Error messages can be retrieved from Mix_GetError( ). proc Mix_SetPanning*(channel: int, left: Uint8, right: Uint8): int{.cdecl, importc, dynlib: SDL_MixerLibName.} # * set the position ofa channel.( angle ) is an integer from 0 to 360, that # * specifies the location of the sound in relation to the listener.( angle ) # * will be reduced as neccesary( 540 becomes 180 degrees, -100 becomes 260 ). # * Angle 0 is due north, and rotates clockwise as the value increases. # * for efficiency, the precision of this effect may be limited( angles 1 # * through 7 might all produce the same effect, 8 through 15 are equal, etc ). # * ( distance ) is an integer between 0 and 255 that specifies the space # * between the sound and the listener.The larger the number, the further # * away the sound is .Using 255 does not guarantee that the channel will be # * culled from the mixing process or be completely silent.For efficiency, # * the precision of this effect may be limited( distance 0 through 5 might # * all produce the same effect, 6 through 10 are equal, etc ).Setting( angle ) # * and ( distance ) to 0 unregisters this effect, since the data would be # * unchanged. # * # * if you need more precise positional audio, consider using OpenAL for # * spatialized effects instead of SDL_mixer.This is only meant to be a # * basic effect for simple "3D" games. # * # * if the audio device is configured for mono output, then you won't get # * any effectiveness from the angle; however, distance attenuation on the # * channel will still occur.While this effect will function with stereo # * voices, it makes more sense to use voices with only one channel of sound, # * so when they are mixed through this effect, the positioning will sound # * correct.You can convert them to mono through SDL before giving them to # * the mixer in the first place if you like. # * # * Setting( channel ) to MIX_CHANNEL_POST registers this as a posteffect, and # * the positioning will be done to the final mixed stream before passing it # * on to the audio device. # * # * This is a convenience wrapper over Mix_SetDistance( ) and Mix_SetPanning( ). # * # * returns zero if error( no such channel or Mix_RegisterEffect( )fails ), # * nonzero if position effect is enabled. # * Error messages can be retrieved from Mix_GetError( ). # * proc Mix_SetPosition*(channel: int, angle: Sint16, distance: Uint8): int{.cdecl, importc, dynlib: SDL_MixerLibName.} #* set the "distance" of a channel.( distance ) is an integer from 0 to 255 # * that specifies the location of the sound in relation to the listener. # * Distance 0 is overlapping the listener, and 255 is as far away as possible # * A distance of 255 does not guarantee silence; in such a case , you might # * want to try changing the chunk's volume, or just cull the sample from the # * mixing process with Mix_HaltChannel( ). # * for efficiency, the precision of this effect may be limited( distances 1 # * through 7 might all produce the same effect, 8 through 15 are equal, etc ). # * ( distance ) is an integer between 0 and 255 that specifies the space # * between the sound and the listener.The larger the number, the further # * away the sound is . # * Setting( distance ) to 0 unregisters this effect, since the data would be # * unchanged. # * if you need more precise positional audio, consider using OpenAL for # * spatialized effects instead of SDL_mixer.This is only meant to be a # * basic effect for simple "3D" games. # * # * Setting( channel ) to MIX_CHANNEL_POST registers this as a posteffect, and # * the distance attenuation will be done to the final mixed stream before # * passing it on to the audio device. # * # * This uses the Mix_RegisterEffect( )API internally. # * # * returns zero if error( no such channel or Mix_RegisterEffect( )fails ), # * nonzero if position effect is enabled. # * Error messages can be retrieved from Mix_GetError( ). # * proc Mix_SetDistance*(channel: int, distance: Uint8): int{.cdecl, importc, dynlib: SDL_MixerLibName.} # * # * !!! FIXME : Haven't implemented, since the effect goes past the # * end of the sound buffer.Will have to think about this. # * - -ryan. # * / # { if 0 # { * Causes an echo effect to be mixed into a sound.( echo ) is the amount # * of echo to mix.0 is no echo, 255 is infinite( and probably not # * what you want ). # * # * Setting( channel ) to MIX_CHANNEL_POST registers this as a posteffect, and # * the reverbing will be done to the final mixed stream before passing it on # * to the audio device. # * # * This uses the Mix_RegisterEffect( )API internally.If you specify an echo # * of zero, the effect is unregistered, as the data is already in that state. # * # * returns zero if error( no such channel or Mix_RegisterEffect( )fails ), # * nonzero if reversing effect is enabled. # * Error messages can be retrieved from Mix_GetError( ). # * # extern no_parse_DECLSPEC int Mix_SetReverb( int channel, Uint8 echo ); # #E ndif # * Causes a channel to reverse its stereo.This is handy if the user has his # * speakers hooked up backwards, or you would like to have a minor bit of # * psychedelia in your sound code. : )Calling this function with ( flip ) # * set to non - zero reverses the chunks's usual channels. If (flip) is zero, # * the effect is unregistered. # * # * This uses the Mix_RegisterEffect( )API internally, and thus is probably # * more CPU intensive than having the user just plug in his speakers # * correctly.Mix_SetReverseStereo( )returns without registering the effect # * function if the audio device is not configured for stereo output. # * # * if you specify MIX_CHANNEL_POST for ( channel ), then this the effect is used # * on the final mixed stream before sending it on to the audio device( a # * posteffect ). # * # * returns zero if error( no such channel or Mix_RegisterEffect( )fails ), # * nonzero if reversing effect is enabled.Note that an audio device in mono # * mode is a no - op, but this call will return successful in that case . # * Error messages can be retrieved from Mix_GetError( ). # * proc Mix_SetReverseStereo*(channel: int, flip: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} # end of effects API. - -ryan. * # Reserve the first channels (0 -> n-1) for the application, i.e. don't allocate # them dynamically to the next sample if requested with a -1 value below. # Returns the number of reserved channels. # proc Mix_ReserveChannels*(num: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} # Channel grouping functions # Attach a tag to a channel. A tag can be assigned to several mixer # channels, to form groups of channels. # If 'tag' is -1, the tag is removed (actually -1 is the tag used to # represent the group of all the channels). # Returns true if everything was OK. # proc Mix_GroupChannel*(which: int, tag: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} # Assign several consecutive channels to a group proc Mix_GroupChannels*(`from`: int, `to`: int, tag: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} # Finds the first available channel in a group of channels proc Mix_GroupAvailable*(tag: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} # Returns the number of channels in a group. This is also a subtle # way to get the total number of channels when 'tag' is -1 # proc Mix_GroupCount*(tag: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} # Finds the "oldest" sample playing in a group of channels proc Mix_GroupOldest*(tag: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} # Finds the "most recent" (i.e. last) sample playing in a group of channels proc Mix_GroupNewer*(tag: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} # The same as above, but the sound is played at most 'ticks' milliseconds proc Mix_PlayChannelTimed*(channel: int, chunk: PMix_Chunk, loops: int, ticks: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} # Play an audio chunk on a specific channel. # If the specified channel is -1, play on the first free channel. # If 'loops' is greater than zero, loop the sound that many times. # If 'loops' is -1, loop inifinitely (~65000 times). # Returns which channel was used to play the sound. # proc Mix_PlayChannel*(channel: int, chunk: PMix_Chunk, loops: int): int proc Mix_PlayMusic*(music: PMix_Music, loops: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} # Fade in music or a channel over "ms" milliseconds, same semantics as the "Play" functions proc Mix_FadeInMusic*(music: PMix_Music, loops: int, ms: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} proc Mix_FadeInChannelTimed*(channel: int, chunk: PMix_Chunk, loops: int, ms: int, ticks: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} proc Mix_FadeInChannel*(channel: int, chunk: PMix_Chunk, loops: int, ms: int): int # Set the volume in the range of 0-128 of a specific channel or chunk. # If the specified channel is -1, set volume for all channels. # Returns the original volume. # If the specified volume is -1, just return the current volume. # proc Mix_Volume*(channel: int, volume: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} proc Mix_VolumeChunk*(chunk: PMix_Chunk, volume: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} proc Mix_VolumeMusic*(volume: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} # Halt playing of a particular channel proc Mix_HaltChannel*(channel: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} proc Mix_HaltGroup*(tag: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} proc Mix_HaltMusic*(): int{.cdecl, importc, dynlib: SDL_MixerLibName.} # Change the expiration delay for a particular channel. # The sample will stop playing after the 'ticks' milliseconds have elapsed, # or remove the expiration if 'ticks' is -1 # proc Mix_ExpireChannel*(channel: int, ticks: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} # Halt a channel, fading it out progressively till it's silent # The ms parameter indicates the number of milliseconds the fading # will take. # proc Mix_FadeOutChannel*(which: int, ms: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} proc Mix_FadeOutGroup*(tag: int, ms: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} proc Mix_FadeOutMusic*(ms: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} # Query the fading status of a channel proc Mix_FadingMusic*(): TMix_Fading{.cdecl, importc, dynlib: SDL_MixerLibName.} proc Mix_FadingChannel*(which: int): TMix_Fading{.cdecl, importc, dynlib: SDL_MixerLibName.} # Pause/Resume a particular channel proc Mix_Pause*(channel: int){.cdecl, importc, dynlib: SDL_MixerLibName.} proc Mix_Resume*(channel: int){.cdecl, importc, dynlib: SDL_MixerLibName.} proc Mix_Paused*(channel: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} # Pause/Resume the music stream proc Mix_PauseMusic*(){.cdecl, importc, dynlib: SDL_MixerLibName.} proc Mix_ResumeMusic*(){.cdecl, importc, dynlib: SDL_MixerLibName.} proc Mix_RewindMusic*(){.cdecl, importc, dynlib: SDL_MixerLibName.} proc Mix_PausedMusic*(): int{.cdecl, importc, dynlib: SDL_MixerLibName.} # Set the current position in the music stream. # This returns 0 if successful, or -1 if it failed or isn't implemented. # This function is only implemented for MOD music formats (set pattern # order number) and for OGG music (set position in seconds), at the # moment. # proc Mix_SetMusicPosition*(position: float64): int{.cdecl, importc, dynlib: SDL_MixerLibName.} # Check the status of a specific channel. # If the specified channel is -1, check all channels. # proc Mix_Playing*(channel: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} proc Mix_PlayingMusic*(): int{.cdecl, importc, dynlib: SDL_MixerLibName.} # Stop music and set external music playback command proc Mix_SetMusicCMD*(command: cstring): int{.cdecl, importc, dynlib: SDL_MixerLibName.} # Synchro value is set by MikMod from modules while playing proc Mix_SetSynchroValue*(value: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.} proc Mix_GetSynchroValue*(): int{.cdecl, importc, dynlib: SDL_MixerLibName.} # # Get the Mix_Chunk currently associated with a mixer channel # Returns nil if it's an invalid channel, or there's no chunk associated. # proc Mix_GetChunk*(channel: int): PMix_Chunk{.cdecl, importc, dynlib: SDL_MixerLibName.} # Close the mixer, halting all playing audio proc Mix_CloseAudio*(){.cdecl, importc, dynlib: SDL_MixerLibName.} # We'll use SDL for reporting errors proc Mix_SetError*(fmt: cstring) proc Mix_GetError*(): cstring # implementation proc SDL_MIXER_VERSION(X: var TSDL_version) = X.major = SDL_MIXER_MAJOR_VERSION X.minor = SDL_MIXER_MINOR_VERSION X.patch = SDL_MIXER_PATCHLEVEL proc Mix_LoadWAV(filename: cstring): PMix_Chunk = result = Mix_LoadWAV_RW(SDL_RWFromFile(filename, "rb"), 1) proc Mix_PlayChannel(channel: int, chunk: PMix_Chunk, loops: int): int = result = Mix_PlayChannelTimed(channel, chunk, loops, - 1) proc Mix_FadeInChannel(channel: int, chunk: PMix_Chunk, loops: int, ms: int): int = result = Mix_FadeInChannelTimed(channel, chunk, loops, ms, - 1) proc Mix_SetError(fmt: cstring) = SDL_SetError(fmt) proc Mix_GetError(): cstring = result = SDL_GetError()