NDK FFmpeg 音視訊解碼

作者：位元組流動

來源：

https://blog.csdn.net/Kennethdroid/article/details/86418725

封裝格式

我們經常所說的視訊格式，如 mp4 、 mkv 、 rmvb 、flv 等，表示的是音視訊的封裝格式，封裝格式實質上是把音頻資料、視訊資料和字幕資料打包成一個檔案的規範。從技術的角度來講，優秀的音視訊封裝格式應該支援大多數音視訊編碼标準。

主要的封裝格式:

名稱	機構	支援的視訊編碼	支援的音頻編碼	使用領域
AVI	微軟	幾乎所有格式		BT 下載下傳影視
MP4	MPEG	MPEG-4 ， H.264 ， H.263 等	AAC ， MPEG-1 等	網際網路視訊網站
FLV	Adobe	VP6 ， H.264	MP3 ， AAC 等
MKV	CoreCodec
RMVB	Real Networks	RealVideo 8 ， 9 ， 10	AAC ， Cook Codec

編碼格式

編碼的目的在于通過壓縮算法降低資料量，提高資料的存儲和傳輸效率。視訊編碼是将視訊像素資料（ RGB ， YUV 等）壓縮成為視訊碼流。音頻編碼是将音頻采樣資料（ PCM 等）壓縮成為音頻碼流。

主要視訊編碼格式：

		推出時間
H.265	MPEG/ITU-T	2013	研發中
H.264		2003	各個領域
MPEG4		2001	小衆
MPEG2		1994	數字電視
VP9	Google
VP8		2008

主要音頻編碼格式：

AAC		1997
AC-3	Dolby	1992	電影
MP3		1993	早期普及
WMV		1999	Windows

音視訊解碼流程

1. 解封裝格式。将輸入的按照一定格式封裝的音視訊資料，分離成為音頻流壓縮編碼資料和視訊流壓縮編碼資料。
2. 解碼。将視訊和音頻的壓縮編碼資料，解碼成為非壓縮的視訊和音頻原始資料。視訊壓縮資料通過解碼輸出為像素資料，如 YUV420P 、 RGB 等；音頻壓縮資料通過解碼輸出為非壓縮的音頻抽樣資料，如 PCM 資料。
3. 音視訊同步。同步解碼出來的視訊和音頻資料，并将音視訊資料送至系統的聲霸卡和顯示卡，播放和顯示出來。

FFmpeg 函數庫

FFmpeg 一般有 8 個函數庫，各個函數庫的功能如下：

函數庫	功能
avcodec	音視訊編解碼
avdevice	多媒體裝置輸入輸出
avfilter	濾鏡特效
avformat	封裝格式處理
postproc	後加工
avutil	工具庫
swresample	音頻采樣資料格式轉換
swscale	視訊像素資料格式轉換

FFmpeg 音視訊解碼

FFmpeg 音視訊解碼主要流程代碼描述：

1. av_register_all() //注冊元件
2. avformat_alloc_context //擷取封裝格式上下文
3. avformat_find_stream_info //擷取輸入檔案資訊
4. avcodec_find_decoder //擷取解碼器
5. avcodec_open2 //打開解碼器
6. avcodec_decode_video2 或 avcodec_decode_audio4 //解碼音視訊幀      

在 AS 工程中引入 FFmpeg 8 個動态庫和 libyuv （負責視訊像素資料格式轉換）動态庫。

工程的頭檔案目錄：

工程的動态庫目錄：

Java 層 API ：

package com.haohao.ffmpeg;

import android.media.AudioFormat;
import android.media.AudioManager;
import android.media.AudioTrack;
import android.util.Log;
import android.view.Surface;

/**
 * author: haohao
 * time: 2017/12/19
 * mail: [email protected]
 * desc: AVUtils
 */
public class AVUtils {
    private static final String TAG = "AVUtils";
    private static AVCallback AVCallback;
    private static AVCallback sAVCallback;
    public static void registerCallback(AVCallback callback) {
        sAVCallback = callback;
    }

    static {
        System.loadLibrary("avfilter-5");
        System.loadLibrary("avdevice-56");
        System.loadLibrary("yuv");
        System.loadLibrary("avutil-54");
        System.loadLibrary("swresample-1");
        System.loadLibrary("avcodec-56");
        System.loadLibrary("avformat-56");
        System.loadLibrary("swscale-3");
        System.loadLibrary("postproc-53");
        System.loadLibrary("native-lib");
    }
    /**
     * 解碼視訊中的視訊壓縮資料
     * @param input_file_path 輸入的視訊檔案路徑
     * @param output_file_path 視訊壓縮資料解碼後輸出的 YUV 檔案路徑
     */
    public static native void videoDecode(String input_file_path, String output_file_path);

    /**
     * 顯示視訊視訊解碼後像素資料
     * @param input 輸入的視訊檔案路徑
     * @param surface 用于顯示視訊視訊解碼後的 RGBA 像素資料
     */
    public static native void videoRender(String input, Surface surface);

