Move AudioDevice and AudioInputDevice to media.

media/audio/audio_input_device.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 "content/renderer/media/audio_input_device.h"
+#include "media/audio/audio_input_device.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/audio/audio_util.h"
 
+namespace media {
+
+AudioInputDevice::CaptureCallback::~CaptureCallback() {}
+AudioInputDevice::CaptureEventHandler::~CaptureEventHandler() {}
+
 // Takes care of invoking the capture callback on the audio thread.
 // An instance of this class is created for each capture stream in
 // OnLowLatencyCreated().
 class AudioInputDevice::AudioThreadCallback
     : public AudioDeviceThread::Callback {
  public:
-  AudioThreadCallback(const media::AudioParameters& audio_parameters,
+  AudioThreadCallback(const AudioParameters& audio_parameters,
                       base::SharedMemoryHandle memory,
                       int memory_length,
                       CaptureCallback* capture_callback);
   virtual ~AudioThreadCallback();
 
   virtual void MapSharedMemory() OVERRIDE;
 
   // Called whenever we receive notifications about pending data.
   virtual void Process(int pending_data) OVERRIDE;
 
  private:
   CaptureCallback* capture_callback_;
   DISALLOW_COPY_AND_ASSIGN(AudioThreadCallback);
 };
 
 AudioInputDevice::AudioInputDevice(
-    media::AudioInputIPC* ipc,
+    AudioInputIPC* ipc,
     const scoped_refptr<base::MessageLoopProxy>& io_loop)
     : ScopedLoopObserver(io_loop),
       callback_(NULL),
       event_handler_(NULL),
       ipc_(ipc),
       stream_id_(0),
       session_id_(0),
       pending_device_ready_(false),
       agc_is_enabled_(false) {
   CHECK(ipc_);
 }
 
-void AudioInputDevice::Initialize(const media::AudioParameters& params,
+void AudioInputDevice::Initialize(const AudioParameters& params,
                                   CaptureCallback* callback,
                                   CaptureEventHandler* event_handler) {
   DCHECK(!callback_);
   DCHECK(!event_handler_);
   audio_parameters_ = params;
   callback_ = callback;
   event_handler_ = event_handler;
 }
 
 void AudioInputDevice::SetDevice(int session_id) {
@@ skipping 69 matching lines @@
 
   MessageLoop::current()->PostTask(FROM_HERE,
       base::Bind(&AudioInputDevice::StartOnIOThread, this));
 }
 
 void AudioInputDevice::OnVolume(double volume) {
   NOTIMPLEMENTED();
 }
 
 void AudioInputDevice::OnStateChanged(
-    media::AudioInputIPCDelegate::State state) {
+    AudioInputIPCDelegate::State state) {
   DCHECK(message_loop()->BelongsToCurrentThread());
 
   // Do nothing if the stream has been closed.
   if (!stream_id_)
     return;
 
   switch (state) {
-    case media::AudioInputIPCDelegate::kStopped:
+    case AudioInputIPCDelegate::kStopped:
       // TODO(xians): Should we just call ShutDownOnIOThread here instead?
       ipc_->RemoveDelegate(stream_id_);
 
       audio_thread_.Stop(MessageLoop::current());
       audio_callback_.reset();
 
       if (event_handler_)
         event_handler_->OnDeviceStopped();
 
       stream_id_ = 0;
       pending_device_ready_ = false;
       break;
-    case media::AudioInputIPCDelegate::kRecording:
+    case AudioInputIPCDelegate::kRecording:
       NOTIMPLEMENTED();
       break;
-    case media::AudioInputIPCDelegate::kError:
+    case AudioInputIPCDelegate::kError:
       DLOG(WARNING) << "AudioInputDevice::OnStateChanged(kError)";
       // Don't dereference the callback object if the audio thread
       // is stopped or stopping.  That could mean that the callback
       // object has been deleted.
       // TODO(tommi): Add an explicit contract for clearing the callback
       // object.  Possibly require calling Initialize again or provide
       // a callback object via Start() and clear it in Stop().
       if (!audio_thread_.IsStopped())
         callback_->OnCaptureError();
       break;
@@ skipping 43 matching lines @@
   DCHECK_EQ(0, stream_id_);
   if (stream_id_)
     return;
 
   stream_id_ = ipc_->AddDelegate(this);
   // If |session_id_| is not specified, it will directly create the stream;
   // otherwise it will send a AudioInputHostMsg_StartDevice msg to the browser
   // and create the stream when getting a OnDeviceReady() callback.
   if (!session_id_) {
     ipc_->CreateStream(stream_id_, audio_parameters_,
-        media::AudioManagerBase::kDefaultDeviceId, agc_is_enabled_);
+        AudioManagerBase::kDefaultDeviceId, agc_is_enabled_);
   } else {
     ipc_->StartDevice(stream_id_, session_id_);
     pending_device_ready_ = true;
   }
 }
 
 void AudioInputDevice::SetSessionIdOnIOThread(int session_id) {
   DCHECK(message_loop()->BelongsToCurrentThread());
   session_id_ = session_id;
 }
@@ skipping 48 matching lines @@
   agc_is_enabled_ = enabled;
 }
 
 void AudioInputDevice::WillDestroyCurrentMessageLoop() {
   LOG(ERROR) << "IO loop going away before the input device has been stopped";
   ShutDownOnIOThread();
 }
 
 // AudioInputDevice::AudioThreadCallback
 AudioInputDevice::AudioThreadCallback::AudioThreadCallback(
-    const media::AudioParameters& audio_parameters,
+    const AudioParameters& audio_parameters,
     base::SharedMemoryHandle memory,
     int memory_length,
     CaptureCallback* capture_callback)
     : AudioDeviceThread::Callback(audio_parameters, memory, memory_length),
       capture_callback_(capture_callback) {
 }
 
 AudioInputDevice::AudioThreadCallback::~AudioThreadCallback() {
 }
 
 void AudioInputDevice::AudioThreadCallback::MapSharedMemory() {
   shared_memory_.Map(memory_length_);
 }
 
 void AudioInputDevice::AudioThreadCallback::Process(int pending_data) {
   // The shared memory represents parameters, size of the data buffer and the
   // actual data buffer containing audio data. Map the memory into this
   // structure and parse out parameters and the data area.
-  media::AudioInputBuffer* buffer =
-      reinterpret_cast<media::AudioInputBuffer*>(shared_memory_.memory());
+  AudioInputBuffer* buffer =
+      reinterpret_cast<AudioInputBuffer*>(shared_memory_.memory());
   DCHECK_EQ(buffer->params.size,
-            memory_length_ - sizeof(media::AudioInputBufferParameters));
+            memory_length_ - sizeof(AudioInputBufferParameters));
   double volume = buffer->params.volume;
 
   int audio_delay_milliseconds = pending_data / bytes_per_ms_;
   int16* memory = reinterpret_cast<int16*>(&buffer->audio[0]);
   const size_t number_of_frames = audio_parameters_.frames_per_buffer();
   const int bytes_per_sample = sizeof(memory[0]);
 
   // Deinterleave each channel and convert to 32-bit floating-point
   // with nominal range -1.0 -> +1.0.
   for (int channel_index = 0; channel_index < audio_parameters_.channels();
        ++channel_index) {
-    media::DeinterleaveAudioChannel(memory,
-                                    audio_data_[channel_index],
-                                    audio_parameters_.channels(),
-                                    channel_index,
-                                    bytes_per_sample,
-                                    number_of_frames);
+    DeinterleaveAudioChannel(memory,
+                             audio_data_[channel_index],
+                             audio_parameters_.channels(),
+                             channel_index,
+                             bytes_per_sample,
+                             number_of_frames);
   }
 
   // Deliver captured data to the client in floating point format
   // and update the audio-delay measurement.
   capture_callback_->Capture(audio_data_, number_of_frames,
                              audio_delay_milliseconds, volume);
 }
+
+}  // namespace media