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