ffmpeg C++推流 没有I帧

如果你在使用FFmpeg C++进行推流时，没有I帧的话，可以尝试以下几个方法：

1. 确认视频编码器参数是否正确设置，包括帧率、码率、分辨率等。

2. 确认视频源文件是否存在I帧，如果不存在I帧，则需要先进行视频转码或者重新采集。

3. 如果使用H.264编码器，可以调整GOP结构，增加I帧的数量，例如将GOP长度调整为1秒。

4. 如果使用rtmp协议进行推流，可以使用"-g"选项设置关键帧间隔，例如-g 30表示每隔30帧插入一个I帧。

5. 可以使用FFmpeg的命令行工具进行测试，查看是否存在I帧，以确认问题是否出在代码中。

相关问题

ffmpeg C++推流 视频服务器报没有SPS、PPS

SPS（Sequence Parameter Set）和PPS（Picture Parameter Set）是H.264视频编码中的两个重要参数集，用来描述视频的编码格式和特性。在推流过程中，如果视频服务器报没有SPS、PPS的错误，可能是由于推流的视频数据中没有包含这两个参数集的数据。

为了解决这个问题，你可以在推流之前先发送SPS和PPS数据给视频服务器。具体步骤如下：

1. 在编码器中获取SPS和PPS数据。

2. 创建一个RTMP连接并连接到视频服务器。

3. 发送SPS和PPS数据到视频服务器。

4. 开始推流视频数据。

下面是一个使用FFmpeg库实现的C++示例代码，用于在推流之前发送SPS和PPS数据：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <linux/videodev2.h>
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/mathematics.h>
#include <libavutil/time.h>

using namespace std;

int main(int argc, char** argv)
{
    // 初始化FFmpeg库
    av_register_all();
    avcodec_register_all();

    // 创建AVFormatContext对象
    AVFormatContext* format_ctx = NULL;
    avformat_alloc_output_context2(&format_ctx, NULL, "flv", "rtmp://localhost/live");

    // 创建AVIOContext对象
    AVIOContext* io_ctx = NULL;
    avio_open(&io_ctx, "rtmp://localhost/live", AVIO_FLAG_WRITE);

    // 将AVIOContext对象与AVFormatContext对象关联
    format_ctx->pb = io_ctx;

    // 创建AVCodecContext对象并设置参数
    AVCodec* codec = avcodec_find_encoder(AV_CODEC_ID_H264);
    AVCodecContext* codec_ctx = avcodec_alloc_context3(codec);
    codec_ctx->codec_id = AV_CODEC_ID_H264;
    codec_ctx->bit_rate = 400000;
    codec_ctx->width = 640;
    codec_ctx->height = 480;
    codec_ctx->time_base = (AVRational){1, 25};
    codec_ctx->gop_size = 10;
    codec_ctx->max_b_frames = 1;
    codec_ctx->pix_fmt = AV_PIX_FMT_YUV420P;

    // 打开编码器
    avcodec_open2(codec_ctx, codec, NULL);

    // 创建AVStream对象
    AVStream* stream = avformat_new_stream(format_ctx, codec);
    stream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
    stream->codecpar->codec_id = AV_CODEC_ID_H264;
    stream->codecpar->bit_rate = 400000;
    stream->codecpar->width = 640;
    stream->codecpar->height = 480;
    stream->codecpar->format = AV_PIX_FMT_YUV420P;

    // 将AVCodecContext对象与AVStream对象关联
    avcodec_parameters_from_context(stream->codecpar, codec_ctx);

    // 打开RTMP输出流
    avformat_write_header(format_ctx, NULL);

    // 发送SPS和PPS数据
    AVPacket packet;
    av_init_packet(&packet);
    packet.data = codec_ctx->extradata;
    packet.size = codec_ctx->extradata_size;
    av_write_frame(format_ctx, &packet);

    // 释放AVPacket对象的内存
    av_packet_unref(&packet);

    // 推流视频数据
    while (true)
    {
        // 获取视频帧数据
        // ...

        // 编码视频帧
        // ...

        // 推流视频帧数据
        // ...
    }

    // 关闭RTMP输出流
    av_write_trailer(format_ctx);
    avio_close(io_ctx);

    // 释放资源
    avcodec_close(codec_ctx);
    avcodec_free_context(&codec_ctx);
    avformat_free_context(format_ctx);

    return 0;
}

在这个示例代码中，我们首先创建了一个AVFormatContext对象，并通过avio_open函数创建一个AVIOContext对象，并将两个对象关联起来。然后，我们创建了一个AVCodecContext对象，并设置了视频编码的参数。接着，我们打开了H.264编码器，并创建了一个AVStream对象，并将AVCodecContext对象与AVStream对象关联起来。然后，我们打开了RTMP输出流，并通过av_write_frame函数发送SPS和PPS数据。最后，我们通过一个循环不断地获取视频帧数据，编码并推流，直到推流结束。

ffmpeg c++ rtsp拉流 并推流

使用 FFmpeg C++ API 实现 RTSP 拉流并推流需要以下步骤：

1. 初始化 FFmpeg 库和 AVFormatContext。

av_register_all();
avformat_network_init();

AVFormatContext *inputContext = avformat_alloc_context();

2. 打开 RTSP 流并读取媒体信息。

if (avformat_open_input(&inputContext, "rtsp://example.com/stream", nullptr, nullptr) != 0) {
    // 处理打开 RTSP 流失败的情况
}

if (avformat_find_stream_info(inputContext, nullptr) < 0) {
    // 处理读取媒体信息失败的情况
}

