MSE: Remap single text track number changes in frame processor

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 <algorithm>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
@@ skipping 48 matching lines @@
 // 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;
 
 const int kVideoTrackNum = 1;
 const int kAudioTrackNum = 2;
 const int kTextTrackNum = 3;
+const int kAlternateTextTrackNum = 4;
 
 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 92 matching lines @@
         base::Bind(&ChunkDemuxerTest::DemuxerNeedKey, base::Unretained(this));
     demuxer_.reset(
         new ChunkDemuxer(open_cb, need_key_cb, base::Bind(&LogFunc), true));
   }
 
   virtual ~ChunkDemuxerTest() {
     ShutdownDemuxer();
   }
 
   void CreateInitSegment(int stream_flags,
-                         bool is_audio_encrypted, bool is_video_encrypted,
+                         bool is_audio_encrypted,
+                         bool is_video_encrypted,
                          scoped_ptr<uint8[]>* buffer,
                          int* size) {
+    CreateInitSegmentInternal(
+        stream_flags, is_audio_encrypted, is_video_encrypted, buffer, false,
+        size);
+  }
+
+  void CreateInitSegmentWithAlternateTextTrackNum(int stream_flags,
+                                                  bool is_audio_encrypted,
+                                                  bool is_video_encrypted,
+                                                  scoped_ptr<uint8[]>* buffer,
+                                                  int* size) {
+    DCHECK(stream_flags & HAS_TEXT);
+    CreateInitSegmentInternal(
+        stream_flags, is_audio_encrypted, is_video_encrypted, buffer, true,
+        size);
+  }
+
+  void CreateInitSegmentInternal(int stream_flags,
+                                 bool is_audio_encrypted,
+                                 bool is_video_encrypted,
+                                 scoped_ptr<uint8[]>* buffer,
+                                 bool use_alternate_text_track_id,
+                                 int* size) {
     bool has_audio = (stream_flags & HAS_AUDIO) != 0;
     bool has_video = (stream_flags & HAS_VIDEO) != 0;
     bool has_text = (stream_flags & HAS_TEXT) != 0;
     scoped_refptr<DecoderBuffer> ebml_header;
     scoped_refptr<DecoderBuffer> info;
     scoped_refptr<DecoderBuffer> audio_track_entry;
     scoped_refptr<DecoderBuffer> video_track_entry;
     scoped_refptr<DecoderBuffer> audio_content_encodings;
     scoped_refptr<DecoderBuffer> video_content_encodings;
     scoped_refptr<DecoderBuffer> text_track_entry;
@@ skipping 22 matching lines @@
       }
     }
 
     if (has_text) {
       // TODO(matthewjheaney): create an abstraction to do
       // this (http://crbug/321454).
       // We need it to also handle the creation of multiple text tracks.
       //
       // This is the track entry for a text track,
       // TrackEntry [AE], size=30
-      //   TrackNum [D7], size=1, val=3
-      //   TrackUID [73] [C5], size=1, value=3
+      //   TrackNum [D7], size=1, val=3 (or 4 if use_alternate_text_track_id)
+      //   TrackUID [73] [C5], size=1, value=3 (must remain constant for same
+      //     track, even if TrackNum changes)
       //   TrackType [83], size=1, val=0x11
       //   CodecId [86], size=18, val="D_WEBVTT/SUBTITLES"
-      const char str[] = "\xAE\x9E\xD7\x81\x03\x73\xC5\x81\x03"
-                         "\x83\x81\x11\x86\x92"
-                         "D_WEBVTT/SUBTITLES";
+      char str[] = "\xAE\x9E\xD7\x81\x03\x73\xC5\x81\x03"
+                   "\x83\x81\x11\x86\x92"
+                   "D_WEBVTT/SUBTITLES";
+      DCHECK_EQ(str[4], kTextTrackNum);
+      if (use_alternate_text_track_id)
+        str[4] = kAlternateTextTrackNum;
+
       const int len = strlen(str);
       DCHECK_EQ(len, 32);
       const uint8* const buf = reinterpret_cast<const uint8*>(str);
       text_track_entry = DecoderBuffer::CopyFrom(buf, len);
       tracks_element_size += text_track_entry->data_size();
     }
 
     *size = ebml_header->data_size() + info->data_size() +
         kTracksHeaderSize + tracks_element_size;
 
@@ skipping 108 matching lines @@
   void AppendSingleStreamCluster(const std::string& source_id, int track_number,
                                  int timecode, int block_count) {
     int block_duration = 0;
     switch (track_number) {
       case kVideoTrackNum:
         block_duration = kVideoBlockDuration;
         break;
       case kAudioTrackNum:
         block_duration = kAudioBlockDuration;
         break;
-      case kTextTrackNum:
+      case kTextTrackNum:  // Fall-through.
+      case kAlternateTextTrackNum:
         block_duration = kTextBlockDuration;
         break;
     }
     ASSERT_NE(block_duration, 0);
     int end_timecode = timecode + block_count * block_duration;
     AppendCluster(source_id,
                   GenerateSingleStreamCluster(
                       timecode, end_timecode, track_number, block_duration));
   }
 
