android 录音

直接给上个详细的使用Android MediaRecorder进行手机录音解说代码：

package cn.com.chenzheng_java.media;

import java.io.IOException;

import android.app.Activity;
import android.media.MediaRecorder;
import android.os.Bundle;

public class MediaRecordActivity extends Activity {
	MediaRecorder mediaRecorder ;
	@Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
       
        mediaRecorder = new MediaRecorder();
        record();
    }
    
	/**
	 * 开始录制
	 */
    private void record(){
    	/**
    	 * mediaRecorder.setAudioSource设置声音来源。
    	 * MediaRecorder.AudioSource这个内部类详细的介绍了声音来源。
    	 * 该类中有许多音频来源，不过最主要使用的还是手机上的麦克风，MediaRecorder.AudioSource.MIC
    	 */
    	mediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
    	/**
    	 * mediaRecorder.setOutputFormat代表输出文件的格式。该语句必须在setAudioSource之后，在prepare之前。
    	 * OutputFormat内部类，定义了音频输出的格式，主要包含MPEG_4、THREE_GPP、RAW_AMR……等。
    	 */
    	mediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
    	/**
    	 * mediaRecorder.setAddioEncoder()方法可以设置音频的编码
    	 * AudioEncoder内部类详细定义了两种编码：AudioEncoder.DEFAULT、AudioEncoder.AMR_NB
    	 */
    	mediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.DEFAULT);
    	/**
    	 * 设置录音之后，保存音频文件的位置
    	 */
    	mediaRecorder.setOutputFile("file:///sdcard/myvido/a.3pg");
    	
    	/**
    	 * 调用start开始录音之前，一定要调用prepare方法。
    	 */
    	try {
			mediaRecorder.prepare();
			mediaRecorder.start();
		}
        catch (IllegalStateException e) {
			e.printStackTrace();
		}
        catch (IOException e) {
			e.printStackTrace();
		}
    }
    
    /***
     * 此外，还有和MediaRecorder有关的几个参数与方法，我们一起来看一下：
     * sampleRateInHz :音频的采样频率，每秒钟能够采样的次数，采样率越高，音质越高。
     * 给出的实例是44100、22050、11025但不限于这几个参数。例如要采集低质量的音频就可以使用4000、8000等低采样率
     * 
     * channelConfig ：声道设置：android支持双声道立体声和单声道。MONO单声道，STEREO立体声
     * 
     * recorder.stop();停止录音
     * recorder.reset();  重置录音 ，会重置到setAudioSource这一步
     * recorder.release(); 解除对录音资源的占用
     */
}

android中AudioRecord采集音频的参数说明  

在android中采集音频的api是android.media.AudioRecord类 其中构造器的几个参数就是标准的声音采集参数 以下是参数的含义解释 public AudioRecord (int audioSource, int sampleRateInHz, int channelConfig, int audioFormat, int bufferSizeInBytes) Since: API Level 3 Class constructor. Parameters audioSource the recording source. See MediaRecorder.AudioSource for recording source definitions. 音频源：指的是从哪里采集音频。这里我们当然是从麦克风采集音频，所以此参数的值为MIC sampleRateInHz the sample rate expressed in Hertz. Examples of rates are (but not limited to) 44100, 22050 and 11025. 采样率：音频的采样频率，每秒钟能够采样的次数，采样率越高，音质越高。给出的实例是44100、22050、11025但不限于这几个参数。例如要采集低质量的音频就可以使用4000、8000等低采样率。 channelConfig describes the configuration of the audio channels. SeeCHANNEL_IN_MONO and CHANNEL_IN_STEREO 声道设置：android支持双声道立体声和单声道。MONO单声道，STEREO立体声 audioFormat the format in which the audio data is represented. SeeENCODING_PCM_16BIT and ENCODING_PCM_8BIT 编码制式和采样大小：采集来的数据当然使用PCM编码(脉冲代码调制编码，即PCM编码。PCM通过抽样、量化、编码三个步骤将连续变化的模拟信号转换为数字编码。) android支持的采样大小16bit 或者8bit。当然采样大小越大，那么信息量越多，音质也越高，现在主流的采样大小都是16bit，在低质量的语音传输的时候8bit 足够了。 bufferSizeInBytes the total size (in bytes) of the buffer where audio data is written to during the recording. New audio data can be read from this buffer in smaller chunks than this size. See getMinBufferSize(int, int, int) to determine the minimum required buffer size for the successful creation of an AudioRecord instance. Using values smaller than getMinBufferSize() will result in an initialization failure. 采集数据需要的缓冲区的大小，如果不知道最小需要的大小可以在getMinBufferSize()查看。 采集到的数据保存在一个byteBuffer中，可以使用流将其读出。亦可保存成为文件的形式

  

Android 使用AudioRecord录音相关和音频文件的封装

分类： Android流媒体学习

在Android中录音可以用MediaRecord录音，操作比较简单。但是不够专业，就是不能对音频进行处理。如果要进行音频的实时的处理或者音频的一些封装

就可以用AudioRecord来进行录音了。

这里给出一段代码。实现了AudioRecord的录音和WAV格式音频的封装。

用AudioTrack和AudioTrack类可以进行边录边播，可以参考：http://blog.sina.com.cn/s/blog_6309e1ed0100j1rw.html

我们这里的代码没有播放。但是有封装和详解，如下：

[java]  view plain copy

