srt

package
v0.0.0-...-5b2bcd3 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jul 23, 2026 License: MIT Imports: 24 Imported by: 0

README

SRT 协议支持

实现 SRT (Secure Reliable Transport) 协议,提供低延迟、高可靠性的实时视频传输。

特性

  • 低延迟传输: 可配置延迟缓冲(默认 120ms)
  • 丢包恢复: ARQ 自动重传机制
  • AES 加密: 支持 128/192/256 位加密
  • 带宽自适应: 根据网络状况自动调整
  • 连接模式: Caller、Listener、Rendezvous

EventBus 支持

通过设置 Conn.EventBus 可订阅连接生命周期事件:

  • Connecting — 正在连接
  • Handshaking — 正在握手
  • Handshaked — 握手完成
  • Connected — 连接成功
  • Disconnecting — 正在断开

快速开始

作为 Caller 连接
conn, err := srt.Dial("srt://server:9000?streamid=live/stream")
if err != nil {
    log.Fatal(err)
}
defer conn.Close()

// 读取流
streams, _ := conn.Streams()
for {
    pkt, err := conn.ReadPacket()
    if err != nil {
        break
    }
    // 处理数据包
}
作为 Listener 接收
listener, err := srt.Listen("srt://:9000")
if err != nil {
    log.Fatal(err)
}
defer listener.Close()

for {
    conn, err := listener.Accept()
    if err != nil {
        continue
    }
    go handleConnection(conn)
}

URL 格式

srt://host:port?streamid=xxx&latency=200&mode=caller
参数说明
参数 说明 默认值
streamid 流标识符 -
latency 延迟缓冲(毫秒) 120
passphrase SRT 加密密钥;设置后走 gosrt/M7S 兼容握手 -
mode 连接模式(caller/listener/rendezvous) caller
pbkeylen 密钥长度(16/24/32) 16
maxbw 最大带宽(bps) -
timeout 连接超时(毫秒) 3000

文件结构

文件 说明
doc.go 包文档
config.go 配置和统计
conn.go 连接和握手
listener.go 监听器实现
packet.go 数据包解析/序列化
data.go 数据通道(ACK/NAK/重传)
demuxer.go TS 解复用
muxer.go TS 复用

与 Stream API 集成

s, _ := stream.New().
    Input("srt://server:9000?streamid=input&latency=200").
    Output("srt://target:9000?streamid=output&latency=200").Done().
    Build()

示例

参考 example/srt-client/example/srt-server/ 目录获取完整示例。

Documentation

Overview

Package srt 实现 SRT (Secure Reliable Transport) 协议支持。

SRT 是一种开源的视频传输协议,专为低延迟、高可靠性的实时视频传输设计。 它结合了 UDP 的低延迟特性和 TCP 的可靠性;设置 passphrase 时会切换到 gosrt 兼容标准 SRT 加密握手。

特性

  • 低延迟传输(可配置延迟缓冲)
  • 丢包恢复(ARQ 自动重传)
  • AES passphrase:10-79 字符密钥,兼容 M7S/gosrt
  • 带宽自适应
  • 连接模式:Caller、Listener、Rendezvous

快速开始

作为 Caller 连接到 SRT 服务器:

conn, err := srt.Dial("srt://server:9000?streamid=live/stream")
if err != nil {
    log.Fatal(err)
}
defer conn.Close()

// 读取流
streams, _ := conn.Streams()
for {
    pkt, err := conn.ReadPacket()
    if err != nil {
        break
    }
    // 处理数据包
}

作为 Listener 接收连接:

listener, err := srt.Listen("srt://:9000")
if err != nil {
    log.Fatal(err)
}
defer listener.Close()

for {
    conn, err := listener.Accept()
    if err != nil {
        continue
    }
    go handleConnection(conn)
}

URL 格式

SRT URL 支持以下参数:

srt://host:port?streamid=xxx&latency=200&passphrase=foobarfoobar&mode=caller

