Android Playback Quality

A portion of an application that I am writing requires me to play a heart sound. When I play it using the source below, several problems arise. 1) It's not very loud, even when I

Solution 1:

I Tested personally with ur one audio clip namely normal_heart_sounds . when u set 4000hz frequency band to maximum Eq level , it sounds very nice. So just test every audio clip and set equalizer for each one of this.

You can also use Equalizer.Settings to back up settings and use them again . Use shared pref. and save band and Eq level for each of them . and when u start playing sound setup Eqalizer with that band .

package com.example.demoact;

import android.app.Activity;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Rect;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.media.audiofx.Equalizer;
import android.media.audiofx.Visualizer;
import android.os.Bundle;
import android.util.Log;
import android.view.Gravity;
import android.view.View;
import android.view.ViewGroup;
import android.widget.LinearLayout;
import android.widget.ScrollView;
import android.widget.SeekBar;
import android.widget.TextView;

publicclassMainActivityextendsActivity {
    privatestaticfinalStringTAG="AudioFxDemo";

    privatestaticfinalfloatVISUALIZER_HEIGHT_DIP=50f;

    private MediaPlayer mMediaPlayer;
    private Visualizer mVisualizer;
    private Equalizer mEqualizer;

    private LinearLayout mLinearLayout;
    private VisualizerView mVisualizerView;
    private TextView mStatusTextView;

    @OverridepublicvoidonCreate(Bundle icicle) {
        super.onCreate(icicle);

        setVolumeControlStream(AudioManager.STREAM_MUSIC);

        mStatusTextView = newTextView(this);
        ScrollView scrollView= newScrollView(this);
        mLinearLayout = newLinearLayout(this);
        scrollView.addView(mLinearLayout);
        mLinearLayout.setOrientation(LinearLayout.VERTICAL);
        mLinearLayout.addView(mStatusTextView);

        setContentView(scrollView);

        // Create the MediaPlayer
        mMediaPlayer = MediaPlayer.create(this, R.raw.normal);
        Log.d(TAG, "MediaPlayer audio session ID: " + mMediaPlayer.getAudioSessionId());

        setupVisualizerFxAndUI();
        setupEqualizerFxAndUI();

        // Make sure the visualizer is enabled only when you actually want to receive data, and// when it makes sense to receive data.
        mVisualizer.setEnabled(true);

        // When the stream ends, we don't need to collect any more data. We don't do this in// setupVisualizerFxAndUI because we likely want to have more, non-Visualizer related code// in this callback.
        mMediaPlayer.setOnCompletionListener(newMediaPlayer.OnCompletionListener() {
            publicvoidonCompletion(MediaPlayer mediaPlayer) {
                mVisualizer.setEnabled(false);
                mMediaPlayer.start();
            }
        });

        mMediaPlayer.start();
        mStatusTextView.setText("Playing audio...");
    }

    privatevoidsetupEqualizerFxAndUI() {
        // Create the Equalizer object (an AudioEffect subclass) and attach it to our media player,// with a default priority (0).
        mEqualizer = newEqualizer(0, mMediaPlayer.getAudioSessionId());
        mEqualizer.setEnabled(true);

        TextVieweqTextView=newTextView(this);
        eqTextView.setText("Equalizer:");
        mLinearLayout.addView(eqTextView);

        shortbands= mEqualizer.getNumberOfBands();

        finalshortminEQLevel= mEqualizer.getBandLevelRange()[0];
        finalshortmaxEQLevel= mEqualizer.getBandLevelRange()[1];

        for (shorti=0; i < bands; i++) {
            finalshortband= i;

            TextViewfreqTextView=newTextView(this);
            freqTextView.setLayoutParams(newViewGroup.LayoutParams(
                    ViewGroup.LayoutParams.FILL_PARENT,
                    ViewGroup.LayoutParams.WRAP_CONTENT));
            freqTextView.setGravity(Gravity.CENTER_HORIZONTAL);
            freqTextView.setText((mEqualizer.getCenterFreq(band) / 1000) + " Hz");
            mLinearLayout.addView(freqTextView);

            LinearLayoutrow=newLinearLayout(this);
            row.setOrientation(LinearLayout.HORIZONTAL);

            TextViewminDbTextView=newTextView(this);
            minDbTextView.setLayoutParams(newViewGroup.LayoutParams(
                    ViewGroup.LayoutParams.WRAP_CONTENT,
                    ViewGroup.LayoutParams.WRAP_CONTENT));
            minDbTextView.setText((minEQLevel / 100) + " dB");

            TextViewmaxDbTextView=newTextView(this);
            maxDbTextView.setLayoutParams(newViewGroup.LayoutParams(
                    ViewGroup.LayoutParams.WRAP_CONTENT,
                    ViewGroup.LayoutParams.WRAP_CONTENT));
            maxDbTextView.setText((maxEQLevel / 100) + " dB");

            LinearLayout.LayoutParamslayoutParams=newLinearLayout.LayoutParams(
                    ViewGroup.LayoutParams.FILL_PARENT,
                    ViewGroup.LayoutParams.WRAP_CONTENT);
            layoutParams.weight = 1;
            SeekBarbar=newSeekBar(this);
            bar.setLayoutParams(layoutParams);
            bar.setMax(maxEQLevel - minEQLevel);
            bar.setProgress(mEqualizer.getBandLevel(band));

            bar.setOnSeekBarChangeListener(newSeekBar.OnSeekBarChangeListener() {
                publicvoidonProgressChanged(SeekBar seekBar, int progress,
                        boolean fromUser) {
                    mEqualizer.setBandLevel(band, (short) (progress + minEQLevel));
                }

                publicvoidonStartTrackingTouch(SeekBar seekBar) {}
                publicvoidonStopTrackingTouch(SeekBar seekBar) {}
            });

            row.addView(minDbTextView);
            row.addView(bar);
            row.addView(maxDbTextView);

            mLinearLayout.addView(row);
        }
    }

    privatevoidsetupVisualizerFxAndUI() {
        // Create a VisualizerView (defined below), which will render the simplified audio// wave form to a Canvas.
        mVisualizerView = newVisualizerView(this);
        mVisualizerView.setLayoutParams(newViewGroup.LayoutParams(
                ViewGroup.LayoutParams.FILL_PARENT,
                (int)(VISUALIZER_HEIGHT_DIP * getResources().getDisplayMetrics().density)));
        mLinearLayout.addView(mVisualizerView);

        // Create the Visualizer object and attach it to our media player.
        mVisualizer = newVisualizer(mMediaPlayer.getAudioSessionId());
        mVisualizer.setCaptureSize(Visualizer.getCaptureSizeRange()[1]);
        mVisualizer.setDataCaptureListener(newVisualizer.OnDataCaptureListener() {
            publicvoidonWaveFormDataCapture(Visualizer visualizer, byte[] bytes,
                    int samplingRate) {
                mVisualizerView.updateVisualizer(bytes);
            }

            publicvoidonFftDataCapture(Visualizer visualizer, byte[] bytes, int samplingRate) {}
        }, Visualizer.getMaxCaptureRate() / 2, true, false);
    }

    @OverrideprotectedvoidonPause() {
        super.onPause();

        if (isFinishing() && mMediaPlayer != null) {
            mVisualizer.release();
            mEqualizer.release();
            mMediaPlayer.release();
            mMediaPlayer = null;
        }
    }
}

