android MediaCodec 音頻編解碼的實現——轉碼

原文地址：http://blog.csdn.net/tinsanmr/article/details/51049179

從今天開始 每周不定期更新博客，把這一周在工作與學習中遇到的問題做個總結。俗話說：好記性不如寫博客，善於總結的人才能走的更遠。寫博客這種利人利己的好處我就不一 一列舉了，總之，誰做誰知道，哈哈。在文章中如果有什么問題或者錯誤，歡迎各位的討論和指正。好了，步入正題，來看看我們今天要講的MediaCodec

一、概述

由於項目的需要，需要將mp3文件轉碼為aac音頻文件，起初打算移植FFmpeg到項目中，無奈FFmpeg過於龐大，項目中的音頻轉碼只是一個輔助util，並不是主要功能。所以打算用MediaCodec來實現這一需求。網上關於MediaCodec的文章少的可憐，寫demo的過程中踩到了無數的坑。不過，在http://blog.csdn.net/tn0521/article/details/44980183 這篇文章的指引下，終於在耳機中聽到了那美妙的旋律，激動的我把這一首歌聽了一星期，因為他出自我的手。哈哈，開個玩笑！在此對這片文章的原創表示感謝，這也是我決定寫博客的原因之一，利人利己。

二、轉碼實現原理

本篇文章以mp3轉碼成aac為例，轉碼實現原理：mp3->pcm->aac，首先將mp3解碼成PCM，再將PCM編碼成aac格式的音頻文件。

PCM：可以將它理解為，未經過壓縮的數字信號，mp3、aac等 理解為pcm壓縮后的文件。播放器在播放mp3、aac等文件時要先將mp3等文件解碼成PCM數據，然后再將PCM送到底層去處理播放

此處就好比 我要將rar壓縮包內的文件改用zip壓縮，->解壓rar-->文件-->壓縮zip

三、遇到問題

1、編解碼過程中會卡主：此為參數設置引起的，下面代碼中會提到

2、編碼的aac音頻不能播放：在編碼過程中需要為aac音頻添加ADTS head，代碼中有體現

3、最頭痛的，轉碼速度太慢，轉碼一首歌長達5分鍾。

此問題究其原因，是由於MediaExtractor每次喂給MediaCodec的數據太少，每次只喂一幀的數據，通過打印的log發現size不到1k，嚴重影響效率，后來嘗試不用MediaExtractor去讀數據，直接開流 BufferInputStream設置200k ，每次循環喂給MediaCodec200k的數據 ， 最終！！！ 在三星手機上完美運行，一次轉碼由5分鍾，直接降到10多秒，但是，注意但是！！！ 此方法在其他測試機上全報錯，淚奔。

無奈，開線程，將解碼和編碼分別放到兩個線程里面去執行，並且讓MediaExtractor讀取多次數據后再交給MediaCodec去處理，此方法轉碼一首歌大約1分鍾左右（各位如果有好的方法不吝賜教，本人非常感激）

四、代碼實現 1）初始化解碼器

MediaExtractor：可用於分離視頻文件的音軌和視頻軌道，如果你只想要視頻，那么用selectTrack方法選中視頻軌道，然后用readSampleData讀出數據，這樣你就得到了一個沒有聲音的視頻。此處我們傳入的是一個音頻文件（mp3），所以也就只有一個軌道，音頻軌道

mime：用來表示媒體文件的格式 mp3為audio/mpeg；aac為audio/mp4a-latm；mp4為video/mp4v-es 此處注意前綴 音頻前綴為audio，視頻前綴為video 我們可用此區別區分媒體文件內的音頻軌道和視頻軌道

mime的各種類型定義在MediaFormat靜態常量中

MediaCodec.createDecoderByType(mime) 創建對應格式的解碼器 要解碼mp3 那么mime="audio/mpeg" 或者MediaFormat.MIMETYPE_AUDIO_MPEG其它同理

 

