vdo-types.h

Go to the documentation of this file.

 
#ifndef __VDO_TYPES_H__
#define __VDO_TYPES_H__
 
#include <glib-object.h>
 
G_BEGIN_DECLS
 
#define VDO_TYPE_WDR_MODE (vdo_wdr_mode_get_type())
#define VDO_TYPE_FORMAT (vdo_format_get_type())
#define VDO_TYPE_H264_PROFILE (vdo_h264_profile_get_type())
#define VDO_TYPE_H265_PROFILE (vdo_h265_profile_get_type())
#define VDO_TYPE_AV1_PROFILE (vdo_av1_profile_get_type())
#define VDO_TYPE_RATE_CONTROL_MODE (vdo_rate_control_mode_get_type())
#define VDO_TYPE_RATE_CONTROL_PRIORITY (vdo_rate_control_priority_get_type())
#define VDO_TYPE_FRAME_TYPE (vdo_frame_type_get_type())
#define VDO_TYPE_TIMESTAMP (vdo_timestamp_get_type())
#define VDO_TYPE_BUFFER_ACCESS (vdo_buffer_access_get_type())
#define VDO_TYPE_BUFFER_STRATEGY (vdo_buffer_strategy_get_type())
#define VDO_TYPE_ZIPSTREAM_PROFILE (vdo_zipstream_profile_get_type())
#define VDO_TYPE_ZIPSTREAM_GDR (vdo_zipstream_gdr_get_type())
 
typedef enum {
    VDO_WDR_MODE_NONE   = -1, 
    VDO_WDR_MODE_LINEAR = 0, 
    VDO_WDR_MODE_2X     = 1, 
    VDO_WDR_MODE_3X     = 2, 
    VDO_WDR_MODE_4X     = 3, 
    VDO_WDR_MODE_SENSOR = 4, 
    VDO_WDR_MODE_OFF    = 5, 
    VDO_WDR_MODE_AUTO   = 6, 
} VdoWdrMode;
 
typedef enum {
    VDO_FORMAT_NONE  = -1, 
    VDO_FORMAT_H264  = 0, 
    VDO_FORMAT_H265  = 1, 
    VDO_FORMAT_JPEG  = 2, 
    VDO_FORMAT_YUV   = 3, 
    VDO_FORMAT_BAYER = 4, 
    VDO_FORMAT_IVS   = 5, 
    VDO_FORMAT_RAW   = 6, 
    VDO_FORMAT_RGBA  = 7, 
    VDO_FORMAT_RGB   = 8, 
    VDO_FORMAT_PLANAR_RGB = 9, 
    VDO_FORMAT_AV1   = 10, 
    VDO_FORMAT_AVIF  = 11, 
} VdoFormat;
 
static inline gboolean
vdo_format_is_encoded(VdoFormat format)
{
    return (format == VDO_FORMAT_H264 ||
            format == VDO_FORMAT_H265 ||
            format == VDO_FORMAT_AV1  ||
            format == VDO_FORMAT_AVIF ||
            format == VDO_FORMAT_JPEG);
}
 
static inline gboolean
vdo_format_is_motion_encoded(VdoFormat format)
{
    switch (format) {
    case VDO_FORMAT_AVIF:
    case VDO_FORMAT_JPEG:
        return FALSE;
    default:
        return vdo_format_is_encoded(format);
    }
}
 
typedef enum {
    VDO_H264_PROFILE_NONE     = -1,
    VDO_H264_PROFILE_BASELINE = 0, 
    VDO_H264_PROFILE_MAIN     = 1, 
    VDO_H264_PROFILE_HIGH     = 2, 
} VdoH264Profile;
 
typedef enum {
    VDO_H265_PROFILE_NONE    = -1,
    VDO_H265_PROFILE_MAIN    = 0, 
    VDO_H265_PROFILE_MAIN_10 = 1, 
} VdoH265Profile;
 
typedef enum {
    VDO_AV1_PROFILE_NONE    = -1, 
    VDO_AV1_PROFILE_MAIN    = 0,  
    VDO_AV1_PROFILE_MAIN_10 = 1,  
} VdoAV1Profile;
 
