local ffi = require "ffi" local bass = ffi.load("bass") if not bass then return nil end -- error ffi.cdef([[ typedef void *PVOID; typedef PVOID HANDLE; typedef HANDLE HWND; typedef uint8_t BYTE; typedef uint16_t WORD; typedef uint32_t DWORD; typedef uint64_t QWORD; typedef int BOOL; typedef struct _GUID { DWORD Data1; WORD Data2; WORD Data3; BYTE Data4[8]; } GUID; typedef DWORD HMUSIC; // MOD music handle typedef DWORD HSAMPLE; // sample handle typedef DWORD HCHANNEL; // playing sample's channel handle typedef DWORD HSTREAM; // sample stream handle typedef DWORD HRECORD; // recording handle typedef DWORD HSYNC; // synchronizer handle typedef DWORD HDSP; // DSP handle typedef DWORD HFX; // DX8 effect handle typedef DWORD HPLUGIN; // Plugin handle typedef struct { const char *name; // description const char *driver; // driver DWORD flags; } BASS_DEVICEINFO; typedef struct { DWORD flags; // device capabilities (DSCAPS_xxx flags) DWORD hwsize; // size of total device hardware memory DWORD hwfree; // size of free device hardware memory DWORD freesam; // number of free sample slots in the hardware DWORD free3d; // number of free 3D sample slots in the hardware DWORD minrate; // min sample rate supported by the hardware DWORD maxrate; // max sample rate supported by the hardware BOOL eax; // device supports EAX? (always FALSE if BASS_DEVICE_3D was not used) DWORD minbuf; // recommended minimum buffer length in ms (requires BASS_DEVICE_LATENCY) DWORD dsver; // DirectSound version DWORD latency; // delay (in ms) before start of playback (requires BASS_DEVICE_LATENCY) DWORD initflags; // BASS_Init "flags" parameter DWORD speakers; // number of speakers available DWORD freq; // current output rate } BASS_INFO; // Recording device info structure typedef struct { DWORD flags; // device capabilities (DSCCAPS_xxx flags) DWORD formats; // supported standard formats (WAVE_FORMAT_xxx flags) DWORD inputs; // number of inputs BOOL singlein; // TRUE = only 1 input can be set at a time DWORD freq; // current input rate } BASS_RECORDINFO; typedef struct { DWORD freq; // default playback rate float volume; // default volume (0-1) float pan; // default pan (-1=left, 0=middle, 1=right) DWORD flags; // BASS_SAMPLE_xxx flags DWORD length; // length (in bytes) DWORD max; // maximum simultaneous playbacks DWORD origres; // original resolution bits DWORD chans; // number of channels DWORD mingap; // minimum gap (ms) between creating channels DWORD mode3d; // BASS_3DMODE_xxx mode float mindist; // minimum distance float maxdist; // maximum distance DWORD iangle; // angle of inside projection cone DWORD oangle; // angle of outside projection cone float outvol; // delta-volume outside the projection cone DWORD vam; // voice allocation/management flags (BASS_VAM_xxx) DWORD priority; // priority (0=lowest, 0xffffffff=highest) } BASS_SAMPLE; typedef struct { DWORD freq; // default playback rate DWORD chans; // channels DWORD flags; // BASS_SAMPLE/STREAM/MUSIC/SPEAKER flags DWORD ctype; // type of channel DWORD origres; // original resolution HPLUGIN plugin; // plugin HSAMPLE sample; // sample const char *filename; // filename } BASS_CHANNELINFO; typedef struct { DWORD ctype; // channel type const char *name; // format description const char *exts; // file extension filter (*.ext1;*.ext2;etc...) } BASS_PLUGINFORM; typedef struct { DWORD version; // version (same form as BASS_GetVersion) DWORD formatc; // number of formats const BASS_PLUGINFORM *formats; // the array of formats } BASS_PLUGININFO; // 3D vector (for 3D positions/velocities/orientations) typedef struct BASS_3DVECTOR { float x; // +=right, -=left float y; // +=up, -=down float z; // +=front, -=behind } BASS_3DVECTOR; enum { EAX_ENVIRONMENT_GENERIC, EAX_ENVIRONMENT_PADDEDCELL, EAX_ENVIRONMENT_ROOM, EAX_ENVIRONMENT_BATHROOM, EAX_ENVIRONMENT_LIVINGROOM, EAX_ENVIRONMENT_STONEROOM, EAX_ENVIRONMENT_AUDITORIUM, EAX_ENVIRONMENT_CONCERTHALL, EAX_ENVIRONMENT_CAVE, EAX_ENVIRONMENT_ARENA, EAX_ENVIRONMENT_HANGAR, EAX_ENVIRONMENT_CARPETEDHALLWAY, EAX_ENVIRONMENT_HALLWAY, EAX_ENVIRONMENT_STONECORRIDOR, EAX_ENVIRONMENT_ALLEY, EAX_ENVIRONMENT_FOREST, EAX_ENVIRONMENT_CITY, EAX_ENVIRONMENT_MOUNTAINS, EAX_ENVIRONMENT_QUARRY, EAX_ENVIRONMENT_PLAIN, EAX_ENVIRONMENT_PARKINGLOT, EAX_ENVIRONMENT_SEWERPIPE, EAX_ENVIRONMENT_UNDERWATER, EAX_ENVIRONMENT_DRUGGED, EAX_ENVIRONMENT_DIZZY, EAX_ENVIRONMENT_PSYCHOTIC, EAX_ENVIRONMENT_COUNT // total number of environments }; typedef DWORD (__stdcall STREAMPROC)(HSTREAM handle, void *buffer, DWORD length, void *user); /* User stream callback function. NOTE: A stream function should obviously be as quick as possible, other streams (and MOD musics) can't be mixed until it's finished. handle : The stream that needs writing buffer : Buffer to write the samples in length : Number of bytes to write user : The 'user' parameter value given when calling BASS_StreamCreate RETURN : Number of bytes written. Set the BASS_STREAMPROC_END flag to end the stream. */ // User file stream callback functions typedef void (__stdcall FILECLOSEPROC)(void *user); typedef QWORD (__stdcall FILELENPROC)(void *user); typedef DWORD (__stdcall FILEREADPROC)(void *buffer, DWORD length, void *user); typedef BOOL (__stdcall FILESEEKPROC)(QWORD offset, void *user); typedef struct { FILECLOSEPROC *close; FILELENPROC *length; FILEREADPROC *read; FILESEEKPROC *seek; } BASS_FILEPROCS; typedef void (__stdcall DOWNLOADPROC)(const void *buffer, DWORD length, void *user); typedef void (__stdcall SYNCPROC)(HSYNC handle, DWORD channel, DWORD data, void *user); /* Sync callback function. NOTE: a sync callback function should be very quick as other syncs can't be processed until it has finished. If the sync is a "mixtime" sync, then other streams and MOD musics can't be mixed until it's finished either. handle : The sync that has occured channel: Channel that the sync occured in data : Additional data associated with the sync's occurance user : The 'user' parameter given when calling BASS_ChannelSetSync */ typedef void (__stdcall DSPPROC)(HDSP handle, DWORD channel, void *buffer, DWORD length, void *user); /* DSP callback function. NOTE: A DSP function should obviously be as quick as possible... other DSP functions, streams and MOD musics can not be processed until it's finished. handle : The DSP handle channel: Channel that the DSP is being applied to buffer : Buffer to apply the DSP to length : Number of bytes in the buffer user : The 'user' parameter given when calling BASS_ChannelSetDSP */ typedef BOOL (__stdcall RECORDPROC)(HRECORD handle, const void *buffer, DWORD length, void *user); /* Recording callback function. handle : The recording handle buffer : Buffer containing the recorded sample data length : Number of bytes user : The 'user' parameter value given when calling BASS_RecordStart RETURN : TRUE = continue recording, FALSE = stop */ // ID3v1 tag structure typedef struct { char id[3]; char title[30]; char artist[30]; char album[30]; char year[4]; char comment[30]; BYTE genre; } TAG_ID3; // Binary APE tag structure typedef struct { const char *key; const void *data; DWORD length; } TAG_APE_BINARY; #pragma pack(push,1) typedef struct { char Description[256]; // description char Originator[32]; // name of the originator char OriginatorReference[32]; // reference of the originator char OriginationDate[10]; // date of creation (yyyy-mm-dd) char OriginationTime[8]; // time of creation (hh-mm-ss) QWORD TimeReference; // first sample count since midnight (little-endian) WORD Version; // BWF version (little-endian) BYTE UMID[64]; // SMPTE UMID BYTE Reserved[190]; char CodingHistory[1]; // history } TAG_BEXT; #pragma pack(pop) // BWF "cart" tag structures typedef struct { DWORD dwUsage; // FOURCC timer usage ID DWORD dwValue; // timer value in samples from head } TAG_CART_TIMER; typedef struct { char Version[4]; // version of the data structure char Title[64]; // title of cart audio sequence char Artist[64]; // artist or creator name char CutID[64]; // cut number identification char ClientID[64]; // client identification char Category[64]; // category ID, PSA, NEWS, etc char Classification[64]; // classification or auxiliary key char OutCue[64]; // out cue text char StartDate[10]; // yyyy-mm-dd char StartTime[8]; // hh:mm:ss char EndDate[10]; // yyyy-mm-dd char EndTime[8]; // hh:mm:ss char ProducerAppID[64]; // name of vendor or application char ProducerAppVersion[64]; // version of producer application char UserDef[64]; // user defined text DWORD dwLevelReference; // sample value for 0 dB reference TAG_CART_TIMER PostTimer[8]; // 8 time markers after head char Reserved[276]; char URL[1024]; // uniform resource locator char TagText[1]; // free form text for scripts or tags } TAG_CART; // CoreAudio codec info structure typedef struct { DWORD ftype; // file format DWORD atype; // audio format const char *name; // description } TAG_CA_CODEC; BOOL __stdcall(BASS_SetConfig)(DWORD option, DWORD value); DWORD __stdcall(BASS_GetConfig)(DWORD option); BOOL __stdcall(BASS_SetConfigPtr)(DWORD option, const void *value); void *__stdcall(BASS_GetConfigPtr)(DWORD option); DWORD __stdcall(BASS_GetVersion)(); int __stdcall(BASS_ErrorGetCode)(); BOOL __stdcall(BASS_GetDeviceInfo)(DWORD device, BASS_DEVICEINFO *info); BOOL __stdcall(BASS_Init)(int device, DWORD freq, DWORD flags, HWND win, const GUID *dsguid); BOOL __stdcall(BASS_SetDevice)(DWORD device); DWORD __stdcall(BASS_GetDevice)(); BOOL __stdcall(BASS_Free)(); void *__stdcall(BASS_GetDSoundObject)(DWORD object); BOOL __stdcall(BASS_GetInfo)(BASS_INFO *info); BOOL __stdcall(BASS_Update)(DWORD length); float __stdcall(BASS_GetCPU)(); BOOL __stdcall(BASS_Start)(); BOOL __stdcall(BASS_Stop)(); BOOL __stdcall(BASS_Pause)(); BOOL __stdcall(BASS_SetVolume)(float volume); float __stdcall(BASS_GetVolume)(); HPLUGIN __stdcall(BASS_PluginLoad)(const char *file, DWORD flags); BOOL __stdcall(BASS_PluginFree)(HPLUGIN handle); const BASS_PLUGININFO *__stdcall(BASS_PluginGetInfo)(HPLUGIN handle); BOOL __stdcall(BASS_Set3DFactors)(float distf, float rollf, float doppf); BOOL __stdcall(BASS_Get3DFactors)(float *distf, float *rollf, float *doppf); BOOL __stdcall(BASS_Set3DPosition)(const BASS_3DVECTOR *pos, const BASS_3DVECTOR *vel, const BASS_3DVECTOR *front, const BASS_3DVECTOR *top); BOOL __stdcall(BASS_Get3DPosition)(BASS_3DVECTOR *pos, BASS_3DVECTOR *vel, BASS_3DVECTOR *front, BASS_3DVECTOR *top); void __stdcall(BASS_Apply3D)(); BOOL __stdcall(BASS_SetEAXParameters)(int env, float vol, float decay, float damp); BOOL __stdcall(BASS_GetEAXParameters)(DWORD *env, float *vol, float *decay, float *damp); HMUSIC __stdcall(BASS_MusicLoad)(BOOL mem, const void *file, QWORD offset, DWORD length, DWORD flags, DWORD freq); BOOL __stdcall(BASS_MusicFree)(HMUSIC handle); HSAMPLE __stdcall(BASS_SampleLoad)(BOOL mem, const void *file, QWORD offset, DWORD length, DWORD max, DWORD flags); HSAMPLE __stdcall(BASS_SampleCreate)(DWORD length, DWORD freq, DWORD chans, DWORD max, DWORD flags); BOOL __stdcall(BASS_SampleFree)(HSAMPLE handle); BOOL __stdcall(BASS_SampleSetData)(HSAMPLE handle, const void *buffer); BOOL __stdcall(BASS_SampleGetData)(HSAMPLE handle, void *buffer); BOOL __stdcall(BASS_SampleGetInfo)(HSAMPLE handle, BASS_SAMPLE *info); BOOL __stdcall(BASS_SampleSetInfo)(HSAMPLE handle, const BASS_SAMPLE *info); HCHANNEL __stdcall(BASS_SampleGetChannel)(HSAMPLE handle, BOOL onlynew); DWORD __stdcall(BASS_SampleGetChannels)(HSAMPLE handle, HCHANNEL *channels); BOOL __stdcall(BASS_SampleStop)(HSAMPLE handle); HSTREAM __stdcall(BASS_StreamCreate)(DWORD freq, DWORD chans, DWORD flags, STREAMPROC *proc, void *user); HSTREAM __stdcall(BASS_StreamCreateFile)(BOOL mem, const void *file, QWORD offset, QWORD length, DWORD flags); HSTREAM __stdcall(BASS_StreamCreateURL)(const char *url, DWORD offset, DWORD flags, DOWNLOADPROC *proc, void *user); HSTREAM __stdcall(BASS_StreamCreateFileUser)(DWORD system, DWORD flags, const BASS_FILEPROCS *proc, void *user); BOOL __stdcall(BASS_StreamFree)(HSTREAM handle); QWORD __stdcall(BASS_StreamGetFilePosition)(HSTREAM handle, DWORD mode); DWORD __stdcall(BASS_StreamPutData)(HSTREAM handle, const void *buffer, DWORD length); DWORD __stdcall(BASS_StreamPutFileData)(HSTREAM handle, const void *buffer, DWORD length); BOOL __stdcall(BASS_RecordGetDeviceInfo)(DWORD device, BASS_DEVICEINFO *info); BOOL __stdcall(BASS_RecordInit)(int device); BOOL __stdcall(BASS_RecordSetDevice)(DWORD device); DWORD __stdcall(BASS_RecordGetDevice)(); BOOL __stdcall(BASS_RecordFree)(); BOOL __stdcall(BASS_RecordGetInfo)(BASS_RECORDINFO *info); const char *__stdcall(BASS_RecordGetInputName)(int input); BOOL __stdcall(BASS_RecordSetInput)(int input, DWORD flags, float volume); DWORD __stdcall(BASS_RecordGetInput)(int input, float *volume); HRECORD __stdcall(BASS_RecordStart)(DWORD freq, DWORD chans, DWORD flags, RECORDPROC *proc, void *user); double __stdcall(BASS_ChannelBytes2Seconds)(DWORD handle, QWORD pos); QWORD __stdcall(BASS_ChannelSeconds2Bytes)(DWORD handle, double pos); DWORD __stdcall(BASS_ChannelGetDevice)(DWORD handle); BOOL __stdcall(BASS_ChannelSetDevice)(DWORD handle, DWORD device); DWORD __stdcall(BASS_ChannelIsActive)(DWORD handle); BOOL __stdcall(BASS_ChannelGetInfo)(DWORD handle, BASS_CHANNELINFO *info); const char *__stdcall(BASS_ChannelGetTags)(DWORD handle, DWORD tags); DWORD __stdcall(BASS_ChannelFlags)(DWORD handle, DWORD flags, DWORD mask); BOOL __stdcall(BASS_ChannelUpdate)(DWORD handle, DWORD length); BOOL __stdcall(BASS_ChannelLock)(DWORD handle, BOOL lock); BOOL __stdcall(BASS_ChannelPlay)(DWORD handle, BOOL restart); BOOL __stdcall(BASS_ChannelStop)(DWORD handle); BOOL __stdcall(BASS_ChannelPause)(DWORD handle); BOOL __stdcall(BASS_ChannelSetAttribute)(DWORD handle, DWORD attrib, float value); BOOL __stdcall(BASS_ChannelGetAttribute)(DWORD handle, DWORD attrib, float *value); BOOL __stdcall(BASS_ChannelSlideAttribute)(DWORD handle, DWORD attrib, float value, DWORD time); BOOL __stdcall(BASS_ChannelIsSliding)(DWORD handle, DWORD attrib); BOOL __stdcall(BASS_ChannelSetAttributeEx)(DWORD handle, DWORD attrib, void *value, DWORD size); DWORD __stdcall(BASS_ChannelGetAttributeEx)(DWORD handle, DWORD attrib, void *value, DWORD size); BOOL __stdcall(BASS_ChannelSet3DAttributes)(DWORD handle, int mode, float min, float max, int iangle, int oangle, float outvol); BOOL __stdcall(BASS_ChannelGet3DAttributes)(DWORD handle, DWORD *mode, float *min, float *max, DWORD *iangle, DWORD *oangle, float *outvol); BOOL __stdcall(BASS_ChannelSet3DPosition)(DWORD handle, const BASS_3DVECTOR *pos, const BASS_3DVECTOR *orient, const BASS_3DVECTOR *vel); BOOL __stdcall(BASS_ChannelGet3DPosition)(DWORD handle, BASS_3DVECTOR *pos, BASS_3DVECTOR *orient, BASS_3DVECTOR *vel); QWORD __stdcall(BASS_ChannelGetLength)(DWORD handle, DWORD mode); BOOL __stdcall(BASS_ChannelSetPosition)(DWORD handle, QWORD pos, DWORD mode); QWORD __stdcall(BASS_ChannelGetPosition)(DWORD handle, DWORD mode); DWORD __stdcall(BASS_ChannelGetLevel)(DWORD handle); BOOL __stdcall(BASS_ChannelGetLevelEx)(DWORD handle, float *levels, float length, DWORD flags); DWORD __stdcall(BASS_ChannelGetData)(DWORD handle, void *buffer, DWORD length); HSYNC __stdcall(BASS_ChannelSetSync)(DWORD handle, DWORD type, QWORD param, SYNCPROC *proc, void *user); BOOL __stdcall(BASS_ChannelRemoveSync)(DWORD handle, HSYNC sync); HDSP __stdcall(BASS_ChannelSetDSP)(DWORD handle, DSPPROC *proc, void *user, int priority); BOOL __stdcall(BASS_ChannelRemoveDSP)(DWORD handle, HDSP dsp); BOOL __stdcall(BASS_ChannelSetLink)(DWORD handle, DWORD chan); BOOL __stdcall(BASS_ChannelRemoveLink)(DWORD handle, DWORD chan); HFX __stdcall(BASS_ChannelSetFX)(DWORD handle, DWORD type, int priority); BOOL __stdcall(BASS_ChannelRemoveFX)(DWORD handle, HFX fx); BOOL __stdcall(BASS_FXSetParameters)(HFX handle, const void *params); BOOL __stdcall(BASS_FXGetParameters)(HFX handle, void *params); BOOL __stdcall(BASS_FXReset)(HFX handle); ]]) BASS_OK = 0 -- all is OK BASS_ERROR_MEM = 1 -- memory error BASS_ERROR_FILEOPEN = 2 -- can't open the file BASS_ERROR_DRIVER = 3 -- can't find a free/valid driver BASS_ERROR_BUFLOST = 4 -- the sample buffer was lost BASS_ERROR_HANDLE = 5 -- invalid handle BASS_ERROR_FORMAT = 6 -- unsupported sample format BASS_ERROR_POSITION = 7 -- invalid position BASS_ERROR_INIT = 8 -- BASS_Init has not been successfully called BASS_ERROR_START = 9 -- BASS_Start has not been successfully called BASS_ERROR_SSL = 10 -- SSL/HTTPS support isn't available BASS_ERROR_ALREADY = 14 -- already initialized/paused/whatever BASS_ERROR_NOCHAN = 18 -- can't get a free channel BASS_ERROR_ILLTYPE = 19 -- an illegal type was specified BASS_ERROR_ILLPARAM = 20 -- an illegal parameter was specified BASS_ERROR_NO3D = 21 -- no 3D support BASS_ERROR_NOEAX = 22 -- no EAX support BASS_ERROR_DEVICE = 23 -- illegal device number BASS_ERROR_NOPLAY = 24 -- not playing BASS_ERROR_FREQ = 25 -- illegal sample rate BASS_ERROR_NOTFILE = 27 -- the stream is not a file stream BASS_ERROR_NOHW = 29 -- no hardware voices available BASS_ERROR_EMPTY = 31 -- the MOD music has no sequence data BASS_ERROR_NONET = 32 -- no internet connection could be opened BASS_ERROR_CREATE = 33 -- couldn't create the file BASS_ERROR_NOFX = 34 -- effects are not available BASS_ERROR_NOTAVAIL = 37 -- requested data is not available BASS_ERROR_DECODE = 38 -- the channel is/isn't a "decoding channel" BASS_ERROR_DX = 39 -- a sufficient DirectX version is not installed BASS_ERROR_TIMEOUT = 40 -- connection timedout BASS_ERROR_FILEFORM = 41 -- unsupported file format BASS_ERROR_SPEAKER = 42 -- unavailable speaker BASS_ERROR_VERSION = 43 -- invalid BASS version (used by add-ons) BASS_ERROR_CODEC = 44 -- codec is not available/supported BASS_ERROR_ENDED = 45 -- the channel/file has ended BASS_ERROR_BUSY = 46 -- the device is busy BASS_ERROR_UNKNOWN = -1 -- some other mystery problem BASS_CONFIG_BUFFER = 0 BASS_CONFIG_UPDATEPERIOD = 1 BASS_CONFIG_GVOL_SAMPLE = 4 BASS_CONFIG_GVOL_STREAM = 5 BASS_CONFIG_GVOL_MUSIC = 6 BASS_CONFIG_CURVE_VOL = 7 BASS_CONFIG_CURVE_PAN = 8 BASS_CONFIG_FLOATDSP = 9 BASS_CONFIG_3DALGORITHM = 10 BASS_CONFIG_NET_TIMEOUT = 11 BASS_CONFIG_NET_BUFFER = 12 BASS_CONFIG_PAUSE_NOPLAY = 13 BASS_CONFIG_NET_PREBUF = 15 BASS_CONFIG_NET_PASSIVE = 18 BASS_CONFIG_REC_BUFFER = 19 BASS_CONFIG_NET_PLAYLIST = 21 BASS_CONFIG_MUSIC_VIRTUAL = 22 BASS_CONFIG_VERIFY = 23 BASS_CONFIG_UPDATETHREADS = 24 BASS_CONFIG_DEV_BUFFER = 27 BASS_CONFIG_VISTA_TRUEPOS = 30 BASS_CONFIG_IOS_MIXAUDIO = 34 BASS_CONFIG_DEV_DEFAULT = 36 BASS_CONFIG_NET_READTIMEOUT = 37 BASS_CONFIG_VISTA_SPEAKERS = 38 BASS_CONFIG_IOS_SPEAKER = 39 BASS_CONFIG_MF_DISABLE = 40 BASS_CONFIG_HANDLES = 41 BASS_CONFIG_UNICODE = 42 BASS_CONFIG_SRC = 43 BASS_CONFIG_SRC_SAMPLE = 44 BASS_CONFIG_ASYNCFILE_BUFFER = 45 BASS_CONFIG_OGG_PRESCAN = 47 BASS_CONFIG_MF_VIDEO = 48 BASS_CONFIG_AIRPLAY = 49 BASS_CONFIG_DEV_NONSTOP = 50 BASS_CONFIG_IOS_NOCATEGORY = 51 BASS_CONFIG_VERIFY_NET = 52 BASS_CONFIG_NET_AGENT = 16 BASS_CONFIG_NET_PROXY = 17 BASS_CONFIG_IOS_NOTIFY = 46 BASS_DEVICE_8BITS = 1 -- 8 bit resolution, else 16 bit BASS_DEVICE_MONO = 2 -- mono, else stereo BASS_DEVICE_3D = 4 -- enable 3D functionality BASS_DEVICE_LATENCY = 0x100 -- calculate device latency (BASS_INFO struct) BASS_DEVICE_CPSPEAKERS = 0x400 -- detect speakers via Windows control panel BASS_DEVICE_SPEAKERS = 0x800 -- force enabling of speaker assignment BASS_DEVICE_NOSPEAKER = 0x1000 -- ignore speaker arrangement BASS_DEVICE_DMIX = 0x2000 -- use ALSA "dmix" plugin BASS_DEVICE_FREQ = 0x4000 -- set device sample rate BASS_OBJECT_DS = 1 -- IDirectSound BASS_OBJECT_DS3DL = 2 -- IDirectSound3DListener BASS_DEVICE_ENABLED = 1 BASS_DEVICE_DEFAULT = 2 BASS_DEVICE_INIT = 4 BASS_DEVICE_TYPE_MASK = 0xff000000 BASS_DEVICE_TYPE_NETWORK = 0x01000000 BASS_DEVICE_TYPE_SPEAKERS = 0x02000000 BASS_DEVICE_TYPE_LINE = 0x03000000 BASS_DEVICE_TYPE_HEADPHONES = 0x04000000 BASS_DEVICE_TYPE_MICROPHONE = 0x05000000 BASS_DEVICE_TYPE_HEADSET = 0x06000000 BASS_DEVICE_TYPE_HANDSET = 0x07000000 BASS_DEVICE_TYPE_DIGITAL = 0x08000000 BASS_DEVICE_TYPE_SPDIF = 0x09000000 BASS_DEVICE_TYPE_HDMI = 0x0a000000 BASS_DEVICE_TYPE_DISPLAYPORT = 0x40000000 BASS_DEVICES_AIRPLAY = 0x1000000 DSCAPS_CONTINUOUSRATE = 0x00000010 -- supports all sample rates between min/maxrate DSCAPS_EMULDRIVER = 0x00000020 -- device does NOT have hardware DirectSound support DSCAPS_CERTIFIED = 0x00000040 -- device driver has been certified by Microsoft DSCAPS_SECONDARYMONO = 0x00000100 -- mono DSCAPS_SECONDARYSTEREO = 0x00000200 -- stereo DSCAPS_SECONDARY8BIT = 0x00000400 -- 8 bit DSCAPS_SECONDARY16BIT = 0x00000800 -- 16 bit DSCCAPS_EMULDRIVER = DSCAPS_EMULDRIVER -- device does NOT have hardware DirectSound recording support DSCCAPS_CERTIFIED = DSCAPS_CERTIFIED -- device driver has been certified by Microsoft WAVE_FORMAT_1M08 = 0x00000001 -- 11.025 kHz, Mono, 8-bit */ WAVE_FORMAT_1S08 = 0x00000002 -- 11.025 kHz, Stereo, 8-bit */ WAVE_FORMAT_1M16 = 0x00000004 -- 11.025 kHz, Mono, 16-bit */ WAVE_FORMAT_1S16 = 0x00000008 -- 11.025 kHz, Stereo, 16-bit */ WAVE_FORMAT_2M08 = 0x00000010 -- 22.05 kHz, Mono, 8-bit */ WAVE_FORMAT_2S08 = 0x00000020 -- 22.05 kHz, Stereo, 8-bit */ WAVE_FORMAT_2M16 = 0x00000040 -- 22.05 kHz, Mono, 16-bit */ WAVE_FORMAT_2S16 = 0x00000080 -- 22.05 kHz, Stereo, 16-bit */ WAVE_FORMAT_4M08 = 0x00000100 -- 44.1 kHz, Mono, 8-bit */ WAVE_FORMAT_4S08 = 0x00000200 -- 44.1 kHz, Stereo, 8-bit */ WAVE_FORMAT_4M16 = 0x00000400 -- 44.1 kHz, Mono, 16-bit */ WAVE_FORMAT_4S16 = 0x00000800 -- 44.1 kHz, Stereo, 16-bit */ BASS_SAMPLE_8BITS = 1 -- 8 bit BASS_SAMPLE_FLOAT = 256 -- 32-bit floating-point BASS_SAMPLE_MONO = 2 -- mono BASS_SAMPLE_LOOP = 4 -- looped BASS_SAMPLE_3D = 8 -- 3D functionality BASS_SAMPLE_SOFTWARE = 16 -- not using hardware mixing BASS_SAMPLE_MUTEMAX = 32 -- mute at max distance (3D only) BASS_SAMPLE_VAM = 64 -- DX7 voice allocation & management BASS_SAMPLE_FX = 128 -- old implementation of DX8 effects BASS_SAMPLE_OVER_VOL = 0x10000 -- override lowest volume BASS_SAMPLE_OVER_POS = 0x20000 -- override longest playing BASS_SAMPLE_OVER_DIST = 0x30000 -- override furthest from listener (3D only) BASS_STREAM_PRESCAN = 0x20000 -- enable pin-point seeking/length (MP3/MP2/MP1) BASS_MP3_SETPOS = BASS_STREAM_PRESCAN BASS_STREAM_AUTOFREE = 0x40000 -- automatically free the stream when it stop/ends BASS_STREAM_RESTRATE = 0x80000 -- restrict the download rate of internet file streams BASS_STREAM_BLOCK = 0x100000 -- download/play internet file stream in small blocks BASS_STREAM_DECODE = 0x200000 -- don't play the stream, only decode (BASS_ChannelGetData) BASS_STREAM_STATUS = 0x800000 -- give server status info (HTTP/ICY tags) in DOWNLOADPROC BASS_MUSIC_FLOAT = BASS_SAMPLE_FLOAT BASS_MUSIC_MONO = BASS_SAMPLE_MONO BASS_MUSIC_LOOP = BASS_SAMPLE_LOOP BASS_MUSIC_3D = BASS_SAMPLE_3D BASS_MUSIC_FX = BASS_SAMPLE_FX BASS_MUSIC_AUTOFREE = BASS_STREAM_AUTOFREE BASS_MUSIC_DECODE = BASS_STREAM_DECODE BASS_MUSIC_PRESCAN = BASS_STREAM_PRESCAN -- calculate playback length BASS_MUSIC_CALCLEN = BASS_MUSIC_PRESCAN BASS_MUSIC_RAMP = 0x200 -- normal ramping BASS_MUSIC_RAMPS = 0x400 -- sensitive ramping BASS_MUSIC_SURROUND = 0x800 -- surround sound BASS_MUSIC_SURROUND2 = 0x1000 -- surround sound (mode 2) BASS_MUSIC_FT2MOD = 0x2000 -- play .MOD as FastTracker 2 does BASS_MUSIC_PT1MOD = 0x4000 -- play .MOD as ProTracker 1 does BASS_MUSIC_NONINTER = 0x10000 -- non-interpolated sample mixing BASS_MUSIC_SINCINTER = 0x800000 -- sinc interpolated sample mixing BASS_MUSIC_POSRESET = 0x8000 -- stop all notes when moving position BASS_MUSIC_POSRESETEX = 0x400000 -- stop all notes and reset bmp/etc when moving position BASS_MUSIC_STOPBACK = 0x80000 -- stop the music on a backwards jump effect BASS_MUSIC_NOSAMPLE = 0x100000 -- don't load the samples BASS_SPEAKER_FRONT = 0x1000000 -- front speakers BASS_SPEAKER_REAR = 0x2000000 -- rear/side speakers BASS_SPEAKER_CENLFE = 0x3000000 -- center & LFE speakers (5.1) BASS_SPEAKER_REAR2 = 0x4000000 -- rear center speakers (7.1) --BASS_SPEAKER_N(n) ((n)<<24) -- n'th pair of speakers (max 15) BASS_SPEAKER_LEFT = 0x10000000 -- modifier: left BASS_SPEAKER_RIGHT = 0x20000000 -- modifier: right BASS_SPEAKER_FRONTLEFT = bit.bor(BASS_SPEAKER_FRONT, BASS_SPEAKER_LEFT) BASS_SPEAKER_FRONTRIGHT = bit.bor(BASS_SPEAKER_FRONT, BASS_SPEAKER_RIGHT) BASS_SPEAKER_REARLEFT = bit.bor(BASS_SPEAKER_REAR, BASS_SPEAKER_LEFT) BASS_SPEAKER_REARRIGHT = bit.bor(BASS_SPEAKER_REAR, BASS_SPEAKER_RIGHT) BASS_SPEAKER_CENTER = bit.bor(BASS_SPEAKER_CENLFE, BASS_SPEAKER_LEFT) BASS_SPEAKER_LFE = bit.bor(BASS_SPEAKER_CENLFE, BASS_SPEAKER_RIGHT) BASS_SPEAKER_REAR2LEFT = bit.bor(BASS_SPEAKER_REAR2, BASS_SPEAKER_LEFT) BASS_SPEAKER_REAR2RIGHT = bit.bor(BASS_SPEAKER_REAR2, BASS_SPEAKER_RIGHT) BASS_ASYNCFILE = 0x40000000 BASS_UNICODE = 0x80000000 BASS_RECORD_PAUSE = 0x8000 -- start recording paused BASS_RECORD_ECHOCANCEL = 0x2000 BASS_RECORD_AGC = 0x4000 BASS_VAM_HARDWARE = 1 BASS_VAM_SOFTWARE = 2 BASS_VAM_TERM_TIME = 4 BASS_VAM_TERM_DIST = 8 BASS_VAM_TERM_PRIO = 16 BASS_CTYPE_SAMPLE = 1 BASS_CTYPE_RECORD = 2 BASS_CTYPE_STREAM = 0x10000 BASS_CTYPE_STREAM_OGG = 0x10002 BASS_CTYPE_STREAM_MP1 = 0x10003 BASS_CTYPE_STREAM_MP2 = 0x10004 BASS_CTYPE_STREAM_MP3 = 0x10005 BASS_CTYPE_STREAM_AIFF = 0x10006 BASS_CTYPE_STREAM_CA = 0x10007 BASS_CTYPE_STREAM_MF = 0x10008 BASS_CTYPE_STREAM_WAV = 0x40000 -- WAVE flag, LOWORD=codec BASS_CTYPE_STREAM_WAV_PCM = 0x50001 BASS_CTYPE_STREAM_WAV_FLOAT = 0x50003 BASS_CTYPE_MUSIC_MOD = 0x20000 BASS_CTYPE_MUSIC_MTM = 0x20001 BASS_CTYPE_MUSIC_S3M = 0x20002 BASS_CTYPE_MUSIC_XM = 0x20003 BASS_CTYPE_MUSIC_IT = 0x20004 BASS_CTYPE_MUSIC_MO3 = 0x00100 -- MO3 flag BASS_3DMODE_NORMAL = 0 -- normal 3D processing BASS_3DMODE_RELATIVE = 1 -- position is relative to the listener BASS_3DMODE_OFF = 2 -- no 3D processing BASS_3DALG_DEFAULT = 0 BASS_3DALG_OFF = 1 BASS_3DALG_FULL = 2 BASS_3DALG_LIGHT = 3 --[[EAX_PRESET_GENERIC EAX_ENVIRONMENT_GENERIC,0.5F,1.493F,0.5F EAX_PRESET_PADDEDCELL EAX_ENVIRONMENT_PADDEDCELL,0.25F,0.1F,0.0F EAX_PRESET_ROOM EAX_ENVIRONMENT_ROOM,0.417F,0.4F,0.666F EAX_PRESET_BATHROOM EAX_ENVIRONMENT_BATHROOM,0.653F,1.499F,0.166F EAX_PRESET_LIVINGROOM EAX_ENVIRONMENT_LIVINGROOM,0.208F,0.478F,0.0F EAX_PRESET_STONEROOM EAX_ENVIRONMENT_STONEROOM,0.5F,2.309F,0.888F EAX_PRESET_AUDITORIUM EAX_ENVIRONMENT_AUDITORIUM,0.403F,4.279F,0.5F EAX_PRESET_CONCERTHALL EAX_ENVIRONMENT_CONCERTHALL,0.5F,3.961F,0.5F EAX_PRESET_CAVE EAX_ENVIRONMENT_CAVE,0.5F,2.886F,1.304F EAX_PRESET_ARENA EAX_ENVIRONMENT_ARENA,0.361F,7.284F,0.332F EAX_PRESET_HANGAR EAX_ENVIRONMENT_HANGAR,0.5F,10.0F,0.3F EAX_PRESET_CARPETEDHALLWAY EAX_ENVIRONMENT_CARPETEDHALLWAY,0.153F,0.259F,2.0F EAX_PRESET_HALLWAY EAX_ENVIRONMENT_HALLWAY,0.361F,1.493F,0.0F EAX_PRESET_STONECORRIDOR EAX_ENVIRONMENT_STONECORRIDOR,0.444F,2.697F,0.638F EAX_PRESET_ALLEY EAX_ENVIRONMENT_ALLEY,0.25F,1.752F,0.776F EAX_PRESET_FOREST EAX_ENVIRONMENT_FOREST,0.111F,3.145F,0.472F EAX_PRESET_CITY EAX_ENVIRONMENT_CITY,0.111F,2.767F,0.224F EAX_PRESET_MOUNTAINS EAX_ENVIRONMENT_MOUNTAINS,0.194F,7.841F,0.472F EAX_PRESET_QUARRY EAX_ENVIRONMENT_QUARRY,1.0F,1.499F,0.5F EAX_PRESET_PLAIN EAX_ENVIRONMENT_PLAIN,0.097F,2.767F,0.224F EAX_PRESET_PARKINGLOT EAX_ENVIRONMENT_PARKINGLOT,0.208F,1.652F,1.5F EAX_PRESET_SEWERPIPE EAX_ENVIRONMENT_SEWERPIPE,0.652F,2.886F,0.25F EAX_PRESET_UNDERWATER EAX_ENVIRONMENT_UNDERWATER,1.0F,1.499F,0.0F EAX_PRESET_DRUGGED EAX_ENVIRONMENT_DRUGGED,0.875F,8.392F,1.388F EAX_PRESET_DIZZY EAX_ENVIRONMENT_DIZZY,0.139F,17.234F,0.666F EAX_PRESET_PSYCHOTIC EAX_ENVIRONMENT_PSYCHOTIC,0.486F,7.563F,0.806F]] BASS_STREAMPROC_END = 0x80000000 -- end of user stream flag --[[STREAMPROC_DUMMY (STREAMPROC*)0 -- "dummy" stream STREAMPROC_PUSH (STREAMPROC*)-1 -- push stream]] STREAMFILE_NOBUFFER = 0 STREAMFILE_BUFFER = 1 STREAMFILE_BUFFERPUSH = 2 BASS_FILEDATA_END = 0 -- end & close the file BASS_FILEPOS_CURRENT = 0 BASS_FILEPOS_DECODE = BASS_FILEPOS_CURRENT BASS_FILEPOS_DOWNLOAD = 1 BASS_FILEPOS_END = 2 BASS_FILEPOS_START = 3 BASS_FILEPOS_CONNECTED = 4 BASS_FILEPOS_BUFFER = 5 BASS_FILEPOS_SOCKET = 6 BASS_FILEPOS_ASYNCBUF = 7 BASS_FILEPOS_SIZE = 8 BASS_SYNC_POS = 0 BASS_SYNC_END = 2 BASS_SYNC_META = 4 BASS_SYNC_SLIDE = 5 BASS_SYNC_STALL = 6 BASS_SYNC_DOWNLOAD = 7 BASS_SYNC_FREE = 8 BASS_SYNC_SETPOS = 11 BASS_SYNC_MUSICPOS = 10 BASS_SYNC_MUSICINST = 1 BASS_SYNC_MUSICFX = 3 BASS_SYNC_OGG_CHANGE = 12 BASS_SYNC_MIXTIME = 0x40000000 -- FLAG: sync at mixtime, else at playtime BASS_SYNC_ONETIME = 0x80000000 -- FLAG: sync only once, else continuously BASS_ACTIVE_STOPPED = 0 BASS_ACTIVE_PLAYING = 1 BASS_ACTIVE_STALLED = 2 BASS_ACTIVE_PAUSED = 3 BASS_ATTRIB_FREQ = 1 BASS_ATTRIB_VOL = 2 BASS_ATTRIB_PAN = 3 BASS_ATTRIB_EAXMIX = 4 BASS_ATTRIB_NOBUFFER = 5 BASS_ATTRIB_VBR = 6 BASS_ATTRIB_CPU = 7 BASS_ATTRIB_SRC = 8 BASS_ATTRIB_NET_RESUME = 9 BASS_ATTRIB_SCANINFO = 10 BASS_ATTRIB_MUSIC_AMPLIFY = 0x100 BASS_ATTRIB_MUSIC_PANSEP = 0x101 BASS_ATTRIB_MUSIC_PSCALER = 0x102 BASS_ATTRIB_MUSIC_BPM = 0x103 BASS_ATTRIB_MUSIC_SPEED = 0x104 BASS_ATTRIB_MUSIC_VOL_GLOBAL = 0x105 BASS_ATTRIB_MUSIC_ACTIVE = 0x106 BASS_ATTRIB_MUSIC_VOL_CHAN = 0x200 -- + channel # BASS_ATTRIB_MUSIC_VOL_INST = 0x300 -- + instrument # BASS_DATA_AVAILABLE = 0 -- query how much data is buffered BASS_DATA_FIXED = 0x20000000 -- flag: return 8.24 fixed-point data BASS_DATA_FLOAT = 0x40000000 -- flag: return floating-point sample data BASS_DATA_FFT256 = 0x80000000 -- 256 sample FFT BASS_DATA_FFT512 = 0x80000001 -- 512 FFT BASS_DATA_FFT1024 = 0x80000002 -- 1024 FFT BASS_DATA_FFT2048 = 0x80000003 -- 2048 FFT BASS_DATA_FFT4096 = 0x80000004 -- 4096 FFT BASS_DATA_FFT8192 = 0x80000005 -- 8192 FFT BASS_DATA_FFT16384 = 0x80000006 -- 16384 FFT BASS_DATA_FFT_INDIVIDUAL = 0x10 -- FFT flag: FFT for each channel, else all combined BASS_DATA_FFT_NOWINDOW = 0x20 -- FFT flag: no Hanning window BASS_DATA_FFT_REMOVEDC = 0x40 -- FFT flag: pre-remove DC bias BASS_DATA_FFT_COMPLEX = 0x80 -- FFT flag: return complex data BASS_LEVEL_MONO = 1 BASS_LEVEL_STEREO = 2 BASS_LEVEL_RMS = 4 BASS_TAG_ID3 = 0 -- ID3v1 tags : TAG_ID3 structure BASS_TAG_ID3V2 = 1 -- ID3v2 tags : variable length block BASS_TAG_OGG = 2 -- OGG comments : series of null-terminated UTF-8 strings BASS_TAG_HTTP = 3 -- HTTP headers : series of null-terminated ANSI strings BASS_TAG_ICY = 4 -- ICY headers : series of null-terminated ANSI strings BASS_TAG_META = 5 -- ICY metadata : ANSI string BASS_TAG_APE = 6 -- APE tags : series of null-terminated UTF-8 strings BASS_TAG_MP4 = 7 -- MP4/iTunes metadata : series of null-terminated UTF-8 strings BASS_TAG_VENDOR = 9 -- OGG encoder : UTF-8 string BASS_TAG_LYRICS3 = 10 -- Lyric3v2 tag : ASCII string BASS_TAG_CA_CODEC = 11 -- CoreAudio codec info : TAG_CA_CODEC structure BASS_TAG_MF = 13 -- Media Foundation tags : series of null-terminated UTF-8 strings BASS_TAG_WAVEFORMAT = 14 -- WAVE format : WAVEFORMATEEX structure BASS_TAG_RIFF_INFO = 0x100 -- RIFF "INFO" tags : series of null-terminated ANSI strings BASS_TAG_RIFF_BEXT = 0x101 -- RIFF/BWF "bext" tags : TAG_BEXT structure BASS_TAG_RIFF_CART = 0x102 -- RIFF/BWF "cart" tags : TAG_CART structure BASS_TAG_RIFF_DISP = 0x103 -- RIFF "DISP" text tag : ANSI string BASS_TAG_APE_BINARY = 0x1000 -- + index #, binary APE tag : TAG_APE_BINARY structure BASS_TAG_MUSIC_NAME = 0x10000 -- MOD music name : ANSI string BASS_TAG_MUSIC_MESSAGE = 0x10001 -- MOD message : ANSI string BASS_TAG_MUSIC_ORDERS = 0x10002 -- MOD order list : BYTE array of pattern numbers BASS_TAG_MUSIC_INST = 0x10100 -- + instrument #, MOD instrument name : ANSI string BASS_TAG_MUSIC_SAMPLE = 0x10300 -- + sample #, MOD sample name : ANSI string BASS_POS_BYTE = 0 -- byte position BASS_POS_MUSIC_ORDER = 1 -- order.row position, MAKELONG(order,row) BASS_POS_OGG = 3 -- OGG bitstream number BASS_POS_INEXACT = 0x8000000 -- flag: allow seeking to inexact position BASS_POS_DECODE = 0x10000000 -- flag: get the decoding (not playing) position BASS_POS_DECODETO = 0x20000000 -- flag: decode to the position instead of seeking BASS_POS_SCAN = 0x40000000 -- flag: scan to the position BASS_INPUT_OFF = 0x10000 BASS_INPUT_ON = 0x20000 BASS_INPUT_TYPE_MASK = 0xff000000 BASS_INPUT_TYPE_UNDEF = 0x00000000 BASS_INPUT_TYPE_DIGITAL = 0x01000000 BASS_INPUT_TYPE_LINE = 0x02000000 BASS_INPUT_TYPE_MIC = 0x03000000 BASS_INPUT_TYPE_SYNTH = 0x04000000 BASS_INPUT_TYPE_CD = 0x05000000 BASS_INPUT_TYPE_PHONE = 0x06000000 BASS_INPUT_TYPE_SPEAKER = 0x07000000 BASS_INPUT_TYPE_WAVE = 0x08000000 BASS_INPUT_TYPE_AUX = 0x09000000 BASS_INPUT_TYPE_ANALOG = 0x0a000000 BASS_IOSNOTIFY_INTERRUPT = 1 -- interruption started BASS_IOSNOTIFY_INTERRUPT_END = 2 -- interruption ended return bass