Lines Matching refs:task
22 * Advanced task flow
23 * Advanced task flow introduces three concepts: port, task and item
27 * Port work like a queue. task will be dequeue from or enqueue to one port.
28 * On input side user will dequeue task from input port, setup task and enqueue task
30 * On output side user will dequeue task from output port, get the information from
31 * and then enqueue task back to output port.
35 * If mpp is work in sync mode on task enqueue function return the task has been done
36 * If mpp is work in async mode on task enqueue function return the task is just put
37 * on the task queue for process.
40 * Item indicates MppPacket or MppFrame which is contained in one task
44 * One mpp task queue has two ports: input and output
48 * But internally these two ports belongs to two task queue.
52 * Each port uses its task queue to communication
61 * Advance task work flow mode:
69 * b - dequeue(input, *task)
71 * d - enqueue(input, task) // when enqueue return the task is not done yet
75 * b - dequeue(output, *task)
77 * d - enqueue(output, task)
84 * b - dequeue(input, *task)
86 * d - enqueue(task) // when enqueue return the task is finished
123 * MppTask is descriptor of a task which send to mpp for process
139 * task_dequeue(ctx, PORT_INPUT, &task);
140 * task_put_item(task, MODE_INPUT, packet)
141 * task_enqueue(ctx, PORT_INPUT, task);
143 * task_dequeue(ctx, PORT_OUTPUT, &task);
144 * task_get_item(task, MODE_OUTPUT, &frame)
145 * task_enqueue(ctx, PORT_OUTPUT, task);
149 * task_dequeue(ctx, PORT_INPUT, &task);
150 * task_put_item(task, MODE_INPUT, packet)
151 * task_put_item(task, MODE_OUTPUT, frame) // buffer will be specified here
152 * task_enqueue(ctx, PORT_INPUT, task);
154 * task_dequeue(ctx, PORT_OUTPUT, &task);
155 * task_get_item(task, MODE_OUTPUT, &frame)
156 * task_enqueue(ctx, PORT_OUTPUT, task);
172 * task_dequeue(ctx, PORT_INPUT, &task);
173 * task_put_item(task, MODE_INPUT, frame)
174 * task_enqueue(ctx, PORT_INPUT, task);
176 * task_dequeue(ctx, PORT_OUTPUT, &task);
177 * task_get_item(task, MODE_OUTPUT, &packet)
178 * task_enqueue(ctx, PORT_OUTPUT, task);
182 * task_dequeue(ctx, PORT_INPUT, &task);
183 * task_put_item(task, MODE_OUTPUT, packet) // buffer will be specified here
184 * task_put_item(task, MODE_INPUT, frame)
185 * task_enqueue(ctx, PORT_INPUT, task);
187 * task_dequeue(ctx, PORT_OUTPUT, &task);
188 * task_get_item(task, MODE_OUTPUT, &packet)
189 * task_get_item(task, MODE_OUTPUT, &frame)
190 * task_enqueue(ctx, PORT_OUTPUT, task);
193 * buffer at the input side. Then at output side when user gets a finished task user can get the output
204 * task_dequeue(ctx, PORT_INPUT, &task);
205 * task_put_item(task, MODE_INPUT, frame)
206 * task_enqueue(ctx, PORT_INPUT, task);
208 * task_dequeue(ctx, PORT_OUTPUT, &task);
209 * task_get_item(task, MODE_OUTPUT, &frame)
210 * task_enqueue(ctx, PORT_OUTPUT, task);
212 /* NOTE: use index rather then handle to descripbe task */
218 MPP_RET mpp_task_meta_set_s32(MppTask task, MppMetaKey key, RK_S32 val);
219 MPP_RET mpp_task_meta_set_s64(MppTask task, MppMetaKey key, RK_S64 val);
220 MPP_RET mpp_task_meta_set_ptr(MppTask task, MppMetaKey key, void *val);
221 MPP_RET mpp_task_meta_set_frame (MppTask task, MppMetaKey key, MppFrame frame);
222 MPP_RET mpp_task_meta_set_packet(MppTask task, MppMetaKey key, MppPacket packet);
223 MPP_RET mpp_task_meta_set_buffer(MppTask task, MppMetaKey key, MppBuffer buffer);
225 MPP_RET mpp_task_meta_get_s32(MppTask task, MppMetaKey key, RK_S32 *val, RK_S32 default_val);
226 MPP_RET mpp_task_meta_get_s64(MppTask task, MppMetaKey key, RK_S64 *val, RK_S64 default_val);
227 MPP_RET mpp_task_meta_get_ptr(MppTask task, MppMetaKey key, void **val, void *default_val);
228 MPP_RET mpp_task_meta_get_frame (MppTask task, MppMetaKey key, MppFrame *frame);
229 MPP_RET mpp_task_meta_get_packet(MppTask task, MppMetaKey key, MppPacket *packet);
230 MPP_RET mpp_task_meta_get_buffer(MppTask task, MppMetaKey key, MppBuffer *buffer);