| /* |
| * Copyright (C) 2013 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. |
| */ |
| |
| #include <inttypes.h> |
| |
| //#define LOG_NDEBUG 0 |
| #define LOG_TAG "SoftVideoDecoderOMXComponent" |
| #include <utils/Log.h> |
| |
| #include <media/stagefright/omx/SoftVideoDecoderOMXComponent.h> |
| |
| #include <media/stagefright/foundation/ADebug.h> |
| #include <media/stagefright/foundation/ALooper.h> |
| #include <media/stagefright/foundation/AMessage.h> |
| #include <media/stagefright/foundation/AUtils.h> |
| #include <media/stagefright/foundation/MediaDefs.h> |
| #include <media/hardware/HardwareAPI.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; |
| } |
| |
| SoftVideoDecoderOMXComponent::SoftVideoDecoderOMXComponent( |
| const char *name, |
| const char *componentRole, |
| OMX_VIDEO_CODINGTYPE codingType, |
| const CodecProfileLevel *profileLevels, |
| size_t numProfileLevels, |
| int32_t width, |
| int32_t height, |
| const OMX_CALLBACKTYPE *callbacks, |
| OMX_PTR appData, |
| OMX_COMPONENTTYPE **component) |
| : SimpleSoftOMXComponent(name, callbacks, appData, component), |
| mIsAdaptive(false), |
| mAdaptiveMaxWidth(0), |
| mAdaptiveMaxHeight(0), |
| mWidth(width), |
| mHeight(height), |
| mCropLeft(0), |
| mCropTop(0), |
| mCropWidth(width), |
| mCropHeight(height), |
| mOutputFormat(OMX_COLOR_FormatYUV420Planar), |
| mOutputPortSettingsChange(NONE), |
| mUpdateColorAspects(false), |
| mMinInputBufferSize(384), // arbitrary, using one uncompressed macroblock |
| mMinCompressionRatio(1), // max input size is normally the output size |
| mComponentRole(componentRole), |
| mCodingType(codingType), |
| mProfileLevels(profileLevels), |
| mNumProfileLevels(numProfileLevels) { |
| |
| // init all the color aspects to be Unspecified. |
| memset(&mDefaultColorAspects, 0, sizeof(ColorAspects)); |
| memset(&mBitstreamColorAspects, 0, sizeof(ColorAspects)); |
| memset(&mFinalColorAspects, 0, sizeof(ColorAspects)); |
| memset(&mHdrStaticInfo, 0, sizeof(HDRStaticInfo)); |
| } |
| |
| void SoftVideoDecoderOMXComponent::initPorts( |
| OMX_U32 numInputBuffers, |
| OMX_U32 inputBufferSize, |
| OMX_U32 numOutputBuffers, |
| const char *mimeType, |
| OMX_U32 minCompressionRatio) { |
| initPorts(numInputBuffers, numInputBuffers, inputBufferSize, |
| numOutputBuffers, numOutputBuffers, mimeType, minCompressionRatio); |
| } |
| |
| void SoftVideoDecoderOMXComponent::initPorts( |
| OMX_U32 numMinInputBuffers, |
| OMX_U32 numInputBuffers, |
| OMX_U32 inputBufferSize, |
| OMX_U32 numMinOutputBuffers, |
| OMX_U32 numOutputBuffers, |
| const char *mimeType, |
| OMX_U32 minCompressionRatio) { |
| mMinInputBufferSize = inputBufferSize; |
| mMinCompressionRatio = minCompressionRatio; |
| |
| OMX_PARAM_PORTDEFINITIONTYPE def; |
| InitOMXParams(&def); |
| |
| def.nPortIndex = kInputPortIndex; |
| def.eDir = OMX_DirInput; |
| def.nBufferCountMin = numMinInputBuffers; |
| def.nBufferCountActual = numInputBuffers; |
| def.nBufferSize = inputBufferSize; |
| def.bEnabled = OMX_TRUE; |
| def.bPopulated = OMX_FALSE; |
| def.eDomain = OMX_PortDomainVideo; |
| def.bBuffersContiguous = OMX_FALSE; |
| def.nBufferAlignment = 1; |
| |
| def.format.video.cMIMEType = const_cast<char *>(mimeType); |
| def.format.video.pNativeRender = NULL; |
| /* size is initialized in updatePortDefinitions() */ |
| def.format.video.nBitrate = 0; |
| def.format.video.xFramerate = 0; |
| def.format.video.bFlagErrorConcealment = OMX_FALSE; |
| def.format.video.eCompressionFormat = mCodingType; |
| def.format.video.eColorFormat = OMX_COLOR_FormatUnused; |
| def.format.video.pNativeWindow = NULL; |
| |
| addPort(def); |
| |
| def.nPortIndex = kOutputPortIndex; |
| def.eDir = OMX_DirOutput; |
| def.nBufferCountMin = numMinOutputBuffers; |
| def.nBufferCountActual = numOutputBuffers; |
| def.bEnabled = OMX_TRUE; |
| def.bPopulated = OMX_FALSE; |
| def.eDomain = OMX_PortDomainVideo; |
| def.bBuffersContiguous = OMX_FALSE; |
| def.nBufferAlignment = 2; |
| |
| def.format.video.cMIMEType = const_cast<char *>("video/raw"); |
| def.format.video.pNativeRender = NULL; |
| /* size is initialized in updatePortDefinitions() */ |
| def.format.video.nBitrate = 0; |
| def.format.video.xFramerate = 0; |
| def.format.video.bFlagErrorConcealment = OMX_FALSE; |
| def.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused; |
| def.format.video.pNativeWindow = NULL; |
| |
| addPort(def); |
| |
| updatePortDefinitions(true /* updateCrop */, true /* updateInputSize */); |
| } |
| |
| void SoftVideoDecoderOMXComponent::updatePortDefinitions(bool updateCrop, bool updateInputSize) { |
| OMX_PARAM_PORTDEFINITIONTYPE *outDef = &editPortInfo(kOutputPortIndex)->mDef; |
| outDef->format.video.nFrameWidth = outputBufferWidth(); |
| outDef->format.video.nFrameHeight = outputBufferHeight(); |
| outDef->format.video.eColorFormat = mOutputFormat; |
| outDef->format.video.nSliceHeight = outDef->format.video.nFrameHeight; |
| |
| int32_t bpp = (mOutputFormat == OMX_COLOR_FormatYUV420Planar16) ? 2 : 1; |
| outDef->format.video.nStride = outDef->format.video.nFrameWidth * bpp; |
| outDef->nBufferSize = |
| (outDef->format.video.nStride * outDef->format.video.nSliceHeight * 3) / 2; |
| |
| OMX_PARAM_PORTDEFINITIONTYPE *inDef = &editPortInfo(kInputPortIndex)->mDef; |
| inDef->format.video.nFrameWidth = mWidth; |
| inDef->format.video.nFrameHeight = mHeight; |
| // input port is compressed, hence it has no stride |
| inDef->format.video.nStride = 0; |
| inDef->format.video.nSliceHeight = 0; |
| |
| // when output format changes, input buffer size does not actually change |
| if (updateInputSize) { |
| inDef->nBufferSize = max( |
| outDef->nBufferSize / mMinCompressionRatio, |
| max(mMinInputBufferSize, inDef->nBufferSize)); |
| } |
| |
| if (updateCrop) { |
| mCropLeft = 0; |
| mCropTop = 0; |
| mCropWidth = mWidth; |
| mCropHeight = mHeight; |
| } |
| } |
| |
| |
| uint32_t SoftVideoDecoderOMXComponent::outputBufferWidth() { |
| return max(mIsAdaptive ? mAdaptiveMaxWidth : 0, mWidth); |
| } |
| |
| uint32_t SoftVideoDecoderOMXComponent::outputBufferHeight() { |
| return max(mIsAdaptive ? mAdaptiveMaxHeight : 0, mHeight); |
| } |
| |
| void SoftVideoDecoderOMXComponent::handlePortSettingsChange( |
| bool *portWillReset, uint32_t width, uint32_t height, |
| OMX_COLOR_FORMATTYPE outputFormat, |
| CropSettingsMode cropSettingsMode, bool fakeStride) { |
| *portWillReset = false; |
| bool sizeChanged = (width != mWidth || height != mHeight); |
| bool formatChanged = (outputFormat != mOutputFormat); |
| bool updateCrop = (cropSettingsMode == kCropUnSet); |
| bool cropChanged = (cropSettingsMode == kCropChanged); |
| bool strideChanged = false; |
| if (fakeStride) { |
| OMX_PARAM_PORTDEFINITIONTYPE *def = &editPortInfo(kOutputPortIndex)->mDef; |
| if (def->format.video.nStride != (OMX_S32)width |
| || def->format.video.nSliceHeight != (OMX_U32)height) { |
| strideChanged = true; |
| } |
| } |
| |
| if (formatChanged || sizeChanged || cropChanged || strideChanged) { |
| if (formatChanged) { |
| ALOGD("formatChanged: 0x%08x -> 0x%08x", mOutputFormat, outputFormat); |
| } |
| mOutputFormat = outputFormat; |
| mWidth = width; |
| mHeight = height; |
| |
| if ((sizeChanged && !mIsAdaptive) |
| || width > mAdaptiveMaxWidth |
| || height > mAdaptiveMaxHeight |
| || formatChanged) { |
| if (mIsAdaptive) { |
| if (width > mAdaptiveMaxWidth) { |
| mAdaptiveMaxWidth = width; |
| } |
| if (height > mAdaptiveMaxHeight) { |
| mAdaptiveMaxHeight = height; |
| } |
| } |
| updatePortDefinitions(updateCrop); |
| notify(OMX_EventPortSettingsChanged, kOutputPortIndex, 0, NULL); |
| mOutputPortSettingsChange = AWAITING_DISABLED; |
| *portWillReset = true; |
| } else { |
| updatePortDefinitions(updateCrop); |
| |
| if (fakeStride) { |
| // MAJOR HACK that is not pretty, it's just to fool the renderer to read the correct |
| // data. |
| // Some software decoders (e.g. SoftMPEG4) fill decoded frame directly to output |
| // buffer without considering the output buffer stride and slice height. So this is |
| // used to signal how the buffer is arranged. The alternative is to re-arrange the |
| // output buffer in SoftMPEG4, but that results in memcopies. |
| OMX_PARAM_PORTDEFINITIONTYPE *def = &editPortInfo(kOutputPortIndex)->mDef; |
| def->format.video.nStride = mWidth; |
| def->format.video.nSliceHeight = mHeight; |
| } |
| |
| notify(OMX_EventPortSettingsChanged, kOutputPortIndex, |
| OMX_IndexConfigCommonOutputCrop, NULL); |
| } |
| } else if (mUpdateColorAspects) { |
| notify(OMX_EventPortSettingsChanged, kOutputPortIndex, |
| kDescribeColorAspectsIndex, NULL); |
| mUpdateColorAspects = false; |
| } |
| } |
| |
| void SoftVideoDecoderOMXComponent::dumpColorAspects(const ColorAspects &colorAspects) { |
| ALOGD("dumpColorAspects: (R:%d(%s), P:%d(%s), M:%d(%s), T:%d(%s)) ", |
| colorAspects.mRange, asString(colorAspects.mRange), |
| colorAspects.mPrimaries, asString(colorAspects.mPrimaries), |
| colorAspects.mMatrixCoeffs, asString(colorAspects.mMatrixCoeffs), |
| colorAspects.mTransfer, asString(colorAspects.mTransfer)); |
| } |
| |
| bool SoftVideoDecoderOMXComponent::colorAspectsDiffer( |
| const ColorAspects &a, const ColorAspects &b) { |
| if (a.mRange != b.mRange |
| || a.mPrimaries != b.mPrimaries |
| || a.mTransfer != b.mTransfer |
| || a.mMatrixCoeffs != b.mMatrixCoeffs) { |
| return true; |
| } |
| return false; |
| } |
| |
| void SoftVideoDecoderOMXComponent::updateFinalColorAspects( |
| const ColorAspects &otherAspects, const ColorAspects &preferredAspects) { |
| Mutex::Autolock autoLock(mColorAspectsLock); |
| ColorAspects newAspects; |
| newAspects.mRange = preferredAspects.mRange != ColorAspects::RangeUnspecified ? |
| preferredAspects.mRange : otherAspects.mRange; |
| newAspects.mPrimaries = preferredAspects.mPrimaries != ColorAspects::PrimariesUnspecified ? |
| preferredAspects.mPrimaries : otherAspects.mPrimaries; |
| newAspects.mTransfer = preferredAspects.mTransfer != ColorAspects::TransferUnspecified ? |
| preferredAspects.mTransfer : otherAspects.mTransfer; |
| newAspects.mMatrixCoeffs = preferredAspects.mMatrixCoeffs != ColorAspects::MatrixUnspecified ? |
| preferredAspects.mMatrixCoeffs : otherAspects.mMatrixCoeffs; |
| |
| // Check to see if need update mFinalColorAspects. |
| if (colorAspectsDiffer(mFinalColorAspects, newAspects)) { |
| mFinalColorAspects = newAspects; |
| mUpdateColorAspects = true; |
| } |
| } |
| |
| status_t SoftVideoDecoderOMXComponent::handleColorAspectsChange() { |
| int perference = getColorAspectPreference(); |
| ALOGD("Color Aspects preference: %d ", perference); |
| |
| if (perference == kPreferBitstream) { |
| updateFinalColorAspects(mDefaultColorAspects, mBitstreamColorAspects); |
| } else if (perference == kPreferContainer) { |
| updateFinalColorAspects(mBitstreamColorAspects, mDefaultColorAspects); |
| } else { |
| return OMX_ErrorUnsupportedSetting; |
| } |
| return OK; |
| } |
| |
| void SoftVideoDecoderOMXComponent::copyYV12FrameToOutputBuffer( |
| uint8_t *dst, const uint8_t *srcY, const uint8_t *srcU, const uint8_t *srcV, |
| size_t srcYStride, size_t srcUStride, size_t srcVStride) { |
| OMX_PARAM_PORTDEFINITIONTYPE *outDef = &editPortInfo(kOutputPortIndex)->mDef; |
| int32_t bpp = (outDef->format.video.eColorFormat == OMX_COLOR_FormatYUV420Planar16) ? 2 : 1; |
| |
| size_t dstYStride = outputBufferWidth() * bpp; |
| size_t dstUVStride = dstYStride / 2; |
| size_t dstHeight = outputBufferHeight(); |
| uint8_t *dstStart = dst; |
| |
| for (size_t i = 0; i < mHeight; ++i) { |
| memcpy(dst, srcY, mWidth * bpp); |
| srcY += srcYStride; |
| dst += dstYStride; |
| } |
| |
| dst = dstStart + dstYStride * dstHeight; |
| for (size_t i = 0; i < mHeight / 2; ++i) { |
| memcpy(dst, srcU, mWidth / 2 * bpp); |
| srcU += srcUStride; |
| dst += dstUVStride; |
| } |
| |
| dst = dstStart + (5 * dstYStride * dstHeight) / 4; |
| for (size_t i = 0; i < mHeight / 2; ++i) { |
| memcpy(dst, srcV, mWidth / 2 * bpp); |
| srcV += srcVStride; |
| dst += dstUVStride; |
| } |
| } |
| |
| OMX_ERRORTYPE SoftVideoDecoderOMXComponent::internalGetParameter( |
| OMX_INDEXTYPE index, OMX_PTR params) { |
| switch (index) { |
| case OMX_IndexParamVideoPortFormat: |
| { |
| OMX_VIDEO_PARAM_PORTFORMATTYPE *formatParams = |
| (OMX_VIDEO_PARAM_PORTFORMATTYPE *)params; |
| |
| if (!isValidOMXParam(formatParams)) { |
| return OMX_ErrorBadParameter; |
| } |
| |
| if (formatParams->nPortIndex > kMaxPortIndex) { |
| return OMX_ErrorBadPortIndex; |
| } |
| |
| if (formatParams->nIndex != 0) { |
| return OMX_ErrorNoMore; |
| } |
| |
| if (formatParams->nPortIndex == kInputPortIndex) { |
| formatParams->eCompressionFormat = mCodingType; |
| formatParams->eColorFormat = OMX_COLOR_FormatUnused; |
| formatParams->xFramerate = 0; |
| } else { |
| CHECK_EQ(formatParams->nPortIndex, 1u); |
| |
| formatParams->eCompressionFormat = OMX_VIDEO_CodingUnused; |
| formatParams->eColorFormat = OMX_COLOR_FormatYUV420Planar; |
| formatParams->xFramerate = 0; |
| } |
| |
| return OMX_ErrorNone; |
| } |
| |
| case OMX_IndexParamVideoProfileLevelQuerySupported: |
| { |
| OMX_VIDEO_PARAM_PROFILELEVELTYPE *profileLevel = |
| (OMX_VIDEO_PARAM_PROFILELEVELTYPE *) params; |
| |
| if (!isValidOMXParam(profileLevel)) { |
| return OMX_ErrorBadParameter; |
| } |
| |
| if (profileLevel->nPortIndex != kInputPortIndex) { |
| ALOGE("Invalid port index: %" PRIu32, profileLevel->nPortIndex); |
| return OMX_ErrorUnsupportedIndex; |
| } |
| |
| if (profileLevel->nProfileIndex >= mNumProfileLevels) { |
| return OMX_ErrorNoMore; |
| } |
| |
| profileLevel->eProfile = mProfileLevels[profileLevel->nProfileIndex].mProfile; |
| profileLevel->eLevel = mProfileLevels[profileLevel->nProfileIndex].mLevel; |
| return OMX_ErrorNone; |
| } |
| |
| default: |
| return SimpleSoftOMXComponent::internalGetParameter(index, params); |
| } |
| } |
| |
| OMX_ERRORTYPE SoftVideoDecoderOMXComponent::internalSetParameter( |
| OMX_INDEXTYPE index, const OMX_PTR params) { |
| // Include extension index OMX_INDEXEXTTYPE. |
| const int32_t indexFull = index; |
| |
| switch (indexFull) { |
| 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, |
| mComponentRole, |
| OMX_MAX_STRINGNAME_SIZE - 1)) { |
| return OMX_ErrorUndefined; |
| } |
| |
| return OMX_ErrorNone; |
| } |
| |
| case OMX_IndexParamVideoPortFormat: |
| { |
| OMX_VIDEO_PARAM_PORTFORMATTYPE *formatParams = |
| (OMX_VIDEO_PARAM_PORTFORMATTYPE *)params; |
| |
| if (!isValidOMXParam(formatParams)) { |
| return OMX_ErrorBadParameter; |
| } |
| |
| if (formatParams->nPortIndex > kMaxPortIndex) { |
| return OMX_ErrorBadPortIndex; |
| } |
| |
| if (formatParams->nPortIndex == kInputPortIndex) { |
| if (formatParams->eCompressionFormat != mCodingType |
| || formatParams->eColorFormat != OMX_COLOR_FormatUnused) { |
| return OMX_ErrorUnsupportedSetting; |
| } |
| } else { |
| if (formatParams->eCompressionFormat != OMX_VIDEO_CodingUnused |
| || formatParams->eColorFormat != OMX_COLOR_FormatYUV420Planar) { |
| return OMX_ErrorUnsupportedSetting; |
| } |
| } |
| |
| return OMX_ErrorNone; |
| } |
| |
| case kPrepareForAdaptivePlaybackIndex: |
| { |
| const PrepareForAdaptivePlaybackParams* adaptivePlaybackParams = |
| (const PrepareForAdaptivePlaybackParams *)params; |
| |
| if (!isValidOMXParam(adaptivePlaybackParams)) { |
| return OMX_ErrorBadParameter; |
| } |
| |
| mIsAdaptive = adaptivePlaybackParams->bEnable; |
| if (mIsAdaptive) { |
| mAdaptiveMaxWidth = adaptivePlaybackParams->nMaxFrameWidth; |
| mAdaptiveMaxHeight = adaptivePlaybackParams->nMaxFrameHeight; |
| mWidth = mAdaptiveMaxWidth; |
| mHeight = mAdaptiveMaxHeight; |
| } else { |
| mAdaptiveMaxWidth = 0; |
| mAdaptiveMaxHeight = 0; |
| } |
| updatePortDefinitions(true /* updateCrop */, true /* updateInputSize */); |
| return OMX_ErrorNone; |
| } |
| |
| case OMX_IndexParamPortDefinition: |
| { |
| OMX_PARAM_PORTDEFINITIONTYPE *newParams = |
| (OMX_PARAM_PORTDEFINITIONTYPE *)params; |
| |
| if (!isValidOMXParam(newParams)) { |
| return OMX_ErrorBadParameter; |
| } |
| |
| OMX_VIDEO_PORTDEFINITIONTYPE *video_def = &newParams->format.video; |
| OMX_PARAM_PORTDEFINITIONTYPE *def = &editPortInfo(newParams->nPortIndex)->mDef; |
| |
| uint32_t oldWidth = def->format.video.nFrameWidth; |
| uint32_t oldHeight = def->format.video.nFrameHeight; |
| uint32_t newWidth = video_def->nFrameWidth; |
| uint32_t newHeight = video_def->nFrameHeight; |
| // We need width, height, stride and slice-height to be non-zero and sensible. |
| // These values were chosen to prevent integer overflows further down the line, and do |
| // not indicate support for 32kx32k video. |
| if (newWidth > 32768 || newHeight > 32768 |
| || video_def->nStride > 32768 || video_def->nStride < -32768 |
| || video_def->nSliceHeight > 32768) { |
| ALOGE("b/22885421"); |
| return OMX_ErrorBadParameter; |
| } |
| if (newWidth != oldWidth || newHeight != oldHeight) { |
| bool outputPort = (newParams->nPortIndex == kOutputPortIndex); |
| if (outputPort) { |
| // only update (essentially crop) if size changes |
| mWidth = newWidth; |
| mHeight = newHeight; |
| |
| updatePortDefinitions(true /* updateCrop */, true /* updateInputSize */); |
| // reset buffer size based on frame size |
| newParams->nBufferSize = def->nBufferSize; |
| } else { |
| // For input port, we only set nFrameWidth and nFrameHeight. Buffer size |
| // is updated when configuring the output port using the max-frame-size, |
| // though client can still request a larger size. |
| def->format.video.nFrameWidth = newWidth; |
| def->format.video.nFrameHeight = newHeight; |
| } |
| } |
| return SimpleSoftOMXComponent::internalSetParameter(index, params); |
| } |
| |
| default: |
| return SimpleSoftOMXComponent::internalSetParameter(index, params); |
| } |
| } |
| |
| OMX_ERRORTYPE SoftVideoDecoderOMXComponent::getConfig( |
| OMX_INDEXTYPE index, OMX_PTR params) { |
| switch ((int)index) { |
| case OMX_IndexConfigCommonOutputCrop: |
| { |
| OMX_CONFIG_RECTTYPE *rectParams = (OMX_CONFIG_RECTTYPE *)params; |
| |
| if (!isValidOMXParam(rectParams)) { |
| return OMX_ErrorBadParameter; |
| } |
| |
| if (rectParams->nPortIndex != kOutputPortIndex) { |
| return OMX_ErrorUndefined; |
| } |
| |
| rectParams->nLeft = mCropLeft; |
| rectParams->nTop = mCropTop; |
| rectParams->nWidth = mCropWidth; |
| rectParams->nHeight = mCropHeight; |
| |
| return OMX_ErrorNone; |
| } |
| case kDescribeColorAspectsIndex: |
| { |
| if (!supportsDescribeColorAspects()) { |
| return OMX_ErrorUnsupportedIndex; |
| } |
| |
| DescribeColorAspectsParams* colorAspectsParams = |
| (DescribeColorAspectsParams *)params; |
| |
| if (!isValidOMXParam(colorAspectsParams)) { |
| return OMX_ErrorBadParameter; |
| } |
| |
| if (colorAspectsParams->nPortIndex != kOutputPortIndex) { |
| return OMX_ErrorBadParameter; |
| } |
| |
| colorAspectsParams->sAspects = mFinalColorAspects; |
| if (colorAspectsParams->bRequestingDataSpace || colorAspectsParams->bDataSpaceChanged) { |
| return OMX_ErrorUnsupportedSetting; |
| } |
| |
| return OMX_ErrorNone; |
| } |
| |
| case kDescribeHdrStaticInfoIndex: |
| { |
| if (!supportDescribeHdrStaticInfo()) { |
| return OMX_ErrorUnsupportedIndex; |
| } |
| |
| DescribeHDRStaticInfoParams* hdrStaticInfoParams = |
| (DescribeHDRStaticInfoParams *)params; |
| |
| if (!isValidOMXParam(hdrStaticInfoParams)) { |
| return OMX_ErrorBadParameter; |
| } |
| |
| if (hdrStaticInfoParams->nPortIndex != kOutputPortIndex) { |
| return OMX_ErrorBadPortIndex; |
| } |
| |
| hdrStaticInfoParams->sInfo = mHdrStaticInfo; |
| |
| return OMX_ErrorNone; |
| } |
| |
| case kDescribeHdr10PlusInfoIndex: |
| { |
| if (!supportDescribeHdr10PlusInfo()) { |
| return OMX_ErrorUnsupportedIndex; |
| } |
| |
| if (mHdr10PlusOutputs.size() > 0) { |
| auto it = mHdr10PlusOutputs.begin(); |
| |
| auto info = (*it).get(); |
| |
| DescribeHDR10PlusInfoParams* outParams = |
| (DescribeHDR10PlusInfoParams *)params; |
| |
| outParams->nParamSizeUsed = info->size(); |
| |
| // If the buffer provided by the client does not have enough |
| // storage, return the size only and do not remove the param yet. |
| if (outParams->nParamSize >= info->size()) { |
| memcpy(outParams->nValue, info->data(), info->size()); |
| mHdr10PlusOutputs.erase(it); |
| } |
| return OMX_ErrorNone; |
| } |
| return OMX_ErrorUnderflow; |
| } |
| |
| default: |
| return OMX_ErrorUnsupportedIndex; |
| } |
| } |
| |
| OMX_ERRORTYPE SoftVideoDecoderOMXComponent::internalSetConfig( |
| OMX_INDEXTYPE index, const OMX_PTR params, bool *frameConfig){ |
| switch ((int)index) { |
| case kDescribeColorAspectsIndex: |
| { |
| if (!supportsDescribeColorAspects()) { |
| return OMX_ErrorUnsupportedIndex; |
| } |
| const DescribeColorAspectsParams* colorAspectsParams = |
| (const DescribeColorAspectsParams *)params; |
| |
| if (!isValidOMXParam(colorAspectsParams)) { |
| return OMX_ErrorBadParameter; |
| } |
| |
| if (colorAspectsParams->nPortIndex != kOutputPortIndex) { |
| return OMX_ErrorBadParameter; |
| } |
| |
| // Update color aspects if necessary. |
| if (colorAspectsDiffer(colorAspectsParams->sAspects, mDefaultColorAspects)) { |
| mDefaultColorAspects = colorAspectsParams->sAspects; |
| status_t err = handleColorAspectsChange(); |
| CHECK(err == OK); |
| } |
| return OMX_ErrorNone; |
| } |
| |
| case kDescribeHdrStaticInfoIndex: |
| { |
| if (!supportDescribeHdrStaticInfo()) { |
| return OMX_ErrorUnsupportedIndex; |
| } |
| |
| const DescribeHDRStaticInfoParams* hdrStaticInfoParams = |
| (DescribeHDRStaticInfoParams *)params; |
| |
| if (!isValidOMXParam(hdrStaticInfoParams)) { |
| return OMX_ErrorBadParameter; |
| } |
| |
| if (hdrStaticInfoParams->nPortIndex != kOutputPortIndex) { |
| return OMX_ErrorBadPortIndex; |
| } |
| |
| mHdrStaticInfo = hdrStaticInfoParams->sInfo; |
| updatePortDefinitions(false); |
| |
| return OMX_ErrorNone; |
| } |
| |
| case kDescribeHdr10PlusInfoIndex: |
| { |
| if (!supportDescribeHdr10PlusInfo()) { |
| return OMX_ErrorUnsupportedIndex; |
| } |
| |
| const DescribeHDR10PlusInfoParams* inParams = |
| (DescribeHDR10PlusInfoParams *)params; |
| |
| if (*frameConfig) { |
| // This is a request to append to the current frame config set. |
| // For now, we only support kDescribeHdr10PlusInfoIndex, which |
| // we simply replace with the last set value. |
| if (mHdr10PlusInputs.size() > 0) { |
| *(--mHdr10PlusInputs.end()) = ABuffer::CreateAsCopy( |
| inParams->nValue, inParams->nParamSizeUsed); |
| } else { |
| ALOGW("Ignoring kDescribeHdr10PlusInfoIndex: append to " |
| "frame config while no frame config is present"); |
| } |
| } else { |
| // This is a frame config, setting *frameConfig to true so that |
| // the client marks the next queued input frame to apply it. |
| *frameConfig = true; |
| mHdr10PlusInputs.push_back(ABuffer::CreateAsCopy( |
| inParams->nValue, inParams->nParamSizeUsed)); |
| } |
| return OMX_ErrorNone; |
| } |
| |
| default: |
| return OMX_ErrorUnsupportedIndex; |
| } |
| } |
| |
| sp<ABuffer> SoftVideoDecoderOMXComponent::dequeueInputFrameConfig() { |
| auto it = mHdr10PlusInputs.begin(); |
| sp<ABuffer> info = *it; |
| mHdr10PlusInputs.erase(it); |
| return info; |
| } |
| |
| void SoftVideoDecoderOMXComponent::queueOutputFrameConfig(const sp<ABuffer> &info) { |
| mHdr10PlusOutputs.push_back(info); |
| notify(OMX_EventConfigUpdate, |
| kOutputPortIndex, |
| kDescribeHdr10PlusInfoIndex, |
| NULL); |
| } |
| |
| OMX_ERRORTYPE SoftVideoDecoderOMXComponent::getExtensionIndex( |
| const char *name, OMX_INDEXTYPE *index) { |
| if (!strcmp(name, "OMX.google.android.index.prepareForAdaptivePlayback")) { |
| *(int32_t*)index = kPrepareForAdaptivePlaybackIndex; |
| return OMX_ErrorNone; |
| } else if (!strcmp(name, "OMX.google.android.index.describeColorAspects") |
| && supportsDescribeColorAspects()) { |
| *(int32_t*)index = kDescribeColorAspectsIndex; |
| return OMX_ErrorNone; |
| } else if (!strcmp(name, "OMX.google.android.index.describeHDRStaticInfo") |
| && supportDescribeHdrStaticInfo()) { |
| *(int32_t*)index = kDescribeHdrStaticInfoIndex; |
| return OMX_ErrorNone; |
| } else if (!strcmp(name, "OMX.google.android.index.describeHDR10PlusInfo") |
| && supportDescribeHdr10PlusInfo()) { |
| *(int32_t*)index = kDescribeHdr10PlusInfoIndex; |
| return OMX_ErrorNone; |
| } |
| |
| return SimpleSoftOMXComponent::getExtensionIndex(name, index); |
| } |
| |
| bool SoftVideoDecoderOMXComponent::supportsDescribeColorAspects() { |
| return getColorAspectPreference() != kNotSupported; |
| } |
| |
| int SoftVideoDecoderOMXComponent::getColorAspectPreference() { |
| return kNotSupported; |
| } |
| |
| bool SoftVideoDecoderOMXComponent::supportDescribeHdrStaticInfo() { |
| return false; |
| } |
| |
| bool SoftVideoDecoderOMXComponent::supportDescribeHdr10PlusInfo() { |
| return false; |
| } |
| |
| void SoftVideoDecoderOMXComponent::onReset() { |
| mOutputPortSettingsChange = NONE; |
| } |
| |
| void SoftVideoDecoderOMXComponent::onPortEnableCompleted(OMX_U32 portIndex, bool enabled) { |
| if (portIndex != kOutputPortIndex) { |
| return; |
| } |
| |
| switch (mOutputPortSettingsChange) { |
| case NONE: |
| break; |
| |
| case AWAITING_DISABLED: |
| { |
| CHECK(!enabled); |
| mOutputPortSettingsChange = AWAITING_ENABLED; |
| break; |
| } |
| |
| default: |
| { |
| CHECK_EQ((int)mOutputPortSettingsChange, (int)AWAITING_ENABLED); |
| CHECK(enabled); |
| mOutputPortSettingsChange = NONE; |
| break; |
| } |
| } |
| } |
| |
| } // namespace android |
