21.Eclipse下Ndk开发_项目结构重构(ffmpeg播放视频 播放音频)

简介: 详细开发过程可以参考(10.Eclipse下Ndk开发(ffmpeg播放视频 播放音频))这里只贴出重构后的代码,注释写的很详细#include "com_example_ndk_ffmpeg_FFmpegUtils.

详细开发过程可以参考(10.Eclipse下Ndk开发(ffmpeg播放视频 播放音频))
这里只贴出重构后的代码,注释写的很详细

#include "com_example_ndk_ffmpeg_FFmpegUtils.h"

#include <stdlib.h>
#include <stdio.h>
//usleep需要
#include <unistd.h>
#include <android/log.h>
//Surface相关
#include <android/native_window_jni.h>
#include <android/native_window.h>

#include<pthread.h>

//被引入的libyuv中有C++代码编写,在这里需要设置为用C来编译

#include "include/libyuv/libyuv.h"


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

#define MAX_AUDIO_FRME_SIZE 48000 * 4

//封装格式
#include "include/ffmpeg/libavformat/avformat.h"
//解码
#include "include/ffmpeg/libavcodec/avcodec.h"
//缩放
#include "include/ffmpeg/libswscale/swscale.h"
//重采样
#include "libswresample/swresample.h"

//nb_streams,视频文件中存在,音频流,视频流,字幕
#define MAX_STREAM 2
//音频重采样缓冲区大小
#define MAX_AUDIO_FRME_SIZE 48000 * 4

struct Player{
    //java虚拟机对象
    JavaVM *javaVM;

    //封装格式上下文
    AVFormatContext *avFormatCtx;
    //音频流视频流索引位置
    int video_stream_index;
    int audio_stream_index;
    //解码器上下文数组
    AVCodecContext *avCodecCtx[MAX_STREAM];
    //解码线程id
    pthread_t decode_threads[MAX_STREAM];
    //窗体绘制
    ANativeWindow* nativeWindow;

    SwrContext *swrCtx;
    //输入的采样格式
    enum AVSampleFormat in_sample_fmt;
    //输出采样格式16bit PCM
    enum AVSampleFormat out_sample_fmt;
    //输入采样率
    int in_sample_rate;
    //输出采样率
    int out_sample_rate;
    //输出的声道个数
    int out_channel_nb;

    //JNI
    jobject audio_track;
    jmethodID audio_track_write_mid;
};

/**
 * 初始化封装格式上下文,获取音频视频流的索引位置
 */
void init_input_format_ctx(struct Player *player,const char* input_cstr ){
    //1.注册所有组件
    av_register_all();

    //封装格式上下文,统领全局的结构体,保存了视频文件封装格式的相关信息
    AVFormatContext *avFormatCtx = avformat_alloc_context();

    //2.打开输入视频文件(AVFormatContext **ps, const char *url, AVInputFormat *fmt, AVDictionary **options)
    if(avformat_open_input(&avFormatCtx,input_cstr,NULL,NULL)!=0){
        LOGE("%s","无法打开输入视频文件");
        return;
    }

    //3.获取视频信息(AVFormatContext *ic, AVDictionary **options)
    if(avformat_find_stream_info(avFormatCtx,NULL)<0){
        LOGE("%s","无法获取视频文件信息");
        return;
    }
    //4.获取音频和视频流的索引位置
    int i;
    for(i = 0; i <avFormatCtx->nb_streams; i++){
        //视频
        if(avFormatCtx->streams[i]->codec->codec_type ==AVMEDIA_TYPE_VIDEO ){
            player->video_stream_index = i;
        }
        //音频
        if(avFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO){
            player->audio_stream_index = i;
        }
    }
    //5.将得到的上下文保存在结构体中
    player->avFormatCtx = avFormatCtx;
}

/**
 * 初始化解码器上下文
 *
 * stream_index:音频或者视频的index,获取对应的解码器
 */
void init_codec_context(struct Player *player,int stream_index){
    AVFormatContext *avFormatCtx = player->avFormatCtx;

    //从视频流或音频流中获取对应的解码器上下文
    AVCodecContext *avCodecCtx = avFormatCtx->streams[stream_index]->codec;
    //根据编解码器id信息查找对应的解码器
    AVCodec *avCodec = avcodec_find_decoder(avCodecCtx->codec_id);

    if (avCodec == NULL){
        LOGE("%s","找不到解码器\n");
        return;
    }

    //打开解码器
    if (avcodec_open2(avCodecCtx,avCodec,NULL)<0){
        LOGE("%s","解码器无法打开\n");
        return;
    }

    //将获取到的解码器上下文保存在结构体中,这个解码器包括音频和视频
    player->avCodecCtx[stream_index] = avCodecCtx;
}

