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_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())

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, 
} 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, 
} VdoFormat;

static inline gboolean
vdo_format_is_encoded(VdoFormat format)
{
    return (format == VDO_FORMAT_H264 ||
            format == VDO_FORMAT_H265 ||
            format == VDO_FORMAT_JPEG);
}

static inline gboolean
vdo_format_is_motion_encoded(VdoFormat format)
{
    return (vdo_format_is_encoded(format) &&
            format != VDO_FORMAT_JPEG);
}

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_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,       
    VDO_FRAME_TYPE_H264_SPS,   
    VDO_FRAME_TYPE_H264_PPS,   
    VDO_FRAME_TYPE_H264_SEI,   
    VDO_FRAME_TYPE_H264_IDR,   
    VDO_FRAME_TYPE_H264_I,     
    VDO_FRAME_TYPE_H264_P,     
    VDO_FRAME_TYPE_H264_B,     
    VDO_FRAME_TYPE_H265_SPS,   
    VDO_FRAME_TYPE_H265_PPS,   
    VDO_FRAME_TYPE_H265_VPS,   
    VDO_FRAME_TYPE_H265_SEI,   
    VDO_FRAME_TYPE_H265_IDR,   
    VDO_FRAME_TYPE_H265_I,     
    VDO_FRAME_TYPE_H265_P,     
    VDO_FRAME_TYPE_H265_B,     
    VDO_FRAME_TYPE_JPEG,       
    VDO_FRAME_TYPE_YUV,        
    VDO_FRAME_TYPE_RAW,        
    VDO_FRAME_TYPE_RGBA,       
    VDO_FRAME_TYPE_RGB,        
    VDO_FRAME_TYPE_PLANAR_RGB, 
} 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_CHUNK_NONE  = 0u,        
    VDO_CHUNK_ERROR = 1u << 31u, 
} VdoChunkType;

typedef struct {
    gpointer     data;
    gsize        size;
    VdoChunkType type;
} VdoChunk;

static inline gboolean
vdo_frame_is_encoded(VdoFrameType type)
{
    return (type >= VDO_FRAME_TYPE_H264_SPS &&
            type <= VDO_FRAME_TYPE_JPEG);
}

static inline VdoFormat
vdo_frame_is_of_format(VdoFrameType type)
{
    switch (type) {
    case VDO_FRAME_TYPE_H264_SPS:
    case VDO_FRAME_TYPE_H264_PPS:
    case VDO_FRAME_TYPE_H264_SEI:
    case VDO_FRAME_TYPE_H264_IDR:
    case VDO_FRAME_TYPE_H264_I:
    case VDO_FRAME_TYPE_H264_P:
    case VDO_FRAME_TYPE_H264_B:
        return VDO_FORMAT_H264;

    case VDO_FRAME_TYPE_H265_SPS:
    case VDO_FRAME_TYPE_H265_PPS:
    case VDO_FRAME_TYPE_H265_VPS:
    case VDO_FRAME_TYPE_H265_SEI:
    case VDO_FRAME_TYPE_H265_IDR:
    case VDO_FRAME_TYPE_H265_I:
    case VDO_FRAME_TYPE_H265_P:
    case VDO_FRAME_TYPE_H265_B:
        return VDO_FORMAT_H265;

    case VDO_FRAME_TYPE_JPEG:
        return VDO_FORMAT_JPEG;

    case VDO_FRAME_TYPE_YUV:
        return VDO_FORMAT_YUV;

    case VDO_FRAME_TYPE_RAW:
        return VDO_FORMAT_RAW;

    case VDO_FRAME_TYPE_RGBA:
        return VDO_FORMAT_RGBA;

    case VDO_FRAME_TYPE_RGB:
        return VDO_FORMAT_RGB;

    case VDO_FRAME_TYPE_PLANAR_RGB:
        return VDO_FORMAT_PLANAR_RGB;

    default:
        return VDO_FORMAT_NONE;
    }
}

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;

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_INVALID    = ~0u,   
} 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;
    VdoResolution resolutions[];
} VdoResolutionSet;

typedef struct {
    guint width;
    guint height;
    guint x;
    guint y;
} VdoRect;

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_zipstream_profile_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_color_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