Android中的录音与音频合成

原文：http://blog.csdn.net/u013676055/article/details/50440893

IOS的框架层有许多有趣的特性，使得它可以将多条音轨合并成一条音轨。你可以使用Audio Unit 和它提供的方法

但是你想要一个类似的功能在Android上？Android的音频框架层并不支持这个。所以我用了几天时间在Google群和StackOverflow上边，去阅读上边的未答问题、搜索一些谷歌手机上边类似的方法或由第三方开发并发布的贡献者和外部开发者。

但是我发现并没有什么可用的信息。

所以我不得不去研究这些问题和工具来解决这个问题。首先我们先来看看平台提供的播放文件的发展性。

 

Android 音频框架的音频播放层包含这些主要的类:

• MediaPlayer:主要播放压缩过的文件(m4a,mp3…)和没有被压缩过但是格式化的(wav)。不能同时播放多个文件。
• SoundPool:可以同时播放多个原生声音文件。
• AudioTrack:可以当做SoundPool使用，但是同时播放多个文件时需要开启线程。

我发现AudioTrack在播放未压缩文件时表现的很好，如果你想同时播放多个文件，你可以创建不同的线程然后开始异步播放。

不幸的是这会出现一些问题：有时候你会发现在播放音频之前会有一些延迟，这导致这个方法不可行。

另一个想法是在播放之前将音频混合。这个还有一个好处：你会获得一个已经混合好的混音文件。如果你用SoundPool实例混音，当你播放的时候，你就只能将音频输出到硬件上（耳机或者扬声器），而不能将之重定向到文件描述。

就像最开始提及的，这个问题还没有解决方案。但是事实上，我们会看见一些琐碎的解决方案。

在研究具体两个音频如何混合到一起之前，我们先看一下在Android上的录音。主要的类有：

• MediaRecorder:MediaPlayer的兄弟类，可以录制不同个是的一品文件(arm,aac)
• AudioRecord:AudioTrack的兄弟类。它录制PCM格式的音频。它是用于CD的未压缩数字音频格式，和wav很相似。
• AudioRecord 提供了所有我们想要控制的东西，我们可以特定它的频率，声道数量等等

[java]  view plain  copy

1. public static final int FREQUENCY = 44100;  
2. public static final int CHANNEL_CONFIGURATION = AudioFormat.CHANNEL_CONFIGURATION_MONO;  
3. public static final int AUDIO_ENCODING =  AudioFormat.ENCODING_PCM_16BIT;  
4.   
5.   
6.     private void recordSound(){  
7.         File file = new File(Environment.getExternalStorageDirectory().getAbsolutePath() + "/"+RECORDE                              D_FILENAME);  
8.         // Delete any previous recording.  
9.         if (file.exists())  
10.             file.delete();  
11.   
12.         try {  
13.             file.createNewFile();  
14.   
15.             // Create a DataOuputStream to write the audio data into the saved file.  
16.             OutputStream os = new FileOutputStream(file);  
17.             BufferedOutputStream bos = new BufferedOutputStream(os);  
18.             DataOutputStream dos = new DataOutputStream(bos);  
19.   
20.   
21.   
22.             // Create a new AudioRecord object to record the audio.  
23.             int bufferSize = AudioRecord.getMinBufferSize(FREQUENCY, CHANNEL_CONFIGURATION, AUDIO_                                   ENCODING);  
24.             AudioRecord audioRecord = new AudioRecord(MediaRecorder.AudioSource.MIC, FREQUENCY, CH                                            ANNEL_CONFIGURATION, AUDIO_ENCODING, bufferSize);  
25.   
26.             short[] buffer = new short[bufferSize];  
27.             audioRecord.startRecording();  
28.   
29.   
30.             while (isRecording) {  
31.                 int bufferReadResult = audioRecord.read(buffer, 0, bufferSize);  
32.                 for (int i = 0; i < bufferReadResult; i++)  
33.                 dos.writeShort(buffer[i]);  
34.             }  
35.   
36.             audioRecord.stop();  
37.             audioRecord.release();  
38.             dos.close();  
39.         } catch (FileNotFoundException e) {  
40.             e.printStackTrace();  
41.         } catch (IllegalArgumentException e) {  
42.             e.printStackTrace();  
43.         } catch (IllegalStateException e) {  
44.             e.printStackTrace();  
45.         } catch (IOException e) {  
46.             e.printStackTrace();  
47.         }  
48.   
49.     }  

在上边贴出来的代码段里,有一个简单的函数,可以用来录44.1 khz 16位PCM音频并保存在SD卡上。这个方法是阻塞的，所以必须在次级线程上运行；它会一直录制，直到isRecording变成false(比如超时或者用户点击按钮停止)

现在是最有趣的部分了：怎么能让两个声音混合到一起呢？

如果两个数字音频有同样的特性（同样的声道数，同样的采样率等）那么将他们混合是比较容易的。这是最简单的也是这篇文章中我唯一涵盖的方案。

在这里每个样本是一个16位数字。在java中一个短整型可以用来代表16位数字，事实上AudioRecord和AudioTrack都是以short数组工作的，它构成了我们的声音。

这是用来合成三个音频的主要方法:

[java]  view plain  copy

