Audio Quality Checker

SenseAudio Audio Quality Checker

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

What This Skill Does

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
{'- ' + '\\n- '.join(report['noise_types']) if report['noise_types'] else 'No issues detected'}
Analysis
{report['analysis']}
Recommendations
{'- ' + '\\n- '.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

Tips for Best Results

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

Install required Python packages:

pip install requests