Java音频处理技术问询：分贝计算、录音及WAV文件分贝分析

Hey there! Let's break down how to handle audio recording, real-time decibel calculation, and analyzing existing WAV files in Java using built-in libraries—no external dependencies needed.

Audio Recording with Java #

We'll use Java's javax.sound.sampled package to capture audio and save it as a WAV file. Here's a complete working example:

import javax.sound.sampled.*;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class AudioRecorder {
    private static final int SAMPLE_RATE = 44100; // Standard CD quality
    private static final int BIT_DEPTH = 16;
    private static final int CHANNELS = 1; // Mono (use 2 for stereo)
    private static final boolean SIGNED = true;
    private static final boolean BIG_ENDIAN = false;

    public static void main(String[] args) {
        AudioFormat format = new AudioFormat(SAMPLE_RATE, BIT_DEPTH, CHANNELS, SIGNED, BIG_ENDIAN);
        DataLine.Info info = new DataLine.Info(TargetDataLine.class, format);

        if (!AudioSystem.isLineSupported(info)) {
            System.err.println("Audio line not supported by your system");
            System.exit(1);
        }

        try (TargetDataLine line = (TargetDataLine) AudioSystem.getLine(info);
             FileOutputStream out = new FileOutputStream(new File("recording.wav"))) {

            line.open(format);
            line.start();
            System.out.println("Recording... Press Ctrl+C to stop");

            byte[] buffer = new byte[4096]; // Adjust buffer size for latency tradeoffs
            int bytesRead;

            while (!Thread.currentThread().isInterrupted()) {
                bytesRead = line.read(buffer, 0, buffer.length);
                if (bytesRead > 0) {
                    out.write(buffer, 0, bytesRead);
                    // Uncomment below for real-time dB calculation during recording
                    // double dB = calculateDecibels(buffer, format);
                    // System.out.printf("Current dB: %.2f dBFS%n", dB);
                }
            }

            line.stop();
            line.close();
            System.out.println("Recording saved to recording.wav");

        } catch (LineUnavailableException | IOException e) {
            e.printStackTrace();
        }
    }
}

Decibel Calculation Basics #

For digital audio, we typically calculate dBFS (decibels full scale) where 0 dB is the maximum possible amplitude. The formula is:
dBFS = 20 * log10(RMS / MaxSampleValue)

• RMS: Root Mean Square of the audio samples (measures average amplitude)
• MaxSampleValue: For 16-bit audio, this is 32767 (the highest positive value)

Here's the reusable calculation method:

private static double calculateDecibels(byte[] buffer, AudioFormat format) {
    int sampleSizeInBytes = format.getSampleSizeInBits() / 8;
    int numSamples = buffer.length / sampleSizeInBytes;
    double sumOfSquares = 0.0;

    for (int i = 0; i < buffer.length; i += sampleSizeInBytes) {
        short sample = 0;
        // Convert raw bytes to signed sample value
        if (sampleSizeInBytes == 2) {
            // 16-bit sample
            sample = (short) ((buffer[i] & 0xFF) | (buffer[i+1] << 8));
            if (format.isBigEndian()) sample = Short.reverseBytes(sample);
        } else if (sampleSizeInBytes == 1) {
            // 8-bit unsigned sample, convert to signed
            sample = (short) ((buffer[i] & 0xFF) - 128);
        }

        // Normalize sample to range [-1.0, 1.0]
        double normalizedSample = sample / (double) Short.MAX_VALUE;
        sumOfSquares += normalizedSample * normalizedSample;
    }

    double rms = Math.sqrt(sumOfSquares / numSamples);
    if (rms == 0) return -Double.MAX_VALUE; // Avoid log10(0) error
    return 20 * Math.log10(rms);
}

Real-time Decibel Calculation #

To get live dB readings while recording, simply uncomment the lines in the recording loop above. The buffer size determines how often updates occur:

• Smaller buffers (e.g., 1024 bytes) = more frequent updates but higher CPU usage
• Larger buffers (e.g., 8192 bytes) = smoother readings with less overhead

Decibel Calculation for Existing WAV Files #

Use AudioSystem to read the WAV file, extract its samples, and run the same dB calculation:

import javax.sound.sampled.*;
import java.io.File;
import java.io.IOException;

public class WavDecibelAnalyzer {
    public static void main(String[] args) {
        File wavFile = new File("recording.wav");
        try (AudioInputStream ais = AudioSystem.getAudioInputStream(wavFile)) {
            AudioFormat format = ais.getFormat();
            long frameLength = ais.getFrameLength();
            int frameSize = format.getFrameSize();
            byte[] buffer = new byte[(int) frameLength * frameSize];

            ais.read(buffer);
            double overallDb = calculateDecibels(buffer, format);
            System.out.printf("Overall dB of WAV file: %.2f dBFS%n", overallDb);

        } catch (UnsupportedAudioFileException | IOException e) {
            e.printStackTrace();
        }
    }

    // Reuse the calculateDecibels method from AudioRecorder
    private static double calculateDecibels(byte[] buffer, AudioFormat format) {
        // Same implementation as above
    }
}

Notes #

• For stereo audio: Modify the sample extraction to average left/right channels before calculating RMS for combined dB, or compute separate dB values for each channel.
• Absolute dB (not dBFS): Requires microphone calibration (since digital samples are relative to hardware input levels). dBFS is the standard for digital audio analysis.

内容的提问来源于stack exchange，提问作者Ihab Khaled Shhadat