MSE: Replace crossfade splicing overlap trimming.

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 147 matching lines @@
       arg, "Initialization segment " +
                std::string(mime_missing_track_type_bool ? "has "
                                                         : "does not have ") +
                std::string(track_type_string_with_article) +
                " track, but the mimetype " +
                std::string(mime_missing_track_type_bool ? "does not specify "
                                                         : "specifies ") +
                std::string(track_type_string_with_article) + " codec.");
 }
 
-MATCHER_P2(GeneratedSplice, duration_microseconds, time_microseconds, "") {
-  return CONTAINS_STRING(arg, "Generated splice of overlap duration " +
-                                  base::IntToString(duration_microseconds) +
-                                  "us into new buffer at " +
-                                  base::IntToString(time_microseconds) + "us.");
-}
-
-MATCHER_P2(SkippingSpliceAtOrBefore,
-           new_microseconds,
-           existing_microseconds,
-           "") {
-  return CONTAINS_STRING(
-      arg, "Skipping splice frame generation: first new buffer at " +
-               base::IntToString(new_microseconds) +
-               "us begins at or before existing buffer at " +
-               base::IntToString(existing_microseconds) + "us.");
-}
-
-MATCHER_P(SkippingSpliceAlreadySpliced, time_microseconds, "") {
-  return CONTAINS_STRING(
-      arg, "Skipping splice frame generation: overlapped buffers at " +
-               base::IntToString(time_microseconds) +
-               "us are in a previously buffered splice.");
+MATCHER_P2(GeneratedSplice, splice_time_mu, overlapped_start_mu, "") {
+  int silence_duration = splice_time_mu - overlapped_start_mu;
+  return CONTAINS_STRING(arg,
+                         "Generated splice for overlapping audio buffer"
+                         " at time:" +
+                             base::IntToString(splice_time_mu) +
+                             "mu. Adding silence of length:" +

[wolenetz, 2016/09/15 23:47:52]

s/mu/us/

[chcunningham, 2016/09/16 20:42:44]

Done.

+                             base::IntToString(silence_duration) +
+                             "mu to replace overlapped buffer at time:" +
+                             base::IntToString(overlapped_start_mu) + "mu.");
 }
 
 MATCHER_P(WebMSimpleBlockDurationEstimated, estimated_duration_ms, "") {
   return CONTAINS_STRING(arg, "Estimating WebM block duration to be " +
                                   base::IntToString(estimated_duration_ms) +
                                   "ms for the last (Simple)Block in the "
                                   "Cluster for this Track. Use BlockGroups "
                                   "with BlockDurations at the end of each "
                                   "Track in a Cluster to avoid estimation.");
 }
@@ skipping 70 matching lines @@
     init_segment_received_cb_ = base::Bind(
         &ChunkDemuxerTest::InitSegmentReceived, base::Unretained(this));
     CreateNewDemuxer();
   }
 
   void CreateNewDemuxer() {
     base::Closure open_cb =
         base::Bind(&ChunkDemuxerTest::DemuxerOpened, base::Unretained(this));
     Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb = base::Bind(
         &ChunkDemuxerTest::OnEncryptedMediaInitData, base::Unretained(this));
-    demuxer_.reset(new ChunkDemuxer(open_cb, encrypted_media_init_data_cb,
-                                    media_log_, true));
+    demuxer_.reset(
+        new ChunkDemuxer(open_cb, encrypted_media_init_data_cb, media_log_));
   }
 
   virtual ~ChunkDemuxerTest() {
     ShutdownDemuxer();
   }
 
   void CreateInitSegment(int stream_flags,
                          bool is_audio_encrypted,
                          bool is_video_encrypted,
                          std::unique_ptr<uint8_t[]>* buffer,
@@ skipping 672 matching lines @@
     // Note: Offsets here and below are derived from
     // media/test/data/bear-640x360-manifest.js and
     // media/test/data/bear-320x240-manifest.js which were
     // generated from media/test/data/bear-640x360.webm and
     // media/test/data/bear-320x240.webm respectively.
     EXPECT_CALL(*this, InitSegmentReceivedMock(_));
     EXPECT_TRUE(AppendData(bear2->data(), 4340));
 
     // Append a media segment that goes from [0.527000, 1.014000).
     EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(2));
