From 03b2f1582d4935e5c82f1ad8bb540b4d8a0f3fac Mon Sep 17 00:00:00 2001
From: vivekchavan14 <vivekchavan382@gmail.com>
Date: Thu, 12 Mar 2026 07:24:03 +0530
Subject: [PATCH] Added audio level analysis

---
 index.html                 |  71 +++++----
 internal/audio/analyzer.go | 309 +++++++++++++++++++++++++++++++++++++
 internal/h264/analyzer.go  |   2 +
 internal/webrtc/webrtc.go  |   4 +
 internal/webrtc/whip.go    |  37 ++++-
 5 files changed, 388 insertions(+), 35 deletions(-)
 create mode 100644 internal/audio/analyzer.go

diff --git a/index.html b/index.html
index e74353e..49142d6 100644
--- a/index.html
+++ b/index.html
@@ -175,7 +175,8 @@
       }
 
       .shell.analysis-started .analysis-panel {
-        max-height: 1400px;
+        max-height: 5000px;
+        overflow: visible;
         opacity: 1;
         transform: translateY(0);
         padding-top: 32px;
@@ -359,13 +360,14 @@
       <main class="panel setup-panel">
         <h1>Stream Sniff</h1>
         <p>
-          Stream Sniff analyzes your streaming video so you can get the best quality possible. It inspects what you send
-          and explains, in plain language, how it could be better.
+          Stream Sniff analyzes your streaming video and audio so you can get the best quality possible. It inspects
+          what you send and explains, in plain language, how it could be better.
         </p>
 
         <ul>
           <li>See whether your video looks overly compressed.</li>
           <li>Check the resolution and H.264 profile you are sending.</li>
+          <li>Check audio levels, clipping, and silence detection.</li>
           <li>Get practical recommendations and the trade-offs behind them.</li>
         </ul>
 
@@ -402,9 +404,14 @@ <h2 class="recommendations-title">Recommendations</h2>
         <ul id="recommendations-list" class="recommendations-list"></ul>
 
         <div class="analysis-header">
-          <h2 id="analysis-heading">Analysis</h2>
+          <h2>Video</h2>
         </div>
-        <ul id="analysis-list" class="analysis-list"></ul>
+        <ul id="video-analysis-list" class="analysis-list"></ul>
+
+        <div class="analysis-header">
+          <h2>Audio</h2>
+        </div>
+        <ul id="audio-analysis-list" class="analysis-list"></ul>
       </section>
     </div>
     <footer class="site-footer">
@@ -420,11 +427,14 @@ <h2 id="analysis-heading">Analysis</h2>
       const bearerTokenInput = document.getElementById("bearer-token");
       const copyButton = document.getElementById("copy-button");
       const setupToggle = document.getElementById("setup-toggle");
-      const analysisHeading = document.getElementById("analysis-heading");
       const status = document.getElementById("status");
-      const analysisList = document.getElementById("analysis-list");
+      const videoAnalysisList = document.getElementById("video-analysis-list");
+      const audioAnalysisList = document.getElementById("audio-analysis-list");
       const recommendationsList = document.getElementById("recommendations-list");
-      const analysesById = new Map();
+      const videoAnalysesById = new Map();
+      const audioAnalysesById = new Map();
+      let videoRecommendations = {};
+      let audioRecommendations = {};
 
       function randomChunk() {
         return Math.random().toString(36).slice(2, 7);
@@ -438,14 +448,10 @@ <h2 id="analysis-heading">Analysis</h2>
         status.textContent = message;
       }
 
-      function renderAnalyses() {
-        analysisList.textContent = "";
-
-        if (analysesById.size === 0) {
-          return;
-        }
+      function renderAnalysisList(listElement, analysesMap) {
+        listElement.textContent = "";
 
-        for (const analysis of analysesById.values()) {
+        for (const analysis of analysesMap.values()) {
           const item = document.createElement("li");
           item.className = "analysis-item";
 
@@ -462,35 +468,45 @@ <h2 id="analysis-heading">Analysis</h2>
 
           item.appendChild(idElement);
           item.appendChild(messageElement);
-          analysisList.appendChild(item);
+          listElement.appendChild(item);
         }
       }
 
-      function renderRecommendations(recommendations) {
+      function renderRecommendations() {
         recommendationsList.textContent = "";
+        const merged = Object.assign({}, videoRecommendations, audioRecommendations);
 
-        for (const id of Object.keys(recommendations)) {
-          if (recommendations[id].length === 0) {
+        for (const id of Object.keys(merged)) {
+          if (merged[id].length === 0) {
             continue;
           }
 
           const item = document.createElement("li");
-          item.textContent = recommendations[id];
+          item.textContent = merged[id];
           recommendationsList.appendChild(item);
         }
       }
 
       function applyAnalyses(payload) {
-        analysesById.clear();
+        const isAudio = payload.type === "audio";
+        const analysesMap = isAudio ? audioAnalysesById : videoAnalysesById;
+        const listElement = isAudio ? audioAnalysisList : videoAnalysisList;
 
+        analysesMap.clear();
         for (const analysis of payload.analyses || []) {
-          analysesById.set(analysis.id, { id: analysis.id, label: analysis.label, message: analysis.message, color: analysis.color });
+          analysesMap.set(analysis.id, { id: analysis.id, label: analysis.label, message: analysis.message, color: analysis.color });
+        }
+
+        if (isAudio) {
+          audioRecommendations = payload.recommendations || {};
+        } else {
+          videoRecommendations = payload.recommendations || {};
         }
 
-        renderRecommendations(payload.recommendations || {});
-        renderAnalyses();
+        renderRecommendations();
+        renderAnalysisList(listElement, analysesMap);
 
-        if (analysesById.size > 0 || Object.keys(payload.recommendations || {}).length > 0) {
+        if (analysesMap.size > 0 || Object.keys(payload.recommendations || {}).length > 0) {
           shell.classList.add("analysis-started");
           updateSetupToggleLabel();
         }
@@ -500,10 +516,6 @@ <h2 id="analysis-heading">Analysis</h2>
         setupToggle.textContent = shell.classList.contains("setup-open") ? "Hide Setup" : "Show Setup";
       }
 
-      function updateAnalysisHeading() {
-        analysisHeading.textContent = `Analysis of ${bearerTokenInput.value}`;
-      }
-
       async function createPeerConnection() {
         const peerConnection = new RTCPeerConnection();
         const analyzeDataChannel = peerConnection.createDataChannel("analyze");
@@ -543,7 +555,6 @@ <h2 id="analysis-heading">Analysis</h2>
         return bearerToken && bearerToken.trim().length > 0 ? bearerToken : generateBearerToken();
       })();
       setStatus("");
-      updateAnalysisHeading();
       createPeerConnection();
     </script>
   </body>
diff --git a/internal/audio/analyzer.go b/internal/audio/analyzer.go
new file mode 100644
index 0000000..cceeb67
--- /dev/null
+++ b/internal/audio/analyzer.go
@@ -0,0 +1,309 @@
+package audio
+
+import (
+	"encoding/json"
+	"fmt"
+	"math"
+	"time"
+
+	"github.com/pion/rtp"
+)
+
+type analysisItem struct {
+	ID      string `json:"id"`
+	Label   string `json:"label"`
+	Message string `json:"message"`
+	Color   string `json:"color,omitempty"`
+}
+
+type payload struct {
+	Type            string            `json:"type"`
+	Analyses        []analysisItem    `json:"analyses"`
+	Recommendations map[string]string `json:"recommendations"`
+}
+
+type snapshot struct {
+	rmsDBFS  float64
+	peakDBFS float64
+}
+
+const (
+	dbfsFloor             = -96.0
+	clipThresh            = 0.99
+	silenceDBFS           = -60.0
+	audioLevelExtensionID = 1
+)
+
+type Analyzer struct {
+	windowSize int
+
+	snapshots []snapshot
+	snapCount int
+	snapIdx   int
+
+	sumSquares float64
+	peakAbs    float64
+	samples    int
+
+	clippingSamples int
+	silentSnapshots int
+
+	started        bool
+	trackStartedAt time.Time
+	lastEmissionAt time.Time
+}
+
+func NewAnalyzer(windowSeconds int) *Analyzer {
+	if windowSeconds < 1 {
+		windowSeconds = 5
+	}
+	return &Analyzer{
+		windowSize: windowSeconds,
+		snapshots:  make([]snapshot, windowSeconds),
+	}
+}
+
+func toDBFS(linear float64) float64 {
+	if linear <= 0 {
+		return dbfsFloor
+	}
+	db := 20 * math.Log10(linear)
+	if db < dbfsFloor {
+		return dbfsFloor
+	}
+	return db
+}
+
+func formatDBFS(db float64) string {
+	if db <= dbfsFloor {
+		return fmt.Sprintf("%.1f dBFS (silence)", db)
+	}
+	return fmt.Sprintf("%.1f dBFS", db)
+}
+
+func colorForRMS(db float64) string {
+	switch {
+	case db > -3:
+		return "rgba(239, 68, 68, 0.22)"
+	case db > -6:
+		return "rgba(249, 115, 22, 0.22)"
+	case db > -24:
+		return "rgba(34, 197, 94, 0.22)"
+	case db > silenceDBFS:
+		return "rgba(250, 204, 21, 0.22)"
+	default:
+		return "rgba(239, 68, 68, 0.22)"
+	}
+}
+
+func colorForPeak(db float64) string {
+	switch {
+	case db > -1:
+		return "rgba(239, 68, 68, 0.22)"
+	case db > -3:
+		return "rgba(249, 115, 22, 0.22)"
+	default:
+		return "rgba(34, 197, 94, 0.22)"
+	}
+}
+
+func colorForClipping(count int) string {
+	if count > 0 {
+		return "rgba(239, 68, 68, 0.22)"
+	}
+	return "rgba(34, 197, 94, 0.22)"
+}
+
+func (a *Analyzer) WriteRTP(packet *rtp.Packet) []byte {
+	if packet == nil {
+		return nil
+	}
+
+	now := time.Now()
+	if !a.started {
+		a.started = true
+		a.trackStartedAt = now
+		a.lastEmissionAt = now
+	}
+
+	var linear float64
+	if ext := packet.GetExtension(audioLevelExtensionID); len(ext) >= 1 {
+		level := ext[0] & 0x7F
+		dbov := -float64(level)
+		linear = math.Pow(10, dbov/20.0)
+	} else {
+		energy := float64(len(packet.Payload)) / 200.0
+		if energy > 1.0 {
+			energy = 1.0
+		}
+		linear = energy * 0.1
+	}
+
+	a.sumSquares += linear * linear
+	abs := math.Abs(linear)
+	if abs > a.peakAbs {
+		a.peakAbs = abs
+	}
+	if abs >= clipThresh {
+		a.clippingSamples++
+	}
+	a.samples++
+
+	if now.Sub(a.lastEmissionAt) < time.Second {
+		return nil
+	}
+
+	var snap snapshot
+	if a.samples > 0 {
+		rms := math.Sqrt(a.sumSquares / float64(a.samples))
+		snap.rmsDBFS = toDBFS(rms)
+		snap.peakDBFS = toDBFS(a.peakAbs)
+	} else {
+		snap.rmsDBFS = dbfsFloor
+		snap.peakDBFS = dbfsFloor
+	}
+
+	if snap.rmsDBFS <= silenceDBFS {
+		a.silentSnapshots++
+	}
+
+	a.snapshots[a.snapIdx] = snap
+	a.snapIdx = (a.snapIdx + 1) % a.windowSize
+	if a.snapCount < a.windowSize {
+		a.snapCount++
+	}
+
+	a.sumSquares = 0
+	a.peakAbs = 0
+	a.samples = 0
+	a.lastEmissionAt = now
+
+	return a.buildPayload(snap)
+}
+
+func (a *Analyzer) buildPayload(current snapshot) []byte {
+	p := payload{
+		Type:            "audio",
+		Analyses:        []analysisItem{},
+		Recommendations: map[string]string{},
+	}
+
+	p.Analyses = append(p.Analyses, analysisItem{
+		ID:      "rms_level",
+		Label:   "RMS Level",
+		Message: formatDBFS(current.rmsDBFS),
+		Color:   colorForRMS(current.rmsDBFS),
+	})
+
+	p.Analyses = append(p.Analyses, analysisItem{
+		ID:      "peak_level",
+		Label:   "Peak Level",
+		Message: formatDBFS(current.peakDBFS),
+		Color:   colorForPeak(current.peakDBFS),
+	})
+
+	if a.snapCount > 0 {
+		minRMS := math.MaxFloat64
+		maxRMS := -math.MaxFloat64
+		sumRMS := 0.0
+		maxPeak := -math.MaxFloat64
+
+		for i := 0; i < a.snapCount; i++ {
+			s := a.snapshots[i]
+			if s.rmsDBFS < minRMS {
+				minRMS = s.rmsDBFS
+			}
+			if s.rmsDBFS > maxRMS {
+				maxRMS = s.rmsDBFS
+			}
+			sumRMS += s.rmsDBFS
+			if s.peakDBFS > maxPeak {
+				maxPeak = s.peakDBFS
+			}
+		}
+		avgRMS := sumRMS / float64(a.snapCount)
+
+		windowLabel := fmt.Sprintf("%ds", a.windowSize)
+
+		p.Analyses = append(p.Analyses,
+			analysisItem{
+				ID:      "window_avg",
+				Label:   "Avg RMS (" + windowLabel + " window)",
+				Message: formatDBFS(avgRMS),
+				Color:   colorForRMS(avgRMS),
+			},
+			analysisItem{
+				ID:      "window_min",
+				Label:   "Min RMS (" + windowLabel + " window)",
+				Message: formatDBFS(minRMS),
+			},
+			analysisItem{
+				ID:      "window_max",
+				Label:   "Max RMS (" + windowLabel + " window)",
+				Message: formatDBFS(maxRMS),
+			},
+			analysisItem{
+				ID:      "window_peak",
+				Label:   "Peak (" + windowLabel + " window)",
+				Message: formatDBFS(maxPeak),
+				Color:   colorForPeak(maxPeak),
+			},
+		)
+	}
+
+	clippingMsg := "None detected"
+	if a.clippingSamples > 0 {
+		clippingMsg = fmt.Sprintf("%d samples clipped", a.clippingSamples)
+	}
+	p.Analyses = append(p.Analyses, analysisItem{
+		ID:      "clipping",
+		Label:   "Clipping",
+		Message: clippingMsg,
+		Color:   colorForClipping(a.clippingSamples),
+	})
+
+	elapsed := time.Since(a.trackStartedAt).Seconds()
+	if elapsed >= 2 {
+		totalSnaps := int(elapsed)
+		if totalSnaps > 0 {
+			silencePct := float64(a.silentSnapshots) / float64(totalSnaps) * 100
+			silenceMsg := fmt.Sprintf("%.0f%%", silencePct)
+			silenceColor := "rgba(34, 197, 94, 0.22)"
+			if silencePct > 50 {
+				silenceColor = "rgba(239, 68, 68, 0.22)"
+			} else if silencePct > 20 {
+				silenceColor = "rgba(250, 204, 21, 0.22)"
+			}
+			p.Analyses = append(p.Analyses, analysisItem{
+				ID:      "silence",
+				Label:   "Silence",
+				Message: silenceMsg,
+				Color:   silenceColor,
+			})
+		}
+	}
+
+	if current.rmsDBFS > -3 {
+		p.Recommendations["rec_hot"] = "Audio levels are very hot (above -3 dBFS). Reduce input gain to avoid distortion."
+	} else if current.rmsDBFS > -6 {
+		p.Recommendations["rec_warm"] = "Audio levels are approaching hot. Consider reducing input gain slightly."
+	}
+
+	if a.clippingSamples > 0 {
+		p.Recommendations["rec_clipping"] = "Clipping detected. Reduce your input gain or add a limiter."
+	}
+
+	if elapsed >= 5 && current.rmsDBFS <= silenceDBFS {
+		p.Recommendations["rec_silence"] = "Audio appears silent. Check that your microphone is unmuted and input gain is turned up."
+	}
+
+	if elapsed >= 5 && current.rmsDBFS > silenceDBFS && current.rmsDBFS <= -36 {
+		p.Recommendations["rec_low"] = "Audio level is very low. Increase your input gain for better signal quality."
+	}
+
+	message, err := json.Marshal(p)
+	if err != nil {
+		return nil
+	}
+	return message
+}
diff --git a/internal/h264/analyzer.go b/internal/h264/analyzer.go
index 7915ce1..9810ac4 100644
--- a/internal/h264/analyzer.go
+++ b/internal/h264/analyzer.go
@@ -17,6 +17,7 @@ type analysisItem struct {
 }
 
 type payload struct {
+	Type            string            `json:"type"`
 	Analyses        []analysisItem    `json:"analyses"`
 	Recommendations map[string]string `json:"recommendations"`
 }
@@ -214,6 +215,7 @@ func (a *Analyzer) WriteRTP(packet *rtp.Packet) []byte {
 
 func (a *Analyzer) items(now time.Time) payload {
 	state := payload{
+		Type:            "video",
 		Analyses:        []analysisItem{},
 		Recommendations: map[string]string{},
 	}
diff --git a/internal/webrtc/webrtc.go b/internal/webrtc/webrtc.go
index bb097c3..19087be 100644
--- a/internal/webrtc/webrtc.go
+++ b/internal/webrtc/webrtc.go
@@ -175,6 +175,10 @@ func PopulateMediaEngine(m *webrtc.MediaEngine) error {
 		}
 	}
 
+	if err := m.RegisterHeaderExtension(webrtc.RTPHeaderExtensionCapability{URI: "urn:ietf:params:rtp-hdrext:ssrc-audio-level"}, webrtc.RTPCodecTypeAudio); err != nil {
+		return err
+	}
+
 	for _, codecDetails := range []struct {
 		payloadType uint8
 		mimeType    string
diff --git a/internal/webrtc/whip.go b/internal/webrtc/whip.go
index a91f966..9b74317 100644
--- a/internal/webrtc/whip.go
+++ b/internal/webrtc/whip.go
@@ -4,18 +4,40 @@ import (
 	"errors"
 	"io"
 	"log"
+	"os"
+	"strconv"
 
+	"stream-sniff/internal/audio"
 	"stream-sniff/internal/h264"
 
 	"github.com/pion/webrtc/v4"
 )
 
-func readAndLogRTP(bearerToken, sessionID string, remoteTrack *webrtc.TrackRemote) {
-	if remoteTrack.Codec().MimeType != webrtc.MimeTypeH264 {
-		return
+func readAndLogVideoRTP(bearerToken, sessionID string, remoteTrack *webrtc.TrackRemote) {
+	analyzer := h264.NewAnalyzer()
+	for {
+		packet, _, err := remoteTrack.ReadRTP()
+		switch {
+		case errors.Is(err, io.EOF):
+			return
+		case err != nil:
+			log.Printf("bearerToken=%s session=%s track-end kind=%s err=%v", bearerToken, sessionID, remoteTrack.Kind().String(), err)
+			return
+		}
+
+		writeAnalyzeMessage(bearerToken, analyzer.WriteRTP(packet))
+	}
+}
+
+func readAndLogAudioRTP(bearerToken, sessionID string, remoteTrack *webrtc.TrackRemote) {
+	windowSeconds := 5
+	if v := os.Getenv("ANALYSIS_WINDOW_SECONDS"); v != "" {
+		if parsed, err := strconv.Atoi(v); err == nil && parsed > 0 {
+			windowSeconds = parsed
+		}
 	}
 
-	analyzer := h264.NewAnalyzer()
+	analyzer := audio.NewAnalyzer(windowSeconds)
 	for {
 		packet, _, err := remoteTrack.ReadRTP()
 		switch {
@@ -33,7 +55,12 @@ func readAndLogRTP(bearerToken, sessionID string, remoteTrack *webrtc.TrackRemot
 func WHIP(offer, bearerToken string) (string, error) {
 	return negotiateOffer(offer, bearerToken, func(peerConnection *webrtc.PeerConnection, bearerToken, sessionID string) {
 		peerConnection.OnTrack(func(remoteTrack *webrtc.TrackRemote, _ *webrtc.RTPReceiver) {
-			go readAndLogRTP(bearerToken, sessionID, remoteTrack)
+			switch remoteTrack.Codec().MimeType {
+			case webrtc.MimeTypeH264:
+				go readAndLogVideoRTP(bearerToken, sessionID, remoteTrack)
+			case webrtc.MimeTypeOpus:
+				go readAndLogAudioRTP(bearerToken, sessionID, remoteTrack)
+			}
 		})
 	})
 }