feat[mpp_dec]: Add jpeg put/get decode support

Signed-off-by: Herman Chen <herman.chen@rock-chips.com>
Change-Id: I2c183d6157b1bcca29cf8559dfe903c92d5ae1de

mpp/codec/inc/mpp_dec_impl.h

@@ -205,6 +205,7 @@ typedef union DecTaskStatus_u {
         RK_U32      info_task_gen_rdy : 1;
         RK_U32      curr_task_rdy     : 1;
         RK_U32      task_parsed_rdy   : 1;
+        RK_U32      mpp_in_frm_at_pkt : 1;
     };
 } DecTaskStatus;
 

mpp/codec/mpp_dec_debug.h

@@ -31,7 +31,7 @@
 
 #define dec_dbg_func(fmt, ...)          mpp_dec_dbg_f(MPP_DEC_DBG_FUNCTION, fmt, ## __VA_ARGS__)
 #define dec_dbg_status(fmt, ...)        mpp_dec_dbg_f(MPP_DEC_DBG_STATUS, fmt, ## __VA_ARGS__)
-#define dec_dbg_detail(fmt, ...)        mpp_dec_dbg(MPP_DEC_DBG_DETAIL, fmt, ## __VA_ARGS__)
+#define dec_dbg_detail(fmt, ...)        mpp_dec_dbg_f(MPP_DEC_DBG_DETAIL, fmt, ## __VA_ARGS__)
 #define dec_dbg_reset(fmt, ...)         mpp_dec_dbg(MPP_DEC_DBG_RESET, fmt, ## __VA_ARGS__)
 #define dec_dbg_notify(fmt, ...)        mpp_dec_dbg_f(MPP_DEC_DBG_NOTIFY, fmt, ## __VA_ARGS__)
 

mpp/codec/mpp_dec_normal.cpp

@@ -979,6 +979,16 @@ void *mpp_dec_advanced_thread(void *data)
         mpp_task_meta_get_packet(mpp_task, KEY_INPUT_PACKET, &packet);
         mpp_task_meta_get_frame (mpp_task, KEY_OUTPUT_FRAME,  &frame);
 
+        if (!frame && packet) {
+            MppMeta meta = mpp_packet_get_meta(packet);
+
+            if (meta) {
+                mpp_meta_get_frame(meta, KEY_OUTPUT_FRAME, &frame);
+                if (frame)
+                    task.status.mpp_in_frm_at_pkt = 1;
+            }
+        }
+
         if (NULL == packet || NULL == frame) {
             mpp_port_enqueue(input, mpp_task);
             task.status.mpp_pkt_in_rdy = 0;
@@ -1022,18 +1032,21 @@ void *mpp_dec_advanced_thread(void *data)
                 goto DEC_OUT;
             }
 
+            dec_dbg_detail("slot change %d\n", mpp_buf_slot_is_changed(frame_slots));
             if (mpp_buf_slot_is_changed(frame_slots)) {
                 size_t slot_size = mpp_buf_slot_get_size(frame_slots);
                 size_t buffer_size = mpp_buffer_get_size(output_buffer);
 
+                dec_dbg_detail("change size required %d vs input %d\n", slot_size, buffer_size);
                 if (slot_size == buffer_size) {
                     mpp_buf_slot_ready(frame_slots);
                 }
 
+                mpp_assert(slot_size <= buffer_size);
+
                 if (slot_size > buffer_size) {
                     mpp_err_f("required buffer size %d is larger than input buffer size %d\n",
                               slot_size, buffer_size);
-                    mpp_assert(slot_size <= buffer_size);
                 }
             }
 
@@ -1080,6 +1093,26 @@ void *mpp_dec_advanced_thread(void *data)
          * final user will release the mpp_frame they had input
          */
     DEC_OUT:
+        if (task.status.mpp_in_frm_at_pkt) {
+            mpp_list *list = mpp->mFrmOut;
+            MppMeta meta = mpp_frame_get_meta(frame);
+
+            if (meta)
+                mpp_meta_set_packet(meta, KEY_INPUT_PACKET, packet);
+
+            mpp_dbg_pts("output frame pts %lld\n", mpp_frame_get_pts(frame));
+
+            list->lock();
+            list->add_at_tail(&frame, sizeof(frame));
+            mpp->mFramePutCount++;
+            list->signal();
+            list->unlock();
+
+            mpp_port_enqueue(input, mpp_task);
+            mpp_task = NULL;
+
+            task.status.mpp_in_frm_at_pkt = 0;
+        } else {
             mpp_task_meta_set_packet(mpp_task, KEY_INPUT_PACKET, packet);
             mpp_port_enqueue(input, mpp_task);
             mpp_task = NULL;
@@ -1093,6 +1126,8 @@ void *mpp_dec_advanced_thread(void *data)
             // setup output task here
             mpp_port_enqueue(output, mpp_task);
             mpp_task = NULL;
+        }
+
         packet = NULL;
         frame = NULL;
 

