How do I monitor audio levels in real time using Java Sound API?

By I Wayan Saryada in Sound API 0 Comment

Monitoring audio levels in real time is useful for applications like voice recorders, streaming tools, or any app that displays a volume meter. In Java, this is possible using the javax.sound.sampled package, specifically with the TargetDataLine class.

In this post, you’ll learn how to:

  • Capture audio input from a microphone
  • Convert it into byte data
  • Calculate the current audio level (amplitude)
  • Display the level in real time (console bar graph style)

Step 1: Setup Required Imports

import javax.sound.sampled.*;

Step 2: Open the Microphone (TargetDataLine)

You’ll need to configure and open a TargetDataLine with a supported audio format:

AudioFormat format = new AudioFormat(44100.0f, 16, 1, true, true);
DataLine.Info info = new DataLine.Info(TargetDataLine.class, format);

TargetDataLine line = (TargetDataLine) AudioSystem.getLine(info);
line.open(format);
line.start();

Step 3: Read and Analyze Audio Data in Real Time

We’ll continuously read short chunks of audio and calculate the volume level based on the root-mean-square (RMS) of the signal.

byte[] buffer = new byte[1024];
int bytesRead;

System.out.println("Monitoring audio levels... (Ctrl+C to stop)");

while (true) {
    bytesRead = line.read(buffer, 0, buffer.length);

    // Convert bytes to amplitude
    double sum = 0.0;
    for (int i = 0; i < bytesRead; i += 2) {
        // Convert byte pair to int
        int sample = (buffer[i] << 8) | (buffer[i + 1] & 0xFF);
        sum += sample * sample;
    }

    double rms = Math.sqrt(sum / ((double) bytesRead / 2));
    double db = 20 * Math.log10(rms); // Convert to decibels

    // Visualize as a simple bar
    int level = (int) (db + 50); // Normalize range
    level = Math.max(0, Math.min(50, level));
    System.out.println("[" + "*".repeat(level) + "]");
}

Step 4: Clean Up

You should close the audio line when you’re done:

line.stop();
line.close();

Notes and Tips

  • The audio input format is 44.1 kHz, 16-bit, mono, signed, big-endian. You can change it to suit your needs.
  • The loop runs indefinitely. You may want to run it on a background thread and provide a stop condition.
  • For better GUI visualization, consider integrating with Swing or JavaFX.

Summary

You’ve just created a simple Java program that listens to microphone input and prints real-time audio level feedback. This can be used as the foundation for:

  • Voice activity detection
  • Audio visualizers
  • Mute detection
  • Noise level meters

Introduction to Java Sound API

By I Wayan Saryada in Sound API 0 Comment

The Java Sound API is a feature of the Java platform, designed to provide low-level support for audio operations such as audio playback and capture (recording), audio format conversions, and sequencing and synthesizing of MIDI (Musical Instrument Digital Interface)

Overview

Java Sound API, included in the Java SE (Standard Edition), is a powerful and flexible toolkit for creating interactive audio applications. It is designed in a way that it can be easily scalable, extended, or integrated with other application-specific solutions.

Developers can take advantage of a set of classes and interfaces that allows them to incorporate both simple and complex sound functionality into their Java programs. Provisions are also available for sophisticated control over audio mixing, audio data format conversions, and real-time streaming.

Capabilities

The Java Sound API comes with a robust set of features:

  1. Audio Playback and Recording: You can play sound data from an application, from a resource embedded within an application jar file, or from a location on the internet. You can also record sound data from different sources and store it in a variety of audio file formats.
  2. Audio Mixing: The Sound API allows you to control the audio (volume, balance, etc.) on a per-channel basis, mix multiple audio streams, and manipulate the audio data before it’s sent to an actual audio device.
  3. MIDI Sequencing and Synthesizing: Java Sound API supports MIDI, a technology widely used for music synthesis in the multimedia industry. MIDI events can be sequenced (i.e., organised in a specific order) and synthesized (i.e., embedded within the application) using the Java Sound API.

Working with Java Sound API

Understanding how data is moved and processed is crucial when working with the Java Sound API. It is designed in such a way that obtained media data from one source (like a file or a microphone). Manipulates it in some manner and then sends it to a destination (like an audio output device or a file).

Sounds start as an AudioInputStream. The Java Sound API uses an AudioSystem to provide many of the operations you may need to perform on that stream, such as obtaining a stream from an audio file.

Here is a basic example of how you can use the Java Sound API to play audio:

package org.kodejava.sound;

import javax.sound.sampled.*;

import java.net.URL;
import java.util.Objects;

public class SoundTest {
    public static void main(String[] args) {
        try {
            URL url = SoundTest.class.getResource("/sound.wav");
            AudioInputStream audioStream = AudioSystem.getAudioInputStream(Objects.requireNonNull(url));

            AudioFormat format = audioStream.getFormat();
            DataLine.Info info = new DataLine.Info(Clip.class, format);

            Clip audioClip = (Clip) AudioSystem.getLine(info);
            audioClip.open(audioStream);
            audioClip.start();

            // Keep the application running for the duration of the audio clip
            Thread.sleep(audioClip.getMicrosecondLength() / 1000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

The above example loads an audio file, gets the required information from the file, opens the clip, and starts playing it.

To read a WAV file stored in the resources directory of a Maven project, you would use the getResource method. This method is part of the standard Java Class Library and can locate any resources that are on the Java ClassPath.

In this example, we assume that sound.wav is located directly under src/main/resources. If the file is in a subdirectory, you would adjust the argument to getResource accordingly. For example, if sound.wav is in src/main/resources/audio, you would use /audio/sound.wav.

Conclusion

The Java Sound API offers powerful lower-level control over audio operations, creating more room for customization and integrations. Whether you’re looking to add simple sound effects or build an audio-rich program, the Java Sound API is a robust, intuitive, and flexible choice.