Introduce the playback time into the MSE garbage collection.

media/filters/chunk_demuxer.cc

 // 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/chunk_demuxer.h"
 
 #include <algorithm>
 #include <limits>
 #include <list>
 
@@ skipping 87 matching lines @@
       scoped_ptr<StreamParser> stream_parser,
       scoped_ptr<FrameProcessorBase> frame_processor, const LogCB& log_cb,
       const CreateDemuxerStreamCB& create_demuxer_stream_cb);
 
   ~SourceState();
 
   void Init(const StreamParser::InitCB& init_cb,
             bool allow_audio,
             bool allow_video,
             const StreamParser::NeedKeyCB& need_key_cb,
-            const NewTextTrackCB& new_text_track_cb);
+            const NewTextTrackCB& new_text_track_cb,
+            base::TimeDelta* media_time);
 
   // Appends new data to the StreamParser.
   // Returns true if the data was successfully appended. Returns false if an
   // error occurred. |*timestamp_offset| is used and possibly updated by the
   // append. |append_window_start| and |append_window_end| correspond to the MSE
   // spec's similarly named source buffer attributes that are used in coded
   // frame processing.
   bool Append(const uint8* data, size_t length,
               TimeDelta append_window_start,
               TimeDelta append_window_end,
@@ skipping 58 matching lines @@
 
   // Called by the |stream_parser_| at the end of a media segment.
   void OnEndOfMediaSegment();
 
   // Called by the |stream_parser_| when new buffers have been parsed.
   // It processes the new buffers using |frame_processor_|, which includes
   // appending the processed frames to associated demuxer streams for each
   // frame's track.
   // Returns true on a successful call. Returns false if an error occurred while
   // processing the buffers.
-  bool OnNewBuffers(const StreamParser::BufferQueue& audio_buffers,
+  bool OnNewBuffers(base::TimeDelta* media_time,
+                    const StreamParser::BufferQueue& audio_buffers,
                     const StreamParser::BufferQueue& video_buffers,
                     const StreamParser::TextBufferQueueMap& text_map);
 
   void OnSourceInitDone(bool success,
                         const StreamParser::InitParameters& params);
 
   CreateDemuxerStreamCB create_demuxer_stream_cb_;
   NewTextTrackCB new_text_track_cb_;
 
   // During Append(), if OnNewBuffers() coded frame processing updates the
@@ skipping 64 matching lines @@
 SourceState::~SourceState() {
   Shutdown();
 
   STLDeleteValues(&text_stream_map_);
 }
 
 void SourceState::Init(const StreamParser::InitCB& init_cb,
                        bool allow_audio,
                        bool allow_video,
                        const StreamParser::NeedKeyCB& need_key_cb,
-                       const NewTextTrackCB& new_text_track_cb) {
+                       const NewTextTrackCB& new_text_track_cb,
+                       base::TimeDelta* media_time) {
   new_text_track_cb_ = new_text_track_cb;
   init_cb_ = init_cb;
 
   stream_parser_->Init(
       base::Bind(&SourceState::OnSourceInitDone, base::Unretained(this)),
       base::Bind(&SourceState::OnNewConfigs,
                  base::Unretained(this),
                  allow_audio,
                  allow_video),
-      base::Bind(&SourceState::OnNewBuffers, base::Unretained(this)),
+      base::Bind(&SourceState::OnNewBuffers,
+                 base::Unretained(this),
+                 media_time),
       new_text_track_cb_.is_null(),
       need_key_cb,
       base::Bind(&SourceState::OnNewMediaSegment, base::Unretained(this)),
       base::Bind(&SourceState::OnEndOfMediaSegment, base::Unretained(this)),
       log_cb_);
 }
 
 void SourceState::SetSequenceMode(bool sequence_mode) {
   DCHECK(!parsing_media_segment_);
 
@@ skipping 381 matching lines @@
   new_media_segment_ = true;
 }
 
 void SourceState::OnEndOfMediaSegment() {
   DVLOG(2) << "OnEndOfMediaSegment()";
   parsing_media_segment_ = false;
   new_media_segment_ = false;
 }
 
 bool SourceState::OnNewBuffers(
+    base::TimeDelta* media_time,
     const StreamParser::BufferQueue& audio_buffers,
     const StreamParser::BufferQueue& video_buffers,
     const StreamParser::TextBufferQueueMap& text_map) {
   DVLOG(2) << "OnNewBuffers()";
   DCHECK(timestamp_offset_during_append_);
   DCHECK(parsing_media_segment_);
 
   const TimeDelta timestamp_offset_before_processing =
       *timestamp_offset_during_append_;
 
@@ skipping 12 matching lines @@
       new_timestamp_offset += EndTimestamp(video_buffers);
     }
   }
 
   if (!frame_processor_->ProcessFrames(audio_buffers,
                                        video_buffers,
                                        text_map,
                                        append_window_start_during_append_,
                                        append_window_end_during_append_,
                                        &new_media_segment_,
-                                       timestamp_offset_during_append_)) {
+                                       timestamp_offset_during_append_,
+                                       *media_time)) {
     return false;
   }
 
   // Only update the timestamp offset if the frame processor hasn't already.
   if (auto_update_timestamp_offset_ &&
       timestamp_offset_before_processing == *timestamp_offset_during_append_) {
     *timestamp_offset_during_append_ = new_timestamp_offset;
   }
 
   return true;
