start to mix , you can call {@link #setOnAudioMixListener(OnAudioMixListener)} before this method to get mixed data.
28 | */
29 | public void mixAudios(File[] rawAudioFiles){
30 |
31 | final int fileSize = rawAudioFiles.length;
32 |
33 | FileInputStream[] audioFileStreams = new FileInputStream[fileSize];
34 | File audioFile = null;
35 |
36 | FileInputStream inputStream;
37 | byte[][] allAudioBytes = new byte[fileSize][];
38 | boolean[] streamDoneArray = new boolean[fileSize];
39 | byte[] buffer = new byte[512];
40 | int offset;
41 |
42 | try {
43 |
44 | for (int fileIndex = 0; fileIndex < fileSize; ++fileIndex) {
45 | audioFile = rawAudioFiles[fileIndex];
46 | audioFileStreams[fileIndex] = new FileInputStream(audioFile);
47 | }
48 |
49 | while(true){
50 |
51 | for(int streamIndex = 0 ; streamIndex < fileSize ; ++streamIndex){
52 |
53 | inputStream = audioFileStreams[streamIndex];
54 | if(!streamDoneArray[streamIndex] && (offset = inputStream.read(buffer)) != -1){
55 | allAudioBytes[streamIndex] = Arrays.copyOf(buffer,buffer.length);
56 | }else{
57 | streamDoneArray[streamIndex] = true;
58 | allAudioBytes[streamIndex] = new byte[512];
59 | }
60 | }
61 |
62 | byte[] mixBytes = mixRawAudioBytes(allAudioBytes);
63 | if(mixBytes != null && mOnAudioMixListener != null){
64 | mOnAudioMixListener.onMixing(mixBytes);
65 | }
66 |
67 | boolean done = true;
68 | for(boolean streamEnd : streamDoneArray){
69 | if(!streamEnd){
70 | done = false;
71 | }
72 | }
73 |
74 | if(done){
75 | if(mOnAudioMixListener != null)
76 | mOnAudioMixListener.onMixComplete();
77 | break;
78 | }
79 | }
80 |
81 | } catch (IOException e) {
82 | e.printStackTrace();
83 | if(mOnAudioMixListener != null)
84 | mOnAudioMixListener.onMixError(1);
85 | }finally{
86 | try {
87 | for(FileInputStream in : audioFileStreams){
88 | if(in != null)
89 | in.close();
90 | }
91 | } catch (IOException e) {
92 | e.printStackTrace();
93 | }
94 | }
95 | }
96 |
97 | abstract byte[] mixRawAudioBytes(byte[][] data);
98 |
99 | public interface OnAudioMixListener{
100 | /**
101 | * invoke when mixing, if you want to stop the mixing process, you can throw an AudioMixException
102 | * @param mixBytes
103 | * @throws AudioMixException
104 | */
105 | void onMixing(byte[] mixBytes) throws IOException;
106 |
107 | void onMixError(int errorCode);
108 |
109 | /**
110 | * invoke when mix success
111 | */
112 | void onMixComplete();
113 | }
114 |
115 | public static class AudioMixException extends IOException{
116 | private static final long serialVersionUID = -1344782236320621800L;
117 |
118 | public AudioMixException(String msg){
119 | super(msg);
120 | }
121 | }
122 |
123 | /**
124 | * 平均值算法
125 | * @author Darcy
126 | */
127 | private static class AverageAudioMixer extends MultiAudioMixer{
128 |
129 | @Override
130 | byte[] mixRawAudioBytes(byte[][] bMulRoadAudioes) {
131 |
132 | if (bMulRoadAudioes == null || bMulRoadAudioes.length == 0)
133 | return null;
134 |
135 | byte[] realMixAudio = bMulRoadAudioes[0];
136 |
137 | if(bMulRoadAudioes.length == 1)
138 | return realMixAudio;
139 |
140 | for(int rw = 0 ; rw < bMulRoadAudioes.length ; ++rw){
141 | if(bMulRoadAudioes[rw].length != realMixAudio.length){
142 | Log.e("app", "column of the road of audio + " + rw +" is diffrent.");
143 | return null;
144 | }
145 | }
146 |
147 | int row = bMulRoadAudioes.length;
148 | int coloum = realMixAudio.length / 2;
149 | short[][] sMulRoadAudioes = new short[row][coloum];
150 |
151 | for (int r = 0; r < row; ++r) {
152 | for (int c = 0; c < coloum; ++c) {
153 | sMulRoadAudioes[r][c] = (short) ((bMulRoadAudioes[r][c * 2] & 0xff) | (bMulRoadAudioes[r][c * 2 + 1] & 0xff) << 8);
154 | }
155 | }
156 |
157 | short[] sMixAudio = new short[coloum];
158 | int mixVal;
159 | int sr = 0;
160 | for (int sc = 0; sc < coloum; ++sc) {
161 | mixVal = 0;
162 | sr = 0;
163 | for (; sr < row; ++sr) {
164 | mixVal += sMulRoadAudioes[sr][sc];
165 | }
166 | sMixAudio[sc] = (short) (mixVal / row);
167 | }
168 |
169 | for (sr = 0; sr < coloum; ++sr) {
170 | realMixAudio[sr * 2] = (byte) (sMixAudio[sr] & 0x00FF);
171 | realMixAudio[sr * 2 + 1] = (byte) ((sMixAudio[sr] & 0xFF00) >> 8);
172 | }
173 |
174 | return realMixAudio;
175 | }
176 |
177 | }
178 | }
179 |
--------------------------------------------------------------------------------
/src/com/musicplus/media/MultiRawAudioPlayer.java:
--------------------------------------------------------------------------------
1 | package com.musicplus.media;
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 java.util.concurrent.BrokenBarrierException;
9 | import java.util.concurrent.CyclicBarrier;
10 |
11 | import android.media.AudioFormat;
12 | import android.media.AudioManager;
13 | import android.media.AudioTrack;
14 | import android.os.Handler;
15 | import android.os.Message;
16 |
17 | import com.musicplus.app.MainApplication;
18 | import com.musicplus.entry.AudioEntry;
19 | import com.musicplus.media.MultiAudioMixer.AudioMixException;
20 | import com.musicplus.media.MultiAudioMixer.OnAudioMixListener;
21 | import com.musicplus.utils.MD5Util;
22 |
23 | /**
24 | * 多路音频同时播放器，原理是通过{@link MultiAudioMixer}进行混音成一条音轨进行播放
25 | * @author Darcy
26 | */
27 | public class MultiRawAudioPlayer {
28 |
29 | private final static int sampleRateInHz = 44100;
30 | private final static int channelConfig = AudioFormat.CHANNEL_OUT_STEREO;
31 | private final static int audioFormat = AudioFormat.ENCODING_PCM_16BIT;
32 |
33 | private volatile boolean playing = false;
34 | private volatile boolean stopped = false;
35 | private final Object mLock = new Object();
36 |
37 | private static final int MSG_PLAY_START = 0x1;
38 | private static final int MSG_PLAY_STOP = 0x2;
39 | private static final int MSG_PLAY_COMPLETE = 0x3;
40 |
41 | private EventHandler mEventHandler = new EventHandler();
42 | private CyclicBarrier mRecordBarrier; //同步录像
43 |
44 | private AudioEntry[] mAudioEntries;
45 |
46 | private static class EventHandler extends Handler{
47 |
48 | private OnRawAudioPlayListener event;
49 |
50 | public void setOnRawAudioPlayListener(OnRawAudioPlayListener l){
51 | event = l;
52 | }
53 |
54 | public void handleMessage(android.os.Message msg) {
55 | String tempMixFile = (String) msg.obj;
56 | switch(msg.what){
57 | case MSG_PLAY_START:
58 | if(event != null)
59 | event.onPlayStart();
60 | break;
61 | case MSG_PLAY_STOP:
62 | if(event != null)
63 | event.onPlayStop(tempMixFile);
64 | break;
65 | case MSG_PLAY_COMPLETE:
66 | if(event != null)
67 | event.onPlayComplete(tempMixFile);
68 | break;
69 | }
70 | };
71 | }
72 |
73 | public MultiRawAudioPlayer(AudioEntry[] audioEntries,CyclicBarrier recordBarrier){
74 | this.mAudioEntries = audioEntries;
75 | this.mRecordBarrier = recordBarrier;
76 | }
77 |
78 | public void setOnRawAudioPlayListener(OnRawAudioPlayListener l){
79 | mEventHandler.setOnRawAudioPlayListener(l);
80 | }
81 |
82 | /**
83 | * 调用该方法开始播放或者从头播放
84 | */
85 | public void play(){
86 |
87 | if(mAudioEntries == null || mAudioEntries.length == 0)
88 | return;
89 |
90 | if(playing){
91 | stop();
92 | play();
93 | }else{
94 | stopped = false;
95 | playing = true;
96 | new PlayThread().start();
97 | }
98 | }
99 |
100 | public void testPlaySync(){
101 | new PlayThread().run();
102 | }
103 |
104 | /**
105 | * 停止播放
106 | */
107 | public void stop(){
108 | stopped = true;
109 | if(playing){
110 | synchronized (mLock) {
111 | try {
112 | mLock.wait();
113 | } catch (InterruptedException e) {
114 | e.printStackTrace();
115 | }
116 | }
117 | }
118 | }
119 |
120 | AudioTrack createTrack(){
121 | int bufferSizeInBytes = AudioTrack.getMinBufferSize(sampleRateInHz, channelConfig, audioFormat);
122 | return new AudioTrack(AudioManager.STREAM_MUSIC, sampleRateInHz, channelConfig, audioFormat, bufferSizeInBytes, AudioTrack.MODE_STREAM);
123 | }
124 |
125 | private void waitForRecordStart(){
126 | if(mRecordBarrier != null){
127 | try {
128 | mRecordBarrier.await();
129 | } catch (BrokenBarrierException e) {
130 | e.printStackTrace();
131 | } catch (InterruptedException e) {
132 | e.printStackTrace();
133 | }
134 | }
135 | }
136 |
137 | private class PlayThread extends Thread{
138 |
139 | @Override
140 | public void run() {
141 | int audioSize = mAudioEntries.length;
142 | File[] rawAudioFiles = new File[audioSize];
143 | StringBuilder sbMix = new StringBuilder();
144 | for(int index = 0; index < audioSize ; ++index){
145 | AudioEntry audioEntry = mAudioEntries[index];
146 | rawAudioFiles[index] = new File(audioEntry.fileUrl);
147 | sbMix.append(audioEntry.id);
148 | }
149 |
150 | boolean hasMixBefore = false;
151 | final String mixFilePath = MainApplication.TEMP_AUDIO_PATH + "/" +MD5Util.getMD5Str(sbMix.toString());
152 | final File tempMixFile = new File(mixFilePath);
153 |
154 | final AudioTrack audioTrack = createTrack();
155 | audioTrack.play();
156 |
157 | try{
158 | final FileOutputStream fosTempMixAudio = new FileOutputStream(tempMixFile);
159 | //single audio
160 | if(audioSize == 1 || hasMixBefore){
161 | FileInputStream audioInput = null;
162 | try {
163 | File singleAudioFile = hasMixBefore ? tempMixFile : rawAudioFiles[0];
164 | audioInput = new FileInputStream(singleAudioFile);
165 | byte[] audioData = new byte[512];
166 | int readCount=0, totalSize=0;
167 |
168 | if(!stopped && (readCount = audioInput.read(audioData))!= -1){
169 | fosTempMixAudio.write(audioData, 0, readCount);
170 | mEventHandler.sendEmptyMessage(MSG_PLAY_START);
171 | waitForRecordStart();
172 | audioTrack.write(audioData, 0, readCount);
173 | totalSize += readCount;
174 | }
175 |
176 | while(!stopped && (readCount = audioInput.read(audioData))!= -1){
177 | fosTempMixAudio.write(audioData, 0, readCount);
178 | audioTrack.write(audioData, 0, readCount);
179 | totalSize += readCount;
180 | }
181 |
182 | if(totalSize >= singleAudioFile.length()){
183 | Message completeMsg = mEventHandler.obtainMessage(MSG_PLAY_COMPLETE, mixFilePath);
184 | mEventHandler.sendMessage(completeMsg);
185 | }
186 |
187 | if(stopped){
188 | Message stopMsg = mEventHandler.obtainMessage(MSG_PLAY_STOP, mixFilePath);
189 | mEventHandler.sendMessage(stopMsg);
190 | }
191 | } catch (FileNotFoundException e) {
192 | e.printStackTrace();
193 | } catch (IOException e) {
194 | e.printStackTrace();
195 | }finally{
196 | try {
197 | if(audioInput != null)
198 | audioInput.close();
199 |
200 | if(fosTempMixAudio != null)
201 | fosTempMixAudio.close();
202 | } catch (IOException e) {
203 | e.printStackTrace();
204 | }
205 | }
206 | return;
207 | }
208 |
209 | // multi audios
210 | MultiAudioMixer mixer = MultiAudioMixer.createAudioMixer();
211 | mixer.setOnAudioMixListener(new OnAudioMixListener() {
212 |
213 | boolean isFirst = false;
214 |
215 | public void onMixing(byte[] mixBytes) throws IOException {
216 | if(stopped){
217 | fosTempMixAudio.close();
218 | Message stopMsg = mEventHandler.obtainMessage(MSG_PLAY_STOP, mixFilePath);
219 | mEventHandler.sendMessage(stopMsg);
220 | throw new AudioMixException("stop play the mix audios.");
221 | }else{
222 | fosTempMixAudio.write(mixBytes);
223 | if(!isFirst){
224 | isFirst = true;
225 | mEventHandler.sendEmptyMessage(MSG_PLAY_START);
226 | waitForRecordStart();
227 | }
228 | audioTrack.write(mixBytes, 0, mixBytes.length);
229 | }
230 | }
231 |
232 | @Override
233 | public void onMixError(int errorCode) {
234 |
235 | if(fosTempMixAudio != null){
236 | try {
237 | fosTempMixAudio.close();
238 | } catch (IOException e) {
239 | e.printStackTrace();
240 | }
241 | }
242 | }
243 |
244 | public void onMixComplete() {
245 |
246 | if(fosTempMixAudio != null){
247 | try {
248 | fosTempMixAudio.close();
249 | } catch (IOException e) {
250 | e.printStackTrace();
251 | }
252 | }
253 |
254 | Message completeMsg = mEventHandler.obtainMessage(MSG_PLAY_COMPLETE, mixFilePath);
255 | mEventHandler.sendMessage(completeMsg);
256 | }
257 | });
258 | mixer.mixAudios(rawAudioFiles);
259 | } catch (FileNotFoundException e) {
260 | e.printStackTrace();
261 | }finally{
262 | audioTrack.stop();
263 | audioTrack.release();
264 | playing = false;
265 | synchronized (mLock) {
266 | mLock.notifyAll();
267 | }
268 | }
269 | }
270 | }
271 |
272 | public interface OnRawAudioPlayListener{
273 | void onPlayStart();
274 | void onPlayStop(String tempMixFile);
275 | void onPlayComplete(String tempMixFile);
276 | }
277 | }
278 |
--------------------------------------------------------------------------------
/src/com/musicplus/media/VideoMuxer.java:
--------------------------------------------------------------------------------
1 | package com.musicplus.media;
2 |
3 | import java.io.File;
4 | import java.io.FileInputStream;
5 | import java.io.IOException;
6 | import java.nio.ByteBuffer;
7 | import java.util.Arrays;
8 |
9 | import android.media.MediaCodec;
10 | import android.media.MediaCodec.BufferInfo;
11 | import android.media.MediaCodecInfo;
12 | import android.media.MediaExtractor;
13 | import android.media.MediaFormat;
14 | import android.media.MediaMuxer;
15 |
16 | import com.musicplus.app.MainApplication;
17 | import com.musicplus.utils.DLog;
18 |
19 | /**
20 | * 视频混合音频
21 | * @author Darcy
22 | */
23 | public abstract class VideoMuxer {
24 |
25 | private static final String TAG = "VideoMuxer";
26 |
27 | String mOutputVideo;
28 |
29 | private VideoMuxer(String outputVideo){
30 | this.mOutputVideo = outputVideo;
31 | }
32 |
33 | public final static VideoMuxer createVideoMuxer(String outputVideo){
34 | return new Mp4Muxer(outputVideo);
35 | }
36 |
37 | /**
38 | * mix raw audio into video
39 | * @param videoFile
40 | * @param rawAudioFile
41 | * @param includeAudioInVideo
42 | */
43 | public abstract void mixRawAudio(File videoFile,File rawAudioFile,boolean includeAudioInVideo);
44 |
45 | /**
46 | * use android sdk MediaMuxer
47 | * @author Darcy
48 | * @version API >= 18
49 | */
50 | private static class Mp4Muxer extends VideoMuxer{
51 |
52 | private final static String AUDIO_MIME = "audio/mp4a-latm";
53 | private final static long audioBytesPerSample = 44100*16/8;
54 |
55 | private long rawAudioSize;
56 |
57 | public Mp4Muxer(String outputVideo) {
58 | super(outputVideo);
59 | }
60 |
61 | @Override
62 | public void mixRawAudio(File videoFile, File rawAudioFile,boolean includeAudioInVideo) {
63 | final String videoFilePath = videoFile.getAbsolutePath();
64 |
65 | MediaMuxer videoMuxer = null;
66 | try {
67 |
68 | final String outputVideo = mOutputVideo;
69 | videoMuxer = new MediaMuxer(outputVideo,MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4);
70 |
71 | MediaFormat videoFormat = null;
72 | MediaExtractor videoExtractor = new MediaExtractor();
73 | videoExtractor.setDataSource(videoFilePath);
74 |
75 | for (int i = 0; i < videoExtractor.getTrackCount(); i++) {
76 | MediaFormat format = videoExtractor.getTrackFormat(i);
77 | String mime = format.getString(MediaFormat.KEY_MIME);
78 | if (mime.startsWith("video/")) {
79 | videoExtractor.selectTrack(i);
80 | videoFormat = format;
81 | break;
82 | }
83 | }
84 |
85 | int videoTrackIndex = videoMuxer.addTrack(videoFormat);
86 | int audioTrackIndex = 0;
87 |
88 | //extract and decode audio
89 | FileInputStream fisExtractAudio = null;
90 | if(includeAudioInVideo){
91 | AndroidAudioDecoder audioDecoder = new AndroidAudioDecoder(videoFilePath);
92 | String extractAudioFilePath = MainApplication.RECORD_AUDIO_PATH + "/" + System.currentTimeMillis();
93 | audioDecoder.decodeToFile(extractAudioFilePath);
94 |
95 | File extractAudioFile = new File(extractAudioFilePath);
96 | fisExtractAudio = new FileInputStream(extractAudioFile);
97 | }
98 | FileInputStream fisMixAudio = new FileInputStream(rawAudioFile);
99 |
100 | boolean readExtractAudioEOS = includeAudioInVideo ? false : true;
101 | boolean readMixAudioEOS = false;
102 | byte[] extractAudioBuffer = new byte[4096];
103 | byte[] mixAudioBuffer = new byte[4096];
104 | int extractAudioReadCount = 0;
105 | int mixAudioReadCount = 0;
106 |
107 | final MultiAudioMixer audioMixer = MultiAudioMixer.createAudioMixer();
108 | final byte[][] twoAudioBytes = new byte[2][];
109 |
110 | final MediaCodec audioEncoder = createACCAudioDecoder();
111 | audioEncoder.start();
112 |
113 | ByteBuffer[] audioInputBuffers = audioEncoder.getInputBuffers();
114 | ByteBuffer[] audioOutputBuffers = audioEncoder.getOutputBuffers();
115 | boolean sawInputEOS = false;
116 | boolean sawOutputEOS = false;
117 | long audioTimeUs = 0 ;
118 | BufferInfo outBufferInfo = new BufferInfo();
119 |
120 | int inputBufIndex, outputBufIndex;
121 | while(!sawOutputEOS){
122 | if (!sawInputEOS) {
123 | inputBufIndex = audioEncoder.dequeueInputBuffer(10000);
124 | if (inputBufIndex >= 0) {
125 | ByteBuffer inputBuffer = audioInputBuffers[inputBufIndex];
126 | inputBuffer.clear();
127 |
128 | int bufferSize = inputBuffer.remaining();
129 | if(bufferSize != extractAudioBuffer.length){
130 | extractAudioBuffer = new byte[bufferSize];
131 | mixAudioBuffer = new byte[bufferSize];
132 | }
133 |
134 | if(!readExtractAudioEOS){
135 | extractAudioReadCount = fisExtractAudio.read(extractAudioBuffer);
136 | if(extractAudioReadCount == -1){
137 | readExtractAudioEOS = true;
138 | }
139 | }
140 |
141 | if(!readMixAudioEOS){
142 | mixAudioReadCount = fisMixAudio.read(mixAudioBuffer);
143 | if(mixAudioReadCount == -1){
144 | readMixAudioEOS = true;
145 | }
146 | }
147 |
148 | if(readExtractAudioEOS && readMixAudioEOS){
149 | audioEncoder.queueInputBuffer(inputBufIndex,0 , 0 , 0 ,MediaCodec.BUFFER_FLAG_END_OF_STREAM);
150 | sawInputEOS = true;
151 | }else{
152 |
153 | byte[] mixAudioBytes;
154 | if(!readExtractAudioEOS && !readMixAudioEOS){
155 | if(extractAudioReadCount == mixAudioReadCount){
156 | twoAudioBytes[0] = extractAudioBuffer;
157 | twoAudioBytes[1] = mixAudioBuffer;
158 | }else if(extractAudioReadCount > mixAudioReadCount){
159 | twoAudioBytes[0] = extractAudioBuffer;
160 | Arrays.fill(mixAudioBuffer, mixAudioReadCount -1, bufferSize, (byte)0);
161 | }else{
162 | Arrays.fill(extractAudioBuffer, extractAudioReadCount -1, bufferSize, (byte)0);
163 | }
164 | mixAudioBytes = audioMixer.mixRawAudioBytes(twoAudioBytes);
165 | if(mixAudioBytes == null){
166 | DLog.e(TAG, "mix audio : null");
167 | }
168 | inputBuffer.put(mixAudioBytes);
169 | rawAudioSize += mixAudioBytes.length;
170 | audioEncoder.queueInputBuffer(inputBufIndex, 0, mixAudioBytes.length, audioTimeUs, 0);
171 | }else if(!readExtractAudioEOS && readMixAudioEOS){
172 | inputBuffer.put(extractAudioBuffer, 0, extractAudioReadCount);
173 | rawAudioSize += extractAudioReadCount;
174 | audioEncoder.queueInputBuffer(inputBufIndex, 0, extractAudioReadCount, audioTimeUs, 0);
175 | }else{
176 | inputBuffer.put(mixAudioBuffer, 0, mixAudioReadCount);
177 | rawAudioSize += mixAudioReadCount;
178 | audioEncoder.queueInputBuffer(inputBufIndex, 0, mixAudioReadCount, audioTimeUs, 0);
179 | }
180 |
181 | audioTimeUs = (long) (1000000 * (rawAudioSize / 2.0) / audioBytesPerSample);
182 | }
183 | }
184 | }
185 |
186 | outputBufIndex = audioEncoder.dequeueOutputBuffer(outBufferInfo, 10000);
187 | if(outputBufIndex >= 0){
188 |
189 | // Simply ignore codec config buffers.
190 | if ((outBufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG)!= 0) {
191 | DLog.i(TAG, "audio encoder: codec config buffer");
192 | audioEncoder.releaseOutputBuffer(outputBufIndex, false);
193 | continue;
194 | }
195 |
196 | if(outBufferInfo.size != 0){
197 | ByteBuffer outBuffer = audioOutputBuffers[outputBufIndex];
198 | outBuffer.position(outBufferInfo.offset);
199 | outBuffer.limit(outBufferInfo.offset + outBufferInfo.size);
200 | DLog.i(TAG, String.format(" writing audio sample : size=%s , presentationTimeUs=%s", outBufferInfo.size, outBufferInfo.presentationTimeUs));
201 | if(lastAudioPresentationTimeUs < outBufferInfo.presentationTimeUs){
202 | videoMuxer.writeSampleData(audioTrackIndex, outBuffer, outBufferInfo);
203 | lastAudioPresentationTimeUs = outBufferInfo.presentationTimeUs;
204 | }else{
205 | DLog.e(TAG, "error sample! its presentationTimeUs should not lower than before.");
206 | }
207 | }
208 |
209 | audioEncoder.releaseOutputBuffer(outputBufIndex, false);
210 |
211 | if ((outBufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
212 | sawOutputEOS = true;
213 | }
214 | }else if (outputBufIndex == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
215 | audioOutputBuffers = audioEncoder.getOutputBuffers();
216 | } else if (outputBufIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
217 | MediaFormat audioFormat = audioEncoder.getOutputFormat();
218 | audioTrackIndex = videoMuxer.addTrack(audioFormat);
219 | videoMuxer.start(); //start muxer
220 | }
221 | }
222 |
223 | if(fisExtractAudio != null){
224 | fisExtractAudio.close();
225 | }
226 |
227 | fisMixAudio.close();
228 | audioEncoder.stop();
229 | audioEncoder.release();
230 |
231 | //mix video
232 | boolean videoMuxDone = false;
233 | // 压缩帧大小 < 原始图片大小
234 | int videoWidth = videoFormat.getInteger(MediaFormat.KEY_WIDTH);
235 | int videoHeight = videoFormat.getInteger(MediaFormat.KEY_HEIGHT);
236 | ByteBuffer videoSampleBuffer = ByteBuffer.allocateDirect(videoWidth * videoHeight);
237 | BufferInfo videoBufferInfo = new BufferInfo();
238 | int sampleSize;
239 | while (!videoMuxDone) {
240 | videoSampleBuffer.clear();
241 | sampleSize = videoExtractor.readSampleData(videoSampleBuffer, 0);
242 | if (sampleSize < 0) {
243 | videoMuxDone = true;
244 | } else {
245 | videoBufferInfo.presentationTimeUs = videoExtractor.getSampleTime();
246 | videoBufferInfo.flags = videoExtractor.getSampleFlags();
247 | videoBufferInfo.size = sampleSize;
248 | videoSampleBuffer.limit(sampleSize);
249 | videoMuxer.writeSampleData(videoTrackIndex, videoSampleBuffer,videoBufferInfo);
250 | videoExtractor.advance();
251 | }
252 | }
253 |
254 | videoExtractor.release();
255 | } catch (IOException e) {
256 | e.printStackTrace();
257 | }finally{
258 | if(videoMuxer != null){
259 | videoMuxer.stop();
260 | videoMuxer.release();
261 | DLog.i(TAG, "video mix complete.");
262 | }
263 | }
264 | }
265 |
266 | private MediaCodec createACCAudioDecoder() throws IOException {
267 | MediaCodec codec = MediaCodec.createEncoderByType(AUDIO_MIME);
268 | MediaFormat format = new MediaFormat();
269 | format.setString(MediaFormat.KEY_MIME, AUDIO_MIME);
270 | format.setInteger(MediaFormat.KEY_BIT_RATE, 128000);
271 | format.setInteger(MediaFormat.KEY_CHANNEL_COUNT, 2);
272 | format.setInteger(MediaFormat.KEY_SAMPLE_RATE, 44100);
273 | format.setInteger(MediaFormat.KEY_AAC_PROFILE,
274 | MediaCodecInfo.CodecProfileLevel.AACObjectLC);
275 | codec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
276 | return codec;
277 | }
278 |
279 | private long lastAudioPresentationTimeUs = -1;
280 | }
281 | }
282 |
--------------------------------------------------------------------------------
/src/com/musicplus/media/VideoRecorder.java:
--------------------------------------------------------------------------------
1 | package com.musicplus.media;
2 |
3 | import java.io.IOException;
4 | import java.util.List;
5 | import java.util.concurrent.BrokenBarrierException;
6 | import java.util.concurrent.CyclicBarrier;
7 |
8 | import android.app.Activity;
9 | import android.hardware.Camera;
10 | import android.media.MediaRecorder;
11 | import android.os.AsyncTask;
12 | import android.view.Surface;
13 | import android.view.SurfaceView;
14 |
15 | /**
16 | * video recoder
17 | *
18 | * @author Darcy
19 | */
20 | public class VideoRecorder {
21 |
22 | private Activity mActivity;
23 | private MediaRecorder mMediaRecorder;
24 | private SurfaceView mPreview;
25 | private int mVidoeWidth,mVideoHeight;
26 | private Camera mCamera;
27 | private String mOutputFile;
28 |
29 | private OnVideoRecordListener mListener;
30 | private volatile boolean isRecording = false;
31 | private boolean isValidCamera;
32 |
33 | private CyclicBarrier mRecordBarrier; //同步背景音乐
34 |
35 | public VideoRecorder(Activity activity , SurfaceView preview, String outputFile, CyclicBarrier recordBarrier) {
36 | this.mActivity = activity;
37 | this.mPreview = preview;
38 | this.mOutputFile = outputFile;
39 | this.mRecordBarrier = recordBarrier;
40 | }
41 |
42 | public void setOnVideoRecordListener(OnVideoRecordListener l){
43 | this.mListener = l;
44 | }
45 |
46 | public void startPreview(){
47 | try {
48 | prepareCamera();
49 | mCamera.startPreview();
50 | isValidCamera = true;
51 | } catch (IOException e) {
52 | e.printStackTrace();
53 | isValidCamera = false;
54 | }
55 | }
56 |
57 | public void startRecord() {
58 | if(isValidCamera && !isRecording){
59 | isRecording = true;
60 | new MediaRecordTask().execute();
61 | }
62 | }
63 |
64 | class MediaRecordTask extends AsyncTask