/*
	BASS 2.4 C/C++ header file
	Copyright (c) 1999-2019 Un4seen Developments Ltd.

	See the BASS.CHM file for more detailed documentation

	Modified for Wine dll
*/

#ifndef WINBASS_H
#define WINBASS_H

#ifdef WINAPI_FAMILY
#include <winapifamily.h>
#endif
#include <wtypes.h>
typedef unsigned __int64 WIN_QWORD;
#define WIN_LOBYTE(a) LOBYTE(a)
#define WIN_HIBYTE(a) HIBYTE(a)
#define WIN_LOWORD(a) LOWORD(a)
#define WIN_HIWORD(a) HIWORD(a)
#define WIN_MAKEWORD(a,b) MAKEWORD(a,b)
#define WIN_MAKELONG(a,b) MAKELONG(a,b)

#ifdef __cplusplus
extern "C" {
#endif

#define WIN_BASSVERSION			0x204
#define WIN_BASSVERSIONTEXT		"2.4"

#ifdef __cplusplus
#define WIN_BASS_UNICODE		0x80000000
#endif

#ifndef WIN_BASSDEF
#define WIN_BASSDEF(f) WINAPI f
#else
#define NOBASSOVERLOADS
#endif

typedef DWORD WIN_HMUSIC;
typedef DWORD WIN_HSAMPLE;
typedef DWORD WIN_HCHANNEL;
typedef DWORD WIN_HSTREAM;
typedef DWORD WIN_HRECORD;
typedef DWORD WIN_HSYNC;
typedef DWORD WIN_HDSP;
typedef DWORD WIN_HFX;
typedef DWORD WIN_HPLUGIN;

typedef struct {
#if defined(_WIN32_WCE) || (defined(WINAPI_FAMILY) && WINAPI_FAMILY != WINAPI_FAMILY_DESKTOP_APP)
	const wchar_t *name;
	const wchar_t *driver;
#else
	const char *name;
	const char *driver;
#endif
	DWORD flags;
} WIN_BASS_DEVICEINFO;

typedef struct {
	DWORD flags;
	DWORD hwsize;
	DWORD hwfree;
	DWORD freesam;
	DWORD free3d;
	DWORD minrate;
	DWORD maxrate;
	BOOL eax;
	DWORD minbuf;
	DWORD dsver;
	DWORD latency;
	DWORD initflags;
	DWORD speakers;
	DWORD freq;
} WIN_BASS_INFO;

typedef struct {
	DWORD flags;
	DWORD formats;
	DWORD inputs;
	BOOL singlein;
	DWORD freq;
} WIN_BASS_RECORDINFO;

typedef struct {
	DWORD freq;
	float volume;
	float pan;
	DWORD flags;
	DWORD length;
	DWORD max;
	DWORD origres;
	DWORD chans;
	DWORD mingap;
	DWORD mode3d;
	float mindist;
	float maxdist;
	DWORD iangle;
	DWORD oangle;
	float outvol;
	DWORD vam;
	DWORD priority;
} WIN_BASS_SAMPLE;

typedef struct {
	DWORD freq;
	DWORD chans;
	DWORD flags;
	DWORD ctype;
	DWORD origres;
	WIN_HPLUGIN plugin;
	WIN_HSAMPLE sample;
	const char *filename;
} WIN_BASS_CHANNELINFO;

typedef struct {
	DWORD ctype;
#if defined(_WIN32_WCE) || (defined(WINAPI_FAMILY) && WINAPI_FAMILY != WINAPI_FAMILY_DESKTOP_APP)
	const wchar_t *name;
	const wchar_t *exts;
#else
	const char *name;
	const char *exts;
#endif
} WIN_BASS_PLUGINFORM;

typedef struct {
	DWORD version;
	DWORD formatc;
	const WIN_BASS_PLUGINFORM *formats;
} WIN_BASS_PLUGININFO;

typedef struct WIN_BASS_3DVECTOR {
#ifdef __cplusplus
	WIN_BASS_3DVECTOR() {}
	WIN_BASS_3DVECTOR(float _x, float _y, float _z) : x(_x), y(_y), z(_z) {}
#endif
	float x;
	float y;
	float z;
} WIN_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
};

