Implement mapping blink track id to demuxer streams

media/filters/chunk_demuxer_unittest.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 <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <utility>
@@ skipping 63 matching lines @@
 const int kAudioTrackSizeWidth = 8;
 const int kAudioTrackEntryHeaderSize =
     kAudioTrackSizeOffset + kAudioTrackSizeWidth;
 
 // The size of TrackEntry element in test file "webm_vp8_track_entry" starts at
 // index 1 and spans 8 bytes.
 const int kVideoTrackSizeOffset = 1;
 const int kVideoTrackSizeWidth = 8;
 const int kVideoTrackEntryHeaderSize =
     kVideoTrackSizeOffset + kVideoTrackSizeWidth;
 

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

Similar test for ffmpeg_demuxer would be good

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

FFmpeg demuxer currently doesn't support mid-stream config changes, so there's
only one set of tracks that is determined at the beginning of playback and never
changes after that.

+// Track numbers AKA bytestream track ids. Bytestream track ids might change
+// within a single playback session if there is only one track of a given type.
 const int kVideoTrackNum = 1;
 const int kAudioTrackNum = 2;
 const int kTextTrackNum = 3;
 const int kAlternateVideoTrackNum = 4;
 const int kAlternateAudioTrackNum = 5;
 const int kAlternateTextTrackNum = 6;
 
+// These value represent externally assigned track ids (for example track ids
+// assigned by blink). Not to be confused with bytestream track ids above. The
+// main difference is that these track ids must stay the same for the duration
+// of the playback session, whereas track numbers / bytestream track ids might

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

I was surprised to read this. Looking at the code here [0] it seems we expect
bytestream track ids to map to blink track ids. And if we encounter a new
bytstream track id, we seem to expect that it is already known (existing) in
SourceBuffer if we've already processed the first init segment? What am I
missing? 

[0]
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

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

That's right. If we encounter a new bytestream track id and there's only one
track of the given type, then we assume that new bytestream track corresponds to
the same track, even if the actual bytestream id is different. So the
external/blink track ids below map to the k*TrackNum in the first init segment
and kAlternate*TrackNum in the second init segment.

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

I see. Are we missing some code in SourceBuffer.cpp? IIUC we add tracks with the
original bystream track ids upon receiving the first init segment. But if a
later init segment changes the bytstream track id, we seem to expect to find a
track with that bytstream id already in the track list?

+// change in subsequent init segments.
+const int kVideoTrackId = 10;

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

Also, can you name these in a way that describes their different purpose? E.g.
kExternalVideoTrackId vs kBystreamVideoTrackId

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

Done.

+const int kAudioTrackId = 11;
+
 const int kAudioBlockDuration = 23;
 const int kVideoBlockDuration = 33;
 const int kTextBlockDuration = 100;
 const int kBlockSize = 10;
 
 const char kSourceId[] = "SourceId";
 const char kDefaultFirstClusterRange[] = "{ [0,46) }";
 const int kDefaultFirstClusterEndTimestamp = 66;
 const int kDefaultSecondClusterEndTimestamp = 132;
 
@@ skipping 1294 matching lines @@
   base::TimeDelta append_window_end_for_next_append_;
 
   // Map of source id to timestamp offset to use for the next AppendData()
   // operation for that source id.
   std::map<std::string, base::TimeDelta> timestamp_offset_map_;
 
  public:
   void InitSegmentReceived(std::unique_ptr<MediaTracks> tracks) {
     DCHECK(tracks.get());
     DCHECK_GT(tracks->tracks().size(), 0u);
 

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

This is busted for multi-track right? You might assert that you only see one
track of a given type

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

Yes, but there are many other places in Chromium media pipeline where we assume
there's only one audio and one video track (e.g.
DemuxerStreamProvider::GetStream and media::Renderer implementations).

+    std::vector<unsigned> track_ids;
+    for (const auto& track : tracks->tracks()) {
+      if (track->type() == MediaTrack::Audio) {
+        track_ids.push_back(kAudioTrackId);
+      } else if (track->type() == MediaTrack::Video) {
+        track_ids.push_back(kVideoTrackId);
+      } else {
+        NOTREACHED();
+      }
+    }
+    demuxer_->OnTrackIdsAssigned(*tracks.get(), track_ids);
+
     InitSegmentReceivedMock(tracks);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChunkDemuxerTest);
 };
 
 TEST_F(ChunkDemuxerTest, Init) {
   InSequence s;
 
@@ skipping 179 matching lines @@
   // Test with 1 audio and 1 video stream. Send a second init segment in which
   // the audio and video track IDs change. Verify that appended buffers before
   // and after the second init segment map to the same underlying track buffers.
   CreateNewDemuxer();
   ASSERT_TRUE(
       InitDemuxerWithEncryptionInfo(HAS_AUDIO | HAS_VIDEO, false, false));
   DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
   ASSERT_TRUE(audio_stream);
   ASSERT_TRUE(video_stream);
+  ASSERT_EQ(audio_stream, demuxer_->GetDemuxerStreamByTrackId(kAudioTrackId));
+  ASSERT_EQ(video_stream, demuxer_->GetDemuxerStreamByTrackId(kVideoTrackId));
 
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "0K 23K", 23),
                      MuxedStreamInfo(kVideoTrackNum, "0K 30", 30));
   CheckExpectedRanges("{ [0,46) }");
 
   EXPECT_CALL(*this, InitSegmentReceivedMock(_));
   AppendInitSegment(HAS_AUDIO | HAS_VIDEO | USE_ALTERNATE_AUDIO_TRACK_ID |
                     USE_ALTERNATE_VIDEO_TRACK_ID);
   AppendMuxedCluster(MuxedStreamInfo(kAlternateAudioTrackNum, "46K 69K", 63),
                      MuxedStreamInfo(kAlternateVideoTrackNum, "60K", 23));
   CheckExpectedRanges("{ [0,92) }");
   CheckExpectedBuffers(audio_stream, "0K 23K 46K 69K");
   CheckExpectedBuffers(video_stream, "0K 30 60K");
+  ASSERT_EQ(audio_stream, demuxer_->GetDemuxerStreamByTrackId(kAudioTrackId));
+  ASSERT_EQ(video_stream, demuxer_->GetDemuxerStreamByTrackId(kVideoTrackId));
 
   ShutdownDemuxer();
 }
 
 TEST_F(ChunkDemuxerTest, InitSegmentSetsNeedRandomAccessPointFlag) {
   // Tests that non-key-frames following an init segment are allowed
   // and dropped, as expected if the initialization segment received
   // algorithm correctly sets the needs random access point flag to true for all
   // track buffers. Note that the first initialization segment is insufficient
   // to fully test this since needs random access point flag initializes to
@@ skipping 3050 matching lines @@
              cluster->size() - video_start);
 
   CheckExpectedRanges(DemuxerStream::AUDIO, "{ [30,90) }");
   CheckExpectedRanges(DemuxerStream::VIDEO, "{ [0,91) }");
   CheckExpectedRanges("{ [30,90) }");
   CheckExpectedBuffers(audio_stream, "30K 40K 50K 60K 70K 80K");
   CheckExpectedBuffers(video_stream, "71K 81");
 }
 
 }  // namespace media