android基于ffmpeg的简单视频播发器 时间同步

最新推荐文章于 2023-07-29 00:07:05 发布
最新推荐文章于 2023-07-29 00:07:05 发布
阅读量541 收藏 2
点赞数
分类专栏： ffmpeg
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010302327/article/details/78436799
版权

前面写了视频解码和音频解码，接下来要同步了

java代码

setContentView(R.layout.activity_main);
SurfaceView surfaceView = findViewById(R.id.surface_view);
surfaceView.getHolder().addCallback(new SurfaceHolder.Callback() {
    @Override
    public void surfaceCreated(SurfaceHolder holder) {

    }

    @Override
    public void surfaceChanged(final SurfaceHolder holder, int format, int width, int height) {
        Thread audioThread = new Thread(){
            @Override
            public void run() {
                super.run();
                String videoPath = "/storage/emulated/0/baiduNetdisk/season09.mp4";
                audioPlay(videoPath);
            }
        };
        audioThread.start();
        Thread videoThread = new Thread(){
            @Override
            public void run() {
                super.run();
                String videoPath = "/storage/emulated/0/baiduNetdisk/season09.mp4";
                videoPlay(videoPath,holder.getSurface());
            }
        };
        videoThread.start();

    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {

    }
});
就是开两个线程主要还是c++代码

既然要同步线程，肯定是让快的线程等待慢的线程，通过前面的代码知道，视频线程比音频快，所以只能让视频线程进行等待，等待的话就用到了锁

pthread_mutex_t video_mutex;
pthread_cond_t video_cond;
还需要等待时间 

long audio_time = 0;
long start_time = 0;

知道当前时间

long getCurrentTime() {
    struct timeval tv;
    gettimeofday(&tv,NULL);
    return tv.tv_sec * 1000 + tv.tv_usec / 1000;
}

计算等待时间的方法 

timespec waitTime(long timeout_ms){
    struct timespec abstime;
    struct timeval now;
    gettimeofday(&now, NULL);
    long nsec = now.tv_usec * 1000 + (timeout_ms % 1000) * 1000000;
    abstime.tv_sec=now.tv_sec + nsec / 1000000000 + timeout_ms / 1000;
    abstime.tv_nsec=nsec % 1000000000;
    return abstime;
}
首先，要在音频线程计算出音频的时间 

double nowTime = frame->pts * av_q2d(avStream->time_base);
long t = (long) (nowTime * 1000);
audio_time = t;
start_time = getCurrentTime();
然后在视频线程计算出时间差 

double nowTime = yuvFrame->pts * av_q2d(avStream->time_base);
long t = (long) (nowTime * 1000);
long time = getCurrentTime() - start_time;
long wait = t - time - audio_time;
再让视频线程进行等待 

struct timespec abstime = waitTime(wait);
pthread_mutex_lock(&video_mutex);
pthread_cond_timedwait(&video_cond, &video_mutex,&abstime);
pthread_mutex_unlock(&video_mutex);
这样就实现时间同步，误差是一定有的，几毫秒到十几毫秒吧

贴完整代码

pthread_mutex_t video_mutex;
pthread_cond_t video_cond;

long audio_time = 0;
long start_time = 0;

long getCurrentTime() {
    struct timeval tv;
    gettimeofday(&tv,NULL);
    return tv.tv_sec * 1000 + tv.tv_usec / 1000;
}

timespec waitTime(long timeout_ms){
    struct timespec abstime;
    struct timeval now;
    gettimeofday(&now, NULL);
    long nsec = now.tv_usec * 1000 + (timeout_ms % 1000) * 1000000;
    abstime.tv_sec=now.tv_sec + nsec / 1000000000 + timeout_ms / 1000;
    abstime.tv_nsec=nsec % 1000000000;
    return abstime;
}

extern "C"
JNIEXPORT void JNICALL
Java_com_example_ffmpegrun_MainActivity_videoPlay(JNIEnv *env, jobject instance, jstring path_,
                                                  jobject surface) {
    const char *path = env->GetStringUTFChars(path_, 0);
    
    // TODO

    pthread_mutex_init (&video_mutex,NULL);
    pthread_cond_init(&video_cond,NULL);


    av_register_all();
    AVFormatContext *fmt_ctx = avformat_alloc_context();
    if (avformat_open_input(&fmt_ctx, path, NULL, NULL) < 0) {
        return;
    }
    if (avformat_find_stream_info(fmt_ctx, NULL) < 0) {
        return;
    }
    AVStream *avStream = NULL;
    int video_stream_index = -1;
    for (int i = 0; i < fmt_ctx->nb_streams; i++) {
        if (fmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
            avStream = fmt_ctx->streams[i];
            video_stream_index = i;
            break;
        }
    }
    if (video_stream_index == -1) {
        return;
    }
    AVCodecContext *codec_ctx = avcodec_alloc_context3(NULL);
    avcodec_parameters_to_context(codec_ctx, avStream->codecpar);

    AVCodec *avCodec = avcodec_find_decoder(codec_ctx->codec_id);
    if (avcodec_open2(codec_ctx, avCodec, NULL) < 0) {
        return;
    }

    ANativeWindow* nativeWindow = ANativeWindow_fromSurface(env,surface);

    AVFrame *yuvFrame = av_frame_alloc();

    EGLUtils *eglUtils = new EGLUtils();
    eglUtils->initEGL(nativeWindow);

    OpenGLUtils *openGLUtils = new OpenGLUtils();
    openGLUtils->surfaceCreated();
    openGLUtils->surfaceChanged(eglUtils->getWidth(),eglUtils->getHeight());
    openGLUtils->initTexture(codec_ctx->width,codec_ctx->height);

    int y_size = codec_ctx->width * codec_ctx->height;
    AVPacket *pkt = (AVPacket *) malloc(sizeof(AVPacket));
    av_new_packet(pkt, y_size);
    int ret;
    while (1) {
        if (av_read_frame(fmt_ctx, pkt) < 0) {
            av_packet_unref(pkt);
            break;
        }
        if (pkt->stream_index == video_stream_index) {
            ret = avcodec_send_packet(codec_ctx, pkt);
            if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
                av_packet_unref(pkt);
                continue;
            }
            ret = avcodec_receive_frame(codec_ctx, yuvFrame);
            if (ret < 0 && ret != AVERROR_EOF) {
                av_packet_unref(pkt);
                continue;
            }

            double nowTime = yuvFrame->pts * av_q2d(avStream->time_base);
            long t = (long) (nowTime * 1000);
            long time = getCurrentTime() - start_time;
            long wait = t - time - audio_time;

            struct timespec abstime = waitTime(wait);
            pthread_mutex_lock(&video_mutex);
            pthread_cond_timedwait(&video_cond, &video_mutex,&abstime);
            pthread_mutex_unlock(&video_mutex);

            openGLUtils->updateTexture(yuvFrame->width,yuvFrame->height,yuvFrame->data[0],yuvFrame->data[1],yuvFrame->data[2]);
            openGLUtils->surfaceDraw();
            eglUtils->drawEGL();

            av_packet_unref(pkt);
        }
        av_packet_unref(pkt);
    }
    av_frame_free(&yuvFrame);
    avcodec_close(codec_ctx);
    avformat_close_input(&fmt_ctx);

    pthread_cond_destroy(&video_cond);
    pthread_mutex_destroy(&video_mutex);

    env->ReleaseStringUTFChars(path_, path);
}
#define MAX_AUDIO_FRME_SIZE 48000 * 4
extern "C"
JNIEXPORT void JNICALL
Java_com_example_ffmpegrun_MainActivity_audioPlay(JNIEnv *env, jobject instance, jstring path_) {
    const char *path = env->GetStringUTFChars(path_, 0);

    // TODO

    av_register_all();
    AVFormatContext *fmt_ctx = avformat_alloc_context();
    if (avformat_open_input(&fmt_ctx, path, NULL, NULL) < 0) {
        return;
    }
    if (avformat_find_stream_info(fmt_ctx, NULL) < 0) {
        return;
    }
    AVStream *avStream = NULL;
    int audio_stream_index = -1;
    for (int i = 0; i < fmt_ctx->nb_streams; i++) {
        if (fmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
            avStream = fmt_ctx->streams[i];
            audio_stream_index = i;
            break;
        }
    }
    if (audio_stream_index == -1) {
        return;
    }
    AVCodecContext *codec_ctx = avcodec_alloc_context3(NULL);
    avcodec_parameters_to_context(codec_ctx, avStream->codecpar);

    AVCodec *avCodec = avcodec_find_decoder(codec_ctx->codec_id);
    if (avcodec_open2(codec_ctx, avCodec, NULL) < 0) {
        return;
    }
    SwrContext *swr_ctx = swr_alloc();

    enum AVSampleFormat in_sample_fmt = codec_ctx->sample_fmt;

    enum AVSampleFormat out_sample_fmt = AV_SAMPLE_FMT_S16;

    int in_sample_rate = codec_ctx->sample_rate;

    int out_sample_rate = in_sample_rate;

    uint64_t in_ch_layout = codec_ctx->channel_layout;

    uint64_t out_ch_layout = AV_CH_LAYOUT_STEREO;


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

    int out_channel_nb = av_get_channel_layout_nb_channels(out_ch_layout);

    jclass player_class = env->GetObjectClass(instance);
    jmethodID create_audio_track_mid = env->GetMethodID(player_class, "createAudio",
                                                        "(II)Landroid/media/AudioTrack;");
    jobject audio_track = env->CallObjectMethod(instance, create_audio_track_mid,
                                                out_sample_rate, out_channel_nb);


    jclass audio_track_class = env->GetObjectClass(audio_track);
    jmethodID audio_track_play_mid = env->GetMethodID(audio_track_class, "play", "()V");
    jmethodID audio_track_stop_mid = env->GetMethodID(audio_track_class, "stop", "()V");
    env->CallVoidMethod(audio_track, audio_track_play_mid);

    jmethodID audio_track_write_mid = env->GetMethodID(audio_track_class, "write",
                                                       "([BII)I");


    uint8_t *out_buffer = (uint8_t *) av_malloc(MAX_AUDIO_FRME_SIZE);

    AVPacket *pkt = (AVPacket *) malloc(sizeof(AVPacket));
    int ret;
    while (1) {

        if (av_read_frame(fmt_ctx, pkt) < 0){
            av_packet_unref(pkt);
            break;
        }
        ret = avcodec_send_packet(codec_ctx, pkt);
        if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
            av_packet_unref(pkt);
            continue;
        }
        AVFrame *frame = av_frame_alloc();

        ret = avcodec_receive_frame(codec_ctx, frame);
        if (ret < 0 && ret != AVERROR_EOF) {
            av_packet_unref(pkt);
            av_frame_free(&frame);
            continue;
        }

        double nowTime = frame->pts * av_q2d(avStream->time_base);
        long t = (long) (nowTime * 1000);
        audio_time = t;
        start_time = getCurrentTime();

        swr_convert(swr_ctx, &out_buffer, MAX_AUDIO_FRME_SIZE,
                    (const uint8_t **) frame->data,
                    frame->nb_samples);
        int out_buffer_size = av_samples_get_buffer_size(NULL, out_channel_nb,
                                                         frame->nb_samples, out_sample_fmt,
                                                         1);

        jbyteArray audio_sample_array = env->NewByteArray(out_buffer_size);
        jbyte *sample_bytep = env->GetByteArrayElements(audio_sample_array, NULL);

        memcpy(sample_bytep, out_buffer, (size_t) out_buffer_size);
        env->ReleaseByteArrayElements(audio_sample_array, sample_bytep, 0);


        env->CallIntMethod(audio_track, audio_track_write_mid,
                           audio_sample_array, 0, out_buffer_size);

        env->DeleteLocalRef(audio_sample_array);

        av_frame_free(&frame);

        av_packet_unref(pkt);
    }

    env->CallVoidMethod(audio_track, audio_track_stop_mid);
    av_free(out_buffer);
    swr_free(&swr_ctx);
    avcodec_close(codec_ctx);
    avformat_close_input(&fmt_ctx);

    env->ReleaseStringUTFChars(path_, path);
}