typedef DWORD (CALLBACK WIN_STREAMPROC)(WIN_HSTREAM handle, void *buffer, DWORD length, void *user);

typedef void (CALLBACK WIN_FILECLOSEPROC)(void *user);
typedef WIN_QWORD (CALLBACK WIN_FILELENPROC)(void *user);
typedef DWORD (CALLBACK WIN_FILEREADPROC)(void *buffer, DWORD length, void *user);
typedef BOOL (CALLBACK WIN_FILESEEKPROC)(WIN_QWORD offset, void *user);

typedef struct {
	WIN_FILECLOSEPROC *close;
	WIN_FILELENPROC *length;
	WIN_FILEREADPROC *read;
	WIN_FILESEEKPROC *seek;
} WIN_BASS_FILEPROCS;

typedef void (CALLBACK WIN_DOWNLOADPROC)(const void *buffer, DWORD length, void *user);

typedef void (CALLBACK WIN_SYNCPROC)(WIN_HSYNC handle, DWORD channel, DWORD data, void *user);

typedef void (CALLBACK WIN_DSPPROC)(WIN_HDSP handle, DWORD channel, void *buffer, DWORD length, void *user);

typedef BOOL (CALLBACK WIN_RECORDPROC)(WIN_HRECORD handle, const void *buffer, DWORD length, void *user);

typedef struct {
	char id[3];
	char title[30];
	char artist[30];
	char album[30];
	char year[4];
	char comment[30];
	BYTE genre;
} WIN_TAG_ID3;

typedef struct {
	const char *key;
	const void *data;
	DWORD length;
} WIN_TAG_APE_BINARY;

#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4200)
#endif
#pragma pack(push,1)
typedef struct {
	char Description[256];
	char Originator[32];
	char OriginatorReference[32];
	char OriginationDate[10];
	char OriginationTime[8];
	WIN_QWORD TimeReference;
	WORD Version;
	BYTE UMID[64];
	BYTE Reserved[190];
#if defined(__GNUC__) && __GNUC__<3
	char CodingHistory[0];
#elif 1 // change to 0 if compiler fails the following line
	char CodingHistory[];
#else
	char CodingHistory[1];
#endif
} WIN_TAG_BEXT;
#pragma pack(pop)

typedef struct
{
	DWORD dwUsage;
	DWORD dwValue;
} WIN_TAG_CART_TIMER;

typedef struct
{
	char Version[4];
	char Title[64];
	char Artist[64];
	char CutID[64];
	char ClientID[64];
	char Category[64];
	char Classification[64];
	char OutCue[64];
	char StartDate[10];
	char StartTime[8];
	char EndDate[10];
	char EndTime[8];
	char ProducerAppID[64];
	char ProducerAppVersion[64];
	char UserDef[64];
	DWORD dwLevelReference;
	WIN_TAG_CART_TIMER PostTimer[8];
	char Reserved[276];
	char URL[1024];
#if defined(__GNUC__) && __GNUC__<3
	char TagText[0];
#elif 1 // change to 0 if compiler fails the following line
	char TagText[];
#else
	char TagText[1];
#endif
} WIN_TAG_CART;

typedef struct
{
	DWORD dwName;
	DWORD dwPosition;
	DWORD fccChunk;
	DWORD dwChunkStart;
	DWORD dwBlockStart;
	DWORD dwSampleOffset;
} WIN_TAG_CUE_POINT;

typedef struct
{
	DWORD dwCuePoints;
#if defined(__GNUC__) && __GNUC__<3
	WIN_TAG_CUE_POINT CuePoints[0];
#elif 1 // change to 0 if compiler fails the following line
	WIN_TAG_CUE_POINT CuePoints[];
#else
	WIN_TAG_CUE_POINT CuePoints[1];
#endif
} WIN_TAG_CUE;

typedef struct
{
	DWORD dwIdentifier;
	DWORD dwType;
	DWORD dwStart;
	DWORD dwEnd;
	DWORD dwFraction;
	DWORD dwPlayCount;
} WIN_TAG_SMPL_LOOP;

