wine/dlls/winecoreaudio.drv/mixer.c

1034 lines
36 KiB
C
Raw Normal View History

/*
* Sample MIXER Wine Driver for Mac OS X (based on OSS mixer)
*
* Copyright 1997 Marcus Meissner
* 1999,2001 Eric Pouech
* 2006,2007 Emmanuel Maillard
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "config.h"
#include "wine/port.h"
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#define NONAMELESSUNION
#define NONAMELESSSTRUCT
#include "windef.h"
#include "winbase.h"
#include "winnls.h"
#include "mmddk.h"
#include "coreaudio.h"
#include "wine/unicode.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(mixer);
#if defined(HAVE_COREAUDIO_COREAUDIO_H)
#include <CoreAudio/CoreAudio.h>
#include <CoreFoundation/CoreFoundation.h>
#define WINE_MIXER_NAME "CoreAudio Mixer"
#define InputDevice (1 << 0)
#define OutputDevice (1 << 1)
#define IsInput(dir) ((dir) & InputDevice)
#define IsOutput(dir) ((dir) & OutputDevice)
#define ControlsPerLine 2 /* number of control per line : volume & (mute | onoff) */
#define IDControlVolume 0
#define IDControlMute 1
typedef struct tagMixerLine
{
char *name;
int direction;
int numChannels;
int componentType;
AudioDeviceID deviceID;
} MixerLine;
typedef struct tagMixerCtrl
{
DWORD dwLineID;
MIXERCONTROLW ctrl;
} MixerCtrl;
typedef struct tagCoreAudio_Mixer
{
MIXERCAPSW caps;
MixerCtrl *mixerCtrls;
MixerLine *lines;
DWORD numCtrl;
} CoreAudio_Mixer;
static CoreAudio_Mixer mixer;
static int numMixers = 1;
/**************************************************************************
*/
static const char * getMessage(UINT uMsg)
{
static char str[64];
#define MSG_TO_STR(x) case x: return #x;
switch (uMsg) {
MSG_TO_STR(DRVM_INIT);
MSG_TO_STR(DRVM_EXIT);
MSG_TO_STR(DRVM_ENABLE);
MSG_TO_STR(DRVM_DISABLE);
MSG_TO_STR(MXDM_GETDEVCAPS);
MSG_TO_STR(MXDM_GETLINEINFO);
MSG_TO_STR(MXDM_GETNUMDEVS);
MSG_TO_STR(MXDM_OPEN);
MSG_TO_STR(MXDM_CLOSE);
MSG_TO_STR(MXDM_GETLINECONTROLS);
MSG_TO_STR(MXDM_GETCONTROLDETAILS);
MSG_TO_STR(MXDM_SETCONTROLDETAILS);
}
#undef MSG_TO_STR
sprintf(str, "UNKNOWN(%08x)", uMsg);
return str;
}
static const char * getControlType(DWORD dwControlType)
{
static char str[64];
#define TYPE_TO_STR(x) case x: return #x;
switch (dwControlType) {
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_CUSTOM);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_BOOLEANMETER);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_SIGNEDMETER);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_PEAKMETER);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_UNSIGNEDMETER);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_BOOLEAN);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_ONOFF);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MUTE);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MONO);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_LOUDNESS);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_STEREOENH);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_BASS_BOOST);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_BUTTON);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_DECIBELS);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_SIGNED);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_UNSIGNED);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_PERCENT);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_SLIDER);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_PAN);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_QSOUNDPAN);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_FADER);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_VOLUME);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_BASS);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_TREBLE);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_EQUALIZER);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_SINGLESELECT);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MUX);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MIXER);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MICROTIME);
TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MILLITIME);
}
#undef TYPE_TO_STR
sprintf(str, "UNKNOWN(%08x)", dwControlType);
return str;
}
static const char * getComponentType(DWORD dwComponentType)
{
static char str[64];
#define TYPE_TO_STR(x) case x: return #x;
switch (dwComponentType) {
TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_UNDEFINED);
TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_DIGITAL);
TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_LINE);
TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_MONITOR);
TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_SPEAKERS);
TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_HEADPHONES);
TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_TELEPHONE);
TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_WAVEIN);
TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_VOICEIN);
TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED);
TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_DIGITAL);
TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_LINE);
TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE);
TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER);
TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC);
TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_TELEPHONE);
TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_PCSPEAKER);
TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT);
TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_AUXILIARY);
TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_ANALOG);
}
#undef TYPE_TO_STR
sprintf(str, "UNKNOWN(%08x)", dwComponentType);
return str;
}
static const char * getTargetType(DWORD dwType)
{
static char str[64];
#define TYPE_TO_STR(x) case x: return #x;
switch (dwType) {
TYPE_TO_STR(MIXERLINE_TARGETTYPE_UNDEFINED);
TYPE_TO_STR(MIXERLINE_TARGETTYPE_WAVEOUT);
TYPE_TO_STR(MIXERLINE_TARGETTYPE_WAVEIN);
TYPE_TO_STR(MIXERLINE_TARGETTYPE_MIDIOUT);
TYPE_TO_STR(MIXERLINE_TARGETTYPE_MIDIIN);
TYPE_TO_STR(MIXERLINE_TARGETTYPE_AUX);
}
#undef TYPE_TO_STR
sprintf(str, "UNKNOWN(%08x)", dwType);
return str;
}
/* FIXME is there a better way ? */
static DWORD DeviceComponentType(char *name)
{
if (strcmp(name, "Built-in Microphone") == 0)
return MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE;
if (strcmp(name, "Built-in Line Input") == 0)
return MIXERLINE_COMPONENTTYPE_SRC_LINE;
if (strcmp(name, "Built-in Output") == 0)
return MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
return MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED;
}
static BOOL DeviceHasMute(AudioDeviceID deviceID, Boolean isInput)
{
Boolean writable = false;
OSStatus err = noErr;
err = AudioDeviceGetPropertyInfo(deviceID, 0, isInput, kAudioDevicePropertyMute, NULL, NULL);
if (err == noErr)
{
/* check if we can set it */
err = AudioDeviceGetPropertyInfo(deviceID, 0, isInput, kAudioDevicePropertyMute, NULL, &writable);
if (err == noErr)
return writable;
}
return FALSE;
}
/*
* Getters
*/
static BOOL MIX_LineGetVolume(DWORD lineID, DWORD channels, Float32 *left, Float32 *right)
{
MixerLine *line = &mixer.lines[lineID];
UInt32 size = sizeof(Float32);
OSStatus err = noErr;
*left = *right = 0.0;
err = AudioDeviceGetProperty(line->deviceID, 1, IsInput(line->direction), kAudioDevicePropertyVolumeScalar, &size, left);
if (err != noErr)
return FALSE;
if (channels == 2)
{
size = sizeof(Float32);
err = AudioDeviceGetProperty(line->deviceID, 2, IsInput(line->direction), kAudioDevicePropertyVolumeScalar, &size, right);
if (err != noErr)
return FALSE;
}
TRACE("lineID %d channels %d return left %f right %f\n", lineID, channels, *left, *right);
return (err == noErr);
}
static BOOL MIX_LineGetMute(DWORD lineID, BOOL *muted)
{
MixerLine *line = &mixer.lines[lineID];
UInt32 size = sizeof(UInt32);
UInt32 val = 0;
OSStatus err = noErr;
err = AudioDeviceGetProperty(line->deviceID, 0, IsInput(line->direction), kAudioDevicePropertyMute, &size, &val);
*muted = val;
return (err == noErr);
}
/*
* Setters
*/
static BOOL MIX_LineSetVolume(DWORD lineID, DWORD channels, Float32 left, Float32 right)
{
MixerLine *line = &mixer.lines[lineID];
UInt32 size = sizeof(Float32);
OSStatus err = noErr;
TRACE("lineID %d channels %d left %f right %f\n", lineID, channels, left, right);
if (channels == 2)
{
err = AudioDeviceSetProperty(line->deviceID, NULL, 1, IsInput(line->direction), kAudioDevicePropertyVolumeScalar, size, &left);
if (err != noErr)
return FALSE;
err = AudioDeviceSetProperty(line->deviceID, NULL, 2, IsInput(line->direction), kAudioDevicePropertyVolumeScalar, size, &right);
}
else
{
/*
FIXME Using master channel failed ?? return kAudioHardwareUnknownPropertyError
err = AudioDeviceSetProperty(line->deviceID, NULL, 0, IsInput(line->direction), kAudioDevicePropertyVolumeScalar, size, &left);
*/
right = left;
err = AudioDeviceSetProperty(line->deviceID, NULL, 1, IsInput(line->direction), kAudioDevicePropertyVolumeScalar, size, &left);
if (err != noErr)
return FALSE;
err = AudioDeviceSetProperty(line->deviceID, NULL, 2, IsInput(line->direction), kAudioDevicePropertyVolumeScalar, size, &right);
}
return (err == noErr);
}
static BOOL MIX_LineSetMute(DWORD lineID, BOOL mute)
{
MixerLine *line = &mixer.lines[lineID];
UInt32 val = mute;
UInt32 size = sizeof(UInt32);
OSStatus err = noErr;
err = AudioDeviceSetProperty(line->deviceID, 0, 0, IsInput(line->direction), kAudioDevicePropertyMute, size, &val);
return (err == noErr);
}
static void MIX_FillControls(void)
{
int i;
int ctrl = 0;
MixerLine *line;
for (i = 0; i < mixer.caps.cDestinations; i++)
{
line = &mixer.lines[i];
mixer.mixerCtrls[ctrl].dwLineID = i;
mixer.mixerCtrls[ctrl].ctrl.cbStruct = sizeof(MIXERCONTROLW);
mixer.mixerCtrls[ctrl].ctrl.dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
mixer.mixerCtrls[ctrl].ctrl.dwControlID = ctrl;
mixer.mixerCtrls[ctrl].ctrl.Bounds.s1.dwMinimum = 0;
mixer.mixerCtrls[ctrl].ctrl.Bounds.s1.dwMaximum = 65535;
mixer.mixerCtrls[ctrl].ctrl.Metrics.cSteps = 656;
ctrl++;
mixer.mixerCtrls[ctrl].dwLineID = i;
if ( !DeviceHasMute(line->deviceID, IsInput(line->direction)) )
mixer.mixerCtrls[ctrl].ctrl.fdwControl |= MIXERCONTROL_CONTROLF_DISABLED;
mixer.mixerCtrls[ctrl].ctrl.cbStruct = sizeof(MIXERCONTROLW);
mixer.mixerCtrls[ctrl].ctrl.dwControlType = MIXERCONTROL_CONTROLTYPE_MUTE;
mixer.mixerCtrls[ctrl].ctrl.dwControlID = ctrl;
mixer.mixerCtrls[ctrl].ctrl.Bounds.s1.dwMinimum = 0;
mixer.mixerCtrls[ctrl].ctrl.Bounds.s1.dwMaximum = 1;
ctrl++;
}
assert(ctrl == mixer.numCtrl);
}
/**************************************************************************
* CoreAudio_MixerInit
*/
LONG CoreAudio_MixerInit(void)
{
OSStatus status;
UInt32 propertySize;
AudioDeviceID *deviceArray = NULL;
char name[MAXPNAMELEN];
int i;
int numLines;
AudioStreamBasicDescription streamDescription;
/* Find number of lines */
status = AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &propertySize, NULL);
if (status)
{
ERR("AudioHardwareGetPropertyInfo for kAudioHardwarePropertyDevices return %c%c%c%c\n", (char) (status >> 24),
(char) (status >> 16),
(char) (status >> 8),
(char) status);
return DRV_FAILURE;
}
numLines = propertySize / sizeof(AudioDeviceID);
mixer.mixerCtrls = NULL;
mixer.lines = NULL;
mixer.numCtrl = 0;
mixer.caps.cDestinations = numLines;
mixer.caps.wMid = 0xAA;
mixer.caps.wPid = 0x55;
mixer.caps.vDriverVersion = 0x0100;
MultiByteToWideChar(CP_ACP, 0, WINE_MIXER_NAME, -1, mixer.caps.szPname, sizeof(mixer.caps.szPname) / sizeof(WCHAR));
mixer.caps.fdwSupport = 0; /* No bits defined yet */
mixer.lines = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MixerLine) * numLines);
if (!mixer.lines)
goto error;
deviceArray = HeapAlloc(GetProcessHeap(), 0, sizeof(AudioDeviceID) * numLines);
propertySize = sizeof(AudioDeviceID) * numLines;
status = AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &propertySize, deviceArray);
if (status)
{
ERR("AudioHardwareGetProperty for kAudioHardwarePropertyDevices return %c%c%c%c\n", (char) (status >> 24),
(char) (status >> 16),
(char) (status >> 8),
(char) status);
goto error;
}
for (i = 0; i < numLines; i++)
{
Boolean write;
MixerLine *line = &mixer.lines[i];
line->deviceID = deviceArray[i];
propertySize = MAXPNAMELEN;
status = AudioDeviceGetProperty(line->deviceID, 0 , FALSE, kAudioDevicePropertyDeviceName, &propertySize, name);
if (status) {
ERR("AudioHardwareGetProperty for kAudioDevicePropertyDeviceName return %c%c%c%c\n", (char) (status >> 24),
(char) (status >> 16),
(char) (status >> 8),
(char) status);
goto error;
}
line->name = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, strlen(name) + 1);
if (!line->name)
goto error;
memcpy(line->name, name, strlen(name));
line->componentType = DeviceComponentType(line->name);
/* check for directions */
/* Output ? */
propertySize = sizeof(UInt32);
status = AudioDeviceGetPropertyInfo(line->deviceID, 0, FALSE, kAudioDevicePropertyStreams, &propertySize, &write );
if (status) {
ERR("AudioDeviceGetPropertyInfo for kAudioDevicePropertyDataSource return %c%c%c%c\n", (char) (status >> 24),
(char) (status >> 16),
(char) (status >> 8),
(char) status);
goto error;
}
if ( (propertySize / sizeof(AudioStreamID)) != 0)
{
line->direction |= OutputDevice;
/* Check the number of channel for the stream */
propertySize = sizeof(streamDescription);
status = AudioDeviceGetProperty(line->deviceID, 0, FALSE , kAudioDevicePropertyStreamFormat, &propertySize, &streamDescription);
if (status != noErr) {
ERR("AudioHardwareGetProperty for kAudioDevicePropertyStreamFormat return %c%c%c%c\n", (char) (status >> 24),
(char) (status >> 16),
(char) (status >> 8),
(char) status);
goto error;
}
line->numChannels = streamDescription.mChannelsPerFrame;
}
else
{
/* Input ? */
propertySize = sizeof(UInt32);
status = AudioDeviceGetPropertyInfo(line->deviceID, 0, TRUE, kAudioDevicePropertyStreams, &propertySize, &write );
if (status) {
ERR("AudioDeviceGetPropertyInfo for kAudioDevicePropertyStreams return %c%c%c%c\n", (char) (status >> 24),
(char) (status >> 16),
(char) (status >> 8),
(char) status);
goto error;
}
if ( (propertySize / sizeof(AudioStreamID)) != 0)
{
line->direction |= InputDevice;
/* Check the number of channel for the stream */
propertySize = sizeof(streamDescription);
status = AudioDeviceGetProperty(line->deviceID, 0, TRUE, kAudioDevicePropertyStreamFormat, &propertySize, &streamDescription);
if (status != noErr) {
ERR("AudioHardwareGetProperty for kAudioDevicePropertyStreamFormat return %c%c%c%c\n", (char) (status >> 24),
(char) (status >> 16),
(char) (status >> 8),
(char) status);
goto error;
}
line->numChannels = streamDescription.mChannelsPerFrame;
}
}
mixer.numCtrl += ControlsPerLine; /* volume & (mute | onoff) */
}
mixer.mixerCtrls = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MixerCtrl) * mixer.numCtrl);
if (!mixer.mixerCtrls)
goto error;
MIX_FillControls();
HeapFree(GetProcessHeap(), 0, deviceArray);
return DRV_SUCCESS;
error:
if (mixer.lines)
{
int i;
for (i = 0; i < mixer.caps.cDestinations; i++)
{
HeapFree(GetProcessHeap(), 0, mixer.lines[i].name);
}
HeapFree(GetProcessHeap(), 0, mixer.lines);
}
HeapFree(GetProcessHeap(), 0, deviceArray);
if (mixer.mixerCtrls)
HeapFree(GetProcessHeap(), 0, mixer.mixerCtrls);
return DRV_FAILURE;
}
/**************************************************************************
* CoreAudio_MixerRelease
*/
void CoreAudio_MixerRelease(void)
{
TRACE("()\n");
if (mixer.lines)
{
int i;
for (i = 0; i < mixer.caps.cDestinations; i++)
{
HeapFree(GetProcessHeap(), 0, mixer.lines[i].name);
}
HeapFree(GetProcessHeap(), 0, mixer.lines);
}
if (mixer.mixerCtrls)
HeapFree(GetProcessHeap(), 0, mixer.mixerCtrls);
}
/**************************************************************************
* MIX_Open [internal]
*/
static DWORD MIX_Open(WORD wDevID, LPMIXEROPENDESC lpMod, DWORD_PTR flags)
{
TRACE("wDevID=%d lpMod=%p dwSize=%08lx\n", wDevID, lpMod, flags);
if (lpMod == NULL) {
WARN("invalid parameter: lpMod == NULL\n");
return MMSYSERR_INVALPARAM;
}
if (wDevID >= numMixers) {
WARN("bad device ID: %04X\n", wDevID);
return MMSYSERR_BADDEVICEID;
}
return MMSYSERR_NOERROR;
}
/**************************************************************************
* MIX_GetNumDevs [internal]
*/
static DWORD MIX_GetNumDevs(void)
{
TRACE("()\n");
return numMixers;
}
static DWORD MIX_GetDevCaps(WORD wDevID, LPMIXERCAPSW lpCaps, DWORD_PTR dwSize)
{
TRACE("wDevID=%d lpCaps=%p\n", wDevID, lpCaps);
if (lpCaps == NULL) {
WARN("Invalid Parameter\n");
return MMSYSERR_INVALPARAM;
}
if (wDevID >= numMixers) {
WARN("bad device ID : %d\n", wDevID);
return MMSYSERR_BADDEVICEID;
}
memcpy(lpCaps, &mixer.caps, min(dwSize, sizeof(*lpCaps)));
return MMSYSERR_NOERROR;
}
/**************************************************************************
* MIX_GetLineInfo [internal]
*/
static DWORD MIX_GetLineInfo(WORD wDevID, LPMIXERLINEW lpMl, DWORD_PTR fdwInfo)
{
int i;
DWORD ret = MMSYSERR_ERROR;
MixerLine *line = NULL;
TRACE("%04X, %p, %08lx\n", wDevID, lpMl, fdwInfo);
if (lpMl == NULL) {
WARN("invalid parameter: lpMl = NULL\n");
return MMSYSERR_INVALPARAM;
}
if (lpMl->cbStruct != sizeof(*lpMl)) {
WARN("invalid parameter: lpMl->cbStruct\n");
return MMSYSERR_INVALPARAM;
}
if (wDevID >= numMixers) {
WARN("bad device ID: %04X\n", wDevID);
return MMSYSERR_BADDEVICEID;
}
/* FIXME: set all the variables correctly... the lines below
* are very wrong...
*/
lpMl->dwUser = 0;
switch (fdwInfo & MIXER_GETLINEINFOF_QUERYMASK)
{
case MIXER_GETLINEINFOF_DESTINATION:
TRACE("MIXER_GETLINEINFOF_DESTINATION %d\n", lpMl->dwDestination);
if ( (lpMl->dwDestination >= 0) && (lpMl->dwDestination < mixer.caps.cDestinations) )
{
lpMl->dwLineID = lpMl->dwDestination;
line = &mixer.lines[lpMl->dwDestination];
}
else ret = MIXERR_INVALLINE;
break;
case MIXER_GETLINEINFOF_COMPONENTTYPE:
TRACE("MIXER_GETLINEINFOF_COMPONENTTYPE %s\n", getComponentType(lpMl->dwComponentType));
for (i = 0; i < mixer.caps.cDestinations; i++)
{
if (mixer.lines[i].componentType == lpMl->dwComponentType)
{
lpMl->dwDestination = lpMl->dwLineID = i;
line = &mixer.lines[i];
break;
}
}
if (line == NULL)
{
WARN("can't find component type %s\n", getComponentType(lpMl->dwComponentType));
ret = MIXERR_INVALVALUE;
}
break;
case MIXER_GETLINEINFOF_SOURCE:
FIXME("MIXER_GETLINEINFOF_SOURCE %d dst=%d\n", lpMl->dwSource, lpMl->dwDestination);
break;
case MIXER_GETLINEINFOF_LINEID:
TRACE("MIXER_GETLINEINFOF_LINEID %d\n", lpMl->dwLineID);
if ( (lpMl->dwLineID >= 0) && (lpMl->dwLineID < mixer.caps.cDestinations) )
{
lpMl->dwDestination = lpMl->dwLineID;
line = &mixer.lines[lpMl->dwLineID];
}
else ret = MIXERR_INVALLINE;
break;
case MIXER_GETLINEINFOF_TARGETTYPE:
FIXME("MIXER_GETLINEINFOF_TARGETTYPE (%s)\n", getTargetType(lpMl->Target.dwType));
switch (lpMl->Target.dwType) {
case MIXERLINE_TARGETTYPE_UNDEFINED:
case MIXERLINE_TARGETTYPE_WAVEOUT:
case MIXERLINE_TARGETTYPE_WAVEIN:
case MIXERLINE_TARGETTYPE_MIDIOUT:
case MIXERLINE_TARGETTYPE_MIDIIN:
case MIXERLINE_TARGETTYPE_AUX:
default:
FIXME("Unhandled target type (%s)\n",
getTargetType(lpMl->Target.dwType));
return MMSYSERR_INVALPARAM;
}
break;
default:
WARN("Unknown flag (%08lx)\n", fdwInfo & MIXER_GETLINEINFOF_QUERYMASK);
break;
}
if (line)
{
lpMl->dwComponentType = line->componentType;
lpMl->cChannels = line->numChannels;
lpMl->cControls = ControlsPerLine;
/* FIXME check there with CoreAudio */
lpMl->cConnections = 1;
lpMl->fdwLine = MIXERLINE_LINEF_ACTIVE;
MultiByteToWideChar(CP_ACP, 0, line->name, -1, lpMl->szShortName, sizeof(lpMl->szShortName) / sizeof(WCHAR));
MultiByteToWideChar(CP_ACP, 0, line->name, -1, lpMl->szName, sizeof(lpMl->szName) / sizeof(WCHAR));
if ( IsInput(line->direction) )
lpMl->Target.dwType = MIXERLINE_TARGETTYPE_WAVEIN;
else
lpMl->Target.dwType = MIXERLINE_TARGETTYPE_WAVEOUT;
lpMl->Target.dwDeviceID = line->deviceID;
lpMl->Target.wMid = mixer.caps.wMid;
lpMl->Target.wPid = mixer.caps.wPid;
lpMl->Target.vDriverVersion = mixer.caps.vDriverVersion;
MultiByteToWideChar(CP_ACP, 0, WINE_MIXER_NAME, -1, lpMl->Target.szPname, sizeof(lpMl->Target.szPname) / sizeof(WCHAR));
ret = MMSYSERR_NOERROR;
}
return ret;
}
/**************************************************************************
* MIX_GetLineControls [internal]
*/
static DWORD MIX_GetLineControls(WORD wDevID, LPMIXERLINECONTROLSW lpMlc, DWORD_PTR flags)
{
DWORD ret = MMSYSERR_NOTENABLED;
int ctrl = 0;
TRACE("%04X, %p, %08lX\n", wDevID, lpMlc, flags);
if (lpMlc == NULL) {
WARN("invalid parameter: lpMlc == NULL\n");
return MMSYSERR_INVALPARAM;
}
if (lpMlc->cbStruct < sizeof(*lpMlc)) {
WARN("invalid parameter: lpMlc->cbStruct = %d\n", lpMlc->cbStruct);
return MMSYSERR_INVALPARAM;
}
if (lpMlc->cbmxctrl < sizeof(MIXERCONTROLW)) {
WARN("invalid parameter: lpMlc->cbmxctrl = %d\n", lpMlc->cbmxctrl);
return MMSYSERR_INVALPARAM;
}
if (wDevID >= numMixers) {
WARN("bad device ID: %04X\n", wDevID);
return MMSYSERR_BADDEVICEID;
}
switch (flags & MIXER_GETLINECONTROLSF_QUERYMASK)
{
case MIXER_GETLINECONTROLSF_ALL:
FIXME("dwLineID=%d MIXER_GETLINECONTROLSF_ALL (%d)\n", lpMlc->dwLineID, lpMlc->cControls);
if (lpMlc->cControls != ControlsPerLine)
{
WARN("invalid parameter lpMlc->cControls %d\n", lpMlc->cControls);
ret = MMSYSERR_INVALPARAM;
}
else
{
if ( (lpMlc->dwLineID >= 0) && (lpMlc->dwLineID < mixer.caps.cDestinations) )
{
int i;
for (i = 0; i < lpMlc->cControls; i++)
{
lpMlc->pamxctrl[i] = mixer.mixerCtrls[lpMlc->dwLineID * i].ctrl;
}
ret = MMSYSERR_NOERROR;
}
else ret = MIXERR_INVALLINE;
}
break;
case MIXER_GETLINECONTROLSF_ONEBYID:
TRACE("dwLineID=%d MIXER_GETLINECONTROLSF_ONEBYID (%d)\n", lpMlc->dwLineID, lpMlc->u.dwControlID);
if ( lpMlc->u.dwControlID >= 0 && lpMlc->u.dwControlID < mixer.numCtrl )
{
lpMlc->pamxctrl[0] = mixer.mixerCtrls[lpMlc->u.dwControlID].ctrl;
ret = MMSYSERR_NOERROR;
}
else ret = MIXERR_INVALVALUE;
break;
case MIXER_GETLINECONTROLSF_ONEBYTYPE:
TRACE("dwLineID=%d MIXER_GETLINECONTROLSF_ONEBYTYPE (%s)\n", lpMlc->dwLineID, getControlType(lpMlc->u.dwControlType));
if ( (lpMlc->dwLineID < 0) || (lpMlc->dwLineID >= mixer.caps.cDestinations) )
{
ret = MIXERR_INVALLINE;
break;
}
if (lpMlc->u.dwControlType == MIXERCONTROL_CONTROLTYPE_VOLUME)
{
ctrl = (lpMlc->dwLineID * ControlsPerLine) + IDControlVolume;
lpMlc->pamxctrl[0] = mixer.mixerCtrls[ctrl].ctrl;
ret = MMSYSERR_NOERROR;
}
else
if (lpMlc->u.dwControlType == MIXERCONTROL_CONTROLTYPE_MUTE)
{
ctrl = (lpMlc->dwLineID * ControlsPerLine) + IDControlMute;
lpMlc->pamxctrl[0] = mixer.mixerCtrls[ctrl].ctrl;
ret = MMSYSERR_NOERROR;
}
break;
default:
ERR("Unknown flag %08lx\n", flags & MIXER_GETLINECONTROLSF_QUERYMASK);
ret = MMSYSERR_INVALPARAM;
}
return ret;
}
/**************************************************************************
* MIX_GetControlDetails [internal]
*/
static DWORD MIX_GetControlDetails(WORD wDevID, LPMIXERCONTROLDETAILS lpmcd, DWORD_PTR fdwDetails)
{
DWORD ret = MMSYSERR_NOTSUPPORTED;
DWORD dwControlType;
TRACE("%04X, %p, %08lx\n", wDevID, lpmcd, fdwDetails);
if (lpmcd == NULL) {
TRACE("invalid parameter: lpmcd == NULL\n");
return MMSYSERR_INVALPARAM;
}
if (wDevID >= numMixers) {
WARN("bad device ID: %04X\n", wDevID);
return MMSYSERR_BADDEVICEID;
}
if ( (fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK) != MIXER_GETCONTROLDETAILSF_VALUE )
{
WARN("Unknown/unimplement GetControlDetails flag (%08lx)\n", fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK);
return MMSYSERR_NOTSUPPORTED;
}
if ( lpmcd->dwControlID < 0 || lpmcd->dwControlID >= mixer.numCtrl )
{
WARN("bad control ID: %d\n", lpmcd->dwControlID);
return MIXERR_INVALVALUE;
}
TRACE("MIXER_GETCONTROLDETAILSF_VALUE %d\n", lpmcd->dwControlID);
dwControlType = mixer.mixerCtrls[lpmcd->dwControlID].ctrl.dwControlType;
switch (dwControlType)
{
case MIXERCONTROL_CONTROLTYPE_VOLUME:
FIXME("controlType : %s channels %d\n", getControlType(dwControlType), lpmcd->cChannels);
{
LPMIXERCONTROLDETAILS_UNSIGNED mcdu;
Float32 left, right;
if (lpmcd->cbDetails != sizeof(MIXERCONTROLDETAILS_UNSIGNED)) {
WARN("invalid parameter: lpmcd->cbDetails == %d\n", lpmcd->cbDetails);
return MMSYSERR_INVALPARAM;
}
if ( MIX_LineGetVolume(mixer.mixerCtrls[lpmcd->dwControlID].dwLineID, lpmcd->cChannels, &left, &right) )
{
mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)lpmcd->paDetails;
switch (lpmcd->cChannels)
{
case 1:
/* mono... so R = L */
mcdu->dwValue = left * 65535;
TRACE("Reading RL = %d\n", mcdu->dwValue);
break;
case 2:
/* stereo, left is paDetails[0] */
mcdu->dwValue = left * 65535;
TRACE("Reading L = %d\n", mcdu->dwValue);
mcdu++;
mcdu->dwValue = right * 65535;
TRACE("Reading R = %d\n", mcdu->dwValue);
break;
default:
WARN("Unsupported cChannels (%d)\n", lpmcd->cChannels);
return MMSYSERR_INVALPARAM;
}
TRACE("=> %08x\n", mcdu->dwValue);
ret = MMSYSERR_NOERROR;
}
}
break;
case MIXERCONTROL_CONTROLTYPE_MUTE:
case MIXERCONTROL_CONTROLTYPE_ONOFF:
FIXME("%s MIXERCONTROLDETAILS_BOOLEAN[%u]\n", getControlType(dwControlType), lpmcd->cChannels);
{
LPMIXERCONTROLDETAILS_BOOLEAN mcdb;
BOOL muted;
if (lpmcd->cbDetails != sizeof(MIXERCONTROLDETAILS_BOOLEAN)) {
WARN("invalid parameter: lpmcd->cbDetails = %d\n", lpmcd->cbDetails);
return MMSYSERR_INVALPARAM;
}
mcdb = (LPMIXERCONTROLDETAILS_BOOLEAN)lpmcd->paDetails;
if ( MIX_LineGetMute(mixer.mixerCtrls[lpmcd->dwControlID].dwLineID, &muted) )
{
mcdb->fValue = muted;
TRACE("=> %s\n", mcdb->fValue ? "on" : "off");
ret = MMSYSERR_NOERROR;
}
}
break;
case MIXERCONTROL_CONTROLTYPE_MIXER:
case MIXERCONTROL_CONTROLTYPE_MUX:
default:
FIXME("controlType : %s\n", getControlType(dwControlType));
break;
}
return ret;
}
/**************************************************************************
* MIX_SetControlDetails [internal]
*/
static DWORD MIX_SetControlDetails(WORD wDevID, LPMIXERCONTROLDETAILS lpmcd, DWORD_PTR fdwDetails)
{
DWORD ret = MMSYSERR_NOTSUPPORTED;
DWORD dwControlType;
TRACE("%04X, %p, %08lx\n", wDevID, lpmcd, fdwDetails);
if (lpmcd == NULL) {
TRACE("invalid parameter: lpmcd == NULL\n");
return MMSYSERR_INVALPARAM;
}
if (wDevID >= numMixers) {
WARN("bad device ID: %04X\n", wDevID);
return MMSYSERR_BADDEVICEID;
}
if ( (fdwDetails & MIXER_SETCONTROLDETAILSF_QUERYMASK) != MIXER_GETCONTROLDETAILSF_VALUE )
{
WARN("Unknown SetControlDetails flag (%08lx)\n", fdwDetails & MIXER_SETCONTROLDETAILSF_QUERYMASK);
return MMSYSERR_NOTSUPPORTED;
}
TRACE("MIXER_SETCONTROLDETAILSF_VALUE dwControlID=%d\n", lpmcd->dwControlID);
dwControlType = mixer.mixerCtrls[lpmcd->dwControlID].ctrl.dwControlType;
switch (dwControlType)
{
case MIXERCONTROL_CONTROLTYPE_VOLUME:
FIXME("controlType : %s\n", getControlType(dwControlType));
{
LPMIXERCONTROLDETAILS_UNSIGNED mcdu;
Float32 left, right = 0;
if (lpmcd->cbDetails != sizeof(MIXERCONTROLDETAILS_UNSIGNED)) {
WARN("invalid parameter: lpmcd->cbDetails == %d\n", lpmcd->cbDetails);
return MMSYSERR_INVALPARAM;
}
mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)lpmcd->paDetails;
switch (lpmcd->cChannels)
{
case 1:
/* mono... so R = L */
TRACE("Setting RL to %d\n", mcdu->dwValue);
left = (Float32) mcdu->dwValue / 65535.0;
break;
case 2:
/* stereo, left is paDetails[0] */
TRACE("Setting L to %d\n", mcdu->dwValue);
left = (Float32) mcdu->dwValue / 65535.0;
mcdu++;
TRACE("Setting R to %d\n", mcdu->dwValue);
right = (Float32) mcdu->dwValue / 65535.0;
break;
default:
WARN("Unsupported cChannels (%d)\n", lpmcd->cChannels);
return MMSYSERR_INVALPARAM;
}
if ( MIX_LineSetVolume(mixer.mixerCtrls[lpmcd->dwControlID].dwLineID, lpmcd->cChannels, left, right) )
ret = MMSYSERR_NOERROR;
}
break;
case MIXERCONTROL_CONTROLTYPE_MUTE:
case MIXERCONTROL_CONTROLTYPE_ONOFF:
TRACE("%s MIXERCONTROLDETAILS_BOOLEAN[%u]\n", getControlType(dwControlType), lpmcd->cChannels);
{
LPMIXERCONTROLDETAILS_BOOLEAN mcdb;
if (lpmcd->cbDetails != sizeof(MIXERCONTROLDETAILS_BOOLEAN)) {
WARN("invalid parameter: cbDetails\n");
return MMSYSERR_INVALPARAM;
}
mcdb = (LPMIXERCONTROLDETAILS_BOOLEAN)lpmcd->paDetails;
if ( MIX_LineSetMute(mixer.mixerCtrls[lpmcd->dwControlID].dwLineID, mcdb->fValue) )
ret = MMSYSERR_NOERROR;
}
break;
case MIXERCONTROL_CONTROLTYPE_MIXER:
case MIXERCONTROL_CONTROLTYPE_MUX:
default:
FIXME("controlType : %s\n", getControlType(dwControlType));
ret = MMSYSERR_NOTSUPPORTED;
break;
}
return ret;
}
/**************************************************************************
* mxdMessage
*/
DWORD WINAPI CoreAudio_mxdMessage(UINT wDevID, UINT wMsg, DWORD_PTR dwUser,
DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
TRACE("(%04X, %s, %08lX, %08lX, %08lX);\n", wDevID, getMessage(wMsg),
dwUser, dwParam1, dwParam2);
switch (wMsg)
{
case DRVM_INIT:
case DRVM_EXIT:
case DRVM_ENABLE:
case DRVM_DISABLE:
/* FIXME: Pretend this is supported */
return 0;
case MXDM_OPEN:
return MIX_Open(wDevID, (LPMIXEROPENDESC)dwParam1, dwParam2);
case MXDM_CLOSE:
return MMSYSERR_NOERROR;
case MXDM_GETNUMDEVS:
return MIX_GetNumDevs();
case MXDM_GETDEVCAPS:
return MIX_GetDevCaps(wDevID, (LPMIXERCAPSW)dwParam1, dwParam2);
case MXDM_GETLINEINFO:
return MIX_GetLineInfo(wDevID, (LPMIXERLINEW)dwParam1, dwParam2);
case MXDM_GETLINECONTROLS:
return MIX_GetLineControls(wDevID, (LPMIXERLINECONTROLSW)dwParam1, dwParam2);
case MXDM_GETCONTROLDETAILS:
return MIX_GetControlDetails(wDevID, (LPMIXERCONTROLDETAILS)dwParam1, dwParam2);
case MXDM_SETCONTROLDETAILS:
return MIX_SetControlDetails(wDevID, (LPMIXERCONTROLDETAILS)dwParam1, dwParam2);
default:
WARN("unknown message %d!\n", wMsg);
return MMSYSERR_NOTSUPPORTED;
}
}
#else
DWORD WINAPI CoreAudio_mxdMessage(UINT wDevID, UINT wMsg, DWORD_PTR dwUser,
DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
TRACE("(%04X, %04x, %08lX, %08lX, %08lX);\n", wDevID, wMsg, dwUser, dwParam1, dwParam2);
return MMSYSERR_NOTENABLED;
}
#endif /* HAVE_COREAUDIO_COREAUDIO_H */