Unreviewed, rolling out r218373.
[WebKit-https.git] / Source / WebCore / platform / audio / ios / AudioDestinationIOS.cpp
1 /*
2  * Copyright (C) 2010 Google Inc. All rights reserved.
3  * Copyright (C) 2011, 2014 Apple Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * 1.  Redistributions of source code must retain the above copyright
10  *     notice, this list of conditions and the following disclaimer.
11  * 2.  Redistributions in binary form must reproduce the above copyright
12  *     notice, this list of conditions and the following disclaimer in the
13  *     documentation and/or other materials provided with the distribution.
14  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
15  *     its contributors may be used to endorse or promote products derived
16  *     from this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #include "config.h"
31
32 #if ENABLE(WEB_AUDIO) && PLATFORM(IOS)
33
34 #include "AudioDestinationIOS.h"
35
36 #include "AudioIOCallback.h"
37 #include "AudioSession.h"
38 #include "FloatConversion.h"
39 #include "Logging.h"
40 #include "RuntimeApplicationChecks.h"
41 #include "SoftLinking.h"
42 #include <AudioToolbox/AudioServices.h>
43 #include <wtf/HashSet.h>
44 #include <wtf/NeverDestroyed.h>
45
46 SOFT_LINK_FRAMEWORK(AudioToolbox)
47 SOFT_LINK(AudioToolbox, AudioComponentFindNext, AudioComponent, (AudioComponent inComponent, const AudioComponentDescription *inDesc), (inComponent, inDesc))
48 SOFT_LINK(AudioToolbox, AudioComponentInstanceDispose, OSStatus, (AudioComponentInstance inInstance), (inInstance))
49 SOFT_LINK(AudioToolbox, AudioComponentInstanceNew, OSStatus, (AudioComponent inComponent, AudioComponentInstance *outInstance), (inComponent, outInstance))
50 SOFT_LINK(AudioToolbox, AudioOutputUnitStart, OSStatus, (AudioUnit ci), (ci))
51 SOFT_LINK(AudioToolbox, AudioOutputUnitStop, OSStatus, (AudioUnit ci), (ci))
52 SOFT_LINK(AudioToolbox, AudioUnitAddPropertyListener, OSStatus, (AudioUnit inUnit, AudioUnitPropertyID inID, AudioUnitPropertyListenerProc inProc, void *inProcUserData), (inUnit, inID, inProc, inProcUserData))
53 SOFT_LINK(AudioToolbox, AudioUnitGetProperty, OSStatus, (AudioUnit inUnit, AudioUnitPropertyID inID, AudioUnitScope inScope, AudioUnitElement inElement, void *outData, UInt32 *ioDataSize), (inUnit, inID, inScope, inElement, outData, ioDataSize))
54 SOFT_LINK(AudioToolbox, AudioUnitInitialize, OSStatus, (AudioUnit inUnit), (inUnit))
55 SOFT_LINK(AudioToolbox, AudioUnitSetProperty, OSStatus, (AudioUnit inUnit, AudioUnitPropertyID inID, AudioUnitScope inScope, AudioUnitElement inElement, const void *inData, UInt32 inDataSize), (inUnit, inID, inScope, inElement, inData, inDataSize))
56
57 namespace WebCore {
58
59 const int kRenderBufferSize = 128;
60 const int kPreferredBufferSize = 256;
61
62 typedef HashSet<AudioDestinationIOS*> AudioDestinationSet;
63 static AudioDestinationSet& audioDestinations()
64 {
65     static NeverDestroyed<AudioDestinationSet> audioDestinationSet;
66     return audioDestinationSet;
67 }
68
69 // Factory method: iOS-implementation
70 std::unique_ptr<AudioDestination> AudioDestination::create(AudioIOCallback& callback, const String&, unsigned numberOfInputChannels, unsigned numberOfOutputChannels, float sampleRate)
71 {
72     // FIXME: make use of inputDeviceId as appropriate.
73
74     // FIXME: Add support for local/live audio input.
75     if (numberOfInputChannels)
76         LOG(Media, "AudioDestination::create(%u, %u, %f) - unhandled input channels", numberOfInputChannels, numberOfOutputChannels, sampleRate);
77
78     // FIXME: Add support for multi-channel (> stereo) output.
79     if (numberOfOutputChannels != 2)
80         LOG(Media, "AudioDestination::create(%u, %u, %f) - unhandled output channels", numberOfInputChannels, numberOfOutputChannels, sampleRate);
81
82     return std::make_unique<AudioDestinationIOS>(callback, sampleRate);
83 }
84
85 float AudioDestination::hardwareSampleRate()
86 {
87     return AudioSession::sharedSession().sampleRate();
88 }
89
90 unsigned long AudioDestination::maxChannelCount()
91 {
92     // FIXME: query the default audio hardware device to return the actual number
93     // of channels of the device. Also see corresponding FIXME in create().
94     // There is a small amount of code which assumes stereo in AudioDestinationIOS which
95     // can be upgraded.
96     return 0;
97 }
98
99 AudioDestinationIOS::AudioDestinationIOS(AudioIOCallback& callback, double sampleRate)
100     : m_outputUnit(0)
101     , m_callback(callback)
102     , m_renderBus(AudioBus::create(2, kRenderBufferSize, false))
103     , m_spareBus(AudioBus::create(2, kRenderBufferSize, true))
104     , m_sampleRate(sampleRate)
105     , m_isPlaying(false)
106 {
107     audioDestinations().add(this);
108
109     // Open and initialize DefaultOutputUnit
110     AudioComponent comp;
111     AudioComponentDescription desc;
112
113     desc.componentType = kAudioUnitType_Output;
114     desc.componentSubType = kAudioUnitSubType_RemoteIO;
115     desc.componentManufacturer = kAudioUnitManufacturer_Apple;
116     desc.componentFlags = 0;
117     desc.componentFlagsMask = 0;
118     comp = AudioComponentFindNext(0, &desc);
119
120     ASSERT(comp);
121
122     OSStatus result = AudioComponentInstanceNew(comp, &m_outputUnit);
123     ASSERT(!result);
124
125     UInt32 flag = 1;
126     result = AudioUnitSetProperty(m_outputUnit, 
127         kAudioOutputUnitProperty_EnableIO, 
128         kAudioUnitScope_Output, 
129         0,
130         &flag, 
131         sizeof(flag));
132     ASSERT(!result);
133
134     result = AudioUnitAddPropertyListener(m_outputUnit, kAudioUnitProperty_MaximumFramesPerSlice, frameSizeChangedProc, this);
135     ASSERT(!result);
136
137     result = AudioUnitInitialize(m_outputUnit);
138     ASSERT(!result);
139
140     configure();
141 }
142
143 AudioDestinationIOS::~AudioDestinationIOS()
144 {
145     audioDestinations().remove(this);
146
147     if (m_outputUnit)
148         AudioComponentInstanceDispose(m_outputUnit);
149 }
150
151 void AudioDestinationIOS::configure()
152 {
153     // Set render callback
154     AURenderCallbackStruct input;
155     input.inputProc = inputProc;
156     input.inputProcRefCon = this;
157     OSStatus result = AudioUnitSetProperty(m_outputUnit, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, 0, &input, sizeof(input));
158     ASSERT(!result);
159
160     // Set stream format
161     AudioStreamBasicDescription streamFormat;
162
163     UInt32 size = sizeof(AudioStreamBasicDescription);
164     result = AudioUnitGetProperty(m_outputUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 0, (void*)&streamFormat, &size);
165     ASSERT(!result);
166
167     const int bytesPerFloat = sizeof(Float32);
168     const int bitsPerByte = 8;
169     streamFormat.mSampleRate = m_sampleRate;
170     streamFormat.mFormatID = kAudioFormatLinearPCM;
171     streamFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kAudioFormatFlagIsNonInterleaved;
172     streamFormat.mBytesPerPacket = bytesPerFloat;
173     streamFormat.mFramesPerPacket = 1;
174     streamFormat.mBytesPerFrame = bytesPerFloat;
175     streamFormat.mChannelsPerFrame = 2;
176     streamFormat.mBitsPerChannel = bitsPerByte * bytesPerFloat;
177
178     result = AudioUnitSetProperty(m_outputUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, (void*)&streamFormat, sizeof(AudioStreamBasicDescription));
179     ASSERT(!result);
180
181     AudioSession::sharedSession().setPreferredBufferSize(kPreferredBufferSize);
182 }
183
184 void AudioDestinationIOS::start()
185 {
186     LOG(Media, "AudioDestinationIOS::start");
187
188     OSStatus result = AudioOutputUnitStart(m_outputUnit);
189     if (!result)
190         setIsPlaying(true);
191 }
192
193 void AudioDestinationIOS::stop()
194 {
195     LOG(Media, "AudioDestinationIOS::stop");
196
197     OSStatus result = AudioOutputUnitStop(m_outputUnit);
198     if (!result)
199         setIsPlaying(false);
200 }
201
202 static void assignAudioBuffersToBus(AudioBuffer* buffers, AudioBus& bus, UInt32 numberOfBuffers, UInt32 numberOfFrames, UInt32 frameOffset, UInt32 framesThisTime)
203 {
204     for (UInt32 i = 0; i < numberOfBuffers; ++i) {
205         UInt32 bytesPerFrame = buffers[i].mDataByteSize / numberOfFrames;
206         UInt32 byteOffset = frameOffset * bytesPerFrame;
207         float* memory = reinterpret_cast<float*>(reinterpret_cast<char*>(buffers[i].mData) + byteOffset);
208         bus.setChannelMemory(i, memory, framesThisTime);
209     }
210 }
211
212 // Pulls on our provider to get rendered audio stream.
213 OSStatus AudioDestinationIOS::render(UInt32 numberOfFrames, AudioBufferList* ioData)
214 {
215     AudioBuffer* buffers = ioData->mBuffers;
216     UInt32 numberOfBuffers = ioData->mNumberBuffers;
217     UInt32 framesRemaining = numberOfFrames;
218     UInt32 frameOffset = 0;
219     while (framesRemaining > 0) {
220         if (m_startSpareFrame < m_endSpareFrame) {
221             ASSERT(m_startSpareFrame < m_endSpareFrame);
222             UInt32 framesThisTime = std::min<UInt32>(m_endSpareFrame - m_startSpareFrame, numberOfFrames);
223             assignAudioBuffersToBus(buffers, *m_renderBus, numberOfBuffers, numberOfFrames, frameOffset, framesThisTime);
224             m_renderBus->copyFromRange(*m_spareBus, m_startSpareFrame, m_endSpareFrame);
225             frameOffset += framesThisTime;
226             framesRemaining -= framesThisTime;
227             m_startSpareFrame += framesThisTime;
228         }
229
230         UInt32 framesThisTime = std::min<UInt32>(kRenderBufferSize, framesRemaining);
231         assignAudioBuffersToBus(buffers, *m_renderBus, numberOfBuffers, numberOfFrames, frameOffset, framesThisTime);
232
233         if (!framesThisTime)
234             break;
235         if (framesThisTime < kRenderBufferSize) {
236             m_callback.render(0, m_spareBus.get(), kRenderBufferSize);
237             m_renderBus->copyFromRange(*m_spareBus, 0, framesThisTime);
238             m_startSpareFrame = framesThisTime;
239             m_endSpareFrame = kRenderBufferSize;
240         } else
241             m_callback.render(0, m_renderBus.get(), framesThisTime);
242         frameOffset += framesThisTime;
243         framesRemaining -= framesThisTime;
244     }
245
246     return noErr;
247 }
248
249 void AudioDestinationIOS::setIsPlaying(bool isPlaying)
250 {
251     if (m_isPlaying == isPlaying)
252         return;
253
254     m_isPlaying = isPlaying;
255     m_callback.isPlayingDidChange();
256 }
257
258 // DefaultOutputUnit callback
259 OSStatus AudioDestinationIOS::inputProc(void* userData, AudioUnitRenderActionFlags*, const AudioTimeStamp*, UInt32 /*busNumber*/, UInt32 numberOfFrames, AudioBufferList* ioData)
260 {
261     AudioDestinationIOS* audioOutput = static_cast<AudioDestinationIOS*>(userData);
262     return audioOutput->render(numberOfFrames, ioData);
263 }
264
265 void AudioDestinationIOS::frameSizeChangedProc(void *inRefCon, AudioUnit, AudioUnitPropertyID, AudioUnitScope, AudioUnitElement)
266 {
267     AudioDestinationIOS* audioOutput = static_cast<AudioDestinationIOS*>(inRefCon);
268     UInt32 bufferSize = 0;
269     UInt32 dataSize = sizeof(bufferSize);
270     AudioUnitGetProperty(audioOutput->m_outputUnit, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global, 0, (void*)&bufferSize, &dataSize);
271     fprintf(stderr, ">>>> frameSizeChanged = %lu\n", static_cast<unsigned long>(bufferSize));
272 }
273
274 } // namespace WebCore
275
276 #endif // ENABLE(WEB_AUDIO) && PLATFORM(IOS)
277