参数说明:

  • streamid: 流标识符
  • latency: 延迟缓冲(毫秒),默认 120
  • passphrase: SRT 加密密钥(10-79 字符)
  • mode: 连接模式(caller/listener/rendezvous)
  • pbkeylen: 密钥长度(16/24/32)
  • maxbw: 最大带宽(bps)
  • timeout: 连接超时(毫秒)

Index

Constants

View Source
const (

	// 加密模式
	EncryptionNone   = 0
	EncryptionAES128 = 1
	EncryptionAES192 = 2
	EncryptionAES256 = 3
)

加密相关常量

View Source
const (
	// 数据包(最高位为 0)
	PacketTypeData = 0

	// 控制包类型(最高位为 1)
	PacketTypeControl = 0x80000000

	// 控制包子类型
	ControlTypeHandshake   = 0x0000
	ControlTypeKeepalive   = 0x0001
	ControlTypeACK         = 0x0002
	ControlTypeNAK         = 0x0003
	ControlTypeCongestion  = 0x0004 // 未使用
	ControlTypeShutdown    = 0x0005
	ControlTypeACKACK      = 0x0006
	ControlTypeDropRequest = 0x0007
	ControlTypePeerError   = 0x0008
	ControlTypeUserDefined = 0x7FFF
)

SRT 数据包类型

View Source
const (
	HandshakeTypeDone       = 0xFFFFFFFD // -3
	HandshakeTypeAgreement  = 0xFFFFFFFE // -2
	HandshakeTypeConclusion = 0xFFFFFFFF // -1
	HandshakeTypeWavehand   = 0x00000000 // 0
	HandshakeTypeInduction  = 0x00000001 // 1
)

握手类型

View Source
const (
	ExtTypeHSReq      = 1 // 握手请求
	ExtTypeHSRsp      = 2 // 握手响应
	ExtTypeKMReq      = 3 // 密钥材料请求
	ExtTypeKMRsp      = 4 // 密钥材料响应
	ExtTypeSID        = 5 // 流 ID
	ExtTypeCongestion = 6 // 拥塞控制
	ExtTypeFilter     = 7 // 过滤器
	ExtTypeGroup      = 8 // 组
)

握手扩展类型

View Source
const (
	HSFlagTSBPDSnd     = 0x0001 // 发送方 TSBPD
	HSFlagTSBPDRcv     = 0x0002 // 接收方 TSBPD
	HSFlagCrypt        = 0x0004 // 加密
	HSFlagTLPktDrop    = 0x0008 // 丢弃过期包
	HSFlagPeriodNAK    = 0x0010 // 周期性 NAK
	HSFlagRexmitFlag   = 0x0020 // 重传标志
	HSFlagStreamAPI    = 0x0040 // 流 API
	HSFlagPacketFilter = 0x0080 // 包过滤器
)

握手标志

View Source
const (
	SRTVersion = 0x00010401 // 1.4.1
)

SRT 版本

Variables

View Source
var (
	ErrInvalidPassphrase  = errors.New("srt: passphrase must be 10-79 characters")
	ErrInvalidKeyLength   = errors.New("srt: key length must be 16, 24 or 32 bytes")
	ErrInvalidLatency     = errors.New("srt: latency must be non-negative")
	ErrInvalidPayloadSize = errors.New("srt: payload size must be 1-1456")
	ErrConnectionFailed   = errors.New("srt: connection failed")
	ErrConnectionClosed   = errors.New("srt: connection closed")
	ErrHandshakeFailed    = errors.New("srt: handshake failed")
	ErrAuthFailed         = errors.New("srt: authentication failed")
	ErrTimeout            = errors.New("srt: operation timeout")
	ErrInvalidStreamID    = errors.New("srt: invalid stream ID")
	ErrNotConnected       = errors.New("srt: not connected")
	ErrAlreadyConnected   = errors.New("srt: already connected")
)

