Generate and assign media track ids in demuxers.

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>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
+#include "base/strings/string_number_conversions.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/bind_to_current_loop.h"
+#include "media/base/media_tracks.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_decoder_config.h"
 #include "media/filters/frame_processor.h"
 #include "media/filters/stream_parser_factory.h"
 
 using base::TimeDelta;
 
 namespace media {
 
 ChunkDemuxerStream::ChunkDemuxerStream(Type type,
-                                       bool splice_frames_enabled)
+                                       bool splice_frames_enabled,
+                                       MediaTrack::TrackId media_track_id)
     : type_(type),
       liveness_(DemuxerStream::LIVENESS_UNKNOWN),
+      media_track_id_(media_track_id),
       state_(UNINITIALIZED),
       splice_frames_enabled_(splice_frames_enabled),
-      partial_append_window_trimming_enabled_(false) {
-}
+      partial_append_window_trimming_enabled_(false) {}
 
 void ChunkDemuxerStream::StartReturningData() {
   DVLOG(1) << "ChunkDemuxerStream::StartReturningData()";
   base::AutoLock auto_lock(lock_);
   DCHECK(read_cb_.is_null());
   ChangeState_Locked(RETURNING_DATA_FOR_READS);
 }
 
 void ChunkDemuxerStream::AbortReads() {
   DVLOG(1) << "ChunkDemuxerStream::AbortReads()";
@@ skipping 317 matching lines @@
       encrypted_media_init_data_cb_(encrypted_media_init_data_cb),
       enable_text_(false),
       media_log_(media_log),
       pending_source_init_done_count_(0),
       duration_(kNoTimestamp()),
       user_specified_duration_(-1),
       liveness_(DemuxerStream::LIVENESS_UNKNOWN),
       splice_frames_enabled_(splice_frames_enabled),
       detected_audio_track_count_(0),
       detected_video_track_count_(0),
-      detected_text_track_count_(0) {
+      detected_text_track_count_(0),
+      next_track_id_(1) {
   DCHECK(!open_cb_.is_null());
   DCHECK(!encrypted_media_init_data_cb_.is_null());
 }
 
 std::string ChunkDemuxer::GetDisplayName() const {
   return "ChunkDemuxer";
 }
 
 void ChunkDemuxer::Initialize(
     DemuxerHost* host,
@@ skipping 172 matching lines @@
 }
 
 void ChunkDemuxer::SetTracksWatcher(
     const std::string& id,
     const MediaTracksUpdatedCB& tracks_updated_cb) {
   base::AutoLock auto_lock(lock_);
   CHECK(IsValidId(id));
   source_state_map_[id]->SetTracksWatcher(tracks_updated_cb);
 }
 
+const DemuxerStream* ChunkDemuxer::GetDemuxerStreamByTrackId(
+    MediaTrack::TrackId track_id) const {
+  base::AutoLock auto_lock(lock_);
+  auto it = track_id_to_demux_stream_map_.find(track_id);
+  DCHECK(it != track_id_to_demux_stream_map_.end());
+  return it->second;
+}
+
 void ChunkDemuxer::RemoveId(const std::string& id) {
   base::AutoLock auto_lock(lock_);
   CHECK(IsValidId(id));
 
   delete source_state_map_[id];
   source_state_map_.erase(id);
 
   if (source_id_audio_ == id)
     source_id_audio_.clear();
 
@@ skipping 420 matching lines @@
   if (duration_ == kNoTimestamp())
     duration_ = kInfiniteDuration();
 
   // The demuxer is now initialized after the |start_timestamp_| was set.
   ChangeState_Locked(INITIALIZED);
   base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
 }
 
 ChunkDemuxerStream* ChunkDemuxer::CreateDemuxerStream(
     DemuxerStream::Type type) {
+  // New ChunkDemuxerStreams can be created only during initialization segment
+  // processing, which happens when a new chunk of data is appended and the
+  // lock_ must be held by ChunkDemuxer::AppendData.
+  lock_.AssertAcquired();
+
+  MediaTrack::TrackId media_track_id = base::UintToString(next_track_id_++);
+
   switch (type) {
     case DemuxerStream::AUDIO:
       if (audio_)
         return NULL;
-      audio_.reset(
-          new ChunkDemuxerStream(DemuxerStream::AUDIO, splice_frames_enabled_));
+      audio_.reset(new ChunkDemuxerStream(
+          DemuxerStream::AUDIO, splice_frames_enabled_, media_track_id));
+      track_id_to_demux_stream_map_[media_track_id] = audio_.get();
       return audio_.get();
       break;
     case DemuxerStream::VIDEO:
       if (video_)
         return NULL;
-      video_.reset(
-          new ChunkDemuxerStream(DemuxerStream::VIDEO, splice_frames_enabled_));
+      video_.reset(new ChunkDemuxerStream(
+          DemuxerStream::VIDEO, splice_frames_enabled_, media_track_id));
+      track_id_to_demux_stream_map_[media_track_id] = video_.get();
       return video_.get();
       break;
     case DemuxerStream::TEXT: {
-      return new ChunkDemuxerStream(DemuxerStream::TEXT,
-                                    splice_frames_enabled_);
+      return new ChunkDemuxerStream(DemuxerStream::TEXT, splice_frames_enabled_,
+                                    media_track_id);
       break;
     }
     case DemuxerStream::UNKNOWN:
     case DemuxerStream::NUM_TYPES:
       NOTREACHED();
       return NULL;
   }
   NOTREACHED();
   return NULL;
 }
@@ skipping 104 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (MediaSourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media