1. package com.ppmeet;  
2.   
3. import java.io.File;  
4. import java.io.FileInputStream;  
5. import java.io.FileNotFoundException;  
6. import java.io.FileOutputStream;  
7. import java.io.IOException;  
8. import android.app.Activity;  
9. import android.graphics.PixelFormat;  
10. import android.media.AudioFormat;  
11. import android.media.AudioRecord;  
12. import android.media.MediaRecorder;  
13. import android.os.Bundle;  
14. import android.view.View;  
15. import android.view.View.OnClickListener;  
16. import android.view.Window;  
17. import android.view.WindowManager;  
18. import android.widget.Button;  
19.   
20. /** 
21.  * class name：TestAudioRecord<BR> 
22.  * class description：用AudioRecord来进行录音<BR> 
23.  * PS： <BR> 
24.  *  
25.  * @version 1.00 2011/09/21 
26.  * @author CODYY)peijiangping 
27.  */  
28. public class TestAudioRecord extends Activity {  
29.     // 音频获取源  
30.     private int audioSource = MediaRecorder.AudioSource.MIC;  
31.     // 设置音频采样率，44100是目前的标准，但是某些设备仍然支持22050，16000，11025  
32.     private static int sampleRateInHz = 44100;  
33.     // 设置音频的录制的声道CHANNEL_IN_STEREO为双声道，CHANNEL_CONFIGURATION_MONO为单声道  
34.     private static int channelConfig = AudioFormat.CHANNEL_IN_STEREO;  
35.     // 音频数据格式:PCM 16位每个样本。保证设备支持。PCM 8位每个样本。不一定能得到设备支持。  
36.     private static int audioFormat = AudioFormat.ENCODING_PCM_16BIT;  
37.     // 缓冲区字节大小  
38.     private int bufferSizeInBytes = 0;  
39.     private Button Start;  
40.     private Button Stop;  
41.     private AudioRecord audioRecord;  
42.     private boolean isRecord = false;// 设置正在录制的状态  
43.     //AudioName裸音频数据文件  
44.     private static final String AudioName = "/sdcard/love.raw";  
45.     //NewAudioName可播放的音频文件  
46.     private static final String NewAudioName = "/sdcard/new.wav";  
47.   
48.     public void onCreate(Bundle savedInstanceState) {  
49.         super.onCreate(savedInstanceState);  
50.         getWindow().setFormat(PixelFormat.TRANSLUCENT);// 让界面横屏  
51.         requestWindowFeature(Window.FEATURE_NO_TITLE);// 去掉界面标题  
52.         getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,  
53.                 WindowManager.LayoutParams.FLAG_FULLSCREEN);  
54.         // 重新设置界面大小  
55.         setContentView(R.layout.main);  
56.         init();  
57.     }  
58.   
59.     private void init() {  
60.         Start = (Button) this.findViewById(R.id.start);  
61.         Stop = (Button) this.findViewById(R.id.stop);  
62.         Start.setOnClickListener(new TestAudioListener());  
63.         Stop.setOnClickListener(new TestAudioListener());  
64.         creatAudioRecord();  
65.     }  
66.   
67.     private void creatAudioRecord() {  
68.         // 获得缓冲区字节大小  
69.         bufferSizeInBytes = AudioRecord.getMinBufferSize(sampleRateInHz,  
70.                 channelConfig, audioFormat);  
71.         // 创建AudioRecord对象  
72.         audioRecord = new AudioRecord(audioSource, sampleRateInHz,  
73.                 channelConfig, audioFormat, bufferSizeInBytes);  
74.     }  
75.   
76.     class TestAudioListener implements OnClickListener {  
77.   
78.         @Override  
79.         public void onClick(View v) {  
80.             if (v == Start) {  
81.                 startRecord();  
82.             }  
83.             if (v == Stop) {  
84.                 stopRecord();  
85.             }  
86.   
87.         }  
88.   
89.     }  
90.   
91.     private void startRecord() {  
92.         audioRecord.startRecording();  
93.         // 让录制状态为true  
94.         isRecord = true;  
95.         // 开启音频文件写入线程  
96.         new Thread(new AudioRecordThread()).start();  
97.     }  
98.   
99.     private void stopRecord() {  
100.         close();  
101.     }  
102.   
103.     private void close() {  
104.         if (audioRecord != null) {  
105.             System.out.println("stopRecord");  
106.             isRecord = false;//停止文件写入  
107.             audioRecord.stop();  
108.             audioRecord.release();//释放资源  
109.             audioRecord = null;  
110.         }  
111.     }  
112.   
113.     class AudioRecordThread implements Runnable {  
114.         @Override  
115.         public void run() {  
116.             writeDateTOFile();//往文件中写入裸数据  
117.             copyWaveFile(AudioName, NewAudioName);//给裸数据加上头文件  
118.         }  
119.     }  
120.   
121.     /** 
122.      * 这里将数据写入文件，但是并不能播放，因为AudioRecord获得的音频是原始的裸音频， 
123.      * 如果需要播放就必须加入一些格式或者编码的头信息。但是这样的好处就是你可以对音频的 裸数据进行处理，比如你要做一个爱说话的TOM 
124.      * 猫在这里就进行音频的处理，然后重新封装 所以说这样得到的音频比较容易做一些音频的处理。 
125.      */  
126.     private void writeDateTOFile() {  
127.         // new一个byte数组用来存一些字节数据，大小为缓冲区大小  
128.         byte[] audiodata = new byte[bufferSizeInBytes];  
129.         FileOutputStream fos = null;  
130.         int readsize = 0;  
131.         try {  
132.             File file = new File(AudioName);  
133.             if (file.exists()) {  
134.                 file.delete();  
135.             }  
136.             fos = new FileOutputStream(file);// 建立一个可存取字节的文件  
137.         } catch (Exception e) {  
138.             e.printStackTrace();  
139.         }  
140.         while (isRecord == true) {  
141.             readsize = audioRecord.read(audiodata, 0, bufferSizeInBytes);  
142.             if (AudioRecord.ERROR_INVALID_OPERATION != readsize) {  
143.                 try {  
144.                     fos.write(audiodata);  
145.                 } catch (IOException e) {  
146.                     e.printStackTrace();  
147.                 }  
148.             }  
149.         }  
150.         try {  
151.             fos.close();// 关闭写入流  
152.         } catch (IOException e) {  
153.             e.printStackTrace();  
154.         }  
155.     }  
156.   
157.     // 这里得到可播放的音频文件  
158.     private void copyWaveFile(String inFilename, String outFilename) {  
159.         FileInputStream in = null;  
160.         FileOutputStream out = null;  
161.         long totalAudioLen = 0;  
162.         long totalDataLen = totalAudioLen + 36;  
163.         long longSampleRate = sampleRateInHz;  
164.         int channels = 2;  
165.         long byteRate = 16 * sampleRateInHz * channels / 8;  
166.         byte[] data = new byte[bufferSizeInBytes];  
167.         try {  
168.             in = new FileInputStream(inFilename);  
169.             out = new FileOutputStream(outFilename);  
170.             totalAudioLen = in.getChannel().size();  
171.             totalDataLen = totalAudioLen + 36;  
172.             WriteWaveFileHeader(out, totalAudioLen, totalDataLen,  
173.                     longSampleRate, channels, byteRate);  
174.             while (in.read(data) != -1) {  
175.                 out.write(data);  
176.             }  
177.             in.close();  
178.             out.close();  
179.         } catch (FileNotFoundException e) {  
180.             e.printStackTrace();  
181.         } catch (IOException e) {  
182.             e.printStackTrace();  
183.         }  
184.     }  
185.   
186.     /** 
187.      * 这里提供一个头信息。插入这些信息就可以得到可以播放的文件。 
188.      * 为我为啥插入这44个字节，这个还真没深入研究，不过你随便打开一个wav 
189.      * 音频的文件，可以发现前面的头文件可以说基本一样哦。每种格式的文件都有 
190.      * 自己特有的头文件。 
191.      */  
192.     private void WriteWaveFileHeader(FileOutputStream out, long totalAudioLen,  
193.             long totalDataLen, long longSampleRate, int channels, long byteRate)  
194.             throws IOException {  
195.         byte[] header = new byte[44];  
196.         header[0] = 'R'; // RIFF/WAVE header  
197.         header[1] = 'I';  
198.         header[2] = 'F';  
199.         header[3] = 'F';  
200.         header[4] = (byte) (totalDataLen & 0xff);  
201.         header[5] = (byte) ((totalDataLen >> 8) & 0xff);  
202.         header[6] = (byte) ((totalDataLen >> 16) & 0xff);  
203.         header[7] = (byte) ((totalDataLen >> 24) & 0xff);  
204.         header[8] = 'W';  
205.         header[9] = 'A';  
206.         header[10] = 'V';  
207.         header[11] = 'E';  
208.         header[12] = 'f'; // 'fmt ' chunk  
209.         header[13] = 'm';  
210.         header[14] = 't';  
211.         header[15] = ' ';  
212.         header[16] = 16; // 4 bytes: size of 'fmt ' chunk  
213.         header[17] = 0;  
214.         header[18] = 0;  
215.         header[19] = 0;  
216.         header[20] = 1; // format = 1  
217.         header[21] = 0;  
218.         header[22] = (byte) channels;  
219.         header[23] = 0;  
220.         header[24] = (byte) (longSampleRate & 0xff);  
221.         header[25] = (byte) ((longSampleRate >> 8) & 0xff);  
222.         header[26] = (byte) ((longSampleRate >> 16) & 0xff);  
223.         header[27] = (byte) ((longSampleRate >> 24) & 0xff);  
224.         header[28] = (byte) (byteRate & 0xff);  
225.         header[29] = (byte) ((byteRate >> 8) & 0xff);  
226.         header[30] = (byte) ((byteRate >> 16) & 0xff);  
227.         header[31] = (byte) ((byteRate >> 24) & 0xff);  
228.         header[32] = (byte) (2 * 16 / 8); // block align  
229.         header[33] = 0;  
230.         header[34] = 16; // bits per sample  
231.         header[35] = 0;  
232.         header[36] = 'd';  
233.         header[37] = 'a';  
234.         header[38] = 't';  
235.         header[39] = 'a';  
236.         header[40] = (byte) (totalAudioLen & 0xff);  
237.         header[41] = (byte) ((totalAudioLen >> 8) & 0xff);  
238.         header[42] = (byte) ((totalAudioLen >> 16) & 0xff);  
239.         header[43] = (byte) ((totalAudioLen >> 24) & 0xff);  
240.         out.write(header, 0, 44);  
241.     }  
242.   
243.     @Override  
244.     protected void onDestroy() {  
245.         close();  
246.         super.onDestroy();  
247.     }  
248. }  

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Android入门（9）AudioRecord和AudioTrack类的使用

   (2010-05-07 09:07:05

    AudioRecord和AudioTrack类是Android获取和播放音频流的重要类，放置在android.media包中。与该包中的MediaRecorder和MediaPlayer类不同，AudioRecord和AudioTrack类在获取和播放音频数据流时无需通过文件保存和文件读取，可以动态地直接获取和播放音频流，在实时处理音频数据流时非常有用。

    当然，如果用户只想录音后写入文件或从文件中取得音频流进行播放，那么直接使用MediaRecorder和MediaPlayer类是首选方案，因为这两个类使用非常方便，而且成功率很高。而AudioRecord和AudioTrack类的使用却比较复杂，我们发现很多人都不能成功地使用这两个类，甚至认为Android的这两个类是不能工作的。

    其实，AudioRecord和AudioTrack类的使用虽然比较复杂，但是可以工作，我们不仅可以很好地使用了这两个类，而且还通过套接字（Socket）实现了音频数据的网络传输，做到了一端使用AudioRecord获取音频流然后通过套接字传输出去，而另一端通过套接字接收后使用AudioTrack类播放。

    下面是我们对AudioRecord和AudioTrack类在使用方面的经验总结：

    （1）创建AudioRecord和AudioTrack类对象：创建这两个类的对象比较复杂，通过对文档的反复和仔细理解，并通过多次失败的尝试，并在北理工的某个Android大牛的网上的文章启发下，我们也最终成功地创建了这两个类的对象。创建AudioRecord和AudioTrack类对象的代码如下：

AudioRecord类：

         m_in_buf_size =AudioRecord.getMinBufferSize(8000,
                        AudioFormat.CHANNEL_CONFIGURATION_MONO,
                        AudioFormat.ENCODING_PCM_16BIT);
   
         m_in_rec = new AudioRecord(MediaRecorder.AudioSource.MIC,
         8000,
         AudioFormat.CHANNEL_CONFIGURATION_MONO,
         AudioFormat.ENCODING_PCM_16BIT,
         m_in_buf_size) ;

AudioTrack类：

         m_out_buf_size = android.media.AudioTrack.getMinBufferSize(8000,
                          AudioFormat.CHANNEL_CONFIGURATION_MONO,
                          AudioFormat.ENCODING_PCM_16BIT);

         m_out_trk = new AudioTrack(AudioManager.STREAM_MUSIC, 8000,
                                       AudioFormat.CHANNEL_CONFIGURATION_MONO,
                                       AudioFormat.ENCODING_PCM_16BIT,
                                       m_out_buf_size,
                                       AudioTrack.MODE_STREAM);

    （2）关于AudioRecord和AudioTrack类的监听函数，不用也行。

 

    （3）调试方面，包括初始化后看logcat信息，以确定类的工作状态，初始化是否成功等。

     编写好代码，没有语法错误，调用模拟器运行、调试代码时，logcat发挥了很好的功用。刚调试时，经常会出现模拟器显示出现异常，这时我们可以在代码的一些关键语句后添加如Log.d("test1","OK")；这样的语句进行标识，出现异常时我们就可以在logcat窗口观察代码执行到哪里出现异常，然后进行相应的修改、调试。模拟器不会出现异常时，又遇到了录放音的问题。录音方面，刚开始选择将语音编码数据存放在多个固定大小的文件中进行传送，但是这种情况下会出现声音断续的现象，而且要反复的建立文件，比较麻烦，后来想到要进行网上传输，直接将语音编码数据以数据流的形式传送，经过验证，这种方法可行并且使代码更加简洁。放音方面，将接收到的数据流存放在一个数组中，然后将数组中数据写到AudioTrack中。刚开始只是“嘟”几声，经过检查发现只是把数据写一次，加入循环，让数据反复写到AudioTrack中，就可以听到正常的语音了。接下来的工作主要是改善话音质量与话音延迟，在进行通话的过程中，观察logcat窗口，发现向数组中写数据时会出现Bufferflow的情况，于是把重心转移到数组大小的影响上，经过试验，发现 AudioRecord一次会读640个数据，然后就对录音和放音中有数组的地方进行实验修改。AudioRecord和AudioTrack进行实例化时，参数中各有一个数组大小，经过试验这个数组大小和AudioRecord和AudioTrack能正常实例化所需的最小Buffer大小（即上面实例化时的m_in_buf_size和m_out_buf_size参数）相等且服务器方进行缓存数据的数组尺寸是上述数值的2倍时，语音质量最好。由于录音和放音的速度不一致，受到北理工大牛的启发，在录音方面，将存放录音数据的数组放到LinkedList中,当LinkedList中数组个数达到2（这个也是经过试验验证话音质量最好时的数据）时，将先录好的数组中数据传送出去。经过上述反复试验和修改，最终使双方通话质量较好，且延时较短（大概有2秒钟）。

    （4）通过套接字传输和接收数据

     数据传送部分，使用的是套接字。通信双方，通过不同的端口向服务器发送请求，与服务器连接上后，开始通话向服务器发送数据，服务器通过一个套接字接收到一方的数据后，先存在一个数组中，然后将该数组中数据以数据流的形式再通过另一个套接字传送到另一方。这样就实现了双方数据的传送。

     （5）代码架构

      为避免反复录入和读取数据占用较多资源，使程序在进行录放音时不能执行其他命令，故将录音和放音各写成一个线程类，然后在主程序中，通过MENU控制通话的开始、停止、结束。

      最后说明，AudioRecord和AudioTrack类可以用，只是稍微复杂些。以下贴出双方通信的源码，希望对大家有所帮助：

主程序Daudioclient：

package cn.Daudioclient;

import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;

public class Daudioclient extends Activity {
 
    public static final int MENU_START_ID = Menu.FIRST ;
    public static final int MENU_STOP_ID = Menu.FIRST + 1 ;
    public static final int MENU_EXIT_ID = Menu.FIRST + 2 ;
 
    protected Saudioserver     m_player ;
    protected Saudioclient     m_recorder ;
 
   
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
   
    public boolean onCreateOptionsMenu(Menu aMenu)
    {
        boolean res = super.onCreateOptionsMenu(aMenu) ;

        aMenu.add(0, MENU_START_ID, 0, "START") ;
        aMenu.add(0, MENU_STOP_ID, 0, "STOP") ;
        aMenu.add(0, MENU_EXIT_ID, 0, "EXIT") ;

        return res ;
    }

   
    public boolean onOptionsItemSelected(MenuItem aMenuItem)
    {
        switch (aMenuItem.getItemId()) {
        case MENU_START_ID:
            {
             m_player = new Saudioserver() ;
                m_recorder = new Saudioclient() ;

                m_player.init() ;
                m_recorder.init() ;

                m_recorder.start() ;
                m_player.start() ;
               
            }
            break ;
        case MENU_STOP_ID:
            {  
             m_recorder.free() ;
                m_player.free() ;

                m_player = null ;
                m_recorder = null ;
            }
            break ;
        case MENU_EXIT_ID:
            {
                int pid = android.os.Process.myPid() ;
                android.os.Process.killProcess(pid) ;
            }
            break ;
        default:
            break ;
        }

        return super.onOptionsItemSelected(aMenuItem);
    }
}

录音程序Saudioclient：

package cn.Daudioclient;

import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.LinkedList;

import android.media.AudioFormat;
import android.media.AudioRecord;
import android.media.MediaRecorder;
import android.util.Log;

public class Saudioclient extends Thread
{
 
    protected AudioRecord m_in_rec ; 
    protected int         m_in_buf_size ;
    protected byte []     m_in_bytes ;
    protected boolean     m_keep_running ;
    protected Socket      s;
    protected DataOutputStream dout;
    protected LinkedList<byte[]>  m_in_q ;
  
    public void run()
 {
      try
      {
          byte [] bytes_pkg ;
             m_in_rec.startRecording() ;
             while(m_keep_running)
             {
                 m_in_rec.read(m_in_bytes, 0, m_in_buf_size) ;
                 bytes_pkg = m_in_bytes.clone() ;
                 if(m_in_q.size() >= 2)
                 {
                        dout.write(m_in_q.removeFirst() , 0, m_in_q.removeFirst() .length);
                    }
                    m_in_q.add(bytes_pkg) ;
             }
     
             m_in_rec.stop() ;
             m_in_rec = null ;
             m_in_bytes = null ;
       dout.close();
        
      }
      catch(Exception e)
      {
       e.printStackTrace();
      }
    }
   
    public void init()
    {
     m_in_buf_size =  AudioRecord.getMinBufferSize(8000,
                        AudioFormat.CHANNEL_CONFIGURATION_MONO,
                        AudioFormat.ENCODING_PCM_16BIT);
   
  m_in_rec = new AudioRecord(MediaRecorder.AudioSource.MIC,
  8000,
  AudioFormat.CHANNEL_CONFIGURATION_MONO,
  AudioFormat.ENCODING_PCM_16BIT,
  m_in_buf_size) ;
  
  m_in_bytes = new byte [m_in_buf_size] ;
  
  m_keep_running = true ;
  m_in_q=new LinkedList<byte[]>();
  
     try
     {
   s=new Socket("192.168.1.100",4332);
   dout=new DataOutputStream(s.getOutputStream());
   //new Thread(R1).start();
  }
     catch (UnknownHostException e)
     {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
     catch (IOException e)
     {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }

    }
   
    public void free()
 {
  m_keep_running = false ;
        try {
            Thread.sleep(1000) ;
        } catch(Exception e) {
            Log.d("sleep exceptions...\n","") ;
        }
 }
}
放音程序Saudioserver：

package cn.Daudioclient;

import java.io.DataInputStream;
import java.io.IOException;
import java.net.Socket;

import android.media.AudioFormat;
import android.media.AudioManager;
import android.media.AudioTrack;
import android.util.Log;

public class Saudioserver extends Thread
{  
    protected AudioTrack m_out_trk ;
    protected int        m_out_buf_size ;
    protected byte []    m_out_bytes ;
    protected boolean    m_keep_running ;
 private Socket s;
 private DataInputStream din;
 public void init()
 {
  try
     {
            s=new Socket("192.168.1.100",4331);
            din=new DataInputStream(s.getInputStream());
           
             m_keep_running = true ;
       
           
            m_out_buf_size = AudioTrack.getMinBufferSize(8000,
                             AudioFormat.CHANNEL_CONFIGURATION_MONO,
                             AudioFormat.ENCODING_PCM_16BIT);

            m_out_trk = new AudioTrack(AudioManager.STREAM_MUSIC, 8000,
                                       AudioFormat.CHANNEL_CONFIGURATION_MONO,
                                       AudioFormat.ENCODING_PCM_16BIT,
                                       m_out_buf_size,
                                       AudioTrack.MODE_STREAM);
         
            m_out_bytes=new byte[m_out_buf_size];
           
           // new Thread(R1).start();
           
     }
     catch(Exception e)
     {
      e.printStackTrace();
     }
 }
   
 public void free()
 {
  m_keep_running = false ;
        try {
            Thread.sleep(1000) ;
        } catch(Exception e) {
            Log.d("sleep exceptions...\n","") ;
        }
 }
 
  public void run()
  {
   byte [] bytes_pkg = null ;
         m_out_trk.play() ;
         while(m_keep_running) {
             try
             {
              din.read(m_out_bytes);
                 bytes_pkg = m_out_bytes.clone() ;
                 m_out_trk.write(bytes_pkg, 0, bytes_pkg.length) ;
             }
             catch(Exception e)
             {
              e.printStackTrace();
             }
            
         }
        
         m_out_trk.stop() ;
         m_out_trk = null ;
         try {
    din.close();
   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
}
        

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Android AudioRecord 实现音频录制

//由于程序可能用到对手机SD卡的读取，所以在manifest.xml里需要配置对sd卡存取的权限：
// <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
// <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/>
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

import android.app.Activity;
import android.content.Context;
import android.media.AudioFormat;
import android.media.AudioManager;
import android.media.AudioRecord;
import android.media.AudioTrack;
import android.media.MediaRecorder;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Environment;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;

import com.telenav.funnl.android.R;
/** 
* 该实例中，我们使用AudioRecord类来完成我们的音频录制程序 
* AudioRecord类，我们可以使用三种不同的read方法来完成录制工作， 
* 每种方法都有其实用的场合 
* 一、实例化一个AudioRecord类我们需要传入几种参数 
* 1、AudioSource：这里可以是MediaRecorder.AudioSource.MIC 
* 2、SampleRateInHz:录制频率，可以为8000hz或者11025hz等，不同的硬件设备这个值不同 
* 3、ChannelConfig:录制通道，可以为udioFormat.CHANNEL_CONFIGURATION_MONO和udioFormat.CHANNEL_CONFIGURATION_STEREO 
* 4、AudioFormat:录制编码格式，可以为AudioFormat.ENCODING_16BIT和BIT,其中16BIT的仿真性比8BIT好，但是需要消耗更多的电量和存储空间 
* 5、BufferSize:录制缓冲大小：可以通过getMinBufferSize来获取 
* 这样我们就可以实例化一个AudioRecord对象了 
* 二、创建一个文件，用于保存录制的内容 
* 同上篇 
* 三、打开一个输出流，指向创建的文件 
* DataOutputStream dos = new DataOutputStream(new BufferedOutputSream(new FileOutputStream(file))) 
* 四、现在就可以开始录制了，我们需要创建一个字节数组来存储从udioRecorder中返回的音频数据，但是 
* 注意，我们定义的数组要小于定义AudioRecord时指定的那个ufferSize 
* short[]buffer = new short[BufferSize/4]; 
* startRecording(); 
* 然后一个循环，调用AudioRecord的read方法实现读取 
* 另外使用MediaPlayer是无法播放使用AudioRecord录制的音频的，为了实现播放，我们需要 
* 使用AudioTrack类来实现 
* AudioTrack类允许我们播放原始的音频数据 
* 
* 
* 一、实例化一个AudioTrack同样要传入几个参数 
* 1、StreamType:在AudioManager中有几个常量，其中一个是TREAM_MUSIC; 
* 2、SampleRateInHz：最好和AudioRecord使用的是同一个值 
* 3、ChannelConfig：同上 
* 4、AudioFormat：同上 
* 5、BufferSize：通过AudioTrack的静态方法getMinBufferSize来获取 
* 6、Mode：可以是AudioTrack.MODE_STREAM和MODE_STATIC，关于这两种不同之处，可以查阅文档 
* 二、打开一个输入流，指向刚刚录制内容保存的文件，然后开始播放，边读取边播放 
* 
* 实现时，音频的录制和播放分别使用两个AsyncTask来完成 
*/ 
public class PCMRecordActivity extends Activity implements OnClickListener{ 

private TextView stateView; 

private Button btnStart,btnStop,btnPlay,btnFinish; 

private RecordTask recorder; 
private PlayTask player; 
private File fpath; 
private File audioFile;
private Context context;

private boolean isRecording=true, isPlaying=false; //标记 

private int frequence = 16000;//8000; //录制频率，单位hz.这里的值注意了，写的不好，可能实例化AudioRecord对象的时候，会出错。我开始写成11025就不行。这取决于硬件设备 
private int channelConfig = AudioFormat.CHANNEL_CONFIGURATION_MONO; 
private int audioEncoding = AudioFormat.ENCODING_PCM_16BIT; 

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

stateView = (TextView)this.findViewById(R.id.view_state); 
stateView.setText("start recording.."); 
btnStart = (Button)this.findViewById(R.id.btn_start); 
btnStart.setText("start");
btnStart.setOnClickListener(this);
btnStop = (Button)this.findViewById(R.id.btn_stop); 
btnStop.setText("stop");
btnStop.setOnClickListener(this);
btnPlay = (Button)this.findViewById(R.id.btn_play);
btnPlay.setText("play");
btnPlay.setOnClickListener(this);
btnFinish = (Button)this.findViewById(R.id.btn_finish); 
btnFinish.setText("finish");
btnFinish.setOnClickListener(this);
btnStop.setEnabled(false); 
btnPlay.setEnabled(false); 
btnFinish.setEnabled(false); 

if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED))//手机有SD卡的情况
{
//在这里我们创建一个文件，用于保存录制内容 
fpath = new File(Environment.getExternalStorageDirectory().getAbsolutePath()+"/data/files/"); 
fpath.mkdirs();//创建文件夹 
}else//手机无SD卡的情况
{
fpath = this.getCacheDir();
}

try { 
//创建临时文件,注意这里的格式为.pcm 
audioFile = File.createTempFile("recording", ".pcm", fpath); 
} catch (IOException e) { 
// TODO Auto-generated catch block 
e.printStackTrace(); 
} 
} 


public void onClick(View v){ 
int id = v.getId(); 
switch(id){ 
case R.id.btn_start: 
//开始录制 

//这里启动录制任务 
recorder = new RecordTask(); 
recorder.execute(); 

break; 
case R.id.btn_stop: 
//停止录制 
this.isRecording = false; 
//更新状态 
//在录制完成时设置，在RecordTask的onPostExecute中完成 
break; 
case R.id.btn_play: 

player = new PlayTask(); 
player.execute(); 
break; 
case R.id.btn_finish: 
//完成播放 
this.isPlaying = false; 
break; 

} 
} 

class RecordTask extends AsyncTask<Void, Integer, Void>{ 
@Override 
protected Void doInBackground(Void... arg0) { 
isRecording = true; 
try { 
//开通输出流到指定的文件 
DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(audioFile))); 
//根据定义好的几个配置，来获取合适的缓冲大小 
int bufferSize = AudioRecord.getMinBufferSize(frequence, channelConfig, audioEncoding); 
//实例化AudioRecord 
AudioRecord record = new AudioRecord(MediaRecorder.AudioSource.MIC, frequence, channelConfig, audioEncoding, bufferSize); 
//定义缓冲 
short[] buffer = new short[bufferSize]; 

//开始录制 
record.startRecording(); 

int r = 0; //存储录制进度 
//定义循环，根据isRecording的值来判断是否继续录制 
while(isRecording){ 
//从bufferSize中读取字节，返回读取的short个数 
//这里老是出现buffer overflow，不知道是什么原因，试了好几个值，都没用，TODO：待解决 
int bufferReadResult = record.read(buffer, 0, buffer.length); 
//循环将buffer中的音频数据写入到OutputStream中 
for(int i=0; i<bufferReadResult; i++){ 
dos.writeShort(buffer[i]); 
} 
publishProgress(new Integer(r)); //向UI线程报告当前进度 
r++; //自增进度值 
} 
//录制结束 
record.stop(); 
Log.v("The DOS available:", "::"+audioFile.length()); 
dos.close(); 
} catch (Exception e) { 
// TODO: handle exception 
} 
return null; 
} 

//当在上面方法中调用publishProgress时，该方法触发,该方法在I线程中被执行 
protected void onProgressUpdate(Integer...progress){ 
stateView.setText(progress[0].toString()); 
} 

protected void onPostExecute(Void result){ 
btnStop.setEnabled(false); 
btnStart.setEnabled(true); 
btnPlay.setEnabled(true); 
btnFinish.setEnabled(false); 
} 

protected void onPreExecute(){ 
//stateView.setText("正在录制"); 
btnStart.setEnabled(false); 
btnPlay.setEnabled(false); 
btnFinish.setEnabled(false); 
btnStop.setEnabled(true); 
} 

} 

