• Android NDK 实现视音频播放器源码

    目录：

    • CMake配置环境项目，gradle代码块：

    • 项目流程图：

    • ffmpeg解封装解码流程API概况：

    • activity_main.xml:

    • 搭建C++上层：

    • Java层MainActivity(上层):

    • 完成Native函数实现（JNI函数）:

    • C++实现文件：

    • C++头文件：

    CMake配置环境项目，gradle代码块：

    1. android {
    2.     compileSdkVersion 30
    3.     buildToolsVersion "30.0.3"
    4.     defaultConfig {
    5.         applicationId "cn.itcast.newproject"
    6.         minSdkVersion 17
    7.         targetSdkVersion 28
    8.         externalNativeBuild{
    9.             cmake{
    10.                 cppFlags ""
    11.                 abiFilters "armeabi-v7a"    //给出CMakeLists.txt指定编译此平台
    12.             }
    13.         }
    14.         ndk{
    15.             abiFilters("armeabi-v7a")   //apk/lib/libnative-lib.so指定编译的是此平台
    16.         }
    17.         versionCode 1
    18.         versionName "1.0"
    19.         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    20.     }
    21.     buildTypes {
    22.         release {
    23.             minifyEnabled false
    24.             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
    25.         }
    26.     }
    27. }

    手写FFmpeg && rtmp(导入别人的也行)：

     

    CMakeLists.txt:

    1. cmake_minimum_required(VERSION 3.6.4111459)
    2.  
    3. set(FFMPEG ${CMAKE_SOURCE_DIR}/ffmpeg)      ##拿到ffmpeg的路径
    4. set(RTMP ${CMAKE_SOURCE_DIR}/rtmp)      ##拿到rtmp的路径
    5.  
    6. include_directories(${FFMPEG}/include)      ##导入ffmpeg的头文件
    7.  
    8. set(CMAKE_CXX_FLAGS  "${CMAKE_CXX_FLAGS} -L${FFMPEG}/libs/${CMAKE_ANDROID_ARCH_ABI}")   ##导入ffmpeg库指定
    9.  
    10. set(CMAKE_CXX_FLAGS  "${CMAKE_CXX_FLAGS} -L${RTMP}/libs/${CMAKE_ANDROID_ARCH_ABI}") # rtmp库指定
    11.  
    12. ##批量导入 源文件
    13. file(GLOB src_files *.cpp)
    14.  
    15. add_library(
    16.         native-lib # 总库libnative-lib.so
    17.         SHARED # 动态库
    18.         ${src_files})
    19.  
    20. target_link_libraries( 
    21.         native-lib # 总库libnative-lib.so
    22.  
    23.         ##忽略顺序的方式，导入
    24.         -Wl,--start-group
    25.         avcodec avfilter avformat avutil swresample swscale
    26.         -Wl,--end-group
    27.  
    28.         log # 日志库，打印日志用的
    29.         z # libz.so库，是FFmpeg需要用ndk的z库，FFMpeg需要额外支持  libz.so
    30.         rtmp # rtmp 后面会专门介绍
    31.         android # android 后面会专门介绍，目前先要明白的是 ANativeWindow 用来渲染画面的
    32.         OpenSLES # OpenSLES 后面会专门介绍，目前先要明白的是 OpenSLES 用来播放声音的
    33. )

    熟悉一下之前的编码流程

    项目流程图：

    ffmpeg解封装解码流程API概况： 

    activity_main.xml: 

    2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 	
    3. 	xmlns:tools="http://schemas.android.com/tools" 
    4. 	android:layout_width="match_parent"
    5. 	android:layout_height="match_parent" 
    6. 	android:orientation="vertical" 
    7. 	tools:context=".MainActivity">
    8.  
    9. <SurfaceView
    10. 	android:id="@+id/surfaceView" 
    11. 	android:layout_width="match_parent" 
    12. 	android:layout_height="200dp" />
    13.  
    14. <LinearLayout
    15. 	android:layout_width="match_parent" 
    16. 	android:layout_height="30dp" 
    17. 	android:layout_margin="5dp">
    18.  
    19. <TextView
    20. 	android:id="@+id/tv_time" 
    21. 	android:layout_width="wrap_content" 
    22. 	android:layout_height="match_parent" 
    23. 	android:gravity="center" 
    24. 	android:text="00:00/00:00" 
    25. 	android:visibility="gone" />
    26.  
    27. <SeekBar
    28. 	android:id="@+id/seekBar" 
    29. 	android:layout_width="0dp" 
    30. 	android:layout_height="match_parent" 
    31. 	android:layout_weight="1" 
    32. 	android:max="100" 
    33. 	android:visibility="gone" />
    34. LinearLayout>
    35.  
    36.  
    37. LinearLayout>
    android视频播放简单实现示例（VideoView&MediaPlayer）
    pdf 0星 超过10%的资源 343KB
    下载

    搭建C++上层：

    思路在注释上

    1. package cn.itcast.newproject;
    2.  
    3. public class PlayerClass {
    4.  
    5.     static {
    6.         System.loadLibrary("native-lib");
    7.     }
    8.  
    9.     //第一步先声明接口
    10.     //下层工作完上层要有接口，准备成功的接口，会去告诉上层
    11.     //接口是给Java层的main用的
    12.     private OnPreparedListener onPreparedListener;
    13.     public PlayerClass() {
    14.     }
    15.  
    16.     // 第二步
    17.     // 设置媒体源（文件路径++++直播地址rtmp）
    18.     // sdk卡本地有MP4文件
    19.     //声明meidiePlay dataSource
    20.     private String dataSource;
    21.     public void setDataSource(String dataSource) {
    22.         this.dataSource = dataSource;
    23.     }
    24.  
    25.     //第三步
    26.     // 播放器准备播放，因为解封装格式不一定成功，一定要打开测试一下
    27.     //成功后再调用接口
    28.     public void prepare() {
    29.         //传参媒体源
    30.         prepareNative(dataSource);
    31.     }
    32.  
    33.     //第四步
    34.     // 开始播放
    35.     public void start() {
    36.         startNative(); }
    37.  
    38.     //第五步
    39.     // 停止播放
    40.     public void stop() {
    41.         stopNative(); }
    42.  
    43.     //第六步
    44.     //程序关闭时，释放资源
    45.     public void release() {
    46.         releaseNative(); }
    47.  
    48.  
    49.     //给JNI反射调用的
    50.     //Native层为C++下层，提供函数给上层Java层调用
    51.     public void onPrepared() {
    52.         //判空，不为空就回调
    53.         if (onPreparedListener != null) {
    54.             onPreparedListener.onPrepared();
    55.         }
    56.     }
    57.  
    58.     //设置准备成功的监听
    59.     public void setOnPreparedListener(OnPreparedListener onPreparedListener) {
    60.         this.onPreparedListener = onPreparedListener; }
    61.  
    62.     //准备成功的监听
    63.     public interface OnPreparedListener {
    64.         void onPrepared();}
    65.  
    66.     //Native函数实现区域
    67.     //使用软编解码，硬编解码的调参数太烦了就不用了
    68.     private native void prepareNative(String dataSource);
    69.     private native void startNative();
    70.     private native void stopNative();
    71.     private native void releaseNative();
    72. }
    73.

    Java层MainActivity(上层): 

    1. package cn.itcast.newproject;
    2.  
    3. import androidx.appcompat.app.AppCompatActivity;
    4.  
    5. import android.os.Bundle;
    6. import android.os.Environment;
    7. import android.view.WindowManager;
    8. import android.widget.Toast;
    9.  
    10. import java.io.File;
    11.  
    12. public class MainActivity extends AppCompatActivity {
    13.  
    14.     private PlayerClass player;
    15.     @Override
    16.     protected void onCreate(Bundle savedInstanceState) {
    17.         super.onCreate(savedInstanceState);
    18.         getWindow().setFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON, WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
    19.         setContentView(R.layout.activity_main);
    20.  
    21.         //创建类
    22.         player = new PlayerClass();
    23.         player.setDataSource(
    24.                 new File(Environment.getExternalStorageDirectory() + File.separator + "demo.mp4")
    25.                         .getAbsolutePath());
    26.         // 准备成功的回调处
    27.         // 被C++调用 可能会是子线程调用的
    28.         player.setOnPreparedListener(new PlayerClass.OnPreparedListener() {
    29.             @Override
    30.             public void onPrepared() {
    31.                 runOnUiThread(new Runnable() {
    32.                     @Override
    33.                     public void run() {
    34.                         Toast.makeText(MainActivity.this, "准备完成，即将开始播放", Toast.LENGTH_SHORT).show();
    35.                     }
    36.                 });
    37.                 //准备成功，调用 C++ 开始播放
    38.                 player.start();
    39.             }
    40.         });
    41.     }
    42.     @Override // ActivityThread.java Handler
    43.     protected void onResume() {     // 触发准备
    44.         super.onResume();
    45.         //保证一触发就传到C++层
    46.         //C++如果是准备成功就返回成功信息，回到runOnUiThread函数打印
    47.         //再调用Play.start()，最后再调回C++
    48.         player.prepare();
    49.     }
    50.  
    51.     @Override
    52.     protected void onStop() {
    53.         super.onStop();
    54.         player.stop();
    55.     }
    56.  
    57.     //Activity关闭的时候释放资源，爱放不放
    58.     @Override
    59.     protected void onDestroy() {
    60.         super.onDestroy();
    61.         player.release();
    62.     }
    63.  
    64. }
    65.

    完成Native函数实现（JNI函数）: 

    1. #include 
    2. #include 
    3. #include "DerryPlayer.h"
    4. #include "JNICallbakcHelper.h"
    5.  
    6. extern "C"{
    7.     #include 
    8. }
    9.  
    10. extern "C" JNIEXPORT jstring JNICALL
    11. Java_com_derry_player_MainActivity_getFFmpegVersion(
    12.         JNIEnv *env,
    13.         jobject /* this */) {
    14.     std::string info = "FFmpeg的版本号是:";
    15.     info.append(av_version_info());
    16.     return env->NewStringUTF(info.c_str());
    17. }
    18.  
    19. DerryPlayer *player = 0;
    20. JavaVM *vm = 0;
    21. jint JNI_OnLoad(JavaVM * vm, void * args) {
    22.     ::vm = vm;
    23.     return JNI_VERSION_1_6;
    24. }
    25.  
    26. //prepareNative
    27. extern "C"
    28. JNIEXPORT void JNICALL
    29. Java_com_derry_player_DerryPlayer_prepareNative(JNIEnv *env, jobject job, jstring data_source) {
    30.     const char * data_source_ = env->GetStringUTFChars(data_source, 0);
    31.     auto *helper = new JNICallbakcHelper(vm, env, job); // C++子线程回调 ， C++主线程回调
    32.     player = new DerryPlayer(data_source_, helper);
    33.     player->prepare();
    34.     env->ReleaseStringUTFChars(data_source, data_source_);
    35. }
    36.  
    37. //startNative
    38. extern "C"
    39. JNIEXPORT void JNICALL
    40. Java_com_derry_player_DerryPlayer_startNative(JNIEnv *env, jobject thiz) {
    41.     if (player) {
    42.         // player.start();
    43.     }
    44. }
    45.  
    46. //stopNative
    47. extern "C"
    48. JNIEXPORT void JNICALL
    49. Java_com_derry_player_DerryPlayer_stopNative(JNIEnv *env, jobject thiz) {
    50. }
    51.  
    52. //releaseNative
    53. extern "C"
    54. JNIEXPORT void JNICALL
    55. Java_com_derry_player_DerryPlayer_releaseNative(JNIEnv *env, jobject thiz) {
    56. }

    C++实现文件： 

    1. #include "DerryPlayer.h"
    2.  
    3. DerryPlayer::PlayerClass(const char *data_source, JNICallbakcHelper *helper) {
    4.     // this->data_source = data_source;
    5.     // 如果一旦被释放，会一定造成悬空指针
    6.  
    7.     // 记得复习深拷贝
    8.     // this->data_source = new char[strlen(data_source)];
    9.     // Java: demo.mp4
    10.     // C层：demo.mp4\0  C层会自动 + \0,  strlen不计算\0的长度，需要手动加 \0
    11.  
    12.     this->data_source = new char[strlen(data_source) + 1];
    13.     strcpy(this->data_source, data_source); // 把源 Copy给成员
    14.  
    15.     this->helper = helper;
    16. }
    17.  
    18. PlayerClass::~PlayerClass() {
    19.     if (data_source) {
    20.         delete data_source;
    21.     }
    22.  
    23.     if (helper) {
    24.         delete helper;
    25.     }
    26. }
    27.  
    28. void *task_prepare(void *args) { 
    29.     // 此函数和PlayerClass这个对象没有关系，不能用PlayerClass的私有成员
    30.  
    31.     // avformat_open_input(0, this->data_source)
    32.  
    33.     auto *player = static_cast(args);
    34.     player->prepare_();
    35.  
    36.     return 0; // 必须返回，坑，错误很难找
    37. }
    38.  
    39. void PlayerClass::prepare_() { // 此函数 是 子线程
    40.     /**
    41.      * TODO 第一步：打开媒体地址（文件路径， 直播地址rtmp）
    42.      */
    43.     formatContext = avformat_alloc_context();
    44.  
    45.     AVDictionary *dictionary = 0;
    46.     av_dict_set(&dictionary, "timeout", "5000000", 0); // 单位微妙
    47.  
    48.  
    49. //AVFormatContext *
    50. //路径
    51. //AVInputFormat *fmt  Mac、Windows 摄像头、麦克风，用不到不写，也不想写
    52. //Http 连接超时， 打开rtmp的超时  AVDictionary **options
    53.  
    54.     int r = avformat_open_input(&formatContext, data_source, 0, &dictionary);
    55.  
    56.     // 释放字典
    57.     av_dict_free(&dictionary);
    58.  
    59.     if (r) {
    60.         // 把错误信息反馈给Java，回调给Java  Toast——打开媒体格式失败，请检查代码
    61.         //实现 JNI 反射回调到Java方法，并提示
    62.         return;
    63.     }
    64.  
    65.         //第二步：查找媒体中的音视频流的信息
    66.  
    67.     r = avformat_find_stream_info(formatContext, 0);
    68.     if (r < 0) {
    69.         // 这里实现 JNI 反射回调到Java方法
    70.         return;
    71.     }
    72.  
    73.         //根据流信息，流的个数，用循环来找
    74.  
    75.     for (int i = 0; i < formatContext->nb_streams; ++i) {
    76.  
    77.         //获取媒体流（视频，音频）
    78.         AVStream *stream = formatContext->streams[i];
    79.  
    80.  
    81.         // 第五步：从上面的流中 获取 编码解码的【参数】
    82.         //由于：后面的编码器 解码器 都需要参数（宽高 等等）
    83.  
    84.         AVCodecParameters *parameters = stream->codecpar;
    85.  
    86.  
    87.         //第六步：（根据上面的【参数】）获取编解码器
    88.         AVCodec *codec = avcodec_find_decoder(parameters->codec_id);
    89.  
    90.  
    91.         //第七步：编解码器 上下文 
    92.  
    93.         AVCodecContext *codecContext = avcodec_alloc_context3(codec);
    94.         if (!codecContext) {
    95.             // 实现 JNI 反射回调到Java方法，并提示
    96.             return;
    97.         }
    98.  
    99.         //第八步：空白parameters copy codecContext）
    100.  
    101.         r = avcodec_parameters_to_context(codecContext, parameters);
    102.         if (r < 0) {
    103.             // 实现JNI 反射回调到Java方法，并提示
    104.             return;
    105.         }
    106.  
    107.  
    108.         //第九步：打开解码器
    109.  
    110.         r = avcodec_open2(codecContext, codec, 0);
    111.         if (r) { // 非0就是true
    112.             // 实现JNI 反射回调到Java方法，并提示
    113.             return;
    114.         }
    115.  
    116.  
    117.         //第十步：从编解码器参数中，获取流的类型 codec_type  ===  音频 视频
    118.  
    119.         if (parameters->codec_type == AVMediaType::AVMEDIA_TYPE_AUDIO) { // 音频
    120.             audio_channel = new AudioChannel();
    121.         } else if (parameters->codec_type == AVMediaType::AVMEDIA_TYPE_VIDEO) { // 视频
    122.             video_channel = new VideoChannel();
    123.         }
    124.     } // for end
    125.  
    126.     /**
    127.     //第十一步: 如果流中 没有音频 也没有 视频 健壮性校验
    128.      */
    129.     if (!audio_channel && !video_channel) {
    130.         // 实现JNI 反射回调到Java方法，并提示
    131.         return;
    132.     }
    133.  
    134.     //第十二步：媒体文件可以了，通知给上层
    135.     if (helper) {
    136.         helper->onPrepared(THREAD_CHILD);
    137.     }
    138. }
    139.  
    140. void DerryPlayer::prepare() {
    141.     // 最后创建子线程
    142.     pthread_create(&pid_prepare, 0, task_prepare, this);
    143. }

    C++头文件： 

    1. #ifndef PLAYERCLASS_PLAYERCLASS_H
    2. #define PLAYERCLASS_PLAYERCLASS_H
    3.  
    4. #include 
    5. #include 
    6. #include "AudioChannel.h"
    7. #include "VideoChannel.h"
    8. #include "JNICallbakcHelper.h"
    9. #include "util.h"
    10.  
    11. extern "C" {//FFmpeg需要用C编译
    12.     #include 
    13. };
    14.  
    15. class DerryPlayer {
    16.  
    17. private:
    18.     char *data_source = 0; // 指针
    19.     pthread_t pid_prepare;
    20.     AVFormatContext *formatContext = 0;
    21.     AudioChannel *audio_channel = 0;
    22.     VideoChannel *video_channel = 0;
    23.     JNICallbakcHelper *helper = 0;
    24.  
    25. public:
    26.     PlayerClass(const char *data_source, JNICallbakcHelper *helper);
    27.     ~PlayerClass();
    28.  
    29.     void prepare();
    30.     void prepare_();
    31. };
    32.  
    33.  
    34. #endif //PLAYERCLASS_PLAYERCLASS_H
    35.

    原文链接：Android NDK 实现视音频播放器源码 - 资料 - 我爱音视频网 - 构建全国最权威的音视频技术交流分享论坛

    本文福利， C++音视频学习资料包、技术视频，内容包括（音视频开发，面试题，FFmpeg ，webRTC ，rtmp ，hls ，rtsp ，ffplay ，srs）↓↓↓↓↓↓见下面↓↓私信或文章底部领取↓↓

  • 相关阅读:
    纯后端如何写前端？我用了低代码平台
    【Nacos】spring cloud （feign）+ Nacos 负载均衡实现
    react原理篇:setState()方法说明
    【Python机器学习】回归模型：推土机售价预测
    第三届机器学习、云计算与智能挖掘国际会议（MLCCIM 2024）
    CHATGPT----自然辩证法分析
    【Python】通过 Python 设置电脑代理端口
    揭秘分布式文件系统大规模元数据管理机制——以Alluxio文件系统为例
    stm32---用外部中断实现红外接收器
    安卓的ATV系统
  • 原文地址：https://blog.csdn.net/m0_60259116/article/details/126015218