void showAllDevices(ASDeviceType typeRequested) {
UInt32 propertySize;
AudioDeviceID dev_array[64];
int numberOfDevices = 0;
ASDeviceType device_type;
char deviceName[256];
AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &propertySize, NULL);
AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &propertySize, dev_array);
numberOfDevices = (propertySize / sizeof(AudioDeviceID));
for(int i = 0; i < numberOfDevices; ++i) {
device_type = getDeviceType(dev_array[i]);
switch(typeRequested) {
case kAudioTypeInput:
case kAudioTypeOutput:
if (device_type != typeRequested) continue;
break;
case kAudioTypeSystemOutput:
if (device_type != kAudioTypeOutput) continue;
break;
}
getDeviceName(dev_array[i], deviceName);
printf("%s (%s)\n",deviceName,deviceTypeName(device_type));
}
}
AudioDeviceID getRequestedDeviceID(char * requestedDeviceName, ASDeviceType typeRequested) {
UInt32 propertySize;
AudioDeviceID dev_array[64];
int numberOfDevices = 0;
char deviceName[256];
AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &propertySize, NULL);
// printf("propertySize=%d\n",propertySize);
AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &propertySize, dev_array);
numberOfDevices = (propertySize / sizeof(AudioDeviceID));
// printf("numberOfDevices=%d\n",numberOfDevices);
for(int i = 0; i < numberOfDevices; ++i) {
switch(typeRequested) {
case kAudioTypeInput:
case kAudioTypeOutput:
if (getDeviceType(dev_array[i]) != typeRequested) continue;
break;
case kAudioTypeSystemOutput:
if (getDeviceType(dev_array[i]) != kAudioTypeOutput) continue;
break;
}
getDeviceName(dev_array[i], deviceName);
// printf("For device %d, id = %d and name is %s\n",i,dev_array[i],deviceName);
if (strcmp(requestedDeviceName, deviceName) == 0) {
return dev_array[i];
}
}
return kAudioDeviceUnknown;
}
AudioDeviceID CCoreAudioHardware::FindAudioDevice(const std::string &searchName)
{
AudioDeviceID deviceId = 0;
if (!searchName.length())
return deviceId;
std::string searchNameLowerCase = searchName;
std::transform(searchNameLowerCase.begin(), searchNameLowerCase.end(), searchNameLowerCase.begin(), ::tolower );
if (searchNameLowerCase.compare("default") == 0)
{
AudioDeviceID defaultDevice = GetDefaultOutputDevice();
CLog::Log(LOGDEBUG, "CCoreAudioHardware::FindAudioDevice: "
"Returning default device [0x%04x].", (uint)defaultDevice);
return defaultDevice;
}
CLog::Log(LOGDEBUG, "CCoreAudioHardware::FindAudioDevice: "
"Searching for device - %s.", searchName.c_str());
// Obtain a list of all available audio devices
UInt32 size = 0;
AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &size, NULL);
size_t deviceCount = size / sizeof(AudioDeviceID);
AudioDeviceID* pDevices = new AudioDeviceID[deviceCount];
OSStatus ret = AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &size, pDevices);
if (ret)
{
CLog::Log(LOGERROR, "CCoreAudioHardware::FindAudioDevice: "
"Unable to retrieve the list of available devices. Error = %s", GetError(ret).c_str());
delete[] pDevices;
return 0;
}
// Attempt to locate the requested device
std::string deviceName;
for (size_t dev = 0; dev < deviceCount; dev++)
{
CCoreAudioDevice device;
device.Open((pDevices[dev]));
deviceName = device.GetName();
UInt32 totalChannels = device.GetTotalOutputChannels();
CLog::Log(LOGDEBUG, "CCoreAudioHardware::FindAudioDevice: "
#if __LP64__
"Device[0x%04x]"
#else
"Device[0x%04lx]"
#endif
" - Name: '%s', Total Ouput Channels: %u. ",
pDevices[dev], deviceName.c_str(), (uint)totalChannels);
std::transform( deviceName.begin(), deviceName.end(), deviceName.begin(), ::tolower );
if (searchNameLowerCase.compare(deviceName) == 0)
deviceId = pDevices[dev];
if (deviceId)
break;
}
delete[] pDevices;
return deviceId;
}
static void audio_cap_ca_help(const char *driver_name)
{
UNUSED(driver_name);
OSErr ret;
AudioDeviceID *dev_ids;
int dev_items;
int i;
UInt32 size;
printf("\tcoreaudio : default CoreAudio input\n");
ret = AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &size, NULL);
if(ret) goto error;
dev_ids = malloc(size);
dev_items = size / sizeof(AudioDeviceID);
ret = AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &size, dev_ids);
if(ret) goto error;
for(i = 0; i < dev_items; ++i)
{
char name[128];
size = sizeof(name);
ret = AudioDeviceGetProperty(dev_ids[i], 0, 0, kAudioDevicePropertyDeviceName, &size, name);
fprintf(stderr,"\tcoreaudio:%d : %s\n", (int) dev_ids[i], name);
}
free(dev_ids);
return;
error:
fprintf(stderr, "[CoreAudio] error obtaining device list.\n");
}
UInt32 CCoreAudioHardware::GetOutputDevices(CoreAudioDeviceList* pList)
{
if (!pList)
return 0;
// Obtain a list of all available audio devices
UInt32 found = 0;
UInt32 size = 0;
AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &size, NULL);
UInt32 deviceCount = size / sizeof(AudioDeviceID);
AudioDeviceID* pDevices = new AudioDeviceID[deviceCount];
OSStatus ret = AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &size, pDevices);
if (ret)
CLog::Log(LOGERROR, "CCoreAudioHardware::GetOutputDevices: Unable to retrieve the list of available devices. Error = 0x%08x (%4.4s)", ret, CONVERT_OSSTATUS(ret));
else
{
for (UInt32 dev = 0; dev < deviceCount; dev++)
{
if (CCoreAudioDevice::GetTotalOutputChannels(pDevices[dev]) == 0)
continue;
found++;
pList->push_back(pDevices[dev]);
}
}
delete[] pDevices;
return found;
}
QList<AudioDeviceID> UBAudioQueueRecorder::inputDeviceIDs()
{
QList<AudioDeviceID> inputDeviceIDs;
UInt32 deviceIDsArraySize(0);
AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &deviceIDsArraySize, 0);
AudioDeviceID deviceIDs[deviceIDsArraySize / sizeof(AudioDeviceID)];
AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &deviceIDsArraySize, deviceIDs);
int deviceIDsCount = deviceIDsArraySize / sizeof(AudioDeviceID);
for (int i = 0; i < deviceIDsCount; i ++)
{
AudioStreamBasicDescription sf;
UInt32 size = sizeof(AudioStreamBasicDescription);
if (noErr == AudioDeviceGetProperty(deviceIDs[i], 0, true, kAudioDevicePropertyStreamFormat, &size, &sf))
{
inputDeviceIDs << deviceIDs[i];
}
}
/*
foreach(AudioDeviceID id, inputDeviceIDs)
{
qDebug() << "Device" << id << deviceNameFromDeviceID(id) << deviceUIDFromDeviceID(id);
}
*/
return inputDeviceIDs;
}
UInt32 CAAudioHardwareSystem::GetPropertyDataSize(AudioHardwarePropertyID inPropertyID)
{
UInt32 theSize = 0;
OSStatus theError = AudioHardwareGetPropertyInfo(inPropertyID, &theSize, NULL);
ThrowIfError(theError, CAException(theError), "CAAudioHardwareSystem::GetPropertyDataSize: got an error getting info about a property");
return theSize;
}
QList<QByteArray> QAudioDeviceInfoInternal::availableDevices(QAudio::Mode mode)
{
QList<QByteArray> devices;
UInt32 propSize = 0;
if (AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &propSize, 0) == noErr) {
const int dc = propSize / sizeof(AudioDeviceID);
if (dc > 0) {
AudioDeviceID* audioDevices = new AudioDeviceID[dc];
if (AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &propSize, audioDevices) == noErr) {
for (int i = 0; i < dc; ++i) {
QByteArray info = get_device_info(audioDevices[i], mode);
if (!info.isNull())
devices << info;
}
}
delete audioDevices;
}
}
return devices;
}
const std::vector<InputDeviceRef>& InputImplAudioUnit::getDevices( bool forceRefresh )
{
if( forceRefresh || ! sDevicesEnumerated ) {
sDevices.clear();
UInt32 propSize;
AudioHardwareGetPropertyInfo( kAudioHardwarePropertyDevices, &propSize, NULL );
uint32_t deviceCount = ( propSize / sizeof(AudioDeviceID) );
AudioDeviceID deviceIds[deviceCount];
AudioHardwareGetProperty( kAudioHardwarePropertyDevices, &propSize, &deviceIds );
for( uint32_t i = 0; i < deviceCount; i++ ) {
try {
InputDeviceRef aDevice = InputDeviceRef( new Device( deviceIds[i] ) );
sDevices.push_back( aDevice );
} catch( InvalidDeviceInputExc ) {
continue;
}
}
sDevicesEnumerated = true;
}
return sDevices;
}
bool CAAudioHardwareSystem::PropertyIsSettable(AudioHardwarePropertyID inPropertyID)
{
Boolean isWritable = false;
OSStatus theError = AudioHardwareGetPropertyInfo(inPropertyID, NULL, &isWritable);
ThrowIfError(theError, CAException(theError), "CAAudioHardwareSystem::PropertyIsSettable: got an error getting info about a property");
return isWritable != 0;
}
void CCoreAudioHardware::ResetAudioDevices()
{
// Reset any devices with an AC3 stream back to a Linear PCM
// so that they can become a default output device
UInt32 size;
AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &size, NULL);
AudioDeviceID *devices = (AudioDeviceID*)malloc(size);
if (!devices)
{
CLog::Log(LOGERROR, "CCoreAudioHardware::ResetAudioDevices: ResetAudioDevices - out of memory?");
return;
}
int numDevices = size / sizeof(AudioDeviceID);
AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &size, devices);
for (int i = 0; i < numDevices; i++)
{
AudioStreamID *streams;
streams = StreamsList(devices[i]);
for (int j = 0; streams[j] != kAudioHardwareBadStreamError; j++)
ResetStream(streams[j]);
free(streams);
}
free(devices);
}
static PaError InitializeDeviceInfos( PaMacCoreHostApiRepresentation *macCoreHostApi, PaHostApiIndex hostApiIndex )
{
PaError result = paNoError;
PaUtilHostApiRepresentation *hostApi;
PaMacCoreDeviceInfo *deviceInfoArray;
// initialise device counts and default devices under the assumption that there are no devices. These values are incremented below if and when devices are successfully initialized.
hostApi = &macCoreHostApi->inheritedHostApiRep;
hostApi->info.deviceCount = 0;
hostApi->info.defaultInputDevice = paNoDevice;
hostApi->info.defaultOutputDevice = paNoDevice;
UInt32 propsize;
AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &propsize, NULL);
int numDevices = propsize / sizeof(AudioDeviceID);
hostApi->info.deviceCount = numDevices;
if (numDevices > 0) {
hostApi->deviceInfos = (PaDeviceInfo**)PaUtil_GroupAllocateMemory(
macCoreHostApi->allocations, sizeof(PaDeviceInfo*) * numDevices );
if( !hostApi->deviceInfos )
{
return paInsufficientMemory;
}
// allocate all device info structs in a contiguous block
deviceInfoArray = (PaMacCoreDeviceInfo*)PaUtil_GroupAllocateMemory(
macCoreHostApi->allocations, sizeof(PaMacCoreDeviceInfo) * numDevices );
if( !deviceInfoArray )
{
return paInsufficientMemory;
}
macCoreHostApi->macCoreDeviceIds = PaUtil_GroupAllocateMemory(macCoreHostApi->allocations, propsize);
AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &propsize, macCoreHostApi->macCoreDeviceIds);
AudioDeviceID defaultInputDevice, defaultOutputDevice;
propsize = sizeof(AudioDeviceID);
AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, &propsize, &defaultInputDevice);
AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice, &propsize, &defaultOutputDevice);
UInt32 i;
for (i = 0; i < numDevices; ++i) {
if (macCoreHostApi->macCoreDeviceIds[i] == defaultInputDevice) {
hostApi->info.defaultInputDevice = i;
}
if (macCoreHostApi->macCoreDeviceIds[i] == defaultOutputDevice) {
hostApi->info.defaultOutputDevice = i;
}
InitializeDeviceInfo(&deviceInfoArray[i], macCoreHostApi->macCoreDeviceIds[i], hostApiIndex);
hostApi->deviceInfos[i] = &(deviceInfoArray[i].inheritedDeviceInfo);
}
}
return result;
}
int macosx_audio_device_count(void)
/* Then this one tells us the number of 'em */
{
OSStatus err = noErr;
UInt32 theSize;
err = AudioHardwareGetPropertyInfo ( kAudioHardwarePropertyDevices, &theSize, NULL );
int num_devices;
num_devices = theSize / sizeof(AudioDeviceID);
//return num_devices;
return 1;
};
static bool scanDevices(unsigned index)
{
OSStatus err = noErr;
UInt32 size;
AudioDeviceID *id;
unsigned i;
if(!devlist) {
if(AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &size, NULL) != noErr)
return false;
devcount = size / sizeof(AudioDeviceID);
devlist = (AudioDeviceID *)malloc(size);
if(AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &size, (void *) devlist) != noErr) {
free(devlist);
return false;
}
size = sizeof(AudioDeviceID);
if(AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, &size, &id) == noErr) {
for(i = 0; i < devcount; ++i)
{
if(!memcmp(&devlist[i], &id, sizeof(AudioDeviceID))) {
devinput = &devlist[i];
break;
}
}
}
size = sizeof(AudioDeviceID);
if(AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice, &size, &id) == noErr) {
for(i = 0; i < devcount; ++i)
{
if(!memcmp(&devlist[i], &id, sizeof(AudioDeviceID))) {
devoutput = &devlist[i];
break;
}
}
}
}
if(!devcount)
return false;
if(index > devcount)
return false;
return true;
}
static void au_card_detect(MSSndCardManager * m)
{
OSStatus err;
UInt32 slen;
int count;
Boolean writable;
int i;
writable = 0;
slen = 0;
err =
AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &slen,
&writable);
if (err != kAudioHardwareNoError) {
ms_error("get kAudioHardwarePropertyDevices error %ld", err);
return;
}
AudioDeviceID devices[slen / sizeof(AudioDeviceID)];
err =
AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &slen, devices);
if (err != kAudioHardwareNoError) {
ms_error("get kAudioHardwarePropertyDevices error %ld", err);
return;
}
/*first, add Default AudioUnit
does not work: why ?
*/
/*ms_snd_card_manager_add_card(m,ca_card_new("Default", "",-1, MS_SND_CARD_CAP_CAPTURE|MS_SND_CARD_CAP_PLAYBACK));
*/
count = slen / sizeof(AudioDeviceID);
for (i = 0; i < count; i++) {
MSSndCard *card;
char uidname[256]= {0},devname[256]= {0};
int card_capacity=0;
if (check_card_capability(devices[i],FALSE,devname,uidname,sizeof(uidname))) {
card_capacity|=MS_SND_CARD_CAP_PLAYBACK;
}
if (check_card_capability(devices[i],TRUE,devname,uidname,sizeof(uidname))) {
card_capacity|=MS_SND_CARD_CAP_CAPTURE;
}
if (card_capacity) {
card=ca_card_new(devname, uidname, devices[i], card_capacity);
ms_snd_card_manager_add_card(m, card);
}
}
}
AudioDeviceID CCoreAudioHardware::FindAudioDevice(CStdString searchName)
{
if (!searchName.length())
return 0;
UInt32 size = 0;
AudioDeviceID deviceId = 0;
OSStatus ret;
if (searchName.Equals("Default Output Device"))
{
AudioDeviceID defaultDevice = GetDefaultOutputDevice();
CLog::Log(LOGDEBUG, "CCoreAudioHardware::FindAudioDevice: Returning default device [0x%04x].", defaultDevice);
return defaultDevice;
}
CLog::Log(LOGDEBUG, "CCoreAudioHardware::FindAudioDevice: Searching for device - %s.", searchName.c_str());
// Obtain a list of all available audio devices
AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &size, NULL);
UInt32 deviceCount = size / sizeof(AudioDeviceID);
AudioDeviceID* pDevices = new AudioDeviceID[deviceCount];
ret = AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &size, pDevices);
if (ret)
{
CLog::Log(LOGERROR, "CCoreAudioHardware::FindAudioDevice: Unable to retrieve the list of available devices. Error = 0x%08x (%4.4s)", ret, CONVERT_OSSTATUS(ret));
delete[] pDevices;
return 0;
}
// Attempt to locate the requested device
CStdString deviceName;
for (UInt32 dev = 0; dev < deviceCount; dev++)
{
CCoreAudioDevice device;
device.Open((pDevices[dev]));
device.GetName(deviceName);
UInt32 totalChannels = device.GetTotalOutputChannels();
CLog::Log(LOGDEBUG, "CCoreAudioHardware::FindAudioDevice: Device[0x%04x] - Name: '%s', Total Ouput Channels: %u. ", pDevices[dev], deviceName.c_str(), totalChannels);
if (searchName.Equals(deviceName))
deviceId = pDevices[dev];
if (deviceId)
break;
}
delete[] pDevices;
return deviceId;
}
static OSStatus display_device_names()
{
UInt32 size;
Boolean isWritable;
int i, deviceNum;
OSStatus err;
CFStringRef UIname;
err = AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &size, &isWritable);
if (err != noErr)
return err;
deviceNum = size/sizeof(AudioDeviceID);
AudioDeviceID devices[deviceNum];
err = AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &size, devices);
if (err != noErr)
return err;
for (i = 0; i < deviceNum; i++) {
char device_name[256];
char internal_name[256];
size = sizeof(CFStringRef);
UIname = NULL;
err = AudioDeviceGetProperty(devices[i], 0, false, kAudioDevicePropertyDeviceUID, &size, &UIname);
if (err == noErr) {
CFStringGetCString(UIname, internal_name, 256, CFStringGetSystemEncoding());
} else {
goto error;
}
size = 256;
err = AudioDeviceGetProperty(devices[i], 0, false, kAudioDevicePropertyDeviceName, &size, device_name);
if (err != noErr)
return err;
jack_info("ICI");
jack_info("Device name = \'%s\', internal_name = \'%s\' (to be used as -d parameter)", device_name, internal_name);
}
return noErr;
error:
if (UIname != NULL)
CFRelease(UIname);
return err;
}
AudioDeviceID getNextDeviceID(AudioDeviceID currentDeviceID, ASDeviceType typeRequested) {
UInt32 propertySize;
AudioDeviceID dev_array[64];
int numberOfDevices = 0;
AudioDeviceID first_dev = kAudioDeviceUnknown;
int found = -1;
AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &propertySize, NULL);
// printf("propertySize=%d\n",propertySize);
AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &propertySize, dev_array);
numberOfDevices = (propertySize / sizeof(AudioDeviceID));
// printf("numberOfDevices=%d\n",numberOfDevices);
for(int i = 0; i < numberOfDevices; ++i) {
switch(typeRequested) {
case kAudioTypeInput:
if (!isAnInputDevice(dev_array[i])) continue;
break;
case kAudioTypeOutput:
if (!isAnOutputDevice(dev_array[i])) continue;
break;
case kAudioTypeSystemOutput:
if (getDeviceType(dev_array[i]) != kAudioTypeOutput) continue;
break;
default: break;
}
if (first_dev == kAudioDeviceUnknown) {
first_dev = dev_array[i];
}
if (found >= 0) {
return dev_array[i];
}
if (dev_array[i] == currentDeviceID) {
found = i;
}
}
return first_dev;
}
static OSStatus get_device_id_from_num(int i, AudioDeviceID * id)
{
OSStatus theStatus;
UInt32 theSize;
int nDevices;
AudioDeviceID *theDeviceList;
theStatus =
AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices,
&theSize, NULL);
nDevices = theSize / sizeof(AudioDeviceID);
theDeviceList =
(AudioDeviceID *) malloc(nDevices * sizeof(AudioDeviceID));
theStatus =
AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &theSize,
theDeviceList);
*id = theDeviceList[i];
return theStatus;
}
AudioDeviceID getRequestedDeviceID(char* requestedDeviceName) {
UInt32 propertySize;
AudioDeviceID dev_array[64];
int numberOfDevices = 0;
char deviceName[256];
AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &propertySize, NULL);
AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &propertySize, dev_array);
numberOfDevices = (propertySize / sizeof(AudioDeviceID));
for(int i = 0; i < numberOfDevices; ++i) {
if (!isAnOutputDevice(dev_array[i])) continue;
getDeviceName(dev_array[i], deviceName);
if (strcmp(requestedDeviceName, deviceName) == 0) {
return dev_array[i];
}
}
return kAudioDeviceUnknown;
}
std::vector<AudioDeviceID> CoreAudioUtilities::audioDeviceList(bool isInput) {
OSStatus status = noErr;
UInt32 numberOfDevices = 0;
UInt32 deviceListSize = 0;
AudioDeviceID * deviceList = NULL;
std::vector<AudioDeviceID> result;
// Getting number of devices
status = AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &deviceListSize, NULL);
if (status) {
LOG_ERROR("Can't get property info: kAudioHardwarePropertyDevices");
return result;
}
numberOfDevices = deviceListSize / sizeof(AudioDeviceID);
////
// Getting device list
deviceList = (AudioDeviceID *) calloc(sizeof(AudioDeviceID), deviceListSize);
status = AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &deviceListSize, deviceList);
if (status) {
LOG_ERROR("Can't get property: kAudioHardwarePropertyDevices");
return result;
}
////
// Populating the result
for (unsigned i = 0 ; i < numberOfDevices ; ++i) {
if ((isInput && hasChannel(deviceList[i], true))
|| (!isInput && hasChannel(deviceList[i], false))) {
result.push_back(deviceList[i]);
}
}
////
return result;
}
void AudioDeviceList::BuildList()
{
mDevices.clear();
UInt32 propsize;
verify_noerr(AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &propsize, NULL));
int nDevices = propsize / sizeof(AudioDeviceID);
AudioDeviceID *devids = new AudioDeviceID[nDevices];
verify_noerr(AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &propsize, devids));
for (int i = 0; i < nDevices; ++i) {
AudioDevice dev(devids[i], mInputs);
if (dev.CountChannels() > 0) {
Device d;
d.mID = devids[i];
dev.GetName(d.mName, sizeof(d.mName));
mDevices.push_back(d);
}
}
delete[] devids;
}
UInt32 CCoreAudioHardware::GetOutputDevices(CoreAudioDeviceList *pList)
{
UInt32 found = 0;
if (!pList)
return found;
// Obtain a list of all available audio devices
size_t size = 0;
AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &size, NULL);
size_t deviceCount = size / sizeof(AudioDeviceID);
AudioDeviceID* pDevices = new AudioDeviceID[deviceCount];
AudioObjectPropertyAddress propertyAddress;
propertyAddress.mScope = kAudioObjectPropertyScopeGlobal;
propertyAddress.mElement = kAudioObjectPropertyElementMaster;
propertyAddress.mSelector = kAudioHardwarePropertyDevices;
OSStatus ret = AudioObjectGetPropertyData(kAudioObjectSystemObject,
&propertyAddress, 0, NULL, &size, pDevices);
if (ret)
CLog::Log(LOGERROR, "CCoreAudioHardware::GetOutputDevices:"
" Unable to retrieve the list of available devices. Error = %s", GetError(ret).c_str());
else
{
for (size_t dev = 0; dev < deviceCount; dev++)
{
CCoreAudioDevice device(pDevices[dev]);
if (device.GetTotalOutputChannels() == 0)
continue;
found++;
pList->push_back(pDevices[dev]);
}
}
delete[] pDevices;
return found;
}
// ----------------------------------------------------------
bool ofxAudioUnitOutput::configureOutputDevice(int deviceID)
// ----------------------------------------------------------
{
OSStatus err = noErr;
UInt32 outSize;
Boolean outWritable;
err = AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &outSize, &outWritable);
if ( err != noErr ) cout<<"err 1"<<endl;
UInt16 devicesAvailable = outSize / sizeof(AudioDeviceID);
if ( devicesAvailable < 1 )
{
fprintf(stderr, "No devices\n" );
//return err;
}else{
cout<<"*devicesAvailable "<<devicesAvailable<<endl;
}
UInt32 on = 1;
UInt32 off = 0;
OFXAU_RET_FALSE(AudioUnitSetProperty(*_unit,
kAudioOutputUnitProperty_EnableIO,
kAudioUnitScope_Input,
1,
&off,
sizeof(off)),
"disabling input on HAL unit");
OFXAU_RET_FALSE(AudioUnitSetProperty(*_unit,
kAudioOutputUnitProperty_EnableIO,
kAudioUnitScope_Output,
0,
&on,
sizeof(on)),
"enabling output on HAL unit");
AudioDeviceID outputDeviceID = kAudioObjectUnknown;
UInt32 deviceIDSize = sizeof( AudioDeviceID );
AudioObjectPropertyAddress prop_addr = {
kAudioHardwarePropertyDefaultOutputDevice,
kAudioObjectPropertyScopeGlobal,
kAudioObjectPropertyElementMaster
};
OFXAU_RET_FALSE(AudioObjectGetPropertyData(kAudioObjectSystemObject,
&prop_addr,
0,
NULL,
&deviceIDSize,
&outputDeviceID),
"getting device ID for default input");
if(deviceID != -1) outputDeviceID = deviceID;
OFXAU_RET_FALSE(AudioUnitSetProperty(*_unit,
kAudioOutputUnitProperty_CurrentDevice,
kAudioUnitScope_Global,
0,
&outputDeviceID,
deviceIDSize),
"setting HAL unit's device ID");
cout<<"outputDeviceID "<<outputDeviceID<<endl;
OFXAU_RET_BOOL(AudioUnitInitialize(*_unit),
"initializing hardware input unit after setting it to input mode");
}
PlexAudioDevicesPtr PlexAudioDevices::FindAll()
{
OSStatus err = noErr;
UInt32 paramSize = 0;
PlexAudioDevices* audioDevices = new PlexAudioDevices();
// Get number of devices.
SAFELY(AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, ¶mSize, NULL));
if (err == noErr)
{
int totalDeviceCount = paramSize / sizeof(AudioDeviceID);
if (totalDeviceCount > 0)
{
CLog::Log(LOGDEBUG, "System has %ld device(s)", totalDeviceCount);
// Allocate the device ID array and retreive them.
AudioDeviceID* pDevices = (AudioDeviceID* )malloc(paramSize);
SAFELY(AudioHardwareGetProperty( kAudioHardwarePropertyDevices, ¶mSize, pDevices));
if (err == noErr)
{
AudioDeviceID defaultDeviceID = 0;
// Find the ID of the default Device.
paramSize = sizeof(AudioDeviceID);
SAFELY(AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice, ¶mSize, &defaultDeviceID));
if (err == noErr)
{
for (int i=0; i<totalDeviceCount; i++)
{
PlexAudioDevicePtr audioDevice = PlexAudioDevicePtr(new PlexAudioDevice(pDevices[i]));
// Add valid devices that support output.
if (audioDevice->isValid() && audioDevice->hasOutput())
{
audioDevices->m_audioDevices.push_back(audioDevice);
// Set the default device.
if (defaultDeviceID == pDevices[i])
audioDevices->m_defaultDevice = audioDevice;
// Set the selected device.
if (g_guiSettings.GetSetting("audiooutput.audiodevice") && g_guiSettings.GetString("audiooutput.audiodevice") == audioDevice->getName())
audioDevices->m_selectedDevice = audioDevice;
}
}
// If we haven't selected any devices, select the default one.
if (!audioDevices->m_selectedDevice)
audioDevices->m_selectedDevice = audioDevices->m_defaultDevice;
// Check if the selected device is alive and usable.
if (audioDevices->m_selectedDevice->isAlive() == false)
{
CLog::Log(LOGWARNING, "Selected audio device [%s] is not alive, switching to default device", audioDevices->m_selectedDevice->getName().c_str());
audioDevices->m_selectedDevice = audioDevices->m_defaultDevice;
}
}
}
free(pDevices);
}
}
// FIXME? Attach a Listener so that we are notified of a change in the Device setup.
// AudioHardwareAddPropertyListener( kAudioHardwarePropertyDevices, HardwareListener, (void *)p_aout);
return PlexAudioDevicesPtr(audioDevices);
}
int macosx_audio_open(audio_desc_t ad, audio_format* ifmt, audio_format *ofmt)
{
OSStatus err = noErr;
UInt32 propertySize;
Boolean writable;
obtained_ = false;
add = ad;
//dev[0] = devices[ad];
UNUSED(ofmt);
// Get the default input device ID.
err = AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDefaultInputDevice, &propertySize, &writable);
if (err != noErr) {
return 0;
}
err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, &propertySize, &(devices[ad].inputDeviceID_));
if (err != noErr) {
debug_msg("error kAudioHardwarePropertyDefaultInputDevice");
return 0;
}
if (devices[ad].inputDeviceID_ == kAudioDeviceUnknown) {
debug_msg("error kAudioDeviceUnknown");
return 0;
}
// Get the input stream description.
err = AudioDeviceGetPropertyInfo(devices[ad].inputDeviceID_, 0, true, kAudioDevicePropertyStreamFormat, &propertySize, &writable);
if (err != noErr) {
debug_msg("error AudioDeviceGetPropertyInfo");
return 0;
}
err = AudioDeviceGetProperty(devices[ad].inputDeviceID_, 0, true, kAudioDevicePropertyStreamFormat, &propertySize, &(devices[ad].inputStreamBasicDescription_));
//printf("inputStreamBasicDescription_.mBytesPerFrame %d\n", devices[add].inputStreamBasicDescription_);
if (err != noErr) {
debug_msg("error AudioDeviceGetProperty");
return 0;
}
// nastavime maly endian
devices[ad].inputStreamBasicDescription_.mFormatFlags &= (kAudioFormatFlagIsBigEndian & 0);
if (writable) {
err = AudioDeviceSetProperty(devices[ad].inputDeviceID_, NULL, 0, true, kAudioDevicePropertyStreamFormat, sizeof(AudioStreamBasicDescription), &(devices[ad].inputStreamBasicDescription_));
if (err != noErr) printf("err: AudioDeviceSetProperty: kAudioDevicePropertyStreamFormat\n");
}
/* set the buffer size of the device */
/*
int bufferByteSize = 8192;
propertySize = sizeof(bufferByteSize);
err = AudioDeviceSetProperty(devices[ad].inputDeviceID_, NULL, 0, true, kAudioDevicePropertyBufferSize, propertySize, &bufferByteSize);
if (err != noErr) debug_msg("err: Set kAudioDevicePropertyBufferSize to %d\n", bufferByteSize);
else debug_msg("sucessfully set kAudioDevicePropertyBufferSize to %d\n", bufferByteSize);
*/
// Set the device sample rate -- a temporary fix for the G5's
// built-in audio and possibly other audio devices.
Boolean IsInput = 0;
int inChannel = 0;
Float64 theAnswer = 44100;
UInt32 theSize = sizeof(theAnswer);
err = AudioDeviceSetProperty(devices[ad].inputDeviceID_, NULL, inChannel, IsInput,
kAudioDevicePropertyNominalSampleRate, theSize, &theAnswer);
if (err != noErr) {
debug_msg("error AudioDeviceSetProperty\n");
return 0;
}
debug_msg("Sample rate, %f\n", theAnswer);
#if defined(MAC_OS_X_VERSION_10_5) && (MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5)
err = AudioDeviceCreateIOProcID(devices[ad].inputDeviceID_, audioIOProc, (void*)NULL, &devices[ad].inputDeviceProcID_);
if (err != noErr) {
debug_msg("error AudioDeviceCreateIOProcID, %s\n", GetMacOSStatusCommentString(err));
return 0;
}
err = OpenADefaultComponent(kAudioUnitType_Output, kAudioUnitSubType_DefaultOutput, &(devices[ad].outputUnit_));
// The HAL AU maybe a better way to in the future...
//err = OpenADefaultComponent(kAudioUnitType_Output, kAudioUnitSubType_HALOutput, &(devices[ad].outputUnit_));
if (err != noErr) {
debug_msg("error OpenADefaultComponent\n");
return 0;
}
#else
// Register the AudioDeviceIOProc.
err = AudioDeviceAddIOProc(devices[ad].inputDeviceID_, audioIOProc, NULL);
if (err != noErr) {
debug_msg("error AudioDeviceAddIOProc\n");
return 0;
}
err = OpenDefaultAudioOutput(&(devices[ad].outputUnit_));
if (err != noErr) {
debug_msg("error OpenDefaultAudioOutput\n");
return 0;
}
#endif
// Register a callback function to provide output data to the unit.
devices[ad].input.inputProc = outputRenderer;
devices[ad].input.inputProcRefCon = 0;
/* These would be needed if HAL used
* UInt32 enableIO =1;
err = AudioUnitSetProperty(devices[ad].outputUnit_, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Output, 0, (const void*)&enableIO, sizeof(UInt32));
enableIO=0;
err = AudioUnitSetProperty(devices[ad].outputUnit_, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input, 1, (const void*)&enableIO, sizeof(UInt32));
if (err != noErr) {
debug_msg("error AudioUnitSetProperty EnableIO with error %ld: %s\n", err, GetMacOSStatusErrorString(err));
return 0;
}*/
#if defined(MAC_OS_X_VERSION_10_5) && (MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5)
err = AudioUnitSetProperty(devices[ad].outputUnit_, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Global, 0, &(devices[ad].input), sizeof(AURenderCallbackStruct));
#else
err = AudioUnitSetProperty(devices[ad].outputUnit_, kAudioOutputUnitProperty_SetInputCallback, kAudioUnitScope_Global, 0, &(devices[ad].input), sizeof(AURenderCallbackStruct));
#endif
if (err != noErr) {
debug_msg("error AudioUnitSetProperty1 with error %ld: %s\n", err, GetMacOSStatusErrorString(err));
return 0;
}
// Define the Mash stream description. Mash puts 20ms of data into each read
// and write call. 20ms at 8000Hz equals 160 samples. Each sample is a u_char,
// so that's 160 bytes. Mash uses 8-bit mu-law internally, so we need to convert
// to 16-bit linear before using the audio data.
devices[ad].mashStreamBasicDescription_.mSampleRate = 8000.0;
//devices[ad].mashStreamBasicDescription_.mSampleRate = ifmt->sample_rate;
devices[ad].mashStreamBasicDescription_.mFormatID = kAudioFormatLinearPCM;
#ifdef WORDS_BIGENDIAN
devices[ad].mashStreamBasicDescription_.mFormatFlags =kLinearPCMFormatFlagIsSignedInteger | kLinearPCMFormatFlagIsBigEndian |kLinearPCMFormatFlagIsPacked;
#else
devices[ad].mashStreamBasicDescription_.mFormatFlags =kLinearPCMFormatFlagIsSignedInteger | kLinearPCMFormatFlagIsPacked;
#endif
devices[ad].mashStreamBasicDescription_.mBytesPerPacket = 2;
devices[ad].mashStreamBasicDescription_.mFramesPerPacket = 1;
devices[ad].mashStreamBasicDescription_.mBytesPerFrame = 2;
devices[ad].mashStreamBasicDescription_.mChannelsPerFrame = 1;
devices[ad].mashStreamBasicDescription_.mBitsPerChannel = 16;
// Inform the default output unit of our source format.
err = AudioUnitSetProperty(devices[ad].outputUnit_, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &(devices[ad].mashStreamBasicDescription_), sizeof(AudioStreamBasicDescription));
if (err != noErr) {
debug_msg("error AudioUnitSetProperty2");
printf("error setting output unit source format\n");
return 0;
}
// check the stream format
err = AudioUnitGetPropertyInfo(devices[ad].outputUnit_, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &propertySize, &writable);
if (err != noErr) debug_msg("err getting propert info for kAudioUnitProperty_StreamFormat\n");
err = AudioUnitGetProperty(devices[ad].outputUnit_, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &streamdesc_, &propertySize);
if (err != noErr) debug_msg("err getting values for kAudioUnitProperty_StreamFormat\n");
char name[128];
audio_format_name(ifmt, name, 128);
debug_msg("Requested ifmt %s\n",name);
debug_msg("ifmt bytes pre block: %d\n",ifmt->bytes_per_block);
// handle the requested format
if (ifmt->encoding != DEV_S16) {
audio_format_change_encoding(ifmt, DEV_S16);
debug_msg("Requested ifmt changed to %s\n",name);
debug_msg("ifmt bytes pre block: %d\n",ifmt->bytes_per_block);
}
audio_format_name(ofmt, name, 128);
debug_msg("Requested ofmt %s\n",name);
debug_msg("ofmt bytes pre block: %d\n",ofmt->bytes_per_block);
// Allocate the read buffer and Z delay line.
//readBufferSize_ = 8192;
readBufferSize_ = ifmt->bytes_per_block * ringBufferFactor_;
//readBufferSize_ = 320;
//printf("readBufferSize_ %d\n", readBufferSize_);
readBuffer_ = malloc(sizeof(u_char)*readBufferSize_);
bzero(readBuffer_, readBufferSize_ * sizeof(u_char));
//memset(readBuffer_, PCMU_AUDIO_ZERO, readBufferSize_);
//inputReadIndex_ = -1;
inputReadIndex_ = 0; inputWriteIndex_ = 0;
zLine_ = malloc(sizeof(double)*DECIM441_LENGTH / 80);
availableInput_ = 0;
// Allocate the write buffer.
//writeBufferSize_ = 8000;
writeBufferSize_ = ofmt->bytes_per_block * ringBufferFactor_;
writeBuffer_ = malloc(sizeof(SInt16)*writeBufferSize_);
bzero(writeBuffer_, writeBufferSize_ * sizeof(SInt16));
outputReadIndex_ = 0; outputWriteIndex_ = 0;
//outputWriteIndex_ = -1;
// Start audio processing.
err = AudioUnitInitialize(devices[ad].outputUnit_);
if (err != noErr) {
debug_msg("error AudioUnitInitialize\n");
return 0;
}
err = AudioDeviceStart(devices[ad].inputDeviceID_, audioIOProc);
if (err != noErr) {
fprintf(stderr, "Input device error: AudioDeviceStart\n");
return 0;
}
err = AudioOutputUnitStart(devices[ad].outputUnit_);
if (err != noErr) {
fprintf(stderr, "Output device error: AudioOutputUnitStart\n");
return 0;
}
// Inform the default output unit of our source format.
/*
err = AudioUnitSetProperty(devices[ad].outputUnit_, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &(devices[ad].mashStreamBasicDescription_), sizeof(AudioStreamBasicDescription));
if (err != noErr) {
debug_msg("error AudioUnitSetProperty3");
return 0;
}
*/
return 1;
};
bool CAAudioHardwareSystem::HasProperty(AudioHardwarePropertyID inPropertyID)
{
OSStatus theError = AudioHardwareGetPropertyInfo(inPropertyID, NULL, NULL);
return theError == 0;
}
bool JARInsert::OpenAudioClient()
{
OSStatus err;
UInt32 size;
Boolean isWritable;
err = AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &size, &isWritable);
if (err != noErr) {
c_error = kErrCoreAudio;
return false;
}
int nDevices = size / sizeof(AudioDeviceID);
JARILog("There are %d audio devices\n", nDevices);
AudioDeviceID *device = (AudioDeviceID*)calloc(nDevices, sizeof(AudioDeviceID));
err = AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &size, device);
if (err != noErr) {
c_error = kErrCoreAudio;
return false;
}
for (int i = 0; i < nDevices; i++) {
JARILog("ID: %ld\n", device[i]);
char name[256];
size = 256;
err = AudioDeviceGetProperty(device[i], 0, true, kAudioDevicePropertyDeviceName, &size, &name);
if (err == noErr) {
JARILog("Name: %s\n", name);
if (strcmp(&name[0], "JackRouter") == 0) {
c_jackDevID = device[i];
if (device != NULL)
free(device);
JARILog("Get Jack client\n");
size = sizeof(UInt32);
err = AudioDeviceGetProperty(c_jackDevID, 0, true, kAudioDevicePropertyGetJackClient, &size, &c_client);
if (err != noErr) {
JARILog("Get Jack client error = %d\n", err);
c_error = kErrNoClient;
return false;
}
JARILog("Get Jack client OK\n");
#if 0
size = sizeof(UInt32);
err = AudioDeviceGetProperty(c_jackDevID, 0, true, kAudioDevicePropertyDeviceIsRunning, &size, &c_isRunning);
if (err != noErr) {
c_error = kErrNoClient;
return false;
}
#endif
if (c_client != NULL) {
c_error = kNoErr;
return true;
} else
return false;
}
}
}
c_error = kErrNoClient;
return false;
}
int gviHardwareListDevices(GVDeviceInfo devices[], int maxDevices, GVDeviceType types)
{
OSStatus result;
UInt32 size;
int numDevices;
int deviceCount;
AudioDeviceID * deviceIDs;
AudioDeviceID defaultCaptureDeviceID;
AudioDeviceID defaultPlaybackDeviceID;
GVDeviceType defaultTypes;
int i;
// get the default device ids
size = sizeof(AudioDeviceID);
result = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, &size, &defaultCaptureDeviceID);
if(result != noErr)
defaultCaptureDeviceID = kAudioDeviceUnknown;
result = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice, &size, &defaultPlaybackDeviceID);
if(result != noErr)
defaultPlaybackDeviceID = kAudioDeviceUnknown;
// get the size of the device ids array
result = AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &size, NULL);
if(result != noErr)
return 0;
// calc the number of devices
numDevices = (size / sizeof(AudioDeviceID));
// allocate the array of device ids
deviceIDs = (AudioDeviceID *)gsimalloc(size);
if(deviceIDs == NULL)
return 0;
// get the device ids
result = AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &size, deviceIDs);
if(result != noErr)
{
gsifree(deviceIDs);
return 0;
}
// fill the array of devices with info
deviceCount = 0;
for(i = 0 ; (i < maxDevices) && (deviceCount < numDevices) ; i++)
{
// try to add the device to the list
GVBool addedDevice = gviFillDeviceInfo(deviceIDs[i], &devices[deviceCount], types);
// check if it was added successfully
if(addedDevice)
{
// check it against the defaults
defaultTypes = (GVDeviceType)0;
if(deviceIDs[i] == defaultCaptureDeviceID)
defaultTypes |= GV_CAPTURE;
if(deviceIDs[i] == defaultPlaybackDeviceID)
defaultTypes |= GV_PLAYBACK;
devices[deviceCount].m_defaultDevice = defaultTypes;
// increment the count
deviceCount++;
}
}
// free the array
gsifree(deviceIDs);
return deviceCount;
}
JNIEXPORT jint JNICALL Java_com_apple_audio_hardware_AudioHardware_AudioHardwareGetPropertyInfo
(JNIEnv *, jclass, jint inPropertyID, jint outSize, jint outWritable)
{
return (jint)AudioHardwareGetPropertyInfo((AudioHardwarePropertyID)inPropertyID, (UInt32 *)outSize, (Boolean *)outWritable);
}
