/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
#include "nsStringFwd.h"
#include "nsTArray.h"
namespace mozilla::sdp::ffi {
struct SdpAttribute;
struct SdpAttributeImageAttrSet;
struct SdpAttributeSimulcastId;
struct SdpAttributeSimulcastVersion;
struct SdpAttributeSsrc;
struct SdpAttributeSsrc;
struct SdpBandwidth;
struct SdpMedia;
struct SdpParserError;
struct SdpSession;
}
#ifndef mozilla_sdp_RsdparsaSdpInc_h
#define mozilla_sdp_RsdparsaSdpInc_h
/* Generated with cbindgen:0.29.1 */
/* DO NOT MODIFY THIS MANUALLY! This file was generated using cbindgen. */
#include <cstdarg>
#include <cstdint>
#include <cstdlib>
#include <ostream>
#include <new>
#include "nsError.h"
namespace mozilla {
namespace sdp {
namespace ffi {
enum class RustAddressType {
IP4,
IP6,
};
enum class RustSdpAttributeDtlsMessageRole {
Client,
Server,
};
enum class RustSdpAttributeFingerprintHashAlgorithm {
Sha1,
Sha224,
Sha256,
Sha384,
Sha512,
};
enum class RustSdpAttributeSetup {
Active,
Actpass,
Holdconn,
Passive,
};
enum class RustSdpSsrcGroupSemantic {
Duplication,
FlowIdentification,
ForwardErrorCorrection,
ForwardErrorCorrectionFr,
SIM,
};
enum class RustSdpAttributeGroupSemantic {
LipSynchronization,
FlowIdentification,
SingleReservationFlow,
AlternateNetworkAddressType,
ForwardErrorCorrection,
DecodingDependency,
Bundle,
};
enum class RustDirection {
Recvonly,
Sendonly,
Sendrecv,
Inactive,
};
enum class RustSdpMediaValue {
Audio,
Video,
Application,
};
enum class RustSdpProtocolValue {
RtpSavpf,
UdpTlsRtpSavp,
TcpDtlsRtpSavp,
UdpTlsRtpSavpf,
TcpDtlsRtpSavpf,
DtlsSctp,
UdpDtlsSctp,
TcpDtlsSctp,
RtpAvp,
RtpAvpf,
RtpSavp,
};
enum class RustSdpFormatType {
Integers,
Strings,
};
template<typename T = void>
struct Vec;
template<typename T>
struct RustSpan {
const T *buffer;
uintptr_t len;
};
using StringView = RustSpan<uint8_t>;
struct RustAddress {
uint8_t ip_address[50];
StringView fqdn;
bool is_fqdn;
};
struct RustExplicitlyTypedAddress {
RustAddressType address_type;
RustAddress address;
};
struct RustSdpOrigin {
StringView username;
uint64_t session_id;
uint64_t session_version;
RustExplicitlyTypedAddress addr;
};
struct RustSdpConnection {
RustExplicitlyTypedAddress addr;
uint8_t ttl;
uint64_t amount;
};
struct RustSdpTiming {
uint64_t start;
uint64_t stop;
};
struct RustSdpAttributeDtlsMessage {
RustSdpAttributeDtlsMessageRole role;
StringView value;
};
struct RustSdpAttributeFingerprint {
RustSdpAttributeFingerprintHashAlgorithm hash_algorithm;
RustSpan<uint8_t> fingerprint;
};
struct RustSdpAttributeSsrc {
uint32_t id;
StringView attribute;
StringView value;
};
struct RustSdpSsrcGroup {
RustSdpSsrcGroupSemantic semantic;
nsTArray<uint32_t> ssrcs;
};
struct RustSdpAttributeRtpmap {
uint8_t payload_type;
StringView codec_name;
uint32_t frequency;
uint32_t channels;
};
struct RustAv1FmtpParameters {
uint8_t profile;
bool has_profile;
uint8_t level_idx;
bool has_level_idx;
uint8_t tier;
bool has_tier;
};
struct RustRtxFmtpParameters {
uint8_t apt;
bool has_rtx_time;
uint32_t rtx_time;
};
struct RustSdpAttributeFmtpParameters {
uint32_t packetization_mode;
bool level_asymmetry_allowed;
uint32_t profile_level_id;
uint32_t max_fs;
uint32_t max_cpb;
uint32_t max_dpb;
uint32_t max_br;
uint32_t max_mbps;
uint32_t max_fr;
uint32_t maxplaybackrate;
uint32_t maxaveragebitrate;
bool usedtx;
bool stereo;
bool useinbandfec;
bool cbr;
uint32_t ptime;
uint32_t minptime;
uint32_t maxptime;
StringView dtmf_tones;
RustAv1FmtpParameters av1;
RustRtxFmtpParameters rtx;
RustSpan<uint8_t> encodings;
nsTArray<StringView> unknown_tokens;
};
struct RustSdpAttributeFmtp {
uint8_t payload_type;
StringView codec_name;
RustSdpAttributeFmtpParameters parameters;
};
struct RustSdpAttributeFlags {
bool ice_lite;
bool rtcp_mux;
bool rtcp_rsize;
bool bundle_only;
bool end_of_candidates;
bool extmap_allow_mixed;
};
struct RustSdpAttributeMsid {
StringView id;
StringView appdata;
};
struct RustSdpAttributeMsidSemantic {
StringView semantic;
nsTArray<StringView> msids;
};
struct RustSdpAttributeGroup {
RustSdpAttributeGroupSemantic semantic;
nsTArray<StringView> tags;
};
struct RustSdpAttributeRtcp {
uint32_t port;
RustExplicitlyTypedAddress unicast_addr;
bool has_address;
};
struct RustSdpAttributeRtcpFb {
uint32_t payload_type;
uint32_t feedback_type;
StringView parameter;
StringView extra;
};
struct RustSdpAttributeImageAttrXyRange {
uint32_t min;
uint32_t max;
uint32_t step;
RustSpan<uint32_t> discrete_values;
};
struct RustSdpAttributeImageAttrSRange {
float min;
float max;
RustSpan<float> discrete_values;
};
struct RustSdpAttributeImageAttrPRange {
float min;
float max;
};
struct RustSdpAttributeImageAttrSet {
RustSdpAttributeImageAttrXyRange x;
RustSdpAttributeImageAttrXyRange y;
bool has_sar;
RustSdpAttributeImageAttrSRange sar;
bool has_par;
RustSdpAttributeImageAttrPRange par;
float q;
};
struct RustSdpAttributeImageAttrSetList {
bool is_wildcard;
nsTArray<RustSdpAttributeImageAttrSet> sets;
};
struct RustSdpAttributeImageAttr {
uint32_t pt;
RustSdpAttributeImageAttrSetList send;
RustSdpAttributeImageAttrSetList recv;
};
struct RustSdpAttributeSctpmap {
uint32_t port;
uint32_t channels;
};
struct RustSdpAttributeSimulcastId {
StringView id;
bool paused;
};
struct RustSdpAttributeSimulcastVersion {
nsTArray<RustSdpAttributeSimulcastId> ids;
};
struct RustSdpAttributeSimulcast {
nsTArray<RustSdpAttributeSimulcastVersion> send;
nsTArray<RustSdpAttributeSimulcastVersion> receive;
};
struct RustSdpAttributeRemoteCandidate {
uint32_t component;
RustAddress address;
uint32_t port;
};
struct RustSdpAttributeRidParameters {
uint32_t max_width;
uint32_t max_height;
uint32_t max_fps;
uint32_t max_fs;
uint32_t max_br;
uint32_t max_pps;
nsTArray<StringView> unknown;
};
struct RustSdpAttributeRid {
StringView id;
uint32_t direction;
RustSpan<uint16_t> formats;
RustSdpAttributeRidParameters params;
nsTArray<StringView> depends;
};
struct RustSdpAttributeExtmap {
uint16_t id;
bool direction_specified;
RustDirection direction;
StringView url;
StringView extension_attributes;
};
extern "C" {
nsresult parse_sdp(StringView sdp,
bool fail_on_warning,
const SdpSession **session,
const SdpParserError **parser_error);
const SdpSession *create_anonymized_sdp_clone(const SdpSession *session);
SdpSession *create_sdp_clone(const SdpSession *session);
void sdp_free_session(SdpSession *sdp_ptr);
SdpSession *sdp_new_reference(SdpSession *session);
size_t sdp_get_error_line_num(SdpParserError *parser_error);
void sdp_get_error_message(const SdpParserError *parser_error, nsACString *out);
void sdp_free_error(SdpParserError *parser_error);
uint64_t get_version(const SdpSession *session);
RustSdpOrigin sdp_get_origin(const SdpSession *session);
StringView session_view(const SdpSession *session);
bool sdp_session_has_connection(const SdpSession *session);
nsresult sdp_get_session_connection(const SdpSession *session, RustSdpConnection *connection);
nsresult sdp_add_media_section(SdpSession *session,
uint32_t media_type,
uint32_t direction,
uint16_t port,
uint32_t protocol,
uint32_t addr_type,
StringView address);
bool sdp_session_has_timing(const SdpSession *session);
nsresult sdp_session_timing(const SdpSession *session, RustSdpTiming *timing);
size_t sdp_media_section_count(const SdpSession *session);
uint32_t get_sdp_bandwidth(const SdpSession *session, const nsACString *bandwidth_type);
const Vec<SdpBandwidth> *sdp_get_session_bandwidth_vec(const SdpSession *session);
const Vec<SdpAttribute> *get_sdp_session_attributes(const SdpSession *session);
uint32_t num_attributes(const SdpSession *session);
nsresult get_attribute_ptr(const SdpSession *session, uint32_t index, const SdpAttribute **ret);
nsresult sdp_get_dtls_message(const Vec<SdpAttribute> *attributes,
RustSdpAttributeDtlsMessage *ret);
nsresult sdp_get_iceufrag(const Vec<SdpAttribute> *attributes, StringView *ret);
nsresult sdp_get_icepwd(const Vec<SdpAttribute> *attributes, StringView *ret);
nsresult sdp_get_identity(const Vec<SdpAttribute> *attributes, StringView *ret);
nsresult sdp_get_iceoptions(const Vec<SdpAttribute> *attributes, nsTArray<StringView> *ret);
nsresult sdp_get_maxptime(const Vec<SdpAttribute> *attributes, uint64_t *ret);
void sdp_get_fingerprints(const Vec<SdpAttribute> *attributes,
nsTArray<RustSdpAttributeFingerprint> *ret_fingerprints);
nsresult sdp_get_setup(const Vec<SdpAttribute> *attributes, RustSdpAttributeSetup *ret);
void sdp_get_ssrcs(const Vec<SdpAttribute> *attributes, nsTArray<RustSdpAttributeSsrc> *ret);
void sdp_get_ssrc_groups(const Vec<SdpAttribute> *attributes, nsTArray<RustSdpSsrcGroup> *ret);
void sdp_get_rtpmaps(const Vec<SdpAttribute> *attributes, nsTArray<RustSdpAttributeRtpmap> *ret);
void sdp_get_fmtp(const Vec<SdpAttribute> *attributes, nsTArray<RustSdpAttributeFmtp> *ret);
int64_t sdp_get_ptime(const Vec<SdpAttribute> *attributes);
int64_t sdp_get_max_msg_size(const Vec<SdpAttribute> *attributes);
int64_t sdp_get_sctp_port(const Vec<SdpAttribute> *attributes);
RustSdpAttributeFlags sdp_get_attribute_flags(const Vec<SdpAttribute> *attributes);
nsresult sdp_get_mid(const Vec<SdpAttribute> *attributes, StringView *ret);
void sdp_get_msids(const Vec<SdpAttribute> *attributes, nsTArray<RustSdpAttributeMsid> *ret);
void sdp_get_msid_semantics(const Vec<SdpAttribute> *attributes,
nsTArray<RustSdpAttributeMsidSemantic> *ret);
void sdp_get_groups(const Vec<SdpAttribute> *attributes, nsTArray<RustSdpAttributeGroup> *ret);
nsresult sdp_get_rtcp(const Vec<SdpAttribute> *attributes, RustSdpAttributeRtcp *ret);
void sdp_get_rtcpfbs(const Vec<SdpAttribute> *attributes, nsTArray<RustSdpAttributeRtcpFb> *ret);
void sdp_get_imageattrs(const Vec<SdpAttribute> *attributes,
nsTArray<RustSdpAttributeImageAttr> *ret);
void sdp_get_sctpmaps(const Vec<SdpAttribute> *attributes, nsTArray<RustSdpAttributeSctpmap> *ret);
nsresult sdp_get_simulcast(const Vec<SdpAttribute> *attributes, RustSdpAttributeSimulcast *ret);
RustDirection sdp_get_direction(const Vec<SdpAttribute> *attributes);
void sdp_get_remote_candidates(const Vec<SdpAttribute> *attributes,
nsTArray<RustSdpAttributeRemoteCandidate> *ret);
void sdp_get_candidates(const Vec<SdpAttribute> *attributes, nsTArray<nsCString> *ret);
void sdp_get_rids(const Vec<SdpAttribute> *attributes, nsTArray<RustSdpAttributeRid> *ret);
void sdp_get_extmaps(const Vec<SdpAttribute> *attributes, nsTArray<RustSdpAttributeExtmap> *ret);
SdpMedia *sdp_get_media_section(SdpSession *session, uintptr_t index);
RustSdpMediaValue sdp_rust_get_media_type(const SdpMedia *sdp_media);
RustSdpProtocolValue sdp_get_media_protocol(const SdpMedia *sdp_media);
RustSdpFormatType sdp_get_format_type(const SdpMedia *sdp_media);
void sdp_get_format_string_vec(const SdpMedia *sdp_media, nsTArray<StringView> *ret);
RustSpan<uint32_t> sdp_get_format_u32_vec(const SdpMedia *sdp_media);
void sdp_set_media_port(SdpMedia *sdp_media, uint32_t port);
uint32_t sdp_get_media_port(const SdpMedia *sdp_media);
uint32_t sdp_get_media_port_count(const SdpMedia *sdp_media);
uint32_t sdp_get_media_bandwidth(const SdpMedia *sdp_media, const nsACString *bandwidth_type);
const Vec<SdpBandwidth> *sdp_get_media_bandwidth_vec(const SdpMedia *sdp_media);
bool sdp_media_has_connection(const SdpMedia *sdp_media);
nsresult sdp_get_media_connection(const SdpMedia *sdp_media, RustSdpConnection *ret);
const Vec<SdpAttribute> *sdp_get_media_attribute_list(const SdpMedia *sdp_media);
void sdp_media_clear_codecs(SdpMedia *sdp_media);
nsresult sdp_media_add_codec(SdpMedia *sdp_media,
uint8_t pt,
StringView codec_name,
uint32_t clockrate,
uint16_t channels);
nsresult sdp_media_add_datachannel(SdpMedia *sdp_media,
StringView name,
uint16_t port,
uint16_t streams,
uint32_t message_size);
void sdp_serialize_bandwidth(const Vec<SdpBandwidth> *bw, nsACString *out);
} // extern "C"
} // namespace ffi
} // namespace sdp
} // namespace mozilla
#endif // mozilla_sdp_RsdparsaSdpInc_h