moq.h

Go to the documentation of this file.

 
#ifndef IMQUIC_MOQ_H
#define IMQUIC_MOQ_H
 
#include "imquic.h"
 
#include <jansson.h>


typedef enum imquic_moq_version {
        /* Base */
        IMQUIC_MOQ_VERSION_BASE = 0xff000000,
        /* Draft version -16 */
        IMQUIC_MOQ_VERSION_MIN = 0xff000010,
        IMQUIC_MOQ_VERSION_16 = 0xff000010,
        /* Draft version -17 */
        IMQUIC_MOQ_VERSION_17 = 0xff000011,
        /* Draft version -18 */
        IMQUIC_MOQ_VERSION_18 = 0xff000012,
        /* Draft version -19 */
        IMQUIC_MOQ_VERSION_19 = 0xff000013,
        /* Draft version -20 */
        IMQUIC_MOQ_VERSION_20 = 0xff000014,
        /* Draft version -21 */
        IMQUIC_MOQ_VERSION_21 = 0xff000015,
        /* Draft version -22 */
        IMQUIC_MOQ_VERSION_22 = 0xff000016,
        IMQUIC_MOQ_VERSION_MAX = IMQUIC_MOQ_VERSION_22,
        /* Any version starting from v15: for client, it means offer all supported versions;
         * for servers, it means accept the first supported offered version */
        IMQUIC_MOQ_VERSION_ANY = 0xff0000ff,
} imquic_moq_version;

const char *imquic_moq_version_str(imquic_moq_version version);
imquic_moq_version imquic_moq_get_version(imquic_connection *conn);

typedef struct imquic_moq_namespace {
        uint8_t *buffer;
        size_t length;
        struct imquic_moq_namespace *next;
} imquic_moq_namespace;

const char *imquic_moq_namespace_str(imquic_moq_namespace *tns, char *buffer, size_t blen, gboolean tuple);
imquic_moq_namespace *imquic_moq_namespace_from_str(const char *ns, uint8_t *tns_num);
gboolean imquic_moq_namespace_equals(imquic_moq_namespace *first, imquic_moq_namespace *second);
gboolean imquic_moq_namespace_contains(imquic_moq_namespace *parent, imquic_moq_namespace *child);
imquic_moq_namespace *imquic_moq_namespace_duplicate(imquic_moq_namespace *tns);
gboolean imquic_moq_namespace_is_valid(imquic_moq_namespace *tns, gboolean fail_if_empty, uint64_t *tns_num);
void imquic_moq_namespace_free(imquic_moq_namespace *tns);

typedef struct imquic_moq_track {
        uint8_t *buffer;
        size_t length;
} imquic_moq_track;

imquic_moq_track *imquic_moq_track_create(uint8_t *buffer, size_t blen);
/* Helper to stringify a track name
 * @param[in] tn The track name to stringify
 * @param[out] buffer The buffer to write the string to
 * @param[in] blen The size of the output buffer
 * @returns A pointer to the output buffer, if successful, or NULL otherwise */
const char *imquic_moq_track_str(imquic_moq_track *tn, char *buffer, size_t blen);
imquic_moq_track *imquic_moq_track_from_str(const char *tn);
gboolean imquic_moq_track_equals(imquic_moq_track *first, imquic_moq_track *second);
imquic_moq_track *imquic_moq_track_duplicate(imquic_moq_track *tn);
gboolean imquic_moq_track_is_valid(imquic_moq_track *tn);
void imquic_moq_track_free(imquic_moq_track *tn);

typedef struct imquic_moq_redirect {
        /* Connect URI */
        char *connect_uri;
        /* Track Namespace */
        imquic_moq_namespace *track_namespace;
        /* Track Name */
        imquic_moq_track *track_name;
} imquic_moq_redirect;

typedef enum imquic_moq_group_order {
        IMQUIC_MOQ_ORDERING_ORIGINAL = 0x0,
        IMQUIC_MOQ_ORDERING_ASCENDING = 0x1,
        IMQUIC_MOQ_ORDERING_DESCENDING = 0x2,
} imquic_moq_group_order;

const char *imquic_moq_group_order_str(imquic_moq_group_order type);

typedef enum imquic_moq_location_filter_type_legacy {
        IMQUIC_MOQ_FILTER_NEXT_GROUP_START = 0x1,
        IMQUIC_MOQ_FILTER_LARGEST_OBJECT = 0x2,
        IMQUIC_MOQ_FILTER_ABSOLUTE_START = 0x3,
        IMQUIC_MOQ_FILTER_ABSOLUTE_RANGE = 0x4,
} imquic_moq_location_filter_type_legacy;

const char *imquic_moq_location_filter_type_legacy_str(imquic_moq_location_filter_type_legacy type);

