Fixed track id remapping in MSE FrameProcessor

media/filters/source_buffer_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/source_buffer_state.h"
 
 #include <set>
 
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
@@ skipping 527 matching lines @@
   // during Flush or parser reset operations.
   CHECK(append_in_progress_);
 
   bool success = true;
 
   // TODO(wolenetz): Update codec string strictness, if necessary, once spec
   // issue https://github.com/w3c/media-source/issues/161 is resolved.
   std::vector<AudioCodec> expected_acodecs = expected_audio_codecs_;
   std::vector<VideoCodec> expected_vcodecs = expected_video_codecs_;
 
+  FrameProcessor::TrackIdChanges track_id_changes;
   for (const auto& track : tracks->tracks()) {
     const auto& track_id = track->bytestream_track_id();
 
     if (track->type() == MediaTrack::Audio) {
       AudioDecoderConfig audio_config = tracks->getAudioConfig(track_id);
       DVLOG(1) << "Audio track_id=" << track_id
                << " config: " << audio_config.AsHumanReadableString();
       DCHECK(audio_config.IsValidConfig());
 
       const auto& it = std::find(expected_acodecs.begin(),
@@ skipping 23 matching lines @@
           auto it = audio_streams_.find(track_id);
           if (it != audio_streams_.end())
             stream = it->second;
         } else {
           // If there is only one audio track then bytestream id might change in
           // a new init segment. So update our state and notify frame processor.
           const auto& it = audio_streams_.begin();
           if (it != audio_streams_.end()) {
             stream = it->second;
             if (it->first != track_id) {
-              frame_processor_->UpdateTrack(it->first, track_id);
+              track_id_changes[it->first] = track_id;
               audio_streams_[track_id] = stream;
               audio_streams_.erase(it->first);
             }
           }
         }
         if (!stream) {
           MEDIA_LOG(ERROR, media_log_) << "Got unexpected audio track"
                                        << " track_id=" << track_id;
           return false;
         }
@@ skipping 35 matching lines @@
           auto it = video_streams_.find(track_id);
           if (it != video_streams_.end())
             stream = it->second;
         } else {
           // If there is only one video track then bytestream id might change in
           // a new init segment. So update our state and notify frame processor.
           const auto& it = video_streams_.begin();
           if (it != video_streams_.end()) {
             stream = it->second;
             if (it->first != track_id) {
-              frame_processor_->UpdateTrack(it->first, track_id);
+              track_id_changes[it->first] = track_id;
               video_streams_[track_id] = stream;
               video_streams_.erase(it->first);
             }
           }
         }
         if (!stream) {
           MEDIA_LOG(ERROR, media_log_) << "Got unexpected video track"
                                        << " track_id=" << track_id;
           return false;
         }
@@ skipping 49 matching lines @@
           config_itr->second.kind(), config_itr->second.label(),
           config_itr->second.language(), old_config.id());
       if (!new_config.Matches(old_config)) {
         success &= false;
         MEDIA_LOG(ERROR, media_log_)
             << "New text track config does not match old one.";
       } else {
         StreamParser::TrackId old_id = stream_itr->first;
         StreamParser::TrackId new_id = config_itr->first;
         if (new_id != old_id) {
-          if (frame_processor_->UpdateTrack(old_id, new_id)) {
-            text_streams_.clear();
-            text_streams_[config_itr->first] = text_stream;
-          } else {
-            success &= false;
-            MEDIA_LOG(ERROR, media_log_)
-                << "Error remapping single text track number";
-          }
+          track_id_changes[old_id] = new_id;
+          text_streams_.erase(old_id);
+          text_streams_[new_id] = text_stream;
         }
       }
     } else {
       for (auto config_itr = text_configs.begin();
            config_itr != text_configs.end(); ++config_itr) {
         auto stream_itr = text_streams_.find(config_itr->first);
         if (stream_itr == text_streams_.end()) {
           success &= false;
           MEDIA_LOG(ERROR, media_log_)
               << "Unexpected text track configuration for track ID "
@@ skipping 13 matching lines @@
         }
       }
     }
   }
 
   if (audio_streams_.empty() && video_streams_.empty()) {
     DVLOG(1) << __func__ << ": couldn't find a valid audio or video stream";
     return false;
   }
 
+  if (!frame_processor_->UpdateTrackIds(track_id_changes)) {
+    DVLOG(1) << __func__ << ": failed to remap track ids in frame processor";
+    return false;
+  }
+
   frame_processor_->SetAllTrackBuffersNeedRandomAccessPoint();
 
   if (!first_init_segment_received_) {
     first_init_segment_received_ = true;
     SetStreamMemoryLimits();
   }
 
   DVLOG(1) << "OnNewConfigs() : " << (success ? "success" : "failed");
   if (success) {
     if (state_ == PENDING_PARSER_CONFIG)
@@ skipping 119 matching lines @@
 }
 void SourceBufferState::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