typedef enum {
    VDO_RATE_CONTROL_MODE_NONE = -1,
    VDO_RATE_CONTROL_MODE_CBR  = 0, 
    VDO_RATE_CONTROL_MODE_VBR  = 1, 
    VDO_RATE_CONTROL_MODE_MBR  = 2, 
    VDO_RATE_CONTROL_MODE_ABR  = 3, 
} VdoRateControlMode;
 
typedef enum {
    VDO_RATE_CONTROL_PRIORITY_NONE           = -1, 
    VDO_RATE_CONTROL_PRIORITY_FRAMERATE      = 0, 
    VDO_RATE_CONTROL_PRIORITY_QUALITY        = 1, 
    VDO_RATE_CONTROL_PRIORITY_FULL_FRAMERATE = 2, 
} VdoRateControlPriority;
 
typedef enum {
    VDO_FRAME_TYPE_NONE       =  0, 
    VDO_FRAME_TYPE_H264_SPS   =  1, 
    VDO_FRAME_TYPE_H264_PPS   =  2, 
    VDO_FRAME_TYPE_H264_SEI   =  3, 
    VDO_FRAME_TYPE_H264_IDR   =  4, 
    VDO_FRAME_TYPE_H264_I     =  5, 
    VDO_FRAME_TYPE_H264_P     =  6, 
    VDO_FRAME_TYPE_H264_B     =  7, 
    VDO_FRAME_TYPE_H265_SPS   =  8, 
    VDO_FRAME_TYPE_H265_PPS   =  9, 
    VDO_FRAME_TYPE_H265_VPS   = 10, 
    VDO_FRAME_TYPE_H265_SEI   = 11, 
    VDO_FRAME_TYPE_H265_IDR   = 12, 
    VDO_FRAME_TYPE_H265_I     = 13, 
    VDO_FRAME_TYPE_H265_P     = 14, 
    VDO_FRAME_TYPE_H265_B     = 15, 
    VDO_FRAME_TYPE_JPEG       = 16, 
    VDO_FRAME_TYPE_YUV        = 17, 
    VDO_FRAME_TYPE_RAW        = 18, 
    VDO_FRAME_TYPE_RGBA       = 19, 
    VDO_FRAME_TYPE_RGB        = 20, 
    VDO_FRAME_TYPE_PLANAR_RGB = 21, 
    VDO_FRAME_TYPE_AV1_KEY    = 22, 
    VDO_FRAME_TYPE_AV1_INTER  = 23, 
    VDO_FRAME_TYPE_AV1_BIDI   = 24, 
    VDO_FRAME_TYPE_AVIF       = 25, 
} VdoFrameType;
 
typedef enum {
    VDO_ZIPSTREAM_PROFILE_NONE     = -1, 
    VDO_ZIPSTREAM_PROFILE_CLASSIC  = 0, 
    VDO_ZIPSTREAM_PROFILE_STORAGE  = 1, 
    VDO_ZIPSTREAM_PROFILE_LIVE     = 2, 
} VdoZipStreamProfile;
 
typedef enum {
    VDO_ZIPSTREAM_GDR_NONE      = -1, 
    VDO_ZIPSTREAM_GDR_AUTO      = 0, 
    VDO_ZIPSTREAM_GDR_OFF       = 1, 
    VDO_ZIPSTREAM_GDR_BALANCED  = 2, 
    VDO_ZIPSTREAM_GDR_EXTREME   = 3, 
} VdoZipStreamGdr;
 
typedef enum {
    VDO_CHUNK_NONE  = 0u,        
    VDO_CHUNK_ERROR = 1u << 31u, 
} VdoChunkType;
 
typedef enum {
    VDO_CHUNK_OPTION_NONE = 0u,        
    VDO_CHUNK_OPTION_MMAP = 1u << 31u, 
} VdoChunkOption;
 
typedef struct {
    union __attribute__((__may_alias__)) {
        gpointer  data;   
        gchar*   chars;   
        guint8*  bytes;   
    };
    gsize        size;   
    VdoChunkType type;   
    gint64       offset; 
} VdoChunk;
 
