详解如何使用代码进行音频合成

作者：郑童宇

1.前言

　　音频合成在现实生活中应用广泛，在网上可以搜索到不少相关的讲解和代码实现，但个人感觉在网上搜索到的音频合成相关文章的讲解都并非十分透彻，故而写下本篇博文，计划通过讲解如何使用代码实现音频合成功能从而将本人对音频合成的理解阐述给各位，力图读完的各位可以对音频合成整体过程有一个清晰的了解。

　　本篇博文以Java为示例语言，以Android为示例平台。

　　本篇博文着力于讲解音频合成实现原理与过程中的细节和潜在问题，目的是让各位不被编码语言所限制，在本质上理解如何实现音频合成的功能。

2.音频合成

2.1.功能简介

　　本次实现的音频合成功能参考"唱吧"的音频合成，功能流程是：录音生成PCM文件，接着根据录音时长对背景音乐文件进行解码加裁剪，同时将解码后的音频调制到与录音文件相同的采样率，采样点字节数，声道数，接着根据指定系数对两个音频文件进行音量调节并合成为PCM文件，最后进行压缩编码生成MP3文件。

2.2.功能实现

2.2.1.录音

　　录音功能生成的目标音频格式是PCM格式，对于PCM的定义，维基百科上是这么写到的："Pulse-code modulation (PCM) is a method used to digitally represent sampled analog signals. It is the standard form of digital audio in computers, Compact Discs, digital telephony and other digital audio applications. In a PCM stream, the amplitude of the analog signal is sampled regularly at uniform intervals, and each sample is quantized to the nearest value within a range of digital steps."，大致意思是PCM是用来采样模拟信号的一种方法，是现在数字音频应用中数字音频的标准格式，而PCM采样的原理，是均匀间隔的将模拟信号的振幅量化成指定数据范围内最贴近的数值。

　　PCM文件存储的数据是不经压缩的纯音频数据，当然只是这么说可能有些抽象，我们拉上大家熟知的MP3文件进行对比，MP3文件存储的是压缩后的音频，PCM与MP3两者之间的关系简单说就是：PCM文件经过MP3压缩算法处理后生成的文件就是MP3文件。我们简单比较一下双方存储所消耗的空间，1分钟的每采样点16位的双声道的44.1kHz采样率PCM文件大小为：1*60*16/8*2*44.1*1000/1024=10335.9375KB，约为10MB，而对应的128kps的MP3文件大小仅为1MB左右，既然PCM文件占用存储空间这么大，我们是不是应该放弃使用PCM格式存储录音，恰恰相反，注意第一句话:"PCM文件存储的数据是不经压缩的纯音频数据"，这意味只有PCM格式的音频数据是可以用来直接进行声音处理，例如进行音量调节，声音滤镜等操作，相对的其他的音频编码格式都是必须解码后才能进行处理（PCM编码的WAV文件也得先读取文件头），当然这不代表PCM文件就好用，因为没有文件头，所以进行处理或者播放之前我们必须事先知道PCM文件的声道数，采样点字节数，采样率，编码大小端，这在大多数情况下都是不可能的，事实上就我所知没有播放器是直接支持PCM文件的播放。不过现在录音的各项系数都是我们定义的，所以我们就不用担心这个问题。

　　背景知识了解这些就足够了，下面我给出实现代码，综合代码讲解实现过程。

 1     if (recordVoice) {
 2         audioRecord = new AudioRecord(MediaRecorder.AudioSource.MIC,
 3                 Constant.RecordSampleRate, AudioFormat.CHANNEL_IN_MONO,
 4                 pcmFormat.getAudioFormat(), audioRecordBufferSize);
 5 
 6         try {
 7             audioRecord.startRecording();
 8         } catch (Exception e) {
 9             NoRecordPermission();
10             continue;
11         }
12 
13         BufferedOutputStream bufferedOutputStream = FileFunction
14                 .GetBufferedOutputStreamFromFile(recordFileUrl);
15 
16         while (recordVoice) {
17             int audioRecordReadDataSize =
18                     audioRecord.read(audioRecordBuffer, 0, audioRecordBufferSize);
19 
20             if (audioRecordReadDataSize > 0) {
21                 calculateRealVolume(audioRecordBuffer, audioRecordReadDataSize);
22                 if (bufferedOutputStream != null) {
23                     try {
24                         byte[] outputByteArray = CommonFunction
25                                 .GetByteBuffer(audioRecordBuffer,
26                                         audioRecordReadDataSize, Variable.isBigEnding);
27                         bufferedOutputStream.write(outputByteArray);
28                     } catch (IOException e) {
29                         e.printStackTrace();
30                     }
31                 }
32             } else {
33                 NoRecordPermission();
34                 continue;
35             }
36         }
37 
38         if (bufferedOutputStream != null) {
39             try {
40                 bufferedOutputStream.close();
41             } catch (Exception e) {
42                 LogFunction.error("关闭录音输出数据流异常", e);
43             }
44         }
45 
46         audioRecord.stop();
47         audioRecord.release();
48         audioRecord = null;
49     }

