Reland: MSE: Relax the 'media segment must begin with keyframe' requirement

media/filters/chunk_demuxer_unittest.cc

Index: media/filters/chunk_demuxer_unittest.cc
diff --git a/media/filters/chunk_demuxer_unittest.cc b/media/filters/chunk_demuxer_unittest.cc
index 8549f61ea135a5c04df2bb56243fcb4e5baf8b76..c095f5a292cb8d57a8d5f7d8d2dac85033b6c4bf 100644
--- a/media/filters/chunk_demuxer_unittest.cc
+++ b/media/filters/chunk_demuxer_unittest.cc
@@ -685,7 +685,8 @@ class ChunkDemuxerTest : public ::testing::Test {
     AppendMuxedCluster(msi);
   }
 
-  void AppendMuxedCluster(const std::vector<MuxedStreamInfo> msi) {
+  scoped_ptr<Cluster> GenerateMuxedCluster(
+      const std::vector<MuxedStreamInfo> msi) {
     std::priority_queue<BlockInfo> block_queue;
     for (size_t i = 0; i < msi.size(); ++i) {
       std::vector<BlockInfo> track_blocks;
@@ -701,8 +702,11 @@ class ChunkDemuxerTest : public ::testing::Test {
             msi[i].last_blocks_estimated_duration));
       }
     }
+    return GenerateCluster(block_queue, false);
+  }
 