    /**
     * 解碼視訊中的音頻壓縮資料
     * @param input 輸入的視訊檔案路徑
     * @param output 音頻壓縮資料解碼後輸出的 PCM 檔案路徑
     */
    public static native void audioDecode(String input, String output);

    /**
     * 播放視訊中的音頻資料
     * @param input 輸入的視訊檔案路徑
     */
    public static native void audioPlay(String input);

    /**
     * 建立一個 AudioTrack 對象，用于播放音頻,在 Native 層中調用。
     */
    public static AudioTrack createAudioTrack(int sampleRate, int num_channel) {
        int audioFormat = AudioFormat.ENCODING_PCM_16BIT;
        Log.i(TAG, "聲道數:" + num_channel);
        int channelConfig;
        if (num_channel == 1) {
            channelConfig = android.media.AudioFormat.CHANNEL_OUT_MONO;
        } else if (num_channel == 2) {
            channelConfig = android.media.AudioFormat.CHANNEL_OUT_STEREO;
        } else {
            channelConfig = android.media.AudioFormat.CHANNEL_OUT_STEREO;
        }

        int bufferSize = AudioTrack.getMinBufferSize(sampleRate, channelConfig, audioFormat);

        AudioTrack audioTrack = new AudioTrack(
                AudioManager.STREAM_MUSIC,
                sampleRate, channelConfig,
                audioFormat,
                bufferSize, AudioTrack.MODE_STREAM);
        return audioTrack;
    }

    public interface AVCallback {
        void onFinish();
    }
}
      

MySurfaceView.java

/**
 * author: haohao
 * time: 2017/12/20
 * mail: [email protected]
 * desc: MySurfaceView
 */
public class MySurfaceView extends SurfaceView {
    public MySurfaceView(Context context) {
        super(context);
    }

    public MySurfaceView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public MySurfaceView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    private void init(){
        // 設定像素繪制格式為 RGBA_8888
        SurfaceHolder holder = getHolder();
        holder.setFormat(PixelFormat.RGBA_8888);
    }
}      

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <com.haohao.ffmpeg.MySurfaceView
        android:id="@+id/my_surface_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="vertical">
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:alpha="0.7"
            android:orientation="horizontal">

            <Button
                android:id="@+id/video_decode_btn"
                android:layout_width="0dp"
                android:layout_weight="1"
                android:layout_height="wrap_content"
                android:text="視訊解碼" />

            <Button
                android:id="@+id/video_render_btn"
                android:layout_width="0dp"
                android:layout_weight="1"
                android:layout_height="wrap_content"
                android:text="視訊渲染" />

        </LinearLayout>
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:alpha="0.7"
            android:orientation="horizontal">

            <Button
                android:id="@+id/audio_decode_btn"
                android:layout_width="0dp"
                android:layout_weight="1"
                android:layout_height="wrap_content"
                android:text="音頻解碼" />

            <Button
                android:id="@+id/audio_play_btn"
                android:layout_width="0dp"
                android:layout_weight="1"
                android:layout_height="wrap_content"
                android:text="音頻播放" />

        </LinearLayout>
    </LinearLayout>
</FrameLayout>      

MainActivity.java

public class MainActivity extends AppCompatActivity implements View.OnClickListener, AVUtils.AVCallback {
    private static final String TAG = "MainActivity";
    private static final String BASE_PATH = Environment.getExternalStorageDirectory().getAbsolutePath() + File.separatorChar;

