android ffmpeg+OpenGL播放yuv+openSL 快放 慢放 视频播放器

最新推荐文章于 2024-09-16 19:09:48 发布
最新推荐文章于 2024-09-16 19:09:48 发布
阅读量1.9k 收藏 2
点赞数
分类专栏： openGL

这里是完整的音视频播放器，功能如下（这里有iOS版的）：
这里写图片描述
视频是通过opengl 播放yuv数据，音频是opensl播放。
app运行流程如下图：
这里写图片描述
红色虚线内的是一个线程的运行，总共涉及到四个线程。
java层几乎没有播放器的内容，ffmpeg，opengl，opensl都是在c++层运行，所以可以原封不动的迁移到其他平台，如ios，不过c/c++代码ios程序员看起来不太友好，有ios版的，ios版的有yuv->RGB->image的方法，有ffmpeg解码播放流程图，解码播放流程一目了然。
看一下app表现，小米6播放每分钟100M等级的视频：
播放每分钟100M等级的视频
可以看到cpu使用在10%左右，很省电了有没有100M每分钟，一部电影是十几G的清晰度。
再看常规清晰度720p：
这里写图片描述
cpu消耗只有3%左右，这也就是直播清晰度了，这cpu消耗还能说什么。
看内存优化：
这里写图片描述
整个播放过程native层内存占用都在15M左右波动，Graphics占用内存也没变化，播放过程中内存释放很到位，没有内存增长。大家可以自行测试。
这里给大家看下ffmpeg解码代码：
FFmpeg.h

//
// Created by huizai on 2017/11/22.
//

#ifndef FFMPEG_DEMO_FFMPEGDECODER_H
#define FFMPEG_DEMO_FFMPEGDECODER_H
#include "JniDefine.h"
#include "YUV_GL_DATA.h"

extern "C" {
//编码
#include "libavcodec/avcodec.h"
//封装格式处理
#include "libavformat/avformat.h"
//像素处理
#include "libswscale/swscale.h"
#include "libswresample/swresample.h"
}

//定义音频重采样后的参数
#define SAMPLE_SIZE 16
#define SAMPLE_RATE 44100
#define CHANNEL     2


typedef struct  FFmpeg{
    int                       totleMs;
//音频播放时间
    int                       aFps;
//视频播放时间
    int                       vFps;
//视频流索引
    int                       videoStreamIndex;
    int                       audioStreamIndex;
    int                       sampleRate;
    int                       sampleSize;
    int                       channel;
//音频贞数据的长度
    int                       pcmDataLength;

    AVFormatContext         * pFormatCtx;
    AVCodecContext          * pVideoCodecCtx;
    AVCodecContext          * pAudioCodecCtx;
    AVFrame                 * pYuv;
    AVFrame                 * pPcm;
    AVCodec                 * pVideoCodec; //视频解码器
    AVCodec                 * pAudioCodec; //音频解码器
    struct SwsContext       * pSwsCtx;
    SwrContext              * pSwrCtx;
    const char              * url;
    AVPacket                  pkt;
    char                    * audioData;
    H264YUV_Frame             yuvFrame;
}Decoder;

int   OpenAndInitDecoder(Decoder * decoder);
int   Read(Decoder * decoder);
int   Decode(Decoder * decoder,AVPacket packet);
int   YuvToGLData(Decoder *decoder);
int   ToPcm(Decoder * decoder,AACFrame * frame);
void  printError(const char* flag,int ret);
double r2d(AVRational r);
#endif //FFMPEG_DEMO_FFMPEGDECODER_H
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63

FFmpeg.cpp

//
// Created by huizai on 2017/11/22.
//

#include "FFmpeg.h"


