vx_khr_pipelining.h

Go to the documentation of this file.

/*
 * Copyright (c) 2012-2025 The Khronos Group Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef _OPENVX_PIPELINING_H_
#define _OPENVX_PIPELINING_H_

#define OPENVX_KHR_PIPELINING  "vx_khr_pipelining"

#include <VX/vx.h>

#ifdef  __cplusplus
extern "C" {
#endif


#define VX_TIMEOUT_WAIT_FOREVER ((vx_uint32)0xFFFFFFFFU)

/*
 * PIPELINING API
 */

#define VX_LIBRARY_KHR_PIPELINING_EXTENSION (0x1)

enum vx_graph_schedule_mode_enum_e
{
    VX_ENUM_GRAPH_SCHEDULE_MODE_TYPE     = 0x21, 
};

enum vx_graph_schedule_mode_type_e {

    VX_GRAPH_SCHEDULE_MODE_NORMAL = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_GRAPH_SCHEDULE_MODE_TYPE) + 0x0,

    VX_GRAPH_SCHEDULE_MODE_QUEUE_AUTO = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_GRAPH_SCHEDULE_MODE_TYPE) + 0x1,

    VX_GRAPH_SCHEDULE_MODE_QUEUE_MANUAL = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_GRAPH_SCHEDULE_MODE_TYPE) + 0x2,
};

enum vx_graph_attribute_pipelining_e {
    VX_GRAPH_SCHEDULE_MODE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_GRAPH) + 0x5,

    VX_GRAPH_TIMEOUT = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_GRAPH) + 0x6,

    VX_GRAPH_EVENT_TIMEOUT = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_GRAPH) + 0x7,

    VX_GRAPH_PIPELINE_DEPTH = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_GRAPH) + 0x8,
};

enum vx_reference_attribute_pipelining_e {
    VX_REFERENCE_ENQUEUE_COUNT = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_REFERENCE) + 0x3,
};

typedef struct _vx_graph_parameter_queue_params_t {

    uint32_t graph_parameter_index;
    vx_uint32 refs_list_size;
    vx_reference *refs_list;
} vx_graph_parameter_queue_params_t;

typedef struct _vx_graph_parameter_config_t {
    vx_uint32    index;
    vx_enum      type;
    vx_enum      direction;
    vx_enum      state;
    vx_uint32    refs_list_size;
} vx_graph_parameter_config_t;

VX_API_ENTRY vx_status VX_API_CALL vxSetGraphScheduleConfig(
    vx_graph graph,
    vx_enum graph_schedule_mode,
    vx_uint32 graph_parameters_list_size,
    const vx_graph_parameter_queue_params_t graph_parameters_queue_params_list[]
    );

VX_API_ENTRY vx_status VX_API_CALL vxGetGraphParameterRefsList(
    vx_graph     graph,
    vx_uint32    param,
    vx_uint32    ref_list_size,
    vx_reference refs_list[]
    );

VX_API_ENTRY vx_status VX_API_CALL vxAddReferencesToGraphParameterList(
    vx_graph                 graph,
    vx_uint32                graph_parameter_index,
    vx_uint32                number_to_add,
    const vx_reference       new_references[]
    );

VX_API_ENTRY vx_status VX_API_CALL vxGraphParameterEnqueueReadyRef(vx_graph graph,
                vx_uint32 graph_parameter_index,
                const vx_reference *refs,
                vx_uint32 num_refs);

VX_API_ENTRY vx_status VX_API_CALL vxGraphParameterDequeueDoneRef(vx_graph graph,
            vx_uint32 graph_parameter_index,
            vx_reference *refs,
            vx_uint32 max_refs,
            vx_uint32 *num_refs);

VX_API_ENTRY vx_status VX_API_CALL vxGraphParameterCheckDoneRef(vx_graph graph,
            vx_uint32 graph_parameter_index,
            vx_uint32 *num_refs);

/*
 * EVENT QUEUE API
 */

enum vx_event_enum_e
{
    VX_ENUM_EVENT_TYPE     = 0x22, 
};

enum vx_context_attribute_event_e {
    VX_CONTEXT_EVENT_TIMEOUT = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_CONTEXT) + 0x10,
};

enum vx_event_type_e {

    VX_EVENT_GRAPH_PARAMETER_CONSUMED = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_EVENT_TYPE) + 0x0,

    VX_EVENT_GRAPH_COMPLETED = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_EVENT_TYPE) + 0x1,

    VX_EVENT_NODE_COMPLETED = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_EVENT_TYPE) + 0x2,

    VX_EVENT_NODE_ERROR = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_EVENT_TYPE) + 0x3,

    VX_EVENT_USER = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_EVENT_TYPE) + 0x4,
};

