ffmpeg 封装MP4

使用FFmpeg封装MP4需要执行以下步骤：

1. 安装FFmpeg。如果你还没有安装FFmpeg，可以从官网下载并安装：https://ffmpeg.org/download.html

2. 编写命令行代码。以下是一个基本的命令行代码示例：

ffmpeg -i input.mp4 -c:v copy -c:a copy output.mp4

其中，input.mp4是你想要封装的原始视频文件名称，output.mp4是封装后的新文件名称。

3. 执行命令行代码。在命令行中输入以上代码，并按下回车键执行。

4. 等待封装完成。封装时间取决于原始视频文件大小和计算机性能。

完成上述步骤后，你就可以得到一个封装好的MP4视频文件。

相关问题

ffmpeg 封装 MP4 音视频同步问题代码实现

以下是使用 ffmpeg 封装 MP4 的音视频同步问题的代码实现：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <time.h>

#include <libavcodec/avcodec.h>
#include <libavutil/opt.h>
#include <libavutil/mathematics.h>
#include <libavutil/timestamp.h>
#include <libavformat/avformat.h>

#define STREAM_FRAME_RATE 25 /* 25 images/s */
#define STREAM_PIX_FMT    AV_PIX_FMT_YUV420P /* default pix_fmt */

static void encode(AVCodecContext *enc_ctx, AVFrame *frame, AVPacket *pkt, FILE *outfile)
{
    int ret;

    /* send the frame to the encoder */
    ret = avcodec_send_frame(enc_ctx, frame);
    if (ret < 0) {
        fprintf(stderr, "Error sending a frame for encoding\n");
        exit(1);
    }

    /* receive encoded frames from the encoder */
    while (ret >= 0) {
        ret = avcodec_receive_packet(enc_ctx, pkt);
        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
            return;
        else if (ret < 0) {
            fprintf(stderr, "Error during encoding\n");
            exit(1);
        }

        fwrite(pkt->data, 1, pkt->size, outfile);
        av_packet_unref(pkt);
    }
}

