Android利用MediaCodec組件實現(xiàn)音視頻編解碼功能

更新時間：2025年09月12日 08:35:19 作者：天天進步2015

Android MediaCodec是Android平臺提供的底層音視頻編解碼API,它為開發(fā)者提供了直接訪問設(shè)備硬件編解碼器的能力,本文將深入探討MediaCodec的核心概念、使用方法以及在實際開發(fā)中的最佳實踐

概述

Android MediaCodec是Android平臺提供的底層音視頻編解碼API，它為開發(fā)者提供了直接訪問設(shè)備硬件編解碼器的能力。通過MediaCodec，我們可以高效地處理音頻和視頻數(shù)據(jù)的編碼與解碼操作，實現(xiàn)高性能的多媒體應(yīng)用。

本文將深入探討MediaCodec的核心概念、使用方法以及在實際開發(fā)中的最佳實踐。

MediaCodec架構(gòu)簡介

基本工作原理

MediaCodec采用異步的、基于緩沖區(qū)的處理模式。其核心架構(gòu)包括：

輸入緩沖區(qū)隊列（Input Buffer Queue）：存放待處理的原始數(shù)據(jù)
輸出緩沖區(qū)隊列（Output Buffer Queue）：存放處理后的數(shù)據(jù)
編解碼引擎：執(zhí)行實際的編解碼操作
回調(diào)機制：通知應(yīng)用程序緩沖區(qū)狀態(tài)變化

狀態(tài)管理

MediaCodec具有明確的狀態(tài)機制：

Uninitialized → Configured → Executing → Released
↓ ↓ ↓
Error ←——————————————————————————

視頻解碼實現(xiàn)

創(chuàng)建和配置解碼器

public class VideoDecoder {
    private MediaCodec decoder;
    private Surface surface;
    