typedef enum imquic_moq_location_filter_type {
        IMQUIC_MOQ_LOCATION_FILTER_NONE = 0x0,
        IMQUIC_MOQ_LOCATION_FILTER_RELATIVE_START = 0x1,
        IMQUIC_MOQ_LOCATION_FILTER_ABSOLUTE_START = 0x2,
        IMQUIC_MOQ_LOCATION_FILTER_GROUP_END = 0x3,
        IMQUIC_MOQ_LOCATION_FILTER_ABSOLUTE_RANGE = 0x4,
        IMQUIC_MOQ_LOCATION_FILTER_NEXT_OBJECT = 0x5,
} imquic_moq_location_filter_type;

const char *imquic_moq_location_filter_type_str(imquic_moq_location_filter_type type);

typedef struct imquic_moq_location {
        uint64_t group;
        uint64_t object;
} imquic_moq_location;

typedef struct imquic_moq_location_range {
        imquic_moq_location start;
        imquic_moq_location end;
} imquic_moq_location_range;

typedef struct imquic_moq_location_filter {
        imquic_moq_location_filter_type type;
        imquic_moq_location_filter_type_legacy legacy_type;
        imquic_moq_location_range range;
} imquic_moq_location_filter;

typedef enum imquic_moq_subscribe_namespace_options {
        IMQUIC_MOQ_WANT_PUBLISH = 0x0,
        IMQUIC_MOQ_WANT_NAMESPACE = 0x1,
        IMQUIC_MOQ_WANT_PUBLISH_AND_NAMESPACE = 0x2,
} imquic_moq_subscribe_namespace_options;

const char *imquic_moq_subscribe_namespace_options_str(imquic_moq_subscribe_namespace_options type);

typedef struct imquic_moq_filters imquic_moq_filters;

typedef struct imquic_moq_request_parameters {
        gboolean auth_token_set;
        uint8_t auth_token[256];
        size_t auth_token_len;
        gboolean delivery_timeout_set;
        uint64_t delivery_timeout;
        gboolean object_delivery_timeout_set;
        uint64_t object_delivery_timeout;
        gboolean subgroup_delivery_timeout_set;
        uint64_t subgroup_delivery_timeout;
        gboolean fill_timeout_set;
        uint64_t fill_timeout;
        gboolean rendezvous_timeout_set;
        uint64_t rendezvous_timeout;
        gboolean subscriber_priority_set;
        uint8_t subscriber_priority;
        gboolean group_order_set;
        imquic_moq_group_order group_order;
        gboolean fill_parameters_set;
        struct imquic_moq_request_parameters *fill_parameters;
        gboolean location_filter_set;
        imquic_moq_location_filter location_filter;
        gboolean filters_set;
        imquic_moq_filters *filters;
        gboolean expires_set;
        uint64_t expires;
        gboolean largest_object_set;
        imquic_moq_location largest_object;
        gboolean forward_set;
        gboolean forward;
        gboolean new_group_request_set;
        uint64_t new_group_request;
        gboolean track_namespace_prefix_set;
        imquic_moq_namespace track_namespace_prefix[32];
        gboolean include_properties_set;
        gboolean include_properties;
        gboolean unknown;
} imquic_moq_request_parameters;

void imquic_moq_request_parameters_init_defaults(imquic_moq_request_parameters *parameters);
void imquic_moq_request_parameters_destroy(imquic_moq_request_parameters *parameters);

typedef enum imquic_moq_delivery {
        IMQUIC_MOQ_USE_DATAGRAM,
        IMQUIC_MOQ_USE_SUBGROUP,
        IMQUIC_MOQ_USE_FETCH
} imquic_moq_delivery;

const char *imquic_moq_delivery_str(imquic_moq_delivery type);

typedef enum imquic_moq_object_status {
        IMQUIC_MOQ_NORMAL_OBJECT = 0x0,
        IMQUIC_MOQ_END_OF_GROUP = 0x3,
        IMQUIC_MOQ_END_OF_TRACK = 0x4,
} imquic_moq_object_status;

const char *imquic_moq_object_status_str(imquic_moq_object_status status);

typedef struct imquic_moq_property {
        uint32_t id;
        union {
                uint64_t number;
                struct imquic_moq_property_data {
                        uint64_t length;
                        uint8_t *buffer;
                } data;
        } value;
} imquic_moq_property;