//子线程解码
void decode_data(void* arg){
    struct Player *player = (struct Player*)arg;
    AVFormatContext *avFormatCtx = player->avFormatCtx;

    //开辟缓冲区AVPacket用于存储一帧一帧的压缩数据(H264)
    AVPacket *avPacket =(AVPacket*)av_mallocz(sizeof(AVPacket));

    int frame_count = 0;

    //每次读取一帧,存入avPacket
    while(av_read_frame(avFormatCtx,avPacket)>=0){
        if(avPacket->stream_index == player->video_stream_index){
            //解码视频
            //decode_video(player,avPacket);
            LOGI("video_frame_count:%d",frame_count++);
        }else if(avPacket->stream_index==player->audio_stream_index){
            //解码音频,这里曾经出现了一个小问题,我在测试解码音频的时候,将解码视频的子线程注释了,然而在这里这个位置
            //上边的decode_video方法没有注释,导致播放的时候,视频也同时进行了播放,并且由于音频和视频在同一个线程中解码,导致
            //音频和视频都有一定程度的卡顿现象,目前达到的效果只是分别开启线程播放视频或者单独播放音频,音视频同步尚未尝试
            decode_audio(player,avPacket);
            LOGI("audio_frame_count:%d",frame_count++);
        }
        //读取完一次释放一次
        av_free_packet(avPacket);
    }
    LOGI("解码完成");

}

/**
 * 解码音频准备
 */
void decode_audio_prepare(struct Player *player){

    AVCodecContext *avCodecCtx = player->avCodecCtx[player->audio_stream_index];

    /**********  重采样设置参数---start   *****/

    //输入的采样格式
    enum AVSampleFormat in_sample_fmt = avCodecCtx->sample_fmt;
    //输出的采样格式16bit PCM
    enum AVSampleFormat out_sample_fmt = AV_SAMPLE_FMT_S16;
    //输入采样率
    int in_sample_rate = avCodecCtx->sample_rate;
    //输出的采样率设置为和输入相同
    int out_sample_rate = in_sample_rate;
    //输入的声道布局
    uint64_t in_ch_layout = avCodecCtx->channel_layout;
    //输出的声道布局(立体声,也可以设置为和输入相同)
    uint64_t out_ch_layout = AV_CH_LAYOUT_STEREO;
    //输出的声道个数,从输出的声道布局中获取
    int out_channel_nb = av_get_channel_layout_nb_channels(out_ch_layout);
    //frame->16bit 44100 PCM 统一音频采样格式与采样率
    SwrContext *swrCtx = swr_alloc();
    /**
     * struct SwrContext *swr_alloc_set_opts(struct SwrContext *s,
     *        int64_t out_ch_layout, enum AVSampleFormat out_sample_fmt, int out_sample_rate,
     *        int64_t  in_ch_layout, enum AVSampleFormat  in_sample_fmt, int  in_sample_rate,
     *        int log_offset, void *log_ctx);
     */
    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);

    /**********  重采样设置参数---end   *****/

    //保存参数到结构体中
    player->in_sample_fmt = in_sample_fmt;
    player->out_sample_fmt = out_sample_fmt;
    player->in_sample_rate = in_sample_rate;
    player->out_sample_rate = out_sample_rate;
    player->out_channel_nb = out_channel_nb;
    player->swrCtx = swrCtx;
}

void jni_audio_prepare(JNIEnv *env,jobject jthiz,struct Player *player){
    //获取播放器工具类class
    jclass player_class = (*env)->GetObjectClass(env,jthiz);

    //获取类中方法createAudioTrack的id
    jmethodID create_audio_track_id = (*env)->GetMethodID(env,player_class,"createAudioTrack","(II)Landroid/media/AudioTrack;");

    //调用这个方法得到AudioTrack对象
    jobject audio_track = (*env)->CallObjectMethod(env,jthiz,create_audio_track_id,player->out_sample_rate,player->out_channel_nb);
    //调用AudioTrack.play方法
    jclass audio_track_class = (*env)->GetObjectClass(env,audio_track);

    //获取AudioTrack类中的play方法id
    jmethodID audio_track_play_mid = (*env)->GetMethodID(env,audio_track_class,"play","()V");
    (*env)->CallVoidMethod(env,audio_track,audio_track_play_mid);

    //AudioTrack.write
    jmethodID audio_track_write_id = (*env)->GetMethodID(env,audio_track_class,"write","([BII)I");

    //设置为全局引用,否则会报错,JNI ERROR(app bug):accessed stale local reference 0xxxxxxxx
    //在子线程中使用jobject或者jclass,要把相应的对象设置为全局引用,否则访问不到
    player->audio_track = (*env)->NewGlobalRef(env,audio_track);
    //(*env)->DeleteGlobalRef,注意全局引用使用完毕要delete
    player->audio_track_write_mid = audio_track_write_id;
}

