audio/AudioHardwareStub.cpp

   1 /* //device/servers/AudioFlinger/AudioHardwareStub.cpp
   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 <stdint.h>
  19 #include <sys/types.h>
  20
  21 #include <stdlib.h>
  22 #include <unistd.h>
  23 #include <utils/String8.h>
  24
  25 #include "AudioHardwareStub.h"
  26 #include <media/AudioRecord.h>
  27
  28 namespace android_audio_legacy {
  29
  30 // ----------------------------------------------------------------------------
  31
  32 AudioHardwareStub::AudioHardwareStub() : mMicMute(false)
  33 {
  34 }
  35
  36 AudioHardwareStub::~AudioHardwareStub()
  37 {
  38 }
  39
  40 status_t AudioHardwareStub::initCheck()
  41 {
  42     return NO_ERROR;
  43 }
  44
  45 AudioStreamOut* AudioHardwareStub::openOutputStream(
  46         uint32_t devices, int *format, uint32_t *channels, uint32_t *sampleRate, status_t *status)
  47 {
  48     AudioStreamOutStub* out = new AudioStreamOutStub();
  49     status_t lStatus = out->set(format, channels, sampleRate);
  50     if (status) {
  51         *status = lStatus;
  52     }
  53     if (lStatus == NO_ERROR)
  54         return out;
  55     delete out;
  56     return 0;
  57 }
  58
  59 void AudioHardwareStub::closeOutputStream(AudioStreamOut* out)
  60 {
  61     delete out;
  62 }
  63
  64 AudioStreamIn* AudioHardwareStub::openInputStream(
  65         uint32_t devices, int *format, uint32_t *channels, uint32_t *sampleRate,
  66         status_t *status, AudioSystem::audio_in_acoustics acoustics)
  67 {
  68     // check for valid input source
  69     if (!AudioSystem::isInputDevice((AudioSystem::audio_devices)devices)) {
  70         return 0;
  71     }
  72
  73     AudioStreamInStub* in = new AudioStreamInStub();
  74     status_t lStatus = in->set(format, channels, sampleRate, acoustics);
  75     if (status) {
  76         *status = lStatus;
  77     }
  78     if (lStatus == NO_ERROR)
  79         return in;
  80     delete in;
  81     return 0;
  82 }
  83
  84 void AudioHardwareStub::closeInputStream(AudioStreamIn* in)
  85 {
  86     delete in;
  87 }
  88
  89 status_t AudioHardwareStub::setVoiceVolume(float volume)
  90 {
  91     return NO_ERROR;
  92 }
  93
  94 status_t AudioHardwareStub::setMasterVolume(float volume)
  95 {
  96     return NO_ERROR;
  97 }
  98
  99 status_t AudioHardwareStub::dumpInternals(int fd, const Vector<String16>& args)
 100 {
 101     const size_t SIZE = 256;
 102     char buffer[SIZE];
 103     String8 result;
 104     result.append("AudioHardwareStub::dumpInternals\n");
 105     snprintf(buffer, SIZE, "\tmMicMute: %s\n", mMicMute? "true": "false");
 106     result.append(buffer);
 107     ::write(fd, result.string(), result.size());
 108     return NO_ERROR;
 109 }
 110
 111 status_t AudioHardwareStub::dump(int fd, const Vector<String16>& args)
 112 {
 113     dumpInternals(fd, args);
 114     return NO_ERROR;
 115 }
 116
 117 // ----------------------------------------------------------------------------
 118
 119 status_t AudioStreamOutStub::set(int *pFormat, uint32_t *pChannels, uint32_t *pRate)
 120 {
 121     if (pFormat) *pFormat = format();
 122     if (pChannels) *pChannels = channels();
 123     if (pRate) *pRate = sampleRate();
 124
 125     return NO_ERROR;
 126 }
 127
 128 ssize_t AudioStreamOutStub::write(const void* buffer, size_t bytes)
 129 {
 130     // fake timing for audio output
 131     usleep(bytes * 1000000 / sizeof(int16_t) / AudioSystem::popCount(channels()) / sampleRate());
 132     return bytes;
 133 }
 134
 135 status_t AudioStreamOutStub::standby()
 136 {
 137     return NO_ERROR;
 138 }
 139
 140 status_t AudioStreamOutStub::dump(int fd, const Vector<String16>& args)
 141 {
 142     const size_t SIZE = 256;
 143     char buffer[SIZE];
 144     String8 result;
 145     snprintf(buffer, SIZE, "AudioStreamOutStub::dump\n");
 146     snprintf(buffer, SIZE, "\tsample rate: %d\n", sampleRate());
 147     snprintf(buffer, SIZE, "\tbuffer size: %d\n", bufferSize());
 148     snprintf(buffer, SIZE, "\tchannels: %d\n", channels());
 149     snprintf(buffer, SIZE, "\tformat: %d\n", format());
 150     result.append(buffer);
 151     ::write(fd, result.string(), result.size());
 152     return NO_ERROR;
 153 }
 154
 155 String8 AudioStreamOutStub::getParameters(const String8& keys)
 156 {
 157     AudioParameter param = AudioParameter(keys);
 158     return param.toString();
 159 }
 160
 161 status_t AudioStreamOutStub::getRenderPosition(uint32_t *dspFrames)
 162 {
 163     return INVALID_OPERATION;
 164 }
 165
 166 // ----------------------------------------------------------------------------
 167
 168 status_t AudioStreamInStub::set(int *pFormat, uint32_t *pChannels, uint32_t *pRate,
 169                 AudioSystem::audio_in_acoustics acoustics)
 170 {
 171     return NO_ERROR;
 172 }
 173
 174 ssize_t AudioStreamInStub::read(void* buffer, ssize_t bytes)
 175 {
 176     // fake timing for audio input
 177     usleep(bytes * 1000000 / sizeof(int16_t) / AudioSystem::popCount(channels()) / sampleRate());
 178     memset(buffer, 0, bytes);
 179     return bytes;
 180 }
 181
 182 status_t AudioStreamInStub::dump(int fd, const Vector<String16>& args)
 183 {
 184     const size_t SIZE = 256;
 185     char buffer[SIZE];
 186     String8 result;
 187     snprintf(buffer, SIZE, "AudioStreamInStub::dump\n");
 188     result.append(buffer);
 189     snprintf(buffer, SIZE, "\tsample rate: %d\n", sampleRate());
 190     result.append(buffer);
 191     snprintf(buffer, SIZE, "\tbuffer size: %d\n", bufferSize());
 192     result.append(buffer);
 193     snprintf(buffer, SIZE, "\tchannels: %d\n", channels());
 194     result.append(buffer);
 195     snprintf(buffer, SIZE, "\tformat: %d\n", format());
 196     result.append(buffer);
 197     ::write(fd, result.string(), result.size());
 198     return NO_ERROR;
 199 }
 200
 201 String8 AudioStreamInStub::getParameters(const String8& keys)
 202 {
 203     AudioParameter param = AudioParameter(keys);
 204     return param.toString();
 205 }
 206
 207 // ----------------------------------------------------------------------------
 208
 209 }; // namespace android