package/mpp
1
0
Fork 0
mirror of https://github.com/nyanmisaka/mpp.git synced 2025-10-05 09:06:50 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

[mpp]: Combine block control and timeout control

Browse Source 
Use MppPollType as block control MPP_SET_INPUT_TIMEOUT and
MPP_SET_OUTPUT_TIMEOUT 's parameter.
Deprecate old block/block_timeout control.

Next step is to change MppPollType to RK_S64 for compatible in different
platform.

Change-Id: I02974f0b8eeb23ff43687448d6c3271ea7dd0a2c
Signed-off-by: Herman Chen <herman.chen@rock-chips.com>
This commit is contained in:
Herman Chen
2018-06-28 11:04:49 +08:00
parent 6f91a59d0b
commit 0a78fb7102
12 changed files with 156 additions and 117 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
inc/mpp_task.h
View File

@@ -102,9 +102,21 @@ typedef enum {
MPP_POLL_BUTT = -2,
MPP_POLL_BLOCK = -1,
MPP_POLL_NON_BLOCK = 0,
MPP_POLL_MAX = 1000,
MPP_POLL_MAX = 8000,
} MppPollType;
/*
* Mpp timeout define
* MPP_TIMEOUT_BLOCK - for block poll
* MPP_TIMEOUT_NON_BLOCK - for non-block poll
* small than MPP_TIMEOUT_MAX - for poll with timeout in ms
* small than MPP_TIMEOUT_BUTT or larger than MPP_TIMEOUT_MAX is invalid value
*/
#define MPP_TIMEOUT_BUTT (-2L)
#define MPP_TIMEOUT_BLOCK (-1L)
#define MPP_TIMEOUT_NON_BLOCK (0L)
#define MPP_TIMEOUT_MAX (8000L)
/*
* MppTask is descriptor of a task which send to mpp for process
* mpp can support different type of work mode, for example:

16
inc/rk_mpi_cmd.h
View File

@@ -75,10 +75,18 @@ typedef enum {
MPP_CMD_BASE = CMD_MODULE_MPP,
MPP_ENABLE_DEINTERLACE,
MPP_SET_INPUT_BLOCK,
MPP_SET_INTPUT_BLOCK_TIMEOUT,
MPP_SET_OUTPUT_BLOCK,
MPP_SET_OUTPUT_BLOCK_TIMEOUT,
MPP_SET_INPUT_BLOCK, /* deprecated */
MPP_SET_INTPUT_BLOCK_TIMEOUT, /* deprecated */
MPP_SET_OUTPUT_BLOCK, /* deprecated */
MPP_SET_OUTPUT_BLOCK_TIMEOUT, /* deprecated */
/*
* timeout setup, refer to MPP_TIMEOUT_XXX
* zero - non block
* negative - block with no timeout
* positive - timeout in milisecond
*/
MPP_SET_INPUT_TIMEOUT, /* parameter type RK_S64 */
MPP_SET_OUTPUT_TIMEOUT, /* parameter type RK_S64 */
MPP_CMD_END,
MPP_CODEC_CMD_BASE = CMD_MODULE_CODEC,

5
mpp/inc/mpp.h
View File

