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