Generate and assign media track ids in demuxers.

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/base/media_track.h"
 #include "media/base/media_tracks.h"
@@ skipping 133 matching lines @@
 void MediaSourceState::SetGroupStartTimestampIfInSequenceMode(
     base::TimeDelta timestamp_offset) {
   DCHECK(!parsing_media_segment_);
 
   frame_processor_->SetGroupStartTimestampIfInSequenceMode(timestamp_offset);
 }
 
 void MediaSourceState::SetTracksWatcher(
     const Demuxer::MediaTracksUpdatedCB& tracks_updated_cb) {
   DCHECK(init_segment_received_cb_.is_null());
+  DCHECK(!tracks_updated_cb.is_null());
   init_segment_received_cb_ = tracks_updated_cb;
-  DCHECK(!init_segment_received_cb_.is_null());
 }
 
 bool MediaSourceState::Append(const uint8_t* data,
                               size_t length,
                               TimeDelta append_window_start,
                               TimeDelta append_window_end,
                               TimeDelta* timestamp_offset) {
   append_in_progress_ = true;
   DCHECK(timestamp_offset);
   DCHECK(!timestamp_offset_during_append_);
@@ skipping 308 matching lines @@
 }
 
 bool MediaSourceState::OnNewConfigs(
     bool allow_audio,
     bool allow_video,
     std::unique_ptr<MediaTracks> tracks,
     const StreamParser::TextTrackConfigMap& text_configs) {
   DCHECK_GE(state_, PENDING_PARSER_CONFIG);
   DCHECK(tracks.get());
 
-  media_tracks_ = std::move(tracks);
-  const AudioDecoderConfig& audio_config = media_tracks_->getFirstAudioConfig();
-  const VideoDecoderConfig& video_config = media_tracks_->getFirstVideoConfig();
+  MediaTrack* audio_track = nullptr;
+  MediaTrack* video_track = nullptr;
+  AudioDecoderConfig audio_config;
+  VideoDecoderConfig video_config;
+  for (const auto& track : tracks->tracks()) {
+    const auto& track_id = track->bytestream_track_id();
+
+    if (track->type() == MediaTrack::Audio) {
+      if (audio_track) {
+        MEDIA_LOG(ERROR, media_log_)
+            << "Error: more than one audio track is currently not supported.";
+        return false;
+      }
+      audio_track = track.get();
+      audio_config = tracks->getAudioConfig(track_id);
+      DCHECK(audio_config.IsValidConfig());

[wolenetz, 2016/06/13 23:23:58]

Mp4StreamParser can create audio or video MediaTracks entry with invalid config
(which could be possible at least if the IsValidConfig() check changes versus
the parameters passed to config::Initialize(...)). (Though it skips subsequent
tracks if it has a valid one of same type, it doesn't check validity via
IsValidConfig prior to adding the initialized config to MediaTracks.) ISTM a
check and MEDIA_LOG for validity should be in mp4_stream_parser between config
intialization and addition of the track to the MediaTracks it's building for
passing to this method.
tl;dr: I don't object to this DCHECK here, but if adding one here, let's try to
add protection at the callers. See webm_tracks_parser's calls to AddAudioTrack
and AddVideoTrack to see how it first conditions on ability to create a valid
config (or otherwise gives parse error), for example. In looking around our
parser, mp4_stream_parser.cc is the only one giving me concern that it might hit
this DCHECK.

[servolk, 2016/06/14 00:01:22]

Done.

+    } else if (track->type() == MediaTrack::Video) {
+      if (video_track) {
+        MEDIA_LOG(ERROR, media_log_)
+            << "Error: more than one video track is currently not supported.";
+        return false;
+      }
+      video_track = track.get();
+      video_config = tracks->getVideoConfig(track_id);
+      DCHECK(video_config.IsValidConfig());
+    } else {
+      MEDIA_LOG(ERROR, media_log_) << "Error: unsupported media track type "
+                                   << track->type();
+      return false;
+    }
+  }
 
   DVLOG(1) << "OnNewConfigs(" << allow_audio << ", " << allow_video << ", "
            << audio_config.IsValidConfig() << ", "
            << video_config.IsValidConfig() << ")";
   // MSE spec allows new configs to be emitted only during Append, but not
   // during Flush or parser reset operations.
   CHECK(append_in_progress_);
 
   if (!audio_config.IsValidConfig() && !video_config.IsValidConfig()) {
     DVLOG(1) << "OnNewConfigs() : Audio & video config are not valid!";
@@ skipping 148 matching lines @@
                                        << config_itr->first
                                        << " does not match old one.";
           break;
         }
       }
     }
   }
 
   frame_processor_->SetAllTrackBuffersNeedRandomAccessPoint();
 
+  if (audio_track) {
+    DCHECK(audio_);
+    audio_track->set_id(audio_->media_track_id());
+  }
+  if (video_track) {
+    DCHECK(video_);
+    video_track->set_id(video_->media_track_id());
+  }
+
   DVLOG(1) << "OnNewConfigs() : " << (success ? "success" : "failed");
   if (success) {
     if (state_ == PENDING_PARSER_CONFIG)
       state_ = PENDING_PARSER_INIT;
     DCHECK(!init_segment_received_cb_.is_null());
-    init_segment_received_cb_.Run(std::move(media_tracks_));
+    init_segment_received_cb_.Run(std::move(tracks));
   }
 
   return success;
 }
 
 void MediaSourceState::OnNewMediaSegment() {
   DVLOG(2) << "OnNewMediaSegment()";
   DCHECK_EQ(state_, PARSER_INITIALIZED);
   parsing_media_segment_ = true;
   media_segment_contained_audio_frame_ = false;
@@ skipping 69 matching lines @@
 
 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