[Chromecast] Make ALSA rendering delay either accurate or kNoTimestamp

chromecast/media/cma/backend/alsa/stream_mixer_alsa.cc

 // Copyright 2015 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.
 
 #include "chromecast/media/cma/backend/alsa/stream_mixer_alsa.h"
 
 #include <algorithm>
 #include <cmath>
+#include <limits>
 #include <utility>
 
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 83 matching lines @@
 // direction they adjusted the requested parameter in, but since we read the
 // output param and then log the information, this module doesn't need to get
 // the direction explicitly.
 static int* kAlsaDirDontCare = nullptr;
 
 // These sample formats will be tried in order. 32 bit samples is ideal, but
 // some devices do not support 32 bit samples.
 const snd_pcm_format_t kPreferredSampleFormats[] = {SND_PCM_FORMAT_S32,
                                                     SND_PCM_FORMAT_S16};
 
+const int64_t kNoTimestamp = std::numeric_limits<int64_t>::min();
+
 int64_t TimespecToMicroseconds(struct timespec time) {
   return static_cast<int64_t>(time.tv_sec) *
              base::Time::kMicrosecondsPerSecond +
          time.tv_nsec / 1000;
 }
 
 bool GetSwitchValueAsInt(const std::string& switch_name,
                          int default_value,
                          int* value) {
   DCHECK(value);
@@ skipping 405 matching lines @@
   }
 
   if (post_loopback_filter_) {
     post_loopback_filter_->SetSampleRateAndFormat(
         output_samples_per_second_, ::media::SampleFormat::kSampleFormatS32);
   }
 
   RETURN_REPORT_ERROR(PcmPrepare, pcm_);
   RETURN_REPORT_ERROR(PcmStatusMalloc, &pcm_status_);
 
-  struct timespec now = {0, 0};
-  clock_gettime(CLOCK_MONOTONIC_RAW, &now);
-  rendering_delay_.timestamp_microseconds = TimespecToMicroseconds(now);
+  rendering_delay_.timestamp_microseconds = kNoTimestamp;
   rendering_delay_.delay_microseconds = 0;
 
   state_ = kStateNormalPlayback;
 }
 
 void StreamMixerAlsa::Stop() {
   for (auto* observer : loopback_observers_) {
     observer->OnLoopbackInterrupted();
   }
 
@@ skipping 272 matching lines @@
                                     int frames) {
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
   CHECK_PCM_INITIALIZED();
 
   size_t interleaved_size = static_cast<size_t>(frames * kNumOutputChannels) *
                             BytesPerOutputFormatSample();
   if (interleaved_.size() < interleaved_size) {
     interleaved_.resize(interleaved_size);
   }
 
-  int64_t expected_playback_time = rendering_delay_.timestamp_microseconds +
-                                   rendering_delay_.delay_microseconds;
+  int64_t expected_playback_time;
+  if (rendering_delay_.timestamp_microseconds == kNoTimestamp) {
+    expected_playback_time = kNoTimestamp;
+  } else {
+    expected_playback_time = rendering_delay_.timestamp_microseconds +
+                             rendering_delay_.delay_microseconds;
+  }
+
   mixed.ToInterleaved(frames, BytesPerOutputFormatSample(),
                       interleaved_.data());
   // Filter, send to observers, and post filter
   if (pre_loopback_filter_) {
     pre_loopback_filter_->ProcessInterleaved(interleaved_.data(), frames);
   }
 
   for (CastMediaShlib::LoopbackAudioObserver* observer : loopback_observers_) {
     observer->OnLoopbackAudio(expected_playback_time, kSampleFormatS32,
                               output_samples_per_second_, kNumOutputChannels,
@@ skipping 27 matching lines @@
   }
   UpdateRenderingDelay(frames);
   for (auto&& input : inputs_)
     input->AfterWriteFrames(rendering_delay_);
 }
 
 void StreamMixerAlsa::UpdateRenderingDelay(int newly_pushed_frames) {
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
   CHECK_PCM_INITIALIZED();
 
-  if (alsa_->PcmStatus(pcm_, pcm_status_) != 0) {
-    // Estimate updated delay based on the number of frames we just pushed.
-    rendering_delay_.delay_microseconds +=
-        static_cast<int64_t>(newly_pushed_frames) *
-        base::Time::kMicrosecondsPerSecond / output_samples_per_second_;
+  if (alsa_->PcmStatus(pcm_, pcm_status_) != 0 ||
+      alsa_->PcmStatusGetState(pcm_status_) != SND_PCM_STATE_RUNNING) {
+    rendering_delay_.timestamp_microseconds = kNoTimestamp;
+    rendering_delay_.delay_microseconds = 0;
     return;
   }
 
   snd_htimestamp_t status_timestamp;
   alsa_->PcmStatusGetHtstamp(pcm_status_, &status_timestamp);
   rendering_delay_.timestamp_microseconds =
       TimespecToMicroseconds(status_timestamp);
   snd_pcm_sframes_t delay_frames = alsa_->PcmStatusGetDelay(pcm_status_);
   rendering_delay_.delay_microseconds = static_cast<int64_t>(delay_frames) *
                                         base::Time::kMicrosecondsPerSecond /
@@ skipping 15 matching lines @@
   DCHECK(std::find(loopback_observers_.begin(), loopback_observers_.end(),
                    observer) != loopback_observers_.end());
   loopback_observers_.erase(std::remove(loopback_observers_.begin(),
                                         loopback_observers_.end(), observer),
                             loopback_observers_.end());
   observer->OnRemoved();
 }
 
 }  // namespace media
 }  // namespace chromecast