Implement mapping blink track id to demuxer streams

media/base/media_tracks.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/base/media_tracks.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/video_decoder_config.h"
 
 namespace media {
 
 MediaTracks::MediaTracks() {}
 
 MediaTracks::~MediaTracks() {}
 
-void MediaTracks::AddAudioTrack(const AudioDecoderConfig& config,
-                                const std::string& id,
-                                const std::string& kind,
-                                const std::string& label,
-                                const std::string& language) {
+const MediaTrack* MediaTracks::AddAudioTrack(const AudioDecoderConfig& config,
+                                             const std::string& id,

[chcunningham, 2016/06/02 21:24:45]

What are the plans for this "id"? Its a little confusing to call this ID while a
trackID also exists. IIUC, these strings are always things like "audio", "text",
"video"... but I'm guessing that may change if we later enable multi-track? The
core of my question is - can we name these something else, here and in the
various places they're created/passed?

[servolk, 2016/06/02 23:53:11]

How about byteStreamTrackId?
Also, these are typically just numbers for now, so it's "1", "2", "3" instead of
"audio", "video". I've already prepared a separate CL to change the type from
string to StreamParser::TrackId (see
https://codereview.chromium.org/1861963008/). I'll do the renaming there as well
to keep this CL easier to review.

[chcunningham, 2016/06/03 20:42:49]

byteStreamTrackId sounds good

+                                             const std::string& kind,
+                                             const std::string& label,
+                                             const std::string& language) {
   DCHECK(config.IsValidConfig());
   CHECK(audio_configs_.find(id) == audio_configs_.end());
   std::unique_ptr<MediaTrack> track = base::WrapUnique(
       new MediaTrack(MediaTrack::Audio, id, kind, label, language));
   tracks_.push_back(std::move(track));
   audio_configs_[id] = config;
+  return tracks_.back().get();
 }
 
-void MediaTracks::AddVideoTrack(const VideoDecoderConfig& config,
-                                const std::string& id,
-                                const std::string& kind,
-                                const std::string& label,
-                                const std::string& language) {
+const MediaTrack* MediaTracks::AddVideoTrack(const VideoDecoderConfig& config,
+                                             const std::string& id,
+                                             const std::string& kind,
+                                             const std::string& label,
+                                             const std::string& language) {
   DCHECK(config.IsValidConfig());
   CHECK(video_configs_.find(id) == video_configs_.end());
   std::unique_ptr<MediaTrack> track = base::WrapUnique(
       new MediaTrack(MediaTrack::Video, id, kind, label, language));
   tracks_.push_back(std::move(track));
   video_configs_[id] = config;
+  return tracks_.back().get();
+}
+
+void MediaTracks::SetDemuxerStreamForMediaTrack(const MediaTrack* track,
+                                                const DemuxerStream* stream) {
+  DCHECK(track_to_demux_stream_map_.find(track) ==

[chcunningham, 2016/06/02 21:24:45]

How are you deciding when to DCHECK vs CHECK? Both of the new methods here mix
DCHECK and CHECK

[servolk, 2016/06/02 23:53:11]

In this case dcheck are for things that might indicate issues but might be
costly and unnecessary in release builds, whereas checks are used to protect us
from e.g. invalid memory accesses.

[chcunningham, 2016/06/03 20:42:49]

Acknowledged.

+         track_to_demux_stream_map_.end());
+
+  bool track_found = false;
+  for (const auto& t : tracks_) {
+    if (t.get() == track) {
+      track_found = true;
+      break;
+    }
+  }
+  CHECK(track_found);
+
+  track_to_demux_stream_map_[track] = stream;
+}
+
+MediaTracks::TrackIdToDemuxStreamMap MediaTracks::OnTrackIdsAssigned(
+    const std::vector<unsigned>& track_ids) const {
+  TrackIdToDemuxStreamMap result;
+  CHECK_EQ(tracks().size(), track_ids.size());
+  CHECK_EQ(track_to_demux_stream_map_.size(), tracks().size());
+  for (size_t i = 0; i < track_ids.size(); ++i) {
+    const MediaTrack* track = tracks()[i].get();
+    DCHECK(track);
+    const auto& it = track_to_demux_stream_map_.find(track);
+    CHECK(it != track_to_demux_stream_map_.end());
+    DVLOG(3) << "OnTrackIdsAssigned track_id=" << track_ids[i]
+             << " DemuxerStream=" << it->second;
+    result[track_ids[i]] = it->second;
+  }
+  return result;
 }
 
 const AudioDecoderConfig& MediaTracks::getAudioConfig(
     const std::string& id) const {
   auto it = audio_configs_.find(id);
   if (it != audio_configs_.end())
     return it->second;
   static AudioDecoderConfig invalidConfig;
   return invalidConfig;
 }
@@ skipping 21 matching lines @@
   for (const auto& track : tracks()) {
     if (track->type() == MediaTrack::Video) {
       return getVideoConfig(track->id());
     }
   }
   static VideoDecoderConfig invalidConfig;
   return invalidConfig;
 }
 
 }  // namespace media