NoOp

type NoOp struct{}

func (i *NoOp) BindRTCPReader(reader RTCPReader) RTCPReader

func (i *NoOp) BindRTCPWriter(writer RTCPWriter) RTCPWriter

func (i *NoOp) BindLocalStream(_ *StreamInfo, writer RTPWriter) RTPWriter

func (i *NoOp) UnbindLocalStream(_ *StreamInfo)

func (i *NoOp) BindRemoteStream(_ *StreamInfo, reader RTPReader) RTPReader

func (i *NoOp) UnbindRemoteStream(_ *StreamInfo)

func (i *NoOp) Close() error

import (
    "fmt"
    "github.com/pion/interceptor"
    "github.com/pion/rtp"
)

// CustomInterceptor only cares about incoming RTP packets
type CustomInterceptor struct {
    interceptor.NoOp  // Embed NoOp for default implementations
    packetCount int
}

// Override only the method we care about
func (c *CustomInterceptor) BindRemoteStream(
    info *interceptor.StreamInfo,
    reader interceptor.RTPReader,
) interceptor.RTPReader {
    return interceptor.RTPReaderFunc(func(b []byte, a interceptor.Attributes) (int, interceptor.Attributes, error) {
        n, attr, err := reader.Read(b, a)
        if err != nil {
            return 0, nil, err
        }
        
        c.packetCount++
        fmt.Printf("Received packet #%d\n", c.packetCount)
        
        return n, attr, nil
    })
}

// All other Interceptor methods are inherited from NoOp

// LoggingInterceptor logs both incoming and outgoing RTP
type LoggingInterceptor struct {
    interceptor.NoOp
    logger *log.Logger
}

func (l *LoggingInterceptor) BindLocalStream(
    info *interceptor.StreamInfo,
    writer interceptor.RTPWriter,
) interceptor.RTPWriter {
    return interceptor.RTPWriterFunc(
        func(header *rtp.Header, payload []byte, attributes interceptor.Attributes) (int, error) {
            l.logger.Printf("Sending RTP packet, SSRC=%d, SeqNum=%d", 
                header.SSRC, header.SequenceNumber)
            return writer.Write(header, payload, attributes)
        },
    )
}

func (l *LoggingInterceptor) BindRemoteStream(
    info *interceptor.StreamInfo,
    reader interceptor.RTPReader,
) interceptor.RTPReader {
    return interceptor.RTPReaderFunc(func(b []byte, a interceptor.Attributes) (int, interceptor.Attributes, error) {
        n, attr, err := reader.Read(b, a)
        if err != nil {
            return 0, nil, err
        }
        
        if attr == nil {
            attr = make(interceptor.Attributes)
        }
        header, _ := attr.GetRTPHeader(b[:n])
        l.logger.Printf("Received RTP packet, SSRC=%d, SeqNum=%d",
            header.SSRC, header.SequenceNumber)
        
        return n, attr, nil
    })
}

// RTCP methods, unbind methods, and Close are all inherited from NoOp

type ResourceInterceptor struct {
    interceptor.NoOp
    resources map[uint32]*Resource
    mu        sync.Mutex
}

func (r *ResourceInterceptor) BindLocalStream(
    info *interceptor.StreamInfo,
    writer interceptor.RTPWriter,
) interceptor.RTPWriter {
    r.mu.Lock()
    r.resources[info.SSRC] = NewResource()
    r.mu.Unlock()
    return writer  // Don't modify packets
}

func (r *ResourceInterceptor) UnbindLocalStream(info *interceptor.StreamInfo) {
    r.mu.Lock()
    if res, ok := r.resources[info.SSRC]; ok {
        res.Close()
        delete(r.resources, info.SSRC)
    }
    r.mu.Unlock()
}

func (r *ResourceInterceptor) Close() error {
    r.mu.Lock()
    defer r.mu.Unlock()
    
    for _, res := range r.resources {
        res.Close()
    }
    r.resources = nil
    return nil
}

// All other methods inherited from NoOp