mpp/inc/mpp.h

@@ -178,6 +178,8 @@ public:
     MppPort         mMppOutPort;
     MppTaskQueue    mInputTaskQueue;
     MppTaskQueue    mOutputTaskQueue;
+    RK_S32          mInputTaskCount;
+    RK_S32          mOutputTaskCount;
 
     MppPollType     mInputTimeout;
     MppPollType     mOutputTimeout;

mpp/mpp.cpp

@@ -108,6 +108,8 @@ Mpp::Mpp(MppCtx ctx)
       mMppOutPort(NULL),
       mInputTaskQueue(NULL),
       mOutputTaskQueue(NULL),
+      mInputTaskCount(1),
+      mOutputTaskCount(1),
       mInputTimeout(MPP_POLL_BUTT),
       mOutputTimeout(MPP_POLL_BUTT),
       mInputTask(NULL),
@@ -176,13 +178,13 @@ MPP_RET Mpp::init(MppCtxType type, MppCodingType coding)
             mpp_buffer_group_get_internal(&mPacketGroup, MPP_BUFFER_TYPE_ION | MPP_BUFFER_FLAGS_CACHABLE);
             mpp_buffer_group_limit_config(mPacketGroup, 0, 3);
 
-            mpp_task_queue_setup(mInputTaskQueue, 4);
+            mInputTaskCount = 4;
-            mpp_task_queue_setup(mOutputTaskQueue, 4);
+            mOutputTaskCount = 4;
-        } else {
-            mpp_task_queue_setup(mInputTaskQueue, 1);
-            mpp_task_queue_setup(mOutputTaskQueue, 1);
         }
 
+        mpp_task_queue_setup(mInputTaskQueue, mInputTaskCount);
+        mpp_task_queue_setup(mOutputTaskQueue, mOutputTaskCount);
+
         mUsrInPort  = mpp_task_queue_get_port(mInputTaskQueue,  MPP_PORT_INPUT);
         mUsrOutPort = mpp_task_queue_get_port(mOutputTaskQueue, MPP_PORT_OUTPUT);
         mMppInPort  = mpp_task_queue_get_port(mInputTaskQueue,  MPP_PORT_OUTPUT);
@@ -223,13 +225,14 @@ MPP_RET Mpp::init(MppCtxType type, MppCodingType coding)
         if (mInputTimeout == MPP_POLL_NON_BLOCK) {
             mEncAyncIo = 1;
 
-            input_task_count = check_frm_task_cnt_cap(coding);
+            mInputTaskCount = check_frm_task_cnt_cap(coding);
-            if (input_task_count == 1)
+            if (mInputTaskCount == 1)
                 mInputTimeout = MPP_POLL_BLOCK;
         }
+        mOutputTaskCount = 8;
 
-        mpp_task_queue_setup(mInputTaskQueue, input_task_count);
+        mpp_task_queue_setup(mInputTaskQueue, mInputTaskCount);
-        mpp_task_queue_setup(mOutputTaskQueue, 8);
+        mpp_task_queue_setup(mOutputTaskQueue, mOutputTaskCount);
 
         mUsrInPort  = mpp_task_queue_get_port(mInputTaskQueue,  MPP_PORT_INPUT);
         mUsrOutPort = mpp_task_queue_get_port(mOutputTaskQueue, MPP_PORT_OUTPUT);
@@ -388,6 +391,8 @@ MPP_RET Mpp::put_packet(MppPacket packet)
         put_packet(extra);
     }
 
+    /* non-jpeg mode - reserve extra task for incoming eos packet */
+    if (mInputTaskCount > 1) {
         if (!mEosTask) {
             /* handle eos packet on block mode */
             ret = poll(MPP_PORT_INPUT, MPP_POLL_BLOCK);
@@ -407,6 +412,7 @@ MPP_RET Mpp::put_packet(MppPacket packet)
             task_dequeue = mEosTask;
             mEosTask = NULL;
         }
+    }
 
     /* Use reserved task to send eos packet */
     if (mInputTask && !task_dequeue) {
@@ -441,8 +447,8 @@ MPP_RET Mpp::put_packet(MppPacket packet)
         ret = MPP_OK;
     } else {
         /* packet zero copy path */
-        mpp_log_f("not support zero copy path\n");
         timeout = MPP_POLL_BLOCK;
+        ret = MPP_OK;
     }
 
     /* setup task */
@@ -466,7 +472,7 @@ MPP_RET Mpp::put_packet(MppPacket packet)
     mPacketPutCount++;
 
     if (timeout && !pkt_copy)
-        ret = poll(MPP_PORT_INPUT, timeout);
+        poll(MPP_PORT_INPUT, timeout);
 
 RET:
     /* wait enqueued task finished */