MSE: Log a warning if muxed AV media segment has no A or has no V block

media/filters/media_source_state.cc

 // Copyright (c) 2016 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/media_source_state.h"
 
 #include "base/callback_helpers.h"
 #include "base/stl_util.h"
 #include "media/filters/chunk_demuxer.h"
 #include "media/filters/frame_processor.h"
 #include "media/filters/source_buffer_stream.h"
 
 namespace media {
 
+enum {
+  // Limits the number of MEDIA_LOG() calls warning the user that a muxed stream
+  // media segment is missing a block from at least one of the audio or video
+  // tracks.
+  kMaxMissingTrackInSegmentLogs = 10,
+};
+
 static TimeDelta EndTimestamp(const StreamParser::BufferQueue& queue) {
   return queue.back()->timestamp() + queue.back()->duration();
 }
 
 // List of time ranges for each SourceBuffer.
 // static
 Ranges<TimeDelta> MediaSourceState::ComputeRangesIntersection(
     const RangesList& activeRanges,
     bool ended) {
   // TODO(servolk): Perhaps this can be removed in favor of blink implementation
@@ skipping 53 matching lines @@
 
 MediaSourceState::MediaSourceState(
     scoped_ptr<StreamParser> stream_parser,
     scoped_ptr<FrameProcessor> frame_processor,
     const CreateDemuxerStreamCB& create_demuxer_stream_cb,
     const scoped_refptr<MediaLog>& media_log)
     : create_demuxer_stream_cb_(create_demuxer_stream_cb),
       timestamp_offset_during_append_(NULL),
       new_media_segment_(false),
       parsing_media_segment_(false),
+      media_segment_contained_audio_frame_(false),
+      media_segment_contained_video_frame_(false),
       stream_parser_(stream_parser.release()),
       audio_(NULL),
       video_(NULL),
       frame_processor_(frame_processor.release()),
       media_log_(media_log),
       auto_update_timestamp_offset_(false) {
   DCHECK(!create_demuxer_stream_cb_.is_null());
   DCHECK(frame_processor_);
 }
 
@@ skipping 75 matching lines @@
   DCHECK(!timestamp_offset_during_append_);
   timestamp_offset_during_append_ = timestamp_offset;
   append_window_start_during_append_ = append_window_start;
   append_window_end_during_append_ = append_window_end;
 
   stream_parser_->Flush();
   timestamp_offset_during_append_ = NULL;
 
   frame_processor_->Reset();
   parsing_media_segment_ = false;
+  media_segment_contained_audio_frame_ = false;
+  media_segment_contained_video_frame_ = false;
 }
 
 void MediaSourceState::Remove(TimeDelta start,
                               TimeDelta end,
                               TimeDelta duration) {
   if (audio_)
     audio_->Remove(start, end, duration);
 
   if (video_)
     video_->Remove(start, end, duration);
@@ skipping 437 matching lines @@
   if (success)
     init_segment_received_cb_.Run();
 
   return success;
 }
 
 void MediaSourceState::OnNewMediaSegment() {
   DVLOG(2) << "OnNewMediaSegment()";
   parsing_media_segment_ = true;
   new_media_segment_ = true;
+  media_segment_contained_audio_frame_ = false;
+  media_segment_contained_video_frame_ = false;
 }
 
 void MediaSourceState::OnEndOfMediaSegment() {
   DVLOG(2) << "OnEndOfMediaSegment()";
   parsing_media_segment_ = false;
   new_media_segment_ = false;
+
+  const bool missing_audio = audio_ && !media_segment_contained_audio_frame_;
+  const bool missing_video = video_ && !media_segment_contained_video_frame_;
+  if (!missing_audio && !missing_video)
+    return;
+
+  LIMITED_MEDIA_LOG(DEBUG, media_log_, num_missing_track_logs_,
+                    kMaxMissingTrackInSegmentLogs)
+      << "Media segment did not contain any "
+      << (missing_audio && missing_video ? "audio or video"
+                                         : missing_audio ? "audio" : "video")
+      << " coded frames, mismatching initialization segment. Therefore, MSE "
+         "coded frame processing may not interoperably detect discontinuities "
+         "in appended media.";
 }
 
 bool MediaSourceState::OnNewBuffers(
     const StreamParser::BufferQueue& audio_buffers,
     const StreamParser::BufferQueue& video_buffers,
     const StreamParser::TextBufferQueueMap& text_map) {
   DVLOG(2) << "OnNewBuffers()";
   DCHECK(timestamp_offset_during_append_);
   DCHECK(parsing_media_segment_);
 
+  media_segment_contained_audio_frame_ |= !audio_buffers.empty();
+  media_segment_contained_video_frame_ |= !video_buffers.empty();
+
   const TimeDelta timestamp_offset_before_processing =
       *timestamp_offset_during_append_;
 
   // Calculate the new timestamp offset for audio/video tracks if the stream
   // parser has requested automatic updates.
   TimeDelta new_timestamp_offset = timestamp_offset_before_processing;
   if (auto_update_timestamp_offset_) {
     const bool have_audio_buffers = !audio_buffers.empty();
     const bool have_video_buffers = !video_buffers.empty();
     if (have_audio_buffers && have_video_buffers) {
@@ skipping 22 matching lines @@
   return true;
 }
 
 void MediaSourceState::OnSourceInitDone(
     const StreamParser::InitParameters& params) {
   auto_update_timestamp_offset_ = params.auto_update_timestamp_offset;
   base::ResetAndReturn(&init_cb_).Run(params);
 }
 
 }  // namespace media