auhal: updated to the latest API

the newly used API was introduced in OS X 10.5, while we still tried to use an older one

note that optical audio output is completely untested

modules/audio_output/auhal.c

@@ -124,9 +124,8 @@ static OSStatus RenderCallbackAnalog    ( vlc_object_t *, AudioUnitRenderActionF
                                           unsigned int, unsigned int, AudioBufferList *);
 static OSStatus RenderCallbackSPDIF     ( AudioDeviceID, const AudioTimeStamp *, const void *, const AudioTimeStamp *,
                                           AudioBufferList *, const AudioTimeStamp *, void * );
-static OSStatus HardwareListener        ( AudioHardwarePropertyID, void *);
-static OSStatus StreamListener          ( AudioStreamID, UInt32,
-                                          AudioDevicePropertyID, void * );
+static OSStatus HardwareListener        ( AudioObjectID, UInt32, const AudioObjectPropertyAddress *, void * );
+static OSStatus StreamListener          ( AudioObjectID, UInt32, const AudioObjectPropertyAddress *, void * );
 static int      AudioDeviceCallback     ( vlc_object_t *, const char *,
                                           vlc_value_t, vlc_value_t, void * );
 
@@ -213,13 +212,18 @@ static int Open( vlc_object_t * p_this )
 
     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 ) ? true : false;
+    if( p_sys->b_supports_digital )
+        msg_Dbg( p_aout, "audio-device supports digital output" );
+    else
+        msg_Dbg( p_aout, "audio-device does not support digital output" );
 
     /* Check if the desired device is alive and usable */
     /* TODO: add a callback to the device to alert us if the device dies */
     i_param_size = sizeof( b_alive );
-    err = AudioDeviceGetProperty( p_sys->i_selected_dev, 0, FALSE,
-                                  kAudioDevicePropertyDeviceIsAlive,
-                                  &i_param_size, &b_alive );
+    AudioObjectPropertyAddress audioDeviceAliveAddress = { kAudioDevicePropertyDeviceIsAlive,
+                                              kAudioDevicePropertyScopeOutput,
+                                              kAudioObjectPropertyElementMaster };
+    err = AudioObjectGetPropertyData( p_sys->i_selected_dev, &audioDeviceAliveAddress, 0, NULL, &i_param_size, &b_alive );
 
     if( err != noErr )
     {
@@ -233,12 +237,14 @@ static int Open( vlc_object_t * p_this )
         msg_Warn( p_aout, "selected audio device is not alive, switching to default device" );
         p_sys->i_selected_dev = p_sys->i_default_dev;
     }
+    else
+        msg_Dbg( p_aout, "selected audio device is alive" );
 
+    AudioObjectPropertyAddress audioDeviceHogModeAddress = { kAudioDevicePropertyHogMode,
+                                  kAudioDevicePropertyScopeOutput,
+                                  kAudioObjectPropertyElementMaster };
     i_param_size = sizeof( p_sys->i_hog_pid );
-    err = AudioDeviceGetProperty( p_sys->i_selected_dev, 0, FALSE,
-                                  kAudioDevicePropertyHogMode,
-                                  &i_param_size, &p_sys->i_hog_pid );
-
+    err = AudioObjectGetPropertyData( p_sys->i_selected_dev, &audioDeviceHogModeAddress, 0, NULL, &i_param_size, &p_sys->i_hog_pid );
     if( err != noErr )
     {
         /* This is not a fatal error. Some drivers simply don't support this property */
@@ -255,21 +261,30 @@ static int Open( vlc_object_t * p_this )
                           "use by another program.") );
         goto error;
     }
+    else
+        msg_Dbg( p_aout, "device is free for us to use" );
 
     /* Check for Digital mode or Analog output mode */
     if( AOUT_FMT_NON_LINEAR( &p_aout->output.output ) && p_sys->b_supports_digital )
     {
         if( OpenSPDIF( p_aout ) )
+        {
+            msg_Dbg( p_aout, "digital output successfully opened" );
             return VLC_SUCCESS;
+        }
     }
     else
     {
         if( OpenAnalog( p_aout ) )
+        {
+            msg_Dbg( p_aout, "analog output successfully opened" );
             return VLC_SUCCESS;
+        }
     }
 
 error:
     /* If we reach this, this aout has failed */
