Implementation of 'AudioContext.getOutputTimestamp' method

third_party/WebKit/Source/platform/audio/AudioDestination.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 52 matching lines @@
                                    unsigned numberOfInputChannels,
                                    unsigned numberOfOutputChannels,
                                    float sampleRate,
                                    PassRefPtr<SecurityOrigin> securityOrigin)
     : m_callback(callback),
       m_numberOfOutputChannels(numberOfOutputChannels),
       m_inputBus(AudioBus::create(numberOfInputChannels, renderBufferSize)),
       m_renderBus(
           AudioBus::create(numberOfOutputChannels, renderBufferSize, false)),
       m_sampleRate(sampleRate),
-      m_isPlaying(false) {
+      m_isPlaying(false),
+      m_framesElapsed(0),
+      m_outputPosition() {
   // Histogram for audioHardwareBufferSize
   DEFINE_STATIC_LOCAL(SparseHistogram, hardwareBufferSizeHistogram,
                       ("WebAudio.AudioDestination.HardwareBufferSize"));
   // Histogram for the actual callback size used.  Typically, this is the same
   // as audioHardwareBufferSize, but can be adjusted depending on some
   // heuristics below.
   DEFINE_STATIC_LOCAL(SparseHistogram, callbackBufferSizeHistogram,
                       ("WebAudio.AudioDestination.CallbackBufferSize"));
 
   // Use the optimal buffer size recommended by the audio backend.
@@ skipping 74 matching lines @@
 float AudioDestination::hardwareSampleRate() {
   return static_cast<float>(Platform::current()->audioHardwareSampleRate());
 }
 
 unsigned long AudioDestination::maxChannelCount() {
   return static_cast<float>(Platform::current()->audioHardwareOutputChannels());
 }
 
 void AudioDestination::render(const WebVector<float*>& sourceData,
                               const WebVector<float*>& audioData,
-                              size_t numberOfFrames) {
+                              size_t numberOfFrames,
+                              double delay,
+                              double delayTimestamp,
+                              size_t priorFramesSkipped) {
   bool isNumberOfChannelsGood = audioData.size() == m_numberOfOutputChannels;
   if (!isNumberOfChannelsGood) {
     ASSERT_NOT_REACHED();
     return;
   }
 
   bool isBufferSizeGood = numberOfFrames == m_callbackBufferSize;
   if (!isBufferSizeGood) {
     ASSERT_NOT_REACHED();
     return;
   }
 
+  m_framesElapsed -= std::min(m_framesElapsed, priorFramesSkipped);
+  double outputPosition =
+      m_framesElapsed / static_cast<double>(m_sampleRate) - delay;
+  m_outputPosition.position = outputPosition;
+  m_outputPosition.timestamp = delayTimestamp;
+  m_outputPositionReceivedTimestamp = base::TimeTicks::Now();
+
   // Buffer optional live input.
   if (sourceData.size() >= 2) {
     // FIXME: handle multi-channel input and don't hard-code to stereo.
     RefPtr<AudioBus> wrapperBus = AudioBus::create(2, numberOfFrames, false);
     wrapperBus->setChannelMemory(0, sourceData[0], numberOfFrames);
     wrapperBus->setChannelMemory(1, sourceData[1], numberOfFrames);
     m_inputFifo->push(wrapperBus.get());
   }
 
   for (unsigned i = 0; i < m_numberOfOutputChannels; ++i)
     m_renderBus->setChannelMemory(i, audioData[i], numberOfFrames);
 
   m_fifo->consume(m_renderBus.get(), numberOfFrames);
+
+  m_framesElapsed += numberOfFrames;
 }
 
 void AudioDestination::provideInput(AudioBus* bus, size_t framesToProcess) {
   AudioBus* sourceBus = nullptr;
   if (m_inputFifo->framesInFifo() >= framesToProcess) {
     m_inputFifo->consume(m_inputBus.get(), framesToProcess);
     sourceBus = m_inputBus.get();
   }
 
-  m_callback.render(sourceBus, bus, framesToProcess);
+  AudioIOPosition outputPosition = m_outputPosition;
+
+  // If platfrom buffer is more than two times longer than |framesToProcess|
+  // we do not want output position to get stuck so we promote it
+  // using the elapsed time from the moment it was initially obtained.
+  if (m_callbackBufferSize > framesToProcess * 2) {

[Raymond Toy, 2016/11/04 17:51:40]

What happens if framesToProcess <= m_callbackBufferSize <= 2*framesToProcess? 
(Basically 128 <= callbacksize <= 256)?  Are we guaranteed to make progress? I
don't quite understand why we don't make progress if size > 2*framesToProcess.

[Mikhail, 2016/11/07 18:28:03]

the 'outputPosition' is initialized in 'render' function call when platform
requires it, so if platform buffer is long (for example 512 frames) the '
AudioContext.currentTime' will progress for 4 times (512/128) in a row with the
same 'outputPosition' value, I put this logic here so that 'outputPosition' does
not stuck for too long. If the platform buffer is short, the 'render' function
is called frequently enough, so there is no need to estimate 'outputPosition'
value in the middle.

[miu, 2016/11/07 23:49:40]

OOC, why not unconditionally advance outputPosition.position by the number of
frames consumed from |m_inputFifo| after each m_callback.render() call? In other
words, it seems you should make sure the value for |outputPosition| is always
consistent with the first sample about to be pulled out of |m_inputFifo|. So, it
seems the diff for this entire method should be:

 void AudioDestination::provideInput(AudioBus* bus, size_t framesToProcess) {
   ...same as original...
 
-  m_callback.render(sourceBus, bus, framesToProcess);
+  m_callback.render(sourceBus, bus, framesToProcess, m_outputPosition);
+  // Finer-granularity update to |m_outputPosition| to reflect the number of
frames consumed from |m_inputFifo| above.
+  m_outputPosition.position += framesToProcess /
static_cast<double>(m_sampleRate);
 }

Then, you don't even need the m_outputPositionReceivedTimestamp/TimeTicks::Now()
hack. ;-)

[Raymond Toy, 2016/11/08 20:47:01]

Ah, that makes sense.  (Note that a huge number of Android devices have callback
buffer size of 3800 or more.)

Then in the line below, the delta is then relatively small.  For a simple graph,
wouldn't TimeTicks::Now() will have advanced just a few 10-100 micro seconds. 
Is that ok?

[Mikhail, 2016/11/28 15:15:59]

I think it is fine as long as linear estimation is correct. With the testing
graph which contains only oscillator, the delta is about 0.000167 sec on my
linux machine (which is quite powerful :) ).

[Mikhail, 2016/11/28 15:15:59]

I am more keen on accuracy, as far as I understand time of playback of certain
amount of frames (1) is not equal to the time those frames are fulfilled by the
context (2) and I'm more interested in (2) so that the user can always make a
reliable estimation of performance time from context time (or vice versa).

[miu, 2016/11/29 20:51:04]

Right, but consider:

1. The outputPosition will always be rewritten (i.e., made accurate again) very
soon in AudioDestination::render().

2. While working within the same platform buffer, it's reasonable to update the
output position based on the number of frames since the skew between the audio
hardware's clock and the system clock should be insignificant in such a short
time period.

3. TimeTicks::Now() is not necessarily cheap or unbounded. For example, on
Windows, a mutex is acquired (inside system libraries).

My other suggestion would be to simply not update the output position here at
all. Even with larger platform buffers, the semantics are still correct: This is
still a "snapshot measurement" of what the context position and performance time
were when audio was played out from the hardware in the recent past.

+    double delta = (base::TimeTicks::Now() - m_outputPositionReceivedTimestamp)
+                       .InSecondsF();
+    outputPosition.position += delta;
+    outputPosition.timestamp += delta;
+  }
+
+  // Some implementations give only rough estimation of |delay| so
+  // we might have negative estimation |outputPosition| value.
+  if (outputPosition.position < 0.0)
+    outputPosition.position = 0.0;
+
+  m_callback.render(sourceBus, bus, framesToProcess, outputPosition);
 }
 
 }  // namespace blink