media/libstagefright/codecs/g711/dec/SoftG711.cpp - platform/frameworks/av - Git at Google

 /*
  * Copyright (C) 2011 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 "SoftG711"
 #include <utils/Log.h>

 #include "SoftG711.h"

 #include <media/stagefright/foundation/ADebug.h>
 #include <media/stagefright/MediaDefs.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;
 }

 SoftG711::SoftG711(
         const char *name,
         const OMX_CALLBACKTYPE *callbacks,
         OMX_PTR appData,
         OMX_COMPONENTTYPE **component)
     : SimpleSoftOMXComponent(name, callbacks, appData, component),
       mIsMLaw(true),
       mSignalledError(false),
       mNumChannels(1),
       mSamplingRate(8000) {
     if (!strcmp(name, "OMX.google.g711.alaw.decoder")) {
         mIsMLaw = false;
     } else {
         CHECK(!strcmp(name, "OMX.google.g711.mlaw.decoder"));
     }

     initPorts();
 }

 SoftG711::~SoftG711() {
 }

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

     def.nPortIndex = 0;
     def.eDir = OMX_DirInput;
     def.nBufferCountMin = kNumBuffers;
     def.nBufferCountActual = def.nBufferCountMin;
     def.nBufferSize = 8192;
     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 *>(
                 mIsMLaw
                     ? MEDIA_MIMETYPE_AUDIO_G711_MLAW
                     : MEDIA_MIMETYPE_AUDIO_G711_ALAW);

     def.format.audio.pNativeRender = NULL;
     def.format.audio.bFlagErrorConcealment = OMX_FALSE;
     def.format.audio.eEncoding = OMX_AUDIO_CodingG711;

     addPort(def);

     def.nPortIndex = 1;
     def.eDir = OMX_DirOutput;
     def.nBufferCountMin = kNumBuffers;
     def.nBufferCountActual = def.nBufferCountMin;
     def.nBufferSize = kMaxNumSamplesPerFrame * sizeof(int16_t);
     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);
 }

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

             if (!isValidOMXParam(pcmParams)) {
                 return OMX_ErrorBadParameter;
             }

             if (pcmParams->nPortIndex > 1) {
                 return OMX_ErrorUndefined;
             }

             pcmParams->eNumData = OMX_NumericalDataSigned;
             pcmParams->eEndian = OMX_EndianBig;
             pcmParams->bInterleaved = OMX_TRUE;
             pcmParams->nBitPerSample = 16;
             if (pcmParams->nPortIndex == 0) {
                 // input port
                 pcmParams->ePCMMode = mIsMLaw ? OMX_AUDIO_PCMModeMULaw
                                               : OMX_AUDIO_PCMModeALaw;
             } else {
                 // output port
                 pcmParams->ePCMMode = OMX_AUDIO_PCMModeLinear;
             }
             pcmParams->eChannelMapping[0] = OMX_AUDIO_ChannelLF;
             pcmParams->eChannelMapping[1] = OMX_AUDIO_ChannelRF;

             pcmParams->nChannels = mNumChannels;
             pcmParams->nSamplingRate = mSamplingRate;

             return OMX_ErrorNone;
         }

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

 OMX_ERRORTYPE SoftG711::internalSetParameter(
         OMX_INDEXTYPE index, const OMX_PTR params) {
     switch (index) {
         case OMX_IndexParamAudioPcm:
         {
             OMX_AUDIO_PARAM_PCMMODETYPE *pcmParams =
                 (OMX_AUDIO_PARAM_PCMMODETYPE *)params;

             if (!isValidOMXParam(pcmParams)) {
                 return OMX_ErrorBadParameter;
             }

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

             if (pcmParams->nChannels < 1 || pcmParams->nChannels > 2) {
                 return OMX_ErrorUndefined;
             }

             if(pcmParams->nPortIndex == 0) {
                 mNumChannels = pcmParams->nChannels;
             }

             mSamplingRate = pcmParams->nSamplingRate;

             return OMX_ErrorNone;
         }

         case OMX_IndexParamStandardComponentRole:
         {
             const OMX_PARAM_COMPONENTROLETYPE *roleParams =
                 (const OMX_PARAM_COMPONENTROLETYPE *)params;

             if (!isValidOMXParam(roleParams)) {
                 return OMX_ErrorBadParameter;
             }

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

             return OMX_ErrorNone;
         }

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

 void SoftG711::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;

         if (inHeader->nFlags & OMX_BUFFERFLAG_EOS) {
             inQueue.erase(inQueue.begin());
             inInfo->mOwnedByUs = false;
             notifyEmptyBufferDone(inHeader);

             outHeader->nFilledLen = 0;
             outHeader->nFlags = OMX_BUFFERFLAG_EOS;

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

         if (inHeader->nFilledLen > kMaxNumSamplesPerFrame) {
             ALOGE("input buffer too large (%d).", inHeader->nFilledLen);

             notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL);
             mSignalledError = true;
         }

         const uint8_t *inputptr = inHeader->pBuffer + inHeader->nOffset;

         if (mIsMLaw) {
             DecodeMLaw(
                     reinterpret_cast<int16_t *>(outHeader->pBuffer),
                     inputptr, inHeader->nFilledLen);
         } else {
             DecodeALaw(
                     reinterpret_cast<int16_t *>(outHeader->pBuffer),
                     inputptr, inHeader->nFilledLen);
         }

         outHeader->nTimeStamp = inHeader->nTimeStamp;
         outHeader->nOffset = 0;
         outHeader->nFilledLen = inHeader->nFilledLen * sizeof(int16_t);
         outHeader->nFlags = 0;

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

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

 // static
 void SoftG711::DecodeALaw(
         int16_t *out, const uint8_t *in, size_t inSize) {
     while (inSize-- > 0) {
         int32_t x = *in++;

         int32_t ix = x ^ 0x55;
         ix &= 0x7f;

         int32_t iexp = ix >> 4;
         int32_t mant = ix & 0x0f;

         if (iexp > 0) {
             mant += 16;
         }

         mant = (mant << 4) + 8;

         if (iexp > 1) {
             mant = mant << (iexp - 1);
         }

         *out++ = (x > 127) ? mant : -mant;
     }
 }

 // static
 void SoftG711::DecodeMLaw(
         int16_t *out, const uint8_t *in, size_t inSize) {
     while (inSize-- > 0) {
         int32_t x = *in++;

         int32_t mantissa = ~x;
         int32_t exponent = (mantissa >> 4) & 7;
         int32_t segment = exponent + 1;
         mantissa &= 0x0f;

         int32_t step = 4 << segment;

         int32_t abs = (0x80l << exponent) + step * mantissa + step / 2 - 4 * 33;

         *out++ = (x < 0x80) ? -abs : abs;
     }
 }

 }  // namespace android

 android::SoftOMXComponent *createSoftOMXComponent(
         const char *name, const OMX_CALLBACKTYPE *callbacks,
         OMX_PTR appData, OMX_COMPONENTTYPE **component) {
     return new android::SoftG711(name, callbacks, appData, component);
 }
	/*
	* Copyright (C) 2011 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 "SoftG711"
	#include <utils/Log.h>

	#include "SoftG711.h"

	#include <media/stagefright/foundation/ADebug.h>
	#include <media/stagefright/MediaDefs.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;
	}

	SoftG711::SoftG711(
	const char *name,
	const OMX_CALLBACKTYPE *callbacks,
	OMX_PTR appData,
	OMX_COMPONENTTYPE **component)
	: SimpleSoftOMXComponent(name, callbacks, appData, component),
	mIsMLaw(true),
	mSignalledError(false),
	mNumChannels(1),
	mSamplingRate(8000) {
	if (!strcmp(name, "OMX.google.g711.alaw.decoder")) {
	mIsMLaw = false;
	} else {
	CHECK(!strcmp(name, "OMX.google.g711.mlaw.decoder"));
	}

	initPorts();
	}

	SoftG711::~SoftG711() {
	}

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

	def.nPortIndex = 0;
	def.eDir = OMX_DirInput;
	def.nBufferCountMin = kNumBuffers;
	def.nBufferCountActual = def.nBufferCountMin;
	def.nBufferSize = 8192;
	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 *>(
	mIsMLaw
	? MEDIA_MIMETYPE_AUDIO_G711_MLAW
	: MEDIA_MIMETYPE_AUDIO_G711_ALAW);

	def.format.audio.pNativeRender = NULL;
	def.format.audio.bFlagErrorConcealment = OMX_FALSE;
	def.format.audio.eEncoding = OMX_AUDIO_CodingG711;

	addPort(def);

	def.nPortIndex = 1;
	def.eDir = OMX_DirOutput;
	def.nBufferCountMin = kNumBuffers;
	def.nBufferCountActual = def.nBufferCountMin;
	def.nBufferSize = kMaxNumSamplesPerFrame * sizeof(int16_t);
	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);
	}

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

	if (!isValidOMXParam(pcmParams)) {
	return OMX_ErrorBadParameter;
	}

	if (pcmParams->nPortIndex > 1) {
	return OMX_ErrorUndefined;
	}

	pcmParams->eNumData = OMX_NumericalDataSigned;
	pcmParams->eEndian = OMX_EndianBig;
	pcmParams->bInterleaved = OMX_TRUE;
	pcmParams->nBitPerSample = 16;
	if (pcmParams->nPortIndex == 0) {
	// input port
	pcmParams->ePCMMode = mIsMLaw ? OMX_AUDIO_PCMModeMULaw
	: OMX_AUDIO_PCMModeALaw;
	} else {
	// output port
	pcmParams->ePCMMode = OMX_AUDIO_PCMModeLinear;
	}
	pcmParams->eChannelMapping[0] = OMX_AUDIO_ChannelLF;
	pcmParams->eChannelMapping[1] = OMX_AUDIO_ChannelRF;

	pcmParams->nChannels = mNumChannels;
	pcmParams->nSamplingRate = mSamplingRate;

	return OMX_ErrorNone;
	}

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

	OMX_ERRORTYPE SoftG711::internalSetParameter(
	OMX_INDEXTYPE index, const OMX_PTR params) {
	switch (index) {
	case OMX_IndexParamAudioPcm:
	{
	OMX_AUDIO_PARAM_PCMMODETYPE *pcmParams =
	(OMX_AUDIO_PARAM_PCMMODETYPE *)params;

	if (!isValidOMXParam(pcmParams)) {
	return OMX_ErrorBadParameter;
	}

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

	if (pcmParams->nChannels < 1 \|\| pcmParams->nChannels > 2) {
	return OMX_ErrorUndefined;
	}

	if(pcmParams->nPortIndex == 0) {
	mNumChannels = pcmParams->nChannels;
	}

	mSamplingRate = pcmParams->nSamplingRate;

	return OMX_ErrorNone;
	}

	case OMX_IndexParamStandardComponentRole:
	{
	const OMX_PARAM_COMPONENTROLETYPE *roleParams =
	(const OMX_PARAM_COMPONENTROLETYPE *)params;

	if (!isValidOMXParam(roleParams)) {
	return OMX_ErrorBadParameter;
	}

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

	return OMX_ErrorNone;
	}

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

	void SoftG711::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;

	if (inHeader->nFlags & OMX_BUFFERFLAG_EOS) {
	inQueue.erase(inQueue.begin());
	inInfo->mOwnedByUs = false;
	notifyEmptyBufferDone(inHeader);

	outHeader->nFilledLen = 0;
	outHeader->nFlags = OMX_BUFFERFLAG_EOS;

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

	if (inHeader->nFilledLen > kMaxNumSamplesPerFrame) {
	ALOGE("input buffer too large (%d).", inHeader->nFilledLen);

	notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL);
	mSignalledError = true;
	}

	const uint8_t *inputptr = inHeader->pBuffer + inHeader->nOffset;

	if (mIsMLaw) {
	DecodeMLaw(
	reinterpret_cast<int16_t *>(outHeader->pBuffer),
	inputptr, inHeader->nFilledLen);
	} else {
	DecodeALaw(
	reinterpret_cast<int16_t *>(outHeader->pBuffer),
	inputptr, inHeader->nFilledLen);
	}

	outHeader->nTimeStamp = inHeader->nTimeStamp;
	outHeader->nOffset = 0;
	outHeader->nFilledLen = inHeader->nFilledLen * sizeof(int16_t);
	outHeader->nFlags = 0;

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

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

	// static
	void SoftG711::DecodeALaw(
	int16_t out, const uint8_t in, size_t inSize) {
	while (inSize-- > 0) {
	int32_t x = *in++;

	int32_t ix = x ^ 0x55;
	ix &= 0x7f;

	int32_t iexp = ix >> 4;
	int32_t mant = ix & 0x0f;

	if (iexp > 0) {
	mant += 16;
	}

	mant = (mant << 4) + 8;

	if (iexp > 1) {
	mant = mant << (iexp - 1);
	}

	*out++ = (x > 127) ? mant : -mant;
	}
	}

	// static
	void SoftG711::DecodeMLaw(
	int16_t out, const uint8_t in, size_t inSize) {
	while (inSize-- > 0) {
	int32_t x = *in++;

	int32_t mantissa = ~x;
	int32_t exponent = (mantissa >> 4) & 7;
	int32_t segment = exponent + 1;
	mantissa &= 0x0f;

	int32_t step = 4 << segment;

	int32_t abs = (0x80l << exponent) + step * mantissa + step / 2 - 4 * 33;

	*out++ = (x < 0x80) ? -abs : abs;
	}
	}

	} // namespace android

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