+    msg_Err( p_aout, "opening the auhal output failed" );
     var_Destroy( p_aout, "audio-device" );
     free( p_sys );
     return VLC_EGENERIC;
@@ -607,11 +622,11 @@ static int OpenSPDIF( aout_instance_t * p_aout )
     p_sys->b_digital = true;
 
     /* Hog the device */
+    AudioObjectPropertyAddress audioDeviceHogModeAddress = { kAudioDevicePropertyHogMode, kAudioDevicePropertyScopeOutput, kAudioObjectPropertyElementMaster };
     i_param_size = sizeof( p_sys->i_hog_pid );
     p_sys->i_hog_pid = getpid() ;
 
-    err = AudioDeviceSetProperty( p_sys->i_selected_dev, 0, 0, FALSE,
-                                  kAudioDevicePropertyHogMode, i_param_size, &p_sys->i_hog_pid );
+    err = AudioObjectSetPropertyData( p_sys->i_selected_dev, &audioDeviceHogModeAddress, 0, NULL, i_param_size, &p_sys->i_hog_pid );
 
     if( err != noErr )
     {
@@ -620,17 +635,15 @@ static int OpenSPDIF( aout_instance_t * p_aout )
     }
 
     /* Set mixable to false if we are allowed to */
-    err = AudioDeviceGetPropertyInfo( p_sys->i_selected_dev, 0, FALSE, kAudioDevicePropertySupportsMixing,
-                                    &i_param_size, &b_writeable );
-
-    err = AudioDeviceGetProperty( p_sys->i_selected_dev, 0, FALSE, kAudioDevicePropertySupportsMixing,
-                                    &i_param_size, &b_mix );
+    AudioObjectPropertyAddress audioDeviceSupportsMixingAddress = { kAudioDevicePropertySupportsMixing , kAudioDevicePropertyScopeOutput, kAudioObjectPropertyElementMaster };
+    b_writeable = AudioObjectHasProperty( p_sys->i_selected_dev, &audioDeviceSupportsMixingAddress );
+    err = AudioObjectGetPropertyDataSize( p_sys->i_selected_dev, &audioDeviceSupportsMixingAddress, 0, NULL, &i_param_size );
+    err = AudioObjectGetPropertyData( p_sys->i_selected_dev, &audioDeviceSupportsMixingAddress, 0, NULL, &i_param_size, &b_mix );
 
     if( !err && b_writeable )
     {
         b_mix = 0;
-        err = AudioDeviceSetProperty( p_sys->i_selected_dev, 0, 0, FALSE,
-                            kAudioDevicePropertySupportsMixing, i_param_size, &b_mix );
+        err = AudioObjectSetPropertyData( p_sys->i_selected_dev, &audioDeviceSupportsMixingAddress, 0, NULL, i_param_size, &b_mix );
         p_sys->b_changed_mixing = true;
     }
 
@@ -641,9 +654,8 @@ static int OpenSPDIF( aout_instance_t * p_aout )
     }
 
     /* Get a list of all the streams on this device */
