Not for submission. fastSeek prototype.

media/renderers/audio_renderer_impl.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/renderers/audio_renderer_impl.h"
 
 #include <math.h>
 #include <stddef.h>
 #include <algorithm>
 #include <utility>
@@ skipping 146 matching lines @@
   sink_->Pause();
   stop_rendering_time_ = last_render_time_;
 }
 
 void AudioRendererImpl::SetMediaTime(base::TimeDelta time) {
   DVLOG(1) << __func__ << "(" << time << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   DCHECK(!rendering_);
-  DCHECK_EQ(state_, kFlushed);
+  DCHECK(state_ == kFlushed || state_ == kPlaying);
 
   start_timestamp_ = time;
   ended_timestamp_ = kInfiniteDuration;
+  last_render_time_ = stop_rendering_time_ = base::TimeTicks();
+  first_packet_timestamp_ = kNoTimestamp;
+  audio_clock_.reset(new AudioClock(time, audio_parameters_.sample_rate()));
+}
+
+void AudioRendererImpl::SetMediaTime_Locked(base::TimeDelta time) {
+  DVLOG(1) << __func__ << "(" << time << ")";
+  DCHECK(task_runner_->BelongsToCurrentThread());
+
+  DCHECK(!rendering_);
+  DCHECK(state_ == kFlushed || state_ == kPlaying);
+
+  start_timestamp_ = time;
+  ended_timestamp_ = kInfiniteDuration;
   last_render_time_ = stop_rendering_time_ = base::TimeTicks();
   first_packet_timestamp_ = kNoTimestamp;
   audio_clock_.reset(new AudioClock(time, audio_parameters_.sample_rate()));
 }
 
 base::TimeDelta AudioRendererImpl::CurrentMediaTime() {
   base::AutoLock auto_lock(lock_);
 
   // Return the current time based on the known extents of the rendered audio
   // data plus an estimate based on the last time those values were calculated.
@@ skipping 120 matching lines @@
     if (buffer_converter_)
       buffer_converter_->Reset();
     algorithm_->FlushBuffers();
   }
 
   // Changes in buffering state are always posted. Flush callback must only be
   // run after buffering state has been set back to nothing.
   task_runner_->PostTask(FROM_HERE, base::ResetAndReturn(&flush_cb_));
 }
 
-void AudioRendererImpl::StartPlaying() {
+void AudioRendererImpl::StartPlayingFrom(StreamPosition position) {
   DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   DCHECK(!sink_playing_);
   DCHECK_EQ(state_, kFlushed);
   DCHECK_EQ(buffering_state_, BUFFERING_HAVE_NOTHING);
   DCHECK(!pending_read_) << "Pending read must complete before seeking";
 
+  start_rendering_from_first_frame_ =
+      position.kind == StreamPosition::Kind::KEY_FRAME_PRECEDING_TIME;
   ChangeState_Locked(kPlaying);
   AttemptRead_Locked();
 }
 
 void AudioRendererImpl::Initialize(DemuxerStream* stream,
                                    CdmContext* cdm_context,
                                    RendererClient* client,
                                    const PipelineStatusCB& init_cb) {
   DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ skipping 256 matching lines @@
       MEDIA_LOG(ERROR, media_log_)
           << "Unsupported midstream configuration change!"
           << " Sample Rate: " << buffer->sample_rate() << " vs "
           << audio_parameters_.sample_rate()
           << ", Channels: " << buffer->channel_count() << " vs "
           << audio_parameters_.channels();
       HandleAbortedReadOrDecodeError(PIPELINE_ERROR_DECODE);
       return;
     }
 
+    if (start_rendering_from_first_frame_) {
+      LOG(ERROR) << "First audio timestamp: " << buffer->timestamp();
+      SetMediaTime_Locked(buffer->timestamp());
+      start_rendering_from_first_frame_ = false;
+    }
+
     if (!splicer_->AddInput(buffer)) {
       HandleAbortedReadOrDecodeError(AUDIO_RENDERER_ERROR_SPLICE_FAILED);
       return;
     }
   }
 
   if (!splicer_->HasNextBuffer()) {
     AttemptRead_Locked();
     return;
   }
@@ skipping 340 matching lines @@
   DCHECK_NE(buffering_state_, buffering_state);
   lock_.AssertAcquired();
   buffering_state_ = buffering_state;
 
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&AudioRendererImpl::OnBufferingStateChange,
                             weak_factory_.GetWeakPtr(), buffering_state_));
 }
 
 }  // namespace media