/* * 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 "C2SoftMpeg2Dec" #include #include #include #include #include #include #include "C2SoftMpeg2Dec.h" #include "impeg2d.h" namespace android { constexpr char COMPONENT_NAME[] = "c2.android.mpeg2.decoder"; class C2SoftMpeg2Dec::IntfImpl : public SimpleInterface::BaseParams { public: explicit IntfImpl(const std::shared_ptr &helper) : SimpleInterface::BaseParams( helper, COMPONENT_NAME, C2Component::KIND_DECODER, C2Component::DOMAIN_VIDEO, MEDIA_MIMETYPE_VIDEO_MPEG2) { noPrivateBuffers(); // TODO: account for our buffers here noInputReferences(); noOutputReferences(); noInputLatency(); noTimeStretch(); // TODO: output latency and reordering 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(16, 1920, 4), C2F(mSize, height).inRange(16, 1088, 4), }) .withSetter(SizeSetter) .build()); addParameter( DefineParam(mProfileLevel, C2_PARAMKEY_PROFILE_LEVEL) .withDefault(new C2StreamProfileLevelInfo::input(0u, C2Config::PROFILE_MP2V_SIMPLE, C2Config::LEVEL_MP2V_HIGH)) .withFields({ C2F(mProfileLevel, profile).oneOf({ C2Config::PROFILE_MP2V_SIMPLE, C2Config::PROFILE_MP2V_MAIN}), C2F(mProfileLevel, level).oneOf({ C2Config::LEVEL_MP2V_LOW, C2Config::LEVEL_MP2V_MAIN, C2Config::LEVEL_MP2V_HIGH_1440, C2Config::LEVEL_MP2V_HIGH}) }) .withSetter(ProfileLevelSetter, mSize) .build()); addParameter( DefineParam(mMaxSize, C2_PARAMKEY_MAX_PICTURE_SIZE) .withDefault(new C2StreamMaxPictureSizeTuning::output(0u, 320, 240)) .withFields({ C2F(mSize, width).inRange(2, 1920, 2), C2F(mSize, height).inRange(2, 1088, 2), }) .withSetter(MaxPictureSizeSetter, mSize) .build()); addParameter( DefineParam(mMaxInputSize, C2_PARAMKEY_INPUT_MAX_BUFFER_SIZE) .withDefault(new C2StreamMaxBufferSizeInfo::input(0u, 320 * 240 * 3 / 2)) .withFields({ C2F(mMaxInputSize, value).any(), }) .calculatedAs(MaxInputSizeSetter, mMaxSize) .build()); C2ChromaOffsetStruct locations[1] = { C2ChromaOffsetStruct::ITU_YUV_420_0() }; std::shared_ptr 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(); 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? addParameter( DefineParam(mPixelFormat, C2_PARAMKEY_PIXEL_FORMAT) .withConstValue(new C2StreamPixelFormatInfo::output( 0u, HAL_PIXEL_FORMAT_YCBCR_420_888)) .build()); } static C2R SizeSetter(bool mayBlock, const C2P &oldMe, C2P &me) { (void)mayBlock; 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 &me, const C2P &size) { (void)mayBlock; // 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), 1920u); me.set().height = c2_min(c2_max(me.v.height, size.v.height), 1088u); return C2R::Ok(); } static C2R MaxInputSizeSetter(bool mayBlock, C2P &me, const C2P &maxSize) { (void)mayBlock; // assume compression ratio of 1 me.set().value = (((maxSize.v.width + 15) / 16) * ((maxSize.v.height + 15) / 16) * 384); return C2R::Ok(); } static C2R ProfileLevelSetter(bool mayBlock, C2P &me, const C2P &size) { (void)mayBlock; (void)size; (void)me; // TODO: validate return C2R::Ok(); } static C2R DefaultColorAspectsSetter(bool mayBlock, C2P &me) { (void)mayBlock; 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 &me) { (void)mayBlock; 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 &me, const C2P &def, const C2P &coded) { (void)mayBlock; // 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; return C2R::Ok(); } std::shared_ptr getColorAspects_l() { return mColorAspects; } private: std::shared_ptr mProfileLevel; std::shared_ptr mSize; std::shared_ptr mMaxSize; std::shared_ptr mMaxInputSize; std::shared_ptr mColorInfo; std::shared_ptr mCodedColorAspects; std::shared_ptr mDefaultColorAspects; std::shared_ptr mColorAspects; std::shared_ptr mPixelFormat; }; static size_t getCpuCoreCount() { long cpuCoreCount = 1; #if defined(_SC_NPROCESSORS_ONLN) cpuCoreCount = sysconf(_SC_NPROCESSORS_ONLN); #else // _SC_NPROC_ONLN must be defined... cpuCoreCount = sysconf(_SC_NPROC_ONLN); #endif CHECK(cpuCoreCount >= 1); ALOGV("Number of CPU cores: %ld", cpuCoreCount); return (size_t)cpuCoreCount; } static void *ivd_aligned_malloc(WORD32 alignment, WORD32 size) { return memalign(alignment, size); } static void ivd_aligned_free(void *mem) { free(mem); } C2SoftMpeg2Dec::C2SoftMpeg2Dec( const char *name, c2_node_id_t id, const std::shared_ptr &intfImpl) : SimpleC2Component(std::make_shared>(name, id, intfImpl)), mIntf(intfImpl), mDecHandle(nullptr), mMemRecords(nullptr), mOutBufferDrain(nullptr), mIvColorformat(IV_YUV_420P), mWidth(320), mHeight(240), mOutIndex(0u) { // If input dump is enabled, then open create an empty file GENERATE_FILE_NAMES(); CREATE_DUMP_FILE(mInFile); } C2SoftMpeg2Dec::~C2SoftMpeg2Dec() { onRelease(); } c2_status_t C2SoftMpeg2Dec::onInit() { status_t err = initDecoder(); return err == OK ? C2_OK : C2_CORRUPTED; } c2_status_t C2SoftMpeg2Dec::onStop() { if (OK != resetDecoder()) return C2_CORRUPTED; resetPlugin(); return C2_OK; } void C2SoftMpeg2Dec::onReset() { (void) onStop(); } void C2SoftMpeg2Dec::onRelease() { (void) deleteDecoder(); if (mOutBufferDrain) { ivd_aligned_free(mOutBufferDrain); mOutBufferDrain = nullptr; } if (mOutBlock) { mOutBlock.reset(); } if (mMemRecords) { ivd_aligned_free(mMemRecords); mMemRecords = nullptr; } } c2_status_t C2SoftMpeg2Dec::onFlush_sm() { if (OK != setFlushMode()) return C2_CORRUPTED; uint32_t displayStride = mStride; uint32_t displayHeight = mHeight; uint32_t bufferSize = displayStride * displayHeight * 3 / 2; mOutBufferDrain = (uint8_t *)ivd_aligned_malloc(128, bufferSize); if (!mOutBufferDrain) { ALOGE("could not allocate tmp output buffer (for flush) of size %u ", bufferSize); return C2_NO_MEMORY; } while (true) { ivd_video_decode_ip_t s_decode_ip; ivd_video_decode_op_t s_decode_op; setDecodeArgs(&s_decode_ip, &s_decode_op, nullptr, nullptr, 0, 0, 0); (void) ivdec_api_function(mDecHandle, &s_decode_ip, &s_decode_op); if (0 == s_decode_op.u4_output_present) { resetPlugin(); break; } } if (mOutBufferDrain) { ivd_aligned_free(mOutBufferDrain); mOutBufferDrain = nullptr; } return C2_OK; } status_t C2SoftMpeg2Dec::getNumMemRecords() { iv_num_mem_rec_ip_t s_num_mem_rec_ip; iv_num_mem_rec_op_t s_num_mem_rec_op; s_num_mem_rec_ip.u4_size = sizeof(s_num_mem_rec_ip); s_num_mem_rec_ip.e_cmd = IV_CMD_GET_NUM_MEM_REC; s_num_mem_rec_op.u4_size = sizeof(s_num_mem_rec_op); IV_API_CALL_STATUS_T status = ivdec_api_function(mDecHandle, &s_num_mem_rec_ip, &s_num_mem_rec_op); if (IV_SUCCESS != status) { ALOGE("Error in getting mem records: 0x%x", s_num_mem_rec_op.u4_error_code); return UNKNOWN_ERROR; } mNumMemRecords = s_num_mem_rec_op.u4_num_mem_rec; return OK; } status_t C2SoftMpeg2Dec::fillMemRecords() { iv_mem_rec_t *ps_mem_rec = (iv_mem_rec_t *) ivd_aligned_malloc( 128, mNumMemRecords * sizeof(iv_mem_rec_t)); if (!ps_mem_rec) { ALOGE("Allocation failure"); return NO_MEMORY; } memset(ps_mem_rec, 0, mNumMemRecords * sizeof(iv_mem_rec_t)); for (size_t i = 0; i < mNumMemRecords; i++) ps_mem_rec[i].u4_size = sizeof(iv_mem_rec_t); mMemRecords = ps_mem_rec; ivdext_fill_mem_rec_ip_t s_fill_mem_ip; ivdext_fill_mem_rec_op_t s_fill_mem_op; s_fill_mem_ip.s_ivd_fill_mem_rec_ip_t.u4_size = sizeof(ivdext_fill_mem_rec_ip_t); s_fill_mem_ip.u4_share_disp_buf = 0; s_fill_mem_ip.e_output_format = mIvColorformat; s_fill_mem_ip.u4_deinterlace = 1; s_fill_mem_ip.s_ivd_fill_mem_rec_ip_t.e_cmd = IV_CMD_FILL_NUM_MEM_REC; s_fill_mem_ip.s_ivd_fill_mem_rec_ip_t.pv_mem_rec_location = mMemRecords; s_fill_mem_ip.s_ivd_fill_mem_rec_ip_t.u4_max_frm_wd = mWidth; s_fill_mem_ip.s_ivd_fill_mem_rec_ip_t.u4_max_frm_ht = mHeight; s_fill_mem_op.s_ivd_fill_mem_rec_op_t.u4_size = sizeof(ivdext_fill_mem_rec_op_t); IV_API_CALL_STATUS_T status = ivdec_api_function(mDecHandle, &s_fill_mem_ip, &s_fill_mem_op); if (IV_SUCCESS != status) { ALOGE("Error in filling mem records: 0x%x", s_fill_mem_op.s_ivd_fill_mem_rec_op_t.u4_error_code); return UNKNOWN_ERROR; } CHECK_EQ(mNumMemRecords, s_fill_mem_op.s_ivd_fill_mem_rec_op_t.u4_num_mem_rec_filled); for (size_t i = 0; i < mNumMemRecords; i++, ps_mem_rec++) { ps_mem_rec->pv_base = ivd_aligned_malloc( ps_mem_rec->u4_mem_alignment, ps_mem_rec->u4_mem_size); if (!ps_mem_rec->pv_base) { ALOGE("Allocation failure for memory record #%zu of size %u", i, ps_mem_rec->u4_mem_size); return NO_MEMORY; } } return OK; } status_t C2SoftMpeg2Dec::createDecoder() { ivdext_init_ip_t s_init_ip; ivdext_init_op_t s_init_op; s_init_ip.s_ivd_init_ip_t.u4_size = sizeof(ivdext_init_ip_t); s_init_ip.s_ivd_init_ip_t.e_cmd = (IVD_API_COMMAND_TYPE_T)IV_CMD_INIT; s_init_ip.s_ivd_init_ip_t.pv_mem_rec_location = mMemRecords; s_init_ip.s_ivd_init_ip_t.u4_frm_max_wd = mWidth; s_init_ip.s_ivd_init_ip_t.u4_frm_max_ht = mHeight; s_init_ip.u4_share_disp_buf = 0; s_init_ip.u4_deinterlace = 1; s_init_ip.s_ivd_init_ip_t.u4_num_mem_rec = mNumMemRecords; s_init_ip.s_ivd_init_ip_t.e_output_format = mIvColorformat; s_init_op.s_ivd_init_op_t.u4_size = sizeof(ivdext_init_op_t); mDecHandle = (iv_obj_t *)mMemRecords[0].pv_base; mDecHandle->pv_fxns = (void *)ivdec_api_function; mDecHandle->u4_size = sizeof(iv_obj_t); IV_API_CALL_STATUS_T status = ivdec_api_function(mDecHandle, &s_init_ip, &s_init_op); if (status != IV_SUCCESS) { ALOGE("error in %s: 0x%x", __func__, s_init_op.s_ivd_init_op_t.u4_error_code); return UNKNOWN_ERROR; } return OK; } status_t C2SoftMpeg2Dec::setNumCores() { ivdext_ctl_set_num_cores_ip_t s_set_num_cores_ip; ivdext_ctl_set_num_cores_op_t s_set_num_cores_op; s_set_num_cores_ip.u4_size = sizeof(ivdext_ctl_set_num_cores_ip_t); s_set_num_cores_ip.e_cmd = IVD_CMD_VIDEO_CTL; s_set_num_cores_ip.e_sub_cmd = IVDEXT_CMD_CTL_SET_NUM_CORES; s_set_num_cores_ip.u4_num_cores = mNumCores; s_set_num_cores_op.u4_size = sizeof(ivdext_ctl_set_num_cores_op_t); IV_API_CALL_STATUS_T status = ivdec_api_function(mDecHandle, &s_set_num_cores_ip, &s_set_num_cores_op); if (status != IV_SUCCESS) { ALOGD("error in %s: 0x%x", __func__, s_set_num_cores_op.u4_error_code); return UNKNOWN_ERROR; } return OK; } status_t C2SoftMpeg2Dec::setParams(size_t stride) { ivd_ctl_set_config_ip_t s_set_dyn_params_ip; ivd_ctl_set_config_op_t s_set_dyn_params_op; s_set_dyn_params_ip.u4_size = sizeof(ivd_ctl_set_config_ip_t); s_set_dyn_params_ip.e_cmd = IVD_CMD_VIDEO_CTL; s_set_dyn_params_ip.e_sub_cmd = IVD_CMD_CTL_SETPARAMS; s_set_dyn_params_ip.u4_disp_wd = (UWORD32) stride; s_set_dyn_params_ip.e_frm_skip_mode = IVD_SKIP_NONE; s_set_dyn_params_ip.e_frm_out_mode = IVD_DISPLAY_FRAME_OUT; s_set_dyn_params_ip.e_vid_dec_mode = IVD_DECODE_FRAME; s_set_dyn_params_op.u4_size = sizeof(ivd_ctl_set_config_op_t); IV_API_CALL_STATUS_T status = ivdec_api_function(mDecHandle, &s_set_dyn_params_ip, &s_set_dyn_params_op); if (status != IV_SUCCESS) { ALOGE("error in %s: 0x%x", __func__, s_set_dyn_params_op.u4_error_code); return UNKNOWN_ERROR; } return OK; } status_t C2SoftMpeg2Dec::getVersion() { ivd_ctl_getversioninfo_ip_t s_get_versioninfo_ip; ivd_ctl_getversioninfo_op_t s_get_versioninfo_op; UWORD8 au1_buf[512]; s_get_versioninfo_ip.u4_size = sizeof(ivd_ctl_getversioninfo_ip_t); s_get_versioninfo_ip.e_cmd = IVD_CMD_VIDEO_CTL; s_get_versioninfo_ip.e_sub_cmd = IVD_CMD_CTL_GETVERSION; s_get_versioninfo_ip.pv_version_buffer = au1_buf; s_get_versioninfo_ip.u4_version_buffer_size = sizeof(au1_buf); s_get_versioninfo_op.u4_size = sizeof(ivd_ctl_getversioninfo_op_t); IV_API_CALL_STATUS_T status = ivdec_api_function(mDecHandle, &s_get_versioninfo_ip, &s_get_versioninfo_op); if (status != IV_SUCCESS) { ALOGD("error in %s: 0x%x", __func__, s_get_versioninfo_op.u4_error_code); } else { ALOGV("ittiam decoder version number: %s", (char *) s_get_versioninfo_ip.pv_version_buffer); } return OK; } status_t C2SoftMpeg2Dec::initDecoder() { status_t ret = getNumMemRecords(); if (OK != ret) return ret; ret = fillMemRecords(); if (OK != ret) return ret; if (OK != createDecoder()) return UNKNOWN_ERROR; mNumCores = MIN(getCpuCoreCount(), MAX_NUM_CORES); mStride = ALIGN64(mWidth); mSignalledError = false; resetPlugin(); (void) setNumCores(); if (OK != setParams(mStride)) return UNKNOWN_ERROR; (void) getVersion(); return OK; } bool C2SoftMpeg2Dec::setDecodeArgs(ivd_video_decode_ip_t *ps_decode_ip, ivd_video_decode_op_t *ps_decode_op, C2ReadView *inBuffer, C2GraphicView *outBuffer, size_t inOffset, size_t inSize, uint32_t tsMarker) { uint32_t displayStride = mStride; uint32_t displayHeight = mHeight; size_t lumaSize = displayStride * displayHeight; size_t chromaSize = lumaSize >> 2; ps_decode_ip->u4_size = sizeof(ivd_video_decode_ip_t); ps_decode_ip->e_cmd = IVD_CMD_VIDEO_DECODE; if (inBuffer) { ps_decode_ip->u4_ts = tsMarker; ps_decode_ip->pv_stream_buffer = const_cast(inBuffer->data() + inOffset); ps_decode_ip->u4_num_Bytes = inSize; } else { ps_decode_ip->u4_ts = 0; ps_decode_ip->pv_stream_buffer = nullptr; ps_decode_ip->u4_num_Bytes = 0; } ps_decode_ip->s_out_buffer.u4_min_out_buf_size[0] = lumaSize; ps_decode_ip->s_out_buffer.u4_min_out_buf_size[1] = chromaSize; ps_decode_ip->s_out_buffer.u4_min_out_buf_size[2] = chromaSize; if (outBuffer) { if (outBuffer->width() < displayStride || outBuffer->height() < displayHeight) { ALOGE("Output buffer too small: provided (%dx%d) required (%ux%u)", outBuffer->width(), outBuffer->height(), displayStride, displayHeight); return false; } ps_decode_ip->s_out_buffer.pu1_bufs[0] = outBuffer->data()[C2PlanarLayout::PLANE_Y]; ps_decode_ip->s_out_buffer.pu1_bufs[1] = outBuffer->data()[C2PlanarLayout::PLANE_U]; ps_decode_ip->s_out_buffer.pu1_bufs[2] = outBuffer->data()[C2PlanarLayout::PLANE_V]; } else { ps_decode_ip->s_out_buffer.pu1_bufs[0] = mOutBufferDrain; ps_decode_ip->s_out_buffer.pu1_bufs[1] = mOutBufferDrain + lumaSize; ps_decode_ip->s_out_buffer.pu1_bufs[2] = mOutBufferDrain + lumaSize + chromaSize; } ps_decode_ip->s_out_buffer.u4_num_bufs = 3; ps_decode_op->u4_size = sizeof(ivd_video_decode_op_t); return true; } bool C2SoftMpeg2Dec::getSeqInfo() { ivdext_ctl_get_seq_info_ip_t s_ctl_get_seq_info_ip; ivdext_ctl_get_seq_info_op_t s_ctl_get_seq_info_op; s_ctl_get_seq_info_ip.u4_size = sizeof(ivdext_ctl_get_seq_info_ip_t); s_ctl_get_seq_info_ip.e_cmd = IVD_CMD_VIDEO_CTL; s_ctl_get_seq_info_ip.e_sub_cmd = (IVD_CONTROL_API_COMMAND_TYPE_T)IMPEG2D_CMD_CTL_GET_SEQ_INFO; s_ctl_get_seq_info_op.u4_size = sizeof(ivdext_ctl_get_seq_info_op_t); IV_API_CALL_STATUS_T status = ivdec_api_function(mDecHandle, &s_ctl_get_seq_info_ip, &s_ctl_get_seq_info_op); if (status != IV_SUCCESS) { ALOGW("Error in getting Sequence info: 0x%x", s_ctl_get_seq_info_op.u4_error_code); return false; } VuiColorAspects vuiColorAspects; vuiColorAspects.primaries = s_ctl_get_seq_info_op.u1_colour_primaries; vuiColorAspects.transfer = s_ctl_get_seq_info_op.u1_transfer_characteristics; vuiColorAspects.coeffs = s_ctl_get_seq_info_op.u1_matrix_coefficients; vuiColorAspects.fullRange = false; // mpeg2 video has limited range. // convert vui aspects to C2 values if changed if (!(vuiColorAspects == mBitstreamColorAspects)) { mBitstreamColorAspects = vuiColorAspects; ColorAspects sfAspects; C2StreamColorAspectsInfo::input codedAspects = { 0u }; ColorUtils::convertIsoColorAspectsToCodecAspects( vuiColorAspects.primaries, vuiColorAspects.transfer, vuiColorAspects.coeffs, vuiColorAspects.fullRange, sfAspects); if (!C2Mapper::map(sfAspects.mPrimaries, &codedAspects.primaries)) { codedAspects.primaries = C2Color::PRIMARIES_UNSPECIFIED; } if (!C2Mapper::map(sfAspects.mRange, &codedAspects.range)) { codedAspects.range = C2Color::RANGE_UNSPECIFIED; } if (!C2Mapper::map(sfAspects.mMatrixCoeffs, &codedAspects.matrix)) { codedAspects.matrix = C2Color::MATRIX_UNSPECIFIED; } if (!C2Mapper::map(sfAspects.mTransfer, &codedAspects.transfer)) { codedAspects.transfer = C2Color::TRANSFER_UNSPECIFIED; } std::vector> failures; (void)mIntf->config({&codedAspects}, C2_MAY_BLOCK, &failures); } return true; } status_t C2SoftMpeg2Dec::setFlushMode() { ivd_ctl_flush_ip_t s_set_flush_ip; ivd_ctl_flush_op_t s_set_flush_op; s_set_flush_ip.u4_size = sizeof(ivd_ctl_flush_ip_t); s_set_flush_ip.e_cmd = IVD_CMD_VIDEO_CTL; s_set_flush_ip.e_sub_cmd = IVD_CMD_CTL_FLUSH; s_set_flush_op.u4_size = sizeof(ivd_ctl_flush_op_t); IV_API_CALL_STATUS_T status = ivdec_api_function(mDecHandle, &s_set_flush_ip, &s_set_flush_op); if (status != IV_SUCCESS) { ALOGE("error in %s: 0x%x", __func__, s_set_flush_op.u4_error_code); return UNKNOWN_ERROR; } return OK; } status_t C2SoftMpeg2Dec::resetDecoder() { ivd_ctl_reset_ip_t s_reset_ip; ivd_ctl_reset_op_t s_reset_op; s_reset_ip.u4_size = sizeof(ivd_ctl_reset_ip_t); s_reset_ip.e_cmd = IVD_CMD_VIDEO_CTL; s_reset_ip.e_sub_cmd = IVD_CMD_CTL_RESET; s_reset_op.u4_size = sizeof(ivd_ctl_reset_op_t); IV_API_CALL_STATUS_T status = ivdec_api_function(mDecHandle, &s_reset_ip, &s_reset_op); if (IV_SUCCESS != status) { ALOGE("error in %s: 0x%x", __func__, s_reset_op.u4_error_code); return UNKNOWN_ERROR; } (void) setNumCores(); mStride = 0; mSignalledError = false; return OK; } void C2SoftMpeg2Dec::resetPlugin() { mSignalledOutputEos = false; gettimeofday(&mTimeStart, nullptr); gettimeofday(&mTimeEnd, nullptr); } status_t C2SoftMpeg2Dec::deleteDecoder() { if (mMemRecords) { iv_mem_rec_t *ps_mem_rec = mMemRecords; for (size_t i = 0; i < mNumMemRecords; i++, ps_mem_rec++) { if (ps_mem_rec->pv_base) { ivd_aligned_free(ps_mem_rec->pv_base); } } ivd_aligned_free(mMemRecords); mMemRecords = nullptr; } mDecHandle = nullptr; return OK; } status_t C2SoftMpeg2Dec::reInitDecoder() { deleteDecoder(); status_t ret = initDecoder(); if (OK != ret) { ALOGE("Failed to initialize decoder"); deleteDecoder(); return ret; } return OK; } void fillEmptyWork(const std::unique_ptr &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 C2SoftMpeg2Dec::finishWork(uint64_t index, const std::unique_ptr &work) { std::shared_ptr buffer = createGraphicBuffer(std::move(mOutBlock), C2Rect(mWidth, mHeight)); mOutBlock = nullptr; { IntfImpl::Lock lock = mIntf->lock(); buffer->setInfo(mIntf->getColorAspects_l()); } class FillWork { public: FillWork(uint32_t flags, C2WorkOrdinalStruct ordinal, const std::shared_ptr& buffer) : mFlags(flags), mOrdinal(ordinal), mBuffer(buffer) {} ~FillWork() = default; void operator()(const std::unique_ptr& 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 mBuffer; }; auto fillWork = [buffer](const std::unique_ptr &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); } } c2_status_t C2SoftMpeg2Dec::ensureDecoderState(const std::shared_ptr &pool) { if (!mDecHandle) { ALOGE("not supposed to be here, invalid decoder context"); return C2_CORRUPTED; } if (mStride != ALIGN64(mWidth)) { mStride = ALIGN64(mWidth); if (OK != setParams(mStride)) return C2_CORRUPTED; } if (mOutBlock && (mOutBlock->width() != mStride || mOutBlock->height() != mHeight)) { mOutBlock.reset(); } if (!mOutBlock) { uint32_t format = HAL_PIXEL_FORMAT_YV12; C2MemoryUsage usage = { C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE }; c2_status_t err = pool->fetchGraphicBlock(mStride, mHeight, format, usage, &mOutBlock); if (err != C2_OK) { ALOGE("fetchGraphicBlock for Output failed with status %d", err); return err; } ALOGV("provided (%dx%d) required (%dx%d)", mOutBlock->width(), mOutBlock->height(), mStride, mHeight); } return C2_OK; } // TODO: can overall error checking be improved? // TODO: allow configuration of color format and usage for graphic buffers instead // of hard coding them to HAL_PIXEL_FORMAT_YV12 // TODO: pass coloraspects information to surface // TODO: test support for dynamic change in resolution // TODO: verify if the decoder sent back all frames void C2SoftMpeg2Dec::process( const std::unique_ptr &work, const std::shared_ptr &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; } size_t inOffset = 0u; size_t inSize = 0u; uint32_t workIndex = work->input.ordinal.frameIndex.peeku() & 0xFFFFFFFF; 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 eos = ((work->input.flags & C2FrameData::FLAG_END_OF_STREAM) != 0); bool hasPicture = false; ALOGV("in buffer attr. size %zu timestamp %d frameindex %d, flags %x", inSize, (int)work->input.ordinal.timestamp.peeku(), (int)work->input.ordinal.frameIndex.peeku(), work->input.flags); size_t inPos = 0; while (inPos < inSize) { if (C2_OK != ensureDecoderState(pool)) { mSignalledError = true; work->workletsProcessed = 1u; work->result = C2_CORRUPTED; return; } C2GraphicView wView = mOutBlock->map().get(); if (wView.error()) { ALOGE("graphic view map failed %d", wView.error()); work->result = C2_CORRUPTED; return; } ivd_video_decode_ip_t s_decode_ip; ivd_video_decode_op_t s_decode_op; if (!setDecodeArgs(&s_decode_ip, &s_decode_op, &rView, &wView, inOffset + inPos, inSize - inPos, workIndex)) { mSignalledError = true; work->workletsProcessed = 1u; work->result = C2_CORRUPTED; return; } // If input dump is enabled, then write to file DUMP_TO_FILE(mInFile, s_decode_ip.pv_stream_buffer, s_decode_ip.u4_num_Bytes); WORD32 delay; GETTIME(&mTimeStart, nullptr); TIME_DIFF(mTimeEnd, mTimeStart, delay); (void) ivdec_api_function(mDecHandle, &s_decode_ip, &s_decode_op); WORD32 decodeTime; GETTIME(&mTimeEnd, nullptr); TIME_DIFF(mTimeStart, mTimeEnd, decodeTime); ALOGV("decodeTime=%6d delay=%6d numBytes=%6d ", decodeTime, delay, s_decode_op.u4_num_bytes_consumed); if (IMPEG2D_UNSUPPORTED_DIMENSIONS == s_decode_op.u4_error_code) { ALOGV("unsupported resolution : %dx%d", s_decode_op.u4_pic_wd, s_decode_op.u4_pic_ht); drainInternal(DRAIN_COMPONENT_NO_EOS, pool, work); resetPlugin(); work->workletsProcessed = 0u; mWidth = s_decode_op.u4_pic_wd; mHeight = s_decode_op.u4_pic_ht; ALOGI("Configuring decoder: mWidth %d , mHeight %d ", mWidth, mHeight); C2StreamPictureSizeInfo::output size(0u, mWidth, mHeight); std::vector> failures; c2_status_t err = mIntf->config({&size}, C2_MAY_BLOCK, &failures); if (err == OK) { work->worklets.front()->output.configUpdate.push_back( C2Param::Copy(size)); } else { ALOGE("Cannot set width and height"); mSignalledError = true; work->workletsProcessed = 1u; work->result = C2_CORRUPTED; return; } if (OK != reInitDecoder()) { ALOGE("Failed to reinitialize decoder"); mSignalledError = true; work->workletsProcessed = 1u; work->result = C2_CORRUPTED; return; } continue; } else if (IVD_RES_CHANGED == (s_decode_op.u4_error_code & 0xFF)) { ALOGV("resolution changed"); drainInternal(DRAIN_COMPONENT_NO_EOS, pool, work); resetDecoder(); resetPlugin(); work->workletsProcessed = 0u; continue; } if (0 < s_decode_op.u4_pic_wd && 0 < s_decode_op.u4_pic_ht) { if (s_decode_op.u4_pic_wd != mWidth || s_decode_op.u4_pic_ht != mHeight) { mWidth = s_decode_op.u4_pic_wd; mHeight = s_decode_op.u4_pic_ht; CHECK_EQ(0u, s_decode_op.u4_output_present); ALOGI("Configuring decoder out: mWidth %d , mHeight %d ", mWidth, mHeight); C2StreamPictureSizeInfo::output size(0u, mWidth, mHeight); std::vector> failures; c2_status_t err = mIntf->config({&size}, C2_MAY_BLOCK, &failures); if (err == OK) { work->worklets.front()->output.configUpdate.push_back( C2Param::Copy(size)); } else { ALOGE("Cannot set width and height"); mSignalledError = true; work->workletsProcessed = 1u; work->result = C2_CORRUPTED; return; } } } (void) getSeqInfo(); hasPicture |= (1 == s_decode_op.u4_frame_decoded_flag); if (s_decode_op.u4_output_present) { finishWork(s_decode_op.u4_ts, work); } inPos += s_decode_op.u4_num_bytes_consumed; if (hasPicture && (inSize - inPos) != 0) { ALOGD("decoded frame in current access nal, ignoring further trailing bytes %d", (int)inSize - (int)inPos); break; } } if (eos) { drainInternal(DRAIN_COMPONENT_WITH_EOS, pool, work); mSignalledOutputEos = true; } else if (!hasPicture) { fillEmptyWork(work); } } c2_status_t C2SoftMpeg2Dec::drainInternal( uint32_t drainMode, const std::shared_ptr &pool, const std::unique_ptr &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 (OK != setFlushMode()) return C2_CORRUPTED; while (true) { if (C2_OK != ensureDecoderState(pool)) { mSignalledError = true; work->workletsProcessed = 1u; work->result = C2_CORRUPTED; return C2_CORRUPTED; } C2GraphicView wView = mOutBlock->map().get(); if (wView.error()) { ALOGE("graphic view map failed %d", wView.error()); return C2_CORRUPTED; } ivd_video_decode_ip_t s_decode_ip; ivd_video_decode_op_t s_decode_op; if (!setDecodeArgs(&s_decode_ip, &s_decode_op, nullptr, &wView, 0, 0, 0)) { mSignalledError = true; work->workletsProcessed = 1u; return C2_CORRUPTED; } (void) ivdec_api_function(mDecHandle, &s_decode_ip, &s_decode_op); if (s_decode_op.u4_output_present) { finishWork(s_decode_op.u4_ts, work); } else { fillEmptyWork(work); break; } } return C2_OK; } c2_status_t C2SoftMpeg2Dec::drain( uint32_t drainMode, const std::shared_ptr &pool) { return drainInternal(drainMode, pool, nullptr); } class C2SoftMpeg2DecFactory : public C2ComponentFactory { public: C2SoftMpeg2DecFactory() : mHelper(std::static_pointer_cast( GetCodec2PlatformComponentStore()->getParamReflector())) { } virtual c2_status_t createComponent( c2_node_id_t id, std::shared_ptr* const component, std::function deleter) override { *component = std::shared_ptr( new C2SoftMpeg2Dec(COMPONENT_NAME, id, std::make_shared(mHelper)), deleter); return C2_OK; } virtual c2_status_t createInterface( c2_node_id_t id, std::shared_ptr* const interface, std::function deleter) override { *interface = std::shared_ptr( new SimpleInterface( COMPONENT_NAME, id, std::make_shared(mHelper)), deleter); return C2_OK; } virtual ~C2SoftMpeg2DecFactory() override = default; private: std::shared_ptr mHelper; }; } // namespace android extern "C" ::C2ComponentFactory* CreateCodec2Factory() { ALOGV("in %s", __func__); return new ::android::C2SoftMpeg2DecFactory(); } extern "C" void DestroyCodec2Factory(::C2ComponentFactory* factory) { ALOGV("in %s", __func__); delete factory; }