| /* |
| * 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), |
| mNumChannels(1), |
| mSignalledError(false) { |
| 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 (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 = mNumChannels; |
| pcmParams->nSamplingRate = 8000; |
| |
| 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 (pcmParams->nPortIndex != 0) { |
| return OMX_ErrorUndefined; |
| } |
| |
| if (pcmParams->nChannels < 1 || pcmParams->nChannels > 2) { |
| return OMX_ErrorUndefined; |
| } |
| |
| mNumChannels = pcmParams->nChannels; |
| |
| return OMX_ErrorNone; |
| } |
| |
| case OMX_IndexParamStandardComponentRole: |
| { |
| const OMX_PARAM_COMPONENTROLETYPE *roleParams = |
| (const OMX_PARAM_COMPONENTROLETYPE *)params; |
| |
| 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 (%ld).", 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); |
| } |
| |