class PlayTask extends AsyncTask<Void, Integer, Void>{ 
@Override 
protected Void doInBackground(Void... arg0) { 
isPlaying = true; 
int bufferSize = AudioTrack.getMinBufferSize(frequence, channelConfig, audioEncoding); 
short[] buffer = new short[bufferSize/4]; 
try { 
//定义输入流，将音频写入到AudioTrack类中，实现播放 
DataInputStream dis = new DataInputStream(new BufferedInputStream(new FileInputStream(audioFile))); 
//实例AudioTrack 
AudioTrack track = new AudioTrack(AudioManager.STREAM_MUSIC, frequence, channelConfig, audioEncoding, bufferSize, AudioTrack.MODE_STREAM); 
//开始播放 
track.play(); 
//由于AudioTrack播放的是流，所以，我们需要一边播放一边读取 
while(isPlaying && dis.available()>0){ 
int i = 0; 
while(dis.available()>0 && i<buffer.length){ 
buffer[i] = dis.readShort(); 
i++; 
} 
//然后将数据写入到AudioTrack中 
track.write(buffer, 0, buffer.length); 

} 

//播放结束 
track.stop(); 
dis.close(); 
} catch (Exception e) { 
// TODO: handle exception 
} 
return null; 
} 

protected void onPostExecute(Void result){ 
btnPlay.setEnabled(true); 
btnFinish.setEnabled(false); 
btnStart.setEnabled(true); 
btnStop.setEnabled(false); 
} 

protected void onPreExecute(){ 
btnStart.setEnabled(false); 
btnStop.setEnabled(false); 
btnPlay.setEnabled(false); 
btnFinish.setEnabled(true); 
} 

} 
} 

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Android多媒体学：利用AudioRecord类实现自己的音频录制程序 .