3. 查找视频流和音频流，并为它们分配解码器。

int videoStreamIndex = -1;
int audioStreamIndex = -1;

for (int i = 0; i < inputContext->nb_streams; i++) {
    AVStream *stream = inputContext->streams[i];
    AVCodecParameters *codecParameters = stream->codecpar;
    AVCodec *codec = avcodec_find_decoder(codecParameters->codec_id);

    if (!codec) {
        continue;
    }

    if (codecParameters->codec_type == AVMEDIA_TYPE_VIDEO && videoStreamIndex < 0) {
        videoStreamIndex = i;
        AVCodecContext *codecContext = avcodec_alloc_context3(codec);
        avcodec_parameters_to_context(codecContext, codecParameters);
        avcodec_open2(codecContext, codec, nullptr);
        // 处理视频流
    } else if (codecParameters->codec_type == AVMEDIA_TYPE_AUDIO && audioStreamIndex < 0) {
        audioStreamIndex = i;
        AVCodecContext *codecContext = avcodec_alloc_context3(codec);
        avcodec_parameters_to_context(codecContext, codecParameters);
        avcodec_open2(codecContext, codec, nullptr);
        // 处理音频流
    }
}

if (videoStreamIndex < 0 || audioStreamIndex < 0) {
    // 处理找不到视频流或音频流的情况
}

4. 创建输出 AVFormatContext，并为视频流和音频流添加编码器。

AVFormatContext *outputContext = avformat_alloc_context();
avformat_alloc_output_context2(&outputContext, nullptr, "flv", "rtmp://example.com/live");

if (!outputContext) {
    // 处理创建输出 AVFormatContext 失败的情况
}

AVStream *videoStream = avformat_new_stream(outputContext, nullptr);
AVStream *audioStream = avformat_new_stream(outputContext, nullptr);

if (!videoStream || !audioStream) {
    // 处理创建输出流失败的情况
}

AVCodecContext *videoCodecContext = avcodec_alloc_context3(nullptr);
AVCodecContext *audioCodecContext = avcodec_alloc_context3(nullptr);

if (!videoCodecContext || !audioCodecContext) {
    // 处理创建编码器上下文失败的情况
}

videoCodecContext->codec_id = AV_CODEC_ID_H264;
videoCodecContext->codec_type = AVMEDIA_TYPE_VIDEO;
videoCodecContext->pix_fmt = AV_PIX_FMT_YUV420P;
videoCodecContext->width = 1280;
videoCodecContext->height = 720;
videoCodecContext->time_base = {1, 25};

audioCodecContext->codec_id = AV_CODEC_ID_AAC;
audioCodecContext->codec_type = AVMEDIA_TYPE_AUDIO;
audioCodecContext->sample_rate = 44100;
audioCodecContext->channels = 2;
audioCodecContext->channel_layout = AV_CH_LAYOUT_STEREO;
audioCodecContext->time_base = {1, 44100};

if (avcodec_open2(videoCodecContext, avcodec_find_encoder(videoCodecContext->codec_id), nullptr) < 0 ||
    avcodec_open2(audioCodecContext, avcodec_find_encoder(audioCodecContext->codec_id), nullptr) < 0) {
    // 处理打开编码器失败的情况
}

avcodec_parameters_from_context(videoStream->codecpar, videoCodecContext);
avcodec_parameters_from_context(audioStream->codecpar, audioCodecContext);

5. 打开输出流并写入媒体头。

if (!(outputContext->oformat->flags & AVFMT_NOFILE)) {
    if (avio_open(&outputContext->pb, "rtmp://example.com/live", AVIO_FLAG_WRITE) < 0) {
        // 处理打开输出流失败的情况
    }
}

if (avformat_write_header(outputContext, nullptr) < 0) {
    // 处理写入媒体头失败的情况
}

6. 读取 RTSP 流中的帧并写入输出流。

AVPacket packet;
av_init_packet(&packet);

while (av_read_frame(inputContext, &packet) == 0) {
    AVStream *inputStream = inputContext->streams[packet.stream_index];
    AVStream *outputStream = outputContext->streams[packet.stream_index];

    if (packet.stream_index == videoStreamIndex) {
        packet.pts = av_rescale_q(packet.pts, inputStream->time_base, videoStream->time_base);
        packet.dts = av_rescale_q(packet.dts, inputStream->time_base, videoStream->time_base);
        packet.duration = av_rescale_q(packet.duration, inputStream->time_base, videoStream->time_base);
        packet.pos = -1;
        av_interleaved_write_frame(outputContext, &packet);
    } else if (packet.stream_index == audioStreamIndex) {
        packet.pts = av_rescale_q(packet.pts, inputStream->time_base, audioStream->time_base);
        packet.dts = av_rescale_q(packet.dts, inputStream->time_base, audioStream->time_base);
        packet.duration = av_rescale_q(packet.duration, inputStream->time_base, audioStream->time_base);
        packet.pos = -1;
        av_interleaved_write_frame(outputContext, &packet);
    }

    av_packet_unref(&packet);
}

7. 写入媒体尾并释放资源。

av_write_trailer(outputContext);
avcodec_free_context(&videoCodecContext);
avcodec_free_context(&audioCodecContext);
avformat_close_input(&inputContext);
avformat_free_context(inputContext);
avformat_free_context(outputContext);

以上就是使用 FFmpeg C++ API 实现 RTSP 拉流并推流的流程。需要注意的是，这只是一个简单的示例，实际的情况可能会更加复杂。