Implementation of a raw audio "decoder". (ecdd39c5) · Commits · e / os / android_frameworks_av

media/libstagefright/ACodec.cpp

+11 −0

Original line number	Diff line number	Diff line
		@@ -768,6 +768,8 @@ status_t ACodec::setComponentRole(
		"video_decoder.h263", "video_encoder.h263" },
		{ MEDIA_MIMETYPE_VIDEO_VPX,
		"video_decoder.vpx", "video_encoder.vpx" },
		{ MEDIA_MIMETYPE_AUDIO_RAW,
		"audio_decoder.raw", "audio_encoder.raw" },
		};

		static const size_t kNumMimeToRole =
		@@ -873,6 +875,15 @@ status_t ACodec::configureCodec(
		} else {
		err = setupG711Codec(encoder, numChannels);
		}
		} else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_RAW)) {
		int32_t numChannels, sampleRate;
		if (encoder
		\|\| !msg->findInt32("channel-count", &numChannels)
		\|\| !msg->findInt32("sample-rate", &sampleRate)) {
		err = INVALID_OPERATION;
		} else {
		err = setupRawAudioFormat(kPortIndexInput, sampleRate, numChannels);
		}
		}

		int32_t maxInputSize;

media/libstagefright/MediaCodecList.cpp

+3 −0

Original line number	Diff line number	Diff line
		@@ -64,6 +64,9 @@ MediaCodecList::MediaCodecList()
		addMediaCodec(true /* encoder */, "M4vH263Encoder");
		addType("video/3gpp");
		addType("video/mp4v-es");

		addMediaCodec(
		false /* encoder */, "OMX.google.raw.decoder", "audio/raw");
		}

		#if 0

media/libstagefright/OMXCodec.cpp

+10 −0

Original line number	Diff line number	Diff line
		@@ -534,6 +534,14 @@ status_t OMXCodec::configureCodec(const sp<MetaData> &meta) {
		CHECK(meta->findInt32(kKeyChannelCount, &numChannels));

		setG711Format(numChannels);
		} else if (!strcasecmp(MEDIA_MIMETYPE_AUDIO_RAW, mMIME)) {
		CHECK(!mIsEncoder);

		int32_t numChannels, sampleRate;
		CHECK(meta->findInt32(kKeyChannelCount, &numChannels));
		CHECK(meta->findInt32(kKeySampleRate, &sampleRate));

		setRawAudioFormat(kPortIndexInput, sampleRate, numChannels);
		}

		if (!strncasecmp(mMIME, "video/", 6)) {
		@@ -1359,6 +1367,8 @@ void OMXCodec::setComponentRole(
		"video_decoder.h263", "video_encoder.h263" },
		{ MEDIA_MIMETYPE_VIDEO_VPX,
		"video_decoder.vpx", "video_encoder.vpx" },
		{ MEDIA_MIMETYPE_AUDIO_RAW,
		"audio_decoder.raw", "audio_encoder.raw" },
		};

		static const size_t kNumMimeToRole =

media/libstagefright/codecs/raw/Android.mk

0 → 100644

+17 −0

Original line number	Diff line number	Diff line
		LOCAL_PATH:= $(call my-dir)
		include $(CLEAR_VARS)

		LOCAL_SRC_FILES := \
		SoftRaw.cpp

		LOCAL_C_INCLUDES := \
		frameworks/av/media/libstagefright/include \
		frameworks/native/include/media/openmax

		LOCAL_SHARED_LIBRARIES := \
		libstagefright_omx libstagefright_foundation libutils

		LOCAL_MODULE := libstagefright_soft_rawdec
		LOCAL_MODULE_TAGS := optional

		include $(BUILD_SHARED_LIBRARY)

media/libstagefright/codecs/raw/SoftRaw.cpp

0 → 100644