错误定义

Functions

func ComputeHMAC

func ComputeHMAC(key, data []byte) []byte

ComputeHMAC 计算 HMAC

func FormatURL

func FormatURL(host string, port int, config Config) string

FormatURL 格式化 SRT URL

func Handler

func Handler(h *avutil.RegisterHandler)

Handler 注册 SRT 协议处理器

func VerifyHMAC

func VerifyHMAC(key, data, mac []byte) bool

VerifyHMAC 验证 HMAC

Types

type Config

type Config struct {
	// 基本配置
	Mode       Mode          // 连接模式
	Latency    time.Duration // 延迟缓冲(默认 120ms)
	StreamID   string        // 流标识符
	Passphrase string        // SRT 加密密钥;非空时使用 gosrt 兼容 M7S/标准 SRT 加密握手
	KeyLength  KeyLength     // 密钥长度(16/24/32)

	// 连接配置
	Timeout         time.Duration // 连接超时
	ConnectTimeout  time.Duration // 握手超时
	PeerIdleTimeout time.Duration // 对端空闲超时

	// 传输配置
	TransmissionType  TransmissionType // 传输类型
	MaxBandwidth      int64            // 最大带宽(bps,0=无限制)
	InputBandwidth    int64            // 输入带宽(用于带宽估计)
	OverheadBandwidth int              // 带宽开销百分比(默认 25%)

	// 缓冲配置
	SendBufferSize    int // 发送缓冲区大小
	ReceiveBufferSize int // 接收缓冲区大小
	FlightFlagSize    int // 飞行窗口大小
	PayloadSize       int // 数据包负载大小(默认 1316)

	// 重传配置
	TooLatePacketDrop bool // 丢弃过期包
	NAKReport         bool // 启用 NAK 报告

	// 拥塞控制
	CongestionControl string // 拥塞控制算法(live/file)

	// 调试
	Debug bool // 启用调试日志
}

Config SRT 连接配置

func DefaultConfig

func DefaultConfig() Config

DefaultConfig 返回默认配置

func HighReliabilityConfig

func HighReliabilityConfig() Config

HighReliabilityConfig 返回高可靠性配置

func ListenerConfig

func ListenerConfig() Config

ListenerConfig 返回监听模式默认配置

func LowLatencyConfig

func LowLatencyConfig() Config

LowLatencyConfig 返回低延迟配置

func RendezvousConfig

func RendezvousConfig() Config

RendezvousConfig 返回对等模式默认配置

func (*Config) Validate

func (c *Config) Validate() error

Validate 验证配置

type Conn

type Conn struct {

	// 事件总线(可选)
	EventBus *event.Bus
	// contains filtered or unexported fields
}

Conn SRT 连接

func Dial

func Dial(rawURL string) (*Conn, error)

Dial 连接到 SRT 服务器

URL 格式: srt://host:port?streamid=xxx&latency=200

passphrase 参数会被解析;非空时走 gosrt 兼容标准 SRT/M7S 加密握手。

func DialConfig

func DialConfig(ctx context.Context, address string, config Config) (*Conn, error)

DialConfig 使用指定配置连接

func DialContext

func DialContext(ctx context.Context, rawURL string) (*Conn, error)

DialContext 使用 context 连接到 SRT 服务器

func (*Conn) Close

func (c *Conn) Close() error

Close 关闭连接

func (*Conn) Config

func (c *Conn) Config() Config

Config 返回连接配置

func (*Conn) IsConnected

func (c *Conn) IsConnected() bool

IsConnected 返回连接状态

func (*Conn) LocalAddr

func (c *Conn) LocalAddr() net.Addr

LocalAddr 返回本地地址

func (*Conn) ReadPacket

func (c *Conn) ReadPacket() (av.Packet, error)

ReadPacket 读取数据包

func (*Conn) RemoteAddr

func (c *Conn) RemoteAddr() net.Addr

