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 100 matching lines @@
   // error occurred.
   bool Append(const uint8* data, size_t length);
 
   // 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.
-  bool SetTimestampOffset(TimeDelta timestamp_offset);
+  // Sets user-specified |timestamp_offset_| if possible.
+  // Returns true if the offset was set. Returns false if the offset could not
+  // be updated at this time.
+  bool SetTimestampOffset(double timestamp_offset);
+
+  // Gets the current timestamp offset.
+  // If |using_user_specified_timestamp_offset_| is true, meaning
+  // |timestamp_offset_| was most recently updated by SetTimestampOffset(),
+  // returns the exact double representation |user_specified_timestamp_offset_|.
+  // Otherwise, |timestamp_offset_| has diverged since construction or the
+  // last SetTimestampOffset(), such as may occur in "sequence" mode Append()
+  // coded frame processing. In this case, returns a double representation of
+  // the current |timestamp_offset_| TimeDelta.
+  double GetTimestampOffset() const;
 
   // 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_;
 
+  // Enable exact round-tripping SetTimestampOffset()+GetTimestampOffset(),
+  // unless the offset is updated in the interim by coded frame processing
+  // in "sequence" mode Append() operations.
+  double user_specified_timestamp_offset_;
+  bool using_user_specified_timestamp_offset_;
+
   // 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),
+      user_specified_timestamp_offset_(0.0),
+      using_user_specified_timestamp_offset_(true),
       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 23 matching lines @@
                                   base::Unretained(this)),
                        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_);
 }
 
-bool SourceState::SetTimestampOffset(TimeDelta timestamp_offset) {
+bool SourceState::SetTimestampOffset(double timestamp_offset) {
   if (parsing_media_segment_)
     return false;
 
-  timestamp_offset_ = timestamp_offset;
+  using_user_specified_timestamp_offset_ = true;
+  user_specified_timestamp_offset_ = timestamp_offset;
+  timestamp_offset_ = base::TimeDelta::FromMicroseconds(
+    timestamp_offset * base::Time::kMicrosecondsPerSecond);
+
   return true;
 }
 
+double SourceState::GetTimestampOffset() const {
+  if (using_user_specified_timestamp_offset_)
+    return user_specified_timestamp_offset_;

[acolwell GONE FROM CHROMIUM, 2014/02/25 17:24:28]

I think we should just return NaN here. Blink already knows what the user
specified one is. We only really need to signal when CFP updates the timestamp
offset. ISTM that the bool should just keep track of whether the CFP has updated
the timestamp offset. Perhaps rename this method to GetUpdatedTimestampOffset()?

It also might be worth keeping all this code in terms of TimeDelta and keeping
all the double business in WebSourceBufferImpl. kNoTimestamp() could be the
placeholder for NaN.

[wolenetz, 2014/02/25 20:32:20]

Done, using TimeDelta, name change, and kNoTimestamp() to indicate no change has
occurred since construction or last SetTimestampOffset().

+  else

[acolwell GONE FROM CHROMIUM, 2014/02/25 17:24:28]

nit: drop else.

[wolenetz, 2014/02/25 20:32:20]

Done.

+    return timestamp_offset_.InSecondsF();
+}
+
 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) {
@@ skipping 1115 matching lines @@
   user_specified_duration_ = duration;
   duration_ = duration_td;
   host_->SetDuration(duration_);
 
   for (SourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->OnSetDuration(duration_);
   }
 }
 
-bool ChunkDemuxer::SetTimestampOffset(const std::string& id, TimeDelta offset) {
+bool ChunkDemuxer::SetTimestampOffset(const std::string& id, double offset) {
   base::AutoLock auto_lock(lock_);
-  DVLOG(1) << "SetTimestampOffset(" << id << ", " << offset.InSecondsF() << ")";
+  DVLOG(1) << "SetTimestampOffset(" << id << ", " << offset << ")";
   CHECK(IsValidId(id));
 
   return source_state_map_[id]->SetTimestampOffset(offset);
 }
 
+double ChunkDemuxer::GetTimestampOffset(const std::string& id) {
+  base::AutoLock auto_lock(lock_);
+  DVLOG(1) << "GetTimestampOffset(" << id << ")";
+  CHECK(IsValidId(id));
+
+  return source_state_map_[id]->GetTimestampOffset();
+}
+
 bool ChunkDemuxer::SetSequenceMode(const std::string& id,
                                    bool sequence_mode) {
   base::AutoLock auto_lock(lock_);
   DVLOG(1) << "SetSequenceMode(" << id << ", " << sequence_mode << ")";
   CHECK(IsValidId(id));
   DCHECK_NE(state_, ENDED);
 
   return source_state_map_[id]->SetSequenceMode(sequence_mode);
 }
 
@@ skipping 293 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (SourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media