int OpenAndInitDecoder(Decoder * decoder){

    //1.注册所有组件
    av_register_all();
    avformat_network_init();
    //2.打开输入视频文件
    //封装格式上下文，统领全局的结构体，保存了视频文件封装格式的相关信息
    decoder->pFormatCtx = avformat_alloc_context();
    int ret = avformat_open_input(&decoder->pFormatCtx, decoder->url, NULL, NULL);
    if (ret != 0) {
        return  ret;
    } else{
        FFLOGI("视频长度：%d",decoder->pFormatCtx->duration);
    }
    decoder->totleMs = (int)(decoder->pFormatCtx->duration/AV_TIME_BASE)*1000;
    avformat_find_stream_info(decoder->pFormatCtx, NULL);
    //分别找到音频视频解码器并打开解码器
    for (int i = 0; i < decoder->pFormatCtx->nb_streams; i++) {
        AVStream *stream = decoder->pFormatCtx->streams[i];
        AVCodec * codec = avcodec_find_decoder(stream->codecpar->codec_id);
        AVCodecContext * codecCtx = avcodec_alloc_context3(codec);
        avcodec_parameters_to_context(codecCtx, stream->codecpar);

        if (codecCtx->codec_type == AVMEDIA_TYPE_VIDEO) {
            printf("video\n");
            decoder->videoStreamIndex = i;
            decoder->pVideoCodec  = codec;
            decoder->pVideoCodecCtx = codecCtx;
            int err = avcodec_open2(decoder->pVideoCodecCtx, decoder->pVideoCodec, NULL);
            if (err != 0) {
                char buf[1024] = {0};
                av_strerror(err, buf, sizeof(buf));
                printf("open videoCodec error:%s", buf);
                return false;
            }
        }
        if (codecCtx->codec_type == AVMEDIA_TYPE_AUDIO) {
            printf("audio\n");
            decoder->audioStreamIndex = i;
            decoder->pAudioCodec  = codec;
            decoder->pAudioCodecCtx = codecCtx;
            int err = avcodec_open2(decoder->pAudioCodecCtx, decoder->pAudioCodec, NULL);
            if (err != 0) {
                char buf[1024] = {0};
                av_strerror(err, buf, sizeof(buf));
                printf("open audionCodec error:%s", buf);
                return false;
            }
            if (codecCtx->sample_rate != SAMPLE_RATE) {
                decoder->sampleRate = codecCtx->sample_rate;
            }
        }
    }
    decoder ->pYuv = av_frame_alloc();
    decoder ->pPcm = av_frame_alloc();
    decoder ->channel = CHANNEL;
    decoder ->sampleSize = SAMPLE_SIZE;
    decoder ->sampleRate = decoder->pAudioCodecCtx->sample_rate;
   // printf("open acodec success! sampleRate:%d  channel:%d  sampleSize:%d fmt:%d\n",
         //  decoder->sampleRate,decoder->channel,decoder->sampleSize,decoder->pAudioCodecCtx->sample_fmt);
    FFLOGI("open acodec success! sampleRate:%d  channel:%d  fmt:%d\n",
           decoder->pAudioCodecCtx->sample_rate,decoder->pAudioCodecCtx->channels,decoder->pAudioCodecCtx->sample_fmt);
    return  ret;
}
int  Read(Decoder * decoder){

    //这里先不加线程锁，在启动多线程的地方统一加锁
    // AVPacket * pkt = malloc(sizeof(AVPacket));
    if (!decoder->pFormatCtx) {
        return -1;
    }
    int err = av_read_frame(decoder->pFormatCtx,&decoder->pkt);
    if (err != 0) {
        printError("av_read_pkt_error:",err);
        if (err == -541478725){
            //读取文件结束
            return -9;
        }
        return  -2;
    }
    return  0;
}
int Decode(Decoder* decoder,AVPacket packet){
    if (!decoder->pFormatCtx) {
        return -1;
    }
    //分配AVFream 空间
    if (decoder->pYuv == NULL) {
        decoder->pYuv = av_frame_alloc();
    }
    if (decoder->pPcm == NULL) {
        decoder->pPcm = av_frame_alloc();
    }
    AVCodecContext * pCodecCtx;
    AVFrame * tempFrame;
    if (packet.stream_index == decoder->videoStreamIndex) {
        pCodecCtx = decoder->pVideoCodecCtx;
        tempFrame = decoder->pYuv;
    }else if (packet.stream_index == decoder->audioStreamIndex){
        pCodecCtx = decoder->pAudioCodecCtx;
        tempFrame = decoder->pPcm;
    }else{
        return -1;
    }
    if (!pCodecCtx) {
        return -1;
    }
    int re = avcodec_send_packet(pCodecCtx,&packet);
    if (re != 0) {
        char errorBuf[1024] = {0};
        av_make_error_string(errorBuf,1024,re);
        FFLOGE("send pkt error:%s",errorBuf);
        return -1;
    }
    re = avcodec_receive_frame(pCodecCtx, tempFrame);
    if (re != 0) {
        char errorBuf[1024] = {0};
        av_make_error_string(errorBuf,1024,re);
        FFLOGE("receive av_data error:%s",errorBuf);
        return -1;
    }
    if (packet.stream_index == decoder->videoStreamIndex) {
        decoder->vFps = (int)((packet.pts * r2d(decoder->pFormatCtx->streams[decoder->videoStreamIndex]->time_base))*1000);
    }else if (packet.stream_index == decoder->audioStreamIndex){
        decoder->aFps = (int)((packet.pts * r2d(decoder->pFormatCtx->streams[decoder->audioStreamIndex]->time_base))*1000);
    }
    FFLOGI("[D]");
    return 0;
}
int Min(int a,int b){
    return a>b?b:a;
}
void copyDecodedFrame(unsigned char *src, unsigned char *dist,int linesize, int width, int height)
{
    width = Min(linesize, width);
    if (sizeof(dist) == 0) {
        return;
    }
    for (int i = 0; i < height; ++i) {
        memcpy(dist, src, width);
        dist += width;
        src += linesize;
    }
}

