types.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2013-2023 CESNET z.s.p.o.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, is permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * 3. Neither the name of CESNET nor the names of its contributors may be
 *    used to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
 * EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef TYPES_H_
#define TYPES_H_
 
#ifndef __cplusplus
#include <stdbool.h>
#endif
#include <stddef.h>
#include <stdint.h>
 
#ifdef __cplusplus
#include <string>
extern "C" {
#endif
 
typedef enum {
        VIDEO_CODEC_NONE = 0, 
        VC_NONE          = VIDEO_CODEC_NONE, // shortcut
        VIDEO_CODEC_FIRST,
        VC_FIRST = VIDEO_CODEC_FIRST,
        RGBA = VIDEO_CODEC_FIRST, 
        UYVY,     
        YUYV,     
        R10k,     
        R12L,     
        v210,     
        DVS10,    
        DXT1,     
        DXT1_YUV, 
        DXT5,     
        RGB,      
        JPEG,     
        RAW,      
        H264,     
        H265,     
        MJPG,     
        VP8,      
        VP9,      
        BGR,      
        J2K,      
        J2KR,     
        HW_VDPAU, 
        HFYU,     
        FFV1,     
        CFHD,     
        RG48,     
        AV1,      
        I420,     
        Y216,     
        Y416,     
        PRORES,           
        PRORES_4444,      
        PRORES_4444_XQ,   
        PRORES_422_HQ,    
        PRORES_422,       
        PRORES_422_PROXY, 
        PRORES_422_LT,    
        DRM_PRIME, 
        VIDEO_CODEC_COUNT, 
        VC_COUNT        = VIDEO_CODEC_COUNT,
        VC_END          = VIDEO_CODEC_COUNT,
        VIDEO_CODEC_END = VIDEO_CODEC_COUNT
} codec_t;
 
enum hw_accel_type {
        HWACCEL_NONE,
        HWACCEL_VDPAU,
        HWACCEL_VAAPI,
        HWACCEL_VIDEOTOOLBOX,
        HWACCEL_CUDA,
        HWACCEL_VULKAN,
        HWACCEL_DRM_PRIME,
        HWACCEL_COUNT
};
 
enum depth {
        DEPTH8  = 8,
        DEPTH10 = 10,
        DEPTH12 = 12,
        DEPTH16 = 16,
};
 
enum subsampling {
        SUBS_420  = 4200,
        SUBS_422  = 4220,
        SUBS_444  = 4440,
        SUBS_4444 = 4444,
};
 
struct pixfmt_desc {
        int depth;       
        int subsampling; 
        bool rgb;
        enum hw_accel_type accel_type;
};
 
enum {
        kHz8  = 8000,
        kHz48 = 48000,
        kHz90 = 90000, 
};
 
enum interlacing_t {
        PROGRESSIVE       = 0, 
        UPPER_FIELD_FIRST = 1, 
        LOWER_FIELD_FIRST = 2, 
        INTERLACED_MERGED = 3, 
        SEGMENTED_FRAME   = 4,  
        INTERLACING_MAX   = SEGMENTED_FRAME,
};
 
struct video_desc {
        unsigned int         width;  
        unsigned int         height; 
 
        codec_t              color_spec;
        double               fps;
        enum interlacing_t   interlacing;
        unsigned int         tile_count;
#ifdef __cplusplus
        bool operator==(video_desc const &) const;
        bool operator!=(video_desc const &) const;
        bool operator!() const;
        operator std::string() const;
#endif
};
 
typedef enum frame_type {
    INTRA = 0,
    BFRAME,
    OTHER
} frame_type_t;
 
enum fec_type {
        FEC_NONE = 0,
        FEC_MULT = 1,
        FEC_LDGM = 2,
        FEC_RS   = 3,
};
 
struct fec_desc {
        enum fec_type type;
        unsigned int k, m, c;
        unsigned int seed;
        unsigned int symbol_size;
#ifdef __cplusplus
        fec_desc() = default;
        inline fec_desc(enum fec_type type_, unsigned int k_ = 0, unsigned int m_ = 0,
                        unsigned int c_ = 0,
                        unsigned int seed_ = 0,
                        unsigned int ss_ = 0) : type(type_), k(k_), m(m_), c(c_), seed(seed_), symbol_size(ss_) {}
#endif
};
 
enum frame_flags_common {
        TIMESTAMP_VALID = 1 << 0, 
};
 
struct video_frame;
struct video_frame_callbacks {
        void               (*dispose)(struct video_frame *);
        void                *dispose_udata;
 
        void               (*data_deleter)(struct video_frame *);
 
        void               (*recycle)(struct video_frame *);
 
        void               (*copy)(struct video_frame *);
};
 
struct tile {
        unsigned int         width;
        unsigned int         height;
 
        char                *data;
        unsigned int         data_len; 
 
        unsigned int         offset;
};
 
#define FLEXIBLE_ARRAY_MEMBER 0
 
enum mem_location_t {
        CPU_MEM = 0,
        CUDA_MEM
};
 
struct video_frame {
        codec_t              color_spec;
        enum interlacing_t   interlacing;
        double               fps;
        frame_type_t         frame_type;
        enum mem_location_t  mem_location;
 
        unsigned int         fragment:1;
        unsigned int         last_fragment:1;
        unsigned int         frame_fragment_id:14;
 
        unsigned int         decoder_overrides_data_len:1;
 
        struct video_frame_callbacks callbacks;
 
        // metadata follow
#define VF_METADATA_START fec_params
        struct fec_desc fec_params;
        int flags;
        uint32_t ssrc;
        int64_t timestamp; 
        uint32_t seq; 
        union {
                uint32_t timecode; 
                uint32_t duration; 
        };
        int64_t compress_start; 
        int64_t compress_end;   
#define VF_METADATA_END tile_count
 
        unsigned int         tile_count;
        struct tile          tiles[FLEXIBLE_ARRAY_MEMBER];
};
 
#define VF_METADATA_SIZE (offsetof(struct video_frame, VF_METADATA_END) - offsetof(struct video_frame, VF_METADATA_START))
 
enum video_mode {
        VIDEO_UNKNOWN, 
        VIDEO_NORMAL,  
        VIDEO_DUAL,    
        VIDEO_STEREO,  
        VIDEO_4K,      
        VIDEO_3X1,     
};
 
enum tx_media_type {
        TX_MEDIA_AUDIO,
        TX_MEDIA_VIDEO
};
 
struct device_option{
        char display_name[512]; //Name displayed to user
        char display_desc[512]; //Description displayed to user
 
        /* internal name of option, options that are used in the same way should
         * have the same key (e.g. both bitrate for libavcodec and quality for jpeg
         * should have the same key). This allows using different labels displayed
         * to user */
        char key[512];
        char opt_str[512]; //Option string to pass to ug (e.g. ":bitrate=")
 
        bool is_boolean; //If true, GUI shows a checkbox instead of text edit
};
 
struct device_info {
        char dev[1024];  
        char name[1024]; 
        bool repeatable; 
        char extra[1024];
        struct mode {    
                char id[1024];   
                char name[1024]; 
        } modes[512];
 
        struct device_option options[64];
};
 
//Impl in video_display.c
void dev_add_option(struct device_info *dev, const char *name, const char *desc, const char *key, const char *opt_str, bool is_boolean);
 
typedef void (*device_probe_func)(struct device_info **available_cards, int *count, void (**deleter)(void *));
 
#ifdef __cplusplus
}
#endif
 
#endif // TYPES_H_