[Mac] Add classes to manage audio samples
[WebKit-https.git] / Source / WebCore / platform / audio / mac / AudioSampleDataSource.cpp
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 "MediaTimeAVFoundation.h"
35 #include <AudioToolbox/AudioConverter.h>
36 #include <mach/mach.h>
37 #include <mach/mach_time.h>
38 #include <mutex>
39 #include <syslog.h>
40 #include <wtf/CurrentTime.h>
41 #include <wtf/StringPrintStream.h>
42
43 #include "CoreMediaSoftLink.h"
44
45 namespace WebCore {
46
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     std::lock_guard<Lock> lock(m_lock);
74
75     if (paused == m_paused)
76         return;
77
78     m_transitioningFromPaused = m_paused;
79     m_paused = paused;
80 }
81
82 OSStatus AudioSampleDataSource::setupConverter()
83 {
84     ASSERT(m_inputDescription && m_outputDescription);
85
86     if (m_converter) {
87         AudioConverterDispose(m_converter);
88         m_converter = nullptr;
89     }
90
91     if (*m_inputDescription == *m_outputDescription)
92         return 0;
93
94     OSStatus err = AudioConverterNew(&m_inputDescription->streamDescription(), &m_outputDescription->streamDescription(), &m_converter);
95     if (err)
96         LOG_ERROR("AudioSampleDataSource::setupConverter(%p) - AudioConverterNew returned error %d (%.4s)", this, err, (char*)&err);
97
98     return err;
99
100 }
101
102 OSStatus AudioSampleDataSource::setInputFormat(const CAAudioStreamDescription& format)
103 {
104     ASSERT(format.sampleRate() >= 0);
105
106     m_inputDescription = std::make_unique<CAAudioStreamDescription>(format);
107     if (m_outputDescription)
108         return setupConverter();
109
110     return 0;
111 }
112
113 OSStatus AudioSampleDataSource::setOutputFormat(const CAAudioStreamDescription& format)
114 {
115     ASSERT(m_inputDescription);
116     ASSERT(format.sampleRate() >= 0);
117
118     m_outputDescription = std::make_unique<CAAudioStreamDescription>(format);
119     if (!m_ringBuffer)
120         m_ringBuffer = std::make_unique<CARingBuffer>();
121
122     m_ringBuffer->allocate(format, static_cast<size_t>(m_maximumSampleCount));
123     m_scratchBuffer = AudioSampleBufferList::create(m_outputDescription->streamDescription(), m_maximumSampleCount);
124
125     return setupConverter();
126 }
127
128 MediaTime AudioSampleDataSource::hostTime() const
129 {
130     // Based on listing #2 from Apple Technical Q&A QA1398, modified to be thread-safe.
131     static double frequency;
132     static mach_timebase_info_data_t timebaseInfo;
133     static std::once_flag initializeTimerOnceFlag;
134     std::call_once(initializeTimerOnceFlag, [] {
135         kern_return_t kr = mach_timebase_info(&timebaseInfo);
136         frequency = 1e-9 * static_cast<double>(timebaseInfo.numer) / static_cast<double>(timebaseInfo.denom);
137         ASSERT_UNUSED(kr, kr == KERN_SUCCESS);
138         ASSERT(timebaseInfo.denom);
139     });
140
141     return MediaTime::createWithDouble(mach_absolute_time() * frequency);
142 }
143
144 void AudioSampleDataSource::pushSamplesInternal(AudioBufferList& bufferList, const MediaTime& presentationTime, size_t sampleCount)
145 {
146     ASSERT(m_lock.isHeld());
147
148     AudioBufferList* sampleBufferList;
149     if (m_converter) {
150         m_scratchBuffer->reset();
151         OSStatus err = m_scratchBuffer->copyFrom(bufferList, m_converter);
152         if (err)
153             return;
154
155         sampleBufferList = &m_scratchBuffer->bufferList();
156     } else
157         sampleBufferList = &bufferList;
158
159     MediaTime sampleTime = presentationTime;
160     if (m_inputSampleOffset == MediaTime::invalidTime()) {
161         m_inputSampleOffset = MediaTime(1 - sampleTime.timeValue(), sampleTime.timeScale());
162         if (m_inputSampleOffset.timeScale() != sampleTime.timeScale()) {
163             // FIXME: It should be possible to do this without calling CMTimeConvertScale.
164             m_inputSampleOffset = toMediaTime(CMTimeConvertScale(toCMTime(m_inputSampleOffset), sampleTime.timeScale(), kCMTimeRoundingMethod_Default));
165         }
166         LOG(MediaCaptureSamples, "@@ pushSamples: input sample offset is %lld, m_maximumSampleCount = %zu", m_inputSampleOffset.timeValue(), m_maximumSampleCount);
167     }
168     sampleTime += m_inputSampleOffset;
169
170 #if !LOG_DISABLED
171     uint64_t startFrame1 = 0;
172     uint64_t endFrame1 = 0;
173     m_ringBuffer->getCurrentFrameBounds(startFrame1, endFrame1);
174 #endif
175
176     m_ringBuffer->store(sampleBufferList, sampleCount, sampleTime.timeValue());
177     m_timeStamp = sampleTime.timeValue();
178
179     LOG(MediaCaptureSamples, "@@ pushSamples: added %ld samples for time = %s (was %s), mach time = %lld", sampleCount, toString(sampleTime).utf8().data(), toString(presentationTime).utf8().data(), mach_absolute_time());
180
181 #if !LOG_DISABLED
182     uint64_t startFrame2 = 0;
183     uint64_t endFrame2 = 0;
184     m_ringBuffer->getCurrentFrameBounds(startFrame2, endFrame2);
185     LOG(MediaCaptureSamples, "@@ pushSamples: buffered range was [%lld .. %lld], is [%lld .. %lld]", startFrame1, endFrame1, startFrame2, endFrame2);
186 #endif
187 }
188
189 void AudioSampleDataSource::pushSamples(const AudioStreamBasicDescription& sampleDescription, CMSampleBufferRef sampleBuffer)
190 {
191     std::lock_guard<Lock> lock(m_lock);
192
193     ASSERT_UNUSED(sampleDescription, *m_inputDescription == sampleDescription);
194     ASSERT(m_ringBuffer);
195
196     size_t bufferSize = AudioSampleBufferList::audioBufferListSizeForStream(*m_inputDescription.get());
197     uint8_t bufferData[bufferSize];
198     AudioBufferList* bufferList = reinterpret_cast<AudioBufferList*>(bufferData);
199     bufferList->mNumberBuffers = m_inputDescription->numberOfInterleavedChannels();
200
201     CMBlockBufferRef buffer = nullptr;
202     OSStatus err = CMSampleBufferGetAudioBufferListWithRetainedBlockBuffer(sampleBuffer, nullptr, bufferList, bufferSize, kCFAllocatorSystemDefault, kCFAllocatorSystemDefault, kCMSampleBufferFlag_AudioBufferList_Assure16ByteAlignment, &buffer);
203     if (err) {
204         LOG_ERROR("AudioSampleDataSource::pushSamples(%p) - CMSampleBufferGetAudioBufferListWithRetainedBlockBuffer returned error %d (%.4s)", this, err, (char*)&err);
205         return;
206     }
207
208     pushSamplesInternal(*bufferList, toMediaTime(CMSampleBufferGetPresentationTimeStamp(sampleBuffer)), CMSampleBufferGetNumSamples(sampleBuffer));
209 }
210
211 void AudioSampleDataSource::pushSamples(const AudioStreamBasicDescription& sampleDescription, const MediaTime& sampleTime, void* audioData, size_t sampleCount)
212 {
213     std::unique_lock<Lock> lock(m_lock, std::try_to_lock);
214     ASSERT(*m_inputDescription == sampleDescription);
215
216     CAAudioStreamDescription description(sampleDescription);
217     size_t bufferSize = AudioSampleBufferList::audioBufferListSizeForStream(description);
218     uint8_t bufferData[bufferSize];
219     AudioBufferList* bufferList = reinterpret_cast<AudioBufferList*>(bufferData);
220
221     AudioSampleBufferList::configureBufferListForStream(*bufferList, description, reinterpret_cast<uint8_t*>(audioData), sampleCount);
222     pushSamplesInternal(*bufferList, sampleTime, sampleCount);
223 }
224
225 bool AudioSampleDataSource::pullSamplesInternal(AudioBufferList& buffer, size_t& sampleCount, uint64_t timeStamp, double /*hostTime*/, PullMode mode)
226 {
227     ASSERT(m_lock.isHeld());
228
229     ASSERT(buffer.mNumberBuffers == m_ringBuffer->channelCount());
230     if (buffer.mNumberBuffers != m_ringBuffer->channelCount()) {
231         AudioSampleBufferList::zeroABL(buffer, sampleCount);
232         sampleCount = 0;
233         return false;
234     }
235
236     if (!m_ringBuffer || m_muted || m_inputSampleOffset == MediaTime::invalidTime()) {
237         AudioSampleBufferList::zeroABL(buffer, sampleCount);
238         sampleCount = 0;
239         return false;
240     }
241
242     uint64_t startFrame = 0;
243     uint64_t endFrame = 0;
244     m_ringBuffer->getCurrentFrameBounds(startFrame, endFrame);
245
246     if (m_transitioningFromPaused) {
247         uint64_t buffered = endFrame - m_timeStamp;
248         if (buffered < sampleCount * 2) {
249             AudioSampleBufferList::zeroABL(buffer, sampleCount);
250             sampleCount = 0;
251             return false;
252         }
253
254         const double twentyMS = .02;
255         const double tenMS = .01;
256         const double fiveMS = .005;
257         double sampleRate = m_outputDescription->sampleRate();
258         if (buffered > sampleRate * twentyMS)
259             m_outputSampleOffset = m_timeStamp - sampleRate * twentyMS;
260         else if (buffered > sampleRate * tenMS)
261             m_outputSampleOffset = m_timeStamp - sampleRate * tenMS;
262         else if (buffered > sampleRate * fiveMS)
263             m_outputSampleOffset = m_timeStamp - sampleRate * fiveMS;
264         else
265             m_outputSampleOffset = m_timeStamp;
266
267         m_transitioningFromPaused = false;
268     }
269
270     timeStamp += m_outputSampleOffset;
271
272     LOG(MediaCaptureSamples, "** pullSamples: asking for %ld samples at time = %lld (was %lld)", sampleCount, timeStamp, timeStamp - m_outputSampleOffset);
273
274     int64_t framesAvailable = sampleCount;
275     if (timeStamp < startFrame || timeStamp + sampleCount > endFrame) {
276         if (timeStamp + sampleCount < startFrame || timeStamp > endFrame)
277             framesAvailable = 0;
278         else if (timeStamp < startFrame)
279             framesAvailable = timeStamp + sampleCount - startFrame;
280         else
281             framesAvailable = timeStamp + sampleCount - endFrame;
282
283         LOG(MediaCaptureSamples, "** pullSamplesInternal: sample %lld is not completely in range [%lld .. %lld], returning %lld frames", timeStamp, startFrame, endFrame, framesAvailable);
284
285         if (!framesAvailable) {
286             AudioSampleBufferList::zeroABL(buffer, sampleCount);
287             return false;
288         }
289     }
290
291     if (m_volume >= .95) {
292         m_ringBuffer->fetch(&buffer, sampleCount, timeStamp, mode == Copy ? CARingBuffer::Copy : CARingBuffer::Mix);
293         return true;
294     }
295
296     if (m_scratchBuffer->copyFrom(*m_ringBuffer.get(), sampleCount, timeStamp, mode == Copy ? CARingBuffer::Copy : CARingBuffer::Mix)) {
297         AudioSampleBufferList::zeroABL(buffer, sampleCount);
298         return false;
299     }
300
301     m_scratchBuffer->applyGain(m_volume);
302     if (m_scratchBuffer->copyTo(buffer, sampleCount))
303         AudioSampleBufferList::zeroABL(buffer, sampleCount);
304
305     return true;
306 }
307
308 bool AudioSampleDataSource::pullSamples(AudioBufferList& buffer, size_t sampleCount, uint64_t timeStamp, double hostTime, PullMode mode)
309 {
310     std::unique_lock<Lock> lock(m_lock, std::try_to_lock);
311     if (!lock.owns_lock() || !m_ringBuffer) {
312         AudioSampleBufferList::zeroABL(buffer, sampleCount);
313         return false;
314     }
315
316     return pullSamplesInternal(buffer, sampleCount, timeStamp, hostTime, mode);
317 }
318
319 bool AudioSampleDataSource::pullSamples(AudioSampleBufferList& buffer, size_t sampleCount, uint64_t timeStamp, double hostTime, PullMode mode)
320 {
321     std::unique_lock<Lock> lock(m_lock, std::try_to_lock);
322     if (!lock.owns_lock() || !m_ringBuffer) {
323         buffer.zero();
324         return false;
325     }
326
327     if (!pullSamplesInternal(buffer.bufferList(), sampleCount, timeStamp, hostTime, mode))
328         return false;
329
330     buffer.setTimes(timeStamp, hostTime);
331     buffer.setSampleCount(sampleCount);
332
333     return true;
334 }
335
336 } // namespace WebCore
337
338 #endif // ENABLE(MEDIA_STREAM)