ffmpeg mp4 dump h264

你可以使用FFmpeg来转储MP4文件中的H.264视频流。以下是一个示例命令：

ffmpeg -i input.mp4 -c:v copy -bsf:v dump_extra output.h264

在这个命令中，`input.mp4`是你要转储的MP4文件的路径，`output.h264`是生成的H.264视频流的输出文件路径。该命令使用了`-c:v copy`参数来直接复制视频流而不进行重新编码，`-bsf:v dump_extra`参数用于将额外信息转储到H.264文件中。

执行该命令后，你将会得到一个包含H.264视频流的单个文件。请记住，这个命令只适用于转储视频流，而不包括音频流或其他元数据。

相关问题

ffmpeg3 mp4转h264 visual studio 中文

以下是使用 Visual Studio 将 MP4 转换为 H264 的步骤：

1. 下载 FFmpeg 并解压缩。
2. 打开 Visual Studio 并创建一个新的控制台应用程序项目。
3. 在解决方案资源管理器中，右键单击项目并选择“属性”。
4. 在属性对话框中，选择“VC++目录”并添加包含目录和库目录，分别指向 FFmpeg 的 include 和 lib 目录。
5. 在“属性”对话框中，选择“链接器”>“输入”并添加以下库文件：

avcodec.lib
avdevice.lib
avfilter.lib
avformat.lib
avutil.lib
postproc.lib
swresample.lib
swscale.lib

6. 在“源文件”文件夹中，右键单击并选择“添加现有项”并添加 ffmpeg.c 文件。
7. 在文件中，找到以下代码：

av_register_all();

并将其替换为以下代码：

avcodec_register_all();
av_register_all();

8. 在文件中，找到以下代码：

if ((err = avformat_open_input(&format_ctx, input_file, NULL, NULL)) < 0)

并在其后添加以下代码：

format_ctx->probesize = 100 * 1024;

9. 在文件中，找到以下代码：

if ((err = avformat_find_stream_info(format_ctx, NULL)) < 0)

并在其后添加以下代码：

av_dump_format(format_ctx, 0, input_file, 0);

10. 在文件中，找到以下代码：

if ((err = avformat_open_input(&format_ctx, input_file, NULL, NULL)) < 0)

并将其替换为以下代码：

if ((err = avformat_open_input(&format_ctx, input_file, NULL, NULL)) < 0) {
    printf("Error: Could not open input file '%s'\n", input_file);
    return -1;
}
if ((err = avformat_find_stream_info(format_ctx, NULL)) < 0) {
    printf("Error: Could not find stream information\n");
    avformat_close_input(&format_ctx);
    return -1;
}
av_dump_format(format_ctx, 0, input_file, 0);

11. 在文件中，找到以下代码：

if ((err = avformat_find_stream_info(format_ctx, NULL)) < 0)

并将其替换为以下代码：

if ((err = avformat_find_stream_info(format_ctx, NULL)) < 0) {
    printf("Error: Could not find stream information\n");
    avformat_close_input(&format_ctx);
    return -1;
}

12. 在文件中，找到以下代码：

if ((err = avcodec_open2(codec_ctx, codec, NULL)) < 0)

并将其替换为以下代码：

if ((err = avcodec_open2(codec_ctx, codec, NULL)) < 0) {
    printf("Error: Could not open codec\n");
    avformat_close_input(&format_ctx);
    return -1;
}

13. 在文件中，找到以下代码：

if ((err = avcodec_open2(codec_ctx, codec, NULL)) < 0)

并将其替换为以下代码：

if ((err = avcodec_open2(codec_ctx, codec, NULL)) < 0) {
    printf("Error: Could not open codec\n");
    avformat_close_input(&format_ctx);
    return -1;
}

14. 在文件中，找到以下代码：

if ((err = av_write_header(format_ctx)) < 0)

并将其替换为以下代码：

if ((err = avformat_write_header(format_ctx, NULL)) < 0) {
    printf("Error: Could not write header\n");
    avformat_close_input(&format_ctx);
    return -1;
}

15. 在文件中，找到以下代码：

if ((err = av_write_trailer(format_ctx)) < 0)

并将其替换为以下代码：

if ((err = av_write_trailer(format_ctx)) < 0) {
    printf("Error: Could not write trailer\n");
    avformat_close_input(&format_ctx);
    return -1;
}

16. 在文件中，找到以下代码：

if ((err = avio_open(&format_ctx->pb, output_file, AVIO_FLAG_WRITE)) < 0)

