Add Stop() to AudioDecoder.

media/filters/ffmpeg_audio_decoder.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/ffmpeg_audio_decoder.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 97 matching lines @@
   }
 
   statistics_cb_ = statistics_cb;
   initialize_cb.Run(PIPELINE_OK);
 }
 
 void FFmpegAudioDecoder::Read(const ReadCB& read_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!read_cb.is_null());
   CHECK(read_cb_.is_null()) << "Overlapping decodes are not supported.";
+  DCHECK(stop_cb_.is_null());
 
   read_cb_ = BindToCurrentLoop(read_cb);
 
   // If we don't have any queued audio from the last packet we decoded, ask for
   // more data from the demuxer to satisfy this read.
   if (queued_audio_.empty()) {
     ReadFromDemuxerStream();
     return;
   }
 
@@ skipping 12 matching lines @@
   return channel_layout_;
 }
 
 int FFmpegAudioDecoder::samples_per_second() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return samples_per_second_;
 }
 
 void FFmpegAudioDecoder::Reset(const base::Closure& closure) {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  base::Closure reset_cb = BindToCurrentLoop(closure);
+  reset_cb_ = BindToCurrentLoop(closure);
 
-  avcodec_flush_buffers(codec_context_.get());
-  ResetTimestampState();
-  queued_audio_.clear();
-  reset_cb.Run();
+  if (read_cb_.is_null())
+    DoReset();
+  // Otherwise a demuxer read is pending, we'll wait until it finishes.
 }
 
-FFmpegAudioDecoder::~FFmpegAudioDecoder() {
-  // TODO(scherkus): should we require Stop() to be called? this might end up
-  // getting called on a random thread due to refcounting.
-  ReleaseFFmpegResources();
+void FFmpegAudioDecoder::Stop(const base::Closure& closure) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  stop_cb_ = BindToCurrentLoop(closure);
+
+  if (read_cb_.is_null())
+    DoStop();
+  // Otherwise a demuxer read is pending, we'll wait until it finishes.
 }
 
+FFmpegAudioDecoder::~FFmpegAudioDecoder() {}
+
 int FFmpegAudioDecoder::GetAudioBuffer(AVCodecContext* codec,
                                        AVFrame* frame,
                                        int flags) {
   // Since this routine is called by FFmpeg when a buffer is required for audio
   // data, use the values supplied by FFmpeg (ignoring the current settings).
   // RunDecodeLoop() gets to determine if the buffer is useable or not.
   AVSampleFormat format = static_cast<AVSampleFormat>(frame->format);
   SampleFormat sample_format = AVSampleFormatToSampleFormat(format);
   int channels = DetermineChannels(frame);
   if ((channels <= 0) || (channels >= limits::kMaxChannels)) {
@@ skipping 45 matching lines @@
 
   // Now create an AVBufferRef for the data just allocated. It will own the
   // reference to the AudioBuffer object.
   void* opaque = NULL;
   buffer.swap(reinterpret_cast<AudioBuffer**>(&opaque));
   frame->buf[0] = av_buffer_create(
       frame->data[0], buffer_size_in_bytes, ReleaseAudioBufferImpl, opaque, 0);
   return 0;
 }
 
+void FFmpegAudioDecoder::DoStop() {
+  DCHECK(!stop_cb_.is_null());
+
+  ResetTimestampState();
+  queued_audio_.clear();
+  ReleaseFFmpegResources();
+  base::ResetAndReturn(&stop_cb_).Run();
+}
+
+void FFmpegAudioDecoder::DoReset() {
+  DCHECK(!reset_cb_.is_null());
+
+  avcodec_flush_buffers(codec_context_.get());
+  ResetTimestampState();
+  queued_audio_.clear();
+  base::ResetAndReturn(&reset_cb_).Run();
+}
+
 void FFmpegAudioDecoder::ReadFromDemuxerStream() {
   DCHECK(!read_cb_.is_null());
   demuxer_stream_->Read(base::Bind(
       &FFmpegAudioDecoder::BufferReady, weak_this_));
 }
 
 void FFmpegAudioDecoder::BufferReady(
     DemuxerStream::Status status,
     const scoped_refptr<DecoderBuffer>& input) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!read_cb_.is_null());
   DCHECK(queued_audio_.empty());
   DCHECK_EQ(status != DemuxerStream::kOk, !input.get()) << status;
 
+  // Stop() is pending, we'll ignore the buffer we just got, fire read_cb_, and
+  // complete the Stop.
+  if (!stop_cb_.is_null()) {
+    base::ResetAndReturn(&read_cb_).Run(kAborted, NULL);
+    DoStop();
+    return;
+  }
+
+  // Reset() is pending, we'll ignore the buffer we just got, fire read_cb_, and

[DaleCurtis, 2014/01/09 23:04:21]

Not sure this is necessary, but should be fine.

[rileya (GONE FROM CHROMIUM), 2014/01/10 00:04:05]

Yeah, I wasn't quite sure. DecryptingAudioDecoder does this (wait for pending
read to complete before a reset), so I figured I'd match that.

+  // complete the Reset.
+  if (!reset_cb_.is_null()) {
+    base::ResetAndReturn(&read_cb_).Run(kAborted, NULL);
+    DoReset();
+    return;
+  }
+
   if (status == DemuxerStream::kAborted) {
     DCHECK(!input.get());
     base::ResetAndReturn(&read_cb_).Run(kAborted, NULL);
     return;
   }
 
   if (status == DemuxerStream::kConfigChanged) {
     DCHECK(!input.get());
 
     // Send a "end of stream" buffer to the decode loop
@@ skipping 279 matching lines @@
     // Decoding finished successfully, update statistics.
     if (result > 0) {
       PipelineStatistics statistics;
       statistics.audio_bytes_decoded = result;
       statistics_cb_.Run(statistics);
     }
   } while (packet.size > 0);
 }
 
 }  // namespace media