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

已于 2024-01-10 10:04:31 修改
阅读量875 收藏 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;
    }
}
你是周小哥啊
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
FFmpeg进阶: 给视频添加背景音乐
yang1fei2的博客
12-04 2544
在抖音、快手一类的短视频软件中，为了提升视频的效果，我们通常会给视频添加有趣的背景音乐。通过FFmpeg库我们也可以给视频添加背景音乐，这里就介绍一下如何通过FFmpeg库给视频添加背景音乐。添加背景音乐的原理图如下图所示
qt 基于ffmpeg 实现视频的拼接、合并
10-16
在Windows系统中，可以下载FFmpeg的预编译版本，将其库文件添加到项目的链接器设置中。在Linux系统中，可以通过包管理器安装FFmpeg库，如`sudo apt-get install libavformat-dev libavcodec-dev libavutil-dev`。 1...
ffmpeg实现多图片与音频合成视频并额外添加bgm
qq_43601009的博客
12-25 2672
ffmpeg实现多张图片与音频合成视频，并额外添加bgm
python调用ffmpeg实现为一个语音文件添加背景音乐
JAMES费的空间
03-12 1118
在给一个自媒体朋友编写一个根据文本自动生成音频文件，最后需要添加背景音乐，python可以调用ffmpeg的合并音频功能实现。确认在环境变量中添加了ffmpeg的bin路径，验证办法是cmd调出命令窗口，输入命令ffmpeg，有版本信息打印出来。前提条件，在操作系统中先安装ffmpeg，连接如(
用ffmpeg对视频添加语音、背景音乐和字幕的方法
最新发布
不甜
06-04 788
其余参数涉及视频和音频的编码设置，如使用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实例，为视频添加一个循环播放的背景音乐（混声）
热门推荐
张雨的博客
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学习日记601-指令-视频裁剪，添加bgm合成mp4
WenCoo的博客
12-03 523
# 实现功能： 1. 截取视频片段 2. 将截取的视频合成视频 3. 将视频添加bgm，合成成品mp4
ffmpeg 实现h264，g711合并成mp4
07-26
总结，通过 FFmpeg 的强大功能，我们可以方便地将 h264 视频流和 g711 音频流合并到一个 MP4 文件中，实现多媒体内容的整合与分发。这个过程涉及到音视频编码的理解、FFmpeg 命令的运用以及多媒体容器的结构知识。...
android采用FFmpeg实现音频混合与拼接剪切
08-26
主要为大家详细介绍了android采用FFmpeg实现音频混合与拼接剪切，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
视频和音频使用ffmpeg进行合并
02-26
FFmpeg是一款强大的开源跨平台工具，用于处理多媒体文件，包括视频、音频的转换、合并、分割等操作。在本文中，我们将深入探讨如何使用FFmpeg将视频和音频进行合并，以便创建一个完整的多媒体文件。 首先，理解...
winform利用ffmpeg给视频添加背景乐
08-03
项目需要给视频加上背景音乐，但网上查了下，发现很多例子都是利用ffmpeg.exe，然后通过命令行的形式将视频和音频合并为一个新的视频，明显不符合要求，所以就利用网上的资料自己写了一个
ffmpeg 绝对有用的音频和视频的截取与合并命令
07-22
ffmpeg虽然可以将图片转换成视频并且添加背景音乐，但是背景音乐无法实现轮播，这里的命令可以先将音频先合并，再截取对应时间长度的音频，从而可以实现视频对应长度的背景音乐。
FFmpeg学习（7）—— 给视频添加背景音乐
liinux-Talk is cheap,show me the code.
03-08 1944
有时自己录制的视频课件想添加一个背景音乐，操作方法如下： 新建一个bat文件1.bat如下： @echo off title 正在转换,mp4视频添加循环背景音乐 ffmpeg -i %1 -i E:\softs\ffmpeg-4.2.2-win64-static\bin\2.mp3 -filter_complex [1:a]aloop=loop=-1:size=2e+09[out];[ou...
ffmpeg操作实战001：视频+音频文件融合
数据饕餮
02-04 1416
把视频文件video.mp4 和音频文件audio.wav融合在一起，输出视频文件output.mp4。
ffmpeg给视频添加背景音乐
swordsmanye的博客
12-13 7973
In the end, it’s not the years in your life that count. It’s the life in your years. 最终，重要的不是活了多少年，而是这些年你怎么活。 --林肯 点到这里了相信你已经下载好了ffmpeg，对这个开源软件的介绍我也就不过多的赘述了，如果没有下载好的小伙伴们可以到官网去进行下载，下载地址：https://www....
FFMPEG音频视频开发: 命令行方式给视频添加音频数据
01-31 1901
一、环境介绍 操作系统介绍：win10 64位 FFMPEG版本:4.4.2 QT版本:5.12.6 二、FFMPEG下载 ubuntu系统下编译安装ffmpeg:https://blog.csdn.net/xiaolong1126626497/article/details/104919095 windos系统下安装ffmpeg:https://blog.csdn.net/xiaolong1126626497/article/details/105412560 三、去掉视频原...
FFmpeg分离音视频,音视频合并,添加多音轨,格式转换,裁切,剪切常用参数详解
Break a Leg
06-01 3100
FFmpeg 分离音视频，分离左右声道，添加音轨 分离音频 ffmpeg -i test.mp4 -vn -acodec copy voice.aac 准备音轨二 ffmpeg -i back.mp4 -vn -acodec copy voice_back.aac 分离视频 ffmpeg -i test.mp4 –an -vcodec copy video.mp4 合并视频 ffmpeg -i video.mp4 -i voice.aac -i voice_back.aac -map 0:v -map
ffmpeg 多个 文件合并
05-22
FFmpeg是一个强大的音视频处理工具，可以用它来将多个音视频文件进行合并。下面是合并多个文件的步骤： 1. 首先，将所有需要合并的文件放在同一个文件夹下，并确保它们按照正确的顺序排列，例如按照时间顺序。 2. 打开命令行窗口或终端，进入到包含这些文件的文件夹。 3. 执行以下命令： ``` ffmpeg -i "concat:file1.mp4|file2.mp4|file3.mp4" -c copy output.mp4 ``` 其中，"file1.mp4|file2.mp4|file3.mp4"是需要合并的文件列表，用竖线分隔。输出文件名为output.mp4。 4. 等待命令执行完成即可。 注意事项： 1. 如果需要合并的文件格式不同，需要先转换成相同的格式再进行合并。 2. 如果需要合并的文件有音频或字幕等其他流，需要使用更复杂的命令进行合并。可以参考FFmpeg官方文档或者其他相关教程进行学习。 3. 在执行命令时，需要根据实际情况修改输入文件名和输出文件名。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

你是周小哥啊

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

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

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

打赏作者

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

抵扣说明：

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

余额充值