rtmp avformat_write_header -22

avformat_write_header返回值为-22表示出现了无效的参数。这可能是因为你在调用avformat_write_header函数时传递了错误的参数或者没有正确的初始化编解码器导致的。你可以检查以下几点：

1. 检查传递给avformat_write_header函数的AVFormatContext结构体是否正确初始化，包括设置正确的封装格式、视频/音频编码器等参数。

2. 检查AVIOContext参数是否正确设置，如果你使用了自定义的IO回调函数，需要确保回调函数正确实现。

3. 检查是否正确设置了视频/音频流的参数，包括编码器、分辨率、帧率、采样率、声道数等。

如果以上几点都检查无误，还是出现-22错误码，可以尝试打印出错误信息以便更好的定位问题，例如使用av_strerror函数打印错误信息。

相关问题

生成一个qt下使用opencv 进行 rtmp推流 其中包含 rtmp_sendpacket 例程

很高兴能为您提供帮助，以下是生成一个Qt下使用OpenCV进行rtmp推流的步骤和例程：

步骤：

1.安装OpenCV，可以从OpenCV官网下载对应的版本进行安装。

2.下载并安装FFmpeg，可以从FFmpeg官网下载对应的版本进行安装。

3.在Qt中配置OpenCV和FFmpeg，在项目.pro文件中添加以下代码：

INCLUDEPATH += [OpenCV的include目录]
LIBS += -L[OpenCV的lib目录] -lopencv_core -lopencv_highgui -lopencv_imgproc -lopencv_videoio -lopencv_imgcodecs

INCLUDEPATH += [FFmpeg的include目录]
LIBS += -L[FFmpeg的lib目录] -lavcodec -lavdevice -lavfilter -lavformat -lavutil -lswresample -lswscale -lavcodec

4.编写rtmp推流代码，示例代码如下：

#include <opencv2/opencv.hpp>
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/opt.h>
#include <libavutil/imgutils.h>
#include <libswscale/swscale.h>

#define STREAM_URL "rtmp://[推流地址]"

using namespace cv;

