winmm.odl

The code for this article was written for version 1.0 of the Active Template Library (ATL). The cu

        DWORD   nSamplesPerSec;    // sample rate
        DWORD   nAvgBytesPerSec;   // for buffer estimation
        WORD    nBlockAlign;       // block size of data
    } WAVEFORMAT;
    typedef WAVEFORMAT       *PWAVEFORMAT;
    typedef WAVEFORMAT NEAR *NPWAVEFORMAT;
    typedef WAVEFORMAT FAR  *LPWAVEFORMAT;

    // flags for wFormatTag field of WAVEFORMAT
    //define WAVE_FORMAT_PCM    1

    // specific waveform format structure for PCM data
    typedef struct pcmwaveformat_tag {
        WAVEFORMAT  wf;
        WORD        wBitsPerSample;
    } PCMWAVEFORMAT;
    typedef PCMWAVEFORMAT       *PPCMWAVEFORMAT;
    typedef PCMWAVEFORMAT NEAR *NPPCMWAVEFORMAT;
    typedef PCMWAVEFORMAT FAR  *LPPCMWAVEFORMAT;

    // waveform audio function prototypes
    UINT WINAPI waveOutGetNumDevs(void);
    UINT WINAPI waveOutGetDevCaps(UINT uDeviceID, WAVEOUTCAPS FAR* lpCaps,
        UINT uSize);
    UINT WINAPI waveOutGetVolume(UINT uDeviceID, DWORD FAR* lpdwVolume);
    UINT WINAPI waveOutSetVolume(UINT uDeviceID, DWORD dwVolume);
    UINT WINAPI waveOutGetErrorText(UINT uError, LPSTR lpText, UINT uSize);
    UINT WINAPI waveOutOpen(HWAVEOUT FAR* lphWaveOut, UINT uDeviceID,
        const WAVEFORMAT FAR* lpFormat, DWORD dwCallback, DWORD dwInstance, DWORD dwFlags);
    UINT WINAPI waveOutClose(HWAVEOUT hWaveOut);
    UINT WINAPI waveOutPrepareHeader(HWAVEOUT hWaveOut,
         WAVEHDR FAR* lpWaveOutHdr, UINT uSize);
    UINT WINAPI waveOutUnprepareHeader(HWAVEOUT hWaveOut,
        WAVEHDR FAR* lpWaveOutHdr, UINT uSize);
    UINT WINAPI waveOutWrite(HWAVEOUT hWaveOut, WAVEHDR FAR* lpWaveOutHdr,
        UINT uSize);
    UINT WINAPI waveOutPause(HWAVEOUT hWaveOut);
    UINT WINAPI waveOutRestart(HWAVEOUT hWaveOut);
    UINT WINAPI waveOutReset(HWAVEOUT hWaveOut);
    UINT WINAPI waveOutBreakLoop(HWAVEOUT hWaveOut);
    UINT WINAPI waveOutGetPosition(HWAVEOUT hWaveOut, MMTIME FAR* lpInfo,
        UINT uSize);
    UINT WINAPI waveOutGetPitch(HWAVEOUT hWaveOut, DWORD FAR* lpdwPitch);
    UINT WINAPI waveOutSetPitch(HWAVEOUT hWaveOut, DWORD dwPitch);
    UINT WINAPI waveOutGetPlaybackRate(HWAVEOUT hWaveOut, DWORD FAR* lpdwRate);
    UINT WINAPI waveOutSetPlaybackRate(HWAVEOUT hWaveOut, DWORD dwRate);
    UINT WINAPI waveOutGetID(HWAVEOUT hWaveOut, UINT FAR* lpuDeviceID);

    DWORD WINAPI waveOutMessage(HWAVEOUT hWaveOut, UINT uMessage, DWORD dw1, DWORD dw2);

    UINT WINAPI waveInGetNumDevs(void);
    UINT WINAPI waveInGetDevCaps(UINT uDeviceID, WAVEINCAPS FAR* lpCaps,
        UINT uSize);
    UINT WINAPI waveInGetErrorText(UINT uError, LPSTR lpText, UINT uSize);
    UINT WINAPI waveInOpen(HWAVEIN FAR* lphWaveIn, UINT uDeviceID,
        const WAVEFORMAT FAR* lpFormat, DWORD dwCallback, DWORD dwInstance, DWORD dwFlags);
    UINT WINAPI waveInClose(HWAVEIN hWaveIn);
    UINT WINAPI waveInPrepareHeader(HWAVEIN hWaveIn,
        WAVEHDR FAR* lpWaveInHdr, UINT uSize);
    UINT WINAPI waveInUnprepareHeader(HWAVEIN hWaveIn,
        WAVEHDR FAR* lpWaveInHdr, UINT uSize);
    UINT WINAPI waveInAddBuffer(HWAVEIN hWaveIn,
        WAVEHDR FAR* lpWaveInHdr, UINT uSize);
    UINT WINAPI waveInStart(HWAVEIN hWaveIn);
    UINT WINAPI waveInStop(HWAVEIN hWaveIn);
    UINT WINAPI waveInReset(HWAVEIN hWaveIn);
    UINT WINAPI waveInGetPosition(HWAVEIN hWaveIn, MMTIME FAR* lpInfo,
        UINT uSize);
    UINT WINAPI waveInGetID(HWAVEIN hWaveIn, UINT FAR* lpuDeviceID);

    DWORD WINAPI waveInMessage(HWAVEIN hWaveIn, UINT uMessage, DWORD dw1, DWORD dw2);
    */


    // ****** MIDI audio support *******

    /*
    // MIDI error return values
    //define MIDIERR_UNPREPARED   (MIDIERR_BASE + 0)   // header not prepared
    //define MIDIERR_STILLPLAYING  (MIDIERR_BASE + 1)   // still something playing
    //define MIDIERR_NOMAP        (MIDIERR_BASE + 2)   // no current map
    //define MIDIERR_NOTREADY     (MIDIERR_BASE + 3)   // hardware is still busy
    //define MIDIERR_NODEVICE     (MIDIERR_BASE + 4)   // port no longer connected
    //define MIDIERR_INVALIDSETUP  (MIDIERR_BASE + 5)   // invalid setup
    //define MIDIERR_LASTERROR    (MIDIERR_BASE + 5)   // last error in range

    // MIDI audio data types
    DECLARE_HANDLE(HMIDI);
    DECLARE_HANDLE(HMIDIIN);
    DECLARE_HANDLE(HMIDIOUT);
    typedef HMIDIIN FAR *LPHMIDIIN;
    typedef HMIDIOUT FAR *LPHMIDIOUT;
    typedef DRVCALLBACK MIDICALLBACK;
    typedef MIDICALLBACK FAR *LPMIDICALLBACK;
    //define MIDIPATCHSIZE  128
    typedef WORD PATCHARRAY[MIDIPATCHSIZE];
    typedef WORD FAR *LPPATCHARRAY;
    typedef WORD KEYARRAY[MIDIPATCHSIZE];
    typedef WORD FAR *LPKEYARRAY;

    // MIDI callback messages
    //define MIM_OPEN       MM_MIM_OPEN
    //define MIM_CLOSE      MM_MIM_CLOSE
    //define MIM_DATA       MM_MIM_DATA
    //define MIM_LONGDATA   MM_MIM_LONGDATA
    //define MIM_ERROR      MM_MIM_ERROR
    //define MIM_LONGERROR  MM_MIM_LONGERROR
    //define MOM_OPEN       MM_MOM_OPEN
    //define MOM_CLOSE      MM_MOM_CLOSE
    //define MOM_DONE       MM_MOM_DONE

    // device ID for MIDI mapper
    //define MIDIMAPPER    (-1)
    //define MIDI_MAPPER    (-1)

    // flags for wFlags parm of midiOutCachePatches(), midiOutCacheDrumPatches()
    //define MIDI_CACHE_ALL     1
    //define MIDI_CACHE_BESTFIT 2
    //define MIDI_CACHE_QUERY   3
    //define MIDI_UNCACHE       4

    // MIDI output device capabilities structure
    typedef struct midioutcaps_tag {
        UINT    wMid;                  // manufacturer ID
        UINT    wPid;                  // product ID
        VERSION vDriverVersion;        // version of the driver
        char    szPname[MAXPNAMELEN];  // product name (NULL terminated string)
        UINT    wTechnology;           // type of device
        UINT    wVoices;               // # of voices (internal synth only)
        UINT    wNotes;                // max # of notes (internal synth only)
        UINT    wChannelMask;          // channels used (internal synth only)
        DWORD   dwSupport;             // functionality supported by driver
    } MIDIOUTCAPS;
    typedef MIDIOUTCAPS       *PMIDIOUTCAPS;
    typedef MIDIOUTCAPS NEAR *NPMIDIOUTCAPS;
    typedef MIDIOUTCAPS FAR  *LPMIDIOUTCAPS;

    // flags for wTechnology field of MIDIOUTCAPS structure
    //define MOD_MIDIPORT   1  // output port
    //define MOD_SYNTH      2  // generic internal synth
    //define MOD_SQSYNTH    3  // square wave internal synth
    //define MOD_FMSYNTH    4  // FM internal synth
    //define MOD_MAPPER     5  // MIDI mapper

    // flags for dwSupport field of MIDIOUTCAPS structure
    //define MIDICAPS_VOLUME         0x0001  // supports volume control
    //define MIDICAPS_LRVOLUME       0x0002  // separate left-right volume control
    //define MIDICAPS_CACHE          0x0004

    // MIDI output device capabilities structure
    typedef struct midiincaps_tag {
        UINT    wMid;                  // manufacturer ID
        UINT    wPid;                  // product ID
        VERSION vDriverVersion;        // version of the driver
        char    szPname[MAXPNAMELEN];  // product name (NULL terminated string)
    } MIDIINCAPS;
    typedef MIDIINCAPS      *PMIDIINCAPS;
    typedef MIDIINCAPS NEAR *NPMIDIINCAPS;
    typedef MIDIINCAPS FAR  *LPMIDIINCAPS;

    // MIDI data block header
    typedef struct midihdr_tag {
        LPSTR       lpData;               // pointer to locked data block
        DWORD       dwBufferLength;       // length of data in data block
        DWORD       dwBytesRecorded;      // used for input only
        DWORD       dwUser;               // for client's use
        DWORD       dwFlags;              // assorted flags (see defines)
        struct midihdr_tag far *lpNext;   // reserved for driver
        DWORD       reserved;             // reserved for driver
    } MIDIHDR;
    typedef MIDIHDR       *PMIDIHDR;
    typedef MIDIHDR NEAR *NPMIDIHDR;
    typedef MIDIHDR FAR  *LPMIDIHDR;

    // flags for dwFlags field of MIDIHDR structure
    //define MHDR_DONE      0x00000001       // done bit
    //define MHDR_PREPARED  0x00000002       // set if header prepared
    //define MHDR_INQUEUE   0x00000004       // reserved for driver

    // MIDI function prototypes
    UINT WINAPI midiOutGetNumDevs(void);
    UINT WINAPI midiOutGetDevCaps(UINT uDeviceID,
        MIDIOUTCAPS FAR* lpCaps, UINT uSize);
    UINT WINAPI midiOutGetVolume(UINT uDeviceID, DWORD FAR* lpdwVolume);
    UINT WINAPI midiOutSetVolume(UINT uDeviceID, DWORD dwVolume);
    UINT WINAPI midiOutGetErrorText(UINT uError, LPSTR lpText, UINT uSize);
    UINT WINAPI midiOutOpen(HMIDIOUT FAR* lphMidiOut, UINT uDeviceID,
        DWORD dwCallback, DWORD dwInstance, DWORD dwFlags);
    UINT WINAPI midiOutClose(HMIDIOUT hMidiOut);
    UINT WINAPI midiOutPrepareHeader(HMIDIOUT hMidiOut,
        MIDIHDR FAR* lpMidiOutHdr, UINT uSize);
    UINT WINAPI midiOutUnprepareHeader(HMIDIOUT hMidiOut,
        MIDIHDR FAR* lpMidiOutHdr, UINT uSize);
    UINT WINAPI midiOutShortMsg(HMIDIOUT hMidiOut, DWORD dwMsg);
    UINT WINAPI midiOutLongMsg(HMIDIOUT hMidiOut,
        MIDIHDR FAR* lpMidiOutHdr, UINT uSize);
    UINT WINAPI midiOutReset(HMIDIOUT hMidiOut);
    UINT WINAPI midiOutCachePatches(HMIDIOUT hMidiOut,
        UINT uBank, WORD FAR* lpwPatchArray, UINT uFlags);
    UINT WINAPI midiOutCacheDrumPatches(HMIDIOUT hMidiOut,
        UINT uPatch, WORD FAR* lpwKeyArray, UINT uFlags);
    UINT WINAPI midiOutGetID(HMIDIOUT hMidiOut, UINT FAR* lpuDeviceID);

    DWORD WINAPI midiOutMessage(HMIDIOUT hMidiOut, UINT uMessage, DWORD dw1, DWORD dw2);

    UINT WINAPI midiInGetNumDevs(void);
    UINT WINAPI midiInGetDevCaps(UINT uDeviceID,
        LPMIDIINCAPS lpCaps, UINT uSize);
    UINT WINAPI midiInGetErrorText(UINT uError, LPSTR lpText, UINT uSize);
    UINT WINAPI midiInOpen(HMIDIIN FAR* lphMidiIn, UINT uDeviceID,
        DWORD dwCallback, DWORD dwInstance, DWORD dwFlags);
    UINT WINAPI midiInClose(HMIDIIN hMidiIn);
    UINT WINAPI midiInPrepareHeader(HMIDIIN hMidiIn,
        MIDIHDR FAR* lpMidiInHdr, UINT uSize);
    UINT WINAPI midiInUnprepareHeader(HMIDIIN hMidiIn,
        MIDIHDR FAR* lpMidiInHdr, UINT uSize);
    UINT WINAPI midiInAddBuffer(HMIDIIN hMidiIn,
        MIDIHDR FAR* lpMidiInHdr, UINT uSize);
    UINT WINAPI midiInStart(HMIDIIN hMidiIn);
    UINT WINAPI midiInStop(HMIDIIN hMidiIn);
    UINT WINAPI midiInReset(HMIDIIN hMidiIn);
    UINT WINAPI midiInGetID(HMIDIIN hMidiIn, UINT FAR* lpuDeviceID);

    DWORD WINAPI midiInMessage(HMIDIIN hMidiIn, UINT uMessage, DWORD dw1, DWORD dw2);
    */

    // ****** Auxiliary audio support ******

    /*
    // device ID for aux device mapper
    //define AUX_MAPPER    (-1)

    // Auxiliary audio device capabilities structure
    typedef struct auxcaps_tag {
        UINT    wMid;                  // manufacturer ID
        UINT    wPid;                  // product ID
        VERSION vDriverVersion;        // version of the driver
        char    szPname[MAXPNAMELEN];  // product name (NULL terminated string)
        UINT    wTechnology;           // type of device
        DWORD   dwSupport;             // functionality supported by driver
    } AUXCAPS;
    typedef AUXCAPS       *PAUXCAPS;
    typedef AUXCAPS NEAR *NPAUXCAPS;
    typedef AUXCAPS FAR  *LPAUXCAPS;

    // flags for wTechnology field in AUXCAPS structure
    //define AUXCAPS_CDAUDIO    1      // audio from internal CD-ROM drive
    //define AUXCAPS_AUXIN     2       // audio from auxiliary input jacks

    // flags for dwSupport field in AUXCAPS structure
    //define AUXCAPS_VOLUME         0x0001  // supports volume control
    //define AUXCAPS_LRVOLUME       0x0002  // separate left-right volume control

    // auxiliary audio function prototypes
    UINT WINAPI auxGetNumDevs(void);
    UINT WINAPI auxGetDevCaps(UINT uDeviceID, AUXCAPS FAR* lpCaps, UINT uSize);
    UINT WINAPI auxSetVolume(UINT uDeviceID, DWORD dwVolume);
    UINT WINAPI auxGetVolume(UINT uDeviceID, DWORD FAR* lpdwVolume);

    DWORD WINAPI auxOutMessage(UINT uDeviceID, UINT uMessage, DWORD dw1, DWORD dw2);
    */


    // ********** Timer support ********

    /* Omit all except timeGetTime
    */