static inline gboolean
vdo_frame_is_encoded(G_GNUC_UNUSED VdoFrameType type)
{
    return FALSE;
}
 
static inline VdoFormat
vdo_frame_is_of_format(G_GNUC_UNUSED VdoFrameType type)
{
    return VDO_FORMAT_NONE;
}
 
#ifndef AXISOS_13_PREVIEW
typedef enum {
    VDO_OVERLAY_ALIGN_NONE   = -1,
    VDO_OVERLAY_ALIGN_TOP    = 0,
    VDO_OVERLAY_ALIGN_BOTTOM = 1,
} VdoOverlayAlign;
 
typedef enum {
    VDO_OVERLAY_COLOR_TRANSPARENT = 0x0000,
    VDO_OVERLAY_COLOR_BLACK = 0xF000,
    VDO_OVERLAY_COLOR_WHITE = 0xFFFF,
} VdoOverlayColor;
 
typedef enum {
    VDO_OVERLAY_TEXT_SIZE_SMALL = 16,
    VDO_OVERLAY_TEXT_SIZE_MEDIUM = 32,
    VDO_OVERLAY_TEXT_SIZE_LARGE = 48,
} VdoOverlayTextSize;
#endif
 
typedef enum {
    VDO_TIMESTAMP_NONE = 0,
 
    VDO_TIMESTAMP_UTC  = 1,
 
    VDO_TIMESTAMP_ZIPSTREAM = 2,
    VDO_TIMESTAMP_DIFF = 4,
 
    VDO_TIMESTAMP_MONO_CAPTURE = 8,
 
    VDO_TIMESTAMP_MONO_SERVER = 16,
 
    VDO_TIMESTAMP_MONO_CLIENT = 32,
 
    VDO_TIMESTAMP_MONO_CLIENT_SERVER_DIFF =
        VDO_TIMESTAMP_DIFF | VDO_TIMESTAMP_MONO_CLIENT \
        | VDO_TIMESTAMP_MONO_SERVER,
 
    VDO_TIMESTAMP_MONO_CLIENT_CAPTURE_DIFF =
        VDO_TIMESTAMP_DIFF | VDO_TIMESTAMP_MONO_CLIENT \
        | VDO_TIMESTAMP_MONO_CAPTURE,
} VdoStreamTimestamp;
 
typedef enum {
    VDO_INTENT_NONE     = 0, 
    VDO_INTENT_CONTROL  = 1, 
    VDO_INTENT_MONITOR  = 2, 
    VDO_INTENT_CONSUME  = 4, 
    VDO_INTENT_PRODUCE  = 8, 
    VDO_INTENT_DEFAULT  = VDO_INTENT_CONSUME | VDO_INTENT_CONTROL, 
    VDO_INTENT_EVENTFD  = 16,  
    VDO_INTENT_UNIVERSE = ~0u, 
} VdoIntent;
 
typedef enum {
    VDO_STREAM_EVENT_NONE            = 0x00u, 
    VDO_STREAM_EVENT_STARTED         = 0x01u, 
    VDO_STREAM_EVENT_STOPPED         = 0x02u, 
    VDO_STREAM_EVENT_RESOURCE        = 0x10u, 
    VDO_STREAM_EVENT_QUOTA_SOFT      = 0x11u, 
    VDO_STREAM_EVENT_QUOTA_HARD      = 0x12u, 
    VDO_STREAM_EVENT_ZIPSTREAM       = 0x20u, 
    VDO_STREAM_EVENT_BUFFERING       = 0x40u, 
    VDO_STREAM_EVENT_BUFFERING_WARN  = 0x41u, 
    VDO_STREAM_EVENT_BUFFERING_FAIL  = 0x42u, 
    VDO_STREAM_EVENT_CREATED         = 0x50u, 
    VDO_STREAM_EVENT_CLOSED          = 0x51u, 
    VDO_STREAM_EVENT_EXISTING        = 0x52u, 
    VDO_STREAM_EVENT_INVALID         = ~0x0u, 
} VdoStreamEvent;
 
