ffmepg 混合 aac h264 数据流 到文件 pts

要使用ffmpeg将AAC和H.264数据流混合到文件中并保留PTS，可以使用以下命令：

ffmpeg -i video.h264 -i audio.aac -c:v copy -c:a copy -map 0:v:0 -map 1:a:0 -shortest output.mp4

这个命令将视频文件video.h264和音频文件audio.aac混合到output.mp4文件中。`-c:v copy`和`-c:a copy`表示将视频和音频流直接复制到输出文件中，而不进行重新编码，以保留输入文件的质量。`-map 0:v:0`和`-map 1:a:0`表示将第一个输入文件的第一个视频流和第二个输入文件的第一个音频流映射到输出文件中。`-shortest`选项表示在第一个输入文件或第二个输入文件结束后停止输出，以避免生成过长的输出文件。同时，PTS将自动保留在输出文件中。

相关问题

ffmepg C++ 编码后 混合 aac h264 数据流 到文件 pts

在C++中使用ffmpeg进行AAC和H.264数据流混合到文件中并保留PTS，可以使用以下步骤：

1. 打开视频和音频输入流：

AVFormatContext *videoFormatCtx = avformat_alloc_context();
avformat_open_input(&videoFormatCtx, "video.h264", NULL, NULL);
avformat_find_stream_info(videoFormatCtx, NULL);

AVFormatContext *audioFormatCtx = avformat_alloc_context();
avformat_open_input(&audioFormatCtx, "audio.aac", NULL, NULL);
avformat_find_stream_info(audioFormatCtx, NULL);

2. 查找H.264和AAC数据流的视频流和音频流索引：

