Android-音频收罗

前言

音视频这块，起首是要先收罗音频。今天我们就来深入探讨一下 Android 音频收罗的两大类型：Mic 音频收罗和系统音频收罗。

Mic音频收罗

Android提供了两个API用于实现录音功能：android.media.AudioRecord、android.media.MediaRecorder。

AudioRecord和MediaRecorder两种都可以录制音频，MediaRecorder已实现大量的封装，操作起来更加简单，而AudioRecord使用起来更加灵活，能实现更多的功能。

AudioRecord


主要是实现边录边播（AudioRecord+AudioTrack）以及对音频的及时处置处罚（如会说话的汤姆猫、语音）
优点：语音的及时处置处罚，可以用代码实现各种音频的封装
缺点：输出是PCM语音数据，如果生存成音频文件，是不能够被播放器播放的，以是必须先写代码实现数据编码以及压缩
示例：
使用AudioRecord类录音，并实现WAV格式封装。录音20s，输出的音频文件大概为3.5M左（已写测试代码）

特点：

• 基于字节省录音；
  
• 可以实现语音的及时处置处罚，举行边录边播，对音频的及时处置处罚；
  
• AudioRecord是一个比较偏底层的API,它可以获取到一帧帧PCM数据，之后可以对这些数据举行处置处罚；
  
• 输出的是PCM的语音数据，如果生存成音频文件是不能被播放器播放的。要用到AudioTrack这个去举行处置处罚；
  

MediaRecorder


已经集成了录音、编码、压缩等，支持少量的录音音频格式，大概有.aac（API = 16） .amr .3gp
优点：大部分以及集成，直接调用相干接口即可，代码量小
缺点：无法及时处置处罚音频；输出的音频格式不是很多，例如没有输出mp3格式文件
示例：
使用MediaRecorder类录音，输出amr格式文件。录音20s，输出的音频文件大概为33K（已写测试代码）
特点：

• 基于文件录音；
  
• MediaRecorder 是基于 AudioRecorder 的 API(终极还是会创建AudioRecord用来与AudioFlinger举行交互) ，它可以直接将收罗到的音频数据转化为执行的编码格式，并生存；
  
• 已集成了录音，编码，压缩等，支持少量的音频格式文件；
  
• 封装度很高，操作简单；
  

音频格式比较


WAV格式：录音质量高，但是压缩率小，文件大。

AAC格式：相对于mp3，AAC格式的音质更佳，文件更小；有损压缩；一般苹果或者Android SDK4.1.2（API 16）及以上版本支持播放 。

AMR格式：压缩比比较大，但相对其他的压缩格式质量比较差，多用于人声，通话录音
mp3格式：使用MediaRecorder没有该视频格式输出。一些人的做法是使用AudioRecord录音，然后编码成wav格式，再转换成mp3格式。

测试代码

audioRecord 封装wav 格式。

