OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "media/filters/source_buffer_stream.h" | 5 #include "media/filters/source_buffer_stream.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <stdint.h> | 8 #include <stdint.h> |
9 #include <string> | 9 #include <string> |
10 #include <vector> | 10 #include <vector> |
(...skipping 23 matching lines...) Expand all Loading... | |
34 | 34 |
35 typedef StreamParser::BufferQueue BufferQueue; | 35 typedef StreamParser::BufferQueue BufferQueue; |
36 | 36 |
37 static const int kDefaultFramesPerSecond = 30; | 37 static const int kDefaultFramesPerSecond = 30; |
38 static const int kDefaultKeyframesPerSecond = 6; | 38 static const int kDefaultKeyframesPerSecond = 6; |
39 static const uint8_t kDataA = 0x11; | 39 static const uint8_t kDataA = 0x11; |
40 static const uint8_t kDataB = 0x33; | 40 static const uint8_t kDataB = 0x33; |
41 static const int kDataSize = 1; | 41 static const int kDataSize = 1; |
42 | 42 |
43 // Matchers for verifying common media log entry strings. | 43 // Matchers for verifying common media log entry strings. |
44 MATCHER(ContainsMissingKeyframeLog, "") { | |
45 return CONTAINS_STRING(arg, | |
46 "Media segment did not begin with key frame. Support " | |
47 "for such segments will be available in a future " | |
48 "version. Please see https://crbug.com/229412."); | |
49 } | |
50 | |
51 MATCHER(ContainsSameTimestampAt30MillisecondsLog, "") { | 44 MATCHER(ContainsSameTimestampAt30MillisecondsLog, "") { |
52 return CONTAINS_STRING(arg, | 45 return CONTAINS_STRING(arg, |
53 "Unexpected combination of buffers with the same " | 46 "Detected an append sequence with keyframe following " |
54 "timestamp detected at 0.03"); | 47 "a non-keyframe, both with the same decode timestamp " |
48 "of 0.03"); | |
55 } | 49 } |
56 | 50 |
57 MATCHER_P(ContainsTrackBufferExhaustionSkipLog, skip_milliseconds, "") { | 51 MATCHER_P(ContainsTrackBufferExhaustionSkipLog, skip_milliseconds, "") { |
58 return CONTAINS_STRING(arg, | 52 return CONTAINS_STRING(arg, |
59 "Media append that overlapped current playback " | 53 "Media append that overlapped current playback " |
60 "position caused time gap in playing VIDEO stream " | 54 "position caused time gap in playing VIDEO stream " |
61 "because the next keyframe is " + | 55 "because the next keyframe is " + |
62 base::IntToString(skip_milliseconds) + | 56 base::IntToString(skip_milliseconds) + |
63 "ms beyond last overlapped frame. Media may " | 57 "ms beyond last overlapped frame. Media may " |
64 "appear temporarily frozen."); | 58 "appear temporarily frozen."); |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
108 EmptyExtraData(), | 102 EmptyExtraData(), |
109 false, | 103 false, |
110 base::TimeDelta(), | 104 base::TimeDelta(), |
111 0); | 105 0); |
112 stream_.reset(new SourceBufferStream(audio_config_, media_log_, true)); | 106 stream_.reset(new SourceBufferStream(audio_config_, media_log_, true)); |
113 | 107 |
114 // Equivalent to 2ms per frame. | 108 // Equivalent to 2ms per frame. |
115 SetStreamInfo(500, 500); | 109 SetStreamInfo(500, 500); |
116 } | 110 } |
117 | 111 |
118 void NewSegmentAppend(int starting_position, int number_of_buffers) { | 112 void NewCodedFrameGroupAppend(int starting_position, int number_of_buffers) { |
119 AppendBuffers(starting_position, number_of_buffers, true, | 113 AppendBuffers(starting_position, number_of_buffers, true, |
120 base::TimeDelta(), true, &kDataA, kDataSize); | 114 base::TimeDelta(), true, &kDataA, kDataSize); |
121 } | 115 } |
122 | 116 |
123 void NewSegmentAppend(int starting_position, | 117 void NewCodedFrameGroupAppend(int starting_position, |
124 int number_of_buffers, | 118 int number_of_buffers, |
125 const uint8_t* data) { | 119 const uint8_t* data) { |
126 AppendBuffers(starting_position, number_of_buffers, true, | 120 AppendBuffers(starting_position, number_of_buffers, true, |
127 base::TimeDelta(), true, data, kDataSize); | 121 base::TimeDelta(), true, data, kDataSize); |
128 } | 122 } |
129 | 123 |
130 void NewSegmentAppend_OffsetFirstBuffer( | 124 void NewCodedFrameGroupAppend_OffsetFirstBuffer( |
131 int starting_position, int number_of_buffers, | 125 int starting_position, |
126 int number_of_buffers, | |
132 base::TimeDelta first_buffer_offset) { | 127 base::TimeDelta first_buffer_offset) { |
133 AppendBuffers(starting_position, number_of_buffers, true, | 128 AppendBuffers(starting_position, number_of_buffers, true, |
134 first_buffer_offset, true, &kDataA, kDataSize); | 129 first_buffer_offset, true, &kDataA, kDataSize); |
135 } | 130 } |
136 | 131 |
137 void NewSegmentAppend_ExpectFailure( | 132 void NewCodedFrameGroupAppend_ExpectFailure(int starting_position, |
138 int starting_position, int number_of_buffers) { | 133 int number_of_buffers) { |
139 AppendBuffers(starting_position, number_of_buffers, true, | 134 AppendBuffers(starting_position, number_of_buffers, true, |
140 base::TimeDelta(), false, &kDataA, kDataSize); | 135 base::TimeDelta(), false, &kDataA, kDataSize); |
141 } | 136 } |
142 | 137 |
143 void AppendBuffers(int starting_position, int number_of_buffers) { | 138 void AppendBuffers(int starting_position, int number_of_buffers) { |
144 AppendBuffers(starting_position, number_of_buffers, false, | 139 AppendBuffers(starting_position, number_of_buffers, false, |
145 base::TimeDelta(), true, &kDataA, kDataSize); | 140 base::TimeDelta(), true, &kDataA, kDataSize); |
146 } | 141 } |
147 | 142 |
148 void AppendBuffers(int starting_position, | 143 void AppendBuffers(int starting_position, |
149 int number_of_buffers, | 144 int number_of_buffers, |
150 const uint8_t* data) { | 145 const uint8_t* data) { |
151 AppendBuffers(starting_position, number_of_buffers, false, | 146 AppendBuffers(starting_position, number_of_buffers, false, |
152 base::TimeDelta(), true, data, kDataSize); | 147 base::TimeDelta(), true, data, kDataSize); |
153 } | 148 } |
154 | 149 |
155 void NewSegmentAppend(const std::string& buffers_to_append) { | 150 void NewCodedFrameGroupAppend(const std::string& buffers_to_append) { |
156 AppendBuffers(buffers_to_append, true, kNoTimestamp(), false, true); | 151 AppendBuffers(buffers_to_append, true, kNoTimestamp(), false, true); |
157 } | 152 } |
158 | 153 |
159 void NewSegmentAppend(base::TimeDelta start_timestamp, | 154 void NewCodedFrameGroupAppend(base::TimeDelta start_timestamp, |
160 const std::string& buffers_to_append) { | 155 const std::string& buffers_to_append) { |
161 AppendBuffers(buffers_to_append, true, start_timestamp, false, true); | 156 AppendBuffers(buffers_to_append, true, start_timestamp, false, true); |
162 } | 157 } |
163 | 158 |
164 void AppendBuffers(const std::string& buffers_to_append) { | 159 void AppendBuffers(const std::string& buffers_to_append) { |
165 AppendBuffers(buffers_to_append, false, kNoTimestamp(), false, true); | 160 AppendBuffers(buffers_to_append, false, kNoTimestamp(), false, true); |
166 } | 161 } |
167 | 162 |
168 void NewSegmentAppendOneByOne(const std::string& buffers_to_append) { | 163 void NewCodedFrameGroupAppendOneByOne(const std::string& buffers_to_append) { |
169 AppendBuffers(buffers_to_append, true, kNoTimestamp(), true, true); | 164 AppendBuffers(buffers_to_append, true, kNoTimestamp(), true, true); |
170 } | 165 } |
171 | 166 |
172 void AppendBuffersOneByOne(const std::string& buffers_to_append) { | 167 void AppendBuffersOneByOne(const std::string& buffers_to_append) { |
173 AppendBuffers(buffers_to_append, false, kNoTimestamp(), true, true); | 168 AppendBuffers(buffers_to_append, false, kNoTimestamp(), true, true); |
174 } | 169 } |
175 | 170 |
176 void NewSegmentAppend_ExpectFailure(const std::string& buffers_to_append) { | 171 void NewCodedFrameGroupAppend_ExpectFailure( |
172 const std::string& buffers_to_append) { | |
177 AppendBuffers(buffers_to_append, true, kNoTimestamp(), false, false); | 173 AppendBuffers(buffers_to_append, true, kNoTimestamp(), false, false); |
178 } | 174 } |
179 | 175 |
180 void AppendBuffers_ExpectFailure(const std::string& buffers_to_append) { | 176 void AppendBuffers_ExpectFailure(const std::string& buffers_to_append) { |
181 AppendBuffers(buffers_to_append, false, kNoTimestamp(), false, false); | 177 AppendBuffers(buffers_to_append, false, kNoTimestamp(), false, false); |
182 } | 178 } |
183 | 179 |
184 void Seek(int position) { | 180 void Seek(int position) { |
185 stream_->Seek(position * frame_duration_); | 181 stream_->Seek(position * frame_duration_); |
186 } | 182 } |
(...skipping 245 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
432 scoped_refptr<StrictMock<MockMediaLog>> media_log_; | 428 scoped_refptr<StrictMock<MockMediaLog>> media_log_; |
433 | 429 |
434 private: | 430 private: |
435 base::TimeDelta ConvertToFrameDuration(int frames_per_second) { | 431 base::TimeDelta ConvertToFrameDuration(int frames_per_second) { |
436 return base::TimeDelta::FromMicroseconds( | 432 return base::TimeDelta::FromMicroseconds( |
437 base::Time::kMicrosecondsPerSecond / frames_per_second); | 433 base::Time::kMicrosecondsPerSecond / frames_per_second); |
438 } | 434 } |
439 | 435 |
440 void AppendBuffers(int starting_position, | 436 void AppendBuffers(int starting_position, |
441 int number_of_buffers, | 437 int number_of_buffers, |
442 bool begin_media_segment, | 438 bool begin_coded_frame_group, |
443 base::TimeDelta first_buffer_offset, | 439 base::TimeDelta first_buffer_offset, |
444 bool expect_success, | 440 bool expect_success, |
445 const uint8_t* data, | 441 const uint8_t* data, |
446 int size) { | 442 int size) { |
447 if (begin_media_segment) | 443 if (begin_coded_frame_group) |
448 stream_->OnNewMediaSegment(DecodeTimestamp::FromPresentationTime( | 444 stream_->OnStartOfCodedFrameGroup(DecodeTimestamp::FromPresentationTime( |
449 starting_position * frame_duration_)); | 445 starting_position * frame_duration_)); |
450 | 446 |
451 int keyframe_interval = frames_per_second_ / keyframes_per_second_; | 447 int keyframe_interval = frames_per_second_ / keyframes_per_second_; |
452 | 448 |
453 BufferQueue queue; | 449 BufferQueue queue; |
454 for (int i = 0; i < number_of_buffers; i++) { | 450 for (int i = 0; i < number_of_buffers; i++) { |
455 int position = starting_position + i; | 451 int position = starting_position + i; |
456 bool is_keyframe = position % keyframe_interval == 0; | 452 bool is_keyframe = position % keyframe_interval == 0; |
457 // Buffer type and track ID are meaningless to these tests. | 453 // Buffer type and track ID are meaningless to these tests. |
458 scoped_refptr<StreamParserBuffer> buffer = | 454 scoped_refptr<StreamParserBuffer> buffer = |
(...skipping 221 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
680 if (buffers.size() >= 2 && | 676 if (buffers.size() >= 2 && |
681 buffers.back()->duration() <= base::TimeDelta()) { | 677 buffers.back()->duration() <= base::TimeDelta()) { |
682 buffers.back()->set_duration( | 678 buffers.back()->set_duration( |
683 buffers[buffers.size() - 2]->duration()); | 679 buffers[buffers.size() - 2]->duration()); |
684 } | 680 } |
685 | 681 |
686 return buffers; | 682 return buffers; |
687 } | 683 } |
688 | 684 |
689 void AppendBuffers(const std::string& buffers_to_append, | 685 void AppendBuffers(const std::string& buffers_to_append, |
690 bool start_new_segment, | 686 bool start_new_coded_frame_group, |
691 base::TimeDelta segment_start_timestamp, | 687 base::TimeDelta coded_frame_group_start_timestamp, |
692 bool one_by_one, | 688 bool one_by_one, |
693 bool expect_success) { | 689 bool expect_success) { |
694 BufferQueue buffers = StringToBufferQueue(buffers_to_append); | 690 BufferQueue buffers = StringToBufferQueue(buffers_to_append); |
695 | 691 |
696 if (start_new_segment) { | 692 if (start_new_coded_frame_group) { |
697 base::TimeDelta start_timestamp = segment_start_timestamp; | 693 base::TimeDelta start_timestamp = coded_frame_group_start_timestamp; |
698 if (start_timestamp == kNoTimestamp()) | 694 if (start_timestamp == kNoTimestamp()) |
699 start_timestamp = buffers[0]->timestamp(); | 695 start_timestamp = buffers[0]->timestamp(); |
700 | 696 |
701 ASSERT_TRUE(start_timestamp <= buffers[0]->timestamp()); | 697 ASSERT_TRUE(start_timestamp <= buffers[0]->timestamp()); |
702 | 698 |
703 stream_->OnNewMediaSegment( | 699 stream_->OnStartOfCodedFrameGroup( |
704 DecodeTimestamp::FromPresentationTime(start_timestamp)); | 700 DecodeTimestamp::FromPresentationTime(start_timestamp)); |
705 } | 701 } |
706 | 702 |
707 if (!one_by_one) { | 703 if (!one_by_one) { |
708 EXPECT_EQ(expect_success, stream_->Append(buffers)); | 704 EXPECT_EQ(expect_success, stream_->Append(buffers)); |
709 return; | 705 return; |
710 } | 706 } |
711 | 707 |
712 // Append each buffer one by one. | 708 // Append each buffer one by one. |
713 for (size_t i = 0; i < buffers.size(); i++) { | 709 for (size_t i = 0; i < buffers.size(); i++) { |
714 BufferQueue wrapper; | 710 BufferQueue wrapper; |
715 wrapper.push_back(buffers[i]); | 711 wrapper.push_back(buffers[i]); |
716 EXPECT_TRUE(stream_->Append(wrapper)); | 712 EXPECT_TRUE(stream_->Append(wrapper)); |
717 } | 713 } |
718 } | 714 } |
719 | 715 |
720 int frames_per_second_; | 716 int frames_per_second_; |
721 int keyframes_per_second_; | 717 int keyframes_per_second_; |
722 base::TimeDelta frame_duration_; | 718 base::TimeDelta frame_duration_; |
723 DISALLOW_COPY_AND_ASSIGN(SourceBufferStreamTest); | 719 DISALLOW_COPY_AND_ASSIGN(SourceBufferStreamTest); |
724 }; | 720 }; |
725 | 721 |
726 TEST_F(SourceBufferStreamTest, Append_SingleRange) { | 722 TEST_F(SourceBufferStreamTest, Append_SingleRange) { |
727 // Append 15 buffers at positions 0 through 14. | 723 // Append 15 buffers at positions 0 through 14. |
728 NewSegmentAppend(0, 15); | 724 NewCodedFrameGroupAppend(0, 15); |
729 | 725 |
730 // Check expected range. | 726 // Check expected range. |
731 CheckExpectedRanges("{ [0,14) }"); | 727 CheckExpectedRanges("{ [0,14) }"); |
732 // Check buffers in range. | 728 // Check buffers in range. |
733 Seek(0); | 729 Seek(0); |
734 CheckExpectedBuffers(0, 14); | 730 CheckExpectedBuffers(0, 14); |
735 } | 731 } |
736 | 732 |
737 TEST_F(SourceBufferStreamTest, Append_SingleRange_OneBufferAtATime) { | 733 TEST_F(SourceBufferStreamTest, Append_SingleRange_OneBufferAtATime) { |
738 // Append 15 buffers starting at position 0, one buffer at a time. | 734 // Append 15 buffers starting at position 0, one buffer at a time. |
739 NewSegmentAppend(0, 1); | 735 NewCodedFrameGroupAppend(0, 1); |
740 for (int i = 1; i < 15; i++) | 736 for (int i = 1; i < 15; i++) |
741 AppendBuffers(i, 1); | 737 AppendBuffers(i, 1); |
742 | 738 |
743 // Check expected range. | 739 // Check expected range. |
744 CheckExpectedRanges("{ [0,14) }"); | 740 CheckExpectedRanges("{ [0,14) }"); |
745 // Check buffers in range. | 741 // Check buffers in range. |
746 Seek(0); | 742 Seek(0); |
747 CheckExpectedBuffers(0, 14); | 743 CheckExpectedBuffers(0, 14); |
748 } | 744 } |
749 | 745 |
750 TEST_F(SourceBufferStreamTest, Append_DisjointRanges) { | 746 TEST_F(SourceBufferStreamTest, Append_DisjointRanges) { |
751 // Append 5 buffers at positions 0 through 4. | 747 // Append 5 buffers at positions 0 through 4. |
752 NewSegmentAppend(0, 5); | 748 NewCodedFrameGroupAppend(0, 5); |
753 | 749 |
754 // Append 10 buffers at positions 15 through 24. | 750 // Append 10 buffers at positions 15 through 24. |
755 NewSegmentAppend(15, 10); | 751 NewCodedFrameGroupAppend(15, 10); |
756 | 752 |
757 // Check expected ranges. | 753 // Check expected ranges. |
758 CheckExpectedRanges("{ [0,4) [15,24) }"); | 754 CheckExpectedRanges("{ [0,4) [15,24) }"); |
759 // Check buffers in ranges. | 755 // Check buffers in ranges. |
760 Seek(0); | 756 Seek(0); |
761 CheckExpectedBuffers(0, 4); | 757 CheckExpectedBuffers(0, 4); |
762 Seek(15); | 758 Seek(15); |
763 CheckExpectedBuffers(15, 24); | 759 CheckExpectedBuffers(15, 24); |
764 } | 760 } |
765 | 761 |
766 TEST_F(SourceBufferStreamTest, Append_AdjacentRanges) { | 762 TEST_F(SourceBufferStreamTest, Append_AdjacentRanges) { |
767 // Append 10 buffers at positions 0 through 9. | 763 // Append 10 buffers at positions 0 through 9. |
768 NewSegmentAppend(0, 10); | 764 NewCodedFrameGroupAppend(0, 10); |
769 | 765 |
770 // Append 11 buffers at positions 15 through 25. | 766 // Append 11 buffers at positions 15 through 25. |
771 NewSegmentAppend(15, 11); | 767 NewCodedFrameGroupAppend(15, 11); |
772 | 768 |
773 // Append 5 buffers at positions 10 through 14 to bridge the gap. | 769 // Append 5 buffers at positions 10 through 14 to bridge the gap. |
774 NewSegmentAppend(10, 5); | 770 NewCodedFrameGroupAppend(10, 5); |
775 | 771 |
776 // Check expected range. | 772 // Check expected range. |
777 CheckExpectedRanges("{ [0,25) }"); | 773 CheckExpectedRanges("{ [0,25) }"); |
778 // Check buffers in range. | 774 // Check buffers in range. |
779 Seek(0); | 775 Seek(0); |
780 CheckExpectedBuffers(0, 25); | 776 CheckExpectedBuffers(0, 25); |
781 } | 777 } |
782 | 778 |
783 TEST_F(SourceBufferStreamTest, Append_DoesNotBeginWithKeyframe) { | |
784 EXPECT_MEDIA_LOG(ContainsMissingKeyframeLog()).Times(2); | |
785 | |
786 // Append fails because the range doesn't begin with a keyframe. | |
787 NewSegmentAppend_ExpectFailure(3, 2); | |
788 | |
789 // Append 10 buffers at positions 5 through 14. | |
790 NewSegmentAppend(5, 10); | |
791 | |
792 // Check expected range. | |
793 CheckExpectedRanges("{ [5,14) }"); | |
794 // Check buffers in range. | |
795 Seek(5); | |
796 CheckExpectedBuffers(5, 14); | |
797 | |
798 // Append fails because the range doesn't begin with a keyframe. | |
799 NewSegmentAppend_ExpectFailure(17, 3); | |
800 | |
801 CheckExpectedRanges("{ [5,14) }"); | |
802 Seek(5); | |
803 CheckExpectedBuffers(5, 14); | |
804 } | |
805 | |
806 TEST_F(SourceBufferStreamTest, Append_DoesNotBeginWithKeyframe_Adjacent) { | |
807 EXPECT_MEDIA_LOG(ContainsMissingKeyframeLog()); | |
808 | |
809 // Append 8 buffers at positions 0 through 7. | |
810 NewSegmentAppend(0, 8); | |
811 | |
812 // Now start a new media segment at position 8. Append should fail because | |
813 // the media segment does not begin with a keyframe. | |
814 NewSegmentAppend_ExpectFailure(8, 2); | |
815 | |
816 // Check expected range. | |
817 CheckExpectedRanges("{ [0,7) }"); | |
818 // Check buffers in range. | |
819 Seek(0); | |
820 CheckExpectedBuffers(0, 7); | |
821 } | |
822 | |
823 TEST_F(SourceBufferStreamTest, Complete_Overlap) { | 779 TEST_F(SourceBufferStreamTest, Complete_Overlap) { |
824 // Append 5 buffers at positions 5 through 9. | 780 // Append 5 buffers at positions 5 through 9. |
825 NewSegmentAppend(5, 5); | 781 NewCodedFrameGroupAppend(5, 5); |
826 | 782 |
827 // Append 15 buffers at positions 0 through 14. | 783 // Append 15 buffers at positions 0 through 14. |
828 NewSegmentAppend(0, 15); | 784 NewCodedFrameGroupAppend(0, 15); |
829 | 785 |
830 // Check expected range. | 786 // Check expected range. |
831 CheckExpectedRanges("{ [0,14) }"); | 787 CheckExpectedRanges("{ [0,14) }"); |
832 // Check buffers in range. | 788 // Check buffers in range. |
833 Seek(0); | 789 Seek(0); |
834 CheckExpectedBuffers(0, 14); | 790 CheckExpectedBuffers(0, 14); |
835 } | 791 } |
836 | 792 |
837 TEST_F(SourceBufferStreamTest, | 793 TEST_F(SourceBufferStreamTest, |
838 Complete_Overlap_AfterSegmentTimestampAndBeforeFirstBufferTimestamp) { | 794 Complete_Overlap_AfterGroupTimestampAndBeforeFirstBufferTimestamp) { |
839 // Append a segment with a start timestamp of 0, but the first | 795 // Append a coded frame group with a start timestamp of 0, but the first |
840 // buffer starts at 30ms. This can happen in muxed content where the | 796 // buffer starts at 30ms. This can happen in muxed content where the |
841 // audio starts before the first frame. | 797 // audio starts before the first frame. |
842 NewSegmentAppend(base::TimeDelta::FromMilliseconds(0), "30K 60K 90K 120K"); | 798 NewCodedFrameGroupAppend(base::TimeDelta::FromMilliseconds(0), |
799 "30K 60K 90K 120K"); | |
843 | 800 |
844 CheckExpectedRangesByTimestamp("{ [0,150) }"); | 801 CheckExpectedRangesByTimestamp("{ [0,150) }"); |
845 | 802 |
846 // Completely overlap the old buffers, with a segment that starts | 803 // Completely overlap the old buffers, with a coded frame group that starts |
847 // after the old segment start timestamp, but before the timestamp | 804 // after the old coded frame group start timestamp, but before the timestamp |
848 // of the first buffer in the segment. | 805 // of the first buffer in the coded frame group. |
849 NewSegmentAppend("20K 50K 80K 110D10K"); | 806 NewCodedFrameGroupAppend("20K 50K 80K 110D10K"); |
850 | 807 |
851 // Verify that the buffered ranges are updated properly and we don't crash. | 808 // Verify that the buffered ranges are updated properly and we don't crash. |
852 CheckExpectedRangesByTimestamp("{ [20,150) }"); | 809 CheckExpectedRangesByTimestamp("{ [20,150) }"); |
853 | 810 |
854 SeekToTimestampMs(20); | 811 SeekToTimestampMs(20); |
855 CheckExpectedBuffers("20K 50K 80K 110K 120K"); | 812 CheckExpectedBuffers("20K 50K 80K 110K 120K"); |
856 } | 813 } |
857 | 814 |
858 TEST_F(SourceBufferStreamTest, Complete_Overlap_EdgeCase) { | 815 TEST_F(SourceBufferStreamTest, Complete_Overlap_EdgeCase) { |
859 // Make each frame a keyframe so that it's okay to overlap frames at any point | 816 // Make each frame a keyframe so that it's okay to overlap frames at any point |
860 // (instead of needing to respect keyframe boundaries). | 817 // (instead of needing to respect keyframe boundaries). |
861 SetStreamInfo(30, 30); | 818 SetStreamInfo(30, 30); |
862 | 819 |
863 // Append 6 buffers at positions 6 through 11. | 820 // Append 6 buffers at positions 6 through 11. |
864 NewSegmentAppend(6, 6); | 821 NewCodedFrameGroupAppend(6, 6); |
865 | 822 |
866 // Append 8 buffers at positions 5 through 12. | 823 // Append 8 buffers at positions 5 through 12. |
867 NewSegmentAppend(5, 8); | 824 NewCodedFrameGroupAppend(5, 8); |
868 | 825 |
869 // Check expected range. | 826 // Check expected range. |
870 CheckExpectedRanges("{ [5,12) }"); | 827 CheckExpectedRanges("{ [5,12) }"); |
871 // Check buffers in range. | 828 // Check buffers in range. |
872 Seek(5); | 829 Seek(5); |
873 CheckExpectedBuffers(5, 12); | 830 CheckExpectedBuffers(5, 12); |
874 } | 831 } |
875 | 832 |
876 TEST_F(SourceBufferStreamTest, Start_Overlap) { | 833 TEST_F(SourceBufferStreamTest, Start_Overlap) { |
877 // Append 10 buffers at positions 5 through 14. | 834 // Append 10 buffers at positions 5 through 14. |
878 NewSegmentAppend(5, 5); | 835 NewCodedFrameGroupAppend(5, 5); |
879 | 836 |
880 // Append 6 buffers at positions 10 through 15. | 837 // Append 6 buffers at positions 10 through 15. |
881 NewSegmentAppend(10, 6); | 838 NewCodedFrameGroupAppend(10, 6); |
882 | 839 |
883 // Check expected range. | 840 // Check expected range. |
884 CheckExpectedRanges("{ [5,15) }"); | 841 CheckExpectedRanges("{ [5,15) }"); |
885 // Check buffers in range. | 842 // Check buffers in range. |
886 Seek(5); | 843 Seek(5); |
887 CheckExpectedBuffers(5, 15); | 844 CheckExpectedBuffers(5, 15); |
888 } | 845 } |
889 | 846 |
890 TEST_F(SourceBufferStreamTest, End_Overlap) { | 847 TEST_F(SourceBufferStreamTest, End_Overlap) { |
891 // Append 10 buffers at positions 10 through 19. | 848 // Append 10 buffers at positions 10 through 19. |
892 NewSegmentAppend(10, 10); | 849 NewCodedFrameGroupAppend(10, 10); |
893 | 850 |
894 // Append 10 buffers at positions 5 through 14. | 851 // Append 10 buffers at positions 5 through 14. |
895 NewSegmentAppend(5, 10); | 852 NewCodedFrameGroupAppend(5, 10); |
896 | 853 |
897 // Check expected range. | 854 // Check expected range. |
898 CheckExpectedRanges("{ [5,19) }"); | 855 CheckExpectedRanges("{ [5,19) }"); |
899 // Check buffers in range. | 856 // Check buffers in range. |
900 Seek(5); | 857 Seek(5); |
901 CheckExpectedBuffers(5, 19); | 858 CheckExpectedBuffers(5, 19); |
902 } | 859 } |
903 | 860 |
904 TEST_F(SourceBufferStreamTest, End_Overlap_Several) { | 861 TEST_F(SourceBufferStreamTest, End_Overlap_Several) { |
905 // Append 10 buffers at positions 10 through 19. | 862 // Append 10 buffers at positions 10 through 19. |
906 NewSegmentAppend(10, 10); | 863 NewCodedFrameGroupAppend(10, 10); |
907 | 864 |
908 // Append 8 buffers at positions 5 through 12. | 865 // Append 8 buffers at positions 5 through 12. |
909 NewSegmentAppend(5, 8); | 866 NewCodedFrameGroupAppend(5, 8); |
910 | 867 |
911 // Check expected ranges: stream should not have kept buffers 13 and 14 | 868 // Check expected ranges: stream should not have kept buffers 13 and 14 |
912 // because the keyframe on which they depended was overwritten. | 869 // because the keyframe on which they depended was overwritten. |
913 CheckExpectedRanges("{ [5,12) [15,19) }"); | 870 CheckExpectedRanges("{ [5,12) [15,19) }"); |
914 | 871 |
915 // Check buffers in range. | 872 // Check buffers in range. |
916 Seek(5); | 873 Seek(5); |
917 CheckExpectedBuffers(5, 12); | 874 CheckExpectedBuffers(5, 12); |
918 CheckNoNextBuffer(); | 875 CheckNoNextBuffer(); |
919 | 876 |
920 Seek(19); | 877 Seek(19); |
921 CheckExpectedBuffers(15, 19); | 878 CheckExpectedBuffers(15, 19); |
922 } | 879 } |
923 | 880 |
924 // Test an end overlap edge case where a single buffer overlaps the | 881 // Test an end overlap edge case where a single buffer overlaps the |
925 // beginning of a range. | 882 // beginning of a range. |
926 // old : *0K* 30 60 90 120K 150 | 883 // old : *0K* 30 60 90 120K 150 |
927 // new : *0K* | 884 // new : *0K* |
928 // after: *0K* *120K* 150K | 885 // after: *0K* *120K* 150K |
929 // track: | 886 // track: |
930 TEST_F(SourceBufferStreamTest, End_Overlap_SingleBuffer) { | 887 TEST_F(SourceBufferStreamTest, End_Overlap_SingleBuffer) { |
931 // Seek to start of stream. | 888 // Seek to start of stream. |
932 SeekToTimestampMs(0); | 889 SeekToTimestampMs(0); |
933 | 890 |
934 NewSegmentAppend("0K 30 60 90 120K 150"); | 891 NewCodedFrameGroupAppend("0K 30 60 90 120K 150"); |
935 CheckExpectedRangesByTimestamp("{ [0,180) }"); | 892 CheckExpectedRangesByTimestamp("{ [0,180) }"); |
936 | 893 |
937 NewSegmentAppend("0D30K"); | 894 NewCodedFrameGroupAppend("0D30K"); |
938 CheckExpectedRangesByTimestamp("{ [0,30) [120,180) }"); | 895 CheckExpectedRangesByTimestamp("{ [0,30) [120,180) }"); |
939 | 896 |
940 CheckExpectedBuffers("0K"); | 897 CheckExpectedBuffers("0K"); |
941 CheckNoNextBuffer(); | 898 CheckNoNextBuffer(); |
942 } | 899 } |
943 | 900 |
944 TEST_F(SourceBufferStreamTest, Complete_Overlap_Several) { | 901 TEST_F(SourceBufferStreamTest, Complete_Overlap_Several) { |
945 // Append 2 buffers at positions 5 through 6. | 902 // Append 2 buffers at positions 5 through 6. |
946 NewSegmentAppend(5, 2); | 903 NewCodedFrameGroupAppend(5, 2); |
947 | 904 |
948 // Append 2 buffers at positions 10 through 11. | 905 // Append 2 buffers at positions 10 through 11. |
949 NewSegmentAppend(10, 2); | 906 NewCodedFrameGroupAppend(10, 2); |
950 | 907 |
951 // Append 2 buffers at positions 15 through 16. | 908 // Append 2 buffers at positions 15 through 16. |
952 NewSegmentAppend(15, 2); | 909 NewCodedFrameGroupAppend(15, 2); |
953 | 910 |
954 // Check expected ranges. | 911 // Check expected ranges. |
955 CheckExpectedRanges("{ [5,6) [10,11) [15,16) }"); | 912 CheckExpectedRanges("{ [5,6) [10,11) [15,16) }"); |
956 | 913 |
957 // Append buffers at positions 0 through 19. | 914 // Append buffers at positions 0 through 19. |
958 NewSegmentAppend(0, 20); | 915 NewCodedFrameGroupAppend(0, 20); |
959 | 916 |
960 // Check expected range. | 917 // Check expected range. |
961 CheckExpectedRanges("{ [0,19) }"); | 918 CheckExpectedRanges("{ [0,19) }"); |
962 // Check buffers in range. | 919 // Check buffers in range. |
963 Seek(0); | 920 Seek(0); |
964 CheckExpectedBuffers(0, 19); | 921 CheckExpectedBuffers(0, 19); |
965 } | 922 } |
966 | 923 |
967 TEST_F(SourceBufferStreamTest, Complete_Overlap_Several_Then_Merge) { | 924 TEST_F(SourceBufferStreamTest, Complete_Overlap_Several_Then_Merge) { |
968 // Append 2 buffers at positions 5 through 6. | 925 // Append 2 buffers at positions 5 through 6. |
969 NewSegmentAppend(5, 2); | 926 NewCodedFrameGroupAppend(5, 2); |
970 | 927 |
971 // Append 2 buffers at positions 10 through 11. | 928 // Append 2 buffers at positions 10 through 11. |
972 NewSegmentAppend(10, 2); | 929 NewCodedFrameGroupAppend(10, 2); |
973 | 930 |
974 // Append 2 buffers at positions 15 through 16. | 931 // Append 2 buffers at positions 15 through 16. |
975 NewSegmentAppend(15, 2); | 932 NewCodedFrameGroupAppend(15, 2); |
976 | 933 |
977 // Append 2 buffers at positions 20 through 21. | 934 // Append 2 buffers at positions 20 through 21. |
978 NewSegmentAppend(20, 2); | 935 NewCodedFrameGroupAppend(20, 2); |
979 | 936 |
980 // Append buffers at positions 0 through 19. | 937 // Append buffers at positions 0 through 19. |
981 NewSegmentAppend(0, 20); | 938 NewCodedFrameGroupAppend(0, 20); |
982 | 939 |
983 // Check expected ranges. | 940 // Check expected ranges. |
984 CheckExpectedRanges("{ [0,21) }"); | 941 CheckExpectedRanges("{ [0,21) }"); |
985 // Check buffers in range. | 942 // Check buffers in range. |
986 Seek(0); | 943 Seek(0); |
987 CheckExpectedBuffers(0, 21); | 944 CheckExpectedBuffers(0, 21); |
988 } | 945 } |
989 | 946 |
990 TEST_F(SourceBufferStreamTest, Complete_Overlap_Selected) { | 947 TEST_F(SourceBufferStreamTest, Complete_Overlap_Selected) { |
991 // Append 10 buffers at positions 5 through 14. | 948 // Append 10 buffers at positions 5 through 14. |
992 NewSegmentAppend(5, 10, &kDataA); | 949 NewCodedFrameGroupAppend(5, 10, &kDataA); |
993 | 950 |
994 // Seek to buffer at position 5. | 951 // Seek to buffer at position 5. |
995 Seek(5); | 952 Seek(5); |
996 | 953 |
997 // Replace old data with new data. | 954 // Replace old data with new data. |
998 NewSegmentAppend(5, 10, &kDataB); | 955 NewCodedFrameGroupAppend(5, 10, &kDataB); |
999 | 956 |
1000 // Check ranges are correct. | 957 // Check ranges are correct. |
1001 CheckExpectedRanges("{ [5,14) }"); | 958 CheckExpectedRanges("{ [5,14) }"); |
1002 | 959 |
1003 // Check that data has been replaced with new data. | 960 // Check that data has been replaced with new data. |
1004 CheckExpectedBuffers(5, 14, &kDataB); | 961 CheckExpectedBuffers(5, 14, &kDataB); |
1005 } | 962 } |
1006 | 963 |
1007 // This test is testing that a client can append data to SourceBufferStream that | 964 // This test is testing that a client can append data to SourceBufferStream that |
1008 // overlaps the range from which the client is currently grabbing buffers. We | 965 // overlaps the range from which the client is currently grabbing buffers. We |
1009 // would expect that the SourceBufferStream would return old data until it hits | 966 // would expect that the SourceBufferStream would return old data until it hits |
1010 // the keyframe of the new data, after which it will return the new data. | 967 // the keyframe of the new data, after which it will return the new data. |
1011 TEST_F(SourceBufferStreamTest, Complete_Overlap_Selected_TrackBuffer) { | 968 TEST_F(SourceBufferStreamTest, Complete_Overlap_Selected_TrackBuffer) { |
1012 // Append 10 buffers at positions 5 through 14. | 969 // Append 10 buffers at positions 5 through 14. |
1013 NewSegmentAppend(5, 10, &kDataA); | 970 NewCodedFrameGroupAppend(5, 10, &kDataA); |
1014 | 971 |
1015 // Seek to buffer at position 5 and get next buffer. | 972 // Seek to buffer at position 5 and get next buffer. |
1016 Seek(5); | 973 Seek(5); |
1017 CheckExpectedBuffers(5, 5, &kDataA); | 974 CheckExpectedBuffers(5, 5, &kDataA); |
1018 | 975 |
1019 // Do a complete overlap by appending 20 buffers at positions 0 through 19. | 976 // Do a complete overlap by appending 20 buffers at positions 0 through 19. |
1020 NewSegmentAppend(0, 20, &kDataB); | 977 NewCodedFrameGroupAppend(0, 20, &kDataB); |
1021 | 978 |
1022 // Check range is correct. | 979 // Check range is correct. |
1023 CheckExpectedRanges("{ [0,19) }"); | 980 CheckExpectedRanges("{ [0,19) }"); |
1024 | 981 |
1025 // Expect old data up until next keyframe in new data. | 982 // Expect old data up until next keyframe in new data. |
1026 CheckExpectedBuffers(6, 9, &kDataA); | 983 CheckExpectedBuffers(6, 9, &kDataA); |
1027 CheckExpectedBuffers(10, 10, &kDataB, true); | 984 CheckExpectedBuffers(10, 10, &kDataB, true); |
1028 | 985 |
1029 // Expect rest of data to be new. | 986 // Expect rest of data to be new. |
1030 CheckExpectedBuffers(11, 19, &kDataB); | 987 CheckExpectedBuffers(11, 19, &kDataB); |
1031 | 988 |
1032 // Seek back to beginning; all data should be new. | 989 // Seek back to beginning; all data should be new. |
1033 Seek(0); | 990 Seek(0); |
1034 CheckExpectedBuffers(0, 19, &kDataB); | 991 CheckExpectedBuffers(0, 19, &kDataB); |
1035 | 992 |
1036 // Check range continues to be correct. | 993 // Check range continues to be correct. |
1037 CheckExpectedRanges("{ [0,19) }"); | 994 CheckExpectedRanges("{ [0,19) }"); |
1038 } | 995 } |
1039 | 996 |
1040 TEST_F(SourceBufferStreamTest, Complete_Overlap_Selected_EdgeCase) { | 997 TEST_F(SourceBufferStreamTest, Complete_Overlap_Selected_EdgeCase) { |
1041 // Append 10 buffers at positions 5 through 14. | 998 // Append 10 buffers at positions 5 through 14. |
1042 NewSegmentAppend(5, 10, &kDataA); | 999 NewCodedFrameGroupAppend(5, 10, &kDataA); |
1043 | 1000 |
1044 // Seek to buffer at position 5 and get next buffer. | 1001 // Seek to buffer at position 5 and get next buffer. |
1045 Seek(5); | 1002 Seek(5); |
1046 CheckExpectedBuffers(5, 5, &kDataA); | 1003 CheckExpectedBuffers(5, 5, &kDataA); |
1047 | 1004 |
1048 // Replace existing data with new data. | 1005 // Replace existing data with new data. |
1049 NewSegmentAppend(5, 10, &kDataB); | 1006 NewCodedFrameGroupAppend(5, 10, &kDataB); |
1050 | 1007 |
1051 // Check ranges are correct. | 1008 // Check ranges are correct. |
1052 CheckExpectedRanges("{ [5,14) }"); | 1009 CheckExpectedRanges("{ [5,14) }"); |
1053 | 1010 |
1054 // Expect old data up until next keyframe in new data. | 1011 // Expect old data up until next keyframe in new data. |
1055 CheckExpectedBuffers(6, 9, &kDataA); | 1012 CheckExpectedBuffers(6, 9, &kDataA); |
1056 CheckExpectedBuffers(10, 10, &kDataB, true); | 1013 CheckExpectedBuffers(10, 10, &kDataB, true); |
1057 | 1014 |
1058 // Expect rest of data to be new. | 1015 // Expect rest of data to be new. |
1059 CheckExpectedBuffers(11, 14, &kDataB); | 1016 CheckExpectedBuffers(11, 14, &kDataB); |
1060 | 1017 |
1061 // Seek back to beginning; all data should be new. | 1018 // Seek back to beginning; all data should be new. |
1062 Seek(5); | 1019 Seek(5); |
1063 CheckExpectedBuffers(5, 14, &kDataB); | 1020 CheckExpectedBuffers(5, 14, &kDataB); |
1064 | 1021 |
1065 // Check range continues to be correct. | 1022 // Check range continues to be correct. |
1066 CheckExpectedRanges("{ [5,14) }"); | 1023 CheckExpectedRanges("{ [5,14) }"); |
1067 } | 1024 } |
1068 | 1025 |
1069 TEST_F(SourceBufferStreamTest, Complete_Overlap_Selected_Multiple) { | 1026 TEST_F(SourceBufferStreamTest, Complete_Overlap_Selected_Multiple) { |
1070 static const uint8_t kDataC = 0x55; | 1027 static const uint8_t kDataC = 0x55; |
1071 static const uint8_t kDataD = 0x77; | 1028 static const uint8_t kDataD = 0x77; |
1072 | 1029 |
1073 // Append 5 buffers at positions 5 through 9. | 1030 // Append 5 buffers at positions 5 through 9. |
1074 NewSegmentAppend(5, 5, &kDataA); | 1031 NewCodedFrameGroupAppend(5, 5, &kDataA); |
1075 | 1032 |
1076 // Seek to buffer at position 5 and get next buffer. | 1033 // Seek to buffer at position 5 and get next buffer. |
1077 Seek(5); | 1034 Seek(5); |
1078 CheckExpectedBuffers(5, 5, &kDataA); | 1035 CheckExpectedBuffers(5, 5, &kDataA); |
1079 | 1036 |
1080 // Replace existing data with new data. | 1037 // Replace existing data with new data. |
1081 NewSegmentAppend(5, 5, &kDataB); | 1038 NewCodedFrameGroupAppend(5, 5, &kDataB); |
1082 | 1039 |
1083 // Then replace it again with different data. | 1040 // Then replace it again with different data. |
1084 NewSegmentAppend(5, 5, &kDataC); | 1041 NewCodedFrameGroupAppend(5, 5, &kDataC); |
1085 | 1042 |
1086 // Now append 5 new buffers at positions 10 through 14. | 1043 // Now append 5 new buffers at positions 10 through 14. |
1087 NewSegmentAppend(10, 5, &kDataC); | 1044 NewCodedFrameGroupAppend(10, 5, &kDataC); |
1088 | 1045 |
1089 // Now replace all the data entirely. | 1046 // Now replace all the data entirely. |
1090 NewSegmentAppend(5, 10, &kDataD); | 1047 NewCodedFrameGroupAppend(5, 10, &kDataD); |
1091 | 1048 |
1092 // Expect buffers 6 through 9 to be DataA, and the remaining | 1049 // Expect buffers 6 through 9 to be DataA, and the remaining |
1093 // buffers to be kDataD. | 1050 // buffers to be kDataD. |
1094 CheckExpectedBuffers(6, 9, &kDataA); | 1051 CheckExpectedBuffers(6, 9, &kDataA); |
1095 CheckExpectedBuffers(10, 14, &kDataD); | 1052 CheckExpectedBuffers(10, 14, &kDataD); |
1096 | 1053 |
1097 // At this point we cannot fulfill request. | 1054 // At this point we cannot fulfill request. |
1098 CheckNoNextBuffer(); | 1055 CheckNoNextBuffer(); |
1099 | 1056 |
1100 // Seek back to beginning; all data should be new. | 1057 // Seek back to beginning; all data should be new. |
1101 Seek(5); | 1058 Seek(5); |
1102 CheckExpectedBuffers(5, 14, &kDataD); | 1059 CheckExpectedBuffers(5, 14, &kDataD); |
1103 } | 1060 } |
1104 | 1061 |
1105 TEST_F(SourceBufferStreamTest, Start_Overlap_Selected) { | 1062 TEST_F(SourceBufferStreamTest, Start_Overlap_Selected) { |
1106 // Append 10 buffers at positions 0 through 9. | 1063 // Append 10 buffers at positions 0 through 9. |
1107 NewSegmentAppend(0, 10, &kDataA); | 1064 NewCodedFrameGroupAppend(0, 10, &kDataA); |
1108 | 1065 |
1109 // Seek to position 5, then add buffers to overlap data at that position. | 1066 // Seek to position 5, then add buffers to overlap data at that position. |
1110 Seek(5); | 1067 Seek(5); |
1111 NewSegmentAppend(5, 10, &kDataB); | 1068 NewCodedFrameGroupAppend(5, 10, &kDataB); |
1112 | 1069 |
1113 // Check expected range. | 1070 // Check expected range. |
1114 CheckExpectedRanges("{ [0,14) }"); | 1071 CheckExpectedRanges("{ [0,14) }"); |
1115 | 1072 |
1116 // Because we seeked to a keyframe, the next buffers should all be new data. | 1073 // Because we seeked to a keyframe, the next buffers should all be new data. |
1117 CheckExpectedBuffers(5, 14, &kDataB); | 1074 CheckExpectedBuffers(5, 14, &kDataB); |
1118 | 1075 |
1119 // Make sure all data is correct. | 1076 // Make sure all data is correct. |
1120 Seek(0); | 1077 Seek(0); |
1121 CheckExpectedBuffers(0, 4, &kDataA); | 1078 CheckExpectedBuffers(0, 4, &kDataA); |
1122 CheckExpectedBuffers(5, 14, &kDataB); | 1079 CheckExpectedBuffers(5, 14, &kDataB); |
1123 } | 1080 } |
1124 | 1081 |
1125 TEST_F(SourceBufferStreamTest, Start_Overlap_Selected_TrackBuffer) { | 1082 TEST_F(SourceBufferStreamTest, Start_Overlap_Selected_TrackBuffer) { |
1126 // Append 15 buffers at positions 0 through 14. | 1083 // Append 15 buffers at positions 0 through 14. |
1127 NewSegmentAppend(0, 15, &kDataA); | 1084 NewCodedFrameGroupAppend(0, 15, &kDataA); |
1128 | 1085 |
1129 // Seek to 10 and get buffer. | 1086 // Seek to 10 and get buffer. |
1130 Seek(10); | 1087 Seek(10); |
1131 CheckExpectedBuffers(10, 10, &kDataA); | 1088 CheckExpectedBuffers(10, 10, &kDataA); |
1132 | 1089 |
1133 // Now append 10 buffers of new data at positions 10 through 19. | 1090 // Now append 10 buffers of new data at positions 10 through 19. |
1134 NewSegmentAppend(10, 10, &kDataB); | 1091 NewCodedFrameGroupAppend(10, 10, &kDataB); |
1135 | 1092 |
1136 // Check expected range. | 1093 // Check expected range. |
1137 CheckExpectedRanges("{ [0,19) }"); | 1094 CheckExpectedRanges("{ [0,19) }"); |
1138 | 1095 |
1139 // The next 4 buffers should be a from the old buffer, followed by a keyframe | 1096 // The next 4 buffers should be a from the old buffer, followed by a keyframe |
1140 // from the new data. | 1097 // from the new data. |
1141 CheckExpectedBuffers(11, 14, &kDataA); | 1098 CheckExpectedBuffers(11, 14, &kDataA); |
1142 CheckExpectedBuffers(15, 15, &kDataB, true); | 1099 CheckExpectedBuffers(15, 15, &kDataB, true); |
1143 | 1100 |
1144 // The rest of the buffers should be new data. | 1101 // The rest of the buffers should be new data. |
1145 CheckExpectedBuffers(16, 19, &kDataB); | 1102 CheckExpectedBuffers(16, 19, &kDataB); |
1146 | 1103 |
1147 // Now seek to the beginning; positions 0 through 9 should be the original | 1104 // Now seek to the beginning; positions 0 through 9 should be the original |
1148 // data, positions 10 through 19 should be the new data. | 1105 // data, positions 10 through 19 should be the new data. |
1149 Seek(0); | 1106 Seek(0); |
1150 CheckExpectedBuffers(0, 9, &kDataA); | 1107 CheckExpectedBuffers(0, 9, &kDataA); |
1151 CheckExpectedBuffers(10, 19, &kDataB); | 1108 CheckExpectedBuffers(10, 19, &kDataB); |
1152 | 1109 |
1153 // Make sure range is still correct. | 1110 // Make sure range is still correct. |
1154 CheckExpectedRanges("{ [0,19) }"); | 1111 CheckExpectedRanges("{ [0,19) }"); |
1155 } | 1112 } |
1156 | 1113 |
1157 TEST_F(SourceBufferStreamTest, Start_Overlap_Selected_EdgeCase) { | 1114 TEST_F(SourceBufferStreamTest, Start_Overlap_Selected_EdgeCase) { |
1158 // Append 10 buffers at positions 5 through 14. | 1115 // Append 10 buffers at positions 5 through 14. |
1159 NewSegmentAppend(5, 10, &kDataA); | 1116 NewCodedFrameGroupAppend(5, 10, &kDataA); |
1160 | 1117 |
1161 Seek(10); | 1118 Seek(10); |
1162 CheckExpectedBuffers(10, 10, &kDataA); | 1119 CheckExpectedBuffers(10, 10, &kDataA); |
1163 | 1120 |
1164 // Now replace the last 5 buffers with new data. | 1121 // Now replace the last 5 buffers with new data. |
1165 NewSegmentAppend(10, 5, &kDataB); | 1122 NewCodedFrameGroupAppend(10, 5, &kDataB); |
1166 | 1123 |
1167 // The next 4 buffers should be the origial data, held in the track buffer. | 1124 // The next 4 buffers should be the origial data, held in the track buffer. |
1168 CheckExpectedBuffers(11, 14, &kDataA); | 1125 CheckExpectedBuffers(11, 14, &kDataA); |
1169 | 1126 |
1170 // The next buffer is at position 15, so we should fail to fulfill the | 1127 // The next buffer is at position 15, so we should fail to fulfill the |
1171 // request. | 1128 // request. |
1172 CheckNoNextBuffer(); | 1129 CheckNoNextBuffer(); |
1173 | 1130 |
1174 // Now append data at 15 through 19 and check to make sure it's correct. | 1131 // Now append data at 15 through 19 and check to make sure it's correct. |
1175 NewSegmentAppend(15, 5, &kDataB); | 1132 NewCodedFrameGroupAppend(15, 5, &kDataB); |
1176 CheckExpectedBuffers(15, 19, &kDataB); | 1133 CheckExpectedBuffers(15, 19, &kDataB); |
1177 | 1134 |
1178 // Seek to beginning of buffered range and check buffers. | 1135 // Seek to beginning of buffered range and check buffers. |
1179 Seek(5); | 1136 Seek(5); |
1180 CheckExpectedBuffers(5, 9, &kDataA); | 1137 CheckExpectedBuffers(5, 9, &kDataA); |
1181 CheckExpectedBuffers(10, 19, &kDataB); | 1138 CheckExpectedBuffers(10, 19, &kDataB); |
1182 | 1139 |
1183 // Check expected range. | 1140 // Check expected range. |
1184 CheckExpectedRanges("{ [5,19) }"); | 1141 CheckExpectedRanges("{ [5,19) }"); |
1185 } | 1142 } |
1186 | 1143 |
1187 // This test covers the case where new buffers end-overlap an existing, selected | 1144 // This test covers the case where new buffers end-overlap an existing, selected |
1188 // range, and the next buffer is a keyframe that's being overlapped by new | 1145 // range, and the next buffer is a keyframe that's being overlapped by new |
1189 // buffers. | 1146 // buffers. |
1190 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 | 1147 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 |
1191 // old  : *A*a a a a A a a a a | 1148 // old  : *A*a a a a A a a a a |
1192 // new  : B b b b b B b b b b | 1149 // new  : B b b b b B b b b b |
1193 // after: B b b b b*B*b b b b A a a a a | 1150 // after: B b b b b*B*b b b b A a a a a |
1194 TEST_F(SourceBufferStreamTest, End_Overlap_Selected) { | 1151 TEST_F(SourceBufferStreamTest, End_Overlap_Selected) { |
1195 // Append 10 buffers at positions 5 through 14. | 1152 // Append 10 buffers at positions 5 through 14. |
1196 NewSegmentAppend(5, 10, &kDataA); | 1153 NewCodedFrameGroupAppend(5, 10, &kDataA); |
1197 | 1154 |
1198 // Seek to position 5. | 1155 // Seek to position 5. |
1199 Seek(5); | 1156 Seek(5); |
1200 | 1157 |
1201 // Now append 10 buffers at positions 0 through 9. | 1158 // Now append 10 buffers at positions 0 through 9. |
1202 NewSegmentAppend(0, 10, &kDataB); | 1159 NewCodedFrameGroupAppend(0, 10, &kDataB); |
1203 | 1160 |
1204 // Check expected range. | 1161 // Check expected range. |
1205 CheckExpectedRanges("{ [0,14) }"); | 1162 CheckExpectedRanges("{ [0,14) }"); |
1206 | 1163 |
1207 // Because we seeked to a keyframe, the next buffers should be new. | 1164 // Because we seeked to a keyframe, the next buffers should be new. |
1208 CheckExpectedBuffers(5, 9, &kDataB); | 1165 CheckExpectedBuffers(5, 9, &kDataB); |
1209 | 1166 |
1210 // Make sure all data is correct. | 1167 // Make sure all data is correct. |
1211 Seek(0); | 1168 Seek(0); |
1212 CheckExpectedBuffers(0, 9, &kDataB); | 1169 CheckExpectedBuffers(0, 9, &kDataB); |
1213 CheckExpectedBuffers(10, 14, &kDataA); | 1170 CheckExpectedBuffers(10, 14, &kDataA); |
1214 } | 1171 } |
1215 | 1172 |
1216 // This test covers the case where new buffers end-overlap an existing, selected | 1173 // This test covers the case where new buffers end-overlap an existing, selected |
1217 // range, and the next buffer in the range is after the newly appended buffers. | 1174 // range, and the next buffer in the range is after the newly appended buffers. |
1218 // In this particular case, the end overlap does not require a split. | 1175 // In this particular case, the end overlap does not require a split. |
1219 // | 1176 // |
1220 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 | 1177 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 |
1221 // old  : |A a a a a A a a*a*a| | 1178 // old  : |A a a a a A a a*a*a| |
1222 // new  : B b b b b B b b b b | 1179 // new  : B b b b b B b b b b |
1223 // after: |B b b b b B b b b b A a a*a*a| | 1180 // after: |B b b b b B b b b b A a a*a*a| |
1224 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_AfterEndOfNew_1) { | 1181 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_AfterEndOfNew_1) { |
1225 // Append 10 buffers at positions 5 through 14. | 1182 // Append 10 buffers at positions 5 through 14. |
1226 NewSegmentAppend(5, 10, &kDataA); | 1183 NewCodedFrameGroupAppend(5, 10, &kDataA); |
1227 | 1184 |
1228 // Seek to position 10, then move to position 13. | 1185 // Seek to position 10, then move to position 13. |
1229 Seek(10); | 1186 Seek(10); |
1230 CheckExpectedBuffers(10, 12, &kDataA); | 1187 CheckExpectedBuffers(10, 12, &kDataA); |
1231 | 1188 |
1232 // Now append 10 buffers at positions 0 through 9. | 1189 // Now append 10 buffers at positions 0 through 9. |
1233 NewSegmentAppend(0, 10, &kDataB); | 1190 NewCodedFrameGroupAppend(0, 10, &kDataB); |
1234 | 1191 |
1235 // Check expected range. | 1192 // Check expected range. |
1236 CheckExpectedRanges("{ [0,14) }"); | 1193 CheckExpectedRanges("{ [0,14) }"); |
1237 | 1194 |
1238 // Make sure rest of data is as expected. | 1195 // Make sure rest of data is as expected. |
1239 CheckExpectedBuffers(13, 14, &kDataA); | 1196 CheckExpectedBuffers(13, 14, &kDataA); |
1240 | 1197 |
1241 // Make sure all data is correct. | 1198 // Make sure all data is correct. |
1242 Seek(0); | 1199 Seek(0); |
1243 CheckExpectedBuffers(0, 9, &kDataB); | 1200 CheckExpectedBuffers(0, 9, &kDataB); |
1244 CheckExpectedBuffers(10, 14, &kDataA); | 1201 CheckExpectedBuffers(10, 14, &kDataA); |
1245 } | 1202 } |
1246 | 1203 |
1247 // This test covers the case where new buffers end-overlap an existing, selected | 1204 // This test covers the case where new buffers end-overlap an existing, selected |
1248 // range, and the next buffer in the range is after the newly appended buffers. | 1205 // range, and the next buffer in the range is after the newly appended buffers. |
1249 // In this particular case, the end overlap requires a split, and the next | 1206 // In this particular case, the end overlap requires a split, and the next |
1250 // buffer is in the split range. | 1207 // buffer is in the split range. |
1251 // | 1208 // |
1252 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 | 1209 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 |
1253 // old  : |A a a a a A a a*a*a| | 1210 // old  : |A a a a a A a a*a*a| |
1254 // new  : B b b b b B b b | 1211 // new  : B b b b b B b b |
1255 // after: |B b b b b B b b| |A a a*a*a| | 1212 // after: |B b b b b B b b| |A a a*a*a| |
1256 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_AfterEndOfNew_2) { | 1213 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_AfterEndOfNew_2) { |
1257 // Append 10 buffers at positions 5 through 14. | 1214 // Append 10 buffers at positions 5 through 14. |
1258 NewSegmentAppend(5, 10, &kDataA); | 1215 NewCodedFrameGroupAppend(5, 10, &kDataA); |
1259 | 1216 |
1260 // Seek to position 10, then move to position 13. | 1217 // Seek to position 10, then move to position 13. |
1261 Seek(10); | 1218 Seek(10); |
1262 CheckExpectedBuffers(10, 12, &kDataA); | 1219 CheckExpectedBuffers(10, 12, &kDataA); |
1263 | 1220 |
1264 // Now append 8 buffers at positions 0 through 7. | 1221 // Now append 8 buffers at positions 0 through 7. |
1265 NewSegmentAppend(0, 8, &kDataB); | 1222 NewCodedFrameGroupAppend(0, 8, &kDataB); |
1266 | 1223 |
1267 // Check expected ranges. | 1224 // Check expected ranges. |
1268 CheckExpectedRanges("{ [0,7) [10,14) }"); | 1225 CheckExpectedRanges("{ [0,7) [10,14) }"); |
1269 | 1226 |
1270 // Make sure rest of data is as expected. | 1227 // Make sure rest of data is as expected. |
1271 CheckExpectedBuffers(13, 14, &kDataA); | 1228 CheckExpectedBuffers(13, 14, &kDataA); |
1272 | 1229 |
1273 // Make sure all data is correct. | 1230 // Make sure all data is correct. |
1274 Seek(0); | 1231 Seek(0); |
1275 CheckExpectedBuffers(0, 7, &kDataB); | 1232 CheckExpectedBuffers(0, 7, &kDataB); |
1276 CheckNoNextBuffer(); | 1233 CheckNoNextBuffer(); |
1277 | 1234 |
1278 Seek(10); | 1235 Seek(10); |
1279 CheckExpectedBuffers(10, 14, &kDataA); | 1236 CheckExpectedBuffers(10, 14, &kDataA); |
1280 } | 1237 } |
1281 | 1238 |
1282 // This test covers the case where new buffers end-overlap an existing, selected | 1239 // This test covers the case where new buffers end-overlap an existing, selected |
1283 // range, and the next buffer in the range is after the newly appended buffers. | 1240 // range, and the next buffer in the range is after the newly appended buffers. |
1284 // In this particular case, the end overlap requires a split, and the next | 1241 // In this particular case, the end overlap requires a split, and the next |
1285 // buffer was in between the end of the new data and the split range. | 1242 // buffer was in between the end of the new data and the split range. |
1286 // | 1243 // |
1287 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 | 1244 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 |
1288 // old  : |A a a*a*a A a a a a| | 1245 // old  : |A a a*a*a A a a a a| |
1289 // new  : B b b b b B b b | 1246 // new  : B b b b b B b b |
1290 // after: |B b b b b B b b| |A a a a a| | 1247 // after: |B b b b b B b b| |A a a a a| |
1291 // track: |a a| | 1248 // track: |a a| |
1292 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_AfterEndOfNew_3) { | 1249 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_AfterEndOfNew_3) { |
1293 // Append 10 buffers at positions 5 through 14. | 1250 // Append 10 buffers at positions 5 through 14. |
1294 NewSegmentAppend(5, 10, &kDataA); | 1251 NewCodedFrameGroupAppend(5, 10, &kDataA); |
1295 | 1252 |
1296 // Seek to position 5, then move to position 8. | 1253 // Seek to position 5, then move to position 8. |
1297 Seek(5); | 1254 Seek(5); |
1298 CheckExpectedBuffers(5, 7, &kDataA); | 1255 CheckExpectedBuffers(5, 7, &kDataA); |
1299 | 1256 |
1300 // Now append 8 buffers at positions 0 through 7. | 1257 // Now append 8 buffers at positions 0 through 7. |
1301 NewSegmentAppend(0, 8, &kDataB); | 1258 NewCodedFrameGroupAppend(0, 8, &kDataB); |
1302 | 1259 |
1303 // Check expected ranges. | 1260 // Check expected ranges. |
1304 CheckExpectedRanges("{ [0,7) [10,14) }"); | 1261 CheckExpectedRanges("{ [0,7) [10,14) }"); |
1305 | 1262 |
1306 // Check for data in the track buffer. | 1263 // Check for data in the track buffer. |
1307 CheckExpectedBuffers(8, 9, &kDataA); | 1264 CheckExpectedBuffers(8, 9, &kDataA); |
1308 // The buffer immediately after the track buffer should be a keyframe. | 1265 // The buffer immediately after the track buffer should be a keyframe. |
1309 CheckExpectedBuffers(10, 10, &kDataA, true); | 1266 CheckExpectedBuffers(10, 10, &kDataA, true); |
1310 | 1267 |
1311 // Make sure all data is correct. | 1268 // Make sure all data is correct. |
1312 Seek(0); | 1269 Seek(0); |
1313 CheckExpectedBuffers(0, 7, &kDataB); | 1270 CheckExpectedBuffers(0, 7, &kDataB); |
1314 Seek(10); | 1271 Seek(10); |
1315 CheckExpectedBuffers(10, 14, &kDataA); | 1272 CheckExpectedBuffers(10, 14, &kDataA); |
1316 } | 1273 } |
1317 | 1274 |
1318 // This test covers the case where new buffers end-overlap an existing, selected | 1275 // This test covers the case where new buffers end-overlap an existing, selected |
1319 // range, and the next buffer in the range is overlapped by the new buffers. | 1276 // range, and the next buffer in the range is overlapped by the new buffers. |
1320 // In this particular case, the end overlap does not require a split. | 1277 // In this particular case, the end overlap does not require a split. |
1321 // | 1278 // |
1322 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 | 1279 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 |
1323 // old  : |A a a*a*a A a a a a| | 1280 // old  : |A a a*a*a A a a a a| |
1324 // new  : B b b b b B b b b b | 1281 // new  : B b b b b B b b b b |
1325 // after: |B b b b b B b b b b A a a a a| | 1282 // after: |B b b b b B b b b b A a a a a| |
1326 // track: |a a| | 1283 // track: |a a| |
1327 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_OverlappedByNew_1) { | 1284 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_OverlappedByNew_1) { |
1328 // Append 10 buffers at positions 5 through 14. | 1285 // Append 10 buffers at positions 5 through 14. |
1329 NewSegmentAppend(5, 10, &kDataA); | 1286 NewCodedFrameGroupAppend(5, 10, &kDataA); |
1330 | 1287 |
1331 // Seek to position 5, then move to position 8. | 1288 // Seek to position 5, then move to position 8. |
1332 Seek(5); | 1289 Seek(5); |
1333 CheckExpectedBuffers(5, 7, &kDataA); | 1290 CheckExpectedBuffers(5, 7, &kDataA); |
1334 | 1291 |
1335 // Now append 10 buffers at positions 0 through 9. | 1292 // Now append 10 buffers at positions 0 through 9. |
1336 NewSegmentAppend(0, 10, &kDataB); | 1293 NewCodedFrameGroupAppend(0, 10, &kDataB); |
1337 | 1294 |
1338 // Check expected range. | 1295 // Check expected range. |
1339 CheckExpectedRanges("{ [0,14) }"); | 1296 CheckExpectedRanges("{ [0,14) }"); |
1340 | 1297 |
1341 // Check for data in the track buffer. | 1298 // Check for data in the track buffer. |
1342 CheckExpectedBuffers(8, 9, &kDataA); | 1299 CheckExpectedBuffers(8, 9, &kDataA); |
1343 // The buffer immediately after the track buffer should be a keyframe. | 1300 // The buffer immediately after the track buffer should be a keyframe. |
1344 CheckExpectedBuffers(10, 10, &kDataA, true); | 1301 CheckExpectedBuffers(10, 10, &kDataA, true); |
1345 | 1302 |
1346 // Make sure all data is correct. | 1303 // Make sure all data is correct. |
1347 Seek(0); | 1304 Seek(0); |
1348 CheckExpectedBuffers(0, 9, &kDataB); | 1305 CheckExpectedBuffers(0, 9, &kDataB); |
1349 CheckExpectedBuffers(10, 14, &kDataA); | 1306 CheckExpectedBuffers(10, 14, &kDataA); |
1350 } | 1307 } |
1351 | 1308 |
1352 // This test covers the case where new buffers end-overlap an existing, selected | 1309 // This test covers the case where new buffers end-overlap an existing, selected |
1353 // range, and the next buffer in the range is overlapped by the new buffers. | 1310 // range, and the next buffer in the range is overlapped by the new buffers. |
1354 // In this particular case, the end overlap requires a split, and the next | 1311 // In this particular case, the end overlap requires a split, and the next |
1355 // keyframe after the track buffer is in the split range. | 1312 // keyframe after the track buffer is in the split range. |
1356 // | 1313 // |
1357 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 | 1314 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 |
1358 // old  : |A*a*a a a A a a a a| | 1315 // old  : |A*a*a a a A a a a a| |
1359 // new  : B b b b b B b | 1316 // new  : B b b b b B b |
1360 // after: |B b b b b B b| |A a a a a| | 1317 // after: |B b b b b B b| |A a a a a| |
1361 // track: |a a a a| | 1318 // track: |a a a a| |
1362 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_OverlappedByNew_2) { | 1319 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_OverlappedByNew_2) { |
1363 // Append 10 buffers at positions 5 through 14. | 1320 // Append 10 buffers at positions 5 through 14. |
1364 NewSegmentAppend(5, 10, &kDataA); | 1321 NewCodedFrameGroupAppend(5, 10, &kDataA); |
1365 | 1322 |
1366 // Seek to position 5, then move to position 6. | 1323 // Seek to position 5, then move to position 6. |
1367 Seek(5); | 1324 Seek(5); |
1368 CheckExpectedBuffers(5, 5, &kDataA); | 1325 CheckExpectedBuffers(5, 5, &kDataA); |
1369 | 1326 |
1370 // Now append 7 buffers at positions 0 through 6. | 1327 // Now append 7 buffers at positions 0 through 6. |
1371 NewSegmentAppend(0, 7, &kDataB); | 1328 NewCodedFrameGroupAppend(0, 7, &kDataB); |
1372 | 1329 |
1373 // Check expected ranges. | 1330 // Check expected ranges. |
1374 CheckExpectedRanges("{ [0,6) [10,14) }"); | 1331 CheckExpectedRanges("{ [0,6) [10,14) }"); |
1375 | 1332 |
1376 // Check for data in the track buffer. | 1333 // Check for data in the track buffer. |
1377 CheckExpectedBuffers(6, 9, &kDataA); | 1334 CheckExpectedBuffers(6, 9, &kDataA); |
1378 // The buffer immediately after the track buffer should be a keyframe. | 1335 // The buffer immediately after the track buffer should be a keyframe. |
1379 CheckExpectedBuffers(10, 10, &kDataA, true); | 1336 CheckExpectedBuffers(10, 10, &kDataA, true); |
1380 | 1337 |
1381 // Make sure all data is correct. | 1338 // Make sure all data is correct. |
(...skipping 10 matching lines...) Expand all Loading... | |
1392 // In this particular case, the end overlap requires a split, and the next | 1349 // In this particular case, the end overlap requires a split, and the next |
1393 // keyframe after the track buffer is in the range with the new buffers. | 1350 // keyframe after the track buffer is in the range with the new buffers. |
1394 // | 1351 // |
1395 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 | 1352 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 |
1396 // old  : |A*a*a a a A a a a a A a a a a| | 1353 // old  : |A*a*a a a A a a a a A a a a a| |
1397 // new  : B b b b b B b b b b B b b | 1354 // new  : B b b b b B b b b b B b b |
1398 // after: |B b b b b B b b b b B b b| |A a a a a| | 1355 // after: |B b b b b B b b b b B b b| |A a a a a| |
1399 // track: |a a a a| | 1356 // track: |a a a a| |
1400 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_OverlappedByNew_3) { | 1357 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_OverlappedByNew_3) { |
1401 // Append 15 buffers at positions 5 through 19. | 1358 // Append 15 buffers at positions 5 through 19. |
1402 NewSegmentAppend(5, 15, &kDataA); | 1359 NewCodedFrameGroupAppend(5, 15, &kDataA); |
1403 | 1360 |
1404 // Seek to position 5, then move to position 6. | 1361 // Seek to position 5, then move to position 6. |
1405 Seek(5); | 1362 Seek(5); |
1406 CheckExpectedBuffers(5, 5, &kDataA); | 1363 CheckExpectedBuffers(5, 5, &kDataA); |
1407 | 1364 |
1408 // Now append 13 buffers at positions 0 through 12. | 1365 // Now append 13 buffers at positions 0 through 12. |
1409 NewSegmentAppend(0, 13, &kDataB); | 1366 NewCodedFrameGroupAppend(0, 13, &kDataB); |
1410 | 1367 |
1411 // Check expected ranges. | 1368 // Check expected ranges. |
1412 CheckExpectedRanges("{ [0,12) [15,19) }"); | 1369 CheckExpectedRanges("{ [0,12) [15,19) }"); |
1413 | 1370 |
1414 // Check for data in the track buffer. | 1371 // Check for data in the track buffer. |
1415 CheckExpectedBuffers(6, 9, &kDataA); | 1372 CheckExpectedBuffers(6, 9, &kDataA); |
1416 // The buffer immediately after the track buffer should be a keyframe | 1373 // The buffer immediately after the track buffer should be a keyframe |
1417 // from the new data. | 1374 // from the new data. |
1418 CheckExpectedBuffers(10, 10, &kDataB, true); | 1375 CheckExpectedBuffers(10, 10, &kDataB, true); |
1419 | 1376 |
1420 // Make sure all data is correct. | 1377 // Make sure all data is correct. |
1421 Seek(0); | 1378 Seek(0); |
1422 CheckExpectedBuffers(0, 12, &kDataB); | 1379 CheckExpectedBuffers(0, 12, &kDataB); |
1423 CheckNoNextBuffer(); | 1380 CheckNoNextBuffer(); |
1424 | 1381 |
1425 Seek(15); | 1382 Seek(15); |
1426 CheckExpectedBuffers(15, 19, &kDataA); | 1383 CheckExpectedBuffers(15, 19, &kDataA); |
1427 } | 1384 } |
1428 | 1385 |
1429 // This test covers the case where new buffers end-overlap an existing, selected | 1386 // This test covers the case where new buffers end-overlap an existing, selected |
1430 // range, and there is no keyframe after the end of the new buffers. | 1387 // range, and there is no keyframe after the end of the new buffers. |
1431 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 | 1388 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 |
1432 // old  : |A*a*a a a| | 1389 // old  : |A*a*a a a| |
1433 // new  : B b b b b B | 1390 // new  : B b b b b B |
1434 // after: |B b b b b B| | 1391 // after: |B b b b b B| |
1435 // track: |a a a a| | 1392 // track: |a a a a| |
1436 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_NoKeyframeAfterNew) { | 1393 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_NoKeyframeAfterNew) { |
1437 // Append 5 buffers at positions 5 through 9. | 1394 // Append 5 buffers at positions 5 through 9. |
1438 NewSegmentAppend(5, 5, &kDataA); | 1395 NewCodedFrameGroupAppend(5, 5, &kDataA); |
1439 | 1396 |
1440 // Seek to position 5, then move to position 6. | 1397 // Seek to position 5, then move to position 6. |
1441 Seek(5); | 1398 Seek(5); |
1442 CheckExpectedBuffers(5, 5, &kDataA); | 1399 CheckExpectedBuffers(5, 5, &kDataA); |
1443 | 1400 |
1444 // Now append 6 buffers at positions 0 through 5. | 1401 // Now append 6 buffers at positions 0 through 5. |
1445 NewSegmentAppend(0, 6, &kDataB); | 1402 NewCodedFrameGroupAppend(0, 6, &kDataB); |
1446 | 1403 |
1447 // Check expected range. | 1404 // Check expected range. |
1448 CheckExpectedRanges("{ [0,5) }"); | 1405 CheckExpectedRanges("{ [0,5) }"); |
1449 | 1406 |
1450 // Check for data in the track buffer. | 1407 // Check for data in the track buffer. |
1451 CheckExpectedBuffers(6, 9, &kDataA); | 1408 CheckExpectedBuffers(6, 9, &kDataA); |
1452 | 1409 |
1453 // Now there's no data to fulfill the request. | 1410 // Now there's no data to fulfill the request. |
1454 CheckNoNextBuffer(); | 1411 CheckNoNextBuffer(); |
1455 | 1412 |
(...skipping 11 matching lines...) Expand all Loading... | |
1467 // old  : |A a a a a A*a*| | 1424 // old  : |A a a a a A*a*| |
1468 // new  : B b b b b B b b b b B | 1425 // new  : B b b b b B b b b b B |
1469 // after: |B b b b b B b b b b B| | 1426 // after: |B b b b b B b b b b B| |
1470 // new  : A a a a a A | 1427 // new  : A a a a a A |
1471 // after: |A a a a a A| |B b b b b B| | 1428 // after: |A a a a a A| |B b b b b B| |
1472 // track: |a| | 1429 // track: |a| |
1473 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_NoKeyframeAfterNew2) { | 1430 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_NoKeyframeAfterNew2) { |
1474 EXPECT_MEDIA_LOG(ContainsTrackBufferExhaustionSkipLog(133)); | 1431 EXPECT_MEDIA_LOG(ContainsTrackBufferExhaustionSkipLog(133)); |
1475 | 1432 |
1476 // Append 7 buffers at positions 10 through 16. | 1433 // Append 7 buffers at positions 10 through 16. |
1477 NewSegmentAppend(10, 7, &kDataA); | 1434 NewCodedFrameGroupAppend(10, 7, &kDataA); |
1478 | 1435 |
1479 // Seek to position 15, then move to position 16. | 1436 // Seek to position 15, then move to position 16. |
1480 Seek(15); | 1437 Seek(15); |
1481 CheckExpectedBuffers(15, 15, &kDataA); | 1438 CheckExpectedBuffers(15, 15, &kDataA); |
1482 | 1439 |
1483 // Now append 11 buffers at positions 5 through 15. | 1440 // Now append 11 buffers at positions 5 through 15. |
1484 NewSegmentAppend(5, 11, &kDataB); | 1441 NewCodedFrameGroupAppend(5, 11, &kDataB); |
1485 CheckExpectedRanges("{ [5,15) }"); | 1442 CheckExpectedRanges("{ [5,15) }"); |
1486 | 1443 |
1487 // Now do another end-overlap to split the range into two parts, where the | 1444 // Now do another end-overlap to split the range into two parts, where the |
1488 // 2nd range should have the next buffer position. | 1445 // 2nd range should have the next buffer position. |
1489 NewSegmentAppend(0, 6, &kDataA); | 1446 NewCodedFrameGroupAppend(0, 6, &kDataA); |
1490 CheckExpectedRanges("{ [0,5) [10,15) }"); | 1447 CheckExpectedRanges("{ [0,5) [10,15) }"); |
1491 | 1448 |
1492 // Check for data in the track buffer. | 1449 // Check for data in the track buffer. |
1493 CheckExpectedBuffers(16, 16, &kDataA); | 1450 CheckExpectedBuffers(16, 16, &kDataA); |
1494 | 1451 |
1495 // Now there's no data to fulfill the request. | 1452 // Now there's no data to fulfill the request. |
1496 CheckNoNextBuffer(); | 1453 CheckNoNextBuffer(); |
1497 | 1454 |
1498 // Add data to the 2nd range, should not be able to fulfill the next read | 1455 // Add data to the 2nd range, should not be able to fulfill the next read |
1499 // until we've added a keyframe. | 1456 // until we've added a keyframe. |
1500 NewSegmentAppend(15, 1, &kDataB); | 1457 NewCodedFrameGroupAppend(15, 1, &kDataB); |
1501 CheckNoNextBuffer(); | 1458 CheckNoNextBuffer(); |
1502 for (int i = 16; i <= 19; i++) { | 1459 for (int i = 16; i <= 19; i++) { |
1503 AppendBuffers(i, 1, &kDataB); | 1460 AppendBuffers(i, 1, &kDataB); |
1504 CheckNoNextBuffer(); | 1461 CheckNoNextBuffer(); |
1505 } | 1462 } |
1506 | 1463 |
1507 // Now append a keyframe. | 1464 // Now append a keyframe. |
1508 AppendBuffers(20, 1, &kDataB); | 1465 AppendBuffers(20, 1, &kDataB); |
1509 | 1466 |
1510 // We should be able to get the next buffer. | 1467 // We should be able to get the next buffer. |
1511 CheckExpectedBuffers(20, 20, &kDataB, true); | 1468 CheckExpectedBuffers(20, 20, &kDataB, true); |
1512 } | 1469 } |
1513 | 1470 |
1514 // This test covers the case where new buffers end-overlap an existing, selected | 1471 // This test covers the case where new buffers end-overlap an existing, selected |
1515 // range, and the next keyframe in a separate range. | 1472 // range, and the next keyframe in a separate range. |
1516 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 | 1473 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 |
1517 // old  : |A*a*a a a| |A a a a a| | 1474 // old  : |A*a*a a a| |A a a a a| |
1518 // new  : B b b b b B | 1475 // new  : B b b b b B |
1519 // after: |B b b b b B| |A a a a a| | 1476 // after: |B b b b b B| |A a a a a| |
1520 // track: |a a a a| | 1477 // track: |a a a a| |
1521 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_NoKeyframeAfterNew3) { | 1478 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_NoKeyframeAfterNew3) { |
1522 // Append 5 buffers at positions 5 through 9. | 1479 // Append 5 buffers at positions 5 through 9. |
1523 NewSegmentAppend(5, 5, &kDataA); | 1480 NewCodedFrameGroupAppend(5, 5, &kDataA); |
1524 | 1481 |
1525 // Append 5 buffers at positions 15 through 19. | 1482 // Append 5 buffers at positions 15 through 19. |
1526 NewSegmentAppend(15, 5, &kDataA); | 1483 NewCodedFrameGroupAppend(15, 5, &kDataA); |
1527 | 1484 |
1528 // Check expected range. | 1485 // Check expected range. |
1529 CheckExpectedRanges("{ [5,9) [15,19) }"); | 1486 CheckExpectedRanges("{ [5,9) [15,19) }"); |
1530 | 1487 |
1531 // Seek to position 5, then move to position 6. | 1488 // Seek to position 5, then move to position 6. |
1532 Seek(5); | 1489 Seek(5); |
1533 CheckExpectedBuffers(5, 5, &kDataA); | 1490 CheckExpectedBuffers(5, 5, &kDataA); |
1534 | 1491 |
1535 // Now append 6 buffers at positions 0 through 5. | 1492 // Now append 6 buffers at positions 0 through 5. |
1536 NewSegmentAppend(0, 6, &kDataB); | 1493 NewCodedFrameGroupAppend(0, 6, &kDataB); |
1537 | 1494 |
1538 // Check expected range. | 1495 // Check expected range. |
1539 CheckExpectedRanges("{ [0,5) [15,19) }"); | 1496 CheckExpectedRanges("{ [0,5) [15,19) }"); |
1540 | 1497 |
1541 // Check for data in the track buffer. | 1498 // Check for data in the track buffer. |
1542 CheckExpectedBuffers(6, 9, &kDataA); | 1499 CheckExpectedBuffers(6, 9, &kDataA); |
1543 | 1500 |
1544 // Now there's no data to fulfill the request. | 1501 // Now there's no data to fulfill the request. |
1545 CheckNoNextBuffer(); | 1502 CheckNoNextBuffer(); |
1546 | 1503 |
(...skipping 12 matching lines...) Expand all Loading... | |
1559 | 1516 |
1560 // This test covers the case when new buffers overlap the middle of a selected | 1517 // This test covers the case when new buffers overlap the middle of a selected |
1561 // range. This tests the case when there is no split and the next buffer is a | 1518 // range. This tests the case when there is no split and the next buffer is a |
1562 // keyframe. | 1519 // keyframe. |
1563 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 | 1520 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 |
1564 // old  : A a a a a*A*a a a a A a a a a | 1521 // old  : A a a a a*A*a a a a A a a a a |
1565 // new  : B b b b b | 1522 // new  : B b b b b |
1566 // after: A a a a a*B*b b b b A a a a a | 1523 // after: A a a a a*B*b b b b A a a a a |
1567 TEST_F(SourceBufferStreamTest, Middle_Overlap_Selected_1) { | 1524 TEST_F(SourceBufferStreamTest, Middle_Overlap_Selected_1) { |
1568 // Append 15 buffers at positions 0 through 14. | 1525 // Append 15 buffers at positions 0 through 14. |
1569 NewSegmentAppend(0, 15, &kDataA); | 1526 NewCodedFrameGroupAppend(0, 15, &kDataA); |
1570 | 1527 |
1571 // Seek to position 5. | 1528 // Seek to position 5. |
1572 Seek(5); | 1529 Seek(5); |
1573 | 1530 |
1574 // Now append 5 buffers at positions 5 through 9. | 1531 // Now append 5 buffers at positions 5 through 9. |
1575 NewSegmentAppend(5, 5, &kDataB); | 1532 NewCodedFrameGroupAppend(5, 5, &kDataB); |
1576 | 1533 |
1577 // Check expected range. | 1534 // Check expected range. |
1578 CheckExpectedRanges("{ [0,14) }"); | 1535 CheckExpectedRanges("{ [0,14) }"); |
1579 | 1536 |
1580 // Check for next data; should be new data. | 1537 // Check for next data; should be new data. |
1581 CheckExpectedBuffers(5, 9, &kDataB); | 1538 CheckExpectedBuffers(5, 9, &kDataB); |
1582 | 1539 |
1583 // Make sure all data is correct. | 1540 // Make sure all data is correct. |
1584 Seek(0); | 1541 Seek(0); |
1585 CheckExpectedBuffers(0, 4, &kDataA); | 1542 CheckExpectedBuffers(0, 4, &kDataA); |
1586 CheckExpectedBuffers(5, 9, &kDataB); | 1543 CheckExpectedBuffers(5, 9, &kDataB); |
1587 CheckExpectedBuffers(10, 14, &kDataA); | 1544 CheckExpectedBuffers(10, 14, &kDataA); |
1588 } | 1545 } |
1589 | 1546 |
1590 // This test covers the case when new buffers overlap the middle of a selected | 1547 // This test covers the case when new buffers overlap the middle of a selected |
1591 // range. This tests the case when there is no split and the next buffer is | 1548 // range. This tests the case when there is no split and the next buffer is |
1592 // after the new buffers. | 1549 // after the new buffers. |
1593 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 | 1550 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 |
1594 // old  : A a a a a A a a a a A*a*a a a | 1551 // old  : A a a a a A a a a a A*a*a a a |
1595 // new  : B b b b b | 1552 // new  : B b b b b |
1596 // after: A a a a a B b b b b A*a*a a a | 1553 // after: A a a a a B b b b b A*a*a a a |
1597 TEST_F(SourceBufferStreamTest, Middle_Overlap_Selected_2) { | 1554 TEST_F(SourceBufferStreamTest, Middle_Overlap_Selected_2) { |
1598 // Append 15 buffers at positions 0 through 14. | 1555 // Append 15 buffers at positions 0 through 14. |
1599 NewSegmentAppend(0, 15, &kDataA); | 1556 NewCodedFrameGroupAppend(0, 15, &kDataA); |
1600 | 1557 |
1601 // Seek to 10 then move to position 11. | 1558 // Seek to 10 then move to position 11. |
1602 Seek(10); | 1559 Seek(10); |
1603 CheckExpectedBuffers(10, 10, &kDataA); | 1560 CheckExpectedBuffers(10, 10, &kDataA); |
1604 | 1561 |
1605 // Now append 5 buffers at positions 5 through 9. | 1562 // Now append 5 buffers at positions 5 through 9. |
1606 NewSegmentAppend(5, 5, &kDataB); | 1563 NewCodedFrameGroupAppend(5, 5, &kDataB); |
1607 | 1564 |
1608 // Check expected range. | 1565 // Check expected range. |
1609 CheckExpectedRanges("{ [0,14) }"); | 1566 CheckExpectedRanges("{ [0,14) }"); |
1610 | 1567 |
1611 // Make sure data is correct. | 1568 // Make sure data is correct. |
1612 CheckExpectedBuffers(11, 14, &kDataA); | 1569 CheckExpectedBuffers(11, 14, &kDataA); |
1613 Seek(0); | 1570 Seek(0); |
1614 CheckExpectedBuffers(0, 4, &kDataA); | 1571 CheckExpectedBuffers(0, 4, &kDataA); |
1615 CheckExpectedBuffers(5, 9, &kDataB); | 1572 CheckExpectedBuffers(5, 9, &kDataB); |
1616 CheckExpectedBuffers(10, 14, &kDataA); | 1573 CheckExpectedBuffers(10, 14, &kDataA); |
1617 } | 1574 } |
1618 | 1575 |
1619 // This test covers the case when new buffers overlap the middle of a selected | 1576 // This test covers the case when new buffers overlap the middle of a selected |
1620 // range. This tests the case when there is a split and the next buffer is | 1577 // range. This tests the case when there is a split and the next buffer is |
1621 // before the new buffers. | 1578 // before the new buffers. |
1622 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 | 1579 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 |
1623 // old  : A a*a*a a A a a a a A a a a a | 1580 // old  : A a*a*a a A a a a a A a a a a |
1624 // new  : B b b | 1581 // new  : B b b |
1625 // after: A a*a*a a B b b| |A a a a a | 1582 // after: A a*a*a a B b b| |A a a a a |
1626 TEST_F(SourceBufferStreamTest, Middle_Overlap_Selected_3) { | 1583 TEST_F(SourceBufferStreamTest, Middle_Overlap_Selected_3) { |
1627 // Append 15 buffers at positions 0 through 14. | 1584 // Append 15 buffers at positions 0 through 14. |
1628 NewSegmentAppend(0, 15, &kDataA); | 1585 NewCodedFrameGroupAppend(0, 15, &kDataA); |
1629 | 1586 |
1630 // Seek to beginning then move to position 2. | 1587 // Seek to beginning then move to position 2. |
1631 Seek(0); | 1588 Seek(0); |
1632 CheckExpectedBuffers(0, 1, &kDataA); | 1589 CheckExpectedBuffers(0, 1, &kDataA); |
1633 | 1590 |
1634 // Now append 3 buffers at positions 5 through 7. | 1591 // Now append 3 buffers at positions 5 through 7. |
1635 NewSegmentAppend(5, 3, &kDataB); | 1592 NewCodedFrameGroupAppend(5, 3, &kDataB); |
1636 | 1593 |
1637 // Check expected range. | 1594 // Check expected range. |
1638 CheckExpectedRanges("{ [0,7) [10,14) }"); | 1595 CheckExpectedRanges("{ [0,7) [10,14) }"); |
1639 | 1596 |
1640 // Make sure data is correct. | 1597 // Make sure data is correct. |
1641 CheckExpectedBuffers(2, 4, &kDataA); | 1598 CheckExpectedBuffers(2, 4, &kDataA); |
1642 CheckExpectedBuffers(5, 7, &kDataB); | 1599 CheckExpectedBuffers(5, 7, &kDataB); |
1643 Seek(10); | 1600 Seek(10); |
1644 CheckExpectedBuffers(10, 14, &kDataA); | 1601 CheckExpectedBuffers(10, 14, &kDataA); |
1645 } | 1602 } |
1646 | 1603 |
1647 // This test covers the case when new buffers overlap the middle of a selected | 1604 // This test covers the case when new buffers overlap the middle of a selected |
1648 // range. This tests the case when there is a split and the next buffer is after | 1605 // range. This tests the case when there is a split and the next buffer is after |
1649 // the new buffers but before the split range. | 1606 // the new buffers but before the split range. |
1650 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 | 1607 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 |
1651 // old  : A a a a a A a a*a*a A a a a a | 1608 // old  : A a a a a A a a*a*a A a a a a |
1652 // new  : B b b | 1609 // new  : B b b |
1653 // after: |A a a a a B b b| |A a a a a| | 1610 // after: |A a a a a B b b| |A a a a a| |
1654 // track: |a a| | 1611 // track: |a a| |
1655 TEST_F(SourceBufferStreamTest, Middle_Overlap_Selected_4) { | 1612 TEST_F(SourceBufferStreamTest, Middle_Overlap_Selected_4) { |
1656 // Append 15 buffers at positions 0 through 14. | 1613 // Append 15 buffers at positions 0 through 14. |
1657 NewSegmentAppend(0, 15, &kDataA); | 1614 NewCodedFrameGroupAppend(0, 15, &kDataA); |
1658 | 1615 |
1659 // Seek to 5 then move to position 8. | 1616 // Seek to 5 then move to position 8. |
1660 Seek(5); | 1617 Seek(5); |
1661 CheckExpectedBuffers(5, 7, &kDataA); | 1618 CheckExpectedBuffers(5, 7, &kDataA); |
1662 | 1619 |
1663 // Now append 3 buffers at positions 5 through 7. | 1620 // Now append 3 buffers at positions 5 through 7. |
1664 NewSegmentAppend(5, 3, &kDataB); | 1621 NewCodedFrameGroupAppend(5, 3, &kDataB); |
1665 | 1622 |
1666 // Check expected range. | 1623 // Check expected range. |
1667 CheckExpectedRanges("{ [0,7) [10,14) }"); | 1624 CheckExpectedRanges("{ [0,7) [10,14) }"); |
1668 | 1625 |
1669 // Buffers 8 and 9 should be in the track buffer. | 1626 // Buffers 8 and 9 should be in the track buffer. |
1670 CheckExpectedBuffers(8, 9, &kDataA); | 1627 CheckExpectedBuffers(8, 9, &kDataA); |
1671 // The buffer immediately after the track buffer should be a keyframe. | 1628 // The buffer immediately after the track buffer should be a keyframe. |
1672 CheckExpectedBuffers(10, 10, &kDataA, true); | 1629 CheckExpectedBuffers(10, 10, &kDataA, true); |
1673 | 1630 |
1674 // Make sure all data is correct. | 1631 // Make sure all data is correct. |
1675 Seek(0); | 1632 Seek(0); |
1676 CheckExpectedBuffers(0, 4, &kDataA); | 1633 CheckExpectedBuffers(0, 4, &kDataA); |
1677 CheckExpectedBuffers(5, 7, &kDataB); | 1634 CheckExpectedBuffers(5, 7, &kDataB); |
1678 Seek(10); | 1635 Seek(10); |
1679 CheckExpectedBuffers(10, 14, &kDataA); | 1636 CheckExpectedBuffers(10, 14, &kDataA); |
1680 } | 1637 } |
1681 | 1638 |
1682 TEST_F(SourceBufferStreamTest, Overlap_OneByOne) { | 1639 TEST_F(SourceBufferStreamTest, Overlap_OneByOne) { |
1683 // Append 5 buffers starting at 10ms, 30ms apart. | 1640 // Append 5 buffers starting at 10ms, 30ms apart. |
1684 NewSegmentAppendOneByOne("10K 40 70 100 130"); | 1641 NewCodedFrameGroupAppendOneByOne("10K 40 70 100 130"); |
1685 | 1642 |
1686 // The range ends at 160, accounting for the last buffer's duration. | 1643 // The range ends at 160, accounting for the last buffer's duration. |
1687 CheckExpectedRangesByTimestamp("{ [10,160) }"); | 1644 CheckExpectedRangesByTimestamp("{ [10,160) }"); |
1688 | 1645 |
1689 // Overlap with 10 buffers starting at the beginning, appended one at a | 1646 // Overlap with 10 buffers starting at the beginning, appended one at a |
1690 // time. | 1647 // time. |
1691 NewSegmentAppend(0, 1, &kDataB); | 1648 NewCodedFrameGroupAppend(0, 1, &kDataB); |
1692 for (int i = 1; i < 10; i++) | 1649 for (int i = 1; i < 10; i++) |
1693 AppendBuffers(i, 1, &kDataB); | 1650 AppendBuffers(i, 1, &kDataB); |
1694 | 1651 |
1695 // All data should be replaced. | 1652 // All data should be replaced. |
1696 Seek(0); | 1653 Seek(0); |
1697 CheckExpectedRanges("{ [0,9) }"); | 1654 CheckExpectedRanges("{ [0,9) }"); |
1698 CheckExpectedBuffers(0, 9, &kDataB); | 1655 CheckExpectedBuffers(0, 9, &kDataB); |
1699 } | 1656 } |
1700 | 1657 |
1701 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_DeleteGroup) { | 1658 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_DeleteGroup) { |
1702 NewSegmentAppendOneByOne("10K 40 70 100 130K"); | 1659 NewCodedFrameGroupAppendOneByOne("10K 40 70 100 130K"); |
1703 CheckExpectedRangesByTimestamp("{ [10,160) }"); | 1660 CheckExpectedRangesByTimestamp("{ [10,160) }"); |
1704 | 1661 |
1705 // Seek to 130ms. | 1662 // Seek to 130ms. |
1706 SeekToTimestampMs(130); | 1663 SeekToTimestampMs(130); |
1707 | 1664 |
1708 // Overlap with a new segment from 0 to 130ms. | 1665 // Overlap with a new coded frame group from 0 to 130ms. |
1709 NewSegmentAppendOneByOne("0K 120D10"); | 1666 NewCodedFrameGroupAppendOneByOne("0K 120D10"); |
1710 | 1667 |
1711 // Next buffer should still be 130ms. | 1668 // Next buffer should still be 130ms. |
1712 CheckExpectedBuffers("130K"); | 1669 CheckExpectedBuffers("130K"); |
1713 | 1670 |
1714 // Check the final buffers is correct. | 1671 // Check the final buffers is correct. |
1715 SeekToTimestampMs(0); | 1672 SeekToTimestampMs(0); |
1716 CheckExpectedBuffers("0K 120 130K"); | 1673 CheckExpectedBuffers("0K 120 130K"); |
1717 } | 1674 } |
1718 | 1675 |
1719 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_BetweenMediaSegments) { | 1676 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_BetweenCodedFrameGroups) { |
1720 // Append 5 buffers starting at 110ms, 30ms apart. | 1677 // Append 5 buffers starting at 110ms, 30ms apart. |
1721 NewSegmentAppendOneByOne("110K 140 170 200 230"); | 1678 NewCodedFrameGroupAppendOneByOne("110K 140 170 200 230"); |
1722 CheckExpectedRangesByTimestamp("{ [110,260) }"); | 1679 CheckExpectedRangesByTimestamp("{ [110,260) }"); |
1723 | 1680 |
1724 // Now append 2 media segments from 0ms to 210ms, 30ms apart. Note that the | 1681 // Now append 2 coded frame groups from 0ms to 210ms, 30ms apart. Note that |
1725 // old keyframe 110ms falls in between these two segments. | 1682 // the |
1726 NewSegmentAppendOneByOne("0K 30 60 90"); | 1683 // old keyframe 110ms falls in between these two groups. |
1727 NewSegmentAppendOneByOne("120K 150 180 210"); | 1684 NewCodedFrameGroupAppendOneByOne("0K 30 60 90"); |
1685 NewCodedFrameGroupAppendOneByOne("120K 150 180 210"); | |
1728 CheckExpectedRangesByTimestamp("{ [0,240) }"); | 1686 CheckExpectedRangesByTimestamp("{ [0,240) }"); |
1729 | 1687 |
1730 // Check the final buffers is correct; the keyframe at 110ms should be | 1688 // Check the final buffers is correct; the keyframe at 110ms should be |
1731 // deleted. | 1689 // deleted. |
1732 SeekToTimestampMs(0); | 1690 SeekToTimestampMs(0); |
1733 CheckExpectedBuffers("0K 30 60 90 120K 150 180 210"); | 1691 CheckExpectedBuffers("0K 30 60 90 120K 150 180 210"); |
1734 } | 1692 } |
1735 | 1693 |
1736 // old : 10K 40 *70* 100K 125 130K | 1694 // old : 10K 40 *70* 100K 125 130K |
1737 // new : 0K 30 60 90 120K | 1695 // new : 0K 30 60 90 120K |
1738 // after: 0K 30 60 90 *120K* 130K | 1696 // after: 0K 30 60 90 *120K* 130K |
1739 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer) { | 1697 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer) { |
1740 EXPECT_MEDIA_LOG(ContainsTrackBufferExhaustionSkipLog(50)); | 1698 EXPECT_MEDIA_LOG(ContainsTrackBufferExhaustionSkipLog(50)); |
1741 | 1699 |
1742 NewSegmentAppendOneByOne("10K 40 70 100K 125 130D30K"); | 1700 NewCodedFrameGroupAppendOneByOne("10K 40 70 100K 125 130D30K"); |
1743 CheckExpectedRangesByTimestamp("{ [10,160) }"); | 1701 CheckExpectedRangesByTimestamp("{ [10,160) }"); |
1744 | 1702 |
1745 // Seek to 70ms. | 1703 // Seek to 70ms. |
1746 SeekToTimestampMs(70); | 1704 SeekToTimestampMs(70); |
1747 CheckExpectedBuffers("10K 40"); | 1705 CheckExpectedBuffers("10K 40"); |
1748 | 1706 |
1749 // Overlap with a new segment from 0 to 130ms. | 1707 // Overlap with a new coded frame group from 0 to 130ms. |
1750 NewSegmentAppendOneByOne("0K 30 60 90 120D10K"); | 1708 NewCodedFrameGroupAppendOneByOne("0K 30 60 90 120D10K"); |
1751 CheckExpectedRangesByTimestamp("{ [0,160) }"); | 1709 CheckExpectedRangesByTimestamp("{ [0,160) }"); |
1752 | 1710 |
1753 // Should return frame 70ms from the track buffer, then switch | 1711 // Should return frame 70ms from the track buffer, then switch |
1754 // to the new data at 120K, then switch back to the old data at 130K. The | 1712 // to the new data at 120K, then switch back to the old data at 130K. The |
1755 // frame at 125ms that depended on keyframe 100ms should have been deleted. | 1713 // frame at 125ms that depended on keyframe 100ms should have been deleted. |
1756 CheckExpectedBuffers("70 120K 130K"); | 1714 CheckExpectedBuffers("70 120K 130K"); |
1757 | 1715 |
1758 // Check the final result: should not include data from the track buffer. | 1716 // Check the final result: should not include data from the track buffer. |
1759 SeekToTimestampMs(0); | 1717 SeekToTimestampMs(0); |
1760 CheckExpectedBuffers("0K 30 60 90 120K 130K"); | 1718 CheckExpectedBuffers("0K 30 60 90 120K 130K"); |
1761 } | 1719 } |
1762 | 1720 |
1763 // Overlap the next keyframe after the end of the track buffer with a new | 1721 // Overlap the next keyframe after the end of the track buffer with a new |
1764 // keyframe. | 1722 // keyframe. |
1765 // old : 10K 40 *70* 100K 125 130K | 1723 // old : 10K 40 *70* 100K 125 130K |
1766 // new : 0K 30 60 90 120K | 1724 // new : 0K 30 60 90 120K |
1767 // after: 0K 30 60 90 *120K* 130K | 1725 // after: 0K 30 60 90 *120K* 130K |
1768 // track: 70 | 1726 // track: 70 |
1769 // new : 110K 130 | 1727 // new : 110K 130 |
1770 // after: 0K 30 60 90 *110K* 130 | 1728 // after: 0K 30 60 90 *110K* 130 |
1771 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer2) { | 1729 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer2) { |
1772 EXPECT_MEDIA_LOG(ContainsTrackBufferExhaustionSkipLog(40)); | 1730 EXPECT_MEDIA_LOG(ContainsTrackBufferExhaustionSkipLog(40)); |
1773 | 1731 |
1774 NewSegmentAppendOneByOne("10K 40 70 100K 125 130D30K"); | 1732 NewCodedFrameGroupAppendOneByOne("10K 40 70 100K 125 130D30K"); |
1775 CheckExpectedRangesByTimestamp("{ [10,160) }"); | 1733 CheckExpectedRangesByTimestamp("{ [10,160) }"); |
1776 | 1734 |
1777 // Seek to 70ms. | 1735 // Seek to 70ms. |
1778 SeekToTimestampMs(70); | 1736 SeekToTimestampMs(70); |
1779 CheckExpectedBuffers("10K 40"); | 1737 CheckExpectedBuffers("10K 40"); |
1780 | 1738 |
1781 // Overlap with a new segment from 0 to 120ms; 70ms and 100ms go in track | 1739 // Overlap with a new coded frame group from 0 to 120ms; 70ms and 100ms go in |
1740 // track | |
1782 // buffer. | 1741 // buffer. |
1783 NewSegmentAppendOneByOne("0K 30 60 90 120D10K"); | 1742 NewCodedFrameGroupAppendOneByOne("0K 30 60 90 120D10K"); |
1784 CheckExpectedRangesByTimestamp("{ [0,160) }"); | 1743 CheckExpectedRangesByTimestamp("{ [0,160) }"); |
1785 | 1744 |
1786 // Now overlap the keyframe at 120ms. | 1745 // Now overlap the keyframe at 120ms. |
1787 NewSegmentAppendOneByOne("110K 130"); | 1746 NewCodedFrameGroupAppendOneByOne("110K 130"); |
1788 | 1747 |
1789 // Should return frame 70ms from the track buffer. Then it should | 1748 // Should return frame 70ms from the track buffer. Then it should |
1790 // return the keyframe after the track buffer, which is at 110ms. | 1749 // return the keyframe after the track buffer, which is at 110ms. |
1791 CheckExpectedBuffers("70 110K 130"); | 1750 CheckExpectedBuffers("70 110K 130"); |
1792 } | 1751 } |
1793 | 1752 |
1794 // Overlap the next keyframe after the end of the track buffer without a | 1753 // Overlap the next keyframe after the end of the track buffer without a |
1795 // new keyframe. | 1754 // new keyframe. |
1796 // old : 10K 40 *70* 100K 125 130K | 1755 // old : 10K 40 *70* 100K 125 130K |
1797 // new : 0K 30 60 90 120K | 1756 // new : 0K 30 60 90 120K |
1798 // after: 0K 30 60 90 *120K* 130K | 1757 // after: 0K 30 60 90 *120K* 130K |
1799 // track: 70 | 1758 // track: 70 |
1800 // new : 50K 80 110 140 | 1759 // new : 50K 80 110 140 |
1801 // after: 0K 30 50K 80 110 140 * (waiting for keyframe) | 1760 // after: 0K 30 50K 80 110 140 * (waiting for keyframe) |
1802 // track: 70 | 1761 // track: 70 |
1803 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer3) { | 1762 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer3) { |
1804 EXPECT_MEDIA_LOG(ContainsTrackBufferExhaustionSkipLog(80)); | 1763 EXPECT_MEDIA_LOG(ContainsTrackBufferExhaustionSkipLog(80)); |
1805 | 1764 |
1806 NewSegmentAppendOneByOne("10K 40 70 100K 125 130D30K"); | 1765 NewCodedFrameGroupAppendOneByOne("10K 40 70 100K 125 130D30K"); |
1807 CheckExpectedRangesByTimestamp("{ [10,160) }"); | 1766 CheckExpectedRangesByTimestamp("{ [10,160) }"); |
1808 | 1767 |
1809 // Seek to 70ms. | 1768 // Seek to 70ms. |
1810 SeekToTimestampMs(70); | 1769 SeekToTimestampMs(70); |
1811 CheckExpectedBuffers("10K 40"); | 1770 CheckExpectedBuffers("10K 40"); |
1812 | 1771 |
1813 // Overlap with a new segment from 0 to 120ms; 70ms goes in track buffer. | 1772 // Overlap with a new coded frame group from 0 to 120ms; 70ms goes in track |
1814 NewSegmentAppendOneByOne("0K 30 60 90 120D10K"); | 1773 // buffer. |
1774 NewCodedFrameGroupAppendOneByOne("0K 30 60 90 120D10K"); | |
1815 CheckExpectedRangesByTimestamp("{ [0,160) }"); | 1775 CheckExpectedRangesByTimestamp("{ [0,160) }"); |
1816 | 1776 |
1817 // Now overlap the keyframe at 120ms and 130ms. | 1777 // Now overlap the keyframe at 120ms and 130ms. |
1818 NewSegmentAppendOneByOne("50K 80 110 140"); | 1778 NewCodedFrameGroupAppendOneByOne("50K 80 110 140"); |
1819 CheckExpectedRangesByTimestamp("{ [0,170) }"); | 1779 CheckExpectedRangesByTimestamp("{ [0,170) }"); |
1820 | 1780 |
1821 // Should have all the buffers from the track buffer, then stall. | 1781 // Should have all the buffers from the track buffer, then stall. |
1822 CheckExpectedBuffers("70"); | 1782 CheckExpectedBuffers("70"); |
1823 CheckNoNextBuffer(); | 1783 CheckNoNextBuffer(); |
1824 | 1784 |
1825 // Appending a keyframe should fulfill the read. | 1785 // Appending a keyframe should fulfill the read. |
1826 AppendBuffersOneByOne("150D30K"); | 1786 AppendBuffersOneByOne("150D30K"); |
1827 CheckExpectedBuffers("150K"); | 1787 CheckExpectedBuffers("150K"); |
1828 CheckNoNextBuffer(); | 1788 CheckNoNextBuffer(); |
1829 } | 1789 } |
1830 | 1790 |
1831 // Overlap the next keyframe after the end of the track buffer with a keyframe | 1791 // Overlap the next keyframe after the end of the track buffer with a keyframe |
1832 // that comes before the end of the track buffer. | 1792 // that comes before the end of the track buffer. |
1833 // old : 10K 40 *70* 100K 125 130K | 1793 // old : 10K 40 *70* 100K 125 130K |
1834 // new : 0K 30 60 90 120K | 1794 // new : 0K 30 60 90 120K |
1835 // after: 0K 30 60 90 *120K* 130K | 1795 // after: 0K 30 60 90 *120K* 130K |
1836 // track: 70 | 1796 // track: 70 |
1837 // new : 80K 110 140 | 1797 // new : 80K 110 140 |
1838 // after: 0K 30 60 *80K* 110 140 | 1798 // after: 0K 30 60 *80K* 110 140 |
1839 // track: 70 | 1799 // track: 70 |
1840 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer4) { | 1800 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer4) { |
1841 NewSegmentAppendOneByOne("10K 40 70 100K 125 130D30K"); | 1801 NewCodedFrameGroupAppendOneByOne("10K 40 70 100K 125 130D30K"); |
1842 CheckExpectedRangesByTimestamp("{ [10,160) }"); | 1802 CheckExpectedRangesByTimestamp("{ [10,160) }"); |
1843 | 1803 |
1844 // Seek to 70ms. | 1804 // Seek to 70ms. |
1845 SeekToTimestampMs(70); | 1805 SeekToTimestampMs(70); |
1846 CheckExpectedBuffers("10K 40"); | 1806 CheckExpectedBuffers("10K 40"); |
1847 | 1807 |
1848 // Overlap with a new segment from 0 to 120ms; 70ms and 100ms go in track | 1808 // Overlap with a new coded frame group from 0 to 120ms; 70ms and 100ms go in |
1809 // track | |
1849 // buffer. | 1810 // buffer. |
1850 NewSegmentAppendOneByOne("0K 30 60 90 120D10K"); | 1811 NewCodedFrameGroupAppendOneByOne("0K 30 60 90 120D10K"); |
1851 CheckExpectedRangesByTimestamp("{ [0,160) }"); | 1812 CheckExpectedRangesByTimestamp("{ [0,160) }"); |
1852 | 1813 |
1853 // Now append a keyframe at 80ms. | 1814 // Now append a keyframe at 80ms. |
1854 NewSegmentAppendOneByOne("80K 110 140"); | 1815 NewCodedFrameGroupAppendOneByOne("80K 110 140"); |
1855 | 1816 |
1856 CheckExpectedBuffers("70 80K 110 140"); | 1817 CheckExpectedBuffers("70 80K 110 140"); |
1857 CheckNoNextBuffer(); | 1818 CheckNoNextBuffer(); |
1858 } | 1819 } |
1859 | 1820 |
1860 // Overlap the next keyframe after the end of the track buffer with a keyframe | 1821 // Overlap the next keyframe after the end of the track buffer with a keyframe |
1861 // that comes before the end of the track buffer, when the selected stream was | 1822 // that comes before the end of the track buffer, when the selected stream was |
1862 // waiting for the next keyframe. | 1823 // waiting for the next keyframe. |
1863 // old : 10K 40 *70* 100K | 1824 // old : 10K 40 *70* 100K |
1864 // new : 0K 30 60 90 120 | 1825 // new : 0K 30 60 90 120 |
1865 // after: 0K 30 60 90 120 * (waiting for keyframe) | 1826 // after: 0K 30 60 90 120 * (waiting for keyframe) |
1866 // track: 70 | 1827 // track: 70 |
1867 // new : 80K 110 140 | 1828 // new : 80K 110 140 |
1868 // after: 0K 30 60 *80K* 110 140 | 1829 // after: 0K 30 60 *80K* 110 140 |
1869 // track: 70 | 1830 // track: 70 |
1870 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer5) { | 1831 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer5) { |
1871 NewSegmentAppendOneByOne("10K 40 70 100K"); | 1832 NewCodedFrameGroupAppendOneByOne("10K 40 70 100K"); |
1872 CheckExpectedRangesByTimestamp("{ [10,130) }"); | 1833 CheckExpectedRangesByTimestamp("{ [10,130) }"); |
1873 | 1834 |
1874 // Seek to 70ms. | 1835 // Seek to 70ms. |
1875 SeekToTimestampMs(70); | 1836 SeekToTimestampMs(70); |
1876 CheckExpectedBuffers("10K 40"); | 1837 CheckExpectedBuffers("10K 40"); |
1877 | 1838 |
1878 // Overlap with a new segment from 0 to 120ms; 70ms goes in track | 1839 // Overlap with a new coded frame group from 0 to 120ms; 70ms goes in track |
1879 // buffer. | 1840 // buffer. |
1880 NewSegmentAppendOneByOne("0K 30 60 90 120"); | 1841 NewCodedFrameGroupAppendOneByOne("0K 30 60 90 120"); |
1881 CheckExpectedRangesByTimestamp("{ [0,150) }"); | 1842 CheckExpectedRangesByTimestamp("{ [0,150) }"); |
1882 | 1843 |
1883 // Now append a keyframe at 80ms. | 1844 // Now append a keyframe at 80ms. |
1884 NewSegmentAppendOneByOne("80K 110 140"); | 1845 NewCodedFrameGroupAppendOneByOne("80K 110 140"); |
1885 | 1846 |
1886 CheckExpectedBuffers("70 80K 110 140"); | 1847 CheckExpectedBuffers("70 80K 110 140"); |
1887 CheckNoNextBuffer(); | 1848 CheckNoNextBuffer(); |
1888 } | 1849 } |
1889 | 1850 |
1890 // Test that appending to a different range while there is data in | 1851 // Test that appending to a different range while there is data in |
1891 // the track buffer doesn't affect the selected range or track buffer state. | 1852 // the track buffer doesn't affect the selected range or track buffer state. |
1892 // old : 10K 40 *70* 100K 125 130K ... 200K 230 | 1853 // old : 10K 40 *70* 100K 125 130K ... 200K 230 |
1893 // new : 0K 30 60 90 120K | 1854 // new : 0K 30 60 90 120K |
1894 // after: 0K 30 60 90 *120K* 130K ... 200K 230 | 1855 // after: 0K 30 60 90 *120K* 130K ... 200K 230 |
1895 // track: 70 | 1856 // track: 70 |
1896 // old : 0K 30 60 90 *120K* 130K ... 200K 230 | 1857 // old : 0K 30 60 90 *120K* 130K ... 200K 230 |
1897 // new : 260K 290 | 1858 // new : 260K 290 |
1898 // after: 0K 30 60 90 *120K* 130K ... 200K 230 260K 290 | 1859 // after: 0K 30 60 90 *120K* 130K ... 200K 230 260K 290 |
1899 // track: 70 | 1860 // track: 70 |
1900 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer6) { | 1861 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer6) { |
1901 EXPECT_MEDIA_LOG(ContainsTrackBufferExhaustionSkipLog(50)); | 1862 EXPECT_MEDIA_LOG(ContainsTrackBufferExhaustionSkipLog(50)); |
1902 | 1863 |
1903 NewSegmentAppendOneByOne("10K 40 70 100K 125 130D30K"); | 1864 NewCodedFrameGroupAppendOneByOne("10K 40 70 100K 125 130D30K"); |
1904 NewSegmentAppendOneByOne("200K 230"); | 1865 NewCodedFrameGroupAppendOneByOne("200K 230"); |
1905 CheckExpectedRangesByTimestamp("{ [10,160) [200,260) }"); | 1866 CheckExpectedRangesByTimestamp("{ [10,160) [200,260) }"); |
1906 | 1867 |
1907 // Seek to 70ms. | 1868 // Seek to 70ms. |
1908 SeekToTimestampMs(70); | 1869 SeekToTimestampMs(70); |
1909 CheckExpectedBuffers("10K 40"); | 1870 CheckExpectedBuffers("10K 40"); |
1910 | 1871 |
1911 // Overlap with a new segment from 0 to 120ms. | 1872 // Overlap with a new coded frame group from 0 to 120ms. |
1912 NewSegmentAppendOneByOne("0K 30 60 90 120D10K"); | 1873 NewCodedFrameGroupAppendOneByOne("0K 30 60 90 120D10K"); |
1913 CheckExpectedRangesByTimestamp("{ [0,160) [200,260) }"); | 1874 CheckExpectedRangesByTimestamp("{ [0,160) [200,260) }"); |
1914 | 1875 |
1915 // Verify that 70 gets read out of the track buffer. | 1876 // Verify that 70 gets read out of the track buffer. |
1916 CheckExpectedBuffers("70"); | 1877 CheckExpectedBuffers("70"); |
1917 | 1878 |
1918 // Append more data to the unselected range. | 1879 // Append more data to the unselected range. |
1919 NewSegmentAppendOneByOne("260K 290"); | 1880 NewCodedFrameGroupAppendOneByOne("260K 290"); |
1920 CheckExpectedRangesByTimestamp("{ [0,160) [200,320) }"); | 1881 CheckExpectedRangesByTimestamp("{ [0,160) [200,320) }"); |
1921 | 1882 |
1922 CheckExpectedBuffers("120K 130K"); | 1883 CheckExpectedBuffers("120K 130K"); |
1923 CheckNoNextBuffer(); | 1884 CheckNoNextBuffer(); |
1924 | 1885 |
1925 // Check the final result: should not include data from the track buffer. | 1886 // Check the final result: should not include data from the track buffer. |
1926 SeekToTimestampMs(0); | 1887 SeekToTimestampMs(0); |
1927 CheckExpectedBuffers("0K 30 60 90 120K 130K"); | 1888 CheckExpectedBuffers("0K 30 60 90 120K 130K"); |
1928 CheckNoNextBuffer(); | 1889 CheckNoNextBuffer(); |
1929 } | 1890 } |
1930 | 1891 |
1931 TEST_F(SourceBufferStreamTest, Seek_Keyframe) { | 1892 TEST_F(SourceBufferStreamTest, Seek_Keyframe) { |
1932 // Append 6 buffers at positions 0 through 5. | 1893 // Append 6 buffers at positions 0 through 5. |
1933 NewSegmentAppend(0, 6); | 1894 NewCodedFrameGroupAppend(0, 6); |
1934 | 1895 |
1935 // Seek to beginning. | 1896 // Seek to beginning. |
1936 Seek(0); | 1897 Seek(0); |
1937 CheckExpectedBuffers(0, 5, true); | 1898 CheckExpectedBuffers(0, 5, true); |
1938 } | 1899 } |
1939 | 1900 |
1940 TEST_F(SourceBufferStreamTest, Seek_NonKeyframe) { | 1901 TEST_F(SourceBufferStreamTest, Seek_NonKeyframe) { |
1941 // Append 15 buffers at positions 0 through 14. | 1902 // Append 15 buffers at positions 0 through 14. |
1942 NewSegmentAppend(0, 15); | 1903 NewCodedFrameGroupAppend(0, 15); |
1943 | 1904 |
1944 // Seek to buffer at position 13. | 1905 // Seek to buffer at position 13. |
1945 Seek(13); | 1906 Seek(13); |
1946 | 1907 |
1947 // Expect seeking back to the nearest keyframe. | 1908 // Expect seeking back to the nearest keyframe. |
1948 CheckExpectedBuffers(10, 14, true); | 1909 CheckExpectedBuffers(10, 14, true); |
1949 | 1910 |
1950 // Seek to buffer at position 3. | 1911 // Seek to buffer at position 3. |
1951 Seek(3); | 1912 Seek(3); |
1952 | 1913 |
1953 // Expect seeking back to the nearest keyframe. | 1914 // Expect seeking back to the nearest keyframe. |
1954 CheckExpectedBuffers(0, 3, true); | 1915 CheckExpectedBuffers(0, 3, true); |
1955 } | 1916 } |
1956 | 1917 |
1957 TEST_F(SourceBufferStreamTest, Seek_NotBuffered) { | 1918 TEST_F(SourceBufferStreamTest, Seek_NotBuffered) { |
1958 // Seek to beginning. | 1919 // Seek to beginning. |
1959 Seek(0); | 1920 Seek(0); |
1960 | 1921 |
1961 // Try to get buffer; nothing's appended. | 1922 // Try to get buffer; nothing's appended. |
1962 CheckNoNextBuffer(); | 1923 CheckNoNextBuffer(); |
1963 | 1924 |
1964 // Append 2 buffers at positions 0. | 1925 // Append 2 buffers at positions 0. |
1965 NewSegmentAppend(0, 2); | 1926 NewCodedFrameGroupAppend(0, 2); |
1966 Seek(0); | 1927 Seek(0); |
1967 CheckExpectedBuffers(0, 1); | 1928 CheckExpectedBuffers(0, 1); |
1968 | 1929 |
1969 // Try to get buffer out of range. | 1930 // Try to get buffer out of range. |
1970 Seek(2); | 1931 Seek(2); |
1971 CheckNoNextBuffer(); | 1932 CheckNoNextBuffer(); |
1972 } | 1933 } |
1973 | 1934 |
1974 TEST_F(SourceBufferStreamTest, Seek_InBetweenTimestamps) { | 1935 TEST_F(SourceBufferStreamTest, Seek_InBetweenTimestamps) { |
1975 // Append 10 buffers at positions 0 through 9. | 1936 // Append 10 buffers at positions 0 through 9. |
1976 NewSegmentAppend(0, 10); | 1937 NewCodedFrameGroupAppend(0, 10); |
1977 | 1938 |
1978 base::TimeDelta bump = frame_duration() / 4; | 1939 base::TimeDelta bump = frame_duration() / 4; |
1979 CHECK(bump > base::TimeDelta()); | 1940 CHECK(bump > base::TimeDelta()); |
1980 | 1941 |
1981 // Seek to buffer a little after position 5. | 1942 // Seek to buffer a little after position 5. |
1982 stream_->Seek(5 * frame_duration() + bump); | 1943 stream_->Seek(5 * frame_duration() + bump); |
1983 CheckExpectedBuffers(5, 5, true); | 1944 CheckExpectedBuffers(5, 5, true); |
1984 | 1945 |
1985 // Seek to buffer a little before position 5. | 1946 // Seek to buffer a little before position 5. |
1986 stream_->Seek(5 * frame_duration() - bump); | 1947 stream_->Seek(5 * frame_duration() - bump); |
1987 CheckExpectedBuffers(0, 0, true); | 1948 CheckExpectedBuffers(0, 0, true); |
1988 } | 1949 } |
1989 | 1950 |
1990 // This test will do a complete overlap of an existing range in order to add | 1951 // This test will do a complete overlap of an existing range in order to add |
1991 // buffers to the track buffers. Then the test does a seek to another part of | 1952 // buffers to the track buffers. Then the test does a seek to another part of |
1992 // the stream. The SourceBufferStream should clear its internal track buffer in | 1953 // the stream. The SourceBufferStream should clear its internal track buffer in |
1993 // response to the Seek(). | 1954 // response to the Seek(). |
1994 TEST_F(SourceBufferStreamTest, Seek_After_TrackBuffer_Filled) { | 1955 TEST_F(SourceBufferStreamTest, Seek_After_TrackBuffer_Filled) { |
1995 // Append 10 buffers at positions 5 through 14. | 1956 // Append 10 buffers at positions 5 through 14. |
1996 NewSegmentAppend(5, 10, &kDataA); | 1957 NewCodedFrameGroupAppend(5, 10, &kDataA); |
1997 | 1958 |
1998 // Seek to buffer at position 5 and get next buffer. | 1959 // Seek to buffer at position 5 and get next buffer. |
1999 Seek(5); | 1960 Seek(5); |
2000 CheckExpectedBuffers(5, 5, &kDataA); | 1961 CheckExpectedBuffers(5, 5, &kDataA); |
2001 | 1962 |
2002 // Do a complete overlap by appending 20 buffers at positions 0 through 19. | 1963 // Do a complete overlap by appending 20 buffers at positions 0 through 19. |
2003 NewSegmentAppend(0, 20, &kDataB); | 1964 NewCodedFrameGroupAppend(0, 20, &kDataB); |
2004 | 1965 |
2005 // Check range is correct. | 1966 // Check range is correct. |
2006 CheckExpectedRanges("{ [0,19) }"); | 1967 CheckExpectedRanges("{ [0,19) }"); |
2007 | 1968 |
2008 // Seek to beginning; all data should be new. | 1969 // Seek to beginning; all data should be new. |
2009 Seek(0); | 1970 Seek(0); |
2010 CheckExpectedBuffers(0, 19, &kDataB); | 1971 CheckExpectedBuffers(0, 19, &kDataB); |
2011 | 1972 |
2012 // Check range continues to be correct. | 1973 // Check range continues to be correct. |
2013 CheckExpectedRanges("{ [0,19) }"); | 1974 CheckExpectedRanges("{ [0,19) }"); |
2014 } | 1975 } |
2015 | 1976 |
2016 TEST_F(SourceBufferStreamTest, Seek_StartOfSegment) { | 1977 TEST_F(SourceBufferStreamTest, Seek_StartOfGroup) { |
2017 base::TimeDelta bump = frame_duration() / 4; | 1978 base::TimeDelta bump = frame_duration() / 4; |
2018 CHECK(bump > base::TimeDelta()); | 1979 CHECK(bump > base::TimeDelta()); |
2019 | 1980 |
2020 // Append 5 buffers at position (5 + |bump|) through 9, where the media | 1981 // Append 5 buffers at position (5 + |bump|) through 9, where the coded frame |
2021 // segment begins at position 5. | 1982 // group begins at position 5. |
2022 Seek(5); | 1983 Seek(5); |
2023 NewSegmentAppend_OffsetFirstBuffer(5, 5, bump); | 1984 NewCodedFrameGroupAppend_OffsetFirstBuffer(5, 5, bump); |
2024 scoped_refptr<StreamParserBuffer> buffer; | 1985 scoped_refptr<StreamParserBuffer> buffer; |
2025 | 1986 |
2026 // GetNextBuffer() should return the next buffer at position (5 + |bump|). | 1987 // GetNextBuffer() should return the next buffer at position (5 + |bump|). |
2027 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kSuccess); | 1988 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kSuccess); |
2028 EXPECT_EQ(buffer->GetDecodeTimestamp(), | 1989 EXPECT_EQ(buffer->GetDecodeTimestamp(), |
2029 DecodeTimestamp::FromPresentationTime(5 * frame_duration() + bump)); | 1990 DecodeTimestamp::FromPresentationTime(5 * frame_duration() + bump)); |
2030 | 1991 |
2031 // Check rest of buffers. | 1992 // Check rest of buffers. |
2032 CheckExpectedBuffers(6, 9); | 1993 CheckExpectedBuffers(6, 9); |
2033 | 1994 |
2034 // Seek to position 15. | 1995 // Seek to position 15. |
2035 Seek(15); | 1996 Seek(15); |
2036 | 1997 |
2037 // Append 5 buffers at positions (15 + |bump|) through 19, where the media | 1998 // Append 5 buffers at positions (15 + |bump|) through 19, where the coded |
2038 // segment begins at 15. | 1999 // frame group begins at 15. |
2039 NewSegmentAppend_OffsetFirstBuffer(15, 5, bump); | 2000 NewCodedFrameGroupAppend_OffsetFirstBuffer(15, 5, bump); |
2040 | 2001 |
2041 // GetNextBuffer() should return the next buffer at position (15 + |bump|). | 2002 // GetNextBuffer() should return the next buffer at position (15 + |bump|). |
2042 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kSuccess); | 2003 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kSuccess); |
2043 EXPECT_EQ(buffer->GetDecodeTimestamp(), DecodeTimestamp::FromPresentationTime( | 2004 EXPECT_EQ(buffer->GetDecodeTimestamp(), DecodeTimestamp::FromPresentationTime( |
2044 15 * frame_duration() + bump)); | 2005 15 * frame_duration() + bump)); |
2045 | 2006 |
2046 // Check rest of buffers. | 2007 // Check rest of buffers. |
2047 CheckExpectedBuffers(16, 19); | 2008 CheckExpectedBuffers(16, 19); |
2048 } | 2009 } |
2049 | 2010 |
2050 TEST_F(SourceBufferStreamTest, Seek_BeforeStartOfSegment) { | 2011 TEST_F(SourceBufferStreamTest, Seek_BeforeStartOfGroup) { |
2051 // Append 10 buffers at positions 5 through 14. | 2012 // Append 10 buffers at positions 5 through 14. |
2052 NewSegmentAppend(5, 10); | 2013 NewCodedFrameGroupAppend(5, 10); |
2053 | 2014 |
2054 // Seek to a time before the first buffer in the range. | 2015 // Seek to a time before the first buffer in the range. |
2055 Seek(0); | 2016 Seek(0); |
2056 | 2017 |
2057 // Should return buffers from the beginning of the range. | 2018 // Should return buffers from the beginning of the range. |
2058 CheckExpectedBuffers(5, 14); | 2019 CheckExpectedBuffers(5, 14); |
2059 } | 2020 } |
2060 | 2021 |
2061 TEST_F(SourceBufferStreamTest, OldSeekPoint_CompleteOverlap) { | 2022 TEST_F(SourceBufferStreamTest, OldSeekPoint_CompleteOverlap) { |
2062 // Append 5 buffers at positions 0 through 4. | 2023 // Append 5 buffers at positions 0 through 4. |
2063 NewSegmentAppend(0, 4); | 2024 NewCodedFrameGroupAppend(0, 4); |
2064 | 2025 |
2065 // Append 5 buffers at positions 10 through 14, and seek to the beginning of | 2026 // Append 5 buffers at positions 10 through 14, and seek to the beginning of |
2066 // this range. | 2027 // this range. |
2067 NewSegmentAppend(10, 5); | 2028 NewCodedFrameGroupAppend(10, 5); |
2068 Seek(10); | 2029 Seek(10); |
2069 | 2030 |
2070 // Now seek to the beginning of the first range. | 2031 // Now seek to the beginning of the first range. |
2071 Seek(0); | 2032 Seek(0); |
2072 | 2033 |
2073 // Completely overlap the old seek point. | 2034 // Completely overlap the old seek point. |
2074 NewSegmentAppend(5, 15); | 2035 NewCodedFrameGroupAppend(5, 15); |
2075 | 2036 |
2076 // The GetNextBuffer() call should respect the 2nd seek point. | 2037 // The GetNextBuffer() call should respect the 2nd seek point. |
2077 CheckExpectedBuffers(0, 0); | 2038 CheckExpectedBuffers(0, 0); |
2078 } | 2039 } |
2079 | 2040 |
2080 TEST_F(SourceBufferStreamTest, OldSeekPoint_CompleteOverlap_Pending) { | 2041 TEST_F(SourceBufferStreamTest, OldSeekPoint_CompleteOverlap_Pending) { |
2081 // Append 2 buffers at positions 0 through 1. | 2042 // Append 2 buffers at positions 0 through 1. |
2082 NewSegmentAppend(0, 2); | 2043 NewCodedFrameGroupAppend(0, 2); |
2083 | 2044 |
2084 // Append 5 buffers at positions 15 through 19 and seek to beginning of the | 2045 // Append 5 buffers at positions 15 through 19 and seek to beginning of the |
2085 // range. | 2046 // range. |
2086 NewSegmentAppend(15, 5); | 2047 NewCodedFrameGroupAppend(15, 5); |
2087 Seek(15); | 2048 Seek(15); |
2088 | 2049 |
2089 // Now seek position 5. | 2050 // Now seek position 5. |
2090 Seek(5); | 2051 Seek(5); |
2091 | 2052 |
2092 // Completely overlap the old seek point. | 2053 // Completely overlap the old seek point. |
2093 NewSegmentAppend(10, 15); | 2054 NewCodedFrameGroupAppend(10, 15); |
2094 | 2055 |
2095 // The seek at position 5 should still be pending. | 2056 // The seek at position 5 should still be pending. |
2096 CheckNoNextBuffer(); | 2057 CheckNoNextBuffer(); |
2097 } | 2058 } |
2098 | 2059 |
2099 TEST_F(SourceBufferStreamTest, OldSeekPoint_MiddleOverlap) { | 2060 TEST_F(SourceBufferStreamTest, OldSeekPoint_MiddleOverlap) { |
2100 // Append 2 buffers at positions 0 through 1. | 2061 // Append 2 buffers at positions 0 through 1. |
2101 NewSegmentAppend(0, 2); | 2062 NewCodedFrameGroupAppend(0, 2); |
2102 | 2063 |
2103 // Append 15 buffers at positions 5 through 19 and seek to position 15. | 2064 // Append 15 buffers at positions 5 through 19 and seek to position 15. |
2104 NewSegmentAppend(5, 15); | 2065 NewCodedFrameGroupAppend(5, 15); |
2105 Seek(15); | 2066 Seek(15); |
2106 | 2067 |
2107 // Now seek to the beginning of the stream. | 2068 // Now seek to the beginning of the stream. |
2108 Seek(0); | 2069 Seek(0); |
2109 | 2070 |
2110 // Overlap the middle of the range such that there are now three ranges. | 2071 // Overlap the middle of the range such that there are now three ranges. |
2111 NewSegmentAppend(10, 3); | 2072 NewCodedFrameGroupAppend(10, 3); |
2112 CheckExpectedRanges("{ [0,1) [5,12) [15,19) }"); | 2073 CheckExpectedRanges("{ [0,1) [5,12) [15,19) }"); |
2113 | 2074 |
2114 // The GetNextBuffer() call should respect the 2nd seek point. | 2075 // The GetNextBuffer() call should respect the 2nd seek point. |
2115 CheckExpectedBuffers(0, 0); | 2076 CheckExpectedBuffers(0, 0); |
2116 } | 2077 } |
2117 | 2078 |
2118 TEST_F(SourceBufferStreamTest, OldSeekPoint_MiddleOverlap_Pending) { | 2079 TEST_F(SourceBufferStreamTest, OldSeekPoint_MiddleOverlap_Pending) { |
2119 // Append 2 buffers at positions 0 through 1. | 2080 // Append 2 buffers at positions 0 through 1. |
2120 NewSegmentAppend(0, 2); | 2081 NewCodedFrameGroupAppend(0, 2); |
2121 | 2082 |
2122 // Append 15 buffers at positions 10 through 24 and seek to position 20. | 2083 // Append 15 buffers at positions 10 through 24 and seek to position 20. |
2123 NewSegmentAppend(10, 15); | 2084 NewCodedFrameGroupAppend(10, 15); |
2124 Seek(20); | 2085 Seek(20); |
2125 | 2086 |
2126 // Now seek to position 5. | 2087 // Now seek to position 5. |
2127 Seek(5); | 2088 Seek(5); |
2128 | 2089 |
2129 // Overlap the middle of the range such that it is now split into two ranges. | 2090 // Overlap the middle of the range such that it is now split into two ranges. |
2130 NewSegmentAppend(15, 3); | 2091 NewCodedFrameGroupAppend(15, 3); |
2131 CheckExpectedRanges("{ [0,1) [10,17) [20,24) }"); | 2092 CheckExpectedRanges("{ [0,1) [10,17) [20,24) }"); |
2132 | 2093 |
2133 // The seek at position 5 should still be pending. | 2094 // The seek at position 5 should still be pending. |
2134 CheckNoNextBuffer(); | 2095 CheckNoNextBuffer(); |
2135 } | 2096 } |
2136 | 2097 |
2137 TEST_F(SourceBufferStreamTest, OldSeekPoint_StartOverlap) { | 2098 TEST_F(SourceBufferStreamTest, OldSeekPoint_StartOverlap) { |
2138 // Append 2 buffers at positions 0 through 1. | 2099 // Append 2 buffers at positions 0 through 1. |
2139 NewSegmentAppend(0, 2); | 2100 NewCodedFrameGroupAppend(0, 2); |
2140 | 2101 |
2141 // Append 15 buffers at positions 5 through 19 and seek to position 15. | 2102 // Append 15 buffers at positions 5 through 19 and seek to position 15. |
2142 NewSegmentAppend(5, 15); | 2103 NewCodedFrameGroupAppend(5, 15); |
2143 Seek(15); | 2104 Seek(15); |
2144 | 2105 |
2145 // Now seek to the beginning of the stream. | 2106 // Now seek to the beginning of the stream. |
2146 Seek(0); | 2107 Seek(0); |
2147 | 2108 |
2148 // Start overlap the old seek point. | 2109 // Start overlap the old seek point. |
2149 NewSegmentAppend(10, 10); | 2110 NewCodedFrameGroupAppend(10, 10); |
2150 | 2111 |
2151 // The GetNextBuffer() call should respect the 2nd seek point. | 2112 // The GetNextBuffer() call should respect the 2nd seek point. |
2152 CheckExpectedBuffers(0, 0); | 2113 CheckExpectedBuffers(0, 0); |
2153 } | 2114 } |
2154 | 2115 |
2155 TEST_F(SourceBufferStreamTest, OldSeekPoint_StartOverlap_Pending) { | 2116 TEST_F(SourceBufferStreamTest, OldSeekPoint_StartOverlap_Pending) { |
2156 // Append 2 buffers at positions 0 through 1. | 2117 // Append 2 buffers at positions 0 through 1. |
2157 NewSegmentAppend(0, 2); | 2118 NewCodedFrameGroupAppend(0, 2); |
2158 | 2119 |
2159 // Append 15 buffers at positions 10 through 24 and seek to position 20. | 2120 // Append 15 buffers at positions 10 through 24 and seek to position 20. |
2160 NewSegmentAppend(10, 15); | 2121 NewCodedFrameGroupAppend(10, 15); |
2161 Seek(20); | 2122 Seek(20); |
2162 | 2123 |
2163 // Now seek to position 5. | 2124 // Now seek to position 5. |
2164 Seek(5); | 2125 Seek(5); |
2165 | 2126 |
2166 // Start overlap the old seek point. | 2127 // Start overlap the old seek point. |
2167 NewSegmentAppend(15, 10); | 2128 NewCodedFrameGroupAppend(15, 10); |
2168 | 2129 |
2169 // The seek at time 0 should still be pending. | 2130 // The seek at time 0 should still be pending. |
2170 CheckNoNextBuffer(); | 2131 CheckNoNextBuffer(); |
2171 } | 2132 } |
2172 | 2133 |
2173 TEST_F(SourceBufferStreamTest, OldSeekPoint_EndOverlap) { | 2134 TEST_F(SourceBufferStreamTest, OldSeekPoint_EndOverlap) { |
2174 // Append 5 buffers at positions 0 through 4. | 2135 // Append 5 buffers at positions 0 through 4. |
2175 NewSegmentAppend(0, 4); | 2136 NewCodedFrameGroupAppend(0, 4); |
2176 | 2137 |
2177 // Append 15 buffers at positions 10 through 24 and seek to start of range. | 2138 // Append 15 buffers at positions 10 through 24 and seek to start of range. |
2178 NewSegmentAppend(10, 15); | 2139 NewCodedFrameGroupAppend(10, 15); |
2179 Seek(10); | 2140 Seek(10); |
2180 | 2141 |
2181 // Now seek to the beginning of the stream. | 2142 // Now seek to the beginning of the stream. |
2182 Seek(0); | 2143 Seek(0); |
2183 | 2144 |
2184 // End overlap the old seek point. | 2145 // End overlap the old seek point. |
2185 NewSegmentAppend(5, 10); | 2146 NewCodedFrameGroupAppend(5, 10); |
2186 | 2147 |
2187 // The GetNextBuffer() call should respect the 2nd seek point. | 2148 // The GetNextBuffer() call should respect the 2nd seek point. |
2188 CheckExpectedBuffers(0, 0); | 2149 CheckExpectedBuffers(0, 0); |
2189 } | 2150 } |
2190 | 2151 |
2191 TEST_F(SourceBufferStreamTest, OldSeekPoint_EndOverlap_Pending) { | 2152 TEST_F(SourceBufferStreamTest, OldSeekPoint_EndOverlap_Pending) { |
2192 // Append 2 buffers at positions 0 through 1. | 2153 // Append 2 buffers at positions 0 through 1. |
2193 NewSegmentAppend(0, 2); | 2154 NewCodedFrameGroupAppend(0, 2); |
2194 | 2155 |
2195 // Append 15 buffers at positions 15 through 29 and seek to start of range. | 2156 // Append 15 buffers at positions 15 through 29 and seek to start of range. |
2196 NewSegmentAppend(15, 15); | 2157 NewCodedFrameGroupAppend(15, 15); |
2197 Seek(15); | 2158 Seek(15); |
2198 | 2159 |
2199 // Now seek to position 5 | 2160 // Now seek to position 5 |
2200 Seek(5); | 2161 Seek(5); |
2201 | 2162 |
2202 // End overlap the old seek point. | 2163 // End overlap the old seek point. |
2203 NewSegmentAppend(10, 10); | 2164 NewCodedFrameGroupAppend(10, 10); |
2204 | 2165 |
2205 // The seek at time 0 should still be pending. | 2166 // The seek at time 0 should still be pending. |
2206 CheckNoNextBuffer(); | 2167 CheckNoNextBuffer(); |
2207 } | 2168 } |
2208 | 2169 |
2209 TEST_F(SourceBufferStreamTest, GetNextBuffer_AfterMerges) { | 2170 TEST_F(SourceBufferStreamTest, GetNextBuffer_AfterMerges) { |
2210 // Append 5 buffers at positions 10 through 14. | 2171 // Append 5 buffers at positions 10 through 14. |
2211 NewSegmentAppend(10, 5); | 2172 NewCodedFrameGroupAppend(10, 5); |
2212 | 2173 |
2213 // Seek to buffer at position 12. | 2174 // Seek to buffer at position 12. |
2214 Seek(12); | 2175 Seek(12); |
2215 | 2176 |
2216 // Append 5 buffers at positions 5 through 9. | 2177 // Append 5 buffers at positions 5 through 9. |
2217 NewSegmentAppend(5, 5); | 2178 NewCodedFrameGroupAppend(5, 5); |
2218 | 2179 |
2219 // Make sure ranges are merged. | 2180 // Make sure ranges are merged. |
2220 CheckExpectedRanges("{ [5,14) }"); | 2181 CheckExpectedRanges("{ [5,14) }"); |
2221 | 2182 |
2222 // Make sure the next buffer is correct. | 2183 // Make sure the next buffer is correct. |
2223 CheckExpectedBuffers(10, 10); | 2184 CheckExpectedBuffers(10, 10); |
2224 | 2185 |
2225 // Append 5 buffers at positions 15 through 19. | 2186 // Append 5 buffers at positions 15 through 19. |
2226 NewSegmentAppend(15, 5); | 2187 NewCodedFrameGroupAppend(15, 5); |
2227 CheckExpectedRanges("{ [5,19) }"); | 2188 CheckExpectedRanges("{ [5,19) }"); |
2228 | 2189 |
2229 // Make sure the remaining next buffers are correct. | 2190 // Make sure the remaining next buffers are correct. |
2230 CheckExpectedBuffers(11, 14); | 2191 CheckExpectedBuffers(11, 14); |
2231 } | 2192 } |
2232 | 2193 |
2233 TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenAppend) { | 2194 TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenAppend) { |
2234 // Append 4 buffers at positions 0 through 3. | 2195 // Append 4 buffers at positions 0 through 3. |
2235 NewSegmentAppend(0, 4); | 2196 NewCodedFrameGroupAppend(0, 4); |
2236 | 2197 |
2237 // Seek to buffer at position 0 and get all buffers. | 2198 // Seek to buffer at position 0 and get all buffers. |
2238 Seek(0); | 2199 Seek(0); |
2239 CheckExpectedBuffers(0, 3); | 2200 CheckExpectedBuffers(0, 3); |
2240 | 2201 |
2241 // Next buffer is at position 4, so should not be able to fulfill request. | 2202 // Next buffer is at position 4, so should not be able to fulfill request. |
2242 CheckNoNextBuffer(); | 2203 CheckNoNextBuffer(); |
2243 | 2204 |
2244 // Append 2 buffers at positions 4 through 5. | 2205 // Append 2 buffers at positions 4 through 5. |
2245 AppendBuffers(4, 2); | 2206 AppendBuffers(4, 2); |
2246 CheckExpectedBuffers(4, 5); | 2207 CheckExpectedBuffers(4, 5); |
2247 } | 2208 } |
2248 | 2209 |
2249 // This test covers the case where new buffers start-overlap a range whose next | 2210 // This test covers the case where new buffers start-overlap a range whose next |
2250 // buffer is not buffered. | 2211 // buffer is not buffered. |
2251 TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenStartOverlap) { | 2212 TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenStartOverlap) { |
2252 // Append 10 buffers at positions 0 through 9 and exhaust the buffers. | 2213 // Append 10 buffers at positions 0 through 9 and exhaust the buffers. |
2253 NewSegmentAppend(0, 10, &kDataA); | 2214 NewCodedFrameGroupAppend(0, 10, &kDataA); |
2254 Seek(0); | 2215 Seek(0); |
2255 CheckExpectedBuffers(0, 9, &kDataA); | 2216 CheckExpectedBuffers(0, 9, &kDataA); |
2256 | 2217 |
2257 // Next buffer is at position 10, so should not be able to fulfill request. | 2218 // Next buffer is at position 10, so should not be able to fulfill request. |
2258 CheckNoNextBuffer(); | 2219 CheckNoNextBuffer(); |
2259 | 2220 |
2260 // Append 6 buffers at positons 5 through 10. This is to test that doing a | 2221 // Append 6 buffers at positons 5 through 10. This is to test that doing a |
2261 // start-overlap successfully fulfills the read at position 10, even though | 2222 // start-overlap successfully fulfills the read at position 10, even though |
2262 // position 10 was unbuffered. | 2223 // position 10 was unbuffered. |
2263 NewSegmentAppend(5, 6, &kDataB); | 2224 NewCodedFrameGroupAppend(5, 6, &kDataB); |
2264 CheckExpectedBuffers(10, 10, &kDataB); | 2225 CheckExpectedBuffers(10, 10, &kDataB); |
2265 | 2226 |
2266 // Then add 5 buffers from positions 11 though 15. | 2227 // Then add 5 buffers from positions 11 though 15. |
2267 AppendBuffers(11, 5, &kDataB); | 2228 AppendBuffers(11, 5, &kDataB); |
2268 | 2229 |
2269 // Check the next 4 buffers are correct, which also effectively seeks to | 2230 // Check the next 4 buffers are correct, which also effectively seeks to |
2270 // position 15. | 2231 // position 15. |
2271 CheckExpectedBuffers(11, 14, &kDataB); | 2232 CheckExpectedBuffers(11, 14, &kDataB); |
2272 | 2233 |
2273 // Replace the next buffer at position 15 with another start overlap. | 2234 // Replace the next buffer at position 15 with another start overlap. |
2274 NewSegmentAppend(15, 2, &kDataA); | 2235 NewCodedFrameGroupAppend(15, 2, &kDataA); |
2275 CheckExpectedBuffers(15, 16, &kDataA); | 2236 CheckExpectedBuffers(15, 16, &kDataA); |
2276 } | 2237 } |
2277 | 2238 |
2278 // Tests a start overlap that occurs right at the timestamp of the last output | 2239 // Tests a start overlap that occurs right at the timestamp of the last output |
2279 // buffer that was returned by GetNextBuffer(). This test verifies that | 2240 // buffer that was returned by GetNextBuffer(). This test verifies that |
2280 // GetNextBuffer() skips to second GOP in the newly appended data instead | 2241 // GetNextBuffer() skips to second GOP in the newly appended data instead |
2281 // of returning two buffers with the same timestamp. | 2242 // of returning two buffers with the same timestamp. |
2282 TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenStartOverlap2) { | 2243 TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenStartOverlap2) { |
2283 NewSegmentAppend("0K 30 60 90 120"); | 2244 NewCodedFrameGroupAppend("0K 30 60 90 120"); |
2284 | 2245 |
2285 Seek(0); | 2246 Seek(0); |
2286 CheckExpectedBuffers("0K 30 60 90 120"); | 2247 CheckExpectedBuffers("0K 30 60 90 120"); |
2287 CheckNoNextBuffer(); | 2248 CheckNoNextBuffer(); |
2288 | 2249 |
2289 // Append a keyframe with the same timestamp as the last buffer output. | 2250 // Append a keyframe with the same timestamp as the last buffer output. |
2290 NewSegmentAppend("120D30K"); | 2251 NewCodedFrameGroupAppend("120D30K"); |
2291 CheckNoNextBuffer(); | 2252 CheckNoNextBuffer(); |
2292 | 2253 |
2293 // Append the rest of the segment and make sure that buffers are returned | 2254 // Append the rest of the coded frame group and make sure that buffers are |
2294 // from the first GOP after 120. | 2255 // returned from the first GOP after 120. |
2295 AppendBuffers("150 180 210K 240"); | 2256 AppendBuffers("150 180 210K 240"); |
2296 CheckExpectedBuffers("210K 240"); | 2257 CheckExpectedBuffers("210K 240"); |
2297 | 2258 |
2298 // Seek to the beginning and verify the contents of the source buffer. | 2259 // Seek to the beginning and verify the contents of the source buffer. |
2299 Seek(0); | 2260 Seek(0); |
2300 CheckExpectedBuffers("0K 30 60 90 120K 150 180 210K 240"); | 2261 CheckExpectedBuffers("0K 30 60 90 120K 150 180 210K 240"); |
2301 CheckNoNextBuffer(); | 2262 CheckNoNextBuffer(); |
2302 } | 2263 } |
2303 | 2264 |
2304 // This test covers the case where new buffers completely overlap a range | 2265 // This test covers the case where new buffers completely overlap a range |
2305 // whose next buffer is not buffered. | 2266 // whose next buffer is not buffered. |
2306 TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenCompleteOverlap) { | 2267 TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenCompleteOverlap) { |
2307 // Append 5 buffers at positions 10 through 14 and exhaust the buffers. | 2268 // Append 5 buffers at positions 10 through 14 and exhaust the buffers. |
2308 NewSegmentAppend(10, 5, &kDataA); | 2269 NewCodedFrameGroupAppend(10, 5, &kDataA); |
2309 Seek(10); | 2270 Seek(10); |
2310 CheckExpectedBuffers(10, 14, &kDataA); | 2271 CheckExpectedBuffers(10, 14, &kDataA); |
2311 | 2272 |
2312 // Next buffer is at position 15, so should not be able to fulfill request. | 2273 // Next buffer is at position 15, so should not be able to fulfill request. |
2313 CheckNoNextBuffer(); | 2274 CheckNoNextBuffer(); |
2314 | 2275 |
2315 // Do a complete overlap and test that this successfully fulfills the read | 2276 // Do a complete overlap and test that this successfully fulfills the read |
2316 // at position 15. | 2277 // at position 15. |
2317 NewSegmentAppend(5, 11, &kDataB); | 2278 NewCodedFrameGroupAppend(5, 11, &kDataB); |
2318 CheckExpectedBuffers(15, 15, &kDataB); | 2279 CheckExpectedBuffers(15, 15, &kDataB); |
2319 | 2280 |
2320 // Then add 5 buffers from positions 16 though 20. | 2281 // Then add 5 buffers from positions 16 though 20. |
2321 AppendBuffers(16, 5, &kDataB); | 2282 AppendBuffers(16, 5, &kDataB); |
2322 | 2283 |
2323 // Check the next 4 buffers are correct, which also effectively seeks to | 2284 // Check the next 4 buffers are correct, which also effectively seeks to |
2324 // position 20. | 2285 // position 20. |
2325 CheckExpectedBuffers(16, 19, &kDataB); | 2286 CheckExpectedBuffers(16, 19, &kDataB); |
2326 | 2287 |
2327 // Do a complete overlap and replace the buffer at position 20. | 2288 // Do a complete overlap and replace the buffer at position 20. |
2328 NewSegmentAppend(0, 21, &kDataA); | 2289 NewCodedFrameGroupAppend(0, 21, &kDataA); |
2329 CheckExpectedBuffers(20, 20, &kDataA); | 2290 CheckExpectedBuffers(20, 20, &kDataA); |
2330 } | 2291 } |
2331 | 2292 |
2332 // This test covers the case where a range is stalled waiting for its next | 2293 // This test covers the case where a range is stalled waiting for its next |
2333 // buffer, then an end-overlap causes the end of the range to be deleted. | 2294 // buffer, then an end-overlap causes the end of the range to be deleted. |
2334 TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenEndOverlap) { | 2295 TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenEndOverlap) { |
2335 // Append 5 buffers at positions 10 through 14 and exhaust the buffers. | 2296 // Append 5 buffers at positions 10 through 14 and exhaust the buffers. |
2336 NewSegmentAppend(10, 5, &kDataA); | 2297 NewCodedFrameGroupAppend(10, 5, &kDataA); |
2337 Seek(10); | 2298 Seek(10); |
2338 CheckExpectedBuffers(10, 14, &kDataA); | 2299 CheckExpectedBuffers(10, 14, &kDataA); |
2339 CheckExpectedRanges("{ [10,14) }"); | 2300 CheckExpectedRanges("{ [10,14) }"); |
2340 | 2301 |
2341 // Next buffer is at position 15, so should not be able to fulfill request. | 2302 // Next buffer is at position 15, so should not be able to fulfill request. |
2342 CheckNoNextBuffer(); | 2303 CheckNoNextBuffer(); |
2343 | 2304 |
2344 // Do an end overlap that causes the latter half of the range to be deleted. | 2305 // Do an end overlap that causes the latter half of the range to be deleted. |
2345 NewSegmentAppend(5, 6, &kDataB); | 2306 NewCodedFrameGroupAppend(5, 6, &kDataB); |
2346 CheckNoNextBuffer(); | 2307 CheckNoNextBuffer(); |
2347 CheckExpectedRanges("{ [5,10) }"); | 2308 CheckExpectedRanges("{ [5,10) }"); |
2348 | 2309 |
2349 // Fill in the gap. Getting the next buffer should still stall at position 15. | 2310 // Fill in the gap. Getting the next buffer should still stall at position 15. |
2350 for (int i = 11; i <= 14; i++) { | 2311 for (int i = 11; i <= 14; i++) { |
2351 AppendBuffers(i, 1, &kDataB); | 2312 AppendBuffers(i, 1, &kDataB); |
2352 CheckNoNextBuffer(); | 2313 CheckNoNextBuffer(); |
2353 } | 2314 } |
2354 | 2315 |
2355 // Append the buffer at position 15 and check to make sure all is correct. | 2316 // Append the buffer at position 15 and check to make sure all is correct. |
2356 AppendBuffers(15, 1); | 2317 AppendBuffers(15, 1); |
2357 CheckExpectedBuffers(15, 15); | 2318 CheckExpectedBuffers(15, 15); |
2358 CheckExpectedRanges("{ [5,15) }"); | 2319 CheckExpectedRanges("{ [5,15) }"); |
2359 } | 2320 } |
2360 | 2321 |
2361 // This test is testing the "next buffer" logic after a complete overlap. In | 2322 // This test is testing the "next buffer" logic after a complete overlap. In |
2362 // this scenario, when the track buffer is exhausted, there is no buffered data | 2323 // this scenario, when the track buffer is exhausted, there is no buffered data |
2363 // to fulfill the request. The SourceBufferStream should be able to fulfill the | 2324 // to fulfill the request. The SourceBufferStream should be able to fulfill the |
2364 // request when the data is later appended, and should not lose track of the | 2325 // request when the data is later appended, and should not lose track of the |
2365 // "next buffer" position. | 2326 // "next buffer" position. |
2366 TEST_F(SourceBufferStreamTest, GetNextBuffer_Overlap_Selected_Complete) { | 2327 TEST_F(SourceBufferStreamTest, GetNextBuffer_Overlap_Selected_Complete) { |
2367 // Append 5 buffers at positions 5 through 9. | 2328 // Append 5 buffers at positions 5 through 9. |
2368 NewSegmentAppend(5, 5, &kDataA); | 2329 NewCodedFrameGroupAppend(5, 5, &kDataA); |
2369 | 2330 |
2370 // Seek to buffer at position 5 and get next buffer. | 2331 // Seek to buffer at position 5 and get next buffer. |
2371 Seek(5); | 2332 Seek(5); |
2372 CheckExpectedBuffers(5, 5, &kDataA); | 2333 CheckExpectedBuffers(5, 5, &kDataA); |
2373 | 2334 |
2374 // Replace existing data with new data. | 2335 // Replace existing data with new data. |
2375 NewSegmentAppend(5, 5, &kDataB); | 2336 NewCodedFrameGroupAppend(5, 5, &kDataB); |
2376 | 2337 |
2377 // Expect old data up until next keyframe in new data. | 2338 // Expect old data up until next keyframe in new data. |
2378 CheckExpectedBuffers(6, 9, &kDataA); | 2339 CheckExpectedBuffers(6, 9, &kDataA); |
2379 | 2340 |
2380 // Next buffer is at position 10, so should not be able to fulfill the | 2341 // Next buffer is at position 10, so should not be able to fulfill the |
2381 // request. | 2342 // request. |
2382 CheckNoNextBuffer(); | 2343 CheckNoNextBuffer(); |
2383 | 2344 |
2384 // Now add 5 new buffers at positions 10 through 14. | 2345 // Now add 5 new buffers at positions 10 through 14. |
2385 AppendBuffers(10, 5, &kDataB); | 2346 AppendBuffers(10, 5, &kDataB); |
2386 CheckExpectedBuffers(10, 14, &kDataB); | 2347 CheckExpectedBuffers(10, 14, &kDataB); |
2387 } | 2348 } |
2388 | 2349 |
2389 TEST_F(SourceBufferStreamTest, PresentationTimestampIndependence) { | 2350 TEST_F(SourceBufferStreamTest, PresentationTimestampIndependence) { |
2390 // Append 20 buffers at position 0. | 2351 // Append 20 buffers at position 0. |
2391 NewSegmentAppend(0, 20); | 2352 NewCodedFrameGroupAppend(0, 20); |
2392 Seek(0); | 2353 Seek(0); |
2393 | 2354 |
2394 int last_keyframe_idx = -1; | 2355 int last_keyframe_idx = -1; |
2395 base::TimeDelta last_keyframe_presentation_timestamp; | 2356 base::TimeDelta last_keyframe_presentation_timestamp; |
2396 base::TimeDelta last_p_frame_presentation_timestamp; | 2357 base::TimeDelta last_p_frame_presentation_timestamp; |
2397 | 2358 |
2398 // Check for IBB...BBP pattern. | 2359 // Check for IBB...BBP pattern. |
2399 for (int i = 0; i < 20; i++) { | 2360 for (int i = 0; i < 20; i++) { |
2400 scoped_refptr<StreamParserBuffer> buffer; | 2361 scoped_refptr<StreamParserBuffer> buffer; |
2401 ASSERT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kSuccess); | 2362 ASSERT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kSuccess); |
(...skipping 15 matching lines...) Expand all Loading... | |
2417 buffer->GetDecodeTimestamp()); | 2378 buffer->GetDecodeTimestamp()); |
2418 } | 2379 } |
2419 } | 2380 } |
2420 } | 2381 } |
2421 | 2382 |
2422 TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteFront) { | 2383 TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteFront) { |
2423 // Set memory limit to 20 buffers. | 2384 // Set memory limit to 20 buffers. |
2424 SetMemoryLimit(20); | 2385 SetMemoryLimit(20); |
2425 | 2386 |
2426 // Append 20 buffers at positions 0 through 19. | 2387 // Append 20 buffers at positions 0 through 19. |
2427 NewSegmentAppend(0, 1, &kDataA); | 2388 NewCodedFrameGroupAppend(0, 1, &kDataA); |
2428 for (int i = 1; i < 20; i++) | 2389 for (int i = 1; i < 20; i++) |
2429 AppendBuffers(i, 1, &kDataA); | 2390 AppendBuffers(i, 1, &kDataA); |
2430 | 2391 |
2431 // GC should be a no-op, since we are just under memory limit. | 2392 // GC should be a no-op, since we are just under memory limit. |
2432 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(0, 0)); | 2393 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(0, 0)); |
2433 CheckExpectedRanges("{ [0,19) }"); | 2394 CheckExpectedRanges("{ [0,19) }"); |
2434 Seek(0); | 2395 Seek(0); |
2435 CheckExpectedBuffers(0, 19, &kDataA); | 2396 CheckExpectedBuffers(0, 19, &kDataA); |
2436 | 2397 |
2437 // Seek to the middle of the stream. | 2398 // Seek to the middle of the stream. |
(...skipping 11 matching lines...) Expand all Loading... | |
2449 CheckExpectedBuffers(10, 24, &kDataA); | 2410 CheckExpectedBuffers(10, 24, &kDataA); |
2450 Seek(5); | 2411 Seek(5); |
2451 CheckExpectedBuffers(5, 9, &kDataA); | 2412 CheckExpectedBuffers(5, 9, &kDataA); |
2452 } | 2413 } |
2453 | 2414 |
2454 TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteFrontGOPsAtATime) { | 2415 TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteFrontGOPsAtATime) { |
2455 // Set memory limit to 20 buffers. | 2416 // Set memory limit to 20 buffers. |
2456 SetMemoryLimit(20); | 2417 SetMemoryLimit(20); |
2457 | 2418 |
2458 // Append 20 buffers at positions 0 through 19. | 2419 // Append 20 buffers at positions 0 through 19. |
2459 NewSegmentAppend(0, 20, &kDataA); | 2420 NewCodedFrameGroupAppend(0, 20, &kDataA); |
2460 | 2421 |
2461 // Seek to position 10. | 2422 // Seek to position 10. |
2462 Seek(10); | 2423 Seek(10); |
2463 CheckExpectedRanges("{ [0,19) }"); | 2424 CheckExpectedRanges("{ [0,19) }"); |
2464 | 2425 |
2465 // Add one buffer to put the memory over the cap. | 2426 // Add one buffer to put the memory over the cap. |
2466 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(10, 1)); | 2427 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(10, 1)); |
2467 AppendBuffers(20, 1, &kDataA); | 2428 AppendBuffers(20, 1, &kDataA); |
2468 | 2429 |
2469 // GC should have deleted the first 5 buffers so that the range still begins | 2430 // GC should have deleted the first 5 buffers so that the range still begins |
2470 // with a keyframe. | 2431 // with a keyframe. |
2471 CheckExpectedRanges("{ [5,20) }"); | 2432 CheckExpectedRanges("{ [5,20) }"); |
2472 CheckExpectedBuffers(10, 20, &kDataA); | 2433 CheckExpectedBuffers(10, 20, &kDataA); |
2473 Seek(5); | 2434 Seek(5); |
2474 CheckExpectedBuffers(5, 9, &kDataA); | 2435 CheckExpectedBuffers(5, 9, &kDataA); |
2475 } | 2436 } |
2476 | 2437 |
2477 TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteBack) { | 2438 TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteBack) { |
2478 // Set memory limit to 5 buffers. | 2439 // Set memory limit to 5 buffers. |
2479 SetMemoryLimit(5); | 2440 SetMemoryLimit(5); |
2480 | 2441 |
2481 // Append 5 buffers at positions 15 through 19. | 2442 // Append 5 buffers at positions 15 through 19. |
2482 NewSegmentAppend(15, 5, &kDataA); | 2443 NewCodedFrameGroupAppend(15, 5, &kDataA); |
2483 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(0, 0)); | 2444 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(0, 0)); |
2484 | 2445 |
2485 // Append 5 buffers at positions 0 through 4. | 2446 // Append 5 buffers at positions 0 through 4. |
2486 NewSegmentAppend(0, 5, &kDataA); | 2447 NewCodedFrameGroupAppend(0, 5, &kDataA); |
2487 CheckExpectedRanges("{ [0,4) [15,19) }"); | 2448 CheckExpectedRanges("{ [0,4) [15,19) }"); |
2488 | 2449 |
2489 // Seek to position 0. | 2450 // Seek to position 0. |
2490 Seek(0); | 2451 Seek(0); |
2491 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(0, 0)); | 2452 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(0, 0)); |
2492 // Should leave the first 5 buffers from 0 to 4. | 2453 // Should leave the first 5 buffers from 0 to 4. |
2493 CheckExpectedRanges("{ [0,4) }"); | 2454 CheckExpectedRanges("{ [0,4) }"); |
2494 CheckExpectedBuffers(0, 4, &kDataA); | 2455 CheckExpectedBuffers(0, 4, &kDataA); |
2495 } | 2456 } |
2496 | 2457 |
2497 TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteFrontAndBack) { | 2458 TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteFrontAndBack) { |
2498 // Set memory limit to 3 buffers. | 2459 // Set memory limit to 3 buffers. |
2499 SetMemoryLimit(3); | 2460 SetMemoryLimit(3); |
2500 | 2461 |
2501 // Seek to position 15. | 2462 // Seek to position 15. |
2502 Seek(15); | 2463 Seek(15); |
2503 | 2464 |
2504 // Append 40 buffers at positions 0 through 39. | 2465 // Append 40 buffers at positions 0 through 39. |
2505 NewSegmentAppend(0, 40, &kDataA); | 2466 NewCodedFrameGroupAppend(0, 40, &kDataA); |
2506 // GC will try to keep data between current playback position and last append | 2467 // GC will try to keep data between current playback position and last append |
2507 // position. This will ensure that the last append position is 19 and will | 2468 // position. This will ensure that the last append position is 19 and will |
2508 // allow GC algorithm to collect data outside of the range [15,19) | 2469 // allow GC algorithm to collect data outside of the range [15,19) |
2509 NewSegmentAppend(15, 5, &kDataA); | 2470 NewCodedFrameGroupAppend(15, 5, &kDataA); |
2510 CheckExpectedRanges("{ [0,39) }"); | 2471 CheckExpectedRanges("{ [0,39) }"); |
2511 | 2472 |
2512 // Should leave the GOP containing the current playback position 15 and the | 2473 // Should leave the GOP containing the current playback position 15 and the |
2513 // last append position 19. GC returns false, since we are still above limit. | 2474 // last append position 19. GC returns false, since we are still above limit. |
2514 EXPECT_FALSE(GarbageCollectWithPlaybackAtBuffer(15, 0)); | 2475 EXPECT_FALSE(GarbageCollectWithPlaybackAtBuffer(15, 0)); |
2515 CheckExpectedRanges("{ [15,19) }"); | 2476 CheckExpectedRanges("{ [15,19) }"); |
2516 CheckExpectedBuffers(15, 19, &kDataA); | 2477 CheckExpectedBuffers(15, 19, &kDataA); |
2517 CheckNoNextBuffer(); | 2478 CheckNoNextBuffer(); |
2518 } | 2479 } |
2519 | 2480 |
2520 TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteSeveralRanges) { | 2481 TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteSeveralRanges) { |
2521 // Append 5 buffers at positions 0 through 4. | 2482 // Append 5 buffers at positions 0 through 4. |
2522 NewSegmentAppend(0, 5); | 2483 NewCodedFrameGroupAppend(0, 5); |
2523 | 2484 |
2524 // Append 5 buffers at positions 10 through 14. | 2485 // Append 5 buffers at positions 10 through 14. |
2525 NewSegmentAppend(10, 5); | 2486 NewCodedFrameGroupAppend(10, 5); |
2526 | 2487 |
2527 // Append 5 buffers at positions 20 through 24. | 2488 // Append 5 buffers at positions 20 through 24. |
2528 NewSegmentAppend(20, 5); | 2489 NewCodedFrameGroupAppend(20, 5); |
2529 | 2490 |
2530 // Append 5 buffers at positions 40 through 44. | 2491 // Append 5 buffers at positions 40 through 44. |
2531 NewSegmentAppend(40, 5); | 2492 NewCodedFrameGroupAppend(40, 5); |
2532 | 2493 |
2533 CheckExpectedRanges("{ [0,4) [10,14) [20,24) [40,44) }"); | 2494 CheckExpectedRanges("{ [0,4) [10,14) [20,24) [40,44) }"); |
2534 | 2495 |
2535 // Seek to position 20. | 2496 // Seek to position 20. |
2536 Seek(20); | 2497 Seek(20); |
2537 CheckExpectedBuffers(20, 20); | 2498 CheckExpectedBuffers(20, 20); |
2538 | 2499 |
2539 // Set memory limit to 1 buffer. | 2500 // Set memory limit to 1 buffer. |
2540 SetMemoryLimit(1); | 2501 SetMemoryLimit(1); |
2541 | 2502 |
2542 // Append 5 buffers at positions 30 through 34. | 2503 // Append 5 buffers at positions 30 through 34. |
2543 NewSegmentAppend(30, 5); | 2504 NewCodedFrameGroupAppend(30, 5); |
2544 | 2505 |
2545 // We will have more than 1 buffer left, GC will fail | 2506 // We will have more than 1 buffer left, GC will fail |
2546 EXPECT_FALSE(GarbageCollectWithPlaybackAtBuffer(20, 0)); | 2507 EXPECT_FALSE(GarbageCollectWithPlaybackAtBuffer(20, 0)); |
2547 | 2508 |
2548 // Should have deleted all buffer ranges before the current buffer and after | 2509 // Should have deleted all buffer ranges before the current buffer and after |
2549 // last GOP | 2510 // last GOP |
2550 CheckExpectedRanges("{ [20,24) [30,34) }"); | 2511 CheckExpectedRanges("{ [20,24) [30,34) }"); |
2551 CheckExpectedBuffers(21, 24); | 2512 CheckExpectedBuffers(21, 24); |
2552 CheckNoNextBuffer(); | 2513 CheckNoNextBuffer(); |
2553 | 2514 |
2554 // Continue appending into the last range to make sure it didn't break. | 2515 // Continue appending into the last range to make sure it didn't break. |
2555 AppendBuffers(35, 10); | 2516 AppendBuffers(35, 10); |
2556 EXPECT_FALSE(GarbageCollectWithPlaybackAtBuffer(20, 0)); | 2517 EXPECT_FALSE(GarbageCollectWithPlaybackAtBuffer(20, 0)); |
2557 // Should save everything between read head and last appended | 2518 // Should save everything between read head and last appended |
2558 CheckExpectedRanges("{ [20,24) [30,44) }"); | 2519 CheckExpectedRanges("{ [20,24) [30,44) }"); |
2559 | 2520 |
2560 // Make sure appending before and after the ranges didn't somehow break. | 2521 // Make sure appending before and after the ranges didn't somehow break. |
2561 SetMemoryLimit(100); | 2522 SetMemoryLimit(100); |
2562 NewSegmentAppend(0, 10); | 2523 NewCodedFrameGroupAppend(0, 10); |
2563 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(20, 0)); | 2524 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(20, 0)); |
2564 CheckExpectedRanges("{ [0,9) [20,24) [30,44) }"); | 2525 CheckExpectedRanges("{ [0,9) [20,24) [30,44) }"); |
2565 Seek(0); | 2526 Seek(0); |
2566 CheckExpectedBuffers(0, 9); | 2527 CheckExpectedBuffers(0, 9); |
2567 | 2528 |
2568 NewSegmentAppend(90, 10); | 2529 NewCodedFrameGroupAppend(90, 10); |
2569 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(0, 0)); | 2530 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(0, 0)); |
2570 CheckExpectedRanges("{ [0,9) [20,24) [30,44) [90,99) }"); | 2531 CheckExpectedRanges("{ [0,9) [20,24) [30,44) [90,99) }"); |
2571 Seek(30); | 2532 Seek(30); |
2572 CheckExpectedBuffers(30, 44); | 2533 CheckExpectedBuffers(30, 44); |
2573 CheckNoNextBuffer(); | 2534 CheckNoNextBuffer(); |
2574 Seek(90); | 2535 Seek(90); |
2575 CheckExpectedBuffers(90, 99); | 2536 CheckExpectedBuffers(90, 99); |
2576 CheckNoNextBuffer(); | 2537 CheckNoNextBuffer(); |
2577 } | 2538 } |
2578 | 2539 |
2579 TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteAfterLastAppend) { | 2540 TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteAfterLastAppend) { |
2580 // Set memory limit to 10 buffers. | 2541 // Set memory limit to 10 buffers. |
2581 SetMemoryLimit(10); | 2542 SetMemoryLimit(10); |
2582 | 2543 |
2583 // Append 1 GOP starting at 310ms, 30ms apart. | 2544 // Append 1 GOP starting at 310ms, 30ms apart. |
2584 NewSegmentAppend("310K 340 370"); | 2545 NewCodedFrameGroupAppend("310K 340 370"); |
2585 | 2546 |
2586 // Append 2 GOPs starting at 490ms, 30ms apart. | 2547 // Append 2 GOPs starting at 490ms, 30ms apart. |
2587 NewSegmentAppend("490K 520 550 580K 610 640"); | 2548 NewCodedFrameGroupAppend("490K 520 550 580K 610 640"); |
2588 | 2549 |
2589 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(0, 0)); | 2550 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(0, 0)); |
2590 | 2551 |
2591 CheckExpectedRangesByTimestamp("{ [310,400) [490,670) }"); | 2552 CheckExpectedRangesByTimestamp("{ [310,400) [490,670) }"); |
2592 | 2553 |
2593 // Seek to the GOP at 580ms. | 2554 // Seek to the GOP at 580ms. |
2594 SeekToTimestampMs(580); | 2555 SeekToTimestampMs(580); |
2595 | 2556 |
2596 // Append 2 GOPs before the existing ranges. | 2557 // Append 2 GOPs before the existing ranges. |
2597 // So the ranges before GC are "{ [100,280) [310,400) [490,670) }". | 2558 // So the ranges before GC are "{ [100,280) [310,400) [490,670) }". |
2598 NewSegmentAppend("100K 130 160 190K 220 250K"); | 2559 NewCodedFrameGroupAppend("100K 130 160 190K 220 250K"); |
2599 | 2560 |
2600 EXPECT_TRUE(stream_->GarbageCollectIfNeeded( | 2561 EXPECT_TRUE(stream_->GarbageCollectIfNeeded( |
2601 DecodeTimestamp::FromMilliseconds(580), 0)); | 2562 DecodeTimestamp::FromMilliseconds(580), 0)); |
2602 | 2563 |
2603 // Should save the newly appended GOPs. | 2564 // Should save the newly appended GOPs. |
2604 CheckExpectedRangesByTimestamp("{ [100,280) [580,670) }"); | 2565 CheckExpectedRangesByTimestamp("{ [100,280) [580,670) }"); |
2605 } | 2566 } |
2606 | 2567 |
2607 TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteAfterLastAppendMerged) { | 2568 TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteAfterLastAppendMerged) { |
2608 // Set memory limit to 10 buffers. | 2569 // Set memory limit to 10 buffers. |
2609 SetMemoryLimit(10); | 2570 SetMemoryLimit(10); |
2610 | 2571 |
2611 // Append 3 GOPs starting at 400ms, 30ms apart. | 2572 // Append 3 GOPs starting at 400ms, 30ms apart. |
2612 NewSegmentAppend("400K 430 460 490K 520 550 580K 610 640"); | 2573 NewCodedFrameGroupAppend("400K 430 460 490K 520 550 580K 610 640"); |
2613 | 2574 |
2614 // Seek to the GOP at 580ms. | 2575 // Seek to the GOP at 580ms. |
2615 SeekToTimestampMs(580); | 2576 SeekToTimestampMs(580); |
2616 | 2577 |
2617 // Append 2 GOPs starting at 220ms, and they will be merged with the existing | 2578 // Append 2 GOPs starting at 220ms, and they will be merged with the existing |
2618 // range. So the range before GC is "{ [220,670) }". | 2579 // range. So the range before GC is "{ [220,670) }". |
2619 NewSegmentAppend("220K 250 280 310K 340 370"); | 2580 NewCodedFrameGroupAppend("220K 250 280 310K 340 370"); |
2620 | 2581 |
2621 EXPECT_TRUE(stream_->GarbageCollectIfNeeded( | 2582 EXPECT_TRUE(stream_->GarbageCollectIfNeeded( |
2622 DecodeTimestamp::FromMilliseconds(580), 0)); | 2583 DecodeTimestamp::FromMilliseconds(580), 0)); |
2623 | 2584 |
2624 // Should save the newly appended GOPs. | 2585 // Should save the newly appended GOPs. |
2625 CheckExpectedRangesByTimestamp("{ [220,400) [580,670) }"); | 2586 CheckExpectedRangesByTimestamp("{ [220,400) [580,670) }"); |
2626 } | 2587 } |
2627 | 2588 |
2628 TEST_F(SourceBufferStreamTest, GarbageCollection_NoSeek) { | 2589 TEST_F(SourceBufferStreamTest, GarbageCollection_NoSeek) { |
2629 // Set memory limit to 20 buffers. | 2590 // Set memory limit to 20 buffers. |
2630 SetMemoryLimit(20); | 2591 SetMemoryLimit(20); |
2631 | 2592 |
2632 // Append 25 buffers at positions 0 through 24. | 2593 // Append 25 buffers at positions 0 through 24. |
2633 NewSegmentAppend(0, 25, &kDataA); | 2594 NewCodedFrameGroupAppend(0, 25, &kDataA); |
2634 | 2595 |
2635 // If playback is still in the first GOP (starting at 0), GC should fail. | 2596 // If playback is still in the first GOP (starting at 0), GC should fail. |
2636 EXPECT_FALSE(GarbageCollectWithPlaybackAtBuffer(2, 0)); | 2597 EXPECT_FALSE(GarbageCollectWithPlaybackAtBuffer(2, 0)); |
2637 CheckExpectedRanges("{ [0,24) }"); | 2598 CheckExpectedRanges("{ [0,24) }"); |
2638 | 2599 |
2639 // As soon as playback position moves past the first GOP, it should be removed | 2600 // As soon as playback position moves past the first GOP, it should be removed |
2640 // and after removing the first GOP we are under memory limit. | 2601 // and after removing the first GOP we are under memory limit. |
2641 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(5, 0)); | 2602 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(5, 0)); |
2642 CheckExpectedRanges("{ [5,24) }"); | 2603 CheckExpectedRanges("{ [5,24) }"); |
2643 CheckNoNextBuffer(); | 2604 CheckNoNextBuffer(); |
2644 Seek(5); | 2605 Seek(5); |
2645 CheckExpectedBuffers(5, 24, &kDataA); | 2606 CheckExpectedBuffers(5, 24, &kDataA); |
2646 } | 2607 } |
2647 | 2608 |
2648 TEST_F(SourceBufferStreamTest, GarbageCollection_PendingSeek) { | 2609 TEST_F(SourceBufferStreamTest, GarbageCollection_PendingSeek) { |
2649 // Append 10 buffers at positions 0 through 9. | 2610 // Append 10 buffers at positions 0 through 9. |
2650 NewSegmentAppend(0, 10, &kDataA); | 2611 NewCodedFrameGroupAppend(0, 10, &kDataA); |
2651 | 2612 |
2652 // Append 5 buffers at positions 25 through 29. | 2613 // Append 5 buffers at positions 25 through 29. |
2653 NewSegmentAppend(25, 5, &kDataA); | 2614 NewCodedFrameGroupAppend(25, 5, &kDataA); |
2654 | 2615 |
2655 // Seek to position 15. | 2616 // Seek to position 15. |
2656 Seek(15); | 2617 Seek(15); |
2657 CheckNoNextBuffer(); | 2618 CheckNoNextBuffer(); |
2658 CheckExpectedRanges("{ [0,9) [25,29) }"); | 2619 CheckExpectedRanges("{ [0,9) [25,29) }"); |
2659 | 2620 |
2660 // Set memory limit to 5 buffers. | 2621 // Set memory limit to 5 buffers. |
2661 SetMemoryLimit(5); | 2622 SetMemoryLimit(5); |
2662 | 2623 |
2663 // Append 5 buffers as positions 30 to 34 to trigger GC. | 2624 // Append 5 buffers as positions 30 to 34 to trigger GC. |
2664 AppendBuffers(30, 5, &kDataA); | 2625 AppendBuffers(30, 5, &kDataA); |
2665 | 2626 |
2666 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(30, 0)); | 2627 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(30, 0)); |
2667 | 2628 |
2668 // The current algorithm will delete from the beginning until the memory is | 2629 // The current algorithm will delete from the beginning until the memory is |
2669 // under cap. | 2630 // under cap. |
2670 CheckExpectedRanges("{ [30,34) }"); | 2631 CheckExpectedRanges("{ [30,34) }"); |
2671 | 2632 |
2672 // Expand memory limit again so that GC won't be triggered. | 2633 // Expand memory limit again so that GC won't be triggered. |
2673 SetMemoryLimit(100); | 2634 SetMemoryLimit(100); |
2674 | 2635 |
2675 // Append data to fulfill seek. | 2636 // Append data to fulfill seek. |
2676 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(30, 5)); | 2637 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(30, 5)); |
2677 NewSegmentAppend(15, 5, &kDataA); | 2638 NewCodedFrameGroupAppend(15, 5, &kDataA); |
2678 | 2639 |
2679 // Check to make sure all is well. | 2640 // Check to make sure all is well. |
2680 CheckExpectedRanges("{ [15,19) [30,34) }"); | 2641 CheckExpectedRanges("{ [15,19) [30,34) }"); |
2681 CheckExpectedBuffers(15, 19, &kDataA); | 2642 CheckExpectedBuffers(15, 19, &kDataA); |
2682 Seek(30); | 2643 Seek(30); |
2683 CheckExpectedBuffers(30, 34, &kDataA); | 2644 CheckExpectedBuffers(30, 34, &kDataA); |
2684 } | 2645 } |
2685 | 2646 |
2686 TEST_F(SourceBufferStreamTest, GarbageCollection_NeedsMoreData) { | 2647 TEST_F(SourceBufferStreamTest, GarbageCollection_NeedsMoreData) { |
2687 // Set memory limit to 15 buffers. | 2648 // Set memory limit to 15 buffers. |
2688 SetMemoryLimit(15); | 2649 SetMemoryLimit(15); |
2689 | 2650 |
2690 // Append 10 buffers at positions 0 through 9. | 2651 // Append 10 buffers at positions 0 through 9. |
2691 NewSegmentAppend(0, 10, &kDataA); | 2652 NewCodedFrameGroupAppend(0, 10, &kDataA); |
2692 | 2653 |
2693 // Advance next buffer position to 10. | 2654 // Advance next buffer position to 10. |
2694 Seek(0); | 2655 Seek(0); |
2695 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(0, 0)); | 2656 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(0, 0)); |
2696 CheckExpectedBuffers(0, 9, &kDataA); | 2657 CheckExpectedBuffers(0, 9, &kDataA); |
2697 CheckNoNextBuffer(); | 2658 CheckNoNextBuffer(); |
2698 | 2659 |
2699 // Append 20 buffers at positions 15 through 34. | 2660 // Append 20 buffers at positions 15 through 34. |
2700 NewSegmentAppend(15, 20, &kDataA); | 2661 NewCodedFrameGroupAppend(15, 20, &kDataA); |
2701 CheckExpectedRanges("{ [0,9) [15,34) }"); | 2662 CheckExpectedRanges("{ [0,9) [15,34) }"); |
2702 | 2663 |
2703 // GC should save the keyframe before the next buffer position and the data | 2664 // GC should save the keyframe before the next buffer position and the data |
2704 // closest to the next buffer position. It will also save all buffers from | 2665 // closest to the next buffer position. It will also save all buffers from |
2705 // next buffer to the last GOP appended, which overflows limit and leads to | 2666 // next buffer to the last GOP appended, which overflows limit and leads to |
2706 // failure. | 2667 // failure. |
2707 EXPECT_FALSE(GarbageCollectWithPlaybackAtBuffer(5, 0)); | 2668 EXPECT_FALSE(GarbageCollectWithPlaybackAtBuffer(5, 0)); |
2708 CheckExpectedRanges("{ [5,9) [15,34) }"); | 2669 CheckExpectedRanges("{ [5,9) [15,34) }"); |
2709 | 2670 |
2710 // Now fulfill the seek at position 10. This will make GC delete the data | 2671 // Now fulfill the seek at position 10. This will make GC delete the data |
2711 // before position 10 to keep it within cap. | 2672 // before position 10 to keep it within cap. |
2712 NewSegmentAppend(10, 5, &kDataA); | 2673 NewCodedFrameGroupAppend(10, 5, &kDataA); |
2713 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(10, 0)); | 2674 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(10, 0)); |
2714 CheckExpectedRanges("{ [10,24) }"); | 2675 CheckExpectedRanges("{ [10,24) }"); |
2715 CheckExpectedBuffers(10, 24, &kDataA); | 2676 CheckExpectedBuffers(10, 24, &kDataA); |
2716 } | 2677 } |
2717 | 2678 |
2718 TEST_F(SourceBufferStreamTest, GarbageCollection_TrackBuffer) { | 2679 TEST_F(SourceBufferStreamTest, GarbageCollection_TrackBuffer) { |
2719 EXPECT_MEDIA_LOG(ContainsTrackBufferExhaustionSkipLog(99)); | 2680 EXPECT_MEDIA_LOG(ContainsTrackBufferExhaustionSkipLog(99)); |
2720 | 2681 |
2721 // Set memory limit to 3 buffers. | 2682 // Set memory limit to 3 buffers. |
2722 SetMemoryLimit(3); | 2683 SetMemoryLimit(3); |
2723 | 2684 |
2724 // Seek to position 15. | 2685 // Seek to position 15. |
2725 Seek(15); | 2686 Seek(15); |
2726 | 2687 |
2727 // Append 18 buffers at positions 0 through 17. | 2688 // Append 18 buffers at positions 0 through 17. |
2728 NewSegmentAppend(0, 18, &kDataA); | 2689 NewCodedFrameGroupAppend(0, 18, &kDataA); |
2729 | 2690 |
2730 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(15, 0)); | 2691 EXPECT_TRUE(GarbageCollectWithPlaybackAtBuffer(15, 0)); |
2731 | 2692 |
2732 // Should leave GOP containing seek position. | 2693 // Should leave GOP containing seek position. |
2733 CheckExpectedRanges("{ [15,17) }"); | 2694 CheckExpectedRanges("{ [15,17) }"); |
2734 | 2695 |
2735 // Move next buffer position to 16. | 2696 // Move next buffer position to 16. |
2736 CheckExpectedBuffers(15, 15, &kDataA); | 2697 CheckExpectedBuffers(15, 15, &kDataA); |
2737 | 2698 |
2738 // Completely overlap the existing buffers. | 2699 // Completely overlap the existing buffers. |
2739 NewSegmentAppend(0, 20, &kDataB); | 2700 NewCodedFrameGroupAppend(0, 20, &kDataB); |
2740 | 2701 |
2741 // Final GOP [15,19) contains 5 buffers, which is more than memory limit of | 2702 // Final GOP [15,19) contains 5 buffers, which is more than memory limit of |
2742 // 3 buffers set at the beginning of the test, so GC will fail. | 2703 // 3 buffers set at the beginning of the test, so GC will fail. |
2743 EXPECT_FALSE(GarbageCollectWithPlaybackAtBuffer(15, 0)); | 2704 EXPECT_FALSE(GarbageCollectWithPlaybackAtBuffer(15, 0)); |
2744 | 2705 |
2745 // Because buffers 16 and 17 are not keyframes, they are moved to the track | 2706 // Because buffers 16 and 17 are not keyframes, they are moved to the track |
2746 // buffer upon overlap. The source buffer (i.e. not the track buffer) is now | 2707 // buffer upon overlap. The source buffer (i.e. not the track buffer) is now |
2747 // waiting for the next keyframe. | 2708 // waiting for the next keyframe. |
2748 CheckExpectedRanges("{ [15,19) }"); | 2709 CheckExpectedRanges("{ [15,19) }"); |
2749 CheckExpectedBuffers(16, 17, &kDataA); | 2710 CheckExpectedBuffers(16, 17, &kDataA); |
(...skipping 10 matching lines...) Expand all Loading... | |
2760 CheckExpectedRanges("{ [20,24) }"); | 2721 CheckExpectedRanges("{ [20,24) }"); |
2761 CheckExpectedBuffers(20, 24, &kDataB); | 2722 CheckExpectedBuffers(20, 24, &kDataB); |
2762 CheckNoNextBuffer(); | 2723 CheckNoNextBuffer(); |
2763 } | 2724 } |
2764 | 2725 |
2765 // Test GC preserves data starting at first GOP containing playback position. | 2726 // Test GC preserves data starting at first GOP containing playback position. |
2766 TEST_F(SourceBufferStreamTest, GarbageCollection_SaveDataAtPlaybackPosition) { | 2727 TEST_F(SourceBufferStreamTest, GarbageCollection_SaveDataAtPlaybackPosition) { |
2767 // Set memory limit to 30 buffers = 1 second of data. | 2728 // Set memory limit to 30 buffers = 1 second of data. |
2768 SetMemoryLimit(30); | 2729 SetMemoryLimit(30); |
2769 // And append 300 buffers = 10 seconds of data. | 2730 // And append 300 buffers = 10 seconds of data. |
2770 NewSegmentAppend(0, 300, &kDataA); | 2731 NewCodedFrameGroupAppend(0, 300, &kDataA); |
2771 CheckExpectedRanges("{ [0,299) }"); | 2732 CheckExpectedRanges("{ [0,299) }"); |
2772 | 2733 |
2773 // Playback position at 0, all data must be preserved. | 2734 // Playback position at 0, all data must be preserved. |
2774 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( | 2735 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( |
2775 DecodeTimestamp::FromMilliseconds(0), 0)); | 2736 DecodeTimestamp::FromMilliseconds(0), 0)); |
2776 CheckExpectedRanges("{ [0,299) }"); | 2737 CheckExpectedRanges("{ [0,299) }"); |
2777 | 2738 |
2778 // Playback position at 1 sec, the first second of data [0,29) should be | 2739 // Playback position at 1 sec, the first second of data [0,29) should be |
2779 // collected, since we are way over memory limit. | 2740 // collected, since we are way over memory limit. |
2780 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( | 2741 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2818 EXPECT_TRUE(stream_->GarbageCollectIfNeeded( | 2779 EXPECT_TRUE(stream_->GarbageCollectIfNeeded( |
2819 DecodeTimestamp::FromMilliseconds(15000), 0)); | 2780 DecodeTimestamp::FromMilliseconds(15000), 0)); |
2820 CheckExpectedRanges("{ [270,299) }"); | 2781 CheckExpectedRanges("{ [270,299) }"); |
2821 } | 2782 } |
2822 | 2783 |
2823 // Test saving the last GOP appended when this GOP is the only GOP in its range. | 2784 // Test saving the last GOP appended when this GOP is the only GOP in its range. |
2824 TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP) { | 2785 TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP) { |
2825 // Set memory limit to 3 and make sure the 4-byte GOP is not garbage | 2786 // Set memory limit to 3 and make sure the 4-byte GOP is not garbage |
2826 // collected. | 2787 // collected. |
2827 SetMemoryLimit(3); | 2788 SetMemoryLimit(3); |
2828 NewSegmentAppend("0K 30 60 90"); | 2789 NewCodedFrameGroupAppend("0K 30 60 90"); |
2829 EXPECT_FALSE(GarbageCollectWithPlaybackAtBuffer(0, 0)); | 2790 EXPECT_FALSE(GarbageCollectWithPlaybackAtBuffer(0, 0)); |
2830 CheckExpectedRangesByTimestamp("{ [0,120) }"); | 2791 CheckExpectedRangesByTimestamp("{ [0,120) }"); |
2831 | 2792 |
2832 // Make sure you can continue appending data to this GOP; again, GC should not | 2793 // Make sure you can continue appending data to this GOP; again, GC should not |
2833 // wipe out anything. | 2794 // wipe out anything. |
2834 AppendBuffers("120D30"); | 2795 AppendBuffers("120D30"); |
2835 EXPECT_FALSE(GarbageCollectWithPlaybackAtBuffer(0, 0)); | 2796 EXPECT_FALSE(GarbageCollectWithPlaybackAtBuffer(0, 0)); |
2836 CheckExpectedRangesByTimestamp("{ [0,150) }"); | 2797 CheckExpectedRangesByTimestamp("{ [0,150) }"); |
2837 | 2798 |
2838 // Append a 2nd range after this without triggering GC. | 2799 // Append a 2nd range after this without triggering GC. |
2839 NewSegmentAppend("200K 230 260 290K 320 350"); | 2800 NewCodedFrameGroupAppend("200K 230 260 290K 320 350"); |
2840 CheckExpectedRangesByTimestamp("{ [0,150) [200,380) }"); | 2801 CheckExpectedRangesByTimestamp("{ [0,150) [200,380) }"); |
2841 | 2802 |
2842 // Seek to 290ms. | 2803 // Seek to 290ms. |
2843 SeekToTimestampMs(290); | 2804 SeekToTimestampMs(290); |
2844 | 2805 |
2845 // Now append a GOP in a separate range after the selected range and trigger | 2806 // Now append a GOP in a separate range after the selected range and trigger |
2846 // GC. Because it is after 290ms, this tests that the GOP is saved when | 2807 // GC. Because it is after 290ms, this tests that the GOP is saved when |
2847 // deleting from the back. | 2808 // deleting from the back. |
2848 NewSegmentAppend("500K 530 560 590"); | 2809 NewCodedFrameGroupAppend("500K 530 560 590"); |
2849 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( | 2810 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( |
2850 DecodeTimestamp::FromMilliseconds(290), 0)); | 2811 DecodeTimestamp::FromMilliseconds(290), 0)); |
2851 | 2812 |
2852 // Should save GOPs between 290ms and the last GOP appended. | 2813 // Should save GOPs between 290ms and the last GOP appended. |
2853 CheckExpectedRangesByTimestamp("{ [290,380) [500,620) }"); | 2814 CheckExpectedRangesByTimestamp("{ [290,380) [500,620) }"); |
2854 | 2815 |
2855 // Continue appending to this GOP after GC. | 2816 // Continue appending to this GOP after GC. |
2856 AppendBuffers("620D30"); | 2817 AppendBuffers("620D30"); |
2857 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( | 2818 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( |
2858 DecodeTimestamp::FromMilliseconds(290), 0)); | 2819 DecodeTimestamp::FromMilliseconds(290), 0)); |
2859 CheckExpectedRangesByTimestamp("{ [290,380) [500,650) }"); | 2820 CheckExpectedRangesByTimestamp("{ [290,380) [500,650) }"); |
2860 } | 2821 } |
2861 | 2822 |
2862 // Test saving the last GOP appended when this GOP is in the middle of a | 2823 // Test saving the last GOP appended when this GOP is in the middle of a |
2863 // non-selected range. | 2824 // non-selected range. |
2864 TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Middle) { | 2825 TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Middle) { |
2865 // Append 3 GOPs starting at 0ms, 30ms apart. | 2826 // Append 3 GOPs starting at 0ms, 30ms apart. |
2866 NewSegmentAppend("0K 30 60 90K 120 150 180K 210 240"); | 2827 NewCodedFrameGroupAppend("0K 30 60 90K 120 150 180K 210 240"); |
2867 CheckExpectedRangesByTimestamp("{ [0,270) }"); | 2828 CheckExpectedRangesByTimestamp("{ [0,270) }"); |
2868 | 2829 |
2869 // Now set the memory limit to 1 and overlap the middle of the range with a | 2830 // Now set the memory limit to 1 and overlap the middle of the range with a |
2870 // new GOP. | 2831 // new GOP. |
2871 SetMemoryLimit(1); | 2832 SetMemoryLimit(1); |
2872 NewSegmentAppend("80K 110 140"); | 2833 NewCodedFrameGroupAppend("80K 110 140"); |
2873 | 2834 |
2874 // This whole GOP should be saved after GC, which will fail due to GOP being | 2835 // This whole GOP should be saved after GC, which will fail due to GOP being |
2875 // larger than 1 buffer | 2836 // larger than 1 buffer |
2876 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( | 2837 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( |
2877 DecodeTimestamp::FromMilliseconds(80), 0)); | 2838 DecodeTimestamp::FromMilliseconds(80), 0)); |
2878 CheckExpectedRangesByTimestamp("{ [80,170) }"); | 2839 CheckExpectedRangesByTimestamp("{ [80,170) }"); |
2879 // We should still be able to continue appending data to GOP | 2840 // We should still be able to continue appending data to GOP |
2880 AppendBuffers("170D30"); | 2841 AppendBuffers("170D30"); |
2881 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( | 2842 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( |
2882 DecodeTimestamp::FromMilliseconds(80), 0)); | 2843 DecodeTimestamp::FromMilliseconds(80), 0)); |
2883 CheckExpectedRangesByTimestamp("{ [80,200) }"); | 2844 CheckExpectedRangesByTimestamp("{ [80,200) }"); |
2884 | 2845 |
2885 // Append a 2nd range after this range, without triggering GC. | 2846 // Append a 2nd range after this range, without triggering GC. |
2886 NewSegmentAppend("400K 430 460 490K 520 550 580K 610 640"); | 2847 NewCodedFrameGroupAppend("400K 430 460 490K 520 550 580K 610 640"); |
2887 CheckExpectedRangesByTimestamp("{ [80,200) [400,670) }"); | 2848 CheckExpectedRangesByTimestamp("{ [80,200) [400,670) }"); |
2888 | 2849 |
2889 // Seek to 80ms to make the first range the selected range. | 2850 // Seek to 80ms to make the first range the selected range. |
2890 SeekToTimestampMs(80); | 2851 SeekToTimestampMs(80); |
2891 | 2852 |
2892 // Now append a GOP in the middle of the second range and trigger GC. Because | 2853 // Now append a GOP in the middle of the second range and trigger GC. Because |
2893 // it is after the selected range, this tests that the GOP is saved when | 2854 // it is after the selected range, this tests that the GOP is saved when |
2894 // deleting from the back. | 2855 // deleting from the back. |
2895 NewSegmentAppend("500K 530 560 590"); | 2856 NewCodedFrameGroupAppend("500K 530 560 590"); |
2896 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( | 2857 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( |
2897 DecodeTimestamp::FromMilliseconds(80), 0)); | 2858 DecodeTimestamp::FromMilliseconds(80), 0)); |
2898 | 2859 |
2899 // Should save the GOPs between the seek point and GOP that was last appended | 2860 // Should save the GOPs between the seek point and GOP that was last appended |
2900 CheckExpectedRangesByTimestamp("{ [80,200) [400,620) }"); | 2861 CheckExpectedRangesByTimestamp("{ [80,200) [400,620) }"); |
2901 | 2862 |
2902 // Continue appending to this GOP after GC. | 2863 // Continue appending to this GOP after GC. |
2903 AppendBuffers("620D30"); | 2864 AppendBuffers("620D30"); |
2904 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( | 2865 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( |
2905 DecodeTimestamp::FromMilliseconds(80), 0)); | 2866 DecodeTimestamp::FromMilliseconds(80), 0)); |
2906 CheckExpectedRangesByTimestamp("{ [80,200) [400,650) }"); | 2867 CheckExpectedRangesByTimestamp("{ [80,200) [400,650) }"); |
2907 } | 2868 } |
2908 | 2869 |
2909 // Test saving the last GOP appended when the GOP containing the next buffer is | 2870 // Test saving the last GOP appended when the GOP containing the next buffer is |
2910 // adjacent to the last GOP appended. | 2871 // adjacent to the last GOP appended. |
2911 TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Selected1) { | 2872 TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Selected1) { |
2912 // Append 3 GOPs at 0ms, 90ms, and 180ms. | 2873 // Append 3 GOPs at 0ms, 90ms, and 180ms. |
2913 NewSegmentAppend("0K 30 60 90K 120 150 180K 210 240"); | 2874 NewCodedFrameGroupAppend("0K 30 60 90K 120 150 180K 210 240"); |
2914 CheckExpectedRangesByTimestamp("{ [0,270) }"); | 2875 CheckExpectedRangesByTimestamp("{ [0,270) }"); |
2915 | 2876 |
2916 // Seek to the GOP at 90ms. | 2877 // Seek to the GOP at 90ms. |
2917 SeekToTimestampMs(90); | 2878 SeekToTimestampMs(90); |
2918 | 2879 |
2919 // Set the memory limit to 1, then overlap the GOP at 0. | 2880 // Set the memory limit to 1, then overlap the GOP at 0. |
2920 SetMemoryLimit(1); | 2881 SetMemoryLimit(1); |
2921 NewSegmentAppend("0K 30 60"); | 2882 NewCodedFrameGroupAppend("0K 30 60"); |
2922 | 2883 |
2923 // GC should save the GOP at 0ms and 90ms, and will fail since GOP larger | 2884 // GC should save the GOP at 0ms and 90ms, and will fail since GOP larger |
2924 // than 1 buffer | 2885 // than 1 buffer |
2925 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( | 2886 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( |
2926 DecodeTimestamp::FromMilliseconds(90), 0)); | 2887 DecodeTimestamp::FromMilliseconds(90), 0)); |
2927 CheckExpectedRangesByTimestamp("{ [0,180) }"); | 2888 CheckExpectedRangesByTimestamp("{ [0,180) }"); |
2928 | 2889 |
2929 // Seek to 0 and check all buffers. | 2890 // Seek to 0 and check all buffers. |
2930 SeekToTimestampMs(0); | 2891 SeekToTimestampMs(0); |
2931 CheckExpectedBuffers("0K 30 60 90K 120 150"); | 2892 CheckExpectedBuffers("0K 30 60 90K 120 150"); |
2932 CheckNoNextBuffer(); | 2893 CheckNoNextBuffer(); |
2933 | 2894 |
2934 // Now seek back to 90ms and append a GOP at 180ms. | 2895 // Now seek back to 90ms and append a GOP at 180ms. |
2935 SeekToTimestampMs(90); | 2896 SeekToTimestampMs(90); |
2936 NewSegmentAppend("180K 210 240"); | 2897 NewCodedFrameGroupAppend("180K 210 240"); |
2937 | 2898 |
2938 // Should save the GOP at 90ms and the GOP at 180ms. | 2899 // Should save the GOP at 90ms and the GOP at 180ms. |
2939 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( | 2900 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( |
2940 DecodeTimestamp::FromMilliseconds(90), 0)); | 2901 DecodeTimestamp::FromMilliseconds(90), 0)); |
2941 CheckExpectedRangesByTimestamp("{ [90,270) }"); | 2902 CheckExpectedRangesByTimestamp("{ [90,270) }"); |
2942 CheckExpectedBuffers("90K 120 150 180K 210 240"); | 2903 CheckExpectedBuffers("90K 120 150 180K 210 240"); |
2943 CheckNoNextBuffer(); | 2904 CheckNoNextBuffer(); |
2944 } | 2905 } |
2945 | 2906 |
2946 // Test saving the last GOP appended when it is at the beginning or end of the | 2907 // Test saving the last GOP appended when it is at the beginning or end of the |
2947 // selected range. This tests when the last GOP appended is before or after the | 2908 // selected range. This tests when the last GOP appended is before or after the |
2948 // GOP containing the next buffer, but not directly adjacent to this GOP. | 2909 // GOP containing the next buffer, but not directly adjacent to this GOP. |
2949 TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Selected2) { | 2910 TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Selected2) { |
2950 // Append 4 GOPs starting at positions 0ms, 90ms, 180ms, 270ms. | 2911 // Append 4 GOPs starting at positions 0ms, 90ms, 180ms, 270ms. |
2951 NewSegmentAppend("0K 30 60 90K 120 150 180K 210 240 270K 300 330"); | 2912 NewCodedFrameGroupAppend("0K 30 60 90K 120 150 180K 210 240 270K 300 330"); |
2952 CheckExpectedRangesByTimestamp("{ [0,360) }"); | 2913 CheckExpectedRangesByTimestamp("{ [0,360) }"); |
2953 | 2914 |
2954 // Seek to the last GOP at 270ms. | 2915 // Seek to the last GOP at 270ms. |
2955 SeekToTimestampMs(270); | 2916 SeekToTimestampMs(270); |
2956 | 2917 |
2957 // Set the memory limit to 1, then overlap the GOP at 90ms. | 2918 // Set the memory limit to 1, then overlap the GOP at 90ms. |
2958 SetMemoryLimit(1); | 2919 SetMemoryLimit(1); |
2959 NewSegmentAppend("90K 120 150"); | 2920 NewCodedFrameGroupAppend("90K 120 150"); |
2960 | 2921 |
2961 // GC will save data in the range where the most recent append has happened | 2922 // GC will save data in the range where the most recent append has happened |
2962 // [0; 180) and the range where the next read position is [270;360) | 2923 // [0; 180) and the range where the next read position is [270;360) |
2963 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( | 2924 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( |
2964 DecodeTimestamp::FromMilliseconds(270), 0)); | 2925 DecodeTimestamp::FromMilliseconds(270), 0)); |
2965 CheckExpectedRangesByTimestamp("{ [0,180) [270,360) }"); | 2926 CheckExpectedRangesByTimestamp("{ [0,180) [270,360) }"); |
2966 | 2927 |
2967 // Add 3 GOPs to the end of the selected range at 360ms, 450ms, and 540ms. | 2928 // Add 3 GOPs to the end of the selected range at 360ms, 450ms, and 540ms. |
2968 NewSegmentAppend("360K 390 420 450K 480 510 540K 570 600"); | 2929 NewCodedFrameGroupAppend("360K 390 420 450K 480 510 540K 570 600"); |
2969 CheckExpectedRangesByTimestamp("{ [0,180) [270,630) }"); | 2930 CheckExpectedRangesByTimestamp("{ [0,180) [270,630) }"); |
2970 | 2931 |
2971 // Overlap the GOP at 450ms and garbage collect to test deleting from the | 2932 // Overlap the GOP at 450ms and garbage collect to test deleting from the |
2972 // back. | 2933 // back. |
2973 NewSegmentAppend("450K 480 510"); | 2934 NewCodedFrameGroupAppend("450K 480 510"); |
2974 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( | 2935 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( |
2975 DecodeTimestamp::FromMilliseconds(270), 0)); | 2936 DecodeTimestamp::FromMilliseconds(270), 0)); |
2976 | 2937 |
2977 // Should save GOPs from GOP at 270ms to GOP at 450ms. | 2938 // Should save GOPs from GOP at 270ms to GOP at 450ms. |
2978 CheckExpectedRangesByTimestamp("{ [270,540) }"); | 2939 CheckExpectedRangesByTimestamp("{ [270,540) }"); |
2979 } | 2940 } |
2980 | 2941 |
2981 // Test saving the last GOP appended when it is the same as the GOP containing | 2942 // Test saving the last GOP appended when it is the same as the GOP containing |
2982 // the next buffer. | 2943 // the next buffer. |
2983 TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Selected3) { | 2944 TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Selected3) { |
2984 // Seek to start of stream. | 2945 // Seek to start of stream. |
2985 SeekToTimestampMs(0); | 2946 SeekToTimestampMs(0); |
2986 | 2947 |
2987 // Append 3 GOPs starting at 0ms, 90ms, 180ms. | 2948 // Append 3 GOPs starting at 0ms, 90ms, 180ms. |
2988 NewSegmentAppend("0K 30 60 90K 120 150 180K 210 240"); | 2949 NewCodedFrameGroupAppend("0K 30 60 90K 120 150 180K 210 240"); |
2989 CheckExpectedRangesByTimestamp("{ [0,270) }"); | 2950 CheckExpectedRangesByTimestamp("{ [0,270) }"); |
2990 | 2951 |
2991 // Set the memory limit to 1 then begin appending the start of a GOP starting | 2952 // Set the memory limit to 1 then begin appending the start of a GOP starting |
2992 // at 0ms. | 2953 // at 0ms. |
2993 SetMemoryLimit(1); | 2954 SetMemoryLimit(1); |
2994 NewSegmentAppend("0K 30"); | 2955 NewCodedFrameGroupAppend("0K 30"); |
2995 | 2956 |
2996 // GC should save the newly appended GOP, which is also the next GOP that | 2957 // GC should save the newly appended GOP, which is also the next GOP that |
2997 // will be returned from the seek request. | 2958 // will be returned from the seek request. |
2998 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( | 2959 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( |
2999 DecodeTimestamp::FromMilliseconds(0), 0)); | 2960 DecodeTimestamp::FromMilliseconds(0), 0)); |
3000 CheckExpectedRangesByTimestamp("{ [0,60) }"); | 2961 CheckExpectedRangesByTimestamp("{ [0,60) }"); |
3001 | 2962 |
3002 // Check the buffers in the range. | 2963 // Check the buffers in the range. |
3003 CheckExpectedBuffers("0K 30"); | 2964 CheckExpectedBuffers("0K 30"); |
3004 CheckNoNextBuffer(); | 2965 CheckNoNextBuffer(); |
3005 | 2966 |
3006 // Continue appending to this buffer. | 2967 // Continue appending to this buffer. |
3007 AppendBuffers("60 90"); | 2968 AppendBuffers("60 90"); |
3008 | 2969 |
3009 // GC should still save the rest of this GOP and should be able to fulfill | 2970 // GC should still save the rest of this GOP and should be able to fulfill |
3010 // the read. | 2971 // the read. |
3011 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( | 2972 EXPECT_FALSE(stream_->GarbageCollectIfNeeded( |
3012 DecodeTimestamp::FromMilliseconds(0), 0)); | 2973 DecodeTimestamp::FromMilliseconds(0), 0)); |
3013 CheckExpectedRangesByTimestamp("{ [0,120) }"); | 2974 CheckExpectedRangesByTimestamp("{ [0,120) }"); |
3014 CheckExpectedBuffers("60 90"); | 2975 CheckExpectedBuffers("60 90"); |
3015 CheckNoNextBuffer(); | 2976 CheckNoNextBuffer(); |
3016 } | 2977 } |
3017 | 2978 |
3018 // Currently disabled because of bug: crbug.com/140875. | 2979 // Currently disabled because of bug: crbug.com/140875. |
3019 TEST_F(SourceBufferStreamTest, DISABLED_GarbageCollection_WaitingForKeyframe) { | 2980 TEST_F(SourceBufferStreamTest, DISABLED_GarbageCollection_WaitingForKeyframe) { |
3020 // Set memory limit to 10 buffers. | 2981 // Set memory limit to 10 buffers. |
3021 SetMemoryLimit(10); | 2982 SetMemoryLimit(10); |
3022 | 2983 |
3023 // Append 5 buffers at positions 10 through 14 and exhaust the buffers. | 2984 // Append 5 buffers at positions 10 through 14 and exhaust the buffers. |
3024 NewSegmentAppend(10, 5, &kDataA); | 2985 NewCodedFrameGroupAppend(10, 5, &kDataA); |
3025 Seek(10); | 2986 Seek(10); |
3026 CheckExpectedBuffers(10, 14, &kDataA); | 2987 CheckExpectedBuffers(10, 14, &kDataA); |
3027 CheckExpectedRanges("{ [10,14) }"); | 2988 CheckExpectedRanges("{ [10,14) }"); |
3028 | 2989 |
3029 // We are now stalled at position 15. | 2990 // We are now stalled at position 15. |
3030 CheckNoNextBuffer(); | 2991 CheckNoNextBuffer(); |
3031 | 2992 |
3032 // Do an end overlap that causes the latter half of the range to be deleted. | 2993 // Do an end overlap that causes the latter half of the range to be deleted. |
3033 NewSegmentAppend(5, 6, &kDataA); | 2994 NewCodedFrameGroupAppend(5, 6, &kDataA); |
3034 CheckNoNextBuffer(); | 2995 CheckNoNextBuffer(); |
3035 CheckExpectedRanges("{ [5,10) }"); | 2996 CheckExpectedRanges("{ [5,10) }"); |
3036 | 2997 |
3037 // Append buffers from position 20 to 29. This should trigger GC. | 2998 // Append buffers from position 20 to 29. This should trigger GC. |
3038 NewSegmentAppend(20, 10, &kDataA); | 2999 NewCodedFrameGroupAppend(20, 10, &kDataA); |
3039 | 3000 |
3040 // GC should keep the keyframe before the seek position 15, and the next 9 | 3001 // GC should keep the keyframe before the seek position 15, and the next 9 |
3041 // buffers closest to the seek position. | 3002 // buffers closest to the seek position. |
3042 CheckNoNextBuffer(); | 3003 CheckNoNextBuffer(); |
3043 CheckExpectedRanges("{ [10,10) [20,28) }"); | 3004 CheckExpectedRanges("{ [10,10) [20,28) }"); |
3044 | 3005 |
3045 // Fulfill the seek by appending one buffer at 15. | 3006 // Fulfill the seek by appending one buffer at 15. |
3046 NewSegmentAppend(15, 1, &kDataA); | 3007 NewCodedFrameGroupAppend(15, 1, &kDataA); |
3047 CheckExpectedBuffers(15, 15, &kDataA); | 3008 CheckExpectedBuffers(15, 15, &kDataA); |
3048 CheckExpectedRanges("{ [15,15) [20,28) }"); | 3009 CheckExpectedRanges("{ [15,15) [20,28) }"); |
3049 } | 3010 } |
3050 | 3011 |
3051 // Test the performance of garbage collection. | 3012 // Test the performance of garbage collection. |
3052 TEST_F(SourceBufferStreamTest, GarbageCollection_Performance) { | 3013 TEST_F(SourceBufferStreamTest, GarbageCollection_Performance) { |
3053 // Force |keyframes_per_second_| to be equal to kDefaultFramesPerSecond. | 3014 // Force |keyframes_per_second_| to be equal to kDefaultFramesPerSecond. |
3054 SetStreamInfo(kDefaultFramesPerSecond, kDefaultFramesPerSecond); | 3015 SetStreamInfo(kDefaultFramesPerSecond, kDefaultFramesPerSecond); |
3055 | 3016 |
3056 const int kBuffersToKeep = 1000; | 3017 const int kBuffersToKeep = 1000; |
3057 SetMemoryLimit(kBuffersToKeep); | 3018 SetMemoryLimit(kBuffersToKeep); |
3058 | 3019 |
3059 int buffers_appended = 0; | 3020 int buffers_appended = 0; |
3060 | 3021 |
3061 NewSegmentAppend(0, kBuffersToKeep); | 3022 NewCodedFrameGroupAppend(0, kBuffersToKeep); |
3062 buffers_appended += kBuffersToKeep; | 3023 buffers_appended += kBuffersToKeep; |
3063 | 3024 |
3064 const int kBuffersToAppend = 1000; | 3025 const int kBuffersToAppend = 1000; |
3065 const int kGarbageCollections = 3; | 3026 const int kGarbageCollections = 3; |
3066 for (int i = 0; i < kGarbageCollections; ++i) { | 3027 for (int i = 0; i < kGarbageCollections; ++i) { |
3067 AppendBuffers(buffers_appended, kBuffersToAppend); | 3028 AppendBuffers(buffers_appended, kBuffersToAppend); |
3068 buffers_appended += kBuffersToAppend; | 3029 buffers_appended += kBuffersToAppend; |
3069 } | 3030 } |
3070 } | 3031 } |
3071 | 3032 |
3072 TEST_F(SourceBufferStreamTest, GarbageCollection_MediaTimeAfterLastAppendTime) { | 3033 TEST_F(SourceBufferStreamTest, GarbageCollection_MediaTimeAfterLastAppendTime) { |
3073 // Set memory limit to 10 buffers. | 3034 // Set memory limit to 10 buffers. |
3074 SetMemoryLimit(10); | 3035 SetMemoryLimit(10); |
3075 | 3036 |
3076 // Append 12 buffers. The duration of the last buffer is 30 | 3037 // Append 12 buffers. The duration of the last buffer is 30 |
3077 NewSegmentAppend("0K 30 60 90 120K 150 180 210K 240 270 300K 330D30"); | 3038 NewCodedFrameGroupAppend("0K 30 60 90 120K 150 180 210K 240 270 300K 330D30"); |
3078 CheckExpectedRangesByTimestamp("{ [0,360) }"); | 3039 CheckExpectedRangesByTimestamp("{ [0,360) }"); |
3079 | 3040 |
3080 // Do a garbage collection with the media time higher than the timestamp of | 3041 // Do a garbage collection with the media time higher than the timestamp of |
3081 // the last appended buffer (330), but still within buffered ranges, taking | 3042 // the last appended buffer (330), but still within buffered ranges, taking |
3082 // into account the duration of the last frame (timestamp of the last frame is | 3043 // into account the duration of the last frame (timestamp of the last frame is |
3083 // 330, duration is 30, so the latest valid buffered position is 330+30=360). | 3044 // 330, duration is 30, so the latest valid buffered position is 330+30=360). |
3084 EXPECT_TRUE(stream_->GarbageCollectIfNeeded( | 3045 EXPECT_TRUE(stream_->GarbageCollectIfNeeded( |
3085 DecodeTimestamp::FromMilliseconds(360), 0)); | 3046 DecodeTimestamp::FromMilliseconds(360), 0)); |
3086 | 3047 |
3087 // GC should collect one GOP from the front to bring us back under memory | 3048 // GC should collect one GOP from the front to bring us back under memory |
3088 // limit of 10 buffers. | 3049 // limit of 10 buffers. |
3089 CheckExpectedRangesByTimestamp("{ [120,360) }"); | 3050 CheckExpectedRangesByTimestamp("{ [120,360) }"); |
3090 } | 3051 } |
3091 | 3052 |
3092 TEST_F(SourceBufferStreamTest, | 3053 TEST_F(SourceBufferStreamTest, |
3093 GarbageCollection_MediaTimeOutsideOfStreamBufferedRange) { | 3054 GarbageCollection_MediaTimeOutsideOfStreamBufferedRange) { |
3094 // Set memory limit to 10 buffers. | 3055 // Set memory limit to 10 buffers. |
3095 SetMemoryLimit(10); | 3056 SetMemoryLimit(10); |
3096 | 3057 |
3097 // Append 12 buffers. | 3058 // Append 12 buffers. |
3098 NewSegmentAppend("0K 30 60 90 120K 150 180 210K 240 270 300K 330"); | 3059 NewCodedFrameGroupAppend("0K 30 60 90 120K 150 180 210K 240 270 300K 330"); |
3099 CheckExpectedRangesByTimestamp("{ [0,360) }"); | 3060 CheckExpectedRangesByTimestamp("{ [0,360) }"); |
3100 | 3061 |
3101 // Seek in order to set the stream read position to 330 an ensure that the | 3062 // Seek in order to set the stream read position to 330 an ensure that the |
3102 // stream selects the buffered range. | 3063 // stream selects the buffered range. |
3103 SeekToTimestampMs(330); | 3064 SeekToTimestampMs(330); |
3104 | 3065 |
3105 // Do a garbage collection with the media time outside the buffered ranges | 3066 // Do a garbage collection with the media time outside the buffered ranges |
3106 // (this might happen when there's both audio and video streams, audio stream | 3067 // (this might happen when there's both audio and video streams, audio stream |
3107 // buffered range is longer than the video stream buffered range, since | 3068 // buffered range is longer than the video stream buffered range, since |
3108 // media::Pipeline uses audio stream as a time source in that case, it might | 3069 // media::Pipeline uses audio stream as a time source in that case, it might |
3109 // return a media_time that is slightly outside of video buffered range). In | 3070 // return a media_time that is slightly outside of video buffered range). In |
3110 // those cases the GC algorithm should clamp the media_time value to the | 3071 // those cases the GC algorithm should clamp the media_time value to the |
3111 // buffered ranges to work correctly (see crbug.com/563292). | 3072 // buffered ranges to work correctly (see crbug.com/563292). |
3112 EXPECT_TRUE(stream_->GarbageCollectIfNeeded( | 3073 EXPECT_TRUE(stream_->GarbageCollectIfNeeded( |
3113 DecodeTimestamp::FromMilliseconds(361), 0)); | 3074 DecodeTimestamp::FromMilliseconds(361), 0)); |
3114 | 3075 |
3115 // GC should collect one GOP from the front to bring us back under memory | 3076 // GC should collect one GOP from the front to bring us back under memory |
3116 // limit of 10 buffers. | 3077 // limit of 10 buffers. |
3117 CheckExpectedRangesByTimestamp("{ [120,360) }"); | 3078 CheckExpectedRangesByTimestamp("{ [120,360) }"); |
3118 } | 3079 } |
3119 | 3080 |
3120 TEST_F(SourceBufferStreamTest, GetRemovalRange_BytesToFree) { | 3081 TEST_F(SourceBufferStreamTest, GetRemovalRange_BytesToFree) { |
3121 // Append 2 GOPs starting at 300ms, 30ms apart. | 3082 // Append 2 GOPs starting at 300ms, 30ms apart. |
3122 NewSegmentAppend("300K 330 360 390K 420 450"); | 3083 NewCodedFrameGroupAppend("300K 330 360 390K 420 450"); |
3123 | 3084 |
3124 // Append 2 GOPs starting at 600ms, 30ms apart. | 3085 // Append 2 GOPs starting at 600ms, 30ms apart. |
3125 NewSegmentAppend("600K 630 660 690K 720 750"); | 3086 NewCodedFrameGroupAppend("600K 630 660 690K 720 750"); |
3126 | 3087 |
3127 // Append 2 GOPs starting at 900ms, 30ms apart. | 3088 // Append 2 GOPs starting at 900ms, 30ms apart. |
3128 NewSegmentAppend("900K 930 960 990K 1020 1050"); | 3089 NewCodedFrameGroupAppend("900K 930 960 990K 1020 1050"); |
3129 | 3090 |
3130 CheckExpectedRangesByTimestamp("{ [300,480) [600,780) [900,1080) }"); | 3091 CheckExpectedRangesByTimestamp("{ [300,480) [600,780) [900,1080) }"); |
3131 | 3092 |
3132 int remove_range_end = -1; | 3093 int remove_range_end = -1; |
3133 int bytes_removed = -1; | 3094 int bytes_removed = -1; |
3134 | 3095 |
3135 // Size 0. | 3096 // Size 0. |
3136 bytes_removed = GetRemovalRangeInMs(300, 1080, 0, &remove_range_end); | 3097 bytes_removed = GetRemovalRangeInMs(300, 1080, 0, &remove_range_end); |
3137 EXPECT_EQ(-1, remove_range_end); | 3098 EXPECT_EQ(-1, remove_range_end); |
3138 EXPECT_EQ(0, bytes_removed); | 3099 EXPECT_EQ(0, bytes_removed); |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3174 EXPECT_EQ(18, bytes_removed); | 3135 EXPECT_EQ(18, bytes_removed); |
3175 | 3136 |
3176 // Larger than the whole ranges. | 3137 // Larger than the whole ranges. |
3177 bytes_removed = GetRemovalRangeInMs(300, 1080, 20, &remove_range_end); | 3138 bytes_removed = GetRemovalRangeInMs(300, 1080, 20, &remove_range_end); |
3178 EXPECT_EQ(1080, remove_range_end); | 3139 EXPECT_EQ(1080, remove_range_end); |
3179 EXPECT_EQ(18, bytes_removed); | 3140 EXPECT_EQ(18, bytes_removed); |
3180 } | 3141 } |
3181 | 3142 |
3182 TEST_F(SourceBufferStreamTest, GetRemovalRange_Range) { | 3143 TEST_F(SourceBufferStreamTest, GetRemovalRange_Range) { |
3183 // Append 2 GOPs starting at 300ms, 30ms apart. | 3144 // Append 2 GOPs starting at 300ms, 30ms apart. |
3184 NewSegmentAppend("300K 330 360 390K 420 450"); | 3145 NewCodedFrameGroupAppend("300K 330 360 390K 420 450"); |
3185 | 3146 |
3186 // Append 2 GOPs starting at 600ms, 30ms apart. | 3147 // Append 2 GOPs starting at 600ms, 30ms apart. |
3187 NewSegmentAppend("600K 630 660 690K 720 750"); | 3148 NewCodedFrameGroupAppend("600K 630 660 690K 720 750"); |
3188 | 3149 |
3189 // Append 2 GOPs starting at 900ms, 30ms apart. | 3150 // Append 2 GOPs starting at 900ms, 30ms apart. |
3190 NewSegmentAppend("900K 930 960 990K 1020 1050"); | 3151 NewCodedFrameGroupAppend("900K 930 960 990K 1020 1050"); |
3191 | 3152 |
3192 CheckExpectedRangesByTimestamp("{ [300,480) [600,780) [900,1080) }"); | 3153 CheckExpectedRangesByTimestamp("{ [300,480) [600,780) [900,1080) }"); |
3193 | 3154 |
3194 int remove_range_end = -1; | 3155 int remove_range_end = -1; |
3195 int bytes_removed = -1; | 3156 int bytes_removed = -1; |
3196 | 3157 |
3197 // Within a GOP and no keyframe. | 3158 // Within a GOP and no keyframe. |
3198 bytes_removed = GetRemovalRangeInMs(630, 660, 20, &remove_range_end); | 3159 bytes_removed = GetRemovalRangeInMs(630, 660, 20, &remove_range_end); |
3199 EXPECT_EQ(-1, remove_range_end); | 3160 EXPECT_EQ(-1, remove_range_end); |
3200 EXPECT_EQ(0, bytes_removed); | 3161 EXPECT_EQ(0, bytes_removed); |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3246 } | 3207 } |
3247 | 3208 |
3248 TEST_F(SourceBufferStreamTest, ConfigChange_Basic) { | 3209 TEST_F(SourceBufferStreamTest, ConfigChange_Basic) { |
3249 VideoDecoderConfig new_config = TestVideoConfig::Large(); | 3210 VideoDecoderConfig new_config = TestVideoConfig::Large(); |
3250 ASSERT_FALSE(new_config.Matches(video_config_)); | 3211 ASSERT_FALSE(new_config.Matches(video_config_)); |
3251 | 3212 |
3252 Seek(0); | 3213 Seek(0); |
3253 CheckVideoConfig(video_config_); | 3214 CheckVideoConfig(video_config_); |
3254 | 3215 |
3255 // Append 5 buffers at positions 0 through 4 | 3216 // Append 5 buffers at positions 0 through 4 |
3256 NewSegmentAppend(0, 5, &kDataA); | 3217 NewCodedFrameGroupAppend(0, 5, &kDataA); |
3257 | 3218 |
3258 CheckVideoConfig(video_config_); | 3219 CheckVideoConfig(video_config_); |
3259 | 3220 |
3260 // Signal a config change. | 3221 // Signal a config change. |
3261 stream_->UpdateVideoConfig(new_config); | 3222 stream_->UpdateVideoConfig(new_config); |
3262 | 3223 |
3263 // Make sure updating the config doesn't change anything since new_config | 3224 // Make sure updating the config doesn't change anything since new_config |
3264 // should not be associated with the buffer GetNextBuffer() will return. | 3225 // should not be associated with the buffer GetNextBuffer() will return. |
3265 CheckVideoConfig(video_config_); | 3226 CheckVideoConfig(video_config_); |
3266 | 3227 |
3267 // Append 5 buffers at positions 5 through 9. | 3228 // Append 5 buffers at positions 5 through 9. |
3268 NewSegmentAppend(5, 5, &kDataB); | 3229 NewCodedFrameGroupAppend(5, 5, &kDataB); |
3269 | 3230 |
3270 // Consume the buffers associated with the initial config. | 3231 // Consume the buffers associated with the initial config. |
3271 scoped_refptr<StreamParserBuffer> buffer; | 3232 scoped_refptr<StreamParserBuffer> buffer; |
3272 for (int i = 0; i < 5; i++) { | 3233 for (int i = 0; i < 5; i++) { |
3273 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kSuccess); | 3234 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kSuccess); |
3274 CheckVideoConfig(video_config_); | 3235 CheckVideoConfig(video_config_); |
3275 } | 3236 } |
3276 | 3237 |
3277 // Verify the next attempt to get a buffer will signal that a config change | 3238 // Verify the next attempt to get a buffer will signal that a config change |
3278 // has happened. | 3239 // has happened. |
3279 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kConfigChange); | 3240 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kConfigChange); |
3280 | 3241 |
3281 // Verify that the new config is now returned. | 3242 // Verify that the new config is now returned. |
3282 CheckVideoConfig(new_config); | 3243 CheckVideoConfig(new_config); |
3283 | 3244 |
3284 // Consume the remaining buffers associated with the new config. | 3245 // Consume the remaining buffers associated with the new config. |
3285 for (int i = 0; i < 5; i++) { | 3246 for (int i = 0; i < 5; i++) { |
3286 CheckVideoConfig(new_config); | 3247 CheckVideoConfig(new_config); |
3287 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kSuccess); | 3248 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kSuccess); |
3288 } | 3249 } |
3289 } | 3250 } |
3290 | 3251 |
3291 TEST_F(SourceBufferStreamTest, ConfigChange_Seek) { | 3252 TEST_F(SourceBufferStreamTest, ConfigChange_Seek) { |
3292 scoped_refptr<StreamParserBuffer> buffer; | 3253 scoped_refptr<StreamParserBuffer> buffer; |
3293 VideoDecoderConfig new_config = TestVideoConfig::Large(); | 3254 VideoDecoderConfig new_config = TestVideoConfig::Large(); |
3294 | 3255 |
3295 Seek(0); | 3256 Seek(0); |
3296 NewSegmentAppend(0, 5, &kDataA); | 3257 NewCodedFrameGroupAppend(0, 5, &kDataA); |
3297 stream_->UpdateVideoConfig(new_config); | 3258 stream_->UpdateVideoConfig(new_config); |
3298 NewSegmentAppend(5, 5, &kDataB); | 3259 NewCodedFrameGroupAppend(5, 5, &kDataB); |
3299 | 3260 |
3300 // Seek to the start of the buffers with the new config and make sure a | 3261 // Seek to the start of the buffers with the new config and make sure a |
3301 // config change is signalled. | 3262 // config change is signalled. |
3302 CheckVideoConfig(video_config_); | 3263 CheckVideoConfig(video_config_); |
3303 Seek(5); | 3264 Seek(5); |
3304 CheckVideoConfig(video_config_); | 3265 CheckVideoConfig(video_config_); |
3305 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kConfigChange); | 3266 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kConfigChange); |
3306 CheckVideoConfig(new_config); | 3267 CheckVideoConfig(new_config); |
3307 CheckExpectedBuffers(5, 9, &kDataB); | 3268 CheckExpectedBuffers(5, 9, &kDataB); |
3308 | 3269 |
(...skipping 11 matching lines...) Expand all Loading... | |
3320 CheckVideoConfig(new_config); | 3281 CheckVideoConfig(new_config); |
3321 Seek(0); | 3282 Seek(0); |
3322 CheckVideoConfig(new_config); | 3283 CheckVideoConfig(new_config); |
3323 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kConfigChange); | 3284 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kConfigChange); |
3324 CheckVideoConfig(video_config_); | 3285 CheckVideoConfig(video_config_); |
3325 CheckExpectedBuffers(0, 4, &kDataA); | 3286 CheckExpectedBuffers(0, 4, &kDataA); |
3326 } | 3287 } |
3327 | 3288 |
3328 TEST_F(SourceBufferStreamTest, SetExplicitDuration) { | 3289 TEST_F(SourceBufferStreamTest, SetExplicitDuration) { |
3329 // Append 2 buffers at positions 5 through 6. | 3290 // Append 2 buffers at positions 5 through 6. |
3330 NewSegmentAppend(5, 2); | 3291 NewCodedFrameGroupAppend(5, 2); |
3331 | 3292 |
3332 // Append 2 buffers at positions 10 through 11. | 3293 // Append 2 buffers at positions 10 through 11. |
3333 NewSegmentAppend(10, 2); | 3294 NewCodedFrameGroupAppend(10, 2); |
3334 | 3295 |
3335 // Append 2 buffers at positions 15 through 16. | 3296 // Append 2 buffers at positions 15 through 16. |
3336 NewSegmentAppend(15, 2); | 3297 NewCodedFrameGroupAppend(15, 2); |
3337 | 3298 |
3338 // Check expected ranges. | 3299 // Check expected ranges. |
3339 CheckExpectedRanges("{ [5,6) [10,11) [15,16) }"); | 3300 CheckExpectedRanges("{ [5,6) [10,11) [15,16) }"); |
3340 | 3301 |
3341 // Set duration to be between buffers 6 and 10. | 3302 // Set duration to be between buffers 6 and 10. |
3342 stream_->OnSetDuration(frame_duration() * 8); | 3303 stream_->OnSetDuration(frame_duration() * 8); |
3343 | 3304 |
3344 // Should truncate the data after 6. | 3305 // Should truncate the data after 6. |
3345 CheckExpectedRanges("{ [5,6) }"); | 3306 CheckExpectedRanges("{ [5,6) }"); |
3346 | 3307 |
3347 // Adding data past the previous duration should still work. | 3308 // Adding data past the previous duration should still work. |
3348 NewSegmentAppend(0, 20); | 3309 NewCodedFrameGroupAppend(0, 20); |
3349 CheckExpectedRanges("{ [0,19) }"); | 3310 CheckExpectedRanges("{ [0,19) }"); |
3350 } | 3311 } |
3351 | 3312 |
3352 TEST_F(SourceBufferStreamTest, SetExplicitDuration_EdgeCase) { | 3313 TEST_F(SourceBufferStreamTest, SetExplicitDuration_EdgeCase) { |
3353 // Append 10 buffers at positions 10 through 19. | 3314 // Append 10 buffers at positions 10 through 19. |
3354 NewSegmentAppend(10, 10); | 3315 NewCodedFrameGroupAppend(10, 10); |
3355 | 3316 |
3356 // Append 5 buffers at positions 25 through 29. | 3317 // Append 5 buffers at positions 25 through 29. |
3357 NewSegmentAppend(25, 5); | 3318 NewCodedFrameGroupAppend(25, 5); |
3358 | 3319 |
3359 // Check expected ranges. | 3320 // Check expected ranges. |
3360 CheckExpectedRanges("{ [10,19) [25,29) }"); | 3321 CheckExpectedRanges("{ [10,19) [25,29) }"); |
3361 | 3322 |
3362 // Set duration to be right before buffer 25. | 3323 // Set duration to be right before buffer 25. |
3363 stream_->OnSetDuration(frame_duration() * 25); | 3324 stream_->OnSetDuration(frame_duration() * 25); |
3364 | 3325 |
3365 // Should truncate the last range. | 3326 // Should truncate the last range. |
3366 CheckExpectedRanges("{ [10,19) }"); | 3327 CheckExpectedRanges("{ [10,19) }"); |
3367 } | 3328 } |
3368 | 3329 |
3369 TEST_F(SourceBufferStreamTest, SetExplicitDuration_DeletePartialRange) { | 3330 TEST_F(SourceBufferStreamTest, SetExplicitDuration_DeletePartialRange) { |
3370 // Append 5 buffers at positions 0 through 4. | 3331 // Append 5 buffers at positions 0 through 4. |
3371 NewSegmentAppend(0, 5); | 3332 NewCodedFrameGroupAppend(0, 5); |
3372 | 3333 |
3373 // Append 10 buffers at positions 10 through 19. | 3334 // Append 10 buffers at positions 10 through 19. |
3374 NewSegmentAppend(10, 10); | 3335 NewCodedFrameGroupAppend(10, 10); |
3375 | 3336 |
3376 // Append 5 buffers at positions 25 through 29. | 3337 // Append 5 buffers at positions 25 through 29. |
3377 NewSegmentAppend(25, 5); | 3338 NewCodedFrameGroupAppend(25, 5); |
3378 | 3339 |
3379 // Check expected ranges. | 3340 // Check expected ranges. |
3380 CheckExpectedRanges("{ [0,4) [10,19) [25,29) }"); | 3341 CheckExpectedRanges("{ [0,4) [10,19) [25,29) }"); |
3381 | 3342 |
3382 // Set duration to be between buffers 13 and 14. | 3343 // Set duration to be between buffers 13 and 14. |
3383 stream_->OnSetDuration(frame_duration() * 14); | 3344 stream_->OnSetDuration(frame_duration() * 14); |
3384 | 3345 |
3385 // Should truncate the data after 13. | 3346 // Should truncate the data after 13. |
3386 CheckExpectedRanges("{ [0,4) [10,13) }"); | 3347 CheckExpectedRanges("{ [0,4) [10,13) }"); |
3387 } | 3348 } |
3388 | 3349 |
3389 TEST_F(SourceBufferStreamTest, SetExplicitDuration_DeleteSelectedRange) { | 3350 TEST_F(SourceBufferStreamTest, SetExplicitDuration_DeleteSelectedRange) { |
3390 // Append 2 buffers at positions 5 through 6. | 3351 // Append 2 buffers at positions 5 through 6. |
3391 NewSegmentAppend(5, 2); | 3352 NewCodedFrameGroupAppend(5, 2); |
3392 | 3353 |
3393 // Append 2 buffers at positions 10 through 11. | 3354 // Append 2 buffers at positions 10 through 11. |
3394 NewSegmentAppend(10, 2); | 3355 NewCodedFrameGroupAppend(10, 2); |
3395 | 3356 |
3396 // Append 2 buffers at positions 15 through 16. | 3357 // Append 2 buffers at positions 15 through 16. |
3397 NewSegmentAppend(15, 2); | 3358 NewCodedFrameGroupAppend(15, 2); |
3398 | 3359 |
3399 // Check expected ranges. | 3360 // Check expected ranges. |
3400 CheckExpectedRanges("{ [5,6) [10,11) [15,16) }"); | 3361 CheckExpectedRanges("{ [5,6) [10,11) [15,16) }"); |
3401 | 3362 |
3402 // Seek to 10. | 3363 // Seek to 10. |
3403 Seek(10); | 3364 Seek(10); |
3404 | 3365 |
3405 // Set duration to be after position 3. | 3366 // Set duration to be after position 3. |
3406 stream_->OnSetDuration(frame_duration() * 4); | 3367 stream_->OnSetDuration(frame_duration() * 4); |
3407 | 3368 |
3408 // Expect everything to be deleted, and should not have next buffer anymore. | 3369 // Expect everything to be deleted, and should not have next buffer anymore. |
3409 CheckNoNextBuffer(); | 3370 CheckNoNextBuffer(); |
3410 CheckExpectedRanges("{ }"); | 3371 CheckExpectedRanges("{ }"); |
3411 | 3372 |
3412 // Appending data at position 10 should not fulfill the seek. | 3373 // Appending data at position 10 should not fulfill the seek. |
3413 // (If the duration is set to be something smaller than the current seek | 3374 // (If the duration is set to be something smaller than the current seek |
3414 // point, then the seek point is reset and the SourceBufferStream waits | 3375 // point, then the seek point is reset and the SourceBufferStream waits |
3415 // for a new seek request. Therefore even if the data is re-appended, it | 3376 // for a new seek request. Therefore even if the data is re-appended, it |
3416 // should not fulfill the old seek.) | 3377 // should not fulfill the old seek.) |
3417 NewSegmentAppend(0, 15); | 3378 NewCodedFrameGroupAppend(0, 15); |
3418 CheckNoNextBuffer(); | 3379 CheckNoNextBuffer(); |
3419 CheckExpectedRanges("{ [0,14) }"); | 3380 CheckExpectedRanges("{ [0,14) }"); |
3420 } | 3381 } |
3421 | 3382 |
3422 TEST_F(SourceBufferStreamTest, SetExplicitDuration_DeletePartialSelectedRange) { | 3383 TEST_F(SourceBufferStreamTest, SetExplicitDuration_DeletePartialSelectedRange) { |
3423 // Append 5 buffers at positions 0 through 4. | 3384 // Append 5 buffers at positions 0 through 4. |
3424 NewSegmentAppend(0, 5); | 3385 NewCodedFrameGroupAppend(0, 5); |
3425 | 3386 |
3426 // Append 20 buffers at positions 10 through 29. | 3387 // Append 20 buffers at positions 10 through 29. |
3427 NewSegmentAppend(10, 20); | 3388 NewCodedFrameGroupAppend(10, 20); |
3428 | 3389 |
3429 // Check expected ranges. | 3390 // Check expected ranges. |
3430 CheckExpectedRanges("{ [0,4) [10,29) }"); | 3391 CheckExpectedRanges("{ [0,4) [10,29) }"); |
3431 | 3392 |
3432 // Seek to position 10. | 3393 // Seek to position 10. |
3433 Seek(10); | 3394 Seek(10); |
3434 | 3395 |
3435 // Set duration to be between buffers 24 and 25. | 3396 // Set duration to be between buffers 24 and 25. |
3436 stream_->OnSetDuration(frame_duration() * 25); | 3397 stream_->OnSetDuration(frame_duration() * 25); |
3437 | 3398 |
(...skipping 12 matching lines...) Expand all Loading... | |
3450 } | 3411 } |
3451 | 3412 |
3452 // Test the case where duration is set while the stream parser buffers | 3413 // Test the case where duration is set while the stream parser buffers |
3453 // already start passing the data to decoding pipeline. Selected range, | 3414 // already start passing the data to decoding pipeline. Selected range, |
3454 // when invalidated by getting truncated, should be updated to NULL | 3415 // when invalidated by getting truncated, should be updated to NULL |
3455 // accordingly so that successive append operations keep working. | 3416 // accordingly so that successive append operations keep working. |
3456 TEST_F(SourceBufferStreamTest, SetExplicitDuration_UpdateSelectedRange) { | 3417 TEST_F(SourceBufferStreamTest, SetExplicitDuration_UpdateSelectedRange) { |
3457 // Seek to start of stream. | 3418 // Seek to start of stream. |
3458 SeekToTimestampMs(0); | 3419 SeekToTimestampMs(0); |
3459 | 3420 |
3460 NewSegmentAppend("0K 30 60 90"); | 3421 NewCodedFrameGroupAppend("0K 30 60 90"); |
3461 | 3422 |
3462 // Read out the first few buffers. | 3423 // Read out the first few buffers. |
3463 CheckExpectedBuffers("0K 30"); | 3424 CheckExpectedBuffers("0K 30"); |
3464 | 3425 |
3465 // Set duration to be right before buffer 1. | 3426 // Set duration to be right before buffer 1. |
3466 stream_->OnSetDuration(base::TimeDelta::FromMilliseconds(60)); | 3427 stream_->OnSetDuration(base::TimeDelta::FromMilliseconds(60)); |
3467 | 3428 |
3468 // Verify that there is no next buffer. | 3429 // Verify that there is no next buffer. |
3469 CheckNoNextBuffer(); | 3430 CheckNoNextBuffer(); |
3470 | 3431 |
3471 // We should be able to append new buffers at this point. | 3432 // We should be able to append new buffers at this point. |
3472 NewSegmentAppend("120K 150"); | 3433 NewCodedFrameGroupAppend("120K 150"); |
3473 | 3434 |
3474 CheckExpectedRangesByTimestamp("{ [0,60) [120,180) }"); | 3435 CheckExpectedRangesByTimestamp("{ [0,60) [120,180) }"); |
3475 } | 3436 } |
3476 | 3437 |
3477 TEST_F(SourceBufferStreamTest, | 3438 TEST_F(SourceBufferStreamTest, |
3478 SetExplicitDuration_AfterSegmentTimestampAndBeforeFirstBufferTimestamp) { | 3439 SetExplicitDuration_AfterGroupTimestampAndBeforeFirstBufferTimestamp) { |
3440 NewCodedFrameGroupAppend("0K 30K 60K"); | |
3479 | 3441 |
3480 NewSegmentAppend("0K 30K 60K"); | 3442 // Append a coded frame group with a start timestamp of 200, but the first |
3481 | |
3482 // Append a segment with a start timestamp of 200, but the first | |
3483 // buffer starts at 230ms. This can happen in muxed content where the | 3443 // buffer starts at 230ms. This can happen in muxed content where the |
3484 // audio starts before the first frame. | 3444 // audio starts before the first frame. |
3485 NewSegmentAppend(base::TimeDelta::FromMilliseconds(200), | 3445 NewCodedFrameGroupAppend(base::TimeDelta::FromMilliseconds(200), |
3486 "230K 260K 290K 320K"); | 3446 "230K 260K 290K 320K"); |
3487 | 3447 |
3488 NewSegmentAppend("400K 430K 460K"); | 3448 NewCodedFrameGroupAppend("400K 430K 460K"); |
3489 | 3449 |
3490 CheckExpectedRangesByTimestamp("{ [0,90) [200,350) [400,490) }"); | 3450 CheckExpectedRangesByTimestamp("{ [0,90) [200,350) [400,490) }"); |
3491 | 3451 |
3492 stream_->OnSetDuration(base::TimeDelta::FromMilliseconds(120)); | 3452 stream_->OnSetDuration(base::TimeDelta::FromMilliseconds(120)); |
3493 | 3453 |
3494 // Verify that the buffered ranges are updated properly and we don't crash. | 3454 // Verify that the buffered ranges are updated properly and we don't crash. |
3495 CheckExpectedRangesByTimestamp("{ [0,90) }"); | 3455 CheckExpectedRangesByTimestamp("{ [0,90) }"); |
3496 } | 3456 } |
3497 | 3457 |
3498 TEST_F(SourceBufferStreamTest, SetExplicitDuration_MarkEOS) { | 3458 TEST_F(SourceBufferStreamTest, SetExplicitDuration_MarkEOS) { |
3499 // Append 1 buffer at positions 0 through 8. | 3459 // Append 1 buffer at positions 0 through 8. |
3500 NewSegmentAppend(0, 9); | 3460 NewCodedFrameGroupAppend(0, 9); |
3501 | 3461 |
3502 // Check expected ranges. | 3462 // Check expected ranges. |
3503 CheckExpectedRanges("{ [0,8) }"); | 3463 CheckExpectedRanges("{ [0,8) }"); |
3504 | 3464 |
3505 // Seek to 5. | 3465 // Seek to 5. |
3506 Seek(5); | 3466 Seek(5); |
3507 | 3467 |
3508 // Set duration to be before the seeked to position. | 3468 // Set duration to be before the seeked to position. |
3509 // This will result in truncation of the selected range and a reset | 3469 // This will result in truncation of the selected range and a reset |
3510 // of NextBufferPosition. | 3470 // of NextBufferPosition. |
3511 stream_->OnSetDuration(frame_duration() * 4); | 3471 stream_->OnSetDuration(frame_duration() * 4); |
3512 | 3472 |
3513 // Check the expected ranges. | 3473 // Check the expected ranges. |
3514 CheckExpectedRanges("{ [0,3) }"); | 3474 CheckExpectedRanges("{ [0,3) }"); |
3515 | 3475 |
3516 // Mark EOS reached. | 3476 // Mark EOS reached. |
3517 stream_->MarkEndOfStream(); | 3477 stream_->MarkEndOfStream(); |
3518 | 3478 |
3519 // Expect EOS to be reached. | 3479 // Expect EOS to be reached. |
3520 CheckEOSReached(); | 3480 CheckEOSReached(); |
3521 } | 3481 } |
3522 | 3482 |
3523 TEST_F(SourceBufferStreamTest, SetExplicitDuration_MarkEOS_IsSeekPending) { | 3483 TEST_F(SourceBufferStreamTest, SetExplicitDuration_MarkEOS_IsSeekPending) { |
3524 // Append 1 buffer at positions 0 through 8. | 3484 // Append 1 buffer at positions 0 through 8. |
3525 NewSegmentAppend(0, 9); | 3485 NewCodedFrameGroupAppend(0, 9); |
3526 | 3486 |
3527 // Check expected ranges. | 3487 // Check expected ranges. |
3528 CheckExpectedRanges("{ [0,8) }"); | 3488 CheckExpectedRanges("{ [0,8) }"); |
3529 | 3489 |
3530 // Seek to 9 which will result in a pending seek. | 3490 // Seek to 9 which will result in a pending seek. |
3531 Seek(9); | 3491 Seek(9); |
3532 | 3492 |
3533 // Set duration to be before the seeked to position. | 3493 // Set duration to be before the seeked to position. |
3534 // This will result in truncation of the selected range and a reset | 3494 // This will result in truncation of the selected range and a reset |
3535 // of NextBufferPosition. | 3495 // of NextBufferPosition. |
3536 stream_->OnSetDuration(frame_duration() * 4); | 3496 stream_->OnSetDuration(frame_duration() * 4); |
3537 | 3497 |
3538 // Check the expected ranges. | 3498 // Check the expected ranges. |
3539 CheckExpectedRanges("{ [0,3) }"); | 3499 CheckExpectedRanges("{ [0,3) }"); |
3540 | 3500 |
3541 EXPECT_TRUE(stream_->IsSeekPending()); | 3501 EXPECT_TRUE(stream_->IsSeekPending()); |
3542 // Mark EOS reached. | 3502 // Mark EOS reached. |
3543 stream_->MarkEndOfStream(); | 3503 stream_->MarkEndOfStream(); |
3544 EXPECT_FALSE(stream_->IsSeekPending()); | 3504 EXPECT_FALSE(stream_->IsSeekPending()); |
3545 } | 3505 } |
3546 | 3506 |
3547 // Test the case were the current playback position is at the end of the | 3507 // Test the case were the current playback position is at the end of the |
3548 // buffered data and several overlaps occur that causes the selected | 3508 // buffered data and several overlaps occur that causes the selected |
3549 // range to get split and then merged back into a single range. | 3509 // range to get split and then merged back into a single range. |
3550 TEST_F(SourceBufferStreamTest, OverlapSplitAndMergeWhileWaitingForMoreData) { | 3510 TEST_F(SourceBufferStreamTest, OverlapSplitAndMergeWhileWaitingForMoreData) { |
3551 // Seek to start of stream. | 3511 // Seek to start of stream. |
3552 SeekToTimestampMs(0); | 3512 SeekToTimestampMs(0); |
3553 | 3513 |
3554 NewSegmentAppend("0K 30 60 90 120K 150"); | 3514 NewCodedFrameGroupAppend("0K 30 60 90 120K 150"); |
3555 CheckExpectedRangesByTimestamp("{ [0,180) }"); | 3515 CheckExpectedRangesByTimestamp("{ [0,180) }"); |
3556 | 3516 |
3557 // Read all the buffered data. | 3517 // Read all the buffered data. |
3558 CheckExpectedBuffers("0K 30 60 90 120K 150"); | 3518 CheckExpectedBuffers("0K 30 60 90 120K 150"); |
3559 CheckNoNextBuffer(); | 3519 CheckNoNextBuffer(); |
3560 | 3520 |
3561 // Append data over the current GOP so that a keyframe is needed before | 3521 // Append data over the current GOP so that a keyframe is needed before |
3562 // playback can continue from the current position. | 3522 // playback can continue from the current position. |
3563 NewSegmentAppend("120K 150"); | 3523 NewCodedFrameGroupAppend("120K 150"); |
3564 CheckExpectedRangesByTimestamp("{ [0,180) }"); | 3524 CheckExpectedRangesByTimestamp("{ [0,180) }"); |
3565 | 3525 |
3566 // Append buffers that cause the range to get split. | 3526 // Append buffers that cause the range to get split. |
3567 NewSegmentAppend("0K 30"); | 3527 NewCodedFrameGroupAppend("0K 30"); |
3568 CheckExpectedRangesByTimestamp("{ [0,60) [120,180) }"); | 3528 CheckExpectedRangesByTimestamp("{ [0,60) [120,180) }"); |
3569 | 3529 |
3570 // Append buffers that cause the ranges to get merged. | 3530 // Append buffers that cause the ranges to get merged. |
3571 AppendBuffers("60 90"); | 3531 AppendBuffers("60 90"); |
3572 | 3532 |
3573 CheckExpectedRangesByTimestamp("{ [0,180) }"); | 3533 CheckExpectedRangesByTimestamp("{ [0,180) }"); |
3574 | 3534 |
3575 // Verify that we still don't have a next buffer. | 3535 // Verify that we still don't have a next buffer. |
3576 CheckNoNextBuffer(); | 3536 CheckNoNextBuffer(); |
3577 | 3537 |
3578 // Add more data to the end and verify that this new data is read correctly. | 3538 // Add more data to the end and verify that this new data is read correctly. |
3579 NewSegmentAppend("180K 210"); | 3539 NewCodedFrameGroupAppend("180K 210"); |
3580 CheckExpectedRangesByTimestamp("{ [0,240) }"); | 3540 CheckExpectedRangesByTimestamp("{ [0,240) }"); |
3581 CheckExpectedBuffers("180K 210"); | 3541 CheckExpectedBuffers("180K 210"); |
3582 } | 3542 } |
3583 | 3543 |
3584 // Verify that non-keyframes with the same timestamp in the same | 3544 // Verify that non-keyframes with the same timestamp in the same |
3585 // append are handled correctly. | 3545 // append are handled correctly. |
3586 TEST_F(SourceBufferStreamTest, SameTimestamp_Video_SingleAppend) { | 3546 TEST_F(SourceBufferStreamTest, SameTimestamp_Video_SingleAppend) { |
3587 Seek(0); | 3547 Seek(0); |
3588 NewSegmentAppend("0K 30 30 60 90 120K 150"); | 3548 NewCodedFrameGroupAppend("0K 30 30 60 90 120K 150"); |
3589 CheckExpectedBuffers("0K 30 30 60 90 120K 150"); | 3549 CheckExpectedBuffers("0K 30 30 60 90 120K 150"); |
3590 } | 3550 } |
3591 | 3551 |
3592 // Verify that non-keyframes with the same timestamp can occur | 3552 // Verify that non-keyframes with the same timestamp can occur |
3593 // in different appends. | 3553 // in different appends. |
3594 TEST_F(SourceBufferStreamTest, SameTimestamp_Video_TwoAppends) { | 3554 TEST_F(SourceBufferStreamTest, SameTimestamp_Video_TwoAppends) { |
3595 Seek(0); | 3555 Seek(0); |
3596 NewSegmentAppend("0K 30"); | 3556 NewCodedFrameGroupAppend("0K 30"); |
3597 AppendBuffers("30 60 90 120K 150"); | 3557 AppendBuffers("30 60 90 120K 150"); |
3598 CheckExpectedBuffers("0K 30 30 60 90 120K 150"); | 3558 CheckExpectedBuffers("0K 30 30 60 90 120K 150"); |
3599 } | 3559 } |
3600 | 3560 |
3601 // Verify that a non-keyframe followed by a keyframe with the same timestamp | 3561 // Verify that a non-keyframe followed by a keyframe with the same timestamp |
3602 // is not allowed. | 3562 // is allowed, but also results in a MediaLog. |
3603 TEST_F(SourceBufferStreamTest, SameTimestamp_Video_Invalid_1) { | 3563 TEST_F(SourceBufferStreamTest, SameTimestamp_Video_SingleAppend_Warning) { |
3604 EXPECT_MEDIA_LOG(ContainsSameTimestampAt30MillisecondsLog()); | 3564 EXPECT_MEDIA_LOG(ContainsSameTimestampAt30MillisecondsLog()); |
3605 | 3565 |
3606 Seek(0); | 3566 Seek(0); |
3607 NewSegmentAppend("0K 30"); | 3567 NewCodedFrameGroupAppend("0K 30 30K 60"); |
3608 AppendBuffers_ExpectFailure("30K 60"); | 3568 CheckExpectedBuffers("0K 30 30K 60"); |
3609 } | 3569 } |
3610 | 3570 |
3611 TEST_F(SourceBufferStreamTest, SameTimestamp_Video_Invalid_2) { | 3571 TEST_F(SourceBufferStreamTest, SameTimestamp_Video_TwoAppends_Warning) { |
3612 EXPECT_MEDIA_LOG(ContainsSameTimestampAt30MillisecondsLog()); | 3572 EXPECT_MEDIA_LOG(ContainsSameTimestampAt30MillisecondsLog()); |
3613 | 3573 |
3614 Seek(0); | 3574 Seek(0); |
3615 NewSegmentAppend_ExpectFailure("0K 30 30K 60"); | 3575 NewCodedFrameGroupAppend("0K 30"); |
3576 AppendBuffers("30K 60"); | |
3577 CheckExpectedBuffers("0K 30 30K 60"); | |
3616 } | 3578 } |
3617 | 3579 |
3618 // Verify that a keyframe followed by a non-keyframe with the same timestamp | 3580 // Verify that a keyframe followed by a non-keyframe with the same timestamp |
3619 // is allowed. | 3581 // is allowed. |
3620 TEST_F(SourceBufferStreamTest, SameTimestamp_VideoKeyFrame_TwoAppends) { | 3582 TEST_F(SourceBufferStreamTest, SameTimestamp_VideoKeyFrame_TwoAppends) { |
3621 Seek(0); | 3583 Seek(0); |
3622 NewSegmentAppend("0K 30K"); | 3584 NewCodedFrameGroupAppend("0K 30K"); |
3623 AppendBuffers("30 60"); | 3585 AppendBuffers("30 60"); |
3624 CheckExpectedBuffers("0K 30K 30 60"); | 3586 CheckExpectedBuffers("0K 30K 30 60"); |
3625 } | 3587 } |
3626 | 3588 |
3627 TEST_F(SourceBufferStreamTest, SameTimestamp_VideoKeyFrame_SingleAppend) { | 3589 TEST_F(SourceBufferStreamTest, SameTimestamp_VideoKeyFrame_SingleAppend) { |
3628 Seek(0); | 3590 Seek(0); |
3629 NewSegmentAppend("0K 30K 30 60"); | 3591 NewCodedFrameGroupAppend("0K 30K 30 60"); |
3630 CheckExpectedBuffers("0K 30K 30 60"); | 3592 CheckExpectedBuffers("0K 30K 30 60"); |
3631 } | 3593 } |
3632 | 3594 |
3633 TEST_F(SourceBufferStreamTest, SameTimestamp_Video_Overlap_1) { | 3595 TEST_F(SourceBufferStreamTest, SameTimestamp_Video_Overlap_1) { |
3634 Seek(0); | 3596 Seek(0); |
3635 NewSegmentAppend("0K 30 60 60 90 120K 150"); | 3597 NewCodedFrameGroupAppend("0K 30 60 60 90 120K 150"); |
3636 | 3598 |
3637 NewSegmentAppend("60K 91 121K 151"); | 3599 NewCodedFrameGroupAppend("60K 91 121K 151"); |
3638 CheckExpectedBuffers("0K 30 60K 91 121K 151"); | 3600 CheckExpectedBuffers("0K 30 60K 91 121K 151"); |
3639 } | 3601 } |
3640 | 3602 |
3641 TEST_F(SourceBufferStreamTest, SameTimestamp_Video_Overlap_2) { | 3603 TEST_F(SourceBufferStreamTest, SameTimestamp_Video_Overlap_2) { |
3642 Seek(0); | 3604 Seek(0); |
3643 NewSegmentAppend("0K 30 60 60 90 120K 150"); | 3605 NewCodedFrameGroupAppend("0K 30 60 60 90 120K 150"); |
3644 NewSegmentAppend("0K 30 61"); | 3606 NewCodedFrameGroupAppend("0K 30 61"); |
3645 CheckExpectedBuffers("0K 30 61 120K 150"); | 3607 CheckExpectedBuffers("0K 30 61 120K 150"); |
3646 } | 3608 } |
3647 | 3609 |
3648 TEST_F(SourceBufferStreamTest, SameTimestamp_Video_Overlap_3) { | 3610 TEST_F(SourceBufferStreamTest, SameTimestamp_Video_Overlap_3) { |
3649 Seek(0); | 3611 Seek(0); |
3650 NewSegmentAppend("0K 20 40 60 80 100K 101 102 103K"); | 3612 NewCodedFrameGroupAppend("0K 20 40 60 80 100K 101 102 103K"); |
3651 NewSegmentAppend("0K 20 40 60 80 90"); | 3613 NewCodedFrameGroupAppend("0K 20 40 60 80 90"); |
3652 CheckExpectedBuffers("0K 20 40 60 80 90 100K 101 102 103K"); | 3614 CheckExpectedBuffers("0K 20 40 60 80 90 100K 101 102 103K"); |
3653 AppendBuffers("90 110K 150"); | 3615 AppendBuffers("90 110K 150"); |
3654 Seek(0); | 3616 Seek(0); |
3655 CheckExpectedBuffers("0K 20 40 60 80 90 90 110K 150"); | 3617 CheckExpectedBuffers("0K 20 40 60 80 90 90 110K 150"); |
3656 CheckNoNextBuffer(); | 3618 CheckNoNextBuffer(); |
3657 CheckExpectedRangesByTimestamp("{ [0,190) }"); | 3619 CheckExpectedRangesByTimestamp("{ [0,190) }"); |
3658 } | 3620 } |
3659 | 3621 |
3660 // Test all the valid same timestamp cases for audio. | 3622 // Test all the valid same timestamp cases for audio. |
3661 TEST_F(SourceBufferStreamTest, SameTimestamp_Audio) { | 3623 TEST_F(SourceBufferStreamTest, SameTimestamp_Audio) { |
3662 AudioDecoderConfig config(kCodecMP3, kSampleFormatF32, CHANNEL_LAYOUT_STEREO, | 3624 AudioDecoderConfig config(kCodecMP3, kSampleFormatF32, CHANNEL_LAYOUT_STEREO, |
3663 44100, EmptyExtraData(), false); | 3625 44100, EmptyExtraData(), false); |
3664 stream_.reset(new SourceBufferStream(config, media_log_, true)); | 3626 stream_.reset(new SourceBufferStream(config, media_log_, true)); |
3665 Seek(0); | 3627 Seek(0); |
3666 NewSegmentAppend("0K 0K 30K 30 60 60"); | 3628 NewCodedFrameGroupAppend("0K 0K 30K 30 60 60"); |
3667 CheckExpectedBuffers("0K 0K 30K 30 60 60"); | 3629 CheckExpectedBuffers("0K 0K 30K 30 60 60"); |
3668 } | 3630 } |
3669 | 3631 |
3670 TEST_F(SourceBufferStreamTest, SameTimestamp_Audio_Invalid_1) { | 3632 TEST_F(SourceBufferStreamTest, SameTimestamp_Audio_SingleAppend_Warning) { |
3671 EXPECT_MEDIA_LOG(ContainsSameTimestampAt30MillisecondsLog()); | 3633 EXPECT_MEDIA_LOG(ContainsSameTimestampAt30MillisecondsLog()); |
3672 | 3634 |
3673 AudioDecoderConfig config(kCodecMP3, kSampleFormatF32, CHANNEL_LAYOUT_STEREO, | 3635 AudioDecoderConfig config(kCodecMP3, kSampleFormatF32, CHANNEL_LAYOUT_STEREO, |
3674 44100, EmptyExtraData(), false); | 3636 44100, EmptyExtraData(), false); |
3675 stream_.reset(new SourceBufferStream(config, media_log_, true)); | 3637 stream_.reset(new SourceBufferStream(config, media_log_, true)); |
3676 Seek(0); | 3638 Seek(0); |
3677 NewSegmentAppend_ExpectFailure("0K 30 30K 60"); | 3639 |
3640 // Note, in reality, a non-keyframe audio frame is rare or perhaps not | |
3641 // possible. | |
3642 NewCodedFrameGroupAppend("0K 30 30K 60"); | |
3643 CheckExpectedBuffers("0K 30 30K 60"); | |
3678 } | 3644 } |
3679 | 3645 |
3680 // If seeking past any existing range and the seek is pending | 3646 // If seeking past any existing range and the seek is pending |
3681 // because no data has been provided for that position, | 3647 // because no data has been provided for that position, |
3682 // the stream position can be considered as the end of stream. | 3648 // the stream position can be considered as the end of stream. |
3683 TEST_F(SourceBufferStreamTest, EndSelected_During_PendingSeek) { | 3649 TEST_F(SourceBufferStreamTest, EndSelected_During_PendingSeek) { |
3684 // Append 15 buffers at positions 0 through 14. | 3650 // Append 15 buffers at positions 0 through 14. |
3685 NewSegmentAppend(0, 15); | 3651 NewCodedFrameGroupAppend(0, 15); |
3686 | 3652 |
3687 Seek(20); | 3653 Seek(20); |
3688 EXPECT_TRUE(stream_->IsSeekPending()); | 3654 EXPECT_TRUE(stream_->IsSeekPending()); |
3689 stream_->MarkEndOfStream(); | 3655 stream_->MarkEndOfStream(); |
3690 EXPECT_FALSE(stream_->IsSeekPending()); | 3656 EXPECT_FALSE(stream_->IsSeekPending()); |
3691 } | 3657 } |
3692 | 3658 |
3693 // If there is a pending seek between 2 existing ranges, | 3659 // If there is a pending seek between 2 existing ranges, |
3694 // the end of the stream has not been reached. | 3660 // the end of the stream has not been reached. |
3695 TEST_F(SourceBufferStreamTest, EndNotSelected_During_PendingSeek) { | 3661 TEST_F(SourceBufferStreamTest, EndNotSelected_During_PendingSeek) { |
3696 // Append: | 3662 // Append: |
3697 // - 10 buffers at positions 0 through 9. | 3663 // - 10 buffers at positions 0 through 9. |
3698 // - 10 buffers at positions 30 through 39 | 3664 // - 10 buffers at positions 30 through 39 |
3699 NewSegmentAppend(0, 10); | 3665 NewCodedFrameGroupAppend(0, 10); |
3700 NewSegmentAppend(30, 10); | 3666 NewCodedFrameGroupAppend(30, 10); |
3701 | 3667 |
3702 Seek(20); | 3668 Seek(20); |
3703 EXPECT_TRUE(stream_->IsSeekPending()); | 3669 EXPECT_TRUE(stream_->IsSeekPending()); |
3704 stream_->MarkEndOfStream(); | 3670 stream_->MarkEndOfStream(); |
3705 EXPECT_TRUE(stream_->IsSeekPending()); | 3671 EXPECT_TRUE(stream_->IsSeekPending()); |
3706 } | 3672 } |
3707 | 3673 |
3708 | 3674 |
3709 // Removing exact start & end of a range. | 3675 // Removing exact start & end of a range. |
3710 TEST_F(SourceBufferStreamTest, Remove_WholeRange1) { | 3676 TEST_F(SourceBufferStreamTest, Remove_WholeRange1) { |
3711 Seek(0); | 3677 Seek(0); |
3712 NewSegmentAppend("10K 40 70K 100 130K"); | 3678 NewCodedFrameGroupAppend("10K 40 70K 100 130K"); |
3713 CheckExpectedRangesByTimestamp("{ [10,160) }"); | 3679 CheckExpectedRangesByTimestamp("{ [10,160) }"); |
3714 RemoveInMs(10, 160, 160); | 3680 RemoveInMs(10, 160, 160); |
3715 CheckExpectedRangesByTimestamp("{ }"); | 3681 CheckExpectedRangesByTimestamp("{ }"); |
3716 } | 3682 } |
3717 | 3683 |
3718 // Removal range starts before range and ends exactly at end. | 3684 // Removal range starts before range and ends exactly at end. |
3719 TEST_F(SourceBufferStreamTest, Remove_WholeRange2) { | 3685 TEST_F(SourceBufferStreamTest, Remove_WholeRange2) { |
3720 Seek(0); | 3686 Seek(0); |
3721 NewSegmentAppend("10K 40 70K 100 130K"); | 3687 NewCodedFrameGroupAppend("10K 40 70K 100 130K"); |
3722 CheckExpectedRangesByTimestamp("{ [10,160) }"); | 3688 CheckExpectedRangesByTimestamp("{ [10,160) }"); |
3723 RemoveInMs(0, 160, 160); | 3689 RemoveInMs(0, 160, 160); |
3724 CheckExpectedRangesByTimestamp("{ }"); | 3690 CheckExpectedRangesByTimestamp("{ }"); |
3725 } | 3691 } |
3726 | 3692 |
3727 // Removal range starts at the start of a range and ends beyond the | 3693 // Removal range starts at the start of a range and ends beyond the |
3728 // range end. | 3694 // range end. |
3729 TEST_F(SourceBufferStreamTest, Remove_WholeRange3) { | 3695 TEST_F(SourceBufferStreamTest, Remove_WholeRange3) { |
3730 Seek(0); | 3696 Seek(0); |
3731 NewSegmentAppend("10K 40 70K 100 130K"); | 3697 NewCodedFrameGroupAppend("10K 40 70K 100 130K"); |
3732 CheckExpectedRangesByTimestamp("{ [10,160) }"); | 3698 CheckExpectedRangesByTimestamp("{ [10,160) }"); |
3733 RemoveInMs(10, 200, 200); | 3699 RemoveInMs(10, 200, 200); |
3734 CheckExpectedRangesByTimestamp("{ }"); | 3700 CheckExpectedRangesByTimestamp("{ }"); |
3735 } | 3701 } |
3736 | 3702 |
3737 // Removal range starts before range start and ends after the range end. | 3703 // Removal range starts before range start and ends after the range end. |
3738 TEST_F(SourceBufferStreamTest, Remove_WholeRange4) { | 3704 TEST_F(SourceBufferStreamTest, Remove_WholeRange4) { |
3739 Seek(0); | 3705 Seek(0); |
3740 NewSegmentAppend("10K 40 70K 100 130K"); | 3706 NewCodedFrameGroupAppend("10K 40 70K 100 130K"); |
3741 CheckExpectedRangesByTimestamp("{ [10,160) }"); | 3707 CheckExpectedRangesByTimestamp("{ [10,160) }"); |
3742 RemoveInMs(0, 200, 200); | 3708 RemoveInMs(0, 200, 200); |
3743 CheckExpectedRangesByTimestamp("{ }"); | 3709 CheckExpectedRangesByTimestamp("{ }"); |
3744 } | 3710 } |
3745 | 3711 |
3746 // Removes multiple ranges. | 3712 // Removes multiple ranges. |
3747 TEST_F(SourceBufferStreamTest, Remove_WholeRange5) { | 3713 TEST_F(SourceBufferStreamTest, Remove_WholeRange5) { |
3748 Seek(0); | 3714 Seek(0); |
3749 NewSegmentAppend("10K 40 70K 100 130K"); | 3715 NewCodedFrameGroupAppend("10K 40 70K 100 130K"); |
3750 NewSegmentAppend("1000K 1030 1060K 1090 1120K"); | 3716 NewCodedFrameGroupAppend("1000K 1030 1060K 1090 1120K"); |
3751 NewSegmentAppend("2000K 2030 2060K 2090 2120K"); | 3717 NewCodedFrameGroupAppend("2000K 2030 2060K 2090 2120K"); |
3752 CheckExpectedRangesByTimestamp("{ [10,160) [1000,1150) [2000,2150) }"); | 3718 CheckExpectedRangesByTimestamp("{ [10,160) [1000,1150) [2000,2150) }"); |
3753 RemoveInMs(10, 3000, 3000); | 3719 RemoveInMs(10, 3000, 3000); |
3754 CheckExpectedRangesByTimestamp("{ }"); | 3720 CheckExpectedRangesByTimestamp("{ }"); |
3755 } | 3721 } |
3756 | 3722 |
3757 // Verifies a [0-infinity) range removes everything. | 3723 // Verifies a [0-infinity) range removes everything. |
3758 TEST_F(SourceBufferStreamTest, Remove_ZeroToInfinity) { | 3724 TEST_F(SourceBufferStreamTest, Remove_ZeroToInfinity) { |
3759 Seek(0); | 3725 Seek(0); |
3760 NewSegmentAppend("10K 40 70K 100 130K"); | 3726 NewCodedFrameGroupAppend("10K 40 70K 100 130K"); |
3761 NewSegmentAppend("1000K 1030 1060K 1090 1120K"); | 3727 NewCodedFrameGroupAppend("1000K 1030 1060K 1090 1120K"); |
3762 NewSegmentAppend("2000K 2030 2060K 2090 2120K"); | 3728 NewCodedFrameGroupAppend("2000K 2030 2060K 2090 2120K"); |
3763 CheckExpectedRangesByTimestamp("{ [10,160) [1000,1150) [2000,2150) }"); | 3729 CheckExpectedRangesByTimestamp("{ [10,160) [1000,1150) [2000,2150) }"); |
3764 Remove(base::TimeDelta(), kInfiniteDuration(), kInfiniteDuration()); | 3730 Remove(base::TimeDelta(), kInfiniteDuration(), kInfiniteDuration()); |
3765 CheckExpectedRangesByTimestamp("{ }"); | 3731 CheckExpectedRangesByTimestamp("{ }"); |
3766 } | 3732 } |
3767 | 3733 |
3768 // Removal range starts at the beginning of the range and ends in the | 3734 // Removal range starts at the beginning of the range and ends in the |
3769 // middle of the range. This test verifies that full GOPs are removed. | 3735 // middle of the range. This test verifies that full GOPs are removed. |
3770 TEST_F(SourceBufferStreamTest, Remove_Partial1) { | 3736 TEST_F(SourceBufferStreamTest, Remove_Partial1) { |
3771 Seek(0); | 3737 Seek(0); |
3772 NewSegmentAppend("10K 40 70K 100 130K"); | 3738 NewCodedFrameGroupAppend("10K 40 70K 100 130K"); |
3773 NewSegmentAppend("1000K 1030 1060K 1090 1120K"); | 3739 NewCodedFrameGroupAppend("1000K 1030 1060K 1090 1120K"); |
3774 CheckExpectedRangesByTimestamp("{ [10,160) [1000,1150) }"); | 3740 CheckExpectedRangesByTimestamp("{ [10,160) [1000,1150) }"); |
3775 RemoveInMs(0, 80, 2200); | 3741 RemoveInMs(0, 80, 2200); |
3776 CheckExpectedRangesByTimestamp("{ [130,160) [1000,1150) }"); | 3742 CheckExpectedRangesByTimestamp("{ [130,160) [1000,1150) }"); |
3777 } | 3743 } |
3778 | 3744 |
3779 // Removal range starts in the middle of a range and ends at the exact | 3745 // Removal range starts in the middle of a range and ends at the exact |
3780 // end of the range. | 3746 // end of the range. |
3781 TEST_F(SourceBufferStreamTest, Remove_Partial2) { | 3747 TEST_F(SourceBufferStreamTest, Remove_Partial2) { |
3782 Seek(0); | 3748 Seek(0); |
3783 NewSegmentAppend("10K 40 70K 100 130K"); | 3749 NewCodedFrameGroupAppend("10K 40 70K 100 130K"); |
3784 NewSegmentAppend("1000K 1030 1060K 1090 1120K"); | 3750 NewCodedFrameGroupAppend("1000K 1030 1060K 1090 1120K"); |
3785 CheckExpectedRangesByTimestamp("{ [10,160) [1000,1150) }"); | 3751 CheckExpectedRangesByTimestamp("{ [10,160) [1000,1150) }"); |
3786 RemoveInMs(40, 160, 2200); | 3752 RemoveInMs(40, 160, 2200); |
3787 CheckExpectedRangesByTimestamp("{ [10,40) [1000,1150) }"); | 3753 CheckExpectedRangesByTimestamp("{ [10,40) [1000,1150) }"); |
3788 } | 3754 } |
3789 | 3755 |
3790 // Removal range starts and ends within a range. | 3756 // Removal range starts and ends within a range. |
3791 TEST_F(SourceBufferStreamTest, Remove_Partial3) { | 3757 TEST_F(SourceBufferStreamTest, Remove_Partial3) { |
3792 Seek(0); | 3758 Seek(0); |
3793 NewSegmentAppend("10K 40 70K 100 130K"); | 3759 NewCodedFrameGroupAppend("10K 40 70K 100 130K"); |
3794 NewSegmentAppend("1000K 1030 1060K 1090 1120K"); | 3760 NewCodedFrameGroupAppend("1000K 1030 1060K 1090 1120K"); |
3795 CheckExpectedRangesByTimestamp("{ [10,160) [1000,1150) }"); | 3761 CheckExpectedRangesByTimestamp("{ [10,160) [1000,1150) }"); |
3796 RemoveInMs(40, 120, 2200); | 3762 RemoveInMs(40, 120, 2200); |
3797 CheckExpectedRangesByTimestamp("{ [10,40) [130,160) [1000,1150) }"); | 3763 CheckExpectedRangesByTimestamp("{ [10,40) [130,160) [1000,1150) }"); |
3798 } | 3764 } |
3799 | 3765 |
3800 // Removal range starts in the middle of one range and ends in the | 3766 // Removal range starts in the middle of one range and ends in the |
3801 // middle of another range. | 3767 // middle of another range. |
3802 TEST_F(SourceBufferStreamTest, Remove_Partial4) { | 3768 TEST_F(SourceBufferStreamTest, Remove_Partial4) { |
3803 Seek(0); | 3769 Seek(0); |
3804 NewSegmentAppend("10K 40 70K 100 130K"); | 3770 NewCodedFrameGroupAppend("10K 40 70K 100 130K"); |
3805 NewSegmentAppend("1000K 1030 1060K 1090 1120K"); | 3771 NewCodedFrameGroupAppend("1000K 1030 1060K 1090 1120K"); |
3806 NewSegmentAppend("2000K 2030 2060K 2090 2120K"); | 3772 NewCodedFrameGroupAppend("2000K 2030 2060K 2090 2120K"); |
3807 CheckExpectedRangesByTimestamp("{ [10,160) [1000,1150) [2000,2150) }"); | 3773 CheckExpectedRangesByTimestamp("{ [10,160) [1000,1150) [2000,2150) }"); |
3808 RemoveInMs(40, 2030, 2200); | 3774 RemoveInMs(40, 2030, 2200); |
3809 CheckExpectedRangesByTimestamp("{ [10,40) [2060,2150) }"); | 3775 CheckExpectedRangesByTimestamp("{ [10,40) [2060,2150) }"); |
3810 } | 3776 } |
3811 | 3777 |
3812 // Test behavior when the current position is removed and new buffers | 3778 // Test behavior when the current position is removed and new buffers |
3813 // are appended over the removal range. | 3779 // are appended over the removal range. |
3814 TEST_F(SourceBufferStreamTest, Remove_CurrentPosition) { | 3780 TEST_F(SourceBufferStreamTest, Remove_CurrentPosition) { |
3815 Seek(0); | 3781 Seek(0); |
3816 NewSegmentAppend("0K 30 60 90K 120 150 180K 210 240 270K 300 330"); | 3782 NewCodedFrameGroupAppend("0K 30 60 90K 120 150 180K 210 240 270K 300 330"); |
3817 CheckExpectedRangesByTimestamp("{ [0,360) }"); | 3783 CheckExpectedRangesByTimestamp("{ [0,360) }"); |
3818 CheckExpectedBuffers("0K 30 60 90K 120"); | 3784 CheckExpectedBuffers("0K 30 60 90K 120"); |
3819 | 3785 |
3820 // Remove a range that includes the next buffer (i.e., 150). | 3786 // Remove a range that includes the next buffer (i.e., 150). |
3821 RemoveInMs(150, 210, 360); | 3787 RemoveInMs(150, 210, 360); |
3822 CheckExpectedRangesByTimestamp("{ [0,150) [270,360) }"); | 3788 CheckExpectedRangesByTimestamp("{ [0,150) [270,360) }"); |
3823 | 3789 |
3824 // Verify that no next buffer is returned. | 3790 // Verify that no next buffer is returned. |
3825 CheckNoNextBuffer(); | 3791 CheckNoNextBuffer(); |
3826 | 3792 |
3827 // Append some buffers to fill the gap that was created. | 3793 // Append some buffers to fill the gap that was created. |
3828 NewSegmentAppend("120K 150 180 210K 240"); | 3794 NewCodedFrameGroupAppend("120K 150 180 210K 240"); |
3829 CheckExpectedRangesByTimestamp("{ [0,360) }"); | 3795 CheckExpectedRangesByTimestamp("{ [0,360) }"); |
3830 | 3796 |
3831 // Verify that buffers resume at the next keyframe after the | 3797 // Verify that buffers resume at the next keyframe after the |
3832 // current position. | 3798 // current position. |
3833 CheckExpectedBuffers("210K 240 270K 300 330"); | 3799 CheckExpectedBuffers("210K 240 270K 300 330"); |
3834 } | 3800 } |
3835 | 3801 |
3836 // Test behavior when buffers in the selected range before the current position | 3802 // Test behavior when buffers in the selected range before the current position |
3837 // are removed. | 3803 // are removed. |
3838 TEST_F(SourceBufferStreamTest, Remove_BeforeCurrentPosition) { | 3804 TEST_F(SourceBufferStreamTest, Remove_BeforeCurrentPosition) { |
3839 Seek(0); | 3805 Seek(0); |
3840 NewSegmentAppend("0K 30 60 90K 120 150 180K 210 240 270K 300 330"); | 3806 NewCodedFrameGroupAppend("0K 30 60 90K 120 150 180K 210 240 270K 300 330"); |
3841 CheckExpectedRangesByTimestamp("{ [0,360) }"); | 3807 CheckExpectedRangesByTimestamp("{ [0,360) }"); |
3842 CheckExpectedBuffers("0K 30 60 90K 120"); | 3808 CheckExpectedBuffers("0K 30 60 90K 120"); |
3843 | 3809 |
3844 // Remove a range that is before the current playback position. | 3810 // Remove a range that is before the current playback position. |
3845 RemoveInMs(0, 90, 360); | 3811 RemoveInMs(0, 90, 360); |
3846 CheckExpectedRangesByTimestamp("{ [90,360) }"); | 3812 CheckExpectedRangesByTimestamp("{ [90,360) }"); |
3847 | 3813 |
3848 CheckExpectedBuffers("150 180K 210 240 270K 300 330"); | 3814 CheckExpectedBuffers("150 180K 210 240 270K 300 330"); |
3849 } | 3815 } |
3850 | 3816 |
3851 // Test removing the entire range for the current media segment | 3817 // Test removing the entire range for the current coded frame group |
3852 // being appended. | 3818 // being appended. |
3853 TEST_F(SourceBufferStreamTest, Remove_MidSegment) { | 3819 TEST_F(SourceBufferStreamTest, Remove_MidGroup) { |
3854 Seek(0); | 3820 Seek(0); |
3855 NewSegmentAppend("0K 30 60 90 120K 150 180 210"); | 3821 NewCodedFrameGroupAppend("0K 30 60 90 120K 150 180 210"); |
3856 CheckExpectedRangesByTimestamp("{ [0,240) }"); | 3822 CheckExpectedRangesByTimestamp("{ [0,240) }"); |
3857 | 3823 |
3858 NewSegmentAppend("0K 30"); | 3824 NewCodedFrameGroupAppend("0K 30"); |
3859 | 3825 |
3860 CheckExpectedBuffers("0K"); | 3826 CheckExpectedBuffers("0K"); |
3861 | 3827 |
3862 CheckExpectedRangesByTimestamp("{ [0,60) [120,240) }"); | 3828 CheckExpectedRangesByTimestamp("{ [0,60) [120,240) }"); |
3863 | 3829 |
3864 // Remove the entire range that is being appended to. | 3830 // Remove the entire range that is being appended to. |
3865 RemoveInMs(0, 60, 240); | 3831 RemoveInMs(0, 60, 240); |
3866 | 3832 |
3867 // Verify that there is no next buffer since it was removed. | 3833 // Verify that there is no next buffer since it was removed. |
3868 CheckNoNextBuffer(); | 3834 CheckNoNextBuffer(); |
3869 | 3835 |
3870 CheckExpectedRangesByTimestamp("{ [120,240) }"); | 3836 CheckExpectedRangesByTimestamp("{ [120,240) }"); |
3871 | 3837 |
3872 // Continue appending frames for the current GOP. | 3838 // Continue appending frames for the current GOP. |
3873 AppendBuffers("60 90"); | 3839 AppendBuffers("60 90"); |
3874 | 3840 |
3875 // Verify that the non-keyframes are not added. | 3841 // Verify that the non-keyframes are not added. |
3876 CheckExpectedRangesByTimestamp("{ [120,240) }"); | 3842 CheckExpectedRangesByTimestamp("{ [120,240) }"); |
3877 | 3843 |
3878 // Finish the previous GOP and start the next one. | 3844 // Finish the previous GOP and start the next one. |
3879 AppendBuffers("120 150K 180"); | 3845 AppendBuffers("120 150K 180"); |
3880 | 3846 |
3881 // Verify that new GOP replaces the existing range. | 3847 // Verify that new GOP replaces the existing range. |
3882 CheckExpectedRangesByTimestamp("{ [150,210) }"); | 3848 CheckExpectedRangesByTimestamp("{ [150,210) }"); |
3883 | 3849 |
3884 | |
3885 SeekToTimestampMs(150); | 3850 SeekToTimestampMs(150); |
3886 CheckExpectedBuffers("150K 180"); | 3851 CheckExpectedBuffers("150K 180"); |
3887 CheckNoNextBuffer(); | 3852 CheckNoNextBuffer(); |
3888 } | 3853 } |
3889 | 3854 |
3890 // Test removing the current GOP being appended, while not removing | 3855 // Test removing the current GOP being appended, while not removing |
3891 // the entire range the GOP belongs to. | 3856 // the entire range the GOP belongs to. |
3892 TEST_F(SourceBufferStreamTest, Remove_GOPBeingAppended) { | 3857 TEST_F(SourceBufferStreamTest, Remove_GOPBeingAppended) { |
3893 Seek(0); | 3858 Seek(0); |
3894 NewSegmentAppend("0K 30 60 90 120K 150 180"); | 3859 NewCodedFrameGroupAppend("0K 30 60 90 120K 150 180"); |
3895 CheckExpectedRangesByTimestamp("{ [0,210) }"); | 3860 CheckExpectedRangesByTimestamp("{ [0,210) }"); |
3896 | 3861 |
3897 // Remove the current GOP being appended. | 3862 // Remove the current GOP being appended. |
3898 RemoveInMs(120, 150, 240); | 3863 RemoveInMs(120, 150, 240); |
3899 CheckExpectedRangesByTimestamp("{ [0,120) }"); | 3864 CheckExpectedRangesByTimestamp("{ [0,120) }"); |
3900 | 3865 |
3901 // Continue appending the current GOP and the next one. | 3866 // Continue appending the current GOP and the next one. |
3902 AppendBuffers("210 240K 270 300"); | 3867 AppendBuffers("210 240K 270 300"); |
3903 | 3868 |
3904 // Verify that the non-keyframe in the previous GOP does | 3869 // Verify that the non-keyframe in the previous GOP does |
3905 // not effect any existing ranges and a new range is started at the | 3870 // not effect any existing ranges and a new range is started at the |
3906 // beginning of the next GOP. | 3871 // beginning of the next GOP. |
3907 CheckExpectedRangesByTimestamp("{ [0,120) [240,330) }"); | 3872 CheckExpectedRangesByTimestamp("{ [0,120) [240,330) }"); |
3908 | 3873 |
3909 // Verify the buffers in the ranges. | 3874 // Verify the buffers in the ranges. |
3910 CheckExpectedBuffers("0K 30 60 90"); | 3875 CheckExpectedBuffers("0K 30 60 90"); |
3911 CheckNoNextBuffer(); | 3876 CheckNoNextBuffer(); |
3912 SeekToTimestampMs(240); | 3877 SeekToTimestampMs(240); |
3913 CheckExpectedBuffers("240K 270 300"); | 3878 CheckExpectedBuffers("240K 270 300"); |
3914 } | 3879 } |
3915 | 3880 |
3916 TEST_F(SourceBufferStreamTest, Remove_WholeGOPBeingAppended) { | 3881 TEST_F(SourceBufferStreamTest, Remove_WholeGOPBeingAppended) { |
3917 SeekToTimestampMs(1000); | 3882 SeekToTimestampMs(1000); |
3918 NewSegmentAppend("1000K 1030 1060 1090"); | 3883 NewCodedFrameGroupAppend("1000K 1030 1060 1090"); |
3919 CheckExpectedRangesByTimestamp("{ [1000,1120) }"); | 3884 CheckExpectedRangesByTimestamp("{ [1000,1120) }"); |
3920 | 3885 |
3921 // Remove the keyframe of the current GOP being appended. | 3886 // Remove the keyframe of the current GOP being appended. |
3922 RemoveInMs(1000, 1030, 1120); | 3887 RemoveInMs(1000, 1030, 1120); |
3923 CheckExpectedRangesByTimestamp("{ }"); | 3888 CheckExpectedRangesByTimestamp("{ }"); |
3924 | 3889 |
3925 // Continue appending the current GOP. | 3890 // Continue appending the current GOP. |
3926 AppendBuffers("1210 1240"); | 3891 AppendBuffers("1210 1240"); |
3927 | 3892 |
3928 CheckExpectedRangesByTimestamp("{ }"); | 3893 CheckExpectedRangesByTimestamp("{ }"); |
3929 | 3894 |
3930 // Append the beginning of the next GOP. | 3895 // Append the beginning of the next GOP. |
3931 AppendBuffers("1270K 1300"); | 3896 AppendBuffers("1270K 1300"); |
3932 | 3897 |
3933 // Verify that the new range is started at the | 3898 // Verify that the new range is started at the |
3934 // beginning of the next GOP. | 3899 // beginning of the next GOP. |
3935 CheckExpectedRangesByTimestamp("{ [1270,1330) }"); | 3900 CheckExpectedRangesByTimestamp("{ [1270,1330) }"); |
3936 | 3901 |
3937 // Verify the buffers in the ranges. | 3902 // Verify the buffers in the ranges. |
3938 CheckNoNextBuffer(); | 3903 CheckNoNextBuffer(); |
3939 SeekToTimestampMs(1270); | 3904 SeekToTimestampMs(1270); |
3940 CheckExpectedBuffers("1270K 1300"); | 3905 CheckExpectedBuffers("1270K 1300"); |
3941 } | 3906 } |
3942 | 3907 |
3943 TEST_F(SourceBufferStreamTest, | 3908 TEST_F(SourceBufferStreamTest, |
3944 Remove_PreviousAppendDestroyedAndOverwriteExistingRange) { | 3909 Remove_PreviousAppendDestroyedAndOverwriteExistingRange) { |
3945 SeekToTimestampMs(90); | 3910 SeekToTimestampMs(90); |
3946 | 3911 |
3947 NewSegmentAppend("90K 120 150"); | 3912 NewCodedFrameGroupAppend("90K 120 150"); |
3948 CheckExpectedRangesByTimestamp("{ [90,180) }"); | 3913 CheckExpectedRangesByTimestamp("{ [90,180) }"); |
3949 | 3914 |
3950 // Append a segment before the previously appended data. | 3915 // Append a coded frame group before the previously appended data. |
3951 NewSegmentAppend("0K 30 60"); | 3916 NewCodedFrameGroupAppend("0K 30 60"); |
3952 | 3917 |
3953 // Verify that the ranges get merged. | 3918 // Verify that the ranges get merged. |
3954 CheckExpectedRangesByTimestamp("{ [0,180) }"); | 3919 CheckExpectedRangesByTimestamp("{ [0,180) }"); |
3955 | 3920 |
3956 // Remove the data from the last append. | 3921 // Remove the data from the last append. |
3957 RemoveInMs(0, 90, 360); | 3922 RemoveInMs(0, 90, 360); |
3958 CheckExpectedRangesByTimestamp("{ [90,180) }"); | 3923 CheckExpectedRangesByTimestamp("{ [90,180) }"); |
3959 | 3924 |
3960 // Append a new segment that follows the removed segment and | 3925 // Append a new coded frame group that follows the removed group and |
3961 // starts at the beginning of the range left over from the | 3926 // starts at the beginning of the range left over from the |
3962 // remove. | 3927 // remove. |
3963 NewSegmentAppend("90K 121 151"); | 3928 NewCodedFrameGroupAppend("90K 121 151"); |
3964 CheckExpectedBuffers("90K 121 151"); | 3929 CheckExpectedBuffers("90K 121 151"); |
3965 } | 3930 } |
3966 | 3931 |
3967 TEST_F(SourceBufferStreamTest, Remove_GapAtBeginningOfMediaSegment) { | 3932 TEST_F(SourceBufferStreamTest, Remove_GapAtBeginningOfGroup) { |
3968 Seek(0); | 3933 Seek(0); |
3969 | 3934 |
3970 // Append a media segment that has a gap at the beginning of it. | 3935 // Append a coded frame group that has a gap at the beginning of it. |
3971 NewSegmentAppend(base::TimeDelta::FromMilliseconds(0), | 3936 NewCodedFrameGroupAppend(base::TimeDelta::FromMilliseconds(0), |
3972 "30K 60 90 120K 150"); | 3937 "30K 60 90 120K 150"); |
3973 CheckExpectedRangesByTimestamp("{ [0,180) }"); | 3938 CheckExpectedRangesByTimestamp("{ [0,180) }"); |
3974 | 3939 |
3975 // Remove the gap that doesn't contain any buffers. | 3940 // Remove the gap that doesn't contain any buffers. |
3976 RemoveInMs(0, 10, 180); | 3941 RemoveInMs(0, 10, 180); |
3977 CheckExpectedRangesByTimestamp("{ [10,180) }"); | 3942 CheckExpectedRangesByTimestamp("{ [10,180) }"); |
3978 | 3943 |
3979 // Verify we still get the first buffer still since only part of | 3944 // Verify we still get the first buffer still since only part of |
3980 // the gap was removed. | 3945 // the gap was removed. |
3981 // TODO(acolwell/wolenetz): Consider not returning a buffer at this | 3946 // TODO(acolwell/wolenetz): Consider not returning a buffer at this |
3982 // point since the current seek position has been explicitly | 3947 // point since the current seek position has been explicitly |
3983 // removed but didn't happen to remove any buffers. | 3948 // removed but didn't happen to remove any buffers. |
3984 // http://crbug.com/384016 | 3949 // http://crbug.com/384016 |
3985 CheckExpectedBuffers("30K"); | 3950 CheckExpectedBuffers("30K"); |
3986 | 3951 |
3987 // Remove a range that includes the first GOP. | 3952 // Remove a range that includes the first GOP. |
3988 RemoveInMs(0, 60, 180); | 3953 RemoveInMs(0, 60, 180); |
3989 | 3954 |
3990 // Verify that no buffer is returned because the current buffer | 3955 // Verify that no buffer is returned because the current buffer |
3991 // position has been removed. | 3956 // position has been removed. |
3992 CheckNoNextBuffer(); | 3957 CheckNoNextBuffer(); |
3993 | 3958 |
3994 CheckExpectedRangesByTimestamp("{ [120,180) }"); | 3959 CheckExpectedRangesByTimestamp("{ [120,180) }"); |
3995 } | 3960 } |
3996 | 3961 |
3997 TEST_F(SourceBufferStreamTest, Text_Append_SingleRange) { | 3962 TEST_F(SourceBufferStreamTest, Text_Append_SingleRange) { |
3998 SetTextStream(); | 3963 SetTextStream(); |
3999 NewSegmentAppend("0K 500K 1000K"); | 3964 NewCodedFrameGroupAppend("0K 500K 1000K"); |
4000 CheckExpectedRangesByTimestamp("{ [0,1500) }"); | 3965 CheckExpectedRangesByTimestamp("{ [0,1500) }"); |
4001 | 3966 |
4002 Seek(0); | 3967 Seek(0); |
4003 CheckExpectedBuffers("0K 500K 1000K"); | 3968 CheckExpectedBuffers("0K 500K 1000K"); |
4004 } | 3969 } |
4005 | 3970 |
4006 TEST_F(SourceBufferStreamTest, Text_Append_DisjointAfter) { | 3971 TEST_F(SourceBufferStreamTest, Text_Append_DisjointAfter) { |
4007 SetTextStream(); | 3972 SetTextStream(); |
4008 NewSegmentAppend("0K 500K 1000K"); | 3973 NewCodedFrameGroupAppend("0K 500K 1000K"); |
4009 CheckExpectedRangesByTimestamp("{ [0,1500) }"); | 3974 CheckExpectedRangesByTimestamp("{ [0,1500) }"); |
4010 NewSegmentAppend("3000K 3500K 4000K"); | 3975 NewCodedFrameGroupAppend("3000K 3500K 4000K"); |
4011 CheckExpectedRangesByTimestamp("{ [0,4500) }"); | 3976 CheckExpectedRangesByTimestamp("{ [0,4500) }"); |
4012 | 3977 |
4013 Seek(0); | 3978 Seek(0); |
4014 CheckExpectedBuffers("0K 500K 1000K 3000K 3500K 4000K"); | 3979 CheckExpectedBuffers("0K 500K 1000K 3000K 3500K 4000K"); |
4015 } | 3980 } |
4016 | 3981 |
4017 TEST_F(SourceBufferStreamTest, Text_Append_DisjointBefore) { | 3982 TEST_F(SourceBufferStreamTest, Text_Append_DisjointBefore) { |
4018 SetTextStream(); | 3983 SetTextStream(); |
4019 NewSegmentAppend("3000K 3500K 4000K"); | 3984 NewCodedFrameGroupAppend("3000K 3500K 4000K"); |
4020 CheckExpectedRangesByTimestamp("{ [3000,4500) }"); | 3985 CheckExpectedRangesByTimestamp("{ [3000,4500) }"); |
4021 NewSegmentAppend("0K 500K 1000K"); | 3986 NewCodedFrameGroupAppend("0K 500K 1000K"); |
4022 CheckExpectedRangesByTimestamp("{ [0,4500) }"); | 3987 CheckExpectedRangesByTimestamp("{ [0,4500) }"); |
4023 | 3988 |
4024 Seek(0); | 3989 Seek(0); |
4025 CheckExpectedBuffers("0K 500K 1000K 3000K 3500K 4000K"); | 3990 CheckExpectedBuffers("0K 500K 1000K 3000K 3500K 4000K"); |
4026 } | 3991 } |
4027 | 3992 |
4028 TEST_F(SourceBufferStreamTest, Text_CompleteOverlap) { | 3993 TEST_F(SourceBufferStreamTest, Text_CompleteOverlap) { |
4029 SetTextStream(); | 3994 SetTextStream(); |
4030 NewSegmentAppend("3000K 3500K 4000K"); | 3995 NewCodedFrameGroupAppend("3000K 3500K 4000K"); |
4031 CheckExpectedRangesByTimestamp("{ [3000,4500) }"); | 3996 CheckExpectedRangesByTimestamp("{ [3000,4500) }"); |
4032 NewSegmentAppend("0K 501K 1001K 1501K 2001K 2501K " | 3997 NewCodedFrameGroupAppend( |
4033 "3001K 3501K 4001K 4501K 5001K"); | 3998 "0K 501K 1001K 1501K 2001K 2501K " |
3999 "3001K 3501K 4001K 4501K 5001K"); | |
4034 CheckExpectedRangesByTimestamp("{ [0,5501) }"); | 4000 CheckExpectedRangesByTimestamp("{ [0,5501) }"); |
4035 | 4001 |
4036 Seek(0); | 4002 Seek(0); |
4037 CheckExpectedBuffers("0K 501K 1001K 1501K 2001K 2501K " | 4003 CheckExpectedBuffers("0K 501K 1001K 1501K 2001K 2501K " |
4038 "3001K 3501K 4001K 4501K 5001K"); | 4004 "3001K 3501K 4001K 4501K 5001K"); |
4039 } | 4005 } |
4040 | 4006 |
4041 TEST_F(SourceBufferStreamTest, Text_OverlapAfter) { | 4007 TEST_F(SourceBufferStreamTest, Text_OverlapAfter) { |
4042 SetTextStream(); | 4008 SetTextStream(); |
4043 NewSegmentAppend("0K 500K 1000K 1500K 2000K"); | 4009 NewCodedFrameGroupAppend("0K 500K 1000K 1500K 2000K"); |
4044 CheckExpectedRangesByTimestamp("{ [0,2500) }"); | 4010 CheckExpectedRangesByTimestamp("{ [0,2500) }"); |
4045 NewSegmentAppend("1499K 2001K 2501K 3001K"); | 4011 NewCodedFrameGroupAppend("1499K 2001K 2501K 3001K"); |
4046 CheckExpectedRangesByTimestamp("{ [0,3501) }"); | 4012 CheckExpectedRangesByTimestamp("{ [0,3501) }"); |
4047 | 4013 |
4048 Seek(0); | 4014 Seek(0); |
4049 CheckExpectedBuffers("0K 500K 1000K 1499K 2001K 2501K 3001K"); | 4015 CheckExpectedBuffers("0K 500K 1000K 1499K 2001K 2501K 3001K"); |
4050 } | 4016 } |
4051 | 4017 |
4052 TEST_F(SourceBufferStreamTest, Text_OverlapBefore) { | 4018 TEST_F(SourceBufferStreamTest, Text_OverlapBefore) { |
4053 SetTextStream(); | 4019 SetTextStream(); |
4054 NewSegmentAppend("1500K 2000K 2500K 3000K 3500K"); | 4020 NewCodedFrameGroupAppend("1500K 2000K 2500K 3000K 3500K"); |
4055 CheckExpectedRangesByTimestamp("{ [1500,4000) }"); | 4021 CheckExpectedRangesByTimestamp("{ [1500,4000) }"); |
4056 NewSegmentAppend("0K 501K 1001K 1501K 2001K"); | 4022 NewCodedFrameGroupAppend("0K 501K 1001K 1501K 2001K"); |
4057 CheckExpectedRangesByTimestamp("{ [0,4000) }"); | 4023 CheckExpectedRangesByTimestamp("{ [0,4000) }"); |
4058 | 4024 |
4059 Seek(0); | 4025 Seek(0); |
4060 CheckExpectedBuffers("0K 501K 1001K 1501K 2001K 3000K 3500K"); | 4026 CheckExpectedBuffers("0K 501K 1001K 1501K 2001K 3000K 3500K"); |
4061 } | 4027 } |
4062 | 4028 |
4063 TEST_F(SourceBufferStreamTest, SpliceFrame_Basic) { | 4029 TEST_F(SourceBufferStreamTest, SpliceFrame_Basic) { |
4064 Seek(0); | 4030 Seek(0); |
4065 NewSegmentAppend("0K S(3K 6 9D3 10D5) 15 20 S(25K 30D5 35D5) 40"); | 4031 NewCodedFrameGroupAppend("0K S(3K 6 9D3 10D5) 15 20 S(25K 30D5 35D5) 40"); |
4066 CheckExpectedBuffers("0K 3K 6 9 C 10 15 20 25K 30 C 35 40"); | 4032 CheckExpectedBuffers("0K 3K 6 9 C 10 15 20 25K 30 C 35 40"); |
4067 CheckNoNextBuffer(); | 4033 CheckNoNextBuffer(); |
4068 } | 4034 } |
4069 | 4035 |
4070 TEST_F(SourceBufferStreamTest, SpliceFrame_SeekClearsSplice) { | 4036 TEST_F(SourceBufferStreamTest, SpliceFrame_SeekClearsSplice) { |
4071 Seek(0); | 4037 Seek(0); |
4072 NewSegmentAppend("0K S(3K 6 9D3 10D5) 15K 20"); | 4038 NewCodedFrameGroupAppend("0K S(3K 6 9D3 10D5) 15K 20"); |
4073 CheckExpectedBuffers("0K 3K 6"); | 4039 CheckExpectedBuffers("0K 3K 6"); |
4074 | 4040 |
4075 SeekToTimestampMs(15); | 4041 SeekToTimestampMs(15); |
4076 CheckExpectedBuffers("15K 20"); | 4042 CheckExpectedBuffers("15K 20"); |
4077 CheckNoNextBuffer(); | 4043 CheckNoNextBuffer(); |
4078 } | 4044 } |
4079 | 4045 |
4080 TEST_F(SourceBufferStreamTest, SpliceFrame_SeekClearsSpliceFromTrackBuffer) { | 4046 TEST_F(SourceBufferStreamTest, SpliceFrame_SeekClearsSpliceFromTrackBuffer) { |
4081 Seek(0); | 4047 Seek(0); |
4082 NewSegmentAppend("0K 2K S(3K 6 9D3 10D5) 15K 20"); | 4048 NewCodedFrameGroupAppend("0K 2K S(3K 6 9D3 10D5) 15K 20"); |
4083 CheckExpectedBuffers("0K 2K"); | 4049 CheckExpectedBuffers("0K 2K"); |
4084 | 4050 |
4085 // Overlap the existing segment. | 4051 // Overlap the existing coded frame group. |
4086 NewSegmentAppend("5K 15K 20"); | 4052 NewCodedFrameGroupAppend("5K 15K 20"); |
4087 CheckExpectedBuffers("3K 6"); | 4053 CheckExpectedBuffers("3K 6"); |
4088 | 4054 |
4089 SeekToTimestampMs(15); | 4055 SeekToTimestampMs(15); |
4090 CheckExpectedBuffers("15K 20"); | 4056 CheckExpectedBuffers("15K 20"); |
4091 CheckNoNextBuffer(); | 4057 CheckNoNextBuffer(); |
4092 } | 4058 } |
4093 | 4059 |
4094 TEST_F(SourceBufferStreamTest, SpliceFrame_ConfigChangeWithinSplice) { | 4060 TEST_F(SourceBufferStreamTest, SpliceFrame_ConfigChangeWithinSplice) { |
4095 VideoDecoderConfig new_config = TestVideoConfig::Large(); | 4061 VideoDecoderConfig new_config = TestVideoConfig::Large(); |
4096 ASSERT_FALSE(new_config.Matches(video_config_)); | 4062 ASSERT_FALSE(new_config.Matches(video_config_)); |
4097 | 4063 |
4098 // Add a new video config, then reset the config index back to the original. | 4064 // Add a new video config, then reset the config index back to the original. |
4099 stream_->UpdateVideoConfig(new_config); | 4065 stream_->UpdateVideoConfig(new_config); |
4100 stream_->UpdateVideoConfig(video_config_); | 4066 stream_->UpdateVideoConfig(video_config_); |
4101 | 4067 |
4102 Seek(0); | 4068 Seek(0); |
4103 CheckVideoConfig(video_config_); | 4069 CheckVideoConfig(video_config_); |
4104 NewSegmentAppend("0K S(3K 6C 9D3 10D5) 15"); | 4070 NewCodedFrameGroupAppend("0K S(3K 6C 9D3 10D5) 15"); |
4105 | 4071 |
4106 CheckExpectedBuffers("0K 3K C"); | 4072 CheckExpectedBuffers("0K 3K C"); |
4107 CheckVideoConfig(new_config); | 4073 CheckVideoConfig(new_config); |
4108 CheckExpectedBuffers("6 9 C"); | 4074 CheckExpectedBuffers("6 9 C"); |
4109 CheckExpectedBuffers("10 C"); | 4075 CheckExpectedBuffers("10 C"); |
4110 CheckVideoConfig(video_config_); | 4076 CheckVideoConfig(video_config_); |
4111 CheckExpectedBuffers("15"); | 4077 CheckExpectedBuffers("15"); |
4112 CheckNoNextBuffer(); | 4078 CheckNoNextBuffer(); |
4113 } | 4079 } |
4114 | 4080 |
4115 TEST_F(SourceBufferStreamTest, SpliceFrame_BasicFromTrackBuffer) { | 4081 TEST_F(SourceBufferStreamTest, SpliceFrame_BasicFromTrackBuffer) { |
4116 Seek(0); | 4082 Seek(0); |
4117 NewSegmentAppend("0K 5K S(8K 9D1 10D10) 20"); | 4083 NewCodedFrameGroupAppend("0K 5K S(8K 9D1 10D10) 20"); |
4118 CheckExpectedBuffers("0K 5K"); | 4084 CheckExpectedBuffers("0K 5K"); |
4119 | 4085 |
4120 // Overlap the existing segment. | 4086 // Overlap the existing coded frame group. |
4121 NewSegmentAppend("5K 20"); | 4087 NewCodedFrameGroupAppend("5K 20"); |
4122 CheckExpectedBuffers("8K 9 C 10 20"); | 4088 CheckExpectedBuffers("8K 9 C 10 20"); |
4123 CheckNoNextBuffer(); | 4089 CheckNoNextBuffer(); |
4124 } | 4090 } |
4125 | 4091 |
4126 TEST_F(SourceBufferStreamTest, | 4092 TEST_F(SourceBufferStreamTest, |
4127 SpliceFrame_ConfigChangeWithinSpliceFromTrackBuffer) { | 4093 SpliceFrame_ConfigChangeWithinSpliceFromTrackBuffer) { |
4128 VideoDecoderConfig new_config = TestVideoConfig::Large(); | 4094 VideoDecoderConfig new_config = TestVideoConfig::Large(); |
4129 ASSERT_FALSE(new_config.Matches(video_config_)); | 4095 ASSERT_FALSE(new_config.Matches(video_config_)); |
4130 | 4096 |
4131 // Add a new video config, then reset the config index back to the original. | 4097 // Add a new video config, then reset the config index back to the original. |
4132 stream_->UpdateVideoConfig(new_config); | 4098 stream_->UpdateVideoConfig(new_config); |
4133 stream_->UpdateVideoConfig(video_config_); | 4099 stream_->UpdateVideoConfig(video_config_); |
4134 | 4100 |
4135 Seek(0); | 4101 Seek(0); |
4136 CheckVideoConfig(video_config_); | 4102 CheckVideoConfig(video_config_); |
4137 NewSegmentAppend("0K 5K S(7K 8C 9D1 10D10) 20"); | 4103 NewCodedFrameGroupAppend("0K 5K S(7K 8C 9D1 10D10) 20"); |
4138 CheckExpectedBuffers("0K 5K"); | 4104 CheckExpectedBuffers("0K 5K"); |
4139 | 4105 |
4140 // Overlap the existing segment. | 4106 // Overlap the existing coded frame group. |
4141 NewSegmentAppend("5K 20"); | 4107 NewCodedFrameGroupAppend("5K 20"); |
4142 CheckExpectedBuffers("7K C"); | 4108 CheckExpectedBuffers("7K C"); |
4143 CheckVideoConfig(new_config); | 4109 CheckVideoConfig(new_config); |
4144 CheckExpectedBuffers("8 9 C"); | 4110 CheckExpectedBuffers("8 9 C"); |
4145 CheckExpectedBuffers("10 C"); | 4111 CheckExpectedBuffers("10 C"); |
4146 CheckVideoConfig(video_config_); | 4112 CheckVideoConfig(video_config_); |
4147 CheckExpectedBuffers("20"); | 4113 CheckExpectedBuffers("20"); |
4148 CheckNoNextBuffer(); | 4114 CheckNoNextBuffer(); |
4149 } | 4115 } |
4150 | 4116 |
4151 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_Basic) { | 4117 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_Basic) { |
4152 EXPECT_MEDIA_LOG(ContainsGeneratedSpliceLog(3000, 11000)); | 4118 EXPECT_MEDIA_LOG(ContainsGeneratedSpliceLog(3000, 11000)); |
4153 | 4119 |
4154 SetAudioStream(); | 4120 SetAudioStream(); |
4155 Seek(0); | 4121 Seek(0); |
4156 NewSegmentAppend("0K 2K 4K 6K 8K 10K 12K"); | 4122 NewCodedFrameGroupAppend("0K 2K 4K 6K 8K 10K 12K"); |
4157 NewSegmentAppend("11K 13K 15K 17K"); | 4123 NewCodedFrameGroupAppend("11K 13K 15K 17K"); |
4158 CheckExpectedBuffers("0K 2K 4K 6K 8K 10K 12K C 11K 13K 15K 17K"); | 4124 CheckExpectedBuffers("0K 2K 4K 6K 8K 10K 12K C 11K 13K 15K 17K"); |
4159 CheckNoNextBuffer(); | 4125 CheckNoNextBuffer(); |
4160 } | 4126 } |
4161 | 4127 |
4162 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoExactSplices) { | 4128 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoExactSplices) { |
4163 EXPECT_MEDIA_LOG( | 4129 EXPECT_MEDIA_LOG( |
4164 HasSubstr("Skipping splice frame generation: first new buffer at 10000us " | 4130 HasSubstr("Skipping splice frame generation: first new buffer at 10000us " |
4165 "begins at or before existing buffer at 10000us.")); | 4131 "begins at or before existing buffer at 10000us.")); |
4166 | 4132 |
4167 SetAudioStream(); | 4133 SetAudioStream(); |
4168 Seek(0); | 4134 Seek(0); |
4169 NewSegmentAppend("0K 2K 4K 6K 8K 10K 12K"); | 4135 NewCodedFrameGroupAppend("0K 2K 4K 6K 8K 10K 12K"); |
4170 NewSegmentAppend("10K 14K"); | 4136 NewCodedFrameGroupAppend("10K 14K"); |
4171 CheckExpectedBuffers("0K 2K 4K 6K 8K 10K 14K"); | 4137 CheckExpectedBuffers("0K 2K 4K 6K 8K 10K 14K"); |
4172 CheckNoNextBuffer(); | 4138 CheckNoNextBuffer(); |
4173 } | 4139 } |
4174 | 4140 |
4175 // Do not allow splices on top of splices. | 4141 // Do not allow splices on top of splices. |
4176 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoDoubleSplice) { | 4142 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoDoubleSplice) { |
4177 InSequence s; | 4143 InSequence s; |
4178 EXPECT_MEDIA_LOG(ContainsGeneratedSpliceLog(3000, 11000)); | 4144 EXPECT_MEDIA_LOG(ContainsGeneratedSpliceLog(3000, 11000)); |
4179 EXPECT_MEDIA_LOG( | 4145 EXPECT_MEDIA_LOG( |
4180 HasSubstr("Skipping splice frame generation: overlapped buffers at " | 4146 HasSubstr("Skipping splice frame generation: overlapped buffers at " |
4181 "10000us are in a previously buffered splice.")); | 4147 "10000us are in a previously buffered splice.")); |
4182 | 4148 |
4183 SetAudioStream(); | 4149 SetAudioStream(); |
4184 Seek(0); | 4150 Seek(0); |
4185 NewSegmentAppend("0K 2K 4K 6K 8K 10K 12K"); | 4151 NewCodedFrameGroupAppend("0K 2K 4K 6K 8K 10K 12K"); |
4186 NewSegmentAppend("11K 13K 15K 17K"); | 4152 NewCodedFrameGroupAppend("11K 13K 15K 17K"); |
4187 | 4153 |
4188 // Verify the splice was created. | 4154 // Verify the splice was created. |
4189 CheckExpectedBuffers("0K 2K 4K 6K 8K 10K 12K C 11K 13K 15K 17K"); | 4155 CheckExpectedBuffers("0K 2K 4K 6K 8K 10K 12K C 11K 13K 15K 17K"); |
4190 CheckNoNextBuffer(); | 4156 CheckNoNextBuffer(); |
4191 Seek(0); | 4157 Seek(0); |
4192 | 4158 |
4193 // Create a splice before the first splice which would include it. | 4159 // Create a splice before the first splice which would include it. |
4194 NewSegmentAppend("9D2K"); | 4160 NewCodedFrameGroupAppend("9D2K"); |
4195 | 4161 |
4196 // A splice on top of a splice should result in a discard of the original | 4162 // A splice on top of a splice should result in a discard of the original |
4197 // splice and no new splice frame being generated. | 4163 // splice and no new splice frame being generated. |
4198 CheckExpectedBuffers("0K 2K 4K 6K 8K 9K 13K 15K 17K"); | 4164 CheckExpectedBuffers("0K 2K 4K 6K 8K 9K 13K 15K 17K"); |
4199 CheckNoNextBuffer(); | 4165 CheckNoNextBuffer(); |
4200 } | 4166 } |
4201 | 4167 |
4202 // Test that a splice is not created if an end timestamp and start timestamp | 4168 // Test that a splice is not created if an end timestamp and start timestamp |
4203 // overlap. | 4169 // overlap. |
4204 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoSplice) { | 4170 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoSplice) { |
4205 SetAudioStream(); | 4171 SetAudioStream(); |
4206 Seek(0); | 4172 Seek(0); |
4207 NewSegmentAppend("0K 2K 4K 6K 8K 10K"); | 4173 NewCodedFrameGroupAppend("0K 2K 4K 6K 8K 10K"); |
4208 NewSegmentAppend("12K 14K 16K 18K"); | 4174 NewCodedFrameGroupAppend("12K 14K 16K 18K"); |
4209 CheckExpectedBuffers("0K 2K 4K 6K 8K 10K 12K 14K 16K 18K"); | 4175 CheckExpectedBuffers("0K 2K 4K 6K 8K 10K 12K 14K 16K 18K"); |
4210 CheckNoNextBuffer(); | 4176 CheckNoNextBuffer(); |
4211 } | 4177 } |
4212 | 4178 |
4213 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_CorrectMediaSegmentStartTime) { | 4179 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_CorrectGroupStartTime) { |
4214 EXPECT_MEDIA_LOG(ContainsGeneratedSpliceLog(5000, 1000)); | 4180 EXPECT_MEDIA_LOG(ContainsGeneratedSpliceLog(5000, 1000)); |
4215 | 4181 |
4216 SetAudioStream(); | 4182 SetAudioStream(); |
4217 Seek(0); | 4183 Seek(0); |
4218 NewSegmentAppend("0K 2K 4K"); | 4184 NewCodedFrameGroupAppend("0K 2K 4K"); |
4219 CheckExpectedRangesByTimestamp("{ [0,6) }"); | 4185 CheckExpectedRangesByTimestamp("{ [0,6) }"); |
4220 NewSegmentAppend("6K 8K 10K"); | 4186 NewCodedFrameGroupAppend("6K 8K 10K"); |
4221 CheckExpectedRangesByTimestamp("{ [0,12) }"); | 4187 CheckExpectedRangesByTimestamp("{ [0,12) }"); |
4222 NewSegmentAppend("1K 4D2K"); | 4188 NewCodedFrameGroupAppend("1K 4D2K"); |
4223 CheckExpectedRangesByTimestamp("{ [0,12) }"); | 4189 CheckExpectedRangesByTimestamp("{ [0,12) }"); |
4224 CheckExpectedBuffers("0K 2K 4K C 1K 4K 6K 8K 10K"); | 4190 CheckExpectedBuffers("0K 2K 4K C 1K 4K 6K 8K 10K"); |
4225 CheckNoNextBuffer(); | 4191 CheckNoNextBuffer(); |
4226 } | 4192 } |
4227 | 4193 |
4228 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_ConfigChange) { | 4194 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_ConfigChange) { |
4229 EXPECT_MEDIA_LOG(ContainsGeneratedSpliceLog(3000, 5000)); | 4195 EXPECT_MEDIA_LOG(ContainsGeneratedSpliceLog(3000, 5000)); |
4230 | 4196 |
4231 SetAudioStream(); | 4197 SetAudioStream(); |
4232 | 4198 |
4233 AudioDecoderConfig new_config(kCodecVorbis, kSampleFormatPlanarF32, | 4199 AudioDecoderConfig new_config(kCodecVorbis, kSampleFormatPlanarF32, |
4234 CHANNEL_LAYOUT_MONO, 1000, EmptyExtraData(), | 4200 CHANNEL_LAYOUT_MONO, 1000, EmptyExtraData(), |
4235 false); | 4201 false); |
4236 ASSERT_NE(new_config.channel_layout(), audio_config_.channel_layout()); | 4202 ASSERT_NE(new_config.channel_layout(), audio_config_.channel_layout()); |
4237 | 4203 |
4238 Seek(0); | 4204 Seek(0); |
4239 CheckAudioConfig(audio_config_); | 4205 CheckAudioConfig(audio_config_); |
4240 NewSegmentAppend("0K 2K 4K 6K"); | 4206 NewCodedFrameGroupAppend("0K 2K 4K 6K"); |
4241 stream_->UpdateAudioConfig(new_config); | 4207 stream_->UpdateAudioConfig(new_config); |
4242 NewSegmentAppend("5K 8K 12K"); | 4208 NewCodedFrameGroupAppend("5K 8K 12K"); |
4243 CheckExpectedBuffers("0K 2K 4K 6K C 5K 8K 12K"); | 4209 CheckExpectedBuffers("0K 2K 4K 6K C 5K 8K 12K"); |
4244 CheckAudioConfig(new_config); | 4210 CheckAudioConfig(new_config); |
4245 CheckNoNextBuffer(); | 4211 CheckNoNextBuffer(); |
4246 } | 4212 } |
4247 | 4213 |
4248 // Ensure splices are not created if there are not enough frames to crossfade. | 4214 // Ensure splices are not created if there are not enough frames to crossfade. |
4249 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoTinySplices) { | 4215 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoTinySplices) { |
4250 EXPECT_MEDIA_LOG(HasSubstr( | 4216 EXPECT_MEDIA_LOG(HasSubstr( |
4251 "Skipping splice frame generation: not enough samples for splicing new " | 4217 "Skipping splice frame generation: not enough samples for splicing new " |
4252 "buffer at 1000us. Have 1000us, but need 2000us.")); | 4218 "buffer at 1000us. Have 1000us, but need 2000us.")); |
4253 | 4219 |
4254 SetAudioStream(); | 4220 SetAudioStream(); |
4255 Seek(0); | 4221 Seek(0); |
4256 | 4222 |
4257 // Overlap the range [0, 2) with [1, 3). Since each frame has a duration of | 4223 // Overlap the range [0, 2) with [1, 3). Since each frame has a duration of |
4258 // 2ms this results in an overlap of 1ms between the ranges. A splice frame | 4224 // 2ms this results in an overlap of 1ms between the ranges. A splice frame |
4259 // should not be generated since it requires at least 2 frames, or 2ms in this | 4225 // should not be generated since it requires at least 2 frames, or 2ms in this |
4260 // case, of data to crossfade. | 4226 // case, of data to crossfade. |
4261 NewSegmentAppend("0D2K"); | 4227 NewCodedFrameGroupAppend("0D2K"); |
4262 CheckExpectedRangesByTimestamp("{ [0,2) }"); | 4228 CheckExpectedRangesByTimestamp("{ [0,2) }"); |
4263 NewSegmentAppend("1D2K"); | 4229 NewCodedFrameGroupAppend("1D2K"); |
4264 CheckExpectedRangesByTimestamp("{ [0,3) }"); | 4230 CheckExpectedRangesByTimestamp("{ [0,3) }"); |
4265 CheckExpectedBuffers("0K 1K"); | 4231 CheckExpectedBuffers("0K 1K"); |
4266 CheckNoNextBuffer(); | 4232 CheckNoNextBuffer(); |
4267 } | 4233 } |
4268 | 4234 |
4269 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoMillisecondSplices) { | 4235 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoMillisecondSplices) { |
4270 EXPECT_MEDIA_LOG( | 4236 EXPECT_MEDIA_LOG( |
4271 HasSubstr("Skipping splice frame generation: not enough samples for " | 4237 HasSubstr("Skipping splice frame generation: not enough samples for " |
4272 "splicing new buffer at 1250us. Have 750us, but need 1000us.")); | 4238 "splicing new buffer at 1250us. Have 750us, but need 1000us.")); |
4273 | 4239 |
4274 video_config_ = TestVideoConfig::Invalid(); | 4240 video_config_ = TestVideoConfig::Invalid(); |
4275 audio_config_.Initialize(kCodecVorbis, kSampleFormatPlanarF32, | 4241 audio_config_.Initialize(kCodecVorbis, kSampleFormatPlanarF32, |
4276 CHANNEL_LAYOUT_STEREO, 4000, EmptyExtraData(), false, | 4242 CHANNEL_LAYOUT_STEREO, 4000, EmptyExtraData(), false, |
4277 base::TimeDelta(), 0); | 4243 base::TimeDelta(), 0); |
4278 stream_.reset(new SourceBufferStream(audio_config_, media_log_, true)); | 4244 stream_.reset(new SourceBufferStream(audio_config_, media_log_, true)); |
4279 // Equivalent to 0.5ms per frame. | 4245 // Equivalent to 0.5ms per frame. |
4280 SetStreamInfo(2000, 2000); | 4246 SetStreamInfo(2000, 2000); |
4281 Seek(0); | 4247 Seek(0); |
4282 | 4248 |
4283 // Append four buffers with a 0.5ms duration each. | 4249 // Append four buffers with a 0.5ms duration each. |
4284 NewSegmentAppend(0, 4); | 4250 NewCodedFrameGroupAppend(0, 4); |
4285 CheckExpectedRangesByTimestamp("{ [0,2) }"); | 4251 CheckExpectedRangesByTimestamp("{ [0,2) }"); |
4286 | 4252 |
4287 // Overlap the range [0, 2) with [1.25, 2); this results in an overlap of | 4253 // Overlap the range [0, 2) with [1.25, 2); this results in an overlap of |
4288 // 0.75ms between the ranges. | 4254 // 0.75ms between the ranges. |
4289 NewSegmentAppend_OffsetFirstBuffer(2, 2, | 4255 NewCodedFrameGroupAppend_OffsetFirstBuffer( |
4290 base::TimeDelta::FromMillisecondsD(0.25)); | 4256 2, 2, base::TimeDelta::FromMillisecondsD(0.25)); |
4291 CheckExpectedRangesByTimestamp("{ [0,2) }"); | 4257 CheckExpectedRangesByTimestamp("{ [0,2) }"); |
4292 | 4258 |
4293 // A splice frame should not be generated (indicated by the lack of a config | 4259 // A splice frame should not be generated (indicated by the lack of a config |
4294 // change in the expected buffer string) since it requires at least 1ms of | 4260 // change in the expected buffer string) since it requires at least 1ms of |
4295 // data to crossfade. | 4261 // data to crossfade. |
4296 CheckExpectedBuffers("0K 0K 1K 1K 1K"); | 4262 CheckExpectedBuffers("0K 0K 1K 1K 1K"); |
4297 CheckNoNextBuffer(); | 4263 CheckNoNextBuffer(); |
4298 } | 4264 } |
4299 | 4265 |
4300 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_Preroll) { | 4266 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_Preroll) { |
4301 EXPECT_MEDIA_LOG(ContainsGeneratedSpliceLog(3000, 11000)); | 4267 EXPECT_MEDIA_LOG(ContainsGeneratedSpliceLog(3000, 11000)); |
4302 | 4268 |
4303 SetAudioStream(); | 4269 SetAudioStream(); |
4304 Seek(0); | 4270 Seek(0); |
4305 NewSegmentAppend("0K 2K 4K 6K 8K 10K 12K"); | 4271 NewCodedFrameGroupAppend("0K 2K 4K 6K 8K 10K 12K"); |
4306 NewSegmentAppend("11P 13K 15K 17K"); | 4272 NewCodedFrameGroupAppend("11P 13K 15K 17K"); |
4307 CheckExpectedBuffers("0K 2K 4K 6K 8K 10K 12K C 11P 13K 15K 17K"); | 4273 CheckExpectedBuffers("0K 2K 4K 6K 8K 10K 12K C 11P 13K 15K 17K"); |
4308 CheckNoNextBuffer(); | 4274 CheckNoNextBuffer(); |
4309 } | 4275 } |
4310 | 4276 |
4311 TEST_F(SourceBufferStreamTest, Audio_PrerollFrame) { | 4277 TEST_F(SourceBufferStreamTest, Audio_PrerollFrame) { |
4312 Seek(0); | 4278 Seek(0); |
4313 NewSegmentAppend("0K 3P 6K"); | 4279 NewCodedFrameGroupAppend("0K 3P 6K"); |
4314 CheckExpectedBuffers("0K 3P 6K"); | 4280 CheckExpectedBuffers("0K 3P 6K"); |
4315 CheckNoNextBuffer(); | 4281 CheckNoNextBuffer(); |
4316 } | 4282 } |
4317 | 4283 |
4318 TEST_F(SourceBufferStreamTest, BFrames) { | 4284 TEST_F(SourceBufferStreamTest, BFrames) { |
4319 Seek(0); | 4285 Seek(0); |
4320 NewSegmentAppend("0K 120|30 30|60 60|90 90|120"); | 4286 NewCodedFrameGroupAppend("0K 120|30 30|60 60|90 90|120"); |
4321 CheckExpectedRangesByTimestamp("{ [0,150) }"); | 4287 CheckExpectedRangesByTimestamp("{ [0,150) }"); |
4322 | 4288 |
4323 CheckExpectedBuffers("0K 120|30 30|60 60|90 90|120"); | 4289 CheckExpectedBuffers("0K 120|30 30|60 60|90 90|120"); |
4324 CheckNoNextBuffer(); | 4290 CheckNoNextBuffer(); |
4325 } | 4291 } |
4326 | 4292 |
4327 TEST_F(SourceBufferStreamTest, RemoveShouldAlwaysExcludeEnd) { | 4293 TEST_F(SourceBufferStreamTest, RemoveShouldAlwaysExcludeEnd) { |
4328 NewSegmentAppend("10D2K 12D2 14D2"); | 4294 NewCodedFrameGroupAppend("10D2K 12D2 14D2"); |
4329 CheckExpectedRangesByTimestamp("{ [10,16) }"); | 4295 CheckExpectedRangesByTimestamp("{ [10,16) }"); |
4330 | 4296 |
4331 // Start new segment, appending KF to abut the start of previous segment. | 4297 // Start new coded frame group, appending KF to abut the start of previous |
4332 NewSegmentAppend("0D10K"); | 4298 // group. |
4299 NewCodedFrameGroupAppend("0D10K"); | |
4333 Seek(0); | 4300 Seek(0); |
4334 CheckExpectedRangesByTimestamp("{ [0,16) }"); | 4301 CheckExpectedRangesByTimestamp("{ [0,16) }"); |
4335 CheckExpectedBuffers("0K 10K 12 14"); | 4302 CheckExpectedBuffers("0K 10K 12 14"); |
4336 CheckNoNextBuffer(); | 4303 CheckNoNextBuffer(); |
4337 | 4304 |
4338 // Append another buffer with the same timestamp as the last KF. This triggers | 4305 // Append another buffer with the same timestamp as the last KF. This triggers |
4339 // special logic that allows two buffers to have the same timestamp. When | 4306 // special logic that allows two buffers to have the same timestamp. When |
4340 // preparing for this new append, there is no reason to remove the later GOP | 4307 // preparing for this new append, there is no reason to remove the later GOP |
4341 // starting at timestamp 10. This verifies the fix for http://crbug.com/469325 | 4308 // starting at timestamp 10. This verifies the fix for http://crbug.com/469325 |
4342 // where the decision *not* to remove the start of the overlapped range was | 4309 // where the decision *not* to remove the start of the overlapped range was |
4343 // erroneously triggering buffers with a timestamp matching the end | 4310 // erroneously triggering buffers with a timestamp matching the end |
4344 // of the append (and any later dependent frames) to be removed. | 4311 // of the append (and any later dependent frames) to be removed. |
4345 AppendBuffers("0D10"); | 4312 AppendBuffers("0D10"); |
4346 Seek(0); | 4313 Seek(0); |
4347 CheckExpectedRangesByTimestamp("{ [0,16) }"); | 4314 CheckExpectedRangesByTimestamp("{ [0,16) }"); |
4348 CheckExpectedBuffers("0K 0 10K 12 14"); | 4315 CheckExpectedBuffers("0K 0 10K 12 14"); |
4349 CheckNoNextBuffer(); | 4316 CheckNoNextBuffer(); |
4350 } | 4317 } |
4351 | 4318 |
4352 TEST_F(SourceBufferStreamTest, RefinedDurationEstimates_BackOverlap) { | 4319 TEST_F(SourceBufferStreamTest, RefinedDurationEstimates_BackOverlap) { |
4353 // Append a few buffers, the last one having estimated duration. | 4320 // Append a few buffers, the last one having estimated duration. |
4354 NewSegmentAppend("0K 5 10 20D10E"); | 4321 NewCodedFrameGroupAppend("0K 5 10 20D10E"); |
4355 CheckExpectedRangesByTimestamp("{ [0,30) }"); | 4322 CheckExpectedRangesByTimestamp("{ [0,30) }"); |
4356 Seek(0); | 4323 Seek(0); |
4357 CheckExpectedBuffers("0K 5 10 20D10E"); | 4324 CheckExpectedBuffers("0K 5 10 20D10E"); |
4358 CheckNoNextBuffer(); | 4325 CheckNoNextBuffer(); |
4359 | 4326 |
4360 // Append a buffer to the end that overlaps the *back* of the existing range. | 4327 // Append a buffer to the end that overlaps the *back* of the existing range. |
4361 // This should trigger the estimated duration to be recomputed as a timestamp | 4328 // This should trigger the estimated duration to be recomputed as a timestamp |
4362 // delta. | 4329 // delta. |
4363 AppendBuffers("25D10"); | 4330 AppendBuffers("25D10"); |
4364 CheckExpectedRangesByTimestamp("{ [0,35) }"); | 4331 CheckExpectedRangesByTimestamp("{ [0,35) }"); |
4365 Seek(0); | 4332 Seek(0); |
4366 // The duration of the buffer at time 20 has changed from 10ms to 5ms. | 4333 // The duration of the buffer at time 20 has changed from 10ms to 5ms. |
4367 CheckExpectedBuffers("0K 5 10 20D5E 25"); | 4334 CheckExpectedBuffers("0K 5 10 20D5E 25"); |
4368 CheckNoNextBuffer(); | 4335 CheckNoNextBuffer(); |
4369 | 4336 |
4370 // If the last buffer is removed, the adjusted duration should remain at 5ms. | 4337 // If the last buffer is removed, the adjusted duration should remain at 5ms. |
4371 RemoveInMs(25, 35, 35); | 4338 RemoveInMs(25, 35, 35); |
4372 CheckExpectedRangesByTimestamp("{ [0,25) }"); | 4339 CheckExpectedRangesByTimestamp("{ [0,25) }"); |
4373 Seek(0); | 4340 Seek(0); |
4374 CheckExpectedBuffers("0K 5 10 20D5E"); | 4341 CheckExpectedBuffers("0K 5 10 20D5E"); |
4375 CheckNoNextBuffer(); | 4342 CheckNoNextBuffer(); |
4376 } | 4343 } |
4377 | 4344 |
4378 TEST_F(SourceBufferStreamTest, RefinedDurationEstimates_FrontOverlap) { | 4345 TEST_F(SourceBufferStreamTest, RefinedDurationEstimates_FrontOverlap) { |
4379 // Append a few buffers. | 4346 // Append a few buffers. |
4380 NewSegmentAppend("10K 15 20D5"); | 4347 NewCodedFrameGroupAppend("10K 15 20D5"); |
4381 CheckExpectedRangesByTimestamp("{ [10,25) }"); | 4348 CheckExpectedRangesByTimestamp("{ [10,25) }"); |
4382 SeekToTimestampMs(10); | 4349 SeekToTimestampMs(10); |
4383 CheckExpectedBuffers("10K 15 20"); | 4350 CheckExpectedBuffers("10K 15 20"); |
4384 CheckNoNextBuffer(); | 4351 CheckNoNextBuffer(); |
4385 | 4352 |
4386 // Append new buffers, where the last has estimated duration that overlaps the | 4353 // Append new buffers, where the last has estimated duration that overlaps the |
4387 // *front* of the existing range. The overlap should trigger refinement of the | 4354 // *front* of the existing range. The overlap should trigger refinement of the |
4388 // estimated duration from 7ms to 5ms. | 4355 // estimated duration from 7ms to 5ms. |
4389 NewSegmentAppend("0K 5D7E"); | 4356 NewCodedFrameGroupAppend("0K 5D7E"); |
4390 CheckExpectedRangesByTimestamp("{ [0,25) }"); | 4357 CheckExpectedRangesByTimestamp("{ [0,25) }"); |
4391 Seek(0); | 4358 Seek(0); |
4392 CheckExpectedBuffers("0K 5D5E 10K 15 20"); | 4359 CheckExpectedBuffers("0K 5D5E 10K 15 20"); |
4393 CheckNoNextBuffer(); | 4360 CheckNoNextBuffer(); |
4394 | 4361 |
4395 // If the overlapped buffer at timestamp 10 is removed, the adjusted duration | 4362 // If the overlapped buffer at timestamp 10 is removed, the adjusted duration |
4396 // should remain adjusted. | 4363 // should remain adjusted. |
4397 RemoveInMs(10, 20, 25); | 4364 RemoveInMs(10, 20, 25); |
4398 CheckExpectedRangesByTimestamp("{ [0,10) }"); | 4365 CheckExpectedRangesByTimestamp("{ [0,10) }"); |
4399 Seek(0); | 4366 Seek(0); |
4400 CheckExpectedBuffers("0K 5D5E"); | 4367 CheckExpectedBuffers("0K 5D5E"); |
4401 CheckNoNextBuffer(); | 4368 CheckNoNextBuffer(); |
4402 } | 4369 } |
4403 | 4370 |
4404 TEST_F(SourceBufferStreamTest, SeekToStartSatisfiedUpToThreshold) { | 4371 TEST_F(SourceBufferStreamTest, SeekToStartSatisfiedUpToThreshold) { |
4405 NewSegmentAppend("999K 1010 1020D10"); | 4372 NewCodedFrameGroupAppend("999K 1010 1020D10"); |
4406 CheckExpectedRangesByTimestamp("{ [999,1030) }"); | 4373 CheckExpectedRangesByTimestamp("{ [999,1030) }"); |
4407 | 4374 |
4408 SeekToTimestampMs(0); | 4375 SeekToTimestampMs(0); |
4409 CheckExpectedBuffers("999K 1010 1020D10"); | 4376 CheckExpectedBuffers("999K 1010 1020D10"); |
4410 CheckNoNextBuffer(); | 4377 CheckNoNextBuffer(); |
4411 } | 4378 } |
4412 | 4379 |
4413 TEST_F(SourceBufferStreamTest, SeekToStartUnsatisfiedBeyondThreshold) { | 4380 TEST_F(SourceBufferStreamTest, SeekToStartUnsatisfiedBeyondThreshold) { |
4414 NewSegmentAppend("1000K 1010 1020D10"); | 4381 NewCodedFrameGroupAppend("1000K 1010 1020D10"); |
4415 CheckExpectedRangesByTimestamp("{ [1000,1030) }"); | 4382 CheckExpectedRangesByTimestamp("{ [1000,1030) }"); |
4416 | 4383 |
4417 SeekToTimestampMs(0); | 4384 SeekToTimestampMs(0); |
4418 CheckNoNextBuffer(); | 4385 CheckNoNextBuffer(); |
4419 } | 4386 } |
4420 | 4387 |
4421 TEST_F(SourceBufferStreamTest, | 4388 TEST_F(SourceBufferStreamTest, |
4422 ReSeekToStartSatisfiedUpToThreshold_SameTimestamps) { | 4389 ReSeekToStartSatisfiedUpToThreshold_SameTimestamps) { |
4423 // Append a few buffers. | 4390 // Append a few buffers. |
4424 NewSegmentAppend("999K 1010 1020D10"); | 4391 NewCodedFrameGroupAppend("999K 1010 1020D10"); |
4425 CheckExpectedRangesByTimestamp("{ [999,1030) }"); | 4392 CheckExpectedRangesByTimestamp("{ [999,1030) }"); |
4426 | 4393 |
4427 // Don't read any buffers between Seek and Remove. | 4394 // Don't read any buffers between Seek and Remove. |
4428 SeekToTimestampMs(0); | 4395 SeekToTimestampMs(0); |
4429 RemoveInMs(999, 1030, 1030); | 4396 RemoveInMs(999, 1030, 1030); |
4430 CheckExpectedRangesByTimestamp("{ }"); | 4397 CheckExpectedRangesByTimestamp("{ }"); |
4431 CheckNoNextBuffer(); | 4398 CheckNoNextBuffer(); |
4432 | 4399 |
4433 // Append buffers at the original timestamps and verify no stall. | 4400 // Append buffers at the original timestamps and verify no stall. |
4434 NewSegmentAppend("999K 1010 1020D10"); | 4401 NewCodedFrameGroupAppend("999K 1010 1020D10"); |
4435 CheckExpectedRangesByTimestamp("{ [999,1030) }"); | 4402 CheckExpectedRangesByTimestamp("{ [999,1030) }"); |
4436 CheckExpectedBuffers("999K 1010 1020D10"); | 4403 CheckExpectedBuffers("999K 1010 1020D10"); |
4437 CheckNoNextBuffer(); | 4404 CheckNoNextBuffer(); |
4438 } | 4405 } |
4439 | 4406 |
4440 TEST_F(SourceBufferStreamTest, | 4407 TEST_F(SourceBufferStreamTest, |
4441 ReSeekToStartSatisfiedUpToThreshold_EarlierTimestamps) { | 4408 ReSeekToStartSatisfiedUpToThreshold_EarlierTimestamps) { |
4442 // Append a few buffers. | 4409 // Append a few buffers. |
4443 NewSegmentAppend("999K 1010 1020D10"); | 4410 NewCodedFrameGroupAppend("999K 1010 1020D10"); |
4444 CheckExpectedRangesByTimestamp("{ [999,1030) }"); | 4411 CheckExpectedRangesByTimestamp("{ [999,1030) }"); |
4445 | 4412 |
4446 // Don't read any buffers between Seek and Remove. | 4413 // Don't read any buffers between Seek and Remove. |
4447 SeekToTimestampMs(0); | 4414 SeekToTimestampMs(0); |
4448 RemoveInMs(999, 1030, 1030); | 4415 RemoveInMs(999, 1030, 1030); |
4449 CheckExpectedRangesByTimestamp("{ }"); | 4416 CheckExpectedRangesByTimestamp("{ }"); |
4450 CheckNoNextBuffer(); | 4417 CheckNoNextBuffer(); |
4451 | 4418 |
4452 // Append buffers before the original timestamps and verify no stall (the | 4419 // Append buffers before the original timestamps and verify no stall (the |
4453 // re-seek to time 0 should still be satisfied with the new buffers). | 4420 // re-seek to time 0 should still be satisfied with the new buffers). |
4454 NewSegmentAppend("500K 510 520D10"); | 4421 NewCodedFrameGroupAppend("500K 510 520D10"); |
4455 CheckExpectedRangesByTimestamp("{ [500,530) }"); | 4422 CheckExpectedRangesByTimestamp("{ [500,530) }"); |
4456 CheckExpectedBuffers("500K 510 520D10"); | 4423 CheckExpectedBuffers("500K 510 520D10"); |
4457 CheckNoNextBuffer(); | 4424 CheckNoNextBuffer(); |
4458 } | 4425 } |
4459 | 4426 |
4460 TEST_F(SourceBufferStreamTest, | 4427 TEST_F(SourceBufferStreamTest, |
4461 ReSeekToStartSatisfiedUpToThreshold_LaterTimestamps) { | 4428 ReSeekToStartSatisfiedUpToThreshold_LaterTimestamps) { |
4462 // Append a few buffers. | 4429 // Append a few buffers. |
4463 NewSegmentAppend("500K 510 520D10"); | 4430 NewCodedFrameGroupAppend("500K 510 520D10"); |
4464 CheckExpectedRangesByTimestamp("{ [500,530) }"); | 4431 CheckExpectedRangesByTimestamp("{ [500,530) }"); |
4465 | 4432 |
4466 // Don't read any buffers between Seek and Remove. | 4433 // Don't read any buffers between Seek and Remove. |
4467 SeekToTimestampMs(0); | 4434 SeekToTimestampMs(0); |
4468 RemoveInMs(500, 530, 530); | 4435 RemoveInMs(500, 530, 530); |
4469 CheckExpectedRangesByTimestamp("{ }"); | 4436 CheckExpectedRangesByTimestamp("{ }"); |
4470 CheckNoNextBuffer(); | 4437 CheckNoNextBuffer(); |
4471 | 4438 |
4472 // Append buffers beginning after original timestamps, but still below the | 4439 // Append buffers beginning after original timestamps, but still below the |
4473 // start threshold, and verify no stall (the re-seek to time 0 should still be | 4440 // start threshold, and verify no stall (the re-seek to time 0 should still be |
4474 // satisfied with the new buffers). | 4441 // satisfied with the new buffers). |
4475 NewSegmentAppend("999K 1010 1020D10"); | 4442 NewCodedFrameGroupAppend("999K 1010 1020D10"); |
4476 CheckExpectedRangesByTimestamp("{ [999,1030) }"); | 4443 CheckExpectedRangesByTimestamp("{ [999,1030) }"); |
4477 CheckExpectedBuffers("999K 1010 1020D10"); | 4444 CheckExpectedBuffers("999K 1010 1020D10"); |
4478 CheckNoNextBuffer(); | 4445 CheckNoNextBuffer(); |
4479 } | 4446 } |
4480 | 4447 |
4481 TEST_F(SourceBufferStreamTest, ReSeekBeyondStartThreshold_SameTimestamps) { | 4448 TEST_F(SourceBufferStreamTest, ReSeekBeyondStartThreshold_SameTimestamps) { |
4482 // Append a few buffers. | 4449 // Append a few buffers. |
4483 NewSegmentAppend("1000K 1010 1020D10"); | 4450 NewCodedFrameGroupAppend("1000K 1010 1020D10"); |
4484 CheckExpectedRangesByTimestamp("{ [1000,1030) }"); | 4451 CheckExpectedRangesByTimestamp("{ [1000,1030) }"); |
4485 | 4452 |
4486 // Don't read any buffers between Seek and Remove. | 4453 // Don't read any buffers between Seek and Remove. |
4487 SeekToTimestampMs(1000); | 4454 SeekToTimestampMs(1000); |
4488 RemoveInMs(1000, 1030, 1030); | 4455 RemoveInMs(1000, 1030, 1030); |
4489 CheckExpectedRangesByTimestamp("{ }"); | 4456 CheckExpectedRangesByTimestamp("{ }"); |
4490 CheckNoNextBuffer(); | 4457 CheckNoNextBuffer(); |
4491 | 4458 |
4492 // Append buffers at the original timestamps and verify no stall. | 4459 // Append buffers at the original timestamps and verify no stall. |
4493 NewSegmentAppend("1000K 1010 1020D10"); | 4460 NewCodedFrameGroupAppend("1000K 1010 1020D10"); |
4494 CheckExpectedRangesByTimestamp("{ [1000,1030) }"); | 4461 CheckExpectedRangesByTimestamp("{ [1000,1030) }"); |
4495 CheckExpectedBuffers("1000K 1010 1020D10"); | 4462 CheckExpectedBuffers("1000K 1010 1020D10"); |
4496 CheckNoNextBuffer(); | 4463 CheckNoNextBuffer(); |
4497 } | 4464 } |
4498 | 4465 |
4499 TEST_F(SourceBufferStreamTest, ReSeekBeyondThreshold_EarlierTimestamps) { | 4466 TEST_F(SourceBufferStreamTest, ReSeekBeyondThreshold_EarlierTimestamps) { |
4500 // Append a few buffers. | 4467 // Append a few buffers. |
4501 NewSegmentAppend("2000K 2010 2020D10"); | 4468 NewCodedFrameGroupAppend("2000K 2010 2020D10"); |
4502 CheckExpectedRangesByTimestamp("{ [2000,2030) }"); | 4469 CheckExpectedRangesByTimestamp("{ [2000,2030) }"); |
4503 | 4470 |
4504 // Don't read any buffers between Seek and Remove. | 4471 // Don't read any buffers between Seek and Remove. |
4505 SeekToTimestampMs(2000); | 4472 SeekToTimestampMs(2000); |
4506 RemoveInMs(2000, 2030, 2030); | 4473 RemoveInMs(2000, 2030, 2030); |
4507 CheckExpectedRangesByTimestamp("{ }"); | 4474 CheckExpectedRangesByTimestamp("{ }"); |
4508 CheckNoNextBuffer(); | 4475 CheckNoNextBuffer(); |
4509 | 4476 |
4510 // Append buffers before the original timestamps and verify no stall (the | 4477 // Append buffers before the original timestamps and verify no stall (the |
4511 // re-seek to time 2 seconds should still be satisfied with the new buffers | 4478 // re-seek to time 2 seconds should still be satisfied with the new buffers |
4512 // and should emit preroll from last keyframe). | 4479 // and should emit preroll from last keyframe). |
4513 NewSegmentAppend("1080K 1090 2000D10"); | 4480 NewCodedFrameGroupAppend("1080K 1090 2000D10"); |
4514 CheckExpectedRangesByTimestamp("{ [1080,2010) }"); | 4481 CheckExpectedRangesByTimestamp("{ [1080,2010) }"); |
4515 CheckExpectedBuffers("1080K 1090 2000D10"); | 4482 CheckExpectedBuffers("1080K 1090 2000D10"); |
4516 CheckNoNextBuffer(); | 4483 CheckNoNextBuffer(); |
4517 } | 4484 } |
4518 | 4485 |
4519 TEST_F(SourceBufferStreamTest, ConfigChange_ReSeek) { | 4486 TEST_F(SourceBufferStreamTest, ConfigChange_ReSeek) { |
4520 // Append a few buffers, with a config change in the middle. | 4487 // Append a few buffers, with a config change in the middle. |
4521 VideoDecoderConfig new_config = TestVideoConfig::Large(); | 4488 VideoDecoderConfig new_config = TestVideoConfig::Large(); |
4522 NewSegmentAppend("2000K 2010 2020D10"); | 4489 NewCodedFrameGroupAppend("2000K 2010 2020D10"); |
4523 stream_->UpdateVideoConfig(new_config); | 4490 stream_->UpdateVideoConfig(new_config); |
4524 NewSegmentAppend("2030K 2040 2050D10"); | 4491 NewCodedFrameGroupAppend("2030K 2040 2050D10"); |
4525 CheckExpectedRangesByTimestamp("{ [2000,2060) }"); | 4492 CheckExpectedRangesByTimestamp("{ [2000,2060) }"); |
4526 | 4493 |
4527 // Read the config change, but don't read any non-config-change buffer between | 4494 // Read the config change, but don't read any non-config-change buffer between |
4528 // Seek and Remove. | 4495 // Seek and Remove. |
4529 scoped_refptr<StreamParserBuffer> buffer; | 4496 scoped_refptr<StreamParserBuffer> buffer; |
4530 CheckVideoConfig(video_config_); | 4497 CheckVideoConfig(video_config_); |
4531 SeekToTimestampMs(2030); | 4498 SeekToTimestampMs(2030); |
4532 CheckVideoConfig(video_config_); | 4499 CheckVideoConfig(video_config_); |
4533 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kConfigChange); | 4500 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kConfigChange); |
4534 CheckVideoConfig(new_config); | 4501 CheckVideoConfig(new_config); |
4535 | 4502 |
4536 // Trigger the re-seek. | 4503 // Trigger the re-seek. |
4537 RemoveInMs(2030, 2060, 2060); | 4504 RemoveInMs(2030, 2060, 2060); |
4538 CheckExpectedRangesByTimestamp("{ [2000,2030) }"); | 4505 CheckExpectedRangesByTimestamp("{ [2000,2030) }"); |
4539 CheckNoNextBuffer(); | 4506 CheckNoNextBuffer(); |
4540 | 4507 |
4541 // Append buffers at the original timestamps and verify no stall or redundant | 4508 // Append buffers at the original timestamps and verify no stall or redundant |
4542 // signalling of config change. | 4509 // signalling of config change. |
4543 NewSegmentAppend("2030K 2040 2050D10"); | 4510 NewCodedFrameGroupAppend("2030K 2040 2050D10"); |
4544 CheckVideoConfig(new_config); | 4511 CheckVideoConfig(new_config); |
4545 CheckExpectedRangesByTimestamp("{ [2000,2060) }"); | 4512 CheckExpectedRangesByTimestamp("{ [2000,2060) }"); |
4546 CheckExpectedBuffers("2030K 2040 2050D10"); | 4513 CheckExpectedBuffers("2030K 2040 2050D10"); |
4547 CheckNoNextBuffer(); | 4514 CheckNoNextBuffer(); |
4548 CheckVideoConfig(new_config); | 4515 CheckVideoConfig(new_config); |
4549 | 4516 |
4550 // Seek to the start of buffered and verify config changes and buffers. | 4517 // Seek to the start of buffered and verify config changes and buffers. |
4551 SeekToTimestampMs(2000); | 4518 SeekToTimestampMs(2000); |
4552 CheckVideoConfig(new_config); | 4519 CheckVideoConfig(new_config); |
4553 ASSERT_FALSE(new_config.Matches(video_config_)); | 4520 ASSERT_FALSE(new_config.Matches(video_config_)); |
4554 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kConfigChange); | 4521 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kConfigChange); |
4555 CheckVideoConfig(video_config_); | 4522 CheckVideoConfig(video_config_); |
4556 CheckExpectedBuffers("2000K 2010 2020D10"); | 4523 CheckExpectedBuffers("2000K 2010 2020D10"); |
4557 CheckVideoConfig(video_config_); | 4524 CheckVideoConfig(video_config_); |
4558 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kConfigChange); | 4525 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kConfigChange); |
4559 CheckVideoConfig(new_config); | 4526 CheckVideoConfig(new_config); |
4560 CheckExpectedBuffers("2030K 2040 2050D10"); | 4527 CheckExpectedBuffers("2030K 2040 2050D10"); |
4561 CheckNoNextBuffer(); | 4528 CheckNoNextBuffer(); |
4562 CheckVideoConfig(new_config); | 4529 CheckVideoConfig(new_config); |
4563 } | 4530 } |
4564 | 4531 |
4565 TEST_F(SourceBufferStreamTest, TrackBuffer_ExhaustionWithSkipForward) { | 4532 TEST_F(SourceBufferStreamTest, TrackBuffer_ExhaustionWithSkipForward) { |
4566 NewSegmentAppend("0K 10 20 30 40"); | 4533 NewCodedFrameGroupAppend("0K 10 20 30 40"); |
4567 | 4534 |
4568 // Read the first 4 buffers, so next buffer is at time 40. | 4535 // Read the first 4 buffers, so next buffer is at time 40. |
4569 Seek(0); | 4536 Seek(0); |
4570 CheckExpectedRangesByTimestamp("{ [0,50) }"); | 4537 CheckExpectedRangesByTimestamp("{ [0,50) }"); |
4571 CheckExpectedBuffers("0K 10 20 30"); | 4538 CheckExpectedBuffers("0K 10 20 30"); |
4572 | 4539 |
4573 // Overlap-append, populating track buffer with timestamp 40 from original | 4540 // Overlap-append, populating track buffer with timestamp 40 from original |
4574 // append. Confirm there could be a large jump in time until the next key | 4541 // append. Confirm there could be a large jump in time until the next key |
4575 // frame after exhausting the track buffer. | 4542 // frame after exhausting the track buffer. |
4576 NewSegmentAppend( | 4543 NewCodedFrameGroupAppend( |
4577 "31K 41 51 61 71 81 91 101 111 121 " | 4544 "31K 41 51 61 71 81 91 101 111 121 " |
4578 "131K 141"); | 4545 "131K 141"); |
4579 CheckExpectedRangesByTimestamp("{ [0,151) }"); | 4546 CheckExpectedRangesByTimestamp("{ [0,151) }"); |
4580 | 4547 |
4581 // Confirm the large jump occurs and warning log is generated. | 4548 // Confirm the large jump occurs and warning log is generated. |
4582 // If this test is changed, update | 4549 // If this test is changed, update |
4583 // TrackBufferExhaustion_ImmediateNewTrackBuffer accordingly. | 4550 // TrackBufferExhaustion_ImmediateNewTrackBuffer accordingly. |
4584 EXPECT_MEDIA_LOG(ContainsTrackBufferExhaustionSkipLog(91)); | 4551 EXPECT_MEDIA_LOG(ContainsTrackBufferExhaustionSkipLog(91)); |
4585 | 4552 |
4586 CheckExpectedBuffers("40 131K 141"); | 4553 CheckExpectedBuffers("40 131K 141"); |
4587 CheckNoNextBuffer(); | 4554 CheckNoNextBuffer(); |
4588 } | 4555 } |
4589 | 4556 |
4590 TEST_F(SourceBufferStreamTest, | 4557 TEST_F(SourceBufferStreamTest, |
4591 TrackBuffer_ExhaustionAndImmediateNewTrackBuffer) { | 4558 TrackBuffer_ExhaustionAndImmediateNewTrackBuffer) { |
4592 NewSegmentAppend("0K 10 20 30 40"); | 4559 NewCodedFrameGroupAppend("0K 10 20 30 40"); |
4593 | 4560 |
4594 // Read the first 4 buffers, so next buffer is at time 40. | 4561 // Read the first 4 buffers, so next buffer is at time 40. |
4595 Seek(0); | 4562 Seek(0); |
4596 CheckExpectedRangesByTimestamp("{ [0,50) }"); | 4563 CheckExpectedRangesByTimestamp("{ [0,50) }"); |
4597 CheckExpectedBuffers("0K 10 20 30"); | 4564 CheckExpectedBuffers("0K 10 20 30"); |
4598 | 4565 |
4599 // Overlap-append | 4566 // Overlap-append |
4600 NewSegmentAppend( | 4567 NewCodedFrameGroupAppend( |
4601 "31K 41 51 61 71 81 91 101 111 121 " | 4568 "31K 41 51 61 71 81 91 101 111 121 " |
4602 "131K 141"); | 4569 "131K 141"); |
4603 CheckExpectedRangesByTimestamp("{ [0,151) }"); | 4570 CheckExpectedRangesByTimestamp("{ [0,151) }"); |
4604 | 4571 |
4605 // Exhaust the track buffer, but don't read any of the overlapping append yet. | 4572 // Exhaust the track buffer, but don't read any of the overlapping append yet. |
4606 CheckExpectedBuffers("40"); | 4573 CheckExpectedBuffers("40"); |
4607 | 4574 |
4608 // Selected range's next buffer is now the 131K buffer from the overlapping | 4575 // Selected range's next buffer is now the 131K buffer from the overlapping |
4609 // append. (See TrackBuffer_ExhaustionWithSkipForward for that verification.) | 4576 // append. (See TrackBuffer_ExhaustionWithSkipForward for that verification.) |
4610 // Do another overlap-append to immediately create another track buffer and | 4577 // Do another overlap-append to immediately create another track buffer and |
4611 // verify both track buffer exhaustions skip forward and emit log warnings. | 4578 // verify both track buffer exhaustions skip forward and emit log warnings. |
4612 NewSegmentAppend("22K 32 42 52 62 72 82 92 102 112 122K 132 142 152K 162"); | 4579 NewCodedFrameGroupAppend( |
4580 "22K 32 42 52 62 72 82 92 102 112 122K 132 142 152K 162"); | |
4613 CheckExpectedRangesByTimestamp("{ [0,172) }"); | 4581 CheckExpectedRangesByTimestamp("{ [0,172) }"); |
4614 | 4582 |
4615 InSequence s; | 4583 InSequence s; |
4616 EXPECT_MEDIA_LOG(ContainsTrackBufferExhaustionSkipLog(91)); | 4584 EXPECT_MEDIA_LOG(ContainsTrackBufferExhaustionSkipLog(91)); |
4617 EXPECT_MEDIA_LOG(ContainsTrackBufferExhaustionSkipLog(11)); | 4585 EXPECT_MEDIA_LOG(ContainsTrackBufferExhaustionSkipLog(11)); |
4618 | 4586 |
4619 CheckExpectedBuffers("131K 141 152K 162"); | 4587 CheckExpectedBuffers("131K 141 152K 162"); |
4620 CheckNoNextBuffer(); | 4588 CheckNoNextBuffer(); |
4621 } | 4589 } |
4622 | 4590 |
4591 TEST_F( | |
4592 SourceBufferStreamTest, | |
4593 AdjacentCodedFrameGroupContinuation_NoGapCreatedByTinyGapInGroupContinuation ) { | |
chcunningham
2016/02/09 00:21:08
Did this test fail before? I would expect the test
wolenetz
2016/02/09 00:47:19
It didn't fail (in an equivalent media-segment-ver
| |
4594 NewCodedFrameGroupAppend("0K 10 20K 30 40K 50D10"); | |
4595 CheckExpectedRangesByTimestamp("{ [0,60) }"); | |
4596 | |
4597 // Continue appending to the previously started coded frame group, albeit with | |
4598 // a tiny (1ms) gap. This gap should *NOT* produce a buffered range gap. | |
4599 AppendBuffers("61K 71D10"); | |
4600 CheckExpectedRangesByTimestamp("{ [0,81) }"); | |
4601 } | |
4602 | |
4603 TEST_F(SourceBufferStreamTest, | |
wolenetz
2016/02/05 23:27:24
Note: I tried an equivalent (media-segment-version
chcunningham
2016/02/09 00:21:08
Acknowledged.
| |
4604 AdjacentCodedFrameGroupContinuation_NoGapCreatedPrefixRemoved) { | |
4605 NewCodedFrameGroupAppend("0K 10 20K 30 40K 50D10"); | |
4606 CheckExpectedRangesByTimestamp("{ [0,60) }"); | |
4607 | |
4608 RemoveInMs(0, 35, 60); | |
chcunningham
2016/02/09 00:21:08
Random aside: I have never liked the last "duratio
wolenetz
2016/02/09 00:47:19
You're probably right that an equivalent version w
| |
4609 CheckExpectedRangesByTimestamp("{ [40,60) }"); | |
4610 | |
4611 // Continue appending to the previously started coded frame group, albeit with | |
4612 // a tiny (1ms) gap. This gap should *NOT* produce a buffered range gap. | |
4613 AppendBuffers("61K 71D10"); | |
4614 CheckExpectedRangesByTimestamp("{ [40,81) }"); | |
4615 } | |
4616 | |
4617 TEST_F(SourceBufferStreamTest, | |
4618 AdjacentNewCodedFrameGroupContinuation_NoGapCreatedPrefixRemoved) { | |
4619 NewCodedFrameGroupAppend("0K 10 20K 30 40K 50D10"); | |
4620 CheckExpectedRangesByTimestamp("{ [0,60) }"); | |
4621 | |
4622 RemoveInMs(0, 35, 60); | |
4623 CheckExpectedRangesByTimestamp("{ [40,60) }"); | |
4624 | |
4625 // Continue appending, with a new coded frame group, albeit with | |
4626 // a tiny (1ms) gap. This gap should *NOT* produce a buffered range gap. | |
4627 // This test demonstrates the "pre-relaxation" behavior, where a new "media | |
4628 // segment" (now a new "coded frame group") was signaled at every media | |
4629 // segment boundary. | |
4630 NewCodedFrameGroupAppend("61K 71D10"); | |
4631 CheckExpectedRangesByTimestamp("{ [40,81) }"); | |
4632 } | |
4633 | |
4623 // TODO(vrk): Add unit tests where keyframes are unaligned between streams. | 4634 // TODO(vrk): Add unit tests where keyframes are unaligned between streams. |
4624 // (crbug.com/133557) | 4635 // (crbug.com/133557) |
4625 | 4636 |
4626 // TODO(vrk): Add unit tests with end of stream being called at interesting | 4637 // TODO(vrk): Add unit tests with end of stream being called at interesting |
4627 // times. | 4638 // times. |
4628 | 4639 |
4629 } // namespace media | 4640 } // namespace media |
OLD | NEW |