1 /* 2 * 3 * Copyright 2015 Rockchip Electronics Co., LTD. 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 #ifndef __MPP_TASK_IMPL_H__ 19 #define __MPP_TASK_IMPL_H__ 20 21 #include "mpp_list.h" 22 #include "mpp_task.h" 23 24 typedef void* MppPort; 25 typedef void* MppTaskQueue; 26 27 /* 28 * mpp task status transaction 29 * 30 * mpp task is generated from mpp port. When create a mpp port the corresponding task 31 * will be created, too. Then external user will dequeue task from port and enqueue to 32 * mpp port for process. 33 * 34 * input port task work flow: 35 * 36 * description | call | status transaction 37 * 1. input port init | enqueue(external) | -> external_queue 38 * 2. input port user dequeue | dequeue(external) | external_queue -> external_hold 39 * 3. user setup task for processing| | 40 * 4. input port user enqueue | enqueue(external) | external_hold -> internal_queue 41 * 5. input port mpp start process | dequeue(internal) | internal_queue -> internal_hold 42 * 6. mpp process task | | 43 * 7. input port mpp task finish | enqueue(internal) | internal_hold -> external_queue 44 * loop to 2 45 * 46 * output port task work flow: 47 * description | call | status transaction 48 * 1. output port init | enqueue(internal) | -> internal_queue 49 * 2. output port mpp task dequeue | dequeue(internal) | internal_queue -> internal_hold 50 * 3. mpp setup task by processed frame/packet | 51 * 4. output port mpp task enqueue | enqueue(internal) | internal_hold -> external_queue 52 * 5. output port user task dequeue | dequeue(external) | external_queue -> external_hold 53 * 6. user get task as output | | 54 * 7. output port user release task | enqueue(external) | external_hold -> external_queue 55 * loop to 2 56 * 57 */ 58 typedef enum MppTaskStatus_e { 59 MPP_INPUT_PORT, /* in external queue and ready for external dequeue */ 60 MPP_INPUT_HOLD, /* dequeued and hold by external user, user will config */ 61 MPP_OUTPUT_PORT, /* in mpp internal work queue and ready for mpp dequeue */ 62 MPP_OUTPUT_HOLD, /* dequeued and hold by mpp internal worker, mpp is processing */ 63 MPP_TASK_STATUS_BUTT, 64 } MppTaskStatus; 65 66 typedef struct MppTaskImpl_t { 67 const char *name; 68 struct list_head list; 69 MppTaskQueue queue; 70 RK_S32 index; 71 MppTaskStatus status; 72 73 MppMeta meta; 74 } MppTaskImpl; 75 76 #ifdef __cplusplus 77 extern "C" { 78 #endif 79 80 MPP_RET check_mpp_task_name(MppTask task); 81 MPP_RET mpp_task_queue_init(MppTaskQueue *queue, void *mpp, const char *name); 82 MPP_RET mpp_task_queue_setup(MppTaskQueue queue, RK_S32 task_count); 83 MPP_RET mpp_task_queue_deinit(MppTaskQueue queue); 84 MppPort mpp_task_queue_get_port(MppTaskQueue queue, MppPortType type); 85 86 #define mpp_port_poll(port, timeout) _mpp_port_poll(__FUNCTION__, port, timeout) 87 #define mpp_port_dequeue(port, task) _mpp_port_dequeue(__FUNCTION__, port, task) 88 #define mpp_port_enqueue(port, task) _mpp_port_enqueue(__FUNCTION__, port, task) 89 #define mpp_port_awake(port) _mpp_port_awake(__FUNCTION__, port) 90 91 MPP_RET _mpp_port_poll(const char *caller, MppPort port, MppPollType timeout); 92 MPP_RET _mpp_port_dequeue(const char *caller, MppPort port, MppTask *task); 93 MPP_RET _mpp_port_enqueue(const char *caller, MppPort port, MppTask task); 94 MPP_RET _mpp_port_awake(const char *caller, MppPort port); 95 96 #ifdef __cplusplus 97 } 98 #endif 99 100 #endif /* __MPP_TASK_IMPL_H__ */ 101