/*****************************************************************************
* Preamble
*****************************************************************************/
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
#include <unistd.h>
-#include <vlc/vlc.h>
+#include <vlc_common.h>
+#include <vlc_plugin.h>
#include <vlc_interface.h>
#include <vlc_aout.h>
AudioDeviceID i_default_dev; /* Keeps DeviceID of defaultOutputDevice */
AudioDeviceID i_selected_dev; /* Keeps DeviceID of the selected device */
UInt32 i_devices; /* Number of CoreAudio Devices */
- vlc_bool_t b_supports_digital;/* Does the currently selected device support digital mode? */
- vlc_bool_t b_digital; /* Are we running in digital mode? */
+ bool b_supports_digital;/* Does the currently selected device support digital mode? */
+ bool b_digital; /* Are we running in digital mode? */
mtime_t clock_diff; /* Difference between VLC clock and Device clock */
/* AUHAL specific */
int i_stream_index; /* The index of i_stream_id in an AudioBufferList */
AudioStreamBasicDescription stream_format; /* The format we changed the stream to */
AudioStreamBasicDescription sfmt_revert; /* The original format of the stream */
- vlc_bool_t b_revert; /* Wether we need to revert the stream format */
- vlc_bool_t b_changed_mixing;/* Wether we need to set the mixing mode back */
+ bool b_revert; /* Wether we need to revert the stream format */
+ bool b_changed_mixing;/* Wether we need to set the mixing mode back */
};
/*****************************************************************************
vlc_module_begin();
set_shortname( "auhal" );
- set_description( _("HAL AudioUnit output") );
+ set_description( N_("HAL AudioUnit output") );
set_capability( "audio output", 101 );
set_category( CAT_AUDIO );
set_subcategory( SUBCAT_AUDIO_AOUT );
set_callbacks( Open, Close );
- add_integer( "macosx-audio-device", 0, NULL, ADEV_TEXT, ADEV_LONGTEXT, VLC_FALSE );
+ add_integer( "macosx-audio-device", 0, NULL, ADEV_TEXT, ADEV_LONGTEXT, false );
vlc_module_end();
/*****************************************************************************
OSStatus err = noErr;
UInt32 i_param_size = 0;
struct aout_sys_t *p_sys = NULL;
- vlc_bool_t b_alive = VLC_FALSE;
vlc_value_t val;
aout_instance_t *p_aout = (aout_instance_t *)p_this;
+ /* Use int here, to match kAudioDevicePropertyDeviceIsAlive
+ * property size */
+ int b_alive = false;
+
/* Allocate structure */
p_aout->output.p_sys = malloc( sizeof( aout_sys_t ) );
if( p_aout->output.p_sys == NULL )
- {
- msg_Err( p_aout, "out of memory" );
- return( VLC_ENOMEM );
- }
+ return VLC_ENOMEM;
p_sys = p_aout->output.p_sys;
p_sys->i_default_dev = 0;
p_sys->i_selected_dev = 0;
p_sys->i_devices = 0;
- p_sys->b_supports_digital = VLC_FALSE;
- p_sys->b_digital = VLC_FALSE;
+ p_sys->b_supports_digital = false;
+ p_sys->b_digital = false;
p_sys->au_component = NULL;
p_sys->au_unit = NULL;
p_sys->clock_diff = (mtime_t) 0;
p_sys->i_hog_pid = -1;
p_sys->i_stream_id = 0;
p_sys->i_stream_index = -1;
- p_sys->b_revert = VLC_FALSE;
- p_sys->b_changed_mixing = VLC_FALSE;
+ p_sys->b_revert = false;
+ p_sys->b_changed_mixing = false;
memset( p_sys->p_remainder_buffer, 0, sizeof(uint8_t) * BUFSIZE );
p_aout->output.pf_play = Play;
}
p_sys->i_selected_dev = val.i_int & ~AOUT_VAR_SPDIF_FLAG; /* remove SPDIF flag to get the true DeviceID */
- p_sys->b_supports_digital = ( val.i_int & AOUT_VAR_SPDIF_FLAG ) ? VLC_TRUE : VLC_FALSE;
+ p_sys->b_supports_digital = ( val.i_int & AOUT_VAR_SPDIF_FLAG ) ? true : false;
/* Check if the desired device is alive and usable */
/* TODO: add a callback to the device to alert us if the device dies */
if( err != noErr )
{
- msg_Err( p_aout, "could not check whether device is alive: %4.4s", (char *)&err );
- goto error;
+ /* Be tolerant, only give a warning here */
+ msg_Warn( p_aout, "could not check whether device [0x%x] is alive: %4.4s", (unsigned int)p_sys->i_selected_dev, (char *)&err );
+ b_alive = false;
}
- if( b_alive == VLC_FALSE )
+ if( b_alive == false )
{
msg_Warn( p_aout, "selected audio device is not alive, switching to default device" );
p_sys->i_selected_dev = p_sys->i_default_dev;
if( p_sys->i_hog_pid != -1 && p_sys->i_hog_pid != getpid() )
{
msg_Err( p_aout, "Selected audio device is exclusively in use by another program." );
- intf_UserFatal( p_aout, VLC_FALSE, _("Audio output failed"),
+ intf_UserFatal( p_aout, false, _("Audio output failed"),
_("The selected audio output device is exclusively in "
"use by another program.") );
goto error;
error:
/* If we reach this, this aout has failed */
var_Destroy( p_aout, "audio-device" );
- if( p_sys ) free( p_sys );
+ free( p_sys );
return VLC_EGENERIC;
}
if( p_sys->au_component == NULL )
{
msg_Warn( p_aout, "we cannot find our HAL component" );
- return VLC_FALSE;
+ return false;
}
err = OpenAComponent( p_sys->au_component, &p_sys->au_unit );
if( err != noErr )
{
msg_Warn( p_aout, "we cannot open our HAL component" );
- return VLC_FALSE;
+ return false;
}
/* Set the device we will use for this output unit */
if( err != noErr )
{
msg_Warn( p_aout, "we cannot select the audio device" );
- return VLC_FALSE;
+ return false;
}
/* Get the current format */
&DeviceFormat,
&i_param_size );
- if( err != noErr ) return VLC_FALSE;
+ if( err != noErr ) return false;
else msg_Dbg( p_aout, STREAM_FORMAT_MSG( "current format is: ", DeviceFormat ) );
/* Get the channel layout of the device side of the unit (vlc -> unit -> device) */
{
p_aout->output.output.i_physical_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
msg_Err( p_aout, "You should configure your speaker layout with Audio Midi Setup Utility in /Applications/Utilities. Now using Stereo mode." );
- intf_UserFatal( p_aout, VLC_FALSE, _("Audio device is not configured"),
+ intf_UserFatal( p_aout, false, _("Audio device is not configured"),
_("You should configure your speaker layout with "
- "the \"Audio Midi Setup Utility\" in /Applications/"
+ "the \"Audio Midi Setup\" utility in /Applications/"
"Utilities. Stereo mode is being used now.") );
}
}
- if( layout ) free( layout );
+ free( layout );
}
else
{
/* Start the AU */
verify_noerr( AudioOutputUnitStart(p_sys->au_unit) );
- return VLC_TRUE;
+ return true;
}
/*****************************************************************************
struct aout_sys_t *p_sys = p_aout->output.p_sys;
OSStatus err = noErr;
UInt32 i_param_size = 0, b_mix = 0;
- Boolean b_writeable = VLC_FALSE;
+ Boolean b_writeable = false;
AudioStreamID *p_streams = NULL;
int i = 0, i_streams = 0;
/* Start doing the SPDIF setup proces */
- p_sys->b_digital = VLC_TRUE;
+ p_sys->b_digital = true;
/* Hog the device */
i_param_size = sizeof( p_sys->i_hog_pid );
if( err != noErr )
{
msg_Err( p_aout, "failed to set hogmode: [%4.4s]", (char *)&err );
- return VLC_FALSE;
+ return false;
}
/* Set mixable to false if we are allowed to */
b_mix = 0;
err = AudioDeviceSetProperty( p_sys->i_selected_dev, 0, 0, FALSE,
kAudioDevicePropertySupportsMixing, i_param_size, &b_mix );
- p_sys->b_changed_mixing = VLC_TRUE;
+ p_sys->b_changed_mixing = true;
}
if( err != noErr )
{
msg_Err( p_aout, "failed to set mixmode: [%4.4s]", (char *)&err );
- return VLC_FALSE;
+ return false;
}
/* Get a list of all the streams on this device */
if( err != noErr )
{
msg_Err( p_aout, "could not get number of streams: [%4.4s]", (char *)&err );
- return VLC_FALSE;
+ return false;
}
i_streams = i_param_size / sizeof( AudioStreamID );
p_streams = (AudioStreamID *)malloc( i_param_size );
if( p_streams == NULL )
- {
- msg_Err( p_aout, "out of memory" );
- return VLC_FALSE;
- }
+ return false;
err = AudioDeviceGetProperty( p_sys->i_selected_dev, 0, FALSE,
kAudioDevicePropertyStreams,
if( err != noErr )
{
msg_Err( p_aout, "could not get number of streams: [%4.4s]", (char *)&err );
- if( p_streams ) free( p_streams );
- return VLC_FALSE;
+ free( p_streams );
+ return false;
}
for( i = 0; i < i_streams && p_sys->i_stream_index < 0 ; i++ )
/* Find a stream with a cac3 stream */
AudioStreamBasicDescription *p_format_list = NULL;
int i_formats = 0, j = 0;
- vlc_bool_t b_digital = VLC_FALSE;
+ bool b_digital = false;
/* Retrieve all the stream formats supported by each output stream */
err = AudioStreamGetPropertyInfo( p_streams[i], 0,
i_formats = i_param_size / sizeof( AudioStreamBasicDescription );
p_format_list = (AudioStreamBasicDescription *)malloc( i_param_size );
if( p_format_list == NULL )
- {
- msg_Err( p_aout, "could not malloc the memory" );
continue;
- }
err = AudioStreamGetProperty( p_streams[i], 0,
kAudioStreamPropertyPhysicalFormats,
if( err != noErr )
{
msg_Err( p_aout, "could not get the list of streamformats: [%4.4s]", (char *)&err );
- if( p_format_list) free( p_format_list);
+ free( p_format_list );
continue;
}
if( p_format_list[j].mFormatID == 'IAC3' ||
p_format_list[j].mFormatID == kAudioFormat60958AC3 )
{
- b_digital = VLC_TRUE;
+ b_digital = true;
break;
}
}
p_sys->i_stream_id = p_streams[i];
p_sys->i_stream_index = i;
- if( p_sys->b_revert == VLC_FALSE )
+ if( p_sys->b_revert == false )
{
/* Retrieve the original format of this stream first if not done so already */
i_param_size = sizeof( p_sys->sfmt_revert );
msg_Err( p_aout, "could not retrieve the original streamformat: [%4.4s]", (char *)&err );
continue;
}
- p_sys->b_revert = VLC_TRUE;
+ p_sys->b_revert = true;
}
for( j = 0; j < i_formats; j++ )
p_sys->stream_format = p_format_list[i_current_rate_format];
else p_sys->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 );
+ free( p_format_list );
}
- if( p_streams ) free( p_streams );
+ free( p_streams );
msg_Dbg( p_aout, STREAM_FORMAT_MSG( "original stream format: ", p_sys->sfmt_revert ) );
if( !AudioStreamChangeFormat( p_aout, p_sys->i_stream_id, p_sys->stream_format ) )
- return VLC_FALSE;
+ return false;
/* Set the format flags */
if( p_sys->stream_format.mFormatFlags & kAudioFormatFlagIsBigEndian )
/* Add IOProc callback */
err = AudioDeviceAddIOProc( p_sys->i_selected_dev,
- (AudioDeviceIOProc)RenderCallbackSPDIF,
- (void *)p_aout );
+ (AudioDeviceIOProc)RenderCallbackSPDIF,
+ (void *)p_aout );
+
if( err != noErr )
{
msg_Err( p_aout, "AudioDeviceAddIOProc failed: [%4.4s]", (char *)&err );
- return VLC_FALSE;
+ return false;
}
/* Check for the difference between the Device clock and mdate */
msg_Err( p_aout, "AudioDeviceStart failed: [%4.4s]", (char *)&err );
err = AudioDeviceRemoveIOProc( p_sys->i_selected_dev,
- (AudioDeviceIOProc)RenderCallbackSPDIF );
+ (AudioDeviceIOProc)RenderCallbackSPDIF );
if( err != noErr )
{
msg_Err( p_aout, "AudioDeviceRemoveIOProc failed: [%4.4s]", (char *)&err );
}
- return VLC_FALSE;
+ return false;
}
- return VLC_TRUE;
+ return true;
}
/* Remove IOProc callback */
err = AudioDeviceRemoveIOProc( p_sys->i_selected_dev,
- (AudioDeviceIOProc)RenderCallbackSPDIF );
+ (AudioDeviceIOProc)RenderCallbackSPDIF );
if( err != noErr )
{
msg_Err( p_aout, "AudioDeviceRemoveIOProc failed: [%4.4s]", (char *)&err );
if( err != noErr ) msg_Err( p_aout, "Could not release hogmode: [%4.4s]", (char *)&err );
}
- if( p_sys ) free( p_sys );
+ free( p_sys );
}
/*****************************************************************************
/* Allocate DeviceID array */
p_devices = (AudioDeviceID*)malloc( sizeof(AudioDeviceID) * p_sys->i_devices );
if( p_devices == NULL )
- {
- msg_Err( p_aout, "out of memory" );
goto error;
- }
/* Populate DeviceID array */
err = AudioHardwareGetProperty( kAudioHardwarePropertyDevices,
/* Retrieve the length of the device name */
err = AudioDeviceGetPropertyInfo(
- p_devices[i], 0, VLC_FALSE,
+ p_devices[i], 0, false,
kAudioDevicePropertyDeviceName,
&i_param_size, NULL);
if( err ) goto error;
/* Retrieve the name of the device */
psz_name = (char *)malloc( i_param_size );
err = AudioDeviceGetProperty(
- p_devices[i], 0, VLC_FALSE,
+ p_devices[i], 0, false,
kAudioDevicePropertyDeviceName,
&i_param_size, psz_name);
if( err ) goto error;
if( err )
goto error;
- if( p_devices ) free( p_devices );
+ free( p_devices );
return;
error:
var_Destroy( p_aout, "audio-device" );
- if( p_devices ) free( p_devices );
+ free( p_devices );
return;
}
UInt32 i_param_size = 0;
AudioStreamID *p_streams = NULL;
int i = 0, i_streams = 0;
- vlc_bool_t b_return = VLC_FALSE;
+ bool b_return = false;
/* Retrieve all the output streams */
err = AudioDeviceGetPropertyInfo( i_dev_id, 0, FALSE,
if( err != noErr )
{
msg_Err( p_aout, "could not get number of streams: [%4.4s]", (char *)&err );
- return VLC_FALSE;
+ return false;
}
i_streams = i_param_size / sizeof( AudioStreamID );
p_streams = (AudioStreamID *)malloc( i_param_size );
if( p_streams == NULL )
- {
- msg_Err( p_aout, "out of memory" );
return VLC_ENOMEM;
- }
err = AudioDeviceGetProperty( i_dev_id, 0, FALSE,
kAudioDevicePropertyStreams,
if( err != noErr )
{
msg_Err( p_aout, "could not get number of streams: [%4.4s]", (char *)&err );
- return VLC_FALSE;
+ return false;
}
for( i = 0; i < i_streams; i++ )
{
if( AudioStreamSupportsDigital( p_aout, p_streams[i] ) )
- b_return = VLC_TRUE;
+ b_return = true;
}
- if( p_streams ) free( p_streams );
+ free( p_streams );
return b_return;
}
UInt32 i_param_size = 0;
AudioStreamBasicDescription *p_format_list = NULL;
int i = 0, i_formats = 0;
- vlc_bool_t b_return = VLC_FALSE;
+ bool b_return = false;
/* Retrieve all the stream formats supported by each output stream */
err = AudioStreamGetPropertyInfo( i_stream_id, 0,
if( err != noErr )
{
msg_Err( p_aout, "could not get number of streamformats: [%4.4s]", (char *)&err );
- return VLC_FALSE;
+ return false;
}
i_formats = i_param_size / sizeof( AudioStreamBasicDescription );
p_format_list = (AudioStreamBasicDescription *)malloc( i_param_size );
if( p_format_list == NULL )
- {
- msg_Err( p_aout, "could not malloc the memory" );
- return VLC_FALSE;
- }
+ return false;
err = AudioStreamGetProperty( i_stream_id, 0,
kAudioStreamPropertyPhysicalFormats,
msg_Err( p_aout, "could not get the list of streamformats: [%4.4s]", (char *)&err );
free( p_format_list);
p_format_list = NULL;
- return VLC_FALSE;
+ return false;
}
for( i = 0; i < i_formats; i++ )
if( p_format_list[i].mFormatID == 'IAC3' ||
p_format_list[i].mFormatID == kAudioFormat60958AC3 )
{
- b_return = VLC_TRUE;
+ b_return = true;
}
}
- if( p_format_list ) free( p_format_list );
+ free( p_format_list );
return b_return;
}
UInt32 i_param_size = 0;
int i;
- struct timeval now;
- struct timespec timeout;
struct { vlc_mutex_t lock; vlc_cond_t cond; } w;
msg_Dbg( p_aout, STREAM_FORMAT_MSG( "setting stream format: ", change_format ) );
/* Condition because SetProperty is asynchronious */
vlc_cond_init( p_aout, &w.cond );
- vlc_mutex_init( p_aout, &w.lock );
+ vlc_mutex_init( &w.lock );
vlc_mutex_lock( &w.lock );
/* Install the callback */
if( err != noErr )
{
msg_Err( p_aout, "AudioStreamAddPropertyListener failed: [%4.4s]", (char *)&err );
- return VLC_FALSE;
+ return false;
}
/* change the format */
if( err != noErr )
{
msg_Err( p_aout, "could not set the stream format: [%4.4s]", (char *)&err );
- return VLC_FALSE;
+ return false;
}
/* The AudioStreamSetProperty is not only asynchronious (requiring the locks)
for( i = 0; i < 5; i++ )
{
AudioStreamBasicDescription actual_format;
+ mtime_t timeout = mdate() + 500000;
- gettimeofday( &now, NULL );
- timeout.tv_sec = now.tv_sec;
- timeout.tv_nsec = (now.tv_usec + 500000) * 1000;
-
- if( pthread_cond_timedwait( &w.cond.cond, &w.lock.mutex, &timeout ) )
+ if( vlc_cond_timedwait( &w.cond, &w.lock, timeout ) )
{
msg_Dbg( p_aout, "reached timeout" );
}
if( err != noErr )
{
msg_Err( p_aout, "AudioStreamRemovePropertyListener failed: [%4.4s]", (char *)&err );
- return VLC_FALSE;
+ return false;
}
/* Destroy the lock and condition */
vlc_mutex_destroy( &w.lock );
vlc_cond_destroy( &w.cond );
- return VLC_TRUE;
+ return true;
}
/*****************************************************************************
if( p_sys->i_total_bytes > 0 )
{
i_mData_bytes = __MIN( p_sys->i_total_bytes - p_sys->i_read_bytes, ioData->mBuffers[0].mDataByteSize );
- p_aout->p_libvlc->pf_memcpy( ioData->mBuffers[0].mData, &p_sys->p_remainder_buffer[p_sys->i_read_bytes], i_mData_bytes );
+ vlc_memcpy( ioData->mBuffers[0].mData,
+ &p_sys->p_remainder_buffer[p_sys->i_read_bytes],
+ i_mData_bytes );
p_sys->i_read_bytes += i_mData_bytes;
current_date += (mtime_t) ( (mtime_t) 1000000 / p_aout->output.output.i_rate ) *
( i_mData_bytes / 4 / aout_FormatNbChannels( &p_aout->output.output ) ); // 4 is fl32 specific
{
/* We don't have enough data yet */
aout_buffer_t * p_buffer;
- p_buffer = aout_OutputNextBuffer( p_aout, current_date , VLC_FALSE );
+ p_buffer = aout_OutputNextBuffer( p_aout, current_date , false );
if( p_buffer != NULL )
{
uint32_t i_second_mData_bytes = __MIN( p_buffer->i_nb_bytes, ioData->mBuffers[0].mDataByteSize - i_mData_bytes );
- p_aout->p_libvlc->pf_memcpy( (uint8_t *)ioData->mBuffers[0].mData + i_mData_bytes, p_buffer->p_buffer, i_second_mData_bytes );
+ vlc_memcpy( (uint8_t *)ioData->mBuffers[0].mData + i_mData_bytes,
+ p_buffer->p_buffer, i_second_mData_bytes );
i_mData_bytes += i_second_mData_bytes;
if( i_mData_bytes >= ioData->mBuffers[0].mDataByteSize )
{
p_sys->i_total_bytes = p_buffer->i_nb_bytes - i_second_mData_bytes;
- p_aout->p_libvlc->pf_memcpy( p_sys->p_remainder_buffer, &p_buffer->p_buffer[i_second_mData_bytes], p_sys->i_total_bytes );
+ vlc_memcpy( p_sys->p_remainder_buffer,
+ &p_buffer->p_buffer[i_second_mData_bytes],
+ p_sys->i_total_bytes );
}
else
{
}
else
{
- p_aout->p_libvlc->pf_memset( (uint8_t *)ioData->mBuffers[0].mData +i_mData_bytes, 0, ioData->mBuffers[0].mDataByteSize - i_mData_bytes );
+ vlc_memset( (uint8_t *)ioData->mBuffers[0].mData +i_mData_bytes,
+ 0,ioData->mBuffers[0].mDataByteSize - i_mData_bytes );
i_mData_bytes += ioData->mBuffers[0].mDataByteSize - i_mData_bytes;
}
}
AudioConvertHostTimeToNanos( inOutputTime->mHostTime ) / 1000;
//- ((mtime_t) 1000000 / p_aout->output.output.i_rate * 31 ); // 31 = Latency in Frames. retrieve somewhere
- p_buffer = aout_OutputNextBuffer( p_aout, current_date, VLC_TRUE );
+ p_buffer = aout_OutputNextBuffer( p_aout, current_date, true );
#define BUFFER outOutputData->mBuffers[p_sys->i_stream_index]
if( p_buffer != NULL )
msg_Warn( p_aout, "bytesize: %d nb_bytes: %d", (int)BUFFER.mDataByteSize, (int)p_buffer->i_nb_bytes );
/* move data into output data buffer */
- p_aout->p_libvlc->pf_memcpy( BUFFER.mData,
- p_buffer->p_buffer, p_buffer->i_nb_bytes );
+ vlc_memcpy( BUFFER.mData, p_buffer->p_buffer, p_buffer->i_nb_bytes );
aout_BufferFree( p_buffer );
}
else
{
- p_aout->p_libvlc->pf_memset( BUFFER.mData, 0, BUFFER.mDataByteSize );
+ vlc_memset( BUFFER.mData, 0, BUFFER.mDataByteSize );
}
#undef BUFFER
projects / vlc / blobdiff