| /* |
| * 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 "C2SoftApvDec" |
| #include <log/log.h> |
| |
| #include <android_media_swcodec_flags.h> |
| |
| #include <media/stagefright/foundation/AUtils.h> |
| #include <media/stagefright/foundation/MediaDefs.h> |
| |
| #include <C2Debug.h> |
| #include <C2PlatformSupport.h> |
| #include <Codec2BufferUtils.h> |
| #include <Codec2CommonUtils.h> |
| #include <Codec2Mapper.h> |
| #include <SimpleC2Interface.h> |
| #include "C2SoftApvDec.h" |
| |
| #include <cutils/properties.h> |
| |
| const char* MEDIA_MIMETYPE_VIDEO_APV = "video/apv"; |
| |
| #define MAX_NUM_FRMS (1) // supports only 1-frame output |
| #define FRM_IDX (0) // supports only 1-frame output |
| // check generic frame or not |
| #define IS_NON_AUX_FRM(frm) \ |
| (((frm)->pbu_type == OAPV_PBU_TYPE_PRIMARY_FRAME) || \ |
| ((frm)->pbu_type == OAPV_PBU_TYPE_NON_PRIMARY_FRAME)) |
| // check auxiliary frame or not |
| #define IS_AUX_FRM(frm) (!(IS_NON_AUX_FRM(frm))) |
| #define OUTPUT_CSP_NATIVE (0) |
| #define OUTPUT_CSP_P210 (1) |
| |
| namespace android { |
| namespace { |
| constexpr char COMPONENT_NAME[] = "c2.android.apv.decoder"; |
| constexpr uint32_t kDefaultOutputDelay = 8; |
| constexpr uint32_t kMaxOutputDelay = 16; |
| constexpr size_t kMinInputBufferSize = 2 * 1024 * 1024; |
| } // namespace |
| |
| class C2SoftApvDec::IntfImpl : public SimpleInterface<void>::BaseParams { |
| public: |
| explicit IntfImpl(const std::shared_ptr<C2ReflectorHelper>& helper) |
| : SimpleInterface<void>::BaseParams(helper, COMPONENT_NAME, C2Component::KIND_DECODER, |
| C2Component::DOMAIN_VIDEO, MEDIA_MIMETYPE_VIDEO_APV) { |
| noPrivateBuffers(); // TODO: account for our buffers here. |
| noInputReferences(); |
| noOutputReferences(); |
| noInputLatency(); |
| noTimeStretch(); |
| |
| addParameter(DefineParam(mAttrib, C2_PARAMKEY_COMPONENT_ATTRIBUTES) |
| .withConstValue(new C2ComponentAttributesSetting( |
| C2Component::ATTRIB_IS_TEMPORAL)) |
| .build()); |
| |
| addParameter(DefineParam(mSize, C2_PARAMKEY_PICTURE_SIZE) |
| .withDefault(new C2StreamPictureSizeInfo::output(0u, 320, 240)) |
| .withFields({ |
| C2F(mSize, width).inRange(2, 4096), |
| C2F(mSize, height).inRange(2, 4096), |
| }) |
| .withSetter(SizeSetter) |
| .build()); |
| |
| addParameter( |
| DefineParam(mProfileLevel, C2_PARAMKEY_PROFILE_LEVEL) |
| .withDefault(new C2StreamProfileLevelInfo::input( |
| 0u, C2Config::PROFILE_APV_422_10)) |
| .withFields( |
| {C2F(mProfileLevel, profile).oneOf({C2Config::PROFILE_APV_422_10}), |
| C2F(mProfileLevel, level) |
| .oneOf({ |
| C2Config::LEVEL_APV_1_BAND_0, |
| C2Config::LEVEL_APV_1_1_BAND_0, |
| C2Config::LEVEL_APV_2_BAND_0, |
| C2Config::LEVEL_APV_2_1_BAND_0, |
| C2Config::LEVEL_APV_3_BAND_0, |
| C2Config::LEVEL_APV_3_1_BAND_0, |
| C2Config::LEVEL_APV_4_BAND_0, |
| C2Config::LEVEL_APV_4_1_BAND_0, |
| C2Config::LEVEL_APV_5_BAND_0, |
| C2Config::LEVEL_APV_5_1_BAND_0, |
| C2Config::LEVEL_APV_6_BAND_0, |
| C2Config::LEVEL_APV_6_1_BAND_0, |
| C2Config::LEVEL_APV_7_BAND_0, |
| C2Config::LEVEL_APV_7_1_BAND_0, |
| C2Config::LEVEL_APV_1_BAND_1, |
| C2Config::LEVEL_APV_1_1_BAND_1, |
| C2Config::LEVEL_APV_2_BAND_1, |
| C2Config::LEVEL_APV_2_1_BAND_1, |
| C2Config::LEVEL_APV_3_BAND_1, |
| C2Config::LEVEL_APV_3_1_BAND_1, |
| C2Config::LEVEL_APV_4_BAND_1, |
| C2Config::LEVEL_APV_4_1_BAND_1, |
| C2Config::LEVEL_APV_5_BAND_1, |
| C2Config::LEVEL_APV_5_1_BAND_1, |
| C2Config::LEVEL_APV_6_BAND_1, |
| C2Config::LEVEL_APV_6_1_BAND_1, |
| C2Config::LEVEL_APV_7_BAND_1, |
| C2Config::LEVEL_APV_7_1_BAND_1, |
| C2Config::LEVEL_APV_1_BAND_2, |
| C2Config::LEVEL_APV_1_1_BAND_2, |
| C2Config::LEVEL_APV_2_BAND_2, |
| C2Config::LEVEL_APV_2_1_BAND_2, |
| C2Config::LEVEL_APV_3_BAND_2, |
| C2Config::LEVEL_APV_3_1_BAND_2, |
| C2Config::LEVEL_APV_4_BAND_2, |
| C2Config::LEVEL_APV_4_1_BAND_2, |
| C2Config::LEVEL_APV_5_BAND_2, |
| C2Config::LEVEL_APV_5_1_BAND_2, |
| C2Config::LEVEL_APV_6_BAND_2, |
| C2Config::LEVEL_APV_6_1_BAND_2, |
| C2Config::LEVEL_APV_7_BAND_2, |
| C2Config::LEVEL_APV_7_1_BAND_2, |
| C2Config::LEVEL_APV_1_BAND_3, |
| C2Config::LEVEL_APV_1_1_BAND_3, |
| C2Config::LEVEL_APV_2_BAND_3, |
| C2Config::LEVEL_APV_2_1_BAND_3, |
| C2Config::LEVEL_APV_3_BAND_3, |
| C2Config::LEVEL_APV_3_1_BAND_3, |
| C2Config::LEVEL_APV_4_BAND_3, |
| C2Config::LEVEL_APV_4_1_BAND_3, |
| C2Config::LEVEL_APV_5_BAND_3, |
| C2Config::LEVEL_APV_5_1_BAND_3, |
| C2Config::LEVEL_APV_6_BAND_3, |
| C2Config::LEVEL_APV_6_1_BAND_3, |
| C2Config::LEVEL_APV_7_BAND_3, |
| C2Config::LEVEL_APV_7_1_BAND_3, |
| })}) |
| .withSetter(ProfileLevelSetter, mSize) |
| .build()); |
| |
| mHdr10PlusInfoInput = C2StreamHdr10PlusInfo::input::AllocShared(0); |
| addParameter(DefineParam(mHdr10PlusInfoInput, C2_PARAMKEY_INPUT_HDR10_PLUS_INFO) |
| .withDefault(mHdr10PlusInfoInput) |
| .withFields({ |
| C2F(mHdr10PlusInfoInput, m.value).any(), |
| }) |
| .withSetter(Hdr10PlusInfoInputSetter) |
| .build()); |
| |
| mHdr10PlusInfoOutput = C2StreamHdr10PlusInfo::output::AllocShared(0); |
| addParameter(DefineParam(mHdr10PlusInfoOutput, C2_PARAMKEY_OUTPUT_HDR10_PLUS_INFO) |
| .withDefault(mHdr10PlusInfoOutput) |
| .withFields({ |
| C2F(mHdr10PlusInfoOutput, m.value).any(), |
| }) |
| .withSetter(Hdr10PlusInfoOutputSetter) |
| .build()); |
| |
| // default static info |
| C2HdrStaticMetadataStruct defaultStaticInfo{}; |
| helper->addStructDescriptors<C2MasteringDisplayColorVolumeStruct, C2ColorXyStruct>(); |
| addParameter( |
| DefineParam(mHdrStaticInfo, C2_PARAMKEY_HDR_STATIC_INFO) |
| .withDefault(new C2StreamHdrStaticInfo::output(0u, defaultStaticInfo)) |
| .withFields({C2F(mHdrStaticInfo, mastering.red.x).inRange(0, 1), |
| C2F(mHdrStaticInfo, mastering.red.y).inRange(0, 1), |
| C2F(mHdrStaticInfo, mastering.green.x).inRange(0, 1), |
| C2F(mHdrStaticInfo, mastering.green.y).inRange(0, 1), |
| C2F(mHdrStaticInfo, mastering.blue.x).inRange(0, 1), |
| C2F(mHdrStaticInfo, mastering.blue.y).inRange(0, 1), |
| C2F(mHdrStaticInfo, mastering.white.x).inRange(0, 1), |
| C2F(mHdrStaticInfo, mastering.white.x).inRange(0, 1), |
| C2F(mHdrStaticInfo, mastering.maxLuminance).inRange(0, 65535), |
| C2F(mHdrStaticInfo, mastering.minLuminance).inRange(0, 6.5535), |
| C2F(mHdrStaticInfo, maxCll).inRange(0, 0XFFFF), |
| C2F(mHdrStaticInfo, maxFall).inRange(0, 0XFFFF)}) |
| .withSetter(HdrStaticInfoSetter) |
| .build()); |
| |
| addParameter(DefineParam(mMaxSize, C2_PARAMKEY_MAX_PICTURE_SIZE) |
| .withDefault(new C2StreamMaxPictureSizeTuning::output(0u, 320, 240)) |
| .withFields({ |
| C2F(mSize, width).inRange(2, 4096, 2), |
| C2F(mSize, height).inRange(2, 4096, 2), |
| }) |
| .withSetter(MaxPictureSizeSetter, mSize) |
| .build()); |
| |
| addParameter( |
| DefineParam(mMaxInputSize, C2_PARAMKEY_INPUT_MAX_BUFFER_SIZE) |
| .withDefault(new C2StreamMaxBufferSizeInfo::input(0u, kMinInputBufferSize)) |
| .withFields({ |
| C2F(mMaxInputSize, value).any(), |
| }) |
| .calculatedAs(MaxInputSizeSetter, mMaxSize) |
| .build()); |
| |
| C2ChromaOffsetStruct locations[1] = {C2ChromaOffsetStruct::ITU_YUV_420_0()}; |
| std::shared_ptr<C2StreamColorInfo::output> defaultColorInfo = |
| C2StreamColorInfo::output::AllocShared(1u, 0u, 8u /* bitDepth */, C2Color::YUV_420); |
| memcpy(defaultColorInfo->m.locations, locations, sizeof(locations)); |
| |
| defaultColorInfo = C2StreamColorInfo::output::AllocShared( |
| {C2ChromaOffsetStruct::ITU_YUV_420_0()}, 0u, 8u /* bitDepth */, C2Color::YUV_420); |
| helper->addStructDescriptors<C2ChromaOffsetStruct>(); |
| addParameter(DefineParam(mColorInfo, C2_PARAMKEY_CODED_COLOR_INFO) |
| .withConstValue(defaultColorInfo) |
| .build()); |
| |
| addParameter(DefineParam(mDefaultColorAspects, C2_PARAMKEY_DEFAULT_COLOR_ASPECTS) |
| .withDefault(new C2StreamColorAspectsTuning::output( |
| 0u, C2Color::RANGE_UNSPECIFIED, C2Color::PRIMARIES_UNSPECIFIED, |
| C2Color::TRANSFER_UNSPECIFIED, C2Color::MATRIX_UNSPECIFIED)) |
| .withFields({C2F(mDefaultColorAspects, range) |
| .inRange(C2Color::RANGE_UNSPECIFIED, |
| C2Color::RANGE_OTHER), |
| C2F(mDefaultColorAspects, primaries) |
| .inRange(C2Color::PRIMARIES_UNSPECIFIED, |
| C2Color::PRIMARIES_OTHER), |
| C2F(mDefaultColorAspects, transfer) |
| .inRange(C2Color::TRANSFER_UNSPECIFIED, |
| C2Color::TRANSFER_OTHER), |
| C2F(mDefaultColorAspects, matrix) |
| .inRange(C2Color::MATRIX_UNSPECIFIED, |
| C2Color::MATRIX_OTHER)}) |
| .withSetter(DefaultColorAspectsSetter) |
| .build()); |
| |
| addParameter(DefineParam(mCodedColorAspects, C2_PARAMKEY_VUI_COLOR_ASPECTS) |
| .withDefault(new C2StreamColorAspectsInfo::input( |
| 0u, C2Color::RANGE_LIMITED, C2Color::PRIMARIES_UNSPECIFIED, |
| C2Color::TRANSFER_UNSPECIFIED, C2Color::MATRIX_UNSPECIFIED)) |
| .withFields({C2F(mCodedColorAspects, range) |
| .inRange(C2Color::RANGE_UNSPECIFIED, |
| C2Color::RANGE_OTHER), |
| C2F(mCodedColorAspects, primaries) |
| .inRange(C2Color::PRIMARIES_UNSPECIFIED, |
| C2Color::PRIMARIES_OTHER), |
| C2F(mCodedColorAspects, transfer) |
| .inRange(C2Color::TRANSFER_UNSPECIFIED, |
| C2Color::TRANSFER_OTHER), |
| C2F(mCodedColorAspects, matrix) |
| .inRange(C2Color::MATRIX_UNSPECIFIED, |
| C2Color::MATRIX_OTHER)}) |
| .withSetter(CodedColorAspectsSetter) |
| .build()); |
| |
| addParameter( |
| DefineParam(mColorAspects, C2_PARAMKEY_COLOR_ASPECTS) |
| .withDefault(new C2StreamColorAspectsInfo::output( |
| 0u, C2Color::RANGE_UNSPECIFIED, C2Color::PRIMARIES_UNSPECIFIED, |
| C2Color::TRANSFER_UNSPECIFIED, C2Color::MATRIX_UNSPECIFIED)) |
| .withFields( |
| {C2F(mColorAspects, range) |
| .inRange(C2Color::RANGE_UNSPECIFIED, C2Color::RANGE_OTHER), |
| C2F(mColorAspects, primaries) |
| .inRange(C2Color::PRIMARIES_UNSPECIFIED, |
| C2Color::PRIMARIES_OTHER), |
| C2F(mColorAspects, transfer) |
| .inRange(C2Color::TRANSFER_UNSPECIFIED, |
| C2Color::TRANSFER_OTHER), |
| C2F(mColorAspects, matrix) |
| .inRange(C2Color::MATRIX_UNSPECIFIED, |
| C2Color::MATRIX_OTHER)}) |
| .withSetter(ColorAspectsSetter, mDefaultColorAspects, mCodedColorAspects) |
| .build()); |
| |
| // TODO: support more formats? |
| std::vector<uint32_t> pixelFormats = {HAL_PIXEL_FORMAT_YCBCR_420_888}; |
| if (isHalPixelFormatSupported((AHardwareBuffer_Format)HAL_PIXEL_FORMAT_YCBCR_P010)) { |
| pixelFormats.push_back(HAL_PIXEL_FORMAT_YCBCR_P010); |
| } |
| // If color format surface isn't added to supported formats, there is no way to know |
| // when the color-format is configured to surface. This is necessary to be able to |
| // choose 10-bit format while decoding 10-bit clips in surface mode. |
| pixelFormats.push_back(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED); |
| addParameter(DefineParam(mPixelFormat, C2_PARAMKEY_PIXEL_FORMAT) |
| .withDefault(new C2StreamPixelFormatInfo::output( |
| 0u, HAL_PIXEL_FORMAT_YCBCR_420_888)) |
| .withFields({C2F(mPixelFormat, value).oneOf(pixelFormats)}) |
| .withSetter((Setter<decltype(*mPixelFormat)>::StrictValueWithNoDeps)) |
| .build()); |
| } |
| |
| static C2R SizeSetter(bool mayBlock, const C2P<C2StreamPictureSizeInfo::output>& oldMe, |
| C2P<C2StreamPictureSizeInfo::output>& me) { |
| (void)mayBlock; |
| ALOGV("%s - %d x %d", __FUNCTION__, me.v.width, me.v.height); |
| C2R res = C2R::Ok(); |
| if (!me.F(me.v.width).supportsAtAll(me.v.width)) { |
| res = res.plus(C2SettingResultBuilder::BadValue(me.F(me.v.width))); |
| me.set().width = oldMe.v.width; |
| } |
| if (!me.F(me.v.height).supportsAtAll(me.v.height)) { |
| res = res.plus(C2SettingResultBuilder::BadValue(me.F(me.v.height))); |
| me.set().height = oldMe.v.height; |
| } |
| return res; |
| } |
| |
| static C2R MaxPictureSizeSetter(bool mayBlock, C2P<C2StreamMaxPictureSizeTuning::output>& me, |
| const C2P<C2StreamPictureSizeInfo::output>& size) { |
| (void)mayBlock; |
| ALOGV("%s - %d x %d", __FUNCTION__, me.v.width, me.v.height); |
| // TODO: get max width/height from the size's field helpers vs. |
| // hardcoding |
| me.set().width = c2_min(c2_max(me.v.width, size.v.width), 4096u); |
| me.set().height = c2_min(c2_max(me.v.height, size.v.height), 4096u); |
| return C2R::Ok(); |
| } |
| |
| static C2R MaxInputSizeSetter(bool mayBlock, C2P<C2StreamMaxBufferSizeInfo::input>& me, |
| const C2P<C2StreamMaxPictureSizeTuning::output>& maxSize) { |
| (void)mayBlock; |
| ALOGV("%s", __FUNCTION__); |
| // assume compression ratio of 2, but enforce a floor |
| me.set().value = |
| c2_max((((maxSize.v.width + 63) / 64) * ((maxSize.v.height + 63) / 64) * 3072), |
| kMinInputBufferSize); |
| return C2R::Ok(); |
| } |
| |
| static C2R DefaultColorAspectsSetter(bool mayBlock, |
| C2P<C2StreamColorAspectsTuning::output>& me) { |
| (void)mayBlock; |
| ALOGV("%s - range: %u, primary: %u, transfer: %u, matrix: %u", __FUNCTION__, me.v.range, |
| me.v.primaries, me.v.transfer, me.v.matrix); |
| if (me.v.range > C2Color::RANGE_OTHER) { |
| me.set().range = C2Color::RANGE_OTHER; |
| } |
| if (me.v.primaries > C2Color::PRIMARIES_OTHER) { |
| me.set().primaries = C2Color::PRIMARIES_OTHER; |
| } |
| if (me.v.transfer > C2Color::TRANSFER_OTHER) { |
| me.set().transfer = C2Color::TRANSFER_OTHER; |
| } |
| if (me.v.matrix > C2Color::MATRIX_OTHER) { |
| me.set().matrix = C2Color::MATRIX_OTHER; |
| } |
| return C2R::Ok(); |
| } |
| |
| static C2R CodedColorAspectsSetter(bool mayBlock, C2P<C2StreamColorAspectsInfo::input>& me) { |
| (void)mayBlock; |
| ALOGV("%s - range: %u, primaries: %u, transfer: %u, matrix: %u", __func__, me.v.range, |
| me.v.primaries, me.v.transfer, me.v.matrix); |
| if (me.v.range > C2Color::RANGE_OTHER) { |
| me.set().range = C2Color::RANGE_OTHER; |
| } |
| if (me.v.primaries > C2Color::PRIMARIES_OTHER) { |
| me.set().primaries = C2Color::PRIMARIES_OTHER; |
| } |
| if (me.v.transfer > C2Color::TRANSFER_OTHER) { |
| me.set().transfer = C2Color::TRANSFER_OTHER; |
| } |
| if (me.v.matrix > C2Color::MATRIX_OTHER) { |
| me.set().matrix = C2Color::MATRIX_OTHER; |
| } |
| return C2R::Ok(); |
| } |
| |
| static C2R ColorAspectsSetter(bool mayBlock, C2P<C2StreamColorAspectsInfo::output>& me, |
| const C2P<C2StreamColorAspectsTuning::output>& def, |
| const C2P<C2StreamColorAspectsInfo::input>& coded) { |
| (void)mayBlock; |
| ALOGV("%s", __FUNCTION__); |
| // take default values for all unspecified fields, and coded values for specified ones |
| me.set().range = coded.v.range == RANGE_UNSPECIFIED ? def.v.range : coded.v.range; |
| me.set().primaries = |
| coded.v.primaries == PRIMARIES_UNSPECIFIED ? def.v.primaries : coded.v.primaries; |
| me.set().transfer = |
| coded.v.transfer == TRANSFER_UNSPECIFIED ? def.v.transfer : coded.v.transfer; |
| me.set().matrix = coded.v.matrix == MATRIX_UNSPECIFIED ? def.v.matrix : coded.v.matrix; |
| ALOGV("%s - me.v.range = %u, me.v.primaries = %u, me.v.transfer = %u, me.v.matrix = %u", |
| __func__, me.v.range, me.v.primaries, me.v.transfer, me.v.matrix); |
| return C2R::Ok(); |
| } |
| |
| static C2R ProfileLevelSetter(bool mayBlock, C2P<C2StreamProfileLevelInfo::input>& me, |
| const C2P<C2StreamPictureSizeInfo::output>& size) { |
| (void)mayBlock; |
| ALOGV("%s", __FUNCTION__); |
| (void)size; |
| (void)me; // TODO: validate |
| return C2R::Ok(); |
| } |
| |
| std::shared_ptr<C2StreamColorAspectsTuning::output> getDefaultColorAspects_l() { |
| ALOGV("%s - mDefaultColorAspects: %u", __FUNCTION__, mDefaultColorAspects->primaries); |
| return mDefaultColorAspects; |
| } |
| |
| std::shared_ptr<C2StreamColorAspectsInfo::output> getColorAspects_l() { |
| ALOGV("%s - mColorAspects: %u", __FUNCTION__, mColorAspects->primaries); |
| return mColorAspects; |
| } |
| |
| static C2R Hdr10PlusInfoInputSetter(bool mayBlock, C2P<C2StreamHdr10PlusInfo::input>& me) { |
| (void)mayBlock; |
| ALOGV("%s", __FUNCTION__); |
| (void)me; // TODO: validate |
| return C2R::Ok(); |
| } |
| |
| static C2R Hdr10PlusInfoOutputSetter(bool mayBlock, C2P<C2StreamHdr10PlusInfo::output>& me) { |
| (void)mayBlock; |
| ALOGV("%s", __FUNCTION__); |
| (void)me; // TODO: validate |
| return C2R::Ok(); |
| } |
| |
| // unsafe getters |
| std::shared_ptr<C2StreamPixelFormatInfo::output> getPixelFormat_l() const { |
| return mPixelFormat; |
| } |
| |
| static C2R HdrStaticInfoSetter(bool mayBlock, C2P<C2StreamHdrStaticInfo::output>& me) { |
| (void)mayBlock; |
| ALOGV("%s", __FUNCTION__); |
| if (me.v.mastering.red.x > 1) { |
| me.set().mastering.red.x = 1; |
| } |
| if (me.v.mastering.red.y > 1) { |
| me.set().mastering.red.y = 1; |
| } |
| if (me.v.mastering.green.x > 1) { |
| me.set().mastering.green.x = 1; |
| } |
| if (me.v.mastering.green.y > 1) { |
| me.set().mastering.green.y = 1; |
| } |
| if (me.v.mastering.blue.x > 1) { |
| me.set().mastering.blue.x = 1; |
| } |
| if (me.v.mastering.blue.y > 1) { |
| me.set().mastering.blue.y = 1; |
| } |
| if (me.v.mastering.white.x > 1) { |
| me.set().mastering.white.x = 1; |
| } |
| if (me.v.mastering.white.y > 1) { |
| me.set().mastering.white.y = 1; |
| } |
| if (me.v.mastering.maxLuminance > 65535.0) { |
| me.set().mastering.maxLuminance = 65535.0; |
| } |
| if (me.v.mastering.minLuminance > 6.5535) { |
| me.set().mastering.minLuminance = 6.5535; |
| } |
| if (me.v.maxCll > 65535.0) { |
| me.set().maxCll = 65535.0; |
| } |
| if (me.v.maxFall > 65535.0) { |
| me.set().maxFall = 65535.0; |
| } |
| return C2R::Ok(); |
| } |
| |
| private: |
| std::shared_ptr<C2StreamProfileLevelInfo::input> mProfileLevel; |
| std::shared_ptr<C2StreamPictureSizeInfo::output> mSize; |
| std::shared_ptr<C2StreamMaxPictureSizeTuning::output> mMaxSize; |
| std::shared_ptr<C2StreamMaxBufferSizeInfo::input> mMaxInputSize; |
| std::shared_ptr<C2StreamColorInfo::output> mColorInfo; |
| std::shared_ptr<C2StreamPixelFormatInfo::output> mPixelFormat; |
| std::shared_ptr<C2StreamColorAspectsTuning::output> mDefaultColorAspects; |
| std::shared_ptr<C2StreamColorAspectsInfo::input> mCodedColorAspects; |
| std::shared_ptr<C2StreamColorAspectsInfo::output> mColorAspects; |
| std::shared_ptr<C2StreamHdr10PlusInfo::input> mHdr10PlusInfoInput; |
| std::shared_ptr<C2StreamHdr10PlusInfo::output> mHdr10PlusInfoOutput; |
| std::shared_ptr<C2StreamHdrStaticInfo::output> mHdrStaticInfo; |
| }; |
| |
| static void ivd_aligned_free(void* ctxt, void* mem) { |
| (void)ctxt; |
| free(mem); |
| } |
| |
| C2SoftApvDec::C2SoftApvDec(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), |
| mDecHandle(nullptr), |
| mOutBufferFlush(nullptr), |
| mIvColorformat(IV_YUV_420P), |
| mOutputDelay(kDefaultOutputDelay), |
| mWidth(320), |
| mHeight(240), |
| mHeaderDecoded(false), |
| mOutIndex(0u) { |
| oapvdHandle = NULL; |
| oapvmHandle = NULL; |
| outputCsp = OUTPUT_CSP_NATIVE; |
| } |
| |
| C2SoftApvDec::~C2SoftApvDec() { |
| onRelease(); |
| } |
| |
| c2_status_t C2SoftApvDec::onInit() { |
| ALOGV("%s", __FUNCTION__); |
| status_t err = initDecoder(); |
| return err == OK ? C2_OK : C2_CORRUPTED; |
| } |
| |
| c2_status_t C2SoftApvDec::onStop() { |
| ALOGV("%s", __FUNCTION__); |
| if (OK != resetDecoder()) return C2_CORRUPTED; |
| resetPlugin(); |
| return C2_OK; |
| } |
| |
| void C2SoftApvDec::onReset() { |
| ALOGV("%s", __FUNCTION__); |
| (void)onStop(); |
| } |
| |
| status_t C2SoftApvDec::deleteDecoder() { |
| ALOGV("%s", __FUNCTION__); |
| if (oapvdHandle) { |
| oapvd_delete(oapvdHandle); |
| oapvdHandle = NULL; |
| } |
| if (oapvmHandle) { |
| oapvm_delete(oapvmHandle); |
| oapvmHandle = NULL; |
| } |
| for (int i = 0; i < ofrms.num_frms; i++) { |
| if (ofrms.frm[i].imgb != NULL) { |
| ofrms.frm[i].imgb->release(ofrms.frm[i].imgb); |
| ofrms.frm[i].imgb = NULL; |
| } |
| } |
| return OK; |
| } |
| |
| void C2SoftApvDec::onRelease() { |
| ALOGV("%s", __FUNCTION__); |
| (void)deleteDecoder(); |
| if (mOutBufferFlush) { |
| ivd_aligned_free(nullptr, mOutBufferFlush); |
| mOutBufferFlush = nullptr; |
| } |
| if (mOutBlock) { |
| mOutBlock.reset(); |
| } |
| } |
| |
| c2_status_t C2SoftApvDec::onFlush_sm() { |
| ALOGV("%s", __FUNCTION__); |
| mSignalledError = false; |
| mSignalledOutputEos = false; |
| return C2_OK; |
| } |
| |
| status_t C2SoftApvDec::createDecoder() { |
| ALOGV("%s", __FUNCTION__); |
| return OK; |
| } |
| |
| status_t C2SoftApvDec::initDecoder() { |
| int ret; |
| mSignalledError = false; |
| mSignalledOutputEos = false; |
| |
| mHalPixelFormat = HAL_PIXEL_FORMAT_YV12; |
| { |
| IntfImpl::Lock lock = mIntf->lock(); |
| mPixelFormatInfo = mIntf->getPixelFormat_l(); |
| ALOGW("Hal pixel format = %d", mPixelFormatInfo->value); |
| } |
| memset(&cdesc, 0, sizeof(oapvd_cdesc_t)); |
| |
| cdesc.threads = 1; // default |
| oapvdHandle = oapvd_create(&cdesc, &ret); |
| if (oapvdHandle == NULL) { |
| ALOGE("ERROR: cannot create APV decoder (err=%d)\n", ret); |
| return C2_NO_INIT; |
| } |
| |
| memset(&ofrms, 0, sizeof(oapv_frms_t)); |
| |
| oapvmHandle = oapvm_create(&ret); |
| if (OAPV_FAILED(ret)) { |
| ALOGE("oapvm create failed"); |
| oapvd_delete(oapvdHandle); |
| oapvdHandle = NULL; |
| return C2_NO_INIT; |
| } |
| |
| ALOGV("oapvd init done"); |
| return OK; |
| } |
| |
| status_t C2SoftApvDec::setFlushMode() { |
| ALOGV("%s", __FUNCTION__); |
| return OK; |
| } |
| |
| status_t C2SoftApvDec::resetDecoder() { |
| ALOGV("%s", __FUNCTION__); |
| return OK; |
| } |
| |
| void C2SoftApvDec::resetPlugin() { |
| ALOGV("%s", __FUNCTION__); |
| mSignalledOutputEos = false; |
| if (mOutBlock) { |
| mOutBlock.reset(); |
| } |
| } |
| |
| 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 C2SoftApvDec::finishWork(uint64_t index, const std::unique_ptr<C2Work>& work, |
| const std::shared_ptr<C2GraphicBlock>& block) { |
| std::shared_ptr<C2Buffer> buffer = createGraphicBuffer(block, C2Rect(mWidth, mHeight)); |
| |
| { |
| IntfImpl::Lock lock = mIntf->lock(); |
| buffer->setInfo(mIntf->getColorAspects_l()); |
| } |
| |
| class FillWork { |
| public: |
| FillWork(uint32_t flags, C2WorkOrdinalStruct ordinal, |
| const std::shared_ptr<C2Buffer>& buffer) |
| : mFlags(flags), mOrdinal(ordinal), mBuffer(buffer) {} |
| ~FillWork() = default; |
| |
| void operator()(const std::unique_ptr<C2Work>& work) { |
| work->worklets.front()->output.flags = (C2FrameData::flags_t)mFlags; |
| work->worklets.front()->output.buffers.clear(); |
| work->worklets.front()->output.ordinal = mOrdinal; |
| work->workletsProcessed = 1u; |
| work->result = C2_OK; |
| if (mBuffer) { |
| work->worklets.front()->output.buffers.push_back(mBuffer); |
| } |
| ALOGV("timestamp = %lld, index = %lld, w/%s buffer", mOrdinal.timestamp.peekll(), |
| mOrdinal.frameIndex.peekll(), mBuffer ? "" : "o"); |
| } |
| |
| private: |
| const uint32_t mFlags; |
| const C2WorkOrdinalStruct mOrdinal; |
| const std::shared_ptr<C2Buffer> mBuffer; |
| }; |
| |
| auto fillWork = [buffer](const std::unique_ptr<C2Work>& work) { |
| work->worklets.front()->output.flags = (C2FrameData::flags_t)0; |
| 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 && c2_cntr64_t(index) == work->input.ordinal.frameIndex) { |
| bool eos = ((work->input.flags & C2FrameData::FLAG_END_OF_STREAM) != 0); |
| // TODO: Check if cloneAndSend can be avoided by tracking number of frames remaining |
| if (eos) { |
| if (buffer) { |
| mOutIndex = index; |
| C2WorkOrdinalStruct outOrdinal = work->input.ordinal; |
| cloneAndSend(mOutIndex, work, |
| FillWork(C2FrameData::FLAG_INCOMPLETE, outOrdinal, buffer)); |
| buffer.reset(); |
| } |
| } else { |
| fillWork(work); |
| } |
| } else { |
| finish(index, fillWork); |
| } |
| } |
| |
| static void copyBufferFromYUV420ToYV12(uint8_t* dstY, uint8_t* dstU, uint8_t* dstV, |
| const uint8_t* srcY, const uint8_t* srcU, |
| const uint8_t* srcV, size_t srcYStride, size_t srcUStride, |
| size_t srcVStride, size_t dstYStride, size_t dstUStride, |
| size_t dstVStride, uint32_t width, uint32_t height) { |
| for (size_t i = 0; i < height; ++i) { |
| memcpy(dstY, srcY, width); |
| srcY += srcYStride; |
| dstY += dstYStride; |
| } |
| |
| for (size_t i = 0; i < height / 2; ++i) { |
| memcpy(dstU, srcU, width / 2); |
| memcpy(dstV, srcV, width / 2); |
| dstU += dstUStride; |
| srcU += srcUStride; |
| dstV += dstVStride; |
| srcV += srcVStride; |
| } |
| } |
| |
| static void copyBufferFromYUV422ToYV12(uint8_t* dstY, uint8_t* dstU, uint8_t* dstV, |
| const uint8_t* srcY, const uint8_t* srcU, |
| const uint8_t* srcV, size_t srcYStride, size_t srcUStride, |
| size_t srcVStride, size_t dstYStride, size_t dstUStride, |
| size_t dstVStride, uint32_t width, uint32_t height) { |
| for (size_t i = 0; i < height; ++i) { |
| memcpy(dstY, srcY, width); |
| srcY += srcYStride; |
| dstY += dstYStride; |
| } |
| |
| for (size_t i = 0; i < height / 2; ++i) { |
| memcpy(dstU, srcU, width / 2); |
| memcpy(dstV, srcV, width / 2); |
| dstU += dstUStride; |
| srcU += srcUStride * 2; |
| dstV += dstVStride; |
| srcV += srcVStride * 2; |
| } |
| } |
| |
| static void copyBufferFromYUV42010bitToP010(uint16_t* dstY, uint16_t* dstUV, const uint16_t* srcY, |
| const uint16_t* srcU, const uint16_t* srcV, |
| size_t srcYStride, size_t srcUStride, size_t srcVStride, |
| size_t dstYStride, size_t dstUVStride, size_t width, |
| size_t height) { |
| for (size_t y = 0; y < height; ++y) { |
| for (size_t x = 0; x < width; ++x) { |
| dstY[x] = srcY[x] << 6; |
| } |
| srcY += srcYStride; |
| dstY += dstYStride; |
| } |
| |
| for (size_t y = 0; y < height / 2; ++y) { |
| for (size_t x = 0; x < width / 2; ++x) { |
| dstUV[2 * x] = srcU[x] << 6; |
| dstUV[2 * x + 1] = srcV[x] << 6; |
| } |
| srcU += srcUStride; |
| srcV += srcVStride; |
| dstUV += dstUVStride; |
| } |
| } |
| |
| static void copyBufferFromYUV42210bitToP010(uint16_t* dstY, uint16_t* dstUV, const uint16_t* srcY, |
| const uint16_t* srcU, const uint16_t* srcV, |
| size_t srcYStride, size_t srcUStride, size_t srcVStride, |
| size_t dstYStride, size_t dstUVStride, size_t width, |
| size_t height) { |
| for (size_t y = 0; y < height; ++y) { |
| for (size_t x = 0; x < width; ++x) { |
| dstY[x] = srcY[x] << 6; |
| } |
| srcY += srcYStride; |
| dstY += dstYStride; |
| } |
| |
| for (size_t y = 0; y < height / 2; ++y) { |
| for (size_t x = 0; x < width / 2; ++x) { |
| dstUV[2 * x] = srcU[x] << 6; |
| dstUV[2 * x + 1] = srcV[x] << 6; |
| } |
| srcU += srcUStride * 2; |
| srcV += srcVStride * 2; |
| dstUV += dstUVStride; |
| } |
| } |
| |
| static void copyBufferFromP210ToP010(uint16_t* dstY, uint16_t* dstUV, const uint16_t* srcY, |
| const uint16_t* srcUV, size_t srcYStride, size_t srcUVStride, |
| size_t dstYStride, size_t dstUVStride, size_t width, |
| size_t height) { |
| for (size_t y = 0; y < height; ++y) { |
| memcpy(dstY, srcY, width * sizeof(uint16_t)); |
| srcY += srcYStride; |
| dstY += dstYStride; |
| } |
| |
| for (size_t y = 0; y < height / 2; ++y) { |
| memcpy(dstUV, srcUV, width * 2); |
| srcUV += srcUVStride * 2; |
| dstUV += dstUVStride; |
| } |
| } |
| |
| static void copyBufferFromYUV42010bitToYV12(uint8_t* dstY, uint8_t* dstU, uint8_t* dstV, |
| const uint16_t* srcY, const uint16_t* srcU, |
| const uint16_t* srcV, size_t srcYStride, |
| size_t srcUStride, size_t srcVStride, size_t dstYStride, |
| size_t dstUStride, size_t dstVStride, uint32_t width, |
| uint32_t height) { |
| for (size_t i = 0; i < height; ++i) { |
| for (size_t j = 0; j < width; ++j) { |
| dstY[i * dstYStride + j] = (srcY[i * srcYStride + j] >> 2) & 0xFF; |
| } |
| } |
| |
| for (size_t i = 0; i < height / 2; ++i) { |
| for (size_t j = 0; j < width / 2; ++j) { |
| dstU[i * dstUStride + j] = (srcU[i * srcUStride + j] >> 2) & 0xFF; |
| } |
| } |
| |
| for (size_t i = 0; i < height / 2; ++i) { |
| for (size_t j = 0; j < width / 2; ++j) { |
| dstV[i * dstVStride + j] = (srcV[i * srcVStride + j] >> 2) & 0xFF; |
| } |
| } |
| } |
| |
| static void copyBufferFromYUV42210bitToYV12(uint8_t* dstY, uint8_t* dstU, uint8_t* dstV, |
| const uint16_t* srcY, const uint16_t* srcU, |
| const uint16_t* srcV, size_t srcYStride, |
| size_t srcUStride, size_t srcVStride, size_t dstYStride, |
| size_t dstUStride, size_t dstVStride, uint32_t width, |
| uint32_t height) { |
| for (size_t i = 0; i < height; ++i) { |
| for (size_t j = 0; j < width; ++j) { |
| dstY[i * dstYStride + j] = (srcY[i * srcYStride + j] >> 2) & 0xFF; |
| } |
| } |
| |
| for (size_t i = 0; i < height / 2; ++i) { |
| for (size_t j = 0; j < width / 2; ++j) { |
| dstU[i * dstUStride + j] = (srcU[i * srcUStride * 2 + j] >> 2) & 0xFF; |
| } |
| } |
| |
| for (size_t i = 0; i < height / 2; ++i) { |
| for (size_t j = 0; j < width / 2; ++j) { |
| dstV[i * dstVStride + j] = (srcV[i * srcVStride * 2 + j] >> 2) & 0xFF; |
| } |
| } |
| } |
| |
| static void copyBufferFromP210ToYV12(uint8_t* dstY, uint8_t* dstU, uint8_t* dstV, |
| const uint16_t* srcY, const uint16_t* srcUV, size_t srcYStride, |
| size_t srcUVStride, size_t dstYStride, size_t dstUStride, |
| size_t dstVStride, size_t width, size_t height) { |
| for (size_t i = 0; i < height; ++i) { |
| for (size_t j = 0; j < width; ++j) { |
| dstY[i * dstYStride + j] = (srcY[i * srcYStride + j] >> 8) & 0xFF; |
| } |
| } |
| |
| for (size_t i = 0; i < height / 2; ++i) { |
| for (size_t j = 0; j < width / 2; ++j) { |
| dstV[i * dstVStride + j] = (srcUV[i * srcUVStride * 2 + j * 2] >> 8) & 0xFF; |
| dstU[i * dstUStride + j] = (srcUV[i * srcUVStride * 2 + j * 2 + 1] >> 8) & 0xFF; |
| } |
| } |
| } |
| |
| void C2SoftApvDec::process(const std::unique_ptr<C2Work>& work, |
| const std::shared_ptr<C2BlockPool>& pool) { |
| // Initialize output work |
| work->result = C2_OK; |
| work->workletsProcessed = 0u; |
| work->worklets.front()->output.configUpdate.clear(); |
| work->worklets.front()->output.flags = work->input.flags; |
| if (mSignalledError || mSignalledOutputEos) { |
| work->result = C2_BAD_VALUE; |
| return; |
| } |
| |
| int ret = 0; |
| size_t inOffset = 0u; |
| size_t inSize = 0u; |
| C2ReadView rView = mDummyReadView; |
| if (!work->input.buffers.empty()) { |
| rView = work->input.buffers[0]->data().linearBlocks().front().map().get(); |
| inSize = rView.capacity(); |
| if (inSize && rView.error()) { |
| ALOGE("read view map failed %d", rView.error()); |
| work->result = C2_CORRUPTED; |
| return; |
| } |
| } |
| |
| bool codecConfig = ((work->input.flags & C2FrameData::FLAG_CODEC_CONFIG) != 0); |
| bool eos = ((work->input.flags & C2FrameData::FLAG_END_OF_STREAM) != 0); |
| |
| ALOGV("in buffer attr. size %zu timestamp %llu frameindex %d, flags %x", inSize, |
| work->input.ordinal.timestamp.peekull(), (int)work->input.ordinal.frameIndex.peeku(), |
| work->input.flags); |
| |
| if (codecConfig) { |
| fillEmptyWork(work); |
| return; |
| } |
| |
| if (inSize > 0) { |
| uint8_t* bitstream = const_cast<uint8_t*>(rView.data() + inOffset); |
| oapv_au_info_t aui; |
| oapv_bitb_t bitb; |
| bitb.addr = bitstream + 4; // skip au |
| bitb.ssize = inSize - 4; |
| |
| if (OAPV_FAILED(oapvd_info(bitb.addr, bitb.ssize, &aui))) { |
| ALOGE("cannot get information from bitstream"); |
| return; |
| } |
| |
| /* create decoding frame buffers */ |
| ofrms.num_frms = aui.num_frms; |
| if (ofrms.num_frms <= 0) { |
| ALOGE("Parse error - no output frame(%d)", ofrms.num_frms); |
| fillEmptyWork(work); |
| return; |
| } |
| for (int i = 0; i < ofrms.num_frms; i++) { |
| oapv_frm_info_t* finfo = &aui.frm_info[FRM_IDX]; |
| oapv_frm_t* frm = &ofrms.frm[i]; |
| |
| if (mWidth != finfo->w || mHeight != finfo->w) { |
| mWidth = finfo->w; |
| mHeight = finfo->h; |
| } |
| |
| if (frm->imgb != NULL && (frm->imgb->w[0] != finfo->w || frm->imgb->h[0] != finfo->h)) { |
| frm->imgb->release(frm->imgb); |
| frm->imgb = NULL; |
| } |
| |
| if (frm->imgb == NULL) { |
| if (outputCsp == OUTPUT_CSP_P210) { |
| frm->imgb = imgb_create(finfo->w, finfo->h, OAPV_CS_P210); |
| } else { |
| frm->imgb = imgb_create(finfo->w, finfo->h, finfo->cs); |
| } |
| if (frm->imgb == NULL) { |
| ALOGE("cannot allocate image buffer (w:%d, h:%d, cs:%d)", finfo->w, finfo->h, |
| finfo->cs); |
| fillEmptyWork(work); |
| return; |
| } |
| } |
| } |
| |
| oapvd_stat_t stat; |
| ret = oapvd_decode(oapvdHandle, &bitb, &ofrms, oapvmHandle, &stat); |
| if (bitb.ssize != stat.read) { |
| ALOGW("decode done, input size: %d, processed size: %d", bitb.ssize, stat.read); |
| } |
| |
| if (OAPV_FAILED(ret)) { |
| ALOGE("failed to decode bitstream\n"); |
| fillEmptyWork(work); |
| return; |
| } |
| |
| status_t err = outputBuffer(pool, work); |
| if (err == NOT_ENOUGH_DATA) { |
| if (inSize > 0) { |
| ALOGV("Maybe non-display frame at %lld.", work->input.ordinal.frameIndex.peekll()); |
| // send the work back with empty buffer. |
| inSize = 0; |
| } |
| } else if (err != OK) { |
| ALOGD("Error while getting the output frame out"); |
| // work->result would be already filled; do fillEmptyWork() below to |
| // send the work back. |
| inSize = 0; |
| } |
| } |
| |
| if (eos) { |
| drainInternal(DRAIN_COMPONENT_WITH_EOS, pool, work); |
| mSignalledOutputEos = true; |
| } else if (!inSize) { |
| fillEmptyWork(work); |
| } |
| } |
| |
| status_t C2SoftApvDec::outputBuffer(const std::shared_ptr<C2BlockPool>& pool, |
| const std::unique_ptr<C2Work>& work) { |
| if (!(work && pool)) return BAD_VALUE; |
| |
| oapv_imgb_t* imgbOutput; |
| std::shared_ptr<C2GraphicBlock> block; |
| |
| if (ofrms.num_frms > 0) { |
| oapv_frm_t* frm = &ofrms.frm[0]; |
| imgbOutput = frm->imgb; |
| } else { |
| ALOGW("No output frames"); |
| return false; |
| } |
| bool isMonochrome = OAPV_CS_GET_FORMAT(imgbOutput->cs) == OAPV_CS_YCBCR400; |
| |
| uint32_t format = HAL_PIXEL_FORMAT_YV12; |
| std::shared_ptr<C2StreamColorAspectsInfo::output> codedColorAspects; |
| if (OAPV_CS_GET_BIT_DEPTH(imgbOutput->cs) == 10 && |
| mPixelFormatInfo->value != HAL_PIXEL_FORMAT_YCBCR_420_888) { |
| IntfImpl::Lock lock = mIntf->lock(); |
| codedColorAspects = mIntf->getColorAspects_l(); |
| bool allowRGBA1010102 = false; |
| if (codedColorAspects->primaries == C2Color::PRIMARIES_BT2020 && |
| codedColorAspects->matrix == C2Color::MATRIX_BT2020 && |
| codedColorAspects->transfer == C2Color::TRANSFER_ST2084) { |
| allowRGBA1010102 = true; |
| } |
| format = getHalPixelFormatForBitDepth10(allowRGBA1010102); |
| } |
| |
| if (mHalPixelFormat != format) { |
| C2StreamPixelFormatInfo::output pixelFormat(0u, format); |
| std::vector<std::unique_ptr<C2SettingResult>> failures; |
| c2_status_t err = mIntf->config({&pixelFormat}, C2_MAY_BLOCK, &failures); |
| if (err == C2_OK) { |
| work->worklets.front()->output.configUpdate.push_back(C2Param::Copy(pixelFormat)); |
| } else { |
| ALOGE("Config update pixelFormat failed"); |
| mSignalledError = true; |
| work->workletsProcessed = 1u; |
| work->result = C2_CORRUPTED; |
| return UNKNOWN_ERROR; |
| } |
| mHalPixelFormat = format; |
| } |
| ALOGV("mHalPixelFormat: %u, format: %d", mHalPixelFormat, format); |
| |
| C2MemoryUsage usage = {C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE}; |
| |
| // check. align height to 2 times does not work. |
| c2_status_t err = |
| pool->fetchGraphicBlock(align(mWidth, 16), align(mHeight, 16), format, usage, &block); |
| |
| if (err != C2_OK) { |
| ALOGE("fetchGraphicBlock for Output failed with status %d", err); |
| work->result = err; |
| return false; |
| } |
| |
| C2GraphicView wView = block->map().get(); |
| if (wView.error()) { |
| ALOGE("graphic view map failed %d", wView.error()); |
| work->result = C2_CORRUPTED; |
| return false; |
| } |
| |
| ALOGV("provided (%dx%d) required (%dx%d)", block->width(), block->height(), mWidth, mHeight); |
| |
| uint8_t* dstY = const_cast<uint8_t*>(wView.data()[C2PlanarLayout::PLANE_Y]); |
| uint8_t* dstU = const_cast<uint8_t*>(wView.data()[C2PlanarLayout::PLANE_U]); |
| uint8_t* dstV = const_cast<uint8_t*>(wView.data()[C2PlanarLayout::PLANE_V]); |
| |
| C2PlanarLayout layout = wView.layout(); |
| size_t dstYStride = layout.planes[C2PlanarLayout::PLANE_Y].rowInc; |
| size_t dstUStride = layout.planes[C2PlanarLayout::PLANE_U].rowInc; |
| size_t dstVStride = layout.planes[C2PlanarLayout::PLANE_V].rowInc; |
| |
| if (format == HAL_PIXEL_FORMAT_YCBCR_P010) { |
| if (OAPV_CS_GET_BIT_DEPTH(imgbOutput->cs) == 10) { |
| const uint16_t* srcY = (const uint16_t*)imgbOutput->a[0]; |
| const uint16_t* srcU = (const uint16_t*)imgbOutput->a[1]; |
| const uint16_t* srcV = (const uint16_t*)imgbOutput->a[2]; |
| size_t srcYStride = imgbOutput->s[0] / 2; |
| size_t srcUStride = imgbOutput->s[1] / 2; |
| size_t srcVStride = imgbOutput->s[2] / 2; |
| dstYStride /= 2; |
| dstUStride /= 2; |
| dstVStride /= 2; |
| if (OAPV_CS_GET_FORMAT(imgbOutput->cs) == OAPV_CF_YCBCR420) { |
| ALOGV("OAPV_CS_YUV420 10bit to P010"); |
| copyBufferFromYUV42010bitToP010((uint16_t*)dstY, (uint16_t*)dstU, srcY, srcU, srcV, |
| srcYStride, srcUStride, srcVStride, dstYStride, |
| dstUStride, mWidth, mHeight); |
| } else if (OAPV_CS_GET_FORMAT(imgbOutput->cs) == OAPV_CF_YCBCR422) { |
| ALOGV("OAPV_CS_YUV422 10bit to P010"); |
| copyBufferFromYUV42210bitToP010((uint16_t*)dstY, (uint16_t*)dstU, srcY, srcU, srcV, |
| srcYStride, srcUStride, srcVStride, dstYStride, |
| dstUStride, mWidth, mHeight); |
| } else if (OAPV_CS_GET_FORMAT(imgbOutput->cs) == OAPV_CF_PLANAR2) { |
| ALOGV("OAPV_CS_P210 to P010"); |
| copyBufferFromP210ToP010((uint16_t*)dstY, (uint16_t*)dstU, srcY, srcU, srcYStride, |
| srcUStride, dstYStride, dstUStride, mWidth, mHeight); |
| } else { |
| ALOGE("Not supported convert format : %d", OAPV_CS_GET_FORMAT(imgbOutput->cs)); |
| } |
| } else { |
| ALOGE("Not supported convder from bd:%d, format: %d(%s), to format: %d(%s)", |
| OAPV_CS_GET_BIT_DEPTH(imgbOutput->cs), OAPV_CS_GET_FORMAT(imgbOutput->cs), |
| OAPV_CS_GET_FORMAT(imgbOutput->cs) == OAPV_CF_YCBCR420 |
| ? "YUV420" |
| : (OAPV_CS_GET_FORMAT(imgbOutput->cs) == OAPV_CF_YCBCR422 ? "YUV422" |
| : "UNKNOWN"), |
| format, |
| format == HAL_PIXEL_FORMAT_YCBCR_P010 |
| ? "P010" |
| : (format == HAL_PIXEL_FORMAT_YCBCR_420_888 |
| ? "YUV420" |
| : (format == HAL_PIXEL_FORMAT_YV12 ? "YV12" : "UNKNOWN"))); |
| } |
| } else { // HAL_PIXEL_FORMAT_YV12 |
| if (OAPV_CS_GET_BIT_DEPTH(imgbOutput->cs) == 10) { |
| const uint16_t* srcY = (const uint16_t*)imgbOutput->a[0]; |
| const uint16_t* srcV = (const uint16_t*)imgbOutput->a[1]; |
| const uint16_t* srcU = (const uint16_t*)imgbOutput->a[2]; |
| size_t srcYStride = imgbOutput->s[0] / 2; |
| size_t srcVStride = imgbOutput->s[1] / 2; |
| size_t srcUStride = imgbOutput->s[2] / 2; |
| if (OAPV_CS_GET_FORMAT(imgbOutput->cs) == OAPV_CF_YCBCR420) { |
| ALOGV("OAPV_CS_YUV420 10bit to YV12"); |
| copyBufferFromYUV42010bitToYV12(dstY, dstU, dstV, srcY, srcU, srcV, srcYStride, |
| srcUStride, srcVStride, dstYStride, dstUStride, |
| dstVStride, mWidth, mHeight); |
| } else if (OAPV_CS_GET_FORMAT(imgbOutput->cs) == OAPV_CF_YCBCR422) { |
| ALOGV("OAPV_CS_YUV422 10bit to YV12"); |
| copyBufferFromYUV42210bitToYV12(dstY, dstU, dstV, srcY, srcU, srcV, srcYStride, |
| srcUStride, srcVStride, dstYStride, dstUStride, |
| dstVStride, mWidth, mHeight); |
| } else if (OAPV_CS_GET_FORMAT(imgbOutput->cs) == OAPV_CF_PLANAR2) { |
| ALOGV("OAPV_CS_P210 to YV12"); |
| copyBufferFromP210ToYV12(dstY, dstU, dstV, srcY, srcV, srcYStride, srcVStride, |
| dstYStride, dstUStride, dstVStride, mWidth, mHeight); |
| } else { |
| ALOGE("Not supported convert format : %d", OAPV_CS_GET_FORMAT(imgbOutput->cs)); |
| } |
| } else if (OAPV_CS_GET_BIT_DEPTH(imgbOutput->cs) == 8) { |
| const uint8_t* srcY = (const uint8_t*)imgbOutput->a[0]; |
| const uint8_t* srcV = (const uint8_t*)imgbOutput->a[1]; |
| const uint8_t* srcU = (const uint8_t*)imgbOutput->a[2]; |
| size_t srcYStride = imgbOutput->s[0]; |
| size_t srcVStride = imgbOutput->s[1]; |
| size_t srcUStride = imgbOutput->s[2]; |
| if (OAPV_CS_GET_FORMAT(imgbOutput->cs) == OAPV_CF_YCBCR420) { |
| ALOGV("OAPV_CS_YUV420 to YV12"); |
| copyBufferFromYUV420ToYV12(dstY, dstU, dstV, srcY, srcU, srcV, srcYStride, |
| srcUStride, srcVStride, dstYStride, dstUStride, |
| dstVStride, mWidth, mHeight); |
| } else if (OAPV_CS_GET_FORMAT(imgbOutput->cs) == OAPV_CF_YCBCR422) { |
| ALOGV("OAPV_CS_YUV422 to YV12"); |
| copyBufferFromYUV422ToYV12(dstY, dstU, dstV, srcY, srcU, srcV, srcYStride, |
| srcUStride, srcVStride, dstYStride, dstUStride, |
| dstVStride, mWidth, mHeight); |
| } else { |
| ALOGE("Not supported convert format : %d", OAPV_CS_GET_FORMAT(imgbOutput->cs)); |
| } |
| } else { |
| ALOGE("Not supported convert from bd:%d, format: %d(%s), to format: %d(%s)", |
| OAPV_CS_GET_BIT_DEPTH(imgbOutput->cs), OAPV_CS_GET_FORMAT(imgbOutput->cs), |
| OAPV_CS_GET_FORMAT(imgbOutput->cs) == OAPV_CF_YCBCR420 |
| ? "YUV420" |
| : (OAPV_CS_GET_FORMAT(imgbOutput->cs) == OAPV_CF_YCBCR422 ? "YUV422" |
| : "UNKNOWN"), |
| format, |
| format == HAL_PIXEL_FORMAT_YCBCR_P010 |
| ? "P010" |
| : (format == HAL_PIXEL_FORMAT_YCBCR_420_888 |
| ? "YUV420" |
| : (format == HAL_PIXEL_FORMAT_YV12 ? "YV12" : "UNKNOWN"))); |
| } |
| } |
| |
| finishWork(work->input.ordinal.frameIndex.peekll(), work, std::move(block)); |
| return OK; |
| } |
| |
| c2_status_t C2SoftApvDec::drainInternal(uint32_t drainMode, |
| const std::shared_ptr<C2BlockPool>& pool, |
| const std::unique_ptr<C2Work>& work) { |
| 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; |
| } |
| |
| if (drainMode == DRAIN_COMPONENT_WITH_EOS && work && work->workletsProcessed == 0u) { |
| fillEmptyWork(work); |
| } |
| return C2_OK; |
| } |
| |
| c2_status_t C2SoftApvDec::drain(uint32_t drainMode, const std::shared_ptr<C2BlockPool>& pool) { |
| return drainInternal(drainMode, pool, nullptr); |
| } |
| |
| class C2SoftApvDecFactory : public C2ComponentFactory { |
| public: |
| C2SoftApvDecFactory() |
| : 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 C2SoftApvDec(COMPONENT_NAME, id, |
| std::make_shared<C2SoftApvDec::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<C2SoftApvDec::IntfImpl>( |
| COMPONENT_NAME, id, std::make_shared<C2SoftApvDec::IntfImpl>(mHelper)), |
| deleter); |
| return C2_OK; |
| } |
| |
| virtual ~C2SoftApvDecFactory() override = default; |
| |
| private: |
| std::shared_ptr<C2ReflectorHelper> mHelper; |
| }; |
| |
| } // namespace android |
| |
| __attribute__((cfi_canonical_jump_table)) extern "C" ::C2ComponentFactory* CreateCodec2Factory() { |
| return new ::android::C2SoftApvDecFactory(); |
| } |
| |
| __attribute__((cfi_canonical_jump_table)) extern "C" void DestroyCodec2Factory( |
| ::C2ComponentFactory* factory) { |
| delete factory; |
| } |