• 博客分类：  
• android

AudioRecord类相对于MediaRecorder来说，更加接近底层，为我们封装的方法也更少。然而实现一个AudioRecord的音频录制程序也很

简单。本实例代码如下：

 

可惜，本实例测试时有个问题，在录制的时候，会出现buffer over。缓存泄露，待解决。

[java]  view plain copy

1. package demo.camera;  
2. import java.io.BufferedInputStream;  
3. import java.io.BufferedOutputStream;  
4. import java.io.DataInputStream;  
5. import java.io.DataOutputStream;  
6. import java.io.File;  
7. import java.io.FileInputStream;  
8. import java.io.FileOutputStream;  
9. import java.io.IOException;  
10. import android.app.Activity;  
11. import android.content.ContentValues;  
12. import android.content.Intent;  
13. import android.hardware.Camera.AutoFocusCallback;  
14. import android.media.AudioFormat;  
15. import android.media.AudioManager;  
16. import android.media.AudioRecord;  
17. import android.media.AudioTrack;  
18. import android.media.MediaPlayer;  
19. import android.media.MediaRecorder;  
20. import android.net.Uri;  
21. import android.os.AsyncTask;  
22. import android.os.Bundle;  
23. import android.os.Environment;  
24. import android.provider.MediaStore;  
25. import android.util.Log;  
26. import android.view.View;  
27. import android.widget.Button;  
28. import android.widget.TextView;  
29. /** 
30.  * 该实例中，我们使用AudioRecord类来完成我们的音频录制程序 
31.  * AudioRecord类，我们可以使用三种不同的read方法来完成录制工作， 
32.  * 每种方法都有其实用的场合 
33.  * 一、实例化一个AudioRecord类我们需要传入几种参数 
34.  * 1、AudioSource：这里可以是MediaRecorder.AudioSource.MIC 
35.  * 2、SampleRateInHz:录制频率，可以为8000hz或者11025hz等，不同的硬件设备这个值不同 
36.  * 3、ChannelConfig:录制通道，可以为AudioFormat.CHANNEL_CONFIGURATION_MONO和AudioFormat.CHANNEL_CONFIGURATION_STEREO 
37.  * 4、AudioFormat:录制编码格式，可以为AudioFormat.ENCODING_16BIT和8BIT,其中16BIT的仿真性比8BIT好，但是需要消耗更多的电量和存储空间 
38.  * 5、BufferSize:录制缓冲大小：可以通过getMinBufferSize来获取 
39.  * 这样我们就可以实例化一个AudioRecord对象了 
40.  * 二、创建一个文件，用于保存录制的内容 
41.  * 同上篇 
42.  * 三、打开一个输出流，指向创建的文件 
43.  * DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(file))) 
44.  * 四、现在就可以开始录制了，我们需要创建一个字节数组来存储从AudioRecorder中返回的音频数据，但是 
45.  * 注意，我们定义的数组要小于定义AudioRecord时指定的那个BufferSize 
46.  * short[]buffer = new short[BufferSize/4]; 
47.  * startRecording(); 
48.  * 然后一个循环，调用AudioRecord的read方法实现读取 
49.  * 另外使用MediaPlayer是无法播放使用AudioRecord录制的音频的，为了实现播放，我们需要 
50.  * 使用AudioTrack类来实现 
51.  * AudioTrack类允许我们播放原始的音频数据 
52.  *  
53.  *  
54.  * 一、实例化一个AudioTrack同样要传入几个参数 
55.  * 1、StreamType:在AudioManager中有几个常量，其中一个是STREAM_MUSIC; 
56.  * 2、SampleRateInHz：最好和AudioRecord使用的是同一个值 
57.  * 3、ChannelConfig：同上 
58.  * 4、AudioFormat：同上 
59.  * 5、BufferSize：通过AudioTrack的静态方法getMinBufferSize来获取 
60.  * 6、Mode：可以是AudioTrack.MODE_STREAM和MODE_STATIC，关于这两种不同之处，可以查阅文档 
61.  * 二、打开一个输入流，指向刚刚录制内容保存的文件，然后开始播放，边读取边播放 
62.  *  
63.  * 实现时，音频的录制和播放分别使用两个AsyncTask来完成  
64.  */  
65. public class MyAudioRecord2 extends Activity{  
66.       
67.     private TextView stateView;  
68.       
69.     private Button btnStart,btnStop,btnPlay,btnFinish;  
70.       
71.     private RecordTask recorder;  
72.     private PlayTask player;  
73.       
74.     private File audioFile;  
75.       
76.     private boolean isRecording=true, isPlaying=false; //标记  
77.       
78.     private int frequence = 8000; //录制频率，单位hz.这里的值注意了，写的不好，可能实例化AudioRecord对象的时候，会出错。我开始写成11025就不行。这取决于硬件设备  
79.     private int channelConfig = AudioFormat.CHANNEL_CONFIGURATION_MONO;  
80.     private int audioEncoding = AudioFormat.ENCODING_PCM_16BIT;  
81.       
82.       
83.     public void onCreate(Bundle savedInstanceState){  
84.         super.onCreate(savedInstanceState);  
85.         setContentView(R.layout.my_audio_record);  
86.           
87.         stateView = (TextView)this.findViewById(R.id.view_state);  
88.         stateView.setText("准备开始");  
89.         btnStart = (Button)this.findViewById(R.id.btn_start);  
90.         btnStop = (Button)this.findViewById(R.id.btn_stop);  
91.         btnPlay = (Button)this.findViewById(R.id.btn_play);  
92.         btnFinish = (Button)this.findViewById(R.id.btn_finish);  
93.         btnFinish.setText("停止播放");  
94.         btnStop.setEnabled(false);  
95.         btnPlay.setEnabled(false);  
96.         btnFinish.setEnabled(false);  
97.           
98.         //在这里我们创建一个文件，用于保存录制内容  
99.         File fpath = new File(Environment.getExternalStorageDirectory().getAbsolutePath()+"/data/files/");  
100.         fpath.mkdirs();//创建文件夹  
101.         try {  
102.             //创建临时文件,注意这里的格式为.pcm  
103.             audioFile = File.createTempFile("recording", ".pcm", fpath);  
104.         } catch (IOException e) {  
105.             // TODO Auto-generated catch block  
106.             e.printStackTrace();  
107.         }         
108.     }  
109.       
110.       
111.     public void onClick(View v){  
112.         int id = v.getId();  
113.         switch(id){  
114.         case R.id.btn_start:  
115.             //开始录制  
116.               
117.             //这里启动录制任务  
118.             recorder = new RecordTask();  
119.             recorder.execute();  
120.               
121.             break;  
122.         case R.id.btn_stop:  
123.             //停止录制  
124.             this.isRecording = false;  
125.             //更新状态  
126.             //在录制完成时设置，在RecordTask的onPostExecute中完成  
127.             break;  
128.         case R.id.btn_play:  
129.               
130.             player = new PlayTask();  
131.             player.execute();  
132.             break;  
133.         case R.id.btn_finish:  
134.             //完成播放  
135.             this.isPlaying = false;  
136.             break;  
137.               
138.         }  
139.     }  
140.       
141.     class RecordTask extends AsyncTask<Void, Integer, Void>{  
142.         @Override  
143.         protected Void doInBackground(Void... arg0) {  
144.             isRecording = true;  
145.             try {  
146.                 //开通输出流到指定的文件  
147.                 DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(audioFile)));  
148.                 //根据定义好的几个配置，来获取合适的缓冲大小  
149.                 int bufferSize = AudioRecord.getMinBufferSize(frequence, channelConfig, audioEncoding);  
150.                 //实例化AudioRecord  
151.                 AudioRecord record = new AudioRecord(MediaRecorder.AudioSource.MIC, frequence, channelConfig, audioEncoding, bufferSize);  
152.                 //定义缓冲  
153.                 short[] buffer = new short[bufferSize];  
154.                   
155.                 //开始录制  
156.                 record.startRecording();  
157.                   
158.                 int r = 0; //存储录制进度  
159.                 //定义循环，根据isRecording的值来判断是否继续录制  
160.                 while(isRecording){  
161.                     //从bufferSize中读取字节，返回读取的short个数  
162.                     //这里老是出现buffer overflow，不知道是什么原因，试了好几个值，都没用，TODO：待解决  
163.                     int bufferReadResult = record.read(buffer, 0, buffer.length);  
164.                     //循环将buffer中的音频数据写入到OutputStream中  
165.                     for(int i=0; i<bufferReadResult; i++){  
166.                         dos.writeShort(buffer[i]);  
167.                     }  
168.                     publishProgress(new Integer(r)); //向UI线程报告当前进度  
169.                     r++; //自增进度值  
170.                 }  
171.                 //录制结束  
172.                 record.stop();  
173.                 Log.v("The DOS available:", "::"+audioFile.length());  
174.                 dos.close();  
175.             } catch (Exception e) {  
176.                 // TODO: handle exception  
177.             }  
178.             return null;  
179.         }  
180.           
181.         //当在上面方法中调用publishProgress时，该方法触发,该方法在UI线程中被执行  
182.         protected void onProgressUpdate(Integer...progress){  
183.             stateView.setText(progress[0].toString());  
184.         }  
185.           
186.         protected void onPostExecute(Void result){  
187.             btnStop.setEnabled(false);  
188.             btnStart.setEnabled(true);  
189.             btnPlay.setEnabled(true);  
190.             btnFinish.setEnabled(false);  
191.         }  
192.           
193.         protected void onPreExecute(){  
194.             //stateView.setText("正在录制");  
195.             btnStart.setEnabled(false);  
196.             btnPlay.setEnabled(false);  
197.             btnFinish.setEnabled(false);  
198.             btnStop.setEnabled(true);         
199.         }  
200.           
201.     }  
202.       
203.     class PlayTask extends AsyncTask<Void, Integer, Void>{  
204.         @Override  
205.         protected Void doInBackground(Void... arg0) {  
206.             isPlaying = true;  
207.             int bufferSize = AudioTrack.getMinBufferSize(frequence, channelConfig, audioEncoding);  
208.             short[] buffer = new short[bufferSize/4];  
209.             try {  
210.                 //定义输入流，将音频写入到AudioTrack类中，实现播放  
211.                 DataInputStream dis = new DataInputStream(new BufferedInputStream(new FileInputStream(audioFile)));  
212.                 //实例AudioTrack  
213.                 AudioTrack track = new AudioTrack(AudioManager.STREAM_MUSIC, frequence, channelConfig, audioEncoding, bufferSize, AudioTrack.MODE_STREAM);  
214.                 //开始播放  
215.                 track.play();  
216.                 //由于AudioTrack播放的是流，所以，我们需要一边播放一边读取  
217.                 while(isPlaying && dis.available()>0){  
218.                     int i = 0;  
219.                     while(dis.available()>0 && i<buffer.length){  
220.                         buffer[i] = dis.readShort();  
221.                         i++;  
222.                     }  
223.                     //然后将数据写入到AudioTrack中  
224.                     track.write(buffer, 0, buffer.length);  
225.                       
226.                 }  
227.                   
228.                 //播放结束  
229.                 track.stop();  
230.                 dis.close();  
231.             } catch (Exception e) {  
232.                 // TODO: handle exception  
233.             }  
234.             return null;  
235.         }  
236.           
237.         protected void onPostExecute(Void result){  
238.             btnPlay.setEnabled(true);  
239.             btnFinish.setEnabled(false);  
240.             btnStart.setEnabled(true);  
241.             btnStop.setEnabled(false);  
242.         }  
243.           
244.         protected void onPreExecute(){    
245.               
246.             //stateView.setText("正在播放");  
247.             btnStart.setEnabled(false);  
248.             btnStop.setEnabled(false);  
249.             btnPlay.setEnabled(false);  
250.             btnFinish.setEnabled(true);           
251.         }  
252.           
253.     }  
254. }  

