Android播放质量

我正在编写的应用程序的一部分要求我播放心音。当我使用下面的源代码播放它时，会出现几个问题

1） 它不是很响，即使我把它设置为最大音量

2） 听起来不对。听起来很多频率都被切断了

我从这个网站上得到了心音：

它是mp3类型的声音。 当我在我的电脑上播放它时，它的声音会更完美，即使我将它设置为低音量

Android不能播放某些频率范围吗？我用的是Nexus7

package com.example.heartsound;

import android.app.Activity;
import android.media.MediaPlayer;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class HeartSound extends Activity {
    MediaPlayer heartsound;
    Button play;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_heart_sound);
                //PLAY BUTTON
        play = (Button) findViewById(R.id.playButton);
        //Using MediaPlayer that will play Heart Sound
        heartsound = MediaPlayer.create(HeartSound.this, R.raw.normal_heart_sound);
        play.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                if (heartsound.isPlaying()) {
                    heartsound.stop();
                    heartsound.start();

                } else {
                    heartsound.start();

                }

            }
        });

    }

    @Override
    protected void onPause() {
        // TODO Auto-generated method stub
        super.onPause();
        heartsound.stop();
        finish();
    }



}

---

我亲自测试了ur一个音频片段，即正常的心音。当你将4000hz频率设置为最大Eq电平时，听起来非常美妙。 因此，只需测试每个音频片段，并为每个片段设置均衡器

您还可以使用备份设置并再次使用。 使用共享优先级，并为每个优先级保存频带和均衡级别。当你开始播放该乐队的声音设置时

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;

public class MainActivity extends Activity {
    private static final String TAG = "AudioFxDemo";

    private static final float VISUALIZER_HEIGHT_DIP = 50f;

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

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