1. package com.example.audiorecordtest;
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;
9. import android.media.AudioFormat;
10. import android.media.AudioRecord;
12. public class AudioRecordFunc {
13.     // 缓冲区字节大小  
14.     private int bufferSizeInBytes = 0;
15.      
16.     //AudioName裸音频数据文件 ，麦克风
17.     private String AudioName = "";  
18.      
19.     //NewAudioName可播放的音频文件  
20.     private String NewAudioName = "";
21.      
22.     private AudioRecord audioRecord;  
23.     private boolean isRecord = false;// 设置正在录制的状态  
24.      
25.      
26.     private static AudioRecordFunc mInstance;
27.          
28.     private AudioRecordFunc(){
29.          
30.     }   
31.      
32.     public synchronized static AudioRecordFunc getInstance()
33.     {
34.         if(mInstance == null)
35.             mInstance = new AudioRecordFunc();
36.         return mInstance;
37.     }
38.      
39.     public int startRecordAndFile() {
40.         //判断是否有外部存储设备sdcard
41.         if(AudioFileFunc.isSdcardExit())
42.         {
43.             if(isRecord)
44.             {
45.                 return ErrorCode.E_STATE_RECODING;
46.             }
47.             else
48.             {
49.                 if(audioRecord == null)
50.                     creatAudioRecord();
51.                  
52.                 audioRecord.startRecording();  
53.                 // 让录制状态为true  
54.                 isRecord = true;  
55.                 // 开启音频文件写入线程  
56.                 new Thread(new AudioRecordThread()).start();  
57.                  
58.                 return ErrorCode.SUCCESS;
59.             }
60.             
61.         }      
62.         else
63.         {
64.             return ErrorCode.E_NOSDCARD;            
65.         }      
67.     }  
68.    
69.     public void stopRecordAndFile() {  
70.         close();  
71.     }
72.      
73.      
74.     public long getRecordFileSize(){
75.         return AudioFileFunc.getFileSize(NewAudioName);
76.     }
77.      
78.    
79.     private void close() {  
80.         if (audioRecord != null) {  
81.             System.out.println("stopRecord");  
82.             isRecord = false;//停止文件写入  
83.             audioRecord.stop();  
84.             audioRecord.release();//释放资源  
85.             audioRecord = null;  
86.         }  
87.     }
88.      
89.      
90.     private void creatAudioRecord() {  
91.         // 获取音频文件路径
92.         AudioName = AudioFileFunc.getRawFilePath();
93.         NewAudioName = AudioFileFunc.getWavFilePath();
94.          
95.         // 获得缓冲区字节大小  
96.         bufferSizeInBytes = AudioRecord.getMinBufferSize(AudioFileFunc.AUDIO_SAMPLE_RATE,  
97.                 AudioFormat.CHANNEL_IN_STEREO, AudioFormat.ENCODING_PCM_16BIT);  
98.          
99.         // 创建AudioRecord对象  
100.         audioRecord = new AudioRecord(AudioFileFunc.AUDIO_INPUT, AudioFileFunc.AUDIO_SAMPLE_RATE,  
101.                 AudioFormat.CHANNEL_IN_STEREO, AudioFormat.ENCODING_PCM_16BIT, bufferSizeInBytes);  
102.     }
103.      
104.      
105.     class AudioRecordThread implements Runnable {  
106.         @Override
107.         public void run() {  
108.             writeDateTOFile();//往文件中写入裸数据  
109.             copyWaveFile(AudioName, NewAudioName);//给裸数据加上头文件  
110.         }  
111.     }  
112.    
113.     /**
114.      * 这里将数据写入文件，但是并不能播放，因为AudioRecord获得的音频是原始的裸音频，
115.      * 如果需要播放就必须加入一些格式或者编码的头信息。但是这样的好处就是你可以对音频的 裸数据进行处理，比如你要做一个爱说话的TOM
116.      * 猫在这里就进行音频的处理，然后重新封装 所以说这样得到的音频比较容易做一些音频的处理。
117.      */
118.     private void writeDateTOFile() {  
119.         // new一个byte数组用来存一些字节数据，大小为缓冲区大小  
120.         byte[] audiodata = new byte[bufferSizeInBytes];  
121.         FileOutputStream fos = null;  
122.         int readsize = 0;  
123.         try {  
124.             File file = new File(AudioName);  
125.             if (file.exists()) {  
126.                 file.delete();  
127.             }  
128.             fos = new FileOutputStream(file);// 建立一个可存取字节的文件  
129.         } catch (Exception e) {  
130.             e.printStackTrace();  
131.         }  
132.         while (isRecord == true) {  
133.             readsize = audioRecord.read(audiodata, 0, bufferSizeInBytes);  
134.             if (AudioRecord.ERROR_INVALID_OPERATION != readsize && fos!=null) {  
135.                 try {  
136.                     fos.write(audiodata);  
137.                 } catch (IOException e) {  
138.                     e.printStackTrace();  
139.                 }  
140.             }  
141.         }  
142.         try {
143.             if(fos != null)
144.                 fos.close();// 关闭写入流  
145.         } catch (IOException e) {  
146.             e.printStackTrace();  
147.         }  
148.     }  
149.    
150.     // 这里得到可播放的音频文件  
151.     private void copyWaveFile(String inFilename, String outFilename) {  
152.         FileInputStream in = null;  
153.         FileOutputStream out = null;  
154.         long totalAudioLen = 0;  
155.         long totalDataLen = totalAudioLen + 36;  
156.         long longSampleRate = AudioFileFunc.AUDIO_SAMPLE_RATE;  
157.         int channels = 2;  
158.         long byteRate = 16 * AudioFileFunc.AUDIO_SAMPLE_RATE * channels / 8;  
159.         byte[] data = new byte[bufferSizeInBytes];  
160.         try {  
161.             in = new FileInputStream(inFilename);  
162.             out = new FileOutputStream(outFilename);  
163.             totalAudioLen = in.getChannel().size();  
164.             totalDataLen = totalAudioLen + 36;  
165.             WriteWaveFileHeader(out, totalAudioLen, totalDataLen,  
166.                     longSampleRate, channels, byteRate);  
167.             while (in.read(data) != -1) {  
168.                 out.write(data);  
169.             }  
170.             in.close();  
171.             out.close();  
172.         } catch (FileNotFoundException e) {  
173.             e.printStackTrace();  
174.         } catch (IOException e) {  
175.             e.printStackTrace();  
176.         }  
177.     }  
178.    
179.     /**
180.      * 这里提供一个头信息。插入这些信息就可以得到可以播放的文件。
181.      * 为我为啥插入这44个字节，这个还真没深入研究，不过你随便打开一个wav
182.      * 音频的文件，可以发现前面的头文件可以说基本一样哦。每种格式的文件都有
183.      * 自己特有的头文件。
184.      */
185.     private void WriteWaveFileHeader(FileOutputStream out, long totalAudioLen,  
186.             long totalDataLen, long longSampleRate, int channels, long byteRate)  
187.             throws IOException {  
188.         byte[] header = new byte[44];  
189.         header[0] = 'R'; // RIFF/WAVE header  
190.         header[1] = 'I';  
191.         header[2] = 'F';  
192.         header[3] = 'F';  
193.         header[4] = (byte) (totalDataLen & 0xff);  
194.         header[5] = (byte) ((totalDataLen >> 8) & 0xff);  
195.         header[6] = (byte) ((totalDataLen >> 16) & 0xff);  
196.         header[7] = (byte) ((totalDataLen >> 24) & 0xff);  
197.         header[8] = 'W';  
198.         header[9] = 'A';  
199.         header[10] = 'V';  
200.         header[11] = 'E';  
201.         header[12] = 'f'; // 'fmt ' chunk  
202.         header[13] = 'm';  
203.         header[14] = 't';  
204.         header[15] = ' ';  
205.         header[16] = 16; // 4 bytes: size of 'fmt ' chunk  
206.         header[17] = 0;  
207.         header[18] = 0;  
208.         header[19] = 0;  
209.         header[20] = 1; // format = 1  
210.         header[21] = 0;  
211.         header[22] = (byte) channels;  
212.         header[23] = 0;  
213.         header[24] = (byte) (longSampleRate & 0xff);  
214.         header[25] = (byte) ((longSampleRate >> 8) & 0xff);  
215.         header[26] = (byte) ((longSampleRate >> 16) & 0xff);  
216.         header[27] = (byte) ((longSampleRate >> 24) & 0xff);  
217.         header[28] = (byte) (byteRate & 0xff);  
218.         header[29] = (byte) ((byteRate >> 8) & 0xff);  
219.         header[30] = (byte) ((byteRate >> 16) & 0xff);  
220.         header[31] = (byte) ((byteRate >> 24) & 0xff);  
221.         header[32] = (byte) (2 * 16 / 8); // block align  
222.         header[33] = 0;  
223.         header[34] = 16; // bits per sample  
224.         header[35] = 0;  
225.         header[36] = 'd';  
226.         header[37] = 'a';  
227.         header[38] = 't';  
228.         header[39] = 'a';  
229.         header[40] = (byte) (totalAudioLen & 0xff);  
230.         header[41] = (byte) ((totalAudioLen >> 8) & 0xff);  
231.         header[42] = (byte) ((totalAudioLen >> 16) & 0xff);  
232.         header[43] = (byte) ((totalAudioLen >> 24) & 0xff);  
233.         out.write(header, 0, 44);  
234.     }  
235. }

