· 6 years ago · Mar 22, 2020, 03:30 AM
1/*
2 BASS 2.4 C/C++ header file
3 Copyright (c) 1999-2016 Un4seen Developments Ltd.
4
5 See the BASS.CHM file for more detailed documentation
6*/
7
8#ifndef BASS_H
9#define BASS_H
10
11#ifdef _WIN32
12
13#include "dll.h"
14
15#include <wtypes.h>
16typedef unsigned __int64 QWORD;
17#else
18#include <stdint.h>
19#define WINAPI
20#define CALLBACK
21typedef uint8_t BYTE;
22typedef uint16_t WORD;
23typedef uint32_t DWORD;
24typedef uint64_t QWORD;
25#ifndef __OBJC__
26typedef int BOOL;
27#endif
28#ifndef TRUE
29#define TRUE 1
30#define FALSE 0
31#endif
32#define LOBYTE(a) (BYTE)(a)
33#define HIBYTE(a) (BYTE)((a)>>8)
34#define LOWORD(a) (WORD)(a)
35#define HIWORD(a) (WORD)((a)>>16)
36#define MAKEWORD(a,b) (WORD)(((a)&0xff)|((b)<<8))
37#define MAKELONG(a,b) (DWORD)(((a)&0xffff)|((b)<<16))
38#endif
39
40#ifdef __cplusplus
41extern "C" {
42#endif
43
44#define BASSVERSION 0x204 // API version
45#define BASSVERSIONTEXT "2.4"
46
47#ifndef BASSDEF
48#define BASSDEF(f) WINAPI f
49#else
50#define NOBASSOVERLOADS
51#endif
52
53 typedef DWORD HMUSIC; // MOD music handle
54 typedef DWORD HSAMPLE; // sample handle
55 typedef DWORD HCHANNEL; // playing sample's channel handle
56 typedef DWORD HSTREAM; // sample stream handle
57 typedef DWORD HRECORD; // recording handle
58 typedef DWORD HSYNC; // synchronizer handle
59 typedef DWORD HDSP; // DSP handle
60 typedef DWORD HFX; // DX8 effect handle
61 typedef DWORD HPLUGIN; // Plugin handle
62
63 // Error codes returned by BASS_ErrorGetCode
64#define BASS_OK 0 // all is OK
65#define BASS_ERROR_MEM 1 // memory error
66#define BASS_ERROR_FILEOPEN 2 // can't open the file
67#define BASS_ERROR_DRIVER 3 // can't find a free/valid driver
68#define BASS_ERROR_BUFLOST 4 // the sample buffer was lost
69#define BASS_ERROR_HANDLE 5 // invalid handle
70#define BASS_ERROR_FORMAT 6 // unsupported sample format
71#define BASS_ERROR_POSITION 7 // invalid position
72#define BASS_ERROR_INIT 8 // BASS_Init has not been successfully called
73#define BASS_ERROR_START 9 // BASS_Start has not been successfully called
74#define BASS_ERROR_SSL 10 // SSL/HTTPS support isn't available
75#define BASS_ERROR_ALREADY 14 // already initialized/paused/whatever
76#define BASS_ERROR_NOCHAN 18 // can't get a free channel
77#define BASS_ERROR_ILLTYPE 19 // an illegal type was specified
78#define BASS_ERROR_ILLPARAM 20 // an illegal parameter was specified
79#define BASS_ERROR_NO3D 21 // no 3D support
80#define BASS_ERROR_NOEAX 22 // no EAX support
81#define BASS_ERROR_DEVICE 23 // illegal device number
82#define BASS_ERROR_NOPLAY 24 // not playing
83#define BASS_ERROR_FREQ 25 // illegal sample rate
84#define BASS_ERROR_NOTFILE 27 // the stream is not a file stream
85#define BASS_ERROR_NOHW 29 // no hardware voices available
86#define BASS_ERROR_EMPTY 31 // the MOD music has no sequence data
87#define BASS_ERROR_NONET 32 // no internet connection could be opened
88#define BASS_ERROR_CREATE 33 // couldn't create the file
89#define BASS_ERROR_NOFX 34 // effects are not available
90#define BASS_ERROR_NOTAVAIL 37 // requested data is not available
91#define BASS_ERROR_DECODE 38 // the channel is/isn't a "decoding channel"
92#define BASS_ERROR_DX 39 // a sufficient DirectX version is not installed
93#define BASS_ERROR_TIMEOUT 40 // connection timedout
94#define BASS_ERROR_FILEFORM 41 // unsupported file format
95#define BASS_ERROR_SPEAKER 42 // unavailable speaker
96#define BASS_ERROR_VERSION 43 // invalid BASS version (used by add-ons)
97#define BASS_ERROR_CODEC 44 // codec is not available/supported
98#define BASS_ERROR_ENDED 45 // the channel/file has ended
99#define BASS_ERROR_BUSY 46 // the device is busy
100#define BASS_ERROR_UNKNOWN -1 // some other mystery problem
101
102// BASS_SetConfig options
103#define BASS_CONFIG_BUFFER 0
104#define BASS_CONFIG_UPDATEPERIOD 1
105#define BASS_CONFIG_GVOL_SAMPLE 4
106#define BASS_CONFIG_GVOL_STREAM 5
107#define BASS_CONFIG_GVOL_MUSIC 6
108#define BASS_CONFIG_CURVE_VOL 7
109#define BASS_CONFIG_CURVE_PAN 8
110#define BASS_CONFIG_FLOATDSP 9
111#define BASS_CONFIG_3DALGORITHM 10
112#define BASS_CONFIG_NET_TIMEOUT 11
113#define BASS_CONFIG_NET_BUFFER 12
114#define BASS_CONFIG_PAUSE_NOPLAY 13
115#define BASS_CONFIG_NET_PREBUF 15
116#define BASS_CONFIG_NET_PASSIVE 18
117#define BASS_CONFIG_REC_BUFFER 19
118#define BASS_CONFIG_NET_PLAYLIST 21
119#define BASS_CONFIG_MUSIC_VIRTUAL 22
120#define BASS_CONFIG_VERIFY 23
121#define BASS_CONFIG_UPDATETHREADS 24
122#define BASS_CONFIG_DEV_BUFFER 27
123#define BASS_CONFIG_VISTA_TRUEPOS 30
124#define BASS_CONFIG_IOS_MIXAUDIO 34
125#define BASS_CONFIG_DEV_DEFAULT 36
126#define BASS_CONFIG_NET_READTIMEOUT 37
127#define BASS_CONFIG_VISTA_SPEAKERS 38
128#define BASS_CONFIG_IOS_SPEAKER 39
129#define BASS_CONFIG_MF_DISABLE 40
130#define BASS_CONFIG_HANDLES 41
131#define BASS_CONFIG_UNICODE 42
132#define BASS_CONFIG_SRC 43
133#define BASS_CONFIG_SRC_SAMPLE 44
134#define BASS_CONFIG_ASYNCFILE_BUFFER 45
135#define BASS_CONFIG_OGG_PRESCAN 47
136#define BASS_CONFIG_MF_VIDEO 48
137#define BASS_CONFIG_AIRPLAY 49
138#define BASS_CONFIG_DEV_NONSTOP 50
139#define BASS_CONFIG_IOS_NOCATEGORY 51
140#define BASS_CONFIG_VERIFY_NET 52
141#define BASS_CONFIG_DEV_PERIOD 53
142#define BASS_CONFIG_FLOAT 54
143#define BASS_CONFIG_NET_SEEK 56
144
145// BASS_SetConfigPtr options
146#define BASS_CONFIG_NET_AGENT 16
147#define BASS_CONFIG_NET_PROXY 17
148#define BASS_CONFIG_IOS_NOTIFY 46
149
150// BASS_Init flags
151#define BASS_DEVICE_8BITS 1 // 8 bit
152#define BASS_DEVICE_MONO 2 // mono
153#define BASS_DEVICE_3D 4 // enable 3D functionality
154#define BASS_DEVICE_16BITS 8 // limit output to 16 bit
155#define BASS_DEVICE_LATENCY 0x100 // calculate device latency (BASS_INFO struct)
156#define BASS_DEVICE_CPSPEAKERS 0x400 // detect speakers via Windows control panel
157#define BASS_DEVICE_SPEAKERS 0x800 // force enabling of speaker assignment
158#define BASS_DEVICE_NOSPEAKER 0x1000 // ignore speaker arrangement
159#define BASS_DEVICE_DMIX 0x2000 // use ALSA "dmix" plugin
160#define BASS_DEVICE_FREQ 0x4000 // set device sample rate
161#define BASS_DEVICE_STEREO 0x8000 // limit output to stereo
162
163// DirectSound interfaces (for use with BASS_GetDSoundObject)
164#define BASS_OBJECT_DS 1 // IDirectSound
165#define BASS_OBJECT_DS3DL 2 // IDirectSound3DListener
166
167// Device info structure
168 typedef struct {
169#if defined(_WIN32_WCE) || (WINAPI_FAMILY && WINAPI_FAMILY!=WINAPI_FAMILY_DESKTOP_APP)
170 const wchar_t *name; // description
171 const wchar_t *driver; // driver
172#else
173 const char *name; // description
174 const char *driver; // driver
175#endif
176 DWORD flags;
177 } BASS_DEVICEINFO;
178
179 // BASS_DEVICEINFO flags
180#define BASS_DEVICE_ENABLED 1
181#define BASS_DEVICE_DEFAULT 2
182#define BASS_DEVICE_INIT 4
183
184#define BASS_DEVICE_TYPE_MASK 0xff000000
185#define BASS_DEVICE_TYPE_NETWORK 0x01000000
186#define BASS_DEVICE_TYPE_SPEAKERS 0x02000000
187#define BASS_DEVICE_TYPE_LINE 0x03000000
188#define BASS_DEVICE_TYPE_HEADPHONES 0x04000000
189#define BASS_DEVICE_TYPE_MICROPHONE 0x05000000
190#define BASS_DEVICE_TYPE_HEADSET 0x06000000
191#define BASS_DEVICE_TYPE_HANDSET 0x07000000
192#define BASS_DEVICE_TYPE_DIGITAL 0x08000000
193#define BASS_DEVICE_TYPE_SPDIF 0x09000000
194#define BASS_DEVICE_TYPE_HDMI 0x0a000000
195#define BASS_DEVICE_TYPE_DISPLAYPORT 0x40000000
196
197// BASS_GetDeviceInfo flags
198#define BASS_DEVICES_AIRPLAY 0x1000000
199
200 typedef struct {
201 DWORD flags; // device capabilities (DSCAPS_xxx flags)
202 DWORD hwsize; // size of total device hardware memory
203 DWORD hwfree; // size of free device hardware memory
204 DWORD freesam; // number of free sample slots in the hardware
205 DWORD free3d; // number of free 3D sample slots in the hardware
206 DWORD minrate; // min sample rate supported by the hardware
207 DWORD maxrate; // max sample rate supported by the hardware
208 BOOL eax; // device supports EAX? (always FALSE if BASS_DEVICE_3D was not used)
209 DWORD minbuf; // recommended minimum buffer length in ms (requires BASS_DEVICE_LATENCY)
210 DWORD dsver; // DirectSound version
211 DWORD latency; // delay (in ms) before start of playback (requires BASS_DEVICE_LATENCY)
212 DWORD initflags; // BASS_Init "flags" parameter
213 DWORD speakers; // number of speakers available
214 DWORD freq; // current output rate
215 } BASS_INFO;
216
217 // BASS_INFO flags (from DSOUND.H)
218#define DSCAPS_CONTINUOUSRATE 0x00000010 // supports all sample rates between min/maxrate
219#define DSCAPS_EMULDRIVER 0x00000020 // device does NOT have hardware DirectSound support
220#define DSCAPS_CERTIFIED 0x00000040 // device driver has been certified by Microsoft
221#define DSCAPS_SECONDARYMONO 0x00000100 // mono
222#define DSCAPS_SECONDARYSTEREO 0x00000200 // stereo
223#define DSCAPS_SECONDARY8BIT 0x00000400 // 8 bit
224#define DSCAPS_SECONDARY16BIT 0x00000800 // 16 bit
225
226// Recording device info structure
227 typedef struct {
228 DWORD flags; // device capabilities (DSCCAPS_xxx flags)
229 DWORD formats; // supported standard formats (WAVE_FORMAT_xxx flags)
230 DWORD inputs; // number of inputs
231 BOOL singlein; // TRUE = only 1 input can be set at a time
232 DWORD freq; // current input rate
233 } BASS_RECORDINFO;
234
235 // BASS_RECORDINFO flags (from DSOUND.H)
236#define DSCCAPS_EMULDRIVER DSCAPS_EMULDRIVER // device does NOT have hardware DirectSound recording support
237#define DSCCAPS_CERTIFIED DSCAPS_CERTIFIED // device driver has been certified by Microsoft
238
239// defines for formats field of BASS_RECORDINFO (from MMSYSTEM.H)
240#ifndef WAVE_FORMAT_1M08
241#define WAVE_FORMAT_1M08 0x00000001 /* 11.025 kHz, Mono, 8-bit */
242#define WAVE_FORMAT_1S08 0x00000002 /* 11.025 kHz, Stereo, 8-bit */
243#define WAVE_FORMAT_1M16 0x00000004 /* 11.025 kHz, Mono, 16-bit */
244#define WAVE_FORMAT_1S16 0x00000008 /* 11.025 kHz, Stereo, 16-bit */
245#define WAVE_FORMAT_2M08 0x00000010 /* 22.05 kHz, Mono, 8-bit */
246#define WAVE_FORMAT_2S08 0x00000020 /* 22.05 kHz, Stereo, 8-bit */
247#define WAVE_FORMAT_2M16 0x00000040 /* 22.05 kHz, Mono, 16-bit */
248#define WAVE_FORMAT_2S16 0x00000080 /* 22.05 kHz, Stereo, 16-bit */
249#define WAVE_FORMAT_4M08 0x00000100 /* 44.1 kHz, Mono, 8-bit */
250#define WAVE_FORMAT_4S08 0x00000200 /* 44.1 kHz, Stereo, 8-bit */
251#define WAVE_FORMAT_4M16 0x00000400 /* 44.1 kHz, Mono, 16-bit */
252#define WAVE_FORMAT_4S16 0x00000800 /* 44.1 kHz, Stereo, 16-bit */
253#endif
254
255// Sample info structure
256 typedef struct {
257 DWORD freq; // default playback rate
258 float volume; // default volume (0-1)
259 float pan; // default pan (-1=left, 0=middle, 1=right)
260 DWORD flags; // BASS_SAMPLE_xxx flags
261 DWORD length; // length (in bytes)
262 DWORD max; // maximum simultaneous playbacks
263 DWORD origres; // original resolution bits
264 DWORD chans; // number of channels
265 DWORD mingap; // minimum gap (ms) between creating channels
266 DWORD mode3d; // BASS_3DMODE_xxx mode
267 float mindist; // minimum distance
268 float maxdist; // maximum distance
269 DWORD iangle; // angle of inside projection cone
270 DWORD oangle; // angle of outside projection cone
271 float outvol; // delta-volume outside the projection cone
272 DWORD vam; // voice allocation/management flags (BASS_VAM_xxx)
273 DWORD priority; // priority (0=lowest, 0xffffffff=highest)
274 } BASS_SAMPLE;
275
276#define BASS_SAMPLE_8BITS 1 // 8 bit
277#define BASS_SAMPLE_FLOAT 256 // 32 bit floating-point
278#define BASS_SAMPLE_MONO 2 // mono
279#define BASS_SAMPLE_LOOP 4 // looped
280#define BASS_SAMPLE_3D 8 // 3D functionality
281#define BASS_SAMPLE_SOFTWARE 16 // not using hardware mixing
282#define BASS_SAMPLE_MUTEMAX 32 // mute at max distance (3D only)
283#define BASS_SAMPLE_VAM 64 // DX7 voice allocation & management
284#define BASS_SAMPLE_FX 128 // old implementation of DX8 effects
285#define BASS_SAMPLE_OVER_VOL 0x10000 // override lowest volume
286#define BASS_SAMPLE_OVER_POS 0x20000 // override longest playing
287#define BASS_SAMPLE_OVER_DIST 0x30000 // override furthest from listener (3D only)
288
289#define BASS_STREAM_PRESCAN 0x20000 // enable pin-point seeking/length (MP3/MP2/MP1)
290#define BASS_MP3_SETPOS BASS_STREAM_PRESCAN
291#define BASS_STREAM_AUTOFREE 0x40000 // automatically free the stream when it stop/ends
292#define BASS_STREAM_RESTRATE 0x80000 // restrict the download rate of internet file streams
293#define BASS_STREAM_BLOCK 0x100000 // download/play internet file stream in small blocks
294#define BASS_STREAM_DECODE 0x200000 // don't play the stream, only decode (BASS_ChannelGetData)
295#define BASS_STREAM_STATUS 0x800000 // give server status info (HTTP/ICY tags) in DOWNLOADPROC
296
297#define BASS_MUSIC_FLOAT BASS_SAMPLE_FLOAT
298#define BASS_MUSIC_MONO BASS_SAMPLE_MONO
299#define BASS_MUSIC_LOOP BASS_SAMPLE_LOOP
300#define BASS_MUSIC_3D BASS_SAMPLE_3D
301#define BASS_MUSIC_FX BASS_SAMPLE_FX
302#define BASS_MUSIC_AUTOFREE BASS_STREAM_AUTOFREE
303#define BASS_MUSIC_DECODE BASS_STREAM_DECODE
304#define BASS_MUSIC_PRESCAN BASS_STREAM_PRESCAN // calculate playback length
305#define BASS_MUSIC_CALCLEN BASS_MUSIC_PRESCAN
306#define BASS_MUSIC_RAMP 0x200 // normal ramping
307#define BASS_MUSIC_RAMPS 0x400 // sensitive ramping
308#define BASS_MUSIC_SURROUND 0x800 // surround sound
309#define BASS_MUSIC_SURROUND2 0x1000 // surround sound (mode 2)
310#define BASS_MUSIC_FT2PAN 0x2000 // apply FastTracker 2 panning to XM files
311#define BASS_MUSIC_FT2MOD 0x2000 // play .MOD as FastTracker 2 does
312#define BASS_MUSIC_PT1MOD 0x4000 // play .MOD as ProTracker 1 does
313#define BASS_MUSIC_NONINTER 0x10000 // non-interpolated sample mixing
314#define BASS_MUSIC_SINCINTER 0x800000 // sinc interpolated sample mixing
315#define BASS_MUSIC_POSRESET 0x8000 // stop all notes when moving position
316#define BASS_MUSIC_POSRESETEX 0x400000 // stop all notes and reset bmp/etc when moving position
317#define BASS_MUSIC_STOPBACK 0x80000 // stop the music on a backwards jump effect
318#define BASS_MUSIC_NOSAMPLE 0x100000 // don't load the samples
319
320 // Speaker assignment flags
321#define BASS_SPEAKER_FRONT 0x1000000 // front speakers
322#define BASS_SPEAKER_REAR 0x2000000 // rear/side speakers
323#define BASS_SPEAKER_CENLFE 0x3000000 // center & LFE speakers (5.1)
324#define BASS_SPEAKER_REAR2 0x4000000 // rear center speakers (7.1)
325#define BASS_SPEAKER_N(n) ((n)<<24) // n'th pair of speakers (max 15)
326#define BASS_SPEAKER_LEFT 0x10000000 // modifier: left
327#define BASS_SPEAKER_RIGHT 0x20000000 // modifier: right
328#define BASS_SPEAKER_FRONTLEFT BASS_SPEAKER_FRONT|BASS_SPEAKER_LEFT
329#define BASS_SPEAKER_FRONTRIGHT BASS_SPEAKER_FRONT|BASS_SPEAKER_RIGHT
330#define BASS_SPEAKER_REARLEFT BASS_SPEAKER_REAR|BASS_SPEAKER_LEFT
331#define BASS_SPEAKER_REARRIGHT BASS_SPEAKER_REAR|BASS_SPEAKER_RIGHT
332#define BASS_SPEAKER_CENTER BASS_SPEAKER_CENLFE|BASS_SPEAKER_LEFT
333#define BASS_SPEAKER_LFE BASS_SPEAKER_CENLFE|BASS_SPEAKER_RIGHT
334#define BASS_SPEAKER_REAR2LEFT BASS_SPEAKER_REAR2|BASS_SPEAKER_LEFT
335#define BASS_SPEAKER_REAR2RIGHT BASS_SPEAKER_REAR2|BASS_SPEAKER_RIGHT
336
337#define BASS_ASYNCFILE 0x40000000
338#define BASS_UNICODE 0x80000000
339
340#define BASS_RECORD_PAUSE 0x8000 // start recording paused
341#define BASS_RECORD_ECHOCANCEL 0x2000
342#define BASS_RECORD_AGC 0x4000
343
344// DX7 voice allocation & management flags
345#define BASS_VAM_HARDWARE 1
346#define BASS_VAM_SOFTWARE 2
347#define BASS_VAM_TERM_TIME 4
348#define BASS_VAM_TERM_DIST 8
349#define BASS_VAM_TERM_PRIO 16
350
351// Channel info structure
352 typedef struct {
353 DWORD freq; // default playback rate
354 DWORD chans; // channels
355 DWORD flags; // BASS_SAMPLE/STREAM/MUSIC/SPEAKER flags
356 DWORD ctype; // type of channel
357 DWORD origres; // original resolution
358 HPLUGIN plugin; // plugin
359 HSAMPLE sample; // sample
360 const char *filename; // filename
361 } BASS_CHANNELINFO;
362
363 // BASS_CHANNELINFO types
364#define BASS_CTYPE_SAMPLE 1
365#define BASS_CTYPE_RECORD 2
366#define BASS_CTYPE_STREAM 0x10000
367#define BASS_CTYPE_STREAM_OGG 0x10002
368#define BASS_CTYPE_STREAM_MP1 0x10003
369#define BASS_CTYPE_STREAM_MP2 0x10004
370#define BASS_CTYPE_STREAM_MP3 0x10005
371#define BASS_CTYPE_STREAM_AIFF 0x10006
372#define BASS_CTYPE_STREAM_CA 0x10007
373#define BASS_CTYPE_STREAM_MF 0x10008
374#define BASS_CTYPE_STREAM_WAV 0x40000 // WAVE flag, LOWORD=codec
375#define BASS_CTYPE_STREAM_WAV_PCM 0x50001
376#define BASS_CTYPE_STREAM_WAV_FLOAT 0x50003
377#define BASS_CTYPE_MUSIC_MOD 0x20000
378#define BASS_CTYPE_MUSIC_MTM 0x20001
379#define BASS_CTYPE_MUSIC_S3M 0x20002
380#define BASS_CTYPE_MUSIC_XM 0x20003
381#define BASS_CTYPE_MUSIC_IT 0x20004
382#define BASS_CTYPE_MUSIC_MO3 0x00100 // MO3 flag
383
384 typedef struct {
385 DWORD ctype; // channel type
386#if defined(_WIN32_WCE) || (WINAPI_FAMILY && WINAPI_FAMILY!=WINAPI_FAMILY_DESKTOP_APP)
387 const wchar_t *name; // format description
388 const wchar_t *exts; // file extension filter (*.ext1;*.ext2;etc...)
389#else
390 const char *name; // format description
391 const char *exts; // file extension filter (*.ext1;*.ext2;etc...)
392#endif
393 } BASS_PLUGINFORM;
394
395 typedef struct {
396 DWORD version; // version (same form as BASS_GetVersion)
397 DWORD formatc; // number of formats
398 const BASS_PLUGINFORM *formats; // the array of formats
399 } BASS_PLUGININFO;
400
401 // 3D vector (for 3D positions/velocities/orientations)
402 typedef struct BASS_3DVECTOR {
403#ifdef __cplusplus
404 BASS_3DVECTOR() {};
405 BASS_3DVECTOR(float _x, float _y, float _z) : x(_x), y(_y), z(_z) {};
406#endif
407 float x; // +=right, -=left
408 float y; // +=up, -=down
409 float z; // +=front, -=behind
410 } BASS_3DVECTOR;
411
412 // 3D channel modes
413#define BASS_3DMODE_NORMAL 0 // normal 3D processing
414#define BASS_3DMODE_RELATIVE 1 // position is relative to the listener
415#define BASS_3DMODE_OFF 2 // no 3D processing
416
417// software 3D mixing algorithms (used with BASS_CONFIG_3DALGORITHM)
418#define BASS_3DALG_DEFAULT 0
419#define BASS_3DALG_OFF 1
420#define BASS_3DALG_FULL 2
421#define BASS_3DALG_LIGHT 3
422
423// EAX environments, use with BASS_SetEAXParameters
424 enum
425 {
426 EAX_ENVIRONMENT_GENERIC,
427 EAX_ENVIRONMENT_PADDEDCELL,
428 EAX_ENVIRONMENT_ROOM,
429 EAX_ENVIRONMENT_BATHROOM,
430 EAX_ENVIRONMENT_LIVINGROOM,
431 EAX_ENVIRONMENT_STONEROOM,
432 EAX_ENVIRONMENT_AUDITORIUM,
433 EAX_ENVIRONMENT_CONCERTHALL,
434 EAX_ENVIRONMENT_CAVE,
435 EAX_ENVIRONMENT_ARENA,
436 EAX_ENVIRONMENT_HANGAR,
437 EAX_ENVIRONMENT_CARPETEDHALLWAY,
438 EAX_ENVIRONMENT_HALLWAY,
439 EAX_ENVIRONMENT_STONECORRIDOR,
440 EAX_ENVIRONMENT_ALLEY,
441 EAX_ENVIRONMENT_FOREST,
442 EAX_ENVIRONMENT_CITY,
443 EAX_ENVIRONMENT_MOUNTAINS,
444 EAX_ENVIRONMENT_QUARRY,
445 EAX_ENVIRONMENT_PLAIN,
446 EAX_ENVIRONMENT_PARKINGLOT,
447 EAX_ENVIRONMENT_SEWERPIPE,
448 EAX_ENVIRONMENT_UNDERWATER,
449 EAX_ENVIRONMENT_DRUGGED,
450 EAX_ENVIRONMENT_DIZZY,
451 EAX_ENVIRONMENT_PSYCHOTIC,
452
453 EAX_ENVIRONMENT_COUNT // total number of environments
454 };
455
456 // EAX presets, usage: BASS_SetEAXParameters(EAX_PRESET_xxx)
457#define EAX_PRESET_GENERIC EAX_ENVIRONMENT_GENERIC,0.5F,1.493F,0.5F
458#define EAX_PRESET_PADDEDCELL EAX_ENVIRONMENT_PADDEDCELL,0.25F,0.1F,0.0F
459#define EAX_PRESET_ROOM EAX_ENVIRONMENT_ROOM,0.417F,0.4F,0.666F
460#define EAX_PRESET_BATHROOM EAX_ENVIRONMENT_BATHROOM,0.653F,1.499F,0.166F
461#define EAX_PRESET_LIVINGROOM EAX_ENVIRONMENT_LIVINGROOM,0.208F,0.478F,0.0F
462#define EAX_PRESET_STONEROOM EAX_ENVIRONMENT_STONEROOM,0.5F,2.309F,0.888F
463#define EAX_PRESET_AUDITORIUM EAX_ENVIRONMENT_AUDITORIUM,0.403F,4.279F,0.5F
464#define EAX_PRESET_CONCERTHALL EAX_ENVIRONMENT_CONCERTHALL,0.5F,3.961F,0.5F
465#define EAX_PRESET_CAVE EAX_ENVIRONMENT_CAVE,0.5F,2.886F,1.304F
466#define EAX_PRESET_ARENA EAX_ENVIRONMENT_ARENA,0.361F,7.284F,0.332F
467#define EAX_PRESET_HANGAR EAX_ENVIRONMENT_HANGAR,0.5F,10.0F,0.3F
468#define EAX_PRESET_CARPETEDHALLWAY EAX_ENVIRONMENT_CARPETEDHALLWAY,0.153F,0.259F,2.0F
469#define EAX_PRESET_HALLWAY EAX_ENVIRONMENT_HALLWAY,0.361F,1.493F,0.0F
470#define EAX_PRESET_STONECORRIDOR EAX_ENVIRONMENT_STONECORRIDOR,0.444F,2.697F,0.638F
471#define EAX_PRESET_ALLEY EAX_ENVIRONMENT_ALLEY,0.25F,1.752F,0.776F
472#define EAX_PRESET_FOREST EAX_ENVIRONMENT_FOREST,0.111F,3.145F,0.472F
473#define EAX_PRESET_CITY EAX_ENVIRONMENT_CITY,0.111F,2.767F,0.224F
474#define EAX_PRESET_MOUNTAINS EAX_ENVIRONMENT_MOUNTAINS,0.194F,7.841F,0.472F
475#define EAX_PRESET_QUARRY EAX_ENVIRONMENT_QUARRY,1.0F,1.499F,0.5F
476#define EAX_PRESET_PLAIN EAX_ENVIRONMENT_PLAIN,0.097F,2.767F,0.224F
477#define EAX_PRESET_PARKINGLOT EAX_ENVIRONMENT_PARKINGLOT,0.208F,1.652F,1.5F
478#define EAX_PRESET_SEWERPIPE EAX_ENVIRONMENT_SEWERPIPE,0.652F,2.886F,0.25F
479#define EAX_PRESET_UNDERWATER EAX_ENVIRONMENT_UNDERWATER,1.0F,1.499F,0.0F
480#define EAX_PRESET_DRUGGED EAX_ENVIRONMENT_DRUGGED,0.875F,8.392F,1.388F
481#define EAX_PRESET_DIZZY EAX_ENVIRONMENT_DIZZY,0.139F,17.234F,0.666F
482#define EAX_PRESET_PSYCHOTIC EAX_ENVIRONMENT_PSYCHOTIC,0.486F,7.563F,0.806F
483
484 typedef DWORD(CALLBACK STREAMPROC)(HSTREAM handle, void *buffer, DWORD length, void *user);
485 /* User stream callback function. NOTE: A stream function should obviously be as quick
486 as possible, other streams (and MOD musics) can't be mixed until it's finished.
487 handle : The stream that needs writing
488 buffer : Buffer to write the samples in
489 length : Number of bytes to write
490 user : The 'user' parameter value given when calling BASS_StreamCreate
491 RETURN : Number of bytes written. Set the BASS_STREAMPROC_END flag to end
492 the stream. */
493
494#define BASS_STREAMPROC_END 0x80000000 // end of user stream flag
495
496 // special STREAMPROCs
497#define STREAMPROC_DUMMY (STREAMPROC*)0 // "dummy" stream
498#define STREAMPROC_PUSH (STREAMPROC*)-1 // push stream
499
500// BASS_StreamCreateFileUser file systems
501#define STREAMFILE_NOBUFFER 0
502#define STREAMFILE_BUFFER 1
503#define STREAMFILE_BUFFERPUSH 2
504
505// User file stream callback functions
506 typedef void (CALLBACK FILECLOSEPROC)(void *user);
507 typedef QWORD(CALLBACK FILELENPROC)(void *user);
508 typedef DWORD(CALLBACK FILEREADPROC)(void *buffer, DWORD length, void *user);
509 typedef BOOL(CALLBACK FILESEEKPROC)(QWORD offset, void *user);
510
511 typedef struct {
512 FILECLOSEPROC *close;
513 FILELENPROC *length;
514 FILEREADPROC *read;
515 FILESEEKPROC *seek;
516 } BASS_FILEPROCS;
517
518 // BASS_StreamPutFileData options
519#define BASS_FILEDATA_END 0 // end & close the file
520
521// BASS_StreamGetFilePosition modes
522#define BASS_FILEPOS_CURRENT 0
523#define BASS_FILEPOS_DECODE BASS_FILEPOS_CURRENT
524#define BASS_FILEPOS_DOWNLOAD 1
525#define BASS_FILEPOS_END 2
526#define BASS_FILEPOS_START 3
527#define BASS_FILEPOS_CONNECTED 4
528#define BASS_FILEPOS_BUFFER 5
529#define BASS_FILEPOS_SOCKET 6
530#define BASS_FILEPOS_ASYNCBUF 7
531#define BASS_FILEPOS_SIZE 8
532
533 typedef void (CALLBACK DOWNLOADPROC)(const void *buffer, DWORD length, void *user);
534 /* Internet stream download callback function.
535 buffer : Buffer containing the downloaded data... NULL=end of download
536 length : Number of bytes in the buffer
537 user : The 'user' parameter value given when calling BASS_StreamCreateURL */
538
539 // BASS_ChannelSetSync types
540#define BASS_SYNC_POS 0
541#define BASS_SYNC_END 2
542#define BASS_SYNC_META 4
543#define BASS_SYNC_SLIDE 5
544#define BASS_SYNC_STALL 6
545#define BASS_SYNC_DOWNLOAD 7
546#define BASS_SYNC_FREE 8
547#define BASS_SYNC_SETPOS 11
548#define BASS_SYNC_MUSICPOS 10
549#define BASS_SYNC_MUSICINST 1
550#define BASS_SYNC_MUSICFX 3
551#define BASS_SYNC_OGG_CHANGE 12
552#define BASS_SYNC_MIXTIME 0x40000000 // flag: sync at mixtime, else at playtime
553#define BASS_SYNC_ONETIME 0x80000000 // flag: sync only once, else continuously
554
555 typedef void (CALLBACK SYNCPROC)(HSYNC handle, DWORD channel, DWORD data, void *user);
556 /* Sync callback function. NOTE: a sync callback function should be very
557 quick as other syncs can't be processed until it has finished. If the sync
558 is a "mixtime" sync, then other streams and MOD musics can't be mixed until
559 it's finished either.
560 handle : The sync that has occured
561 channel: Channel that the sync occured in
562 data : Additional data associated with the sync's occurance
563 user : The 'user' parameter given when calling BASS_ChannelSetSync */
564
565 typedef void (CALLBACK DSPPROC)(HDSP handle, DWORD channel, void *buffer, DWORD length, void *user);
566 /* DSP callback function. NOTE: A DSP function should obviously be as quick as
567 possible... other DSP functions, streams and MOD musics can not be processed
568 until it's finished.
569 handle : The DSP handle
570 channel: Channel that the DSP is being applied to
571 buffer : Buffer to apply the DSP to
572 length : Number of bytes in the buffer
573 user : The 'user' parameter given when calling BASS_ChannelSetDSP */
574
575 typedef BOOL(CALLBACK RECORDPROC)(HRECORD handle, const void *buffer, DWORD length, void *user);
576 /* Recording callback function.
577 handle : The recording handle
578 buffer : Buffer containing the recorded sample data
579 length : Number of bytes
580 user : The 'user' parameter value given when calling BASS_RecordStart
581 RETURN : TRUE = continue recording, FALSE = stop */
582
583 // BASS_ChannelIsActive return values
584#define BASS_ACTIVE_STOPPED 0
585#define BASS_ACTIVE_PLAYING 1
586#define BASS_ACTIVE_STALLED 2
587#define BASS_ACTIVE_PAUSED 3
588
589// Channel attributes
590#define BASS_ATTRIB_FREQ 1
591#define BASS_ATTRIB_VOL 2
592#define BASS_ATTRIB_PAN 3
593#define BASS_ATTRIB_EAXMIX 4
594#define BASS_ATTRIB_NOBUFFER 5
595#define BASS_ATTRIB_VBR 6
596#define BASS_ATTRIB_CPU 7
597#define BASS_ATTRIB_SRC 8
598#define BASS_ATTRIB_NET_RESUME 9
599#define BASS_ATTRIB_SCANINFO 10
600#define BASS_ATTRIB_NORAMP 11
601#define BASS_ATTRIB_BITRATE 12
602#define BASS_ATTRIB_MUSIC_AMPLIFY 0x100
603#define BASS_ATTRIB_MUSIC_PANSEP 0x101
604#define BASS_ATTRIB_MUSIC_PSCALER 0x102
605#define BASS_ATTRIB_MUSIC_BPM 0x103
606#define BASS_ATTRIB_MUSIC_SPEED 0x104
607#define BASS_ATTRIB_MUSIC_VOL_GLOBAL 0x105
608#define BASS_ATTRIB_MUSIC_ACTIVE 0x106
609#define BASS_ATTRIB_MUSIC_VOL_CHAN 0x200 // + channel #
610#define BASS_ATTRIB_MUSIC_VOL_INST 0x300 // + instrument #
611
612// BASS_ChannelGetData flags
613#define BASS_DATA_AVAILABLE 0 // query how much data is buffered
614#define BASS_DATA_FIXED 0x20000000 // flag: return 8.24 fixed-point data
615#define BASS_DATA_FLOAT 0x40000000 // flag: return floating-point sample data
616#define BASS_DATA_FFT256 0x80000000 // 256 sample FFT
617#define BASS_DATA_FFT512 0x80000001 // 512 FFT
618#define BASS_DATA_FFT1024 0x80000002 // 1024 FFT
619#define BASS_DATA_FFT2048 0x80000003 // 2048 FFT
620#define BASS_DATA_FFT4096 0x80000004 // 4096 FFT
621#define BASS_DATA_FFT8192 0x80000005 // 8192 FFT
622#define BASS_DATA_FFT16384 0x80000006 // 16384 FFT
623#define BASS_DATA_FFT32768 0x80000007 // 32768 FFT
624#define BASS_DATA_FFT_INDIVIDUAL 0x10 // FFT flag: FFT for each channel, else all combined
625#define BASS_DATA_FFT_NOWINDOW 0x20 // FFT flag: no Hanning window
626#define BASS_DATA_FFT_REMOVEDC 0x40 // FFT flag: pre-remove DC bias
627#define BASS_DATA_FFT_COMPLEX 0x80 // FFT flag: return complex data
628
629// BASS_ChannelGetLevelEx flags
630#define BASS_LEVEL_MONO 1
631#define BASS_LEVEL_STEREO 2
632#define BASS_LEVEL_RMS 4
633
634// BASS_ChannelGetTags types : what's returned
635#define BASS_TAG_ID3 0 // ID3v1 tags : TAG_ID3 structure
636#define BASS_TAG_ID3V2 1 // ID3v2 tags : variable length block
637#define BASS_TAG_OGG 2 // OGG comments : series of null-terminated UTF-8 strings
638#define BASS_TAG_HTTP 3 // HTTP headers : series of null-terminated ANSI strings
639#define BASS_TAG_ICY 4 // ICY headers : series of null-terminated ANSI strings
640#define BASS_TAG_META 5 // ICY metadata : ANSI string
641#define BASS_TAG_APE 6 // APE tags : series of null-terminated UTF-8 strings
642#define BASS_TAG_MP4 7 // MP4/iTunes metadata : series of null-terminated UTF-8 strings
643#define BASS_TAG_WMA 8 // WMA tags : series of null-terminated UTF-8 strings
644#define BASS_TAG_VENDOR 9 // OGG encoder : UTF-8 string
645#define BASS_TAG_LYRICS3 10 // Lyric3v2 tag : ASCII string
646#define BASS_TAG_CA_CODEC 11 // CoreAudio codec info : TAG_CA_CODEC structure
647#define BASS_TAG_MF 13 // Media Foundation tags : series of null-terminated UTF-8 strings
648#define BASS_TAG_WAVEFORMAT 14 // WAVE format : WAVEFORMATEEX structure
649#define BASS_TAG_RIFF_INFO 0x100 // RIFF "INFO" tags : series of null-terminated ANSI strings
650#define BASS_TAG_RIFF_BEXT 0x101 // RIFF/BWF "bext" tags : TAG_BEXT structure
651#define BASS_TAG_RIFF_CART 0x102 // RIFF/BWF "cart" tags : TAG_CART structure
652#define BASS_TAG_RIFF_DISP 0x103 // RIFF "DISP" text tag : ANSI string
653#define BASS_TAG_APE_BINARY 0x1000 // + index #, binary APE tag : TAG_APE_BINARY structure
654#define BASS_TAG_MUSIC_NAME 0x10000 // MOD music name : ANSI string
655#define BASS_TAG_MUSIC_MESSAGE 0x10001 // MOD message : ANSI string
656#define BASS_TAG_MUSIC_ORDERS 0x10002 // MOD order list : BYTE array of pattern numbers
657#define BASS_TAG_MUSIC_AUTH 0x10003 // MOD author : UTF-8 string
658#define BASS_TAG_MUSIC_INST 0x10100 // + instrument #, MOD instrument name : ANSI string
659#define BASS_TAG_MUSIC_SAMPLE 0x10300 // + sample #, MOD sample name : ANSI string
660
661// ID3v1 tag structure
662 typedef struct {
663 char id[3];
664 char title[30];
665 char artist[30];
666 char album[30];
667 char year[4];
668 char comment[30];
669 BYTE genre;
670 } TAG_ID3;
671
672 // Binary APE tag structure
673 typedef struct {
674 const char *key;
675 const void *data;
676 DWORD length;
677 } TAG_APE_BINARY;
678
679 // BWF "bext" tag structure
680#ifdef _MSC_VER
681#pragma warning(push)
682#pragma warning(disable:4200)
683#endif
684#pragma pack(push,1)
685 typedef struct {
686 char Description[256]; // description
687 char Originator[32]; // name of the originator
688 char OriginatorReference[32]; // reference of the originator
689 char OriginationDate[10]; // date of creation (yyyy-mm-dd)
690 char OriginationTime[8]; // time of creation (hh-mm-ss)
691 QWORD TimeReference; // first sample count since midnight (little-endian)
692 WORD Version; // BWF version (little-endian)
693 BYTE UMID[64]; // SMPTE UMID
694 BYTE Reserved[190];
695#if defined(__GNUC__) && __GNUC__<3
696 char CodingHistory[0]; // history
697#elif 1 // change to 0 if compiler fails the following line
698 char CodingHistory[]; // history
699#else
700 char CodingHistory[1]; // history
701#endif
702 } TAG_BEXT;
703#pragma pack(pop)
704
705 // BWF "cart" tag structures
706 typedef struct
707 {
708 DWORD dwUsage; // FOURCC timer usage ID
709 DWORD dwValue; // timer value in samples from head
710 } TAG_CART_TIMER;
711
712 typedef struct
713 {
714 char Version[4]; // version of the data structure
715 char Title[64]; // title of cart audio sequence
716 char Artist[64]; // artist or creator name
717 char CutID[64]; // cut number identification
718 char ClientID[64]; // client identification
719 char Category[64]; // category ID, PSA, NEWS, etc
720 char Classification[64]; // classification or auxiliary key
721 char OutCue[64]; // out cue text
722 char StartDate[10]; // yyyy-mm-dd
723 char StartTime[8]; // hh:mm:ss
724 char EndDate[10]; // yyyy-mm-dd
725 char EndTime[8]; // hh:mm:ss
726 char ProducerAppID[64]; // name of vendor or application
727 char ProducerAppVersion[64]; // version of producer application
728 char UserDef[64]; // user defined text
729 DWORD dwLevelReference; // sample value for 0 dB reference
730 TAG_CART_TIMER PostTimer[8]; // 8 time markers after head
731 char Reserved[276];
732 char URL[1024]; // uniform resource locator
733#if defined(__GNUC__) && __GNUC__<3
734 char TagText[0]; // free form text for scripts or tags
735#elif 1 // change to 0 if compiler fails the following line
736 char TagText[]; // free form text for scripts or tags
737#else
738 char TagText[1]; // free form text for scripts or tags
739#endif
740 } TAG_CART;
741#ifdef _MSC_VER
742#pragma warning(pop)
743#endif
744
745 // CoreAudio codec info structure
746 typedef struct {
747 DWORD ftype; // file format
748 DWORD atype; // audio format
749 const char *name; // description
750 } TAG_CA_CODEC;
751
752#ifndef _WAVEFORMATEX_
753#define _WAVEFORMATEX_
754#pragma pack(push,1)
755 typedef struct tWAVEFORMATEX
756 {
757 WORD wFormatTag;
758 WORD nChannels;
759 DWORD nSamplesPerSec;
760 DWORD nAvgBytesPerSec;
761 WORD nBlockAlign;
762 WORD wBitsPerSample;
763 WORD cbSize;
764 } WAVEFORMATEX, *PWAVEFORMATEX, *LPWAVEFORMATEX;
765 typedef const WAVEFORMATEX *LPCWAVEFORMATEX;
766#pragma pack(pop)
767#endif
768
769 // BASS_ChannelGetLength/GetPosition/SetPosition modes
770#define BASS_POS_BYTE 0 // byte position
771#define BASS_POS_MUSIC_ORDER 1 // order.row position, MAKELONG(order,row)
772#define BASS_POS_OGG 3 // OGG bitstream number
773#define BASS_POS_INEXACT 0x8000000 // flag: allow seeking to inexact position
774#define BASS_POS_DECODE 0x10000000 // flag: get the decoding (not playing) position
775#define BASS_POS_DECODETO 0x20000000 // flag: decode to the position instead of seeking
776#define BASS_POS_SCAN 0x40000000 // flag: scan to the position
777
778// BASS_RecordSetInput flags
779#define BASS_INPUT_OFF 0x10000
780#define BASS_INPUT_ON 0x20000
781
782#define BASS_INPUT_TYPE_MASK 0xff000000
783#define BASS_INPUT_TYPE_UNDEF 0x00000000
784#define BASS_INPUT_TYPE_DIGITAL 0x01000000
785#define BASS_INPUT_TYPE_LINE 0x02000000
786#define BASS_INPUT_TYPE_MIC 0x03000000
787#define BASS_INPUT_TYPE_SYNTH 0x04000000
788#define BASS_INPUT_TYPE_CD 0x05000000
789#define BASS_INPUT_TYPE_PHONE 0x06000000
790#define BASS_INPUT_TYPE_SPEAKER 0x07000000
791#define BASS_INPUT_TYPE_WAVE 0x08000000
792#define BASS_INPUT_TYPE_AUX 0x09000000
793#define BASS_INPUT_TYPE_ANALOG 0x0a000000
794
795// DX8 effect types, use with BASS_ChannelSetFX
796 enum
797 {
798 BASS_FX_DX8_CHORUS,
799 BASS_FX_DX8_COMPRESSOR,
800 BASS_FX_DX8_DISTORTION,
801 BASS_FX_DX8_ECHO,
802 BASS_FX_DX8_FLANGER,
803 BASS_FX_DX8_GARGLE,
804 BASS_FX_DX8_I3DL2REVERB,
805 BASS_FX_DX8_PARAMEQ,
806 BASS_FX_DX8_REVERB
807 };
808
809 typedef struct {
810 float fWetDryMix;
811 float fDepth;
812 float fFeedback;
813 float fFrequency;
814 DWORD lWaveform; // 0=triangle, 1=sine
815 float fDelay;
816 DWORD lPhase; // BASS_DX8_PHASE_xxx
817 } BASS_DX8_CHORUS;
818
819 typedef struct {
820 float fGain;
821 float fAttack;
822 float fRelease;
823 float fThreshold;
824 float fRatio;
825 float fPredelay;
826 } BASS_DX8_COMPRESSOR;
827
828 typedef struct {
829 float fGain;
830 float fEdge;
831 float fPostEQCenterFrequency;
832 float fPostEQBandwidth;
833 float fPreLowpassCutoff;
834 } BASS_DX8_DISTORTION;
835
836 typedef struct {
837 float fWetDryMix;
838 float fFeedback;
839 float fLeftDelay;
840 float fRightDelay;
841 BOOL lPanDelay;
842 } BASS_DX8_ECHO;
843
844 typedef struct {
845 float fWetDryMix;
846 float fDepth;
847 float fFeedback;
848 float fFrequency;
849 DWORD lWaveform; // 0=triangle, 1=sine
850 float fDelay;
851 DWORD lPhase; // BASS_DX8_PHASE_xxx
852 } BASS_DX8_FLANGER;
853
854 typedef struct {
855 DWORD dwRateHz; // Rate of modulation in hz
856 DWORD dwWaveShape; // 0=triangle, 1=square
857 } BASS_DX8_GARGLE;
858
859 typedef struct {
860 int lRoom; // [-10000, 0] default: -1000 mB
861 int lRoomHF; // [-10000, 0] default: 0 mB
862 float flRoomRolloffFactor; // [0.0, 10.0] default: 0.0
863 float flDecayTime; // [0.1, 20.0] default: 1.49s
864 float flDecayHFRatio; // [0.1, 2.0] default: 0.83
865 int lReflections; // [-10000, 1000] default: -2602 mB
866 float flReflectionsDelay; // [0.0, 0.3] default: 0.007 s
867 int lReverb; // [-10000, 2000] default: 200 mB
868 float flReverbDelay; // [0.0, 0.1] default: 0.011 s
869 float flDiffusion; // [0.0, 100.0] default: 100.0 %
870 float flDensity; // [0.0, 100.0] default: 100.0 %
871 float flHFReference; // [20.0, 20000.0] default: 5000.0 Hz
872 } BASS_DX8_I3DL2REVERB;
873
874 typedef struct {
875 float fCenter;
876 float fBandwidth;
877 float fGain;
878 } BASS_DX8_PARAMEQ;
879
880 typedef struct {
881 float fInGain; // [-96.0,0.0] default: 0.0 dB
882 float fReverbMix; // [-96.0,0.0] default: 0.0 db
883 float fReverbTime; // [0.001,3000.0] default: 1000.0 ms
884 float fHighFreqRTRatio; // [0.001,0.999] default: 0.001
885 } BASS_DX8_REVERB;
886
887#define BASS_DX8_PHASE_NEG_180 0
888#define BASS_DX8_PHASE_NEG_90 1
889#define BASS_DX8_PHASE_ZERO 2
890#define BASS_DX8_PHASE_90 3
891#define BASS_DX8_PHASE_180 4
892
893 typedef void (CALLBACK IOSNOTIFYPROC)(DWORD status);
894 /* iOS notification callback function.
895 status : The notification (BASS_IOSNOTIFY_xxx) */
896
897#define BASS_IOSNOTIFY_INTERRUPT 1 // interruption started
898#define BASS_IOSNOTIFY_INTERRUPT_END 2 // interruption ended
899
900 inline BOOL BASS_SetConfig(DWORD option, DWORD value)
901 {
902 return reinterpret_cast<BOOL(__stdcall*)(DWORD, DWORD)>(BASS::bass_lib.GetProcAddressFromMemory(BASS::bass_lib_handle, _("BASS_SetConfig")))(option, value);
903 }
904
905 inline DWORD BASS_GetConfig(DWORD option)
906 {
907 return reinterpret_cast<DWORD(__stdcall*)(DWORD)>(BASS::bass_lib.GetProcAddressFromMemory(BASS::bass_lib_handle, _("BASS_GetConfig")))(option);
908 }
909
910 BOOL BASSDEF(BASS_SetConfigPtr)(DWORD option, const void *value);
911 void *BASSDEF(BASS_GetConfigPtr)(DWORD option);
912 inline DWORD BASS_GetVersion()
913 {
914 return reinterpret_cast<DWORD(__stdcall*)()>(BASS::bass_lib.GetProcAddressFromMemory(BASS::bass_lib_handle, _("BASS_GetVersion")))();
915 }
916 int BASSDEF(BASS_ErrorGetCode)();
917 BOOL BASSDEF(BASS_GetDeviceInfo)(DWORD device, BASS_DEVICEINFO *info);
918#if defined(_WIN32) && !defined(_WIN32_WCE) && !(WINAPI_FAMILY && WINAPI_FAMILY!=WINAPI_FAMILY_DESKTOP_APP)
919 inline BOOL BASS_Init(int device, DWORD freq, DWORD flags, HWND win, const GUID *dsguid)
920 {
921 return reinterpret_cast<BOOL(__stdcall*)(int device, DWORD freq, DWORD flags, HWND win, const GUID *dsguid)>(BASS::bass_lib.GetProcAddressFromMemory(BASS::bass_lib_handle, _("BASS_Init")))(device, freq, flags, win, dsguid);
922 }
923
924#else
925 BOOL BASSDEF(BASS_Init)(int device, DWORD freq, DWORD flags, void *win, void *dsguid);
926#endif
927 BOOL BASSDEF(BASS_SetDevice)(DWORD device);
928 DWORD BASSDEF(BASS_GetDevice)();
929 inline BOOL BASS_Free()
930 {
931 return reinterpret_cast<BOOL(__stdcall*)()>(BASS::bass_lib.GetProcAddressFromMemory(BASS::bass_lib_handle, _("BASS_Free")))();
932 }
933#if defined(_WIN32) && !defined(_WIN32_WCE) && !(WINAPI_FAMILY && WINAPI_FAMILY!=WINAPI_FAMILY_DESKTOP_APP)
934 void *BASSDEF(BASS_GetDSoundObject)(DWORD object);
935#endif
936 BOOL BASSDEF(BASS_GetInfo)(BASS_INFO *info);
937 BOOL BASSDEF(BASS_Update)(DWORD length);
938 float BASSDEF(BASS_GetCPU)();
939 inline BOOL BASS_Start()
940 {
941 return reinterpret_cast<BOOL(__stdcall*)()>(BASS::bass_lib.GetProcAddressFromMemory(BASS::bass_lib_handle, _("BASS_Start")))();
942 }
943 inline BOOL BASS_Stop()
944 {
945 return reinterpret_cast<BOOL(__stdcall*)()>(BASS::bass_lib.GetProcAddressFromMemory(BASS::bass_lib_handle, _("BASS_Stop")))();
946 }
947 inline BOOL BASS_Pause()
948 {
949 return reinterpret_cast<BOOL(__stdcall*)()>(BASS::bass_lib.GetProcAddressFromMemory(BASS::bass_lib_handle, _("BASS_Pause")))();
950 }
951 inline BOOL BASS_SetVolume(float volume)
952 {
953 return reinterpret_cast<BOOL(__stdcall*)(float volume)>(BASS::bass_lib.GetProcAddressFromMemory(BASS::bass_lib_handle, _("BASS_SetVolume")))(volume);
954 }
955 inline float BASS_GetVolume()
956 {
957 return reinterpret_cast<float(__stdcall*)()>(BASS::bass_lib.GetProcAddressFromMemory(BASS::bass_lib_handle, _("BASS_GetVolume")))();
958 }
959
960 HPLUGIN BASSDEF(BASS_PluginLoad)(const char *file, DWORD flags);
961 BOOL BASSDEF(BASS_PluginFree)(HPLUGIN handle);
962 const BASS_PLUGININFO *BASSDEF(BASS_PluginGetInfo)(HPLUGIN handle);
963
964 BOOL BASSDEF(BASS_Set3DFactors)(float distf, float rollf, float doppf);
965 BOOL BASSDEF(BASS_Get3DFactors)(float *distf, float *rollf, float *doppf);
966 BOOL BASSDEF(BASS_Set3DPosition)(const BASS_3DVECTOR *pos, const BASS_3DVECTOR *vel, const BASS_3DVECTOR *front, const BASS_3DVECTOR *top);
967 BOOL BASSDEF(BASS_Get3DPosition)(BASS_3DVECTOR *pos, BASS_3DVECTOR *vel, BASS_3DVECTOR *front, BASS_3DVECTOR *top);
968 void BASSDEF(BASS_Apply3D)();
969#if defined(_WIN32) && !defined(_WIN32_WCE) && !(WINAPI_FAMILY && WINAPI_FAMILY!=WINAPI_FAMILY_DESKTOP_APP)
970 BOOL BASSDEF(BASS_SetEAXParameters)(int env, float vol, float decay, float damp);
971 BOOL BASSDEF(BASS_GetEAXParameters)(DWORD *env, float *vol, float *decay, float *damp);
972#endif
973
974 HMUSIC BASSDEF(BASS_MusicLoad)(BOOL mem, const void *file, QWORD offset, DWORD length, DWORD flags, DWORD freq);
975 BOOL BASSDEF(BASS_MusicFree)(HMUSIC handle);
976
977 HSAMPLE BASSDEF(BASS_SampleLoad)(BOOL mem, const void *file, QWORD offset, DWORD length, DWORD max, DWORD flags);
978 HSAMPLE BASSDEF(BASS_SampleCreate)(DWORD length, DWORD freq, DWORD chans, DWORD max, DWORD flags);
979 BOOL BASSDEF(BASS_SampleFree)(HSAMPLE handle);
980 BOOL BASSDEF(BASS_SampleSetData)(HSAMPLE handle, const void *buffer);
981 BOOL BASSDEF(BASS_SampleGetData)(HSAMPLE handle, void *buffer);
982 BOOL BASSDEF(BASS_SampleGetInfo)(HSAMPLE handle, BASS_SAMPLE *info);
983 BOOL BASSDEF(BASS_SampleSetInfo)(HSAMPLE handle, const BASS_SAMPLE *info);
984 HCHANNEL BASSDEF(BASS_SampleGetChannel)(HSAMPLE handle, BOOL onlynew);
985 DWORD BASSDEF(BASS_SampleGetChannels)(HSAMPLE handle, HCHANNEL *channels);
986 BOOL BASSDEF(BASS_SampleStop)(HSAMPLE handle);
987
988 HSTREAM BASSDEF(BASS_StreamCreate)(DWORD freq, DWORD chans, DWORD flags, STREAMPROC *proc, void *user);
989 inline HSTREAM BASS_StreamCreateFile(BOOL mem, const void *file, QWORD offset, QWORD length, DWORD flags)
990 {
991 return reinterpret_cast<HSTREAM(__stdcall*)(BOOL mem, const void *file, QWORD offset, QWORD length, DWORD flags)>(BASS::bass_lib.GetProcAddressFromMemory(BASS::bass_lib_handle, _("BASS_StreamCreateFile")))(mem, file, offset, length, flags);
992 }
993
994 inline HSTREAM BASS_StreamCreateURL(const char *url, DWORD offset, DWORD flags, DOWNLOADPROC *proc, void *user)
995 {
996 return reinterpret_cast<HSTREAM(__stdcall*)(const char *url, DWORD offset, DWORD flags, DOWNLOADPROC *proc, void *user)>(BASS::bass_lib.GetProcAddressFromMemory(BASS::bass_lib_handle, _("BASS_StreamCreateURL")))(url, offset, flags, proc, user);
997 }
998
999 HSTREAM BASSDEF(BASS_StreamCreateFileUser)(DWORD system, DWORD flags, const BASS_FILEPROCS *proc, void *user);
1000 inline BOOL BASS_StreamFree(HSTREAM handle)
1001 {
1002 return reinterpret_cast<BOOL(__stdcall*)(HSTREAM handle)>(BASS::bass_lib.GetProcAddressFromMemory(BASS::bass_lib_handle, _("BASS_StreamFree")))(handle);
1003 }
1004
1005 inline QWORD BASS_StreamGetFilePosition(HSTREAM handle, DWORD mode)
1006 {
1007 return reinterpret_cast<QWORD(__stdcall*)(HSTREAM handle, DWORD mode)>(BASS::bass_lib.GetProcAddressFromMemory(BASS::bass_lib_handle, _("BASS_StreamGetFilePosition")))(handle, mode);
1008 }
1009
1010 DWORD BASSDEF(BASS_StreamPutData)(HSTREAM handle, const void *buffer, DWORD length);
1011 DWORD BASSDEF(BASS_StreamPutFileData)(HSTREAM handle, const void *buffer, DWORD length);
1012
1013 BOOL BASSDEF(BASS_RecordGetDeviceInfo)(DWORD device, BASS_DEVICEINFO *info);
1014 BOOL BASSDEF(BASS_RecordInit)(int device);
1015 BOOL BASSDEF(BASS_RecordSetDevice)(DWORD device);
1016 DWORD BASSDEF(BASS_RecordGetDevice)();
1017 BOOL BASSDEF(BASS_RecordFree)();
1018 BOOL BASSDEF(BASS_RecordGetInfo)(BASS_RECORDINFO *info);
1019 const char *BASSDEF(BASS_RecordGetInputName)(int input);
1020 BOOL BASSDEF(BASS_RecordSetInput)(int input, DWORD flags, float volume);
1021 DWORD BASSDEF(BASS_RecordGetInput)(int input, float *volume);
1022 HRECORD BASSDEF(BASS_RecordStart)(DWORD freq, DWORD chans, DWORD flags, RECORDPROC *proc, void *user);
1023
1024 double BASSDEF(BASS_ChannelBytes2Seconds)(DWORD handle, QWORD pos);
1025 QWORD BASSDEF(BASS_ChannelSeconds2Bytes)(DWORD handle, double pos);
1026 DWORD BASSDEF(BASS_ChannelGetDevice)(DWORD handle);
1027 BOOL BASSDEF(BASS_ChannelSetDevice)(DWORD handle, DWORD device);
1028 DWORD BASSDEF(BASS_ChannelIsActive)(DWORD handle);
1029 BOOL BASSDEF(BASS_ChannelGetInfo)(DWORD handle, BASS_CHANNELINFO *info);
1030 inline const char * BASS_ChannelGetTags(DWORD handle, DWORD tags)
1031 {
1032 return reinterpret_cast<const char *(__stdcall*)(DWORD handle, DWORD tags)>(BASS::bass_lib.GetProcAddressFromMemory(BASS::bass_lib_handle, _("BASS_ChannelGetTags")))(handle, tags);
1033 }
1034
1035 DWORD BASSDEF(BASS_ChannelFlags)(DWORD handle, DWORD flags, DWORD mask);
1036 BOOL BASSDEF(BASS_ChannelUpdate)(DWORD handle, DWORD length);
1037 BOOL BASSDEF(BASS_ChannelLock)(DWORD handle, BOOL lock);
1038 inline BOOL BASS_ChannelPlay(DWORD handle, BOOL restart)
1039 {
1040 return reinterpret_cast<BOOL(__stdcall*)(DWORD handle, BOOL restart)>(BASS::bass_lib.GetProcAddressFromMemory(BASS::bass_lib_handle, _("BASS_ChannelPlay")))(handle, restart);
1041 }
1042 BOOL BASSDEF(BASS_ChannelStop)(DWORD handle);
1043 BOOL BASSDEF(BASS_ChannelPause)(DWORD handle);
1044 inline BOOL BASS_ChannelSetAttribute(DWORD handle, DWORD attrib, float value)
1045 {
1046 return reinterpret_cast<BOOL(__stdcall*)(DWORD handle, DWORD attrib, float value)>(BASS::bass_lib.GetProcAddressFromMemory(BASS::bass_lib_handle, _("BASS_ChannelSetAttribute")))(handle, attrib, value);
1047 }
1048 BOOL BASSDEF(BASS_ChannelGetAttribute)(DWORD handle, DWORD attrib, float *value);
1049 BOOL BASSDEF(BASS_ChannelSlideAttribute)(DWORD handle, DWORD attrib, float value, DWORD time);
1050 BOOL BASSDEF(BASS_ChannelIsSliding)(DWORD handle, DWORD attrib);
1051 BOOL BASSDEF(BASS_ChannelSetAttributeEx)(DWORD handle, DWORD attrib, void *value, DWORD size);
1052 DWORD BASSDEF(BASS_ChannelGetAttributeEx)(DWORD handle, DWORD attrib, void *value, DWORD size);
1053 BOOL BASSDEF(BASS_ChannelSet3DAttributes)(DWORD handle, int mode, float min, float max, int iangle, int oangle, float outvol);
1054 BOOL BASSDEF(BASS_ChannelGet3DAttributes)(DWORD handle, DWORD *mode, float *min, float *max, DWORD *iangle, DWORD *oangle, float *outvol);
1055 BOOL BASSDEF(BASS_ChannelSet3DPosition)(DWORD handle, const BASS_3DVECTOR *pos, const BASS_3DVECTOR *orient, const BASS_3DVECTOR *vel);
1056 BOOL BASSDEF(BASS_ChannelGet3DPosition)(DWORD handle, BASS_3DVECTOR *pos, BASS_3DVECTOR *orient, BASS_3DVECTOR *vel);
1057 QWORD BASSDEF(BASS_ChannelGetLength)(DWORD handle, DWORD mode);
1058 BOOL BASSDEF(BASS_ChannelSetPosition)(DWORD handle, QWORD pos, DWORD mode);
1059 QWORD BASSDEF(BASS_ChannelGetPosition)(DWORD handle, DWORD mode);
1060 DWORD BASSDEF(BASS_ChannelGetLevel)(DWORD handle);
1061 BOOL BASSDEF(BASS_ChannelGetLevelEx)(DWORD handle, float *levels, float length, DWORD flags);
1062 DWORD BASSDEF(BASS_ChannelGetData)(DWORD handle, void *buffer, DWORD length);
1063 inline HSYNC BASS_ChannelSetSync(DWORD handle, DWORD type, QWORD param, SYNCPROC *proc, void *user)
1064 {
1065 return reinterpret_cast<HSYNC(__stdcall*)(DWORD handle, DWORD type, QWORD param, SYNCPROC *proc, void *user)>(BASS::bass_lib.GetProcAddressFromMemory(BASS::bass_lib_handle, _("BASS_ChannelSetSync")))(handle, type, param, proc, user);
1066 }
1067 BOOL BASSDEF(BASS_ChannelRemoveSync)(DWORD handle, HSYNC sync);
1068 HDSP BASSDEF(BASS_ChannelSetDSP)(DWORD handle, DSPPROC *proc, void *user, int priority);
1069 BOOL BASSDEF(BASS_ChannelRemoveDSP)(DWORD handle, HDSP dsp);
1070 BOOL BASSDEF(BASS_ChannelSetLink)(DWORD handle, DWORD chan);
1071 BOOL BASSDEF(BASS_ChannelRemoveLink)(DWORD handle, DWORD chan);
1072 HFX BASSDEF(BASS_ChannelSetFX)(DWORD handle, DWORD type, int priority);
1073 BOOL BASSDEF(BASS_ChannelRemoveFX)(DWORD handle, HFX fx);
1074
1075 BOOL BASSDEF(BASS_FXSetParameters)(HFX handle, const void *params);
1076 BOOL BASSDEF(BASS_FXGetParameters)(HFX handle, void *params);
1077 BOOL BASSDEF(BASS_FXReset)(HFX handle);
1078 BOOL BASSDEF(BASS_FXSetPriority)(HFX handle, int priority);
1079
1080#ifdef __cplusplus
1081}
1082
1083#if defined(_WIN32) && !defined(NOBASSOVERLOADS)
1084static inline HPLUGIN BASS_PluginLoad(const WCHAR *file, DWORD flags)
1085{
1086 return BASS_PluginLoad((const char*) file, flags | BASS_UNICODE);
1087}
1088
1089static inline HMUSIC BASS_MusicLoad(BOOL mem, const WCHAR *file, QWORD offset, DWORD length, DWORD flags, DWORD freq)
1090{
1091 return BASS_MusicLoad(mem, (const void*) file, offset, length, flags | BASS_UNICODE, freq);
1092}
1093
1094static inline HSAMPLE BASS_SampleLoad(BOOL mem, const WCHAR *file, QWORD offset, DWORD length, DWORD max, DWORD flags)
1095{
1096 return BASS_SampleLoad(mem, (const void*) file, offset, length, max, flags | BASS_UNICODE);
1097}
1098/*
1099static inline HSTREAM BASS_StreamCreateFile(BOOL mem, const WCHAR *file, QWORD offset, QWORD length, DWORD flags)
1100{
1101 return BASS_StreamCreateFile(mem, (const void*)file, offset, length, flags|BASS_UNICODE);
1102}
1103*/
1104static inline HSTREAM BASS_StreamCreateURL(const WCHAR *url, DWORD offset, DWORD flags, DOWNLOADPROC *proc, void *user)
1105{
1106 return BASS_StreamCreateURL((const char*) url, offset, flags | BASS_UNICODE, proc, user);
1107}
1108
1109static inline BOOL BASS_SetConfigPtr(DWORD option, const WCHAR *value)
1110{
1111 return BASS_SetConfigPtr(option | BASS_UNICODE, (const void*) value);
1112}
1113#endif
1114#endif
1115
1116#endif