    private String input_video_file_path = BASE_PATH
            + "input.mp4";
    private String output_video_file_path = BASE_PATH
            + "output.yuv";
    private String input_audio_file_path = BASE_PATH
            + "hello.mp3";
    private String output_audio_file_path = BASE_PATH
            + "hello.pcm";
    private String video_src = BASE_PATH
            + "ffmpeg.mp4";
    private Button mDecodeVideoBtn;
    private Button mVideoRenderBtn;
    private Button mAudioPlayBtn, mAudioDecodeBtn;
    private ProgressDialog mProgressDialog;
    private ExecutorService mExecutorService;
    private MySurfaceView mySurfaceView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            requestPermissions(new String[]{Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.MOUNT_UNMOUNT_FILESYSTEMS}, 0);
        }

        mDecodeVideoBtn = (Button)findViewById(R.id.video_decode_btn);
        mVideoRenderBtn = (Button)findViewById(R.id.video_render_btn);
        mAudioDecodeBtn = (Button) findViewById(R.id.audio_decode_btn);
        mAudioPlayBtn = (Button)findViewById(R.id.audio_play_btn);

        mySurfaceView = (MySurfaceView) findViewById(R.id.my_surface_view);
        mDecodeVideoBtn.setOnClickListener(this);
        mVideoRenderBtn.setOnClickListener(this);
        mAudioDecodeBtn.setOnClickListener(this);
        mAudioPlayBtn.setOnClickListener(this);

        AVUtils.registerCallback(this);
        mProgressDialog = new ProgressDialog(this);
        mProgressDialog.setCanceledOnTouchOutside(false);
        mExecutorService = Executors.newFixedThreadPool(2);
    }

    @Override
    public void onClick(View view) {
        int id = view.getId();
        switch (id) {
            case R.id.video_decode_btn:
                mProgressDialog.setMessage("正在解碼...");
                mProgressDialog.show();
                mExecutorService.submit(new Runnable() {
                    @Override
                    public void run() {
                        AVUtils.videoDecode(input_video_file_path, output_video_file_path);
                    }
                });

                break;
            case R.id.video_render_btn:
                mExecutorService.submit(new Runnable() {
                    @Override
                    public void run() {
                        AVUtils.videoRender(input_video_file_path, mySurfaceView.getHolder().getSurface());
                    }
                });
                break;
            case R.id.audio_decode_btn:
                mProgressDialog.setMessage("正在解碼...");
                mProgressDialog.show();
                mExecutorService.submit(new Runnable() {
                    @Override
                    public void run() {
                        AVUtils.audioDecode(input_audio_file_path, output_audio_file_path);
                    }
                });
                break;
            case R.id.audio_play_btn:
                mExecutorService.submit(new Runnable() {
                    @Override
                    public void run() {
                        AVUtils.audioPlay(input_video_file_path);
                    }
                });
                break;
        }

    }

    @Override
    public void onFinish() {
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                if (mProgressDialog.isShowing()) {
                    mProgressDialog.dismiss();
                }
                Toast.makeText(MainActivity.this, "解碼完成", Toast.LENGTH_SHORT).show();
            }
        });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mExecutorService.shutdown();
    }
}
      

nativelib.c

#include <jni.h>
#include <string.h>
#include <android/log.h>
#include <stdio.h>
#include <libavutil/time.h>

//編碼
#include "include/libavcodec/avcodec.h"
//封裝格式處理
#include "include/libavformat/avformat.h"
//像素處理
#include "include/libswscale/swscale.h"

#define LOGI(FORMAT, ...) __android_log_print(ANDROID_LOG_INFO,"haohao",FORMAT,##__VA_ARGS__);
#define LOGE(FORMAT, ...) __android_log_print(ANDROID_LOG_ERROR,"haohao",FORMAT,##__VA_ARGS__);

//中文字元串轉換
jstring charsToUTF8String(JNIEnv *env, char *s) {
    jclass string_cls = (*env)->FindClass(env, "java/lang/String");
    jmethodID mid = (*env)->GetMethodID(env, string_cls, "<init>", "([BLjava/lang/String;)V");

    jbyteArray jb_arr = (*env)->NewByteArray(env, strlen(s));
    (*env)->SetByteArrayRegion(env, jb_arr, 0, strlen(s), s);

    jstring charset = (*env)->NewStringUTF(env, "UTF-8");

    return (*env)->NewObject(env, string_cls, mid, jb_arr, charset);
}

