FFmpeg将多张图片编码成视频-创新互联

前言

本篇文章的需求是将相机获取到的图片进行编码，编码成一个视频，耗费了大约一个星期的时间在解决各种问题。这里阐述一下这篇文章所要解决的几个问题：

成都网络公司-成都网站建设公司创新互联建站十多年经验成就非凡，专业从事网站建设、成都做网站，成都网页设计，成都网页制作，软文发稿，广告投放平台等。十多年来已成功提供全面的成都网站建设方案，打造行业特色的成都网站建设案例，建站热线：18980820575，我们期待您的来电！

1、如何将多张图片编码成视频。

2、如何进行定时录制视频。

3、同时开启多线程进行视频录制。

4、对录制文件目录进行管理：每次都检测录制目录大小是否超过指定大小，如果超过，则删除指定大小的时间最早的一些文件。

正文 一、准备工作 1、下载FFmpeg的开发版

1、下载链接： https://ffmpeg.org/download.html

2、

3、

4、由于我是在Win10下，所以选择：

2、使用环境

Win10 + Qt8.0.2(MSVC2019) + FFmpeg 4.4

二、整体流程解析

上面的流程图，基本上就是这次这个项目的整体流程了，上面的 2 3 4点都是在单例层完成的。只有第一点是在FFmpegRecord那一层完成的。

三、单例模式——多线程视频录制

首先，确定目标，我是要“同时录制多个视频”，所以，必须得开多个线程，并且，在这一层，就必须要完成：

1、给上层应用的调用提供一个接口。

2、进行定时关闭录制的操作。

3、对底层FFmpegRecord对象进行管理。

4、对录制文件进行管理——在开启录制的时候，检测当前目录文件的大小。

先给出开录制与关录制中整体的代码，然后再慢慢进行解释吧.

//开启录制的接口
QString CRecordMgr::StartRecord(eRecordType eType, QString sFileName, int iRecordSTime)
{QMutexLocker oLocker(&m_mutex);
    QString sPath = "/myPath/recordfile";
    quint64 iCountByte = _DetectDiskInfo(sPath);//检测某文件路径下的所有文件字节数

    //当这个字节数大于某个指定的值得时候
    if (iCountByte >DetectMinMB*1024*1024)
    {_RemoveRecordFile(sPath);//移除时间最早的500MB的文件
        QThread::msleep(1000);
    }

    if (sFileName.isEmpty())
    {qint64 timestamp = QDateTime::currentDateTime().toSecsSinceEpoch();
        sFileName = QString("%1.mp4").arg(timestamp);
    }

    
    _PreActionStart();//开启要传图过来的相机
    QString sMissionId = CCommonFunc::CreateUUID();
    CFFmpegRecord *pFFmpegRecord = new CFFmpegRecord();//创建对象

    if (pFFmpegRecord)
    {pFFmpegRecord->setObjectName(sMissionId);//设置对象名词

        m_mapFFmpegRecord.insert(sMissionId, pFFmpegRecord);
        m_mapRecordFileName.insert(sMissionId, sFileName);
        m_mapRecordType.insert(sMissionId, eType);

        pFFmpegRecord->SetMissionId(sMissionId);
        pFFmpegRecord->SetRecordType((CFFmpegRecord::eRecordType)eType);
        pFFmpegRecord->SetRecordFileName(sFileName);
        pFFmpegRecord->SetRecordTime(iRecordSTime);
        pFFmpegRecord->Init();

        //为这个对象创建一个定时器   
        m_pRecordTimer = new QTimer(this);
        m_pRecordTimer->setSingleShot(true);
        m_pRecordTimer->setObjectName(sMissionId);
        connect(m_pRecordTimer, &QTimer::timeout, this, &CRecordMgr::SLOT_StopRecord);//超时了就调用对应的槽函数
        m_mapTimer.insert(sMissionId, m_pRecordTimer);

        QtConcurrent::run([this,iRecordSTime](){if (m_pRecordTimer)
            {QMetaObject::invokeMethod(m_pRecordTimer, "start", Qt::QueuedConnection,
                                          Q_ARG(int, iRecordSTime*1000));
            }
        });

        //将外部传入的信号传入编码的代码中
        m_oConnect = connect(gVideoMgr::instance(), &CVideoMgr::SIGNAL_CommonCameraImage,pFFmpegRecord, &CFFmpegRecord::SLOT_FFmpegImage, Qt::QueuedConnection);
        m_mapConnect.insert(sMissionId, m_oConnect);
    }

    return sMissionId;
}

