Merge "C2SoftHevcDec: add support to use ihevcd instead of ivd structures" (fe1258b4) · Commits · e / os / android_frameworks_av

media/codec2/components/hevc/C2SoftHevcDec.cpp

+76 −67

Original line number	Diff line number	Diff line
		@@ -26,7 +26,6 @@
		#include <SimpleC2Interface.h>

		#include "C2SoftHevcDec.h"
		#include "ihevcd_cxa.h"

		namespace android {

		@@ -380,12 +379,14 @@ c2_status_t C2SoftHevcDec::onFlush_sm() {
		}

		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) {
		ihevcd_cxa_video_decode_ip_t s_hevcd_decode_ip = {};
		ihevcd_cxa_video_decode_op_t s_hevcd_decode_op = {};
		ivd_video_decode_ip_t *ps_decode_ip = &s_hevcd_decode_ip.s_ivd_video_decode_ip_t;
		ivd_video_decode_op_t *ps_decode_op = &s_hevcd_decode_op.s_ivd_video_decode_op_t;

		setDecodeArgs(ps_decode_ip, ps_decode_op, nullptr, nullptr, 0, 0, 0);
		(void) ivdec_api_function(mDecHandle, ps_decode_ip, ps_decode_op);
		if (0 == ps_decode_op->u4_output_present) {
		resetPlugin();
		break;
		}
		@@ -400,8 +401,8 @@ c2_status_t C2SoftHevcDec::onFlush_sm() {
		}

		status_t C2SoftHevcDec::createDecoder() {
		ivdext_create_ip_t s_create_ip;
		ivdext_create_op_t s_create_op;
		ivdext_create_ip_t s_create_ip = {};
		ivdext_create_op_t s_create_op = {};

		s_create_ip.s_ivd_create_ip_t.u4_size = sizeof(ivdext_create_ip_t);
		s_create_ip.s_ivd_create_ip_t.e_cmd = IVD_CMD_CREATE;
		@@ -427,8 +428,8 @@ status_t C2SoftHevcDec::createDecoder() {
		}

		status_t C2SoftHevcDec::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;
		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;
		@@ -447,22 +448,26 @@ status_t C2SoftHevcDec::setNumCores() {
		}

		status_t C2SoftHevcDec::setParams(size_t stride, IVD_VIDEO_DECODE_MODE_T dec_mode) {
		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 = dec_mode;
		s_set_dyn_params_op.u4_size = sizeof(ivd_ctl_set_config_op_t);
		ihevcd_cxa_ctl_set_config_ip_t s_hevcd_set_dyn_params_ip = {};
		ihevcd_cxa_ctl_set_config_op_t s_hevcd_set_dyn_params_op = {};
		ivd_ctl_set_config_ip_t *ps_set_dyn_params_ip =
		&s_hevcd_set_dyn_params_ip.s_ivd_ctl_set_config_ip_t;
		ivd_ctl_set_config_op_t *ps_set_dyn_params_op =
		&s_hevcd_set_dyn_params_op.s_ivd_ctl_set_config_op_t;

		ps_set_dyn_params_ip->u4_size = sizeof(ihevcd_cxa_ctl_set_config_ip_t);
		ps_set_dyn_params_ip->e_cmd = IVD_CMD_VIDEO_CTL;
		ps_set_dyn_params_ip->e_sub_cmd = IVD_CMD_CTL_SETPARAMS;
		ps_set_dyn_params_ip->u4_disp_wd = (UWORD32) stride;
		ps_set_dyn_params_ip->e_frm_skip_mode = IVD_SKIP_NONE;
		ps_set_dyn_params_ip->e_frm_out_mode = IVD_DISPLAY_FRAME_OUT;
		ps_set_dyn_params_ip->e_vid_dec_mode = dec_mode;
		ps_set_dyn_params_op->u4_size = sizeof(ihevcd_cxa_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);
		ps_set_dyn_params_ip,
		ps_set_dyn_params_op);
		if (status != IV_SUCCESS) {
		ALOGE("error in %s: 0x%x", __func__, s_set_dyn_params_op.u4_error_code);
		ALOGE("error in %s: 0x%x", __func__, ps_set_dyn_params_op->u4_error_code);
		return UNKNOWN_ERROR;
		}

		@@ -470,8 +475,8 @@ status_t C2SoftHevcDec::setParams(size_t stride, IVD_VIDEO_DECODE_MODE_T dec_mod
		}

		status_t C2SoftHevcDec::getVersion() {
		ivd_ctl_getversioninfo_ip_t s_get_versioninfo_ip;
		ivd_ctl_getversioninfo_op_t s_get_versioninfo_op;
		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);
		@@ -529,7 +534,7 @@ bool C2SoftHevcDec::setDecodeArgs(ivd_video_decode_ip_t *ps_decode_ip,
		if (OK != setParams(mStride, IVD_DECODE_FRAME)) return false;
		}

		ps_decode_ip->u4_size = sizeof(ivd_video_decode_ip_t);
		ps_decode_ip->u4_size = sizeof(ihevcd_cxa_video_decode_ip_t);
		ps_decode_ip->e_cmd = IVD_CMD_VIDEO_DECODE;
		if (inBuffer) {
		ps_decode_ip->u4_ts = tsMarker;
		@@ -558,15 +563,15 @@ bool C2SoftHevcDec::setDecodeArgs(ivd_video_decode_ip_t *ps_decode_ip,
		ps_decode_ip->s_out_buffer.pu1_bufs[2] = mOutBufferFlush + lumaSize + chromaSize;
		}
		ps_decode_ip->s_out_buffer.u4_num_bufs = 3;
		ps_decode_op->u4_size = sizeof(ivd_video_decode_op_t);
		ps_decode_op->u4_size = sizeof(ihevcd_cxa_video_decode_op_t);
		ps_decode_op->u4_output_present = 0;

		return true;
		}

		bool C2SoftHevcDec::getVuiParams() {
		ivdext_ctl_get_vui_params_ip_t s_get_vui_params_ip;
		ivdext_ctl_get_vui_params_op_t s_get_vui_params_op;
		ivdext_ctl_get_vui_params_ip_t s_get_vui_params_ip = {};
		ivdext_ctl_get_vui_params_op_t s_get_vui_params_op = {};

		s_get_vui_params_ip.u4_size = sizeof(ivdext_ctl_get_vui_params_ip_t);
		s_get_vui_params_ip.e_cmd = IVD_CMD_VIDEO_CTL;
		@@ -614,8 +619,8 @@ bool C2SoftHevcDec::getVuiParams() {
		}

		status_t C2SoftHevcDec::setFlushMode() {
		ivd_ctl_flush_ip_t s_set_flush_ip;
		ivd_ctl_flush_op_t s_set_flush_op;
		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;
		@@ -633,8 +638,8 @@ status_t C2SoftHevcDec::setFlushMode() {
		}

		status_t C2SoftHevcDec::resetDecoder() {
		ivd_ctl_reset_ip_t s_reset_ip;
		ivd_ctl_reset_op_t s_reset_op;
		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;
		@@ -662,8 +667,8 @@ void C2SoftHevcDec::resetPlugin() {

		status_t C2SoftHevcDec::deleteDecoder() {
		if (mDecHandle) {
		ivdext_delete_ip_t s_delete_ip;
		ivdext_delete_op_t s_delete_op;
		ivdext_delete_ip_t s_delete_ip = {};
		ivdext_delete_op_t s_delete_op = {};

		s_delete_ip.s_ivd_delete_ip_t.u4_size = sizeof(ivdext_delete_ip_t);
		s_delete_ip.s_ivd_delete_ip_t.e_cmd = IVD_CMD_DELETE;
		@@ -835,9 +840,11 @@ void C2SoftHevcDec::process(
		work->result = wView.error();
		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,
		ihevcd_cxa_video_decode_ip_t s_hevcd_decode_ip = {};
		ihevcd_cxa_video_decode_op_t s_hevcd_decode_op = {};
		ivd_video_decode_ip_t *ps_decode_ip = &s_hevcd_decode_ip.s_ivd_video_decode_ip_t;
		ivd_video_decode_op_t *ps_decode_op = &s_hevcd_decode_op.s_ivd_video_decode_op_t;
		if (!setDecodeArgs(ps_decode_ip, ps_decode_op, &rView, &wView,
		inOffset + inPos, inSize - inPos, workIndex)) {
		mSignalledError = true;
		work->workletsProcessed = 1u;
		@@ -852,26 +859,26 @@ void C2SoftHevcDec::process(
		WORD32 delay;
		GETTIME(&mTimeStart, nullptr);
		TIME_DIFF(mTimeEnd, mTimeStart, delay);
		(void) ivdec_api_function(mDecHandle, &s_decode_ip, &s_decode_op);
		(void) ivdec_api_function(mDecHandle, ps_decode_ip, ps_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 (IVD_MEM_ALLOC_FAILED == (s_decode_op.u4_error_code & IVD_ERROR_MASK)) {
		ps_decode_op->u4_num_bytes_consumed);
		if (IVD_MEM_ALLOC_FAILED == (ps_decode_op->u4_error_code & IVD_ERROR_MASK)) {
		ALOGE("allocation failure in decoder");
		mSignalledError = true;
		work->workletsProcessed = 1u;
		work->result = C2_CORRUPTED;
		return;
		} else if (IVD_STREAM_WIDTH_HEIGHT_NOT_SUPPORTED ==
		(s_decode_op.u4_error_code & IVD_ERROR_MASK)) {
		(ps_decode_op->u4_error_code & IVD_ERROR_MASK)) {
		ALOGE("unsupported resolution : %dx%d", mWidth, mHeight);
		mSignalledError = true;
		work->workletsProcessed = 1u;
		work->result = C2_CORRUPTED;
		return;
		} else if (IVD_RES_CHANGED == (s_decode_op.u4_error_code & IVD_ERROR_MASK)) {
		} else if (IVD_RES_CHANGED == (ps_decode_op->u4_error_code & IVD_ERROR_MASK)) {
		ALOGV("resolution changed");
		drainInternal(DRAIN_COMPONENT_NO_EOS, pool, work);
		resetDecoder();
		@@ -880,16 +887,16 @@ void C2SoftHevcDec::process(

		/* Decode header and get new dimensions */
		setParams(mStride, IVD_DECODE_HEADER);
		(void) ivdec_api_function(mDecHandle, &s_decode_ip, &s_decode_op);
		} else if (IS_IVD_FATAL_ERROR(s_decode_op.u4_error_code)) {
		ALOGE("Fatal error in decoder 0x%x", s_decode_op.u4_error_code);
		(void) ivdec_api_function(mDecHandle, ps_decode_ip, ps_decode_op);
		} else if (IS_IVD_FATAL_ERROR(ps_decode_op->u4_error_code)) {
		ALOGE("Fatal error in decoder 0x%x", ps_decode_op->u4_error_code);
		mSignalledError = true;
		work->workletsProcessed = 1u;
		work->result = C2_CORRUPTED;
		return;
		}
		if (s_decode_op.i4_reorder_depth >= 0 && mOutputDelay != s_decode_op.i4_reorder_depth) {
		mOutputDelay = s_decode_op.i4_reorder_depth;
		if (ps_decode_op->i4_reorder_depth >= 0 && mOutputDelay != ps_decode_op->i4_reorder_depth) {
		mOutputDelay = ps_decode_op->i4_reorder_depth;
		ALOGV("New Output delay %d ", mOutputDelay);

		C2PortActualDelayTuning::output outputDelay(mOutputDelay);
		@@ -907,15 +914,15 @@ void C2SoftHevcDec::process(
		return;
		}
		}
		if (0 < s_decode_op.u4_pic_wd && 0 < s_decode_op.u4_pic_ht) {
		if (0 < ps_decode_op->u4_pic_wd && 0 < ps_decode_op->u4_pic_ht) {
		if (mHeaderDecoded == false) {
		mHeaderDecoded = true;
		setParams(ALIGN32(s_decode_op.u4_pic_wd), IVD_DECODE_FRAME);
		setParams(ALIGN32(ps_decode_op->u4_pic_wd), IVD_DECODE_FRAME);
		}
		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);
		if (ps_decode_op->u4_pic_wd != mWidth \|\| ps_decode_op->u4_pic_ht != mHeight) {
		mWidth = ps_decode_op->u4_pic_wd;
		mHeight = ps_decode_op->u4_pic_ht;
		CHECK_EQ(0u, ps_decode_op->u4_output_present);

		C2StreamPictureSizeInfo::output size(0u, mWidth, mHeight);
		std::vector<std::unique_ptr<C2SettingResult>> failures;
		@@ -935,15 +942,15 @@ void C2SoftHevcDec::process(
		}
		}
		(void) getVuiParams();
		hasPicture \|= (1 == s_decode_op.u4_frame_decoded_flag);
		if (s_decode_op.u4_output_present) {
		finishWork(s_decode_op.u4_ts, work);
		hasPicture \|= (1 == ps_decode_op->u4_frame_decoded_flag);
		if (ps_decode_op->u4_output_present) {
		finishWork(ps_decode_op->u4_ts, work);
		}
		if (0 == s_decode_op.u4_num_bytes_consumed) {
		if (0 == ps_decode_op->u4_num_bytes_consumed) {
		ALOGD("Bytes consumed is zero. Ignoring remaining bytes");
		break;
		}
		inPos += s_decode_op.u4_num_bytes_consumed;
		inPos += ps_decode_op->u4_num_bytes_consumed;
		if (hasPicture && (inSize - inPos)) {
		ALOGD("decoded frame in current access nal, ignoring further trailing bytes %d",
		(int)inSize - (int)inPos);
		@@ -985,16 +992,18 @@ c2_status_t C2SoftHevcDec::drainInternal(
		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)) {
		ihevcd_cxa_video_decode_ip_t s_hevcd_decode_ip = {};
		ihevcd_cxa_video_decode_op_t s_hevcd_decode_op = {};
		ivd_video_decode_ip_t *ps_decode_ip = &s_hevcd_decode_ip.s_ivd_video_decode_ip_t;
		ivd_video_decode_op_t *ps_decode_op = &s_hevcd_decode_op.s_ivd_video_decode_op_t;
		if (!setDecodeArgs(ps_decode_ip, ps_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);
		(void) ivdec_api_function(mDecHandle, ps_decode_ip, ps_decode_op);
		if (ps_decode_op->u4_output_present) {
		finishWork(ps_decode_op->u4_ts, work);
		} else {
		fillEmptyWork(work);
		break;

media/codec2/components/hevc/C2SoftHevcDec.h

+1 −2

Original line number	Diff line number	Diff line
		@@ -23,8 +23,7 @@
		#include <SimpleC2Component.h>

		#include "ihevc_typedefs.h"
		#include "iv.h"
		#include "ivd.h"
		#include "ihevcd_cxa.h"

		namespace android {