开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > OpenGL > 查看源码
Bass.h
资源名称：OpenGL动画演示(包含代码).rar　[点击查看]
上传用户：sz83729876
上传日期：2013-03-07
资源大小：4140k
文件大小：59k
源码类别：

OpenGL

开发平台：

Windows_Unix

Bass.h：源码内容
  1. /* BASS 1.7 C/C++ header file, copyright (c) 1999-2002 Ian Luck.
  2.    Please report bugs/suggestions/etc... to bass@un4seen.com
  4.    See the BASS.CHM file for more complete documentation */
  6. #ifndef BASS_H
  7. #define BASS_H
  9. #include <wtypes.h>
  11. #ifdef __cplusplus
  12. extern "C" {
  13. #endif
  15. #ifndef BASSDEF
  16. #define BASSDEF(f) WINAPI f
  17. #endif
  19. typedef unsigned __int64 QWORD; // 64-bit
  21. typedef DWORD HMUSIC; // MOD music handle
  22. typedef DWORD HSAMPLE; // sample handle
  23. typedef DWORD HCHANNEL; // playing sample's channel handle
  24. typedef DWORD HSTREAM; // sample stream handle
  25. typedef DWORD HSYNC; // synchronizer handle
  26. typedef DWORD HDSP; // DSP handle
  27. typedef DWORD HFX; // DX8 effect handle
  29. // Error codes returned by BASS_GetErrorCode
  30. #define BASS_OK 0 // all is OK
  31. #define BASS_ERROR_MEM 1 // memory error
  32. #define BASS_ERROR_FILEOPEN 2 // can't open the file
  33. #define BASS_ERROR_DRIVER 3 // can't find a free/valid driver
  34. #define BASS_ERROR_BUFLOST 4 // the sample buffer was lost - please report this!
  35. #define BASS_ERROR_HANDLE 5 // invalid handle
  36. #define BASS_ERROR_FORMAT 6 // unsupported format
  37. #define BASS_ERROR_POSITION 7 // invalid playback position
  38. #define BASS_ERROR_INIT 8 // BASS_Init has not been successfully called
  39. #define BASS_ERROR_START 9 // BASS_Start has not been successfully called
  40. #define BASS_ERROR_INITCD 10 // can't initialize CD
  41. #define BASS_ERROR_CDINIT 11 // BASS_CDInit has not been successfully called
  42. #define BASS_ERROR_NOCD 12 // no CD in drive
  43. #define BASS_ERROR_CDTRACK 13 // can't play the selected CD track
  44. #define BASS_ERROR_ALREADY 14 // already initialized
  45. #define BASS_ERROR_CDVOL 15 // CD has no volume control
  46. #define BASS_ERROR_NOPAUSE 16 // not paused
  47. #define BASS_ERROR_NOTAUDIO 17 // not an audio track
  48. #define BASS_ERROR_NOCHAN 18 // can't get a free channel
  49. #define BASS_ERROR_ILLTYPE 19 // an illegal type was specified
  50. #define BASS_ERROR_ILLPARAM 20 // an illegal parameter was specified
  51. #define BASS_ERROR_NO3D 21 // no 3D support
  52. #define BASS_ERROR_NOEAX 22 // no EAX support
  53. #define BASS_ERROR_DEVICE 23 // illegal device number
  54. #define BASS_ERROR_NOPLAY 24 // not playing
  55. #define BASS_ERROR_FREQ 25 // illegal sample rate
  56. #define BASS_ERROR_NOA3D 26 // A3D.DLL is not installed
  57. #define BASS_ERROR_NOTFILE 27 // the stream is not a file stream (WAV/MP3/MP2/MP1/OGG)
  58. #define BASS_ERROR_NOHW 29 // no hardware voices available
  59. #define BASS_ERROR_EMPTY 31 // the MOD music has no sequence data
  60. #define BASS_ERROR_NONET 32 // no internet connection could be opened
  61. #define BASS_ERROR_CREATE 33 // couldn't create the file
  62. #define BASS_ERROR_NOFX 34 // effects are not available
  63. #define BASS_ERROR_PLAYING 35 // the channel is playing
  64. #define BASS_ERROR_NOTAVAIL 37 // requested data is not available
  65. #define BASS_ERROR_DECODE 38 // the channel is a "decoding channel"
  66. #define BASS_ERROR_DX 39 // a sufficient DirectX version is not installed
  67. #define BASS_ERROR_TIMEOUT 40 // connection timedout
  68. #define BASS_ERROR_UNKNOWN -1 // some other mystery error
  70. // Device setup flags
  71. #define BASS_DEVICE_8BITS 1 // use 8 bit resolution, else 16 bit
  72. #define BASS_DEVICE_MONO 2 // use mono, else stereo
  73. #define BASS_DEVICE_3D 4 // enable 3D functionality
  74. /* If the BASS_DEVICE_3D flag is not specified when initilizing BASS,
  75. then the 3D flags (BASS_SAMPLE_3D and BASS_MUSIC_3D) are ignored when
  76. loading/creating a sample/stream/music. */
  77. #define BASS_DEVICE_LEAVEVOL 32 // leave the volume as it is
  78. #define BASS_DEVICE_NOTHREAD 128 // update buffers manually (using BASS_Update)
  79. #define BASS_DEVICE_LATENCY 256 // calculate device latency (BASS_INFO struct)
  80. #define BASS_DEVICE_VOL1000 512 // 0-1000 volume range (else 0-100)
  81. #define BASS_DEVICE_BALANCE 1024 // allow left/right balance control with BASS_SetVolume
  83. // DirectSound interfaces (for use with BASS_GetDSoundObject)
  84. #define BASS_OBJECT_DS 1 // IDirectSound
  85. #define BASS_OBJECT_DS3DL 2 // IDirectSound3DListener
  87. typedef struct {
  88. DWORD size; // size of this struct (set this before calling the function)
  89. DWORD flags; // device capabilities (DSCAPS_xxx flags)
  90. DWORD hwsize; // size of total device hardware memory
  91. DWORD hwfree; // size of free device hardware memory
  92. DWORD freesam; // number of free sample slots in the hardware
  93. DWORD free3d; // number of free 3D sample slots in the hardware
  94. DWORD minrate; // min sample rate supported by the hardware
  95. DWORD maxrate; // max sample rate supported by the hardware
  96. BOOL eax; // device supports EAX? (always FALSE if BASS_DEVICE_3D was not used)
  97. DWORD minbuf; // recommended minimum buffer length in ms (requires BASS_DEVICE_LATENCY)
  98. DWORD dsver; // DirectSound version (use to check for DX5/7/8 functions)
  99. DWORD latency; // delay (in ms) before start of playback (requires BASS_DEVICE_LATENCY)
  100. } BASS_INFO;
  102. // BASS_INFO flags (from DSOUND.H)
  103. #define DSCAPS_CONTINUOUSRATE 0x00000010
  104. /* supports all sample rates between min/maxrate */
  105. #define DSCAPS_EMULDRIVER 0x00000020
  106. /* device does NOT have hardware DirectSound support */
  107. #define DSCAPS_CERTIFIED 0x00000040
  108. /* device driver has been certified by Microsoft */
  109. /* The following flags tell what type of samples are supported by HARDWARE
  110. mixing, all these formats are supported by SOFTWARE mixing */
  111. #define DSCAPS_SECONDARYMONO 0x00000100 // mono
  112. #define DSCAPS_SECONDARYSTEREO 0x00000200 // stereo
  113. #define DSCAPS_SECONDARY8BIT 0x00000400 // 8 bit
  114. #define DSCAPS_SECONDARY16BIT 0x00000800 // 16 bit
  116. typedef struct {
  117. DWORD size; // size of this struct (set this before calling the function)
  118. DWORD flags; // device capabilities (DSCCAPS_xxx flags)
  119. DWORD formats; // supported standard formats (WAVE_FORMAT_xxx flags)
  120. DWORD inputs; // number of inputs
  121. BOOL singlein; // TRUE = only 1 input can be set at a time
  122. } BASS_RECORDINFO;
  124. // BASS_RECORDINFO flags (from DSOUND.H)
  125. #define DSCCAPS_EMULDRIVER DSCAPS_EMULDRIVER
  126. /* device does NOT have hardware DirectSound recording support */
  127. #define DSCCAPS_CERTIFIED DSCAPS_CERTIFIED
  128. /* device driver has been certified by Microsoft */
  130. // defines for formats field of BASS_RECORDINFO (from MMSYSTEM.H)
  131. #define WAVE_FORMAT_1M08       0x00000001       /* 11.025 kHz, Mono,   8-bit  */
  132. #define WAVE_FORMAT_1S08       0x00000002       /* 11.025 kHz, Stereo, 8-bit  */
  133. #define WAVE_FORMAT_1M16       0x00000004       /* 11.025 kHz, Mono,   16-bit */
  134. #define WAVE_FORMAT_1S16       0x00000008       /* 11.025 kHz, Stereo, 16-bit */
  135. #define WAVE_FORMAT_2M08       0x00000010       /* 22.05  kHz, Mono,   8-bit  */
  136. #define WAVE_FORMAT_2S08       0x00000020       /* 22.05  kHz, Stereo, 8-bit  */
  137. #define WAVE_FORMAT_2M16       0x00000040       /* 22.05  kHz, Mono,   16-bit */
  138. #define WAVE_FORMAT_2S16       0x00000080       /* 22.05  kHz, Stereo, 16-bit */
  139. #define WAVE_FORMAT_4M08       0x00000100       /* 44.1   kHz, Mono,   8-bit  */
  140. #define WAVE_FORMAT_4S08       0x00000200       /* 44.1   kHz, Stereo, 8-bit  */
  141. #define WAVE_FORMAT_4M16       0x00000400       /* 44.1   kHz, Mono,   16-bit */
  142. #define WAVE_FORMAT_4S16       0x00000800       /* 44.1   kHz, Stereo, 16-bit */
  144. // Music flags
  145. #define BASS_MUSIC_RAMP 1 // normal ramping
  146. #define BASS_MUSIC_RAMPS 2 // sensitive ramping
  147. /* Ramping doesn't take a lot of extra processing and improves
  148. the sound quality by removing "clicks". Sensitive ramping will
  149. leave sharp attacked samples, unlike normal ramping. */
  150. #define BASS_MUSIC_LOOP 4 // loop music
  151. #define BASS_MUSIC_FT2MOD 16 // play .MOD as FastTracker 2 does
  152. #define BASS_MUSIC_PT1MOD 32 // play .MOD as ProTracker 1 does
  153. #define BASS_MUSIC_MONO 64 // force mono mixing (less CPU usage)
  154. #define BASS_MUSIC_3D 128 // enable 3D functionality
  155. #define BASS_MUSIC_POSRESET 256 // stop all notes when moving position
  156. #define BASS_MUSIC_SURROUND 512 // surround sound
  157. #define BASS_MUSIC_SURROUND2 1024 // surround sound (mode 2)
  158. #define BASS_MUSIC_STOPBACK 2048 // stop the music on a backwards jump effect
  159. #define BASS_MUSIC_FX 4096 // enable old implementation of DX8 effects
  160. #define BASS_MUSIC_CALCLEN 8192 // calculate playback length
  161. #define BASS_MUSIC_DECODE 0x200000// don't play the music, only decode (BASS_ChannelGetData)
  162. #define BASS_MUSIC_NOSAMPLE 0x400000// don't load the samples
  164. // Sample info structure & flags
  165. typedef struct {
  166. DWORD freq; // default playback rate
  167. DWORD volume; // default volume (0-100)
  168. int pan; // default pan (-100=left, 0=middle, 100=right)
  169. DWORD flags; // BASS_SAMPLE_xxx flags
  170. DWORD length; // length (in samples, not bytes)
  171. DWORD max; // maximum simultaneous playbacks
  172. /* The following are the sample's default 3D attributes (if the sample
  173. is 3D, BASS_SAMPLE_3D is in flags) see BASS_ChannelSet3DAttributes */
  174. DWORD mode3d; // BASS_3DMODE_xxx mode
  175. float mindist; // minimum distance
  176. float maxdist; // maximum distance
  177. DWORD iangle; // angle of inside projection cone
  178. DWORD oangle; // angle of outside projection cone
  179. DWORD outvol; // delta-volume outside the projection cone
  180. /* The following are the defaults used if the sample uses the DirectX 7
  181. voice allocation/management features. */
  182. DWORD vam; // voice allocation/management flags (BASS_VAM_xxx)
  183. DWORD priority; // priority (0=lowest, 0xffffffff=highest)
  184. } BASS_SAMPLE;
  186. #define BASS_SAMPLE_8BITS 1 // 8 bit, else 16 bit
  187. #define BASS_SAMPLE_MONO 2 // mono, else stereo
  188. #define BASS_SAMPLE_LOOP 4 // looped
  189. #define BASS_SAMPLE_3D 8 // 3D functionality enabled
  190. #define BASS_SAMPLE_SOFTWARE 16 // it's NOT using hardware mixing
  191. #define BASS_SAMPLE_MUTEMAX 32 // muted at max distance (3D only)
  192. #define BASS_SAMPLE_VAM 64 // uses the DX7 voice allocation & management
  193. #define BASS_SAMPLE_FX 128 // old implementation of DX8 effects are enabled
  194. #define BASS_SAMPLE_OVER_VOL 0x10000 // override lowest volume
  195. #define BASS_SAMPLE_OVER_POS 0x20000 // override longest playing
  196. #define BASS_SAMPLE_OVER_DIST 0x30000 // override furthest from listener (3D only)
  198. #define BASS_MP3_HALFRATE 0x10000 // reduced quality MP3/MP2/MP1 (half sample rate)
  199. #define BASS_MP3_SETPOS 0x20000 // enable pin-point seeking on the MP3/MP2/MP1/OGG
  201. #define BASS_STREAM_AUTOFREE 0x40000 // automatically free the stream when it stop/ends
  202. #define BASS_STREAM_RESTRATE 0x80000 // restrict the download rate of internet file streams
  203. #define BASS_STREAM_BLOCK 0x100000// download/play internet file stream (MPx/OGG) in small blocks
  204. #define BASS_STREAM_DECODE 0x200000// don't play the stream, only decode (BASS_ChannelGetData)
  205. #define BASS_STREAM_META 0x400000// request metadata from a Shoutcast stream
  206. #define BASS_STREAM_FILEPROC 0x800000// use a STREAMFILEPROC callback
  208. // DX7 voice allocation flags
  209. #define BASS_VAM_HARDWARE 1
  210. /* Play the sample in hardware. If no hardware voices are available then
  211. the "play" call will fail */
  212. #define BASS_VAM_SOFTWARE 2
  213. /* Play the sample in software (ie. non-accelerated). No other VAM flags
  214. may be used together with this flag. */
  216. // DX7 voice management flags
  217. /* These flags enable hardware resource stealing... if the hardware has no
  218. available voices, a currently playing buffer will be stopped to make room for
  219. the new buffer. NOTE: only samples loaded/created with the BASS_SAMPLE_VAM
  220. flag are considered for termination by the DX7 voice management. */
  221. #define BASS_VAM_TERM_TIME 4
  222. /* If there are no free hardware voices, the buffer to be terminated will be
  223. the one with the least time left to play. */
  224. #define BASS_VAM_TERM_DIST 8
  225. /* If there are no free hardware voices, the buffer to be terminated will be
  226. one that was loaded/created with the BASS_SAMPLE_MUTEMAX flag and is beyond
  227. it's max distance. If there are no buffers that match this criteria, then the
  228. "play" call will fail. */
  229. #define BASS_VAM_TERM_PRIO 16
  230. /* If there are no free hardware voices, the buffer to be terminated will be
  231. the one with the lowest priority. */
  233. // 3D vector (for 3D positions/velocities/orientations)
  234. typedef struct {
  235. float x; // +=right, -=left
  236. float y; // +=up, -=down
  237. float z; // +=front, -=behind
  238. } BASS_3DVECTOR;
  240. // 3D channel modes
  241. #define BASS_3DMODE_NORMAL 0
  242. /* normal 3D processing */
  243. #define BASS_3DMODE_RELATIVE 1
  244. /* The channel's 3D position (position/velocity/orientation) are relative to
  245. the listener. When the listener's position/velocity/orientation is changed
  246. with BASS_Set3DPosition, the channel's position relative to the listener does
  247. not change. */
  248. #define BASS_3DMODE_OFF 2
  249. /* Turn off 3D processing on the channel, the sound will be played
  250. in the center. */
  252. // EAX environments, use with BASS_SetEAXParameters
  253. enum
  254. {
  255.     EAX_ENVIRONMENT_GENERIC,
  256.     EAX_ENVIRONMENT_PADDEDCELL,
  257.     EAX_ENVIRONMENT_ROOM,
  258.     EAX_ENVIRONMENT_BATHROOM,
  259.     EAX_ENVIRONMENT_LIVINGROOM,
  260.     EAX_ENVIRONMENT_STONEROOM,
  261.     EAX_ENVIRONMENT_AUDITORIUM,
  262.     EAX_ENVIRONMENT_CONCERTHALL,
  263.     EAX_ENVIRONMENT_CAVE,
  264.     EAX_ENVIRONMENT_ARENA,
  265.     EAX_ENVIRONMENT_HANGAR,
  266.     EAX_ENVIRONMENT_CARPETEDHALLWAY,
  267.     EAX_ENVIRONMENT_HALLWAY,
  268.     EAX_ENVIRONMENT_STONECORRIDOR,
  269.     EAX_ENVIRONMENT_ALLEY,
  270.     EAX_ENVIRONMENT_FOREST,
  271.     EAX_ENVIRONMENT_CITY,
  272.     EAX_ENVIRONMENT_MOUNTAINS,
  273.     EAX_ENVIRONMENT_QUARRY,
  274.     EAX_ENVIRONMENT_PLAIN,
  275.     EAX_ENVIRONMENT_PARKINGLOT,
  276.     EAX_ENVIRONMENT_SEWERPIPE,
  277.     EAX_ENVIRONMENT_UNDERWATER,
  278.     EAX_ENVIRONMENT_DRUGGED,
  279.     EAX_ENVIRONMENT_DIZZY,
  280.     EAX_ENVIRONMENT_PSYCHOTIC,
  282.     EAX_ENVIRONMENT_COUNT // total number of environments
  283. };
  285. // EAX presets, usage: BASS_SetEAXParameters(EAX_PRESET_xxx)
  286. #define EAX_PRESET_GENERIC         EAX_ENVIRONMENT_GENERIC,0.5F,1.493F,0.5F
  287. #define EAX_PRESET_PADDEDCELL      EAX_ENVIRONMENT_PADDEDCELL,0.25F,0.1F,0.0F
  288. #define EAX_PRESET_ROOM            EAX_ENVIRONMENT_ROOM,0.417F,0.4F,0.666F
  289. #define EAX_PRESET_BATHROOM        EAX_ENVIRONMENT_BATHROOM,0.653F,1.499F,0.166F
  290. #define EAX_PRESET_LIVINGROOM      EAX_ENVIRONMENT_LIVINGROOM,0.208F,0.478F,0.0F
  291. #define EAX_PRESET_STONEROOM       EAX_ENVIRONMENT_STONEROOM,0.5F,2.309F,0.888F
  292. #define EAX_PRESET_AUDITORIUM      EAX_ENVIRONMENT_AUDITORIUM,0.403F,4.279F,0.5F
  293. #define EAX_PRESET_CONCERTHALL     EAX_ENVIRONMENT_CONCERTHALL,0.5F,3.961F,0.5F
  294. #define EAX_PRESET_CAVE            EAX_ENVIRONMENT_CAVE,0.5F,2.886F,1.304F
  295. #define EAX_PRESET_ARENA           EAX_ENVIRONMENT_ARENA,0.361F,7.284F,0.332F
  296. #define EAX_PRESET_HANGAR          EAX_ENVIRONMENT_HANGAR,0.5F,10.0F,0.3F
  297. #define EAX_PRESET_CARPETEDHALLWAY EAX_ENVIRONMENT_CARPETEDHALLWAY,0.153F,0.259F,2.0F
  298. #define EAX_PRESET_HALLWAY         EAX_ENVIRONMENT_HALLWAY,0.361F,1.493F,0.0F
  299. #define EAX_PRESET_STONECORRIDOR   EAX_ENVIRONMENT_STONECORRIDOR,0.444F,2.697F,0.638F
  300. #define EAX_PRESET_ALLEY           EAX_ENVIRONMENT_ALLEY,0.25F,1.752F,0.776F
  301. #define EAX_PRESET_FOREST          EAX_ENVIRONMENT_FOREST,0.111F,3.145F,0.472F
  302. #define EAX_PRESET_CITY            EAX_ENVIRONMENT_CITY,0.111F,2.767F,0.224F
  303. #define EAX_PRESET_MOUNTAINS       EAX_ENVIRONMENT_MOUNTAINS,0.194F,7.841F,0.472F
  304. #define EAX_PRESET_QUARRY          EAX_ENVIRONMENT_QUARRY,1.0F,1.499F,0.5F
  305. #define EAX_PRESET_PLAIN           EAX_ENVIRONMENT_PLAIN,0.097F,2.767F,0.224F
  306. #define EAX_PRESET_PARKINGLOT      EAX_ENVIRONMENT_PARKINGLOT,0.208F,1.652F,1.5F
  307. #define EAX_PRESET_SEWERPIPE       EAX_ENVIRONMENT_SEWERPIPE,0.652F,2.886F,0.25F
  308. #define EAX_PRESET_UNDERWATER      EAX_ENVIRONMENT_UNDERWATER,1.0F,1.499F,0.0F
  309. #define EAX_PRESET_DRUGGED         EAX_ENVIRONMENT_DRUGGED,0.875F,8.392F,1.388F
  310. #define EAX_PRESET_DIZZY           EAX_ENVIRONMENT_DIZZY,0.139F,17.234F,0.666F
  311. #define EAX_PRESET_PSYCHOTIC       EAX_ENVIRONMENT_PSYCHOTIC,0.486F,7.563F,0.806F
  313. // software 3D mixing algorithm modes (used with BASS_Set3DAlgorithm)
  314. #define BASS_3DALG_DEFAULT 0
  315. /* default algorithm (currently translates to BASS_3DALG_OFF) */
  316. #define BASS_3DALG_OFF 1
  317. /* Uses normal left and right panning. The vertical axis is ignored except for
  318. scaling of volume due to distance. Doppler shift and volume scaling are still
  319. applied, but the 3D filtering is not performed. This is the most CPU efficient
  320. software implementation, but provides no virtual 3D audio effect. Head Related
  321. Transfer Function processing will not be done. Since only normal stereo panning
  322. is used, a channel using this algorithm may be accelerated by a 2D hardware
  323. voice if no free 3D hardware voices are available. */
  324. #define BASS_3DALG_FULL 2
  325. /* This algorithm gives the highest quality 3D audio effect, but uses more CPU.
  326. Requires Windows 98 2nd Edition or Windows 2000 that uses WDM drivers, if this
  327. mode is not available then BASS_3DALG_OFF will be used instead. */
  328. #define BASS_3DALG_LIGHT 3
  329. /* This algorithm gives a good 3D audio effect, and uses less CPU than the FULL
  330. mode. Requires Windows 98 2nd Edition or Windows 2000 that uses WDM drivers, if
  331. this mode is not available then BASS_3DALG_OFF will be used instead. */
  333. typedef DWORD (CALLBACK STREAMPROC)(HSTREAM handle, void *buffer, DWORD length, DWORD user);
  334. /* User stream callback function. NOTE: A stream function should obviously be as quick
  335. as possible, other streams (and MOD musics) can't be mixed until it's finished.
  336. handle : The stream that needs writing
  337. buffer : Buffer to write the samples in
  338. length : Number of bytes to write
  339. user   : The 'user' parameter value given when calling BASS_StreamCreate
  340. RETURN : Number of bytes written. If less than "length" then the
  341.          stream is assumed to be at the end, and is stopped. */
  343. // STREAMFILEPROC actions
  344. #define BASS_FILE_CLOSE 0
  345. #define BASS_FILE_READ 1
  346. #define BASS_FILE_QUERY 2
  347. #define BASS_FILE_LEN 3
  349. typedef DWORD (CALLBACK STREAMFILEPROC)(DWORD action,DWORD param1,DWORD param2,DWORD user);
  350. /* User file stream callback function.
  351. action : The action to perform, one of BASS_FILE_xxx values.
  352. param1 : Depends on "action"
  353. param2 : Depends on "action"
  354. user   : The 'user' parameter value given when calling BASS_StreamCreate
  355. RETURN : Depends on "action" */
  357. /* Sync types (with BASS_ChannelSetSync "param" and SYNCPROC "data"
  358. definitions) & flags. */
  359. #define BASS_SYNC_MUSICPOS 0
  360. #define BASS_SYNC_POS 0
  361. /* Sync when a music or stream reaches a position.
  362. if HMUSIC...
  363. param: LOWORD=order (0=first, -1=all) HIWORD=row (0=first, -1=all)
  364. data : LOWORD=order HIWORD=row
  365. if HSTREAM...
  366. param: position in bytes
  367. data : not used */
  368. #define BASS_SYNC_MUSICINST 1
  369. /* Sync when an instrument (sample for the non-instrument based formats)
  370. is played in a music (not including retrigs).
  371. param: LOWORD=instrument (1=first) HIWORD=note (0=c0...119=b9, -1=all)
  372. data : LOWORD=note HIWORD=volume (0-64) */
  373. #define BASS_SYNC_END 2
  374. /* Sync when a music or file stream reaches the end.
  375. param: not used
  376. data : 1 = the sync is triggered by a backward jump in a MOD music, otherwise not used */
  377. #define BASS_SYNC_MUSICFX 3
  378. /* Sync when the "sync" effect (XM/MTM/MOD: E8x/Wxx, IT/S3M: S2x) is used.
  379. param: 0:data=pos, 1:data="x" value
  380. data : param=0: LOWORD=order HIWORD=row, param=1: "x" value */
  381. #define BASS_SYNC_META 4
  382. /* Sync when metadata is received in a Shoutcast stream.
  383. param: not used
  384. data : pointer to the metadata */
  385. #define BASS_SYNC_SLIDE 5
  386. /* Sync when an attribute slide is completed.
  387. param: not used
  388. data : the type of slide completed (one of the BASS_SLIDE_xxx values) */
  389. #define BASS_SYNC_MESSAGE 0x20000000 // FLAG: post a Windows message (instead of callback)
  390. /* When using a window message "callback", the message to post is given in the "proc"
  391. parameter of BASS_ChannelSetSync, and is posted to the window specified in the BASS_Init
  392. call. The message parameters are: WPARAM = data, LPARAM = user. */
  393. #define BASS_SYNC_MIXTIME 0x40000000 // FLAG: sync at mixtime, else at playtime
  394. #define BASS_SYNC_ONETIME 0x80000000 // FLAG: sync only once, else continuously
  396. typedef void (CALLBACK SYNCPROC)(HSYNC handle, DWORD channel, DWORD data, DWORD user);
  397. /* Sync callback function. NOTE: a sync callback function should be very
  398. quick as other syncs cannot be processed until it has finished. If the sync
  399. is a "mixtime" sync, then other streams and MOD musics can not be mixed
  400. until it's finished either.
  401. handle : The sync that has occured
  402. channel: Channel that the sync occured in
  403. data   : Additional data associated with the sync's occurance
  404. user   : The 'user' parameter given when calling BASS_ChannelSetSync */
  406. typedef void (CALLBACK DSPPROC)(HDSP handle, DWORD channel, void *buffer, DWORD length, DWORD user);
  407. /* DSP callback function. NOTE: A DSP function should obviously be as quick as
  408. possible... other DSP functions, streams and MOD musics can not be processed
  409. until it's finished.
  410. handle : The DSP handle
  411. channel: Channel that the DSP is being applied to
  412. buffer : Buffer to apply the DSP to
  413. length : Number of bytes in the buffer
  414. user   : The 'user' parameter given when calling BASS_ChannelSetDSP */
  416. typedef BOOL (CALLBACK RECORDPROC)(void *buffer, DWORD length, DWORD user);
  417. /* Recording callback function.
  418. buffer : Buffer containing the recorded sample data
  419. length : Number of bytes
  420. user   : The 'user' parameter value given when calling BASS_RecordStart
  421. RETURN : TRUE = continue recording, FALSE = stop */
  423. // BASS_ChannelGetData flags
  424. #define BASS_DATA_AVAILABLE 0 // query how much data is buffered
  425. #define BASS_DATA_FFT512 0x80000000 // 512 sample FFT
  426. #define BASS_DATA_FFT1024 0x80000001 // 1024 FFT
  427. #define BASS_DATA_FFT2048 0x80000002 // 2048 FFT
  428. #define BASS_DATA_FFT512S 0x80000010 // stereo 512 sample FFT
  429. #define BASS_DATA_FFT1024S 0x80000011 // stereo 1024 FFT
  430. #define BASS_DATA_FFT2048S 0x80000012 // stereo 2048 FFT
  432. // BASS_StreamGetTags flags : what's returned
  433. #define BASS_TAG_ID3 0 // ID3v1 tags : 128 byte block
  434. #define BASS_TAG_ID3V2 1 // ID3v2 tags : variable length block
  435. #define BASS_TAG_OGG 2 // OGG comments : array of null-terminated strings
  436. #define BASS_TAG_HTTP 3 // HTTP headers : array of null-terminated strings
  437. #define BASS_TAG_ICY 4 // ICY headers : array of null-terminated strings
  438. #define BASS_TAG_META 5 // ICY metadata : null-terminated string
  440. // DX8 effect types, use with BASS_ChannelSetFX
  441. enum
  442. {
  443. BASS_FX_CHORUS, // GUID_DSFX_STANDARD_CHORUS
  444. BASS_FX_COMPRESSOR, // GUID_DSFX_STANDARD_COMPRESSOR
  445. BASS_FX_DISTORTION, // GUID_DSFX_STANDARD_DISTORTION
  446. BASS_FX_ECHO, // GUID_DSFX_STANDARD_ECHO
  447. BASS_FX_FLANGER, // GUID_DSFX_STANDARD_FLANGER
  448. BASS_FX_GARGLE, // GUID_DSFX_STANDARD_GARGLE
  449. BASS_FX_I3DL2REVERB, // GUID_DSFX_STANDARD_I3DL2REVERB
  450. BASS_FX_PARAMEQ, // GUID_DSFX_STANDARD_PARAMEQ
  451. BASS_FX_REVERB // GUID_DSFX_WAVES_REVERB
  452. };
  454. typedef struct {
  455.     float       fWetDryMix;
  456.     float       fDepth;
  457.     float       fFeedback;
  458.     float       fFrequency;
  459.     DWORD       lWaveform; // 0=triangle, 1=sine
  460.     float       fDelay;
  461.     DWORD       lPhase; // BASS_FX_PHASE_xxx
  462. } BASS_FXCHORUS; // DSFXChorus
  464. typedef struct {
  465.     float   fGain;
  466.     float   fAttack;
  467.     float   fRelease;
  468.     float   fThreshold;
  469.     float   fRatio;
  470.     float   fPredelay;
  471. } BASS_FXCOMPRESSOR; // DSFXCompressor
  473. typedef struct {
  474.     float   fGain;
  475.     float   fEdge;
  476.     float   fPostEQCenterFrequency;
  477.     float   fPostEQBandwidth;
  478.     float   fPreLowpassCutoff;
  479. } BASS_FXDISTORTION; // DSFXDistortion
  481. typedef struct {
  482.     float   fWetDryMix;
  483.     float   fFeedback;
  484.     float   fLeftDelay;
  485.     float   fRightDelay;
  486.     BOOL    lPanDelay;
  487. } BASS_FXECHO; // DSFXEcho
  489. typedef struct {
  490.     float       fWetDryMix;
  491.     float       fDepth;
  492.     float       fFeedback;
  493.     float       fFrequency;
  494.     DWORD       lWaveform; // 0=triangle, 1=sine
  495.     float       fDelay;
  496.     DWORD       lPhase; // BASS_FX_PHASE_xxx
  497. } BASS_FXFLANGER; // DSFXFlanger
  499. typedef struct {
  500.     DWORD       dwRateHz;               // Rate of modulation in hz
  501.     DWORD       dwWaveShape;            // 0=triangle, 1=square
  502. } BASS_FXGARGLE; // DSFXGargle
  504. typedef struct {
  505.     int     lRoom;                  // [-10000, 0]      default: -1000 mB
  506.     int     lRoomHF;                // [-10000, 0]      default: 0 mB
  507.     float   flRoomRolloffFactor;    // [0.0, 10.0]      default: 0.0
  508.     float   flDecayTime;            // [0.1, 20.0]      default: 1.49s
  509.     float   flDecayHFRatio;         // [0.1, 2.0]       default: 0.83
  510.     int     lReflections;           // [-10000, 1000]   default: -2602 mB
  511.     float   flReflectionsDelay;     // [0.0, 0.3]       default: 0.007 s
  512.     int     lReverb;                // [-10000, 2000]   default: 200 mB
  513.     float   flReverbDelay;          // [0.0, 0.1]       default: 0.011 s
  514.     float   flDiffusion;            // [0.0, 100.0]     default: 100.0 %
  515.     float   flDensity;              // [0.0, 100.0]     default: 100.0 %
  516.     float   flHFReference;          // [20.0, 20000.0]  default: 5000.0 Hz
  517. } BASS_FXI3DL2REVERB; // DSFXI3DL2Reverb
  519. typedef struct {
  520.     float   fCenter;
  521.     float   fBandwidth;
  522.     float   fGain;
  523. } BASS_FXPARAMEQ; // DSFXParamEq
  525. typedef struct {
  526.     float   fInGain;                // [-96.0,0.0]            default: 0.0 dB
  527.     float   fReverbMix;             // [-96.0,0.0]            default: 0.0 db
  528.     float   fReverbTime;            // [0.001,3000.0]         default: 1000.0 ms
  529.     float   fHighFreqRTRatio;       // [0.001,0.999]          default: 0.001
  530. } BASS_FXREVERB; // DSFXWavesReverb
  532. #define BASS_FX_PHASE_NEG_180        0
  533. #define BASS_FX_PHASE_NEG_90         1
  534. #define BASS_FX_PHASE_ZERO           2
  535. #define BASS_FX_PHASE_90             3
  536. #define BASS_FX_PHASE_180            4
  538. #define CDCHANNEL 0 // CD channel, for use with BASS_Channel functions
  539. #define RECORDCHAN 1 // Recording channel, for use with BASS_Channel functions
  541. // BASS_ChannelIsActive return values
  542. #define BASS_ACTIVE_STOPPED 0
  543. #define BASS_ACTIVE_PLAYING 1
  544. #define BASS_ACTIVE_STALLED 2
  545. #define BASS_ACTIVE_PAUSED 3
  547. // BASS_ChannelIsSliding return flags
  548. #define BASS_SLIDE_FREQ 1
  549. #define BASS_SLIDE_VOL 2
  550. #define BASS_SLIDE_PAN 4
  552. // BASS_CDGetID flags
  553. #define BASS_CDID_IDENTITY 0
  554. #define BASS_CDID_UPC 1
  555. #define BASS_CDID_CDDB 2
  556. #define BASS_CDID_CDDB2 3
  558. // BASS_RecordSetInput flags
  559. #define BASS_INPUT_OFF 0x10000
  560. #define BASS_INPUT_ON 0x20000
  561. #define BASS_INPUT_LEVEL 0x40000
  563. // BASS_SetNetConfig flags
  564. #define BASS_NET_TIMEOUT 0
  565. #define BASS_NET_BUFFER 1
  568. DWORD BASSDEF(BASS_GetVersion)();
  569. /* Retrieve the version number of BASS that is loaded.
  570. RETURN : The BASS version (LOWORD.HIWORD) */
  572. char *BASSDEF(BASS_GetDeviceDescription)(DWORD devnum);
  573. /* Get the text description of a device. This function can be used to
  574. enumerate the available devices.
  575. devnum : The device (0=first)
  576. RETURN : The text description of the device (NULL=error) */
  578. float BASSDEF(BASS_SetBufferLength)(float length);
  579. /* Set the amount that BASS mixes ahead new musics/streams. Changing
  580. this setting does not affect musics/streams that have already been
  581. loaded/created. Increasing the buffer length, decreases the chance of
  582. the sound possibly breaking-up on slower computers, but increase DSP
  583. latency. The default length is 0.5 secs.
  584. length : The buffer length in seconds
  585. RETURN : The actual new buffer length */
  587. DWORD BASSDEF(BASS_SetNetConfig)(DWORD option, DWORD value);
  588. /* Set an internet config option.
  589. option : The option to set (one of the BASS_NET_xxx flags)
  590. value  : The new value
  591. RETURN : The old value (-1=error) */
  593. void BASSDEF(BASS_SetGlobalVolumes)(int musvol, int samvol, int strvol);
  594. /* Set the global music/sample/stream volume levels.
  595. musvol : MOD music global volume level (0-100, -1=leave current)
  596. samvol : Sample global volume level (0-100, -1=leave current)
  597. strvol : Stream global volume level (0-100, -1=leave current) */
  599. void BASSDEF(BASS_GetGlobalVolumes)(DWORD *musvol, DWORD *samvol, DWORD *strvol);
  600. /* Retrieve the global music/sample/stream volume levels.
  601. musvol : MOD music global volume level (NULL=don't retrieve it)
  602. samvol : Sample global volume level (NULL=don't retrieve it)
  603. strvol : Stream global volume level (NULL=don't retrieve it) */
  605. void BASSDEF(BASS_SetLogCurves)(BOOL volume, BOOL pan);
  606. /* Make the volume/panning values translate to a logarithmic curve,
  607. or a linear "curve" (the default).
  608. volume : volume curve (FALSE=linear, TRUE=log)
  609. pan    : panning curve (FALSE=linear, TRUE=log) */
  611. void BASSDEF(BASS_Set3DAlgorithm)(DWORD algo);
  612. /* Set the 3D algorithm for software mixed 3D channels (does not affect
  613. hardware mixed channels). Changing the mode only affects subsequently
  614. created or loaded samples/streams/musics, not those that already exist.
  615. Requires DirectX 7 or above.
  616. algo   : algorithm flag (BASS_3DALG_xxx) */
  618. DWORD BASSDEF(BASS_ErrorGetCode)();
  619. /* Get the BASS_ERROR_xxx error code. Use this function to get the
  620. reason for an error. */
  622. void BASSDEF(BASS_SetCLSID)(GUID *clsid);
  623. /* Set the class identifier of the object to create, that will be used
  624. to initialize DirectSound.
  625. clsid  : Class identifier of the object to create (NULL=use default) */
  627. BOOL BASSDEF(BASS_Init)(int device, DWORD freq, DWORD flags, HWND win);
  628. /* Initialize the digital output. This must be called before all following
  629. BASS functions (except CD and recording functions).
  630. device : Device to use (0=first, -1=default, -2=no sound)
  631. freq   : Output sample rate
  632. flags  : BASS_DEVICE_xxx flags (optional HIWORD=update period)
  633. win    : Owner window (0=current foreground window)
  635. NOTE: The "no sound" device (device=-2), allows loading and "playing"
  636. of MOD musics only (all sample/stream functions and most other functions
  637. fail). This is so that you can still use the MOD musics as synchronizers
  638. when there is no soundcard present. When using device -2, you should still
  639. set the other arguments as you would do normally. */
  641. void BASSDEF(BASS_Free)();
  642. /* Free all resources used by the digital output, including all musics
  643. and samples. */
  645. void *BASSDEF(BASS_GetDSoundObject)(DWORD object);
  646. /* Retrieve a pointer to a DirectSound interface. This can be used by
  647. advanced users to "plugin" external functionality.
  648. object : The interface to retrieve (BASS_OBJECT_xxx)
  649. RETURN : A pointer to the requested interface (NULL=error) */
  651. void BASSDEF(BASS_GetInfo)(BASS_INFO *info);
  652. /* Retrieve some information on the device being used.
  653. info   : Pointer to store info at */
  655. BOOL BASSDEF(BASS_Update)();
  656. /* Update the HMUSIC/HSTREAM channel buffers. */
  658. float BASSDEF(BASS_GetCPU)();
  659. /* Get the current CPU usage of BASS. This includes the time taken to mix
  660. the MOD musics and sample streams, and also the time taken by any user
  661. DSP functions. It does not include plain sample mixing which is done by
  662. the output device (hardware accelerated) or DirectSound (emulated). Audio
  663. CD playback requires no CPU usage.
  664. RETURN : The CPU usage percentage (floating-point) */
  666. BOOL BASSDEF(BASS_Start)();
  667. /* Start the digital output. */
  669. BOOL BASSDEF(BASS_Stop)();
  670. /* Stop the digital output, stopping all musics/samples/streams. */
  672. BOOL BASSDEF(BASS_Pause)();
  673. /* Stop the digital output, pausing all musics/samples/streams. Use
  674. BASS_Start to resume the digital output. */
  676. BOOL BASSDEF(BASS_SetVolume)(DWORD volume);
  677. /* Set the digital output master volume.
  678. volume : Desired volume level (0-100) */
  680. int BASSDEF(BASS_GetVolume)();
  681. /* Get the digital output master volume.
  682. RETURN : The volume level (0-100, -1=error) */
  684. BOOL BASSDEF(BASS_Set3DFactors)(float distf, float rollf, float doppf);
  685. /* Set the factors that affect the calculations of 3D sound.
  686. distf  : Distance factor (0.0-10.0, 1.0=use meters, 0.3=use feet, <0.0=leave current)
  687.          By default BASS measures distances in meters, you can change this
  688.          setting if you are using a different unit of measurement.
  689. roolf  : Rolloff factor, how fast the sound quietens with distance
  690.          (0.0=no rolloff, 1.0=real world, 2.0=2x real... 10.0=max, <0.0=leave current)
  691. doppf  : Doppler factor (0.0=no doppler, 1.0=real world, 2.0=2x real... 10.0=max, <0.0=leave current)
  692.          The doppler effect is the way a sound appears to change frequency when it is
  693.          moving towards or away from you. The listener and sound velocity settings are
  694.          used to calculate this effect, this "doppf" value can be used to lessen or
  695.          exaggerate the effect. */
  697. BOOL BASSDEF(BASS_Get3DFactors)(float *distf, float *rollf, float *doppf);
  698. /* Get the factors that affect the calculations of 3D sound.
  699. distf  : Distance factor (NULL=don't get it)
  700. roolf  : Rolloff factor (NULL=don't get it)
  701. doppf  : Doppler factor (NULL=don't get it) */
  703. BOOL BASSDEF(BASS_Set3DPosition)(BASS_3DVECTOR *pos, BASS_3DVECTOR *vel, BASS_3DVECTOR *front, BASS_3DVECTOR *top);
  704. /* Set the position/velocity/orientation of the listener (ie. the player/viewer).
  705. pos    : Position of the listener (NULL=leave current)
  706. vel    : Listener's velocity, used to calculate doppler effect (NULL=leave current)
  707. front  : Direction that listener's front is pointing (NULL=leave current)
  708. top    : Direction that listener's top is pointing (NULL=leave current)
  709.          NOTE: front & top must both be set in a single call */
  711. BOOL BASSDEF(BASS_Get3DPosition)(BASS_3DVECTOR *pos, BASS_3DVECTOR *vel, BASS_3DVECTOR *front, BASS_3DVECTOR *top);
  712. /* Get the position/velocity/orientation of the listener.
  713. pos    : Position of the listener (NULL=don't get it)
  714. vel    : Listener's velocity (NULL=don't get it)
  715. front  : Direction that listener's front is pointing (NULL=don't get it)
  716. top    : Direction that listener's top is pointing (NULL=don't get it)
  717.          NOTE: front & top must both be retrieved in a single call */
  719. BOOL BASSDEF(BASS_Apply3D)();
  720. /* Apply changes made to the 3D system. This must be called to apply any changes
  721. made with BASS_Set3DFactors, BASS_Set3DPosition, BASS_ChannelSet3DAttributes or
  722. BASS_ChannelSet3DPosition. It improves performance to have DirectSound do all the
  723. required recalculating at the same time like this, rather than recalculating after
  724. every little change is made. NOTE: This is automatically called when starting a 3D
  725. sample with BASS_SamplePlay3D/Ex. */
  727. BOOL BASSDEF(BASS_SetEAXParameters)(int env, float vol, float decay, float damp);
  728. /* Set the type of EAX environment and it's parameters. Obviously, EAX functions
  729. have no effect if no EAX supporting device (ie. SB Live) is used.
  730. env    : Reverb environment (EAX_ENVIRONMENT_xxx, -1=leave current)
  731. vol    : Volume of the reverb (0.0=off, 1.0=max, <0.0=leave current)
  732. decay  : Time in seconds it takes the reverb to diminish by 60dB (0.1-20.0, <0.0=leave current)
  733. damp   : The damping, high or low frequencies decay faster (0.0=high decays quickest,
  734.          1.0=low/high decay equally, 2.0=low decays quickest, <0.0=leave current) */
  736. BOOL BASSDEF(BASS_GetEAXParameters)(DWORD *env, float *vol, float *decay, float *damp);
  737. /* Get the current EAX parameters.
  738. env    : Reverb environment (NULL=don't get it)
  739. vol    : Reverb volume (NULL=don't get it)
  740. decay  : Decay duration (NULL=don't get it)
  741. damp   : The damping (NULL=don't get it) */
  744. HMUSIC BASSDEF(BASS_MusicLoad)(BOOL mem, void *file, DWORD offset, DWORD length, DWORD flags);
  745. /* Load a music (MO3/XM/MOD/S3M/IT/MTM). The amplification and pan
  746. seperation are initially set to 50, use BASS_MusicSetAmplify
  747. and BASS_MusicSetPanSep to adjust them.
  748. mem    : TRUE = Load music from memory
  749. file   : Filename (mem=FALSE) or memory location (mem=TRUE)
  750. offset : File offset to load the music from (only used if mem=FALSE)
  751. length : Data length (only used if mem=FALSE, 0=use to end of file)
  752. flags  : BASS_MUSIC_xxx flags
  753. RETURN : The loaded music's handle (NULL=error) */
  755. void BASSDEF(BASS_MusicFree)(HMUSIC handle);
  756. /* Free a music's resources.
  757. handle : Music handle */
  759. char *BASSDEF(BASS_MusicGetName)(HMUSIC handle);
  760. /* Retrieves a music's name.
  761. handle : Music handle
  762. RETURN : The music's name (NULL=error) */
  764. DWORD BASSDEF(BASS_MusicGetLength)(HMUSIC handle, BOOL playlen);
  765. /* Retrieves the length of a music in patterns (how many "orders" there are)
  766. or in output bytes (requires BASS_MUSIC_CALCLEN was used with BASS_MusicLoad).
  767. handle : Music handle
  768. playlen: TRUE=get the playback length, FALSE=get the pattern length
  769. RETURN : The length of the music (-1=error) */
  771. BOOL BASSDEF(BASS_MusicPreBuf)(HMUSIC handle);
  772. /* Pre-buffer initial sample data ready for playback.
  773. handle : Handle of music */
  775. BOOL BASSDEF(BASS_MusicPlay)(HMUSIC handle);
  776. /* Play a music. Playback continues from where it was last stopped/paused.
  777. Multiple musics may be played simultaneously.
  778. handle : Handle of music to play */
  780. BOOL BASSDEF(BASS_MusicPlayEx)(HMUSIC handle, DWORD pos, int flags, BOOL reset);
  781. /* Play a music, specifying start position and playback flags.
  782. handle : Handle of music to play
  783. pos    : Position to start playback from, LOWORD=order HIWORD=row
  784. flags  : BASS_MUSIC_xxx flags. These flags overwrite the defaults
  785.          specified when the music was loaded. (-1=use current flags)
  786. reset  : TRUE = Stop all current playing notes and reset bpm/etc... */
  788. BOOL BASSDEF(BASS_MusicSetAmplify)(HMUSIC handle, DWORD amp);
  789. /* Set a music's amplification level.
  790. handle : Music handle
  791. amp    : Amplification level (0-100) */
  793. BOOL BASSDEF(BASS_MusicSetPanSep)(HMUSIC handle, DWORD pan);
  794. /* Set a music's pan seperation.
  795. handle : Music handle
  796. pan    : Pan seperation (0-100, 50=linear) */
  798. BOOL BASSDEF(BASS_MusicSetPositionScaler)(HMUSIC handle, DWORD scale);
  799. /* Set a music's "GetPosition" scaler
  800. When you call BASS_ChannelGetPosition, the "row" (HIWORD) will be
  801. scaled by this value. By using a higher scaler, you can get a more
  802. precise position indication.
  803. handle : Music handle
  804. scale  : The scaler (1-256) */
  806. BOOL BASSDEF(BASS_MusicSetChannelVol)(HMUSIC handle, DWORD channel, DWORD volume);
  807. /* Set the volume level of a channel in a music
  808. handle : Music handle
  809. channel: Channel number (0=first)
  810. volume : Volume level (0-100) */
  812. int BASSDEF(BASS_MusicGetChannelVol)(HMUSIC handle, DWORD channel);
  813. /* Get the volume level of a channel in a music
  814. handle : Music handle
  815. channel: Channel number (0=first)
  816. RETURN : The channel's volume (-1=error) */
  819. HSAMPLE BASSDEF(BASS_SampleLoad)(BOOL mem, void *file, DWORD offset, DWORD length, DWORD max, DWORD flags);
  820. /* Load a WAV/MP3/MP2/MP1 sample. If you're loading a sample with 3D
  821. functionality, then you should use BASS_GetInfo and BASS_SetInfo to set
  822. the default 3D parameters. You can also use these two functions to set
  823. the sample's default frequency/volume/pan/looping.
  824. mem    : TRUE = Load sample from memory
  825. file   : Filename (mem=FALSE) or memory location (mem=TRUE)
  826. offset : File offset to load the sample from (only used if mem=FALSE)
  827. length : Data length (only used if mem=FALSE, 0=use to end of file)
  828. max    : Maximum number of simultaneous playbacks (1-65535)
  829. flags  : BASS_SAMPLE_xxx flags (only the LOOP/3D/SOFTWARE/VAM/MUTEMAX/OVER_xxx flags are used)
  830. RETURN : The loaded sample's handle (NULL=error) */
  832. void* BASSDEF(BASS_SampleCreate)(DWORD length, DWORD freq, DWORD max, DWORD flags);
  833. /* Create a sample. This function allows you to generate custom samples, or
  834. load samples that are not in the WAV format. A pointer is returned to the
  835. memory location at which you should write the sample's data. After writing
  836. the data, call BASS_SampleCreateDone to get the new sample's handle.
  837. length : The sample's length (in samples, NOT bytes)
  838. freq   : default sample rate
  839. max    : Maximum number of simultaneous playbacks (1-65535)
  840. flags  : BASS_SAMPLE_xxx flags
  841. RETURN : Memory location to write the sample's data (NULL=error) */
  843. HSAMPLE BASSDEF(BASS_SampleCreateDone)();
  844. /* Finished creating a new sample.
  845. RETURN : The new sample's handle (NULL=error) */
  847. void BASSDEF(BASS_SampleFree)(HSAMPLE handle);
  848. /* Free a sample's resources.
  849. handle : Sample handle */
  851. BOOL BASSDEF(BASS_SampleGetInfo)(HSAMPLE handle, BASS_SAMPLE *info);
  852. /* Retrieve a sample's current default attributes.
  853. handle : Sample handle
  854. info   : Pointer to store sample info */
  856. BOOL BASSDEF(BASS_SampleSetInfo)(HSAMPLE handle, BASS_SAMPLE *info);
  857. /* Set a sample's default attributes.
  858. handle : Sample handle
  859. info   : Sample info, only the freq/volume/pan/3D attributes and
  860.          looping/override method flags are used */
  862. HCHANNEL BASSDEF(BASS_SamplePlay)(HSAMPLE handle);
  863. /* Play a sample, using the sample's default attributes.
  864. handle : Handle of sample to play
  865. RETURN : Handle of channel used to play the sample (NULL=error) */
  867. HCHANNEL BASSDEF(BASS_SamplePlayEx)(HSAMPLE handle, DWORD start, int freq, int volume, int pan, BOOL loop);
  868. /* Play a sample, using specified attributes.
  869. handle : Handle of sample to play
  870. start  : Playback start position (in samples, not bytes)
  871. freq   : Playback rate (-1=default)
  872. volume : Volume (-1=default, 0=silent, 100=max)
  873. pan    : Pan position (-101=default, -100=left, 0=middle, 100=right)
  874. loop   : TRUE = Loop sample (-1=default)
  875. RETURN : Handle of channel used to play the sample (NULL=error) */
  877. HCHANNEL BASSDEF(BASS_SamplePlay3D)(HSAMPLE handle, BASS_3DVECTOR *pos, BASS_3DVECTOR *orient, BASS_3DVECTOR *vel);
  878. /* Play a 3D sample, setting it's 3D position, orientation and velocity.
  879. handle : Handle of sample to play
  880. pos    : position of the sound (NULL = x/y/z=0.0)
  881. orient : orientation of the sound, this is irrelevant if it's an
  882.          omnidirectional sound source (NULL = x/y/z=0.0)
  883. vel    : velocity of the sound (NULL = x/y/z=0.0)
  884. RETURN : Handle of channel used to play the sample (NULL=error) */
  886. HCHANNEL BASSDEF(BASS_SamplePlay3DEx)(HSAMPLE handle, BASS_3DVECTOR *pos, BASS_3DVECTOR *orient, BASS_3DVECTOR *vel, DWORD start, int freq, int volume, BOOL loop);
  887. /* Play a 3D sample, using specified attributes.
  888. handle : Handle of sample to play
  889. pos    : position of the sound (NULL = x/y/z=0.0)
  890. orient : orientation of the sound, this is irrelevant if it's an
  891.          omnidirectional sound source (NULL = x/y/z=0.0)
  892. vel    : velocity of the sound (NULL = x/y/z=0.0)
  893. start  : Playback start position (in samples, not bytes)
  894. freq   : Playback rate (-1=default)
  895. volume : Volume (-1=default, 0=silent, 100=max)
  896. loop   : TRUE = Loop sample (-1=default)
  897. RETURN : Handle of channel used to play the sample (NULL=error) */
  899. BOOL BASSDEF(BASS_SampleStop)(HSAMPLE handle);
  900. /* Stops all instances of a sample. For example, if a sample is playing
  901. simultaneously 3 times, calling this function will stop all 3 of them,
  902. which is obviously simpler than calling BASS_ChannelStop 3 times.
  903. handle : Handle of sample to stop */
  906. HSTREAM BASSDEF(BASS_StreamCreate)(DWORD freq, DWORD flags, void *proc, DWORD user);
  907. /* Create a user sample stream.
  908. freq   : Stream playback rate (100-100000)
  909. flags  : BASS_SAMPLE_xxx flags (only the 8BITS/MONO/3D flags are used)
  910. proc   : User defined stream writing function
  911. user   : The 'user' value passed to the callback function
  912. RETURN : The created stream's handle (NULL=error) */
  914. HSTREAM BASSDEF(BASS_StreamCreateFile)(BOOL mem, void *file, DWORD offset, DWORD length, DWORD flags);
  915. /* Create a sample stream from an MP3/MP2/MP1/OGG or WAV file.
  916. mem    : TRUE = Stream file from memory
  917. file   : Filename (mem=FALSE) or memory location (mem=TRUE)
  918. offset : File offset of the stream data
  919. length : File length (0=use whole file if mem=FALSE)
  920. flags  : Flags
  921. RETURN : The created stream's handle (NULL=error) */
  923. HSTREAM BASSDEF(BASS_StreamCreateURL)(char *url, DWORD offset, DWORD flags, char *save);
  924. /* Create a sample stream from an MP3/MP2/MP1/OGG or WAV file on the internet,
  925. optionally saving a local copy to disk.
  926. url    : The URL (beginning with "http://" or "ftp://")
  927. offset : File offset of start streaming from
  928. flags  : Flags
  929. save   : Filename to save the streamed file as locally (NULL=don't save)
  930. RETURN : The created stream's handle (NULL=error) */
  932. void BASSDEF(BASS_StreamFree)(HSTREAM handle);
  933. /* Free a sample stream's resources.
  934. handle : Stream handle */
  936. QWORD BASSDEF(BASS_StreamGetLength)(HSTREAM handle);
  937. /* Retrieves the playback length (in bytes) of a file stream. It's not always
  938. possible to 100% accurately guess the length of a stream, so the length returned
  939. may be only an approximation when using some WAV codecs.
  940. handle : Stream handle 
  941. RETURN : The length (0=streaming in blocks, -1=error) */
  943. char *BASSDEF(BASS_StreamGetTags)(HSTREAM handle, DWORD tags);
  944. /* Retrieves the requested tags/headers, if available.
  945. handle : Stream handle
  946. tags   : A BASS_TAG_xxx flag
  947. RETURN : Pointer to the tags (NULL=error) */
  949. BOOL BASSDEF(BASS_StreamPreBuf)(HSTREAM handle);
  950. /* Pre-buffer initial sample data ready for playback.
  951. handle : Handle of stream */
  953. BOOL BASSDEF(BASS_StreamPlay)(HSTREAM handle, BOOL flush, DWORD flags);
  954. /* Play a sample stream, optionally flushing the buffer first.
  955. handle : Handle of stream to play
  956. flush  : Flush buffer contents. If you stop a stream and then want to
  957.          continue it from where it stopped, don't flush it. Flushing
  958.          a file stream causes it to restart from the beginning.
  959. flags  : BASS_SAMPLE_LOOP flag (only affects file streams) */
  961. DWORD BASSDEF(BASS_StreamGetFilePosition)(HSTREAM handle, DWORD mode);
  962. /* Retrieves the file position of the decoding, the download (if streaming from
  963. the internet), or the end (total length). Obviously only works with file streams.
  964. handle : Stream handle
  965. mode   : The position to retrieve (0=decoding, 1=download, 2=end)
  966. RETURN : The position (-1=error) */
  969. BOOL BASSDEF(BASS_CDInit)(char *drive, DWORD flags);
  970. /* Initialize the CD functions, must be called before any other CD
  971. functions. The volume is initially set to 100 (the maximum), use
  972. BASS_ChannelSetAttributes to adjust it.
  973. drive  : The CD drive, for example: "d:" (NULL=use default drive)
  974. flags  : BASS_DEVICE_LEAVEVOL=leave the volume as it is */
  976. void BASSDEF(BASS_CDFree)();
  977. /* Free resources used by the CD. */
  979. BOOL BASSDEF(BASS_CDInDrive)();
  980. /* Check if there is a CD in the drive. */
  982. BOOL BASSDEF(BASS_CDDoor)(BOOL open);
  983. /* Opens or closes the CD door.
  984. open   : TRUE=open the door */
  986. char *BASSDEF(BASS_CDGetID)(DWORD id);
  987. /* Retrieves identification info from the CD in the drive.
  988. id     : One of the BASS_CDID_xxx flags
  989. RETURN : ID string (NULL=error) */
  991. DWORD BASSDEF(BASS_CDGetTracks)();
  992. /* Retrieves the number of tracks on the CD
  993. RETURN : The number of tracks (-1=error) */
  995. BOOL BASSDEF(BASS_CDPlay)(DWORD track, BOOL loop, BOOL wait);
  996. /* Play a CD track.
  997. track  : Track number to play (1=first)
  998. loop   : TRUE = Loop the track
  999. wait   : TRUE = don't return until playback has started (some drives
  1000.                 will always wait anyway) */
  1002. DWORD BASSDEF(BASS_CDGetTrackLength)(DWORD track);
  1003. /* Retrieves the playback length (in milliseconds) of a cd track.
  1004. track  : The CD track (1=first)
  1005. RETURN : The length (-1=error) */
  1008. char *BASSDEF(BASS_RecordGetDeviceDescription)(DWORD devnum);
  1009. /* Get the text description of a recording device. This function can be
  1010. used to enumerate the available devices.
  1011. devnum : The device (0=first)
  1012. RETURN : The text description of the device (NULL=error) */
  1014. BOOL BASSDEF(BASS_RecordInit)(int device);
  1015. /* Initialize a recording device.
  1016. device : Device to use (0=first, -1=default) */
  1018. void BASSDEF(BASS_RecordFree)();
  1019. /* Free all resources used by the recording device. */
  1021. void BASSDEF(BASS_RecordGetInfo)(BASS_RECORDINFO *info);
  1022. /* Retrieve some information on the recording device being used.
  1023. info   : Pointer to store info at */
  1025. char *BASSDEF(BASS_RecordGetInputName)(DWORD input);
  1026. /* Get the text description of a recording input.
  1027. input  : Input number (0=first)
  1028. RETURN : The text description (NULL=error) */
  1030. BOOL BASSDEF(BASS_RecordSetInput)(DWORD input, DWORD setting);
  1031. /* Adjust the setting of a recording input.
  1032. input  : Input number (0=first)
  1033. setting: BASS_INPUT flags (if BASS_INPUT_LEVEL used, LOWORD=volume) */
  1035. DWORD BASSDEF(BASS_RecordGetInput)(DWORD input);
  1036. /* Retrieve the setting of a recording input.
  1037. input  : Input number (0=first)
  1038. RETURN : The setting (LOWORD=volume, with BASS_INPUT_OFF flag if off, -1=error) */
  1040. BOOL BASSDEF(BASS_RecordStart)(DWORD freq, DWORD flags, RECORDPROC *proc, DWORD user);
  1041. /* Start recording. Use BASS_ChannelStop to stop recording.
  1042. freq   : Sampling rate
  1043. flags  : BASS_SAMPLE_8BITS/MONO flags (optional HIWORD=update period)
  1044. proc   : User defined function to receive the recorded data
  1045. user   : The 'user' value passed to the callback function */
  1048. /* A "channel" can be a playing sample (HCHANNEL), a MOD music (HMUSIC), a
  1049. sample stream (HSTREAM), the CD (CDCHANNEL), or recording (RECORDCHAN). The
  1050. following functions can be used with one or more of these channel types. */
  1052. float BASSDEF(BASS_ChannelBytes2Seconds)(DWORD handle, QWORD pos);
  1053. /* Translate a byte position into time (seconds)
  1054. handle : Handle of channel (HCHANNEL/HMUSIC/HSTREAM, or RECORDCHAN, also HSAMPLE)
  1055. pos    : The position to translate
  1056. RETURN : The millisecond position (<0=error) */
  1058. QWORD BASSDEF(BASS_ChannelSeconds2Bytes)(DWORD handle, float pos);
  1059. /* Translate a time (seconds) position into bytes
  1060. handle : Handle of channel (HCHANNEL/HMUSIC/HSTREAM, or RECORDCHAN, also HSAMPLE)
  1061. pos    : The position to translate
  1062. RETURN : The byte position (-1=error) */
  1064. DWORD BASSDEF(BASS_ChannelIsActive)(DWORD handle);
  1065. /* Check if a channel is active (playing) or stalled.
  1066. handle : Channel handle (HCHANNEL/HMUSIC/HSTREAM, or CDCHANNEL/RECORDCHAN)
  1067. RETURN : One of the BASS_ACTIVE_xxx values */
  1069. DWORD BASSDEF(BASS_ChannelGetFlags)(DWORD handle);
  1070. /* Get some info about a channel.
  1071. handle : Channel handle (HCHANNEL/HMUSIC/HSTREAM)
  1072. RETURN : BASS_SAMPLE_xxx flags (-1=error) */
  1074. BOOL BASSDEF(BASS_ChannelStop)(DWORD handle);
  1075. /* Stop a channel.
  1076. handle : Channel handle (HCHANNEL/HMUSIC/HSTREAM, or CDCHANNEL/RECORDCHAN) */
  1078. BOOL BASSDEF(BASS_ChannelPause)(DWORD handle);
  1079. /* Pause a channel.
  1080. handle : Channel handle (HCHANNEL/HMUSIC/HSTREAM, or CDCHANNEL/RECORDCHAN) */
  1082. BOOL BASSDEF(BASS_ChannelResume)(DWORD handle);
  1083. /* Resume a paused channel.
  1084. handle : Channel handle (HCHANNEL/HMUSIC/HSTREAM, or CDCHANNEL/RECORDCHAN) */
  1086. BOOL BASSDEF(BASS_ChannelSetAttributes)(DWORD handle, int freq, int volume, int pan);
  1087. /* Update a channel's attributes. The actual setting may not be exactly
  1088. as specified, depending on the accuracy of the device and drivers.
  1089. NOTE: Only the volume can be adjusted for the CD "channel", but not all
  1090. soundcards allow controlling of the CD volume level.
  1091. handle : Channel handle (HCHANNEL/HMUSIC/HSTREAM, or CDCHANNEL)
  1092. freq   : Playback rate (100-100000, 0=original, -1=leave current)
  1093. volume : Volume (-1=leave current, 0=silent, 100=max)
  1094. pan    : Pan position (-101=current, -100=left, 0=middle, 100=right)
  1095.          panning has no effect on 3D channels */
  1097. BOOL BASSDEF(BASS_ChannelGetAttributes)(DWORD handle, DWORD *freq, DWORD *volume, int *pan);
  1098. /* Retrieve a channel's attributes. Only the volume is available for
  1099. the CD "channel" (if allowed by the soundcard/drivers).
  1100. handle : Channel handle (HCHANNEL/HMUSIC/HSTREAM, or CDCHANNEL)
  1101. freq   : Pointer to store playback rate (NULL=don't retrieve it)
  1102. volume : Pointer to store volume (NULL=don't retrieve it)
  1103. pan    : Pointer to store pan position (NULL=don't retrieve it) */
  1105. BOOL BASSDEF(BASS_ChannelSlideAttributes)(DWORD handle, int freq, int volume, int pan, DWORD time);
  1106. /* Slide a channel's attributes over a period of time.
  1107. handle : Channel handle (HCHANNEL/HMUSIC/HSTREAM, or CDCHANNEL)
  1108. freq   : Playback rate (100-100000, -1=leave current)
  1109. volume : Volume (-1=leave current, 0=silent, 100=max, -2 = fadeout and stop channel)
  1110. pan    : Pan position (-101=current, -100=left, 0=middle, 100=right)
  1111. time   : Duration of the slide (in milliseconds) */
  1113. DWORD BASSDEF(BASS_ChannelIsSliding)(DWORD handle);
  1114. /* Check if a channel's attributes (freq/vol/pan) are sliding.
  1115. handle : Channel handle (HCHANNEL/HMUSIC/HSTREAM, or CDCHANNEL)
  1116. RETURN : Combination of the BASS_SLIDE_xxx flags */
  1118. BOOL BASSDEF(BASS_ChannelSet3DAttributes)(DWORD handle, int mode, float min, float max, int iangle, int oangle, int outvol);
  1119. /* Set a channel's 3D attributes.
  1120. handle : Channel handle (HCHANNEL/HSTREAM/HMUSIC)
  1121. mode   : BASS_3DMODE_xxx mode (-1=leave current setting)
  1122. min    : minimum distance, volume stops increasing within this distance (<0.0=leave current)
  1123. max    : maximum distance, volume stops decreasing past this distance (<0.0=leave current)
  1124. iangle : angle of inside projection cone in degrees (360=omnidirectional, -1=leave current)
  1125. oangle : angle of outside projection cone in degrees (-1=leave current)
  1126.          NOTE: iangle & oangle must both be set in a single call
  1127. outvol : delta-volume outside the projection cone (0=silent, 100=same as inside)
  1128. The iangle/oangle angles decide how wide the sound is projected around the
  1129. orientation angle. Within the inside angle the volume level is the channel
  1130. level as set with BASS_ChannelSetAttributes, from the inside to the outside
  1131. angles the volume gradually changes by the "outvol" setting. */
  1133. BOOL BASSDEF(BASS_ChannelGet3DAttributes)(DWORD handle, DWORD *mode, float *min, float *max, DWORD *iangle, DWORD *oangle, DWORD *outvol);
  1134. /* Retrieve a channel's 3D attributes.
  1135. handle : Channel handle (HCHANNEL/HSTREAM/HMUSIC)
  1136. mode   : BASS_3DMODE_xxx mode (NULL=don't retrieve it)
  1137. min    : minumum distance (NULL=don't retrieve it)
  1138. max    : maximum distance (NULL=don't retrieve it)
  1139. iangle : angle of inside projection cone (NULL=don't retrieve it)
  1140. oangle : angle of outside projection cone (NULL=don't retrieve it)
  1141.          NOTE: iangle & oangle must both be retrieved in a single call
  1142. outvol : delta-volume outside the projection cone (NULL=don't retrieve it) */
  1144. BOOL BASSDEF(BASS_ChannelSet3DPosition)(DWORD handle, BASS_3DVECTOR *pos, BASS_3DVECTOR *orient, BASS_3DVECTOR *vel);
  1145. /* Update a channel's 3D position, orientation and velocity. The velocity
  1146. is only used to calculate the doppler effect.
  1147. handle : Channel handle (HCHANNEL/HSTREAM/HMUSIC)
  1148. pos    : position of the sound (NULL=leave current)
  1149. orient : orientation of the sound, this is irrelevant if it's an
  1150.          omnidirectional sound source (NULL=leave current)
  1151. vel    : velocity of the sound (NULL=leave current) */
  1153. BOOL BASSDEF(BASS_ChannelGet3DPosition)(DWORD handle, BASS_3DVECTOR *pos, BASS_3DVECTOR *orient, BASS_3DVECTOR *vel);
  1154. /* Retrieve a channel's current 3D position, orientation and velocity.
  1155. handle : Channel handle (HCHANNEL/HSTREAM/HMUSIC)
  1156. pos    : position of the sound (NULL=don't retrieve it)
  1157. orient : orientation of the sound, this is irrelevant if it's an
  1158.          omnidirectional sound source (NULL=don't retrieve it)
  1159. vel    : velocity of the sound (NULL=don't retrieve it) */
  1161. BOOL BASSDEF(BASS_ChannelSetPosition)(DWORD handle, QWORD pos);
  1162. /* Set the current playback position of a channel.
  1163. handle : Channel handle (HCHANNEL/HMUSIC/HSTREAM, or CDCHANNEL)
  1164. pos    : the position
  1165.     if HCHANNEL: position in bytes
  1166.     if HMUSIC: LOWORD=order HIWORD=row ... use MAKELONG(order,row)
  1167.     if HSTREAM: position in bytes, file streams only
  1168.     if CDCHANNEL: position in milliseconds from start of track */
  1170. QWORD BASSDEF(BASS_ChannelGetPosition)(DWORD handle);
  1171. /* Get the current playback position of a channel.
  1172. handle : Channel handle (HCHANNEL/HMUSIC/HSTREAM, or CDCHANNEL)
  1173. RETURN : the position (-1=error)
  1174. if HCHANNEL: position in bytes
  1175. if HMUSIC: LOWORD=order HIWORD=row (see BASS_MusicSetPositionScaler)
  1176. if HSTREAM: total bytes played since the stream was last flushed
  1177. if CDCHANNEL: position in milliseconds from start of track */
  1179. DWORD BASSDEF(BASS_ChannelGetLevel)(DWORD handle);
  1180. /* Calculate a channel's current output level.
  1181. handle : Channel handle (HMUSIC/HSTREAM, or RECORDCHAN)
  1182. RETURN : LOWORD=left level (0-128) HIWORD=right level (0-128) (-1=error) */
  1184. DWORD BASSDEF(BASS_ChannelGetData)(DWORD handle, void *buffer, DWORD length);
  1185. /* Retrieves upto "length" bytes of the channel's current sample data. This is
  1186. useful if you wish to "visualize" the sound.
  1187. handle : Channel handle (HMUSIC/HSTREAM, or RECORDCHAN)
  1188. buffer : Location to write the data
  1189. length : Number of bytes of wanted, or a BASS_DATA_xxx flag
  1190. RETURN : Number of bytes actually written to the buffer (-1=error) */
  1192. HSYNC BASSDEF(BASS_ChannelSetSync)(DWORD handle, DWORD type, QWORD param, SYNCPROC *proc, DWORD user);
  1193. /* Setup a sync on a channel. Multiple syncs may be used per channel.
  1194. handle : Channel handle
  1195. type   : Sync type (BASS_SYNC_xxx type & flags)
  1196. param  : Sync parameters (see the BASS_SYNC_xxx type description)
  1197. proc   : User defined callback function (window message if using BASS_SYNC_MESSAGE flag)
  1198. user   : The 'user' value passed to the callback function
  1199. RETURN : Sync handle (NULL=error) */
  1201. BOOL BASSDEF(BASS_ChannelRemoveSync)(DWORD handle, HSYNC sync);
  1202. /* Remove a sync from a channel
  1203. handle : Channel handle
  1204. sync   : Handle of sync to remove */
  1206. HDSP BASSDEF(BASS_ChannelSetDSP)(DWORD handle, DSPPROC *proc, DWORD user);
  1207. /* Setup a user DSP function on a channel. When multiple DSP functions
  1208. are used on a channel, they are called in the order that they were added.
  1209. handle : Channel handle (HMUSIC/HSTREAM)
  1210. proc   : User defined callback function
  1211. user   : The 'user' value passed to the callback function
  1212. RETURN : DSP handle (NULL=error) */
  1214. BOOL BASSDEF(BASS_ChannelRemoveDSP)(DWORD handle, HDSP dsp);
  1215. /* Remove a DSP function from a channel
  1216. handle : Channel handle (HMUSIC/HSTREAM)
  1217. dsp    : Handle of DSP to remove */
  1219. HFX BASSDEF(BASS_ChannelSetFX)(DWORD handle, DWORD type);
  1220. /* Setup a DX8 effect on a channel. Use BASS_FXSetParameters
  1221. to set the effect parameters. Obviously requires DX8.
  1222. handle : Channel handle (HMUSIC/HSTREAM)
  1223. type   : Type of effect to setup (BASS_FX_xxx)
  1224. RETURN : FX handle (NULL=error) */
  1226. BOOL BASSDEF(BASS_ChannelRemoveFX)(DWORD handle, HFX fx);
  1227. /* Remove a DX8 effect from a channel.
  1228. handle : Channel handle (HMUSIC/HSTREAM)
  1229. fx     : Handle of FX to remove */
  1231. BOOL BASSDEF(BASS_ChannelSetEAXMix)(DWORD handle, float mix);
  1232. /* Set the wet(reverb)/dry(no reverb) mix ratio on the channel. By default
  1233. the distance of the sound from the listener is used to calculate the mix.
  1234. NOTE: The channel must have 3D functionality enabled for the EAX environment
  1235. to have any affect on it.
  1236. handle : Channel handle (HCHANNEL/HSTREAM/HMUSIC)
  1237. mix    : The ratio (0.0=reverb off, 1.0=max reverb, -1.0=let EAX calculate
  1238.          the reverb mix based on the distance) */
  1240. BOOL BASSDEF(BASS_ChannelGetEAXMix)(DWORD handle, float *mix);
  1241. /* Get the wet(reverb)/dry(no reverb) mix ratio on the channel.
  1242. handle : Channel handle (HCHANNEL/HSTREAM/HMUSIC)
  1243. mix    : Pointer to store the ratio at */
  1245. BOOL BASSDEF(BASS_ChannelSetLink)(DWORD handle, DWORD chan);
  1246. /* Set a link between 2 channels. When the 1st is played/stopped/paused/resumed
  1247. the 2nd channel is also played/stopped/paused/resumed.
  1248. handle : Handle of channel to link "chan" to (HMUSIC/HSTREAM)
  1249. chan   : Handle of channel to link to "handle" (HMUSIC/HSTREAM) */
  1251. BOOL BASSDEF(BASS_ChannelRemoveLink)(DWORD handle, DWORD chan);
  1252. /* Remove a link from a channel.
  1253. handle : Handle of channel to unlink with "chan" (HMUSIC/HSTREAM)
  1254. chan   : Handle of channel to unlink from "handle" (HMUSIC/HSTREAM) */
  1257. BOOL BASSDEF(BASS_FXSetParameters)(HFX handle, void *par);
  1258. /* Set the parameters of a DX8 effect.
  1259. handle : FX handle
  1260. par    : Pointer to the parameter structure */
  1262. BOOL BASSDEF(BASS_FXGetParameters)(HFX handle, void *par);
  1263. /* Retrieve the parameters of a DX8 effect.
  1264. handle : FX handle
  1265. par    : Pointer to the parameter structure */
  1267. #ifdef __cplusplus
  1268. }
  1269. #endif
  1271. #endif