-    err = AudioDeviceGetPropertyInfo( p_sys->i_selected_dev, 0, FALSE,
-                                      kAudioDevicePropertyStreams,
-                                      &i_param_size, NULL );
+    AudioObjectPropertyAddress streamsAddress = { kAudioDevicePropertyStreams, kAudioDevicePropertyScopeOutput, kAudioObjectPropertyElementMaster };
+    err = AudioObjectGetPropertyDataSize( p_sys->i_selected_dev, &streamsAddress, 0, NULL, &i_param_size );
     if( err != noErr )
     {
         msg_Err( p_aout, "could not get number of streams: [%4.4s]", (char *)&err );
@@ -655,9 +667,7 @@ static int OpenSPDIF( aout_instance_t * p_aout )
     if( p_streams == NULL )
         return false;
 
-    err = AudioDeviceGetProperty( p_sys->i_selected_dev, 0, FALSE,
-                                    kAudioDevicePropertyStreams,
-                                    &i_param_size, p_streams );
+    err = AudioObjectGetPropertyData( p_sys->i_selected_dev, &streamsAddress, 0, NULL, &i_param_size, p_streams );
 
     if( err != noErr )
     {
@@ -666,6 +676,7 @@ static int OpenSPDIF( aout_instance_t * p_aout )
         return false;
     }
 
+    AudioObjectPropertyAddress physicalFormatsAddress = { kAudioStreamPropertyPhysicalFormats, kAudioDevicePropertyScopeOutput, kAudioObjectPropertyElementMaster };
     for( i = 0; i < i_streams && p_sys->i_stream_index < 0 ; i++ )
     {
         /* Find a stream with a cac3 stream */
@@ -674,12 +685,10 @@ static int OpenSPDIF( aout_instance_t * p_aout )
         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 );
+        err = AudioObjectGetPropertyDataSize( p_streams[i], &physicalFormatsAddress, 0, NULL, &i_param_size );
         if( err != noErr )
         {
-            msg_Err( p_aout, "could not get number of streamformats: [%4.4s]", (char *)&err );
+            msg_Err( p_aout, "OpenSPDIF: could not get number of streamformats: [%s] (%i)", (char *)&err, err );
             continue;
         }
 
@@ -688,9 +697,7 @@ static int OpenSPDIF( aout_instance_t * p_aout )
         if( p_format_list == NULL )
             continue;
 
-        err = AudioStreamGetProperty( p_streams[i], 0,
-                                          kAudioStreamPropertyPhysicalFormats,
-                                          &i_param_size, p_format_list );
+        err = AudioObjectGetPropertyData( p_streams[i], &physicalFormatsAddress, 0, NULL, &i_param_size, p_format_list );
         if( err != noErr )
         {
             msg_Err( p_aout, "could not get the list of streamformats: [%4.4s]", (char *)&err );
@@ -723,10 +730,7 @@ static int OpenSPDIF( aout_instance_t * p_aout )
             {
                 /* Retrieve the original format of this stream first if not done so already */
                 i_param_size = sizeof( p_sys->sfmt_revert );
-                err = AudioStreamGetProperty( p_sys->i_stream_id, 0,
-                                              kAudioStreamPropertyPhysicalFormat,
-                                              &i_param_size,
-                                              &p_sys->sfmt_revert );
+                err = AudioObjectGetPropertyData( p_sys->i_stream_id, &physicalFormatsAddress, 0, NULL, &i_param_size, &p_sys->sfmt_revert );
                 if( err != noErr )
                 {
                     msg_Err( p_aout, "could not retrieve the original streamformat: [%4.4s]", (char *)&err );
@@ -865,18 +869,15 @@ static void Close( vlc_object_t * p_this )
             int b_mix;
             Boolean b_writeable;
             /* Revert mixable to true if we are allowed to */
-            err = AudioDeviceGetPropertyInfo( p_sys->i_selected_dev, 0, FALSE, kAudioDevicePropertySupportsMixing,
-                                        &i_param_size, &b_writeable );
-
-            err = AudioDeviceGetProperty( p_sys->i_selected_dev, 0, FALSE, kAudioDevicePropertySupportsMixing,
-                                        &i_param_size, &b_mix );
+            AudioObjectPropertyAddress audioDeviceSupportsMixingAddress = { kAudioDevicePropertySupportsMixing , kAudioDevicePropertyScopeOutput, kAudioObjectPropertyElementMaster };
+            b_writeable = AudioObjectHasProperty( p_sys->i_selected_dev, &audioDeviceSupportsMixingAddress );
+            err = AudioObjectGetPropertyData( p_sys->i_selected_dev, &audioDeviceSupportsMixingAddress, 0, NULL, &i_param_size, &b_mix );
 
             if( !err && b_writeable )
             {
                 msg_Dbg( p_aout, "mixable is: %d", b_mix );
                 b_mix = 1;
-                err = AudioDeviceSetProperty( p_sys->i_selected_dev, 0, 0, FALSE,
-                                    kAudioDevicePropertySupportsMixing, i_param_size, &b_mix );
+                err = AudioObjectSetPropertyData( p_sys->i_selected_dev, &audioDeviceSupportsMixingAddress, 0, NULL, i_param_size, &b_mix );
             }
 
             if( err != noErr )
@@ -886,8 +887,8 @@ static void Close( vlc_object_t * p_this )
         }
     }
 
-    err = AudioHardwareRemovePropertyListener( kAudioHardwarePropertyDevices,
-                                               HardwareListener );
+    AudioObjectPropertyAddress audioDevicesAddress = { kAudioHardwarePropertyDevices, kAudioDevicePropertyScopeOutput, kAudioObjectPropertyElementMaster };
+    err = AudioObjectRemovePropertyListener( kAudioObjectSystemObject, &audioDevicesAddress, HardwareListener, NULL );
 
     if( err != noErr )
     {
@@ -898,8 +899,10 @@ static void Close( vlc_object_t * p_this )
     {
         p_sys->i_hog_pid = -1;
         i_param_size = sizeof( p_sys->i_hog_pid );
-        err = AudioDeviceSetProperty( p_sys->i_selected_dev, 0, 0, FALSE,
-                                         kAudioDevicePropertyHogMode, i_param_size, &p_sys->i_hog_pid );
+        AudioObjectPropertyAddress audioDeviceHogModeAddress = { kAudioDevicePropertyHogMode,
+            kAudioDevicePropertyScopeOutput,
+            kAudioObjectPropertyElementMaster };
+        err = AudioObjectSetPropertyData( p_sys->i_selected_dev, &audioDeviceHogModeAddress, 0, NULL, i_param_size, &p_sys->i_hog_pid );
         if( err != noErr ) msg_Err( p_aout, "Could not release hogmode: [%4.4s]", (char *)&err );
     }
 
@@ -929,11 +932,11 @@ static void Probe( aout_instance_t * p_aout )
     struct aout_sys_t   *p_sys = p_aout->output.p_sys;
 
     /* Get number of devices */
-    err = AudioHardwareGetPropertyInfo( kAudioHardwarePropertyDevices,
-                                        &i_param_size, NULL );
+    AudioObjectPropertyAddress audioDevicesAddress = { kAudioHardwarePropertyDevices, kAudioDevicePropertyScopeOutput, kAudioObjectPropertyElementMaster };
+    err = AudioObjectGetPropertyDataSize(kAudioObjectSystemObject, &audioDevicesAddress, 0, NULL, &i_param_size);
     if( err != noErr )
     {
-        msg_Err( p_aout, "Could not get number of devices: [%4.4s]", (char *)&err );
+        msg_Err( p_aout, "Could not get number of devices: [%s]", (char *)&err );
         goto error;
     }
 
@@ -953,21 +956,20 @@ static void Probe( aout_instance_t * p_aout )
         goto error;
 
     /* Populate DeviceID array */
-    err = AudioHardwareGetProperty( kAudioHardwarePropertyDevices,
-                                    &i_param_size, p_devices );
+    err = AudioObjectGetPropertyData( kAudioObjectSystemObject, &audioDevicesAddress, 0, NULL, &i_param_size, p_devices );
     if( err != noErr )
     {
-        msg_Err( p_aout, "could not get the device IDs: [%4.4s]", (char *)&err );
+        msg_Err( p_aout, "could not get the device IDs: [%s]", (char *)&err );
         goto error;
     }
 
     /* Find the ID of the default Device */
+    AudioObjectPropertyAddress defaultDeviceAddress = { kAudioHardwarePropertyDefaultOutputDevice, kAudioDevicePropertyScopeOutput, kAudioObjectPropertyElementMaster };
     i_param_size = sizeof( AudioDeviceID );
-    err = AudioHardwareGetProperty( kAudioHardwarePropertyDefaultOutputDevice,
-                                    &i_param_size, &devid_def );
+    err= AudioObjectGetPropertyData( kAudioObjectSystemObject, &defaultDeviceAddress, 0, NULL, &i_param_size, &devid_def );
     if( err != noErr )
     {
-        msg_Err( p_aout, "could not get default audio device: [%4.4s]", (char *)&err );
+        msg_Err( p_aout, "could not get default audio device: [%s]", (char *)&err );
         goto error;
     }
     p_sys->i_default_dev = devid_def;
@@ -976,24 +978,20 @@ static void Probe( aout_instance_t * p_aout )
     text.psz_string = (char*)_("Audio Device");
     var_Change( p_aout, "audio-device", VLC_VAR_SETTEXT, &text, NULL );
 
+    AudioObjectPropertyAddress deviceNameAddress = { kAudioDevicePropertyDeviceName, kAudioDevicePropertyScopeOutput, kAudioObjectPropertyElementMaster };
+
     for( i = 0; i < p_sys->i_devices; i++ )
     {
         char *psz_name;
         i_param_size = 0;
 
         /* Retrieve the length of the device name */
-        err = AudioDeviceGetPropertyInfo(
-                    p_devices[i], 0, false,
-                    kAudioDevicePropertyDeviceName,
-                    &i_param_size, NULL);
+        err = AudioObjectGetPropertyDataSize( p_devices[i], &deviceNameAddress, 0, NULL, &i_param_size );
         if( err ) goto error;
 
         /* Retrieve the name of the device */
         psz_name = (char *)malloc( i_param_size );
-        err = AudioDeviceGetProperty(
-                    p_devices[i], 0, false,
-                    kAudioDevicePropertyDeviceName,
-                    &i_param_size, psz_name);
+        err = AudioObjectGetPropertyData( p_devices[i], &deviceNameAddress, 0, NULL, &i_param_size, psz_name );
         if( err ) goto error;
 
         msg_Dbg( p_aout, "DevID: %u DevName: %s", p_devices[i], psz_name );
@@ -1050,9 +1048,7 @@ static void Probe( aout_instance_t * p_aout )
     var_AddCallback( p_aout, "audio-device", AudioDeviceCallback, NULL );
 
     /* Attach a Listener so that we are notified of a change in the Device setup */
-    err = AudioHardwareAddPropertyListener( kAudioHardwarePropertyDevices,
-                                            HardwareListener,
-                                            (void *)p_aout );
+    err = AudioObjectAddPropertyListener( kAudioObjectSystemObject, &audioDevicesAddress, HardwareListener, (void *)p_aout );
     if( err )
         goto error;
 
@@ -1071,9 +1067,9 @@ error:
 static int AudioDeviceHasOutput( AudioDeviceID i_dev_id )
 {
     UInt32            dataSize;
-    Boolean            isWritable;
 
-    verify_noerr( AudioDeviceGetPropertyInfo( i_dev_id, 0, FALSE, kAudioDevicePropertyStreams, &dataSize, &isWritable) );
+    AudioObjectPropertyAddress streamsAddress = { kAudioDevicePropertyStreams, kAudioDevicePropertyScopeOutput, kAudioObjectPropertyElementMaster };
+    verify_noerr( AudioObjectGetPropertyDataSize( i_dev_id, &streamsAddress, 0, NULL, &dataSize ) );
     if (dataSize == 0) return FALSE;
 
     return TRUE;
@@ -1091,12 +1087,12 @@ static int AudioDeviceSupportsDigital( aout_instance_t *p_aout, AudioDeviceID i_
     bool                  b_return = false;
 
     /* Retrieve all the output streams */
-    err = AudioDeviceGetPropertyInfo( i_dev_id, 0, FALSE,
-                                      kAudioDevicePropertyStreams,
-                                      &i_param_size, NULL );
+    AudioObjectPropertyAddress streamsAddress = { kAudioDevicePropertyStreams, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };
+    err = AudioObjectGetPropertyDataSize( i_dev_id, &streamsAddress, 0, NULL, &i_param_size );
+
     if( err != noErr )
     {
-        msg_Err( p_aout, "could not get number of streams: [%4.4s]", (char *)&err );
+        msg_Err( p_aout, "could not get number of streams: [%s] (%i)", (char *)&err, err );
         return false;
     }
 
@@ -1105,13 +1101,11 @@ static int AudioDeviceSupportsDigital( aout_instance_t *p_aout, AudioDeviceID i_
     if( p_streams == NULL )
         return VLC_ENOMEM;
 
-    err = AudioDeviceGetProperty( i_dev_id, 0, FALSE,
-                                    kAudioDevicePropertyStreams,
-                                    &i_param_size, p_streams );
+    err = AudioObjectGetPropertyData( i_dev_id, &streamsAddress, 0, NULL, &i_param_size, p_streams );
 
     if( err != noErr )
     {
-        msg_Err( p_aout, "could not get number of streams: [%4.4s]", (char *)&err );
+        msg_Err( p_aout, "could not get list of streams: [%s]", (char *)&err );
         return false;
     }
 
@@ -1137,12 +1131,16 @@ static int AudioStreamSupportsDigital( aout_instance_t *p_aout, AudioStreamID i_
     bool                  b_return = false;
 
     /* Retrieve all the stream formats supported by each output stream */
-    err = AudioStreamGetPropertyInfo( i_stream_id, 0,
-                                      kAudioStreamPropertyPhysicalFormats,
-                                      &i_param_size, NULL );
-    if( err != noErr )
+    AudioObjectPropertyAddress physicalFormatsAddress = { kAudioStreamPropertyAvailablePhysicalFormats, kAudioDevicePropertyScopeOutput, kAudioObjectPropertyElementMaster };
+    err = AudioObjectGetPropertyDataSize( i_stream_id, &physicalFormatsAddress, 0, NULL, &i_param_size );
+    if( err == kAudioHardwareUnknownPropertyError )
+    {
+        msg_Err( p_aout, "audio stream doesn't support query kAudioStreamPropertyAvailablePhysicalFormats" );
+        return false;
+    }
+    else if( err != noErr )
     {
-        msg_Err( p_aout, "could not get number of streamformats: [%4.4s]", (char *)&err );
+        msg_Err( p_aout, "AudioStreamSupportsDigital: could not get number of streamformats: [%s] (%i)", (char *)&err, err );
         return false;
     }
 
@@ -1151,9 +1149,7 @@ static int AudioStreamSupportsDigital( aout_instance_t *p_aout, AudioStreamID i_
     if( p_format_list == NULL )
         return false;
 
-    err = AudioStreamGetProperty( i_stream_id, 0,
-                                      kAudioStreamPropertyPhysicalFormats,
-                                      &i_param_size, p_format_list );
+    err = AudioObjectGetPropertyData( i_stream_id, &physicalFormatsAddress, 0, NULL, &i_param_size, p_format_list );
     if( err != noErr )
     {
         msg_Err( p_aout, "could not get the list of streamformats: [%4.4s]", (char *)&err );
@@ -1186,6 +1182,8 @@ static int AudioStreamChangeFormat( aout_instance_t *p_aout, AudioStreamID i_str
     UInt32              i_param_size = 0;
     int i;
 
+    AudioObjectPropertyAddress physicalFormatAddress = { kAudioStreamPropertyPhysicalFormat, kAudioDevicePropertyScopeOutput, kAudioObjectPropertyElementMaster };
+
     struct { vlc_mutex_t lock; vlc_cond_t cond; } w;
 
     msg_Dbg( p_aout, STREAM_FORMAT_MSG( "setting stream format: ", change_format ) );
@@ -1196,20 +1194,16 @@ static int AudioStreamChangeFormat( aout_instance_t *p_aout, AudioStreamID i_str
     vlc_mutex_lock( &w.lock );
 
     /* Install the callback */
-    err = AudioStreamAddPropertyListener( i_stream_id, 0,
-                                      kAudioStreamPropertyPhysicalFormat,
-                                      StreamListener, (void *)&w );
+    err = AudioObjectAddPropertyListener( i_stream_id, &physicalFormatAddress, StreamListener, (void *)&w );
     if( err != noErr )
     {
-        msg_Err( p_aout, "AudioStreamAddPropertyListener failed: [%4.4s]", (char *)&err );
+        msg_Err( p_aout, "AudioObjectAddPropertyListener for kAudioStreamPropertyPhysicalFormat failed: [%4.4s]", (char *)&err );
         return false;
     }
 
     /* change the format */
-    err = AudioStreamSetProperty( i_stream_id, 0, 0,
-                                  kAudioStreamPropertyPhysicalFormat,
-                                  sizeof( AudioStreamBasicDescription ),
-                                  &change_format );
+    err = AudioObjectSetPropertyData( i_stream_id, &physicalFormatAddress, 0, NULL, sizeof( AudioStreamBasicDescription ),
+                                     &change_format );
     if( err != noErr )
     {
         msg_Err( p_aout, "could not set the stream format: [%4.4s]", (char *)&err );
@@ -1231,10 +1225,7 @@ static int AudioStreamChangeFormat( aout_instance_t *p_aout, AudioStreamID i_str
         }
 
         i_param_size = sizeof( AudioStreamBasicDescription );
-        err = AudioStreamGetProperty( i_stream_id, 0,
-                                      kAudioStreamPropertyPhysicalFormat,
-                                      &i_param_size,
-                                      &actual_format );
+        err = AudioObjectGetPropertyData( i_stream_id, &physicalFormatAddress, 0, NULL, &i_param_size, &actual_format );
 
         msg_Dbg( p_aout, STREAM_FORMAT_MSG( "actual format in use: ", actual_format ) );
         if( actual_format.mSampleRate == change_format.mSampleRate &&
@@ -1248,9 +1239,7 @@ static int AudioStreamChangeFormat( aout_instance_t *p_aout, AudioStreamID i_str
     }
 
     /* Removing the property listener */
-    err = AudioStreamRemovePropertyListener( i_stream_id, 0,
-                                            kAudioStreamPropertyPhysicalFormat,
-                                            StreamListener );
+    err = AudioObjectRemovePropertyListener( i_stream_id, &physicalFormatAddress, StreamListener, NULL );
     if( err != noErr )
     {
         msg_Err( p_aout, "AudioStreamRemovePropertyListener failed: [%4.4s]", (char *)&err );
@@ -1419,22 +1408,21 @@ static OSStatus RenderCallbackSPDIF( AudioDeviceID inDevice,
 /*****************************************************************************
  * HardwareListener: Warns us of changes in the list of registered devices
  *****************************************************************************/
-static OSStatus HardwareListener( AudioHardwarePropertyID inPropertyID,
-                                  void * inClientData )
+static OSStatus HardwareListener( AudioObjectID inObjectID,  UInt32 inNumberAddresses, const AudioObjectPropertyAddress inAddresses[], void*inClientData)
 {
     OSStatus err = noErr;
     aout_instance_t     *p_aout = (aout_instance_t *)inClientData;
+    VLC_UNUSED(inObjectID);
 
-    switch( inPropertyID )
+    for ( unsigned int i = 0; i < inNumberAddresses; i++ )
     {
-        case kAudioHardwarePropertyDevices:
+        if( inAddresses[i].mSelector == kAudioHardwarePropertyDevices )
         {
             /* something changed in the list of devices */
             /* We trigger the audio-device's aout_ChannelsRestart callback */
             var_TriggerCallback( p_aout, "audio-device" );
             var_Destroy( p_aout, "audio-device" );
         }
-        break;
     }
 
     return( err );
@@ -1443,27 +1431,21 @@ static OSStatus HardwareListener( AudioHardwarePropertyID inPropertyID,
 /*****************************************************************************
  * StreamListener
  *****************************************************************************/
-static OSStatus StreamListener( AudioStreamID inStream,
-                                UInt32 inChannel,
-                                AudioDevicePropertyID inPropertyID,
-                                void * inClientData )
+static OSStatus StreamListener( AudioObjectID inObjectID,  UInt32 inNumberAddresses, const AudioObjectPropertyAddress inAddresses[], void*inClientData)
 {
     OSStatus err = noErr;
     struct { vlc_mutex_t lock; vlc_cond_t cond; } * w = inClientData;
 
-    VLC_UNUSED(inStream);
-    VLC_UNUSED(inChannel);
+    VLC_UNUSED(inObjectID);
 
-    switch( inPropertyID )
+    for ( unsigned int i = 0; i < inNumberAddresses; i++ )
     {
-        case kAudioStreamPropertyPhysicalFormat:
+        if( inAddresses[i].mSelector == kAudioStreamPropertyPhysicalFormat )
+        {
             vlc_mutex_lock( &w->lock );
             vlc_cond_signal( &w->cond );
             vlc_mutex_unlock( &w->lock );
-            break;
-
-        default:
-            break;
+        }
     }
     return( err );
 }