static int play(void* output_samples,int num_bytes,int flags)
{
int wrote, b_digital;
SInt32 exit_reason;
// Check whether we need to reset the digital output stream.
if (ao->b_digital && ao->b_stream_format_changed)
{
ao->b_stream_format_changed = 0;
b_digital = AudioStreamSupportsDigital(ao->i_stream_id);
if (b_digital)
{
/* Current stream supports digital format output, let's set it. */
ao_msg(MSGT_AO, MSGL_V,
"Detected current stream supports digital, try to restore digital output...\n");
if (!AudioStreamChangeFormat(ao->i_stream_id, ao->stream_format))
{
ao_msg(MSGT_AO, MSGL_WARN, "Restoring digital output failed.\n");
}
else
{
ao_msg(MSGT_AO, MSGL_WARN, "Restoring digital output succeeded.\n");
reset();
}
}
else
ao_msg(MSGT_AO, MSGL_V, "Detected current stream does not support digital.\n");
}
wrote=write_buffer(output_samples, num_bytes);
audio_resume();
do {
exit_reason = CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.01, true);
} while (exit_reason == kCFRunLoopRunHandledSource);
return wrote;
}
/*****************************************************************************
* Setup a encoded digital stream (SPDIF)
*****************************************************************************/
static int OpenSPDIF(void)
{
OSStatus err = noErr;
UInt32 i_param_size, b_mix = 0;
Boolean b_writeable = 0;
AudioStreamID *p_streams = NULL;
int i, i_streams = 0;
AudioObjectPropertyAddress property_address;
/* Start doing the SPDIF setup process. */
ao->b_digital = 1;
/* Hog the device. */
ao->i_hog_pid = getpid() ;
err = SetAudioProperty(ao->i_selected_dev,
kAudioDevicePropertyHogMode,
sizeof(ao->i_hog_pid), &ao->i_hog_pid);
if (err != noErr)
{
ao_msg(MSGT_AO, MSGL_WARN, "failed to set hogmode: [%4.4s]\n", (char *)&err);
ao->i_hog_pid = -1;
goto err_out;
}
/* Set mixable to false if we are allowed to. */
err = IsAudioPropertySettable(ao->i_selected_dev,
kAudioDevicePropertySupportsMixing,
&b_writeable);
err = GetAudioProperty(ao->i_selected_dev,
kAudioDevicePropertySupportsMixing,
sizeof(UInt32), &b_mix);
if (err != noErr && b_writeable)
{
b_mix = 0;
err = SetAudioProperty(ao->i_selected_dev,
kAudioDevicePropertySupportsMixing,
sizeof(UInt32), &b_mix);
ao->b_changed_mixing = 1;
}
if (err != noErr)
{
ao_msg(MSGT_AO, MSGL_WARN, "failed to set mixmode: [%4.4s]\n", (char *)&err);
goto err_out;
}
/* Get a list of all the streams on this device. */
i_param_size = GetAudioPropertyArray(ao->i_selected_dev,
kAudioDevicePropertyStreams,
kAudioDevicePropertyScopeOutput,
(void **)&p_streams);
if (!i_param_size) {
ao_msg(MSGT_AO, MSGL_WARN, "could not get number of streams.\n");
goto err_out;
}
i_streams = i_param_size / sizeof(AudioStreamID);
ao_msg(MSGT_AO, MSGL_V, "current device stream number: %d\n", i_streams);
for (i = 0; i < i_streams && ao->i_stream_index < 0; ++i)
{
/* Find a stream with a cac3 stream. */
AudioStreamBasicDescription *p_format_list = NULL;
int i_formats = 0, j = 0, b_digital = 0;
i_param_size = GetGlobalAudioPropertyArray(p_streams[i],
kAudioStreamPropertyPhysicalFormats,
(void **)&p_format_list);
if (!i_param_size) {
ao_msg(MSGT_AO, MSGL_WARN,
"Could not get number of stream formats.\n");
continue;
}
i_formats = i_param_size / sizeof(AudioStreamBasicDescription);
/* Check if one of the supported formats is a digital format. */
for (j = 0; j < i_formats; ++j)
{
if (p_format_list[j].mFormatID == 'IAC3' ||
p_format_list[j].mFormatID == kAudioFormat60958AC3)
{
b_digital = 1;
break;
}
}
if (b_digital)
{
/* If this stream supports a digital (cac3) format, then set it. */
int i_requested_rate_format = -1;
int i_current_rate_format = -1;
int i_backup_rate_format = -1;
ao->i_stream_id = p_streams[i];
ao->i_stream_index = i;
if (ao->b_revert == 0)
{
/* Retrieve the original format of this stream first if not done so already. */
err = GetAudioProperty(ao->i_stream_id,
kAudioStreamPropertyPhysicalFormat,
sizeof(ao->sfmt_revert), &ao->sfmt_revert);
if (err != noErr)
{
ao_msg(MSGT_AO, MSGL_WARN,
"Could not retrieve the original stream format: [%4.4s]\n",
(char *)&err);
if (p_format_list) free(p_format_list);
continue;
}
ao->b_revert = 1;
}
for (j = 0; j < i_formats; ++j)
if (p_format_list[j].mFormatID == 'IAC3' ||
p_format_list[j].mFormatID == kAudioFormat60958AC3)
{
if (p_format_list[j].mSampleRate == ao->stream_format.mSampleRate)
{
i_requested_rate_format = j;
break;
}
if (p_format_list[j].mSampleRate == ao->sfmt_revert.mSampleRate)
i_current_rate_format = j;
else if (i_backup_rate_format < 0 || p_format_list[j].mSampleRate > p_format_list[i_backup_rate_format].mSampleRate)
i_backup_rate_format = j;
}
if (i_requested_rate_format >= 0) /* We prefer to output at the samplerate of the original audio. */
ao->stream_format = p_format_list[i_requested_rate_format];
else if (i_current_rate_format >= 0) /* If not possible, we will try to use the current samplerate of the device. */
ao->stream_format = p_format_list[i_current_rate_format];
else ao->stream_format = p_format_list[i_backup_rate_format]; /* And if we have to, any digital format will be just fine (highest rate possible). */
}
if (p_format_list) free(p_format_list);
}
if (p_streams) free(p_streams);
if (ao->i_stream_index < 0)
{
ao_msg(MSGT_AO, MSGL_WARN,
"Cannot find any digital output stream format when OpenSPDIF().\n");
goto err_out;
}
print_format(MSGL_V, "original stream format:", &ao->sfmt_revert);
if (!AudioStreamChangeFormat(ao->i_stream_id, ao->stream_format))
goto err_out;
property_address.mSelector = kAudioDevicePropertyDeviceHasChanged;
property_address.mScope = kAudioObjectPropertyScopeGlobal;
property_address.mElement = kAudioObjectPropertyElementMaster;
err = AudioObjectAddPropertyListener(ao->i_selected_dev,
&property_address,
DeviceListener,
NULL);
if (err != noErr)
ao_msg(MSGT_AO, MSGL_WARN, "AudioDeviceAddPropertyListener for kAudioDevicePropertyDeviceHasChanged failed: [%4.4s]\n", (char *)&err);
/* FIXME: If output stream is not native byte-order, we need change endian somewhere. */
/* Although there's no such case reported. */
#if HAVE_BIGENDIAN
if (!(ao->stream_format.mFormatFlags & kAudioFormatFlagIsBigEndian))
#else
if (ao->stream_format.mFormatFlags & kAudioFormatFlagIsBigEndian)
#endif
ao_msg(MSGT_AO, MSGL_WARN,
"Output stream has non-native byte order, digital output may fail.\n");
/* For ac3/dts, just use packet size 6144 bytes as chunk size. */
ao->chunk_size = ao->stream_format.mBytesPerPacket;
ao_data.samplerate = ao->stream_format.mSampleRate;
ao_data.channels = ao->stream_format.mChannelsPerFrame;
ao_data.bps = ao_data.samplerate * (ao->stream_format.mBytesPerPacket/ao->stream_format.mFramesPerPacket);
ao_data.outburst = ao->chunk_size;
ao_data.buffersize = ao_data.bps;
ao->num_chunks = (ao_data.bps+ao->chunk_size-1)/ao->chunk_size;
ao->buffer_len = ao->num_chunks * ao->chunk_size;
ao->buffer = av_fifo_alloc(ao->buffer_len);
ao_msg(MSGT_AO,MSGL_V, "using %5d chunks of %d bytes (buffer len %d bytes)\n", (int)ao->num_chunks, (int)ao->chunk_size, (int)ao->buffer_len);
/* Create IOProc callback. */
err = AudioDeviceCreateIOProcID(ao->i_selected_dev,
(AudioDeviceIOProc)RenderCallbackSPDIF,
(void *)ao,
&ao->renderCallback);
if (err != noErr || ao->renderCallback == NULL)
{
ao_msg(MSGT_AO, MSGL_WARN, "AudioDeviceAddIOProc failed: [%4.4s]\n", (char *)&err);
goto err_out1;
}
reset();
return CONTROL_TRUE;
err_out1:
if (ao->b_revert)
AudioStreamChangeFormat(ao->i_stream_id, ao->sfmt_revert);
err_out:
if (ao->b_changed_mixing && ao->sfmt_revert.mFormatID != kAudioFormat60958AC3)
{
int b_mix = 1;
err = SetAudioProperty(ao->i_selected_dev,
kAudioDevicePropertySupportsMixing,
sizeof(int), &b_mix);
if (err != noErr)
ao_msg(MSGT_AO, MSGL_WARN, "failed to set mixmode: [%4.4s]\n",
(char *)&err);
}
if (ao->i_hog_pid == getpid())
{
ao->i_hog_pid = -1;
err = SetAudioProperty(ao->i_selected_dev,
kAudioDevicePropertyHogMode,
sizeof(ao->i_hog_pid), &ao->i_hog_pid);
if (err != noErr)
ao_msg(MSGT_AO, MSGL_WARN, "Could not release hogmode: [%4.4s]\n",
(char *)&err);
}
av_fifo_free(ao->buffer);
free(ao);
ao = NULL;
return CONTROL_FALSE;
}
/* unload plugin and deregister from coreaudio */
static void uninit(int immed)
{
OSStatus err = noErr;
if (!immed) {
long long timeleft=(1000000LL*av_fifo_size(ao->buffer))/ao_data.bps;
ao_msg(MSGT_AO,MSGL_DBG2, "%d bytes left @%d bps (%d usec)\n", av_fifo_size(ao->buffer), ao_data.bps, (int)timeleft);
usec_sleep((int)timeleft);
}
if (!ao->b_digital) {
AudioOutputUnitStop(ao->theOutputUnit);
AudioUnitUninitialize(ao->theOutputUnit);
CloseComponent(ao->theOutputUnit);
}
else {
/* Stop device. */
err = AudioDeviceStop(ao->i_selected_dev, ao->renderCallback);
if (err != noErr)
ao_msg(MSGT_AO, MSGL_WARN, "AudioDeviceStop failed: [%4.4s]\n", (char *)&err);
/* Remove IOProc callback. */
err = AudioDeviceDestroyIOProcID(ao->i_selected_dev, ao->renderCallback);
if (err != noErr)
ao_msg(MSGT_AO, MSGL_WARN, "AudioDeviceRemoveIOProc failed: [%4.4s]\n", (char *)&err);
if (ao->b_revert)
AudioStreamChangeFormat(ao->i_stream_id, ao->sfmt_revert);
if (ao->b_changed_mixing && ao->sfmt_revert.mFormatID != kAudioFormat60958AC3)
{
UInt32 b_mix;
Boolean b_writeable;
/* Revert mixable to true if we are allowed to. */
err = IsAudioPropertySettable(ao->i_selected_dev,
kAudioDevicePropertySupportsMixing,
&b_writeable);
err = GetAudioProperty(ao->i_selected_dev,
kAudioDevicePropertySupportsMixing,
sizeof(UInt32), &b_mix);
if (err != noErr && b_writeable)
{
b_mix = 1;
err = SetAudioProperty(ao->i_selected_dev,
kAudioDevicePropertySupportsMixing,
sizeof(UInt32), &b_mix);
}
if (err != noErr)
ao_msg(MSGT_AO, MSGL_WARN, "failed to set mixmode: [%4.4s]\n", (char *)&err);
}
if (ao->i_hog_pid == getpid())
{
ao->i_hog_pid = -1;
err = SetAudioProperty(ao->i_selected_dev,
kAudioDevicePropertyHogMode,
sizeof(ao->i_hog_pid), &ao->i_hog_pid);
if (err != noErr) ao_msg(MSGT_AO, MSGL_WARN, "Could not release hogmode: [%4.4s]\n", (char *)&err);
}
}
av_fifo_free(ao->buffer);
free(ao);
ao = NULL;
}
/*****************************************************************************
* Setup a encoded digital stream (SPDIF)
*****************************************************************************/
int CoreAudioAUHAL::OpenSPDIF(struct CoreAudioDeviceParameters *deviceParameters, const CStdString& strName, int channels, float sampleRate, int bitsPerSample, int packetSize)
{
OSStatus err = noErr;
UInt32 i_param_size = 0, b_mix = 0;
Boolean b_writeable = false;
AudioStreamID *p_streams = NULL;
int i = 0, i_streams = 0;
// We're digital.
s_lastPlayWasSpdif = true;
/* Start doing the SPDIF setup proces */
//deviceParameters->b_digital = true;
deviceParameters->b_changed_mixing = false;
/* Hog the device */
i_param_size = sizeof(deviceParameters->i_hog_pid);
deviceParameters->i_hog_pid = getpid();
err = AudioDeviceSetProperty(deviceParameters->device_id, 0, 0, FALSE,
kAudioDevicePropertyHogMode, i_param_size, &deviceParameters->i_hog_pid);
if( err != noErr )
{
CLog::Log(LOGERROR, "Failed to set hogmode: [%4.4s]", (char *)&err );
return false;
}
/* Set mixable to false if we are allowed to */
err = AudioDeviceGetPropertyInfo(deviceParameters->device_id, 0, FALSE, kAudioDevicePropertySupportsMixing,
&i_param_size, &b_writeable );
err = AudioDeviceGetProperty(deviceParameters->device_id, 0, FALSE, kAudioDevicePropertySupportsMixing,
&i_param_size, &b_mix );
if( !err && b_writeable )
{
b_mix = 0;
err = AudioDeviceSetProperty( deviceParameters->device_id, 0, 0, FALSE,
kAudioDevicePropertySupportsMixing, i_param_size, &b_mix );
deviceParameters->b_changed_mixing = true;
}
if( err != noErr )
{
CLog::Log(LOGERROR, "Failed to set mixmode: [%4.4s]", (char *)&err );
return false;
}
/* Get a list of all the streams on this device */
err = AudioDeviceGetPropertyInfo(deviceParameters->device_id, 0, FALSE,
kAudioDevicePropertyStreams,
&i_param_size, NULL );
if( err != noErr )
{
CLog::Log(LOGERROR, "Could not get number of streams: [%4.4s]", (char *)&err );
return false;
}
i_streams = i_param_size / sizeof( AudioStreamID );
p_streams = (AudioStreamID *)malloc( i_param_size );
if( p_streams == NULL )
return false;
err = AudioDeviceGetProperty(deviceParameters->device_id, 0, FALSE,
kAudioDevicePropertyStreams,
&i_param_size, p_streams );
if( err != noErr )
{
CLog::Log(LOGERROR, "Could not get number of streams: [%4.4s]", (char *)&err );
free( p_streams );
return false;
}
for( i = 0; i < i_streams && deviceParameters->i_stream_index < 0 ; i++ )
{
/* Find a stream with a cac3 stream */
AudioStreamBasicDescription *p_format_list = NULL;
int i_formats = 0, j = 0;
bool b_digital = false;
/* Retrieve all the stream formats supported by each output stream */
err = AudioStreamGetPropertyInfo( p_streams[i], 0,
kAudioStreamPropertyPhysicalFormats,
&i_param_size, NULL );
if( err != noErr )
{
CLog::Log(LOGERROR, "Could not get number of streamformats: [%4.4s]", (char *)&err );
continue;
}
i_formats = i_param_size / sizeof( AudioStreamBasicDescription );
p_format_list = (AudioStreamBasicDescription *)malloc( i_param_size );
if( p_format_list == NULL )
continue;
err = AudioStreamGetProperty( p_streams[i], 0,
kAudioStreamPropertyPhysicalFormats,
&i_param_size, p_format_list );
if( err != noErr )
{
CLog::Log(LOGERROR, "Could not get the list of streamformats: [%4.4s]", (char *)&err );
free( p_format_list );
continue;
}
/* Check if one of the supported formats is a digital format */
for( j = 0; j < i_formats; j++ )
{
if( p_format_list[j].mFormatID == 'IAC3' ||
p_format_list[j].mFormatID == kAudioFormat60958AC3 )
{
b_digital = true;
break;
}
}
if( b_digital )
{
/* if this stream supports a digital (cac3) format, then go set it. */
int i_requested_rate_format = -1;
int i_current_rate_format = -1;
int i_backup_rate_format = -1;
deviceParameters->i_stream_id = p_streams[i];
deviceParameters->i_stream_index = i;
if(deviceParameters->b_revert == false )
{
/* Retrieve the original format of this stream first if not done so already */
i_param_size = sizeof(deviceParameters->sfmt_revert);
err = AudioStreamGetProperty(deviceParameters->i_stream_id, 0,
kAudioStreamPropertyPhysicalFormat,
&i_param_size,
&deviceParameters->sfmt_revert );
if( err != noErr )
{
CLog::Log(LOGERROR, "Could not retrieve the original streamformat: [%4.4s]", (char *)&err );
//continue;
}
else deviceParameters->b_revert = true;
}
for( j = 0; j < i_formats; j++ )
{
if( p_format_list[j].mFormatID == 'IAC3' ||
p_format_list[j].mFormatID == kAudioFormat60958AC3 )
{
if( p_format_list[j].mSampleRate == sampleRate)
{
i_requested_rate_format = j;
break;
}
else if( p_format_list[j].mSampleRate == deviceParameters->sfmt_revert.mSampleRate )
{
i_current_rate_format = j;
}
else
{
if( i_backup_rate_format < 0 || p_format_list[j].mSampleRate > p_format_list[i_backup_rate_format].mSampleRate )
i_backup_rate_format = j;
}
}
}
if( i_requested_rate_format >= 0 ) /* We prefer to output at the samplerate of the original audio */
deviceParameters->stream_format = p_format_list[i_requested_rate_format];
else if( i_current_rate_format >= 0 ) /* If not possible, we will try to use the current samplerate of the device */
deviceParameters->stream_format = p_format_list[i_current_rate_format];
else deviceParameters->stream_format = p_format_list[i_backup_rate_format]; /* And if we have to, any digital format will be just fine (highest rate possible) */
}
free( p_format_list );
}
free( p_streams );
CLog::Log(LOGINFO, STREAM_FORMAT_MSG("original stream format: ", deviceParameters->sfmt_revert ) );
if( !AudioStreamChangeFormat(deviceParameters, deviceParameters->i_stream_id, deviceParameters->stream_format))
return false;
// Get device hardware buffer size
uint32_t audioDeviceLatency, audioStreamLatency, audioDeviceBufferFrameSize, audioDeviceSafetyOffset;
deviceParameters->hardwareFrameLatency = 0;
i_param_size = sizeof(uint32_t);
err = AudioDeviceGetProperty(deviceParameters->device_id,
0, false,
kAudioDevicePropertyLatency,
&i_param_size,
&audioDeviceLatency);
if (err == noErr) deviceParameters->hardwareFrameLatency += audioDeviceLatency;
err = AudioDeviceGetProperty(deviceParameters->device_id,
0, false,
kAudioDevicePropertyBufferFrameSize,
&i_param_size,
&audioDeviceBufferFrameSize);
if (err == noErr) deviceParameters->hardwareFrameLatency += audioDeviceBufferFrameSize;
err = AudioDeviceGetProperty(deviceParameters->device_id,
0, false,
kAudioDevicePropertySafetyOffset,
&i_param_size,
&audioDeviceSafetyOffset);
if (err == noErr) deviceParameters->hardwareFrameLatency += audioDeviceSafetyOffset;
err = AudioStreamGetProperty(deviceParameters->i_stream_id,
0,
kAudioStreamPropertyLatency,
&i_param_size,
&audioStreamLatency);
if (err == noErr) deviceParameters->hardwareFrameLatency += audioStreamLatency;
CLog::Log(LOGINFO, "Hardware latency: %i frames (%.2f msec @ %.0fHz)", deviceParameters->hardwareFrameLatency,
(float)deviceParameters->hardwareFrameLatency / deviceParameters->stream_format.mSampleRate * 1000,
deviceParameters->stream_format.mSampleRate);
// initialise the CoreAudio sink buffer
uint32_t framecount = 1;
while(framecount <= deviceParameters->stream_format.mSampleRate) // ensure power of 2
{
framecount <<= 1;
}
#warning free
deviceParameters->outputBuffer = (PaUtilRingBuffer *)malloc(sizeof(PaUtilRingBuffer));
deviceParameters->outputBufferData = calloc(1, framecount * channels * bitsPerSample/8); // use uncompressed size if encoding ac3
PaUtil_InitializeRingBuffer(deviceParameters->outputBuffer, channels * bitsPerSample/8, framecount, deviceParameters->outputBufferData);
/* Add IOProc callback */
err = AudioDeviceCreateIOProcID(deviceParameters->device_id,
(AudioDeviceIOProc)RenderCallbackSPDIF,
deviceParameters,
&deviceParameters->sInputIOProcID);
if( err != noErr )
{
CLog::Log(LOGERROR, "AudioDeviceAddIOProcID failed: [%4.4s]", (char *)&err );
return false;
}
/* Start device */
err = AudioDeviceStart(deviceParameters->device_id, (AudioDeviceIOProc)RenderCallbackSPDIF );
if( err != noErr )
{
CLog::Log(LOGERROR, "AudioDeviceStart failed: [%4.4s]", (char *)&err );
err = AudioDeviceDestroyIOProcID(deviceParameters->device_id,
(AudioDeviceIOProc)RenderCallbackSPDIF);
if( err != noErr )
{
CLog::Log(LOGERROR, "AudioDeviceRemoveIOProc failed: [%4.4s]", (char *)&err );
}
return false;
}
return true;
}
HRESULT CoreAudioAUHAL::Deinitialize()
{
// Don't allow double deinitialization.
if (m_bIsInitialized == false)
return S_OK;
CLog::Log(LOGDEBUG,"CoreAudioAUHAL::Deinitialize");
OSStatus err = noErr;
UInt32 i_param_size = 0;
if(deviceParameters->au_unit)
{
verify_noerr( AudioOutputUnitStop( deviceParameters->au_unit ) );
verify_noerr( AudioUnitUninitialize( deviceParameters->au_unit ) );
verify_noerr( CloseComponent( deviceParameters->au_unit ) );
deviceParameters->au_unit = NULL;
}
if (deviceParameters->m_bEncodeAC3)
{
ac3encoderFinalise(&deviceParameters->m_ac3encoder);
}
if( deviceParameters->b_digital )
{
/* Stop device */
err = AudioDeviceStop( deviceParameters->device_id,
(AudioDeviceIOProc)RenderCallbackSPDIF );
if( err != noErr )
{
CLog::Log(LOGERROR, "AudioDeviceStop failed: [%4.4s]", (char *)&err );
}
/* Remove IOProc callback */
err = AudioDeviceDestroyIOProcID(deviceParameters->device_id, deviceParameters->sInputIOProcID);
if( err != noErr )
{
CLog::Log(LOGERROR, "AudioDeviceRemoveIOProc failed: [%4.4s]", (char *)&err );
}
if( deviceParameters->b_changed_mixing && deviceParameters->sfmt_revert.mFormatID != kAudioFormat60958AC3 )
{
int b_mix;
Boolean b_writeable = false;
/* Revert mixable to true if we are allowed to */
err = AudioDeviceGetPropertyInfo(deviceParameters->device_id, 0, FALSE, kAudioDevicePropertySupportsMixing,
&i_param_size, &b_writeable );
err = AudioDeviceGetProperty( deviceParameters->device_id, 0, FALSE, kAudioDevicePropertySupportsMixing,
&i_param_size, &b_mix );
if( !err && b_writeable )
{
CLog::Log(LOGDEBUG, "mixable is: %d", b_mix );
b_mix = 1;
err = AudioDeviceSetProperty( deviceParameters->device_id, 0, 0, FALSE,
kAudioDevicePropertySupportsMixing, i_param_size, &b_mix );
}
if( err != noErr )
{
CLog::Log(LOGERROR, "failed to set mixmode: [%4.4s]", (char *)&err );
}
}
}
#warning fix listener
//err = AudioHardwareRemovePropertyListener( kAudioHardwarePropertyDevices,
// HardwareListener );
if( err != noErr )
{
CLog::Log(LOGERROR, "AudioHardwareRemovePropertyListener failed: [%4.4s]", (char *)&err );
}
if( deviceParameters->i_hog_pid == getpid() )
{
deviceParameters->i_hog_pid = -1;
i_param_size = sizeof( deviceParameters->i_hog_pid );
err = AudioDeviceSetProperty( deviceParameters->device_id, 0, 0, FALSE,
kAudioDevicePropertyHogMode, i_param_size, &deviceParameters->i_hog_pid );
if( err != noErr ) CLog::Log(LOGERROR, "Could not release hogmode: [%4.4s]", (char *)&err );
}
// Revert the stream format *after* we've set all the parameters, as doing it before seems to
// result in a hang under some circumstances, an apparent deadlock in CoreAudio between handing
// the stream format change and setting parameters.
//
if (deviceParameters->b_digital && deviceParameters->b_revert)
AudioStreamChangeFormat(deviceParameters, deviceParameters->i_stream_id, deviceParameters->sfmt_revert);
m_bIsInitialized = false;
return S_OK;
}
