media: Delete renderer/demuxer splicing code.

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>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/default_tick_clock.h"
 #include "build/build_config.h"
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_buffer_converter.h"
 #include "media/base/audio_latency.h"
-#include "media/base/audio_splicer.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
 #include "media/base/renderer_client.h"
 #include "media/base/timestamp_constants.h"
 #include "media/filters/audio_clock.h"
 #include "media/filters/decrypting_demuxer_stream.h"
 
 namespace media {
@@ skipping 16 matching lines @@
       playback_rate_(0.0),
       state_(kUninitialized),
       buffering_state_(BUFFERING_HAVE_NOTHING),
       rendering_(false),
       sink_playing_(false),
       pending_read_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
       is_suspending_(false),
       weak_factory_(this) {
-  audio_buffer_stream_->set_splice_observer(base::Bind(
-      &AudioRendererImpl::OnNewSpliceBuffer, weak_factory_.GetWeakPtr()));
   audio_buffer_stream_->set_config_change_observer(base::Bind(
       &AudioRendererImpl::OnConfigChange, weak_factory_.GetWeakPtr()));
 
   // Tests may not have a power monitor.
   base::PowerMonitor* monitor = base::PowerMonitor::Get();
   if (!monitor)
     return;
 
   // PowerObserver's must be added and removed from the same thread, but we
   // won't remove the observer until we're destructed on |task_runner_| so we
@@ skipping 221 matching lines @@
     DCHECK_EQ(state_, kFlushed);
     DCHECK(!flush_cb_.is_null());
 
     received_end_of_stream_ = false;
     rendered_end_of_stream_ = false;
 
     // Flush() may have been called while underflowed/not fully buffered.
     if (buffering_state_ != BUFFERING_HAVE_NOTHING)
       SetBufferingState_Locked(BUFFERING_HAVE_NOTHING);
 
-    splicer_->Reset();
     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_));
 }
 
@@ skipping 144 matching lines @@
   if (!audio_parameters_.IsValid()) {
     DVLOG(1) << __func__ << ": Invalid audio parameters: "
              << audio_parameters_.AsHumanReadableString();
     ChangeState_Locked(kUninitialized);
     base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_INITIALIZATION_FAILED);
     return;
   }
 
   if (expecting_config_changes_)
     buffer_converter_.reset(new AudioBufferConverter(audio_parameters_));
-  splicer_.reset(new AudioSplicer(audio_parameters_.sample_rate(), media_log_));
 
   // We're all good! Continue initializing the rest of the audio renderer
   // based on the decoder format.
   algorithm_.reset(new AudioRendererAlgorithm());
   algorithm_->Initialize(audio_parameters_);
 
   ChangeState_Locked(kFlushed);
 
   {
     base::AutoUnlock auto_unlock(lock_);
@@ skipping 74 matching lines @@
 
   DCHECK_EQ(status, AudioBufferStream::OK);
   DCHECK(buffer.get());
 
   if (state_ == kFlushing) {
     ChangeState_Locked(kFlushed);
     DoFlush_Locked();
     return;
   }
 
+  bool need_another_buffer = false;
+
   if (expecting_config_changes_) {
     if (last_decoded_sample_rate_ &&
         buffer->sample_rate() != last_decoded_sample_rate_) {
       DVLOG(1) << __func__ << " Updating audio sample_rate."
                << " ts:" << buffer->timestamp().InMicroseconds()
                << " old:" << last_decoded_sample_rate_
                << " new:" << buffer->sample_rate();
       OnConfigChange();
     }
     last_decoded_sample_rate_ = buffer->sample_rate();
 
     DCHECK(buffer_converter_);
     buffer_converter_->AddInput(buffer);
+
+    if (!buffer_converter_->HasNextBuffer()) {
+      AttemptRead_Locked();
+      return;
+    }
+
     while (buffer_converter_->HasNextBuffer()) {
-      if (!splicer_->AddInput(buffer_converter_->GetNextBuffer())) {
-        HandleAbortedReadOrDecodeError(AUDIO_RENDERER_ERROR_SPLICE_FAILED);
-        return;
-      }
+      need_another_buffer =
+          HandleDecodedBuffer_Locked(buffer_converter_->GetNextBuffer());
     }
   } else {
     // TODO(chcunningham, tguilbert): Figure out if we want to support implicit
     // config changes during src=. Doing so requires resampling each individual
     // stream which is inefficient when there are many tags in a page.
     //
     // Check if the buffer we received matches the expected configuration.
     // Note: We explicitly do not check channel layout here to avoid breaking
     // weird behavior with multichannel wav files: http://crbug.com/600538.
     if (!buffer->end_of_stream() &&
         (buffer->sample_rate() != audio_parameters_.sample_rate() ||
          buffer->channel_count() != audio_parameters_.channels())) {
       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 (!splicer_->AddInput(buffer)) {
-      HandleAbortedReadOrDecodeError(AUDIO_RENDERER_ERROR_SPLICE_FAILED);
-      return;
-    }
+    need_another_buffer = HandleDecodedBuffer_Locked(buffer);
   }
 
-  if (!splicer_->HasNextBuffer()) {
-    AttemptRead_Locked();
-    return;
-  }
-
-  bool need_another_buffer = false;
-  while (splicer_->HasNextBuffer())
-    need_another_buffer = HandleSplicerBuffer_Locked(splicer_->GetNextBuffer());
-
   if (!need_another_buffer && !CanRead_Locked())
     return;
 
   AttemptRead_Locked();
 }
 
-bool AudioRendererImpl::HandleSplicerBuffer_Locked(
+bool AudioRendererImpl::HandleDecodedBuffer_Locked(
     const scoped_refptr<AudioBuffer>& buffer) {
   lock_.AssertAcquired();
   if (buffer->end_of_stream()) {
     received_end_of_stream_ = true;
   } else {
     if (state_ == kPlaying) {
       if (IsBeforeStartTime(buffer))
         return true;
 
       // Trim off any additional time before the start timestamp.
@@ skipping 292 matching lines @@
       return;
   }
 }
 
 void AudioRendererImpl::ChangeState_Locked(State new_state) {
   DVLOG(1) << __func__ << " : " << state_ << " -> " << new_state;
   lock_.AssertAcquired();
   state_ = new_state;
 }
 
-void AudioRendererImpl::OnNewSpliceBuffer(base::TimeDelta splice_timestamp) {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-  splicer_->SetSpliceTimestamp(splice_timestamp);
-}
-
 void AudioRendererImpl::OnConfigChange() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(expecting_config_changes_);
   buffer_converter_->ResetTimestampState();
-  // Drain flushed buffers from the converter so the AudioSplicer receives all
-  // data ahead of any OnNewSpliceBuffer() calls.  Since discontinuities should
-  // only appear after config changes, AddInput() should never fail here.
-  while (buffer_converter_->HasNextBuffer())
-    CHECK(splicer_->AddInput(buffer_converter_->GetNextBuffer()));
 }
 
 void AudioRendererImpl::SetBufferingState_Locked(
     BufferingState buffering_state) {
   DVLOG(1) << __func__ << " : " << buffering_state_ << " -> "
            << buffering_state;
   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