求解决pcm播放问题

weng4570 发布于 2013/08/08 16:27
阅读 1K+
收藏 1

7~LHGL`((@G{{1GD2VLVL.jpg (30.48 KB, 下载次数: 0)

工程图

工程图



使用audio来录音,使用AudioTrack来播放,发现播放出来的声音是吱吱的那种杂音。这是怎么回事呢?录音代码中采样率8000的时候播放pcm数据是吱吱的声音;但是44100的时候没有声音;怎么解决播放录的声音;



public class AudioPlayerDemoActivity extends Activity implements OnClickListener{
    /** Called when the activity is first created. */

        private TextView mTextViewState;                                // 播放状态
        
        private Button mBtnPlayButton;                                        // 播放
        
        private Button mBtnPauseButton;                                        // 暂停
        
        private Button mBtnStopButton;                                        // 停止
        
        private AudioPlayer mAudioPlayer;                                // 播放器
        
        private Handler mHandler;

    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        initView();

        initLogic();
    }




    @Override
        protected void onDestroy() {
                // TODO Auto-generated method stub
                super.onDestroy();
                
                mAudioPlayer.release();
        }




        public void initView()
    {
            mTextViewState = (TextView) findViewById(R.id.tvPlayState);
            
            mBtnPlayButton = (Button) findViewById(R.id.buttonPlay);
            mBtnPlayButton.setOnClickListener(this);
            
            mBtnPauseButton = (Button) findViewById(R.id.buttonPause);
            mBtnPauseButton.setOnClickListener(this);
            
            mBtnStopButton = (Button) findViewById(R.id.buttonStop);
            mBtnStopButton.setOnClickListener(this);
    }

    public void initLogic()
    {
            mHandler = new Handler()
            {

                        @Override
                        public void handleMessage(Message msg) {
                                // TODO Auto-generated method stub
                                switch(msg.what)
                                {
                                case AudioPlayer.STATE_MSG_ID:
                                        showState((Integer)msg.obj);
                                        break;
                                }
                        }
                    
                    
            };
            
            mAudioPlayer = new AudioPlayer(mHandler);
            
            // 获取音频参数
            AudioParam audioParam = getAudioParam();
            mAudioPlayer.setAudioParam(audioParam);
            
            // 获取音频数据
            byte[] data = getPCMData();
            mAudioPlayer.setDataSource(data);
            
            // 音频源就绪
            mAudioPlayer.prepare();
            
            if (data == null)
            {
                    mTextViewState.setText(filePath + ":该路径下不存在文件!");
            }
    }


    @Override
        public void onClick(View view) {
                // TODO Auto-generated method stub
                switch(view.getId())
                {
                case R.id.buttonPlay:
                        play();
                        break;
                case R.id.buttonPause:
                        pause();
                        break;
                case R.id.buttonStop:
                        stop();
                        break;
                }
        }

    public void play()
    {
            mAudioPlayer.play();
    }

    public void pause()
    {
            mAudioPlayer.pause();
    }

    public void stop()
    {
            mAudioPlayer.stop();
    }


    public void showState(int state)
    {
            String showString = "";
            
            switch(state)
            {
            case PlayState.MPS_UNINIT:
                    showString = "MPS_UNINIT";
                    break;
            case PlayState.MPS_PREPARE:
                    showString = "MPS_PREPARE";
                    break;
            case PlayState.MPS_PLAYING:
                    showString = "MPS_PLAYING";
                    break;
            case PlayState.MPS_PAUSE:
                    showString = "MPS_PAUSE";
                    break;
            }
            
            showState(showString);
    }


    public void showState(String str)
    {
            mTextViewState.setText(str);
    }  
        
        
         /*
     * 获得PCM音频数据参数
     */
        public AudioParam getAudioParam()
        {
                AudioParam audioParam = new AudioParam();
            audioParam.mFrequency = 44100;
            audioParam.mChannel = AudioFormat.CHANNEL_CONFIGURATION_STEREO;
            audioParam.mSampBit = AudioFormat.ENCODING_PCM_16BIT;
            
            return audioParam;
        }
        
        
        
        String  filePath  = Environment.getExternalStorageDirectory().getAbsolutePath() + "/testmusic.pcm";
    /*
     * 获得PCM音频数据
     */
    public byte[] getPCMData()
    {
            
            File file = new File(filePath);
            if (file == null){
                    return null;
            }
            
            FileInputStream inStream;
                try {
                        inStream = new FileInputStream(file);
                } catch (FileNotFoundException e) {
                        e.printStackTrace();
                        return null;
                }
                
                byte[] data_pack = null;
            if (inStream != null){
                    long size = file.length();
                    
                    data_pack = new byte[(int) size];
                    try {
                                inStream.read(data_pack);
                        } catch (IOException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                                return null;
                        }

            }
            
            return data_pack;
    }

}



下面这个是AudioPlaye
package com.genius.demo;

import android.media.AudioManager;
import android.media.AudioTrack;
import android.os.Handler;
import android.os.Message;
import android.provider.ContactsContract.Contacts.Data;
import android.util.Log;

public class AudioPlayer implements IPlayComplete{

        private final static String TAG = "AudioPlayer";
        
        public final static int    STATE_MSG_ID = 0x0010;
        
        private Handler    mHandler;
        
        private AudioParam mAudioParam;                                                        // 音频参数
        
        private byte[]            mData;                                                                // 音频数据
        
        private AudioTrack mAudioTrack;                                                        // AudioTrack对象
        
        private boolean    mBReady = false;                                                // 播放源是否就绪
        
        private PlayAudioThread mPlayAudioThread;                                // 播放线程
        
        public AudioPlayer(Handler handler)
        {
                mHandler = handler;
        }
        
        public AudioPlayer(Handler handler,AudioParam audioParam)
        {
                mHandler = handler;
                setAudioParam(audioParam);        
        }
        
        /*
         * 设置音频参数
         */
        public void setAudioParam(AudioParam audioParam)
        {
                mAudioParam = audioParam;
        }
        
        /*
         * 设置音频源
         */
        public void setDataSource(byte[] data)
        {
                mData = data;                
        }
        
        
        /*
         *  就绪播放源
         */
        public boolean prepare()
        {
                if (mData == null || mAudioParam == null)
                {
                        return false;
                }
                
                if (mBReady == true)
                {
                        return true;
                }
                
                try {
                        createAudioTrack();
                } catch (Exception e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                        return false;
                }
                                
                
                mBReady = true;
                
                setPlayState(PlayState.MPS_PREPARE);
                
                return true;
        }
        
        /*
         * 释放播放源
         */
        public boolean release()
        {
                stop();

                releaseAudioTrack();
        
                mBReady = false;
                
                setPlayState(PlayState.MPS_UNINIT);
                
                return true;
        }
        
        /*
         * 播放
         */
        public boolean play()
        {
                if (mBReady == false)
                {
                        return false;
                }
                
                
                switch(mPlayState)
                {
                case PlayState.MPS_PREPARE:
                        mPlayOffset = 0;
                        setPlayState(PlayState.MPS_PLAYING);
                        startThread();        
                        break;
                case PlayState.MPS_PAUSE:
                        setPlayState(PlayState.MPS_PLAYING);
                        startThread();        
                        break;
                }
                
                
                return true;
        }
        
        /*
         * 暂停
         */
        public boolean pause()
        {

                if (mBReady == false)
                {
                        return false;
                }
                
                if (mPlayState == PlayState.MPS_PLAYING)
                {
                        setPlayState(PlayState.MPS_PAUSE);
                        stopThread();
                }
                
                return true;
        }
        
        /*
         * 停止
         */
        public boolean stop()
        {

                if (mBReady == false)
                {
                        return false;
                }
                
                setPlayState(PlayState.MPS_PREPARE);
                stopThread();
                
                return true;
                
                
                
        }
        
        
        private synchronized void setPlayState(int state)
        {
                mPlayState = state;
                
                if (mHandler != null)
                {
                        Message msg = mHandler.obtainMessage(STATE_MSG_ID);
                        msg.obj = mPlayState;
                        msg.sendToTarget();
                }
        }
        

        private void createAudioTrack() throws Exception
        {
                
                // 获得构建对象的最小缓冲区大小                                         一般情况 minBufferSize  会导致播出吱吱声音。
                int minBufSize = AudioTrack.getMinBufferSize(mAudioParam.mFrequency, 
                                                                                                        mAudioParam.mChannel,
                                                                                                        mAudioParam.mSampBit);
                
                
                mPrimePlaySize = minBufSize * 2;
                Log.d(TAG, "mPrimePlaySize = " + mPrimePlaySize);
                
//                         STREAM_ALARM:警告声
//                         STREAM_MUSCI:音乐声,例如music等
//                         STREAM_RING:铃声
//                         STREAM_SYSTEM:系统声音
//                         STREAM_VOCIE_CALL:电话声音
                mAudioTrack = new AudioTrack(AudioManager.STREAM_MUSIC,
                                                                        mAudioParam.mFrequency, 
                                                                        mAudioParam.mChannel, 
                                                                        mAudioParam.mSampBit, 
                                                                        minBufSize,
                                                                        AudioTrack.MODE_STREAM);
//                                AudioTrack中有MODE_STATIC和MODE_STREAM两种分类。
//                      STREAM的意思是由用户在应用程序通过write方式把数据一次一次得写到audiotrack中。
//                                这个和我们在socket中发送数据一样,应用层从某个地方获取数据,例如通过编解码得到PCM数据,然后write到audiotrack。
//                                这种方式的坏处就是总是在JAVA层和Native层交互,效率损失较大。
//                                而STATIC的意思是一开始创建的时候,就把音频数据放到一个固定的buffer,然后直接传给audiotrack,
//                                后续就不用一次次得write了。AudioTrack会自己播放这个buffer中的数据。
//                                这种方法对于铃声等内存占用较小,延时要求较高的声音来说很适用。
                
                

        }
        
        private void releaseAudioTrack(){
                if (mAudioTrack != null){
                        mAudioTrack.stop();                                               
                        mAudioTrack.release();
                        mAudioTrack = null;
                }
                
        }
        
        
        private void startThread()
        {
                if (mPlayAudioThread == null)
                {
                        mThreadExitFlag = false;
                        mPlayAudioThread = new PlayAudioThread();
                        mPlayAudioThread.start();
                }
        }
        
        private void stopThread()
        {
                if (mPlayAudioThread != null)
                {
                        mThreadExitFlag = true;
                        mPlayAudioThread = null;
                }
        }

        
        private boolean mThreadExitFlag = false;                                                // 线程退出标志
        
        private int     mPrimePlaySize = 0;                                                                // 较优播放块大小
        
        private int         mPlayOffset = 0;                                                                // 当前播放位置
        
        private int     mPlayState = 0;                                                                        // 当前播放状态
        
        
        /*
         *  播放音频的线程
         */
        class PlayAudioThread extends Thread
        {

                
                @Override
                public void run() {
                        // TODO Auto-generated method stub

                        
                        Log.d(TAG, "PlayAudioThread run mPlayOffset = " + mPlayOffset);
                        
                        mAudioTrack.play();        
                        
                                while(true)
                                {                                                                                        
                                        
                                        if (mThreadExitFlag == true)
                                        {
                                                break;
                                        }                                        
                                        
                                        try {
                                                
                                                int size = mAudioTrack.write(mData, mPlayOffset, mPrimePlaySize);
                                        
                                                mPlayOffset += mPrimePlaySize;
                
                                                
                                        } catch (Exception e) {
                                                // TODO: handle exception
                                                e.printStackTrace();
                                                AudioPlayer.this.onPlayComplete();
                                                break;
                                        }
                        
                                        if (mPlayOffset >= mData.length)
                                        {                        
                                                AudioPlayer.this.onPlayComplete();
                                                break;
                                        }
                                        
                                        
                                }
                                
                        mAudioTrack.stop();        
                        
                
                        Log.d(TAG, "PlayAudioThread complete...");                                
                        
                }
        
                
                
        }
        
        
        
        @Override
        public void onPlayComplete() {
                // TODO Auto-generated method stub                
                mPlayAudioThread = null;
                if (mPlayState != PlayState.MPS_PAUSE)
                {
                        setPlayState(PlayState.MPS_PREPARE);
                }
                
        }        
        
        
}


···············java代码  AudioParam······················
package com.genius.demo;

public class AudioParam {

        int mFrequency;                                        // 采样率
        
        int mChannel;                                        // 声道
        
        int mSampBit;                                        // 采样精度
        
}




··············java代码 IPlayComplete ···················

package com.genius.demo;

public interface IPlayComplete {

        public void onPlayComplete();
        
}



··················java代码  PlayState·····················

package com.genius.demo;

public interface PlayState {
        
        public static final int MPS_UNINIT = 0;                                // 未就绪
        
        public static final int MPS_PREPARE = 1;                        // 准备就绪(停止)
        
        public static final int MPS_PLAYING = 2;                        // 播放中
        
        public static final int MPS_PAUSE = 3;                                // 暂停
}

加载中
0
J
JGDIBC

我也是,你解决了没有?

解决了分享一下,谢啦

返回顶部
顶部