@@ skipping 61 matching lines @@
 void ChunkDemuxerStream::Seek(TimeDelta time) {
   DVLOG(1) << "ChunkDemuxerStream::Seek(" << time.InSecondsF() << ")";
   base::AutoLock auto_lock(lock_);
   DCHECK(read_cb_.is_null());
   DCHECK(state_ == UNINITIALIZED || state_ == RETURNING_ABORT_FOR_READS)
       << state_;
 
   stream_->Seek(time);
 }
 
-bool ChunkDemuxerStream::Append(const StreamParser::BufferQueue& buffers) {
+bool ChunkDemuxerStream::Append(const StreamParser::BufferQueue& buffers,
+                                base::TimeDelta media_time) {
   if (buffers.empty())
     return false;
 
   base::AutoLock auto_lock(lock_);
   DCHECK_NE(state_, SHUTDOWN);
-  if (!stream_->Append(buffers)) {
+  if (!stream_->Append(buffers, media_time)) {
     DVLOG(1) << "ChunkDemuxerStream::Append() : stream append failed";
     return false;
   }
 
   if (!read_cb_.is_null())
     CompletePendingReadIfPossible_Locked();
 
   return true;
 }
 
@@ skipping 202 matching lines @@
                            const LogCB& log_cb,
                            bool splice_frames_enabled)
     : state_(WAITING_FOR_INIT),
       cancel_next_seek_(false),
       host_(NULL),
       open_cb_(open_cb),
       need_key_cb_(need_key_cb),
       enable_text_(false),
       log_cb_(log_cb),
       duration_(kNoTimestamp()),
+      media_time_(kNoTimestamp()),
       user_specified_duration_(-1),
       liveness_(LIVENESS_UNKNOWN),
       splice_frames_enabled_(splice_frames_enabled) {
   DCHECK(!open_cb_.is_null());
   DCHECK(!need_key_cb_.is_null());
 }
 
 void ChunkDemuxer::Initialize(
     DemuxerHost* host,
     const PipelineStatusCB& cb,
@@ skipping 72 matching lines @@
 Demuxer::Liveness ChunkDemuxer::GetLiveness() const {
   return liveness_;
 }
 
 void ChunkDemuxer::StartWaitingForSeek(TimeDelta seek_time) {
   DVLOG(1) << "StartWaitingForSeek()";
   base::AutoLock auto_lock(lock_);
   DCHECK(state_ == INITIALIZED || state_ == ENDED || state_ == SHUTDOWN ||
          state_ == PARSE_ERROR) << state_;
   DCHECK(seek_cb_.is_null());
+  media_time_ = seek_time;
 
   if (state_ == SHUTDOWN || state_ == PARSE_ERROR)
     return;
 
   AbortPendingReads();
   SeekAllSources(seek_time);
 
   // Cancel state set in CancelPendingSeek() since we want to
   // accept the next Seek().
   cancel_next_seek_ = false;
@@ skipping 69 matching lines @@
   if (enable_text_) {
     new_text_track_cb = base::Bind(&ChunkDemuxer::OnNewTextTrack,
                                    base::Unretained(this));
   }
 
   source_state->Init(
       base::Bind(&ChunkDemuxer::OnSourceInitDone, base::Unretained(this)),
       has_audio,
       has_video,
       need_key_cb_,
-      new_text_track_cb);
+      new_text_track_cb,
+      &media_time_);
 
   source_state_map_[id] = source_state.release();
   return kOk;
 }
 
 void ChunkDemuxer::RemoveId(const std::string& id) {
   base::AutoLock auto_lock(lock_);
   CHECK(IsValidId(id));
 
   delete source_state_map_[id];
@@ skipping 21 matching lines @@
                               TimeDelta append_window_start,
                               TimeDelta append_window_end,
                               TimeDelta* timestamp_offset) {
   DVLOG(1) << "AppendData(" << id << ", " << length << ")";
 
   DCHECK(!id.empty());
   DCHECK(timestamp_offset);
 
   Ranges<TimeDelta> ranges;
 
+  // TODO(damienv): Retrieve the current media time outside of any lock.
+  base::TimeDelta current_media_time = kNoTimestamp();
+
   {
     base::AutoLock auto_lock(lock_);
     DCHECK_NE(state_, ENDED);
 
     // Capture if any of the SourceBuffers are waiting for data before we start
     // parsing.
     bool old_waiting_for_data = IsSeekWaitingForData_Locked();
 
     if (length == 0u)
       return;
 
     DCHECK(data);
+    media_time_ = current_media_time;
 
     switch (state_) {
       case INITIALIZING:
         DCHECK(IsValidId(id));
         if (!source_state_map_[id]->Append(data, length,
                                            append_window_start,
                                            append_window_end,
                                            timestamp_offset)) {
           ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
           return;
@@ skipping 479 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (SourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media