1. private void mixFiles() {  
2.         try {  
3.             InputStream is1 = getResources().openRawResource(R.raw.test1);  
4.             List<Short> music1 = createMusicArray(is1);  
5.   
6.             InputStream is2 = getResources().openRawResource(R.raw.test2);  
7.             List<Short> music2 = createMusicArray(is2);  
8.   
9.             InputStream is3 = getResources().openRawResource(R.raw.test3);  
10.             List<Short> music3 = createMusicArray(is3);  
11.   
12.             completeStreams(music1, music2, music3);  
13.             short[] music1Array = buildShortArray(music1);  
14.             short[] music2Array = buildShortArray(music2);  
15.             short[] music3Array = buildShortArray(music3);  
16.   
17.             short[] output = new short[music1Array.length];  
18.             for (int i = 0; i < output.length; i++) {  
19.   
20.                 float samplef1 = music1Array[i] / 32768.0f;  
21.                 float samplef2 = music2Array[i] / 32768.0f;  
22.                 float samplef3 = music3Array[i] / 32768.0f;  
23.   
24.                 float mixed = samplef1 + samplef2 + samplef3;  
25.                 // reduce the volume a bit:  
26.                 mixed *= 0.8;  
27.                 // hard clipping  
28.                 if (mixed > 1.0f) mixed = 1.0f;  
29.                 if (mixed < -1.0f) mixed = -1.0f;  
30.                 short outputSample = (short) (mixed * 32768.0f);  
31.                 output[i] = outputSample;  
32.             }  
33.             saveToFile(output);  
34.         } catch (NotFoundException e) {  
35.             e.printStackTrace();  
36.         } catch (IOException e) {  
37.             e.printStackTrace();  
38.         }  
39.     }  

还有一些其它补充的代码，因为帖子现在已经太长了我没有贴出来，但是关于它们实现了什么有一些小提示：

创建

• createMusicArray 读取流并且返回一个List<Short>
• completeStreams 通过给尾部添加一系列'0'使得较小的文件正常化。最重三个文件会有同样的长度。
• buildShortArray 将List<Short>转为short[]
• saveToFile 保存文件 :)

这个方法中的重点就是我们把所有样本求和。使short转为float[-1,1]，这样就不会出现溢出的问题。在最后我们减少了一点音量，然后我们把它保存到一个新的数组。这样就完成了!

当然，这只是最简单的方案。如果样本不是这样的话我们就需要其他的计算。但我认为大多我们要混音的时候，我们可以控制它的录制方式从而减少其复杂性。

一旦我们有了一个合成的PCM文件，我们就可以让它转为.wav文件这样每个播放器就都可以播放它了。补充：很多人都曾问我要更多的帮助，那么下边就是从原生流文件创建short array 的代码。

[java]  view plain  copy

1. /** 
2.      * Dealing with big endian streams 
3.      * 
4.      * @param byte0 
5.      * @param byte1 
6.      * @return a shrt with the two bytes swapped 
7.      */  
8.     private static short swapBytes(byte byte0, byte byte1) {  
9.         return (short) ((byte1 & 0xff) << 8 | (byte0 & 0xff));  
10.     }  
11.   
12.     /** 
13.      * From file to byte[] array 
14.      * 
15.      * @param sample 
16.      * @param swap   should swap bytes? 
17.      * @return 
18.      * @throws IOException 
19.      */  
20.     public static byte[] sampleToByteArray(File sample, boolean swap) throws IOException {  
21.         ByteArrayOutputStream baos = new ByteArrayOutputStream();  
22.   
23.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(sample));  
24.         int BUFFERSIZE = 4096;  
25.         byte[] buffer = new byte[BUFFERSIZE];  
26.         while (bis.read(buffer) != -1) {  
27.             baos.write(buffer);  
28.         }  
29.         byte[] outputByteArray = baos.toByteArray();  
30.         bis.close();  
31.         baos.close();  
32.   
33.         if (swap) {  
34.             for (int i = 0; i < outputByteArray.length - 1; i = i + 2) {  
35.                 byte byte0 = outputByteArray[i];  
36.                 outputByteArray[i] = outputByteArray[i + 1];  
37.                 outputByteArray[i + 1] = byte0;  
38.             }  
39.         }  
40.   
41.         return outputByteArray;  
42.     }  
43.   
44.     /** 
45.      * Read a file and returns its contents as array of shorts 
46.      * 
47.      * @param sample the sample file 
48.      * @param swap   true if we should swap the bytes of short (reading a little-endian file), false otherwise (readin        g a big-endian file) 
49.      * @return 
50.      * @throws IOException 
51.      */  
52.     public static short[] sampleToShortArray(File sample, boolean swap) throws IOException {  
53.         short[] outputArray = new short[(int) sample.length() / 2];  
54.   
55.   
56.         byte[] outputByteArray = sampleToByteArray(sample, false);  
57.   
58.   
59.         for (int i = 0, j = 0; i < outputByteArray.length; i += 2, j++) {  
60.             if (swap) {  
61.                 outputArray[j] = swapBytes(outputByteArray[i], outputByteArray[i + 1]);  
62.             } else {  
63.                 outputArray[j] = swapBytes(outputByteArray[i + 1], outputByteArray[i]);  
64.             }  
65.         }  
66.         return outputArray;  
67.     }  

原文链接