[Chromecast] Log playback stall event.

chromecast/media/cma/pipeline/media_pipeline_impl.cc

 // Copyright 2014 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/pipeline/media_pipeline_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 69 matching lines @@
 MediaPipelineImpl::MediaPipelineImpl()
     : cdm_(nullptr),
       backend_state_(BACKEND_STATE_UNINITIALIZED),
       playback_rate_(1.0f),
       audio_decoder_(nullptr),
       video_decoder_(nullptr),
       pending_time_update_task_(false),
       statistics_rolling_counter_(0),
       audio_bytes_for_bitrate_estimation_(0),
       video_bytes_for_bitrate_estimation_(0),
+      playback_stalled_(false),
+      playback_stalled_notification_sent_(false),
       weak_factory_(this) {
   CMALOG(kLogControl) << __FUNCTION__;
   weak_this_ = weak_factory_.GetWeakPtr();
   thread_checker_.DetachFromThread();
 }
 
 MediaPipelineImpl::~MediaPipelineImpl() {
   CMALOG(kLogControl) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 316 matching lines @@
     metrics::CastMetricsHelper::GetInstance()->RecordApplicationEvent(
         "Cast.Platform.Pause");
   } else if (!is_buffering && (backend_state_ == BACKEND_STATE_PAUSED)) {
     // Once we finish buffering, we need to honour the desired playback rate
     // (rather than just resuming). This way, if playback was paused while
     // buffering, it will remain paused rather than incorrectly resuming.
     SetPlaybackRate(playback_rate_);
   }
 }
 
+void MediaPipelineImpl::CheckForPlaybackStall(base::TimeDelta media_time,
+                                              base::TimeTicks current_stc) {

[alokp, 2016/06/02 00:09:33]

DCHECK(media_time >= last_media_time)

[ejason, 2016/06/03 16:48:47]

I added this DCHECK but during my local longevity tests it appears that this
assumption doesn't hold (i.e., I hit the DCHECK). I didn't debug further. 

While I wouldn't expect this condition either, I think the initial if-condition
that checks that media_time != last_media_time should handle this gracefully (it
either no-ops or resets stall state and returns). Further, we only use the stc
value for calculations. 

I did add a DCHECK for media_time != ::media::kNoTimestamp as the code as
written should only be called with a valid media_time. 

+  // Check to see if a stall condition exists. If not, check to see if we need
+  // to transition out of the previous stall condition.
+  if (media_time != last_media_time_) {
+    if (playback_stalled_) {
+      // Transition out of the stalled condition.
+      base::TimeDelta stall_duration = current_stc - playback_stalled_time_;
+      LOG(INFO) << "Transitioning out of stalled state. Stall duration was "

[alokp, 2016/06/02 00:09:33]

LOG(INFO) -> CMALOG

[ejason, 2016/06/03 16:48:47]

Done.

+                << stall_duration.InMilliseconds() << " ms";
+      playback_stalled_ = false;
+      playback_stalled_notification_sent_ = false;
+    }
+    return;
+  }
+
+  // Check to see if this is a new stall condition.
+  if (!playback_stalled_) {
+    playback_stalled_ = true;
+    playback_stalled_time_ = current_stc;
+    return;
+  }
+
+  // If we are in an existing stall, check to see if we've been stalled for more
+  // than 2.5 s. If so, send a single notification of the stall event.
+  if (!playback_stalled_notification_sent_) {
+    base::TimeDelta current_stall_duration =
+        current_stc - playback_stalled_time_;
+    if (current_stall_duration.InMilliseconds() >= 2500) {

[alokp, 2016/06/02 00:09:33]

move 2500 into a constant.

[ejason, 2016/06/03 16:48:47]

Done.

+      LOG(INFO) << "Playback stalled";
+      metrics::CastMetricsHelper::GetInstance()->RecordApplicationEvent(
+          "Cast.Platform.PlaybackStall");
+      playback_stalled_notification_sent_ = true;
+    }
+    return;
+  }
+}
+
 void MediaPipelineImpl::UpdateMediaTime() {

[alokp, 2016/06/02 00:09:33]

verify that this is not scheduled when playback_rate = 0. Otherwise you will log
false stall events.

[ejason, 2016/06/03 16:48:47]

I reviewed the code and it appears to be the case. That said, I added explicit
checks to CheckForPlaybackStall() for this case and the case where we are
buffering, as we have another metric for the buffering_controller case. 

   pending_time_update_task_ = false;
   if ((backend_state_ != BACKEND_STATE_PLAYING) &&
       (backend_state_ != BACKEND_STATE_PAUSED))
     return;
 
   if (statistics_rolling_counter_ == 0) {
     if (audio_pipeline_)
       audio_pipeline_->UpdateStatistics();
     if (video_pipeline_)
       video_pipeline_->UpdateStatistics();
@@ skipping 29 matching lines @@
       media_pipeline_backend_->GetCurrentPts());
   if (media_time == ::media::kNoTimestamp()) {
     pending_time_update_task_ = true;
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, base::Bind(&MediaPipelineImpl::UpdateMediaTime, weak_this_),
         kTimeUpdateInterval);
     return;
   }
   base::TimeTicks stc = base::TimeTicks::Now();
 
+  CheckForPlaybackStall(media_time, stc);
+
   base::TimeDelta max_rendering_time = media_time;
   if (buffering_controller_) {
     buffering_controller_->SetMediaTime(media_time);
 
     // Receiving the same time twice in a row means playback isn't moving,
     // so don't interpolate ahead.
     if (media_time != last_media_time_) {
       max_rendering_time = buffering_controller_->GetMaxRenderingTime();
       if (max_rendering_time == ::media::kNoTimestamp())
         max_rendering_time = media_time;
@@ skipping 27 matching lines @@
 
 void MediaPipelineImpl::ResetBitrateState() {
   elapsed_time_delta_ = base::TimeDelta::FromSeconds(0);
   audio_bytes_for_bitrate_estimation_ = 0;
   video_bytes_for_bitrate_estimation_ = 0;
   last_sample_time_ = base::TimeTicks::Now();
 }
 
 }  // namespace media
 }  // namespace chromecast