typedef struct
{
	DWORD dwManufacturer;
	DWORD dwProduct;
	DWORD dwSamplePeriod;
	DWORD dwMIDIUnityNote;
	DWORD dwMIDIPitchFraction;
	DWORD dwSMPTEFormat;
	DWORD dwSMPTEOffset;
	DWORD cSampleLoops;
	DWORD cbSamplerData;
#if defined(__GNUC__) && __GNUC__<3
	WIN_TAG_SMPL_LOOP SampleLoops[0];
#elif 1 // change to 0 if compiler fails the following line
	WIN_TAG_SMPL_LOOP SampleLoops[];
#else
	WIN_TAG_SMPL_LOOP SampleLoops[1];
#endif
} WIN_TAG_SMPL;
#ifdef _MSC_VER
#pragma warning(pop)
#endif

typedef struct {
	DWORD ftype;
	DWORD atype;
	const char *name;
} WIN_TAG_CA_CODEC;

#ifndef _WIN_WAVEFORMATEX_
#define _WIN_WAVEFORMATEX_
#pragma pack(push,1)
typedef struct WIN_tWAVEFORMATEX
{
	WORD wFormatTag;
	WORD nChannels;
	DWORD nSamplesPerSec;
	DWORD nAvgBytesPerSec;
	WORD nBlockAlign;
	WORD wBitsPerSample;
	WORD cbSize;
} WIN_WAVEFORMATEX, *WIN_PWAVEFORMATEX, *WIN_LPWAVEFORMATEX;
typedef const WIN_WAVEFORMATEX *WIN_LPCWAVEFORMATEX;
#pragma pack(pop)
#endif

typedef struct {
	float       fWetDryMix;
	float       fDepth;
	float       fFeedback;
	float       fFrequency;
	DWORD       lWaveform;
	float       fDelay;
	DWORD       lPhase;
} WIN_BASS_DX8_CHORUS;

typedef struct {
	float   fGain;
	float   fAttack;
	float   fRelease;
	float   fThreshold;
	float   fRatio;
	float   fPredelay;
} WIN_BASS_DX8_COMPRESSOR;

typedef struct {
	float   fGain;
	float   fEdge;
	float   fPostEQCenterFrequency;
	float   fPostEQBandwidth;
	float   fPreLowpassCutoff;
} WIN_BASS_DX8_DISTORTION;

typedef struct {
	float   fWetDryMix;
	float   fFeedback;
	float   fLeftDelay;
	float   fRightDelay;
	BOOL    lPanDelay;
} WIN_BASS_DX8_ECHO;

typedef struct {
	float       fWetDryMix;
	float       fDepth;
	float       fFeedback;
	float       fFrequency;
	DWORD       lWaveform;
	float       fDelay;
	DWORD       lPhase;
} WIN_BASS_DX8_FLANGER;

typedef struct {
	DWORD       dwRateHz;
	DWORD       dwWaveShape;
} WIN_BASS_DX8_GARGLE;

typedef struct {
	int     lRoom;
	int     lRoomHF;
	float   flRoomRolloffFactor;
	float   flDecayTime;
	float   flDecayHFRatio;
	int     lReflections;
	float   flReflectionsDelay;
	int     lReverb;
	float   flReverbDelay;
	float   flDiffusion;
	float   flDensity;
	float   flHFReference;
} WIN_BASS_DX8_I3DL2REVERB;

typedef struct {
	float   fCenter;
	float   fBandwidth;
	float   fGain;
} WIN_BASS_DX8_PARAMEQ;

typedef struct {
	float   fInGain;
	float   fReverbMix;
	float   fReverbTime;
	float   fHighFreqRTRatio;
} WIN_BASS_DX8_REVERB;

typedef struct {
	float fTarget;
	float fCurrent;
	float fTime;
	DWORD lCurve;
} WIN_BASS_FX_VOLUME_PARAM;

typedef void (CALLBACK WIN_IOSNOTIFYPROC)(DWORD status);