Android使用AudioRecord录音相关和音频文件的封装

Posted on  2012/05/02

在Android中录音可以用MediaRecord录音，操作比较简单。但是不够专业，就是不能对音频进行处理。如果要进行音频的实时的处理或者音频的一些封装

就可以用AudioRecord来进行录音了。

这里给出一段代码。实现了AudioRecord的录音和WAV格式音频的封装。

用AudioTrack和AudioTrack类可以进行边录边播，可以参考：http://www.2cto.com/kf/201112/113210.html

我们这里的代码没有播放。但是有封装和详解，如下：

view source

print ?

001	package com.ppmeet;

002

003	import java.io.File;

004	import java.io.FileInputStream;

005	import java.io.FileNotFoundException;

006	import java.io.FileOutputStream;

007	import java.io.IOException;

008	import android.app.Activity;

009	import android.graphics.PixelFormat;

010	import android.media.AudioFormat;

011	import android.media.AudioRecord;

012	import android.media.MediaRecorder;

013	import android.os.Bundle;

014	import android.view.View;

015	import android.view.View.OnClickListener;

016	import android.view.Window;

017	import android.view.WindowManager;

018	import android.widget.Button;

019

/**

020

021	* class name：TestAudioRecord

022

023	* class description：用AudioRecord来进行录音

024

025

* PS：

026

027

*

028

029	* @version 1.00 2011/09/21

030

031	* @author CODYY)peijiangping

032

033

*/