　　录音的实际实现和控制代码较多，在此仅抽出核心的录音代码进行讲解。在此为获取录音的原始数据，我使用了Android原生的AudioRecord，其他的平台基本也会提供类似的工具类。这段代码实现的功能是当录音开始后，应用会根据设定的采样率和声道数以及采样字节数来不断从MIC中获取原始的音频数据，然后将获取的音频数据写入到指定文件中，直至录音结束。这段代码逻辑比较清晰的，我就不过多讲解了。

　　潜在问题的话，手机平台上是需要申请录音权限的，如果没有录音权限就无法生成正确的录音文件。

2.2.2.解码与裁剪背景音乐

　　如前文所说，除了PCM格式以外的所有音频编码格式的音频都必须解码后才可以处理，因此要让背景音乐参与合成必须事先对背景音乐进行解码，同时为减少合成的MP3文件的大小，需要根据录音时长对解码的音频文件进行裁剪。本节不会详细解释解码算法，因为每个平台都会有对应封装的工具类，直接使用即可。

　　背景知识先讲这些，本次功能实现过程中的潜在问题较多，下面我给出实现代码，综合代码讲解实现过程。

 1     private boolean decodeMusicFile(String musicFileUrl, String decodeFileUrl, int startSecond, int endSecond,
 2                                     Handler handler,
 3                                     DecodeOperateInterface decodeOperateInterface) {
 4         int sampleRate = 0;
 5         int channelCount = 0;
 6 
 7         long duration = 0;
 8 
 9         String mime = null;
10 
11         MediaExtractor mediaExtractor = new MediaExtractor();
12         MediaFormat mediaFormat = null;
13         MediaCodec mediaCodec = null;
14 
15         try {
16             mediaExtractor.setDataSource(musicFileUrl);
17         } catch (Exception e) {
18             LogFunction.error("设置解码音频文件路径错误", e);
19             return false;
20         }
21 
22         mediaFormat = mediaExtractor.getTrackFormat(0);
23         sampleRate = mediaFormat.containsKey(MediaFormat.KEY_SAMPLE_RATE) ?
24                 mediaFormat.getInteger(MediaFormat.KEY_SAMPLE_RATE) : 44100;
25         channelCount = mediaFormat.containsKey(MediaFormat.KEY_CHANNEL_COUNT) ?
26                 mediaFormat.getInteger(MediaFormat.KEY_CHANNEL_COUNT) : 1;
27         duration = mediaFormat.containsKey(MediaFormat.KEY_DURATION) ? mediaFormat.getLong(MediaFormat.KEY_DURATION) : 0;
28         mime = mediaFormat.containsKey(MediaFormat.KEY_MIME) ? mediaFormat.getString(MediaFormat.KEY_MIME) : "";
29 
30         LogFunction.log("歌曲信息",
31                 "Track info: mime:" + mime + " 采样率sampleRate:" + sampleRate + " channels:" +
32                         channelCount + " duration:" + duration);
33 
34         if (CommonFunction.isEmpty(mime) || !mime.startsWith("audio/")) {
35             LogFunction.error("解码文件不是音频文件", "mime:" + mime);
36             return false;
37         }
38 
39         if (mime.equals("audio/ffmpeg")) {
40             mime = "audio/mpeg";
41             mediaFormat.setString(MediaFormat.KEY_MIME, mime);
42         }
43 
44         try {
45             mediaCodec = MediaCodec.createDecoderByType(mime);
46 
47             mediaCodec.configure(mediaFormat, null, null, 0);
48         } catch (Exception e) {
49             LogFunction.error("解码器configure出错", e);
50             return false;
51         }
52 
53         getDecodeData(mediaExtractor, mediaCodec, decodeFileUrl, sampleRate, channelCount, startSecond,
54                 endSecond, handler, decodeOperateInterface);
55         return true;
56     }

　　decodeMusicFile方法的代码主要功能是获取背景音乐信息，初始化解码器，最后调用getDecodeData方法正式开始对背景音乐进行处理。

