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 @@
                                    float sampleRate,
                                    PassRefPtr<SecurityOrigin> securityOrigin)
     : m_callback(callback),
       m_numberOfOutputChannels(numberOfOutputChannels),
       m_inputBus(AudioBus::create(numberOfInputChannels,
                                   AudioUtilities::kRenderQuantumFrames)),
       m_renderBus(AudioBus::create(numberOfOutputChannels,
                                    AudioUtilities::kRenderQuantumFrames,
                                    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 77 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) {
+    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