1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

✅ 1. RTP paket kaybı izleme (Bölüm 2.2)
   → Kayıp > 0.01% ise uyar
   
✅ 2. RTP jitter izleme (Bölüm 2.2)
   → Jitter > 1ms ise uyar
   
✅ 3. PTP offset izleme (Bölüm 2.6)
   → Offset > 10μs ise uyar
   
✅ 4. Temel Grafana dashboard (Bölüm 5)
   → Stream'lere görünürlük

1
2
3
4
5
6
7
8

✅ 5. SMPTE 2022-7 sağlığı (Bölüm 2.4)
   → Redundancy'nin çalıştığından emin olun
   
✅ 6. Buffer seviyesi izleme (Bölüm 8.1)
   → Frame drop'ları önleyin
   
✅ 7. Uyarı (Bölüm 6)
   → İzleyiciler şikayet etmeden önce haberdar olun

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

✅ 8. Audio izleme (Bölüm 2.3)
   → Sample rate, A/V sync
   
✅ 9. Ancillary data (Bölüm 2.5)
   → Closed captions (FCC uyumluluğu!)
   
✅ 10. Network switch'leri (Bölüm 4.3)
   → Switch sağlığı için gNMI
   
✅ 11. NMOS control plane (Bölüm 10.1)
   → Registry ve bağlantıları izleyin

1
2
3
4
5

✅ 12. Güvenlik sıkılaştırması (Bölüm 8.1)
✅ 13. CI/CD pipeline (Bölüm 11.9)
✅ 14. Synthetic monitoring (Bölüm 11.10)
✅ 15. Log korelasyonu (Bölüm 11.11)
✅ 16. Ölçekleme stratejileri (Bölüm 10.4)

1
2
3