/**
     * 初始化解碼器
     */
    private void initMediaDecode() {
        try {
            mediaExtractor=new MediaExtractor();//此類可分離視頻文件的音軌和視頻軌道
            mediaExtractor.setDataSource(srcPath);//媒體文件的位置
            for (int i = 0; i < mediaExtractor.getTrackCount(); i++) {//遍歷媒體軌道 此處我們傳入的是音頻文件，所以也就只有一條軌道
                MediaFormat format = mediaExtractor.getTrackFormat(i);
                String mime = format.getString(MediaFormat.KEY_MIME);
                if (mime.startsWith("audio")) {//獲取音頻軌道
//                    format.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, 200 * 1024);
                    mediaExtractor.selectTrack(i);//選擇此音頻軌道
                    mediaDecode = MediaCodec.createDecoderByType(mime);//創建Decode解碼器
                    mediaDecode.configure(format, null, null, 0);
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        if (mediaDecode == null) {
            Log.e(TAG, "create mediaDecode failed");
            return;
        }
        mediaDecode.start();//啟動MediaCodec ，等待傳入數據
        decodeInputBuffers=mediaDecode.getInputBuffers();//MediaCodec在此ByteBuffer[]中獲取輸入數據
        decodeOutputBuffers=mediaDecode.getOutputBuffers();//MediaCodec將解碼后的數據放到此ByteBuffer[]中 我們可以直接在這里面得到PCM數據
        decodeBufferInfo=new MediaCodec.BufferInfo();//用於描述解碼得到的byte[]數據的相關信息
        showLog("buffers:" + decodeInputBuffers.length);
    }

 

 

2)初始化編碼器 

編碼器的創建於解碼器的類似，只不過解碼器的MediaFormat直接在音頻文件內獲取就可以了，編碼器的MediaFormat需要自己來創建

 

/**
 * 初始化AAC編碼器
 */
private void initAACMediaEncode() {
    try {
        MediaFormat encodeFormat = MediaFormat.createAudioFormat(encodeType, 44100, 2);//參數對應-> mime type、采樣率、聲道數
        encodeFormat.setInteger(MediaFormat.KEY_BIT_RATE, 96000);//比特率
        encodeFormat.setInteger(MediaFormat.KEY_AAC_PROFILE, MediaCodecInfo.CodecProfileLevel.AACObjectLC);
        encodeFormat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, 100 * 1024);//作用於inputBuffer的大小
        mediaEncode = MediaCodec.createEncoderByType(encodeType);
        mediaEncode.configure(encodeFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
    } catch (IOException e) {
        e.printStackTrace();
    }

    if (mediaEncode == null) {
        Log.e(TAG, "create mediaEncode failed");
        return;
    }
    mediaEncode.start();
    encodeInputBuffers=mediaEncode.getInputBuffers();
    encodeOutputBuffers=mediaEncode.getOutputBuffers();
    encodeBufferInfo=new MediaCodec.BufferInfo();
}
 

 

3)解碼的實現

 

/**
     * 解碼{@link #srcPath}音頻文件 得到PCM數據塊
     * @return 是否解碼完所有數據
     */
    private void srcAudioFormatToPCM() {
        for (int i = 0; i < decodeInputBuffers.length-1; i++) {
        int inputIndex = mediaDecode.dequeueInputBuffer(-1);//獲取可用的inputBuffer -1代表一直等待，0表示不等待 建議-1,避免丟幀
        if (inputIndex < 0) {
            codeOver =true;
            return;
        }

        ByteBuffer inputBuffer = decodeInputBuffers[inputIndex];//拿到inputBuffer
        inputBuffer.clear();//清空之前傳入inputBuffer內的數據
        int sampleSize = mediaExtractor.readSampleData(inputBuffer, 0);//MediaExtractor讀取數據到inputBuffer中
        if (sampleSize <0) {//小於0 代表所有數據已讀取完成
                codeOver=true;
            }else {
                mediaDecode.queueInputBuffer(inputIndex, 0, sampleSize, 0, 0);//通知MediaDecode解碼剛剛傳入的數據
                mediaExtractor.advance();//MediaExtractor移動到下一取樣處
                decodeSize+=sampleSize;
            }
        }

        //獲取解碼得到的byte[]數據 參數BufferInfo上面已介紹 10000同樣為等待時間 同上-1代表一直等待，0代表不等待。此處單位為微秒
        //此處建議不要填-1 有些時候並沒有數據輸出，那么他就會一直卡在這 等待
        int outputIndex = mediaDecode.dequeueOutputBuffer(decodeBufferInfo, 10000);

//        showLog("decodeOutIndex:" + outputIndex);
        ByteBuffer outputBuffer;
        byte[] chunkPCM;
        while (outputIndex >= 0) {//每次解碼完成的數據不一定能一次吐出 所以用while循環，保證解碼器吐出所有數據
            outputBuffer = decodeOutputBuffers[outputIndex];//拿到用於存放PCM數據的Buffer
            chunkPCM = new byte[decodeBufferInfo.size];//BufferInfo內定義了此數據塊的大小
            outputBuffer.get(chunkPCM);//將Buffer內的數據取出到字節數組中
            outputBuffer.clear();//數據取出后一定記得清空此Buffer MediaCodec是循環使用這些Buffer的，不清空下次會得到同樣的數據
            putPCMData(chunkPCM);//自己定義的方法，供編碼器所在的線程獲取數據,下面會貼出代碼
            mediaDecode.releaseOutputBuffer(outputIndex, false);//此操作一定要做，不然MediaCodec用完所有的Buffer后 將不能向外輸出數據
            outputIndex = mediaDecode.dequeueOutputBuffer(decodeBufferInfo, 10000);//再次獲取數據，如果沒有數據輸出則outputIndex=-1 循環結束
        }

    }

 

 

4）編碼的實現

 

/**
     * 編碼PCM數據 得到{@link #encodeType}格式的音頻文件，並保存到{@link #dstPath}
     */
    private void dstAudioFormatFromPCM() {

        int inputIndex;
        ByteBuffer inputBuffer;
        int outputIndex;
        ByteBuffer outputBuffer;
        byte[] chunkAudio;
        int outBitSize;
        int outPacketSize;
        byte[] chunkPCM;

//        showLog("doEncode");
        for (int i = 0; i < encodeInputBuffers.length-1; i++) {
            chunkPCM=getPCMData();//獲取解碼器所在線程輸出的數據 代碼后邊會貼上
            if (chunkPCM == null) {
                break;
            }
            inputIndex = mediaEncode.dequeueInputBuffer(-1);//同解碼器
            inputBuffer = encodeInputBuffers[inputIndex];//同解碼器
            inputBuffer.clear();//同解碼器
            inputBuffer.limit(chunkPCM.length);
            inputBuffer.put(chunkPCM);//PCM數據填充給inputBuffer
            mediaEncode.queueInputBuffer(inputIndex, 0, chunkPCM.length, 0, 0);//通知編碼器 編碼
        }

            outputIndex = mediaEncode.dequeueOutputBuffer(encodeBufferInfo, 10000);//同解碼器
            while (outputIndex >= 0) {//同解碼器

                outBitSize=encodeBufferInfo.size;
                outPacketSize=outBitSize+7;//7為ADTS頭部的大小
                outputBuffer = encodeOutputBuffers[outputIndex];//拿到輸出Buffer
                outputBuffer.position(encodeBufferInfo.offset);
                outputBuffer.limit(encodeBufferInfo.offset + outBitSize);
                chunkAudio = new byte[outPacketSize];
                addADTStoPacket(chunkAudio,outPacketSize);//添加ADTS 代碼后面會貼上
                outputBuffer.get(chunkAudio, 7, outBitSize);//將編碼得到的AAC數據 取出到byte[]中 偏移量offset=7 你懂得
                outputBuffer.position(encodeBufferInfo.offset);
//                showLog("outPacketSize:" + outPacketSize + " encodeOutBufferRemain:" + outputBuffer.remaining());
                try {
                    bos.write(chunkAudio,0,chunkAudio.length);//BufferOutputStream 將文件保存到內存卡中 *.aac 
                } catch (IOException e) {
                    e.printStackTrace();
                }

                mediaEncode.releaseOutputBuffer(outputIndex,false);
                outputIndex = mediaEncode.dequeueOutputBuffer(encodeBufferInfo, 10000);

            }

    }
 

 

/**
     * 添加ADTS頭
     * @param packet
     * @param packetLen
     */
    private void addADTStoPacket(byte[] packet, int packetLen) {
        int profile = 2; // AAC LC
        int freqIdx = 4; // 44.1KHz
        int chanCfg = 2; // CPE


// fill in ADTS data
        packet[0] = (byte) 0xFF;
        packet[1] = (byte) 0xF9;
        packet[2] = (byte) (((profile - 1) << 6) + (freqIdx << 2) + (chanCfg >> 2));
        packet[3] = (byte) (((chanCfg & 3) << 6) + (packetLen >> 11));
        packet[4] = (byte) ((packetLen & 0x7FF) >> 3);
        packet[5] = (byte) (((packetLen & 7) << 5) + 0x1F);
        packet[6] = (byte) 0xFC;
    }
 

 

5）完整代碼

package com.example.tinsan.mediaparser;


        import android.media.MediaCodec;
        import android.media.MediaCodecInfo;
        import android.media.MediaExtractor;
        import android.media.MediaFormat;
        import android.util.Log;

        import java.io.BufferedInputStream;
        import java.io.BufferedOutputStream;
        import java.io.File;
        import java.io.FileInputStream;
        import java.io.FileNotFoundException;
        import java.io.FileOutputStream;
        import java.io.IOException;
        import java.nio.ByteBuffer;
        import java.util.ArrayList;

/**
 * Created by senshan_wang on 2016/3/31.
 */
public class AudioCodec {

    private static final String TAG = "AudioCodec";
    private String encodeType;
    private String srcPath;
    private String dstPath;
    private MediaCodec mediaDecode;
    private MediaCodec mediaEncode;
    private MediaExtractor mediaExtractor;
    private ByteBuffer[] decodeInputBuffers;
    private ByteBuffer[] decodeOutputBuffers;
    private ByteBuffer[] encodeInputBuffers;
    private ByteBuffer[] encodeOutputBuffers;
    private MediaCodec.BufferInfo decodeBufferInfo;
    private MediaCodec.BufferInfo encodeBufferInfo;
    private FileOutputStream fos;
    private BufferedOutputStream bos;
    private FileInputStream fis;
    private BufferedInputStream bis;
    private ArrayList<byte[]> chunkPCMDataContainer;//PCM數據塊容器
    private OnCompleteListener onCompleteListener;
    private OnProgressListener onProgressListener;
    private long fileTotalSize;
    private long decodeSize;


    public static AudioCodec newInstance() {
        return new AudioCodec();
    }

    /**
     * 設置編碼器類型
     * @param encodeType
     */
    public void setEncodeType(String encodeType) {
        this.encodeType=encodeType;
    }

    /**
     * 設置輸入輸出文件位置
     * @param srcPath
     * @param dstPath
     */
    public void setIOPath(String srcPath, String dstPath) {
        this.srcPath=srcPath;
        this.dstPath=dstPath;
    }

    /**
     * 此類已經過封裝
     * 調用prepare方法 會初始化Decode 、Encode 、輸入輸出流 等一些列操作
     */
    public void prepare() {

        if (encodeType == null) {
            throw new IllegalArgumentException("encodeType can't be null");
        }

        if (srcPath == null) {
            throw new IllegalArgumentException("srcPath can't be null");
        }

        if (dstPath == null) {
            throw new IllegalArgumentException("dstPath can't be null");
        }

        try {
            fos = new FileOutputStream(new File(dstPath));
            bos = new BufferedOutputStream(fos,200*1024);
            File file = new File(srcPath);
            fileTotalSize=file.length();
        } catch (IOException e) {
            e.printStackTrace();
        }
        chunkPCMDataContainer= new ArrayList<>();
        initMediaDecode();//解碼器

        if (encodeType == MediaFormat.MIMETYPE_AUDIO_AAC) {
            initAACMediaEncode();//AAC編碼器
        }else if (encodeType == MediaFormat.MIMETYPE_AUDIO_MPEG) {
            initMPEGMediaEncode();//mp3編碼器
        }

    }

    /**
     * 初始化解碼器
     */
    private void initMediaDecode() {
        try {
            mediaExtractor=new MediaExtractor();//此類可分離視頻文件的音軌和視頻軌道
            mediaExtractor.setDataSource(srcPath);//媒體文件的位置
            for (int i = 0; i < mediaExtractor.getTrackCount(); i++) {//遍歷媒體軌道 此處我們傳入的是音頻文件，所以也就只有一條軌道
                MediaFormat format = mediaExtractor.getTrackFormat(i);
                String mime = format.getString(MediaFormat.KEY_MIME);
                if (mime.startsWith("audio")) {//獲取音頻軌道
//                    format.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, 200 * 1024);
                    mediaExtractor.selectTrack(i);//選擇此音頻軌道
                    mediaDecode = MediaCodec.createDecoderByType(mime);//創建Decode解碼器
                    mediaDecode.configure(format, null, null, 0);
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        if (mediaDecode == null) {
            Log.e(TAG, "create mediaDecode failed");
            return;
        }
        mediaDecode.start();//啟動MediaCodec ，等待傳入數據
        decodeInputBuffers=mediaDecode.getInputBuffers();//MediaCodec在此ByteBuffer[]中獲取輸入數據
        decodeOutputBuffers=mediaDecode.getOutputBuffers();//MediaCodec將解碼后的數據放到此ByteBuffer[]中 我們可以直接在這里面得到PCM數據
        decodeBufferInfo=new MediaCodec.BufferInfo();//用於描述解碼得到的byte[]數據的相關信息
        showLog("buffers:" + decodeInputBuffers.length);
    }


    /**
     * 初始化AAC編碼器
     */
    private void initAACMediaEncode() {
        try {
            MediaFormat encodeFormat = MediaFormat.createAudioFormat(encodeType, 44100, 2);//參數對應-> mime type、采樣率、聲道數
            encodeFormat.setInteger(MediaFormat.KEY_BIT_RATE, 96000);//比特率
            encodeFormat.setInteger(MediaFormat.KEY_AAC_PROFILE, MediaCodecInfo.CodecProfileLevel.AACObjectLC);
            encodeFormat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, 100 * 1024);
            mediaEncode = MediaCodec.createEncoderByType(encodeType);
            mediaEncode.configure(encodeFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
        } catch (IOException e) {
            e.printStackTrace();
        }

        if (mediaEncode == null) {
            Log.e(TAG, "create mediaEncode failed");
            return;
        }
        mediaEncode.start();
        encodeInputBuffers=mediaEncode.getInputBuffers();
        encodeOutputBuffers=mediaEncode.getOutputBuffers();
        encodeBufferInfo=new MediaCodec.BufferInfo();
    }

    /**
     * 初始化MPEG編碼器
     */
    private void initMPEGMediaEncode() {
        
    }

    private boolean codeOver = false;
    /**
     * 開始轉碼
     * 音頻數據{@link #srcPath}先解碼成PCM  PCM數據在編碼成想要得到的{@link #encodeType}音頻格式
     * mp3->PCM->aac
     */
    public void startAsync() {
        showLog("start");

        new Thread(new DecodeRunnable()).start();
        new Thread(new EncodeRunnable()).start();

    }

    /**
     * 將PCM數據存入{@link #chunkPCMDataContainer}
     * @param pcmChunk PCM數據塊
     */
    private void putPCMData(byte[] pcmChunk) {
        synchronized (AudioCodec.class) {//記得加鎖
            chunkPCMDataContainer.add(pcmChunk);
        }
    }

    /**
     * 在Container中{@link #chunkPCMDataContainer}取出PCM數據
     * @return PCM數據塊
     */
    private byte[] getPCMData() {
        synchronized (AudioCodec.class) {//記得加鎖
            showLog("getPCM:"+chunkPCMDataContainer.size());
            if (chunkPCMDataContainer.isEmpty()) {
                return null;
            }

            byte[] pcmChunk = chunkPCMDataContainer.get(0);//每次取出index 0 的數據
            chunkPCMDataContainer.remove(pcmChunk);//取出后將此數據remove掉 既能保證PCM數據塊的取出順序 又能及時釋放內存
            return pcmChunk;
        }
    }


    /**
     * 解碼{@link #srcPath}音頻文件 得到PCM數據塊
     * @return 是否解碼完所有數據
     */
    private void srcAudioFormatToPCM() {
        for (int i = 0; i < decodeInputBuffers.length-1; i++) {
        int inputIndex = mediaDecode.dequeueInputBuffer(-1);//獲取可用的inputBuffer -1代表一直等待，0表示不等待 建議-1,避免丟幀
        if (inputIndex < 0) {
            codeOver =true;
            return;
        }

        ByteBuffer inputBuffer = decodeInputBuffers[inputIndex];//拿到inputBuffer
        inputBuffer.clear();//清空之前傳入inputBuffer內的數據
        int sampleSize = mediaExtractor.readSampleData(inputBuffer, 0);//MediaExtractor讀取數據到inputBuffer中
        if (sampleSize <0) {//小於0 代表所有數據已讀取完成
                codeOver=true;
            }else {
                mediaDecode.queueInputBuffer(inputIndex, 0, sampleSize, 0, 0);//通知MediaDecode解碼剛剛傳入的數據
                mediaExtractor.advance();//MediaExtractor移動到下一取樣處
                decodeSize+=sampleSize;
            }
        }

        //獲取解碼得到的byte[]數據 參數BufferInfo上面已介紹 10000同樣為等待時間 同上-1代表一直等待，0代表不等待。此處單位為微秒
        //此處建議不要填-1 有些時候並沒有數據輸出，那么他就會一直卡在這 等待
        int outputIndex = mediaDecode.dequeueOutputBuffer(decodeBufferInfo, 10000);

//        showLog("decodeOutIndex:" + outputIndex);
        ByteBuffer outputBuffer;
        byte[] chunkPCM;
        while (outputIndex >= 0) {//每次解碼完成的數據不一定能一次吐出 所以用while循環，保證解碼器吐出所有數據
            outputBuffer = decodeOutputBuffers[outputIndex];//拿到用於存放PCM數據的Buffer
            chunkPCM = new byte[decodeBufferInfo.size];//BufferInfo內定義了此數據塊的大小
            outputBuffer.get(chunkPCM);//將Buffer內的數據取出到字節數組中
            outputBuffer.clear();//數據取出后一定記得清空此Buffer MediaCodec是循環使用這些Buffer的，不清空下次會得到同樣的數據
            putPCMData(chunkPCM);//自己定義的方法，供編碼器所在的線程獲取數據,下面會貼出代碼
            mediaDecode.releaseOutputBuffer(outputIndex, false);//此操作一定要做，不然MediaCodec用完所有的Buffer后 將不能向外輸出數據
            outputIndex = mediaDecode.dequeueOutputBuffer(decodeBufferInfo, 10000);//再次獲取數據，如果沒有數據輸出則outputIndex=-1 循環結束
        }

    }

    /**
     * 編碼PCM數據 得到{@link #encodeType}格式的音頻文件，並保存到{@link #dstPath}
     */
    private void dstAudioFormatFromPCM() {

        int inputIndex;
        ByteBuffer inputBuffer;
        int outputIndex;
        ByteBuffer outputBuffer;
        byte[] chunkAudio;
        int outBitSize;
        int outPacketSize;
        byte[] chunkPCM;

//        showLog("doEncode");
        for (int i = 0; i < encodeInputBuffers.length-1; i++) {
            chunkPCM=getPCMData();//獲取解碼器所在線程輸出的數據 代碼后邊會貼上
            if (chunkPCM == null) {
                break;
            }
            inputIndex = mediaEncode.dequeueInputBuffer(-1);//同解碼器
            inputBuffer = encodeInputBuffers[inputIndex];//同解碼器
            inputBuffer.clear();//同解碼器
            inputBuffer.limit(chunkPCM.length);
            inputBuffer.put(chunkPCM);//PCM數據填充給inputBuffer
            mediaEncode.queueInputBuffer(inputIndex, 0, chunkPCM.length, 0, 0);//通知編碼器 編碼
        }

            outputIndex = mediaEncode.dequeueOutputBuffer(encodeBufferInfo, 10000);//同解碼器
            while (outputIndex >= 0) {//同解碼器

                outBitSize=encodeBufferInfo.size;
                outPacketSize=outBitSize+7;//7為ADTS頭部的大小
                outputBuffer = encodeOutputBuffers[outputIndex];//拿到輸出Buffer
                outputBuffer.position(encodeBufferInfo.offset);
                outputBuffer.limit(encodeBufferInfo.offset + outBitSize);
                chunkAudio = new byte[outPacketSize];
                addADTStoPacket(chunkAudio,outPacketSize);//添加ADTS 代碼后面會貼上
                outputBuffer.get(chunkAudio, 7, outBitSize);//將編碼得到的AAC數據 取出到byte[]中 偏移量offset=7 你懂得
                outputBuffer.position(encodeBufferInfo.offset);
//                showLog("outPacketSize:" + outPacketSize + " encodeOutBufferRemain:" + outputBuffer.remaining());
                try {
                    bos.write(chunkAudio,0,chunkAudio.length);//BufferOutputStream 將文件保存到內存卡中 *.aac
                } catch (IOException e) {
                    e.printStackTrace();
                }

                mediaEncode.releaseOutputBuffer(outputIndex,false);
                outputIndex = mediaEncode.dequeueOutputBuffer(encodeBufferInfo, 10000);

            }
    }

    /**
     * 添加ADTS頭
     * @param packet
     * @param packetLen
     */
    private void addADTStoPacket(byte[] packet, int packetLen) {
        int profile = 2; // AAC LC
        int freqIdx = 4; // 44.1KHz
        int chanCfg = 2; // CPE


// fill in ADTS data
        packet[0] = (byte) 0xFF;
        packet[1] = (byte) 0xF9;
        packet[2] = (byte) (((profile - 1) << 6) + (freqIdx << 2) + (chanCfg >> 2));
        packet[3] = (byte) (((chanCfg & 3) << 6) + (packetLen >> 11));
        packet[4] = (byte) ((packetLen & 0x7FF) >> 3);
        packet[5] = (byte) (((packetLen & 7) << 5) + 0x1F);
        packet[6] = (byte) 0xFC;
    }

    /**
     * 釋放資源
     */
    public void release() {
        try {
            if (bos != null) {
                bos.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }finally {
                    bos=null;
                }
            }
        }

        try {
            if (fos != null) {
                fos.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            fos=null;
        }

        if (mediaEncode != null) {
            mediaEncode.stop();
            mediaEncode.release();
            mediaEncode=null;
        }

        if (mediaDecode != null) {
            mediaDecode.stop();
            mediaDecode.release();
            mediaDecode=null;
        }

        if (mediaExtractor != null) {
            mediaExtractor.release();
            mediaExtractor=null;
        }

        if (onCompleteListener != null) {
            onCompleteListener=null;
        }

        if (onProgressListener != null) {
            onProgressListener=null;
        }
        showLog("release");
    }

    /**
     * 解碼線程
     */
    private class DecodeRunnable implements Runnable{

        @Override
        public void run() {
            while (!codeOver) {
                srcAudioFormatToPCM();
            }
        }
    }

    /**
     * 編碼線程
     */
    private class EncodeRunnable implements Runnable {

        @Override
        public void run() {
            long t=System.currentTimeMillis();
            while (!codeOver || !chunkPCMDataContainer.isEmpty()) {
                dstAudioFormatFromPCM();
            }
            if (onCompleteListener != null) {
                onCompleteListener.completed();
            }
            showLog("size:"+fileTotalSize+" decodeSize:"+decodeSize+"time:"+(System.currentTimeMillis()-t));
        }
    }


    /**
     * 轉碼完成回調接口
     */
    public interface OnCompleteListener{
        void completed();
    }

    /**
     * 轉碼進度監聽器
     */
    public interface OnProgressListener{
        void progress();
    }

    /**
     * 設置轉碼完成監聽器
     * @param onCompleteListener
     */
    public void setOnCompleteListener(OnCompleteListener onCompleteListener) {
        this.onCompleteListener=onCompleteListener;
    }

    public void setOnProgressListener(OnProgressListener onProgressListener) {
        this.onProgressListener = onProgressListener;
    }

    private void showLog(String msg) {
        Log.e("AudioCodec", msg);
    }
}

 

6）調用

此類已經過封裝，可通過下面的方法調用

String path=Environment.getExternalStorageDirectory().getAbsolutePath();
AudioCodec audioCodec=AudioCodec.newInstance();
audioCodec.setEncodeType(MediaFormat.MIMETYPE_AUDIO_MPEG);
audioCodec.setIOPath(path + "/codec.aac", path + "/encode.mp3");
audioCodec.prepare();
audioCodec.startAsync();
audioCodec.setOnCompleteListener(new AudioCodec.OnCompleteListener() {
    @Override
    public void completed() {
        audioCodec.release();
    }
});