BOOL WIN_BASSDEF(WIN_BASS_SetConfig)(DWORD option, DWORD value);
DWORD WIN_BASSDEF(WIN_BASS_GetConfig)(DWORD option);
BOOL WIN_BASSDEF(WIN_BASS_SetConfigPtr)(DWORD option, const void *value);
void *WIN_BASSDEF(WIN_BASS_GetConfigPtr)(DWORD option);
DWORD WIN_BASSDEF(WIN_BASS_GetVersion)(void);
int WIN_BASSDEF(WIN_BASS_ErrorGetCode)(void);

BOOL WIN_BASSDEF(WIN_BASS_GetDeviceInfo)(DWORD device, WIN_BASS_DEVICEINFO *info);
#if !defined(_WIN32_WCE) && !(defined(WINAPI_FAMILY) && WINAPI_FAMILY != WINAPI_FAMILY_DESKTOP_APP)
BOOL WIN_BASSDEF(WIN_BASS_Init)(int device, DWORD freq, DWORD flags, HWND win, const GUID *dsguid);
#else
BOOL WIN_BASSDEF(WIN_BASS_Init)(int device, DWORD freq, DWORD flags, void *win, void *dsguid);
#endif
BOOL WIN_BASSDEF(WIN_BASS_Free)(void);
BOOL WIN_BASSDEF(WIN_BASS_SetDevice)(DWORD device);
DWORD WIN_BASSDEF(WIN_BASS_GetDevice)(void);
BOOL WIN_BASSDEF(WIN_BASS_GetInfo)(WIN_BASS_INFO *info);
BOOL WIN_BASSDEF(WIN_BASS_Start)(void);
BOOL WIN_BASSDEF(WIN_BASS_Stop)(void);
BOOL WIN_BASSDEF(WIN_BASS_Pause)(void);
BOOL WIN_BASSDEF(WIN_BASS_IsStarted)(void);
BOOL WIN_BASSDEF(WIN_BASS_Update)(DWORD length);
float WIN_BASSDEF(WIN_BASS_GetCPU)(void);
BOOL WIN_BASSDEF(WIN_BASS_SetVolume)(float volume);
float WIN_BASSDEF(WIN_BASS_GetVolume)(void);
#if !defined(_WIN32_WCE) && !(defined(WINAPI_FAMILY) && WINAPI_FAMILY!=WINAPI_FAMILY_DESKTOP_APP)
void *WIN_BASSDEF(WIN_BASS_GetDSoundObject)(DWORD object);
#endif

BOOL WIN_BASSDEF(WIN_BASS_Set3DFactors)(float distf, float rollf, float doppf);
BOOL WIN_BASSDEF(WIN_BASS_Get3DFactors)(float *distf, float *rollf, float *doppf);
BOOL WIN_BASSDEF(WIN_BASS_Set3DPosition)(const WIN_BASS_3DVECTOR *pos, const WIN_BASS_3DVECTOR *vel, const WIN_BASS_3DVECTOR *front, const WIN_BASS_3DVECTOR *top);
BOOL WIN_BASSDEF(WIN_BASS_Get3DPosition)(WIN_BASS_3DVECTOR *pos, WIN_BASS_3DVECTOR *vel, WIN_BASS_3DVECTOR *front, WIN_BASS_3DVECTOR *top);
void WIN_BASSDEF(WIN_BASS_Apply3D)(void);
#if !defined(_WIN32_WCE) && !(defined(WINAPI_FAMILY) && WINAPI_FAMILY != WINAPI_FAMILY_DESKTOP_APP)
BOOL WIN_BASSDEF(WIN_BASS_SetEAXParameters)(int env, float vol, float decay, float damp);
BOOL WIN_BASSDEF(WIN_BASS_GetEAXParameters)(DWORD *env, float *vol, float *decay, float *damp);
#endif

WIN_HPLUGIN WIN_BASSDEF(WIN_BASS_PluginLoad)(const char *file, DWORD flags);
BOOL WIN_BASSDEF(WIN_BASS_PluginFree)(WIN_HPLUGIN handle);
const WIN_BASS_PLUGININFO *WIN_BASSDEF(WIN_BASS_PluginGetInfo)(WIN_HPLUGIN handle);

