git.sesse.net Git - vlc/blob - modules/audio_output/auhal.c

   1 /*****************************************************************************
   2  * auhal.c: AUHAL and Coreaudio output plugin
   3  *****************************************************************************
   4  * Copyright (C) 2005 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Derk-Jan Hartman <hartman at videolan dot org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27 #ifdef HAVE_CONFIG_H
  28 # include "config.h"
  29 #endif
  30
  31 #include <unistd.h>
  32
  33 #include <vlc_common.h>
  34 #include <vlc_plugin.h>
  35 #include <vlc_dialog.h>
  36 #include <vlc_aout.h>
  37
  38 // By pass part of header which compile with some warnings,
  39 // and that we don't require.
  40 #define __MACHINEEXCEPTIONS__
  41
  42 #include <CoreAudio/CoreAudio.h>
  43 #include <AudioUnit/AudioUnitProperties.h>
  44 #include <AudioUnit/AudioUnitParameters.h>
  45 #include <AudioUnit/AudioOutputUnit.h>
  46 #include <AudioToolbox/AudioFormat.h>
  47
  48 #define STREAM_FORMAT_MSG( pre, sfm ) \
  49     pre "[%ld][%4.4s][%ld][%ld][%ld][%ld][%ld][%ld]", \
  50     (UInt32)sfm.mSampleRate, (char *)&sfm.mFormatID, \
  51     sfm.mFormatFlags, sfm.mBytesPerPacket, \
  52     sfm.mFramesPerPacket, sfm.mBytesPerFrame, \
  53     sfm.mChannelsPerFrame, sfm.mBitsPerChannel
  54
  55 #define STREAM_FORMAT_MSG_FULL( pre, sfm ) \
  56     pre ":\nsamplerate: [%ld]\nFormatID: [%4.4s]\nFormatFlags: [%ld]\nBypesPerPacket: [%ld]\nFramesPerPacket: [%ld]\nBytesPerFrame: [%ld]\nChannelsPerFrame: [%ld]\nBitsPerChannel[%ld]", \
  57     (UInt32)sfm.mSampleRate, (char *)&sfm.mFormatID, \
  58     sfm.mFormatFlags, sfm.mBytesPerPacket, \
  59     sfm.mFramesPerPacket, sfm.mBytesPerFrame, \
  60     sfm.mChannelsPerFrame, sfm.mBitsPerChannel
  61
  62 #define BUFSIZE 0xffffff
  63 #define AOUT_VAR_SPDIF_FLAG 0xf00000
  64
  65 /*
  66  * TODO:
  67  * - clean up the debug info
  68  * - clean up C99'isms
  69  * - be better at changing stream setup or devices setup changes while playing.
  70  * - fix 6.1 and 7.1
  71  */
  72
  73 /*****************************************************************************
  74  * aout_sys_t: private audio output method descriptor
  75  *****************************************************************************
  76  * This structure is part of the audio output thread descriptor.
  77  * It describes the CoreAudio specific properties of an output thread.
  78  *****************************************************************************/
  79 struct aout_sys_t
  80 {
  81     AudioDeviceID               i_default_dev;  /* Keeps DeviceID of defaultOutputDevice */
  82     AudioDeviceID               i_selected_dev; /* Keeps DeviceID of the selected device */
  83     UInt32                      i_devices;      /* Number of CoreAudio Devices */
  84     bool                  b_supports_digital;/* Does the currently selected device support digital mode? */
  85     bool                  b_digital;      /* Are we running in digital mode? */
  86     mtime_t                     clock_diff;     /* Difference between VLC clock and Device clock */
  87
  88     /* AUHAL specific */
  89     Component                   au_component;   /* The Audiocomponent we use */
  90     AudioUnit                   au_unit;        /* The AudioUnit we use */
  91     uint8_t                     p_remainder_buffer[BUFSIZE];
  92     uint32_t                    i_read_bytes;
  93     uint32_t                    i_total_bytes;
  94
  95     /* CoreAudio SPDIF mode specific */
  96     pid_t                       i_hog_pid;      /* The keep the pid of our hog status */
  97     AudioStreamID               i_stream_id;    /* The StreamID that has a cac3 streamformat */
  98     int                         i_stream_index; /* The index of i_stream_id in an AudioBufferList */
  99     AudioStreamBasicDescription stream_format;  /* The format we changed the stream to */
 100     AudioStreamBasicDescription sfmt_revert;    /* The original format of the stream */
 101     bool                  b_revert;       /* Wether we need to revert the stream format */
 102     bool                  b_changed_mixing;/* Wether we need to set the mixing mode back */
 103 };
 104
 105 /*****************************************************************************
 106  * Local prototypes.
 107  *****************************************************************************/
 108 static int      Open                    ( vlc_object_t * );
 109 static int      OpenAnalog              ( aout_instance_t * );
 110 static int      OpenSPDIF               ( aout_instance_t * );
 111 static void     Close                   ( vlc_object_t * );
 112
 113 static void     Play                    ( aout_instance_t * );
 114 static void     Probe                   ( aout_instance_t * );
 115
 116 static int      AudioDeviceHasOutput    ( AudioDeviceID );
 117 static int      AudioDeviceSupportsDigital( aout_instance_t *, AudioDeviceID );
 118 static int      AudioStreamSupportsDigital( aout_instance_t *, AudioStreamID );
 119 static int      AudioStreamChangeFormat ( aout_instance_t *, AudioStreamID, AudioStreamBasicDescription );
 120
 121 static OSStatus RenderCallbackAnalog    ( vlc_object_t *, AudioUnitRenderActionFlags *, const AudioTimeStamp *,
 122                                           unsigned int, unsigned int, AudioBufferList *);
 123 static OSStatus RenderCallbackSPDIF     ( AudioDeviceID, const AudioTimeStamp *, const void *, const AudioTimeStamp *,
 124                                           AudioBufferList *, const AudioTimeStamp *, void * );
 125 static OSStatus HardwareListener        ( AudioHardwarePropertyID, void *);
 126 static OSStatus StreamListener          ( AudioStreamID, UInt32,
 127                                           AudioDevicePropertyID, void * );
 128 static int      AudioDeviceCallback     ( vlc_object_t *, const char *,
 129                                           vlc_value_t, vlc_value_t, void * );
 130
 131
 132 /*****************************************************************************
 133  * Module descriptor
 134  *****************************************************************************/
 135 #define ADEV_TEXT N_("Audio Device")
 136 #define ADEV_LONGTEXT N_("Choose a number corresponding to the number of an " \
 137     "audio device, as listed in your 'Audio Device' menu. This device will " \
 138     "then be used by default for audio playback.")
 139
 140 vlc_module_begin ()
 141     set_shortname( "auhal" )
 142     set_description( N_("HAL AudioUnit output") )
 143     set_capability( "audio output", 101 )
 144     set_category( CAT_AUDIO )
 145     set_subcategory( SUBCAT_AUDIO_AOUT )
 146     set_callbacks( Open, Close )
 147     add_integer( "macosx-audio-device", 0, NULL, ADEV_TEXT, ADEV_LONGTEXT, false )
 148 vlc_module_end ()
 149
 150 /*****************************************************************************
 151  * Open: open macosx audio output
 152  *****************************************************************************/
 153 static int Open( vlc_object_t * p_this )
 154 {
 155     OSStatus                err = noErr;
 156     UInt32                  i_param_size = 0;
 157     struct aout_sys_t       *p_sys = NULL;
 158     vlc_value_t             val;
 159     aout_instance_t         *p_aout = (aout_instance_t *)p_this;
 160
 161     /* Use int here, to match kAudioDevicePropertyDeviceIsAlive
 162      * property size */
 163     int                     b_alive = false;
 164
 165     /* Allocate structure */
 166     p_aout->output.p_sys = malloc( sizeof( aout_sys_t ) );
 167     if( p_aout->output.p_sys == NULL )
 168         return VLC_ENOMEM;
 169
 170     p_sys = p_aout->output.p_sys;
 171     p_sys->i_default_dev = 0;
 172     p_sys->i_selected_dev = 0;
 173     p_sys->i_devices = 0;
 174     p_sys->b_supports_digital = false;
 175     p_sys->b_digital = false;
 176     p_sys->au_component = NULL;
 177     p_sys->au_unit = NULL;
 178     p_sys->clock_diff = (mtime_t) 0;
 179     p_sys->i_read_bytes = 0;
 180     p_sys->i_total_bytes = 0;
 181     p_sys->i_hog_pid = -1;
 182     p_sys->i_stream_id = 0;
 183     p_sys->i_stream_index = -1;
 184     p_sys->b_revert = false;
 185     p_sys->b_changed_mixing = false;
 186     memset( p_sys->p_remainder_buffer, 0, sizeof(uint8_t) * BUFSIZE );
 187
 188     p_aout->output.pf_play = Play;
 189
 190     aout_FormatPrint( p_aout, "VLC is looking for:", (audio_sample_format_t *)&p_aout->output.output );
 191
 192     /* Persistent device variable */
 193     if( var_Type( p_aout->p_libvlc, "macosx-audio-device" ) == 0 )
 194     {
 195         var_Create( p_aout->p_libvlc, "macosx-audio-device", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 196     }
 197
 198     /* Build a list of devices */
 199     if( var_Type( p_aout, "audio-device" ) == 0 )
 200     {
 201         Probe( p_aout );
 202     }
 203
 204     /* What device do we want? */
 205     if( var_Get( p_aout, "audio-device", &val ) < 0 )
 206     {
 207         msg_Err( p_aout, "audio-device var does not exist. device probe failed." );
 208         goto error;
 209     }
 210
 211     p_sys->i_selected_dev = val.i_int & ~AOUT_VAR_SPDIF_FLAG; /* remove SPDIF flag to get the true DeviceID */
 212     p_sys->b_supports_digital = ( val.i_int & AOUT_VAR_SPDIF_FLAG ) ? true : false;
 213
 214     /* Check if the desired device is alive and usable */
 215     /* TODO: add a callback to the device to alert us if the device dies */
 216     i_param_size = sizeof( b_alive );
 217     err = AudioDeviceGetProperty( p_sys->i_selected_dev, 0, FALSE,
 218                                   kAudioDevicePropertyDeviceIsAlive,
 219                                   &i_param_size, &b_alive );
 220
 221     if( err != noErr )
 222     {
 223         /* Be tolerant, only give a warning here */
 224         msg_Warn( p_aout, "could not check whether device [0x%x] is alive: %4.4s", (unsigned int)p_sys->i_selected_dev, (char *)&err );
 225         b_alive = false;
 226     }
 227
 228     if( b_alive == false )
 229     {
 230         msg_Warn( p_aout, "selected audio device is not alive, switching to default device" );
 231         p_sys->i_selected_dev = p_sys->i_default_dev;
 232     }
 233
 234     i_param_size = sizeof( p_sys->i_hog_pid );
 235     err = AudioDeviceGetProperty( p_sys->i_selected_dev, 0, FALSE,
 236                                   kAudioDevicePropertyHogMode,
 237                                   &i_param_size, &p_sys->i_hog_pid );
 238
 239     if( err != noErr )
 240     {
 241         /* This is not a fatal error. Some drivers simply don't support this property */
 242         msg_Warn( p_aout, "could not check whether device is hogged: %4.4s",
 243                  (char *)&err );
 244         p_sys->i_hog_pid = -1;
 245     }
 246
 247     if( p_sys->i_hog_pid != -1 && p_sys->i_hog_pid != getpid() )
 248     {
 249         msg_Err( p_aout, "Selected audio device is exclusively in use by another program." );
 250         dialog_Fatal( p_aout, _("Audio output failed"), "%s",
 251                         _("The selected audio output device is exclusively in "
 252                           "use by another program.") );
 253         goto error;
 254     }
 255
 256     /* Check for Digital mode or Analog output mode */
 257     if( AOUT_FMT_NON_LINEAR( &p_aout->output.output ) && p_sys->b_supports_digital )
 258     {
 259         if( OpenSPDIF( p_aout ) )
 260             return VLC_SUCCESS;
 261     }
 262     else
 263     {
 264         if( OpenAnalog( p_aout ) )
 265             return VLC_SUCCESS;
 266     }
 267
 268 error:
 269     /* If we reach this, this aout has failed */
 270     var_Destroy( p_aout, "audio-device" );
 271     free( p_sys );
 272     return VLC_EGENERIC;
 273 }
 274
 275 /*****************************************************************************
 276  * Open: open and setup a HAL AudioUnit to do analog (multichannel) audio output
 277  *****************************************************************************/
 278 static int OpenAnalog( aout_instance_t *p_aout )
 279 {
 280     struct aout_sys_t           *p_sys = p_aout->output.p_sys;
 281     OSStatus                    err = noErr;
 282     UInt32                      i_param_size = 0, i = 0;
 283     int                         i_original;
 284     ComponentDescription        desc;
 285     AudioStreamBasicDescription DeviceFormat;
 286     AudioChannelLayout          *layout;
 287     AudioChannelLayout          new_layout;
 288     AURenderCallbackStruct      input;
 289
 290     /* Lets go find our Component */
 291     desc.componentType = kAudioUnitType_Output;
 292     desc.componentSubType = kAudioUnitSubType_HALOutput;
 293     desc.componentManufacturer = kAudioUnitManufacturer_Apple;
 294     desc.componentFlags = 0;
 295     desc.componentFlagsMask = 0;
 296
 297     p_sys->au_component = FindNextComponent( NULL, &desc );
 298     if( p_sys->au_component == NULL )
 299     {
 300         msg_Warn( p_aout, "we cannot find our HAL component" );
 301         return false;
 302     }
 303
 304     err = OpenAComponent( p_sys->au_component, &p_sys->au_unit );
 305     if( err != noErr )
 306     {
 307         msg_Warn( p_aout, "we cannot open our HAL component" );
 308         return false;
 309     }
 310
 311     /* Set the device we will use for this output unit */
 312     err = AudioUnitSetProperty( p_sys->au_unit,
 313                          kAudioOutputUnitProperty_CurrentDevice,
 314                          kAudioUnitScope_Global,
 315                          0,
 316                          &p_sys->i_selected_dev,
 317                          sizeof( AudioDeviceID ));
 318
 319     if( err != noErr )
 320     {
 321         msg_Warn( p_aout, "we cannot select the audio device" );
 322         return false;
 323     }
 324
 325     /* Get the current format */
 326     i_param_size = sizeof(AudioStreamBasicDescription);
 327
 328     err = AudioUnitGetProperty( p_sys->au_unit,
 329                                    kAudioUnitProperty_StreamFormat,
 330                                    kAudioUnitScope_Input,
 331                                    0,
 332                                    &DeviceFormat,
 333                                    &i_param_size );
 334
 335     if( err != noErr ) return false;
 336     else msg_Dbg( p_aout, STREAM_FORMAT_MSG( "current format is: ", DeviceFormat ) );
 337
 338     /* Get the channel layout of the device side of the unit (vlc -> unit -> device) */
 339     err = AudioUnitGetPropertyInfo( p_sys->au_unit,
 340                                    kAudioDevicePropertyPreferredChannelLayout,
 341                                    kAudioUnitScope_Output,
 342                                    0,
 343                                    &i_param_size,
 344                                    NULL );
 345
 346     if( err == noErr )
 347     {
 348         layout = (AudioChannelLayout *)malloc( i_param_size);
 349
 350         verify_noerr( AudioUnitGetProperty( p_sys->au_unit,
 351                                        kAudioDevicePropertyPreferredChannelLayout,
 352                                        kAudioUnitScope_Output,
 353                                        0,
 354                                        layout,
 355                                        &i_param_size ));
 356
 357         /* We need to "fill out" the ChannelLayout, because there are multiple ways that it can be set */
 358         if( layout->mChannelLayoutTag == kAudioChannelLayoutTag_UseChannelBitmap)
 359         {
 360             /* bitmap defined channellayout */
 361             verify_noerr( AudioFormatGetProperty( kAudioFormatProperty_ChannelLayoutForBitmap,
 362                                     sizeof( UInt32), &layout->mChannelBitmap,
 363                                     &i_param_size,
 364                                     layout ));
 365         }
 366         else if( layout->mChannelLayoutTag != kAudioChannelLayoutTag_UseChannelDescriptions )
 367         {
 368             /* layouttags defined channellayout */
 369             verify_noerr( AudioFormatGetProperty( kAudioFormatProperty_ChannelLayoutForTag,
 370                                     sizeof( AudioChannelLayoutTag ), &layout->mChannelLayoutTag,
 371                                     &i_param_size,
 372                                     layout ));
 373         }
 374
 375         msg_Dbg( p_aout, "layout of AUHAL has %d channels" , (int)layout->mNumberChannelDescriptions );
 376
 377         /* Initialize the VLC core channel count */
 378         p_aout->output.output.i_physical_channels = 0;
 379         i_original = p_aout->output.output.i_original_channels & AOUT_CHAN_PHYSMASK;
 380
 381         if( i_original == AOUT_CHAN_CENTER || layout->mNumberChannelDescriptions < 2 )
 382         {
 383             /* We only need Mono or cannot output more than 1 channel */
 384             p_aout->output.output.i_physical_channels = AOUT_CHAN_CENTER;
 385         }
 386         else if( i_original == (AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT) || layout->mNumberChannelDescriptions < 3 )
 387         {
 388             /* We only need Stereo or cannot output more than 2 channels */
 389             p_aout->output.output.i_physical_channels = AOUT_CHAN_RIGHT | AOUT_CHAN_LEFT;
 390         }
 391         else
 392         {
 393             /* We want more than stereo and we can do that */
 394             for( i = 0; i < layout->mNumberChannelDescriptions; i++ )
 395             {
 396                 msg_Dbg( p_aout, "this is channel: %d", (int)layout->mChannelDescriptions[i].mChannelLabel );
 397
 398                 switch( layout->mChannelDescriptions[i].mChannelLabel )
 399                 {
 400                     case kAudioChannelLabel_Left:
 401                         p_aout->output.output.i_physical_channels |= AOUT_CHAN_LEFT;
 402                         continue;
 403                     case kAudioChannelLabel_Right:
 404                         p_aout->output.output.i_physical_channels |= AOUT_CHAN_RIGHT;
 405                         continue;
 406                     case kAudioChannelLabel_Center:
 407                         p_aout->output.output.i_physical_channels |= AOUT_CHAN_CENTER;
 408                         continue;
 409                     case kAudioChannelLabel_LFEScreen:
 410                         p_aout->output.output.i_physical_channels |= AOUT_CHAN_LFE;
 411                         continue;
 412                     case kAudioChannelLabel_LeftSurround:
 413                         p_aout->output.output.i_physical_channels |= AOUT_CHAN_REARLEFT;
 414                         continue;
 415                     case kAudioChannelLabel_RightSurround:
 416                         p_aout->output.output.i_physical_channels |= AOUT_CHAN_REARRIGHT;
 417                         continue;
 418                     case kAudioChannelLabel_RearSurroundLeft:
 419                         p_aout->output.output.i_physical_channels |= AOUT_CHAN_MIDDLELEFT;
 420                         continue;
 421                     case kAudioChannelLabel_RearSurroundRight:
 422                         p_aout->output.output.i_physical_channels |= AOUT_CHAN_MIDDLERIGHT;
 423                         continue;
 424                     case kAudioChannelLabel_CenterSurround:
 425                         p_aout->output.output.i_physical_channels |= AOUT_CHAN_REARCENTER;
 426                         continue;
 427                     default:
 428                         msg_Warn( p_aout, "unrecognized channel form provided by driver: %d", (int)layout->mChannelDescriptions[i].mChannelLabel );
 429                 }
 430             }
 431             if( p_aout->output.output.i_physical_channels == 0 )
 432             {
 433                 p_aout->output.output.i_physical_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
 434                 msg_Err( p_aout, "You should configure your speaker layout with Audio Midi Setup Utility in /Applications/Utilities. Now using Stereo mode." );
 435                 dialog_Fatal( p_aout, _("Audio device is not configured"), "%s",
 436                                 _("You should configure your speaker layout with "
 437                                   "the \"Audio Midi Setup\" utility in /Applications/"
 438                                   "Utilities. Stereo mode is being used now.") );
 439             }
 440         }
 441         free( layout );
 442     }
 443     else
 444     {
 445         msg_Warn( p_aout, "this driver does not support kAudioDevicePropertyPreferredChannelLayout. BAD DRIVER AUTHOR !!!" );
 446         p_aout->output.output.i_physical_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
 447     }
 448
 449     msg_Dbg( p_aout, "selected %d physical channels for device output", aout_FormatNbChannels( &p_aout->output.output ) );
 450     msg_Dbg( p_aout, "VLC will output: %s", aout_FormatPrintChannels( &p_aout->output.output ));
 451
 452     memset (&new_layout, 0, sizeof(new_layout));
 453     switch( aout_FormatNbChannels( &p_aout->output.output ) )
 454     {
 455         case 1:
 456             new_layout.mChannelLayoutTag = kAudioChannelLayoutTag_Mono;
 457             break;
 458         case 2:
 459             new_layout.mChannelLayoutTag = kAudioChannelLayoutTag_Stereo;
 460             break;
 461         case 3:
 462             if( p_aout->output.output.i_physical_channels & AOUT_CHAN_CENTER )
 463             {
 464                 new_layout.mChannelLayoutTag = kAudioChannelLayoutTag_DVD_7; // L R C
 465             }
 466             else if( p_aout->output.output.i_physical_channels & AOUT_CHAN_LFE )
 467             {
 468                 new_layout.mChannelLayoutTag = kAudioChannelLayoutTag_DVD_4; // L R LFE
 469             }
 470             break;
 471         case 4:
 472             if( p_aout->output.output.i_physical_channels & ( AOUT_CHAN_CENTER | AOUT_CHAN_LFE ) )
 473             {
 474                 new_layout.mChannelLayoutTag = kAudioChannelLayoutTag_DVD_10; // L R C LFE
 475             }
 476             else if( p_aout->output.output.i_physical_channels & ( AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT ) )
 477             {
 478                 new_layout.mChannelLayoutTag = kAudioChannelLayoutTag_DVD_3; // L R Ls Rs
 479             }
 480             else if( p_aout->output.output.i_physical_channels & ( AOUT_CHAN_CENTER | AOUT_CHAN_REARCENTER ) )
 481             {
 482                 new_layout.mChannelLayoutTag = kAudioChannelLayoutTag_DVD_3; // L R C Cs
 483             }
 484             break;
 485         case 5:
 486             if( p_aout->output.output.i_physical_channels & ( AOUT_CHAN_CENTER ) )
 487             {
 488                 new_layout.mChannelLayoutTag = kAudioChannelLayoutTag_DVD_19; // L R Ls Rs C
 489             }
 490             else if( p_aout->output.output.i_physical_channels & ( AOUT_CHAN_LFE ) )
 491             {
 492                 new_layout.mChannelLayoutTag = kAudioChannelLayoutTag_DVD_18; // L R Ls Rs LFE
 493             }
 494             break;
 495         case 6:
 496             if( p_aout->output.output.i_physical_channels & ( AOUT_CHAN_LFE ) )
 497             {
 498                 new_layout.mChannelLayoutTag = kAudioChannelLayoutTag_DVD_20; // L R Ls Rs C LFE
 499             }
 500             else
 501             {
 502                 new_layout.mChannelLayoutTag = kAudioChannelLayoutTag_AudioUnit_6_0; // L R Ls Rs C Cs
 503             }
 504             break;
 505         case 7:
 506             /* FIXME: This is incorrect. VLC uses the internal ordering: L R Lm Rm Lr Rr C LFE but this is wrong */
 507             new_layout.mChannelLayoutTag = kAudioChannelLayoutTag_MPEG_6_1_A; // L R C LFE Ls Rs Cs
 508             break;
 509         case 8:
 510             /* FIXME: This is incorrect. VLC uses the internal ordering: L R Lm Rm Lr Rr C LFE but this is wrong */
 511             new_layout.mChannelLayoutTag = kAudioChannelLayoutTag_MPEG_7_1_A; // L R C LFE Ls Rs Lc Rc
 512             break;
 513     }
 514
 515     /* Set up the format to be used */
 516     DeviceFormat.mSampleRate = p_aout->output.output.i_rate;
 517     DeviceFormat.mFormatID = kAudioFormatLinearPCM;
 518
 519     /* We use float 32. It's the best supported format by both VLC and Coreaudio */
 520     p_aout->output.output.i_format = VLC_CODEC_FL32;
 521     DeviceFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked;
 522     DeviceFormat.mBitsPerChannel = 32;
 523     DeviceFormat.mChannelsPerFrame = aout_FormatNbChannels( &p_aout->output.output );
 524
 525     /* Calculate framesizes and stuff */
 526     DeviceFormat.mFramesPerPacket = 1;
 527     DeviceFormat.mBytesPerFrame = DeviceFormat.mBitsPerChannel * DeviceFormat.mChannelsPerFrame / 8;
 528     DeviceFormat.mBytesPerPacket = DeviceFormat.mBytesPerFrame * DeviceFormat.mFramesPerPacket;
 529
 530     /* Set the desired format */
 531     i_param_size = sizeof(AudioStreamBasicDescription);
 532     verify_noerr( AudioUnitSetProperty( p_sys->au_unit,
 533                                    kAudioUnitProperty_StreamFormat,
 534                                    kAudioUnitScope_Input,
 535                                    0,
 536                                    &DeviceFormat,
 537                                    i_param_size ));
 538
 539     msg_Dbg( p_aout, STREAM_FORMAT_MSG( "we set the AU format: " , DeviceFormat ) );
 540
 541     /* Retrieve actual format */
 542     verify_noerr( AudioUnitGetProperty( p_sys->au_unit,
 543                                    kAudioUnitProperty_StreamFormat,
 544                                    kAudioUnitScope_Input,
 545                                    0,
 546                                    &DeviceFormat,
 547                                    &i_param_size ));
 548
 549     msg_Dbg( p_aout, STREAM_FORMAT_MSG( "the actual set AU format is " , DeviceFormat ) );
 550
 551     /* Do the last VLC aout setups */
 552     aout_FormatPrepare( &p_aout->output.output );
 553     p_aout->output.i_nb_samples = 2048;
 554     aout_VolumeSoftInit( p_aout );
 555
 556     /* set the IOproc callback */
 557     input.inputProc = (AURenderCallback) RenderCallbackAnalog;
 558     input.inputProcRefCon = p_aout;
 559
 560     verify_noerr( AudioUnitSetProperty( p_sys->au_unit,
 561                             kAudioUnitProperty_SetRenderCallback,
 562                             kAudioUnitScope_Input,
 563                             0, &input, sizeof( input ) ) );
 564
 565     input.inputProc = (AURenderCallback) RenderCallbackAnalog;
 566     input.inputProcRefCon = p_aout;
 567
 568     /* Set the new_layout as the layout VLC will use to feed the AU unit */
 569     verify_noerr( AudioUnitSetProperty( p_sys->au_unit,
 570                             kAudioUnitProperty_AudioChannelLayout,
 571                             kAudioUnitScope_Input,
 572                             0, &new_layout, sizeof(new_layout) ) );
 573
 574     if( new_layout.mNumberChannelDescriptions > 0 )
 575         free( new_layout.mChannelDescriptions );
 576
 577     /* AU initiliaze */
 578     verify_noerr( AudioUnitInitialize(p_sys->au_unit) );
 579
 580     /* Find the difference between device clock and mdate clock */
 581     p_sys->clock_diff = - (mtime_t)
 582         AudioConvertHostTimeToNanos( AudioGetCurrentHostTime() ) / 1000;
 583     p_sys->clock_diff += mdate();
 584
 585     /* Start the AU */
 586     verify_noerr( AudioOutputUnitStart(p_sys->au_unit) );
 587
 588     return true;
 589 }
 590
 591 /*****************************************************************************
 592  * Setup a encoded digital stream (SPDIF)
 593  *****************************************************************************/
 594 static int OpenSPDIF( aout_instance_t * p_aout )
 595 {
 596     struct aout_sys_t       *p_sys = p_aout->output.p_sys;
 597     OSStatus                err = noErr;
 598     UInt32                  i_param_size = 0, b_mix = 0;
 599     Boolean                 b_writeable = false;
 600     AudioStreamID           *p_streams = NULL;
 601     int                     i = 0, i_streams = 0;
 602
 603     /* Start doing the SPDIF setup proces */
 604     p_sys->b_digital = true;
 605
 606     /* Hog the device */
 607     i_param_size = sizeof( p_sys->i_hog_pid );
 608     p_sys->i_hog_pid = getpid() ;
 609
 610     err = AudioDeviceSetProperty( p_sys->i_selected_dev, 0, 0, FALSE,
 611                                   kAudioDevicePropertyHogMode, i_param_size, &p_sys->i_hog_pid );
 612
 613     if( err != noErr )
 614     {
 615         msg_Err( p_aout, "failed to set hogmode: [%4.4s]", (char *)&err );
 616         return false;
 617     }
 618
 619     /* Set mixable to false if we are allowed to */
 620     err = AudioDeviceGetPropertyInfo( p_sys->i_selected_dev, 0, FALSE, kAudioDevicePropertySupportsMixing,
 621                                     &i_param_size, &b_writeable );
 622
 623     err = AudioDeviceGetProperty( p_sys->i_selected_dev, 0, FALSE, kAudioDevicePropertySupportsMixing,
 624                                     &i_param_size, &b_mix );
 625
 626     if( !err && b_writeable )
 627     {
 628         b_mix = 0;
 629         err = AudioDeviceSetProperty( p_sys->i_selected_dev, 0, 0, FALSE,
 630                             kAudioDevicePropertySupportsMixing, i_param_size, &b_mix );
 631         p_sys->b_changed_mixing = true;
 632     }
 633
 634     if( err != noErr )
 635     {
 636         msg_Err( p_aout, "failed to set mixmode: [%4.4s]", (char *)&err );
 637         return false;
 638     }
 639
 640     /* Get a list of all the streams on this device */
 641     err = AudioDeviceGetPropertyInfo( p_sys->i_selected_dev, 0, FALSE,
 642                                       kAudioDevicePropertyStreams,
 643                                       &i_param_size, NULL );
 644     if( err != noErr )
 645     {
 646         msg_Err( p_aout, "could not get number of streams: [%4.4s]", (char *)&err );
 647         return false;
 648     }
 649
 650     i_streams = i_param_size / sizeof( AudioStreamID );
 651     p_streams = (AudioStreamID *)malloc( i_param_size );
 652     if( p_streams == NULL )
 653         return false;
 654
 655     err = AudioDeviceGetProperty( p_sys->i_selected_dev, 0, FALSE,
 656                                     kAudioDevicePropertyStreams,
 657                                     &i_param_size, p_streams );
 658
 659     if( err != noErr )
 660     {
 661         msg_Err( p_aout, "could not get number of streams: [%4.4s]", (char *)&err );
 662         free( p_streams );
 663         return false;
 664     }
 665
 666     for( i = 0; i < i_streams && p_sys->i_stream_index < 0 ; i++ )
 667     {
 668         /* Find a stream with a cac3 stream */
 669         AudioStreamBasicDescription *p_format_list = NULL;
 670         int                         i_formats = 0, j = 0;
 671         bool                  b_digital = false;
 672
 673         /* Retrieve all the stream formats supported by each output stream */
 674         err = AudioStreamGetPropertyInfo( p_streams[i], 0,
 675                                           kAudioStreamPropertyPhysicalFormats,
 676                                           &i_param_size, NULL );
 677         if( err != noErr )
 678         {
 679             msg_Err( p_aout, "could not get number of streamformats: [%4.4s]", (char *)&err );
 680             continue;
 681         }
 682
 683         i_formats = i_param_size / sizeof( AudioStreamBasicDescription );
 684         p_format_list = (AudioStreamBasicDescription *)malloc( i_param_size );
 685         if( p_format_list == NULL )
 686             continue;
 687
 688         err = AudioStreamGetProperty( p_streams[i], 0,
 689                                           kAudioStreamPropertyPhysicalFormats,
 690                                           &i_param_size, p_format_list );
 691         if( err != noErr )
 692         {
 693             msg_Err( p_aout, "could not get the list of streamformats: [%4.4s]", (char *)&err );
 694             free( p_format_list );
 695             continue;
 696         }
 697
 698         /* Check if one of the supported formats is a digital format */
 699         for( j = 0; j < i_formats; j++ )
 700         {
 701             if( p_format_list[j].mFormatID == 'IAC3' ||
 702                   p_format_list[j].mFormatID == kAudioFormat60958AC3 )
 703             {
 704                 b_digital = true;
 705                 break;
 706             }
 707         }
 708
 709         if( b_digital )
 710         {
 711             /* if this stream supports a digital (cac3) format, then go set it. */
 712             int i_requested_rate_format = -1;
 713             int i_current_rate_format = -1;
 714             int i_backup_rate_format = -1;
 715
 716             p_sys->i_stream_id = p_streams[i];
 717             p_sys->i_stream_index = i;
 718
 719             if( p_sys->b_revert == false )
 720             {
 721                 /* Retrieve the original format of this stream first if not done so already */
 722                 i_param_size = sizeof( p_sys->sfmt_revert );
 723                 err = AudioStreamGetProperty( p_sys->i_stream_id, 0,
 724                                               kAudioStreamPropertyPhysicalFormat,
 725                                               &i_param_size,
 726                                               &p_sys->sfmt_revert );
 727                 if( err != noErr )
 728                 {
 729                     msg_Err( p_aout, "could not retrieve the original streamformat: [%4.4s]", (char *)&err );
 730                     continue;
 731                 }
 732                 p_sys->b_revert = true;
 733             }
 734
 735             for( j = 0; j < i_formats; j++ )
 736             {
 737                 if( p_format_list[j].mFormatID == 'IAC3' ||
 738                       p_format_list[j].mFormatID == kAudioFormat60958AC3 )
 739                 {
 740                     if( p_format_list[j].mSampleRate == p_aout->output.output.i_rate )
 741                     {
 742                         i_requested_rate_format = j;
 743                         break;
 744                     }
 745                     else if( p_format_list[j].mSampleRate == p_sys->sfmt_revert.mSampleRate )
 746                     {
 747                         i_current_rate_format = j;
 748                     }
 749                     else
 750                     {
 751                         if( i_backup_rate_format < 0 || p_format_list[j].mSampleRate > p_format_list[i_backup_rate_format].mSampleRate )
 752                             i_backup_rate_format = j;
 753                     }
 754                 }
 755
 756             }
 757
 758             if( i_requested_rate_format >= 0 ) /* We prefer to output at the samplerate of the original audio */
 759                 p_sys->stream_format = p_format_list[i_requested_rate_format];
 760             else if( i_current_rate_format >= 0 ) /* If not possible, we will try to use the current samplerate of the device */
 761                 p_sys->stream_format = p_format_list[i_current_rate_format];
 762             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) */
 763         }
 764         free( p_format_list );
 765     }
 766     free( p_streams );
 767
 768     msg_Dbg( p_aout, STREAM_FORMAT_MSG( "original stream format: ", p_sys->sfmt_revert ) );
 769
 770     if( !AudioStreamChangeFormat( p_aout, p_sys->i_stream_id, p_sys->stream_format ) )
 771         return false;
 772
 773     /* Set the format flags */
 774     if( p_sys->stream_format.mFormatFlags & kAudioFormatFlagIsBigEndian )
 775         p_aout->output.output.i_format = VLC_CODEC_SPDIFB;
 776     else
 777         p_aout->output.output.i_format = VLC_CODEC_SPDIFL;
 778     p_aout->output.output.i_bytes_per_frame = AOUT_SPDIF_SIZE;
 779     p_aout->output.output.i_frame_length = A52_FRAME_NB;
 780     p_aout->output.i_nb_samples = p_aout->output.output.i_frame_length;
 781     p_aout->output.output.i_rate = (unsigned int)p_sys->stream_format.mSampleRate;
 782     aout_FormatPrepare( &p_aout->output.output );
 783     aout_VolumeNoneInit( p_aout );
 784
 785     /* Add IOProc callback */
 786     err = AudioDeviceAddIOProc( p_sys->i_selected_dev,
 787                                (AudioDeviceIOProc)RenderCallbackSPDIF,
 788                                (void *)p_aout );
 789
 790     if( err != noErr )
 791     {
 792         msg_Err( p_aout, "AudioDeviceAddIOProc failed: [%4.4s]", (char *)&err );
 793         return false;
 794     }
 795
 796     /* Check for the difference between the Device clock and mdate */
 797     p_sys->clock_diff = - (mtime_t)
 798         AudioConvertHostTimeToNanos( AudioGetCurrentHostTime() ) / 1000;
 799     p_sys->clock_diff += mdate();
 800
 801     /* Start device */
 802     err = AudioDeviceStart( p_sys->i_selected_dev, (AudioDeviceIOProc)RenderCallbackSPDIF );
 803     if( err != noErr )
 804     {
 805         msg_Err( p_aout, "AudioDeviceStart failed: [%4.4s]", (char *)&err );
 806
 807         err = AudioDeviceRemoveIOProc( p_sys->i_selected_dev,
 808                                      (AudioDeviceIOProc)RenderCallbackSPDIF );
 809         if( err != noErr )
 810         {
 811             msg_Err( p_aout, "AudioDeviceRemoveIOProc failed: [%4.4s]", (char *)&err );
 812         }
 813         return false;
 814     }
 815
 816     return true;
 817 }
 818
 819
 820 /*****************************************************************************
 821  * Close: Close HAL AudioUnit
 822  *****************************************************************************/
 823 static void Close( vlc_object_t * p_this )
 824 {
 825     aout_instance_t     *p_aout = (aout_instance_t *)p_this;
 826     struct aout_sys_t   *p_sys = p_aout->output.p_sys;
 827     OSStatus            err = noErr;
 828     UInt32              i_param_size = 0;
 829
 830     if( p_sys->au_unit )
 831     {
 832         verify_noerr( AudioOutputUnitStop( p_sys->au_unit ) );
 833         verify_noerr( AudioUnitUninitialize( p_sys->au_unit ) );
 834         verify_noerr( CloseComponent( p_sys->au_unit ) );
 835     }
 836
 837     if( p_sys->b_digital )
 838     {
 839         /* Stop device */
 840         err = AudioDeviceStop( p_sys->i_selected_dev,
 841                                (AudioDeviceIOProc)RenderCallbackSPDIF );
 842         if( err != noErr )
 843         {
 844             msg_Err( p_aout, "AudioDeviceStop failed: [%4.4s]", (char *)&err );
 845         }
 846
 847         /* Remove IOProc callback */
 848         err = AudioDeviceRemoveIOProc( p_sys->i_selected_dev,
 849                                       (AudioDeviceIOProc)RenderCallbackSPDIF );
 850         if( err != noErr )
 851         {
 852             msg_Err( p_aout, "AudioDeviceRemoveIOProc failed: [%4.4s]", (char *)&err );
 853         }
 854
 855         if( p_sys->b_revert )
 856         {
 857             AudioStreamChangeFormat( p_aout, p_sys->i_stream_id, p_sys->sfmt_revert );
 858         }
 859
 860         if( p_sys->b_changed_mixing && p_sys->sfmt_revert.mFormatID != kAudioFormat60958AC3 )
 861         {
 862             int b_mix;
 863             Boolean b_writeable;
 864             /* Revert mixable to true if we are allowed to */
 865             err = AudioDeviceGetPropertyInfo( p_sys->i_selected_dev, 0, FALSE, kAudioDevicePropertySupportsMixing,
 866                                         &i_param_size, &b_writeable );
 867
 868             err = AudioDeviceGetProperty( p_sys->i_selected_dev, 0, FALSE, kAudioDevicePropertySupportsMixing,
 869                                         &i_param_size, &b_mix );
 870
 871             if( !err && b_writeable )
 872             {
 873                 msg_Dbg( p_aout, "mixable is: %d", b_mix );
 874                 b_mix = 1;
 875                 err = AudioDeviceSetProperty( p_sys->i_selected_dev, 0, 0, FALSE,
 876                                     kAudioDevicePropertySupportsMixing, i_param_size, &b_mix );
 877             }
 878
 879             if( err != noErr )
 880             {
 881                 msg_Err( p_aout, "failed to set mixmode: [%4.4s]", (char *)&err );
 882             }
 883         }
 884     }
 885
 886     err = AudioHardwareRemovePropertyListener( kAudioHardwarePropertyDevices,
 887                                                HardwareListener );
 888
 889     if( err != noErr )
 890     {
 891         msg_Err( p_aout, "AudioHardwareRemovePropertyListener failed: [%4.4s]", (char *)&err );
 892     }
 893
 894     if( p_sys->i_hog_pid == getpid() )
 895     {
 896         p_sys->i_hog_pid = -1;
 897         i_param_size = sizeof( p_sys->i_hog_pid );
 898         err = AudioDeviceSetProperty( p_sys->i_selected_dev, 0, 0, FALSE,
 899                                          kAudioDevicePropertyHogMode, i_param_size, &p_sys->i_hog_pid );
 900         if( err != noErr ) msg_Err( p_aout, "Could not release hogmode: [%4.4s]", (char *)&err );
 901     }
 902
 903     free( p_sys );
 904 }
 905
 906 /*****************************************************************************
 907  * Play: nothing to do
 908  *****************************************************************************/
 909 static void Play( aout_instance_t * p_aout )
 910 {
 911     VLC_UNUSED(p_aout);
 912 }
 913
 914
 915 /*****************************************************************************
 916  * Probe: Check which devices the OS has, and add them to our audio-device menu
 917  *****************************************************************************/
 918 static void Probe( aout_instance_t * p_aout )
 919 {
 920     OSStatus            err = noErr;
 921     UInt32              i = 0, i_param_size = 0;
 922     AudioDeviceID       devid_def = 0;
 923     AudioDeviceID       *p_devices = NULL;
 924     vlc_value_t         val, text;
 925
 926     struct aout_sys_t   *p_sys = p_aout->output.p_sys;
 927
 928     /* Get number of devices */
 929     err = AudioHardwareGetPropertyInfo( kAudioHardwarePropertyDevices,
 930                                         &i_param_size, NULL );
 931     if( err != noErr )
 932     {
 933         msg_Err( p_aout, "Could not get number of devices: [%4.4s]", (char *)&err );
 934         goto error;
 935     }
 936
 937     p_sys->i_devices = i_param_size / sizeof( AudioDeviceID );
 938
 939     if( p_sys->i_devices < 1 )
 940     {
 941         msg_Err( p_aout, "No audio output devices were found." );
 942         goto error;
 943     }
 944
 945     msg_Dbg( p_aout, "system has [%ld] device(s)", p_sys->i_devices );
 946
 947     /* Allocate DeviceID array */
 948     p_devices = (AudioDeviceID*)malloc( sizeof(AudioDeviceID) * p_sys->i_devices );
 949     if( p_devices == NULL )
 950         goto error;
 951
 952     /* Populate DeviceID array */
 953     err = AudioHardwareGetProperty( kAudioHardwarePropertyDevices,
 954                                     &i_param_size, p_devices );
 955     if( err != noErr )
 956     {
 957         msg_Err( p_aout, "could not get the device IDs: [%4.4s]", (char *)&err );
 958         goto error;
 959     }
 960
 961     /* Find the ID of the default Device */
 962     i_param_size = sizeof( AudioDeviceID );
 963     err = AudioHardwareGetProperty( kAudioHardwarePropertyDefaultOutputDevice,
 964                                     &i_param_size, &devid_def );
 965     if( err != noErr )
 966     {
 967         msg_Err( p_aout, "could not get default audio device: [%4.4s]", (char *)&err );
 968         goto error;
 969     }
 970     p_sys->i_default_dev = devid_def;
 971
 972     var_Create( p_aout, "audio-device", VLC_VAR_INTEGER|VLC_VAR_HASCHOICE );
 973     text.psz_string = (char*)_("Audio Device");
 974     var_Change( p_aout, "audio-device", VLC_VAR_SETTEXT, &text, NULL );
 975
 976     for( i = 0; i < p_sys->i_devices; i++ )
 977     {
 978         char *psz_name;
 979         i_param_size = 0;
 980
 981         /* Retrieve the length of the device name */
 982         err = AudioDeviceGetPropertyInfo(
 983                     p_devices[i], 0, false,
 984                     kAudioDevicePropertyDeviceName,
 985                     &i_param_size, NULL);
 986         if( err ) goto error;
 987
 988         /* Retrieve the name of the device */
 989         psz_name = (char *)malloc( i_param_size );
 990         err = AudioDeviceGetProperty(
 991                     p_devices[i], 0, false,
 992                     kAudioDevicePropertyDeviceName,
 993                     &i_param_size, psz_name);
 994         if( err ) goto error;
 995
 996         msg_Dbg( p_aout, "DevID: %#lx DevName: %s", p_devices[i], psz_name );
 997
 998         if( !AudioDeviceHasOutput( p_devices[i]) )
 999         {
1000             msg_Dbg( p_aout, "this device is INPUT only. skipping..." );
1001             free( psz_name );
1002             continue;
1003         }
1004
1005         /* Add the menu entries */
1006         val.i_int = (int)p_devices[i];
1007         text.psz_string = psz_name;
1008         var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE, &val, &text );
1009         text.psz_string = NULL;
1010         if( p_sys->i_default_dev == p_devices[i] )
1011         {
1012             /* The default device is the selected device normally */
1013             var_Change( p_aout, "audio-device", VLC_VAR_SETDEFAULT, &val, NULL );
1014             var_Set( p_aout, "audio-device", val );
1015         }
1016
1017         if( AudioDeviceSupportsDigital( p_aout, p_devices[i] ) )
1018         {
1019             val.i_int = (int)p_devices[i] | AOUT_VAR_SPDIF_FLAG;
1020             if( asprintf( &text.psz_string, _("%s (Encoded Output)"), psz_name ) != -1 )
1021             {
1022                 var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE, &val, &text );
1023                 free( text.psz_string );
1024                 if( p_sys->i_default_dev == p_devices[i] && config_GetInt( p_aout, "spdif" ) )
1025                 {
1026                     /* We selected to prefer SPDIF output if available
1027                      * then this "dummy" entry should be selected */
1028                     var_Change( p_aout, "audio-device", VLC_VAR_SETDEFAULT, &val, NULL );
1029                     var_Set( p_aout, "audio-device", val );
1030                 }
1031             }
1032         }
1033
1034         free( psz_name);
1035     }
1036
1037     /* If a device is already "preselected", then use this device */
1038     var_Get( p_aout->p_libvlc, "macosx-audio-device", &val );
1039     if( val.i_int > 0 )
1040     {
1041         var_Change( p_aout, "audio-device", VLC_VAR_SETDEFAULT, &val, NULL );
1042         var_Set( p_aout, "audio-device", val );
1043     }
1044
1045     /* If we change the device we want to use, we should renegotiate the audio chain */
1046     var_AddCallback( p_aout, "audio-device", AudioDeviceCallback, NULL );
1047
1048     /* Attach a Listener so that we are notified of a change in the Device setup */
1049     err = AudioHardwareAddPropertyListener( kAudioHardwarePropertyDevices,
1050                                             HardwareListener,
1051                                             (void *)p_aout );
1052     if( err )
1053         goto error;
1054
1055     free( p_devices );
1056     return;
1057
1058 error:
1059     msg_Warn( p_aout, "audio device already in use" );
1060     free( p_devices );
1061     return;
1062 }
1063
1064 /*****************************************************************************
1065  * AudioDeviceHasOutput: Checks if the Device actually provides any outputs at all
1066  *****************************************************************************/
1067 static int AudioDeviceHasOutput( AudioDeviceID i_dev_id )
1068 {
1069     UInt32            dataSize;
1070     Boolean            isWritable;
1071
1072     verify_noerr( AudioDeviceGetPropertyInfo( i_dev_id, 0, FALSE, kAudioDevicePropertyStreams, &dataSize, &isWritable) );
1073     if (dataSize == 0) return FALSE;
1074
1075     return TRUE;
1076 }
1077
1078 /*****************************************************************************
1079  * AudioDeviceSupportsDigital: Check i_dev_id for digital stream support.
1080  *****************************************************************************/
1081 static int AudioDeviceSupportsDigital( aout_instance_t *p_aout, AudioDeviceID i_dev_id )
1082 {
1083     OSStatus                    err = noErr;
1084     UInt32                      i_param_size = 0;
1085     AudioStreamID               *p_streams = NULL;
1086     int                         i = 0, i_streams = 0;
1087     bool                  b_return = false;
1088
1089     /* Retrieve all the output streams */
1090     err = AudioDeviceGetPropertyInfo( i_dev_id, 0, FALSE,
1091                                       kAudioDevicePropertyStreams,
1092                                       &i_param_size, NULL );
1093     if( err != noErr )
1094     {
1095         msg_Err( p_aout, "could not get number of streams: [%4.4s]", (char *)&err );
1096         return false;
1097     }
1098
1099     i_streams = i_param_size / sizeof( AudioStreamID );
1100     p_streams = (AudioStreamID *)malloc( i_param_size );
1101     if( p_streams == NULL )
1102         return VLC_ENOMEM;
1103
1104     err = AudioDeviceGetProperty( i_dev_id, 0, FALSE,
1105                                     kAudioDevicePropertyStreams,
1106                                     &i_param_size, p_streams );
1107
1108     if( err != noErr )
1109     {
1110         msg_Err( p_aout, "could not get number of streams: [%4.4s]", (char *)&err );
1111         return false;
1112     }
1113
1114     for( i = 0; i < i_streams; i++ )
1115     {
1116         if( AudioStreamSupportsDigital( p_aout, p_streams[i] ) )
1117             b_return = true;
1118     }
1119
1120     free( p_streams );
1121     return b_return;
1122 }
1123
1124 /*****************************************************************************
1125  * AudioStreamSupportsDigital: Check i_stream_id for digital stream support.
1126  *****************************************************************************/
1127 static int AudioStreamSupportsDigital( aout_instance_t *p_aout, AudioStreamID i_stream_id )
1128 {
1129     OSStatus                    err = noErr;
1130     UInt32                      i_param_size = 0;
1131     AudioStreamBasicDescription *p_format_list = NULL;
1132     int                         i = 0, i_formats = 0;
1133     bool                  b_return = false;
1134
1135     /* Retrieve all the stream formats supported by each output stream */
1136     err = AudioStreamGetPropertyInfo( i_stream_id, 0,
1137                                       kAudioStreamPropertyPhysicalFormats,
1138                                       &i_param_size, NULL );
1139     if( err != noErr )
1140     {
1141         msg_Err( p_aout, "could not get number of streamformats: [%4.4s]", (char *)&err );
1142         return false;
1143     }
1144
1145     i_formats = i_param_size / sizeof( AudioStreamBasicDescription );
1146     p_format_list = (AudioStreamBasicDescription *)malloc( i_param_size );
1147     if( p_format_list == NULL )
1148         return false;
1149
1150     err = AudioStreamGetProperty( i_stream_id, 0,
1151                                       kAudioStreamPropertyPhysicalFormats,
1152                                       &i_param_size, p_format_list );
1153     if( err != noErr )
1154     {
1155         msg_Err( p_aout, "could not get the list of streamformats: [%4.4s]", (char *)&err );
1156         free( p_format_list);
1157         p_format_list = NULL;
1158         return false;
1159     }
1160
1161     for( i = 0; i < i_formats; i++ )
1162     {
1163         msg_Dbg( p_aout, STREAM_FORMAT_MSG( "supported format: ", p_format_list[i] ) );
1164
1165         if( p_format_list[i].mFormatID == 'IAC3' ||
1166                   p_format_list[i].mFormatID == kAudioFormat60958AC3 )
1167         {
1168             b_return = true;
1169         }
1170     }
1171
1172     free( p_format_list );
1173     return b_return;
1174 }
1175
1176 /*****************************************************************************
1177  * AudioStreamChangeFormat: Change i_stream_id to change_format
1178  *****************************************************************************/
1179 static int AudioStreamChangeFormat( aout_instance_t *p_aout, AudioStreamID i_stream_id, AudioStreamBasicDescription change_format )
1180 {
1181     OSStatus            err = noErr;
1182     UInt32              i_param_size = 0;
1183     int i;
1184
1185     struct { vlc_mutex_t lock; vlc_cond_t cond; } w;
1186
1187     msg_Dbg( p_aout, STREAM_FORMAT_MSG( "setting stream format: ", change_format ) );
1188
1189     /* Condition because SetProperty is asynchronious */
1190     vlc_cond_init( &w.cond );
1191     vlc_mutex_init( &w.lock );
1192     vlc_mutex_lock( &w.lock );
1193
1194     /* Install the callback */
1195     err = AudioStreamAddPropertyListener( i_stream_id, 0,
1196                                       kAudioStreamPropertyPhysicalFormat,
1197                                       StreamListener, (void *)&w );
1198     if( err != noErr )
1199     {
1200         msg_Err( p_aout, "AudioStreamAddPropertyListener failed: [%4.4s]", (char *)&err );
1201         return false;
1202     }
1203
1204     /* change the format */
1205     err = AudioStreamSetProperty( i_stream_id, 0, 0,
1206                                   kAudioStreamPropertyPhysicalFormat,
1207                                   sizeof( AudioStreamBasicDescription ),
1208                                   &change_format );
1209     if( err != noErr )
1210     {
1211         msg_Err( p_aout, "could not set the stream format: [%4.4s]", (char *)&err );
1212         return false;
1213     }
1214
1215     /* The AudioStreamSetProperty is not only asynchronious (requiring the locks)
1216      * it is also not atomic in its behaviour.
1217      * Therefore we check 5 times before we really give up.
1218      * FIXME: failing isn't actually implemented yet. */
1219     for( i = 0; i < 5; i++ )
1220     {
1221         AudioStreamBasicDescription actual_format;
1222         mtime_t timeout = mdate() + 500000;
1223
1224         if( vlc_cond_timedwait( &w.cond, &w.lock, timeout ) )
1225         {
1226             msg_Dbg( p_aout, "reached timeout" );
1227         }
1228
1229         i_param_size = sizeof( AudioStreamBasicDescription );
1230         err = AudioStreamGetProperty( i_stream_id, 0,
1231                                       kAudioStreamPropertyPhysicalFormat,
1232                                       &i_param_size,
1233                                       &actual_format );
1234
1235         msg_Dbg( p_aout, STREAM_FORMAT_MSG( "actual format in use: ", actual_format ) );
1236         if( actual_format.mSampleRate == change_format.mSampleRate &&
1237             actual_format.mFormatID == change_format.mFormatID &&
1238             actual_format.mFramesPerPacket == change_format.mFramesPerPacket )
1239         {
1240             /* The right format is now active */
1241             break;
1242         }
1243         /* We need to check again */
1244     }
1245
1246     /* Removing the property listener */
1247     err = AudioStreamRemovePropertyListener( i_stream_id, 0,
1248                                             kAudioStreamPropertyPhysicalFormat,
1249                                             StreamListener );
1250     if( err != noErr )
1251     {
1252         msg_Err( p_aout, "AudioStreamRemovePropertyListener failed: [%4.4s]", (char *)&err );
1253         return false;
1254     }
1255
1256     /* Destroy the lock and condition */
1257     vlc_mutex_unlock( &w.lock );
1258     vlc_mutex_destroy( &w.lock );
1259     vlc_cond_destroy( &w.cond );
1260
1261     return true;
1262 }
1263
1264 /*****************************************************************************
1265  * RenderCallbackAnalog: This function is called everytime the AudioUnit wants
1266  * us to provide some more audio data.
1267  * Don't print anything during normal playback, calling blocking function from
1268  * this callback is not allowed.
1269  *****************************************************************************/
1270 static OSStatus RenderCallbackAnalog( vlc_object_t *_p_aout,
1271                                       AudioUnitRenderActionFlags *ioActionFlags,
1272                                       const AudioTimeStamp *inTimeStamp,
1273                                       unsigned int inBusNumber,
1274                                       unsigned int inNumberFrames,
1275                                       AudioBufferList *ioData )
1276 {
1277     AudioTimeStamp  host_time;
1278     mtime_t         current_date = 0;
1279     uint32_t        i_mData_bytes = 0;
1280
1281     aout_instance_t * p_aout = (aout_instance_t *)_p_aout;
1282     struct aout_sys_t * p_sys = p_aout->output.p_sys;
1283
1284     VLC_UNUSED(ioActionFlags);
1285     VLC_UNUSED(inBusNumber);
1286     VLC_UNUSED(inNumberFrames);
1287
1288     host_time.mFlags = kAudioTimeStampHostTimeValid;
1289     AudioDeviceTranslateTime( p_sys->i_selected_dev, inTimeStamp, &host_time );
1290
1291     /* Check for the difference between the Device clock and mdate */
1292     p_sys->clock_diff = - (mtime_t)
1293         AudioConvertHostTimeToNanos( AudioGetCurrentHostTime() ) / 1000;
1294     p_sys->clock_diff += mdate();
1295
1296     current_date = p_sys->clock_diff +
1297                    AudioConvertHostTimeToNanos( host_time.mHostTime ) / 1000;
1298                    //- ((mtime_t) 1000000 / p_aout->output.output.i_rate * 31 ); // 31 = Latency in Frames. retrieve somewhere
1299
1300     if( ioData == NULL && ioData->mNumberBuffers < 1 )
1301     {
1302         msg_Err( p_aout, "no iodata or buffers");
1303         return 0;
1304     }
1305     if( ioData->mNumberBuffers > 1 )
1306         msg_Err( p_aout, "well this is weird. seems like there is more than one buffer..." );
1307
1308
1309     if( p_sys->i_total_bytes > 0 )
1310     {
1311         i_mData_bytes = __MIN( p_sys->i_total_bytes - p_sys->i_read_bytes, ioData->mBuffers[0].mDataByteSize );
1312         vlc_memcpy( ioData->mBuffers[0].mData,
1313                     &p_sys->p_remainder_buffer[p_sys->i_read_bytes],
1314                     i_mData_bytes );
1315         p_sys->i_read_bytes += i_mData_bytes;
1316         current_date += (mtime_t) ( (mtime_t) 1000000 / p_aout->output.output.i_rate ) *
1317                         ( i_mData_bytes / 4 / aout_FormatNbChannels( &p_aout->output.output )  ); // 4 is fl32 specific
1318
1319         if( p_sys->i_read_bytes >= p_sys->i_total_bytes )
1320             p_sys->i_read_bytes = p_sys->i_total_bytes = 0;
1321     }
1322
1323     while( i_mData_bytes < ioData->mBuffers[0].mDataByteSize )
1324     {
1325         /* We don't have enough data yet */
1326         aout_buffer_t * p_buffer;
1327         p_buffer = aout_OutputNextBuffer( p_aout, current_date , false );
1328
1329         if( p_buffer != NULL )
1330         {
1331             uint32_t i_second_mData_bytes = __MIN( p_buffer->i_buffer, ioData->mBuffers[0].mDataByteSize - i_mData_bytes );
1332
1333             vlc_memcpy( (uint8_t *)ioData->mBuffers[0].mData + i_mData_bytes,
1334                         p_buffer->p_buffer, i_second_mData_bytes );
1335             i_mData_bytes += i_second_mData_bytes;
1336
1337             if( i_mData_bytes >= ioData->mBuffers[0].mDataByteSize )
1338             {
1339                 p_sys->i_total_bytes = p_buffer->i_buffer - i_second_mData_bytes;
1340                 vlc_memcpy( p_sys->p_remainder_buffer,
1341                             &p_buffer->p_buffer[i_second_mData_bytes],
1342                             p_sys->i_total_bytes );
1343             }
1344             else
1345             {
1346                 /* update current_date */
1347                 current_date += (mtime_t) ( (mtime_t) 1000000 / p_aout->output.output.i_rate ) *
1348                                 ( i_second_mData_bytes / 4 / aout_FormatNbChannels( &p_aout->output.output )  ); // 4 is fl32 specific
1349             }
1350             aout_BufferFree( p_buffer );
1351         }
1352         else
1353         {
1354              vlc_memset( (uint8_t *)ioData->mBuffers[0].mData +i_mData_bytes,
1355                          0,ioData->mBuffers[0].mDataByteSize - i_mData_bytes );
1356              i_mData_bytes += ioData->mBuffers[0].mDataByteSize - i_mData_bytes;
1357         }
1358     }
1359     return( noErr );
1360 }
1361
1362 /*****************************************************************************
1363  * RenderCallbackSPDIF: callback for SPDIF audio output
1364  *****************************************************************************/
1365 static OSStatus RenderCallbackSPDIF( AudioDeviceID inDevice,
1366                                     const AudioTimeStamp * inNow,
1367                                     const void * inInputData,
1368                                     const AudioTimeStamp * inInputTime,
1369                                     AudioBufferList * outOutputData,
1370                                     const AudioTimeStamp * inOutputTime,
1371                                     void * threadGlobals )
1372 {
1373     aout_buffer_t * p_buffer;
1374     mtime_t         current_date;
1375
1376     aout_instance_t * p_aout = (aout_instance_t *)threadGlobals;
1377     struct aout_sys_t * p_sys = p_aout->output.p_sys;
1378
1379     VLC_UNUSED(inDevice);
1380     VLC_UNUSED(inInputData);
1381     VLC_UNUSED(inInputTime);
1382
1383     /* Check for the difference between the Device clock and mdate */
1384     p_sys->clock_diff = - (mtime_t)
1385         AudioConvertHostTimeToNanos( inNow->mHostTime ) / 1000;
1386     p_sys->clock_diff += mdate();
1387
1388     current_date = p_sys->clock_diff +
1389                    AudioConvertHostTimeToNanos( inOutputTime->mHostTime ) / 1000;
1390                    //- ((mtime_t) 1000000 / p_aout->output.output.i_rate * 31 ); // 31 = Latency in Frames. retrieve somewhere
1391
1392     p_buffer = aout_OutputNextBuffer( p_aout, current_date, true );
1393
1394 #define BUFFER outOutputData->mBuffers[p_sys->i_stream_index]
1395     if( p_buffer != NULL )
1396     {
1397         if( (int)BUFFER.mDataByteSize != (int)p_buffer->i_buffer)
1398             msg_Warn( p_aout, "bytesize: %d nb_bytes: %d", (int)BUFFER.mDataByteSize, (int)p_buffer->i_buffer );
1399
1400         /* move data into output data buffer */
1401         vlc_memcpy( BUFFER.mData, p_buffer->p_buffer, p_buffer->i_buffer );
1402         aout_BufferFree( p_buffer );
1403     }
1404     else
1405     {
1406         vlc_memset( BUFFER.mData, 0, BUFFER.mDataByteSize );
1407     }
1408 #undef BUFFER
1409
1410     return( noErr );
1411 }
1412
1413 /*****************************************************************************
1414  * HardwareListener: Warns us of changes in the list of registered devices
1415  *****************************************************************************/
1416 static OSStatus HardwareListener( AudioHardwarePropertyID inPropertyID,
1417                                   void * inClientData )
1418 {
1419     OSStatus err = noErr;
1420     aout_instance_t     *p_aout = (aout_instance_t *)inClientData;
1421
1422     switch( inPropertyID )
1423     {
1424         case kAudioHardwarePropertyDevices:
1425         {
1426             /* something changed in the list of devices */
1427             /* We trigger the audio-device's aout_ChannelsRestart callback */
1428             var_TriggerCallback( p_aout, "audio-device" );
1429             var_Destroy( p_aout, "audio-device" );
1430         }
1431         break;
1432     }
1433
1434     return( err );
1435 }
1436
1437 /*****************************************************************************
1438  * StreamListener
1439  *****************************************************************************/
1440 static OSStatus StreamListener( AudioStreamID inStream,
1441                                 UInt32 inChannel,
1442                                 AudioDevicePropertyID inPropertyID,
1443                                 void * inClientData )
1444 {
1445     OSStatus err = noErr;
1446     struct { vlc_mutex_t lock; vlc_cond_t cond; } * w = inClientData;
1447
1448     VLC_UNUSED(inStream);
1449     VLC_UNUSED(inChannel);
1450
1451     switch( inPropertyID )
1452     {
1453         case kAudioStreamPropertyPhysicalFormat:
1454             vlc_mutex_lock( &w->lock );
1455             vlc_cond_signal( &w->cond );
1456             vlc_mutex_unlock( &w->lock );
1457             break;
1458
1459         default:
1460             break;
1461     }
1462     return( err );
1463 }
1464
1465 /*****************************************************************************
1466  * AudioDeviceCallback: Callback triggered when the audio-device variable is changed
1467  *****************************************************************************/
1468 static int AudioDeviceCallback( vlc_object_t *p_this, const char *psz_variable,
1469                      vlc_value_t old_val, vlc_value_t new_val, void *param )
1470 {
1471     aout_instance_t *p_aout = (aout_instance_t *)p_this;
1472     var_Set( p_aout->p_libvlc, "macosx-audio-device", new_val );
1473     msg_Dbg( p_aout, "Set Device: %#x", new_val.i_int );
1474     return aout_ChannelsRestart( p_this, psz_variable, old_val, new_val, param );
1475 }
1476