modules/audio_output/coreaudio_common.c

   1 /*****************************************************************************
   2  * coreaudio_common.c: Common AudioUnit code for iOS and macOS
   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 #import "coreaudio_common.h"
  26 #import <CoreAudio/CoreAudioTypes.h>
  27
  28 #import <dlfcn.h>
  29 #import <mach/mach_time.h>
  30
  31 static struct
  32 {
  33     void (*lock)(os_unfair_lock *lock);
  34     void (*unlock)(os_unfair_lock *lock);
  35 } unfair_lock;
  36
  37 static mach_timebase_info_data_t tinfo;
  38
  39 static inline uint64_t
  40 BytesToFrames(struct aout_sys_common *p_sys, size_t i_bytes)
  41 {
  42     return i_bytes * p_sys->i_frame_length / p_sys->i_bytes_per_frame;
  43 }
  44
  45 static inline vlc_tick_t
  46 FramesToUs(struct aout_sys_common *p_sys, uint64_t i_nb_frames)
  47 {
  48     return i_nb_frames * CLOCK_FREQ / p_sys->i_rate;
  49 }
  50
  51 static void
  52 ca_ClearOutBuffers(audio_output_t *p_aout)
  53 {
  54     struct aout_sys_common *p_sys = (struct aout_sys_common *) p_aout->sys;
  55
  56     block_ChainRelease(p_sys->p_out_chain);
  57     p_sys->p_out_chain = NULL;
  58     p_sys->pp_out_last = &p_sys->p_out_chain;
  59
  60     p_sys->i_out_size = 0;
  61 }
  62
  63 static void
  64 ca_init_once(void)
  65 {
  66     unfair_lock.lock = dlsym(RTLD_DEFAULT, "os_unfair_lock_lock");
  67     if (!unfair_lock.lock)
  68         return;
  69     unfair_lock.unlock = dlsym(RTLD_DEFAULT, "os_unfair_lock_unlock");
  70     if (!unfair_lock.unlock)
  71         unfair_lock.lock = NULL;
  72
  73     if (mach_timebase_info(&tinfo) != KERN_SUCCESS)
  74         tinfo.numer = tinfo.denom = 0;
  75 }
  76
  77 static void
  78 lock_init(struct aout_sys_common *p_sys)
  79 {
  80     if (unfair_lock.lock)
  81         p_sys->lock.unfair = OS_UNFAIR_LOCK_INIT;
  82     else
  83         vlc_mutex_init(&p_sys->lock.mutex);
  84 }
  85
  86 static void
  87 lock_destroy(struct aout_sys_common *p_sys)
  88 {
  89     if (!unfair_lock.lock)
  90         vlc_mutex_destroy(&p_sys->lock.mutex);
  91 }
  92
  93 static void
  94 lock_lock(struct aout_sys_common *p_sys)
  95 {
  96     if (unfair_lock.lock)
  97         unfair_lock.lock(&p_sys->lock.unfair);
  98     else
  99         vlc_mutex_lock(&p_sys->lock.mutex);
 100 }
 101
 102 static void
 103 lock_unlock(struct aout_sys_common *p_sys)
 104 {
 105     if (unfair_lock.lock)
 106         unfair_lock.unlock(&p_sys->lock.unfair);
 107     else
 108         vlc_mutex_unlock(&p_sys->lock.mutex);
 109 }
 110
 111 void
 112 ca_Open(audio_output_t *p_aout)
 113 {
 114     struct aout_sys_common *p_sys = (struct aout_sys_common *) p_aout->sys;
 115
 116     static pthread_once_t once = PTHREAD_ONCE_INIT;
 117     pthread_once(&once, ca_init_once);
 118
 119     vlc_sem_init(&p_sys->flush_sem, 0);
 120     lock_init(p_sys);
 121     p_sys->p_out_chain = NULL;
 122
 123     p_aout->play = ca_Play;
 124     p_aout->pause = ca_Pause;
 125     p_aout->flush = ca_Flush;
 126     p_aout->time_get = ca_TimeGet;
 127 }
 128
 129 void
 130 ca_Close(audio_output_t *p_aout)
 131 {
 132     struct aout_sys_common *p_sys = (struct aout_sys_common *) p_aout->sys;
 133
 134     vlc_sem_destroy(&p_sys->flush_sem);
 135     lock_destroy(p_sys);
 136 }
 137
 138 /* Called from render callbacks. No lock, wait, and IO here */
 139 void
 140 ca_Render(audio_output_t *p_aout, uint32_t i_frames, uint64_t i_host_time,
 141           uint8_t *p_output, size_t i_requested)
 142 {
 143     struct aout_sys_common *p_sys = (struct aout_sys_common *) p_aout->sys;
 144
 145     lock_lock(p_sys);
 146
 147     p_sys->i_render_host_time = i_host_time;
 148     p_sys->i_render_frames = i_frames;
 149
 150     if (p_sys->b_do_flush)
 151     {
 152         ca_ClearOutBuffers(p_aout);
 153         /* Signal that the renderer is flushed */
 154         p_sys->b_do_flush = false;
 155         vlc_sem_post(&p_sys->flush_sem);
 156     }
 157
 158     if (p_sys->b_paused)
 159         goto drop;
 160
 161     size_t i_copied = 0;
 162     block_t *p_block = p_sys->p_out_chain;
 163     while (p_block != NULL && i_requested != 0)
 164     {
 165         size_t i_tocopy = __MIN(i_requested, p_block->i_buffer);
 166         memcpy(&p_output[i_copied], p_block->p_buffer, i_tocopy);
 167         i_requested -= i_tocopy;
 168         i_copied += i_tocopy;
 169         if (i_tocopy == p_block->i_buffer)
 170         {
 171             block_t *p_release = p_block;
 172             p_block = p_block->p_next;
 173             block_Release(p_release);
 174         }
 175         else
 176         {
 177             assert(i_requested == 0);
 178
 179             p_block->p_buffer += i_tocopy;
 180             p_block->i_buffer -= i_tocopy;
 181         }
 182     }
 183     p_sys->p_out_chain = p_block;
 184     if (!p_sys->p_out_chain)
 185         p_sys->pp_out_last = &p_sys->p_out_chain;
 186     p_sys->i_out_size -= i_copied;
 187
 188     /* Pad with 0 */
 189     if (i_requested > 0)
 190     {
 191         assert(p_sys->i_out_size == 0);
 192         p_sys->i_underrun_size += i_requested;
 193         memset(&p_output[i_copied], 0, i_requested);
 194     }
 195
 196     lock_unlock(p_sys);
 197     return;
 198
 199 drop:
 200     memset(p_output, 0, i_requested);
 201     lock_unlock(p_sys);
 202 }
 203
 204 int
 205 ca_TimeGet(audio_output_t *p_aout, vlc_tick_t *delay)
 206 {
 207     struct aout_sys_common *p_sys = (struct aout_sys_common *) p_aout->sys;
 208
 209     if (unlikely(tinfo.denom == 0))
 210         return -1;
 211
 212     lock_lock(p_sys);
 213
 214     vlc_tick_t i_render_delay;
 215     if (likely(p_sys->i_render_host_time != 0))
 216     {
 217         const uint64_t i_render_time_us = p_sys->i_render_host_time
 218                                         * tinfo.numer / tinfo.denom / 1000;
 219         i_render_delay = i_render_time_us - vlc_tick_now();
 220     }
 221     else
 222         i_render_delay = 0;
 223
 224     const int64_t i_out_frames = BytesToFrames(p_sys, p_sys->i_out_size);
 225     *delay = FramesToUs(p_sys, i_out_frames + p_sys->i_render_frames)
 226            + p_sys->i_dev_latency_us + i_render_delay;
 227
 228     lock_unlock(p_sys);
 229     return 0;
 230 }
 231
 232 void
 233 ca_Flush(audio_output_t *p_aout, bool wait)
 234 {
 235     struct aout_sys_common *p_sys = (struct aout_sys_common *) p_aout->sys;
 236
 237     lock_lock(p_sys);
 238     if (wait)
 239     {
 240         while (p_sys->i_out_size > 0)
 241         {
 242             if (p_sys->b_paused)
 243             {
 244                 ca_ClearOutBuffers(p_aout);
 245                 break;
 246             }
 247
 248             /* Calculate the duration of the circular buffer, in order to wait
 249              * for the render thread to play it all */
 250             const vlc_tick_t i_frame_us =
 251                 FramesToUs(p_sys, BytesToFrames(p_sys, p_sys->i_out_size)) + VLC_TICK_FROM_MS(10);
 252             lock_unlock(p_sys);
 253             vlc_tick_sleep(i_frame_us);
 254             lock_lock(p_sys);
 255         }
 256     }
 257     else
 258     {
 259         assert(!p_sys->b_do_flush);
 260         if (p_sys->b_paused)
 261             ca_ClearOutBuffers(p_aout);
 262         else
 263         {
 264             p_sys->b_do_flush = true;
 265             lock_unlock(p_sys);
 266             vlc_sem_wait(&p_sys->flush_sem);
 267             lock_lock(p_sys);
 268         }
 269     }
 270
 271     p_sys->i_render_host_time = 0;
 272     p_sys->i_render_frames = 0;
 273     lock_unlock(p_sys);
 274 }
 275
 276 void
 277 ca_Pause(audio_output_t * p_aout, bool pause, vlc_tick_t date)
 278 {
 279     struct aout_sys_common *p_sys = (struct aout_sys_common *) p_aout->sys;
 280     VLC_UNUSED(date);
 281
 282     lock_lock(p_sys);
 283     p_sys->b_paused = pause;
 284     lock_unlock(p_sys);
 285 }
 286
 287 void
 288 ca_Play(audio_output_t * p_aout, block_t * p_block, vlc_tick_t date)
 289 {
 290     struct aout_sys_common *p_sys = (struct aout_sys_common *) p_aout->sys;
 291
 292     /* Do the channel reordering */
 293     if (p_sys->chans_to_reorder)
 294        aout_ChannelReorder(p_block->p_buffer, p_block->i_buffer,
 295                            p_sys->chans_to_reorder, p_sys->chan_table,
 296                            VLC_CODEC_FL32);
 297
 298     lock_lock(p_sys);
 299     do
 300     {
 301         const size_t i_avalaible_bytes =
 302             __MIN(p_block->i_buffer, p_sys->i_out_max_size - p_sys->i_out_size);
 303
 304         if (unlikely(i_avalaible_bytes != p_block->i_buffer))
 305         {
 306             /* Not optimal but unlikely code path. */
 307
 308             lock_unlock(p_sys);
 309
 310             block_t *p_new = block_Alloc(i_avalaible_bytes);
 311             if (!p_new)
 312             {
 313                 block_Release(p_block);
 314                 return;
 315             }
 316
 317             memcpy(p_new->p_buffer, p_block->p_buffer, i_avalaible_bytes);
 318
 319             p_block->p_buffer += i_avalaible_bytes;
 320             p_block->i_buffer -= i_avalaible_bytes;
 321
 322             lock_lock(p_sys);
 323
 324             block_ChainLastAppend(&p_sys->pp_out_last, p_new);
 325             p_sys->i_out_size += i_avalaible_bytes;
 326
 327             if (p_sys->b_paused)
 328             {
 329                 lock_unlock(p_sys);
 330                 block_Release(p_block);
 331                 return;
 332             }
 333
 334             const vlc_tick_t i_frame_us =
 335                 FramesToUs(p_sys, BytesToFrames(p_sys, p_block->i_buffer));
 336
 337             /* Wait for the render buffer to play the remaining data */
 338             lock_unlock(p_sys);
 339             vlc_tick_sleep(i_frame_us);
 340             lock_lock(p_sys);
 341         }
 342         else
 343         {
 344             block_ChainLastAppend(&p_sys->pp_out_last, p_block);
 345             p_sys->i_out_size += i_avalaible_bytes;
 346             p_block = NULL;
 347         }
 348     } while (p_block != NULL);
 349
 350     size_t i_underrun_size = p_sys->i_underrun_size;
 351     p_sys->i_underrun_size = 0;
 352
 353     lock_unlock(p_sys);
 354
 355     if (i_underrun_size > 0)
 356         msg_Warn(p_aout, "underrun of %zu bytes", i_underrun_size);
 357
 358     (void) date;
 359 }
 360
 361 int
 362 ca_Initialize(audio_output_t *p_aout, const audio_sample_format_t *fmt,
 363               vlc_tick_t i_dev_latency_us)
 364 {
 365     struct aout_sys_common *p_sys = (struct aout_sys_common *) p_aout->sys;
 366
 367     p_sys->i_underrun_size = 0;
 368     p_sys->b_paused = false;
 369     p_sys->i_render_host_time = 0;
 370     p_sys->i_render_frames = 0;
 371
 372     p_sys->i_rate = fmt->i_rate;
 373     p_sys->i_bytes_per_frame = fmt->i_bytes_per_frame;
 374     p_sys->i_frame_length = fmt->i_frame_length;
 375     p_sys->chans_to_reorder = 0;
 376
 377     msg_Dbg(p_aout, "Current device has a latency of %lld us",
 378             i_dev_latency_us);
 379
 380     /* TODO VLC can't handle latency higher than 1 seconds */
 381     if (i_dev_latency_us > 1000000)
 382     {
 383         i_dev_latency_us = 1000000;
 384         msg_Warn(p_aout, "VLC can't handle this device latency, lowering it to "
 385                  "%lld", i_dev_latency_us);
 386     }
 387     p_sys->i_dev_latency_us = i_dev_latency_us;
 388
 389     /* setup circular buffer */
 390     size_t i_audiobuffer_size = fmt->i_rate * fmt->i_bytes_per_frame
 391                               / p_sys->i_frame_length;
 392     if (fmt->channel_type == AUDIO_CHANNEL_TYPE_AMBISONICS)
 393     {
 394         /* lower latency: 200 ms of buffering. XXX: Decrease when VLC's core
 395          * can handle lower audio latency */
 396         p_sys->i_out_max_size = i_audiobuffer_size / 5;
 397     }
 398     else
 399     {
 400         /* 2 seconds of buffering */
 401         p_sys->i_out_max_size = i_audiobuffer_size * 2;
 402     }
 403
 404     ca_ClearOutBuffers(p_aout);
 405
 406     return VLC_SUCCESS;
 407 }
 408
 409 void
 410 ca_Uninitialize(audio_output_t *p_aout)
 411 {
 412     struct aout_sys_common *p_sys = (struct aout_sys_common *) p_aout->sys;
 413     ca_ClearOutBuffers(p_aout);
 414     p_sys->i_out_max_size = 0;
 415 }
 416
 417 void
 418 ca_SetAliveState(audio_output_t *p_aout, bool alive)
 419 {
 420     struct aout_sys_common *p_sys = (struct aout_sys_common *) p_aout->sys;
 421
 422     lock_lock(p_sys);
 423
 424     bool b_sem_post = false;
 425     p_sys->b_paused = !alive;
 426     if (!alive && p_sys->b_do_flush)
 427     {
 428         ca_ClearOutBuffers(p_aout);
 429         p_sys->b_do_flush = false;
 430         b_sem_post = true;
 431     }
 432
 433     lock_unlock(p_sys);
 434
 435     if (b_sem_post)
 436         vlc_sem_post(&p_sys->flush_sem);
 437 }
 438
 439 AudioUnit
 440 au_NewOutputInstance(audio_output_t *p_aout, OSType comp_sub_type)
 441 {
 442     AudioComponentDescription desc = {
 443         .componentType = kAudioUnitType_Output,
 444         .componentSubType = comp_sub_type,
 445         .componentManufacturer = kAudioUnitManufacturer_Apple,
 446         .componentFlags = 0,
 447         .componentFlagsMask = 0,
 448     };
 449
 450     AudioComponent au_component;
 451     au_component = AudioComponentFindNext(NULL, &desc);
 452     if (au_component == NULL)
 453     {
 454         msg_Err(p_aout, "cannot find any AudioComponent, PCM output failed");
 455         return NULL;
 456     }
 457
 458     AudioUnit au;
 459     OSStatus err = AudioComponentInstanceNew(au_component, &au);
 460     if (err != noErr)
 461     {
 462         ca_LogErr("cannot open AudioComponent, PCM output failed");
 463         return NULL;
 464     }
 465     return au;
 466 }
 467
 468 /*****************************************************************************
 469  * RenderCallback: This function is called everytime the AudioUnit wants
 470  * us to provide some more audio data.
 471  * Don't print anything during normal playback, calling blocking function from
 472  * this callback is not allowed.
 473  *****************************************************************************/
 474 static OSStatus
 475 RenderCallback(void *p_data, AudioUnitRenderActionFlags *ioActionFlags,
 476                const AudioTimeStamp *inTimeStamp, UInt32 inBusNumber,
 477                UInt32 inNumberFrames, AudioBufferList *ioData)
 478 {
 479     VLC_UNUSED(ioActionFlags);
 480     VLC_UNUSED(inTimeStamp);
 481     VLC_UNUSED(inBusNumber);
 482
 483     uint64_t i_host_time = (inTimeStamp->mFlags & kAudioTimeStampHostTimeValid)
 484                          ? inTimeStamp->mHostTime : 0;
 485
 486     ca_Render(p_data, inNumberFrames, i_host_time, ioData->mBuffers[0].mData,
 487               ioData->mBuffers[0].mDataByteSize);
 488
 489     return noErr;
 490 }
 491
 492 static AudioChannelLayout *
 493 GetLayoutDescription(audio_output_t *p_aout,
 494                      const AudioChannelLayout *outlayout)
 495 {
 496     AudioFormatPropertyID id;
 497     UInt32 size;
 498     const void *data;
 499     /* We need to "fill out" the ChannelLayout, because there are multiple
 500      * ways that it can be set */
 501     if (outlayout->mChannelLayoutTag == kAudioChannelLayoutTag_UseChannelBitmap)
 502     {
 503         id = kAudioFormatProperty_ChannelLayoutForBitmap;
 504         size = sizeof(UInt32);
 505         data = &outlayout->mChannelBitmap;
 506     }
 507     else
 508     {
 509         id = kAudioFormatProperty_ChannelLayoutForTag;
 510         size = sizeof(AudioChannelLayoutTag);
 511         data = &outlayout->mChannelLayoutTag;
 512     }
 513
 514     UInt32 param_size;
 515     OSStatus err = AudioFormatGetPropertyInfo(id, size, data, &param_size);
 516     if (err != noErr)
 517         return NULL;
 518
 519     AudioChannelLayout *reslayout = malloc(param_size);
 520     if (reslayout == NULL)
 521         return NULL;
 522
 523     err = AudioFormatGetProperty(id, size, data, &param_size, reslayout);
 524     if (err != noErr || reslayout->mNumberChannelDescriptions == 0)
 525     {
 526         msg_Err(p_aout, "insufficient number of output channels");
 527         free(reslayout);
 528         return NULL;
 529     }
 530
 531     return reslayout;
 532 }
 533
 534 static int
 535 MapOutputLayout(audio_output_t *p_aout, audio_sample_format_t *fmt,
 536                 const AudioChannelLayout *outlayout, bool *warn_configuration)
 537 {
 538     /* Fill VLC physical_channels from output layout */
 539     fmt->i_physical_channels = 0;
 540     uint32_t i_original = fmt->i_physical_channels;
 541     AudioChannelLayout *reslayout = NULL;
 542
 543     if (outlayout == NULL)
 544     {
 545         msg_Dbg(p_aout, "not output layout, default to Stereo");
 546         fmt->i_physical_channels = AOUT_CHANS_STEREO;
 547         goto end;
 548     }
 549
 550     if (outlayout->mChannelLayoutTag !=
 551         kAudioChannelLayoutTag_UseChannelDescriptions)
 552     {
 553         reslayout = GetLayoutDescription(p_aout, outlayout);
 554         if (reslayout == NULL)
 555             return VLC_EGENERIC;
 556         outlayout = reslayout;
 557     }
 558
 559     if (i_original == AOUT_CHAN_CENTER
 560      || outlayout->mNumberChannelDescriptions < 2)
 561     {
 562         /* We only need Mono or cannot output more than 1 channel */
 563         fmt->i_physical_channels = AOUT_CHAN_CENTER;
 564         msg_Dbg(p_aout, "output layout of AUHAL has 1 channel");
 565     }
 566     else if (i_original == (AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT)
 567           || outlayout->mNumberChannelDescriptions < 3)
 568     {
 569         /* We only need Stereo or cannot output more than 2 channels */
 570         fmt->i_physical_channels = AOUT_CHANS_STEREO;
 571         msg_Dbg(p_aout, "output layout of AUHAL is Stereo");
 572     }
 573     else
 574     {
 575         assert(outlayout->mNumberChannelDescriptions > 0);
 576
 577         msg_Dbg(p_aout, "output layout of AUHAL has %i channels",
 578                 outlayout->mNumberChannelDescriptions);
 579
 580         /* maps auhal channels to vlc ones */
 581         static const unsigned i_auhal_channel_mapping[] = {
 582             [kAudioChannelLabel_Left]           = AOUT_CHAN_LEFT,
 583             [kAudioChannelLabel_Right]          = AOUT_CHAN_RIGHT,
 584             [kAudioChannelLabel_Center]         = AOUT_CHAN_CENTER,
 585             [kAudioChannelLabel_LFEScreen]      = AOUT_CHAN_LFE,
 586             [kAudioChannelLabel_LeftSurround]   = AOUT_CHAN_REARLEFT,
 587             [kAudioChannelLabel_RightSurround]  = AOUT_CHAN_REARRIGHT,
 588             /* needs to be swapped with rear */
 589             [kAudioChannelLabel_RearSurroundLeft]  = AOUT_CHAN_MIDDLELEFT,
 590             /* needs to be swapped with rear */
 591             [kAudioChannelLabel_RearSurroundRight] = AOUT_CHAN_MIDDLERIGHT,
 592             [kAudioChannelLabel_CenterSurround] = AOUT_CHAN_REARCENTER
 593         };
 594         static const size_t i_auhal_size = sizeof(i_auhal_channel_mapping)
 595                                          / sizeof(i_auhal_channel_mapping[0]);
 596
 597         /* We want more than stereo and we can do that */
 598         for (unsigned i = 0; i < outlayout->mNumberChannelDescriptions; i++)
 599         {
 600             AudioChannelLabel chan =
 601                 outlayout->mChannelDescriptions[i].mChannelLabel;
 602 #ifndef NDEBUG
 603             msg_Dbg(p_aout, "this is channel: %d", (int) chan);
 604 #endif
 605             if (chan < i_auhal_size && i_auhal_channel_mapping[chan] > 0)
 606                 fmt->i_physical_channels |= i_auhal_channel_mapping[chan];
 607             else
 608                 msg_Dbg(p_aout, "found nonrecognized channel %d at index "
 609                         "%d", chan, i);
 610         }
 611         if (fmt->i_physical_channels == 0)
 612         {
 613             fmt->i_physical_channels = AOUT_CHANS_STEREO;
 614             if (warn_configuration)
 615                 *warn_configuration = true;
 616         }
 617
 618     }
 619
 620 end:
 621     free(reslayout);
 622     aout_FormatPrepare(fmt);
 623
 624     msg_Dbg(p_aout, "selected %d physical channels for device output",
 625             aout_FormatNbChannels(fmt));
 626     msg_Dbg(p_aout, "VLC will output: %s", aout_FormatPrintChannels(fmt));
 627
 628     return VLC_SUCCESS;
 629 }
 630
 631 static int
 632 SetupInputLayout(audio_output_t *p_aout, const audio_sample_format_t *fmt,
 633                  AudioChannelLayoutTag *inlayout_tag)
 634 {
 635     struct aout_sys_common *p_sys = (struct aout_sys_common *) p_aout->sys;
 636     uint32_t chans_out[AOUT_CHAN_MAX];
 637
 638     /* Some channel abbreviations used below:
 639      * L - left
 640      * R - right
 641      * C - center
 642      * Ls - left surround
 643      * Rs - right surround
 644      * Cs - center surround
 645      * Rls - rear left surround
 646      * Rrs - rear right surround
 647      * Lw - left wide
 648      * Rw - right wide
 649      * Lsd - left surround direct
 650      * Rsd - right surround direct
 651      * Lc - left center
 652      * Rc - right center
 653      * Ts - top surround
 654      * Vhl - vertical height left
 655      * Vhc - vertical height center
 656      * Vhr - vertical height right
 657      * Lt - left matrix total. for matrix encoded stereo.
 658      * Rt - right matrix total. for matrix encoded stereo. */
 659
 660     switch (aout_FormatNbChannels(fmt))
 661     {
 662         case 1:
 663             *inlayout_tag = kAudioChannelLayoutTag_Mono;
 664             break;
 665         case 2:
 666             *inlayout_tag = kAudioChannelLayoutTag_Stereo;
 667             break;
 668         case 3:
 669             if (fmt->i_physical_channels & AOUT_CHAN_CENTER) /* L R C */
 670                 *inlayout_tag = kAudioChannelLayoutTag_DVD_7;
 671             else if (fmt->i_physical_channels & AOUT_CHAN_LFE) /* L R LFE */
 672                 *inlayout_tag = kAudioChannelLayoutTag_DVD_4;
 673             break;
 674         case 4:
 675             if (fmt->i_physical_channels & (AOUT_CHAN_CENTER | AOUT_CHAN_LFE)) /* L R C LFE */
 676                 *inlayout_tag = kAudioChannelLayoutTag_DVD_10;
 677             else if (fmt->i_physical_channels & AOUT_CHANS_REAR) /* L R Ls Rs */
 678                 *inlayout_tag = kAudioChannelLayoutTag_DVD_3;
 679             else if (fmt->i_physical_channels & AOUT_CHANS_CENTER) /* L R C Cs */
 680                 *inlayout_tag = kAudioChannelLayoutTag_DVD_3;
 681             break;
 682         case 5:
 683             if (fmt->i_physical_channels & (AOUT_CHAN_CENTER)) /* L R Ls Rs C */
 684                 *inlayout_tag = kAudioChannelLayoutTag_DVD_19;
 685             else if (fmt->i_physical_channels & (AOUT_CHAN_LFE)) /* L R Ls Rs LFE */
 686                 *inlayout_tag = kAudioChannelLayoutTag_DVD_18;
 687             break;
 688         case 6:
 689             if (fmt->i_physical_channels & (AOUT_CHAN_LFE))
 690             {
 691                 /* L R Ls Rs C LFE */
 692                 *inlayout_tag = kAudioChannelLayoutTag_DVD_20;
 693
 694                 chans_out[0] = AOUT_CHAN_LEFT;
 695                 chans_out[1] = AOUT_CHAN_RIGHT;
 696                 chans_out[2] = AOUT_CHAN_REARLEFT;
 697                 chans_out[3] = AOUT_CHAN_REARRIGHT;
 698                 chans_out[4] = AOUT_CHAN_CENTER;
 699                 chans_out[5] = AOUT_CHAN_LFE;
 700
 701                 p_sys->chans_to_reorder =
 702                     aout_CheckChannelReorder(NULL, chans_out,
 703                                              fmt->i_physical_channels,
 704                                              p_sys->chan_table);
 705                 if (p_sys->chans_to_reorder)
 706                     msg_Dbg(p_aout, "channel reordering needed for 5.1 output");
 707             }
 708             else
 709             {
 710                 /* L R Ls Rs C Cs */
 711                 *inlayout_tag = kAudioChannelLayoutTag_AudioUnit_6_0;
 712
 713                 chans_out[0] = AOUT_CHAN_LEFT;
 714                 chans_out[1] = AOUT_CHAN_RIGHT;
 715                 chans_out[2] = AOUT_CHAN_REARLEFT;
 716                 chans_out[3] = AOUT_CHAN_REARRIGHT;
 717                 chans_out[4] = AOUT_CHAN_CENTER;
 718                 chans_out[5] = AOUT_CHAN_REARCENTER;
 719
 720                 p_sys->chans_to_reorder =
 721                     aout_CheckChannelReorder(NULL, chans_out,
 722                                              fmt->i_physical_channels,
 723                                              p_sys->chan_table);
 724                 if (p_sys->chans_to_reorder)
 725                     msg_Dbg(p_aout, "channel reordering needed for 6.0 output");
 726             }
 727             break;
 728         case 7:
 729             /* L R C LFE Ls Rs Cs */
 730             *inlayout_tag = kAudioChannelLayoutTag_MPEG_6_1_A;
 731
 732             chans_out[0] = AOUT_CHAN_LEFT;
 733             chans_out[1] = AOUT_CHAN_RIGHT;
 734             chans_out[2] = AOUT_CHAN_CENTER;
 735             chans_out[3] = AOUT_CHAN_LFE;
 736             chans_out[4] = AOUT_CHAN_REARLEFT;
 737             chans_out[5] = AOUT_CHAN_REARRIGHT;
 738             chans_out[6] = AOUT_CHAN_REARCENTER;
 739
 740             p_sys->chans_to_reorder =
 741                 aout_CheckChannelReorder(NULL, chans_out,
 742                                          fmt->i_physical_channels,
 743                                          p_sys->chan_table);
 744             if (p_sys->chans_to_reorder)
 745                 msg_Dbg(p_aout, "channel reordering needed for 6.1 output");
 746
 747             break;
 748         case 8:
 749             if (fmt->i_physical_channels & (AOUT_CHAN_LFE))
 750             {
 751                 /* L R C LFE Ls Rs Rls Rrs */
 752                 *inlayout_tag = kAudioChannelLayoutTag_MPEG_7_1_C;
 753
 754                 chans_out[0] = AOUT_CHAN_LEFT;
 755                 chans_out[1] = AOUT_CHAN_RIGHT;
 756                 chans_out[2] = AOUT_CHAN_CENTER;
 757                 chans_out[3] = AOUT_CHAN_LFE;
 758                 chans_out[4] = AOUT_CHAN_MIDDLELEFT;
 759                 chans_out[5] = AOUT_CHAN_MIDDLERIGHT;
 760                 chans_out[6] = AOUT_CHAN_REARLEFT;
 761                 chans_out[7] = AOUT_CHAN_REARRIGHT;
 762             }
 763             else
 764             {
 765                 /* Lc C Rc L R Ls Cs Rs */
 766                 *inlayout_tag = kAudioChannelLayoutTag_DTS_8_0_B;
 767
 768                 chans_out[0] = AOUT_CHAN_MIDDLELEFT;
 769                 chans_out[1] = AOUT_CHAN_CENTER;
 770                 chans_out[2] = AOUT_CHAN_MIDDLERIGHT;
 771                 chans_out[3] = AOUT_CHAN_LEFT;
 772                 chans_out[4] = AOUT_CHAN_RIGHT;
 773                 chans_out[5] = AOUT_CHAN_REARLEFT;
 774                 chans_out[6] = AOUT_CHAN_REARCENTER;
 775                 chans_out[7] = AOUT_CHAN_REARRIGHT;
 776             }
 777             p_sys->chans_to_reorder =
 778                 aout_CheckChannelReorder(NULL, chans_out,
 779                                          fmt->i_physical_channels,
 780                                          p_sys->chan_table);
 781             if (p_sys->chans_to_reorder)
 782                 msg_Dbg(p_aout, "channel reordering needed for 7.1 / 8.0 output");
 783             break;
 784         case 9:
 785             /* Lc C Rc L R Ls Cs Rs LFE */
 786             *inlayout_tag = kAudioChannelLayoutTag_DTS_8_1_B;
 787             chans_out[0] = AOUT_CHAN_MIDDLELEFT;
 788             chans_out[1] = AOUT_CHAN_CENTER;
 789             chans_out[2] = AOUT_CHAN_MIDDLERIGHT;
 790             chans_out[3] = AOUT_CHAN_LEFT;
 791             chans_out[4] = AOUT_CHAN_RIGHT;
 792             chans_out[5] = AOUT_CHAN_REARLEFT;
 793             chans_out[6] = AOUT_CHAN_REARCENTER;
 794             chans_out[7] = AOUT_CHAN_REARRIGHT;
 795             chans_out[8] = AOUT_CHAN_LFE;
 796
 797             p_sys->chans_to_reorder =
 798                 aout_CheckChannelReorder(NULL, chans_out,
 799                                          fmt->i_physical_channels,
 800                                          p_sys->chan_table);
 801             if (p_sys->chans_to_reorder)
 802                 msg_Dbg(p_aout, "channel reordering needed for 8.1 output");
 803             break;
 804     }
 805
 806     return VLC_SUCCESS;
 807 }
 808
 809 int
 810 au_Initialize(audio_output_t *p_aout, AudioUnit au, audio_sample_format_t *fmt,
 811               const AudioChannelLayout *outlayout, vlc_tick_t i_dev_latency_us,
 812               bool *warn_configuration)
 813 {
 814     int ret;
 815     AudioChannelLayoutTag inlayout_tag;
 816
 817     if (warn_configuration)
 818         *warn_configuration = false;
 819
 820     /* Set the desired format */
 821     AudioStreamBasicDescription desc;
 822     if (aout_BitsPerSample(fmt->i_format) != 0)
 823     {
 824         /* PCM */
 825         fmt->i_format = VLC_CODEC_FL32;
 826         ret = MapOutputLayout(p_aout, fmt, outlayout, warn_configuration);
 827         if (ret != VLC_SUCCESS)
 828             return ret;
 829
 830         ret = SetupInputLayout(p_aout, fmt, &inlayout_tag);
 831         if (ret != VLC_SUCCESS)
 832             return ret;
 833
 834         desc.mFormatFlags = kAudioFormatFlagsNativeFloatPacked;
 835         desc.mChannelsPerFrame = aout_FormatNbChannels(fmt);
 836         desc.mBitsPerChannel = 32;
 837     }
 838     else if (AOUT_FMT_SPDIF(fmt))
 839     {
 840         /* Passthrough */
 841         fmt->i_format = VLC_CODEC_SPDIFL;
 842         fmt->i_bytes_per_frame = 4;
 843         fmt->i_frame_length = 1;
 844
 845         inlayout_tag = kAudioChannelLayoutTag_Stereo;
 846
 847         desc.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger |
 848                             kLinearPCMFormatFlagIsPacked; /* S16LE */
 849         desc.mChannelsPerFrame = 2;
 850         desc.mBitsPerChannel = 16;
 851     }
 852     else
 853         return VLC_EGENERIC;
 854
 855     desc.mSampleRate = fmt->i_rate;
 856     desc.mFormatID = kAudioFormatLinearPCM;
 857     desc.mFramesPerPacket = 1;
 858     desc.mBytesPerFrame = desc.mBitsPerChannel * desc.mChannelsPerFrame / 8;
 859     desc.mBytesPerPacket = desc.mBytesPerFrame * desc.mFramesPerPacket;
 860
 861     OSStatus err = AudioUnitSetProperty(au, kAudioUnitProperty_StreamFormat,
 862                                         kAudioUnitScope_Input, 0, &desc,
 863                                         sizeof(desc));
 864     if (err != noErr)
 865     {
 866         ca_LogErr("failed to set stream format");
 867         return VLC_EGENERIC;
 868     }
 869     msg_Dbg(p_aout, STREAM_FORMAT_MSG("Current AU format: " , desc));
 870
 871     /* Retrieve actual format */
 872     err = AudioUnitGetProperty(au, kAudioUnitProperty_StreamFormat,
 873                                kAudioUnitScope_Input, 0, &desc,
 874                                &(UInt32) { sizeof(desc) });
 875     if (err != noErr)
 876     {
 877         ca_LogErr("failed to set stream format");
 878         return VLC_EGENERIC;
 879     }
 880
 881     /* Set the IOproc callback */
 882     const AURenderCallbackStruct callback = {
 883         .inputProc = RenderCallback,
 884         .inputProcRefCon = p_aout,
 885     };
 886
 887     err = AudioUnitSetProperty(au, kAudioUnitProperty_SetRenderCallback,
 888                                kAudioUnitScope_Input, 0, &callback,
 889                                sizeof(callback));
 890     if (err != noErr)
 891     {
 892         ca_LogErr("failed to setup render callback");
 893         return VLC_EGENERIC;
 894     }
 895
 896     /* Set the input_layout as the layout VLC will use to feed the AU unit.
 897      * Yes, it must be the INPUT scope */
 898     AudioChannelLayout inlayout = {
 899         .mChannelLayoutTag = inlayout_tag,
 900     };
 901     err = AudioUnitSetProperty(au, kAudioUnitProperty_AudioChannelLayout,
 902                                kAudioUnitScope_Input, 0, &inlayout,
 903                                sizeof(inlayout));
 904     if (err != noErr)
 905     {
 906         ca_LogErr("failed to setup input layout");
 907         return VLC_EGENERIC;
 908     }
 909
 910     /* AU init */
 911     err = AudioUnitInitialize(au);
 912
 913     if (err != noErr)
 914     {
 915         ca_LogErr("AudioUnitInitialize failed");
 916         return VLC_EGENERIC;
 917     }
 918
 919     ret = ca_Initialize(p_aout, fmt, i_dev_latency_us);
 920     if (ret != VLC_SUCCESS)
 921     {
 922         AudioUnitUninitialize(au);
 923         return VLC_EGENERIC;
 924     }
 925
 926     return VLC_SUCCESS;
 927 }
 928
 929 void
 930 au_Uninitialize(audio_output_t *p_aout, AudioUnit au)
 931 {
 932     OSStatus err = AudioUnitUninitialize(au);
 933     if (err != noErr)
 934         ca_LogWarn("AudioUnitUninitialize failed");
 935
 936     ca_Uninitialize(p_aout);
 937 }