src/media/filters/source_buffer_range.cc

   1 // Copyright 2014 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_range.h"
   6
   7 #include <algorithm>
   8
   9 namespace media {
  10
  11 // Comparison operators for std::upper_bound() and std::lower_bound().
  12 static bool CompareTimeDeltaToStreamParserBuffer(
  13     const DecodeTimestamp& decode_timestamp,
  14     const scoped_refptr<StreamParserBuffer>& buffer) {
  15   return decode_timestamp < buffer->GetDecodeTimestamp();
  16 }
  17 static bool CompareStreamParserBufferToTimeDelta(
  18     const scoped_refptr<StreamParserBuffer>& buffer,
  19     const DecodeTimestamp& decode_timestamp) {
  20   return buffer->GetDecodeTimestamp() < decode_timestamp;
  21 }
  22
  23 bool SourceBufferRange::AllowSameTimestamp(
  24     bool prev_is_keyframe, bool current_is_keyframe) {
  25   return prev_is_keyframe || !current_is_keyframe;
  26 }
  27
  28 SourceBufferRange::SourceBufferRange(
  29     GapPolicy gap_policy, const BufferQueue& new_buffers,
  30     DecodeTimestamp media_segment_start_time,
  31     const InterbufferDistanceCB& interbuffer_distance_cb)
  32     : gap_policy_(gap_policy),
  33       keyframe_map_index_base_(0),
  34       next_buffer_index_(-1),
  35       media_segment_start_time_(media_segment_start_time),
  36       interbuffer_distance_cb_(interbuffer_distance_cb),
  37       size_in_bytes_(0) {
  38   CHECK(!new_buffers.empty());
  39   DCHECK(new_buffers.front()->IsKeyframe());
  40   DCHECK(!interbuffer_distance_cb.is_null());
  41   AppendBuffersToEnd(new_buffers);
  42 }
  43
  44 SourceBufferRange::~SourceBufferRange() {}
  45
  46 void SourceBufferRange::AppendBuffersToEnd(const BufferQueue& new_buffers) {
  47   DCHECK(buffers_.empty() || CanAppendBuffersToEnd(new_buffers));
  48   DCHECK(media_segment_start_time_ == kNoDecodeTimestamp() ||
  49          media_segment_start_time_ <=
  50              new_buffers.front()->GetDecodeTimestamp());
  51   for (BufferQueue::const_iterator itr = new_buffers.begin();
  52        itr != new_buffers.end();
  53        ++itr) {
  54     DCHECK((*itr)->GetDecodeTimestamp() != kNoDecodeTimestamp());
  55     buffers_.push_back(*itr);
  56     size_in_bytes_ += (*itr)->data_size();
  57
  58     if ((*itr)->IsKeyframe()) {
  59       keyframe_map_.insert(
  60           std::make_pair((*itr)->GetDecodeTimestamp(),
  61                          buffers_.size() - 1 + keyframe_map_index_base_));
  62     }
  63   }
  64 }
  65
  66 void SourceBufferRange::Seek(DecodeTimestamp timestamp) {
  67   DCHECK(CanSeekTo(timestamp));
  68   DCHECK(!keyframe_map_.empty());
  69
  70   KeyframeMap::iterator result = GetFirstKeyframeBefore(timestamp);
  71   next_buffer_index_ = result->second - keyframe_map_index_base_;
  72   DCHECK_LT(next_buffer_index_, static_cast<int>(buffers_.size()));
  73 }
  74
  75 void SourceBufferRange::SeekAheadTo(DecodeTimestamp timestamp) {
  76   SeekAhead(timestamp, false);
  77 }
  78
  79 void SourceBufferRange::SeekAheadPast(DecodeTimestamp timestamp) {
  80   SeekAhead(timestamp, true);
  81 }
  82
  83 void SourceBufferRange::SeekAhead(DecodeTimestamp timestamp,
  84                                   bool skip_given_timestamp) {
  85   DCHECK(!keyframe_map_.empty());
  86
  87   KeyframeMap::iterator result =
  88       GetFirstKeyframeAt(timestamp, skip_given_timestamp);
  89
  90   // If there isn't a keyframe after |timestamp|, then seek to end and return
  91   // kNoTimestamp to signal such.
  92   if (result == keyframe_map_.end()) {
  93     next_buffer_index_ = -1;
  94     return;
  95   }
  96   next_buffer_index_ = result->second - keyframe_map_index_base_;
  97   DCHECK_LT(next_buffer_index_, static_cast<int>(buffers_.size()));
  98 }
  99
 100 void SourceBufferRange::SeekToStart() {
 101   DCHECK(!buffers_.empty());
 102   next_buffer_index_ = 0;
 103 }
 104
 105 SourceBufferRange* SourceBufferRange::SplitRange(
 106     DecodeTimestamp timestamp, bool is_exclusive) {
 107   CHECK(!buffers_.empty());
 108
 109   // Find the first keyframe after |timestamp|. If |is_exclusive|, do not
 110   // include keyframes at |timestamp|.
 111   KeyframeMap::iterator new_beginning_keyframe =
 112       GetFirstKeyframeAt(timestamp, is_exclusive);
 113
 114   // If there is no keyframe after |timestamp|, we can't split the range.
 115   if (new_beginning_keyframe == keyframe_map_.end())
 116     return NULL;
 117
 118   // Remove the data beginning at |keyframe_index| from |buffers_| and save it
 119   // into |removed_buffers|.
 120   int keyframe_index =
 121       new_beginning_keyframe->second - keyframe_map_index_base_;
 122   DCHECK_LT(keyframe_index, static_cast<int>(buffers_.size()));
 123   BufferQueue::iterator starting_point = buffers_.begin() + keyframe_index;
 124   BufferQueue removed_buffers(starting_point, buffers_.end());
 125
 126   DecodeTimestamp new_range_start_timestamp = kNoDecodeTimestamp();
 127   if (GetStartTimestamp() < buffers_.front()->GetDecodeTimestamp() &&
 128       timestamp < removed_buffers.front()->GetDecodeTimestamp()) {
 129     // The split is in the gap between |media_segment_start_time_| and
 130     // the first buffer of the new range so we should set the start
 131     // time of the new range to |timestamp| so we preserve part of the
 132     // gap in the new range.
 133     new_range_start_timestamp = timestamp;
 134   }
 135
 136   keyframe_map_.erase(new_beginning_keyframe, keyframe_map_.end());
 137   FreeBufferRange(starting_point, buffers_.end());
 138
 139   // Create a new range with |removed_buffers|.
 140   SourceBufferRange* split_range =
 141       new SourceBufferRange(
 142           gap_policy_, removed_buffers, new_range_start_timestamp,
 143           interbuffer_distance_cb_);
 144
 145   // If the next buffer position is now in |split_range|, update the state of
 146   // this range and |split_range| accordingly.
 147   if (next_buffer_index_ >= static_cast<int>(buffers_.size())) {
 148     split_range->next_buffer_index_ = next_buffer_index_ - keyframe_index;
 149     ResetNextBufferPosition();
 150   }
 151
 152   return split_range;
 153 }
 154
 155 SourceBufferRange::BufferQueue::iterator SourceBufferRange::GetBufferItrAt(
 156     DecodeTimestamp timestamp,
 157     bool skip_given_timestamp) {
 158   return skip_given_timestamp
 159              ? std::upper_bound(buffers_.begin(),
 160                                 buffers_.end(),
 161                                 timestamp,
 162                                 CompareTimeDeltaToStreamParserBuffer)
 163              : std::lower_bound(buffers_.begin(),
 164                                 buffers_.end(),
 165                                 timestamp,
 166                                 CompareStreamParserBufferToTimeDelta);
 167 }
 168
 169 SourceBufferRange::KeyframeMap::iterator
 170 SourceBufferRange::GetFirstKeyframeAt(DecodeTimestamp timestamp,
 171                                       bool skip_given_timestamp) {
 172   return skip_given_timestamp ?
 173       keyframe_map_.upper_bound(timestamp) :
 174       keyframe_map_.lower_bound(timestamp);
 175 }
 176
 177 SourceBufferRange::KeyframeMap::iterator
 178 SourceBufferRange::GetFirstKeyframeBefore(DecodeTimestamp timestamp) {
 179   KeyframeMap::iterator result = keyframe_map_.lower_bound(timestamp);
 180   // lower_bound() returns the first element >= |timestamp|, so we want the
 181   // previous element if it did not return the element exactly equal to
 182   // |timestamp|.
 183   if (result != keyframe_map_.begin() &&
 184       (result == keyframe_map_.end() || result->first != timestamp)) {
 185     --result;
 186   }
 187   return result;
 188 }
 189
 190 void SourceBufferRange::DeleteAll(BufferQueue* removed_buffers) {
 191   TruncateAt(buffers_.begin(), removed_buffers);
 192 }
 193
 194 bool SourceBufferRange::TruncateAt(
 195     DecodeTimestamp timestamp, BufferQueue* removed_buffers,
 196     bool is_exclusive) {
 197   // Find the place in |buffers_| where we will begin deleting data.
 198   BufferQueue::iterator starting_point =
 199       GetBufferItrAt(timestamp, is_exclusive);
 200   return TruncateAt(starting_point, removed_buffers);
 201 }
 202
 203 int SourceBufferRange::DeleteGOPFromFront(BufferQueue* deleted_buffers) {
 204   DCHECK(!FirstGOPContainsNextBufferPosition());
 205   DCHECK(deleted_buffers);
 206
 207   int buffers_deleted = 0;
 208   int total_bytes_deleted = 0;
 209
 210   KeyframeMap::iterator front = keyframe_map_.begin();
 211   DCHECK(front != keyframe_map_.end());
 212
 213   // Delete the keyframe at the start of |keyframe_map_|.
 214   keyframe_map_.erase(front);
 215
 216   // Now we need to delete all the buffers that depend on the keyframe we've
 217   // just deleted.
 218   int end_index = keyframe_map_.size() > 0 ?
 219       keyframe_map_.begin()->second - keyframe_map_index_base_ :
 220       buffers_.size();
 221
 222   // Delete buffers from the beginning of the buffered range up until (but not
 223   // including) the next keyframe.
 224   for (int i = 0; i < end_index; i++) {
 225     int bytes_deleted = buffers_.front()->data_size();
 226     size_in_bytes_ -= bytes_deleted;
 227     total_bytes_deleted += bytes_deleted;
 228     deleted_buffers->push_back(buffers_.front());
 229     buffers_.pop_front();
 230     ++buffers_deleted;
 231   }
 232
 233   // Update |keyframe_map_index_base_| to account for the deleted buffers.
 234   keyframe_map_index_base_ += buffers_deleted;
 235
 236   if (next_buffer_index_ > -1) {
 237     next_buffer_index_ -= buffers_deleted;
 238     DCHECK_GE(next_buffer_index_, 0);
 239   }
 240
 241   // Invalidate media segment start time if we've deleted the first buffer of
 242   // the range.
 243   if (buffers_deleted > 0)
 244     media_segment_start_time_ = kNoDecodeTimestamp();
 245
 246   return total_bytes_deleted;
 247 }
 248
 249 int SourceBufferRange::DeleteGOPFromBack(BufferQueue* deleted_buffers) {
 250   DCHECK(!LastGOPContainsNextBufferPosition());
 251   DCHECK(deleted_buffers);
 252
 253   // Remove the last GOP's keyframe from the |keyframe_map_|.
 254   KeyframeMap::iterator back = keyframe_map_.end();
 255   DCHECK_GT(keyframe_map_.size(), 0u);
 256   --back;
 257
 258   // The index of the first buffer in the last GOP is equal to the new size of
 259   // |buffers_| after that GOP is deleted.
 260   size_t goal_size = back->second - keyframe_map_index_base_;
 261   keyframe_map_.erase(back);
 262
 263   int total_bytes_deleted = 0;
 264   while (buffers_.size() != goal_size) {
 265     int bytes_deleted = buffers_.back()->data_size();
 266     size_in_bytes_ -= bytes_deleted;
 267     total_bytes_deleted += bytes_deleted;
 268     // We're removing buffers from the back, so push each removed buffer to the
 269     // front of |deleted_buffers| so that |deleted_buffers| are in nondecreasing
 270     // order.
 271     deleted_buffers->push_front(buffers_.back());
 272     buffers_.pop_back();
 273   }
 274
 275   return total_bytes_deleted;
 276 }
 277
 278 int SourceBufferRange::GetRemovalGOP(
 279     DecodeTimestamp start_timestamp, DecodeTimestamp end_timestamp,
 280     int total_bytes_to_free, DecodeTimestamp* removal_end_timestamp) {
 281   int bytes_to_free = total_bytes_to_free;
 282   int bytes_removed = 0;
 283
 284   KeyframeMap::iterator gop_itr = GetFirstKeyframeAt(start_timestamp, false);
 285   if (gop_itr == keyframe_map_.end())
 286     return 0;
 287   int keyframe_index = gop_itr->second - keyframe_map_index_base_;
 288   BufferQueue::iterator buffer_itr = buffers_.begin() + keyframe_index;
 289   KeyframeMap::iterator gop_end = keyframe_map_.end();
 290   if (end_timestamp < GetBufferedEndTimestamp())
 291     gop_end = GetFirstKeyframeBefore(end_timestamp);
 292
 293   // Check if the removal range is within a GOP and skip the loop if so.
 294   // [keyframe]...[start_timestamp]...[end_timestamp]...[keyframe]
 295   KeyframeMap::iterator gop_itr_prev = gop_itr;
 296   if (gop_itr_prev != keyframe_map_.begin() && --gop_itr_prev == gop_end)
 297     gop_end = gop_itr;
 298
 299   while (gop_itr != gop_end && bytes_to_free > 0) {
 300     ++gop_itr;
 301
 302     int gop_size = 0;
 303     int next_gop_index = gop_itr == keyframe_map_.end() ?
 304         buffers_.size() : gop_itr->second - keyframe_map_index_base_;
 305     BufferQueue::iterator next_gop_start = buffers_.begin() + next_gop_index;
 306     for (; buffer_itr != next_gop_start; ++buffer_itr)
 307       gop_size += (*buffer_itr)->data_size();
 308
 309     bytes_removed += gop_size;
 310     bytes_to_free -= gop_size;
 311   }
 312   if (bytes_removed > 0) {
 313     *removal_end_timestamp = gop_itr == keyframe_map_.end() ?
 314         GetBufferedEndTimestamp() : gop_itr->first;
 315   }
 316   return bytes_removed;
 317 }
 318
 319 bool SourceBufferRange::FirstGOPContainsNextBufferPosition() const {
 320   if (!HasNextBufferPosition())
 321     return false;
 322
 323   // If there is only one GOP, it must contain the next buffer position.
 324   if (keyframe_map_.size() == 1u)
 325     return true;
 326
 327   KeyframeMap::const_iterator second_gop = keyframe_map_.begin();
 328   ++second_gop;
 329   return next_buffer_index_ < second_gop->second - keyframe_map_index_base_;
 330 }
 331
 332 bool SourceBufferRange::LastGOPContainsNextBufferPosition() const {
 333   if (!HasNextBufferPosition())
 334     return false;
 335
 336   // If there is only one GOP, it must contain the next buffer position.
 337   if (keyframe_map_.size() == 1u)
 338     return true;
 339
 340   KeyframeMap::const_iterator last_gop = keyframe_map_.end();
 341   --last_gop;
 342   return last_gop->second - keyframe_map_index_base_ <= next_buffer_index_;
 343 }
 344
 345 void SourceBufferRange::FreeBufferRange(
 346     const BufferQueue::iterator& starting_point,
 347     const BufferQueue::iterator& ending_point) {
 348   for (BufferQueue::iterator itr = starting_point;
 349        itr != ending_point; ++itr) {
 350     size_in_bytes_ -= (*itr)->data_size();
 351     DCHECK_GE(size_in_bytes_, 0);
 352   }
 353   buffers_.erase(starting_point, ending_point);
 354 }
 355
 356 bool SourceBufferRange::TruncateAt(
 357     const BufferQueue::iterator& starting_point, BufferQueue* removed_buffers) {
 358   DCHECK(!removed_buffers || removed_buffers->empty());
 359
 360   // Return if we're not deleting anything.
 361   if (starting_point == buffers_.end())
 362     return buffers_.empty();
 363
 364   // Reset the next buffer index if we will be deleting the buffer that's next
 365   // in sequence.
 366   if (HasNextBufferPosition()) {
 367     DecodeTimestamp next_buffer_timestamp = GetNextTimestamp();
 368     if (next_buffer_timestamp == kNoDecodeTimestamp() ||
 369         next_buffer_timestamp >= (*starting_point)->GetDecodeTimestamp()) {
 370       if (HasNextBuffer() && removed_buffers) {
 371         int starting_offset = starting_point - buffers_.begin();
 372         int next_buffer_offset = next_buffer_index_ - starting_offset;
 373         DCHECK_GE(next_buffer_offset, 0);
 374         BufferQueue saved(starting_point + next_buffer_offset, buffers_.end());
 375         removed_buffers->swap(saved);
 376       }
 377       ResetNextBufferPosition();
 378     }
 379   }
 380
 381   // Remove keyframes from |starting_point| onward.
 382   KeyframeMap::iterator starting_point_keyframe =
 383       keyframe_map_.lower_bound((*starting_point)->GetDecodeTimestamp());
 384   keyframe_map_.erase(starting_point_keyframe, keyframe_map_.end());
 385
 386   // Remove everything from |starting_point| onward.
 387   FreeBufferRange(starting_point, buffers_.end());
 388   return buffers_.empty();
 389 }
 390
 391 bool SourceBufferRange::GetNextBuffer(
 392     scoped_refptr<StreamParserBuffer>* out_buffer) {
 393   if (!HasNextBuffer())
 394     return false;
 395
 396   *out_buffer = buffers_[next_buffer_index_];
 397   next_buffer_index_++;
 398   return true;
 399 }
 400
 401 bool SourceBufferRange::HasNextBuffer() const {
 402   return next_buffer_index_ >= 0 &&
 403       next_buffer_index_ < static_cast<int>(buffers_.size());
 404 }
 405
 406 int SourceBufferRange::GetNextConfigId() const {
 407   DCHECK(HasNextBuffer());
 408   // If the next buffer is an audio splice frame, the next effective config id
 409   // comes from the first fade out preroll buffer.
 410   return buffers_[next_buffer_index_]->GetSpliceBufferConfigId(0);
 411 }
 412
 413 DecodeTimestamp SourceBufferRange::GetNextTimestamp() const {
 414   DCHECK(!buffers_.empty());
 415   DCHECK(HasNextBufferPosition());
 416
 417   if (next_buffer_index_ >= static_cast<int>(buffers_.size())) {
 418     return kNoDecodeTimestamp();
 419   }
 420
 421   return buffers_[next_buffer_index_]->GetDecodeTimestamp();
 422 }
 423
 424 bool SourceBufferRange::HasNextBufferPosition() const {
 425   return next_buffer_index_ >= 0;
 426 }
 427
 428 void SourceBufferRange::ResetNextBufferPosition() {
 429   next_buffer_index_ = -1;
 430 }
 431
 432 void SourceBufferRange::AppendRangeToEnd(const SourceBufferRange& range,
 433                                          bool transfer_current_position) {
 434   DCHECK(CanAppendRangeToEnd(range));
 435   DCHECK(!buffers_.empty());
 436
 437   if (transfer_current_position && range.next_buffer_index_ >= 0)
 438     next_buffer_index_ = range.next_buffer_index_ + buffers_.size();
 439
 440   AppendBuffersToEnd(range.buffers_);
 441 }
 442
 443 bool SourceBufferRange::CanAppendRangeToEnd(
 444     const SourceBufferRange& range) const {
 445   return CanAppendBuffersToEnd(range.buffers_);
 446 }
 447
 448 bool SourceBufferRange::CanAppendBuffersToEnd(
 449     const BufferQueue& buffers) const {
 450   DCHECK(!buffers_.empty());
 451   return IsNextInSequence(buffers.front()->GetDecodeTimestamp(),
 452                           buffers.front()->IsKeyframe());
 453 }
 454
 455 bool SourceBufferRange::BelongsToRange(DecodeTimestamp timestamp) const {
 456   DCHECK(!buffers_.empty());
 457
 458   return (IsNextInSequence(timestamp, false) ||
 459           (GetStartTimestamp() <= timestamp && timestamp <= GetEndTimestamp()));
 460 }
 461
 462 bool SourceBufferRange::CanSeekTo(DecodeTimestamp timestamp) const {
 463   DecodeTimestamp start_timestamp =
 464       std::max(DecodeTimestamp(), GetStartTimestamp() - GetFudgeRoom());
 465   return !keyframe_map_.empty() && start_timestamp <= timestamp &&
 466       timestamp < GetBufferedEndTimestamp();
 467 }
 468
 469 bool SourceBufferRange::CompletelyOverlaps(
 470     const SourceBufferRange& range) const {
 471   return GetStartTimestamp() <= range.GetStartTimestamp() &&
 472       GetEndTimestamp() >= range.GetEndTimestamp();
 473 }
 474
 475 bool SourceBufferRange::EndOverlaps(const SourceBufferRange& range) const {
 476   return range.GetStartTimestamp() <= GetEndTimestamp() &&
 477       GetEndTimestamp() < range.GetEndTimestamp();
 478 }
 479
 480 DecodeTimestamp SourceBufferRange::GetStartTimestamp() const {
 481   DCHECK(!buffers_.empty());
 482   DecodeTimestamp start_timestamp = media_segment_start_time_;
 483   if (start_timestamp == kNoDecodeTimestamp())
 484     start_timestamp = buffers_.front()->GetDecodeTimestamp();
 485   return start_timestamp;
 486 }
 487
 488 DecodeTimestamp SourceBufferRange::GetEndTimestamp() const {
 489   DCHECK(!buffers_.empty());
 490   return buffers_.back()->GetDecodeTimestamp();
 491 }
 492
 493 DecodeTimestamp SourceBufferRange::GetBufferedEndTimestamp() const {
 494   DCHECK(!buffers_.empty());
 495   base::TimeDelta duration = buffers_.back()->duration();
 496   if (duration == kNoTimestamp() || duration == base::TimeDelta())
 497     duration = GetApproximateDuration();
 498   return GetEndTimestamp() + duration;
 499 }
 500
 501 DecodeTimestamp SourceBufferRange::NextKeyframeTimestamp(
 502     DecodeTimestamp timestamp) {
 503   DCHECK(!keyframe_map_.empty());
 504
 505   if (timestamp < GetStartTimestamp() || timestamp >= GetBufferedEndTimestamp())
 506     return kNoDecodeTimestamp();
 507
 508   KeyframeMap::iterator itr = GetFirstKeyframeAt(timestamp, false);
 509   if (itr == keyframe_map_.end())
 510     return kNoDecodeTimestamp();
 511
 512   // If the timestamp is inside the gap between the start of the media
 513   // segment and the first buffer, then just pretend there is a
 514   // keyframe at the specified timestamp.
 515   if (itr == keyframe_map_.begin() &&
 516       timestamp > media_segment_start_time_ &&
 517       timestamp < itr->first) {
 518     return timestamp;
 519   }
 520
 521   return itr->first;
 522 }
 523
 524 DecodeTimestamp SourceBufferRange::KeyframeBeforeTimestamp(
 525     DecodeTimestamp timestamp) {
 526   DCHECK(!keyframe_map_.empty());
 527
 528   if (timestamp < GetStartTimestamp() || timestamp >= GetBufferedEndTimestamp())
 529     return kNoDecodeTimestamp();
 530
 531   return GetFirstKeyframeBefore(timestamp)->first;
 532 }
 533
 534 bool SourceBufferRange::IsNextInSequence(
 535     DecodeTimestamp timestamp, bool is_keyframe) const {
 536   DecodeTimestamp end = buffers_.back()->GetDecodeTimestamp();
 537   if (end < timestamp &&
 538       (gap_policy_ == ALLOW_GAPS ||
 539        timestamp <= end + GetFudgeRoom())) {
 540     return true;
 541   }
 542
 543   return timestamp == end && AllowSameTimestamp(
 544       buffers_.back()->IsKeyframe(), is_keyframe);
 545 }
 546
 547 base::TimeDelta SourceBufferRange::GetFudgeRoom() const {
 548   // Because we do not know exactly when is the next timestamp, any buffer
 549   // that starts within 2x the approximate duration of a buffer is considered
 550   // within this range.
 551   return 2 * GetApproximateDuration();
 552 }
 553
 554 base::TimeDelta SourceBufferRange::GetApproximateDuration() const {
 555   base::TimeDelta max_interbuffer_distance = interbuffer_distance_cb_.Run();
 556   DCHECK(max_interbuffer_distance != kNoTimestamp());
 557   return max_interbuffer_distance;
 558 }
 559
 560 bool SourceBufferRange::GetBuffersInRange(DecodeTimestamp start,
 561                                           DecodeTimestamp end,
 562                                           BufferQueue* buffers) {
 563   // Find the nearest buffer with a decode timestamp <= start.
 564   const DecodeTimestamp first_timestamp = KeyframeBeforeTimestamp(start);
 565   if (first_timestamp == kNoDecodeTimestamp())
 566     return false;
 567
 568   // Find all buffers involved in the range.
 569   const size_t previous_size = buffers->size();
 570   for (BufferQueue::iterator it = GetBufferItrAt(first_timestamp, false);
 571        it != buffers_.end();
 572        ++it) {
 573     const scoped_refptr<StreamParserBuffer>& buffer = *it;
 574     // Buffers without duration are not supported, so bail if we encounter any.
 575     if (buffer->duration() == kNoTimestamp() ||
 576         buffer->duration() <= base::TimeDelta()) {
 577       return false;
 578     }
 579     if (buffer->end_of_stream() ||
 580         buffer->timestamp() >= end.ToPresentationTime()) {
 581       break;
 582     }
 583
 584     if (buffer->timestamp() + buffer->duration() <= start.ToPresentationTime())
 585       continue;
 586     buffers->push_back(buffer);
 587   }
 588   return previous_size < buffers->size();
 589 }
 590
 591 }  // namespace media