typedef enum {
    VDO_BUFFER_ACCESS_NONE   = 0u,
 
    VDO_BUFFER_ACCESS_CPU_RD = 1u << 0u,
 
    VDO_BUFFER_ACCESS_DEV_RD = 1u << 1u,
 
    VDO_BUFFER_ACCESS_ANY_RD = VDO_BUFFER_ACCESS_CPU_RD | VDO_BUFFER_ACCESS_DEV_RD,
 
    VDO_BUFFER_ACCESS_CPU_WR = 1u << 8u,
 
    VDO_BUFFER_ACCESS_DEV_WR = 1u << 9u,
 
    VDO_BUFFER_ACCESS_ANY_WR = VDO_BUFFER_ACCESS_CPU_WR | VDO_BUFFER_ACCESS_DEV_WR,
 
    VDO_BUFFER_ACCESS_CPU_RW = VDO_BUFFER_ACCESS_CPU_RD | VDO_BUFFER_ACCESS_CPU_WR,
 
    VDO_BUFFER_ACCESS_DEV_RW = VDO_BUFFER_ACCESS_DEV_RD | VDO_BUFFER_ACCESS_DEV_WR,
 
    VDO_BUFFER_ACCESS_ANY_RW = VDO_BUFFER_ACCESS_CPU_RW | VDO_BUFFER_ACCESS_DEV_RW,
} VdoBufferAccess;
 
typedef enum {
    VDO_BUFFER_STRATEGY_NONE     = 0,
 
 
    VDO_BUFFER_STRATEGY_INPUT    = 1,
 
    VDO_BUFFER_STRATEGY_EXTERNAL = 2,
 
    VDO_BUFFER_STRATEGY_EXPLICIT = 3,
 
    VDO_BUFFER_STRATEGY_INFINITE = 4,
} VdoBufferStrategy;
 
typedef struct {
    gpointer data;   
    gsize data_size; 
} VdoMemChunk;
 
typedef struct {
    guint32 width;  
    guint32 height; 
} VdoResolution;
 
typedef struct {
    gsize count; 
    __extension__ VdoResolution resolutions[]; 
} VdoResolutionSet;
 
typedef struct {
    guint width;  
    guint height; 
    guint x;      
    guint y;      
} VdoRect;
 
typedef union __attribute__((__may_alias__)) {
    __extension__ struct {gint32 x;   gint32 y;};
    __extension__ struct {gint32 w;   gint32 h;};
    __extension__ struct {gint32 num; gint32 den;};
    gint32 val[2];
} VdoPair32i;
 
typedef union __attribute__((__may_alias__)) {
    __extension__ struct {guint32 x;   guint32 y;};
    __extension__ struct {guint32 w;   guint32 h;};
    __extension__ struct {guint32 num; guint32 den;};
    VdoResolution res;
    guint32 val[2];
} VdoPair32u;
 
typedef union __attribute__((__may_alias__)) {
    __extension__ struct {gint32 x; gint32 y; gint32 w; gint32 h;};
    gint32 val[4];
} VdoQuad32i;
 
typedef union __attribute__((__may_alias__)) {
    __extension__ struct {guint32 x; guint32 y; guint32 w; guint32 h;};
    guint32 val[4];
} VdoQuad32u;
 
GType vdo_wdr_mode_get_type(void);
 
GType vdo_format_get_type(void);
 
GType vdo_h264_profile_get_type(void);
 
GType vdo_h265_profile_get_type(void);
 
GType vdo_av1_profile_get_type(void);
 
GType vdo_zipstream_profile_get_type(void);
 
GType vdo_zipstream_gdr_get_type(void);
 
GType vdo_rate_control_mode_get_type(void);
 
GType vdo_rate_control_priority_get_type(void);
 
GType vdo_frame_type_get_type(void);
 
GType vdo_timestamp_get_type(void);
 
GType vdo_intent_get_type(void);
 
GType vdo_buffer_access_get_type(void);
 
GType vdo_buffer_strategy_get_type(void);
 
const char *vdo_format_to_str(VdoFormat format);
 
G_END_DECLS
 
#endif