Refactored DataBuffer to use unix_hacker style methods.

media/filters/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/filters/audio_renderer_impl.h"
 
 #include <math.h>
 
 #include <algorithm>
 
@@ skipping 22 matching lines @@
 };
 
 void HistogramRendererEvent(AudioRendererEvent event) {
   UMA_HISTOGRAM_ENUMERATION("Media.AudioRendererEvents", event, MAX_EVENTS);
 }
 
 }  // namespace
 
 AudioRendererImpl::AudioRendererImpl(
     const scoped_refptr<base::MessageLoopProxy>& message_loop,
-    media::AudioRendererSink* sink,
-    ScopedVector<AudioDecoder> decoders,
+    media::AudioRendererSink* sink, ScopedVector<AudioDecoder> decoders,
     const SetDecryptorReadyCB& set_decryptor_ready_cb,
     bool increase_preroll_on_underflow)
     : message_loop_(message_loop),
       weak_factory_(this),
       sink_(sink),
-      decoder_selector_(new AudioDecoderSelector(
-          message_loop, decoders.Pass(), set_decryptor_ready_cb)),
+      decoder_selector_(new AudioDecoderSelector(message_loop, decoders.Pass(),
+                                                 set_decryptor_ready_cb)),
       now_cb_(base::Bind(&base::TimeTicks::Now)),
       state_(kUninitialized),
       sink_playing_(false),
       pending_read_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
       audio_time_buffered_(kNoTimestamp()),
       current_time_(kNoTimestamp()),
       underflow_disabled_(false),
       increase_preroll_on_underflow_(increase_preroll_on_underflow),
       preroll_aborted_(false),
-      actual_frames_per_buffer_(0) {
-}
+      actual_frames_per_buffer_(0) {}

[brettw, 2013/06/24 21:18:29]

I liked the old way better.

 
 AudioRendererImpl::~AudioRendererImpl() {
   // Stop() should have been called and |algorithm_| should have been destroyed.
   DCHECK(state_ == kUninitialized || state_ == kStopped);
   DCHECK(!algorithm_.get());
 }
 
 void AudioRendererImpl::Play(const base::Closure& callback) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
@@ skipping 22 matching lines @@
     sink_->Play();
     sink_playing_ = true;
   }
 }
 
 void AudioRendererImpl::Pause(const base::Closure& callback) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   {
     base::AutoLock auto_lock(lock_);
-    DCHECK(state_ == kPlaying || state_ == kUnderflow ||
-           state_ == kRebuffering) << "state_ == " << state_;
+    DCHECK(state_ == kPlaying || state_ == kUnderflow || state_ == kRebuffering)
+        << "state_ == " << state_;
     pause_cb_ = callback;
     state_ = kPaused;
 
     // Pause only when we've completed our pending read.
-    if (!pending_read_)
-      base::ResetAndReturn(&pause_cb_).Run();
+    if (!pending_read_) base::ResetAndReturn(&pause_cb_).Run();
   }
 
   DoPause();
 }
 
 void AudioRendererImpl::DoPause() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   if (sink_playing_) {
     sink_->Pause();
     sink_playing_ = false;
   }
 }
 
 void AudioRendererImpl::Flush(const base::Closure& callback) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   if (decrypting_demuxer_stream_) {
-    decrypting_demuxer_stream_->Reset(base::Bind(
-        &AudioRendererImpl::ResetDecoder, weak_this_, callback));
+    decrypting_demuxer_stream_->Reset(
+        base::Bind(&AudioRendererImpl::ResetDecoder, weak_this_, callback));
     return;
   }
 
   decoder_->Reset(callback);
 }
 
 void AudioRendererImpl::ResetDecoder(const base::Closure& callback) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   decoder_->Reset(callback);
 }
@@ skipping 44 matching lines @@
   rendered_end_of_stream_ = false;
   preroll_aborted_ = false;
 
   splicer_->Reset();
   algorithm_->FlushBuffers();
   earliest_end_time_ = now_cb_.Run();
 
   AttemptRead_Locked();
 }
 