    @Override
    public void onCreate(Bundle icicle) {
        super.onCreate(icicle);

        setVolumeControlStream(AudioManager.STREAM_MUSIC);

        mStatusTextView = new TextView(this);
        ScrollView scrollView= new ScrollView(this);
        mLinearLayout = new LinearLayout(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(new MediaPlayer.OnCompletionListener() {
            public void onCompletion(MediaPlayer mediaPlayer) {
                mVisualizer.setEnabled(false);
                mMediaPlayer.start();
            }
        });

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

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

        TextView eqTextView = new TextView(this);
        eqTextView.setText("Equalizer:");
        mLinearLayout.addView(eqTextView);

        short bands = mEqualizer.getNumberOfBands();

        final short minEQLevel = mEqualizer.getBandLevelRange()[0];
        final short maxEQLevel = mEqualizer.getBandLevelRange()[1];

        for (short i = 0; i < bands; i++) {
            final short band = i;

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

            LinearLayout row = new LinearLayout(this);
            row.setOrientation(LinearLayout.HORIZONTAL);

            TextView minDbTextView = new TextView(this);
            minDbTextView.setLayoutParams(new ViewGroup.LayoutParams(
                    ViewGroup.LayoutParams.WRAP_CONTENT,
                    ViewGroup.LayoutParams.WRAP_CONTENT));
            minDbTextView.setText((minEQLevel / 100) + " dB");

            TextView maxDbTextView = new TextView(this);
            maxDbTextView.setLayoutParams(new ViewGroup.LayoutParams(
                    ViewGroup.LayoutParams.WRAP_CONTENT,
                    ViewGroup.LayoutParams.WRAP_CONTENT));
            maxDbTextView.setText((maxEQLevel / 100) + " dB");

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

            bar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
                public void onProgressChanged(SeekBar seekBar, int progress,
                        boolean fromUser) {
                    mEqualizer.setBandLevel(band, (short) (progress + minEQLevel));
                }

                public void onStartTrackingTouch(SeekBar seekBar) {}
                public void onStopTrackingTouch(SeekBar seekBar) {}
            });

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

            mLinearLayout.addView(row);
        }
    }

    private void setupVisualizerFxAndUI() {
        // Create a VisualizerView (defined below), which will render the simplified audio
        // wave form to a Canvas.
        mVisualizerView = new VisualizerView(this);
        mVisualizerView.setLayoutParams(new ViewGroup.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 = new Visualizer(mMediaPlayer.getAudioSessionId());
        mVisualizer.setCaptureSize(Visualizer.getCaptureSizeRange()[1]);
        mVisualizer.setDataCaptureListener(new Visualizer.OnDataCaptureListener() {
            public void onWaveFormDataCapture(Visualizer visualizer, byte[] bytes,
                    int samplingRate) {
                mVisualizerView.updateVisualizer(bytes);
            }

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

    @Override
    protected void onPause() {
        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 }
 */
class VisualizerView extends View {
    private byte[] mBytes;
    private float[] mPoints;
    private Rect mRect = new Rect();

    private Paint mForePaint = new Paint();

    public VisualizerView(Context context) {
        super(context);
        init();
    }

    private void init() {
        mBytes = null;

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

    public void updateVisualizer(byte[] bytes) {
        mBytes = bytes;
        invalidate();
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);

        if (mBytes == null) {
            return;
        }

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

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

        for (int i = 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);
    }
}

package com.example.demoact；
导入android.app.Activity；
导入android.content.Context；
导入android.graphics.Canvas；
导入android.graphics.Color；
导入android.graphics.Paint；
导入android.graphics.Rect；
导入android.media.AudioManager；
导入android.media.MediaPlayer；
导入android.media.audiofx.Equalizer；
导入android.media.audiofx.Visualizer；
导入android.os.Bundle；
导入android.util.Log；
导入android.view.Gravity；
导入android.view.view；
导入android.view.ViewGroup；
导入android.widget.LinearLayout；
导入android.widget.ScrollView；
导入android.widget.SeekBar；
导入android.widget.TextView；
公共类MainActivity扩展了活动{
私有静态最终字符串标记=“AudioFxDemo”；
专用静态最终浮子可视化仪\u高度\u倾角=50f；
私有媒体层；
专用可视化工具mVisualizer；
专用均衡器；
私人线路布局；
私有可视化视图mVisualizerView；
私有文本视图mStatusTextView；
@凌驾
创建公共空间（捆绑冰柱）{
超级冰柱；
setVolumeControlStream（AudioManager.STREAM_MUSIC）；
mStatusTextView=新文本视图（此）；
ScrollView ScrollView=新的ScrollView（此）；
mLinearLayout=新的线性布局（此）；
scrollView.addView（mLinearLayout）；
mLinearLayout.setOrientation（LinearLayout.VERTICAL）；
mLinearLayout.addView（mStatusTextView）；
setContentView（滚动视图）；
//创建MediaPlayer
mMediaPlayer=MediaPlayer.create（这个，R.raw.normal）；
Log.d（标记“MediaPlayer音频会话ID:+mMediaPlayer.getAudioSessionId（））；
setupVisualizerFxAndUI（）；
setupequalifierxandui（）；
//确保仅当您确实希望接收数据时才启用可视化工具，并且
//当接收数据有意义时。
mVisualizer.setEnabled（true）；
//当流结束时，我们不需要收集更多的数据。我们不需要在
//setupVisualizerFxAndUI，因为我们可能希望有更多与可视化工具无关的代码
//在这个回调中。
mmediplayer.setOnCompletionListener（新的MediaPlayer.OnCompletionListener（）{
完成时的公共作废（MediaPlayer MediaPlayer）{
mVisualizer.setEnabled（false）；
mmediplayer.start（）；
}
});
mmediplayer.start（）；
mStatusTextView.setText（“播放音频…”）；
}
私有void setuperfxandui（）{
//创建均衡器对象（AudioEffect子类）并将其连接到我们的媒体播放器，
//具有默认优先级（0）。
mEqualizer=新均衡器（0，mmediplayer.getAudioSessionId（））；
mEqualizer.setEnabled（true）；
TextView eqTextView=新的TextView（此）；
setText（“均衡器：”）；
mLinearLayout.addView（eqTextView）；
short bands=mEqualizer.getNumberOfBands（）；
final short minEQLevel=mEqualizer.getBandLevelRange（）[0]；
final short maxEQLevel=mEqualizer.getBandLevelRange（）[1]；
用于（短i=0；i