IntervalPLI Package

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

func NewReceiverInterceptor(opts ...GeneratorOption) (*ReceiverInterceptorFactory, error)

func GeneratorInterval(interval time.Duration) GeneratorOption

func WithGeneratorLoggerFactory(loggerFactory logging.LoggerFactory) GeneratorOption

func (r *GeneratorInterceptor) ForcePLI(ssrc ...uint32)

import (
    "time"
    "github.com/pion/interceptor"
    "github.com/pion/interceptor/pkg/intervalpli"
)

// Create PLI generator
// Sends PLI every 3 seconds
pli, err := intervalpli.NewReceiverInterceptor(
    intervalpli.GeneratorInterval(3 * time.Second),
)
if err != nil {
    panic(err)
}

// Add to registry
registry := &interceptor.Registry{}
registry.Add(pli)

// Build interceptor
i, err := registry.Build("peer-connection-1")
if err != nil {
    panic(err)
}
defer i.Close()

// Only send PLI on-demand via ForcePLI()
pli, _ := intervalpli.NewReceiverInterceptor(
    intervalpli.GeneratorInterval(0), // Disable periodic sending
)

import "github.com/pion/interceptor/pkg/intervalpli"

// Get reference to the interceptor
var pliGen *intervalpli.GeneratorInterceptor

// Later, force PLI for specific SSRC
pliGen.ForcePLI(videoSSRC)

// Or for multiple SSRCs
pliGen.ForcePLI(ssrc1, ssrc2, ssrc3)

import (
    "time"
    "github.com/pion/interceptor"
    "github.com/pion/interceptor/pkg/intervalpli"
    "github.com/pion/webrtc/v4"
)

func setupPLI() (*webrtc.PeerConnection, *intervalpli.GeneratorInterceptor, error) {
    m := &webrtc.MediaEngine{}
    if err := m.RegisterDefaultCodecs(); err != nil {
        return nil, nil, err
    }
    
    ir := &interceptor.Registry{}
    
    // Create PLI generator
    pliFactory, _ := intervalpli.NewReceiverInterceptor(
        intervalpli.GeneratorInterval(2 * time.Second),
    )
    ir.Add(pliFactory)
    
    // Get reference for manual control
    pliGen, _ := intervalpli.NewGeneratorInterceptor(
        intervalpli.GeneratorInterval(2 * time.Second),
    )
    
    api := webrtc.NewAPI(
        webrtc.WithMediaEngine(m),
        webrtc.WithInterceptorRegistry(ir),
    )
    
    pc, err := api.NewPeerConnection(webrtc.Configuration{})
    return pc, pliGen, err
}

type PictureLossIndication struct {
    SenderSSRC uint32  // SSRC of sender
    MediaSSRC  uint32  // SSRC of media stream
}

// Ensure keyframe at stream start
pli, _ := intervalpli.NewReceiverInterceptor(
    intervalpli.GeneratorInterval(0), // No periodic PLI
)

// When new stream detected
pc.OnTrack(func(track *webrtc.TrackRemote, receiver *webrtc.RTPReceiver) {
    if track.Kind() == webrtc.RTPCodecTypeVideo {
        // Force PLI to get initial keyframe
        pliGen.ForcePLI(uint32(track.SSRC()))
    }
})

// Periodic PLI for resilience
pli, _ := intervalpli.NewReceiverInterceptor(
    intervalpli.GeneratorInterval(3 * time.Second),
)

// Also force PLI on detected corruption
if detectVideoCorruption() {
    pliGen.ForcePLI(videoSSRC)
}

// Request keyframe when switching simulcast layers
func switchLayer(newSSRC uint32) {
    // Switch to new layer
    updateReceiver(newSSRC)
    
    // Request keyframe for clean decode
    pliGen.ForcePLI(newSSRC)
}

import "github.com/pion/interceptor/pkg/stats"

// Request keyframe after bitrate change
func onBitrateChange(newBitrate int, ssrc uint32) {
    updateEncoderBitrate(newBitrate)
    
    // Request keyframe to apply new bitrate
    pliGen.ForcePLI(ssrc)
}

import "github.com/pion/interceptor/pkg/stats"

func adaptivePLI(statsGetter stats.Getter, ssrc uint32, pliGen *intervalpli.GeneratorInterceptor) {
    ticker := time.NewTicker(1 * time.Second)
    defer ticker.Stop()
    
    lastStats := statsGetter.Get(ssrc)
    
    for range ticker.C {
        currentStats := statsGetter.Get(ssrc)
        if currentStats == nil || lastStats == nil {
            continue
        }
        
        // Calculate loss rate since last check
        lostPackets := currentStats.PacketsLost - lastStats.PacketsLost
        receivedPackets := currentStats.PacketsReceived - lastStats.PacketsReceived
        
        if receivedPackets > 0 {
            lossRate := float64(lostPackets) / float64(receivedPackets)
            
            // Force PLI if high loss detected
            if lossRate > 0.05 {
                log.Printf("High loss detected (%.1f%%), requesting keyframe", lossRate*100)
                pliGen.ForcePLI(ssrc)
            }
        }
        
        lastStats = currentStats
    }
}

type ConditionalPLI struct {
    pliGen          *intervalpli.GeneratorInterceptor
    lastKeyframe    map[uint32]time.Time
    minInterval     time.Duration
}

func (c *ConditionalPLI) RequestKeyframe(ssrc uint32) {
    now := time.Now()
    
    // Rate limit PLI requests
    if last, ok := c.lastKeyframe[ssrc]; ok {
        if now.Sub(last) < c.minInterval {
            log.Printf("PLI rate limited for SSRC %d", ssrc)
            return
        }
    }
    
    c.lastKeyframe[ssrc] = now
    c.pliGen.ForcePLI(ssrc)
}

type VideoStreamManager struct {
    pliGen *intervalpli.GeneratorInterceptor
    ssrcs  []uint32
    mu     sync.Mutex
}

func (m *VideoStreamManager) AddStream(ssrc uint32) {
    m.mu.Lock()
    defer m.mu.Unlock()
    
    m.ssrcs = append(m.ssrcs, ssrc)
    
    // Request initial keyframe
    m.pliGen.ForcePLI(ssrc)
}

func (m *VideoStreamManager) RefreshAll() {
    m.mu.Lock()
    defer m.mu.Unlock()
    
    // Request keyframes for all streams
    m.pliGen.ForcePLI(m.ssrcs...)
}

import "github.com/pion/logging"

loggerFactory := logging.NewDefaultLoggerFactory()
loggerFactory.DefaultLogLevel = logging.LogLevelDebug

pli, _ := intervalpli.NewReceiverInterceptor(
    intervalpli.WithGeneratorLoggerFactory(loggerFactory),
    intervalpli.GeneratorInterval(3 * time.Second),
)

// Log will show:
// - When PLI is sent
// - Which SSRCs receive PLI
// - Timing information