　　代码中使用了Android原生工具类作为解码器，事实上作为原生的解码器，我也遇到过兼容性问题不得不做了一些相应的处理，不得不抱怨一句不同的Android定制系统实在是导致了太多的兼容性问题。

  1     private void getDecodeData(MediaExtractor mediaExtractor, MediaCodec mediaCodec, String decodeFileUrl, int sampleRate,
  2                                int channelCount, int startSecond, int endSecond,
  3                                Handler handler,
  4                                final DecodeOperateInterface decodeOperateInterface) {
  5         boolean decodeInputEnd = false;
  6         boolean decodeOutputEnd = false;
  7 
  8         int sampleDataSize;
  9         int inputBufferIndex;
 10         int outputBufferIndex;
 11         int byteNumber;
 12 
 13         long decodeNoticeTime = System.currentTimeMillis();
 14         long decodeTime;
 15         long presentationTimeUs = 0;
 16 
 17         final long timeOutUs = 100;
 18         final long startMicroseconds = startSecond * 1000 * 1000;
 19         final long endMicroseconds = endSecond * 1000 * 1000;
 20 
 21         ByteBuffer[] inputBuffers;
 22         ByteBuffer[] outputBuffers;
 23 
 24         ByteBuffer sourceBuffer;
 25         ByteBuffer targetBuffer;
 26 
 27         MediaFormat outputFormat = mediaCodec.getOutputFormat();
 28 
 29         MediaCodec.BufferInfo bufferInfo;
 30 
 31         byteNumber =
 32                 (outputFormat.containsKey("bit-width") ? outputFormat.getInteger("bit-width") : 0) / 8;
 33 
 34         mediaCodec.start();
 35 
 36         inputBuffers = mediaCodec.getInputBuffers();
 37         outputBuffers = mediaCodec.getOutputBuffers();
 38 
 39         mediaExtractor.selectTrack(0);
 40 
 41         bufferInfo = new MediaCodec.BufferInfo();
 42 
 43         BufferedOutputStream bufferedOutputStream = FileFunction
 44                 .GetBufferedOutputStreamFromFile(decodeFileUrl);
 45 
 46         while (!decodeOutputEnd) {
 47             if (decodeInputEnd) {
 48                 return;
 49             }
 50 
 51             decodeTime = System.currentTimeMillis();
 52 
 53             if (decodeTime - decodeNoticeTime > Constant.OneSecond) {
 54                 final int decodeProgress =
 55                         (int) ((presentationTimeUs - startMicroseconds) * Constant.NormalMaxProgress /
 56                                 endMicroseconds);
 57 
 58                 if (decodeProgress > 0) {
 59                     handler.post(new Runnable() {
 60                         @Override
 61                         public void run() {
 62                             decodeOperateInterface.updateDecodeProgress(decodeProgress);
 63                         }
 64                     });
 65                 }
 66 
 67                 decodeNoticeTime = decodeTime;
 68             }
 69 
 70             try {
 71                 inputBufferIndex = mediaCodec.dequeueInputBuffer(timeOutUs);
 72 
 73                 if (inputBufferIndex >= 0) {
 74                     sourceBuffer = inputBuffers[inputBufferIndex];
 75 
 76                     sampleDataSize = mediaExtractor.readSampleData(sourceBuffer, 0);
 77 
 78                     if (sampleDataSize < 0) {
 79                         decodeInputEnd = true;
 80                         sampleDataSize = 0;
 81                     } else {
 82                         presentationTimeUs = mediaExtractor.getSampleTime();
 83                     }
 84 
 85                     mediaCodec.queueInputBuffer(inputBufferIndex, 0, sampleDataSize,
 86                             presentationTimeUs,
 87                             decodeInputEnd ? MediaCodec.BUFFER_FLAG_END_OF_STREAM : 0);
 88 
 89                     if (!decodeInputEnd) {
 90                         mediaExtractor.advance();
 91                     }
 92                 } else {
 93                     LogFunction.error("inputBufferIndex", "" + inputBufferIndex);
 94                 }
 95 
 96                 // decode to PCM and push it to the AudioTrack player
 97                 outputBufferIndex = mediaCodec.dequeueOutputBuffer(bufferInfo, timeOutUs);
 98 
 99                 if (outputBufferIndex < 0) {
100                     switch (outputBufferIndex) {
101                         case MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED:
102                             outputBuffers = mediaCodec.getOutputBuffers();
103                             LogFunction.error("MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED",
104                                     "[AudioDecoder]output buffers have changed.");
105                             break;
106                         case MediaCodec.INFO_OUTPUT_FORMAT_CHANGED:
107                             outputFormat = mediaCodec.getOutputFormat();
108 
109                             sampleRate = outputFormat.containsKey(MediaFormat.KEY_SAMPLE_RATE) ?
110                                     outputFormat.getInteger(MediaFormat.KEY_SAMPLE_RATE) : sampleRate;
111                             channelCount = outputFormat.containsKey(MediaFormat.KEY_CHANNEL_COUNT) ?
112                                     outputFormat.getInteger(MediaFormat.KEY_CHANNEL_COUNT) : channelCount;
113                             byteNumber = (outputFormat.containsKey("bit-width") ? outputFormat.getInteger("bit-width") : 0) / 8;
114 
115                             LogFunction.error("MediaCodec.INFO_OUTPUT_FORMAT_CHANGED",
116                                     "[AudioDecoder]output format has changed to " +
117                                             mediaCodec.getOutputFormat());
118                             break;
119                         default:
120                             LogFunction.error("error",
121                                     "[AudioDecoder] dequeueOutputBuffer returned " +
122                                             outputBufferIndex);
123                             break;
124                     }
125                     continue;
126                 }
127 
128                 targetBuffer = outputBuffers[outputBufferIndex];
129 
130                 byte[] sourceByteArray = new byte[bufferInfo.size];
131 
132                 targetBuffer.get(sourceByteArray);
133                 targetBuffer.clear();
134 
135                 mediaCodec.releaseOutputBuffer(outputBufferIndex, false);
136 
137                 if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
138                     decodeOutputEnd = true;
139                 }
140 
141                 if (sourceByteArray.length > 0 && bufferedOutputStream != null) {
142                     if (presentationTimeUs < startMicroseconds) {
143                         continue;
144                     }
145 
146                     byte[] convertByteNumberByteArray = ConvertByteNumber(byteNumber, Constant.RecordByteNumber, sourceByteArray);
147 
148                     byte[] resultByteArray =
149                             ConvertChannelNumber(channelCount, Constant.RecordChannelNumber, Constant.RecordByteNumber,
150                                     convertByteNumberByteArray);
151 
152                     try {
153                         bufferedOutputStream.write(resultByteArray);
154                     } catch (Exception e) {
155                         LogFunction.error("输出解压音频数据异常", e);
156                     }
157                 }
158 
159                 if (presentationTimeUs > endMicroseconds) {
160                     break;
161                 }
162             } catch (Exception e) {
163                 LogFunction.error("getDecodeData异常", e);
164             }
165         }
166 
167         if (bufferedOutputStream != null) {
168             try {
169                 bufferedOutputStream.close();
170             } catch (IOException e) {
171                 LogFunction.error("关闭bufferedOutputStream异常", e);
172             }
173         }
174 
175         if (sampleRate != Constant.RecordSampleRate) {
176             Resample(sampleRate, decodeFileUrl);
177         }
178 
179         if (mediaCodec != null) {
180             mediaCodec.stop();
181             mediaCodec.release();
182         }
183 
184         if (mediaExtractor != null) {
185             mediaExtractor.release();
186         }
187     }