RemoteAddr 返回远程地址

func (*Conn) SetReadDeadline

func (c *Conn) SetReadDeadline(t time.Time) error

SetReadDeadline 设置读取超时

func (*Conn) SetWriteDeadline

func (c *Conn) SetWriteDeadline(t time.Time) error

SetWriteDeadline 设置写入超时

func (*Conn) Stats

func (c *Conn) Stats() Stats

Stats 返回连接统计

func (*Conn) StreamID

func (c *Conn) StreamID() string

StreamID 返回流 ID

func (*Conn) Streams

func (c *Conn) Streams() ([]av.CodecData, error)

Streams 返回流信息

func (*Conn) WriteHeader

func (c *Conn) WriteHeader(streams []av.CodecData) error

WriteHeader 写入流头信息

func (*Conn) WritePacket

func (c *Conn) WritePacket(pkt av.Packet) error

WritePacket 写入数据包

func (*Conn) WriteTrailer

func (c *Conn) WriteTrailer() error

WriteTrailer 写入流尾信息

type CryptoContext

type CryptoContext struct {
	// contains filtered or unexported fields
}

CryptoContext 加密上下文

func NewCryptoContext

func NewCryptoContext(passphrase string, keyLength KeyLength) (*CryptoContext, error)

NewCryptoContext 创建加密上下文

func NewCryptoContextWithSalt

func NewCryptoContextWithSalt(passphrase string, keyLength KeyLength, salt []byte) (*CryptoContext, error)

NewCryptoContextWithSalt 使用指定盐创建加密上下文(用于接收方)

func (*CryptoContext) BuildKMRequest

func (ctx *CryptoContext) BuildKMRequest() (*KMRequest, error)

BuildKMRequest 构建密钥材料请求

func (*CryptoContext) Decrypt

func (ctx *CryptoContext) Decrypt(ciphertext []byte, seqNum uint32) ([]byte, error)

Decrypt 解密数据

func (*CryptoContext) Enabled

func (ctx *CryptoContext) Enabled() bool

Enabled 返回是否启用加密

func (*CryptoContext) Encrypt

func (ctx *CryptoContext) Encrypt(plaintext []byte, seqNum uint32) ([]byte, error)

Encrypt 加密数据

func (*CryptoContext) KeyIndex

func (ctx *CryptoContext) KeyIndex() uint8

KeyIndex 返回当前密钥索引

func (*CryptoContext) KeyLength

func (ctx *CryptoContext) KeyLength() KeyLength

KeyLength 返回密钥长度

func (*CryptoContext) RotateKey

func (ctx *CryptoContext) RotateKey() error

RotateKey 轮换密钥

func (*CryptoContext) Salt

func (ctx *CryptoContext) Salt() []byte

Salt 返回盐值

func (*CryptoContext) SetSEK

func (ctx *CryptoContext) SetSEK(sek []byte) error

SetSEK 设置流加密密钥(用于接收方解密 KMREQ 后)

func (*CryptoContext) UnwrapSEK

func (ctx *CryptoContext) UnwrapSEK(wrapped []byte) ([]byte, error)

UnwrapSEK 使用 KEK 解包 SEK(用于处理 KMREQ)

func (*CryptoContext) WrapSEK

func (ctx *CryptoContext) WrapSEK() ([]byte, error)

WrapSEK 使用 KEK 包装 SEK(用于 KMREQ)

type DataChannel

type DataChannel struct {
	// contains filtered or unexported fields
}

DataChannel SRT 数据通道 处理数据包的发送、接收、重传和排序

func (*DataChannel) GetStats

func (dc *DataChannel) GetStats() (sent, recv, lost, retrans, bytesSent, bytesRecv uint64)

GetStats 获取统计信息

func (*DataChannel) HandleIncomingPacket

func (dc *DataChannel) HandleIncomingPacket(data []byte)

HandleIncomingPacket 处理来自监听器的数据包(服务端连接使用)

