Lines Matching refs:task
23 * Advanced task flow
24 * Advanced task flow introduces three concepts: port, task and item
28 * Port work like a queue. task will be dequeue from or enqueue to one port.
29 * On input side user will dequeue task from input port, setup task and enqueue task
31 * On output side user will dequeue task from output port, get the information from
32 * and then enqueue task back to output port.
36 * If mpp is work in sync mode on task enqueue function return the task has been done
37 * If mpp is work in async mode on task enqueue function return the task is just put
38 * on the task queue for process.
41 * Item indicates MppPacket or MppFrame which is contained in one task
45 * One mpp task queue has two ports: input and output
49 * But internally these two ports belongs to two task queue.
53 * Each port uses its task queue to communication
62 * Advance task work flow mode:
70 * b - dequeue(input, *task)
72 * d - enqueue(input, task) // when enqueue return the task is not done yet
76 * b - dequeue(output, *task)
78 * d - enqueue(output, task)
85 * b - dequeue(input, *task)
87 * d - enqueue(task) // when enqueue return the task is finished
124 * MppTask is descriptor of a task which send to mpp for process
140 * task_dequeue(ctx, PORT_INPUT, &task);
141 * task_put_item(task, MODE_INPUT, packet)
142 * task_enqueue(ctx, PORT_INPUT, task);
144 * task_dequeue(ctx, PORT_OUTPUT, &task);
145 * task_get_item(task, MODE_OUTPUT, &frame)
146 * task_enqueue(ctx, PORT_OUTPUT, task);
150 * task_dequeue(ctx, PORT_INPUT, &task);
151 * task_put_item(task, MODE_INPUT, packet)
152 * task_put_item(task, MODE_OUTPUT, frame) // buffer will be specified here
153 * task_enqueue(ctx, PORT_INPUT, task);
155 * task_dequeue(ctx, PORT_OUTPUT, &task);
156 * task_get_item(task, MODE_OUTPUT, &frame)
157 * task_enqueue(ctx, PORT_OUTPUT, task);
173 * task_dequeue(ctx, PORT_INPUT, &task);
174 * task_put_item(task, MODE_INPUT, frame)
175 * task_enqueue(ctx, PORT_INPUT, task);
177 * task_dequeue(ctx, PORT_OUTPUT, &task);
178 * task_get_item(task, MODE_OUTPUT, &packet)
179 * task_enqueue(ctx, PORT_OUTPUT, task);
183 * task_dequeue(ctx, PORT_INPUT, &task);
184 * task_put_item(task, MODE_OUTPUT, packet) // buffer will be specified here
185 * task_put_item(task, MODE_INPUT, frame)
186 * task_enqueue(ctx, PORT_INPUT, task);
188 * task_dequeue(ctx, PORT_OUTPUT, &task);
189 * task_get_item(task, MODE_OUTPUT, &packet)
190 * task_get_item(task, MODE_OUTPUT, &frame)
191 * task_enqueue(ctx, PORT_OUTPUT, task);
194 * buffer at the input side. Then at output side when user gets a finished task user can get the output
205 * task_dequeue(ctx, PORT_INPUT, &task);
206 * task_put_item(task, MODE_INPUT, frame)
207 * task_enqueue(ctx, PORT_INPUT, task);
209 * task_dequeue(ctx, PORT_OUTPUT, &task);
210 * task_get_item(task, MODE_OUTPUT, &frame)
211 * task_enqueue(ctx, PORT_OUTPUT, task);
213 /* NOTE: use index rather then handle to descripbe task */
219 MPP_RET mpp_task_meta_set_s32(MppTask task, MppMetaKey key, RK_S32 val);
220 MPP_RET mpp_task_meta_set_s64(MppTask task, MppMetaKey key, RK_S64 val);
221 MPP_RET mpp_task_meta_set_ptr(MppTask task, MppMetaKey key, void *val);
222 MPP_RET mpp_task_meta_set_frame (MppTask task, MppMetaKey key, MppFrame frame);
223 MPP_RET mpp_task_meta_set_packet(MppTask task, MppMetaKey key, MppPacket packet);
224 MPP_RET mpp_task_meta_set_buffer(MppTask task, MppMetaKey key, MppBuffer buffer);
226 MPP_RET mpp_task_meta_get_s32(MppTask task, MppMetaKey key, RK_S32 *val, RK_S32 default_val);
227 MPP_RET mpp_task_meta_get_s64(MppTask task, MppMetaKey key, RK_S64 *val, RK_S64 default_val);
228 MPP_RET mpp_task_meta_get_ptr(MppTask task, MppMetaKey key, void **val, void *default_val);
229 MPP_RET mpp_task_meta_get_frame (MppTask task, MppMetaKey key, MppFrame *frame);
230 MPP_RET mpp_task_meta_get_packet(MppTask task, MppMetaKey key, MppPacket *packet);
231 MPP_RET mpp_task_meta_get_buffer(MppTask task, MppMetaKey key, MppBuffer *buffer);