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 3 // found in the LICENSE file. 4 5 #include "media/filters/source_buffer_stream.h" 6 7 #include <string> 8 9 #include "base/bind.h" 10 #include "base/bind_helpers.h" 11 #include "base/logging.h" 12 #include "base/strings/string_number_conversions.h" 13 #include "base/strings/string_split.h" 14 #include "base/strings/string_util.h" 15 #include "media/base/data_buffer.h" 16 #include "media/base/media_log.h" 17 #include "media/base/test_helpers.h" 18 #include "media/base/text_track_config.h" 19 #include "media/filters/webvtt_util.h" 20 #include "testing/gtest/include/gtest/gtest.h" 21 22 namespace media { 23 24 typedef StreamParser::BufferQueue BufferQueue; 25 26 static const int kDefaultFramesPerSecond = 30; 27 static const int kDefaultKeyframesPerSecond = 6; 28 static const uint8 kDataA = 0x11; 29 static const uint8 kDataB = 0x33; 30 static const int kDataSize = 1; 31 32 class SourceBufferStreamTest : public testing::Test { 33 protected: 34 SourceBufferStreamTest() { 35 video_config_ = TestVideoConfig::Normal(); 36 SetStreamInfo(kDefaultFramesPerSecond, kDefaultKeyframesPerSecond); 37 stream_.reset(new SourceBufferStream(video_config_, log_cb(), true)); 38 } 39 40 void SetMemoryLimit(int buffers_of_data) { 41 stream_->set_memory_limit(buffers_of_data * kDataSize); 42 } 43 44 void SetStreamInfo(int frames_per_second, int keyframes_per_second) { 45 frames_per_second_ = frames_per_second; 46 keyframes_per_second_ = keyframes_per_second; 47 frame_duration_ = ConvertToFrameDuration(frames_per_second); 48 } 49 50 void SetTextStream() { 51 video_config_ = TestVideoConfig::Invalid(); 52 TextTrackConfig config(kTextSubtitles, "", "", ""); 53 stream_.reset(new SourceBufferStream(config, LogCB(), true)); 54 SetStreamInfo(2, 2); 55 } 56 57 void SetAudioStream() { 58 video_config_ = TestVideoConfig::Invalid(); 59 audio_config_.Initialize(kCodecVorbis, 60 kSampleFormatPlanarF32, 61 CHANNEL_LAYOUT_STEREO, 62 1000, 63 NULL, 64 0, 65 false, 66 false, 67 base::TimeDelta(), 68 0); 69 stream_.reset(new SourceBufferStream(audio_config_, LogCB(), true)); 70 71 // Equivalent to 2ms per frame. 72 SetStreamInfo(500, 500); 73 } 74 75 void NewSegmentAppend(int starting_position, int number_of_buffers) { 76 AppendBuffers(starting_position, number_of_buffers, true, 77 base::TimeDelta(), true, &kDataA, kDataSize); 78 } 79 80 void NewSegmentAppend(int starting_position, int number_of_buffers, 81 const uint8* data) { 82 AppendBuffers(starting_position, number_of_buffers, true, 83 base::TimeDelta(), true, data, kDataSize); 84 } 85 86 void NewSegmentAppend_OffsetFirstBuffer( 87 int starting_position, int number_of_buffers, 88 base::TimeDelta first_buffer_offset) { 89 AppendBuffers(starting_position, number_of_buffers, true, 90 first_buffer_offset, true, &kDataA, kDataSize); 91 } 92 93 void NewSegmentAppend_ExpectFailure( 94 int starting_position, int number_of_buffers) { 95 AppendBuffers(starting_position, number_of_buffers, true, 96 base::TimeDelta(), false, &kDataA, kDataSize); 97 } 98 99 void AppendBuffers(int starting_position, int number_of_buffers) { 100 AppendBuffers(starting_position, number_of_buffers, false, 101 base::TimeDelta(), true, &kDataA, kDataSize); 102 } 103 104 void AppendBuffers(int starting_position, int number_of_buffers, 105 const uint8* data) { 106 AppendBuffers(starting_position, number_of_buffers, false, 107 base::TimeDelta(), true, data, kDataSize); 108 } 109 110 void NewSegmentAppend(const std::string& buffers_to_append) { 111 AppendBuffers(buffers_to_append, true, kNoTimestamp(), false, true); 112 } 113 114 void NewSegmentAppend(base::TimeDelta start_timestamp, 115 const std::string& buffers_to_append) { 116 AppendBuffers(buffers_to_append, true, start_timestamp, false, true); 117 } 118 119 void AppendBuffers(const std::string& buffers_to_append) { 120 AppendBuffers(buffers_to_append, false, kNoTimestamp(), false, true); 121 } 122 123 void NewSegmentAppendOneByOne(const std::string& buffers_to_append) { 124 AppendBuffers(buffers_to_append, true, kNoTimestamp(), true, true); 125 } 126 127 void AppendBuffersOneByOne(const std::string& buffers_to_append) { 128 AppendBuffers(buffers_to_append, false, kNoTimestamp(), true, true); 129 } 130 131 void NewSegmentAppend_ExpectFailure(const std::string& buffers_to_append) { 132 AppendBuffers(buffers_to_append, true, kNoTimestamp(), false, false); 133 } 134 135 void AppendBuffers_ExpectFailure(const std::string& buffers_to_append) { 136 AppendBuffers(buffers_to_append, false, kNoTimestamp(), false, false); 137 } 138 139 void Seek(int position) { 140 stream_->Seek(position * frame_duration_); 141 } 142 143 void SeekToTimestamp(base::TimeDelta timestamp) { 144 stream_->Seek(timestamp); 145 } 146 147 void RemoveInMs(int start, int end, int duration) { 148 Remove(base::TimeDelta::FromMilliseconds(start), 149 base::TimeDelta::FromMilliseconds(end), 150 base::TimeDelta::FromMilliseconds(duration)); 151 } 152 153 void Remove(base::TimeDelta start, base::TimeDelta end, 154 base::TimeDelta duration) { 155 stream_->Remove(start, end, duration); 156 } 157 158 int GetRemovalRangeInMs(int start, int end, int bytes_to_free, 159 int* removal_end) { 160 DecodeTimestamp removal_end_timestamp = 161 DecodeTimestamp::FromMilliseconds(*removal_end); 162 int bytes_removed = stream_->GetRemovalRange( 163 DecodeTimestamp::FromMilliseconds(start), 164 DecodeTimestamp::FromMilliseconds(end), bytes_to_free, 165 &removal_end_timestamp); 166 *removal_end = removal_end_timestamp.InMilliseconds(); 167 return bytes_removed; 168 } 169 170 void CheckExpectedRanges(const std::string& expected) { 171 Ranges<base::TimeDelta> r = stream_->GetBufferedTime(); 172 173 std::stringstream ss; 174 ss << "{ "; 175 for (size_t i = 0; i < r.size(); ++i) { 176 int64 start = (r.start(i) / frame_duration_); 177 int64 end = (r.end(i) / frame_duration_) - 1; 178 ss << "[" << start << "," << end << ") "; 179 } 180 ss << "}"; 181 EXPECT_EQ(expected, ss.str()); 182 } 183 184 void CheckExpectedRangesByTimestamp(const std::string& expected) { 185 Ranges<base::TimeDelta> r = stream_->GetBufferedTime(); 186 187 std::stringstream ss; 188 ss << "{ "; 189 for (size_t i = 0; i < r.size(); ++i) { 190 int64 start = r.start(i).InMilliseconds(); 191 int64 end = r.end(i).InMilliseconds(); 192 ss << "[" << start << "," << end << ") "; 193 } 194 ss << "}"; 195 EXPECT_EQ(expected, ss.str()); 196 } 197 198 void CheckExpectedBuffers( 199 int starting_position, int ending_position) { 200 CheckExpectedBuffers(starting_position, ending_position, false, NULL, 0); 201 } 202 203 void CheckExpectedBuffers( 204 int starting_position, int ending_position, bool expect_keyframe) { 205 CheckExpectedBuffers(starting_position, ending_position, expect_keyframe, 206 NULL, 0); 207 } 208 209 void CheckExpectedBuffers( 210 int starting_position, int ending_position, const uint8* data) { 211 CheckExpectedBuffers(starting_position, ending_position, false, data, 212 kDataSize); 213 } 214 215 void CheckExpectedBuffers( 216 int starting_position, int ending_position, const uint8* data, 217 bool expect_keyframe) { 218 CheckExpectedBuffers(starting_position, ending_position, expect_keyframe, 219 data, kDataSize); 220 } 221 222 void CheckExpectedBuffers( 223 int starting_position, int ending_position, bool expect_keyframe, 224 const uint8* expected_data, int expected_size) { 225 int current_position = starting_position; 226 for (; current_position <= ending_position; current_position++) { 227 scoped_refptr<StreamParserBuffer> buffer; 228 SourceBufferStream::Status status = stream_->GetNextBuffer(&buffer); 229 230 EXPECT_NE(status, SourceBufferStream::kConfigChange); 231 if (status != SourceBufferStream::kSuccess) 232 break; 233 234 if (expect_keyframe && current_position == starting_position) 235 EXPECT_TRUE(buffer->IsKeyframe()); 236 237 if (expected_data) { 238 const uint8* actual_data = buffer->data(); 239 const int actual_size = buffer->data_size(); 240 EXPECT_EQ(expected_size, actual_size); 241 for (int i = 0; i < std::min(actual_size, expected_size); i++) { 242 EXPECT_EQ(expected_data[i], actual_data[i]); 243 } 244 } 245 246 EXPECT_EQ(buffer->GetDecodeTimestamp() / frame_duration_, 247 current_position); 248 } 249 250 EXPECT_EQ(ending_position + 1, current_position); 251 } 252 253 void CheckExpectedBuffers(const std::string& expected) { 254 std::vector<std::string> timestamps; 255 base::SplitString(expected, ' ', ×tamps); 256 std::stringstream ss; 257 const SourceBufferStream::Type type = stream_->GetType(); 258 base::TimeDelta active_splice_timestamp = kNoTimestamp(); 259 for (size_t i = 0; i < timestamps.size(); i++) { 260 scoped_refptr<StreamParserBuffer> buffer; 261 SourceBufferStream::Status status = stream_->GetNextBuffer(&buffer); 262 263 if (i > 0) 264 ss << " "; 265 266 if (status == SourceBufferStream::kConfigChange) { 267 switch (type) { 268 case SourceBufferStream::kVideo: 269 stream_->GetCurrentVideoDecoderConfig(); 270 break; 271 case SourceBufferStream::kAudio: 272 stream_->GetCurrentAudioDecoderConfig(); 273 break; 274 case SourceBufferStream::kText: 275 stream_->GetCurrentTextTrackConfig(); 276 break; 277 } 278 279 EXPECT_EQ("C", timestamps[i]); 280 281 ss << "C"; 282 continue; 283 } 284 285 EXPECT_EQ(SourceBufferStream::kSuccess, status); 286 if (status != SourceBufferStream::kSuccess) 287 break; 288 289 ss << buffer->timestamp().InMilliseconds(); 290 291 if (buffer->GetDecodeTimestamp() != 292 DecodeTimestamp::FromPresentationTime(buffer->timestamp())) { 293 ss << "|" << buffer->GetDecodeTimestamp().InMilliseconds(); 294 } 295 296 // Handle preroll buffers. 297 if (EndsWith(timestamps[i], "P", true)) { 298 ASSERT_TRUE(buffer->IsKeyframe()); 299 scoped_refptr<StreamParserBuffer> preroll_buffer; 300 preroll_buffer.swap(buffer); 301 302 // When a preroll buffer is encountered we should be able to request one 303 // more buffer. The first buffer should match the timestamp and config 304 // of the second buffer, except that its discard_padding() should be its 305 // duration. 306 ASSERT_EQ(SourceBufferStream::kSuccess, 307 stream_->GetNextBuffer(&buffer)); 308 ASSERT_EQ(buffer->GetConfigId(), preroll_buffer->GetConfigId()); 309 ASSERT_EQ(buffer->track_id(), preroll_buffer->track_id()); 310 ASSERT_EQ(buffer->timestamp(), preroll_buffer->timestamp()); 311 ASSERT_EQ(buffer->GetDecodeTimestamp(), 312 preroll_buffer->GetDecodeTimestamp()); 313 ASSERT_EQ(kInfiniteDuration(), preroll_buffer->discard_padding().first); 314 ASSERT_EQ(base::TimeDelta(), preroll_buffer->discard_padding().second); 315 ASSERT_TRUE(buffer->IsKeyframe()); 316 317 ss << "P"; 318 } else if (buffer->IsKeyframe()) { 319 ss << "K"; 320 } 321 322 // Until the last splice frame is seen, indicated by a matching timestamp, 323 // all buffers must have the same splice_timestamp(). 324 if (buffer->timestamp() == active_splice_timestamp) { 325 ASSERT_EQ(buffer->splice_timestamp(), kNoTimestamp()); 326 } else { 327 ASSERT_TRUE(active_splice_timestamp == kNoTimestamp() || 328 active_splice_timestamp == buffer->splice_timestamp()); 329 } 330 331 active_splice_timestamp = buffer->splice_timestamp(); 332 } 333 EXPECT_EQ(expected, ss.str()); 334 } 335 336 void CheckNoNextBuffer() { 337 scoped_refptr<StreamParserBuffer> buffer; 338 EXPECT_EQ(SourceBufferStream::kNeedBuffer, stream_->GetNextBuffer(&buffer)); 339 } 340 341 void CheckVideoConfig(const VideoDecoderConfig& config) { 342 const VideoDecoderConfig& actual = stream_->GetCurrentVideoDecoderConfig(); 343 EXPECT_TRUE(actual.Matches(config)) 344 << "Expected: " << config.AsHumanReadableString() 345 << "\nActual: " << actual.AsHumanReadableString(); 346 } 347 348 void CheckAudioConfig(const AudioDecoderConfig& config) { 349 const AudioDecoderConfig& actual = stream_->GetCurrentAudioDecoderConfig(); 350 EXPECT_TRUE(actual.Matches(config)) 351 << "Expected: " << config.AsHumanReadableString() 352 << "\nActual: " << actual.AsHumanReadableString(); 353 } 354 355 const LogCB log_cb() { 356 return base::Bind(&SourceBufferStreamTest::DebugMediaLog, 357 base::Unretained(this)); 358 } 359 360 base::TimeDelta frame_duration() const { return frame_duration_; } 361 362 scoped_ptr<SourceBufferStream> stream_; 363 VideoDecoderConfig video_config_; 364 AudioDecoderConfig audio_config_; 365 366 private: 367 base::TimeDelta ConvertToFrameDuration(int frames_per_second) { 368 return base::TimeDelta::FromMicroseconds( 369 base::Time::kMicrosecondsPerSecond / frames_per_second); 370 } 371 372 void AppendBuffers(int starting_position, 373 int number_of_buffers, 374 bool begin_media_segment, 375 base::TimeDelta first_buffer_offset, 376 bool expect_success, 377 const uint8* data, 378 int size) { 379 if (begin_media_segment) 380 stream_->OnNewMediaSegment(DecodeTimestamp::FromPresentationTime( 381 starting_position * frame_duration_)); 382 383 int keyframe_interval = frames_per_second_ / keyframes_per_second_; 384 385 BufferQueue queue; 386 for (int i = 0; i < number_of_buffers; i++) { 387 int position = starting_position + i; 388 bool is_keyframe = position % keyframe_interval == 0; 389 // Buffer type and track ID are meaningless to these tests. 390 scoped_refptr<StreamParserBuffer> buffer = 391 StreamParserBuffer::CopyFrom(data, size, is_keyframe, 392 DemuxerStream::AUDIO, 0); 393 base::TimeDelta timestamp = frame_duration_ * position; 394 395 if (i == 0) 396 timestamp += first_buffer_offset; 397 buffer->SetDecodeTimestamp( 398 DecodeTimestamp::FromPresentationTime(timestamp)); 399 400 // Simulate an IBB...BBP pattern in which all B-frames reference both 401 // the I- and P-frames. For a GOP with playback order 12345, this would 402 // result in a decode timestamp order of 15234. 403 base::TimeDelta presentation_timestamp; 404 if (is_keyframe) { 405 presentation_timestamp = timestamp; 406 } else if ((position - 1) % keyframe_interval == 0) { 407 // This is the P-frame (first frame following the I-frame) 408 presentation_timestamp = 409 (timestamp + frame_duration_ * (keyframe_interval - 2)); 410 } else { 411 presentation_timestamp = timestamp - frame_duration_; 412 } 413 buffer->set_timestamp(presentation_timestamp); 414 buffer->set_duration(frame_duration_); 415 416 queue.push_back(buffer); 417 } 418 if (!queue.empty()) 419 EXPECT_EQ(expect_success, stream_->Append(queue)); 420 } 421 422 void UpdateLastBufferDuration(DecodeTimestamp current_dts, 423 BufferQueue* buffers) { 424 if (buffers->empty() || buffers->back()->duration() > base::TimeDelta()) 425 return; 426 427 DecodeTimestamp last_dts = buffers->back()->GetDecodeTimestamp(); 428 DCHECK(current_dts >= last_dts); 429 buffers->back()->set_duration(current_dts - last_dts); 430 } 431 432 // StringToBufferQueue() allows for the generation of StreamParserBuffers from 433 // coded strings of timestamps separated by spaces. Supported syntax: 434 // 435 // xx: 436 // Generates a StreamParserBuffer with decode and presentation timestamp xx. 437 // E.g., "0 1 2 3". 438 // 439 // pp|dd: 440 // Generates a StreamParserBuffer with presentation timestamp pp and decode 441 // timestamp dd. E.g., "0|0 3|1 1|2 2|3". 442 // 443 // ##Dzz 444 // Specifies the duration for a buffer. ## represents one of the 2 timestamp 445 // formats above. zz specifies the duration of the buffer in milliseconds. 446 // If the duration isn't specified with this syntax then the buffer duration 447 // is determined by the difference between the decode timestamp in ## and 448 // the decode timestamp of the previous buffer in the string. If the string 449 // only contains 1 buffer then the duration must be explicitly specified with 450 // this format. 451 // 452 // ##K: 453 // Indicates the buffer with timestamp ## reflects a keyframe. ## 454 // can be any of the 3 timestamp formats above. 455 // E.g., "0K 1|2K 2|4D2K". 456 // 457 // S(a# ... y# z#) 458 // Indicates a splice frame buffer should be created with timestamp z#. The 459 // preceding timestamps a# ... y# will be treated as the fade out preroll for 460 // the splice frame. If a timestamp within the preroll ends with C the config 461 // id to use for that and subsequent preroll appends is incremented by one. 462 // The config id for non-splice frame appends will not be affected. 463 BufferQueue StringToBufferQueue(const std::string& buffers_to_append) { 464 std::vector<std::string> timestamps; 465 base::SplitString(buffers_to_append, ' ', ×tamps); 466 467 CHECK_GT(timestamps.size(), 0u); 468 469 bool splice_frame = false; 470 size_t splice_config_id = stream_->append_config_index_; 471 BufferQueue pre_splice_buffers; 472 BufferQueue buffers; 473 for (size_t i = 0; i < timestamps.size(); i++) { 474 bool is_keyframe = false; 475 bool has_preroll = false; 476 bool last_splice_frame = false; 477 // Handle splice frame starts. 478 if (StartsWithASCII(timestamps[i], "S(", true)) { 479 CHECK(!splice_frame); 480 splice_frame = true; 481 // Remove the "S(" off of the token. 482 timestamps[i] = timestamps[i].substr(2, timestamps[i].length()); 483 } 484 if (splice_frame && EndsWith(timestamps[i], ")", true)) { 485 splice_frame = false; 486 last_splice_frame = true; 487 // Remove the ")" off of the token. 488 timestamps[i] = timestamps[i].substr(0, timestamps[i].length() - 1); 489 } 490 // Handle config changes within the splice frame. 491 if (splice_frame && EndsWith(timestamps[i], "C", true)) { 492 splice_config_id++; 493 CHECK(splice_config_id < stream_->audio_configs_.size() || 494 splice_config_id < stream_->video_configs_.size()); 495 // Remove the "C" off of the token. 496 timestamps[i] = timestamps[i].substr(0, timestamps[i].length() - 1); 497 } 498 if (EndsWith(timestamps[i], "K", true)) { 499 is_keyframe = true; 500 // Remove the "K" off of the token. 501 timestamps[i] = timestamps[i].substr(0, timestamps[i].length() - 1); 502 } 503 // Handle preroll buffers. 504 if (EndsWith(timestamps[i], "P", true)) { 505 is_keyframe = true; 506 has_preroll = true; 507 // Remove the "P" off of the token. 508 timestamps[i] = timestamps[i].substr(0, timestamps[i].length() - 1); 509 } 510 511 int duration_in_ms = 0; 512 size_t duration_pos = timestamps[i].find('D'); 513 if (duration_pos != std::string::npos) { 514 CHECK(base::StringToInt(timestamps[i].substr(duration_pos + 1), 515 &duration_in_ms)); 516 timestamps[i] = timestamps[i].substr(0, duration_pos); 517 } 518 519 std::vector<std::string> buffer_timestamps; 520 base::SplitString(timestamps[i], '|', &buffer_timestamps); 521 522 if (buffer_timestamps.size() == 1) 523 buffer_timestamps.push_back(buffer_timestamps[0]); 524 525 CHECK_EQ(2u, buffer_timestamps.size()); 526 527 int pts_in_ms = 0; 528 int dts_in_ms = 0; 529 CHECK(base::StringToInt(buffer_timestamps[0], &pts_in_ms)); 530 CHECK(base::StringToInt(buffer_timestamps[1], &dts_in_ms)); 531 532 // Create buffer. Buffer type and track ID are meaningless to these tests. 533 scoped_refptr<StreamParserBuffer> buffer = 534 StreamParserBuffer::CopyFrom(&kDataA, kDataSize, is_keyframe, 535 DemuxerStream::AUDIO, 0); 536 buffer->set_timestamp(base::TimeDelta::FromMilliseconds(pts_in_ms)); 537 538 if (dts_in_ms != pts_in_ms) { 539 buffer->SetDecodeTimestamp( 540 DecodeTimestamp::FromMilliseconds(dts_in_ms)); 541 } 542 543 if (duration_in_ms) 544 buffer->set_duration(base::TimeDelta::FromMilliseconds(duration_in_ms)); 545 546 // Simulate preroll buffers by just generating another buffer and sticking 547 // it as the preroll. 548 if (has_preroll) { 549 scoped_refptr<StreamParserBuffer> preroll_buffer = 550 StreamParserBuffer::CopyFrom( 551 &kDataA, kDataSize, is_keyframe, DemuxerStream::AUDIO, 0); 552 preroll_buffer->set_duration(frame_duration_); 553 buffer->SetPrerollBuffer(preroll_buffer); 554 } 555 556 if (splice_frame) { 557 // Make sure that splice frames aren't used with content where decode 558 // and presentation timestamps can differ. (i.e., B-frames) 559 CHECK_EQ(buffer->GetDecodeTimestamp().InMicroseconds(), 560 buffer->timestamp().InMicroseconds()); 561 if (!pre_splice_buffers.empty()) { 562 // Enforce strictly monotonically increasing timestamps. 563 CHECK_GT( 564 buffer->timestamp().InMicroseconds(), 565 pre_splice_buffers.back()->timestamp().InMicroseconds()); 566 CHECK_GT( 567 buffer->GetDecodeTimestamp().InMicroseconds(), 568 pre_splice_buffers.back()->GetDecodeTimestamp().InMicroseconds()); 569 } 570 buffer->SetConfigId(splice_config_id); 571 UpdateLastBufferDuration(buffer->GetDecodeTimestamp(), 572 &pre_splice_buffers); 573 pre_splice_buffers.push_back(buffer); 574 continue; 575 } 576 577 if (last_splice_frame) { 578 // Require at least one additional buffer for a splice. 579 CHECK(!pre_splice_buffers.empty()); 580 buffer->SetConfigId(splice_config_id); 581 buffer->ConvertToSpliceBuffer(pre_splice_buffers); 582 pre_splice_buffers.clear(); 583 } 584 585 UpdateLastBufferDuration(buffer->GetDecodeTimestamp(), &buffers); 586 buffers.push_back(buffer); 587 } 588 589 // If the last buffer doesn't have a duration, assume it is the 590 // same as the second to last buffer. 591 if (buffers.size() >= 2 && 592 buffers.back()->duration() <= base::TimeDelta()) { 593 buffers.back()->set_duration( 594 buffers[buffers.size() - 2]->duration()); 595 } 596 597 return buffers; 598 } 599 600 void AppendBuffers(const std::string& buffers_to_append, 601 bool start_new_segment, 602 base::TimeDelta segment_start_timestamp, 603 bool one_by_one, 604 bool expect_success) { 605 BufferQueue buffers = StringToBufferQueue(buffers_to_append); 606 607 if (start_new_segment) { 608 base::TimeDelta start_timestamp = segment_start_timestamp; 609 if (start_timestamp == kNoTimestamp()) 610 start_timestamp = buffers[0]->timestamp(); 611 612 ASSERT_TRUE(start_timestamp <= buffers[0]->timestamp()); 613 614 stream_->OnNewMediaSegment( 615 DecodeTimestamp::FromPresentationTime(start_timestamp)); 616 } 617 618 if (!one_by_one) { 619 EXPECT_EQ(expect_success, stream_->Append(buffers)); 620 return; 621 } 622 623 // Append each buffer one by one. 624 for (size_t i = 0; i < buffers.size(); i++) { 625 BufferQueue wrapper; 626 wrapper.push_back(buffers[i]); 627 EXPECT_TRUE(stream_->Append(wrapper)); 628 } 629 } 630 631 void DebugMediaLog(const std::string& log) { 632 DVLOG(1) << log; 633 } 634 635 int frames_per_second_; 636 int keyframes_per_second_; 637 base::TimeDelta frame_duration_; 638 DISALLOW_COPY_AND_ASSIGN(SourceBufferStreamTest); 639 }; 640 641 TEST_F(SourceBufferStreamTest, Append_SingleRange) { 642 // Append 15 buffers at positions 0 through 14. 643 NewSegmentAppend(0, 15); 644 645 // Check expected range. 646 CheckExpectedRanges("{ [0,14) }"); 647 // Check buffers in range. 648 Seek(0); 649 CheckExpectedBuffers(0, 14); 650 } 651 652 TEST_F(SourceBufferStreamTest, Append_SingleRange_OneBufferAtATime) { 653 // Append 15 buffers starting at position 0, one buffer at a time. 654 NewSegmentAppend(0, 1); 655 for (int i = 1; i < 15; i++) 656 AppendBuffers(i, 1); 657 658 // Check expected range. 659 CheckExpectedRanges("{ [0,14) }"); 660 // Check buffers in range. 661 Seek(0); 662 CheckExpectedBuffers(0, 14); 663 } 664 665 TEST_F(SourceBufferStreamTest, Append_DisjointRanges) { 666 // Append 5 buffers at positions 0 through 4. 667 NewSegmentAppend(0, 5); 668 669 // Append 10 buffers at positions 15 through 24. 670 NewSegmentAppend(15, 10); 671 672 // Check expected ranges. 673 CheckExpectedRanges("{ [0,4) [15,24) }"); 674 // Check buffers in ranges. 675 Seek(0); 676 CheckExpectedBuffers(0, 4); 677 Seek(15); 678 CheckExpectedBuffers(15, 24); 679 } 680 681 TEST_F(SourceBufferStreamTest, Append_AdjacentRanges) { 682 // Append 10 buffers at positions 0 through 9. 683 NewSegmentAppend(0, 10); 684 685 // Append 11 buffers at positions 15 through 25. 686 NewSegmentAppend(15, 11); 687 688 // Append 5 buffers at positions 10 through 14 to bridge the gap. 689 NewSegmentAppend(10, 5); 690 691 // Check expected range. 692 CheckExpectedRanges("{ [0,25) }"); 693 // Check buffers in range. 694 Seek(0); 695 CheckExpectedBuffers(0, 25); 696 } 697 698 TEST_F(SourceBufferStreamTest, Append_DoesNotBeginWithKeyframe) { 699 // Append fails because the range doesn't begin with a keyframe. 700 NewSegmentAppend_ExpectFailure(3, 2); 701 702 // Append 10 buffers at positions 5 through 14. 703 NewSegmentAppend(5, 10); 704 705 // Check expected range. 706 CheckExpectedRanges("{ [5,14) }"); 707 // Check buffers in range. 708 Seek(5); 709 CheckExpectedBuffers(5, 14); 710 711 // Append fails because the range doesn't begin with a keyframe. 712 NewSegmentAppend_ExpectFailure(17, 3); 713 714 CheckExpectedRanges("{ [5,14) }"); 715 Seek(5); 716 CheckExpectedBuffers(5, 14); 717 } 718 719 TEST_F(SourceBufferStreamTest, Append_DoesNotBeginWithKeyframe_Adjacent) { 720 // Append 8 buffers at positions 0 through 7. 721 NewSegmentAppend(0, 8); 722 723 // Now start a new media segment at position 8. Append should fail because 724 // the media segment does not begin with a keyframe. 725 NewSegmentAppend_ExpectFailure(8, 2); 726 727 // Check expected range. 728 CheckExpectedRanges("{ [0,7) }"); 729 // Check buffers in range. 730 Seek(0); 731 CheckExpectedBuffers(0, 7); 732 } 733 734 TEST_F(SourceBufferStreamTest, Complete_Overlap) { 735 // Append 5 buffers at positions 5 through 9. 736 NewSegmentAppend(5, 5); 737 738 // Append 15 buffers at positions 0 through 14. 739 NewSegmentAppend(0, 15); 740 741 // Check expected range. 742 CheckExpectedRanges("{ [0,14) }"); 743 // Check buffers in range. 744 Seek(0); 745 CheckExpectedBuffers(0, 14); 746 } 747 748 TEST_F(SourceBufferStreamTest, 749 Complete_Overlap_AfterSegmentTimestampAndBeforeFirstBufferTimestamp) { 750 // Append a segment with a start timestamp of 0, but the first 751 // buffer starts at 30ms. This can happen in muxed content where the 752 // audio starts before the first frame. 753 NewSegmentAppend(base::TimeDelta::FromMilliseconds(0), "30K 60K 90K 120K"); 754 755 CheckExpectedRangesByTimestamp("{ [0,150) }"); 756 757 // Completely overlap the old buffers, with a segment that starts 758 // after the old segment start timestamp, but before the timestamp 759 // of the first buffer in the segment. 760 NewSegmentAppend("20K 50K 80K 110D10K"); 761 762 // Verify that the buffered ranges are updated properly and we don't crash. 763 CheckExpectedRangesByTimestamp("{ [20,150) }"); 764 765 SeekToTimestamp(base::TimeDelta::FromMilliseconds(20)); 766 CheckExpectedBuffers("20K 50K 80K 110K 120K"); 767 } 768 769 TEST_F(SourceBufferStreamTest, Complete_Overlap_EdgeCase) { 770 // Make each frame a keyframe so that it's okay to overlap frames at any point 771 // (instead of needing to respect keyframe boundaries). 772 SetStreamInfo(30, 30); 773 774 // Append 6 buffers at positions 6 through 11. 775 NewSegmentAppend(6, 6); 776 777 // Append 8 buffers at positions 5 through 12. 778 NewSegmentAppend(5, 8); 779 780 // Check expected range. 781 CheckExpectedRanges("{ [5,12) }"); 782 // Check buffers in range. 783 Seek(5); 784 CheckExpectedBuffers(5, 12); 785 } 786 787 TEST_F(SourceBufferStreamTest, Start_Overlap) { 788 // Append 10 buffers at positions 5 through 14. 789 NewSegmentAppend(5, 5); 790 791 // Append 6 buffers at positions 10 through 15. 792 NewSegmentAppend(10, 6); 793 794 // Check expected range. 795 CheckExpectedRanges("{ [5,15) }"); 796 // Check buffers in range. 797 Seek(5); 798 CheckExpectedBuffers(5, 15); 799 } 800 801 TEST_F(SourceBufferStreamTest, End_Overlap) { 802 // Append 10 buffers at positions 10 through 19. 803 NewSegmentAppend(10, 10); 804 805 // Append 10 buffers at positions 5 through 14. 806 NewSegmentAppend(5, 10); 807 808 // Check expected range. 809 CheckExpectedRanges("{ [5,19) }"); 810 // Check buffers in range. 811 Seek(5); 812 CheckExpectedBuffers(5, 19); 813 } 814 815 TEST_F(SourceBufferStreamTest, End_Overlap_Several) { 816 // Append 10 buffers at positions 10 through 19. 817 NewSegmentAppend(10, 10); 818 819 // Append 8 buffers at positions 5 through 12. 820 NewSegmentAppend(5, 8); 821 822 // Check expected ranges: stream should not have kept buffers 13 and 14 823 // because the keyframe on which they depended was overwritten. 824 CheckExpectedRanges("{ [5,12) [15,19) }"); 825 826 // Check buffers in range. 827 Seek(5); 828 CheckExpectedBuffers(5, 12); 829 CheckNoNextBuffer(); 830 831 Seek(19); 832 CheckExpectedBuffers(15, 19); 833 } 834 835 // Test an end overlap edge case where a single buffer overlaps the 836 // beginning of a range. 837 // old : *0K* 30 60 90 120K 150 838 // new : *0K* 839 // after: *0K* *120K* 150K 840 // track: 841 TEST_F(SourceBufferStreamTest, End_Overlap_SingleBuffer) { 842 // Seek to start of stream. 843 SeekToTimestamp(base::TimeDelta::FromMilliseconds(0)); 844 845 NewSegmentAppend("0K 30 60 90 120K 150"); 846 CheckExpectedRangesByTimestamp("{ [0,180) }"); 847 848 NewSegmentAppend("0D30K"); 849 CheckExpectedRangesByTimestamp("{ [0,30) [120,180) }"); 850 851 CheckExpectedBuffers("0K"); 852 CheckNoNextBuffer(); 853 } 854 855 TEST_F(SourceBufferStreamTest, Complete_Overlap_Several) { 856 // Append 2 buffers at positions 5 through 6. 857 NewSegmentAppend(5, 2); 858 859 // Append 2 buffers at positions 10 through 11. 860 NewSegmentAppend(10, 2); 861 862 // Append 2 buffers at positions 15 through 16. 863 NewSegmentAppend(15, 2); 864 865 // Check expected ranges. 866 CheckExpectedRanges("{ [5,6) [10,11) [15,16) }"); 867 868 // Append buffers at positions 0 through 19. 869 NewSegmentAppend(0, 20); 870 871 // Check expected range. 872 CheckExpectedRanges("{ [0,19) }"); 873 // Check buffers in range. 874 Seek(0); 875 CheckExpectedBuffers(0, 19); 876 } 877 878 TEST_F(SourceBufferStreamTest, Complete_Overlap_Several_Then_Merge) { 879 // Append 2 buffers at positions 5 through 6. 880 NewSegmentAppend(5, 2); 881 882 // Append 2 buffers at positions 10 through 11. 883 NewSegmentAppend(10, 2); 884 885 // Append 2 buffers at positions 15 through 16. 886 NewSegmentAppend(15, 2); 887 888 // Append 2 buffers at positions 20 through 21. 889 NewSegmentAppend(20, 2); 890 891 // Append buffers at positions 0 through 19. 892 NewSegmentAppend(0, 20); 893 894 // Check expected ranges. 895 CheckExpectedRanges("{ [0,21) }"); 896 // Check buffers in range. 897 Seek(0); 898 CheckExpectedBuffers(0, 21); 899 } 900 901 TEST_F(SourceBufferStreamTest, Complete_Overlap_Selected) { 902 // Append 10 buffers at positions 5 through 14. 903 NewSegmentAppend(5, 10, &kDataA); 904 905 // Seek to buffer at position 5. 906 Seek(5); 907 908 // Replace old data with new data. 909 NewSegmentAppend(5, 10, &kDataB); 910 911 // Check ranges are correct. 912 CheckExpectedRanges("{ [5,14) }"); 913 914 // Check that data has been replaced with new data. 915 CheckExpectedBuffers(5, 14, &kDataB); 916 } 917 918 // This test is testing that a client can append data to SourceBufferStream that 919 // overlaps the range from which the client is currently grabbing buffers. We 920 // would expect that the SourceBufferStream would return old data until it hits 921 // the keyframe of the new data, after which it will return the new data. 922 TEST_F(SourceBufferStreamTest, Complete_Overlap_Selected_TrackBuffer) { 923 // Append 10 buffers at positions 5 through 14. 924 NewSegmentAppend(5, 10, &kDataA); 925 926 // Seek to buffer at position 5 and get next buffer. 927 Seek(5); 928 CheckExpectedBuffers(5, 5, &kDataA); 929 930 // Do a complete overlap by appending 20 buffers at positions 0 through 19. 931 NewSegmentAppend(0, 20, &kDataB); 932 933 // Check range is correct. 934 CheckExpectedRanges("{ [0,19) }"); 935 936 // Expect old data up until next keyframe in new data. 937 CheckExpectedBuffers(6, 9, &kDataA); 938 CheckExpectedBuffers(10, 10, &kDataB, true); 939 940 // Expect rest of data to be new. 941 CheckExpectedBuffers(11, 19, &kDataB); 942 943 // Seek back to beginning; all data should be new. 944 Seek(0); 945 CheckExpectedBuffers(0, 19, &kDataB); 946 947 // Check range continues to be correct. 948 CheckExpectedRanges("{ [0,19) }"); 949 } 950 951 TEST_F(SourceBufferStreamTest, Complete_Overlap_Selected_EdgeCase) { 952 // Append 10 buffers at positions 5 through 14. 953 NewSegmentAppend(5, 10, &kDataA); 954 955 // Seek to buffer at position 5 and get next buffer. 956 Seek(5); 957 CheckExpectedBuffers(5, 5, &kDataA); 958 959 // Replace existing data with new data. 960 NewSegmentAppend(5, 10, &kDataB); 961 962 // Check ranges are correct. 963 CheckExpectedRanges("{ [5,14) }"); 964 965 // Expect old data up until next keyframe in new data. 966 CheckExpectedBuffers(6, 9, &kDataA); 967 CheckExpectedBuffers(10, 10, &kDataB, true); 968 969 // Expect rest of data to be new. 970 CheckExpectedBuffers(11, 14, &kDataB); 971 972 // Seek back to beginning; all data should be new. 973 Seek(5); 974 CheckExpectedBuffers(5, 14, &kDataB); 975 976 // Check range continues to be correct. 977 CheckExpectedRanges("{ [5,14) }"); 978 } 979 980 TEST_F(SourceBufferStreamTest, Complete_Overlap_Selected_Multiple) { 981 static const uint8 kDataC = 0x55; 982 static const uint8 kDataD = 0x77; 983 984 // Append 5 buffers at positions 5 through 9. 985 NewSegmentAppend(5, 5, &kDataA); 986 987 // Seek to buffer at position 5 and get next buffer. 988 Seek(5); 989 CheckExpectedBuffers(5, 5, &kDataA); 990 991 // Replace existing data with new data. 992 NewSegmentAppend(5, 5, &kDataB); 993 994 // Then replace it again with different data. 995 NewSegmentAppend(5, 5, &kDataC); 996 997 // Now append 5 new buffers at positions 10 through 14. 998 NewSegmentAppend(10, 5, &kDataC); 999 1000 // Now replace all the data entirely. 1001 NewSegmentAppend(5, 10, &kDataD); 1002 1003 // Expect buffers 6 through 9 to be DataA, and the remaining 1004 // buffers to be kDataD. 1005 CheckExpectedBuffers(6, 9, &kDataA); 1006 CheckExpectedBuffers(10, 14, &kDataD); 1007 1008 // At this point we cannot fulfill request. 1009 CheckNoNextBuffer(); 1010 1011 // Seek back to beginning; all data should be new. 1012 Seek(5); 1013 CheckExpectedBuffers(5, 14, &kDataD); 1014 } 1015 1016 TEST_F(SourceBufferStreamTest, Start_Overlap_Selected) { 1017 // Append 10 buffers at positions 0 through 9. 1018 NewSegmentAppend(0, 10, &kDataA); 1019 1020 // Seek to position 5, then add buffers to overlap data at that position. 1021 Seek(5); 1022 NewSegmentAppend(5, 10, &kDataB); 1023 1024 // Check expected range. 1025 CheckExpectedRanges("{ [0,14) }"); 1026 1027 // Because we seeked to a keyframe, the next buffers should all be new data. 1028 CheckExpectedBuffers(5, 14, &kDataB); 1029 1030 // Make sure all data is correct. 1031 Seek(0); 1032 CheckExpectedBuffers(0, 4, &kDataA); 1033 CheckExpectedBuffers(5, 14, &kDataB); 1034 } 1035 1036 TEST_F(SourceBufferStreamTest, Start_Overlap_Selected_TrackBuffer) { 1037 // Append 15 buffers at positions 0 through 14. 1038 NewSegmentAppend(0, 15, &kDataA); 1039 1040 // Seek to 10 and get buffer. 1041 Seek(10); 1042 CheckExpectedBuffers(10, 10, &kDataA); 1043 1044 // Now append 10 buffers of new data at positions 10 through 19. 1045 NewSegmentAppend(10, 10, &kDataB); 1046 1047 // Check expected range. 1048 CheckExpectedRanges("{ [0,19) }"); 1049 1050 // The next 4 buffers should be a from the old buffer, followed by a keyframe 1051 // from the new data. 1052 CheckExpectedBuffers(11, 14, &kDataA); 1053 CheckExpectedBuffers(15, 15, &kDataB, true); 1054 1055 // The rest of the buffers should be new data. 1056 CheckExpectedBuffers(16, 19, &kDataB); 1057 1058 // Now seek to the beginning; positions 0 through 9 should be the original 1059 // data, positions 10 through 19 should be the new data. 1060 Seek(0); 1061 CheckExpectedBuffers(0, 9, &kDataA); 1062 CheckExpectedBuffers(10, 19, &kDataB); 1063 1064 // Make sure range is still correct. 1065 CheckExpectedRanges("{ [0,19) }"); 1066 } 1067 1068 TEST_F(SourceBufferStreamTest, Start_Overlap_Selected_EdgeCase) { 1069 // Append 10 buffers at positions 5 through 14. 1070 NewSegmentAppend(5, 10, &kDataA); 1071 1072 Seek(10); 1073 CheckExpectedBuffers(10, 10, &kDataA); 1074 1075 // Now replace the last 5 buffers with new data. 1076 NewSegmentAppend(10, 5, &kDataB); 1077 1078 // The next 4 buffers should be the origial data, held in the track buffer. 1079 CheckExpectedBuffers(11, 14, &kDataA); 1080 1081 // The next buffer is at position 15, so we should fail to fulfill the 1082 // request. 1083 CheckNoNextBuffer(); 1084 1085 // Now append data at 15 through 19 and check to make sure it's correct. 1086 NewSegmentAppend(15, 5, &kDataB); 1087 CheckExpectedBuffers(15, 19, &kDataB); 1088 1089 // Seek to beginning of buffered range and check buffers. 1090 Seek(5); 1091 CheckExpectedBuffers(5, 9, &kDataA); 1092 CheckExpectedBuffers(10, 19, &kDataB); 1093 1094 // Check expected range. 1095 CheckExpectedRanges("{ [5,19) }"); 1096 } 1097 1098 // This test covers the case where new buffers end-overlap an existing, selected 1099 // range, and the next buffer is a keyframe that's being overlapped by new 1100 // buffers. 1101 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1102 // old : *A*a a a a A a a a a 1103 // new : B b b b b B b b b b 1104 // after: B b b b b*B*b b b b A a a a a 1105 TEST_F(SourceBufferStreamTest, End_Overlap_Selected) { 1106 // Append 10 buffers at positions 5 through 14. 1107 NewSegmentAppend(5, 10, &kDataA); 1108 1109 // Seek to position 5. 1110 Seek(5); 1111 1112 // Now append 10 buffers at positions 0 through 9. 1113 NewSegmentAppend(0, 10, &kDataB); 1114 1115 // Check expected range. 1116 CheckExpectedRanges("{ [0,14) }"); 1117 1118 // Because we seeked to a keyframe, the next buffers should be new. 1119 CheckExpectedBuffers(5, 9, &kDataB); 1120 1121 // Make sure all data is correct. 1122 Seek(0); 1123 CheckExpectedBuffers(0, 9, &kDataB); 1124 CheckExpectedBuffers(10, 14, &kDataA); 1125 } 1126 1127 // This test covers the case where new buffers end-overlap an existing, selected 1128 // range, and the next buffer in the range is after the newly appended buffers. 1129 // In this particular case, the end overlap does not require a split. 1130 // 1131 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1132 // old : |A a a a a A a a*a*a| 1133 // new : B b b b b B b b b b 1134 // after: |B b b b b B b b b b A a a*a*a| 1135 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_AfterEndOfNew_1) { 1136 // Append 10 buffers at positions 5 through 14. 1137 NewSegmentAppend(5, 10, &kDataA); 1138 1139 // Seek to position 10, then move to position 13. 1140 Seek(10); 1141 CheckExpectedBuffers(10, 12, &kDataA); 1142 1143 // Now append 10 buffers at positions 0 through 9. 1144 NewSegmentAppend(0, 10, &kDataB); 1145 1146 // Check expected range. 1147 CheckExpectedRanges("{ [0,14) }"); 1148 1149 // Make sure rest of data is as expected. 1150 CheckExpectedBuffers(13, 14, &kDataA); 1151 1152 // Make sure all data is correct. 1153 Seek(0); 1154 CheckExpectedBuffers(0, 9, &kDataB); 1155 CheckExpectedBuffers(10, 14, &kDataA); 1156 } 1157 1158 // This test covers the case where new buffers end-overlap an existing, selected 1159 // range, and the next buffer in the range is after the newly appended buffers. 1160 // In this particular case, the end overlap requires a split, and the next 1161 // buffer is in the split range. 1162 // 1163 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1164 // old : |A a a a a A a a*a*a| 1165 // new : B b b b b B b b 1166 // after: |B b b b b B b b| |A a a*a*a| 1167 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_AfterEndOfNew_2) { 1168 // Append 10 buffers at positions 5 through 14. 1169 NewSegmentAppend(5, 10, &kDataA); 1170 1171 // Seek to position 10, then move to position 13. 1172 Seek(10); 1173 CheckExpectedBuffers(10, 12, &kDataA); 1174 1175 // Now append 8 buffers at positions 0 through 7. 1176 NewSegmentAppend(0, 8, &kDataB); 1177 1178 // Check expected ranges. 1179 CheckExpectedRanges("{ [0,7) [10,14) }"); 1180 1181 // Make sure rest of data is as expected. 1182 CheckExpectedBuffers(13, 14, &kDataA); 1183 1184 // Make sure all data is correct. 1185 Seek(0); 1186 CheckExpectedBuffers(0, 7, &kDataB); 1187 CheckNoNextBuffer(); 1188 1189 Seek(10); 1190 CheckExpectedBuffers(10, 14, &kDataA); 1191 } 1192 1193 // This test covers the case where new buffers end-overlap an existing, selected 1194 // range, and the next buffer in the range is after the newly appended buffers. 1195 // In this particular case, the end overlap requires a split, and the next 1196 // buffer was in between the end of the new data and the split range. 1197 // 1198 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1199 // old : |A a a*a*a A a a a a| 1200 // new : B b b b b B b b 1201 // after: |B b b b b B b b| |A a a a a| 1202 // track: |a a| 1203 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_AfterEndOfNew_3) { 1204 // Append 10 buffers at positions 5 through 14. 1205 NewSegmentAppend(5, 10, &kDataA); 1206 1207 // Seek to position 5, then move to position 8. 1208 Seek(5); 1209 CheckExpectedBuffers(5, 7, &kDataA); 1210 1211 // Now append 8 buffers at positions 0 through 7. 1212 NewSegmentAppend(0, 8, &kDataB); 1213 1214 // Check expected ranges. 1215 CheckExpectedRanges("{ [0,7) [10,14) }"); 1216 1217 // Check for data in the track buffer. 1218 CheckExpectedBuffers(8, 9, &kDataA); 1219 // The buffer immediately after the track buffer should be a keyframe. 1220 CheckExpectedBuffers(10, 10, &kDataA, true); 1221 1222 // Make sure all data is correct. 1223 Seek(0); 1224 CheckExpectedBuffers(0, 7, &kDataB); 1225 Seek(10); 1226 CheckExpectedBuffers(10, 14, &kDataA); 1227 } 1228 1229 // This test covers the case where new buffers end-overlap an existing, selected 1230 // range, and the next buffer in the range is overlapped by the new buffers. 1231 // In this particular case, the end overlap does not require a split. 1232 // 1233 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1234 // old : |A a a*a*a A a a a a| 1235 // new : B b b b b B b b b b 1236 // after: |B b b b b B b b b b A a a a a| 1237 // track: |a a| 1238 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_OverlappedByNew_1) { 1239 // Append 10 buffers at positions 5 through 14. 1240 NewSegmentAppend(5, 10, &kDataA); 1241 1242 // Seek to position 5, then move to position 8. 1243 Seek(5); 1244 CheckExpectedBuffers(5, 7, &kDataA); 1245 1246 // Now append 10 buffers at positions 0 through 9. 1247 NewSegmentAppend(0, 10, &kDataB); 1248 1249 // Check expected range. 1250 CheckExpectedRanges("{ [0,14) }"); 1251 1252 // Check for data in the track buffer. 1253 CheckExpectedBuffers(8, 9, &kDataA); 1254 // The buffer immediately after the track buffer should be a keyframe. 1255 CheckExpectedBuffers(10, 10, &kDataA, true); 1256 1257 // Make sure all data is correct. 1258 Seek(0); 1259 CheckExpectedBuffers(0, 9, &kDataB); 1260 CheckExpectedBuffers(10, 14, &kDataA); 1261 } 1262 1263 // This test covers the case where new buffers end-overlap an existing, selected 1264 // range, and the next buffer in the range is overlapped by the new buffers. 1265 // In this particular case, the end overlap requires a split, and the next 1266 // keyframe after the track buffer is in the split range. 1267 // 1268 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1269 // old : |A*a*a a a A a a a a| 1270 // new : B b b b b B b 1271 // after: |B b b b b B b| |A a a a a| 1272 // track: |a a a a| 1273 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_OverlappedByNew_2) { 1274 // Append 10 buffers at positions 5 through 14. 1275 NewSegmentAppend(5, 10, &kDataA); 1276 1277 // Seek to position 5, then move to position 6. 1278 Seek(5); 1279 CheckExpectedBuffers(5, 5, &kDataA); 1280 1281 // Now append 7 buffers at positions 0 through 6. 1282 NewSegmentAppend(0, 7, &kDataB); 1283 1284 // Check expected ranges. 1285 CheckExpectedRanges("{ [0,6) [10,14) }"); 1286 1287 // Check for data in the track buffer. 1288 CheckExpectedBuffers(6, 9, &kDataA); 1289 // The buffer immediately after the track buffer should be a keyframe. 1290 CheckExpectedBuffers(10, 10, &kDataA, true); 1291 1292 // Make sure all data is correct. 1293 Seek(0); 1294 CheckExpectedBuffers(0, 6, &kDataB); 1295 CheckNoNextBuffer(); 1296 1297 Seek(10); 1298 CheckExpectedBuffers(10, 14, &kDataA); 1299 } 1300 1301 // This test covers the case where new buffers end-overlap an existing, selected 1302 // range, and the next buffer in the range is overlapped by the new buffers. 1303 // In this particular case, the end overlap requires a split, and the next 1304 // keyframe after the track buffer is in the range with the new buffers. 1305 // 1306 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1307 // old : |A*a*a a a A a a a a A a a a a| 1308 // new : B b b b b B b b b b B b b 1309 // after: |B b b b b B b b b b B b b| |A a a a a| 1310 // track: |a a a a| 1311 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_OverlappedByNew_3) { 1312 // Append 15 buffers at positions 5 through 19. 1313 NewSegmentAppend(5, 15, &kDataA); 1314 1315 // Seek to position 5, then move to position 6. 1316 Seek(5); 1317 CheckExpectedBuffers(5, 5, &kDataA); 1318 1319 // Now append 13 buffers at positions 0 through 12. 1320 NewSegmentAppend(0, 13, &kDataB); 1321 1322 // Check expected ranges. 1323 CheckExpectedRanges("{ [0,12) [15,19) }"); 1324 1325 // Check for data in the track buffer. 1326 CheckExpectedBuffers(6, 9, &kDataA); 1327 // The buffer immediately after the track buffer should be a keyframe 1328 // from the new data. 1329 CheckExpectedBuffers(10, 10, &kDataB, true); 1330 1331 // Make sure all data is correct. 1332 Seek(0); 1333 CheckExpectedBuffers(0, 12, &kDataB); 1334 CheckNoNextBuffer(); 1335 1336 Seek(15); 1337 CheckExpectedBuffers(15, 19, &kDataA); 1338 } 1339 1340 // This test covers the case where new buffers end-overlap an existing, selected 1341 // range, and there is no keyframe after the end of the new buffers. 1342 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1343 // old : |A*a*a a a| 1344 // new : B b b b b B 1345 // after: |B b b b b B| 1346 // track: |a a a a| 1347 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_NoKeyframeAfterNew) { 1348 // Append 5 buffers at positions 5 through 9. 1349 NewSegmentAppend(5, 5, &kDataA); 1350 1351 // Seek to position 5, then move to position 6. 1352 Seek(5); 1353 CheckExpectedBuffers(5, 5, &kDataA); 1354 1355 // Now append 6 buffers at positions 0 through 5. 1356 NewSegmentAppend(0, 6, &kDataB); 1357 1358 // Check expected range. 1359 CheckExpectedRanges("{ [0,5) }"); 1360 1361 // Check for data in the track buffer. 1362 CheckExpectedBuffers(6, 9, &kDataA); 1363 1364 // Now there's no data to fulfill the request. 1365 CheckNoNextBuffer(); 1366 1367 // Let's fill in the gap, buffers 6 through 10. 1368 AppendBuffers(6, 5, &kDataB); 1369 1370 // We should be able to get the next buffer. 1371 CheckExpectedBuffers(10, 10, &kDataB); 1372 } 1373 1374 // This test covers the case where new buffers end-overlap an existing, selected 1375 // range, and there is no keyframe after the end of the new buffers, then the 1376 // range gets split. 1377 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1378 // old : |A a a a a A*a*| 1379 // new : B b b b b B b b b b B 1380 // after: |B b b b b B b b b b B| 1381 // new : A a a a a A 1382 // after: |A a a a a A| |B b b b b B| 1383 // track: |a| 1384 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_NoKeyframeAfterNew2) { 1385 // Append 7 buffers at positions 10 through 16. 1386 NewSegmentAppend(10, 7, &kDataA); 1387 1388 // Seek to position 15, then move to position 16. 1389 Seek(15); 1390 CheckExpectedBuffers(15, 15, &kDataA); 1391 1392 // Now append 11 buffers at positions 5 through 15. 1393 NewSegmentAppend(5, 11, &kDataB); 1394 CheckExpectedRanges("{ [5,15) }"); 1395 1396 // Now do another end-overlap to split the range into two parts, where the 1397 // 2nd range should have the next buffer position. 1398 NewSegmentAppend(0, 6, &kDataA); 1399 CheckExpectedRanges("{ [0,5) [10,15) }"); 1400 1401 // Check for data in the track buffer. 1402 CheckExpectedBuffers(16, 16, &kDataA); 1403 1404 // Now there's no data to fulfill the request. 1405 CheckNoNextBuffer(); 1406 1407 // Add data to the 2nd range, should not be able to fulfill the next read 1408 // until we've added a keyframe. 1409 NewSegmentAppend(15, 1, &kDataB); 1410 CheckNoNextBuffer(); 1411 for (int i = 16; i <= 19; i++) { 1412 AppendBuffers(i, 1, &kDataB); 1413 CheckNoNextBuffer(); 1414 } 1415 1416 // Now append a keyframe. 1417 AppendBuffers(20, 1, &kDataB); 1418 1419 // We should be able to get the next buffer. 1420 CheckExpectedBuffers(20, 20, &kDataB, true); 1421 } 1422 1423 // This test covers the case where new buffers end-overlap an existing, selected 1424 // range, and the next keyframe in a separate range. 1425 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1426 // old : |A*a*a a a| |A a a a a| 1427 // new : B b b b b B 1428 // after: |B b b b b B| |A a a a a| 1429 // track: |a a a a| 1430 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_NoKeyframeAfterNew3) { 1431 // Append 5 buffers at positions 5 through 9. 1432 NewSegmentAppend(5, 5, &kDataA); 1433 1434 // Append 5 buffers at positions 15 through 19. 1435 NewSegmentAppend(15, 5, &kDataA); 1436 1437 // Check expected range. 1438 CheckExpectedRanges("{ [5,9) [15,19) }"); 1439 1440 // Seek to position 5, then move to position 6. 1441 Seek(5); 1442 CheckExpectedBuffers(5, 5, &kDataA); 1443 1444 // Now append 6 buffers at positions 0 through 5. 1445 NewSegmentAppend(0, 6, &kDataB); 1446 1447 // Check expected range. 1448 CheckExpectedRanges("{ [0,5) [15,19) }"); 1449 1450 // Check for data in the track buffer. 1451 CheckExpectedBuffers(6, 9, &kDataA); 1452 1453 // Now there's no data to fulfill the request. 1454 CheckNoNextBuffer(); 1455 1456 // Let's fill in the gap, buffers 6 through 14. 1457 AppendBuffers(6, 9, &kDataB); 1458 1459 // Check expected range. 1460 CheckExpectedRanges("{ [0,19) }"); 1461 1462 // We should be able to get the next buffer. 1463 CheckExpectedBuffers(10, 14, &kDataB); 1464 1465 // We should be able to get the next buffer. 1466 CheckExpectedBuffers(15, 19, &kDataA); 1467 } 1468 1469 // This test covers the case when new buffers overlap the middle of a selected 1470 // range. This tests the case when there is no split and the next buffer is a 1471 // keyframe. 1472 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1473 // old : A a a a a*A*a a a a A a a a a 1474 // new : B b b b b 1475 // after: A a a a a*B*b b b b A a a a a 1476 TEST_F(SourceBufferStreamTest, Middle_Overlap_Selected_1) { 1477 // Append 15 buffers at positions 0 through 14. 1478 NewSegmentAppend(0, 15, &kDataA); 1479 1480 // Seek to position 5. 1481 Seek(5); 1482 1483 // Now append 5 buffers at positions 5 through 9. 1484 NewSegmentAppend(5, 5, &kDataB); 1485 1486 // Check expected range. 1487 CheckExpectedRanges("{ [0,14) }"); 1488 1489 // Check for next data; should be new data. 1490 CheckExpectedBuffers(5, 9, &kDataB); 1491 1492 // Make sure all data is correct. 1493 Seek(0); 1494 CheckExpectedBuffers(0, 4, &kDataA); 1495 CheckExpectedBuffers(5, 9, &kDataB); 1496 CheckExpectedBuffers(10, 14, &kDataA); 1497 } 1498 1499 // This test covers the case when new buffers overlap the middle of a selected 1500 // range. This tests the case when there is no split and the next buffer is 1501 // after the new buffers. 1502 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1503 // old : A a a a a A a a a a A*a*a a a 1504 // new : B b b b b 1505 // after: A a a a a B b b b b A*a*a a a 1506 TEST_F(SourceBufferStreamTest, Middle_Overlap_Selected_2) { 1507 // Append 15 buffers at positions 0 through 14. 1508 NewSegmentAppend(0, 15, &kDataA); 1509 1510 // Seek to 10 then move to position 11. 1511 Seek(10); 1512 CheckExpectedBuffers(10, 10, &kDataA); 1513 1514 // Now append 5 buffers at positions 5 through 9. 1515 NewSegmentAppend(5, 5, &kDataB); 1516 1517 // Check expected range. 1518 CheckExpectedRanges("{ [0,14) }"); 1519 1520 // Make sure data is correct. 1521 CheckExpectedBuffers(11, 14, &kDataA); 1522 Seek(0); 1523 CheckExpectedBuffers(0, 4, &kDataA); 1524 CheckExpectedBuffers(5, 9, &kDataB); 1525 CheckExpectedBuffers(10, 14, &kDataA); 1526 } 1527 1528 // This test covers the case when new buffers overlap the middle of a selected 1529 // range. This tests the case when there is a split and the next buffer is 1530 // before the new buffers. 1531 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1532 // old : A a*a*a a A a a a a A a a a a 1533 // new : B b b 1534 // after: A a*a*a a B b b| |A a a a a 1535 TEST_F(SourceBufferStreamTest, Middle_Overlap_Selected_3) { 1536 // Append 15 buffers at positions 0 through 14. 1537 NewSegmentAppend(0, 15, &kDataA); 1538 1539 // Seek to beginning then move to position 2. 1540 Seek(0); 1541 CheckExpectedBuffers(0, 1, &kDataA); 1542 1543 // Now append 3 buffers at positions 5 through 7. 1544 NewSegmentAppend(5, 3, &kDataB); 1545 1546 // Check expected range. 1547 CheckExpectedRanges("{ [0,7) [10,14) }"); 1548 1549 // Make sure data is correct. 1550 CheckExpectedBuffers(2, 4, &kDataA); 1551 CheckExpectedBuffers(5, 7, &kDataB); 1552 Seek(10); 1553 CheckExpectedBuffers(10, 14, &kDataA); 1554 } 1555 1556 // This test covers the case when new buffers overlap the middle of a selected 1557 // range. This tests the case when there is a split and the next buffer is after 1558 // the new buffers but before the split range. 1559 // index: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1560 // old : A a a a a A a a*a*a A a a a a 1561 // new : B b b 1562 // after: |A a a a a B b b| |A a a a a| 1563 // track: |a a| 1564 TEST_F(SourceBufferStreamTest, Middle_Overlap_Selected_4) { 1565 // Append 15 buffers at positions 0 through 14. 1566 NewSegmentAppend(0, 15, &kDataA); 1567 1568 // Seek to 5 then move to position 8. 1569 Seek(5); 1570 CheckExpectedBuffers(5, 7, &kDataA); 1571 1572 // Now append 3 buffers at positions 5 through 7. 1573 NewSegmentAppend(5, 3, &kDataB); 1574 1575 // Check expected range. 1576 CheckExpectedRanges("{ [0,7) [10,14) }"); 1577 1578 // Buffers 8 and 9 should be in the track buffer. 1579 CheckExpectedBuffers(8, 9, &kDataA); 1580 // The buffer immediately after the track buffer should be a keyframe. 1581 CheckExpectedBuffers(10, 10, &kDataA, true); 1582 1583 // Make sure all data is correct. 1584 Seek(0); 1585 CheckExpectedBuffers(0, 4, &kDataA); 1586 CheckExpectedBuffers(5, 7, &kDataB); 1587 Seek(10); 1588 CheckExpectedBuffers(10, 14, &kDataA); 1589 } 1590 1591 TEST_F(SourceBufferStreamTest, Overlap_OneByOne) { 1592 // Append 5 buffers starting at 10ms, 30ms apart. 1593 NewSegmentAppendOneByOne("10K 40 70 100 130"); 1594 1595 // The range ends at 160, accounting for the last buffer's duration. 1596 CheckExpectedRangesByTimestamp("{ [10,160) }"); 1597 1598 // Overlap with 10 buffers starting at the beginning, appended one at a 1599 // time. 1600 NewSegmentAppend(0, 1, &kDataB); 1601 for (int i = 1; i < 10; i++) 1602 AppendBuffers(i, 1, &kDataB); 1603 1604 // All data should be replaced. 1605 Seek(0); 1606 CheckExpectedRanges("{ [0,9) }"); 1607 CheckExpectedBuffers(0, 9, &kDataB); 1608 } 1609 1610 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_DeleteGroup) { 1611 NewSegmentAppendOneByOne("10K 40 70 100 130K"); 1612 CheckExpectedRangesByTimestamp("{ [10,160) }"); 1613 1614 // Seek to 130ms. 1615 SeekToTimestamp(base::TimeDelta::FromMilliseconds(130)); 1616 1617 // Overlap with a new segment from 0 to 130ms. 1618 NewSegmentAppendOneByOne("0K 120D10"); 1619 1620 // Next buffer should still be 130ms. 1621 CheckExpectedBuffers("130K"); 1622 1623 // Check the final buffers is correct. 1624 SeekToTimestamp(base::TimeDelta::FromMilliseconds(0)); 1625 CheckExpectedBuffers("0K 120 130K"); 1626 } 1627 1628 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_BetweenMediaSegments) { 1629 // Append 5 buffers starting at 110ms, 30ms apart. 1630 NewSegmentAppendOneByOne("110K 140 170 200 230"); 1631 CheckExpectedRangesByTimestamp("{ [110,260) }"); 1632 1633 // Now append 2 media segments from 0ms to 210ms, 30ms apart. Note that the 1634 // old keyframe 110ms falls in between these two segments. 1635 NewSegmentAppendOneByOne("0K 30 60 90"); 1636 NewSegmentAppendOneByOne("120K 150 180 210"); 1637 CheckExpectedRangesByTimestamp("{ [0,240) }"); 1638 1639 // Check the final buffers is correct; the keyframe at 110ms should be 1640 // deleted. 1641 SeekToTimestamp(base::TimeDelta::FromMilliseconds(0)); 1642 CheckExpectedBuffers("0K 30 60 90 120K 150 180 210"); 1643 } 1644 1645 // old : 10K 40 *70* 100K 125 130K 1646 // new : 0K 30 60 90 120K 1647 // after: 0K 30 60 90 *120K* 130K 1648 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer) { 1649 NewSegmentAppendOneByOne("10K 40 70 100K 125 130D30K"); 1650 CheckExpectedRangesByTimestamp("{ [10,160) }"); 1651 1652 // Seek to 70ms. 1653 SeekToTimestamp(base::TimeDelta::FromMilliseconds(70)); 1654 CheckExpectedBuffers("10K 40"); 1655 1656 // Overlap with a new segment from 0 to 130ms. 1657 NewSegmentAppendOneByOne("0K 30 60 90 120D10K"); 1658 CheckExpectedRangesByTimestamp("{ [0,160) }"); 1659 1660 // Should return frame 70ms from the track buffer, then switch 1661 // to the new data at 120K, then switch back to the old data at 130K. The 1662 // frame at 125ms that depended on keyframe 100ms should have been deleted. 1663 CheckExpectedBuffers("70 120K 130K"); 1664 1665 // Check the final result: should not include data from the track buffer. 1666 SeekToTimestamp(base::TimeDelta::FromMilliseconds(0)); 1667 CheckExpectedBuffers("0K 30 60 90 120K 130K"); 1668 } 1669 1670 // Overlap the next keyframe after the end of the track buffer with a new 1671 // keyframe. 1672 // old : 10K 40 *70* 100K 125 130K 1673 // new : 0K 30 60 90 120K 1674 // after: 0K 30 60 90 *120K* 130K 1675 // track: 70 1676 // new : 110K 130 1677 // after: 0K 30 60 90 *110K* 130 1678 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer2) { 1679 NewSegmentAppendOneByOne("10K 40 70 100K 125 130D30K"); 1680 CheckExpectedRangesByTimestamp("{ [10,160) }"); 1681 1682 // Seek to 70ms. 1683 SeekToTimestamp(base::TimeDelta::FromMilliseconds(70)); 1684 CheckExpectedBuffers("10K 40"); 1685 1686 // Overlap with a new segment from 0 to 120ms; 70ms and 100ms go in track 1687 // buffer. 1688 NewSegmentAppendOneByOne("0K 30 60 90 120D10K"); 1689 CheckExpectedRangesByTimestamp("{ [0,160) }"); 1690 1691 // Now overlap the keyframe at 120ms. 1692 NewSegmentAppendOneByOne("110K 130"); 1693 1694 // Should return frame 70ms from the track buffer. Then it should 1695 // return the keyframe after the track buffer, which is at 110ms. 1696 CheckExpectedBuffers("70 110K 130"); 1697 } 1698 1699 // Overlap the next keyframe after the end of the track buffer without a 1700 // new keyframe. 1701 // old : 10K 40 *70* 100K 125 130K 1702 // new : 0K 30 60 90 120K 1703 // after: 0K 30 60 90 *120K* 130K 1704 // track: 70 1705 // new : 50K 80 110 140 1706 // after: 0K 30 50K 80 110 140 * (waiting for keyframe) 1707 // track: 70 1708 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer3) { 1709 NewSegmentAppendOneByOne("10K 40 70 100K 125 130D30K"); 1710 CheckExpectedRangesByTimestamp("{ [10,160) }"); 1711 1712 // Seek to 70ms. 1713 SeekToTimestamp(base::TimeDelta::FromMilliseconds(70)); 1714 CheckExpectedBuffers("10K 40"); 1715 1716 // Overlap with a new segment from 0 to 120ms; 70ms goes in track buffer. 1717 NewSegmentAppendOneByOne("0K 30 60 90 120D10K"); 1718 CheckExpectedRangesByTimestamp("{ [0,160) }"); 1719 1720 // Now overlap the keyframe at 120ms and 130ms. 1721 NewSegmentAppendOneByOne("50K 80 110 140"); 1722 CheckExpectedRangesByTimestamp("{ [0,170) }"); 1723 1724 // Should have all the buffers from the track buffer, then stall. 1725 CheckExpectedBuffers("70"); 1726 CheckNoNextBuffer(); 1727 1728 // Appending a keyframe should fulfill the read. 1729 AppendBuffersOneByOne("150D30K"); 1730 CheckExpectedBuffers("150K"); 1731 CheckNoNextBuffer(); 1732 } 1733 1734 // Overlap the next keyframe after the end of the track buffer with a keyframe 1735 // that comes before the end of the track buffer. 1736 // old : 10K 40 *70* 100K 125 130K 1737 // new : 0K 30 60 90 120K 1738 // after: 0K 30 60 90 *120K* 130K 1739 // track: 70 1740 // new : 80K 110 140 1741 // after: 0K 30 60 *80K* 110 140 1742 // track: 70 1743 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer4) { 1744 NewSegmentAppendOneByOne("10K 40 70 100K 125 130D30K"); 1745 CheckExpectedRangesByTimestamp("{ [10,160) }"); 1746 1747 // Seek to 70ms. 1748 SeekToTimestamp(base::TimeDelta::FromMilliseconds(70)); 1749 CheckExpectedBuffers("10K 40"); 1750 1751 // Overlap with a new segment from 0 to 120ms; 70ms and 100ms go in track 1752 // buffer. 1753 NewSegmentAppendOneByOne("0K 30 60 90 120D10K"); 1754 CheckExpectedRangesByTimestamp("{ [0,160) }"); 1755 1756 // Now append a keyframe at 80ms. 1757 NewSegmentAppendOneByOne("80K 110 140"); 1758 1759 CheckExpectedBuffers("70 80K 110 140"); 1760 CheckNoNextBuffer(); 1761 } 1762 1763 // Overlap the next keyframe after the end of the track buffer with a keyframe 1764 // that comes before the end of the track buffer, when the selected stream was 1765 // waiting for the next keyframe. 1766 // old : 10K 40 *70* 100K 1767 // new : 0K 30 60 90 120 1768 // after: 0K 30 60 90 120 * (waiting for keyframe) 1769 // track: 70 1770 // new : 80K 110 140 1771 // after: 0K 30 60 *80K* 110 140 1772 // track: 70 1773 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer5) { 1774 NewSegmentAppendOneByOne("10K 40 70 100K"); 1775 CheckExpectedRangesByTimestamp("{ [10,130) }"); 1776 1777 // Seek to 70ms. 1778 SeekToTimestamp(base::TimeDelta::FromMilliseconds(70)); 1779 CheckExpectedBuffers("10K 40"); 1780 1781 // Overlap with a new segment from 0 to 120ms; 70ms goes in track 1782 // buffer. 1783 NewSegmentAppendOneByOne("0K 30 60 90 120"); 1784 CheckExpectedRangesByTimestamp("{ [0,150) }"); 1785 1786 // Now append a keyframe at 80ms. 1787 NewSegmentAppendOneByOne("80K 110 140"); 1788 1789 CheckExpectedBuffers("70 80K 110 140"); 1790 CheckNoNextBuffer(); 1791 } 1792 1793 // Test that appending to a different range while there is data in 1794 // the track buffer doesn't affect the selected range or track buffer state. 1795 // old : 10K 40 *70* 100K 125 130K ... 200K 230 1796 // new : 0K 30 60 90 120K 1797 // after: 0K 30 60 90 *120K* 130K ... 200K 230 1798 // track: 70 1799 // old : 0K 30 60 90 *120K* 130K ... 200K 230 1800 // new : 260K 290 1801 // after: 0K 30 60 90 *120K* 130K ... 200K 230 260K 290 1802 // track: 70 1803 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer6) { 1804 NewSegmentAppendOneByOne("10K 40 70 100K 125 130D30K"); 1805 NewSegmentAppendOneByOne("200K 230"); 1806 CheckExpectedRangesByTimestamp("{ [10,160) [200,260) }"); 1807 1808 // Seek to 70ms. 1809 SeekToTimestamp(base::TimeDelta::FromMilliseconds(70)); 1810 CheckExpectedBuffers("10K 40"); 1811 1812 // Overlap with a new segment from 0 to 120ms. 1813 NewSegmentAppendOneByOne("0K 30 60 90 120D10K"); 1814 CheckExpectedRangesByTimestamp("{ [0,160) [200,260) }"); 1815 1816 // Verify that 70 gets read out of the track buffer. 1817 CheckExpectedBuffers("70"); 1818 1819 // Append more data to the unselected range. 1820 NewSegmentAppendOneByOne("260K 290"); 1821 CheckExpectedRangesByTimestamp("{ [0,160) [200,320) }"); 1822 1823 CheckExpectedBuffers("120K 130K"); 1824 CheckNoNextBuffer(); 1825 1826 // Check the final result: should not include data from the track buffer. 1827 SeekToTimestamp(base::TimeDelta::FromMilliseconds(0)); 1828 CheckExpectedBuffers("0K 30 60 90 120K 130K"); 1829 CheckNoNextBuffer(); 1830 } 1831 1832 TEST_F(SourceBufferStreamTest, Seek_Keyframe) { 1833 // Append 6 buffers at positions 0 through 5. 1834 NewSegmentAppend(0, 6); 1835 1836 // Seek to beginning. 1837 Seek(0); 1838 CheckExpectedBuffers(0, 5, true); 1839 } 1840 1841 TEST_F(SourceBufferStreamTest, Seek_NonKeyframe) { 1842 // Append 15 buffers at positions 0 through 14. 1843 NewSegmentAppend(0, 15); 1844 1845 // Seek to buffer at position 13. 1846 Seek(13); 1847 1848 // Expect seeking back to the nearest keyframe. 1849 CheckExpectedBuffers(10, 14, true); 1850 1851 // Seek to buffer at position 3. 1852 Seek(3); 1853 1854 // Expect seeking back to the nearest keyframe. 1855 CheckExpectedBuffers(0, 3, true); 1856 } 1857 1858 TEST_F(SourceBufferStreamTest, Seek_NotBuffered) { 1859 // Seek to beginning. 1860 Seek(0); 1861 1862 // Try to get buffer; nothing's appended. 1863 CheckNoNextBuffer(); 1864 1865 // Append 2 buffers at positions 0. 1866 NewSegmentAppend(0, 2); 1867 Seek(0); 1868 CheckExpectedBuffers(0, 1); 1869 1870 // Try to get buffer out of range. 1871 Seek(2); 1872 CheckNoNextBuffer(); 1873 } 1874 1875 TEST_F(SourceBufferStreamTest, Seek_InBetweenTimestamps) { 1876 // Append 10 buffers at positions 0 through 9. 1877 NewSegmentAppend(0, 10); 1878 1879 base::TimeDelta bump = frame_duration() / 4; 1880 CHECK(bump > base::TimeDelta()); 1881 1882 // Seek to buffer a little after position 5. 1883 stream_->Seek(5 * frame_duration() + bump); 1884 CheckExpectedBuffers(5, 5, true); 1885 1886 // Seek to buffer a little before position 5. 1887 stream_->Seek(5 * frame_duration() - bump); 1888 CheckExpectedBuffers(0, 0, true); 1889 } 1890 1891 // This test will do a complete overlap of an existing range in order to add 1892 // buffers to the track buffers. Then the test does a seek to another part of 1893 // the stream. The SourceBufferStream should clear its internal track buffer in 1894 // response to the Seek(). 1895 TEST_F(SourceBufferStreamTest, Seek_After_TrackBuffer_Filled) { 1896 // Append 10 buffers at positions 5 through 14. 1897 NewSegmentAppend(5, 10, &kDataA); 1898 1899 // Seek to buffer at position 5 and get next buffer. 1900 Seek(5); 1901 CheckExpectedBuffers(5, 5, &kDataA); 1902 1903 // Do a complete overlap by appending 20 buffers at positions 0 through 19. 1904 NewSegmentAppend(0, 20, &kDataB); 1905 1906 // Check range is correct. 1907 CheckExpectedRanges("{ [0,19) }"); 1908 1909 // Seek to beginning; all data should be new. 1910 Seek(0); 1911 CheckExpectedBuffers(0, 19, &kDataB); 1912 1913 // Check range continues to be correct. 1914 CheckExpectedRanges("{ [0,19) }"); 1915 } 1916 1917 TEST_F(SourceBufferStreamTest, Seek_StartOfSegment) { 1918 base::TimeDelta bump = frame_duration() / 4; 1919 CHECK(bump > base::TimeDelta()); 1920 1921 // Append 5 buffers at position (5 + |bump|) through 9, where the media 1922 // segment begins at position 5. 1923 Seek(5); 1924 NewSegmentAppend_OffsetFirstBuffer(5, 5, bump); 1925 scoped_refptr<StreamParserBuffer> buffer; 1926 1927 // GetNextBuffer() should return the next buffer at position (5 + |bump|). 1928 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kSuccess); 1929 EXPECT_EQ(buffer->GetDecodeTimestamp(), 1930 DecodeTimestamp::FromPresentationTime(5 * frame_duration() + bump)); 1931 1932 // Check rest of buffers. 1933 CheckExpectedBuffers(6, 9); 1934 1935 // Seek to position 15. 1936 Seek(15); 1937 1938 // Append 5 buffers at positions (15 + |bump|) through 19, where the media 1939 // segment begins at 15. 1940 NewSegmentAppend_OffsetFirstBuffer(15, 5, bump); 1941 1942 // GetNextBuffer() should return the next buffer at position (15 + |bump|). 1943 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kSuccess); 1944 EXPECT_EQ(buffer->GetDecodeTimestamp(), DecodeTimestamp::FromPresentationTime( 1945 15 * frame_duration() + bump)); 1946 1947 // Check rest of buffers. 1948 CheckExpectedBuffers(16, 19); 1949 } 1950 1951 TEST_F(SourceBufferStreamTest, Seek_BeforeStartOfSegment) { 1952 // Append 10 buffers at positions 5 through 14. 1953 NewSegmentAppend(5, 10); 1954 1955 // Seek to a time before the first buffer in the range. 1956 Seek(0); 1957 1958 // Should return buffers from the beginning of the range. 1959 CheckExpectedBuffers(5, 14); 1960 } 1961 1962 TEST_F(SourceBufferStreamTest, OldSeekPoint_CompleteOverlap) { 1963 // Append 5 buffers at positions 0 through 4. 1964 NewSegmentAppend(0, 4); 1965 1966 // Append 5 buffers at positions 10 through 14, and seek to the beginning of 1967 // this range. 1968 NewSegmentAppend(10, 5); 1969 Seek(10); 1970 1971 // Now seek to the beginning of the first range. 1972 Seek(0); 1973 1974 // Completely overlap the old seek point. 1975 NewSegmentAppend(5, 15); 1976 1977 // The GetNextBuffer() call should respect the 2nd seek point. 1978 CheckExpectedBuffers(0, 0); 1979 } 1980 1981 TEST_F(SourceBufferStreamTest, OldSeekPoint_CompleteOverlap_Pending) { 1982 // Append 2 buffers at positions 0 through 1. 1983 NewSegmentAppend(0, 2); 1984 1985 // Append 5 buffers at positions 15 through 19 and seek to beginning of the 1986 // range. 1987 NewSegmentAppend(15, 5); 1988 Seek(15); 1989 1990 // Now seek position 5. 1991 Seek(5); 1992 1993 // Completely overlap the old seek point. 1994 NewSegmentAppend(10, 15); 1995 1996 // The seek at position 5 should still be pending. 1997 CheckNoNextBuffer(); 1998 } 1999 2000 TEST_F(SourceBufferStreamTest, OldSeekPoint_MiddleOverlap) { 2001 // Append 2 buffers at positions 0 through 1. 2002 NewSegmentAppend(0, 2); 2003 2004 // Append 15 buffers at positions 5 through 19 and seek to position 15. 2005 NewSegmentAppend(5, 15); 2006 Seek(15); 2007 2008 // Now seek to the beginning of the stream. 2009 Seek(0); 2010 2011 // Overlap the middle of the range such that there are now three ranges. 2012 NewSegmentAppend(10, 3); 2013 CheckExpectedRanges("{ [0,1) [5,12) [15,19) }"); 2014 2015 // The GetNextBuffer() call should respect the 2nd seek point. 2016 CheckExpectedBuffers(0, 0); 2017 } 2018 2019 TEST_F(SourceBufferStreamTest, OldSeekPoint_MiddleOverlap_Pending) { 2020 // Append 2 buffers at positions 0 through 1. 2021 NewSegmentAppend(0, 2); 2022 2023 // Append 15 buffers at positions 10 through 24 and seek to position 20. 2024 NewSegmentAppend(10, 15); 2025 Seek(20); 2026 2027 // Now seek to position 5. 2028 Seek(5); 2029 2030 // Overlap the middle of the range such that it is now split into two ranges. 2031 NewSegmentAppend(15, 3); 2032 CheckExpectedRanges("{ [0,1) [10,17) [20,24) }"); 2033 2034 // The seek at position 5 should still be pending. 2035 CheckNoNextBuffer(); 2036 } 2037 2038 TEST_F(SourceBufferStreamTest, OldSeekPoint_StartOverlap) { 2039 // Append 2 buffers at positions 0 through 1. 2040 NewSegmentAppend(0, 2); 2041 2042 // Append 15 buffers at positions 5 through 19 and seek to position 15. 2043 NewSegmentAppend(5, 15); 2044 Seek(15); 2045 2046 // Now seek to the beginning of the stream. 2047 Seek(0); 2048 2049 // Start overlap the old seek point. 2050 NewSegmentAppend(10, 10); 2051 2052 // The GetNextBuffer() call should respect the 2nd seek point. 2053 CheckExpectedBuffers(0, 0); 2054 } 2055 2056 TEST_F(SourceBufferStreamTest, OldSeekPoint_StartOverlap_Pending) { 2057 // Append 2 buffers at positions 0 through 1. 2058 NewSegmentAppend(0, 2); 2059 2060 // Append 15 buffers at positions 10 through 24 and seek to position 20. 2061 NewSegmentAppend(10, 15); 2062 Seek(20); 2063 2064 // Now seek to position 5. 2065 Seek(5); 2066 2067 // Start overlap the old seek point. 2068 NewSegmentAppend(15, 10); 2069 2070 // The seek at time 0 should still be pending. 2071 CheckNoNextBuffer(); 2072 } 2073 2074 TEST_F(SourceBufferStreamTest, OldSeekPoint_EndOverlap) { 2075 // Append 5 buffers at positions 0 through 4. 2076 NewSegmentAppend(0, 4); 2077 2078 // Append 15 buffers at positions 10 through 24 and seek to start of range. 2079 NewSegmentAppend(10, 15); 2080 Seek(10); 2081 2082 // Now seek to the beginning of the stream. 2083 Seek(0); 2084 2085 // End overlap the old seek point. 2086 NewSegmentAppend(5, 10); 2087 2088 // The GetNextBuffer() call should respect the 2nd seek point. 2089 CheckExpectedBuffers(0, 0); 2090 } 2091 2092 TEST_F(SourceBufferStreamTest, OldSeekPoint_EndOverlap_Pending) { 2093 // Append 2 buffers at positions 0 through 1. 2094 NewSegmentAppend(0, 2); 2095 2096 // Append 15 buffers at positions 15 through 29 and seek to start of range. 2097 NewSegmentAppend(15, 15); 2098 Seek(15); 2099 2100 // Now seek to position 5 2101 Seek(5); 2102 2103 // End overlap the old seek point. 2104 NewSegmentAppend(10, 10); 2105 2106 // The seek at time 0 should still be pending. 2107 CheckNoNextBuffer(); 2108 } 2109 2110 TEST_F(SourceBufferStreamTest, GetNextBuffer_AfterMerges) { 2111 // Append 5 buffers at positions 10 through 14. 2112 NewSegmentAppend(10, 5); 2113 2114 // Seek to buffer at position 12. 2115 Seek(12); 2116 2117 // Append 5 buffers at positions 5 through 9. 2118 NewSegmentAppend(5, 5); 2119 2120 // Make sure ranges are merged. 2121 CheckExpectedRanges("{ [5,14) }"); 2122 2123 // Make sure the next buffer is correct. 2124 CheckExpectedBuffers(10, 10); 2125 2126 // Append 5 buffers at positions 15 through 19. 2127 NewSegmentAppend(15, 5); 2128 CheckExpectedRanges("{ [5,19) }"); 2129 2130 // Make sure the remaining next buffers are correct. 2131 CheckExpectedBuffers(11, 14); 2132 } 2133 2134 TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenAppend) { 2135 // Append 4 buffers at positions 0 through 3. 2136 NewSegmentAppend(0, 4); 2137 2138 // Seek to buffer at position 0 and get all buffers. 2139 Seek(0); 2140 CheckExpectedBuffers(0, 3); 2141 2142 // Next buffer is at position 4, so should not be able to fulfill request. 2143 CheckNoNextBuffer(); 2144 2145 // Append 2 buffers at positions 4 through 5. 2146 AppendBuffers(4, 2); 2147 CheckExpectedBuffers(4, 5); 2148 } 2149 2150 // This test covers the case where new buffers start-overlap a range whose next 2151 // buffer is not buffered. 2152 TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenStartOverlap) { 2153 // Append 10 buffers at positions 0 through 9 and exhaust the buffers. 2154 NewSegmentAppend(0, 10, &kDataA); 2155 Seek(0); 2156 CheckExpectedBuffers(0, 9, &kDataA); 2157 2158 // Next buffer is at position 10, so should not be able to fulfill request. 2159 CheckNoNextBuffer(); 2160 2161 // Append 6 buffers at positons 5 through 10. This is to test that doing a 2162 // start-overlap successfully fulfills the read at position 10, even though 2163 // position 10 was unbuffered. 2164 NewSegmentAppend(5, 6, &kDataB); 2165 CheckExpectedBuffers(10, 10, &kDataB); 2166 2167 // Then add 5 buffers from positions 11 though 15. 2168 AppendBuffers(11, 5, &kDataB); 2169 2170 // Check the next 4 buffers are correct, which also effectively seeks to 2171 // position 15. 2172 CheckExpectedBuffers(11, 14, &kDataB); 2173 2174 // Replace the next buffer at position 15 with another start overlap. 2175 NewSegmentAppend(15, 2, &kDataA); 2176 CheckExpectedBuffers(15, 16, &kDataA); 2177 } 2178 2179 // Tests a start overlap that occurs right at the timestamp of the last output 2180 // buffer that was returned by GetNextBuffer(). This test verifies that 2181 // GetNextBuffer() skips to second GOP in the newly appended data instead 2182 // of returning two buffers with the same timestamp. 2183 TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenStartOverlap2) { 2184 NewSegmentAppend("0K 30 60 90 120"); 2185 2186 Seek(0); 2187 CheckExpectedBuffers("0K 30 60 90 120"); 2188 CheckNoNextBuffer(); 2189 2190 // Append a keyframe with the same timestamp as the last buffer output. 2191 NewSegmentAppend("120D30K"); 2192 CheckNoNextBuffer(); 2193 2194 // Append the rest of the segment and make sure that buffers are returned 2195 // from the first GOP after 120. 2196 AppendBuffers("150 180 210K 240"); 2197 CheckExpectedBuffers("210K 240"); 2198 2199 // Seek to the beginning and verify the contents of the source buffer. 2200 Seek(0); 2201 CheckExpectedBuffers("0K 30 60 90 120K 150 180 210K 240"); 2202 CheckNoNextBuffer(); 2203 } 2204 2205 // This test covers the case where new buffers completely overlap a range 2206 // whose next buffer is not buffered. 2207 TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenCompleteOverlap) { 2208 // Append 5 buffers at positions 10 through 14 and exhaust the buffers. 2209 NewSegmentAppend(10, 5, &kDataA); 2210 Seek(10); 2211 CheckExpectedBuffers(10, 14, &kDataA); 2212 2213 // Next buffer is at position 15, so should not be able to fulfill request. 2214 CheckNoNextBuffer(); 2215 2216 // Do a complete overlap and test that this successfully fulfills the read 2217 // at position 15. 2218 NewSegmentAppend(5, 11, &kDataB); 2219 CheckExpectedBuffers(15, 15, &kDataB); 2220 2221 // Then add 5 buffers from positions 16 though 20. 2222 AppendBuffers(16, 5, &kDataB); 2223 2224 // Check the next 4 buffers are correct, which also effectively seeks to 2225 // position 20. 2226 CheckExpectedBuffers(16, 19, &kDataB); 2227 2228 // Do a complete overlap and replace the buffer at position 20. 2229 NewSegmentAppend(0, 21, &kDataA); 2230 CheckExpectedBuffers(20, 20, &kDataA); 2231 } 2232 2233 // This test covers the case where a range is stalled waiting for its next 2234 // buffer, then an end-overlap causes the end of the range to be deleted. 2235 TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenEndOverlap) { 2236 // Append 5 buffers at positions 10 through 14 and exhaust the buffers. 2237 NewSegmentAppend(10, 5, &kDataA); 2238 Seek(10); 2239 CheckExpectedBuffers(10, 14, &kDataA); 2240 CheckExpectedRanges("{ [10,14) }"); 2241 2242 // Next buffer is at position 15, so should not be able to fulfill request. 2243 CheckNoNextBuffer(); 2244 2245 // Do an end overlap that causes the latter half of the range to be deleted. 2246 NewSegmentAppend(5, 6, &kDataB); 2247 CheckNoNextBuffer(); 2248 CheckExpectedRanges("{ [5,10) }"); 2249 2250 // Fill in the gap. Getting the next buffer should still stall at position 15. 2251 for (int i = 11; i <= 14; i++) { 2252 AppendBuffers(i, 1, &kDataB); 2253 CheckNoNextBuffer(); 2254 } 2255 2256 // Append the buffer at position 15 and check to make sure all is correct. 2257 AppendBuffers(15, 1); 2258 CheckExpectedBuffers(15, 15); 2259 CheckExpectedRanges("{ [5,15) }"); 2260 } 2261 2262 // This test is testing the "next buffer" logic after a complete overlap. In 2263 // this scenario, when the track buffer is exhausted, there is no buffered data 2264 // to fulfill the request. The SourceBufferStream should be able to fulfill the 2265 // request when the data is later appended, and should not lose track of the 2266 // "next buffer" position. 2267 TEST_F(SourceBufferStreamTest, GetNextBuffer_Overlap_Selected_Complete) { 2268 // Append 5 buffers at positions 5 through 9. 2269 NewSegmentAppend(5, 5, &kDataA); 2270 2271 // Seek to buffer at position 5 and get next buffer. 2272 Seek(5); 2273 CheckExpectedBuffers(5, 5, &kDataA); 2274 2275 // Replace existing data with new data. 2276 NewSegmentAppend(5, 5, &kDataB); 2277 2278 // Expect old data up until next keyframe in new data. 2279 CheckExpectedBuffers(6, 9, &kDataA); 2280 2281 // Next buffer is at position 10, so should not be able to fulfill the 2282 // request. 2283 CheckNoNextBuffer(); 2284 2285 // Now add 5 new buffers at positions 10 through 14. 2286 AppendBuffers(10, 5, &kDataB); 2287 CheckExpectedBuffers(10, 14, &kDataB); 2288 } 2289 2290 TEST_F(SourceBufferStreamTest, PresentationTimestampIndependence) { 2291 // Append 20 buffers at position 0. 2292 NewSegmentAppend(0, 20); 2293 Seek(0); 2294 2295 int last_keyframe_idx = -1; 2296 base::TimeDelta last_keyframe_presentation_timestamp; 2297 base::TimeDelta last_p_frame_presentation_timestamp; 2298 2299 // Check for IBB...BBP pattern. 2300 for (int i = 0; i < 20; i++) { 2301 scoped_refptr<StreamParserBuffer> buffer; 2302 ASSERT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kSuccess); 2303 2304 if (buffer->IsKeyframe()) { 2305 EXPECT_EQ(DecodeTimestamp::FromPresentationTime(buffer->timestamp()), 2306 buffer->GetDecodeTimestamp()); 2307 last_keyframe_idx = i; 2308 last_keyframe_presentation_timestamp = buffer->timestamp(); 2309 } else if (i == last_keyframe_idx + 1) { 2310 ASSERT_NE(last_keyframe_idx, -1); 2311 last_p_frame_presentation_timestamp = buffer->timestamp(); 2312 EXPECT_LT(last_keyframe_presentation_timestamp, 2313 last_p_frame_presentation_timestamp); 2314 } else { 2315 EXPECT_GT(buffer->timestamp(), last_keyframe_presentation_timestamp); 2316 EXPECT_LT(buffer->timestamp(), last_p_frame_presentation_timestamp); 2317 EXPECT_LT(DecodeTimestamp::FromPresentationTime(buffer->timestamp()), 2318 buffer->GetDecodeTimestamp()); 2319 } 2320 } 2321 } 2322 2323 TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteFront) { 2324 // Set memory limit to 20 buffers. 2325 SetMemoryLimit(20); 2326 2327 // Append 20 buffers at positions 0 through 19. 2328 NewSegmentAppend(0, 1, &kDataA); 2329 for (int i = 1; i < 20; i++) 2330 AppendBuffers(i, 1, &kDataA); 2331 2332 // None of the buffers should trigger garbage collection, so all data should 2333 // be there as expected. 2334 CheckExpectedRanges("{ [0,19) }"); 2335 Seek(0); 2336 CheckExpectedBuffers(0, 19, &kDataA); 2337 2338 // Seek to the middle of the stream. 2339 Seek(10); 2340 2341 // Append 5 buffers to the end of the stream. 2342 AppendBuffers(20, 5, &kDataA); 2343 2344 // GC should have deleted the first 5 buffers. 2345 CheckExpectedRanges("{ [5,24) }"); 2346 CheckExpectedBuffers(10, 24, &kDataA); 2347 Seek(5); 2348 CheckExpectedBuffers(5, 9, &kDataA); 2349 } 2350 2351 TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteFrontGOPsAtATime) { 2352 // Set memory limit to 20 buffers. 2353 SetMemoryLimit(20); 2354 2355 // Append 20 buffers at positions 0 through 19. 2356 NewSegmentAppend(0, 20, &kDataA); 2357 2358 // Seek to position 10. 2359 Seek(10); 2360 2361 // Add one buffer to put the memory over the cap. 2362 AppendBuffers(20, 1, &kDataA); 2363 2364 // GC should have deleted the first 5 buffers so that the range still begins 2365 // with a keyframe. 2366 CheckExpectedRanges("{ [5,20) }"); 2367 CheckExpectedBuffers(10, 20, &kDataA); 2368 Seek(5); 2369 CheckExpectedBuffers(5, 9, &kDataA); 2370 } 2371 2372 TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteBack) { 2373 // Set memory limit to 5 buffers. 2374 SetMemoryLimit(5); 2375 2376 // Seek to position 0. 2377 Seek(0); 2378 2379 // Append 20 buffers at positions 0 through 19. 2380 NewSegmentAppend(0, 20, &kDataA); 2381 2382 // Should leave the first 5 buffers from 0 to 4 and the last GOP appended. 2383 CheckExpectedRanges("{ [0,4) [15,19) }"); 2384 CheckExpectedBuffers(0, 4, &kDataA); 2385 } 2386 2387 TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteFrontAndBack) { 2388 // Set memory limit to 3 buffers. 2389 SetMemoryLimit(3); 2390 2391 // Seek to position 15. 2392 Seek(15); 2393 2394 // Append 40 buffers at positions 0 through 39. 2395 NewSegmentAppend(0, 40, &kDataA); 2396 2397 // Should leave the GOP containing the seek position and the last GOP 2398 // appended. 2399 CheckExpectedRanges("{ [15,19) [35,39) }"); 2400 CheckExpectedBuffers(15, 19, &kDataA); 2401 CheckNoNextBuffer(); 2402 } 2403 2404 TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteSeveralRanges) { 2405 // Append 5 buffers at positions 0 through 4. 2406 NewSegmentAppend(0, 5); 2407 2408 // Append 5 buffers at positions 10 through 14. 2409 NewSegmentAppend(10, 5); 2410 2411 // Append 5 buffers at positions 20 through 24. 2412 NewSegmentAppend(20, 5); 2413 2414 // Append 5 buffers at positions 30 through 34. 2415 NewSegmentAppend(30, 5); 2416 2417 CheckExpectedRanges("{ [0,4) [10,14) [20,24) [30,34) }"); 2418 2419 // Seek to position 21. 2420 Seek(20); 2421 CheckExpectedBuffers(20, 20); 2422 2423 // Set memory limit to 1 buffer. 2424 SetMemoryLimit(1); 2425 2426 // Append 5 buffers at positions 40 through 44. This will trigger GC. 2427 NewSegmentAppend(40, 5); 2428 2429 // Should delete everything except the GOP containing the current buffer and 2430 // the last GOP appended. 2431 CheckExpectedRanges("{ [20,24) [40,44) }"); 2432 CheckExpectedBuffers(21, 24); 2433 CheckNoNextBuffer(); 2434 2435 // Continue appending into the last range to make sure it didn't break. 2436 AppendBuffers(45, 10); 2437 // Should only save last GOP appended. 2438 CheckExpectedRanges("{ [20,24) [50,54) }"); 2439 2440 // Make sure appending before and after the ranges didn't somehow break. 2441 SetMemoryLimit(100); 2442 NewSegmentAppend(0, 10); 2443 CheckExpectedRanges("{ [0,9) [20,24) [50,54) }"); 2444 Seek(0); 2445 CheckExpectedBuffers(0, 9); 2446 2447 NewSegmentAppend(90, 10); 2448 CheckExpectedRanges("{ [0,9) [20,24) [50,54) [90,99) }"); 2449 Seek(50); 2450 CheckExpectedBuffers(50, 54); 2451 CheckNoNextBuffer(); 2452 Seek(90); 2453 CheckExpectedBuffers(90, 99); 2454 CheckNoNextBuffer(); 2455 } 2456 2457 TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteAfterLastAppend) { 2458 // Set memory limit to 10 buffers. 2459 SetMemoryLimit(10); 2460 2461 // Append 1 GOP starting at 310ms, 30ms apart. 2462 NewSegmentAppend("310K 340 370"); 2463 2464 // Append 2 GOPs starting at 490ms, 30ms apart. 2465 NewSegmentAppend("490K 520 550 580K 610 640"); 2466 2467 CheckExpectedRangesByTimestamp("{ [310,400) [490,670) }"); 2468 2469 // Seek to the GOP at 580ms. 2470 SeekToTimestamp(base::TimeDelta::FromMilliseconds(580)); 2471 2472 // Append 2 GOPs before the existing ranges. 2473 // So the ranges before GC are "{ [100,280) [310,400) [490,670) }". 2474 NewSegmentAppend("100K 130 160 190K 220 250K"); 2475 2476 // Should save the newly appended GOPs. 2477 CheckExpectedRangesByTimestamp("{ [100,280) [580,670) }"); 2478 } 2479 2480 TEST_F(SourceBufferStreamTest, GarbageCollection_DeleteAfterLastAppendMerged) { 2481 // Set memory limit to 10 buffers. 2482 SetMemoryLimit(10); 2483 2484 // Append 3 GOPs starting at 400ms, 30ms apart. 2485 NewSegmentAppend("400K 430 460 490K 520 550 580K 610 640"); 2486 2487 // Seek to the GOP at 580ms. 2488 SeekToTimestamp(base::TimeDelta::FromMilliseconds(580)); 2489 2490 // Append 2 GOPs starting at 220ms, and they will be merged with the existing 2491 // range. So the range before GC is "{ [220,670) }". 2492 NewSegmentAppend("220K 250 280 310K 340 370"); 2493 2494 // Should save the newly appended GOPs. 2495 CheckExpectedRangesByTimestamp("{ [220,400) [580,670) }"); 2496 } 2497 2498 TEST_F(SourceBufferStreamTest, GarbageCollection_NoSeek) { 2499 // Set memory limit to 20 buffers. 2500 SetMemoryLimit(20); 2501 2502 // Append 25 buffers at positions 0 through 24. 2503 NewSegmentAppend(0, 25, &kDataA); 2504 2505 // GC deletes the first 5 buffers to keep the memory limit within cap. 2506 CheckExpectedRanges("{ [5,24) }"); 2507 CheckNoNextBuffer(); 2508 Seek(5); 2509 CheckExpectedBuffers(5, 24, &kDataA); 2510 } 2511 2512 TEST_F(SourceBufferStreamTest, GarbageCollection_PendingSeek) { 2513 // Append 10 buffers at positions 0 through 9. 2514 NewSegmentAppend(0, 10, &kDataA); 2515 2516 // Append 5 buffers at positions 25 through 29. 2517 NewSegmentAppend(25, 5, &kDataA); 2518 2519 // Seek to position 15. 2520 Seek(15); 2521 CheckNoNextBuffer(); 2522 2523 CheckExpectedRanges("{ [0,9) [25,29) }"); 2524 2525 // Set memory limit to 5 buffers. 2526 SetMemoryLimit(5); 2527 2528 // Append 5 buffers as positions 30 to 34 to trigger GC. 2529 AppendBuffers(30, 5, &kDataA); 2530 2531 // The current algorithm will delete from the beginning until the memory is 2532 // under cap. 2533 CheckExpectedRanges("{ [30,34) }"); 2534 2535 // Expand memory limit again so that GC won't be triggered. 2536 SetMemoryLimit(100); 2537 2538 // Append data to fulfill seek. 2539 NewSegmentAppend(15, 5, &kDataA); 2540 2541 // Check to make sure all is well. 2542 CheckExpectedRanges("{ [15,19) [30,34) }"); 2543 CheckExpectedBuffers(15, 19, &kDataA); 2544 Seek(30); 2545 CheckExpectedBuffers(30, 34, &kDataA); 2546 } 2547 2548 TEST_F(SourceBufferStreamTest, GarbageCollection_NeedsMoreData) { 2549 // Set memory limit to 15 buffers. 2550 SetMemoryLimit(15); 2551 2552 // Append 10 buffers at positions 0 through 9. 2553 NewSegmentAppend(0, 10, &kDataA); 2554 2555 // Advance next buffer position to 10. 2556 Seek(0); 2557 CheckExpectedBuffers(0, 9, &kDataA); 2558 CheckNoNextBuffer(); 2559 2560 // Append 20 buffers at positions 15 through 34. 2561 NewSegmentAppend(15, 20, &kDataA); 2562 2563 // GC should have saved the keyframe before the current seek position and the 2564 // data closest to the current seek position. It will also save the last GOP 2565 // appended. 2566 CheckExpectedRanges("{ [5,9) [15,19) [30,34) }"); 2567 2568 // Now fulfill the seek at position 10. This will make GC delete the data 2569 // before position 10 to keep it within cap. 2570 NewSegmentAppend(10, 5, &kDataA); 2571 CheckExpectedRanges("{ [10,19) [30,34) }"); 2572 CheckExpectedBuffers(10, 19, &kDataA); 2573 } 2574 2575 TEST_F(SourceBufferStreamTest, GarbageCollection_TrackBuffer) { 2576 // Set memory limit to 3 buffers. 2577 SetMemoryLimit(3); 2578 2579 // Seek to position 15. 2580 Seek(15); 2581 2582 // Append 18 buffers at positions 0 through 17. 2583 NewSegmentAppend(0, 18, &kDataA); 2584 2585 // Should leave GOP containing seek position. 2586 CheckExpectedRanges("{ [15,17) }"); 2587 2588 // Seek ahead to position 16. 2589 CheckExpectedBuffers(15, 15, &kDataA); 2590 2591 // Completely overlap the existing buffers. 2592 NewSegmentAppend(0, 20, &kDataB); 2593 2594 // Because buffers 16 and 17 are not keyframes, they are moved to the track 2595 // buffer upon overlap. The source buffer (i.e. not the track buffer) is now 2596 // waiting for the next keyframe. 2597 CheckExpectedRanges("{ [15,19) }"); 2598 CheckExpectedBuffers(16, 17, &kDataA); 2599 CheckNoNextBuffer(); 2600 2601 // Now add a keyframe at position 20. 2602 AppendBuffers(20, 5, &kDataB); 2603 2604 // Should garbage collect such that there are 5 frames remaining, starting at 2605 // the keyframe. 2606 CheckExpectedRanges("{ [20,24) }"); 2607 CheckExpectedBuffers(20, 24, &kDataB); 2608 CheckNoNextBuffer(); 2609 } 2610 2611 // Test saving the last GOP appended when this GOP is the only GOP in its range. 2612 TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP) { 2613 // Set memory limit to 3 and make sure the 4-byte GOP is not garbage 2614 // collected. 2615 SetMemoryLimit(3); 2616 NewSegmentAppend("0K 30 60 90"); 2617 CheckExpectedRangesByTimestamp("{ [0,120) }"); 2618 2619 // Make sure you can continue appending data to this GOP; again, GC should not 2620 // wipe out anything. 2621 AppendBuffers("120D30"); 2622 CheckExpectedRangesByTimestamp("{ [0,150) }"); 2623 2624 // Set memory limit to 100 and append a 2nd range after this without 2625 // triggering GC. 2626 SetMemoryLimit(100); 2627 NewSegmentAppend("200K 230 260 290K 320 350"); 2628 CheckExpectedRangesByTimestamp("{ [0,150) [200,380) }"); 2629 2630 // Seek to 290ms. 2631 SeekToTimestamp(base::TimeDelta::FromMilliseconds(290)); 2632 2633 // Now set memory limit to 3 and append a GOP in a separate range after the 2634 // selected range. Because it is after 290ms, this tests that the GOP is saved 2635 // when deleting from the back. 2636 SetMemoryLimit(3); 2637 NewSegmentAppend("500K 530 560 590"); 2638 2639 // Should save GOP with 290ms and last GOP appended. 2640 CheckExpectedRangesByTimestamp("{ [290,380) [500,620) }"); 2641 2642 // Continue appending to this GOP after GC. 2643 AppendBuffers("620D30"); 2644 CheckExpectedRangesByTimestamp("{ [290,380) [500,650) }"); 2645 } 2646 2647 // Test saving the last GOP appended when this GOP is in the middle of a 2648 // non-selected range. 2649 TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Middle) { 2650 // Append 3 GOPs starting at 0ms, 30ms apart. 2651 NewSegmentAppend("0K 30 60 90K 120 150 180K 210 240"); 2652 CheckExpectedRangesByTimestamp("{ [0,270) }"); 2653 2654 // Now set the memory limit to 1 and overlap the middle of the range with a 2655 // new GOP. 2656 SetMemoryLimit(1); 2657 NewSegmentAppend("80K 110 140"); 2658 2659 // This whole GOP should be saved, and should be able to continue appending 2660 // data to it. 2661 CheckExpectedRangesByTimestamp("{ [80,170) }"); 2662 AppendBuffers("170D30"); 2663 CheckExpectedRangesByTimestamp("{ [80,200) }"); 2664 2665 // Set memory limit to 100 and append a 2nd range after this without 2666 // triggering GC. 2667 SetMemoryLimit(100); 2668 NewSegmentAppend("400K 430 460 490K 520 550 580K 610 640"); 2669 CheckExpectedRangesByTimestamp("{ [80,200) [400,670) }"); 2670 2671 // Seek to 80ms to make the first range the selected range. 2672 SeekToTimestamp(base::TimeDelta::FromMilliseconds(80)); 2673 2674 // Now set memory limit to 3 and append a GOP in the middle of the second 2675 // range. Because it is after the selected range, this tests that the GOP is 2676 // saved when deleting from the back. 2677 SetMemoryLimit(3); 2678 NewSegmentAppend("500K 530 560 590"); 2679 2680 // Should save the GOP containing the seek point and GOP that was last 2681 // appended. 2682 CheckExpectedRangesByTimestamp("{ [80,200) [500,620) }"); 2683 2684 // Continue appending to this GOP after GC. 2685 AppendBuffers("620D30"); 2686 CheckExpectedRangesByTimestamp("{ [80,200) [500,650) }"); 2687 } 2688 2689 // Test saving the last GOP appended when the GOP containing the next buffer is 2690 // adjacent to the last GOP appended. 2691 TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Selected1) { 2692 // Append 3 GOPs at 0ms, 90ms, and 180ms. 2693 NewSegmentAppend("0K 30 60 90K 120 150 180K 210 240"); 2694 CheckExpectedRangesByTimestamp("{ [0,270) }"); 2695 2696 // Seek to the GOP at 90ms. 2697 SeekToTimestamp(base::TimeDelta::FromMilliseconds(90)); 2698 2699 // Set the memory limit to 1, then overlap the GOP at 0. 2700 SetMemoryLimit(1); 2701 NewSegmentAppend("0K 30 60"); 2702 2703 // Should save the GOP at 0ms and 90ms. 2704 CheckExpectedRangesByTimestamp("{ [0,180) }"); 2705 2706 // Seek to 0 and check all buffers. 2707 SeekToTimestamp(base::TimeDelta::FromMilliseconds(0)); 2708 CheckExpectedBuffers("0K 30 60 90K 120 150"); 2709 CheckNoNextBuffer(); 2710 2711 // Now seek back to 90ms and append a GOP at 180ms. 2712 SeekToTimestamp(base::TimeDelta::FromMilliseconds(90)); 2713 NewSegmentAppend("180K 210 240"); 2714 2715 // Should save the GOP at 90ms and the GOP at 180ms. 2716 CheckExpectedRangesByTimestamp("{ [90,270) }"); 2717 CheckExpectedBuffers("90K 120 150 180K 210 240"); 2718 CheckNoNextBuffer(); 2719 } 2720 2721 // Test saving the last GOP appended when it is at the beginning or end of the 2722 // selected range. This tests when the last GOP appended is before or after the 2723 // GOP containing the next buffer, but not directly adjacent to this GOP. 2724 TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Selected2) { 2725 // Append 4 GOPs starting at positions 0ms, 90ms, 180ms, 270ms. 2726 NewSegmentAppend("0K 30 60 90K 120 150 180K 210 240 270K 300 330"); 2727 CheckExpectedRangesByTimestamp("{ [0,360) }"); 2728 2729 // Seek to the last GOP at 270ms. 2730 SeekToTimestamp(base::TimeDelta::FromMilliseconds(270)); 2731 2732 // Set the memory limit to 1, then overlap the GOP at 90ms. 2733 SetMemoryLimit(1); 2734 NewSegmentAppend("90K 120 150"); 2735 2736 // Should save the GOP at 90ms and the GOP at 270ms. 2737 CheckExpectedRangesByTimestamp("{ [90,180) [270,360) }"); 2738 2739 // Set memory limit to 100 and add 3 GOPs to the end of the selected range 2740 // at 360ms, 450ms, and 540ms. 2741 SetMemoryLimit(100); 2742 NewSegmentAppend("360K 390 420 450K 480 510 540K 570 600"); 2743 CheckExpectedRangesByTimestamp("{ [90,180) [270,630) }"); 2744 2745 // Constrain the memory limit again and overlap the GOP at 450ms to test 2746 // deleting from the back. 2747 SetMemoryLimit(1); 2748 NewSegmentAppend("450K 480 510"); 2749 2750 // Should save GOP at 270ms and the GOP at 450ms. 2751 CheckExpectedRangesByTimestamp("{ [270,360) [450,540) }"); 2752 } 2753 2754 // Test saving the last GOP appended when it is the same as the GOP containing 2755 // the next buffer. 2756 TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Selected3) { 2757 // Seek to start of stream. 2758 SeekToTimestamp(base::TimeDelta::FromMilliseconds(0)); 2759 2760 // Append 3 GOPs starting at 0ms, 90ms, 180ms. 2761 NewSegmentAppend("0K 30 60 90K 120 150 180K 210 240"); 2762 CheckExpectedRangesByTimestamp("{ [0,270) }"); 2763 2764 // Set the memory limit to 1 then begin appending the start of a GOP starting 2765 // at 0ms. 2766 SetMemoryLimit(1); 2767 NewSegmentAppend("0K 30"); 2768 2769 // Should save the newly appended GOP, which is also the next GOP that will be 2770 // returned from the seek request. 2771 CheckExpectedRangesByTimestamp("{ [0,60) }"); 2772 2773 // Check the buffers in the range. 2774 CheckExpectedBuffers("0K 30"); 2775 CheckNoNextBuffer(); 2776 2777 // Continue appending to this buffer. 2778 AppendBuffers("60 90"); 2779 2780 // Should still save the rest of this GOP and should be able to fulfill the 2781 // read. 2782 CheckExpectedRangesByTimestamp("{ [0,120) }"); 2783 CheckExpectedBuffers("60 90"); 2784 CheckNoNextBuffer(); 2785 } 2786 2787 // Currently disabled because of bug: crbug.com/140875. 2788 TEST_F(SourceBufferStreamTest, DISABLED_GarbageCollection_WaitingForKeyframe) { 2789 // Set memory limit to 10 buffers. 2790 SetMemoryLimit(10); 2791 2792 // Append 5 buffers at positions 10 through 14 and exhaust the buffers. 2793 NewSegmentAppend(10, 5, &kDataA); 2794 Seek(10); 2795 CheckExpectedBuffers(10, 14, &kDataA); 2796 CheckExpectedRanges("{ [10,14) }"); 2797 2798 // We are now stalled at position 15. 2799 CheckNoNextBuffer(); 2800 2801 // Do an end overlap that causes the latter half of the range to be deleted. 2802 NewSegmentAppend(5, 6, &kDataA); 2803 CheckNoNextBuffer(); 2804 CheckExpectedRanges("{ [5,10) }"); 2805 2806 // Append buffers from position 20 to 29. This should trigger GC. 2807 NewSegmentAppend(20, 10, &kDataA); 2808 2809 // GC should keep the keyframe before the seek position 15, and the next 9 2810 // buffers closest to the seek position. 2811 CheckNoNextBuffer(); 2812 CheckExpectedRanges("{ [10,10) [20,28) }"); 2813 2814 // Fulfill the seek by appending one buffer at 15. 2815 NewSegmentAppend(15, 1, &kDataA); 2816 CheckExpectedBuffers(15, 15, &kDataA); 2817 CheckExpectedRanges("{ [15,15) [20,28) }"); 2818 } 2819 2820 // Test the performance of garbage collection. 2821 TEST_F(SourceBufferStreamTest, GarbageCollection_Performance) { 2822 // Force |keyframes_per_second_| to be equal to kDefaultFramesPerSecond. 2823 SetStreamInfo(kDefaultFramesPerSecond, kDefaultFramesPerSecond); 2824 2825 const int kBuffersToKeep = 1000; 2826 SetMemoryLimit(kBuffersToKeep); 2827 2828 int buffers_appended = 0; 2829 2830 NewSegmentAppend(0, kBuffersToKeep); 2831 buffers_appended += kBuffersToKeep; 2832 2833 const int kBuffersToAppend = 1000; 2834 const int kGarbageCollections = 3; 2835 for (int i = 0; i < kGarbageCollections; ++i) { 2836 AppendBuffers(buffers_appended, kBuffersToAppend); 2837 buffers_appended += kBuffersToAppend; 2838 } 2839 } 2840 2841 TEST_F(SourceBufferStreamTest, GetRemovalRange_BytesToFree) { 2842 // Append 2 GOPs starting at 300ms, 30ms apart. 2843 NewSegmentAppend("300K 330 360 390K 420 450"); 2844 2845 // Append 2 GOPs starting at 600ms, 30ms apart. 2846 NewSegmentAppend("600K 630 660 690K 720 750"); 2847 2848 // Append 2 GOPs starting at 900ms, 30ms apart. 2849 NewSegmentAppend("900K 930 960 990K 1020 1050"); 2850 2851 CheckExpectedRangesByTimestamp("{ [300,480) [600,780) [900,1080) }"); 2852 2853 int remove_range_end = -1; 2854 int bytes_removed = -1; 2855 2856 // Size 0. 2857 bytes_removed = GetRemovalRangeInMs(300, 1080, 0, &remove_range_end); 2858 EXPECT_EQ(-1, remove_range_end); 2859 EXPECT_EQ(0, bytes_removed); 2860 2861 // Smaller than the size of GOP. 2862 bytes_removed = GetRemovalRangeInMs(300, 1080, 1, &remove_range_end); 2863 EXPECT_EQ(390, remove_range_end); 2864 // Remove as the size of GOP. 2865 EXPECT_EQ(3, bytes_removed); 2866 2867 // The same size with a GOP. 2868 bytes_removed = GetRemovalRangeInMs(300, 1080, 3, &remove_range_end); 2869 EXPECT_EQ(390, remove_range_end); 2870 EXPECT_EQ(3, bytes_removed); 2871 2872 // The same size with a range. 2873 bytes_removed = GetRemovalRangeInMs(300, 1080, 6, &remove_range_end); 2874 EXPECT_EQ(480, remove_range_end); 2875 EXPECT_EQ(6, bytes_removed); 2876 2877 // A frame larger than a range. 2878 bytes_removed = GetRemovalRangeInMs(300, 1080, 7, &remove_range_end); 2879 EXPECT_EQ(690, remove_range_end); 2880 EXPECT_EQ(9, bytes_removed); 2881 2882 // The same size with two ranges. 2883 bytes_removed = GetRemovalRangeInMs(300, 1080, 12, &remove_range_end); 2884 EXPECT_EQ(780, remove_range_end); 2885 EXPECT_EQ(12, bytes_removed); 2886 2887 // Larger than two ranges. 2888 bytes_removed = GetRemovalRangeInMs(300, 1080, 14, &remove_range_end); 2889 EXPECT_EQ(990, remove_range_end); 2890 EXPECT_EQ(15, bytes_removed); 2891 2892 // The same size with the whole ranges. 2893 bytes_removed = GetRemovalRangeInMs(300, 1080, 18, &remove_range_end); 2894 EXPECT_EQ(1080, remove_range_end); 2895 EXPECT_EQ(18, bytes_removed); 2896 2897 // Larger than the whole ranges. 2898 bytes_removed = GetRemovalRangeInMs(300, 1080, 20, &remove_range_end); 2899 EXPECT_EQ(1080, remove_range_end); 2900 EXPECT_EQ(18, bytes_removed); 2901 } 2902 2903 TEST_F(SourceBufferStreamTest, GetRemovalRange_Range) { 2904 // Append 2 GOPs starting at 300ms, 30ms apart. 2905 NewSegmentAppend("300K 330 360 390K 420 450"); 2906 2907 // Append 2 GOPs starting at 600ms, 30ms apart. 2908 NewSegmentAppend("600K 630 660 690K 720 750"); 2909 2910 // Append 2 GOPs starting at 900ms, 30ms apart. 2911 NewSegmentAppend("900K 930 960 990K 1020 1050"); 2912 2913 CheckExpectedRangesByTimestamp("{ [300,480) [600,780) [900,1080) }"); 2914 2915 int remove_range_end = -1; 2916 int bytes_removed = -1; 2917 2918 // Within a GOP and no keyframe. 2919 bytes_removed = GetRemovalRangeInMs(630, 660, 20, &remove_range_end); 2920 EXPECT_EQ(-1, remove_range_end); 2921 EXPECT_EQ(0, bytes_removed); 2922 2923 // Across a GOP and no keyframe. 2924 bytes_removed = GetRemovalRangeInMs(630, 750, 20, &remove_range_end); 2925 EXPECT_EQ(-1, remove_range_end); 2926 EXPECT_EQ(0, bytes_removed); 2927 2928 // The same size with a range. 2929 bytes_removed = GetRemovalRangeInMs(600, 780, 20, &remove_range_end); 2930 EXPECT_EQ(780, remove_range_end); 2931 EXPECT_EQ(6, bytes_removed); 2932 2933 // One frame larger than a range. 2934 bytes_removed = GetRemovalRangeInMs(570, 810, 20, &remove_range_end); 2935 EXPECT_EQ(780, remove_range_end); 2936 EXPECT_EQ(6, bytes_removed); 2937 2938 // Facing the other ranges. 2939 bytes_removed = GetRemovalRangeInMs(480, 900, 20, &remove_range_end); 2940 EXPECT_EQ(780, remove_range_end); 2941 EXPECT_EQ(6, bytes_removed); 2942 2943 // In the midle of the other ranges, but not including any GOP. 2944 bytes_removed = GetRemovalRangeInMs(420, 960, 20, &remove_range_end); 2945 EXPECT_EQ(780, remove_range_end); 2946 EXPECT_EQ(6, bytes_removed); 2947 2948 // In the middle of the other ranges. 2949 bytes_removed = GetRemovalRangeInMs(390, 990, 20, &remove_range_end); 2950 EXPECT_EQ(990, remove_range_end); 2951 EXPECT_EQ(12, bytes_removed); 2952 2953 // A frame smaller than the whole ranges. 2954 bytes_removed = GetRemovalRangeInMs(330, 1050, 20, &remove_range_end); 2955 EXPECT_EQ(990, remove_range_end); 2956 EXPECT_EQ(12, bytes_removed); 2957 2958 // The same with the whole ranges. 2959 bytes_removed = GetRemovalRangeInMs(300, 1080, 20, &remove_range_end); 2960 EXPECT_EQ(1080, remove_range_end); 2961 EXPECT_EQ(18, bytes_removed); 2962 2963 // Larger than the whole ranges. 2964 bytes_removed = GetRemovalRangeInMs(270, 1110, 20, &remove_range_end); 2965 EXPECT_EQ(1080, remove_range_end); 2966 EXPECT_EQ(18, bytes_removed); 2967 } 2968 2969 TEST_F(SourceBufferStreamTest, ConfigChange_Basic) { 2970 VideoDecoderConfig new_config = TestVideoConfig::Large(); 2971 ASSERT_FALSE(new_config.Matches(video_config_)); 2972 2973 Seek(0); 2974 CheckVideoConfig(video_config_); 2975 2976 // Append 5 buffers at positions 0 through 4 2977 NewSegmentAppend(0, 5, &kDataA); 2978 2979 CheckVideoConfig(video_config_); 2980 2981 // Signal a config change. 2982 stream_->UpdateVideoConfig(new_config); 2983 2984 // Make sure updating the config doesn't change anything since new_config 2985 // should not be associated with the buffer GetNextBuffer() will return. 2986 CheckVideoConfig(video_config_); 2987 2988 // Append 5 buffers at positions 5 through 9. 2989 NewSegmentAppend(5, 5, &kDataB); 2990 2991 // Consume the buffers associated with the initial config. 2992 scoped_refptr<StreamParserBuffer> buffer; 2993 for (int i = 0; i < 5; i++) { 2994 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kSuccess); 2995 CheckVideoConfig(video_config_); 2996 } 2997 2998 // Verify the next attempt to get a buffer will signal that a config change 2999 // has happened. 3000 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kConfigChange); 3001 3002 // Verify that the new config is now returned. 3003 CheckVideoConfig(new_config); 3004 3005 // Consume the remaining buffers associated with the new config. 3006 for (int i = 0; i < 5; i++) { 3007 CheckVideoConfig(new_config); 3008 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kSuccess); 3009 } 3010 } 3011 3012 TEST_F(SourceBufferStreamTest, ConfigChange_Seek) { 3013 scoped_refptr<StreamParserBuffer> buffer; 3014 VideoDecoderConfig new_config = TestVideoConfig::Large(); 3015 3016 Seek(0); 3017 NewSegmentAppend(0, 5, &kDataA); 3018 stream_->UpdateVideoConfig(new_config); 3019 NewSegmentAppend(5, 5, &kDataB); 3020 3021 // Seek to the start of the buffers with the new config and make sure a 3022 // config change is signalled. 3023 CheckVideoConfig(video_config_); 3024 Seek(5); 3025 CheckVideoConfig(video_config_); 3026 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kConfigChange); 3027 CheckVideoConfig(new_config); 3028 CheckExpectedBuffers(5, 9, &kDataB); 3029 3030 3031 // Seek to the start which has a different config. Don't fetch any buffers and 3032 // seek back to buffers with the current config. Make sure a config change 3033 // isn't signalled in this case. 3034 CheckVideoConfig(new_config); 3035 Seek(0); 3036 Seek(7); 3037 CheckExpectedBuffers(5, 9, &kDataB); 3038 3039 3040 // Seek to the start and make sure a config change is signalled. 3041 CheckVideoConfig(new_config); 3042 Seek(0); 3043 CheckVideoConfig(new_config); 3044 EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kConfigChange); 3045 CheckVideoConfig(video_config_); 3046 CheckExpectedBuffers(0, 4, &kDataA); 3047 } 3048 3049 TEST_F(SourceBufferStreamTest, SetExplicitDuration) { 3050 // Append 2 buffers at positions 5 through 6. 3051 NewSegmentAppend(5, 2); 3052 3053 // Append 2 buffers at positions 10 through 11. 3054 NewSegmentAppend(10, 2); 3055 3056 // Append 2 buffers at positions 15 through 16. 3057 NewSegmentAppend(15, 2); 3058 3059 // Check expected ranges. 3060 CheckExpectedRanges("{ [5,6) [10,11) [15,16) }"); 3061 3062 // Set duration to be between buffers 6 and 10. 3063 stream_->OnSetDuration(frame_duration() * 8); 3064 3065 // Should truncate the data after 6. 3066 CheckExpectedRanges("{ [5,6) }"); 3067 3068 // Adding data past the previous duration should still work. 3069 NewSegmentAppend(0, 20); 3070 CheckExpectedRanges("{ [0,19) }"); 3071 } 3072 3073 TEST_F(SourceBufferStreamTest, SetExplicitDuration_EdgeCase) { 3074 // Append 10 buffers at positions 10 through 19. 3075 NewSegmentAppend(10, 10); 3076 3077 // Append 5 buffers at positions 25 through 29. 3078 NewSegmentAppend(25, 5); 3079 3080 // Check expected ranges. 3081 CheckExpectedRanges("{ [10,19) [25,29) }"); 3082 3083 // Set duration to be right before buffer 25. 3084 stream_->OnSetDuration(frame_duration() * 25); 3085 3086 // Should truncate the last range. 3087 CheckExpectedRanges("{ [10,19) }"); 3088 } 3089 3090 TEST_F(SourceBufferStreamTest, SetExplicitDuration_DeletePartialRange) { 3091 // Append 5 buffers at positions 0 through 4. 3092 NewSegmentAppend(0, 5); 3093 3094 // Append 10 buffers at positions 10 through 19. 3095 NewSegmentAppend(10, 10); 3096 3097 // Append 5 buffers at positions 25 through 29. 3098 NewSegmentAppend(25, 5); 3099 3100 // Check expected ranges. 3101 CheckExpectedRanges("{ [0,4) [10,19) [25,29) }"); 3102 3103 // Set duration to be between buffers 13 and 14. 3104 stream_->OnSetDuration(frame_duration() * 14); 3105 3106 // Should truncate the data after 13. 3107 CheckExpectedRanges("{ [0,4) [10,13) }"); 3108 } 3109 3110 TEST_F(SourceBufferStreamTest, SetExplicitDuration_DeleteSelectedRange) { 3111 // Append 2 buffers at positions 5 through 6. 3112 NewSegmentAppend(5, 2); 3113 3114 // Append 2 buffers at positions 10 through 11. 3115 NewSegmentAppend(10, 2); 3116 3117 // Append 2 buffers at positions 15 through 16. 3118 NewSegmentAppend(15, 2); 3119 3120 // Check expected ranges. 3121 CheckExpectedRanges("{ [5,6) [10,11) [15,16) }"); 3122 3123 // Seek to 10. 3124 Seek(10); 3125 3126 // Set duration to be after position 3. 3127 stream_->OnSetDuration(frame_duration() * 4); 3128 3129 // Expect everything to be deleted, and should not have next buffer anymore. 3130 CheckNoNextBuffer(); 3131 CheckExpectedRanges("{ }"); 3132 3133 // Appending data at position 10 should not fulfill the seek. 3134 // (If the duration is set to be something smaller than the current seek 3135 // point, then the seek point is reset and the SourceBufferStream waits 3136 // for a new seek request. Therefore even if the data is re-appended, it 3137 // should not fulfill the old seek.) 3138 NewSegmentAppend(0, 15); 3139 CheckNoNextBuffer(); 3140 CheckExpectedRanges("{ [0,14) }"); 3141 } 3142 3143 TEST_F(SourceBufferStreamTest, SetExplicitDuration_DeletePartialSelectedRange) { 3144 // Append 5 buffers at positions 0 through 4. 3145 NewSegmentAppend(0, 5); 3146 3147 // Append 20 buffers at positions 10 through 29. 3148 NewSegmentAppend(10, 20); 3149 3150 // Check expected ranges. 3151 CheckExpectedRanges("{ [0,4) [10,29) }"); 3152 3153 // Seek to position 10. 3154 Seek(10); 3155 3156 // Set duration to be between buffers 24 and 25. 3157 stream_->OnSetDuration(frame_duration() * 25); 3158 3159 // Should truncate the data after 24. 3160 CheckExpectedRanges("{ [0,4) [10,24) }"); 3161 3162 // The seek position should not be lost. 3163 CheckExpectedBuffers(10, 10); 3164 3165 // Now set the duration immediately after buffer 10. 3166 stream_->OnSetDuration(frame_duration() * 11); 3167 3168 // Seek position should be reset. 3169 CheckNoNextBuffer(); 3170 CheckExpectedRanges("{ [0,4) [10,10) }"); 3171 } 3172 3173 // Test the case where duration is set while the stream parser buffers 3174 // already start passing the data to decoding pipeline. Selected range, 3175 // when invalidated by getting truncated, should be updated to NULL 3176 // accordingly so that successive append operations keep working. 3177 TEST_F(SourceBufferStreamTest, SetExplicitDuration_UpdateSelectedRange) { 3178 // Seek to start of stream. 3179 SeekToTimestamp(base::TimeDelta::FromMilliseconds(0)); 3180 3181 NewSegmentAppend("0K 30 60 90"); 3182 3183 // Read out the first few buffers. 3184 CheckExpectedBuffers("0K 30"); 3185 3186 // Set duration to be right before buffer 1. 3187 stream_->OnSetDuration(base::TimeDelta::FromMilliseconds(60)); 3188 3189 // Verify that there is no next buffer. 3190 CheckNoNextBuffer(); 3191 3192 // We should be able to append new buffers at this point. 3193 NewSegmentAppend("120K 150"); 3194 3195 CheckExpectedRangesByTimestamp("{ [0,60) [120,180) }"); 3196 } 3197 3198 TEST_F(SourceBufferStreamTest, 3199 SetExplicitDuration_AfterSegmentTimestampAndBeforeFirstBufferTimestamp) { 3200 3201 NewSegmentAppend("0K 30K 60K"); 3202 3203 // Append a segment with a start timestamp of 200, but the first 3204 // buffer starts at 230ms. This can happen in muxed content where the 3205 // audio starts before the first frame. 3206 NewSegmentAppend(base::TimeDelta::FromMilliseconds(200), 3207 "230K 260K 290K 320K"); 3208 3209 NewSegmentAppend("400K 430K 460K"); 3210 3211 CheckExpectedRangesByTimestamp("{ [0,90) [200,350) [400,490) }"); 3212 3213 stream_->OnSetDuration(base::TimeDelta::FromMilliseconds(120)); 3214 3215 // Verify that the buffered ranges are updated properly and we don't crash. 3216 CheckExpectedRangesByTimestamp("{ [0,90) }"); 3217 } 3218 3219 // Test the case were the current playback position is at the end of the 3220 // buffered data and several overlaps occur that causes the selected 3221 // range to get split and then merged back into a single range. 3222 TEST_F(SourceBufferStreamTest, OverlapSplitAndMergeWhileWaitingForMoreData) { 3223 // Seek to start of stream. 3224 SeekToTimestamp(base::TimeDelta::FromMilliseconds(0)); 3225 3226 NewSegmentAppend("0K 30 60 90 120K 150"); 3227 CheckExpectedRangesByTimestamp("{ [0,180) }"); 3228 3229 // Read all the buffered data. 3230 CheckExpectedBuffers("0K 30 60 90 120K 150"); 3231 CheckNoNextBuffer(); 3232 3233 // Append data over the current GOP so that a keyframe is needed before 3234 // playback can continue from the current position. 3235 NewSegmentAppend("120K 150"); 3236 CheckExpectedRangesByTimestamp("{ [0,180) }"); 3237 3238 // Append buffers that cause the range to get split. 3239 NewSegmentAppend("0K 30"); 3240 CheckExpectedRangesByTimestamp("{ [0,60) [120,180) }"); 3241 3242 // Append buffers that cause the ranges to get merged. 3243 AppendBuffers("60 90"); 3244 3245 CheckExpectedRangesByTimestamp("{ [0,180) }"); 3246 3247 // Verify that we still don't have a next buffer. 3248 CheckNoNextBuffer(); 3249 3250 // Add more data to the end and verify that this new data is read correctly. 3251 NewSegmentAppend("180K 210"); 3252 CheckExpectedRangesByTimestamp("{ [0,240) }"); 3253 CheckExpectedBuffers("180K 210"); 3254 } 3255 3256 // Verify that non-keyframes with the same timestamp in the same 3257 // append are handled correctly. 3258 TEST_F(SourceBufferStreamTest, SameTimestamp_Video_SingleAppend) { 3259 Seek(0); 3260 NewSegmentAppend("0K 30 30 60 90 120K 150"); 3261 CheckExpectedBuffers("0K 30 30 60 90 120K 150"); 3262 } 3263 3264 // Verify that non-keyframes with the same timestamp can occur 3265 // in different appends. 3266 TEST_F(SourceBufferStreamTest, SameTimestamp_Video_TwoAppends) { 3267 Seek(0); 3268 NewSegmentAppend("0K 30"); 3269 AppendBuffers("30 60 90 120K 150"); 3270 CheckExpectedBuffers("0K 30 30 60 90 120K 150"); 3271 } 3272 3273 // Verify that a non-keyframe followed by a keyframe with the same timestamp 3274 // is not allowed. 3275 TEST_F(SourceBufferStreamTest, SameTimestamp_Video_Invalid_1) { 3276 Seek(0); 3277 NewSegmentAppend("0K 30"); 3278 AppendBuffers_ExpectFailure("30K 60"); 3279 } 3280 3281 TEST_F(SourceBufferStreamTest, SameTimestamp_Video_Invalid_2) { 3282 Seek(0); 3283 NewSegmentAppend_ExpectFailure("0K 30 30K 60"); 3284 } 3285 3286 // Verify that a keyframe followed by a non-keyframe with the same timestamp 3287 // is allowed. 3288 TEST_F(SourceBufferStreamTest, SameTimestamp_VideoKeyFrame_TwoAppends) { 3289 Seek(0); 3290 NewSegmentAppend("0K 30K"); 3291 AppendBuffers("30 60"); 3292 CheckExpectedBuffers("0K 30K 30 60"); 3293 } 3294 3295 TEST_F(SourceBufferStreamTest, SameTimestamp_VideoKeyFrame_SingleAppend) { 3296 Seek(0); 3297 NewSegmentAppend("0K 30K 30 60"); 3298 CheckExpectedBuffers("0K 30K 30 60"); 3299 } 3300 3301 TEST_F(SourceBufferStreamTest, SameTimestamp_Video_Overlap_1) { 3302 Seek(0); 3303 NewSegmentAppend("0K 30 60 60 90 120K 150"); 3304 3305 NewSegmentAppend("60K 91 121K 151"); 3306 CheckExpectedBuffers("0K 30 60K 91 121K 151"); 3307 } 3308 3309 TEST_F(SourceBufferStreamTest, SameTimestamp_Video_Overlap_2) { 3310 Seek(0); 3311 NewSegmentAppend("0K 30 60 60 90 120K 150"); 3312 NewSegmentAppend("0K 30 61"); 3313 CheckExpectedBuffers("0K 30 61 120K 150"); 3314 } 3315 3316 TEST_F(SourceBufferStreamTest, SameTimestamp_Video_Overlap_3) { 3317 Seek(0); 3318 NewSegmentAppend("0K 20 40 60 80 100K 101 102 103K"); 3319 NewSegmentAppend("0K 20 40 60 80 90"); 3320 CheckExpectedBuffers("0K 20 40 60 80 90 100K 101 102 103K"); 3321 AppendBuffers("90 110K 150"); 3322 Seek(0); 3323 CheckExpectedBuffers("0K 20 40 60 80 90 90 110K 150"); 3324 CheckNoNextBuffer(); 3325 CheckExpectedRangesByTimestamp("{ [0,190) }"); 3326 } 3327 3328 // Test all the valid same timestamp cases for audio. 3329 TEST_F(SourceBufferStreamTest, SameTimestamp_Audio) { 3330 AudioDecoderConfig config(kCodecMP3, kSampleFormatF32, CHANNEL_LAYOUT_STEREO, 3331 44100, NULL, 0, false); 3332 stream_.reset(new SourceBufferStream(config, log_cb(), true)); 3333 Seek(0); 3334 NewSegmentAppend("0K 0K 30K 30 60 60"); 3335 CheckExpectedBuffers("0K 0K 30K 30 60 60"); 3336 } 3337 3338 TEST_F(SourceBufferStreamTest, SameTimestamp_Audio_Invalid_1) { 3339 AudioDecoderConfig config(kCodecMP3, kSampleFormatF32, CHANNEL_LAYOUT_STEREO, 3340 44100, NULL, 0, false); 3341 stream_.reset(new SourceBufferStream(config, log_cb(), true)); 3342 Seek(0); 3343 NewSegmentAppend_ExpectFailure("0K 30 30K 60"); 3344 } 3345 3346 // If seeking past any existing range and the seek is pending 3347 // because no data has been provided for that position, 3348 // the stream position can be considered as the end of stream. 3349 TEST_F(SourceBufferStreamTest, EndSelected_During_PendingSeek) { 3350 // Append 15 buffers at positions 0 through 14. 3351 NewSegmentAppend(0, 15); 3352 3353 Seek(20); 3354 EXPECT_TRUE(stream_->IsSeekPending()); 3355 stream_->MarkEndOfStream(); 3356 EXPECT_FALSE(stream_->IsSeekPending()); 3357 } 3358 3359 // If there is a pending seek between 2 existing ranges, 3360 // the end of the stream has not been reached. 3361 TEST_F(SourceBufferStreamTest, EndNotSelected_During_PendingSeek) { 3362 // Append: 3363 // - 10 buffers at positions 0 through 9. 3364 // - 10 buffers at positions 30 through 39 3365 NewSegmentAppend(0, 10); 3366 NewSegmentAppend(30, 10); 3367 3368 Seek(20); 3369 EXPECT_TRUE(stream_->IsSeekPending()); 3370 stream_->MarkEndOfStream(); 3371 EXPECT_TRUE(stream_->IsSeekPending()); 3372 } 3373 3374 3375 // Removing exact start & end of a range. 3376 TEST_F(SourceBufferStreamTest, Remove_WholeRange1) { 3377 Seek(0); 3378 NewSegmentAppend("10K 40 70K 100 130K"); 3379 CheckExpectedRangesByTimestamp("{ [10,160) }"); 3380 RemoveInMs(10, 160, 160); 3381 CheckExpectedRangesByTimestamp("{ }"); 3382 } 3383 3384 // Removal range starts before range and ends exactly at end. 3385 TEST_F(SourceBufferStreamTest, Remove_WholeRange2) { 3386 Seek(0); 3387 NewSegmentAppend("10K 40 70K 100 130K"); 3388 CheckExpectedRangesByTimestamp("{ [10,160) }"); 3389 RemoveInMs(0, 160, 160); 3390 CheckExpectedRangesByTimestamp("{ }"); 3391 } 3392 3393 // Removal range starts at the start of a range and ends beyond the 3394 // range end. 3395 TEST_F(SourceBufferStreamTest, Remove_WholeRange3) { 3396 Seek(0); 3397 NewSegmentAppend("10K 40 70K 100 130K"); 3398 CheckExpectedRangesByTimestamp("{ [10,160) }"); 3399 RemoveInMs(10, 200, 200); 3400 CheckExpectedRangesByTimestamp("{ }"); 3401 } 3402 3403 // Removal range starts before range start and ends after the range end. 3404 TEST_F(SourceBufferStreamTest, Remove_WholeRange4) { 3405 Seek(0); 3406 NewSegmentAppend("10K 40 70K 100 130K"); 3407 CheckExpectedRangesByTimestamp("{ [10,160) }"); 3408 RemoveInMs(0, 200, 200); 3409 CheckExpectedRangesByTimestamp("{ }"); 3410 } 3411 3412 // Removes multiple ranges. 3413 TEST_F(SourceBufferStreamTest, Remove_WholeRange5) { 3414 Seek(0); 3415 NewSegmentAppend("10K 40 70K 100 130K"); 3416 NewSegmentAppend("1000K 1030 1060K 1090 1120K"); 3417 NewSegmentAppend("2000K 2030 2060K 2090 2120K"); 3418 CheckExpectedRangesByTimestamp("{ [10,160) [1000,1150) [2000,2150) }"); 3419 RemoveInMs(10, 3000, 3000); 3420 CheckExpectedRangesByTimestamp("{ }"); 3421 } 3422 3423 // Verifies a [0-infinity) range removes everything. 3424 TEST_F(SourceBufferStreamTest, Remove_ZeroToInfinity) { 3425 Seek(0); 3426 NewSegmentAppend("10K 40 70K 100 130K"); 3427 NewSegmentAppend("1000K 1030 1060K 1090 1120K"); 3428 NewSegmentAppend("2000K 2030 2060K 2090 2120K"); 3429 CheckExpectedRangesByTimestamp("{ [10,160) [1000,1150) [2000,2150) }"); 3430 Remove(base::TimeDelta(), kInfiniteDuration(), kInfiniteDuration()); 3431 CheckExpectedRangesByTimestamp("{ }"); 3432 } 3433 3434 // Removal range starts at the beginning of the range and ends in the 3435 // middle of the range. This test verifies that full GOPs are removed. 3436 TEST_F(SourceBufferStreamTest, Remove_Partial1) { 3437 Seek(0); 3438 NewSegmentAppend("10K 40 70K 100 130K"); 3439 NewSegmentAppend("1000K 1030 1060K 1090 1120K"); 3440 CheckExpectedRangesByTimestamp("{ [10,160) [1000,1150) }"); 3441 RemoveInMs(0, 80, 2200); 3442 CheckExpectedRangesByTimestamp("{ [130,160) [1000,1150) }"); 3443 } 3444 3445 // Removal range starts in the middle of a range and ends at the exact 3446 // end of the range. 3447 TEST_F(SourceBufferStreamTest, Remove_Partial2) { 3448 Seek(0); 3449 NewSegmentAppend("10K 40 70K 100 130K"); 3450 NewSegmentAppend("1000K 1030 1060K 1090 1120K"); 3451 CheckExpectedRangesByTimestamp("{ [10,160) [1000,1150) }"); 3452 RemoveInMs(40, 160, 2200); 3453 CheckExpectedRangesByTimestamp("{ [10,40) [1000,1150) }"); 3454 } 3455 3456 // Removal range starts and ends within a range. 3457 TEST_F(SourceBufferStreamTest, Remove_Partial3) { 3458 Seek(0); 3459 NewSegmentAppend("10K 40 70K 100 130K"); 3460 NewSegmentAppend("1000K 1030 1060K 1090 1120K"); 3461 CheckExpectedRangesByTimestamp("{ [10,160) [1000,1150) }"); 3462 RemoveInMs(40, 120, 2200); 3463 CheckExpectedRangesByTimestamp("{ [10,40) [130,160) [1000,1150) }"); 3464 } 3465 3466 // Removal range starts in the middle of one range and ends in the 3467 // middle of another range. 3468 TEST_F(SourceBufferStreamTest, Remove_Partial4) { 3469 Seek(0); 3470 NewSegmentAppend("10K 40 70K 100 130K"); 3471 NewSegmentAppend("1000K 1030 1060K 1090 1120K"); 3472 NewSegmentAppend("2000K 2030 2060K 2090 2120K"); 3473 CheckExpectedRangesByTimestamp("{ [10,160) [1000,1150) [2000,2150) }"); 3474 RemoveInMs(40, 2030, 2200); 3475 CheckExpectedRangesByTimestamp("{ [10,40) [2060,2150) }"); 3476 } 3477 3478 // Test behavior when the current position is removed and new buffers 3479 // are appended over the removal range. 3480 TEST_F(SourceBufferStreamTest, Remove_CurrentPosition) { 3481 Seek(0); 3482 NewSegmentAppend("0K 30 60 90K 120 150 180K 210 240 270K 300 330"); 3483 CheckExpectedRangesByTimestamp("{ [0,360) }"); 3484 CheckExpectedBuffers("0K 30 60 90K 120"); 3485 3486 // Remove a range that includes the next buffer (i.e., 150). 3487 RemoveInMs(150, 210, 360); 3488 CheckExpectedRangesByTimestamp("{ [0,150) [270,360) }"); 3489 3490 // Verify that no next buffer is returned. 3491 CheckNoNextBuffer(); 3492 3493 // Append some buffers to fill the gap that was created. 3494 NewSegmentAppend("120K 150 180 210K 240"); 3495 CheckExpectedRangesByTimestamp("{ [0,360) }"); 3496 3497 // Verify that buffers resume at the next keyframe after the 3498 // current position. 3499 CheckExpectedBuffers("210K 240 270K 300 330"); 3500 } 3501 3502 // Test behavior when buffers in the selected range before the current position 3503 // are removed. 3504 TEST_F(SourceBufferStreamTest, Remove_BeforeCurrentPosition) { 3505 Seek(0); 3506 NewSegmentAppend("0K 30 60 90K 120 150 180K 210 240 270K 300 330"); 3507 CheckExpectedRangesByTimestamp("{ [0,360) }"); 3508 CheckExpectedBuffers("0K 30 60 90K 120"); 3509 3510 // Remove a range that is before the current playback position. 3511 RemoveInMs(0, 90, 360); 3512 CheckExpectedRangesByTimestamp("{ [90,360) }"); 3513 3514 CheckExpectedBuffers("150 180K 210 240 270K 300 330"); 3515 } 3516 3517 // Test removing the entire range for the current media segment 3518 // being appended. 3519 TEST_F(SourceBufferStreamTest, Remove_MidSegment) { 3520 Seek(0); 3521 NewSegmentAppend("0K 30 60 90 120K 150 180 210"); 3522 CheckExpectedRangesByTimestamp("{ [0,240) }"); 3523 3524 NewSegmentAppend("0K 30"); 3525 3526 CheckExpectedBuffers("0K"); 3527 3528 CheckExpectedRangesByTimestamp("{ [0,60) [120,240) }"); 3529 3530 // Remove the entire range that is being appended to. 3531 RemoveInMs(0, 60, 240); 3532 3533 // Verify that there is no next buffer since it was removed. 3534 CheckNoNextBuffer(); 3535 3536 CheckExpectedRangesByTimestamp("{ [120,240) }"); 3537 3538 // Continue appending frames for the current GOP. 3539 AppendBuffers("60 90"); 3540 3541 // Verify that the non-keyframes are not added. 3542 CheckExpectedRangesByTimestamp("{ [120,240) }"); 3543 3544 // Finish the previous GOP and start the next one. 3545 AppendBuffers("120 150K 180"); 3546 3547 // Verify that new GOP replaces the existing range. 3548 CheckExpectedRangesByTimestamp("{ [150,210) }"); 3549 3550 3551 SeekToTimestamp(base::TimeDelta::FromMilliseconds(150)); 3552 CheckExpectedBuffers("150K 180"); 3553 CheckNoNextBuffer(); 3554 } 3555 3556 // Test removing the current GOP being appended, while not removing 3557 // the entire range the GOP belongs to. 3558 TEST_F(SourceBufferStreamTest, Remove_GOPBeingAppended) { 3559 Seek(0); 3560 NewSegmentAppend("0K 30 60 90 120K 150 180"); 3561 CheckExpectedRangesByTimestamp("{ [0,210) }"); 3562 3563 // Remove the current GOP being appended. 3564 RemoveInMs(120, 150, 240); 3565 CheckExpectedRangesByTimestamp("{ [0,120) }"); 3566 3567 // Continue appending the current GOP and the next one. 3568 AppendBuffers("210 240K 270 300"); 3569 3570 // Verify that the non-keyframe in the previous GOP does 3571 // not effect any existing ranges and a new range is started at the 3572 // beginning of the next GOP. 3573 CheckExpectedRangesByTimestamp("{ [0,120) [240,330) }"); 3574 3575 // Verify the buffers in the ranges. 3576 CheckExpectedBuffers("0K 30 60 90"); 3577 CheckNoNextBuffer(); 3578 SeekToTimestamp(base::TimeDelta::FromMilliseconds(240)); 3579 CheckExpectedBuffers("240K 270 300"); 3580 } 3581 3582 TEST_F(SourceBufferStreamTest, Remove_WholeGOPBeingAppended) { 3583 Seek(0); 3584 NewSegmentAppend("0K 30 60 90"); 3585 CheckExpectedRangesByTimestamp("{ [0,120) }"); 3586 3587 // Remove the keyframe of the current GOP being appended. 3588 RemoveInMs(0, 30, 120); 3589 CheckExpectedRangesByTimestamp("{ }"); 3590 3591 // Continue appending the current GOP. 3592 AppendBuffers("210 240"); 3593 3594 CheckExpectedRangesByTimestamp("{ }"); 3595 3596 // Append the beginning of the next GOP. 3597 AppendBuffers("270K 300"); 3598 3599 // Verify that the new range is started at the 3600 // beginning of the next GOP. 3601 CheckExpectedRangesByTimestamp("{ [270,330) }"); 3602 3603 // Verify the buffers in the ranges. 3604 CheckNoNextBuffer(); 3605 SeekToTimestamp(base::TimeDelta::FromMilliseconds(270)); 3606 CheckExpectedBuffers("270K 300"); 3607 } 3608 3609 TEST_F(SourceBufferStreamTest, 3610 Remove_PreviousAppendDestroyedAndOverwriteExistingRange) { 3611 SeekToTimestamp(base::TimeDelta::FromMilliseconds(90)); 3612 3613 NewSegmentAppend("90K 120 150"); 3614 CheckExpectedRangesByTimestamp("{ [90,180) }"); 3615 3616 // Append a segment before the previously appended data. 3617 NewSegmentAppend("0K 30 60"); 3618 3619 // Verify that the ranges get merged. 3620 CheckExpectedRangesByTimestamp("{ [0,180) }"); 3621 3622 // Remove the data from the last append. 3623 RemoveInMs(0, 90, 360); 3624 CheckExpectedRangesByTimestamp("{ [90,180) }"); 3625 3626 // Append a new segment that follows the removed segment and 3627 // starts at the beginning of the range left over from the 3628 // remove. 3629 NewSegmentAppend("90K 121 151"); 3630 CheckExpectedBuffers("90K 121 151"); 3631 } 3632 3633 TEST_F(SourceBufferStreamTest, Remove_GapAtBeginningOfMediaSegment) { 3634 Seek(0); 3635 3636 // Append a media segment that has a gap at the beginning of it. 3637 NewSegmentAppend(base::TimeDelta::FromMilliseconds(0), 3638 "30K 60 90 120K 150"); 3639 CheckExpectedRangesByTimestamp("{ [0,180) }"); 3640 3641 // Remove the gap that doesn't contain any buffers. 3642 RemoveInMs(0, 10, 180); 3643 CheckExpectedRangesByTimestamp("{ [10,180) }"); 3644 3645 // Verify we still get the first buffer still since only part of 3646 // the gap was removed. 3647 // TODO(acolwell/wolenetz): Consider not returning a buffer at this 3648 // point since the current seek position has been explicitly 3649 // removed but didn't happen to remove any buffers. 3650 // http://crbug.com/384016 3651 CheckExpectedBuffers("30K"); 3652 3653 // Remove a range that includes the first GOP. 3654 RemoveInMs(0, 60, 180); 3655 3656 // Verify that no buffer is returned because the current buffer 3657 // position has been removed. 3658 CheckNoNextBuffer(); 3659 3660 CheckExpectedRangesByTimestamp("{ [120,180) }"); 3661 } 3662 3663 TEST_F(SourceBufferStreamTest, Text_Append_SingleRange) { 3664 SetTextStream(); 3665 NewSegmentAppend("0K 500K 1000K"); 3666 CheckExpectedRangesByTimestamp("{ [0,1500) }"); 3667 3668 Seek(0); 3669 CheckExpectedBuffers("0K 500K 1000K"); 3670 } 3671 3672 TEST_F(SourceBufferStreamTest, Text_Append_DisjointAfter) { 3673 SetTextStream(); 3674 NewSegmentAppend("0K 500K 1000K"); 3675 CheckExpectedRangesByTimestamp("{ [0,1500) }"); 3676 NewSegmentAppend("3000K 3500K 4000K"); 3677 CheckExpectedRangesByTimestamp("{ [0,4500) }"); 3678 3679 Seek(0); 3680 CheckExpectedBuffers("0K 500K 1000K 3000K 3500K 4000K"); 3681 } 3682 3683 TEST_F(SourceBufferStreamTest, Text_Append_DisjointBefore) { 3684 SetTextStream(); 3685 NewSegmentAppend("3000K 3500K 4000K"); 3686 CheckExpectedRangesByTimestamp("{ [3000,4500) }"); 3687 NewSegmentAppend("0K 500K 1000K"); 3688 CheckExpectedRangesByTimestamp("{ [0,4500) }"); 3689 3690 Seek(0); 3691 CheckExpectedBuffers("0K 500K 1000K 3000K 3500K 4000K"); 3692 } 3693 3694 TEST_F(SourceBufferStreamTest, Text_CompleteOverlap) { 3695 SetTextStream(); 3696 NewSegmentAppend("3000K 3500K 4000K"); 3697 CheckExpectedRangesByTimestamp("{ [3000,4500) }"); 3698 NewSegmentAppend("0K 501K 1001K 1501K 2001K 2501K " 3699 "3001K 3501K 4001K 4501K 5001K"); 3700 CheckExpectedRangesByTimestamp("{ [0,5501) }"); 3701 3702 Seek(0); 3703 CheckExpectedBuffers("0K 501K 1001K 1501K 2001K 2501K " 3704 "3001K 3501K 4001K 4501K 5001K"); 3705 } 3706 3707 TEST_F(SourceBufferStreamTest, Text_OverlapAfter) { 3708 SetTextStream(); 3709 NewSegmentAppend("0K 500K 1000K 1500K 2000K"); 3710 CheckExpectedRangesByTimestamp("{ [0,2500) }"); 3711 NewSegmentAppend("1499K 2001K 2501K 3001K"); 3712 CheckExpectedRangesByTimestamp("{ [0,3501) }"); 3713 3714 Seek(0); 3715 CheckExpectedBuffers("0K 500K 1000K 1499K 2001K 2501K 3001K"); 3716 } 3717 3718 TEST_F(SourceBufferStreamTest, Text_OverlapBefore) { 3719 SetTextStream(); 3720 NewSegmentAppend("1500K 2000K 2500K 3000K 3500K"); 3721 CheckExpectedRangesByTimestamp("{ [1500,4000) }"); 3722 NewSegmentAppend("0K 501K 1001K 1501K 2001K"); 3723 CheckExpectedRangesByTimestamp("{ [0,4000) }"); 3724 3725 Seek(0); 3726 CheckExpectedBuffers("0K 501K 1001K 1501K 2001K 3000K 3500K"); 3727 } 3728 3729 TEST_F(SourceBufferStreamTest, SpliceFrame_Basic) { 3730 Seek(0); 3731 NewSegmentAppend("0K S(3K 6 9D3 10D5) 15 20 S(25K 30D5 35D5) 40"); 3732 CheckExpectedBuffers("0K 3K 6 9 C 10 15 20 25K 30 C 35 40"); 3733 CheckNoNextBuffer(); 3734 } 3735 3736 TEST_F(SourceBufferStreamTest, SpliceFrame_SeekClearsSplice) { 3737 Seek(0); 3738 NewSegmentAppend("0K S(3K 6 9D3 10D5) 15K 20"); 3739 CheckExpectedBuffers("0K 3K 6"); 3740 3741 SeekToTimestamp(base::TimeDelta::FromMilliseconds(15)); 3742 CheckExpectedBuffers("15K 20"); 3743 CheckNoNextBuffer(); 3744 } 3745 3746 TEST_F(SourceBufferStreamTest, SpliceFrame_SeekClearsSpliceFromTrackBuffer) { 3747 Seek(0); 3748 NewSegmentAppend("0K 2K S(3K 6 9D3 10D5) 15K 20"); 3749 CheckExpectedBuffers("0K 2K"); 3750 3751 // Overlap the existing segment. 3752 NewSegmentAppend("5K 15K 20"); 3753 CheckExpectedBuffers("3K 6"); 3754 3755 SeekToTimestamp(base::TimeDelta::FromMilliseconds(15)); 3756 CheckExpectedBuffers("15K 20"); 3757 CheckNoNextBuffer(); 3758 } 3759 3760 TEST_F(SourceBufferStreamTest, SpliceFrame_ConfigChangeWithinSplice) { 3761 VideoDecoderConfig new_config = TestVideoConfig::Large(); 3762 ASSERT_FALSE(new_config.Matches(video_config_)); 3763 3764 // Add a new video config, then reset the config index back to the original. 3765 stream_->UpdateVideoConfig(new_config); 3766 stream_->UpdateVideoConfig(video_config_); 3767 3768 Seek(0); 3769 CheckVideoConfig(video_config_); 3770 NewSegmentAppend("0K S(3K 6C 9D3 10D5) 15"); 3771 3772 CheckExpectedBuffers("0K 3K C"); 3773 CheckVideoConfig(new_config); 3774 CheckExpectedBuffers("6 9 C"); 3775 CheckExpectedBuffers("10 C"); 3776 CheckVideoConfig(video_config_); 3777 CheckExpectedBuffers("15"); 3778 CheckNoNextBuffer(); 3779 } 3780 3781 TEST_F(SourceBufferStreamTest, SpliceFrame_BasicFromTrackBuffer) { 3782 Seek(0); 3783 NewSegmentAppend("0K 5K S(8K 9D1 10D10) 20"); 3784 CheckExpectedBuffers("0K 5K"); 3785 3786 // Overlap the existing segment. 3787 NewSegmentAppend("5K 20"); 3788 CheckExpectedBuffers("8K 9 C 10 20"); 3789 CheckNoNextBuffer(); 3790 } 3791 3792 TEST_F(SourceBufferStreamTest, 3793 SpliceFrame_ConfigChangeWithinSpliceFromTrackBuffer) { 3794 VideoDecoderConfig new_config = TestVideoConfig::Large(); 3795 ASSERT_FALSE(new_config.Matches(video_config_)); 3796 3797 // Add a new video config, then reset the config index back to the original. 3798 stream_->UpdateVideoConfig(new_config); 3799 stream_->UpdateVideoConfig(video_config_); 3800 3801 Seek(0); 3802 CheckVideoConfig(video_config_); 3803 NewSegmentAppend("0K 5K S(7K 8C 9D1 10D10) 20"); 3804 CheckExpectedBuffers("0K 5K"); 3805 3806 // Overlap the existing segment. 3807 NewSegmentAppend("5K 20"); 3808 CheckExpectedBuffers("7K C"); 3809 CheckVideoConfig(new_config); 3810 CheckExpectedBuffers("8 9 C"); 3811 CheckExpectedBuffers("10 C"); 3812 CheckVideoConfig(video_config_); 3813 CheckExpectedBuffers("20"); 3814 CheckNoNextBuffer(); 3815 } 3816 3817 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_Basic) { 3818 SetAudioStream(); 3819 Seek(0); 3820 NewSegmentAppend("0K 2K 4K 6K 8K 10K 12K"); 3821 NewSegmentAppend("11K 13K 15K 17K"); 3822 CheckExpectedBuffers("0K 2K 4K 6K 8K 10K 12K C 11K 13K 15K 17K"); 3823 CheckNoNextBuffer(); 3824 } 3825 3826 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoExactSplices) { 3827 SetAudioStream(); 3828 Seek(0); 3829 NewSegmentAppend("0K 2K 4K 6K 8K 10K 12K"); 3830 NewSegmentAppend("10K 14K"); 3831 CheckExpectedBuffers("0K 2K 4K 6K 8K 10K 14K"); 3832 CheckNoNextBuffer(); 3833 } 3834 3835 // Do not allow splices on top of splices. 3836 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoDoubleSplice) { 3837 SetAudioStream(); 3838 Seek(0); 3839 NewSegmentAppend("0K 2K 4K 6K 8K 10K 12K"); 3840 NewSegmentAppend("11K 13K 15K 17K"); 3841 3842 // Verify the splice was created. 3843 CheckExpectedBuffers("0K 2K 4K 6K 8K 10K 12K C 11K 13K 15K 17K"); 3844 CheckNoNextBuffer(); 3845 Seek(0); 3846 3847 // Create a splice before the first splice which would include it. 3848 NewSegmentAppend("9D2K"); 3849 3850 // A splice on top of a splice should result in a discard of the original 3851 // splice and no new splice frame being generated. 3852 CheckExpectedBuffers("0K 2K 4K 6K 8K 9K 13K 15K 17K"); 3853 CheckNoNextBuffer(); 3854 } 3855 3856 // Test that a splice is not created if an end timestamp and start timestamp 3857 // overlap. 3858 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoSplice) { 3859 SetAudioStream(); 3860 Seek(0); 3861 NewSegmentAppend("0K 2K 4K 6K 8K 10K"); 3862 NewSegmentAppend("12K 14K 16K 18K"); 3863 CheckExpectedBuffers("0K 2K 4K 6K 8K 10K 12K 14K 16K 18K"); 3864 CheckNoNextBuffer(); 3865 } 3866 3867 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_CorrectMediaSegmentStartTime) { 3868 SetAudioStream(); 3869 Seek(0); 3870 NewSegmentAppend("0K 2K 4K"); 3871 CheckExpectedRangesByTimestamp("{ [0,6) }"); 3872 NewSegmentAppend("6K 8K 10K"); 3873 CheckExpectedRangesByTimestamp("{ [0,12) }"); 3874 NewSegmentAppend("1K 4D2K"); 3875 CheckExpectedRangesByTimestamp("{ [0,12) }"); 3876 CheckExpectedBuffers("0K 2K 4K C 1K 4K 6K 8K 10K"); 3877 CheckNoNextBuffer(); 3878 } 3879 3880 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_ConfigChange) { 3881 SetAudioStream(); 3882 3883 AudioDecoderConfig new_config(kCodecVorbis, 3884 kSampleFormatPlanarF32, 3885 CHANNEL_LAYOUT_MONO, 3886 1000, 3887 NULL, 3888 0, 3889 false); 3890 ASSERT_NE(new_config.channel_layout(), audio_config_.channel_layout()); 3891 3892 Seek(0); 3893 CheckAudioConfig(audio_config_); 3894 NewSegmentAppend("0K 2K 4K 6K"); 3895 stream_->UpdateAudioConfig(new_config); 3896 NewSegmentAppend("5K 8K 12K"); 3897 CheckExpectedBuffers("0K 2K 4K 6K C 5K 8K 12K"); 3898 CheckAudioConfig(new_config); 3899 CheckNoNextBuffer(); 3900 } 3901 3902 // Ensure splices are not created if there are not enough frames to crossfade. 3903 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoTinySplices) { 3904 SetAudioStream(); 3905 Seek(0); 3906 3907 // Overlap the range [0, 2) with [1, 3). Since each frame has a duration of 3908 // 2ms this results in an overlap of 1ms between the ranges. A splice frame 3909 // should not be generated since it requires at least 2 frames, or 2ms in this 3910 // case, of data to crossfade. 3911 NewSegmentAppend("0D2K"); 3912 CheckExpectedRangesByTimestamp("{ [0,2) }"); 3913 NewSegmentAppend("1D2K"); 3914 CheckExpectedRangesByTimestamp("{ [0,3) }"); 3915 CheckExpectedBuffers("0K 1K"); 3916 CheckNoNextBuffer(); 3917 } 3918 3919 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_Preroll) { 3920 SetAudioStream(); 3921 Seek(0); 3922 NewSegmentAppend("0K 2K 4K 6K 8K 10K 12K"); 3923 NewSegmentAppend("11P 13K 15K 17K"); 3924 CheckExpectedBuffers("0K 2K 4K 6K 8K 10K 12K C 11P 13K 15K 17K"); 3925 CheckNoNextBuffer(); 3926 } 3927 3928 TEST_F(SourceBufferStreamTest, Audio_PrerollFrame) { 3929 Seek(0); 3930 NewSegmentAppend("0K 3P 6K"); 3931 CheckExpectedBuffers("0K 3P 6K"); 3932 CheckNoNextBuffer(); 3933 } 3934 3935 TEST_F(SourceBufferStreamTest, BFrames) { 3936 Seek(0); 3937 NewSegmentAppend("0K 120|30 30|60 60|90 90|120"); 3938 CheckExpectedRangesByTimestamp("{ [0,150) }"); 3939 3940 CheckExpectedBuffers("0K 120|30 30|60 60|90 90|120"); 3941 CheckNoNextBuffer(); 3942 } 3943 3944 // TODO(vrk): Add unit tests where keyframes are unaligned between streams. 3945 // (crbug.com/133557) 3946 3947 // TODO(vrk): Add unit tests with end of stream being called at interesting 3948 // times. 3949 3950 } // namespace media 3951