JNIEXPORT void JNICALL
Java_com_haohao_ffmpeg_AVUtils_videoDecode(JNIEnv *env, jclass type, jstring input_,
                                           jstring output_) {

    //通路靜态方法
    jmethodID mid = (*env)->GetStaticMethodID(env, type, "onNativeCallback", "()V");
    //需要轉碼的視訊檔案(輸入的視訊檔案)
    const char *input = (*env)->GetStringUTFChars(env, input_, 0);
    const char *output = (*env)->GetStringUTFChars(env, output_, 0);

    //注冊所有元件
    av_register_all();

    //封裝格式上下文，統領全局的結構體，儲存了視訊檔案封裝格式的相關資訊
    AVFormatContext *pFormatCtx = avformat_alloc_context();

    //打開輸入視訊檔案
    if (avformat_open_input(&pFormatCtx, input, NULL, NULL) != 0) {
        LOGE("%s", "無法打開輸入視訊檔案");
        return;
    }

    //擷取視訊檔案資訊，例如得到視訊的寬高
    if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {
        LOGE("%s", "無法擷取視訊檔案資訊");
        return;
    }

    //擷取視訊流的索引位置
    //周遊所有類型的流（音頻流、視訊流、字幕流），找到視訊流
    int v_stream_idx = -1;
    int i = 0;

    for (; i < pFormatCtx->nb_streams; i++) {
        //判斷視訊流
        if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
            v_stream_idx = i;
            break;
        }
    }

    if (v_stream_idx == -1) {
        LOGE("%s", "找不到視訊流\n");
        return;
    }

    //根據視訊的編碼方式，擷取對應的解碼器
    AVCodecContext *pCodecCtx = pFormatCtx->streams[v_stream_idx]->codec;

    //根據編解碼上下文中的編碼 id 查找對應的解碼器
    AVCodec *pCodec = avcodec_find_decoder(pCodecCtx->codec_id);

    if (pCodec == NULL) {
        LOGE("%s", "找不到解碼器，或者視訊已加密\n");
        return;
    }

    //打開解碼器，解碼器有問題（比如說我們編譯FFmpeg的時候沒有編譯對應類型的解碼器）
    if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0) {
        LOGE("%s", "解碼器無法打開\n");
        return;
    }

    //輸出視訊資訊
    LOGI("視訊的檔案格式：%s", pFormatCtx->iformat->name);
    LOGI("視訊時長：%lld", (pFormatCtx->duration) / (1000 * 1000));
    LOGI("視訊的寬高：%d,%d", pCodecCtx->width, pCodecCtx->height);
    LOGI("解碼器的名稱：%s", pCodec->name);

    //準備讀取
    //AVPacket用于存儲一幀一幀的壓縮資料（H264）
    //緩沖區，開辟空間
    AVPacket *packet = (AVPacket *) av_malloc(sizeof(AVPacket));

    //AVFrame用于存儲解碼後的像素資料(YUV)
    //記憶體配置設定
    AVFrame *pFrame = av_frame_alloc();
    //YUV420
    AVFrame *pFrameYUV = av_frame_alloc();
    //隻有指定了AVFrame的像素格式、畫面大小才能真正配置設定記憶體
    //緩沖區配置設定記憶體
    uint8_t *out_buffer = (uint8_t *) av_malloc(
            avpicture_get_size(AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height));
    //初始化緩沖區
    avpicture_fill((AVPicture *) pFrameYUV, out_buffer, AV_PIX_FMT_YUV420P, pCodecCtx->width,
                   pCodecCtx->height);

    //用于轉碼（縮放）的參數，轉之前的寬高，轉之後的寬高，格式等
    struct SwsContext *sws_ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height,
                                                pCodecCtx->pix_fmt,
                                                pCodecCtx->width, pCodecCtx->height,
                                                AV_PIX_FMT_YUV420P,
                                                SWS_BICUBIC, NULL, NULL, NULL);
    int got_picture, ret;

    //輸出檔案
    FILE *fp_yuv = fopen(output, "wb+");

    int frame_count = 0;

    //一幀一幀的讀取壓縮資料
    while (av_read_frame(pFormatCtx, packet) >= 0) {
        //隻要視訊壓縮資料（根據流的索引位置判斷）
        if (packet->stream_index == v_stream_idx) {
            //解碼一幀視訊壓縮資料，得到視訊像素資料
            ret = avcodec_decode_video2(pCodecCtx, pFrame, &got_picture, packet);
            if (ret < 0) {
                LOGE("%s", "解碼錯誤");
                return;
            }

            //為 0 說明解碼完成，非0正在解碼
            if (got_picture) {
                //AVFrame轉為像素格式YUV420，寬高
                //2 6輸入、輸出資料
                //3 7輸入、輸出畫面一行的資料的大小 AVFrame 轉換是一行一行轉換的
                //4 輸入資料第一列要轉碼的位置 從0開始
                //5 輸入畫面的高度
                sws_scale(sws_ctx, pFrame->data, pFrame->linesize, 0, pCodecCtx->height,
                          pFrameYUV->data, pFrameYUV->linesize);

                //輸出到YUV檔案
                //AVFrame像素幀寫入檔案
                //data解碼後的圖像像素資料（音頻采樣資料）
                //Y 亮度 UV 色度（壓縮了） 人對亮度更加敏感
                //U V 個數是Y的1/4
                int y_size = pCodecCtx->width * pCodecCtx->height;
                fwrite(pFrameYUV->data[0], 1, y_size, fp_yuv);
                fwrite(pFrameYUV->data[1], 1, y_size / 4, fp_yuv);
                fwrite(pFrameYUV->data[2], 1, y_size / 4, fp_yuv);

                frame_count++;
                LOGI("解碼第%d幀", frame_count);
            }
        }

        //釋放資源
        av_free_packet(packet);
    }

    fclose(fp_yuv);

    av_frame_free(&pFrame);

    avcodec_close(pCodecCtx);

    avformat_free_context(pFormatCtx);

    (*env)->ReleaseStringUTFChars(env, input_, input);
    (*env)->ReleaseStringUTFChars(env, output_, output);
    //通知 Java 層解碼完畢
    (*env)->CallStaticVoidMethod(env, type, mid);
}

//使用這兩個 Window 相關的頭檔案需要在 CMake 腳本中引入 android 庫
#include <android/native_window_jni.h>
#include <android/native_window.h>
#include "include/yuv/libyuv.h"