/**
 * 解码音频
 */
void decode_audio(struct Player *player,AVPacket *avPacket){

    AVCodecContext *avFormatCtx = player->avCodecCtx[player->audio_stream_index];

    //开辟空间存储压缩数据
    AVFrame *avFrame = av_frame_alloc();
    //Zero if no frame could be decoded, otherwise it is non-zero
    int got_frame;
    /**
     * int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame,
     *      int *got_frame_ptr, const AVPacket *avpkt);
     */
    avcodec_decode_audio4(avFormatCtx,avFrame,&got_frame,avPacket);
    //重采样缓冲区
    uint8_t *out_buffer = av_malloc(MAX_AUDIO_FRME_SIZE);
    //解码一帧成功
    if(got_frame){
        /**
         * int swr_convert(struct SwrContext *s, uint8_t **out, int out_count,
                                const uint8_t **in , int in_count);
         */
        swr_convert(player->swrCtx,&out_buffer,MAX_AUDIO_FRME_SIZE,(const uint8_t **)avFrame->data,avFrame->nb_samples);
        /**
         * 获取sample的size
         * int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples,
                               enum AVSampleFormat sample_fmt, int align);
         */
        int out_buffer_size = av_samples_get_buffer_size(NULL,player->out_channel_nb,avFrame->nb_samples,player->out_sample_fmt,1);

        //关联当前线程的JNIEnv
        JavaVM *javaVM = player->javaVM;
        JNIEnv *env;
        (*javaVM)->AttachCurrentThread(javaVM,&env,NULL);

        //out_buffer缓冲区数据,转成byte数组,需要用到env,所以在上边获取
        //调用write方法需要传入一个byte数组,这个数组是包含out_buffer数组内容的,所以需要转换
        //创建一个和out_buffer数组同样大小的数组
        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,player->audio_track,player->audio_track_write_mid,
                audio_sample_array,0,out_buffer_size);
        //TODO
        //操作完成一次就释放一次数组,否则会溢出
        (*env)->DeleteLocalRef(env,audio_sample_array);
        (*javaVM)->DetachCurrentThread(javaVM);
        usleep(1000 * 16);

    }
    av_frame_free(&avFrame);
}

/**
 * 解码视频准备
 */
void decode_video_prepare(JNIEnv *env,struct Player *player,jobject surface){
    //窗体  保存到结构体中
    player->nativeWindow = ANativeWindow_fromSurface(env,surface);
}
/**
 * 解码视频
 */
void decode_video(struct Player *player,AVPacket *avPacket){

    //开辟缓冲区AVFrame用于存储解码后的像素数据(YUV)
    AVFrame *yuv_Frame = av_frame_alloc();
    //开辟缓冲区AVFrame用于存储转成rgba8888后的像素数据(YUV)
    AVFrame *rgb_Frame = av_frame_alloc();
    //绘制时的缓冲区
    ANativeWindow_Buffer outBuffer;

    AVCodecContext *avCodecCtx = player->avCodecCtx[player->video_stream_index];

    //是否获取到视频像素数据的标记(Zero if no frame could be decompressed, otherwise, it is nonzero.)
    int got_picture;
    int decode_result;
    //筛选视频压缩数据(根据流的索引位置判断)
    if(avPacket->stream_index == player->video_stream_index){
        //7.解码一帧视频压缩数据,得到视频像素数据
        decode_result = avcodec_decode_video2(avCodecCtx,yuv_Frame,&got_picture,avPacket);

        if (decode_result < 0){
            LOGE("%s","解码错误");
            return;
        }
        //为0说明全部解码完成,非0正在解码
        if (got_picture){

            //设置缓冲区的属性    format 注意格式需要和surfaceview指定的像素格式相同
            ANativeWindow_setBuffersGeometry(player->nativeWindow, avCodecCtx->width, avCodecCtx->height, WINDOW_FORMAT_RGBA_8888);
            ANativeWindow_lock(player->nativeWindow,&outBuffer,NULL);

            //设置缓冲区像素格式,rgb_frame的缓冲区与outBuffer.bits时同一块内存
            avpicture_fill((AVPicture*)rgb_Frame,outBuffer.bits,PIX_FMT_RGBA,avCodecCtx->width,avCodecCtx->height);

            //按照yvu的顺序传参,如下,颜色正常,可以参照示例程序
            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],
                    avCodecCtx->width,avCodecCtx->height);
            //unlock
            ANativeWindow_unlockAndPost(player->nativeWindow);

            //每次都需要sleep一下,否则会播放一帧之后就崩溃
            usleep(1000 * 16);
        }
    }
    av_frame_free(&yuv_Frame);
    av_frame_free(&rgb_Frame);
}