-    EXPECT_MEDIA_LOG(GeneratedSplice(20000, 527000));
+    EXPECT_MEDIA_LOG(GeneratedSplice(527000, 524000));
     EXPECT_TRUE(AppendData(bear2->data() + 55290, 18785));
     CheckExpectedRanges("{ [0,1027) [1201,2736) }");
 
     // Append initialization segment for bear1 & fill gap with [779-1197)
     // segment.
     EXPECT_CALL(*this, InitSegmentReceivedMock(_));
     EXPECT_TRUE(AppendData(bear1->data(), 4370));
     EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(23));
-    EXPECT_MEDIA_LOG(GeneratedSplice(26000, 779000));
+    EXPECT_MEDIA_LOG(GeneratedSplice(779000, 759000));
     EXPECT_TRUE(AppendData(bear1->data() + 72737, 28183));
     CheckExpectedRanges("{ [0,2736) }");
 
     MarkEndOfStream(PIPELINE_OK);
     return true;
   }
 
   void ShutdownDemuxer() {
     if (demuxer_) {
       demuxer_->Shutdown();
@@ skipping 838 matching lines @@
                        base::TimeDelta::FromMilliseconds(0),
                        &video_read_done));
 
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 }
 
 TEST_F(ChunkDemuxerTest, OutOfOrderClusters) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   ASSERT_TRUE(AppendCluster(kDefaultFirstCluster()));
-  EXPECT_MEDIA_LOG(GeneratedSplice(13000, 10000));
+  EXPECT_MEDIA_LOG(GeneratedSplice(10000, 0));
   ASSERT_TRUE(AppendCluster(GenerateCluster(10, 4)));
 
   // Make sure that AppendCluster() does not fail with a cluster that has
   // overlaps with the previously appended cluster.
-  EXPECT_MEDIA_LOG(SkippingSpliceAlreadySpliced(0));
+  EXPECT_MEDIA_LOG(GeneratedSplice(5000, 0));
   ASSERT_TRUE(AppendCluster(GenerateCluster(5, 4)));
 
   // Verify that AppendData() can still accept more data.
+  EXPECT_MEDIA_LOG(GeneratedSplice(45000, 28000));
   std::unique_ptr<Cluster> cluster_c(GenerateCluster(45, 2));
-  EXPECT_MEDIA_LOG(GeneratedSplice(6000, 45000));
   ASSERT_TRUE(demuxer_->AppendData(
       kSourceId, cluster_c->data(), cluster_c->size(),
       append_window_start_for_next_append_, append_window_end_for_next_append_,
       &timestamp_offset_map_[kSourceId]));
 }
 
 TEST_F(ChunkDemuxerTest, NonMonotonicButAboveClusterTimecode) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   ASSERT_TRUE(AppendCluster(kDefaultFirstCluster()));
 
@@ skipping 312 matching lines @@
   // affect the expected ranges.
   CheckExpectedRanges("{ [0,66) }");
 
   // Unmark end of stream state and verify that the ranges return to
   // their pre-"end of stream" values.
   demuxer_->UnmarkEndOfStream();
   CheckExpectedRanges("{ [0,46) }");
 
   // Add text track data and verify that the buffered ranges don't change
   // since the intersection of all the tracks doesn't change.
-  EXPECT_MEDIA_LOG(SkippingSpliceAtOrBefore(0, 0));
   EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(200)));
   AppendMuxedCluster(MuxedStreamInfo(kVideoTrackNum, "0K 33", 33),
                      MuxedStreamInfo(kAudioTrackNum, "0K 23K", 23),
                      MuxedStreamInfo(kTextTrackNum, "0K 100K"));
   CheckExpectedRanges("{ [0,46) }");
 
   // Mark end of stream and verify that text track data is reflected in
   // the new range.
   MarkEndOfStream(PIPELINE_OK);
   CheckExpectedRanges("{ [0,200) }");