并将其替换为以下代码：

if ((err = avio_open(&format_ctx->pb, output_file, AVIO_FLAG_WRITE)) < 0) {
    printf("Error: Could not open output file '%s'\n", output_file);
    avformat_close_input(&format_ctx);
    return -1;
}

17. 在文件中，找到以下代码：

if ((err = av_interleaved_write_frame(format_ctx, &pkt)) < 0)

并将其替换为以下代码：

if ((err = av_interleaved_write_frame(format_ctx, &pkt)) < 0) {
    printf("Error: Could not write frame\n");
    avformat_close_input(&format_ctx);
    return -1;
}

18. 在文件中，找到以下代码：

if ((err = avformat_close_input(&format_ctx)) < 0)

并将其替换为以下代码：

if ((err = avformat_close_input(&format_ctx)) < 0) {
    printf("Error: Could not close input file\n");
    return -1;
}

19. 在文件中，找到以下代码：

if ((err = avcodec_close(codec_ctx)) < 0)

并将其替换为以下代码：

if ((err = avcodec_close(codec_ctx)) < 0) {
    printf("Error: Could not close codec\n");
    return -1;
}

20. 在文件中，找到以下代码：

if ((err = avformat_free_context(format_ctx)) < 0)

并将其替换为以下代码：

if ((err = avformat_free_context(format_ctx)) < 0) {
    printf("Error: Could not free format context\n");
    return -1;
}

21. 在文件中，找到以下代码：

avcodec_register_all();
av_register_all();

并在其下面添加以下代码：

avformat_network_init();

22. 在文件中，找到以下代码：

const char* input_file = "input.mp4";
const char* output_file = "output.h264";

并将其替换为以下代码：

const char* input_file = "path\\to\\input.mp4";
const char* output_file = "path\\to\\output.h264";

23. 在 Visual Studio 中，单击“生成”>“生成解决方案”以构建应用程序。
24. 打开命令提示符并导航到应用程序的 Debug 目录。
25. 输入以下命令以运行应用程序：

ffmpeg.exe

26. 程序将开始转换 MP4 文件并将其保存为 H264 文件。

请注意，这只是一个基本的示例。根据您的需求和输入文件的格式，您可能需要进行其他修改才能使其正常工作。

ffmpeg写h264视频文件

可以使用ffmpeg库将视频流编码为H.264视频文件。以下是使用ffmpeg库编写H.264视频文件的基本步骤：

1. 打开视频文件，获取输入视频流和输出视频流。
2. 配置编码器参数，例如视频分辨率、帧率、位速率等。
3. 初始化编码器。
4. 从输入视频流中读取帧。
5. 将帧送入编码器进行编码。
6. 将编码后的数据写入输出视频流。
7. 重复步骤4到6，直到所有帧都被编码并写入输出视频流。
8. 关闭输入和输出视频流，关闭编码器。

下面是一个简单的示例代码，演示如何使用ffmpeg库将视频文件编码为H.264视频文件：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>

#define __STDC_CONSTANT_MACROS
#ifdef _WIN32
//Windows
extern "C"{
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
#include "libswscale/swscale.h"
#include "libavutil/opt.h"
};
#else
//Linux...
#ifdef __cplusplus
extern "C"{
#endif
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>
#include <libavutil/opt.h>
#ifdef __cplusplus
};
#endif
#endif

using namespace std;

