| Index: media/filters/source_buffer_stream_unittest.cc
|
| diff --git a/media/filters/source_buffer_stream_unittest.cc b/media/filters/source_buffer_stream_unittest.cc
|
| index cb8d2174f5ea4001fd03f43f67d1948834b1cdc9..53e8066ed6189b9cd0e875ff6d548a5e383ca54a 100644
|
| --- a/media/filters/source_buffer_stream_unittest.cc
|
| +++ b/media/filters/source_buffer_stream_unittest.cc
|
| @@ -41,17 +41,11 @@ static const uint8_t kDataB = 0x33;
|
| static const int kDataSize = 1;
|
|
|
| // Matchers for verifying common media log entry strings.
|
| -MATCHER(ContainsMissingKeyframeLog, "") {
|
| - return CONTAINS_STRING(arg,
|
| - "Media segment did not begin with key frame. Support "
|
| - "for such segments will be available in a future "
|
| - "version. Please see https://crbug.com/229412.");
|
| -}
|
| -
|
| MATCHER(ContainsSameTimestampAt30MillisecondsLog, "") {
|
| return CONTAINS_STRING(arg,
|
| - "Unexpected combination of buffers with the same "
|
| - "timestamp detected at 0.03");
|
| + "Detected an append sequence with keyframe following "
|
| + "a non-keyframe, both with the same decode timestamp "
|
| + "of 0.03");
|
| }
|
|
|
| MATCHER_P(ContainsTrackBufferExhaustionSkipLog, skip_milliseconds, "") {
|
| @@ -115,27 +109,28 @@ class SourceBufferStreamTest : public testing::Test {
|
| SetStreamInfo(500, 500);
|
| }
|
|
|
| - void NewSegmentAppend(int starting_position, int number_of_buffers) {
|
| + void NewCodedFrameGroupAppend(int starting_position, int number_of_buffers) {
|
| AppendBuffers(starting_position, number_of_buffers, true,
|
| base::TimeDelta(), true, &kDataA, kDataSize);
|
| }
|
|
|
| - void NewSegmentAppend(int starting_position,
|
| - int number_of_buffers,
|
| - const uint8_t* data) {
|
| + void NewCodedFrameGroupAppend(int starting_position,
|
| + int number_of_buffers,
|
| + const uint8_t* data) {
|
| AppendBuffers(starting_position, number_of_buffers, true,
|
| base::TimeDelta(), true, data, kDataSize);
|
| }
|
|
|
| - void NewSegmentAppend_OffsetFirstBuffer(
|
| - int starting_position, int number_of_buffers,
|
| + void NewCodedFrameGroupAppend_OffsetFirstBuffer(
|
| + int starting_position,
|
| + int number_of_buffers,
|
| base::TimeDelta first_buffer_offset) {
|
| AppendBuffers(starting_position, number_of_buffers, true,
|
| first_buffer_offset, true, &kDataA, kDataSize);
|
| }
|
|
|
| - void NewSegmentAppend_ExpectFailure(
|
| - int starting_position, int number_of_buffers) {
|
| + void NewCodedFrameGroupAppend_ExpectFailure(int starting_position,
|
| + int number_of_buffers) {
|
| AppendBuffers(starting_position, number_of_buffers, true,
|
| base::TimeDelta(), false, &kDataA, kDataSize);
|
| }
|
| @@ -152,12 +147,12 @@ class SourceBufferStreamTest : public testing::Test {
|
| base::TimeDelta(), true, data, kDataSize);
|
| }
|
|
|
| - void NewSegmentAppend(const std::string& buffers_to_append) {
|
| + void NewCodedFrameGroupAppend(const std::string& buffers_to_append) {
|
| AppendBuffers(buffers_to_append, true, kNoTimestamp(), false, true);
|
| }
|
|
|
| - void NewSegmentAppend(base::TimeDelta start_timestamp,
|
| - const std::string& buffers_to_append) {
|
| + void NewCodedFrameGroupAppend(base::TimeDelta start_timestamp,
|
| + const std::string& buffers_to_append) {
|
| AppendBuffers(buffers_to_append, true, start_timestamp, false, true);
|
| }
|
|
|
| @@ -165,7 +160,7 @@ class SourceBufferStreamTest : public testing::Test {
|
| AppendBuffers(buffers_to_append, false, kNoTimestamp(), false, true);
|
| }
|
|
|
| - void NewSegmentAppendOneByOne(const std::string& buffers_to_append) {
|
| + void NewCodedFrameGroupAppendOneByOne(const std::string& buffers_to_append) {
|
| AppendBuffers(buffers_to_append, true, kNoTimestamp(), true, true);
|
| }
|
|
|
| @@ -173,7 +168,8 @@ class SourceBufferStreamTest : public testing::Test {
|
| AppendBuffers(buffers_to_append, false, kNoTimestamp(), true, true);
|
| }
|
|
|
| - void NewSegmentAppend_ExpectFailure(const std::string& buffers_to_append) {
|
| + void NewCodedFrameGroupAppend_ExpectFailure(
|
| + const std::string& buffers_to_append) {
|
| AppendBuffers(buffers_to_append, true, kNoTimestamp(), false, false);
|
| }
|
|
|
| @@ -206,6 +202,11 @@ class SourceBufferStreamTest : public testing::Test {
|
| stream_->Remove(start, end, duration);
|
| }
|
|
|
| + void SignalStartOfCodedFrameGroup(base::TimeDelta start_timestamp) {
|
| + stream_->OnStartOfCodedFrameGroup(
|
| + DecodeTimestamp::FromPresentationTime(start_timestamp));
|
| + }
|
| +
|
| int GetRemovalRangeInMs(int start, int end, int bytes_to_free,
|
| int* removal_end) {
|
| DecodeTimestamp removal_end_timestamp =
|
| @@ -439,13 +440,13 @@ class SourceBufferStreamTest : public testing::Test {
|
|
|
| void AppendBuffers(int starting_position,
|
| int number_of_buffers,
|
| - bool begin_media_segment,
|
| + bool begin_coded_frame_group,
|
| base::TimeDelta first_buffer_offset,
|
| bool expect_success,
|
| const uint8_t* data,
|
| int size) {
|
| - if (begin_media_segment)
|
| - stream_->OnNewMediaSegment(DecodeTimestamp::FromPresentationTime(
|
| + if (begin_coded_frame_group)
|
| + stream_->OnStartOfCodedFrameGroup(DecodeTimestamp::FromPresentationTime(
|
| starting_position * frame_duration_));
|
|
|
| int keyframe_interval = frames_per_second_ / keyframes_per_second_;
|
| @@ -687,20 +688,20 @@ class SourceBufferStreamTest : public testing::Test {
|
| }
|
|
|
| void AppendBuffers(const std::string& buffers_to_append,
|
| - bool start_new_segment,
|
| - base::TimeDelta segment_start_timestamp,
|
| + bool start_new_coded_frame_group,
|
| + base::TimeDelta coded_frame_group_start_timestamp,
|
| bool one_by_one,
|
| bool expect_success) {
|
| BufferQueue buffers = StringToBufferQueue(buffers_to_append);
|
|
|
| - if (start_new_segment) {
|
| - base::TimeDelta start_timestamp = segment_start_timestamp;
|
| + if (start_new_coded_frame_group) {
|
| + base::TimeDelta start_timestamp = coded_frame_group_start_timestamp;
|
| if (start_timestamp == kNoTimestamp())
|
| start_timestamp = buffers[0]->timestamp();
|
|
|
| ASSERT_TRUE(start_timestamp <= buffers[0]->timestamp());
|
|
|
| - stream_->OnNewMediaSegment(
|
| + stream_->OnStartOfCodedFrameGroup(
|
| DecodeTimestamp::FromPresentationTime(start_timestamp));
|
| }
|
|
|
| @@ -725,7 +726,7 @@ class SourceBufferStreamTest : public testing::Test {
|
|
|
| TEST_F(SourceBufferStreamTest, Append_SingleRange) {
|
| // Append 15 buffers at positions 0 through 14.
|
| - NewSegmentAppend(0, 15);
|
| + NewCodedFrameGroupAppend(0, 15);
|
|
|
| // Check expected range.
|
| CheckExpectedRanges("{ [0,14) }");
|
| @@ -736,7 +737,7 @@ TEST_F(SourceBufferStreamTest, Append_SingleRange) {
|
|
|
| TEST_F(SourceBufferStreamTest, Append_SingleRange_OneBufferAtATime) {
|
| // Append 15 buffers starting at position 0, one buffer at a time.
|
| - NewSegmentAppend(0, 1);
|
| + NewCodedFrameGroupAppend(0, 1);
|
| for (int i = 1; i < 15; i++)
|
| AppendBuffers(i, 1);
|
|
|
| @@ -749,10 +750,10 @@ TEST_F(SourceBufferStreamTest, Append_SingleRange_OneBufferAtATime) {
|
|
|
| TEST_F(SourceBufferStreamTest, Append_DisjointRanges) {
|
| // Append 5 buffers at positions 0 through 4.
|
| - NewSegmentAppend(0, 5);
|
| + NewCodedFrameGroupAppend(0, 5);
|
|
|
| // Append 10 buffers at positions 15 through 24.
|
| - NewSegmentAppend(15, 10);
|
| + NewCodedFrameGroupAppend(15, 10);
|
|
|
| // Check expected ranges.
|
| CheckExpectedRanges("{ [0,4) [15,24) }");
|
| @@ -765,13 +766,13 @@ TEST_F(SourceBufferStreamTest, Append_DisjointRanges) {
|
|
|
| TEST_F(SourceBufferStreamTest, Append_AdjacentRanges) {
|
| // Append 10 buffers at positions 0 through 9.
|
| - NewSegmentAppend(0, 10);
|
| + NewCodedFrameGroupAppend(0, 10);
|
|
|
| // Append 11 buffers at positions 15 through 25.
|
| - NewSegmentAppend(15, 11);
|
| + NewCodedFrameGroupAppend(15, 11);
|
|
|
| // Append 5 buffers at positions 10 through 14 to bridge the gap.
|
| - NewSegmentAppend(10, 5);
|
| + NewCodedFrameGroupAppend(10, 5);
|
|
|
| // Check expected range.
|
| CheckExpectedRanges("{ [0,25) }");
|
| @@ -780,52 +781,12 @@ TEST_F(SourceBufferStreamTest, Append_AdjacentRanges) {
|
| CheckExpectedBuffers(0, 25);
|
| }
|
|
|
| -TEST_F(SourceBufferStreamTest, Append_DoesNotBeginWithKeyframe) {
|
| - EXPECT_MEDIA_LOG(ContainsMissingKeyframeLog()).Times(2);
|
| -
|
| - // Append fails because the range doesn't begin with a keyframe.
|
| - NewSegmentAppend_ExpectFailure(3, 2);
|
| -
|
| - // Append 10 buffers at positions 5 through 14.
|
| - NewSegmentAppend(5, 10);
|
| -
|
| - // Check expected range.
|
| - CheckExpectedRanges("{ [5,14) }");
|
| - // Check buffers in range.
|
| - Seek(5);
|
| - CheckExpectedBuffers(5, 14);
|
| -
|
| - // Append fails because the range doesn't begin with a keyframe.
|
| - NewSegmentAppend_ExpectFailure(17, 3);
|
| -
|
| - CheckExpectedRanges("{ [5,14) }");
|
| - Seek(5);
|
| - CheckExpectedBuffers(5, 14);
|
| -}
|
| -
|
| -TEST_F(SourceBufferStreamTest, Append_DoesNotBeginWithKeyframe_Adjacent) {
|
| - EXPECT_MEDIA_LOG(ContainsMissingKeyframeLog());
|
| -
|
| - // Append 8 buffers at positions 0 through 7.
|
| - NewSegmentAppend(0, 8);
|
| -
|
| - // Now start a new media segment at position 8. Append should fail because
|
| - // the media segment does not begin with a keyframe.
|
| - NewSegmentAppend_ExpectFailure(8, 2);
|
| -
|
| - // Check expected range.
|
| - CheckExpectedRanges("{ [0,7) }");
|
| - // Check buffers in range.
|
| - Seek(0);
|
| - CheckExpectedBuffers(0, 7);
|
| -}
|
| -
|
| TEST_F(SourceBufferStreamTest, Complete_Overlap) {
|
| // Append 5 buffers at positions 5 through 9.
|
| - NewSegmentAppend(5, 5);
|
| + NewCodedFrameGroupAppend(5, 5);
|
|
|
| // Append 15 buffers at positions 0 through 14.
|
| - NewSegmentAppend(0, 15);
|
| + NewCodedFrameGroupAppend(0, 15);
|
|
|
| // Check expected range.
|
| CheckExpectedRanges("{ [0,14) }");
|
| @@ -835,18 +796,19 @@ TEST_F(SourceBufferStreamTest, Complete_Overlap) {
|
| }
|
|
|
| TEST_F(SourceBufferStreamTest,
|
| - Complete_Overlap_AfterSegmentTimestampAndBeforeFirstBufferTimestamp) {
|
| - // Append a segment with a start timestamp of 0, but the first
|
| + Complete_Overlap_AfterGroupTimestampAndBeforeFirstBufferTimestamp) {
|
| + // Append a coded frame group with a start timestamp of 0, but the first
|
| // buffer starts at 30ms. This can happen in muxed content where the
|
| // audio starts before the first frame.
|
| - NewSegmentAppend(base::TimeDelta::FromMilliseconds(0), "30K 60K 90K 120K");
|
| + NewCodedFrameGroupAppend(base::TimeDelta::FromMilliseconds(0),
|
| + "30K 60K 90K 120K");
|
|
|
| CheckExpectedRangesByTimestamp("{ [0,150) }");
|
|
|
| - // Completely overlap the old buffers, with a segment that starts
|
| - // after the old segment start timestamp, but before the timestamp
|
| - // of the first buffer in the segment.
|
| - NewSegmentAppend("20K 50K 80K 110D10K");
|
| + // Completely overlap the old buffers, with a coded frame group that starts
|
| + // after the old coded frame group start timestamp, but before the timestamp
|
| + // of the first buffer in the coded frame group.
|
| + NewCodedFrameGroupAppend("20K 50K 80K 110D10K");
|
|
|
| // Verify that the buffered ranges are updated properly and we don't crash.
|
| CheckExpectedRangesByTimestamp("{ [20,150) }");
|
| @@ -861,10 +823,10 @@ TEST_F(SourceBufferStreamTest, Complete_Overlap_EdgeCase) {
|
| SetStreamInfo(30, 30);
|
|
|
| // Append 6 buffers at positions 6 through 11.
|
| - NewSegmentAppend(6, 6);
|
| + NewCodedFrameGroupAppend(6, 6);
|
|
|
| // Append 8 buffers at positions 5 through 12.
|
| - NewSegmentAppend(5, 8);
|
| + NewCodedFrameGroupAppend(5, 8);
|
|
|
| // Check expected range.
|
| CheckExpectedRanges("{ [5,12) }");
|
| @@ -875,10 +837,10 @@ TEST_F(SourceBufferStreamTest, Complete_Overlap_EdgeCase) {
|
|
|
| TEST_F(SourceBufferStreamTest, Start_Overlap) {
|
| // Append 10 buffers at positions 5 through 14.
|
| - NewSegmentAppend(5, 5);
|
| + NewCodedFrameGroupAppend(5, 5);
|
|
|
| // Append 6 buffers at positions 10 through 15.
|
| - NewSegmentAppend(10, 6);
|
| + NewCodedFrameGroupAppend(10, 6);
|
|
|
| // Check expected range.
|
| CheckExpectedRanges("{ [5,15) }");
|
| @@ -889,10 +851,10 @@ TEST_F(SourceBufferStreamTest, Start_Overlap) {
|
|
|
| TEST_F(SourceBufferStreamTest, End_Overlap) {
|
| // Append 10 buffers at positions 10 through 19.
|
| - NewSegmentAppend(10, 10);
|
| + NewCodedFrameGroupAppend(10, 10);
|
|
|
| // Append 10 buffers at positions 5 through 14.
|
| - NewSegmentAppend(5, 10);
|
| + NewCodedFrameGroupAppend(5, 10);
|
|
|
| // Check expected range.
|
| CheckExpectedRanges("{ [5,19) }");
|
| @@ -903,10 +865,10 @@ TEST_F(SourceBufferStreamTest, End_Overlap) {
|
|
|
| TEST_F(SourceBufferStreamTest, End_Overlap_Several) {
|
| // Append 10 buffers at positions 10 through 19.
|
| - NewSegmentAppend(10, 10);
|
| + NewCodedFrameGroupAppend(10, 10);
|
|
|
| // Append 8 buffers at positions 5 through 12.
|
| - NewSegmentAppend(5, 8);
|
| + NewCodedFrameGroupAppend(5, 8);
|
|
|
| // Check expected ranges: stream should not have kept buffers 13 and 14
|
| // because the keyframe on which they depended was overwritten.
|
| @@ -931,10 +893,10 @@ TEST_F(SourceBufferStreamTest, End_Overlap_SingleBuffer) {
|
| // Seek to start of stream.
|
| SeekToTimestampMs(0);
|
|
|
| - NewSegmentAppend("0K 30 60 90 120K 150");
|
| + NewCodedFrameGroupAppend("0K 30 60 90 120K 150");
|
| CheckExpectedRangesByTimestamp("{ [0,180) }");
|
|
|
| - NewSegmentAppend("0D30K");
|
| + NewCodedFrameGroupAppend("0D30K");
|
| CheckExpectedRangesByTimestamp("{ [0,30) [120,180) }");
|
|
|
| CheckExpectedBuffers("0K");
|
| @@ -943,19 +905,19 @@ TEST_F(SourceBufferStreamTest, End_Overlap_SingleBuffer) {
|
|
|
| TEST_F(SourceBufferStreamTest, Complete_Overlap_Several) {
|
| // Append 2 buffers at positions 5 through 6.
|
| - NewSegmentAppend(5, 2);
|
| + NewCodedFrameGroupAppend(5, 2);
|
|
|
| // Append 2 buffers at positions 10 through 11.
|
| - NewSegmentAppend(10, 2);
|
| + NewCodedFrameGroupAppend(10, 2);
|
|
|
| // Append 2 buffers at positions 15 through 16.
|
| - NewSegmentAppend(15, 2);
|
| + NewCodedFrameGroupAppend(15, 2);
|
|
|
| // Check expected ranges.
|
| CheckExpectedRanges("{ [5,6) [10,11) [15,16) }");
|
|
|
| // Append buffers at positions 0 through 19.
|
| - NewSegmentAppend(0, 20);
|
| + NewCodedFrameGroupAppend(0, 20);
|
|
|
| // Check expected range.
|
| CheckExpectedRanges("{ [0,19) }");
|
| @@ -966,19 +928,19 @@ TEST_F(SourceBufferStreamTest, Complete_Overlap_Several) {
|
|
|
| TEST_F(SourceBufferStreamTest, Complete_Overlap_Several_Then_Merge) {
|
| // Append 2 buffers at positions 5 through 6.
|
| - NewSegmentAppend(5, 2);
|
| + NewCodedFrameGroupAppend(5, 2);
|
|
|
| // Append 2 buffers at positions 10 through 11.
|
| - NewSegmentAppend(10, 2);
|
| + NewCodedFrameGroupAppend(10, 2);
|
|
|
| // Append 2 buffers at positions 15 through 16.
|
| - NewSegmentAppend(15, 2);
|
| + NewCodedFrameGroupAppend(15, 2);
|
|
|
| // Append 2 buffers at positions 20 through 21.
|
| - NewSegmentAppend(20, 2);
|
| + NewCodedFrameGroupAppend(20, 2);
|
|
|
| // Append buffers at positions 0 through 19.
|
| - NewSegmentAppend(0, 20);
|
| + NewCodedFrameGroupAppend(0, 20);
|
|
|
| // Check expected ranges.
|
| CheckExpectedRanges("{ [0,21) }");
|
| @@ -989,13 +951,13 @@ TEST_F(SourceBufferStreamTest, Complete_Overlap_Several_Then_Merge) {
|
|
|
| TEST_F(SourceBufferStreamTest, Complete_Overlap_Selected) {
|
| // Append 10 buffers at positions 5 through 14.
|
| - NewSegmentAppend(5, 10, &kDataA);
|
| + NewCodedFrameGroupAppend(5, 10, &kDataA);
|
|
|
| // Seek to buffer at position 5.
|
| Seek(5);
|
|
|
| // Replace old data with new data.
|
| - NewSegmentAppend(5, 10, &kDataB);
|
| + NewCodedFrameGroupAppend(5, 10, &kDataB);
|
|
|
| // Check ranges are correct.
|
| CheckExpectedRanges("{ [5,14) }");
|
| @@ -1010,14 +972,14 @@ TEST_F(SourceBufferStreamTest, Complete_Overlap_Selected) {
|
| // the keyframe of the new data, after which it will return the new data.
|
| TEST_F(SourceBufferStreamTest, Complete_Overlap_Selected_TrackBuffer) {
|
| // Append 10 buffers at positions 5 through 14.
|
| - NewSegmentAppend(5, 10, &kDataA);
|
| + NewCodedFrameGroupAppend(5, 10, &kDataA);
|
|
|
| // Seek to buffer at position 5 and get next buffer.
|
| Seek(5);
|
| CheckExpectedBuffers(5, 5, &kDataA);
|
|
|
| // Do a complete overlap by appending 20 buffers at positions 0 through 19.
|
| - NewSegmentAppend(0, 20, &kDataB);
|
| + NewCodedFrameGroupAppend(0, 20, &kDataB);
|
|
|
| // Check range is correct.
|
| CheckExpectedRanges("{ [0,19) }");
|
| @@ -1039,14 +1001,14 @@ TEST_F(SourceBufferStreamTest, Complete_Overlap_Selected_TrackBuffer) {
|
|
|
| TEST_F(SourceBufferStreamTest, Complete_Overlap_Selected_EdgeCase) {
|
| // Append 10 buffers at positions 5 through 14.
|
| - NewSegmentAppend(5, 10, &kDataA);
|
| + NewCodedFrameGroupAppend(5, 10, &kDataA);
|
|
|
| // Seek to buffer at position 5 and get next buffer.
|
| Seek(5);
|
| CheckExpectedBuffers(5, 5, &kDataA);
|
|
|
| // Replace existing data with new data.
|
| - NewSegmentAppend(5, 10, &kDataB);
|
| + NewCodedFrameGroupAppend(5, 10, &kDataB);
|
|
|
| // Check ranges are correct.
|
| CheckExpectedRanges("{ [5,14) }");
|
| @@ -1071,23 +1033,23 @@ TEST_F(SourceBufferStreamTest, Complete_Overlap_Selected_Multiple) {
|
| static const uint8_t kDataD = 0x77;
|
|
|
| // Append 5 buffers at positions 5 through 9.
|
| - NewSegmentAppend(5, 5, &kDataA);
|
| + NewCodedFrameGroupAppend(5, 5, &kDataA);
|
|
|
| // Seek to buffer at position 5 and get next buffer.
|
| Seek(5);
|
| CheckExpectedBuffers(5, 5, &kDataA);
|
|
|
| // Replace existing data with new data.
|
| - NewSegmentAppend(5, 5, &kDataB);
|
| + NewCodedFrameGroupAppend(5, 5, &kDataB);
|
|
|
| // Then replace it again with different data.
|
| - NewSegmentAppend(5, 5, &kDataC);
|
| + NewCodedFrameGroupAppend(5, 5, &kDataC);
|
|
|
| // Now append 5 new buffers at positions 10 through 14.
|
| - NewSegmentAppend(10, 5, &kDataC);
|
| + NewCodedFrameGroupAppend(10, 5, &kDataC);
|
|
|
| // Now replace all the data entirely.
|
| - NewSegmentAppend(5, 10, &kDataD);
|
| + NewCodedFrameGroupAppend(5, 10, &kDataD);
|
|
|
| // Expect buffers 6 through 9 to be DataA, and the remaining
|
| // buffers to be kDataD.
|
| @@ -1104,11 +1066,11 @@ TEST_F(SourceBufferStreamTest, Complete_Overlap_Selected_Multiple) {
|
|
|
| TEST_F(SourceBufferStreamTest, Start_Overlap_Selected) {
|
| // Append 10 buffers at positions 0 through 9.
|
| - NewSegmentAppend(0, 10, &kDataA);
|
| + NewCodedFrameGroupAppend(0, 10, &kDataA);
|
|
|
| // Seek to position 5, then add buffers to overlap data at that position.
|
| Seek(5);
|
| - NewSegmentAppend(5, 10, &kDataB);
|
| + NewCodedFrameGroupAppend(5, 10, &kDataB);
|
|
|
| // Check expected range.
|
| CheckExpectedRanges("{ [0,14) }");
|
| @@ -1124,14 +1086,14 @@ TEST_F(SourceBufferStreamTest, Start_Overlap_Selected) {
|
|
|
| TEST_F(SourceBufferStreamTest, Start_Overlap_Selected_TrackBuffer) {
|
| // Append 15 buffers at positions 0 through 14.
|
| - NewSegmentAppend(0, 15, &kDataA);
|
| + NewCodedFrameGroupAppend(0, 15, &kDataA);
|
|
|
| // Seek to 10 and get buffer.
|
| Seek(10);
|
| CheckExpectedBuffers(10, 10, &kDataA);
|
|
|
| // Now append 10 buffers of new data at positions 10 through 19.
|
| - NewSegmentAppend(10, 10, &kDataB);
|
| + NewCodedFrameGroupAppend(10, 10, &kDataB);
|
|
|
| // Check expected range.
|
| CheckExpectedRanges("{ [0,19) }");
|
| @@ -1156,13 +1118,13 @@ TEST_F(SourceBufferStreamTest, Start_Overlap_Selected_TrackBuffer) {
|
|
|
| TEST_F(SourceBufferStreamTest, Start_Overlap_Selected_EdgeCase) {
|
| // Append 10 buffers at positions 5 through 14.
|
| - NewSegmentAppend(5, 10, &kDataA);
|
| + NewCodedFrameGroupAppend(5, 10, &kDataA);
|
|
|
| Seek(10);
|
| CheckExpectedBuffers(10, 10, &kDataA);
|
|
|
| // Now replace the last 5 buffers with new data.
|
| - NewSegmentAppend(10, 5, &kDataB);
|
| + NewCodedFrameGroupAppend(10, 5, &kDataB);
|
|
|
| // The next 4 buffers should be the origial data, held in the track buffer.
|
| CheckExpectedBuffers(11, 14, &kDataA);
|
| @@ -1172,7 +1134,7 @@ TEST_F(SourceBufferStreamTest, Start_Overlap_Selected_EdgeCase) {
|
| CheckNoNextBuffer();
|
|
|
| // Now append data at 15 through 19 and check to make sure it's correct.
|
| - NewSegmentAppend(15, 5, &kDataB);
|
| + NewCodedFrameGroupAppend(15, 5, &kDataB);
|
| CheckExpectedBuffers(15, 19, &kDataB);
|
|
|
| // Seek to beginning of buffered range and check buffers.
|
| @@ -1193,13 +1155,13 @@ TEST_F(SourceBufferStreamTest, Start_Overlap_Selected_EdgeCase) {
|
| // after: B b b b b*B*b b b b A a a a a
|
| TEST_F(SourceBufferStreamTest, End_Overlap_Selected) {
|
| // Append 10 buffers at positions 5 through 14.
|
| - NewSegmentAppend(5, 10, &kDataA);
|
| + NewCodedFrameGroupAppend(5, 10, &kDataA);
|
|
|
| // Seek to position 5.
|
| Seek(5);
|
|
|
| // Now append 10 buffers at positions 0 through 9.
|
| - NewSegmentAppend(0, 10, &kDataB);
|
| + NewCodedFrameGroupAppend(0, 10, &kDataB);
|
|
|
| // Check expected range.
|
| CheckExpectedRanges("{ [0,14) }");
|
| @@ -1223,14 +1185,14 @@ TEST_F(SourceBufferStreamTest, End_Overlap_Selected) {
|
| // after: |B b b b b B b b b b A a a*a*a|
|
| TEST_F(SourceBufferStreamTest, End_Overlap_Selected_AfterEndOfNew_1) {
|
| // Append 10 buffers at positions 5 through 14.
|
| - NewSegmentAppend(5, 10, &kDataA);
|
| + NewCodedFrameGroupAppend(5, 10, &kDataA);
|
|
|
| // Seek to position 10, then move to position 13.
|
| Seek(10);
|
| CheckExpectedBuffers(10, 12, &kDataA);
|
|
|
| // Now append 10 buffers at positions 0 through 9.
|
| - NewSegmentAppend(0, 10, &kDataB);
|
| + NewCodedFrameGroupAppend(0, 10, &kDataB);
|
|
|
| // Check expected range.
|
| CheckExpectedRanges("{ [0,14) }");
|
| @@ -1255,14 +1217,14 @@ TEST_F(SourceBufferStreamTest, End_Overlap_Selected_AfterEndOfNew_1) {
|
| // after: |B b b b b B b b| |A a a*a*a|
|
| TEST_F(SourceBufferStreamTest, End_Overlap_Selected_AfterEndOfNew_2) {
|
| // Append 10 buffers at positions 5 through 14.
|
| - NewSegmentAppend(5, 10, &kDataA);
|
| + NewCodedFrameGroupAppend(5, 10, &kDataA);
|
|
|
| // Seek to position 10, then move to position 13.
|
| Seek(10);
|
| CheckExpectedBuffers(10, 12, &kDataA);
|
|
|
| // Now append 8 buffers at positions 0 through 7.
|
| - NewSegmentAppend(0, 8, &kDataB);
|
| + NewCodedFrameGroupAppend(0, 8, &kDataB);
|
|
|
| // Check expected ranges.
|
| CheckExpectedRanges("{ [0,7) [10,14) }");
|
| @@ -1291,14 +1253,14 @@ TEST_F(SourceBufferStreamTest, End_Overlap_Selected_AfterEndOfNew_2) {
|
| // track: |a a|
|
| TEST_F(SourceBufferStreamTest, End_Overlap_Selected_AfterEndOfNew_3) {
|
| // Append 10 buffers at positions 5 through 14.
|
| - NewSegmentAppend(5, 10, &kDataA);
|
| + NewCodedFrameGroupAppend(5, 10, &kDataA);
|
|
|
| // Seek to position 5, then move to position 8.
|
| Seek(5);
|
| CheckExpectedBuffers(5, 7, &kDataA);
|
|
|
| // Now append 8 buffers at positions 0 through 7.
|
| - NewSegmentAppend(0, 8, &kDataB);
|
| + NewCodedFrameGroupAppend(0, 8, &kDataB);
|
|
|
| // Check expected ranges.
|
| CheckExpectedRanges("{ [0,7) [10,14) }");
|
| @@ -1326,14 +1288,14 @@ TEST_F(SourceBufferStreamTest, End_Overlap_Selected_AfterEndOfNew_3) {
|
| // track: |a a|
|
| TEST_F(SourceBufferStreamTest, End_Overlap_Selected_OverlappedByNew_1) {
|
| // Append 10 buffers at positions 5 through 14.
|
| - NewSegmentAppend(5, 10, &kDataA);
|
| + NewCodedFrameGroupAppend(5, 10, &kDataA);
|
|
|
| // Seek to position 5, then move to position 8.
|
| Seek(5);
|
| CheckExpectedBuffers(5, 7, &kDataA);
|
|
|
| // Now append 10 buffers at positions 0 through 9.
|
| - NewSegmentAppend(0, 10, &kDataB);
|
| + NewCodedFrameGroupAppend(0, 10, &kDataB);
|
|
|
| // Check expected range.
|
| CheckExpectedRanges("{ [0,14) }");
|
| @@ -1361,14 +1323,14 @@ TEST_F(SourceBufferStreamTest, End_Overlap_Selected_OverlappedByNew_1) {
|
| // track: |a a a a|
|
| TEST_F(SourceBufferStreamTest, End_Overlap_Selected_OverlappedByNew_2) {
|
| // Append 10 buffers at positions 5 through 14.
|
| - NewSegmentAppend(5, 10, &kDataA);
|
| + NewCodedFrameGroupAppend(5, 10, &kDataA);
|
|
|
| // Seek to position 5, then move to position 6.
|
| Seek(5);
|
| CheckExpectedBuffers(5, 5, &kDataA);
|
|
|
| // Now append 7 buffers at positions 0 through 6.
|
| - NewSegmentAppend(0, 7, &kDataB);
|
| + NewCodedFrameGroupAppend(0, 7, &kDataB);
|
|
|
| // Check expected ranges.
|
| CheckExpectedRanges("{ [0,6) [10,14) }");
|
| @@ -1399,14 +1361,14 @@ TEST_F(SourceBufferStreamTest, End_Overlap_Selected_OverlappedByNew_2) {
|
| // track: |a a a a|
|
| TEST_F(SourceBufferStreamTest, End_Overlap_Selected_OverlappedByNew_3) {
|
| // Append 15 buffers at positions 5 through 19.
|
| - NewSegmentAppend(5, 15, &kDataA);
|
| + NewCodedFrameGroupAppend(5, 15, &kDataA);
|
|
|
| // Seek to position 5, then move to position 6.
|
| Seek(5);
|
| CheckExpectedBuffers(5, 5, &kDataA);
|
|
|
| // Now append 13 buffers at positions 0 through 12.
|
| - NewSegmentAppend(0, 13, &kDataB);
|
| + NewCodedFrameGroupAppend(0, 13, &kDataB);
|
|
|
| // Check expected ranges.
|
| CheckExpectedRanges("{ [0,12) [15,19) }");
|
| @@ -1435,14 +1397,14 @@ TEST_F(SourceBufferStreamTest, End_Overlap_Selected_OverlappedByNew_3) {
|
| // track: |a a a a|
|
| TEST_F(SourceBufferStreamTest, End_Overlap_Selected_NoKeyframeAfterNew) {
|
| // Append 5 buffers at positions 5 through 9.
|
| - NewSegmentAppend(5, 5, &kDataA);
|
| + NewCodedFrameGroupAppend(5, 5, &kDataA);
|
|
|
| // Seek to position 5, then move to position 6.
|
| Seek(5);
|
| CheckExpectedBuffers(5, 5, &kDataA);
|
|
|
| // Now append 6 buffers at positions 0 through 5.
|
| - NewSegmentAppend(0, 6, &kDataB);
|
| + NewCodedFrameGroupAppend(0, 6, &kDataB);
|
|
|
| // Check expected range.
|
| CheckExpectedRanges("{ [0,5) }");
|
| @@ -1474,19 +1436,19 @@ TEST_F(SourceBufferStreamTest, End_Overlap_Selected_NoKeyframeAfterNew2) {
|
| EXPECT_MEDIA_LOG(ContainsTrackBufferExhaustionSkipLog(133));
|
|
|
| // Append 7 buffers at positions 10 through 16.
|
| - NewSegmentAppend(10, 7, &kDataA);
|
| + NewCodedFrameGroupAppend(10, 7, &kDataA);
|
|
|
| // Seek to position 15, then move to position 16.
|
| Seek(15);
|
| CheckExpectedBuffers(15, 15, &kDataA);
|
|
|
| // Now append 11 buffers at positions 5 through 15.
|
| - NewSegmentAppend(5, 11, &kDataB);
|
| + NewCodedFrameGroupAppend(5, 11, &kDataB);
|
| CheckExpectedRanges("{ [5,15) }");
|
|
|
| // Now do another end-overlap to split the range into two parts, where the
|
| // 2nd range should have the next buffer position.
|
| - NewSegmentAppend(0, 6, &kDataA);
|
| + NewCodedFrameGroupAppend(0, 6, &kDataA);
|
| CheckExpectedRanges("{ [0,5) [10,15) }");
|
|
|
| // Check for data in the track buffer.
|
| @@ -1497,7 +1459,7 @@ TEST_F(SourceBufferStreamTest, End_Overlap_Selected_NoKeyframeAfterNew2) {
|
|
|
| // Add data to the 2nd range, should not be able to fulfill the next read
|
| // until we've added a keyframe.
|
| - NewSegmentAppend(15, 1, &kDataB);
|
| + NewCodedFrameGroupAppend(15, 1, &kDataB);
|
| CheckNoNextBuffer();
|
| for (int i = 16; i <= 19; i++) {
|
| AppendBuffers(i, 1, &kDataB);
|
| @@ -1520,10 +1482,10 @@ TEST_F(SourceBufferStreamTest, End_Overlap_Selected_NoKeyframeAfterNew2) {
|
| // track: |a a a a|
|
| TEST_F(SourceBufferStreamTest, End_Overlap_Selected_NoKeyframeAfterNew3) {
|
| // Append 5 buffers at positions 5 through 9.
|
| - NewSegmentAppend(5, 5, &kDataA);
|
| + NewCodedFrameGroupAppend(5, 5, &kDataA);
|
|
|
| // Append 5 buffers at positions 15 through 19.
|
| - NewSegmentAppend(15, 5, &kDataA);
|
| + NewCodedFrameGroupAppend(15, 5, &kDataA);
|
|
|
| // Check expected range.
|
| CheckExpectedRanges("{ [5,9) [15,19) }");
|
| @@ -1533,7 +1495,7 @@ TEST_F(SourceBufferStreamTest, End_Overlap_Selected_NoKeyframeAfterNew3) {
|
| CheckExpectedBuffers(5, 5, &kDataA);
|
|
|
| // Now append 6 buffers at positions 0 through 5.
|
| - NewSegmentAppend(0, 6, &kDataB);
|
| + NewCodedFrameGroupAppend(0, 6, &kDataB);
|
|
|
| // Check expected range.
|
| CheckExpectedRanges("{ [0,5) [15,19) }");
|
| @@ -1566,13 +1528,13 @@ TEST_F(SourceBufferStreamTest, End_Overlap_Selected_NoKeyframeAfterNew3) {
|
| // after: A a a a a*B*b b b b A a a a a
|
| TEST_F(SourceBufferStreamTest, Middle_Overlap_Selected_1) {
|
| // Append 15 buffers at positions 0 through 14.
|
| - NewSegmentAppend(0, 15, &kDataA);
|
| + NewCodedFrameGroupAppend(0, 15, &kDataA);
|
|
|
| // Seek to position 5.
|
| Seek(5);
|
|
|
| // Now append 5 buffers at positions 5 through 9.
|
| - NewSegmentAppend(5, 5, &kDataB);
|
| + NewCodedFrameGroupAppend(5, 5, &kDataB);
|
|
|
| // Check expected range.
|
| CheckExpectedRanges("{ [0,14) }");
|
| @@ -1596,14 +1558,14 @@ TEST_F(SourceBufferStreamTest, Middle_Overlap_Selected_1) {
|
| // after: A a a a a B b b b b A*a*a a a
|
| TEST_F(SourceBufferStreamTest, Middle_Overlap_Selected_2) {
|
| // Append 15 buffers at positions 0 through 14.
|
| - NewSegmentAppend(0, 15, &kDataA);
|
| + NewCodedFrameGroupAppend(0, 15, &kDataA);
|
|
|
| // Seek to 10 then move to position 11.
|
| Seek(10);
|
| CheckExpectedBuffers(10, 10, &kDataA);
|
|
|
| // Now append 5 buffers at positions 5 through 9.
|
| - NewSegmentAppend(5, 5, &kDataB);
|
| + NewCodedFrameGroupAppend(5, 5, &kDataB);
|
|
|
| // Check expected range.
|
| CheckExpectedRanges("{ [0,14) }");
|
| @@ -1625,14 +1587,14 @@ TEST_F(SourceBufferStreamTest, Middle_Overlap_Selected_2) {
|
| // after: A a*a*a a B b b| |A a a a a
|
| TEST_F(SourceBufferStreamTest, Middle_Overlap_Selected_3) {
|
| // Append 15 buffers at positions 0 through 14.
|
| - NewSegmentAppend(0, 15, &kDataA);
|
| + NewCodedFrameGroupAppend(0, 15, &kDataA);
|
|
|
| // Seek to beginning then move to position 2.
|
| Seek(0);
|
| CheckExpectedBuffers(0, 1, &kDataA);
|
|
|
| // Now append 3 buffers at positions 5 through 7.
|
| - NewSegmentAppend(5, 3, &kDataB);
|
| + NewCodedFrameGroupAppend(5, 3, &kDataB);
|
|
|
| // Check expected range.
|
| CheckExpectedRanges("{ [0,7) [10,14) }");
|
| @@ -1654,14 +1616,14 @@ TEST_F(SourceBufferStreamTest, Middle_Overlap_Selected_3) {
|
| // track: |a a|
|
| TEST_F(SourceBufferStreamTest, Middle_Overlap_Selected_4) {
|
| // Append 15 buffers at positions 0 through 14.
|
| - NewSegmentAppend(0, 15, &kDataA);
|
| + NewCodedFrameGroupAppend(0, 15, &kDataA);
|
|
|
| // Seek to 5 then move to position 8.
|
| Seek(5);
|
| CheckExpectedBuffers(5, 7, &kDataA);
|
|
|
| // Now append 3 buffers at positions 5 through 7.
|
| - NewSegmentAppend(5, 3, &kDataB);
|
| + NewCodedFrameGroupAppend(5, 3, &kDataB);
|
|
|
| // Check expected range.
|
| CheckExpectedRanges("{ [0,7) [10,14) }");
|
| @@ -1681,14 +1643,14 @@ TEST_F(SourceBufferStreamTest, Middle_Overlap_Selected_4) {
|
|
|
| TEST_F(SourceBufferStreamTest, Overlap_OneByOne) {
|
| // Append 5 buffers starting at 10ms, 30ms apart.
|
| - NewSegmentAppendOneByOne("10K 40 70 100 130");
|
| + NewCodedFrameGroupAppendOneByOne("10K 40 70 100 130");
|
|
|
| // The range ends at 160, accounting for the last buffer's duration.
|
| CheckExpectedRangesByTimestamp("{ [10,160) }");
|
|
|
| // Overlap with 10 buffers starting at the beginning, appended one at a
|
| // time.
|
| - NewSegmentAppend(0, 1, &kDataB);
|
| + NewCodedFrameGroupAppend(0, 1, &kDataB);
|
| for (int i = 1; i < 10; i++)
|
| AppendBuffers(i, 1, &kDataB);
|
|
|
| @@ -1699,14 +1661,14 @@ TEST_F(SourceBufferStreamTest, Overlap_OneByOne) {
|
| }
|
|
|
| TEST_F(SourceBufferStreamTest, Overlap_OneByOne_DeleteGroup) {
|
| - NewSegmentAppendOneByOne("10K 40 70 100 130K");
|
| + NewCodedFrameGroupAppendOneByOne("10K 40 70 100 130K");
|
| CheckExpectedRangesByTimestamp("{ [10,160) }");
|
|
|
| // Seek to 130ms.
|
| SeekToTimestampMs(130);
|
|
|
| - // Overlap with a new segment from 0 to 130ms.
|
| - NewSegmentAppendOneByOne("0K 120D10");
|
| + // Overlap with a new coded frame group from 0 to 130ms.
|
| + NewCodedFrameGroupAppendOneByOne("0K 120D10");
|
|
|
| // Next buffer should still be 130ms.
|
| CheckExpectedBuffers("130K");
|
| @@ -1716,15 +1678,16 @@ TEST_F(SourceBufferStreamTest, Overlap_OneByOne_DeleteGroup) {
|
| CheckExpectedBuffers("0K 120 130K");
|
| }
|
|
|
| -TEST_F(SourceBufferStreamTest, Overlap_OneByOne_BetweenMediaSegments) {
|
| +TEST_F(SourceBufferStreamTest, Overlap_OneByOne_BetweenCodedFrameGroups) {
|
| // Append 5 buffers starting at 110ms, 30ms apart.
|
| - NewSegmentAppendOneByOne("110K 140 170 200 230");
|
| + NewCodedFrameGroupAppendOneByOne("110K 140 170 200 230");
|
| CheckExpectedRangesByTimestamp("{ [110,260) }");
|
|
|
| - // Now append 2 media segments from 0ms to 210ms, 30ms apart. Note that the
|
| - // old keyframe 110ms falls in between these two segments.
|
| - NewSegmentAppendOneByOne("0K 30 60 90");
|
| - NewSegmentAppendOneByOne("120K 150 180 210");
|
| + // Now append 2 coded frame groups from 0ms to 210ms, 30ms apart. Note that
|
| + // the
|
| + // old keyframe 110ms falls in between these two groups.
|
| + NewCodedFrameGroupAppendOneByOne("0K 30 60 90");
|
| + NewCodedFrameGroupAppendOneByOne("120K 150 180 210");
|
| CheckExpectedRangesByTimestamp("{ [0,240) }");
|
|
|
| // Check the final buffers is correct; the keyframe at 110ms should be
|
| @@ -1739,15 +1702,15 @@ TEST_F(SourceBufferStreamTest, Overlap_OneByOne_BetweenMediaSegments) {
|
| TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer) {
|
| EXPECT_MEDIA_LOG(ContainsTrackBufferExhaustionSkipLog(50));
|
|
|
| - NewSegmentAppendOneByOne("10K 40 70 100K 125 130D30K");
|
| + NewCodedFrameGroupAppendOneByOne("10K 40 70 100K 125 130D30K");
|
| CheckExpectedRangesByTimestamp("{ [10,160) }");
|
|
|
| // Seek to 70ms.
|
| SeekToTimestampMs(70);
|
| CheckExpectedBuffers("10K 40");
|
|
|
| - // Overlap with a new segment from 0 to 130ms.
|
| - NewSegmentAppendOneByOne("0K 30 60 90 120D10K");
|
| + // Overlap with a new coded frame group from 0 to 130ms.
|
| + NewCodedFrameGroupAppendOneByOne("0K 30 60 90 120D10K");
|
| CheckExpectedRangesByTimestamp("{ [0,160) }");
|
|
|
| // Should return frame 70ms from the track buffer, then switch
|
| @@ -1771,20 +1734,21 @@ TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer) {
|
| TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer2) {
|
| EXPECT_MEDIA_LOG(ContainsTrackBufferExhaustionSkipLog(40));
|
|
|
| - NewSegmentAppendOneByOne("10K 40 70 100K 125 130D30K");
|
| + NewCodedFrameGroupAppendOneByOne("10K 40 70 100K 125 130D30K");
|
| CheckExpectedRangesByTimestamp("{ [10,160) }");
|
|
|
| // Seek to 70ms.
|
| SeekToTimestampMs(70);
|
| CheckExpectedBuffers("10K 40");
|
|
|
| - // Overlap with a new segment from 0 to 120ms; 70ms and 100ms go in track
|
| + // Overlap with a new coded frame group from 0 to 120ms; 70ms and 100ms go in
|
| + // track
|
| // buffer.
|
| - NewSegmentAppendOneByOne("0K 30 60 90 120D10K");
|
| + NewCodedFrameGroupAppendOneByOne("0K 30 60 90 120D10K");
|
| CheckExpectedRangesByTimestamp("{ [0,160) }");
|
|
|
| // Now overlap the keyframe at 120ms.
|
| - NewSegmentAppendOneByOne("110K 130");
|
| + NewCodedFrameGroupAppendOneByOne("110K 130");
|
|
|
| // Should return frame 70ms from the track buffer. Then it should
|
| // return the keyframe after the track buffer, which is at 110ms.
|
| @@ -1803,19 +1767,20 @@ TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer2) {
|
| TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer3) {
|
| EXPECT_MEDIA_LOG(ContainsTrackBufferExhaustionSkipLog(80));
|
|
|
| - NewSegmentAppendOneByOne("10K 40 70 100K 125 130D30K");
|
| + NewCodedFrameGroupAppendOneByOne("10K 40 70 100K 125 130D30K");
|
| CheckExpectedRangesByTimestamp("{ [10,160) }");
|
|
|
| // Seek to 70ms.
|
| SeekToTimestampMs(70);
|
| CheckExpectedBuffers("10K 40");
|
|
|
| - // Overlap with a new segment from 0 to 120ms; 70ms goes in track buffer.
|
| - NewSegmentAppendOneByOne("0K 30 60 90 120D10K");
|
| + // Overlap with a new coded frame group from 0 to 120ms; 70ms goes in track
|
| + // buffer.
|
| + NewCodedFrameGroupAppendOneByOne("0K 30 60 90 120D10K");
|
| CheckExpectedRangesByTimestamp("{ [0,160) }");
|
|
|
| // Now overlap the keyframe at 120ms and 130ms.
|
| - NewSegmentAppendOneByOne("50K 80 110 140");
|
| + NewCodedFrameGroupAppendOneByOne("50K 80 110 140");
|
| CheckExpectedRangesByTimestamp("{ [0,170) }");
|
|
|
| // Should have all the buffers from the track buffer, then stall.
|
| @@ -1838,20 +1803,21 @@ TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer3) {
|
| // after: 0K 30 60 *80K* 110 140
|
| // track: 70
|
| TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer4) {
|
| - NewSegmentAppendOneByOne("10K 40 70 100K 125 130D30K");
|
| + NewCodedFrameGroupAppendOneByOne("10K 40 70 100K 125 130D30K");
|
| CheckExpectedRangesByTimestamp("{ [10,160) }");
|
|
|
| // Seek to 70ms.
|
| SeekToTimestampMs(70);
|
| CheckExpectedBuffers("10K 40");
|
|
|
| - // Overlap with a new segment from 0 to 120ms; 70ms and 100ms go in track
|
| + // Overlap with a new coded frame group from 0 to 120ms; 70ms and 100ms go in
|
| + // track
|
| // buffer.
|
| - NewSegmentAppendOneByOne("0K 30 60 90 120D10K");
|
| + NewCodedFrameGroupAppendOneByOne("0K 30 60 90 120D10K");
|
| CheckExpectedRangesByTimestamp("{ [0,160) }");
|
|
|
| // Now append a keyframe at 80ms.
|
| - NewSegmentAppendOneByOne("80K 110 140");
|
| + NewCodedFrameGroupAppendOneByOne("80K 110 140");
|
|
|
| CheckExpectedBuffers("70 80K 110 140");
|
| CheckNoNextBuffer();
|
| @@ -1868,20 +1834,20 @@ TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer4) {
|
| // after: 0K 30 60 *80K* 110 140
|
| // track: 70
|
| TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer5) {
|
| - NewSegmentAppendOneByOne("10K 40 70 100K");
|
| + NewCodedFrameGroupAppendOneByOne("10K 40 70 100K");
|
| CheckExpectedRangesByTimestamp("{ [10,130) }");
|
|
|
| // Seek to 70ms.
|
| SeekToTimestampMs(70);
|
| CheckExpectedBuffers("10K 40");
|
|
|
| - // Overlap with a new segment from 0 to 120ms; 70ms goes in track
|
| + // Overlap with a new coded frame group from 0 to 120ms; 70ms goes in track
|
| // buffer.
|
| - NewSegmentAppendOneByOne("0K 30 60 90 120");
|
| + NewCodedFrameGroupAppendOneByOne("0K 30 60 90 120");
|
| CheckExpectedRangesByTimestamp("{ [0,150) }");
|
|
|
| // Now append a keyframe at 80ms.
|
| - NewSegmentAppendOneByOne("80K 110 140");
|
| + NewCodedFrameGroupAppendOneByOne("80K 110 140");
|
|
|
| CheckExpectedBuffers("70 80K 110 140");
|
| CheckNoNextBuffer();
|
| @@ -1900,23 +1866,23 @@ TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer5) {
|
| TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer6) {
|
| EXPECT_MEDIA_LOG(ContainsTrackBufferExhaustionSkipLog(50));
|
|
|
| - NewSegmentAppendOneByOne("10K 40 70 100K 125 130D30K");
|
| - NewSegmentAppendOneByOne("200K 230");
|
| + NewCodedFrameGroupAppendOneByOne("10K 40 70 100K 125 130D30K");
|
| + NewCodedFrameGroupAppendOneByOne("200K 230");
|
| CheckExpectedRangesByTimestamp("{ [10,160) [200,260) }");
|
|
|
| // Seek to 70ms.
|
| SeekToTimestampMs(70);
|
| CheckExpectedBuffers("10K 40");
|
|
|
| - // Overlap with a new segment from 0 to 120ms.
|
| - NewSegmentAppendOneByOne("0K 30 60 90 120D10K");
|
| + // Overlap with a new coded frame group from 0 to 120ms.
|
| + NewCodedFrameGroupAppendOneByOne("0K 30 60 90 120D10K");
|
| CheckExpectedRangesByTimestamp("{ [0,160) [200,260) }");
|
|
|
| // Verify that 70 gets read out of the track buffer.
|
| CheckExpectedBuffers("70");
|
|
|
| // Append more data to the unselected range.
|
| - NewSegmentAppendOneByOne("260K 290");
|
| + NewCodedFrameGroupAppendOneByOne("260K 290");
|
| CheckExpectedRangesByTimestamp("{ [0,160) [200,320) }");
|
|
|
| CheckExpectedBuffers("120K 130K");
|
| @@ -1930,7 +1896,7 @@ TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer6) {
|
|
|
| TEST_F(SourceBufferStreamTest, Seek_Keyframe) {
|
| // Append 6 buffers at positions 0 through 5.
|
| - NewSegmentAppend(0, 6);
|
| + NewCodedFrameGroupAppend(0, 6);
|
|
|
| // Seek to beginning.
|
| Seek(0);
|
| @@ -1939,7 +1905,7 @@ TEST_F(SourceBufferStreamTest, Seek_Keyframe) {
|
|
|
| TEST_F(SourceBufferStreamTest, Seek_NonKeyframe) {
|
| // Append 15 buffers at positions 0 through 14.
|
| - NewSegmentAppend(0, 15);
|
| + NewCodedFrameGroupAppend(0, 15);
|
|
|
| // Seek to buffer at position 13.
|
| Seek(13);
|
| @@ -1962,7 +1928,7 @@ TEST_F(SourceBufferStreamTest, Seek_NotBuffered) {
|
| CheckNoNextBuffer();
|
|
|
| // Append 2 buffers at positions 0.
|
| - NewSegmentAppend(0, 2);
|
| + NewCodedFrameGroupAppend(0, 2);
|
| Seek(0);
|
| CheckExpectedBuffers(0, 1);
|
|
|
| @@ -1973,7 +1939,7 @@ TEST_F(SourceBufferStreamTest, Seek_NotBuffered) {
|
|
|
| TEST_F(SourceBufferStreamTest, Seek_InBetweenTimestamps) {
|
| // Append 10 buffers at positions 0 through 9.
|
| - NewSegmentAppend(0, 10);
|
| + NewCodedFrameGroupAppend(0, 10);
|
|
|
| base::TimeDelta bump = frame_duration() / 4;
|
| CHECK(bump > base::TimeDelta());
|
| @@ -1993,14 +1959,14 @@ TEST_F(SourceBufferStreamTest, Seek_InBetweenTimestamps) {
|
| // response to the Seek().
|
| TEST_F(SourceBufferStreamTest, Seek_After_TrackBuffer_Filled) {
|
| // Append 10 buffers at positions 5 through 14.
|
| - NewSegmentAppend(5, 10, &kDataA);
|
| + NewCodedFrameGroupAppend(5, 10, &kDataA);
|
|
|
| // Seek to buffer at position 5 and get next buffer.
|
| Seek(5);
|
| CheckExpectedBuffers(5, 5, &kDataA);
|
|
|
| // Do a complete overlap by appending 20 buffers at positions 0 through 19.
|
| - NewSegmentAppend(0, 20, &kDataB);
|
| + NewCodedFrameGroupAppend(0, 20, &kDataB);
|
|
|
| // Check range is correct.
|
| CheckExpectedRanges("{ [0,19) }");
|
| @@ -2013,14 +1979,14 @@ TEST_F(SourceBufferStreamTest, Seek_After_TrackBuffer_Filled) {
|
| CheckExpectedRanges("{ [0,19) }");
|
| }
|
|
|
| -TEST_F(SourceBufferStreamTest, Seek_StartOfSegment) {
|
| +TEST_F(SourceBufferStreamTest, Seek_StartOfGroup) {
|
| base::TimeDelta bump = frame_duration() / 4;
|
| CHECK(bump > base::TimeDelta());
|
|
|
| - // Append 5 buffers at position (5 + |bump|) through 9, where the media
|
| - // segment begins at position 5.
|
| + // Append 5 buffers at position (5 + |bump|) through 9, where the coded frame
|
| + // group begins at position 5.
|
| Seek(5);
|
| - NewSegmentAppend_OffsetFirstBuffer(5, 5, bump);
|
| + NewCodedFrameGroupAppend_OffsetFirstBuffer(5, 5, bump);
|
| scoped_refptr<StreamParserBuffer> buffer;
|
|
|
| // GetNextBuffer() should return the next buffer at position (5 + |bump|).
|
| @@ -2034,9 +2000,9 @@ TEST_F(SourceBufferStreamTest, Seek_StartOfSegment) {
|
| // Seek to position 15.
|
| Seek(15);
|
|
|
| - // Append 5 buffers at positions (15 + |bump|) through 19, where the media
|
| - // segment begins at 15.
|
| - NewSegmentAppend_OffsetFirstBuffer(15, 5, bump);
|
| + // Append 5 buffers at positions (15 + |bump|) through 19, where the coded
|
| + // frame group begins at 15.
|
| + NewCodedFrameGroupAppend_OffsetFirstBuffer(15, 5, bump);
|
|
|
| // GetNextBuffer() should return the next buffer at position (15 + |bump|).
|
| EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kSuccess);
|
| @@ -2047,9 +2013,9 @@ TEST_F(SourceBufferStreamTest, Seek_StartOfSegment) {
|
| CheckExpectedBuffers(16, 19);
|
| }
|
|
|
| -TEST_F(SourceBufferStreamTest, Seek_BeforeStartOfSegment) {
|
| +TEST_F(SourceBufferStreamTest, Seek_BeforeStartOfGroup) {
|
| // Append 10 buffers at positions 5 through 14.
|
| - NewSegmentAppend(5, 10);
|
| + NewCodedFrameGroupAppend(5, 10);
|
|
|
| // Seek to a time before the first buffer in the range.
|
| Seek(0);
|
| @@ -2060,18 +2026,18 @@ TEST_F(SourceBufferStreamTest, Seek_BeforeStartOfSegment) {
|
|
|
| TEST_F(SourceBufferStreamTest, OldSeekPoint_CompleteOverlap) {
|
| // Append 5 buffers at positions 0 through 4.
|
| - NewSegmentAppend(0, 4);
|
| + NewCodedFrameGroupAppend(0, 4);
|
|
|
| // Append 5 buffers at positions 10 through 14, and seek to the beginning of
|
| // this range.
|
| - NewSegmentAppend(10, 5);
|
| + NewCodedFrameGroupAppend(10, 5);
|
| Seek(10);
|
|
|
| // Now seek to the beginning of the first range.
|
| Seek(0);
|
|
|
| // Completely overlap the old seek point.
|
| - NewSegmentAppend(5, 15);
|
| + NewCodedFrameGroupAppend(5, 15);
|
|
|
| // The GetNextBuffer() call should respect the 2nd seek point.
|
| CheckExpectedBuffers(0, 0);
|
| @@ -2079,18 +2045,18 @@ TEST_F(SourceBufferStreamTest, OldSeekPoint_CompleteOverlap) {
|
|
|
| TEST_F(SourceBufferStreamTest, OldSeekPoint_CompleteOverlap_Pending) {
|
| // Append 2 buffers at positions 0 through 1.
|
| - NewSegmentAppend(0, 2);
|
| + NewCodedFrameGroupAppend(0, 2);
|
|
|
| // Append 5 buffers at positions 15 through 19 and seek to beginning of the
|
| // range.
|
| - NewSegmentAppend(15, 5);
|
| + NewCodedFrameGroupAppend(15, 5);
|
| Seek(15);
|
|
|
| // Now seek position 5.
|
| Seek(5);
|
|
|
| // Completely overlap the old seek point.
|
| - NewSegmentAppend(10, 15);
|
| + NewCodedFrameGroupAppend(10, 15);
|
|
|
| // The seek at position 5 should still be pending.
|
| CheckNoNextBuffer();
|
| @@ -2098,17 +2064,17 @@ TEST_F(SourceBufferStreamTest, OldSeekPoint_CompleteOverlap_Pending) {
|
|
|
| TEST_F(SourceBufferStreamTest, OldSeekPoint_MiddleOverlap) {
|
| // Append 2 buffers at positions 0 through 1.
|
| - NewSegmentAppend(0, 2);
|
| + NewCodedFrameGroupAppend(0, 2);
|
|
|
| // Append 15 buffers at positions 5 through 19 and seek to position 15.
|
| - NewSegmentAppend(5, 15);
|
| + NewCodedFrameGroupAppend(5, 15);
|
| Seek(15);
|
|
|
| // Now seek to the beginning of the stream.
|
| Seek(0);
|
|
|
| // Overlap the middle of the range such that there are now three ranges.
|
| - NewSegmentAppend(10, 3);
|
| + NewCodedFrameGroupAppend(10, 3);
|
| CheckExpectedRanges("{ [0,1) [5,12) [15,19) }");
|
|
|
| // The GetNextBuffer() call should respect the 2nd seek point.
|
| @@ -2117,17 +2083,17 @@ TEST_F(SourceBufferStreamTest, OldSeekPoint_MiddleOverlap) {
|
|
|
| TEST_F(SourceBufferStreamTest, OldSeekPoint_MiddleOverlap_Pending) {
|
| // Append 2 buffers at positions 0 through 1.
|
| - NewSegmentAppend(0, 2);
|
| + NewCodedFrameGroupAppend(0, 2);
|
|
|
| // Append 15 buffers at positions 10 through 24 and seek to position 20.
|
| - NewSegmentAppend(10, 15);
|
| + NewCodedFrameGroupAppend(10, 15);
|
| Seek(20);
|
|
|
| // Now seek to position 5.
|
| Seek(5);
|
|
|
| // Overlap the middle of the range such that it is now split into two ranges.
|
| - NewSegmentAppend(15, 3);
|
| + NewCodedFrameGroupAppend(15, 3);
|
| CheckExpectedRanges("{ [0,1) [10,17) [20,24) }");
|
|
|
| // The seek at position 5 should still be pending.
|
| @@ -2136,17 +2102,17 @@ TEST_F(SourceBufferStreamTest, OldSeekPoint_MiddleOverlap_Pending) {
|
|
|
| TEST_F(SourceBufferStreamTest, OldSeekPoint_StartOverlap) {
|
| // Append 2 buffers at positions 0 through 1.
|
| - NewSegmentAppend(0, 2);
|
| + NewCodedFrameGroupAppend(0, 2);
|
|
|
| // Append 15 buffers at positions 5 through 19 and seek to position 15.
|
| - NewSegmentAppend(5, 15);
|
| + NewCodedFrameGroupAppend(5, 15);
|
| Seek(15);
|
|
|
| // Now seek to the beginning of the stream.
|
| Seek(0);
|
|
|
| // Start overlap the old seek point.
|
| - NewSegmentAppend(10, 10);
|
| + NewCodedFrameGroupAppend(10, 10);
|
|
|
| // The GetNextBuffer() call should respect the 2nd seek point.
|
| CheckExpectedBuffers(0, 0);
|
| @@ -2154,17 +2120,17 @@ TEST_F(SourceBufferStreamTest, OldSeekPoint_StartOverlap) {
|
|
|
| TEST_F(SourceBufferStreamTest, OldSeekPoint_StartOverlap_Pending) {
|
| // Append 2 buffers at positions 0 through 1.
|
| - NewSegmentAppend(0, 2);
|
| + NewCodedFrameGroupAppend(0, 2);
|
|
|
| // Append 15 buffers at positions 10 through 24 and seek to position 20.
|
| - NewSegmentAppend(10, 15);
|
| + NewCodedFrameGroupAppend(10, 15);
|
| Seek(20);
|
|
|
| // Now seek to position 5.
|
| Seek(5);
|
|
|
| // Start overlap the old seek point.
|
| - NewSegmentAppend(15, 10);
|
| + NewCodedFrameGroupAppend(15, 10);
|
|
|
| // The seek at time 0 should still be pending.
|
| CheckNoNextBuffer();
|
| @@ -2172,17 +2138,17 @@ TEST_F(SourceBufferStreamTest, OldSeekPoint_StartOverlap_Pending) {
|
|
|
| TEST_F(SourceBufferStreamTest, OldSeekPoint_EndOverlap) {
|
| // Append 5 buffers at positions 0 through 4.
|
| - NewSegmentAppend(0, 4);
|
| + NewCodedFrameGroupAppend(0, 4);
|
|
|
| // Append 15 buffers at positions 10 through 24 and seek to start of range.
|
| - NewSegmentAppend(10, 15);
|
| + NewCodedFrameGroupAppend(10, 15);
|
| Seek(10);
|
|
|
| // Now seek to the beginning of the stream.
|
| Seek(0);
|
|
|
| // End overlap the old seek point.
|
| - NewSegmentAppend(5, 10);
|
| + NewCodedFrameGroupAppend(5, 10);
|
|
|
| // The GetNextBuffer() call should respect the 2nd seek point.
|
| CheckExpectedBuffers(0, 0);
|
| @@ -2190,17 +2156,17 @@ TEST_F(SourceBufferStreamTest, OldSeekPoint_EndOverlap) {
|
|
|
| TEST_F(SourceBufferStreamTest, OldSeekPoint_EndOverlap_Pending) {
|
| // Append 2 buffers at positions 0 through 1.
|
| - NewSegmentAppend(0, 2);
|
| + NewCodedFrameGroupAppend(0, 2);
|
|
|
| // Append 15 buffers at positions 15 through 29 and seek to start of range.
|
| - NewSegmentAppend(15, 15);
|
| + NewCodedFrameGroupAppend(15, 15);
|
| Seek(15);
|
|
|
| // Now seek to position 5
|
| Seek(5);
|
|
|
| // End overlap the old seek point.
|
| - NewSegmentAppend(10, 10);
|
| + NewCodedFrameGroupAppend(10, 10);
|
|
|
| // The seek at time 0 should still be pending.
|
| CheckNoNextBuffer();
|
| @@ -2208,13 +2174,13 @@ TEST_F(SourceBufferStreamTest, OldSeekPoint_EndOverlap_Pending) {
|
|
|
| TEST_F(SourceBufferStreamTest, GetNextBuffer_AfterMerges) {
|
| // Append 5 buffers at positions 10 through 14.
|
| - NewSegmentAppend(10, 5);
|
| + NewCodedFrameGroupAppend(10, 5);
|
|
|
| // Seek to buffer at position 12.
|
| Seek(12);
|
|
|
| // Append 5 buffers at positions 5 through 9.
|
| - NewSegmentAppend(5, 5);
|
| + NewCodedFrameGroupAppend(5, 5);
|
|
|
| // Make sure ranges are merged.
|
| CheckExpectedRanges("{ [5,14) }");
|
| @@ -2223,7 +2189,7 @@ TEST_F(SourceBufferStreamTest, GetNextBuffer_AfterMerges) {
|
| CheckExpectedBuffers(10, 10);
|
|
|
| // Append 5 buffers at positions 15 through 19.
|
| - NewSegmentAppend(15, 5);
|
| + NewCodedFrameGroupAppend(15, 5);
|
| CheckExpectedRanges("{ [5,19) }");
|
|
|
| // Make sure the remaining next buffers are correct.
|
| @@ -2232,7 +2198,7 @@ TEST_F(SourceBufferStreamTest, GetNextBuffer_AfterMerges) {
|
|
|
| TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenAppend) {
|
| // Append 4 buffers at positions 0 through 3.
|
| - NewSegmentAppend(0, 4);
|
| + NewCodedFrameGroupAppend(0, 4);
|
|
|
| // Seek to buffer at position 0 and get all buffers.
|
| Seek(0);
|
| @@ -2250,7 +2216,7 @@ TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenAppend) {
|
| // buffer is not buffered.
|
| TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenStartOverlap) {
|
| // Append 10 buffers at positions 0 through 9 and exhaust the buffers.
|
| - NewSegmentAppend(0, 10, &kDataA);
|
| + NewCodedFrameGroupAppend(0, 10, &kDataA);
|
| Seek(0);
|
| CheckExpectedBuffers(0, 9, &kDataA);
|
|
|
| @@ -2260,7 +2226,7 @@ TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenStartOverlap) {
|
| // Append 6 buffers at positons 5 through 10. This is to test that doing a
|
| // start-overlap successfully fulfills the read at position 10, even though
|
| // position 10 was unbuffered.
|
| - NewSegmentAppend(5, 6, &kDataB);
|
| + NewCodedFrameGroupAppend(5, 6, &kDataB);
|
| CheckExpectedBuffers(10, 10, &kDataB);
|
|
|
| // Then add 5 buffers from positions 11 though 15.
|
| @@ -2271,7 +2237,7 @@ TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenStartOverlap) {
|
| CheckExpectedBuffers(11, 14, &kDataB);
|
|
|
| // Replace the next buffer at position 15 with another start overlap.
|
| - NewSegmentAppend(15, 2, &kDataA);
|
| + NewCodedFrameGroupAppend(15, 2, &kDataA);
|
| CheckExpectedBuffers(15, 16, &kDataA);
|
| }
|
|
|
| @@ -2280,18 +2246,18 @@ TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenStartOverlap) {
|
| // GetNextBuffer() skips to second GOP in the newly appended data instead
|
| // of returning two buffers with the same timestamp.
|
| TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenStartOverlap2) {
|
| - NewSegmentAppend("0K 30 60 90 120");
|
| + NewCodedFrameGroupAppend("0K 30 60 90 120");
|
|
|
| Seek(0);
|
| CheckExpectedBuffers("0K 30 60 90 120");
|
| CheckNoNextBuffer();
|
|
|
| // Append a keyframe with the same timestamp as the last buffer output.
|
| - NewSegmentAppend("120D30K");
|
| + NewCodedFrameGroupAppend("120D30K");
|
| CheckNoNextBuffer();
|
|
|
| - // Append the rest of the segment and make sure that buffers are returned
|
| - // from the first GOP after 120.
|
| + // Append the rest of the coded frame group and make sure that buffers are
|
| + // returned from the first GOP after 120.
|
| AppendBuffers("150 180 210K 240");
|
| CheckExpectedBuffers("210K 240");
|
|
|
| @@ -2305,7 +2271,7 @@ TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenStartOverlap2) {
|
| // whose next buffer is not buffered.
|
| TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenCompleteOverlap) {
|
| // Append 5 buffers at positions 10 through 14 and exhaust the buffers.
|
| - NewSegmentAppend(10, 5, &kDataA);
|
| + NewCodedFrameGroupAppend(10, 5, &kDataA);
|
| Seek(10);
|
| CheckExpectedBuffers(10, 14, &kDataA);
|
|
|
| @@ -2314,7 +2280,7 @@ TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenCompleteOverlap) {
|
|
|
| // Do a complete overlap and test that this successfully fulfills the read
|
| // at position 15.
|
| - NewSegmentAppend(5, 11, &kDataB);
|
| + NewCodedFrameGroupAppend(5, 11, &kDataB);
|
| CheckExpectedBuffers(15, 15, &kDataB);
|
|
|
| // Then add 5 buffers from positions 16 though 20.
|
| @@ -2325,7 +2291,7 @@ TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenCompleteOverlap) {
|
| CheckExpectedBuffers(16, 19, &kDataB);
|
|
|
| // Do a complete overlap and replace the buffer at position 20.
|
| - NewSegmentAppend(0, 21, &kDataA);
|
| + NewCodedFrameGroupAppend(0, 21, &kDataA);
|
| CheckExpectedBuffers(20, 20, &kDataA);
|
| }
|
|
|
| @@ -2333,7 +2299,7 @@ TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenCompleteOverlap) {
|
| // buffer, then an end-overlap causes the end of the range to be deleted.
|
| TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenEndOverlap) {
|
| // Append 5 buffers at positions 10 through 14 and exhaust the buffers.
|
| - NewSegmentAppend(10, 5, &kDataA);
|
| + NewCodedFrameGroupAppend(10, 5, &kDataA);
|
| Seek(10);
|
| CheckExpectedBuffers(10, 14, &kDataA);
|
| CheckExpectedRanges("{ [10,14) }");
|
| @@ -2342,7 +2308,7 @@ TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenEndOverlap) {
|
| CheckNoNextBuffer();
|
|
|
| // Do an end overlap that causes the latter half of the range to be deleted.
|
| - NewSegmentAppend(5, 6, &kDataB);
|
| + NewCodedFrameGroupAppend(5, 6, &kDataB);
|
| CheckNoNextBuffer();
|
| CheckExpectedRanges("{ [5,10) }");
|
|
|
| @@ -2365,14 +2331,14 @@ TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenEndOverlap) {
|
| // "next buffer" position.
|
| TEST_F(SourceBufferStreamTest, GetNextBuffer_Overlap_Selected_Complete) {
|
| // Append 5 buffers at positions 5 through 9.
|
| - NewSegmentAppend(5, 5, &kDataA);
|
| + NewCodedFrameGroupAppend(5, 5, &kDataA);
|
|
|
| // Seek to buffer at position 5 and get next buffer.
|
| Seek(5);
|
| CheckExpectedBuffers(5, 5, &kDataA);
|
|
|
| // Replace existing data with new data.
|
| - NewSegmentAppend(5, 5, &kDataB);
|
| + NewCodedFrameGroupAppend(5, 5, &kDataB);
|
|
|
| // Expect old data up until next keyframe in new data.
|
| CheckExpectedBuffers(6, 9, &kDataA);
|
| @@ -2388,7 +2354,7 @@ TEST_F(SourceBufferStreamTest, GetNextBuffer_Overlap_Selected_Complete) {
|
|
|
| TEST_F(SourceBufferStreamTest, PresentationTimestampIndependence) {
|
| // Append 20 buffers at position 0.
|
| - NewSegmentAppend(0, 20);
|
| + NewCodedFrameGroupAppend(0, 20);
|
| Seek(0);
|
|
|
| int last_keyframe_idx = -1;
|
| @@ -2424,7 +2390,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteFront) {
|
| SetMemoryLimit(20);
|
|
|
| // Append 20 buffers at positions 0 through 19.
|
| - NewSegmentAppend(0, 1, &kDataA);
|
| + NewCodedFrameGroupAppend(0, 1, &kDataA);
|
| for (int i = 1; i < 20; i++)
|
| AppendBuffers(i, 1, &kDataA);
|
|
|
| @@ -2456,8 +2422,8 @@ TEST_F(SourceBufferStreamTest,
|
| // Set memory limit to 15 buffers.
|
| SetMemoryLimit(15);
|
|
|
| - NewSegmentAppend("0K 10 20 30 40 50K 60 70 80 90");
|
| - NewSegmentAppend("1000K 1010 1020 1030 1040");
|
| + NewCodedFrameGroupAppend("0K 10 20 30 40 50K 60 70 80 90");
|
| + NewCodedFrameGroupAppend("1000K 1010 1020 1030 1040");
|
|
|
| // GC should be a no-op, since we are just under memory limit.
|
| EXPECT_TRUE(stream_->GarbageCollectIfNeeded(DecodeTimestamp(), 0));
|
| @@ -2482,7 +2448,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteFrontGOPsAtATime) {
|
| SetMemoryLimit(20);
|
|
|
| // Append 20 buffers at positions 0 through 19.
|
| - NewSegmentAppend(0, 20, &kDataA);
|
| + NewCodedFrameGroupAppend(0, 20, &kDataA);
|
|
|
| // Seek to position 10.
|
| Seek(10);
|
| @@ -2505,11 +2471,11 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteBack) {
|
| SetMemoryLimit(5);
|
|
|
| // Append 5 buffers at positions 15 through 19.
|
| - NewSegmentAppend(15, 5, &kDataA);
|
| + NewCodedFrameGroupAppend(15, 5, &kDataA);
|
| EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(0, 0));
|
|
|
| // Append 5 buffers at positions 0 through 4.
|
| - NewSegmentAppend(0, 5, &kDataA);
|
| + NewCodedFrameGroupAppend(0, 5, &kDataA);
|
| CheckExpectedRanges("{ [0,4) [15,19) }");
|
|
|
| // Seek to position 0.
|
| @@ -2528,11 +2494,11 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteFrontAndBack) {
|
| Seek(15);
|
|
|
| // Append 40 buffers at positions 0 through 39.
|
| - NewSegmentAppend(0, 40, &kDataA);
|
| + NewCodedFrameGroupAppend(0, 40, &kDataA);
|
| // GC will try to keep data between current playback position and last append
|
| // position. This will ensure that the last append position is 19 and will
|
| // allow GC algorithm to collect data outside of the range [15,19)
|
| - NewSegmentAppend(15, 5, &kDataA);
|
| + NewCodedFrameGroupAppend(15, 5, &kDataA);
|
| CheckExpectedRanges("{ [0,39) }");
|
|
|
| // Should leave the GOP containing the current playback position 15 and the
|
| @@ -2545,16 +2511,16 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteFrontAndBack) {
|
|
|
| TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteSeveralRanges) {
|
| // Append 5 buffers at positions 0 through 4.
|
| - NewSegmentAppend(0, 5);
|
| + NewCodedFrameGroupAppend(0, 5);
|
|
|
| // Append 5 buffers at positions 10 through 14.
|
| - NewSegmentAppend(10, 5);
|
| + NewCodedFrameGroupAppend(10, 5);
|
|
|
| // Append 5 buffers at positions 20 through 24.
|
| - NewSegmentAppend(20, 5);
|
| + NewCodedFrameGroupAppend(20, 5);
|
|
|
| // Append 5 buffers at positions 40 through 44.
|
| - NewSegmentAppend(40, 5);
|
| + NewCodedFrameGroupAppend(40, 5);
|
|
|
| CheckExpectedRanges("{ [0,4) [10,14) [20,24) [40,44) }");
|
|
|
| @@ -2566,7 +2532,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteSeveralRanges) {
|
| SetMemoryLimit(1);
|
|
|
| // Append 5 buffers at positions 30 through 34.
|
| - NewSegmentAppend(30, 5);
|
| + NewCodedFrameGroupAppend(30, 5);
|
|
|
| // We will have more than 1 buffer left, GC will fail
|
| EXPECT_FALSE(GarbageCollectWithPlaybackAtBuffer(20, 0));
|
| @@ -2585,13 +2551,13 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteSeveralRanges) {
|
|
|
| // Make sure appending before and after the ranges didn't somehow break.
|
| SetMemoryLimit(100);
|
| - NewSegmentAppend(0, 10);
|
| + NewCodedFrameGroupAppend(0, 10);
|
| EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(20, 0));
|
| CheckExpectedRanges("{ [0,9) [20,24) [30,44) }");
|
| Seek(0);
|
| CheckExpectedBuffers(0, 9);
|
|
|
| - NewSegmentAppend(90, 10);
|
| + NewCodedFrameGroupAppend(90, 10);
|
| EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(0, 0));
|
| CheckExpectedRanges("{ [0,9) [20,24) [30,44) [90,99) }");
|
| Seek(30);
|
| @@ -2607,10 +2573,10 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteAfterLastAppend) {
|
| SetMemoryLimit(10);
|
|
|
| // Append 1 GOP starting at 310ms, 30ms apart.
|
| - NewSegmentAppend("310K 340 370");
|
| + NewCodedFrameGroupAppend("310K 340 370");
|
|
|
| // Append 2 GOPs starting at 490ms, 30ms apart.
|
| - NewSegmentAppend("490K 520 550 580K 610 640");
|
| + NewCodedFrameGroupAppend("490K 520 550 580K 610 640");
|
|
|
| EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(0, 0));
|
|
|
| @@ -2621,7 +2587,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteAfterLastAppend) {
|
|
|
| // Append 2 GOPs before the existing ranges.
|
| // So the ranges before GC are "{ [100,280) [310,400) [490,670) }".
|
| - NewSegmentAppend("100K 130 160 190K 220 250K");
|
| + NewCodedFrameGroupAppend("100K 130 160 190K 220 250K");
|
|
|
| EXPECT_TRUE(stream_->GarbageCollectIfNeeded(
|
| DecodeTimestamp::FromMilliseconds(580), 0));
|
| @@ -2635,14 +2601,14 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteAfterLastAppendMerged) {
|
| SetMemoryLimit(10);
|
|
|
| // Append 3 GOPs starting at 400ms, 30ms apart.
|
| - NewSegmentAppend("400K 430 460 490K 520 550 580K 610 640");
|
| + NewCodedFrameGroupAppend("400K 430 460 490K 520 550 580K 610 640");
|
|
|
| // Seek to the GOP at 580ms.
|
| SeekToTimestampMs(580);
|
|
|
| // Append 2 GOPs starting at 220ms, and they will be merged with the existing
|
| // range. So the range before GC is "{ [220,670) }".
|
| - NewSegmentAppend("220K 250 280 310K 340 370");
|
| + NewCodedFrameGroupAppend("220K 250 280 310K 340 370");
|
|
|
| EXPECT_TRUE(stream_->GarbageCollectIfNeeded(
|
| DecodeTimestamp::FromMilliseconds(580), 0));
|
| @@ -2656,7 +2622,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_NoSeek) {
|
| SetMemoryLimit(20);
|
|
|
| // Append 25 buffers at positions 0 through 24.
|
| - NewSegmentAppend(0, 25, &kDataA);
|
| + NewCodedFrameGroupAppend(0, 25, &kDataA);
|
|
|
| // If playback is still in the first GOP (starting at 0), GC should fail.
|
| EXPECT_FALSE(GarbageCollectWithPlaybackAtBuffer(2, 0));
|
| @@ -2673,10 +2639,10 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_NoSeek) {
|
|
|
| TEST_F(SourceBufferStreamTest, GarbageCollection_PendingSeek) {
|
| // Append 10 buffers at positions 0 through 9.
|
| - NewSegmentAppend(0, 10, &kDataA);
|
| + NewCodedFrameGroupAppend(0, 10, &kDataA);
|
|
|
| // Append 5 buffers at positions 25 through 29.
|
| - NewSegmentAppend(25, 5, &kDataA);
|
| + NewCodedFrameGroupAppend(25, 5, &kDataA);
|
|
|
| // Seek to position 15.
|
| Seek(15);
|
| @@ -2700,7 +2666,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_PendingSeek) {
|
|
|
| // Append data to fulfill seek.
|
| EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(30, 5));
|
| - NewSegmentAppend(15, 5, &kDataA);
|
| + NewCodedFrameGroupAppend(15, 5, &kDataA);
|
|
|
| // Check to make sure all is well.
|
| CheckExpectedRanges("{ [15,19) [30,34) }");
|
| @@ -2714,7 +2680,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_NeedsMoreData) {
|
| SetMemoryLimit(15);
|
|
|
| // Append 10 buffers at positions 0 through 9.
|
| - NewSegmentAppend(0, 10, &kDataA);
|
| + NewCodedFrameGroupAppend(0, 10, &kDataA);
|
|
|
| // Advance next buffer position to 10.
|
| Seek(0);
|
| @@ -2723,7 +2689,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_NeedsMoreData) {
|
| CheckNoNextBuffer();
|
|
|
| // Append 20 buffers at positions 15 through 34.
|
| - NewSegmentAppend(15, 20, &kDataA);
|
| + NewCodedFrameGroupAppend(15, 20, &kDataA);
|
| CheckExpectedRanges("{ [0,9) [15,34) }");
|
|
|
| // GC should save the keyframe before the next buffer position and the data
|
| @@ -2735,7 +2701,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_NeedsMoreData) {
|
|
|
| // Now fulfill the seek at position 10. This will make GC delete the data
|
| // before position 10 to keep it within cap.
|
| - NewSegmentAppend(10, 5, &kDataA);
|
| + NewCodedFrameGroupAppend(10, 5, &kDataA);
|
| EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(10, 0));
|
| CheckExpectedRanges("{ [10,24) }");
|
| CheckExpectedBuffers(10, 24, &kDataA);
|
| @@ -2751,7 +2717,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_TrackBuffer) {
|
| Seek(15);
|
|
|
| // Append 18 buffers at positions 0 through 17.
|
| - NewSegmentAppend(0, 18, &kDataA);
|
| + NewCodedFrameGroupAppend(0, 18, &kDataA);
|
|
|
| EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(15, 0));
|
|
|
| @@ -2762,7 +2728,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_TrackBuffer) {
|
| CheckExpectedBuffers(15, 15, &kDataA);
|
|
|
| // Completely overlap the existing buffers.
|
| - NewSegmentAppend(0, 20, &kDataB);
|
| + NewCodedFrameGroupAppend(0, 20, &kDataB);
|
|
|
| // Final GOP [15,19) contains 5 buffers, which is more than memory limit of
|
| // 3 buffers set at the beginning of the test, so GC will fail.
|
| @@ -2793,7 +2759,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_SaveDataAtPlaybackPosition) {
|
| // Set memory limit to 30 buffers = 1 second of data.
|
| SetMemoryLimit(30);
|
| // And append 300 buffers = 10 seconds of data.
|
| - NewSegmentAppend(0, 300, &kDataA);
|
| + NewCodedFrameGroupAppend(0, 300, &kDataA);
|
| CheckExpectedRanges("{ [0,299) }");
|
|
|
| // Playback position at 0, all data must be preserved.
|
| @@ -2851,7 +2817,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP) {
|
| // Set memory limit to 3 and make sure the 4-byte GOP is not garbage
|
| // collected.
|
| SetMemoryLimit(3);
|
| - NewSegmentAppend("0K 30 60 90");
|
| + NewCodedFrameGroupAppend("0K 30 60 90");
|
| EXPECT_FALSE(GarbageCollectWithPlaybackAtBuffer(0, 0));
|
| CheckExpectedRangesByTimestamp("{ [0,120) }");
|
|
|
| @@ -2862,7 +2828,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP) {
|
| CheckExpectedRangesByTimestamp("{ [0,150) }");
|
|
|
| // Append a 2nd range after this without triggering GC.
|
| - NewSegmentAppend("200K 230 260 290K 320 350");
|
| + NewCodedFrameGroupAppend("200K 230 260 290K 320 350");
|
| CheckExpectedRangesByTimestamp("{ [0,150) [200,380) }");
|
|
|
| // Seek to 290ms.
|
| @@ -2871,7 +2837,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP) {
|
| // Now append a GOP in a separate range after the selected range and trigger
|
| // GC. Because it is after 290ms, this tests that the GOP is saved when
|
| // deleting from the back.
|
| - NewSegmentAppend("500K 530 560 590");
|
| + NewCodedFrameGroupAppend("500K 530 560 590");
|
| EXPECT_FALSE(stream_->GarbageCollectIfNeeded(
|
| DecodeTimestamp::FromMilliseconds(290), 0));
|
|
|
| @@ -2889,13 +2855,13 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP) {
|
| // non-selected range.
|
| TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Middle) {
|
| // Append 3 GOPs starting at 0ms, 30ms apart.
|
| - NewSegmentAppend("0K 30 60 90K 120 150 180K 210 240");
|
| + NewCodedFrameGroupAppend("0K 30 60 90K 120 150 180K 210 240");
|
| CheckExpectedRangesByTimestamp("{ [0,270) }");
|
|
|
| // Now set the memory limit to 1 and overlap the middle of the range with a
|
| // new GOP.
|
| SetMemoryLimit(1);
|
| - NewSegmentAppend("80K 110 140");
|
| + NewCodedFrameGroupAppend("80K 110 140");
|
|
|
| // This whole GOP should be saved after GC, which will fail due to GOP being
|
| // larger than 1 buffer
|
| @@ -2909,7 +2875,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Middle) {
|
| CheckExpectedRangesByTimestamp("{ [80,200) }");
|
|
|
| // Append a 2nd range after this range, without triggering GC.
|
| - NewSegmentAppend("400K 430 460 490K 520 550 580K 610 640");
|
| + NewCodedFrameGroupAppend("400K 430 460 490K 520 550 580K 610 640");
|
| CheckExpectedRangesByTimestamp("{ [80,200) [400,670) }");
|
|
|
| // Seek to 80ms to make the first range the selected range.
|
| @@ -2918,7 +2884,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Middle) {
|
| // Now append a GOP in the middle of the second range and trigger GC. Because
|
| // it is after the selected range, this tests that the GOP is saved when
|
| // deleting from the back.
|
| - NewSegmentAppend("500K 530 560 590");
|
| + NewCodedFrameGroupAppend("500K 530 560 590");
|
| EXPECT_FALSE(stream_->GarbageCollectIfNeeded(
|
| DecodeTimestamp::FromMilliseconds(80), 0));
|
|
|
| @@ -2936,7 +2902,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Middle) {
|
| // adjacent to the last GOP appended.
|
| TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Selected1) {
|
| // Append 3 GOPs at 0ms, 90ms, and 180ms.
|
| - NewSegmentAppend("0K 30 60 90K 120 150 180K 210 240");
|
| + NewCodedFrameGroupAppend("0K 30 60 90K 120 150 180K 210 240");
|
| CheckExpectedRangesByTimestamp("{ [0,270) }");
|
|
|
| // Seek to the GOP at 90ms.
|
| @@ -2944,7 +2910,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Selected1) {
|
|
|
| // Set the memory limit to 1, then overlap the GOP at 0.
|
| SetMemoryLimit(1);
|
| - NewSegmentAppend("0K 30 60");
|
| + NewCodedFrameGroupAppend("0K 30 60");
|
|
|
| // GC should save the GOP at 0ms and 90ms, and will fail since GOP larger
|
| // than 1 buffer
|
| @@ -2959,7 +2925,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Selected1) {
|
|
|
| // Now seek back to 90ms and append a GOP at 180ms.
|
| SeekToTimestampMs(90);
|
| - NewSegmentAppend("180K 210 240");
|
| + NewCodedFrameGroupAppend("180K 210 240");
|
|
|
| // Should save the GOP at 90ms and the GOP at 180ms.
|
| EXPECT_FALSE(stream_->GarbageCollectIfNeeded(
|
| @@ -2974,7 +2940,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Selected1) {
|
| // GOP containing the next buffer, but not directly adjacent to this GOP.
|
| TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Selected2) {
|
| // Append 4 GOPs starting at positions 0ms, 90ms, 180ms, 270ms.
|
| - NewSegmentAppend("0K 30 60 90K 120 150 180K 210 240 270K 300 330");
|
| + NewCodedFrameGroupAppend("0K 30 60 90K 120 150 180K 210 240 270K 300 330");
|
| CheckExpectedRangesByTimestamp("{ [0,360) }");
|
|
|
| // Seek to the last GOP at 270ms.
|
| @@ -2982,7 +2948,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Selected2) {
|
|
|
| // Set the memory limit to 1, then overlap the GOP at 90ms.
|
| SetMemoryLimit(1);
|
| - NewSegmentAppend("90K 120 150");
|
| + NewCodedFrameGroupAppend("90K 120 150");
|
|
|
| // GC will save data in the range where the most recent append has happened
|
| // [0; 180) and the range where the next read position is [270;360)
|
| @@ -2991,12 +2957,12 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Selected2) {
|
| CheckExpectedRangesByTimestamp("{ [0,180) [270,360) }");
|
|
|
| // Add 3 GOPs to the end of the selected range at 360ms, 450ms, and 540ms.
|
| - NewSegmentAppend("360K 390 420 450K 480 510 540K 570 600");
|
| + NewCodedFrameGroupAppend("360K 390 420 450K 480 510 540K 570 600");
|
| CheckExpectedRangesByTimestamp("{ [0,180) [270,630) }");
|
|
|
| // Overlap the GOP at 450ms and garbage collect to test deleting from the
|
| // back.
|
| - NewSegmentAppend("450K 480 510");
|
| + NewCodedFrameGroupAppend("450K 480 510");
|
| EXPECT_FALSE(stream_->GarbageCollectIfNeeded(
|
| DecodeTimestamp::FromMilliseconds(270), 0));
|
|
|
| @@ -3011,13 +2977,13 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Selected3) {
|
| SeekToTimestampMs(0);
|
|
|
| // Append 3 GOPs starting at 0ms, 90ms, 180ms.
|
| - NewSegmentAppend("0K 30 60 90K 120 150 180K 210 240");
|
| + NewCodedFrameGroupAppend("0K 30 60 90K 120 150 180K 210 240");
|
| CheckExpectedRangesByTimestamp("{ [0,270) }");
|
|
|
| // Set the memory limit to 1 then begin appending the start of a GOP starting
|
| // at 0ms.
|
| SetMemoryLimit(1);
|
| - NewSegmentAppend("0K 30");
|
| + NewCodedFrameGroupAppend("0K 30");
|
|
|
| // GC should save the newly appended GOP, which is also the next GOP that
|
| // will be returned from the seek request.
|
| @@ -3047,7 +3013,7 @@ TEST_F(SourceBufferStreamTest, DISABLED_GarbageCollection_WaitingForKeyframe) {
|
| SetMemoryLimit(10);
|
|
|
| // Append 5 buffers at positions 10 through 14 and exhaust the buffers.
|
| - NewSegmentAppend(10, 5, &kDataA);
|
| + NewCodedFrameGroupAppend(10, 5, &kDataA);
|
| Seek(10);
|
| CheckExpectedBuffers(10, 14, &kDataA);
|
| CheckExpectedRanges("{ [10,14) }");
|
| @@ -3056,12 +3022,12 @@ TEST_F(SourceBufferStreamTest, DISABLED_GarbageCollection_WaitingForKeyframe) {
|
| CheckNoNextBuffer();
|
|
|
| // Do an end overlap that causes the latter half of the range to be deleted.
|
| - NewSegmentAppend(5, 6, &kDataA);
|
| + NewCodedFrameGroupAppend(5, 6, &kDataA);
|
| CheckNoNextBuffer();
|
| CheckExpectedRanges("{ [5,10) }");
|
|
|
| // Append buffers from position 20 to 29. This should trigger GC.
|
| - NewSegmentAppend(20, 10, &kDataA);
|
| + NewCodedFrameGroupAppend(20, 10, &kDataA);
|
|
|
| // GC should keep the keyframe before the seek position 15, and the next 9
|
| // buffers closest to the seek position.
|
| @@ -3069,7 +3035,7 @@ TEST_F(SourceBufferStreamTest, DISABLED_GarbageCollection_WaitingForKeyframe) {
|
| CheckExpectedRanges("{ [10,10) [20,28) }");
|
|
|
| // Fulfill the seek by appending one buffer at 15.
|
| - NewSegmentAppend(15, 1, &kDataA);
|
| + NewCodedFrameGroupAppend(15, 1, &kDataA);
|
| CheckExpectedBuffers(15, 15, &kDataA);
|
| CheckExpectedRanges("{ [15,15) [20,28) }");
|
| }
|
| @@ -3084,7 +3050,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_Performance) {
|
|
|
| int buffers_appended = 0;
|
|
|
| - NewSegmentAppend(0, kBuffersToKeep);
|
| + NewCodedFrameGroupAppend(0, kBuffersToKeep);
|
| buffers_appended += kBuffersToKeep;
|
|
|
| const int kBuffersToAppend = 1000;
|
| @@ -3100,7 +3066,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_MediaTimeAfterLastAppendTime) {
|
| SetMemoryLimit(10);
|
|
|
| // Append 12 buffers. The duration of the last buffer is 30
|
| - NewSegmentAppend("0K 30 60 90 120K 150 180 210K 240 270 300K 330D30");
|
| + NewCodedFrameGroupAppend("0K 30 60 90 120K 150 180 210K 240 270 300K 330D30");
|
| CheckExpectedRangesByTimestamp("{ [0,360) }");
|
|
|
| // Do a garbage collection with the media time higher than the timestamp of
|
| @@ -3121,7 +3087,7 @@ TEST_F(SourceBufferStreamTest,
|
| SetMemoryLimit(10);
|
|
|
| // Append 12 buffers.
|
| - NewSegmentAppend("0K 30 60 90 120K 150 180 210K 240 270 300K 330");
|
| + NewCodedFrameGroupAppend("0K 30 60 90 120K 150 180 210K 240 270 300K 330");
|
| CheckExpectedRangesByTimestamp("{ [0,360) }");
|
|
|
| // Seek in order to set the stream read position to 330 an ensure that the
|
| @@ -3145,13 +3111,13 @@ TEST_F(SourceBufferStreamTest,
|
|
|
| TEST_F(SourceBufferStreamTest, GetRemovalRange_BytesToFree) {
|
| // Append 2 GOPs starting at 300ms, 30ms apart.
|
| - NewSegmentAppend("300K 330 360 390K 420 450");
|
| + NewCodedFrameGroupAppend("300K 330 360 390K 420 450");
|
|
|
| // Append 2 GOPs starting at 600ms, 30ms apart.
|
| - NewSegmentAppend("600K 630 660 690K 720 750");
|
| + NewCodedFrameGroupAppend("600K 630 660 690K 720 750");
|
|
|
| // Append 2 GOPs starting at 900ms, 30ms apart.
|
| - NewSegmentAppend("900K 930 960 990K 1020 1050");
|
| + NewCodedFrameGroupAppend("900K 930 960 990K 1020 1050");
|
|
|
| CheckExpectedRangesByTimestamp("{ [300,480) [600,780) [900,1080) }");
|
|
|
| @@ -3207,13 +3173,13 @@ TEST_F(SourceBufferStreamTest, GetRemovalRange_BytesToFree) {
|
|
|
| TEST_F(SourceBufferStreamTest, GetRemovalRange_Range) {
|
| // Append 2 GOPs starting at 300ms, 30ms apart.
|
| - NewSegmentAppend("300K 330 360 390K 420 450");
|
| + NewCodedFrameGroupAppend("300K 330 360 390K 420 450");
|
|
|
| // Append 2 GOPs starting at 600ms, 30ms apart.
|
| - NewSegmentAppend("600K 630 660 690K 720 750");
|
| + NewCodedFrameGroupAppend("600K 630 660 690K 720 750");
|
|
|
| // Append 2 GOPs starting at 900ms, 30ms apart.
|
| - NewSegmentAppend("900K 930 960 990K 1020 1050");
|
| + NewCodedFrameGroupAppend("900K 930 960 990K 1020 1050");
|
|
|
| CheckExpectedRangesByTimestamp("{ [300,480) [600,780) [900,1080) }");
|
|
|
| @@ -3279,7 +3245,7 @@ TEST_F(SourceBufferStreamTest, ConfigChange_Basic) {
|
| CheckVideoConfig(video_config_);
|
|
|
| // Append 5 buffers at positions 0 through 4
|
| - NewSegmentAppend(0, 5, &kDataA);
|
| + NewCodedFrameGroupAppend(0, 5, &kDataA);
|
|
|
| CheckVideoConfig(video_config_);
|
|
|
| @@ -3291,7 +3257,7 @@ TEST_F(SourceBufferStreamTest, ConfigChange_Basic) {
|
| CheckVideoConfig(video_config_);
|
|
|
| // Append 5 buffers at positions 5 through 9.
|
| - NewSegmentAppend(5, 5, &kDataB);
|
| + NewCodedFrameGroupAppend(5, 5, &kDataB);
|
|
|
| // Consume the buffers associated with the initial config.
|
| scoped_refptr<StreamParserBuffer> buffer;
|
| @@ -3319,9 +3285,9 @@ TEST_F(SourceBufferStreamTest, ConfigChange_Seek) {
|
| VideoDecoderConfig new_config = TestVideoConfig::Large();
|
|
|
| Seek(0);
|
| - NewSegmentAppend(0, 5, &kDataA);
|
| + NewCodedFrameGroupAppend(0, 5, &kDataA);
|
| stream_->UpdateVideoConfig(new_config);
|
| - NewSegmentAppend(5, 5, &kDataB);
|
| + NewCodedFrameGroupAppend(5, 5, &kDataB);
|
|
|
| // Seek to the start of the buffers with the new config and make sure a
|
| // config change is signalled.
|
| @@ -3353,13 +3319,13 @@ TEST_F(SourceBufferStreamTest, ConfigChange_Seek) {
|
|
|
| TEST_F(SourceBufferStreamTest, SetExplicitDuration) {
|
| // Append 2 buffers at positions 5 through 6.
|
| - NewSegmentAppend(5, 2);
|
| + NewCodedFrameGroupAppend(5, 2);
|
|
|
| // Append 2 buffers at positions 10 through 11.
|
| - NewSegmentAppend(10, 2);
|
| + NewCodedFrameGroupAppend(10, 2);
|
|
|
| // Append 2 buffers at positions 15 through 16.
|
| - NewSegmentAppend(15, 2);
|
| + NewCodedFrameGroupAppend(15, 2);
|
|
|
| // Check expected ranges.
|
| CheckExpectedRanges("{ [5,6) [10,11) [15,16) }");
|
| @@ -3371,16 +3337,16 @@ TEST_F(SourceBufferStreamTest, SetExplicitDuration) {
|
| CheckExpectedRanges("{ [5,6) }");
|
|
|
| // Adding data past the previous duration should still work.
|
| - NewSegmentAppend(0, 20);
|
| + NewCodedFrameGroupAppend(0, 20);
|
| CheckExpectedRanges("{ [0,19) }");
|
| }
|
|
|
| TEST_F(SourceBufferStreamTest, SetExplicitDuration_EdgeCase) {
|
| // Append 10 buffers at positions 10 through 19.
|
| - NewSegmentAppend(10, 10);
|
| + NewCodedFrameGroupAppend(10, 10);
|
|
|
| // Append 5 buffers at positions 25 through 29.
|
| - NewSegmentAppend(25, 5);
|
| + NewCodedFrameGroupAppend(25, 5);
|
|
|
| // Check expected ranges.
|
| CheckExpectedRanges("{ [10,19) [25,29) }");
|
| @@ -3394,13 +3360,13 @@ TEST_F(SourceBufferStreamTest, SetExplicitDuration_EdgeCase) {
|
|
|
| TEST_F(SourceBufferStreamTest, SetExplicitDuration_DeletePartialRange) {
|
| // Append 5 buffers at positions 0 through 4.
|
| - NewSegmentAppend(0, 5);
|
| + NewCodedFrameGroupAppend(0, 5);
|
|
|
| // Append 10 buffers at positions 10 through 19.
|
| - NewSegmentAppend(10, 10);
|
| + NewCodedFrameGroupAppend(10, 10);
|
|
|
| // Append 5 buffers at positions 25 through 29.
|
| - NewSegmentAppend(25, 5);
|
| + NewCodedFrameGroupAppend(25, 5);
|
|
|
| // Check expected ranges.
|
| CheckExpectedRanges("{ [0,4) [10,19) [25,29) }");
|
| @@ -3414,13 +3380,13 @@ TEST_F(SourceBufferStreamTest, SetExplicitDuration_DeletePartialRange) {
|
|
|
| TEST_F(SourceBufferStreamTest, SetExplicitDuration_DeleteSelectedRange) {
|
| // Append 2 buffers at positions 5 through 6.
|
| - NewSegmentAppend(5, 2);
|
| + NewCodedFrameGroupAppend(5, 2);
|
|
|
| // Append 2 buffers at positions 10 through 11.
|
| - NewSegmentAppend(10, 2);
|
| + NewCodedFrameGroupAppend(10, 2);
|
|
|
| // Append 2 buffers at positions 15 through 16.
|
| - NewSegmentAppend(15, 2);
|
| + NewCodedFrameGroupAppend(15, 2);
|
|
|
| // Check expected ranges.
|
| CheckExpectedRanges("{ [5,6) [10,11) [15,16) }");
|
| @@ -3440,17 +3406,17 @@ TEST_F(SourceBufferStreamTest, SetExplicitDuration_DeleteSelectedRange) {
|
| // point, then the seek point is reset and the SourceBufferStream waits
|
| // for a new seek request. Therefore even if the data is re-appended, it
|
| // should not fulfill the old seek.)
|
| - NewSegmentAppend(0, 15);
|
| + NewCodedFrameGroupAppend(0, 15);
|
| CheckNoNextBuffer();
|
| CheckExpectedRanges("{ [0,14) }");
|
| }
|
|
|
| TEST_F(SourceBufferStreamTest, SetExplicitDuration_DeletePartialSelectedRange) {
|
| // Append 5 buffers at positions 0 through 4.
|
| - NewSegmentAppend(0, 5);
|
| + NewCodedFrameGroupAppend(0, 5);
|
|
|
| // Append 20 buffers at positions 10 through 29.
|
| - NewSegmentAppend(10, 20);
|
| + NewCodedFrameGroupAppend(10, 20);
|
|
|
| // Check expected ranges.
|
| CheckExpectedRanges("{ [0,4) [10,29) }");
|
| @@ -3483,7 +3449,7 @@ TEST_F(SourceBufferStreamTest, SetExplicitDuration_UpdateSelectedRange) {
|
| // Seek to start of stream.
|
| SeekToTimestampMs(0);
|
|
|
| - NewSegmentAppend("0K 30 60 90");
|
| + NewCodedFrameGroupAppend("0K 30 60 90");
|
|
|
| // Read out the first few buffers.
|
| CheckExpectedBuffers("0K 30");
|
| @@ -3495,23 +3461,22 @@ TEST_F(SourceBufferStreamTest, SetExplicitDuration_UpdateSelectedRange) {
|
| CheckNoNextBuffer();
|
|
|
| // We should be able to append new buffers at this point.
|
| - NewSegmentAppend("120K 150");
|
| + NewCodedFrameGroupAppend("120K 150");
|
|
|
| CheckExpectedRangesByTimestamp("{ [0,60) [120,180) }");
|
| }
|
|
|
| TEST_F(SourceBufferStreamTest,
|
| - SetExplicitDuration_AfterSegmentTimestampAndBeforeFirstBufferTimestamp) {
|
| -
|
| - NewSegmentAppend("0K 30K 60K");
|
| + SetExplicitDuration_AfterGroupTimestampAndBeforeFirstBufferTimestamp) {
|
| + NewCodedFrameGroupAppend("0K 30K 60K");
|
|
|
| - // Append a segment with a start timestamp of 200, but the first
|
| + // Append a coded frame group with a start timestamp of 200, but the first
|
| // buffer starts at 230ms. This can happen in muxed content where the
|
| // audio starts before the first frame.
|
| - NewSegmentAppend(base::TimeDelta::FromMilliseconds(200),
|
| - "230K 260K 290K 320K");
|
| + NewCodedFrameGroupAppend(base::TimeDelta::FromMilliseconds(200),
|
| + "230K 260K 290K 320K");
|
|
|
| - NewSegmentAppend("400K 430K 460K");
|
| + NewCodedFrameGroupAppend("400K 430K 460K");
|
|
|
| CheckExpectedRangesByTimestamp("{ [0,90) [200,350) [400,490) }");
|
|
|
| @@ -3523,7 +3488,7 @@ TEST_F(SourceBufferStreamTest,
|
|
|
| TEST_F(SourceBufferStreamTest, SetExplicitDuration_MarkEOS) {
|
| // Append 1 buffer at positions 0 through 8.
|
| - NewSegmentAppend(0, 9);
|
| + NewCodedFrameGroupAppend(0, 9);
|
|
|
| // Check expected ranges.
|
| CheckExpectedRanges("{ [0,8) }");
|
| @@ -3548,7 +3513,7 @@ TEST_F(SourceBufferStreamTest, SetExplicitDuration_MarkEOS) {
|
|
|
| TEST_F(SourceBufferStreamTest, SetExplicitDuration_MarkEOS_IsSeekPending) {
|
| // Append 1 buffer at positions 0 through 8.
|
| - NewSegmentAppend(0, 9);
|
| + NewCodedFrameGroupAppend(0, 9);
|
|
|
| // Check expected ranges.
|
| CheckExpectedRanges("{ [0,8) }");
|
| @@ -3577,7 +3542,7 @@ TEST_F(SourceBufferStreamTest, OverlapSplitAndMergeWhileWaitingForMoreData) {
|
| // Seek to start of stream.
|
| SeekToTimestampMs(0);
|
|
|
| - NewSegmentAppend("0K 30 60 90 120K 150");
|
| + NewCodedFrameGroupAppend("0K 30 60 90 120K 150");
|
| CheckExpectedRangesByTimestamp("{ [0,180) }");
|
|
|
| // Read all the buffered data.
|
| @@ -3586,11 +3551,11 @@ TEST_F(SourceBufferStreamTest, OverlapSplitAndMergeWhileWaitingForMoreData) {
|
|
|
| // Append data over the current GOP so that a keyframe is needed before
|
| // playback can continue from the current position.
|
| - NewSegmentAppend("120K 150");
|
| + NewCodedFrameGroupAppend("120K 150");
|
| CheckExpectedRangesByTimestamp("{ [0,180) }");
|
|
|
| // Append buffers that cause the range to get split.
|
| - NewSegmentAppend("0K 30");
|
| + NewCodedFrameGroupAppend("0K 30");
|
| CheckExpectedRangesByTimestamp("{ [0,60) [120,180) }");
|
|
|
| // Append buffers that cause the ranges to get merged.
|
| @@ -3602,7 +3567,7 @@ TEST_F(SourceBufferStreamTest, OverlapSplitAndMergeWhileWaitingForMoreData) {
|
| CheckNoNextBuffer();
|
|
|
| // Add more data to the end and verify that this new data is read correctly.
|
| - NewSegmentAppend("180K 210");
|
| + NewCodedFrameGroupAppend("180K 210");
|
| CheckExpectedRangesByTimestamp("{ [0,240) }");
|
| CheckExpectedBuffers("180K 210");
|
| }
|
| @@ -3611,7 +3576,7 @@ TEST_F(SourceBufferStreamTest, OverlapSplitAndMergeWhileWaitingForMoreData) {
|
| // append are handled correctly.
|
| TEST_F(SourceBufferStreamTest, SameTimestamp_Video_SingleAppend) {
|
| Seek(0);
|
| - NewSegmentAppend("0K 30 30 60 90 120K 150");
|
| + NewCodedFrameGroupAppend("0K 30 30 60 90 120K 150");
|
| CheckExpectedBuffers("0K 30 30 60 90 120K 150");
|
| }
|
|
|
| @@ -3619,62 +3584,64 @@ TEST_F(SourceBufferStreamTest, SameTimestamp_Video_SingleAppend) {
|
| // in different appends.
|
| TEST_F(SourceBufferStreamTest, SameTimestamp_Video_TwoAppends) {
|
| Seek(0);
|
| - NewSegmentAppend("0K 30");
|
| + NewCodedFrameGroupAppend("0K 30");
|
| AppendBuffers("30 60 90 120K 150");
|
| CheckExpectedBuffers("0K 30 30 60 90 120K 150");
|
| }
|
|
|
| // Verify that a non-keyframe followed by a keyframe with the same timestamp
|
| -// is not allowed.
|
| -TEST_F(SourceBufferStreamTest, SameTimestamp_Video_Invalid_1) {
|
| +// is allowed, but also results in a MediaLog.
|
| +TEST_F(SourceBufferStreamTest, SameTimestamp_Video_SingleAppend_Warning) {
|
| EXPECT_MEDIA_LOG(ContainsSameTimestampAt30MillisecondsLog());
|
|
|
| Seek(0);
|
| - NewSegmentAppend("0K 30");
|
| - AppendBuffers_ExpectFailure("30K 60");
|
| + NewCodedFrameGroupAppend("0K 30 30K 60");
|
| + CheckExpectedBuffers("0K 30 30K 60");
|
| }
|
|
|
| -TEST_F(SourceBufferStreamTest, SameTimestamp_Video_Invalid_2) {
|
| +TEST_F(SourceBufferStreamTest, SameTimestamp_Video_TwoAppends_Warning) {
|
| EXPECT_MEDIA_LOG(ContainsSameTimestampAt30MillisecondsLog());
|
|
|
| Seek(0);
|
| - NewSegmentAppend_ExpectFailure("0K 30 30K 60");
|
| + NewCodedFrameGroupAppend("0K 30");
|
| + AppendBuffers("30K 60");
|
| + CheckExpectedBuffers("0K 30 30K 60");
|
| }
|
|
|
| // Verify that a keyframe followed by a non-keyframe with the same timestamp
|
| // is allowed.
|
| TEST_F(SourceBufferStreamTest, SameTimestamp_VideoKeyFrame_TwoAppends) {
|
| Seek(0);
|
| - NewSegmentAppend("0K 30K");
|
| + NewCodedFrameGroupAppend("0K 30K");
|
| AppendBuffers("30 60");
|
| CheckExpectedBuffers("0K 30K 30 60");
|
| }
|
|
|
| TEST_F(SourceBufferStreamTest, SameTimestamp_VideoKeyFrame_SingleAppend) {
|
| Seek(0);
|
| - NewSegmentAppend("0K 30K 30 60");
|
| + NewCodedFrameGroupAppend("0K 30K 30 60");
|
| CheckExpectedBuffers("0K 30K 30 60");
|
| }
|
|
|
| TEST_F(SourceBufferStreamTest, SameTimestamp_Video_Overlap_1) {
|
| Seek(0);
|
| - NewSegmentAppend("0K 30 60 60 90 120K 150");
|
| + NewCodedFrameGroupAppend("0K 30 60 60 90 120K 150");
|
|
|
| - NewSegmentAppend("60K 91 121K 151");
|
| + NewCodedFrameGroupAppend("60K 91 121K 151");
|
| CheckExpectedBuffers("0K 30 60K 91 121K 151");
|
| }
|
|
|
| TEST_F(SourceBufferStreamTest, SameTimestamp_Video_Overlap_2) {
|
| Seek(0);
|
| - NewSegmentAppend("0K 30 60 60 90 120K 150");
|
| - NewSegmentAppend("0K 30 61");
|
| + NewCodedFrameGroupAppend("0K 30 60 60 90 120K 150");
|
| + NewCodedFrameGroupAppend("0K 30 61");
|
| CheckExpectedBuffers("0K 30 61 120K 150");
|
| }
|
|
|
| TEST_F(SourceBufferStreamTest, SameTimestamp_Video_Overlap_3) {
|
| Seek(0);
|
| - NewSegmentAppend("0K 20 40 60 80 100K 101 102 103K");
|
| - NewSegmentAppend("0K 20 40 60 80 90");
|
| + NewCodedFrameGroupAppend("0K 20 40 60 80 100K 101 102 103K");
|
| + NewCodedFrameGroupAppend("0K 20 40 60 80 90");
|
| CheckExpectedBuffers("0K 20 40 60 80 90 100K 101 102 103K");
|
| AppendBuffers("90 110K 150");
|
| Seek(0);
|
| @@ -3689,18 +3656,22 @@ TEST_F(SourceBufferStreamTest, SameTimestamp_Audio) {
|
| 44100, EmptyExtraData(), false);
|
| stream_.reset(new SourceBufferStream(config, media_log_, true));
|
| Seek(0);
|
| - NewSegmentAppend("0K 0K 30K 30 60 60");
|
| + NewCodedFrameGroupAppend("0K 0K 30K 30 60 60");
|
| CheckExpectedBuffers("0K 0K 30K 30 60 60");
|
| }
|
|
|
| -TEST_F(SourceBufferStreamTest, SameTimestamp_Audio_Invalid_1) {
|
| +TEST_F(SourceBufferStreamTest, SameTimestamp_Audio_SingleAppend_Warning) {
|
| EXPECT_MEDIA_LOG(ContainsSameTimestampAt30MillisecondsLog());
|
|
|
| AudioDecoderConfig config(kCodecMP3, kSampleFormatF32, CHANNEL_LAYOUT_STEREO,
|
| 44100, EmptyExtraData(), false);
|
| stream_.reset(new SourceBufferStream(config, media_log_, true));
|
| Seek(0);
|
| - NewSegmentAppend_ExpectFailure("0K 30 30K 60");
|
| +
|
| + // Note, in reality, a non-keyframe audio frame is rare or perhaps not
|
| + // possible.
|
| + NewCodedFrameGroupAppend("0K 30 30K 60");
|
| + CheckExpectedBuffers("0K 30 30K 60");
|
| }
|
|
|
| // If seeking past any existing range and the seek is pending
|
| @@ -3708,7 +3679,7 @@ TEST_F(SourceBufferStreamTest, SameTimestamp_Audio_Invalid_1) {
|
| // the stream position can be considered as the end of stream.
|
| TEST_F(SourceBufferStreamTest, EndSelected_During_PendingSeek) {
|
| // Append 15 buffers at positions 0 through 14.
|
| - NewSegmentAppend(0, 15);
|
| + NewCodedFrameGroupAppend(0, 15);
|
|
|
| Seek(20);
|
| EXPECT_TRUE(stream_->IsSeekPending());
|
| @@ -3722,8 +3693,8 @@ TEST_F(SourceBufferStreamTest, EndNotSelected_During_PendingSeek) {
|
| // Append:
|
| // - 10 buffers at positions 0 through 9.
|
| // - 10 buffers at positions 30 through 39
|
| - NewSegmentAppend(0, 10);
|
| - NewSegmentAppend(30, 10);
|
| + NewCodedFrameGroupAppend(0, 10);
|
| + NewCodedFrameGroupAppend(30, 10);
|
|
|
| Seek(20);
|
| EXPECT_TRUE(stream_->IsSeekPending());
|
| @@ -3735,7 +3706,7 @@ TEST_F(SourceBufferStreamTest, EndNotSelected_During_PendingSeek) {
|
| // Removing exact start & end of a range.
|
| TEST_F(SourceBufferStreamTest, Remove_WholeRange1) {
|
| Seek(0);
|
| - NewSegmentAppend("10K 40 70K 100 130K");
|
| + NewCodedFrameGroupAppend("10K 40 70K 100 130K");
|
| CheckExpectedRangesByTimestamp("{ [10,160) }");
|
| RemoveInMs(10, 160, 160);
|
| CheckExpectedRangesByTimestamp("{ }");
|
| @@ -3744,7 +3715,7 @@ TEST_F(SourceBufferStreamTest, Remove_WholeRange1) {
|
| // Removal range starts before range and ends exactly at end.
|
| TEST_F(SourceBufferStreamTest, Remove_WholeRange2) {
|
| Seek(0);
|
| - NewSegmentAppend("10K 40 70K 100 130K");
|
| + NewCodedFrameGroupAppend("10K 40 70K 100 130K");
|
| CheckExpectedRangesByTimestamp("{ [10,160) }");
|
| RemoveInMs(0, 160, 160);
|
| CheckExpectedRangesByTimestamp("{ }");
|
| @@ -3754,7 +3725,7 @@ TEST_F(SourceBufferStreamTest, Remove_WholeRange2) {
|
| // range end.
|
| TEST_F(SourceBufferStreamTest, Remove_WholeRange3) {
|
| Seek(0);
|
| - NewSegmentAppend("10K 40 70K 100 130K");
|
| + NewCodedFrameGroupAppend("10K 40 70K 100 130K");
|
| CheckExpectedRangesByTimestamp("{ [10,160) }");
|
| RemoveInMs(10, 200, 200);
|
| CheckExpectedRangesByTimestamp("{ }");
|
| @@ -3763,7 +3734,7 @@ TEST_F(SourceBufferStreamTest, Remove_WholeRange3) {
|
| // Removal range starts before range start and ends after the range end.
|
| TEST_F(SourceBufferStreamTest, Remove_WholeRange4) {
|
| Seek(0);
|
| - NewSegmentAppend("10K 40 70K 100 130K");
|
| + NewCodedFrameGroupAppend("10K 40 70K 100 130K");
|
| CheckExpectedRangesByTimestamp("{ [10,160) }");
|
| RemoveInMs(0, 200, 200);
|
| CheckExpectedRangesByTimestamp("{ }");
|
| @@ -3772,9 +3743,9 @@ TEST_F(SourceBufferStreamTest, Remove_WholeRange4) {
|
| // Removes multiple ranges.
|
| TEST_F(SourceBufferStreamTest, Remove_WholeRange5) {
|
| Seek(0);
|
| - NewSegmentAppend("10K 40 70K 100 130K");
|
| - NewSegmentAppend("1000K 1030 1060K 1090 1120K");
|
| - NewSegmentAppend("2000K 2030 2060K 2090 2120K");
|
| + NewCodedFrameGroupAppend("10K 40 70K 100 130K");
|
| + NewCodedFrameGroupAppend("1000K 1030 1060K 1090 1120K");
|
| + NewCodedFrameGroupAppend("2000K 2030 2060K 2090 2120K");
|
| CheckExpectedRangesByTimestamp("{ [10,160) [1000,1150) [2000,2150) }");
|
| RemoveInMs(10, 3000, 3000);
|
| CheckExpectedRangesByTimestamp("{ }");
|
| @@ -3783,9 +3754,9 @@ TEST_F(SourceBufferStreamTest, Remove_WholeRange5) {
|
| // Verifies a [0-infinity) range removes everything.
|
| TEST_F(SourceBufferStreamTest, Remove_ZeroToInfinity) {
|
| Seek(0);
|
| - NewSegmentAppend("10K 40 70K 100 130K");
|
| - NewSegmentAppend("1000K 1030 1060K 1090 1120K");
|
| - NewSegmentAppend("2000K 2030 2060K 2090 2120K");
|
| + NewCodedFrameGroupAppend("10K 40 70K 100 130K");
|
| + NewCodedFrameGroupAppend("1000K 1030 1060K 1090 1120K");
|
| + NewCodedFrameGroupAppend("2000K 2030 2060K 2090 2120K");
|
| CheckExpectedRangesByTimestamp("{ [10,160) [1000,1150) [2000,2150) }");
|
| Remove(base::TimeDelta(), kInfiniteDuration(), kInfiniteDuration());
|
| CheckExpectedRangesByTimestamp("{ }");
|
| @@ -3795,8 +3766,8 @@ TEST_F(SourceBufferStreamTest, Remove_ZeroToInfinity) {
|
| // middle of the range. This test verifies that full GOPs are removed.
|
| TEST_F(SourceBufferStreamTest, Remove_Partial1) {
|
| Seek(0);
|
| - NewSegmentAppend("10K 40 70K 100 130K");
|
| - NewSegmentAppend("1000K 1030 1060K 1090 1120K");
|
| + NewCodedFrameGroupAppend("10K 40 70K 100 130K");
|
| + NewCodedFrameGroupAppend("1000K 1030 1060K 1090 1120K");
|
| CheckExpectedRangesByTimestamp("{ [10,160) [1000,1150) }");
|
| RemoveInMs(0, 80, 2200);
|
| CheckExpectedRangesByTimestamp("{ [130,160) [1000,1150) }");
|
| @@ -3806,8 +3777,8 @@ TEST_F(SourceBufferStreamTest, Remove_Partial1) {
|
| // end of the range.
|
| TEST_F(SourceBufferStreamTest, Remove_Partial2) {
|
| Seek(0);
|
| - NewSegmentAppend("10K 40 70K 100 130K");
|
| - NewSegmentAppend("1000K 1030 1060K 1090 1120K");
|
| + NewCodedFrameGroupAppend("10K 40 70K 100 130K");
|
| + NewCodedFrameGroupAppend("1000K 1030 1060K 1090 1120K");
|
| CheckExpectedRangesByTimestamp("{ [10,160) [1000,1150) }");
|
| RemoveInMs(40, 160, 2200);
|
| CheckExpectedRangesByTimestamp("{ [10,40) [1000,1150) }");
|
| @@ -3816,8 +3787,8 @@ TEST_F(SourceBufferStreamTest, Remove_Partial2) {
|
| // Removal range starts and ends within a range.
|
| TEST_F(SourceBufferStreamTest, Remove_Partial3) {
|
| Seek(0);
|
| - NewSegmentAppend("10K 40 70K 100 130K");
|
| - NewSegmentAppend("1000K 1030 1060K 1090 1120K");
|
| + NewCodedFrameGroupAppend("10K 40 70K 100 130K");
|
| + NewCodedFrameGroupAppend("1000K 1030 1060K 1090 1120K");
|
| CheckExpectedRangesByTimestamp("{ [10,160) [1000,1150) }");
|
| RemoveInMs(40, 120, 2200);
|
| CheckExpectedRangesByTimestamp("{ [10,40) [130,160) [1000,1150) }");
|
| @@ -3827,9 +3798,9 @@ TEST_F(SourceBufferStreamTest, Remove_Partial3) {
|
| // middle of another range.
|
| TEST_F(SourceBufferStreamTest, Remove_Partial4) {
|
| Seek(0);
|
| - NewSegmentAppend("10K 40 70K 100 130K");
|
| - NewSegmentAppend("1000K 1030 1060K 1090 1120K");
|
| - NewSegmentAppend("2000K 2030 2060K 2090 2120K");
|
| + NewCodedFrameGroupAppend("10K 40 70K 100 130K");
|
| + NewCodedFrameGroupAppend("1000K 1030 1060K 1090 1120K");
|
| + NewCodedFrameGroupAppend("2000K 2030 2060K 2090 2120K");
|
| CheckExpectedRangesByTimestamp("{ [10,160) [1000,1150) [2000,2150) }");
|
| RemoveInMs(40, 2030, 2200);
|
| CheckExpectedRangesByTimestamp("{ [10,40) [2060,2150) }");
|
| @@ -3839,7 +3810,7 @@ TEST_F(SourceBufferStreamTest, Remove_Partial4) {
|
| // are appended over the removal range.
|
| TEST_F(SourceBufferStreamTest, Remove_CurrentPosition) {
|
| Seek(0);
|
| - NewSegmentAppend("0K 30 60 90K 120 150 180K 210 240 270K 300 330");
|
| + NewCodedFrameGroupAppend("0K 30 60 90K 120 150 180K 210 240 270K 300 330");
|
| CheckExpectedRangesByTimestamp("{ [0,360) }");
|
| CheckExpectedBuffers("0K 30 60 90K 120");
|
|
|
| @@ -3851,7 +3822,7 @@ TEST_F(SourceBufferStreamTest, Remove_CurrentPosition) {
|
| CheckNoNextBuffer();
|
|
|
| // Append some buffers to fill the gap that was created.
|
| - NewSegmentAppend("120K 150 180 210K 240");
|
| + NewCodedFrameGroupAppend("120K 150 180 210K 240");
|
| CheckExpectedRangesByTimestamp("{ [0,360) }");
|
|
|
| // Verify that buffers resume at the next keyframe after the
|
| @@ -3863,7 +3834,7 @@ TEST_F(SourceBufferStreamTest, Remove_CurrentPosition) {
|
| // are removed.
|
| TEST_F(SourceBufferStreamTest, Remove_BeforeCurrentPosition) {
|
| Seek(0);
|
| - NewSegmentAppend("0K 30 60 90K 120 150 180K 210 240 270K 300 330");
|
| + NewCodedFrameGroupAppend("0K 30 60 90K 120 150 180K 210 240 270K 300 330");
|
| CheckExpectedRangesByTimestamp("{ [0,360) }");
|
| CheckExpectedBuffers("0K 30 60 90K 120");
|
|
|
| @@ -3874,14 +3845,14 @@ TEST_F(SourceBufferStreamTest, Remove_BeforeCurrentPosition) {
|
| CheckExpectedBuffers("150 180K 210 240 270K 300 330");
|
| }
|
|
|
| -// Test removing the entire range for the current media segment
|
| +// Test removing the entire range for the current coded frame group
|
| // being appended.
|
| -TEST_F(SourceBufferStreamTest, Remove_MidSegment) {
|
| +TEST_F(SourceBufferStreamTest, Remove_MidGroup) {
|
| Seek(0);
|
| - NewSegmentAppend("0K 30 60 90 120K 150 180 210");
|
| + NewCodedFrameGroupAppend("0K 30 60 90 120K 150 180 210");
|
| CheckExpectedRangesByTimestamp("{ [0,240) }");
|
|
|
| - NewSegmentAppend("0K 30");
|
| + NewCodedFrameGroupAppend("0K 30");
|
|
|
| CheckExpectedBuffers("0K");
|
|
|
| @@ -3907,7 +3878,6 @@ TEST_F(SourceBufferStreamTest, Remove_MidSegment) {
|
| // Verify that new GOP replaces the existing range.
|
| CheckExpectedRangesByTimestamp("{ [150,210) }");
|
|
|
| -
|
| SeekToTimestampMs(150);
|
| CheckExpectedBuffers("150K 180");
|
| CheckNoNextBuffer();
|
| @@ -3917,7 +3887,7 @@ TEST_F(SourceBufferStreamTest, Remove_MidSegment) {
|
| // the entire range the GOP belongs to.
|
| TEST_F(SourceBufferStreamTest, Remove_GOPBeingAppended) {
|
| Seek(0);
|
| - NewSegmentAppend("0K 30 60 90 120K 150 180");
|
| + NewCodedFrameGroupAppend("0K 30 60 90 120K 150 180");
|
| CheckExpectedRangesByTimestamp("{ [0,210) }");
|
|
|
| // Remove the current GOP being appended.
|
| @@ -3941,7 +3911,7 @@ TEST_F(SourceBufferStreamTest, Remove_GOPBeingAppended) {
|
|
|
| TEST_F(SourceBufferStreamTest, Remove_WholeGOPBeingAppended) {
|
| SeekToTimestampMs(1000);
|
| - NewSegmentAppend("1000K 1030 1060 1090");
|
| + NewCodedFrameGroupAppend("1000K 1030 1060 1090");
|
| CheckExpectedRangesByTimestamp("{ [1000,1120) }");
|
|
|
| // Remove the keyframe of the current GOP being appended.
|
| @@ -3970,11 +3940,11 @@ TEST_F(SourceBufferStreamTest,
|
| Remove_PreviousAppendDestroyedAndOverwriteExistingRange) {
|
| SeekToTimestampMs(90);
|
|
|
| - NewSegmentAppend("90K 120 150");
|
| + NewCodedFrameGroupAppend("90K 120 150");
|
| CheckExpectedRangesByTimestamp("{ [90,180) }");
|
|
|
| - // Append a segment before the previously appended data.
|
| - NewSegmentAppend("0K 30 60");
|
| + // Append a coded frame group before the previously appended data.
|
| + NewCodedFrameGroupAppend("0K 30 60");
|
|
|
| // Verify that the ranges get merged.
|
| CheckExpectedRangesByTimestamp("{ [0,180) }");
|
| @@ -3983,19 +3953,19 @@ TEST_F(SourceBufferStreamTest,
|
| RemoveInMs(0, 90, 360);
|
| CheckExpectedRangesByTimestamp("{ [90,180) }");
|
|
|
| - // Append a new segment that follows the removed segment and
|
| + // Append a new coded frame group that follows the removed group and
|
| // starts at the beginning of the range left over from the
|
| // remove.
|
| - NewSegmentAppend("90K 121 151");
|
| + NewCodedFrameGroupAppend("90K 121 151");
|
| CheckExpectedBuffers("90K 121 151");
|
| }
|
|
|
| -TEST_F(SourceBufferStreamTest, Remove_GapAtBeginningOfMediaSegment) {
|
| +TEST_F(SourceBufferStreamTest, Remove_GapAtBeginningOfGroup) {
|
| Seek(0);
|
|
|
| - // Append a media segment that has a gap at the beginning of it.
|
| - NewSegmentAppend(base::TimeDelta::FromMilliseconds(0),
|
| - "30K 60 90 120K 150");
|
| + // Append a coded frame group that has a gap at the beginning of it.
|
| + NewCodedFrameGroupAppend(base::TimeDelta::FromMilliseconds(0),
|
| + "30K 60 90 120K 150");
|
| CheckExpectedRangesByTimestamp("{ [0,180) }");
|
|
|
| // Remove the gap that doesn't contain any buffers.
|
| @@ -4022,7 +3992,7 @@ TEST_F(SourceBufferStreamTest, Remove_GapAtBeginningOfMediaSegment) {
|
|
|
| TEST_F(SourceBufferStreamTest, Text_Append_SingleRange) {
|
| SetTextStream();
|
| - NewSegmentAppend("0K 500K 1000K");
|
| + NewCodedFrameGroupAppend("0K 500K 1000K");
|
| CheckExpectedRangesByTimestamp("{ [0,1500) }");
|
|
|
| Seek(0);
|
| @@ -4031,9 +4001,9 @@ TEST_F(SourceBufferStreamTest, Text_Append_SingleRange) {
|
|
|
| TEST_F(SourceBufferStreamTest, Text_Append_DisjointAfter) {
|
| SetTextStream();
|
| - NewSegmentAppend("0K 500K 1000K");
|
| + NewCodedFrameGroupAppend("0K 500K 1000K");
|
| CheckExpectedRangesByTimestamp("{ [0,1500) }");
|
| - NewSegmentAppend("3000K 3500K 4000K");
|
| + NewCodedFrameGroupAppend("3000K 3500K 4000K");
|
| CheckExpectedRangesByTimestamp("{ [0,4500) }");
|
|
|
| Seek(0);
|
| @@ -4042,9 +4012,9 @@ TEST_F(SourceBufferStreamTest, Text_Append_DisjointAfter) {
|
|
|
| TEST_F(SourceBufferStreamTest, Text_Append_DisjointBefore) {
|
| SetTextStream();
|
| - NewSegmentAppend("3000K 3500K 4000K");
|
| + NewCodedFrameGroupAppend("3000K 3500K 4000K");
|
| CheckExpectedRangesByTimestamp("{ [3000,4500) }");
|
| - NewSegmentAppend("0K 500K 1000K");
|
| + NewCodedFrameGroupAppend("0K 500K 1000K");
|
| CheckExpectedRangesByTimestamp("{ [0,4500) }");
|
|
|
| Seek(0);
|
| @@ -4053,10 +4023,11 @@ TEST_F(SourceBufferStreamTest, Text_Append_DisjointBefore) {
|
|
|
| TEST_F(SourceBufferStreamTest, Text_CompleteOverlap) {
|
| SetTextStream();
|
| - NewSegmentAppend("3000K 3500K 4000K");
|
| + NewCodedFrameGroupAppend("3000K 3500K 4000K");
|
| CheckExpectedRangesByTimestamp("{ [3000,4500) }");
|
| - NewSegmentAppend("0K 501K 1001K 1501K 2001K 2501K "
|
| - "3001K 3501K 4001K 4501K 5001K");
|
| + NewCodedFrameGroupAppend(
|
| + "0K 501K 1001K 1501K 2001K 2501K "
|
| + "3001K 3501K 4001K 4501K 5001K");
|
| CheckExpectedRangesByTimestamp("{ [0,5501) }");
|
|
|
| Seek(0);
|
| @@ -4066,9 +4037,9 @@ TEST_F(SourceBufferStreamTest, Text_CompleteOverlap) {
|
|
|
| TEST_F(SourceBufferStreamTest, Text_OverlapAfter) {
|
| SetTextStream();
|
| - NewSegmentAppend("0K 500K 1000K 1500K 2000K");
|
| + NewCodedFrameGroupAppend("0K 500K 1000K 1500K 2000K");
|
| CheckExpectedRangesByTimestamp("{ [0,2500) }");
|
| - NewSegmentAppend("1499K 2001K 2501K 3001K");
|
| + NewCodedFrameGroupAppend("1499K 2001K 2501K 3001K");
|
| CheckExpectedRangesByTimestamp("{ [0,3501) }");
|
|
|
| Seek(0);
|
| @@ -4077,9 +4048,9 @@ TEST_F(SourceBufferStreamTest, Text_OverlapAfter) {
|
|
|
| TEST_F(SourceBufferStreamTest, Text_OverlapBefore) {
|
| SetTextStream();
|
| - NewSegmentAppend("1500K 2000K 2500K 3000K 3500K");
|
| + NewCodedFrameGroupAppend("1500K 2000K 2500K 3000K 3500K");
|
| CheckExpectedRangesByTimestamp("{ [1500,4000) }");
|
| - NewSegmentAppend("0K 501K 1001K 1501K 2001K");
|
| + NewCodedFrameGroupAppend("0K 501K 1001K 1501K 2001K");
|
| CheckExpectedRangesByTimestamp("{ [0,4000) }");
|
|
|
| Seek(0);
|
| @@ -4088,14 +4059,14 @@ TEST_F(SourceBufferStreamTest, Text_OverlapBefore) {
|
|
|
| TEST_F(SourceBufferStreamTest, SpliceFrame_Basic) {
|
| Seek(0);
|
| - NewSegmentAppend("0K S(3K 6 9D3 10D5) 15 20 S(25K 30D5 35D5) 40");
|
| + NewCodedFrameGroupAppend("0K S(3K 6 9D3 10D5) 15 20 S(25K 30D5 35D5) 40");
|
| CheckExpectedBuffers("0K 3K 6 9 C 10 15 20 25K 30 C 35 40");
|
| CheckNoNextBuffer();
|
| }
|
|
|
| TEST_F(SourceBufferStreamTest, SpliceFrame_SeekClearsSplice) {
|
| Seek(0);
|
| - NewSegmentAppend("0K S(3K 6 9D3 10D5) 15K 20");
|
| + NewCodedFrameGroupAppend("0K S(3K 6 9D3 10D5) 15K 20");
|
| CheckExpectedBuffers("0K 3K 6");
|
|
|
| SeekToTimestampMs(15);
|
| @@ -4105,11 +4076,11 @@ TEST_F(SourceBufferStreamTest, SpliceFrame_SeekClearsSplice) {
|
|
|
| TEST_F(SourceBufferStreamTest, SpliceFrame_SeekClearsSpliceFromTrackBuffer) {
|
| Seek(0);
|
| - NewSegmentAppend("0K 2K S(3K 6 9D3 10D5) 15K 20");
|
| + NewCodedFrameGroupAppend("0K 2K S(3K 6 9D3 10D5) 15K 20");
|
| CheckExpectedBuffers("0K 2K");
|
|
|
| - // Overlap the existing segment.
|
| - NewSegmentAppend("5K 15K 20");
|
| + // Overlap the existing coded frame group.
|
| + NewCodedFrameGroupAppend("5K 15K 20");
|
| CheckExpectedBuffers("3K 6");
|
|
|
| SeekToTimestampMs(15);
|
| @@ -4127,7 +4098,7 @@ TEST_F(SourceBufferStreamTest, SpliceFrame_ConfigChangeWithinSplice) {
|
|
|
| Seek(0);
|
| CheckVideoConfig(video_config_);
|
| - NewSegmentAppend("0K S(3K 6C 9D3 10D5) 15");
|
| + NewCodedFrameGroupAppend("0K S(3K 6C 9D3 10D5) 15");
|
|
|
| CheckExpectedBuffers("0K 3K C");
|
| CheckVideoConfig(new_config);
|
| @@ -4140,11 +4111,11 @@ TEST_F(SourceBufferStreamTest, SpliceFrame_ConfigChangeWithinSplice) {
|
|
|
| TEST_F(SourceBufferStreamTest, SpliceFrame_BasicFromTrackBuffer) {
|
| Seek(0);
|
| - NewSegmentAppend("0K 5K S(8K 9D1 10D10) 20");
|
| + NewCodedFrameGroupAppend("0K 5K S(8K 9D1 10D10) 20");
|
| CheckExpectedBuffers("0K 5K");
|
|
|
| - // Overlap the existing segment.
|
| - NewSegmentAppend("5K 20");
|
| + // Overlap the existing coded frame group.
|
| + NewCodedFrameGroupAppend("5K 20");
|
| CheckExpectedBuffers("8K 9 C 10 20");
|
| CheckNoNextBuffer();
|
| }
|
| @@ -4160,11 +4131,11 @@ TEST_F(SourceBufferStreamTest,
|
|
|
| Seek(0);
|
| CheckVideoConfig(video_config_);
|
| - NewSegmentAppend("0K 5K S(7K 8C 9D1 10D10) 20");
|
| + NewCodedFrameGroupAppend("0K 5K S(7K 8C 9D1 10D10) 20");
|
| CheckExpectedBuffers("0K 5K");
|
|
|
| - // Overlap the existing segment.
|
| - NewSegmentAppend("5K 20");
|
| + // Overlap the existing coded frame group.
|
| + NewCodedFrameGroupAppend("5K 20");
|
| CheckExpectedBuffers("7K C");
|
| CheckVideoConfig(new_config);
|
| CheckExpectedBuffers("8 9 C");
|
| @@ -4179,8 +4150,8 @@ TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_Basic) {
|
|
|
| SetAudioStream();
|
| Seek(0);
|
| - NewSegmentAppend("0K 2K 4K 6K 8K 10K 12K");
|
| - NewSegmentAppend("11K 13K 15K 17K");
|
| + NewCodedFrameGroupAppend("0K 2K 4K 6K 8K 10K 12K");
|
| + NewCodedFrameGroupAppend("11K 13K 15K 17K");
|
| CheckExpectedBuffers("0K 2K 4K 6K 8K 10K 12K C 11K 13K 15K 17K");
|
| CheckNoNextBuffer();
|
| }
|
| @@ -4192,8 +4163,8 @@ TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoExactSplices) {
|
|
|
| SetAudioStream();
|
| Seek(0);
|
| - NewSegmentAppend("0K 2K 4K 6K 8K 10K 12K");
|
| - NewSegmentAppend("10K 14K");
|
| + NewCodedFrameGroupAppend("0K 2K 4K 6K 8K 10K 12K");
|
| + NewCodedFrameGroupAppend("10K 14K");
|
| CheckExpectedBuffers("0K 2K 4K 6K 8K 10K 14K");
|
| CheckNoNextBuffer();
|
| }
|
| @@ -4208,8 +4179,8 @@ TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoDoubleSplice) {
|
|
|
| SetAudioStream();
|
| Seek(0);
|
| - NewSegmentAppend("0K 2K 4K 6K 8K 10K 12K");
|
| - NewSegmentAppend("11K 13K 15K 17K");
|
| + NewCodedFrameGroupAppend("0K 2K 4K 6K 8K 10K 12K");
|
| + NewCodedFrameGroupAppend("11K 13K 15K 17K");
|
|
|
| // Verify the splice was created.
|
| CheckExpectedBuffers("0K 2K 4K 6K 8K 10K 12K C 11K 13K 15K 17K");
|
| @@ -4217,7 +4188,7 @@ TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoDoubleSplice) {
|
| Seek(0);
|
|
|
| // Create a splice before the first splice which would include it.
|
| - NewSegmentAppend("9D2K");
|
| + NewCodedFrameGroupAppend("9D2K");
|
|
|
| // A splice on top of a splice should result in a discard of the original
|
| // splice and no new splice frame being generated.
|
| @@ -4230,22 +4201,22 @@ TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoDoubleSplice) {
|
| TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoSplice) {
|
| SetAudioStream();
|
| Seek(0);
|
| - NewSegmentAppend("0K 2K 4K 6K 8K 10K");
|
| - NewSegmentAppend("12K 14K 16K 18K");
|
| + NewCodedFrameGroupAppend("0K 2K 4K 6K 8K 10K");
|
| + NewCodedFrameGroupAppend("12K 14K 16K 18K");
|
| CheckExpectedBuffers("0K 2K 4K 6K 8K 10K 12K 14K 16K 18K");
|
| CheckNoNextBuffer();
|
| }
|
|
|
| -TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_CorrectMediaSegmentStartTime) {
|
| +TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_CorrectGroupStartTime) {
|
| EXPECT_MEDIA_LOG(ContainsGeneratedSpliceLog(5000, 1000));
|
|
|
| SetAudioStream();
|
| Seek(0);
|
| - NewSegmentAppend("0K 2K 4K");
|
| + NewCodedFrameGroupAppend("0K 2K 4K");
|
| CheckExpectedRangesByTimestamp("{ [0,6) }");
|
| - NewSegmentAppend("6K 8K 10K");
|
| + NewCodedFrameGroupAppend("6K 8K 10K");
|
| CheckExpectedRangesByTimestamp("{ [0,12) }");
|
| - NewSegmentAppend("1K 4D2K");
|
| + NewCodedFrameGroupAppend("1K 4D2K");
|
| CheckExpectedRangesByTimestamp("{ [0,12) }");
|
| CheckExpectedBuffers("0K 2K 4K C 1K 4K 6K 8K 10K");
|
| CheckNoNextBuffer();
|
| @@ -4263,9 +4234,9 @@ TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_ConfigChange) {
|
|
|
| Seek(0);
|
| CheckAudioConfig(audio_config_);
|
| - NewSegmentAppend("0K 2K 4K 6K");
|
| + NewCodedFrameGroupAppend("0K 2K 4K 6K");
|
| stream_->UpdateAudioConfig(new_config);
|
| - NewSegmentAppend("5K 8K 12K");
|
| + NewCodedFrameGroupAppend("5K 8K 12K");
|
| CheckExpectedBuffers("0K 2K 4K 6K C 5K 8K 12K");
|
| CheckAudioConfig(new_config);
|
| CheckNoNextBuffer();
|
| @@ -4284,9 +4255,9 @@ TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoTinySplices) {
|
| // 2ms this results in an overlap of 1ms between the ranges. A splice frame
|
| // should not be generated since it requires at least 2 frames, or 2ms in this
|
| // case, of data to crossfade.
|
| - NewSegmentAppend("0D2K");
|
| + NewCodedFrameGroupAppend("0D2K");
|
| CheckExpectedRangesByTimestamp("{ [0,2) }");
|
| - NewSegmentAppend("1D2K");
|
| + NewCodedFrameGroupAppend("1D2K");
|
| CheckExpectedRangesByTimestamp("{ [0,3) }");
|
| CheckExpectedBuffers("0K 1K");
|
| CheckNoNextBuffer();
|
| @@ -4307,19 +4278,19 @@ TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoMillisecondSplices) {
|
| Seek(0);
|
|
|
| // Append four buffers with a 0.5ms duration each.
|
| - NewSegmentAppend(0, 4);
|
| + NewCodedFrameGroupAppend(0, 4);
|
| CheckExpectedRangesByTimestamp("{ [0,2) }");
|
|
|
| // Overlap the range [0, 2) with [1.25, 2); this results in an overlap of
|
| // 0.75ms between the ranges.
|
| - NewSegmentAppend_OffsetFirstBuffer(2, 2,
|
| - base::TimeDelta::FromMillisecondsD(0.25));
|
| + NewCodedFrameGroupAppend_OffsetFirstBuffer(
|
| + 2, 2, base::TimeDelta::FromMillisecondsD(0.25));
|
| CheckExpectedRangesByTimestamp("{ [0,2) }");
|
|
|
| // A splice frame should not be generated (indicated by the lack of a config
|
| // change in the expected buffer string) since it requires at least 1ms of
|
| // data to crossfade.
|
| - CheckExpectedBuffers("0K 0K 1K 1K 1K");
|
| + CheckExpectedBuffers("0K 0K 1K 1K");
|
| CheckNoNextBuffer();
|
| }
|
|
|
| @@ -4328,22 +4299,22 @@ TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_Preroll) {
|
|
|
| SetAudioStream();
|
| Seek(0);
|
| - NewSegmentAppend("0K 2K 4K 6K 8K 10K 12K");
|
| - NewSegmentAppend("11P 13K 15K 17K");
|
| + NewCodedFrameGroupAppend("0K 2K 4K 6K 8K 10K 12K");
|
| + NewCodedFrameGroupAppend("11P 13K 15K 17K");
|
| CheckExpectedBuffers("0K 2K 4K 6K 8K 10K 12K C 11P 13K 15K 17K");
|
| CheckNoNextBuffer();
|
| }
|
|
|
| TEST_F(SourceBufferStreamTest, Audio_PrerollFrame) {
|
| Seek(0);
|
| - NewSegmentAppend("0K 3P 6K");
|
| + NewCodedFrameGroupAppend("0K 3P 6K");
|
| CheckExpectedBuffers("0K 3P 6K");
|
| CheckNoNextBuffer();
|
| }
|
|
|
| TEST_F(SourceBufferStreamTest, BFrames) {
|
| Seek(0);
|
| - NewSegmentAppend("0K 120|30 30|60 60|90 90|120");
|
| + NewCodedFrameGroupAppend("0K 120|30 30|60 60|90 90|120");
|
| CheckExpectedRangesByTimestamp("{ [0,150) }");
|
|
|
| CheckExpectedBuffers("0K 120|30 30|60 60|90 90|120");
|
| @@ -4351,11 +4322,12 @@ TEST_F(SourceBufferStreamTest, BFrames) {
|
| }
|
|
|
| TEST_F(SourceBufferStreamTest, RemoveShouldAlwaysExcludeEnd) {
|
| - NewSegmentAppend("10D2K 12D2 14D2");
|
| + NewCodedFrameGroupAppend("10D2K 12D2 14D2");
|
| CheckExpectedRangesByTimestamp("{ [10,16) }");
|
|
|
| - // Start new segment, appending KF to abut the start of previous segment.
|
| - NewSegmentAppend("0D10K");
|
| + // Start new coded frame group, appending KF to abut the start of previous
|
| + // group.
|
| + NewCodedFrameGroupAppend("0D10K");
|
| Seek(0);
|
| CheckExpectedRangesByTimestamp("{ [0,16) }");
|
| CheckExpectedBuffers("0K 10K 12 14");
|
| @@ -4377,7 +4349,7 @@ TEST_F(SourceBufferStreamTest, RemoveShouldAlwaysExcludeEnd) {
|
|
|
| TEST_F(SourceBufferStreamTest, RefinedDurationEstimates_BackOverlap) {
|
| // Append a few buffers, the last one having estimated duration.
|
| - NewSegmentAppend("0K 5 10 20D10E");
|
| + NewCodedFrameGroupAppend("0K 5 10 20D10E");
|
| CheckExpectedRangesByTimestamp("{ [0,30) }");
|
| Seek(0);
|
| CheckExpectedBuffers("0K 5 10 20D10E");
|
| @@ -4403,7 +4375,7 @@ TEST_F(SourceBufferStreamTest, RefinedDurationEstimates_BackOverlap) {
|
|
|
| TEST_F(SourceBufferStreamTest, RefinedDurationEstimates_FrontOverlap) {
|
| // Append a few buffers.
|
| - NewSegmentAppend("10K 15 20D5");
|
| + NewCodedFrameGroupAppend("10K 15 20D5");
|
| CheckExpectedRangesByTimestamp("{ [10,25) }");
|
| SeekToTimestampMs(10);
|
| CheckExpectedBuffers("10K 15 20");
|
| @@ -4412,7 +4384,7 @@ TEST_F(SourceBufferStreamTest, RefinedDurationEstimates_FrontOverlap) {
|
| // Append new buffers, where the last has estimated duration that overlaps the
|
| // *front* of the existing range. The overlap should trigger refinement of the
|
| // estimated duration from 7ms to 5ms.
|
| - NewSegmentAppend("0K 5D7E");
|
| + NewCodedFrameGroupAppend("0K 5D7E");
|
| CheckExpectedRangesByTimestamp("{ [0,25) }");
|
| Seek(0);
|
| CheckExpectedBuffers("0K 5D5E 10K 15 20");
|
| @@ -4428,7 +4400,7 @@ TEST_F(SourceBufferStreamTest, RefinedDurationEstimates_FrontOverlap) {
|
| }
|
|
|
| TEST_F(SourceBufferStreamTest, SeekToStartSatisfiedUpToThreshold) {
|
| - NewSegmentAppend("999K 1010 1020D10");
|
| + NewCodedFrameGroupAppend("999K 1010 1020D10");
|
| CheckExpectedRangesByTimestamp("{ [999,1030) }");
|
|
|
| SeekToTimestampMs(0);
|
| @@ -4437,7 +4409,7 @@ TEST_F(SourceBufferStreamTest, SeekToStartSatisfiedUpToThreshold) {
|
| }
|
|
|
| TEST_F(SourceBufferStreamTest, SeekToStartUnsatisfiedBeyondThreshold) {
|
| - NewSegmentAppend("1000K 1010 1020D10");
|
| + NewCodedFrameGroupAppend("1000K 1010 1020D10");
|
| CheckExpectedRangesByTimestamp("{ [1000,1030) }");
|
|
|
| SeekToTimestampMs(0);
|
| @@ -4447,7 +4419,7 @@ TEST_F(SourceBufferStreamTest, SeekToStartUnsatisfiedBeyondThreshold) {
|
| TEST_F(SourceBufferStreamTest,
|
| ReSeekToStartSatisfiedUpToThreshold_SameTimestamps) {
|
| // Append a few buffers.
|
| - NewSegmentAppend("999K 1010 1020D10");
|
| + NewCodedFrameGroupAppend("999K 1010 1020D10");
|
| CheckExpectedRangesByTimestamp("{ [999,1030) }");
|
|
|
| // Don't read any buffers between Seek and Remove.
|
| @@ -4457,7 +4429,7 @@ TEST_F(SourceBufferStreamTest,
|
| CheckNoNextBuffer();
|
|
|
| // Append buffers at the original timestamps and verify no stall.
|
| - NewSegmentAppend("999K 1010 1020D10");
|
| + NewCodedFrameGroupAppend("999K 1010 1020D10");
|
| CheckExpectedRangesByTimestamp("{ [999,1030) }");
|
| CheckExpectedBuffers("999K 1010 1020D10");
|
| CheckNoNextBuffer();
|
| @@ -4466,7 +4438,7 @@ TEST_F(SourceBufferStreamTest,
|
| TEST_F(SourceBufferStreamTest,
|
| ReSeekToStartSatisfiedUpToThreshold_EarlierTimestamps) {
|
| // Append a few buffers.
|
| - NewSegmentAppend("999K 1010 1020D10");
|
| + NewCodedFrameGroupAppend("999K 1010 1020D10");
|
| CheckExpectedRangesByTimestamp("{ [999,1030) }");
|
|
|
| // Don't read any buffers between Seek and Remove.
|
| @@ -4477,7 +4449,7 @@ TEST_F(SourceBufferStreamTest,
|
|
|
| // Append buffers before the original timestamps and verify no stall (the
|
| // re-seek to time 0 should still be satisfied with the new buffers).
|
| - NewSegmentAppend("500K 510 520D10");
|
| + NewCodedFrameGroupAppend("500K 510 520D10");
|
| CheckExpectedRangesByTimestamp("{ [500,530) }");
|
| CheckExpectedBuffers("500K 510 520D10");
|
| CheckNoNextBuffer();
|
| @@ -4486,7 +4458,7 @@ TEST_F(SourceBufferStreamTest,
|
| TEST_F(SourceBufferStreamTest,
|
| ReSeekToStartSatisfiedUpToThreshold_LaterTimestamps) {
|
| // Append a few buffers.
|
| - NewSegmentAppend("500K 510 520D10");
|
| + NewCodedFrameGroupAppend("500K 510 520D10");
|
| CheckExpectedRangesByTimestamp("{ [500,530) }");
|
|
|
| // Don't read any buffers between Seek and Remove.
|
| @@ -4498,7 +4470,7 @@ TEST_F(SourceBufferStreamTest,
|
| // Append buffers beginning after original timestamps, but still below the
|
| // start threshold, and verify no stall (the re-seek to time 0 should still be
|
| // satisfied with the new buffers).
|
| - NewSegmentAppend("999K 1010 1020D10");
|
| + NewCodedFrameGroupAppend("999K 1010 1020D10");
|
| CheckExpectedRangesByTimestamp("{ [999,1030) }");
|
| CheckExpectedBuffers("999K 1010 1020D10");
|
| CheckNoNextBuffer();
|
| @@ -4506,7 +4478,7 @@ TEST_F(SourceBufferStreamTest,
|
|
|
| TEST_F(SourceBufferStreamTest, ReSeekBeyondStartThreshold_SameTimestamps) {
|
| // Append a few buffers.
|
| - NewSegmentAppend("1000K 1010 1020D10");
|
| + NewCodedFrameGroupAppend("1000K 1010 1020D10");
|
| CheckExpectedRangesByTimestamp("{ [1000,1030) }");
|
|
|
| // Don't read any buffers between Seek and Remove.
|
| @@ -4516,7 +4488,7 @@ TEST_F(SourceBufferStreamTest, ReSeekBeyondStartThreshold_SameTimestamps) {
|
| CheckNoNextBuffer();
|
|
|
| // Append buffers at the original timestamps and verify no stall.
|
| - NewSegmentAppend("1000K 1010 1020D10");
|
| + NewCodedFrameGroupAppend("1000K 1010 1020D10");
|
| CheckExpectedRangesByTimestamp("{ [1000,1030) }");
|
| CheckExpectedBuffers("1000K 1010 1020D10");
|
| CheckNoNextBuffer();
|
| @@ -4524,7 +4496,7 @@ TEST_F(SourceBufferStreamTest, ReSeekBeyondStartThreshold_SameTimestamps) {
|
|
|
| TEST_F(SourceBufferStreamTest, ReSeekBeyondThreshold_EarlierTimestamps) {
|
| // Append a few buffers.
|
| - NewSegmentAppend("2000K 2010 2020D10");
|
| + NewCodedFrameGroupAppend("2000K 2010 2020D10");
|
| CheckExpectedRangesByTimestamp("{ [2000,2030) }");
|
|
|
| // Don't read any buffers between Seek and Remove.
|
| @@ -4536,7 +4508,7 @@ TEST_F(SourceBufferStreamTest, ReSeekBeyondThreshold_EarlierTimestamps) {
|
| // Append buffers before the original timestamps and verify no stall (the
|
| // re-seek to time 2 seconds should still be satisfied with the new buffers
|
| // and should emit preroll from last keyframe).
|
| - NewSegmentAppend("1080K 1090 2000D10");
|
| + NewCodedFrameGroupAppend("1080K 1090 2000D10");
|
| CheckExpectedRangesByTimestamp("{ [1080,2010) }");
|
| CheckExpectedBuffers("1080K 1090 2000D10");
|
| CheckNoNextBuffer();
|
| @@ -4545,9 +4517,9 @@ TEST_F(SourceBufferStreamTest, ReSeekBeyondThreshold_EarlierTimestamps) {
|
| TEST_F(SourceBufferStreamTest, ConfigChange_ReSeek) {
|
| // Append a few buffers, with a config change in the middle.
|
| VideoDecoderConfig new_config = TestVideoConfig::Large();
|
| - NewSegmentAppend("2000K 2010 2020D10");
|
| + NewCodedFrameGroupAppend("2000K 2010 2020D10");
|
| stream_->UpdateVideoConfig(new_config);
|
| - NewSegmentAppend("2030K 2040 2050D10");
|
| + NewCodedFrameGroupAppend("2030K 2040 2050D10");
|
| CheckExpectedRangesByTimestamp("{ [2000,2060) }");
|
|
|
| // Read the config change, but don't read any non-config-change buffer between
|
| @@ -4566,7 +4538,7 @@ TEST_F(SourceBufferStreamTest, ConfigChange_ReSeek) {
|
|
|
| // Append buffers at the original timestamps and verify no stall or redundant
|
| // signalling of config change.
|
| - NewSegmentAppend("2030K 2040 2050D10");
|
| + NewCodedFrameGroupAppend("2030K 2040 2050D10");
|
| CheckVideoConfig(new_config);
|
| CheckExpectedRangesByTimestamp("{ [2000,2060) }");
|
| CheckExpectedBuffers("2030K 2040 2050D10");
|
| @@ -4589,7 +4561,7 @@ TEST_F(SourceBufferStreamTest, ConfigChange_ReSeek) {
|
| }
|
|
|
| TEST_F(SourceBufferStreamTest, TrackBuffer_ExhaustionWithSkipForward) {
|
| - NewSegmentAppend("0K 10 20 30 40");
|
| + NewCodedFrameGroupAppend("0K 10 20 30 40");
|
|
|
| // Read the first 4 buffers, so next buffer is at time 40.
|
| Seek(0);
|
| @@ -4599,7 +4571,7 @@ TEST_F(SourceBufferStreamTest, TrackBuffer_ExhaustionWithSkipForward) {
|
| // Overlap-append, populating track buffer with timestamp 40 from original
|
| // append. Confirm there could be a large jump in time until the next key
|
| // frame after exhausting the track buffer.
|
| - NewSegmentAppend(
|
| + NewCodedFrameGroupAppend(
|
| "31K 41 51 61 71 81 91 101 111 121 "
|
| "131K 141");
|
| CheckExpectedRangesByTimestamp("{ [0,151) }");
|
| @@ -4615,7 +4587,7 @@ TEST_F(SourceBufferStreamTest, TrackBuffer_ExhaustionWithSkipForward) {
|
|
|
| TEST_F(SourceBufferStreamTest,
|
| TrackBuffer_ExhaustionAndImmediateNewTrackBuffer) {
|
| - NewSegmentAppend("0K 10 20 30 40");
|
| + NewCodedFrameGroupAppend("0K 10 20 30 40");
|
|
|
| // Read the first 4 buffers, so next buffer is at time 40.
|
| Seek(0);
|
| @@ -4623,7 +4595,7 @@ TEST_F(SourceBufferStreamTest,
|
| CheckExpectedBuffers("0K 10 20 30");
|
|
|
| // Overlap-append
|
| - NewSegmentAppend(
|
| + NewCodedFrameGroupAppend(
|
| "31K 41 51 61 71 81 91 101 111 121 "
|
| "131K 141");
|
| CheckExpectedRangesByTimestamp("{ [0,151) }");
|
| @@ -4635,7 +4607,8 @@ TEST_F(SourceBufferStreamTest,
|
| // append. (See TrackBuffer_ExhaustionWithSkipForward for that verification.)
|
| // Do another overlap-append to immediately create another track buffer and
|
| // verify both track buffer exhaustions skip forward and emit log warnings.
|
| - NewSegmentAppend("22K 32 42 52 62 72 82 92 102 112 122K 132 142 152K 162");
|
| + NewCodedFrameGroupAppend(
|
| + "22K 32 42 52 62 72 82 92 102 112 122K 132 142 152K 162");
|
| CheckExpectedRangesByTimestamp("{ [0,172) }");
|
|
|
| InSequence s;
|
| @@ -4646,6 +4619,150 @@ TEST_F(SourceBufferStreamTest,
|
| CheckNoNextBuffer();
|
| }
|
|
|
| +TEST_F(
|
| + SourceBufferStreamTest,
|
| + AdjacentCodedFrameGroupContinuation_NoGapCreatedByTinyGapInGroupContinuation) {
|
| + NewCodedFrameGroupAppend("0K 10 20K 30 40K 50D10");
|
| + CheckExpectedRangesByTimestamp("{ [0,60) }");
|
| +
|
| + // Continue appending to the previously started coded frame group, albeit with
|
| + // a tiny (1ms) gap. This gap should *NOT* produce a buffered range gap.
|
| + AppendBuffers("61K 71D10");
|
| + CheckExpectedRangesByTimestamp("{ [0,81) }");
|
| +}
|
| +
|
| +TEST_F(SourceBufferStreamTest,
|
| + AdjacentCodedFrameGroupContinuation_NoGapCreatedPrefixRemoved) {
|
| + NewCodedFrameGroupAppend("0K 10 20K 30 40K 50D10");
|
| + CheckExpectedRangesByTimestamp("{ [0,60) }");
|
| +
|
| + RemoveInMs(0, 35, 60);
|
| + CheckExpectedRangesByTimestamp("{ [40,60) }");
|
| +
|
| + // Continue appending to the previously started coded frame group, albeit with
|
| + // a tiny (1ms) gap. This gap should *NOT* produce a buffered range gap.
|
| + AppendBuffers("61K 71D10");
|
| + CheckExpectedRangesByTimestamp("{ [40,81) }");
|
| +}
|
| +
|
| +TEST_F(SourceBufferStreamTest,
|
| + AdjacentNewCodedFrameGroupContinuation_NoGapCreatedPrefixRemoved) {
|
| + NewCodedFrameGroupAppend("0K 10 20K 30 40K 50D10");
|
| + CheckExpectedRangesByTimestamp("{ [0,60) }");
|
| +
|
| + RemoveInMs(0, 35, 60);
|
| + CheckExpectedRangesByTimestamp("{ [40,60) }");
|
| +
|
| + // Continue appending, with a new coded frame group, albeit with
|
| + // a tiny (1ms) gap. This gap should *NOT* produce a buffered range gap.
|
| + // This test demonstrates the "pre-relaxation" behavior, where a new "media
|
| + // segment" (now a new "coded frame group") was signaled at every media
|
| + // segment boundary.
|
| + NewCodedFrameGroupAppend("61K 71D10");
|
| + CheckExpectedRangesByTimestamp("{ [40,81) }");
|
| +}
|
| +
|
| +TEST_F(SourceBufferStreamTest,
|
| + StartCodedFrameGroup_RemoveThenAppendMoreMuchLater) {
|
| + NewCodedFrameGroupAppend("1000K 1010 1020 1030K 1040 1050 1060K 1070 1080");
|
| + NewCodedFrameGroupAppend("0K 10 20");
|
| + CheckExpectedRangesByTimestamp("{ [0,30) [1000,1090) }");
|
| +
|
| + SignalStartOfCodedFrameGroup(base::TimeDelta::FromMilliseconds(1070));
|
| + CheckExpectedRangesByTimestamp("{ [0,30) [1000,1090) }");
|
| +
|
| + RemoveInMs(1030, 1050, 1090);
|
| + CheckExpectedRangesByTimestamp("{ [0,30) [1000,1030) [1060,1090) }");
|
| +
|
| + // We've signalled that we're about to do some appends to a coded frame group
|
| + // which starts at time 1070ms. Note that the first frame, if any ever,
|
| + // appended to this SourceBufferStream for that coded frame group must have a
|
| + // decode timestamp >= 1070ms (it can be significantly in the future).
|
| + // Regardless, that appended frame must be buffered into the same existing
|
| + // range as current [1060,1090), since the new coded frame group's start of
|
| + // 1070ms is within that range.
|
| + AppendBuffers("2000K 2010");
|
| + CheckExpectedRangesByTimestamp("{ [0,30) [1000,1030) [1060,2020) }");
|
| + SeekToTimestampMs(1060);
|
| + CheckExpectedBuffers("1060K 2000K 2010");
|
| + CheckNoNextBuffer();
|
| +}
|
| +
|
| +TEST_F(SourceBufferStreamTest,
|
| + StartCodedFrameGroup_InExisting_AppendMuchLater) {
|
| + NewCodedFrameGroupAppend("0K 10 20 30K 40 50");
|
| + SignalStartOfCodedFrameGroup(base::TimeDelta::FromMilliseconds(45));
|
| + CheckExpectedRangesByTimestamp("{ [0,60) }");
|
| +
|
| + AppendBuffers("2000K 2010");
|
| + CheckExpectedRangesByTimestamp("{ [0,2020) }");
|
| + Seek(0);
|
| + CheckExpectedBuffers("0K 10 20 30K 40 2000K 2010");
|
| + CheckNoNextBuffer();
|
| +}
|
| +
|
| +TEST_F(SourceBufferStreamTest,
|
| + StartCodedFrameGroup_InExisting_RemoveGOP_ThenAppend_1) {
|
| + NewCodedFrameGroupAppend("0K 10 20 30K 40 50");
|
| + SignalStartOfCodedFrameGroup(base::TimeDelta::FromMilliseconds(30));
|
| + RemoveInMs(30, 60, 60);
|
| + CheckExpectedRangesByTimestamp("{ [0,30) }");
|
| +
|
| + AppendBuffers("2000K 2010");
|
| + CheckExpectedRangesByTimestamp("{ [0,2020) }");
|
| + Seek(0);
|
| + CheckExpectedBuffers("0K 10 20 2000K 2010");
|
| + CheckNoNextBuffer();
|
| +}
|
| +
|
| +TEST_F(SourceBufferStreamTest,
|
| + StartCodedFrameGroup_InExisting_RemoveGOP_ThenAppend_2) {
|
| + NewCodedFrameGroupAppend("0K 10 20 30K 40 50");
|
| + SignalStartOfCodedFrameGroup(base::TimeDelta::FromMilliseconds(45));
|
| + RemoveInMs(30, 60, 60);
|
| + CheckExpectedRangesByTimestamp("{ [0,30) }");
|
| +
|
| + AppendBuffers("2000K 2010");
|
| + CheckExpectedRangesByTimestamp("{ [0,30) [45,2020) }");
|
| + Seek(0);
|
| + CheckExpectedBuffers("0K 10 20");
|
| + CheckNoNextBuffer();
|
| + SeekToTimestampMs(45);
|
| + CheckExpectedBuffers("2000K 2010");
|
| + CheckNoNextBuffer();
|
| + SeekToTimestampMs(1000);
|
| + CheckExpectedBuffers("2000K 2010");
|
| + CheckNoNextBuffer();
|
| +}
|
| +
|
| +TEST_F(SourceBufferStreamTest,
|
| + StartCodedFrameGroup_InExisting_RemoveMostRecentAppend_ThenAppend_1) {
|
| + NewCodedFrameGroupAppend("0K 10 20 30K 40 50");
|
| + SignalStartOfCodedFrameGroup(base::TimeDelta::FromMilliseconds(45));
|
| + RemoveInMs(50, 60, 60);
|
| + CheckExpectedRangesByTimestamp("{ [0,50) }");
|
| +
|
| + AppendBuffers("2000K 2010");
|
| + CheckExpectedRangesByTimestamp("{ [0,2020) }");
|
| + Seek(0);
|
| + CheckExpectedBuffers("0K 10 20 30K 40 2000K 2010");
|
| + CheckNoNextBuffer();
|
| +}
|
| +
|
| +TEST_F(SourceBufferStreamTest,
|
| + StartCodedFrameGroup_InExisting_RemoveMostRecentAppend_ThenAppend_2) {
|
| + NewCodedFrameGroupAppend("0K 10 20 30K 40 50");
|
| + SignalStartOfCodedFrameGroup(base::TimeDelta::FromMilliseconds(50));
|
| + RemoveInMs(50, 60, 60);
|
| + CheckExpectedRangesByTimestamp("{ [0,50) }");
|
| +
|
| + AppendBuffers("2000K 2010");
|
| + CheckExpectedRangesByTimestamp("{ [0,2020) }");
|
| + Seek(0);
|
| + CheckExpectedBuffers("0K 10 20 30K 40 2000K 2010");
|
| + CheckNoNextBuffer();
|
| +}
|
| +
|
| // TODO(vrk): Add unit tests where keyframes are unaligned between streams.
|
| // (crbug.com/133557)
|
|
|
|
|
Chromium Code Reviews
Issue 1670033002:
Reland: MSE: Relax the 'media segment must begin with keyframe' requirement (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master