@@ skipping 689 matching lines @@
       audio_id, GenerateSingleStreamCluster(900, 970, kAudioTrackNum, 70)));
   ASSERT_TRUE(AppendCluster(
       video_id, GenerateSingleStreamCluster(920, 950, kVideoTrackNum, 30)));
   CheckExpectedRanges(DemuxerStream::AUDIO,
                       "{ [0,23) [300,400) [520,590) [720,750) [900,970) }");
   CheckExpectedRanges(DemuxerStream::VIDEO,
                       "{ [0,33) [320,420) [500,570) [700,770) [920,950) }");
   CheckExpectedRangesForMediaSource(
       "{ [0,23) [320,400) [520,570) [720,750) [920,950) }");
 
-  // Appending within buffered range should not affect buffered ranges.
-  EXPECT_MEDIA_LOG(GeneratedSplice(40000, 930000));
+  // Audio buffered ranges are trimmed from 970 to 950 due to splicing the
+  // previously buffered audio frame (now silence from [900-930), newly
+  // appended audio from [930, 950)
+  EXPECT_MEDIA_LOG(GeneratedSplice(930000, 900000));
   ASSERT_TRUE(AppendCluster(
       audio_id, GenerateSingleStreamCluster(930, 950, kAudioTrackNum, 20)));
+  CheckExpectedRanges(DemuxerStream::AUDIO,
+                      "{ [0,23) [300,400) [520,590) [720,750) [900,950) }");
+
+  // Appending within buffered range should not affect video buffered ranges.
   ASSERT_TRUE(AppendCluster(
       video_id, GenerateSingleStreamCluster(930, 950, kVideoTrackNum, 20)));
-  CheckExpectedRanges(DemuxerStream::AUDIO,
-                      "{ [0,23) [300,400) [520,590) [720,750) [900,970) }");
   CheckExpectedRanges(DemuxerStream::VIDEO,
                       "{ [0,33) [320,420) [500,570) [700,770) [920,950) }");
+
   CheckExpectedRangesForMediaSource(
       "{ [0,23) [320,400) [520,570) [720,750) [920,950) }");
 }
 
 TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioVideo) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   // Audio block: 0 -> 23
   // Video block: 0 -> 33
   // Buffered Range: 0 -> 23
@@ skipping 51 matching lines @@
   // 900, so the added buffered range is 900 -> 950
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "900D70K"),
                      MuxedStreamInfo(kVideoTrackNum, "920D30K"));
 
   CheckExpectedRanges(DemuxerStream::AUDIO,
                       "{ [0,23) [300,400) [500,590) [700,750) [900,970) }");
   CheckExpectedRanges(DemuxerStream::VIDEO,
                       "{ [0,33) [300,420) [500,570) [700,770) [900,950) }");
   CheckExpectedRanges("{ [0,23) [300,400) [500,570) [700,750) [900,950) }");
 
-  // Appending within buffered range should not affect buffered ranges.
-  EXPECT_MEDIA_LOG(GeneratedSplice(40000, 930000));
+  // Appending within buffered range should not affect video buffered ranges.
+  EXPECT_MEDIA_LOG(GeneratedSplice(930000, 900000));
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "930D20K"),
                      MuxedStreamInfo(kVideoTrackNum, "930D20K"));
-  CheckExpectedRanges(DemuxerStream::AUDIO,
-                      "{ [0,23) [300,400) [500,590) [700,750) [900,970) }");
   CheckExpectedRanges(DemuxerStream::VIDEO,
                       "{ [0,33) [300,420) [500,570) [700,770) [900,950) }");
+
+  // Audio buffered ranges are trimmed from 970 to 950 due to splicing the
+  // previously buffered audio frame - now silence from [900-930), newly
+  // appended audio from [930, 950).
+  CheckExpectedRanges(DemuxerStream::AUDIO,
+                      "{ [0,23) [300,400) [500,590) [700,750) [900,950) }");
+
   CheckExpectedRanges("{ [0,23) [300,400) [500,570) [700,750) [900,950) }");
 }
 
 TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioVideoText) {
   EXPECT_CALL(host_, AddTextStream(_, _));
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO | HAS_TEXT));
 
   // Append audio & video data
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "0K 23K", 23),
                      MuxedStreamInfo(kVideoTrackNum, "0K 33", 33));