int main()
{
    AVFormatContext *pFormatCtx;
    AVOutputFormat *fmt;
    AVStream *video_st;
    AVCodecContext *pCodecCtx;
    AVCodec *pCodec;
    AVFrame *pFrame, *pFrameRGB;
    uint8_t *buffer;
    int videoindex = -1;
    int framecnt = 0;
    int64_t start_time = 0;
    struct SwsContext *img_convert_ctx;

    // OpenCV读取视频文件
    VideoCapture capture(0);
    if(!capture.isOpened())
    {
        printf("OpenCV: Could not open camera.\n");
        return -1;
    }

    // 初始化FFmpeg
    av_register_all();

    // 初始化输出格式
    avformat_alloc_output_context2(&pFormatCtx, NULL, "flv", STREAM_URL);
    if(!pFormatCtx)
    {
        printf("FFmpeg: Could not allocate output context.\n");
        return -1;
    }
    fmt = pFormatCtx->oformat;

    // 添加视频流
    video_st = avformat_new_stream(pFormatCtx, 0);
    if(!video_st)
    {
        printf("FFmpeg: Could not create new stream.\n");
        return -1;
    }
    videoindex = video_st->index;

    // 设置编码器参数
    pCodecCtx = video_st->codec;
    pCodecCtx->codec_id = fmt->video_codec;
    pCodecCtx->codec_type = AVMEDIA_TYPE_VIDEO;
    pCodecCtx->pix_fmt = AV_PIX_FMT_YUV420P;
    pCodecCtx->width = capture.get(CV_CAP_PROP_FRAME_WIDTH);
    pCodecCtx->height = capture.get(CV_CAP_PROP_FRAME_HEIGHT);
    pCodecCtx->time_base.num = 1;
    pCodecCtx->time_base.den = 25;

    // 查找编码器
    pCodec = avcodec_find_encoder(pCodecCtx->codec_id);
    if(!pCodec)
    {
        printf("FFmpeg: Could not find encoder.\n");
        return -1;
    }

    // 打开编码器
    if(avcodec_open2(pCodecCtx, pCodec, NULL) < 0)
    {
        printf("FFmpeg: Could not open encoder.\n");
        return -1;
    }

    // 分配视频帧内存
    pFrame = av_frame_alloc();
    pFrameRGB = av_frame_alloc();

    // 分配视频帧缓冲区内存
    int numBytes = av_image_get_buffer_size(AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height, 1);
    buffer = (uint8_t *)av_malloc(numBytes * sizeof(uint8_t));
    av_image_fill_arrays(pFrame->data, pFrame->linesize, buffer, AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height, 1);

    // 分配视频帧RGB缓冲区内存
    uint8_t *rgbBuffer = (uint8_t *)av_malloc(av_image_get_buffer_size(AV_PIX_FMT_RGB24, pCodecCtx->width, pCodecCtx->height, 1));
    av_image_fill_arrays(pFrameRGB->data, pFrameRGB->linesize, rgbBuffer, AV_PIX_FMT_RGB24, pCodecCtx->width, pCodecCtx->height, 1);

    // 初始化图像转换上下文
    img_convert_ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height, AV_PIX_FMT_RGB24, pCodecCtx->width, pCodecCtx->height, AV_PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL);

    // 输出格式信息
    av_dump_format(pFormatCtx, 0, STREAM_URL, 1);

    // 打开输出URL
    if(!(fmt->flags & AVFMT_NOFILE))
    {
        if(avio_open(&pFormatCtx->pb, STREAM_URL, AVIO_FLAG_WRITE) < 0)
        {
            printf("FFmpeg: Could not open output URL.\n");
            return -1;
        }
    }

    // 写入头部
    avformat_write_header(pFormatCtx, NULL);

    while(capture.read(pFrameRGB->data[0]))
    {
        // RGB转YUV
        sws_scale(img_convert_ctx, pFrameRGB->data, pFrameRGB->linesize, 0, pCodecCtx->height, pFrame->data, pFrame->linesize);

        // 视频帧时间
        AVRational time_base = {1, 1000};
        int64_t pts = framecnt * (pCodecCtx->time_base.den * 1000 / pCodecCtx->time_base.num) / 25;
        pFrame->pts = av_rescale_q(pts, time_base, video_st->time_base);
        pFrame->key_frame = 1;

        // 编码并推送视频帧
        AVPacket pkt;
        int ret = avcodec_send_frame(pCodecCtx, pFrame);
        if(ret < 0)
        {
            printf("FFmpeg: Error sending frame.\n");
            break;
        }
        while(ret >= 0)
        {
            ret = avcodec_receive_packet(pCodecCtx, &pkt);
            if(ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
            {
                break;
            }
            else if(ret < 0)
            {
                printf("FFmpeg: Error encoding frame.\n");
                return -1;
            }

            // 发送视频帧Packet
            av_packet_rescale_ts(&pkt, pCodecCtx->time_base, video_st->time_base);
            pkt.stream_index = videoindex;
            ret = av_interleaved_write_frame(pFormatCtx, &pkt);
            av_packet_unref(&pkt);
        }

        // 输出进度信息
        printf("FFmpeg: Encode frame index:%d\n", framecnt);

        framecnt++;

        // 推流时间
        if(start_time == 0)
        {
            start_time = av_gettime();
        }
        int64_t now_time = av_gettime() - start_time;
        int64_t duration = framecnt * pCodecCtx->time_base.num * 1000 / pCodecCtx->time_base.den;
        if(now_time < duration)
        {
            av_usleep(duration - now_time);
        }
    }

    // 写入尾部
    av_write_trailer(pFormatCtx);

    // 释放内存
    avcodec_close(pCodecCtx);
    av_free(pCodecCtx);
    av_frame_free(&pFrame);
    av_frame_free(&pFrameRGB);
    av_free(buffer);
    av_free(rgbBuffer);
    avio_close(pFormatCtx->pb);
    avformat_free_context(pFormatCtx);

    return 0;
}

注：在实际使用中需要将[推流地址]替换为实际的地址。

这是一个简单的例程，仅供参考，具体实现方式还需要根据实际情况进行调整和完善。

./ffmpeg_g -re -i /home/tsdl/Downloads/test0524.mp4 -vcodec libx264 -profile:v baseline -r 25 -g 50 -f rtc "http://192.168.114.34:1985/rtc/v1/whip/?app=live&stream=livestream"生成C代码示例

以下是使用FFmpeg库生成相应的C代码示例，可以实现将本地视频文件实时推流到指定的RTMP服务器：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <unistd.h>

#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include <libavutil/avutil.h>