//使用任务Id对录制任务进行关闭

bool CRecordMgr::StopRecord(QString sId)
{
CFFmpegRecord *pFFmpegRecord = m_mapFFmpegRecord.value(sId);

if (pFFmpegRecord)
{
    pFFmpegRecord->StopRecord();//对底下的录制任务进行关闭
    QThread::msleep(500);
    QMetaObject::Connection oConnect = m_mapConnect.value(sId);
    disconnect(oConnect);

    CRecordMgr::eRecordType eRecordType = m_mapRecordType.value(sId);
    QString sFileName = m_mapRecordFileName.value(sId);
    QTimer *pTimer = m_mapTimer.value(sId);

    if (pTimer && pTimer->isActive())
        pTimer->stop();

    if (m_mapFFmpegRecord.size() == 0)
    {
        _PreActionEnd();//当没有任务录制任务的时候，关闭相机
    }

    pFFmpegRecord->deleteLater();//最好使用deletelater() 直接删除，可能此时某些缓存的图片还没传输结束
    pFFmpegRecord = nullptr;
    emit SIGNAL_RecordTask_Finished(eRecordType, sId, sFileName);//给外部提供录制结束的接口

    m_mapFFmpegRecord.remove(sId);
    m_mapRecordType.remove(sId);
    m_mapRecordFileName.remove(sId);
    m_mapTimer.remove(sId);
}

return true;

}

1、给上层应用一个开启录制与关闭录制的接口

基本上，就是直接调用就可以了，由于我这边是单例，所以我直接调用接口就可以了，如果你们没有用单例，就看你们怎么设计了。

gRecordMgr::instance->StartRecord(eAlarmRecord, "");
gRecordMgr::instance->StopRecord();

2、定时录制的功能

定时录制，最开始是在最底层去操作的，也就是在FFmpegRecord层去操作的，结果至少花费了我一天多的时间在找出问题的所在，明明定时器的设置，定时器的触发都很简单，但就是没办法触发。后面才发觉，原来是最底层的FFmpegRecord还需要去接收外部的图片，基本资源都一直被占用着，所以，根本轮不到定时器的触发，这就很糟糕，所以，最后觉得在RecordMgr层去做定时器的操作，才得以完成。 使用了两种方式，可以使用QTimer, 也可以使用timeEvent,startTimer；其实可能使用startTimer来触发，是更合适的，因为是要有多个定时器的。

方法一

m_pRecordTimer = new QTimer(this);
        m_pRecordTimer->setSingleShot(true);
        m_pRecordTimer->setObjectName(sMissionId);
        connect(m_pRecordTimer, &QTimer::timeout, this, &CRecordMgr::SLOT_StopRecord);//超时了就调用对应的槽函数
        m_mapTimer.insert(sMissionId, m_pRecordTimer);

        QtConcurrent::run([this,iRecordSTime](){if (m_pRecordTimer)
            {QMetaObject::invokeMethod(m_pRecordTimer, "start", Qt::QueuedConnection,
                                          Q_ARG(int, iRecordSTime*1000));
            }
        });

方法二

int iTimerId = startTimer(m_pRecordTimer);

void timeEvent(QTimeEvent *event);

3、对录制对象进行管理

CFFmpegRecord *pFFmpegRecord = new CFFmpegRecord();//创建对象

    if (pFFmpegRecord)
    {pFFmpegRecord->setObjectName(sMissionId);//设置对象名称
        m_mapFFmpegRecord.insert(sMissionId, pFFmpegRecord);//将这个对象，使用QMap进行存储
    }

4、对录制文件进行管理

调用方式：