@@ skipping 319 matching lines @@
   DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
 
   // Fetch initial audio config and verify it matches what we expect.
   const AudioDecoderConfig& audio_config_1 = audio->audio_decoder_config();
   ASSERT_TRUE(audio_config_1.IsValidConfig());
   EXPECT_EQ(audio_config_1.samples_per_second(), 44100);
   EXPECT_EQ(audio_config_1.extra_data().size(), 3863u);
 
   ExpectRead(DemuxerStream::AUDIO, 0);
 
-  // The first config change seen is from a splice frame representing an overlap
-  // of buffer from config 1 by buffers from config 2.
+  // Read until we encounter config 2.
   ReadUntilNotOkOrEndOfStream(DemuxerStream::AUDIO, &status, &last_timestamp);
   ASSERT_EQ(status, DemuxerStream::kConfigChanged);
-  EXPECT_EQ(last_timestamp.InMilliseconds(), 524);
+  EXPECT_EQ(last_timestamp.InMilliseconds(), 501);
 
   // Fetch the new decoder config.
   const AudioDecoderConfig& audio_config_2 = audio->audio_decoder_config();
   ASSERT_TRUE(audio_config_2.IsValidConfig());
   EXPECT_EQ(audio_config_2.samples_per_second(), 44100);
   EXPECT_EQ(audio_config_2.extra_data().size(), 3935u);
 
-  // The next config change is from a splice frame representing an overlap of
-  // buffers from config 2 by buffers from config 1.
+  // Read until we encounter config 1 again.
   ReadUntilNotOkOrEndOfStream(DemuxerStream::AUDIO, &status, &last_timestamp);
   ASSERT_EQ(status, DemuxerStream::kConfigChanged);
-  EXPECT_EQ(last_timestamp.InMilliseconds(), 782);
+  EXPECT_EQ(last_timestamp.InMilliseconds(), 736);
   ASSERT_TRUE(audio_config_1.Matches(audio->audio_decoder_config()));
 
   // Read until the end of the stream just to make sure there aren't any other
   // config changes.
   ReadUntilNotOkOrEndOfStream(DemuxerStream::AUDIO, &status, &last_timestamp);
   ASSERT_EQ(status, DemuxerStream::kOk);
   EXPECT_EQ(last_timestamp.InMilliseconds(), 2744);
 }
 
 TEST_F(ChunkDemuxerTest, ConfigChange_Seek) {
@@ skipping 280 matching lines @@
       true, true, true, true, false,
   };
 
   static_assert(arraysize(kBuffer) == arraysize(kExpectedReturnValues),
       "test arrays out of sync");
   static_assert(arraysize(kBuffer) == sizeof(kBuffer),
       "there should be one byte per index");
 
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(23)).Times(2);
-  EXPECT_MEDIA_LOG(GeneratedSplice(22000, 2000));
+  EXPECT_MEDIA_LOG(GeneratedSplice(2000, 1000));
   for (size_t i = 0; i < sizeof(kBuffer); i++) {
     DVLOG(3) << "Appending and testing index " << i;
     ASSERT_TRUE(AppendData(kBuffer + i, 1));
     bool expected_return_value = kExpectedReturnValues[i];
     EXPECT_EQ(expected_return_value,
               demuxer_->IsParsingMediaSegment(kSourceId));
   }
 }
 
 TEST_F(ChunkDemuxerTest, DurationChange) {
@@ skipping 1086 matching lines @@
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   EXPECT_NE(nullptr, audio_stream);
   CheckStreamStatusNotifications(audio_stream);
   DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
   EXPECT_NE(nullptr, video_stream);
   CheckStreamStatusNotifications(video_stream);
 }
 
 }  // namespace media