media/audio/null_audio_sink.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/audio/null_audio_sink.h"
   6
   7 #include "base/bind.h"
   8 #include "base/location.h"
   9 #include "base/single_thread_task_runner.h"
  10 #include "media/audio/fake_audio_worker.h"
  11 #include "media/base/audio_hash.h"
  12
  13 namespace media {
  14
  15 NullAudioSink::NullAudioSink(
  16     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
  17     : initialized_(false),
  18       playing_(false),
  19       callback_(NULL),
  20       task_runner_(task_runner) {
  21 }
  22
  23 NullAudioSink::~NullAudioSink() {}
  24
  25 void NullAudioSink::Initialize(const AudioParameters& params,
  26                                RenderCallback* callback) {
  27   DCHECK(!initialized_);
  28   fake_worker_.reset(new FakeAudioWorker(task_runner_, params));
  29   audio_bus_ = AudioBus::Create(params);
  30   callback_ = callback;
  31   initialized_ = true;
  32 }
  33
  34 void NullAudioSink::Start() {
  35   DCHECK(task_runner_->BelongsToCurrentThread());
  36   DCHECK(!playing_);
  37 }
  38
  39 void NullAudioSink::Stop() {
  40   DCHECK(task_runner_->BelongsToCurrentThread());
  41
  42   // Stop may be called at any time, so we have to check before stopping.
  43   if (fake_worker_)
  44     fake_worker_->Stop();
  45 }
  46
  47 void NullAudioSink::Play() {
  48   DCHECK(task_runner_->BelongsToCurrentThread());
  49   DCHECK(initialized_);
  50
  51   if (playing_)
  52     return;
  53
  54   fake_worker_->Start(base::Bind(
  55       &NullAudioSink::CallRender, base::Unretained(this)));
  56   playing_ = true;
  57 }
  58
  59 void NullAudioSink::Pause() {
  60   DCHECK(task_runner_->BelongsToCurrentThread());
  61
  62   if (!playing_)
  63     return;
  64
  65   fake_worker_->Stop();
  66   playing_ = false;
  67 }
  68
  69 bool NullAudioSink::SetVolume(double volume) {
  70   // Audio is always muted.
  71   return volume == 0.0;
  72 }
  73
  74 void NullAudioSink::SwitchOutputDevice(const std::string& device_id,
  75                                        const GURL& security_origin,
  76                                        const SwitchOutputDeviceCB& callback) {
  77   DCHECK(task_runner_->BelongsToCurrentThread());
  78   callback.Run(SWITCH_OUTPUT_DEVICE_RESULT_ERROR_NOT_SUPPORTED);
  79 }
  80
  81 void NullAudioSink::CallRender() {
  82   DCHECK(task_runner_->BelongsToCurrentThread());
  83
  84   int frames_received = callback_->Render(audio_bus_.get(), 0);
  85   if (!audio_hash_ || frames_received <= 0)
  86     return;
  87
  88   audio_hash_->Update(audio_bus_.get(), frames_received);
  89 }
  90
  91 void NullAudioSink::StartAudioHashForTesting() {
  92   DCHECK(!initialized_);
  93   audio_hash_.reset(new AudioHash());
  94 }
  95
  96 std::string NullAudioSink::GetAudioHashForTesting() {
  97   return audio_hash_ ? audio_hash_->ToString() : std::string();
  98 }
  99
 100 }  // namespace media