QString sPath = "/myPath/recordfile";
    quint64 iCountByte = _DetectDiskInfo(sPath);//检测某文件路径下的所有文件字节数

    //当这个字节数大于某个指定的值得时候
    if (iCountByte >DetectMinMB*1024*1024)
    {_RemoveRecordFile(sPath);//移除时间最早的500MB的文件
        QThread::msleep(1000);
    }

具体的函数：

quint64 CRecordMgr::_DetectDiskInfo(QString _sPath)
{QDir dir(_sPath);
    quint64 size = 0;

    foreach(QFileInfo fileInfo, dir.entryInfoList(QDir::Files))
    {//计算文件大小
        size += fileInfo.size();
    }

    foreach(QString subDir, dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot))
    {//若存在子目录，则递归调用dirFileSize()函数
        size += _DetectDiskInfo(_sPath + QDir::separator() + subDir);
    }

    return size;
}

void CRecordMgr::_RemoveRecordFile(QString _sPath)
{QDir dir(_sPath);

    if (!dir.exists())
    {return;
    }

    QStringList lstFileName =_GetFilePath(_sPath);

    QListlistPath;

    for (auto index : lstFileName)
    {listPath.push_back(index);
    }

    qSort(listPath.begin(), listPath.end(),[](const QString &str1, const QString &str2){QStringList lst1 = str1.split("/");
        QStringList lst2 = str2.split("/");
        QString sComStr1 = lst1.last();
        QString sComStr2 = lst2.last();

        if (sComStr1.compare(sComStr2)==0)
            return sComStr1< sComStr2;

        return sComStr1< sComStr2;
    });

    lstFileName.clear();

    for (auto index : listPath)
    {lstFileName.append(index);
    }

    int iFileCount = lstFileName.size();

    qint64 iDeleteSize = 0;
    const qint64 ciSize = 500 * 1024 * 1024; // 每次删除超过500M即停止删除

    for (int i = 0; i< iFileCount; i++)
    {QString sFileName = lstFileName.at(i);
        QFileInfo oFileInfo(sFileName);

        iDeleteSize += oFileInfo.size();
        dir.remove(sFileName);
        lstFileName.pop_back();

        if (iDeleteSize >ciSize)
        {break;
        }
    }
}

QStringList CRecordMgr::_GetFilePath(QString _sPath)
{QStringList listFileInfo;
    QDir dir(_sPath);

    if (!dir.exists())
    {return listFileInfo;
    }

    //获取filePath下所有文件夹和文件
    dir.setFilter(QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot);//文件夹|文件|不包含./和../

    //排序文件夹优先
    dir.setSorting(QDir::DirsFirst);

    //获取文件夹下所有文件(文件夹+文件)
    QFileInfoList list = dir.entryInfoList();

    for (int i = 0; i< list.size(); i++)
    {QFileInfo fileInfo = list.at(i);
        QStringList listSingleFileInfo;
        QString sFilePath = fileInfo.filePath();

        if (fileInfo.isDir())//判断是否为文件夹
        {listSingleFileInfo = _GetFilePath(fileInfo.filePath());//递归开始
            listFileInfo.append(listSingleFileInfo);
        }
        else
        {listFileInfo.append(sFilePath);
        }
    }

    return listFileInfo;
}

这部分的内容，基本上移植是比较方便的，注意使用环境是在Arm上的，未尝试过在windows环境进行操作。

四、FFmpegRecord编码层

老规矩，先把整体的代码贴出来，后面再详细解释一下。

CFFmpegRecord::CFFmpegRecord(QObject *parent) : QObject(parent)
{}

