|
|
#include "nmFFmpegVideoWriter.h"
|
|
|
|
|
|
#include <QCoreApplication>
|
|
|
#include <QFile>
|
|
|
#include <QFileInfo>
|
|
|
#include <QtGlobal>
|
|
|
|
|
|
#ifdef NM_ENABLE_FFMPEG_VIDEO_EXPORT
|
|
|
|
|
|
#ifndef __STDC_CONSTANT_MACROS
|
|
|
#define __STDC_CONSTANT_MACROS
|
|
|
#endif
|
|
|
|
|
|
extern "C" {
|
|
|
#include <libavcodec/avcodec.h>
|
|
|
#include <libavformat/avformat.h>
|
|
|
#include <libavutil/avutil.h>
|
|
|
#include <libavutil/error.h>
|
|
|
#include <libavutil/mathematics.h>
|
|
|
#include <libavutil/mem.h>
|
|
|
#include <libavutil/pixfmt.h>
|
|
|
#include <libswscale/swscale.h>
|
|
|
}
|
|
|
|
|
|
#include <errno.h>
|
|
|
#include <limits.h>
|
|
|
#include <stdio.h>
|
|
|
|
|
|
#endif
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
QString writerText(const char* pText)
|
|
|
{
|
|
|
return QCoreApplication::translate("nmFFmpegVideoWriter", pText);
|
|
|
}
|
|
|
|
|
|
QString normalizedExtension(const QString& sExtension)
|
|
|
{
|
|
|
QString sNormalized = sExtension.trimmed().toLower();
|
|
|
if(sNormalized.startsWith('.')) {
|
|
|
sNormalized.remove(0, 1);
|
|
|
}
|
|
|
return sNormalized;
|
|
|
}
|
|
|
|
|
|
#ifdef NM_ENABLE_FFMPEG_VIDEO_EXPORT
|
|
|
|
|
|
struct VideoFormatSpec
|
|
|
{
|
|
|
const char* m_pExtension;
|
|
|
const char* m_pMuxerName;
|
|
|
AVCodecID m_eCodecId;
|
|
|
const char* m_pCodecName;
|
|
|
const char* m_pEncoderName;
|
|
|
AVPixelFormat m_ePixelFormat;
|
|
|
bool m_bMjpeg;
|
|
|
};
|
|
|
|
|
|
// 产品对外承诺的格式、容器和编码器是固定组合，能力探测与实际打开均使用此表。
|
|
|
const VideoFormatSpec g_oFormatSpecs[] =
|
|
|
{
|
|
|
{ "mp4", "mp4", AV_CODEC_ID_MPEG4, "mpeg4", nullptr,
|
|
|
AV_PIX_FMT_YUV420P, false },
|
|
|
{ "avi", "avi", AV_CODEC_ID_MJPEG, "mjpeg", nullptr,
|
|
|
AV_PIX_FMT_YUVJ422P, true },
|
|
|
{ "mov", "mov", AV_CODEC_ID_MPEG4, "mpeg4", nullptr,
|
|
|
AV_PIX_FMT_YUV420P, false },
|
|
|
{ "mpg", "mpeg", AV_CODEC_ID_MPEG2VIDEO, "mpeg2video", nullptr,
|
|
|
AV_PIX_FMT_YUV420P, false },
|
|
|
{ "webm", "webm", AV_CODEC_ID_VP8, "vp8", "libvpx",
|
|
|
AV_PIX_FMT_YUV420P, false },
|
|
|
{ "mkv", "matroska", AV_CODEC_ID_MPEG4, "mpeg4", nullptr,
|
|
|
AV_PIX_FMT_YUV420P, false },
|
|
|
{ "wmv", "asf", AV_CODEC_ID_WMV2, "wmv2", nullptr,
|
|
|
AV_PIX_FMT_YUV420P, false },
|
|
|
{ "flv", "flv", AV_CODEC_ID_FLV1, "flv", nullptr,
|
|
|
AV_PIX_FMT_YUV420P, false }
|
|
|
};
|
|
|
|
|
|
const int FORMAT_SPEC_COUNT =
|
|
|
sizeof(g_oFormatSpecs) / sizeof(g_oFormatSpecs[0]);
|
|
|
|
|
|
const VideoFormatSpec* findFormatSpec(const QString& sExtension)
|
|
|
{
|
|
|
const QByteArray aExtension =
|
|
|
normalizedExtension(sExtension).toLatin1();
|
|
|
for(int nIndex = 0; nIndex < FORMAT_SPEC_COUNT; ++nIndex) {
|
|
|
if(aExtension == g_oFormatSpecs[nIndex].m_pExtension) {
|
|
|
return &g_oFormatSpecs[nIndex];
|
|
|
}
|
|
|
}
|
|
|
return nullptr;
|
|
|
}
|
|
|
|
|
|
AVCodec* findEncoder(const VideoFormatSpec& oSpec)
|
|
|
{
|
|
|
return oSpec.m_pEncoderName != nullptr
|
|
|
? avcodec_find_encoder_by_name(oSpec.m_pEncoderName)
|
|
|
: avcodec_find_encoder(oSpec.m_eCodecId);
|
|
|
}
|
|
|
|
|
|
const char* requestedEncoderName(const VideoFormatSpec& oSpec)
|
|
|
{
|
|
|
return oSpec.m_pEncoderName != nullptr
|
|
|
? oSpec.m_pEncoderName : oSpec.m_pCodecName;
|
|
|
}
|
|
|
|
|
|
QString ffmpegErrorText(int nError)
|
|
|
{
|
|
|
char pBuffer[256] = { 0 };
|
|
|
if(av_strerror(nError, pBuffer, sizeof(pBuffer)) == 0) {
|
|
|
return QString::fromLocal8Bit(pBuffer);
|
|
|
}
|
|
|
return writerText("Unknown FFmpeg error.");
|
|
|
}
|
|
|
|
|
|
int ffmpegMajorVersion(unsigned nVersion)
|
|
|
{
|
|
|
return static_cast<int>((nVersion >> 16) & 0xffU);
|
|
|
}
|
|
|
|
|
|
bool inspectBackend(QString& sError)
|
|
|
{
|
|
|
// 读取实际加载的DLL版本，不使用编译期宏代替运行时ABI校验。
|
|
|
const int nAvformatMajor = ffmpegMajorVersion(avformat_version());
|
|
|
const int nAvcodecMajor = ffmpegMajorVersion(avcodec_version());
|
|
|
const int nAvutilMajor = ffmpegMajorVersion(avutil_version());
|
|
|
const int nSwscaleMajor = ffmpegMajorVersion(swscale_version());
|
|
|
if(nAvformatMajor != 54 || nAvcodecMajor != 54 ||
|
|
|
nAvutilMajor != 52 || nSwscaleMajor != 2) {
|
|
|
sError = writerText(
|
|
|
"The FFmpeg runtime is incompatible. Expected "
|
|
|
"avformat/avcodec/avutil/swscale major versions 54/54/52/2, "
|
|
|
"but found %1/%2/%3/%4.")
|
|
|
.arg(nAvformatMajor)
|
|
|
.arg(nAvcodecMajor)
|
|
|
.arg(nAvutilMajor)
|
|
|
.arg(nSwscaleMajor);
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
av_register_all();
|
|
|
for(int nIndex = 0; nIndex < FORMAT_SPEC_COUNT; ++nIndex) {
|
|
|
const VideoFormatSpec& oSpec = g_oFormatSpecs[nIndex];
|
|
|
AVOutputFormat* pMuxer = av_guess_format(
|
|
|
oSpec.m_pMuxerName, nullptr, nullptr);
|
|
|
if(pMuxer == nullptr) {
|
|
|
sError = writerText(
|
|
|
"Video format .%1 is unavailable because muxer \"%2\" is missing.")
|
|
|
.arg(QString::fromLatin1(oSpec.m_pExtension))
|
|
|
.arg(QString::fromLatin1(oSpec.m_pMuxerName));
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
AVCodec* pEncoder = findEncoder(oSpec);
|
|
|
if(pEncoder == nullptr || pEncoder->id != oSpec.m_eCodecId) {
|
|
|
sError = writerText(
|
|
|
"Video format .%1 is unavailable because encoder \"%2\" is missing.")
|
|
|
.arg(QString::fromLatin1(oSpec.m_pExtension))
|
|
|
.arg(QString::fromLatin1(requestedEncoderName(oSpec)));
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
const int nCodecSupport = avformat_query_codec(
|
|
|
pMuxer, oSpec.m_eCodecId, FF_COMPLIANCE_NORMAL);
|
|
|
// FFmpeg 1.1中负值表示无法判断；只有明确返回0时才能认定组合不受支持。
|
|
|
if(nCodecSupport == 0) {
|
|
|
sError = writerText(
|
|
|
"Video format .%1 is unavailable because muxer \"%2\" "
|
|
|
"does not support codec \"%3\".")
|
|
|
.arg(QString::fromLatin1(oSpec.m_pExtension))
|
|
|
.arg(QString::fromLatin1(oSpec.m_pMuxerName))
|
|
|
.arg(QString::fromLatin1(oSpec.m_pCodecName));
|
|
|
return false;
|
|
|
}
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
#endif
|
|
|
|
|
|
}
|
|
|
|
|
|
nmFFmpegVideoWriter::VideoSettings::VideoSettings()
|
|
|
: m_nWidth(0),
|
|
|
m_nHeight(0),
|
|
|
m_nFramesPerSecond(0)
|
|
|
{
|
|
|
}
|
|
|
|
|
|
class nmFFmpegVideoWriter::Private
|
|
|
{
|
|
|
public:
|
|
|
enum State
|
|
|
{
|
|
|
State_Closed = 0,
|
|
|
State_Opened,
|
|
|
State_Finished,
|
|
|
State_Failed,
|
|
|
State_Cancelled
|
|
|
};
|
|
|
|
|
|
Private()
|
|
|
: m_eState(State_Closed),
|
|
|
m_nWidth(0),
|
|
|
m_nHeight(0),
|
|
|
m_nFramesPerSecond(0),
|
|
|
m_nFrameNumber(0)
|
|
|
#ifdef NM_ENABLE_FFMPEG_VIDEO_EXPORT
|
|
|
, m_pFormatContext(nullptr),
|
|
|
m_pStream(nullptr),
|
|
|
m_pCodecContext(nullptr),
|
|
|
m_pCodec(nullptr),
|
|
|
m_pFrame(nullptr),
|
|
|
m_pScaleContext(nullptr),
|
|
|
m_pAvioContext(nullptr),
|
|
|
m_bCodecOpened(false),
|
|
|
m_bPictureAllocated(false),
|
|
|
m_bMjpeg(false)
|
|
|
#endif
|
|
|
{
|
|
|
}
|
|
|
|
|
|
State m_eState;
|
|
|
QString m_sTemporaryFilePath;
|
|
|
QString m_sExtension;
|
|
|
int m_nWidth;
|
|
|
int m_nHeight;
|
|
|
int m_nFramesPerSecond;
|
|
|
qint64 m_nFrameNumber;
|
|
|
|
|
|
#ifdef NM_ENABLE_FFMPEG_VIDEO_EXPORT
|
|
|
AVFormatContext* m_pFormatContext;
|
|
|
AVStream* m_pStream;
|
|
|
AVCodecContext* m_pCodecContext;
|
|
|
AVCodec* m_pCodec;
|
|
|
AVFrame* m_pFrame;
|
|
|
SwsContext* m_pScaleContext;
|
|
|
AVIOContext* m_pAvioContext;
|
|
|
QFile m_oFile;
|
|
|
bool m_bCodecOpened;
|
|
|
bool m_bPictureAllocated;
|
|
|
bool m_bMjpeg;
|
|
|
|
|
|
static int writePacketCallback(void* pOpaque,
|
|
|
uint8_t* pBuffer,
|
|
|
int nBufferSize)
|
|
|
{
|
|
|
Private* pPrivate = static_cast<Private*>(pOpaque);
|
|
|
if(pPrivate == nullptr || pBuffer == nullptr || nBufferSize < 0 ||
|
|
|
!pPrivate->m_oFile.isOpen()) {
|
|
|
return AVERROR(EIO);
|
|
|
}
|
|
|
|
|
|
// QFile可能只写入部分数据，必须循环到整包落盘；0同样视为IO失败。
|
|
|
qint64 nWrittenTotal = 0;
|
|
|
while(nWrittenTotal < nBufferSize) {
|
|
|
const qint64 nWritten = pPrivate->m_oFile.write(
|
|
|
reinterpret_cast<const char*>(pBuffer) +
|
|
|
nWrittenTotal,
|
|
|
nBufferSize - nWrittenTotal);
|
|
|
if(nWritten <= 0) {
|
|
|
return AVERROR(EIO);
|
|
|
}
|
|
|
nWrittenTotal += nWritten;
|
|
|
}
|
|
|
return nBufferSize;
|
|
|
}
|
|
|
|
|
|
static int64_t seekCallback(void* pOpaque,
|
|
|
int64_t nOffset,
|
|
|
int nWhence)
|
|
|
{
|
|
|
Private* pPrivate = static_cast<Private*>(pOpaque);
|
|
|
if(pPrivate == nullptr || !pPrivate->m_oFile.isOpen()) {
|
|
|
return AVERROR(EIO);
|
|
|
}
|
|
|
|
|
|
// MP4/MOV会在Trailer阶段回写文件头，因此自定义IO必须完整支持Seek。
|
|
|
const int nCleanWhence = nWhence & ~AVSEEK_FORCE;
|
|
|
if(nCleanWhence == AVSEEK_SIZE) {
|
|
|
return pPrivate->m_oFile.size();
|
|
|
}
|
|
|
|
|
|
qint64 nBase = 0;
|
|
|
if(nCleanWhence == SEEK_CUR) {
|
|
|
nBase = pPrivate->m_oFile.pos();
|
|
|
} else if(nCleanWhence == SEEK_END) {
|
|
|
nBase = pPrivate->m_oFile.size();
|
|
|
} else if(nCleanWhence != SEEK_SET) {
|
|
|
return AVERROR(EINVAL);
|
|
|
}
|
|
|
|
|
|
if((nOffset > 0 && nBase > LLONG_MAX - nOffset) ||
|
|
|
(nOffset < 0 && nOffset < -nBase)) {
|
|
|
return AVERROR(EINVAL);
|
|
|
}
|
|
|
const qint64 nTarget = nBase + nOffset;
|
|
|
if(nTarget < 0 || !pPrivate->m_oFile.seek(nTarget)) {
|
|
|
return AVERROR(EIO);
|
|
|
}
|
|
|
return pPrivate->m_oFile.pos();
|
|
|
}
|
|
|
|
|
|
bool writeEncodedPacket(AVPacket& oPacket, QString* pError)
|
|
|
{
|
|
|
// 正常编码和刷新编码器产生的Packet统一在此换算到流时间基。
|
|
|
oPacket.stream_index = m_pStream->index;
|
|
|
if(oPacket.pts != AV_NOPTS_VALUE) {
|
|
|
oPacket.pts = av_rescale_q(
|
|
|
oPacket.pts,
|
|
|
m_pCodecContext->time_base,
|
|
|
m_pStream->time_base);
|
|
|
}
|
|
|
if(oPacket.dts != AV_NOPTS_VALUE) {
|
|
|
oPacket.dts = av_rescale_q(
|
|
|
oPacket.dts,
|
|
|
m_pCodecContext->time_base,
|
|
|
m_pStream->time_base);
|
|
|
}
|
|
|
oPacket.duration = av_rescale_q(
|
|
|
1, m_pCodecContext->time_base,
|
|
|
m_pStream->time_base);
|
|
|
|
|
|
const int nResult = av_interleaved_write_frame(
|
|
|
m_pFormatContext, &oPacket);
|
|
|
// FFmpeg n1.1在函数返回时已经接管Packet数据，无论返回值如何均不得释放。
|
|
|
if(nResult < 0) {
|
|
|
if(pError != nullptr) {
|
|
|
*pError = writerText("Unable to write the encoded video packet: %1")
|
|
|
.arg(ffmpegErrorText(nResult));
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
bool flushEncoder(QString* pError)
|
|
|
{
|
|
|
if(m_pCodec == nullptr ||
|
|
|
(m_pCodec->capabilities & CODEC_CAP_DELAY) == 0) {
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
for(;;) {
|
|
|
AVPacket oPacket;
|
|
|
av_init_packet(&oPacket);
|
|
|
oPacket.data = nullptr;
|
|
|
oPacket.size = 0;
|
|
|
int nGotPacket = 0;
|
|
|
const int nResult = avcodec_encode_video2(
|
|
|
m_pCodecContext, &oPacket, nullptr, &nGotPacket);
|
|
|
if(nResult < 0) {
|
|
|
av_free_packet(&oPacket);
|
|
|
if(pError != nullptr) {
|
|
|
*pError = writerText("Unable to flush the video encoder: %1")
|
|
|
.arg(ffmpegErrorText(nResult));
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
if(nGotPacket == 0) {
|
|
|
av_free_packet(&oPacket);
|
|
|
return true;
|
|
|
}
|
|
|
// 写入函数被调用后Muxer已接管Packet，返回失败时也不能再次释放。
|
|
|
if(!writeEncodedPacket(oPacket, pError)) {
|
|
|
return false;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void releaseAvioContext()
|
|
|
{
|
|
|
// 先断开FormatContext，防止后续释放阶段误用已经销毁的自定义AVIO。
|
|
|
if(m_pFormatContext != nullptr) {
|
|
|
m_pFormatContext->pb = nullptr;
|
|
|
}
|
|
|
if(m_pAvioContext != nullptr) {
|
|
|
av_freep(&m_pAvioContext->buffer);
|
|
|
av_freep(&m_pAvioContext);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void releaseCodecAndFormat()
|
|
|
{
|
|
|
if(m_pScaleContext != nullptr) {
|
|
|
sws_freeContext(m_pScaleContext);
|
|
|
m_pScaleContext = nullptr;
|
|
|
}
|
|
|
if(m_pFrame != nullptr) {
|
|
|
if(m_bPictureAllocated) {
|
|
|
avpicture_free(reinterpret_cast<AVPicture*>(m_pFrame));
|
|
|
m_bPictureAllocated = false;
|
|
|
}
|
|
|
av_free(m_pFrame);
|
|
|
m_pFrame = nullptr;
|
|
|
}
|
|
|
if(m_bCodecOpened && m_pCodecContext != nullptr) {
|
|
|
avcodec_close(m_pCodecContext);
|
|
|
m_bCodecOpened = false;
|
|
|
}
|
|
|
if(m_pFormatContext != nullptr) {
|
|
|
avformat_free_context(m_pFormatContext);
|
|
|
m_pFormatContext = nullptr;
|
|
|
}
|
|
|
m_pStream = nullptr;
|
|
|
m_pCodecContext = nullptr;
|
|
|
m_pCodec = nullptr;
|
|
|
}
|
|
|
|
|
|
void abortAndRemoveTemporaryFile()
|
|
|
{
|
|
|
// 取消和失败不写Trailer，也绝不进入最终文件发布事务。
|
|
|
releaseAvioContext();
|
|
|
if(m_oFile.isOpen()) {
|
|
|
m_oFile.close();
|
|
|
}
|
|
|
releaseCodecAndFormat();
|
|
|
if(!m_sTemporaryFilePath.isEmpty()) {
|
|
|
QFile::remove(m_sTemporaryFilePath);
|
|
|
}
|
|
|
}
|
|
|
#endif
|
|
|
};
|
|
|
|
|
|
nmFFmpegVideoWriter::nmFFmpegVideoWriter()
|
|
|
: m_pPrivate(new Private())
|
|
|
{
|
|
|
}
|
|
|
|
|
|
nmFFmpegVideoWriter::~nmFFmpegVideoWriter()
|
|
|
{
|
|
|
if(m_pPrivate != nullptr) {
|
|
|
if(m_pPrivate->m_eState == Private::State_Opened) {
|
|
|
cancel();
|
|
|
}
|
|
|
delete m_pPrivate;
|
|
|
m_pPrivate = nullptr;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
bool nmFFmpegVideoWriter::open(
|
|
|
const VideoSettings& oSettings,
|
|
|
QString* pError)
|
|
|
{
|
|
|
if(pError != nullptr) {
|
|
|
pError->clear();
|
|
|
}
|
|
|
if(m_pPrivate == nullptr ||
|
|
|
m_pPrivate->m_eState == Private::State_Opened ||
|
|
|
oSettings.m_sTemporaryFilePath.isEmpty() ||
|
|
|
!isSupportedExtension(oSettings.m_sFileExtension) ||
|
|
|
oSettings.m_nWidth < 2 || oSettings.m_nWidth > 8192 ||
|
|
|
oSettings.m_nHeight < 2 || oSettings.m_nHeight > 8192 ||
|
|
|
(oSettings.m_nWidth % 2) != 0 ||
|
|
|
(oSettings.m_nHeight % 2) != 0 ||
|
|
|
oSettings.m_nFramesPerSecond < 1 ||
|
|
|
oSettings.m_nFramesPerSecond > 5000) {
|
|
|
if(pError != nullptr) {
|
|
|
*pError = writerText("The video encoder settings are invalid.");
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
#ifndef NM_ENABLE_FFMPEG_VIDEO_EXPORT
|
|
|
if(pError != nullptr) {
|
|
|
*pError = writerText("The video encoding components are unavailable.");
|
|
|
}
|
|
|
return false;
|
|
|
#else
|
|
|
QString sBackendError;
|
|
|
if(!isBackendAvailable(&sBackendError)) {
|
|
|
if(pError != nullptr) {
|
|
|
*pError = sBackendError;
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
m_pPrivate->m_sTemporaryFilePath =
|
|
|
QFileInfo(oSettings.m_sTemporaryFilePath).absoluteFilePath();
|
|
|
m_pPrivate->m_sExtension =
|
|
|
normalizedExtension(oSettings.m_sFileExtension);
|
|
|
m_pPrivate->m_nWidth = oSettings.m_nWidth;
|
|
|
m_pPrivate->m_nHeight = oSettings.m_nHeight;
|
|
|
m_pPrivate->m_nFramesPerSecond = oSettings.m_nFramesPerSecond;
|
|
|
m_pPrivate->m_nFrameNumber = 0;
|
|
|
m_pPrivate->m_eState = Private::State_Failed;
|
|
|
|
|
|
const VideoFormatSpec* pSpec =
|
|
|
findFormatSpec(m_pPrivate->m_sExtension);
|
|
|
m_pPrivate->m_pCodec = pSpec == nullptr
|
|
|
? nullptr : findEncoder(*pSpec);
|
|
|
if(pSpec == nullptr || m_pPrivate->m_pCodec == nullptr ||
|
|
|
avformat_alloc_output_context2(
|
|
|
&m_pPrivate->m_pFormatContext, nullptr,
|
|
|
pSpec->m_pMuxerName, nullptr) < 0 ||
|
|
|
m_pPrivate->m_pFormatContext == nullptr) {
|
|
|
if(pError != nullptr) {
|
|
|
*pError = writerText("Unable to initialize the video container.");
|
|
|
}
|
|
|
m_pPrivate->abortAndRemoveTemporaryFile();
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
m_pPrivate->m_pStream = avformat_new_stream(
|
|
|
m_pPrivate->m_pFormatContext, m_pPrivate->m_pCodec);
|
|
|
if(m_pPrivate->m_pStream == nullptr) {
|
|
|
if(pError != nullptr) {
|
|
|
*pError = writerText("Unable to create the video stream.");
|
|
|
}
|
|
|
m_pPrivate->abortAndRemoveTemporaryFile();
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
m_pPrivate->m_pCodecContext = m_pPrivate->m_pStream->codec;
|
|
|
AVCodecContext* pCodecContext = m_pPrivate->m_pCodecContext;
|
|
|
pCodecContext->codec_id = pSpec->m_eCodecId;
|
|
|
pCodecContext->codec_type = AVMEDIA_TYPE_VIDEO;
|
|
|
pCodecContext->width = oSettings.m_nWidth;
|
|
|
pCodecContext->height = oSettings.m_nHeight;
|
|
|
pCodecContext->time_base.num = 1;
|
|
|
pCodecContext->time_base.den = oSettings.m_nFramesPerSecond;
|
|
|
m_pPrivate->m_pStream->time_base = pCodecContext->time_base;
|
|
|
pCodecContext->gop_size = qMax(1, oSettings.m_nFramesPerSecond * 2);
|
|
|
pCodecContext->max_b_frames = 0;
|
|
|
pCodecContext->pix_fmt = pSpec->m_ePixelFormat;
|
|
|
// 以1080p/15 FPS的8 Mbps为基准缩放，计算过程保持64位范围。
|
|
|
const double dScaledBitRate = 8000000.0 *
|
|
|
static_cast<double>(oSettings.m_nWidth) *
|
|
|
static_cast<double>(oSettings.m_nHeight) *
|
|
|
static_cast<double>(oSettings.m_nFramesPerSecond) /
|
|
|
(1920.0 * 1080.0 * 15.0);
|
|
|
const qint64 nBitRate = qBound<qint64>(
|
|
|
500000, static_cast<qint64>(dScaledBitRate + 0.5),
|
|
|
50000000);
|
|
|
pCodecContext->bit_rate = static_cast<int>(nBitRate);
|
|
|
m_pPrivate->m_bMjpeg = pSpec->m_bMjpeg;
|
|
|
if(m_pPrivate->m_bMjpeg) {
|
|
|
pCodecContext->flags |= CODEC_FLAG_QSCALE;
|
|
|
pCodecContext->global_quality = FF_QP2LAMBDA * 2;
|
|
|
}
|
|
|
if((m_pPrivate->m_pFormatContext->oformat->flags &
|
|
|
AVFMT_GLOBALHEADER) != 0) {
|
|
|
pCodecContext->flags |= CODEC_FLAG_GLOBAL_HEADER;
|
|
|
}
|
|
|
|
|
|
int nResult = avcodec_open2(
|
|
|
pCodecContext, m_pPrivate->m_pCodec, nullptr);
|
|
|
if(nResult < 0) {
|
|
|
if(pError != nullptr) {
|
|
|
*pError = writerText("Unable to open the video encoder: %1")
|
|
|
.arg(ffmpegErrorText(nResult));
|
|
|
}
|
|
|
m_pPrivate->abortAndRemoveTemporaryFile();
|
|
|
return false;
|
|
|
}
|
|
|
m_pPrivate->m_bCodecOpened = true;
|
|
|
|
|
|
m_pPrivate->m_pFrame = avcodec_alloc_frame();
|
|
|
if(m_pPrivate->m_pFrame == nullptr ||
|
|
|
avpicture_alloc(
|
|
|
reinterpret_cast<AVPicture*>(m_pPrivate->m_pFrame),
|
|
|
pSpec->m_ePixelFormat,
|
|
|
oSettings.m_nWidth, oSettings.m_nHeight) < 0) {
|
|
|
if(pError != nullptr) {
|
|
|
*pError = writerText("Unable to allocate the video frame buffer.");
|
|
|
}
|
|
|
m_pPrivate->abortAndRemoveTemporaryFile();
|
|
|
return false;
|
|
|
}
|
|
|
m_pPrivate->m_bPictureAllocated = true;
|
|
|
m_pPrivate->m_pFrame->width = oSettings.m_nWidth;
|
|
|
m_pPrivate->m_pFrame->height = oSettings.m_nHeight;
|
|
|
m_pPrivate->m_pFrame->format = pSpec->m_ePixelFormat;
|
|
|
|
|
|
m_pPrivate->m_pScaleContext = sws_getContext(
|
|
|
oSettings.m_nWidth, oSettings.m_nHeight,
|
|
|
AV_PIX_FMT_RGB24,
|
|
|
oSettings.m_nWidth, oSettings.m_nHeight,
|
|
|
pSpec->m_ePixelFormat,
|
|
|
SWS_BILINEAR, nullptr, nullptr, nullptr);
|
|
|
if(m_pPrivate->m_pScaleContext == nullptr) {
|
|
|
if(pError != nullptr) {
|
|
|
*pError = writerText("Unable to initialize the video color conversion.");
|
|
|
}
|
|
|
m_pPrivate->abortAndRemoveTemporaryFile();
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
QFile::remove(m_pPrivate->m_sTemporaryFilePath);
|
|
|
m_pPrivate->m_oFile.setFileName(m_pPrivate->m_sTemporaryFilePath);
|
|
|
if(!m_pPrivate->m_oFile.open(
|
|
|
QIODevice::ReadWrite | QIODevice::Truncate)) {
|
|
|
if(pError != nullptr) {
|
|
|
*pError = writerText("Unable to create the temporary video file.");
|
|
|
}
|
|
|
m_pPrivate->abortAndRemoveTemporaryFile();
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
// QFile负责Unicode路径，FFmpeg只通过自定义AVIO读写，不直接打开文件名。
|
|
|
const int nAvioBufferSize = 32768;
|
|
|
unsigned char* pAvioBuffer = static_cast<unsigned char*>(
|
|
|
av_malloc(nAvioBufferSize));
|
|
|
if(pAvioBuffer != nullptr) {
|
|
|
m_pPrivate->m_pAvioContext = avio_alloc_context(
|
|
|
pAvioBuffer, nAvioBufferSize, 1,
|
|
|
m_pPrivate, nullptr,
|
|
|
&Private::writePacketCallback,
|
|
|
&Private::seekCallback);
|
|
|
}
|
|
|
if(m_pPrivate->m_pAvioContext == nullptr) {
|
|
|
av_free(pAvioBuffer);
|
|
|
if(pError != nullptr) {
|
|
|
*pError = writerText("Unable to initialize the video file output.");
|
|
|
}
|
|
|
m_pPrivate->abortAndRemoveTemporaryFile();
|
|
|
return false;
|
|
|
}
|
|
|
m_pPrivate->m_pAvioContext->seekable = AVIO_SEEKABLE_NORMAL;
|
|
|
m_pPrivate->m_pFormatContext->pb = m_pPrivate->m_pAvioContext;
|
|
|
m_pPrivate->m_pFormatContext->flags |= AVFMT_FLAG_CUSTOM_IO;
|
|
|
|
|
|
// filename仅用于让Muxer识别扩展名；真实输出目标由FormatContext::pb提供。
|
|
|
const QByteArray aPlaceholder =
|
|
|
QString::fromLatin1("output.%1")
|
|
|
.arg(m_pPrivate->m_sExtension).toLatin1();
|
|
|
qstrncpy(m_pPrivate->m_pFormatContext->filename,
|
|
|
aPlaceholder.constData(),
|
|
|
sizeof(m_pPrivate->m_pFormatContext->filename));
|
|
|
nResult = avformat_write_header(
|
|
|
m_pPrivate->m_pFormatContext, nullptr);
|
|
|
if(nResult < 0) {
|
|
|
if(pError != nullptr) {
|
|
|
*pError = writerText("Unable to write the video header: %1")
|
|
|
.arg(ffmpegErrorText(nResult));
|
|
|
}
|
|
|
m_pPrivate->abortAndRemoveTemporaryFile();
|
|
|
return false;
|
|
|
}
|
|
|
m_pPrivate->m_eState = Private::State_Opened;
|
|
|
return true;
|
|
|
#endif
|
|
|
}
|
|
|
|
|
|
bool nmFFmpegVideoWriter::writeRgb24Frame(
|
|
|
const unsigned char* pData,
|
|
|
int nStride,
|
|
|
bool bBottomUp,
|
|
|
QString* pError)
|
|
|
{
|
|
|
if(pError != nullptr) {
|
|
|
pError->clear();
|
|
|
}
|
|
|
if(m_pPrivate == nullptr ||
|
|
|
m_pPrivate->m_eState != Private::State_Opened ||
|
|
|
pData == nullptr || nStride < m_pPrivate->m_nWidth * 3) {
|
|
|
if(pError != nullptr) {
|
|
|
*pError = writerText("The RGB video frame is invalid.");
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
#ifndef NM_ENABLE_FFMPEG_VIDEO_EXPORT
|
|
|
if(pError != nullptr) {
|
|
|
*pError = writerText("The video encoding components are unavailable.");
|
|
|
}
|
|
|
return false;
|
|
|
#else
|
|
|
const uint8_t* pSourceData[4] = { nullptr, nullptr, nullptr, nullptr };
|
|
|
int pSourceStride[4] = { 0, 0, 0, 0 };
|
|
|
pSourceData[0] = bBottomUp
|
|
|
? pData + static_cast<qint64>(m_pPrivate->m_nHeight - 1) *
|
|
|
nStride
|
|
|
: pData;
|
|
|
pSourceStride[0] = bBottomUp ? -nStride : nStride;
|
|
|
const int nScaledRows = sws_scale(
|
|
|
m_pPrivate->m_pScaleContext,
|
|
|
pSourceData, pSourceStride,
|
|
|
0, m_pPrivate->m_nHeight,
|
|
|
m_pPrivate->m_pFrame->data,
|
|
|
m_pPrivate->m_pFrame->linesize);
|
|
|
if(nScaledRows != m_pPrivate->m_nHeight) {
|
|
|
if(pError != nullptr) {
|
|
|
*pError = writerText("Unable to convert the video frame colors.");
|
|
|
}
|
|
|
m_pPrivate->m_eState = Private::State_Failed;
|
|
|
m_pPrivate->abortAndRemoveTemporaryFile();
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
// PTS使用连续输出序号，不能使用被采样的原始结果帧下标。
|
|
|
m_pPrivate->m_pFrame->pts = m_pPrivate->m_nFrameNumber;
|
|
|
if(m_pPrivate->m_bMjpeg) {
|
|
|
m_pPrivate->m_pFrame->quality =
|
|
|
m_pPrivate->m_pCodecContext->global_quality;
|
|
|
}
|
|
|
AVPacket oPacket;
|
|
|
av_init_packet(&oPacket);
|
|
|
oPacket.data = nullptr;
|
|
|
oPacket.size = 0;
|
|
|
int nGotPacket = 0;
|
|
|
const int nResult = avcodec_encode_video2(
|
|
|
m_pPrivate->m_pCodecContext,
|
|
|
&oPacket, m_pPrivate->m_pFrame, &nGotPacket);
|
|
|
if(nResult < 0) {
|
|
|
av_free_packet(&oPacket);
|
|
|
if(pError != nullptr) {
|
|
|
*pError = writerText("Unable to encode the video frame: %1")
|
|
|
.arg(ffmpegErrorText(nResult));
|
|
|
}
|
|
|
m_pPrivate->m_eState = Private::State_Failed;
|
|
|
m_pPrivate->abortAndRemoveTemporaryFile();
|
|
|
return false;
|
|
|
}
|
|
|
++m_pPrivate->m_nFrameNumber;
|
|
|
if(nGotPacket == 0) {
|
|
|
av_free_packet(&oPacket);
|
|
|
return true;
|
|
|
}
|
|
|
if(!m_pPrivate->writeEncodedPacket(oPacket, pError)) {
|
|
|
m_pPrivate->m_eState = Private::State_Failed;
|
|
|
m_pPrivate->abortAndRemoveTemporaryFile();
|
|
|
return false;
|
|
|
}
|
|
|
return true;
|
|
|
#endif
|
|
|
}
|
|
|
|
|
|
bool nmFFmpegVideoWriter::finish(QString* pError)
|
|
|
{
|
|
|
if(pError != nullptr) {
|
|
|
pError->clear();
|
|
|
}
|
|
|
if(m_pPrivate == nullptr ||
|
|
|
m_pPrivate->m_eState != Private::State_Opened) {
|
|
|
if(pError != nullptr) {
|
|
|
*pError = writerText("The video writer is not open.");
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
#ifndef NM_ENABLE_FFMPEG_VIDEO_EXPORT
|
|
|
if(pError != nullptr) {
|
|
|
*pError = writerText("The video encoding components are unavailable.");
|
|
|
}
|
|
|
return false;
|
|
|
#else
|
|
|
// 先离开Opened状态，确保任何失败路径和析构都不会再次执行finish。
|
|
|
m_pPrivate->m_eState = Private::State_Failed;
|
|
|
if(!m_pPrivate->flushEncoder(pError)) {
|
|
|
m_pPrivate->abortAndRemoveTemporaryFile();
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
// Trailer必须在关闭自定义IO前完成，MP4/MOV会在这里Seek并回写文件头。
|
|
|
const int nTrailerResult = av_write_trailer(
|
|
|
m_pPrivate->m_pFormatContext);
|
|
|
avio_flush(m_pPrivate->m_pAvioContext);
|
|
|
const int nAvioError = m_pPrivate->m_pAvioContext->error;
|
|
|
const bool bFileFlushed = m_pPrivate->m_oFile.flush();
|
|
|
m_pPrivate->m_oFile.close();
|
|
|
|
|
|
m_pPrivate->releaseAvioContext();
|
|
|
m_pPrivate->releaseCodecAndFormat();
|
|
|
|
|
|
if(nTrailerResult < 0 || nAvioError != 0 || !bFileFlushed) {
|
|
|
if(pError != nullptr) {
|
|
|
if(nTrailerResult < 0) {
|
|
|
*pError = writerText("Unable to finalize the video container: %1")
|
|
|
.arg(ffmpegErrorText(nTrailerResult));
|
|
|
} else if(nAvioError != 0) {
|
|
|
*pError = writerText("Unable to flush the video output: %1")
|
|
|
.arg(ffmpegErrorText(nAvioError));
|
|
|
} else {
|
|
|
*pError = writerText("Unable to flush the temporary video file.");
|
|
|
}
|
|
|
}
|
|
|
QFile::remove(m_pPrivate->m_sTemporaryFilePath);
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
const QFileInfo oTemporaryFile(m_pPrivate->m_sTemporaryFilePath);
|
|
|
if(!oTemporaryFile.isFile() || oTemporaryFile.size() <= 0) {
|
|
|
if(pError != nullptr) {
|
|
|
*pError = writerText("The temporary video file is empty.");
|
|
|
}
|
|
|
QFile::remove(m_pPrivate->m_sTemporaryFilePath);
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
m_pPrivate->m_eState = Private::State_Finished;
|
|
|
return true;
|
|
|
#endif
|
|
|
}
|
|
|
|
|
|
void nmFFmpegVideoWriter::cancel()
|
|
|
{
|
|
|
if(m_pPrivate == nullptr ||
|
|
|
m_pPrivate->m_eState != Private::State_Opened) {
|
|
|
return;
|
|
|
}
|
|
|
m_pPrivate->m_eState = Private::State_Cancelled;
|
|
|
#ifdef NM_ENABLE_FFMPEG_VIDEO_EXPORT
|
|
|
m_pPrivate->abortAndRemoveTemporaryFile();
|
|
|
#endif
|
|
|
}
|
|
|
|
|
|
bool nmFFmpegVideoWriter::isBackendAvailable(QString* pError)
|
|
|
{
|
|
|
if(pError != nullptr) {
|
|
|
pError->clear();
|
|
|
}
|
|
|
#ifndef NM_ENABLE_FFMPEG_VIDEO_EXPORT
|
|
|
if(pError != nullptr) {
|
|
|
*pError = writerText("The video encoding components are unavailable.");
|
|
|
}
|
|
|
return false;
|
|
|
#else
|
|
|
static int nCachedAvailability = -1;
|
|
|
static QString sCachedError;
|
|
|
if(nCachedAvailability >= 0) {
|
|
|
if(nCachedAvailability == 0 && pError != nullptr) {
|
|
|
*pError = sCachedError;
|
|
|
}
|
|
|
return nCachedAvailability == 1;
|
|
|
}
|
|
|
|
|
|
// 八种正式格式采用全有或全无策略，避免按钮可用后才暴露缺失组件。
|
|
|
nCachedAvailability = inspectBackend(sCachedError) ? 1 : 0;
|
|
|
if(nCachedAvailability == 0 && pError != nullptr) {
|
|
|
*pError = sCachedError;
|
|
|
}
|
|
|
return nCachedAvailability == 1;
|
|
|
#endif
|
|
|
}
|
|
|
|
|
|
QStringList nmFFmpegVideoWriter::getSupportedExtensions()
|
|
|
{
|
|
|
QStringList listExtensions;
|
|
|
listExtensions << QString::fromLatin1("mp4")
|
|
|
<< QString::fromLatin1("avi")
|
|
|
<< QString::fromLatin1("mov")
|
|
|
<< QString::fromLatin1("mpg")
|
|
|
<< QString::fromLatin1("webm")
|
|
|
<< QString::fromLatin1("mkv")
|
|
|
<< QString::fromLatin1("wmv")
|
|
|
<< QString::fromLatin1("flv");
|
|
|
return listExtensions;
|
|
|
}
|
|
|
|
|
|
bool nmFFmpegVideoWriter::isSupportedExtension(
|
|
|
const QString& sExtension)
|
|
|
{
|
|
|
return getSupportedExtensions().contains(
|
|
|
normalizedExtension(sExtension));
|
|
|
}
|