typedef enum imquic_moq_property_type {
        IMQUIC_MOQ_PROPERTY_OBJECT_DELIVERY_TIMEOUT = 0x02,
                IMQUIC_MOQ_PROPERTY_DELIVERY_TIMEOUT = 0x02,
        IMQUIC_MOQ_PROPERTY_MAX_CACHE_DURATION = 0x04,
        IMQUIC_MOQ_PROPERTY_SUBGROUP_DELIVERY_TIMEOUT = 0x06,
        IMQUIC_MOQ_PROPERTY_DEFAULT_PUBLISHER_PRIORITY = 0x0E,
        IMQUIC_MOQ_PROPERTY_DEFAULT_GROUP_ORDER = 0x22,
        IMQUIC_MOQ_PROPERTY_DYNAMIC_GROUPS = 0x30,
        IMQUIC_MOQ_PROPERTY_PRIOR_GROUP_ID_GAP = 0x3C,
        IMQUIC_MOQ_PROPERTY_PRIOR_OBJECT_ID_GAP = 0x3E,
        IMQUIC_MOQ_PROPERTY_IMMUTABLE_PROPERTIES = 0xB,
        IMQUIC_MOQ_LOC_TIMESTAMP = 0x10,
        IMQUIC_MOQ_LOC_TIMESCALE = 0x08,
        IMQUIC_MOQ_LOC_VIDEO_CONFIG = 0x0D,
        IMQUIC_MOQ_LOC_VIDEO_FRAME_MARKING = 0x09,
        IMQUIC_MOQ_LOC_AUDIO_CONFIG = 0x0F,
        IMQUIC_MOQ_LOC_AUDIO_LEVEL = 0x0C,
        IMQUIC_MOQ_LOC_CODEC_STRING = 0x11,
        IMQUIC_MOQ_SECOBJ_ENCRYPTED_LIST = 0xA,
        IMQUIC_MOQ_SECOBJ_PADDING = 0x32,
} imquic_moq_property_type;

const char *imquic_moq_property_type_str(imquic_moq_version version, imquic_moq_property_type type);

GList *imquic_moq_parse_properties(imquic_moq_version version, uint8_t *properties, size_t plen);
size_t imquic_moq_build_properties(imquic_moq_version version, GList *properties, uint8_t *bytes, size_t blen);

typedef struct imquic_moq_object {
        uint64_t request_id;
        gboolean fill_fetch;
        uint64_t track_alias;
        uint64_t group_id;
        uint64_t subgroup_id;
        uint64_t object_id;
        imquic_moq_object_status object_status;
        gboolean priority_set;
        uint8_t priority;
        GList *properties;
        uint8_t *payload_prefix;
        size_t payload_prefix_len;
        uint8_t *payload;
        size_t payload_len;
        imquic_moq_delivery delivery;
        gboolean first_of_subgroup;
        gboolean end_of_stream;
} imquic_moq_object;



typedef enum imquic_moq_filter_type {
        IMQUIC_MOQ_FILTER_SUBGROUP = 0x25,
        IMQUIC_MOQ_FILTER_OBJECT = 0x26,
        IMQUIC_MOQ_FILTER_PRIORITY = 0x27,
        IMQUIC_MOQ_FILTER_OBJECT_PROPERTY = 0x28,
        IMQUIC_MOQ_FILTER_TRACK_PROPERTY = 0x29,
} imquic_moq_filter_type;

const char *imquic_moq_filter_type_str(imquic_moq_filter_type type);

typedef struct imquic_moq_filter_range {
        imquic_moq_filter_type type;
        uint8_t set_id;
        imquic_moq_property_type property;
        uint64_t start;
        uint64_t end;
} imquic_moq_filter_range;

imquic_moq_filter_range *imquic_moq_filter_range_create(imquic_moq_filter_type type,
        uint8_t set_id, imquic_moq_property_type property, uint64_t start, uint64_t end);
void imquic_moq_filter_range_destroy(imquic_moq_filter_range *filter);

struct imquic_moq_filters {
        GHashTable *filters_map;
        GList *filters_list;
};

imquic_moq_filters *imquic_moq_filters_create(void);
imquic_moq_filters *imquic_moq_filters_duplicate(imquic_moq_filters *filters);
int imquic_moq_filters_add(imquic_moq_filters *filters, imquic_moq_filter_range *filter);
gboolean imquic_moq_filters_match_object(imquic_moq_filters *filters, imquic_moq_object *object);
gboolean imquic_moq_filters_match_track(imquic_moq_filters *filters, GList *properties);
void imquic_moq_filters_destroy(imquic_moq_filters *filters);


uint64_t imquic_read_moqint(imquic_moq_version version, uint8_t *bytes, size_t blen, uint8_t *length);
uint8_t imquic_write_moqint(imquic_moq_version version, uint64_t number, uint8_t *bytes, size_t blen);


typedef enum imquic_moq_auth_token_alias_type {
        IMQUIC_MOQ_AUTH_TOKEN_DELETE = 0x0,
        IMQUIC_MOQ_AUTH_TOKEN_REGISTER = 0x1,
        IMQUIC_MOQ_AUTH_TOKEN_USE_ALIAS = 0x2,
        IMQUIC_MOQ_AUTH_TOKEN_USE_VALUE = 0x3,
} imquic_moq_auth_token_alias_type;

const char *imquic_moq_auth_token_alias_type_str(imquic_moq_auth_token_alias_type type);

typedef struct imquic_moq_auth_token {
        imquic_moq_auth_token_alias_type alias_type;
        gboolean token_alias_set;
        uint64_t token_alias;
        gboolean token_type_set;
        uint64_t token_type;
        struct imquic_moq_auth_token_value {
                uint64_t length;
                uint8_t *buffer;
        } token_value;
} imquic_moq_auth_token;

