ffmpeg c++代码推流RTSP/RTMP（命令行推流）

最新推荐文章于 2024-05-05 14:54:55 发布
最新推荐文章于 2024-05-05 14:54:55 发布
阅读量1.1w 收藏 90
点赞数 11
文章标签： ffmpeg c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37400316/article/details/127632441
版权

由于ffmpeg推出的rtsp或者rtmp端口需要Listen，所以需要开启端口TCP/UDP，之后采用ffmpeg向端口推送数据

第一，安装rtsp-simple-server

release下载地址https://github.com/aler9/rtsp-simple-server/releases/tag/v0.20.1
源码下载github地址
下载后解压后配置好端口，运行执行文件即可进行端口监听。

./rtsp-simple-server

第二，测试

FFmpeg 常用的命令行参数有

		-c：指定编码器
		-c copy：直接复制，不经过重新编码(这样比较快)
		-c:v：指定视频编码器
		-c:a：指定音频编码器
		-i：指定输入文件
		-an：去除音频流,不处理音频
		-vn：去除视频流,不处理视频
		-preset：指定输出的视频质量，会影响文件的生成速度，候选值有：ultrafast, superfast, veryfast, faster, fast, medium, slow, slower, veryslow.
		-y：不经过确认，输出时直接覆盖同名文件
		-vcodec: 设定视频编解码器，未设定时则使用与输入流相同的编解码器
		-b: 设定视频流量，默认为200Kbit/s
		-r: 设定帧速率，默认为25
		-s: 设定画面的宽与高
		-aspect: 设定画面的比例
		-ss: 开始时间
		
		# 音频参数
		-ar: 设定采样率
		-ac: 设定声音的Channel数
		-acodec: 设定声音编解码器，未设定时则使用与输入流相同的编解码器
		-an: 不处理音频
  • 转码

    H264 转 MP4$ ffmpeg -i "xx.h264" -c:v copy -f mp4 "xx.mp4"

    MP4 转 TSffmpeg -i xx.mp4 -c copy -vbsf h264_mp4toannexb faded.ts

  • 推流

    监听 UDP 端口转推为 HLS 流，$ ffmpeg -i udp://127.0.0.1:9000-c copy -f hls xx.m3u8
    将 MP4 通过 UDP 协议推送为 RTSP 流ffmpeg -re -i xx.mp4 -rtsp_transport tcp -vcodec h264 -f rtsp rtsp://192.168.3.4/xx
    将 h264 文件推流到 RTMP 服务器 ffmpeg -re -i hik.h264 -c copy -f flv rtmp://192.168.3.4/live/fromh264
    转推海康RTSP到RTMP服务器ffmpeg -rtsp_transport tcp -i rtsp://username:password@192.168.42.128:554/h264/ch1/main/av_stream -vcodec copy -acodec copy -ar 44100 -strict -2 -ac 1 -f flv -s 1280x720 -q 10 -f flv rtmp://192.168.3.4/live/fromrtsp

第三，引用头文件

在这里插入图片描述

代码推送视频
#include <iostream>

extern "C"
{
#include "libavformat/avformat.h"
#include "libavutil/mathematics.h"
#include "libavutil/time.h"
};

int avError(int errNum);

