🥮 mooncakes.io
    Sign in

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

    InterceptorError

    source
    pub(all) suberror InterceptorError {
      InvalidConfiguration(String)
      PipelineFailed(String)
    } derive(Eq, 
    Debug    )

    Context

    source
    pub(all) struct Context {
      direction : Direction
      stream_id : String?
    } derive(Eq, 
    Debug    )

    Context::direction

    source
    fn Context::direction(self : Context) -> Direction

    Context::new

    source
    fn Context::new(direction~ : Direction, stream_id? : String) -> Context

    Context::stream_id

    source
    fn Context::stream_id(self : Context) -> String?

    Direction

    source
    pub(all) enum Direction {
      Inbound
      Outbound
    } derive(Eq, 
    Debug    )

    MissingPacket

    source
    type MissingPacket

    NackGenerator

    source
    pub struct NackGenerator {
      sender_ssrc : UInt
      media_ssrc : UInt
      max_tracked : Int
      max_retries : Int
      missing : Array[MissingPacket]
      last_sequence : UInt16?
    }

    NackGenerator::missing_sequences

    source
    fn NackGenerator::missing_sequences(self : NackGenerator) -> Array[UInt16]

    NackGenerator::new

    source
    fn NackGenerator::new(sender_ssrc~ : UInt, media_ssrc~ : UInt, max_tracked? : Int, max_retries? : Int) -> NackGenerator raise InterceptorError

    NackGenerator::observe

    source

    NackGenerator::poll_feedback

    source

    Packet

    source

    Pipeline

    source
    pub struct Pipeline {
      stages : Array[Stage]
    }

    Pipeline::add

    source
    fn Pipeline::add(self : Pipeline, stage : Stage) -> Unit

    Pipeline::length

    source
    fn Pipeline::length(self : Pipeline) -> Int

    Pipeline::new

    source
    fn Pipeline::new() -> Pipeline

    Pipeline::process

    source
    fn Pipeline::process(self : Pipeline, context : Context, packet : Packet) -> Array[Packet] raise InterceptorError

    ReceiverReportGenerator

    source
    pub struct ReceiverReportGenerator {
      sender_ssrc : UInt
      media_ssrc : UInt
      clock_rate : UInt
      initialized : Bool
      base_sequence : UInt16
      max_sequence : UInt16
      cycles : UInt
      received : UInt
      octet_count : UInt64
      expected_prior : UInt
      received_prior : UInt
      transit : Int64?
      jitter : Int64
      seen : Array[UInt]
      last_sender_report : UInt
      last_sender_report_arrival_ms : Int64?
    }

    ReceiverReportGenerator::jitter

    source

    ReceiverReportGenerator::new

    source
    fn ReceiverReportGenerator::new(sender_ssrc~ : UInt, media_ssrc~ : UInt, clock_rate~ : UInt) -> ReceiverReportGenerator raise InterceptorError

    ReceiverReportGenerator::observe

    source
    fn ReceiverReportGenerator::observe(self : ReceiverReportGenerator, packet : 
    Packet    , arrival_ticks : UInt) -> Unit

    ReceiverReportGenerator::observe_sender_report

    source
    fn ReceiverReportGenerator::observe_sender_report(self : ReceiverReportGenerator, report : 
    SenderReportPacket    , arrival_ms : Int64) -> Unit

    ReceiverReportGenerator::octet_count

    source
    fn ReceiverReportGenerator::octet_count(self : ReceiverReportGenerator) -> UInt64

    ReceiverReportGenerator::packet_count

    source
    fn ReceiverReportGenerator::packet_count(self : ReceiverReportGenerator) -> UInt

    ReceiverReportGenerator::packets_lost

    source
    fn ReceiverReportGenerator::packets_lost(self : ReceiverReportGenerator) -> UInt64

    ReceiverReportGenerator::report

    source

    RtxReceiver

    source
    pub struct RtxReceiver {
      media_ssrc : UInt
      media_payload_type : Byte
      rtx_ssrc : UInt
      rtx_payload_type : Byte
      recent : Array[UInt16]
      capacity : Int
    }

    RtxReceiver::new

    source
    fn RtxReceiver::new(media_ssrc~ : UInt, media_payload_type~ : Byte, rtx_ssrc~ : UInt, rtx_payload_type~ : Byte, capacity? : Int) -> RtxReceiver raise InterceptorError

    RtxReceiver::observe_primary

    source
    fn RtxReceiver::observe_primary(self : RtxReceiver, packet : 
    Packet    ) -> Unit

    RtxReceiver::recover

    source

    RtxSender

    source
    pub struct RtxSender {
      media_ssrc : UInt
      rtx_ssrc : UInt
      rtx_payload_type : Byte
      capacity : Int
      history : Array[
    Packet    ]
      sequence_number : UInt16
      retransmitted_packets : UInt64
      retransmitted_bytes : UInt64
    }

    RtxSender::new

    source
    fn RtxSender::new(media_ssrc~ : UInt, rtx_ssrc~ : UInt, rtx_payload_type~ : Byte, sequence_number? : UInt16, capacity? : Int) -> RtxSender raise InterceptorError

    RtxSender::remember

    source
    fn RtxSender::remember(self : RtxSender, packet : 
    Packet    ) -> Unit

    RtxSender::retransmit

    source

    RtxSender::retransmitted_bytes

    source
    fn RtxSender::retransmitted_bytes(self : RtxSender) -> UInt64

    RtxSender::retransmitted_packets

    source
    fn RtxSender::retransmitted_packets(self : RtxSender) -> UInt64

    SenderReportGenerator

    source
    pub struct SenderReportGenerator {
      sender_ssrc : UInt
      packet_count : UInt
      octet_count : UInt
      last_rtp_timestamp : UInt
    }

    SenderReportGenerator::new

    source
    fn SenderReportGenerator::new(sender_ssrc : UInt) -> SenderReportGenerator

    SenderReportGenerator::observe

    source

    SenderReportGenerator::octet_count

    source
    fn SenderReportGenerator::octet_count(self : SenderReportGenerator) -> UInt

    SenderReportGenerator::packet_count

    source
    fn SenderReportGenerator::packet_count(self : SenderReportGenerator) -> UInt

    SenderReportGenerator::report

    source

    Stage

    source
    pub struct Stage {
      name : String
      handler : (Context, Packet) -> Array[Packet] raise InterceptorError
    }

    Stage::name

    source
    fn Stage::name(self : Stage) -> String

    Stage::new

    source
    fn Stage::new(name~ : String, handler~ : (Context, Packet) -> Array[Packet] raise InterceptorError) -> Stage raise InterceptorError

    TwccObservation

    source
    type TwccObservation

    TwccRecorder

    source
    pub struct TwccRecorder {
      sender_ssrc : UInt
      media_ssrc : UInt
      extension_id : Byte
      max_packets : Int
      observations : Array[TwccObservation]
      base_sequence : UInt16?
      feedback_packet_count : Byte
    }

    TwccRecorder::new

    source
    fn TwccRecorder::new(sender_ssrc~ : UInt, media_ssrc~ : UInt, extension_id~ : Byte, max_packets? : Int) -> TwccRecorder raise InterceptorError

    TwccRecorder::observe

    source
    fn TwccRecorder::observe(self : TwccRecorder, packet : 
    Packet    , arrival_us : Int64) -> Unit raise InterceptorError

    TwccRecorder::observe_with_extension_id

    source
    fn TwccRecorder::observe_with_extension_id(self : TwccRecorder, packet : 
    Packet    , arrival_us : Int64, extension_id : Byte) -> Unit raise InterceptorError

    TwccRecorder::poll_feedback

    source

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io