Home | History | Annotate | Download | only in audio 
      1 /* //device/servers/AudioFlinger/AudioDumpInterface.cpp
      2 **
      3 ** Copyright 2008, 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 #define LOG_TAG "AudioFlingerDump"
     19 //#define LOG_NDEBUG 0
     20 
     21 #include <stdint.h>
     22 #include <sys/types.h>
     23 #include <utils/Log.h>
     24 
     25 #include <stdlib.h>
     26 #include <unistd.h>
     27 
     28 #include "AudioDumpInterface.h"
     29 
     30 namespace android {
     31 
     32 // ----------------------------------------------------------------------------
     33 
     34 AudioDumpInterface::AudioDumpInterface(AudioHardwareInterface* hw)
     35     : mPolicyCommands(String8("")), mFileName(String8(""))
     36 {
     37     if(hw == 0) {
     38         ALOGE("Dump construct hw = 0");
     39     }
     40     mFinalInterface = hw;
     41     ALOGV("Constructor %p, mFinalInterface %p", this, mFinalInterface);
     42 }
     43 
     44 
     45 AudioDumpInterface::~AudioDumpInterface()
     46 {
     47     for (size_t i = 0; i < mOutputs.size(); i++) {
     48         closeOutputStream((AudioStreamOut *)mOutputs[i]);
     49     }
     50 
     51     for (size_t i = 0; i < mInputs.size(); i++) {
     52         closeInputStream((AudioStreamIn *)mInputs[i]);
     53     }
     54 
     55     if(mFinalInterface) delete mFinalInterface;
     56 }
     57 
     58 
     59 AudioStreamOut* AudioDumpInterface::openOutputStream(
     60         uint32_t devices, int *format, uint32_t *channels, uint32_t *sampleRate, status_t *status)
     61 {
     62     AudioStreamOut* outFinal = NULL;
     63     int lFormat = AudioSystem::PCM_16_BIT;
     64     uint32_t lChannels = AudioSystem::CHANNEL_OUT_STEREO;
     65     uint32_t lRate = 44100;
     66 
     67 
     68     outFinal = mFinalInterface->openOutputStream(devices, format, channels, sampleRate, status);
     69     if (outFinal != 0) {
     70         lFormat = outFinal->format();
     71         lChannels = outFinal->channels();
     72         lRate = outFinal->sampleRate();
     73     } else {
     74         if (format != 0) {
     75             if (*format != 0) {
     76                 lFormat = *format;
     77             } else {
     78                 *format = lFormat;
     79             }
     80         }
     81         if (channels != 0) {
     82             if (*channels != 0) {
     83                 lChannels = *channels;
     84             } else {
     85                 *channels = lChannels;
     86             }
     87         }
     88         if (sampleRate != 0) {
     89             if (*sampleRate != 0) {
     90                 lRate = *sampleRate;
     91             } else {
     92                 *sampleRate = lRate;
     93             }
     94         }
     95         if (status) *status = NO_ERROR;
     96     }
     97     ALOGV("openOutputStream(), outFinal %p", outFinal);
     98 
     99     AudioStreamOutDump *dumOutput = new AudioStreamOutDump(this, mOutputs.size(), outFinal,
    100             devices, lFormat, lChannels, lRate);
    101     mOutputs.add(dumOutput);
    102 
    103     return dumOutput;
    104 }
    105 
    106 void AudioDumpInterface::closeOutputStream(AudioStreamOut* out)
    107 {
    108     AudioStreamOutDump *dumpOut = (AudioStreamOutDump *)out;
    109 
    110     if (mOutputs.indexOf(dumpOut) < 0) {
    111         ALOGW("Attempt to close invalid output stream");
    112         return;
    113     }
    114 
    115     ALOGV("closeOutputStream() output %p", out);
    116 
    117     dumpOut->standby();
    118     if (dumpOut->finalStream() != NULL) {
    119         mFinalInterface->closeOutputStream(dumpOut->finalStream());
    120     }
    121 
    122     mOutputs.remove(dumpOut);
    123     delete dumpOut;
    124 }
    125 
    126 AudioStreamIn* AudioDumpInterface::openInputStream(uint32_t devices, int *format, uint32_t *channels,
    127         uint32_t *sampleRate, status_t *status, AudioSystem::audio_in_acoustics acoustics)
    128 {
    129     AudioStreamIn* inFinal = NULL;
    130     int lFormat = AudioSystem::PCM_16_BIT;
    131     uint32_t lChannels = AudioSystem::CHANNEL_IN_MONO;
    132     uint32_t lRate = 8000;
    133 
    134     inFinal = mFinalInterface->openInputStream(devices, format, channels, sampleRate, status, acoustics);
    135     if (inFinal != 0) {
    136         lFormat = inFinal->format();
    137         lChannels = inFinal->channels();
    138         lRate = inFinal->sampleRate();
    139     } else {
    140         if (format != 0) {
    141             if (*format != 0) {
    142                 lFormat = *format;
    143             } else {
    144                 *format = lFormat;
    145             }
    146         }
    147         if (channels != 0) {
    148             if (*channels != 0) {
    149                 lChannels = *channels;
    150             } else {
    151                 *channels = lChannels;
    152             }
    153         }
    154         if (sampleRate != 0) {
    155             if (*sampleRate != 0) {
    156                 lRate = *sampleRate;
    157             } else {
    158                 *sampleRate = lRate;
    159             }
    160         }
    161         if (status) *status = NO_ERROR;
    162     }
    163     ALOGV("openInputStream(), inFinal %p", inFinal);
    164 
    165     AudioStreamInDump *dumInput = new AudioStreamInDump(this, mInputs.size(), inFinal,
    166             devices, lFormat, lChannels, lRate);
    167     mInputs.add(dumInput);
    168 
    169     return dumInput;
    170 }
    171 void AudioDumpInterface::closeInputStream(AudioStreamIn* in)
    172 {
    173     AudioStreamInDump *dumpIn = (AudioStreamInDump *)in;
    174 
    175     if (mInputs.indexOf(dumpIn) < 0) {
    176         ALOGW("Attempt to close invalid input stream");
    177         return;
    178     }
    179     dumpIn->standby();
    180     if (dumpIn->finalStream() != NULL) {
    181         mFinalInterface->closeInputStream(dumpIn->finalStream());
    182     }
    183 
    184     mInputs.remove(dumpIn);
    185     delete dumpIn;
    186 }
    187 
    188 
    189 status_t AudioDumpInterface::setParameters(const String8& keyValuePairs)
    190 {
    191     AudioParameter param = AudioParameter(keyValuePairs);
    192     String8 value;
    193     int valueInt;
    194     ALOGV("setParameters %s", keyValuePairs.string());
    195 
    196     if (param.get(String8("test_cmd_file_name"), value) == NO_ERROR) {
    197         mFileName = value;
    198         param.remove(String8("test_cmd_file_name"));
    199     }
    200     if (param.get(String8("test_cmd_policy"), value) == NO_ERROR) {
    201         Mutex::Autolock _l(mLock);
    202         param.remove(String8("test_cmd_policy"));
    203         mPolicyCommands = param.toString();
    204         ALOGV("test_cmd_policy command %s written", mPolicyCommands.string());
    205         return NO_ERROR;
    206     }
    207 
    208     if (mFinalInterface != 0 ) return mFinalInterface->setParameters(keyValuePairs);
    209     return NO_ERROR;
    210 }
    211 
    212 String8 AudioDumpInterface::getParameters(const String8& keys)
    213 {
    214     AudioParameter param = AudioParameter(keys);
    215     AudioParameter response;
    216     String8 value;
    217 
    218 //    ALOGV("getParameters %s", keys.string());
    219     if (param.get(String8("test_cmd_policy"), value) == NO_ERROR) {
    220         Mutex::Autolock _l(mLock);
    221         if (mPolicyCommands.length() != 0) {
    222             response = AudioParameter(mPolicyCommands);
    223             response.addInt(String8("test_cmd_policy"), 1);
    224         } else {
    225             response.addInt(String8("test_cmd_policy"), 0);
    226         }
    227         param.remove(String8("test_cmd_policy"));
    228 //        ALOGV("test_cmd_policy command %s read", mPolicyCommands.string());
    229     }
    230 
    231     if (param.get(String8("test_cmd_file_name"), value) == NO_ERROR) {
    232         response.add(String8("test_cmd_file_name"), mFileName);
    233         param.remove(String8("test_cmd_file_name"));
    234     }
    235 
    236     String8 keyValuePairs = response.toString();
    237 
    238     if (param.size() && mFinalInterface != 0 ) {
    239         keyValuePairs += ";";
    240         keyValuePairs += mFinalInterface->getParameters(param.toString());
    241     }
    242 
    243     return keyValuePairs;
    244 }
    245 
    246 status_t AudioDumpInterface::setMode(int mode)
    247 {
    248     return mFinalInterface->setMode(mode);
    249 }
    250 
    251 size_t AudioDumpInterface::getInputBufferSize(uint32_t sampleRate, int format, int channelCount)
    252 {
    253     return mFinalInterface->getInputBufferSize(sampleRate, format, channelCount);
    254 }
    255 
    256 // ----------------------------------------------------------------------------
    257 
    258 AudioStreamOutDump::AudioStreamOutDump(AudioDumpInterface *interface,
    259                                         int id,
    260                                         AudioStreamOut* finalStream,
    261                                         uint32_t devices,
    262                                         int format,
    263                                         uint32_t channels,
    264                                         uint32_t sampleRate)
    265     : mInterface(interface), mId(id),
    266       mSampleRate(sampleRate), mFormat(format), mChannels(channels), mLatency(0), mDevice(devices),
    267       mBufferSize(1024), mFinalStream(finalStream), mFile(0), mFileCount(0)
    268 {
    269     ALOGV("AudioStreamOutDump Constructor %p, mInterface %p, mFinalStream %p", this, mInterface, mFinalStream);
    270 }
    271 
    272 
    273 AudioStreamOutDump::~AudioStreamOutDump()
    274 {
    275     ALOGV("AudioStreamOutDump destructor");
    276     Close();
    277 }
    278 
    279 ssize_t AudioStreamOutDump::write(const void* buffer, size_t bytes)
    280 {
    281     ssize_t ret;
    282 
    283     if (mFinalStream) {
    284         ret = mFinalStream->write(buffer, bytes);
    285     } else {
    286         usleep((((bytes * 1000) / frameSize()) / sampleRate()) * 1000);
    287         ret = bytes;
    288     }
    289     if(!mFile) {
    290         if (mInterface->fileName() != "") {
    291             char name[255];
    292             sprintf(name, "%s_out_%d_%d.pcm", mInterface->fileName().string(), mId, ++mFileCount);
    293             mFile = fopen(name, "wb");
    294             ALOGV("Opening dump file %s, fh %p", name, mFile);
    295         }
    296     }
    297     if (mFile) {
    298         fwrite(buffer, bytes, 1, mFile);
    299     }
    300     return ret;
    301 }
    302 
    303 status_t AudioStreamOutDump::standby()
    304 {
    305     ALOGV("AudioStreamOutDump standby(), mFile %p, mFinalStream %p", mFile, mFinalStream);
    306 
    307     Close();
    308     if (mFinalStream != 0 ) return mFinalStream->standby();
    309     return NO_ERROR;
    310 }
    311 
    312 uint32_t AudioStreamOutDump::sampleRate() const
    313 {
    314     if (mFinalStream != 0 ) return mFinalStream->sampleRate();
    315     return mSampleRate;
    316 }
    317 
    318 size_t AudioStreamOutDump::bufferSize() const
    319 {
    320     if (mFinalStream != 0 ) return mFinalStream->bufferSize();
    321     return mBufferSize;
    322 }
    323 
    324 uint32_t AudioStreamOutDump::channels() const
    325 {
    326     if (mFinalStream != 0 ) return mFinalStream->channels();
    327     return mChannels;
    328 }
    329 int AudioStreamOutDump::format() const
    330 {
    331     if (mFinalStream != 0 ) return mFinalStream->format();
    332     return mFormat;
    333 }
    334 uint32_t AudioStreamOutDump::latency() const
    335 {
    336     if (mFinalStream != 0 ) return mFinalStream->latency();
    337     return 0;
    338 }
    339 status_t AudioStreamOutDump::setVolume(float left, float right)
    340 {
    341     if (mFinalStream != 0 ) return mFinalStream->setVolume(left, right);
    342     return NO_ERROR;
    343 }
    344 status_t AudioStreamOutDump::setParameters(const String8& keyValuePairs)
    345 {
    346     ALOGV("AudioStreamOutDump::setParameters %s", keyValuePairs.string());
    347 
    348     if (mFinalStream != 0 ) {
    349         return mFinalStream->setParameters(keyValuePairs);
    350     }
    351 
    352     AudioParameter param = AudioParameter(keyValuePairs);
    353     String8 value;
    354     int valueInt;
    355     status_t status = NO_ERROR;
    356 
    357     if (param.getInt(String8("set_id"), valueInt) == NO_ERROR) {
    358         mId = valueInt;
    359     }
    360 
    361     if (param.getInt(String8("format"), valueInt) == NO_ERROR) {
    362         if (mFile == 0) {
    363             mFormat = valueInt;
    364         } else {
    365             status = INVALID_OPERATION;
    366         }
    367     }
    368     if (param.getInt(String8("channels"), valueInt) == NO_ERROR) {
    369         if (valueInt == AudioSystem::CHANNEL_OUT_STEREO || valueInt == AudioSystem::CHANNEL_OUT_MONO) {
    370             mChannels = valueInt;
    371         } else {
    372             status = BAD_VALUE;
    373         }
    374     }
    375     if (param.getInt(String8("sampling_rate"), valueInt) == NO_ERROR) {
    376         if (valueInt > 0 && valueInt <= 48000) {
    377             if (mFile == 0) {
    378                 mSampleRate = valueInt;
    379             } else {
    380                 status = INVALID_OPERATION;
    381             }
    382         } else {
    383             status = BAD_VALUE;
    384         }
    385     }
    386     return status;
    387 }
    388 
    389 String8 AudioStreamOutDump::getParameters(const String8& keys)
    390 {
    391     if (mFinalStream != 0 ) return mFinalStream->getParameters(keys);
    392 
    393     AudioParameter param = AudioParameter(keys);
    394     return param.toString();
    395 }
    396 
    397 status_t AudioStreamOutDump::dump(int fd, const Vector<String16>& args)
    398 {
    399     if (mFinalStream != 0 ) return mFinalStream->dump(fd, args);
    400     return NO_ERROR;
    401 }
    402 
    403 void AudioStreamOutDump::Close()
    404 {
    405     if(mFile) {
    406         fclose(mFile);
    407         mFile = 0;
    408     }
    409 }
    410 
    411 status_t AudioStreamOutDump::getRenderPosition(uint32_t *dspFrames)
    412 {
    413     if (mFinalStream != 0 ) return mFinalStream->getRenderPosition(dspFrames);
    414     return INVALID_OPERATION;
    415 }
    416 
    417 // ----------------------------------------------------------------------------
    418 
    419 AudioStreamInDump::AudioStreamInDump(AudioDumpInterface *interface,
    420                                         int id,
    421                                         AudioStreamIn* finalStream,
    422                                         uint32_t devices,
    423                                         int format,
    424                                         uint32_t channels,
    425                                         uint32_t sampleRate)
    426     : mInterface(interface), mId(id),
    427       mSampleRate(sampleRate), mFormat(format), mChannels(channels), mDevice(devices),
    428       mBufferSize(1024), mFinalStream(finalStream), mFile(0), mFileCount(0)
    429 {
    430     ALOGV("AudioStreamInDump Constructor %p, mInterface %p, mFinalStream %p", this, mInterface, mFinalStream);
    431 }
    432 
    433 
    434 AudioStreamInDump::~AudioStreamInDump()
    435 {
    436     Close();
    437 }
    438 
    439 ssize_t AudioStreamInDump::read(void* buffer, ssize_t bytes)
    440 {
    441     ssize_t ret;
    442 
    443     if (mFinalStream) {
    444         ret = mFinalStream->read(buffer, bytes);
    445         if(!mFile) {
    446             if (mInterface->fileName() != "") {
    447                 char name[255];
    448                 sprintf(name, "%s_in_%d_%d.pcm", mInterface->fileName().string(), mId, ++mFileCount);
    449                 mFile = fopen(name, "wb");
    450                 ALOGV("Opening input dump file %s, fh %p", name, mFile);
    451             }
    452         }
    453         if (mFile) {
    454             fwrite(buffer, bytes, 1, mFile);
    455         }
    456     } else {
    457         usleep((((bytes * 1000) / frameSize()) / sampleRate()) * 1000);
    458         ret = bytes;
    459         if(!mFile) {
    460             char name[255];
    461             strcpy(name, "/sdcard/music/sine440");
    462             if (channels() == AudioSystem::CHANNEL_IN_MONO) {
    463                 strcat(name, "_mo");
    464             } else {
    465                 strcat(name, "_st");
    466             }
    467             if (format() == AudioSystem::PCM_16_BIT) {
    468                 strcat(name, "_16b");
    469             } else {
    470                 strcat(name, "_8b");
    471             }
    472             if (sampleRate() < 16000) {
    473                 strcat(name, "_8k");
    474             } else if (sampleRate() < 32000) {
    475                 strcat(name, "_22k");
    476             } else if (sampleRate() < 48000) {
    477                 strcat(name, "_44k");
    478             } else {
    479                 strcat(name, "_48k");
    480             }
    481             strcat(name, ".wav");
    482             mFile = fopen(name, "rb");
    483             ALOGV("Opening input read file %s, fh %p", name, mFile);
    484             if (mFile) {
    485                 fseek(mFile, AUDIO_DUMP_WAVE_HDR_SIZE, SEEK_SET);
    486             }
    487         }
    488         if (mFile) {
    489             ssize_t bytesRead = fread(buffer, bytes, 1, mFile);
    490             if (bytesRead >=0 && bytesRead < bytes) {
    491                 fseek(mFile, AUDIO_DUMP_WAVE_HDR_SIZE, SEEK_SET);
    492                 fread((uint8_t *)buffer+bytesRead, bytes-bytesRead, 1, mFile);
    493             }
    494         }
    495     }
    496 
    497     return ret;
    498 }
    499 
    500 status_t AudioStreamInDump::standby()
    501 {
    502     ALOGV("AudioStreamInDump standby(), mFile %p, mFinalStream %p", mFile, mFinalStream);
    503 
    504     Close();
    505     if (mFinalStream != 0 ) return mFinalStream->standby();
    506     return NO_ERROR;
    507 }
    508 
    509 status_t AudioStreamInDump::setGain(float gain)
    510 {
    511     if (mFinalStream != 0 ) return mFinalStream->setGain(gain);
    512     return NO_ERROR;
    513 }
    514 
    515 uint32_t AudioStreamInDump::sampleRate() const
    516 {
    517     if (mFinalStream != 0 ) return mFinalStream->sampleRate();
    518     return mSampleRate;
    519 }
    520 
    521 size_t AudioStreamInDump::bufferSize() const
    522 {
    523     if (mFinalStream != 0 ) return mFinalStream->bufferSize();
    524     return mBufferSize;
    525 }
    526 
    527 uint32_t AudioStreamInDump::channels() const
    528 {
    529     if (mFinalStream != 0 ) return mFinalStream->channels();
    530     return mChannels;
    531 }
    532 
    533 int AudioStreamInDump::format() const
    534 {
    535     if (mFinalStream != 0 ) return mFinalStream->format();
    536     return mFormat;
    537 }
    538 
    539 status_t AudioStreamInDump::setParameters(const String8& keyValuePairs)
    540 {
    541     ALOGV("AudioStreamInDump::setParameters()");
    542     if (mFinalStream != 0 ) return mFinalStream->setParameters(keyValuePairs);
    543     return NO_ERROR;
    544 }
    545 
    546 String8 AudioStreamInDump::getParameters(const String8& keys)
    547 {
    548     if (mFinalStream != 0 ) return mFinalStream->getParameters(keys);
    549 
    550     AudioParameter param = AudioParameter(keys);
    551     return param.toString();
    552 }
    553 
    554 unsigned int AudioStreamInDump::getInputFramesLost() const
    555 {
    556     if (mFinalStream != 0 ) return mFinalStream->getInputFramesLost();
    557     return 0;
    558 }
    559 
    560 status_t AudioStreamInDump::dump(int fd, const Vector<String16>& args)
    561 {
    562     if (mFinalStream != 0 ) return mFinalStream->dump(fd, args);
    563     return NO_ERROR;
    564 }
    565 
    566 void AudioStreamInDump::Close()
    567 {
    568     if(mFile) {
    569         fclose(mFile);
    570         mFile = 0;
    571     }
    572 }
    573 }; // namespace android
    574