HMUSIC typedef DWORD ; MOD music handle HSAMPLE typedef DWORD ; sample handle HCHANNEL typedef DWORD ; playing sample's channel handle HSTERAM typedef DWORD ; sample stream handle HSYNC typedef DWORD ; synchronizer handle HDSP typedef DWORD ; DSP handle HFX typedef DWORD ; DX8 effect handle ; Error codes returned by BASS_GetErrorCode() BASS_OK equ 0 ; all is OK BASS_ERROR_MEM equ 1 ; memory error BASS_ERROR_FILEOPEN equ 2 ; can't open the file BASS_ERROR_DRIVER equ 3 ; can't find a free/valid driver BASS_ERROR_BUFLOST equ 4 ; the sample buffer was lost - please report this! BASS_ERROR_HANDLE equ 5 ; invalid handle BASS_ERROR_FORMAT equ 6 ; unsupported format BASS_ERROR_POSITION equ 7 ; invalid playback position BASS_ERROR_INIT equ 8 ; BASS_Init has not been successfully called BASS_ERROR_START equ 9 ; BASS_Start has not been successfully called BASS_ERROR_INITCD equ 10 ; can't initialize CD BASS_ERROR_CDINIT equ 11 ; BASS_CDInit has not been successfully called BASS_ERROR_NOCD equ 12 ; no CD in drive BASS_ERROR_CDTRACK equ 13 ; can't play the selected CD track BASS_ERROR_ALREADY equ 14 ; already initialized BASS_ERROR_CDVOL equ 15 ; CD has no volume control BASS_ERROR_NOPAUSE equ 16 ; not paused BASS_ERROR_NOTAUDIO equ 17 ; not an audio track BASS_ERROR_NOCHAN equ 18 ; can't get a free channel BASS_ERROR_ILLTYPE equ 19 ; an illegal type was specified BASS_ERROR_ILLPARAM equ 20 ; an illegal parameter was specified BASS_ERROR_NO3D equ 21 ; no 3D support BASS_ERROR_NOEAX equ 22 ; no EAX support BASS_ERROR_DEVICE equ 23 ; illegal device number BASS_ERROR_NOPLAY equ 24 ; not playing BASS_ERROR_FREQ equ 25 ; illegal sample rate BASS_ERROR_NOA3D equ 26 ; A3D.DLL is not installed BASS_ERROR_NOTFILE equ 27 ; the stream is not a file stream (WAV/MP3/MP2/MP1/OGG) BASS_ERROR_NOHW equ 29 ; no hardware voices available BASS_ERROR_NOSYNC equ 30 ; synchronizers have been disabled BASS_ERROR_EMPTY equ 31 ; the MOD music has no sequence data BASS_ERROR_NONET equ 32 ; no internet connection could be opened BASS_ERROR_CREATE equ 33 ; couldn't create the file BASS_ERROR_NOFX equ 34 ; effects are not enabled BASS_ERROR_PLAYING equ 35 ; the channel is playing BASS_ERROR_NOOGG equ 36 ; OGG.DLL/VORBIS.DLL could not be loaded BASS_ERROR_NOTAVAIL equ 37 ; requested data is not available BASS_ERROR_UNKNOWN equ -1 ; some other mystery error ; Device setup flags BASS_DEVICE_8BITS equ 1 ; use 8 bit resolution, else 16 bit BASS_DEVICE_MONO equ 2 ; use mono, else stereo BASS_DEVICE_3D equ 4 ; enable 3D functionality ; If the BASS_DEVICE_3D flag is not specified when initilizing BASS, ; then the 3D flags (BASS_SAMPLE_3D and BASS_MUSIC_3D) are ignored when ; loading/creating a sample/stream/music. BASS_DEVICE_A3D equ 8 ; enable A3D functionality BASS_DEVICE_NOSYNC equ 16 ; disable synchronizers BASS_DEVICE_LEAVEVOL equ 32 ; leave the volume as it is BASS_DEVICE_OGG equ 64 ; enable OGG support (requires OGG.DLL & VORBIS.DLL) BASS_DEVICE_NOTHREAD equ 128 ; update buffers manually (using BASS_Update) BASS_DEVICE_LATENCY equ 256 ; calculate device latency (BASS_INFO struct) ; DirectSound interfaces (for use with BASS_GetDSoundObject) BASS_OBJECT_DS equ 1 ; IDirectSound BASS_OBJECT_DS3DL equ 2 ; IDirectSound3DListener BASS_INFO struct _size dword ? ; size of this struct (set this before calling the function) flags dword ? ; device capabilities (DSCAPS_xxx flags) ; The following values are irrelevant if the device doesn't have hardware ; support (DSCAPS_EMULDRIVER is specified in flags) hwsize dword ? ; size of total device hardware memory hwfree dword ? ; size of free device hardware memory freesam dword ? ; number of free sample slots in the hardware free3d dword ? ; number of free 3D sample slots in the hardware minrate dword ? ; min sample rate supported by the hardware maxrate dword ? ; max sample rate supported by the hardware _eax dword ? ; device supports EAX? (always FALSE if BASS_DEVICE_3D was not used) a3d dword ? ; A3D version (0=unsupported or BASS_DEVICE_A3D was not used) dsver dword ? ; DirectSound version (use to check for DX5/7 functions) latency dword ? ; delay (in ms) before start of playback (requires BASS_DEVICE_LATENCY) BASS_INFO ends ; BASS_INFO flags (from DSOUND.H) DSCAPS_CONTINUOUSRATE equ 00000010h ; supports all sample rates between min/maxrate DSCAPS_EMULDRIVER equ 00000020h ; device does NOT have hardware DirectSound support DSCAPS_CERTIFIED equ 00000040h ; device driver has been certified by Microsoft ; The following flags tell what type of samples are supported by HARDWARE ; mixing, all these formats are supported by SOFTWARE mixing DSCAPS_SECONDARYMONO equ 00000100h ; mono DSCAPS_SECONDARYSTEREO equ 00000200h ; stereo DSCAPS_SECONDARY8BIT equ 00000400h ; 8 bit DSCAPS_SECONDARY16BIT equ 00000800h ; 16 bit ; Music flags BASS_MUSIC_RAMP equ 1 ; normal ramping BASS_MUSIC_RAMPS equ 2 ; sensitive ramping ; Ramping doesn't take a lot of extra processing and improves ; the sound quality by removing "clicks". Sensitive ramping will ; leave sharp attacked samples, unlike normal ramping. BASS_MUSIC_LOOP equ 4 ; loop music BASS_MUSIC_FT2MOD equ 16 ; play .MOD as FastTracker 2 does BASS_MUSIC_PT1MOD equ 32 ; play .MOD as ProTracker 1 does BASS_MUSIC_MONO equ 64 ; force mono mixing (less CPU usage) BASS_MUSIC_3D equ 128 ; enable 3D functionality BASS_MUSIC_POSRESET equ 256 ; stop all notes when moving position BASS_MUSIC_SURROUND equ 512 ; surround sound BASS_MUSIC_SURROUND2 equ 1024 ; surround sound (mode 2) BASS_MUSIC_STOPBACK equ 2048 ; stop the music on a backwards jump effect BASS_MUSIC_FX equ 4096 ; enable DX8 effects BASS_MUSIC_CALCLEN equ 8192 ; calculate playback length ; Sample info structure & flags BASS_SAMPLE struct freq dword ? ; default playback rate volume dword ? ; default volume (0-100) pan dword ? ; default pan (-100=left, 0=middle, 100=right) flags dword ? ; BASS_SAMPLE_xxx flags _length dword ? ; length (in samples, not bytes) max dword ? ; maximum simultaneous playbacks ; The following are the sample's default 3D attributes (if the sample ; is 3D, BASS_SAMPLE_3D is in flags) see BASS_ChannelSet3DAttributes mode3d dword ? ; BASS_3DMODE_xxx mode mindist real4 ? ; minimum distance maxdist real4 ? ; maximum distance iangle dword ? ; angle of inside projection cone oangle dword ? ; angle of outside projection cone outvol dword ? ; delta-volume outside the projection cone ; The following are the defaults used if the sample uses the DirectX 7 ; voice allocation/management features. vam dword ? ; voice allocation/management flags (BASS_VAM_xxx) priority dword ? ; priority (0=lowest, 0xffffffff=highest) BASS_SAMPLE ends BASS_SAMPLE_8BITS equ 1 ; 8 bit, else 16 bit BASS_SAMPLE_MONO equ 2 ; mono, else stereo BASS_SAMPLE_LOOP equ 4 ; looped BASS_SAMPLE_3D equ 8 ; 3D functionality enabled BASS_SAMPLE_SOFTWARE equ 16 ; it's NOT using hardware mixing BASS_SAMPLE_MUTEMAX equ 32 ; muted at max distance (3D only) BASS_SAMPLE_VAM equ 64 ; uses the DX7 voice allocation & management BASS_SAMPLE_FX equ 128 ; the DX8 effects are enabled BASS_SAMPLE_OVER_VOL equ 10000h ; override lowest volume BASS_SAMPLE_OVER_POS equ 20000h ; override longest playing BASS_SAMPLE_OVER_DIST equ 30000h ; override furthest from listener (3D only) BASS_MP3_HALFRATE equ 10000h ; reduced quality MP3/MP2/MP1 (half sample rate) BASS_MP3_SETPOS equ 20000h ; enable pin-point seeking on the MP3/MP2/MP1/OGG BASS_STREAM_AUTOFREE equ 40000h ; automatically free the stream when it stop/ends BASS_STREAM_RESTRATE equ 80000h ; restrict the download rate of internet file streams BASS_STREAM_BLOCK equ 100000h ; download/play internet file stream (MPx/OGG) in small blocks ; DX7 voice allocation flags BASS_VAM_HARDWARE equ 1 ; Play the sample in hardware. If no hardware voices are available then ; the "play" call will fail BASS_VAM_SOFTWARE equ 2 ; Play the sample in software (ie. non-accelerated). No other VAM flags ; may be used together with this flag. ; DX7 voice management flags ; These flags enable hardware resource stealing... if the hardware has no ; available voices, a currently playing buffer will be stopped to make room for ; the new buffer. NOTE: only samples loaded/created with the BASS_SAMPLE_VAM ; flag are considered for termination by the DX7 voice management. BASS_VAM_TERM_TIME equ 4 ; If there are no free hardware voices, the buffer to be terminated will be ; the one with the least time left to play. BASS_VAM_TERM_DIST equ 8 ; If there are no free hardware voices, the buffer to be terminated will be ; one that was loaded/created with the BASS_SAMPLE_MUTEMAX flag and is beyond ; it's max distance. If there are no buffers that match this criteria, then the ; "play" call will fail. BASS_VAM_TERM_PRIO equ 16 ; If there are no free hardware voices, the buffer to be terminated will be ; the one with the lowest priority. ; 3D vector (for 3D positions/velocities/orientations) BASS_3DVECTOR struct x real4 ? ; +=right, -=left y real4 ? ; +=up, -=down z real4 ? ; +=front, -=behind BASS_3DVECTOR ends ; 3D channel modes BASS_3DMODE_NORMAL equ 0 ; normal 3D processing BASS_3DMODE_RELATIVE equ 1 ; The channel's 3D position (position/velocity/orientation) are relative to ; the listener. When the listener's position/velocity/orientation is changed ; with BASS_Set3DPosition, the channel's position relative to the listener does ; not change. BASS_3DMODE_OFF equ 2 ; Turn off 3D processing on the channel, the sound will be played ;in the center. ; EAX environments, use with BASS_SetEAXParameters COMMENT % enum { EAX_ENVIRONMENT_GENERIC, EAX_ENVIRONMENT_PADDEDCELL, EAX_ENVIRONMENT_ROOM, EAX_ENVIRONMENT_BATHROOM, EAX_ENVIRONMENT_LIVINGROOM, EAX_ENVIRONMENT_STONEROOM, EAX_ENVIRONMENT_AUDITORIUM, EAX_ENVIRONMENT_CONCERTHALL, EAX_ENVIRONMENT_CAVE, EAX_ENVIRONMENT_ARENA, EAX_ENVIRONMENT_HANGAR, EAX_ENVIRONMENT_CARPETEDHALLWAY, EAX_ENVIRONMENT_HALLWAY, EAX_ENVIRONMENT_STONECORRIDOR, EAX_ENVIRONMENT_ALLEY, EAX_ENVIRONMENT_FOREST, EAX_ENVIRONMENT_CITY, EAX_ENVIRONMENT_MOUNTAINS, EAX_ENVIRONMENT_QUARRY, EAX_ENVIRONMENT_PLAIN, EAX_ENVIRONMENT_PARKINGLOT, EAX_ENVIRONMENT_SEWERPIPE, EAX_ENVIRONMENT_UNDERWATER, EAX_ENVIRONMENT_DRUGGED, EAX_ENVIRONMENT_DIZZY, EAX_ENVIRONMENT_PSYCHOTIC, EAX_ENVIRONMENT_COUNT ; total number of environments }; ; EAX presets, usage: BASS_SetEAXParameters(EAX_PRESET_xxx) #define EAX_PRESET_GENERIC EAX_ENVIRONMENT_GENERIC,0.5F,1.493F,0.5F #define EAX_PRESET_PADDEDCELL EAX_ENVIRONMENT_PADDEDCELL,0.25F,0.1F,0.0F #define EAX_PRESET_ROOM EAX_ENVIRONMENT_ROOM,0.417F,0.4F,0.666F #define EAX_PRESET_BATHROOM EAX_ENVIRONMENT_BATHROOM,0.653F,1.499F,0.166F #define EAX_PRESET_LIVINGROOM EAX_ENVIRONMENT_LIVINGROOM,0.208F,0.478F,0.0F #define EAX_PRESET_STONEROOM EAX_ENVIRONMENT_STONEROOM,0.5F,2.309F,0.888F #define EAX_PRESET_AUDITORIUM EAX_ENVIRONMENT_AUDITORIUM,0.403F,4.279F,0.5F #define EAX_PRESET_CONCERTHALL EAX_ENVIRONMENT_CONCERTHALL,0.5F,3.961F,0.5F #define EAX_PRESET_CAVE EAX_ENVIRONMENT_CAVE,0.5F,2.886F,1.304F #define EAX_PRESET_ARENA EAX_ENVIRONMENT_ARENA,0.361F,7.284F,0.332F #define EAX_PRESET_HANGAR EAX_ENVIRONMENT_HANGAR,0.5F,10.0F,0.3F #define EAX_PRESET_CARPETEDHALLWAY EAX_ENVIRONMENT_CARPETEDHALLWAY,0.153F,0.259F,2.0F #define EAX_PRESET_HALLWAY EAX_ENVIRONMENT_HALLWAY,0.361F,1.493F,0.0F #define EAX_PRESET_STONECORRIDOR EAX_ENVIRONMENT_STONECORRIDOR,0.444F,2.697F,0.638F #define EAX_PRESET_ALLEY EAX_ENVIRONMENT_ALLEY,0.25F,1.752F,0.776F #define EAX_PRESET_FOREST EAX_ENVIRONMENT_FOREST,0.111F,3.145F,0.472F #define EAX_PRESET_CITY EAX_ENVIRONMENT_CITY,0.111F,2.767F,0.224F #define EAX_PRESET_MOUNTAINS EAX_ENVIRONMENT_MOUNTAINS,0.194F,7.841F,0.472F #define EAX_PRESET_QUARRY EAX_ENVIRONMENT_QUARRY,1.0F,1.499F,0.5F #define EAX_PRESET_PLAIN EAX_ENVIRONMENT_PLAIN,0.097F,2.767F,0.224F #define EAX_PRESET_PARKINGLOT EAX_ENVIRONMENT_PARKINGLOT,0.208F,1.652F,1.5F #define EAX_PRESET_SEWERPIPE EAX_ENVIRONMENT_SEWERPIPE,0.652F,2.886F,0.25F #define EAX_PRESET_UNDERWATER EAX_ENVIRONMENT_UNDERWATER,1.0F,1.499F,0.0F #define EAX_PRESET_DRUGGED EAX_ENVIRONMENT_DRUGGED,0.875F,8.392F,1.388F #define EAX_PRESET_DIZZY EAX_ENVIRONMENT_DIZZY,0.139F,17.234F,0.666F #define EAX_PRESET_PSYCHOTIC EAX_ENVIRONMENT_PSYCHOTIC,0.486F,7.563F,0.806F % ; A3D resource manager modes A3D_RESMODE_OFF equ 0 ; off A3D_RESMODE_NOTIFY equ 1 ; notify when there are no free hardware channels A3D_RESMODE_DYNAMIC equ 2 ; non-looping channels are managed A3D_RESMODE_DYNAMIC_LOOPERS equ 3 ; all (inc. looping) channels are managed (req A3D 1.2) ; software 3D mixing algorithm modes (used with BASS_Set3DAlgorithm) BASS_3DALG_DEFAULT equ 0 ; default algorithm (currently translates to BASS_3DALG_OFF) BASS_3DALG_OFF equ 1 ; Uses normal left and right panning. The vertical axis is ignored except for ; scaling of volume due to distance. Doppler shift and volume scaling are still ; applied, but the 3D filtering is not performed. This is the most CPU efficient ; software implementation, but provides no virtual 3D audio effect. Head Related ; Transfer Function processing will not be done. Since only normal stereo panning ; is used, a channel using this algorithm may be accelerated by a 2D hardware ; voice if no free 3D hardware voices are available. BASS_3DALG_FULL equ 2 ; This algorithm gives the highest quality 3D audio effect, but uses more CPU. ; Requires Windows 98 2nd Edition or Windows 2000 that uses WDM drivers, if this ; mode is not available then BASS_3DALG_OFF will be used instead. BASS_3DALG_LIGHT equ 3 ; This algorithm gives a good 3D audio effect, and uses less CPU than the FULL ; mode. Requires Windows 98 2nd Edition or Windows 2000 that uses WDM drivers, if ; this mode is not available then BASS_3DALG_OFF will be used instead. ;typedef DWORD (CALLBACK STREAMPROC)(HSTREAM handle, void *buffer, DWORD length, DWORD user); ; Stream callback function. NOTE: A stream function should obviously be as quick ; as possible, other streams (and MOD musics) can't be mixed until it's finished. ; handle : The stream that needs writing ; buffer : Buffer to write the samples in ; length : Number of bytes to write ; user : The 'user' parameter value given when calling BASS_StreamCreate ; RETURN : Number of bytes written. If less than "length" then the ; stream is assumed to be at the end, and is stopped. ; Sync types (with BASS_ChannelSetSync() "param" and SYNCPROC "data" ; definitions) & flags. BASS_SYNC_MUSICPOS equ 0 BASS_SYNC_POS equ 0 ; Sync when a music or stream reaches a position. ; if HMUSIC... ; param: LOWORD=order (0=first, -1=all) HIWORD=row (0=first, -1=all) ; data : LOWORD=order HIWORD=row ; if HSTREAM... ; param: position in bytes ; data : not used BASS_SYNC_MUSICINST equ 1 ; Sync when an instrument (sample for the non-instrument based formats) ; is played in a music (not including retrigs). ; param: LOWORD=instrument (1=first) HIWORD=note (0=c0...119=b9, -1=all) ; data : LOWORD=note HIWORD=volume (0-64) BASS_SYNC_END equ 2 ; Sync when a music or file stream reaches the end. ; param: not used ; data : 1 = the sync is triggered by a backward jump in a MOD music, otherwise not used BASS_SYNC_MUSICFX equ 3 ; Sync when the "sync" effect (XM/MTM/MOD: E8x/Wxx, IT/S3M: S2x) is used. ; param: 0:data=pos, 1:data="x" value ; data : param=0: LOWORD=order HIWORD=row, param=1: "x" value BASS_SYNC_MIXTIME equ 40000000h ; FLAG: sync at mixtime, else at playtime BASS_SYNC_ONETIME equ 80000000h ; FLAG: sync only once, else continuously ;typedef void (CALLBACK SYNCPROC)(HSYNC handle, DWORD channel, DWORD data, DWORD user); ; Sync callback function. NOTE: a sync callback function should be very ; quick (eg. just posting a message) as other syncs cannot be processed ; until it has finished. If the sync is a "mixtime" sync, then other streams ; and MOD musics can not be mixed until it's finished either. ; handle : The sync that has occured ; channel: Channel that the sync occured in ; data : Additional data associated with the sync's occurance ; user : The 'user' parameter given when calling BASS_ChannelSetSync ;typedef void (CALLBACK DSPPROC)(HSYNC handle, DWORD channel, void *buffer, DWORD length, DWORD user); ; DSP callback function. NOTE: A DSP function should obviously be as quick as ; possible... other DSP functions, streams and MOD musics can not be processed ; until it's finished. ; handle : The DSP handle ; channel: Channel that the DSP is being applied to ; buffer : Buffer to apply the DSP to ; length : Number of bytes in the buffer ; user : The 'user' parameter given when calling BASS_ChannelSetDSP ; BASS_ChannelGetData flags BASS_DATA_FFT512 equ 80000000h ; 512 sample FFT BASS_DATA_FFT1024 equ 80000001h ; 1024 FFT BASS_DATA_FFT2048 equ 80000002h ; 2048 FFT ; BASS_StreamGetTags flags : what's returned BASS_TAG_ID3 equ 0 ; ID3v1 tags : 128 byte block BASS_TAG_ID3V2 equ 1 ; ID3v2 tags : variable length block BASS_TAG_OGG equ 2 ; OGG comments : array of null-terminated strings BASS_TAG_HTTP equ 3 ; HTTP headers : array of null-terminated strings BASS_TAG_ICY equ 4 ; ICY headers : array of null-terminated strings ; DX8 effect types, use with BASS_ChannelSetFX COMMENT % enum { BASS_FX_CHORUS, ; GUID_DSFX_STANDARD_CHORUS BASS_FX_COMPRESSOR, ; GUID_DSFX_STANDARD_COMPRESSOR BASS_FX_DISTORTION, ; GUID_DSFX_STANDARD_DISTORTION BASS_FX_ECHO, ; GUID_DSFX_STANDARD_ECHO BASS_FX_FLANGER, ; GUID_DSFX_STANDARD_FLANGER BASS_FX_GARGLE, ; GUID_DSFX_STANDARD_GARGLE BASS_FX_I3DL2REVERB, ; GUID_DSFX_STANDARD_I3DL2REVERB BASS_FX_PARAMEQ, ; GUID_DSFX_STANDARD_PARAMEQ BASS_FX_REVERB ; GUID_DSFX_WAVES_REVERB }; % BASS_FXCHORUS struct fWetDryMix real4 ? fDepth real4 ? fFeedback real4 ? fFrequency real4 ? lWaveform dword ? ; 0=triangle, 1=sine fDelay real4 ? lPhase dword ? ; BASS_FX_PHASE_xxx BASS_FXCHORUS ends ; DSFXChorus BASS_FXCOMPRESSOR struct fGain real4 ? fAttack real4 ? fRelease real4 ? fThreshold real4 ? fRatio real4 ? fPredelay real4 ? BASS_FXCOMPRESSOR ends ; DSFXCompressor BASS_FXDISTORTION struct fGain real4 ? fEdge real4 ? fPostEQCenterFrequency real4 ? fPostEQBandwidth real4 ? fPreLowpassCutoff real4 ? BASS_FXDISTORTION ends ; DSFXDistortion BASS_FXECHO struct fWetDryMix real4 ? fFeedback real4 ? fLeftDelay real4 ? fRightDelay real4 ? lPanDelay dword ? BASS_FXECHO ends ; DSFXEcho BASS_FXFLANGER struct fWetDryMix real4 ? fDepth real4 ? fFeedback real4 ? fFrequency real4 ? lWaveform dword ? ; 0=triangle, 1=sine fDelay real4 ? lPhase dword ? ; BASS_FX_PHASE_xxx BASS_FXFLANGER ends ; DSFXFlanger BASS_FXGARGLE struct dwRateHz dword ? ; Rate of modulation in hz dwWaveShape dword ? ; 0=triangle, 1=square BASS_FXGARGLE ends ; DSFXGargle BASS_FXI3DL2REVERB struct lRoom dword ? ; [-10000, 0] default: -1000 mB lRoomHF dword ? ; [-10000, 0] default: 0 mB flRoomRolloffFactor real4 ? ; [0.0, 10.0] default: 0.0 flDecayTime real4 ? ; [0.1, 20.0] default: 1.49s flDecayHFRatio real4 ? ; [0.1, 2.0] default: 0.83 lReflections dword ? ; [-10000, 1000] default: -2602 mB flReflectionsDelay real4 ? ; [0.0, 0.3] default: 0.007 s lReverb dword ? ; [-10000, 2000] default: 200 mB flReverbDelay real4 ? ; [0.0, 0.1] default: 0.011 s flDiffusion real4 ? ; [0.0, 100.0] default: 100.0 % flDensity real4 ? ; [0.0, 100.0] default: 100.0 % flHFReference real4 ? ; [20.0, 20000.0] default: 5000.0 Hz BASS_FXI3DL2REVERB ends ; DSFXI3DL2Reverb BASS_FXPARAMEQ struct fCenter real4 ? fBandwidth real4 ? fGain real4 ? BASS_FXPARAMEQ ends ; DSFXParamEq BASS_FXREVERB struct fInGain real4 ? ; [-96.0,0.0] default: 0.0 dB fReverbMix real4 ? ; [-96.0,0.0] default: 0.0 db fReverbTime real4 ? ; [0.001,3000.0] default: 1000.0 ms fHighFreqRTRatio real4 ? ; [0.001,0.999] default: 0.001 BASS_FXREVERB ends ; DSFXWavesReverb BASS_FX_PHASE_NEG_180 equ 0 BASS_FX_PHASE_NEG_90 equ 1 BASS_FX_PHASE_ZERO equ 2 BASS_FX_PHASE_90 equ 3 BASS_FX_PHASE_180 equ 4 CDCHANNEL equ 0 ; CD channel, for use with BASS_Channel functions ; BASS_CDGetID flags BASS_CDID_IDENTITY equ 0 BASS_CDID_UPC equ 1 ;DWORD BASSDEF(BASS_GetVersion)(); ; Retrieve the version number of BASS that is loaded. ; RETURN : The BASS version (LOWORD.HIWORD) ;BOOL BASSDEF(BASS_GetDeviceDescription)(DWORD devnum, char **desc); ; Get the text description of a device. This function can be used to ; enumerate the available devices. ; devnum : The device (0=first) ; desc : Pointer to store pointer to text description at ;float BASSDEF(BASS_SetBufferLength)(float length); ; Set the amount that BASS mixes ahead new musics/streams. Changing ; this setting does not affect musics/streams that have already been ; loaded/created. Increasing the buffer length, decreases the chance of ; the sound possibly breaking-up on slower computers, but also requires ; more memory. The default length is 0.5 secs. ; length : The buffer length in seconds ; RETURN : The actual new buffer length ;void BASSDEF(BASS_SetGlobalVolumes)(int musvol, int samvol, int strvol); ; Set the global music/sample/stream volume levels. ; musvol : MOD music global volume level (0-100, -1=leave current) ; samvol : Sample global volume level (0-100, -1=leave current) ; strvol : Stream global volume level (0-100, -1=leave current) ;void BASSDEF(BASS_GetGlobalVolumes)(DWORD *musvol, DWORD *samvol, DWORD *strvol); ; Retrive the global music/sample/stream volume levels. ; musvol : MOD music global volume level (NULL=don't retrieve it) ; samvol : Sample global volume level (NULL=don't retrieve it) ; strvol : Stream global volume level (NULL=don't retrieve it) ;void BASSDEF(BASS_SetLogCurves)(BOOL volume, BOOL pan); ; Make the volume/panning values translate to a logarithmic curve, ; or a linear "curve" (the default). ; volume : volume curve (FALSE=linear, TRUE=log) ; pan : panning curve (FALSE=linear, TRUE=log) ;void BASSDEF(BASS_Set3DAlgorithm)(DWORD algo); ; Set the 3D algorithm for software mixed 3D channels (does not affect ; hardware mixed channels). Changing the mode only affects subsequently ; created or loaded samples/streams/musics, not those that already exist. ; Requires DirectX 7 or above. ; algo : algorithm flag (BASS_3DALG_xxx) ;DWORD BASSDEF(BASS_ErrorGetCode)(); ; Get the BASS_ERROR_xxx error code. Use this function to get the ; reason for an error. ;BOOL BASSDEF(BASS_Init)(int device, DWORD freq, DWORD flags, HWND win); ; Initialize the digital output. This must be called before all following ; BASS functions (except CD functions). ; device : Device to use (0=first, -1=default, -2=no sound) ; freq : Output sample rate ; flags : BASS_DEVICE_xxx flags (optional HIWORD=update period) ; win : Owner window (0=current foreground window) ; NOTE: The "no sound" device (device=-2), allows loading and "playing" ; of MOD musics only (all sample/stream functions and most other functions ; fail). This is so that you can still use the MOD musics as synchronizers ; when there is no soundcard present. When using device -2, you should still ; set the other arguments as you would do normally. ;void BASSDEF(BASS_Free)(); ; Free all resources used by the digital output, including all musics ; and samples. ;void *BASSDEF(BASS_GetDSoundObject)(DWORD object); ; Retrieve a pointer to a DirectSound interface. This can be used by ; advanced users to "plugin" external functionality. ; object : The interface to retrieve (BASS_OBJECT_xxx) ; RETURN : A pointer to the requested interface (NULL=error) ;void BASSDEF(BASS_GetInfo)(BASS_INFO *info); ; Retrieve some information on the device being used. ; info : Pointer to store info at ;BOOL BASSDEF(BASS_Update)(); ; Update the HMUSIC/HSTREAM channel buffers. ;float BASSDEF(BASS_GetCPU)(); ; Get the current CPU usage of BASS. This includes the time taken to mix ; the MOD musics and sample streams, and also the time taken by any user ; DSP functions. It does not include plain sample mixing which is done by ; the output device (hardware accelerated) or DirectSound (emulated). Audio ; CD playback requires no CPU usage. ; RETURN : The CPU usage percentage (floating-point) ;BOOL BASSDEF(BASS_Start)(); ; Start the digital output. ;BOOL BASSDEF(BASS_Stop)(); ; Stop the digital output, stopping all musics/samples/streams. ;BOOL BASSDEF(BASS_Pause)(); ; Stop the digital output, pausing all musics/samples/streams. Use ; BASS_Start() to resume the digital output. ;BOOL BASSDEF(BASS_SetVolume)(DWORD volume); ; Set the digital output master volume. ; volume : Desired volume level (0-100) ;int BASSDEF(BASS_GetVolume)(); ; Get the digital output master volume. ; RETURN : The volume level (0-100, -1=error) ;BOOL BASSDEF(BASS_Set3DFactors)(float distf, float rollf, float doppf); ; Set the factors that affect the calculations of 3D sound. ; distf : Distance factor (0.0-10.0, 1.0=use meters, 0.3=use feet, <0.0=leave current) ; By default BASS measures distances in meters, you can change this ; setting if you are using a different unit of measurement. ; roolf : Rolloff factor, how fast the sound quietens with distance ; (0.0=no rolloff, 1.0=real world, 2.0=2x real... 10.0=max, <0.0=leave current) ; doppf : Doppler factor (0.0=no doppler, 1.0=real world, 2.0=2x real... 10.0=max, <0.0=leave current) ; The doppler effect is the way a sound appears to change frequency when it is ; moving towards or away from you. The listener and sound velocity settings are ; used to calculate this effect, this "doppf" value can be used to lessen or ; exaggerate the effect. ;BOOL BASSDEF(BASS_Get3DFactors)(float *distf, float *rollf, float *doppf); ; Get the factors that affect the calculations of 3D sound. ; distf : Distance factor (NULL=don't get it) ; roolf : Rolloff factor (NULL=don't get it) ; doppf : Doppler factor (NULL=don't get it) ;BOOL BASSDEF(BASS_Set3DPosition)(BASS_3DVECTOR *pos, BASS_3DVECTOR *vel, BASS_3DVECTOR *front, BASS_3DVECTOR *top); ; Set the position/velocity/orientation of the listener (ie. the player/viewer). ; pos : Position of the listener (NULL=leave current) ; vel : Listener's velocity, used to calculate doppler effect (NULL=leave current) ; front : Direction that listener's front is pointing (NULL=leave current) ; top : Direction that listener's top is pointing (NULL=leave current) ; NOTE: front & top must both be set in a single call ;BOOL BASSDEF(BASS_Get3DPosition)(BASS_3DVECTOR *pos, BASS_3DVECTOR *vel, BASS_3DVECTOR *front, BASS_3DVECTOR *top); ; Get the position/velocity/orientation of the listener. ; pos : Position of the listener (NULL=don't get it) ; vel : Listener's velocity (NULL=don't get it) ; front : Direction that listener's front is pointing (NULL=don't get it) ; top : Direction that listener's top is pointing (NULL=don't get it) ; NOTE: front & top must both be retrieved in a single call ;BOOL BASSDEF(BASS_Apply3D)(); ; Apply changes made to the 3D system. This must be called to apply any changes ; made with BASS_Set3DFactors, BASS_Set3DPosition, BASS_ChannelSet3DAttributes or ; BASS_ChannelSet3DPosition. It improves performance to have DirectSound do all the ; required recalculating at the same time like this, rather than recalculating after ; every little change is made. NOTE: This is automatically called when starting a 3D ; sample with BASS_SamplePlay3D/Ex. ;BOOL BASSDEF(BASS_SetEAXParameters)(int env, float vol, float decay, float damp); ; Set the type of EAX environment and it's parameters. Obviously, EAX functions ; have no effect if no EAX supporting device (ie. SB Live) is used. ; env : Reverb environment (EAX_ENVIRONMENT_xxx, -1=leave current) ; vol : Volume of the reverb (0.0=off, 1.0=max, <0.0=leave current) ; decay : Time in seconds it takes the reverb to diminish by 60dB (0.1-20.0, <0.0=leave current) ; damp : The damping, high or low frequencies decay faster (0.0=high decays quickest, ; 1.0=low/high decay equally, 2.0=low decays quickest, <0.0=leave current) ;BOOL BASSDEF(BASS_GetEAXParameters)(DWORD *env, float *vol, float *decay, float *damp); ; Get the current EAX parameters. ; env : Reverb environment (NULL=don't get it) ; vol : Reverb volume (NULL=don't get it) ; decay : Decay duration (NULL=don't get it) ; damp : The damping (NULL=don't get it) ;BOOL BASSDEF(BASS_SetA3DResManager)(DWORD mode); ; Set the A3D resource management mode. ; mode : The mode (A3D_RESMODE_OFF=disable resource management, ; A3D_RESMODE_DYNAMIC=enable resource manager but looping channels are not managed, ; A3D_RESMODE_DYNAMIC_LOOPERS=enable resource manager including looping channels, ; A3D_RESMODE_NOTIFY=plays will fail when there are no available resources) ;DWORD BASSDEF(BASS_GetA3DResManager)(); ; Get the A3D resource management mode. ; RETURN : The mode (0xffffffff=error) ;BOOL BASSDEF(BASS_SetA3DHFAbsorbtion)(float factor); ; Set the A3D high frequency absorbtion factor. ; factor : Absorbtion factor (0.0=disabled, <1.0=diminished, 1.0=default, ; >1.0=exaggerated) ;BOOL BASSDEF(BASS_GetA3DHFAbsorbtion)(float *factor); ; Retrieve the current A3D high frequency absorbtion factor. ; factor : The absorbtion factor ;HMUSIC BASSDEF(BASS_MusicLoad)(BOOL mem, void *file, DWORD offset, DWORD length, DWORD flags); ; Load a music (MO3/XM/MOD/S3M/IT/MTM). The amplification and pan ; seperation are initially set to 50, use BASS_MusicSetAmplify() ; and BASS_MusicSetPanSep() to adjust them. ; mem : TRUE = Load music from memory ; file : Filename (mem=FALSE) or memory location (mem=TRUE) ; offset : File offset to load the music from (only used if mem=FALSE) ; length : Data length (only used if mem=FALSE, 0=use to end of file) ; flags : BASS_MUSIC_xxx flags ; RETURN : The loaded music's handle (NULL=error) ;void BASSDEF(BASS_MusicFree)(HMUSIC handle); ; Free a music's resources. ; handle : Music handle ;char *BASSDEF(BASS_MusicGetName)(HMUSIC handle); ; Retrieves a music's name. ; handle : Music handle ; RETURN : The music's name (NULL=error) ;DWORD BASSDEF(BASS_MusicGetLength)(HMUSIC handle, BOOL playlen); ; Retrieves the length of a music in patterns (how many "orders" there are) ; or in output bytes (requires BASS_MUSIC_CALCLEN was used with BASS_MusicLoad). ; handle : Music handle ; playlen: TRUE=get the playback length, FALSE=get the pattern length ; RETURN : The length of the music (0xFFFFFFFF=error) ;BOOL BASSDEF(BASS_MusicPreBuf)(HMUSIC handle); ; Pre-buffer initial sample data ready for playback. ; handle : Handle of music ;BOOL BASSDEF(BASS_MusicPlay)(HMUSIC handle); ; Play a music. Playback continues from where it was last stopped/paused. ; Multiple musics may be played simultaneously. ; handle : Handle of music to play ;BOOL BASSDEF(BASS_MusicPlayEx)(HMUSIC handle, DWORD pos, int flags, BOOL reset); ; Play a music, specifying start position and playback flags. ; handle : Handle of music to play ; pos : Position to start playback from, LOWORD=order HIWORD=row ; flags : BASS_MUSIC_xxx flags. These flags overwrite the defaults ; specified when the music was loaded. (-1=use current flags) ; reset : TRUE = Stop all current playing notes and reset bpm/etc... ;BOOL BASSDEF(BASS_MusicSetAmplify)(HMUSIC handle, DWORD amp); ; Set a music's amplification level. ; handle : Music handle ; amp : Amplification level (0-100) ;BOOL BASSDEF(BASS_MusicSetPanSep)(HMUSIC handle, DWORD pan); ; Set a music's pan seperation. ; handle : Music handle ; pan : Pan seperation (0-100, 50=linear) ;BOOL BASSDEF(BASS_MusicSetPositionScaler)(HMUSIC handle, DWORD scale); ; Set a music's "GetPosition" scaler ; When you call BASS_ChannelGetPosition, the "row" (HIWORD) will be ; scaled by this value. By using a higher scaler, you can get a more ; precise position indication. ; handle : Music handle ; scale : The scaler (1-256) ;HSAMPLE BASSDEF(BASS_SampleLoad)(BOOL mem, void *file, DWORD offset, DWORD length, DWORD max, DWORD flags); ; Load a WAV/MP3/MP2/MP1 sample. If you're loading a sample with 3D ; functionality, then you should use BASS_GetInfo and BASS_SetInfo to set ; the default 3D parameters. You can also use these two functions to set ; the sample's default frequency/volume/pan/looping. ; mem : TRUE = Load sample from memory ; file : Filename (mem=FALSE) or memory location (mem=TRUE) ; offset : File offset to load the sample from (only used if mem=FALSE) ; length : Data length (only used if mem=FALSE, 0=use to end of file) ; max : Maximum number of simultaneous playbacks (1-65535) ; flags : BASS_SAMPLE_xxx flags (only the LOOP/3D/SOFTWARE/VAM/MUTEMAX/OVER_xxx flags are used) ; RETURN : The loaded sample's handle (NULL=error) ;void* BASSDEF(BASS_SampleCreate)(DWORD length, DWORD freq, DWORD max, DWORD flags); ; Create a sample. This function allows you to generate custom samples, or ; load samples that are not in the WAV format. A pointer is returned to the ; memory location at which you should write the sample's data. After writing ; the data, call BASS_SampleCreateDone to get the new sample's handle. ; length : The sample's length (in samples, NOT bytes) ; freq : default sample rate ; max : Maximum number of simultaneous playbacks (1-65535) ; flags : BASS_SAMPLE_xxx flags ; RETURN : Memory location to write the sample's data (NULL=error) ;HSAMPLE BASSDEF(BASS_SampleCreateDone)(); ; Finished creating a new sample. ; RETURN : The new sample's handle (NULL=error) ;void BASSDEF(BASS_SampleFree)(HSAMPLE handle); ; Free a sample's resources. ; handle : Sample handle ;BOOL BASSDEF(BASS_SampleGetInfo)(HSAMPLE handle, BASS_SAMPLE *info); ; Retrieve a sample's current default attributes. ; handle : Sample handle ; info : Pointer to store sample info ;BOOL BASSDEF(BASS_SampleSetInfo)(HSAMPLE handle, BASS_SAMPLE *info); ; Set a sample's default attributes. ; handle : Sample handle ; info : Sample info, only the freq/volume/pan/3D attributes and ; looping/override method flags are used ;HCHANNEL BASSDEF(BASS_SamplePlay)(HSAMPLE handle); ; Play a sample, using the sample's default attributes. ; handle : Handle of sample to play ; RETURN : Handle of channel used to play the sample (NULL=error) ;HCHANNEL BASSDEF(BASS_SamplePlayEx)(HSAMPLE handle, DWORD start, int freq, int volume, int pan, BOOL loop); ; Play a sample, using specified attributes. ; handle : Handle of sample to play ; start : Playback start position (in samples, not bytes) ; freq : Playback rate (-1=default) ; volume : Volume (-1=default, 0=silent, 100=max) ; pan : Pan position (-101=default, -100=left, 0=middle, 100=right) ; loop : TRUE = Loop sample (-1=default) ; RETURN : Handle of channel used to play the sample (NULL=error) ;HCHANNEL BASSDEF(BASS_SamplePlay3D)(HSAMPLE handle, BASS_3DVECTOR *pos, BASS_3DVECTOR *orient, BASS_3DVECTOR *vel); ; Play a 3D sample, setting it's 3D position, orientation and velocity. ; handle : Handle of sample to play ; pos : position of the sound (NULL = x/y/z=0.0) ; orient : orientation of the sound, this is irrelevant if it's an ; omnidirectional sound source (NULL = x/y/z=0.0) ; vel : velocity of the sound (NULL = x/y/z=0.0) ; RETURN : Handle of channel used to play the sample (NULL=error) ;HCHANNEL BASSDEF(BASS_SamplePlay3DEx)(HSAMPLE handle, BASS_3DVECTOR *pos, BASS_3DVECTOR *orient, BASS_3DVECTOR *vel, DWORD start, int freq, int volume, BOOL loop); ; Play a 3D sample, using specified attributes. ; handle : Handle of sample to play ; pos : position of the sound (NULL = x/y/z=0.0) ; orient : orientation of the sound, this is irrelevant if it's an ; omnidirectional sound source (NULL = x/y/z=0.0) ; vel : velocity of the sound (NULL = x/y/z=0.0) ; start : Playback start position (in samples, not bytes) ; freq : Playback rate (-1=default) ; volume : Volume (-1=default, 0=silent, 100=max) ; loop : TRUE = Loop sample (-1=default) ; RETURN : Handle of channel used to play the sample (NULL=error) ;BOOL BASSDEF(BASS_SampleStop)(HSAMPLE handle); ; Stops all instances of a sample. For example, if a sample is playing ; simultaneously 3 times, calling this function will stop all 3 of them, ; which is obviously simpler than calling BASS_ChannelStop() 3 times. ; handle : Handle of sample to stop ;HSTREAM BASSDEF(BASS_StreamCreate)(DWORD freq, DWORD flags, STREAMPROC *proc, DWORD user); ; Create a user sample stream. ; freq : Stream playback rate (100-100000) ; flags : BASS_SAMPLE_xxx flags (only the 8BITS/MONO/3D flags are used) ; proc : User defined stream writing function ; user : The 'user' value passed to the callback function ; RETURN : The created stream's handle (NULL=error) ;HSTREAM BASSDEF(BASS_StreamCreateFile)(BOOL mem, void *file, DWORD offset, DWORD length, DWORD flags); ; Create a sample stream from an MP3/MP2/MP1/OGG or WAV file. ; mem : TRUE = Stream file from memory ; file : Filename (mem=FALSE) or memory location (mem=TRUE) ; offset : File offset of the stream data ; length : File length (0=use whole file if mem=FALSE) ; flags : Flags ; RETURN : The created stream's handle (NULL=error) ;HSTREAM BASSDEF(BASS_StreamCreateURL)(char *url, DWORD offset, DWORD flags, char *save); ; Create a sample stream from an MP3/MP2/MP1/OGG or WAV file on the internet, ; optionally saving a local copy to disk. ; url : The URL (beginning with "http:;" or "ftp:;") ; offset : File offset of start streaming from ; flags : Flags ; save : Filename to save the streamed file as locally (NULL=don't save) ; RETURN : The created stream's handle (NULL=error) ;void BASSDEF(BASS_StreamFree)(HSTREAM handle); ; Free a sample stream's resources. ; handle : Stream handle ;DWORD BASSDEF(BASS_StreamGetLength)(HSTREAM handle); ; Retrieves the playback length (in bytes) of a file stream. It's not always ; possible to 100% accurately guess the length of a stream, so the length returned ; may be only an approximation when using some WAV codecs. ; handle : Stream handle ; RETURN : The length (0=streaming in blocks, 0xffffffff=error) ;char *BASSDEF(BASS_StreamGetTags)(HSTREAM handle, DWORD tags); ; Retrieves the requested tags/headers, if available. ; handle : Stream handle ; tags : A BASS_TAG_xxx flag ; RETURN : Pointer to the tags (NULL=error) ;BOOL BASSDEF(BASS_StreamPreBuf)(HSTREAM handle); ; Pre-buffer initial sample data ready for playback. ; handle : Handle of stream ;BOOL BASSDEF(BASS_StreamPlay)(HSTREAM handle, BOOL flush, DWORD flags); ; Play a sample stream, optionally flushing the buffer first. ; handle : Handle of stream to play ; flush : Flush buffer contents. If you stop a stream and then want to ; continue it from where it stopped, don't flush it. Flushing ; a file stream causes it to restart from the beginning. ; flags : BASS_SAMPLE_LOOP flag (only affects file streams) ;DWORD BASSDEF(BASS_StreamGetFilePosition)(HSTREAM handle, DWORD mode); ; Retrieves the file position of the decoding, the download (if streaming from ; the internet), or the end (total length). Obviously only works with file streams. ; handle : Stream handle ; mode : The position to retrieve (0=decoding, 1=download, 2=end) ; RETURN : The position (0xffffffff=error) ;BOOL BASSDEF(BASS_CDInit)(char *drive); ; Initialize the CD functions, must be called before any other CD ; functions. The volume is initially set to 100 (the maximum), use ; BASS_ChannelSetAttributes() to adjust it. ; drive : The CD drive, for example: "d:" (NULL=use default drive) ;void BASSDEF(BASS_CDFree)(); ; Free resources used by the CD. ;BOOL BASSDEF(BASS_CDInDrive)(); ; Check if there is a CD in the drive. ;char *BASSDEF(BASS_CDGetID)(DWORD id); ; Retrieves identification info from the CD in the drive. ; id : BASS_CDID_IDENTITY or BASS_CDID_UPC ; RETURN : ID string (NULL=error) ;DWORD BASSDEF(BASS_CDGetTracks)(); ; Retrieves the number of tracks on the CD ; RETURN : The number of tracks (0xffffffff=error) ;BOOL BASSDEF(BASS_CDPlay)(DWORD track, BOOL loop, BOOL wait); ; Play a CD track. ; track : Track number to play (1=first) ; loop : TRUE = Loop the track ; wait : TRUE = don't return until playback has started (some drives ; will always wait anyway) ;DWORD BASSDEF(BASS_CDGetTrackLength)(DWORD track); ; Retrieves the playback length (in milliseconds) of a cd track. ; track : The CD track (1=first) ; RETURN : The length (0xffffffff=error) ; A "channel" can be a playing sample (HCHANNEL), a MOD music (HMUSIC), ; a sample stream (HSTREAM), or the CD (CDCHANNEL). The following ; functions can be used with one or more of these channel types. ;float BASSDEF(BASS_ChannelBytes2Seconds)(DWORD handle, DWORD pos); ; Translate a byte position into time (seconds) ; handle : Handle of channel (HCHANNEL/HMUSIC/HSTREAM, also HSAMPLE) ; pos : The position to translate ; RETURN : The millisecond position (<0=error) ;DWORD BASSDEF(BASS_ChannelSeconds2Bytes)(DWORD handle, float pos); ; Translate a time (seconds) position into bytes ; handle : Handle of channel (HCHANNEL/HMUSIC/HSTREAM, also HSAMPLE) ; pos : The position to translate ; RETURN : The byte position (0xffffffff=error) ;int BASSDEF(BASS_ChannelIsActive)(DWORD handle); ; Check if a channel is active (playing) or stalled. ; handle : Channel handle (HCHANNEL/HMUSIC/HSTREAM, or CDCHANNEL) ; RETURN : 0=not playing, 1=playing, 2=stalled(internet) ;DWORD BASSDEF(BASS_ChannelGetFlags)(DWORD handle); ; Get some info about a channel. ; handle : Channel handle (HCHANNEL/HMUSIC/HSTREAM) ; RETURN : BASS_SAMPLE_xxx flags (0xffffffff=error) ;BOOL BASSDEF(BASS_ChannelStop)(DWORD handle); ; Stop a channel. ; handle : Channel handle (HCHANNEL/HMUSIC/HSTREAM, or CDCHANNEL) ;BOOL BASSDEF(BASS_ChannelPause)(DWORD handle); ; Pause a channel. ; handle : Channel handle (HCHANNEL/HMUSIC/HSTREAM, or CDCHANNEL) ;BOOL BASSDEF(BASS_ChannelResume)(DWORD handle); ; Resume a paused channel. ; handle : Channel handle (HCHANNEL/HMUSIC/HSTREAM, or CDCHANNEL) ;BOOL BASSDEF(BASS_ChannelSetAttributes)(DWORD handle, int freq, int volume, int pan); ; Update a channel's attributes. The actual setting may not be exactly ; as specified, depending on the accuracy of the device and drivers. ; NOTE: Only the volume can be adjusted for the CD "channel", but not all ; soundcards allow controlling of the CD volume level. ; handle : Channel handle (HCHANNEL/HMUSIC/HSTREAM, or CDCHANNEL) ; freq : Playback rate (100-100000, 0=original, -1=leave current) ; volume : Volume (-1=leave current, 0=silent, 100=max) ; pan : Pan position (-101=current, -100=left, 0=middle, 100=right) ; panning has no effect on 3D channels ;BOOL BASSDEF(BASS_ChannelGetAttributes)(DWORD handle, DWORD *freq, DWORD *volume, int *pan); ; Retrieve a channel's attributes. Only the volume is available for ; the CD "channel" (if allowed by the soundcard/drivers). ; handle : Channel handle (HCHANNEL/HMUSIC/HSTREAM, or CDCHANNEL) ; freq : Pointer to store playback rate (NULL=don't retrieve it) ; volume : Pointer to store volume (NULL=don't retrieve it) ; pan : Pointer to store pan position (NULL=don't retrieve it) ;BOOL BASSDEF(BASS_ChannelSet3DAttributes)(DWORD handle, int mode, float min, float max, int iangle, int oangle, int outvol); ; Set a channel's 3D attributes. ; handle : Channel handle (HCHANNEL/HSTREAM/HMUSIC) ; mode : BASS_3DMODE_xxx mode (-1=leave current setting) ; min : minimum distance, volume stops increasing within this distance (<0.0=leave current) ; max : maximum distance, volume stops decreasing past this distance (<0.0=leave current) ; iangle : angle of inside projection cone in degrees (360=omnidirectional, -1=leave current) ; oangle : angle of outside projection cone in degrees (-1=leave current) ; NOTE: iangle & oangle must both be set in a single call ; outvol : delta-volume outside the projection cone (0=silent, 100=same as inside) ; The iangle/oangle angles decide how wide the sound is projected around the ; orientation angle. Within the inside angle the volume level is the channel ; level as set with BASS_ChannelSetAttributes, from the inside to the outside ; angles the volume gradually changes by the "outvol" setting. ;BOOL BASSDEF(BASS_ChannelGet3DAttributes)(DWORD handle, DWORD *mode, float *min, float *max, DWORD *iangle, DWORD *oangle, DWORD *outvol); ; Retrieve a channel's 3D attributes. ; handle : Channel handle (HCHANNEL/HSTREAM/HMUSIC) ; mode : BASS_3DMODE_xxx mode (NULL=don't retrieve it) ; min : minumum distance (NULL=don't retrieve it) ; max : maximum distance (NULL=don't retrieve it) ; iangle : angle of inside projection cone (NULL=don't retrieve it) ; oangle : angle of outside projection cone (NULL=don't retrieve it) ; NOTE: iangle & oangle must both be retrieved in a single call ; outvol : delta-volume outside the projection cone (NULL=don't retrieve it) ;BOOL BASSDEF(BASS_ChannelSet3DPosition)(DWORD handle, BASS_3DVECTOR *pos, BASS_3DVECTOR *orient, BASS_3DVECTOR *vel); ; Update a channel's 3D position, orientation and velocity. The velocity ; is only used to calculate the doppler effect. ; handle : Channel handle (HCHANNEL/HSTREAM/HMUSIC) ; pos : position of the sound (NULL=leave current) ; orient : orientation of the sound, this is irrelevant if it's an ; omnidirectional sound source (NULL=leave current) ; vel : velocity of the sound (NULL=leave current) ;BOOL BASSDEF(BASS_ChannelGet3DPosition)(DWORD handle, BASS_3DVECTOR *pos, BASS_3DVECTOR *orient, BASS_3DVECTOR *vel); ; Retrieve a channel's current 3D position, orientation and velocity. ; handle : Channel handle (HCHANNEL/HSTREAM/HMUSIC) ; pos : position of the sound (NULL=don't retrieve it) ; orient : orientation of the sound, this is irrelevant if it's an ; omnidirectional sound source (NULL=don't retrieve it) ; vel : velocity of the sound (NULL=don't retrieve it) ;BOOL BASSDEF(BASS_ChannelSetPosition)(DWORD handle, DWORD pos); ; Set the current playback position of a channel. ; handle : Channel handle (HCHANNEL/HMUSIC/HSTREAM, or CDCHANNEL) ; pos : the position ; if HCHANNEL: position in bytes ; if HMUSIC: LOWORD=order HIWORD=row ... use MAKELONG(order,row) ; if HSTREAM: position in bytes, file streams only (MP3/MP2/MP1/OGG require BASS_MP3_SETPOS) ; if CDCHANNEL: position in milliseconds from start of track ;DWORD BASSDEF(BASS_ChannelGetPosition)(DWORD handle); ; Get the current playback position of a channel. ; handle : Channel handle (HCHANNEL/HMUSIC/HSTREAM, or CDCHANNEL) ; RETURN : the position (0xffffffff=error) ; if HCHANNEL: position in bytes ; if HMUSIC: LOWORD=order HIWORD=row (see BASS_MusicSetPositionScaler) ; if HSTREAM: total bytes played since the stream was last flushed ; if CDCHANNEL: position in milliseconds from start of track ;DWORD BASSDEF(BASS_ChannelGetLevel)(DWORD handle); ; Calculate a channel's current output level. ; handle : Channel handle (HMUSIC/HSTREAM) ; RETURN : LOWORD=left level (0-128) HIWORD=right level (0-128) (0xffffffff=error) ;DWORD BASSDEF(BASS_ChannelGetData)(DWORD handle, void *buffer, DWORD length); ; Retrieves upto "length" bytes of the channel's current sample data. This is ; useful if you wish to "visualize" the sound. ; handle : Channel handle (HMUSIC/HSTREAM) ; buffer : Location to write the data ; length : Number of bytes of wanted, or a BASS_DATA_xxx flag ; RETURN : Number of bytes actually written to the buffer (0xffffffff=error) ;HSYNC BASSDEF(BASS_ChannelSetSync)(DWORD handle, DWORD type, DWORD param, SYNCPROC *proc, DWORD user); ; Setup a sync on a channel. Multiple syncs may be used per channel. ; handle : Channel handle ; type : Sync type (BASS_SYNC_xxx type & flags) ; param : Sync parameters (see the BASS_SYNC_xxx type description) ; proc : User defined callback function ; user : The 'user' value passed to the callback function ; RETURN : Sync handle (NULL=error) ;BOOL BASSDEF(BASS_ChannelRemoveSync)(DWORD handle, HSYNC sync); ; Remove a sync from a channel ; handle : Channel handle ; sync : Handle of sync to remove ;HDSP BASSDEF(BASS_ChannelSetDSP)(DWORD handle, DSPPROC *proc, DWORD user); ; Setup a user DSP function on a channel. When multiple DSP functions ; are used on a channel, they are called in the order that they were added. ; handle : Channel handle (HMUSIC/HSTREAM) ; proc : User defined callback function ; user : The 'user' value passed to the callback function ; RETURN : DSP handle (NULL=error) ;BOOL BASSDEF(BASS_ChannelRemoveDSP)(DWORD handle, HDSP dsp); ; Remove a DSP function from a channel ; handle : Channel handle (HMUSIC/HSTREAM) ; dsp : Handle of DSP to remove ;HFX BASSDEF(BASS_ChannelSetFX)(DWORD handle, DWORD type); ; Setup a DX8 effect on a channel. Can only be used when the channel ; is not playing. Use BASS_FXSetParameters to set the effect parameters. ; Obviously requires DX8. ; handle : Channel handle (HMUSIC/HSTREAM) ; type : Type of effect to setup (BASS_FX_xxx) ; RETURN : FX handle (NULL=error) ;BOOL BASSDEF(BASS_ChannelRemoveFX)(DWORD handle, HFX fx); ; Remove a DX8 effect from a channel. Can only be used when the ; channel is not playing. ; handle : Channel handle (HMUSIC/HSTREAM) ; fx : Handle of FX to remove ;BOOL BASSDEF(BASS_ChannelSetEAXMix)(DWORD handle, float mix); ; Set the wet(reverb)/dry(no reverb) mix ratio on the channel. By default ; the distance of the sound from the listener is used to calculate the mix. ; NOTE: The channel must have 3D functionality enabled for the EAX environment ; to have any affect on it. ; handle : Channel handle (HCHANNEL/HSTREAM/HMUSIC) ; mix : The ratio (0.0=reverb off, 1.0=max reverb, -1.0=let EAX calculate ; the reverb mix based on the distance) ;BOOL BASSDEF(BASS_ChannelGetEAXMix)(DWORD handle, float *mix); ; Get the wet(reverb)/dry(no reverb) mix ratio on the channel. ; handle : Channel handle (HCHANNEL/HSTREAM/HMUSIC) ; mix : Pointer to store the ratio at ;BOOL BASSDEF(BASS_ChannelSetLink)(DWORD handle, DWORD chan); ; Set a link between 2 channels. When the 1st is played/stopped/paused/resumed ; the 2nd channel is also played/stopped/paused/resumed. ; handle : Handle of channel to link "chan" to (HMUSIC/HSTREAM) ; chan : Handle of channel to link to "handle" (HMUSIC/HSTREAM) ;BOOL BASSDEF(BASS_ChannelRemoveLink)(DWORD handle, DWORD chan); ; Remove a link from a channel. ; handle : Handle of channel to unlink with "chan" (HMUSIC/HSTREAM) ; chan : Handle of channel to unlink from "handle" (HMUSIC/HSTREAM) ;BOOL BASSDEF(BASS_FXSetParameters)(HFX handle, void *par); ; Set the parameters of a DX8 effect. ; handle : FX handle ; par : Pointer to the parameter structure ;BOOL BASSDEF(BASS_FXGetParameters)(HFX handle, void *par); ; Retrieve the parameters of a DX8 effect. ; handle : FX handle ; par : Pointer to the parameter structure BASS_Apply3D PROTO BASS_CDFree PROTO BASS_CDGetTrackLength PROTO :DWORD BASS_CDGetTracks PROTO BASS_CDInDrive PROTO BASS_CDInit PROTO :DWORD BASS_CDPlay PROTO :DWORD,:DWORD,:DWORD BASS_ChannelGet3DAttributes PROTO :DWORD,:DWORD,:DWORD,:DWORD,:DWORD,:DWORD,:DWORD BASS_ChannelGet3DPosition PROTO :DWORD,:DWORD,:DWORD,:DWORD BASS_ChannelGetAttributes PROTO :DWORD,:DWORD,:DWORD,:DWORD BASS_ChannelGetData PROTO :DWORD,:DWORD,:DWORD BASS_ChannelGetEAXMix PROTO :DWORD,:DWORD BASS_ChannelGetFlags PROTO :DWORD BASS_ChannelGetLevel PROTO :DWORD BASS_ChannelGetPosition PROTO :DWORD BASS_ChannelIsActive PROTO :DWORD BASS_ChannelPause PROTO :DWORD BASS_ChannelRemoveDSP PROTO :DWORD,:DWORD BASS_ChannelRemoveSync PROTO :DWORD,:DWORD BASS_ChannelResume PROTO :DWORD BASS_ChannelSet3DAttributes PROTO :DWORD,:DWORD,:DWORD,:DWORD,:DWORD,:DWORD,:DWORD BASS_ChannelSet3DPosition PROTO :DWORD,:DWORD,:DWORD,:DWORD BASS_ChannelSetAttributes PROTO :DWORD,:DWORD,:DWORD,:DWORD BASS_ChannelSetDSP PROTO :DWORD,:DWORD,:DWORD BASS_ChannelSetEAXMix PROTO :DWORD,:DWORD BASS_ChannelSetPosition PROTO :DWORD,:DWORD BASS_ChannelSetSync PROTO :DWORD,:DWORD,:DWORD,:DWORD,:DWORD BASS_ChannelStop PROTO :DWORD BASS_ErrorGetCode PROTO BASS_Free PROTO BASS_Get3DFactors PROTO :DWORD,:DWORD,:DWORD BASS_Get3DPosition PROTO :DWORD,:DWORD,:DWORD,:DWORD BASS_GetA3DHFAbsorbtion PROTO :DWORD BASS_GetA3DResManager PROTO BASS_GetCPU PROTO BASS_GetDSoundObject PROTO :DWORD BASS_GetDeviceDescription PROTO :DWORD,:DWORD BASS_GetEAXParameters PROTO :DWORD,:DWORD,:DWORD,:DWORD BASS_GetGlobalVolumes PROTO :DWORD,:DWORD,:DWORD BASS_GetInfo PROTO :DWORD BASS_GetVersion PROTO BASS_GetVolume PROTO BASS_Init PROTO :DWORD,:DWORD,:DWORD,:DWORD BASS_MusicFree PROTO :DWORD BASS_MusicGetLength PROTO :DWORD BASS_MusicGetName PROTO :DWORD BASS_MusicLoad PROTO :DWORD,:DWORD,:DWORD,:DWORD,:DWORD BASS_MusicPlay PROTO :DWORD BASS_MusicPlayEx PROTO :DWORD,:DWORD,:DWORD,:DWORD BASS_MusicSetAmplify PROTO :DWORD,:DWORD BASS_MusicSetPanSep PROTO :DWORD,:DWORD BASS_MusicSetPositionScaler PROTO :DWORD,:DWORD BASS_Pause PROTO BASS_SampleCreate PROTO :DWORD,:DWORD,:DWORD,:DWORD BASS_SampleCreateDone PROTO BASS_SampleFree PROTO :DWORD BASS_SampleGetInfo PROTO :DWORD,:DWORD BASS_SampleLoad PROTO :DWORD,:DWORD,:DWORD,:DWORD,:DWORD,:DWORD BASS_SamplePlay PROTO :DWORD BASS_SamplePlay3D PROTO :DWORD,:DWORD,:DWORD,:DWORD BASS_SamplePlay3DEx PROTO :DWORD,:DWORD,:DWORD,:DWORD,:DWORD,:DWORD,:DWORD,:DWORD BASS_SamplePlayEx PROTO :DWORD,:DWORD,:DWORD,:DWORD,:DWORD,:DWORD BASS_SampleSetInfo PROTO :DWORD,:DWORD BASS_SampleStop PROTO :DWORD BASS_Set3DAlgorithm PROTO :DWORD BASS_Set3DFactors PROTO :DWORD,:DWORD,:DWORD BASS_Set3DPosition PROTO :DWORD,:DWORD,:DWORD,:DWORD BASS_SetA3DHFAbsorbtion PROTO :DWORD BASS_SetA3DResManager PROTO :DWORD BASS_SetBufferLength PROTO :DWORD BASS_SetEAXParameters PROTO :DWORD,:DWORD,:DWORD,:DWORD BASS_SetGlobalVolumes PROTO :DWORD,:DWORD,:DWORD BASS_SetLogCurves PROTO :DWORD,:DWORD BASS_SetVolume PROTO :DWORD BASS_Start PROTO BASS_Stop PROTO BASS_StreamCreate PROTO :DWORD,:DWORD,:DWORD,:DWORD BASS_StreamCreateFile PROTO :DWORD,:DWORD,:DWORD,:DWORD,:DWORD BASS_StreamCreateURL PROTO :DWORD,:DWORD,:DWORD BASS_StreamFree PROTO :DWORD BASS_StreamGetFilePosition PROTO :DWORD,:DWORD BASS_StreamGetLength PROTO :DWORD BASS_StreamPlay PROTO :DWORD,:DWORD,:DWORD