int main(int argc, char* argv[]){
    //输入文件
    const char *fileAddress = "../xx.mp4";
    //推流地址
    const char *rtmpAddress = "rtsp://0.0.0.0:8554/test";

    //注册所有库
    av_register_all();
    //初始化网络库
    avformat_network_init();


    
    //                       输入流处理部分                      ///
    
    AVFormatContext *ictx = NULL;
    //打开文件
    int ret = avformat_open_input(&ictx, fileAddress, 0, NULL);
    if (ret < 0)
    {
        return avError(ret);
    }
    std::cout << "avformat_open_input succeeded" << std::endl;
    //获取流信息
    ret = avformat_find_stream_info(ictx, 0);
    if (ret != 0)
    {
        return avError(ret);
    }
    //打印视频信息
    av_dump_format(ictx, 0, fileAddress, 0);


    
    //                       输出流处理部分                      ///
    
    AVFormatContext *octx = NULL;
    //创建输出上下文
    ret = avformat_alloc_output_context2(&octx, NULL, "rtsp", rtmpAddress); 
    //    ret = avformat_alloc_output_context2(&octx, NULL, "rtsp", rtmpAddress); 
    if (ret < 0) {
        return avError(ret);
    }
    std::cout << "avformat_alloc_output_context2 succeeded" << std::endl;
    //配置输出流
    for (int i = 0; i < ictx->nb_streams; i++) {
        //创建一个新的流
        AVStream *outStream = avformat_new_stream(octx, ictx->streams[i]->codec->codec);
        if (!outStream) {
            return avError(0);
        }
        //复制配置信息
        ret = avcodec_parameters_copy(outStream->codecpar, ictx->streams[i]->codecpar);
        if (ret < 0) {
            return avError(ret);
        }
        outStream->codec->codec_tag = 0;
    }
    //打印输出流的信息
    av_dump_format(octx, 0, rtmpAddress, 1);


    
    //                         准备推流                          ///
    
    //打开io
    ret = avio_open(&octx->pb, rtmpAddress, AVIO_FLAG_WRITE);
    if (ret < 0) {
        avError(ret);
    }
    //写入头部信息
    ret = avformat_write_header(octx, NULL);
    if ( ret < 0) {
        avError(ret);
    }
    std::cout << "avformat_write_header succeeded" << std::endl;
    //推流每一帧数据
    AVPacket avPacket;
    long long startTime = av_gettime();
    while (true)
    
    {
        ret = av_read_frame(ictx, &avPacket);
        if (ret < 0 )
        {
            break;
        }
        std::cout << avPacket.pts << " " << std::flush;
        //计算转换时间戳
        //获取时间基数
        AVRational itime = ictx->streams[avPacket.stream_index]->time_base;
        AVRational otime = octx->streams[avPacket.stream_index]->time_base;
        avPacket.pts = av_rescale_q_rnd(avPacket.pts, itime, otime, (AVRounding)(AV_ROUND_NEAR_INF | AV_ROUND_NEAR_INF));
        avPacket.dts = av_rescale_q_rnd(avPacket.dts, itime, otime, (AVRounding)(AV_ROUND_NEAR_INF | AV_ROUND_NEAR_INF));
        //到这一帧经历了多长时间
        avPacket.duration = av_rescale_q_rnd(avPacket.duration, itime, otime, (AVRounding)(AV_ROUND_NEAR_INF | AV_ROUND_NEAR_INF));
        avPacket.pos = -1;
        //视频帧推送速度
        if (ictx->streams[avPacket.stream_index]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
        {
            AVRational tb = ictx->streams[avPacket.stream_index]->time_base;
            //已经过去的时间
            long long now = av_gettime() - startTime;
            long long dts = 0;
            dts = avPacket.dts * (1000 * 1000 * av_q2d(tb));
            if (dts > now)
            {
                av_usleep(dts - now);
            }
        }
        ret = av_interleaved_write_frame(octx, &avPacket);
        
        if (ret < 0)
        {
            break;
        }
    }
    
    std::cin.get();
    return 0;
}

int avError(int errNum) {
    char buf[1024];
    //获取错误信息
    av_strerror(errNum, buf, sizeof(buf));
    std::cout << " failed! " << buf << std::endl;
    return -1;
}
代码推送图片
#include <iostream> 
#include <opencv2/opencv.hpp>
#include <opencv2/opencv.hpp>
#include <opencv2/core.hpp>

#include <opencv2/imgcodecs.hpp>
#include <opencv2/core/mat.hpp>
#include <opencv2/imgproc/imgproc.hpp>
using namespace cv;
using namespace std;


//FFMPEG
extern "C"
{
#include <libswscale/swscale.h>
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>
}
#pragma comment(lib, "swscale.lib")
#pragma comment(lib, "avcodec.lib")
#pragma comment(lib, "avutil.lib")
#pragma comment(lib, "avformat.lib")

int main()
{
    VideoCapture capture(0);
    
    const char *outUrl;
    outUrl = "rtsp://0.0.0.0:8554/test";
    //注册所有的编解码器
    avcodec_register_all();
    //注册所有的封装器
    av_register_all();
    //注册所有网络协议
    avformat_network_init();
    //像素格式转换上下文
    SwsContext *vsc = NULL;
    //输出的数据结构
    AVFrame *yuv = NULL;
    //编码器上下文
    AVCodecContext *vc = NULL;
    //rtmp flv 封装器
    AVFormatContext *ic = NULL;
    AVOutputFormat *ofmt = NULL;
    int inWidth = 4160;
    int inHeight = 1024;
    int fps = 16;
    ///2 初始化格式转换上下文
    vsc = sws_getCachedContext(vsc,
        inWidth, inHeight, AV_PIX_FMT_BGR24,     //源宽、高、像素格式
        inWidth, inHeight, AV_PIX_FMT_YUV420P,//目标宽、高、像素格式
        SWS_BICUBIC,  // 尺寸变化使用算法
        0, 0, 0 );
        if (!vsc)
    {
        
    }
    ///3 初始化输出的数据结构
    yuv = av_frame_alloc();
    yuv->format = AV_PIX_FMT_YUV420P;
    yuv->width = inWidth;
    yuv->height = inHeight;
    yuv->pts = 0;
    //分配yuv空间
    int ret = av_frame_get_buffer(yuv, 32);
    if (ret != 0)
    {
        char buf[1024] = { 0 };
        av_strerror(ret, buf, sizeof(buf) - 1);

    }
    ///4 初始化编码上下文
    //a 找到编码器
    AVCodec *codec = avcodec_find_encoder(AV_CODEC_ID_H264);
    if (!codec)
    {

    }
    //b 创建编码器上下文
    vc = avcodec_alloc_context3(codec);
    if (!vc)
    {
       // throw exception("avcodec_alloc_context3 failed!");
    }
    //c 配置编码器参数
    vc->flags |= AV_CODEC_FLAG_GLOBAL_HEADER; //全局参数
    vc->codec_id = codec->id;
    vc->thread_count = 8;
    vc->bit_rate = 50 * 1024 * 8;//压缩后每秒视频的bit位大小 50kB
    vc->width = inWidth;
    vc->height = inHeight;
    vc->time_base = { 1,fps };
    vc->framerate = { fps,1 };
    //画面组的大小，多少帧一个关键帧
    vc->gop_size = 50;
    vc->max_b_frames = 0;
    vc->pix_fmt = AV_PIX_FMT_YUV420P;//AV_PIX_FMT_RGB24  AV_PIX_FMT_YUV420P
    //d 打开编码器上下文
    ret = avcodec_open2(vc, codec, 0);
    if (ret != 0)
    {
        char buf[1024] = { 0 };
        av_strerror(ret, buf, sizeof(buf) - 1);
        //throw exception(buf);
    }
    cout << "avcodec_open2 success!" << endl;
    ///5 输出封装器和视频流配置
    //a 创建输出封装器上下文
    ret = avformat_alloc_output_context2(&ic, NULL, "rtsp", outUrl);
    if (ret != 0)
    {
        char buf[1024] = { 0 };
        av_strerror(ret, buf, sizeof(buf) - 1);
        //throw exception(buf);
    }
    ofmt = ic->oformat;
    //b 添加视频流 
    AVStream *vs = avformat_new_stream(ic, codec);
    if (!vs)
    {
       // throw exception("avformat_new_stream failed");
    }
    ret = avcodec_parameters_from_context(vs->codecpar, vc);
    av_dump_format(ic, 0, outUrl, 1);
    //打开rtmp 的网络输出IO
    if (!(ofmt->flags & AVFMT_NOFILE))
    {
        ret = avio_open(&ic->pb, outUrl, AVIO_FLAG_WRITE);
        if (ret != 0)
        {
            char buf[1024] = { 0 };
            av_strerror(ret, buf, sizeof(buf) - 1);
            //throw exception(buf);
        }
    }
    //写入封装头
    ret = avformat_write_header(ic, NULL);
    if (ret != 0)
    {
        char buf[1024] = { 0 };
        av_strerror(ret, buf, sizeof(buf) - 1);
        //throw exception(buf);
    }
    AVPacket pack;
    memset(&pack, 0, sizeof(pack));
    int vpts = 0;
      cv::Mat color_image=cv::imread("../11.jpg");//change picture
    while (1)
    
    {

	    //Mat color_image;  
	    //定义一个Mat类变量frame，用于存储每一帧的图像 		
	   // capture >> color_image;  
	    //读取当前帧 		
	    //若视频完成播放，退出循环		
	    /*
	    if (color_image.empty())		
	    { 		
	            cout << "1111111111111 break!" << endl;	
	    		break; 		
	    }*/
	    ///ffmpeg推流部分
       //rgb to yuv
        uint8_t *indata[AV_NUM_DATA_POINTERS] = { 0 };
        indata[0] = color_image.data;
        int insize[AV_NUM_DATA_POINTERS] = { 0 };
        
        //一行（宽）数据的字节数
        insize[0] = color_image.cols * color_image.elemSize();
        int h = sws_scale(vsc, indata, insize, 0, color_image.rows, //源数据
            yuv->data, yuv->linesize);
         cout << color_image.rows << endl;	
        if (h <= 0)
        {
            continue;
        }
        //cout << h << " " << flush;
        ///h264编码
        yuv->pts = vpts;
        vpts++;
        ret = avcodec_send_frame(vc, yuv);
        if (ret != 0)
            continue;
        ret = avcodec_receive_packet(vc, &pack);
        if (ret != 0 || pack.size > 0)
        {
            //cout << "*" << pack.size << flush;
        }
        else
        {
            continue;
        }
        //推流

        pack.pts = av_rescale_q(pack.pts, vc->time_base, vs->time_base);
        pack.dts = av_rescale_q(pack.dts, vc->time_base, vs->time_base);
        pack.duration = av_rescale_q(pack.duration, vc->time_base, vs->time_base);
        ret = av_interleaved_write_frame(ic, &pack);
        if (ret == 0)
        {
            //cout << "#" << flush;
        }
}}

参考文章

CV/NLP大虾
关注
  • 11
    点赞
  • 踩
  • 90
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
C++ 调用 ffmpeg 进行 rtmp 推流
叹世界
09-29 3920
C++ 调用 ffmpeg 进行 rtmp 推流
ffmpeg推流rstp文件夹脚本
04-26
在“ffmpeg推流rtsp文件夹脚本”这个主题中，我们将深入探讨如何利用FFmpeg进行RTSP（Real Time Streaming Protocol）推流，并结合提供的文件信息来解析整个流程。 首先，"video"文件夹包含的是待处理的视频源，...
0延时ffmpeg推流程序源码,0延时rtsp推流程序源码和超低延时rtsp,rtmp播放器
06-02
此源码由深圳市好游科技有限公司开发 主要展示了使用ffmpeg实现0延时rtsp,rtmp推流功能，以及flv视频流文件的存储 支持windows usb摄像机推流和linux嵌入式系统真实开发板的推流 深圳市好游科技同时提供超低延时(100-200毫秒)的rtsp,rtmp播放器 支持windows，安卓，苹果系统超低延时实时视频流播放 此源码还演示了使用好游科技的p2p sdk实现实时视频传输 更多视频推流和播放相关技术交流，欢迎加入qq群：384170753 深圳市好游科技有限公司致力于物联网云平台开发和p2p音视频传输技术的研发 公司拥有完全自主研发的P2P内网穿透系统和物联网解决方案 详细介绍请参见公司官方网站：www.haoyou456.com
基于FFmpeg进行rtsp推流及拉流（详细教程）
热门推荐
12-07 8万+
基于FFmpeg进行rtsp推流及拉流
【FFmpeg】使用 ffmpeg 命令实现直播推拉流 ( 推流和拉流简介 | 流媒体服务器搭建 | 使用 ffmpeg 命令进行推流操作 | 使用 ffmpeg/ffplay 命令进行拉流操作 )
最新发布
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
05-05 9053
一、推流和拉流简介 1、直播推流和拉流操作 2、直播推流和拉流涉及到的软件 3、推流 -> 拉流 流程 二、流媒体服务器搭建 1、相关文件准备 2、创建 ECS 云服务器实例 3、配置安全组 4、使用 WinSCP 上传流媒体服务器软件及配置脚本 5、使用 SecureCRT 连接服务器 6、搭建流媒体服务器 三、使用 ffmpeg 命令进行推流操作 四、使用 ffplay 命令进行拉流操作 五、使用 ffmpeg 命令进行拉流操作
FFmpeg进行rtsp推流
liveweb视频汇聚平台
10-25 1653
stream_loop 为循环读取视频源的次数，-1为无限循环；下载完成后，双击安装包文件，然后按照提示操作安装 FFmpeg。命令来检查是否安装成功。如果安装成功，将显示安装的版本号等信息。的版本号，表明 FFmpeg 已安装。否则，需要进行安装。官方网站，然后下载最新版本的 Windows 安装包。首先，打开终端（在 Windows 中是。下载对应编译好的文件直接运行就好。在安装完成后，可以再次运行。-re 为以流的方式读取；-f 为格式化输出到哪里；1.4 macOS系统。-i 为输入的文件；
FFmpeg 代码实现流媒体推流（RTSP）
m0_60259116的博客
07-18 1万+
FFmpeg 代码实现流媒体推流（RTSP）
Linux下C++实现ffmpeg图片推RTSP流到流媒体服务器
weixin_45807901的博客
02-17 3684
环境：Ubuntu18.04 opencv4.1.3 ffmpeg4.1.3 图片推流进服务器（rtsp）
ffmpeg 采集摄像机流(rtsp)后推流(rtmp)
06-04
推流到 RTMP 服务器，我们需要使用 FFmpeg 的 `avformat_alloc_output_context2` 创建一个新的输出上下文，并指定 RTMP 地址，如 "rtmp://server_url/live/stream_key"。 使用 FFmpeg 的 `avformat_write_header` ...
FFmpegDemo_C#推流_c++推流服务器_ffmpeg推流_ffmpeg_推流
09-11
在推流过程中，FFmpeg会先将原始音视频数据编码，然后封装到特定的流媒体协议如RTMP（Real-Time Messaging Protocol）、HLS（HTTP Live Streaming）或RTSP（Real Time Streaming Protocol）中，最后发送到服务器。...
利用ffmpeg实现RTSP，RTMP推流以及保存到本地录像文件
07-12
RTSP, RTMP协议推流， 以及保存到本地MP4，MKV录像文件。 如果要成功编译， 需要下载和编译ffmpeg库，libfdk-aac库，x264库。 编译这些库，非常耗时。如果懒得去编译， 可以直接使用已经编译好的stream_push.dll...
C++封装FFMPEG拉取RTSP的音视频流接口类
09-27
在C++编程中，FFmpeg库常用于处理音视频数据，例如从RTSP（Real Time Streaming Protocol）流中拉取音视频数据。本篇文章将详细介绍如何使用C++封装FFmpeg库来实现RTSP拉流，并通过回调方式处理接收到的数据。 首先...
ffmpeg搭建一个简单的rtsp推流方案
shelgi的博客
06-15 2万+
首先我们必须要安装好,不管是源码编译还是直接安装网上都有很多教程,这里不多展开.至于和任意安装一个就好,主要是为了能对rtsp拉流播放.以VLC安装为例:最后就是安装rtsp服务器,这里可以去github上搜索相关的项目,我这里是ubuntu所以可以去这个链接https://github.com/aler9/rtsp-simple-server/releases下载对应编译好的文件直接运行就好.随便准备好一个mp4视频,然后开始动手...
FFmpeg采集摄像头图像并推流至RTSP/RTMP
liveweb视频汇聚平台
09-21 3162
但是，有个地方要注意，就是从文件读出来的帧（输入帧）的时间戳要转换为封装器对应输出流的时基。假如我们要推送的流来源于一个文件，那就要先把文件的流枚举出来，获得每个流的信息，然后把这几个流“插入”到封装器里面，这样封装器才能识别这些流的格式。我们调用avformat_new_stream生成一个新的流，然后调用avcodec_copy_context将文件的视频流或音频流的上下文属性拷贝到新流的目标上下文中，这样新的流就具有了和输入流同样的属性了（编码格式、分辨率、采样率等）。但是这样写还不完善。
ffmpeg rtsp 推流RTSP推流+流媒体+播放流媒体技术方案
liveweb视频汇聚平台
10-06 1473
FFmpeg是一个开源的跨平台的音视频处理工具，可以用来进行音视频的编解码、转码、剪辑、合成等操作。在流媒体领域，FFmpeg也是一个非常重要的工具，可以用来进行RTSP推流、HLS推流、RTMP推流等操作。RTSP推流是指将本地的音视频流通过RTSP协议推送到远程服务器上，实现实时的音视频传输。下面是一个基本的RTSP推流的命令：ffmpeg -re -i input.mp4 -c:v copy -c:a copy -f rtsp rtsp://server_ip:port/stream_name 其中，
C++编程FFMpeg（QT5+OpenCV）实战--实时美颜直播推流
08-22
C++编程FFMpeg实时美颜直播推流实战视频培训教程，本课程基于ffmpeg，qt5，opencv进行实战教学。基于c++编程，掌握录制视频（rtsp和系统相机）录制音频（qt）开发方法，掌握音视频各类参数含义，掌握音视频编码（h264+acc），磨皮美颜（opencv）,音视频封装（flv），基于rtmp协议推流。多线程处理技术。掌握nginx-rtmp和crtmpserver的直播服务器配置。
Windows上使用FFmpeg实现本地视频推送模拟海康协议rtsp视频流
BADAO_LIUMANG_QIZHI的博客
08-16 3082
上面记录的是使用FFmpeg拉取海康协议摄像头的rtsp流并推流到流媒体服务器。如果在其它业务场景下需要本地的视频文件模拟海康的rtsp流协议格式进行推流。
RTSP 和 RTMP通过ffmpeg实现将本地摄像头推流到RTSP服务器
liveweb视频汇聚平台
10-24 8654
因为 m3u8的直播原理是将直播源不停的压缩成指定时长的ts文件（比如9秒，10秒一个ts文件）并同时实时更新m3u8文件里的列表以达到直播的效果。RTMP（Real Time Message Protocol 实时消息传递协议） 有 Adobe 公司提出，用来解决多媒体数据传输流的多路复用（Multiplexing）和分包（packetizing）的问题，优势在于低延迟，稳定性高，支持所有摄像头格式，浏览器加载 flash插件就可以直接播放。按现在的趋势，flashplayer是要逐渐被淘汰掉的。
c++ ffmpeg进行rtsp 推流
05-10
在 C++ 中使用 FFmpeg 进行 RTSP 推流，主要需要以下步骤： 1. 初始化 FFmpeg 库：调用 av_register_all() 函数注册 FFmpeg 库中的所有可用文件格式和编解码器。 2. 打开输入流：调用 avformat_open_input() 函数打开 RTSP 输入流，获取输入流的相关信息。 3. 查找视频流：调用 avformat_find_stream_info() 函数查找视频流的相关信息。 4. 查找编码器：调用 avcodec_find_encoder() 函数查找编码器，以便将视频流编码为指定格式。 5. 创建输出格式上下文：调用 avformat_alloc_output_context2() 函数创建输出格式上下文。 6. 添加视频流：调用 avformat_new_stream() 函数创建一个新的视频流。 7. 打开输出流：调用 avio_open2() 函数打开输出流。 8. 写文件头：调用 avformat_write_header() 函数将输出格式上下文中的头部信息写入输出流中。 9. 循环读取视频帧：调用 av_read_frame() 函数循环读取视频帧。 10. 编码视频帧：调用 avcodec_encode_video2() 函数将读取的视频帧编码为指定格式。 11. 写入编码后的帧数据：调用 av_write_frame() 函数将编码后的帧数据写入输出流中。 12. 写文件尾：调用 av_write_trailer() 函数将输出格式上下文的尾部信息写入输出流中。 13. 释放资源：释放所有资源。 以下是一个简单的示例代码： ```C++ #include <iostream> #include <cstdlib> #include <cstring> #include <cstdio> #include <unistd.h> extern "C" { #include <libavformat/avformat.h> #include <libavcodec/avcodec.h> #include <libavutil/opt.h> #include <libavutil/mathematics.h> #include <libavutil/timestamp.h> #include <libavutil/error.h> } #define RTSP_URL "rtsp://localhost:8554/test.sdp" // RTSP 输入地址 #define OUTPUT_URL "rtmp://localhost:1935/live/test" // RTMP 输出地址 int main(int argc, char *argv[]) { av_register_all(); // 注册所有可用文件格式和编解码器 AVFormatContext *ifmt_ctx = NULL; int ret = 0; // 打开 RTSP 输入流 if ((ret = avformat_open_input(&ifmt_ctx, RTSP_URL, NULL, NULL)) < 0) { std::cerr << "Could not open input stream " << RTSP_URL << std::endl; return ret; } // 查找视频流信息 if ((ret = avformat_find_stream_info(ifmt_ctx, NULL)) < 0) { std::cerr << "Could not find stream information" << std::endl; return ret; } AVCodecContext *codec_ctx = NULL; AVCodec *codec = NULL; // 查找 H.264 编码器 codec = avcodec_find_encoder_by_name("libx264"); if (!codec) { std::cerr << "Could not find h264 encoder" << std::endl; return AVERROR(EINVAL); } // 创建编码器上下文 codec_ctx = avcodec_alloc_context3(codec); if (!codec_ctx) { std::cerr << "Could not allocate codec context" << std::endl; return AVERROR(ENOMEM); } // 设置编码器参数 codec_ctx->codec_id = codec->id; codec_ctx->bit_rate = 400000; codec_ctx->width = 640; codec_ctx->height = 480; codec_ctx->time_base = {1, 25}; codec_ctx->gop_size = 10; codec_ctx->pix_fmt = AV_PIX_FMT_YUV420P; // 打开编码器 if ((ret = avcodec_open2(codec_ctx, codec, NULL)) < 0) { std::cerr << "Could not open codec" << std::endl; return ret; } AVFormatContext *ofmt_ctx = NULL; AVOutputFormat *ofmt = NULL; // 创建输出格式上下文 avformat_alloc_output_context2(&ofmt_ctx, NULL, "flv", OUTPUT_URL); ofmt = ofmt_ctx->oformat; // 添加视频流 AVStream *out_stream = avformat_new_stream(ofmt_ctx, NULL); out_stream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO; out_stream->codecpar->codec_id = codec_ctx->codec_id; out_stream->codecpar->bit_rate = codec_ctx->bit_rate; out_stream->codecpar->width = codec_ctx->width; out_stream->codecpar->height = codec_ctx->height; avcodec_parameters_from_context(out_stream->codecpar, codec_ctx); // 打开输出流 if (!(ofmt->flags & AVFMT_NOFILE)) { if ((ret = avio_open2(&ofmt_ctx->pb, OUTPUT_URL, AVIO_FLAG_WRITE, NULL, NULL)) < 0) { std::cerr << "Could not open output URL " << OUTPUT_URL << std::endl; return ret; } } // 写文件头 if ((ret = avformat_write_header(ofmt_ctx, NULL)) < 0) { std::cerr << "Error writing header" << std::endl; return ret; } int video_stream_index = 0; AVPacket pkt = {0}; // 循环读取视频帧 while (true) { if ((ret = av_read_frame(ifmt_ctx, &pkt)) < 0) { break; } if (pkt.stream_index == video_stream_index) { // 编码视频帧 if ((ret = avcodec_send_packet(codec_ctx, &pkt)) < 0) { std::cerr << "Error sending packet to encoder" << std::endl; break; } // 写入编码后的帧数据 while (ret >= 0) { ret = avcodec_receive_frame(codec_ctx, frame); if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) { break; } else if (ret < 0) { std::cerr << "Error receiving frame from encoder" << std::endl; goto end; } av_init_packet(&pkt); pkt.data = NULL; pkt.size = 0; // 将编码后的帧数据写入输出流 if ((ret = avcodec_send_frame(codec_ctx, frame)) < 0) { std::cerr << "Error sending frame to encoder" << std::endl; goto end; } while (ret >= 0) { ret = avcodec_receive_packet(codec_ctx, &pkt); if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) { break; } else if (ret < 0) { std::cerr << "Error receiving packet from encoder" << std::endl; goto end; } av_packet_rescale_ts(&pkt, codec_ctx->time_base, out_stream->time_base); pkt.stream_index = video_stream_index; if ((ret = av_write_frame(ofmt_ctx, &pkt)) < 0) { std::cerr << "Error writing packet to output stream" << std::endl; goto end; } } av_packet_unref(&pkt); } } av_packet_unref(&pkt); } // 写文件尾 av_write_trailer(ofmt_ctx); end: // 释放资源 avcodec_free_context(&codec_ctx); avformat_close_input(&ifmt_ctx); avformat_free_context(ofmt_ctx); return 0; } ``` 需要注意的是，该示例代码并未完全测试，仅供参考，具体实现还需要根据实际情况进行调整。同时，需要注意 FFmpeg 的版本问题，不同版本的 API 可能存在差异。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值