SenseAudio Audio Quality Checker

Analyze audio files to detect quality issues, identify noise types, and provide improvement recommendations.

What This Skill Does

• Detect noise and quality issues in audio files
• Identify specific noise types (background noise, hum, static, etc.)
• Provide noise severity ratings
• Generate quality assessment reports
• Recommend improvements for audio quality

Prerequisites

Install required Python packages:

pip install requests

Implementation Guide

Step 1: Analyze Audio File

import os
import requests

API_KEY = os.environ["SENSEAUDIO_API_KEY"]

def check_audio_quality(audio_file):
    url = "https://api.senseaudio.cn/v1/audio/analysis"

    headers = {"Authorization": f"Bearer {API_KEY}"}
    files = {"file": open(audio_file, "rb")}
    data = {"model": "sense-asr-check"}

    response = requests.post(url, headers=headers, files=files, data=data)
    return response.json()

# Example response:
# {
#   "audio_info": {
#     "duration": 5230,
#     "format": "wav"
#   },
#   "result": {
#     "has_noise": true,
#     "noise_score": 0.65,
#     "severity": "moderate",
#     "noise_types": ["background_noise", "hum"],
#     "analysis": "Audio contains moderate background noise and electrical hum"
#   }
# }

Step 2: Parse Quality Report

def parse_quality_report(analysis_result):
    audio_info = analysis_result.get("audio_info", {})
    result = analysis_result.get("result", {})

    report = {
        "duration_ms": audio_info.get("duration"),
        "format": audio_info.get("format"),
        "has_issues": result.get("has_noise", False),
        "noise_score": result.get("noise_score", 0),
        "severity": result.get("severity", "none"),
        "noise_types": result.get("noise_types", []),
        "analysis": result.get("analysis", ""),
        "recommendations": generate_recommendations(result)
    }

    return report

Step 3: Generate Recommendations

def generate_recommendations(quality_result):
    recommendations = []

    noise_score = quality_result.get("noise_score", 0)
    noise_types = quality_result.get("noise_types", [])
    severity = quality_result.get("severity", "none")

    # General recommendations based on severity
    if severity == "severe":
        recommendations.append("Re-record audio in a quieter environment")
        recommendations.append("Use professional audio equipment")
    elif severity == "moderate":
        recommendations.append("Apply noise reduction in post-processing")
        recommendations.append("Consider using a better microphone")
    elif severity == "mild":
        recommendations.append("Minor noise reduction may improve quality")

    # Specific recommendations based on noise types
    if "background_noise" in noise_types:
        recommendations.append("Record in a quieter location")
        recommendations.append("Use acoustic treatment (foam panels, curtains)")

    if "hum" in noise_types:
        recommendations.append("Check for electrical interference")
        recommendations.append("Use balanced audio cables")
        recommendations.append("Ensure proper grounding of equipment")

    if "static" in noise_types:
        recommendations.append("Check cable connections")
        recommendations.append("Replace faulty cables or equipment")

    if "wind_noise" in noise_types:
        recommendations.append("Use a windscreen or pop filter")
        recommendations.append("Record indoors or in sheltered location")

    if "echo" in noise_types:
        recommendations.append("Add acoustic treatment to reduce reflections")
        recommendations.append("Record closer to microphone")

    return recommendations

Step 4: Batch Quality Check

def batch_quality_check(audio_files):
    results = []

    for audio_file in audio_files:
        try:
            analysis = check_audio_quality(audio_file)
            report = parse_quality_report(analysis)

            results.append({
                "file": audio_file,
                "status": "analyzed",
                "report": report
            })
        except Exception as e:
            results.append({
                "file": audio_file,
                "status": "error",
                "error": str(e)
            })

    return results

Advanced Features

Quality Scoring System

def calculate_quality_score(analysis_result):
    """Calculate overall quality score (0-100)"""
    noise_score = analysis_result.get("noise_score", 0)
    severity = analysis_result.get("severity", "none")

    # Base score
    base_score = 100

    # Deduct based on noise score
    noise_penalty = noise_score * 50  # Max 50 points

    # Additional penalty for severity
    severity_penalties = {
        "none": 0,
        "mild": 10,
        "moderate": 25,
        "severe": 40
    }
    severity_penalty = severity_penalties.get(severity, 0)

    final_score = max(0, base_score - noise_penalty - severity_penalty)

    return {
        "score": round(final_score, 1),
        "grade": get_quality_grade(final_score)
    }