WIN_HSAMPLE WIN_BASSDEF(WIN_BASS_SampleLoad)(BOOL mem, const void *file, WIN_QWORD offset, DWORD length, DWORD max, DWORD flags);
WIN_HSAMPLE WIN_BASSDEF(WIN_BASS_SampleCreate)(DWORD length, DWORD freq, DWORD chans, DWORD max, DWORD flags);
BOOL WIN_BASSDEF(WIN_BASS_SampleFree)(WIN_HSAMPLE handle);
BOOL WIN_BASSDEF(WIN_BASS_SampleSetData)(WIN_HSAMPLE handle, const void *buffer);
BOOL WIN_BASSDEF(WIN_BASS_SampleGetData)(WIN_HSAMPLE handle, void *buffer);
BOOL WIN_BASSDEF(WIN_BASS_SampleGetInfo)(WIN_HSAMPLE handle, WIN_BASS_SAMPLE *info);
BOOL WIN_BASSDEF(WIN_BASS_SampleSetInfo)(WIN_HSAMPLE handle, const WIN_BASS_SAMPLE *info);
WIN_HCHANNEL WIN_BASSDEF(WIN_BASS_SampleGetChannel)(WIN_HSAMPLE handle, BOOL onlynew);
DWORD WIN_BASSDEF(WIN_BASS_SampleGetChannels)(WIN_HSAMPLE handle, WIN_HCHANNEL *channels);
BOOL WIN_BASSDEF(WIN_BASS_SampleStop)(WIN_HSAMPLE handle);

WIN_HSTREAM WIN_BASSDEF(WIN_BASS_StreamCreate)(DWORD freq, DWORD chans, DWORD flags, WIN_STREAMPROC *proc, void *user);
WIN_HSTREAM WIN_BASSDEF(WIN_BASS_StreamCreateFile)(BOOL mem, const void *file, WIN_QWORD offset, WIN_QWORD length, DWORD flags);
WIN_HSTREAM WIN_BASSDEF(WIN_BASS_StreamCreateURL)(const char *url, DWORD offset, DWORD flags, WIN_DOWNLOADPROC *proc, void *user);
WIN_HSTREAM WIN_BASSDEF(WIN_BASS_StreamCreateFileUser)(DWORD system, DWORD flags, const WIN_BASS_FILEPROCS *proc, void *user);
BOOL WIN_BASSDEF(WIN_BASS_StreamFree)(WIN_HSTREAM handle);
WIN_QWORD WIN_BASSDEF(WIN_BASS_StreamGetFilePosition)(WIN_HSTREAM handle, DWORD mode);
DWORD WIN_BASSDEF(WIN_BASS_StreamPutData)(WIN_HSTREAM handle, const void *buffer, DWORD length);
DWORD WIN_BASSDEF(WIN_BASS_StreamPutFileData)(WIN_HSTREAM handle, const void *buffer, DWORD length);

WIN_HMUSIC WIN_BASSDEF(WIN_BASS_MusicLoad)(BOOL mem, const void *file, WIN_QWORD offset, DWORD length, DWORD flags, DWORD freq);
BOOL WIN_BASSDEF(WIN_BASS_MusicFree)(WIN_HMUSIC handle);

BOOL WIN_BASSDEF(WIN_BASS_RecordGetDeviceInfo)(DWORD device, WIN_BASS_DEVICEINFO *info);
BOOL WIN_BASSDEF(WIN_BASS_RecordInit)(int device);
BOOL WIN_BASSDEF(WIN_BASS_RecordFree)(void);
BOOL WIN_BASSDEF(WIN_BASS_RecordSetDevice)(DWORD device);
DWORD WIN_BASSDEF(WIN_BASS_RecordGetDevice)(void);
BOOL WIN_BASSDEF(WIN_BASS_RecordGetInfo)(WIN_BASS_RECORDINFO *info);
const char *WIN_BASSDEF(WIN_BASS_RecordGetInputName)(int input);
BOOL WIN_BASSDEF(WIN_BASS_RecordSetInput)(int input, DWORD flags, float volume);
DWORD WIN_BASSDEF(WIN_BASS_RecordGetInput)(int input, float *volume);
WIN_HRECORD WIN_BASSDEF(WIN_BASS_RecordStart)(DWORD freq, DWORD chans, DWORD flags, WIN_RECORDPROC *proc, void *user);

