Sign in

    moonbit-community/rtc/sdp does not have a README file

    IceCredentials

    SdpError

    pub(all) suberror SdpError {
    InvalidSyntax(String)
    UnsupportedAttribute(String)
    InvalidState(String)
    } derive(Eq,
    Debug
    )

    DataChannelParameters

    pub struct DataChannelParameters {
    mid : String
    bundle_mids : Array[String]
    ice_credentials :
    IceCredentials

    fingerprint : DtlsFingerprint
    setup : DtlsSetup
    candidates : Array[String]
    end_of_candidates : Bool
    sctp_port : UInt16
    max_message_size : UInt64
    } derive(Eq,
    Debug
    )

    DataChannelParameters::bundle_mids

    fn DataChannelParameters::bundle_mids(self : DataChannelParameters) -> Array[String]

    DataChannelParameters::candidates

    fn DataChannelParameters::candidates(self : DataChannelParameters) -> Array[String]

    DataChannelParameters::end_of_candidates

    fn DataChannelParameters::end_of_candidates(self : DataChannelParameters) -> Bool

    DataChannelParameters::fingerprint

    DataChannelParameters::ice_credentials

    DataChannelParameters::max_message_size

    fn DataChannelParameters::max_message_size(self : DataChannelParameters) -> UInt64

    DataChannelParameters::mid

    DataChannelParameters::sctp_port

    fn DataChannelParameters::sctp_port(self : DataChannelParameters) -> UInt16

    DataChannelParameters::setup

    DataChannelParameters::validate_for_type

    fn DataChannelParameters::validate_for_type(self : DataChannelParameters, sdp_type : SdpType) -> Unit raise SdpError

    DtlsFingerprint

    pub struct DtlsFingerprint {
    algorithm : String
    value : String
    } derive(Eq,
    Debug
    )

    DtlsFingerprint::algorithm

    fn DtlsFingerprint::algorithm(self : DtlsFingerprint) -> String

    DtlsFingerprint::new

    fn DtlsFingerprint::new(algorithm~ : String, value~ : String) -> DtlsFingerprint raise SdpError

    DtlsFingerprint::value

    fn DtlsFingerprint::value(self : DtlsFingerprint) -> String

    DtlsSetup

    pub(all) enum DtlsSetup {
    ActPass
    Active
    Passive
    HoldConn
    } derive(Eq,
    Debug
    )

    DtlsSetup::parse

    fn DtlsSetup::parse(value : String) -> DtlsSetup raise SdpError

    DtlsSetup::to_string

    fn DtlsSetup::to_string(self : DtlsSetup) -> String

    MediaDescription

    pub struct MediaDescription {
    media_kind : String
    port : UInt16
    port_count : UInt16?
    protocol : String
    formats : Array[String]
    fields : Array[SdpField]
    } derive(Eq,
    Debug
    )

    MediaDescription::add_attribute

    fn MediaDescription::add_attribute(self : MediaDescription, attribute : SdpAttribute) -> Unit raise SdpError

    MediaDescription::add_field

    fn MediaDescription::add_field(self : MediaDescription, field : SdpField) -> Unit

    MediaDescription::attribute

    fn MediaDescription::attribute(self : MediaDescription, key : String) -> SdpAttribute? raise SdpError

    MediaDescription::attributes

    fn MediaDescription::attributes(self : MediaDescription, key : String) -> Array[SdpAttribute] raise SdpError

    MediaDescription::fields

    MediaDescription::formats

    fn MediaDescription::formats(self : MediaDescription) -> Array[String]

    MediaDescription::media_kind

    fn MediaDescription::media_kind(self : MediaDescription) -> String

    MediaDescription::new

    fn MediaDescription::new(media_kind~ : String, port~ : UInt16, port_count? : UInt16, protocol~ : String, formats~ : Array[String], fields? : Array[SdpField]) -> MediaDescription raise SdpError

    MediaDescription::port

    fn MediaDescription::port(self : MediaDescription) -> UInt16

    MediaDescription::port_count

    fn MediaDescription::port_count(self : MediaDescription) -> UInt16?

    MediaDescription::protocol

    fn MediaDescription::protocol(self : MediaDescription) -> String

    MediaDirection

    pub(all) enum MediaDirection {
    SendRecv
    SendOnly
    RecvOnly
    Inactive
    } derive(Eq,
    Debug
    )

    MediaDirection::parse

    fn MediaDirection::parse(value : String) -> MediaDirection raise SdpError

    MediaDirection::to_string

    fn MediaDirection::to_string(self : MediaDirection) -> String

    RidDirection

    pub(all) enum RidDirection {
    RidSend
    RidRecv
    } derive(Eq,
    Debug
    )

    RtpCodecParameters

    pub(all) struct RtpCodecParameters {
    payload_type : Byte
    encoding_name : String
    clock_rate : UInt
    channels : UInt16
    fmtp : String
    rtcp_feedback : Array[String]
    } derive(Eq,
    Debug
    )

    RtpCodecParameters::channels

    fn RtpCodecParameters::channels(self : RtpCodecParameters) -> UInt16

    RtpCodecParameters::clock_rate

    fn RtpCodecParameters::clock_rate(self : RtpCodecParameters) -> UInt

    RtpCodecParameters::encoding_name

    fn RtpCodecParameters::encoding_name(self : RtpCodecParameters) -> String

    RtpCodecParameters::fmtp

    fn RtpCodecParameters::fmtp(self : RtpCodecParameters) -> String

    RtpCodecParameters::new

    fn RtpCodecParameters::new(payload_type~ : Byte, encoding_name~ : String, clock_rate~ : UInt, channels? : UInt16, fmtp? : String, rtcp_feedback? : Array[String]) -> RtpCodecParameters raise SdpError

    RtpCodecParameters::payload_type

    fn RtpCodecParameters::payload_type(self : RtpCodecParameters) -> Byte

    RtpCodecParameters::rtcp_feedback

    fn RtpCodecParameters::rtcp_feedback(self : RtpCodecParameters) -> Array[String]

    RtpHeaderExtensionParameters

    pub(all) struct RtpHeaderExtensionParameters {
    id : Byte
    uri : String
    } derive(Eq,
    Debug
    )

    RtpHeaderExtensionParameters::id

    RtpHeaderExtensionParameters::new

    fn RtpHeaderExtensionParameters::new(id~ : Byte, uri~ : String) -> RtpHeaderExtensionParameters raise SdpError

    RtpHeaderExtensionParameters::uri

    RtpMediaParameters

    pub(all) struct RtpMediaParameters {
    kind : String
    mid : String
    direction : MediaDirection
    codecs : Array[RtpCodecParameters]
    header_extensions : Array[RtpHeaderExtensionParameters]
    stream_id : String?
    track_id : String?
    ssrc : UInt?
    rtx_ssrc : UInt?
    streams : Array[RtpStreamParameters]
    cname : String?
    } derive(Eq,
    Debug
    )

    RtpMediaParameters::cname

    fn RtpMediaParameters::cname(self : RtpMediaParameters) -> String?

    RtpMediaParameters::codecs

    RtpMediaParameters::direction

    RtpMediaParameters::header_extensions

    RtpMediaParameters::kind

    fn RtpMediaParameters::kind(self : RtpMediaParameters) -> String

    RtpMediaParameters::mid

    fn RtpMediaParameters::mid(self : RtpMediaParameters) -> String

    RtpMediaParameters::new

    fn RtpMediaParameters::new(kind~ : String, mid~ : String, direction? : MediaDirection, codecs~ : Array[RtpCodecParameters], header_extensions? : Array[RtpHeaderExtensionParameters], stream_id? : String, track_id? : String, ssrc? : UInt, rtx_ssrc? : UInt, streams? : Array[RtpStreamParameters], cname? : String) -> RtpMediaParameters raise SdpError

    RtpMediaParameters::rtx_ssrc

    fn RtpMediaParameters::rtx_ssrc(self : RtpMediaParameters) -> UInt?

    RtpMediaParameters::ssrc

    fn RtpMediaParameters::ssrc(self : RtpMediaParameters) -> UInt?

    RtpMediaParameters::stream_id

    fn RtpMediaParameters::stream_id(self : RtpMediaParameters) -> String?

    RtpMediaParameters::streams

    RtpMediaParameters::track_id

    fn RtpMediaParameters::track_id(self : RtpMediaParameters) -> String?

    RtpStreamParameters

    pub(all) struct RtpStreamParameters {
    ssrc : UInt?
    rtx_ssrc : UInt?
    rid : String?
    paused : Bool
    rid_direction : RidDirection
    } derive(Eq,
    Debug
    )

    RtpStreamParameters::new

    fn RtpStreamParameters::new(ssrc? : UInt, rtx_ssrc? : UInt, rid? : String, paused? : Bool, rid_direction? : RidDirection) -> RtpStreamParameters raise SdpError

    SdpAttribute

    pub struct SdpAttribute {
    key : String
    value : String?
    } derive(Eq,
    Debug
    )

    SdpAttribute::key

    fn SdpAttribute::key(self : SdpAttribute) -> String

    SdpAttribute::new

    fn SdpAttribute::new(key~ : String, value? : String) -> SdpAttribute raise SdpError

    SdpAttribute::value

    fn SdpAttribute::value(self : SdpAttribute) -> String?

    SdpDocument

    pub struct SdpDocument {
    session_fields : Array[SdpField]
    media_descriptions : Array[MediaDescription]
    } derive(Eq,
    Debug
    )

    SdpDocument::datachannel_parameters

    fn SdpDocument::datachannel_parameters(self : SdpDocument) -> DataChannelParameters raise SdpError

    SdpDocument::marshal

    fn SdpDocument::marshal(self : SdpDocument) -> String

    SdpDocument::media_descriptions

    fn SdpDocument::media_descriptions(self : SdpDocument) -> Array[MediaDescription]

    SdpDocument::new

    fn SdpDocument::new(session_fields~ : Array[SdpField], media_descriptions? : Array[MediaDescription]) -> SdpDocument raise SdpError

    SdpDocument::new_datachannel

    fn SdpDocument::new_datachannel(session_id~ : UInt64, session_version~ : UInt64, mid~ : String, ice_credentials~ :
    IceCredentials
    , fingerprint~ : DtlsFingerprint, setup~ : DtlsSetup, candidates? : Array[String], end_of_candidates? : Bool, sctp_port? : UInt16, max_message_size? : UInt64, media_sections? : Array[RtpMediaParameters], application_index? : Int) -> SdpDocument raise SdpError

    SdpDocument::parse

    fn SdpDocument::parse(sdp : String) -> SdpDocument raise SdpError

    SdpDocument::rtp_media_parameters

    fn SdpDocument::rtp_media_parameters(self : SdpDocument) -> Array[RtpMediaParameters] raise SdpError

    SdpDocument::session_attribute

    fn SdpDocument::session_attribute(self : SdpDocument, key : String) -> SdpAttribute? raise SdpError

    SdpDocument::session_attributes

    fn SdpDocument::session_attributes(self : SdpDocument, key : String) -> Array[SdpAttribute] raise SdpError

    SdpDocument::session_fields

    fn SdpDocument::session_fields(self : SdpDocument) -> Array[SdpField]

    SdpField

    pub struct SdpField {
    kind : Byte
    value : String
    } derive(Eq,
    Debug
    )

    SdpField::kind

    fn SdpField::kind(self : SdpField) -> Byte

    SdpField::new

    fn SdpField::new(kind~ : Byte, value~ : String) -> SdpField raise SdpError

    SdpField::value

    fn SdpField::value(self : SdpField) -> String

    SdpType

    pub(all) enum SdpType {
    Offer
    Pranswer
    Answer
    Rollback
    } derive(Eq,
    Debug
    )

    SessionDescription

    pub struct SessionDescription {
    sdp_type : SdpType
    sdp : String
    } derive(Eq,
    Debug
    )

    SessionDescription::datachannel_parameters

    fn SessionDescription::datachannel_parameters(self : SessionDescription) -> DataChannelParameters raise SdpError

    SessionDescription::document

    SessionDescription::from_document

    fn SessionDescription::from_document(sdp_type~ : SdpType, document : SdpDocument) -> SessionDescription raise SdpError

    SessionDescription::new

    fn SessionDescription::new(sdp_type~ : SdpType, sdp~ : String) -> SessionDescription

    SessionDescription::rtp_media_parameters

    fn SessionDescription::rtp_media_parameters(self : SessionDescription) -> Array[RtpMediaParameters] raise SdpError

    SessionDescription::sdp

    fn SessionDescription::sdp(self : SessionDescription) -> String

    SessionDescription::sdp_type

    SignalingState

    pub(all) enum SignalingState {
    Stable
    HaveLocalOffer
    HaveRemoteOffer
    HaveLocalPranswer
    HaveRemotePranswer
    Closed
    } derive(Eq,
    Debug
    )

    SignalingStateMachine

    pub struct SignalingStateMachine {
    state : SignalingState
    current_local : SessionDescription?
    current_remote : SessionDescription?
    pending_local : SessionDescription?
    pending_remote : SessionDescription?
    }

    SignalingStateMachine::close

    SignalingStateMachine::current_local_description

    fn SignalingStateMachine::current_local_description(self : SignalingStateMachine) -> SessionDescription?

    SignalingStateMachine::current_remote_description

    fn SignalingStateMachine::current_remote_description(self : SignalingStateMachine) -> SessionDescription?

    SignalingStateMachine::local_description

    SignalingStateMachine::new

    SignalingStateMachine::pending_local_description

    fn SignalingStateMachine::pending_local_description(self : SignalingStateMachine) -> SessionDescription?

    SignalingStateMachine::pending_remote_description

    fn SignalingStateMachine::pending_remote_description(self : SignalingStateMachine) -> SessionDescription?

    SignalingStateMachine::remote_description

    SignalingStateMachine::set_local_description

    fn SignalingStateMachine::set_local_description(self : SignalingStateMachine, description : SessionDescription) -> Unit raise SdpError

    SignalingStateMachine::set_remote_description

    fn SignalingStateMachine::set_remote_description(self : SignalingStateMachine, description : SessionDescription) -> Unit raise SdpError

    SignalingStateMachine::state