int imquic_moq_parse_auth_token(imquic_moq_version version, uint8_t *bytes, size_t blen, imquic_moq_auth_token *token);
size_t imquic_moq_build_auth_token(imquic_moq_version version, imquic_moq_auth_token *token, uint8_t *bytes, size_t blen);


typedef enum imquic_moq_error_code {
        IMQUIC_MOQ_NO_ERROR = 0x0,
        IMQUIC_MOQ_INTERNAL_ERROR = 0x1,
        IMQUIC_MOQ_UNAUTHORIZED = 0x2,
        IMQUIC_MOQ_PROTOCOL_VIOLATION = 0x3,
        IMQUIC_MOQ_INVALID_REQUEST_ID = 0x4,
        IMQUIC_MOQ_DUPLICATE_TRACK_ALIAS = 0x5,
        IMQUIC_MOQ_KEYVALUE_FORMATTING_ERROR = 0x6,
                IMQUIC_MOQ_INVALID_REQUIRED_REQUEST_ID = 0x7,   /* Deprecated in v18 */
                IMQUIC_MOQ_TOO_MANY_REQUESTS = 0x7,             /* Deprecated in v17 */
        IMQUIC_MOQ_INVALID_PATH = 0x8,
        IMQUIC_MOQ_MALFORMED_PATH = 0x9,
        IMQUIC_MOQ_GOAWAY_TIMEOUT = 0x10,
        IMQUIC_MOQ_CONTROL_MESSAGE_TIMEOUT = 0x11,
        IMQUIC_MOQ_DATA_STREAM_TIMEOUT = 0x12,
        IMQUIC_MOQ_AUTH_TOKEN_CACHE_OVERFLOW = 0x13,
        IMQUIC_MOQ_DUPLICATE_AUTH_TOKEN_ALIAS = 0x14,
        IMQUIC_MOQ_VERSION_NEGOTIATION_FAILED = 0x15,   /* Deprecated in v20 */
        IMQUIC_MOQ_MALFORMED_AUTH_TOKEN = 0x16,
        IMQUIC_MOQ_UNKNOWN_AUTH_TOKEN_ALIAS = 0x17,
        IMQUIC_MOQ_EXPIRED_AUTH_TOKEN = 0x18,
        IMQUIC_MOQ_INVALID_AUTHORITY = 0x19,
        IMQUIC_MOQ_MALFORMED_AUTHORITY = 0x1A,
        IMQUIC_MOQ_TOO_MANY_REQUEST_UPDATES = 0x1B,             /* Added in v19 */
        /* Not an actual error */
        IMQUIC_MOQ_UNKNOWN_ERROR = 0xFF
} imquic_moq_error_code;

const char *imquic_moq_error_code_str(imquic_moq_error_code code);

typedef enum imquic_moq_request_error_code {
        IMQUIC_MOQ_REQERR_INTERNAL_ERROR = 0x0,
        IMQUIC_MOQ_REQERR_UNAUTHORIZED = 0x1,
        IMQUIC_MOQ_REQERR_TIMEOUT = 0x2,
        IMQUIC_MOQ_REQERR_NOT_SUPPORTED = 0x3,
        IMQUIC_MOQ_REQERR_MALFORMED_AUTH_TOKEN = 0x4,
        IMQUIC_MOQ_REQERR_EXPIRED_AUTH_TOKEN = 0x5,
        IMQUIC_MOQ_REQERR_GOING_AWAY = 0x6,
        IMQUIC_MOQ_REQERR_EXCESSIVE_LOAD = 0x9,
        /* The following are returned by publishers */
        IMQUIC_MOQ_REQERR_DOES_NOT_EXIST = 0x10,
        IMQUIC_MOQ_REQERR_INVALID_RANGE = 0x11,
        IMQUIC_MOQ_REQERR_MALFORMED_TRACK = 0x12,
                IMQUIC_MOQ_REQERR_DUPLICATE_SUBSCRIPTION = 0x19,        /* Deprecated in v19 */
        /* The following are returned by subscribers */
        IMQUIC_MOQ_REQERR_UNINTERESTED = 0x20,
        /* Others */
        IMQUIC_MOQ_REQERR_PREFIX_OVERLAP = 0x30,
        IMQUIC_MOQ_REQERR_NAMESPACE_TOO_LARGE = 0x31,
        IMQUIC_MOQ_REQERR_INVALID_JOINING_REQUEST_ID = 0x32,    /* Deprecated in v20 */
        IMQUIC_MOQ_REQERR_UNSUPPORTED_EXTENSION = 0x33, /* Added in v18 */
        IMQUIC_MOQ_REQERR_REDIRECT = 0x34,      /* Added in v18 */
        IMQUIC_MOQ_REQERR_CONFLICTING_FILTERS = 0x35,   /* Added in v19 */
        IMQUIC_MOQ_REQERR_INVALID_FILTER = 0x36,        /* Added in v19 */
} imquic_moq_request_error_code;

const char *imquic_moq_request_error_code_str(imquic_moq_request_error_code code);

