Chrome-side implementation of media source 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 "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 81 matching lines @@
 //         and |has_video| are undefined.
 static bool IsSupported(const std::string& type,
                         std::vector<std::string>& codecs,
                         ParserFactoryFunction* factory_function,
                         bool* has_audio,
                         bool* has_video) {
   *factory_function = NULL;
   *has_audio = false;
   *has_video = false;
 
-  // Search for the SupportedTypeInfo for |type|
+  // Search for the SupportedTypeInfo for |type|.
   for (size_t i = 0; i < arraysize(kSupportedTypeInfo); ++i) {
     const SupportedTypeInfo& type_info = kSupportedTypeInfo[i];
     if (type == type_info.type) {
       // Make sure all the codecs specified in |codecs| are
       // in the supported type info.
       for (size_t j = 0; j < codecs.size(); ++j) {
         // Search the type info for a match.
         bool found_codec = false;
         DemuxerStream::Type codec_type = DemuxerStream::UNKNOWN;
 
@@ skipping 345 matching lines @@
 
   scoped_refptr<StreamParserBuffer> buffer;
   while (!read_cbs_.empty()) {
     if (!stream_->GetNextBuffer(&buffer))
       return;
     closures->push_back(base::Bind(read_cbs_.front(), buffer));
     read_cbs_.pop_front();
   }
 }
 
+void ChunkDemuxer::AdjustBufferTimestamps(
+    const StreamParser::BufferQueue& buffers,
+    base::TimeDelta timestamp_offset) {
+  if (timestamp_offset == base::TimeDelta())
+    return;
+
+  for (StreamParser::BufferQueue::const_iterator itr = buffers.begin();
+       itr != buffers.end(); ++itr) {
+    (*itr)->SetDecodeTimestamp(
+        (*itr)->GetDecodeTimestamp() + timestamp_offset);
+    (*itr)->SetTimestamp((*itr)->GetTimestamp() + timestamp_offset);
+  }
+}
+
 ChunkDemuxer::ChunkDemuxer(ChunkDemuxerClient* client)
     : state_(WAITING_FOR_INIT),
       host_(NULL),
       client_(client),
       start_time_(kNoTimestamp()) {
   DCHECK(client);
 }
 
 void ChunkDemuxer::Initialize(DemuxerHost* host,
                               const PipelineStatusCB& cb) {
@@ skipping 126 matching lines @@
   scoped_ptr<StreamParser> stream_parser(factory_function());
   CHECK(stream_parser.get());
 
   stream_parser->Init(
       base::Bind(&ChunkDemuxer::OnStreamParserInitDone, this),
       base::Bind(&ChunkDemuxer::OnNewConfigs, base::Unretained(this),
                  has_audio, has_video),
       audio_cb,
       video_cb,
       base::Bind(&ChunkDemuxer::OnNeedKey, base::Unretained(this)),
-      base::Bind(&ChunkDemuxer::OnNewMediaSegment, base::Unretained(this), id));
+      base::Bind(&ChunkDemuxer::OnNewMediaSegment, base::Unretained(this), id),
+      base::Bind(&ChunkDemuxer::OnEndOfMediaSegment,
+                 base::Unretained(this), id));
 
   stream_parser_map_[id] = stream_parser.release();
+  StreamInfo info = { base::TimeDelta(), true };
+  stream_info_map_[id] = info;
 
   return kOk;
 }
 
 void ChunkDemuxer::RemoveId(const std::string& id) {
   CHECK_GT(stream_parser_map_.count(id), 0u);
   base::AutoLock auto_lock(lock_);
 
   delete stream_parser_map_[id];
   stream_parser_map_.erase(id);
+  stream_info_map_.erase(id);
 
   if (source_id_audio_ == id && audio_)
     audio_->Shutdown();
 
   if (source_id_video_ == id && video_)
     video_->Shutdown();
 }
 
 Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges(const std::string& id) const {
   DCHECK(!id.empty());
@@ skipping 115 matching lines @@
 }
 
 void ChunkDemuxer::Abort(const std::string& id) {
   DVLOG(1) << "Abort(" << id << ")";
   DCHECK(!id.empty());
   DCHECK_GT(stream_parser_map_.count(id), 0u);
 
   stream_parser_map_[id]->Flush();
 }
 
+bool ChunkDemuxer::TimestampOffset(const std::string& id, float offset) {
+  DVLOG(1) << "TimestampOffset(" << id << ", " << offset << ")";
+  DCHECK_GT(stream_parser_map_.count(id), 0u);
+
+  TimeDelta time_offset = TimeDelta::FromMicroseconds(
+      offset * base::Time::kMicrosecondsPerSecond);
+
+  if (!stream_info_map_[id].can_update_offset)
+    return false;
+
+  stream_info_map_[id].timestamp_offset = time_offset;
+  return true;
+}
+
 bool ChunkDemuxer::EndOfStream(PipelineStatus status) {
   DVLOG(1) << "EndOfStream(" << status << ")";
   base::AutoLock auto_lock(lock_);
   DCHECK_NE(state_, WAITING_FOR_INIT);
   DCHECK_NE(state_, ENDED);
 
   if (state_ == SHUTDOWN || state_ == PARSE_ERROR)
     return true;
 
   if (state_ == INITIALIZING) {
@@ skipping 184 matching lines @@
   return success;
 }
 
 bool ChunkDemuxer::OnAudioBuffers(const StreamParser::BufferQueue& buffers) {
   lock_.AssertAcquired();
   DCHECK_NE(state_, SHUTDOWN);
 
   if (!audio_)
     return false;
 
+  CHECK_GT(stream_info_map_.count(source_id_audio_), 0u);
+  AdjustBufferTimestamps(
+      buffers, stream_info_map_[source_id_audio_].timestamp_offset);
+  stream_info_map_[source_id_video_].can_update_offset = false;

[acolwell GONE FROM CHROMIUM, 2012/07/20 18:21:01]

did you mean source_id_audio_ here?

[vrk (LEFT CHROMIUM), 2012/07/25 17:16:48]

d'oh. Yes :) My test page only uses video, so I didn't catch this!

I actually removed this line in response to the comment below, but the unit
tests I added catches the equivalent mistake.

+
   return audio_->Append(buffers);
 }
 
 bool ChunkDemuxer::OnVideoBuffers(const StreamParser::BufferQueue& buffers) {
   lock_.AssertAcquired();
   DCHECK_NE(state_, SHUTDOWN);
 
   if (!video_)
     return false;
 
+  CHECK_GT(stream_info_map_.count(source_id_video_), 0u);
+  AdjustBufferTimestamps(
+      buffers, stream_info_map_[source_id_video_].timestamp_offset);
+  stream_info_map_[source_id_video_].can_update_offset = false;

[acolwell GONE FROM CHROMIUM, 2012/07/20 18:21:01]

Perhaps move this to OnNewMediaSegment()? That way it is symmetrical with
OnEndOfMediaSegment().

[vrk (LEFT CHROMIUM), 2012/07/25 17:16:48]

Done and removed from OnAudioBuffers() as well.

+
   return video_->Append(buffers);
 }
 
 bool ChunkDemuxer::OnNeedKey(scoped_array<uint8> init_data,
                              int init_data_size) {
   client_->DemuxerNeedKey(init_data.Pass(), init_data_size);
   return true;
 }
 
 void ChunkDemuxer::OnNewMediaSegment(const std::string& source_id,
-                                     TimeDelta start_timestamp) {
+                                     TimeDelta timestamp) {
   DVLOG(2) << "OnNewMediaSegment(" << source_id << ", "
-           << start_timestamp.InSecondsF() << ")";
+           << timestamp.InSecondsF() << ")";
   lock_.AssertAcquired();
 
+  CHECK_GT(stream_info_map_.count(source_id), 0u);
+  base::TimeDelta start_timestamp =
+      timestamp + stream_info_map_[source_id].timestamp_offset;
+
   if (start_time_ == kNoTimestamp()) {
     DCHECK(state_ == INITIALIZING || state_ == WAITING_FOR_START_TIME);
     // Use the first reported media segment start time as the |start_time_|
     // for the demuxer.
     start_time_ = start_timestamp;
   }
 
   if (audio_ && source_id == source_id_audio_)
     audio_->OnNewMediaSegment(start_timestamp);
   if (video_ && source_id == source_id_video_)
     video_->OnNewMediaSegment(start_timestamp);
 
   if (state_ != WAITING_FOR_START_TIME)
     return;
 
   if (audio_) {
     audio_->SetStartTime(start_time_);
     audio_->Seek(start_time_);
   }
   if (video_) {
     video_->SetStartTime(start_time_);
     video_->Seek(start_time_);
   }
 
   // The demuxer is now initialized after the |start_timestamp_| was set.
   ChangeState_Locked(INITIALIZED);
   base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
 }
 
+void ChunkDemuxer::OnEndOfMediaSegment(const std::string& source_id) {
+  DVLOG(2) << "OnEndOfMediaSegment(" << source_id << ")";
+  CHECK_GT(stream_info_map_.count(source_id_video_), 0u);
+  stream_info_map_[source_id_video_].can_update_offset = true;
+}
+
 }  // namespace media