backup/DxWnd.reloaded
1
0
Fork 0
mirror of https://github.com/DxWnd/DxWnd.reloaded synced 2024-12-30 09:25:35 +01:00
Code Issues Projects Releases Activity
DxWnd.reloaded/Include/qmixer.h
gho tik 6883c264d4 v2_03_91_src_fx4 
Former-commit-id: 2a0a9d30c2dab0c0808e956988867df4086b1d00
2017-03-06 11:47:39 -05:00

1430 lines
39 KiB
C
Raw Permalink Blame History

//
// QMixer for Windows and Macintosh.
// Copyright (c) 1995-1998 QSound Labs, Inc. All Rights Reserved.
// Version 4.13, July 26, 1998.
//
// Based on Microsoft's WaveMix API.
// Copyright (c) 1993, 1994 Microsoft Corporation. All Rights Reserved.
//
#ifndef QMIXER_H
#define QMIXER_H
#if !defined(_QMIXIMP)
#define _QMIXIMP __declspec(dllimport)
#endif
DECLARE_HANDLE(HQMIXER);
//
// Constants for qprocessing
//
#define Q_PAN_MIN 0
#define Q_PAN_MAX 60
#define Q_PAN_DEFAULT 15
#define Q_VOLUME_DEFAULT 10000
//
// Flags for channel functions.
//
#define QMIX_ALL 0x0001 // apply to all channels
#define QMIX_NOREMIX 0x0002 // don't remix
#define QMIX_CONTROL_NOREMIX 0x0004 // don't remix
typedef
struct QSVECTOR {
float x; // meters
float y; // meters
float z; // meters
} QSVECTOR, *LPQSVECTOR;
typedef
struct QSPOLAR {
float azimuth; // degrees
float range; // meters
float elevation; // degrees
} QSPOLAR, *LPQSPOLAR;
#ifdef __cplusplus
extern "C" {
#endif
typedef
struct QMIXINFO {
DWORD dwSize;
DWORD dwMajorVersion;
DWORD dwMinorVersion;
DWORD dwBuildNumber;
}
QMIXINFO, FAR* LPQMIXINFO;
_QMIXIMP
DWORD
WINAPI
QSWaveMixGetInfoEx(
LPQMIXINFO lpInfo
);
//
// Error handling functions.
//
typedef UINT QMIX_RESULT;
_QMIXIMP
QMIX_RESULT
WINAPI
QSWaveMixGetLastError(
void
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixGetErrorText(
QMIX_RESULT qmrError,
LPSTR pszText,
UINT cchText
);
//
// Initialization functions.
//
_QMIXIMP
HQMIXER
WINAPI
QSWaveMixInit(
void
);
#define QMIX_CONFIG_USEPRIMARY 0x0001
#define QMIX_CONFIG_NOTHREAD 0x0002
#define QMIX_CONFIG_PLAYSILENCE 0x0004
#define QMIX_CONFIG_LEFTCOORDS 0x0008
#define QMIX_CONFIG_RIGHTCOORDS 0x0000
#define QMIX_CONFIG_GLOBALROLLOFF 0x0010
#define QMIX_CONFIG_OUTPUT_DETECT 0
#define QMIX_CONFIG_OUTPUT_WAVEOUT 1
#define QMIX_CONFIG_OUTPUT_DIRECTSOUND 2
#define QMIX_CONFIG_MATH_DETECT 0
#define QMIX_CONFIG_MATH_INTEGER 1
#define QMIX_CONFIG_MATH_FLOAT 2
#define QMIX_CONFIG_MATH_MMX 3
typedef
struct QMIXCONFIG {
DWORD dwSize;
DWORD dwFlags;
DWORD dwSamplingRate; // 11025, 22050, or 44100 Hz; if 0 uses 22050
LPVOID lpIDirectSound;
const GUID FAR* lpGuid;
int iChannels; // if 0, uses default of 8
int iOutput; // if 0, uses best output device
int iLatency; // (in ms) if 0, uses default for output device
int iMath; // style of math
HWND hwnd; // handle used when initializing DirectSound
// (if 0, QMixer will find main window)
int iChannels3dHw; // number of 3d hardware channels
int iChannels3dQS; // number of 3d QSound software channels
int iChannels3dSw; // number of 3d software channels
int iChannels2dHw; // number of 2d hardware channels
int iChannels2dQS; // number of 2d QSound software channels
int iChannels2dSw; // number of 2d software channels
}
QMIXCONFIG, FAR* LPQMIXCONFIG;
_QMIXIMP
HQMIXER
WINAPI
QSWaveMixInitEx(
LPQMIXCONFIG lpConfig
);
//
// Choose between speakers or headphones.
//
#define QMIX_SPEAKERS_STEREO 0
#define QMIX_SPEAKERS_HEADPHONES 1
#define QMIX_SPEAKERS_MONO 2
#define QMIX_SPEAKERS_QUAD 3
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixSetSpeakerPlacement(
HQMIXER hQMixer,
int placement
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixGetSpeakerPlacement(
HQMIXER hQMixer,
LPDWORD lpdwPlacement
);
//
// The following function turns on and off various options
// in the mixer. Turning off features can save CPU cycles.
//
#define QMIX_OPTIONS_REAR 1 // improved rear effect
#define QMIX_OPTIONS_CROSSOVER 2 // improved frequency response
#define QMIX_OPTIONS_FLIPOUTPUT 4 // flip output channels
#define QMIX_OPTIONS_DOPPLER 8 // calculate listener velocity using position updates
#define QMIX_OPTIONS_ALL 0xffffffff
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixSetOptions(
HQMIXER hQMixer,
DWORD dwFlags,
DWORD dwMask
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixGetOptions(
HQMIXER hQMixer,
LPDWORD lpdwFlags
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixSetMixerOption(
HQMIXER hQMixer,
DWORD dwFlags,
LPVOID lpvOptions
);
//
// QSWaveMixOpenChannel flags
//
#define QMIX_OPENSINGLE 0 // open the single channel specified by iChannel
#define QMIX_OPENALL 1 // opens all the channels, iChannel ignored
#define QMIX_OPENCOUNT 2 // open iChannel Channels (eg. if iChannel = 4 will create channels 0-3)
#define QMIX_OPENAVAILABLE 3 // open the first unopened channel, and return channel number
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixOpenChannel(
HQMIXER hQMixer,
int iChannel,
DWORD dwFlags
);
//
// Comprehensive channel parameters. Used in the functions
// - QSWaveMixGetChannelParams
// - QSWaveMixSetChannelParams
// - QSWaveMixCalculateChannelParams
// - QSWaveMixFindChannel
// - QSWaveMixPlayEx
//
// The first set of parameters shouldn't be modified, the second set
// can be altered for QSWaveMixSetChannelParams, and the third set
// are calculated by QMixer.
//
typedef
struct QMIX_CHANNEL_PARAMS {
DWORD dwSize; // size of this structure
DWORD dwChannelType; // combination of QMIX_CHANNELTYPE_ flags
LPWAVEFORMATEX lpwfxFormat; // channel format (overrides default mixer output)
DWORD dwMixerFlags; // reserved
QSVECTOR vPosition; // 3d position (Cartesian coordinates)
QSVECTOR vVelocity; // 3d velocity (Cartesian coordinates)
QSVECTOR vOrientation; // 3d orientation (Cartesian coordinates)
float flInnerConeAngle; // inner cone angle (degrees)
float flOuterConeAngle; // outer cone angle (degrees)
float flOuterConeAtten; // attenuation outside cone (db)
float flMinDistance; // minimum distance (m)
float flMaxDistance; // maximum distance (m)
float flRolloff; // rolloff factor (0..10, default=1.0)
float flVolume; // scale
LONG lFrequency; // playback frequency
LONG lPanRate; // time in which a change is completed (ms)
LONG lPriority; // user-defined priority
DWORD dwModes; // combination of QSWaveMixEnableChannel flags
long unused[16]; // reserved for future expansion (set to zero)
LONG lTimePlaying; // current time playing current sound (ms)
LONG lTimeRemaining; // current time left to play (ms)
float flDistance; // current distance to listener (m)
float flAzimuth; // current azimuth (degrees)
float flElevation; // current elevation (degrees)
float flConeScale; // amount that volume is scaled for cone effect
float flRolloffScale; // amount that volume is scaled for rolloff effect
float flAppliedVolume; // volume applied to sound, including rolloff & cone effects (scale)
float flDopplerSpeedup; // speedup due to Doppler shift
QSVECTOR vHeadPosition; // position relative to listener (left-handed coordinates)
QSVECTOR vHeadVelocity; // velocity relative to listener (left-handed coordinates)
} QMIX_CHANNEL_PARAMS;
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixGetChannelParams(
HQMIXER hQMixer,
int iChannel,
QMIX_CHANNEL_PARAMS* params
);
_QMIXIMP MMRESULT WINAPI
QSWaveMixSetChannelParams(
HQMIXER hQMixer,
int iChannel,
DWORD dwFlags,
const QMIX_CHANNEL_PARAMS* params
);
_QMIXIMP MMRESULT WINAPI
QSWaveMixCalculateChannelParams(
HQMIXER hQMixer,
QMIX_CHANNEL_PARAMS* params,
DWORD dwFlags
);
//
// Channel types. These flags are used in:
// QSWaveMixConfigureChannel,
// QSWaveMixFindChannel.
// They also appear in the dwChannelType field in QMIX_CHANNEL_PARAMS.
//
#define QMIX_CHANNELTYPE_QSOUND 0x00010000 // uses QSound software mixer
#define QMIX_CHANNELTYPE_STREAMING 0x00020000 // uses hardware streaming DirectSoundBuffer
#define QMIX_CHANNELTYPE_STATIC 0x00040000 // uses hardware static DirectSoundBuffer
#define QMIX_CHANNELTYPE_SOFTWARE 0x00080000 // uses software DirectSoundBuffer
#define QMIX_CHANNELTYPE_DSOUND \
(QMIX_CHANNELTYPE_STREAMING|QMIX_CHANNELTYPE_STATIC|QMIX_CHANNELTYPE_SOFTWARE)
#define QMIX_CHANNELTYPE_ANYMIXER 0x00ff0000
#define QMIX_CHANNELTYPE_2D 0x01000000 // stereo only
#define QMIX_CHANNELTYPE_3D 0x02000000 // supports full 3d features
#define QMIX_CHANNELTYPE_ANYFEATURE 0x7f000000
#define QMIX_CHANNELTYPE_ALL (QMIX_CHANNELTYPE_ANYMIXER|QMIX_CHANNELTYPE_ANYFEATURE)
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixConfigureChannel(
HQMIXER hQMixer,
int iChannel,
DWORD dwFlags, // type of channel
LPCWAVEFORMATEX format, // format of channel (optional)
LPVOID lpvOptions // options (reserved, set to zero)
);
//
// Find a channel using one of the QMIX_FINDCHANNEL_ priority schemes.
//
// The type of channel can be restricted to one of the types given by
// a combination of the QMIX_CHANNELTYPE_ flags.
//
// Normally the channel will be excluded from subsequent calls to
// QSWaveMixFindChannel until a sound is played on the channel. This is
// to allow the setting up of several sounds to be played at the same
// instant. This reservation can be disabled by setting the
// QMIX_FINDCHANNEL_NORESERVE flag.
//
#define QMIX_FINDCHANNEL_SORTMETHOD 0x0000000f // mask for sort method
#define QMIX_FINDCHANNEL_BEGINTIME 0x00000000 // sort by time from beginning (least-recently used)
#define QMIX_FINDCHANNEL_ENDTIME 0x00000001 // sort by time to end (most-recently available)
#define QMIX_FINDCHANNEL_VOLUME 0x00000002 // sort by applied volume
#define QMIX_FINDCHANNEL_DISTANCE 0x00000003 // sort by distance from listener
#define QMIX_FINDCHANNEL_PRIORITY 0x00000004 // sort by user priority
#define QMIX_FINDCHANNEL_TOPLAY 0x00000000 // pick a playing or ready (idle) channel for playing another
#define QMIX_FINDCHANNEL_TOPAUSE 0x00000010 // pick a playing channel for pausing
#define QMIX_FINDCHANNEL_TORESTART 0x00000020 // pick a paused channel for restarting
#define QMIX_FINDCHANNEL_FORMAT 0x00000080 // channel must match lpParams->lpwfxFormat
#define QMIX_FINDCHANNEL_NORESERVE 0x80000000 // don't exclude from subsequent searches
#define QMIX_FINDCHANNEL_LRU QMIX_FINDCHANNEL_BEGINTIME
#define QMIX_FINDCHANNEL_MRA QMIX_FINDCHANNEL_ENDTIME
_QMIXIMP
int
WINAPI
QSWaveMixFindChannel(
HQMIXER hQMixer,
DWORD dwFlags,
const QMIX_CHANNEL_PARAMS* lpParams // compare with these parameters
);
//
// Turn on QMixer's dynamic scheduling. The lpChannelTypes array gives the
// channel type (one of QMIX_CHANNELTYPE_ANYMIXER and one of
// QMIX_CHANNELTYPE_ANYFEATURE) and the maximum number of desired channels of
// that type that should play at any time. A count of -1 channels specifies
// that as many channels as possible should be played. An entry with
// dwChannelType ends the list. If lpChannelTypes is null, the current type
// settings are used. If QMIX_PRIORITIZE_NONE is used, scheduling is turned
// off.
//
typedef
struct QMIX_CHANNELTYPES {
DWORD dwChannelType; // type of channel
int iMaxChannels; // maximum number of channels of that type to play
} QMIX_CHANNELTYPES, *LPQMIX_CHANNELTYPES;
#define QMIX_PRIORITIZE_NONE 0x0000000f
_QMIXIMP MMRESULT WINAPI
QSWaveMixPrioritizeChannels(
HQMIXER hQMixer,
LPQMIX_CHANNELTYPES lpChannelTypes,
DWORD dwFlags,
LPVOID lpvParams
);
//
// Structure describing wave data; returned by QSWaveMixOpenWave and
// QSWaveMixOpenWaveEx.
//
#define MAXFILENAME 15
typedef struct MIXWAVE {
PCMWAVEFORMAT pcm; // data format
WAVEHDR wh; // location and length of data
char szWaveFilename[MAXFILENAME+1]; // truncated version of name
LPWAVEFORMATEX pwf; // data format; needed for MSACM wave files
#if defined(MACINTOSH)
CmpSoundHeader format; // Mac version of sound info
#endif
}
MIXWAVE, FAR* LPMIXWAVE;
typedef const MIXWAVE FAR* LPCMIXWAVE;
// Input streaming callback function. Return TRUE to continue to play, return
// FALSE to stop playing.
typedef BOOL (CALLBACK *LPQMIXINPUTCALLBACK)(void* buffer, DWORD bytes, void* user);
//
// QSWaveMixOpenWave and QSWaveMixOpenWaveEx flags.
//
#define QMIX_FILE 0x0001 // load from file
#define QMIX_RESOURCE 0x0002 // load from resource
#define QMIX_MEMORY 0x0004 // load using MMIOINFO supplied by user
#define QMIX_RESIDENT 0x0008 // use memory-resident data
#define QMIX_FILESTREAM 0x0010 // stream from file
#define QMIX_INPUTSTREAM 0x0011 // stream from input buffer
#define QMIX_FILESPEC 0x0012 // Macintosh file specification
typedef union {
const char* FileName; // Name of RIFF file (e.g. "*.wav") with wave.
struct { // Wave stored in resource.
const char* Name; // Name of resource.
HINSTANCE hInstance; // Handle of module where resource is located.
} Resource;
LPMMIOINFO lpMmioInfo; // Read from file already opened by mmioOpen.
struct { // Memory resident wave.
LPCWAVEFORMATEX Format; // Format of wave; can be compressed.
HPSTR Data; // Pointer to memory resident audio samples.
DWORD Bytes; // Length of Data, in bytes.
DWORD Samples; // Number of wave samples; needed if compressed.
DWORD Tag; // User-defined id.
} Resident;
struct { // Input streaming using user callback.
LPCWAVEFORMATEX Format; // Format of data (must be uncompressed).
DWORD BlockBytes; // Preferred length of block.
LPQMIXINPUTCALLBACK Callback; // User-defined callback function.
LPVOID User; // Data to be provided to callback.
DWORD Tag; // User-defined id.
} Stream;
#if defined(MACINTOSH)
FSSpec* FileSpec; // Macintosh file specifier.
#endif
} QMIXWAVEPARAMS, *LPQMIXWAVEPARAMS;
_QMIXIMP
LPMIXWAVE
WINAPI
QSWaveMixOpenWaveEx(
HQMIXER hQMixer,
LPQMIXWAVEPARAMS lpWaveParams,
DWORD dwFlags
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixActivate(
HQMIXER hQMixer,
BOOL fActivate
);
//
// Options for dwFlags parameter in QSWaveMixPlayEx.
//
// Note: the QMIX_USELRUCHANNEL flag has two functions. When QMIX_CLEARQUEUE
// is also set, the channel that has been playing the longest (least-recently-
// used) is cleared and the buffer played. When QMIX_QUEUEWAVE is set, the
// channel that will first finish playing will be selected and the buffer
// queued to play. Of course, if an unused channel is found, it will be
// selected instead. If QMIX_WAIT has not been specified, then the channel
// number will be returned in the iChannel field.
//
#define QMIX_QUEUEWAVE 0x0000 // queue on channel
#define QMIX_CLEARQUEUE 0x0001 // clear queue on channel
#define QMIX_USELRUCHANNEL 0x0002 // see note above
#define QMIX_HIPRIORITY 0x0004
#define QMIX_HIGHPRIORITY QMIX_HIPRIORITY
#define QMIX_WAIT 0x0008 // queue to be played with other sounds
#define QMIX_IMMEDIATE 0x0020 // apply volume/pan changes without interpolation
#define QMIX_PLAY_SETEVENT 0x0100 // call SetEvent((HANDLE)callback) on completion
#define QMIX_PLAY_PULSEEVENT 0x0200 // call PulseEvent((HANDLE)callback) on completion
#define QMIX_PLAY_NOTIFYSTOP 0x0400 // do callback even when stopping or flushing sound
typedef void (CALLBACK *LPQMIXDONECALLBACK)(int iChannel, LPMIXWAVE lpWave, DWORD dwUser);
typedef struct QMIXPLAYPARAMS {
DWORD dwSize; // this must be set
LPMIXWAVE lpImage; // additional preprocessed audio for high performance
HWND hwndNotify; // if set, WOM_OPEN and WOM_DONE notification messages sent here
LPQMIXDONECALLBACK callback;
DWORD dwUser; // user data accompanying callback
LONG lStart;
LONG lStartLoop;
LONG lEndLoop;
LONG lEnd;
const QMIX_CHANNEL_PARAMS* lpChannelParams; // initialize with these parameters
}
QMIXPLAYPARAMS, *LPQMIXPLAYPARAMS;
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixPlayEx(
HQMIXER hQMixer, // the mixer handle
int iChannel, // channel number to be played on
DWORD dwFlags,
LPMIXWAVE lpMixWave, // sound to be played
int iLoops, // number of loops to be played (-1 = forever)
LPQMIXPLAYPARAMS lpParams // if NULL, defaults will be used
);
//
// Functions for controlling channels.
//
// The flag QMIX_WAIT can be used in the dwFlags argument of the
// channel parameter functions to defer the use of the new parameter
// until the next sound is played with QSWaveMixPlayEx. This allows
// us synchronize the changing of channel parameters with the beginning
// of a sound.
//
// The flag QMIX_USEONCE can be used to use the parameter only for the
// remainder of the current sound; afterwards the parameter reverts
// back to the channel's defaults. If no sound is playing, the
// parameter is used for the entire duration of the next sound.
// If both QMIX_USEONCE and QMIX_WAIT are used, then the property takes
// effect for the entire duration of the following sound.
//
// These flags can be used with the following functions:
// - QSWaveMixEnableChannel
// - QSWaveMixSetChannelParams
// - QSWaveMixSetChannelPriority
// - QSWaveMixSetDistanceMapping
// - QSWaveMixSetFrequency
// - QSWaveMixSetPan
// - QSWaveMixSetPanRate
// - QSWaveMixSetPolarPosition
// - QSWaveMixSetPosition
// - QSWaveMixSetSourceCone
// - QSWaveMixSetSourceCone2
// - QSWaveMixSetSourcePosition
// - QSWaveMixSetSourceVelocity
// - QSWaveMixSetVolume
//
#define QMIX_USEONCE 0x10 // settings are temporary
//
// Set the amount of time, in milliseconds, to effect a change in
// a channel property (e.g. volume, position). Non-zero values smooth
// out changes.
//
// Use QSWaveMixSetPanRate(hQMixer, iChannel, QMIX_WAIT|QMIX_USEONCE, 0)
// to implement sudden changes for the next sound without losing the
// smoothing function. Using QMIX_IMMEDIATE with QSWaveMixPlayEx also
// causes immediate changes while preserving subsequent pan interpolations.
//
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixSetPanRate(
HQMIXER hQMixer,
int iChannel,
DWORD dwFlags,
DWORD dwRate
);
//
// The pan value can be set to values from 0 to 60:
// 0 = full left,
// 15 = straight ahead (mono),
// 30 = full right,
// 45 = behind.
//
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixSetPan(
HQMIXER hQMixer,
int iChannel,
DWORD dwFlags,
int pan
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixSetVolume(
HQMIXER hQMixer,
int iChannel,
DWORD dwFlags,
int volume
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixSetPolarPosition(
HQMIXER hQMixer,
int iChannel,
DWORD dwFlags,
const QSPOLAR* lpQPosition
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixSetFrequency(
HQMIXER hQMixer,
int iChannel,
DWORD dwFlags,
DWORD dwFrequency
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixPauseChannel(
HQMIXER hQMixer,
int iChannel,
DWORD dwFlags
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixRestartChannel(
HQMIXER hQMixer,
int iChannel,
DWORD dwFlags
);
#define QMIX_STOP_FINISHLASTLOOP 0x1000
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixStopChannel(
HQMIXER hQMixer,
int iChannel,
DWORD dwFlags
);
//
// QSWaveMixEnableChannel: if mode==0, use conventional, high-performance
// stereo mixer. Non-zero modes imply some form of additional processing.
//
#define QMIX_CHANNEL_STEREO 0x0000 // perform stereo mixing
#define QMIX_CHANNEL_QSOUND 0x0001 // perform QSound localization (default)
#define QMIX_CHANNEL_DOPPLER 0x0002 // calculate velocity using position updates
#define QMIX_CHANNEL_RANGE 0x0004 // do range effects
#define QMIX_CHANNEL_ELEVATION 0x0008 // do elevation effects
#define QMIX_CHANNEL_NODOPPLERPITCH 0x0010 // disable Doppler pitch shift for this channel
#define QMIX_CHANNEL_PITCH_COPY 0x0000 // pitch shifting using copying (fastest)
#define QMIX_CHANNEL_PITCH_LINEAR 0x0100 // pitch shifting using linear interpolation (better but slower)
#define QMIX_CHANNEL_PITCH_SPLINE 0x0200 // pitch shifting using spline interpolation (better yet, but much slower)
#define QMIX_CHANNEL_PITCH_FILTER 0x0300 // pitch shifting using FIR filter (best, but slowest)
#define QMIX_CHANNEL_PITCH_MASK 0x0700 // bits reserved for pitch types
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixEnableChannel(
HQMIXER hQMixer,
int iChannel,
DWORD dwFlags,
int mode
);
//
// QSWaveMixEnable is equivalent to
// QSWaveMixEnableChannel(hQMixer, 0, QMIX_ALL, mode).
//
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixEnable(
HQMIXER hQMixer,
int mode
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixSetChannelPriority(
HQMIXER hQMixer,
int iChannel,
LONG lPriority,
DWORD dwFlags
);
//
// Status functions.
//
//
// Return a pointer to the internal DirectSound object. Handy for creating
// additional secondary buffers (but only if QMIX_CONFIG_USEPRIMARY was not
// set in QSWaveMixConfigureInit).
//
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixGetDirectSound(
HQMIXER hQMixer,
LPVOID FAR* lplpIDirectSound
);
//
// Return a pointer to the internal DirectSoundBuffer object.
//
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixGetDirectSoundBuffer(
HQMIXER hQMixer,
int iChannel,
LPVOID FAR* lplpIDirectSoundBuffer
);
//
// Return TRUE if there are no more buffers playing or queued on the channel.
// This is an alternative to waiting for a WOM_DONE message to be sent to a
// window.
//
_QMIXIMP
BOOL
WINAPI
QSWaveMixIsChannelDone(
HQMIXER hQMixer,
int iChannel
);
#define QMIX_CHANNELSTATUS_OPEN 0x01 // channel is open
#define QMIX_CHANNELSTATUS_QUEUED 0x02 // channel has a play request queued on it
#define QMIX_CHANNELSTATUS_PAUSED 0x04 // channel is paused
#define QMIX_CHANNELSTATUS_PLAYING 0x08 // channel is playing a sound
#define QMIX_CHANNELSTATUS_RESERVED 0x10 // channel is reserved from FindChannel for playing
_QMIXIMP DWORD WINAPI
QSWaveMixGetChannelStatus(
HQMIXER hQMixer,
int iChannel
);
#define QMIX_POSITION_BYTES 0
#define QMIX_POSITION_SAMPLES 1
#define QMIX_POSITION_MS 2
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixGetPlayPosition(
HQMIXER hQMixer,
int iChannel,
LPMIXWAVE* lplpWave,
LPDWORD lpdwPosition,
DWORD dwFlags
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixGetPan(
HQMIXER hQMixer,
int iChannel,
LPDWORD lpdwPan
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixGetVolume(
HQMIXER hQMixer,
int iChannel,
LPDWORD lpdwVolume
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixGetPanRate(
HQMIXER hQMixer,
int iChannel,
LPDWORD lpdwRate
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixGetFrequency(
HQMIXER hQMixer,
int iChannel,
LPDWORD lpdwFrequency
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixGetPolarPosition(
HQMIXER hQMixer,
int iChannel,
QSPOLAR* lpQPosition
);
//**********************************************************************
// Interface for 3d Cartesian Coordinate system.
//
// All measurements are in S.I. units, e.g. coordinates and room size are
// meters, velocity and speed of sound in m/s.
//
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixSetRoomSize(
HQMIXER hQMixer,
float roomSize,
DWORD dwFlags
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixSetSpeedOfSound(
HQMIXER hQMixer,
float speed,
DWORD dwFlags
);
typedef struct QMIX_DISTANCES {
UINT cbSize; // size of structure (needed for future versions)
float minDistance; // sounds are at full volume if closer than this
float maxDistance; // sounds are muted if further away than this
float scale; // relative amount to adjust rolloff by
} QMIX_DISTANCES, *LPQMIX_DISTANCES;
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixSetDistanceMapping(
HQMIXER hQMixer,
int iChannel,
DWORD dwFlags,
const LPQMIX_DISTANCES lpDistances
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixGetRoomSize(
HQMIXER hQMixer,
float* pfRoomSize
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixGetSpeedOfSound(
HQMIXER hQMixer,
float* pfSpeed
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixGetDistanceMapping(
HQMIXER hQMixer,
int iChannel,
LPQMIX_DISTANCES lpDistances
);
//
// Listener parameters.
//
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixSetListenerPosition(
HQMIXER hQMixer,
const QSVECTOR* position,
DWORD dwFlags
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixSetListenerOrientation(
HQMIXER hQMixer,
const QSVECTOR* direction,
const QSVECTOR* up,
DWORD dwFlags
);
//
// Velocity is used solely to set Doppler shift.
//
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixSetListenerVelocity(
HQMIXER hQMixer,
const QSVECTOR* velocity,
DWORD dwFlags
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixSetListenerRolloff(
HQMIXER hQMixer,
float rolloff,
DWORD dwFlags
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixGetListenerPosition(
HQMIXER hQMixer,
QSVECTOR* position
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixGetListenerOrientation(
HQMIXER hQMixer,
QSVECTOR* direction,
QSVECTOR* up
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixGetListenerVelocity(
HQMIXER hQMixer,
QSVECTOR* velocity
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixSetSourcePosition(
HQMIXER hQMixer,
int iChannel,
DWORD dwFlags,
const QSVECTOR* position
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixSetSourceVelocity(
HQMIXER hQMixer,
int iChannel,
DWORD dwFlags,
const QSVECTOR* velocity
);
//
// Listener will hear full volume if inside source's cone, given by
// orientation and angle. If outside, source will be attenuated by
// additional attenuation.
//
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixSetSourceCone(
HQMIXER hQMixer,
int iChannel,
DWORD dwFlags,
const QSVECTOR* orientation,
float coneAngle,
float ambient_db
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixSetSourceCone2(
HQMIXER hQMixer,
int iChannel,
DWORD dwFlags,
const QSVECTOR* orientation,
float innerConeAngle,
float outerConeAngle,
float ambient_db
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixGetSourcePosition(
HQMIXER hQMixer,
int iChannel,
QSVECTOR* position
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixGetSourceVelocity(
HQMIXER hQMixer,
int iChannel,
QSVECTOR* velocity
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixGetSourceCone(
HQMIXER hQMixer,
int iChannel,
QSVECTOR* orientation,
float* pfAngle,
float* ambient_db
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixGetSourceCone2(
HQMIXER hQMixer,
int iChannel,
QSVECTOR* orientation,
float* pfInnerAngle,
float* pfOuterAngle,
float* ambient_db
);
//**********************************************************************
// Profiling functions.
//
typedef struct QMIX_PROFILE {
DWORD dwCalls; // number of times mixer thread was called
DWORD dwMixing; // time spent mixing
DWORD dwAudioDriver; // time spent calling audio driver (e.g. DirectSound)
DWORD dwTotal; // total time in mixer thread
DWORD dwDuration; // time during test
} QMIX_PROFILE, *LPQMIX_PROFILE;
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixStartProfile(
HQMIXER hQMixer
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixStopProfile(
HQMIXER hQMixer,
LPQMIX_PROFILE lpProfile,
UINT cbProfile
);
//**********************************************************************
// Call QSWaveMixPump to force more mixing. Essential if mixer was
// configured with QMIX_CONFIG_NOTHREAD.
//
_QMIXIMP
void
WINAPI
QSWaveMixPump(
void);
//**********************************************************************
// Functions to shut down mixer.
//
// Note that, in versions 2.10 and later, that QSWaveMixFreeWave can be
// called with a null hQMixer if QSWaveMixCloseSession has been called.
//
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixFlushChannel(
HQMIXER hQMixer,
int iChannel,
DWORD dwFlags
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixCloseChannel(
HQMIXER hQMixer,
int iChannel,
DWORD dwFlags
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixFreeWave(
HQMIXER hQMixer,
LPMIXWAVE lpMixWave
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixCloseSession(
HQMIXER hQMixer
);
//
// Diagnostic codes available from QSWaveMixGetLastError. Equivalent strings
// can be recalled using QSWaveMixGetErrorText.
//
#define ERROR_QMIX_OK 0 // OK, no error.
#define ERROR_QMIX_CONFIGMISSING 1 // Can't find configuration (.ini) file.
#define ERROR_QMIX_MIXERHANDLE 2 // Mixer handle is null or invalid.
#define ERROR_QMIX_RESULTUNKNOWN 3 // Unknown error code.
#define ERROR_QMIX_MEMORY 4 // Out of memory.
#define ERROR_QMIX_EXCEPTIONUNKNOWN 5 // Unknown error.
#define ERROR_QMIX_WAVEOUTNONE 6 // No wave output devices.
#define ERROR_QMIX_DLLNAME 7 // Name of QMixer library is unavailable or invalid.
#define ERROR_QMIX_WAVEOUTINCOMPATIBLE 8 // The wave output device is incompatible with QMixer.
#define ERROR_QMIX_ACTIVATED 9 // Can't activate two QMixer sessions.
#define ERROR_QMIX_CHANNELINVALID 10 // Channel number is invalid.
#define ERROR_QMIX_OPENCHANNELFLAG 11 // Invalid flag for opening channel.
#define ERROR_QMIX_PANINVALID 12 // Invalid pan value.
#define ERROR_QMIX_NOTACTIVATED 13 // Mixer has not been activated.
#define ERROR_QMIX_CHANNELUNAVAILABLE 14 // No channels are available for playing this sound.
#define ERROR_QMIX_WAVERESOURCE 15 // Couldn't find or load resource containing wave data.
#define ERROR_QMIX_WAVEOPEN 16 // Couldn't open wave file.
#define ERROR_QMIX_WAVEFORMAT 17 // Format of wave data is corrupted.
#define ERROR_QMIX_ACMINVALID 18 // The ACM wave format couldn't be translated.
#define ERROR_QMIX_DSOUNDMISSING 19 // The DirectSound library dsound.dll could not be found.
#define ERROR_QMIX_DSOUNDCREATEADDR 20 // Could not find DirectSoundCreate function in dsound.dll.
#define ERROR_QMIX_DSOUNDCREATE 21 // Couldn't create DirectSound object.
#define ERROR_QMIX_DSOUNDCOOPERATIVE 22 // The cooperative level for DirectSound could not be set.
#define ERROR_QMIX_DSOUNDCAPS 23 // Couldn't determine DirectSound capabilities.
#define ERROR_QMIX_DSOUNDPRIMARY 24 // Couldn't create DirectSound primary buffer.
#define ERROR_QMIX_DSOUNDPRIMARYCAPS 25 // Couldn't determine DirectSound primary buffer capabilities.
#define ERROR_QMIX_DSOUNDFORMAT 26 // Couldn't set format of DirectSound output.
#define ERROR_QMIX_DSOUNDSECONDARY 27 // Couldn't create DirectSound secondary buffer.
#define ERROR_QMIX_DSOUNDPLAY 28 // Couldn't play DirectSound buffer.
#define ERROR_QMIX_WAVEOUTOPEN 29 // Wave output error while opening device.
#define ERROR_QMIX_WAVEOUTWRITE 30 // Wave output error while writing to device.
#define ERROR_QMIX_WAVEOUTCLOSE 31 // Wave output error while closing device.
#define ERROR_QMIX_PARAMPTR 32 // Parameter points to invalid location.
#define ERROR_QMIX_NOTIMPLEMENTED 33 // Feature is not implemented.
#define ERROR_QMIX_DSOUNDNODRIVER 34 // No DirectSound driver is available for use.
#define ERROR_QMIX_SMALLPRIMARY 35 // DirectSound primary buffer is too small.
#define ERROR_QMIX_UNKNOWNFORMAT 36 // Unknown sound file format.
#define ERROR_QMIX_DRIVENOTREADY 37 // Drive is not ready.
#define ERROR_QMIX_READERROR 38 // Error reading sound file.
#define ERROR_QMIX_UNKNOWNAIFC 39 // Unknown format of AIFF-C file.
#define ERROR_QMIX_MACRESOURCE 40 // Unable to obtain sampled sound data from resource.
#define ERROR_QMIX_SCINVALID 41 // The sound data format couldn't be translated.
#define ERROR_QMIX_MACSOUNDCAPS 42 // Couldn't retrieve Macintosh sound output capabilities.
#define ERROR_QMIX_MACCHANNEL 43 // Couldn't create sound channel.
#define ERROR_QMIX_MACCLEAR 44 // Couldn't clear sound channel.
#define ERROR_QMIX_MACPAUSE 45 // Couldn't pause sound channel.
#define ERROR_QMIX_MACQUEUE 46 // Couldn't queue data on sound channel.
#define ERROR_QMIX_MACRESUME 47 // Couldn't resume paused sound channel.
#define ERROR_QMIX_CATCH 48 // Caught unknown error.
#define ERROR_QMIX_HOLD 49 // Unable to prevent virtual memory from being paged.
#define ERROR_QMIX_INVALIDPARAM 50 // Invalid parameter.
#define ERROR_QMIX_DSB_STATUS 51 // Couldn't get DirectSound buffer status.
#define ERROR_QMIX_DSB_POSITION 52 // Couldn't get DirectSound buffer position.
#define ERROR_QMIX_DSOUNDMIXPRIMARY 53 // Can't mix into primary buffer (DirectSound driver is probably emulated).
/* set to byte packing so Win16 and Win32 structures will be the same */
#pragma pack(1)
typedef struct WAVEMIXINFO {
WORD wSize;
BYTE bVersionMajor;
BYTE bVersionMinor;
char szDate[12]; /* Mmm dd yyyy */
DWORD dwFormats; /* see waveOutGetDevCaps (wavemix requires synchronous device) */
}
WAVEMIXINFO, *PWAVEMIXINFO, FAR * LPWAVEMIXINFO;
_QMIXIMP
WORD
WINAPI
QSWaveMixGetInfo(
LPWAVEMIXINFO lpWaveMixInfo
);
//
// Constants, structure, and declaration for obsolete configuration function.
//
#define WMIX_CONFIG_CHANNELS 0x0001
#define WMIX_CONFIG_SAMPLINGRATE 0x0002
#define WMIX_CONFIG_DIRECTSOUND 0x0004
#define WMIX_CONFIG_USEPRIMARY 0x0008
#define WMIX_CONFIG_INPUTCHANNELS 0x0010
#define WMIX_CONFIG_OUTPUT 0x0020
#define WMIX_CONFIG_LATENCY 0x0040
#define WMIX_CONFIG_NOTHREAD 0x0080
#define WMIX_OUTPUT_WAVEOUT 0
#define WMIX_OUTPUT_DIRECTSOUND 1
#define WMIX_OUTPUT_NATIVEAUDIO 2 // not implemented
typedef struct MIXCONFIG {
WORD wSize;
DWORD dwFlags;
WORD wChannels; // 1=MONO, 2=STEREO
WORD wSamplingRate; // 11=11025, 22=22050, 44=44100 Hz
LPVOID lpIDirectSound;
WORD wInputChannels;
WORD wOutput;
WORD wLatency;
}
MIXCONFIG, *PMIXCONFIG, FAR * LPMIXCONFIG;
_QMIXIMP
HQMIXER
WINAPI
QSWaveMixConfigureInit(
LPMIXCONFIG lpConfig
);
//
// Obsolete wave opening function.
//
//
// Structure for opening waves that are already residing in memory.
// Note that the dwSamples parameter is a new field needed for using
// compressed data. To keep backwards compatibility, it is only used
// when QSWaveMixOpenWave is used with the QMIX_RESIDENT_COMPRESSED
// parameter.
//
#define QMIX_RESIDENT_COMPRESSED 0x0009 // QMIX_RESIDENT with valid dwSample parameter
typedef struct QMEMRESIDENT {
PCMWAVEFORMAT* pcm; // format; LPWAVEFORMATEX works here too
HPSTR lpData; // pointer to memory resident audio samples
DWORD dwDataSize; // length of data, in bytes
WORD tag; // user-defined id (used in MIXWAVE.szWaveFilename)
DWORD dwSamples; // number of samples in compressed wave
}
QMEMRESIDENT, * PQMEMRESIDENT, FAR * LPQMEMRESIDENT;
//
// Structure for a wave that will get audio from user callback function.
//
#if defined(_WIN32)
typedef void (__cdecl* LPQMIXSTREAMCALLBACK)(void* buffer, DWORD bytes, void* user);
#endif
#if defined(MACINTOSH)
typedef void (* LPQMIXSTREAMCALLBACK)(void* buffer, DWORD bytes, void* user);
#endif
typedef struct QINPUTSTREAM {
PCMWAVEFORMAT* pcm; // format of input data: must be in PCM
DWORD dwBlockLength; // preferred block length (bytes)
LPQMIXSTREAMCALLBACK callback;
// callback called when more data needed
void *user; // user data sent to callback
WORD tag;
}
QINPUTSTREAM, *PQINPUTSTREAM, FAR* LPQINPUTSTREAM;
//
// Open wave file. The szWaveFilename parameter is one of the
// following:
// - name of file (QMIX_FILE and QMIX_FILESTREAM flags),
// - name of resource (also need to set hInst) (QMIX_RESOURCE flag),
// - LPQMEMRESIDENT pointer cast to LPSTR (QMIX_RESIDENT flag),
// - LPQINPUTSTREAM pointer cast to LPSTR (QMIX_INPUTSTREAM flag),
// - LPMMIOINFO pointer cast to LPSTR (QMIX_MEMORY flag),
// - FSSpec* pointer cast to LPSTR (on Macintosh) (QMIX_FILESPEC flag),
//
_QMIXIMP
LPMIXWAVE
WINAPI
QSWaveMixOpenWave(
HQMIXER hQMixer,
LPSTR szWaveFilename, // see notes above
HINSTANCE hInst, // only required when QMIX_RESOURCE flag set
DWORD dwFlags
);
typedef struct QPOSITION {
int azimuth; // degrees; 0 is straight ahead, 90 is to the right
int range; // 0 to 32767; 0 is closest
int elevation; // -90 to 90 degrees
} QPOSITION, FAR* LPQPOSITION;
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixSetPosition(
HQMIXER hQMixer,
int iChannel,
DWORD dwFlags,
const QPOSITION* lpQPosition
);
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixGetPosition(
HQMIXER hQMixer,
int iChannel,
LPQPOSITION lpQPosition
);
//
// Obsolete play function.
//
#define QMIX_USEPOSITION 0x10 // use the MIXPLAYPARAMS.position field
typedef struct MIXPLAYPARAMS {
WORD wSize; // this must be set
HQMIXER hMixSession; // value returned by QSWaveMixInit or QSWaveMixConfigureInit
int iChannel; // channel number
LPMIXWAVE lpMixWave; // pointer returned by QSWaveMixOpenWave
HWND hWndNotify; // if set, WOM_OPEN and WOM_DONE notification messages sent here
DWORD dwFlags;
WORD wLoops; // 0xFFFF means loop forever
int qVolume; // initial volume; set to -1 to use default
int qPanPos; // initial pan position; set to -1 to use default
LPMIXWAVE lpImage; // set to preprocessed data for high performance
QPOSITION position; // initial position (used only if QMIX_USEPOSITION set)
}
MIXPLAYPARAMS, * PMIXPLAYPARAM, FAR* LPMIXPLAYPARAMS;
_QMIXIMP
MMRESULT
WINAPI
QSWaveMixPlay(
LPMIXPLAYPARAMS lpMixPlayParams
);
/* return to default packing */
#pragma pack()
//
// Obsolete constants.
//
#define WMIX_ALL QMIX_ALL
#define WMIX_NOREMIX QMIX_NOREMIX
#define WMIX_CONTROL_NOREMIX QMIX_CONTROL_NOREMIX
#define WMIX_OPENSINGLE QMIX_OPENSINGLE
#define WMIX_OPENALL QMIX_OPENALL
#define WMIX_OPENCOUNT QMIX_OPENCOUNT
#define WMIX_OPENAVAILABLE QMIX_OPENAVAILABLE
#define WMIX_FILE QMIX_FILE
#define WMIX_RESOURCE QMIX_RESOURCE
#define WMIX_MEMORY QMIX_MEMORY
#define WMIX_RESIDENT QMIX_RESIDENT
#define WMIX_FILESTREAM QMIX_FILESTREAM
#define WMIX_INPUTSTREAM QMIX_INPUTSTREAM
#define WMIX_QUEUEWAVE QMIX_QUEUEWAVE
#define WMIX_CLEARQUEUE QMIX_CLEARQUEUE
#define WMIX_USELRUCHANNEL QMIX_USELRUCHANNEL
#define WMIX_HIPRIORITY QMIX_HIPRIORITY
#define WMIX_HIGHPRIORITY QMIX_HIGHPRIORITY
#define WMIX_WAIT QMIX_WAIT
#define WMIX_USEPOSITION QMIX_USEPOSITION
#ifdef __cplusplus
}
#endif
#endif
Reference in New Issue View Git Blame Copy Permalink