Allow StreamParsers to request automatic timestampOffset updates.

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>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/stl_util.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/video_decoder_config.h"
 #include "media/filters/legacy_frame_processor.h"
 #include "media/filters/stream_parser_factory.h"
 
 using base::TimeDelta;
 
 namespace media {
 
+// Compute the end timestamp for buffers within an append window range.
+// TODO(dalecurtis): This code should probably live in the frame processor, but
+// requires some spec updates before we can do so.  For now it's a logical clone
+// of LegacyFrameProcessor::FilterWithAppendWindow().
+static TimeDelta EndTimestamp(const StreamParser::BufferQueue& buffers,
+                              TimeDelta append_window_start,
+                              TimeDelta append_window_end) {
+  TimeDelta end_timestamp = kNoTimestamp();
+
+  // Find the last buffer within the append window range.
+  for (StreamParser::BufferQueue::const_reverse_iterator itr = buffers.rbegin();
+       itr != buffers.rend();
+       ++itr) {
+    const scoped_refptr<StreamParserBuffer>& buffer = *itr;
+    if (buffer->timestamp() >= append_window_start &&
+        buffer->timestamp() <= append_window_end) {
+      end_timestamp = buffer->timestamp() + buffer->duration();
+      break;
+    }
+  }
+
+  return end_timestamp;
+}
+
 // List of time ranges for each SourceBuffer.
 typedef std::list<Ranges<TimeDelta> > RangesList;
 static Ranges<TimeDelta> ComputeIntersection(const RangesList& activeRanges,
                                              bool ended) {
   // Implementation of HTMLMediaElement.buffered algorithm in MSE spec.
   // https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#dom-htmlmediaelement.buffered
 
   // Step 1: If activeSourceBuffers.length equals 0 then return an empty
   //  TimeRanges object and abort these steps.
   if (activeRanges.empty())
@@ skipping 45 matching lines @@
 // Contains state belonging to a source id.
 class SourceState {
  public:
   // Callback signature used to create ChunkDemuxerStreams.
   typedef base::Callback<ChunkDemuxerStream*(
       DemuxerStream::Type)> CreateDemuxerStreamCB;
 
   typedef base::Callback<void(
       ChunkDemuxerStream*, const TextTrackConfig&)> NewTextTrackCB;
 
+  // First parameter - Indicates initialization success. Set to true if
+  //                   initialization was successful. False if an error
+  //                   occurred.
+  // Second parameter - Indicates the stream duration. Only contains a valid
+  //                    value if the first parameter is true.
+  typedef base::Callback<void(bool, TimeDelta)> InitCB;
+
   SourceState(
       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,
+  void Init(const InitCB& init_cb,
             bool allow_audio,
             bool allow_video,
             const StreamParser::NeedKeyCB& need_key_cb,
             const NewTextTrackCB& new_text_track_cb);
 
   // 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
@@ skipping 60 matching lines @@
   // 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,
                     const StreamParser::BufferQueue& video_buffers,
                     const StreamParser::TextBufferQueueMap& text_map);
 
+  void OnSourceInitDone(bool success,
+                        TimeDelta duration,
+                        bool auto_update_timestamp_offset);
+
   CreateDemuxerStreamCB create_demuxer_stream_cb_;
   NewTextTrackCB new_text_track_cb_;
 
   // During Append(), if OnNewBuffers() coded frame processing updates the
   // timestamp offset then |*timestamp_offset_during_append_| is also updated
   // so Append()'s caller can know the new offset. This pointer is only non-NULL
   // during the lifetime of an Append() call.
   TimeDelta* timestamp_offset_during_append_;
 
   // During Append(), coded frame processing triggered by OnNewBuffers()
@@ skipping 19 matching lines @@
   scoped_ptr<StreamParser> stream_parser_;
 
   ChunkDemuxerStream* audio_;  // Not owned by |this|.
   ChunkDemuxerStream* video_;  // Not owned by |this|.
 
   typedef std::map<StreamParser::TrackId, ChunkDemuxerStream*> TextStreamMap;
   TextStreamMap text_stream_map_;  // |this| owns the map's stream pointers.
 
   scoped_ptr<FrameProcessorBase> frame_processor_;
   LogCB log_cb_;
+  InitCB init_cb_;
+
+  // Indicates that timestampOffset should be updated automatically during
+  // OnNewBuffers() based on the earliest end timestamp of the buffers provided.
+  bool auto_update_timestamp_offset_;
 
   DISALLOW_COPY_AND_ASSIGN(SourceState);
 };
 
 SourceState::SourceState(
     scoped_ptr<StreamParser> stream_parser,
     scoped_ptr<FrameProcessorBase> frame_processor,
     const LogCB& log_cb,
     const CreateDemuxerStreamCB& create_demuxer_stream_cb)
     : create_demuxer_stream_cb_(create_demuxer_stream_cb),
       timestamp_offset_during_append_(NULL),
       new_media_segment_(false),
       parsing_media_segment_(false),
       stream_parser_(stream_parser.release()),
       audio_(NULL),
       video_(NULL),
       frame_processor_(frame_processor.release()),
-      log_cb_(log_cb) {
+      log_cb_(log_cb),
+      auto_update_timestamp_offset_(false) {
   DCHECK(!create_demuxer_stream_cb_.is_null());
   DCHECK(frame_processor_);
 }
 
 SourceState::~SourceState() {
   Shutdown();
 
   STLDeleteValues(&text_stream_map_);
 }
 
-void SourceState::Init(const StreamParser::InitCB& init_cb,
+void SourceState::Init(const InitCB& init_cb,
                        bool allow_audio,
                        bool allow_video,
                        const StreamParser::NeedKeyCB& need_key_cb,
                        const NewTextTrackCB& new_text_track_cb) {
   new_text_track_cb_ = new_text_track_cb;
+  init_cb_ = init_cb;
 
-  stream_parser_->Init(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)),
                        new_text_track_cb_.is_null(),
                        need_key_cb,
                        base::Bind(&SourceState::OnNewMediaSegment,
                                   base::Unretained(this)),
@@ skipping 366 matching lines @@
   new_media_segment_ = false;
 }
 
 bool SourceState::OnNewBuffers(
     const StreamParser::BufferQueue& audio_buffers,
     const StreamParser::BufferQueue& video_buffers,
     const StreamParser::TextBufferQueueMap& text_map) {
   DVLOG(2) << "OnNewBuffers()";
   DCHECK(timestamp_offset_during_append_);
 
-  return 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_);
+  const TimeDelta current_timestamp_offset = *timestamp_offset_during_append_;
+  const bool success =

[wolenetz, 2014/03/18 02:09:30]

nit: If |success| is false, this indicates a parse error. In that case, not all
of the frames may have been processed successfully, so probably we should abort
the auto timestampOffset update process, too.

[DaleCurtis, 2014/03/18 02:16:04]

Done.

+      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_);
+
+  // Update the timestamp offset for audio/video tracks if it hasn't already
+  // been updated by the frame processor.
+  if (auto_update_timestamp_offset_ &&
+      current_timestamp_offset == *timestamp_offset_during_append_) {
+    const TimeDelta audio_end = EndTimestamp(audio_buffers,
+                                             append_window_start_during_append_,
+                                             append_window_end_during_append_);
+    const TimeDelta video_end = EndTimestamp(audio_buffers,

[wolenetz, 2014/03/18 02:09:30]

s/audio_buf/video_buf/

[DaleCurtis, 2014/03/18 02:16:04]

Done.

+                                             append_window_start_during_append_,
+                                             append_window_end_during_append_);
+    const bool have_audio_buffers = audio_end != kNoTimestamp();
+    const bool have_video_buffers = video_end != kNoTimestamp();
+    if (have_audio_buffers && have_video_buffers) {
+      *timestamp_offset_during_append_ = std::min(audio_end, video_end);
+    } else if (have_audio_buffers) {
+      *timestamp_offset_during_append_ = audio_end;
+    } else if (have_video_buffers) {
+      *timestamp_offset_during_append_ = video_end;
+    }
+  }
+
+  return success;
+}
+
+void SourceState::OnSourceInitDone(bool success,
+                                   TimeDelta duration,
+                                   bool auto_update_timestamp_offset) {
+  auto_update_timestamp_offset_ = auto_update_timestamp_offset;
+  base::ResetAndReturn(&init_cb_).Run(success, duration);
 }
 
 ChunkDemuxerStream::ChunkDemuxerStream(Type type)
     : type_(type),
       state_(UNINITIALIZED) {
 }
 
 void ChunkDemuxerStream::StartReturningData() {
   DVLOG(1) << "ChunkDemuxerStream::StartReturningData()";
   base::AutoLock auto_lock(lock_);
@@ skipping 755 matching lines @@
   for (SourceStateMap::const_iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     if (itr->second->IsSeekWaitingForData())
       return true;
   }
 
   return false;
 }
 
 void ChunkDemuxer::OnSourceInitDone(bool success, TimeDelta duration) {
-  DVLOG(1) << "OnSourceInitDone(" << success << ", "
-           << duration.InSecondsF() << ")";
+  DVLOG(1) << "OnSourceInitDone(" << success
+           << ", " << duration.InSecondsF() << ")";
   lock_.AssertAcquired();
   DCHECK_EQ(state_, INITIALIZING);
   if (!success || (!audio_ && !video_)) {
     ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
     return;
   }
 
   if (duration != TimeDelta() && duration_ == kNoTimestamp())
     UpdateDuration(duration);
 
@@ skipping 141 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (SourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media