Remove obsolete software codec header files and amr encoders. (949a0640) · Commits · e / os / android_frameworks_base

media/libstagefright/codecs/amrnb/enc/AMRNBEncoder.cpp

deleted100644 → 0

+0 −249

Original line number	Diff line number	Diff line
		/*
		* 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.
		*/

		#include "AMRNBEncoder.h"

		#include "gsmamr_enc.h"

		#include <media/stagefright/foundation/ADebug.h>
		#include <media/stagefright/MediaBufferGroup.h>
		#include <media/stagefright/MediaDefs.h>
		#include <media/stagefright/MediaErrors.h>
		#include <media/stagefright/MetaData.h>

		namespace android {

		static const int32_t kNumSamplesPerFrame = 160;
		static const int32_t kSampleRate = 8000;

		AMRNBEncoder::AMRNBEncoder(const sp<MediaSource> &source, const sp<MetaData> &meta)
		: mSource(source),
		mMeta(meta),
		mStarted(false),
		mBufferGroup(NULL),
		mEncState(NULL),
		mSidState(NULL),
		mAnchorTimeUs(0),
		mNumFramesOutput(0),
		mInputBuffer(NULL),
		mMode(MR475),
		mNumInputSamples(0) {
		}

		AMRNBEncoder::~AMRNBEncoder() {
		if (mStarted) {
		stop();
		}
		}

		static Mode PickModeFromBitrate(int32_t bps) {
		if (bps <= 4750) {
		return MR475;
		} else if (bps <= 5150) {
		return MR515;
		} else if (bps <= 5900) {
		return MR59;
		} else if (bps <= 6700) {
		return MR67;
		} else if (bps <= 7400) {
		return MR74;
		} else if (bps <= 7950) {
		return MR795;
		} else if (bps <= 10200) {
		return MR102;
		} else {
		return MR122;
		}
		}

		status_t AMRNBEncoder::start(MetaData *params) {
		if (mStarted) {
		ALOGW("Call start() when encoder already started");
		return OK;
		}

		mBufferGroup = new MediaBufferGroup;
		mBufferGroup->add_buffer(new MediaBuffer(32));

		CHECK_EQ(AMREncodeInit(
		&mEncState, &mSidState, false /* dtx_enable */),
		0);

		status_t err = mSource->start(params);
		if (err != OK) {
		ALOGE("AudioSource is not available");
		return err;
		}

		mAnchorTimeUs = 0;
		mNumFramesOutput = 0;
		mStarted = true;
		mNumInputSamples = 0;

		int32_t bitrate;
		if (params && params->findInt32(kKeyBitRate, &bitrate)) {
		mMode = PickModeFromBitrate(bitrate);
		} else {
		mMode = MR475;
		}

		return OK;
		}

		status_t AMRNBEncoder::stop() {
		if (!mStarted) {
		ALOGW("Call stop() when encoder has not started.");
		return OK;
		}

		if (mInputBuffer) {
		mInputBuffer->release();
		mInputBuffer = NULL;
		}

		delete mBufferGroup;
		mBufferGroup = NULL;

		mSource->stop();

		AMREncodeExit(&mEncState, &mSidState);
		mEncState = mSidState = NULL;

		mStarted = false;

		return OK;
		}

		sp<MetaData> AMRNBEncoder::getFormat() {
		sp<MetaData> srcFormat = mSource->getFormat();

		mMeta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AMR_NB);

		int64_t durationUs;
		if (srcFormat->findInt64(kKeyDuration, &durationUs)) {
		mMeta->setInt64(kKeyDuration, durationUs);
		}

		mMeta->setCString(kKeyDecoderComponent, "AMRNBEncoder");

		return mMeta;
		}

		status_t AMRNBEncoder::read(
		MediaBuffer *out, const ReadOptions options) {
		status_t err;

		*out = NULL;

		int64_t seekTimeUs;
		ReadOptions::SeekMode mode;
		CHECK(options == NULL \|\| !options->getSeekTo(&seekTimeUs, &mode));
		bool readFromSource = false;
		int64_t wallClockTimeUs = -1;

		while (mNumInputSamples < kNumSamplesPerFrame) {
		if (mInputBuffer == NULL) {
		err = mSource->read(&mInputBuffer, options);

		if (err != OK) {
		if (mNumInputSamples == 0) {
		return ERROR_END_OF_STREAM;
		}
		memset(&mInputFrame[mNumInputSamples],
		0,
		sizeof(int16_t)
		* (kNumSamplesPerFrame - mNumInputSamples));
		mNumInputSamples = kNumSamplesPerFrame;
		break;
		}

		size_t align = mInputBuffer->range_length() % sizeof(int16_t);
		CHECK_EQ(align, 0);
		readFromSource = true;

		int64_t timeUs;
		if (mInputBuffer->meta_data()->findInt64(kKeyDriftTime, &timeUs)) {
		wallClockTimeUs = timeUs;
		}
		if (mInputBuffer->meta_data()->findInt64(kKeyAnchorTime, &timeUs)) {
		mAnchorTimeUs = timeUs;
		}
		} else {
		readFromSource = false;
		}

		size_t copy =
		(kNumSamplesPerFrame - mNumInputSamples) * sizeof(int16_t);

		if (copy > mInputBuffer->range_length()) {
		copy = mInputBuffer->range_length();
		}

		memcpy(&mInputFrame[mNumInputSamples],
		(const uint8_t *)mInputBuffer->data()
		+ mInputBuffer->range_offset(),
		copy);

		mNumInputSamples += copy / sizeof(int16_t);

		mInputBuffer->set_range(
		mInputBuffer->range_offset() + copy,
		mInputBuffer->range_length() - copy);

		if (mInputBuffer->range_length() == 0) {
		mInputBuffer->release();
		mInputBuffer = NULL;
		}
		}

		MediaBuffer *buffer;
		CHECK_EQ(mBufferGroup->acquire_buffer(&buffer), (status_t)OK);

		uint8_t outPtr = (uint8_t )buffer->data();

		Frame_Type_3GPP frameType;
		int res = AMREncode(
		mEncState, mSidState, (Mode)mMode,
		mInputFrame, outPtr, &frameType, AMR_TX_WMF);

		CHECK(res >= 0);
		CHECK((size_t)res < buffer->size());

		// Convert header byte from WMF to IETF format.
		outPtr[0] = ((outPtr[0] << 3) \| 4) & 0x7c;

		buffer->set_range(0, res);

		// Each frame of 160 samples is 20ms long.
		int64_t mediaTimeUs = mNumFramesOutput * 20000LL;
		buffer->meta_data()->setInt64(
		kKeyTime, mAnchorTimeUs + mediaTimeUs);

		if (readFromSource && wallClockTimeUs != -1) {
		buffer->meta_data()->setInt64(kKeyDriftTime,
		mediaTimeUs - wallClockTimeUs);
		}

		++mNumFramesOutput;

		*out = buffer;

		mNumInputSamples = 0;

		return OK;
		}

		} // namespace android

