Initial checkin of AudioSource and AMRWriter, a pair of classes supporting pure-audio recording in stagefright.

related-to-bug: 2295449

cmds/stagefright/audioloop.cpp

@@ -1,7 +1,10 @@
 #include "SineSource.h"
 
 #include <binder/ProcessState.h>
+#include <media/mediarecorder.h>
+#include <media/stagefright/AMRWriter.h>
 #include <media/stagefright/AudioPlayer.h>
+#include <media/stagefright/AudioSource.h>
 #include <media/stagefright/MediaDebug.h>
 #include <media/stagefright/MediaDefs.h>
 #include <media/stagefright/MetaData.h>
@@ -21,7 +24,16 @@ int main() {
     OMXClient client;
     CHECK_EQ(client.connect(), OK);
 
+#if 0
     sp<MediaSource> source = new SineSource(kSampleRate, kNumChannels);
+#else
+    sp<MediaSource> source = new AudioSource(
+            AUDIO_SOURCE_DEFAULT,
+            kSampleRate,
+            kNumChannels == 1
+                ? AudioSystem::CHANNEL_IN_MONO
+                : AudioSystem::CHANNEL_IN_STEREO);
+#endif
 
     sp<MetaData> meta = new MetaData;
 
@@ -43,12 +55,19 @@ int main() {
             meta, true /* createEncoder */,
             source);
 
+#if 1
+    sp<AMRWriter> writer = new AMRWriter("/sdcard/out.amr");
+    writer->addSource(encoder);
+    writer->start();
+    sleep(10);
+    writer->stop();
+#else
     sp<MediaSource> decoder = OMXCodec::Create(
             client.interface(),
             meta, false /* createEncoder */,
             encoder);
 
-#if 1
+#if 0
     AudioPlayer *player = new AudioPlayer(NULL);
     player->setSource(decoder);
 
@@ -60,7 +79,7 @@ int main() {
 
     delete player;
     player = NULL;
-#else
+#elif 0
     CHECK_EQ(decoder->start(), OK);
 
     MediaBuffer *buffer;
@@ -75,6 +94,7 @@ int main() {
     }
 
     CHECK_EQ(decoder->stop(), OK);
+#endif
 #endif
 
     return 0;

include/media/stagefright/AMRWriter.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2010 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.
+ */
+
+#ifndef AMR_WRITER_H_
+
+#define AMR_WRITER_H_
+
+#include <stdio.h>
+
+#include <utils/RefBase.h>
+#include <utils/threads.h>
+
+namespace android {
+
+struct MediaSource;
+
+struct AMRWriter : public RefBase {
+    AMRWriter(const char *filename);
+    AMRWriter(int fd);
+
+    status_t initCheck() const;
+
+    status_t addSource(const sp<MediaSource> &source);
+
+    status_t start();
+    void stop();
+
+protected:
+    virtual ~AMRWriter();
+
+private:
+    Mutex mLock;
+
+    FILE *mFile;
+    status_t mInitCheck;
+    sp<MediaSource> mSource;
+    bool mStarted;
+    volatile bool mDone;
+    pthread_t mThread;
+
+    static void *ThreadWrapper(void *);
+    void threadFunc();
+
+    AMRWriter(const AMRWriter &);
+    AMRWriter &operator=(const AMRWriter &);
+};
+
+}  // namespace android
+
+#endif  // AMR_WRITER_H_

include/media/stagefright/AudioSource.h

@@ -18,16 +18,20 @@
 
 #define AUDIO_SOURCE_H_
 
+#include <media/AudioSystem.h>
 #include <media/stagefright/MediaSource.h>
 
 namespace android {
 
 class AudioRecord;
+struct MediaBufferGroup;
 
-class AudioSource {
-public:
-    AudioSource(int inputSource);
-    virtual ~AudioSource();
+struct AudioSource : public MediaSource {
+    // Note that the "channels" parameter is _not_ the number of channels,
+    // but a bitmask of AudioSystem::audio_channels constants.
+    AudioSource(
+            int inputSource, uint32_t sampleRate,
+            uint32_t channels = AudioSystem::CHANNEL_IN_MONO);
 
     status_t initCheck() const;
 
@@ -38,9 +42,16 @@ public:
     virtual status_t read(
             MediaBuffer **buffer, const ReadOptions *options = NULL);
 
+protected:
+    virtual ~AudioSource();
+
 private:
+    enum { kMaxBufferSize = 8192 };
+
     AudioRecord *mRecord;
     status_t mInitCheck;
+    bool mStarted;
+    MediaBufferGroup *mGroup;
 
     AudioSource(const AudioSource &);
     AudioSource &operator=(const AudioSource &);

media/libstagefright/AMRWriter.cpp

@@ -0,0 +1,184 @@
+/*
+ * Copyright (C) 2010 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.
+ */
+
+#include <media/stagefright/AMRWriter.h>
+
+#include <media/stagefright/MediaBuffer.h>
+#include <media/stagefright/MediaDebug.h>
+#include <media/stagefright/MediaDefs.h>
+#include <media/stagefright/MediaErrors.h>
+#include <media/stagefright/MediaSource.h>
+#include <media/stagefright/MetaData.h>
+
+namespace android {
+
+AMRWriter::AMRWriter(const char *filename)
+    : mFile(fopen(filename, "wb")),
+      mInitCheck(mFile != NULL ? OK : NO_INIT),
+      mStarted(false) {
+}
+
+AMRWriter::AMRWriter(int fd)
+    : mFile(fdopen(fd, "wb")),
+      mInitCheck(mFile != NULL ? OK : NO_INIT),
+      mStarted(false) {
+}
+
+AMRWriter::~AMRWriter() {
+    if (mStarted) {
+        stop();
+    }
+
+    if (mFile != NULL) {
+        fclose(mFile);
+        mFile = NULL;
+    }
+}
+
+status_t AMRWriter::initCheck() const {
+    return mInitCheck;
+}
+
+status_t AMRWriter::addSource(const sp<MediaSource> &source) {
+    Mutex::Autolock autoLock(mLock);
+
+    if (mInitCheck != OK) {
+        return mInitCheck;
+    }
+
+    if (mSource != NULL) {
+        // AMR files only support a single track of audio.
+        return UNKNOWN_ERROR;
+    }
+
+    sp<MetaData> meta = source->getFormat();
+
+    const char *mime;
+    CHECK(meta->findCString(kKeyMIMEType, &mime));
+
+    bool isWide = false;
+    if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AMR_WB)) {
+        isWide = true;
+    } else if (strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AMR_NB)) {
+        return ERROR_UNSUPPORTED;
+    }
+
+    int32_t channelCount;
+    int32_t sampleRate;
+    CHECK(meta->findInt32(kKeyChannelCount, &channelCount));
+    CHECK_EQ(channelCount, 1);
+    CHECK(meta->findInt32(kKeySampleRate, &sampleRate));
+    CHECK_EQ(sampleRate, (isWide ? 16000 : 8000));
+
+    mSource = source;
+
+    const char *kHeader = isWide ? "#!AMR-WB\n" : "#!AMR\n";
+    size_t n = strlen(kHeader);
+    if (fwrite(kHeader, 1, n, mFile) != n) {
+        return ERROR_IO;
+    }
+
+    return OK;
+}
+
+status_t AMRWriter::start() {
+    Mutex::Autolock autoLock(mLock);
+
+    if (mInitCheck != OK) {
+        return mInitCheck;
+    }
+
+    if (mStarted || mSource == NULL) {
+        return UNKNOWN_ERROR;
+    }
+
+    status_t err = mSource->start();
+
+    if (err != OK) {
+        return err;
+    }
+
+    pthread_attr_t attr;
+    pthread_attr_init(&attr);
+    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+
+    mDone = false;
+
+    pthread_create(&mThread, &attr, ThreadWrapper, this);
+    pthread_attr_destroy(&attr);
+
+    mStarted = true;
+
+    return OK;
+}
+
+void AMRWriter::stop() {
+    {
+        Mutex::Autolock autoLock(mLock);
+
+        if (!mStarted) {
+            return;
+        }
+
+        mDone = true;
+    }
+
+    void *dummy;
+    pthread_join(mThread, &dummy);
+
+    mSource->stop();
+
+    mStarted = false;
+}
+
+// static
+void *AMRWriter::ThreadWrapper(void *me) {
+    static_cast<AMRWriter *>(me)->threadFunc();
+
+    return NULL;
+}
+
+void AMRWriter::threadFunc() {
+    for (;;) {
+        Mutex::Autolock autoLock(mLock);
+
+        if (mDone) {
+            break;
+        }
+
+        MediaBuffer *buffer;
+        status_t err = mSource->read(&buffer);
+
+        if (err != OK) {
+            break;
+        }
+
+        ssize_t n = fwrite(
+                (const uint8_t *)buffer->data() + buffer->range_offset(),
+                1,
+                buffer->range_length(),
+                mFile);
+
+        buffer->release();
+        buffer = NULL;
+
+        if (n < (ssize_t)buffer->range_length()) {
+            break;
+        }
+    }
+}
+
+}  // namespace android

media/libstagefright/Android.mk

@@ -16,7 +16,9 @@ ifeq ($(BUILD_WITH_FULL_STAGEFRIGHT),true)
 
 LOCAL_SRC_FILES +=                \
         AMRExtractor.cpp          \
+        AMRWriter.cpp             \
         AudioPlayer.cpp           \
+        AudioSource.cpp           \
         AwesomePlayer.cpp         \
         CachingDataSource.cpp     \
         CameraSource.cpp          \

media/libstagefright/AudioSource.cpp

@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2010 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.
+ */
+
+#include <media/stagefright/AudioSource.h>
+
+#include <media/AudioRecord.h>
+#include <media/stagefright/MediaBufferGroup.h>
+#include <media/stagefright/MediaDebug.h>
+#include <media/stagefright/MediaDefs.h>
+#include <media/stagefright/MetaData.h>
+
+namespace android {
+
+AudioSource::AudioSource(
+        int inputSource, uint32_t sampleRate, uint32_t channels)
+    : mRecord(new AudioRecord(
+                inputSource, sampleRate, AudioSystem::PCM_16_BIT, channels)),
+      mInitCheck(mRecord->initCheck()),
+      mStarted(false),
+      mGroup(NULL) {
+}
+
+AudioSource::~AudioSource() {
+    if (mStarted) {
+        stop();
+    }
+
+    delete mRecord;
+    mRecord = NULL;
+}
+
+status_t AudioSource::initCheck() const {
+    return mInitCheck;
+}
+
+status_t AudioSource::start(MetaData *params) {
+    if (mStarted) {
+        return UNKNOWN_ERROR;
+    }
+
+    status_t err = mRecord->start();
+
+    if (err == OK) {
+        mGroup = new MediaBufferGroup;
+        mGroup->add_buffer(new MediaBuffer(kMaxBufferSize));
+
+        mStarted = true;
+    }
+
+    return err;
+}
+
+status_t AudioSource::stop() {
+    if (!mStarted) {
+        return UNKNOWN_ERROR;
+    }
+
+    mRecord->stop();
+
+    delete mGroup;
+    mGroup = NULL;
+
+    mStarted = false;
+
+    return OK;
+}
+
+sp<MetaData> AudioSource::getFormat() {
+    sp<MetaData> meta = new MetaData;
+    meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_RAW);
+    meta->setInt32(kKeySampleRate, mRecord->getSampleRate());
+    meta->setInt32(kKeyChannelCount, mRecord->channelCount());
+    meta->setInt32(kKeyMaxInputSize, kMaxBufferSize);
+
+    return meta;
+}
+
+status_t AudioSource::read(
+        MediaBuffer **out, const ReadOptions *options) {
+    *out = NULL;
+
+    MediaBuffer *buffer;
+    CHECK_EQ(mGroup->acquire_buffer(&buffer), OK);
+
+    uint32_t numFramesRecorded;
+    mRecord->getPosition(&numFramesRecorded);
+
+    buffer->meta_data()->setInt64(
+            kKeyTime,
+            (1000000ll * numFramesRecorded) / mRecord->getSampleRate()
+            - mRecord->latency() * 1000);
+
+    ssize_t n = mRecord->read(buffer->data(), buffer->size());
+
+    if (n < 0) {
+        buffer->release();
+        buffer = NULL;
+
+        return (status_t)n;
+    }
+
+    buffer->set_range(0, n);
+
+    *out = buffer;
+
+    return OK;
+}
+
+}  // namespace android