-void AudioRendererImpl::Initialize(DemuxerStream* stream,
-                                   const PipelineStatusCB& init_cb,
-                                   const StatisticsCB& statistics_cb,
-                                   const base::Closure& underflow_cb,
-                                   const TimeCB& time_cb,
-                                   const base::Closure& ended_cb,
-                                   const base::Closure& disabled_cb,
-                                   const PipelineStatusCB& error_cb) {
+void AudioRendererImpl::Initialize(

[brettw, 2013/06/24 21:18:29]

Old way was better

+    DemuxerStream* stream, const PipelineStatusCB& init_cb,
+    const StatisticsCB& statistics_cb, const base::Closure& underflow_cb,
+    const TimeCB& time_cb, const base::Closure& ended_cb,
+    const base::Closure& disabled_cb, const PipelineStatusCB& error_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(stream);
   DCHECK_EQ(stream->type(), DemuxerStream::AUDIO);
   DCHECK(!init_cb.is_null());
   DCHECK(!statistics_cb.is_null());
   DCHECK(!underflow_cb.is_null());
   DCHECK(!time_cb.is_null());
   DCHECK(!ended_cb.is_null());
   DCHECK(!disabled_cb.is_null());
   DCHECK(!error_cb.is_null());
   DCHECK_EQ(kUninitialized, state_);
   DCHECK(sink_.get());
 
   weak_this_ = weak_factory_.GetWeakPtr();
   init_cb_ = init_cb;
   statistics_cb_ = statistics_cb;
   underflow_cb_ = underflow_cb;
   time_cb_ = time_cb;
   ended_cb_ = ended_cb;
   disabled_cb_ = disabled_cb;
   error_cb_ = error_cb;
 
   decoder_selector_->SelectAudioDecoder(
-      stream,
-      statistics_cb,
+      stream, statistics_cb,
       base::Bind(&AudioRendererImpl::OnDecoderSelected, weak_this_));
 }
 
 void AudioRendererImpl::OnDecoderSelected(
     scoped_ptr<AudioDecoder> decoder,
     scoped_ptr<DecryptingDemuxerStream> decrypting_demuxer_stream) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   scoped_ptr<AudioDecoderSelector> deleter(decoder_selector_.Pass());
 
   if (state_ == kStopped) {
@@ skipping 62 matching lines @@
   }
 }
 
 void AudioRendererImpl::SetVolume(float volume) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(sink_.get());
   sink_->SetVolume(volume);
 }
 
 void AudioRendererImpl::DecodedAudioReady(
-    AudioDecoder::Status status,
-    const scoped_refptr<DataBuffer>& buffer) {
+    AudioDecoder::Status status, const scoped_refptr<DataBuffer>& buffer) {

[brettw, 2013/06/24 21:18:29]

Old way was better.

   DCHECK(message_loop_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   DCHECK(state_ == kPaused || state_ == kPrerolling || state_ == kPlaying ||
          state_ == kUnderflow || state_ == kRebuffering || state_ == kStopped);
 
   CHECK(pending_read_);
   pending_read_ = false;
 
   if (status == AudioDecoder::kAborted) {
@@ skipping 24 matching lines @@
     need_another_buffer = HandleSplicerBuffer(splicer_->GetNextBuffer());
 
   if (!need_another_buffer && !CanRead_Locked())
     return;
 
   AttemptRead_Locked();
 }
 
 bool AudioRendererImpl::HandleSplicerBuffer(
     const scoped_refptr<DataBuffer>& buffer) {
-  if (buffer->IsEndOfStream()) {
+  if (buffer->end_of_stream()) {
     received_end_of_stream_ = true;
 
     // Transition to kPlaying if we are currently handling an underflow since
     // no more data will be arriving.
     if (state_ == kUnderflow || state_ == kRebuffering)
       state_ = kPlaying;
   }
 
   switch (state_) {
     case kUninitialized:
       NOTREACHED();
       return false;
     case kPaused:
-      if (!buffer->IsEndOfStream())
-        algorithm_->EnqueueBuffer(buffer);
+      if (!buffer->end_of_stream()) algorithm_->EnqueueBuffer(buffer);
       DCHECK(!pending_read_);
       base::ResetAndReturn(&pause_cb_).Run();
       return false;
     case kPrerolling:
       if (IsBeforePrerollTime(buffer))
         return true;
 
-      if (!buffer->IsEndOfStream()) {
+      if (!buffer->end_of_stream()) {
         algorithm_->EnqueueBuffer(buffer);
         if (!algorithm_->IsQueueFull())
           return false;
       }
       state_ = kPaused;
       base::ResetAndReturn(&preroll_cb_).Run(PIPELINE_OK);
       return false;
     case kPlaying:
     case kUnderflow:
     case kRebuffering:
-      if (!buffer->IsEndOfStream())
+      if (!buffer->end_of_stream())
         algorithm_->EnqueueBuffer(buffer);
       return false;
     case kStopped:
       return false;
   }
   return false;
 }
 
 void AudioRendererImpl::AttemptRead() {
   base::AutoLock auto_lock(lock_);
@@ skipping 21 matching lines @@
       return false;
 
     case kPrerolling:
     case kPlaying:
     case kUnderflow:
     case kRebuffering:
       break;
   }
 
   return !pending_read_ && !received_end_of_stream_ &&
-      !algorithm_->IsQueueFull();
+         !algorithm_->IsQueueFull();
 }
 
 void AudioRendererImpl::SetPlaybackRate(float playback_rate) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK_GE(playback_rate, 0);
   DCHECK(sink_.get());
 
   // We have two cases here:
   // Play: current_playback_rate == 0 && playback_rate != 0
   // Pause: current_playback_rate != 0 && playback_rate == 0
   float current_playback_rate = algorithm_->playback_rate();
   if (current_playback_rate == 0 && playback_rate != 0)
     DoPlay();
   else if (current_playback_rate != 0 && playback_rate == 0)
     DoPause();
 
   base::AutoLock auto_lock(lock_);
   algorithm_->SetPlaybackRate(playback_rate);
 }
 
 bool AudioRendererImpl::IsBeforePrerollTime(
     const scoped_refptr<DataBuffer>& buffer) {
-  return (state_ == kPrerolling) && buffer.get() && !buffer->IsEndOfStream() &&
-         (buffer->GetTimestamp() + buffer->GetDuration()) < preroll_timestamp_;
+  return (state_ == kPrerolling) && buffer.get() &&
+         !buffer->end_of_stream() &&
+         (buffer->timestamp() + buffer->duration()) <
+             preroll_timestamp_;
 }
 
 int AudioRendererImpl::Render(AudioBus* audio_bus,
                               int audio_delay_milliseconds) {
   if (actual_frames_per_buffer_ != audio_bus->frames()) {
     audio_buffer_.reset(
         new uint8[audio_bus->frames() * audio_parameters_.GetBytesPerFrame()]);
     actual_frames_per_buffer_ = audio_bus->frames();
   }
 
-  int frames_filled = FillBuffer(
-      audio_buffer_.get(), audio_bus->frames(), audio_delay_milliseconds);
+  int frames_filled = FillBuffer(audio_buffer_.get(), audio_bus->frames(),
+                                 audio_delay_milliseconds);
   DCHECK_LE(frames_filled, actual_frames_per_buffer_);
 
   // Deinterleave audio data into the output bus.
-  audio_bus->FromInterleaved(
-      audio_buffer_.get(), frames_filled,
-      audio_parameters_.bits_per_sample() / 8);
+  audio_bus->FromInterleaved(audio_buffer_.get(), frames_filled,
+                             audio_parameters_.bits_per_sample() / 8);
 
   return frames_filled;
 }
 
-uint32 AudioRendererImpl::FillBuffer(uint8* dest,
-                                     uint32 requested_frames,
+uint32 AudioRendererImpl::FillBuffer(uint8* dest, uint32 requested_frames,
                                      int audio_delay_milliseconds) {
   base::TimeDelta current_time = kNoTimestamp();
   base::TimeDelta max_time = kNoTimestamp();
-  base::TimeDelta playback_delay = base::TimeDelta::FromMilliseconds(
-      audio_delay_milliseconds);
+  base::TimeDelta playback_delay =
+      base::TimeDelta::FromMilliseconds(audio_delay_milliseconds);
 
   size_t frames_written = 0;
   base::Closure underflow_cb;
   {
     base::AutoLock auto_lock(lock_);
 
     // Ensure Stop() hasn't destroyed our |algorithm_| on the pipeline thread.
     if (!algorithm_)
       return 0;
 
@@ skipping 36 matching lines @@
         state_ = kUnderflow;
         underflow_cb = underflow_cb_;
       } else {
         // We can't write any data this cycle. For example, we may have
         // sent all available data to the audio device while not reaching
         // |earliest_end_time_|.
       }
     }
 
     if (CanRead_Locked()) {
-      message_loop_->PostTask(FROM_HERE, base::Bind(
-          &AudioRendererImpl::AttemptRead, weak_this_));
+      message_loop_->PostTask(
+          FROM_HERE, base::Bind(&AudioRendererImpl::AttemptRead, weak_this_));
     }
 
     // The |audio_time_buffered_| is the ending timestamp of the last frame
     // buffered at the audio device. |playback_delay| is the amount of time
     // buffered at the audio device. The current time can be computed by their
     // difference.
     if (audio_time_buffered_ != kNoTimestamp()) {
       // Adjust the delay according to playback rate.
       base::TimeDelta adjusted_playback_delay =
-          base::TimeDelta::FromMicroseconds(ceil(
-              playback_delay.InMicroseconds() * playback_rate));
+          base::TimeDelta::FromMicroseconds(
+              ceil(playback_delay.InMicroseconds() * playback_rate));
 
       base::TimeDelta previous_time = current_time_;
       current_time_ = audio_time_buffered_ - adjusted_playback_delay;
 
       // Time can change in one of two ways:
       //   1) The time of the audio data at the audio device changed, or
       //   2) The playback delay value has changed
       //
       // We only want to set |current_time| (and thus execute |time_cb_|) if
       // time has progressed and we haven't signaled end of stream yet.
       //
       // Why? The current latency of the system results in getting the last call
       // to FillBuffer() later than we'd like, which delays firing the 'ended'
       // event, which delays the looping/trigging performance of short sound
       // effects.
       //
       // TODO(scherkus): revisit this and switch back to relying on playback
       // delay after we've revamped our audio IPC subsystem.
       if (current_time_ > previous_time && !rendered_end_of_stream_) {
         current_time = current_time_;
       }
     }
 
     // The call to FillBuffer() on |algorithm_| has increased the amount of
     // buffered audio data. Update the new amount of time buffered.
     max_time = algorithm_->GetTime();
     audio_time_buffered_ = max_time;
 
-    UpdateEarliestEndTime_Locked(
-        frames_written, playback_delay, now_cb_.Run());
+    UpdateEarliestEndTime_Locked(frames_written, playback_delay, now_cb_.Run());
   }
 
   if (current_time != kNoTimestamp() && max_time != kNoTimestamp()) {
     time_cb_.Run(current_time, max_time);
   }
 
   if (!underflow_cb.is_null())
     underflow_cb.Run();
 
   return frames_written;
@@ skipping 44 matching lines @@
     case kUnderflow:
     case kRebuffering:
     case kStopped:
       if (status != PIPELINE_OK)
         error_cb_.Run(status);
       return;
   }
 }
 
 }  // namespace media