| /* |
| * Copyright (c) 2002, 2007, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code 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 |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| |
| #define USE_ERROR |
| //#define USE_TRACE |
| |
| #ifndef WIN32_EXTRA_LEAN |
| #define WIN32_EXTRA_LEAN |
| #endif |
| #ifndef WIN32_LEAN_AND_MEAN |
| #define WIN32_LEAN_AND_MEAN |
| #endif |
| |
| #include <windows.h> |
| #include <mmsystem.h> |
| #include "Ports.h" |
| |
| #if USE_PORTS == TRUE |
| |
| typedef struct tag_PortControlID PortControlID; |
| |
| typedef struct tag_PortInfo { |
| // Windows API stuff |
| HMIXER handle; |
| INT32 mixerIndex; |
| int dstLineCount; // how many MIXERLINE structs in dstMixerLine |
| MIXERLINE* dstLines; |
| int srcLineCount; // how many MIXERLINE structs in srcMixerLine |
| MIXERLINE* srcLines; // contains all the Source Lines of dstLines |
| // Java Sound mapping |
| int targetPortCount; // one port per dstLine (playback) |
| int sourcePortCount; // only WAVEIN; one port maps to one srcLine |
| LPMIXERLINE* ports; // points into dstLines and dstLines. Starts with Target Ports (Playback) |
| int maxControlCount; // upper bound of number of controls |
| int usedControlIDs; // number of items already filled in controlIDs |
| PortControlID* controlIDs; // the control IDs themselves |
| int usedMuxData; |
| MIXERCONTROLDETAILS_BOOLEAN* muxData; |
| } PortInfo; |
| |
| #define PORT_CONTROL_TYPE_BOOLEAN 1 |
| #define PORT_CONTROL_TYPE_SIGNED 2 |
| #define PORT_CONTROL_TYPE_UNSIGNED 3 |
| //#define PORT_CONTROL_TYPE_UNSIGNED_DB 4 |
| #define PORT_CONTROL_TYPE_FAKE_VOLUME 5 |
| #define PORT_CONTROL_TYPE_FAKE_BALANCE 6 |
| #define PORT_CONTROL_TYPE_MUX 5 |
| #define PORT_CONTROL_TYPE_MIXER 6 |
| |
| typedef struct tag_PortControlID { |
| PortInfo* portInfo; |
| INT32 controlType; // one of PORT_CONTROL_TYPE_XX |
| INT32 min; |
| INT32 max; |
| MIXERCONTROLDETAILS details; |
| union { |
| MIXERCONTROLDETAILS_BOOLEAN boolValue; |
| MIXERCONTROLDETAILS_SIGNED signedValue; |
| MIXERCONTROLDETAILS_UNSIGNED unsignedValue[2]; |
| INT32 muxIndex; |
| }; |
| } PortControlID; |
| |
| |
| int getControlInfo(HMIXER handle, MIXERLINE* line, MIXERLINECONTROLS* controls); |
| |
| INT32 PORT_GetPortMixerCount() { |
| return (INT32) mixerGetNumDevs(); |
| } |
| |
| #ifdef USE_TRACE |
| |
| char* getLineFlags(DWORD flags) { |
| static char ret[100]; |
| ret[0]=0; |
| if (flags & MIXERLINE_LINEF_ACTIVE) { |
| strcat(ret, "ACTIVE "); |
| flags ^= MIXERLINE_LINEF_ACTIVE; |
| } |
| if (flags & MIXERLINE_LINEF_DISCONNECTED) { |
| strcat(ret, "DISCONNECTED "); |
| flags ^= MIXERLINE_LINEF_DISCONNECTED; |
| } |
| if (flags & MIXERLINE_LINEF_SOURCE) { |
| strcat(ret, "SOURCE "); |
| flags ^= MIXERLINE_LINEF_SOURCE; |
| } |
| if (flags!=0) { |
| UINT_PTR r = (UINT_PTR) ret; |
| r += strlen(ret); |
| sprintf((char*) r, "%d", flags); |
| } |
| return ret; |
| } |
| |
| char* getComponentType(int componentType) { |
| switch (componentType) { |
| case MIXERLINE_COMPONENTTYPE_DST_HEADPHONES: return "DST_HEADPHONES"; |
| case MIXERLINE_COMPONENTTYPE_DST_LINE: return "DST_LINE"; |
| case MIXERLINE_COMPONENTTYPE_DST_SPEAKERS: return "DST_SPEAKERS"; |
| case MIXERLINE_COMPONENTTYPE_DST_DIGITAL: return "DST_DIGITAL"; |
| case MIXERLINE_COMPONENTTYPE_DST_MONITOR: return "DST_MONITOR"; |
| case MIXERLINE_COMPONENTTYPE_DST_TELEPHONE: return "DST_TELEPHONE"; |
| case MIXERLINE_COMPONENTTYPE_DST_UNDEFINED: return "DST_UNDEFINED"; |
| case MIXERLINE_COMPONENTTYPE_DST_VOICEIN: return "DST_VOICEIN"; |
| case MIXERLINE_COMPONENTTYPE_DST_WAVEIN: return "DST_WAVEIN"; |
| |
| case MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC: return "SRC_COMPACTDISC"; |
| case MIXERLINE_COMPONENTTYPE_SRC_LINE: return "SRC_LINE"; |
| case MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE: return "SRC_MICROPHONE"; |
| case MIXERLINE_COMPONENTTYPE_SRC_ANALOG: return "SRC_ANALOG"; |
| case MIXERLINE_COMPONENTTYPE_SRC_AUXILIARY: return "SRC_AUXILIARY"; |
| case MIXERLINE_COMPONENTTYPE_SRC_DIGITAL: return "SRC_DIGITAL"; |
| case MIXERLINE_COMPONENTTYPE_SRC_PCSPEAKER: return "SRC_PCSPEAKER"; |
| case MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER: return "SRC_SYNTHESIZER"; |
| case MIXERLINE_COMPONENTTYPE_SRC_TELEPHONE: return "SRC_TELEPHONE"; |
| case MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED: return "SRC_UNDEFINED"; |
| case MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT: return "SRC_WAVEOUT"; |
| } |
| return ""; |
| } |
| |
| void printMixerLine(MIXERLINE* mixerLine) { |
| TRACE2("MIXERLINE destination=%d, source=%d, ", mixerLine->dwDestination, mixerLine->dwSource); |
| TRACE3("channels=%d, connections=%d, controls=%d, ", mixerLine->cChannels, mixerLine->cConnections, mixerLine->cControls); |
| TRACE3("\"%s\", fdwLine=%s, componentType=%s\n", mixerLine->szName, getLineFlags(mixerLine->fdwLine), getComponentType(mixerLine->dwComponentType)); |
| } |
| |
| char* getControlClass(int controlType) { |
| switch (controlType & MIXERCONTROL_CT_CLASS_MASK) { |
| case MIXERCONTROL_CT_CLASS_CUSTOM : return "CLASS_CUSTOM"; |
| case MIXERCONTROL_CT_CLASS_FADER : return "CLASS_FADER "; |
| case MIXERCONTROL_CT_CLASS_LIST : return "CLASS_LIST "; |
| case MIXERCONTROL_CT_CLASS_METER : return "CLASS_METER "; |
| case MIXERCONTROL_CT_CLASS_NUMBER : return "CLASS_NUMBER"; |
| case MIXERCONTROL_CT_CLASS_SLIDER : return "CLASS_SLIDER"; |
| case MIXERCONTROL_CT_CLASS_SWITCH : return "CLASS_SWITCH"; |
| case MIXERCONTROL_CT_CLASS_TIME : return "CLASS_TIME "; |
| } |
| return "unknown class"; |
| } |
| |
| char* getControlType(int controlType) { |
| switch (controlType) { |
| case MIXERCONTROL_CONTROLTYPE_CUSTOM : return "CUSTOM "; |
| case MIXERCONTROL_CONTROLTYPE_BASS : return "BASS "; |
| case MIXERCONTROL_CONTROLTYPE_EQUALIZER : return "EQUALIZER "; |
| case MIXERCONTROL_CONTROLTYPE_FADER : return "FADER "; |
| case MIXERCONTROL_CONTROLTYPE_TREBLE : return "TREBLE "; |
| case MIXERCONTROL_CONTROLTYPE_VOLUME : return "VOLUME "; |
| case MIXERCONTROL_CONTROLTYPE_MIXER : return "MIXER "; |
| case MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT : return "MULTIPLESELECT "; |
| case MIXERCONTROL_CONTROLTYPE_MUX : return "MUX "; |
| case MIXERCONTROL_CONTROLTYPE_SINGLESELECT : return "SINGLESELECT "; |
| case MIXERCONTROL_CONTROLTYPE_BOOLEANMETER : return "BOOLEANMETER "; |
| case MIXERCONTROL_CONTROLTYPE_PEAKMETER : return "PEAKMETER "; |
| case MIXERCONTROL_CONTROLTYPE_SIGNEDMETER : return "SIGNEDMETER "; |
| case MIXERCONTROL_CONTROLTYPE_UNSIGNEDMETER : return "UNSIGNEDMETER "; |
| case MIXERCONTROL_CONTROLTYPE_DECIBELS : return "DECIBELS "; |
| case MIXERCONTROL_CONTROLTYPE_PERCENT : return "PERCENT "; |
| case MIXERCONTROL_CONTROLTYPE_SIGNED : return "SIGNED "; |
| case MIXERCONTROL_CONTROLTYPE_UNSIGNED : return "UNSIGNED "; |
| case MIXERCONTROL_CONTROLTYPE_PAN : return "PAN "; |
| case MIXERCONTROL_CONTROLTYPE_QSOUNDPAN : return "QSOUNDPAN "; |
| case MIXERCONTROL_CONTROLTYPE_SLIDER : return "SLIDER "; |
| case MIXERCONTROL_CONTROLTYPE_BOOLEAN : return "BOOLEAN "; |
| case MIXERCONTROL_CONTROLTYPE_BUTTON : return "BUTTON "; |
| case MIXERCONTROL_CONTROLTYPE_LOUDNESS : return "LOUDNESS "; |
| case MIXERCONTROL_CONTROLTYPE_MONO : return "MONO "; |
| case MIXERCONTROL_CONTROLTYPE_MUTE : return "MUTE "; |
| case MIXERCONTROL_CONTROLTYPE_ONOFF : return "ONOFF "; |
| case MIXERCONTROL_CONTROLTYPE_STEREOENH : return "STEREOENH "; |
| case MIXERCONTROL_CONTROLTYPE_MICROTIME : return "MICROTIME "; |
| case MIXERCONTROL_CONTROLTYPE_MILLITIME : return "MILLITIME "; |
| } |
| return "unknown"; |
| } |
| |
| char* getControlState(DWORD controlState) { |
| static char ret[100]; |
| ret[0]=0; |
| if (controlState & MIXERCONTROL_CONTROLF_DISABLED) { |
| strcat(ret, "DISABLED "); |
| controlState ^= MIXERCONTROL_CONTROLF_DISABLED; |
| } |
| if (controlState & MIXERCONTROL_CONTROLF_MULTIPLE) { |
| strcat(ret, "MULTIPLE "); |
| controlState ^= MIXERCONTROL_CONTROLF_MULTIPLE; |
| } |
| if (controlState & MIXERCONTROL_CONTROLF_UNIFORM) { |
| strcat(ret, "UNIFORM "); |
| controlState ^= MIXERCONTROL_CONTROLF_UNIFORM; |
| } |
| if (controlState!=0) { |
| UINT_PTR r = (UINT_PTR) ret; |
| r += strlen(ret); |
| sprintf((char*) r, "%d", controlState); |
| } |
| return ret; |
| } |
| |
| void printControl(MIXERCONTROL* control) { |
| TRACE3(" %s: dwControlType=%s/%s, ", control->szName, getControlClass(control->dwControlType), getControlType(control->dwControlType)); |
| TRACE3("multpleItems=%d, state=%d, %s\n", control->cMultipleItems, control->fdwControl, getControlState(control->fdwControl)); |
| } |
| |
| void printMixerLineControls(HMIXER handle, MIXERLINE* mixerLine) { |
| MIXERLINECONTROLS controls; |
| DWORD i; |
| TRACE1(" Controls for %s:\n", mixerLine->szName); |
| if (getControlInfo(handle, mixerLine, &controls)) { |
| for (i = 0; i < controls.cControls; i++) { |
| printControl(&controls.pamxctrl[i]); |
| } |
| if (controls.pamxctrl) { |
| free(controls.pamxctrl); |
| controls.pamxctrl = NULL; |
| } |
| } |
| } |
| |
| void printInfo(PortInfo* info) { |
| TRACE5(" PortInfo %p: handle=%p, mixerIndex=%d, dstLineCount=%d, dstLines=%p, ", info, (void*) info->handle, info->mixerIndex, info->dstLineCount, info->dstLines); |
| TRACE5("srcLineCount=%d, srcLines=%p, targetPortCount=%d, sourcePortCount=%d, ports=%p, ", info->srcLineCount, info->srcLines, info->targetPortCount, info->sourcePortCount, info->ports); |
| TRACE3("maxControlCount=%d, usedControlIDs=%d, controlIDs=%p \n", info->maxControlCount, info->usedControlIDs, info->controlIDs); |
| TRACE2("usedMuxData=%d, muxData=%p, controlIDs=%p \n", info->usedMuxData, info->muxData); |
| } |
| |
| #endif // USE_TRACE |
| |
| // internal utility functions |
| |
| int getMixerLineByDestination(HMIXER handle, DWORD dstIndex, MIXERLINE* mixerLine) { |
| mixerLine->cbStruct = sizeof(MIXERLINE); |
| mixerLine->dwDestination = dstIndex; |
| if (mixerGetLineInfo((HMIXEROBJ) handle, mixerLine, |
| MIXER_GETLINEINFOF_DESTINATION | MIXER_OBJECTF_HMIXER |
| ) == MMSYSERR_NOERROR) { |
| return TRUE; |
| } |
| mixerLine->cControls = 0; |
| mixerLine->cConnections = 0; |
| return FALSE; |
| } |
| |
| int getMixerLineByType(HMIXER handle, DWORD linetype, MIXERLINE* mixerLine) { |
| mixerLine->cbStruct = sizeof(MIXERLINE); |
| mixerLine->dwComponentType = linetype; |
| if (mixerGetLineInfo((HMIXEROBJ) handle, mixerLine, |
| MIXER_GETLINEINFOF_COMPONENTTYPE | MIXER_OBJECTF_HMIXER |
| ) == MMSYSERR_NOERROR) { |
| return TRUE; |
| } |
| mixerLine->cControls = 0; |
| mixerLine->cConnections = 0; |
| return FALSE; |
| } |
| |
| int getMixerLineBySource(HMIXER handle, DWORD dstIndex, DWORD srcIndex, MIXERLINE* mixerLine) { |
| mixerLine->cbStruct = sizeof(MIXERLINE); |
| mixerLine->dwDestination = dstIndex; |
| mixerLine->dwSource = srcIndex; |
| if (mixerGetLineInfo((HMIXEROBJ) handle, mixerLine, |
| MIXER_GETLINEINFOF_SOURCE | MIXER_OBJECTF_HMIXER |
| ) == MMSYSERR_NOERROR) { |
| return TRUE; |
| } |
| mixerLine->cControls = 0; |
| mixerLine->cConnections = 0; |
| return FALSE; |
| } |
| |
| int getControlInfo(HMIXER handle, MIXERLINE* line, MIXERLINECONTROLS* controls) { |
| int ret = FALSE; |
| |
| //TRACE2(">getControlInfo for line %s with %d controls\n", line->szName, line->cControls); |
| controls->pamxctrl = NULL; |
| if (line->cControls > 0) { |
| // line points to the requested line. |
| // Reserve memory for the control infos |
| controls->cbStruct = sizeof(MIXERLINECONTROLS); |
| controls->dwLineID = line->dwLineID; |
| controls->cControls = line->cControls; |
| controls->cbmxctrl = sizeof(MIXERCONTROL); |
| controls->pamxctrl = (MIXERCONTROL*) malloc(sizeof(MIXERCONTROL) * line->cControls); |
| if (controls->pamxctrl) { |
| //TRACE0(" calling mixerGetLineControls\n"); |
| ret = mixerGetLineControls((HMIXEROBJ) handle, controls, |
| MIXER_GETLINECONTROLSF_ALL | MIXER_OBJECTF_HMIXER) == MMSYSERR_NOERROR; |
| } |
| } |
| if (!ret) { |
| if (controls->pamxctrl) { |
| free(controls->pamxctrl); |
| controls->pamxctrl = NULL; |
| } |
| } |
| //TRACE0("<getControlInfo \n"); |
| return ret; |
| } |
| |
| // returns TRUE if there are more than MIXER/MUX controls in this line |
| // if controls is non-NULL, it will be filled with the info |
| int lineHasControls(HMIXER handle, MIXERLINE* line, MIXERLINECONTROLS* controls) { |
| MIXERLINECONTROLS localControls; |
| int ret = FALSE; |
| UINT i; |
| |
| localControls.pamxctrl = NULL; |
| if (controls == NULL) { |
| controls = &localControls; |
| } |
| if (getControlInfo(handle, line, controls)) { |
| for (i = 0; !ret && (i < controls->cControls); i++) { |
| switch (controls->pamxctrl[i].dwControlType & MIXERCONTROL_CT_CLASS_MASK) { |
| case MIXERCONTROL_CT_CLASS_FADER : // fall through |
| case MIXERCONTROL_CT_CLASS_SLIDER : // fall through |
| case MIXERCONTROL_CT_CLASS_SWITCH : ret = TRUE; |
| } |
| } |
| } |
| if (localControls.pamxctrl) { |
| free(localControls.pamxctrl); |
| localControls.pamxctrl = NULL; |
| } |
| return ret; |
| } |
| |
| |
| ///// implemented functions of Ports.h |
| |
| INT32 PORT_GetPortMixerDescription(INT32 mixerIndex, PortMixerDescription* description) { |
| MIXERCAPS mixerCaps; |
| if (mixerGetDevCaps(mixerIndex, &mixerCaps, sizeof(MIXERCAPS)) == MMSYSERR_NOERROR) { |
| strncpy(description->name, mixerCaps.szPname, PORT_STRING_LENGTH-1); |
| description->name[PORT_STRING_LENGTH-1] = 0; |
| sprintf(description->version, "%d.%d", (mixerCaps.vDriverVersion & 0xFF00) >> 8, mixerCaps.vDriverVersion & 0xFF); |
| strncpy(description->description, "Port Mixer", PORT_STRING_LENGTH-1); |
| return TRUE; |
| } |
| return FALSE; |
| } |
| |
| int getDestinationCount(HMIXER handle) { |
| int ret = 0; |
| MIXERCAPS mixerCaps; |
| |
| if (mixerGetDevCaps((UINT_PTR) handle, &mixerCaps, sizeof(MIXERCAPS)) == MMSYSERR_NOERROR) { |
| ret = mixerCaps.cDestinations; |
| } |
| return ret; |
| } |
| |
| void* PORT_Open(INT32 mixerIndex) { |
| PortInfo* info = NULL; |
| MMRESULT mmres; |
| HMIXER handle; |
| MIXERLINE* waveInLine; |
| int success = FALSE; |
| int src, dst, srcIndex, waveInHasControls; |
| int dstCount; |
| |
| TRACE0("PORT_Open\n"); |
| mmres = mixerOpen((LPHMIXER) &handle, mixerIndex, 0, 0, MIXER_OBJECTF_MIXER); |
| if (mmres != MMSYSERR_NOERROR) { |
| return NULL; |
| } |
| |
| info = (PortInfo*) malloc(sizeof(PortInfo)); |
| if (info != NULL) { |
| success = TRUE; |
| memset(info, 0, sizeof(PortInfo)); |
| info->handle = handle; |
| info->mixerIndex = mixerIndex; |
| waveInLine = NULL; |
| waveInHasControls = FALSE; |
| // number of destinations |
| dstCount = getDestinationCount(handle); |
| if (dstCount) { |
| info->dstLines = (MIXERLINE*) malloc(dstCount * sizeof(MIXERLINE)); |
| success = (info->dstLines != NULL); |
| } |
| if (success && info->dstLines) { |
| // go through all destinations and fill the structures in PortInfo |
| for (dst = 0; dst < dstCount; dst++) { |
| if (getMixerLineByDestination(handle, dst, &info->dstLines[info->dstLineCount])) { |
| info->srcLineCount += info->dstLines[info->dstLineCount].cConnections; |
| if (info->dstLines[info->dstLineCount].dwComponentType == MIXERLINE_COMPONENTTYPE_DST_WAVEIN && !waveInLine) { |
| waveInLine = &info->dstLines[info->dstLineCount]; |
| info->sourcePortCount = waveInLine->cConnections; |
| if (lineHasControls(handle, waveInLine, NULL)) { |
| // add a single port for all the controls that do not show in the MUX/MIXER controls |
| info->sourcePortCount++; |
| waveInHasControls = TRUE; |
| } |
| } else { |
| info->targetPortCount++; |
| } |
| info->dstLineCount++; |
| } |
| } |
| } |
| if (info->srcLineCount) { |
| info->srcLines = (MIXERLINE*) malloc(info->srcLineCount * sizeof(MIXERLINE)); |
| success = (info->srcLines != NULL); |
| } |
| if (success && info->srcLines) { |
| // go through all destinations and fill the source line structures in PortInfo |
| srcIndex = 0; |
| for (dst = 0; dst < info->dstLineCount; dst++) { |
| // remember the srcIndex for mapping the srcLines to this destination line |
| info->dstLines[dst].dwUser = srcIndex; |
| for (src = 0; src < (int) info->dstLines[dst].cConnections; src++) { |
| getMixerLineBySource(handle, dst, src, &info->srcLines[srcIndex++]); |
| } |
| } |
| } |
| // now create the mapping to Java Sound |
| if ((info->targetPortCount + info->sourcePortCount) > 0) { |
| info->ports = (LPMIXERLINE*) malloc((info->targetPortCount + info->sourcePortCount) * sizeof(LPMIXERLINE)); |
| success = (info->ports != NULL); |
| } |
| if (success && info->ports) { |
| // first add the target MIXERLINEs to the array |
| srcIndex = 0; |
| for (dst = 0; dst < info->dstLineCount; dst++) { |
| if (waveInLine != &info->dstLines[dst]) { |
| info->ports[srcIndex++] = &info->dstLines[dst]; |
| } |
| } |
| if (srcIndex != info->targetPortCount) { |
| ERROR2("srcIndex=%d is NOT targetPortCount=%d !\n", srcIndex, info->targetPortCount); |
| } |
| //srcIndex = info->targetPortCount; // should be automatic! |
| if (waveInLine) { |
| // if the recording destination line has controls, add the line |
| if (waveInHasControls) { |
| info->ports[srcIndex++] = waveInLine; |
| } |
| for (src = 0; src < (int) waveInLine->cConnections; src++) { |
| info->ports[srcIndex++] = &info->srcLines[src + waveInLine->dwUser]; |
| } |
| } |
| if (srcIndex != (info->targetPortCount + info->sourcePortCount)) { |
| ERROR2("srcIndex=%d is NOT PortCount=%d !\n", srcIndex, (info->targetPortCount + info->sourcePortCount)); |
| } |
| } |
| } |
| if (!success) { |
| if (handle != NULL) { |
| mixerClose(handle); |
| } |
| PORT_Close((void*) info); |
| info = NULL; |
| } |
| return info; |
| } |
| |
| void PORT_Close(void* id) { |
| TRACE0("PORT_Close\n"); |
| if (id != NULL) { |
| PortInfo* info = (PortInfo*) id; |
| if (info->handle) { |
| mixerClose(info->handle); |
| info->handle = NULL; |
| } |
| if (info->dstLines) { |
| free(info->dstLines); |
| info->dstLines = NULL; |
| } |
| if (info->srcLines) { |
| free(info->srcLines); |
| info->srcLines=NULL; |
| } |
| if (info->ports) { |
| free(info->ports); |
| info->ports = NULL; |
| } |
| if (info->controlIDs) { |
| free(info->controlIDs); |
| info->controlIDs = NULL; |
| } |
| if (info->muxData) { |
| free(info->muxData); |
| info->muxData = NULL; |
| } |
| free(info); |
| } |
| } |
| |
| INT32 PORT_GetPortCount(void* id) { |
| int ret = 0; |
| PortInfo* info = (PortInfo*) id; |
| if (info != NULL) { |
| ret = info->targetPortCount + info->sourcePortCount; |
| } |
| return ret; |
| } |
| |
| int componentType2type(DWORD componentType) { |
| int ret = 0; |
| if (componentType >= MIXERLINE_COMPONENTTYPE_DST_FIRST && componentType <= MIXERLINE_COMPONENTTYPE_DST_LAST) { |
| ret = PORT_DST_UNKNOWN; |
| } |
| else if (componentType >= MIXERLINE_COMPONENTTYPE_SRC_FIRST && componentType <= MIXERLINE_COMPONENTTYPE_SRC_LAST) { |
| ret = PORT_SRC_UNKNOWN; |
| } |
| // handle special cases |
| switch (componentType) { |
| case MIXERLINE_COMPONENTTYPE_DST_HEADPHONES: ret = PORT_DST_HEADPHONE; break; |
| case MIXERLINE_COMPONENTTYPE_DST_LINE: ret = PORT_DST_LINE_OUT; break; |
| case MIXERLINE_COMPONENTTYPE_DST_SPEAKERS: ret = PORT_DST_SPEAKER; break; |
| case MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC: ret = PORT_SRC_COMPACT_DISC; break; |
| case MIXERLINE_COMPONENTTYPE_SRC_LINE: ret = PORT_SRC_LINE_IN; break; |
| case MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE: ret = PORT_SRC_MICROPHONE; break; |
| } |
| return ret; |
| } |
| |
| INT32 PORT_GetPortType(void* id, INT32 portIndex) { |
| MIXERLINE* line; |
| PortInfo* info = (PortInfo*) id; |
| if ((portIndex >= 0) && (portIndex < PORT_GetPortCount(id))) { |
| line = info->ports[portIndex]; |
| if (line) { |
| return componentType2type(line->dwComponentType); |
| } |
| } |
| return 0; |
| } |
| |
| INT32 PORT_GetPortName(void* id, INT32 portIndex, char* name, INT32 len) { |
| MIXERLINE* line; |
| PortInfo* info = (PortInfo*) id; |
| |
| if ((portIndex >= 0) && (portIndex < PORT_GetPortCount(id))) { |
| line = info->ports[portIndex]; |
| if (line) { |
| strncpy(name, line->szName, len-1); |
| name[len-1] = 0; |
| return TRUE; |
| } |
| } |
| return FALSE; |
| } |
| |
| int getControlCount(HMIXER handle, MIXERLINE* line, INT32* muxCount) { |
| MIXERLINECONTROLS controls; |
| int ret = 0; |
| UINT i; |
| |
| controls.pamxctrl = NULL; |
| if (getControlInfo(handle, line, &controls)) { |
| for (i = 0; i < controls.cControls; i++) { |
| switch (controls.pamxctrl[i].dwControlType & MIXERCONTROL_CT_CLASS_MASK) { |
| case MIXERCONTROL_CT_CLASS_FADER : // fall through |
| case MIXERCONTROL_CT_CLASS_SLIDER : // fall through |
| case MIXERCONTROL_CT_CLASS_SWITCH : // fall through |
| case MIXERCONTROL_CT_CLASS_LIST : ret++; break; |
| } |
| if ((controls.pamxctrl[i].dwControlType == MIXERCONTROL_CONTROLTYPE_MIXER) |
| || (controls.pamxctrl[i].dwControlType == MIXERCONTROL_CONTROLTYPE_MUX)) { |
| ret += controls.pamxctrl[i].cMultipleItems; |
| if (muxCount) { |
| (*muxCount) += controls.pamxctrl[i].cMultipleItems; |
| } |
| } |
| else if ((controls.pamxctrl[i].dwControlType == MIXERCONTROL_CONTROLTYPE_VOLUME) |
| && (line->cChannels == 2)) { |
| ret++; // for FAKE volume/balance pairs |
| } |
| } |
| } |
| if (controls.pamxctrl) { |
| free(controls.pamxctrl); |
| controls.pamxctrl = NULL; |
| } |
| return ret; |
| } |
| |
| MIXERLINE* findDestLine(PortInfo* info, DWORD dwDestination) { |
| int i; |
| TRACE0(">findDestLine\n"); |
| for (i = 0; i < info->dstLineCount; i++) { |
| if (info->dstLines[i].dwDestination == dwDestination) { |
| TRACE0("<findDestLine\n"); |
| return &(info->dstLines[i]); |
| } |
| } |
| TRACE0("<findDestLine NULL\n"); |
| return NULL; |
| } |
| |
| void createMuxControl(PortInfo* info, PortControlCreator* creator, MIXERLINE* dstLine, DWORD srcLineID, void** controlObjects, int* controlCount) { |
| MIXERLINECONTROLS controlInfos; |
| MIXERCONTROLDETAILS* details; |
| MIXERCONTROLDETAILS_LISTTEXT* listTextDetails = NULL; |
| UINT listTextDetailCount = 0; |
| PortControlID* controlID; |
| UINT i, c; |
| int m; |
| |
| TRACE0(">createMuxControl\n"); |
| // go through all controls of dstline |
| controlInfos.pamxctrl = NULL; |
| if (getControlInfo(info->handle, dstLine, &controlInfos)) { |
| for (i = 0; i < controlInfos.cControls; i++) { |
| if (((controlInfos.pamxctrl[i].dwControlType == MIXERCONTROL_CONTROLTYPE_MIXER) |
| || (controlInfos.pamxctrl[i].dwControlType == MIXERCONTROL_CONTROLTYPE_MUX)) |
| && (controlInfos.pamxctrl[i].cMultipleItems > 0)) { |
| if (info->usedControlIDs >= info->maxControlCount) { |
| ERROR1("not enough free controlIDs !! maxControlIDs = %d\n", info->maxControlCount); |
| break; |
| } |
| // get the details for this mux control |
| controlID = &(info->controlIDs[info->usedControlIDs]); |
| controlID->portInfo = info; |
| if (controlInfos.pamxctrl[i].dwControlType == MIXERCONTROL_CONTROLTYPE_MIXER) { |
| controlID->controlType = PORT_CONTROL_TYPE_MIXER; |
| } else { |
| controlID->controlType = PORT_CONTROL_TYPE_MUX; |
| } |
| details = &(controlID->details); |
| details->cbStruct = sizeof(MIXERCONTROLDETAILS); |
| details->dwControlID = controlInfos.pamxctrl[i].dwControlID; |
| details->cChannels = 1; |
| details->cMultipleItems = controlInfos.pamxctrl[i].cMultipleItems; |
| details->cbDetails = sizeof(MIXERCONTROLDETAILS_LISTTEXT); |
| if (!listTextDetails || (listTextDetailCount < (details->cMultipleItems * details->cChannels))) { |
| // need to allocate new listTextDetails |
| if (listTextDetails) { |
| free(listTextDetails); |
| listTextDetails = NULL; |
| } |
| listTextDetailCount = details->cMultipleItems * details->cChannels; |
| listTextDetails = (MIXERCONTROLDETAILS_LISTTEXT*) malloc(listTextDetailCount * sizeof(MIXERCONTROLDETAILS_LISTTEXT)); |
| if (!listTextDetails) { |
| ERROR0("createMuxControl: unable to allocate listTextDetails!\n"); |
| if (controlInfos.pamxctrl) { |
| free(controlInfos.pamxctrl); |
| controlInfos.pamxctrl = NULL; |
| } |
| TRACE0("<createMuxControl ERROR\n"); |
| return; |
| } |
| } |
| details->paDetails = listTextDetails; |
| if (mixerGetControlDetails((HMIXEROBJ) info->handle, details, MIXER_GETCONTROLDETAILSF_LISTTEXT | MIXER_OBJECTF_HMIXER) != MMSYSERR_NOERROR) { |
| ERROR0("createMuxControl: unable to get control details!\n"); |
| continue; |
| } |
| // prevent freeing this data |
| details->paDetails = NULL; |
| // go through all mux items. If the line matches, then add a BOOLEAN select control |
| for (c = 0; c < details->cMultipleItems; c++) { |
| if (listTextDetails[c].dwParam1 == srcLineID) { |
| // we have found the line in the MUX lines. |
| controlID->muxIndex = c; |
| details->cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN); |
| // now look if any other controlID was already part of this MUX line |
| for (m = 0; m < info->usedControlIDs; m++) { |
| if (info->controlIDs[m].details.dwControlID == details->dwControlID) { |
| // reuse the MUX Data |
| TRACE2("Reusing paDetails=%p of controlID[%d]\n", info->controlIDs[m].details.paDetails, m); |
| details->paDetails = info->controlIDs[m].details.paDetails; |
| break; |
| } |
| } |
| if (!details->paDetails) { |
| // first time this MUX control is used, allocate some of the muxData |
| details->paDetails = &(info->muxData[info->usedMuxData]); |
| TRACE2("Setting paDetails=%p to muxData[%d] \n", details->paDetails, info->usedMuxData); |
| info->usedMuxData += details->cMultipleItems; |
| } |
| // finally this line can be added |
| controlObjects[*controlCount] = (creator->newBooleanControl)(creator, controlID, CONTROL_TYPE_SELECT); |
| (*controlCount)++; |
| info->usedControlIDs++; |
| break; |
| } |
| } |
| } |
| } |
| } |
| if (listTextDetails) { |
| free(listTextDetails); |
| listTextDetails = NULL; |
| } |
| if (controlInfos.pamxctrl) { |
| free(controlInfos.pamxctrl); |
| controlInfos.pamxctrl = NULL; |
| } |
| TRACE0("<createMuxControl\n"); |
| } |
| |
| void createPortControl(PortInfo* info, PortControlCreator* creator, MIXERCONTROL* mixerControl, |
| INT32 type, void** controlObjects, int* controlCount) { |
| PortControlID* controlID; |
| void* newControl = NULL; |
| char* typeName = mixerControl->szName; |
| float min; |
| TRACE0(">createPortControl\n"); |
| |
| // fill the ControlID structure and add this control |
| if (info->usedControlIDs >= info->maxControlCount) { |
| ERROR1("not enough free controlIDs !! maxControlIDs = %d\n", info->maxControlCount); |
| return; |
| } |
| controlID = &(info->controlIDs[info->usedControlIDs]); |
| controlID->portInfo = info; |
| controlID->controlType = type; |
| controlID->details.cbStruct = sizeof(MIXERCONTROLDETAILS); |
| controlID->details.dwControlID = mixerControl->dwControlID; |
| controlID->details.cChannels = 1; // uniform |
| controlID->details.cMultipleItems = 0; |
| switch (type) { |
| case PORT_CONTROL_TYPE_BOOLEAN: |
| TRACE0(" PORT_CONTROL_TYPE_BOOLEAN\n"); |
| controlID->details.cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN); |
| controlID->details.paDetails = &(controlID->boolValue); |
| if (mixerControl->dwControlType == MIXERCONTROL_CONTROLTYPE_MUTE) { |
| typeName = CONTROL_TYPE_MUTE; |
| } |
| newControl = (creator->newBooleanControl)(creator, controlID, typeName); |
| break; |
| case PORT_CONTROL_TYPE_SIGNED: |
| TRACE0(" PORT_CONTROL_TYPE_SIGNED\n"); |
| controlID->details.cbDetails = sizeof(MIXERCONTROLDETAILS_SIGNED); |
| controlID->details.paDetails = &(controlID->signedValue); |
| controlID->min = (INT32) mixerControl->Bounds.lMinimum; |
| controlID->max = (INT32) mixerControl->Bounds.lMaximum; |
| if (mixerControl->dwControlType == MIXERCONTROL_CONTROLTYPE_PAN) { |
| typeName = CONTROL_TYPE_PAN; |
| } |
| newControl = (creator->newFloatControl)(creator, controlID, typeName, |
| -1.0f, 1.0f, 2.0f / (controlID->max - controlID->min + 1), ""); |
| break; |
| case PORT_CONTROL_TYPE_FAKE_VOLUME: // fall through |
| case PORT_CONTROL_TYPE_FAKE_BALANCE: // fall through |
| case PORT_CONTROL_TYPE_UNSIGNED: |
| TRACE0(" PORT_CONTROL_TYPE_UNSIGNED\n"); |
| controlID->details.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED); |
| controlID->details.paDetails = &(controlID->unsignedValue[0]); |
| controlID->min = (INT32) mixerControl->Bounds.dwMinimum; |
| controlID->max = (INT32) mixerControl->Bounds.dwMaximum; |
| min = 0.0f; |
| if ((type == PORT_CONTROL_TYPE_FAKE_VOLUME) |
| || (mixerControl->dwControlType == MIXERCONTROL_CONTROLTYPE_VOLUME)) { |
| typeName = CONTROL_TYPE_VOLUME; |
| } |
| if (type == PORT_CONTROL_TYPE_FAKE_BALANCE) { |
| typeName = CONTROL_TYPE_BALANCE; |
| min = -1.0f; |
| } |
| if ((type == PORT_CONTROL_TYPE_FAKE_VOLUME) |
| || (type == PORT_CONTROL_TYPE_FAKE_BALANCE)) { |
| controlID->details.cChannels = 2; |
| } |
| TRACE0(" ....PORT_CONTROL_TYPE_UNSIGNED\n"); |
| newControl = (creator->newFloatControl)(creator, controlID, typeName, |
| min, 1.0f, 1.0f / (controlID->max - controlID->min + 1), ""); |
| break; |
| default: |
| ERROR1("createPortControl: unknown type %d !", type); |
| break; |
| } |
| if (newControl) { |
| controlObjects[*controlCount] = newControl; |
| (*controlCount)++; |
| info->usedControlIDs++; |
| } |
| TRACE0("<createPortControl\n"); |
| } |
| |
| void createLineControls(PortInfo* info, PortControlCreator* creator, MIXERLINE* line, void** controlObjects, int* controlCount) { |
| MIXERLINECONTROLS controlInfos; |
| MIXERCONTROL* mixerControl; |
| UINT i; |
| INT32 type; |
| |
| TRACE1(">createLineControls for line %s\n", line->szName); |
| // go through all controls of line |
| controlInfos.pamxctrl = NULL; |
| if (getControlInfo(info->handle, line, &controlInfos)) { |
| for (i = 0; i < controlInfos.cControls; i++) { |
| TRACE1(" %d\n", i); |
| mixerControl = &(controlInfos.pamxctrl[i]); |
| type = 0; |
| switch (mixerControl->dwControlType) { |
| case MIXERCONTROL_CONTROLTYPE_BOOLEAN : // fall through |
| case MIXERCONTROL_CONTROLTYPE_BUTTON : // fall through |
| case MIXERCONTROL_CONTROLTYPE_LOUDNESS : // fall through |
| case MIXERCONTROL_CONTROLTYPE_MONO : // fall through |
| case MIXERCONTROL_CONTROLTYPE_MUTE : // fall through |
| case MIXERCONTROL_CONTROLTYPE_ONOFF : // fall through |
| case MIXERCONTROL_CONTROLTYPE_STEREOENH: type = PORT_CONTROL_TYPE_BOOLEAN; break; |
| |
| case MIXERCONTROL_CONTROLTYPE_PAN : // fall through |
| case MIXERCONTROL_CONTROLTYPE_QSOUNDPAN: // fall through |
| case MIXERCONTROL_CONTROLTYPE_SLIDER : type = PORT_CONTROL_TYPE_SIGNED; break; |
| |
| case MIXERCONTROL_CONTROLTYPE_BASS : // fall through |
| //case MIXERCONTROL_CONTROLTYPE_EQUALIZER: // fall through |
| case MIXERCONTROL_CONTROLTYPE_FADER : // fall through |
| case MIXERCONTROL_CONTROLTYPE_TREBLE : type = PORT_CONTROL_TYPE_UNSIGNED; break; |
| case MIXERCONTROL_CONTROLTYPE_VOLUME : |
| type = PORT_CONTROL_TYPE_UNSIGNED; |
| if (line->cChannels == 2 && ((mixerControl->fdwControl & MIXERCONTROL_CONTROLF_UNIFORM) == 0)) { |
| type = PORT_CONTROL_TYPE_FAKE_VOLUME; |
| } |
| break; |
| } |
| if (type != 0) { |
| createPortControl(info, creator, mixerControl, type, controlObjects, controlCount); |
| // create fake balance for fake volume |
| if (type == PORT_CONTROL_TYPE_FAKE_VOLUME) { |
| createPortControl(info, creator, mixerControl, PORT_CONTROL_TYPE_FAKE_BALANCE, controlObjects, controlCount); |
| } |
| } |
| } |
| } |
| if (controlInfos.pamxctrl) { |
| free(controlInfos.pamxctrl); |
| controlInfos.pamxctrl = NULL; |
| } |
| TRACE0("<createLineControls\n"); |
| } |
| |
| void addCompoundControl(PortInfo* info, PortControlCreator* creator, char* name, void** controlObjects, int* controlCount) { |
| void* compControl; |
| |
| TRACE1(">addCompoundControl %d controls\n", *controlCount); |
| if (*controlCount) { |
| // create compound control and add it to the vector |
| compControl = (creator->newCompoundControl)(creator, name, controlObjects, *controlCount); |
| if (compControl) { |
| TRACE1(" addCompoundControl: calling addControl %p\n", compControl); |
| (creator->addControl)(creator, compControl); |
| } |
| *controlCount = 0; |
| } |
| TRACE0("<addCompoundControl\n"); |
| } |
| |
| void addAllControls(PortInfo* info, PortControlCreator* creator, void** controlObjects, int* controlCount) { |
| int i = 0; |
| |
| TRACE0(">addAllControl\n"); |
| // go through all controls and add them to the vector |
| for (i = 0; i < *controlCount; i++) { |
| (creator->addControl)(creator, controlObjects[i]); |
| } |
| *controlCount = 0; |
| TRACE0("<addAllControl\n"); |
| } |
| |
| |
| |
| void PORT_GetControls(void* id, INT32 portIndex, PortControlCreator* creator) { |
| MIXERLINE* line; |
| PortInfo* info = (PortInfo*) id; |
| int portCount = PORT_GetPortCount(id); |
| void** controls = NULL; |
| int controlCount; |
| UINT i; |
| |
| TRACE4(">PORT_GetControls(id=%p, portIndex=%d). controlIDs=%p, maxControlCount=%d\n", id, portIndex, info->controlIDs, info->maxControlCount); |
| if ((portIndex >= 0) && (portIndex < portCount)) { |
| line = info->ports[portIndex]; |
| if (line) { |
| // if the memory isn't reserved for the control structures, allocate it |
| if (!info->controlIDs) { |
| int i, maxCount = 0, muxCount = 0; |
| TRACE0("getControl: allocate mem\n"); |
| // get a maximum number of controls |
| // first for all destination lines |
| for (i = 0; i < info->dstLineCount; i++) { |
| MIXERLINE* thisLine = &(info->dstLines[i]); |
| maxCount += getControlCount(info->handle, thisLine, &muxCount); |
| } |
| // then all source lines |
| for (i = 0; i < info->srcLineCount; i++) { |
| MIXERLINE* thisLine = &(info->srcLines[i]); |
| maxCount += getControlCount(info->handle, thisLine, &muxCount); |
| } |
| info->maxControlCount = maxCount; |
| if (maxCount > 0) { |
| info->controlIDs = (PortControlID*) malloc(sizeof(PortControlID) * maxCount); |
| } else { |
| // no ports: nothing to do ! |
| return; |
| } |
| TRACE2("Creating muxData for %d elements and %d controlIDs.\n", muxCount, maxCount); |
| if (muxCount > 0) { |
| info->muxData = (MIXERCONTROLDETAILS_BOOLEAN*) malloc(sizeof(MIXERCONTROLDETAILS_BOOLEAN) * muxCount); |
| } |
| if (!info->controlIDs || (muxCount && !info->muxData)) { |
| ERROR3("PORT_GetControls: info->controlIDs=%p, muxCount=%d, info->muxData=%p !!\n", info->controlIDs, muxCount, info->muxData); |
| return; |
| } |
| } |
| if (info->maxControlCount == 0) { |
| return; |
| } |
| controls = (void*) malloc(info->maxControlCount * sizeof(void*)); |
| if (!controls) { |
| ERROR0("PORT_GetControls: couldn't allocate controls!\n"); |
| return; |
| } |
| |
| // add controls of this line |
| controlCount = 0; |
| // if this line is part of MUX, add the respective BOOLEANCONTROL as a control |
| if ((line->fdwLine & MIXERLINE_LINEF_SOURCE) == MIXERLINE_LINEF_SOURCE) { |
| MIXERLINE* dstLine = findDestLine(info, line->dwDestination); |
| TRACE0("Port_getControls: this is a source line\n"); |
| if (dstLine) { |
| // selection controls (implemented as Mute control) |
| createMuxControl(info, creator, dstLine, line->dwLineID, controls, &controlCount); |
| } |
| // then add all controls in one compound control |
| createLineControls(info, creator, line, controls, &controlCount); |
| addCompoundControl(info, creator, line->szName, controls, &controlCount); |
| } else { |
| TRACE0("getControl: this is a dest line\n"); |
| // if this is a destination line, add its controls |
| createLineControls(info, creator, line, controls, &controlCount); |
| addAllControls(info, creator, controls, &controlCount); |
| // then add all controls of its source lines as one compound control |
| for (i = 0; i < line->cConnections; i++) { |
| // then add all controls |
| MIXERLINE* srcLine = &(info->srcLines[line->dwUser + i]); |
| TRACE1("PORT_getControls: add source line %d\n", i); |
| createLineControls(info, creator, srcLine, controls, &controlCount); |
| addCompoundControl(info, creator, srcLine->szName, controls, &controlCount); |
| } |
| } |
| } |
| } |
| if (controls) { |
| free(controls); |
| } |
| TRACE0("< PORT_getControls\n"); |
| } |
| |
| int getControlValue(PortControlID* controlID) { |
| if (mixerGetControlDetails((HMIXEROBJ) controlID->portInfo->handle, &(controlID->details), |
| MIXER_GETCONTROLDETAILSF_VALUE | MIXER_OBJECTF_HMIXER) != MMSYSERR_NOERROR) { |
| ERROR0("getControlValue: unable to get control details!\n"); |
| //ERROR3(" cbStruct=%d, dwControlID=%d, cChannels=%d, ", controlID->details.cbStruct, controlID->details.dwControlID, controlID->details.cChannels); |
| //ERROR2(" cMultipleItems=%d, cbDetails=%d\n", controlID->details.cMultipleItems, controlID->details.cbDetails); |
| return FALSE; |
| } |
| return TRUE; |
| } |
| |
| int setControlValue(PortControlID* controlID) { |
| if (mixerSetControlDetails((HMIXEROBJ) controlID->portInfo->handle, &(controlID->details), |
| MIXER_SETCONTROLDETAILSF_VALUE | MIXER_OBJECTF_HMIXER) != MMSYSERR_NOERROR) { |
| ERROR0("setControlValue: unable to set control details!\n"); |
| //ERROR3(" cbStruct=%d, dwControlID=%d, cChannels=%d, ", controlID->details.cbStruct, controlID->details.dwControlID, controlID->details.cChannels); |
| //ERROR2(" cMultipleItems=%d, cbDetails=%d\n", controlID->details.cMultipleItems, controlID->details.cbDetails); |
| return FALSE; |
| } |
| return TRUE; |
| } |
| |
| INT32 PORT_GetIntValue(void* controlIDV) { |
| PortControlID* controlID = (PortControlID*) controlIDV; |
| MIXERCONTROLDETAILS_BOOLEAN* bools; |
| int ret = 0; |
| if (getControlValue(controlID)) { |
| switch (controlID->controlType) { |
| case PORT_CONTROL_TYPE_MUX: // fall through |
| case PORT_CONTROL_TYPE_MIXER: |
| bools = (MIXERCONTROLDETAILS_BOOLEAN*) controlID->details.paDetails; |
| ret = (bools[controlID->muxIndex].fValue)?TRUE:FALSE; |
| break; |
| case PORT_CONTROL_TYPE_BOOLEAN: |
| ret = (controlID->boolValue.fValue)?TRUE:FALSE; |
| break; |
| default: ERROR1("PORT_GetIntValue: wrong controlType=%d !\n", controlID->controlType); |
| } |
| } |
| return ret; |
| } |
| |
| void PORT_SetIntValue(void* controlIDV, INT32 value) { |
| PortControlID* controlID = (PortControlID*) controlIDV; |
| MIXERCONTROLDETAILS_BOOLEAN* bools; |
| UINT i; |
| |
| switch (controlID->controlType) { |
| case PORT_CONTROL_TYPE_MUX: |
| if (!value) { |
| // cannot unselect a MUX line |
| return; |
| } |
| if (!getControlValue(controlID)) { |
| return; |
| } |
| bools = (MIXERCONTROLDETAILS_BOOLEAN*) controlID->details.paDetails; |
| for (i = 0; i < controlID->details.cMultipleItems; i++) { |
| bools[i].fValue = (i == (UINT) controlID->muxIndex)?TRUE:FALSE; |
| } |
| break; |
| case PORT_CONTROL_TYPE_MIXER: |
| if (!getControlValue(controlID)) { |
| return; |
| } |
| bools = (MIXERCONTROLDETAILS_BOOLEAN*) controlID->details.paDetails; |
| bools[controlID->muxIndex].fValue = (value?TRUE:FALSE); |
| break; |
| case PORT_CONTROL_TYPE_BOOLEAN: |
| controlID->boolValue.fValue = (value?TRUE:FALSE); |
| break; |
| default: |
| ERROR1("PORT_SetIntValue: wrong controlType=%d !\n", controlID->controlType); |
| return; |
| } |
| setControlValue(controlID); |
| } |
| |
| float getFakeBalance(PortControlID* controlID) { |
| float volL, volR; |
| float range = (float) (controlID->max - controlID->min); |
| // pan is the ratio of left and right |
| volL = (((float) (controlID->unsignedValue[0].dwValue - controlID->min)) / range); |
| volR = (((float) (controlID->unsignedValue[1].dwValue - controlID->min)) / range); |
| if (volL > volR) { |
| return -1.0f + (volR / volL); |
| } |
| else if (volR > volL) { |
| return 1.0f - (volL / volR); |
| } |
| return 0.0f; |
| } |
| |
| float getFakeVolume(PortControlID* controlID) { |
| // volume is the greater value of both |
| UINT vol = controlID->unsignedValue[0].dwValue; |
| if (controlID->unsignedValue[1].dwValue > vol) { |
| vol = controlID->unsignedValue[1].dwValue; |
| } |
| return (((float) (vol - controlID->min)) / (controlID->max - controlID->min)); |
| } |
| |
| /* |
| * sets the unsigned values for left and right volume according to |
| * the given volume (0...1) and balance (-1..0..+1) |
| */ |
| void setFakeVolume(PortControlID* controlID, float vol, float bal) { |
| vol = vol * (controlID->max - controlID->min); |
| if (bal < 0.0f) { |
| controlID->unsignedValue[0].dwValue = (UINT) (vol + 0.5f) + controlID->min; |
| controlID->unsignedValue[1].dwValue = (UINT) ((vol * (bal + 1.0f)) + 0.5f) + controlID->min; |
| } else { |
| controlID->unsignedValue[1].dwValue = (UINT) (vol + 0.5f) + controlID->min; |
| controlID->unsignedValue[0].dwValue = (UINT) ((vol * (1.0f - bal)) + 0.5f) + controlID->min; |
| } |
| } |
| |
| float PORT_GetFloatValue(void* controlIDV) { |
| PortControlID* controlID = (PortControlID*) controlIDV; |
| float ret = 0.0f; |
| float range = (float) (controlID->max - controlID->min); |
| if (getControlValue(controlID)) { |
| switch (controlID->controlType) { |
| case PORT_CONTROL_TYPE_SIGNED: |
| ret = ((float) controlID->signedValue.lValue) / controlID->max; |
| break; |
| case PORT_CONTROL_TYPE_UNSIGNED: |
| ret = (((float) (controlID->unsignedValue[0].dwValue - controlID->min)) / range); |
| break; |
| case PORT_CONTROL_TYPE_FAKE_VOLUME: |
| ret = getFakeVolume(controlID); |
| break; |
| case PORT_CONTROL_TYPE_FAKE_BALANCE: |
| ret = getFakeBalance(controlID); |
| break; |
| default: ERROR1("PORT_GetFloatValue: wrong controlType=%d !\n", controlID->controlType); |
| } |
| } |
| return ret; |
| } |
| |
| void PORT_SetFloatValue(void* controlIDV, float value) { |
| PortControlID* controlID = (PortControlID*) controlIDV; |
| float range = (float) (controlID->max - controlID->min); |
| switch (controlID->controlType) { |
| case PORT_CONTROL_TYPE_SIGNED: |
| controlID->signedValue.lValue = (INT32) ((value * controlID->max) + 0.5f); |
| break; |
| case PORT_CONTROL_TYPE_UNSIGNED: |
| controlID->unsignedValue[0].dwValue = (INT32) ((value * range) + 0.5f) + controlID->min; |
| break; |
| case PORT_CONTROL_TYPE_FAKE_VOLUME: |
| if (!getControlValue(controlID)) { |
| return; |
| } |
| setFakeVolume(controlID, value, getFakeBalance(controlID)); |
| break; |
| case PORT_CONTROL_TYPE_FAKE_BALANCE: |
| if (!getControlValue(controlID)) { |
| return; |
| } |
| setFakeVolume(controlID, getFakeVolume(controlID), value); |
| break; |
| default: |
| ERROR1("PORT_SetFloatValue: wrong controlType=%d !\n", controlID->controlType); |
| return; |
| } |
| setControlValue(controlID); |
| } |
| |
| #endif // USE_PORTS |