JNIEXPORT void JNICALL
Java_com_haohao_ffmpeg_AVUtils_videoRender(JNIEnv *env, jclass type, jstring input_,
                                           jobject surface) {
    //需要轉碼的視訊檔案(輸入的視訊檔案)
    const char *input = (*env)->GetStringUTFChars(env, input_, 0);

    //注冊所有元件
    av_register_all();
    //avcodec_register_all();

    //封裝格式上下文，統領全局的結構體，儲存了視訊檔案封裝格式的相關資訊
    AVFormatContext *pFormatCtx = avformat_alloc_context();

    //打開輸入視訊檔案
    if (avformat_open_input(&pFormatCtx, input, NULL, NULL) != 0) {
        LOGE("%s", "無法打開輸入視訊檔案");
        return;
    }

    //擷取視訊檔案資訊，例如得到視訊的寬高
    //第二個參數是一個字典，表示你需要擷取什麼資訊，比如視訊的中繼資料
    if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {
        LOGE("%s", "無法擷取視訊檔案資訊");
        return;
    }

    //擷取視訊流的索引位置
    //周遊所有類型的流（音頻流、視訊流、字幕流），找到視訊流
    int v_stream_idx = -1;
    int i = 0;
    //number of streams
    for (; i < pFormatCtx->nb_streams; i++) {
        //流的類型
        if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
            v_stream_idx = i;
            break;
        }
    }

    if (v_stream_idx == -1) {
        LOGE("%s", "找不到視訊流\n");
        return;
    }


    //擷取視訊流中的編解碼上下文
    AVCodecContext *pCodecCtx = pFormatCtx->streams[v_stream_idx]->codec;

    //根據編解碼上下文中的編碼 id 查找對應的解碼器
    AVCodec *pCodec = avcodec_find_decoder(pCodecCtx->codec_id);

    if (pCodec == NULL) {
        LOGE("%s", "找不到解碼器，或者視訊已加密\n");
        return;
    }

    //打開解碼器，解碼器有問題（比如說我們編譯FFmpeg的時候沒有編譯對應類型的解碼器）
    if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0) {
        LOGE("%s", "解碼器無法打開\n");
        return;
    }

    //準備讀取
    //AVPacket用于存儲一幀一幀的壓縮資料（H264）
    //緩沖區，開辟空間
    AVPacket *packet = (AVPacket *) av_malloc(sizeof(AVPacket));

    //AVFrame用于存儲解碼後的像素資料(YUV)
    //記憶體配置設定
    AVFrame *yuv_frame = av_frame_alloc();
    AVFrame *rgb_frame = av_frame_alloc();

    int got_picture, ret;
    int frame_count = 0;

    //窗體
    ANativeWindow *pWindow = ANativeWindow_fromSurface(env, surface);
    //繪制時的緩沖區
    ANativeWindow_Buffer out_buffer;

    //一幀一幀的讀取壓縮資料
    while (av_read_frame(pFormatCtx, packet) >= 0) {
        //隻要視訊壓縮資料（根據流的索引位置判斷）
        if (packet->stream_index == v_stream_idx) {
            //7.解碼一幀視訊壓縮資料，得到視訊像素資料
            ret = avcodec_decode_video2(pCodecCtx, yuv_frame, &got_picture, packet);
            if (ret < 0) {
                LOGE("%s", "解碼錯誤");
                return;
            }

            //為0說明解碼完成，非0正在解碼
            if (got_picture) {

                //lock window
                //設定緩沖區的屬性：寬高、像素格式（需要與Java層的格式一緻）
                ANativeWindow_setBuffersGeometry(pWindow, pCodecCtx->width, pCodecCtx->height,
                                                 WINDOW_FORMAT_RGBA_8888);
                ANativeWindow_lock(pWindow, &out_buffer, NULL);

                //初始化緩沖區
                //設定屬性，像素格式、寬高
                //rgb_frame的緩沖區就是Window的緩沖區，同一個，解鎖的時候就會進行繪制
                avpicture_fill((AVPicture *) rgb_frame, out_buffer.bits, AV_PIX_FMT_RGBA,
                               pCodecCtx->width,
                               pCodecCtx->height);

                //YUV格式的資料轉換成RGBA 8888格式的資料, FFmpeg 也可以轉換，但是存在問題，使用libyuv這個庫實作
                I420ToARGB(yuv_frame->data[0], yuv_frame->linesize[0],
                           yuv_frame->data[2], yuv_frame->linesize[2],
                           yuv_frame->data[1], yuv_frame->linesize[1],
                           rgb_frame->data[0], rgb_frame->linesize[0],
                           pCodecCtx->width, pCodecCtx->height);

                //3、unlock window
                ANativeWindow_unlockAndPost(pWindow);

                frame_count++;
                LOGI("解碼繪制第%d幀", frame_count);
            }
        }

        //釋放資源
        av_free_packet(packet);
    }

    av_frame_free(&yuv_frame);
    avcodec_close(pCodecCtx);
    avformat_free_context(pFormatCtx);
    (*env)->ReleaseStringUTFChars(env, input_, input);
}


#include "libswresample/swresample.h"

#define MAX_AUDIO_FRME_SIZE 48000 * 4

