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

   1 /*****************************************************************************
   2  * Copyright (C) 2000-2013 VLC authors and VideoLAN
   3  * $Id$
   4  *
   5  * Authors: Romain Goyet <romain.goyet@likid.org>
   6  *          Felix Paul Kühne <fkuehne at videolan dot org>
   7  *          Rémi Denis-Courmont
   8  *          Rafaël Carré <funman at videolan dot org>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 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 General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 #pragma mark includes
  26
  27 #ifdef HAVE_CONFIG_H
  28 # import "config.h"
  29 #endif
  30 #import <vlc_common.h>
  31 #import <vlc_plugin.h>
  32 #import <vlc_aout.h>
  33 #import <AudioToolBox/AudioQueue.h>
  34 #import <AudioToolBox/AudioSession.h>
  35 #import <TargetConditionals.h>
  36
  37 #pragma mark -
  38 #pragma mark private declarations
  39
  40 struct aout_sys_t
  41 {
  42     AudioQueueRef           audioQueueRef;
  43     AudioQueueTimelineRef   timelineRef;
  44
  45     mtime_t                 i_played_length;
  46     int                     i_rate;
  47     float                   f_volume;
  48 };
  49 static int  Open                     (vlc_object_t *);
  50 static void Close                    (vlc_object_t *);
  51 static void Play                     (audio_output_t *, block_t *);
  52 static void Pause                    (audio_output_t *p_aout, bool pause, mtime_t date);
  53 static void Flush                    (audio_output_t *p_aout, bool wait);
  54 static int  TimeGet                  (audio_output_t *aout, mtime_t *);
  55 static void UnusedAudioQueueCallback (void *, AudioQueueRef, AudioQueueBufferRef);
  56 static int Start(audio_output_t *, audio_sample_format_t *);
  57 static void Stop(audio_output_t *);
  58 static int VolumeSet(audio_output_t *, float );
  59 vlc_module_begin ()
  60 set_shortname("AudioQueue")
  61 set_description(N_("AudioQueue (iOS / Mac OS) audio output"))
  62 set_capability("audio output", 40)
  63 set_category(CAT_AUDIO)
  64 set_subcategory(SUBCAT_AUDIO_AOUT)
  65 add_shortcut("audioqueue")
  66 set_callbacks(Open, Close)
  67 vlc_module_end ()
  68
  69 #pragma mark -
  70 #pragma mark initialization
  71
  72 static int Open(vlc_object_t *obj)
  73 {
  74     audio_output_t *aout = (audio_output_t *)obj;
  75     aout_sys_t *sys = malloc(sizeof (*sys));
  76
  77     if (unlikely(sys == NULL))
  78         return VLC_ENOMEM;
  79
  80     aout->sys = sys;
  81     aout->start = Start;
  82     aout->stop = Stop;
  83     aout->volume_set = VolumeSet;
  84
  85     /* reset volume */
  86     aout_VolumeReport(aout, 1.0);
  87
  88     return VLC_SUCCESS;
  89 }
  90
  91 static void Close(vlc_object_t *obj)
  92 {
  93     audio_output_t *aout = (audio_output_t *)obj;
  94     msg_Dbg( aout, "audioqueue: Close");
  95     aout_sys_t *sys = aout->sys;
  96
  97     free(sys);
  98 }
  99
 100 static int VolumeSet(audio_output_t * p_aout, float volume)
 101 {
 102     struct aout_sys_t *p_sys = p_aout->sys;
 103     OSStatus ostatus;
 104
 105     aout_VolumeReport(p_aout, volume);
 106     p_sys->f_volume = volume;
 107
 108     /* Set volume for output unit */
 109     ostatus = AudioQueueSetParameter(p_sys->audioQueueRef, kAudioQueueParam_Volume, volume * volume * volume);
 110
 111     return ostatus;
 112 }
 113
 114 static int Start(audio_output_t *p_aout, audio_sample_format_t *restrict fmt)
 115 {
 116     aout_sys_t *p_sys = p_aout->sys;
 117     OSStatus error = 0;
 118
 119     // prepare the format description for our output
 120     AudioStreamBasicDescription streamDescription;
 121     streamDescription.mSampleRate = fmt->i_rate;
 122     streamDescription.mFormatID = kAudioFormatLinearPCM;
 123     streamDescription.mFormatFlags = kAudioFormatFlagsNativeFloatPacked; // FL32
 124     streamDescription.mFramesPerPacket = 1;
 125     streamDescription.mChannelsPerFrame = 2;
 126     streamDescription.mBitsPerChannel = 32;
 127     streamDescription.mBytesPerFrame = streamDescription.mBitsPerChannel * streamDescription.mChannelsPerFrame / 8;
 128     streamDescription.mBytesPerPacket = streamDescription.mBytesPerFrame * streamDescription.mFramesPerPacket;
 129
 130     // init new output instance
 131     error = AudioQueueNewOutput(&streamDescription,           // Format
 132                                  UnusedAudioQueueCallback,    // Unused Callback, which needs to be provided to have a proper instance
 133                                  NULL,                        // User data, passed to the callback
 134                                  NULL,                        // RunLoop
 135                                  kCFRunLoopCommonModes,       // RunLoop mode
 136                                  0,                           // Flags ; must be zero (per documentation)...
 137                                  &(p_sys->audioQueueRef));    // Output
 138     msg_Dbg(p_aout, "New AudioQueue instance created (status = %li)", error);
 139     if (error != noErr)
 140         return VLC_EGENERIC;
 141
 142     fmt->i_format = VLC_CODEC_FL32;
 143     fmt->i_physical_channels = AOUT_CHANS_STEREO;
 144     aout_FormatPrepare(fmt);
 145     p_aout->sys->i_rate = fmt->i_rate;
 146
 147     // start queue
 148     error = AudioQueueStart(p_sys->audioQueueRef, NULL);
 149     msg_Dbg(p_aout, "Starting AudioQueue (status = %li)", error);
 150
 151     // start timeline for synchro
 152     error = AudioQueueCreateTimeline(p_sys->audioQueueRef, &p_sys->timelineRef);
 153     msg_Dbg(p_aout, "AudioQueue Timeline started (status = %li)", error);
 154     if (error != noErr)
 155         return VLC_EGENERIC;
 156
 157 #ifdef TARGET_OS_IPHONE
 158     // start audio session so playback continues if mute switch is on
 159     AudioSessionInitialize (NULL,
 160                             kCFRunLoopCommonModes,
 161                             NULL,
 162                             NULL);
 163
 164         // Set audio session to mediaplayback
 165         UInt32 sessionCategory = kAudioSessionCategory_MediaPlayback;
 166         AudioSessionSetProperty(kAudioSessionProperty_AudioCategory, sizeof(sessionCategory),&sessionCategory);
 167         AudioSessionSetActive(true);
 168 #endif
 169
 170     p_aout->time_get = TimeGet;
 171     p_aout->play = Play;
 172     p_aout->pause = Pause;
 173     p_aout->flush = Flush;
 174
 175     return VLC_SUCCESS;
 176 }
 177
 178 static void Stop(audio_output_t *p_aout)
 179 {
 180 #ifdef TARGET_OS_IPHONE
 181     AudioSessionSetActive(false);
 182 #endif
 183
 184     p_aout->sys->i_played_length = 0;
 185     AudioQueueDisposeTimeline(p_aout->sys->audioQueueRef, p_aout->sys->timelineRef);
 186     AudioQueueStop(p_aout->sys->audioQueueRef, true);
 187     AudioQueueDispose(p_aout->sys->audioQueueRef, true);
 188     msg_Dbg(p_aout, "audioqueue stopped and disposed");
 189 }
 190
 191 #pragma mark -
 192 #pragma mark actual playback
 193
 194 static void Play(audio_output_t *p_aout, block_t *p_block)
 195 {
 196     AudioQueueBufferRef inBuffer = NULL;
 197     OSStatus status;
 198
 199     status = AudioQueueAllocateBuffer(p_aout->sys->audioQueueRef, p_block->i_buffer, &inBuffer);
 200     if (status == noErr) {
 201         memcpy(inBuffer->mAudioData, p_block->p_buffer, p_block->i_buffer);
 202         inBuffer->mAudioDataByteSize = p_block->i_buffer;
 203
 204         status = AudioQueueEnqueueBuffer(p_aout->sys->audioQueueRef, inBuffer, 0, NULL);
 205         if (status == noErr)
 206             p_aout->sys->i_played_length += p_block->i_length;
 207         else
 208             msg_Err(p_aout, "enqueuing buffer failed (%li)", status);
 209     } else
 210             msg_Err(p_aout, "buffer alloction failed (%li)", status);
 211
 212     block_Release(p_block);
 213 }
 214
 215 void UnusedAudioQueueCallback(void * inUserData, AudioQueueRef inAQ, AudioQueueBufferRef inBuffer) {
 216     /* this function does nothing, but needs to be here to make the AudioQueue API happy.
 217      * without a callback, it will refuse to create an AudioQueue instance. */
 218     VLC_UNUSED(inUserData);
 219     VLC_UNUSED(inAQ);
 220     VLC_UNUSED(inBuffer);
 221 }
 222
 223 static void Pause(audio_output_t *p_aout, bool pause, mtime_t date)
 224 {
 225     VLC_UNUSED(date);
 226
 227     if (pause) {
 228         AudioQueuePause(p_aout->sys->audioQueueRef);
 229 #ifdef TARGET_OS_IPHONE
 230         AudioSessionSetActive(false);
 231 #endif
 232     } else {
 233         AudioQueueStart(p_aout->sys->audioQueueRef, NULL);
 234 #ifdef TARGET_OS_IPHONE
 235         AudioSessionSetActive(true);
 236 #endif
 237     }
 238 }
 239
 240 static void Flush(audio_output_t *p_aout, bool wait)
 241 {
 242     if (!p_aout->sys->audioQueueRef)
 243         return;
 244
 245     AudioQueueDisposeTimeline(p_aout->sys->audioQueueRef, p_aout->sys->timelineRef);
 246
 247     if (wait)
 248         AudioQueueStop(p_aout->sys->audioQueueRef, false);
 249     else
 250         AudioQueueStop(p_aout->sys->audioQueueRef, true);
 251
 252     p_aout->sys->i_played_length = 0;
 253     AudioQueueStart(p_aout->sys->audioQueueRef, NULL);
 254     AudioQueueCreateTimeline(p_aout->sys->audioQueueRef, &p_aout->sys->timelineRef);
 255 }
 256
 257 static int TimeGet(audio_output_t *p_aout, mtime_t *restrict delay)
 258 {
 259     AudioTimeStamp outTimeStamp;
 260     Boolean b_discontinuity;
 261     OSStatus status = AudioQueueGetCurrentTime(p_aout->sys->audioQueueRef, p_aout->sys->timelineRef, &outTimeStamp, &b_discontinuity);
 262
 263     if (status != noErr)
 264         return -1;
 265
 266     if (b_discontinuity)
 267         msg_Dbg(p_aout, "detected output discontinuity");
 268
 269     mtime_t i_pos = (mtime_t) outTimeStamp.mSampleTime * CLOCK_FREQ / p_aout->sys->i_rate;
 270     *delay = p_aout->sys->i_played_length - i_pos;
 271
 272     return 0;
 273 }