怎么编译Ijkplayer 这里就不说了,自行百度吧
截图、录制的实现是根据某个变量条件判断的,视频在播放过程中不断循环获取数据进行解封装、解压缩,在这过程中,根据一个变量判断是否需要截图或录制视频;截图 的变量理应是一次性的,完成截图功能之后,把对应截图变量变成假;录制则根据用户停止或者读取到文件结尾后停止录制
1、截图实现原理是在播放画面之前,判断是否需要截图,是则拿到 AVFrame对其进行编码,然后封装成一个图片文件
2、录制也是一样的原理,在解码AVPacket 之前判断是否需要录像,是则复制一份AVPacket ,然后封装成音视频文件
一、配置编译参数
向config 目录下的module-lite.sh 文件末尾添加以下内容:
export COMMON_FF_CFG_FLAGS="$COMMON_FF_CFG_FLAGS --enable-protocol=rtp"
export COMMON_FF_CFG_FLAGS="$COMMON_FF_CFG_FLAGS --enable-demuxer=rtsp"
export COMMON_FF_CFG_FLAGS="$COMMON_FF_CFG_FLAGS --enable-muxer=mjpeg"
export COMMON_FF_CFG_FLAGS="$COMMON_FF_CFG_FLAGS --enable-decoder=mjpeg"
export COMMON_FF_CFG_FLAGS="$COMMON_FF_CFG_FLAGS --enable-demuxer=mjpeg"
export COMMON_FF_CFG_FLAGS="$COMMON_FF_CFG_FLAGS --enable-encoder=mjpeg"
(我项目中播放的是rtsp的,所以ffmpeg 需要开启rtsp支持,还有截图功能)
然后删除 module.sh文件,重新生成module.sh 文件
ln -s module-lite.sh module.sh
( ln -s 相当于重定向 )
然后重新编译ffmpeg库,在 ijkplayer-android / android / contrib 目录下:
./compile-ffmpeg.sh clean //清理以前编译的ffmpeg库文件
./compile-ffmpeg.sh armv7a //编译armv7a 架构的so库
二、添加代码
以下所有操作的文件都在 ijkplayer-android/ijkmedia/ijkplayer 目录中
1、核心方法与变量
首先添加一些变量
向 ff_ffplay_def.h 头文件中的 FFPlayer 结构体添加以下变量
int is_screenshot;//是否截图,是一次性的,一次只能截一张图
char *screen_file_name;//输出图片的路径 screen_file_name;//截图保存地址
AVFormatContext *m_ofmt_ctx; // 用于输出的AVFormatContext结构体
AVOutputFormat *m_ofmt;
pthread_mutex_t record_mutex; // 锁
int is_record; // 是否在录制
int record_error; //虽然没用,但是代码中使用到了,所以别删
int videoindex;//视频输入流的下标
int audeoindex;//音频输入流的下标
int videoindex_out;//视频输出流的下标
int audioindex_out;//音频输出流的下标
int record_count; //录制packet 数量,这个测试用的,虽然没用,但是代码中使用到了,所以别删
int is_first; // 用于录制时候,当某一帧的 pts 和 dts 一致时,才开始录制
int64_t start_pts; // 开始录制时pts
int64_t start_dts; // 开始录制时dts
以下是FFPlayer 结构体的部分内容(方便对照)
typedef struct FFPlayer {
const AVClass *av_class;
/* ffplay context */
VideoState *is;
/* format/codec options */
AVDictionary *format_opts;
AVDictionary *codec_opts;
AVDictionary *sws_dict;
AVDictionary *player_opts;
AVDictionary *swr_opts;
AVDictionary *swr_preset_opts;
int is_screenshot;//是否截图,是一次性的,一次只能截一张图
char *screen_file_name;//输出图片的路径 screen_file_name;//截图保存地址
AVFormatContext *m_ofmt_ctx; // 用于输出的AVFormatContext结构体
AVOutputFormat *m_ofmt;
pthread_mutex_t record_mutex; // 锁
int is_record; // 是否在录制
int record_error; //虽然没用,但是代码中使用到了,所以别删
int videoindex;//视频输入流的下标
int audeoindex;//音频输入流的下标
int videoindex_out;//视频输出流的下标
int audioindex_out;//音频输出流的下标
int record_count; //录制packet 数量,这个测试用的,虽然没用,但是代码中使用到了,所以别删
int is_first; // 用于录制时候,当某一帧的 pts 和 dts 一致时,才开始录制
int64_t start_pts; // 开始录制时pts
int64_t start_dts; // 开始录制时dts
/* ffplay options specified by the user */
#ifdef FFP_MERGE
AVInputFormat *file_iformat;
.
.
.
}
ff_ffplay.h 头文件末尾添加以下 函数
/*
* 截图
* @param out_file 保存截图文件的全路径,只需要文件路径就行,不需要提前生成文件
*/
int ffp_get_current_frame(FFPlayer* ffp,const char* out_file);
/*
* 开始录制
* @param file_name 保存录制文件的全路径,只需要文件路径就行,不需要提前生成文件
*/
int ffp_start_record(FFPlayer *ffp, const char *file_name);
/*
* 结束录制
*/
int ffp_stop_record(FFPlayer *ffp);
/*
* 把 packet 包写入文件中
*/
int ffp_record_file(FFPlayer *ffp, AVPacket *packet);
/*
* 判断是否在录制
*
*/
int ffp_is_record(FFPlayer *ffp);
/*
* 保存图片
@param out_file 文件路径
*/
int save_png(AVFrame *picture, const char *out_file);
ff_ffplay.c 文件添加实现
int ffp_get_current_frame(FFPlayer* ffp,const char* out_file) {
if (!ffp->is_screenshot){
ffp->is_screenshot = 1;
if (ffp->screen_file_name!=NULL) {
free(ffp->screen_file_name);
ffp->screen_file_name = NULL;
}
ffp->screen_file_name = (char*)malloc(sizeof(char)*strlen(out_file)+1);
strcpy(ffp->screen_file_name, out_file);
return 1;
}
return 0;
}
//开始录制函数:file_name是保存路径
int ffp_start_record(FFPlayer *ffp, const char *file_name)
{
J4A_ALOGE("开始录制函数:%s\n",file_name);
assert(ffp);
VideoState *is = ffp->is;
int ret;
ffp->m_ofmt_ctx = NULL;
ffp->m_ofmt = NULL;
ffp->is_record = 0;
ffp->record_error = 0;
ffp->videoindex = -1;
ffp->audeoindex = -1;
ffp->videoindex_out = -1;//视频输出流的下标
ffp->audioindex_out = -1;//音频输出流的下标
if (!file_name || !strlen(file_name)) { // 没有路径
J4A_ALOGE("filename is invalid\n");
goto end;
}
if (!is || !is->ic|| is->paused || is->abort_request) { // 没有上下文,或者上下文已经停止
J4A_ALOGE("没有上下文,或者上下文已经停止\n");
goto end;
}
if (ffp->is_record) { // 已经在录制
J4A_ALOGE("已经在录制\n");
goto end;
}
for (int i = 0; i < is->ic->nb_streams; i++) {
AVStream* av_stream = is->ic->streams[i];
enum AVMediaType mediaType = av_stream->codecpar->codec_type;
if (mediaType == AVMEDIA_TYPE_VIDEO) {
ffp->videoindex = i;
J4A_ALOGE("视频流= %d\n", i);//1
}else if (mediaType == AVMEDIA_TYPE_AUDIO) {
ffp->audeoindex = i;
J4A_ALOGE("音频流= %d\n", i);//2
}
else
{
continue;
}
}
// 初始化一个用于输出的AVFormatContext结构体
avformat_alloc_output_context2(&ffp->m_ofmt_ctx, NULL, NULL, file_name);
if (!ffp->m_ofmt_ctx) {
av_log(ffp, AV_LOG_ERROR, "Could not create output context filename is %s\n", file_name);
J4A_ALOGE("创建输出的AVFormatContext结构体失败-->%s",file_name);
goto end;
}
ffp->m_ofmt = ffp->m_ofmt_ctx->oformat;
for (int i = 0; i < is->ic->nb_streams; i++) {
if (i==ffp->videoindex || i== ffp->audeoindex ){
AVStream* in_stream = is->ic->streams[i];
AVCodecParameters* codecpar = in_stream->codecpar;
enum AVMediaType mediaType = codecpar->codec_type;
AVCodec* dec = avcodec_find_decoder(codecpar->codec_id);
AVStream* out_stream = avformat_new_stream(ffp->m_ofmt_ctx, dec);
if (!out_stream) {
J4A_ALOGE("Failed allocating output stream\n");
ret = AVERROR_UNKNOWN;
goto end;
}
if (i == ffp->videoindex) {
ffp->videoindex_out = out_stream->index;
}
else if (i == ffp->audeoindex){
ffp->audioindex_out = out_stream->index;
}else {
}
codecpar->codec_tag = 0;
AVCodecContext* context = avcodec_alloc_context3(dec);
ret = avcodec_parameters_to_context(context, codecpar);
//ret = avcodec_parameters_from_context(codecpar, context);
//out_stream->codecpar = codecpar;
out_stream->codec = context;
}else{
continue;
}
}
av_dump_format(ffp->m_ofmt_ctx, 0, file_name, 1);
// 打开输出文件
if (!(ffp->m_ofmt->flags & AVFMT_NOFILE)) {
if (avio_open(&ffp->m_ofmt_ctx->pb, file_name, AVIO_FLAG_WRITE) < 0) {
av_log(ffp, AV_LOG_ERROR, "Could not open output file '%s'", file_name);
goto end;
}
}
// 写视频文件头
if (avformat_write_header(ffp->m_ofmt_ctx, NULL) < 0) {
av_log(ffp, AV_LOG_ERROR, "Error occurred when opening output file\n");
goto end;
}
ffp->is_record = 1;
ffp->record_error = 0;
pthread_mutex_init(&ffp->record_mutex, NULL);
return 0;
end:
ffp->record_error = 1;
return -1;
}
//停止录播
int ffp_stop_record(FFPlayer *ffp)
{
assert(ffp);
if (ffp->is_record) {
ffp->is_record = 0;
pthread_mutex_lock(&ffp->record_mutex);
if (ffp->m_ofmt_ctx != NULL) {
av_write_trailer(ffp->m_ofmt_ctx);
if (ffp->m_ofmt_ctx && !(ffp->m_ofmt->flags & AVFMT_NOFILE)) {
avio_close(ffp->m_ofmt_ctx->pb);
}
avformat_free_context(ffp->m_ofmt_ctx);
ffp->m_ofmt_ctx = NULL;
ffp->is_first = 0;
ffp->record_count = 0;
ffp->videoindex = -1;
ffp->audeoindex = -1;
ffp->videoindex_out = -1;
ffp->audioindex_out = -1;
ffp->start_pts = 0;
ffp->start_dts = 0;
}
pthread_mutex_unlock(&ffp->record_mutex);
pthread_mutex_destroy(&ffp->record_mutex);
av_log(ffp, AV_LOG_DEBUG, "stopRecord ok\n");
}
else {
av_log(ffp, AV_LOG_ERROR, "don't need stopRecord\n");
}
return 0;
}
int ffp_record_file(FFPlayer* ffp, AVPacket* packet)
{
assert(ffp);
VideoState* is = ffp->is;
int ret = 0;
int stream_index = 0;
AVStream* in_stream;
AVStream* out_stream;
int pkt_index = packet->stream_index;
if (pkt_index == ffp->videoindex || pkt_index == ffp->audeoindex) {
if (ffp->is_record) {
if (packet == NULL) {
ffp->record_error = 1;
av_log(ffp, AV_LOG_ERROR, "packet == NULL");
return -1;
}
AVPacket* pkt = (AVPacket*)av_malloc(sizeof(AVPacket)); // 与看直播的 AVPacket分开,不然卡屏
av_new_packet(pkt, 0);
if (0 == av_packet_ref(pkt, packet)) {
pthread_mutex_lock(&ffp->record_mutex);
// 需要减去第一帧的时间,
pkt->pts =pkt->pts - ffp->start_pts;
pkt->dts =pkt->dts - ffp->start_dts;
in_stream = is->ic->streams[pkt->stream_index];
if (pkt->stream_index == ffp->videoindex) {
out_stream = ffp->m_ofmt_ctx->streams[ffp->videoindex_out];
stream_index=ffp->videoindex_out;
}
else {
out_stream = ffp->m_ofmt_ctx->streams[ffp->audioindex_out];
stream_index=ffp->audioindex_out;
}
// 转换PTS/DTS
pkt->pts = av_rescale_q_rnd(pkt->pts, in_stream->time_base, out_stream->time_base, (AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
pkt->dts = av_rescale_q_rnd(pkt->dts, in_stream->time_base, out_stream->time_base, (AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
pkt->duration = av_rescale_q(pkt->duration, in_stream->time_base, out_stream->time_base);
pkt->pos = -1;
pkt->stream_index = stream_index;
ffp->record_count++;
J4A_ALOGE("录制packet数量=%d\n", ffp->record_count);
// 写入一个AVPacket到输出文件
if ((ret = av_interleaved_write_frame(ffp->m_ofmt_ctx, pkt)) < 0) {
av_log(ffp, AV_LOG_ERROR, "Error muxing packet\n");
}
av_packet_unref(pkt);
pthread_mutex_unlock(&ffp->record_mutex);
}
else {
av_log(ffp, AV_LOG_ERROR, "av_packet_ref == NULL");
}
}
}
return ret;
}
//是否正在录制
int ffp_is_record(FFPlayer *ffp){
return ffp->is_record;
}
//保存图片
int save_png(AVFrame *picture, const char *out_file) {
AVFormatContext *pFormatCtx;
AVOutputFormat *fmt;
AVStream *video_st;
AVCodecContext *pCodecCtx;
AVCodec *pCodec;
AVPacket pkt;
int y_size;
int got_picture = 0;
int ret = 0;
//Method 1
pFormatCtx = avformat_alloc_context();
//Guess format
fmt = av_guess_format("mjpeg", NULL, NULL);
pFormatCtx->oformat = fmt;
//Output URL
if (avio_open(&pFormatCtx->pb, out_file, AVIO_FLAG_READ_WRITE) < 0) {
avformat_free_context(pFormatCtx);
J4A_ALOGE("Couldn't open output file.");
return -1;
}
//Method 2. More simple
//avformat_alloc_output_context2(&pFormatCtx, NULL, NULL, out_file);
//fmt = pFormatCtx->oformat;
video_st = avformat_new_stream(pFormatCtx, 0);
if (video_st == NULL) {
avio_close(pFormatCtx->pb);
avformat_free_context(pFormatCtx);
return -1;
}
pCodecCtx = video_st->codec;
pCodecCtx->codec_id = fmt->video_codec;
pCodecCtx->codec_type = AVMEDIA_TYPE_VIDEO;
pCodecCtx->pix_fmt = AV_PIX_FMT_YUVJ420P;
pCodecCtx->width = picture->width;
pCodecCtx->height = picture->height;
pCodecCtx->time_base.num = 1;
pCodecCtx->time_base.den = 25;
//Output some information
av_dump_format(pFormatCtx, 0, out_file, 1);
AV_CODEC_ID_MJPEG;
pCodec = avcodec_find_encoder(pCodecCtx->codec_id);
if (!pCodec) {
avcodec_close(video_st->codec);
avio_close(pFormatCtx->pb);
avformat_free_context(pFormatCtx);
J4A_ALOGE("Codec not found.");
return -1;
}
if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0) {
J4A_ALOGE("Could not open codec.");
avcodec_close(video_st->codec);
avio_close(pFormatCtx->pb);
avformat_free_context(pFormatCtx);
return -1;
}
//Write Header
avformat_write_header(pFormatCtx, NULL);
y_size = pCodecCtx->width * pCodecCtx->height;
av_new_packet(&pkt, y_size * 3);
ret = avcodec_encode_video2(pCodecCtx, &pkt, picture, &got_picture);
if (ret < 0) {
J4A_ALOGE("Encode Error.\n");
avcodec_close(video_st->codec);
avio_close(pFormatCtx->pb);
avformat_free_context(pFormatCtx);
return -1;
}
if (got_picture == 1) {
pkt.stream_index = video_st->index;
ret = av_write_frame(pFormatCtx, &pkt);
}
av_free_packet(&pkt);
//Write Trailer
av_write_trailer(pFormatCtx);
J4A_ALOGE("Encode Successful.\n");
if (video_st) {
avcodec_close(video_st->codec);
}
avio_close(pFormatCtx->pb);
avformat_free_context(pFormatCtx);
return 0;
}
以上代码使用了Android NDK的打印方法,所以在ff_ffplay.h 加入头文件
#include "ff_ffplay_def.h"
#include "ff_fferror.h"
#include "ff_ffmsg.h"
#include "j4a/j4a_base.h" //加这个
以上是基础函数的声明和实现,真正的核心功能,现在需要在什么位置调用相应的函数:
2、截图插入位置
理想的截图位置是在显示画面之前拿到AVFrame 帧,然后封装成一张图片,但是ijkplayer 内部把AVFrame 转成了一个SDL_VoutOverlay ,数据发生改变,死活封装不成一张图片(没研究透),所以只能在转化成 SDL_VoutOverlay 之前判断 是否需要截图,好在也能截取当前画面,视觉误差几乎没有;
截图插入位置,在 ff_ffplay.c 中的 ffplay_video_thread() 函数中插入以下代码
if (ffp->is_screenshot) {
J4A_ALOGE("截图保存地址=%s", ffp->screen_file_name);
ffp->is_screenshot=0;
save_png(frame, ffp->screen_file_name);
free(ffp->screen_file_name);
ffp->screen_file_name = NULL;
}
ffplay_video_thread 部分代码
/*视频解码函数*/
static int ffplay_video_thread(void* arg)
{
FFPlayer* ffp = arg;
VideoState* is = ffp->is;
AVFrame* frame = av_frame_alloc();
double pts;
double duration;
int ret;
AVRational tb = is->video_st->time_base;
AVRational frame_rate = av_guess_frame_rate(is->ic, is->video_st, NULL);
int64_t dst_pts = -1;
int64_t last_dst_pts = -1;
int retry_convert_image = 0;
int convert_frame_count = 0;
for (;;) {
.
.
. n行代码
.
.
duration = (frame_rate.num && frame_rate.den ? av_q2d((AVRational) { frame_rate.den, frame_rate.num }) : 0);
pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
//截图插入位置,直接复制这段代码即可
if (ffp->is_screenshot) {
J4A_ALOGE("截图保存地址=%s", ffp->screen_file_name);
ffp->is_screenshot=0;
save_png(frame, ffp->screen_file_name);
free(ffp->screen_file_name);
ffp->screen_file_name = NULL;
}
ret = queue_picture(ffp, frame, pts, duration, frame->pkt_pos, is->viddec.pkt_serial);
// 好像也可以放到这个位置,还不太清楚 queue_picture 函数中有没有对frame内容做修改,所以放在 queue_picture 之前
av_frame_unref(frame);
.
.
. 若干行代码
.
.
the_end:
#if CONFIG_AVFILTER
avfilter_graph_free(&graph);
#endif
av_log(NULL, AV_LOG_INFO, "convert image convert_frame_count = %d\n", convert_frame_count);
av_frame_free(&frame);
return 0;
}
3、录制插入位置
理想的录制流程是,拿到播放前的音频、视频数据,重新编码,在把音频、视频数据封装成 音视频文件,但是视频帧经过转化成了SDL_VoutOverlay ,所以这种方法放弃了(难度也比较大);
所以这里的录制时,在AVPacket 解码成 AVFrame 之前,判断是否录制;刚好ijkplayer 音视频数据解码 都在decoder_decode_frame 函数中进行,在函数decoder_decode_frame中插入以下代码:
// 获取开始录制前dts等于pts最后的值,这样录像第一帧的的显示时间和解码时间一致
if (!ffp->is_first && pkt.pts == pkt.dts) {
ffp->is_first = 1;
ffp->start_pts = pkt.pts;
ffp->start_dts = pkt.dts;
}
if (ffp->is_record && ffp->is_first) { // 可以录制时,写入文件
if (0 != ffp_record_file(ffp, &pkt)) {
ffp->record_error = 1;
ffp_stop_record(ffp);
}
}
decoder_decode_frame 部分代码:
static int decoder_decode_frame(FFPlayer *ffp, Decoder *d, AVFrame *frame, AVSubtitle *sub) {
int ret = AVERROR(EAGAIN);
for (;;) {
AVPacket pkt;
.
.
. 若干代码
.
.
int result = avcodec_send_packet(d->avctx, &pkt);
//录制插入代码,开始
// 获取开始录制前dts等于pts最后的值,这样录像第一帧的的显示时间和解码时间一致
if (!ffp->is_first && pkt.pts == pkt.dts) {
ffp->is_first = 1;
ffp->start_pts = pkt.pts;
ffp->start_dts = pkt.dts;
}
if (ffp->is_record && ffp->is_first) { // 可以录制时,写入文件
if (0 != ffp_record_file(ffp, &pkt)) {
ffp->record_error = 1;
J4A_ALOGE("意外停止录制");
ffp_stop_record(ffp);
}
}
//录制插入代码,结束
if (result == AVERROR(EAGAIN)) {
av_log(d->avctx, AV_LOG_ERROR, "Receive_frame and send_packet both returned EAGAIN, which is an API violation.\n");
d->packet_pending = 1;
av_packet_move_ref(&d->pkt, &pkt);
}
}
av_packet_unref(&pkt);
}
}
}
-------------------------------------------------分割线---------------------------------------------------
下面的代码只是调用上面的代码而已:
4、Android 调用ff_ffplay
ijkplayer 的内容只是就像个中介一样,Android 调用C 代码是在ijkplayer_jni 中,ijkplayer_jni 调用 具体功能只能通过ijkplayer 来调用;
向ijkplayer.h 头文件结尾添加函数声明, 也是对应ff_ffplay.h添加的函数,少了ffp_record_file函数,因为ffp_record_file函数是录制过程写入文件操作,外部不需要关心
int ijkmp_get_current_frame(IjkMediaPlayer* mp,const char* out_file);
int ijkmp_start_record(IjkMediaPlayer *mp,const char *file_name);
int ijkmp_stop_record(IjkMediaPlayer *mp);
int ijkmp_is_record(IjkMediaPlayer *mp);
ijkplayer.c 实现
int ijkmp_get_current_frame(IjkMediaPlayer* mp,const char* file_name) {
assert(mp);
MPTRACE("ijkmp_get_current_frament()\n");
pthread_mutex_lock(&mp->mutex);
int retval = ffp_get_current_frame(mp->ffplayer, file_name);
pthread_mutex_unlock(&mp->mutex);
MPTRACE("ijkmp_get_current_frament()=%d\n", retval);
return retval;
}
int ijkmp_start_record(IjkMediaPlayer *mp,const char *file_name)
{
assert(mp);
MPTRACE("ijkmp_startRecord()\n");
pthread_mutex_lock(&mp->mutex);
int retval = ffp_start_record(mp->ffplayer,file_name);
pthread_mutex_unlock(&mp->mutex);
MPTRACE("ijkmp_startRecord()=%d\n", retval);
return retval;
}
int ijkmp_stop_record(IjkMediaPlayer *mp)
{
assert(mp);
MPTRACE("ijkmp_stopRecord()\n");
pthread_mutex_lock(&mp->mutex);
int retval = ffp_stop_record(mp->ffplayer);
pthread_mutex_unlock(&mp->mutex);
MPTRACE("ijkmp_stopRecord()=%d\n", retval);
return retval;
}
int ijkmp_is_record(IjkMediaPlayer *mp)
{
assert(mp);
MPTRACE("ijkmp_stopRecord()\n");
pthread_mutex_lock(&mp->mutex);
int retval = ffp_is_record(mp->ffplayer);
pthread_mutex_unlock(&mp->mutex);
MPTRACE("ijkmp_stopRecord()=%d\n", retval);
return retval;
}
以下是Android 调用 C 代码的方法映射,在 …/ijkplayer-android/ijkmedia/ijkplayer/android 目录下
向ijkplayer_jni.c 中加入方法映射 (注意看注释,不要直接复制)
static JNINativeMethod g_methods[] = {
{
"_setDataSource",
"(Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;)V",
(void *) IjkMediaPlayer_setDataSourceAndHeaders
},
{ "_setDataSourceFd", "(I)V", (void *) IjkMediaPlayer_setDataSourceFd },
{ "_setDataSource", "(Ltv/danmaku/ijk/media/player/misc/IMediaDataSource;)V", (void *)IjkMediaPlayer_setDataSourceCallback },
{ "_setAndroidIOCallback", "(Ltv/danmaku/ijk/media/player/misc/IAndroidIO;)V", (void *)IjkMediaPlayer_setAndroidIOCallback },
.
. 省略
.
//添加下面这几个
{ "getCurrentFrame", "(Ljava/lang/String;)I", (void *) IjkMediaPlayer_getCurrentFrame },
{ "startRecord", "(Ljava/lang/String;)I", (void *) IjkMediaPlayer_startRecord },
{ "stopRecord", "()I", (void *) IjkMediaPlayer_stopRecord },
{ "isRecord", "()I", (void *) IjkMediaPlayer_isRecord },
};
对应的本地映射方法
static int
IjkMediaPlayer_getCurrentFrame(JNIEnv *env, jclass thiz, jstring name)
{
const char *c_name = (*env)->GetStringUTFChars(env, name, 0);
jint retval = 0;
IjkMediaPlayer* mp = jni_get_media_player(env, thiz);
JNI_CHECK_GOTO(mp, env, NULL, "mpjni: IjkMediaPlayer_getCurrentFrame: null mp", LABEL_RETURN);
retval = ijkmp_get_current_frame(mp,c_name);
LABEL_RETURN:
ijkmp_dec_ref_p(&mp);
if (c_name)
(*env)->ReleaseStringUTFChars(env, name, c_name);
return retval;
}
static jint
IjkMediaPlayer_startRecord(JNIEnv *env, jclass thiz,jstring file)
{
jint retval = 0;
IjkMediaPlayer *mp = jni_get_media_player(env, thiz);
JNI_CHECK_GOTO(mp, env, NULL, "mpjni: startRecord: null mp", LABEL_RETURN);
const char *nativeString = (*env)->GetStringUTFChars(env, file, 0);
retval = ijkmp_start_record(mp,nativeString);
LABEL_RETURN:
ijkmp_dec_ref_p(&mp);
return retval;
}
static jint
IjkMediaPlayer_stopRecord(JNIEnv *env, jclass thiz)
{
jint retval = 0;
IjkMediaPlayer *mp = jni_get_media_player(env, thiz);
JNI_CHECK_GOTO(mp, env, NULL, "mpjni: stopRecord: null mp", LABEL_RETURN);
retval = ijkmp_stop_record(mp);
LABEL_RETURN:
ijkmp_dec_ref_p(&mp);
return retval;
}
static jint
IjkMediaPlayer_isRecord(JNIEnv *env, jclass thiz)
{
jint retval = 0;
IjkMediaPlayer *mp = jni_get_media_player(env, thiz);
JNI_CHECK_GOTO(mp, env, NULL, "mpjni: stopRecord: null mp", LABEL_RETURN);
retval = ijkmp_is_record(mp);
LABEL_RETURN:
ijkmp_dec_ref_p(&mp);
return retval;
}
完成之后编译生成 生成库文件,在/ijkplayer-android/android 目录下执行以下命令
./compile-ijk.sh clean //清理以前生成的库文件
./compile-ijk.sh armv7a //编译生成armv7a 结构的ijkplayer播放器的动态库文件
三、Android 使用
编译好的so库在 …/ijkplayer-android/android/ijkplayer/cpu架构/src/main/libs / 对应的upc架构 中,项目中添加so库,
因为添加了jni 的映射方法,所以也需要添加Android 层的方法调用到jni。导入 ijkplayer-java 模块,调用jni 层的代码是在 IjkMediaPlayer 类中,向IjkMediaPlayer添加以下native 方法
@Override
public native int startRecord(String recordVideoPath);
@Override
public native int stopRecord();
// 如果是在录像中返回的值是 1
@Override
public native int isRecord();
@Override
public native int getCurrentFrame(String saveFile);
(我项目中使用到了Ijkplayer 提供的IjkVideoView 播放控件,这个播放控件播放内核不止一个,所以我把以上方法放到了 IMediaPlayer 抽象类中,不使用Ijkplayer 提供的IjkVideoView 控件,直接使用 IjkMediaPlayer 来控制播放则在IjkMediaPlayer 中直接添加上面方法就好)
IjkVideoView 类中添加以下代码
public int startRecord(String recordVideoPath) {
return mMediaPlayer.startRecord(recordVideoPath);
}
public int stopRecord() {
return mMediaPlayer.stopRecord();
}
public boolean isRecord() {
// 如果是在录像中返回的值是 1
return mMediaPlayer.isRecord() > 0;
}
public void getTestBitmp(String saveFile) {
mMediaPlayer.getCurrentFrame(saveFile);
}
如果播放内核不是ijkplayer 判断一下 mMediaPlayer
因为我是录制的是直播,所以配置了一下内容
ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_PLAYER, "start-on-prepared", 0);
ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_FORMAT, "http-detect-range-support", 0);
ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_CODEC, "skip_loop_filter", 48);
ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_FORMAT, "rtsp_transport", "tcp");
ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_FORMAT, "rtsp_flags", "prefer_tcp");
// ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_FORMAT, "allowed_media_types", "video"); //根据媒体类型来配置
ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_FORMAT, "timeout", 20000);
ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_FORMAT, "buffer_size", 1316);
ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_FORMAT, "infbuf", 1); // 无限读
ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_FORMAT, "analyzemaxduration", 100L);
ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_FORMAT, "probesize", 10240L);
ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_FORMAT, "flush_packets", 1L);
// 关闭播放器缓冲,这个必须关闭,否则会出现播放一段时间后,一直卡主,控制台打印 FFP_MSG_BUFFERING_START
ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_PLAYER, "packet-buffering", 0L);
ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_PLAYER, "framedrop", 2L);
最后,不给demo说不过去,这里献上
参考:
iOS直播内容保存为本地视频

本文详细介绍了如何在ijkplayer安卓版中实现截图和录制功能。首先,通过配置编译参数开启rtsp和mjpeg支持,并添加相关变量和函数。截图功能在播放画面前获取AVFrame并编码成图片;录制功能则在解码AVPacket前判断是否需要录制,并将数据写入文件。核心代码分别在`ffplay_video_thread()`和`decoder_decode_frame()`函数中插入。最后,介绍了Android层如何调用这些C代码,并提供了ijkplayer-java模块的相应方法映射。
1187

被折叠的 条评论
为什么被折叠?



