Implementation of 'AudioContext.getOutputTimestamp' method

media/audio/alsa/alsa_output.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // THREAD SAFETY
 //
 // AlsaPcmOutputStream object is *not* thread-safe and should only be used
 // from the audio thread.  We DCHECK on this assumption whenever we can.
 //
 // SEMANTICS OF Close()
@@ skipping 143 matching lines @@
       bytes_per_output_frame_(bytes_per_frame_),
       alsa_buffer_frames_(0),
       stop_stream_(false),
       wrapper_(wrapper),
       manager_(manager),
       message_loop_(base::MessageLoop::current()),
       playback_handle_(NULL),
       frames_per_packet_(packet_size_ / bytes_per_frame_),
       state_(kCreated),
       volume_(1.0f),
+      elapsed_written_frames_(0),
       source_callback_(NULL),
       audio_bus_(AudioBus::Create(params)),
       weak_factory_(this) {
   DCHECK(manager_->GetTaskRunner()->BelongsToCurrentThread());
   DCHECK_EQ(audio_bus_->frames() * bytes_per_frame_, packet_size_);
 
   // Sanity check input values.
   if (!params.IsValid()) {
     LOG(WARNING) << "Unsupported audio parameters.";
     TransitionTo(kInError);
@@ skipping 108 matching lines @@
     return;
 
   // Only post the task if we can enter the playing state.
   if (TransitionTo(kIsPlaying) != kIsPlaying)
     return;
 
   // Before starting, the buffer might have audio from previous user of this
   // device.
   buffer_->Clear();
 
+  // Invalidate written frames count.
+  elapsed_written_frames_ = 0;
+
   // When starting again, drop all packets in the device and prepare it again
   // in case we are restarting from a pause state and need to flush old data.
   int error = wrapper_->PcmDrop(playback_handle_);
   if (error < 0 && error != -EAGAIN) {
     LOG(ERROR) << "Failure clearing playback device ("
                << wrapper_->PcmName(playback_handle_) << "): "
                << wrapper_->StrError(error);
     stop_stream_ = true;
     return;
   }
@@ skipping 157 matching lines @@
           RunErrorCallback(frames_written);
           stop_stream_ = true;
         }
       }
     } else {
       DCHECK_EQ(frames_written, frames);
 
       // Seek forward in the buffer after we've written some data to ALSA.
       buffer_->Seek(frames_written * bytes_per_output_frame_);
     }
+    if (frames_written)
+      elapsed_written_frames_ += frames_written;
   } else {
     // If nothing left to write and playback hasn't started yet, start it now.
     // This ensures that shorter sounds will still play.
     if (playback_handle_ &&
         (wrapper_->PcmState(playback_handle_) == SND_PCM_STATE_PREPARED) &&
         GetCurrentDelay() > 0) {
       wrapper_->PcmStart(playback_handle_);
     }
   }
 }
@@ skipping 297 matching lines @@
 }
 
 bool AlsaPcmOutputStream::IsOnAudioThread() const {
   return message_loop_ && message_loop_ == base::MessageLoop::current();
 }
 
 int AlsaPcmOutputStream::RunDataCallback(AudioBus* audio_bus,
                                          uint32_t total_bytes_delay) {
   TRACE_EVENT0("audio", "AlsaPcmOutputStream::RunDataCallback");
 
+  AudioTimestamp output_timestamp;
+  // This is quite a raugh estimation, we need to consider using
+  // snd_pcm_status_get_audio* API when it is accessible.
+  output_timestamp.frames = elapsed_written_frames_ - GetCurrentDelay();
+  output_timestamp.ticks = base::TimeTicks::Now().ToInternalValue();
+  DCHECK(output_timestamp.frames >= 0);
+
   if (source_callback_)
-    return source_callback_->OnMoreData(audio_bus, total_bytes_delay, 0);
+    return source_callback_->OnMoreData(audio_bus, total_bytes_delay, 0,
+                                        output_timestamp);
 
   return 0;
 }
 
 void AlsaPcmOutputStream::RunErrorCallback(int code) {
   if (source_callback_)
     source_callback_->OnError(this);
 }
 
 // Changes the AudioSourceCallback to proxy calls to.  Pass in NULL to
 // release ownership of the currently registered callback.
 void AlsaPcmOutputStream::set_source_callback(AudioSourceCallback* callback) {
   DCHECK(IsOnAudioThread());
   source_callback_ = callback;
 }
 
 }  // namespace media