[mpp_enc]: fix memory leak and flow error in Android recording flow

git-svn-id: https://10.10.10.66:8443/svn/MediaProcessPlatform/trunk/mpp@1068 6e48237b-75ef-9749-8fc9-41990f28c85a

mpp/base/mpp_meta.cpp

@@ -316,6 +316,7 @@ static MPP_RET get_val_by_key(MppMetaImpl *meta, MppMetaKey key, MppMetaType typ
     MppMetaNode *node = service->find_node(meta, index);
     if (node) {
         *val = node->val;
+        service->put_node(node);
         ret = MPP_OK;
     }
     return ret;

mpp/base/mpp_task_impl.cpp

@@ -282,7 +282,8 @@ MPP_RET mpp_task_queue_deinit(MppTaskQueue queue)
     if (p->tasks) {
         for (RK_S32 i = 0; i < p->task_count; i++) {
             /* we must ensure that all task return to init status */
-            mpp_assert(p->tasks[i].status == MPP_INPUT_PORT);
+            mpp_assert(p->tasks[i].status == MPP_INPUT_PORT ||
+                       p->tasks[i].status == MPP_INPUT_HOLD);
             mpp_meta_put(p->tasks[i].meta);
         }
         mpp_free(p->tasks);

mpp/codec/mpp_enc.cpp

@@ -28,7 +28,7 @@
 #include "mpp_packet_impl.h"
 #include "hal_h264e_api.h"
 
-static MPP_RET release_task_in_port(MppPort output)
+static MPP_RET release_task_in_port(MppPort port)
 {
     MPP_RET ret = MPP_OK;
     MppPacket packet = NULL;
@@ -36,23 +36,26 @@ static MPP_RET release_task_in_port(MppPort output)
     MppTask mpp_task;
 
     do {
-        ret = mpp_port_dequeue(output, &mpp_task);
+        ret = mpp_port_dequeue(port, &mpp_task);
         if (ret)
             break;
 
         if (mpp_task) {
             packet = NULL;
             frame = NULL;
-            mpp_task_meta_get_frame (mpp_task, MPP_META_KEY_INPUT_FRM,  &frame);
+            ret = mpp_task_meta_get_frame(mpp_task, MPP_META_KEY_INPUT_FRM,  &frame);
             if (frame) {
                 mpp_frame_deinit(&frame);
                 frame = NULL;
             }
-            mpp_task_meta_get_packet(mpp_task, MPP_META_KEY_OUTPUT_PKT, &packet);
+            ret = mpp_task_meta_get_packet(mpp_task, MPP_META_KEY_OUTPUT_PKT, &packet);
             if (packet) {
-                mpp_frame_deinit(&packet);
+                mpp_packet_deinit(&packet);
                 packet = NULL;
             }
+
+            mpp_port_enqueue(port, mpp_task);
+            mpp_task = NULL;
         } else
             break;
     } while (1);
@@ -134,13 +137,17 @@ void *mpp_enc_control_thread(void *data)
             if (mpp_frame_get_eos(frame))
                 mpp_packet_set_eos(packet);
 
-            // enqueue task back to input input
+            /*
+             * first clear output packet
+             * then enqueue task back to input port
+             * final user will release the mpp_frame they had input
+             */
+            mpp_task_meta_set_frame(mpp_task, MPP_META_KEY_INPUT_FRM, frame);
             mpp_port_enqueue(input, mpp_task);
             mpp_task = NULL;
 
             // send finished task to output port
             mpp_port_dequeue(output, &mpp_task);
-            mpp_task_meta_set_frame(mpp_task,  MPP_META_KEY_INPUT_FRM,  frame);
             mpp_task_meta_set_packet(mpp_task, MPP_META_KEY_OUTPUT_PKT, packet);
 
             {
@@ -162,6 +169,7 @@ void *mpp_enc_control_thread(void *data)
     }
 
     // clear remain task in output port
+    release_task_in_port(mpp->mInputPort);
     release_task_in_port(input);
     release_task_in_port(mpp->mOutputPort);
 

mpp/mpp.cpp

@@ -60,6 +60,7 @@ Mpp::Mpp()
       mInputBlock(0),
       mOutputBlock(0),
       mMultiFrame(0),
+      mInputTask(NULL),
       mStatus(0),
       mParserFastMode(0),
       mParserNeedSplit(0),
@@ -282,7 +283,7 @@ MPP_RET Mpp::put_frame(MppFrame frame)
         return MPP_NOK;
 
     MPP_RET ret = MPP_NOK;
-    MppTask task = NULL;
+    MppTask task = mInputTask;
 
     do {
         if (NULL == task) {
@@ -317,11 +318,26 @@ MPP_RET Mpp::put_frame(MppFrame frame)
             while (MPP_NOK == mpp_port_can_dequeue(mInputPort)) {
                 msleep(2);
             }
+
+            ret = dequeue(MPP_PORT_INPUT, &task);
+            if (ret) {
+                mpp_log_f("failed to dequeue from input port ret %d\n", ret);
+                break;
+            }
+
+            mpp_assert(task);
+            ret = mpp_task_meta_get_frame(task, MPP_META_KEY_INPUT_FRM, &frame);
+            if (frame) {
+                mpp_frame_deinit(&frame);
+                frame = NULL;
+            }
         }
 
         break;
     } while (1);
 
+    mInputTask = task;
+
     return ret;
 }
 
@@ -332,7 +348,6 @@ MPP_RET Mpp::get_packet(MppPacket *packet)
 
     MPP_RET ret = MPP_OK;
     MppTask task = NULL;
-    MppFrame frame = NULL;
 
     do {
         if (NULL == task) {
@@ -355,12 +370,6 @@ MPP_RET Mpp::get_packet(MppPacket *packet)
 
         mpp_assert(task);
 
-        mpp_task_meta_get_frame(task, MPP_META_KEY_INPUT_FRM, &frame);
-        if (frame) {
-            mpp_frame_deinit(&frame);
-            frame = NULL;
-        }
-
         ret = mpp_task_meta_get_packet(task, MPP_META_KEY_OUTPUT_PKT, packet);
         if (ret) {
             mpp_log_f("failed to get output packet from task ret %d\n", ret);

mpp/mpp.h

@@ -136,6 +136,9 @@ private:
     RK_U32          mOutputBlock;
     RK_U32          mMultiFrame;
 
+    // task for put_frame / put_packet
+    MppTask         mInputTask;
+
     RK_U32          mStatus;
 
     /* decoder paramter before init */