double WIN_BASSDEF(WIN_BASS_ChannelBytes2Seconds)(DWORD handle, WIN_QWORD pos);
WIN_QWORD WIN_BASSDEF(WIN_BASS_ChannelSeconds2Bytes)(DWORD handle, double pos);
DWORD WIN_BASSDEF(WIN_BASS_ChannelGetDevice)(DWORD handle);
BOOL WIN_BASSDEF(WIN_BASS_ChannelSetDevice)(DWORD handle, DWORD device);
DWORD WIN_BASSDEF(WIN_BASS_ChannelIsActive)(DWORD handle);
BOOL WIN_BASSDEF(WIN_BASS_ChannelGetInfo)(DWORD handle, WIN_BASS_CHANNELINFO *info);
const char *WIN_BASSDEF(WIN_BASS_ChannelGetTags)(DWORD handle, DWORD tags);
DWORD WIN_BASSDEF(WIN_BASS_ChannelFlags)(DWORD handle, DWORD flags, DWORD mask);
BOOL WIN_BASSDEF(WIN_BASS_ChannelLock)(DWORD handle, BOOL lock);
BOOL WIN_BASSDEF(WIN_BASS_ChannelPlay)(DWORD handle, BOOL restart);
BOOL WIN_BASSDEF(WIN_BASS_ChannelStop)(DWORD handle);
BOOL WIN_BASSDEF(WIN_BASS_ChannelPause)(DWORD handle);
BOOL WIN_BASSDEF(WIN_BASS_ChannelUpdate)(DWORD handle, DWORD length);
BOOL WIN_BASSDEF(WIN_BASS_ChannelSetAttribute)(DWORD handle, DWORD attrib, float value);
BOOL WIN_BASSDEF(WIN_BASS_ChannelGetAttribute)(DWORD handle, DWORD attrib, float *value);
BOOL WIN_BASSDEF(WIN_BASS_ChannelSlideAttribute)(DWORD handle, DWORD attrib, float value, DWORD time);
BOOL WIN_BASSDEF(WIN_BASS_ChannelIsSliding)(DWORD handle, DWORD attrib);
BOOL WIN_BASSDEF(WIN_BASS_ChannelSetAttributeEx)(DWORD handle, DWORD attrib, void *value, DWORD size);
DWORD WIN_BASSDEF(WIN_BASS_ChannelGetAttributeEx)(DWORD handle, DWORD attrib, void *value, DWORD size);
BOOL WIN_BASSDEF(WIN_BASS_ChannelSet3DAttributes)(DWORD handle, int mode, float min, float max, int iangle, int oangle, float outvol);
BOOL WIN_BASSDEF(WIN_BASS_ChannelGet3DAttributes)(DWORD handle, DWORD *mode, float *min, float *max, DWORD *iangle, DWORD *oangle, float *outvol);
BOOL WIN_BASSDEF(WIN_BASS_ChannelSet3DPosition)(DWORD handle, const WIN_BASS_3DVECTOR *pos, const WIN_BASS_3DVECTOR *orient, const WIN_BASS_3DVECTOR *vel);
BOOL WIN_BASSDEF(WIN_BASS_ChannelGet3DPosition)(DWORD handle, WIN_BASS_3DVECTOR *pos, WIN_BASS_3DVECTOR *orient, WIN_BASS_3DVECTOR *vel);
WIN_QWORD WIN_BASSDEF(WIN_BASS_ChannelGetLength)(DWORD handle, DWORD mode);
BOOL WIN_BASSDEF(WIN_BASS_ChannelSetPosition)(DWORD handle, WIN_QWORD pos, DWORD mode);
WIN_QWORD WIN_BASSDEF(WIN_BASS_ChannelGetPosition)(DWORD handle, DWORD mode);
DWORD WIN_BASSDEF(WIN_BASS_ChannelGetLevel)(DWORD handle);
BOOL WIN_BASSDEF(WIN_BASS_ChannelGetLevelEx)(DWORD handle, float *levels, float length, DWORD flags);
DWORD WIN_BASSDEF(WIN_BASS_ChannelGetData)(DWORD handle, void *buffer, DWORD length);
WIN_HSYNC WIN_BASSDEF(WIN_BASS_ChannelSetSync)(DWORD handle, DWORD type, WIN_QWORD param, WIN_SYNCPROC *proc, void *user);
BOOL WIN_BASSDEF(WIN_BASS_ChannelRemoveSync)(DWORD handle, WIN_HSYNC sync);
BOOL WIN_BASSDEF(WIN_BASS_ChannelSetLink)(DWORD handle, DWORD chan);
BOOL WIN_BASSDEF(WIN_BASS_ChannelRemoveLink)(DWORD handle, DWORD chan);
WIN_HDSP WIN_BASSDEF(WIN_BASS_ChannelSetDSP)(DWORD handle, WIN_DSPPROC *proc, void *user, int priority);
BOOL WIN_BASSDEF(WIN_BASS_ChannelRemoveDSP)(DWORD handle, WIN_HDSP dsp);
WIN_HFX WIN_BASSDEF(WIN_BASS_ChannelSetFX)(DWORD handle, DWORD type, int priority);
BOOL WIN_BASSDEF(WIN_BASS_ChannelRemoveFX)(DWORD handle, WIN_HFX fx);