-    AppendCluster(kSourceId, GenerateCluster(block_queue, false));
+  void AppendMuxedCluster(const std::vector<MuxedStreamInfo> msi) {
+    AppendCluster(kSourceId, GenerateMuxedCluster(msi));
   }
 
   void AppendData(const std::string& source_id,
@@ -902,7 +906,7 @@ class ChunkDemuxerTest : public ::testing::Test {
   // The resulting video stream returns data from each file for the following
   // time ranges.
   // bear-320x240.webm : [0-501)       [801-2736)
-  // bear-640x360.webm :       [527-793)
+  // bear-640x360.webm :       [527-760)
   //
   // bear-320x240.webm AudioDecoderConfig returns 3863 for its extra_data size.
   // bear-640x360.webm AudioDecoderConfig returns 3935 for its extra_data size.
@@ -3201,7 +3205,7 @@ TEST_F(ChunkDemuxerTest, ConfigChange_Video) {
   // Read until the next config change.
   ReadUntilNotOkOrEndOfStream(DemuxerStream::VIDEO, &status, &last_timestamp);
   ASSERT_EQ(status, DemuxerStream::kConfigChanged);
-  EXPECT_EQ(last_timestamp.InMilliseconds(), 793);
+  EXPECT_EQ(last_timestamp.InMilliseconds(), 760);

[chcunningham, 2016/02/12 22:46:40]

Whats this small adjustment about?

[wolenetz, 2016/02/24 00:34:46]

Per l.909 and l.916, and per the new "remove previously buffered overlapped
region between coded-frame-group-start and the start of the first frame for this
track since the coded frame group started" logic, there is one less video coded
frame buffered from where the 320x200 bear1 coded frame group (with start at
time 779 (jagged start, audio: 779, video:801)) overlapped the 640x480 bear2
append. So there is an expected additional remove of [779,801) included in the
remove [new video coded frames from 801 onwards) done as part of the append to
the video SBS. This is "part 2a" from your CR comment breakdown of step 7.
See also InitDemuxerWithConfigChangeData() for details on how the API is
exercised to setup the SourceBufferStreams for these config change tests.

[chcunningham, 2016/02/24 19:06:26]

Acknowledged.

 
   // Get the new config and verify that it matches the first one.
   ASSERT_TRUE(video_config_1.Matches(video->video_decoder_config()));
@@ -4401,4 +4405,212 @@ TEST_F(ChunkDemuxerTest, SegmentMissingAudioVideoFrames) {
   AppendCluster(GenerateEmptyCluster(0));
 }
 
+TEST_F(ChunkDemuxerTest, RelaxedKeyframe_FirstSegmentMissingKeyframe) {
+  // Append V:[n n n][n n K]
+  // Expect V:           [K]
+  ASSERT_TRUE(InitDemuxer(HAS_VIDEO));
+  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+
+  EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(10)).Times(2);
+  AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "0 10 20");
+  AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "30 40 50K");
+  CheckExpectedRanges("{ [50,60) }");
+  CheckExpectedBuffers(video_stream, "50K");
+}
+
+TEST_F(ChunkDemuxerTest, RelaxedKeyframe_SecondSegmentMissingKeyframe) {
+  // Append V:[K n n][n n n]
+  // Expect V:[K n n][n n n]
+  ASSERT_TRUE(InitDemuxer(HAS_VIDEO));
+  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+
+  EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(10)).Times(2);
+  AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "0K 10 20");
+  AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "30 40 50");
+  CheckExpectedRanges("{ [0,60) }");
+  CheckExpectedBuffers(video_stream, "0K 10 20 30 40 50");
+}
+
+TEST_F(ChunkDemuxerTest, RelaxedKeyframe_RemoveInterruptsCodedFrameGroup_1) {
+  // Append V:[K n n]
+  // Remove    *****
+  // Append V:       [n n n][n K n]
+  // Expect:                  [K n]
+  ASSERT_TRUE(InitDemuxer(HAS_VIDEO));
+  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+
+  EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(10)).Times(3);
+  AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "0K 10 20");
+  demuxer_->Remove(kSourceId, base::TimeDelta(),
+                   base::TimeDelta::FromMilliseconds(30));
+  AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "30 40 50");
+  AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "60 70K 80");
+  CheckExpectedRanges("{ [70,90) }");
+  CheckExpectedBuffers(video_stream, "70K 80");
+}
+
+TEST_F(ChunkDemuxerTest, RelaxedKeyframe_RemoveInterruptsCodedFrameGroup_2) {
+  // Append V:[K n n][n n n][n K n]
+  // Remove    *
+  // Expect:                  [K n]
+  ASSERT_TRUE(InitDemuxer(HAS_VIDEO));
+  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+
+  EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(10)).Times(3);
+  AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "0K 10 20");
+  AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "30 40 50");
+  AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "60 70K 80");
+  demuxer_->Remove(kSourceId, base::TimeDelta(),
+                   base::TimeDelta::FromMilliseconds(10));
+  CheckExpectedRanges("{ [70,90) }");
+  CheckExpectedBuffers(video_stream, "70K 80");
+}
+
+TEST_F(ChunkDemuxerTest, RelaxedKeyframe_RemoveInterruptsCodedFrameGroup_3) {
+  // Append V:[K n n][n n n][n K n]
+  // Remove               *
+  // Expect:  [K n n..n n]    [K n]
+  ASSERT_TRUE(InitDemuxer(HAS_VIDEO));
+  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+
+  EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(10)).Times(3);
+  AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "0K 10 20");
+  AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "30 40 50");
+  AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "60 70K 80");
+  demuxer_->Remove(kSourceId, base::TimeDelta::FromMilliseconds(50),
+                   base::TimeDelta::FromMilliseconds(60));
+  CheckExpectedRanges("{ [0,50) [70,90) }");
+  CheckExpectedBuffers(video_stream, "0K 10 20 30 40");
+  Seek(base::TimeDelta::FromMilliseconds(70));
+  CheckExpectedBuffers(video_stream, "70K 80");
+}
+
+TEST_F(ChunkDemuxerTest,
+       RelaxedKeyframe_RemoveInterruptsMuxedCodedFrameGroup_1) {
+  // Append muxed:
+  //        A:[K K K]
+  //        V:[K n n]
+  // Remove    *****
+  // Append muxed:
+  //        A:       [K K K][K K K]
+  //        V:       [n n n][n K n]
+  // Expect:
+  //        A:       [K K K][K K K]
+  //        V                 [K n]
+  ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
+  DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+
+  AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "0K 10K 20D10K"),
+                     MuxedStreamInfo(kVideoTrackNum, "0K 10 20", 10));
+  demuxer_->Remove(kSourceId, base::TimeDelta(),
+                   base::TimeDelta::FromMilliseconds(30));
+  AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "30K 40K 50D10K"),
+                     MuxedStreamInfo(kVideoTrackNum, "30 40 50", 10));
+  AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "60K 70K 80D10K"),
+                     MuxedStreamInfo(kVideoTrackNum, "60 70K 80", 10));
+  CheckExpectedRanges(DemuxerStream::AUDIO, "{ [30,90) }");
+  CheckExpectedRanges(DemuxerStream::VIDEO, "{ [70,90) }");
+  CheckExpectedRanges("{ [70,90) }");
+  CheckExpectedBuffers(audio_stream, "30K 40K 50K 60K 70K 80K");
+  CheckExpectedBuffers(video_stream, "70K 80");
+}
+
+TEST_F(ChunkDemuxerTest,
+       RelaxedKeyframe_RemoveInterruptsMuxedCodedFrameGroup_2) {
+  // Append muxed:
+  //        A:[K K K]
+  //        V:(Nothing, simulating jagged cluster start or a long previous
+  //          video frame)
+  // Remove    *****
+  // Append muxed:
+  //        A:       [K K K][K K K]
+  //        V:       [n n n][n K n]
+  // Expect:
+  //        A:       [K K K][K K K]
+  //        V [................K n] (As would occur if there really were a
+  //        jagged cluster start and not badly muxed clusters as used to
+  //        simulate a jagged start in this test.)
+  ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
+  DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+
+  EXPECT_MEDIA_LOG(SegmentMissingFrames("video"));
+  AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "0K 10K 20D10K"),
+                     MuxedStreamInfo(kVideoTrackNum, ""));
+  demuxer_->Remove(kSourceId, base::TimeDelta(),
+                   base::TimeDelta::FromMilliseconds(30));
+  AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "30K 40K 50D10K"),
+                     MuxedStreamInfo(kVideoTrackNum, "30 40 50", 10));
+  AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "60K 70K 80D10K"),
+                     MuxedStreamInfo(kVideoTrackNum, "60 70K 80", 10));
+  CheckExpectedRanges(DemuxerStream::AUDIO, "{ [30,90) }");
+  CheckExpectedRanges(DemuxerStream::VIDEO, "{ [0,90) }");
+  CheckExpectedRanges("{ [30,90) }");
+  CheckExpectedBuffers(audio_stream, "30K 40K 50K 60K 70K 80K");
+  CheckExpectedBuffers(video_stream, "70K 80");
+}
+
+TEST_F(ChunkDemuxerTest,
+       RelaxedKeyframe_RemoveInterruptsMuxedCodedFrameGroup_3) {
+  // Append muxed:
+  //        A:[K K K
+  //        V:(Nothing yet. This is a jagged start, not simulated.)
+  // Remove    *****
+  // Append muxed:
+  //        A:       K K K K K K]
+  //        V:       n n n n K n]
+  // Expect:
+  //        A:      [K K K K K K]
+  //        V [..............K n]
+  ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
+  DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+
+  std::vector<MuxedStreamInfo> msi(2);
+  msi[0] =
+      MuxedStreamInfo(kAudioTrackNum, "0K 10K 20K 30K 40K 50K 60K 70K 80D10K");
+  msi[1] = MuxedStreamInfo(kVideoTrackNum, "31 41 51 61 71K 81", 10);
+  scoped_ptr<Cluster> cluster = GenerateMuxedCluster(msi);
+
+  // Append the first part of the cluster, up to the beginning of the first
+  // video simpleblock. The result should be just 4 audio blocks and no video
+  // blocks are appended. Since the stream parser does not yet have a duration
+  // for the 4th audio block in this partial cluster append, it is not yet
+  // emitted from the parser, and only the first 3 audio blocks are expected to
+  // be buffered by and available from the demuxer.
+  ASSERT_EQ(kVideoTrackNum, 1);
+  int video_start = 0;
+  bool found = false;
+  while (video_start < cluster->size() - 10) {
+    if (cluster->data()[video_start] == 0xA3 &&
+        cluster->data()[video_start + 9] == 0x81) {
+      found = true;
+      break;
+    }
+    video_start++;
+  }
+
+  ASSERT_TRUE(found);
+  ASSERT_GT(video_start, 0);
+  ASSERT_LT(video_start, cluster->size() - 3);
+
+  AppendData(kSourceId, cluster->data(), video_start);
+  CheckExpectedRanges(DemuxerStream::AUDIO, "{ [0,30) }");
+  CheckExpectedRanges(DemuxerStream::VIDEO, "{ }");
+
+  demuxer_->Remove(kSourceId, base::TimeDelta(),
+                   base::TimeDelta::FromMilliseconds(30));
+
+  // Append the remainder of the cluster
+  AppendData(kSourceId, cluster->data() + video_start,
+             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