Raw PCM (Pulse-Code Modulation) audio consists of sequential binary samples representing amplitude at discrete time intervals. To visualize this data as a waveform on Android, the binary stream must be decoded, normalized, and rendered using the Canvas API. The implementation follows a three-phase architecture: data ingestion, amplitude extraction, and graphical rendering.

Phase 1: Ingesting Raw PCM Bytes

PCM files tyipcally contain unheadered 16-bit signed integer samples. Efficient loading requires buffered streams to handle large audio files without exhausting the heap. The following utility method reads the binary stream into a byte array using FileChannel for optimal I/O performance.

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public static byte[] loadRawPcmBuffer(String audioPath) throws IOException {
    File sourceFile = new File(audioPath);
    byte[] rawSamples = new byte[(int) sourceFile.length()];
    try (FileInputStream inputStream = new FileInputStream(sourceFile);
         FileChannel channel = inputStream.getChannel()) {
        channel.read(ByteBuffer.wrap(rawSamples));
    }
    return rawSamples;
}

Phase 2: Converting Samples to Visual Amplitudes

Directly plotting every single PCM sample is computationally expensive and visually indistinguishable on standard displays. The optimal approach downsamples the data by calculating the maximum absolute amplitude within fixed pixel-width intervals (buckets). Each 16-bit sample consists of two bytes in little-endian format.

public static float[] extractNormalizedPeaks(byte[] pcmBuffer, int displayWidth) {
    int totalSamples = pcmBuffer.length / 2;
    float[] peakValues = new float[displayWidth];
    int samplesPerPixel = totalSamples / displayWidth;
    if (samplesPerPixel < 1) samplesPerPixel = 1;

    for (int col = 0; col < displayWidth; col++) {
        short maxAmplitude = Short.MIN_VALUE;
        int byteOffset = col * samplesPerPixel * 2;
        int boundary = Math.min(byteOffset + (samplesPerPixel * 2), pcmBuffer.length);

        for (int idx = byteOffset; idx < boundary; idx += 2) {
            short currentSample = (short) (((pcmBuffer[idx + 1] & 0xFF) << 8) | (pcmBuffer[idx] & 0xFF));
            if (Math.abs(currentSample) > Math.abs(maxAmplitude)) {
                maxAmplitude = currentSample;
            }
        }
        peakValues[col] = Math.abs(maxAmplitude) / 32768.0f;
    }
    return peakValues;
}

Phase 3: Canvas Rendering

The extracted amplitude array drives the drawing logic. A custom View iterates through the normalized values, mapping them to vertical line coordinates centered on the view's midpoint. Using Paint ensures efficient stroke rendering.

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.util.AttributeSet;
import android.view.View;

public class WaveformRenderer extends View {
    private final Paint strokeBrush = new Paint(Paint.ANTI_ALIAS_FLAG);
    private float[] amplitudeData = new float[0];

    public WaveformRenderer(Context ctx, AttributeSet attrs) {
        super(ctx, attrs);
        strokeBrush.setColor(0xFF6200EE);
        strokeBrush.setStrokeWidth(3f);
        strokeBrush.setStyle(Paint.Style.STROKE);
    }

    public void supplyData(float[] normalizedPeaks) {
        this.amplitudeData = normalizedPeaks;
        invalidate();
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        if (amplitudeData.length == 0) return;

        int centerY = getHeight() / 2;
        float horizontalStep = (float) getWidth() / (amplitudeData.length - 1);

        for (int i = 0; i < amplitudeData.length - 1; i++) {
            float startX = i * horizontalStep;
            float startY = centerY - (amplitudeData[i] * centerY);
            float endX = (i + 1) * horizontalStep;
            float endY = centerY - (amplitudeData[i + 1] * centerY);
            canvas.drawLine(startX, startY, endX, endY, strokeBrush);
        }
    }
}

Integrate these components by invoking loadRawPcmBuffer on a background thread, passing the result to extractNormalizedPeaks, and feeding the final float array into the supplyData method of the custom view instance. Ensure the rendering view matches the canvas width used during the bucket calculation to maintain proportional accuracy.