复制代码

MediaRecorder录音，输出amr格式音频

1. package com.example.audiorecordtest;
3. import java.io.File;
4. import java.io.IOException;
6. import android.media.MediaRecorder;
8. public class MediaRecordFunc {  
9.     private boolean isRecord = false;
10.      
11.     private MediaRecorder mMediaRecorder;
12.     private MediaRecordFunc(){
13.     }
14.      
15.     private static MediaRecordFunc mInstance;
16.     public synchronized static MediaRecordFunc getInstance(){
17.         if(mInstance == null)
18.             mInstance = new MediaRecordFunc();
19.         return mInstance;
20.     }
21.      
22.     public int startRecordAndFile(){
23.         //判断是否有外部存储设备sdcard
24.         if(AudioFileFunc.isSdcardExit())
25.         {
26.             if(isRecord)
27.             {
28.                 return ErrorCode.E_STATE_RECODING;
29.             }
30.             else
31.             {
32.                 if(mMediaRecorder == null)
33.                     createMediaRecord();
34.                  
35.                 try{
36.                     mMediaRecorder.prepare();
37.                     mMediaRecorder.start();
38.                     // 让录制状态为true  
39.                     isRecord = true;
40.                     return ErrorCode.SUCCESS;
41.                 }catch(IOException ex){
42.                     ex.printStackTrace();
43.                     return ErrorCode.E_UNKOWN;
44.                 }
45.             }
46.             
47.         }      
48.         else
49.         {
50.             return ErrorCode.E_NOSDCARD;            
51.         }      
52.     }
53.      
54.      
55.     public void stopRecordAndFile(){
56.          close();
57.     }
58.      
59.     public long getRecordFileSize(){
60.         return AudioFileFunc.getFileSize(AudioFileFunc.getAMRFilePath());
61.     }
62.      
63.      
64.     private void createMediaRecord(){
65.          /* ①Initial：实例化MediaRecorder对象 */
66.         mMediaRecorder = new MediaRecorder();
67.          
68.         /* setAudioSource/setVedioSource*/
69.         mMediaRecorder.setAudioSource(AudioFileFunc.AUDIO_INPUT);//设置麦克风
70.          
71.         /* 设置输出文件的格式：THREE_GPP/MPEG-4/RAW_AMR/Default
72.          * THREE_GPP(3gp格式，H263视频/ARM音频编码)、MPEG-4、RAW_AMR(只支持音频且音频编码要求为AMR_NB)
73.          */
74.          mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.DEFAULT);
75.          
76.          /* 设置音频文件的编码：AAC/AMR_NB/AMR_MB/Default */
77.          mMediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.DEFAULT);
78.          
79.          /* 设置输出文件的路径 */
80.          File file = new File(AudioFileFunc.getAMRFilePath());
81.          if (file.exists()) {  
82.              file.delete();  
83.          }
84.          mMediaRecorder.setOutputFile(AudioFileFunc.getAMRFilePath());
85.     }
86.      
87.      
88.     private void close(){
89.         if (mMediaRecorder != null) {  
90.             System.out.println("stopRecord");  
91.             isRecord = false;
92.             mMediaRecorder.stop();  
93.             mMediaRecorder.release();  
94.             mMediaRecorder = null;
95.         }  
96.     }
97. }