JNIEXPORT void JNICALL Java_com_example_ndk_1ffmpeg_FFmpegUtils_play
(JNIEnv *env, jobject jobj, jstring input_jstr, jobject surface){

        const char* input_cstr = (*env)->GetStringUTFChars(env,input_jstr,NULL);

        //给结构体申请一块空间(最后需要free掉)
        struct Player *player = (struct Player*)malloc(sizeof(struct Player));
        //获取Java虚拟机对象
        (*env)->GetJavaVM(env,&(player->javaVM));
        //初始化封装格式上下文
        init_input_format_ctx(player,input_cstr);

        int video_stream_index = player->video_stream_index;
        int audio_stream_index = player->audio_stream_index;
        //获取音视频解码器,并打开
        init_codec_context(player,video_stream_index);
        init_codec_context(player,audio_stream_index);

        decode_video_prepare(env,player,surface);
        decode_audio_prepare(player);

        jni_audio_prepare(env,jobj,player);
        //int pthread_create(pthread_t *thread, pthread_attr_t const * attr,
        //void *(*start_routine)(void *), void * arg);
        //创建子线程解码视频
        //pthread_create(&(player->decode_threads[video_stream_index]),NULL,decode_data,(void*)player);
        //创建子线程解码音频
        pthread_create(&(player->decode_threads[audio_stream_index]),NULL,decode_data,(void*)player);

}

