libdatachannel/bindings

Search:
Group by:

DataChannel, Track, and WebSocket common APItotal size buffered to sendDataChannel, Track, and WebSocket common extended APItotal size available to receiveDataChannelreturns dc idreturns dc idTrackreturns ws idNote: SCTP settings apply to newly-created PeerConnections only

Types

rtcAvailableCallbackFunc = proc (id: cint; usePtr: pointer)
rtcBufferedAmountLowCallbackFunc = proc (id: cint; usePtr: pointer)
rtcCandidateCallbackFunc = proc (pc: cint; cand: cstring; mid: cstring;
                                 usePtr: pointer)
RtcCertificateType {.size: 4.} = enum
  RTC_CERTIFICATE_DEFAULT = 0, ## ECDSA
  RTC_CERTIFICATE_ECDSA = 1, RTC_CERTIFICATE_RSA = 2
rtcClosedCallbackFunc = proc (id: cint; usePtr: pointer)
RtcCodec {.size: 4.} = enum
  RTC_CODEC_H264 = 0, RTC_CODEC_VP8 = 1, RTC_CODEC_VP9 = 2, RTC_CODEC_OPUS = 128
rtcConfiguration {.header: "libdatachannel/rtc.h", bycopy, bycopy.} = object
  iceServers*: cstringArray
  iceServersCount*: cint
  bindAddress*: cstring      ## libjuice only, NULL means any
  certificateType*: RtcCertificateType
  iceTransportPolicy*: RtcTransportPolicy
  enableIceTcp*: bool
  disableAutoNegotiation*: bool
  portRangeBegin*: uint16    ## 0 means automatic
  portRangeEnd*: uint16      ## 0 means automatic
  mtu*: cint                 ## <= 0 means automatic
  maxMessageSize*: cint      ## <= 0 means default
rtcDataChannelCallbackFunc = proc (pc: cint; dc: cint; usePtr: pointer)
RTCDataChannelInit {.bycopy.} = object
  reliability*: RTCReliability
  protocol*: cstring         ## empty string if NULL
  negotiated*: bool
  manualStream*: bool
  stream*: uint16            ## numeric ID 0-65534, ignored if manualStream is false
rtcDescriptionCallbackFunc = proc (pc: cint; sdp: cstring; type: cstring;
                                   usePtr: pointer)
RtcDirection {.size: 4.} = enum
  RTC_DIRECTION_UNKNOWN = 0, RTC_DIRECTION_SENDONLY = 1,
  RTC_DIRECTION_RECVONLY = 2, RTC_DIRECTION_SENDRECV = 3,
  RTC_DIRECTION_INACTIVE = 4
rtcErrorCallbackFunc = proc (id: cint; error: cstring; usePtr: pointer)
rtcGatheringState {.size: 4.} = enum
  RTC_GATHERING_NEW = 0, RTC_GATHERING_INPROGRESS = 1,
  RTC_GATHERING_COMPLETE = 2
rtcGatheringStateCallbackFunc = proc (pc: cint; state: rtcGatheringState;
                                      usePtr: pointer)
rtcLogCallbackFunc = proc (level: RTCLogLevel; message: cstring)
RTCLogLevel {.size: 4.} = enum
  LogNone = 0, LogFatal = 1, LogError = 2, LogWarning = 3, LogInfo = 4,
  LogDebug = 5, LogVerbose = 6
rtcMessageCallbackFunc = proc (id: cint; message: cstring; size: cint;
                               usePtr: pointer)
RTCNalUnitSeparator = enum
  RTC_NAL_SEPARATOR_LENGTH = 0, ## first 4 bytes are NAL unit length
  RTC_NAL_SEPARATOR_LONG_START_SEQUENCE = 1, ## 0x00, 0x00, 0x00, 0x01
  RTC_NAL_SEPARATOR_SHORT_START_SEQUENCE = 2, ## 0x00, 0x00, 0x01
  RTC_NAL_SEPARATOR_START_SEQUENCE = 3 ## long or short start sequence
rtcOpenCallbackFunc = proc (id: cint; usePtr: pointer)
RTCPacketizationHandlerInit {.bycopy.} = object
  ssrc*: uint32
  cname*: cstring
  payloadType*: uint8
  clockRate*: uint32
  sequenceNumber*: uint16
  timestamp*: uint32         ## H264
  nalSeparator*: RTCNalUnitSeparator ## NAL unit separator
  maxFragmentSize*: uint16   ## Maximum NAL unit fragment size
RTCReliability {.bycopy.} = object
  unordered*: bool
  unreliable*: bool
  maxPacketLifeTime*: cint   ## ignored if reliable
  maxRetransmits*: cint      ## ignored if reliable
