🥮 mooncakes.io
    Sign in

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

    RtcpError

    source
    pub(all) suberror RtcpError {
      InvalidPacket(String)
      InvalidCompoundPacket(String)
      PacketTooLarge(Int)
    } derive(Eq, 
    Debug    )

    ApplicationDefinedPacket

    source
    pub(all) struct ApplicationDefinedPacket {
      subtype : Byte
      ssrc : UInt
      name : Bytes
      data : Bytes
    } derive(Eq, 
    Debug    )

    ApplicationDefinedPacket::marshal

    source

    ApplicationDefinedPacket::new

    source
    fn ApplicationDefinedPacket::new(subtype? : Byte, ssrc~ : UInt, name~ : Bytes, data? : Bytes) -> ApplicationDefinedPacket raise RtcpError

    ApplicationDefinedPacket::to_packet

    source

    ExtendedReportBlock

    source
    pub(all) struct ExtendedReportBlock {
      block_type : Byte
      type_specific : Byte
      payload : Bytes
    } derive(Eq, 
    Debug    )

    ExtendedReportBlock::new

    source
    fn ExtendedReportBlock::new(block_type~ : Byte, type_specific? : Byte, payload~ : Bytes) -> ExtendedReportBlock raise RtcpError

    ExtendedReportPacket

    source
    pub(all) struct ExtendedReportPacket {
      sender_ssrc : UInt
      blocks : Array[ExtendedReportBlock]
    } derive(Eq, 
    Debug    )

    ExtendedReportPacket::marshal

    source
    fn ExtendedReportPacket::marshal(self : ExtendedReportPacket) -> Bytes raise RtcpError

    ExtendedReportPacket::new

    source
    fn ExtendedReportPacket::new(sender_ssrc~ : UInt, blocks? : Array[ExtendedReportBlock]) -> ExtendedReportPacket

    ExtendedReportPacket::to_packet

    source

    FullIntraRequestEntry

    source
    pub(all) struct FullIntraRequestEntry {
      ssrc : UInt
      sequence_number : Byte
    } derive(Eq, 
    Debug    )

    FullIntraRequestPacket

    source
    pub(all) struct FullIntraRequestPacket {
      sender_ssrc : UInt
      media_ssrc : UInt
      entries : Array[FullIntraRequestEntry]
    } derive(Eq, 
    Debug    )

    FullIntraRequestPacket::marshal

    source
    fn FullIntraRequestPacket::marshal(self : FullIntraRequestPacket) -> Bytes raise RtcpError

    FullIntraRequestPacket::new

    source
    fn FullIntraRequestPacket::new(sender_ssrc~ : UInt, media_ssrc? : UInt, entries~ : Array[FullIntraRequestEntry]) -> FullIntraRequestPacket

    FullIntraRequestPacket::to_packet

    source

    GoodbyePacket

    source
    pub(all) struct GoodbyePacket {
      sources : Array[UInt]
      reason : Bytes?
    } derive(Eq, 
    Debug    )

    GoodbyePacket::marshal

    source
    fn GoodbyePacket::marshal(self : GoodbyePacket) -> Bytes raise RtcpError

    GoodbyePacket::new

    source
    fn GoodbyePacket::new(sources~ : Array[UInt], reason? : Bytes) -> GoodbyePacket raise RtcpError

    GoodbyePacket::to_packet

    source
    fn GoodbyePacket::to_packet(self : GoodbyePacket) -> Packet raise RtcpError

    pub(all) struct Header {
      padding : Bool
      count : Byte
      packet_type : Byte
      length_words_minus_one : UInt16
    } derive(Eq, 
    Debug    )

    Header::count

    source
    fn Header::count(self : Header) -> Byte

    Header::length_words_minus_one

    source
    fn Header::length_words_minus_one(self : Header) -> UInt16

    Header::packet_type

    source
    fn Header::packet_type(self : Header) -> Byte

    Header::padding

    source
    fn Header::padding(self : Header) -> Bool

    NackPair

    source
    pub(all) struct NackPair {
      packet_id : UInt16
      lost_packets : UInt16
    } derive(Eq, 
    Debug    )

    NackPair::lost_sequence_numbers

    source
    fn NackPair::lost_sequence_numbers(self : NackPair) -> Array[UInt16]

    NackPair::new

    source
    fn NackPair::new(packet_id~ : UInt16, lost_packets? : UInt16) -> NackPair

    Packet

    source
    pub(all) enum Packet {
      SenderReport(Bytes)
      ReceiverReport(Bytes)
      SourceDescription(Bytes)
      Goodbye(Bytes)
      ApplicationDefined(Bytes)
      TransportFeedback(Bytes)
      PayloadFeedback(Bytes)
      ExtendedReport(Bytes)
      Unknown(Bytes)
    } derive(Eq, 
    Debug    )

    Packet::as_application_defined

    source
    fn Packet::as_application_defined(self : Packet) -> ApplicationDefinedPacket raise RtcpError

    Packet::as_extended_report

    source
    fn Packet::as_extended_report(self : Packet) -> ExtendedReportPacket raise RtcpError

    Packet::as_full_intra_request

    source
    fn Packet::as_full_intra_request(self : Packet) -> FullIntraRequestPacket raise RtcpError

    Packet::as_goodbye

    source
    fn Packet::as_goodbye(self : Packet) -> GoodbyePacket raise RtcpError

    Packet::as_picture_loss_indication

    source
    fn Packet::as_picture_loss_indication(self : Packet) -> PictureLossIndicationPacket raise RtcpError

    Packet::as_receiver_estimated_maximum_bitrate

    source
    fn Packet::as_receiver_estimated_maximum_bitrate(self : Packet) -> ReceiverEstimatedMaximumBitratePacket raise RtcpError

    Packet::as_receiver_report

    source
    fn Packet::as_receiver_report(self : Packet) -> ReceiverReportPacket raise RtcpError

    Packet::as_sender_report

    source
    fn Packet::as_sender_report(self : Packet) -> SenderReportPacket raise RtcpError

    Packet::as_source_description

    source
    fn Packet::as_source_description(self : Packet) -> SourceDescriptionPacket raise RtcpError

    Packet::as_transport_layer_nack

    source
    fn Packet::as_transport_layer_nack(self : Packet) -> TransportLayerNackPacket raise RtcpError

    Packet::as_transport_wide_cc

    source
    fn Packet::as_transport_wide_cc(self : Packet) -> TransportWideCcPacket raise RtcpError

    Packet::decode

    source
    fn Packet::decode(data : Bytes) -> Packet raise RtcpError

    Packet::header

    source
    fn Packet::header(self : Packet) -> Header raise RtcpError

    Packet::marshal

    source
    fn Packet::marshal(self : Packet) -> Bytes raise RtcpError

    Packet::unmarshal

    source
    fn Packet::unmarshal(data : Bytes) -> Packet raise RtcpError

    PictureLossIndicationPacket

    source
    pub(all) struct PictureLossIndicationPacket {
      sender_ssrc : UInt
      media_ssrc : UInt
    } derive(Eq, 
    Debug    )

    PictureLossIndicationPacket::marshal

    source

    PictureLossIndicationPacket::new

    source
    fn PictureLossIndicationPacket::new(sender_ssrc~ : UInt, media_ssrc~ : UInt) -> PictureLossIndicationPacket

    PictureLossIndicationPacket::to_packet

    source

    ReceiverEstimatedMaximumBitratePacket

    source
    pub(all) struct ReceiverEstimatedMaximumBitratePacket {
      sender_ssrc : UInt
      bitrate : UInt64
      ssrcs : Array[UInt]
    } derive(Eq, 
    Debug    )

    ReceiverEstimatedMaximumBitratePacket::marshal

    source

    ReceiverEstimatedMaximumBitratePacket::new

    source
    fn ReceiverEstimatedMaximumBitratePacket::new(sender_ssrc~ : UInt, bitrate~ : UInt64, ssrcs~ : Array[UInt]) -> ReceiverEstimatedMaximumBitratePacket raise RtcpError

    ReceiverEstimatedMaximumBitratePacket::to_packet

    source

    ReceiverReportPacket

    source
    pub(all) struct ReceiverReportPacket {
      sender_ssrc : UInt
      reports : Array[ReceptionReport]
      profile_extensions : Bytes
    } derive(Eq, 
    Debug    )

    ReceiverReportPacket::marshal

    source
    fn ReceiverReportPacket::marshal(self : ReceiverReportPacket) -> Bytes raise RtcpError

    ReceiverReportPacket::new

    source
    fn ReceiverReportPacket::new(sender_ssrc~ : UInt, reports? : Array[ReceptionReport], profile_extensions? : Bytes) -> ReceiverReportPacket raise RtcpError

    ReceiverReportPacket::to_packet

    source

    ReceptionReport

    source
    pub(all) struct ReceptionReport {
      ssrc : UInt
      fraction_lost : Byte
      cumulative_lost : Int
      extended_sequence_number : UInt
      jitter : UInt
      last_sender_report : UInt
      delay_since_last_sender_report : UInt
    } derive(Eq, 
    Debug    )

    ReceptionReport::cumulative_lost

    source
    fn ReceptionReport::cumulative_lost(self : ReceptionReport) -> Int

    ReceptionReport::delay_since_last_sender_report

    source
    fn ReceptionReport::delay_since_last_sender_report(self : ReceptionReport) -> UInt

    ReceptionReport::extended_sequence_number

    source
    fn ReceptionReport::extended_sequence_number(self : ReceptionReport) -> UInt

    ReceptionReport::fraction_lost

    source
    fn ReceptionReport::fraction_lost(self : ReceptionReport) -> Byte

    ReceptionReport::jitter

    source
    fn ReceptionReport::jitter(self : ReceptionReport) -> UInt

    ReceptionReport::last_sender_report

    source
    fn ReceptionReport::last_sender_report(self : ReceptionReport) -> UInt

    ReceptionReport::new

    source
    fn ReceptionReport::new(ssrc~ : UInt, fraction_lost? : Byte, cumulative_lost? : Int, extended_sequence_number? : UInt, jitter? : UInt, last_sender_report? : UInt, delay_since_last_sender_report? : UInt) -> ReceptionReport raise RtcpError

    ReceptionReport::ssrc

    source
    fn ReceptionReport::ssrc(self : ReceptionReport) -> UInt

    SenderReportPacket

    source
    pub(all) struct SenderReportPacket {
      sender_ssrc : UInt
      ntp_timestamp : UInt64
      rtp_timestamp : UInt
      packet_count : UInt
      octet_count : UInt
      reports : Array[ReceptionReport]
      profile_extensions : Bytes
    } derive(Eq, 
    Debug    )

    SenderReportPacket::marshal

    source
    fn SenderReportPacket::marshal(self : SenderReportPacket) -> Bytes raise RtcpError

    SenderReportPacket::new

    source
    fn SenderReportPacket::new(sender_ssrc~ : UInt, ntp_timestamp~ : UInt64, rtp_timestamp~ : UInt, packet_count~ : UInt, octet_count~ : UInt, reports? : Array[ReceptionReport], profile_extensions? : Bytes) -> SenderReportPacket raise RtcpError

    SenderReportPacket::to_packet

    source
    fn SenderReportPacket::to_packet(self : SenderReportPacket) -> Packet raise RtcpError

    SourceDescriptionChunk

    source
    pub(all) struct SourceDescriptionChunk {
      source : UInt
      items : Array[SourceDescriptionItem]
    } derive(Eq, 
    Debug    )

    SourceDescriptionChunk::new

    source

    SourceDescriptionItem

    source
    pub(all) struct SourceDescriptionItem {
      item_type : SourceDescriptionType
      value : Bytes
    } derive(Eq, 
    Debug    )

    SourceDescriptionItem::new

    source
    fn SourceDescriptionItem::new(item_type~ : SourceDescriptionType, value~ : Bytes) -> SourceDescriptionItem raise RtcpError

    SourceDescriptionPacket

    source
    pub(all) struct SourceDescriptionPacket {
      chunks : Array[SourceDescriptionChunk]
    } derive(Eq, 
    Debug    )

    SourceDescriptionPacket::marshal

    source
    fn SourceDescriptionPacket::marshal(self : SourceDescriptionPacket) -> Bytes raise RtcpError

    SourceDescriptionPacket::new

    source

    SourceDescriptionPacket::to_packet

    source

    SourceDescriptionType

    source
    pub(all) enum SourceDescriptionType {
      Cname
      Name
      Email
      Phone
      Location
      Tool
      Note
      Private
      Unknown(Byte)
    } derive(Eq, 
    Debug    )

    TransportLayerNackPacket

    source
    pub(all) struct TransportLayerNackPacket {
      sender_ssrc : UInt
      media_ssrc : UInt
      nacks : Array[NackPair]
    } derive(Eq, 
    Debug    )

    TransportLayerNackPacket::marshal

    source

    TransportLayerNackPacket::new

    source
    fn TransportLayerNackPacket::new(sender_ssrc~ : UInt, media_ssrc~ : UInt, nacks~ : Array[NackPair]) -> TransportLayerNackPacket

    TransportLayerNackPacket::to_packet

    source

    TransportWideCcPacket

    source
    pub(all) struct TransportWideCcPacket {
      sender_ssrc : UInt
      media_ssrc : UInt
      base_sequence_number : UInt16
      reference_time : UInt
      feedback_packet_count : Byte
      statuses : Array[TransportWideStatus]
    } derive(Eq, 
    Debug    )

    TransportWideCcPacket::marshal

    source
    fn TransportWideCcPacket::marshal(self : TransportWideCcPacket) -> Bytes raise RtcpError

    TransportWideCcPacket::new

    source
    fn TransportWideCcPacket::new(sender_ssrc~ : UInt, media_ssrc~ : UInt, base_sequence_number~ : UInt16, reference_time~ : UInt, feedback_packet_count? : Byte, statuses~ : Array[TransportWideStatus]) -> TransportWideCcPacket raise RtcpError

    TransportWideCcPacket::to_packet

    source

    TransportWideStatus

    source
    pub(all) enum TransportWideStatus {
      PacketNotReceived
      PacketReceivedSmallDelta(Int)
      PacketReceivedLargeDelta(Int)
      PacketReceivedWithoutDelta
    } derive(Eq, 
    Debug    )

    decode_compound

    source
    fn decode_compound(data : Bytes) -> Array[Packet] raise RtcpError

    encode_compound

    source
    fn encode_compound(packets : Array[Packet]) -> Bytes raise RtcpError

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io