@@ -0,0 +1,1023 @@ |
|
|
1 |
{$mode delphi} |
|
|
2 |
|
|
|
3 |
{ |
|
|
4 |
BASS 2.4 Delphi unit |
|
|
5 |
Copyright (c) 1999-2018 Un4seen Developments Ltd. |
|
|
6 |
|
|
|
7 |
See the BASS.CHM file for more detailed documentation |
|
|
8 |
|
|
|
9 |
How to install |
|
|
10 |
-------------- |
|
|
11 |
Copy BASS.PAS to the \LIB subdirectory of your Delphi path or your project dir |
|
|
12 |
|
|
|
13 |
NOTE: Delphi users should use the BASS_UNICODE flag where possible |
|
|
14 |
} |
|
|
15 |
|
|
|
16 |
unit BASS; |
|
|
17 |
|
|
|
18 |
interface |
|
|
19 |
|
|
|
20 |
{$IFDEF MSWINDOWS} |
|
|
21 |
uses |
|
|
22 |
Windows; |
|
|
23 |
{$ENDIF} |
|
|
24 |
|
|
|
25 |
const |
|
|
26 |
BASSVERSION = $204; // API version |
|
|
27 |
BASSVERSIONTEXT = '2.4'; |
|
|
28 |
|
|
|
29 |
// Use these to test for error from functions that return a DWORD or QWORD |
|
|
30 |
DW_ERROR = LongWord(-1); // -1 (DWORD) |
|
|
31 |
QW_ERROR = Int64(-1); // -1 (QWORD) |
|
|
32 |
|
|
|
33 |
// Error codes returned by BASS_ErrorGetCode() |
|
|
34 |
BASS_OK = 0; // all is OK |
|
|
35 |
BASS_ERROR_MEM = 1; // memory error |
|
|
36 |
BASS_ERROR_FILEOPEN = 2; // can't open the file |
|
|
37 |
BASS_ERROR_DRIVER = 3; // can't find a free sound driver |
|
|
38 |
BASS_ERROR_BUFLOST = 4; // the sample buffer was lost |
|
|
39 |
BASS_ERROR_HANDLE = 5; // invalid handle |
|
|
40 |
BASS_ERROR_FORMAT = 6; // unsupported sample format |
|
|
41 |
BASS_ERROR_POSITION = 7; // invalid position |
|
|
42 |
BASS_ERROR_INIT = 8; // BASS_Init has not been successfully called |
|
|
43 |
BASS_ERROR_START = 9; // BASS_Start has not been successfully called |
|
|
44 |
BASS_ERROR_ALREADY = 14; // already initialized/paused/whatever |
|
|
45 |
BASS_ERROR_NOCHAN = 18; // can't get a free channel |
|
|
46 |
BASS_ERROR_ILLTYPE = 19; // an illegal type was specified |
|
|
47 |
BASS_ERROR_ILLPARAM = 20; // an illegal parameter was specified |
|
|
48 |
BASS_ERROR_NO3D = 21; // no 3D support |
|
|
49 |
BASS_ERROR_NOEAX = 22; // no EAX support |
|
|
50 |
BASS_ERROR_DEVICE = 23; // illegal device number |
|
|
51 |
BASS_ERROR_NOPLAY = 24; // not playing |
|
|
52 |
BASS_ERROR_FREQ = 25; // illegal sample rate |
|
|
53 |
BASS_ERROR_NOTFILE = 27; // the stream is not a file stream |
|
|
54 |
BASS_ERROR_NOHW = 29; // no hardware voices available |
|
|
55 |
BASS_ERROR_EMPTY = 31; // the MOD music has no sequence data |
|
|
56 |
BASS_ERROR_NONET = 32; // no internet connection could be opened |
|
|
57 |
BASS_ERROR_CREATE = 33; // couldn't create the file |
|
|
58 |
BASS_ERROR_NOFX = 34; // effects are not available |
|
|
59 |
BASS_ERROR_NOTAVAIL = 37; // requested data/action is not available |
|
|
60 |
BASS_ERROR_DECODE = 38; // the channel is/isn't a "decoding channel" |
|
|
61 |
BASS_ERROR_DX = 39; // a sufficient DirectX version is not installed |
|
|
62 |
BASS_ERROR_TIMEOUT = 40; // connection timedout |
|
|
63 |
BASS_ERROR_FILEFORM = 41; // unsupported file format |
|
|
64 |
BASS_ERROR_SPEAKER = 42; // unavailable speaker |
|
|
65 |
BASS_ERROR_VERSION = 43; // invalid BASS version (used by add-ons) |
|
|
66 |
BASS_ERROR_CODEC = 44; // codec is not available/supported |
|
|
67 |
BASS_ERROR_ENDED = 45; // the channel/file has ended |
|
|
68 |
BASS_ERROR_BUSY = 46; // the device is busy |
|
|
69 |
BASS_ERROR_UNKNOWN = -1; // some other mystery problem |
|
|
70 |
|
|
|
71 |
// BASS_SetConfig options |
|
|
72 |
BASS_CONFIG_BUFFER = 0; |
|
|
73 |
BASS_CONFIG_UPDATEPERIOD = 1; |
|
|
74 |
BASS_CONFIG_GVOL_SAMPLE = 4; |
|
|
75 |
BASS_CONFIG_GVOL_STREAM = 5; |
|
|
76 |
BASS_CONFIG_GVOL_MUSIC = 6; |
|
|
77 |
BASS_CONFIG_CURVE_VOL = 7; |
|
|
78 |
BASS_CONFIG_CURVE_PAN = 8; |
|
|
79 |
BASS_CONFIG_FLOATDSP = 9; |
|
|
80 |
BASS_CONFIG_3DALGORITHM = 10; |
|
|
81 |
BASS_CONFIG_NET_TIMEOUT = 11; |
|
|
82 |
BASS_CONFIG_NET_BUFFER = 12; |
|
|
83 |
BASS_CONFIG_PAUSE_NOPLAY = 13; |
|
|
84 |
BASS_CONFIG_NET_PREBUF = 15; |
|
|
85 |
BASS_CONFIG_NET_PASSIVE = 18; |
|
|
86 |
BASS_CONFIG_REC_BUFFER = 19; |
|
|
87 |
BASS_CONFIG_NET_PLAYLIST = 21; |
|
|
88 |
BASS_CONFIG_MUSIC_VIRTUAL = 22; |
|
|
89 |
BASS_CONFIG_VERIFY = 23; |
|
|
90 |
BASS_CONFIG_UPDATETHREADS = 24; |
|
|
91 |
BASS_CONFIG_DEV_BUFFER = 27; |
|
|
92 |
BASS_CONFIG_VISTA_TRUEPOS = 30; |
|
|
93 |
BASS_CONFIG_IOS_MIXAUDIO = 34; |
|
|
94 |
BASS_CONFIG_DEV_DEFAULT = 36; |
|
|
95 |
BASS_CONFIG_NET_READTIMEOUT = 37; |
|
|
96 |
BASS_CONFIG_VISTA_SPEAKERS = 38; |
|
|
97 |
BASS_CONFIG_IOS_SPEAKER = 39; |
|
|
98 |
BASS_CONFIG_MF_DISABLE = 40; |
|
|
99 |
BASS_CONFIG_HANDLES = 41; |
|
|
100 |
BASS_CONFIG_UNICODE = 42; |
|
|
101 |
BASS_CONFIG_SRC = 43; |
|
|
102 |
BASS_CONFIG_SRC_SAMPLE = 44; |
|
|
103 |
BASS_CONFIG_ASYNCFILE_BUFFER = 45; |
|
|
104 |
BASS_CONFIG_OGG_PRESCAN = 47; |
|
|
105 |
BASS_CONFIG_MF_VIDEO = 48; |
|
|
106 |
BASS_CONFIG_AIRPLAY = 49; |
|
|
107 |
BASS_CONFIG_DEV_NONSTOP = 50; |
|
|
108 |
BASS_CONFIG_IOS_NOCATEGORY = 51; |
|
|
109 |
BASS_CONFIG_VERIFY_NET = 52; |
|
|
110 |
BASS_CONFIG_DEV_PERIOD = 53; |
|
|
111 |
BASS_CONFIG_FLOAT = 54; |
|
|
112 |
BASS_CONFIG_NET_SEEK = 56; |
|
|
113 |
BASS_CONFIG_AM_DISABLE = 58; |
|
|
114 |
BASS_CONFIG_NET_PLAYLIST_DEPTH = 59; |
|
|
115 |
BASS_CONFIG_NET_PREBUF_WAIT = 60; |
|
|
116 |
|
|
|
117 |
// BASS_SetConfigPtr options |
|
|
118 |
BASS_CONFIG_NET_AGENT = 16; |
|
|
119 |
BASS_CONFIG_NET_PROXY = 17; |
|
|
120 |
|
|
|
121 |
// BASS_Init flags |
|
|
122 |
BASS_DEVICE_8BITS = 1; // 8 bit |
|
|
123 |
BASS_DEVICE_MONO = 2; // mono |
|
|
124 |
BASS_DEVICE_3D = 4; // enable 3D functionality |
|
|
125 |
BASS_DEVICE_16BITS = 8; // limit output to 16 bit |
|
|
126 |
BASS_DEVICE_LATENCY = $100; // calculate device latency (BASS_INFO struct) |
|
|
127 |
BASS_DEVICE_CPSPEAKERS = $400; // detect speakers via Windows control panel |
|
|
128 |
BASS_DEVICE_SPEAKERS = $800; // force enabling of speaker assignment |
|
|
129 |
BASS_DEVICE_NOSPEAKER = $1000; // ignore speaker arrangement |
|
|
130 |
BASS_DEVICE_DMIX = $2000; // use ALSA "dmix" plugin |
|
|
131 |
BASS_DEVICE_FREQ = $4000; // set device sample rate |
|
|
132 |
BASS_DEVICE_STEREO = $8000; // limit output to stereo |
|
|
133 |
BASS_DEVICE_AUDIOTRACK = $20000; // use AudioTrack output |
|
|
134 |
BASS_DEVICE_DSOUND = $40000; // use DirectSound output |
|
|
135 |
|
|
|
136 |
// DirectSound interfaces (for use with BASS_GetDSoundObject) |
|
|
137 |
BASS_OBJECT_DS = 1; // IDirectSound |
|
|
138 |
BASS_OBJECT_DS3DL = 2; // IDirectSound3DListener |
|
|
139 |
|
|
|
140 |
// BASS_DEVICEINFO flags |
|
|
141 |
BASS_DEVICE_ENABLED = 1; |
|
|
142 |
BASS_DEVICE_DEFAULT = 2; |
|
|
143 |
BASS_DEVICE_INIT = 4; |
|
|
144 |
|
|
|
145 |
BASS_DEVICE_TYPE_MASK = $ff000000; |
|
|
146 |
BASS_DEVICE_TYPE_NETWORK = $01000000; |
|
|
147 |
BASS_DEVICE_TYPE_SPEAKERS = $02000000; |
|
|
148 |
BASS_DEVICE_TYPE_LINE = $03000000; |
|
|
149 |
BASS_DEVICE_TYPE_HEADPHONES = $04000000; |
|
|
150 |
BASS_DEVICE_TYPE_MICROPHONE = $05000000; |
|
|
151 |
BASS_DEVICE_TYPE_HEADSET = $06000000; |
|
|
152 |
BASS_DEVICE_TYPE_HANDSET = $07000000; |
|
|
153 |
BASS_DEVICE_TYPE_DIGITAL = $08000000; |
|
|
154 |
BASS_DEVICE_TYPE_SPDIF = $09000000; |
|
|
155 |
BASS_DEVICE_TYPE_HDMI = $0a000000; |
|
|
156 |
BASS_DEVICE_TYPE_DISPLAYPORT = $40000000; |
|
|
157 |
|
|
|
158 |
// BASS_GetDeviceInfo flags |
|
|
159 |
BASS_DEVICES_AIRPLAY = $1000000; |
|
|
160 |
|
|
|
161 |
// BASS_INFO flags (from DSOUND.H) |
|
|
162 |
DSCAPS_CONTINUOUSRATE = $00000010; // supports all sample rates between min/maxrate |
|
|
163 |
DSCAPS_EMULDRIVER = $00000020; // device does NOT have hardware DirectSound support |
|
|
164 |
DSCAPS_CERTIFIED = $00000040; // device driver has been certified by Microsoft |
|
|
165 |
DSCAPS_SECONDARYMONO = $00000100; // mono |
|
|
166 |
DSCAPS_SECONDARYSTEREO = $00000200; // stereo |
|
|
167 |
DSCAPS_SECONDARY8BIT = $00000400; // 8 bit |
|
|
168 |
DSCAPS_SECONDARY16BIT = $00000800; // 16 bit |
|
|
169 |
|
|
|
170 |
// BASS_RECORDINFO flags (from DSOUND.H) |
|
|
171 |
DSCCAPS_EMULDRIVER = DSCAPS_EMULDRIVER; // device does NOT have hardware DirectSound recording support |
|
|
172 |
DSCCAPS_CERTIFIED = DSCAPS_CERTIFIED; // device driver has been certified by Microsoft |
|
|
173 |
|
|
|
174 |
// defines for formats field of BASS_RECORDINFO (from MMSYSTEM.H) |
|
|
175 |
WAVE_FORMAT_1M08 = $00000001; // 11.025 kHz, Mono, 8-bit |
|
|
176 |
WAVE_FORMAT_1S08 = $00000002; // 11.025 kHz, Stereo, 8-bit |
|
|
177 |
WAVE_FORMAT_1M16 = $00000004; // 11.025 kHz, Mono, 16-bit |
|
|
178 |
WAVE_FORMAT_1S16 = $00000008; // 11.025 kHz, Stereo, 16-bit |
|
|
179 |
WAVE_FORMAT_2M08 = $00000010; // 22.05 kHz, Mono, 8-bit |
|
|
180 |
WAVE_FORMAT_2S08 = $00000020; // 22.05 kHz, Stereo, 8-bit |
|
|
181 |
WAVE_FORMAT_2M16 = $00000040; // 22.05 kHz, Mono, 16-bit |
|
|
182 |
WAVE_FORMAT_2S16 = $00000080; // 22.05 kHz, Stereo, 16-bit |
|
|
183 |
WAVE_FORMAT_4M08 = $00000100; // 44.1 kHz, Mono, 8-bit |
|
|
184 |
WAVE_FORMAT_4S08 = $00000200; // 44.1 kHz, Stereo, 8-bit |
|
|
185 |
WAVE_FORMAT_4M16 = $00000400; // 44.1 kHz, Mono, 16-bit |
|
|
186 |
WAVE_FORMAT_4S16 = $00000800; // 44.1 kHz, Stereo, 16-bit |
|
|
187 |
|
|
|
188 |
BASS_SAMPLE_8BITS = 1; // 8 bit |
|
|
189 |
BASS_SAMPLE_FLOAT = 256; // 32 bit floating-point |
|
|
190 |
BASS_SAMPLE_MONO = 2; // mono |
|
|
191 |
BASS_SAMPLE_LOOP = 4; // looped |
|
|
192 |
BASS_SAMPLE_3D = 8; // 3D functionality |
|
|
193 |
BASS_SAMPLE_SOFTWARE = 16; // not using hardware mixing |
|
|
194 |
BASS_SAMPLE_MUTEMAX = 32; // mute at max distance (3D only) |
|
|
195 |
BASS_SAMPLE_VAM = 64; // DX7 voice allocation & management |
|
|
196 |
BASS_SAMPLE_FX = 128; // old implementation of DX8 effects |
|
|
197 |
BASS_SAMPLE_OVER_VOL = $10000; // override lowest volume |
|
|
198 |
BASS_SAMPLE_OVER_POS = $20000; // override longest playing |
|
|
199 |
BASS_SAMPLE_OVER_DIST = $30000; // override furthest from listener (3D only) |
|
|
200 |
|
|
|
201 |
BASS_STREAM_PRESCAN = $20000; // enable pin-point seeking/length (MP3/MP2/MP1) |
|
|
202 |
BASS_STREAM_AUTOFREE = $40000; // automatically free the stream when it stop/ends |
|
|
203 |
BASS_STREAM_RESTRATE = $80000; // restrict the download rate of internet file streams |
|
|
204 |
BASS_STREAM_BLOCK = $100000;// download/play internet file stream in small blocks |
|
|
205 |
BASS_STREAM_DECODE = $200000;// don't play the stream, only decode (BASS_ChannelGetData) |
|
|
206 |
BASS_STREAM_STATUS = $800000;// give server status info (HTTP/ICY tags) in DOWNLOADPROC |
|
|
207 |
|
|
|
208 |
BASS_MP3_IGNOREDELAY = $200; // ignore LAME/Xing/VBRI/iTunes delay & padding info |
|
|
209 |
BASS_MP3_SETPOS = BASS_STREAM_PRESCAN; |
|
|
210 |
|
|
|
211 |
BASS_MUSIC_FLOAT = BASS_SAMPLE_FLOAT; |
|
|
212 |
BASS_MUSIC_MONO = BASS_SAMPLE_MONO; |
|
|
213 |
BASS_MUSIC_LOOP = BASS_SAMPLE_LOOP; |
|
|
214 |
BASS_MUSIC_3D = BASS_SAMPLE_3D; |
|
|
215 |
BASS_MUSIC_FX = BASS_SAMPLE_FX; |
|
|
216 |
BASS_MUSIC_AUTOFREE = BASS_STREAM_AUTOFREE; |
|
|
217 |
BASS_MUSIC_DECODE = BASS_STREAM_DECODE; |
|
|
218 |
BASS_MUSIC_PRESCAN = BASS_STREAM_PRESCAN; // calculate playback length |
|
|
219 |
BASS_MUSIC_CALCLEN = BASS_MUSIC_PRESCAN; |
|
|
220 |
BASS_MUSIC_RAMP = $200; // normal ramping |
|
|
221 |
BASS_MUSIC_RAMPS = $400; // sensitive ramping |
|
|
222 |
BASS_MUSIC_SURROUND = $800; // surround sound |
|
|
223 |
BASS_MUSIC_SURROUND2 = $1000; // surround sound (mode 2) |
|
|
224 |
BASS_MUSIC_FT2PAN = $2000; // apply FastTracker 2 panning to XM files |
|
|
225 |
BASS_MUSIC_FT2MOD = $2000; // play .MOD as FastTracker 2 does |
|
|
226 |
BASS_MUSIC_PT1MOD = $4000; // play .MOD as ProTracker 1 does |
|
|
227 |
BASS_MUSIC_NONINTER = $10000; // non-interpolated sample mixing |
|
|
228 |
BASS_MUSIC_SINCINTER = $800000; // sinc interpolated sample mixing |
|
|
229 |
BASS_MUSIC_POSRESET = $8000; // stop all notes when moving position |
|
|
230 |
BASS_MUSIC_POSRESETEX = $400000; // stop all notes and reset bmp/etc when moving position |
|
|
231 |
BASS_MUSIC_STOPBACK = $80000; // stop the music on a backwards jump effect |
|
|
232 |
BASS_MUSIC_NOSAMPLE = $100000; // don't load the samples |
|
|
233 |
|
|
|
234 |
// Speaker assignment flags |
|
|
235 |
BASS_SPEAKER_FRONT = $1000000; // front speakers |
|
|
236 |
BASS_SPEAKER_REAR = $2000000; // rear/side speakers |
|
|
237 |
BASS_SPEAKER_CENLFE = $3000000; // center & LFE speakers (5.1) |
|
|
238 |
BASS_SPEAKER_REAR2 = $4000000; // rear center speakers (7.1) |
|
|
239 |
BASS_SPEAKER_LEFT = $10000000; // modifier: left |
|
|
240 |
BASS_SPEAKER_RIGHT = $20000000; // modifier: right |
|
|
241 |
BASS_SPEAKER_FRONTLEFT = BASS_SPEAKER_FRONT or BASS_SPEAKER_LEFT; |
|
|
242 |
BASS_SPEAKER_FRONTRIGHT = BASS_SPEAKER_FRONT or BASS_SPEAKER_RIGHT; |
|
|
243 |
BASS_SPEAKER_REARLEFT = BASS_SPEAKER_REAR or BASS_SPEAKER_LEFT; |
|
|
244 |
BASS_SPEAKER_REARRIGHT = BASS_SPEAKER_REAR or BASS_SPEAKER_RIGHT; |
|
|
245 |
BASS_SPEAKER_CENTER = BASS_SPEAKER_CENLFE or BASS_SPEAKER_LEFT; |
|
|
246 |
BASS_SPEAKER_LFE = BASS_SPEAKER_CENLFE or BASS_SPEAKER_RIGHT; |
|
|
247 |
BASS_SPEAKER_REAR2LEFT = BASS_SPEAKER_REAR2 or BASS_SPEAKER_LEFT; |
|
|
248 |
BASS_SPEAKER_REAR2RIGHT = BASS_SPEAKER_REAR2 or BASS_SPEAKER_RIGHT; |
|
|
249 |
|
|
|
250 |
BASS_ASYNCFILE = $40000000; |
|
|
251 |
BASS_UNICODE = $80000000; |
|
|
252 |
|
|
|
253 |
BASS_RECORD_PAUSE = $8000; // start recording paused |
|
|
254 |
|
|
|
255 |
// DX7 voice allocation & management flags |
|
|
256 |
BASS_VAM_HARDWARE = 1; |
|
|
257 |
BASS_VAM_SOFTWARE = 2; |
|
|
258 |
BASS_VAM_TERM_TIME = 4; |
|
|
259 |
BASS_VAM_TERM_DIST = 8; |
|
|
260 |
BASS_VAM_TERM_PRIO = 16; |
|
|
261 |
|
|
|
262 |
BASS_ORIGRES_FLOAT = $10000; |
|
|
263 |
|
|
|
264 |
// BASS_CHANNELINFO types |
|
|
265 |
BASS_CTYPE_SAMPLE = 1; |
|
|
266 |
BASS_CTYPE_RECORD = 2; |
|
|
267 |
BASS_CTYPE_STREAM = $10000; |
|
|
268 |
BASS_CTYPE_STREAM_OGG = $10002; |
|
|
269 |
BASS_CTYPE_STREAM_MP1 = $10003; |
|
|
270 |
BASS_CTYPE_STREAM_MP2 = $10004; |
|
|
271 |
BASS_CTYPE_STREAM_MP3 = $10005; |
|
|
272 |
BASS_CTYPE_STREAM_AIFF = $10006; |
|
|
273 |
BASS_CTYPE_STREAM_CA = $10007; |
|
|
274 |
BASS_CTYPE_STREAM_MF = $10008; |
|
|
275 |
BASS_CTYPE_STREAM_AM = $10009; |
|
|
276 |
BASS_CTYPE_STREAM_DUMMY = $18000; |
|
|
277 |
BASS_CTYPE_STREAM_DEVICE = $18001; |
|
|
278 |
BASS_CTYPE_STREAM_WAV = $40000; // WAVE flag, LOWORD=codec |
|
|
279 |
BASS_CTYPE_STREAM_WAV_PCM = $50001; |
|
|
280 |
BASS_CTYPE_STREAM_WAV_FLOAT = $50003; |
|
|
281 |
BASS_CTYPE_MUSIC_MOD = $20000; |
|
|
282 |
BASS_CTYPE_MUSIC_MTM = $20001; |
|
|
283 |
BASS_CTYPE_MUSIC_S3M = $20002; |
|
|
284 |
BASS_CTYPE_MUSIC_XM = $20003; |
|
|
285 |
BASS_CTYPE_MUSIC_IT = $20004; |
|
|
286 |
BASS_CTYPE_MUSIC_MO3 = $00100; // MO3 flag |
|
|
287 |
|
|
|
288 |
// 3D channel modes |
|
|
289 |
BASS_3DMODE_NORMAL = 0; // normal 3D processing |
|
|
290 |
BASS_3DMODE_RELATIVE = 1; // position is relative to the listener |
|
|
291 |
BASS_3DMODE_OFF = 2; // no 3D processing |
|
|
292 |
|
|
|
293 |
// software 3D mixing algorithms (used with BASS_CONFIG_3DALGORITHM) |
|
|
294 |
BASS_3DALG_DEFAULT = 0; |
|
|
295 |
BASS_3DALG_OFF = 1; |
|
|
296 |
BASS_3DALG_FULL = 2; |
|
|
297 |
BASS_3DALG_LIGHT = 3; |
|
|
298 |
|
|
|
299 |
// EAX environments, use with BASS_SetEAXParameters |
|
|
300 |
EAX_ENVIRONMENT_GENERIC = 0; |
|
|
301 |
EAX_ENVIRONMENT_PADDEDCELL = 1; |
|
|
302 |
EAX_ENVIRONMENT_ROOM = 2; |
|
|
303 |
EAX_ENVIRONMENT_BATHROOM = 3; |
|
|
304 |
EAX_ENVIRONMENT_LIVINGROOM = 4; |
|
|
305 |
EAX_ENVIRONMENT_STONEROOM = 5; |
|
|
306 |
EAX_ENVIRONMENT_AUDITORIUM = 6; |
|
|
307 |
EAX_ENVIRONMENT_CONCERTHALL = 7; |
|
|
308 |
EAX_ENVIRONMENT_CAVE = 8; |
|
|
309 |
EAX_ENVIRONMENT_ARENA = 9; |
|
|
310 |
EAX_ENVIRONMENT_HANGAR = 10; |
|
|
311 |
EAX_ENVIRONMENT_CARPETEDHALLWAY = 11; |
|
|
312 |
EAX_ENVIRONMENT_HALLWAY = 12; |
|
|
313 |
EAX_ENVIRONMENT_STONECORRIDOR = 13; |
|
|
314 |
EAX_ENVIRONMENT_ALLEY = 14; |
|
|
315 |
EAX_ENVIRONMENT_FOREST = 15; |
|
|
316 |
EAX_ENVIRONMENT_CITY = 16; |
|
|
317 |
EAX_ENVIRONMENT_MOUNTAINS = 17; |
|
|
318 |
EAX_ENVIRONMENT_QUARRY = 18; |
|
|
319 |
EAX_ENVIRONMENT_PLAIN = 19; |
|
|
320 |
EAX_ENVIRONMENT_PARKINGLOT = 20; |
|
|
321 |
EAX_ENVIRONMENT_SEWERPIPE = 21; |
|
|
322 |
EAX_ENVIRONMENT_UNDERWATER = 22; |
|
|
323 |
EAX_ENVIRONMENT_DRUGGED = 23; |
|
|
324 |
EAX_ENVIRONMENT_DIZZY = 24; |
|
|
325 |
EAX_ENVIRONMENT_PSYCHOTIC = 25; |
|
|
326 |
// total number of environments |
|
|
327 |
EAX_ENVIRONMENT_COUNT = 26; |
|
|
328 |
|
|
|
329 |
BASS_STREAMPROC_END = $80000000; // end of user stream flag |
|
|
330 |
|
|
|
331 |
// BASS_StreamCreateFileUser file systems |
|
|
332 |
STREAMFILE_NOBUFFER = 0; |
|
|
333 |
STREAMFILE_BUFFER = 1; |
|
|
334 |
STREAMFILE_BUFFERPUSH = 2; |
|
|
335 |
|
|
|
336 |
// BASS_StreamPutFileData options |
|
|
337 |
BASS_FILEDATA_END = 0; // end & close the file |
|
|
338 |
|
|
|
339 |
// BASS_StreamGetFilePosition modes |
|
|
340 |
BASS_FILEPOS_CURRENT = 0; |
|
|
341 |
BASS_FILEPOS_DECODE = BASS_FILEPOS_CURRENT; |
|
|
342 |
BASS_FILEPOS_DOWNLOAD = 1; |
|
|
343 |
BASS_FILEPOS_END = 2; |
|
|
344 |
BASS_FILEPOS_START = 3; |
|
|
345 |
BASS_FILEPOS_CONNECTED = 4; |
|
|
346 |
BASS_FILEPOS_BUFFER = 5; |
|
|
347 |
BASS_FILEPOS_SOCKET = 6; |
|
|
348 |
BASS_FILEPOS_ASYNCBUF = 7; |
|
|
349 |
BASS_FILEPOS_SIZE = 8; |
|
|
350 |
BASS_FILEPOS_BUFFERING = 9; |
|
|
351 |
|
|
|
352 |
// BASS_ChannelSetSync types |
|
|
353 |
BASS_SYNC_POS = 0; |
|
|
354 |
BASS_SYNC_END = 2; |
|
|
355 |
BASS_SYNC_META = 4; |
|
|
356 |
BASS_SYNC_SLIDE = 5; |
|
|
357 |
BASS_SYNC_STALL = 6; |
|
|
358 |
BASS_SYNC_DOWNLOAD = 7; |
|
|
359 |
BASS_SYNC_FREE = 8; |
|
|
360 |
BASS_SYNC_SETPOS = 11; |
|
|
361 |
BASS_SYNC_MUSICPOS = 10; |
|
|
362 |
BASS_SYNC_MUSICINST = 1; |
|
|
363 |
BASS_SYNC_MUSICFX = 3; |
|
|
364 |
BASS_SYNC_OGG_CHANGE = 12; |
|
|
365 |
BASS_SYNC_MIXTIME = $40000000; // flag: sync at mixtime, else at playtime |
|
|
366 |
BASS_SYNC_ONETIME = $80000000; // flag: sync only once, else continuously |
|
|
367 |
|
|
|
368 |
// BASS_ChannelIsActive return values |
|
|
369 |
BASS_ACTIVE_STOPPED = 0; |
|
|
370 |
BASS_ACTIVE_PLAYING = 1; |
|
|
371 |
BASS_ACTIVE_STALLED = 2; |
|
|
372 |
BASS_ACTIVE_PAUSED = 3; |
|
|
373 |
|
|
|
374 |
// Channel attributes |
|
|
375 |
BASS_ATTRIB_FREQ = 1; |
|
|
376 |
BASS_ATTRIB_VOL = 2; |
|
|
377 |
BASS_ATTRIB_PAN = 3; |
|
|
378 |
BASS_ATTRIB_EAXMIX = 4; |
|
|
379 |
BASS_ATTRIB_NOBUFFER = 5; |
|
|
380 |
BASS_ATTRIB_VBR = 6; |
|
|
381 |
BASS_ATTRIB_CPU = 7; |
|
|
382 |
BASS_ATTRIB_SRC = 8; |
|
|
383 |
BASS_ATTRIB_NET_RESUME = 9; |
|
|
384 |
BASS_ATTRIB_SCANINFO = 10; |
|
|
385 |
BASS_ATTRIB_NORAMP = 11; |
|
|
386 |
BASS_ATTRIB_BITRATE = 12; |
|
|
387 |
BASS_ATTRIB_BUFFER = 13; |
|
|
388 |
BASS_ATTRIB_MUSIC_AMPLIFY = $100; |
|
|
389 |
BASS_ATTRIB_MUSIC_PANSEP = $101; |
|
|
390 |
BASS_ATTRIB_MUSIC_PSCALER = $102; |
|
|
391 |
BASS_ATTRIB_MUSIC_BPM = $103; |
|
|
392 |
BASS_ATTRIB_MUSIC_SPEED = $104; |
|
|
393 |
BASS_ATTRIB_MUSIC_VOL_GLOBAL = $105; |
|
|
394 |
BASS_ATTRIB_MUSIC_ACTIVE = $106; |
|
|
395 |
BASS_ATTRIB_MUSIC_VOL_CHAN = $200; // + channel # |
|
|
396 |
BASS_ATTRIB_MUSIC_VOL_INST = $300; // + instrument # |
|
|
397 |
|
|
|
398 |
// BASS_ChannelSlideAttribute flags |
|
|
399 |
BASS_SLIDE_LOG = $1000000; |
|
|
400 |
|
|
|
401 |
// BASS_ChannelGetData flags |
|
|
402 |
BASS_DATA_AVAILABLE = 0; // query how much data is buffered |
|
|
403 |
BASS_DATA_FIXED = $20000000; // flag: return 8.24 fixed-point data |
|
|
404 |
BASS_DATA_FLOAT = $40000000; // flag: return floating-point sample data |
|
|
405 |
BASS_DATA_FFT256 = $80000000; // 256 sample FFT |
|
|
406 |
BASS_DATA_FFT512 = $80000001; // 512 FFT |
|
|
407 |
BASS_DATA_FFT1024 = $80000002; // 1024 FFT |
|
|
408 |
BASS_DATA_FFT2048 = $80000003; // 2048 FFT |
|
|
409 |
BASS_DATA_FFT4096 = $80000004; // 4096 FFT |
|
|
410 |
BASS_DATA_FFT8192 = $80000005; // 8192 FFT |
|
|
411 |
BASS_DATA_FFT16384 = $80000006; // 16384 FFT |
|
|
412 |
BASS_DATA_FFT32768 = $80000007; // 32768 FFT |
|
|
413 |
BASS_DATA_FFT_INDIVIDUAL = $10; // FFT flag: FFT for each channel, else all combined |
|
|
414 |
BASS_DATA_FFT_NOWINDOW = $20; // FFT flag: no Hanning window |
|
|
415 |
BASS_DATA_FFT_REMOVEDC = $40; // FFT flag: pre-remove DC bias |
|
|
416 |
BASS_DATA_FFT_COMPLEX = $80; // FFT flag: return complex data |
|
|
417 |
|
|
|
418 |
// BASS_ChannelGetLevelEx flags |
|
|
419 |
BASS_LEVEL_MONO = 1; |
|
|
420 |
BASS_LEVEL_STEREO = 2; |
|
|
421 |
BASS_LEVEL_RMS = 4; |
|
|
422 |
BASS_LEVEL_VOLPAN = 8; |
|
|
423 |
|
|
|
424 |
// BASS_ChannelGetTags types : what's returned |
|
|
425 |
BASS_TAG_ID3 = 0; // ID3v1 tags : TAG_ID3 structure |
|
|
426 |
BASS_TAG_ID3V2 = 1; // ID3v2 tags : variable length block |
|
|
427 |
BASS_TAG_OGG = 2; // OGG comments : series of null-terminated UTF-8 strings |
|
|
428 |
BASS_TAG_HTTP = 3; // HTTP headers : series of null-terminated ANSI strings |
|
|
429 |
BASS_TAG_ICY = 4; // ICY headers : series of null-terminated ANSI strings |
|
|
430 |
BASS_TAG_META = 5; // ICY metadata : ANSI string |
|
|
431 |
BASS_TAG_APE = 6; // APEv2 tags : series of null-terminated UTF-8 strings |
|
|
432 |
BASS_TAG_MP4 = 7; // MP4/iTunes metadata : series of null-terminated UTF-8 strings |
|
|
433 |
BASS_TAG_WMA = 8; // WMA tags : series of null-terminated UTF-8 strings |
|
|
434 |
BASS_TAG_VENDOR = 9; // OGG encoder : UTF-8 string |
|
|
435 |
BASS_TAG_LYRICS3 = 10; // Lyric3v2 tag : ASCII string |
|
|
436 |
BASS_TAG_CA_CODEC = 11; // CoreAudio codec info : TAG_CA_CODEC structure |
|
|
437 |
BASS_TAG_MF = 13; // Media Foundation tags : series of null-terminated UTF-8 strings |
|
|
438 |
BASS_TAG_WAVEFORMAT = 14; // WAVE format : WAVEFORMATEEX structure |
|
|
439 |
BASS_TAG_AM_MIME = 15; // Android Media MIME type : ASCII string |
|
|
440 |
BASS_TAG_AM_NAME = 16; // Android Media codec name : ASCII string |
|
|
441 |
BASS_TAG_RIFF_INFO = $100; // RIFF "INFO" tags : series of null-terminated ANSI strings |
|
|
442 |
BASS_TAG_RIFF_BEXT = $101; // RIFF/BWF "bext" tags : TAG_BEXT structure |
|
|
443 |
BASS_TAG_RIFF_CART = $102; // RIFF/BWF "cart" tags : TAG_CART structure |
|
|
444 |
BASS_TAG_RIFF_DISP = $103; // RIFF "DISP" text tag : ANSI string |
|
|
445 |
BASS_TAG_RIFF_CUE = $104; // RIFF "cue " chunk : TAG_CUE structure |
|
|
446 |
BASS_TAG_RIFF_SMPL = $105; // RIFF "smpl" chunk : TAG_SMPL structure |
|
|
447 |
BASS_TAG_APE_BINARY = $1000; // + index #, binary APEv2 tag : TAG_APE_BINARY structure |
|
|
448 |
BASS_TAG_MUSIC_NAME = $10000; // MOD music name : ANSI string |
|
|
449 |
BASS_TAG_MUSIC_MESSAGE = $10001; // MOD message : ANSI string |
|
|
450 |
BASS_TAG_MUSIC_ORDERS = $10002; // MOD order list : BYTE array of pattern numbers |
|
|
451 |
BASS_TAG_MUSIC_AUTH = $10003; // MOD author : UTF-8 string |
|
|
452 |
BASS_TAG_MUSIC_INST = $10100; // + instrument #, MOD instrument name : ANSI string |
|
|
453 |
BASS_TAG_MUSIC_SAMPLE = $10300; // + sample #, MOD sample name : ANSI string |
|
|
454 |
|
|
|
455 |
// BASS_ChannelGetLength/GetPosition/SetPosition modes |
|
|
456 |
BASS_POS_BYTE = 0; // byte position |
|
|
457 |
BASS_POS_MUSIC_ORDER = 1; // order.row position, MAKELONG(order,row) |
|
|
458 |
BASS_POS_OGG = 3; // OGG bitstream number |
|
|
459 |
BASS_POS_RESET = $2000000; // flag: reset user file buffers |
|
|
460 |
BASS_POS_RELATIVE = $4000000; // flag: seek relative to the current position |
|
|
461 |
BASS_POS_INEXACT = $8000000; // flag: allow seeking to inexact position |
|
|
462 |
BASS_POS_DECODE = $10000000; // flag: get the decoding (not playing) position |
|
|
463 |
BASS_POS_DECODETO = $20000000; // flag: decode to the position instead of seeking |
|
|
464 |
BASS_POS_SCAN = $40000000; // flag: scan to the position |
|
|
465 |
|
|
|
466 |
// BASS_ChannelSetDevice/GetDevice option |
|
|
467 |
BASS_NODEVICE = $20000; |
|
|
468 |
|
|
|
469 |
// BASS_RecordSetInput flags |
|
|
470 |
BASS_INPUT_OFF = $10000; |
|
|
471 |
BASS_INPUT_ON = $20000; |
|
|
472 |
|
|
|
473 |
BASS_INPUT_TYPE_MASK = $FF000000; |
|
|
474 |
BASS_INPUT_TYPE_UNDEF = $00000000; |
|
|
475 |
BASS_INPUT_TYPE_DIGITAL = $01000000; |
|
|
476 |
BASS_INPUT_TYPE_LINE = $02000000; |
|
|
477 |
BASS_INPUT_TYPE_MIC = $03000000; |
|
|
478 |
BASS_INPUT_TYPE_SYNTH = $04000000; |
|
|
479 |
BASS_INPUT_TYPE_CD = $05000000; |
|
|
480 |
BASS_INPUT_TYPE_PHONE = $06000000; |
|
|
481 |
BASS_INPUT_TYPE_SPEAKER = $07000000; |
|
|
482 |
BASS_INPUT_TYPE_WAVE = $08000000; |
|
|
483 |
BASS_INPUT_TYPE_AUX = $09000000; |
|
|
484 |
BASS_INPUT_TYPE_ANALOG = $0A000000; |
|
|
485 |
|
|
|
486 |
// BASS_ChannelSetFX effect types |
|
|
487 |
BASS_FX_DX8_CHORUS = 0; |
|
|
488 |
BASS_FX_DX8_COMPRESSOR = 1; |
|
|
489 |
BASS_FX_DX8_DISTORTION = 2; |
|
|
490 |
BASS_FX_DX8_ECHO = 3; |
|
|
491 |
BASS_FX_DX8_FLANGER = 4; |
|
|
492 |
BASS_FX_DX8_GARGLE = 5; |
|
|
493 |
BASS_FX_DX8_I3DL2REVERB = 6; |
|
|
494 |
BASS_FX_DX8_PARAMEQ = 7; |
|
|
495 |
BASS_FX_DX8_REVERB = 8; |
|
|
496 |
BASS_FX_VOLUME = 9; |
|
|
497 |
|
|
|
498 |
BASS_DX8_PHASE_NEG_180 = 0; |
|
|
499 |
BASS_DX8_PHASE_NEG_90 = 1; |
|
|
500 |
BASS_DX8_PHASE_ZERO = 2; |
|
|
501 |
BASS_DX8_PHASE_90 = 3; |
|
|
502 |
BASS_DX8_PHASE_180 = 4; |
|
|
503 |
|
|
|
504 |
type |
|
|
505 |
DWORD = LongWord; |
|
|
506 |
BOOL = LongBool; |
|
|
507 |
QWORD = Int64; |
|
|
508 |
|
|
|
509 |
HMUSIC = DWORD; // MOD music handle |
|
|
510 |
HSAMPLE = DWORD; // sample handle |
|
|
511 |
HCHANNEL = DWORD; // playing sample's channel handle |
|
|
512 |
HSTREAM = DWORD; // sample stream handle |
|
|
513 |
HRECORD = DWORD; // recording handle |
|
|
514 |
HSYNC = DWORD; // synchronizer handle |
|
|
515 |
HDSP = DWORD; // DSP handle |
|
|
516 |
HFX = DWORD; // DX8 effect handle |
|
|
517 |
HPLUGIN = DWORD; // Plugin handle |
|
|
518 |
|
|
|
519 |
// Device info structure |
|
|
520 |
BASS_DEVICEINFO = record |
|
|
521 |
name: PAnsiChar; // description |
|
|
522 |
driver: PAnsiChar; // driver |
|
|
523 |
flags: DWORD; |
|
|
524 |
end; |
|
|
525 |
|
|
|
526 |
BASS_INFO = record |
|
|
527 |
flags: DWORD; // device capabilities (DSCAPS_xxx flags) |
|
|
528 |
hwsize: DWORD; // size of total device hardware memory |
|
|
529 |
hwfree: DWORD; // size of free device hardware memory |
|
|
530 |
freesam: DWORD; // number of free sample slots in the hardware |
|
|
531 |
free3d: DWORD; // number of free 3D sample slots in the hardware |
|
|
532 |
minrate: DWORD; // min sample rate supported by the hardware |
|
|
533 |
maxrate: DWORD; // max sample rate supported by the hardware |
|
|
534 |
eax: BOOL; // device supports EAX? (always FALSE if BASS_DEVICE_3D was not used) |
|
|
535 |
minbuf: DWORD; // recommended minimum buffer length in ms (requires BASS_DEVICE_LATENCY) |
|
|
536 |
dsver: DWORD; // DirectSound version |
|
|
537 |
latency: DWORD; // delay (in ms) before start of playback (requires BASS_DEVICE_LATENCY) |
|
|
538 |
initflags: DWORD; // BASS_Init "flags" parameter |
|
|
539 |
speakers: DWORD; // number of speakers available |
|
|
540 |
freq: DWORD; // current output rate |
|
|
541 |
end; |
|
|
542 |
|
|
|
543 |
// Recording device info structure |
|
|
544 |
BASS_RECORDINFO = record |
|
|
545 |
flags: DWORD; // device capabilities (DSCCAPS_xxx flags) |
|
|
546 |
formats: DWORD; // supported standard formats (WAVE_FORMAT_xxx flags) |
|
|
547 |
inputs: DWORD; // number of inputs |
|
|
548 |
singlein: BOOL; // only 1 input can be set at a time |
|
|
549 |
freq: DWORD; // current input rate |
|
|
550 |
end; |
|
|
551 |
|
|
|
552 |
// Sample info structure |
|
|
553 |
BASS_SAMPLE = record |
|
|
554 |
freq: DWORD; // default playback rate |
|
|
555 |
volume: Single; // default volume (0-100) |
|
|
556 |
pan: Single; // default pan (-100=left, 0=middle, 100=right) |
|
|
557 |
flags: DWORD; // BASS_SAMPLE_xxx flags |
|
|
558 |
length: DWORD; // length (in samples, not bytes) |
|
|
559 |
max: DWORD; // maximum simultaneous playbacks |
|
|
560 |
origres: DWORD; // original resolution |
|
|
561 |
chans: DWORD; // number of channels |
|
|
562 |
mingap: DWORD; // minimum gap (ms) between creating channels |
|
|
563 |
mode3d: DWORD; // BASS_3DMODE_xxx mode |
|
|
564 |
mindist: Single; // minimum distance |
|
|
565 |
maxdist: Single; // maximum distance |
|
|
566 |
iangle: DWORD; // angle of inside projection cone |
|
|
567 |
oangle: DWORD; // angle of outside projection cone |
|
|
568 |
outvol: Single; // delta-volume outside the projection cone |
|
|
569 |
vam: DWORD; // voice allocation/management flags (BASS_VAM_xxx) |
|
|
570 |
priority: DWORD; // priority (0=lowest, $ffffffff=highest) |
|
|
571 |
end; |
|
|
572 |
|
|
|
573 |
// Channel info structure |
|
|
574 |
BASS_CHANNELINFO = record |
|
|
575 |
freq: DWORD; // default playback rate |
|
|
576 |
chans: DWORD; // channels |
|
|
577 |
flags: DWORD; // BASS_SAMPLE/STREAM/MUSIC/SPEAKER flags |
|
|
578 |
ctype: DWORD; // type of channel |
|
|
579 |
origres: DWORD; // original resolution |
|
|
580 |
plugin: HPLUGIN; // plugin |
|
|
581 |
sample: HSAMPLE; // sample |
|
|
582 |
{$IFDEF CPUX64} |
|
|
583 |
padding: DWORD; |
|
|
584 |
{$ENDIF} |
|
|
585 |
filename: PChar; // filename |
|
|
586 |
end; |
|
|
587 |
|
|
|
588 |
BASS_PLUGINFORM = record |
|
|
589 |
ctype: DWORD; // channel type |
|
|
590 |
{$IFDEF CPUX64} |
|
|
591 |
padding: DWORD; |
|
|
592 |
{$ENDIF} |
|
|
593 |
name: PAnsiChar; // format description |
|
|
594 |
exts: PAnsiChar; // file extension filter (*.ext1;*.ext2;etc...) |
|
|
595 |
end; |
|
|
596 |
PBASS_PLUGINFORMS = ^TBASS_PLUGINFORMS; |
|
|
597 |
TBASS_PLUGINFORMS = array[0..maxInt div sizeOf(BASS_PLUGINFORM) - 1] of BASS_PLUGINFORM; |
|
|
598 |
|
|
|
599 |
PBASS_PLUGININFO = ^BASS_PLUGININFO; |
|
|
600 |
BASS_PLUGININFO = record |
|
|
601 |
version: DWORD; // version (same form as BASS_GetVersion) |
|
|
602 |
formatc: DWORD; // number of formats |
|
|
603 |
formats: PBASS_PLUGINFORMS; // the array of formats |
|
|
604 |
end; |
|
|
605 |
|
|
|
606 |
// 3D vector (for 3D positions/velocities/orientations) |
|
|
607 |
BASS_3DVECTOR = record |
|
|
608 |
x: Single; // +=right, -=left |
|
|
609 |
y: Single; // +=up, -=down |
|
|
610 |
z: Single; // +=front, -=behind |
|
|
611 |
end; |
|
|
612 |
|
|
|
613 |
// User file stream callback functions |
|
|
614 |
FILECLOSEPROC = procedure(user: Pointer); {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; |
|
|
615 |
FILELENPROC = function(user: Pointer): QWORD; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; |
|
|
616 |
FILEREADPROC = function(buffer: Pointer; length: DWORD; user: Pointer): DWORD; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; |
|
|
617 |
FILESEEKPROC = function(offset: QWORD; user: Pointer): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; |
|
|
618 |
|
|
|
619 |
BASS_FILEPROCS = record |
|
|
620 |
close: FILECLOSEPROC; |
|
|
621 |
length: FILELENPROC; |
|
|
622 |
read: FILEREADPROC; |
|
|
623 |
seek: FILESEEKPROC; |
|
|
624 |
end; |
|
|
625 |
|
|
|
626 |
// ID3v1 tag structure |
|
|
627 |
PTAG_ID3 = ^TAG_ID3; |
|
|
628 |
TAG_ID3 = record |
|
|
629 |
id: Array[0..2] of AnsiChar; |
|
|
630 |
title: Array[0..29] of AnsiChar; |
|
|
631 |
artist: Array[0..29] of AnsiChar; |
|
|
632 |
album: Array[0..29] of AnsiChar; |
|
|
633 |
year: Array[0..3] of AnsiChar; |
|
|
634 |
comment: Array[0..29] of AnsiChar; |
|
|
635 |
genre: Byte; |
|
|
636 |
end; |
|
|
637 |
|
|
|
638 |
// Binary APEv2 tag structure |
|
|
639 |
PTAG_APE_BINARY = ^TAG_APE_BINARY; |
|
|
640 |
TAG_APE_BINARY = record |
|
|
641 |
key: PAnsiChar; |
|
|
642 |
data: PAnsiChar; |
|
|
643 |
length: DWORD; |
|
|
644 |
end; |
|
|
645 |
|
|
|
646 |
// BWF "bext" tag structure |
|
|
647 |
PTAG_BEXT = ^TAG_BEXT; |
|
|
648 |
TAG_BEXT = packed record |
|
|
649 |
Description: Array[0..255] of AnsiChar; // description |
|
|
650 |
Originator: Array[0..31] of AnsiChar; // name of the originator |
|
|
651 |
OriginatorReference: Array[0..31] of AnsiChar; // reference of the originator |
|
|
652 |
OriginationDate: Array[0..9] of AnsiChar; // date of creation (yyyy-mm-dd) |
|
|
653 |
OriginationTime: Array[0..7] of AnsiChar; // time of creation (hh-mm-ss) |
|
|
654 |
TimeReference: QWORD; // first sample count since midnight (little-endian) |
|
|
655 |
Version: Word; // BWF version (little-endian) |
|
|
656 |
UMID: Array[0..63] of Byte; // SMPTE UMID |
|
|
657 |
Reserved: Array[0..189] of Byte; |
|
|
658 |
CodingHistory: AnsiChar; // history |
|
|
659 |
end; |
|
|
660 |
|
|
|
661 |
BASS_DX8_CHORUS = record |
|
|
662 |
fWetDryMix: Single; |
|
|
663 |
fDepth: Single; |
|
|
664 |
fFeedback: Single; |
|
|
665 |
fFrequency: Single; |
|
|
666 |
lWaveform: DWORD; // 0=triangle, 1=sine |
|
|
667 |
fDelay: Single; |
|
|
668 |
lPhase: DWORD; // BASS_DX8_PHASE_xxx |
|
|
669 |
end; |
|
|
670 |
|
|
|
671 |
BASS_DX8_COMPRESSOR = record |
|
|
672 |
fGain: Single; |
|
|
673 |
fAttack: Single; |
|
|
674 |
fRelease: Single; |
|
|
675 |
fThreshold: Single; |
|
|
676 |
fRatio: Single; |
|
|
677 |
fPredelay: Single; |
|
|
678 |
end; |
|
|
679 |
|
|
|
680 |
BASS_DX8_DISTORTION = record |
|
|
681 |
fGain: Single; |
|
|
682 |
fEdge: Single; |
|
|
683 |
fPostEQCenterFrequency: Single; |
|
|
684 |
fPostEQBandwidth: Single; |
|
|
685 |
fPreLowpassCutoff: Single; |
|
|
686 |
end; |
|
|
687 |
|
|
|
688 |
BASS_DX8_ECHO = record |
|
|
689 |
fWetDryMix: Single; |
|
|
690 |
fFeedback: Single; |
|
|
691 |
fLeftDelay: Single; |
|
|
692 |
fRightDelay: Single; |
|
|
693 |
lPanDelay: BOOL; |
|
|
694 |
end; |
|
|
695 |
|
|
|
696 |
BASS_DX8_FLANGER = record |
|
|
697 |
fWetDryMix: Single; |
|
|
698 |
fDepth: Single; |
|
|
699 |
fFeedback: Single; |
|
|
700 |
fFrequency: Single; |
|
|
701 |
lWaveform: DWORD; // 0=triangle, 1=sine |
|
|
702 |
fDelay: Single; |
|
|
703 |
lPhase: DWORD; // BASS_DX8_PHASE_xxx |
|
|
704 |
end; |
|
|
705 |
|
|
|
706 |
BASS_DX8_GARGLE = record |
|
|
707 |
dwRateHz: DWORD; // Rate of modulation in hz |
|
|
708 |
dwWaveShape: DWORD; // 0=triangle, 1=square |
|
|
709 |
end; |
|
|
710 |
|
|
|
711 |
BASS_DX8_I3DL2REVERB = record |
|
|
712 |
lRoom: LongInt; // [-10000, 0] default: -1000 mB |
|
|
713 |
lRoomHF: LongInt; // [-10000, 0] default: 0 mB |
|
|
714 |
flRoomRolloffFactor: Single; // [0.0, 10.0] default: 0.0 |
|
|
715 |
flDecayTime: Single; // [0.1, 20.0] default: 1.49s |
|
|
716 |
flDecayHFRatio: Single; // [0.1, 2.0] default: 0.83 |
|
|
717 |
lReflections: LongInt; // [-10000, 1000] default: -2602 mB |
|
|
718 |
flReflectionsDelay: Single; // [0.0, 0.3] default: 0.007 s |
|
|
719 |
lReverb: LongInt; // [-10000, 2000] default: 200 mB |
|
|
720 |
flReverbDelay: Single; // [0.0, 0.1] default: 0.011 s |
|
|
721 |
flDiffusion: Single; // [0.0, 100.0] default: 100.0 % |
|
|
722 |
flDensity: Single; // [0.0, 100.0] default: 100.0 % |
|
|
723 |
flHFReference: Single; // [20.0, 20000.0] default: 5000.0 Hz |
|
|
724 |
end; |
|
|
725 |
|
|
|
726 |
BASS_DX8_PARAMEQ = record |
|
|
727 |
fCenter: Single; |
|
|
728 |
fBandwidth: Single; |
|
|
729 |
fGain: Single; |
|
|
730 |
end; |
|
|
731 |
|
|
|
732 |
BASS_DX8_REVERB = record |
|
|
733 |
fInGain: Single; // [-96.0,0.0] default: 0.0 dB |
|
|
734 |
fReverbMix: Single; // [-96.0,0.0] default: 0.0 db |
|
|
735 |
fReverbTime: Single; // [0.001,3000.0] default: 1000.0 ms |
|
|
736 |
fHighFreqRTRatio: Single; // [0.001,0.999] default: 0.001 |
|
|
737 |
end; |
|
|
738 |
|
|
|
739 |
BASS_FX_VOLUME_PARAM = record |
|
|
740 |
fTarget: Single; |
|
|
741 |
fCurrent: Single; |
|
|
742 |
fTime: Single; |
|
|
743 |
lCurve: DWORD; |
|
|
744 |
end; |
|
|
745 |
|
|
|
746 |
// callback function types |
|
|
747 |
STREAMPROC = function(handle: HSTREAM; buffer: Pointer; length: DWORD; user: Pointer): DWORD; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; |
|
|
748 |
{ |
|
|
749 |
User stream callback function. NOTE: A stream function should obviously be as |
|
|
750 |
quick as possible, other streams (and MOD musics) can't be mixed until |
|
|
751 |
it's finished. |
|
|
752 |
handle : The stream that needs writing |
|
|
753 |
buffer : Buffer to write the samples in |
|
|
754 |
length : Number of bytes to write |
|
|
755 |
user : The 'user' parameter value given when calling BASS_StreamCreate |
|
|
756 |
RETURN : Number of bytes written. Set the BASS_STREAMPROC_END flag to end |
|
|
757 |
the stream. |
|
|
758 |
} |
|
|
759 |
|
|
|
760 |
const |
|
|
761 |
// special STREAMPROCs |
|
|
762 |
STREAMPROC_DUMMY = Pointer(0); // "dummy" stream |
|
|
763 |
STREAMPROC_PUSH = Pointer(-1); // push stream |
|
|
764 |
STREAMPROC_DEVICE = Pointer(-2); // device mix stream |
|
|
765 |
|
|
|
766 |
type |
|
|
767 |
DOWNLOADPROC = procedure(buffer: Pointer; length: DWORD; user: Pointer); {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; |
|
|
768 |
{ |
|
|
769 |
Internet stream download callback function. |
|
|
770 |
buffer : Buffer containing the downloaded data... NULL=end of download |
|
|
771 |
length : Number of bytes in the buffer |
|
|
772 |
user : The 'user' parameter value given when calling BASS_StreamCreateURL |
|
|
773 |
} |
|
|
774 |
|
|
|
775 |
SYNCPROC = procedure(handle: HSYNC; channel, data: DWORD; user: Pointer); {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; |
|
|
776 |
{ |
|
|
777 |
Sync callback function. NOTE: a sync callback function should be very |
|
|
778 |
quick as other syncs cannot be processed until it has finished. If the |
|
|
779 |
sync is a "mixtime" sync, then other streams and MOD musics can not be |
|
|
780 |
mixed until it's finished either. |
|
|
781 |
handle : The sync that has occured |
|
|
782 |
channel: Channel that the sync occured in |
|
|
783 |
data : Additional data associated with the sync's occurance |
|
|
784 |
user : The 'user' parameter given when calling BASS_ChannelSetSync |
|
|
785 |
} |
|
|
786 |
|
|
|
787 |
DSPPROC = procedure(handle: HDSP; channel: DWORD; buffer: Pointer; length: DWORD; user: Pointer); {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; |
|
|
788 |
{ |
|
|
789 |
DSP callback function. NOTE: A DSP function should obviously be as quick |
|
|
790 |
as possible... other DSP functions, streams and MOD musics can not be |
|
|
791 |
processed until it's finished. |
|
|
792 |
handle : The DSP handle |
|
|
793 |
channel: Channel that the DSP is being applied to |
|
|
794 |
buffer : Buffer to apply the DSP to |
|
|
795 |
length : Number of bytes in the buffer |
|
|
796 |
user : The 'user' parameter given when calling BASS_ChannelSetDSP |
|
|
797 |
} |
|
|
798 |
|
|
|
799 |
RECORDPROC = function(handle: HRECORD; buffer: Pointer; length: DWORD; user: Pointer): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; |
|
|
800 |
{ |
|
|
801 |
Recording callback function. |
|
|
802 |
handle : The recording handle |
|
|
803 |
buffer : Buffer containing the recorded sample data |
|
|
804 |
length : Number of bytes |
|
|
805 |
user : The 'user' parameter value given when calling BASS_RecordStart |
|
|
806 |
RETURN : TRUE = continue recording, FALSE = stop |
|
|
807 |
} |
|
|
808 |
|
|
|
809 |
|
|
|
810 |
// Functions |
|
|
811 |
const |
|
|
812 |
{$IFDEF MSWINDOWS} |
|
|
813 |
bassdll = 'bass.dll'; |
|
|
814 |
{$ENDIF} |
|
|
815 |
{$IFDEF LINUX} |
|
|
816 |
bassdll = 'libbass.so'; |
|
|
817 |
{$ENDIF} |
|
|
818 |
{$IFDEF MACOS} |
|
|
819 |
bassdll = 'libbass.dylib'; |
|
|
820 |
{$ENDIF} |
|
|
821 |
|
|
|
822 |
function BASS_SetConfig(option, value: DWORD): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
823 |
function BASS_GetConfig(option: DWORD): DWORD; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
824 |
function BASS_SetConfigPtr(option: DWORD; value: Pointer): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
825 |
function BASS_GetConfigPtr(option: DWORD): Pointer; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
826 |
function BASS_GetVersion: DWORD; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
827 |
function BASS_ErrorGetCode: LongInt; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
828 |
function BASS_GetDeviceInfo(device: DWORD; var info: BASS_DEVICEINFO): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
829 |
{$IFDEF MSWINDOWS} |
|
|
830 |
function BASS_Init(device: LongInt; freq, flags: DWORD; win: HWND; clsid: PGUID): BOOL; stdcall; external bassdll; |
|
|
831 |
{$ELSE} |
|
|
832 |
function BASS_Init(device: LongInt; freq, flags: DWORD; win: Pointer; clsid: Pointer): BOOL; cdecl; external bassdll; |
|
|
833 |
{$ENDIF} |
|
|
834 |
function BASS_SetDevice(device: DWORD): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
835 |
function BASS_GetDevice: DWORD; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
836 |
function BASS_Free: BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
837 |
{$IFDEF MSWINDOWS} |
|
|
838 |
function BASS_GetDSoundObject(obj: DWORD): Pointer; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
839 |
{$ENDIF} |
|
|
840 |
function BASS_GetInfo(var info: BASS_INFO): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
841 |
function BASS_Update(length: DWORD): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
842 |
function BASS_GetCPU: Single; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
843 |
function BASS_Start: BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
844 |
function BASS_Stop: BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
845 |
function BASS_Pause: BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
846 |
function BASS_SetVolume(volume: Single): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
847 |
function BASS_GetVolume: Single; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
848 |
|
|
|
849 |
function BASS_PluginLoad(filename: PChar; flags: DWORD): HPLUGIN; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
850 |
function BASS_PluginFree(handle: HPLUGIN): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
851 |
function BASS_PluginGetInfo(handle: HPLUGIN): PBASS_PLUGININFO; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
852 |
|
|
|
853 |
function BASS_Set3DFactors(distf, rollf, doppf: Single): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
854 |
function BASS_Get3DFactors(var distf, rollf, doppf: Single): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
855 |
function BASS_Set3DPosition(var pos, vel, front, top: BASS_3DVECTOR): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
856 |
function BASS_Get3DPosition(var pos, vel, front, top: BASS_3DVECTOR): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
857 |
procedure BASS_Apply3D; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
858 |
{$IFDEF MSWINDOWS} |
|
|
859 |
function BASS_SetEAXParameters(env: LongInt; vol, decay, damp: Single): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
860 |
function BASS_GetEAXParameters(var env: DWORD; var vol, decay, damp: Single): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
861 |
{$ENDIF} |
|
|
862 |
|
|
|
863 |
function BASS_MusicLoad(mem: BOOL; f: Pointer; offset: QWORD; length, flags, freq: DWORD): HMUSIC; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
864 |
function BASS_MusicFree(handle: HMUSIC): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
865 |
|
|
|
866 |
function BASS_SampleLoad(mem: BOOL; f: Pointer; offset: QWORD; length, max, flags: DWORD): HSAMPLE; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
867 |
function BASS_SampleCreate(length, freq, chans, max, flags: DWORD): HSAMPLE; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
868 |
function BASS_SampleFree(handle: HSAMPLE): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
869 |
function BASS_SampleSetData(handle: HSAMPLE; buffer: Pointer): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
870 |
function BASS_SampleGetData(handle: HSAMPLE; buffer: Pointer): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
871 |
function BASS_SampleGetInfo(handle: HSAMPLE; var info: BASS_SAMPLE): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
872 |
function BASS_SampleSetInfo(handle: HSAMPLE; var info: BASS_SAMPLE): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
873 |
function BASS_SampleGetChannel(handle: HSAMPLE; onlynew: BOOL): HCHANNEL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
874 |
function BASS_SampleGetChannels(handle: HSAMPLE; channels: Pointer): DWORD; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
875 |
function BASS_SampleStop(handle: HSAMPLE): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
876 |
|
|
|
877 |
function BASS_StreamCreate(freq, chans, flags: DWORD; proc: STREAMPROC; user: Pointer): HSTREAM; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
878 |
function BASS_StreamCreateFile(mem: BOOL; f: Pointer; offset, length: QWORD; flags: DWORD): HSTREAM; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
879 |
function BASS_StreamCreateURL(url: PChar; offset: DWORD; flags: DWORD; proc: DOWNLOADPROC; user: Pointer):HSTREAM; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
880 |
function BASS_StreamCreateFileUser(system, flags: DWORD; var procs: BASS_FILEPROCS; user: Pointer): HSTREAM; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
881 |
function BASS_StreamFree(handle: HSTREAM): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
882 |
function BASS_StreamGetFilePosition(handle: HSTREAM; mode: DWORD): QWORD; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
883 |
function BASS_StreamPutData(handle: HSTREAM; buffer: Pointer; length: DWORD): DWORD; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
884 |
function BASS_StreamPutFileData(handle: HSTREAM; buffer: Pointer; length: DWORD): DWORD; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
885 |
|
|
|
886 |
function BASS_RecordGetDeviceInfo(device: DWORD; var info: BASS_DEVICEINFO): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
887 |
function BASS_RecordInit(device: LongInt):BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
888 |
function BASS_RecordSetDevice(device: DWORD): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
889 |
function BASS_RecordGetDevice: DWORD; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
890 |
function BASS_RecordFree: BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
891 |
function BASS_RecordGetInfo(var info: BASS_RECORDINFO): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
892 |
function BASS_RecordGetInputName(input: LongInt): PAnsiChar; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
893 |
function BASS_RecordSetInput(input: LongInt; flags: DWORD; volume: Single): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
894 |
function BASS_RecordGetInput(input: LongInt; var volume: Single): DWORD; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
895 |
function BASS_RecordStart(freq, chans, flags: DWORD; proc: RECORDPROC; user: Pointer): HRECORD; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
896 |
|
|
|
897 |
function BASS_ChannelBytes2Seconds(handle: DWORD; pos: QWORD): Double; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF};external bassdll; |
|
|
898 |
function BASS_ChannelSeconds2Bytes(handle: DWORD; pos: Double): QWORD; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF};external bassdll; |
|
|
899 |
function BASS_ChannelGetDevice(handle: DWORD): DWORD; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
900 |
function BASS_ChannelSetDevice(handle, device: DWORD): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
901 |
function BASS_ChannelIsActive(handle: DWORD): DWORD; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF};external bassdll; |
|
|
902 |
function BASS_ChannelGetInfo(handle: DWORD; var info: BASS_CHANNELINFO):BOOL;{$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF};external bassdll; |
|
|
903 |
function BASS_ChannelGetTags(handle: HSTREAM; tags: DWORD): PAnsiChar; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
904 |
function BASS_ChannelFlags(handle, flags, mask: DWORD): DWORD; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
905 |
function BASS_ChannelUpdate(handle, length: DWORD): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
906 |
function BASS_ChannelLock(handle: DWORD; lock: BOOL): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
907 |
function BASS_ChannelPlay(handle: DWORD; restart: BOOL): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
908 |
function BASS_ChannelStop(handle: DWORD): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
909 |
function BASS_ChannelPause(handle: DWORD): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
910 |
function BASS_ChannelSetAttribute(handle, attrib: DWORD; value: Single): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
911 |
function BASS_ChannelGetAttribute(handle, attrib: DWORD; var value: Single): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
912 |
function BASS_ChannelSlideAttribute(handle, attrib: DWORD; value: Single; time: DWORD): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
913 |
function BASS_ChannelIsSliding(handle, attrib: DWORD): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF};external bassdll; |
|
|
914 |
function BASS_ChannelSetAttributeEx(handle, attrib: DWORD; value: Pointer; size: DWORD): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF};external bassdll; |
|
|
915 |
function BASS_ChannelGetAttributeEx(handle, attrib: DWORD; value: Pointer; size: DWORD): DWORD; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF};external bassdll; |
|
|
916 |
function BASS_ChannelSet3DAttributes(handle: DWORD; mode: LongInt; min, max: Single; iangle, oangle, outvol: LongInt): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
917 |
function BASS_ChannelGet3DAttributes(handle: DWORD; var mode: DWORD; var min, max: Single; var iangle, oangle, outvol: DWORD): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
918 |
function BASS_ChannelSet3DPosition(handle: DWORD; var pos, orient, vel: BASS_3DVECTOR): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
919 |
function BASS_ChannelGet3DPosition(handle: DWORD; var pos, orient, vel: BASS_3DVECTOR): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
920 |
function BASS_ChannelGetLength(handle, mode: DWORD): QWORD; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
921 |
function BASS_ChannelSetPosition(handle: DWORD; pos: QWORD; mode: DWORD): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
922 |
function BASS_ChannelGetPosition(handle, mode: DWORD): QWORD; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
923 |
function BASS_ChannelGetLevel(handle: DWORD): DWORD; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
924 |
function BASS_ChannelGetLevelEx(handle: DWORD; levels: PSingle; length: Single; flags: DWORD): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
925 |
function BASS_ChannelGetData(handle: DWORD; buffer: Pointer; length: DWORD): DWORD; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
926 |
function BASS_ChannelSetSync(handle: DWORD; type_: DWORD; param: QWORD; proc: SYNCPROC; user: Pointer): HSYNC; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
927 |
function BASS_ChannelRemoveSync(handle: DWORD; sync: HSYNC): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
928 |
function BASS_ChannelSetDSP(handle: DWORD; proc: DSPPROC; user: Pointer; priority: LongInt): HDSP; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
929 |
function BASS_ChannelRemoveDSP(handle: DWORD; dsp: HDSP): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
930 |
function BASS_ChannelSetLink(handle, chan: DWORD): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
931 |
function BASS_ChannelRemoveLink(handle, chan: DWORD): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
932 |
function BASS_ChannelSetFX(handle, type_: DWORD; priority: LongInt): HFX; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
933 |
function BASS_ChannelRemoveFX(handle: DWORD; fx: HFX): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
934 |
|
|
|
935 |
function BASS_FXSetParameters(handle: HFX; par: Pointer): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
936 |
function BASS_FXGetParameters(handle: HFX; par: Pointer): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
937 |
function BASS_FXReset(handle: HFX): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
938 |
function BASS_FXSetPriority(handle: HFX; priority: LongInt): BOOL; {$IFDEF MSWINDOWS}stdcall{$ELSE}cdecl{$ENDIF}; external bassdll; |
|
|
939 |
|
|
|
940 |
|
|
|
941 |
function BASS_SPEAKER_N(n: DWORD): DWORD; |
|
|
942 |
{$IFDEF MSWINDOWS} |
|
|
943 |
function BASS_SetEAXPreset(env: LongInt): BOOL; |
|
|
944 |
{ |
|
|
945 |
This function is defined in the implementation part of this unit. |
|
|
946 |
It is not part of BASS.DLL but an extra function which makes it easier |
|
|
947 |
to set the predefined EAX environments. |
|
|
948 |
env : a EAX_ENVIRONMENT_xxx constant |
|
|
949 |
} |
|
|
950 |
{$ENDIF} |
|
|
951 |
|
|
|
952 |
|
|
|
953 |
implementation |
|
|
954 |
|
|
|
955 |
function BASS_SPEAKER_N(n: DWORD): DWORD; |
|
|
956 |
begin |
|
|
957 |
Result := n shl 24; |
|
|
958 |
end; |
|
|
959 |
|
|
|
960 |
{$IFDEF MSWINDOWS} |
|
|
961 |
function BASS_SetEAXPreset(env: LongInt): BOOL; |
|
|
962 |
begin |
|
|
963 |
case (env) of |
|
|
964 |
EAX_ENVIRONMENT_GENERIC: |
|
|
965 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_GENERIC, 0.5, 1.493, 0.5); |
|
|
966 |
EAX_ENVIRONMENT_PADDEDCELL: |
|
|
967 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_PADDEDCELL, 0.25, 0.1, 0); |
|
|
968 |
EAX_ENVIRONMENT_ROOM: |
|
|
969 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_ROOM, 0.417, 0.4, 0.666); |
|
|
970 |
EAX_ENVIRONMENT_BATHROOM: |
|
|
971 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_BATHROOM, 0.653, 1.499, 0.166); |
|
|
972 |
EAX_ENVIRONMENT_LIVINGROOM: |
|
|
973 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_LIVINGROOM, 0.208, 0.478, 0); |
|
|
974 |
EAX_ENVIRONMENT_STONEROOM: |
|
|
975 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_STONEROOM, 0.5, 2.309, 0.888); |
|
|
976 |
EAX_ENVIRONMENT_AUDITORIUM: |
|
|
977 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_AUDITORIUM, 0.403, 4.279, 0.5); |
|
|
978 |
EAX_ENVIRONMENT_CONCERTHALL: |
|
|
979 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_CONCERTHALL, 0.5, 3.961, 0.5); |
|
|
980 |
EAX_ENVIRONMENT_CAVE: |
|
|
981 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_CAVE, 0.5, 2.886, 1.304); |
|
|
982 |
EAX_ENVIRONMENT_ARENA: |
|
|
983 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_ARENA, 0.361, 7.284, 0.332); |
|
|
984 |
EAX_ENVIRONMENT_HANGAR: |
|
|
985 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_HANGAR, 0.5, 10.0, 0.3); |
|
|
986 |
EAX_ENVIRONMENT_CARPETEDHALLWAY: |
|
|
987 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_CARPETEDHALLWAY, 0.153, 0.259, 2.0); |
|
|
988 |
EAX_ENVIRONMENT_HALLWAY: |
|
|
989 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_HALLWAY, 0.361, 1.493, 0); |
|
|
990 |
EAX_ENVIRONMENT_STONECORRIDOR: |
|
|
991 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_STONECORRIDOR, 0.444, 2.697, 0.638); |
|
|
992 |
EAX_ENVIRONMENT_ALLEY: |
|
|
993 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_ALLEY, 0.25, 1.752, 0.776); |
|
|
994 |
EAX_ENVIRONMENT_FOREST: |
|
|
995 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_FOREST, 0.111, 3.145, 0.472); |
|
|
996 |
EAX_ENVIRONMENT_CITY: |
|
|
997 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_CITY, 0.111, 2.767, 0.224); |
|
|
998 |
EAX_ENVIRONMENT_MOUNTAINS: |
|
|
999 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_MOUNTAINS, 0.194, 7.841, 0.472); |
|
|
1000 |
EAX_ENVIRONMENT_QUARRY: |
|
|
1001 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_QUARRY, 1, 1.499, 0.5); |
|
|
1002 |
EAX_ENVIRONMENT_PLAIN: |
|
|
1003 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_PLAIN, 0.097, 2.767, 0.224); |
|
|
1004 |
EAX_ENVIRONMENT_PARKINGLOT: |
|
|
1005 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_PARKINGLOT, 0.208, 1.652, 1.5); |
|
|
1006 |
EAX_ENVIRONMENT_SEWERPIPE: |
|
|
1007 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_SEWERPIPE, 0.652, 2.886, 0.25); |
|
|
1008 |
EAX_ENVIRONMENT_UNDERWATER: |
|
|
1009 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_UNDERWATER, 1, 1.499, 0); |
|
|
1010 |
EAX_ENVIRONMENT_DRUGGED: |
|
|
1011 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_DRUGGED, 0.875, 8.392, 1.388); |
|
|
1012 |
EAX_ENVIRONMENT_DIZZY: |
|
|
1013 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_DIZZY, 0.139, 17.234, 0.666); |
|
|
1014 |
EAX_ENVIRONMENT_PSYCHOTIC: |
|
|
1015 |
Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_PSYCHOTIC, 0.486, 7.563, 0.806); |
|
|
1016 |
else |
|
|
1017 |
Result := FALSE; |
|
|
1018 |
end; |
|
|
1019 |
end; |
|
|
1020 |
{$ENDIF} |
|
|
1021 |
|
|
|
1022 |
end. |
|
|
1023 |
|