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