mirror of
git://source.winehq.org/git/wine.git
synced 2024-11-05 18:01:34 +00:00
295 lines
8.4 KiB
C
295 lines
8.4 KiB
C
/*
|
|
* Wine Driver for CoreAudio / AudioUnit
|
|
*
|
|
* Copyright 2005, 2006 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"
|
|
|
|
#define ULONG CoreFoundation_ULONG
|
|
#define HRESULT CoreFoundation_HRESULT
|
|
#ifndef HAVE_AUDIOUNIT_AUDIOCOMPONENT_H
|
|
#include <CoreServices/CoreServices.h>
|
|
#endif
|
|
#include <AudioUnit/AudioUnit.h>
|
|
#include <AudioToolbox/AudioToolbox.h>
|
|
#undef ULONG
|
|
#undef HRESULT
|
|
|
|
#undef DPRINTF
|
|
#undef STDMETHODCALLTYPE
|
|
#include "coreaudio.h"
|
|
#include "wine/debug.h"
|
|
|
|
#ifndef HAVE_AUDIOUNIT_AUDIOCOMPONENT_H
|
|
/* Define new AudioComponent Manager functions for compatibility's sake */
|
|
typedef Component AudioComponent;
|
|
typedef ComponentDescription AudioComponentDescription;
|
|
typedef ComponentInstance AudioComponentInstance;
|
|
|
|
static inline AudioComponent AudioComponentFindNext(AudioComponent ac, AudioComponentDescription *desc)
|
|
{
|
|
return FindNextComponent(ac, desc);
|
|
}
|
|
|
|
static inline OSStatus AudioComponentInstanceNew(AudioComponent ac, AudioComponentInstance *aci)
|
|
{
|
|
return OpenAComponent(ac, aci);
|
|
}
|
|
|
|
static inline OSStatus AudioComponentInstanceDispose(AudioComponentInstance aci)
|
|
{
|
|
return CloseComponent(aci);
|
|
}
|
|
#endif
|
|
|
|
#ifndef HAVE_AUGRAPHADDNODE
|
|
static inline OSStatus AUGraphAddNode(AUGraph graph, const AudioComponentDescription *desc, AUNode *node)
|
|
{
|
|
return AUGraphNewNode(graph, desc, 0, NULL, node);
|
|
}
|
|
|
|
static inline OSStatus AUGraphNodeInfo(AUGraph graph, AUNode node, AudioComponentDescription *desc, AudioUnit *au)
|
|
{
|
|
return AUGraphGetNodeInfo(graph, node, desc, 0, NULL, au);
|
|
}
|
|
#endif
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(wave);
|
|
WINE_DECLARE_DEBUG_CHANNEL(midi);
|
|
|
|
static const char *streamDescription(const AudioStreamBasicDescription* stream)
|
|
{
|
|
return wine_dbg_sprintf("\n mSampleRate : %f\n mFormatID : %s\n mFormatFlags : %lX\n mBytesPerPacket : %lu\n mFramesPerPacket : %lu\n mBytesPerFrame : %lu\n mChannelsPerFrame : %lu\n mBitsPerChannel : %lu\n",
|
|
stream->mSampleRate,
|
|
wine_dbgstr_fourcc(stream->mFormatID),
|
|
stream->mFormatFlags,
|
|
stream->mBytesPerPacket,
|
|
stream->mFramesPerPacket,
|
|
stream->mBytesPerFrame,
|
|
stream->mChannelsPerFrame,
|
|
stream->mBitsPerChannel);
|
|
}
|
|
|
|
int AudioUnit_CloseAudioUnit(AudioUnit au)
|
|
{
|
|
OSStatus err = AudioComponentInstanceDispose(au);
|
|
return (err == noErr);
|
|
}
|
|
|
|
int AudioUnit_InitializeWithStreamDescription(AudioUnit au, AudioStreamBasicDescription *stream)
|
|
{
|
|
OSStatus err = noErr;
|
|
|
|
TRACE("input format: %s\n", streamDescription(stream));
|
|
|
|
err = AudioUnitSetProperty(au, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input,
|
|
0, stream, sizeof(*stream));
|
|
|
|
if (err != noErr)
|
|
{
|
|
ERR("AudioUnitSetProperty return an error %s\n", wine_dbgstr_fourcc(err));
|
|
return 0;
|
|
}
|
|
|
|
err = AudioUnitInitialize(au);
|
|
if (err != noErr)
|
|
{
|
|
ERR("AudioUnitInitialize return an error %s\n", wine_dbgstr_fourcc(err));
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int AudioUnit_SetVolume(AudioUnit au, float left, float right)
|
|
{
|
|
OSStatus err = noErr;
|
|
static int once;
|
|
|
|
if (!once++) FIXME("independent left/right volume not implemented (%f, %f)\n", left, right);
|
|
|
|
err = AudioUnitSetParameter(au, kHALOutputParam_Volume, kAudioUnitParameterFlag_Output, 0, left, 0);
|
|
|
|
if (err != noErr)
|
|
{
|
|
ERR("AudioUnitSetParameter return an error %s\n", wine_dbgstr_fourcc(err));
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int AudioUnit_GetVolume(AudioUnit au, float *left, float *right)
|
|
{
|
|
OSStatus err = noErr;
|
|
static int once;
|
|
|
|
if (!once++) FIXME("independent left/right volume not implemented\n");
|
|
|
|
err = AudioUnitGetParameter(au, kHALOutputParam_Volume, kAudioUnitParameterFlag_Output, 0, left);
|
|
if (err != noErr)
|
|
{
|
|
ERR("AudioUnitGetParameter return an error %s\n", wine_dbgstr_fourcc(err));
|
|
return 0;
|
|
}
|
|
*right = *left;
|
|
return 1;
|
|
}
|
|
|
|
|
|
/* FIXME: implement sample rate conversion on input */
|
|
int AudioUnit_GetInputDeviceSampleRate(void)
|
|
{
|
|
AudioDeviceID defaultInputDevice;
|
|
UInt32 param;
|
|
AudioObjectPropertyAddress propertyAddress;
|
|
Float64 sampleRate;
|
|
OSStatus err;
|
|
|
|
param = sizeof(defaultInputDevice);
|
|
propertyAddress.mSelector = kAudioHardwarePropertyDefaultInputDevice;
|
|
propertyAddress.mScope = kAudioObjectPropertyScopeGlobal;
|
|
propertyAddress.mElement = kAudioObjectPropertyElementMaster;
|
|
err = AudioObjectGetPropertyData(kAudioObjectSystemObject, &propertyAddress, 0, NULL, ¶m, &defaultInputDevice);
|
|
if (err != noErr || defaultInputDevice == kAudioDeviceUnknown)
|
|
{
|
|
ERR("Couldn't get the default audio input device ID: %08lx\n", err);
|
|
return 0;
|
|
}
|
|
|
|
param = sizeof(sampleRate);
|
|
propertyAddress.mSelector = kAudioDevicePropertyNominalSampleRate;
|
|
propertyAddress.mScope = kAudioDevicePropertyScopeInput;
|
|
err = AudioObjectGetPropertyData(defaultInputDevice, &propertyAddress, 0, NULL, ¶m, &sampleRate);
|
|
if (err != noErr)
|
|
{
|
|
ERR("Couldn't get the device sample rate: %08lx\n", err);
|
|
return 0;
|
|
}
|
|
|
|
return sampleRate;
|
|
}
|
|
|
|
/*
|
|
* MIDI Synth Unit
|
|
*/
|
|
int SynthUnit_CreateDefaultSynthUnit(AUGraph *graph, AudioUnit *synth)
|
|
{
|
|
OSStatus err;
|
|
AudioComponentDescription desc;
|
|
AUNode synthNode;
|
|
AUNode outNode;
|
|
|
|
err = NewAUGraph(graph);
|
|
if (err != noErr)
|
|
{
|
|
ERR_(midi)("NewAUGraph return %s\n", wine_dbgstr_fourcc(err));
|
|
return 0;
|
|
}
|
|
|
|
desc.componentManufacturer = kAudioUnitManufacturer_Apple;
|
|
desc.componentFlags = 0;
|
|
desc.componentFlagsMask = 0;
|
|
|
|
/* create synth node */
|
|
desc.componentType = kAudioUnitType_MusicDevice;
|
|
desc.componentSubType = kAudioUnitSubType_DLSSynth;
|
|
|
|
err = AUGraphAddNode(*graph, &desc, &synthNode);
|
|
if (err != noErr)
|
|
{
|
|
ERR_(midi)("AUGraphAddNode cannot create synthNode : %s\n", wine_dbgstr_fourcc(err));
|
|
return 0;
|
|
}
|
|
|
|
/* create out node */
|
|
desc.componentType = kAudioUnitType_Output;
|
|
desc.componentSubType = kAudioUnitSubType_DefaultOutput;
|
|
|
|
err = AUGraphAddNode(*graph, &desc, &outNode);
|
|
if (err != noErr)
|
|
{
|
|
ERR_(midi)("AUGraphAddNode cannot create outNode %s\n", wine_dbgstr_fourcc(err));
|
|
return 0;
|
|
}
|
|
|
|
err = AUGraphOpen(*graph);
|
|
if (err != noErr)
|
|
{
|
|
ERR_(midi)("AUGraphOpen return %s\n", wine_dbgstr_fourcc(err));
|
|
return 0;
|
|
}
|
|
|
|
/* connecting the nodes */
|
|
err = AUGraphConnectNodeInput(*graph, synthNode, 0, outNode, 0);
|
|
if (err != noErr)
|
|
{
|
|
ERR_(midi)("AUGraphConnectNodeInput cannot connect synthNode to outNode : %s\n", wine_dbgstr_fourcc(err));
|
|
return 0;
|
|
}
|
|
|
|
/* Get the synth unit */
|
|
err = AUGraphNodeInfo(*graph, synthNode, 0, synth);
|
|
if (err != noErr)
|
|
{
|
|
ERR_(midi)("AUGraphNodeInfo return %s\n", wine_dbgstr_fourcc(err));
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
int SynthUnit_Initialize(AudioUnit synth, AUGraph graph)
|
|
{
|
|
OSStatus err = noErr;
|
|
|
|
err = AUGraphInitialize(graph);
|
|
if (err != noErr)
|
|
{
|
|
ERR_(midi)("AUGraphInitialize(%p) return %s\n", graph, wine_dbgstr_fourcc(err));
|
|
return 0;
|
|
}
|
|
|
|
err = AUGraphStart(graph);
|
|
if (err != noErr)
|
|
{
|
|
ERR_(midi)("AUGraphStart(%p) return %s\n", graph, wine_dbgstr_fourcc(err));
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
int SynthUnit_Close(AUGraph graph)
|
|
{
|
|
OSStatus err = noErr;
|
|
|
|
err = AUGraphStop(graph);
|
|
if (err != noErr)
|
|
{
|
|
ERR_(midi)("AUGraphStop(%p) return %s\n", graph, wine_dbgstr_fourcc(err));
|
|
return 0;
|
|
}
|
|
|
|
err = DisposeAUGraph(graph);
|
|
if (err != noErr)
|
|
{
|
|
ERR_(midi)("DisposeAUGraph(%p) return %s\n", graph, wine_dbgstr_fourcc(err));
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|