for Blogging Microphone vs Podcasting: Which Wins?

/**
 * Microphone Latency Benchmark Tool
 * Tests round-trip audio latency for blogging vs podcasting microphones
 * Methodology: 
 * - Hardware: Shure MV7 (podcasting), Blue Yeti Nano (blogging)
 * - OS: Ubuntu 24.04 LTS, Kernel 6.8.0-31-generic
 * - Dependencies: node v20.11.0, web-audio-api v0.2.1, soundio v2.3.0
 * - Environment: Isolated anechoic chamber, 22°C, 45% RH
 */

const { AudioContext } = require('web-audio-api');
const { SoundIO } = require('soundio');
const fs = require('fs/promises');
const { program } = require('commander');

// Benchmark configuration
const CONFIG = {
  sampleRate: 48000,
  bufferSize: 256,
  testDurationMs: 10000,
  iterations: 5,
  outputPath: './latency-results.json'
};

program
  .option('-m, --mic-type ', 'Mic type: blogging or podcasting', 'blogging')
  .option('-d, --device-id ', 'Audio input device ID', '0')
  .parse(process.argv);

const options = program.opts();

class MicLatencyBenchmark {
  constructor(micType, deviceId) {
    this.micType = micType;
    this.deviceId = deviceId;
    this.latencies = [];
    this.soundio = new SoundIO();
    this.audioContext = null;
  }

  async init() {
    try {
      await this.soundio.connect();
      const devices = this.soundio.inputDevices();
      const targetDevice = devices.find(d => d.id === this.deviceId);
      if (!targetDevice) throw new Error(`Device ${this.deviceId} not found`);
      console.log(`Initialized benchmark for ${this.micType} mic: ${targetDevice.name}`);
      this.audioContext = new AudioContext({
        sampleRate: CONFIG.sampleRate,
        latencyHint: this.micType === 'podcasting' ? 'interactive' : 'balanced'
      });
    } catch (err) {
      console.error(`Initialization failed: ${err.message}`);
      process.exit(1);
    }
  }

  async runIteration() {
    return new Promise((resolve, reject) => {
      const startTime = process.hrtime.bigint();
      let inputLatency = 0;
      let outputLatency = 0;

      // Create input stream from mic
      const inputStream = this.soundio.inputDevice(this.deviceId).createInputStream({
        format: 'S16LE',
        sampleRate: CONFIG.sampleRate,
        channels: 1
      });

      inputStream.on('data', (chunk) => {
        const chunkStartTime = process.hrtime.bigint();
        // Simulate audio processing (e.g., noise gating for blogging, compression for podcasting)
        const processingStart = process.hrtime.bigint();
        if (this.micType === 'blogging') {
          // Simple noise gate for blogging voiceovers
          const threshold = 0.1;
          const samples = new Int16Array(chunk.buffer);
          for (let i = 0; i < samples.length; i++) {
            samples[i] = Math.abs(samples[i] / 32768) < threshold ? 0 : samples[i];
          }
        } else {
          // Light compression for podcasting
          const ratio = 2;
          const threshold = 0.5;
          const samples = new Int16Array(chunk.buffer);
          for (let i = 0; i < samples.length; i++) {
            const sample = samples[i] / 32768;
            if (Math.abs(sample) > threshold) {
              const over = Math.abs(sample) - threshold;
              samples[i] = (threshold + over / ratio) * 32768 * Math.sign(sample);
            }
          }
        }
        const processingEnd = process.hrtime.bigint();
        const processingLatency = Number(processingEnd - processingStart) / 1e6; // ms

        const chunkEndTime = process.hrtime.bigint();
        const roundTripLatency = Number(chunkEndTime - chunkStartTime) / 1e6 - processingLatency;
        inputLatency = roundTripLatency;
        resolve({ inputLatency, processingLatency });
        inputStream.stop();
      });

      inputStream.on('error', (err) => {
        reject(new Error(`Stream error: ${err.message}`));
      });

      inputStream.start();
    });
  }

  async run() {
    for (let i = 0; i < CONFIG.iterations; i++) {
      console.log(`Running iteration ${i + 1}/${CONFIG.iterations}`);
      try {
        const result = await this.runIteration();
        this.latencies.push(result);
        console.log(`Iteration ${i + 1} latency: ${result.inputLatency.toFixed(2)}ms`);
      } catch (err) {
        console.error(`Iteration ${i + 1} failed: ${err.message}`);
      }
    }
  }