typedef struct _vx_event_graph_parameter_consumed {

    vx_graph graph;
    vx_uint32 graph_parameter_index;
} vx_event_graph_parameter_consumed;

typedef struct _vx_event_graph_completed {

    vx_graph graph;
} vx_event_graph_completed;

typedef struct _vx_event_node_completed {

    vx_graph graph;
    vx_node node;
} vx_event_node_completed;

typedef struct _vx_event_node_error {

    vx_graph graph;
    vx_node node;
    vx_status status;
} vx_event_node_error;

typedef struct _vx_event_user_event {

    void *user_event_parameter;
} vx_event_user_event;

typedef union _vx_event_info_t {

    vx_event_graph_parameter_consumed graph_parameter_consumed;
    vx_event_graph_completed graph_completed;
    vx_event_node_completed node_completed;
    vx_event_node_error node_error;
    vx_event_user_event user_event;
} vx_event_info_t;


typedef struct _vx_event {

    vx_enum type;
    vx_uint64 timestamp;
    vx_uint32 app_value;
    vx_event_info_t event_info;
} vx_event_t;

VX_API_ENTRY vx_status VX_API_CALL vxWaitEvent(vx_context context, vx_event_t *event, vx_bool do_not_block);

VX_API_ENTRY vx_status VX_API_CALL vxEnableEvents(vx_context context);

VX_API_ENTRY vx_status VX_API_CALL vxDisableEvents(vx_context context);

VX_API_ENTRY vx_status VX_API_CALL vxSendUserEvent(vx_context context, vx_uint32 app_value, const void *parameter);


VX_API_ENTRY vx_status VX_API_CALL vxRegisterEvent(vx_reference ref, enum vx_event_type_e type, vx_uint32 param, vx_uint32 app_value);

VX_API_ENTRY vx_status VX_API_CALL vxRegisterGraphEvent(vx_reference graph_or_node, enum vx_event_type_e type, vx_uint32 param, vx_uint32 app_value);

VX_API_ENTRY vx_status VX_API_CALL vxWaitGraphEvent(vx_graph graph, vx_event_t * event, vx_bool do_not_block);

VX_API_ENTRY vx_status VX_API_CALL vxEnableGraphEvents(vx_graph graph);

VX_API_ENTRY vx_status VX_API_CALL vxDisableGraphEvents(vx_graph graph);

VX_API_ENTRY vx_status VX_API_CALL vxSendUserGraphEvent(vx_graph graph, vx_uint32 app_value, const void *parameter);

/*
 * STREAMING API
 */

enum vx_node_state_enum_e
{
    VX_ENUM_NODE_STATE_TYPE     = 0x23, 
};

enum vx_node_state_e {

    VX_NODE_STATE_STEADY  = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_NODE_STATE_TYPE) + 0x0,

    VX_NODE_STATE_PIPEUP  = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_NODE_STATE_TYPE) + 0x1,

};

enum vx_node_attribute_streaming_e {
    VX_NODE_STATE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_NODE) + 0x9,
};

enum vx_kernel_attribute_streaming_e {
    VX_KERNEL_PIPEUP_OUTPUT_DEPTH = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_KERNEL) + 0x4,

    VX_KERNEL_PIPEUP_INPUT_DEPTH = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_KERNEL) + 0x5,
};

VX_API_ENTRY vx_status VX_API_CALL vxEnableGraphStreaming(vx_graph graph, vx_node trigger_node);

VX_API_ENTRY vx_status VX_API_CALL vxStartGraphStreaming(vx_graph graph);


VX_API_ENTRY vx_status VX_API_CALL vxStopGraphStreaming(vx_graph graph);

/* Additional helper API */
typedef struct _vx_kernel_parameter_config_t {
    vx_uint32         index;        
    vx_enum           type;         
    vx_enum           direction;    
    vx_enum           state;        
    vx_meta_format    meta;         
} vx_kernel_parameter_config_t;

VX_API_ENTRY vx_status VX_API_CALL vxGetKernelParameterConfig(
    vx_kernel                                   kernel,
    vx_uint32                                   num_params,
    vx_kernel_parameter_config_t                parameter_config[]
    );

VX_API_ENTRY vx_status VX_API_CALL vxGetGraphParameterConfig(
    vx_graph                                    graph,
    vx_uint32                                   num_params,
    vx_graph_parameter_config_t                 parameter_config[]
    );

#ifdef  __cplusplus
}
#endif

#endif