def get_quality_grade(score):
    if score >= 90:
        return "Excellent"
    elif score >= 75:
        return "Good"
    elif score >= 60:
        return "Fair"
    elif score >= 40:
        return "Poor"
    else:
        return "Unacceptable"

Comparative Analysis

def compare_audio_quality(original_file, processed_file):
    """Compare quality before and after processing"""

    original_analysis = check_audio_quality(original_file)
    processed_analysis = check_audio_quality(processed_file)

    original_score = calculate_quality_score(original_analysis["result"])
    processed_score = calculate_quality_score(processed_analysis["result"])

    comparison = {
        "original": {
            "file": original_file,
            "score": original_score,
            "noise_score": original_analysis["result"]["noise_score"]
        },
        "processed": {
            "file": processed_file,
            "score": processed_score,
            "noise_score": processed_analysis["result"]["noise_score"]
        },
        "improvement": {
            "score_delta": processed_score["score"] - original_score["score"],
            "noise_reduction": original_analysis["result"]["noise_score"] - processed_analysis["result"]["noise_score"]
        }
    }

    return comparison

Automated Quality Gate

def quality_gate_check(audio_file, min_score=70):
    """Check if audio meets minimum quality threshold"""

    analysis = check_audio_quality(audio_file)
    quality = calculate_quality_score(analysis["result"])

    passed = quality["score"] >= min_score

    return {
        "passed": passed,
        "score": quality["score"],
        "grade": quality["grade"],
        "threshold": min_score,
        "analysis": analysis
    }

Detailed Report Generation

def generate_detailed_report(audio_file):
    """Generate comprehensive quality report"""

    analysis = check_audio_quality(audio_file)
    report = parse_quality_report(analysis)
    quality = calculate_quality_score(analysis["result"])

    detailed_report = f"""
# Audio Quality Report

## File Information
- **File**: {audio_file}
- **Duration**: {report['duration_ms']/1000:.2f} seconds
- **Format**: {report['format']}

## Quality Assessment
- **Overall Score**: {quality['score']}/100
- **Grade**: {quality['grade']}
- **Noise Score**: {report['noise_score']:.2f}
- **Severity**: {report['severity']}

## Issues Detected
{'- ' + '\\
- '.join(report['noise_types']) if report['noise_types'] else 'No issues detected'}

## Analysis
{report['analysis']}

## Recommendations
{'- ' + '\\
- '.join(report['recommendations']) if report['recommendations'] else 'No recommendations'}
"""

    return detailed_report

Use Cases

Pre-Recording Validation

def validate_recording_environment():
    """Test recording environment before actual recording"""

    # record_test_audio() is a placeholder — implement using your preferred
    # audio capture library (e.g. sounddevice, pyaudio) to record a short clip.
    test_file = record_test_audio(duration=5)

    # Check quality
    gate_result = quality_gate_check(test_file, min_score=75)

    if gate_result["passed"]:
        return {
            "ready": True,
            "message": "Environment is suitable for recording"
        }
    else:
        return {
            "ready": False,
            "message": "Environment needs improvement",
            "recommendations": gate_result["analysis"]["result"]["recommendations"]
        }

Post-Production Quality Control

def qc_pipeline(audio_files, min_score=80):
    """Quality control for batch of audio files"""

    qc_results = {
        "passed": [],
        "failed": [],
        "total": len(audio_files)
    }

    for audio_file in audio_files:
        result = quality_gate_check(audio_file, min_score)

        if result["passed"]:
            qc_results["passed"].append(audio_file)
        else:
            qc_results["failed"].append({
                "file": audio_file,
                "score": result["score"],
                "issues": result["analysis"]["result"]["noise_types"]
            })

    qc_results["pass_rate"] = len(qc_results["passed"]) / qc_results["total"] * 100

    return qc_results

Output Format

• Quality analysis JSON
• Detailed quality report (Markdown/PDF)
• Noise detection results
• Improvement recommendations
• Quality score and grade

Tips for Best Results

• Test audio files before important recordings
• Use quality gates in production pipelines
• Compare before/after processing
• Track quality metrics over time
• Address severe issues immediately

Example Usage

User request: "Check the quality of this audio recording and tell me if it's good enough for a podcast"

Skill actions:

1. Upload audio file to analysis API
2. Parse quality results
3. Calculate quality score
4. Generate recommendations
5. Provide clear pass/fail assessment
6. Suggest improvements if needed

Reference

API docs: https://senseaudio.cn/docs/speech_recognition