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

media/filters/chunk_demuxer.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/chunk_demuxer.h"
 
 #include <algorithm>
 #include <limits>
 #include <list>
 #include <utility>
@@ skipping 174 matching lines @@
   // processing decoder configurations.
   bool OnNewConfigs(bool allow_audio, bool allow_video,
                     const AudioDecoderConfig& audio_config,
                     const VideoDecoderConfig& video_config,
                     const StreamParser::TextTrackConfigMap& text_configs);
 
   // Called by the |stream_parser_| at the beginning of a new media segment.
   void OnNewMediaSegment();
 
   // Called by the |stream_parser_| at the end of a media segment.
-  void OnEndOfMediaSegment();
+  bool OnEndOfMediaSegment();
 
   // Called by the |stream_parser_| when new buffers have been parsed.
   // It processes the new buffers using |frame_processor_|, which includes
   // appending the processed frames to associated demuxer streams for each
   // frame's track.
   // Returns true on a successful call. Returns false if an error occurred while
   // processing the buffers.
   bool OnNewBuffers(const StreamParser::BufferQueue& audio_buffers,
                     const StreamParser::BufferQueue& video_buffers,
                     const StreamParser::TextBufferQueueMap& text_map);
@@ skipping 27 matching lines @@
   // appended. The flag is set on actual media segment boundaries and
   // when the "append window" filtering causes discontinuities in the
   // appended data.
   // TODO(wolenetz/acolwell): Investigate if we need this, or if coded frame
   // processing's discontinuity logic is enough. See http://crbug.com/351489.
   bool new_media_segment_;
 
   // Keeps track of whether a media segment is being parsed.
   bool parsing_media_segment_;
 
+  // Valid only while |parsing_media_segment_| is true. These flags are to
+  // enforce adherence to MSE spec's requirement of at least one frame for each
+  // A/V track in each media segment.
+  bool media_segment_contained_audio_frame_;
+  bool media_segment_contained_video_frame_;
+
   // The object used to parse appended data.
   scoped_ptr<StreamParser> stream_parser_;
 
   ChunkDemuxerStream* audio_;  // Not owned by |this|.
   ChunkDemuxerStream* video_;  // Not owned by |this|.
 
   typedef std::map<StreamParser::TrackId, ChunkDemuxerStream*> TextStreamMap;
   TextStreamMap text_stream_map_;  // |this| owns the map's stream pointers.
 
   scoped_ptr<FrameProcessor> frame_processor_;
@@ skipping 17 matching lines @@
 };
 
 SourceState::SourceState(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 60 matching lines @@
         << __FUNCTION__ << ": stream parsing failed."
         << " Data size=" << length
         << " append_window_start=" << append_window_start.InSecondsF()
         << " append_window_end=" << append_window_end.InSecondsF();
   }
   timestamp_offset_during_append_ = NULL;
   init_segment_received_cb_.Reset();
   return result;
 }
 
 void SourceState::ResetParserState(TimeDelta append_window_start,

[chcunningham, 2016/01/07 22:23:56]

Should you set media_segment_contained_{video|audio}_frame_ = false here?

[wolenetz, 2016/01/16 01:23:35]

Good idea for at least maintainability. Done (in MediaSourceState now).

                                    TimeDelta append_window_end,
                                    base::TimeDelta* timestamp_offset) {
   DCHECK(timestamp_offset);
   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;
@@ skipping 447 matching lines @@
   if (success)
     init_segment_received_cb_.Run();
 
   return success;
 }
 
 void SourceState::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 SourceState::OnEndOfMediaSegment() {
+bool SourceState::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) {
+    MEDIA_LOG(ERROR, media_log_)
+        << "Media segment did not contain any "
+        << (missing_audio && missing_video ? "audio or video"
+                                           : missing_audio ? "audio" : "video")
+        << " coded frames, mismatching initialization segment";
+    return false;
+  }
+
+  return true;
 }
 
 bool SourceState::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 1113 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (SourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media