RTCSctpSettings {.bycopy.} = object
  recvBufferSize*: cint      ## in bytes, <= 0 means optimized default
  sendBufferSize*: cint      ## in bytes, <= 0 means optimized default
  maxChunksOnQueue*: cint    ## in chunks, <= 0 means optimized default
  initialCongestionWindow*: cint ## in MTUs, <= 0 means optimized default
  maxBurst*: cint            ## in MTUs, 0 means optimized default, < 0 means disabled
  congestionControlModule*: cint ## 0: RFC2581 (default), 1: HSTCP, 2: H-TCP, 3: RTCC
  delayedSackTimeMs*: cint   ## in msecs, 0 means optimized default, < 0 means disabled
  minRetransmitTimeoutMs*: cint ## in msecs, <= 0 means optimized default
  maxRetransmitTimeoutMs*: cint ## in msecs, <= 0 means optimized default
  initialRetransmitTimeoutMs*: cint ## in msecs, <= 0 means optimized default
  maxRetransmitAttempts*: cint ## number of retransmissions, <= 0 means optimized default
  heartbeatIntervalMs*: cint ## in msecs, <= 0 means optimized default
rtcSignalingState {.size: 4.} = enum
  RTC_SIGNALING_STABLE = 0, RTC_SIGNALING_HAVE_LOCAL_OFFER = 1,
  RTC_SIGNALING_HAVE_REMOTE_OFFER = 2, RTC_SIGNALING_HAVE_LOCAL_PRANSWER = 3,
  RTC_SIGNALING_HAVE_REMOTE_PRANSWER = 4
rtcSignalingStateCallbackFunc = proc (pc: cint; state: rtcSignalingState;
                                      usePtr: pointer)
RTCSsrcForTypeInit {.bycopy.} = object
  ssrc*: uint32
  name*: cstring             ## optional
  msid*: cstring             ## optional
  trackId*: cstring          ## optional, track ID used in MSID
RTCStartTime {.bycopy.} = object
  seconds*: cdouble          ## Start time in seconds
  since1970*: bool           ## true if seconds since 1970
                             ## false if seconds since 1900
  timestamp*: uint32         ## Start timestamp
rtcState {.size: 4.} = enum
  RTC_NEW = 0, RTC_CONNECTING = 1, RTC_CONNECTED = 2, RTC_DISCONNECTED = 3,
  RTC_FAILED = 4, RTC_CLOSED = 5
rtcStateChangeCallbackFunc = proc (pc: cint; state: rtcState; usePtr: pointer)
rtcTrackCallbackFunc = proc (pc: cint; tr: cint; usePtr: pointer)
RTCTrackInit {.bycopy.} = object
  direction*: RtcDirection
  codec*: RtcCodec
  payloadType*: cint
  ssrc*: uint32
  mid*: cstring
  name*: cstring             ## optional
  msid*: cstring             ## optional
  trackId*: cstring          ## optional, track ID used in MSID
RtcTransportPolicy {.size: 4.} = enum
  RTC_TRANSPORT_POLICY_ALL = 0, RTC_TRANSPORT_POLICY_RELAY = 1
RTCWebSocketClientCallbackFunc = proc (wsserver: cint; ws: cint; usePtr: pointer) {.
    cdecl.}
rtcWsConfiguration = object
  disableTlsVerification*: bool ## if true, don't verify the TLS certificate
rtcWsServerConfiguration = object
  port*: uint16              ## 0 means automatic selection
  enableTls*: bool           ## if true, enable TLS (WSS)
  certificatePemFile*: cstring ## NULL for autogenerated certificate
  keyPemFile*: cstring       ## NULL for autogenerated certificate
  keyPemPass*: cstring       ## NULL if no pass

Procs

proc rtcAddRemoteCandidate(pc: cint; cand: cstring; mid: cstring): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
proc rtcAddTrack(pc: cint; mediaDescriptionSdp: cstring): cint {.importc,
    ...raises: [], tags: [], forbids: [].}
proc rtcAddTrackEx(pc: cint; init: ptr RTCTrackInit): cint {.importc,
    ...raises: [], tags: [], forbids: [].}
proc rtcChainRtcpNackResponder(tr: cint; maxStoredPacketsCount: cuint): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
Chain RtcpNackResponder to handler chain for given track 
proc rtcChainRtcpSrReporter(tr: cint): cint {.importc, ...raises: [], tags: [],
    forbids: [].}
Chain RtcpSrReporter to handler chain for given track 
proc rtcCleanup() {.importc, ...raises: [], tags: [], forbids: [].}
proc rtcClosePeerConnection(pc: cint): cint {.importc, ...raises: [], tags: [],
    forbids: [].}
proc rtcCreateDataChannel(pc: cint; label: cstring): cint {.importc, ...raises: [],
    tags: [], forbids: [].}