typedef enum imquic_moq_pub_done_code {
        IMQUIC_MOQ_PUBDONE_INTERNAL_ERROR = 0x0,
        IMQUIC_MOQ_PUBDONE_UNAUTHORIZED = 0x1,
        IMQUIC_MOQ_PUBDONE_TRACK_ENDED = 0x2,
        IMQUIC_MOQ_PUBDONE_SUBSCRIPTION_ENDED = 0x3,    /* Deprecated in v20 */
        IMQUIC_MOQ_PUBDONE_GOING_AWAY = 0x4,
        IMQUIC_MOQ_PUBDONE_TOO_FAR_BEHIND = 0x5,        /* Swapped in v18 */
        IMQUIC_MOQ_PUBDONE_EXPIRED = 0x6,       /* Swapped in v18 */
        IMQUIC_MOQ_PUBDONE_UPDATE_FAILED = 0x8,
        IMQUIC_MOQ_PUBDONE_EXCESSIVE_LOAD = 0x9,
        IMQUIC_MOQ_PUBDONE_MALFORMED_TRACK = 0x12,
} imquic_moq_pub_done_code;

const char *imquic_moq_pub_done_code_str(imquic_moq_pub_done_code code);

typedef enum imquic_moq_reset_stream_code {
        IMQUIC_MOQ_RESET_INTERNAL_ERROR = 0x0,
        IMQUIC_MOQ_RESET_CANCELLED = 0x1,
        IMQUIC_MOQ_RESET_DELIVERY_TIMEOUT = 0x2,
        IMQUIC_MOQ_RESET_SESSION_CLOSED = 0x3,
        IMQUIC_MOQ_RESET_GOING_AWAY = 0x4,      /* Added in v18 */
        IMQUIC_MOQ_RESET_TOO_FAR_BEHIND = 0x5,
        IMQUIC_MOQ_RESET_UNKNOWN_OBJECT_STATUS = 0x6,   /* Value changed in v18 */
        IMQUIC_MOQ_RESET_EXPIRED_AUTH_TOKEN = 0x7,      /* Added in v18 */
        IMQUIC_MOQ_RESET_EXCESSIVE_LOAD = 0x9,
        IMQUIC_MOQ_RESET_MALFORMED_TRACK = 0x12,
} imquic_moq_reset_stream_code;

const char *imquic_moq_reset_stream_code_str(imquic_moq_reset_stream_code code);


imquic_server *imquic_create_moq_server(const char *name, ...);
imquic_client *imquic_create_moq_client(const char *name, ...);

void imquic_set_new_moq_connection_cb(imquic_endpoint *endpoint,
        void (* new_moq_connection)(imquic_connection *conn, void *user_data));
void imquic_set_incoming_moq_connection_cb(imquic_endpoint *endpoint,
        uint64_t (* incoming_moq_connection)(imquic_connection *conn, uint8_t *auth, size_t authlen));
void imquic_set_moq_ready_cb(imquic_endpoint *endpoint,
        void (* moq_ready)(imquic_connection *conn));
void imquic_set_incoming_publish_namespace_cb(imquic_endpoint *endpoint,
        void (* incoming_publish_namespace)(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns, imquic_moq_request_parameters *parameters));
void imquic_set_incoming_publish_namespace_cancel_cb(imquic_endpoint *endpoint,
        void (* incoming_publish_namespace_cancel)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_error_code error_code, const char *reason));
void imquic_set_publish_namespace_accepted_cb(imquic_endpoint *endpoint,
        void (* publish_namespace_accepted)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_parameters *parameters));
void imquic_set_publish_namespace_error_cb(imquic_endpoint *endpoint,
        void (* publish_namespace_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_error_code error_code,
                const char *reason, uint64_t retry_interval, imquic_moq_redirect *redirect));
void imquic_set_publish_namespace_done_cb(imquic_endpoint *endpoint,
        void (* publish_namespace_done)(imquic_connection *conn, uint64_t request_id));
void imquic_set_incoming_publish_cb(imquic_endpoint *endpoint,
        void (* incoming_publish)(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns, imquic_moq_track *tn,
                uint64_t track_alias, imquic_moq_request_parameters *parameters, GList *track_properties));
void imquic_set_publish_accepted_cb(imquic_endpoint *endpoint,
        void (* publish_accepted)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_parameters *parameters));
void imquic_set_publish_error_cb(imquic_endpoint *endpoint,
        void (* publish_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_error_code error_code,
                const char *reason, uint64_t retry_interval, imquic_moq_redirect *redirect));
void imquic_set_incoming_subscribe_cb(imquic_endpoint *endpoint,
        void (* incoming_subscribe)(imquic_connection *conn, uint64_t request_id,
                imquic_moq_namespace *tns, imquic_moq_track *tn, imquic_moq_request_parameters *parameters));
void imquic_set_subscribe_accepted_cb(imquic_endpoint *endpoint,
        void (* subscribe_accepted)(imquic_connection *conn, uint64_t request_id, uint64_t track_alias, imquic_moq_request_parameters *parameters, GList *track_properties));
