audio/AudioHardwareInterface.cpp

   1 /*
   2 **
   3 ** Copyright 2007, The Android Open Source Project
   4 **
   5 ** Licensed under the Apache License, Version 2.0 (the "License");
   6 ** you may not use this file except in compliance with the License.
   7 ** You may obtain a copy of the License at
   8 **
   9 **     http://www.apache.org/licenses/LICENSE-2.0
  10 **
  11 ** Unless required by applicable law or agreed to in writing, software
  12 ** distributed under the License is distributed on an "AS IS" BASIS,
  13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 ** See the License for the specific language governing permissions and
  15 ** limitations under the License.
  16 */
  17
  18 #include <cutils/properties.h>
  19 #include <string.h>
  20 #include <unistd.h>
  21 //#define LOG_NDEBUG 0
  22
  23 #define LOG_TAG "AudioHardwareInterface"
  24 #include <utils/Log.h>
  25 #include <utils/String8.h>
  26
  27 #include "AudioHardwareStub.h"
  28 #include "AudioHardwareGeneric.h"
  29 #ifdef WITH_A2DP
  30 #include "A2dpAudioInterface.h"
  31 #endif
  32
  33 #ifdef ENABLE_AUDIO_DUMP
  34 #include "AudioDumpInterface.h"
  35 #endif
  36
  37
  38 // change to 1 to log routing calls
  39 #define LOG_ROUTING_CALLS 1
  40
  41 namespace android {
  42
  43 #if LOG_ROUTING_CALLS
  44 static const char* routingModeStrings[] =
  45 {
  46     "OUT OF RANGE",
  47     "INVALID",
  48     "CURRENT",
  49     "NORMAL",
  50     "RINGTONE",
  51     "IN_CALL",
  52     "IN_COMMUNICATION"
  53 };
  54
  55 static const char* routeNone = "NONE";
  56
  57 static const char* displayMode(int mode)
  58 {
  59     if ((mode < AudioSystem::MODE_INVALID) || (mode >= AudioSystem::NUM_MODES))
  60         return routingModeStrings[0];
  61     return routingModeStrings[mode+3];
  62 }
  63 #endif
  64
  65 // ----------------------------------------------------------------------------
  66
  67 AudioHardwareInterface* AudioHardwareInterface::create()
  68 {
  69     /*
  70      * FIXME: This code needs to instantiate the correct audio device
  71      * interface. For now - we use compile-time switches.
  72      */
  73     AudioHardwareInterface* hw = 0;
  74     char value[PROPERTY_VALUE_MAX];
  75
  76 #ifdef GENERIC_AUDIO
  77     hw = new AudioHardwareGeneric();
  78 #else
  79     // if running in emulation - use the emulator driver
  80     if (property_get("ro.kernel.qemu", value, 0)) {
  81         LOGD("Running in emulation - using generic audio driver");
  82         hw = new AudioHardwareGeneric();
  83     }
  84     else {
  85         LOGV("Creating Vendor Specific AudioHardware");
  86         hw = createAudioHardware();
  87     }
  88 #endif
  89     if (hw->initCheck() != NO_ERROR) {
  90         LOGW("Using stubbed audio hardware. No sound will be produced.");
  91         delete hw;
  92         hw = new AudioHardwareStub();
  93     }
  94
  95 #ifdef WITH_A2DP
  96     hw = new A2dpAudioInterface(hw);
  97 #endif
  98
  99 #ifdef ENABLE_AUDIO_DUMP
 100     // This code adds a record of buffers in a file to write calls made by AudioFlinger.
 101     // It replaces the current AudioHardwareInterface object by an intermediate one which
 102     // will record buffers in a file (after sending them to hardware) for testing purpose.
 103     // This feature is enabled by defining symbol ENABLE_AUDIO_DUMP.
 104     // The output file is set with setParameters("test_cmd_file_name=<name>"). Pause are not recorded in the file.
 105     LOGV("opening PCM dump interface");
 106     hw = new AudioDumpInterface(hw);    // replace interface
 107 #endif
 108     return hw;
 109 }
 110
 111 AudioStreamOut::~AudioStreamOut()
 112 {
 113 }
 114
 115 AudioStreamIn::~AudioStreamIn() {}
 116
 117 AudioHardwareBase::AudioHardwareBase()
 118 {
 119     mMode = 0;
 120 }
 121
 122 status_t AudioHardwareBase::setMode(int mode)
 123 {
 124 #if LOG_ROUTING_CALLS
 125     LOGD("setMode(%s)", displayMode(mode));
 126 #endif
 127     if ((mode < 0) || (mode >= AudioSystem::NUM_MODES))
 128         return BAD_VALUE;
 129     if (mMode == mode)
 130         return ALREADY_EXISTS;
 131     mMode = mode;
 132     return NO_ERROR;
 133 }
 134
 135 // default implementation
 136 status_t AudioHardwareBase::setParameters(const String8& keyValuePairs)
 137 {
 138     return NO_ERROR;
 139 }
 140
 141 // default implementation
 142 String8 AudioHardwareBase::getParameters(const String8& keys)
 143 {
 144     AudioParameter param = AudioParameter(keys);
 145     return param.toString();
 146 }
 147
 148 // default implementation
 149 size_t AudioHardwareBase::getInputBufferSize(uint32_t sampleRate, int format, int channelCount)
 150 {
 151     if (sampleRate != 8000) {
 152         LOGW("getInputBufferSize bad sampling rate: %d", sampleRate);
 153         return 0;
 154     }
 155     if (format != AudioSystem::PCM_16_BIT) {
 156         LOGW("getInputBufferSize bad format: %d", format);
 157         return 0;
 158     }
 159     if (channelCount != 1) {
 160         LOGW("getInputBufferSize bad channel count: %d", channelCount);
 161         return 0;
 162     }
 163
 164     return 320;
 165 }
 166
 167 status_t AudioHardwareBase::dumpState(int fd, const Vector<String16>& args)
 168 {
 169     const size_t SIZE = 256;
 170     char buffer[SIZE];
 171     String8 result;
 172     snprintf(buffer, SIZE, "AudioHardwareBase::dumpState\n");
 173     result.append(buffer);
 174     snprintf(buffer, SIZE, "\tmMode: %d\n", mMode);
 175     result.append(buffer);
 176     ::write(fd, result.string(), result.size());
 177     dump(fd, args);  // Dump the state of the concrete child.
 178     return NO_ERROR;
 179 }
 180
 181 // ----------------------------------------------------------------------------
 182
 183 }; // namespace android