Sign in

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

    MediaError

    pub(all) suberror MediaError {
    InvalidCodec(String)
    InvalidTrack(String)
    InvalidMedia(String)
    EndOfStream
    } derive(Eq,
    Debug
    )

    AudioBuffer

    pub struct AudioBuffer {
    samples : Array[Int16]
    channels : Int
    layout : AudioLayout
    } derive(Eq,
    Debug
    )

    AudioBuffer::channels

    fn AudioBuffer::channels(self : AudioBuffer) -> Int

    AudioBuffer::frames

    fn AudioBuffer::frames(self : AudioBuffer) -> Int

    AudioBuffer::from_pcm_s16

    fn AudioBuffer::from_pcm_s16(data : Bytes, channels~ : Int, little_endian? : Bool, layout? : AudioLayout) -> AudioBuffer raise MediaError

    AudioBuffer::layout

    fn AudioBuffer::layout(self : AudioBuffer) -> AudioLayout

    AudioBuffer::new

    fn AudioBuffer::new(samples~ : Array[Int16], channels~ : Int, layout? : AudioLayout) -> AudioBuffer raise MediaError

    AudioBuffer::sample

    fn AudioBuffer::sample(self : AudioBuffer, channel : Int, frame : Int) -> Int16 raise MediaError

    AudioBuffer::sample_count

    fn AudioBuffer::sample_count(self : AudioBuffer) -> Int

    AudioBuffer::samples

    fn AudioBuffer::samples(self : AudioBuffer) -> Array[Int16]

    AudioBuffer::slice_frames

    fn AudioBuffer::slice_frames(self : AudioBuffer, start : Int, end : Int) -> AudioBuffer raise MediaError

    AudioBuffer::to_pcm_s16

    fn AudioBuffer::to_pcm_s16(self : AudioBuffer, little_endian? : Bool) -> Bytes

    AudioBuffer::with_layout

    fn AudioBuffer::with_layout(self : AudioBuffer, layout : AudioLayout) -> AudioBuffer

    AudioLayout

    pub(all) enum AudioLayout {
    Interleaved
    Deinterleaved
    } derive(Eq,
    Debug
    )

    CodecCapability

    pub(all) struct CodecCapability {
    mime_type : String
    clock_rate : UInt
    channels : UInt16
    fmtp : String
    rtcp_feedback : Array[String]
    } derive(Eq,
    Debug
    )

    CodecCapability::channels

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

    CodecCapability::clock_rate

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

    CodecCapability::encoding_name

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

    CodecCapability::fmtp

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

    CodecCapability::mime_type

    fn CodecCapability::mime_type(self : CodecCapability) -> String

    CodecCapability::new

    fn CodecCapability::new(mime_type~ : String, clock_rate~ : UInt, channels? : UInt16, fmtp? : String, rtcp_feedback? : Array[String]) -> CodecCapability raise MediaError

    CodecCapability::rtcp_feedback

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

    EncodedFrameContext

    pub(all) struct EncodedFrameContext {
    direction : TransformDirection
    track_id : String?
    codec : CodecCapability
    ssrc : UInt
    sequence_number : UInt16
    timestamp : UInt
    marker : Bool
    } derive(Eq,
    Debug
    )

    EncodedFrameContext::new

    fn EncodedFrameContext::new(direction~ : TransformDirection, track_id? : String, codec~ : CodecCapability, ssrc~ : UInt, sequence_number~ : UInt16, timestamp~ : UInt, marker~ : Bool) -> EncodedFrameContext

    EncodedTransform

    pub struct EncodedTransform {
    name : String
    handler : (EncodedFrameContext, Bytes) -> Bytes raise MediaError
    }

    EncodedTransform::name

    fn EncodedTransform::name(self : EncodedTransform) -> String

    EncodedTransform::new

    fn EncodedTransform::new(name~ : String, handler~ : (EncodedFrameContext, Bytes) -> Bytes raise MediaError) -> EncodedTransform raise MediaError

    EncodedTransformPipeline

    pub struct EncodedTransformPipeline {
    stages : Array[EncodedTransform]
    }

    EncodedTransformPipeline::add

    EncodedTransformPipeline::length

    EncodedTransformPipeline::new

    EncodedTransformPipeline::process

    fn EncodedTransformPipeline::process(self : EncodedTransformPipeline, context : EncodedFrameContext, payload : Bytes) -> Bytes raise MediaError

    H26xCodec

    pub(all) enum H26xCodec {
    Avc
    Hevc
    } derive(Eq,
    Debug
    )

    H26xNal

    pub(all) struct H26xNal {
    codec : H26xCodec
    unit_type : Byte
    forbidden_zero_bit : Bool
    layer_id : Byte
    temporal_id_plus_one : Byte
    data : Bytes
    } derive(Eq,
    Debug
    )

    H26xNal::codec

    fn H26xNal::codec(self : H26xNal) -> H26xCodec

    H26xNal::data

    fn H26xNal::data(self : H26xNal) -> Bytes

    H26xNal::forbidden_zero_bit

    fn H26xNal::forbidden_zero_bit(self : H26xNal) -> Bool

    H26xNal::layer_id

    fn H26xNal::layer_id(self : H26xNal) -> Byte

    H26xNal::temporal_id_plus_one

    fn H26xNal::temporal_id_plus_one(self : H26xNal) -> Byte

    H26xNal::unit_type

    fn H26xNal::unit_type(self : H26xNal) -> Byte

    H26xReader

    pub struct H26xReader {
    codec : H26xCodec
    data : Bytes
    ranges : Array[(Int, Int)]
    index : Int
    }

    H26xReader::new

    fn H26xReader::new(codec~ : H26xCodec, data~ : Bytes) -> H26xReader raise MediaError

    H26xReader::next_nal

    fn H26xReader::next_nal(self : H26xReader) -> H26xNal? raise MediaError

    H26xReader::reset

    fn H26xReader::reset(self : H26xReader) -> Unit

    H26xWriter

    pub struct H26xWriter {
    codec : H26xCodec
    output : Array[Byte]
    pending_payloads : Array[Bytes]
    pending_timestamp : UInt?
    closed : Bool
    dropped_incomplete_samples : UInt
    }

    H26xWriter::bytes

    fn H26xWriter::bytes(self : H26xWriter) -> Bytes

    H26xWriter::close

    fn H26xWriter::close(self : H26xWriter) -> Unit

    H26xWriter::dropped_incomplete_samples

    fn H26xWriter::dropped_incomplete_samples(self : H26xWriter) -> UInt

    H26xWriter::new

    fn H26xWriter::new(codec : H26xCodec) -> H26xWriter

    H26xWriter::write_payloads

    fn H26xWriter::write_payloads(self : H26xWriter, payloads : Array[Bytes]) -> Unit raise MediaError

    H26xWriter::write_rtp

    fn H26xWriter::write_rtp(self : H26xWriter, packet :
    Packet
    ) -> Unit raise MediaError

    H26xWriter::write_sample

    fn H26xWriter::write_sample(self : H26xWriter, sample : Sample) -> Unit raise MediaError

    IvfCodec

    pub(all) enum IvfCodec {
    Vp8
    Vp9
    Av1
    } derive(Eq,
    Debug
    )

    IvfCodec::fourcc

    fn IvfCodec::fourcc(self : IvfCodec) -> Bytes

    IvfCodec::from_fourcc

    fn IvfCodec::from_fourcc(value : Bytes) -> IvfCodec raise MediaError

    IvfFrame

    pub(all) struct IvfFrame {
    data : Bytes
    timestamp : UInt64
    } derive(Eq,
    Debug
    )

    IvfFrame::data

    fn IvfFrame::data(self : IvfFrame) -> Bytes

    IvfFrame::new

    fn IvfFrame::new(data~ : Bytes, timestamp~ : UInt64) -> IvfFrame

    IvfFrame::timestamp

    fn IvfFrame::timestamp(self : IvfFrame) -> UInt64

    IvfHeader

    pub(all) struct IvfHeader {
    codec : IvfCodec
    width : UInt16
    height : UInt16
    timebase_denominator : UInt
    timebase_numerator : UInt
    num_frames : UInt
    } derive(Eq,
    Debug
    )

    IvfHeader::codec

    fn IvfHeader::codec(self : IvfHeader) -> IvfCodec

    IvfHeader::height

    fn IvfHeader::height(self : IvfHeader) -> UInt16

    IvfHeader::new

    fn IvfHeader::new(codec~ : IvfCodec, width~ : UInt16, height~ : UInt16, timebase_denominator~ : UInt, timebase_numerator~ : UInt, num_frames? : UInt) -> IvfHeader raise MediaError

    IvfHeader::num_frames

    fn IvfHeader::num_frames(self : IvfHeader) -> UInt

    IvfHeader::timebase_denominator

    fn IvfHeader::timebase_denominator(self : IvfHeader) -> UInt

    IvfHeader::timebase_numerator

    fn IvfHeader::timebase_numerator(self : IvfHeader) -> UInt

    IvfHeader::width

    fn IvfHeader::width(self : IvfHeader) -> UInt16

    IvfReader

    pub struct IvfReader {
    data : Bytes
    header : IvfHeader
    offset : Int
    frame_index : UInt
    }

    IvfReader::bytes_read

    fn IvfReader::bytes_read(self : IvfReader) -> Int

    IvfReader::header

    fn IvfReader::header(self : IvfReader) -> IvfHeader

    IvfReader::new

    fn IvfReader::new(data : Bytes) -> IvfReader raise MediaError

    IvfReader::next_frame

    fn IvfReader::next_frame(self : IvfReader) -> IvfFrame? raise MediaError

    IvfWriter

    pub struct IvfWriter {
    header : IvfHeader
    output : Array[Byte]
    frame_count : UInt
    closed : Bool
    }

    IvfWriter::bytes

    fn IvfWriter::bytes(self : IvfWriter) -> Bytes

    IvfWriter::close

    fn IvfWriter::close(self : IvfWriter) -> Unit

    IvfWriter::frame_count

    fn IvfWriter::frame_count(self : IvfWriter) -> UInt

    IvfWriter::new

    fn IvfWriter::new(header : IvfHeader) -> IvfWriter

    IvfWriter::write_frame

    fn IvfWriter::write_frame(self : IvfWriter, frame : Bytes, timestamp : UInt64) -> Unit raise MediaError

    MediaKind

    pub(all) enum MediaKind {
    Audio
    Video
    } derive(Eq,
    Debug
    )

    MediaTrack

    pub struct MediaTrack {
    id : String
    stream_id : String
    kind : MediaKind
    codec : CodecCapability
    } derive(
    Debug
    )

    MediaTrack::codec

    MediaTrack::id

    fn MediaTrack::id(self : MediaTrack) -> String

    MediaTrack::kind

    fn MediaTrack::kind(self : MediaTrack) -> MediaKind

    MediaTrack::new

    fn MediaTrack::new(id~ : String, stream_id~ : String, kind~ : MediaKind, codec~ : CodecCapability) -> MediaTrack

    MediaTrack::stream_id

    fn MediaTrack::stream_id(self : MediaTrack) -> String

    OggHeader

    pub(all) struct OggHeader {
    version : Byte
    channels : Byte
    pre_skip : UInt16
    sample_rate : UInt
    output_gain : UInt16
    channel_mapping_family : Byte
    stream_count : Byte
    coupled_count : Byte
    channel_mapping : Bytes
    } derive(Eq,
    Debug
    )

    OggHeader::channel_mapping

    fn OggHeader::channel_mapping(self : OggHeader) -> Bytes

    OggHeader::channel_mapping_family

    fn OggHeader::channel_mapping_family(self : OggHeader) -> Byte

    OggHeader::channels

    fn OggHeader::channels(self : OggHeader) -> Byte

    OggHeader::coupled_count

    fn OggHeader::coupled_count(self : OggHeader) -> Byte

    OggHeader::output_gain

    fn OggHeader::output_gain(self : OggHeader) -> UInt16

    OggHeader::pre_skip

    fn OggHeader::pre_skip(self : OggHeader) -> UInt16

    OggHeader::sample_rate

    fn OggHeader::sample_rate(self : OggHeader) -> UInt

    OggHeader::stream_count

    fn OggHeader::stream_count(self : OggHeader) -> Byte

    OggHeader::version

    fn OggHeader::version(self : OggHeader) -> Byte

    OggPacket

    pub(all) struct OggPacket {
    data : Bytes
    granule_position : UInt64
    end_of_stream : Bool
    } derive(Eq,
    Debug
    )

    OggPacket::data

    fn OggPacket::data(self : OggPacket) -> Bytes

    OggPacket::granule_position

    fn OggPacket::granule_position(self : OggPacket) -> UInt64

    OggPacket::is_end_of_stream

    fn OggPacket::is_end_of_stream(self : OggPacket) -> Bool

    OggPage

    pub(all) struct OggPage {
    header : OggPageHeader
    payload : Bytes
    } derive(Eq,
    Debug
    )

    OggPage::header

    fn OggPage::header(self : OggPage) -> OggPageHeader

    OggPage::payload

    fn OggPage::payload(self : OggPage) -> Bytes

    OggPageHeader

    pub(all) struct OggPageHeader {
    header_type : Byte
    granule_position : UInt64
    serial : UInt
    sequence : UInt
    checksum : UInt
    segments : Bytes
    } derive(Eq,
    Debug
    )

    OggPageHeader::checksum

    fn OggPageHeader::checksum(self : OggPageHeader) -> UInt

    OggPageHeader::granule_position

    fn OggPageHeader::granule_position(self : OggPageHeader) -> UInt64

    OggPageHeader::header_type

    fn OggPageHeader::header_type(self : OggPageHeader) -> Byte

    OggPageHeader::is_beginning_of_stream

    fn OggPageHeader::is_beginning_of_stream(self : OggPageHeader) -> Bool

    OggPageHeader::is_end_of_stream

    fn OggPageHeader::is_end_of_stream(self : OggPageHeader) -> Bool

    OggPageHeader::segments

    fn OggPageHeader::segments(self : OggPageHeader) -> Bytes

    OggPageHeader::sequence

    fn OggPageHeader::sequence(self : OggPageHeader) -> UInt

    OggPageHeader::serial

    fn OggPageHeader::serial(self : OggPageHeader) -> UInt

    OggReader

    pub struct OggReader {
    data : Bytes
    header : OggHeader
    tags : OpusTags
    verify_checksum : Bool
    offset : Int
    pending : Array[Byte]
    queued : Array[OggPacket]
    serial : UInt
    expected_sequence : UInt
    reached_eos : Bool
    }

    OggReader::bytes_read

    fn OggReader::bytes_read(self : OggReader) -> Int

    OggReader::header

    fn OggReader::header(self : OggReader) -> OggHeader

    OggReader::new

    fn OggReader::new(data : Bytes, verify_checksum? : Bool) -> OggReader raise MediaError

    OggReader::next_packet

    fn OggReader::next_packet(self : OggReader) -> OggPacket? raise MediaError

    OggReader::tags

    fn OggReader::tags(self : OggReader) -> OpusTags

    OggWriter

    pub struct OggWriter {
    sample_rate : UInt
    channels : Byte
    pre_skip : UInt16
    serial : UInt
    output : Array[Byte]
    sequence : UInt
    last_granule_position : UInt64
    last_rtp_timestamp : UInt?
    closed : Bool
    }

    OggWriter::bytes

    fn OggWriter::bytes(self : OggWriter) -> Bytes

    OggWriter::close

    fn OggWriter::close(self : OggWriter) -> Unit raise MediaError

    OggWriter::new

    fn OggWriter::new(sample_rate~ : UInt, channels~ : Byte, pre_skip? : UInt16, serial? : UInt, tags? : OpusTags) -> OggWriter raise MediaError

    OggWriter::write_opus_packet

    fn OggWriter::write_opus_packet(self : OggWriter, payload : Bytes, granule_position : UInt64) -> Unit raise MediaError

    OggWriter::write_rtp

    fn OggWriter::write_rtp(self : OggWriter, packet :
    Packet
    ) -> Unit raise MediaError

    OpusTags

    pub(all) struct OpusTags {
    vendor : String
    comments : Array[UserComment]
    } derive(Eq,
    Debug
    )

    OpusTags::comments

    fn OpusTags::comments(self : OpusTags) -> Array[UserComment]

    OpusTags::new

    fn OpusTags::new(vendor~ : String, comments? : Array[UserComment]) -> OpusTags

    OpusTags::vendor

    fn OpusTags::vendor(self : OpusTags) -> String

    RtpEncodingParameters

    pub(all) struct RtpEncodingParameters {
    ssrc : UInt?
    payload_type : Byte?
    rtx_ssrc : UInt?
    rtx_payload_type : Byte?
    rid : String?
    active : Bool
    max_bitrate : UInt64?
    scale_resolution_down_by : Double?
    scalability_mode : String?
    } derive(Eq,
    Debug
    )

    RtpEncodingParameters::new

    fn RtpEncodingParameters::new(ssrc? : UInt, payload_type? : Byte, rtx_ssrc? : UInt, rtx_payload_type? : Byte, rid? : String, active? : Bool, max_bitrate? : UInt64, scale_resolution_down_by? : Double, scalability_mode? : String) -> RtpEncodingParameters raise MediaError

    RtpParameters

    pub struct RtpParameters {
    codec : CodecCapability
    encodings : Array[RtpEncodingParameters]
    } derive(Eq,
    Debug
    )

    RtpParameters::codec

    RtpParameters::encodings

    RtpParameters::new

    RtpReceiver

    pub struct RtpReceiver {
    kind : MediaKind
    track : MediaTrack?
    parameters : RtpParameters?
    } derive(
    Debug
    )

    RtpReceiver::kind

    fn RtpReceiver::kind(self : RtpReceiver) -> MediaKind

    RtpReceiver::new

    fn RtpReceiver::new(kind~ : MediaKind) -> RtpReceiver

    RtpReceiver::parameters

    fn RtpReceiver::parameters(self : RtpReceiver) -> RtpParameters?

    RtpReceiver::set_parameters

    fn RtpReceiver::set_parameters(self : RtpReceiver, parameters : RtpParameters?) -> Unit

    RtpReceiver::set_track

    fn RtpReceiver::set_track(self : RtpReceiver, track : MediaTrack?) -> Unit raise MediaError

    RtpReceiver::track

    fn RtpReceiver::track(self : RtpReceiver) -> MediaTrack?

    RtpSender

    pub struct RtpSender {
    kind : MediaKind
    track : MediaTrack?
    parameters : RtpParameters?
    } derive(
    Debug
    )

    RtpSender::kind

    fn RtpSender::kind(self : RtpSender) -> MediaKind

    RtpSender::new

    fn RtpSender::new(kind~ : MediaKind) -> RtpSender

    RtpSender::parameters

    fn RtpSender::parameters(self : RtpSender) -> RtpParameters?

    RtpSender::replace_track

    fn RtpSender::replace_track(self : RtpSender, track : MediaTrack?) -> Unit raise MediaError

    RtpSender::set_parameters

    fn RtpSender::set_parameters(self : RtpSender, parameters : RtpParameters?) -> Unit

    RtpSender::track

    fn RtpSender::track(self : RtpSender) -> MediaTrack?

    RtpTransceiver

    pub struct RtpTransceiver {
    mid : String?
    kind : MediaKind
    direction : TransceiverDirection
    current_direction : TransceiverDirection?
    sender : RtpSender
    receiver : RtpReceiver
    } derive(
    Debug
    )

    RtpTransceiver::assign_mid

    fn RtpTransceiver::assign_mid(self : RtpTransceiver, mid : String) -> Unit raise MediaError

    RtpTransceiver::current_direction

    fn RtpTransceiver::current_direction(self : RtpTransceiver) -> TransceiverDirection?

    RtpTransceiver::direction

    RtpTransceiver::kind

    RtpTransceiver::mid

    fn RtpTransceiver::mid(self : RtpTransceiver) -> String?

    RtpTransceiver::new

    RtpTransceiver::receiver

    fn RtpTransceiver::receiver(self : RtpTransceiver) -> RtpReceiver

    RtpTransceiver::sender

    RtpTransceiver::set_current_direction

    fn RtpTransceiver::set_current_direction(self : RtpTransceiver, direction : TransceiverDirection) -> Unit

    RtpTransceiver::set_direction

    fn RtpTransceiver::set_direction(self : RtpTransceiver, direction : TransceiverDirection) -> Unit raise MediaError

    RtpTransceiver::stop

    fn RtpTransceiver::stop(self : RtpTransceiver) -> Unit

    Sample

    pub(all) struct Sample {
    data : Bytes
    timestamp :
    WallTime

    duration :
    Duration

    packet_timestamp : UInt
    prev_dropped_packets : UInt16
    prev_padding_packets : UInt16
    } derive(Eq,
    Debug
    )

    Sample::data

    fn Sample::data(self : Sample) -> Bytes

    Sample::packet_timestamp

    fn Sample::packet_timestamp(self : Sample) -> UInt

    Sample::prev_dropped_packets

    fn Sample::prev_dropped_packets(self : Sample) -> UInt16

    Sample::prev_padding_packets

    fn Sample::prev_padding_packets(self : Sample) -> UInt16

    Sample::timestamp

    SampleBuilder

    pub struct SampleBuilder {
    max_late : Int
    codec :
    PayloadCodec

    sample_rate : UInt
    max_late_timestamp : UInt
    packets : Array[
    Packet
    ]
    ready : Array[Sample]
    next_sequence : UInt16?
    consumed_any : Bool
    last_sample_timestamp : UInt?
    dropped_packets : UInt16
    padding_packets : UInt16
    generated_at :
    WallTime

    }

    SampleBuilder::flush

    fn SampleBuilder::flush(self : SampleBuilder) -> Unit raise MediaError

    SampleBuilder::new

    SampleBuilder::pop

    fn SampleBuilder::pop(self : SampleBuilder) -> Sample? raise MediaError

    SampleBuilder::pop_with_timestamp

    fn SampleBuilder::pop_with_timestamp(self : SampleBuilder) -> (Sample, UInt)? raise MediaError

    SampleBuilder::push

    SampleBuilder::push_at

    SampleBuilder::set_generated_at

    fn SampleBuilder::set_generated_at(self : SampleBuilder, timestamp :
    WallTime
    ) -> Unit

    SampleBuilder::with_max_time_delay

    TransceiverDirection

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

    TransformDirection

    pub(all) enum TransformDirection {
    TransformInbound
    TransformOutbound
    } derive(Eq,
    Debug
    )

    UserComment

    pub(all) struct UserComment {
    key : String
    value : String
    } derive(Eq,
    Debug
    )

    UserComment::key

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

    UserComment::new

    fn UserComment::new(key~ : String, value~ : String) -> UserComment

    UserComment::value

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