modules/audio_output/auhal.c

   1 /*****************************************************************************
   2  * auhal.c: AUHAL and Coreaudio output plugin
   3  *****************************************************************************
   4  * Copyright (C) 2005 - 2017 VLC authors and VideoLAN
   5  *
   6  * Authors: Derk-Jan Hartman <hartman at videolan dot org>
   7  *          Felix Paul Kühne <fkuehne at videolan dot org>
   8  *          David Fuhrmann <david dot fuhrmann at googlemail dot com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU Lesser General Public License as published by
  12  * the Free Software Foundation; either version 2.1 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18  * GNU Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public License
  21  * along with this program; if not, write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 #pragma mark includes
  26
  27 #import "coreaudio_common.h"
  28
  29 #import <vlc_plugin.h>
  30 #import <vlc_dialog.h>                      // vlc_dialog_display_error
  31
  32 #import <CoreAudio/CoreAudio.h>             // AudioDeviceID
  33 #import <CoreServices/CoreServices.h>
  34
  35 #pragma mark -
  36 #pragma mark local prototypes & module descriptor
  37
  38
  39 #define AOUT_VOLUME_DEFAULT             256
  40 #define AOUT_VOLUME_MAX                 512
  41
  42 #define VOLUME_TEXT N_("Audio volume")
  43 #define VOLUME_LONGTEXT VOLUME_TEXT
  44
  45 #define DEVICE_TEXT N_("Last audio device")
  46 #define DEVICE_LONGTEXT DEVICE_TEXT
  47
  48 static int      Open                    (vlc_object_t *);
  49 static void     Close                   (vlc_object_t *);
  50
  51 vlc_module_begin ()
  52     set_shortname("auhal")
  53     set_description(N_("HAL AudioUnit output"))
  54     set_capability("audio output", 101)
  55     set_category(CAT_AUDIO)
  56     set_subcategory(SUBCAT_AUDIO_AOUT)
  57     set_callbacks(Open, Close)
  58     add_integer("auhal-volume", AOUT_VOLUME_DEFAULT,
  59                 VOLUME_TEXT, VOLUME_LONGTEXT, true)
  60     change_integer_range(0, AOUT_VOLUME_MAX)
  61     add_string("auhal-audio-device", "", DEVICE_TEXT, DEVICE_LONGTEXT, true)
  62     add_obsolete_integer("macosx-audio-device") /* since 2.1.0 */
  63 vlc_module_end ()
  64
  65 #pragma mark -
  66 #pragma mark private declarations
  67
  68 #define AOUT_VAR_SPDIF_FLAG 0xf00000
  69
  70 /*****************************************************************************
  71  * aout_sys_t: private audio output method descriptor
  72  *****************************************************************************
  73  * This structure is part of the audio output thread descriptor.
  74  * It describes the CoreAudio specific properties of an output thread.
  75  *****************************************************************************/
  76 struct aout_sys_t
  77 {
  78     struct aout_sys_common c;
  79
  80     /* DeviceID of the selected device */
  81     AudioObjectID               i_selected_dev;
  82     /* DeviceID of device which will be selected on start */
  83     AudioObjectID               i_new_selected_dev;
  84     /* true if the user selected the default audio device (id 0) */
  85     bool                        b_selected_dev_is_default;
  86
  87     /* DeviceID of current device */
  88     AudioDeviceIOProcID         i_procID;
  89     /* Are we running in digital mode? */
  90     bool                        b_digital;
  91
  92     /* AUHAL specific */
  93     AudioUnit                   au_unit;
  94
  95     /* CoreAudio SPDIF mode specific */
  96     /* Keep the pid of our hog status */
  97     pid_t                       i_hog_pid;
  98     /* The StreamID that has a cac3 streamformat */
  99     AudioStreamID               i_stream_id;
 100     /* The index of i_stream_id in an AudioBufferList */
 101     int                         i_stream_index;
 102     /* The original format of the stream */
 103     AudioStreamBasicDescription sfmt_revert;
 104     /* Whether we need to revert the stream format */
 105     bool                        b_revert;
 106     /* Whether we need to set the mixing mode back */
 107     bool                        b_changed_mixing;
 108
 109     CFArrayRef                  device_list;
 110     /* protects access to device_list */
 111     vlc_mutex_t                 device_list_lock;
 112
 113     /* Synchronizes access to i_selected_dev. This is only needed between VLCs
 114      * audio thread and the core audio callback thread. The value is only
 115      * changed in Start, further access to this variable within the audio
 116      * thread (start, stop, close) needs no protection. */
 117     vlc_mutex_t                 selected_device_lock;
 118
 119     float                       f_volume;
 120     bool                        b_mute;
 121
 122     bool                        b_ignore_streams_changed_callback;
 123 };
 124
 125 #pragma mark -
 126 #pragma mark helpers
 127
 128 static int
 129 AoGetProperty(audio_output_t *p_aout, AudioObjectID id,
 130               const AudioObjectPropertyAddress *p_address, size_t i_elm_size,
 131               ssize_t i_nb_expected_elms, size_t *p_nb_elms, void **pp_out_data,
 132               void *p_allocated_out_data)
 133 {
 134     assert(i_elm_size > 0);
 135
 136     /* Get data size */
 137     UInt32 i_out_size;
 138     OSStatus err = AudioObjectGetPropertyDataSize(id, p_address, 0, NULL,
 139                                                   &i_out_size);
 140     if (err != noErr)
 141     {
 142         msg_Err(p_aout, "AudioObjectGetPropertyDataSize failed, device id: %i, "
 143                 "prop: [%4.4s], OSStatus: %d", id, (const char *) &p_address[0],
 144                 (int)err);
 145         return VLC_EGENERIC;
 146     }
 147
 148     size_t i_nb_elms = i_out_size / i_elm_size;
 149     if (p_nb_elms != NULL)
 150         *p_nb_elms = i_nb_elms;
 151     /* Check if we get the expected number of elements */
 152     if (i_nb_expected_elms != -1 && (size_t)i_nb_expected_elms != i_nb_elms)
 153     {
 154         msg_Err(p_aout, "AoGetProperty error: expected elements don't match");
 155         return VLC_EGENERIC;
 156     }
 157
 158     if (pp_out_data == NULL && p_allocated_out_data == NULL)
 159         return VLC_SUCCESS;
 160
 161     if (i_out_size == 0)
 162     {
 163         if (pp_out_data != NULL)
 164             *pp_out_data = NULL;
 165         return VLC_SUCCESS;
 166     }
 167
 168     /* Alloc data or use pre-allocated one */
 169     void *p_out_data;
 170     if (pp_out_data != NULL)
 171     {
 172         assert(p_allocated_out_data == NULL);
 173
 174         *pp_out_data = malloc(i_out_size);
 175         if (*pp_out_data == NULL)
 176             return VLC_ENOMEM;
 177         p_out_data = *pp_out_data;
 178     }
 179     else
 180     {
 181         assert(p_allocated_out_data != NULL);
 182         p_out_data = p_allocated_out_data;
 183     }
 184
 185     /* Fill data */
 186     err = AudioObjectGetPropertyData(id, p_address, 0, NULL, &i_out_size,
 187                                      p_out_data);
 188     if (err != noErr)
 189     {
 190         msg_Err(p_aout, "AudioObjectGetPropertyData failed, device id: %i, "
 191                 "prop: [%4.4s], OSStatus: %d", id, (const char *) &p_address[0],
 192                 (int) err);
 193
 194         if (pp_out_data != NULL)
 195             free(*pp_out_data);
 196         return VLC_EGENERIC;
 197     }
 198     assert(p_nb_elms == NULL || *p_nb_elms == (i_out_size / i_elm_size));
 199     return VLC_SUCCESS;
 200 }
 201
 202 /* Get Audio Object Property data: pp_out_data will be allocated by this MACRO
 203  * and need to be freed in case of success. */
 204 #define AO_GETPROP(id, type, p_out_nb_elms, pp_out_data, a1, a2) \
 205     AoGetProperty(p_aout, (id), \
 206                   &(AudioObjectPropertyAddress) {(a1), (a2), 0}, sizeof(type), \
 207                   -1, (p_out_nb_elms), (void **)(pp_out_data), NULL)
 208
 209 /* Get 1 Audio Object Property data: pre-allocated by the caller */
 210 #define AO_GET1PROP(id, type, p_out_data, a1, a2) \
 211     AoGetProperty(p_aout, (id), \
 212                   &(AudioObjectPropertyAddress) {(a1), (a2), 0}, sizeof(type), \
 213                   1, NULL, NULL, (p_out_data))
 214
 215 static bool
 216 AoIsPropertySettable(audio_output_t *p_aout, AudioObjectID id,
 217                      const AudioObjectPropertyAddress *p_address)
 218 {
 219     Boolean b_settable;
 220     OSStatus err = AudioObjectIsPropertySettable(id, p_address, &b_settable);
 221     if (err != noErr)
 222     {
 223         msg_Warn(p_aout, "AudioObjectIsPropertySettable failed, device id: %i, "
 224                  "prop: [%4.4s], OSStatus: %d", id, (const char *)&p_address[0],
 225                  (int)err);
 226         return false;
 227     }
 228     return b_settable;
 229 }
 230
 231 #define AO_ISPROPSETTABLE(id, a1, a2) \
 232     AoIsPropertySettable(p_aout, (id), \
 233                          &(AudioObjectPropertyAddress) { (a1), (a2), 0})
 234
 235 #define AO_HASPROP(id, a1, a2) \
 236     AudioObjectHasProperty((id), &(AudioObjectPropertyAddress) { (a1), (a2), 0})
 237
 238 static int
 239 AoSetProperty(audio_output_t *p_aout, AudioObjectID id,
 240               const AudioObjectPropertyAddress *p_address, size_t i_data,
 241               const void *p_data)
 242 {
 243     OSStatus err =
 244         AudioObjectSetPropertyData(id, p_address, 0, NULL, i_data, p_data);
 245
 246     if (err != noErr)
 247     {
 248         msg_Err(p_aout, "AudioObjectSetPropertyData failed, device id: %i, "
 249                  "prop: [%4.4s], OSStatus: %d", id, (const char *)&p_address[0],
 250                  (int)err);
 251         return VLC_EGENERIC;
 252     }
 253     return VLC_SUCCESS;
 254 }
 255
 256 #define AO_SETPROP(id, i_data, p_data, a1, a2) \
 257     AoSetProperty(p_aout, (id), \
 258                   &(AudioObjectPropertyAddress) { (a1), (a2), 0}, \
 259                   (i_data), (p_data));
 260
 261 static int
 262 AoUpdateListener(audio_output_t *p_aout, bool add, AudioObjectID id,
 263                  const AudioObjectPropertyAddress *p_address,
 264                  AudioObjectPropertyListenerProc listener, void *data)
 265 {
 266     OSStatus err = add ?
 267         AudioObjectAddPropertyListener(id, p_address, listener, data) :
 268         AudioObjectRemovePropertyListener(id, p_address, listener, data);
 269
 270     if (err != noErr)
 271     {
 272         msg_Err(p_aout, "AudioObject%sPropertyListener failed, device id %i, "
 273                 "prop: [%4.4s], OSStatus: %d", add ? "Add" : "Remove", id,
 274                 (const char *)&p_address[0], (int)err);
 275         return VLC_EGENERIC;
 276     }
 277     return VLC_SUCCESS;
 278 }
 279
 280 #define AO_UPDATELISTENER(id, add, listener, data, a1, a2) \
 281     AoUpdateListener(p_aout, add, (id), \
 282                   &(AudioObjectPropertyAddress) { (a1), (a2), 0}, \
 283                   (listener), (data))
 284
 285 #pragma mark -
 286 #pragma mark Stream / Hardware Listeners
 287
 288 static bool
 289 IsAudioFormatDigital(AudioFormatID id)
 290 {
 291     switch (id)
 292     {
 293         case 'IAC3':
 294         case 'iac3':
 295         case kAudioFormat60958AC3:
 296         case kAudioFormatAC3:
 297         case kAudioFormatEnhancedAC3:
 298             return true;
 299         default:
 300             return false;
 301     }
 302 }
 303
 304 static OSStatus
 305 StreamsChangedListener(AudioObjectID, UInt32,
 306                        const AudioObjectPropertyAddress [], void *);
 307
 308 static int
 309 ManageAudioStreamsCallback(audio_output_t *p_aout, AudioDeviceID i_dev_id,
 310                            bool b_register)
 311 {
 312     /* Retrieve all the output streams */
 313     size_t i_streams;
 314     AudioStreamID *p_streams;
 315     int ret = AO_GETPROP(i_dev_id, AudioStreamID, &i_streams, &p_streams,
 316                           kAudioDevicePropertyStreams,
 317                           kAudioObjectPropertyScopeOutput);
 318     if (ret != VLC_SUCCESS)
 319         return ret;
 320
 321     for (size_t i = 0; i < i_streams; i++)
 322     {
 323         /* get notified when physical formats change */
 324         AO_UPDATELISTENER(p_streams[i], b_register, StreamsChangedListener,
 325                           p_aout, kAudioStreamPropertyAvailablePhysicalFormats,
 326                           kAudioObjectPropertyScopeGlobal);
 327     }
 328
 329     free(p_streams);
 330     return VLC_SUCCESS;
 331 }
 332
 333 /*
 334  * AudioStreamSupportsDigital: Checks if audio stream is compatible with raw
 335  * bitstreams
 336  */
 337 static bool
 338 AudioStreamSupportsDigital(audio_output_t *p_aout, AudioStreamID i_stream_id)
 339 {
 340     bool b_return = false;
 341
 342     /* Retrieve all the stream formats supported by each output stream */
 343     size_t i_formats;
 344     AudioStreamRangedDescription *p_format_list;
 345     int ret = AO_GETPROP(i_stream_id, AudioStreamRangedDescription, &i_formats,
 346                           &p_format_list,
 347                           kAudioStreamPropertyAvailablePhysicalFormats,
 348                           kAudioObjectPropertyScopeGlobal);
 349     if (ret != VLC_SUCCESS)
 350         return false;
 351
 352     for (size_t i = 0; i < i_formats; i++)
 353     {
 354 #ifndef NDEBUG
 355         msg_Dbg(p_aout, STREAM_FORMAT_MSG("supported format: ",
 356                 p_format_list[i].mFormat));
 357 #endif
 358
 359         if (IsAudioFormatDigital(p_format_list[i].mFormat.mFormatID))
 360             b_return = true;
 361     }
 362
 363     free(p_format_list);
 364     return b_return;
 365 }
 366
 367 /*
 368  * AudioDeviceSupportsDigital: Checks if device supports raw bitstreams
 369  */
 370 static bool
 371 AudioDeviceSupportsDigital(audio_output_t *p_aout, AudioDeviceID i_dev_id)
 372 {
 373     size_t i_streams;
 374     AudioStreamID * p_streams;
 375     int ret = AO_GETPROP(i_dev_id, AudioStreamID, &i_streams, &p_streams,
 376                           kAudioDevicePropertyStreams,
 377                           kAudioObjectPropertyScopeOutput);
 378     if (ret != VLC_SUCCESS)
 379         return false;
 380
 381     for (size_t i = 0; i < i_streams; i++)
 382     {
 383         if (AudioStreamSupportsDigital(p_aout, p_streams[i]))
 384         {
 385             free(p_streams);
 386             return true;
 387         }
 388     }
 389
 390     free(p_streams);
 391     return false;
 392 }
 393
 394 static void
 395 ReportDevice(audio_output_t *p_aout, UInt32 i_id, char *name)
 396 {
 397     char deviceid[10];
 398     sprintf(deviceid, "%i", i_id);
 399
 400     aout_HotplugReport(p_aout, deviceid, name);
 401 }
 402
 403 /*
 404  * AudioDeviceIsAHeadphone: Checks if device is a headphone
 405  */
 406
 407 static bool
 408 AudioDeviceIsAHeadphone(audio_output_t *p_aout, AudioDeviceID i_dev_id)
 409 {
 410     UInt32 defaultSize = sizeof(AudioDeviceID);
 411
 412     const AudioObjectPropertyAddress defaultAddr = {
 413         kAudioHardwarePropertyDefaultOutputDevice,
 414         kAudioObjectPropertyScopeGlobal,
 415         kAudioObjectPropertyElementMaster
 416     };
 417
 418     AudioObjectGetPropertyData(kAudioObjectSystemObject, &defaultAddr, 0, NULL, &defaultSize, &i_dev_id);
 419
 420     AudioObjectPropertyAddress property;
 421     property.mSelector = kAudioDevicePropertyDataSource;
 422     property.mScope = kAudioDevicePropertyScopeOutput;
 423     property.mElement = kAudioObjectPropertyElementMaster;
 424
 425     UInt32 data;
 426     UInt32 size = sizeof(UInt32);
 427     AudioObjectGetPropertyData(i_dev_id, &property, 0, NULL, &size, &data);
 428
 429     /*
 430      'hdpn' == headphone
 431      'ispk' == internal speaker
 432      '61pd' == HDMI
 433      '    ' == Bluetooth accessory or AirPlay
 434     */
 435
 436     return data == 'hdpn';
 437 }
 438
 439 /*
 440  * AudioDeviceHasOutput: Checks if the device is actually an output device
 441  */
 442 static int
 443 AudioDeviceHasOutput(audio_output_t *p_aout, AudioDeviceID i_dev_id)
 444 {
 445     size_t i_streams;
 446     int ret = AO_GETPROP(i_dev_id, AudioStreamID, &i_streams, NULL,
 447                           kAudioDevicePropertyStreams,
 448                           kAudioObjectPropertyScopeOutput);
 449     if (ret != VLC_SUCCESS || i_streams == 0)
 450         return FALSE;
 451
 452     return TRUE;
 453 }
 454
 455 static void
 456 RebuildDeviceList(audio_output_t * p_aout)
 457 {
 458     struct aout_sys_t   *p_sys = p_aout->sys;
 459
 460     msg_Dbg(p_aout, "Rebuild device list");
 461
 462     ReportDevice(p_aout, 0, _("System Sound Output Device"));
 463
 464     /* Get number of devices */
 465     size_t i_devices;
 466     AudioDeviceID *p_devices;
 467     int ret = AO_GETPROP(kAudioObjectSystemObject, AudioDeviceID, &i_devices,
 468                          &p_devices, kAudioHardwarePropertyDevices,
 469                          kAudioObjectPropertyScopeGlobal);
 470
 471     if (ret != VLC_SUCCESS || i_devices == 0)
 472     {
 473         msg_Err(p_aout, "No audio output devices found.");
 474         return;
 475     }
 476     msg_Dbg(p_aout, "found %zu audio device(s)", i_devices);
 477
 478     /* setup local array */
 479     CFMutableArrayRef currentListOfDevices =
 480         CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
 481
 482     for (size_t i = 0; i < i_devices; i++)
 483     {
 484         CFStringRef device_name_ref;
 485         char *psz_name;
 486         CFIndex length;
 487         UInt32 i_id = p_devices[i];
 488
 489         int ret = AO_GET1PROP(i_id, CFStringRef, &device_name_ref,
 490                               kAudioObjectPropertyName,
 491                               kAudioObjectPropertyScopeGlobal);
 492         if (ret != VLC_SUCCESS)
 493         {
 494             msg_Dbg(p_aout, "failed to get name for device %i", i_id);
 495             continue;
 496         }
 497
 498         length = CFStringGetLength(device_name_ref);
 499         length++;
 500         psz_name = malloc(length);
 501         if (!psz_name)
 502         {
 503             CFRelease(device_name_ref);
 504             return;
 505         }
 506         CFStringGetCString(device_name_ref, psz_name, length,
 507                            kCFStringEncodingUTF8);
 508         CFRelease(device_name_ref);
 509
 510         msg_Dbg(p_aout, "DevID: %i DevName: %s", i_id, psz_name);
 511
 512         if (!AudioDeviceHasOutput(p_aout, i_id))
 513         {
 514             msg_Dbg(p_aout, "this '%s' is INPUT only. skipping...", psz_name);
 515             free(psz_name);
 516             continue;
 517         }
 518
 519         ReportDevice(p_aout, i_id, psz_name);
 520         CFNumberRef deviceNumber = CFNumberCreate(kCFAllocatorDefault,
 521                                                   kCFNumberSInt32Type, &i_id);
 522         CFArrayAppendValue(currentListOfDevices, deviceNumber);
 523         CFRelease(deviceNumber);
 524
 525         if (AudioDeviceSupportsDigital(p_aout, i_id))
 526         {
 527             msg_Dbg(p_aout, "'%s' supports digital output", psz_name);
 528             char *psz_encoded_name = nil;
 529             asprintf(&psz_encoded_name, _("%s (Encoded Output)"), psz_name);
 530             i_id = i_id | AOUT_VAR_SPDIF_FLAG;
 531             ReportDevice(p_aout, i_id, psz_encoded_name);
 532             deviceNumber = CFNumberCreate(kCFAllocatorDefault,
 533                                           kCFNumberSInt32Type, &i_id);
 534             CFArrayAppendValue(currentListOfDevices, deviceNumber);
 535             CFRelease(deviceNumber);
 536             free(psz_encoded_name);
 537         }
 538
 539         // TODO: only register once for each device
 540         ManageAudioStreamsCallback(p_aout, p_devices[i], true);
 541
 542         free(psz_name);
 543     }
 544
 545     vlc_mutex_lock(&p_sys->device_list_lock);
 546     CFIndex count = 0;
 547     if (p_sys->device_list)
 548         count = CFArrayGetCount(p_sys->device_list);
 549     CFRange newListSearchRange =
 550         CFRangeMake(0, CFArrayGetCount(currentListOfDevices));
 551
 552     if (count > 0)
 553     {
 554         msg_Dbg(p_aout, "Looking for removed devices");
 555         CFNumberRef cfn_device_id;
 556         int i_device_id = 0;
 557         for (CFIndex x = 0; x < count; x++)
 558         {
 559             if (!CFArrayContainsValue(currentListOfDevices, newListSearchRange,
 560                                       CFArrayGetValueAtIndex(p_sys->device_list,
 561                                       x)))
 562             {
 563                 cfn_device_id = CFArrayGetValueAtIndex(p_sys->device_list, x);
 564                 if (cfn_device_id)
 565                 {
 566                     CFNumberGetValue(cfn_device_id, kCFNumberSInt32Type,
 567                                      &i_device_id);
 568                     msg_Dbg(p_aout, "Device ID %i is not found in new array, "
 569                             "deleting.", i_device_id);
 570
 571                     ReportDevice(p_aout, i_device_id, NULL);
 572                 }
 573             }
 574         }
 575     }
 576     if (p_sys->device_list)
 577         CFRelease(p_sys->device_list);
 578     p_sys->device_list = CFArrayCreateCopy(kCFAllocatorDefault,
 579                                            currentListOfDevices);
 580     CFRelease(currentListOfDevices);
 581     vlc_mutex_unlock(&p_sys->device_list_lock);
 582
 583     free(p_devices);
 584 }
 585
 586 /*
 587  * Callback when current device is not alive anymore
 588  */
 589 static OSStatus
 590 DeviceAliveListener(AudioObjectID inObjectID,  UInt32 inNumberAddresses,
 591                     const AudioObjectPropertyAddress inAddresses[],
 592                     void *inClientData)
 593 {
 594     VLC_UNUSED(inObjectID);
 595     VLC_UNUSED(inNumberAddresses);
 596     VLC_UNUSED(inAddresses);
 597
 598     audio_output_t *p_aout = (audio_output_t *)inClientData;
 599     if (!p_aout)
 600         return -1;
 601
 602     msg_Warn(p_aout, "audio device died, resetting aout");
 603     aout_RestartRequest(p_aout, AOUT_RESTART_OUTPUT);
 604
 605     return noErr;
 606 }
 607
 608 /*
 609  * Callback when default audio device changed
 610  */
 611 static OSStatus
 612 DefaultDeviceChangedListener(AudioObjectID inObjectID, UInt32 inNumberAddresses,
 613                              const AudioObjectPropertyAddress inAddresses[],
 614                              void *inClientData)
 615 {
 616     VLC_UNUSED(inObjectID);
 617     VLC_UNUSED(inNumberAddresses);
 618     VLC_UNUSED(inAddresses);
 619
 620     audio_output_t *p_aout = (audio_output_t *)inClientData;
 621     if (!p_aout)
 622         return -1;
 623
 624     aout_sys_t *p_sys = p_aout->sys;
 625
 626     if (!p_aout->sys->b_selected_dev_is_default)
 627         return noErr;
 628
 629     AudioObjectID defaultDeviceID;
 630     int ret = AO_GET1PROP(kAudioObjectSystemObject, AudioObjectID,
 631                           &defaultDeviceID,
 632                           kAudioHardwarePropertyDefaultOutputDevice,
 633                           kAudioObjectPropertyScopeOutput);
 634     if (ret != VLC_SUCCESS)
 635         return -1;
 636
 637     msg_Dbg(p_aout, "default device changed to %i", defaultDeviceID);
 638
 639     /* Default device is changed by the os to allow other apps to play sound
 640      * while in digital mode. But this should not affect ourself. */
 641     if (p_aout->sys->b_digital)
 642     {
 643         msg_Dbg(p_aout, "ignore, as digital mode is active");
 644         return noErr;
 645     }
 646
 647     vlc_mutex_lock(&p_sys->selected_device_lock);
 648     /* Also ignore events which announce the same device id */
 649     if (defaultDeviceID != p_aout->sys->i_selected_dev)
 650     {
 651         msg_Dbg(p_aout, "default device actually changed, resetting aout");
 652         aout_RestartRequest(p_aout, AOUT_RESTART_OUTPUT);
 653     }
 654     vlc_mutex_unlock(&p_sys->selected_device_lock);
 655
 656     return noErr;
 657 }
 658
 659 /*
 660  * Callback when physical formats for device change
 661  */
 662 static OSStatus
 663 StreamsChangedListener(AudioObjectID inObjectID, UInt32 inNumberAddresses,
 664                        const AudioObjectPropertyAddress inAddresses[],
 665                        void *inClientData)
 666 {
 667     VLC_UNUSED(inNumberAddresses);
 668     VLC_UNUSED(inAddresses);
 669
 670     audio_output_t *p_aout = (audio_output_t *)inClientData;
 671     if (!p_aout)
 672         return -1;
 673
 674     aout_sys_t *p_sys = p_aout->sys;
 675     if(unlikely(p_sys->b_ignore_streams_changed_callback == true))
 676         return 0;
 677
 678     msg_Dbg(p_aout, "available physical formats for audio device changed");
 679     RebuildDeviceList(p_aout);
 680
 681     vlc_mutex_lock(&p_sys->selected_device_lock);
 682     /* In this case audio has not yet started. Below code will not work and is
 683      * not needed here. */
 684     if (p_sys->i_selected_dev == 0)
 685     {
 686         vlc_mutex_unlock(&p_sys->selected_device_lock);
 687         return 0;
 688     }
 689
 690     /*
 691      * check if changed stream id belongs to current device
 692      */
 693     size_t i_streams;
 694     AudioStreamID *p_streams;
 695     int ret = AO_GETPROP(p_sys->i_selected_dev, AudioStreamID, &i_streams,
 696                          &p_streams, kAudioDevicePropertyStreams,
 697                          kAudioObjectPropertyScopeOutput);
 698     if (ret != VLC_SUCCESS)
 699     {
 700         vlc_mutex_unlock(&p_sys->selected_device_lock);
 701         return ret;
 702     }
 703     vlc_mutex_unlock(&p_sys->selected_device_lock);
 704
 705     for (size_t i = 0; i < i_streams; i++)
 706     {
 707         if (p_streams[i] == inObjectID)
 708         {
 709             msg_Dbg(p_aout, "Restart aout as this affects current device");
 710             aout_RestartRequest(p_aout, AOUT_RESTART_OUTPUT);
 711             break;
 712         }
 713     }
 714     free(p_streams);
 715
 716     return noErr;
 717 }
 718
 719 /*
 720  * Callback when device list changed
 721  */
 722 static OSStatus
 723 DevicesListener(AudioObjectID inObjectID, UInt32 inNumberAddresses,
 724                 const AudioObjectPropertyAddress inAddresses[],
 725                 void *inClientData)
 726 {
 727     VLC_UNUSED(inObjectID);
 728     VLC_UNUSED(inNumberAddresses);
 729     VLC_UNUSED(inAddresses);
 730
 731     audio_output_t *p_aout = (audio_output_t *)inClientData;
 732     if (!p_aout)
 733         return -1;
 734     aout_sys_t *p_sys = p_aout->sys;
 735
 736     msg_Dbg(p_aout, "audio device configuration changed, resetting cache");
 737     RebuildDeviceList(p_aout);
 738
 739     vlc_mutex_lock(&p_sys->selected_device_lock);
 740     vlc_mutex_lock(&p_sys->device_list_lock);
 741     CFNumberRef selectedDevice =
 742         CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type,
 743                        &p_sys->i_selected_dev);
 744     CFRange range = CFRangeMake(0, CFArrayGetCount(p_sys->device_list));
 745     if (!CFArrayContainsValue(p_sys->device_list, range, selectedDevice))
 746         aout_RestartRequest(p_aout, AOUT_RESTART_OUTPUT);
 747     CFRelease(selectedDevice);
 748     vlc_mutex_unlock(&p_sys->device_list_lock);
 749     vlc_mutex_unlock(&p_sys->selected_device_lock);
 750
 751     return noErr;
 752 }
 753
 754 /*
 755  * StreamListener: check whether the device's physical format change is complete
 756  */
 757 static OSStatus
 758 StreamListener(AudioObjectID inObjectID, UInt32 inNumberAddresses,
 759                const AudioObjectPropertyAddress inAddresses[],
 760                void *inClientData)
 761 {
 762     OSStatus err = noErr;
 763     struct { vlc_mutex_t lock; vlc_cond_t cond; } * w = inClientData;
 764
 765     VLC_UNUSED(inObjectID);
 766
 767     for (unsigned int i = 0; i < inNumberAddresses; i++)
 768     {
 769         if (inAddresses[i].mSelector == kAudioStreamPropertyPhysicalFormat)
 770         {
 771             int canc = vlc_savecancel();
 772             vlc_mutex_lock(&w->lock);
 773             vlc_cond_signal(&w->cond);
 774             vlc_mutex_unlock(&w->lock);
 775             vlc_restorecancel(canc);
 776             break;
 777         }
 778     }
 779     return err;
 780 }
 781
 782 /*
 783  * AudioStreamChangeFormat: switch stream format based on the provided
 784  * description
 785  */
 786 static int
 787 AudioStreamChangeFormat(audio_output_t *p_aout, AudioStreamID i_stream_id,
 788                         AudioStreamBasicDescription change_format)
 789 {
 790     int retValue = false;
 791
 792     struct { vlc_mutex_t lock; vlc_cond_t cond; } w;
 793
 794     msg_Dbg(p_aout, STREAM_FORMAT_MSG("setting stream format: ", change_format));
 795
 796     /* Condition because SetProperty is asynchronious */
 797     vlc_cond_init(&w.cond);
 798     vlc_mutex_init(&w.lock);
 799     vlc_mutex_lock(&w.lock);
 800
 801     /* Install the callback */
 802     int ret = AO_UPDATELISTENER(i_stream_id, true, StreamListener, &w,
 803                                 kAudioStreamPropertyPhysicalFormat,
 804                                 kAudioObjectPropertyScopeGlobal);
 805
 806     if (ret != VLC_SUCCESS)
 807     {
 808         retValue = false;
 809         goto out;
 810     }
 811
 812     /* change the format */
 813     ret = AO_SETPROP(i_stream_id, sizeof(AudioStreamBasicDescription),
 814                      &change_format, kAudioStreamPropertyPhysicalFormat,
 815                      kAudioObjectPropertyScopeGlobal);
 816     if (ret != VLC_SUCCESS)
 817     {
 818         retValue = false;
 819         goto out;
 820     }
 821
 822     /* The AudioStreamSetProperty is not only asynchronious (requiring the
 823      * locks) it is also not atomic in its behaviour.  Therefore we check 9
 824      * times before we really give up.
 825      */
 826     for (int i = 0; i < 9; i++)
 827     {
 828         /* Callback is not always invoked. So first check if format is already
 829          * set. */
 830         if (i > 0)
 831         {
 832             mtime_t timeout = mdate() + 500000;
 833             if (vlc_cond_timedwait(&w.cond, &w.lock, timeout))
 834                 msg_Dbg(p_aout, "reached timeout");
 835         }
 836
 837         AudioStreamBasicDescription actual_format;
 838         int ret = AO_GET1PROP(i_stream_id, AudioStreamBasicDescription,
 839                               &actual_format,
 840                               kAudioStreamPropertyPhysicalFormat,
 841                               kAudioObjectPropertyScopeGlobal);
 842
 843         if (ret != VLC_SUCCESS)
 844             continue;
 845
 846         msg_Dbg(p_aout, STREAM_FORMAT_MSG("actual format in use: ",
 847                 actual_format));
 848         if (actual_format.mSampleRate == change_format.mSampleRate &&
 849             actual_format.mFormatID == change_format.mFormatID &&
 850             actual_format.mFramesPerPacket == change_format.mFramesPerPacket)
 851         {
 852             /* The right format is now active */
 853             retValue = true;
 854             break;
 855         }
 856
 857         /* We need to check again */
 858     }
 859
 860 out:
 861     vlc_mutex_unlock(&w.lock);
 862
 863     /* Removing the property listener */
 864     ret = AO_UPDATELISTENER(i_stream_id, false, StreamListener, &w,
 865                             kAudioStreamPropertyPhysicalFormat,
 866                             kAudioObjectPropertyScopeGlobal);
 867     if (ret != VLC_SUCCESS)
 868         retValue = false;
 869
 870     vlc_mutex_destroy(&w.lock);
 871     vlc_cond_destroy(&w.cond);
 872
 873     return retValue;
 874 }
 875
 876 #pragma mark -
 877 #pragma mark core interaction
 878
 879 static int
 880 SwitchAudioDevice(audio_output_t *p_aout, const char *name)
 881 {
 882     struct aout_sys_t *p_sys = p_aout->sys;
 883
 884     if (name)
 885         p_sys->i_new_selected_dev = atoi(name);
 886     else
 887         p_sys->i_new_selected_dev = 0;
 888
 889     p_sys->i_new_selected_dev = p_sys->i_new_selected_dev & ~AOUT_VAR_SPDIF_FLAG;
 890
 891     aout_DeviceReport(p_aout, name);
 892     aout_RestartRequest(p_aout, AOUT_RESTART_OUTPUT);
 893
 894     return 0;
 895 }
 896
 897 static int
 898 VolumeSet(audio_output_t * p_aout, float volume)
 899 {
 900     struct aout_sys_t *p_sys = p_aout->sys;
 901     OSStatus ostatus = 0;
 902
 903     if (p_sys->b_digital)
 904         return VLC_EGENERIC;
 905
 906     p_sys->f_volume = volume;
 907     aout_VolumeReport(p_aout, volume);
 908
 909     /* Set volume for output unit */
 910     if (!p_sys->b_mute)
 911     {
 912         ostatus = AudioUnitSetParameter(p_sys->au_unit,
 913                                         kHALOutputParam_Volume,
 914                                         kAudioUnitScope_Global,
 915                                         0,
 916                                         volume * volume * volume,
 917                                         0);
 918     }
 919
 920     if (var_InheritBool(p_aout, "volume-save"))
 921         config_PutInt(p_aout, "auhal-volume",
 922                       lroundf(volume * AOUT_VOLUME_DEFAULT));
 923
 924     return ostatus;
 925 }
 926
 927 static int
 928 MuteSet(audio_output_t * p_aout, bool mute)
 929 {
 930     struct aout_sys_t *p_sys = p_aout->sys;
 931
 932     if(p_sys->b_digital)
 933         return VLC_EGENERIC;
 934
 935     p_sys->b_mute = mute;
 936     aout_MuteReport(p_aout, mute);
 937
 938     float volume = .0;
 939     if (!mute)
 940         volume = p_sys->f_volume;
 941
 942     OSStatus err =
 943         AudioUnitSetParameter(p_sys->au_unit, kHALOutputParam_Volume,
 944                               kAudioUnitScope_Global, 0,
 945                               volume * volume * volume, 0);
 946
 947     return err == noErr ? VLC_SUCCESS : VLC_EGENERIC;
 948 }
 949
 950 #pragma mark -
 951 #pragma mark actual playback
 952
 953 /*
 954  * RenderCallbackSPDIF: callback for SPDIF audio output
 955  */
 956 static OSStatus
 957 RenderCallbackSPDIF(AudioDeviceID inDevice, const AudioTimeStamp * inNow,
 958                     const AudioBufferList * inInputData,
 959                     const AudioTimeStamp * inInputTime,
 960                     AudioBufferList * outOutputData,
 961                     const AudioTimeStamp * inOutputTime, void *p_data)
 962 {
 963     VLC_UNUSED(inNow);
 964     VLC_UNUSED(inDevice);
 965     VLC_UNUSED(inInputData);
 966     VLC_UNUSED(inInputTime);
 967     VLC_UNUSED(inOutputTime);
 968
 969     audio_output_t * p_aout = p_data;
 970     aout_sys_t *p_sys = p_aout->sys;
 971     uint8_t *p_output = outOutputData->mBuffers[p_sys->i_stream_index].mData;
 972     size_t i_size = outOutputData->mBuffers[p_sys->i_stream_index].mDataByteSize;
 973
 974     ca_Render(p_aout, p_output, i_size);
 975
 976     return noErr;
 977 }
 978
 979 #pragma mark -
 980 #pragma mark initialization
 981
 982 /*
 983  * StartAnalog: open and setup a HAL AudioUnit to do PCM audio output
 984  */
 985 static int
 986 StartAnalog(audio_output_t *p_aout, audio_sample_format_t *fmt,
 987             mtime_t i_latency_us)
 988 {
 989     struct aout_sys_t           *p_sys = p_aout->sys;
 990     OSStatus                    err = noErr;
 991     UInt32                      i_param_size;
 992     AudioChannelLayout          *layout = NULL;
 993
 994     if (aout_FormatNbChannels(fmt) == 0)
 995         return VLC_EGENERIC;
 996
 997     p_sys->au_unit = au_NewOutputInstance(p_aout, kAudioUnitSubType_HALOutput);
 998     if (p_sys->au_unit == NULL)
 999         return VLC_EGENERIC;
1000
1001     p_aout->current_sink_info.headphones = AudioDeviceIsAHeadphone(p_aout, p_sys->i_selected_dev);
1002
1003     /* Set the device we will use for this output unit */
1004     err = AudioUnitSetProperty(p_sys->au_unit,
1005                                kAudioOutputUnitProperty_CurrentDevice,
1006                                kAudioUnitScope_Global, 0,
1007                                &p_sys->i_selected_dev, sizeof(AudioObjectID));
1008
1009     if (err != noErr)
1010     {
1011         ca_LogErr("cannot select audio output device, PCM output failed");
1012         goto error;
1013     }
1014
1015     /* Get the channel layout of the device side of the unit (vlc -> unit ->
1016      * device) */
1017     err = AudioUnitGetPropertyInfo(p_sys->au_unit,
1018                                    kAudioDevicePropertyPreferredChannelLayout,
1019                                    kAudioUnitScope_Output, 0, &i_param_size,
1020                                    NULL);
1021     if (err == noErr)
1022     {
1023         layout = (AudioChannelLayout *)malloc(i_param_size);
1024         if (layout == NULL)
1025             goto error;
1026
1027         OSStatus err =
1028             AudioUnitGetProperty(p_sys->au_unit,
1029                                  kAudioDevicePropertyPreferredChannelLayout,
1030                                  kAudioUnitScope_Output, 0, layout,
1031                                  &i_param_size);
1032         if (err != noErr)
1033             goto error;
1034     }
1035     else
1036         ca_LogWarn("device driver does not support "
1037                    "kAudioDevicePropertyPreferredChannelLayout - using stereo");
1038
1039     /* Do the last VLC aout setups */
1040     int ret = au_Initialize(p_aout, p_sys->au_unit, fmt, layout, i_latency_us);
1041     if (ret != VLC_SUCCESS)
1042         goto error;
1043
1044     err = AudioOutputUnitStart(p_sys->au_unit);
1045     if (err != noErr)
1046     {
1047         ca_LogErr("AudioUnitStart failed");
1048         au_Uninitialize(p_aout, p_sys->au_unit);
1049         goto error;
1050     }
1051
1052     /* Set volume for output unit */
1053     VolumeSet(p_aout, p_sys->f_volume);
1054     MuteSet(p_aout, p_sys->b_mute);
1055
1056     free(layout);
1057     return VLC_SUCCESS;
1058 error:
1059     AudioComponentInstanceDispose(p_sys->au_unit);
1060     free(layout);
1061     return VLC_EGENERIC;
1062 }
1063
1064 /*
1065  * StartSPDIF: Setup an encoded digital stream (SPDIF) output
1066  */
1067 static int
1068 StartSPDIF(audio_output_t * p_aout, audio_sample_format_t *fmt,
1069            mtime_t i_latency_us)
1070 {
1071     struct aout_sys_t *p_sys = p_aout->sys;
1072     int ret;
1073
1074     /* Check if device supports digital */
1075     if (!AudioDeviceSupportsDigital(p_aout, p_sys->i_selected_dev))
1076     {
1077         msg_Dbg(p_aout, "Audio device supports PCM mode only");
1078         return VLC_EGENERIC;
1079     }
1080
1081     ret = AO_GET1PROP(p_sys->i_selected_dev, pid_t, &p_sys->i_hog_pid,
1082                       kAudioDevicePropertyHogMode,
1083                       kAudioObjectPropertyScopeOutput);
1084     if (ret != VLC_SUCCESS)
1085     {
1086         /* This is not a fatal error. Some drivers simply don't support this
1087          * property */
1088         p_sys->i_hog_pid = -1;
1089     }
1090
1091     if (p_sys->i_hog_pid != -1 && p_sys->i_hog_pid != getpid())
1092     {
1093         msg_Err(p_aout, "Selected audio device is exclusively in use by another"
1094                 " program.");
1095         vlc_dialog_display_error(p_aout, _("Audio output failed"), "%s",
1096             _("The selected audio output device is exclusively in "
1097             "use by another program."));
1098         return VLC_EGENERIC;
1099     }
1100
1101     AudioStreamBasicDescription desired_stream_format;
1102     memset(&desired_stream_format, 0, sizeof(desired_stream_format));
1103
1104     /* Start doing the SPDIF setup proces */
1105     p_sys->b_digital = true;
1106
1107     /* Hog the device */
1108     p_sys->i_hog_pid = getpid();
1109
1110     /*
1111      * HACK: On 10.6, auhal will trigger the streams changed callback when
1112      * calling below line, directly in the same thread. This call needs to be
1113      * ignored to avoid endless restarting.
1114      */
1115     p_sys->b_ignore_streams_changed_callback = true;
1116     ret = AO_SETPROP(p_sys->i_selected_dev, sizeof(p_sys->i_hog_pid),
1117                      &p_sys->i_hog_pid, kAudioDevicePropertyHogMode,
1118                      kAudioObjectPropertyScopeOutput);
1119     p_sys->b_ignore_streams_changed_callback = false;
1120
1121     if (ret != VLC_SUCCESS)
1122         return ret;
1123
1124     if (AO_HASPROP(p_sys->i_selected_dev, kAudioDevicePropertySupportsMixing,
1125                    kAudioObjectPropertyScopeGlobal))
1126     {
1127         /* Set mixable to false if we are allowed to */
1128         UInt32 b_mix;
1129         bool b_writeable = AO_ISPROPSETTABLE(p_sys->i_selected_dev,
1130                                              kAudioDevicePropertySupportsMixing,
1131                                              kAudioObjectPropertyScopeGlobal);
1132
1133         ret = AO_GET1PROP(p_sys->i_selected_dev, UInt32, &b_mix,
1134                           kAudioDevicePropertySupportsMixing,
1135                           kAudioObjectPropertyScopeGlobal);
1136         if (ret == VLC_SUCCESS && b_writeable)
1137         {
1138             b_mix = 0;
1139             ret = AO_SETPROP(p_sys->i_selected_dev, sizeof(UInt32), &b_mix,
1140                              kAudioDevicePropertySupportsMixing,
1141                              kAudioObjectPropertyScopeGlobal);
1142             p_sys->b_changed_mixing = true;
1143         }
1144
1145         if (ret != VLC_SUCCESS)
1146         {
1147             msg_Err(p_aout, "failed to set mixmode");
1148             return ret;
1149         }
1150     }
1151
1152     /* Get a list of all the streams on this device */
1153     size_t i_streams;
1154     AudioStreamID *p_streams;
1155     ret = AO_GETPROP(p_sys->i_selected_dev, AudioStreamID, &i_streams,
1156                      &p_streams, kAudioDevicePropertyStreams,
1157                      kAudioObjectPropertyScopeOutput);
1158     if (ret != VLC_SUCCESS)
1159         return ret;
1160
1161     for (unsigned i = 0; i < i_streams && p_sys->i_stream_index < 0 ; i++)
1162     {
1163         /* Find a stream with a cac3 stream */
1164         bool b_digital = false;
1165
1166         /* Retrieve all the stream formats supported by each output stream */
1167         size_t i_formats;
1168         AudioStreamRangedDescription *p_format_list;
1169         int ret = AO_GETPROP(p_streams[i], AudioStreamRangedDescription,
1170                              &i_formats, &p_format_list,
1171                              kAudioStreamPropertyAvailablePhysicalFormats,
1172                              kAudioObjectPropertyScopeGlobal);
1173         if (ret != VLC_SUCCESS)
1174             continue;
1175
1176         /* Check if one of the supported formats is a digital format */
1177         for (size_t j = 0; j < i_formats; j++)
1178         {
1179             if (IsAudioFormatDigital(p_format_list[j].mFormat.mFormatID))
1180             {
1181                 b_digital = true;
1182                 break;
1183             }
1184         }
1185
1186         if (b_digital)
1187         {
1188             /* if this stream supports a digital (cac3) format, then go set it.
1189              * */
1190             int i_requested_rate_format = -1;
1191             int i_current_rate_format = -1;
1192             int i_backup_rate_format = -1;
1193
1194             if (!p_sys->b_revert)
1195             {
1196                 /* Retrieve the original format of this stream first if not
1197                  * done so already */
1198                 AudioStreamBasicDescription current_streamformat;
1199                 int ret = AO_GET1PROP(p_streams[i], AudioStreamBasicDescription,
1200                                       &current_streamformat,
1201                                       kAudioStreamPropertyPhysicalFormat,
1202                                       kAudioObjectPropertyScopeGlobal);
1203                 if (ret != VLC_SUCCESS)
1204                     continue;
1205
1206                 /*
1207                  * Only the first found format id is accepted. In case of
1208                  * another id later on, we still use the already saved one.
1209                  * This can happen if the user plugs in a spdif cable while a
1210                  * stream is already playing. Then, auhal already misleadingly
1211                  * reports an ac3 format here whereas the original format
1212                  * should be still pcm.
1213                  */
1214                 if (p_sys->sfmt_revert.mFormatID > 0
1215                  && p_sys->sfmt_revert.mFormatID != current_streamformat.mFormatID
1216                  && p_streams[i] == p_sys->i_stream_id)
1217                 {
1218                     msg_Warn(p_aout, STREAM_FORMAT_MSG("Detected current stream"
1219                              " format: ", current_streamformat));
1220                     msg_Warn(p_aout, "... there is another stream format "
1221                              "already stored, the current one is ignored");
1222                 }
1223                 else
1224                     p_sys->sfmt_revert = current_streamformat;
1225
1226                 p_sys->b_revert = true;
1227             }
1228
1229             p_sys->i_stream_id = p_streams[i];
1230             p_sys->i_stream_index = i;
1231
1232             for (size_t j = 0; j < i_formats; j++)
1233             {
1234                 if (IsAudioFormatDigital(p_format_list[j].mFormat.mFormatID))
1235                 {
1236                     if (p_format_list[j].mFormat.mSampleRate == fmt->i_rate)
1237                     {
1238                         i_requested_rate_format = j;
1239                         break;
1240                     }
1241                     else if (p_format_list[j].mFormat.mSampleRate ==
1242                              p_sys->sfmt_revert.mSampleRate)
1243                         i_current_rate_format = j;
1244                     else
1245                     {
1246                         if (i_backup_rate_format < 0
1247                          || p_format_list[j].mFormat.mSampleRate >
1248                             p_format_list[i_backup_rate_format].mFormat.mSampleRate)
1249                             i_backup_rate_format = j;
1250                     }
1251                 }
1252
1253             }
1254
1255             if (i_requested_rate_format >= 0)
1256             {
1257                 /* We prefer to output at the samplerate of the original audio */
1258                 desired_stream_format =
1259                     p_format_list[i_requested_rate_format].mFormat;
1260             }
1261             else if (i_current_rate_format >= 0)
1262             {
1263                 /* If not possible, we will try to use the current samplerate
1264                  * of the device */
1265                 desired_stream_format =
1266                     p_format_list[i_current_rate_format].mFormat;
1267             }
1268             else
1269             {
1270                 /* And if we have to, any digital format will be just fine
1271                  * (highest rate possible) */
1272                 desired_stream_format =
1273                     p_format_list[i_backup_rate_format].mFormat;
1274             }
1275         }
1276         free(p_format_list);
1277     }
1278     free(p_streams);
1279
1280     msg_Dbg(p_aout, STREAM_FORMAT_MSG("original stream format: ",
1281             p_sys->sfmt_revert));
1282
1283     if (!AudioStreamChangeFormat(p_aout, p_sys->i_stream_id, desired_stream_format))
1284     {
1285         msg_Err(p_aout, "failed to change stream format for SPDIF output");
1286         return VLC_EGENERIC;
1287     }
1288
1289     /* Set the format flags */
1290     if (desired_stream_format.mFormatFlags & kAudioFormatFlagIsBigEndian)
1291         fmt->i_format = VLC_CODEC_SPDIFB;
1292     else
1293         fmt->i_format = VLC_CODEC_SPDIFL;
1294     fmt->i_bytes_per_frame = AOUT_SPDIF_SIZE;
1295     fmt->i_frame_length = A52_FRAME_NB;
1296     fmt->i_rate = (unsigned int)desired_stream_format.mSampleRate;
1297     aout_FormatPrepare(fmt);
1298
1299     /* Add IOProc callback */
1300     OSStatus err =
1301         AudioDeviceCreateIOProcID(p_sys->i_selected_dev,
1302                                   RenderCallbackSPDIF,
1303                                   p_aout, &p_sys->i_procID);
1304     if (err != noErr)
1305     {
1306         ca_LogErr("Failed to create Process ID");
1307         return VLC_EGENERIC;
1308     }
1309
1310     ret = ca_Initialize(p_aout, fmt, i_latency_us);
1311     if (ret != VLC_SUCCESS)
1312     {
1313         AudioDeviceDestroyIOProcID(p_sys->i_selected_dev, p_sys->i_procID);
1314         return VLC_EGENERIC;
1315     }
1316
1317     /* Start device */
1318     err = AudioDeviceStart(p_sys->i_selected_dev, p_sys->i_procID);
1319     if (err != noErr)
1320     {
1321         ca_LogErr("Failed to start audio device");
1322
1323         err = AudioDeviceDestroyIOProcID(p_sys->i_selected_dev, p_sys->i_procID);
1324         if (err != noErr)
1325             ca_LogErr("Failed to destroy process ID");
1326
1327         return VLC_EGENERIC;
1328     }
1329
1330     msg_Dbg(p_aout, "Using audio device for digital output");
1331     return VLC_SUCCESS;
1332 }
1333
1334 static void
1335 Stop(audio_output_t *p_aout)
1336 {
1337     struct aout_sys_t   *p_sys = p_aout->sys;
1338     OSStatus            err = noErr;
1339
1340     msg_Dbg(p_aout, "Stopping the auhal module");
1341
1342     if (p_sys->au_unit)
1343     {
1344         AudioOutputUnitStop(p_sys->au_unit);
1345         au_Uninitialize(p_aout, p_sys->au_unit);
1346         AudioComponentInstanceDispose(p_sys->au_unit);
1347     }
1348     else
1349     {
1350         assert(p_sys->b_digital);
1351
1352         /* Stop device */
1353         err = AudioDeviceStop(p_sys->i_selected_dev,
1354                                p_sys->i_procID);
1355         if (err != noErr)
1356             ca_LogErr("AudioDeviceStop failed");
1357
1358         /* Remove IOProc callback */
1359         err = AudioDeviceDestroyIOProcID(p_sys->i_selected_dev,
1360                                           p_sys->i_procID);
1361         if (err != noErr)
1362             ca_LogErr("Failed to destroy Process ID");
1363
1364         if (p_sys->b_revert
1365          && !AudioStreamChangeFormat(p_aout, p_sys->i_stream_id, p_sys->sfmt_revert))
1366             msg_Err(p_aout, "failed to revert stream format in close");
1367
1368         if (p_sys->b_changed_mixing
1369          && p_sys->sfmt_revert.mFormatID != kAudioFormat60958AC3)
1370         {
1371             UInt32 b_mix;
1372             /* Revert mixable to true if we are allowed to */
1373             bool b_writeable =
1374                 AO_ISPROPSETTABLE(p_sys->i_selected_dev,
1375                                   kAudioDevicePropertySupportsMixing,
1376                                   kAudioObjectPropertyScopeGlobal);
1377             int ret = AO_GET1PROP(p_sys->i_selected_dev, UInt32, &b_mix,
1378                                   kAudioDevicePropertySupportsMixing,
1379                                   kAudioObjectPropertyScopeOutput);
1380             if (ret == VLC_SUCCESS && b_writeable)
1381             {
1382                 msg_Dbg(p_aout, "mixable is: %d", b_mix);
1383                 b_mix = 1;
1384                 ret = AO_SETPROP(p_sys->i_selected_dev,
1385                                  sizeof(UInt32), &b_mix,
1386                                  kAudioDevicePropertySupportsMixing,
1387                                  kAudioObjectPropertyScopeOutput);
1388             }
1389
1390             if (ret != VLC_SUCCESS)
1391                 msg_Err(p_aout, "failed to re-set mixmode");
1392         }
1393         ca_Uninitialize(p_aout);
1394
1395         if (p_sys->i_hog_pid == getpid())
1396         {
1397             p_sys->i_hog_pid = -1;
1398
1399             /*
1400              * HACK: On 10.6, auhal will trigger the streams changed callback
1401              * when calling below line, directly in the same thread. This call
1402              * needs to be ignored to avoid endless restarting.
1403              */
1404             p_sys->b_ignore_streams_changed_callback = true;
1405             AO_SETPROP(p_sys->i_selected_dev, sizeof(p_sys->i_hog_pid),
1406                        &p_sys->i_hog_pid, kAudioDevicePropertyHogMode,
1407                        kAudioObjectPropertyScopeOutput);
1408             p_sys->b_ignore_streams_changed_callback = false;
1409         }
1410
1411         p_sys->b_digital = false;
1412     }
1413
1414     /* remove audio device alive callback */
1415     AO_UPDATELISTENER(p_sys->i_selected_dev, false, DeviceAliveListener, p_aout,
1416                       kAudioDevicePropertyDeviceIsAlive,
1417                       kAudioObjectPropertyScopeGlobal);
1418 }
1419
1420 static int
1421 Start(audio_output_t *p_aout, audio_sample_format_t *restrict fmt)
1422 {
1423     UInt32                  i_param_size = 0;
1424     struct aout_sys_t       *p_sys = NULL;
1425
1426     /* Use int here, to match kAudioDevicePropertyDeviceIsAlive
1427      * property size */
1428     int                     b_alive = false;
1429
1430     if (AOUT_FMT_HDMI(fmt))
1431         return VLC_EGENERIC;
1432
1433     p_sys = p_aout->sys;
1434     p_sys->b_digital = false;
1435     p_sys->au_unit = NULL;
1436     p_sys->i_stream_index = -1;
1437     p_sys->b_revert = false;
1438     p_sys->b_changed_mixing = false;
1439
1440     vlc_mutex_lock(&p_sys->selected_device_lock);
1441     p_sys->i_selected_dev = p_sys->i_new_selected_dev;
1442
1443     aout_FormatPrint(p_aout, "VLC is looking for:", fmt);
1444
1445     msg_Dbg(p_aout, "attempting to use device %i", p_sys->i_selected_dev);
1446
1447     if (p_sys->i_selected_dev > 0)
1448     {
1449         /* Check if device is in devices list. Only checking for
1450          * kAudioDevicePropertyDeviceIsAlive is not sufficient, as a former
1451          * airplay device might be already gone, but the device number might be
1452          * still valid. Core Audio even says that this device would be alive.
1453          * Don't ask why, its Core Audio. */
1454         CFIndex count = CFArrayGetCount(p_sys->device_list);
1455         CFNumberRef deviceNumber =
1456             CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type,
1457                            &p_sys->i_selected_dev);
1458         if (CFArrayContainsValue(p_sys->device_list,
1459                                  CFRangeMake(0, count), deviceNumber))
1460         {
1461             /* Check if the desired device is alive and usable */
1462             i_param_size = sizeof(b_alive);
1463             int ret = AO_GET1PROP(p_sys->i_selected_dev, int, &b_alive,
1464                                   kAudioDevicePropertyDeviceIsAlive,
1465                                   kAudioObjectPropertyScopeGlobal);
1466             if (ret != VLC_SUCCESS)
1467                 b_alive = false; /* Be tolerant */
1468
1469             if (!b_alive)
1470                 msg_Warn(p_aout, "selected audio device is not alive, switching"
1471                          " to default device");
1472
1473         }
1474         else
1475         {
1476             msg_Warn(p_aout, "device id %i not found in the current devices "
1477                      "list, fallback to default device", p_sys->i_selected_dev);
1478         }
1479         CFRelease(deviceNumber);
1480     }
1481
1482     p_sys->b_selected_dev_is_default = false;
1483     if (!b_alive || p_sys->i_selected_dev == 0)
1484     {
1485         p_sys->b_selected_dev_is_default = true;
1486
1487         AudioObjectID defaultDeviceID = 0;
1488         int ret = AO_GET1PROP(kAudioObjectSystemObject, AudioObjectID,
1489                               &defaultDeviceID,
1490                               kAudioHardwarePropertyDefaultOutputDevice,
1491                               kAudioObjectPropertyScopeOutput);
1492         if (ret != VLC_SUCCESS)
1493         {
1494             vlc_mutex_unlock(&p_sys->selected_device_lock);
1495             return VLC_EGENERIC;
1496         }
1497         else
1498             msg_Dbg(p_aout, "using default audio device %i", defaultDeviceID);
1499
1500         p_sys->i_selected_dev = defaultDeviceID;
1501     }
1502     vlc_mutex_unlock(&p_sys->selected_device_lock);
1503
1504     /* add a callback to see if the device dies later on */
1505     AO_UPDATELISTENER(p_sys->i_selected_dev, true, DeviceAliveListener, p_aout,
1506                       kAudioDevicePropertyDeviceIsAlive,
1507                       kAudioObjectPropertyScopeGlobal);
1508
1509     /* get device latency */
1510     UInt32 i_latency_samples;
1511     AO_GET1PROP(p_sys->i_selected_dev, UInt32, &i_latency_samples,
1512                 kAudioDevicePropertyLatency, kAudioObjectPropertyScopeOutput);
1513     mtime_t i_latency_us = i_latency_samples * CLOCK_FREQ / fmt->i_rate;
1514
1515     /* Check for Digital mode or Analog output mode */
1516     if (AOUT_FMT_SPDIF (fmt))
1517     {
1518         if (StartSPDIF (p_aout, fmt, i_latency_us) == VLC_SUCCESS)
1519         {
1520             msg_Dbg(p_aout, "digital output successfully opened");
1521             return VLC_SUCCESS;
1522         }
1523     }
1524     else
1525     {
1526         if (StartAnalog(p_aout, fmt, i_latency_us) == VLC_SUCCESS)
1527         {
1528             msg_Dbg(p_aout, "analog output successfully opened");
1529             fmt->channel_type = AUDIO_CHANNEL_TYPE_BITMAP;
1530             return VLC_SUCCESS;
1531         }
1532     }
1533
1534     msg_Err(p_aout, "opening auhal output failed");
1535     AO_UPDATELISTENER(p_sys->i_selected_dev, false, DeviceAliveListener, p_aout,
1536                       kAudioDevicePropertyDeviceIsAlive,
1537                       kAudioObjectPropertyScopeGlobal);
1538     return VLC_EGENERIC;
1539 }
1540
1541 static void Close(vlc_object_t *obj)
1542 {
1543     audio_output_t *p_aout = (audio_output_t *)obj;
1544     aout_sys_t *p_sys = p_aout->sys;
1545
1546     /* remove audio devices callback */
1547     AO_UPDATELISTENER(kAudioObjectSystemObject, false, DevicesListener, p_aout,
1548                       kAudioHardwarePropertyDevices,
1549                       kAudioObjectPropertyScopeGlobal);
1550
1551     /* remove listener to be notified about changes in default audio device */
1552     AO_UPDATELISTENER(kAudioObjectSystemObject, false,
1553                       DefaultDeviceChangedListener, p_aout,
1554                       kAudioHardwarePropertyDefaultOutputDevice,
1555                       kAudioObjectPropertyScopeGlobal);
1556
1557     /*
1558      * StreamsChangedListener can rebuild the device list and thus held the
1559      * device_list_lock.  To avoid a possible deadlock, an array copy is
1560      * created here.  In rare cases, this can lead to missing
1561      * StreamsChangedListener callback deregistration (TODO).
1562      */
1563     vlc_mutex_lock(&p_sys->device_list_lock);
1564     CFArrayRef device_list_cpy = CFArrayCreateCopy(NULL, p_sys->device_list);
1565     vlc_mutex_unlock(&p_sys->device_list_lock);
1566
1567     /* remove streams callbacks */
1568     CFIndex count = CFArrayGetCount(device_list_cpy);
1569     if (count > 0)
1570     {
1571         for (CFIndex x = 0; x < count; x++)
1572         {
1573             AudioDeviceID deviceId = 0;
1574             CFNumberRef cfn_device_id =
1575                 CFArrayGetValueAtIndex(device_list_cpy, x);
1576             if (!cfn_device_id)
1577                 continue;
1578
1579             CFNumberGetValue(cfn_device_id, kCFNumberSInt32Type, &deviceId);
1580             if (!(deviceId & AOUT_VAR_SPDIF_FLAG))
1581                 ManageAudioStreamsCallback(p_aout, deviceId, false);
1582         }
1583     }
1584
1585     CFRelease(device_list_cpy);
1586     CFRelease(p_sys->device_list);
1587
1588     char *psz_device = aout_DeviceGet(p_aout);
1589     config_PutPsz(p_aout, "auhal-audio-device", psz_device);
1590     free(psz_device);
1591
1592     vlc_mutex_destroy(&p_sys->selected_device_lock);
1593     vlc_mutex_destroy(&p_sys->device_list_lock);
1594
1595     ca_Close(p_aout);
1596     free(p_sys);
1597 }
1598
1599 static int Open(vlc_object_t *obj)
1600 {
1601     audio_output_t *p_aout = (audio_output_t *)obj;
1602     aout_sys_t *p_sys = calloc(1, sizeof (*p_sys));
1603     if (unlikely(p_sys == NULL))
1604         return VLC_ENOMEM;
1605
1606     vlc_mutex_init(&p_sys->device_list_lock);
1607     vlc_mutex_init(&p_sys->selected_device_lock);
1608     p_sys->b_digital = false;
1609     p_sys->b_ignore_streams_changed_callback = false;
1610     p_sys->b_selected_dev_is_default = false;
1611     memset(&p_sys->sfmt_revert, 0, sizeof(p_sys->sfmt_revert));
1612     p_sys->i_stream_id = 0;
1613
1614     p_aout->sys = p_sys;
1615     p_aout->start = Start;
1616     p_aout->stop = Stop;
1617     p_aout->volume_set = VolumeSet;
1618     p_aout->mute_set = MuteSet;
1619     p_aout->device_select = SwitchAudioDevice;
1620     p_sys->device_list = CFArrayCreate(kCFAllocatorDefault, NULL, 0, NULL);
1621
1622     /*
1623      * Force an own run loop for callbacks.
1624      *
1625      * According to rtaudio, this is absolutely necessary since 10.6 to get
1626      * correct notifications.  It might fix issues when using the module as a
1627      * library where a proper loop is not setup already.
1628      */
1629     CFRunLoopRef theRunLoop = NULL;
1630     AO_SETPROP(kAudioObjectSystemObject, sizeof(CFRunLoopRef),
1631                &theRunLoop, kAudioHardwarePropertyRunLoop,
1632                kAudioObjectPropertyScopeGlobal);
1633
1634     /* Attach a listener so that we are notified of a change in the device
1635      * setup */
1636     AO_UPDATELISTENER(kAudioObjectSystemObject, true, DevicesListener, p_aout,
1637                       kAudioHardwarePropertyDevices,
1638                       kAudioObjectPropertyScopeGlobal);
1639
1640     /* Attach a listener to be notified about changes in default audio device */
1641     AO_UPDATELISTENER(kAudioObjectSystemObject, true,
1642                       DefaultDeviceChangedListener, p_aout,
1643                       kAudioHardwarePropertyDefaultOutputDevice,
1644                       kAudioObjectPropertyScopeGlobal);
1645
1646     RebuildDeviceList(p_aout);
1647
1648     /* remember the volume */
1649     p_sys->f_volume = var_InheritInteger(p_aout, "auhal-volume")
1650                     / (float)AOUT_VOLUME_DEFAULT;
1651     aout_VolumeReport(p_aout, p_sys->f_volume);
1652     p_sys->b_mute = var_InheritBool(p_aout, "mute");
1653     aout_MuteReport(p_aout, p_sys->b_mute);
1654
1655     char *psz_audio_device = var_InheritString(p_aout, "auhal-audio-device");
1656     SwitchAudioDevice(p_aout, psz_audio_device);
1657     free(psz_audio_device);
1658
1659     ca_Open(p_aout);
1660     return VLC_SUCCESS;
1661 }