　　getDecodeData方法是此次的进行解码和裁剪的核心，方法的传入参数中mediaExtractor，mediaCodec用以实际控制处理背景音乐的音频数据，decodeFileUrl用以指明解码和裁剪后的PCM文件的存储地址，sampleRate，channelCount分别用以指明背景音乐的采样率，声道数，startSecond用以指明裁剪背景音乐的开始时间，目前功能中默认为0，endSecond用以指明裁剪背景音乐的结束时间，数值大小由录音时长直接决定。

　　getDecodeData方法中通过不断通过mediaCodec读入背景音乐原始数据进行处理，然后解码输出到buffer从而获取解码后的数据，因为mediaCodec的读取解码方法和平台相关就不过多描述，在解码过程中通过startSecond与endSecond来控制解码后音频数据输出的开始与结束。

　　解码和裁剪根据上文的描述是比较简单的，通过平台提供的工具类解码背景音乐数据，然后通过变量裁剪出指定长度的解码后音频数据输出到外文件，这一个流程结束功能就实现了，但在过程中存在几个潜在问题点。

　　首先，要进行合成处理的话，我们必须要保证录音文件和解码后文件的采样率，采样点字节数，以及声道数相同，因为录音文件的这三项系数已经固定，所以我们必须对解码的音频数据进行处理以保证最终生成的解码文件三项系数和录音文件一致。在http://blog.csdn.net/ownwell/article/details/8114121/，我们可以了解PCM文件常见的四种存储格式。

　　格式字节1 字节2 字节3 字节4

　　8位单声道   0声道 0声道     0声道     0声道
　　8位双声道   0声道(左)   1声道(右)   0声道(左)   1声道(右)
　　16位单声道   0声道(低)   0声道(高)   0声道(低)   0声道(高)
　　16位双声道 0声道(左，低字节) 0声道(左，高字节) 1声道(右，低字节) 1声道(右，高字节)

　　了解这些知识后，我们就可以知道如何编码以将已知格式的音频数据转化到另一采样点字节数和声道数。