相关文章
|
18天前
|
编解码
FFmpeg开发笔记(三十三)分析ZLMediaKit对H.264流的插帧操作
《FFmpeg开发实战》书中3.4.3节讲解如何将H.264流封装成MP4。H.264流通常以SPS→PPS→IDR帧开始,这一说法通过雷霄骅的H264分析器得到验证。分析器能解析H.264文件但不支持MP4。ZLMediaKit服务器在遇到I帧时会自动插入SPS和PPS配置帧,确保流符合标准格式。若缺少这些帧,客户端拉流时会报错。FFmpeg开发实战:从零基础到短视频上线》书中提供了更多FFmpeg开发细节。
32 0
FFmpeg开发笔记(三十三)分析ZLMediaKit对H.264流的插帧操作
|
5天前
|
Web App开发 缓存 Linux
FFmpeg开发笔记(三十六)Linux环境安装SRS实现视频直播推流
《FFmpeg开发实战》书中第10章提及轻量级流媒体服务器MediaMTX,适合测试RTSP/RTMP协议,但不适合生产环境。推荐使用SRS或ZLMediaKit,其中SRS是国产开源实时视频服务器,支持多种流媒体协议。本文简述在华为欧拉系统上编译安装SRS和FFmpeg的步骤,包括安装依赖、下载源码、配置、编译以及启动SRS服务。此外,还展示了如何通过FFmpeg进行RTMP推流,并使用VLC播放器测试拉流。更多FFmpeg开发内容可参考相关书籍。
19 2
FFmpeg开发笔记(三十六)Linux环境安装SRS实现视频直播推流
|
11天前
|
Linux Apache C++
FFmpeg开发笔记(三十五)Windows环境给FFmpeg集成libsrt
该文介绍了如何在Windows环境下为FFmpeg集成SRT协议支持库libsrt。首先,需要安装Perl和Nasm,然后编译OpenSSL。接着,下载libsrt源码并使用CMake配置,生成VS工程并编译生成srt.dll和srt.lib。最后,将编译出的库文件和头文件按照特定目录结构放置,并更新环境变量,重新配置启用libsrt的FFmpeg并进行编译安装。该过程有助于优化直播推流的性能,减少卡顿问题。
44 2
FFmpeg开发笔记(三十五)Windows环境给FFmpeg集成libsrt
|
12天前
|
Linux
FFmpeg开发笔记(三十四)Linux环境给FFmpeg集成libsrt和librist
《FFmpeg开发实战》书中介绍了直播的RTSP和RTMP协议,以及新协议SRT和RIST。SRT是安全可靠传输协议,RIST是可靠的互联网流传输协议,两者于2017年发布。腾讯视频云采用SRT改善推流卡顿。以下是Linux环境下为FFmpeg集成libsrt和librist的步骤:下载安装源码,配置、编译和安装。要启用这些库,需重新配置FFmpeg,添加相关选项,然后编译和安装。成功后,通过`ffmpeg -version`检查版本信息以确认启用SRT和RIST支持。详细过程可参考书中相应章节。
22 1
FFmpeg开发笔记(三十四)Linux环境给FFmpeg集成libsrt和librist
|
25天前
|
编解码 Java Android开发
FFmpeg开发笔记(三十一)使用RTMP Streamer开启APP直播推流
RTMP Streamer是一款开源的安卓直播推流框架,支持RTMP、RTSP和SRT协议,适用于各种直播场景。它支持H264、H265、AV1视频编码和AAC、G711、OPUS音频编码。本文档介绍了如何使用Java版的RTMP Streamer,建议使用小海豚版本的Android Studio (Dolphin)。加载项目时,可添加国内仓库加速依赖下载。RTMP Streamer包含五个模块:app、encoder、rtmp、rtplibrary和rtsp。完成加载后,可以在手机上安装并运行APP,提供多种直播方式。开发者可以从《FFmpeg开发实战:从零基础到短视频上线》获取更多信息。
54 7
FFmpeg开发笔记(三十一)使用RTMP Streamer开启APP直播推流
|
26天前
|
存储 编解码
FFmpeg开发笔记(三十)解析H.264码流中的SPS帧和PPS帧
《FFmpeg开发实战》书中介绍了音视频编码历史,重点讲述H.264的成功在于其分为视频编码层和网络抽象层。H.264帧类型包括SPS(序列参数集,含视频规格参数),PPS(图像参数集,含编码参数)和IDR帧(立即解码刷新,关键帧)。SPS用于计算视频宽高和帧率,PPS存储编码设置,IDR帧则标志新的解码序列。书中还配以图片展示各帧结构详情,完整内容可参考相关书籍。
52 7
FFmpeg开发笔记(三十)解析H.264码流中的SPS帧和PPS帧
|
4天前
|
编解码
FFmpeg开发笔记(三十七)分析SRS对HLS协议里TS包的插帧操作
《FFmpeg开发实战》书中讲解了音视频封装格式,重点介绍了TS,因其固定长度和独立解码特性,常用于HLS协议。HLS通过m3u8文件指示客户端播放TS分片。SRS服务器在转换MP4至TS时,会在每个TS包头添加SPS和PPS帧,保证解码完整性。这一过程在SrsIngestHlsOutput::on_ts_video函数中体现,调用write_h264_sps_pps和write_h264_ipb_frame完成。详细实现涉及SrsRawH264Stream::mux_sequence_header函数,遵循ISO标准写入SPS和PPS NAL单元。
16 0
FFmpeg开发笔记(三十七)分析SRS对HLS协议里TS包的插帧操作
|
19天前
|
Web App开发 移动开发 编解码
FFmpeg开发笔记(三十二)利用RTMP协议构建电脑与手机的直播Demo
本文讨论了实时数据传输在互联网中的重要性,如即时通讯和在线直播。一对一通信通常使用WebRTC技术,但一对多直播需要流媒体服务器和特定协议,如RTSP、RTMP、SRT或RIST。RTMP由于其稳定性和早期普及,成为国内直播的主流。文章通过实例演示了如何使用OBS Studio和RTMP Streamer进行RTMP推流,并对比了不同流媒体传输协议的优缺点。推荐了两本关于FFmpeg和Android开发的书籍以供深入学习。
26 0
FFmpeg开发笔记(三十二)利用RTMP协议构建电脑与手机的直播Demo
|
7天前
|
存储 Oracle Java
Java面试题:描述如何使用Eclipse或IntelliJ IDEA进行Java开发?
Java面试题:描述如何使用Eclipse或IntelliJ IDEA进行Java开发?
12 0
|
27天前
|
开发工具 Android开发 git
合作开发(Eclipse+git +码云)
合作开发(Eclipse+git +码云)
17 0