RTP Kayıp Oranı: %0.02 (10,000'de 2 paket)
Görsel Etki: Aralıklı blok artifacts
İş Etkisi: İzleyici şikayetleri, sosyal medya tepkisi

1
2
3

Kamera 1 PTP Offset: +5μs (normal)
Kamera 7 PTP Offset: +42,000μs (42ms kayma!)
Sonuç: Kamera geçişlerinde audio/video sync sorunları

1
2
3

Beklenen Bant Genişliği: 2.5 Gbps (belgelenmiş stream'ler)
Gerçek Bant Genişliği: 8.7 Gbps (bilinmeyen multicast kaynakları!)
Sonuç: Ağ tıkanıklığı, düşen frame'ler, başarısız production

1
2
3
4
5
6
7
8

Senaryo: Kamera "Narrow" olarak yapılandırılmış ama ağda jitter var

Beklenen: Sabit paket varışı (alıcı buffer için kolay)
Gerçek: Paketler patlamalar halinde geliyor (buffer tükenmeleri!)

Sonuç: %0 paket kaybına rağmen frame drop'lar!

İzleme İhtiyacı: Stream sınıfının ağ davranışıyla eşleşmediğini tespit et

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# Capture single RTP packet for analysis
tcpdump -i eth0 -nn -X -c 1 'udp dst port 20000'

# Output:
# 12:34:56.789012 IP 10.1.1.100.50000 > 239.1.1.10.20000: UDP, length 1460
# 0x0000:  4500 05dc 1234 4000 4011 abcd 0a01 0164  E....4@.@......d
# 0x0010:  ef01 010a c350 4e20 05c8 5678 8060 006f  .....PN...Vx.`.o
#                                    ↑↑↑↑ ↑↑↑↑
#                                    RTP  Seq
#          ↑↑↑↑ ↑↑↑↑ ↑↑↑↑ ↑↑↑↑
#          Ver  DSCP  Total Len

# Parse with tshark for detailed RTP info
tshark -i eth0 -Y "rtp" -T fields \
    -e rtp.seq -e rtp.timestamp -e rtp.ssrc -e rtp.p_type

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

type RTPStreamMetrics struct {
    // Sequence number'lara göre beklenen toplam paketler
    PacketsExpected   uint64
    // Gerçekten alınan paketler
    PacketsReceived   uint64
    // Hesaplanan kayıp
    PacketLoss        float64 // yüzde
    // Kategoriye göre kayıp
    SinglePacketLoss  uint64  // 1 paket kayboldu
    BurstLoss         uint64  // 2+ ardışık kayboldu
}

// Kabul edilebilir eşikler
const (
    ThresholdPacketLossWarning  = 0.001  // %0.001 = 100,000'de 1
    ThresholdPacketLossCritical = 0.01   // %0.01 = 10,000'de 1
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

type JitterMetrics struct {
    // RFC 3550 jitter hesaplaması
    InterarrivalJitter float64  // mikrosaniye cinsinden
    // Gözlemlenen maksimum jitter
    MaxJitter          float64
    // Jitter histogramı (dağılım)
    JitterHistogram    map[int]int  // bucket -> sayım
}

// 1080p60 için eşikler
const (
    ThresholdJitterWarning  = 500   // 500μs
    ThresholdJitterCritical = 1000  // 1ms
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

type ArrivalMetrics struct {
    // Saniyedeki paketler (stream spec'e uymalı)
    PacketsPerSecond  float64
    // Beklenen hız (SDP'den)
    ExpectedPPS       float64
    // Sapma
    RateDeviation     float64  // yüzde
}

// Örnek: 1080p60 4:2:2 10-bit
const (
    Expected1080p60PPS = 90000  // ~90K paket/saniye
)

1
2
3
4
5
6
7
8

type TimestampMetrics struct {
    // Timestamp atlamaları (süreksizlikler)
    TimestampJumps    uint64
    // Clock hızı (video için 90kHz, audio için 48kHz)
    ClockRate         uint32
    // PTP'ye karşı timestamp kayması
    TimestampDrift    float64  // mikrosaniye
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

// ST 2110-22'ye özgü metrikler
type ST2110_22Metrics struct {
    // İletim Modu
    TransmissionMode    string  // "gapped" (2110-20) veya "linear" (2110-22)
    
    // TRS (Transmission Rate Scheduler) Uyumluluğu
    TRSCompliant        bool
    TRSViolations       uint64
    TRSMode             string  // narrow linear için "2110TPNL"
    
    // Drain Zamanlaması (CBR için kritik)
    DrainPeriodNs       int64   // Beklenen drain periyodu (örn. 1080p60 için 13468 ns)
    ActualDrainNs       int64   // Ölçülen drain periyodu
    DrainVarianceNs     int64   // Beklenenden varyans (< 100ns olmalı)
    DrainJitter         float64 // Drain zamanlamasında jitter
    
    // N ve Nmax (satır başına paket)
    PacketsPerLine      int     // Video satırı başına gerçek paketler
    MaxPacketsPerLine   int     // Maksimum izin verilen (SDP'den)
    NViolations         uint64  // N'nin Nmax'ı aştığı zamanlar
    
    // TFSM (Time of First Scheduled Packet) her frame için
    TFSMOffset          int64   // Frame sınırından nanosaniyeler
    TFSMVariance        int64   // Sabit olmalı
    
    // Read Point (Rₚ) takibi
    ReadPointOffset     int64   // PTP epoch'tan offset
    ReadPointDrift      float64 // Zamana göre kayma
    
    // Paket aralıkları (linear mode'da uniform olmalı)
    InterPacketGap      int64   // Paketler arası nanosaniye
    GapVariance         int64   // Linear mode'da minimal olmalı
}

// ST 2110-22 için eşikler
const (
    MaxDrainVarianceNs  = 100    // 100ns maksimum varyans
    MaxTFSMVarianceNs   = 50     // 50ns maksimum TFSM varyansı
    MaxGapVarianceNs    = 200    // 200ns maksimum paketler arası boşluk varyansı
)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197

// rtp/st2110_22.go
package rtp

import (
    "fmt"
    "math"
    "time"
)

type ST2110_22Analyzer struct {
    metrics          ST2110_22Metrics
    
    // Drain zamanlaması için durum
    lastPacketTime   time.Time
    lastFrameStart   time.Time
    packetsThisFrame int
    
    // Beklenen değerler (SDP'den)
    expectedDrainNs  int64
    expectedNmax     int
    
    // Çalışan istatistikler
    drainSamples     []int64
    gapSamples       []int64
}

func NewST2110_22Analyzer(width, height int, fps float64) *ST2110_22Analyzer {
    // Linear mode için beklenen drain'i hesapla
    // 1080p60 için: drain = 1/60 / 1125 satır ≈ 13468 ns satır başına
    frameTimeNs := int64(1e9 / fps)
    totalLines := height + (height / 10) // Aktif + blanking
    drainPeriodNs := frameTimeNs / int64(totalLines)
    
    return &ST2110_22Analyzer{
        expectedDrainNs: drainPeriodNs,
        metrics: ST2110_22Metrics{
            TransmissionMode: "linear",
            TRSMode:         "2110TPNL",
        },
    }
}

func (a *ST2110_22Analyzer) AnalyzePacket(packet *RTPPacket, arrivalTime time.Time) {
    now := arrivalTime
    
    // Yeni frame mi kontrol et (marker bit veya timestamp wrap)
    if packet.Marker || a.isNewFrame(packet) {
        // Önceki frame'i doğrula
        a.validateFrame()
        
        // Yeni frame için sıfırla
        a.lastFrameStart = now
        a.packetsThisFrame = 0
    }
    
    a.packetsThisFrame++
    
    // Paketler arası boşluğu ölç (linear mode'da uniform olmalı)
    if !a.lastPacketTime.IsZero() {
        gap := now.Sub(a.lastPacketTime).Nanoseconds()
        a.gapSamples = append(a.gapSamples, gap)
        a.metrics.InterPacketGap = gap
        
        // Boşluk varyansını hesapla
        if len(a.gapSamples) > 100 {
            a.metrics.GapVariance = a.calculateVariance(a.gapSamples)
            
            // Varyans çok yüksekse uyar (non-linear iletim!)
            if a.metrics.GapVariance > MaxGapVarianceNs {
                fmt.Printf("UYARI: Yüksek boşluk varyansı %dns (linear mode bekleniyor)\n", 
                    a.metrics.GapVariance)
            }
            
            // Sadece son örnekleri tut
            a.gapSamples = a.gapSamples[len(a.gapSamples)-100:]
        }
    }
    a.lastPacketTime = now
    
    // RTP extension'dan TFSM'yi (Time of First Scheduled Packet) çıkar
    if tfsm := a.extractTFSM(packet); tfsm != 0 {
        a.metrics.TFSMOffset = tfsm
        
        // TFSM'nin frame'ler arası tutarlı olduğunu doğrula
        // (frame sınırından aynı offset olmalı)
        if a.metrics.TFSMVariance > MaxTFSMVarianceNs {
            a.metrics.TRSViolations++
            a.metrics.TRSCompliant = false
        }
    }
}

func (a *ST2110_22Analyzer) validateFrame() {
    if a.packetsThisFrame == 0 {
        return
    }
    
    // Gerçek drain periyodunu hesapla
    frameDuration := time.Since(a.lastFrameStart).Nanoseconds()
    actualDrain := frameDuration / int64(a.packetsThisFrame)
    
    a.metrics.ActualDrainNs = actualDrain
    a.drainSamples = append(a.drainSamples, actualDrain)
    
    // Drain varyansını hesapla
    if len(a.drainSamples) > 100 {
        variance := a.calculateVariance(a.drainSamples)
        a.metrics.DrainVarianceNs = variance
        
        // TRS uyumluluğunu kontrol et (drain tolerans içinde sabit olmalı)
        if variance > MaxDrainVarianceNs {
            a.metrics.TRSViolations++
            a.metrics.TRSCompliant = false
            
            fmt.Printf("TRS İHLALİ: Drain varyansı %dns (maks: %dns)\n",
                variance, MaxDrainVarianceNs)
        } else {
            a.metrics.TRSCompliant = true
        }
        
        // Sadece son örnekleri tut
        a.drainSamples = a.drainSamples[len(a.drainSamples)-100:]
    }
    
    // N'nin (satır başına paket) Nmax'ı aşmadığını doğrula
    a.metrics.PacketsPerLine = a.packetsThisFrame
    if a.expectedNmax > 0 && a.packetsThisFrame > a.expectedNmax {
        a.metrics.NViolations++
        fmt.Printf("N İHLALİ: %d paket (Nmax: %d)\n",
            a.packetsThisFrame, a.expectedNmax)
    }
}

func (a *ST2110_22Analyzer) calculateVariance(samples []int64) int64 {
    if len(samples) == 0 {
        return 0
    }
    
    // Ortalamayı hesapla
    var sum int64
    for _, v := range samples {
        sum += v
    }
    mean := float64(sum) / float64(len(samples))
    
    // Varyansı hesapla
    var variance float64
    for _, v := range samples {
        diff := float64(v) - mean
        variance += diff * diff
    }
    variance /= float64(len(samples))
    
    return int64(math.Sqrt(variance))
}

func (a *ST2110_22Analyzer) extractTFSM(packet *RTPPacket) int64 {
    // TFSM için RTP header extension'ı parse et (varsa)
    // ST 2110-22 zamanlama bilgisi için RTP extension ID 1 kullanır
    // Uygulama gerçek paket yapısına bağlı
    return 0  // Placeholder
}

func (a *ST2110_22Analyzer) isNewFrame(packet *RTPPacket) bool {
    // Frame sınırlarını tespit et (timestamp artışı)
    // 1080p60 için: timestamp 1500 artar (90kHz / 60fps)
    return false  // Placeholder
}

// ST 2110-22 için Prometheus metrikleri
func (e *ST2110Exporter) registerST2110_22Metrics() {
    e.trsCompliant = prometheus.NewGaugeVec(
        prometheus.GaugeOpts{
            Name: "st2110_22_trs_compliant",
            Help: "TRS uyumluluk durumu (1=uyumlu, 0=ihlal)",
        },
        []string{"stream_id"},
    )
    
    e.drainVariance = prometheus.NewGaugeVec(
        prometheus.GaugeOpts{
            Name: "st2110_22_drain_variance_nanoseconds",
            Help: "Nanosaniye cinsinden drain zamanlama varyansı",
        },
        []string{"stream_id"},
    )
    
    e.trsViolations = prometheus.NewCounterVec(
        prometheus.CounterOpts{
            Name: "st2110_22_trs_violations_total",
            Help: "Toplam TRS uyumluluk ihlalleri",
        },
        []string{"stream_id"},
    )
    
    prometheus.MustRegister(e.trsCompliant, e.drainVariance, e.trsViolations)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

# alerts/st2110_22.yml
groups:
  - name: st2110_22_cbr
    interval: 1s
    rules:
      # TRS uyumluluk ihlali
      - alert: ST2110_22_TRSViolation
        expr: st2110_22_trs_compliant == 0
        for: 5s
        labels:
          severity: critical
        annotations:
          summary: "{{ $labels.stream_id }} üzerinde TRS uyumluluk ihlali"
          description: "Stream sabit bit hızı iletimini sürdürmüyor"
      
      # Aşırı drain varyansı
      - alert: ST2110_22_HighDrainVariance
        expr: st2110_22_drain_variance_nanoseconds > 100
        for: 10s
        labels:
          severity: warning
        annotations:
          summary: "{{ $labels.stream_id }} üzerinde yüksek drain varyansı"
          description: "Drain varyansı {{ $value }}ns (maks: 100ns)"
      
      # N, Nmax'ı aştı
      - alert: ST2110_22_NExceeded
        expr: increase(st2110_22_n_violations_total[1m]) > 0
        labels:
          severity: critical
        annotations:
          summary: "{{ $labels.stream_id }} üzerinde satır başına paket Nmax'ı aştı"
          description: "ST 2110-22 N kısıtlaması ihlal edildi"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

// Audio'ya özgü metrikler
type AudioStreamMetrics struct {
    // Sample rate doğrulaması
    SampleRate          int     // 48000, 96000, vb.
    ActualSampleRate    float64 // Ölçülen (beyan edilenle eşleşmeli)
    SampleRateDrift     float64 // ppm (parts per million)
    
    // Channel mapping
    DeclaredChannels    int     // SDP'den
    ActualChannels      int     // Stream'de tespit edilen
    ChannelMappingOK    bool
    
    // Audio'ya özgü zamanlama
    PacketsPerSecond    float64 // örn. 1ms paketler için 1000
    SamplesPerPacket    int     // örn. 48kHz/1ms için 48 örnek
    
    // A/V Sync (video stream'e göre)
    VideoStreamID       string
    AudioDelayMs        float64 // Audio önde (+) veya arkada (-) video
    LipSyncError        bool    // > 40ms fark edilir
    
    // AES67 uyumluluğu
    AES67Compliant      bool
    AES67Profile        string  // "High", "Medium", "Low"
    
    // Audio kalite göstergeleri
    SilenceDetected     bool
    ClippingDetected    bool    // Audio > 0dBFS
    PhaseIssues         bool    // L/R kanal faz sorunları
    
    // ST 2110-31 (HDR audio) özel
    BitDepth            int     // 16, 24, 32 bit
    DynamicRange        float64 // dB
}

// Eşikler
const (
    MaxSampleRateDriftPPM  = 10     // 10 ppm maksimum kayma
    MaxAudioDelayMs        = 40     // 40ms dudak sync toleransı
    MaxSilenceDurationMs   = 5000   // 5 saniye sessizlik = uyarı
)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

// audio/analyzer.go
package audio

import (
    "fmt"
    "math"
    "time"
)

type AudioAnalyzer struct {
    metrics        AudioStreamMetrics
    videoAnalyzer  *VideoAnalyzer  // A/V sync hesaplaması için
    
    // Sample rate ölçümü
    lastTimestamp  uint32
    lastPacketTime time.Time
    sampleCount    uint64
    
    // Sessizlik tespiti
    silenceStart   time.Time
    isSilent       bool
    
    // Kanal doğrulaması
    channelData    [][]int16  // Kanal başına örnekler
}

func NewAudioAnalyzer(sampleRate, channels int) *AudioAnalyzer {
    return &AudioAnalyzer{
        metrics: AudioStreamMetrics{
            SampleRate:       sampleRate,
            DeclaredChannels: channels,
        },
        channelData: make([][]int16, channels),
    }
}

func (a *AudioAnalyzer) AnalyzePacket(packet *RTPPacket, arrivalTime time.Time) {
    // RTP payload'dan audio örneklerini çıkar
    samples := a.extractSamples(packet)
    
    // Gerçek sample rate'i ölç
    if a.lastTimestamp != 0 {
        timestampDiff := packet.Timestamp - a.lastTimestamp
        timeDiff := arrivalTime.Sub(a.lastPacketTime).Seconds()
        
        if timeDiff > 0 {
            actualRate := float64(timestampDiff) / timeDiff
            a.metrics.ActualSampleRate = actualRate
            
            // ppm cinsinden kaymayı hesapla
            expectedRate := float64(a.metrics.SampleRate)
            drift := (actualRate - expectedRate) / expectedRate * 1e6
            a.metrics.SampleRateDrift = drift
            
            if math.Abs(drift) > MaxSampleRateDriftPPM {
                fmt.Printf("AUDIO KAYMASI: %.2f ppm (maks: %d)\n", drift, MaxSampleRateDriftPPM)
            }
        }
    }
    
    a.lastTimestamp = packet.Timestamp
    a.lastPacketTime = arrivalTime
    a.sampleCount += uint64(len(samples))
    
    // Sessizliği tespit et (tüm örnekler sıfıra yakın)
    if a.isSilenceFrame(samples) {
        if !a.isSilent {
            a.silenceStart = arrivalTime
            a.isSilent = true
        }
        
        silenceDuration := arrivalTime.Sub(a.silenceStart)
        if silenceDuration.Milliseconds() > MaxSilenceDurationMs {
            a.metrics.SilenceDetected = true
            fmt.Printf("SESSİZLİK TESPİT EDİLDİ: %dms\n", silenceDuration.Milliseconds())
        }
    } else {
        a.isSilent = false
        a.metrics.SilenceDetected = false
    }
    
    // Clipping'i tespit et (maksimum/minimum değerlerde örnekler)
    if a.detectClipping(samples) {
        a.metrics.ClippingDetected = true
    }
    
    // Kanal sayısını doğrula
    channels := len(samples) / a.metrics.SamplesPerPacket
    if channels != a.metrics.DeclaredChannels {
        a.metrics.ChannelMappingOK = false
        fmt.Printf("KANAL UYUŞMAZLIĞI: Beklenen %d, alınan %d\n",
            a.metrics.DeclaredChannels, channels)
    }
}

// A/V sync offset'ini hesapla
func (a *AudioAnalyzer) CalculateAVSync() {
    if a.videoAnalyzer == nil {
        return
    }
    
    // Audio timestamp'ini al (örnekler cinsinden)
    audioTimestampNs := int64(a.lastTimestamp) * 1e9 / int64(a.metrics.SampleRate)
    
    // Video timestamp'ini al (90kHz birimleri cinsinden)
    videoTimestampNs := int64(a.videoAnalyzer.lastTimestamp) * 1e9 / 90000
    
    // Offset'i hesapla
    offsetNs := audioTimestampNs - videoTimestampNs
    a.metrics.AudioDelayMs = float64(offsetNs) / 1e6
    
    // Dudak sync hatasını kontrol et
    if math.Abs(a.metrics.AudioDelayMs) > MaxAudioDelayMs {
        a.metrics.LipSyncError = true
        fmt.Printf("DUDAK SYNC HATASI: Audio %+.1fms (maks: ±%dms)\n",
            a.metrics.AudioDelayMs, MaxAudioDelayMs)
    } else {
        a.metrics.LipSyncError = false
    }
}

func (a *AudioAnalyzer) isSilenceFrame(samples []int16) bool {
    // Tüm örneklerin eşik altında olup olmadığını kontrol et (örn. -60dBFS)
    threshold := int16(32)  // Çok sessiz
    
    for _, sample := range samples {
        if sample > threshold || sample < -threshold {
            return false
        }
    }
    return true
}

func (a *AudioAnalyzer) detectClipping(samples []int16) bool {
    // Herhangi bir örneğin maks/min'de olup olmadığını kontrol et (clipping)
    maxVal := int16(32767)
    minVal := int16(-32768)
    
    for _, sample := range samples {
        if sample >= maxVal-10 || sample <= minVal+10 {
            return true
        }
    }
    return false
}

func (a *AudioAnalyzer) extractSamples(packet *RTPPacket) []int16 {
    // RTP payload'dan L16, L24 veya L32 audio'yu parse et
    // Uygulama bit derinliğine bağlı
    return nil  // Placeholder
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

# alerts/audio.yml
groups:
  - name: st2110_audio
    interval: 1s
    rules:
      # Sample rate sapması
      - alert: ST2110AudioSampleRateDrift
        expr: abs(st2110_audio_sample_rate_drift_ppm) > 10
        for: 5s
        labels:
          severity: critical
        annotations:
          summary: "{{ $labels.stream_id }} üzerinde audio sample rate sapması"
          description: "Kayma: {{ $value }} ppm (maks: 10 ppm)"
      
      # Dudak sync hatası
      - alert: ST2110LipSyncError
        expr: abs(st2110_audio_delay_milliseconds) > 40
        for: 10s
        labels:
          severity: critical
        annotations:
          summary: "{{ $labels.stream_id }} üzerinde dudak sync hatası"
          description: "Audio offset: {{ $value }}ms (maks: ±40ms)"
      
      # Uzun süreli sessizlik
      - alert: ST2110AudioSilence
        expr: st2110_audio_silence_detected == 1
        for: 5s
        labels:
          severity: warning
        annotations:
          summary: "{{ $labels.stream_id }} üzerinde uzun süreli sessizlik"
          description: "> 5 saniye audio sinyali tespit edilmedi"
      
      # Audio clipping
      - alert: ST2110AudioClipping
        expr: st2110_audio_clipping_detected == 1
        for: 1s
        labels:
          severity: warning
        annotations:
          summary: "{{ $labels.stream_id }} üzerinde audio clipping"
          description: "Audio seviyeleri 0dBFS'yi aşıyor (bozulma)"
      
      # Kanal mapping hatası
      - alert: ST2110AudioChannelMismatch
        expr: st2110_audio_channel_mapping_ok == 0
        for: 5s
        labels:
          severity: critical
        annotations:
          summary: "{{ $labels.stream_id }} üzerinde audio kanal uyuşmazlığı"
          description: "Beyan edilen vs gerçek kanal sayısı uyuşmazlığı"

1
2
3
4
5
6
7
8
9

⚠️  CRITICAL: Path Diversity < 50%
Shared Hops: core-switch-1.local
Risk: Single point of failure detected!

Action Required:
1. Reconfigure backup path via Core B
2. Verify with traceroute:
   Main:   hop1→CoreA→hop3
   Backup: hop1→CoreB→hop3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

// Validate true path diversity for SMPTE 2022-7
func (a *ST2022_7Analyzer) ValidatePathDiversity() error {
    // Traceroute both streams
    mainPath := traceroute(a.mainStreamIP)
    backupPath := traceroute(a.backupStreamIP)
    
    // Find shared hops
    sharedHops := []string{}
    for _, hop := range mainPath {
        if contains(backupPath, hop) {
            sharedHops = append(sharedHops, hop)
        }
    }
    
    // Calculate diversity percentage
    totalHops := len(mainPath) + len(backupPath)
    uniqueHops := totalHops - (2 * len(sharedHops))
    diversity := float64(uniqueHops) / float64(totalHops)
    
    a.metrics.PathDiversity = diversity
    a.metrics.SharedHops = sharedHops
    
    // Alert if diversity too low
    if diversity < MinPathDiversity {
        return fmt.Errorf(
            "CRITICAL: Path diversity %.1f%% < %.1f%%. Shared hops: %v",
            diversity*100, MinPathDiversity*100, sharedHops,
        )
    }
    
    return nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

// ST 2022-7 detaylı metrikler
type ST2022_7Metrics struct {
    // Stream durumu
    MainStreamActive       bool
    BackupStreamActive     bool
    BothStreamsHealthy     bool
    
    // Stream başına sağlık
    MainPacketLoss         float64
    BackupPacketLoss       float64
    MainJitter             float64
    BackupJitter           float64
    MainLastSeenMs         int64   // Son paketten bu yana milisaniye
    BackupLastSeenMs       int64
    
    // Protection switching
    CurrentActiveStream    string  // "main", "backup", "both"
    SwitchingMode          string  // "seamless" veya "manual"
    LastSwitchTime         time.Time
    SwitchingEvents        uint64
    
    // Seamless switching performansı
    LastSwitchDuration     time.Duration  // Geçiş ne kadar sürdü
    PacketsLostDuringSwitch uint64        // Seamless için SIFIR olmalı
    
    // Path çeşitliliği doğrulaması
    MainNetworkPath        []string  // Yoldaki IP adresleri (traceroute)
    BackupNetworkPath      []string
    PathDiversity          float64   // Farklı hop'ların yüzdesi
    SharedHops             []string  // Ortak arıza noktaları
    
    // Zamanlama hizalaması
    StreamTimingOffset     int64     // Ana/yedek arasında nanosaniye
    TimingWithinTolerance  bool      // < 1ms offset gerekli
    
    // Paket birleştirici istatistikleri
    DuplicatePacketsRx     uint64    // Her iki stream de aynı paketi aldı
    UniqueFromMain         uint64    // Sadece ana'da paket vardı
    UniqueFromBackup       uint64    // Sadece yedekte paket vardı (geçiş olayları)
    MergerBufferUsage      float64   // Kullanılan birleştirici buffer yüzdesi
}

// Eşikler
const (
    MaxStreamTimingOffsetMs = 1     // Stream'ler arası maksimum 1ms
    MaxSwitchDurationMs     = 100   // Maksimum 100ms geçiş süresi
    MinPathDiversity        = 0.5   // Minimum %50 farklı yollar
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

Senaryo: Switch yeniden başlatma nedeniyle ana stream başarısız oluyor

2022-7 Olmadan:
  T+0ms:    Ana stream durur
  T+500ms:  Operatör fark eder
  T+30s:    Manuel failover başlatılır
  T+35s:    Yedek stream canlı
  Sonuç: 35 saniye yayında SİYAH ($$$$$)

2022-7 ile (Seamless):
  T+0ms:    Ana stream durur
  T+1ms:    Alıcı otomatik olarak yedeğe geçer
  T+2ms:    Yedek stream çıkış yapıyor
  Sonuç: 2ms kesinti (izleyiciler için görünmez) ✅

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233

// protection/st2022_7.go
package protection

import (
    "fmt"
    "time"
)

type ST2022_7Analyzer struct {
    metrics ST2022_7Metrics
    
    // Paket birleştirici durumu
    seenPackets      map[uint16]packetInfo  // Sequence -> bilgi
    mergerBuffer     []MergedPacket
    mergerBufferSize int
    
    // Stream sağlık takibi
    mainHealthCheck  time.Time
    backupHealthCheck time.Time
}

type packetInfo struct {
    source      string  // "main" veya "backup"
    timestamp   time.Time
    delivered   bool
}

type MergedPacket struct {
    seqNumber   uint16
    fromMain    bool
    fromBackup  bool
    delivered   string  // Hangi stream kullanıldı
    arrivalDiff time.Duration  // Stream'ler arası zaman farkı
}

func NewST2022_7Analyzer(bufferSize int) *ST2022_7Analyzer {
    return &ST2022_7Analyzer{
        seenPackets:      make(map[uint16]packetInfo),
        mergerBuffer:     make([]MergedPacket, 0, bufferSize),
        mergerBufferSize: bufferSize,
        metrics: ST2022_7Metrics{
            SwitchingMode: "seamless",
        },
    }
}

func (a *ST2022_7Analyzer) ProcessPacket(packet *RTPPacket, source string, arrivalTime time.Time) *RTPPacket {
    seq := packet.SequenceNumber
    
    // Stream sağlığını güncelle
    if source == "main" {
        a.mainHealthCheck = arrivalTime
        a.metrics.MainStreamActive = true
    } else {
        a.backupHealthCheck = arrivalTime
        a.metrics.BackupStreamActive = true
    }
    
    // Bu paketi daha önce görüp görmediğimizi kontrol et
    if existing, seen := a.seenPackets[seq]; seen {
        // Duplicate paket (her iki stream de çalışıyor)
        a.metrics.DuplicatePacketsRx++
        
        // Stream'ler arası zamanlama offset'ini hesapla
        timeDiff := arrivalTime.Sub(existing.timestamp)
        a.metrics.StreamTimingOffset = timeDiff.Nanoseconds()
        
        if timeDiff.Milliseconds() > MaxStreamTimingOffsetMs {
            a.metrics.TimingWithinTolerance = false
            fmt.Printf("ZAMANLAMA OFFSET: Ana/yedek arasında %dms (maks: %dms)\n",
                timeDiff.Milliseconds(), MaxStreamTimingOffsetMs)
        }
        
        // Zaten teslim edildi, duplicate'i at
        if existing.delivered {
            return nil
        }
        
        // Birleştirme kaydını güncelle
        a.updateMergeRecord(seq, source, arrivalTime)
        
        return nil  // Duplicate'i at
    }
    
    // Yeni paket - kaydet
    a.seenPackets[seq] = packetInfo{
        source:    source,
        timestamp: arrivalTime,
        delivered: false,
    }
    
    // Benzersiz paket sayaçlarını güncelle
    if source == "main" {
        a.metrics.UniqueFromMain++
    } else {
        a.metrics.UniqueFromBackup++
        
        // Sadece yedekten paket = ana stream'de kayıp!
        // Bu bir geçiş olayı
        if !a.isMainHealthy() {
            a.handleSwitch(arrivalTime)
        }
    }
    
    // Paketi teslim et
    info := a.seenPackets[seq]
    info.delivered = true
    a.seenPackets[seq] = info
    
    // Aktif stream'i güncelle
    a.updateActiveStream(source)
    
    // Map'ten eski paketleri temizle (sadece son 1000'i tut)
    if len(a.seenPackets) > 1000 {
        a.cleanOldPackets()
    }
    
    return packet
}

func (a *ST2022_7Analyzer) isMainHealthy() bool {
    // Ana, son 100ms'de paket yoksa çökmüş sayılır
    return time.Since(a.mainHealthCheck).Milliseconds() < 100
}

func (a *ST2022_7Analyzer) isBackupHealthy() bool {
    return time.Since(a.backupHealthCheck).Milliseconds() < 100
}

func (a *ST2022_7Analyzer) handleSwitch(switchTime time.Time) {
    // Geçiş olayını kaydet
    a.metrics.SwitchingEvents++
    
    // Geçiş süresini hesapla
    if !a.metrics.LastSwitchTime.IsZero() {
        duration := switchTime.Sub(a.metrics.LastSwitchTime)
        a.metrics.LastSwitchDuration = duration
        
        fmt.Printf("KORUMA GEÇİŞİ: Ana → Yedek (süre: %dms)\n",
            duration.Milliseconds())
        
        if duration.Milliseconds() > MaxSwitchDurationMs {
            fmt.Printf("YAVAŞ GEÇİŞ: %dms (maks: %dms)\n",
                duration.Milliseconds(), MaxSwitchDurationMs)
        }
    }
    
    a.metrics.LastSwitchTime = switchTime
    a.metrics.CurrentActiveStream = "backup"
}

func (a *ST2022_7Analyzer) updateActiveStream(source string) {
    mainHealthy := a.isMainHealthy()
    backupHealthy := a.isBackupHealthy()
    
    a.metrics.BothStreamsHealthy = mainHealthy && backupHealthy
    
    if mainHealthy && backupHealthy {
        a.metrics.CurrentActiveStream = "both"
    } else if mainHealthy {
        a.metrics.CurrentActiveStream = "main"
    } else if backupHealthy {
        a.metrics.CurrentActiveStream = "backup"
    } else {
        a.metrics.CurrentActiveStream = "none"  // Felaket!
    }
}

func (a *ST2022_7Analyzer) updateMergeRecord(seq uint16, source string, arrival time.Time) {
    // Mevcut birleştirme kaydını bul
    for i := range a.mergerBuffer {
        if a.mergerBuffer[i].seqNumber == seq {
            if source == "backup" {
                a.mergerBuffer[i].fromBackup = true
            }
            return
        }
    }
}

func (a *ST2022_7Analyzer) cleanOldPackets() {
    // 500'den eski paketleri kaldır (son pencereyi tut)
    minSeq := uint16(0)
    for seq := range a.seenPackets {
        if seq > minSeq {
            minSeq = seq
        }
    }
    
    cutoff := minSeq - 500
    for seq := range a.seenPackets {
        if seq < cutoff {
            delete(a.seenPackets, seq)
        }
    }
}

// Path çeşitliliğini doğrula (farklı ağ yolları kullanmalı!)
func (a *ST2022_7Analyzer) ValidatePathDiversity() {
    // Bu, ana ve yedek stream'lerin farklı fiziksel yollar
    // aldığını doğrulamak için traceroute veya benzeri kullanır
    
    mainPath := a.metrics.MainNetworkPath
    backupPath := a.metrics.BackupNetworkPath
    
    if len(mainPath) == 0 || len(backupPath) == 0 {
        return
    }
    
    // Paylaşılan hop'ları say
    shared := 0
    a.metrics.SharedHops = []string{}
    
    for _, mainHop := range mainPath {
        for _, backupHop := range backupPath {
            if mainHop == backupHop {
                shared++
                a.metrics.SharedHops = append(a.metrics.SharedHops, mainHop)
            }
        }
    }
    
    // Çeşitlilik yüzdesini hesapla
    totalHops := len(mainPath) + len(backupPath)
    diversity := 1.0 - (float64(shared*2) / float64(totalHops))
    a.metrics.PathDiversity = diversity
    
    if diversity < MinPathDiversity {
        fmt.Printf("DÜŞÜK YOL ÇEŞİTLİLİĞİ: %.1f%% (min: %.1f%%)\n",
            diversity*100, MinPathDiversity*100)
        fmt.Printf("Paylaşılan hop'lar: %v\n", a.metrics.SharedHops)
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

# alerts/st2022_7.yml
groups:
  - name: smpte_2022_7
    interval: 1s
    rules:
      # Her iki stream de çöktü = felaket
      - alert: ST2022_7_BothStreamsDown
        expr: st2110_st2022_7_both_streams_healthy == 0
        for: 1s
        labels:
          severity: critical
          page: "true"
        annotations:
          summary: "FELAKET: {{ $labels.stream_id }} üzerinde her iki ST 2022-7 stream de çöktü"
          description: "Ana VE yedek stream'ler çevrimdışı - TAM BAŞARISIZLIK"
      
      # Yedek stream çöktü (koruma yok!)
      - alert: ST2022_7_BackupStreamDown
        expr: st2110_st2022_7_backup_stream_active == 0
        for: 30s
        labels:
          severity: warning
        annotations:
          summary: "{{ $labels.stream_id }} üzerinde ST 2022-7 yedek stream çöktü"
          description: "Ana stream başarısız olursa koruma mevcut değil!"
      
      # Aşırı geçiş (ağ dengesizliği)
      - alert: ST2022_7_ExcessiveSwitching
        expr: rate(st2110_st2022_7_switching_events[5m]) > 0.1
        labels:
          severity: warning
        annotations:
          summary: "{{ $labels.stream_id }} üzerinde aşırı ST 2022-7 geçişi"
          description: "Saniyede {{ $value }} geçiş - ağ dengesizliğini gösteriyor"
      
      # Yavaş geçiş (> 100ms)
      - alert: ST2022_7_SlowSwitch
        expr: st2110_st2022_7_last_switch_duration_ms > 100
        labels:
          severity: warning
        annotations:
          summary: "{{ $labels.stream_id }} üzerinde yavaş ST 2022-7 geçişi"
          description: "Geçiş {{ $value }}ms sürdü (maks: 100ms)"
      
      # Düşük yol çeşitliliği (tek arıza noktası)
      - alert: ST2022_7_LowPathDiversity
        expr: st2110_st2022_7_path_diversity < 0.5
        for: 1m
        labels:
          severity: warning
        annotations:
          summary: "{{ $labels.stream_id }} üzerinde düşük yol çeşitliliği"
          description: "Sadece {{ $value | humanizePercentage }} yol çeşitliliği"
      
      # Zamanlama offset çok yüksek
      - alert: ST2022_7_TimingOffset
        expr: abs(st2110_st2022_7_stream_timing_offset_ms) > 1
        for: 10s
        labels:
          severity: warning
        annotations:
          summary: "ST 2022-7 stream'leri arasında yüksek zamanlama offset'i"
          description: "Offset: {{ $value }}ms (maks: 1ms)"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// Ancillary data metrikleri
type AncillaryDataMetrics struct {
    // Mevcut data tipleri
    ClosedCaptionsPresent bool
    TimecodePresent       bool
    AFDPresent            bool    // Active Format Description
    VITCPresent           bool    // Vertical Interval Timecode
    
    // Closed captions (CEA-608/708)
    CCPacketsReceived     uint64
    CCPacketsLost         uint64
    CCLossRate            float64
    LastCCTimestamp       time.Time
    CCGaps                uint64   // > 1 saniye boşluklar
    
    // Timecode takibi
    Timecode              string   // HH:MM:SS:FF
    TimecodeJumps         uint64   // Süreksizlikler
    TimecodeDropFrame     bool
    TimecodeFrameRate     float64
    
    // AFD (aspect ratio signaling)
    AFDCode               uint8    // 0-15
    AFDChanged            uint64   // AFD kaç kez değişti
    
    // SCTE-104 (reklam ekleme tetikleyicileri)
    SCTE104Present        bool
    AdInsertionTriggers   uint64
}

// Ancillary izleme neden önemli
const (
    MaxCCGapMs = 1000  // CC olmadan 1 saniye = uyumluluk ihlali (FCC)
)

1
2
3
4
5
6
7

Olay: Canlı haber sırasında 2 dakika closed caption kaybı

Kök Neden: ST 2110-40 ancillary stream'de %0.5 paket kaybı
Video/Audio: Mükemmel (%0.001 kayıp)
Sonuç: RTÜK cezası + izleyici şikayetleri

Ders: Ancillary data'yı ayrı izleyin!

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101