　　getDecodeData方法中146行调用的ConvertByteNumber方法是通过处理音频数据以保证解码后音频文件和录音文件采样点字节数相同。

 1     private static byte[] ConvertByteNumber(int sourceByteNumber, int outputByteNumber, byte[] sourceByteArray) {
 2         if (sourceByteNumber == outputByteNumber) {
 3             return sourceByteArray;
 4         }
 5 
 6         int sourceByteArrayLength = sourceByteArray.length;
 7 
 8         byte[] byteArray;
 9 
10         switch (sourceByteNumber) {
11             case 1:
12                 switch (outputByteNumber) {
13                     case 2:
14                         byteArray = new byte[sourceByteArrayLength * 2];
15 
16                         byte resultByte[];
17 
18                         for (int index = 0; index < sourceByteArrayLength; index += 1) {
19                             resultByte = CommonFunction.GetBytes((short) (sourceByteArray[index] * 256), Variable.isBigEnding);
20 
21                             byteArray[2 * index] = resultByte[0];
22                             byteArray[2 * index + 1] = resultByte[1];
23                         }
24 
25                         return byteArray;
26                 }
27                 break;
28             case 2:
29                 switch (outputByteNumber) {
30                     case 1:
31                         int outputByteArrayLength = sourceByteArrayLength / 2;
32 
33                         byteArray = new byte[outputByteArrayLength];
34 
35                         for (int index = 0; index < outputByteArrayLength; index += 1) {
36                             byteArray[index] = (byte) (CommonFunction.GetShort(sourceByteArray[2 * index],
37                                     sourceByteArray[2 * index + 1], Variable.isBigEnding) / 256);
38                         }
39 
40                         return byteArray;
41                 }
42                 break;
43         }
44 
45         return sourceByteArray;
46     }

　　ConvertByteNumber方法的参数中sourceByteNumber代表背景音乐文件采样点字节数，outputByteNumber代表录音文件采样点字节数，两者如果相同就不处理，不相同则根据背景音乐文件采样点字节数进行不同的处理，本方法只对单字节存储和双字节存储进行了处理，欢迎在各位Github上填充其他采样点字节数的处理方法，

　　getDecodeData方法中149行调用的ConvertChannelNumber方法是通过处理音频数据以保证解码后音频文件和录音文件声道数相同。

 1     private static byte[] ConvertChannelNumber(int sourceChannelCount, int outputChannelCount, int byteNumber,
 2                                                byte[] sourceByteArray) {
 3         if (sourceChannelCount == outputChannelCount) {
 4             return sourceByteArray;
 5         }
 6 
 7         switch (byteNumber) {
 8             case 1:
 9             case 2:
10                 break;
11             default:
12                 return sourceByteArray;
13         }
14 
15         int sourceByteArrayLength = sourceByteArray.length;
16 
17         byte[] byteArray;
18 
19         switch (sourceChannelCount) {
20             case 1:
21                 switch (outputChannelCount) {
22                     case 2:
23                         byteArray = new byte[sourceByteArrayLength * 2];
24 
25                         byte firstByte;
26                         byte secondByte;
27 
28                         switch (byteNumber) {
29                             case 1:
30                                 for (int index = 0; index < sourceByteArrayLength; index += 1) {
31                                     firstByte = sourceByteArray[index];
32 
33                                     byteArray[2 * index] = firstByte;
34                                     byteArray[2 * index + 1] = firstByte;
35                                 }
36                                 break;
37                             case 2:
38                                 for (int index = 0; index < sourceByteArrayLength; index += 2) {
39                                     firstByte = sourceByteArray[index];
40                                     secondByte = sourceByteArray[index + 1];
41 
42                                     byteArray[2 * index] = firstByte;
43                                     byteArray[2 * index + 1] = secondByte;
44                                     byteArray[2 * index + 2] = firstByte;
45                                     byteArray[2 * index + 3] = secondByte;
46                                 }
47                                 break;
48                         }
49 
50                         return byteArray;
51                 }
52                 break;
53             case 2:
54                 switch (outputChannelCount) {
55                     case 1:
56                         int outputByteArrayLength = sourceByteArrayLength / 2;
57 
58                         byteArray = new byte[outputByteArrayLength];
59 
60                         switch (byteNumber) {
61                             case 1:
62                                 for (int index = 0; index < outputByteArrayLength; index += 2) {
63                                     short averageNumber =
64                                             (short) ((short) sourceByteArray[2 * index] + (short) sourceByteArray[2 * index + 1]);
65                                     byteArray[index] = (byte) (averageNumber >> 1);
66                                 }
67                                 break;
68                             case 2:
69                                 for (int index = 0; index < outputByteArrayLength; index += 2) {
70                                     byte resultByte[] = CommonFunction.AverageShortByteArray(sourceByteArray[2 * index],
71                                             sourceByteArray[2 * index + 1], sourceByteArray[2 * index + 2],
72                                             sourceByteArray[2 * index + 3], Variable.isBigEnding);
73 
74                                     byteArray[index] = resultByte[0];
75                                     byteArray[index + 1] = resultByte[1];
76                                 }
77                                 break;
78                         }
79 
80                         return byteArray;
81                 }
82                 break;
83         }
84 
85         return sourceByteArray;
86     }

　　ConvertChannelNumber方法的参数中sourceChannelCount代表背景音乐文件声道数，outputChannelCount代表录音文件声道数，两者如果相同就不处理，不相同则根据声道数和采样点字节数进行不同的处理，本方法只对单双通道进行了处理，欢迎在Github上填充立体声等声道的处理方法。

