Enable round-tripping and updating of WebSourceBufferImpl timestamp offset

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 <deque>
 #include <limits>
 #include <list>
@@ skipping 91 matching lines @@
 
   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);
 
   // Appends new data to the StreamParser.
   // Returns true if the data was successfully appended. Returns false if an
   // error occurred.
-  bool Append(const uint8* data, size_t length);
+  // If the append changed the source buffer's timestamp offset, sets
+  // |*new_timestamp_offset| to the updated timestamp offset. Otherwise, sets
+  // |*new_timestamp_offset| to kNoTimestamp() to indicate no change.
+  bool Append(const uint8* data, size_t length,
+              TimeDelta* new_timestamp_offset);
 
   // Aborts the current append sequence and resets the parser.
   void Abort();
 
   // Calls Remove(|start|, |end|, |duration|) on all
   // ChunkDemuxerStreams managed by this object.
   void Remove(TimeDelta start, TimeDelta end, TimeDelta duration);
 
-  // Sets |timestamp_offset_| if possible.
-  // Returns if the offset was set. Returns false if the offset could not be
-  // updated at this time.
+  // Sets user-specified |timestamp_offset_| if possible.
+  // Returns true if the offset was set. Returns false if the offset could not
+  // be set at this time.
   bool SetTimestampOffset(TimeDelta timestamp_offset);
 
   // Sets |sequence_mode_| to |sequence_mode| if possible.
   // Returns true if the mode update was allowed. Returns false if the mode
   // could not be updated at this time.
   bool SetSequenceMode(bool sequence_mode);
 
-  TimeDelta timestamp_offset() const { return timestamp_offset_; }
-
   void set_append_window_start(TimeDelta start) {
     append_window_start_ = start;
   }
   void set_append_window_end(TimeDelta end) { append_window_end_ = end; }
 
   // Returns the range of buffered data in this source, capped at |duration|.
   // |ended| - Set to true if end of stream has been signalled and the special
   // end of stream range logic needs to be executed.
   Ranges<TimeDelta> GetBufferedRanges(TimeDelta duration, bool ended) const;
 
@@ skipping 74 matching lines @@
                               bool* needs_keyframe,
                               StreamParser::BufferQueue* filtered_buffers);
 
   CreateDemuxerStreamCB create_demuxer_stream_cb_;
   IncreaseDurationCB increase_duration_cb_;
   NewTextTrackCB new_text_track_cb_;
 
   // The offset to apply to media segment timestamps.
   TimeDelta timestamp_offset_;
 
+  // Flag that tracks whether or not the current Append() operation changed
+  // |timestamp_offset_|.
+  bool timestamp_offset_updated_by_append_;
+
   // Tracks the mode by which appended media is processed. If true, then
   // appended media is processed using "sequence" mode. Otherwise, appended
   // media is processed using "segments" mode.
   // TODO(wolenetz): Enable "sequence" mode logic. See http://crbug.com/249422
   // and http://crbug.com/333437.
   bool sequence_mode_;
 
   TimeDelta append_window_start_;
   TimeDelta append_window_end_;
 
@@ skipping 121 matching lines @@
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ChunkDemuxerStream);
 };
 
 SourceState::SourceState(scoped_ptr<StreamParser> stream_parser,
                          const LogCB& log_cb,
                          const CreateDemuxerStreamCB& create_demuxer_stream_cb,
                          const IncreaseDurationCB& increase_duration_cb)
     : create_demuxer_stream_cb_(create_demuxer_stream_cb),
       increase_duration_cb_(increase_duration_cb),
+      timestamp_offset_updated_by_append_(false),
       sequence_mode_(false),
       append_window_end_(kInfiniteDuration()),
       new_media_segment_(false),
       parsing_media_segment_(false),
       stream_parser_(stream_parser.release()),
       audio_(NULL),
       audio_needs_keyframe_(true),
       video_(NULL),
       video_needs_keyframe_(true),
       log_cb_(log_cb) {
@@ skipping 39 matching lines @@
 }
 
 bool SourceState::SetSequenceMode(bool sequence_mode) {
   if (parsing_media_segment_)
     return false;
 
   sequence_mode_ = sequence_mode;
   return true;
 }
 
+bool SourceState::Append(const uint8* data, size_t length,
+                         TimeDelta* new_timestamp_offset) {
+  DCHECK(new_timestamp_offset);
 
-bool SourceState::Append(const uint8* data, size_t length) {
-  return stream_parser_->Parse(data, length);
+  timestamp_offset_updated_by_append_ = false;
+  bool err = stream_parser_->Parse(data, length);
+
+  if (timestamp_offset_updated_by_append_)
+    *new_timestamp_offset = timestamp_offset_;

[acolwell GONE FROM CHROMIUM, 2014/02/27 18:27:21]

If we pass timestamp_offset here then we can just make this code be
if (timestamp_offset_updated_by_append_ && timestamp_offset)
  *timestamp_offset = timestamp_offset_.InSecondsF();

and a bunch of the other code becomes unnecessary.

In the future, we may consider just setting timestamp_offset_ with
*timestamp_offset and remove the SetTimestampOffset() in favor of an
isParsingMediaSegment() method.

[wolenetz, 2014/02/27 21:48:49]

Done.

+  else
+    *new_timestamp_offset = kNoTimestamp();
+
+  return err;
 }
 
 void SourceState::Abort() {
   stream_parser_->Flush();
   audio_needs_keyframe_ = true;
   video_needs_keyframe_ = true;
   parsing_media_segment_ = false;
 }
 
 void SourceState::Remove(TimeDelta start, TimeDelta end, TimeDelta duration) {
@@ skipping 961 matching lines @@
   base::AutoLock auto_lock(lock_);
   DCHECK(!id.empty());
 
   SourceStateMap::const_iterator itr = source_state_map_.find(id);
 
   DCHECK(itr != source_state_map_.end());
   return itr->second->GetBufferedRanges(duration_, state_ == ENDED);
 }
 
 void ChunkDemuxer::AppendData(const std::string& id,
-                              const uint8* data,
-                              size_t length) {
+                              const uint8* data, size_t length,
+                              TimeDelta* new_timestamp_offset) {
   DVLOG(1) << "AppendData(" << id << ", " << length << ")";
 
   DCHECK(!id.empty());
+  DCHECK(new_timestamp_offset);
+
+  // Signal unchanged timestamp offset unless it is actually changed.
+  *new_timestamp_offset = kNoTimestamp();
 
   Ranges<TimeDelta> ranges;
 
   {
     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);
 
     switch (state_) {
       case INITIALIZING:
         DCHECK(IsValidId(id));
-        if (!source_state_map_[id]->Append(data, length)) {
+        if (!source_state_map_[id]->Append(data, length,
+                                           new_timestamp_offset)) {
           ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
           return;
         }
         break;
 
       case INITIALIZED: {
         DCHECK(IsValidId(id));
-        if (!source_state_map_[id]->Append(data, length)) {
+        if (!source_state_map_[id]->Append(data, length,
+                                           new_timestamp_offset)) {
           ReportError_Locked(PIPELINE_ERROR_DECODE);
           return;
         }
       } break;
 
       case PARSE_ERROR:
         DVLOG(1) << "AppendData(): Ignoring data after a parse error.";
         return;
 
       case WAITING_FOR_INIT:
@@ skipping 411 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (SourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media