proc rtcCreateDataChannelEx(pc: cint; label: cstring;
                            init: ptr RTCDataChannelInit): cint {.importc,
    ...raises: [], tags: [], forbids: [].}
proc rtcCreatePeerConnection(config: ptr rtcConfiguration): cint {.importc,
    ...raises: [], tags: [], forbids: [].}
returns pc id 
proc rtcCreateWebSocket(url: cstring): cint {.importc, ...raises: [], tags: [],
    forbids: [].}
proc rtcCreateWebSocketEx(url: cstring; config: ptr rtcWsConfiguration): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
proc rtcCreateWebSocketServer(config: ptr rtcWsServerConfiguration;
                              cb: RTCWebSocketClientCallbackFunc): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
proc rtcDeleteDataChannel(dc: cint): cint {.importc, ...raises: [], tags: [],
    forbids: [].}
proc rtcDeletePeerConnection(pc: cint): cint {.importc, ...raises: [], tags: [],
    forbids: [].}
proc rtcDeleteTrack(tr: cint): cint {.importc, ...raises: [], tags: [], forbids: [].}
proc rtcDeleteWebSocket(ws: cint): cint {.importc, ...raises: [], tags: [],
    forbids: [].}
proc rtcDeleteWebSocketServer(wsserver: cint): cint {.importc, ...raises: [],
    tags: [], forbids: [].}
proc rtcGetAvailableAmount(id: cint): cint {.importc, ...raises: [], tags: [],
    forbids: [].}
proc rtcGetBufferedAmount(id: cint): cint {.importc, ...raises: [], tags: [],
    forbids: [].}
proc rtcGetCNameForSsrc(tr: cint; ssrc: uint32; cname: cstring; cnameSize: cint): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
Get CName for SSRC 
proc rtcGetCurrentTrackTimestamp(id: cint; timestamp: ptr uint32): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
Get current timestamp, result is written to timestamp 
proc rtcGetDataChannelLabel(dc: cint; buffer: cstring; size: cint): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
proc rtcGetDataChannelProtocol(dc: cint; buffer: cstring; size: cint): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
proc rtcGetDataChannelReliability(dc: cint; reliability: ptr RTCReliability): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
proc rtcGetDataChannelStream(dc: cint): cint {.importc, ...raises: [], tags: [],
    forbids: [].}
proc rtcGetLocalAddress(pc: cint; buffer: cstring; size: cint): cint {.importc,
    ...raises: [], tags: [], forbids: [].}
proc rtcGetLocalDescription(pc: cint; buffer: cstring; size: cint): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
proc rtcGetLocalDescriptionType(pc: cint; buffer: cstring; size: cint): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
proc rtcGetPreviousTrackSenderReportTimestamp(id: cint; timestamp: ptr uint32): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
Get timestamp of previous RTCP SR, result is written to timestamp 
proc rtcGetRemoteAddress(pc: cint; buffer: cstring; size: cint): cint {.importc,
    ...raises: [], tags: [], forbids: [].}
proc rtcGetRemoteDescription(pc: cint; buffer: cstring; size: cint): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
proc rtcGetRemoteDescriptionType(pc: cint; buffer: cstring; size: cint): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
proc rtcGetSelectedCandidatePair(pc: cint; local: cstring; localSize: cint;
                                 remote: cstring; remoteSize: cint): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
proc rtcGetSsrcsForTrack(tr: cint; buffer: ptr uint32; count: cint): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
Get all SSRCs for given track 
proc rtcGetSsrcsForType(mediaType: cstring; sdp: cstring; buffer: ptr uint32;
                        bufferSize: cint): cint {.importc, ...raises: [], tags: [],
    forbids: [].}
Get all SSRCs for given media type in given SDP 
proc rtcGetTrackDescription(tr: cint; buffer: cstring; size: cint): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
proc rtcGetTrackPayloadTypesForCodec(tr: cint; ccodec: cstring;
                                     buffer: ptr cint; size: cint): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
Get all available payload types for given codec and stores them in buffer, does nothing if buffer is NULL 
proc rtcGetTrackStartTimestamp(id: cint; timestamp: ptr uint32): cint {.importc,
    ...raises: [], tags: [], forbids: [].}
Get start timestamp for track identified by given id, result is written to timestamp 
proc rtcGetUserPointer(i: cint): pointer {.importc, ...raises: [], tags: [],
    forbids: [].}
proc rtcGetWebSocketPath(ws: cint; buffer: cstring; size: cint): cint {.importc,
    ...raises: [], tags: [], forbids: [].}
proc rtcGetWebSocketRemoteAddress(ws: cint; buffer: cstring; size: cint): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
proc rtcGetWebSocketServerPort(wsserver: cint): cint {.importc, ...raises: [],
    tags: [], forbids: [].}
proc rtcInitLogger(level: RTCLogLevel; cb: rtcLogCallbackFunc) {.importc,
    ...raises: [], tags: [], forbids: [].}