CFFmpegRecord::~CFFmpegRecord()
{LOG_INFO<< "-->~CFFmpegRecord Start";
    av_free(m_pBuffer);
    av_free(m_pYuvBuffer);
    sws_freeContext(m_SwsImgCtx);

    if (m_pOutPutFormatCtx)
    {avio_close(m_pOutPutFormatCtx->pb);
        avformat_free_context(m_pOutPutFormatCtx);
    }

    if (m_pEncodecCtx)
        avcodec_free_context(&m_pEncodecCtx);

    if (m_pRgbFrame)
        av_frame_free(&m_pRgbFrame);

    if (m_pYuvFrame)
        av_frame_free(&m_pYuvFrame);

    m_pYuvBuffer = nullptr;
    m_pBuffer = nullptr;
    m_SwsImgCtx = nullptr;
    m_pRgbFrame = nullptr;
    m_pYuvFrame = nullptr;
    m_pOutPutFormatCtx = nullptr;
    m_pEncodecCtx = nullptr;

    if (m_pThread)
    {m_pThread->quit();
        m_pThread->exit();
    }

    LOG_INFO<< "-->~CFFmpegRecord End";
}

void CFFmpegRecord::Init()
{m_pThread = new QThread();
    m_pThread->setObjectName("CFFmpegRecord");
    this->moveToThread(m_pThread);
    m_pThread->start();
    m_bExitThread = false;
}

void CFFmpegRecord::InitFFmpeg()
{int ret = 0;
    m_iPerFrameCnt = 10;
    m_iIndex = 0;
    m_pEnPacket = av_packet_alloc();
    string sRecordName = m_sRecordFileName.toStdString();
    m_cRecordFileName = sRecordName.c_str();

    ret = avformat_alloc_output_context2(&m_pOutPutFormatCtx, NULL, NULL, m_cRecordFileName);

    if (ret< 0)
    {LOG_INFO<< "Cannot alloc output file context";
        return;
    }

    ret = avio_open(&m_pOutPutFormatCtx->pb, m_cRecordFileName, AVIO_FLAG_READ_WRITE);

    if (ret< 0)
    {LOG_INFO<< "output file open failed";
        return;
    }

    pEncodec = avcodec_find_encoder(AV_CODEC_ID_H264);

    if (pEncodec == NULL)
    {LOG_INFO<< "Cannot find any endcoder";
        return;
    }

    m_pEncodecCtx = avcodec_alloc_context3(pEncodec);

    if (m_pEncodecCtx == NULL)
    {LOG_INFO<< "Cannot alloc AVCodecContext";
        return;
    }

    m_pVideoStream = avformat_new_stream(m_pOutPutFormatCtx, pEncodec);

    if (m_pVideoStream == NULL) {LOG_INFO<< "failed create new video stream";
        return;
    }

    m_pVideoStream->time_base = AVRational{1,10 };

    m_pCodecParam = m_pVideoStream->codecpar;
    m_pCodecParam->width = m_iWidth;
    m_pCodecParam->height = m_iHeight;
    m_pCodecParam->codec_type = AVMEDIA_TYPE_VIDEO;

    ret = avcodec_parameters_to_context(m_pEncodecCtx, m_pCodecParam);

    if (ret< 0)
    {LOG_INFO<< "Cannot copy codec para";
        return;
    }

    m_pEncodecCtx->pix_fmt = AV_PIX_FMT_YUV420P;
    m_pEncodecCtx->time_base = AVRational{1,10 };
    m_pEncodecCtx->bit_rate = 500000;
    m_pEncodecCtx->gop_size = 100;

    // 某些封装格式必须要设置该标志，否则会造成封装后文件中信息的缺失,如：mp4
    if (m_pOutPutFormatCtx->oformat->flags & AVFMT_GLOBALHEADER)
    {m_pEncodecCtx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
    }

    AVDictionary *param = 0;

    if (pEncodec->id == AV_CODEC_ID_H264)
    {m_pEncodecCtx->qmin = 10;
        m_pEncodecCtx->qmax = 51;
        m_pEncodecCtx->qcompress = (float)0.6;
        m_pEncodecCtx->max_b_frames = 0;

        av_dict_set(¶m, "preset", "fast", 0);
        av_dict_set(¶m, "tune", "zerolatency", 0);
    }

    ret = avcodec_open2(m_pEncodecCtx, pEncodec, ¶m);

    if (ret< 0)
    {LOG_INFO<< "Open encoder failed";
        return;
    }

    //再将codecCtx设置的参数传给param，用于写入头文件信息
    avcodec_parameters_from_context(m_pCodecParam, m_pEncodecCtx);

    m_pRgbFrame = av_frame_alloc();
    m_pYuvFrame = av_frame_alloc();

    m_pYuvFrame->width = m_iWidth;
    m_pYuvFrame->height = m_iHeight;
    m_pYuvFrame->format = m_pEncodecCtx->pix_fmt;

    m_pRgbFrame->width = m_iWidth;
    m_pRgbFrame->height = m_iHeight;
    m_pRgbFrame->format = AV_PIX_FMT_BGR24;

    m_iBufferSize = av_image_get_buffer_size((AVPixelFormat)m_pRgbFrame->format, m_iWidth, m_iHeight, 1);
    m_pBuffer = (uint8_t*)av_malloc(m_iBufferSize);
    ret = av_image_fill_arrays(m_pRgbFrame->data, m_pRgbFrame->linesize, m_pBuffer, (AVPixelFormat)m_pRgbFrame->format, m_iWidth, m_iHeight, 1);

    if (ret< 0)
    {LOG_INFO<< "Cannot filled rgbFrame";
        return;
    }

    int yuvSize = av_image_get_buffer_size((AVPixelFormat)m_pYuvFrame->format, m_iWidth, m_iHeight, 1);
    m_pYuvBuffer = (uint8_t*)av_malloc(yuvSize);

    ret = av_image_fill_arrays(m_pYuvFrame->data, m_pYuvFrame->linesize, m_pYuvBuffer, (AVPixelFormat)m_pYuvFrame->format, m_iWidth, m_iHeight, 1);

    if (ret< 0)
    {LOG_INFO<< "Cannot filled yuvFrame";
        return;
    }

    m_SwsImgCtx = sws_getContext(m_iWidth, m_iHeight, AV_PIX_FMT_BGR24, m_iWidth, m_iHeight, m_pEncodecCtx->pix_fmt, 0, NULL, NULL, NULL);

    ret = avformat_write_header(m_pOutPutFormatCtx, NULL);

    if (ret != AVSTREAM_INIT_IN_WRITE_HEADER)
    {LOG_INFO<< "Write file header fail";
        return;
    }

    av_new_packet(m_pEnPacket, m_iBufferSize);
}