media/libstagefright/codecs/amrnb/enc/Android.mk

+0 −1

Original line number	Diff line number	Diff line
		@@ -2,7 +2,6 @@ LOCAL_PATH := $(call my-dir)
		include $(CLEAR_VARS)

		LOCAL_SRC_FILES := \
		AMRNBEncoder.cpp \
		src/amrencode.cpp \
		src/autocorr.cpp \
		src/c1035pf.cpp \

media/libstagefright/codecs/amrwbenc/AMRWBEncoder.cpp

deleted100644 → 0

+0 −301

Original line number	Diff line number	Diff line
		/*
		* 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.
		*/

		//#define LOG_NDEBUG 0
		#define LOG_TAG "AMRWBEncoder"
		#include <utils/Log.h>

		#include "AMRWBEncoder.h"
		#include "voAMRWB.h"
		#include "cmnMemory.h"

		#include <media/stagefright/foundation/ADebug.h>
		#include <media/stagefright/MediaBufferGroup.h>
		#include <media/stagefright/MediaDefs.h>
		#include <media/stagefright/MediaErrors.h>
		#include <media/stagefright/MetaData.h>

		namespace android {

		static const int32_t kNumSamplesPerFrame = 320;
		static const int32_t kBitsPerSample = 16;
		static const int32_t kInputBufferSize = (kBitsPerSample / 8) * kNumSamplesPerFrame;
		static const int32_t kSampleRate = 16000;
		static const int32_t kNumChannels = 1;

		AMRWBEncoder::AMRWBEncoder(const sp<MediaSource> &source, const sp<MetaData> &meta)
		: mSource(source),
		mMeta(meta),
		mStarted(false),
		mBufferGroup(NULL),
		mInputBuffer(NULL),
		mEncoderHandle(NULL),
		mApiHandle(NULL),
		mMemOperator(NULL),
		mAnchorTimeUs(0),
		mNumFramesOutput(0),
		mNumInputSamples(0) {
		}

		static VOAMRWBMODE pickModeFromBitRate(int32_t bps) {
		CHECK(bps >= 0);
		if (bps <= 6600) {
		return VOAMRWB_MD66;
		} else if (bps <= 8850) {
		return VOAMRWB_MD885;
		} else if (bps <= 12650) {
		return VOAMRWB_MD1265;
		} else if (bps <= 14250) {
		return VOAMRWB_MD1425;
		} else if (bps <= 15850) {
		return VOAMRWB_MD1585;
		} else if (bps <= 18250) {
		return VOAMRWB_MD1825;
		} else if (bps <= 19850) {
		return VOAMRWB_MD1985;
		} else if (bps <= 23050) {
		return VOAMRWB_MD2305;
		}
		return VOAMRWB_MD2385;
		}

		status_t AMRWBEncoder::initCheck() {
		CHECK(mApiHandle == NULL && mEncoderHandle == NULL);
		CHECK(mMeta->findInt32(kKeyBitRate, &mBitRate));

		mApiHandle = new VO_AUDIO_CODECAPI;
		CHECK(mApiHandle);

		if (VO_ERR_NONE != voGetAMRWBEncAPI(mApiHandle)) {
		ALOGE("Failed to get api handle");
		return UNKNOWN_ERROR;
		}

		mMemOperator = new VO_MEM_OPERATOR;
		CHECK(mMemOperator != NULL);
		mMemOperator->Alloc = cmnMemAlloc;
		mMemOperator->Copy = cmnMemCopy;
		mMemOperator->Free = cmnMemFree;
		mMemOperator->Set = cmnMemSet;
		mMemOperator->Check = cmnMemCheck;

		VO_CODEC_INIT_USERDATA userData;
		memset(&userData, 0, sizeof(userData));
		userData.memflag = VO_IMF_USERMEMOPERATOR;
		userData.memData = (VO_PTR) mMemOperator;
		if (VO_ERR_NONE != mApiHandle->Init(&mEncoderHandle, VO_AUDIO_CodingAMRWB, &userData)) {
		ALOGE("Failed to init AMRWB encoder");
		return UNKNOWN_ERROR;
		}

		// Configure AMRWB encoder$
		VOAMRWBMODE mode = pickModeFromBitRate(mBitRate);
		if (VO_ERR_NONE != mApiHandle->SetParam(mEncoderHandle, VO_PID_AMRWB_MODE, &mode)) {
		ALOGE("Failed to set AMRWB encoder mode to %d", mode);
		return UNKNOWN_ERROR;
		}

		VOAMRWBFRAMETYPE type = VOAMRWB_RFC3267;
		if (VO_ERR_NONE != mApiHandle->SetParam(mEncoderHandle, VO_PID_AMRWB_FRAMETYPE, &type)) {
		ALOGE("Failed to set AMRWB encoder frame type to %d", type);
		return UNKNOWN_ERROR;
		}

		return OK;
		}

		AMRWBEncoder::~AMRWBEncoder() {
		if (mStarted) {
		stop();
		}
		}

		status_t AMRWBEncoder::start(MetaData *params) {
		if (mStarted) {
		ALOGW("Call start() when encoder already started");
		return OK;
		}

		mBufferGroup = new MediaBufferGroup;

		// The largest buffer size is header + 477 bits
		mBufferGroup->add_buffer(new MediaBuffer(1024));

		CHECK_EQ((status_t)OK, initCheck());

		mNumFramesOutput = 0;

		status_t err = mSource->start(params);
		if (err != OK) {
		ALOGE("AudioSource is not available");
		return err;
		}
		mStarted = true;

		return OK;
		}

		status_t AMRWBEncoder::stop() {
		if (!mStarted) {
		ALOGW("Call stop() when encoder has not started");
		return OK;
		}

		if (mInputBuffer) {
		mInputBuffer->release();
		mInputBuffer = NULL;
		}

		delete mBufferGroup;
		mBufferGroup = NULL;


		CHECK_EQ((VO_U32)VO_ERR_NONE, mApiHandle->Uninit(mEncoderHandle));
		mEncoderHandle = NULL;

		delete mApiHandle;
		mApiHandle = NULL;

		delete mMemOperator;
		mMemOperator;

		mStarted = false;

		mSource->stop();
		return OK;
		}

		sp<MetaData> AMRWBEncoder::getFormat() {
		sp<MetaData> srcFormat = mSource->getFormat();

		mMeta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AMR_WB);

		int64_t durationUs;
		if (srcFormat->findInt64(kKeyDuration, &durationUs)) {
		mMeta->setInt64(kKeyDuration, durationUs);
		}

		mMeta->setCString(kKeyDecoderComponent, "AMRWBEncoder");

		return mMeta;
		}

		status_t AMRWBEncoder::read(
		MediaBuffer *out, const ReadOptions options) {
		status_t err;

		*out = NULL;

		int64_t seekTimeUs;
		ReadOptions::SeekMode mode;
		CHECK(options == NULL \|\| !options->getSeekTo(&seekTimeUs, &mode));
		bool readFromSource = false;
		int64_t wallClockTimeUs = -1;

		while (mNumInputSamples < kNumSamplesPerFrame) {
		if (mInputBuffer == NULL) {
		err = mSource->read(&mInputBuffer, options);

		if (err != OK) {
		if (mNumInputSamples == 0) {
		return ERROR_END_OF_STREAM;
		}
		memset(&mInputFrame[mNumInputSamples],
		0,
		sizeof(int16_t)
		* (kNumSamplesPerFrame - mNumInputSamples));
		mNumInputSamples = 0;
		break;
		}

		size_t align = mInputBuffer->range_length() % sizeof(int16_t);
		CHECK_EQ(align, (size_t)0);

		int64_t timeUs;
		if (mInputBuffer->meta_data()->findInt64(kKeyDriftTime, &timeUs)) {
		wallClockTimeUs = timeUs;
		}
		if (mInputBuffer->meta_data()->findInt64(kKeyAnchorTime, &timeUs)) {
		mAnchorTimeUs = timeUs;
		}
		readFromSource = true;
		} else {
		readFromSource = false;
		}

		size_t copy =
		(kNumSamplesPerFrame - mNumInputSamples) * sizeof(int16_t);

		if (copy > mInputBuffer->range_length()) {
		copy = mInputBuffer->range_length();
		}

		memcpy(&mInputFrame[mNumInputSamples],
		(const uint8_t *)mInputBuffer->data()
		+ mInputBuffer->range_offset(),
		copy);

		mInputBuffer->set_range(
		mInputBuffer->range_offset() + copy,
		mInputBuffer->range_length() - copy);

		if (mInputBuffer->range_length() == 0) {
		mInputBuffer->release();
		mInputBuffer = NULL;
		}

		mNumInputSamples += copy / sizeof(int16_t);
		if (mNumInputSamples >= kNumSamplesPerFrame) {
		mNumInputSamples %= kNumSamplesPerFrame;
		break; // Get a whole input frame 640 bytes
		}
		}

		VO_CODECBUFFER inputData;
		memset(&inputData, 0, sizeof(inputData));
		inputData.Buffer = (unsigned char*) mInputFrame;
		inputData.Length = kInputBufferSize;
		CHECK(VO_ERR_NONE == mApiHandle->SetInputData(mEncoderHandle,&inputData));

		MediaBuffer *buffer;
		CHECK_EQ(mBufferGroup->acquire_buffer(&buffer), (status_t)OK);
		uint8_t outPtr = (uint8_t )buffer->data();

		VO_CODECBUFFER outputData;
		memset(&outputData, 0, sizeof(outputData));
		VO_AUDIO_OUTPUTINFO outputInfo;
		memset(&outputInfo, 0, sizeof(outputInfo));

		VO_U32 ret = VO_ERR_NONE;
		outputData.Buffer = outPtr;
		outputData.Length = buffer->size();
		ret = mApiHandle->GetOutputData(mEncoderHandle, &outputData, &outputInfo);
		CHECK(ret == VO_ERR_NONE \|\| ret == VO_ERR_INPUT_BUFFER_SMALL);

		buffer->set_range(0, outputData.Length);
		++mNumFramesOutput;

		int64_t mediaTimeUs = mNumFramesOutput * 20000LL;
		buffer->meta_data()->setInt64(kKeyTime, mAnchorTimeUs + mediaTimeUs);
		if (readFromSource && wallClockTimeUs != -1) {
		buffer->meta_data()->setInt64(kKeyDriftTime, mediaTimeUs - wallClockTimeUs);
		}

		*out = buffer;
		return OK;
		}

		} // namespace android

