package/mpp
1
0
Fork 0
mirror of https://github.com/nyanmisaka/mpp.git synced 2025-10-06 01:26:49 +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_BUTT = -2,
MPP_POLL_BLOCK = -1, MPP_POLL_BLOCK = -1,
MPP_POLL_NON_BLOCK = 0, MPP_POLL_NON_BLOCK = 0,
MPP_POLL_MAX = 1000, MPP_POLL_MAX = 8000,
} MppPollType; } 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 * MppTask is descriptor of a task which send to mpp for process
* mpp can support different type of work mode, for example: * 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_CMD_BASE = CMD_MODULE_MPP,
MPP_ENABLE_DEINTERLACE, MPP_ENABLE_DEINTERLACE,
MPP_SET_INPUT_BLOCK, MPP_SET_INPUT_BLOCK, /* deprecated */
MPP_SET_INTPUT_BLOCK_TIMEOUT, MPP_SET_INTPUT_BLOCK_TIMEOUT, /* deprecated */
MPP_SET_OUTPUT_BLOCK, MPP_SET_OUTPUT_BLOCK, /* deprecated */
MPP_SET_OUTPUT_BLOCK_TIMEOUT, 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_CMD_END,
MPP_CODEC_CMD_BASE = CMD_MODULE_CODEC, MPP_CODEC_CMD_BASE = CMD_MODULE_CODEC,

5
mpp/inc/mpp.h
View File

@@ -109,9 +109,8 @@ public:
MppTaskQueue mInputTaskQueue; MppTaskQueue mInputTaskQueue;
MppTaskQueue mOutputTaskQueue; MppTaskQueue mOutputTaskQueue;
MppPollType mInputBlock; MppPollType mInputTimeout;
MppPollType mOutputBlock; MppPollType mOutputTimeout;
RK_S64 mOutputBlockTimeout;
MppTask mInputTask; 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; MppPollType block = MPP_POLL_BLOCK;
/* setup input / output block mode */ /* 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) 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) { if (memGroup == NULL) {
ret = mpp_buffer_group_get_internal(&memGroup, MPP_BUFFER_TYPE_ION); 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; mpicmd = MPP_DEC_GET_VPUMEM_USED_COUNT;
} break; } break;
case VPU_API_SET_OUTPUT_BLOCK: { 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; } break;
case VPU_API_GET_EOS_STATUS: { case VPU_API_GET_EOS_STATUS: {
*((RK_S32 *)param) = mEosSet; *((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 * If there is frame to return get the frame first
* But if the output mode is block then we need to send packet 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); ret = mpp->get_frame(frame);
if (ret || *frame) if (ret || *frame)
break; break;
@@ -118,7 +118,7 @@ static MPP_RET mpi_decode(MppCtx ctx, MppPacket packet, MppFrame *frame)
break; break;
/* /*
* then send input stream with block mode * then send input stream with timeout mode
*/ */
ret = mpp->put_packet(packet); ret = mpp->put_packet(packet);
if (MPP_OK == ret) if (MPP_OK == ret)

72
mpp/mpp.cpp
View File