void imquic_set_subscribe_error_cb(imquic_endpoint *endpoint,
        void (* subscribe_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_error_code error_code,
                const char *reason, uint64_t retry_interval, imquic_moq_redirect *redirect));
void imquic_set_request_updated_cb(imquic_endpoint *endpoint,
        void (* request_updated)(imquic_connection *conn, uint64_t request_id, uint64_t sub_request_id, imquic_moq_request_parameters *parameters));
void imquic_set_request_update_accepted_cb(imquic_endpoint *endpoint,
        void (* request_update_accepted)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_parameters *parameters));
void imquic_set_request_update_error_cb(imquic_endpoint *endpoint,
        void (* request_update_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_error_code error_code,
                const char *reason, uint64_t retry_interval, imquic_moq_redirect *redirect));
void imquic_set_publish_state_notify_cb(imquic_endpoint *endpoint,
        void (* publish_state_notify)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_parameters *parameters));
void imquic_set_publish_done_cb(imquic_endpoint *endpoint,
        void (* publish_done)(imquic_connection *conn, uint64_t request_id, imquic_moq_pub_done_code status_code, uint64_t streams_count, const char *reason));
void imquic_set_incoming_unsubscribe_cb(imquic_endpoint *endpoint,
        void (* incoming_unsubscribe)(imquic_connection *conn, uint64_t request_id));
void imquic_set_requests_blocked_cb(imquic_endpoint *endpoint,
        void (* requests_blocked)(imquic_connection *conn, uint64_t max_request_id));
void imquic_set_incoming_subscribe_namespace_cb(imquic_endpoint *endpoint,
        void (* incoming_subscribe_namespace)(imquic_connection *conn, uint64_t request_id,
                imquic_moq_namespace *tns, imquic_moq_subscribe_namespace_options subscribe_options, imquic_moq_request_parameters *parameters));
void imquic_set_subscribe_namespace_accepted_cb(imquic_endpoint *endpoint,
        void (* subscribe_namespace_accepted)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_parameters *parameters));
void imquic_set_subscribe_namespace_error_cb(imquic_endpoint *endpoint,
        void (* subscribe_namespace_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_error_code error_code,
                const char *reason, uint64_t retry_interval, imquic_moq_redirect *redirect));
void imquic_set_incoming_unsubscribe_namespace_cb(imquic_endpoint *endpoint,
        void (* incoming_unsubscribe_namespace)(imquic_connection *conn, uint64_t request_id));
void imquic_set_incoming_subscribe_tracks_cb(imquic_endpoint *endpoint,
        void (* incoming_subscribe_tracks)(imquic_connection *conn, uint64_t request_id,
                imquic_moq_namespace *tns, imquic_moq_request_parameters *parameters));
void imquic_set_subscribe_tracks_accepted_cb(imquic_endpoint *endpoint,
        void (* subscribe_tracks_accepted)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_parameters *parameters));
void imquic_set_subscribe_tracks_error_cb(imquic_endpoint *endpoint,
        void (* subscribe_tracks_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_error_code error_code,
                const char *reason, uint64_t retry_interval, imquic_moq_redirect *redirect));
void imquic_set_incoming_unsubscribe_tracks_cb(imquic_endpoint *endpoint,
        void (* incoming_unsubscribe_tracks)(imquic_connection *conn, uint64_t request_id));
void imquic_set_incoming_namespace_cb(imquic_endpoint *endpoint,
        void (* incoming_namespace)(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns));
void imquic_set_incoming_namespace_done_cb(imquic_endpoint *endpoint,
        void (* incoming_namespace_done)(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns));
void imquic_set_incoming_publish_skipped_cb(imquic_endpoint *endpoint,
        void (* incoming_publish_skipped)(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns, imquic_moq_track *tn));
void imquic_set_incoming_fetch_cb(imquic_endpoint *endpoint,
        void (* incoming_fetch)(imquic_connection *conn, uint64_t request_id,
                imquic_moq_namespace *tns, imquic_moq_track *tn, imquic_moq_location_range *range, imquic_moq_request_parameters *parameters));
void imquic_set_incoming_joining_fetch_cb(imquic_endpoint *endpoint,
        void (* incoming_joining_fetch)(imquic_connection *conn, uint64_t request_id, uint64_t joining_request_id,
                gboolean absolute, uint64_t joining_start, imquic_moq_request_parameters *parameters));
void imquic_set_incoming_fetch_cancel_cb(imquic_endpoint *endpoint,
        void (* incoming_fetch_cancel)(imquic_connection *conn, uint64_t request_id));
void imquic_set_fetch_accepted_cb(imquic_endpoint *endpoint,
        void (* fetch_accepted)(imquic_connection *conn, uint64_t request_id,
                imquic_moq_location *largest, imquic_moq_request_parameters *parameters, GList *track_properties));
void imquic_set_fetch_error_cb(imquic_endpoint *endpoint,
        void (* fetch_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_error_code error_code,
                const char *reason, uint64_t retry_interval, imquic_moq_redirect *redirect));