int main(int argc, char* argv[])
{
    // 注册所有的编解码器、复用器和过滤器等
    av_register_all();

    // 打开视频文件
    AVFormatContext *pFormatCtx = NULL;
    if (avformat_open_input(&pFormatCtx, argv[1], NULL, NULL) != 0) {
        printf("Couldn't open input stream.\n");
        return -1;
    }

    // 找到视频流信息
    if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {
        printf("Couldn't find stream information.\n");
        return -1;
    }

    // 打印视频流信息
    av_dump_format(pFormatCtx, 0, argv[1], 0);

    // 找到视频编码器
    AVCodec* pCodec = NULL;
    int videoStreamIndex = -1;
    for (int i = 0; i < pFormatCtx->nb_streams; i++) {
        if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
            videoStreamIndex = i;
            pCodec = avcodec_find_decoder(pFormatCtx->streams[i]->codec->codec_id);
            break;
        }
    }
    if (videoStreamIndex == -1) {
        printf("Couldn't find a video stream.\n");
        return -1;
    }
    if (pCodec == NULL) {
        printf("Couldn't find a suitable video decoder.\n");
        return -1;
    }

    // 打开视频编码器
    if (avcodec_open2(pFormatCtx->streams[videoStreamIndex]->codec, pCodec, NULL) < 0) {
        printf("Couldn't open codec.\n");
        return -1;
    }

    // 打开输出文件
    AVFormatContext* pOutputFormatCtx = NULL;
    AVOutputFormat* pOutputFormat = av_guess_format(NULL, "output.mp4", NULL);
    avformat_alloc_output_context2(&pOutputFormatCtx, pOutputFormat, NULL, "output.mp4");
    if (pOutputFormatCtx == NULL) {
        printf("Couldn't create output context.\n");
        return -1;
    }
    AVStream* pOutputStream = avformat_new_stream(pOutputFormatCtx, NULL);
    if (pOutputStream == NULL) {
        printf("Couldn't create output stream.\n");
        return -1;
    }
    if (avcodec_copy_context(pOutputStream->codec, pFormatCtx->streams[videoStreamIndex]->codec) < 0) {
        printf("Couldn't copy codec context.\n");
        return -1;
    }
    if (avio_open(&pOutputFormatCtx->pb, "output.mp4", AVIO_FLAG_WRITE) < 0) {
        printf("Couldn't open output file.\n");
        return -1;
    }
    if (avformat_write_header(pOutputFormatCtx, NULL) < 0) {
        printf("Error occurred when opening output file.\n");
        return -1;
    }

    // 初始化编码器
    AVCodecContext* pEncoderCtx = pOutputStream->codec;
    if (avcodec_open2(pEncoderCtx, avcodec_find_encoder(AV_CODEC_ID_H264), NULL) < 0) {
        printf("Couldn't open encoder.\n");
        return -1;
    }

    // 分配视频帧和输出缓冲区
    AVFrame* pFrame = av_frame_alloc();
    AVFrame* pFrameRGB = av_frame_alloc();
    uint8_t* buffer = (uint8_t*)av_malloc(avpicture_get_size(AV_PIX_FMT_RGB24, pEncoderCtx->width, pEncoderCtx->height));
    avpicture_fill((AVPicture*)pFrameRGB, buffer, AV_PIX_FMT_RGB24, pEncoderCtx->width, pEncoderCtx->height);

    // 初始化像素格式转换器
    struct SwsContext* imgConvertCtx = sws_getContext(pEncoderCtx->width, pEncoderCtx->height, pFormatCtx->streams[videoStreamIndex]->codec->pix_fmt,
        pEncoderCtx->width, pEncoderCtx->height, AV_PIX_FMT_RGB24, SWS_BICUBIC, NULL, NULL, NULL);

    // 编码每一帧
    AVPacket pkt;
    int frameFinished = 0;
    while (av_read_frame(pFormatCtx, &pkt) >= 0) {
        if (pkt.stream_index == videoStreamIndex) {
            avcodec_decode_video2(pFormatCtx->streams[videoStreamIndex]->codec, pFrame, &frameFinished, &pkt);
            if (frameFinished) {
                sws_scale(imgConvertCtx, (const uint8_t* const*)pFrame->data, pFrame->linesize, 0,
                    pEncoderCtx->height, pFrameRGB->data, pFrameRGB->linesize);
                AVPacket pktOut;
                av_init_packet(&pktOut);
                pktOut.data = NULL;
                pktOut.size = 0;
                int gotPacket = 0;
                avcodec_encode_video2(pEncoderCtx, &pktOut, pFrameRGB, &gotPacket);
                if (gotPacket) {
                    av_packet_rescale_ts(&pktOut, pEncoderCtx->time_base, pOutputStream->time_base);
                    pktOut.stream_index = pOutputStream->index;
                    av_write_frame(pOutputFormatCtx, &pktOut);
                }
            }
        }
        av_free_packet(&pkt);
    }

    // 编码结束
    av_write_trailer(pOutputFormatCtx);

    // 清理
    avcodec_close(pEncoderCtx);
    av_free(pEncoderCtx);
    av_frame_free(&pFrame);
    av_frame_free(&pFrameRGB);
    av_free(buffer);
    avio_close(pOutputFormatCtx->pb);
    avformat_free_context(pOutputFormatCtx);
    avcodec_close(pFormatCtx->streams[videoStreamIndex]->codec);
    avformat_close_input(&pFormatCtx);
    return 0;
}