@@ skipping 17 matching lines @@
         block_flags = kWebMFlagKeyframe;
         // Remove the "K" off of the token.
         timestamp_str = timestamp_str.substr(0, timestamps[i].length() - 1);
       }
       int timestamp_in_ms;
       CHECK(base::StringToInt(timestamp_str, &timestamp_in_ms));
 
       if (i == 0)
         cb.SetClusterTimecode(timestamp_in_ms);
 
-      if (track_number == kTextTrackNum) {
+      if (track_number == kTextTrackNum ||
+          track_number == kAlternateTextTrackNum) {
         cb.AddBlockGroup(track_number, timestamp_in_ms, kTextBlockDuration,
                          block_flags, &data[0], data.size());
       } else {
         cb.AddSimpleBlock(track_number, timestamp_in_ms, block_flags,
                           &data[0], data.size());
       }
     }
     AppendCluster(source_id, cb.Finish());
   }
 
@@ skipping 730 matching lines @@
                        ->supports_partial_append_window_trimming());
     } else {
       EXPECT_FALSE(video_stream);
     }
 
     ShutdownDemuxer();
     demuxer_.reset();
   }
 }
 
+TEST_P(ChunkDemuxerTest, SingleTextTrackIdChange) {
+  // Test with 1 video stream, 1 audio, and 1 text stream. Send a second init
+  // segment in which the text track ID changes. Verify appended buffers before
+  // and after the second init segment map to the same underlying track buffers.
+  CreateNewDemuxer();
+  DemuxerStream* text_stream = NULL;
+  TextTrackConfig text_config;
+  EXPECT_CALL(host_, AddTextStream(_, _))
+      .WillOnce(DoAll(SaveArg<0>(&text_stream),
+                      SaveArg<1>(&text_config)));
+  ASSERT_TRUE(InitDemuxerWithEncryptionInfo(
+      HAS_TEXT | 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_TRUE(text_stream);
+
+  AppendSingleStreamCluster(kSourceId, kAudioTrackNum, "0K 23K");
+  AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "0K 30");
+  AppendSingleStreamCluster(kSourceId, kTextTrackNum, "10K");
+  CheckExpectedRanges(kSourceId, "{ [0,46) }");
+
+  scoped_ptr<uint8[]> info_tracks;
+  int info_tracks_size = 0;
+  CreateInitSegmentWithAlternateTextTrackNum(HAS_TEXT | HAS_AUDIO | HAS_VIDEO,
+                                             false, false,
+                                             &info_tracks, &info_tracks_size);
+  demuxer_->AppendData(kSourceId, info_tracks.get(), info_tracks_size,
+                       append_window_start_for_next_append_,
+                       append_window_end_for_next_append_,
+                       &timestamp_offset_map_[kSourceId]);
+
+  AppendSingleStreamCluster(kSourceId, kAudioTrackNum, "46K 69K");
+  AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "60K");
+  AppendSingleStreamCluster(kSourceId, kAlternateTextTrackNum, "45K");
+
+  CheckExpectedRanges(kSourceId, "{ [0,92) }");
+  CheckExpectedBuffers(audio_stream, "0 23 46 69");
+  CheckExpectedBuffers(video_stream, "0 30 60");
+  CheckExpectedBuffers(text_stream, "10 45");
+
+  ShutdownDemuxer();
+}
+
 // Make sure that the demuxer reports an error if Shutdown()
 // is called before all the initialization segments are appended.
 TEST_P(ChunkDemuxerTest, Shutdown_BeforeAllInitSegmentsAppended) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(
           kDefaultDuration(), DEMUXER_ERROR_COULD_NOT_OPEN), true);
 
   EXPECT_EQ(AddId("audio", HAS_AUDIO), ChunkDemuxer::kOk);
   EXPECT_EQ(AddId("video", HAS_VIDEO), ChunkDemuxer::kOk);
@@ skipping 2182 matching lines @@
   CheckExpectedBuffers(audio_stream, "160 180");
   CheckExpectedBuffers(video_stream, "180 210");
 }
 
 // Generate two sets of tests: one using FrameProcessor, and one using
 // LegacyFrameProcessor.
 INSTANTIATE_TEST_CASE_P(NewFrameProcessor, ChunkDemuxerTest, Values(false));
 INSTANTIATE_TEST_CASE_P(LegacyFrameProcessor, ChunkDemuxerTest, Values(true));
 
 }  // namespace media