//音頻解碼（重采樣）
JNIEXPORT void JNICALL
Java_com_haohao_ffmpeg_AVUtils_audioDecode(JNIEnv *env, jclass type, jstring input_,
                                           jstring output_) {
    //通路靜态方法
    jmethodID mid = (*env)->GetStaticMethodID(env, type, "onNativeCallback", "()V");
    const char *input = (*env)->GetStringUTFChars(env, input_, 0);
    const char *output = (*env)->GetStringUTFChars(env, output_, 0);

    //注冊元件
    av_register_all();
    AVFormatContext *pFormatCtx = avformat_alloc_context();
    //打開音頻檔案
    if (avformat_open_input(&pFormatCtx, input, NULL, NULL) != 0) {
        LOGI("%s", "無法打開音頻檔案");
        return;
    }
    //擷取輸入檔案資訊
    if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {
        LOGI("%s", "無法擷取輸入檔案資訊");
        return;
    }
    //擷取音頻流索引位置
    int i = 0, audio_stream_idx = -1;
    for (; i < pFormatCtx->nb_streams; i++) {
        if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
            audio_stream_idx = i;
            break;
        }
    }

    //擷取解碼器
    AVCodecContext *codecCtx = pFormatCtx->streams[audio_stream_idx]->codec;
    AVCodec *codec = avcodec_find_decoder(codecCtx->codec_id);
    if (codec == NULL) {
        LOGI("%s", "無法擷取解碼器");
        return;
    }
    //打開解碼器
    if (avcodec_open2(codecCtx, codec, NULL) < 0) {
        LOGI("%s", "無法打開解碼器");
        return;
    }
    //壓縮資料
    AVPacket *packet = (AVPacket *) av_malloc(sizeof(AVPacket));
    //解壓縮資料
    AVFrame *frame = av_frame_alloc();
    //frame->16bit 44100 PCM 統一音頻采樣格式與采樣率
    SwrContext *swrCtx = swr_alloc();

    //重采樣設定參數
    //輸入的采樣格式
    enum AVSampleFormat in_sample_fmt = codecCtx->sample_fmt;
    //輸出采樣格式16bit PCM
    enum AVSampleFormat out_sample_fmt = AV_SAMPLE_FMT_S16;
    //輸入采樣率
    int in_sample_rate = codecCtx->sample_rate;
    //輸出采樣率
    int out_sample_rate = 44100;
    //擷取輸入的聲道布局
    //根據聲道個數擷取預設的聲道布局（2個聲道，預設立體聲stereo）
    //av_get_default_channel_layout(codecCtx->channels);
    uint64_t in_ch_layout = codecCtx->channel_layout;
    //輸出的聲道布局（立體聲）
    uint64_t out_ch_layout = AV_CH_LAYOUT_STEREO;

    swr_alloc_set_opts(swrCtx,
                       out_ch_layout, out_sample_fmt, out_sample_rate,
                       in_ch_layout, in_sample_fmt, in_sample_rate,
                       0, NULL);
    swr_init(swrCtx);

    //輸出的聲道個數
    int out_channel_nb = av_get_channel_layout_nb_channels(out_ch_layout);

    //重采樣設定參數

    //位寬16bit 采樣率 44100HZ 的 PCM 資料
    uint8_t *out_buffer = (uint8_t *) av_malloc(MAX_AUDIO_FRME_SIZE);

    FILE *fp_pcm = fopen(output, "wb");

    int got_frame = 0, index = 0, ret;
    //不斷讀取壓縮資料
    while (av_read_frame(pFormatCtx, packet) >= 0) {
        //解碼
        ret = avcodec_decode_audio4(codecCtx, frame, &got_frame, packet);

        if (ret < 0) {
            LOGI("%s", "解碼完成");
        }
        //解碼一幀成功
        if (got_frame > 0) {
            LOGI("解碼：%d", index++);
            swr_convert(swrCtx, &out_buffer, MAX_AUDIO_FRME_SIZE, frame->data, frame->nb_samples);
            //擷取sample的size
            int out_buffer_size = av_samples_get_buffer_size(NULL, out_channel_nb,
                                                             frame->nb_samples, out_sample_fmt, 1);
            fwrite(out_buffer, 1, out_buffer_size, fp_pcm);
        }

        av_free_packet(packet);
    }

    fclose(fp_pcm);
    av_frame_free(&frame);
    av_free(out_buffer);

    swr_free(&swrCtx);
    avcodec_close(codecCtx);
    avformat_close_input(&pFormatCtx);

    (*env)->ReleaseStringUTFChars(env, input_, input);
    (*env)->ReleaseStringUTFChars(env, output_, output);
    //通知 Java 層解碼完成
    (*env)->CallStaticVoidMethod(env, type, mid);
}