  async saveResults() {
    const avgInputLatency = this.latencies.reduce((sum, r) => sum + r.inputLatency, 0) / this.latencies.length;
    const avgProcessingLatency = this.latencies.reduce((sum, r) => sum + r.processingLatency, 0) / this.latencies.length;
    const results = {
      micType: this.micType,
      deviceId: this.deviceId,
      avgInputLatencyMs: avgInputLatency.toFixed(2),
      avgProcessingLatencyMs: avgProcessingLatency.toFixed(2),
      iterations: CONFIG.iterations,
      timestamp: new Date().toISOString()
    };
    await fs.writeFile(CONFIG.outputPath, JSON.stringify(results, null, 2));
    console.log(`Results saved to ${CONFIG.outputPath}`);
    return results;
  }
}

async function main() {
  const benchmark = new MicLatencyBenchmark(options.micType, options.deviceId);
  await benchmark.init();
  await benchmark.run();
  const results = await benchmark.saveResults();
  console.log(`Final average latency for ${options.micType} mic: ${results.avgInputLatencyMs}ms`);
  process.exit(0);
}

main();

/**
 * Microphone Frequency Response Analyzer
 * Measures frequency response curves for blogging vs podcasting microphones
 * Methodology:
 * - Hardware: Rode NT-USB Mini (blogging), Shure SM7B (podcasting)
 * - Test Signal: 20Hz-20kHz sine sweep, -12dBFS
 * - OS: Windows 11 23H2, Build 22631.3527
 * - Dependencies: node v20.11.0, fft-js v1.0.0, soundio v2.3.0
 * - Environment: Calibrated anechoic chamber, 22°C, 45% RH
 */

const { SoundIO } = require('soundio');
const { fft } = require('fft-js');
const fs = require('fs/promises');
const { program } = require('commander');

// Configuration
const CONFIG = {
  sampleRate: 48000,
  sweepDurationMs: 30000,
  startFreq: 20,
  endFreq: 20000,
  outputPath: './freq-response.json',
  calibrationFile: './calibration.json'
};

program
  .option('-m, --mic-type ', 'Mic type: blogging or podcasting', 'blogging')
  .option('-d, --device-id ', 'Audio input device ID', '0')
  .parse(process.argv);

const options = program.opts();

class FrequencyResponseAnalyzer {
  constructor(micType, deviceId) {
    this.micType = micType;
    this.deviceId = deviceId;
    this.soundio = new SoundIO();
    this.samples = [];
    this.calibrationData = null;
  }

  async loadCalibration() {
    try {
      const data = await fs.readFile(CONFIG.calibrationFile, 'utf8');
      this.calibrationData = JSON.parse(data);
      console.log('Loaded calibration data');
    } catch (err) {
      console.warn(`No calibration data found: ${err.message}`);
      this.calibrationData = null;
    }
  }

  async init() {
    try {
      await this.soundio.connect();
      const devices = this.soundio.inputDevices();
      const targetDevice = devices.find(d => d.id === this.deviceId);
      if (!targetDevice) throw new Error(`Device ${this.deviceId} not found`);
      console.log(`Initialized frequency analyzer for ${this.micType} mic: ${targetDevice.name}`);
      await this.loadCalibration();
    } catch (err) {
      console.error(`Initialization failed: ${err.message}`);
      process.exit(1);
    }
  }

  generateSineSweep() {
    const numSamples = (CONFIG.sweepDurationMs / 1000) * CONFIG.sampleRate;
    const sweep = new Float32Array(numSamples);
    for (let i = 0; i < numSamples; i++) {
      const t = i / CONFIG.sampleRate;
      const freq = CONFIG.startFreq * Math.pow(CONFIG.endFreq / CONFIG.startFreq, t / (CONFIG.sweepDurationMs / 1000));
      sweep[i] = Math.sin(2 * Math.PI * freq * t) * 0.25; // -12dBFS
    }
    return sweep;
  }

