Return buffers from StreamParsers in a single unified map

media/filters/media_source_state.cc

 // Copyright 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/command_line.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 758 matching lines @@
                     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) {
+    const StreamParser::BufferQueueMap& buffer_queue_map) {
   DVLOG(2) << "OnNewBuffers()";
   DCHECK_EQ(state_, PARSER_INITIALIZED);
   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();
+  for (const auto& it : buffer_queue_map) {
+    const StreamParser::BufferQueue& bufq = it.second;
+    DCHECK(!bufq.empty());
+    if (bufq[0]->type() == DemuxerStream::AUDIO) {
+      media_segment_contained_audio_frame_ = true;
+    } else if (bufq[0]->type() == DemuxerStream::VIDEO) {
+      media_segment_contained_video_frame_ = true;
+    }
+  }
 
   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) {
-      new_timestamp_offset +=
-          std::min(EndTimestamp(audio_buffers), EndTimestamp(video_buffers));
-    } else if (have_audio_buffers) {
-      new_timestamp_offset += EndTimestamp(audio_buffers);
-    } else if (have_video_buffers) {
-      new_timestamp_offset += EndTimestamp(video_buffers);
+    TimeDelta min_end_timestamp = kNoTimestamp;
+    for (const auto& it : buffer_queue_map) {
+      const StreamParser::BufferQueue& bufq = it.second;
+      DCHECK(!bufq.empty());
+      if (min_end_timestamp == kNoTimestamp ||
+          EndTimestamp(bufq) < min_end_timestamp) {
+        min_end_timestamp = EndTimestamp(bufq);
+        DCHECK_NE(kNoTimestamp, min_end_timestamp);
+      }
     }
+    if (min_end_timestamp != kNoTimestamp)
+      new_timestamp_offset += min_end_timestamp;
   }
 
-  if (!frame_processor_->ProcessFrames(audio_buffers, video_buffers, text_map,
-                                       append_window_start_during_append_,
-                                       append_window_end_during_append_,
-                                       timestamp_offset_during_append_)) {
+  if (!frame_processor_->ProcessFrames(
+          buffer_queue_map, append_window_start_during_append_,
+          append_window_end_during_append_, timestamp_offset_during_append_)) {
     return false;
   }
 
   // Only update the timestamp offset if the frame processor hasn't already.
   if (auto_update_timestamp_offset_ &&
       timestamp_offset_before_processing == *timestamp_offset_during_append_) {
     *timestamp_offset_during_append_ = new_timestamp_offset;
   }
 
   return true;
 }
 
 void MediaSourceState::OnSourceInitDone(
     const StreamParser::InitParameters& params) {
   DCHECK_EQ(state_, PENDING_PARSER_INIT);
   state_ = PARSER_INITIALIZED;
   auto_update_timestamp_offset_ = params.auto_update_timestamp_offset;
   base::ResetAndReturn(&init_cb_).Run(params);
 }
 
 }  // namespace media