@@ -109,9 +109,8 @@ public:
MppTaskQueue mInputTaskQueue;
MppTaskQueue mOutputTaskQueue;
MppPollType mInputBlock;
MppPollType mOutputBlock;
RK_S64 mOutputBlockTimeout;
MppPollType mInputTimeout;
MppPollType mOutputTimeout;
MppTask mInputTask;
/*

18
mpp/legacy/vpu_api_legacy.cpp
View File

@@ -447,9 +447,9 @@ RK_S32 VpuApiLegacy::init(VpuCodecContext *ctx, RK_U8 *extraData, RK_U32 extra_s
MppPollType block = MPP_POLL_BLOCK;
/* setup input / output block mode */
ret = mpi->control(mpp_ctx, MPP_SET_INPUT_BLOCK, (MppParam)&block);
ret = mpi->control(mpp_ctx, MPP_SET_INPUT_TIMEOUT, (MppParam)&block);
if (MPP_OK != ret)
mpp_err("mpi->control MPP_SET_INPUT_BLOCK failed\n");
mpp_err("mpi->control MPP_SET_INPUT_TIMEOUT failed\n");
if (memGroup == NULL) {
ret = mpp_buffer_group_get_internal(&memGroup, MPP_BUFFER_TYPE_ION);
@@ -1440,7 +1440,19 @@ RK_S32 VpuApiLegacy::control(VpuCodecContext *ctx, VPU_API_CMD cmd, void *param)
mpicmd = MPP_DEC_GET_VPUMEM_USED_COUNT;
} break;
case VPU_API_SET_OUTPUT_BLOCK: {
mpicmd = MPP_SET_OUTPUT_BLOCK;
mpicmd = MPP_SET_OUTPUT_TIMEOUT;
if (param) {
RK_S32 timeout = *((RK_S32*)param);
if (timeout) {
if (timeout < 0)
mpp_log("set output mode to block\n");
else
mpp_log("set output timeout %d ms\n", timeout);
} else {
mpp_log("set output mode to non-block\n");
}
}
} break;
case VPU_API_GET_EOS_STATUS: {
*((RK_S32 *)param) = mEosSet;

4
mpp/mpi.cpp
View File

@@ -107,7 +107,7 @@ static MPP_RET mpi_decode(MppCtx ctx, MppPacket packet, MppFrame *frame)
* If there is frame to return get the frame first
* But if the output mode is block then we need to send packet first
*/
if (!mpp->mOutputBlock || packet_done) {
if (!mpp->mOutputTimeout || packet_done) {
ret = mpp->get_frame(frame);
if (ret || *frame)
break;
@@ -118,7 +118,7 @@ static MPP_RET mpi_decode(MppCtx ctx, MppPacket packet, MppFrame *frame)
break;
/*
* then send input stream with block mode
* then send input stream with timeout mode
*/
ret = mpp->put_packet(packet);
if (MPP_OK == ret)

72
mpp/mpp.cpp
View File

@@ -51,9 +51,8 @@ Mpp::Mpp()
mOutputPort(NULL),
mInputTaskQueue(NULL),
mOutputTaskQueue(NULL),
mInputBlock(MPP_POLL_NON_BLOCK),
mOutputBlock(MPP_POLL_NON_BLOCK),
mOutputBlockTimeout(-1),
mInputTimeout(MPP_POLL_NON_BLOCK),
mOutputTimeout(MPP_POLL_NON_BLOCK),
mInputTask(NULL),
mThreadCodec(NULL),
mThreadHal(NULL),
@@ -294,8 +293,6 @@ MPP_RET Mpp::put_packet(MppPacket packet)
MPP_RET Mpp::get_frame(MppFrame *frame)
{
RK_S32 ret;
if (!mInitDone)
return MPP_ERR_INIT;
@@ -303,20 +300,21 @@ MPP_RET Mpp::get_frame(MppFrame *frame)
MppFrame first = NULL;
if (0 == mFrames->list_size()) {
if (mOutputBlock == MPP_POLL_BLOCK) {
if (mOutputBlockTimeout >= 0) {
ret = mFrames->wait(mOutputBlockTimeout);
if (mOutputTimeout) {
if (mOutputTimeout < 0) {
/* block wait */
mFrames->wait();
} else {
RK_S32 ret = mFrames->wait(mOutputTimeout);
if (ret) {
if (ret == ETIMEDOUT)
return MPP_ERR_TIMEOUT;
else
return MPP_NOK;
}
} else {
mFrames->wait();
}
} else {
/* NOTE: this sleep is to avoid user's dead loop */
/* NOTE: in non-block mode the sleep is to avoid user's dead loop */
msleep(1);
}
}
@@ -362,9 +360,9 @@ MPP_RET Mpp::put_frame(MppFrame frame)
if (mInputTask == NULL) {
/* poll input port for valid task */
ret = poll(MPP_PORT_INPUT, mInputBlock);
ret = poll(MPP_PORT_INPUT, mInputTimeout);
if (ret) {
mpp_log_f("poll on set timeout %d ret %d\n", mInputBlock, ret);
mpp_log_f("poll on set timeout %d ret %d\n", mInputTimeout, ret);
goto RET;
}
@@ -395,7 +393,7 @@ MPP_RET Mpp::put_frame(MppFrame frame)
/* wait enqueued task finished */
ret = poll(MPP_PORT_INPUT, MPP_POLL_BLOCK);
if (ret) {
mpp_log_f("poll on get timeout %d ret %d\n", mInputBlock, ret);
mpp_log_f("poll on get timeout %d ret %d\n", mInputTimeout, ret);
goto RET;
}
@@ -429,7 +427,7 @@ MPP_RET Mpp::get_packet(MppPacket *packet)
MPP_RET ret = MPP_OK;
MppTask task = NULL;
ret = poll(MPP_PORT_OUTPUT, mOutputBlock);
ret = poll(MPP_PORT_OUTPUT, mOutputTimeout);
if (ret) {
// NOTE: Do not treat poll failure as error. Just clear output
ret = MPP_OK;
@@ -655,17 +653,43 @@ MPP_RET Mpp::control_mpp(MpiCmd cmd, MppParam param)
MPP_RET ret = MPP_OK;
switch (cmd) {
case MPP_SET_INPUT_BLOCK: {
MppPollType block = *((MppPollType *)param);
mInputBlock = block;
} break;
case MPP_SET_OUTPUT_BLOCK: {
MppPollType block = *((MppPollType *)param);
mOutputBlock = block;
} break;
case MPP_SET_INPUT_BLOCK :
case MPP_SET_OUTPUT_BLOCK :
case MPP_SET_INTPUT_BLOCK_TIMEOUT :
case MPP_SET_OUTPUT_BLOCK_TIMEOUT : {
mOutputBlockTimeout = *((RK_S64 *)param);
MppPollType block = (param) ? *((MppPollType *)param) : MPP_POLL_NON_BLOCK;
if (block <= MPP_POLL_BUTT || block > MPP_POLL_MAX) {
mpp_err("invalid output timeout type %d should be in range [%d, %d]\n",
block, MPP_POLL_BUTT, MPP_POLL_MAX);
ret = MPP_ERR_VALUE;
break;
}
if (cmd == MPP_SET_INPUT_BLOCK || cmd == MPP_SET_INTPUT_BLOCK_TIMEOUT)
mInputTimeout = block;
else
mOutputTimeout = block;
mpp_log("deprecated block control, use timeout control instead\n");
} break;
case MPP_SET_INPUT_TIMEOUT:
case MPP_SET_OUTPUT_TIMEOUT: {
MppPollType timeout = (param) ? *((MppPollType *)param) : MPP_POLL_NON_BLOCK;
if (timeout <= MPP_POLL_BUTT || timeout > MPP_POLL_MAX) {
mpp_err("invalid output timeout type %d should be in range [%d, %d]\n",
timeout, MPP_POLL_BUTT, MPP_POLL_MAX);
ret = MPP_ERR_VALUE;
break;
}
if (cmd == MPP_SET_INPUT_TIMEOUT)
mInputTimeout = timeout;
else
mOutputTimeout = timeout;
} break;
default : {
ret = MPP_NOK;
} break;

26
test/mpi_dec_mt_test.c
View File

@@ -281,8 +281,7 @@ int mpi_dec_test_decode(MpiDecTestCmd *cmd)
MpiCmd mpi_cmd = MPP_CMD_BASE;
MppParam param = NULL;
RK_U32 need_split = 1;
RK_U32 output_block = MPP_POLL_BLOCK;
RK_S64 block_timeout = cmd->timeout;
MppPollType timeout = cmd->timeout;
// paramter for resource malloc
RK_U32 width = cmd->width;
@@ -353,22 +352,15 @@ int mpi_dec_test_decode(MpiDecTestCmd *cmd)
goto MPP_TEST_OUT;
}
// output timeout setup
// if timeout is 0 then it is non-block mode
// if timeout is -1 then it is block mode
// if timeout is positive value then it is timeout time in ms
if (block_timeout) {
param = &output_block;
ret = mpi->control(ctx, MPP_SET_OUTPUT_BLOCK, param);
// NOTE: timeout value please refer to MppPollType definition
// 0 - non-block call (default)
// -1 - block call
// +val - timeout value in ms
if (timeout) {
param = &timeout;
ret = mpi->control(ctx, MPP_SET_OUTPUT_TIMEOUT, param);
if (MPP_OK != ret) {
mpp_err("Failed to set blocking mode on MPI (code = %d).\n", ret);
goto MPP_TEST_OUT;
}
param = &block_timeout;
ret = mpi->control(ctx, MPP_SET_OUTPUT_BLOCK_TIMEOUT, param);
if (MPP_OK != ret) {
mpp_err("Failed to set blocking mode on MPI (code = %d).\n", ret);
mpp_err("Failed to set output timeout %d ret %d\n", timeout, ret);
goto MPP_TEST_OUT;
}
}

22
test/mpi_dec_multi_test.c
View File

@@ -386,8 +386,7 @@ void* mpi_dec_test_decode(void *cmd_ctx)
MpiCmd mpi_cmd = MPP_CMD_BASE;
MppParam param = NULL;
RK_U32 need_split = 1;
RK_U32 output_block = MPP_POLL_BLOCK;
RK_S64 block_timeout = cmd->timeout;
MppPollType timeout = cmd->timeout;
// paramter for resource malloc
RK_U32 width = cmd->width;
@@ -505,18 +504,15 @@ void* mpi_dec_test_decode(void *cmd_ctx)
goto MPP_TEST_OUT;
}
if (block_timeout) {
param = &output_block;
ret = mpi->control(ctx, MPP_SET_OUTPUT_BLOCK, param);
// NOTE: timeout value please refer to MppPollType definition
// 0 - non-block call (default)
// -1 - block call
// +val - timeout value in ms
if (timeout) {
param = &timeout;
ret = mpi->control(ctx, MPP_SET_OUTPUT_TIMEOUT, param);
if (MPP_OK != ret) {
mpp_err("Failed to set blocking mode on MPI (code = %d).\n", ret);
goto MPP_TEST_OUT;
}
param = &block_timeout;
ret = mpi->control(ctx, MPP_SET_OUTPUT_BLOCK_TIMEOUT, param);
if (MPP_OK != ret) {
mpp_err("Failed to set blocking mode on MPI (code = %d).\n", ret);
mpp_err("Failed to set output timeout %d ret %d\n", timeout, ret);
goto MPP_TEST_OUT;
}
}

22
test/mpi_dec_test.c
View File

@@ -431,8 +431,7 @@ int mpi_dec_test_decode(MpiDecTestCmd *cmd)
MpiCmd mpi_cmd = MPP_CMD_BASE;
MppParam param = NULL;
RK_U32 need_split = 1;
RK_U32 output_block = MPP_POLL_BLOCK;
RK_S64 block_timeout = cmd->timeout;
MppPollType timeout = cmd->timeout;
// paramter for resource malloc
RK_U32 width = cmd->width;
@@ -553,18 +552,15 @@ int mpi_dec_test_decode(MpiDecTestCmd *cmd)
goto MPP_TEST_OUT;
}
if (block_timeout) {
param = &output_block;
ret = mpi->control(ctx, MPP_SET_OUTPUT_BLOCK, param);
// NOTE: timeout value please refer to MppPollType definition
// 0 - non-block call (default)
// -1 - block call
// +val - timeout value in ms
if (timeout) {
param = &timeout;
ret = mpi->control(ctx, MPP_SET_OUTPUT_TIMEOUT, param);
if (MPP_OK != ret) {
mpp_err("Failed to set blocking mode on MPI (code = %d).\n", ret);
goto MPP_TEST_OUT;
}
param = &block_timeout;
ret = mpi->control(ctx, MPP_SET_OUTPUT_BLOCK_TIMEOUT, param);
if (MPP_OK != ret) {
mpp_err("Failed to set blocking mode on MPI (code = %d).\n", ret);
mpp_err("Failed to set output timeout %d ret %d\n", timeout, ret);
goto MPP_TEST_OUT;
}
}

38
test/mpi_rc2_test.c
View File

@@ -508,7 +508,7 @@ static MPP_RET mpi_rc_enc_init(MpiRc2TestCtx *ctx)
MppCtx *enc_ctx = &ctx->enc_ctx;
MppApi *enc_mpi;
MpiRcTestCmd *cmd = &ctx->cmd;
int block;
MppPollType block = MPP_POLL_NON_BLOCK;
MppCodingType type = cmd->type;
@@ -527,15 +527,14 @@ static MPP_RET mpi_rc_enc_init(MpiRc2TestCtx *ctx)
enc_mpi = ctx->enc_mpi;
block = 0;
ret = enc_mpi->control(*enc_ctx, MPP_SET_INPUT_BLOCK, (MppParam)&block);
ret = enc_mpi->control(*enc_ctx, MPP_SET_INPUT_TIMEOUT, (MppParam)&block);
if (MPP_OK != ret) {
mpp_err("enc_mpi->control MPP_SET_INPUT_BLOCK failed\n");
mpp_err("enc_mpi->control MPP_SET_INPUT_TIMEOUT failed\n");
goto MPP_TEST_OUT;
}
ret = enc_mpi->control(*enc_ctx, MPP_SET_OUTPUT_BLOCK, (MppParam)&block);
ret = enc_mpi->control(*enc_ctx, MPP_SET_OUTPUT_TIMEOUT, (MppParam)&block);
if (MPP_OK != ret) {
mpp_err("enc_mpi->control MPP_SET_OUTPUT_BLOCK failed\n");
mpp_err("enc_mpi->control MPP_SET_OUTPUT_TIMEOUT failed\n");
goto MPP_TEST_OUT;
}
@@ -704,7 +703,7 @@ static MPP_RET mpi_rc_post_dec_init(MpiRc2TestCtx *ctx)
MpiRcTestCmd *cmd = &ctx->cmd;
MppCodingType type = cmd->type;
RK_U32 need_split = 0;
int block;
MppPollType block = MPP_POLL_NON_BLOCK;
// decoder init
ret = mpp_create(&ctx->dec_ctx_post, &ctx->dec_mpi_post);
@@ -727,19 +726,18 @@ static MPP_RET mpi_rc_post_dec_init(MpiRc2TestCtx *ctx)
mpp_err("dec_mpi->control failed\n");
goto MPP_TEST_OUT;
}
block = 0;
ret = ctx->dec_mpi_post->control(ctx->dec_ctx_post, MPP_SET_INPUT_BLOCK,
ret = ctx->dec_mpi_post->control(ctx->dec_ctx_post, MPP_SET_INPUT_TIMEOUT,
(MppParam)&block);
if (MPP_OK != ret) {
mpp_err("dec_mpi->control dec MPP_SET_INPUT_BLOCK failed\n");
mpp_err("dec_mpi->control dec MPP_SET_INPUT_TIMEOUT failed\n");
goto MPP_TEST_OUT;
}
block = 1;
ret = ctx->dec_mpi_post->control(ctx->dec_ctx_post, MPP_SET_OUTPUT_BLOCK,
block = MPP_POLL_BLOCK;
ret = ctx->dec_mpi_post->control(ctx->dec_ctx_post, MPP_SET_OUTPUT_TIMEOUT,
(MppParam)&block);
if (MPP_OK != ret) {
mpp_err("dec_mpi->control MPP_SET_OUTPUT_BLOCK failed\n");
mpp_err("dec_mpi->control MPP_SET_OUTPUT_TIMEOUT failed\n");
goto MPP_TEST_OUT;
}
@@ -825,7 +823,7 @@ static MPP_RET mpi_rc_pre_dec_init(MpiRc2TestCtx *ctx)
MPP_RET ret = MPP_OK;
MpiRcTestCmd *cmd = &ctx->cmd;
RK_U32 need_split = 1;
RK_S32 block;
MppPollType block = MPP_POLL_NON_BLOCK;
MppApi *mpi = NULL;
// decoder init
@@ -850,18 +848,18 @@ static MPP_RET mpi_rc_pre_dec_init(MpiRc2TestCtx *ctx)
goto MPP_TEST_OUT;
}
block = 0;
ret = mpi->control(ctx->dec_ctx_pre, MPP_SET_INPUT_BLOCK, (MppParam)&block);
ret = mpi->control(ctx->dec_ctx_pre, MPP_SET_INPUT_TIMEOUT,
(MppParam)&block);
if (MPP_OK != ret) {
mpp_err("dec_mpi->control dec MPP_SET_INPUT_BLOCK failed\n");
mpp_err("dec_mpi->control dec MPP_SET_INPUT_TIMEOUT failed\n");
goto MPP_TEST_OUT;
}
block = 1;
ret = mpi->control(ctx->dec_ctx_pre, MPP_SET_OUTPUT_BLOCK,
block = MPP_POLL_BLOCK;
ret = mpi->control(ctx->dec_ctx_pre, MPP_SET_OUTPUT_TIMEOUT,
(MppParam)&block);
if (MPP_OK != ret) {
mpp_err("dec_mpi->control MPP_SET_OUTPUT_BLOCK failed\n");
mpp_err("dec_mpi->control MPP_SET_OUTPUT_TIMEOUT failed\n");
goto MPP_TEST_OUT;
}

30
test/mpi_rc_test.c
View File

@@ -417,8 +417,7 @@ static MPP_RET mpi_rc_codec(MpiRcTestCtx *ctx)
FILE *fp_stat = file->fp_stat;
RK_U8 *dec_in_buf = NULL;
RK_U32 need_split = 0;
RK_U32 block_input = 0;
RK_U32 block_output = 0;
MppPollType block = MPP_POLL_NON_BLOCK;
// base flow context
MppCtx enc_ctx = NULL;
@@ -514,16 +513,18 @@ static MPP_RET mpi_rc_codec(MpiRcTestCtx *ctx)
mpp_err("dec_mpi->control failed\n");
goto MPP_TEST_OUT;
}
block_input = 0;
block_output = 1;
ret = dec_mpi->control(dec_ctx, MPP_SET_INPUT_BLOCK, (MppParam)&block_input);
block = MPP_POLL_NON_BLOCK;
ret = dec_mpi->control(dec_ctx, MPP_SET_INPUT_TIMEOUT, (MppParam)&block);
if (MPP_OK != ret) {
mpp_err("dec_mpi->control dec MPP_SET_INPUT_BLOCK failed\n");
mpp_err("dec_mpi->control dec MPP_SET_INPUT_TIMEOUT failed\n");
goto MPP_TEST_OUT;
}
ret = dec_mpi->control(dec_ctx, MPP_SET_OUTPUT_BLOCK, (MppParam)&block_output);
block = MPP_POLL_BLOCK;
ret = dec_mpi->control(dec_ctx, MPP_SET_OUTPUT_TIMEOUT, (MppParam)&block);
if (MPP_OK != ret) {
mpp_err("dec_mpi->control MPP_SET_OUTPUT_BLOCK failed\n");
mpp_err("dec_mpi->control MPP_SET_OUTPUT_TIMEOUT failed\n");
goto MPP_TEST_OUT;
}
@@ -552,16 +553,17 @@ static MPP_RET mpi_rc_codec(MpiRcTestCtx *ctx)
mpp_err("mpp_create encoder failed\n");
goto MPP_TEST_OUT;
}
block_input = 0;
block_output = 0;
ret = enc_mpi->control(enc_ctx, MPP_SET_INPUT_BLOCK, (MppParam)&block_input);
block = MPP_POLL_NON_BLOCK;
ret = enc_mpi->control(enc_ctx, MPP_SET_INPUT_TIMEOUT, (MppParam)&block);
if (MPP_OK != ret) {
mpp_err("enc_mpi->control MPP_SET_INPUT_BLOCK failed\n");
mpp_err("enc_mpi->control MPP_SET_INPUT_TIMEOUT failed\n");
goto MPP_TEST_OUT;
}
ret = enc_mpi->control(enc_ctx, MPP_SET_OUTPUT_BLOCK, (MppParam)&block_output);
ret = enc_mpi->control(enc_ctx, MPP_SET_OUTPUT_TIMEOUT, (MppParam)&block);
if (MPP_OK != ret) {
mpp_err("enc_mpi->control MPP_SET_OUTPUT_BLOCK failed\n");
mpp_err("enc_mpi->control MPP_SET_OUTPUT_TIMEOUT failed\n");
goto MPP_TEST_OUT;
}

6
test/mpi_test.c
View File

@@ -45,7 +45,7 @@ int mpi_test()
MpiCmd cmd = MPP_CMD_BASE;
MppParam param = NULL;
RK_U32 output_block = 1;
MppPollType block = MPP_POLL_BLOCK;
RK_S32 i;
char *buf = NULL;
@@ -75,8 +75,8 @@ int mpi_test()
}
// NOTE: decoder do not need control function
cmd = MPP_SET_OUTPUT_BLOCK;
param = &output_block;
cmd = MPP_SET_OUTPUT_TIMEOUT;
param = &block;
ret = mpi->control(ctx, cmd, param);
if (MPP_OK != ret) {
mpp_err("mpi->control failed\n");