JNIEXPORT void JNICALL
Java_com_haohao_ffmpeg_AVUtils_audioPlay(JNIEnv *env, jclass type, jstring input_) {
    const char *input = (*env)->GetStringUTFChars(env, input_, 0);
    LOGI("%s", "sound");
    //注冊元件
    av_register_all();
    AVFormatContext *pFormatCtx = avformat_alloc_context();
    //打開音頻檔案
    if (avformat_open_input(&pFormatCtx, input, NULL, NULL) != 0) {
        LOGI("%s", "無法打開音頻檔案");
        return;
    }
    //擷取輸入檔案資訊
    if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {
        LOGI("%s", "無法擷取輸入檔案資訊");
        return;
    }
    //擷取音頻流索引位置
    int i = 0, audio_stream_idx = -1;
    for (; i < pFormatCtx->nb_streams; i++) {
        if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
            audio_stream_idx = i;
            break;
        }
    }

    //擷取解碼器
    AVCodecContext *codecCtx = pFormatCtx->streams[audio_stream_idx]->codec;
    AVCodec *codec = avcodec_find_decoder(codecCtx->codec_id);
    if (codec == NULL) {
        LOGI("%s", "無法擷取解碼器");
        return;
    }
    //打開解碼器
    if (avcodec_open2(codecCtx, codec, NULL) < 0) {
        LOGI("%s", "無法打開解碼器");
        return;
    }
    //壓縮資料
    AVPacket *packet = (AVPacket *) av_malloc(sizeof(AVPacket));
    //解壓縮資料
    AVFrame *frame = av_frame_alloc();
    //frame->16bit 44100 PCM 統一音頻采樣格式與采樣率
    SwrContext *swrCtx = swr_alloc();

    //輸入的采樣格式
    enum AVSampleFormat in_sample_fmt = codecCtx->sample_fmt;
    //輸出采樣格式16bit PCM
    enum AVSampleFormat out_sample_fmt = AV_SAMPLE_FMT_S16;
    //輸入采樣率
    int in_sample_rate = codecCtx->sample_rate;
    //輸出采樣率
    int out_sample_rate = in_sample_rate;
    //擷取輸入的聲道布局
    //根據聲道個數擷取預設的聲道布局（2個聲道，預設立體聲stereo）
    //av_get_default_channel_layout(codecCtx->channels);
    uint64_t in_ch_layout = codecCtx->channel_layout;
    //輸出的聲道布局（立體聲）
    uint64_t out_ch_layout = AV_CH_LAYOUT_STEREO;

    swr_alloc_set_opts(swrCtx,
                       out_ch_layout, out_sample_fmt, out_sample_rate,
                       in_ch_layout, in_sample_fmt, in_sample_rate,
                       0, NULL);
    swr_init(swrCtx);

    //輸出的聲道個數
    int out_channel_nb = av_get_channel_layout_nb_channels(out_ch_layout);
    //AudioTrack對象
    jmethodID create_audio_track_mid = (*env)->GetStaticMethodID(env, type, "createAudioTrack",
                                                                 "(II)Landroid/media/AudioTrack;");
    jobject audio_track = (*env)->CallStaticObjectMethod(env, type, create_audio_track_mid,
                                                         out_sample_rate, out_channel_nb);

    //調用AudioTrack.play方法
    jclass audio_track_class = (*env)->GetObjectClass(env, audio_track);
    jmethodID audio_track_play_mid = (*env)->GetMethodID(env, audio_track_class, "play", "()V");
    jmethodID audio_track_stop_mid = (*env)->GetMethodID(env, audio_track_class, "stop", "()V");
    (*env)->CallVoidMethod(env, audio_track, audio_track_play_mid);

    //AudioTrack.write
    jmethodID audio_track_write_mid = (*env)->GetMethodID(env, audio_track_class, "write",
                                                          "([BII)I");
    //16bit 44100 PCM 資料
    uint8_t *out_buffer = (uint8_t *) av_malloc(MAX_AUDIO_FRME_SIZE);

    int got_frame = 0, index = 0, ret;
    //不斷讀取壓縮資料
    while (av_read_frame(pFormatCtx, packet) >= 0) {
        //解碼音頻類型的Packet
        if (packet->stream_index == audio_stream_idx) {
            //解碼
            ret = avcodec_decode_audio4(codecCtx, frame, &got_frame, packet);

            if (ret < 0) {
                LOGI("%s", "解碼完成");
            }
            //解碼一幀成功
            if (got_frame > 0) {
                LOGI("解碼：%d", index++);
                swr_convert(swrCtx, &out_buffer, MAX_AUDIO_FRME_SIZE,
                            (const uint8_t **) frame->data, frame->nb_samples);
                //擷取sample的size
                int out_buffer_size = av_samples_get_buffer_size(NULL, out_channel_nb,
                                                                 frame->nb_samples, out_sample_fmt,
                                                                 1);

                //out_buffer緩沖區資料，轉成byte數組
                jbyteArray audio_sample_array = (*env)->NewByteArray(env, out_buffer_size);
                jbyte *sample_bytep = (*env)->GetByteArrayElements(env, audio_sample_array, NULL);
                //out_buffer的資料複制到sampe_bytep
                memcpy(sample_bytep, out_buffer, out_buffer_size);
                //同步
                (*env)->ReleaseByteArrayElements(env, audio_sample_array, sample_bytep, 0);

                //AudioTrack.write PCM資料
                (*env)->CallIntMethod(env, audio_track, audio_track_write_mid,
                                      audio_sample_array, 0, out_buffer_size);
                //釋放局部引用
                (*env)->DeleteLocalRef(env, audio_sample_array);
            }
        }
        av_free_packet(packet);
    }

    (*env)->CallVoidMethod(env, audio_track, audio_track_stop_mid);

    av_frame_free(&frame);
    av_free(out_buffer);

    swr_free(&swrCtx);
    avcodec_close(codecCtx);
    avformat_close_input(&pFormatCtx);

    (*env)->ReleaseStringUTFChars(env, input_, input);
}
      