void imquic_set_incoming_track_status_cb(imquic_endpoint *endpoint,
        void (* incoming_track_status)(imquic_connection *conn, uint64_t request_id,
                imquic_moq_namespace *tns, imquic_moq_track *tn, imquic_moq_request_parameters *parameters));
void imquic_set_track_status_accepted_cb(imquic_endpoint *endpoint,
        void (* track_status_accepted)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_parameters *parameters, GList *track_properties));
void imquic_set_track_status_error_cb(imquic_endpoint *endpoint,
        void (* track_status_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_error_code error_code,
                const char *reason, uint64_t retry_interval, imquic_moq_redirect *redirect));
void imquic_set_incoming_object_cb(imquic_endpoint *endpoint,
        void (* incoming_object)(imquic_connection *conn, imquic_moq_object *object));
void imquic_set_incoming_goaway_cb(imquic_endpoint *endpoint,
        void (* incoming_goaway)(imquic_connection *conn, const char *uri, uint64_t timeout));
void imquic_set_incoming_request_goaway_cb(imquic_endpoint *endpoint,
        void (* incoming_request_goaway)(imquic_connection *conn, uint64_t request_id, const char *uri, uint64_t timeout));
void imquic_set_moq_connection_gone_cb(imquic_endpoint *endpoint,
        void (* moq_connection_gone)(imquic_connection *conn, uint64_t error_code, const char *reason));

int imquic_moq_set_connection_auth(imquic_connection *conn, uint8_t *auth, size_t authlen);

int imquic_moq_set_max_request_id(imquic_connection *conn, uint64_t max_request_id);

uint64_t imquic_moq_get_next_request_id(imquic_connection *conn);

int imquic_moq_set_max_filter_ranges(imquic_connection *conn, uint64_t max_filter_ranges);

uint64_t imquic_moq_get_remote_max_filter_ranges(imquic_connection *conn);

const char *imquic_moq_get_remote_implementation(imquic_connection *conn);

/* Namespaces and subscriptions */
int imquic_moq_publish_namespace(imquic_connection *conn, uint64_t request_id,
        imquic_moq_namespace *tns, imquic_moq_request_parameters *parameters);
int imquic_moq_accept_publish_namespace(imquic_connection *conn, uint64_t request_id,
        imquic_moq_request_parameters *parameters);
int imquic_moq_reject_publish_namespace(imquic_connection *conn, uint64_t request_id,
        imquic_moq_request_error_code error_code, const char *reason, uint64_t retry_interval, imquic_moq_redirect *redirect);
int imquic_moq_publish_namespace_done(imquic_connection *conn, uint64_t request_id);
int imquic_moq_publish(imquic_connection *conn,
        uint64_t request_id, imquic_moq_namespace *tns, imquic_moq_track *tn,
        uint64_t track_alias, imquic_moq_request_parameters *parameters, GList *track_properties);
int imquic_moq_accept_publish(imquic_connection *conn, uint64_t request_id, imquic_moq_request_parameters *parameters);
int imquic_moq_reject_publish(imquic_connection *conn, uint64_t request_id,
        imquic_moq_request_error_code error_code, const char *reason, uint64_t retry_interval, imquic_moq_redirect *redirect);
int imquic_moq_subscribe(imquic_connection *conn, uint64_t request_id,
        imquic_moq_namespace *tns, imquic_moq_track *tn, imquic_moq_request_parameters *parameters);
int imquic_moq_accept_subscribe(imquic_connection *conn, uint64_t request_id,
        uint64_t track_alias, imquic_moq_request_parameters *parameters, GList *track_properties);
int imquic_moq_reject_subscribe(imquic_connection *conn, uint64_t request_id,
        imquic_moq_request_error_code error_code, const char *reason, uint64_t retry_interval, imquic_moq_redirect *redirect);
int imquic_moq_update_request(imquic_connection *conn, uint64_t request_id,
        uint64_t sub_request_id, imquic_moq_request_parameters *parameters);
int imquic_moq_accept_request_update(imquic_connection *conn, uint64_t request_id,
        imquic_moq_request_parameters *parameters);
int imquic_moq_reject_request_update(imquic_connection *conn, uint64_t request_id,
        imquic_moq_request_error_code error_code, const char *reason, uint64_t retry_interval, imquic_moq_redirect *redirect);
int imquic_moq_publish_state_notify(imquic_connection *conn, uint64_t request_id,
        imquic_moq_request_parameters *parameters);
int imquic_moq_publish_done(imquic_connection *conn, uint64_t request_id,
        imquic_moq_pub_done_code status_code, const char *reason);
int imquic_moq_unsubscribe(imquic_connection *conn, uint64_t request_id);
int imquic_moq_subscribe_namespace(imquic_connection *conn, uint64_t request_id,
        imquic_moq_namespace *tns, imquic_moq_subscribe_namespace_options subscribe_options, imquic_moq_request_parameters *parameters);
int imquic_moq_accept_subscribe_namespace(imquic_connection *conn, uint64_t request_id,
        imquic_moq_request_parameters *parameters);
