utils.h

Go to the documentation of this file.

 
#ifndef JANUS_UTILS_H
#define JANUS_UTILS_H
 
#include <stdint.h>
#include <glib.h>
#include <jansson.h>
 
#define JANUS_JSON_STRING                       JSON_STRING
#define JANUS_JSON_INTEGER                      JSON_INTEGER
#define JANUS_JSON_OBJECT                       JSON_OBJECT
/* Use JANUS_JSON_BOOL instead of the non-existing JSON_BOOLEAN */
#define JANUS_JSON_BOOL                         JSON_TRUE
#define JANUS_JSON_PARAM_REQUIRED       1
#define JANUS_JSON_PARAM_POSITIVE       2
#define JANUS_JSON_PARAM_NONEMPTY       4
 
struct janus_json_parameter {
        const gchar *name;
        json_type jtype;
        unsigned int flags;
};
 
gint64 janus_get_monotonic_time(void);
 
gint64 janus_get_real_time(void);
 
char *janus_string_replace(char *message, const char *old_string, const char *new_string) G_GNUC_WARN_UNUSED_RESULT;
 
size_t janus_strlcat(char *dest, const char *src, size_t dest_size);
 
int janus_strlcat_fast(char *dest, const char *src, size_t dest_size, size_t *offset);
 
gboolean janus_is_true(const char *value);
 
gboolean janus_strcmp_const_time(const void *str1, const void *str2);
 
guint32 janus_random_uint32(void);
 
guint64 janus_random_uint64_full(void);
 
guint64 janus_random_uint64(void);
 
char *janus_random_uuid(void);
 
guint64 *janus_uint64_dup(guint64 num);
 
guint64 janus_uint64_hash(guint64 num);
 
int janus_string_to_uint8(const char *str, uint8_t *num);
 
int janus_string_to_uint16(const char *str, uint16_t *num);
 
int janus_string_to_uint32(const char *str, uint32_t *num);
 
 
typedef gsize janus_flags;
 
void janus_flags_reset(janus_flags *flags);
 
void janus_flags_set(janus_flags *flags, gsize flag);
 
void janus_flags_clear(janus_flags *flags, gsize flag);
 
gboolean janus_flags_is_set(janus_flags *flags, gsize flag);
 
int janus_mkdir(const char *dir, mode_t mode);
 
gchar *janus_make_absolute_path(const gchar *base_dir, const gchar *path);
 
int janus_get_codec_pt(const char *sdp, const char *codec);
 
const char *janus_get_codec_from_pt(const char *sdp, int pt);
 
int janus_pidfile_create(const char *file);
 
int janus_pidfile_remove(void);
 
void janus_protected_folder_add(const char *folder);
 
gboolean janus_is_folder_protected(const char *path);
 
void janus_protected_folders_clear(void);
 
void janus_get_json_type_name(int jtype, unsigned int flags, char *type_name);
 
gboolean janus_json_is_valid(json_t *val, json_type jtype, unsigned int flags);
 
#define JANUS_VALIDATE_JSON_OBJECT_FORMAT(missing_format, invalid_format, obj, params, error_code, error_cause, log_error, missing_code, invalid_code) \
        do { \
                error_code = 0; \
                unsigned int i; \
                for(i = 0; i < sizeof(params) / sizeof(struct janus_json_parameter); i++) { \
                        json_t *val = json_object_get(obj, params[i].name); \
                        if(!val) { \
                                if((params[i].flags & JANUS_JSON_PARAM_REQUIRED) != 0) {        \
                                        error_code = (missing_code); \
                                        if(log_error) \
                                                JANUS_LOG(LOG_ERR, missing_format "\n", params[i].name); \
                                        if(error_cause != NULL) \
                                                g_snprintf(error_cause, sizeof(error_cause), missing_format, params[i].name); \
                                        break; \
                                } \
                                continue; \
                        } \
                        if(!janus_json_is_valid(val, params[i].jtype, params[i].flags)) { \
                                error_code = (invalid_code); \
                                char type_name[20]; \
                                janus_get_json_type_name(params[i].jtype, params[i].flags, type_name); \
                                if(log_error) \
                                        JANUS_LOG(LOG_ERR, invalid_format "\n", params[i].name, type_name); \
                                if(error_cause != NULL) \
                                        g_snprintf(error_cause, sizeof(error_cause), invalid_format, params[i].name, type_name); \
                                break; \
                        } \
                } \
        } while(0)
 
