Update app.py

app.py

@@ -1,3 +1,7 @@
+# ============================================================
+# app.py  (Updated Full Version — Chunk 1: Lines 1–300)
+# ============================================================
+
 import gradio as gr
 import sys
 from pathlib import Path
@@ -23,6 +27,7 @@ except ImportError:
 # ==================== ANALYSIS FUNCTIONS ====================
 
 def read_audio_info(path):
+    """Read audio file metadata"""
     info = sf.info(path)
     return {
         "samplerate": int(info.samplerate),
@@ -35,18 +40,19 @@ def read_audio_info(path):
 
 
 def compute_time_domain_stats(y):
+    """Calculate time-domain statistics"""
     peak = float(np.max(np.abs(y)))
-    rms = float(np.sqrt(np.mean(y**2)))
-    
+    rms = float(np.sqrt(np.mean(y ** 2)))
+
     peak_db = 20 * np.log10(max(peak, 1e-12))
     rms_db = 20 * np.log10(max(rms, 1e-12))
     crest_factor = peak_db - rms_db
-    
+
     abs_y = np.abs(y)
     noise_floor = float(np.percentile(abs_y, 10))
     snr_est = 20 * np.log10(max(rms, 1e-12) / max(noise_floor, 1e-12))
     zcr = float(np.mean(librosa.feature.zero_crossing_rate(y)))
-    
+
     return {
         "peak": peak,
         "rms": rms,
@@ -59,76 +65,90 @@ def compute_time_domain_stats(y):
     }
 
 
-def compute_spectral_analysis(y, sr, n_fft=8192):
+# ============================================================
+# UPDATED SPECTRAL ANALYSIS FUNCTION (FFT=4096, 90th percentile)
+# ============================================================
+
+def compute_spectral_analysis(y, sr, n_fft=4096):
+    """Comprehensive spectral analysis tuned for speech QC"""
+
     hop_length = n_fft // 4
 
     # STFT
-    S = np.abs(librosa.stft(y, n_fft=n_fft, hop_length=hop_length, window='hann'))
-    freqs = np.linspace(0, sr/2, S.shape[0])
+    S = np.abs(librosa.stft(y, n_fft=n_fft, hop_length=hop_length, window="hann"))
+    freqs = np.linspace(0, sr / 2, S.shape[0])
 
-    # dB matrix
+    # Convert amplitude to dB
     S_db = librosa.amplitude_to_db(S, ref=np.max)
 
-    # ===== HYBRID FIX: Percentile-Based Energy =====
-    S_power = S**2
-    energy = np.percentile(S_power, 75, axis=1) + 1e-20
+    # ===== UPDATED ENERGY ESTIMATE: 90th percentile of power =====
+    S_power = S ** 2
+    energy = np.percentile(S_power, 90, axis=1) + 1e-20
     total_energy = float(np.sum(energy))
-
     cum_energy = np.cumsum(energy)
+
+    # Rolloffs
     roll85_idx = np.searchsorted(cum_energy, 0.85 * total_energy)
     roll95_idx = np.searchsorted(cum_energy, 0.95 * total_energy)
-    freq_at_85 = float(freqs[min(roll85_idx, len(freqs)-1)])
-    freq_at_95 = float(freqs[min(roll95_idx, len(freqs)-1)])
 
-    # ===== HYBRID FIX: 90th percentile dB (instead of mean) =====
+    freq_at_85 = float(freqs[min(roll85_idx, len(freqs) - 1)])
+    freq_at_95 = float(freqs[min(roll95_idx, len(freqs) - 1)])
+
+    # ===== UPDATED HF ENVELOPE: 90th percentile of dB =====
     mean_db_per_bin = np.percentile(S_db, 90, axis=1)
 
     peak_db = float(np.max(S_db))
-    threshold_db = peak_db - 60.0
+    threshold_db = peak_db - 60
+
     non_silent_bins = np.where(mean_db_per_bin > threshold_db)[0]
     highest_freq = float(freqs[non_silent_bins[-1]]) if non_silent_bins.size else 0.0
 
-    # Energy band functions
-    def energy_above(f):
-        idx = np.searchsorted(freqs, f)
-        return float(100.0 * np.sum(energy[idx:]) / total_energy)
+    # ===================== UPDATED SPEECH-CENTRIC BANDS =====================
+    def band_energy(low, high):
+        i1 = np.searchsorted(freqs, low)
+        i2 = np.searchsorted(freqs, high)
+        return float(100 * np.sum(energy[i1:i2]) / total_energy)
 
-    def energy_below(f):
+    def band_energy_above(f):
         idx = np.searchsorted(freqs, f)
-        return float(100.0 * np.sum(energy[:idx]) / total_energy)
+        return float(100 * np.sum(energy[idx:]) / total_energy)
 
     energy_stats = {
-        "below_100hz": energy_below(100),
-        "below_200hz": energy_below(200),
-        "100_500hz": energy_below(500) - energy_below(100),
-        "500_2khz": energy_below(2000) - energy_below(500),
-        "2k_8khz": energy_below(8000) - energy_below(2000),
-        "above_8khz": energy_above(8000),
-        "above_12khz": energy_above(12000),
-        "above_16khz": energy_above(16000),
+        "below_100hz": band_energy(0, 100),
+        "100_500hz": band_energy(100, 500),
+        "500_2khz": band_energy(500, 2000),
+        "2k_8khz": band_energy(2000, 8000),
+        "8k_12khz": band_energy(8000, 12000),
+        "12k_16khz": band_energy(12000, 16000),
+        "above_16khz": band_energy_above(16000)
     }
 
-    # Brick-wall detection using new percentile spectrum
+    # Brickwall detection
     diffs = np.diff(mean_db_per_bin)
-    big_drop_idx = np.where(diffs < -20.0)[0]
+    big_drop_idx = np.where(diffs < -20)[0]
     brick_wall = bool(big_drop_idx.size)
     brick_freq = float(freqs[big_drop_idx[0]]) if big_drop_idx.size else None
 
-    # Spectral notches (unchanged, but uses new mean_db_per_bin)
+    # Spectral notches
     smooth = sps.medfilt(mean_db_per_bin, kernel_size=9)
     minima = sps.argrelextrema(smooth, np.less)[0]
     notches = []
+
     for m in minima:
-        left = smooth[max(0, m-6):m]
-        right = smooth[m+1:min(len(smooth), m+7)]
-        neighbors_peak = max(
+        left = smooth[max(0, m - 6):m]
+        right = smooth[m + 1:min(len(smooth), m + 7)]
+        neighbor_peak = max(
             left.max() if left.size else -999,
             right.max() if right.size else -999
         )
-        depth = neighbors_peak - smooth[m]
-        if depth >= 15.0 and freqs[m] > 100:
-            notches.append({"freq": float(freqs[m]), "depth_db": float(depth)})
-
+        depth = neighbor_peak - smooth[m]
+        if depth >= 15 and freqs[m] > 100:
+            notches.append({
+                "freq": float(freqs[m]),
+                "depth_db": float(depth)
+            })
+
+    # Additional spectral stats
     centroid = float(np.mean(librosa.feature.spectral_centroid(S=S, sr=sr)))
     bandwidth = float(np.mean(librosa.feature.spectral_bandwidth(S=S, sr=sr)))
     flatness = float(np.mean(librosa.feature.spectral_flatness(S=S)))
@@ -149,139 +169,182 @@ def compute_spectral_analysis(y, sr, n_fft=8192):
         "spectral_centroid": centroid,
         "spectral_bandwidth": bandwidth,
         "spectral_flatness": flatness,
-        "spectral_rolloff": rolloff,
+        "spectral_rolloff": rolloff
     }
-
-
-def compute_loudness(y, sr):
-    if not LOUDNESS_AVAILABLE:
-        return None
-    try:
-        meter = pyln.Meter(sr)
-        loudness = float(meter.integrated_loudness(y))
-        return loudness
-    except Exception:
-        return None
-
+# ============================================================
+# UPDATED ISSUE DETECTION (HF thresholds corrected)
+# ============================================================
 
 def detect_audio_issues(spectral, time_stats):
+    """Detect common audio processing artifacts"""
     issues = []
     energy = spectral["energy_distribution"]
-    
-    if energy["below_200hz"] < 2.0:
-        issues.append(("HIGH_PASS_FILTER", "HIGH", 
-                      f"Very low energy below 200Hz ({energy['below_200hz']:.2f}%). Likely HPF applied."))
-    elif energy["below_200hz"] < 5.0:
-        issues.append(("HIGH_PASS_FILTER", "MEDIUM", 
-                      f"Low energy below 200Hz ({energy['below_200hz']:.2f}%). Possible mild HPF."))
-
-    if energy["above_12khz"] < 0.2 and spectral["highest_freq_minus60db"] < 12000:
-        issues.append(("HF_LOSS", "HIGH", 
-                      f"Severe HF loss. Only {energy['above_12khz']:.3f}% above 12kHz."))
-    elif energy["above_12khz"] < 1.0:
-        issues.append(("HF_LOSS", "MEDIUM", 
-                      f"Reduced HF content ({energy['above_12khz']:.2f}% above 12kHz)."))
 
-    if spectral["brick_wall_detected"]:
-        issues.append(("BRICK_WALL", "HIGH", 
-                      f"Brick-wall filter at {spectral['brick_wall_freq']:.0f}Hz."))
+    # High-pass detection
+    if energy["below_100hz"] < 0.5:
+        issues.append(("HIGH_PASS_FILTER", "HIGH",
+                       f"Very low energy <100Hz ({energy['below_100hz']:.2f}%). Possible HPF."))
 
-    if len(spectral["spectral_notches"]) > 0:
-        issues.append(("SPECTRAL_NOTCHES", "MEDIUM", 
-                      f"{len(spectral['spectral_notches'])} spectral notches detected."))
+    # Updated HF-loss rules (speech-appropriate)
+    if energy["8k_12khz"] < 0.05 and spectral["highest_freq_minus60db"] < 8000:
+        issues.append(("HF_LOSS", "HIGH",
+                       f"Severe HF loss. Only {energy['8k_12khz']:.3f}% in 8–12kHz."))
+
+    elif energy["8k_12khz"] < 0.3:
+        issues.append(("HF_LOSS", "MEDIUM",
+                       f"Reduced HF content ({energy['8k_12khz']:.3f}% in 8–12kHz)."))
 
-    if time_stats["crest_factor_db"] < 3.0:
-        issues.append(("OVER_COMPRESSION", "HIGH", 
-                      f"Very low crest factor ({time_stats['crest_factor_db']:.1f}dB). Heavy compression."))
-    elif time_stats["crest_factor_db"] < 6.0:
-        issues.append(("COMPRESSION", "MEDIUM", 
-                      f"Low crest factor ({time_stats['crest_factor_db']:.1f}dB). Moderate compression."))
+    # Brickwall filter
+    if spectral["brick_wall_detected"]:
+        issues.append(("BRICK_WALL", "HIGH",
+                       f"Possible brick-wall at {spectral['brick_wall_freq']:.0f} Hz"))
 
+    # Spectral notches
+    if len(spectral["spectral_notches"]) > 0:
+        issues.append(("SPECTRAL_NOTCHES", "MEDIUM",
+                       f"{len(spectral['spectral_notches'])} spectral notches detected."))
+
+    # Compression
+    if time_stats["crest_factor_db"] < 3:
+        issues.append(("OVER_COMPRESSION", "HIGH",
+                       f"Very low crest factor {time_stats['crest_factor_db']:.1f} dB"))
+    elif time_stats["crest_factor_db"] < 6:
+        issues.append(("COMPRESSION", "MEDIUM",
+                       f"Low crest factor {time_stats['crest_factor_db']:.1f} dB"))
+
+    # Clipping
     if time_stats["peak"] >= 0.999:
-        issues.append(("CLIPPING", "CRITICAL", 
-                      f"Peak at {time_stats['peak']:.6f}. Possible digital clipping!"))
+        issues.append(("CLIPPING", "CRITICAL",
+                       f"Peak amplitude {time_stats['peak']:.6f}. Possible clipping."))
 
     return issues
 
+
+# ============================================================
+# REPORT GENERATION
+# ============================================================
+
 def create_report(audio_data, output_path):
     """Create comprehensive PNG report"""
-    
-    plt.style.use('default')
-    fig = plt.figure(figsize=(22, 14))
-    fig.patch.set_facecolor('white')
-    
-    fig.suptitle(f'AUDIO FORENSIC ANALYSIS REPORT\n{audio_data["filename"]}', 
-                 fontsize=20, fontweight='bold', y=0.97)
-    
-    gs = gridspec.GridSpec(4, 4, figure=fig, hspace=0.4, wspace=0.4,
-                          height_ratios=[1.5, 1, 0.8, 0.9],
-                          left=0.05, right=0.95, top=0.92, bottom=0.05)
-    
-    # SPECTROGRAM
+
+    plt.style.use("default")
+
+    # UPDATED FIGURE SIZE
+    fig = plt.figure(figsize=(22, 16))
+    fig.patch.set_facecolor("white")
+
+    fig.suptitle(
+        f"AUDIO FORENSIC ANALYSIS REPORT\n{audio_data['filename']}",
+        fontsize=20,
+        fontweight="bold",
+        y=0.97
+    )
+
+    gs = gridspec.GridSpec(
+        4, 4,
+        figure=fig,
+        hspace=0.4,
+        wspace=0.4,
+        height_ratios=[1.5, 1, 0.8, 0.9],
+        left=0.05,
+        right=0.95,
+        top=0.92,
+        bottom=0.05
+    )
+
+    # ============================
+    # SPECTROGRAM PLOT (UPDATED)
+    # ============================
+
     ax_spec = fig.add_subplot(gs[0, :])
-    S_db = audio_data['spectral']['S_db']
-    sr = audio_data['info']['samplerate']
-    hop = audio_data['spectral']['hop_length']
-    
+
+    S_db = audio_data["spectral"]["S_db"]
+    sr = audio_data["info"]["samplerate"]
+    hop = audio_data["spectral"]["hop_length"]
+
     img = librosa.display.specshow(
-        S_db, sr=sr, hop_length=hop,
-        x_axis='time', y_axis='hz',
-        cmap='viridis', ax=ax_spec, vmin=-80, vmax=0
+        S_db,
+        sr=sr,
+        hop_length=hop,
+        y_axis="hz",
+        x_axis="time",
+        cmap="viridis",
+        ax=ax_spec,
+        vmin=-80,
+        vmax=0
     )
-    ax_spec.set_title('Spectrogram', fontsize=14, fontweight='bold', pad=10)
-    ax_spec.set_ylabel('Frequency (Hz)', fontsize=11, fontweight='bold')
-    ax_spec.set_xlabel('Time (seconds)', fontsize=11, fontweight='bold')
-    ax_spec.grid(True, alpha=0.3, linestyle='--', linewidth=0.5)
-    
-    cbar = plt.colorbar(img, ax=ax_spec, format='%+2.0f dB', pad=0.01)
+
+    ax_spec.set_title("Spectrogram", fontsize=14, fontweight="bold", pad=10)
+    ax_spec.set_ylabel("Frequency (Hz)", fontsize=11, fontweight="bold")
+    ax_spec.set_xlabel("Time (seconds)", fontsize=11, fontweight="bold")
+    ax_spec.grid(True, alpha=0.3, linestyle="--", linewidth=0.5)
+
+    cbar = plt.colorbar(img, ax=ax_spec, format="%+2.0f dB", pad=0.01)
     cbar.ax.tick_params(labelsize=10)
-    cbar.set_label('Magnitude (dB)', fontsize=10, fontweight='bold')
-    
-    # FILE INFO
+    cbar.set_label("Magnitude (dB)", fontsize=10, fontweight="bold")
+
+    # ============================
+    # FILE INFO BLOCK
+    # ============================
+
     ax_info = fig.add_subplot(gs[1, 0:2])
-    ax_info.axis('off')
-    info = audio_data['info']
-    time = audio_data['time_stats']
-    
+    ax_info.axis("off")
+
+    info = audio_data["info"]
+    time = audio_data["time_stats"]
+
     info_lines = [
         "FILE INFORMATION",
         "─" * 50,
         f"Sample Rate:     {info['samplerate']:,} Hz",
         f"Channels:        {info['channels']}",
-        f"Duration:        {info['duration']:.2f} seconds",
+        f"Duration:        {info['duration']:.2f} sec",
         f"Format:          {info['format']} ({info['subtype']})",
         f"Total Frames:    {info['frames']:,}",
         "",
         "TIME-DOMAIN ANALYSIS",
         "─" * 50,
-        f"Peak Level:      {time['peak_db']:.2f} dBFS  ({time['peak']:.6f})",
-        f"RMS Level:       {time['rms_db']:.2f} dBFS  ({time['rms']:.6f})",
+        f"Peak Level:      {time['peak_db']:.2f} dBFS ({time['peak']:.6f})",
+        f"RMS Level:       {time['rms_db']:.2f} dBFS ({time['rms']:.6f})",
         f"Crest Factor:    {time['crest_factor_db']:.2f} dB",
         f"Noise Floor:     {time['noise_floor']:.6f}",
         f"Est. SNR:        {time['snr_db']:.1f} dB",
         f"Zero Cross Rate: {time['zero_crossing_rate']:.4f}",
     ]
-    
-    if audio_data.get('lufs') is not None:
+
+    if audio_data.get("lufs") is not None:
         info_lines.extend([
             "",
             "LOUDNESS (BS.1770)",
             "─" * 50,
             f"Integrated LUFS: {audio_data['lufs']:.2f} LUFS"
         ])
-    
+
     info_text = "\n".join(info_lines)
-    ax_info.text(0.05, 0.95, info_text, transform=ax_info.transAxes,
-                 fontsize=11, verticalalignment='top', family='monospace',
-                 bbox=dict(boxstyle='round,pad=1', facecolor='#E8F4F8', 
-                          edgecolor='#0077BE', linewidth=2))
-    
-    # SPECTRAL STATS
+
+    ax_info.text(
+        0.05, 0.95, info_text,
+        transform=ax_info.transAxes,
+        fontsize=11,
+        verticalalignment="top",
+        family="monospace",
+        bbox=dict(
+            boxstyle="round,pad=1",
+            facecolor="#E8F4F8",
+            edgecolor="#0077BE",
+            linewidth=2
+        )
+    )
+    # ============================
+    # SPECTRAL STATS PANEL
+    # ============================
+
     ax_spectral = fig.add_subplot(gs[1, 2:4])
-    ax_spectral.axis('off')
-    spec = audio_data['spectral']
-    energy = spec['energy_distribution']
-    
+    ax_spectral.axis("off")
+
+    spec = audio_data["spectral"]
+    energy = spec["energy_distribution"]
+
     spectral_lines = [
         "SPECTRAL ANALYSIS",
         "─" * 50,
@@ -290,68 +353,118 @@ def create_report(audio_data, output_path):
         f"Flatness:        {spec['spectral_flatness']:.4f}",
         f"Rolloff:         {spec['spectral_rolloff']:.1f} Hz",
         "",
-        "FREQUENCY ROLLOFFS",
+        "FREQUENCY ROLLOFF POINTS",
         "─" * 50,
         f"85% Energy:      {spec['rolloff_85pct']:.1f} Hz",
         f"95% Energy:      {spec['rolloff_95pct']:.1f} Hz",
         f"Highest (-60dB): {spec['highest_freq_minus60db']:.1f} Hz",
         "",
-        "ENERGY DISTRIBUTION BY BAND",
+        "ENERGY DISTRIBUTION (Speech Bands)",
         "─" * 50,
         f"< 100 Hz:        {energy['below_100hz']:.2f}%",
-        f"100-500 Hz:      {energy['100_500hz']:.2f}%",
-        f"500-2k Hz:       {energy['500_2khz']:.2f}%",
-        f"2k-8k Hz:        {energy['2k_8khz']:.2f}%",
-        f"> 8 kHz:         {energy['above_8khz']:.2f}%",
-        f"> 12 kHz:        {energy['above_12khz']:.2f}%",
-        f"> 16 kHz:        {energy['above_16khz']:.2f}%",
+        f"100–500 Hz:      {energy['100_500hz']:.2f}%",
+        f"500–2k Hz:       {energy['500_2khz']:.2f}%",
+        f"2k–8k Hz:        {energy['2k_8khz']:.2f}%",
+        f"8k–12k Hz:       {energy['8k_12khz']:.2f}%",
+        f"12k–16k Hz:      {energy['12k_16khz']:.2f}%",
+        f"> 16k Hz:        {energy['above_16khz']:.2f}%",
     ]
-    
+
     spectral_text = "\n".join(spectral_lines)
-    ax_spectral.text(0.05, 0.95, spectral_text, transform=ax_spectral.transAxes,
-                     fontsize=11, verticalalignment='top', family='monospace',
-                     bbox=dict(boxstyle='round,pad=1', facecolor='#FFF4E6', 
-                              edgecolor='#FF8C00', linewidth=2))
-    
-    # ENERGY BAR CHART
+
+    ax_spectral.text(
+        0.05, 0.95, spectral_text,
+        transform=ax_spectral.transAxes,
+        fontsize=11,
+        verticalalignment="top",
+        family="monospace",
+        bbox=dict(
+            boxstyle="round,pad=1",
+            facecolor="#FFF4E6",
+            edgecolor="#FF8C00",
+            linewidth=2
+        )
+    )
+
+
+    # ============================
+    # ENERGY DISTRIBUTION BAR CHART
+    # ============================
+
     ax_energy = fig.add_subplot(gs[2, :])
-    
-    bands = ['<100Hz', '100-500Hz', '500-2kHz', '2k-8kHz', '>8kHz', '>12kHz', '>16kHz']
+
+    bands = [
+        "<100Hz",
+        "100–500Hz",
+        "500–2kHz",
+        "2k–8kHz",
+        "8k–12kHz",
+        "12k–16kHz",
+        ">16kHz"
+    ]
+
     values = [
-        energy['below_100hz'],
-        energy['100_500hz'],
-        energy['500_2khz'],
-        energy['2k_8khz'],
-        energy['above_8khz'],
-        energy['above_12khz'],
-        energy['above_16khz']
+        energy["below_100hz"],
+        energy["100_500hz"],
+        energy["500_2khz"],
+        energy["2k_8khz"],
+        energy["8k_12khz"],
+        energy["12k_16khz"],
+        energy["above_16khz"]
     ]
-    
-    colors = ['#2C3E50', '#E74C3C', '#E67E22', '#F39C12', '#2ECC71', '#3498DB', '#9B59B6']
-    bars = ax_energy.bar(bands, values, color=colors, edgecolor='black', linewidth=1.5, alpha=0.85)
-    
-    ax_energy.set_ylabel('Energy Percentage (%)', fontsize=12, fontweight='bold')
-    ax_energy.set_title('Frequency Band Energy Distribution', fontsize=13, fontweight='bold', pad=10)
-    ax_energy.grid(axis='y', alpha=0.4, linestyle='--', linewidth=0.8)
-    ax_energy.set_ylim(0, max(values) * 1.15)
+
+    colors = [
+        "#2C3E50",
+        "#E74C3C",
+        "#E67E22",
+        "#F39C12",
+        "#2ECC71",
+        "#3498DB",
+        "#9B59B6"
+    ]
+
+    bars = ax_energy.bar(
+        bands, values,
+        color=colors,
+        edgecolor="black",
+        linewidth=1.5,
+        alpha=0.85
+    )
+
+    ax_energy.set_ylabel("Energy Percentage (%)", fontsize=12, fontweight="bold")
+    ax_energy.set_title("Frequency Band Energy Distribution", fontsize=13, fontweight="bold", pad=10)
+    ax_energy.grid(axis="y", alpha=0.4, linestyle="--", linewidth=0.8)
+    ax_energy.set_ylim(0, max(values) * 1.15 if max(values) > 0 else 1)
     ax_energy.set_axisbelow(True)
-    
+
     for bar, val in zip(bars, values):
         height = bar.get_height()
-        ax_energy.text(bar.get_x() + bar.get_width()/2., height + 0.5,
-                      f'{val:.2f}%', ha='center', va='bottom', 
-                      fontsize=10, fontweight='bold')
-    
+        ax_energy.text(
+            bar.get_x() + bar.get_width() / 2., height + 0.5,
+            f"{val:.2f}%",
+            ha="center",
+            va="bottom",
+            fontsize=10,
+            fontweight="bold"
+        )
+
+
+    # ============================
     # ISSUES PANEL
+    # ============================
+
     ax_issues = fig.add_subplot(gs[3, 0:3])
-    ax_issues.axis('off')
-    
-    issues = audio_data['issues']
-    
-    issue_lines = ["DETECTED ISSUES & WARNINGS", "═" * 80]
-    
+    ax_issues.axis("off")
+
+    issues = audio_data["issues"]
+
+    issue_lines = [
+        "DETECTED ISSUES & WARNINGS",
+        "═" * 80
+    ]
+
     if not issues:
-        issue_lines.append("✅ No significant issues detected - Audio quality is good!")
+        issue_lines.append("✅ No significant issues detected.")
     else:
         severity_icons = {
             "CRITICAL": "🔴 CRITICAL",
@@ -359,53 +472,73 @@ def create_report(audio_data, output_path):
             "MEDIUM": "🟡 MEDIUM",
             "LOW": "🟢 LOW"
         }
-        
+
         for issue_type, severity, description in issues:
             icon = severity_icons.get(severity, "⚪ INFO")
-            issue_lines.append(f"\n{icon} - {issue_type}")
+            issue_lines.append(f"\n{icon} — {issue_type}")
             issue_lines.append(f"  → {description}")
-    
-    if spec['spectral_notches']:
+
+    # If spectral notches exist, list them
+    if spec["spectral_notches"]:
         issue_lines.append(f"\n🎵 SPECTRAL NOTCHES DETECTED: {len(spec['spectral_notches'])}")
-        for i, notch in enumerate(spec['spectral_notches'][:5], 1):
-            issue_lines.append(f"  {i}. Frequency: {notch['freq']:.1f} Hz, Depth: {notch['depth_db']:.1f} dB")
-        if len(spec['spectral_notches']) > 5:
-            issue_lines.append(f"  ... and {len(spec['spectral_notches'])-5} more")
-    
-    if spec['brick_wall_detected']:
+        for i, notch in enumerate(spec["spectral_notches"][:5], start=1):
+            issue_lines.append(
+                f"  {i}. Frequency: {notch['freq']:.1f} Hz, Depth: {notch['depth_db']:.1f} dB"
+            )
+        if len(spec["spectral_notches"]) > 5:
+            issue_lines.append(f"  ... and {len(spec['spectral_notches']) - 5} more")
+
+    # Brickwall detection notice
+    if spec["brick_wall_detected"]:
         issue_lines.append(f"\n⚠️ BRICK-WALL FILTER: Detected at {spec['brick_wall_freq']:.0f} Hz")
-    
+
     issues_text = "\n".join(issue_lines)
-    ax_issues.text(0.05, 0.95, issues_text, transform=ax_issues.transAxes,
-                   fontsize=11, verticalalignment='top', family='monospace',
-                   bbox=dict(boxstyle='round,pad=1', facecolor='#FFE6E6', 
-                            edgecolor='#DC143C', linewidth=2))
-    
-    # QUALITY SCORE
+
+    ax_issues.text(
+        0.05, 0.95, issues_text,
+        transform=ax_issues.transAxes,
+        fontsize=11,
+        verticalalignment="top",
+        family="monospace",
+        bbox=dict(
+            boxstyle="round,pad=1",
+            facecolor="#FFE6E6",
+            edgecolor="#DC143C",
+            linewidth=2
+        )
+    )
+    # ============================
+    # QUALITY SCORE PANEL
+    # ============================
+
     ax_score = fig.add_subplot(gs[3, 3])
-    ax_score.axis('off')
-    
+    ax_score.axis("off")
+
+    issues = audio_data["issues"]
+
+    # Score penalties
+    critical = sum(1 for _, sev, _ in issues if sev == "CRITICAL")
+    high = sum(1 for _, sev, _ in issues if sev == "HIGH")
+    medium = sum(1 for _, sev, _ in issues if sev == "MEDIUM")
+
     score = 100
-    critical = sum(1 for _, sev, _ in issues if sev == 'CRITICAL')
-    high = sum(1 for _, sev, _ in issues if sev == 'HIGH')
-    medium = sum(1 for _, sev, _ in issues if sev == 'MEDIUM')
-    
     score -= critical * 30
     score -= high * 15
     score -= medium * 5
     score = max(0, score)
-    
+
+    # Grade + Color
     if score >= 90:
-        grade, color, quality = "A", '#00C853', "EXCELLENT"
+        grade, quality, color = "A", "EXCELLENT", "#00C853"
     elif score >= 75:
-        grade, color, quality = "B", '#64DD17', "GOOD"
+        grade, quality, color = "B", "GOOD", "#64DD17"
     elif score >= 60:
-        grade, color, quality = "C", '#FFD600', "FAIR"
+        grade, quality, color = "C", "FAIR", "#FFD600"
     elif score >= 40:
-        grade, color, quality = "D", '#FF6D00', "POOR"
+        grade, quality, color = "D", "POOR", "#FF6D00"
     else:
-        grade, color, quality = "F", '#D50000', "CRITICAL"
-    
+        grade, quality, color = "F", "CRITICAL", "#D50000"
+
     score_lines = [
         "QUALITY ASSESSMENT",
         "═" * 28,
@@ -421,55 +554,76 @@ def create_report(audio_data, output_path):
         f"🟡 Medium:   {medium}",
         "",
         "─" * 28,
-        f"Generated:",
+        "Generated:",
         f"{audio_data['timestamp']}"
     ]
-    
+
     score_text = "\n".join(score_lines)
-    ax_score.text(0.5, 0.5, score_text, transform=ax_score.transAxes,
-                  fontsize=11, ha='center', va='center', family='monospace',
-                  bbox=dict(boxstyle='round,pad=1.2', facecolor=color, 
-                           edgecolor='black', linewidth=3, alpha=0.7),
-                  fontweight='bold')
-    
-    plt.savefig(output_path, dpi=300, bbox_inches='tight', 
-                facecolor='white', edgecolor='none')
-    plt.close()
-    
-    return output_path
 
+    ax_score.text(
+        0.5, 0.5, score_text,
+        transform=ax_score.transAxes,
+        fontsize=11,
+        ha="center",
+        va="center",
+        family="monospace",
+        bbox=dict(
+            boxstyle="round,pad=1.2",
+            facecolor=color,
+            edgecolor="black",
+            linewidth=3,
+            alpha=0.75
+        ),
+        fontweight="bold"
+    )
 
-# ==================== GRADIO INTERFACE ====================
+    # ============================
+    # SAVE REPORT
+    # ============================
+
+    plt.savefig(
+        output_path,
+        dpi=300,
+        bbox_inches="tight",
+        facecolor="white",
+        edgecolor="none"
+    )
+    plt.close()
+
+    return output_path
+# ============================================================
+# MAIN ANALYSIS FUNCTION (GRADIO CALLBACK)
+# ============================================================
 
 def analyze_audio(audio_file, progress=gr.Progress()):
-    """Analyze uploaded audio file"""
+    """Analyze uploaded audio file."""
     if audio_file is None:
         return None, "⚠️ Please upload an audio file to analyze."
-    
+
     try:
         progress(0.1, desc="Reading audio file...")
-        
+
         output_dir = Path("reports")
         output_dir.mkdir(exist_ok=True)
-        
+
         path = Path(audio_file)
-        
+
         progress(0.2, desc="Loading audio data...")
         info = read_audio_info(str(path))
         y, sr = librosa.load(str(path), sr=None, mono=True)
-        
+
         progress(0.4, desc="Analyzing time-domain...")
         time_stats = compute_time_domain_stats(y)
-        
+
         progress(0.6, desc="Performing spectral analysis...")
         spectral = compute_spectral_analysis(y, sr)
-        
+
         progress(0.7, desc="Computing loudness...")
         lufs = compute_loudness(y, sr) if LOUDNESS_AVAILABLE else None
-        
+
         progress(0.8, desc="Detecting audio issues...")
         issues = detect_audio_issues(spectral, time_stats)
-        
+
         audio_data = {
             "filename": path.name,
             "info": info,
@@ -479,24 +633,27 @@ def analyze_audio(audio_file, progress=gr.Progress()):
             "issues": issues,
             "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         }
-        
+
         progress(0.9, desc="Generating report...")
-        
+
         output_filename = path.stem + "_report.png"
         output_path = output_dir / output_filename
-        
+
         create_report(audio_data, str(output_path))
-        
+
         progress(1.0, desc="Complete!")
-        
-        # Calculate quality score
-        critical = sum(1 for _, sev, _ in issues if sev == 'CRITICAL')
-        high = sum(1 for _, sev, _ in issues if sev == 'HIGH')
-        medium = sum(1 for _, sev, _ in issues if sev == 'MEDIUM')
-        
+
+        # ============================
+        # SCORE COMPUTATION
+        # ============================
+
+        critical = sum(1 for _, sev, _ in issues if sev == "CRITICAL")
+        high = sum(1 for _, sev, _ in issues if sev == "HIGH")
+        medium = sum(1 for _, sev, _ in issues if sev == "MEDIUM")
+
         score = 100 - (critical * 30) - (high * 15) - (medium * 5)
         score = max(0, score)
-        
+
         if score >= 90:
             grade, quality, color = "A", "EXCELLENT", "🟢"
         elif score >= 75:
@@ -507,102 +664,117 @@ def analyze_audio(audio_file, progress=gr.Progress()):
             grade, quality, color = "D", "POOR", "🟠"
         else:
             grade, quality, color = "F", "CRITICAL", "🔴"
-        
-        energy = spectral['energy_distribution']
-        
-        summary = f"""
-# 🎵 Analysis Complete! ✅
 
+        energy = spectral["energy_distribution"]
+
+        # ============================
+        # SUMMARY OUTPUT (Markdown)
+        # ============================
+
+        summary = f"""
+# 🎵 Analysis Complete!  
 ## File Information
 - **Filename:** `{audio_data['filename']}`
-- **Duration:** {info['duration']:.2f} seconds
-- **Sample Rate:** {info['samplerate']:,} Hz
-- **Channels:** {info['channels']}
+- **Duration:** {info['duration']:.2f} sec  
+- **Sample Rate:** {info['samplerate']:,} Hz  
+- **Channels:** {info['channels']}  
 - **Format:** {info['format']} ({info['subtype']})
 
 ---
 
-## Quality Assessment
-
-### Overall Score: **{score}/100** - Grade **{grade}** {color}
+## Quality Assessment  
+### Overall Score: **{score}/100** — Grade **{grade}** {color}  
 **Quality Rating:** {quality}
 
 ### Audio Metrics
 | Metric | Value |
-|--------|-------|
+|--------|--------|
 | Peak Level | {time_stats['peak_db']:.2f} dBFS |
 | RMS Level | {time_stats['rms_db']:.2f} dBFS |
 | Crest Factor | {time_stats['crest_factor_db']:.2f} dB |
 | SNR (Est.) | {time_stats['snr_db']:.1f} dB |
 """
-        
+
         if lufs is not None:
             summary += f"| Integrated LUFS | {lufs:.2f} LUFS |\n"
-        
+
         summary += f"""
 ---
 
-## Spectral Analysis
+## Spectral Analysis  
 | Parameter | Value |
-|-----------|-------|
+|-----------|--------|
 | Spectral Centroid | {spectral['spectral_centroid']:.1f} Hz |
 | 85% Rolloff | {spectral['rolloff_85pct']:.1f} Hz |
 | 95% Rolloff | {spectral['rolloff_95pct']:.1f} Hz |
-| Highest Freq (-60dB) | {spectral['highest_freq_minus60db']:.1f} Hz |
+| Highest Freq (–60 dB) | {spectral['highest_freq_minus60db']:.1f} Hz |
 
-### Energy Distribution
-- **< 100 Hz:** {energy['below_100hz']:.2f}%
-- **100-500 Hz:** {energy['100_500hz']:.2f}%
-- **500-2k Hz:** {energy['500_2khz']:.2f}%
-- **2k-8k Hz:** {energy['2k_8khz']:.2f}%
-- **> 8 kHz:** {energy['above_8khz']:.2f}%
-- **> 12 kHz:** {energy['above_12khz']:.2f}%
+### Energy Distribution (Speech Bands)
+
+- **<100 Hz:** {energy['below_100hz']:.2f}%
+- **100–500 Hz:** {energy['100_500hz']:.2f}%
+- **500–2k Hz:** {energy['500_2khz']:.2f}%
+- **2k–8k Hz:** {energy['2k_8khz']:.2f}%
+- **8k–12k Hz:** {energy['8k_12khz']:.2f}%
+- **12k–16k Hz:** {energy['12k_16khz']:.2f}%
+- **>16k Hz:** {energy['above_16khz']:.2f}%
 
 ---
 
 ## Issues Detected: **{len(issues)}**
 """
-        
+
         if issues:
             summary += "\n### ⚠️ Detected Issues:\n\n"
-            severity_icons = {"CRITICAL": "🔴", "HIGH": "🟠", "MEDIUM": "🟡", "LOW": "🟢"}
-            
-            for issue_type, severity, desc in issues:
-                icon = severity_icons.get(severity, "⚪")
-                summary += f"{icon} **[{severity}] {issue_type}**\n"
+            icons = {"CRITICAL": "🔴", "HIGH": "🟠", "MEDIUM": "🟡", "LOW": "🟢"}
+
+            for issue_type, sev, desc in issues:
+                summary += f"{icons.get(sev,'⚪')} **[{sev}] {issue_type}**\n"
                 summary += f"   - {desc}\n\n"
         else:
-            summary += "\n### ✅ No significant issues detected!\n"
-        
-        if spectral['spectral_notches']:
-            summary += f"\n### 🎵 Spectral Notches: {len(spectral['spectral_notches'])}\n\n"
-            for i, notch in enumerate(spectral['spectral_notches'][:5], 1):
-                summary += f"{i}. **{notch['freq']:.1f} Hz** (Depth: {notch['depth_db']:.1f} dB)\n"
-        
-        summary += f"\n---\n\n📊 **Report:** `{output_filename}` | 🕐 **Generated:** {audio_data['timestamp']}\n"
-        
+            summary += "\n### ✅ No significant issues detected.\n"
+
+        if spectral["spectral_notches"]:
+            summary += f"\n### 🎵 Spectral Notches: {len(spectral['spectral_notches'])}\n"
+            for i, n in enumerate(spectral["spectral_notches"][:5], 1):
+                summary += f"{i}. **{n['freq']:.1f} Hz** (Depth: {n['depth_db']:.1f} dB)\n"
+
+        summary += f"""
+
+---
+
+📊 **Report File:** `{output_filename}`  
+🕒 **Generated:** {audio_data['timestamp']}
+
+"""
+
         return str(output_path), summary
-        
+
     except Exception as e:
         import traceback
         traceback.print_exc()
         return None, f"# ❌ Analysis Failed\n\n**Error:** {str(e)}"
-
-
-# ==================== CREATE INTERFACE ====================
+# ============================================================
+# ==============  GRADIO USER INTERFACE  =====================
+# ============================================================
 
 with gr.Blocks(title="Audio Forensic Analyzer") as demo:
-    
+
     gr.Markdown("""
-    # 🎵 Audio Forensic Analyzer
-    
-    Upload an audio file to perform comprehensive forensic analysis.
-    
-    **Detects:** Compression, Filtering, Clipping, Spectral Anomalies, and more.
-    
-    **Supported formats:** WAV, MP3, FLAC, OGG, M4A, AAC
+    # 🎵 Audio Forensic Analyzer  
+    Upload an audio file to perform detailed forensic-level analysis.
+
+    This tool evaluates:
+    - Spectrum balance  
+    - HF rolloff & filtering  
+    - Compression  
+    - Clipping  
+    - Noise levels  
+    - Spectral anomalies (notches, brickwalls)
+
+    **Supported formats:** WAV, MP3, FLAC, OGG, M4A, AAC  
     """)
-    
+
     with gr.Row():
         with gr.Column(scale=1):
             audio_input = gr.Audio(
@@ -610,28 +782,33 @@ with gr.Blocks(title="Audio Forensic Analyzer") as demo:
                 type="filepath",
                 sources=["upload"]
             )
-            
+
             analyze_btn = gr.Button(
                 "🔍 Analyze Audio",
                 variant="primary",
                 size="lg"
             )
-        
+
         with gr.Column(scale=2):
             report_output = gr.Image(
                 label="📊 Analysis Report",
                 type="filepath",
                 height=600
             )
-    
+
     with gr.Row():
         summary_output = gr.Markdown(label="📋 Analysis Summary")
-    
+
     analyze_btn.click(
         fn=analyze_audio,
         inputs=[audio_input],
         outputs=[report_output, summary_output]
     )
 
+
+# ============================================================
+# ==============  APP LAUNCH  ================================
+# ============================================================
+
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()