BOOL WIN_BASSDEF(WIN_BASS_FXSetParameters)(WIN_HFX handle, const void *params);
BOOL WIN_BASSDEF(WIN_BASS_FXGetParameters)(WIN_HFX handle, void *params);
BOOL WIN_BASSDEF(WIN_BASS_FXSetPriority)(WIN_HFX handle, int priority);
BOOL WIN_BASSDEF(WIN_BASS_FXReset)(WIN_HFX handle);

#ifdef __cplusplus
}

#if !defined(NOBASSOVERLOADS)
static inline WIN_HPLUGIN WIN_BASS_PluginLoad(const WCHAR *file, DWORD flags)
{
	return WIN_BASS_PluginLoad((const char*)file, flags | WIN_BASS_UNICODE);
}

static inline WIN_HMUSIC WIN_BASS_MusicLoad(BOOL mem, const WCHAR *file, WIN_QWORD offset, DWORD length, DWORD flags, DWORD freq)
{
	return WIN_BASS_MusicLoad(mem, (const void*)file, offset, length, flags | WIN_BASS_UNICODE, freq);
}

static inline WIN_HSAMPLE WIN_BASS_SampleLoad(BOOL mem, const WCHAR *file, WIN_QWORD offset, DWORD length, DWORD max, DWORD flags)
{
	return WIN_BASS_SampleLoad(mem, (const void*)file, offset, length, max, flags | WIN_BASS_UNICODE);
}

static inline WIN_HSTREAM WIN_BASS_StreamCreateFile(BOOL mem, const WCHAR *file, WIN_QWORD offset, WIN_QWORD length, DWORD flags)
{
	return WIN_BASS_StreamCreateFile(mem, (const void*)file, offset, length, flags | WIN_BASS_UNICODE);
}

static inline WIN_HSTREAM WIN_BASS_StreamCreateURL(const WCHAR *url, DWORD offset, DWORD flags, WIN_DOWNLOADPROC *proc, void *user)
{
	return WIN_BASS_StreamCreateURL((const char*)url, offset, flags | WIN_BASS_UNICODE, proc, user);
}

static inline BOOL WIN_BASS_SetConfigPtr(DWORD option, const WCHAR *value)
{
	return WIN_BASS_SetConfigPtr(option | WIN_BASS_UNICODE, (const void*)value);
}
#endif
#endif

#endif