blob: dfd1596fd76db63545c6f2db0e4dfcad3d55c06d [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "media/filters/source_buffer_stream.h"
#include <algorithm>
#include <map>
#include "base/basictypes.h"
#include "base/bind.h"
#include "base/logging.h"
#include "base/stl_util.h"
#if defined(__LB_SHELL__) || defined(COBALT)
#include "media/base/shell_media_platform.h"
#endif
namespace media {
// Helper class representing a range of buffered data. All buffers in a
// SourceBufferRange are ordered sequentially in presentation order with no
// gaps.
class SourceBufferRange {
public:
typedef std::deque<scoped_refptr<StreamParserBuffer> > BufferQueue;
// Returns the maximum distance in time between any buffer seen in this
// stream. Used to estimate the duration of a buffer if its duration is not
// known.
typedef base::Callback<base::TimeDelta()> InterbufferDistanceCB;
// Creates a source buffer range with |new_buffers|. |new_buffers| cannot be
// empty and the front of |new_buffers| must be a keyframe.
// |media_segment_start_time| refers to the starting timestamp for the media
// segment to which these buffers belong.
SourceBufferRange(const BufferQueue& new_buffers,
base::TimeDelta media_segment_start_time,
const InterbufferDistanceCB& interbuffer_distance_cb);
// Appends |buffers| to the end of the range and updates |keyframe_map_| as
// it encounters new keyframes. Assumes |buffers| belongs at the end of the
// range.
void AppendBuffersToEnd(const BufferQueue& buffers);
bool CanAppendBuffersToEnd(const BufferQueue& buffers) const;
// Appends the buffers from |range| into this range.
// The first buffer in |range| must come directly after the last buffer
// in this range.
// If |transfer_current_position| is true, |range|'s |next_buffer_index_|
// is transfered to this SourceBufferRange.
void AppendRangeToEnd(const SourceBufferRange& range,
bool transfer_current_position);
bool CanAppendRangeToEnd(const SourceBufferRange& range) const;
// Updates |next_buffer_index_| to point to the Buffer containing |timestamp|.
// Assumes |timestamp| is valid and in this range.
void Seek(base::TimeDelta timestamp);
// Updates |next_buffer_index_| to point to next keyframe after or equal to
// |timestamp|.
void SeekAheadTo(base::TimeDelta timestamp);
// Updates |next_buffer_index_| to point to next keyframe strictly after
// |timestamp|.
void SeekAheadPast(base::TimeDelta timestamp);
// Seeks to the beginning of the range.
void SeekToStart();
// Finds the next keyframe from |buffers_| after |timestamp| (or at
// |timestamp| if |is_exclusive| is false) and creates and returns a new
// SourceBufferRange with the buffers from that keyframe onward.
// The buffers in the new SourceBufferRange are moved out of this range. If
// there is no keyframe after |timestamp|, SplitRange() returns null and this
// range is unmodified.
SourceBufferRange* SplitRange(base::TimeDelta timestamp, bool is_exclusive);
// Deletes the buffers from this range starting at |timestamp|, exclusive if
// |is_exclusive| is true, inclusive otherwise.
// Resets |next_buffer_index_| if the buffer at |next_buffer_index_| was
// deleted, and deletes the |keyframe_map_| entries for the buffers that
// were removed.
// |deleted_buffers| contains the buffers that were deleted from this range,
// starting at the buffer that had been at |next_buffer_index_|.
// Returns true if the |next_buffer_index_| is reset. Note that this method
// may return true even if it does not add any buffers to |deleted_buffers|.
// This indicates that the range had not buffered |next_buffer_index_|, but
// a buffer at that position would have been deleted.
bool TruncateAt(base::TimeDelta timestamp,
BufferQueue* deleted_buffers, bool is_exclusive);
// Deletes all buffers in range.
bool DeleteAll(BufferQueue* deleted_buffers);
// Deletes a GOP from the front or back of the range and moves these
// buffers into |deleted_buffers|. Returns the number of bytes deleted from
// the range (i.e. the size in bytes of |deleted_buffers|).
int DeleteGOPFromFront(BufferQueue* deleted_buffers);
int DeleteGOPFromBack(BufferQueue* deleted_buffers);
// Indicates whether the GOP at the beginning or end of the range contains the
// next buffer position.
bool FirstGOPContainsNextBufferPosition() const;
bool LastGOPContainsNextBufferPosition() const;
// Updates |out_buffer| with the next buffer in presentation order. Seek()
// must be called before calls to GetNextBuffer(), and buffers are returned
// in order from the last call to Seek(). Returns true if |out_buffer| is
// filled with a valid buffer, false if there is not enough data to fulfill
// the request.
bool GetNextBuffer(scoped_refptr<StreamParserBuffer>* out_buffer);
bool HasNextBuffer() const;
// Returns the config ID for the buffer that will be returned by
// GetNextBuffer().
int GetNextConfigId() const;
// Returns true if the range knows the position of the next buffer it should
// return, i.e. it has been Seek()ed. This does not necessarily mean that it
// has the next buffer yet.
bool HasNextBufferPosition() const;
// Resets this range to an "unseeked" state.
void ResetNextBufferPosition();
// Returns the timestamp of the next buffer that will be returned from
// GetNextBuffer(), or kNoTimestamp() if the timestamp is unknown.
base::TimeDelta GetNextTimestamp() const;
// Returns the start timestamp of the range.
base::TimeDelta GetStartTimestamp() const;
// Returns the timestamp of the last buffer in the range.
base::TimeDelta GetEndTimestamp() const;
// Returns the timestamp for the end of the buffered region in this range.
// This is an approximation if the duration for the last buffer in the range
// is unset.
base::TimeDelta GetBufferedEndTimestamp() const;
// Returns whether a buffer with a starting timestamp of |timestamp| would
// belong in this range. This includes a buffer that would be appended to
// the end of the range.
bool BelongsToRange(base::TimeDelta timestamp) const;
// Returns true if the range has enough data to seek to the specified
// |timestamp|, false otherwise.
bool CanSeekTo(base::TimeDelta timestamp) const;
// Returns true if this range's buffered timespan completely overlaps the
// buffered timespan of |range|.
bool CompletelyOverlaps(const SourceBufferRange& range) const;
// Returns true if the end of this range contains buffers that overlaps with
// the beginning of |range|.
bool EndOverlaps(const SourceBufferRange& range) const;
// Returns true if |timestamp| is the timestamp of the next buffer in
// sequence after |buffer|, false otherwise.
bool IsNextInSequence(
const scoped_refptr<media::StreamParserBuffer>& buffer,
base::TimeDelta timestamp) const;
int size_in_bytes() const { return size_in_bytes_; }
private:
typedef std::map<base::TimeDelta, int> KeyframeMap;
// Seeks the range to the next keyframe after |timestamp|. If
// |skip_given_timestamp| is true, the seek will go to a keyframe with a
// timestamp strictly greater than |timestamp|.
void SeekAhead(base::TimeDelta timestamp, bool skip_given_timestamp);
// Returns an iterator in |buffers_| pointing to the buffer at |timestamp|.
// If |skip_given_timestamp| is true, this returns the first buffer with
// timestamp greater than |timestamp|.
BufferQueue::iterator GetBufferItrAt(
base::TimeDelta timestamp, bool skip_given_timestamp);
// Returns an iterator in |keyframe_map_| pointing to the next keyframe after
// |timestamp|. If |skip_given_timestamp| is true, this returns the first
// keyframe with a timestamp strictly greater than |timestamp|.
KeyframeMap::iterator GetFirstKeyframeAt(
base::TimeDelta timestamp, bool skip_given_timestamp);
// Returns an iterator in |keyframe_map_| pointing to the first keyframe
// before or at |timestamp|.
KeyframeMap::iterator GetFirstKeyframeBefore(base::TimeDelta timestamp);
// Helper method to delete buffers in |buffers_| starting at
// |starting_point|, an iterator in |buffers_|.
bool TruncateAt(const BufferQueue::iterator& starting_point,
BufferQueue* deleted_buffers);
// Frees the buffers in |buffers_| from [|start_point|,|ending_point|) and
// updates the |size_in_bytes_| accordingly. Does not update |keyframe_map_|.
void FreeBufferRange(const BufferQueue::iterator& starting_point,
const BufferQueue::iterator& ending_point);
// Returns the distance in time estimating how far from the beginning or end
// of this range a buffer can be to considered in the range.
base::TimeDelta GetFudgeRoom() const;
// Returns the approximate duration of a buffer in this range.
base::TimeDelta GetApproximateDuration() const;
// An ordered list of buffers in this range.
BufferQueue buffers_;
// Maps keyframe timestamps to its index position in |buffers_|.
KeyframeMap keyframe_map_;
// Index base of all positions in |keyframe_map_|. In other words, the
// real position of entry |k| of |keyframe_map_| in the range is:
// keyframe_map_[k] - keyframe_map_index_base_
int keyframe_map_index_base_;
// Index into |buffers_| for the next buffer to be returned by
// GetNextBuffer(), set to -1 before Seek().
int next_buffer_index_;
// True if the range needs to wait for the next keyframe to be appended before
// returning buffers from GetNextBuffer().
bool waiting_for_keyframe_;
// If |waiting_for_keyframe_| is true, this range will wait for the next
// keyframe with timestamp >= |next_keyframe_timestamp_|.
base::TimeDelta next_keyframe_timestamp_;
// If the first buffer in this range is the beginning of a media segment,
// |media_segment_start_time_| is the time when the media segment begins.
// |media_segment_start_time_| may be <= the timestamp of the first buffer in
// |buffers_|. |media_segment_start_time_| is kNoTimestamp() if this range
// does not start at the beginning of a media segment, which can only happen
// garbage collection or after an end overlap that results in a split range
// (we don't have a way of knowing the media segment timestamp for the new
// range).
base::TimeDelta media_segment_start_time_;
// Called to get the largest interbuffer distance seen so far in the stream.
InterbufferDistanceCB interbuffer_distance_cb_;
// Stores the amount of memory taken up by the data in |buffers_|.
int size_in_bytes_;
DISALLOW_COPY_AND_ASSIGN(SourceBufferRange);
};
} // namespace media
// Helper method that returns true if |ranges| is sorted in increasing order,
// false otherwise.
static bool IsRangeListSorted(
const std::list<media::SourceBufferRange*>& ranges) {
base::TimeDelta prev = media::kNoTimestamp();
for (std::list<media::SourceBufferRange*>::const_iterator itr =
ranges.begin(); itr != ranges.end(); ++itr) {
if (prev != media::kNoTimestamp() && prev >= (*itr)->GetStartTimestamp())
return false;
prev = (*itr)->GetEndTimestamp();
}
return true;
}
// Comparison function for two Buffers based on timestamp.
static bool BufferComparator(
const scoped_refptr<media::StreamParserBuffer>& first,
const scoped_refptr<media::StreamParserBuffer>& second) {
return first->GetDecodeTimestamp() < second->GetDecodeTimestamp();
}
// Returns an estimate of how far from the beginning or end of a range a buffer
// can be to still be considered in the range, given the |approximate_duration|
// of a buffer in the stream.
static base::TimeDelta ComputeFudgeRoom(base::TimeDelta approximate_duration) {
// Because we do not know exactly when is the next timestamp, any buffer
// that starts within 2x the approximate duration of a buffer is considered
// within this range.
return 2 * approximate_duration;
}
// An arbitrarily-chosen number to estimate the duration of a buffer if none
// is set and there's not enough information to get a better estimate.
static int kDefaultBufferDurationInMs = 125;
// The amount of time the beginning of the buffered data can differ from the
// start time in order to still be considered the start of stream.
static base::TimeDelta kSeekToStartFudgeRoom() {
return base::TimeDelta::FromMilliseconds(1000);
}
// The maximum amount of data in bytes the stream will keep in memory.
// 12MB: approximately 5 minutes of 320Kbps content.
// 150MB: approximately 5 minutes of 4Mbps content.
#if !defined(__LB_SHELL__) || defined(COBALT)
static const int kDefaultAudioMemoryLimit = 12 * 1024 * 1024;
static const int kDefaultVideoMemoryLimit = 150 * 1024 * 1024;
#endif
namespace media {
#if defined(__LB_SHELL__) || defined(COBALT)
SourceBufferStream::SourceBufferStream(
const AudioDecoderConfig& audio_config,
const LogCB& log_cb)
: log_cb_(log_cb),
current_config_index_(0),
append_config_index_(0),
seek_pending_(false),
seek_buffer_timestamp_(kNoTimestamp()),
selected_range_(NULL),
media_segment_start_time_(kNoTimestamp()),
range_for_next_append_(ranges_.end()),
new_media_segment_(false),
last_buffer_timestamp_(kNoTimestamp()),
max_interbuffer_distance_(kNoTimestamp()),
#if defined(__LB_SHELL__) || defined(COBALT)
memory_limit_(ShellMediaPlatform::Instance()->
GetSourceBufferStreamAudioMemoryLimit()),
#else // defined(__LB_SHELL__) || defined(COBALT)
memory_limit_(kDefaultAudioMemoryLimit),
#endif // defined(__LB_SHELL__) || defined(COBALT)
config_change_pending_(false) {
DCHECK(audio_config.IsValidConfig());
audio_configs_.push_back(new AudioDecoderConfig());
audio_configs_.back()->CopyFrom(audio_config);
}
SourceBufferStream::SourceBufferStream(
const VideoDecoderConfig& video_config,
const LogCB& log_cb)
: log_cb_(log_cb),
current_config_index_(0),
append_config_index_(0),
seek_pending_(false),
seek_buffer_timestamp_(kNoTimestamp()),
selected_range_(NULL),
media_segment_start_time_(kNoTimestamp()),
range_for_next_append_(ranges_.end()),
new_media_segment_(false),
last_buffer_timestamp_(kNoTimestamp()),
max_interbuffer_distance_(kNoTimestamp()),
#if defined(__LB_SHELL__) || defined(COBALT)
memory_limit_(ShellMediaPlatform::Instance()->
GetSourceBufferStreamVideoMemoryLimit()),
#else // defined(__LB_SHELL__) || defined(COBALT)
memory_limit_(kDefaultVideoMemoryLimit),
#endif // defined(__LB_SHELL__) || defined(COBALT)
config_change_pending_(false) {
DCHECK(video_config.IsValidConfig());
video_configs_.push_back(new VideoDecoderConfig());
video_configs_.back()->CopyFrom(video_config);
}
#else
SourceBufferStream::SourceBufferStream(const AudioDecoderConfig& audio_config,
const LogCB& log_cb)
: log_cb_(log_cb),
current_config_index_(0),
append_config_index_(0),
seek_pending_(false),
seek_buffer_timestamp_(kNoTimestamp()),
selected_range_(NULL),
media_segment_start_time_(kNoTimestamp()),
range_for_next_append_(ranges_.end()),
new_media_segment_(false),
last_buffer_timestamp_(kNoTimestamp()),
max_interbuffer_distance_(kNoTimestamp()),
memory_limit_(kDefaultAudioMemoryLimit),
config_change_pending_(false) {
DCHECK(audio_config.IsValidConfig());
audio_configs_.push_back(new AudioDecoderConfig());
audio_configs_.back()->CopyFrom(audio_config);
}
SourceBufferStream::SourceBufferStream(const VideoDecoderConfig& video_config,
const LogCB& log_cb)
: log_cb_(log_cb),
current_config_index_(0),
append_config_index_(0),
seek_pending_(false),
seek_buffer_timestamp_(kNoTimestamp()),
selected_range_(NULL),
media_segment_start_time_(kNoTimestamp()),
range_for_next_append_(ranges_.end()),
new_media_segment_(false),
last_buffer_timestamp_(kNoTimestamp()),
max_interbuffer_distance_(kNoTimestamp()),
memory_limit_(kDefaultVideoMemoryLimit),
config_change_pending_(false) {
DCHECK(video_config.IsValidConfig());
video_configs_.push_back(new VideoDecoderConfig());
video_configs_.back()->CopyFrom(video_config);
}
#endif
SourceBufferStream::~SourceBufferStream() {
while (!ranges_.empty()) {
delete ranges_.front();
ranges_.pop_front();
}
STLDeleteElements(&audio_configs_);
STLDeleteElements(&video_configs_);
}
void SourceBufferStream::OnNewMediaSegment(
base::TimeDelta media_segment_start_time) {
media_segment_start_time_ = media_segment_start_time;
new_media_segment_ = true;
RangeList::iterator last_range = range_for_next_append_;
range_for_next_append_ = FindExistingRangeFor(media_segment_start_time);
// Only reset |last_buffer_timestamp_| if this new media segment is not
// adjacent to the previous media segment appended to the stream.
if (range_for_next_append_ == ranges_.end() ||
!AreAdjacentInSequence(
last_buffer_timestamp_, media_segment_start_time)) {
last_buffer_timestamp_ = kNoTimestamp();
} else {
DCHECK(last_range == range_for_next_append_);
}
}
bool SourceBufferStream::Append(
const SourceBufferStream::BufferQueue& buffers) {
DCHECK(!buffers.empty());
DCHECK(media_segment_start_time_ != kNoTimestamp());
// Log if new media segment doesn't begin with a keyframe.
if (new_media_segment_ && !buffers.front()->IsKeyframe()) {
MEDIA_LOG(log_cb_) << "Media segment did not begin with keyframe.";
}
// Buffers within a media segment should be monotonically increasing.
if (!IsMonotonicallyIncreasing(buffers)) {
MEDIA_LOG(log_cb_) << "Buffers were not monotonically increasing.";
return false;
}
if (media_segment_start_time_ < base::TimeDelta() ||
buffers.front()->GetDecodeTimestamp() < base::TimeDelta()) {
MEDIA_LOG(log_cb_)
<< "Cannot append a media segment with negative timestamps.";
return false;
}
UpdateMaxInterbufferDistance(buffers);
SetConfigIds(buffers);
// Save a snapshot of stream state before range modifications are made.
base::TimeDelta next_buffer_timestamp = GetNextBufferTimestamp();
base::TimeDelta end_buffer_timestamp = GetEndBufferTimestamp();
bool deleted_next_buffer = false;
BufferQueue deleted_buffers;
RangeList::iterator range_for_new_buffers = range_for_next_append_;
// If there's a range for |buffers|, insert |buffers| accordingly. Otherwise,
// create a new range with |buffers|.
if (range_for_new_buffers != ranges_.end()) {
InsertIntoExistingRange(range_for_new_buffers, buffers,
&deleted_next_buffer, &deleted_buffers);
} else {
DCHECK(new_media_segment_);
#if defined(__LB_SHELL__) || defined(COBALT)
range_for_new_buffers =
AddToRanges(new SourceBufferRange(
buffers, media_segment_start_time_,
base::Bind(&SourceBufferStream::GetMaxInterbufferDistance,
base::Unretained(this))));
#else
range_for_new_buffers =
AddToRanges(new SourceBufferRange(
buffers, media_segment_start_time_,
base::Bind(&SourceBufferStream::GetMaxInterbufferDistance,
base::Unretained(this))));
#endif
}
range_for_next_append_ = range_for_new_buffers;
new_media_segment_ = false;
last_buffer_timestamp_ = buffers.back()->GetDecodeTimestamp();
// Resolve overlaps.
ResolveCompleteOverlaps(
range_for_new_buffers, &deleted_next_buffer, &deleted_buffers);
ResolveEndOverlap(
range_for_new_buffers, &deleted_next_buffer, &deleted_buffers);
MergeWithAdjacentRangeIfNecessary(range_for_new_buffers);
// Seek to try to fulfill a previous call to Seek().
if (seek_pending_) {
DCHECK(!selected_range_);
DCHECK(!deleted_next_buffer);
Seek(seek_buffer_timestamp_);
}
// Seek because the Append() has deleted the buffer that would have been
// returned in the next call to GetNextBuffer().
if (deleted_next_buffer) {
DCHECK(!seek_pending_);
SetSelectedRange(*range_for_new_buffers);
if (next_buffer_timestamp != kNoTimestamp()) {
// Seek ahead to the keyframe at or after |next_buffer_timestamp|, the
// timestamp of the deleted next buffer.
selected_range_->SeekAheadTo(next_buffer_timestamp);
// Update track buffer with non-keyframe buffers leading up to the current
// position of |selected_range_|.
PruneTrackBuffer();
if (!deleted_buffers.empty())
UpdateTrackBuffer(deleted_buffers);
} else {
// If |next_buffer_timestamp| is kNoTimestamp(), it means the range
// we've overlapped didn't actually have the next buffer buffered, and it
// was waiting for the next buffer whose timestamp was greater than
// |end_buffer_timestamp|. Seek the |selected_range_| to the next keyframe
// after |end_buffer_timestamp|.
DCHECK(track_buffer_.empty());
DCHECK(deleted_buffers.empty());
selected_range_->SeekAheadPast(end_buffer_timestamp);
}
}
GarbageCollectIfNeeded();
DCHECK(IsRangeListSorted(ranges_));
DCHECK(OnlySelectedRangeIsSeeked());
return true;
}
void SourceBufferStream::ResetSeekState() {
SetSelectedRange(NULL);
track_buffer_.clear();
config_change_pending_ = false;
}
bool SourceBufferStream::ShouldSeekToStartOfBuffered(
base::TimeDelta seek_timestamp) const {
if (ranges_.empty())
return false;
base::TimeDelta beginning_of_buffered =
ranges_.front()->GetStartTimestamp();
return (seek_timestamp <= beginning_of_buffered &&
beginning_of_buffered < kSeekToStartFudgeRoom());
}
bool SourceBufferStream::IsMonotonicallyIncreasing(
const BufferQueue& buffers) const {
DCHECK(!buffers.empty());
base::TimeDelta prev_timestamp = last_buffer_timestamp_;
for (BufferQueue::const_iterator itr = buffers.begin();
itr != buffers.end(); ++itr) {
base::TimeDelta current_timestamp = (*itr)->GetDecodeTimestamp();
DCHECK(current_timestamp != kNoTimestamp());
if (prev_timestamp != kNoTimestamp() && current_timestamp < prev_timestamp)
return false;
prev_timestamp = current_timestamp;
}
return true;
}
bool SourceBufferStream::OnlySelectedRangeIsSeeked() const {
for (RangeList::const_iterator itr = ranges_.begin();
itr != ranges_.end(); ++itr) {
if ((*itr)->HasNextBufferPosition() && (*itr) != selected_range_)
return false;
}
return !selected_range_ || selected_range_->HasNextBufferPosition();
}
void SourceBufferStream::UpdateMaxInterbufferDistance(
const BufferQueue& buffers) {
DCHECK(!buffers.empty());
base::TimeDelta prev_timestamp = last_buffer_timestamp_;
for (BufferQueue::const_iterator itr = buffers.begin();
itr != buffers.end(); ++itr) {
base::TimeDelta current_timestamp = (*itr)->GetDecodeTimestamp();
DCHECK(current_timestamp != kNoTimestamp());
base::TimeDelta interbuffer_distance;
// WebMStreamParser in M25 doesn't guarantee that a duration is always set.
if ((*itr)->GetDuration() != kNoTimestamp())
interbuffer_distance = (*itr)->GetDuration();
if (prev_timestamp != kNoTimestamp()) {
interbuffer_distance =
std::max(current_timestamp - prev_timestamp, interbuffer_distance);
}
if (interbuffer_distance > base::TimeDelta()) {
if (max_interbuffer_distance_ == kNoTimestamp()) {
max_interbuffer_distance_ = interbuffer_distance;
} else {
max_interbuffer_distance_ =
std::max(max_interbuffer_distance_, interbuffer_distance);
}
}
prev_timestamp = current_timestamp;
}
}
void SourceBufferStream::SetConfigIds(const BufferQueue& buffers) {
for (BufferQueue::const_iterator itr = buffers.begin();
itr != buffers.end(); ++itr) {
(*itr)->SetConfigId(append_config_index_);
}
}
void SourceBufferStream::GarbageCollectIfNeeded() {
// Compute size of |ranges_|.
int ranges_size = 0;
for (RangeList::iterator itr = ranges_.begin(); itr != ranges_.end(); ++itr)
ranges_size += (*itr)->size_in_bytes();
// Return if we're under or at the memory limit.
if (ranges_size <= memory_limit_)
return;
LogMediaSourceTimeRanges("before garbage collect", GetBufferedTime());
int bytes_to_free = ranges_size - memory_limit_;
// Begin deleting from the front.
int bytes_freed = FreeBuffers(bytes_to_free, false);
LogMediaSourceTimeRanges("after garbage collect from front",
GetBufferedTime());
// Begin deleting from the back.
if (bytes_to_free - bytes_freed > 0) {
FreeBuffers(bytes_to_free - bytes_freed, true);
LogMediaSourceTimeRanges("after garbage collect from back",
GetBufferedTime());
}
}
int SourceBufferStream::FreeBuffers(int total_bytes_to_free,
bool reverse_direction) {
DCHECK_GT(total_bytes_to_free, 0);
int bytes_to_free = total_bytes_to_free;
int bytes_freed = 0;
// This range will save the last GOP appended to |range_for_next_append_|
// if the buffers surrounding it get deleted during garbage collection.
SourceBufferRange* new_range_for_append = NULL;
while (!ranges_.empty() && bytes_to_free > 0) {
SourceBufferRange* current_range = NULL;
BufferQueue buffers;
int bytes_deleted = 0;
if (reverse_direction) {
current_range = ranges_.back();
if (current_range->LastGOPContainsNextBufferPosition()) {
DCHECK_EQ(current_range, selected_range_);
break;
}
bytes_deleted = current_range->DeleteGOPFromBack(&buffers);
} else {
current_range = ranges_.front();
if (current_range->FirstGOPContainsNextBufferPosition()) {
DCHECK_EQ(current_range, selected_range_);
break;
}
bytes_deleted = current_range->DeleteGOPFromFront(&buffers);
}
// Check to see if we've just deleted the GOP that was last appended.
if (buffers.back()->GetDecodeTimestamp() == last_buffer_timestamp_) {
DCHECK(last_buffer_timestamp_ != kNoTimestamp());
DCHECK(!new_range_for_append);
// Create a new range containing these buffers.
#if defined(__LB_SHELL__) || defined(COBALT)
new_range_for_append = new SourceBufferRange(
buffers, kNoTimestamp(),
base::Bind(&SourceBufferStream::GetMaxInterbufferDistance,
base::Unretained(this)));
#else
new_range_for_append = new SourceBufferRange(
buffers, kNoTimestamp(),
base::Bind(&SourceBufferStream::GetMaxInterbufferDistance,
base::Unretained(this)));
#endif
range_for_next_append_ = ranges_.end();
} else {
bytes_to_free -= bytes_deleted;
bytes_freed += bytes_deleted;
}
if (current_range->size_in_bytes() == 0) {
DCHECK_NE(current_range, selected_range_);
DCHECK(range_for_next_append_ == ranges_.end() ||
*range_for_next_append_ != current_range);
delete current_range;
reverse_direction ? ranges_.pop_back() : ranges_.pop_front();
}
}
// Insert |new_range_for_append| into |ranges_|, if applicable.
if (new_range_for_append) {
range_for_next_append_ = AddToRanges(new_range_for_append);
DCHECK(range_for_next_append_ != ranges_.end());
// Check to see if we need to merge |new_range_for_append| with the range
// before or after it. |new_range_for_append| is created whenever the last
// GOP appended is encountered, regardless of whether any buffers after it
// are ultimately deleted. Merging is necessary if there were no buffers
// (or very few buffers) deleted after creating |new_range_for_append|.
if (range_for_next_append_ != ranges_.begin()) {
RangeList::iterator range_before_next = range_for_next_append_;
--range_before_next;
MergeWithAdjacentRangeIfNecessary(range_before_next);
}
MergeWithAdjacentRangeIfNecessary(range_for_next_append_);
}
return bytes_freed;
}
void SourceBufferStream::InsertIntoExistingRange(
const RangeList::iterator& range_for_new_buffers_itr,
const BufferQueue& new_buffers,
bool* deleted_next_buffer, BufferQueue* deleted_buffers) {
DCHECK(deleted_next_buffer);
DCHECK(deleted_buffers);
SourceBufferRange* range_for_new_buffers = *range_for_new_buffers_itr;
if (last_buffer_timestamp_ != kNoTimestamp()) {
// Clean up the old buffers between the last appended buffer and the
// beginning of |new_buffers|.
*deleted_next_buffer =
DeleteBetween(
range_for_new_buffers, last_buffer_timestamp_,
new_buffers.front()->GetDecodeTimestamp(), true,
deleted_buffers);
}
// If we cannot append the |new_buffers| to the end of the existing range,
// this is either a start overlap or an middle overlap. Delete the buffers
// that |new_buffers| overlaps.
if (!range_for_new_buffers->CanAppendBuffersToEnd(new_buffers)) {
*deleted_next_buffer |=
DeleteBetween(
range_for_new_buffers, new_buffers.front()->GetDecodeTimestamp(),
new_buffers.back()->GetDecodeTimestamp(), false,
deleted_buffers);
}
range_for_new_buffers->AppendBuffersToEnd(new_buffers);
}
bool SourceBufferStream::DeleteBetween(
SourceBufferRange* range, base::TimeDelta start_timestamp,
base::TimeDelta end_timestamp, bool is_range_exclusive,
BufferQueue* deleted_buffers) {
SourceBufferRange* new_next_range =
range->SplitRange(end_timestamp, is_range_exclusive);
if (new_next_range)
AddToRanges(new_next_range);
BufferQueue saved_buffers;
bool deleted_next_buffer =
range->TruncateAt(start_timestamp, &saved_buffers, is_range_exclusive);
if (selected_range_ != range)
return deleted_next_buffer;
DCHECK(deleted_buffers->empty());
*deleted_buffers = saved_buffers;
// If the next buffer position has transferred to the split range, set the
// selected range accordingly.
if (new_next_range && new_next_range->HasNextBufferPosition()) {
DCHECK(!range->HasNextBufferPosition());
DCHECK(!deleted_next_buffer);
SetSelectedRange(new_next_range);
}
return deleted_next_buffer;
}
bool SourceBufferStream::AreAdjacentInSequence(
base::TimeDelta first_timestamp, base::TimeDelta second_timestamp) const {
return first_timestamp < second_timestamp &&
second_timestamp <=
first_timestamp + ComputeFudgeRoom(GetMaxInterbufferDistance());
}
void SourceBufferStream::ResolveCompleteOverlaps(
const RangeList::iterator& range_with_new_buffers_itr,
bool* deleted_next_buffer, BufferQueue* deleted_buffers) {
DCHECK(deleted_next_buffer);
DCHECK(deleted_buffers);
SourceBufferRange* range_with_new_buffers = *range_with_new_buffers_itr;
RangeList::iterator next_range_itr = range_with_new_buffers_itr;
++next_range_itr;
while (next_range_itr != ranges_.end() &&
range_with_new_buffers->CompletelyOverlaps(**next_range_itr)) {
if (*next_range_itr == selected_range_) {
DCHECK(!*deleted_next_buffer);
*deleted_next_buffer = selected_range_->DeleteAll(deleted_buffers);
DCHECK(*deleted_next_buffer);
SetSelectedRange(NULL);
}
delete *next_range_itr;
next_range_itr = ranges_.erase(next_range_itr);
}
}
void SourceBufferStream::ResolveEndOverlap(
const RangeList::iterator& range_with_new_buffers_itr,
bool* deleted_next_buffer, BufferQueue* deleted_buffers) {
DCHECK(deleted_next_buffer);
DCHECK(deleted_buffers);
SourceBufferRange* range_with_new_buffers = *range_with_new_buffers_itr;
RangeList::iterator next_range_itr = range_with_new_buffers_itr;
++next_range_itr;
if (next_range_itr == ranges_.end() ||
!range_with_new_buffers->EndOverlaps(**next_range_itr)) {
return;
}
// Split the overlapped range after |range_with_new_buffers|'s last buffer
// overlaps. Now |overlapped_range| contains only the buffers that do not
// belong in |ranges_| anymore, and |new_next_range| contains buffers that
// go after |range_with_new_buffers| (without overlap).
scoped_ptr<SourceBufferRange> overlapped_range(*next_range_itr);
next_range_itr = ranges_.erase(next_range_itr);
SourceBufferRange* new_next_range =
overlapped_range->SplitRange(
range_with_new_buffers->GetEndTimestamp(), true);
// If there were non-overlapped buffers, add the new range to |ranges_|.
if (new_next_range)
AddToRanges(new_next_range);
// If we didn't overlap a selected range, return.
if (selected_range_ != overlapped_range.get())
return;
// If the |overlapped_range| transfers its next buffer position to
// |new_next_range|, make |new_next_range| the |selected_range_|.
if (new_next_range && new_next_range->HasNextBufferPosition()) {
DCHECK(!overlapped_range->HasNextBufferPosition());
SetSelectedRange(new_next_range);
return;
}
// Save the buffers in |overlapped_range|.
DCHECK(!*deleted_next_buffer);
DCHECK_EQ(overlapped_range.get(), selected_range_);
*deleted_next_buffer = overlapped_range->DeleteAll(deleted_buffers);
DCHECK(*deleted_next_buffer);
// |overlapped_range| will be deleted, so set |selected_range_| to NULL.
SetSelectedRange(NULL);
}
void SourceBufferStream::PruneTrackBuffer() {
DCHECK(selected_range_);
DCHECK(selected_range_->HasNextBufferPosition());
base::TimeDelta next_timestamp = selected_range_->GetNextTimestamp();
// If we don't have the next timestamp, we don't have anything to delete.
if (next_timestamp == kNoTimestamp())
return;
while (!track_buffer_.empty() &&
track_buffer_.back()->GetDecodeTimestamp() >= next_timestamp) {
track_buffer_.pop_back();
}
}
void SourceBufferStream::UpdateTrackBuffer(const BufferQueue& deleted_buffers) {
DCHECK(!deleted_buffers.empty());
DCHECK(selected_range_);
DCHECK(selected_range_->HasNextBufferPosition());
base::TimeDelta next_keyframe_timestamp = selected_range_->GetNextTimestamp();
base::TimeDelta start_of_deleted =
deleted_buffers.front()->GetDecodeTimestamp();
// |deleted_buffers| should always come after the buffers in |track_buffer|.
if (!track_buffer_.empty())
DCHECK(track_buffer_.back()->GetDecodeTimestamp() < start_of_deleted);
// If there is no gap between what was deleted and what was added, nothing
// should be added to the track buffer.
if (selected_range_->HasNextBuffer() &&
next_keyframe_timestamp <= start_of_deleted) {
return;
}
// If the |selected_range_| is ready to return data, fill the track buffer
// with all buffers that come before |next_keyframe_timestamp| and return.
if (selected_range_->HasNextBuffer()) {
for (BufferQueue::const_iterator itr = deleted_buffers.begin();
itr != deleted_buffers.end() &&
(*itr)->GetDecodeTimestamp() < next_keyframe_timestamp; ++itr) {
track_buffer_.push_back(*itr);
}
return;
}
// Otherwise, the |selected_range_| is not ready to return data, so add all
// the deleted buffers into the |track_buffer_|.
track_buffer_.insert(track_buffer_.end(),
deleted_buffers.begin(), deleted_buffers.end());
// See if the next range contains the keyframe after the end of the
// |track_buffer_|, and if so, change |selected_range_|.
RangeList::iterator next_range_itr = ++(GetSelectedRangeItr());
if (next_range_itr == ranges_.end())
return;
(*next_range_itr)->SeekAheadPast(
track_buffer_.back()->GetDecodeTimestamp());
if (!(*next_range_itr)->HasNextBuffer())
return;
if (!selected_range_->IsNextInSequence(
track_buffer_.back(), (*next_range_itr)->GetNextTimestamp())) {
(*next_range_itr)->ResetNextBufferPosition();
return;
}
SetSelectedRange(*next_range_itr);
}
void SourceBufferStream::MergeWithAdjacentRangeIfNecessary(
const RangeList::iterator& range_with_new_buffers_itr) {
SourceBufferRange* range_with_new_buffers = *range_with_new_buffers_itr;
RangeList::iterator next_range_itr = range_with_new_buffers_itr;
++next_range_itr;
if (next_range_itr != ranges_.end() &&
range_with_new_buffers->CanAppendRangeToEnd(**next_range_itr)) {
bool transfer_current_position = selected_range_ == *next_range_itr;
range_with_new_buffers->AppendRangeToEnd(**next_range_itr,
transfer_current_position);
// Update |selected_range_| pointer if |range| has become selected after
// merges.
if (transfer_current_position)
SetSelectedRange(range_with_new_buffers);
if (next_range_itr == range_for_next_append_)
range_for_next_append_ = range_with_new_buffers_itr;
delete *next_range_itr;
ranges_.erase(next_range_itr);
}
}
void SourceBufferStream::Seek(base::TimeDelta timestamp) {
DCHECK(timestamp >= base::TimeDelta());
ResetSeekState();
if (ShouldSeekToStartOfBuffered(timestamp)) {
SetSelectedRange(ranges_.front());
ranges_.front()->SeekToStart();
seek_pending_ = false;
seek_buffer_timestamp_ = GetNextBufferTimestamp();
return;
}
seek_buffer_timestamp_ = timestamp;
seek_pending_ = true;
RangeList::iterator itr = ranges_.end();
for (itr = ranges_.begin(); itr != ranges_.end(); ++itr) {
if ((*itr)->CanSeekTo(timestamp))
break;
}
if (itr == ranges_.end())
return;
SetSelectedRange(*itr);
selected_range_->Seek(timestamp);
seek_pending_ = false;
seek_buffer_timestamp_ = GetNextBufferTimestamp();
}
bool SourceBufferStream::IsSeekPending() const {
return seek_pending_;
}
base::TimeDelta SourceBufferStream::GetSeekKeyframeTimestamp() const {
DCHECK(!IsSeekPending());
return seek_buffer_timestamp_;
}
void SourceBufferStream::OnSetDuration(base::TimeDelta duration) {
RangeList::iterator itr = ranges_.end();
for (itr = ranges_.begin(); itr != ranges_.end(); ++itr) {
if ((*itr)->GetEndTimestamp() > duration)
break;
}
if (itr == ranges_.end())
return;
// Need to partially truncate this range.
if ((*itr)->GetStartTimestamp() < duration) {
bool deleted_seek_point = (*itr)->TruncateAt(duration, NULL, false);
if (deleted_seek_point)
ResetSeekState();
++itr;
}
// Delete all ranges that begin after |duration|.
while (itr != ranges_.end()) {
// If we're about to delete the selected range, also reset the seek state.
DCHECK((*itr)->GetStartTimestamp() >= duration);
if (*itr== selected_range_)
ResetSeekState();
delete *itr;
itr = ranges_.erase(itr);
}
}
SourceBufferStream::Status SourceBufferStream::GetNextBuffer(
scoped_refptr<StreamParserBuffer>* out_buffer) {
CHECK(!config_change_pending_);
if (!track_buffer_.empty()) {
DCHECK(selected_range_);
if (track_buffer_.front()->GetConfigId() != current_config_index_) {
config_change_pending_ = true;
DVLOG(1) << "Config change (track buffer config ID does not match).";
return kConfigChange;
}
*out_buffer = track_buffer_.front();
track_buffer_.pop_front();
return kSuccess;
}
if (!selected_range_ || !selected_range_->HasNextBuffer())
return kNeedBuffer;
if (selected_range_->GetNextConfigId() != current_config_index_) {
config_change_pending_ = true;
DVLOG(1) << "Config change (selected range config ID does not match).";
return kConfigChange;
}
CHECK(selected_range_->GetNextBuffer(out_buffer));
return kSuccess;
}
base::TimeDelta SourceBufferStream::GetNextBufferTimestamp() {
if (!selected_range_) {
DCHECK(track_buffer_.empty());
return kNoTimestamp();
}
DCHECK(selected_range_->HasNextBufferPosition());
if (!track_buffer_.empty())
return track_buffer_.front()->GetDecodeTimestamp();
return selected_range_->GetNextTimestamp();
}
base::TimeDelta SourceBufferStream::GetEndBufferTimestamp() {
if (!selected_range_)
return kNoTimestamp();
return selected_range_->GetEndTimestamp();
}
SourceBufferStream::RangeList::iterator
SourceBufferStream::FindExistingRangeFor(base::TimeDelta start_timestamp) {
for (RangeList::iterator itr = ranges_.begin(); itr != ranges_.end(); ++itr) {
if ((*itr)->BelongsToRange(start_timestamp))
return itr;
}
return ranges_.end();
}
SourceBufferStream::RangeList::iterator
SourceBufferStream::AddToRanges(SourceBufferRange* new_range) {
base::TimeDelta start_timestamp = new_range->GetStartTimestamp();
RangeList::iterator itr = ranges_.end();
for (itr = ranges_.begin(); itr != ranges_.end(); ++itr) {
if ((*itr)->GetStartTimestamp() > start_timestamp)
break;
}
return ranges_.insert(itr, new_range);
}
SourceBufferStream::RangeList::iterator
SourceBufferStream::GetSelectedRangeItr() {
DCHECK(selected_range_);
RangeList::iterator itr = ranges_.end();
for (itr = ranges_.begin(); itr != ranges_.end(); ++itr) {
if (*itr == selected_range_)
break;
}
DCHECK(itr != ranges_.end());
return itr;
}
void SourceBufferStream::SetSelectedRange(SourceBufferRange* range) {
if (selected_range_)
selected_range_->ResetNextBufferPosition();
selected_range_ = range;
}
Ranges<base::TimeDelta> SourceBufferStream::GetBufferedTime() const {
Ranges<base::TimeDelta> ranges;
for (RangeList::const_iterator itr = ranges_.begin();
itr != ranges_.end(); ++itr) {
ranges.Add((*itr)->GetStartTimestamp(), (*itr)->GetBufferedEndTimestamp());
}
return ranges;
}
bool SourceBufferStream::IsEndSelected() const {
return ranges_.empty() || selected_range_ == ranges_.back();
}
const AudioDecoderConfig& SourceBufferStream::GetCurrentAudioDecoderConfig() {
if (config_change_pending_)
CompleteConfigChange();
return *audio_configs_[current_config_index_];
}
const VideoDecoderConfig& SourceBufferStream::GetCurrentVideoDecoderConfig() {
if (config_change_pending_)
CompleteConfigChange();
return *video_configs_[current_config_index_];
}
base::TimeDelta SourceBufferStream::GetMaxInterbufferDistance() const {
if (max_interbuffer_distance_ == kNoTimestamp())
return base::TimeDelta::FromMilliseconds(kDefaultBufferDurationInMs);
return max_interbuffer_distance_;
}
bool SourceBufferStream::UpdateAudioConfig(const AudioDecoderConfig& config) {
DCHECK(!audio_configs_.empty());
DCHECK(video_configs_.empty());
DVLOG(3) << "UpdateAudioConfig.";
if (audio_configs_[0]->codec() != config.codec()) {
MEDIA_LOG(log_cb_) << "Audio codec changes not allowed.";
return false;
}
if (audio_configs_[0]->samples_per_second() != config.samples_per_second()) {
MEDIA_LOG(log_cb_) << "Audio sample rate changes not allowed.";
return false;
}
if (audio_configs_[0]->channel_layout() != config.channel_layout()) {
MEDIA_LOG(log_cb_) << "Audio channel layout changes not allowed.";
return false;
}
if (audio_configs_[0]->bits_per_channel() != config.bits_per_channel()) {
MEDIA_LOG(log_cb_) << "Audio bits per channel changes not allowed.";
return false;
}
if (audio_configs_[0]->is_encrypted() != config.is_encrypted()) {
MEDIA_LOG(log_cb_) << "Audio encryption changes not allowed.";
return false;
}
// Check to see if the new config matches an existing one.
for (size_t i = 0; i < audio_configs_.size(); ++i) {
if (config.Matches(*audio_configs_[i])) {
append_config_index_ = i;
return true;
}
}
// No matches found so let's add this one to the list.
append_config_index_ = audio_configs_.size();
DVLOG(2) << "New audio config - index: " << append_config_index_;
audio_configs_.resize(audio_configs_.size() + 1);
audio_configs_[append_config_index_] = new AudioDecoderConfig();
audio_configs_[append_config_index_]->CopyFrom(config);
return true;
}
bool SourceBufferStream::UpdateVideoConfig(const VideoDecoderConfig& config) {
DCHECK(!video_configs_.empty());
DCHECK(audio_configs_.empty());
DVLOG(3) << "UpdateVideoConfig.";
if (video_configs_[0]->is_encrypted() != config.is_encrypted()) {
MEDIA_LOG(log_cb_) << "Video Encryption changes not allowed.";
return false;
}
if (video_configs_[0]->codec() != config.codec()) {
MEDIA_LOG(log_cb_) << "Video codec changes not allowed.";
return false;
}
if (video_configs_[0]->is_encrypted() != config.is_encrypted()) {
MEDIA_LOG(log_cb_) << "Video encryption changes not allowed.";
return false;
}
// Check to see if the new config matches an existing one.
for (size_t i = 0; i < video_configs_.size(); ++i) {
if (config.Matches(*video_configs_[i])) {
append_config_index_ = i;
return true;
}
}
// No matches found so let's add this one to the list.
append_config_index_ = video_configs_.size();
DVLOG(2) << "New video config - index: " << append_config_index_;
video_configs_.resize(video_configs_.size() + 1);
video_configs_[append_config_index_] = new VideoDecoderConfig();
video_configs_[append_config_index_]->CopyFrom(config);
return true;
}
void SourceBufferStream::CompleteConfigChange() {
config_change_pending_ = false;
if (!track_buffer_.empty()) {
current_config_index_ = track_buffer_.front()->GetConfigId();
return;
}
if (selected_range_ && selected_range_->HasNextBuffer())
current_config_index_ = selected_range_->GetNextConfigId();
}
#if defined(__LB_SHELL__) || defined(COBALT)
SourceBufferRange::SourceBufferRange(
const BufferQueue& new_buffers, base::TimeDelta media_segment_start_time,
const InterbufferDistanceCB& interbuffer_distance_cb)
: keyframe_map_index_base_(0),
next_buffer_index_(-1),
waiting_for_keyframe_(false),
next_keyframe_timestamp_(kNoTimestamp()),
media_segment_start_time_(media_segment_start_time),
interbuffer_distance_cb_(interbuffer_distance_cb),
size_in_bytes_(0) {
DCHECK(!new_buffers.empty());
DCHECK(!interbuffer_distance_cb.is_null());
AppendBuffersToEnd(new_buffers);
}
#else
SourceBufferRange::SourceBufferRange(
const BufferQueue& new_buffers, base::TimeDelta media_segment_start_time,
const InterbufferDistanceCB& interbuffer_distance_cb)
: keyframe_map_index_base_(0),
next_buffer_index_(-1),
waiting_for_keyframe_(false),
next_keyframe_timestamp_(kNoTimestamp()),
media_segment_start_time_(media_segment_start_time),
interbuffer_distance_cb_(interbuffer_distance_cb),
size_in_bytes_(0) {
DCHECK(!new_buffers.empty());
DCHECK(!interbuffer_distance_cb.is_null());
AppendBuffersToEnd(new_buffers);
}
#endif
void SourceBufferRange::AppendBuffersToEnd(const BufferQueue& new_buffers) {
for (BufferQueue::const_iterator itr = new_buffers.begin();
itr != new_buffers.end(); ++itr) {
DCHECK((*itr)->GetDecodeTimestamp() != kNoTimestamp());
buffers_.push_back(*itr);
size_in_bytes_ += (*itr)->GetDataSize();
if ((*itr)->IsKeyframe()) {
keyframe_map_.insert(
std::make_pair((*itr)->GetDecodeTimestamp(),
static_cast<int>(buffers_.size()) - 1 +
keyframe_map_index_base_));
if (waiting_for_keyframe_ &&
(*itr)->GetDecodeTimestamp() >= next_keyframe_timestamp_) {
next_buffer_index_ = buffers_.size() - 1;
next_keyframe_timestamp_ = kNoTimestamp();
waiting_for_keyframe_ = false;
}
}
}
}
void SourceBufferRange::Seek(base::TimeDelta timestamp) {
DCHECK(CanSeekTo(timestamp));
DCHECK(!keyframe_map_.empty());
next_keyframe_timestamp_ = kNoTimestamp();
waiting_for_keyframe_ = false;
KeyframeMap::iterator result = GetFirstKeyframeBefore(timestamp);
next_buffer_index_ = result->second - keyframe_map_index_base_;
DCHECK_LT(next_buffer_index_, static_cast<int>(buffers_.size()));
}
void SourceBufferRange::SeekAheadTo(base::TimeDelta timestamp) {
SeekAhead(timestamp, false);
}
void SourceBufferRange::SeekAheadPast(base::TimeDelta timestamp) {
SeekAhead(timestamp, true);
}
void SourceBufferRange::SeekAhead(base::TimeDelta timestamp,
bool skip_given_timestamp) {
DCHECK(!keyframe_map_.empty());
KeyframeMap::iterator result =
GetFirstKeyframeAt(timestamp, skip_given_timestamp);
// If there isn't a keyframe after |timestamp|, then seek to end and return
// kNoTimestamp to signal such.
if (result == keyframe_map_.end()) {
waiting_for_keyframe_ = true;
next_buffer_index_ = -1;
next_keyframe_timestamp_ = timestamp;
return;
}
next_buffer_index_ = result->second - keyframe_map_index_base_;
DCHECK_LT(next_buffer_index_, static_cast<int>(buffers_.size()));
}
void SourceBufferRange::SeekToStart() {
DCHECK(!buffers_.empty());
next_buffer_index_ = 0;
}
SourceBufferRange* SourceBufferRange::SplitRange(
base::TimeDelta timestamp, bool is_exclusive) {
// Find the first keyframe after |timestamp|. If |is_exclusive|, do not
// include keyframes at |timestamp|.
KeyframeMap::iterator new_beginning_keyframe =
GetFirstKeyframeAt(timestamp, is_exclusive);
// If there is no keyframe after |timestamp|, we can't split the range.
if (new_beginning_keyframe == keyframe_map_.end())
return NULL;
// Remove the data beginning at |keyframe_index| from |buffers_| and save it
// into |removed_buffers|.
int keyframe_index =
new_beginning_keyframe->second - keyframe_map_index_base_;
DCHECK_LT(keyframe_index, static_cast<int>(buffers_.size()));
BufferQueue::iterator starting_point = buffers_.begin() + keyframe_index;
BufferQueue removed_buffers(starting_point, buffers_.end());
keyframe_map_.erase(new_beginning_keyframe, keyframe_map_.end());
FreeBufferRange(starting_point, buffers_.end());
// Create a new range with |removed_buffers|.
#if defined(__LB_SHELL__) || defined(COBALT)
SourceBufferRange* split_range =
new SourceBufferRange(
removed_buffers, kNoTimestamp(), interbuffer_distance_cb_);
#else
SourceBufferRange* split_range =
new SourceBufferRange(
removed_buffers, kNoTimestamp(), interbuffer_distance_cb_);
#endif
// If the next buffer position is now in |split_range|, update the state of
// this range and |split_range| accordingly.
if (next_buffer_index_ >= static_cast<int>(buffers_.size())) {
DCHECK(!waiting_for_keyframe_);
split_range->next_buffer_index_ = next_buffer_index_ - keyframe_index;
ResetNextBufferPosition();
} else if (waiting_for_keyframe_) {
split_range->waiting_for_keyframe_ = true;
split_range->next_keyframe_timestamp_ = next_keyframe_timestamp_;
ResetNextBufferPosition();
}
return split_range;
}
SourceBufferRange::BufferQueue::iterator SourceBufferRange::GetBufferItrAt(
base::TimeDelta timestamp, bool skip_given_timestamp) {
// Need to make a dummy buffer with timestamp |timestamp| in order to search
// the |buffers_| container.
scoped_refptr<StreamParserBuffer> dummy_buffer =
StreamParserBuffer::CopyFrom(NULL, 0, false);
dummy_buffer->SetDecodeTimestamp(timestamp);
if (skip_given_timestamp) {
return std::upper_bound(
buffers_.begin(), buffers_.end(), dummy_buffer, BufferComparator);
}
return std::lower_bound(
buffers_.begin(), buffers_.end(), dummy_buffer, BufferComparator);
}
SourceBufferRange::KeyframeMap::iterator
SourceBufferRange::GetFirstKeyframeAt(base::TimeDelta timestamp,
bool skip_given_timestamp) {
return skip_given_timestamp ?
keyframe_map_.upper_bound(timestamp) :
keyframe_map_.lower_bound(timestamp);
}
SourceBufferRange::KeyframeMap::iterator
SourceBufferRange::GetFirstKeyframeBefore(base::TimeDelta timestamp) {
KeyframeMap::iterator result = keyframe_map_.lower_bound(timestamp);
// lower_bound() returns the first element >= |timestamp|, so we want the
// previous element if it did not return the element exactly equal to
// |timestamp|.
if (result != keyframe_map_.begin() &&
(result == keyframe_map_.end() || result->first != timestamp)) {
--result;
}
return result;
}
bool SourceBufferRange::DeleteAll(BufferQueue* removed_buffers) {
return TruncateAt(buffers_.begin(), removed_buffers);
}
bool SourceBufferRange::TruncateAt(
base::TimeDelta timestamp, BufferQueue* removed_buffers,
bool is_exclusive) {
// Find the place in |buffers_| where we will begin deleting data.
BufferQueue::iterator starting_point =
GetBufferItrAt(timestamp, is_exclusive);
return TruncateAt(starting_point, removed_buffers);
}
int SourceBufferRange::DeleteGOPFromFront(BufferQueue* deleted_buffers) {
DCHECK(!FirstGOPContainsNextBufferPosition());
DCHECK(deleted_buffers);
int buffers_deleted = 0;
int total_bytes_deleted = 0;
KeyframeMap::iterator front = keyframe_map_.begin();
DCHECK(front != keyframe_map_.end());
// Delete the keyframe at the start of |keyframe_map_|.
keyframe_map_.erase(front);
// Now we need to delete all the buffers that depend on the keyframe we've
// just deleted.
int end_index = keyframe_map_.size() > 0 ?
keyframe_map_.begin()->second - keyframe_map_index_base_ :
buffers_.size();
// Delete buffers from the beginning of the buffered range up until (but not
// including) the next keyframe.
for (int i = 0; i < end_index; i++) {
int bytes_deleted = buffers_.front()->GetDataSize();
size_in_bytes_ -= bytes_deleted;
total_bytes_deleted += bytes_deleted;
deleted_buffers->push_back(buffers_.front());
buffers_.pop_front();
++buffers_deleted;
}
// Update |keyframe_map_index_base_| to account for the deleted buffers.
keyframe_map_index_base_ += buffers_deleted;
if (next_buffer_index_ > -1) {
next_buffer_index_ -= buffers_deleted;
DCHECK_GE(next_buffer_index_, 0);
}
// Invalidate media segment start time if we've deleted the first buffer of
// the range.
if (buffers_deleted > 0)
media_segment_start_time_ = kNoTimestamp();
return total_bytes_deleted;
}
int SourceBufferRange::DeleteGOPFromBack(BufferQueue* deleted_buffers) {
DCHECK(!LastGOPContainsNextBufferPosition());
DCHECK(deleted_buffers);
// Remove the last GOP's keyframe from the |keyframe_map_|.
KeyframeMap::iterator back = keyframe_map_.end();
DCHECK_GT(keyframe_map_.size(), 0u);
--back;
// The index of the first buffer in the last GOP is equal to the new size of
// |buffers_| after that GOP is deleted.
size_t goal_size = back->second - keyframe_map_index_base_;
keyframe_map_.erase(back);
int total_bytes_deleted = 0;
while (buffers_.size() != goal_size) {
int bytes_deleted = buffers_.back()->GetDataSize();
size_in_bytes_ -= bytes_deleted;
total_bytes_deleted += bytes_deleted;
// We're removing buffers from the back, so push each removed buffer to the
// front of |deleted_buffers| so that |deleted_buffers| are in nondecreasing
// order.
deleted_buffers->push_front(buffers_.back());
buffers_.pop_back();
}
return total_bytes_deleted;
}
bool SourceBufferRange::FirstGOPContainsNextBufferPosition() const {
if (!HasNextBufferPosition())
return false;
// If there is only one GOP, it must contain the next buffer position.
if (keyframe_map_.size() == 1u)
return true;
KeyframeMap::const_iterator second_gop = keyframe_map_.begin();
++second_gop;
return !waiting_for_keyframe_ &&
next_buffer_index_ < second_gop->second - keyframe_map_index_base_;
}
bool SourceBufferRange::LastGOPContainsNextBufferPosition() const {
if (!HasNextBufferPosition())
return false;
// If there is only one GOP, it must contain the next buffer position.
if (keyframe_map_.size() == 1u)
return true;
KeyframeMap::const_iterator last_gop = keyframe_map_.end();
--last_gop;
return waiting_for_keyframe_ ||
last_gop->second - keyframe_map_index_base_ <= next_buffer_index_;
}
void SourceBufferRange::FreeBufferRange(
const BufferQueue::iterator& starting_point,
const BufferQueue::iterator& ending_point) {
for (BufferQueue::iterator itr = starting_point;
itr != ending_point; ++itr) {
size_in_bytes_ -= (*itr)->GetDataSize();
DCHECK_GE(size_in_bytes_, 0);
}
buffers_.erase(starting_point, ending_point);
}
bool SourceBufferRange::TruncateAt(
const BufferQueue::iterator& starting_point, BufferQueue* removed_buffers) {
DCHECK(!removed_buffers || removed_buffers->empty());
// Return if we're not deleting anything.
if (starting_point == buffers_.end())
return false;
// Reset the next buffer index if we will be deleting the buffer that's next
// in sequence.
bool removed_next_buffer = false;
if (HasNextBufferPosition()) {
base::TimeDelta next_buffer_timestamp = GetNextTimestamp();
if (next_buffer_timestamp == kNoTimestamp() ||
next_buffer_timestamp >= (*starting_point)->GetDecodeTimestamp()) {
if (HasNextBuffer() && removed_buffers) {
int starting_offset = starting_point - buffers_.begin();
int next_buffer_offset = next_buffer_index_ - starting_offset;
DCHECK_GE(next_buffer_offset, 0);
BufferQueue saved(starting_point + next_buffer_offset, buffers_.end());
removed_buffers->swap(saved);
}
ResetNextBufferPosition();
removed_next_buffer = true;
}
}
// Remove keyframes from |starting_point| onward.
KeyframeMap::iterator starting_point_keyframe =
keyframe_map_.lower_bound((*starting_point)->GetDecodeTimestamp());
keyframe_map_.erase(starting_point_keyframe, keyframe_map_.end());
// Remove everything from |starting_point| onward.
FreeBufferRange(starting_point, buffers_.end());
return removed_next_buffer;
}
bool SourceBufferRange::GetNextBuffer(
scoped_refptr<StreamParserBuffer>* out_buffer) {
if (!HasNextBuffer())
return false;
*out_buffer = buffers_.at(next_buffer_index_);
next_buffer_index_++;
return true;
}
bool SourceBufferRange::HasNextBuffer() const {
return next_buffer_index_ >= 0 &&
next_buffer_index_ < static_cast<int>(buffers_.size()) &&
!waiting_for_keyframe_;
}
int SourceBufferRange::GetNextConfigId() const {
DCHECK(HasNextBuffer());
return buffers_.at(next_buffer_index_)->GetConfigId();
}
base::TimeDelta SourceBufferRange::GetNextTimestamp() const {
DCHECK(!buffers_.empty());
DCHECK(HasNextBufferPosition());
if (waiting_for_keyframe_ ||
next_buffer_index_ >= static_cast<int>(buffers_.size())) {
return kNoTimestamp();
}
return buffers_.at(next_buffer_index_)->GetDecodeTimestamp();
}
bool SourceBufferRange::HasNextBufferPosition() const {
return next_buffer_index_ >= 0 || waiting_for_keyframe_;
}
void SourceBufferRange::ResetNextBufferPosition() {
next_buffer_index_ = -1;
waiting_for_keyframe_ = false;
next_keyframe_timestamp_ = kNoTimestamp();
}
void SourceBufferRange::AppendRangeToEnd(const SourceBufferRange& range,
bool transfer_current_position) {
DCHECK(CanAppendRangeToEnd(range));
DCHECK(!buffers_.empty());
if (transfer_current_position)
next_buffer_index_ = range.next_buffer_index_ + buffers_.size();
AppendBuffersToEnd(range.buffers_);
}
bool SourceBufferRange::CanAppendRangeToEnd(
const SourceBufferRange& range) const {
return CanAppendBuffersToEnd(range.buffers_);
}
bool SourceBufferRange::CanAppendBuffersToEnd(
const BufferQueue& buffers) const {
DCHECK(!buffers_.empty());
return IsNextInSequence(buffers_.back(),
buffers.front()->GetDecodeTimestamp());
}
bool SourceBufferRange::BelongsToRange(base::TimeDelta timestamp) const {
DCHECK(!buffers_.empty());
return (IsNextInSequence(buffers_.back(), timestamp) ||
(GetStartTimestamp() <= timestamp && timestamp <= GetEndTimestamp()));
}
bool SourceBufferRange::CanSeekTo(base::TimeDelta timestamp) const {
base::TimeDelta start_timestamp =
std::max(base::TimeDelta(), GetStartTimestamp() - GetFudgeRoom());
return !keyframe_map_.empty() && start_timestamp <= timestamp &&
timestamp < GetBufferedEndTimestamp();
}
bool SourceBufferRange::CompletelyOverlaps(
const SourceBufferRange& range) const {
return GetStartTimestamp() <= range.GetStartTimestamp() &&
GetEndTimestamp() >= range.GetEndTimestamp();
}
bool SourceBufferRange::EndOverlaps(const SourceBufferRange& range) const {
return range.GetStartTimestamp() <= GetEndTimestamp() &&
GetEndTimestamp() < range.GetEndTimestamp();
}
base::TimeDelta SourceBufferRange::GetStartTimestamp() const {
DLOG_IF(WARNING, buffers_.empty()) << "|buffers_| cannot be empty.";
base::TimeDelta start_timestamp = media_segment_start_time_;
if (start_timestamp == kNoTimestamp())
start_timestamp = buffers_.front()->GetDecodeTimestamp();
return start_timestamp;
}
base::TimeDelta SourceBufferRange::GetEndTimestamp() const {
DCHECK(!buffers_.empty());
return buffers_.back()->GetDecodeTimestamp();
}
base::TimeDelta SourceBufferRange::GetBufferedEndTimestamp() const {
DCHECK(!buffers_.empty());
base::TimeDelta duration = buffers_.back()->GetDuration();
if (duration == kNoTimestamp() || duration == base::TimeDelta())
duration = GetApproximateDuration();
return GetEndTimestamp() + duration;
}
bool SourceBufferRange::IsNextInSequence(
const scoped_refptr<media::StreamParserBuffer>& buffer,
base::TimeDelta timestamp) const {
return buffer->GetDecodeTimestamp() < timestamp &&
timestamp <= buffer->GetDecodeTimestamp() + GetFudgeRoom();
}
base::TimeDelta SourceBufferRange::GetFudgeRoom() const {
return ComputeFudgeRoom(GetApproximateDuration());
}
base::TimeDelta SourceBufferRange::GetApproximateDuration() const {
base::TimeDelta max_interbuffer_distance = interbuffer_distance_cb_.Run();
DCHECK(max_interbuffer_distance != kNoTimestamp());
return max_interbuffer_distance;
}
void LogMediaSourceTimeRanges(const std::string& desc,
const Ranges<base::TimeDelta>& time_ranges) {
#if LOG_MEDIA_SOURCE_ACTIVITIES
LOG(INFO) << ("======== " + desc + " ========");
for (size_t i = 0; i < time_ranges.size(); ++i)
LOG(INFO) << "\t\tRange " << i << " : "
<< time_ranges.start(i).InMicroseconds() << " - "
<< time_ranges.end(i).InMicroseconds();
#endif // LOG_MEDIA_SOURCE_ACTIVITIES
}
} // namespace media