    public void initDecoder(String mimeType, int width, int height, Surface outputSurface) {
        try {
            // 創(chuàng)建解碼器實例
            decoder = MediaCodec.createDecoderByType(mimeType);
            
            // 配置MediaFormat
            MediaFormat format = MediaFormat.createVideoFormat(mimeType, width, height);
            
            // 設(shè)置輸出Surface
            this.surface = outputSurface;
            
            // 配置解碼器
            decoder.configure(format, surface, null, 0);
            decoder.start();
            
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

異步解碼處理

public void startDecoding() {
    decoder.setCallback(new MediaCodec.Callback() {
        @Override
        public void onInputBufferAvailable(MediaCodec codec, int index) {
            // 處理輸入緩沖區(qū)
            ByteBuffer inputBuffer = codec.getInputBuffer(index);
            
            // 從數(shù)據(jù)源讀取數(shù)據(jù)到inputBuffer
            int sampleSize = readSampleData(inputBuffer);
            
            if (sampleSize > 0) {
                // 提交輸入數(shù)據(jù)
                codec.queueInputBuffer(index, 0, sampleSize, 
                    getCurrentTimestamp(), 0);
            } else {
                // 數(shù)據(jù)結(jié)束
                codec.queueInputBuffer(index, 0, 0, 0, 
                    MediaCodec.BUFFER_FLAG_END_OF_STREAM);
            }
        }
        
        @Override
        public void onOutputBufferAvailable(MediaCodec codec, int index, 
                MediaCodec.BufferInfo info) {
            // 處理輸出緩沖區(qū)
            if ((info.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
                // 解碼完成
                handleDecodingComplete();
            }
            
            // 釋放輸出緩沖區(qū)（渲染到Surface）
            codec.releaseOutputBuffer(index, true);
        }
        
        @Override
        public void onError(MediaCodec codec, MediaCodec.CodecException e) {
            // 錯誤處理
            handleError(e);
        }
        
        @Override
        public void onOutputFormatChanged(MediaCodec codec, MediaFormat format) {
            // 輸出格式變化處理
            handleFormatChange(format);
        }
    });
}

視頻編碼實現(xiàn)

編碼器初始化

public class VideoEncoder {
    private MediaCodec encoder;
    private Surface inputSurface;
    private MediaMuxer muxer;
    
    public void initEncoder(String outputPath, int width, int height, int bitRate) {
        try {
            // 創(chuàng)建編碼器
            encoder = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_VIDEO_AVC);
            
            // 配置編碼參數(shù)
            MediaFormat format = MediaFormat.createVideoFormat(
                MediaFormat.MIMETYPE_VIDEO_AVC, width, height);
            format.setInteger(MediaFormat.KEY_COLOR_FORMAT, 
                MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
            format.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
            format.setInteger(MediaFormat.KEY_FRAME_RATE, 30);
            format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 2);
            
            // 配置編碼器
            encoder.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
            
            // 獲取輸入Surface
            inputSurface = encoder.createInputSurface();
            
            // 創(chuàng)建MediaMuxer用于輸出
            muxer = new MediaMuxer(outputPath, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4);
            
            encoder.start();
            
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

編碼數(shù)據(jù)處理

private int videoTrackIndex = -1;
private boolean muxerStarted = false;

public void startEncoding() {
    encoder.setCallback(new MediaCodec.Callback() {
        @Override
        public void onInputBufferAvailable(MediaCodec codec, int index) {
            // 對于Surface輸入，這個回調(diào)通常不使用
        }
        
        @Override
        public void onOutputBufferAvailable(MediaCodec codec, int index, 
                MediaCodec.BufferInfo info) {
            ByteBuffer outputBuffer = codec.getOutputBuffer(index);
            
            if ((info.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
                // 配置數(shù)據(jù)，通常是SPS/PPS
                info.size = 0;
            }
            
            if (info.size > 0) {
                if (!muxerStarted) {
                    throw new RuntimeException("Muxer hasn't started");
                }
                
                // 調(diào)整ByteBuffer位置
                outputBuffer.position(info.offset);
                outputBuffer.limit(info.offset + info.size);
                
                // 寫入媒體數(shù)據(jù)
                muxer.writeSampleData(videoTrackIndex, outputBuffer, info);
            }
            
            // 釋放輸出緩沖區(qū)
            codec.releaseOutputBuffer(index, false);
            
            if ((info.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
                // 編碼完成
                handleEncodingComplete();
            }
        }
        
        @Override
        public void onError(MediaCodec codec, MediaCodec.CodecException e) {
            handleError(e);
        }
        
        @Override
        public void onOutputFormatChanged(MediaCodec codec, MediaFormat format) {
            if (muxerStarted) {
                throw new RuntimeException("Format changed twice");
            }
            
            // 添加軌道到muxer
            videoTrackIndex = muxer.addTrack(format);
            muxer.start();
            muxerStarted = true;
        }
    });
}

音頻編解碼

音頻解碼示例

public class AudioDecoder {
    private MediaCodec audioDecoder;
    private MediaExtractor extractor;
    
    public void initAudioDecoder(String filePath) {
        try {
            extractor = new MediaExtractor();
            extractor.setDataSource(filePath);
            
            // 找到音頻軌道
            int audioTrack = selectAudioTrack(extractor);
            if (audioTrack >= 0) {
                extractor.selectTrack(audioTrack);
                MediaFormat format = extractor.getTrackFormat(audioTrack);
                
                String mimeType = format.getString(MediaFormat.KEY_MIME);
                audioDecoder = MediaCodec.createDecoderByType(mimeType);
                audioDecoder.configure(format, null, null, 0);
                audioDecoder.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    private int selectAudioTrack(MediaExtractor extractor) {
        int trackCount = extractor.getTrackCount();
        for (int i = 0; i < trackCount; i++) {
            MediaFormat format = extractor.getTrackFormat(i);
            String mimeType = format.getString(MediaFormat.KEY_MIME);
            if (mimeType.startsWith("audio/")) {
                return i;
            }
        }
        return -1;
    }
}

音頻編碼示例

public void initAudioEncoder(int sampleRate, int channelCount, int bitRate) {
    try {
        MediaFormat format = MediaFormat.createAudioFormat(
            MediaFormat.MIMETYPE_AUDIO_AAC, sampleRate, channelCount);
        format.setInteger(MediaFormat.KEY_AAC_PROFILE, 
            MediaCodecInfo.CodecProfileLevel.AACObjectLC);
        format.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
        
        encoder = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_AUDIO_AAC);
        encoder.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
        encoder.start();
        
    } catch (IOException e) {
        e.printStackTrace();
    }
}

性能優(yōu)化策略

1. 緩沖區(qū)管理

// 合理設(shè)置緩沖區(qū)大小
private static final int BUFFER_SIZE = 64 * 1024; // 64KB

// 重用ByteBuffer避免頻繁分配
private ByteBuffer reusableBuffer = ByteBuffer.allocate(BUFFER_SIZE);

2. 線程優(yōu)化

// 使用專用線程處理編解碼
private HandlerThread codecThread;
private Handler codecHandler;

private void initCodecThread() {
    codecThread = new HandlerThread("CodecThread");
    codecThread.start();
    codecHandler = new Handler(codecThread.getLooper());
}

3. 內(nèi)存管理

// 及時釋放資源
private void releaseResources() {
    if (decoder != null) {
        decoder.stop();
        decoder.release();
        decoder = null;
    }
    
    if (surface != null) {
        surface.release();
        surface = null;
    }
}

錯誤處理與調(diào)試

常見錯誤類型

private void handleCodecError(MediaCodec.CodecException e) {
    if (e.isTransient()) {
        // 暫時性錯誤，可以重試
        Log.w(TAG, "Transient codec error", e);
        retryOperation();
    } else if (e.isRecoverable()) {
        // 可恢復(fù)錯誤，重新配置編解碼器
        Log.w(TAG, "Recoverable codec error", e);
        reconfigureCodec();
    } else {
        // 致命錯誤，需要完全重建
        Log.e(TAG, "Fatal codec error", e);
        recreateCodec();
    }
}

調(diào)試技巧

日志記錄：詳細記錄緩沖區(qū)狀態(tài)和時間戳
性能監(jiān)控：監(jiān)控幀率、碼率和延遲
內(nèi)存檢查：使用Profiler檢查內(nèi)存泄漏

最佳實踐

1. 選擇合適的編解碼器

// 檢查硬件編解碼器支持
private boolean isHardwareAccelerated(String codecName) {
    return !codecName.startsWith("OMX.google.");
}

// 優(yōu)先選擇硬件編解碼器
private MediaCodec createOptimalDecoder(String mimeType) {
    MediaCodecList codecList = new MediaCodecList(MediaCodecList.ALL_CODECS);
    for (MediaCodecInfo codecInfo : codecList.getCodecInfos()) {
        if (codecInfo.isEncoder()) continue;
        
        String[] types = codecInfo.getSupportedTypes();
        for (String type : types) {
            if (type.equals(mimeType) && isHardwareAccelerated(codecInfo.getName())) {
                try {
                    return MediaCodec.createByCodecName(codecInfo.getName());
                } catch (IOException e) {
                    continue;
                }
            }
        }
    }
    
    // 回退到默認編解碼器
    try {
        return MediaCodec.createDecoderByType(mimeType);
    } catch (IOException e) {
        return null;
    }
}

2. 配置參數(shù)優(yōu)化

private MediaFormat createOptimalVideoFormat(int width, int height, int bitRate) {
    MediaFormat format = MediaFormat.createVideoFormat(
        MediaFormat.MIMETYPE_VIDEO_AVC, width, height);
    
    // 設(shè)置關(guān)鍵參數(shù)
    format.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
    format.setInteger(MediaFormat.KEY_FRAME_RATE, 30);
    format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 2);
    
    // 設(shè)置編碼質(zhì)量
    format.setInteger(MediaFormat.KEY_BITRATE_MODE, 
        MediaCodecInfo.EncoderCapabilities.BITRATE_MODE_VBR);
    
    // 設(shè)置顏色格式
    format.setInteger(MediaFormat.KEY_COLOR_FORMAT, 
        MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
    
    return format;
}

3. 同步和時間戳管理

private long generatePresentationTime() {
    return System.nanoTime() / 1000; // 微秒時間戳
}

private void adjustTimestamp(MediaCodec.BufferInfo info, long baseTime) {
    info.presentationTimeUs = info.presentationTimeUs - baseTime;
}