复制代码

其他文件 

1. package com.example.audiorecordtest;
3. import java.io.File;
5. import android.media.MediaRecorder;
6. import android.os.Environment;
8. public class AudioFileFunc {
9.     //音频输入-麦克风
10.     public final static int AUDIO_INPUT = MediaRecorder.AudioSource.MIC;
11.      
12.     //采用频率
13.     //44100是目前的标准，但是某些设备仍然支持22050，16000，11025
14.     public final static int AUDIO_SAMPLE_RATE = 44100;  //44.1KHz,普遍使用的频率   
15.     //录音输出文件
16.     private final static String AUDIO_RAW_FILENAME = "RawAudio.raw";
17.     private final static String AUDIO_WAV_FILENAME = "FinalAudio.wav";
18.     public final static String AUDIO_AMR_FILENAME = "FinalAudio.amr";
19.      
20.     /**
21.      * 判断是否有外部存储设备sdcard
22.      * @return true | false
23.      */
24.     public static boolean isSdcardExit(){      
25.         if (Environment.getExternalStorageState().equals(android.os.Environment.MEDIA_MOUNTED))
26.             return true;
27.         else
28.             return false;
29.     }
30.          
31.     /**
32.      * 获取麦克风输入的原始音频流文件路径
33.      * @return
34.      */
35.     public static String getRawFilePath(){
36.         String mAudioRawPath = "";
37.         if(isSdcardExit()){
38.             String fileBasePath = Environment.getExternalStorageDirectory().getAbsolutePath();
39.             mAudioRawPath = fileBasePath+"/"+AUDIO_RAW_FILENAME;
40.         }   
41.          
42.         return mAudioRawPath;
43.     }
44.      
45.     /**
46.      * 获取编码后的WAV格式音频文件路径
47.      * @return
48.      */
49.     public static String getWavFilePath(){
50.         String mAudioWavPath = "";
51.         if(isSdcardExit()){
52.             String fileBasePath = Environment.getExternalStorageDirectory().getAbsolutePath();
53.             mAudioWavPath = fileBasePath+"/"+AUDIO_WAV_FILENAME;
54.         }
55.         return mAudioWavPath;
56.     }
57.      
58.      
59.     /**
60.      * 获取编码后的AMR格式音频文件路径
61.      * @return
62.      */
63.     public static String getAMRFilePath(){
64.         String mAudioAMRPath = "";
65.         if(isSdcardExit()){
66.             String fileBasePath = Environment.getExternalStorageDirectory().getAbsolutePath();
67.             mAudioAMRPath = fileBasePath+"/"+AUDIO_AMR_FILENAME;
68.         }
69.         return mAudioAMRPath;
70.     }   
71.      
72.      
73.     /**
74.      * 获取文件大小
75.      * @param path,文件的绝对路径
76.      * @return
77.      */
78.     public static long getFileSize(String path){
79.         File mFile = new File(path);
80.         if(!mFile.exists())
81.             return -1;
82.         return mFile.length();
83.     }
85. }

复制代码

总结

AudioRecord这种方式收罗最为灵活，使开辟者最大限度的处置处罚收罗的音频,同时它捕获到的音频是原始音频PCM格式的！像做变声处置处罚的必要就必须要用它收集音频；

系统音频收罗


系统音频收罗有两种方法，但都有范围性。

2.1 REMOTE_SUBMIX


2.2 AudioPlaybackCapture




免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。