WadWASAPI.h

Go to the documentation of this file.

/*
 * This file is part of the Wave Arts VQE library.
 * Copyright (C) 2011 Wave Arts, Inc. (http://wavearts.com)
 *
 * VQE is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * VQE is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * A copy of the GNU General Public License is included with VQE,
 * and can be found online at <http://www.gnu.org/licenses/>.
 *
 * If you'd like to distribute a closed-source product which uses VQE,
 * you must obtain a commercial VQE license from Wave Arts.
 */
//
// WaAudioDev C++ wrapper around Windows Audio Services API (WASAPI).
//
// Bill Gardner, Jun, 2011
//



#ifndef _WAD_WASAPI_H
#define _WAD_WASAPI_H

#include "WaAudioDev.h"
#include "SampleFifo.h"
#include "WadResPort.h"
#include "WadConvPort.h"
#include <MMDeviceAPI.h>
#include <AudioClient.h>
#include <AudioPolicy.h>

#define USE_SIMPLE_OUT_VOL      1       

#define CLOCK_TEST      0       

typedef struct {
        LPWSTR id;                      
        WadDevInfo info;        
} WASAPIDevInfo;

class WadWASAPI : public WaAudioDev {
protected:
        AUDCLNT_SHAREMODE shareMode;    
        ERole role;                                             
        // device discovery
        IMMDeviceEnumerator *pEnumerator;       
        int numDev;                                     
        WASAPIDevInfo *devTab;          

        bool GetDeviceName(IMMDevice *device, char *devName, size_t len);
        int defaultInDev;                       
        int defaultOutDev;                      
        // streaming
        IMMDevice *pCaptureDevice;      
        IMMDevice *pRenderDevice;       
        IAudioClient *pInAudioClient;   
        IAudioClient *pOutAudioClient;  
        IAudioCaptureClient *pCaptureClient;    
        IAudioRenderClient *pRenderClient;              
        IAudioClock *pInAudioClock;             
        UINT64 inFrequency;                             
        IAudioClock *pOutAudioClock;    
        UINT64 outFrequency;                    
#if CLOCK_TEST
        UINT64 startInTime;
        UINT64 startInPos;
        UINT64 startOutTime;
        UINT64 startOutPos;
#endif
#if USE_SIMPLE_OUT_VOL
        ISimpleAudioVolume *pOutSimpleAudioVolume;      
#endif
        UINT32 inFrameCount;    
        UINT32 outFrameCount;   
        bool inNeedsConversion;         
        bool outNeedsConversion;        
        void *inBuf;            
        void *outBuf;           
        SampleFifo *inFifo;     
        void *inFifoBuf;        
        WAVEFORMATEX inWavFmt;  
        WAVEFORMATEX outWavFmt; 
        HANDLE hRenderEvent;    
        HANDLE hCaptureEvent;   
        HANDLE hQuitEvent;              
        HANDLE hThread;                 
        WadCallbackFn *appInFn; 
        WadCallbackFn *appOutFn;        
        void *appArg;           
        // Closest parameters: set these when WASAPI can't support format,
        // caller will fetch via GetClosestBlah()
        WadStreamFormat closestInFmt;   
        WadStreamFormat closestOutFmt;  

        void CloseInternal();
        REFERENCE_TIME GetDevicePeriodMultiple(REFERENCE_TIME minTime, REFERENCE_TIME devicePeriod);
        bool CalculateBufferTimes(IAudioClient *audioClient, bool isInput,
                REFERENCE_TIME *pBufferTime, REFERENCE_TIME *pDevicePeriod);
        HRESULT IsFormatSupported(IAudioClient *client, WAVEFORMATEX *pFormat,
                WAVEFORMATEX **ppClosestMatch);
        int AccessVol(int devId, bool isOutput, bool setVol, float *pVol);

public:
        WadWASAPI(AUDCLNT_SHAREMODE shareMode = AUDCLNT_SHAREMODE_SHARED, ERole role = eCommunications);
        ~WadWASAPI();
        WadAPI GetAPI();
        int Init();

        // implement WaAudioDev
        virtual int GetNumDevices(int *pNumDev);
        virtual int GetDevInfo(int devId, WadDevInfo *pInfo);
        virtual int GetDefaultInDevId(int *pId);
        virtual int GetDefaultOutDevId(int *pId);
        virtual int Open(WadParam *param, WadCallbackFn *inFn, WadCallbackFn *outFn, void *arg);
        virtual int Start();
        virtual int Stop();
        virtual void Close();
        virtual void Wait();
        virtual bool IsRunning();
        virtual int SetVol(int devId, bool isOutput, float vol);
        virtual int GetVol(int devId, bool isOutput, float *pVol);
        virtual int GetClosestFormat(bool isOutput, WadStreamFormat *pFormat);
        virtual int GetBufTime(bool isOutput, int *pBufTimeMsec);
        DWORD Thread();

};

#if 0

//
// Aborted effort to clean up the Open hack in WadResWASAPI. The idea is to
// define WaAudioDev::GetPort which returns the port for the device.
// So a derived device can set up additional processing, like sample
// rate conversion, format conversion, etc., by providing a different
// port. The device itself implement WaAudioDevPort, which is the
// raw device without conversion. The problem with this method is that
// the caller has to do:
// wad = new WaAudioDev(...);
// port = wad->GetPort();
// port->Open(...)
// It's a lot cleaner to just call wad->Open(). So the hack stays.
//
class WadResWASAPIPort : public WaAudioDevPortObj
{
protected:
public:
        WadResWASAPIPort(WaAudioDevPort *devPort);
        ~WadResWASAPIPort();
        int Open(WadParam *param, WadCallbackFn *inFn, WadCallbackFn *outFn, void *arg);
        void Close();
};

#endif

class WadResWASAPI : public WadWASAPI
{
protected:
        WadResPort *resPort;            
        bool openingViaResPort;         
        bool closingViaResPort;         
        WadConvPort *convPort;          

public:
        WadResWASAPI();
        ~WadResWASAPI();

        int Open(WadParam *param, WadCallbackFn *inFn, WadCallbackFn *outFn, void *arg);
        void Close();
};

#endif