Home | History | Annotate | Download | only in audio 
      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 
     30 #ifdef ENABLE_AUDIO_DUMP
     31 #include "AudioDumpInterface.h"
     32 #endif
     33 
     34 
     35 // change to 1 to log routing calls
     36 #define LOG_ROUTING_CALLS 1
     37 
     38 namespace android_audio_legacy {
     39 
     40 #if LOG_ROUTING_CALLS
     41 static const char* routingModeStrings[] =
     42 {
     43     "OUT OF RANGE",
     44     "INVALID",
     45     "CURRENT",
     46     "NORMAL",
     47     "RINGTONE",
     48     "IN_CALL",
     49     "IN_COMMUNICATION"
     50 };
     51 
     52 static const char* routeNone = "NONE";
     53 
     54 static const char* displayMode(int mode)
     55 {
     56     if ((mode < AudioSystem::MODE_INVALID) || (mode >= AudioSystem::NUM_MODES))
     57         return routingModeStrings[0];
     58     return routingModeStrings[mode+3];
     59 }
     60 #endif
     61 
     62 // ----------------------------------------------------------------------------
     63 
     64 AudioHardwareInterface* AudioHardwareInterface::create()
     65 {
     66     return NULL;
     67 }
     68 
     69 AudioStreamOut::~AudioStreamOut()
     70 {
     71 }
     72 
     73 // default implementation is unsupported
     74 status_t AudioStreamOut::getNextWriteTimestamp(int64_t *timestamp)
     75 {
     76     return INVALID_OPERATION;
     77 }
     78 
     79 AudioStreamIn::~AudioStreamIn() {}
     80 
     81 AudioHardwareBase::AudioHardwareBase()
     82 {
     83     mMode = 0;
     84 }
     85 
     86 status_t AudioHardwareBase::setMode(int mode)
     87 {
     88 #if LOG_ROUTING_CALLS
     89     ALOGD("setMode(%s)", displayMode(mode));
     90 #endif
     91     if ((mode < 0) || (mode >= AudioSystem::NUM_MODES))
     92         return BAD_VALUE;
     93     if (mMode == mode)
     94         return ALREADY_EXISTS;
     95     mMode = mode;
     96     return NO_ERROR;
     97 }
     98 
     99 // default implementation
    100 status_t AudioHardwareBase::setParameters(const String8& keyValuePairs)
    101 {
    102     return NO_ERROR;
    103 }
    104 
    105 // default implementation
    106 String8 AudioHardwareBase::getParameters(const String8& keys)
    107 {
    108     AudioParameter param = AudioParameter(keys);
    109     return param.toString();
    110 }
    111 
    112 // default implementation
    113 size_t AudioHardwareBase::getInputBufferSize(uint32_t sampleRate, int format, int channelCount)
    114 {
    115     if (sampleRate != 8000) {
    116         ALOGW("getInputBufferSize bad sampling rate: %d", sampleRate);
    117         return 0;
    118     }
    119     if (format != AudioSystem::PCM_16_BIT) {
    120         ALOGW("getInputBufferSize bad format: %d", format);
    121         return 0;
    122     }
    123     if (channelCount != 1) {
    124         ALOGW("getInputBufferSize bad channel count: %d", channelCount);
    125         return 0;
    126     }
    127 
    128     return 320;
    129 }
    130 
    131 // default implementation is unsupported
    132 status_t AudioHardwareBase::getMasterVolume(float *volume)
    133 {
    134     return INVALID_OPERATION;
    135 }
    136 
    137 status_t AudioHardwareBase::dumpState(int fd, const Vector<String16>& args)
    138 {
    139     const size_t SIZE = 256;
    140     char buffer[SIZE];
    141     String8 result;
    142     snprintf(buffer, SIZE, "AudioHardwareBase::dumpState\n");
    143     result.append(buffer);
    144     snprintf(buffer, SIZE, "\tmMode: %d\n", mMode);
    145     result.append(buffer);
    146     ::write(fd, result.string(), result.size());
    147     dump(fd, args);  // Dump the state of the concrete child.
    148     return NO_ERROR;
    149 }
    150 
    151 // default implementation calls its "without flags" counterpart
    152 AudioStreamOut* AudioHardwareInterface::openOutputStreamWithFlags(uint32_t devices,
    153                                           audio_output_flags_t flags,
    154                                           int *format,
    155                                           uint32_t *channels,
    156                                           uint32_t *sampleRate,
    157                                           status_t *status)
    158 {
    159     return openOutputStream(devices, format, channels, sampleRate, status);
    160 }
    161 
    162 // ----------------------------------------------------------------------------
    163 
    164 }; // namespace android
    165