MSE: Log buffered audio splice generation to media-internals

media/filters/source_buffer_stream.cc

 // Copyright (c) 2012 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 "media/filters/source_buffer_stream.h"
 
 #include <algorithm>
 #include <map>
 #include <sstream>
 
@@ skipping 1530 matching lines @@
           splice_dts, max_splice_end_dts, &pre_splice_buffers)) {
     return;
   }
 
   // If there are gaps in the timeline, it's possible that we only find buffers
   // after the splice point but within the splice range.  For simplicity, we do
   // not generate splice frames in this case.
   //
   // We also do not want to generate splices if the first new buffer replaces an
   // existing buffer exactly.
-  if (pre_splice_buffers.front()->timestamp() >= splice_timestamp)
+  if (pre_splice_buffers.front()->timestamp() >= splice_timestamp) {
+    LogDegenerateSplice();
     return;
+  }
 
   // If any |pre_splice_buffers| are already splices or preroll, do not generate
   // a splice.
   for (size_t i = 0; i < pre_splice_buffers.size(); ++i) {
     const BufferQueue& original_splice_buffers =
         pre_splice_buffers[i]->splice_buffers();
     if (!original_splice_buffers.empty()) {
       DVLOG(1) << "Can't generate splice: overlapped buffers contain a "
                   "pre-existing splice.";
+      LogDegenerateSplice();
       return;
     }
 
     if (pre_splice_buffers[i]->preroll_buffer().get()) {
       DVLOG(1) << "Can't generate splice: overlapped buffers contain preroll.";
+      LogDegenerateSplice();
       return;
     }
   }
 
   // Don't generate splice frames which represent less than a millisecond (which
   // is frequently the extent of timestamp resolution for poorly encoded media)
   // or less than two frames (need at least two to crossfade).
   const base::TimeDelta splice_duration =
       pre_splice_buffers.back()->timestamp() +
       pre_splice_buffers.back()->duration() - splice_timestamp;
   const base::TimeDelta minimum_splice_duration = std::max(
       base::TimeDelta::FromMilliseconds(1),
       base::TimeDelta::FromSecondsD(
           2.0 / audio_configs_[append_config_index_].samples_per_second()));
   if (splice_duration < minimum_splice_duration) {
     DVLOG(1) << "Can't generate splice: not enough samples for crossfade; have "
              << splice_duration.InMicroseconds() << " us, but need "
              << minimum_splice_duration.InMicroseconds() << " us.";
+    LogDegenerateSplice();
     return;
   }
 
   DVLOG(1) << "Generating splice frame @ " << new_buffers.front()->timestamp()
            << ", splice duration: " << splice_duration.InMicroseconds()
            << " us";
+  LogSplice(splice_duration.InSecondsF());
   new_buffers.front()->ConvertToSpliceBuffer(pre_splice_buffers);
 }
 
 bool SourceBufferStream::SetPendingBuffer(
     scoped_refptr<StreamParserBuffer>* out_buffer) {
   DCHECK(out_buffer->get());
   DCHECK(!pending_buffer_.get());
 
   const bool have_splice_buffers = !(*out_buffer)->splice_buffers().empty();
   const bool have_preroll_buffer = !!(*out_buffer)->preroll_buffer().get();
 
   if (!have_splice_buffers && !have_preroll_buffer)
     return false;
 
   DCHECK_NE(have_splice_buffers, have_preroll_buffer);
   splice_buffers_index_ = 0;
   pending_buffer_.swap(*out_buffer);
   pending_buffers_complete_ = false;
   return true;
 }
 
+void SourceBufferStream::LogSplice(double splice_duration) {
+  splice_stats_.OnSplice(splice_duration);
+  media_log_->AddEvent(
+      media_log_->CreateBufferedSpliceStatisticsChangedEvent(splice_stats_));
+}
+
+void SourceBufferStream::LogDegenerateSplice() {
+  splice_stats_.OnDegenerateSplice();
+  media_log_->AddEvent(
+      media_log_->CreateBufferedSpliceStatisticsChangedEvent(splice_stats_));
+}
+
 }  // namespace media