+213 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2012 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 "SoftRaw"
		#include <utils/Log.h>

		#include "SoftRaw.h"

		#include <media/stagefright/foundation/ADebug.h>
		#include <media/stagefright/foundation/hexdump.h>

		namespace android {

		template<class T>
		static void InitOMXParams(T *params) {
		params->nSize = sizeof(T);
		params->nVersion.s.nVersionMajor = 1;
		params->nVersion.s.nVersionMinor = 0;
		params->nVersion.s.nRevision = 0;
		params->nVersion.s.nStep = 0;
		}

		SoftRaw::SoftRaw(
		const char *name,
		const OMX_CALLBACKTYPE *callbacks,
		OMX_PTR appData,
		OMX_COMPONENTTYPE **component)
		: SimpleSoftOMXComponent(name, callbacks, appData, component),
		mSignalledError(false),
		mChannelCount(2),
		mSampleRate(44100) {
		initPorts();
		CHECK_EQ(initDecoder(), (status_t)OK);
		}

		SoftRaw::~SoftRaw() {
		}

		void SoftRaw::initPorts() {
		OMX_PARAM_PORTDEFINITIONTYPE def;
		InitOMXParams(&def);

		def.nPortIndex = 0;
		def.eDir = OMX_DirInput;
		def.nBufferCountMin = kNumBuffers;
		def.nBufferCountActual = def.nBufferCountMin;
		def.nBufferSize = 32 * 1024;
		def.bEnabled = OMX_TRUE;
		def.bPopulated = OMX_FALSE;
		def.eDomain = OMX_PortDomainAudio;
		def.bBuffersContiguous = OMX_FALSE;
		def.nBufferAlignment = 1;

		def.format.audio.cMIMEType = const_cast<char *>("audio/raw");
		def.format.audio.pNativeRender = NULL;
		def.format.audio.bFlagErrorConcealment = OMX_FALSE;
		def.format.audio.eEncoding = OMX_AUDIO_CodingPCM;

		addPort(def);

		def.nPortIndex = 1;
		def.eDir = OMX_DirOutput;
		def.nBufferCountMin = kNumBuffers;
		def.nBufferCountActual = def.nBufferCountMin;
		def.nBufferSize = 32 * 1024;
		def.bEnabled = OMX_TRUE;
		def.bPopulated = OMX_FALSE;
		def.eDomain = OMX_PortDomainAudio;
		def.bBuffersContiguous = OMX_FALSE;
		def.nBufferAlignment = 2;

		def.format.audio.cMIMEType = const_cast<char *>("audio/raw");
		def.format.audio.pNativeRender = NULL;
		def.format.audio.bFlagErrorConcealment = OMX_FALSE;
		def.format.audio.eEncoding = OMX_AUDIO_CodingPCM;

		addPort(def);
		}

		status_t SoftRaw::initDecoder() {
		return OK;
		}

		OMX_ERRORTYPE SoftRaw::internalGetParameter(
		OMX_INDEXTYPE index, OMX_PTR params) {
		switch (index) {
		case OMX_IndexParamAudioPcm:
		{
		OMX_AUDIO_PARAM_PCMMODETYPE *pcmParams =
		(OMX_AUDIO_PARAM_PCMMODETYPE *)params;

		if (pcmParams->nPortIndex != 0 && pcmParams->nPortIndex != 1) {
		return OMX_ErrorUndefined;
		}

		pcmParams->eNumData = OMX_NumericalDataSigned;
		pcmParams->eEndian = OMX_EndianBig;
		pcmParams->bInterleaved = OMX_TRUE;
		pcmParams->nBitPerSample = 16;
		pcmParams->ePCMMode = OMX_AUDIO_PCMModeLinear;
		pcmParams->eChannelMapping[0] = OMX_AUDIO_ChannelLF;
		pcmParams->eChannelMapping[1] = OMX_AUDIO_ChannelRF;

		pcmParams->nChannels = mChannelCount;
		pcmParams->nSamplingRate = mSampleRate;

		return OMX_ErrorNone;
		}

		default:
		return SimpleSoftOMXComponent::internalGetParameter(index, params);
		}
		}

		OMX_ERRORTYPE SoftRaw::internalSetParameter(
		OMX_INDEXTYPE index, const OMX_PTR params) {
		switch (index) {
		case OMX_IndexParamStandardComponentRole:
		{
		const OMX_PARAM_COMPONENTROLETYPE *roleParams =
		(const OMX_PARAM_COMPONENTROLETYPE *)params;

		if (strncmp((const char *)roleParams->cRole,
		"audio_decoder.raw",
		OMX_MAX_STRINGNAME_SIZE - 1)) {
		return OMX_ErrorUndefined;
		}

		return OMX_ErrorNone;
		}

		case OMX_IndexParamAudioPcm:
		{
		const OMX_AUDIO_PARAM_PCMMODETYPE *pcmParams =
		(OMX_AUDIO_PARAM_PCMMODETYPE *)params;

		if (pcmParams->nPortIndex != 0) {
		return OMX_ErrorUndefined;
		}

		mChannelCount = pcmParams->nChannels;
		mSampleRate = pcmParams->nSamplingRate;

		return OMX_ErrorNone;
		}

		default:
		return SimpleSoftOMXComponent::internalSetParameter(index, params);
		}
		}

		void SoftRaw::onQueueFilled(OMX_U32 portIndex) {
		if (mSignalledError) {
		return;
		}

		List<BufferInfo *> &inQueue = getPortQueue(0);
		List<BufferInfo *> &outQueue = getPortQueue(1);

		while (!inQueue.empty() && !outQueue.empty()) {
		BufferInfo inInfo = inQueue.begin();
		OMX_BUFFERHEADERTYPE *inHeader = inInfo->mHeader;

		BufferInfo outInfo = outQueue.begin();
		OMX_BUFFERHEADERTYPE *outHeader = outInfo->mHeader;

		CHECK_GE(outHeader->nAllocLen, inHeader->nFilledLen);
		memcpy(outHeader->pBuffer,
		inHeader->pBuffer + inHeader->nOffset,
		inHeader->nFilledLen);

		outHeader->nFlags = inHeader->nFlags;
		outHeader->nOffset = 0;
		outHeader->nFilledLen = inHeader->nFilledLen;
		outHeader->nTimeStamp = inHeader->nTimeStamp;

		bool sawEOS = (inHeader->nFlags & OMX_BUFFERFLAG_EOS) != 0;

		inQueue.erase(inQueue.begin());
		inInfo->mOwnedByUs = false;
		notifyEmptyBufferDone(inHeader);

		outQueue.erase(outQueue.begin());
		outInfo->mOwnedByUs = false;
		notifyFillBufferDone(outHeader);

		if (sawEOS) {
		break;
		}
		}
		}

		} // namespace android

		android::SoftOMXComponent *createSoftOMXComponent(
		const char name, const OMX_CALLBACKTYPE callbacks,
		OMX_PTR appData, OMX_COMPONENTTYPE **component) {
		return new android::SoftRaw(name, callbacks, appData, component);
		}