proc rtcIsClosed(id: cint): bool {.importc, ...raises: [], tags: [], forbids: [].}
proc rtcIsOpen(id: cint): bool {.importc, ...raises: [], tags: [], forbids: [].}
proc rtcPreload() {.importc, ...raises: [], tags: [], forbids: [].}
proc rtcReceiveMessage(id: cint; buffer: cstring; size: ptr cint): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
proc rtcSendMessage(id: cint; data: cstring; size: cint): cint {.importc,
    ...raises: [], tags: [], forbids: [].}
proc rtcSetAvailableCallback(id: cint; cb: rtcAvailableCallbackFunc): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
proc rtcSetBufferedAmountLowCallback(id: cint;
                                     cb: rtcBufferedAmountLowCallbackFunc): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
proc rtcSetBufferedAmountLowThreshold(id: cint; amount: cint): cint {.importc,
    ...raises: [], tags: [], forbids: [].}
proc rtcSetClosedCallback(id: cint; cb: rtcClosedCallbackFunc): cint {.importc,
    ...raises: [], tags: [], forbids: [].}
proc rtcSetDataChannelCallback(pc: cint; cb: rtcDataChannelCallbackFunc): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
proc rtcSetErrorCallback(id: cint; cb: rtcErrorCallbackFunc): cint {.importc,
    ...raises: [], tags: [], forbids: [].}
proc rtcSetGatheringStateChangeCallback(pc: cint;
                                        cb: rtcGatheringStateCallbackFunc): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
proc rtcSetH264PacketizationHandler(tr: cint;
                                    init: ptr RTCPacketizationHandlerInit): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
Set H264PacketizationHandler for track 
proc rtcSetLocalCandidateCallback(pc: cint; cb: rtcCandidateCallbackFunc): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
proc rtcSetLocalDescription(pc: cint; type: ptr cstring): cint {.importc,
    ...raises: [], tags: [], forbids: [].}
proc rtcSetLocalDescriptionCallback(pc: cint; cb: rtcDescriptionCallbackFunc): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
proc rtcSetMessageCallback(id: cint; cb: rtcMessageCallbackFunc): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
proc rtcSetNeedsToSendRtcpSr(id: cint): cint {.importc, ...raises: [], tags: [],
    forbids: [].}
Set NeedsToReport flag in RtcpSrReporter handler identified by given track id 
proc rtcSetOpenCallback(id: cint; cb: rtcOpenCallbackFunc): cint {.importc,
    ...raises: [], tags: [], forbids: [].}
proc rtcSetOpusPacketizationHandler(tr: cint;
                                    init: ptr RTCPacketizationHandlerInit): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
Set OpusPacketizationHandler for track 
proc rtcSetRemoteDescription(pc: cint; sdp: cstring; type: cstring): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
proc rtcSetRtpConfigurationStartTime(id: cint; startTime: ptr RTCStartTime): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
Set start time for RTP stream 
proc rtcSetSctpSettings(settings: ptr RTCSctpSettings): cint {.importc,
    ...raises: [], tags: [], forbids: [].}
proc rtcSetSsrcForType(mediaType: cstring; sdp: cstring; buffer: cstring;
                       bufferSize: cint; init: ptr RTCSsrcForTypeInit): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
Set SSRC for given media type in given SDP 
proc rtcSetStateChangeCallback(pc: cint; cb: rtcStateChangeCallbackFunc): cint {.
    importc, ...raises: [], tags: [], forbids: [].}
proc rtcSetTrackCallback(pc: cint; cb: rtcTrackCallbackFunc): cint {.importc,
    ...raises: [], tags: [], forbids: [].}
proc rtcSetTrackRtpTimestamp(id: cint; timestamp: uint32): cint {.importc,
    ...raises: [], tags: [], forbids: [].}
Set RTP timestamp for track identified by given id 
proc rtcSetUserPointer(id: cint; usePtr: pointer) {.importc, ...raises: [],
    tags: [], forbids: [].}
proc rtcStartRtcpSenderReporterRecording(id: cint): cint {.importc, ...raises: [],
    tags: [], forbids: [].}
Start stats recording for RTCP Sender Reporter 
proc rtcTransformSecondsToTimestamp(id: cint; seconds: cdouble;
                                    timestamp: ptr uint32): cint {.importc,
    ...raises: [], tags: [], forbids: [].}
Transform seconds to timestamp using track's clock rate, result is written to timestamp 
proc rtcTransformTimestampToSeconds(id: cint; timestamp: uint32;
                                    seconds: ptr cdouble): cint {.importc,
    ...raises: [], tags: [], forbids: [].}
Transform timestamp to seconds using track's clock rate, result is written to seconds

Made with Nim. Generated: 2025-04-04 01:01:53 UTC