int main(int argc, char **argv)
{
    const char *filename, *outfilename;
    const AVCodec *codec;
    AVCodecContext *c = NULL;
    int i, ret, x, y;
    FILE *outfile;
    AVFrame *frame;
    AVPacket *pkt;
    AVDictionary *opt = NULL;

    /* check command line parameters */
    if (argc <= 2) {
        fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
        exit(0);
    }
    filename    = argv[1];
    outfilename = argv[2];

    /* register all codecs and formats */
    av_register_all();

    /* open the input file */
    ret = avformat_open_input(&fmt_ctx, filename, NULL, NULL);
    if (ret < 0) {
        fprintf(stderr, "Error opening the input file: %s\n", filename);
        exit(1);
    }

    /* retrieve stream information */
    ret = avformat_find_stream_info(fmt_ctx, NULL);
    if (ret < 0) {
        fprintf(stderr, "Error finding stream information\n");
        exit(1);
    }

    /* select the audio and video stream */
    for (i = 0; i < fmt_ctx->nb_streams; i++) {
        if (fmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
            video_stream_idx = i;
        else if (fmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
            audio_stream_idx = i;
    }
    if (video_stream_idx == -1) {
        fprintf(stderr, "No video stream found in the input file\n");
        exit(1);
    }
    if (audio_stream_idx == -1) {
        fprintf(stderr, "No audio stream found in the input file\n");
        exit(1);
    }

    /* get a pointer to the codec context for the video stream */
    codecpar = fmt_ctx->streams[video_stream_idx]->codecpar;
    codec = avcodec_find_decoder(codecpar->codec_id);
    if (!codec) {
        fprintf(stderr, "Codec not found\n");
        exit(1);
    }
    c = avcodec_alloc_context3(codec);
    if (!c) {
        fprintf(stderr, "Could not allocate codec context\n");
        exit(1);
    }
    ret = avcodec_parameters_to_context(c, codecpar);
    if (ret < 0) {
        fprintf(stderr, "Could not initialize codec context\n");
        exit(1);
    }
    ret = avcodec_open2(c, codec, NULL);
    if (ret < 0) {
        fprintf(stderr, "Could not open codec\n");
        exit(1);
    }

    /* allocate frames and packets */
    frame = av_frame_alloc();
    if (!frame) {
        fprintf(stderr, "Could not allocate video frame\n");
        exit(1);
    }
    pkt = av_packet_alloc();
    if (!pkt) {
        fprintf(stderr, "Could not allocate packet\n");
        exit(1);
    }

    /* open the output file */
    outfile = fopen(outfilename, "wb");
    if (!outfile) {
        fprintf(stderr, "Could not open output file\n");
        exit(1);
    }

    /* encode video */
    for (;;) {
        ret = av_read_frame(fmt_ctx, pkt);
        if (ret < 0)
            break;

        /* check if this packet belongs to the video stream */
        if (pkt->stream_index == video_stream_idx) {
            /* decode video frame */
            ret = avcodec_send_packet(c, pkt);
            if (ret < 0) {
                fprintf(stderr, "Error decoding video frame\n");
                exit(1);
            }
            while (ret >= 0) {
                ret = avcodec_receive_frame(c, frame);
                if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
                    break;
                else if (ret < 0) {
                    fprintf(stderr, "Error during video decoding\n");
                    exit(1);
                }

                /* encode video frame */
                encode(video_enc_ctx, frame, pkt, outfile);
            }
        }

        av_packet_unref(pkt);
    }

    /* flush the encoder */
    encode(video_enc_ctx, NULL, pkt, outfile);

    /* close output file */
    fclose(outfile);

    /* free memory */
    av_frame_free(&frame);
    av_packet_free(&pkt);
    avcodec_free_context(&video_enc_ctx);

    return 0;
}

以上代码中使用了 ffmpeg 库来进行封装 MP4，其中包括了音视频同步等处理。需要注意的是，这段代码仅是一个示例，需要根据具体的需求进行适当的修改。

directshow采集音视频，x264 lame 编码后，调用 ffmpeg 封装 MP4 音视频同步问题代码实现

首先，你需要使用 DirectShow 采集音视频数据，并使用 x264 和 LAME 进行编码。然后，你需要使用 FFmpeg 封装音视频数据为 MP4 文件。下面是一个简单的示例代码，展示如何实现音视频同步：

// 初始化 DirectShow 采集器
CoInitialize(NULL);
IGraphBuilder* pGraph = NULL;
IMediaControl* pControl = NULL;
ICaptureGraphBuilder2* pBuilder = NULL;
IBaseFilter* pAudioCaptureFilter = NULL;
IBaseFilter* pVideoCaptureFilter = NULL;
IBaseFilter* pAudioEncoderFilter = NULL;
IBaseFilter* pVideoEncoderFilter = NULL;
IBaseFilter* pMuxFilter = NULL;

CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
                 IID_IGraphBuilder, (void**)&pGraph);
CoCreateInstance(CLSID_CaptureGraphBuilder2, NULL, CLSCTX_INPROC_SERVER,
                 IID_ICaptureGraphBuilder2, (void**)&pBuilder);
pBuilder->SetFiltergraph(pGraph);

// 添加音频采集器和编码器
CoCreateInstance(CLSID_AudioCapture, NULL, CLSCTX_INPROC_SERVER,
                 IID_IBaseFilter, (void**)&pAudioCaptureFilter);
CoCreateInstance(CLSID_AudioEncoder, NULL, CLSCTX_INPROC_SERVER,
                 IID_IBaseFilter, (void**)&pAudioEncoderFilter);
pGraph->AddFilter(pAudioCaptureFilter, L"Audio Capture Filter");
pGraph->AddFilter(pAudioEncoderFilter, L"Audio Encoder Filter");

// 添加视频采集器和编码器
CoCreateInstance(CLSID_VideoCapture, NULL, CLSCTX_INPROC_SERVER,
                 IID_IBaseFilter, (void**)&pVideoCaptureFilter);
CoCreateInstance(CLSID_VideoEncoder, NULL, CLSCTX_INPROC_SERVER,
                 IID_IBaseFilter, (void**)&pVideoEncoderFilter);
pGraph->AddFilter(pVideoCaptureFilter, L"Video Capture Filter");
pGraph->AddFilter(pVideoEncoderFilter, L"Video Encoder Filter");

// 添加 MP4 封装器
CoCreateInstance(CLSID_MPEG4Muxer, NULL, CLSCTX_INPROC_SERVER,
                 IID_IBaseFilter, (void**)&pMuxFilter);
pGraph->AddFilter(pMuxFilter, L"MP4 Mux Filter");

// 连接音频采集器和编码器
IPin* pAudioCaptureOutPin = GetPin(pAudioCaptureFilter, PINDIR_OUTPUT);
IPin* pAudioEncoderInPin = GetPin(pAudioEncoderFilter, PINDIR_INPUT);
pGraph->Connect(pAudioCaptureOutPin, pAudioEncoderInPin);

// 连接视频采集器和编码器
IPin* pVideoCaptureOutPin = GetPin(pVideoCaptureFilter, PINDIR_OUTPUT);
IPin* pVideoEncoderInPin = GetPin(pVideoEncoderFilter, PINDIR_INPUT);
pGraph->Connect(pVideoCaptureOutPin, pVideoEncoderInPin);

// 连接音频编码器和 MP4 封装器
IPin* pAudioEncoderOutPin = GetPin(pAudioEncoderFilter, PINDIR_OUTPUT);
IPin* pMuxInAudioPin = GetPin(pMuxFilter, PINDIR_INPUT, MEDIATYPE_Audio);
pGraph->Connect(pAudioEncoderOutPin, pMuxInAudioPin);

// 连接视频编码器和 MP4 封装器
IPin* pVideoEncoderOutPin = GetPin(pVideoEncoderFilter, PINDIR_OUTPUT);
IPin* pMuxInVideoPin = GetPin(pMuxFilter, PINDIR_INPUT, MEDIATYPE_Video);
pGraph->Connect(pVideoEncoderOutPin, pMuxInVideoPin);

// 开始采集和编码
pControl->Run();

// 等待直到采集结束
while (true) {
  if (CheckCaptureEnded(pAudioCaptureFilter) && 
      CheckCaptureEnded(pVideoCaptureFilter)) {
    break;
  }
  Sleep(10);
}

// 停止采集和编码
pControl->Stop();

// 释放资源
pMuxFilter->Release();
pVideoEncoderFilter->Release();
pVideoCaptureFilter->Release();
pAudioEncoderFilter->Release();
pAudioCaptureFilter->Release();
pBuilder->Release();
pControl->Release();
pGraph->Release();
CoUninitialize();

在上面的代码中，我们使用 DirectShow 采集音频和视频数据，并将它们分别传递给音频和视频编码器进行编码。然后，我们将编码后的音频和视频数据传递给 MP4 封装器，将它们封装为 MP4 文件。在这个过程中，我们需要确保音频和视频数据的时间戳是同步的，以确保最终的 MP4 文件中的音视频是同步的。