034

035	public class TestAudioRecord extends Activity {

036

037

// 音频获取源

038

039	private int audioSource = MediaRecorder.AudioSource.MIC;

040

041	// 设置音频采样率，44100是目前的标准，但是某些设备仍然支持22050，16000，11025

042

043	private static int sampleRateInHz = 44100;

044

045	// 设置音频的录制的声道CHANNEL_IN_STEREO为双声道，CHANNEL_CONFIGURATION_MONO为单声道

046

047	private static int channelConfig = AudioFormat.CHANNEL_IN_STEREO;

048

049	// 音频数据格式:PCM 16位每个样本。保证设备支持。PCM 8位每个样本。不一定能得到设备支持。

050

051	private static int audioFormat = AudioFormat.ENCODING_PCM_16BIT;

052

053	// 缓冲区字节大小  www.2cto.com

054

055	private int bufferSizeInBytes = 0;

056

057	private Button Start;

058

059	private Button Stop;

060

061	private AudioRecord audioRecord;

062

063	private boolean isRecord = false;// 设置正在录制的状态

064

065	//AudioName裸音频数据文件

066

067	private static final String AudioName = "/sdcard/love.raw";

068

069	//NewAudioName可播放的音频文件

070

071	private static final String NewAudioName = "/sdcard/new.wav";

072

073	public void onCreate(Bundle savedInstanceState) {

074

075	super.onCreate(savedInstanceState);

076

077	getWindow().setFormat(PixelFormat.TRANSLUCENT);// 让界面横屏

078

079	requestWindowFeature(Window.FEATURE_NO_TITLE);// 去掉界面标题

080

081	getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,

082

083	WindowManager.LayoutParams.FLAG_FULLSCREEN);

084

085	// 重新设置界面大小

086

087	setContentView(R.layout.main);

088

089

init();

090

091

}

