Move media/audio files into media namespace

media/audio/linux/alsa_util.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/audio/linux/alsa_util.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "media/audio/linux/alsa_wrapper.h"
 
 namespace alsa_util {
 
-static snd_pcm_t* OpenDevice(AlsaWrapper* wrapper,
+static snd_pcm_t* OpenDevice(media::AlsaWrapper* wrapper,
                              const char* device_name,
                              snd_pcm_stream_t type,
                              int channels,
                              int sample_rate,
                              snd_pcm_format_t pcm_format,
                              int latency_us) {
   snd_pcm_t* handle = NULL;
   int error = wrapper->PcmOpen(&handle, device_name, type, SND_PCM_NONBLOCK);
   if (error < 0) {
     LOG(WARNING) << "PcmOpen: " << device_name << ","
@@ skipping 49 matching lines @@
       return SND_PCM_FORMAT_S24;
 
     case 32:
       return SND_PCM_FORMAT_S32;
 
     default:
       return SND_PCM_FORMAT_UNKNOWN;
   }
 }
 
-int CloseDevice(AlsaWrapper* wrapper, snd_pcm_t* handle) {
+int CloseDevice(media::AlsaWrapper* wrapper, snd_pcm_t* handle) {
   std::string device_name = wrapper->PcmName(handle);
   int error = wrapper->PcmClose(handle);
   if (error < 0) {
     LOG(ERROR) << "PcmClose: " << device_name << ", "
                << wrapper->StrError(error);
   }
 
   return error;
 }
 
-snd_pcm_t* OpenCaptureDevice(AlsaWrapper* wrapper,
+snd_pcm_t* OpenCaptureDevice(media::AlsaWrapper* wrapper,
                              const char* device_name,
                              int channels,
                              int sample_rate,
                              snd_pcm_format_t pcm_format,
                              int latency_us) {
   return OpenDevice(wrapper, device_name, SND_PCM_STREAM_CAPTURE, channels,
                     sample_rate, pcm_format, latency_us);
 }
 
-snd_pcm_t* OpenPlaybackDevice(AlsaWrapper* wrapper,
+snd_pcm_t* OpenPlaybackDevice(media::AlsaWrapper* wrapper,
                               const char* device_name,
                               int channels,
                               int sample_rate,
                               snd_pcm_format_t pcm_format,
                               int latency_us) {
   return OpenDevice(wrapper, device_name, SND_PCM_STREAM_PLAYBACK, channels,
                     sample_rate, pcm_format, latency_us);
 }
 
-snd_mixer_t* OpenMixer(AlsaWrapper* wrapper,
+snd_mixer_t* OpenMixer(media::AlsaWrapper* wrapper,
                        const std::string& device_name) {
   snd_mixer_t* mixer = NULL;
 
   int error = wrapper->MixerOpen(&mixer, 0);
   if (error < 0) {
     LOG(ERROR) << "MixerOpen: " << device_name << ", "
                << wrapper->StrError(error);
     return NULL;
   }
 
@@ skipping 10 matching lines @@
   if (error < 0) {
     LOG(ERROR) << "MixerElementRegister: " << control_name << ", "
                << wrapper->StrError(error);
     alsa_util::CloseMixer(wrapper, mixer, device_name);
     return NULL;
   }
 
   return mixer;
 }
 
-void CloseMixer(AlsaWrapper* wrapper, snd_mixer_t* mixer,
+void CloseMixer(media::AlsaWrapper* wrapper, snd_mixer_t* mixer,
                 const std::string& device_name) {
   if (!mixer)
     return;
 
   wrapper->MixerFree(mixer);
 
   int error = 0;
   if (!device_name.empty()) {
     std::string control_name = DeviceNameToControlName(device_name);
     error = wrapper->MixerDetach(mixer, control_name.c_str());
     if (error < 0) {
       LOG(WARNING) << "MixerDetach: " << control_name << ", "
                    << wrapper->StrError(error);
     }
   }
 
   error = wrapper->MixerClose(mixer);
   if (error < 0) {
     LOG(WARNING) << "MixerClose: " << wrapper->StrError(error);
   }
 }
 
-snd_mixer_elem_t* LoadCaptureMixerElement(AlsaWrapper* wrapper,
+snd_mixer_elem_t* LoadCaptureMixerElement(media::AlsaWrapper* wrapper,
                                           snd_mixer_t* mixer) {
   if (!mixer)
     return NULL;
 
   int error = wrapper->MixerLoad(mixer);
   if (error < 0) {
     LOG(ERROR) << "MixerLoad: " << wrapper->StrError(error);
     return NULL;
   }
 
@@ skipping 11 matching lines @@
       else if (strcmp(elem_name, kMicElemName) == 0)
         mic_elem = elem;
     }
   }
 
   // Did not find any Capture handle, use the Mic handle.
   return mic_elem;
 }
 
 }  // namespace alsa_util