int main(int argc, char **argv)
{
    AVFormatContext *fmt_ctx = NULL;
    AVCodecContext *video_enc_ctx = NULL;
    AVCodec *video_enc = NULL;
    AVStream *video_stream = NULL;
    AVOutputFormat *out_fmt = NULL;
    AVIOContext *out_io_ctx = NULL;
    AVFormatContext *out_fmt_ctx = NULL;
    AVPacket pkt;
    int ret;

    char *in_filename = "/home/tsdl/Downloads/test0524.mp4";
    char *out_filename = "http://192.168.114.34:1985/rtc/v1/whip/?app=live&stream=livestream";

    // 注册所有的编解码器、封装器和协议
    av_register_all();
    avformat_network_init();

    // 打开输入文件
    if ((ret = avformat_open_input(&fmt_ctx, in_filename, NULL, NULL)) < 0) {
        fprintf(stderr, "Could not open input file '%s'\n", in_filename);
        goto end;
    }

    // 查找流信息
    if ((ret = avformat_find_stream_info(fmt_ctx, NULL)) < 0) {
        fprintf(stderr, "Could not find stream information\n");
        goto end;
    }

    // 选择视频流
    int video_stream_index = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &video_enc, 0);
    if (video_stream_index < 0) {
        fprintf(stderr, "Could not find video stream in input file '%s'\n", in_filename);
        goto end;
    }

    // 打开视频解码器
    video_enc_ctx = avcodec_alloc_context3(video_enc);
    if (!video_enc_ctx) {
        fprintf(stderr, "Could not allocate video encoder context\n");
        goto end;
    }

    if ((ret = avcodec_parameters_to_context(video_enc_ctx, fmt_ctx->streams[video_stream_index]->codecpar)) < 0) {
        fprintf(stderr, "Could not copy video codec parameters to encoder context\n");
        goto end;
    }

    if ((ret = avcodec_open2(video_enc_ctx, video_enc, NULL)) < 0) {
        fprintf(stderr, "Could not open video encoder\n");
        goto end;
    }

    // 创建输出格式上下文
    if ((ret = avformat_alloc_output_context2(&out_fmt_ctx, NULL, "rtmp", out_filename)) < 0) {
        fprintf(stderr, "Could not allocate output format context\n");
        goto end;
    }

    // 创建输出流
    video_stream = avformat_new_stream(out_fmt_ctx, NULL);
    if (!video_stream) {
        fprintf(stderr, "Could not allocate video output stream\n");
        goto end;
    }

    // 复制编解码器参数
    if ((ret = avcodec_parameters_copy(video_stream->codecpar, fmt_ctx->streams[video_stream_index]->codecpar)) < 0) {
        fprintf(stderr, "Could not copy video codec parameters\n");
        goto end;
    }

    // 设置输出流时间基准
    video_stream->time_base = video_enc_ctx->time_base;

    // 打开输出IO上下文
    if ((ret = avio_open2(&out_io_ctx, out_filename, AVIO_FLAG_WRITE, NULL, NULL)) < 0) {
        fprintf(stderr, "Could not open output url '%s'\n", out_filename);
        goto end;
    }

    out_fmt_ctx->pb = out_io_ctx;

    // 写入输出格式头部
    if ((ret = avformat_write_header(out_fmt_ctx, NULL)) < 0) {
        fprintf(stderr, "Could not write output format header\n");
        goto end;
    }

    // 初始化AVPacket
    av_init_packet(&pkt);
    pkt.data = NULL;
    pkt.size = 0;

    // 读取并编码视频帧
    while (1) {
        AVStream *in_stream, *out_stream;
        AVFrame *frame = av_frame_alloc();

        if ((ret = av_read_frame(fmt_ctx, &pkt)) < 0) {
            break;
        }

        if (pkt.stream_index == video_stream_index) {
            avcodec_send_packet(video_enc_ctx, &pkt);

            while (ret >= 0) {
                ret = avcodec_receive_frame(video_enc_ctx, frame);
                if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
                    break;
                } else if (ret < 0) {
                    fprintf(stderr, "Error while receiving a video frame from the encoder\n");
                    goto end;
                }

                // 编码并发送视频帧
                av_packet_unref(&pkt);
                av_init_packet(&pkt);

                ret = avcodec_send_frame(video_enc_ctx, frame);
                if (ret < 0) {
                    fprintf(stderr, "Error while sending a video frame to the encoder\n");
                    goto end;
                }

                while (ret >= 0) {
                    ret = avcodec_receive_packet(video_enc_ctx, &pkt);
                    if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
                        break;
                    } else if (ret < 0) {
                        fprintf(stderr, "Error while receiving a video packet from the encoder\n");
                        goto end;
                    }

                    // 发送视频包到输出流
                    av_packet_rescale_ts(&pkt, video_enc_ctx->time_base, video_stream->time_base);
                    pkt.stream_index = video_stream->index;
                    av_interleaved_write_frame(out_fmt_ctx, &pkt);

                    av_packet_unref(&pkt);
                    av_init_packet(&pkt);
                }
            }

            av_frame_unref(frame);
        }

        av_packet_unref(&pkt);
    }

    // 写入输出格式尾部
    av_write_trailer(out_fmt_ctx);

end:
    if (video_enc_ctx) {
        avcodec_free_context(&video_enc_ctx);
    }

    if (fmt_ctx) {
        avformat_close_input(&fmt_ctx);
    }

    if (out_fmt_ctx) {
        avio_closep(&out_fmt_ctx->pb);
        avformat_free_context(out_fmt_ctx);
    }

    if (out_io_ctx) {
        av_freep(&out_io_ctx->buffer);
        av_free(out_io_ctx);
    }

    if (ret < 0) {
        fprintf(stderr, "Error occurred: %s\n", av_err2str(ret));
        return 1;
    }

    return 0;
}

注意需要将代码中的输入文件路径和输出URL替换为实际的路径和URL。另外，还需要在编译时链接FFmpeg库，例如使用gcc编译器编译上述代码的命令为：

gcc -o ffmpeg_push_stream ffmpeg_push_stream.c -lavformat -lavcodec -lavutil -lm