092

093	private void init() {

094

095	Start = (Button) this.findViewById(R.id.start);

096

097	Stop = (Button) this.findViewById(R.id.stop);

098

099	Start.setOnClickListener(new TestAudioListener());

100

101	Stop.setOnClickListener(new TestAudioListener());

102

103	creatAudioRecord();

104

105

}

106

107	private void creatAudioRecord() {

108

109	// 获得缓冲区字节大小

110

111	bufferSizeInBytes = AudioRecord.getMinBufferSize(sampleRateInHz,

112

113	channelConfig, audioFormat);

114

115	// 创建AudioRecord对象

116

117	audioRecord = new AudioRecord(audioSource, sampleRateInHz,

118

119	channelConfig, audioFormat, bufferSizeInBytes);

120

121

}

122

123	class TestAudioListener implements OnClickListener {

124

@Override

125	public void onClick(View v) {

126	if (v == Start) {

127	startRecord();

128

}

129	if (v == Stop) {

130	stopRecord();

131

}

132

133

}

134

135

}

136

137	private void startRecord() {

138	audioRecord.startRecording();

139	// 让录制状态为true

140	isRecord = true;

141	// 开启音频文件写入线程

142	new Thread(new AudioRecordThread()).start();

143

}

144

145	private void stopRecord() {

146

close();

147

}

148

149	private void close() {

150	if (audioRecord != null) {

151	System.out.println("stopRecord");

152	isRecord = false;//停止文件写入

153	audioRecord.stop();

154	audioRecord.release();//释放资源

155	audioRecord = null;

156

}

157

}

158

159	class AudioRecordThread implements Runnable {

160

@Override

161	public void run() {

162	writeDateTOFile();//往文件中写入裸数据

163	copyWaveFile(AudioName, NewAudioName);//给裸数据加上头文件

164

}

165

}

166

167

/**

168	* 这里将数据写入文件，但是并不能播放，因为AudioRecord获得的音频是原始的裸音频，

169	* 如果需要播放就必须加入一些格式或者编码的头信息。但是这样的好处就是你可以对音频的 裸数据进行处理，比如你要做一个爱说话的TOM

170	* 猫在这里就进行音频的处理，然后重新封装 所以说这样得到的音频比较容易做一些音频的处理。

171

*/

172	private void writeDateTOFile() {

173	// new一个byte数组用来存一些字节数据，大小为缓冲区大小

174	byte[] audiodata = new byte[bufferSizeInBytes];

175	FileOutputStream fos = null;

176	int readsize = 0;

177

try {

178	File file = new File(AudioName);

179	if (file.exists()) {

180	file.delete();

181

}

182	fos = new FileOutputStream(file);// 建立一个可存取字节的文件

183	} catch (Exception e) {

184	e.printStackTrace();

185

}

186	while (isRecord == true) {

187	readsize = audioRecord.read(audiodata, 0, bufferSizeInBytes);

188	if (AudioRecord.ERROR_INVALID_OPERATION != readsize) {

189

try {

190	fos.write(audiodata);

191	} catch (IOException e) {

192	e.printStackTrace();

193

}

194

}

195

}

196

try {

197	fos.close();// 关闭写入流

198	} catch (IOException e) {

199	e.printStackTrace();

200

}

201

}

202

203	// 这里得到可播放的音频文件

204	private void copyWaveFile(String inFilename, String outFilename) {

205	FileInputStream in = null;

206	FileOutputStream out = null;

207	long totalAudioLen = 0;

208	long totalDataLen = totalAudioLen + 36;

209	long longSampleRate = sampleRateInHz;

210	int channels = 2;

211	long byteRate = 16 * sampleRateInHz * channels / 8;

212	byte[] data = new byte[bufferSizeInBytes];

213

try {

214	in = new FileInputStream(inFilename);

215	out = new FileOutputStream(outFilename);

216	totalAudioLen = in.getChannel().size();

217	totalDataLen = totalAudioLen + 36;

218	WriteWaveFileHeader(out, totalAudioLen, totalDataLen,

219	longSampleRate, channels, byteRate);

220	while (in.read(data) != -1) {

221	out.write(data);

222

}

223	in.close();

224	out.close();

225	} catch (FileNotFoundException e) {

226	e.printStackTrace();

227	} catch (IOException e) {

228	e.printStackTrace();

229

}

230

}

231

232

/**

233	* 这里提供一个头信息。插入这些信息就可以得到可以播放的文件。

234	* 为我为啥插入这44个字节，这个还真没深入研究，不过你随便打开一个wav

235	* 音频的文件，可以发现前面的头文件可以说基本一样哦。每种格式的文件都有

236	* 自己特有的头文件。

237

*/

238	private void WriteWaveFileHeader(FileOutputStream out, longtotalAudioLen,

239	long totalDataLen, long longSampleRate, int channels,long byteRate)

