9a4752b70864f0f32d42a610dfdef930f3150e8b
[WebKit-https.git] / Source / WebCore / platform / audio / mac / AudioSampleDataSource.mm
1 /*
2  * Copyright (C) 2017 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "AudioSampleDataSource.h"
28
29 #if ENABLE(MEDIA_STREAM)
30
31 #include "CAAudioStreamDescription.h"
32 #include "CARingBuffer.h"
33 #include "Logging.h"
34 #include <AudioToolbox/AudioConverter.h>
35 #include <mach/mach.h>
36 #include <mach/mach_time.h>
37 #include <mutex>
38 #include <pal/avfoundation/MediaTimeAVFoundation.h>
39 #include <syslog.h>
40 #include <wtf/CurrentTime.h>
41 #include <wtf/StringPrintStream.h>
42
43 #include <pal/cf/CoreMediaSoftLink.h>
44
45 namespace WebCore {
46 using namespace PAL;
47 using namespace JSC;
48
49 Ref<AudioSampleDataSource> AudioSampleDataSource::create(size_t maximumSampleCount)
50 {
51     return adoptRef(*new AudioSampleDataSource(maximumSampleCount));
52 }
53
54 AudioSampleDataSource::AudioSampleDataSource(size_t maximumSampleCount)
55     : m_inputSampleOffset(MediaTime::invalidTime())
56     , m_maximumSampleCount(maximumSampleCount)
57 {
58 }
59
60 AudioSampleDataSource::~AudioSampleDataSource()
61 {
62     m_inputDescription = nullptr;
63     m_outputDescription = nullptr;
64     m_ringBuffer = nullptr;
65     if (m_converter) {
66         AudioConverterDispose(m_converter);
67         m_converter = nullptr;
68     }
69 }
70
71 void AudioSampleDataSource::setPaused(bool paused)
72 {
73     if (paused == m_paused)
74         return;
75
76     m_transitioningFromPaused = m_paused;
77     m_paused = paused;
78 }
79
80 OSStatus AudioSampleDataSource::setupConverter()
81 {
82     ASSERT(m_inputDescription && m_outputDescription);
83
84     if (m_converter) {
85         AudioConverterDispose(m_converter);
86         m_converter = nullptr;
87     }
88
89     if (*m_inputDescription == *m_outputDescription)
90         return 0;
91
92     OSStatus err = AudioConverterNew(&m_inputDescription->streamDescription(), &m_outputDescription->streamDescription(), &m_converter);
93     if (err)
94         LOG_ERROR("AudioSampleDataSource::setupConverter(%p) - AudioConverterNew returned error %d (%.4s)", this, (int)err, (char*)&err);
95
96     return err;
97
98 }
99
100 OSStatus AudioSampleDataSource::setInputFormat(const CAAudioStreamDescription& format)
101 {
102     ASSERT(format.sampleRate() >= 0);
103
104     m_inputDescription = std::make_unique<CAAudioStreamDescription>(format);
105     if (m_outputDescription)
106         return setupConverter();
107
108     return 0;
109 }
110
111 OSStatus AudioSampleDataSource::setOutputFormat(const CAAudioStreamDescription& format)
112 {
113     ASSERT(m_inputDescription);
114     ASSERT(format.sampleRate() >= 0);
115
116     m_outputDescription = std::make_unique<CAAudioStreamDescription>(format);
117     if (!m_ringBuffer)
118         m_ringBuffer = std::make_unique<CARingBuffer>();
119
120     m_ringBuffer->allocate(format, static_cast<size_t>(m_maximumSampleCount));
121     m_scratchBuffer = AudioSampleBufferList::create(m_outputDescription->streamDescription(), m_maximumSampleCount);
122
123     return setupConverter();
124 }
125
126 MediaTime AudioSampleDataSource::hostTime() const
127 {
128     // Based on listing #2 from Apple Technical Q&A QA1398, modified to be thread-safe.
129     static double frequency;
130     static mach_timebase_info_data_t timebaseInfo;
131     static std::once_flag initializeTimerOnceFlag;
132     std::call_once(initializeTimerOnceFlag, [] {
133         kern_return_t kr = mach_timebase_info(&timebaseInfo);
134         frequency = 1e-9 * static_cast<double>(timebaseInfo.numer) / static_cast<double>(timebaseInfo.denom);
135         ASSERT_UNUSED(kr, kr == KERN_SUCCESS);
136         ASSERT(timebaseInfo.denom);
137     });
138
139     return MediaTime::createWithDouble(mach_absolute_time() * frequency);
140 }
141
142 void AudioSampleDataSource::pushSamplesInternal(const AudioBufferList& bufferList, const MediaTime& presentationTime, size_t sampleCount)
143 {
144     MediaTime sampleTime = presentationTime;
145
146     const AudioBufferList* sampleBufferList;
147     if (m_converter) {
148         m_scratchBuffer->reset();
149         OSStatus err = m_scratchBuffer->copyFrom(bufferList, sampleCount, m_converter);
150         if (err)
151             return;
152
153         sampleBufferList = m_scratchBuffer->bufferList().list();
154         sampleCount = m_scratchBuffer->sampleCount();
155         sampleTime = presentationTime.toTimeScale(m_outputDescription->sampleRate(), MediaTime::RoundingFlags::TowardZero);
156     } else
157         sampleBufferList = &bufferList;
158
159     if (m_expectedNextPushedSampleTime.isValid() && abs(m_expectedNextPushedSampleTime - sampleTime).timeValue() == 1)
160         sampleTime = m_expectedNextPushedSampleTime;
161     m_expectedNextPushedSampleTime = sampleTime + MediaTime(sampleCount, sampleTime.timeScale());
162
163     if (m_inputSampleOffset == MediaTime::invalidTime()) {
164         m_inputSampleOffset = MediaTime(1 - sampleTime.timeValue(), sampleTime.timeScale());
165         LOG(MediaCaptureSamples, "@@ pushSamples: input sample offset is %lld, m_maximumSampleCount = %zu", m_inputSampleOffset.timeValue(), m_maximumSampleCount);
166     }
167     sampleTime += m_inputSampleOffset;
168
169 #if !LOG_DISABLED
170     uint64_t startFrame1 = 0;
171     uint64_t endFrame1 = 0;
172     m_ringBuffer->getCurrentFrameBounds(startFrame1, endFrame1);
173 #endif
174
175     m_ringBuffer->store(sampleBufferList, sampleCount, sampleTime.timeValue());
176     m_lastPushedSampleCount = sampleCount;
177
178 #if !LOG_DISABLED
179     uint64_t startFrame2 = 0;
180     uint64_t endFrame2 = 0;
181     m_ringBuffer->getCurrentFrameBounds(startFrame2, endFrame2);
182     dispatch_async(dispatch_get_main_queue(), [sampleCount, sampleTime, presentationTime, absoluteTime = mach_absolute_time(), startFrame1, endFrame1, startFrame2, endFrame2] {
183         LOG(MediaCaptureSamples, "@@ pushSamples: added %ld samples for time = %s (was %s), mach time = %lld", sampleCount, toString(sampleTime).utf8().data(), toString(presentationTime).utf8().data(), absoluteTime);
184         LOG(MediaCaptureSamples, "@@ pushSamples: buffered range was [%lld .. %lld], is [%lld .. %lld]", startFrame1, endFrame1, startFrame2, endFrame2);
185     });
186 #endif
187 }
188
189 void AudioSampleDataSource::pushSamples(const AudioStreamBasicDescription& sampleDescription, CMSampleBufferRef sampleBuffer)
190 {
191     ASSERT_UNUSED(sampleDescription, *m_inputDescription == sampleDescription);
192     ASSERT(m_ringBuffer);
193     
194     WebAudioBufferList list(*m_inputDescription, sampleBuffer);
195     pushSamplesInternal(list, PAL::toMediaTime(PAL::CMSampleBufferGetPresentationTimeStamp(sampleBuffer)), PAL::CMSampleBufferGetNumSamples(sampleBuffer));
196 }
197
198 void AudioSampleDataSource::pushSamples(const MediaTime& sampleTime, const PlatformAudioData& audioData, size_t sampleCount)
199 {
200     ASSERT(is<WebAudioBufferList>(audioData));
201     pushSamplesInternal(*downcast<WebAudioBufferList>(audioData).list(), sampleTime, sampleCount);
202 }
203
204 bool AudioSampleDataSource::pullSamplesInternal(AudioBufferList& buffer, size_t& sampleCount, uint64_t timeStamp, double /*hostTime*/, PullMode mode)
205 {
206     size_t byteCount = sampleCount * m_outputDescription->bytesPerFrame();
207
208     ASSERT(buffer.mNumberBuffers == m_ringBuffer->channelCount());
209     if (buffer.mNumberBuffers != m_ringBuffer->channelCount()) {
210         AudioSampleBufferList::zeroABL(buffer, byteCount);
211         sampleCount = 0;
212         return false;
213     }
214
215     if (!m_ringBuffer || m_muted || m_inputSampleOffset == MediaTime::invalidTime()) {
216         AudioSampleBufferList::zeroABL(buffer, byteCount);
217         sampleCount = 0;
218         return false;
219     }
220
221     uint64_t startFrame = 0;
222     uint64_t endFrame = 0;
223     m_ringBuffer->getCurrentFrameBounds(startFrame, endFrame);
224
225     if (m_transitioningFromPaused) {
226         uint64_t buffered = endFrame - startFrame;
227         if (buffered < sampleCount * 2) {
228             AudioSampleBufferList::zeroABL(buffer, byteCount);
229             sampleCount = 0;
230             return false;
231         }
232
233         const double twentyMS = .02;
234         const double tenMS = .01;
235         const double fiveMS = .005;
236         double sampleRate = m_outputDescription->sampleRate();
237         m_outputSampleOffset = (endFrame - sampleCount) - timeStamp;
238         if (m_lastPushedSampleCount > sampleRate * twentyMS)
239             m_outputSampleOffset -= sampleRate * twentyMS;
240         else if (m_lastPushedSampleCount > sampleRate * tenMS)
241             m_outputSampleOffset -= sampleRate * tenMS;
242         else if (m_lastPushedSampleCount > sampleRate * fiveMS)
243             m_outputSampleOffset -= sampleRate * fiveMS;
244
245         m_transitioningFromPaused = false;
246     }
247
248     timeStamp += m_outputSampleOffset;
249
250 #if !LOG_DISABLED
251     dispatch_async(dispatch_get_main_queue(), [sampleCount, timeStamp, sampleOffset = m_outputSampleOffset] {
252         LOG(MediaCaptureSamples, "** pullSamples: asking for %ld samples at time = %lld (was %lld)", sampleCount, timeStamp, timeStamp - sampleOffset);
253     });
254 #endif
255
256     uint64_t framesAvailable = sampleCount;
257     if (timeStamp < startFrame || timeStamp + sampleCount > endFrame) {
258         if (timeStamp + sampleCount < startFrame || timeStamp > endFrame)
259             framesAvailable = 0;
260         else if (timeStamp < startFrame)
261             framesAvailable = timeStamp + sampleCount - startFrame;
262         else
263             framesAvailable = timeStamp + sampleCount - endFrame;
264
265 #if !LOG_DISABLED
266         dispatch_async(dispatch_get_main_queue(), [timeStamp, startFrame, endFrame, framesAvailable] {
267             LOG(MediaCaptureSamples, "** pullSamplesInternal: sample %lld is not completely in range [%lld .. %lld], returning %lld frames", timeStamp, startFrame, endFrame, framesAvailable);
268         });
269 #endif
270
271         if (framesAvailable < sampleCount) {
272             m_outputSampleOffset -= sampleCount - framesAvailable;
273             AudioSampleBufferList::zeroABL(buffer, byteCount);
274             return false;
275         }
276     }
277
278     m_ringBuffer->fetch(&buffer, sampleCount, timeStamp, mode == Copy ? CARingBuffer::Copy : CARingBuffer::Mix);
279
280     if (m_volume < .95)
281         AudioSampleBufferList::applyGain(buffer, m_volume, m_outputDescription->format());
282
283     return true;
284 }
285
286 bool AudioSampleDataSource::pullAvalaibleSamplesAsChunks(AudioBufferList& buffer, size_t sampleCountPerChunk, uint64_t timeStamp, Function<void()>&& consumeFilledBuffer)
287 {
288     if (!m_ringBuffer)
289         return false;
290
291     ASSERT(buffer.mNumberBuffers == m_ringBuffer->channelCount());
292     if (buffer.mNumberBuffers != m_ringBuffer->channelCount())
293         return false;
294
295     uint64_t startFrame = 0;
296     uint64_t endFrame = 0;
297     m_ringBuffer->getCurrentFrameBounds(startFrame, endFrame);
298     if (m_transitioningFromPaused) {
299         m_outputSampleOffset = timeStamp + (endFrame - sampleCountPerChunk);
300         m_transitioningFromPaused = false;
301     }
302
303     timeStamp += m_outputSampleOffset;
304
305     if (timeStamp < startFrame)
306         timeStamp = startFrame;
307
308     startFrame = timeStamp;
309
310     if (m_muted) {
311         AudioSampleBufferList::zeroABL(buffer, sampleCountPerChunk * m_outputDescription->bytesPerFrame());
312         while (endFrame - startFrame >= sampleCountPerChunk) {
313             consumeFilledBuffer();
314             startFrame += sampleCountPerChunk;
315         }
316         return true;
317     }
318
319     while (endFrame - startFrame >= sampleCountPerChunk) {
320         if (m_ringBuffer->fetch(&buffer, sampleCountPerChunk, startFrame, CARingBuffer::Copy))
321             return false;
322         consumeFilledBuffer();
323         startFrame += sampleCountPerChunk;
324     }
325     return true;
326 }
327
328 bool AudioSampleDataSource::pullSamples(AudioBufferList& buffer, size_t sampleCount, uint64_t timeStamp, double hostTime, PullMode mode)
329 {
330     if (!m_ringBuffer) {
331         size_t byteCount = sampleCount * m_outputDescription->bytesPerFrame();
332         AudioSampleBufferList::zeroABL(buffer, byteCount);
333         return false;
334     }
335
336     return pullSamplesInternal(buffer, sampleCount, timeStamp, hostTime, mode);
337 }
338
339 bool AudioSampleDataSource::pullSamples(AudioSampleBufferList& buffer, size_t sampleCount, uint64_t timeStamp, double hostTime, PullMode mode)
340 {
341     if (!m_ringBuffer) {
342         buffer.zero();
343         return false;
344     }
345
346     if (!pullSamplesInternal(buffer.bufferList(), sampleCount, timeStamp, hostTime, mode))
347         return false;
348
349     buffer.setTimes(timeStamp, hostTime);
350     buffer.setSampleCount(sampleCount);
351
352     return true;
353 }
354
355 } // namespace WebCore
356
357 #endif // ENABLE(MEDIA_STREAM)