int   YuvToGLData(Decoder *decoder){
    if (!decoder->pFormatCtx || !decoder->pYuv ||decoder-> pYuv->linesize[0] <= 0) {
        return -1;
    }
    //把数据重新封装成opengl需要的格式
    unsigned int lumaLength= (unsigned int)(decoder->pYuv->height)*(Min(decoder->pYuv->linesize[0], decoder->pYuv->width));
    unsigned int chromBLength=(unsigned int)((decoder->pYuv->height)/2)*(Min(decoder->pYuv->linesize[1], (decoder->pYuv->width)/2));
    unsigned int chromRLength=(unsigned int)((decoder->pYuv->height)/2)*(Min(decoder->pYuv->linesize[2], (decoder->pYuv->width)/2));

    decoder->yuvFrame.luma.dataBuffer = (unsigned char*)malloc(lumaLength);
    decoder->yuvFrame.chromaB.dataBuffer = (unsigned char*)malloc(chromBLength);
    decoder->yuvFrame.chromaR.dataBuffer = (unsigned char*)malloc(chromRLength);

    decoder->yuvFrame.width=(unsigned int)decoder->pYuv->width;
    decoder->yuvFrame.height=(unsigned int)decoder->pYuv->height;

    if (decoder->pYuv->height <= 0) {
        free(decoder->yuvFrame.luma.dataBuffer);
        free(decoder->yuvFrame.chromaB.dataBuffer);
        free(decoder->yuvFrame.chromaR.dataBuffer);
        return -1;
    }

    copyDecodedFrame(decoder->pYuv->data[0],decoder->yuvFrame.luma.dataBuffer,decoder->pYuv->linesize[0],
                     decoder->pYuv->width,decoder->pYuv->height);
    copyDecodedFrame(decoder->pYuv->data[1], decoder->yuvFrame.chromaB.dataBuffer,decoder->pYuv->linesize[1],
                     decoder->pYuv->width / 2,decoder->pYuv->height / 2);
    copyDecodedFrame(decoder->pYuv->data[2], decoder->yuvFrame.chromaR.dataBuffer,decoder->pYuv->linesize[2],
                     decoder->pYuv->width / 2,decoder->pYuv->height / 2);
    return 0;
}
int ToPcm(Decoder * decoder,AACFrame * frame){
    if (!decoder->pFormatCtx || !decoder->pPcm) {
        return -1;
    }
   // printf("sample_rate:%d,channels:%d,sample_fmt:%d,channel_layout:%llu,nb_samples:%d\n",pAudioCodecCtx->sample_rate,pAudioCodecCtx->channels,pAudioCodecCtx->sample_fmt,pAudioCodecCtx->channel_layout,pPcm->nb_samples);
    //音频重采样
    if (decoder->pSwrCtx == NULL) {
        decoder->pSwrCtx = swr_alloc();
        swr_alloc_set_opts(decoder->pSwrCtx,
                           AV_CH_LAYOUT_STEREO,//2声道立体声
                           AV_SAMPLE_FMT_S16,  //采样大小 16位
                           decoder->sampleRate,
                           decoder->pAudioCodecCtx->channel_layout,
                           decoder->pAudioCodecCtx->sample_fmt,// 样本类型
                           decoder->pAudioCodecCtx->sample_rate,
                           0, 0);
        int ret = swr_init(decoder->pSwrCtx);
        char errorBuf[1024] = {0};
        av_make_error_string(errorBuf,1024,ret);
        FFLOGE("swr_init error:%s",errorBuf);
    }
    uint8_t * tempData[1];
    tempData[0] = (uint8_t*)frame->dataBuffer;
    int len = swr_convert(decoder->pSwrCtx, tempData, 10000, (const uint8_t**)decoder->pPcm->data,decoder->pPcm->nb_samples);
    if (len < 0) {
        char errbuf[1024] = {0};
        FFLOGE("swr_convert error:%d",len);
        return 0;
    }
    int outSize = av_samples_get_buffer_size(NULL,
                                             CHANNEL,
                                             len,
                                             AV_SAMPLE_FMT_S16,0);
    frame->length = (unsigned int)outSize;
    FFLOGI("nb_smples:%d,des_smples:%d,outSize:%d",decoder->pPcm->nb_samples,len,outSize);
    return 0;
}