2017/11/6更新

发现个bug修改一下

声音解码时在av_read_frame()之后加个判断

if(pkt->stream_index == audio_stream_index)

然后再进行播放处理，因为av_read_frame()得到的数据有视频数据和音频数据，因为这个线程是专门处理声音的，所以把视频数据给过滤掉，就像视频线程会过滤音频数据一样









红色与青色
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
老调重弹之ffmpeg视频时间同步
10-01 490
之前尝试了对视频数据的解码和简单的显示，解码完一帧图像就显示，然后立即再解码下一帧并显示，相当于一个视频以XN倍的快进播放完。现在尝试对视频图像做时间同步，即按正常的视频速率播放。 DTS和PTS 首先有两个概念：DTS和PTS。一个是解码时间，一个是显示时间。对视频的编码，并不是一个帧就包含...
android基于UDP局域网实现视频同步播放
08-19
android基于udp局域网实现视频同步播放
android基于ffmpeg的简单视频播发器 编译ffmpeg
红色与青色
11-01 376
ffmpeg编译的文章网上很多，很简单，我是windows10系统 首先安装mingw:https://sourceforge.net/projects/mingw/files 在安装界面选择basic setup,把右边的都勾选，然后点击installation选择apply change进行下载安装 配置环境变量，在Path内添加 C:\MinGW\bin C:\MinGW\msys
音视频同步基础——FFMPEG时间戳
weixin_45196915的博客
11-16 1394
文章出处：FFmpeg时间戳详解 - 叶余 - 博客园 1. I 帧/P 帧/B 帧 I 帧：I 帧(Intra-coded picture, 帧内编码帧，常称为关键帧)包含一幅完整的图像信息，属于帧内编码图像，不含运动矢量，在解码时不需要参考其他帧图像。因此在 I 帧图像处可以切换频道，而不会导致图像丢失或无法解码。I 帧图像用于阻止误差的累积和扩散。在闭合式 GOP 中，每个 GOP 的第一个帧一定是 I 帧，且当前 GOP 的数据不会参考前后 GOP 的数据。 P 帧：P 帧(Predictiv
【ffmpeg音视频同步】解决ffmpeg音视频中多线程之间的数据同步问题
最新发布
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
07-29 1192
音视频同步（Audio-Video Synchronization）是音频和视频处理中的一个关键问题，特别是在嵌入式系统和实时系统中，音视频同步是确保用户体验的重要因素。在实际应用中，我们经常需要处理来自不同源的音频和视频流，这些流可能具有不同的时间基准和延迟。为了确保音频和视频的同步播放，我们需要对这些流进行精确的同步处理。
C++基于opencv与ffmpeg的视频编辑器源码.zip
06-02
C++基于opencv与ffmpeg的视频编辑器源码，C++开发，QT界面，基于opencv与ffmpeg的视频编辑器。+配置文件，C++基于opencv与ffmpeg的视频编辑器源码，C++开发，QT界面，基于opencv与ffmpeg的视频编辑器。+配置文件C++...
最简单的基于FFMPEG的视频编码器（修正）
06-08
尽管该视频编码器的代码十分简单，但是几乎包含了使用FFMPEG编码一个视频所有必备的API。十分适合FFmpeg的初学者。 工程基于VC2010。 使用了2014.5.6版本的FFmpeg类库。 注：这是修正版，增加了flush_encoder()...
基于ffmpeg无损视频压缩软件
05-29
FFmpeg是一款强大的开源多媒体处理...总的来说，基于FFmpeg的无损视频压缩软件结合Python可以实现高效、灵活的视频优化。通过调整参数和编写自动化脚本，我们可以根据需求平衡视频质量和文件大小，满足不同场景的需求。
最简单的基于FFMPEG的视频编码器（修正
04-19
"最简单的基于FFMPEG的视频编码器（修正版）"可能是一个示例项目，旨在帮助初学者理解如何利用FFmpeg库进行基本的视频编码操作。 在FFmpeg中，编码过程涉及几个关键步骤： 1. **初始化FFmpeg库**：首先，你需要...
android 获取音频时间戳,如何获取Android中视频文件的关键帧(同步帧)时间戳列表？...
weixin_39531780的博客
05-29 284
对于一个优雅的解决方案,好像您需要使用ffmpeg for android来实现这一点.有人试过这样：How to get the frame from video file in android;并建议使用ffmpeg.如果您不想使用ffmpeg,您可以尝试以下操作：private ArrayList getKeyFrameTimestamps(String filename) {ArrayLi...
BaiduNetdisk_6.1.0
04-16
BaiduNetdisk_6.1.0
FileProvider
05-31
FileProvider的使用
Android视频处理之动态时间水印效果
01-20
最近的项目中遇到一个非常头痛的需求，在Android端录制视频的时候动态添加像监控画面一样的精确到秒的时间信息，关键是，并不是说只在播放器的界面显示时间就可以了，而是录制到视频里面去，这个MP4在电脑上播放也能看到每个画面的时间。 最后想到的办法是在录制完成以后去处理这个视频。 期间参考了很多资料，比较有用的大概是ffmpeg和比较新的Api mediaCodec系列了。介于ffmpeg都是C实现，和一大堆NDK相关，本人不是太懂，就重点关注了MediaCodec系列。 参考逻辑流程图一目了然的这篇博文 MediaCodec进行编解码的大体逻辑是这样的(转载)： 主要函数的调用逻辑如
storage/emulated/0是什么？
m0_38094058的博客
11-06 14万+
storage/emulated/0 是手机内部存储根目录 个人总结： 手机内部存储是storage/emulated/0，而手机SD卡的存储是storage/emulated/1 前面部分不一定相同 (如果本人理解有误，希望大家能指出 谢谢) RAM表示手机的运行内存 ROM是手机的存储内存，相当于电脑的硬盘 Android开发中容易混淆的是内部存储和外部储存(这个内部存储和外部存储不要跟上面...
华为手机storage/emulated/0找不到的问题 解决方法
qq_42732137的博客
06-19 7万+
华为手机/storage/emulated/0找不到的问题 解决方法 网易云下载了音乐后，想要提取出来，但是找不到下载文件夹在哪里。 更新鸿蒙os系统后，理论上也不会影响文件夹的设置。后经过查询，发现该问题早在2016年emui系统就存在了。目前看来这个是由于Android系统对文件夹调用的显示问题导致的。 搜索“华为”“storage”等关键词后，未看见有提出解决办法的答案。 这里放出解决网易云文件夹的方法，该方法可以被迁移到寻找其他文件上。 网易云app下载的音乐，显示保存在/storage/emula
android基于ffmpeg的简单视频播发器 三线程实现播放器(完)
红色与青色
11-08 1829
一个多星期都在研究播放器，从双线程到三线程，它们的关系太复杂了，总是搞不定，而且本人c++水平实在有限，很多东西都不太会用。终于搞好了一个能拿得出手的东东，基本没啥严重的bug了，或者我没发现严重的bug，不过代码还是挺乱的，而且音视频对齐使用的办法也不是很好，以后再慢慢优化，先拿来用 一个线程读取AVPacket保存到数组，由另外两个线程做解码和播放，这样就不会出现上一篇博文里一个文件两个线程
storage/emulated/0.到底在哪儿
热门推荐
gislaozhang
07-31 19万+
问题： 通过logcat读出的sdcard根目录的路径名是/storage/emulated/0/. 但是我不知道这个路径到底是在哪儿？ 解答： android的API的得到的就是/storage/emulated/0/，这个路径我们用的时候一般直接进/sdcard/或者/mnt/sdcard/，其实是一个相同的位置； 通过Device File Explorer查找到/mnt/sd...
/storage/emulated/0保存路径
songzi1228的博客
12-13 14万+
0代表的是设备内存，1代表的是内存卡，所以你看下0后面的文件夹是什么名字，直接打开设备内存找到那个文件夹就可以了。
Android平台FFMPEG音视频处理方案研究
"这篇硕士论文详细探讨了在Android多媒体平台上基于FFmpeg的音视频处理方案，旨在为Android上的音视频开发提供技术指导。作者罗潇在导师黄红斌副教授的指导下，研究了如何利用FFmpeg在Android系统中实现音视频的处理...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值