记录 FFmpeg实现文件剪切、合并、BGM添加

已于 2024-01-10 10:04:31 修改
阅读量987 收藏 1
点赞数 1
文章标签： ffmpeg 音视频 c++
于 2023-06-16 11:33:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/t__zxt/article/details/131243363
版权

说明

代码实现了对原视频文件添加BGM、媒体文件按时间剪切、合并多个媒体文件的功能。虽然实现效果以及功能全面性无法媲美专业软件，但是完全满足基本使用，代码保证实现原理及思路的正确性，二次开发可自行优化完善。

注：对于合并文件应保证合并文件媒体格式完全一致，专业软件处理不一致的文件应该会检查格式并转换为统一格式在进行合并。

代码

已封装为线程类，原理不太复杂但是细节处理较多，尤其是时间戳问题。代码如下

头文件

#ifndef TASKTHREAD_H
#define TASKTHREAD_H

#include <QObject>
#include <QThread>
#include <QDebug>
#include <QTimer>
#include "ffmpeghead.h"

enum TaskType
{
    Type_BGM = 1,
    Type_Cut,
    Type_Merge
};

/**
 * 任务执行线程类
 */
class TaskThread : public QThread
{
    Q_OBJECT
public:
    explicit TaskThread(QObject *parent = nullptr);
    ~TaskThread();

    //公共函数
    void setTaskType(int type);
    void setBgmParm(const QString &source, const QString &bgm);
    void setCutParm(const QString &source, int start, int end);
    void setMergeParm(const QStringList &fileList);
    bool getTaskStatus();

    //背景音乐功能
    void doBgmTask();

    //剪辑功能
    void doCutTask();

    //合并功能
    void doMergeTask();

signals:
    void sigTaskFinish(const QString &info);

protected:
    void run();

private:
    int type;            //功能类型 0背景音乐 1剪辑 2合并

    QString bgmSource;   //bgm视频源文件
    QString bgmDst;      //bgm音频文件

    QString cutSource;   //剪辑源文件
    int cutStart;        //剪辑开始时间
    int cutEnd;          //剪辑结束时间

    QStringList mergeList;  //需要合并的文件列表
};

#endif // TASKTHREAD_H

实现文件

#include "taskthread.h"

TaskThread::TaskThread(QObject *parent) : QThread(parent)
{
    type = 0;

    this->cutStart = 0;
    this->cutEnd = 0;
}

TaskThread::~TaskThread()
{
    quit();
    wait();
}

void TaskThread::setTaskType(int type)
{
    this->type = type;
}

void TaskThread::setBgmParm(const QString &source, const QString &bgm)
{
    this->bgmSource = source;
    this->bgmDst = bgm;
}

void TaskThread::setCutParm(const QString &source, int start, int end)
{
    this->cutSource = source;
    this->cutStart = start;
    this->cutEnd = end;
}

void TaskThread::setMergeParm(const QStringList &fileList)
{
    this->mergeList = fileList;
}

bool TaskThread::getTaskStatus()
{
    return this->isRunning();
}