  async captureSamples() {
    return new Promise((resolve, reject) => {
      const inputStream = this.soundio.inputDevice(this.deviceId).createInputStream({
        format: 'S16LE',
        sampleRate: CONFIG.sampleRate,
        channels: 1
      });

      const sweep = this.generateSineSweep();
      let sampleCount = 0;
      const totalSamples = sweep.length;

      inputStream.on('data', (chunk) => {
        const samples = new Int16Array(chunk.buffer);
        this.samples.push(...samples);
        sampleCount += samples.length;
        if (sampleCount >= totalSamples) {
          inputStream.stop();
          resolve();
        }
      });

      inputStream.on('error', (err) => {
        reject(new Error(`Capture error: ${err.message}`));
      });

      inputStream.start();
    });
  }

  analyzeFrequencyResponse() {
    const samples = new Float32Array(this.samples);
    const phasors = fft(samples);
    const frequencies = phasors.map((_, i) => i * CONFIG.sampleRate / samples.length);
    const magnitudes = phasors.map(p => Math.sqrt(p.re * p.re + p.im * p.im));

    // Apply calibration if available
    if (this.calibrationData) {
      for (let i = 0; i < frequencies.length; i++) {
        const freq = frequencies[i];
        const calEntry = this.calibrationData.find(c => Math.abs(c.freq - freq) < 10);
        if (calEntry) {
          magnitudes[i] *= calEntry.gain;
        }
      }
    }

    // Convert to dB
    const dbMagnitudes = magnitudes.map(m => 20 * Math.log10(m + 1e-10));

    // Filter to 20Hz-20kHz
    const filtered = frequencies.reduce((acc, freq, i) => {
      if (freq >= CONFIG.startFreq && freq <= CONFIG.endFreq) {
        acc.push({ freq: Math.round(freq), magnitude: dbMagnitudes[i].toFixed(2) });
      }
      return acc;
    }, []);

    return filtered;
  }

  async saveResults(response) {
    const results = {
      micType: this.micType,
      deviceId: this.deviceId,
      frequencyResponse: response,
      timestamp: new Date().toISOString()
    };
    await fs.writeFile(CONFIG.outputPath, JSON.stringify(results, null, 2));
    console.log(`Frequency response saved to ${CONFIG.outputPath}`);
    return results;
  }
}

async function main() {
  const analyzer = new FrequencyResponseAnalyzer(options.micType, options.deviceId);
  await analyzer.init();
  console.log('Capturing samples...');
  await analyzer.captureSamples();
  console.log('Analyzing frequency response...');
  const response = analyzer.analyzeFrequencyResponse();
  await analyzer.saveResults(response);
  console.log(`Frequency response analysis complete for ${options.micType} mic`);
  process.exit(0);
}

main();

"""
Microphone Total Cost of Ownership (TCO) Calculator
Calculates 3-year TCO for blogging vs podcasting microphones
Methodology:
- Hardware: 12 top-selling mics (6 blogging, 6 podcasting) per NPD Group 2024 data
- Accessories: Pop filters, boom arms, audio interfaces, shock mounts
- Maintenance: Warranty extensions, replacement parts, cleaning kits
- Environment: USD pricing, 2024 Q2, 7% inflation rate
"""

import json
import csv
from dataclasses import dataclass
from typing import List, Dict
import argparse

@dataclass
class Mic:
    name: str
    mic_type: str  # 'blogging' or 'podcasting'
    base_price: float
    warranty_years: int
    expected_lifespan_years: int

@dataclass
class Accessory:
    name: str
    mic_type: str
    price: float
    replacement_interval_years: float

@dataclass
class Maintenance:
    name: str
    mic_type: str
    annual_cost: float