　　getDecodeData方法中176行调用的Resample方法是用以处理音频数据以保证解码后音频文件和录音文件采样率相同。

 1     private static void Resample(int sampleRate, String decodeFileUrl) {
 2         String newDecodeFileUrl = decodeFileUrl + "new";
 3 
 4         try {
 5             FileInputStream fileInputStream =
 6                     new FileInputStream(new File(decodeFileUrl));
 7             FileOutputStream fileOutputStream =
 8                     new FileOutputStream(new File(newDecodeFileUrl));
 9 
10             new SSRC(fileInputStream, fileOutputStream, sampleRate, Constant.RecordSampleRate,
11                     Constant.RecordByteNumber, Constant.RecordByteNumber, 1, Integer.MAX_VALUE, 0, 0, true);
12 
13             fileInputStream.close();
14             fileOutputStream.close();
15 
16             FileFunction.RenameFile(newDecodeFileUrl, decodeFileUrl);
17         } catch (IOException e) {
18             LogFunction.error("关闭bufferedOutputStream异常", e);
19         }
20     }

　　为了修改采样率，在此使用了SSRC在Java端的实现，在网上可以搜到一份关于SSRC的介绍："SSRC = Synchronous Sample Rate Converter，同步采样率转换，直白地说就是只能做整数倍频，不支持任意频率之间的转换，比如44.1KHz<->48KHz。"，但不同的SSRC实现原理有所不同，我是用的是来自https://github.com/shibatch/SSRC在Java端的实现，简单读了此SSRC在Java端实现的源码，其代码实现中通过判别重采样前后采样率的最大公约数是否满足设定条件作为是否可重采样的依据，可以支持常见的非整数倍频率的采样率转化，如44.1khz<->48khz，但如果目标采样率是比较特殊的采样率如某一较大的质数，那就无法支持重采样。

　　至此，Resample，ConvertByteNumber，ConvertChannelNumber三个方法的处理保证了解码后文件和录音文件的采样率，采样点字节数，以及声道数相同。

　　接着，此处潜在的第二个问题就是大小端存储。对计算机体系结构有所了解的同学肯定了解"大小端"这个概念，大小端分别代表了多字节数据在内存中组织的两种不同顺序，如果对于"大小端"不是太了解，可以浏览http://blog.jobbole.com/102432/的阐述，在处理音频数据的方法中，我们可以看到"Variable.isBigEnding"这个参数，这个参数的含义就是当前平台是否使用大端编码，这里大家肯定会有疑问，内存中多字节数据的组织顺序为什么会影响我们对音频数据的处理，举个例子，如果我们在将采样点8位的音频数据转化为采样点16位，目前的做法是将原始数据乘以256，相当于每一个byte转化为short，同时short的高字节为原byte的内容，低字节为0，那现在问题来了，那就是高字节放到高地址还是低地址，这就和平台采用的大小端存储格式息息相关了，当然如果我们输出的数据类型是short那就不用关心，Java会帮我们处理掉，但我们输出的是byte数组，这就需要我们自己对数据进行处理了。

　　这是一个很容易忽视的问题，因为正常情况下的软件开发过程中我们基本是不用关心大小端的问题的，但在这里必须对大小端的情况进行处理，不然会出现在某些平台合成的音频无法播放的情况。

2.2.3.合成与输出