void CFFmpegRecord::SetMissionId(QString _sMissionId)
{m_sMissionId = _sMissionId;
}

void CFFmpegRecord::SetRecordType(eRecordType eType)
{m_iRecordType = eType;
}

void CFFmpegRecord::SetRecordFileName(QString _sFileName)
{QString sRecordDir;
    QDir dir;
    switch (m_iRecordType) {case eAlarmRecord:
    {sRecordDir = QString("/ics/recordfile/alarm/");

        if (!dir.exists(sRecordDir))
        {dir.mkpath(sRecordDir);
        }
        m_sRecordFileName = sRecordDir.append(_sFileName);
    }
        break;
    case eOperateRecord:
    {sRecordDir = QString("/ics/recordfile/operate/");

        if (!dir.exists(sRecordDir))
        {dir.mkpath(sRecordDir);
        }

        m_sRecordFileName = sRecordDir.append(_sFileName);
    }
        break;
    case eTakeRecord:
    {sRecordDir = QString("/ics/recordfile/take/");

        if (!dir.exists(sRecordDir))
        {dir.mkpath(sRecordDir);
        }

        m_sRecordFileName = sRecordDir.append(_sFileName);
    }
        break;
    case eReturnRecord:
    {sRecordDir = QString("/ics/recordfile/return/");

        if (!dir.exists(sRecordDir))
        {dir.mkpath(sRecordDir);
        }

        m_sRecordFileName = sRecordDir.append(_sFileName);
    }
        break;
    default:
        break;
    }

    LOG_INFO<< "-->CFFmpegRecord::SetRecordFileName FileName:"<m_iRecordTime = _iRecordTime;
}

void CFFmpegRecord::StopRecord()
{m_bExitThread = true;
}

