media/libstagefright/codecs/gsm/dec/SoftGSM.cpp - platform/frameworks/av - Git at Google

 /*
  * 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 "SoftGSM"
 #include <utils/Log.h>

 #include "SoftGSM.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;
 }

 // Microsoft WAV GSM encoding packs two GSM frames into 65 bytes.
 static const int kMSGSMFrameSize = 65;

 SoftGSM::SoftGSM(
         const char *name,
         const OMX_CALLBACKTYPE *callbacks,
         OMX_PTR appData,
         OMX_COMPONENTTYPE **component)
     : SimpleSoftOMXComponent(name, callbacks, appData, component),
       mSignalledError(false) {

     CHECK(!strcmp(name, "OMX.google.gsm.decoder"));

     mGsm = gsm_create();
     CHECK(mGsm);
     int msopt = 1;
     gsm_option(mGsm, GSM_OPT_WAV49, &msopt);

     initPorts();
 }

 SoftGSM::~SoftGSM() {
     gsm_destroy(mGsm);
 }

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

     def.nPortIndex = 0;
     def.eDir = OMX_DirInput;
     def.nBufferCountMin = kNumBuffers;
     def.nBufferCountActual = def.nBufferCountMin;
     def.nBufferSize = 1024 / kMSGSMFrameSize * kMSGSMFrameSize;
     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 *>(MEDIA_MIMETYPE_AUDIO_MSGSM);

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

     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 SoftGSM::internalGetParameter(
         OMX_INDEXTYPE index, OMX_PTR params) {
     switch (index) {
         case OMX_IndexParamAudioPortFormat:
         {
             OMX_AUDIO_PARAM_PORTFORMATTYPE *formatParams =
                 (OMX_AUDIO_PARAM_PORTFORMATTYPE *)params;

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

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

             if (formatParams->nIndex > 0) {
                 return OMX_ErrorNoMore;
             }

             formatParams->eEncoding =
                 (formatParams->nPortIndex == 0)
                     ? OMX_AUDIO_CodingGSMFR : OMX_AUDIO_CodingPCM;

             return OMX_ErrorNone;
         }

         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;
             pcmParams->ePCMMode = OMX_AUDIO_PCMModeLinear;
             pcmParams->eChannelMapping[0] = OMX_AUDIO_ChannelLF;
             pcmParams->eChannelMapping[1] = OMX_AUDIO_ChannelRF;

             pcmParams->nChannels = 1;
             pcmParams->nSamplingRate = 8000;

             return OMX_ErrorNone;
         }

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

 OMX_ERRORTYPE SoftGSM::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) {
                 return OMX_ErrorUndefined;
             }

             if (pcmParams->nSamplingRate != 8000) {
                 return OMX_ErrorUndefined;
             }

             return OMX_ErrorNone;
         }

         case OMX_IndexParamAudioPortFormat:
         {
             const OMX_AUDIO_PARAM_PORTFORMATTYPE *formatParams =
                 (const OMX_AUDIO_PARAM_PORTFORMATTYPE *)params;

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

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

             if ((formatParams->nPortIndex == 0
                         && formatParams->eEncoding != OMX_AUDIO_CodingGSMFR)
                 || (formatParams->nPortIndex == 1
                         && formatParams->eEncoding != OMX_AUDIO_CodingPCM)) {
                 return OMX_ErrorUndefined;
             }

             return OMX_ErrorNone;
         }

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

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

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

             return OMX_ErrorNone;
         }

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

 void SoftGSM::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) && inHeader->nFilledLen == 0) {
             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;
         }

         if(((inHeader->nFilledLen / kMSGSMFrameSize) * kMSGSMFrameSize) != inHeader->nFilledLen) {
             ALOGE("input buffer not multiple of %d (%d).", kMSGSMFrameSize, inHeader->nFilledLen);
             notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL);
             mSignalledError = true;
         }

         if (outHeader->nAllocLen < (inHeader->nFilledLen / kMSGSMFrameSize) * 320) {
             ALOGE("output buffer is not large enough (%d).", outHeader->nAllocLen);
             android_errorWriteLog(0x534e4554, "27793367");
             notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL);
             mSignalledError = true;
             return;
         }

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

         int n = mSignalledError ? 0 : DecodeGSM(mGsm,
                   reinterpret_cast<int16_t *>(outHeader->pBuffer), inputptr, inHeader->nFilledLen);

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

         if (inHeader->nFlags & OMX_BUFFERFLAG_EOS) {
             inHeader->nFilledLen = 0;
         } else {
             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
 int SoftGSM::DecodeGSM(gsm handle,
         int16_t *out, uint8_t *in, size_t inSize) {

     int ret = 0;
     while (inSize > 0) {
         gsm_decode(handle, in, out);
         in += 33;
         inSize -= 33;
         out += 160;
         ret += 160;
         gsm_decode(handle, in, out);
         in += 32;
         inSize -= 32;
         out += 160;
         ret += 160;
     }
     return ret;
 }

 void SoftGSM::onPortFlushCompleted(OMX_U32 portIndex) {
     if (portIndex == 0) {
         gsm_destroy(mGsm);
         mGsm = gsm_create();
         int msopt = 1;
         gsm_option(mGsm, GSM_OPT_WAV49, &msopt);
     }
 }

 void SoftGSM::onReset() {
     gsm_destroy(mGsm);
     mGsm = gsm_create();
     int msopt = 1;
     gsm_option(mGsm, GSM_OPT_WAV49, &msopt);
     mSignalledError = false;
 }


 }  // namespace android

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

	#include "SoftGSM.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;
	}

	// Microsoft WAV GSM encoding packs two GSM frames into 65 bytes.
	static const int kMSGSMFrameSize = 65;

	SoftGSM::SoftGSM(
	const char *name,
	const OMX_CALLBACKTYPE *callbacks,
	OMX_PTR appData,
	OMX_COMPONENTTYPE **component)
	: SimpleSoftOMXComponent(name, callbacks, appData, component),
	mSignalledError(false) {

	CHECK(!strcmp(name, "OMX.google.gsm.decoder"));

	mGsm = gsm_create();
	CHECK(mGsm);
	int msopt = 1;
	gsm_option(mGsm, GSM_OPT_WAV49, &msopt);

	initPorts();
	}

	SoftGSM::~SoftGSM() {
	gsm_destroy(mGsm);
	}

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

	def.nPortIndex = 0;
	def.eDir = OMX_DirInput;
	def.nBufferCountMin = kNumBuffers;
	def.nBufferCountActual = def.nBufferCountMin;
	def.nBufferSize = 1024 / kMSGSMFrameSize * kMSGSMFrameSize;
	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 *>(MEDIA_MIMETYPE_AUDIO_MSGSM);

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

	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 SoftGSM::internalGetParameter(
	OMX_INDEXTYPE index, OMX_PTR params) {
	switch (index) {
	case OMX_IndexParamAudioPortFormat:
	{
	OMX_AUDIO_PARAM_PORTFORMATTYPE *formatParams =
	(OMX_AUDIO_PARAM_PORTFORMATTYPE *)params;

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

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

	if (formatParams->nIndex > 0) {
	return OMX_ErrorNoMore;
	}

	formatParams->eEncoding =
	(formatParams->nPortIndex == 0)
	? OMX_AUDIO_CodingGSMFR : OMX_AUDIO_CodingPCM;

	return OMX_ErrorNone;
	}

	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;
	pcmParams->ePCMMode = OMX_AUDIO_PCMModeLinear;
	pcmParams->eChannelMapping[0] = OMX_AUDIO_ChannelLF;
	pcmParams->eChannelMapping[1] = OMX_AUDIO_ChannelRF;

	pcmParams->nChannels = 1;
	pcmParams->nSamplingRate = 8000;

	return OMX_ErrorNone;
	}

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

	OMX_ERRORTYPE SoftGSM::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) {
	return OMX_ErrorUndefined;
	}

	if (pcmParams->nSamplingRate != 8000) {
	return OMX_ErrorUndefined;
	}

	return OMX_ErrorNone;
	}

	case OMX_IndexParamAudioPortFormat:
	{
	const OMX_AUDIO_PARAM_PORTFORMATTYPE *formatParams =
	(const OMX_AUDIO_PARAM_PORTFORMATTYPE *)params;

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

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

	if ((formatParams->nPortIndex == 0
	&& formatParams->eEncoding != OMX_AUDIO_CodingGSMFR)
	\|\| (formatParams->nPortIndex == 1
	&& formatParams->eEncoding != OMX_AUDIO_CodingPCM)) {
	return OMX_ErrorUndefined;
	}

	return OMX_ErrorNone;
	}

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

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

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

	return OMX_ErrorNone;
	}

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

	void SoftGSM::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) && inHeader->nFilledLen == 0) {
	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;
	}

	if(((inHeader->nFilledLen / kMSGSMFrameSize) * kMSGSMFrameSize) != inHeader->nFilledLen) {
	ALOGE("input buffer not multiple of %d (%d).", kMSGSMFrameSize, inHeader->nFilledLen);
	notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL);
	mSignalledError = true;
	}

	if (outHeader->nAllocLen < (inHeader->nFilledLen / kMSGSMFrameSize) * 320) {
	ALOGE("output buffer is not large enough (%d).", outHeader->nAllocLen);
	android_errorWriteLog(0x534e4554, "27793367");
	notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL);
	mSignalledError = true;
	return;
	}

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

	int n = mSignalledError ? 0 : DecodeGSM(mGsm,
	reinterpret_cast<int16_t *>(outHeader->pBuffer), inputptr, inHeader->nFilledLen);

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

	if (inHeader->nFlags & OMX_BUFFERFLAG_EOS) {
	inHeader->nFilledLen = 0;
	} else {
	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
	int SoftGSM::DecodeGSM(gsm handle,
	int16_t out, uint8_t in, size_t inSize) {

	int ret = 0;
	while (inSize > 0) {
	gsm_decode(handle, in, out);
	in += 33;
	inSize -= 33;
	out += 160;
	ret += 160;
	gsm_decode(handle, in, out);
	in += 32;
	inSize -= 32;
	out += 160;
	ret += 160;
	}
	return ret;
	}

	void SoftGSM::onPortFlushCompleted(OMX_U32 portIndex) {
	if (portIndex == 0) {
	gsm_destroy(mGsm);
	mGsm = gsm_create();
	int msopt = 1;
	gsm_option(mGsm, GSM_OPT_WAV49, &msopt);
	}
	}

	void SoftGSM::onReset() {
	gsm_destroy(mGsm);
	mGsm = gsm_create();
	int msopt = 1;
	gsm_option(mGsm, GSM_OPT_WAV49, &msopt);
	mSignalledError = false;
	}




	} // namespace android

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