void TaskThread::doBgmTask()
{
    qDebug() << "doBgmTask";

    std::string tempVideo = bgmSource.toStdString();
    const char *video_filename = tempVideo.c_str();
    std::string tempAudio = bgmDst.toStdString();
    const char *audio_filename = tempAudio.c_str();

    const char *out_filename = "./testbgm.mp4";

    AVOutputFormat *ofmt = NULL;
    AVFormatContext *ifmt_ctx = NULL, *ifmt_ctx_bgm = NULL, *ofmt_ctx = NULL;
    AVPacket pkt;
    AVPacket pktBgm;

    int ret = 0;
    uint i = 0;
    int stream_index = 0;
    int *stream_mapping = NULL;
    int stream_mapping_size = 0;
    int audio_index = 0;

    //打开视频文件
    if ((ret = avformat_open_input(&ifmt_ctx, video_filename, 0, 0)) < 0)
    {
        fprintf(stderr, "Could not open input file '%s'\n", video_filename);
        return;
    }

    if ((ret = avformat_find_stream_info(ifmt_ctx, 0)) < 0)
    {
        fprintf(stderr, "Failed to retrieve input stream information");
        return;
    }

    //打开音频文件
    if ((ret = avformat_open_input(&ifmt_ctx_bgm, audio_filename, 0, 0)) < 0)
    {
        fprintf(stderr, "Could not open input file '%s'\n", audio_filename);
        return;
    }

    if ((ret = avformat_find_stream_info(ifmt_ctx_bgm, 0)) < 0)
    {
        fprintf(stderr, "Failed to retrieve input stream information\n");
        return;
    }


    //设置输出文件
    avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, out_filename);
    if (!ofmt_ctx)
    {
        fprintf(stderr, "Could not create output context\n");
        ret = AVERROR_UNKNOWN;
        return;
    }

    //设置输出-根据视频文件
    stream_mapping_size = ifmt_ctx->nb_streams;
    stream_mapping = (int *)av_mallocz_array(stream_mapping_size, sizeof(*stream_mapping));
    if (!stream_mapping)
    {
        ret = AVERROR(ENOMEM);
        return;
    }

    for (i = 0; i < ifmt_ctx->nb_streams; i++)
    {
        AVStream *out_stream;
        AVStream *in_stream = ifmt_ctx->streams[i];
        AVCodecParameters *in_codecpar = in_stream->codecpar;

        if (in_codecpar->codec_type != AVMEDIA_TYPE_AUDIO &&
                in_codecpar->codec_type != AVMEDIA_TYPE_VIDEO &&
                in_codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE)
        {
            stream_mapping[i] = -1;
            continue;
        }

        stream_mapping[i] = stream_index++;

        out_stream = avformat_new_stream(ofmt_ctx, NULL);
        if (!out_stream)
        {
            fprintf(stderr, "Failed allocating output stream\n");
            ret = AVERROR_UNKNOWN;
            return;
        }

        ret = avcodec_parameters_copy(out_stream->codecpar, in_codecpar);
        if (ret < 0)
        {
            fprintf(stderr, "Failed to copy codec parameters\n");
            return;
        }
        out_stream->codecpar->codec_tag = 0;
    }

    //设置输出-根据音频文件
    for (i = 0; i < ifmt_ctx_bgm->nb_streams; i++)
    {
        AVStream *out_stream;
        AVStream *in_stream = ifmt_ctx_bgm->streams[i];
        AVCodecParameters *in_codecpar = in_stream->codecpar;

        if (in_codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
        {
            audio_index = -1;
            continue;
        }

        audio_index = i;

        out_stream = avformat_new_stream(ofmt_ctx, NULL);
        if (!out_stream)
        {
            fprintf(stderr, "Failed allocating output stream\n");
            ret = AVERROR_UNKNOWN;
            return;
        }

        ret = avcodec_parameters_copy(out_stream->codecpar, in_codecpar);
        if (ret < 0)
        {
            fprintf(stderr, "Failed to copy codec parameters\n");
            return;
        }
        out_stream->codecpar->codec_tag = 0;
    }

    //打开输出
    ofmt = ofmt_ctx->oformat;
    if (!(ofmt->flags & AVFMT_NOFILE))
    {
        ret = avio_open(&ofmt_ctx->pb, out_filename, AVIO_FLAG_WRITE);
        if (ret < 0)
        {
            fprintf(stderr, "Could not open output file '%s'", out_filename);
            return;
        }
    }

    ret = avformat_write_header(ofmt_ctx, NULL);
    if (ret < 0)
    {
        fprintf(stderr, "Error occurred when opening output file\n");
        return;
    }

    //写入视频文件的信息
    int maxVideoSec = 0;
    while (1)
    {
        AVStream *in_stream, *out_stream;
        ret = av_read_frame(ifmt_ctx, &pkt);
        if (ret < 0)
            break;

        in_stream = ifmt_ctx->streams[pkt.stream_index];
        if (pkt.stream_index >= stream_mapping_size || stream_mapping[pkt.stream_index] < 0)
        {
            av_packet_unref(&pkt);
            continue;
        }

        //记录视频文件的最大值
        if(in_stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
        {
            maxVideoSec = pkt.pts * av_q2d(in_stream->time_base);
        }

        pkt.stream_index = stream_mapping[pkt.stream_index];
        out_stream = ofmt_ctx->streams[pkt.stream_index];

        /* copy packet */
        pkt.pts = av_rescale_q_rnd(pkt.pts, in_stream->time_base, out_stream->time_base, AVRounding(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
        pkt.dts = av_rescale_q_rnd(pkt.dts, in_stream->time_base, out_stream->time_base, AVRounding(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;

        ret = av_interleaved_write_frame(ofmt_ctx, &pkt);
        if (ret < 0)
        {
            fprintf(stderr, "Error muxing packet\n");
            break;
        }
        av_packet_unref(&pkt);
    }

    //写入音频文件的信息
    while (1)
    {
        AVStream *in_stream, *out_stream;
        ret = av_read_frame(ifmt_ctx_bgm, &pktBgm);
        if (ret < 0)
            break;

        in_stream = ifmt_ctx_bgm->streams[pktBgm.stream_index];

        //bgm过长则忽略
        if(pktBgm.pts * av_q2d(in_stream->time_base) >= maxVideoSec)
        {
            av_packet_unref(&pktBgm);
            break;
        }

        //已有视频输出流生成，不能在使用音频默认的index
        pktBgm.stream_index = ifmt_ctx->nb_streams;
        out_stream = ofmt_ctx->streams[pktBgm.stream_index];

        /* copy packet */
        pktBgm.pts = av_rescale_q_rnd(pktBgm.pts, in_stream->time_base, out_stream->time_base, AVRounding(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
        pktBgm.dts = av_rescale_q_rnd(pktBgm.dts, in_stream->time_base, out_stream->time_base, AVRounding(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
        pktBgm.duration = av_rescale_q(pktBgm.duration, in_stream->time_base, out_stream->time_base);
        pktBgm.pos = -1;

        ret = av_interleaved_write_frame(ofmt_ctx, &pktBgm);
        if (ret < 0)
        {
            fprintf(stderr, "Error muxing bgm packet\n");
            break;
        }
        av_packet_unref(&pktBgm);
    }

    av_write_trailer(ofmt_ctx);

    qDebug() << "doBgmTask finish";

    avformat_close_input(&ifmt_ctx);
    avformat_close_input(&ifmt_ctx_bgm);

    /* close output */
    if (ofmt_ctx && !(ofmt->flags & AVFMT_NOFILE))
        avio_closep(&ofmt_ctx->pb);

    avformat_free_context(ofmt_ctx);
    av_freep(&stream_mapping);

    QString info = "添加背景音乐结束";
    emit sigTaskFinish(info);
}

void TaskThread::doCutTask()
{
    qDebug() << "doCutTask";

    AVOutputFormat *ofmt = NULL;
    AVFormatContext *ifmt_ctx = NULL, *ofmt_ctx = NULL;
    AVPacket pkt;
    int ret = 0;
    uint i = 0;
    int stream_index = 0;
    int *stream_mapping = NULL;
    int stream_mapping_size = 0;

    std::string temp = cutSource.toStdString();
    const char *in_filename = temp.c_str();
    const char *out_filename = "./testcut.mp4";


    if ((ret = avformat_open_input(&ifmt_ctx, in_filename, 0, 0)) < 0)
    {
        fprintf(stderr, "Could not open input file '%s'", in_filename);
        return;
    }

    if ((ret = avformat_find_stream_info(ifmt_ctx, 0)) < 0)
    {
        fprintf(stderr, "Failed to retrieve input stream information");
        return;
    }


    avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, out_filename);
    if (!ofmt_ctx)
    {
        fprintf(stderr, "Could not create output context\n");
        ret = AVERROR_UNKNOWN;
        return;
    }

    stream_mapping_size = ifmt_ctx->nb_streams;
    stream_mapping = (int *)av_mallocz_array(stream_mapping_size, sizeof(*stream_mapping));
    if (!stream_mapping)
    {
        ret = AVERROR(ENOMEM);
        return;
    }

    ofmt = ofmt_ctx->oformat;

    for (i = 0; i < ifmt_ctx->nb_streams; i++)
    {
        AVStream *out_stream;
        AVStream *in_stream = ifmt_ctx->streams[i];
        AVCodecParameters *in_codecpar = in_stream->codecpar;

        if (in_codecpar->codec_type != AVMEDIA_TYPE_AUDIO &&
                in_codecpar->codec_type != AVMEDIA_TYPE_VIDEO &&
                in_codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE)
        {
            stream_mapping[i] = -1;
            continue;
        }

        stream_mapping[i] = stream_index++;

        out_stream = avformat_new_stream(ofmt_ctx, NULL);
        if (!out_stream)
        {
            fprintf(stderr, "Failed allocating output stream\n");
            ret = AVERROR_UNKNOWN;
            return;
        }

        ret = avcodec_parameters_copy(out_stream->codecpar, in_codecpar);
        if (ret < 0)
        {
            fprintf(stderr, "Failed to copy codec parameters\n");
            return;
        }
        out_stream->codecpar->codec_tag = 0;
    }

    if (!(ofmt->flags & AVFMT_NOFILE))
    {
        ret = avio_open(&ofmt_ctx->pb, out_filename, AVIO_FLAG_WRITE);
        if (ret < 0)
        {
            fprintf(stderr, "Could not open output file '%s'", out_filename);
            return;
        }
    }

    ret = avformat_write_header(ofmt_ctx, NULL);
    if (ret < 0)
    {
        fprintf(stderr, "Error occurred when opening output file\n");
        return;
    }

    int curPacketSec = 0;
    int lastPtsVideo = 0;
    int lastDtsVideo = 0;
    int lastPtsAudio = 0;
    int lastDtsAudio = 0;
    while (1)
    {
        AVStream *in_stream, *out_stream;

        ret = av_read_frame(ifmt_ctx, &pkt);
        if (ret < 0)
            break;

        in_stream = ifmt_ctx->streams[pkt.stream_index];
        if (pkt.stream_index >= stream_mapping_size || stream_mapping[pkt.stream_index] < 0)
        {
            av_packet_unref(&pkt);
            continue;
        }

        curPacketSec = pkt.pts * av_q2d(in_stream->time_base);
//        qDebug() << "curPacketSec" << curPacketSec;

        if(curPacketSec < cutStart)
        {
            if(in_stream->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
            {
                lastPtsAudio = pkt.pts;
                lastDtsAudio = pkt.dts;
            }
            else if(in_stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
            {
                lastPtsVideo = pkt.pts;
                lastDtsVideo = pkt.dts;
            }

            av_packet_unref(&pkt);
            continue;
        }


        if(in_stream->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
        {
            pkt.pts -= lastPtsAudio;
            pkt.dts -= lastDtsAudio;
        }
        else if(in_stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
        {
            pkt.pts -= lastPtsVideo;
            pkt.dts -= lastDtsVideo;
        }

        pkt.stream_index = stream_mapping[pkt.stream_index];
        out_stream = ofmt_ctx->streams[pkt.stream_index];

        /* copy packet */
        pkt.pts = av_rescale_q_rnd(pkt.pts, in_stream->time_base, out_stream->time_base, AVRounding(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
        pkt.dts = av_rescale_q_rnd(pkt.dts, in_stream->time_base, out_stream->time_base, AVRounding(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;

        ret = av_interleaved_write_frame(ofmt_ctx, &pkt);
        if (ret < 0)
        {
            fprintf(stderr, "Error muxing packet\n");
            break;
        }
        av_packet_unref(&pkt);

        //时间限制
        if(curPacketSec > cutEnd)
        {
            break;
        }
    }

    av_write_trailer(ofmt_ctx);
    qDebug() << "doCutTask finish";

    avformat_close_input(&ifmt_ctx);
    if (ofmt_ctx && !(ofmt->flags & AVFMT_NOFILE))
        avio_closep(&ofmt_ctx->pb);

    avformat_free_context(ofmt_ctx);
    av_freep(&stream_mapping);

    QString info = "剪切文件结束";
    emit sigTaskFinish(info);
}

void TaskThread::doMergeTask()
{
    qDebug() << "start doMergeTask";

    const int mergeNum = mergeList.size();
    const char *out_filename = "testmerge.mp4";
    int ret = 0;

    //1 初始化输入文件
    AVFormatContext *ifmt_ctx[mergeNum] = {NULL};
    for(int i=0; i<mergeNum; i++)
    {
        std::string fileName = QString(mergeList.at(i)).toStdString();
        const char *in_filename = fileName.c_str();

        ifmt_ctx[i] = avformat_alloc_context();
        if ((ret = avformat_open_input(&ifmt_ctx[i], in_filename, 0, 0)) < 0)
        {
            fprintf(stderr, "Could not open input file '%s'", in_filename);
            avformat_close_input(&ifmt_ctx[i]);
            return;
        }

        if ((ret = avformat_find_stream_info(ifmt_ctx[i], 0)) < 0)
        {
            fprintf(stderr, "Failed to retrieve input stream information");
            avformat_close_input(&ifmt_ctx[i]);
            return;
        }
    }

    //2 初始化输出文件
    AVFormatContext *ofmt_ctx = NULL;
    avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, out_filename);
    if (!ofmt_ctx)
    {
        fprintf(stderr, "Could not create output context\n");
        ret = AVERROR_UNKNOWN;
        return;
    }

    AVOutputFormat *ofmt = ofmt_ctx->oformat;

    //这里默认用第一个文件参数初始化
    for (uint i=0; i<ifmt_ctx[0]->nb_streams; i++)
    {
        AVStream *in_stream = ifmt_ctx[0]->streams[i];
        AVCodecParameters *in_codecpar = in_stream->codecpar;

        AVStream *out_stream = avformat_new_stream(ofmt_ctx, NULL);
        if (!out_stream)
        {
            fprintf(stderr, "Failed allocating output stream\n");
            return;
        }

        ret = avcodec_parameters_copy(out_stream->codecpar, in_codecpar);
        if (ret < 0)
        {
            fprintf(stderr, "Failed to copy codec parameters\n");
            return;
        }
        out_stream->codecpar->codec_tag = 0;
    }

    if (!(ofmt->flags & AVFMT_NOFILE))
    {
        ret = avio_open(&ofmt_ctx->pb, out_filename, AVIO_FLAG_WRITE);
        if (ret < 0)
        {
            fprintf(stderr, "Could not open output file '%s'", out_filename);
            if (ofmt_ctx && !(ofmt->flags & AVFMT_NOFILE))
                avio_closep(&ofmt_ctx->pb);
        }
    }

    //3 输入输出初始化均完成，先文件写头
    ret = avformat_write_header(ofmt_ctx, NULL);
    if (ret < 0)
    {
        fprintf(stderr, "Error occurred when opening output file\n");
        return;
    }

    //4 循环写入实际包数据
    int fileIndex = 0;
    AVPacket pkt;
    int lastVideoPts[mergeNum] = {0};
    int lastVideoDts[mergeNum] = {0};
    int lastAudioPts[mergeNum] = {0};

    qDebug() << ">>开始写入文件" << fileIndex+1;
    while (true)
    {
        ret = av_read_frame(ifmt_ctx[fileIndex], &pkt);
        if (ret < 0)
        {
            //循环结束跳出
            fileIndex++;
            if(fileIndex == mergeNum)
            {
                break;
            }

            qDebug() << ">>开始写入文件" << fileIndex+1;
            continue;
        }

        AVStream *in_stream = ifmt_ctx[fileIndex]->streams[pkt.stream_index];
        AVStream *out_stream = ofmt_ctx->streams[pkt.stream_index];

        // int curPacketSec = pkt.pts * av_q2d(in_stream->time_base);
        // qDebug() << "pkt原始数据" << curPacketSec << pkt.pts << pkt.dts << pkt.duration << pkt.stream_index;

        if(in_stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
        {
            if(fileIndex >= 1)
            {
                pkt.pts += lastVideoPts[fileIndex-1];
                pkt.dts += lastVideoPts[fileIndex-1];
            }
            lastVideoPts[fileIndex] = pkt.pts;
            lastVideoDts[fileIndex] = pkt.dts;
        }
        else if(in_stream->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
        {
            if(fileIndex >= 1)
            {
                pkt.pts += lastAudioPts[fileIndex-1];
                pkt.dts = pkt.pts;
            }
            lastAudioPts[fileIndex] = pkt.pts;
        }

        // qDebug() << "pkt处理数据" << curPacketSec << pkt.pts << pkt.dts << pkt.duration;

        /* copy packet */
        pkt.pts = av_rescale_q_rnd(pkt.pts, in_stream->time_base, out_stream->time_base, AVRounding(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
        pkt.dts = av_rescale_q_rnd(pkt.dts, in_stream->time_base, out_stream->time_base, AVRounding(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
        pkt.duration = av_rescale_q(pkt.duration, in_stream->time_base, out_stream->time_base);

        // qDebug() << "pkt转换数据" << curPacketSec << pkt.pts << pkt.dts << pkt.duration;
        ret = av_interleaved_write_frame(ofmt_ctx, &pkt);
        if (ret < 0)
        {
            char err[32];
            av_strerror(ret,err,32);
            fprintf(stderr, "Error muxing packet error:%s\n",err);
            continue;
        }
        av_packet_unref(&pkt);
    }

    av_write_trailer(ofmt_ctx);

    if (ofmt_ctx && !(ofmt->flags & AVFMT_NOFILE))
        avio_closep(&ofmt_ctx->pb);
    avformat_free_context(ofmt_ctx);

    qDebug() << "doMergeTask finish";

    QString info = "合并文件结束";
    emit sigTaskFinish(info);
}

void TaskThread::run()
{
    switch (this->type)
    {
    case 1:
        doBgmTask();
        break;
    case 2:
        doCutTask();
        break;
    case 3:
        doMergeTask();
        break;
    default:
        break;
    }
}
你是周小哥啊
关注
FFmpeg进阶: 给视频添加背景音乐
yang1fei2的博客
12-04 2734
在抖音、快手一类的短视频软件中，为了提升视频的效果，我们通常会给视频添加有趣的背景音乐。通过FFmpeg库我们也可以给视频添加背景音乐，这里就介绍一下如何通过FFmpeg库给视频添加背景音乐。添加背景音乐的原理图如下图所示
qt 基于ffmpeg 实现视频的拼接、合并
10-16
在Windows系统中，可以下载FFmpeg的预编译版本，将其库文件添加到项目的链接器设置中。在Linux系统中，可以通过包管理器安装FFmpeg库，如`sudo apt-get install libavformat-dev libavcodec-dev libavutil-dev`。 1...
winform利用ffmpeg给视频添加背景乐
08-03
项目需要给视频加上背景音乐，但网上查了下，发现很多例子都是利用ffmpeg.exe，然后通过命令行的形式将视频和音频合并为一个新的视频，明显不符合要求，所以就利用网上的资料自己写了一个
python使用ffmpeg将视频、音频合并合成（速度最快）
云霄IT的博客
08-23 928
基本方法：ffmpeg视频音频合成命令。
用ffmpeg对视频添加语音、背景音乐和字幕的方法
不甜
06-04 1309
其余参数涉及视频和音频的编码设置，如使用H.264编码器(-c:v libx264)、CRF值(-crf 23)、预设(-preset veryfast)、AAC音频编码(-c:a aac)和音频比特率(-b:a 128k)等，用于控制输出文件的质量和兼容性。-map “[vout]” -map “[audio_mixed]” 指定最终输出使用哪些流：处理过的视频流[vout]和混合后的音频流[audio_mixed]。[1:a] 指的是第二个输入文件（voice.mp3）的音频部分。
FFmpeg的简单使用【Windows】--- 视频混剪+添加背景音乐
最新发布
qq_45569925的博客
10-14 870
ffprobe是FFmpeg套件中的一个工具，用于提取媒体文件的元数据，它可以获取各种媒体文件的信息，包括视频、音频和其他媒体数据。
Ffmpeg实例，为视频添加一个循环播放的背景音乐（混声）
热门推荐
张雨的博客
01-06 1万+
ffmpeg命令目录 方案1（不推荐）（混声） ffmpeg -i E:\1\subtitle\out3.mp4 -i E:\1\subtitle\music3D.wav -filter_complex [1:a]aloop=loop=-1:size=2e+09[out];[out][0:a]amix -ss 0 -t 60 -y out.mp4 //输入视频，最好选一个大于一分钟的尝试 -i E:\1\subtitle\out3.mp4 //输入背景音，最好短一点，方便测试是否循环 -i E:\1\.
雷神的代码FFMpeg 实现音视频剪切（无编解码）
06-23
这篇文章将详细介绍如何使用 C 语言通过 FFmpeg 库实现音视频剪切。 首先，我们需要理解 FFmpeg 的基本架构。FFmpeg 包含多个组件，如 libavformat 用于处理容器格式，libavcodec 用于编码和解码音频/视频流，...
android采用FFmpeg实现音频混合与拼接剪切
01-20
首先，要在 Android Studio 中配置 FFmpeg，你需要在 `build.gradle` 文件中添加对 CMake 的支持以及 FFmpeg 库的配置。这通常包括设置 `cppFlags`，指定 `abiFilters` 以支持特定的 CPU 架构，如 armeabi-v7a。示例...
ffmpeg 实现h264，g711合并成mp4
07-26
总结，通过 FFmpeg 的强大功能，我们可以方便地将 h264 视频流和 g711 音频流合并到一个 MP4 文件中，实现多媒体内容的整合与分发。这个过程涉及到音视频编码的理解、FFmpeg 命令的运用以及多媒体容器的结构知识。...
ffmpeg 绝对有用的音频和视频的截取与合并命令
07-22
ffmpeg虽然可以将图片转换成视频并且添加背景音乐，但是背景音乐无法实现轮播，这里的命令可以先将音频先合并，再截取对应时间长度的音频，从而可以实现视频对应长度的背景音乐。
通过ffmpeg实现批量改名，然后将多个视频文件合并为1个
07-25
通过ffmpeg实现批量改名，然后将多个视频文件合并为1个 文件后缀可以自己修改，ts，或者mp4都可以用
使用python+ffmpeg批量混剪视频
mj412828668的博客
10-23 1618
# encoding=utf-8 import os import itertools def main(): #使用前，要先配置好ffmpeg的环境变量，并删除videos_path中txt文件夹下的所有文件 ffmpeg_path = "D:\\FFmpeg\\bin\\ffmpeg" videos_path = "C:\\Users\\Yan\\Desktop\\videos" concat_list_path = videos_path + "\\txt\\" .
FFmpeg命令裁剪和合并视频
qq_41682323的博客
04-23 2525
FFmpeg命令裁剪和合并视频
使用ffmpeg合并（连接）文件
lakeheart879的专栏
10-22 6300
部分翻译来自： https://trac.ffmpeg.org/wiki/How%20to%20concatenate%20%28join,%20merge%29%20media%20files 关键词：concatenate；append；合并；连接 使用ffmpeg连接文件分两类，连接编码完全相同的文件；连接编码不同的文件 连接编码完全相同的文件 有两种方式，使用concat
C#中使用FFMPEG切割、合并视频。
weixin_33804990的博客
12-17 1373
参考网址：https://blog.csdn.net/samwang_/article/details/70332924 使用前先确保电脑已经安装了FFMPEG，并且配置好环境变量。检测是否安装配置好的方法:在cmd中输入ffmpeg   class FFMEPG { //视频切割 public string Cut(string OriginFile/*视频源文...
ffmpeg音视频裁剪
Scl_Diligent的博客
04-29 2271
音视频裁剪，通常会依据时间轴为基准，从某个起始点到终止点的音视频截取出来，当然音视频文件中存在多路流，所对每一组流进行裁剪。
python调用ffmpeg实现为一个语音文件添加背景音乐
JAMES费的空间
03-12 1207
在给一个自媒体朋友编写一个根据文本自动生成音频文件，最后需要添加背景音乐，python可以调用ffmpeg的合并音频功能实现。确认在环境变量中添加了ffmpeg的bin路径，验证办法是cmd调出命令窗口，输入命令ffmpeg，有版本信息打印出来。前提条件，在操作系统中先安装ffmpeg，连接如(
使用dos批处理和ffmpeg合并ts文件为mp4
其中包含了两个批处理文件（"合并ts文件.bat"和"转化为mp4.bat"），FFmpeg的可执行文件（ffmpeg.exe），以及一个文本文件（m3u8和ts文件合并.txt），该文本文件可能包含了关于如何使用FFmpeg和这些批处理文件的说明...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

你是周小哥啊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值