　　录音和对背景音乐的处理结束了，接下来就是最后的合成了，对于合成我们脑海中浮现最多的会是什么？相加，对没错，音频合成并不神秘，音频合成的本质就是相同系数的音频文件之间数据的加和，当然现实中的合成往往并非如此简单，在网上搜索"混音算法"，我们可以看到大量高深的音频合成算法，但就目前而言，我们没必要实现复杂的混音算法，只要让两个音频文件的原始音频数据相加即可，不过为了让我们的合成看上去稍微有一些技术含量，此次提供的音频合成方法中允许任意音频文件相对于另一音频文件进行时间上的偏移，并可以通过两个权重数据进行音量调节。下面我就给出具体代码吧，讲解如何实现。

  1     public static void ComposeAudio(String firstAudioFilePath, String secondAudioFilePath,
  2                                     String composeAudioFilePath, boolean deleteSource,
  3                                     float firstAudioWeight, float secondAudioWeight,
  4                                     int audioOffset,
  5                                     final ComposeAudioInterface composeAudioInterface) {
  6         boolean firstAudioFinish = false;
  7         boolean secondAudioFinish = false;
  8 
  9         byte[] firstAudioByteBuffer;
 10         byte[] secondAudioByteBuffer;
 11         byte[] mp3Buffer;
 12 
 13         short resultShort;
 14         short[] outputShortArray;
 15 
 16         int index;
 17         int firstAudioReadNumber;
 18         int secondAudioReadNumber;
 19         int outputShortArrayLength;
 20         final int byteBufferSize = 1024;
 21 
 22         firstAudioByteBuffer = new byte[byteBufferSize];
 23         secondAudioByteBuffer = new byte[byteBufferSize];
 24         mp3Buffer = new byte[(int) (7200 + (byteBufferSize * 1.25))];
 25 
 26         outputShortArray = new short[byteBufferSize / 2];
 27 
 28         Handler handler = new Handler(Looper.getMainLooper());
 29 
 30         FileInputStream firstAudioInputStream = FileFunction.GetFileInputStreamFromFile(firstAudioFilePath);
 31         FileInputStream secondAudioInputStream = FileFunction.GetFileInputStreamFromFile(secondAudioFilePath);
 32         FileOutputStream composeAudioOutputStream = FileFunction.GetFileOutputStreamFromFile(composeAudioFilePath);
 33 
 34         LameUtil.init(Constant.RecordSampleRate, Constant.LameBehaviorChannelNumber,
 35                 Constant.BehaviorSampleRate, Constant.LameBehaviorBitRate, Constant.LameMp3Quality);
 36 
 37         try {
 38             while (!firstAudioFinish && !secondAudioFinish) {
 39                 index = 0;
 40 
 41                 if (audioOffset < 0) {
 42                     secondAudioReadNumber = secondAudioInputStream.read(secondAudioByteBuffer);
 43 
 44                     outputShortArrayLength = secondAudioReadNumber / 2;
 45 
 46                     for (; index < outputShortArrayLength; index++) {
 47                         resultShort = CommonFunction.GetShort(secondAudioByteBuffer[index * 2],
 48                                 secondAudioByteBuffer[index * 2 + 1], Variable.isBigEnding);
 49 
 50                         outputShortArray[index] = (short) (resultShort * secondAudioWeight);
 51                     }
 52 
 53                     audioOffset += secondAudioReadNumber;
 54 
 55                     if (secondAudioReadNumber < 0) {
 56                         secondAudioFinish = true;
 57                         break;
 58                     }
 59 
 60                     if (audioOffset >= 0) {
 61                         break;
 62                     }
 63                 } else {
 64                     firstAudioReadNumber = firstAudioInputStream.read(firstAudioByteBuffer);
 65 
 66                     outputShortArrayLength = firstAudioReadNumber / 2;
 67 
 68                     for (; index < outputShortArrayLength; index++) {
 69                         resultShort = CommonFunction.GetShort(firstAudioByteBuffer[index * 2],
 70                                 firstAudioByteBuffer[index * 2 + 1], Variable.isBigEnding);
 71 
 72                         outputShortArray[index] = (short) (resultShort * firstAudioWeight);
 73                     }
 74 
 75                     audioOffset -= firstAudioReadNumber;
 76 
 77                     if (firstAudioReadNumber < 0) {
 78                         firstAudioFinish = true;
 79                         break;
 80                     }
 81 
 82                     if (audioOffset <= 0) {
 83                         break;
 84                     }
 85                 }
 86 
 87                 if (outputShortArrayLength > 0) {
 88                     int encodedSize = LameUtil.encode(outputShortArray, outputShortArray,
 89                             outputShortArrayLength, mp3Buffer);
 90 
 91                     if (encodedSize > 0) {
 92                         composeAudioOutputStream.write(mp3Buffer, 0, encodedSize);
 93                     }
 94                 }
 95             }
 96 
 97             handler.post(new Runnable() {
 98                 @Override
 99                 public void run() {
100                     if (composeAudioInterface != null) {
101                         composeAudioInterface.updateComposeProgress(20);
102                     }
103                 }
104             });
105 
106             while (!firstAudioFinish || !secondAudioFinish) {
107                 index = 0;
108 
109                 firstAudioReadNumber = firstAudioInputStream.read(firstAudioByteBuffer);
110                 secondAudioReadNumber = secondAudioInputStream.read(secondAudioByteBuffer);
111 
112                 int minAudioReadNumber = Math.min(firstAudioReadNumber, secondAudioReadNumber);
113                 int maxAudioReadNumber = Math.max(firstAudioReadNumber, secondAudioReadNumber);
114 
115                 if (firstAudioReadNumber < 0) {
116                     firstAudioFinish = true;
117                 }
118 
119                 if (secondAudioReadNumber < 0) {
120                     secondAudioFinish = true;
121                 }
122 
123                 int halfMinAudioReadNumber = minAudioReadNumber / 2;
124 
125                 outputShortArrayLength = maxAudioReadNumber / 2;
126 
127                 for (; index < halfMinAudioReadNumber; index++) {
128                     resultShort = CommonFunction.WeightShort(firstAudioByteBuffer[index * 2],
129                             firstAudioByteBuffer[index * 2 + 1], secondAudioByteBuffer[index * 2],
130                             secondAudioByteBuffer[index * 2 + 1], firstAudioWeight,
131                             secondAudioWeight, Variable.isBigEnding);
132 
133                     outputShortArray[index] = resultShort;
134                 }
135 
136                 if (firstAudioReadNumber != secondAudioReadNumber) {
137                     if (firstAudioReadNumber > secondAudioReadNumber) {
138                         for (; index < outputShortArrayLength; index++) {
139                             resultShort = CommonFunction.GetShort(firstAudioByteBuffer[index * 2],
140                                     firstAudioByteBuffer[index * 2 + 1], Variable.isBigEnding);
141 
142                             outputShortArray[index] = (short) (resultShort * firstAudioWeight);
143                         }
144                     } else {
145                         for (; index < outputShortArrayLength; index++) {
146                             resultShort = CommonFunction.GetShort(secondAudioByteBuffer[index * 2],
147                                     secondAudioByteBuffer[index * 2 + 1], Variable.isBigEnding);
148 
149                             outputShortArray[index] = (short) (resultShort * secondAudioWeight);
150                         }
151                     }
152                 }
153 
154                 if (outputShortArrayLength > 0) {
155                     int encodedSize = LameUtil.encode(outputShortArray, outputShortArray,
156                             outputShortArrayLength, mp3Buffer);
157 
158                     if (encodedSize > 0) {
159                         composeAudioOutputStream.write(mp3Buffer, 0, encodedSize);
160                     }
161                 }
162             }
163         } catch (Exception e) {
164             LogFunction.error("ComposeAudio异常", e);
165 
166             handler.post(new Runnable() {
167                 @Override
168                 public void run() {
169                     if (composeAudioInterface != null) {
170                         composeAudioInterface.composeFail();
171                     }
172                 }
173             });
174 
175             return;
176         }
177 
178         handler.post(new Runnable() {
179             @Override
180             public void run() {
181                 if (composeAudioInterface != null) {
182                     composeAudioInterface.updateComposeProgress(50);
183                 }
184             }
185         });
186 
187         try {
188             final int flushResult = LameUtil.flush(mp3Buffer);
189 
190             if (flushResult > 0) {
191                 composeAudioOutputStream.write(mp3Buffer, 0, flushResult);
192             }
193         } catch (Exception e) {
194             LogFunction.error("释放ComposeAudio LameUtil异常", e);
195         } finally {
196             try {
197                 composeAudioOutputStream.close();
198             } catch (Exception e) {
199                 LogFunction.error("关闭合成输出音频流异常", e);
200             }
201 
202             LameUtil.close();
203         }
204 
205         if (deleteSource) {
206             FileFunction.DeleteFile(firstAudioFilePath);
207             FileFunction.DeleteFile(secondAudioFilePath);
208         }
209 
210         try {
211             firstAudioInputStream.close();
212             secondAudioInputStream.close();
213         } catch (IOException e) {
214             LogFunction.error("关闭合成输入音频流异常", e);
215         }
216 
217         handler.post(new Runnable() {
218             @Override
219             public void run() {
220                 if (composeAudioInterface != null) {
221                     composeAudioInterface.composeSuccess();
222                 }
223             }
224         });
225     }

