TDA4VM: tda4vm

Mufaddal Esmael

Part Number: TDA4VM

Referencing this earlier discussion with Lucas Weaver:

"You are welcome to use vxProcessGraph if you do just want to execute a single frame at a time. However, you can access each individual frame even with pipelining by making the output a graph parameter and dequeueing this buffer to the application."

Could you please help expand on this further. Does this involve creating an additional image variable as part of the app context and saving it here. For example using:

vxGraphParameterEnqueueReadyRef(obj->graph, 0, (vx_reference*)&(obj->cap_frames[buf_id]), 1); The last value can be changed to enqueue the number of outputs. Is there a way to write this or copy this buffer such that it can be made available external to the camera app as it is displaying within this application. How would I expand this to support multiple outputs.

Also is the sequence:

vxGraphParameterDequeueDoneRef. followed by

vxGraphParameterEnqueueReadyRef correct?

Please advise.

over 4 years ago

0 Lucas Weaver over 4 years ago

TI__Genius 13845 points

Hello Mufaddal,

I would recommend taking a look at the pipelining tutorial as well as the details about pipelining in TI OpenVX below if you haven't already.

https://software-dl.ti.com/jacinto7/esd/processor-sdk-rtos-jacinto7/latest/exports/docs/tiovx/docs/user_guide/vx__tutorial__graph__pipeline__two__nodes_8c.html

https://software-dl.ti.com/jacinto7/esd/processor-sdk-rtos-jacinto7/latest/exports/docs/tiovx/docs/user_guide/TIOVX_PIPELINING.html

Let me try to answer your questions below. Let me know if I need to clarify somewhere:

By creating an array of buffers in the OpenVX application, you can determine the buffer depth to be used for a particular image. In your provided API call of vxGraphParameterEnqueueReadyRef, the obj->cap_frames array is an array of vx_image buffers that can be enqueued to a particular parameter of the graph. Yes, the last value of this API can be used to enqueue a specified number of buffers, but typically we just do these one at a time in steady state as they are available from the graph
After the images have been dequeued from the graph, the application now has control of this buffer and so the buffer pointer can be mapped to the application using the standard OpenVx API's, such as the one below. This can now be accessed by the application. It will need to be unmapped prior to re-enqueueing to the graph
- https://www.khronos.org/registry/OpenVX/specs/1.1/html/df/d09/group__group__image.html#ga7f680c04462fcb05a0eae1a96dd923e3
Regarding multiple outputs, if you are referring here to having a larger buffer queue, this can simply be done by creating a larger array of image buffers and registering this value when setting up the graph parameters
Regarding the sequence of calls, yes, in steady state (after you have first enqueued all available buffers to the application), you will need to dequeue the completed buffer from the graph so that you can enqueue it back to the graph so that it is recycled and used upon the next process call.

Regards,

Lucas

Processors

Processors forum

TDA4VM: tda4vm