#define JANUS_VALIDATE_JSON_OBJECT(obj, params, error_code, error_cause, log_error, missing_code, invalid_code) \
        JANUS_VALIDATE_JSON_OBJECT_FORMAT("Missing mandatory element (%s)", "Invalid element type (%s should be %s)", obj, params, error_code, error_cause, log_error, missing_code, invalid_code)
 
#define JANUS_CHECK_SECRET(secret, obj, member, error_code, error_cause, missing_code, invalid_code, unauthorized_code) \
        do { \
                if (secret) { \
                        static struct janus_json_parameter secret_parameters[] = { \
                                {member, JSON_STRING, JANUS_JSON_PARAM_REQUIRED} \
                        }; \
                        JANUS_VALIDATE_JSON_OBJECT(obj, secret_parameters, error_code, error_cause, TRUE, missing_code, invalid_code); \
                        if(error_code == 0 && !janus_strcmp_const_time((secret), json_string_value(json_object_get(obj, member)))) { \
                                error_code = (unauthorized_code); \
                                JANUS_LOG(LOG_ERR, "Unauthorized (wrong %s)\n", member); \
                                if(error_cause != NULL) \
                                        g_snprintf(error_cause, sizeof(error_cause), "Unauthorized (wrong %s)", member); \
                        } \
                } \
        } while(0)
 
gboolean janus_vp8_is_keyframe(const char *buffer, int len);
 
gboolean janus_vp9_is_keyframe(const char *buffer, int len);
 
gboolean janus_h264_is_keyframe(const char *buffer, int len);
 
gboolean janus_h264_is_i_frame(const char *buffer, int len);
 
gboolean janus_h264_is_b_frame(const char *buffer, int len);
 
gboolean janus_av1_is_keyframe(const char *buffer, int len);
 
gboolean janus_h265_is_keyframe(const char *buffer, int len);
 
typedef struct janus_vp8_simulcast_context {
        uint16_t last_picid, base_picid, base_picid_prev;
        uint8_t last_tlzi, base_tlzi, base_tlzi_prev;
} janus_vp8_simulcast_context;
 
void janus_vp8_simulcast_context_reset(janus_vp8_simulcast_context *context);
 
int janus_vp8_parse_descriptor(char *buffer, int len,
                gboolean *m, uint16_t *picid, uint8_t *tl0picidx, uint8_t *tid, uint8_t *y, uint8_t *keyidx);
 
void janus_vp8_simulcast_descriptor_update(char *buffer, int len, janus_vp8_simulcast_context *context, gboolean switched);
 
typedef struct janus_vp9_svc_info {
        int spatial_layer, temporal_layer;
        uint8_t fbit, pbit, dbit, ubit, bbit, ebit;
} janus_vp9_svc_info;
 
int janus_vp9_parse_svc(char *buffer, int len, gboolean *found, janus_vp9_svc_info *info);
 
typedef struct janus_red_block {
        uint8_t pt;
        uint32_t ts_offset;
        uint8_t *data;
        uint16_t length;
} janus_red_block;
GList *janus_red_parse_blocks(char *buffer, int len);
int janus_red_pack_blocks(char *buffer, int len, GList *blocks);
int janus_red_replace_block_pt(char *buffer, int len, int pt);
 
guint32 janus_push_bits(guint32 word, size_t num, guint32 val);
 
void janus_set1(guint8 *data, size_t i, guint8 val);
 
void janus_set2(guint8 *data, size_t i, guint32 val);
 
void janus_set3(guint8 *data, size_t i, guint32 val);
 
void janus_set4(guint8 *data, size_t i, guint32 val);
 
/* \brief Helpers to read a bit from a bitstream
 * @param[in] base Pointer to the start of the bitstream
 * @param[in] offset Offset in bits from the start
 * @returns The value of the bit */
uint8_t janus_bitstream_getbit(uint8_t *base, uint32_t offset);
/* \brief Helpers to read agroup of bits from a bitstream
 * @param[in] base Pointer to the start of the bitstream
 * @param[in] num The number of bits to read
 * @param[in] offset Offset in bits from the start
 * @returns The value of the bits */
uint32_t janus_bitstream_getbits(uint8_t *base, uint8_t num, uint32_t *offset);
 
size_t janus_gzip_compress(int compression, char *text, size_t tlen, char *compressed, size_t zlen);
 
#endif