　　ComposeAudio方法是此次的进行合成的具体代码实现，方法的传入参数中firstAudioFilePath, secondAudioFilePath是用以合成的音频文件地址，composeAudioFilePath用以指明合成后输出的MP3文件的存储地址，firstAudioWeight，secondAudioWeight分别用以指明合成的两个音频文件在合成过程中的音量权重，audioOffset用以指明第一个音频文件相对于第二个音频文件合成过程中的数据偏移，如为负数，则合成过程中先输出audioOffset个字节长度的第二个音频文件数据，如为正数，则合成过程中先输出audioOffset个字节长度的第一个音频文件数据，audioOffset在另一程度上也代表着时间的偏移，目前我们合成的两个音频文件参数为16位单通道44.1khz采样率，那么audioOffset如果为1*16/8*1*44100=88200字节，那么最终合成出的MP3文件中会先播放1s的第一个音频文件的音频接着再播放两个音频文件加和的音频。

　　整体合成代码是很清晰的，因为加入了时间偏移，所以合成过程中是有可能有一个文件先输出完的，在代码中针对性的进行处理即可，当然即使没有时间偏移也是可能出现类似情况的，比如音乐时长2分钟，录音3分钟，音乐输出结束后那就只应该输出录音音频了，另外在代码中将PCM数据编码为MP3文件使用了LAME的MP3编码库，除此以外代码中就没有比较复杂的模块了。

3.总结

　　至此，音频合成的流程我们算是走完了，希望读到此处的各位对音频合成的实现有了清晰的了解。

　　这篇博文就到这里结束了，本文所有代码已经托管到https://github.com/CrazyZty/ComposeAudio，大家可以自由下载。