diff --git a/inc/mpp_task.h b/inc/mpp_task.h
index 0dad6c6c..808b807d 100644
--- a/inc/mpp_task.h
+++ b/inc/mpp_task.h
@@ -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:
diff --git a/inc/rk_mpi_cmd.h b/inc/rk_mpi_cmd.h
index df7dfa05..c0b894c8 100644
--- a/inc/rk_mpi_cmd.h
+++ b/inc/rk_mpi_cmd.h
@@ -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,
diff --git a/mpp/inc/mpp.h b/mpp/inc/mpp.h
index f439bddd..4d9a17e9 100644
--- a/mpp/inc/mpp.h
+++ b/mpp/inc/mpp.h
@@ -109,9 +109,8 @@ public:
     MppTaskQueue    mInputTaskQueue;
     MppTaskQueue    mOutputTaskQueue;
 
-    MppPollType     mInputBlock;
-    MppPollType     mOutputBlock;
-    RK_S64          mOutputBlockTimeout;
+    MppPollType     mInputTimeout;
+    MppPollType     mOutputTimeout;
 
     MppTask         mInputTask;
     /*
diff --git a/mpp/legacy/vpu_api_legacy.cpp b/mpp/legacy/vpu_api_legacy.cpp
index f23608f3..ccefe827 100644
--- a/mpp/legacy/vpu_api_legacy.cpp
+++ b/mpp/legacy/vpu_api_legacy.cpp
@@ -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;
diff --git a/mpp/mpi.cpp b/mpp/mpi.cpp
index 01fe43e8..56db43ca 100644
--- a/mpp/mpi.cpp
+++ b/mpp/mpi.cpp
@@ -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)
diff --git a/mpp/mpp.cpp b/mpp/mpp.cpp
index 17f1a582..b5e5d0e4 100644
--- a/mpp/mpp.cpp
+++ b/mpp/mpp.cpp
@@ -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;
+    case MPP_SET_INPUT_BLOCK :
+    case MPP_SET_OUTPUT_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;
-    case MPP_SET_OUTPUT_BLOCK: {
-        MppPollType block = *((MppPollType *)param);
-        mOutputBlock = block;
-    } break;
-    case MPP_SET_OUTPUT_BLOCK_TIMEOUT: {
-        mOutputBlockTimeout = *((RK_S64 *)param);
+
+    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;
diff --git a/test/mpi_dec_mt_test.c b/test/mpi_dec_mt_test.c
index 0b838e3a..bf3d42e3 100644
--- a/test/mpi_dec_mt_test.c
+++ b/test/mpi_dec_mt_test.c
@@ -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;
         }
     }
diff --git a/test/mpi_dec_multi_test.c b/test/mpi_dec_multi_test.c
index a1ef3354..c8acb891 100644
--- a/test/mpi_dec_multi_test.c
+++ b/test/mpi_dec_multi_test.c
@@ -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;
         }
     }
diff --git a/test/mpi_dec_test.c b/test/mpi_dec_test.c
index 686a5b89..2a33468d 100644
--- a/test/mpi_dec_test.c
+++ b/test/mpi_dec_test.c
@@ -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;
         }
     }
diff --git a/test/mpi_rc2_test.c b/test/mpi_rc2_test.c
index 7f27310d..5d87f662 100644
--- a/test/mpi_rc2_test.c
+++ b/test/mpi_rc2_test.c
@@ -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;
     }
 
diff --git a/test/mpi_rc_test.c b/test/mpi_rc_test.c
index 5c297161..32bb804a 100644
--- a/test/mpi_rc_test.c
+++ b/test/mpi_rc_test.c
@@ -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;
     }
 
diff --git a/test/mpi_test.c b/test/mpi_test.c
index dd82542e..ed8c3120 100644
--- a/test/mpi_test.c
+++ b/test/mpi_test.c
@@ -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");