/***************************************************************************
* DirectSoundEnumerateW [DSOUND.3]
*
* Enumerate all DirectSound drivers installed in the system
*
* PARAMS
* lpDSEnumCallback [I] Address of callback function.
* lpContext [I] Address of user defined context passed to callback function.
*
* RETURNS
* Success: DS_OK
* Failure: DSERR_INVALIDPARAM
*/
HRESULT WINAPI DirectSoundEnumerateW(
LPDSENUMCALLBACKW lpDSEnumCallback,
LPVOID lpContext )
{
unsigned devs, wod;
DSDRIVERDESC desc;
GUID guid;
int err;
WCHAR wDesc[MAXPNAMELEN];
WCHAR wName[MAXPNAMELEN];
TRACE("lpDSEnumCallback = %p, lpContext = %p\n",
lpDSEnumCallback, lpContext);
if (lpDSEnumCallback == NULL) {
WARN("invalid parameter: lpDSEnumCallback == NULL\n");
return DSERR_INVALIDPARAM;
}
setup_dsound_options();
devs = waveOutGetNumDevs();
if (devs > 0) {
if (GetDeviceID(&DSDEVID_DefaultPlayback, &guid) == DS_OK) {
static const WCHAR empty[] = { 0 };
for (wod = 0; wod < devs; ++wod) {
if (IsEqualGUID( &guid, &DSOUND_renderer_guids[wod] ) ) {
err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,ds_hw_accel));
if (err == DS_OK) {
TRACE("calling lpDSEnumCallback(NULL,\"%s\",\"%s\",%p)\n",
"Primary Sound Driver",desc.szDrvname,lpContext);
MultiByteToWideChar( CP_ACP, 0, "Primary Sound Driver", -1,
wDesc, sizeof(wDesc)/sizeof(WCHAR) );
if (lpDSEnumCallback(NULL, wDesc, empty, lpContext) == FALSE)
return DS_OK;
}
}
}
}
}
for (wod = 0; wod < devs; ++wod) {
err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,ds_hw_accel));
if (err == DS_OK) {
TRACE("calling lpDSEnumCallback(%s,\"%s\",\"%s\",%p)\n",
debugstr_guid(&DSOUND_renderer_guids[wod]),desc.szDesc,desc.szDrvname,lpContext);
MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1,
wDesc, sizeof(wDesc)/sizeof(WCHAR) );
wDesc[(sizeof(wDesc)/sizeof(WCHAR)) - 1] = '\0';
MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1,
wName, sizeof(wName)/sizeof(WCHAR) );
wName[(sizeof(wName)/sizeof(WCHAR)) - 1] = '\0';
if (lpDSEnumCallback(&DSOUND_renderer_guids[wod], wDesc, wName, lpContext) == FALSE)
return DS_OK;
}
}
return DS_OK;
}
static bool
set_tux_as_default_playback(void)
{
int i;
WAVEOUTCAPSA wa_device;
if (!waveOutGetNumDevs())
{
return false;
}
for (i = 0; i < waveOutGetNumDevs(); i++)
{
memset(&wa_device, 0, sizeof(wa_device));
if (waveOutGetDevCapsA(i, &wa_device, sizeof(wa_device)) == 0)
{
if (strstr(wa_device.szPname, "TuxDroid-Audio") != NULL)
{
if (waveOutMessage((HWAVEOUT)WAVE_MAPPER,
DRVM_MAPPER_PREFERRED_SET, i, 0) == 0)
{
return true;
}
}
}
}
return false;
}
static void SetSpeakerMode(bool speakerphone)
{
MMRESULT result = waveOutMessage((HWAVEOUT)0, MM_WOM_FORCESPEAKER, speakerphone, 0);
if (result != MMSYSERR_NOERROR) {
wchar_t buffer[200];
wsprintf(buffer, L"Could not do speakerphone switch, error=%u", result);
AfxMessageBox(buffer);
}
}
static cubeb_device_pref
winmm_query_preferred_out_device(UINT devid)
{
DWORD mmpref = WAVE_MAPPER, compref = WAVE_MAPPER, status;
cubeb_device_pref ret = CUBEB_DEVICE_PREF_NONE;
if (waveOutMessage((HWAVEOUT)(size_t)WAVE_MAPPER, DRVM_MAPPER_PREFERRED_GET,
(DWORD_PTR)&mmpref, (DWORD_PTR)&status) == MMSYSERR_NOERROR &&
devid == mmpref)
ret |= CUBEB_DEVICE_PREF_MULTIMEDIA | CUBEB_DEVICE_PREF_NOTIFICATION;
if (waveOutMessage((HWAVEOUT)(size_t)WAVE_MAPPER, DRVM_MAPPER_CONSOLEVOICECOM_GET,
(DWORD_PTR)&compref, (DWORD_PTR)&status) == MMSYSERR_NOERROR &&
devid == compref)
ret |= CUBEB_DEVICE_PREF_VOICE;
return ret;
}
OVR_PUBLIC_FUNCTION(ovrResult) ovr_GetAudioDeviceOutWaveId(UINT* deviceOutId)
{
if (!deviceOutId)
return ovrError_InvalidParameter;
if (waveOutMessage((HWAVEOUT)WAVE_MAPPER, DRVM_MAPPER_PREFERRED_GET, (DWORD_PTR)deviceOutId, NULL) != 0)
return ovrError_RuntimeException;
return ovrSuccess;
}
static bool
set_default_playback(int idx)
{
if (waveOutMessage((HWAVEOUT)WAVE_MAPPER, DRVM_MAPPER_PREFERRED_SET,
idx, 0) == 0)
{
return true;
}
return false;
}
static bool
get_default_playback_idx(int *idx)
{
int err;
DWORD po = -1;
DWORD pf = 0;
err = waveOutMessage((HWAVEOUT)WAVE_MAPPER, DRVM_MAPPER_PREFERRED_GET,
(DWORD)&po, (DWORD)&pf);
if (err == 0)
{
*idx = po;
return true;
}
return true;
}
OVR_PUBLIC_FUNCTION(ovrResult) ovr_GetAudioDeviceOutWaveId(UINT* deviceOutId)
{
REV_TRACE(ovr_GetAudioDeviceOutWaveId);
if (!deviceOutId)
return ovrError_InvalidParameter;
// Query and cache the result
static UINT cachedId = 0;
if (!cachedId)
{
#pragma warning( disable : 4312 )
if (waveOutMessage((HWAVEOUT)WAVE_MAPPER, DRVM_MAPPER_PREFERRED_GET, (DWORD_PTR)&cachedId, NULL) != 0)
return ovrError_AudioDeviceNotFound;
#pragma warning( default : 4312 )
}
*deviceOutId = cachedId;
return ovrSuccess;
}
int open_ep_mixers(px_mixer *Px, UINT deviceIn, UINT deviceOut)
{
PxEPInfo *info;
IMMDeviceEnumerator *denum = NULL;
IMMDevice *device = NULL;
HRESULT hr;
MMRESULT res;
LPWSTR idStr;
size_t idLen;
if (!initialize(Px)) {
goto fail;
}
info = (PxEPInfo *) Px->info;
info->inputEP = NULL;
info->outputEP = NULL;
// Create an audio endpoint device enumerator.
hr = CoCreateInstance(&CLSID_MMDeviceEnumerator,
NULL,
CLSCTX_ALL,
&IID_IMMDeviceEnumerator,
&denum);
if (FAILED(hr)) {
goto fail;
}
if (deviceIn == WAVE_MAPPER) {
hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(denum,
eCapture,
eMultimedia,
&device);
if (SUCCEEDED(hr)) {
hr = IMMDevice_Activate(device,
&IID_IAudioEndpointVolume,
CLSCTX_ALL,
NULL,
&info->inputEP);
IUnknown_Release(device);
}
if (FAILED(hr)) {
goto fail;
}
}
else {
res = waveInMessage((HWAVEIN)IntToPtr(deviceIn),
DRV_QUERYFUNCTIONINSTANCEIDSIZE,
(DWORD_PTR)&idLen,
(DWORD_PTR)NULL);
if (res != MMSYSERR_NOERROR) {
goto fail;
}
idStr = (WCHAR *) CoTaskMemAlloc(idLen + sizeof(WCHAR));
if (idStr == NULL) {
goto fail;
}
res = waveInMessage((HWAVEIN)IntToPtr(deviceIn),
DRV_QUERYFUNCTIONINSTANCEID,
(DWORD_PTR)idStr,
(DWORD_PTR)idLen);
if (res != MMSYSERR_NOERROR) {
CoTaskMemFree(idStr);
goto fail;
}
hr = IMMDeviceEnumerator_GetDevice(denum, idStr, &device);
if (SUCCEEDED(hr)) {
hr = IMMDevice_Activate(device,
&IID_IAudioEndpointVolume,
CLSCTX_ALL,
NULL,
&info->inputEP);
IUnknown_Release(device);
}
CoTaskMemFree(idStr);
if (FAILED(hr)) {
goto fail;
}
}
if (deviceOut == WAVE_MAPPER) {
hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(denum,
eRender,
eMultimedia,
&device);
if (SUCCEEDED(hr)) {
hr = IMMDevice_Activate(device,
&IID_IAudioEndpointVolume,
CLSCTX_ALL,
NULL,
&info->outputEP);
IUnknown_Release(device);
}
if (FAILED(hr)) {
goto fail;
}
}
else {
res = waveOutMessage((HWAVEOUT)IntToPtr(deviceOut),
DRV_QUERYFUNCTIONINSTANCEIDSIZE,
(DWORD_PTR)&idLen,
(DWORD_PTR)NULL);
if (res != MMSYSERR_NOERROR) {
goto fail;
}
idStr = (WCHAR *) CoTaskMemAlloc(idLen + sizeof(WCHAR));
if (idStr == NULL) {
goto fail;
}
res = waveOutMessage((HWAVEOUT)IntToPtr(deviceOut),
DRV_QUERYFUNCTIONINSTANCEID,
(DWORD_PTR)idStr,
(DWORD_PTR)idLen);
if (res != MMSYSERR_NOERROR) {
CoTaskMemFree(idStr);
goto fail;
}
hr = IMMDeviceEnumerator_GetDevice(denum, idStr, &device);
if (SUCCEEDED(hr)) {
hr = IMMDevice_Activate(device,
&IID_IAudioEndpointVolume,
CLSCTX_ALL,
NULL,
&info->outputEP);
IUnknown_Release(device);
}
CoTaskMemFree(idStr);
if (FAILED(hr)) {
goto fail;
}
}
if (denum) {
IUnknown_Release(denum);
}
return TRUE;
fail:
if (denum) {
IUnknown_Release(denum);
}
return cleanup(Px);
}
BOOL
FindWinMMDeviceIndex(
LPFILTERINFO CurInfo,
BOOL bRecord)
{
ULONG DeviceCount, Index;
WCHAR Buffer[MAX_PATH];
DWORD Size, dwResult;
if (bRecord)
DeviceCount = waveInGetNumDevs();
else
DeviceCount = waveOutGetNumDevs();
/* sanity check */
//ASSERT(DeviceCount);
for(Index = 0; Index < DeviceCount; Index++)
{
Size = 0;
/* query device interface size */
if (bRecord)
dwResult = waveInMessage(UlongToHandle(Index), DRV_QUERYDEVICEINTERFACESIZE, (DWORD_PTR)&Size, 0);
else
dwResult = waveOutMessage(UlongToHandle(Index), DRV_QUERYDEVICEINTERFACESIZE, (DWORD_PTR)&Size, 0);
if (dwResult != MMSYSERR_NOERROR)
{
DPRINT("Failed DRV_QUERYDEVICEINTERFACESIZE with %lx bRecord %u Index %u\n", dwResult, bRecord, Index);
continue;
}
/* sanity check */
ASSERT(Size < MAX_PATH);
/* now get the device interface string */
if (bRecord)
dwResult = waveInMessage(UlongToHandle(Index), DRV_QUERYDEVICEINTERFACE, (DWORD_PTR)Buffer, MAX_PATH);
else
dwResult = waveOutMessage(UlongToHandle(Index), DRV_QUERYDEVICEINTERFACE, (DWORD_PTR)Buffer, MAX_PATH);
if (dwResult != MMSYSERR_NOERROR)
{
DPRINT("Failed DRV_QUERYDEVICEINTERFACE with %lx bRecord %u Index %u\n", dwResult, bRecord, Index);
continue;
}
if (!wcsicmp(CurInfo->DevicePath, Buffer))
{
if (bRecord)
CurInfo->MappedId[0] = Index;
else
CurInfo->MappedId[1] = Index;
return TRUE;
}
}
DPRINT1("Failed to find device %ws bRecord %u Count %u\n", CurInfo->DevicePath, bRecord, DeviceCount);
// HACK
if (bRecord)
CurInfo->MappedId[0] = 0;
else
CurInfo->MappedId[1] = 0;
return TRUE;
}
static int winsnd_open(WinSndData *device, int devnumber, int bits,int stereo, int rate, int *minsz)
{
MMRESULT mr = NOERROR;
DWORD dwFlag;
int i;
int channel = 1;
if (stereo>0)
channel = stereo;
device->wfx.wFormatTag = WAVE_FORMAT_PCM;
device->wfx.cbSize = 0;
device->wfx.nAvgBytesPerSec = 16000;
device->wfx.nBlockAlign = 2;
device->wfx.nChannels = channel;
device->wfx.nSamplesPerSec = rate; /* 8000; */
device->wfx.wBitsPerSample = bits;
dwFlag = CALLBACK_FUNCTION;
if (devnumber != WAVE_MAPPER)
dwFlag = WAVE_MAPPED | CALLBACK_FUNCTION;
mr = waveOutOpen (&(device->waveoutdev), devnumber, &(device->wfx), (DWORD) SpeakerCallback,
(DWORD)device, dwFlag);
if (mr != NOERROR)
{
ms_warning("Failed to open device: trying default device. (waveOutOpen:0x%i)", mr);
dwFlag = CALLBACK_FUNCTION;
mr = waveOutOpen (&(device->waveoutdev), WAVE_MAPPER, &(device->wfx), (DWORD) SpeakerCallback,
(DWORD)device, dwFlag);
}
if (mr != NOERROR)
{
ms_warning("Failed to open windows sound device. (waveOutOpen:0x%i)", mr);
return -1;
}
#if 0
#define MM_WOM_SETSECONDARYGAINCLASS (WM_USER)
#define MM_WOM_SETSECONDARYGAINLIMIT (WM_USER+1)
#define MM_WOM_FORCESPEAKER (WM_USER+2)
bool bSpeaker=TRUE;
mr = waveOutMessage(device->waveoutdev, MM_WOM_FORCESPEAKER, bSpeaker, 0);
if (mr != NOERROR)
{
ms_warning("Failed to use earphone. (waveOutMessage:0x%i)", mr);
return -1;
}
typedef HRESULT (* _SetSpeakerMode)(DWORD mode);
_SetSpeakerMode pfnSetSpeakerMode;
HINSTANCE hDll = LoadLibrary(L"\\windows\\ossvcs.dll");
//_debug(L"ossvcs.dll h=%X",hDll);
pfnSetSpeakerMode = (_SetSpeakerMode)GetProcAddress(hDll,(LPCTSTR)218);
if (pfnSetSpeakerMode)
{
//_debug(L"SetSpeakerMode imported.");
DWORD sm = 0;
//_debug(L"SpeakerMode set to %d", sm);
pfnSetSpeakerMode(sm);
}
//else
//_debug(L"pfnSetSpeakerMode import failed.");
FreeLibrary(hDll);
#endif
#ifdef CONTROLVOLUME
mr = waveOutGetVolume(device->waveoutdev, &device->dwOldVolume);
if (mr != NOERROR)
{
ms_warning("Failed to get volume device. (waveOutGetVolume:0x%i)", mr);
}
mr = waveOutSetVolume(device->waveoutdev, 0xFFFFFFFF);
if (mr != NOERROR)
{
ms_warning("Failed to set volume device. (waveOutSetVolume:0x%i)", mr);
}
#endif
/* prepare windows buffers */
for (i = 0; i < MAX_WAVEHDR; i++)
{
memset (&(device->waveouthdr[i]), 0, sizeof (device->waveouthdr[i]));
device->waveouthdr[i].lpData = device->waveoutbuffer[i];
/* BUG: on ne connait pas la taille des frames a recevoir...
on utilise enc_frame_per_packet au lien de dec_frame_per_packet */
device->waveouthdr[i].dwBufferLength = device->rate/8000 * WINSND_BUFLEN;
/* 480 pour 98 (speex) */
device->waveouthdr[i].dwFlags = 0;
device->waveouthdr[i].dwUser = i;
mr = waveOutPrepareHeader (device->waveoutdev, &(device->waveouthdr[i]),
sizeof (device->waveouthdr[i]));
if (mr != MMSYSERR_NOERROR){
ms_warning("Failed to prepare windows sound device. (waveOutPrepareHeader:0x%i)", mr);
}
else
{
ms_message("Sound Header prepared %i for windows sound device. (waveOutPrepareHeader)", i);
}
}
/* Init Microphone device */
dwFlag = CALLBACK_FUNCTION;
if (devnumber != WAVE_MAPPER)
dwFlag = WAVE_MAPPED | CALLBACK_FUNCTION;
mr = waveInOpen (&(device->waveindev), devnumber, &(device->wfx),
(DWORD) WaveInCallback, (DWORD)device, dwFlag);
if (mr != NOERROR)
{
ms_warning("Failed to open device: trying default device. (waveInOpen:0x%i)", mr);
dwFlag = CALLBACK_FUNCTION;
mr = waveInOpen (&(device->waveindev), WAVE_MAPPER, &(device->wfx),
(DWORD) WaveInCallback, (DWORD)device, dwFlag);
}
if (mr != NOERROR)
{
ms_warning("Failed to prepare windows sound device. (waveInOpen:0x%i)", mr);
return -1;
}
for (i = 0; i < MAX_WAVEHDR; i++)
{
memset (&(device->waveinhdr[i]), 0, sizeof (device->waveinhdr[i]));
device->waveinhdr[i].lpData = device->waveinbuffer[i];
/* frameSize */
device->waveinhdr[i].dwBufferLength = device->rate/8000 * WINSND_BUFLEN;
device->waveinhdr[i].dwFlags = 0;
device->waveinhdr[i].dwUser = i;
mr = waveInPrepareHeader (device->waveindev, &(device->waveinhdr[i]),
sizeof (device->waveinhdr[i]));
if (mr == MMSYSERR_NOERROR){
mr = waveInAddBuffer (device->waveindev, &(device->waveinhdr[i]),
sizeof (device->waveinhdr[i]));
if (mr == MMSYSERR_NOERROR)
{
ms_message("Sound Header prepared %i for windows sound device. (waveInAddBuffer)", i);
}
else
{
ms_warning("Failed to prepare windows sound device. (waveInAddBuffer:0x%i)", mr);
}
}
else
{
ms_warning("Failed to prepare windows sound device. (waveInPrepareHeader:0x%i)", mr);
}
}
#ifndef DISABLE_SPEEX
#if 0
device->pst = speex_preprocess_state_init((device->rate/8000 * 320)/2, device->rate);
if (device->pst!=NULL) {
float f;
i=1;
speex_preprocess_ctl(device->pst, SPEEX_PREPROCESS_SET_VAD, &i);
i=1;
speex_preprocess_ctl(device->pst, SPEEX_PREPROCESS_SET_DENOISE, &i);
i=0;
speex_preprocess_ctl(device->pst, SPEEX_PREPROCESS_SET_AGC, &i);
f=8000;
speex_preprocess_ctl(device->pst, SPEEX_PREPROCESS_SET_AGC_LEVEL, &f);
i=0;
speex_preprocess_ctl(device->pst, SPEEX_PREPROCESS_SET_DEREVERB, &i);
f=.4;
speex_preprocess_ctl(device->pst, SPEEX_PREPROCESS_SET_DEREVERB_DECAY, &f);
f=.3;
speex_preprocess_ctl(device->pst, SPEEX_PREPROCESS_SET_DEREVERB_LEVEL, &f);
}
#endif
#endif
mr = waveInStart (device->waveindev);
if (mr != MMSYSERR_NOERROR)
{
ms_warning("Failed to start recording on windows sound device. (waveInStart:0x%i)", mr);
return -1;
}
*minsz=device->rate/8000 * 320;
return 0;
}
HRESULT DSOUND_ReopenDevice(DirectSoundDevice *device, BOOL forcewave)
{
HRESULT hres = DS_OK;
TRACE("(%p, %d)\n", device, forcewave);
if (device->driver)
{
IDsDriver_Close(device->driver);
if (device->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMOPEN)
waveOutClose(device->hwo);
IDsDriver_Release(device->driver);
device->driver = NULL;
device->buffer = NULL;
device->hwo = 0;
}
else if (device->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMOPEN)
waveOutClose(device->hwo);
/* DRV_QUERYDSOUNDIFACE is a "Wine extension" to get the DSound interface */
if (ds_hw_accel != DS_HW_ACCEL_EMULATION && !forcewave)
waveOutMessage((HWAVEOUT)device->drvdesc.dnDevNode, DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&device->driver, 0);
/* Get driver description */
if (device->driver) {
DWORD wod = device->drvdesc.dnDevNode;
hres = IDsDriver_GetDriverDesc(device->driver,&(device->drvdesc));
device->drvdesc.dnDevNode = wod;
if (FAILED(hres)) {
WARN("IDsDriver_GetDriverDesc failed: %08x\n", hres);
IDsDriver_Release(device->driver);
device->driver = NULL;
}
}
/* if no DirectSound interface available, use WINMM API instead */
if (!device->driver)
device->drvdesc.dwFlags = DSDDESC_DOMMSYSTEMOPEN | DSDDESC_DOMMSYSTEMSETFORMAT;
if (device->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMOPEN)
{
DWORD flags = CALLBACK_FUNCTION;
if (device->driver)
flags |= WAVE_DIRECTSOUND;
hres = mmErr(waveOutOpen(&(device->hwo), device->drvdesc.dnDevNode, device->pwfx, (DWORD_PTR)DSOUND_callback, (DWORD_PTR)device, flags));
if (FAILED(hres)) {
WARN("waveOutOpen failed\n");
if (device->driver)
{
IDsDriver_Release(device->driver);
device->driver = NULL;
}
return hres;
}
}
if (device->driver)
hres = IDsDriver_Open(device->driver);
return hres;
}
static HRESULT DSPROPERTY_DescriptionW(
LPVOID pPropData,
ULONG cbPropData,
PULONG pcbReturned )
{
PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA ppd = pPropData;
HRESULT err;
GUID dev_guid;
ULONG wod, wid, wodn, widn;
DSDRIVERDESC desc;
TRACE("pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
pPropData,cbPropData,pcbReturned);
TRACE("DeviceId=%s\n",debugstr_guid(&ppd->DeviceId));
if ( IsEqualGUID( &ppd->DeviceId , &GUID_NULL) ) {
/* default device of type specified by ppd->DataFlow */
if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) {
TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
ppd->DeviceId = DSDEVID_DefaultCapture;
} else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) {
TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
ppd->DeviceId = DSDEVID_DefaultPlayback;
} else {
WARN("DataFlow=Unknown(%d)\n", ppd->DataFlow);
return E_PROP_ID_UNSUPPORTED;
}
}
setup_dsound_options();
GetDeviceID(&ppd->DeviceId, &dev_guid);
wodn = waveOutGetNumDevs();
widn = waveInGetNumDevs();
wid = wod = dev_guid.Data4[7];
if (!memcmp(&dev_guid, &DSOUND_renderer_guids[0], sizeof(GUID)-1)
&& wod < wodn)
{
ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
ppd->WaveDeviceId = wod;
}
else if (!memcmp(&dev_guid, &DSOUND_capture_guids[0], sizeof(GUID)-1)
&& wid < widn)
{
ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
ppd->WaveDeviceId = wid;
}
else
{
WARN("Device not found\n");
return E_PROP_ID_UNSUPPORTED;
}
if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER)
err = waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,ds_hw_accel);
else
err = waveInMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,ds_hw_accel);
if (err != MMSYSERR_NOERROR)
{
WARN("waveMessage(DRV_QUERYDSOUNDDESC) failed!\n");
return E_PROP_ID_UNSUPPORTED;
}
else
{
/* FIXME: Still a memory leak.. */
int desclen, modlen;
static WCHAR wInterface[] = { 'I','n','t','e','r','f','a','c','e',0 };
modlen = MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, NULL, 0 );
desclen = MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, NULL, 0 );
ppd->Module = HeapAlloc(GetProcessHeap(),0,modlen*sizeof(WCHAR));
ppd->Description = HeapAlloc(GetProcessHeap(),0,desclen*sizeof(WCHAR));
ppd->Interface = wInterface;
if (!ppd->Description || !ppd->Module)
{
WARN("Out of memory\n");
HeapFree(GetProcessHeap(), 0, ppd->Description);
HeapFree(GetProcessHeap(), 0, ppd->Module);
ppd->Description = ppd->Module = NULL;
return E_OUTOFMEMORY;
}
MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, ppd->Module, modlen );
MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, ppd->Description, desclen );
}
ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
if (pcbReturned) {
*pcbReturned = sizeof(*ppd);
TRACE("*pcbReturned=%d\n", *pcbReturned);
}
return S_OK;
}
HRESULT
WINAPI
GetDeviceID(LPCGUID pGuidSrc, LPGUID pGuidDest)
{
ULONG DeviceID = ULONG_MAX, Flags;
MMRESULT Result;
LPFILTERINFO Filter;
if (!pGuidSrc || !pGuidDest)
{
/* invalid param */
return DSERR_INVALIDPARAM;
}
/* sanity check */
ASSERT(!IsEqualGUID(pGuidSrc, &GUID_NULL));
if (IsEqualGUID(&DSDEVID_DefaultPlayback, pGuidSrc) ||
IsEqualGUID(&DSDEVID_DefaultVoicePlayback, pGuidSrc))
{
Result = waveOutMessage(UlongToHandle(WAVE_MAPPER), DRVM_MAPPER_PREFERRED_GET, (DWORD_PTR)&DeviceID, (DWORD_PTR)&Flags);
if (Result != MMSYSERR_NOERROR || DeviceID == ULONG_MAX)
{
/* hack */
DPRINT1("Failed to get DRVM_MAPPER_PREFERRED_GET, using device 0\n");
DeviceID = 0;
}
if (!FindDeviceByMappedId(DeviceID, &Filter, TRUE))
{
/* device not found */
return DSERR_INVALIDPARAM;
}
/* copy device guid */
RtlMoveMemory(pGuidDest, &Filter->DeviceGuid[1], sizeof(GUID));
return DS_OK;
}
else if (IsEqualGUID(&DSDEVID_DefaultCapture, pGuidSrc) ||
IsEqualGUID(&DSDEVID_DefaultVoiceCapture, pGuidSrc))
{
Result = waveInMessage(UlongToHandle(WAVE_MAPPER), DRVM_MAPPER_PREFERRED_GET, (DWORD_PTR)&DeviceID, (DWORD_PTR)&Flags);
if (Result != MMSYSERR_NOERROR || DeviceID == ULONG_MAX)
{
/* hack */
DPRINT1("Failed to get DRVM_MAPPER_PREFERRED_GET, for record using device 0\n");
DeviceID = 0;
}
if (!FindDeviceByMappedId(DeviceID, &Filter, FALSE))
{
/* device not found */
return DSERR_INVALIDPARAM;
}
/* copy device guid */
RtlMoveMemory(pGuidDest, &Filter->DeviceGuid[0], sizeof(GUID));
return DS_OK;
}
if (!FindDeviceByGuid(pGuidSrc, &Filter))
{
/* unknown guid */
return DSERR_INVALIDPARAM;
}
/* done */
return DS_OK;
}
void TinyWaveOut::SendMessage(UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
waveOutMessage(hWaveOut, uMsg, dwParam1, dwParam2);
}
