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