| /* |
| * Copyright (C) 2018 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 "C2SoftXaacDec" |
| #include <log/log.h> |
| |
| #include <inttypes.h> |
| |
| #include <cutils/properties.h> |
| #include <media/stagefright/foundation/ADebug.h> |
| #include <media/stagefright/foundation/MediaDefs.h> |
| #include <media/stagefright/foundation/hexdump.h> |
| |
| #include <C2PlatformSupport.h> |
| #include <SimpleC2Interface.h> |
| |
| #include "C2SoftXaacDec.h" |
| |
| #define DRC_DEFAULT_MOBILE_REF_LEVEL -16.0 /* 64*-0.25dB = -16 dB below full scale for mobile conf */ |
| #define DRC_DEFAULT_MOBILE_DRC_CUT 1.0 /* maximum compression of dynamic range for mobile conf */ |
| #define DRC_DEFAULT_MOBILE_DRC_BOOST 1.0 /* maximum compression of dynamic range for mobile conf */ |
| #define DRC_DEFAULT_MOBILE_DRC_HEAVY C2Config::DRC_COMPRESSION_HEAVY /* switch for heavy compression for mobile conf */ |
| #define DRC_DEFAULT_MOBILE_DRC_EFFECT 3 /* MPEG-D DRC effect type; 3 => Limited playback range */ |
| #define DRC_DEFAULT_MOBILE_ENC_LEVEL (0.25) /* encoder target level; -1 => the value is unknown, otherwise dB step value (e.g. 64 for -16 dB) */ |
| #define MAX_CHANNEL_COUNT 8 /* maximum number of audio channels that can be decoded */ |
| // names of properties that can be used to override the default DRC settings |
| #define PROP_DRC_OVERRIDE_REF_LEVEL "aac_drc_reference_level" |
| #define PROP_DRC_OVERRIDE_CUT "aac_drc_cut" |
| #define PROP_DRC_OVERRIDE_BOOST "aac_drc_boost" |
| #define PROP_DRC_OVERRIDE_HEAVY "aac_drc_heavy" |
| #define PROP_DRC_OVERRIDE_ENC_LEVEL "aac_drc_enc_target_level" |
| #define PROP_DRC_OVERRIDE_EFFECT_TYPE "ro.aac_drc_effect_type" |
| |
| #define RETURN_IF_FATAL(retval, str) \ |
| if (retval & IA_FATAL_ERROR) { \ |
| ALOGE("Error in %s: Returned: %d", str, retval); \ |
| return retval; \ |
| } else if (retval != IA_NO_ERROR) { \ |
| ALOGW("Warning in %s: Returned: %d", str, retval); \ |
| } |
| |
| |
| namespace android { |
| |
| constexpr char COMPONENT_NAME[] = "c2.android.xaac.decoder"; |
| |
| class C2SoftXaacDec::IntfImpl : public C2InterfaceHelper { |
| public: |
| explicit IntfImpl(const std::shared_ptr<C2ReflectorHelper> &helper) |
| : C2InterfaceHelper(helper) { |
| |
| setDerivedInstance(this); |
| |
| addParameter( |
| DefineParam(mInputFormat, C2_NAME_INPUT_STREAM_FORMAT_SETTING) |
| .withConstValue(new C2StreamFormatConfig::input(0u, C2FormatCompressed)) |
| .build()); |
| |
| addParameter( |
| DefineParam(mOutputFormat, C2_NAME_OUTPUT_STREAM_FORMAT_SETTING) |
| .withConstValue(new C2StreamFormatConfig::output(0u, C2FormatAudio)) |
| .build()); |
| |
| addParameter( |
| DefineParam(mInputMediaType, C2_NAME_INPUT_PORT_MIME_SETTING) |
| .withConstValue(AllocSharedString<C2PortMimeConfig::input>( |
| MEDIA_MIMETYPE_AUDIO_AAC)) |
| .build()); |
| |
| addParameter( |
| DefineParam(mOutputMediaType, C2_NAME_OUTPUT_PORT_MIME_SETTING) |
| .withConstValue(AllocSharedString<C2PortMimeConfig::output>( |
| MEDIA_MIMETYPE_AUDIO_RAW)) |
| .build()); |
| |
| addParameter( |
| DefineParam(mSampleRate, C2_NAME_STREAM_SAMPLE_RATE_SETTING) |
| .withDefault(new C2StreamSampleRateInfo::output(0u, 44100)) |
| .withFields({C2F(mSampleRate, value).oneOf({ |
| 7350, 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000 |
| })}) |
| .withSetter((Setter<decltype(*mSampleRate)>::StrictValueWithNoDeps)) |
| .build()); |
| |
| addParameter( |
| DefineParam(mChannelCount, C2_NAME_STREAM_CHANNEL_COUNT_SETTING) |
| .withDefault(new C2StreamChannelCountInfo::output(0u, 1)) |
| .withFields({C2F(mChannelCount, value).inRange(1, 8)}) |
| .withSetter(Setter<decltype(*mChannelCount)>::StrictValueWithNoDeps) |
| .build()); |
| |
| addParameter( |
| DefineParam(mBitrate, C2_NAME_STREAM_BITRATE_SETTING) |
| .withDefault(new C2BitrateTuning::input(0u, 64000)) |
| .withFields({C2F(mBitrate, value).inRange(8000, 960000)}) |
| .withSetter(Setter<decltype(*mBitrate)>::NonStrictValueWithNoDeps) |
| .build()); |
| |
| addParameter( |
| DefineParam(mInputMaxBufSize, C2_PARAMKEY_INPUT_MAX_BUFFER_SIZE) |
| .withConstValue(new C2StreamMaxBufferSizeInfo::input(0u, 8192)) |
| .build()); |
| |
| addParameter( |
| DefineParam(mAacFormat, C2_NAME_STREAM_AAC_FORMAT_SETTING) |
| .withDefault(new C2StreamAacFormatInfo::input(0u, C2AacStreamFormatRaw)) |
| .withFields({C2F(mAacFormat, value).oneOf({ |
| C2AacStreamFormatRaw, C2AacStreamFormatAdts |
| })}) |
| .withSetter(Setter<decltype(*mAacFormat)>::StrictValueWithNoDeps) |
| .build()); |
| |
| addParameter( |
| DefineParam(mProfileLevel, C2_PARAMKEY_PROFILE_LEVEL) |
| .withDefault(new C2StreamProfileLevelInfo::input(0u, |
| C2Config::PROFILE_AAC_LC, C2Config::LEVEL_UNUSED)) |
| .withFields({ |
| C2F(mProfileLevel, profile).oneOf({ |
| C2Config::PROFILE_AAC_LC, |
| C2Config::PROFILE_AAC_HE, |
| C2Config::PROFILE_AAC_HE_PS, |
| C2Config::PROFILE_AAC_LD, |
| C2Config::PROFILE_AAC_ELD, |
| C2Config::PROFILE_AAC_XHE}), |
| C2F(mProfileLevel, level).oneOf({ |
| C2Config::LEVEL_UNUSED |
| }) |
| }) |
| .withSetter(ProfileLevelSetter) |
| .build()); |
| |
| addParameter( |
| DefineParam(mDrcCompressMode, C2_PARAMKEY_DRC_COMPRESSION_MODE) |
| .withDefault(new C2StreamDrcCompressionModeTuning::input(0u, C2Config::DRC_COMPRESSION_HEAVY)) |
| .withFields({ |
| C2F(mDrcCompressMode, value).oneOf({ |
| C2Config::DRC_COMPRESSION_ODM_DEFAULT, |
| C2Config::DRC_COMPRESSION_NONE, |
| C2Config::DRC_COMPRESSION_LIGHT, |
| C2Config::DRC_COMPRESSION_HEAVY}) |
| }) |
| .withSetter(Setter<decltype(*mDrcCompressMode)>::StrictValueWithNoDeps) |
| .build()); |
| |
| addParameter( |
| DefineParam(mDrcTargetRefLevel, C2_PARAMKEY_DRC_TARGET_REFERENCE_LEVEL) |
| .withDefault(new C2StreamDrcTargetReferenceLevelTuning::input(0u, DRC_DEFAULT_MOBILE_REF_LEVEL)) |
| .withFields({C2F(mDrcTargetRefLevel, value).inRange(-31.75, 0.25)}) |
| .withSetter(Setter<decltype(*mDrcTargetRefLevel)>::StrictValueWithNoDeps) |
| .build()); |
| |
| addParameter( |
| DefineParam(mDrcEncTargetLevel, C2_PARAMKEY_DRC_ENCODED_TARGET_LEVEL) |
| .withDefault(new C2StreamDrcEncodedTargetLevelTuning::input(0u, DRC_DEFAULT_MOBILE_ENC_LEVEL)) |
| .withFields({C2F(mDrcEncTargetLevel, value).inRange(-31.75, 0.25)}) |
| .withSetter(Setter<decltype(*mDrcEncTargetLevel)>::StrictValueWithNoDeps) |
| .build()); |
| |
| addParameter( |
| DefineParam(mDrcBoostFactor, C2_PARAMKEY_DRC_BOOST_FACTOR) |
| .withDefault(new C2StreamDrcBoostFactorTuning::input(0u, DRC_DEFAULT_MOBILE_DRC_BOOST)) |
| .withFields({C2F(mDrcBoostFactor, value).inRange(0, 1.)}) |
| .withSetter(Setter<decltype(*mDrcBoostFactor)>::StrictValueWithNoDeps) |
| .build()); |
| |
| addParameter( |
| DefineParam(mDrcAttenuationFactor, C2_PARAMKEY_DRC_ATTENUATION_FACTOR) |
| .withDefault(new C2StreamDrcAttenuationFactorTuning::input(0u, DRC_DEFAULT_MOBILE_DRC_CUT)) |
| .withFields({C2F(mDrcAttenuationFactor, value).inRange(0, 1.)}) |
| .withSetter(Setter<decltype(*mDrcAttenuationFactor)>::StrictValueWithNoDeps) |
| .build()); |
| |
| addParameter( |
| DefineParam(mDrcEffectType, C2_PARAMKEY_DRC_EFFECT_TYPE) |
| .withDefault(new C2StreamDrcEffectTypeTuning::input(0u, C2Config::DRC_EFFECT_LIMITED_PLAYBACK_RANGE)) |
| .withFields({ |
| C2F(mDrcEffectType, value).oneOf({ |
| C2Config::DRC_EFFECT_ODM_DEFAULT, |
| C2Config::DRC_EFFECT_OFF, |
| C2Config::DRC_EFFECT_NONE, |
| C2Config::DRC_EFFECT_LATE_NIGHT, |
| C2Config::DRC_EFFECT_NOISY_ENVIRONMENT, |
| C2Config::DRC_EFFECT_LIMITED_PLAYBACK_RANGE, |
| C2Config::DRC_EFFECT_LOW_PLAYBACK_LEVEL, |
| C2Config::DRC_EFFECT_DIALOG_ENHANCEMENT, |
| C2Config::DRC_EFFECT_GENERAL_COMPRESSION}) |
| }) |
| .withSetter(Setter<decltype(*mDrcEffectType)>::StrictValueWithNoDeps) |
| .build()); |
| } |
| |
| bool isAdts() const { return mAacFormat->value == C2AacStreamFormatAdts; } |
| uint32_t getBitrate() const { return mBitrate->value; } |
| static C2R ProfileLevelSetter(bool mayBlock, C2P<C2StreamProfileLevelInfo::input> &me) { |
| (void)mayBlock; |
| (void)me; // TODO: validate |
| return C2R::Ok(); |
| } |
| int32_t getDrcCompressMode() const { return mDrcCompressMode->value == C2Config::DRC_COMPRESSION_HEAVY ? 1 : 0; } |
| int32_t getDrcTargetRefLevel() const { return (mDrcTargetRefLevel->value <= 0 ? -mDrcTargetRefLevel->value * 4. + 0.5 : -1); } |
| int32_t getDrcEncTargetLevel() const { return (mDrcEncTargetLevel->value <= 0 ? -mDrcEncTargetLevel->value * 4. + 0.5 : -1); } |
| int32_t getDrcBoostFactor() const { return mDrcBoostFactor->value * 127. + 0.5; } |
| int32_t getDrcAttenuationFactor() const { return mDrcAttenuationFactor->value * 127. + 0.5; } |
| int32_t getDrcEffectType() const { return mDrcEffectType->value; } |
| |
| private: |
| std::shared_ptr<C2StreamFormatConfig::input> mInputFormat; |
| std::shared_ptr<C2StreamFormatConfig::output> mOutputFormat; |
| std::shared_ptr<C2PortMimeConfig::input> mInputMediaType; |
| std::shared_ptr<C2PortMimeConfig::output> mOutputMediaType; |
| std::shared_ptr<C2StreamSampleRateInfo::output> mSampleRate; |
| std::shared_ptr<C2StreamChannelCountInfo::output> mChannelCount; |
| std::shared_ptr<C2BitrateTuning::input> mBitrate; |
| std::shared_ptr<C2StreamMaxBufferSizeInfo::input> mInputMaxBufSize; |
| std::shared_ptr<C2StreamAacFormatInfo::input> mAacFormat; |
| std::shared_ptr<C2StreamProfileLevelInfo::input> mProfileLevel; |
| std::shared_ptr<C2StreamDrcCompressionModeTuning::input> mDrcCompressMode; |
| std::shared_ptr<C2StreamDrcTargetReferenceLevelTuning::input> mDrcTargetRefLevel; |
| std::shared_ptr<C2StreamDrcEncodedTargetLevelTuning::input> mDrcEncTargetLevel; |
| std::shared_ptr<C2StreamDrcBoostFactorTuning::input> mDrcBoostFactor; |
| std::shared_ptr<C2StreamDrcAttenuationFactorTuning::input> mDrcAttenuationFactor; |
| std::shared_ptr<C2StreamDrcEffectTypeTuning::input> mDrcEffectType; |
| // TODO Add : C2StreamAacSbrModeTuning |
| }; |
| |
| C2SoftXaacDec::C2SoftXaacDec( |
| const char* name, |
| c2_node_id_t id, |
| const std::shared_ptr<IntfImpl> &intfImpl) |
| : SimpleC2Component(std::make_shared<SimpleInterface<IntfImpl>>(name, id, intfImpl)), |
| mIntf(intfImpl), |
| mXheaacCodecHandle(nullptr), |
| mMpegDDrcHandle(nullptr), |
| mOutputDrainBuffer(nullptr) { |
| } |
| |
| C2SoftXaacDec::~C2SoftXaacDec() { |
| onRelease(); |
| } |
| |
| c2_status_t C2SoftXaacDec::onInit() { |
| mOutputFrameLength = 1024; |
| mInputBuffer = nullptr; |
| mOutputBuffer = nullptr; |
| mSampFreq = 0; |
| mNumChannels = 0; |
| mPcmWdSz = 0; |
| mChannelMask = 0; |
| mNumOutBytes = 0; |
| mCurFrameIndex = 0; |
| mCurTimestamp = 0; |
| mIsCodecInitialized = false; |
| mIsCodecConfigFlushRequired = false; |
| mSignalledOutputEos = false; |
| mSignalledError = false; |
| mOutputDrainBufferWritePos = 0; |
| mDRCFlag = 0; |
| mMpegDDRCPresent = 0; |
| mMemoryVec.clear(); |
| mDrcMemoryVec.clear(); |
| |
| IA_ERRORCODE err = initDecoder(); |
| return err == IA_NO_ERROR ? C2_OK : C2_CORRUPTED; |
| |
| } |
| |
| c2_status_t C2SoftXaacDec::onStop() { |
| mOutputFrameLength = 1024; |
| drainDecoder(); |
| // reset the "configured" state |
| mSampFreq = 0; |
| mNumChannels = 0; |
| mPcmWdSz = 0; |
| mChannelMask = 0; |
| mNumOutBytes = 0; |
| mCurFrameIndex = 0; |
| mCurTimestamp = 0; |
| mSignalledOutputEos = false; |
| mSignalledError = false; |
| mOutputDrainBufferWritePos = 0; |
| mDRCFlag = 0; |
| mMpegDDRCPresent = 0; |
| |
| return C2_OK; |
| } |
| |
| void C2SoftXaacDec::onReset() { |
| (void)onStop(); |
| } |
| |
| void C2SoftXaacDec::onRelease() { |
| IA_ERRORCODE errCode = deInitXAACDecoder(); |
| if (IA_NO_ERROR != errCode) ALOGE("deInitXAACDecoder() failed %d", errCode); |
| |
| errCode = deInitMPEGDDDrc(); |
| if (IA_NO_ERROR != errCode) ALOGE("deInitMPEGDDDrc() failed %d", errCode); |
| |
| if (mOutputDrainBuffer) { |
| delete[] mOutputDrainBuffer; |
| mOutputDrainBuffer = nullptr; |
| } |
| } |
| |
| IA_ERRORCODE C2SoftXaacDec::initDecoder() { |
| ALOGV("initDecoder()"); |
| IA_ERRORCODE err_code = IA_NO_ERROR; |
| |
| err_code = initXAACDecoder(); |
| if (err_code != IA_NO_ERROR) { |
| ALOGE("initXAACDecoder Failed"); |
| /* Call deInit to free any allocated memory */ |
| deInitXAACDecoder(); |
| return IA_FATAL_ERROR; |
| } |
| |
| mOutputDrainBuffer = new short[kOutputDrainBufferSize]; |
| |
| err_code = initXAACDrc(); |
| RETURN_IF_FATAL(err_code, "initXAACDrc"); |
| |
| |
| return IA_NO_ERROR; |
| } |
| |
| static void fillEmptyWork(const std::unique_ptr<C2Work>& work) { |
| uint32_t flags = 0; |
| if (work->input.flags & C2FrameData::FLAG_END_OF_STREAM) { |
| flags |= C2FrameData::FLAG_END_OF_STREAM; |
| ALOGV("signalling eos"); |
| } |
| work->worklets.front()->output.flags = (C2FrameData::flags_t)flags; |
| work->worklets.front()->output.buffers.clear(); |
| work->worklets.front()->output.ordinal = work->input.ordinal; |
| work->workletsProcessed = 1u; |
| } |
| |
| void C2SoftXaacDec::finishWork(const std::unique_ptr<C2Work>& work, |
| const std::shared_ptr<C2BlockPool>& pool) { |
| ALOGV("mCurFrameIndex = %" PRIu64, mCurFrameIndex); |
| |
| std::shared_ptr<C2LinearBlock> block; |
| C2MemoryUsage usage = {C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE}; |
| // TODO: error handling, proper usage, etc. |
| c2_status_t err = |
| pool->fetchLinearBlock(mOutputDrainBufferWritePos, usage, &block); |
| if (err != C2_OK) ALOGE("err = %d", err); |
| C2WriteView wView = block->map().get(); |
| int16_t* outBuffer = reinterpret_cast<int16_t*>(wView.data()); |
| memcpy(outBuffer, mOutputDrainBuffer, mOutputDrainBufferWritePos); |
| mOutputDrainBufferWritePos = 0; |
| |
| auto fillWork = [buffer = createLinearBuffer(block)]( |
| const std::unique_ptr<C2Work>& work) { |
| uint32_t flags = 0; |
| if (work->input.flags & C2FrameData::FLAG_END_OF_STREAM) { |
| flags |= C2FrameData::FLAG_END_OF_STREAM; |
| ALOGV("signalling eos"); |
| } |
| work->worklets.front()->output.flags = (C2FrameData::flags_t)flags; |
| work->worklets.front()->output.buffers.clear(); |
| work->worklets.front()->output.buffers.push_back(buffer); |
| work->worklets.front()->output.ordinal = work->input.ordinal; |
| work->workletsProcessed = 1u; |
| }; |
| if (work && work->input.ordinal.frameIndex == c2_cntr64_t(mCurFrameIndex)) { |
| fillWork(work); |
| } else { |
| finish(mCurFrameIndex, fillWork); |
| } |
| |
| ALOGV("out timestamp %" PRIu64 " / %u", mCurTimestamp, block->capacity()); |
| } |
| |
| void C2SoftXaacDec::process(const std::unique_ptr<C2Work>& work, |
| const std::shared_ptr<C2BlockPool>& pool) { |
| work->workletsProcessed = 0u; |
| work->result = C2_OK; |
| work->worklets.front()->output.configUpdate.clear(); |
| if (mSignalledError || mSignalledOutputEos) { |
| work->result = C2_BAD_VALUE; |
| return; |
| } |
| uint8_t* inBuffer = nullptr; |
| uint32_t inBufferLength = 0; |
| C2ReadView view = mDummyReadView; |
| size_t offset = 0u; |
| size_t size = 0u; |
| if (!work->input.buffers.empty()) { |
| view = work->input.buffers[0]->data().linearBlocks().front().map().get(); |
| size = view.capacity(); |
| } |
| if (size && view.error()) { |
| ALOGE("read view map failed %d", view.error()); |
| work->result = view.error(); |
| return; |
| } |
| |
| bool eos = (work->input.flags & C2FrameData::FLAG_END_OF_STREAM) != 0; |
| bool codecConfig = |
| (work->input.flags & C2FrameData::FLAG_CODEC_CONFIG) != 0; |
| |
| if (codecConfig) { |
| if (size == 0u) { |
| ALOGE("empty codec config"); |
| mSignalledError = true; |
| work->result = C2_CORRUPTED; |
| return; |
| } |
| // const_cast because of libAACdec method signature. |
| inBuffer = const_cast<uint8_t*>(view.data() + offset); |
| inBufferLength = size; |
| |
| /* GA header configuration sent to Decoder! */ |
| IA_ERRORCODE err_code = configXAACDecoder(inBuffer, inBufferLength); |
| if (IA_NO_ERROR != err_code) { |
| ALOGE("configXAACDecoder err_code = %d", err_code); |
| mSignalledError = true; |
| work->result = C2_CORRUPTED; |
| return; |
| } |
| work->worklets.front()->output.flags = work->input.flags; |
| work->worklets.front()->output.ordinal = work->input.ordinal; |
| work->worklets.front()->output.buffers.clear(); |
| work->workletsProcessed = 1u; |
| return; |
| } |
| |
| mCurFrameIndex = work->input.ordinal.frameIndex.peeku(); |
| mCurTimestamp = work->input.ordinal.timestamp.peeku(); |
| mOutputDrainBufferWritePos = 0; |
| while (size > 0u) { |
| if ((kOutputDrainBufferSize * sizeof(int16_t) - |
| mOutputDrainBufferWritePos) < |
| (mOutputFrameLength * sizeof(int16_t) * mNumChannels)) { |
| ALOGV("skipping decode: not enough space left in DrainBuffer"); |
| break; |
| } |
| |
| ALOGV("inAttribute size = %zu", size); |
| if (mIntf->isAdts()) { |
| ALOGV("ADTS"); |
| size_t adtsHeaderSize = 0; |
| // skip 30 bits, aac_frame_length follows. |
| // ssssssss ssssiiip ppffffPc ccohCCll llllllll lll????? |
| |
| const uint8_t* adtsHeader = view.data() + offset; |
| bool signalError = false; |
| if (size < 7) { |
| ALOGE("Audio data too short to contain even the ADTS header. " |
| "Got %zu bytes.", size); |
| hexdump(adtsHeader, size); |
| signalError = true; |
| } else { |
| bool protectionAbsent = (adtsHeader[1] & 1); |
| unsigned aac_frame_length = ((adtsHeader[3] & 3) << 11) | |
| (adtsHeader[4] << 3) | |
| (adtsHeader[5] >> 5); |
| |
| if (size < aac_frame_length) { |
| ALOGE("Not enough audio data for the complete frame. " |
| "Got %zu bytes, frame size according to the ADTS " |
| "header is %u bytes.", size, aac_frame_length); |
| hexdump(adtsHeader, size); |
| signalError = true; |
| } else { |
| adtsHeaderSize = (protectionAbsent ? 7 : 9); |
| if (aac_frame_length < adtsHeaderSize) { |
| signalError = true; |
| } else { |
| // const_cast because of libAACdec method signature. |
| inBuffer = |
| const_cast<uint8_t*>(adtsHeader + adtsHeaderSize); |
| inBufferLength = aac_frame_length - adtsHeaderSize; |
| |
| offset += adtsHeaderSize; |
| size -= adtsHeaderSize; |
| } |
| } |
| } |
| |
| if (signalError) { |
| mSignalledError = true; |
| work->result = C2_CORRUPTED; |
| return; |
| } |
| } else { |
| ALOGV("Non ADTS"); |
| // const_cast because of libAACdec method signature. |
| inBuffer = const_cast<uint8_t*>(view.data() + offset); |
| inBufferLength = size; |
| } |
| |
| signed int prevSampleRate = mSampFreq; |
| signed int prevNumChannels = mNumChannels; |
| |
| /* XAAC decoder expects first frame to be fed via configXAACDecoder API |
| * which should initialize the codec. Once this state is reached, call the |
| * decodeXAACStream API with same frame to decode! */ |
| if (!mIsCodecInitialized) { |
| IA_ERRORCODE err_code = configXAACDecoder(inBuffer, inBufferLength); |
| if (IA_NO_ERROR != err_code) { |
| ALOGE("configXAACDecoder Failed 2 err_code = %d", err_code); |
| mSignalledError = true; |
| work->result = C2_CORRUPTED; |
| return; |
| } |
| |
| if ((mSampFreq != prevSampleRate) || |
| (mNumChannels != prevNumChannels)) { |
| ALOGI("Reconfiguring decoder: %d->%d Hz, %d->%d channels", |
| prevSampleRate, mSampFreq, prevNumChannels, mNumChannels); |
| |
| C2StreamSampleRateInfo::output sampleRateInfo(0u, mSampFreq); |
| C2StreamChannelCountInfo::output channelCountInfo(0u, mNumChannels); |
| std::vector<std::unique_ptr<C2SettingResult>> failures; |
| c2_status_t err = mIntf->config( |
| { &sampleRateInfo, &channelCountInfo }, |
| C2_MAY_BLOCK, |
| &failures); |
| if (err == OK) { |
| work->worklets.front()->output.configUpdate.push_back( |
| C2Param::Copy(sampleRateInfo)); |
| work->worklets.front()->output.configUpdate.push_back( |
| C2Param::Copy(channelCountInfo)); |
| } else { |
| ALOGE("Cannot set width and height"); |
| mSignalledError = true; |
| work->result = C2_CORRUPTED; |
| return; |
| } |
| } |
| } |
| |
| signed int bytesConsumed = 0; |
| IA_ERRORCODE errorCode = IA_NO_ERROR; |
| if (mIsCodecInitialized) { |
| mIsCodecConfigFlushRequired = true; |
| errorCode = decodeXAACStream(inBuffer, inBufferLength, |
| &bytesConsumed, &mNumOutBytes); |
| } else if (!mIsCodecConfigFlushRequired) { |
| ALOGW("Assumption that first frame after header initializes decoder Failed!"); |
| mSignalledError = true; |
| work->result = C2_CORRUPTED; |
| return; |
| } |
| size -= bytesConsumed; |
| offset += bytesConsumed; |
| |
| if (inBufferLength != (uint32_t)bytesConsumed) |
| ALOGW("All data not consumed"); |
| |
| /* In case of error, decoder would have given out empty buffer */ |
| if ((IA_NO_ERROR != errorCode) && (0 == mNumOutBytes) && mIsCodecInitialized) |
| mNumOutBytes = mOutputFrameLength * (mPcmWdSz / 8) * mNumChannels; |
| |
| if (!bytesConsumed) { |
| ALOGW("bytesConsumed = 0 should never happen"); |
| } |
| |
| if ((uint32_t)mNumOutBytes > |
| mOutputFrameLength * sizeof(int16_t) * mNumChannels) { |
| ALOGE("mNumOutBytes > mOutputFrameLength * sizeof(int16_t) * mNumChannels, should never happen"); |
| mSignalledError = true; |
| work->result = C2_CORRUPTED; |
| return; |
| } |
| |
| if (IA_NO_ERROR != errorCode) { |
| // TODO: check for overflow, ASAN |
| memset(mOutputBuffer, 0, mNumOutBytes); |
| |
| // Discard input buffer. |
| size = 0; |
| |
| // fall through |
| } |
| memcpy(mOutputDrainBuffer, mOutputBuffer, mNumOutBytes); |
| mOutputDrainBufferWritePos += mNumOutBytes; |
| } |
| |
| if (mOutputDrainBufferWritePos) { |
| finishWork(work, pool); |
| } else { |
| fillEmptyWork(work); |
| } |
| if (eos) mSignalledOutputEos = true; |
| } |
| |
| c2_status_t C2SoftXaacDec::drain(uint32_t drainMode, |
| const std::shared_ptr<C2BlockPool>& pool) { |
| (void)pool; |
| if (drainMode == NO_DRAIN) { |
| ALOGW("drain with NO_DRAIN: no-op"); |
| return C2_OK; |
| } |
| if (drainMode == DRAIN_CHAIN) { |
| ALOGW("DRAIN_CHAIN not supported"); |
| return C2_OMITTED; |
| } |
| |
| return C2_OK; |
| } |
| |
| IA_ERRORCODE C2SoftXaacDec::configflushDecode() { |
| IA_ERRORCODE err_code; |
| uint32_t ui_init_done; |
| uint32_t inBufferLength = 8203; |
| |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_INIT, |
| IA_CMD_TYPE_FLUSH_MEM, |
| NULL); |
| RETURN_IF_FATAL(err_code, "IA_CMD_TYPE_FLUSH_MEM"); |
| |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_SET_INPUT_BYTES, |
| 0, |
| &inBufferLength); |
| RETURN_IF_FATAL(err_code, "IA_API_CMD_SET_INPUT_BYTES"); |
| |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_INIT, |
| IA_CMD_TYPE_FLUSH_MEM, |
| NULL); |
| RETURN_IF_FATAL(err_code, "IA_CMD_TYPE_FLUSH_MEM"); |
| |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_INIT, |
| IA_CMD_TYPE_INIT_DONE_QUERY, |
| &ui_init_done); |
| RETURN_IF_FATAL(err_code, "IA_CMD_TYPE_INIT_DONE_QUERY"); |
| |
| if (ui_init_done) { |
| err_code = getXAACStreamInfo(); |
| RETURN_IF_FATAL(err_code, "getXAACStreamInfo"); |
| ALOGV("Found Codec with below config---\nsampFreq %d\nnumChannels %d\npcmWdSz %d\nchannelMask %d\noutputFrameLength %d", |
| mSampFreq, mNumChannels, mPcmWdSz, mChannelMask, mOutputFrameLength); |
| mIsCodecInitialized = true; |
| } |
| return IA_NO_ERROR; |
| } |
| |
| c2_status_t C2SoftXaacDec::onFlush_sm() { |
| if (mIsCodecInitialized) { |
| IA_ERRORCODE err_code = configflushDecode(); |
| if (err_code != IA_NO_ERROR) { |
| ALOGE("Error in configflushDecode: Error %d", err_code); |
| } |
| } |
| drainDecoder(); |
| mSignalledOutputEos = false; |
| mSignalledError = false; |
| |
| return C2_OK; |
| } |
| |
| IA_ERRORCODE C2SoftXaacDec::drainDecoder() { |
| /* Output delay compensation logic should sit here. */ |
| /* Nothing to be done as XAAC decoder does not introduce output buffer delay */ |
| |
| return 0; |
| } |
| |
| IA_ERRORCODE C2SoftXaacDec::initXAACDecoder() { |
| /* First part */ |
| /* Error Handler Init */ |
| /* Get Library Name, Library Version and API Version */ |
| /* Initialize API structure + Default config set */ |
| /* Set config params from user */ |
| /* Initialize memory tables */ |
| /* Get memory information and allocate memory */ |
| |
| mInputBufferSize = 0; |
| mInputBuffer = nullptr; |
| mOutputBuffer = nullptr; |
| /* Process struct initing end */ |
| |
| /* ******************************************************************/ |
| /* Initialize API structure and set config params to default */ |
| /* ******************************************************************/ |
| /* API size */ |
| uint32_t pui_api_size; |
| /* Get the API size */ |
| IA_ERRORCODE err_code = ixheaacd_dec_api(NULL, |
| IA_API_CMD_GET_API_SIZE, |
| 0, |
| &pui_api_size); |
| RETURN_IF_FATAL(err_code, "IA_API_CMD_GET_API_SIZE"); |
| |
| /* Allocate memory for API */ |
| mXheaacCodecHandle = memalign(4, pui_api_size); |
| if (!mXheaacCodecHandle) { |
| ALOGE("malloc for pui_api_size + 4 >> %d Failed", pui_api_size + 4); |
| return IA_FATAL_ERROR; |
| } |
| mMemoryVec.push(mXheaacCodecHandle); |
| |
| /* Set the config params to default values */ |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_INIT, |
| IA_CMD_TYPE_INIT_API_PRE_CONFIG_PARAMS, |
| NULL); |
| RETURN_IF_FATAL(err_code, "IA_CMD_TYPE_INIT_API_PRE_CONFIG_PARAMS"); |
| |
| /* Get the API size */ |
| err_code = ia_drc_dec_api(NULL, IA_API_CMD_GET_API_SIZE, 0, &pui_api_size); |
| |
| RETURN_IF_FATAL(err_code, "IA_API_CMD_GET_API_SIZE"); |
| |
| /* Allocate memory for API */ |
| mMpegDDrcHandle = memalign(4, pui_api_size); |
| if (!mMpegDDrcHandle) { |
| ALOGE("malloc for pui_api_size + 4 >> %d Failed", pui_api_size + 4); |
| return IA_FATAL_ERROR; |
| } |
| mMemoryVec.push(mMpegDDrcHandle); |
| |
| /* Set the config params to default values */ |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_INIT, |
| IA_CMD_TYPE_INIT_API_PRE_CONFIG_PARAMS, NULL); |
| |
| RETURN_IF_FATAL(err_code, "IA_CMD_TYPE_INIT_API_PRE_CONFIG_PARAMS"); |
| |
| /* ******************************************************************/ |
| /* Set config parameters */ |
| /* ******************************************************************/ |
| uint32_t ui_mp4_flag = 1; |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_SET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_PARAM_ISMP4, |
| &ui_mp4_flag); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_PARAM_ISMP4"); |
| |
| /* ******************************************************************/ |
| /* Initialize Memory info tables */ |
| /* ******************************************************************/ |
| uint32_t ui_proc_mem_tabs_size; |
| pVOID pv_alloc_ptr; |
| /* Get memory info tables size */ |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_GET_MEMTABS_SIZE, |
| 0, |
| &ui_proc_mem_tabs_size); |
| RETURN_IF_FATAL(err_code, "IA_API_CMD_GET_MEMTABS_SIZE"); |
| |
| pv_alloc_ptr = memalign(4, ui_proc_mem_tabs_size); |
| if (!pv_alloc_ptr) { |
| ALOGE("Malloc for size (ui_proc_mem_tabs_size + 4) = %d failed!", ui_proc_mem_tabs_size + 4); |
| return IA_FATAL_ERROR; |
| } |
| mMemoryVec.push(pv_alloc_ptr); |
| |
| /* Set pointer for process memory tables */ |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_SET_MEMTABS_PTR, |
| 0, |
| pv_alloc_ptr); |
| RETURN_IF_FATAL(err_code, "IA_API_CMD_SET_MEMTABS_PTR"); |
| |
| /* initialize the API, post config, fill memory tables */ |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_INIT, |
| IA_CMD_TYPE_INIT_API_POST_CONFIG_PARAMS, |
| NULL); |
| RETURN_IF_FATAL(err_code, "IA_CMD_TYPE_INIT_API_POST_CONFIG_PARAMS"); |
| |
| /* ******************************************************************/ |
| /* Allocate Memory with info from library */ |
| /* ******************************************************************/ |
| /* There are four different types of memories, that needs to be allocated */ |
| /* persistent,scratch,input and output */ |
| for (int i = 0; i < 4; i++) { |
| int ui_size = 0, ui_alignment = 0, ui_type = 0; |
| |
| /* Get memory size */ |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_GET_MEM_INFO_SIZE, |
| i, |
| &ui_size); |
| RETURN_IF_FATAL(err_code, "IA_API_CMD_GET_MEM_INFO_SIZE"); |
| |
| /* Get memory alignment */ |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_GET_MEM_INFO_ALIGNMENT, |
| i, |
| &ui_alignment); |
| RETURN_IF_FATAL(err_code, "IA_API_CMD_GET_MEM_INFO_ALIGNMENT"); |
| |
| /* Get memory type */ |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_GET_MEM_INFO_TYPE, |
| i, |
| &ui_type); |
| RETURN_IF_FATAL(err_code, "IA_API_CMD_GET_MEM_INFO_TYPE"); |
| |
| pv_alloc_ptr = memalign(ui_alignment, ui_size); |
| if (!pv_alloc_ptr) { |
| ALOGE("Malloc for size (ui_size + ui_alignment) = %d failed!", |
| ui_size + ui_alignment); |
| return IA_FATAL_ERROR; |
| } |
| mMemoryVec.push(pv_alloc_ptr); |
| |
| /* Set the buffer pointer */ |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_SET_MEM_PTR, |
| i, |
| pv_alloc_ptr); |
| RETURN_IF_FATAL(err_code, "IA_API_CMD_SET_MEM_PTR"); |
| if (ui_type == IA_MEMTYPE_INPUT) { |
| mInputBuffer = (pWORD8)pv_alloc_ptr; |
| mInputBufferSize = ui_size; |
| } |
| if (ui_type == IA_MEMTYPE_OUTPUT) |
| mOutputBuffer = (pWORD8)pv_alloc_ptr; |
| } |
| /* End first part */ |
| |
| return IA_NO_ERROR; |
| } |
| |
| status_t C2SoftXaacDec::initXAACDrc() { |
| IA_ERRORCODE err_code = IA_NO_ERROR; |
| unsigned int ui_drc_val; |
| // DRC_PRES_MODE_WRAP_DESIRED_TARGET |
| int32_t targetRefLevel = mIntf->getDrcTargetRefLevel(); |
| ALOGV("AAC decoder using desired DRC target reference level of %d", targetRefLevel); |
| ui_drc_val = (unsigned int)targetRefLevel; |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_SET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_TARGET_LEVEL, |
| &ui_drc_val); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_TARGET_LEVEL"); |
| |
| /* Use ui_drc_val from PROP_DRC_OVERRIDE_REF_LEVEL or DRC_DEFAULT_MOBILE_REF_LEVEL |
| * for IA_ENHAACPLUS_DEC_DRC_TARGET_LOUDNESS too */ |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, IA_API_CMD_SET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_DRC_TARGET_LOUDNESS, &ui_drc_val); |
| |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_DRC_TARGET_LOUDNESS"); |
| |
| int32_t attenuationFactor = mIntf->getDrcAttenuationFactor(); |
| ALOGV("AAC decoder using desired DRC attenuation factor of %d", attenuationFactor); |
| ui_drc_val = (unsigned int)attenuationFactor; |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_SET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_CUT, |
| &ui_drc_val); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_CUT"); |
| |
| // DRC_PRES_MODE_WRAP_DESIRED_BOOST_FACTOR |
| int32_t boostFactor = mIntf->getDrcBoostFactor(); |
| ALOGV("AAC decoder using desired DRC boost factor of %d", boostFactor); |
| ui_drc_val = (unsigned int)boostFactor; |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_SET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_BOOST, |
| &ui_drc_val); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_BOOST"); |
| |
| // DRC_PRES_MODE_WRAP_DESIRED_HEAVY |
| int32_t compressMode = mIntf->getDrcCompressMode(); |
| ALOGV("AAC decoder using desried DRC heavy compression switch of %d", compressMode); |
| ui_drc_val = (unsigned int)compressMode; |
| |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_SET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_HEAVY_COMP, |
| &ui_drc_val); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_HEAVY_COMP"); |
| |
| // AAC_UNIDRC_SET_EFFECT |
| int32_t effectType = mIntf->getDrcEffectType(); |
| ALOGV("AAC decoder using MPEG-D DRC effect type %d", effectType); |
| ui_drc_val = (unsigned int)effectType; |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, IA_API_CMD_SET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_DRC_EFFECT_TYPE, &ui_drc_val); |
| |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_DRC_EFFECT_TYPE"); |
| |
| return IA_NO_ERROR; |
| } |
| |
| IA_ERRORCODE C2SoftXaacDec::deInitXAACDecoder() { |
| ALOGV("deInitXAACDecoder"); |
| |
| /* Error code */ |
| IA_ERRORCODE err_code = IA_NO_ERROR; |
| |
| if (mXheaacCodecHandle) { |
| /* Tell that the input is over in this buffer */ |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_INPUT_OVER, |
| 0, |
| NULL); |
| } |
| |
| /* Irrespective of error returned in IA_API_CMD_INPUT_OVER, free allocated memory */ |
| for (void* buf : mMemoryVec) { |
| free(buf); |
| } |
| mMemoryVec.clear(); |
| mXheaacCodecHandle = nullptr; |
| |
| return err_code; |
| } |
| |
| IA_ERRORCODE C2SoftXaacDec::deInitMPEGDDDrc() { |
| ALOGV("deInitMPEGDDDrc"); |
| |
| for (void* buf : mDrcMemoryVec) { |
| free(buf); |
| } |
| mDrcMemoryVec.clear(); |
| return IA_NO_ERROR; |
| } |
| |
| IA_ERRORCODE C2SoftXaacDec::configXAACDecoder(uint8_t* inBuffer, uint32_t inBufferLength) { |
| if (mInputBufferSize < inBufferLength) { |
| ALOGE("Cannot config AAC, input buffer size %d < inBufferLength %d", mInputBufferSize, inBufferLength); |
| return false; |
| } |
| /* Copy the buffer passed by Android plugin to codec input buffer */ |
| memcpy(mInputBuffer, inBuffer, inBufferLength); |
| |
| /* Set number of bytes to be processed */ |
| IA_ERRORCODE err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_SET_INPUT_BYTES, |
| 0, |
| &inBufferLength); |
| RETURN_IF_FATAL(err_code, "IA_API_CMD_SET_INPUT_BYTES"); |
| |
| if (mIsCodecConfigFlushRequired) { |
| /* If codec is already initialized, then GA header is passed again */ |
| /* Need to call the Flush API instead of INIT_PROCESS */ |
| mIsCodecInitialized = false; /* Codec needs to be Reinitialized after flush */ |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_INIT, |
| IA_CMD_TYPE_GA_HDR, |
| NULL); |
| RETURN_IF_FATAL(err_code, "IA_CMD_TYPE_GA_HDR"); |
| } else { |
| /* Initialize the process */ |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_INIT, |
| IA_CMD_TYPE_INIT_PROCESS, |
| NULL); |
| RETURN_IF_FATAL(err_code, "IA_CMD_TYPE_INIT_PROCESS"); |
| } |
| |
| uint32_t ui_init_done; |
| /* Checking for end of initialization */ |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_INIT, |
| IA_CMD_TYPE_INIT_DONE_QUERY, |
| &ui_init_done); |
| RETURN_IF_FATAL(err_code, "IA_CMD_TYPE_INIT_DONE_QUERY"); |
| |
| /* How much buffer is used in input buffers */ |
| int32_t i_bytes_consumed; |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_GET_CURIDX_INPUT_BUF, |
| 0, |
| &i_bytes_consumed); |
| RETURN_IF_FATAL(err_code, "IA_API_CMD_GET_CURIDX_INPUT_BUF"); |
| |
| if (ui_init_done) { |
| err_code = getXAACStreamInfo(); |
| RETURN_IF_FATAL(err_code, "getXAACStreamInfo"); |
| ALOGI("Found Codec with below config---\nsampFreq %d\nnumChannels %d\npcmWdSz %d\nchannelMask %d\noutputFrameLength %d", |
| mSampFreq, mNumChannels, mPcmWdSz, mChannelMask, mOutputFrameLength); |
| mIsCodecInitialized = true; |
| |
| err_code = configMPEGDDrc(); |
| RETURN_IF_FATAL(err_code, "configMPEGDDrc"); |
| } |
| |
| return IA_NO_ERROR; |
| } |
| IA_ERRORCODE C2SoftXaacDec::initMPEGDDDrc() { |
| IA_ERRORCODE err_code = IA_NO_ERROR; |
| |
| for (int i = 0; i < (WORD32)2; i++) { |
| WORD32 ui_size, ui_alignment, ui_type; |
| pVOID pv_alloc_ptr; |
| |
| /* Get memory size */ |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_GET_MEM_INFO_SIZE, i, &ui_size); |
| |
| RETURN_IF_FATAL(err_code, "IA_API_CMD_GET_MEM_INFO_SIZE"); |
| |
| /* Get memory alignment */ |
| err_code = |
| ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_GET_MEM_INFO_ALIGNMENT, i, &ui_alignment); |
| |
| RETURN_IF_FATAL(err_code, "IA_API_CMD_GET_MEM_INFO_ALIGNMENT"); |
| |
| /* Get memory type */ |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_GET_MEM_INFO_TYPE, i, &ui_type); |
| RETURN_IF_FATAL(err_code, "IA_API_CMD_GET_MEM_INFO_TYPE"); |
| |
| pv_alloc_ptr = memalign(4, ui_size); |
| if (pv_alloc_ptr == NULL) { |
| ALOGE(" Cannot create requested memory %d", ui_size); |
| return IA_FATAL_ERROR; |
| } |
| mDrcMemoryVec.push(pv_alloc_ptr); |
| |
| /* Set the buffer pointer */ |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_SET_MEM_PTR, i, pv_alloc_ptr); |
| |
| RETURN_IF_FATAL(err_code, "IA_API_CMD_SET_MEM_PTR"); |
| } |
| |
| WORD32 ui_size; |
| ui_size = 8192 * 2; |
| |
| mDrcInBuf = (int8_t*)memalign(4, ui_size); |
| if (mDrcInBuf == NULL) { |
| ALOGE(" Cannot create requested memory %d", ui_size); |
| return IA_FATAL_ERROR; |
| } |
| mDrcMemoryVec.push(mDrcInBuf); |
| |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_SET_MEM_PTR, 2, mDrcInBuf); |
| RETURN_IF_FATAL(err_code, "IA_API_CMD_SET_MEM_PTR"); |
| |
| mDrcOutBuf = (int8_t*)memalign(4, ui_size); |
| if (mDrcOutBuf == NULL) { |
| ALOGE(" Cannot create requested memory %d", ui_size); |
| return IA_FATAL_ERROR; |
| } |
| mDrcMemoryVec.push(mDrcOutBuf); |
| |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_SET_MEM_PTR, 3, mDrcOutBuf); |
| RETURN_IF_FATAL(err_code, "IA_API_CMD_SET_MEM_PTR"); |
| |
| return IA_NO_ERROR; |
| } |
| int C2SoftXaacDec::configMPEGDDrc() { |
| IA_ERRORCODE err_code = IA_NO_ERROR; |
| int i_effect_type; |
| int i_loud_norm; |
| int i_target_loudness; |
| unsigned int i_sbr_mode; |
| |
| /* Sampling Frequency */ |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_SET_CONFIG_PARAM, |
| IA_DRC_DEC_CONFIG_PARAM_SAMP_FREQ, &mSampFreq); |
| RETURN_IF_FATAL(err_code, "IA_DRC_DEC_CONFIG_PARAM_SAMP_FREQ"); |
| /* Total Number of Channels */ |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_SET_CONFIG_PARAM, |
| IA_DRC_DEC_CONFIG_PARAM_NUM_CHANNELS, &mNumChannels); |
| RETURN_IF_FATAL(err_code, "IA_DRC_DEC_CONFIG_PARAM_NUM_CHANNELS"); |
| |
| /* PCM word size */ |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_SET_CONFIG_PARAM, |
| IA_DRC_DEC_CONFIG_PARAM_PCM_WDSZ, &mPcmWdSz); |
| RETURN_IF_FATAL(err_code, "IA_DRC_DEC_CONFIG_PARAM_PCM_WDSZ"); |
| |
| /*Set Effect Type*/ |
| |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, IA_API_CMD_GET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_EFFECT_TYPE, &i_effect_type); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_EFFECT_TYPE"); |
| |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_SET_CONFIG_PARAM, |
| IA_DRC_DEC_CONFIG_DRC_EFFECT_TYPE, &i_effect_type); |
| RETURN_IF_FATAL(err_code, "IA_DRC_DEC_CONFIG_DRC_EFFECT_TYPE"); |
| |
| /*Set target loudness */ |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, IA_API_CMD_GET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_TARGET_LOUDNESS, |
| &i_target_loudness); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_TARGET_LOUDNESS"); |
| |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_SET_CONFIG_PARAM, |
| IA_DRC_DEC_CONFIG_DRC_TARGET_LOUDNESS, &i_target_loudness); |
| RETURN_IF_FATAL(err_code, "IA_DRC_DEC_CONFIG_DRC_TARGET_LOUDNESS"); |
| |
| /*Set loud_norm_flag*/ |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, IA_API_CMD_GET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_LOUD_NORM, &i_loud_norm); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_LOUD_NORM"); |
| |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_SET_CONFIG_PARAM, |
| IA_DRC_DEC_CONFIG_DRC_LOUD_NORM, &i_loud_norm); |
| RETURN_IF_FATAL(err_code, "IA_DRC_DEC_CONFIG_DRC_LOUD_NORM"); |
| |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, IA_API_CMD_GET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_PARAM_SBR_MODE, &i_sbr_mode); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_PARAM_SBR_MODE"); |
| |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_INIT, |
| IA_CMD_TYPE_INIT_API_POST_CONFIG_PARAMS, NULL); |
| |
| RETURN_IF_FATAL(err_code, "IA_CMD_TYPE_INIT_API_POST_CONFIG_PARAMS"); |
| |
| /* Free any memory that is allocated for MPEG D Drc so far */ |
| deInitMPEGDDDrc(); |
| |
| err_code = initMPEGDDDrc(); |
| if (err_code != IA_NO_ERROR) { |
| ALOGE("initMPEGDDDrc failed with error %d", err_code); |
| deInitMPEGDDDrc(); |
| return err_code; |
| } |
| |
| /* DRC buffers |
| buf[0] - contains extension element pay load loudness related |
| buf[1] - contains extension element pay load*/ |
| { |
| VOID* p_array[2][16]; |
| WORD32 ii; |
| WORD32 buf_sizes[2][16]; |
| WORD32 num_elements; |
| WORD32 num_config_ext; |
| WORD32 bit_str_fmt = 1; |
| |
| WORD32 uo_num_chan; |
| |
| memset(buf_sizes, 0, 32 * sizeof(WORD32)); |
| |
| err_code = |
| ixheaacd_dec_api(mXheaacCodecHandle, IA_API_CMD_GET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_EXT_ELE_BUF_SIZES, &buf_sizes[0][0]); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_EXT_ELE_BUF_SIZES"); |
| |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, IA_API_CMD_GET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_EXT_ELE_PTR, &p_array); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_EXT_ELE_PTR"); |
| |
| err_code = |
| ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_INIT, IA_CMD_TYPE_INIT_SET_BUFF_PTR, 0); |
| RETURN_IF_FATAL(err_code, "IA_CMD_TYPE_INIT_SET_BUFF_PTR"); |
| |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, IA_API_CMD_GET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_NUM_ELE, &num_elements); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_NUM_ELE"); |
| |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, IA_API_CMD_GET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_NUM_CONFIG_EXT, &num_config_ext); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_NUM_CONFIG_EXT"); |
| |
| for (ii = 0; ii < num_config_ext; ii++) { |
| /*copy loudness bitstream*/ |
| if (buf_sizes[0][ii] > 0) { |
| memcpy(mDrcInBuf, p_array[0][ii], buf_sizes[0][ii]); |
| |
| /*Set bitstream_split_format */ |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_SET_CONFIG_PARAM, |
| IA_DRC_DEC_CONFIG_PARAM_BITS_FORMAT, &bit_str_fmt); |
| RETURN_IF_FATAL(err_code, "IA_DRC_DEC_CONFIG_PARAM_BITS_FORMAT"); |
| |
| /* Set number of bytes to be processed */ |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_SET_INPUT_BYTES_IL_BS, 0, |
| &buf_sizes[0][ii]); |
| RETURN_IF_FATAL(err_code, "IA_API_CMD_SET_INPUT_BYTES_IL_BS"); |
| |
| /* Execute process */ |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_INIT, |
| IA_CMD_TYPE_INIT_CPY_IL_BSF_BUFF, NULL); |
| RETURN_IF_FATAL(err_code, "IA_CMD_TYPE_INIT_CPY_IL_BSF_BUFF"); |
| |
| mDRCFlag = 1; |
| } |
| } |
| |
| for (ii = 0; ii < num_elements; ii++) { |
| /*copy config bitstream*/ |
| if (buf_sizes[1][ii] > 0) { |
| memcpy(mDrcInBuf, p_array[1][ii], buf_sizes[1][ii]); |
| /* Set number of bytes to be processed */ |
| |
| /*Set bitstream_split_format */ |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_SET_CONFIG_PARAM, |
| IA_DRC_DEC_CONFIG_PARAM_BITS_FORMAT, &bit_str_fmt); |
| RETURN_IF_FATAL(err_code, "IA_DRC_DEC_CONFIG_PARAM_BITS_FORMAT"); |
| |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_SET_INPUT_BYTES_IC_BS, 0, |
| &buf_sizes[1][ii]); |
| RETURN_IF_FATAL(err_code, "IA_API_CMD_SET_INPUT_BYTES_IC_BS"); |
| |
| /* Execute process */ |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_INIT, |
| IA_CMD_TYPE_INIT_CPY_IC_BSF_BUFF, NULL); |
| |
| RETURN_IF_FATAL(err_code, "IA_CMD_TYPE_INIT_CPY_IC_BSF_BUFF"); |
| |
| mDRCFlag = 1; |
| } |
| } |
| |
| if (mDRCFlag == 1) { |
| mMpegDDRCPresent = 1; |
| } else { |
| mMpegDDRCPresent = 0; |
| } |
| |
| /*Read interface buffer config file bitstream*/ |
| if (mMpegDDRCPresent == 1) { |
| WORD32 interface_is_present = 1; |
| |
| if (i_sbr_mode != 0) { |
| if (i_sbr_mode == 1) { |
| mOutputFrameLength = 2048; |
| } else if (i_sbr_mode == 3) { |
| mOutputFrameLength = 4096; |
| } else { |
| mOutputFrameLength = 1024; |
| } |
| } else { |
| mOutputFrameLength = 4096; |
| } |
| |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_SET_CONFIG_PARAM, |
| IA_DRC_DEC_CONFIG_PARAM_FRAME_SIZE, (WORD32 *)&mOutputFrameLength); |
| RETURN_IF_FATAL(err_code, "IA_DRC_DEC_CONFIG_PARAM_FRAME_SIZE"); |
| |
| err_code = |
| ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_SET_CONFIG_PARAM, |
| IA_DRC_DEC_CONFIG_PARAM_INT_PRESENT, &interface_is_present); |
| RETURN_IF_FATAL(err_code, "IA_DRC_DEC_CONFIG_PARAM_INT_PRESENT"); |
| |
| /* Execute process */ |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_INIT, |
| IA_CMD_TYPE_INIT_CPY_IN_BSF_BUFF, NULL); |
| RETURN_IF_FATAL(err_code, "IA_CMD_TYPE_INIT_CPY_IN_BSF_BUFF"); |
| |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_INIT, |
| IA_CMD_TYPE_INIT_PROCESS, NULL); |
| RETURN_IF_FATAL(err_code, "IA_CMD_TYPE_INIT_PROCESS"); |
| |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_GET_CONFIG_PARAM, |
| IA_DRC_DEC_CONFIG_PARAM_NUM_CHANNELS, &uo_num_chan); |
| RETURN_IF_FATAL(err_code, "IA_DRC_DEC_CONFIG_PARAM_NUM_CHANNELS"); |
| } |
| } |
| |
| return err_code; |
| } |
| |
| IA_ERRORCODE C2SoftXaacDec::decodeXAACStream(uint8_t* inBuffer, |
| uint32_t inBufferLength, |
| int32_t* bytesConsumed, |
| int32_t* outBytes) { |
| if (mInputBufferSize < inBufferLength) { |
| ALOGE("Cannot config AAC, input buffer size %d < inBufferLength %d", mInputBufferSize, inBufferLength); |
| return -1; |
| } |
| /* Copy the buffer passed by Android plugin to codec input buffer */ |
| memcpy(mInputBuffer, inBuffer, inBufferLength); |
| |
| /* Set number of bytes to be processed */ |
| IA_ERRORCODE err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_SET_INPUT_BYTES, |
| 0, |
| &inBufferLength); |
| RETURN_IF_FATAL(err_code, "IA_API_CMD_SET_INPUT_BYTES"); |
| |
| /* Execute process */ |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_EXECUTE, |
| IA_CMD_TYPE_DO_EXECUTE, |
| NULL); |
| RETURN_IF_FATAL(err_code, "IA_CMD_TYPE_DO_EXECUTE"); |
| |
| /* Checking for end of processing */ |
| uint32_t ui_exec_done; |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_EXECUTE, |
| IA_CMD_TYPE_DONE_QUERY, |
| &ui_exec_done); |
| RETURN_IF_FATAL(err_code, "IA_CMD_TYPE_DONE_QUERY"); |
| |
| if (ui_exec_done != 1) { |
| VOID* p_array; // ITTIAM:buffer to handle gain payload |
| WORD32 buf_size = 0; // ITTIAM:gain payload length |
| WORD32 bit_str_fmt = 1; |
| WORD32 gain_stream_flag = 1; |
| |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, IA_API_CMD_GET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_GAIN_PAYLOAD_LEN, &buf_size); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_GAIN_PAYLOAD_LEN"); |
| |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, IA_API_CMD_GET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_GAIN_PAYLOAD_BUF, &p_array); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_GAIN_PAYLOAD_BUF"); |
| |
| if (buf_size > 0) { |
| /*Set bitstream_split_format */ |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_SET_CONFIG_PARAM, |
| IA_DRC_DEC_CONFIG_PARAM_BITS_FORMAT, &bit_str_fmt); |
| RETURN_IF_FATAL(err_code, "IA_DRC_DEC_CONFIG_PARAM_BITS_FORMAT"); |
| |
| memcpy(mDrcInBuf, p_array, buf_size); |
| /* Set number of bytes to be processed */ |
| err_code = |
| ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_SET_INPUT_BYTES_BS, 0, &buf_size); |
| RETURN_IF_FATAL(err_code, "IA_DRC_DEC_CONFIG_PARAM_BITS_FORMAT"); |
| |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_SET_CONFIG_PARAM, |
| IA_DRC_DEC_CONFIG_GAIN_STREAM_FLAG, &gain_stream_flag); |
| RETURN_IF_FATAL(err_code, "IA_DRC_DEC_CONFIG_PARAM_BITS_FORMAT"); |
| |
| /* Execute process */ |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_INIT, |
| IA_CMD_TYPE_INIT_CPY_BSF_BUFF, NULL); |
| RETURN_IF_FATAL(err_code, "IA_DRC_DEC_CONFIG_PARAM_BITS_FORMAT"); |
| |
| mMpegDDRCPresent = 1; |
| } |
| } |
| |
| /* How much buffer is used in input buffers */ |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_GET_CURIDX_INPUT_BUF, |
| 0, |
| bytesConsumed); |
| RETURN_IF_FATAL(err_code, "IA_API_CMD_GET_CURIDX_INPUT_BUF"); |
| |
| /* Get the output bytes */ |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_GET_OUTPUT_BYTES, |
| 0, |
| outBytes); |
| RETURN_IF_FATAL(err_code, "IA_API_CMD_GET_OUTPUT_BYTES"); |
| |
| if (mMpegDDRCPresent == 1) { |
| memcpy(mDrcInBuf, mOutputBuffer, *outBytes); |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_SET_INPUT_BYTES, 0, outBytes); |
| RETURN_IF_FATAL(err_code, "IA_API_CMD_SET_INPUT_BYTES"); |
| |
| err_code = |
| ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_EXECUTE, IA_CMD_TYPE_DO_EXECUTE, NULL); |
| RETURN_IF_FATAL(err_code, "IA_CMD_TYPE_DO_EXECUTE"); |
| |
| memcpy(mOutputBuffer, mDrcOutBuf, *outBytes); |
| } |
| return IA_NO_ERROR; |
| } |
| |
| IA_ERRORCODE C2SoftXaacDec::getXAACStreamInfo() { |
| IA_ERRORCODE err_code = IA_NO_ERROR; |
| |
| /* Sampling frequency */ |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_GET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_PARAM_SAMP_FREQ, |
| &mSampFreq); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_PARAM_SAMP_FREQ"); |
| |
| /* Total Number of Channels */ |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_GET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_PARAM_NUM_CHANNELS, |
| &mNumChannels); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_PARAM_NUM_CHANNELS"); |
| if (mNumChannels > MAX_CHANNEL_COUNT) { |
| ALOGE(" No of channels are more than max channels\n"); |
| return IA_FATAL_ERROR; |
| } |
| |
| /* PCM word size */ |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_GET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_PARAM_PCM_WDSZ, |
| &mPcmWdSz); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_PARAM_PCM_WDSZ"); |
| if ((mPcmWdSz / 8) != 2) { |
| ALOGE(" No of channels are more than max channels\n"); |
| return IA_FATAL_ERROR; |
| } |
| |
| /* channel mask to tell the arrangement of channels in bit stream */ |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_GET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_PARAM_CHANNEL_MASK, |
| &mChannelMask); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_PARAM_CHANNEL_MASK"); |
| |
| /* Channel mode to tell MONO/STEREO/DUAL-MONO/NONE_OF_THESE */ |
| uint32_t ui_channel_mode; |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_GET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_PARAM_CHANNEL_MODE, |
| &ui_channel_mode); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_PARAM_CHANNEL_MODE"); |
| if (ui_channel_mode == 0) |
| ALOGV("Channel Mode: MONO_OR_PS\n"); |
| else if (ui_channel_mode == 1) |
| ALOGV("Channel Mode: STEREO\n"); |
| else if (ui_channel_mode == 2) |
| ALOGV("Channel Mode: DUAL-MONO\n"); |
| else |
| ALOGV("Channel Mode: NONE_OF_THESE or MULTICHANNEL\n"); |
| |
| /* Channel mode to tell SBR PRESENT/NOT_PRESENT */ |
| uint32_t ui_sbr_mode; |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, |
| IA_API_CMD_GET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_PARAM_SBR_MODE, |
| &ui_sbr_mode); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_PARAM_SBR_MODE"); |
| if (ui_sbr_mode == 0) |
| ALOGV("SBR Mode: NOT_PRESENT\n"); |
| else if (ui_sbr_mode == 1) |
| ALOGV("SBR Mode: PRESENT\n"); |
| else |
| ALOGV("SBR Mode: ILLEGAL\n"); |
| |
| /* mOutputFrameLength = 1024 * (1 + SBR_MODE) for AAC */ |
| /* For USAC it could be 1024 * 3 , support to query */ |
| /* not yet added in codec */ |
| mOutputFrameLength = 1024 * (1 + ui_sbr_mode); |
| ALOGI("mOutputFrameLength %d ui_sbr_mode %d", mOutputFrameLength, ui_sbr_mode); |
| |
| return IA_NO_ERROR; |
| } |
| |
| IA_ERRORCODE C2SoftXaacDec::setXAACDRCInfo(int32_t drcCut, int32_t drcBoost, |
| int32_t drcRefLevel, |
| int32_t drcHeavyCompression, |
| int32_t drEffectType) { |
| IA_ERRORCODE err_code = IA_NO_ERROR; |
| |
| int32_t ui_drc_enable = 1; |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, IA_API_CMD_SET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_ENABLE, |
| &ui_drc_enable); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_ENABLE"); |
| if (drcCut != -1) { |
| err_code = |
| ixheaacd_dec_api(mXheaacCodecHandle, IA_API_CMD_SET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_CUT, &drcCut); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_CUT"); |
| } |
| |
| if (drcBoost != -1) { |
| err_code = ixheaacd_dec_api( |
| mXheaacCodecHandle, IA_API_CMD_SET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_BOOST, &drcBoost); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_BOOST"); |
| } |
| |
| if (drcRefLevel != -1) { |
| err_code = ixheaacd_dec_api( |
| mXheaacCodecHandle, IA_API_CMD_SET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_TARGET_LEVEL, &drcRefLevel); |
| RETURN_IF_FATAL(err_code, |
| "IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_TARGET_LEVEL"); |
| } |
| |
| if (drcRefLevel != -1) { |
| err_code = ixheaacd_dec_api( |
| mXheaacCodecHandle, IA_API_CMD_SET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_DRC_TARGET_LOUDNESS, &drcRefLevel); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_DRC_TARGET_LOUDNESS"); |
| } |
| |
| if (drcHeavyCompression != -1) { |
| err_code = |
| ixheaacd_dec_api(mXheaacCodecHandle, IA_API_CMD_SET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_HEAVY_COMP, |
| &drcHeavyCompression); |
| RETURN_IF_FATAL(err_code, |
| "IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_HEAVY_COMP"); |
| } |
| |
| err_code = |
| ixheaacd_dec_api(mXheaacCodecHandle, IA_API_CMD_SET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_DRC_EFFECT_TYPE, &drEffectType); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_DRC_EFFECT_TYPE"); |
| |
| int32_t i_effect_type, i_target_loudness, i_loud_norm; |
| /*Set Effect Type*/ |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, IA_API_CMD_GET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_EFFECT_TYPE, |
| &i_effect_type); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_EFFECT_TYPE"); |
| |
| err_code = |
| ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_SET_CONFIG_PARAM, |
| IA_DRC_DEC_CONFIG_DRC_EFFECT_TYPE, &i_effect_type); |
| |
| RETURN_IF_FATAL(err_code, "IA_DRC_DEC_CONFIG_DRC_EFFECT_TYPE"); |
| |
| /*Set target loudness */ |
| err_code = ixheaacd_dec_api( |
| mXheaacCodecHandle, IA_API_CMD_GET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_TARGET_LOUDNESS, &i_target_loudness); |
| RETURN_IF_FATAL(err_code, |
| "IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_TARGET_LOUDNESS"); |
| |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_SET_CONFIG_PARAM, |
| IA_DRC_DEC_CONFIG_DRC_TARGET_LOUDNESS, |
| &i_target_loudness); |
| RETURN_IF_FATAL(err_code, "IA_DRC_DEC_CONFIG_DRC_TARGET_LOUDNESS"); |
| |
| /*Set loud_norm_flag*/ |
| err_code = ixheaacd_dec_api(mXheaacCodecHandle, IA_API_CMD_GET_CONFIG_PARAM, |
| IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_LOUD_NORM, |
| &i_loud_norm); |
| RETURN_IF_FATAL(err_code, "IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_LOUD_NORM"); |
| |
| err_code = ia_drc_dec_api(mMpegDDrcHandle, IA_API_CMD_SET_CONFIG_PARAM, |
| IA_DRC_DEC_CONFIG_DRC_LOUD_NORM, &i_loud_norm); |
| |
| RETURN_IF_FATAL(err_code, "IA_DRC_DEC_CONFIG_DRC_LOUD_NORM"); |
| |
| return IA_NO_ERROR; |
| } |
| |
| class C2SoftXaacDecFactory : public C2ComponentFactory { |
| public: |
| C2SoftXaacDecFactory() : mHelper(std::static_pointer_cast<C2ReflectorHelper>( |
| GetCodec2PlatformComponentStore()->getParamReflector())) { |
| } |
| |
| virtual c2_status_t createComponent( |
| c2_node_id_t id, |
| std::shared_ptr<C2Component>* const component, |
| std::function<void(C2Component*)> deleter) override { |
| *component = std::shared_ptr<C2Component>( |
| new C2SoftXaacDec(COMPONENT_NAME, |
| id, |
| std::make_shared<C2SoftXaacDec::IntfImpl>(mHelper)), |
| deleter); |
| return C2_OK; |
| } |
| |
| virtual c2_status_t createInterface( |
| c2_node_id_t id, |
| std::shared_ptr<C2ComponentInterface>* const interface, |
| std::function<void(C2ComponentInterface*)> deleter) override { |
| *interface = std::shared_ptr<C2ComponentInterface>( |
| new SimpleInterface<C2SoftXaacDec::IntfImpl>( |
| COMPONENT_NAME, id, std::make_shared<C2SoftXaacDec::IntfImpl>(mHelper)), |
| deleter); |
| return C2_OK; |
| } |
| |
| virtual ~C2SoftXaacDecFactory() override = default; |
| |
| private: |
| std::shared_ptr<C2ReflectorHelper> mHelper; |
| }; |
| |
| } // namespace android |
| |
| extern "C" ::C2ComponentFactory* CreateCodec2Factory() { |
| ALOGV("in %s", __func__); |
| return new ::android::C2SoftXaacDecFactory(); |
| } |
| |
| extern "C" void DestroyCodec2Factory(::C2ComponentFactory* factory) { |
| ALOGV("in %s", __func__); |
| delete factory; |
| } |