/**
 * A simple class that draws waveform data received from a
 * {@link Visualizer.OnDataCaptureListener#onWaveFormDataCapture }
 */classVisualizerViewextendsView {
    privatebyte[] mBytes;
    privatefloat[] mPoints;
    privateRectmRect=newRect();

    privatePaintmForePaint=newPaint();

    publicVisualizerView(Context context) {
        super(context);
        init();
    }

    privatevoidinit() {
        mBytes = null;

        mForePaint.setStrokeWidth(1f);
        mForePaint.setAntiAlias(true);
        mForePaint.setColor(Color.rgb(0, 128, 255));
    }

    publicvoidupdateVisualizer(byte[] bytes) {
        mBytes = bytes;
        invalidate();
    }

    @OverrideprotectedvoidonDraw(Canvas canvas) {
        super.onDraw(canvas);

        if (mBytes == null) {
            return;
        }

        if (mPoints == null || mPoints.length < mBytes.length * 4) {
            mPoints = newfloat[mBytes.length * 4];
        }

        mRect.set(0, 0, getWidth(), getHeight());

        for (inti=0; i < mBytes.length - 1; i++) {
            mPoints[i * 4] = mRect.width() * i / (mBytes.length - 1);
            mPoints[i * 4 + 1] = mRect.height() / 2
                    + ((byte) (mBytes[i] + 128)) * (mRect.height() / 2) / 128;
            mPoints[i * 4 + 2] = mRect.width() * (i + 1) / (mBytes.length - 1);
            mPoints[i * 4 + 3] = mRect.height() / 2
                    + ((byte) (mBytes[i + 1] + 128)) * (mRect.height() / 2) / 128;
        }

        canvas.drawLines(mPoints, mForePaint);
    }
}