void CFFmpegRecord::writeImageToMp4(QImage _img)
{DLOG_TRACE<<"-->CFFmpegRecord::writeImageToMp4 start";
    QTime time;
    time.start();

    if (_img.isNull())
    {LOG_INFO<< "-->writeImageToMp4 img is NULL";
        return;
    }

    Mat img = QImage2Mat(_img);
    memcpy(m_pBuffer, img.data, m_iBufferSize);
    sws_scale(m_SwsImgCtx,
              m_pRgbFrame->data,
              m_pRgbFrame->linesize,
              0,
              m_pEncodecCtx->height,
              m_pYuvFrame->data,
              m_pYuvFrame->linesize);

    m_iIndex ++;
    m_pYuvFrame->pts = m_iIndex;
    rgb2mp4Encode(m_pEncodecCtx, m_pYuvFrame, m_pEnPacket, m_pVideoStream, m_pOutPutFormatCtx);

    DLOG_TRACE<<"-->CFFmpegRecord::writeImageToMp4 end"<cv::Mat mat;

    switch (_img.format())
    {case QImage::Format_ARGB32:
    case QImage::Format_RGB32:
    case QImage::Format_ARGB32_Premultiplied:
        mat = cv::Mat(_img.height(), _img.width(), CV_8UC4, (void*)_img.constBits(), _img.bytesPerLine());
        break;
    case QImage::Format_RGB888:
        mat = cv::Mat(_img.height(), _img.width(), CV_8UC3, (void*)_img.constBits(), _img.bytesPerLine());
        cv::cvtColor(mat, mat, CV_BGR2RGB);
        break;
    case QImage::Format_Indexed8:
        mat = cv::Mat(_img.height(), _img.width(), CV_8UC1, (void*)_img.constBits(), _img.bytesPerLine());
        break;
    }
    return mat;
}

int CFFmpegRecord::rgb2mp4Encode(AVCodecContext* codecCtx, AVFrame* yuvFrame, AVPacket* pkt, AVStream* vStream, AVFormatContext* fmtCtx)
{int ret = 0;

    if (avcodec_send_frame(codecCtx, yuvFrame) >= 0)
    {while (avcodec_receive_packet(codecCtx, pkt) >= 0)
        {pkt->stream_index = vStream->index;
            pkt->pos = -1;

            av_packet_rescale_ts(pkt, codecCtx->time_base, vStream->time_base);
            DLOG_TRACE<< "encoder success:"<< pkt->size<< endl;

            ret = av_interleaved_write_frame(fmtCtx, pkt);

            if (ret< 0)
            {char errStr[256];
                av_strerror(ret, errStr, 256);
                DLOG_TRACE<< "error is:"<< errStr<< endl;
            }
        }
    }
    return ret;
}

void CFFmpegRecord::SLOT_FFmpegImage(const QByteArray &_oYuv420, int _iWidth, int _iHeight)
{QMutexLocker oLocker(&m_mutex);
    DLOG_TRACE<< "-->CFFmpegRecord::SLOT_FFmpegImage Start";

    QTime time;
    time.start();

    m_iWidth = _iWidth;
    m_iHeight = _iHeight;

    if (nullptr == m_pRGBData)
    {m_pRGBData = new uchar[_iWidth * _iHeight * 3];
        m_oImage = std::move(QImage(m_pRGBData, _iWidth, _iHeight, QImage::Format_RGB888));
    }

    CPixelFormatConverter::YUV420ToRGB24((uchar*)_oYuv420.data(), _iWidth, _iHeight, &m_pRGBData);

    if (false == m_bInit)
    {InitFFmpeg();
        m_bInit = true;
    }

    if (!m_bExitThread)
    {writeImageToMp4(m_oImage);
    }

    if (m_bExitThread && m_bExit)
    {rgb2mp4Encode(m_pEncodecCtx, NULL, m_pEnPacket, m_pVideoStream, m_pOutPutFormatCtx);
        av_write_trailer(m_pOutPutFormatCtx);
        m_bExit = false;
    }

    LOG_INFO<< "-->CFFmpegRecord::SLOT_FFmpegImage End Time is :"<

参考

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧

分享名称：FFmpeg将多张图片编码成视频-创新互联
文章路径：http://bjjierui.cn/article/djdgcd.html