240	throws IOException {

241	byte[] header = new byte[44];

242	header[0] = 'R'; // RIFF/WAVE header

243	header[1] = 'I';

244	header[2] = 'F';

245	header[3] = 'F';

246	header[4] = (byte) (totalDataLen & 0xff);

247	header[5] = (byte) ((totalDataLen >> <img src="http://www.ieulb.com/wp-includes/images/smilies/icon_cool.gif"alt="8)" class="wp-smiley"> & 0xff);

248	header[6] = (byte) ((totalDataLen >> 16) & 0xff);

249	header[7] = (byte) ((totalDataLen >> 24) & 0xff);

250	header[8] = 'W';

251	header[9] = 'A';

252	header[10] = 'V';

253	header[11] = 'E';

254	header[12] = 'f'; // 'fmt ' chunk

255	header[13] = 'm';

256	header[14] = 't';

257	header[15] = ' ';

258	header[16] = 16; // 4 bytes: size of 'fmt ' chunk

259	header[17] = 0;

260	header[18] = 0;

261	header[19] = 0;

262	header[20] = 1; // format = 1

263	header[21] = 0;

264	header[22] = (byte) channels;

265	header[23] = 0;

266	header[24] = (byte) (longSampleRate & 0xff);

267	header[25] = (byte) ((longSampleRate >> <img src="http://www.ieulb.com/wp-includes/images/smilies/icon_cool.gif"alt="8)" class="wp-smiley"> & 0xff);

268	header[26] = (byte) ((longSampleRate >> 16) & 0xff);

269	header[27] = (byte) ((longSampleRate >> 24) & 0xff);

270	header[28] = (byte) (byteRate & 0xff);

271	header[29] = (byte) ((byteRate >> <img src="http://www.ieulb.com/wp-includes/images/smilies/icon_cool.gif"alt="8)" class="wp-smiley"> & 0xff);

272	header[30] = (byte) ((byteRate >> 16) & 0xff);

273	header[31] = (byte) ((byteRate >> 24) & 0xff);

274	header[32] = (byte) (2 * 16 / 8); // block align

275	header[33] = 0;

276	header[34] = 16; // bits per sample

277	header[35] = 0;

278	header[36] = 'd';

279	header[37] = 'a';

280	header[38] = 't';

281	header[39] = 'a';

282	header[40] = (byte) (totalAudioLen & 0xff);

283	header[41] = (byte) ((totalAudioLen >> <img src="http://www.ieulb.com/wp-includes/images/smilies/icon_cool.gif"alt="8)" class="wp-smiley"> & 0xff);

284	header[42] = (byte) ((totalAudioLen >> 16) & 0xff);

285	header[43] = (byte) ((totalAudioLen >> 24) & 0xff);

286	out.write(header, 0, 44);

287

}

288

289

@Override

290	protected void onDestroy() {

291

close();

292	super.onDestroy();

293

}

294

}

http://blog.csdn.net/acu/article/details/7287730

因为上一篇博客代码有点太多，就单开了，这两天主要在看android语音录制和压缩转码相关知识，前端时间看见腾讯官方微博宣布，已经开放出即使聊天软件正在等待审批，但这个直接影响电话运营商，能通过的可能性应该不大，但我对这方面的技术很有兴趣，所以就试试看。其中涉及到很多声音方面的处理问题，在android中有两个类可以录制语音：AudioRecord和MediaRecorder，MediaRecorder主要是录制音频并写入文件，而AudioRecord主要是录制音频流，录制的音频流为pcm格式，关于pcm格式可以自行搜索一下，在传输过程中可以转换为amr格式，但没有相关可以类库有点麻烦，另外iphone不支持播放amr格式音频，如果需要跨两个平台可以使用AAC，压缩比也不错，音质也很好，我还没有测试过，网上评议而已。编码方面大家都推荐speex，我看了一下，需要是用System.loadLibrary加载进speex提供的类库。下面记录一下写的一个边录制边播放的一段代码吧

[java]  view plain copy

1. package voice.hcent.com;  
2.    
3. import java.io.IOException;  
4.    
5. import android.app.Activity;  
6. import android.os.Bundle;  
7. import android.os.Looper;  
8. import android.os.Process;  
9. import android.util.Log;  
10. import android.view.MotionEvent;  
11. import android.view.View;  
12. import android.widget.Button;  
13. import android.widget.Toast;  
14.    
15. import android.media.AudioFormat;  
16. import android.media.AudioManager;  
17. import android.media.AudioRecord;  
18. import android.media.AudioTrack;  
19. import android.media.MediaRecorder;  
20.    
21. public class VoiceHcentActivity extends Activity {  
22.    
23.     static {  
24.         System.loadLibrary("media_jni");  
25.     }  
26.    
27.     public int frequency = 8000;  
28.     private int rBufferSize, pBufferSize;  
29.     private Button startSpeech;  
30.     private AudioRecord recorder;  
31.     private VoiceSpeech vspeech;  
32.     private AudioTrack player;  
33.     private boolean stopSpeech = false;  
34.    
35.     /** Called when the activity is first created. */  
36.     @Override  
37.     public void onCreate(Bundle savedInstanceState) {  
38.         super.onCreate(savedInstanceState);  
39.         setContentView(R.layout.main);  
40.    
41.         init();  
42.    
43.         test();  
44.     }  
45.    
46.     public void init(){  
47.         try{  
48.             startSpeech = (Button)findViewById(R.id.StartSpeech);  
49.    
50.             //设置播放器缓冲区大小  
51.             pBufferSize = AudioTrack.getMinBufferSize(frequency, AudioFormat.CHANNEL_CONFIGURATION_MONO,   
52.                     AudioFormat.ENCODING_PCM_16BIT);  
53.    
54.             //获取播放器对象  
55.             player = new AudioTrack(AudioManager.STREAM_MUSIC, frequency,   
56.                     AudioFormat.CHANNEL_CONFIGURATION_MONO, AudioFormat.ENCODING_PCM_16BIT,  
57.                     pBufferSize, AudioTrack.MODE_STREAM);  
58.    
59.             //设置录音缓冲区大小  
60.             rBufferSize = AudioRecord.getMinBufferSize(frequency,   
61.                     AudioFormat.CHANNEL_CONFIGURATION_MONO, AudioFormat.ENCODING_PCM_16BIT);  
62.    
63.             //获取录音机对象  
64.             recorder = new AudioRecord(MediaRecorder.AudioSource.MIC,   
65.                     frequency, AudioFormat.CHANNEL_CONFIGURATION_MONO,   
66.                     AudioFormat.ENCODING_PCM_16BIT, rBufferSize);  
67.    
68.         }catch (Exception e) {  
69.             String msg = "ERROR init: "+e.getStackTrace();  
70.             VoiceHcentActivity.this.toastMsg(msg);  
71.         }  
72.     }  
73.    
74.     /** 
75.      * 开始录音 
76.      */  
77.     public void startRecord(){  
78.         stopSpeech = false;  
79.         vspeech = new VoiceSpeech();  
80.         vspeech.start();  
81.     }  
82.    
83.     /** 
84.      * 结束录音 
85.      */  
86.     public void stopRecord() {  
87.         stopSpeech = true;  
88.     }  
89.    
90.     /** 
91.      * 开始播放录音 
92.      */  
93.     public void startPlay(){  
94.    
95.         //设置播放器音量  
96.         player.setStereoVolume(0.7f, 0.7f);  
97.    
98.         player.play();  
99.     }  
100.    
101.     /** 
102.      * 结束播放录音 
103.      */  
104.     public void stopPlay(){  
105.         player.stop();  
106.     }  
107.    
108.     public void test(){  
109.    
110.         startSpeech.setOnTouchListener(new View.OnTouchListener() {  
111.    
112.             public boolean onTouch(View arg0, MotionEvent arg1) {  
113.    
114.                 switch (arg1.getAction()) {  
115.    
116.                     case MotionEvent.ACTION_DOWN: //开始说话  
117.                         startPlay();  
118.                         startRecord();  
119.    
120.                         toastMsg("starting record!");  
121.                         break;  
122.    
123.                     case MotionEvent.ACTION_UP: //停止说话  
124.                         Log.i("hcent", "111");  
125.                         stopPlay();  
126.                         Log.i("hcent", "222");  
127.                         stopRecord();  
128.                         toastMsg("stoped record!");  
129.                         break;  
130.    
131.                     default:  
132.                         break;  
133.                 }  
134.    
135.                 return false;  
136.             }  
137.         });  
138.    
139.     }  
140.    
141.     public class VoiceSpeech extends Thread{  
142.    
143.         @Override  
144.         public void run() {  
145.             super.run();  
146.             try {  
147.                 byte[] tempBuffer, readBuffer = new byte[rBufferSize];  
148.                 int bufResult = 0;  
149.                 recorder.startRecording();  
150.                 while(!stopSpeech){  
151.                     bufResult = recorder.read(readBuffer, 0, rBufferSize);  
152.                     if(bufResult>0 && bufResult%2==0){  
153.                         tempBuffer = new byte[bufResult];  
154.                         System.arraycopy(readBuffer, 0, tempBuffer, 0, rBufferSize);  
155.                         player.write(tempBuffer, 0, tempBuffer.length);  
156.                     }  
157.                     Log.d("hcent", "get read:"+bufResult+"___"+readBuffer.length);  
158.                 }  
159.                 recorder.stop();  
160.                 Looper.prepare();  
161.                 VoiceHcentActivity.this.toastMsg("AudioSpeech have ended!");  
162.                 Looper.loop();    
163.             } catch (Exception e) {  
164.                 String msg = "ERROR AudioRecord: "+e.getStackTrace();  
165.                 Looper.prepare();  
166.                 VoiceHcentActivity.this.toastMsg(msg);  
167.                 Looper.loop();  
168.             }        
169.         }  
170.     }  
171.     @Override  
172.     protected void onDestroy(){  
173.         player.release();  
174.         recorder.release();  
175.         super.onDestroy();  
176.         Process.killProcess(Process.myPid());  
177.     }  
178.     public void toastMsg(String msg){  
179.         Toast.makeText(this, msg, Toast.LENGTH_SHORT).show();  
180.         Log.e("hcent", msg);  
181.     }    
182. }