int videoStreamIndex = av_find_best_stream(videoFormatCtx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
int audioStreamIndex = av_find_best_stream(audioFormatCtx, AVMEDIA_TYPE_AUDIO, -1, -1, NULL, 0);

3. 分别打开视频和音频解码器：

AVCodecContext *videoCodecCtx = avcodec_alloc_context3(NULL);
avcodec_parameters_to_context(videoCodecCtx, videoFormatCtx->streams[videoStreamIndex]->codecpar);
AVCodec *videoCodec = avcodec_find_decoder(videoCodecCtx->codec_id);
avcodec_open2(videoCodecCtx, videoCodec, NULL);

AVCodecContext *audioCodecCtx = avcodec_alloc_context3(NULL);
avcodec_parameters_to_context(audioCodecCtx, audioFormatCtx->streams[audioStreamIndex]->codecpar);
AVCodec *audioCodec = avcodec_find_decoder(audioCodecCtx->codec_id);
avcodec_open2(audioCodecCtx, audioCodec, NULL);

4. 创建输出文件并打开视频和音频编码器：

AVFormatContext *outputFormatCtx = avformat_alloc_context();
avformat_alloc_output_context2(&outputFormatCtx, NULL, NULL, "output.mp4");
AVStream *outputVideoStream = avformat_new_stream(outputFormatCtx, NULL);
AVStream *outputAudioStream = avformat_new_stream(outputFormatCtx, NULL);

AVCodecContext *outputVideoCodecCtx = avcodec_alloc_context3(NULL);
avcodec_parameters_to_context(outputVideoCodecCtx, outputVideoStream->codecpar);
AVCodec *outputVideoCodec = avcodec_find_encoder(outputVideoCodecCtx->codec_id);
avcodec_open2(outputVideoCodecCtx, outputVideoCodec, NULL);

AVCodecContext *outputAudioCodecCtx = avcodec_alloc_context3(NULL);
avcodec_parameters_to_context(outputAudioCodecCtx, outputAudioStream->codecpar);
AVCodec *outputAudioCodec = avcodec_find_encoder(outputAudioCodecCtx->codec_id);
avcodec_open2(outputAudioCodecCtx, outputAudioCodec, NULL);

avio_open(&outputFormatCtx->pb, "output.mp4", AVIO_FLAG_WRITE);
avformat_write_header(outputFormatCtx, NULL);

5. 读取视频和音频数据流，进行编码和写入输出文件：

AVPacket videoPacket, audioPacket;
int videoFrameCount = 0, audioFrameCount = 0;

while (av_read_frame(videoFormatCtx, &videoPacket) >= 0 || av_read_frame(audioFormatCtx, &audioPacket) >= 0) {
    if (videoPacket.stream_index == videoStreamIndex) {
        AVFrame *videoFrame = av_frame_alloc();
        avcodec_send_packet(videoCodecCtx, &videoPacket);
        avcodec_receive_frame(videoCodecCtx, videoFrame);

        // 对视频帧进行编码

        av_packet_unref(&videoPacket);
        av_frame_free(&videoFrame);
    } else if (audioPacket.stream_index == audioStreamIndex) {
        AVFrame *audioFrame = av_frame_alloc();
        avcodec_send_packet(audioCodecCtx, &audioPacket);
        avcodec_receive_frame(audioCodecCtx, audioFrame);

        // 对音频帧进行编码

        av_packet_unref(&audioPacket);
        av_frame_free(&audioFrame);
    }

    // 将编码后的视频帧和音频帧写入输出文件
    av_write_frame(outputFormatCtx, &outputPacket);
    av_packet_unref(&outputPacket);
}

// 写入文件尾信息
av_write_trailer(outputFormatCtx);

这个C++代码片段演示了如何使用ffmpeg将AAC和H.264数据流混合到文件中并保留PTS。注意，在代码中省略了一些错误处理和释放资源的步骤，确保在实际使用时进行处理。

ffmepg C++ 编码后 混合 aac h264 数据流 到文件 pts 音视频同步

您好，针对您的问题，我可以给出如下思路：

1. 使用FFmpeg的C++ API来编码H264和AAC数据流，并将它们混合在一起。

2. 对于每个视频帧和音频帧，使用PTS（Presentation Time Stamp）来保证它们的时间戳是正确的。

3. 将编码后的H264和AAC数据流写入一个文件中，同时确保它们的时间戳是同步的。

下面是一个简单的示例代码，仅供参考：

#include <iostream>
#include <string>
#include <vector>
#include <chrono>
#include <thread>

extern "C" {
#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include <libavutil/opt.h>
#include <libavutil/timestamp.h>
#include <libavutil/audio_fifo.h>
}

#define AUDIO_SAMPLE_RATE 48000
#define AUDIO_CHANNELS 2
#define AUDIO_FORMAT AV_SAMPLE_FMT_FLT
#define AUDIO_BITRATE 128000

using namespace std;

int main(int argc, char* argv[])
{
    // Initialize FFmpeg
    av_register_all();
    avcodec_register_all();

    // Open video output file
    AVFormatContext* out_ctx;
    avformat_alloc_output_context2(&out_ctx, NULL, NULL, "output.mp4");
    AVStream* video_stream = avformat_new_stream(out_ctx, NULL);
    AVStream* audio_stream = avformat_new_stream(out_ctx, NULL);

    // Configure video stream
    AVCodec* video_codec = avcodec_find_encoder(AV_CODEC_ID_H264);
    AVCodecContext* video_ctx = avcodec_alloc_context3(video_codec);
    video_ctx->bit_rate = 400000;
    video_ctx->width = 640;
    video_ctx->height = 480;
    video_ctx->time_base = { 1, 25 };
    video_ctx->gop_size = 10;
    video_ctx->max_b_frames = 1;
    avcodec_open2(video_ctx, video_codec, NULL);
    avcodec_parameters_from_context(video_stream->codecpar, video_ctx);
    video_stream->time_base = video_ctx->time_base;

    // Configure audio stream
    AVCodec* audio_codec = avcodec_find_encoder(AV_CODEC_ID_AAC);
    AVCodecContext* audio_ctx = avcodec_alloc_context3(audio_codec);
    audio_ctx->sample_rate = AUDIO_SAMPLE_RATE;
    audio_ctx->channels = AUDIO_CHANNELS;
    audio_ctx->sample_fmt = AUDIO_FORMAT;
    audio_ctx->bit_rate = AUDIO_BITRATE;
    audio_ctx->time_base = { 1, AUDIO_SAMPLE_RATE };
    avcodec_open2(audio_ctx, audio_codec, NULL);
    avcodec_parameters_from_context(audio_stream->codecpar, audio_ctx);
    audio_stream->time_base = audio_ctx->time_base;

    // Open output file
    avio_open(&out_ctx->pb, "output.mp4", AVIO_FLAG_WRITE);

    // Write header to output file
    avformat_write_header(out_ctx, NULL);

    // Encode and write frames to output file
    for (int i = 0; i < 100; i++) {
        // Encode video frame
        AVFrame* video_frame = av_frame_alloc();
        video_frame->width = video_ctx->width;
        video_frame->height = video_ctx->height;
        video_frame->format = video_ctx->pix_fmt;
        av_frame_get_buffer(video_frame, 0);
        // Fill video frame with data...
        avcodec_send_frame(video_ctx, video_frame);
        AVPacket video_pkt;
        av_init_packet(&video_pkt);
        avcodec_receive_packet(video_ctx, &video_pkt);
        video_pkt.stream_index = video_stream->index;
        video_pkt.pts = i * video_ctx->time_base.den / (video_ctx->time_base.num * 25);
        video_pkt.dts = video_pkt.pts;
        av_interleaved_write_frame(out_ctx, &video_pkt);
        av_packet_unref(&video_pkt);
        av_frame_free(&video_frame);

        // Encode audio frame
        AVFrame* audio_frame = av_frame_alloc();
        audio_frame->sample_rate = audio_ctx->sample_rate;
        audio_frame->channels = audio_ctx->channels;
        audio_frame->format = audio_ctx->sample_fmt;
        av_frame_get_buffer(audio_frame, 0);
        // Fill audio frame with data...
        avcodec_send_frame(audio_ctx, audio_frame);
        AVPacket audio_pkt;
        av_init_packet(&audio_pkt);
        avcodec_receive_packet(audio_ctx, &audio_pkt);
        audio_pkt.stream_index = audio_stream->index;
        audio_pkt.pts = i * audio_ctx->time_base.den / AUDIO_SAMPLE_RATE;
        audio_pkt.dts = audio_pkt.pts;
        av_interleaved_write_frame(out_ctx, &audio_pkt);
        av_packet_unref(&audio_pkt);
        av_frame_free(&audio_frame);

        // Sleep for a while to simulate real-time processing
        this_thread::sleep_for(chrono::milliseconds(40));
    }

    // Write trailer to output file
    av_write_trailer(out_ctx);

    // Close output file
    avio_close(out_ctx->pb);
    avformat_free_context(out_ctx);

    // Cleanup FFmpeg
    avcodec_free_context(&video_ctx);
    avcodec_free_context(&audio_ctx);

    return 0;
}

在上述示例代码中，我们先初始化了FFmpeg，并创建了一个输出文件。然后，我们分别配置了视频流和音频流的编码参数，并将它们添加到输出文件中。接下来，我们编码并写入了100个视频帧和音频帧，并使用PTS保证它们的时间戳是正确的。最后，我们写入了输出文件的尾部，并关闭了输出文件。

请注意，上述示例代码仅供参考，您需要根据自己的实际需求进行修改和优化。