media/libstagefright/codecs/amrwbenc/Android.mk

+0 −1

Original line number	Diff line number	Diff line
		@@ -5,7 +5,6 @@ include frameworks/base/media/libstagefright/codecs/common/Config.mk


		LOCAL_SRC_FILES := \
		AMRWBEncoder.cpp \
		src/autocorr.c \
		src/az_isp.c \
		src/bits.c \

media/libstagefright/include/AACDecoder.h

deleted100644 → 0

+0 −68

Original line number	Diff line number	Diff line
		/*
		* 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.
		*/

		#ifndef AAC_DECODER_H_

		#define AAC_DECODER_H_

		#include <media/stagefright/MediaSource.h>

		struct tPVMP4AudioDecoderExternal;

		namespace android {

		struct MediaBufferGroup;
		struct MetaData;

		struct AACDecoder : public MediaSource {
		AACDecoder(const sp<MediaSource> &source);

		virtual status_t start(MetaData *params);
		virtual status_t stop();

		virtual sp<MetaData> getFormat();

		virtual status_t read(
		MediaBuffer *buffer, const ReadOptions options);

		protected:
		virtual ~AACDecoder();

		private:
		sp<MetaData> mMeta;
		sp<MediaSource> mSource;
		bool mStarted;

		MediaBufferGroup *mBufferGroup;

		tPVMP4AudioDecoderExternal *mConfig;
		void *mDecoderBuf;
		int64_t mAnchorTimeUs;
		int64_t mNumSamplesOutput;
		status_t mInitCheck;
		int64_t mNumDecodedBuffers;
		int32_t mUpsamplingFactor;

		MediaBuffer *mInputBuffer;

		status_t initCheck();
		AACDecoder(const AACDecoder &);
		AACDecoder &operator=(const AACDecoder &);
		};

		} // namespace android

		#endif // AAC_DECODER_H_