CMakeLists.txt

cmake_minimum_required(VERSION 3.4.1)

include_directories(${CMAKE_SOURCE_DIR}/src/main/cpp/include)
set(jnilibs "${CMAKE_SOURCE_DIR}/src/main/jniLibs")
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${jnilibs}/${ANDROID_ABI})


add_library( # Sets the name of the library.
             native-lib

             # Sets the library as a shared library.
             SHARED

             # Provides a relative path to your source file(s).
             src/main/cpp/native-lib.c)

# 添加 FFmpeg 的 8 個函數庫和 yuvlib 庫
add_library(avutil-54 SHARED IMPORTED )
set_target_properties(avutil-54 PROPERTIES IMPORTED_LOCATION "${jnilibs}/${ANDROID_ABI}/libavutil-54.so")


add_library(swresample-1 SHARED IMPORTED )
set_target_properties(swresample-1 PROPERTIES IMPORTED_LOCATION "${jnilibs}/${ANDROID_ABI}/libswresample-1.so")


add_library(avcodec-56 SHARED IMPORTED )
set_target_properties(avcodec-56 PROPERTIES IMPORTED_LOCATION "${jnilibs}/${ANDROID_ABI}/libavcodec-56.so")


add_library(avformat-56 SHARED IMPORTED )
set_target_properties(avformat-56 PROPERTIES IMPORTED_LOCATION "${jnilibs}/${ANDROID_ABI}/libavformat-56.so")


add_library(swscale-3 SHARED IMPORTED )
set_target_properties(swscale-3 PROPERTIES IMPORTED_LOCATION "${jnilibs}/${ANDROID_ABI}/libswscale-3.so")


add_library(postproc-53 SHARED IMPORTED )
set_target_properties(postproc-53 PROPERTIES IMPORTED_LOCATION "${jnilibs}/${ANDROID_ABI}/libpostproc-53.so")


add_library(avfilter-5 SHARED IMPORTED )
set_target_properties(avfilter-5 PROPERTIES IMPORTED_LOCATION "${jnilibs}/${ANDROID_ABI}/libavfilter-5.so")


add_library(avdevice-56 SHARED IMPORTED )
set_target_properties(avdevice-56 PROPERTIES IMPORTED_LOCATION "${jnilibs}/${ANDROID_ABI}/libavdevice-56.so")


add_library(yuv SHARED IMPORTED )
set_target_properties(yuv PROPERTIES IMPORTED_LOCATION "${jnilibs}/${ANDROID_ABI}/libyuv.so")


find_library( # Sets the name of the path variable.
              log-lib

              # Specifies the name of the NDK library that
              # you want CMake to locate.
              log )


#找到 Android 系統 Window 繪制相關的庫
find_library(
            android-lib
            android
            )


target_link_libraries( native-lib 
                       ${log-lib} 
                       ${android-lib} 
                       avutil-54 
                       swresample-1
                       avcodec-56
                       avformat-56
                       swscale-3
                       postproc-53
                       avfilter-5
                       avdevice-56
                       yuv)      

PS：

1. 注意添加檔案讀寫權限。
2. 關注公衆号

   位元組流動

   ，并在背景回複

   ffmpeglib

   擷取相應的函數庫。

參考文章

雷霄骅部落格 http://blog.csdn.net/leixiaohua1020/article/details/15811977

Jason 的 NDK 開發進階教程

部落格 NDK 開發系列文章：

• NDK 編譯的三種方式
• NDK 開發中引入第三方靜态庫和動态庫
• NDK 開發中 Native 與 Java 互動
• NDK POSIX 多線程程式設計
• NDK Android OpenSL ES 音頻采集與播放
• NDK FFmpeg 編譯
• NDK FFmpeg 音視訊解碼
• NDK 直播流媒體伺服器搭建
• NDK 直播推流與引流
• NDK 開發中快速定位 Crash 問題

「視訊雲技術」你最值得關注的音視訊技術公衆号，每周推送來自阿裡雲一線的實踐技術文章，在這裡與音視訊領域一流工程師交流切磋。