func (*DataChannel) RecvData

func (dc *DataChannel) RecvData() ([]byte, error)

RecvData 接收数据

func (*DataChannel) SendData

func (dc *DataChannel) SendData(data []byte) error

SendData 发送数据

func (*DataChannel) Start

func (dc *DataChannel) Start()

Start 启动数据通道

func (*DataChannel) Stop

func (dc *DataChannel) Stop()

Stop 停止数据通道

type Demuxer

type Demuxer struct {
	// contains filtered or unexported fields
}

Demuxer SRT 解复用器 从 SRT 连接读取 TS 数据并解复用为 AV 包

func NewDemuxer

func NewDemuxer(conn *Conn) *Demuxer

NewDemuxer 创建 SRT 解复用器

func OpenDemuxer

func OpenDemuxer(rawURL string) (*Demuxer, error)

OpenDemuxer 打开 SRT URL 并创建解复用器

func OpenDemuxerContext

func OpenDemuxerContext(ctx context.Context, rawURL string) (*Demuxer, error)

OpenDemuxerContext 使用 context 打开 SRT URL 并创建解复用器

func (*Demuxer) Close

func (d *Demuxer) Close() error

Close 关闭解复用器

func (*Demuxer) Conn

func (d *Demuxer) Conn() *Conn

Conn 返回底层 SRT 连接

func (*Demuxer) ReadPacket

func (d *Demuxer) ReadPacket() (av.Packet, error)

ReadPacket 读取数据包

func (*Demuxer) Streams

func (d *Demuxer) Streams() ([]av.CodecData, error)

Streams 返回流信息

type HSReqExtension

type HSReqExtension struct {
	SRTVersion     uint32
	SRTFlags       uint32
	RecvTSBPDDelay uint16
	SendTSBPDDelay uint16
}

HSReqExtension 握手请求扩展

func ParseHSReqExtension

func ParseHSReqExtension(b []byte) (ext HSReqExtension, err error)

ParseHSReqExtension 解析握手请求扩展

func (*HSReqExtension) Marshal

func (ext *HSReqExtension) Marshal() []byte

Marshal 序列化握手请求扩展

type Handshake

type Handshake struct {
	Version        uint32   // SRT 版本
	EncryptionType uint16   // 加密类型
	ExtensionField uint16   // 扩展字段
	InitialSeqNum  uint32   // 初始序列号
	MTU            uint32   // 最大传输单元
	FlowWindow     uint32   // 流控窗口
	HandshakeType  uint32   // 握手类型
	SRTSocketID    uint32   // SRT Socket ID
	SynCookie      uint32   // SYN Cookie
	PeerIP         [16]byte // 对端 IP

	// 扩展数据
	Extensions []HandshakeExtension
}

Handshake SRT 握手包

func ParseHandshake

func ParseHandshake(b []byte) (hs Handshake, err error)

ParseHandshake 解析握手包

func (*Handshake) Marshal

func (hs *Handshake) Marshal() []byte

Marshal 序列化握手包

type HandshakeExtension

type HandshakeExtension struct {
	Type uint16
	Data []byte
}

HandshakeExtension 握手扩展

type KMRequest

type KMRequest struct {
	Version    uint8  // 版本
	PacketType uint8  // 包类型
	Sign       uint16 // 签名
	KeyType    uint8  // 密钥类型
	KeyLength  uint8  // 密钥长度
	KeyIndex   uint8  // 密钥索引
	Salt       []byte // 盐值
	WrappedKey []byte // 包装的密钥
}

KMRequest 密钥材料请求

func ParseKMRequest

func ParseKMRequest(data []byte) (*KMRequest, error)

ParseKMRequest 解析密钥材料请求

func (*KMRequest) Serialize

func (req *KMRequest) Serialize() []byte

Serialize 序列化密钥材料请求

type KMResponse