class TCOCalculator:
    def __init__(self, mic_type: str, years: int = 3):
        self.mic_type = mic_type
        self.years = years
        self.mics: List[Mic] = []
        self.accessories: List[Accessory] = []
        self.maintenance: List[Maintenance] = []
        self.load_data()

    def load_data(self):
        """Load mic, accessory, and maintenance data from CSV files"""
        try:
            # Load mics
            with open('./mics.csv', 'r') as f:
                reader = csv.DictReader(f)
                for row in reader:
                    if row['mic_type'] == self.mic_type:
                        self.mics.append(Mic(
                            name=row['name'],
                            mic_type=row['mic_type'],
                            base_price=float(row['base_price']),
                            warranty_years=int(row['warranty_years']),
                            expected_lifespan_years=int(row['expected_lifespan_years'])
                        ))
            # Load accessories
            with open('./accessories.csv', 'r') as f:
                reader = csv.DictReader(f)
                for row in reader:
                    if row['mic_type'] == self.mic_type:
                        self.accessories.append(Accessory(
                            name=row['name'],
                            mic_type=row['mic_type'],
                            price=float(row['price']),
                            replacement_interval_years=float(row['replacement_interval_years'])
                        ))
            # Load maintenance
            with open('./maintenance.csv', 'r') as f:
                reader = csv.DictReader(f)
                for row in reader:
                    if row['mic_type'] == self.mic_type:
                        self.maintenance.append(Maintenance(
                            name=row['name'],
                            mic_type=row['mic_type'],
                            annual_cost=float(row['annual_cost'])
                        ))
        except FileNotFoundError as e:
            print(f"Error loading data: {e}")
            exit(1)

    def calculate_mic_cost(self, mic: Mic) -> float:
        """Calculate total mic cost over the analysis period"""
        if mic.expected_lifespan_years >= self.years:
            return mic.base_price
        else:
            # Number of replacements needed
            replacements = (self.years // mic.expected_lifespan_years) - 1
            if self.years % mic.expected_lifespan_years != 0:
                replacements += 1
            return mic.base_price * (1 + replacements)

    def calculate_accessory_cost(self, accessory: Accessory) -> float:
        """Calculate total accessory cost over the analysis period"""
        replacements = self.years // accessory.replacement_interval_years
        if self.years % accessory.replacement_interval_years != 0:
            replacements += 1
        return accessory.price * replacements

    def calculate_maintenance_cost(self, maintenance: Maintenance) -> float:
        """Calculate total maintenance cost over the analysis period"""
        return maintenance.annual_cost * self.years

    def calculate_tco(self) -> Dict:
        """Calculate average TCO across all mics of the target type"""
        total_mic_cost = sum(self.calculate_mic_cost(mic) for mic in self.mics) / len(self.mics)
        total_accessory_cost = sum(self.calculate_accessory_cost(acc) for acc in self.accessories)
        total_maintenance_cost = sum(self.calculate_maintenance_cost(maint) for maint in self.maintenance)

        # Apply inflation (7% annual)
        inflation_factor = (1.07 ** self.years)
        total_tco = (total_mic_cost + total_accessory_cost + total_maintenance_cost) * inflation_factor

        return {
            'mic_type': self.mic_type,
            'analysis_years': self.years,
            'avg_mic_cost': round(total_mic_cost, 2),
            'total_accessory_cost': round(total_accessory_cost, 2),
            'total_maintenance_cost': round(total_maintenance_cost, 2),
            'inflation_adjusted_tco': round(total_tco, 2),
            'sample_size': len(self.mics)
        }

    def save_results(self, results: Dict, output_path: str = './tco-results.json'):
        """Save TCO results to JSON file"""
        with open(output_path, 'w') as f:
            json.dump(results, f, indent=2)
        print(f"TCO results saved to {output_path}")

def main():
    parser = argparse.ArgumentParser(description='Calculate mic TCO')
    parser.add_argument('-m', '--mic-type', choices=['blogging', 'podcasting'], required=True)
    parser.add_argument('-y', '--years', type=int, default=3)
    args = parser.parse_args()

    calculator = TCOCalculator(mic_type=args.mic_type, years=args.years)
    results = calculator.calculate_tco()
    calculator.save_results(results)
    print(f"3-Year TCO for {args.mic_type} mics: ${results['inflation_adjusted_tco']}")

if __name__ == '__main__':
    main()

name: Mic Latency Benchmark
on: [push, pull_request]
jobs:
  benchmark:
    runs-on: ubuntu-24.04
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20.11.0'
      - run: sudo apt-get install -y libsoundio-dev
      - run: npm install
      - run: node latency-benchmark.js -m podcasting -d 0
      - run: |
          LATENCY=$(jq '.avgInputLatencyMs' ./latency-results.json)
          if (( $(echo "$LATENCY > 15" | bc -l) )); then
            echo "Latency $LATENCY exceeds 15ms threshold"
            exit 1
          fi

# Apply EQ curve to match blogging mic response to podcasting mic
ffmpeg -i input.wav -af "equalizer=f=100:width_type=h:width=50:g=-2,equalizer=f=1000:width_type=h:width=100:g=1.5,equalizer=f=10000:width_type=h:width=200:g=-1" output.wav

name,mic_type,base_price,warranty_years,expected_lifespan_years
Rode NT-USB Mini,blogging,99,2,5