| /* |
| * Copyright (C) 2009 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_NDEBUG 0 |
| #define LOG_TAG "AMRExtractor" |
| #include <utils/Log.h> |
| |
| #include "include/AMRExtractor.h" |
| |
| #include <media/stagefright/foundation/ADebug.h> |
| #include <media/stagefright/DataSource.h> |
| #include <media/stagefright/MediaBufferGroup.h> |
| #include <media/stagefright/MediaDefs.h> |
| #include <media/stagefright/MediaErrors.h> |
| #include <media/stagefright/MediaSource.h> |
| #include <media/stagefright/MetaData.h> |
| #include <utils/String8.h> |
| |
| namespace android { |
| |
| class AMRSource : public MediaSource { |
| public: |
| AMRSource(const sp<DataSource> &source, |
| const sp<MetaData> &meta, |
| bool isWide, |
| const off64_t *offset_table, |
| size_t offset_table_length); |
| |
| virtual status_t start(MetaData *params = NULL); |
| virtual status_t stop(); |
| |
| virtual sp<MetaData> getFormat(); |
| |
| virtual status_t read( |
| MediaBuffer **buffer, const ReadOptions *options = NULL); |
| |
| protected: |
| virtual ~AMRSource(); |
| |
| private: |
| sp<DataSource> mDataSource; |
| sp<MetaData> mMeta; |
| bool mIsWide; |
| |
| off64_t mOffset; |
| int64_t mCurrentTimeUs; |
| bool mStarted; |
| MediaBufferGroup *mGroup; |
| |
| off64_t mOffsetTable[OFFSET_TABLE_LEN]; |
| size_t mOffsetTableLength; |
| |
| AMRSource(const AMRSource &); |
| AMRSource &operator=(const AMRSource &); |
| }; |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| static size_t getFrameSize(bool isWide, unsigned FT) { |
| static const size_t kFrameSizeNB[16] = { |
| 95, 103, 118, 134, 148, 159, 204, 244, |
| 39, 43, 38, 37, // SID |
| 0, 0, 0, // future use |
| 0 // no data |
| }; |
| static const size_t kFrameSizeWB[16] = { |
| 132, 177, 253, 285, 317, 365, 397, 461, 477, |
| 40, // SID |
| 0, 0, 0, 0, // future use |
| 0, // speech lost |
| 0 // no data |
| }; |
| |
| if (FT > 15 || (isWide && FT > 9 && FT < 14) || (!isWide && FT > 11 && FT < 15)) { |
| ALOGE("illegal AMR frame type %d", FT); |
| return 0; |
| } |
| |
| size_t frameSize = isWide ? kFrameSizeWB[FT] : kFrameSizeNB[FT]; |
| |
| // Round up bits to bytes and add 1 for the header byte. |
| frameSize = (frameSize + 7) / 8 + 1; |
| |
| return frameSize; |
| } |
| |
| static status_t getFrameSizeByOffset(const sp<DataSource> &source, |
| off64_t offset, bool isWide, size_t *frameSize) { |
| uint8_t header; |
| if (source->readAt(offset, &header, 1) < 1) { |
| return ERROR_IO; |
| } |
| |
| unsigned FT = (header >> 3) & 0x0f; |
| |
| *frameSize = getFrameSize(isWide, FT); |
| if (*frameSize == 0) { |
| return ERROR_MALFORMED; |
| } |
| return OK; |
| } |
| |
| AMRExtractor::AMRExtractor(const sp<DataSource> &source) |
| : mDataSource(source), |
| mInitCheck(NO_INIT), |
| mOffsetTableLength(0) { |
| String8 mimeType; |
| float confidence; |
| if (!SniffAMR(mDataSource, &mimeType, &confidence, NULL)) { |
| return; |
| } |
| |
| mIsWide = (mimeType == MEDIA_MIMETYPE_AUDIO_AMR_WB); |
| |
| mMeta = new MetaData; |
| mMeta->setCString( |
| kKeyMIMEType, mIsWide ? MEDIA_MIMETYPE_AUDIO_AMR_WB |
| : MEDIA_MIMETYPE_AUDIO_AMR_NB); |
| |
| mMeta->setInt32(kKeyChannelCount, 1); |
| mMeta->setInt32(kKeySampleRate, mIsWide ? 16000 : 8000); |
| |
| off64_t offset = mIsWide ? 9 : 6; |
| off64_t streamSize; |
| size_t frameSize, numFrames = 0; |
| int64_t duration = 0; |
| |
| if (mDataSource->getSize(&streamSize) == OK) { |
| while (offset < streamSize) { |
| if (getFrameSizeByOffset(source, offset, mIsWide, &frameSize) != OK) { |
| return; |
| } |
| |
| if ((numFrames % 50 == 0) && (numFrames / 50 < OFFSET_TABLE_LEN)) { |
| CHECK_EQ(mOffsetTableLength, numFrames / 50); |
| mOffsetTable[mOffsetTableLength] = offset - (mIsWide ? 9: 6); |
| mOffsetTableLength ++; |
| } |
| |
| offset += frameSize; |
| duration += 20000; // Each frame is 20ms |
| numFrames ++; |
| } |
| |
| mMeta->setInt64(kKeyDuration, duration); |
| } |
| |
| mInitCheck = OK; |
| } |
| |
| AMRExtractor::~AMRExtractor() { |
| } |
| |
| sp<MetaData> AMRExtractor::getMetaData() { |
| sp<MetaData> meta = new MetaData; |
| |
| if (mInitCheck != OK) { |
| return meta; |
| } |
| |
| meta->setCString(kKeyMIMEType, mIsWide ? "audio/amr-wb" : "audio/amr"); |
| |
| return meta; |
| } |
| |
| size_t AMRExtractor::countTracks() { |
| return mInitCheck == OK ? 1 : 0; |
| } |
| |
| sp<MediaSource> AMRExtractor::getTrack(size_t index) { |
| if (mInitCheck != OK || index != 0) { |
| return NULL; |
| } |
| |
| return new AMRSource(mDataSource, mMeta, mIsWide, |
| mOffsetTable, mOffsetTableLength); |
| } |
| |
| sp<MetaData> AMRExtractor::getTrackMetaData(size_t index, uint32_t /* flags */) { |
| if (mInitCheck != OK || index != 0) { |
| return NULL; |
| } |
| |
| return mMeta; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| AMRSource::AMRSource( |
| const sp<DataSource> &source, const sp<MetaData> &meta, |
| bool isWide, const off64_t *offset_table, size_t offset_table_length) |
| : mDataSource(source), |
| mMeta(meta), |
| mIsWide(isWide), |
| mOffset(mIsWide ? 9 : 6), |
| mCurrentTimeUs(0), |
| mStarted(false), |
| mGroup(NULL), |
| mOffsetTableLength(offset_table_length) { |
| if (mOffsetTableLength > 0 && mOffsetTableLength <= OFFSET_TABLE_LEN) { |
| memcpy ((char*)mOffsetTable, (char*)offset_table, sizeof(off64_t) * mOffsetTableLength); |
| } |
| } |
| |
| AMRSource::~AMRSource() { |
| if (mStarted) { |
| stop(); |
| } |
| } |
| |
| status_t AMRSource::start(MetaData * /* params */) { |
| CHECK(!mStarted); |
| |
| mOffset = mIsWide ? 9 : 6; |
| mCurrentTimeUs = 0; |
| mGroup = new MediaBufferGroup; |
| mGroup->add_buffer(new MediaBuffer(128)); |
| mStarted = true; |
| |
| return OK; |
| } |
| |
| status_t AMRSource::stop() { |
| CHECK(mStarted); |
| |
| delete mGroup; |
| mGroup = NULL; |
| |
| mStarted = false; |
| return OK; |
| } |
| |
| sp<MetaData> AMRSource::getFormat() { |
| return mMeta; |
| } |
| |
| status_t AMRSource::read( |
| MediaBuffer **out, const ReadOptions *options) { |
| *out = NULL; |
| |
| int64_t seekTimeUs; |
| ReadOptions::SeekMode mode; |
| if (options && options->getSeekTo(&seekTimeUs, &mode)) { |
| size_t size; |
| int64_t seekFrame = seekTimeUs / 20000ll; // 20ms per frame. |
| mCurrentTimeUs = seekFrame * 20000ll; |
| |
| size_t index = seekFrame < 0 ? 0 : seekFrame / 50; |
| if (index >= mOffsetTableLength) { |
| index = mOffsetTableLength - 1; |
| } |
| |
| mOffset = mOffsetTable[index] + (mIsWide ? 9 : 6); |
| |
| for (int i = 0; i< seekFrame - index * 50; i++) { |
| status_t err; |
| if ((err = getFrameSizeByOffset(mDataSource, mOffset, |
| mIsWide, &size)) != OK) { |
| return err; |
| } |
| mOffset += size; |
| } |
| } |
| |
| uint8_t header; |
| ssize_t n = mDataSource->readAt(mOffset, &header, 1); |
| |
| if (n < 1) { |
| return ERROR_END_OF_STREAM; |
| } |
| |
| if (header & 0x83) { |
| // Padding bits must be 0. |
| |
| ALOGE("padding bits must be 0, header is 0x%02x", header); |
| |
| return ERROR_MALFORMED; |
| } |
| |
| unsigned FT = (header >> 3) & 0x0f; |
| |
| size_t frameSize = getFrameSize(mIsWide, FT); |
| if (frameSize == 0) { |
| return ERROR_MALFORMED; |
| } |
| |
| MediaBuffer *buffer; |
| status_t err = mGroup->acquire_buffer(&buffer); |
| if (err != OK) { |
| return err; |
| } |
| |
| n = mDataSource->readAt(mOffset, buffer->data(), frameSize); |
| |
| if (n != (ssize_t)frameSize) { |
| buffer->release(); |
| buffer = NULL; |
| |
| return ERROR_IO; |
| } |
| |
| buffer->set_range(0, frameSize); |
| buffer->meta_data()->setInt64(kKeyTime, mCurrentTimeUs); |
| buffer->meta_data()->setInt32(kKeyIsSyncFrame, 1); |
| |
| mOffset += frameSize; |
| mCurrentTimeUs += 20000; // Each frame is 20ms |
| |
| *out = buffer; |
| |
| return OK; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| bool SniffAMR( |
| const sp<DataSource> &source, String8 *mimeType, float *confidence, |
| sp<AMessage> *) { |
| char header[9]; |
| |
| if (source->readAt(0, header, sizeof(header)) != sizeof(header)) { |
| return false; |
| } |
| |
| if (!memcmp(header, "#!AMR\n", 6)) { |
| *mimeType = MEDIA_MIMETYPE_AUDIO_AMR_NB; |
| *confidence = 0.5; |
| |
| return true; |
| } else if (!memcmp(header, "#!AMR-WB\n", 9)) { |
| *mimeType = MEDIA_MIMETYPE_AUDIO_AMR_WB; |
| *confidence = 0.5; |
| |
| return true; |
| } |
| |
| return false; |
| } |
| |
| } // namespace android |