| /* //device/servers/AudioFlinger/AudioDumpInterface.cpp |
| ** |
| ** Copyright 2008, The Android Open Source Project |
| ** |
| ** Licensed under the Apache License, Version 2.0 (the "License"); |
| ** you may not use this file except in compliance with the License. |
| ** You may obtain a copy of the License at |
| ** |
| ** http://www.apache.org/licenses/LICENSE-2.0 |
| ** |
| ** Unless required by applicable law or agreed to in writing, software |
| ** distributed under the License is distributed on an "AS IS" BASIS, |
| ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| ** See the License for the specific language governing permissions and |
| ** limitations under the License. |
| */ |
| |
| #define LOG_TAG "AudioFlingerDump" |
| //#define LOG_NDEBUG 0 |
| |
| #include <stdint.h> |
| #include <sys/types.h> |
| #include <utils/Log.h> |
| |
| #include <stdlib.h> |
| #include <unistd.h> |
| |
| #include "AudioDumpInterface.h" |
| |
| namespace android { |
| |
| // ---------------------------------------------------------------------------- |
| |
| AudioDumpInterface::AudioDumpInterface(AudioHardwareInterface* hw) |
| : mPolicyCommands(String8("")), mFileName(String8("")) |
| { |
| if(hw == 0) { |
| ALOGE("Dump construct hw = 0"); |
| } |
| mFinalInterface = hw; |
| ALOGV("Constructor %p, mFinalInterface %p", this, mFinalInterface); |
| } |
| |
| |
| AudioDumpInterface::~AudioDumpInterface() |
| { |
| for (size_t i = 0; i < mOutputs.size(); i++) { |
| closeOutputStream((AudioStreamOut *)mOutputs[i]); |
| } |
| |
| for (size_t i = 0; i < mInputs.size(); i++) { |
| closeInputStream((AudioStreamIn *)mInputs[i]); |
| } |
| |
| if(mFinalInterface) delete mFinalInterface; |
| } |
| |
| |
| AudioStreamOut* AudioDumpInterface::openOutputStream( |
| uint32_t devices, int *format, uint32_t *channels, uint32_t *sampleRate, status_t *status) |
| { |
| AudioStreamOut* outFinal = NULL; |
| int lFormat = AudioSystem::PCM_16_BIT; |
| uint32_t lChannels = AudioSystem::CHANNEL_OUT_STEREO; |
| uint32_t lRate = 44100; |
| |
| |
| outFinal = mFinalInterface->openOutputStream(devices, format, channels, sampleRate, status); |
| if (outFinal != 0) { |
| lFormat = outFinal->format(); |
| lChannels = outFinal->channels(); |
| lRate = outFinal->sampleRate(); |
| } else { |
| if (format != 0) { |
| if (*format != 0) { |
| lFormat = *format; |
| } else { |
| *format = lFormat; |
| } |
| } |
| if (channels != 0) { |
| if (*channels != 0) { |
| lChannels = *channels; |
| } else { |
| *channels = lChannels; |
| } |
| } |
| if (sampleRate != 0) { |
| if (*sampleRate != 0) { |
| lRate = *sampleRate; |
| } else { |
| *sampleRate = lRate; |
| } |
| } |
| if (status) *status = NO_ERROR; |
| } |
| ALOGV("openOutputStream(), outFinal %p", outFinal); |
| |
| AudioStreamOutDump *dumOutput = new AudioStreamOutDump(this, mOutputs.size(), outFinal, |
| devices, lFormat, lChannels, lRate); |
| mOutputs.add(dumOutput); |
| |
| return dumOutput; |
| } |
| |
| void AudioDumpInterface::closeOutputStream(AudioStreamOut* out) |
| { |
| AudioStreamOutDump *dumpOut = (AudioStreamOutDump *)out; |
| |
| if (mOutputs.indexOf(dumpOut) < 0) { |
| ALOGW("Attempt to close invalid output stream"); |
| return; |
| } |
| |
| ALOGV("closeOutputStream() output %p", out); |
| |
| dumpOut->standby(); |
| if (dumpOut->finalStream() != NULL) { |
| mFinalInterface->closeOutputStream(dumpOut->finalStream()); |
| } |
| |
| mOutputs.remove(dumpOut); |
| delete dumpOut; |
| } |
| |
| AudioStreamIn* AudioDumpInterface::openInputStream(uint32_t devices, int *format, uint32_t *channels, |
| uint32_t *sampleRate, status_t *status, AudioSystem::audio_in_acoustics acoustics) |
| { |
| AudioStreamIn* inFinal = NULL; |
| int lFormat = AudioSystem::PCM_16_BIT; |
| uint32_t lChannels = AudioSystem::CHANNEL_IN_MONO; |
| uint32_t lRate = 8000; |
| |
| inFinal = mFinalInterface->openInputStream(devices, format, channels, sampleRate, status, acoustics); |
| if (inFinal != 0) { |
| lFormat = inFinal->format(); |
| lChannels = inFinal->channels(); |
| lRate = inFinal->sampleRate(); |
| } else { |
| if (format != 0) { |
| if (*format != 0) { |
| lFormat = *format; |
| } else { |
| *format = lFormat; |
| } |
| } |
| if (channels != 0) { |
| if (*channels != 0) { |
| lChannels = *channels; |
| } else { |
| *channels = lChannels; |
| } |
| } |
| if (sampleRate != 0) { |
| if (*sampleRate != 0) { |
| lRate = *sampleRate; |
| } else { |
| *sampleRate = lRate; |
| } |
| } |
| if (status) *status = NO_ERROR; |
| } |
| ALOGV("openInputStream(), inFinal %p", inFinal); |
| |
| AudioStreamInDump *dumInput = new AudioStreamInDump(this, mInputs.size(), inFinal, |
| devices, lFormat, lChannels, lRate); |
| mInputs.add(dumInput); |
| |
| return dumInput; |
| } |
| void AudioDumpInterface::closeInputStream(AudioStreamIn* in) |
| { |
| AudioStreamInDump *dumpIn = (AudioStreamInDump *)in; |
| |
| if (mInputs.indexOf(dumpIn) < 0) { |
| ALOGW("Attempt to close invalid input stream"); |
| return; |
| } |
| dumpIn->standby(); |
| if (dumpIn->finalStream() != NULL) { |
| mFinalInterface->closeInputStream(dumpIn->finalStream()); |
| } |
| |
| mInputs.remove(dumpIn); |
| delete dumpIn; |
| } |
| |
| |
| status_t AudioDumpInterface::setParameters(const String8& keyValuePairs) |
| { |
| AudioParameter param = AudioParameter(keyValuePairs); |
| String8 value; |
| int valueInt; |
| ALOGV("setParameters %s", keyValuePairs.string()); |
| |
| if (param.get(String8("test_cmd_file_name"), value) == NO_ERROR) { |
| mFileName = value; |
| param.remove(String8("test_cmd_file_name")); |
| } |
| if (param.get(String8("test_cmd_policy"), value) == NO_ERROR) { |
| Mutex::Autolock _l(mLock); |
| param.remove(String8("test_cmd_policy")); |
| mPolicyCommands = param.toString(); |
| ALOGV("test_cmd_policy command %s written", mPolicyCommands.string()); |
| return NO_ERROR; |
| } |
| |
| if (mFinalInterface != 0 ) return mFinalInterface->setParameters(keyValuePairs); |
| return NO_ERROR; |
| } |
| |
| String8 AudioDumpInterface::getParameters(const String8& keys) |
| { |
| AudioParameter param = AudioParameter(keys); |
| AudioParameter response; |
| String8 value; |
| |
| // ALOGV("getParameters %s", keys.string()); |
| if (param.get(String8("test_cmd_policy"), value) == NO_ERROR) { |
| Mutex::Autolock _l(mLock); |
| if (mPolicyCommands.length() != 0) { |
| response = AudioParameter(mPolicyCommands); |
| response.addInt(String8("test_cmd_policy"), 1); |
| } else { |
| response.addInt(String8("test_cmd_policy"), 0); |
| } |
| param.remove(String8("test_cmd_policy")); |
| // ALOGV("test_cmd_policy command %s read", mPolicyCommands.string()); |
| } |
| |
| if (param.get(String8("test_cmd_file_name"), value) == NO_ERROR) { |
| response.add(String8("test_cmd_file_name"), mFileName); |
| param.remove(String8("test_cmd_file_name")); |
| } |
| |
| String8 keyValuePairs = response.toString(); |
| |
| if (param.size() && mFinalInterface != 0 ) { |
| keyValuePairs += ";"; |
| keyValuePairs += mFinalInterface->getParameters(param.toString()); |
| } |
| |
| return keyValuePairs; |
| } |
| |
| status_t AudioDumpInterface::setMode(int mode) |
| { |
| return mFinalInterface->setMode(mode); |
| } |
| |
| size_t AudioDumpInterface::getInputBufferSize(uint32_t sampleRate, int format, int channelCount) |
| { |
| return mFinalInterface->getInputBufferSize(sampleRate, format, channelCount); |
| } |
| |
| // ---------------------------------------------------------------------------- |
| |
| AudioStreamOutDump::AudioStreamOutDump(AudioDumpInterface *interface, |
| int id, |
| AudioStreamOut* finalStream, |
| uint32_t devices, |
| int format, |
| uint32_t channels, |
| uint32_t sampleRate) |
| : mInterface(interface), mId(id), |
| mSampleRate(sampleRate), mFormat(format), mChannels(channels), mLatency(0), mDevice(devices), |
| mBufferSize(1024), mFinalStream(finalStream), mFile(0), mFileCount(0) |
| { |
| ALOGV("AudioStreamOutDump Constructor %p, mInterface %p, mFinalStream %p", this, mInterface, mFinalStream); |
| } |
| |
| |
| AudioStreamOutDump::~AudioStreamOutDump() |
| { |
| ALOGV("AudioStreamOutDump destructor"); |
| Close(); |
| } |
| |
| ssize_t AudioStreamOutDump::write(const void* buffer, size_t bytes) |
| { |
| ssize_t ret; |
| |
| if (mFinalStream) { |
| ret = mFinalStream->write(buffer, bytes); |
| } else { |
| usleep((((bytes * 1000) / frameSize()) / sampleRate()) * 1000); |
| ret = bytes; |
| } |
| if(!mFile) { |
| if (mInterface->fileName() != "") { |
| char name[255]; |
| sprintf(name, "%s_out_%d_%d.pcm", mInterface->fileName().string(), mId, ++mFileCount); |
| mFile = fopen(name, "wb"); |
| ALOGV("Opening dump file %s, fh %p", name, mFile); |
| } |
| } |
| if (mFile) { |
| fwrite(buffer, bytes, 1, mFile); |
| } |
| return ret; |
| } |
| |
| status_t AudioStreamOutDump::standby() |
| { |
| ALOGV("AudioStreamOutDump standby(), mFile %p, mFinalStream %p", mFile, mFinalStream); |
| |
| Close(); |
| if (mFinalStream != 0 ) return mFinalStream->standby(); |
| return NO_ERROR; |
| } |
| |
| uint32_t AudioStreamOutDump::sampleRate() const |
| { |
| if (mFinalStream != 0 ) return mFinalStream->sampleRate(); |
| return mSampleRate; |
| } |
| |
| size_t AudioStreamOutDump::bufferSize() const |
| { |
| if (mFinalStream != 0 ) return mFinalStream->bufferSize(); |
| return mBufferSize; |
| } |
| |
| uint32_t AudioStreamOutDump::channels() const |
| { |
| if (mFinalStream != 0 ) return mFinalStream->channels(); |
| return mChannels; |
| } |
| int AudioStreamOutDump::format() const |
| { |
| if (mFinalStream != 0 ) return mFinalStream->format(); |
| return mFormat; |
| } |
| uint32_t AudioStreamOutDump::latency() const |
| { |
| if (mFinalStream != 0 ) return mFinalStream->latency(); |
| return 0; |
| } |
| status_t AudioStreamOutDump::setVolume(float left, float right) |
| { |
| if (mFinalStream != 0 ) return mFinalStream->setVolume(left, right); |
| return NO_ERROR; |
| } |
| status_t AudioStreamOutDump::setParameters(const String8& keyValuePairs) |
| { |
| ALOGV("AudioStreamOutDump::setParameters %s", keyValuePairs.string()); |
| |
| if (mFinalStream != 0 ) { |
| return mFinalStream->setParameters(keyValuePairs); |
| } |
| |
| AudioParameter param = AudioParameter(keyValuePairs); |
| String8 value; |
| int valueInt; |
| status_t status = NO_ERROR; |
| |
| if (param.getInt(String8("set_id"), valueInt) == NO_ERROR) { |
| mId = valueInt; |
| } |
| |
| if (param.getInt(String8("format"), valueInt) == NO_ERROR) { |
| if (mFile == 0) { |
| mFormat = valueInt; |
| } else { |
| status = INVALID_OPERATION; |
| } |
| } |
| if (param.getInt(String8("channels"), valueInt) == NO_ERROR) { |
| if (valueInt == AudioSystem::CHANNEL_OUT_STEREO || valueInt == AudioSystem::CHANNEL_OUT_MONO) { |
| mChannels = valueInt; |
| } else { |
| status = BAD_VALUE; |
| } |
| } |
| if (param.getInt(String8("sampling_rate"), valueInt) == NO_ERROR) { |
| if (valueInt > 0 && valueInt <= 48000) { |
| if (mFile == 0) { |
| mSampleRate = valueInt; |
| } else { |
| status = INVALID_OPERATION; |
| } |
| } else { |
| status = BAD_VALUE; |
| } |
| } |
| return status; |
| } |
| |
| String8 AudioStreamOutDump::getParameters(const String8& keys) |
| { |
| if (mFinalStream != 0 ) return mFinalStream->getParameters(keys); |
| |
| AudioParameter param = AudioParameter(keys); |
| return param.toString(); |
| } |
| |
| status_t AudioStreamOutDump::dump(int fd, const Vector<String16>& args) |
| { |
| if (mFinalStream != 0 ) return mFinalStream->dump(fd, args); |
| return NO_ERROR; |
| } |
| |
| void AudioStreamOutDump::Close() |
| { |
| if(mFile) { |
| fclose(mFile); |
| mFile = 0; |
| } |
| } |
| |
| status_t AudioStreamOutDump::getRenderPosition(uint32_t *dspFrames) |
| { |
| if (mFinalStream != 0 ) return mFinalStream->getRenderPosition(dspFrames); |
| return INVALID_OPERATION; |
| } |
| |
| // ---------------------------------------------------------------------------- |
| |
| AudioStreamInDump::AudioStreamInDump(AudioDumpInterface *interface, |
| int id, |
| AudioStreamIn* finalStream, |
| uint32_t devices, |
| int format, |
| uint32_t channels, |
| uint32_t sampleRate) |
| : mInterface(interface), mId(id), |
| mSampleRate(sampleRate), mFormat(format), mChannels(channels), mDevice(devices), |
| mBufferSize(1024), mFinalStream(finalStream), mFile(0), mFileCount(0) |
| { |
| ALOGV("AudioStreamInDump Constructor %p, mInterface %p, mFinalStream %p", this, mInterface, mFinalStream); |
| } |
| |
| |
| AudioStreamInDump::~AudioStreamInDump() |
| { |
| Close(); |
| } |
| |
| ssize_t AudioStreamInDump::read(void* buffer, ssize_t bytes) |
| { |
| ssize_t ret; |
| |
| if (mFinalStream) { |
| ret = mFinalStream->read(buffer, bytes); |
| if(!mFile) { |
| if (mInterface->fileName() != "") { |
| char name[255]; |
| sprintf(name, "%s_in_%d_%d.pcm", mInterface->fileName().string(), mId, ++mFileCount); |
| mFile = fopen(name, "wb"); |
| ALOGV("Opening input dump file %s, fh %p", name, mFile); |
| } |
| } |
| if (mFile) { |
| fwrite(buffer, bytes, 1, mFile); |
| } |
| } else { |
| usleep((((bytes * 1000) / frameSize()) / sampleRate()) * 1000); |
| ret = bytes; |
| if(!mFile) { |
| char name[255]; |
| strcpy(name, "/sdcard/music/sine440"); |
| if (channels() == AudioSystem::CHANNEL_IN_MONO) { |
| strcat(name, "_mo"); |
| } else { |
| strcat(name, "_st"); |
| } |
| if (format() == AudioSystem::PCM_16_BIT) { |
| strcat(name, "_16b"); |
| } else { |
| strcat(name, "_8b"); |
| } |
| if (sampleRate() < 16000) { |
| strcat(name, "_8k"); |
| } else if (sampleRate() < 32000) { |
| strcat(name, "_22k"); |
| } else if (sampleRate() < 48000) { |
| strcat(name, "_44k"); |
| } else { |
| strcat(name, "_48k"); |
| } |
| strcat(name, ".wav"); |
| mFile = fopen(name, "rb"); |
| ALOGV("Opening input read file %s, fh %p", name, mFile); |
| if (mFile) { |
| fseek(mFile, AUDIO_DUMP_WAVE_HDR_SIZE, SEEK_SET); |
| } |
| } |
| if (mFile) { |
| ssize_t bytesRead = fread(buffer, bytes, 1, mFile); |
| if (bytesRead >=0 && bytesRead < bytes) { |
| fseek(mFile, AUDIO_DUMP_WAVE_HDR_SIZE, SEEK_SET); |
| fread((uint8_t *)buffer+bytesRead, bytes-bytesRead, 1, mFile); |
| } |
| } |
| } |
| |
| return ret; |
| } |
| |
| status_t AudioStreamInDump::standby() |
| { |
| ALOGV("AudioStreamInDump standby(), mFile %p, mFinalStream %p", mFile, mFinalStream); |
| |
| Close(); |
| if (mFinalStream != 0 ) return mFinalStream->standby(); |
| return NO_ERROR; |
| } |
| |
| status_t AudioStreamInDump::setGain(float gain) |
| { |
| if (mFinalStream != 0 ) return mFinalStream->setGain(gain); |
| return NO_ERROR; |
| } |
| |
| uint32_t AudioStreamInDump::sampleRate() const |
| { |
| if (mFinalStream != 0 ) return mFinalStream->sampleRate(); |
| return mSampleRate; |
| } |
| |
| size_t AudioStreamInDump::bufferSize() const |
| { |
| if (mFinalStream != 0 ) return mFinalStream->bufferSize(); |
| return mBufferSize; |
| } |
| |
| uint32_t AudioStreamInDump::channels() const |
| { |
| if (mFinalStream != 0 ) return mFinalStream->channels(); |
| return mChannels; |
| } |
| |
| int AudioStreamInDump::format() const |
| { |
| if (mFinalStream != 0 ) return mFinalStream->format(); |
| return mFormat; |
| } |
| |
| status_t AudioStreamInDump::setParameters(const String8& keyValuePairs) |
| { |
| ALOGV("AudioStreamInDump::setParameters()"); |
| if (mFinalStream != 0 ) return mFinalStream->setParameters(keyValuePairs); |
| return NO_ERROR; |
| } |
| |
| String8 AudioStreamInDump::getParameters(const String8& keys) |
| { |
| if (mFinalStream != 0 ) return mFinalStream->getParameters(keys); |
| |
| AudioParameter param = AudioParameter(keys); |
| return param.toString(); |
| } |
| |
| unsigned int AudioStreamInDump::getInputFramesLost() const |
| { |
| if (mFinalStream != 0 ) return mFinalStream->getInputFramesLost(); |
| return 0; |
| } |
| |
| status_t AudioStreamInDump::dump(int fd, const Vector<String16>& args) |
| { |
| if (mFinalStream != 0 ) return mFinalStream->dump(fd, args); |
| return NO_ERROR; |
| } |
| |
| void AudioStreamInDump::Close() |
| { |
| if(mFile) { |
| fclose(mFile); |
| mFile = 0; |
| } |
| } |
| }; // namespace android |
