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 <algorithm> 8 #include <map> 9 10 #include "base/bind.h" 11 #include "base/debug/trace_event.h" 12 #include "base/logging.h" 13 #include "media/base/audio_splicer.h" 14 #include "media/filters/source_buffer_platform.h" 15 #include "media/filters/source_buffer_range.h" 16 17 namespace media { 18 19 // Helper method that returns true if |ranges| is sorted in increasing order, 20 // false otherwise. 21 static bool IsRangeListSorted( 22 const std::list<media::SourceBufferRange*>& ranges) { 23 DecodeTimestamp prev = kNoDecodeTimestamp(); 24 for (std::list<SourceBufferRange*>::const_iterator itr = 25 ranges.begin(); itr != ranges.end(); ++itr) { 26 if (prev != kNoDecodeTimestamp() && prev >= (*itr)->GetStartTimestamp()) 27 return false; 28 prev = (*itr)->GetEndTimestamp(); 29 } 30 return true; 31 } 32 33 // Returns an estimate of how far from the beginning or end of a range a buffer 34 // can be to still be considered in the range, given the |approximate_duration| 35 // of a buffer in the stream. 36 // TODO(wolenetz): Once all stream parsers emit accurate frame durations, use 37 // logic like FrameProcessor (2*last_frame_duration + last_decode_timestamp) 38 // instead of an overall maximum interbuffer delta for range discontinuity 39 // detection, and adjust similarly for splice frame discontinuity detection. 40 // See http://crbug.com/351489 and http://crbug.com/351166. 41 static base::TimeDelta ComputeFudgeRoom(base::TimeDelta approximate_duration) { 42 // Because we do not know exactly when is the next timestamp, any buffer 43 // that starts within 2x the approximate duration of a buffer is considered 44 // within this range. 45 return 2 * approximate_duration; 46 } 47 48 // An arbitrarily-chosen number to estimate the duration of a buffer if none 49 // is set and there's not enough information to get a better estimate. 50 static int kDefaultBufferDurationInMs = 125; 51 52 // The amount of time the beginning of the buffered data can differ from the 53 // start time in order to still be considered the start of stream. 54 static base::TimeDelta kSeekToStartFudgeRoom() { 55 return base::TimeDelta::FromMilliseconds(1000); 56 } 57 58 static SourceBufferRange::GapPolicy TypeToGapPolicy( 59 SourceBufferStream::Type type) { 60 switch (type) { 61 case SourceBufferStream::kAudio: 62 case SourceBufferStream::kVideo: 63 return SourceBufferRange::NO_GAPS_ALLOWED; 64 case SourceBufferStream::kText: 65 return SourceBufferRange::ALLOW_GAPS; 66 } 67 68 NOTREACHED(); 69 return SourceBufferRange::NO_GAPS_ALLOWED; 70 } 71 72 SourceBufferStream::SourceBufferStream(const AudioDecoderConfig& audio_config, 73 const LogCB& log_cb, 74 bool splice_frames_enabled) 75 : log_cb_(log_cb), 76 current_config_index_(0), 77 append_config_index_(0), 78 seek_pending_(false), 79 end_of_stream_(false), 80 seek_buffer_timestamp_(kNoTimestamp()), 81 selected_range_(NULL), 82 media_segment_start_time_(kNoDecodeTimestamp()), 83 range_for_next_append_(ranges_.end()), 84 new_media_segment_(false), 85 last_appended_buffer_timestamp_(kNoDecodeTimestamp()), 86 last_appended_buffer_is_keyframe_(false), 87 last_output_buffer_timestamp_(kNoDecodeTimestamp()), 88 max_interbuffer_distance_(kNoTimestamp()), 89 memory_limit_(kSourceBufferAudioMemoryLimit), 90 config_change_pending_(false), 91 splice_buffers_index_(0), 92 pending_buffers_complete_(false), 93 splice_frames_enabled_(splice_frames_enabled) { 94 DCHECK(audio_config.IsValidConfig()); 95 audio_configs_.push_back(audio_config); 96 } 97 98 SourceBufferStream::SourceBufferStream(const VideoDecoderConfig& video_config, 99 const LogCB& log_cb, 100 bool splice_frames_enabled) 101 : log_cb_(log_cb), 102 current_config_index_(0), 103 append_config_index_(0), 104 seek_pending_(false), 105 end_of_stream_(false), 106 seek_buffer_timestamp_(kNoTimestamp()), 107 selected_range_(NULL), 108 media_segment_start_time_(kNoDecodeTimestamp()), 109 range_for_next_append_(ranges_.end()), 110 new_media_segment_(false), 111 last_appended_buffer_timestamp_(kNoDecodeTimestamp()), 112 last_appended_buffer_is_keyframe_(false), 113 last_output_buffer_timestamp_(kNoDecodeTimestamp()), 114 max_interbuffer_distance_(kNoTimestamp()), 115 memory_limit_(kSourceBufferVideoMemoryLimit), 116 config_change_pending_(false), 117 splice_buffers_index_(0), 118 pending_buffers_complete_(false), 119 splice_frames_enabled_(splice_frames_enabled) { 120 DCHECK(video_config.IsValidConfig()); 121 video_configs_.push_back(video_config); 122 } 123 124 SourceBufferStream::SourceBufferStream(const TextTrackConfig& text_config, 125 const LogCB& log_cb, 126 bool splice_frames_enabled) 127 : log_cb_(log_cb), 128 current_config_index_(0), 129 append_config_index_(0), 130 text_track_config_(text_config), 131 seek_pending_(false), 132 end_of_stream_(false), 133 seek_buffer_timestamp_(kNoTimestamp()), 134 selected_range_(NULL), 135 media_segment_start_time_(kNoDecodeTimestamp()), 136 range_for_next_append_(ranges_.end()), 137 new_media_segment_(false), 138 last_appended_buffer_timestamp_(kNoDecodeTimestamp()), 139 last_appended_buffer_is_keyframe_(false), 140 last_output_buffer_timestamp_(kNoDecodeTimestamp()), 141 max_interbuffer_distance_(kNoTimestamp()), 142 memory_limit_(kSourceBufferAudioMemoryLimit), 143 config_change_pending_(false), 144 splice_buffers_index_(0), 145 pending_buffers_complete_(false), 146 splice_frames_enabled_(splice_frames_enabled) {} 147 148 SourceBufferStream::~SourceBufferStream() { 149 while (!ranges_.empty()) { 150 delete ranges_.front(); 151 ranges_.pop_front(); 152 } 153 } 154 155 void SourceBufferStream::OnNewMediaSegment( 156 DecodeTimestamp media_segment_start_time) { 157 DVLOG(1) << __FUNCTION__ << "(" << media_segment_start_time.InSecondsF() 158 << ")"; 159 DCHECK(!end_of_stream_); 160 media_segment_start_time_ = media_segment_start_time; 161 new_media_segment_ = true; 162 163 RangeList::iterator last_range = range_for_next_append_; 164 range_for_next_append_ = FindExistingRangeFor(media_segment_start_time); 165 166 // Only reset |last_appended_buffer_timestamp_| if this new media segment is 167 // not adjacent to the previous media segment appended to the stream. 168 if (range_for_next_append_ == ranges_.end() || 169 !AreAdjacentInSequence(last_appended_buffer_timestamp_, 170 media_segment_start_time)) { 171 last_appended_buffer_timestamp_ = kNoDecodeTimestamp(); 172 last_appended_buffer_is_keyframe_ = false; 173 DVLOG(3) << __FUNCTION__ << " next appended buffers will be in a new range"; 174 } else if (last_range != ranges_.end()) { 175 DCHECK(last_range == range_for_next_append_); 176 DVLOG(3) << __FUNCTION__ << " next appended buffers will continue range " 177 << "unless intervening remove makes discontinuity"; 178 } 179 } 180 181 bool SourceBufferStream::Append(const BufferQueue& buffers) { 182 TRACE_EVENT2("media", "SourceBufferStream::Append", 183 "stream type", GetStreamTypeName(), 184 "buffers to append", buffers.size()); 185 186 DCHECK(!buffers.empty()); 187 DCHECK(media_segment_start_time_ != kNoDecodeTimestamp()); 188 DCHECK(media_segment_start_time_ <= buffers.front()->GetDecodeTimestamp()); 189 DCHECK(!end_of_stream_); 190 191 // New media segments must begin with a keyframe. 192 if (new_media_segment_ && !buffers.front()->IsKeyframe()) { 193 MEDIA_LOG(log_cb_) << "Media segment did not begin with keyframe."; 194 return false; 195 } 196 197 // Buffers within a media segment should be monotonically increasing. 198 if (!IsMonotonicallyIncreasing(buffers)) 199 return false; 200 201 if (media_segment_start_time_ < DecodeTimestamp() || 202 buffers.front()->GetDecodeTimestamp() < DecodeTimestamp()) { 203 MEDIA_LOG(log_cb_) 204 << "Cannot append a media segment with negative timestamps."; 205 return false; 206 } 207 208 if (!IsNextTimestampValid(buffers.front()->GetDecodeTimestamp(), 209 buffers.front()->IsKeyframe())) { 210 MEDIA_LOG(log_cb_) << "Invalid same timestamp construct detected at time " 211 << buffers.front()->GetDecodeTimestamp().InSecondsF(); 212 213 return false; 214 } 215 216 UpdateMaxInterbufferDistance(buffers); 217 SetConfigIds(buffers); 218 219 // Save a snapshot of stream state before range modifications are made. 220 DecodeTimestamp next_buffer_timestamp = GetNextBufferTimestamp(); 221 BufferQueue deleted_buffers; 222 223 PrepareRangesForNextAppend(buffers, &deleted_buffers); 224 225 // If there's a range for |buffers|, insert |buffers| accordingly. Otherwise, 226 // create a new range with |buffers|. 227 if (range_for_next_append_ != ranges_.end()) { 228 (*range_for_next_append_)->AppendBuffersToEnd(buffers); 229 last_appended_buffer_timestamp_ = buffers.back()->GetDecodeTimestamp(); 230 last_appended_buffer_is_keyframe_ = buffers.back()->IsKeyframe(); 231 } else { 232 DecodeTimestamp new_range_start_time = std::min( 233 media_segment_start_time_, buffers.front()->GetDecodeTimestamp()); 234 const BufferQueue* buffers_for_new_range = &buffers; 235 BufferQueue trimmed_buffers; 236 237 // If the new range is not being created because of a new media 238 // segment, then we must make sure that we start with a keyframe. 239 // This can happen if the GOP in the previous append gets destroyed 240 // by a Remove() call. 241 if (!new_media_segment_) { 242 BufferQueue::const_iterator itr = buffers.begin(); 243 244 // Scan past all the non-keyframes. 245 while (itr != buffers.end() && !(*itr)->IsKeyframe()) { 246 ++itr; 247 } 248 249 // If we didn't find a keyframe, then update the last appended 250 // buffer state and return. 251 if (itr == buffers.end()) { 252 last_appended_buffer_timestamp_ = buffers.back()->GetDecodeTimestamp(); 253 last_appended_buffer_is_keyframe_ = buffers.back()->IsKeyframe(); 254 return true; 255 } else if (itr != buffers.begin()) { 256 // Copy the first keyframe and everything after it into 257 // |trimmed_buffers|. 258 trimmed_buffers.assign(itr, buffers.end()); 259 buffers_for_new_range = &trimmed_buffers; 260 } 261 262 new_range_start_time = 263 buffers_for_new_range->front()->GetDecodeTimestamp(); 264 } 265 266 range_for_next_append_ = 267 AddToRanges(new SourceBufferRange( 268 TypeToGapPolicy(GetType()), 269 *buffers_for_new_range, new_range_start_time, 270 base::Bind(&SourceBufferStream::GetMaxInterbufferDistance, 271 base::Unretained(this)))); 272 last_appended_buffer_timestamp_ = 273 buffers_for_new_range->back()->GetDecodeTimestamp(); 274 last_appended_buffer_is_keyframe_ = 275 buffers_for_new_range->back()->IsKeyframe(); 276 } 277 278 new_media_segment_ = false; 279 280 MergeWithAdjacentRangeIfNecessary(range_for_next_append_); 281 282 // Seek to try to fulfill a previous call to Seek(). 283 if (seek_pending_) { 284 DCHECK(!selected_range_); 285 DCHECK(deleted_buffers.empty()); 286 Seek(seek_buffer_timestamp_); 287 } 288 289 if (!deleted_buffers.empty()) { 290 DecodeTimestamp start_of_deleted = 291 deleted_buffers.front()->GetDecodeTimestamp(); 292 293 DCHECK(track_buffer_.empty() || 294 track_buffer_.back()->GetDecodeTimestamp() < start_of_deleted) 295 << "decode timestamp " 296 << track_buffer_.back()->GetDecodeTimestamp().InSecondsF() << " sec" 297 << ", start_of_deleted " << start_of_deleted.InSecondsF()<< " sec"; 298 299 track_buffer_.insert(track_buffer_.end(), deleted_buffers.begin(), 300 deleted_buffers.end()); 301 } 302 303 // Prune any extra buffers in |track_buffer_| if new keyframes 304 // are appended to the range covered by |track_buffer_|. 305 if (!track_buffer_.empty()) { 306 DecodeTimestamp keyframe_timestamp = 307 FindKeyframeAfterTimestamp(track_buffer_.front()->GetDecodeTimestamp()); 308 if (keyframe_timestamp != kNoDecodeTimestamp()) 309 PruneTrackBuffer(keyframe_timestamp); 310 } 311 312 SetSelectedRangeIfNeeded(next_buffer_timestamp); 313 314 GarbageCollectIfNeeded(); 315 316 DCHECK(IsRangeListSorted(ranges_)); 317 DCHECK(OnlySelectedRangeIsSeeked()); 318 return true; 319 } 320 321 void SourceBufferStream::Remove(base::TimeDelta start, base::TimeDelta end, 322 base::TimeDelta duration) { 323 DVLOG(1) << __FUNCTION__ << "(" << start.InSecondsF() 324 << ", " << end.InSecondsF() 325 << ", " << duration.InSecondsF() << ")"; 326 DCHECK(start >= base::TimeDelta()) << start.InSecondsF(); 327 DCHECK(start < end) << "start " << start.InSecondsF() 328 << " end " << end.InSecondsF(); 329 DCHECK(duration != kNoTimestamp()); 330 331 DecodeTimestamp start_dts = DecodeTimestamp::FromPresentationTime(start); 332 DecodeTimestamp end_dts = DecodeTimestamp::FromPresentationTime(end); 333 DecodeTimestamp remove_end_timestamp = 334 DecodeTimestamp::FromPresentationTime(duration); 335 DecodeTimestamp keyframe_timestamp = FindKeyframeAfterTimestamp(end_dts); 336 if (keyframe_timestamp != kNoDecodeTimestamp()) { 337 remove_end_timestamp = keyframe_timestamp; 338 } else if (end_dts < remove_end_timestamp) { 339 remove_end_timestamp = end_dts; 340 } 341 342 BufferQueue deleted_buffers; 343 RemoveInternal(start_dts, remove_end_timestamp, false, &deleted_buffers); 344 345 if (!deleted_buffers.empty()) 346 SetSelectedRangeIfNeeded(deleted_buffers.front()->GetDecodeTimestamp()); 347 } 348 349 void SourceBufferStream::RemoveInternal( 350 DecodeTimestamp start, DecodeTimestamp end, bool is_exclusive, 351 BufferQueue* deleted_buffers) { 352 DVLOG(1) << __FUNCTION__ << "(" << start.InSecondsF() 353 << ", " << end.InSecondsF() 354 << ", " << is_exclusive << ")"; 355 356 DCHECK(start >= DecodeTimestamp()); 357 DCHECK(start < end) << "start " << start.InSecondsF() 358 << " end " << end.InSecondsF(); 359 DCHECK(deleted_buffers); 360 361 RangeList::iterator itr = ranges_.begin(); 362 363 while (itr != ranges_.end()) { 364 SourceBufferRange* range = *itr; 365 if (range->GetStartTimestamp() >= end) 366 break; 367 368 // Split off any remaining end piece and add it to |ranges_|. 369 SourceBufferRange* new_range = range->SplitRange(end, is_exclusive); 370 if (new_range) { 371 itr = ranges_.insert(++itr, new_range); 372 --itr; 373 374 // Update the selected range if the next buffer position was transferred 375 // to |new_range|. 376 if (new_range->HasNextBufferPosition()) 377 SetSelectedRange(new_range); 378 } 379 380 // Truncate the current range so that it only contains data before 381 // the removal range. 382 BufferQueue saved_buffers; 383 bool delete_range = range->TruncateAt(start, &saved_buffers, is_exclusive); 384 385 // Check to see if the current playback position was removed and 386 // update the selected range appropriately. 387 if (!saved_buffers.empty()) { 388 DCHECK(!range->HasNextBufferPosition()); 389 DCHECK(deleted_buffers->empty()); 390 391 *deleted_buffers = saved_buffers; 392 } 393 394 if (range == selected_range_ && !range->HasNextBufferPosition()) 395 SetSelectedRange(NULL); 396 397 // If the current range now is completely covered by the removal 398 // range then delete it and move on. 399 if (delete_range) { 400 DeleteAndRemoveRange(&itr); 401 continue; 402 } 403 404 // Clear |range_for_next_append_| if we determine that the removal 405 // operation makes it impossible for the next append to be added 406 // to the current range. 407 if (range_for_next_append_ != ranges_.end() && 408 *range_for_next_append_ == range && 409 last_appended_buffer_timestamp_ != kNoDecodeTimestamp()) { 410 DecodeTimestamp potential_next_append_timestamp = 411 last_appended_buffer_timestamp_ + 412 base::TimeDelta::FromInternalValue(1); 413 414 if (!range->BelongsToRange(potential_next_append_timestamp)) { 415 DVLOG(1) << "Resetting range_for_next_append_ since the next append" 416 << " can't add to the current range."; 417 range_for_next_append_ = 418 FindExistingRangeFor(potential_next_append_timestamp); 419 } 420 } 421 422 // Move on to the next range. 423 ++itr; 424 } 425 426 DCHECK(IsRangeListSorted(ranges_)); 427 DCHECK(OnlySelectedRangeIsSeeked()); 428 DVLOG(1) << __FUNCTION__ << " : done"; 429 } 430 431 void SourceBufferStream::ResetSeekState() { 432 SetSelectedRange(NULL); 433 track_buffer_.clear(); 434 config_change_pending_ = false; 435 last_output_buffer_timestamp_ = kNoDecodeTimestamp(); 436 splice_buffers_index_ = 0; 437 pending_buffer_ = NULL; 438 pending_buffers_complete_ = false; 439 } 440 441 bool SourceBufferStream::ShouldSeekToStartOfBuffered( 442 base::TimeDelta seek_timestamp) const { 443 if (ranges_.empty()) 444 return false; 445 base::TimeDelta beginning_of_buffered = 446 ranges_.front()->GetStartTimestamp().ToPresentationTime(); 447 return (seek_timestamp <= beginning_of_buffered && 448 beginning_of_buffered < kSeekToStartFudgeRoom()); 449 } 450 451 bool SourceBufferStream::IsMonotonicallyIncreasing( 452 const BufferQueue& buffers) const { 453 DCHECK(!buffers.empty()); 454 DecodeTimestamp prev_timestamp = last_appended_buffer_timestamp_; 455 bool prev_is_keyframe = last_appended_buffer_is_keyframe_; 456 for (BufferQueue::const_iterator itr = buffers.begin(); 457 itr != buffers.end(); ++itr) { 458 DecodeTimestamp current_timestamp = (*itr)->GetDecodeTimestamp(); 459 bool current_is_keyframe = (*itr)->IsKeyframe(); 460 DCHECK(current_timestamp != kNoDecodeTimestamp()); 461 DCHECK((*itr)->duration() >= base::TimeDelta()) 462 << "Packet with invalid duration." 463 << " pts " << (*itr)->timestamp().InSecondsF() 464 << " dts " << (*itr)->GetDecodeTimestamp().InSecondsF() 465 << " dur " << (*itr)->duration().InSecondsF(); 466 467 if (prev_timestamp != kNoDecodeTimestamp()) { 468 if (current_timestamp < prev_timestamp) { 469 MEDIA_LOG(log_cb_) << "Buffers were not monotonically increasing."; 470 return false; 471 } 472 473 if (current_timestamp == prev_timestamp && 474 !SourceBufferRange::AllowSameTimestamp(prev_is_keyframe, 475 current_is_keyframe)) { 476 MEDIA_LOG(log_cb_) << "Unexpected combination of buffers with the" 477 << " same timestamp detected at " 478 << current_timestamp.InSecondsF(); 479 return false; 480 } 481 } 482 483 prev_timestamp = current_timestamp; 484 prev_is_keyframe = current_is_keyframe; 485 } 486 return true; 487 } 488 489 bool SourceBufferStream::IsNextTimestampValid( 490 DecodeTimestamp next_timestamp, bool next_is_keyframe) const { 491 return (last_appended_buffer_timestamp_ != next_timestamp) || 492 new_media_segment_ || 493 SourceBufferRange::AllowSameTimestamp(last_appended_buffer_is_keyframe_, 494 next_is_keyframe); 495 } 496 497 498 bool SourceBufferStream::OnlySelectedRangeIsSeeked() const { 499 for (RangeList::const_iterator itr = ranges_.begin(); 500 itr != ranges_.end(); ++itr) { 501 if ((*itr)->HasNextBufferPosition() && (*itr) != selected_range_) 502 return false; 503 } 504 return !selected_range_ || selected_range_->HasNextBufferPosition(); 505 } 506 507 void SourceBufferStream::UpdateMaxInterbufferDistance( 508 const BufferQueue& buffers) { 509 DCHECK(!buffers.empty()); 510 DecodeTimestamp prev_timestamp = last_appended_buffer_timestamp_; 511 for (BufferQueue::const_iterator itr = buffers.begin(); 512 itr != buffers.end(); ++itr) { 513 DecodeTimestamp current_timestamp = (*itr)->GetDecodeTimestamp(); 514 DCHECK(current_timestamp != kNoDecodeTimestamp()); 515 516 base::TimeDelta interbuffer_distance = (*itr)->duration(); 517 DCHECK(interbuffer_distance >= base::TimeDelta()); 518 519 if (prev_timestamp != kNoDecodeTimestamp()) { 520 interbuffer_distance = 521 std::max(current_timestamp - prev_timestamp, interbuffer_distance); 522 } 523 524 if (interbuffer_distance > base::TimeDelta()) { 525 if (max_interbuffer_distance_ == kNoTimestamp()) { 526 max_interbuffer_distance_ = interbuffer_distance; 527 } else { 528 max_interbuffer_distance_ = 529 std::max(max_interbuffer_distance_, interbuffer_distance); 530 } 531 } 532 prev_timestamp = current_timestamp; 533 } 534 } 535 536 void SourceBufferStream::SetConfigIds(const BufferQueue& buffers) { 537 for (BufferQueue::const_iterator itr = buffers.begin(); 538 itr != buffers.end(); ++itr) { 539 (*itr)->SetConfigId(append_config_index_); 540 } 541 } 542 543 void SourceBufferStream::GarbageCollectIfNeeded() { 544 // Compute size of |ranges_|. 545 int ranges_size = 0; 546 for (RangeList::iterator itr = ranges_.begin(); itr != ranges_.end(); ++itr) 547 ranges_size += (*itr)->size_in_bytes(); 548 549 // Return if we're under or at the memory limit. 550 if (ranges_size <= memory_limit_) 551 return; 552 553 int bytes_to_free = ranges_size - memory_limit_; 554 555 // Begin deleting after the last appended buffer. 556 int bytes_freed = FreeBuffersAfterLastAppended(bytes_to_free); 557 558 // Begin deleting from the front. 559 if (bytes_to_free - bytes_freed > 0) 560 bytes_freed += FreeBuffers(bytes_to_free - bytes_freed, false); 561 562 // Begin deleting from the back. 563 if (bytes_to_free - bytes_freed > 0) 564 FreeBuffers(bytes_to_free - bytes_freed, true); 565 } 566 567 int SourceBufferStream::FreeBuffersAfterLastAppended(int total_bytes_to_free) { 568 DecodeTimestamp next_buffer_timestamp = GetNextBufferTimestamp(); 569 if (last_appended_buffer_timestamp_ == kNoDecodeTimestamp() || 570 next_buffer_timestamp == kNoDecodeTimestamp() || 571 last_appended_buffer_timestamp_ >= next_buffer_timestamp) { 572 return 0; 573 } 574 575 DecodeTimestamp remove_range_start = last_appended_buffer_timestamp_; 576 if (last_appended_buffer_is_keyframe_) 577 remove_range_start += GetMaxInterbufferDistance(); 578 579 DecodeTimestamp remove_range_start_keyframe = FindKeyframeAfterTimestamp( 580 remove_range_start); 581 if (remove_range_start_keyframe != kNoDecodeTimestamp()) 582 remove_range_start = remove_range_start_keyframe; 583 if (remove_range_start >= next_buffer_timestamp) 584 return 0; 585 586 DecodeTimestamp remove_range_end; 587 int bytes_freed = GetRemovalRange( 588 remove_range_start, next_buffer_timestamp, total_bytes_to_free, 589 &remove_range_end); 590 if (bytes_freed > 0) { 591 Remove(remove_range_start.ToPresentationTime(), 592 remove_range_end.ToPresentationTime(), 593 next_buffer_timestamp.ToPresentationTime()); 594 } 595 596 return bytes_freed; 597 } 598 599 int SourceBufferStream::GetRemovalRange( 600 DecodeTimestamp start_timestamp, DecodeTimestamp end_timestamp, 601 int total_bytes_to_free, DecodeTimestamp* removal_end_timestamp) { 602 DCHECK(start_timestamp >= DecodeTimestamp()) << start_timestamp.InSecondsF(); 603 DCHECK(start_timestamp < end_timestamp) 604 << "start " << start_timestamp.InSecondsF() 605 << ", end " << end_timestamp.InSecondsF(); 606 607 int bytes_to_free = total_bytes_to_free; 608 int bytes_freed = 0; 609 610 for (RangeList::iterator itr = ranges_.begin(); 611 itr != ranges_.end() && bytes_to_free > 0; ++itr) { 612 SourceBufferRange* range = *itr; 613 if (range->GetStartTimestamp() >= end_timestamp) 614 break; 615 if (range->GetEndTimestamp() < start_timestamp) 616 continue; 617 618 int bytes_removed = range->GetRemovalGOP( 619 start_timestamp, end_timestamp, bytes_to_free, removal_end_timestamp); 620 bytes_to_free -= bytes_removed; 621 bytes_freed += bytes_removed; 622 } 623 return bytes_freed; 624 } 625 626 int SourceBufferStream::FreeBuffers(int total_bytes_to_free, 627 bool reverse_direction) { 628 TRACE_EVENT2("media", "SourceBufferStream::FreeBuffers", 629 "total bytes to free", total_bytes_to_free, 630 "reverse direction", reverse_direction); 631 632 DCHECK_GT(total_bytes_to_free, 0); 633 int bytes_to_free = total_bytes_to_free; 634 int bytes_freed = 0; 635 636 // This range will save the last GOP appended to |range_for_next_append_| 637 // if the buffers surrounding it get deleted during garbage collection. 638 SourceBufferRange* new_range_for_append = NULL; 639 640 while (!ranges_.empty() && bytes_to_free > 0) { 641 SourceBufferRange* current_range = NULL; 642 BufferQueue buffers; 643 int bytes_deleted = 0; 644 645 if (reverse_direction) { 646 current_range = ranges_.back(); 647 if (current_range->LastGOPContainsNextBufferPosition()) { 648 DCHECK_EQ(current_range, selected_range_); 649 break; 650 } 651 bytes_deleted = current_range->DeleteGOPFromBack(&buffers); 652 } else { 653 current_range = ranges_.front(); 654 if (current_range->FirstGOPContainsNextBufferPosition()) { 655 DCHECK_EQ(current_range, selected_range_); 656 break; 657 } 658 bytes_deleted = current_range->DeleteGOPFromFront(&buffers); 659 } 660 661 // Check to see if we've just deleted the GOP that was last appended. 662 DecodeTimestamp end_timestamp = buffers.back()->GetDecodeTimestamp(); 663 if (end_timestamp == last_appended_buffer_timestamp_) { 664 DCHECK(last_appended_buffer_timestamp_ != kNoDecodeTimestamp()); 665 DCHECK(!new_range_for_append); 666 // Create a new range containing these buffers. 667 new_range_for_append = new SourceBufferRange( 668 TypeToGapPolicy(GetType()), 669 buffers, kNoDecodeTimestamp(), 670 base::Bind(&SourceBufferStream::GetMaxInterbufferDistance, 671 base::Unretained(this))); 672 range_for_next_append_ = ranges_.end(); 673 } else { 674 bytes_to_free -= bytes_deleted; 675 bytes_freed += bytes_deleted; 676 } 677 678 if (current_range->size_in_bytes() == 0) { 679 DCHECK_NE(current_range, selected_range_); 680 DCHECK(range_for_next_append_ == ranges_.end() || 681 *range_for_next_append_ != current_range); 682 delete current_range; 683 reverse_direction ? ranges_.pop_back() : ranges_.pop_front(); 684 } 685 } 686 687 // Insert |new_range_for_append| into |ranges_|, if applicable. 688 if (new_range_for_append) { 689 range_for_next_append_ = AddToRanges(new_range_for_append); 690 DCHECK(range_for_next_append_ != ranges_.end()); 691 692 // Check to see if we need to merge |new_range_for_append| with the range 693 // before or after it. |new_range_for_append| is created whenever the last 694 // GOP appended is encountered, regardless of whether any buffers after it 695 // are ultimately deleted. Merging is necessary if there were no buffers 696 // (or very few buffers) deleted after creating |new_range_for_append|. 697 if (range_for_next_append_ != ranges_.begin()) { 698 RangeList::iterator range_before_next = range_for_next_append_; 699 --range_before_next; 700 MergeWithAdjacentRangeIfNecessary(range_before_next); 701 } 702 MergeWithAdjacentRangeIfNecessary(range_for_next_append_); 703 } 704 return bytes_freed; 705 } 706 707 void SourceBufferStream::PrepareRangesForNextAppend( 708 const BufferQueue& new_buffers, BufferQueue* deleted_buffers) { 709 DCHECK(deleted_buffers); 710 711 bool temporarily_select_range = false; 712 if (!track_buffer_.empty()) { 713 DecodeTimestamp tb_timestamp = track_buffer_.back()->GetDecodeTimestamp(); 714 DecodeTimestamp seek_timestamp = FindKeyframeAfterTimestamp(tb_timestamp); 715 if (seek_timestamp != kNoDecodeTimestamp() && 716 seek_timestamp < new_buffers.front()->GetDecodeTimestamp() && 717 range_for_next_append_ != ranges_.end() && 718 (*range_for_next_append_)->BelongsToRange(seek_timestamp)) { 719 DCHECK(tb_timestamp < seek_timestamp); 720 DCHECK(!selected_range_); 721 DCHECK(!(*range_for_next_append_)->HasNextBufferPosition()); 722 723 // If there are GOPs between the end of the track buffer and the 724 // beginning of the new buffers, then temporarily seek the range 725 // so that the buffers between these two times will be deposited in 726 // |deleted_buffers| as if they were part of the current playback 727 // position. 728 // TODO(acolwell): Figure out a more elegant way to do this. 729 SeekAndSetSelectedRange(*range_for_next_append_, seek_timestamp); 730 temporarily_select_range = true; 731 } 732 } 733 734 // Handle splices between the existing buffers and the new buffers. If a 735 // splice is generated the timestamp and duration of the first buffer in 736 // |new_buffers| will be modified. 737 if (splice_frames_enabled_) 738 GenerateSpliceFrame(new_buffers); 739 740 DecodeTimestamp prev_timestamp = last_appended_buffer_timestamp_; 741 bool prev_is_keyframe = last_appended_buffer_is_keyframe_; 742 DecodeTimestamp next_timestamp = new_buffers.front()->GetDecodeTimestamp(); 743 bool next_is_keyframe = new_buffers.front()->IsKeyframe(); 744 745 if (prev_timestamp != kNoDecodeTimestamp() && 746 prev_timestamp != next_timestamp) { 747 // Clean up the old buffers between the last appended buffer and the 748 // beginning of |new_buffers|. 749 RemoveInternal(prev_timestamp, next_timestamp, true, deleted_buffers); 750 } 751 752 // Make the delete range exclusive if we are dealing with an allowed same 753 // timestamp situation. This prevents the first buffer in the current append 754 // from deleting the last buffer in the previous append if both buffers 755 // have the same timestamp. 756 // 757 // The delete range should never be exclusive if a splice frame was generated 758 // because we don't generate splice frames for same timestamp situations. 759 DCHECK(new_buffers.front()->splice_timestamp() != 760 new_buffers.front()->timestamp()); 761 const bool is_exclusive = 762 new_buffers.front()->splice_buffers().empty() && 763 prev_timestamp == next_timestamp && 764 SourceBufferRange::AllowSameTimestamp(prev_is_keyframe, next_is_keyframe); 765 766 // Delete the buffers that |new_buffers| overlaps. 767 DecodeTimestamp start = new_buffers.front()->GetDecodeTimestamp(); 768 DecodeTimestamp end = new_buffers.back()->GetDecodeTimestamp(); 769 base::TimeDelta duration = new_buffers.back()->duration(); 770 771 if (duration != kNoTimestamp() && duration > base::TimeDelta()) { 772 end += duration; 773 } else { 774 // TODO(acolwell): Ensure all buffers actually have proper 775 // duration info so that this hack isn't needed. 776 // http://crbug.com/312836 777 end += base::TimeDelta::FromInternalValue(1); 778 } 779 780 RemoveInternal(start, end, is_exclusive, deleted_buffers); 781 782 // Restore the range seek state if necessary. 783 if (temporarily_select_range) 784 SetSelectedRange(NULL); 785 } 786 787 bool SourceBufferStream::AreAdjacentInSequence( 788 DecodeTimestamp first_timestamp, DecodeTimestamp second_timestamp) const { 789 return first_timestamp < second_timestamp && 790 second_timestamp <= 791 first_timestamp + ComputeFudgeRoom(GetMaxInterbufferDistance()); 792 } 793 794 void SourceBufferStream::PruneTrackBuffer(const DecodeTimestamp timestamp) { 795 // If we don't have the next timestamp, we don't have anything to delete. 796 if (timestamp == kNoDecodeTimestamp()) 797 return; 798 799 while (!track_buffer_.empty() && 800 track_buffer_.back()->GetDecodeTimestamp() >= timestamp) { 801 track_buffer_.pop_back(); 802 } 803 } 804 805 void SourceBufferStream::MergeWithAdjacentRangeIfNecessary( 806 const RangeList::iterator& range_with_new_buffers_itr) { 807 DCHECK(range_with_new_buffers_itr != ranges_.end()); 808 809 SourceBufferRange* range_with_new_buffers = *range_with_new_buffers_itr; 810 RangeList::iterator next_range_itr = range_with_new_buffers_itr; 811 ++next_range_itr; 812 813 if (next_range_itr == ranges_.end() || 814 !range_with_new_buffers->CanAppendRangeToEnd(**next_range_itr)) { 815 return; 816 } 817 818 bool transfer_current_position = selected_range_ == *next_range_itr; 819 range_with_new_buffers->AppendRangeToEnd(**next_range_itr, 820 transfer_current_position); 821 // Update |selected_range_| pointer if |range| has become selected after 822 // merges. 823 if (transfer_current_position) 824 SetSelectedRange(range_with_new_buffers); 825 826 if (next_range_itr == range_for_next_append_) 827 range_for_next_append_ = range_with_new_buffers_itr; 828 829 DeleteAndRemoveRange(&next_range_itr); 830 } 831 832 void SourceBufferStream::Seek(base::TimeDelta timestamp) { 833 DCHECK(timestamp >= base::TimeDelta()); 834 ResetSeekState(); 835 836 if (ShouldSeekToStartOfBuffered(timestamp)) { 837 ranges_.front()->SeekToStart(); 838 SetSelectedRange(ranges_.front()); 839 seek_pending_ = false; 840 return; 841 } 842 843 seek_buffer_timestamp_ = timestamp; 844 seek_pending_ = true; 845 846 DecodeTimestamp seek_dts = DecodeTimestamp::FromPresentationTime(timestamp); 847 848 RangeList::iterator itr = ranges_.end(); 849 for (itr = ranges_.begin(); itr != ranges_.end(); ++itr) { 850 if ((*itr)->CanSeekTo(seek_dts)) 851 break; 852 } 853 854 if (itr == ranges_.end()) 855 return; 856 857 SeekAndSetSelectedRange(*itr, seek_dts); 858 seek_pending_ = false; 859 } 860 861 bool SourceBufferStream::IsSeekPending() const { 862 return !(end_of_stream_ && IsEndSelected()) && seek_pending_; 863 } 864 865 void SourceBufferStream::OnSetDuration(base::TimeDelta duration) { 866 DecodeTimestamp duration_dts = 867 DecodeTimestamp::FromPresentationTime(duration); 868 869 RangeList::iterator itr = ranges_.end(); 870 for (itr = ranges_.begin(); itr != ranges_.end(); ++itr) { 871 if ((*itr)->GetEndTimestamp() > duration_dts) 872 break; 873 } 874 if (itr == ranges_.end()) 875 return; 876 877 // Need to partially truncate this range. 878 if ((*itr)->GetStartTimestamp() < duration_dts) { 879 bool delete_range = (*itr)->TruncateAt(duration_dts, NULL, false); 880 if ((*itr == selected_range_) && !selected_range_->HasNextBufferPosition()) 881 SetSelectedRange(NULL); 882 883 if (delete_range) { 884 DeleteAndRemoveRange(&itr); 885 } else { 886 ++itr; 887 } 888 } 889 890 // Delete all ranges that begin after |duration_dts|. 891 while (itr != ranges_.end()) { 892 // If we're about to delete the selected range, also reset the seek state. 893 DCHECK((*itr)->GetStartTimestamp() >= duration_dts); 894 if (*itr == selected_range_) 895 ResetSeekState(); 896 DeleteAndRemoveRange(&itr); 897 } 898 } 899 900 SourceBufferStream::Status SourceBufferStream::GetNextBuffer( 901 scoped_refptr<StreamParserBuffer>* out_buffer) { 902 if (!pending_buffer_.get()) { 903 const SourceBufferStream::Status status = GetNextBufferInternal(out_buffer); 904 if (status != SourceBufferStream::kSuccess || !SetPendingBuffer(out_buffer)) 905 return status; 906 } 907 908 if (!pending_buffer_->splice_buffers().empty()) 909 return HandleNextBufferWithSplice(out_buffer); 910 911 DCHECK(pending_buffer_->preroll_buffer().get()); 912 return HandleNextBufferWithPreroll(out_buffer); 913 } 914 915 SourceBufferStream::Status SourceBufferStream::HandleNextBufferWithSplice( 916 scoped_refptr<StreamParserBuffer>* out_buffer) { 917 const BufferQueue& splice_buffers = pending_buffer_->splice_buffers(); 918 const size_t last_splice_buffer_index = splice_buffers.size() - 1; 919 920 // Are there any splice buffers left to hand out? The last buffer should be 921 // handed out separately since it represents the first post-splice buffer. 922 if (splice_buffers_index_ < last_splice_buffer_index) { 923 // Account for config changes which occur between fade out buffers. 924 if (current_config_index_ != 925 splice_buffers[splice_buffers_index_]->GetConfigId()) { 926 config_change_pending_ = true; 927 DVLOG(1) << "Config change (splice buffer config ID does not match)."; 928 return SourceBufferStream::kConfigChange; 929 } 930 931 // Every pre splice buffer must have the same splice_timestamp(). 932 DCHECK(pending_buffer_->splice_timestamp() == 933 splice_buffers[splice_buffers_index_]->splice_timestamp()); 934 935 // No pre splice buffers should have preroll. 936 DCHECK(!splice_buffers[splice_buffers_index_]->preroll_buffer().get()); 937 938 *out_buffer = splice_buffers[splice_buffers_index_++]; 939 return SourceBufferStream::kSuccess; 940 } 941 942 // Did we hand out the last pre-splice buffer on the previous call? 943 if (!pending_buffers_complete_) { 944 DCHECK_EQ(splice_buffers_index_, last_splice_buffer_index); 945 pending_buffers_complete_ = true; 946 config_change_pending_ = true; 947 DVLOG(1) << "Config change (forced for fade in of splice frame)."; 948 return SourceBufferStream::kConfigChange; 949 } 950 951 // All pre-splice buffers have been handed out and a config change completed, 952 // so hand out the final buffer for fade in. Because a config change is 953 // always issued prior to handing out this buffer, any changes in config id 954 // have been inherently handled. 955 DCHECK(pending_buffers_complete_); 956 DCHECK_EQ(splice_buffers_index_, splice_buffers.size() - 1); 957 DCHECK(splice_buffers.back()->splice_timestamp() == kNoTimestamp()); 958 *out_buffer = splice_buffers.back(); 959 pending_buffer_ = NULL; 960 961 // If the last splice buffer has preroll, hand off to the preroll handler. 962 return SetPendingBuffer(out_buffer) ? HandleNextBufferWithPreroll(out_buffer) 963 : SourceBufferStream::kSuccess; 964 } 965 966 SourceBufferStream::Status SourceBufferStream::HandleNextBufferWithPreroll( 967 scoped_refptr<StreamParserBuffer>* out_buffer) { 968 // Any config change should have already been handled. 969 DCHECK_EQ(current_config_index_, pending_buffer_->GetConfigId()); 970 971 // Check if the preroll buffer has already been handed out. 972 if (!pending_buffers_complete_) { 973 pending_buffers_complete_ = true; 974 *out_buffer = pending_buffer_->preroll_buffer(); 975 return SourceBufferStream::kSuccess; 976 } 977 978 // Preroll complete, hand out the final buffer. 979 *out_buffer = pending_buffer_; 980 pending_buffer_ = NULL; 981 return SourceBufferStream::kSuccess; 982 } 983 984 SourceBufferStream::Status SourceBufferStream::GetNextBufferInternal( 985 scoped_refptr<StreamParserBuffer>* out_buffer) { 986 CHECK(!config_change_pending_); 987 988 if (!track_buffer_.empty()) { 989 DCHECK(!selected_range_); 990 scoped_refptr<StreamParserBuffer>& next_buffer = track_buffer_.front(); 991 992 // If the next buffer is an audio splice frame, the next effective config id 993 // comes from the first splice buffer. 994 if (next_buffer->GetSpliceBufferConfigId(0) != current_config_index_) { 995 config_change_pending_ = true; 996 DVLOG(1) << "Config change (track buffer config ID does not match)."; 997 return kConfigChange; 998 } 999 1000 *out_buffer = next_buffer; 1001 track_buffer_.pop_front(); 1002 last_output_buffer_timestamp_ = (*out_buffer)->GetDecodeTimestamp(); 1003 1004 // If the track buffer becomes empty, then try to set the selected range 1005 // based on the timestamp of this buffer being returned. 1006 if (track_buffer_.empty()) 1007 SetSelectedRangeIfNeeded(last_output_buffer_timestamp_); 1008 1009 return kSuccess; 1010 } 1011 1012 if (!selected_range_ || !selected_range_->HasNextBuffer()) { 1013 if (end_of_stream_ && IsEndSelected()) 1014 return kEndOfStream; 1015 return kNeedBuffer; 1016 } 1017 1018 if (selected_range_->GetNextConfigId() != current_config_index_) { 1019 config_change_pending_ = true; 1020 DVLOG(1) << "Config change (selected range config ID does not match)."; 1021 return kConfigChange; 1022 } 1023 1024 CHECK(selected_range_->GetNextBuffer(out_buffer)); 1025 last_output_buffer_timestamp_ = (*out_buffer)->GetDecodeTimestamp(); 1026 return kSuccess; 1027 } 1028 1029 DecodeTimestamp SourceBufferStream::GetNextBufferTimestamp() { 1030 if (!track_buffer_.empty()) 1031 return track_buffer_.front()->GetDecodeTimestamp(); 1032 1033 if (!selected_range_) 1034 return kNoDecodeTimestamp(); 1035 1036 DCHECK(selected_range_->HasNextBufferPosition()); 1037 return selected_range_->GetNextTimestamp(); 1038 } 1039 1040 SourceBufferStream::RangeList::iterator 1041 SourceBufferStream::FindExistingRangeFor(DecodeTimestamp start_timestamp) { 1042 for (RangeList::iterator itr = ranges_.begin(); itr != ranges_.end(); ++itr) { 1043 if ((*itr)->BelongsToRange(start_timestamp)) 1044 return itr; 1045 } 1046 return ranges_.end(); 1047 } 1048 1049 SourceBufferStream::RangeList::iterator 1050 SourceBufferStream::AddToRanges(SourceBufferRange* new_range) { 1051 DecodeTimestamp start_timestamp = new_range->GetStartTimestamp(); 1052 RangeList::iterator itr = ranges_.end(); 1053 for (itr = ranges_.begin(); itr != ranges_.end(); ++itr) { 1054 if ((*itr)->GetStartTimestamp() > start_timestamp) 1055 break; 1056 } 1057 return ranges_.insert(itr, new_range); 1058 } 1059 1060 SourceBufferStream::RangeList::iterator 1061 SourceBufferStream::GetSelectedRangeItr() { 1062 DCHECK(selected_range_); 1063 RangeList::iterator itr = ranges_.end(); 1064 for (itr = ranges_.begin(); itr != ranges_.end(); ++itr) { 1065 if (*itr == selected_range_) 1066 break; 1067 } 1068 DCHECK(itr != ranges_.end()); 1069 return itr; 1070 } 1071 1072 void SourceBufferStream::SeekAndSetSelectedRange( 1073 SourceBufferRange* range, DecodeTimestamp seek_timestamp) { 1074 if (range) 1075 range->Seek(seek_timestamp); 1076 SetSelectedRange(range); 1077 } 1078 1079 void SourceBufferStream::SetSelectedRange(SourceBufferRange* range) { 1080 DVLOG(1) << __FUNCTION__ << " : " << selected_range_ << " -> " << range; 1081 if (selected_range_) 1082 selected_range_->ResetNextBufferPosition(); 1083 DCHECK(!range || range->HasNextBufferPosition()); 1084 selected_range_ = range; 1085 } 1086 1087 Ranges<base::TimeDelta> SourceBufferStream::GetBufferedTime() const { 1088 Ranges<base::TimeDelta> ranges; 1089 for (RangeList::const_iterator itr = ranges_.begin(); 1090 itr != ranges_.end(); ++itr) { 1091 ranges.Add((*itr)->GetStartTimestamp().ToPresentationTime(), 1092 (*itr)->GetBufferedEndTimestamp().ToPresentationTime()); 1093 } 1094 return ranges; 1095 } 1096 1097 base::TimeDelta SourceBufferStream::GetBufferedDuration() const { 1098 if (ranges_.empty()) 1099 return base::TimeDelta(); 1100 1101 return ranges_.back()->GetBufferedEndTimestamp().ToPresentationTime(); 1102 } 1103 1104 void SourceBufferStream::MarkEndOfStream() { 1105 DCHECK(!end_of_stream_); 1106 end_of_stream_ = true; 1107 } 1108 1109 void SourceBufferStream::UnmarkEndOfStream() { 1110 DCHECK(end_of_stream_); 1111 end_of_stream_ = false; 1112 } 1113 1114 bool SourceBufferStream::IsEndSelected() const { 1115 if (ranges_.empty()) 1116 return true; 1117 1118 if (seek_pending_) { 1119 base::TimeDelta last_range_end_time = 1120 ranges_.back()->GetBufferedEndTimestamp().ToPresentationTime(); 1121 return seek_buffer_timestamp_ >= last_range_end_time; 1122 } 1123 1124 return selected_range_ == ranges_.back(); 1125 } 1126 1127 const AudioDecoderConfig& SourceBufferStream::GetCurrentAudioDecoderConfig() { 1128 if (config_change_pending_) 1129 CompleteConfigChange(); 1130 return audio_configs_[current_config_index_]; 1131 } 1132 1133 const VideoDecoderConfig& SourceBufferStream::GetCurrentVideoDecoderConfig() { 1134 if (config_change_pending_) 1135 CompleteConfigChange(); 1136 return video_configs_[current_config_index_]; 1137 } 1138 1139 const TextTrackConfig& SourceBufferStream::GetCurrentTextTrackConfig() { 1140 return text_track_config_; 1141 } 1142 1143 base::TimeDelta SourceBufferStream::GetMaxInterbufferDistance() const { 1144 if (max_interbuffer_distance_ == kNoTimestamp()) 1145 return base::TimeDelta::FromMilliseconds(kDefaultBufferDurationInMs); 1146 return max_interbuffer_distance_; 1147 } 1148 1149 bool SourceBufferStream::UpdateAudioConfig(const AudioDecoderConfig& config) { 1150 DCHECK(!audio_configs_.empty()); 1151 DCHECK(video_configs_.empty()); 1152 DVLOG(3) << "UpdateAudioConfig."; 1153 1154 if (audio_configs_[0].codec() != config.codec()) { 1155 MEDIA_LOG(log_cb_) << "Audio codec changes not allowed."; 1156 return false; 1157 } 1158 1159 if (audio_configs_[0].is_encrypted() != config.is_encrypted()) { 1160 MEDIA_LOG(log_cb_) << "Audio encryption changes not allowed."; 1161 return false; 1162 } 1163 1164 // Check to see if the new config matches an existing one. 1165 for (size_t i = 0; i < audio_configs_.size(); ++i) { 1166 if (config.Matches(audio_configs_[i])) { 1167 append_config_index_ = i; 1168 return true; 1169 } 1170 } 1171 1172 // No matches found so let's add this one to the list. 1173 append_config_index_ = audio_configs_.size(); 1174 DVLOG(2) << "New audio config - index: " << append_config_index_; 1175 audio_configs_.resize(audio_configs_.size() + 1); 1176 audio_configs_[append_config_index_] = config; 1177 return true; 1178 } 1179 1180 bool SourceBufferStream::UpdateVideoConfig(const VideoDecoderConfig& config) { 1181 DCHECK(!video_configs_.empty()); 1182 DCHECK(audio_configs_.empty()); 1183 DVLOG(3) << "UpdateVideoConfig."; 1184 1185 if (video_configs_[0].codec() != config.codec()) { 1186 MEDIA_LOG(log_cb_) << "Video codec changes not allowed."; 1187 return false; 1188 } 1189 1190 if (video_configs_[0].is_encrypted() != config.is_encrypted()) { 1191 MEDIA_LOG(log_cb_) << "Video encryption changes not allowed."; 1192 return false; 1193 } 1194 1195 // Check to see if the new config matches an existing one. 1196 for (size_t i = 0; i < video_configs_.size(); ++i) { 1197 if (config.Matches(video_configs_[i])) { 1198 append_config_index_ = i; 1199 return true; 1200 } 1201 } 1202 1203 // No matches found so let's add this one to the list. 1204 append_config_index_ = video_configs_.size(); 1205 DVLOG(2) << "New video config - index: " << append_config_index_; 1206 video_configs_.resize(video_configs_.size() + 1); 1207 video_configs_[append_config_index_] = config; 1208 return true; 1209 } 1210 1211 void SourceBufferStream::CompleteConfigChange() { 1212 config_change_pending_ = false; 1213 1214 if (pending_buffer_.get()) { 1215 current_config_index_ = 1216 pending_buffer_->GetSpliceBufferConfigId(splice_buffers_index_); 1217 return; 1218 } 1219 1220 if (!track_buffer_.empty()) { 1221 current_config_index_ = track_buffer_.front()->GetSpliceBufferConfigId(0); 1222 return; 1223 } 1224 1225 if (selected_range_ && selected_range_->HasNextBuffer()) 1226 current_config_index_ = selected_range_->GetNextConfigId(); 1227 } 1228 1229 void SourceBufferStream::SetSelectedRangeIfNeeded( 1230 const DecodeTimestamp timestamp) { 1231 DVLOG(1) << __FUNCTION__ << "(" << timestamp.InSecondsF() << ")"; 1232 1233 if (selected_range_) { 1234 DCHECK(track_buffer_.empty()); 1235 return; 1236 } 1237 1238 if (!track_buffer_.empty()) { 1239 DCHECK(!selected_range_); 1240 return; 1241 } 1242 1243 DecodeTimestamp start_timestamp = timestamp; 1244 1245 // If the next buffer timestamp is not known then use a timestamp just after 1246 // the timestamp on the last buffer returned by GetNextBuffer(). 1247 if (start_timestamp == kNoDecodeTimestamp()) { 1248 if (last_output_buffer_timestamp_ == kNoDecodeTimestamp()) 1249 return; 1250 1251 start_timestamp = last_output_buffer_timestamp_ + 1252 base::TimeDelta::FromInternalValue(1); 1253 } 1254 1255 DecodeTimestamp seek_timestamp = 1256 FindNewSelectedRangeSeekTimestamp(start_timestamp); 1257 1258 // If we don't have buffered data to seek to, then return. 1259 if (seek_timestamp == kNoDecodeTimestamp()) 1260 return; 1261 1262 DCHECK(track_buffer_.empty()); 1263 SeekAndSetSelectedRange(*FindExistingRangeFor(seek_timestamp), 1264 seek_timestamp); 1265 } 1266 1267 DecodeTimestamp SourceBufferStream::FindNewSelectedRangeSeekTimestamp( 1268 const DecodeTimestamp start_timestamp) { 1269 DCHECK(start_timestamp != kNoDecodeTimestamp()); 1270 DCHECK(start_timestamp >= DecodeTimestamp()); 1271 1272 RangeList::iterator itr = ranges_.begin(); 1273 1274 for (; itr != ranges_.end(); ++itr) { 1275 if ((*itr)->GetEndTimestamp() >= start_timestamp) { 1276 break; 1277 } 1278 } 1279 1280 if (itr == ranges_.end()) 1281 return kNoDecodeTimestamp(); 1282 1283 // First check for a keyframe timestamp >= |start_timestamp| 1284 // in the current range. 1285 DecodeTimestamp keyframe_timestamp = 1286 (*itr)->NextKeyframeTimestamp(start_timestamp); 1287 1288 if (keyframe_timestamp != kNoDecodeTimestamp()) 1289 return keyframe_timestamp; 1290 1291 // If a keyframe was not found then look for a keyframe that is 1292 // "close enough" in the current or next range. 1293 DecodeTimestamp end_timestamp = 1294 start_timestamp + ComputeFudgeRoom(GetMaxInterbufferDistance()); 1295 DCHECK(start_timestamp < end_timestamp); 1296 1297 // Make sure the current range doesn't start beyond |end_timestamp|. 1298 if ((*itr)->GetStartTimestamp() >= end_timestamp) 1299 return kNoDecodeTimestamp(); 1300 1301 keyframe_timestamp = (*itr)->KeyframeBeforeTimestamp(end_timestamp); 1302 1303 // Check to see if the keyframe is within the acceptable range 1304 // (|start_timestamp|, |end_timestamp|]. 1305 if (keyframe_timestamp != kNoDecodeTimestamp() && 1306 start_timestamp < keyframe_timestamp && 1307 keyframe_timestamp <= end_timestamp) { 1308 return keyframe_timestamp; 1309 } 1310 1311 // If |end_timestamp| is within this range, then no other checks are 1312 // necessary. 1313 if (end_timestamp <= (*itr)->GetEndTimestamp()) 1314 return kNoDecodeTimestamp(); 1315 1316 // Move on to the next range. 1317 ++itr; 1318 1319 // Return early if the next range does not contain |end_timestamp|. 1320 if (itr == ranges_.end() || (*itr)->GetStartTimestamp() >= end_timestamp) 1321 return kNoDecodeTimestamp(); 1322 1323 keyframe_timestamp = (*itr)->KeyframeBeforeTimestamp(end_timestamp); 1324 1325 // Check to see if the keyframe is within the acceptable range 1326 // (|start_timestamp|, |end_timestamp|]. 1327 if (keyframe_timestamp != kNoDecodeTimestamp() && 1328 start_timestamp < keyframe_timestamp && 1329 keyframe_timestamp <= end_timestamp) { 1330 return keyframe_timestamp; 1331 } 1332 1333 return kNoDecodeTimestamp(); 1334 } 1335 1336 DecodeTimestamp SourceBufferStream::FindKeyframeAfterTimestamp( 1337 const DecodeTimestamp timestamp) { 1338 DCHECK(timestamp != kNoDecodeTimestamp()); 1339 1340 RangeList::iterator itr = FindExistingRangeFor(timestamp); 1341 1342 if (itr == ranges_.end()) 1343 return kNoDecodeTimestamp(); 1344 1345 // First check for a keyframe timestamp >= |timestamp| 1346 // in the current range. 1347 return (*itr)->NextKeyframeTimestamp(timestamp); 1348 } 1349 1350 std::string SourceBufferStream::GetStreamTypeName() const { 1351 switch (GetType()) { 1352 case kAudio: 1353 return "AUDIO"; 1354 case kVideo: 1355 return "VIDEO"; 1356 case kText: 1357 return "TEXT"; 1358 } 1359 NOTREACHED(); 1360 return ""; 1361 } 1362 1363 SourceBufferStream::Type SourceBufferStream::GetType() const { 1364 if (!audio_configs_.empty()) 1365 return kAudio; 1366 if (!video_configs_.empty()) 1367 return kVideo; 1368 DCHECK_NE(text_track_config_.kind(), kTextNone); 1369 return kText; 1370 } 1371 1372 void SourceBufferStream::DeleteAndRemoveRange(RangeList::iterator* itr) { 1373 DVLOG(1) << __FUNCTION__; 1374 1375 DCHECK(*itr != ranges_.end()); 1376 if (**itr == selected_range_) { 1377 DVLOG(1) << __FUNCTION__ << " deleting selected range."; 1378 SetSelectedRange(NULL); 1379 } 1380 1381 if (*itr == range_for_next_append_) { 1382 DVLOG(1) << __FUNCTION__ << " deleting range_for_next_append_."; 1383 range_for_next_append_ = ranges_.end(); 1384 last_appended_buffer_timestamp_ = kNoDecodeTimestamp(); 1385 last_appended_buffer_is_keyframe_ = false; 1386 } 1387 1388 delete **itr; 1389 *itr = ranges_.erase(*itr); 1390 } 1391 1392 void SourceBufferStream::GenerateSpliceFrame(const BufferQueue& new_buffers) { 1393 DCHECK(!new_buffers.empty()); 1394 1395 // Splice frames are only supported for audio. 1396 if (GetType() != kAudio) 1397 return; 1398 1399 // Find the overlapped range (if any). 1400 const base::TimeDelta splice_timestamp = new_buffers.front()->timestamp(); 1401 const DecodeTimestamp splice_dts = 1402 DecodeTimestamp::FromPresentationTime(splice_timestamp); 1403 RangeList::iterator range_itr = FindExistingRangeFor(splice_dts); 1404 if (range_itr == ranges_.end()) 1405 return; 1406 1407 const DecodeTimestamp max_splice_end_dts = 1408 splice_dts + base::TimeDelta::FromMilliseconds( 1409 AudioSplicer::kCrossfadeDurationInMilliseconds); 1410 1411 // Find all buffers involved before the splice point. 1412 BufferQueue pre_splice_buffers; 1413 if (!(*range_itr)->GetBuffersInRange( 1414 splice_dts, max_splice_end_dts, &pre_splice_buffers)) { 1415 return; 1416 } 1417 1418 // If there are gaps in the timeline, it's possible that we only find buffers 1419 // after the splice point but within the splice range. For simplicity, we do 1420 // not generate splice frames in this case. 1421 // 1422 // We also do not want to generate splices if the first new buffer replaces an 1423 // existing buffer exactly. 1424 if (pre_splice_buffers.front()->timestamp() >= splice_timestamp) 1425 return; 1426 1427 // If any |pre_splice_buffers| are already splices or preroll, do not generate 1428 // a splice. 1429 for (size_t i = 0; i < pre_splice_buffers.size(); ++i) { 1430 const BufferQueue& original_splice_buffers = 1431 pre_splice_buffers[i]->splice_buffers(); 1432 if (!original_splice_buffers.empty()) { 1433 DVLOG(1) << "Can't generate splice: overlapped buffers contain a " 1434 "pre-existing splice."; 1435 return; 1436 } 1437 1438 if (pre_splice_buffers[i]->preroll_buffer().get()) { 1439 DVLOG(1) << "Can't generate splice: overlapped buffers contain preroll."; 1440 return; 1441 } 1442 } 1443 1444 // Don't generate splice frames which represent less than two frames, since we 1445 // need at least that much to generate a crossfade. Per the spec, make this 1446 // check using the sample rate of the overlapping buffers. 1447 const base::TimeDelta splice_duration = 1448 pre_splice_buffers.back()->timestamp() + 1449 pre_splice_buffers.back()->duration() - splice_timestamp; 1450 const base::TimeDelta minimum_splice_duration = base::TimeDelta::FromSecondsD( 1451 2.0 / audio_configs_[append_config_index_].samples_per_second()); 1452 if (splice_duration < minimum_splice_duration) { 1453 DVLOG(1) << "Can't generate splice: not enough samples for crossfade; have " 1454 << splice_duration.InMicroseconds() << " us, but need " 1455 << minimum_splice_duration.InMicroseconds() << " us."; 1456 return; 1457 } 1458 1459 new_buffers.front()->ConvertToSpliceBuffer(pre_splice_buffers); 1460 } 1461 1462 bool SourceBufferStream::SetPendingBuffer( 1463 scoped_refptr<StreamParserBuffer>* out_buffer) { 1464 DCHECK(out_buffer->get()); 1465 DCHECK(!pending_buffer_.get()); 1466 1467 const bool have_splice_buffers = !(*out_buffer)->splice_buffers().empty(); 1468 const bool have_preroll_buffer = !!(*out_buffer)->preroll_buffer().get(); 1469 1470 if (!have_splice_buffers && !have_preroll_buffer) 1471 return false; 1472 1473 DCHECK_NE(have_splice_buffers, have_preroll_buffer); 1474 splice_buffers_index_ = 0; 1475 pending_buffer_.swap(*out_buffer); 1476 pending_buffers_complete_ = false; 1477 return true; 1478 } 1479 1480 } // namespace media 1481