type KMResponse struct {
	Version    uint8
	PacketType uint8
	Sign       uint16
	Status     uint8 // 0=OK, 1=Error
	KeyIndex   uint8
}

KMResponse 密钥材料响应

func BuildKMResponse

func BuildKMResponse(status uint8, keyIndex uint8) *KMResponse

BuildKMResponse 构建密钥材料响应

func (*KMResponse) Serialize

func (rsp *KMResponse) Serialize() []byte

Serialize 序列化密钥材料响应

type KeyLength

type KeyLength int

KeyLength 加密密钥长度

const (
	KeyLength128 KeyLength = 16
	KeyLength192 KeyLength = 24
	KeyLength256 KeyLength = 32
)

type Listener

type Listener struct {
	// contains filtered or unexported fields
}

Listener SRT 监听器

func Listen

func Listen(rawURL string) (*Listener, error)

Listen 创建 SRT 监听器

URL 格式: srt://:port 或 srt://0.0.0.0:port

func ListenConfig

func ListenConfig(ctx context.Context, address string, config Config) (*Listener, error)

ListenConfig 使用指定配置创建监听器

func ListenContext

func ListenContext(ctx context.Context, rawURL string) (*Listener, error)

ListenContext 使用 context 创建监听器

func (*Listener) Accept

func (l *Listener) Accept() (*Conn, error)

Accept 接受新连接

func (*Listener) AcceptContext

func (l *Listener) AcceptContext(ctx context.Context) (*Conn, error)

AcceptContext 使用 context 接受新连接

func (*Listener) Addr

func (l *Listener) Addr() net.Addr

Addr 返回监听地址

func (*Listener) Clients

func (l *Listener) Clients() int

Clients 返回当前连接的客户端数量

func (*Listener) Close

func (l *Listener) Close() error

Close 关闭监听器

func (*Listener) Config

func (l *Listener) Config() Config

Config 返回配置

type Mode

type Mode int

Mode SRT 连接模式

const (
	// ModeCaller 主动连接模式
	ModeCaller Mode = iota
	// ModeListener 监听模式
	ModeListener
	// ModeRendezvous 对等连接模式
	ModeRendezvous
)

func ParseMode

func ParseMode(s string) Mode

ParseMode 解析模式字符串

func (Mode) String

func (m Mode) String() string

String 返回模式名称

type Muxer

type Muxer struct {
	// contains filtered or unexported fields
}

Muxer SRT 复用器 将 AV 包复用为 TS 数据并通过 SRT 连接发送

func CreateMuxer

func CreateMuxer(rawURL string) (*Muxer, error)

CreateMuxer 连接到 SRT URL 并创建复用器

func CreateMuxerContext

func CreateMuxerContext(ctx context.Context, rawURL string) (*Muxer, error)

CreateMuxerContext 使用 context 连接到 SRT URL 并创建复用器

func NewMuxer

func NewMuxer(conn *Conn) *Muxer

NewMuxer 创建 SRT 复用器

func (*Muxer) Close

func (m *Muxer) Close() error

Close 关闭复用器

func (*Muxer) Conn

func (m *Muxer) Conn() *Conn

Conn 返回底层 SRT 连接

func (*Muxer) WriteHeader

func (m *Muxer) WriteHeader(streams []av.CodecData) error

WriteHeader 写入头部

func (*Muxer) WritePacket

func (m *Muxer) WritePacket(pkt av.Packet) error

WritePacket 写入数据包

func (*Muxer) WriteTrailer

func (m *Muxer) WriteTrailer() error

WriteTrailer 写入尾部

type Packet

type Packet struct {
	// 头部字段
	IsControl      bool   // 是否为控制包
	ControlType    uint16 // 控制包类型
	SubType        uint16 // 控制包子类型
	AdditionalInfo uint32 // 控制包附加信息(第二个 32-bit 字)
	SeqNum         uint32 // 序列号(数据包)
	Timestamp      uint32 // 时间戳
	DestSockID     uint32 // 目标 Socket ID

	// 数据包特有字段
	Position   uint8  // 包位置(PP)
	OrderFlag  bool   // 顺序标志(O)
	KeyFlag    uint8  // 密钥标志(KK)
	Retransmit bool   // 重传标志(R)
	MsgNum     uint32 // 消息号

	// 数据
	Data []byte
}