int imquic_moq_reject_subscribe_namespace(imquic_connection *conn, uint64_t request_id,
        imquic_moq_request_error_code error_code, const char *reason, uint64_t retry_interval, imquic_moq_redirect *redirect);
int imquic_moq_unsubscribe_namespace(imquic_connection *conn, uint64_t request_id);
int imquic_moq_subscribe_tracks(imquic_connection *conn, uint64_t request_id,
        imquic_moq_namespace *tns, imquic_moq_request_parameters *parameters);
int imquic_moq_accept_subscribe_tracks(imquic_connection *conn, uint64_t request_id,
        imquic_moq_request_parameters *parameters);
int imquic_moq_reject_subscribe_tracks(imquic_connection *conn, uint64_t request_id,
        imquic_moq_request_error_code error_code, const char *reason, uint64_t retry_interval, imquic_moq_redirect *redirect);
int imquic_moq_unsubscribe_tracks(imquic_connection *conn, uint64_t request_id);
int imquic_moq_notify_namespace(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns);
int imquic_moq_notify_namespace_done(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns);
int imquic_moq_notify_publish_skipped(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns, imquic_moq_track *tn);
int imquic_moq_fetch(imquic_connection *conn,
        uint64_t request_id, imquic_moq_namespace *tns, imquic_moq_track *tn,
        imquic_moq_location_range *range, imquic_moq_request_parameters *parameters);
int imquic_moq_joining_fetch(imquic_connection *conn,
        uint64_t request_id, uint64_t joining_request_id,
        gboolean absolute, uint64_t joining_start, imquic_moq_request_parameters *parameters);
int imquic_moq_accept_fetch(imquic_connection *conn, uint64_t request_id,
        imquic_moq_location *largest, imquic_moq_request_parameters *parameters, GList *track_properties);
int imquic_moq_reject_fetch(imquic_connection *conn, uint64_t request_id,
        imquic_moq_request_error_code error_code, const char *reason, uint64_t retry_interval, imquic_moq_redirect *redirect);
int imquic_moq_cancel_fetch(imquic_connection *conn, uint64_t request_id);
int imquic_moq_track_status(imquic_connection *conn, uint64_t request_id,
        imquic_moq_namespace *tns, imquic_moq_track *tn, imquic_moq_request_parameters *parameters);
int imquic_moq_accept_track_status(imquic_connection *conn, uint64_t request_id,
        imquic_moq_request_parameters *parameters, GList *track_properties);
int imquic_moq_reject_track_status(imquic_connection *conn, uint64_t request_id,
        imquic_moq_request_error_code error_code, const char *reason, uint64_t retry_interval, imquic_moq_redirect *redirect);
int imquic_moq_send_object(imquic_connection *conn, imquic_moq_object *object);
int imquic_moq_send_padding(imquic_connection *conn, size_t padding, gboolean datagram);
int imquic_moq_requests_blocked(imquic_connection *conn);
int imquic_moq_goaway(imquic_connection *conn, const char *uri, uint64_t timeout);
int imquic_moq_request_goaway(imquic_connection *conn, uint64_t request_id, const char *uri, uint64_t timeout);


typedef struct imquic_moq_catalog {
        char *version;
        int64_t generated_at;
        GList *tracks;
} imquic_moq_catalog;

typedef struct imquic_moq_catalog_track {
        char *track_name;
        char *track_namespace;
        char *packaging;
        gboolean is_live;
        uint64_t target_latency;
        char *role;
        uint8_t render_group;
        char *codec;
        uint32_t samplerate;
        char *channel_config;
        uint16_t width;
        uint16_t height;
        uint8_t framerate;
        uint32_t bitrate;
} imquic_moq_catalog_track;

imquic_moq_catalog *imquic_moq_catalog_create(const char *version);
imquic_moq_catalog *imquic_moq_catalog_parse(const char *json);
int imquic_moq_catalog_update(imquic_moq_catalog *catalog, const char *json);
imquic_moq_catalog_track *imquic_moq_catalog_create_track(const char *track_namespace,
        const char *track_name, const char *packaging, gboolean is_live);
int imquic_moq_catalog_add_track(imquic_moq_catalog *catalog, imquic_moq_catalog_track *track);
int imquic_moq_catalog_remove_track(imquic_moq_catalog *catalog,
        const char *track_namespace, const char *track_name);
char *imquic_moq_catalog_serialize(imquic_moq_catalog *catalog);
json_t *imquic_moq_catalog_serialize_obj(imquic_moq_catalog *catalog);
/* Destroy an existing imquic_moq_catalog_track instance
 * @param track The imquic_moq_catalog_track instance to destroy */
void imquic_moq_catalog_track_destroy(imquic_moq_catalog_track *track);
/* Destroy an existing imquic_moq_catalog instance
 * @param catalog The imquic_moq_catalog instance to destroy */
void imquic_moq_catalog_destroy(imquic_moq_catalog *catalog);

 
#endif