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