Packet SRT 数据包

func NewACKPacket

func NewACKPacket(ackSeqNum uint32, destSockID uint32, ackData []byte) Packet

NewACKPacket 创建 ACK 包

func NewControlPacket

func NewControlPacket(controlType uint16, destSockID uint32, data []byte) Packet

NewControlPacket 创建控制包

func NewHandshakePacket

func NewHandshakePacket(hs Handshake, destSockID uint32) Packet

NewHandshakePacket 创建握手包

func NewKeepalivePacket

func NewKeepalivePacket(destSockID uint32) Packet

NewKeepalivePacket 创建保活包

func NewNAKPacket

func NewNAKPacket(destSockID uint32, lostList []byte) Packet

NewNAKPacket 创建 NAK 包

func NewShutdownPacket

func NewShutdownPacket(destSockID uint32) Packet

NewShutdownPacket 创建关闭包

func ParsePacket

func ParsePacket(b []byte) (pkt Packet, err error)

ParsePacket 解析 SRT 数据包

func (*Packet) Marshal

func (pkt *Packet) Marshal() []byte

Marshal 序列化 SRT 数据包

type Reader

type Reader struct {
	// contains filtered or unexported fields
}

Reader 实现 io.Reader 接口的包装器

func NewReader

func NewReader(dc *DataChannel) *Reader

NewReader 创建 Reader

func (*Reader) Read

func (r *Reader) Read(p []byte) (n int, err error)

Read 实现 io.Reader

type Stats

type Stats struct {
	// 时间信息
	StartTime     time.Time     // 连接开始时间
	ConnectedTime time.Duration // 已连接时长

	// 数据统计
	BytesSent       int64 // 发送字节数
	BytesReceived   int64 // 接收字节数
	PacketsSent     int64 // 发送包数
	PacketsReceived int64 // 接收包数

	// 丢包统计
	PacketsLost    int64   // 丢包数
	PacketsDropped int64   // 丢弃包数
	PacketsRetrans int64   // 重传包数
	LossRate       float64 // 丢包率

	// 延迟统计
	RTT         time.Duration // 往返时延
	RTTVariance time.Duration // RTT 方差
	Latency     time.Duration // 当前延迟

	// 带宽统计
	Bandwidth    int64   // 当前带宽(bps)
	MaxBandwidth int64   // 最大带宽
	SendRate     float64 // 发送速率(Mbps)
	ReceiveRate  float64 // 接收速率(Mbps)

	// 缓冲统计
	SendBufferLevel    int // 发送缓冲水位
	ReceiveBufferLevel int // 接收缓冲水位
	FlightSize         int // 飞行窗口大小

	// 拥塞统计
	CongestionWindow int // 拥塞窗口大小
}

Stats SRT 连接统计

type TransmissionType

type TransmissionType int

TransmissionType 传输类型

const (
	// TransmissionLive 直播模式(默认)
	TransmissionLive TransmissionType = iota
	// TransmissionFile 文件传输模式
	TransmissionFile
)

type Writer

type Writer struct {
	// contains filtered or unexported fields
}

Writer 实现 io.Writer 接口的包装器

func NewWriter

func NewWriter(dc *DataChannel) *Writer

NewWriter 创建 Writer

func (*Writer) Write

func (w *Writer) Write(p []byte) (n int, err error)

Write 实现 io.Writer

Source Files

  • config.go
  • conn.go
  • crypto.go
  • data.go
  • demuxer.go
  • doc.go
  • gosrt_adapter.go
  • handler.go
  • listener.go
  • packet.go

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL