TrackLocal

type TrackLocal interface {
    // Bind implements the way media data flows from Track to PeerConnection
    Bind(TrackLocalContext) (RTPCodecParameters, error)
    
    // Unbind implements teardown logic when track is no longer needed
    Unbind(TrackLocalContext) error
    
    // ID is the unique identifier for this Track
    ID() string
    
    // RID is the RTP Stream ID for this track
    RID() string
    
    // StreamID is the group this track belongs to
    StreamID() string
    
    // Kind controls if this TrackLocal is audio or video
    Kind() RTPCodecType
}

Bind(TrackLocalContext) (RTPCodecParameters, error)

Unbind(TrackLocalContext) error

ID() string

RID() string

StreamID() string

Kind() RTPCodecType

type TrackLocalContext interface {
    // CodecParameters returns negotiated RTPCodecParameters
    CodecParameters() []RTPCodecParameters
    
    // HeaderExtensions returns negotiated RTPHeaderExtensionParameters
    HeaderExtensions() []RTPHeaderExtensionParameter
    
    // SSRC returns the negotiated SSRC
    SSRC() SSRC
    
    // SSRCRetransmission returns the negotiated retransmission SSRC
    SSRCRetransmission() SSRC
    
    // SSRCForwardErrorCorrection returns the negotiated FEC SSRC
    SSRCForwardErrorCorrection() SSRC
    
    // WriteStream returns the WriteStream for this TrackLocal
    WriteStream() TrackLocalWriter
    
    // ID is a unique identifier used for both Bind/Unbind
    ID() string
    
    // RTCPReader returns the RTCP interceptor for this TrackLocal
    RTCPReader() interceptor.RTCPReader
}

type TrackLocalWriter interface {
    // WriteRTP encrypts an RTP packet and writes to the connection
    WriteRTP(header *rtp.Header, payload []byte) (int, error)
    
    // Write encrypts and writes a full RTP packet
    Write(b []byte) (int, error)
}

// Create a VP8 video track
videoTrack, err := webrtc.NewTrackLocalStaticSample(
    webrtc.RTPCodecCapability{MimeType: webrtc.MimeTypeVP8},
    "video",
    "pion",
)
if err != nil {
    panic(err)
}

// Add track to peer connection
rtpSender, err := peerConnection.AddTrack(videoTrack)
if err != nil {
    panic(err)
}

fmt.Printf("Track ID: %s\n", videoTrack.ID())
fmt.Printf("Stream ID: %s\n", videoTrack.StreamID())
fmt.Printf("Kind: %s\n", videoTrack.Kind())

// Create an Opus audio track
audioTrack, err := webrtc.NewTrackLocalStaticSample(
    webrtc.RTPCodecCapability{
        MimeType:  webrtc.MimeTypeOpus,
        ClockRate: 48000,
        Channels:  2,
    },
    "audio",
    "pion",
)
if err != nil {
    panic(err)
}

peerConnection.AddTrack(audioTrack)

track, _ := webrtc.NewTrackLocalStaticSample(
    webrtc.RTPCodecCapability{MimeType: webrtc.MimeTypeVP8},
    "video",
    "pion",
)

peerConnection.AddTrack(track)

// Write video frames
for {
    // Get frame from your source
    frame := getNextVideoFrame()
    
    err := track.WriteSample(media.Sample{
        Data:     frame,
        Duration: time.Millisecond * 33, // ~30fps
    })
    if err != nil {
        panic(err)
    }
}

// Create tracks for different quality levels
highTrack, _ := webrtc.NewTrackLocalStaticSample(
    webrtc.RTPCodecCapability{MimeType: webrtc.MimeTypeVP8},
    "video",
    "pion",
)
highTrack.SetRID("high")

mediumTrack, _ := webrtc.NewTrackLocalStaticSample(
    webrtc.RTPCodecCapability{MimeType: webrtc.MimeTypeVP8},
    "video",
    "pion",
)
mediumTrack.SetRID("medium")

lowTrack, _ := webrtc.NewTrackLocalStaticSample(
    webrtc.RTPCodecCapability{MimeType: webrtc.MimeTypeVP8},
    "video",
    "pion",
)
lowTrack.SetRID("low")

// Add base track
rtpSender, _ := peerConnection.AddTrack(highTrack)

// Add additional encodings
rtpSender.AddEncoding(mediumTrack)
rtpSender.AddEncoding(lowTrack)

// Create track that accepts raw RTP packets
track, err := webrtc.NewTrackLocalStaticRTP(
    webrtc.RTPCodecCapability{MimeType: webrtc.MimeTypeH264},
    "video",
    "pion",
)
if err != nil {
    panic(err)
}

peerConnection.AddTrack(track)

// Write RTP packets
for {
    rtpPacket := getRTPPacket() // Your RTP packet source
    
    err := track.WriteRTP(rtpPacket)
    if err != nil {
        panic(err)
    }
}

type CustomTrack struct {
    id       string
    streamID string
    kind     webrtc.RTPCodecType
}

func (t *CustomTrack) Bind(ctx webrtc.TrackLocalContext) (webrtc.RTPCodecParameters, error) {
    // Select codec from available options
    codecs := ctx.CodecParameters()
    if len(codecs) == 0 {
        return webrtc.RTPCodecParameters{}, errors.New("no codecs available")
    }
    
    // Start your media pipeline
    go t.writeLoop(ctx.WriteStream())
    
    return codecs[0], nil
}

func (t *CustomTrack) Unbind(ctx webrtc.TrackLocalContext) error {
    // Cleanup resources
    return nil
}

func (t *CustomTrack) ID() string       { return t.id }
func (t *CustomTrack) RID() string      { return "" }
func (t *CustomTrack) StreamID() string { return t.streamID }
func (t *CustomTrack) Kind() webrtc.RTPCodecType { return t.kind }

func (t *CustomTrack) writeLoop(writer webrtc.TrackLocalWriter) {
    // Your custom media writing logic
}