@@ -51,9 +51,8 @@ Mpp::Mpp()
mOutputPort(NULL), mOutputPort(NULL),
mInputTaskQueue(NULL), mInputTaskQueue(NULL),
mOutputTaskQueue(NULL), mOutputTaskQueue(NULL),
mInputBlock(MPP_POLL_NON_BLOCK), mInputTimeout(MPP_POLL_NON_BLOCK),
mOutputBlock(MPP_POLL_NON_BLOCK), mOutputTimeout(MPP_POLL_NON_BLOCK),
mOutputBlockTimeout(-1),
mInputTask(NULL), mInputTask(NULL),
mThreadCodec(NULL), mThreadCodec(NULL),
mThreadHal(NULL), mThreadHal(NULL),
@@ -294,8 +293,6 @@ MPP_RET Mpp::put_packet(MppPacket packet)
MPP_RET Mpp::get_frame(MppFrame *frame) MPP_RET Mpp::get_frame(MppFrame *frame)
{ {
RK_S32 ret;
if (!mInitDone) if (!mInitDone)
return MPP_ERR_INIT; return MPP_ERR_INIT;
@@ -303,20 +300,21 @@ MPP_RET Mpp::get_frame(MppFrame *frame)
MppFrame first = NULL; MppFrame first = NULL;
if (0 == mFrames->list_size()) { if (0 == mFrames->list_size()) {
if (mOutputBlock == MPP_POLL_BLOCK) { if (mOutputTimeout) {
if (mOutputBlockTimeout >= 0) { if (mOutputTimeout < 0) {
ret = mFrames->wait(mOutputBlockTimeout); /* block wait */
mFrames->wait();
} else {
RK_S32 ret = mFrames->wait(mOutputTimeout);
if (ret) { if (ret) {
if (ret == ETIMEDOUT) if (ret == ETIMEDOUT)
return MPP_ERR_TIMEOUT; return MPP_ERR_TIMEOUT;
else else
return MPP_NOK; return MPP_NOK;
} }
} else {
mFrames->wait();
} }
} else { } 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); msleep(1);
} }
} }
@@ -362,9 +360,9 @@ MPP_RET Mpp::put_frame(MppFrame frame)
if (mInputTask == NULL) { if (mInputTask == NULL) {
/* poll input port for valid task */ /* poll input port for valid task */
ret = poll(MPP_PORT_INPUT, mInputBlock); ret = poll(MPP_PORT_INPUT, mInputTimeout);
if (ret) { 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; goto RET;
} }
@@ -395,7 +393,7 @@ MPP_RET Mpp::put_frame(MppFrame frame)
/* wait enqueued task finished */ /* wait enqueued task finished */
ret = poll(MPP_PORT_INPUT, MPP_POLL_BLOCK); ret = poll(MPP_PORT_INPUT, MPP_POLL_BLOCK);
if (ret) { 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; goto RET;
} }
@@ -429,7 +427,7 @@ MPP_RET Mpp::get_packet(MppPacket *packet)
MPP_RET ret = MPP_OK; MPP_RET ret = MPP_OK;
MppTask task = NULL; MppTask task = NULL;
ret = poll(MPP_PORT_OUTPUT, mOutputBlock); ret = poll(MPP_PORT_OUTPUT, mOutputTimeout);
if (ret) { if (ret) {
// NOTE: Do not treat poll failure as error. Just clear output // NOTE: Do not treat poll failure as error. Just clear output
ret = MPP_OK; ret = MPP_OK;
@@ -655,17 +653,43 @@ MPP_RET Mpp::control_mpp(MpiCmd cmd, MppParam param)
MPP_RET ret = MPP_OK; MPP_RET ret = MPP_OK;
switch (cmd) { switch (cmd) {
case MPP_SET_INPUT_BLOCK: { case MPP_SET_INPUT_BLOCK :
MppPollType block = *((MppPollType *)param); case MPP_SET_OUTPUT_BLOCK :
mInputBlock = block; case MPP_SET_INTPUT_BLOCK_TIMEOUT :
case MPP_SET_OUTPUT_BLOCK_TIMEOUT : {
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; } break;
case MPP_SET_OUTPUT_BLOCK: {
MppPollType block = *((MppPollType *)param); case MPP_SET_INPUT_TIMEOUT:
mOutputBlock = block; case MPP_SET_OUTPUT_TIMEOUT: {
} break; MppPollType timeout = (param) ? *((MppPollType *)param) : MPP_POLL_NON_BLOCK;
case MPP_SET_OUTPUT_BLOCK_TIMEOUT: {
mOutputBlockTimeout = *((RK_S64 *)param); 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; } break;
default : { default : {
ret = MPP_NOK; ret = MPP_NOK;
} break; } 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; MpiCmd mpi_cmd = MPP_CMD_BASE;
MppParam param = NULL; MppParam param = NULL;
RK_U32 need_split = 1; RK_U32 need_split = 1;
RK_U32 output_block = MPP_POLL_BLOCK; MppPollType timeout = cmd->timeout;
RK_S64 block_timeout = cmd->timeout;
// paramter for resource malloc // paramter for resource malloc
RK_U32 width = cmd->width; RK_U32 width = cmd->width;
@@ -353,22 +352,15 @@ int mpi_dec_test_decode(MpiDecTestCmd *cmd)
goto MPP_TEST_OUT; goto MPP_TEST_OUT;
} }
// output timeout setup // NOTE: timeout value please refer to MppPollType definition
// if timeout is 0 then it is non-block mode // 0 - non-block call (default)
// if timeout is -1 then it is block mode // -1 - block call
// if timeout is positive value then it is timeout time in ms // +val - timeout value in ms
if (block_timeout) { if (timeout) {
param = &output_block; param = &timeout;
ret = mpi->control(ctx, MPP_SET_OUTPUT_BLOCK, param); ret = mpi->control(ctx, MPP_SET_OUTPUT_TIMEOUT, param);
if (MPP_OK != ret) { 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;
}
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);
goto MPP_TEST_OUT; 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; MpiCmd mpi_cmd = MPP_CMD_BASE;
MppParam param = NULL; MppParam param = NULL;
RK_U32 need_split = 1; RK_U32 need_split = 1;
RK_U32 output_block = MPP_POLL_BLOCK; MppPollType timeout = cmd->timeout;
RK_S64 block_timeout = cmd->timeout;
// paramter for resource malloc // paramter for resource malloc
RK_U32 width = cmd->width; RK_U32 width = cmd->width;
@@ -505,18 +504,15 @@ void* mpi_dec_test_decode(void *cmd_ctx)
goto MPP_TEST_OUT; goto MPP_TEST_OUT;
} }
if (block_timeout) { // NOTE: timeout value please refer to MppPollType definition
param = &output_block; // 0 - non-block call (default)
ret = mpi->control(ctx, MPP_SET_OUTPUT_BLOCK, param); // -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) { 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;
}
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);
goto MPP_TEST_OUT; 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; MpiCmd mpi_cmd = MPP_CMD_BASE;
MppParam param = NULL; MppParam param = NULL;
RK_U32 need_split = 1; RK_U32 need_split = 1;
RK_U32 output_block = MPP_POLL_BLOCK; MppPollType timeout = cmd->timeout;
RK_S64 block_timeout = cmd->timeout;
// paramter for resource malloc // paramter for resource malloc
RK_U32 width = cmd->width; RK_U32 width = cmd->width;
@@ -553,18 +552,15 @@ int mpi_dec_test_decode(MpiDecTestCmd *cmd)
goto MPP_TEST_OUT; goto MPP_TEST_OUT;
} }
if (block_timeout) { // NOTE: timeout value please refer to MppPollType definition
param = &output_block; // 0 - non-block call (default)
ret = mpi->control(ctx, MPP_SET_OUTPUT_BLOCK, param); // -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) { 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;
}
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);
goto MPP_TEST_OUT; 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; MppCtx *enc_ctx = &ctx->enc_ctx;
MppApi *enc_mpi; MppApi *enc_mpi;
MpiRcTestCmd *cmd = &ctx->cmd; MpiRcTestCmd *cmd = &ctx->cmd;
int block; MppPollType block = MPP_POLL_NON_BLOCK;
MppCodingType type = cmd->type; MppCodingType type = cmd->type;
@@ -527,15 +527,14 @@ static MPP_RET mpi_rc_enc_init(MpiRc2TestCtx *ctx)
enc_mpi = ctx->enc_mpi; enc_mpi = ctx->enc_mpi;
block = 0; ret = enc_mpi->control(*enc_ctx, MPP_SET_INPUT_TIMEOUT, (MppParam)&block);
ret = enc_mpi->control(*enc_ctx, MPP_SET_INPUT_BLOCK, (MppParam)&block);
if (MPP_OK != ret) { 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; 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) { 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; goto MPP_TEST_OUT;
} }
@@ -704,7 +703,7 @@ static MPP_RET mpi_rc_post_dec_init(MpiRc2TestCtx *ctx)
MpiRcTestCmd *cmd = &ctx->cmd; MpiRcTestCmd *cmd = &ctx->cmd;
MppCodingType type = cmd->type; MppCodingType type = cmd->type;
RK_U32 need_split = 0; RK_U32 need_split = 0;
int block; MppPollType block = MPP_POLL_NON_BLOCK;
// decoder init // decoder init
ret = mpp_create(&ctx->dec_ctx_post, &ctx->dec_mpi_post); 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"); mpp_err("dec_mpi->control failed\n");
goto MPP_TEST_OUT; goto MPP_TEST_OUT;
} }
block = 0; ret = ctx->dec_mpi_post->control(ctx->dec_ctx_post, MPP_SET_INPUT_TIMEOUT,
ret = ctx->dec_mpi_post->control(ctx->dec_ctx_post, MPP_SET_INPUT_BLOCK,
(MppParam)&block); (MppParam)&block);
if (MPP_OK != ret) { 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; goto MPP_TEST_OUT;
} }
block = 1; block = MPP_POLL_BLOCK;
ret = ctx->dec_mpi_post->control(ctx->dec_ctx_post, MPP_SET_OUTPUT_BLOCK, ret = ctx->dec_mpi_post->control(ctx->dec_ctx_post, MPP_SET_OUTPUT_TIMEOUT,
(MppParam)&block); (MppParam)&block);
if (MPP_OK != ret) { 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; goto MPP_TEST_OUT;
} }
@@ -825,7 +823,7 @@ static MPP_RET mpi_rc_pre_dec_init(MpiRc2TestCtx *ctx)
MPP_RET ret = MPP_OK; MPP_RET ret = MPP_OK;
MpiRcTestCmd *cmd = &ctx->cmd; MpiRcTestCmd *cmd = &ctx->cmd;
RK_U32 need_split = 1; RK_U32 need_split = 1;
RK_S32 block; MppPollType block = MPP_POLL_NON_BLOCK;
MppApi *mpi = NULL; MppApi *mpi = NULL;
// decoder init // decoder init
@@ -850,18 +848,18 @@ static MPP_RET mpi_rc_pre_dec_init(MpiRc2TestCtx *ctx)
goto MPP_TEST_OUT; goto MPP_TEST_OUT;
} }
block = 0; ret = mpi->control(ctx->dec_ctx_pre, MPP_SET_INPUT_TIMEOUT,
ret = mpi->control(ctx->dec_ctx_pre, MPP_SET_INPUT_BLOCK, (MppParam)&block); (MppParam)&block);
if (MPP_OK != ret) { 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; goto MPP_TEST_OUT;
} }
block = 1; block = MPP_POLL_BLOCK;
ret = mpi->control(ctx->dec_ctx_pre, MPP_SET_OUTPUT_BLOCK, ret = mpi->control(ctx->dec_ctx_pre, MPP_SET_OUTPUT_TIMEOUT,
(MppParam)&block); (MppParam)&block);
if (MPP_OK != ret) { 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; 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; FILE *fp_stat = file->fp_stat;
RK_U8 *dec_in_buf = NULL; RK_U8 *dec_in_buf = NULL;
RK_U32 need_split = 0; RK_U32 need_split = 0;
RK_U32 block_input = 0; MppPollType block = MPP_POLL_NON_BLOCK;
RK_U32 block_output = 0;
// base flow context // base flow context
MppCtx enc_ctx = NULL; MppCtx enc_ctx = NULL;
@@ -514,16 +513,18 @@ static MPP_RET mpi_rc_codec(MpiRcTestCtx *ctx)
mpp_err("dec_mpi->control failed\n"); mpp_err("dec_mpi->control failed\n");
goto MPP_TEST_OUT; goto MPP_TEST_OUT;
} }
block_input = 0;
block_output = 1; block = MPP_POLL_NON_BLOCK;
ret = dec_mpi->control(dec_ctx, MPP_SET_INPUT_BLOCK, (MppParam)&block_input); ret = dec_mpi->control(dec_ctx, MPP_SET_INPUT_TIMEOUT, (MppParam)&block);
if (MPP_OK != ret) { 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; 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) { 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; goto MPP_TEST_OUT;
} }
@@ -552,16 +553,17 @@ static MPP_RET mpi_rc_codec(MpiRcTestCtx *ctx)
mpp_err("mpp_create encoder failed\n"); mpp_err("mpp_create encoder failed\n");
goto MPP_TEST_OUT; goto MPP_TEST_OUT;
} }
block_input = 0;
block_output = 0; block = MPP_POLL_NON_BLOCK;
ret = enc_mpi->control(enc_ctx, MPP_SET_INPUT_BLOCK, (MppParam)&block_input); ret = enc_mpi->control(enc_ctx, MPP_SET_INPUT_TIMEOUT, (MppParam)&block);
if (MPP_OK != ret) { 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; 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) { 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; goto MPP_TEST_OUT;
} }

6
test/mpi_test.c
View File

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