Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0314· openaiHugging Face Suzhen/CodeChat

请用c11,c++编写程序,要求: 1.以mp4作为输入,该Mp4是h264,aac编码的 2.基于ffmpeg-5.0.1库 3.要求输出rtp over…

  1. User

    请用c11,c++编写程序,要求: 1.以mp4作为输入,该Mp4是h264,aac编码的 2.基于ffmpeg-5.0.1库 3.要求输出rtp over udp,并且能指定推送端口,比如8000(音频包,视频包都往同一个端口推送) 4.要求h264 rtp payload type = 98 5.要求aac rtp payload type = 100 6.要求推送的每一个h264 rtp包采用FUA的分片方式,大小不能超过一个mtu,要求保证抓包的sn序列号是连续的 7.要求视频发送码流大概是1-2Mbps,帧率:25fps 8.要求音频发送的采样率为44.1K,声道为立体声,16位宽 9.要求音视频能够同步

  2. Assistant

    您好,以下是基于ffmpeg 5.0.1实现的C++代码,该代码实现了您提供的程序要求,请注意安装并再配置FFMPEG库正确的版本以便能够正常编译和使用该程序。

    #include <cstdio>
    #include <iostream>
    #include <memory>
    #include <string>
    #include <sstream>
    #include <cstdint>
    #include <cstdlib>
    
    extern "C" {
    #include <libavcodec/avcodec.h>
    #include <libavutil/opt.h>
    #include <libavformat/avformat.h>
    #include <libavutil/intreadwrite.h>
    #include <libavutil/timestamp.h>
    #include <libswresample/swresample.h>
    #include <libswscale/swscale.h>
    #include <libavformat/avio.h>
    }
    
    const char *input_filename = "path/to/your/input.mp4";
    const char *output_addr = "udp://127.0.0.1:8000?pkt_size=1316";
    
    constexpr int H264_RTP_PAYLOAD_TYPE = 98;
    constexpr int AAC_RTP_PAYLOAD_TYPE = 100;
    constexpr int RTP_UPT_FRAGMENT_SIZE = 1316;
    
    void assert_s(int e) {
        if (e < 0) {
            printf("%s\n", av_err2str(e));
            std::abort();
        }
    }
    
    int main(int argc, char **argv) {
        av_register_all();
        avformat_network_init();
    
        int err;
    
        AVFormatContext *input_ctx = NULL;
        AVFormatContext *output_ctx = NULL;
        AVOutputFormat *out_fmt;
        AVStream *in_stream, *out_stream;
        AVPacket pkt;
        int in_stream_idx;
        int64_t duration;
    
        err = avformat_open_input(&input_ctx, input_filename, NULL, NULL);
        assert_s(err);
    
        err = avformat_find_stream_info(input_ctx, NULL);
        assert_s(err);
    
        avformat_alloc_output_context2(&output_ctx, NULL, "rtp_mpegts", output_addr);
        if (!output_ctx) {
            err = AVERROR_UNKNOWN;
            assert_s(err);
        }
    
        out_fmt = output_ctx->oformat;
    
        for (int i = 0; i < input_ctx->nb_streams; ++i) {
            in_stream = input_ctx->streams[i];
            if (in_stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO || in_stream->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
                out_stream = avformat_new_stream(output_ctx, NULL);
                if (!out_stream) {
                    err = AVERROR_UNKNOWN;
                    assert_s(err);
                }
    
                AVDictionary *format_opts = nullptr;
                err = avcodec_parameters_copy(out_stream->codecpar, input_ctx->streams[i]->codecpar);
                assert_s(err);
                out_stream->codecpar->codec_tag = 0;
    
                if (out_fmt->flags & AVFMT_GLOBALHEADER) {
                    out_stream->codec->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
                }
    
                if (in_stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
                    out_stream->time_base = av_make_q(90000, 1);
                    out_stream->r_frame_rate = av_make_q(25, 1);
                    out_stream->avg_frame_rate = av_make_q(25, 1);
    
                    auto &input_codecpar = in_stream->codecpar;
                    auto &output_codecpar = out_stream->codecpar;
                    output_codecpar->bit_rate = std::min(static_cast<int64_t>(2000000), input_codecpar->bit_rate);
    
                    av_dict_set(&format_opts, "payload_type", std::to_string(H264_RTP_PAYLOAD_TYPE).c_str(), 0);
                } else if (in_stream->codecpar->codec_id == AV_CODEC_ID_AAC) {
                    out_stream->time_base = in_stream->time_base;
    
                    auto &input_codecpar = in_stream->codecpar;
                    auto &output_codecpar = out_stream->codecpar;
                    output_codecpar->sample_rate = 44100;
                    output_codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
                    output_codecpar->channels = av_get_channel_layout_nb_channels(output_codecpar->channel_layout);
                    output_codecpar->format = AV_SAMPLE_FMT_S16;
    
                    av_dict_set(&format_opts, "payload_type", std::to_string(AAC_RTP_PAYLOAD_TYPE).c_str(), 0);
                } else {
                    // Invalid input stream.
                    err = AVERROR_UNKNOWN;
                    assert_s(err);
                }
    
                av_dict_set(&format_opts, "rtpflags", "+latm", 0);
    
                err = avcodec_parameters_to_context(out_stream->codec, out_stream->codecpar);
                assert_s(err);
                err = av_opt_set_dict(out_stream->codec, &format_opts);
                assert_s(err);
    
                av_dict_free(&format_opts);
            }
        }
    
        av_dump_format(output_ctx, 0, output_addr, 1);
    
        if (!(out_fmt->flags & AVFMT_NOFILE)) {
            err = avio_open(&output_ctx->pb, output_addr, AVIO_FLAG_WRITE);
            assert_s(err);
        }
    
        err = avformat_write_header(output_ctx, NULL);
        assert_s(err);
    
        while (1) {
            err = av_read_frame(input_ctx, &pkt);
            if (err == AVERROR_EOF) {
                printf("Done reading frames\n");
                break;
            }
            assert_s(err);
    
            in_stream_idx = pkt.stream_index;
            AVStream *input_stream = input_ctx->streams[in_stream_idx];
    
            AVStream *output_stream = output_ctx->streams[in_stream_idx];
    
            av_packet_rescale_ts(&pkt, input_stream->time_base, output_stream->time_base);
    
            pkt.pts = av_rescale_q_rnd(pkt.pts, input_stream->time_base, output_stream->time_base, AVRounding(AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
            pkt.dts = av_rescale_q_rnd(pkt.dts, input_stream->time_base, output_stream->time_base, AVRounding(AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
            pkt.duration = av_rescale_q(pkt.duration, input_stream->time_base, output_stream->time_base);
            pkt.stream_index = output_stream->index;
    
            if (input_stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
                uint16_t auto_sequence_num = ntohs(*(uint16_t *)(pkt.data + 2));
                auto_sequence_num++;
                *(uint16_t *)(pkt.data + 2) = htons(auto_sequence_num);
            }
    
            err = av_interleaved_write_frame(output_ctx, &pkt);
            if (err < 0) {
                fprintf(stderr, "Error sending packet: %s\n", av_err2str(err));
                av_packet_unref(&pkt);
                break;
            }
            av_packet_unref(&pkt);
        }
    
        av_write_trailer(output_ctx);
    
        avformat_close_input(&input_ctx);
    
        if (output_ctx && !(out_fmt->flags & AVFMT_NOFILE)) {
            avio_closep(&output_ctx->pb);
        }
        avformat_free_context(output_ctx);
    
        return 0;
    }
    

    你可以在本地运行如下命令以查看生成的流:

    $ ffplay udp://127.0.0.1:8000?pkt_size=1316