How to calculate the audio amplitude in real time (android)

Question

I am working on an Android app where I need to calculate the audio amplitude in real time. As of now I am using MediaPlayer to play the track. Is there a way to calculate its amplitude in real time while playing it?

Here is my code:

int counterPlayer = 0;
static double[] drawingBufferForPlayer = new double[100];
private byte[] mBytes;
private byte[] mFFTBytes;
private Visualizer mVisualizer;

public void link(final MediaPlayer player)
{
    if(player == null)
    {
        throw new NullPointerException("Cannot link to null MediaPlayer");
    }

    // Create the Visualizer object and attach it to our media player.
    mVisualizer = new Visualizer(player.getAudioSessionId());
    mVisualizer.setCaptureSize(Visualizer.getCaptureSizeRange()[1]);
    //mVisualizer.setMeasurementMode(Visualizer.MEASUREMENT_MODE_PEAK_RMS);

    // Pass through Visualizer data to VisualizerView
    Visualizer.OnDataCaptureListener captureListener = new Visualizer.OnDataCaptureListener()
    {
        @Override
        public void onWaveFormDataCapture(Visualizer visualizer, byte[] bytes,
                                          int samplingRate)
        {
            updateVisualizer(bytes);
        }

        @Override
        public void onFftDataCapture(Visualizer visualizer, byte[] bytes,
                                     int samplingRate)
        {
            updateVisualizerFFT(bytes);
        }
    };

    mVisualizer.setDataCaptureListener(captureListener,
            Visualizer.getMaxCaptureRate() / 2, true, true);
    // Enabled Visualizer and disable when we're done with the stream
    mVisualizer.setEnabled(true);
    player.setOnCompletionListener(new MediaPlayer.OnCompletionListener()
    {
        @Override
        public void onCompletion(MediaPlayer mediaPlayer)
        {
            mVisualizer.setEnabled(false);
        }
    });
}
public void updateVisualizer(byte[] bytes) {

    int t = calculateRMSLevel(bytes);
    Visualizer.MeasurementPeakRms measurementPeakRms = new Visualizer.MeasurementPeakRms();
    int x = mVisualizer.getMeasurementPeakRms(measurementPeakRms);
    mBytes = bytes;
}

/**
 * Pass FFT data to the visualizer. Typically this will be obtained from the
 * Android Visualizer.OnDataCaptureListener call back. See
 * {@link android.media.audiofx.Visualizer.OnDataCaptureListener#onFftDataCapture }
 * @param bytes
 */
public void updateVisualizerFFT(byte[] bytes) {
    int t = calculateRMSLevel(bytes);
    mFFTBytes = bytes;
}
public int calculateRMSLevel(byte[] audioData) {
    //System.out.println("::::: audioData :::::"+audioData);
    double amplitude = 0;
    for (int i = 0; i < audioData.length; i++) {
        amplitude += Math.abs((double) (audioData[i] / 32768.0));
    }
    amplitude = amplitude / audioData.length;
    //Add this data to buffer for display
    if (counterPlayer < 100) {
        drawingBufferForPlayer[counterPlayer++] = amplitude;
    } else {
        for (int k = 0; k < 99; k++) {
            drawingBufferForPlayer[k] = drawingBufferForPlayer[k + 1];
        }
        drawingBufferForPlayer[99] = amplitude;
    }

    updateBufferDataPlayer(drawingBufferForPlayer);
    setDataForPlayer(100,100);

    return (int)amplitude;
}

Since I need a value between 0-1, So I divide it 32768 (32byte) — Manzar Hussain Siddique, Jan 29 '15 at 13:25
Did you try the answer here: http://stackoverflow.com/questions/17486222/animate-progressbar-by-getting-the-amplitude-of-mediaplayer — Shai Levy, Jan 29 '15 at 13:32
I need to read the audio buffer, so that I can control the amplitude display rate. I tried audiomanager but was not working properly. Can you share some sample code regarding this. — Manzar Hussain Siddique, Jan 29 '15 at 13:32

score 9 · Answer 1 · answered Jan 29 '15 at 17:52

9

Your problem lies in the improper conversion of 16-bit samples to double precision. First you need to convert two adjacent bytes to an int and then do the conversion to double. For example

double amplitude = 0;
for (int i = 0; i < audioData.length/2; i++) {
    double y = (audioData[i*2] | audioData[i*2+1] << 8) / 32768.0
    // depending on your endianness:
    // double y = (audioData[i*2]<<8 | audioData[i*2+1]) / 32768.0
    amplitude += Math.abs(y);
}
amplitude = amplitude / audioData.length / 2;

Please note that your code and my answer are both assuming one channel of data. If you have more than one channel you'll need to be careful to separate the amplitudes as the data will be interleaved L,R,L,R (after the conversion to double).

answered Jan 29 '15 at 17:52

jaket

9,140
2
25
44

You, sir, are a genius – SlyOtis Aug 07 '18 at 12:52
what does 32768 represent here? – Fahad Saleem Mar 25 '20 at 12:23
32768 = abs(minimum value of short data type): https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html – Michal Vician Nov 05 '21 at 12:55

score 3 · Answer 2 · answered Sep 06 '15 at 10:56

3

Did you try with that solution?

// Calc amplitude for this waveform
float accumulator = 0;
for (int i = 0; i < data.bytes.length - 1; i++) {
  accumulator += Math.abs(data.bytes[i]);
}

float amp = accumulator/(128 * data.bytes.length);

answered Sep 06 '15 at 10:56

Jame

3,746
6
52
101

score 0 · Answer 3 · answered Jan 29 '15 at 14:09

0

Use this example:

http://androidexample.com/Detect_Noise_Or_Blow_Sound_-_Set_Sound_Frequency_Thersold/index.php?view=article_discription&aid=108&aaid=130

Hope this solves your problem....cheerz

answered Jan 29 '15 at 14:09

asdec90

1,070
2
13
28

How to calculate the audio amplitude in real time (android)

3 Answers3

Linked