void printError(const char * flag,int ret){
    char errorbuf[1024] = {0};
    av_make_error_string(errorbuf, 1024, ret);
    FFLOGE("%s,ret:%d,%s", flag, ret, errorbuf);
}
double r2d(AVRational r){
    return r.num == 0 || r.den == 0 ? 0.:(double)r.num/(double)r.den;
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229

可以跟iOS版的对比一下，根本没区别，都是一样的，要不怎么说跨平台技术呢。代码说明可以去看ios版的有简单说明。也可以下载源码debug进行了解。

说明一点，想要做优化的，就是我这里线程锁加的很粗糙，这样会造成不同线程对资源的等待，会有点点不流畅，应该精细到每一句就好了，自己去调吧。

注意！
想要跑这个代码一点要配置好ndk编译环境！要不然跑不起来。
配置教程：
http://blog.csdn.net/m0_37677536/article/details/78557573

源码下载（运行环境AS3.0,编译：gradle-4.1-all）：
http://download.csdn.net/download/m0_37677536/10155271
ffmpeg库现在只支持本地或在线MP4格式播放。
新版库下载（支持所有常见格式播放，目录结构跟代码中版本不一样需要配置）：
http://download.csdn.net/download/m0_37677536/10241575
测试视频下载（现在代码是在线播放1080p网络不好会卡）：
https://pan.baidu.com/s/1dEWVdAT 密码：k4vu
下载后放到手机跟目录，改一下MainActivity里面的播放地址即可；
android opengl 播放 yuv：
http://blog.csdn.net/m0_37677536/article/details/78783267
android opensl播放 pcm：
http://blog.csdn.net/m0_37677536/article/details/79013969

陈纪建
关注
专栏目录
FFmpegOpenGL:Android视频播放器，由FFmpeg解码，由OpenGL ES 2.0渲染
05-16
FFmpegOpenGL Android视频播放器，由FFmpeg解码，由OpenGL ES 2.0渲染
FFmpeg打造Android万能音频播放器
01-05
FFmpeg打造Android万能音频播放器视频教程，移植FFmpeg到Android平台，利用FFmpeg解码音频数据并用OpenSL ES来播放，打造Android万能播放器。
Android MediaPlayer + GLSurfaceView 播放视频
最新发布
ansondroider的博客
09-16 2104
在Android开发中，使用OpenGL ES来渲染视频是一种常见的需求，尤其是在需要实现自定义的视频播放界面或者视频特效时。结合MediaPlayer，我们可以实现一个功能强大的视频播放器。以下是一个简单的示例，展示如何在Android应用中使用OpenGL ES和MediaPlayer播放本地视频。
FFmpeg+OpenGL ES+OpenSL ES打造Android视频播放器
05-06
FFmpeg+OpenGL ES+OpenSL ES打造Android视频播放器教程，该课程基于C++语言，用FFmpeg、OpenGL ES、OpenSL ES和MediaCodec打造Android视频播放器。以录播课形式讲解课程所涉及的知识点和整体流程，每节课都有相关的PPT和源码资料，并用通俗易懂的方式讲解课程。适合人群 有一定的C++基础和Android开发经验。
iOS ffmpeg+OpenGL播放yuv+openAL 快放 慢放 视频播放器
irainsa的博客
03-22 571
由于老版本的ffmpeg一些使用方法将要废弃如streams[videoStream]->codec这种方式查找解码器就不能用了，再使用就会报警告，或者报错，这里使用新版ffmpeg接口制作播放器。先看播放器功能（这里有android版的）：带有音视频同步，快慢速播放，本地及网络视频播放等，经测试支持所有网络视频流，目前还没有发现播放不出的网络视频流。这是一个完整的播放器，后面有源码下载地址。
Android集成FFmpeg，看这篇就够了
热门推荐
日敲三万行代码
04-19 1万+
本教程会教大家集成FFmpeg，并使用FFmpeg的代码（非命令行）进行播放mp3。 一、下载FFmpeg源码，编译出静态库.a/动态库.so 传送门：https://blog.csdn.net/gxhea/article/details/115539124 二、将库复制到项目中 我编译的是.a静态库，复制到项目中；还需要复制FFmpeg的源代码到项目中，源代码在FFmpeg的根目录，具体复制哪些请看项目结构图片 三、CMakeLists.txt进行第三方库链接 # For more
iOS ffmpeg+OpenGL播放yuv+openAL 快放 慢放 视频播放器-附件资源
03-02
iOS ffmpeg+OpenGL播放yuv+openAL 快放 慢放 视频播放器-附件资源
Android+FFmpeg+OpenSL ES音频解码播放
11-11
总之，"Android+FFmpeg+OpenSL ES音频解码播放"是一个涵盖多媒体处理、Android原生开发和性能优化的综合课题，需要开发者具备扎实的编程基础和对Android音频系统的深入理解。通过合理利用这些技术，可以创建出高效、...
一个qt+ffmpeg+opengl播放音视频的demo
01-29
在本文中，我们将深入探讨如何使用Qt、FFmpeg和OpenGL技术来实现音视频播放的示例项目。这个项目名为“XPlay2”，虽然存在一些小bug，但它为学习者提供了宝贵的实践经验，且代码注释相对完整，有助于理解其工作原理...
android ffmpeg+OpenGL播放yuv+openSL 快放 慢放 视频播放器
huizai的博客
12-12 5333
这里是完整的音视频播放器，功能如下（这里有iOS版的）： 视频是通过opengl 播放yuv数据，音频是opensl播放。 app运行流程如下图： 红色虚线内的是一个线程的运行，总共涉及到四个线程。 java层几乎没有播放器的内容，ffmpeg，opengl，opensl都是在c++层运行，所以可以原封不动的迁移到其他平台，如ios，不过c/c++代码ios程序员看起来不太友好，有
OpenGL如何处理YUV数据（Android开发）(格式：I420、NV12、NV21)
02-17
OpenGL如何处理YUV数据（Android开发）(格式：I420、NV12、NV21) OpenGL如何处理YUV数据（Android开发）(格式：I420、NV12、NV21)
入门FFmpeg编程 --Android
QG
07-21 3611
ffmpeg 编程
一文读懂 Android FFmpeg 视频解码过程与实战分析
m0_60259116的博客
03-07 6281
概述 本文首先以 FFmpeg 视频解码为主题，主要介绍了 FFmpeg 进行解码视频时的主要流程、基本原理；其次，文章还讲述了与 FFmpeg 视频解码有关的简单应用，包括如何在原有的 FFmpeg 视频解码的基础上按照一定时间轴顺序播放视频、如何在播放视频时加入 seek 的逻辑；除此之外，文章重点介绍了解码视频时可能容易遗漏的细节，最后是简单地阐述了下如何封装一个具有基本的视频解码功能的 VideoDecoder。 前言 FFmpeg FFmpeg 是一套可以用来录制、转换数字音频、视频，
Android系统集成和使用FFmpeg
weixin_41678668的博客
07-01 1551
ubuntu环境交叉编译FFmpeg库，并且集成到android系统使用。
ffmpeg专辑(六):android执行ffmpeg命令行
minping9101的博客
08-01 1343
经过前几篇的介绍，我们已经掌握在linux下编译ffmpeg.so。我们编译出so，目的是为了能够使用so达到使用ffmpeg相关功能的目的。本篇介绍如何在android上直接执行ffmpeg命令行。本文要求读者有一定的jni基础。
Android FFmpeg开发(一)，FFmpeg编译与集成
yinshipin007的博客
05-06 1210
一、准备交叉编译环境我的环境如下：系统：ubuntu20.04NDK版本：r17c。
Android ffmpeg详解
qq_27672101的博客
07-29 1906
一、编译ffmpeg： 1、准备android ndk： 下载android ndk：选择linux平台，注意是否是64位，链接https://developer.android.google.cn/ndk/downloads/ ubuntu解压ndk安装包：unzip android-ndk-r20-linux-x86_64.zip 2、准备ffmpeg： 下载ffmpeg：...
FFMPEG编码保存的视频文件播放速度太快原因
weixin_42717961的博客
01-08 8286
今天偶然发现自己使用ffmepg从摄像头采集然后保存文件，使用播放器播放，速度很快，网上查了很多资料都说是帧率的问题，可特么倒是说明白啊，帧率帧率，你倒是说明白帧率错在哪啊。最后自己摸索，发现所谓的帧率问题都是人云亦云。真正的原因并不是帧率问题，准确说是输入文件的帧率需要和输出文件的帧率要一致，如果不一致就会出现视频文件播放过慢或者过快的问题。 下面举1个李子： 1：输入文件是摄像头 1....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值