C++, ffmpeg, libavcodec-RTSP拉流，opencv实时预览

在ffmpeg_rtsp原有的rtsp拉流项目基础上加入了udp连接rtsp，日志模块，opencv实施预览等功能。

RTSPStreamPlayer.cpp

#include "RTSPStreamPlayer.h"
#include <iostream>
#include <thread>
#include <chrono>
#include <experimental/filesystem>
#include <iomanip>
#include <sstream>namespace fs = std::experimental::filesystem;RTSPStreamPlayer::RTSPStreamPlayer(const std::string& rtsp_url, int target_width, int target_height): rtsp_url_(rtsp_url), target_width_(target_width), target_height_(target_height),is_running_(false), is_initialized_(false), format_context_(nullptr),codec_context_(nullptr), frame_(nullptr), frame_rgb_(nullptr),sws_context_(nullptr), buffer_(nullptr), video_stream_index_(-1),start_time_(-1), end_time_(-1), execution_duration_sec_(-1),start_time_set_(false), reconnect_attempts_(0), max_reconnect_attempts_(5),buffer_size_(10 * 1024 * 1024),  // 默认10MB缓冲区timeout_(5000000),  // 默认5秒超时frame_count_(0), current_fps_(0.0),is_recording_(false), output_format_context_(nullptr),output_codec_context_(nullptr), output_video_stream_(nullptr), start_pts_(0)
{}RTSPStreamPlayer::~RTSPStreamPlayer() {stopRecording();stop();// 释放FFmpeg资源if (buffer_) {av_free(buffer_);}if (frame_rgb_) {av_frame_free(&frame_rgb_);}if (frame_) {av_frame_free(&frame_);}if (codec_context_) {avcodec_free_context(&codec_context_);}if (format_context_) {avformat_close_input(&format_context_);}if (sws_context_) {sws_freeContext(sws_context_);}
}void RTSPStreamPlayer::setBufferSize(int buffer_size) {buffer_size_ = buffer_size;
}void RTSPStreamPlayer::setTimeout(int timeout) {timeout_ = timeout;
}bool RTSPStreamPlayer::init(bool use_tcp) {// 释放可能存在的资源if (format_context_) {avformat_close_input(&format_context_);format_context_ = nullptr;}// 初始化FFmpegav_register_all();avformat_network_init();std::cout << "尝试初始化RTSP流: " << rtsp_url_ << std::endl;std::cout << "使用" << (use_tcp ? "TCP" : "UDP") << "传输协议" << std::endl;// 打开RTSP流format_context_ = avformat_alloc_context();AVDictionary *options = nullptr;// 设置传输协议if (use_tcp) {av_dict_set(&options, "rtsp_transport", "tcp", 0);}// 设置超时时间char timeout_str[20];snprintf(timeout_str, sizeof(timeout_str), "%d", timeout_);av_dict_set(&options, "stimeout", timeout_str, 0);// 设置缓冲区大小char buffer_size_str[20];snprintf(buffer_size_str, sizeof(buffer_size_str), "%d", buffer_size_);av_dict_set(&options, "buffer_size", buffer_size_str, 0);// 禁用多播av_dict_set(&options, "use_multicast", "0", 0);// 打开输入流int ret = avformat_open_input(&format_context_, rtsp_url_.c_str(), nullptr, &options);if (ret != 0) {char errbuf[AV_ERROR_MAX_STRING_SIZE];av_strerror(ret, errbuf, AV_ERROR_MAX_STRING_SIZE);std::cerr << "无法打开RTSP流: " << errbuf << std::endl;av_dict_free(&options);return false;}av_dict_free(&options);// 获取流信息ret = avformat_find_stream_info(format_context_, nullptr);if (ret < 0) {char errbuf[AV_ERROR_MAX_STRING_SIZE];av_strerror(ret, errbuf, AV_ERROR_MAX_STRING_SIZE);std::cerr << "无法获取流信息: " << errbuf << std::endl;return false;}// 打印流信息（调试用）av_dump_format(format_context_, 0, rtsp_url_.c_str(), 0);// 查找视频流video_stream_index_ = -1;for (unsigned int i = 0; i < format_context_->nb_streams; i++) {if (format_context_->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {video_stream_index_ = i;// 计算并打印帧率AVStream* video_stream = format_context_->streams[i];if (video_stream->r_frame_rate.den && video_stream->r_frame_rate.num) {double fps = av_q2d(video_stream->r_frame_rate);std::cout << "视频帧率: " << fps << " FPS" << std::endl;} else if (video_stream->avg_frame_rate.den && video_stream->avg_frame_rate.num) {double fps = av_q2d(video_stream->avg_frame_rate);std::cout << "视频平均帧率: " << fps << " FPS" << std::endl;}break;}}if (video_stream_index_ == -1) {std::cerr << "未找到视频流" << std::endl;return false;}// 获取解码器参数AVCodecParameters* codec_params = format_context_->streams[video_stream_index_]->codecpar;std::cout << "找到视频流，编码格式: " << codec_params->codec_id << std::endl;// 获取解码器const AVCodec* codec = avcodec_find_decoder(codec_params->codec_id);if (!codec) {std::cerr << "无法找到解码器" << std::endl;return false;}// 初始化解码器上下文if (codec_context_) {avcodec_free_context(&codec_context_);}codec_context_ = avcodec_alloc_context3(codec);if (avcodec_parameters_to_context(codec_context_, codec_params) < 0) {std::cerr << "无法初始化解码器上下文" << std::endl;return false;}// 解码器选项AVDictionary *decoder_opts = nullptr;av_dict_set(&decoder_opts, "threads", "auto", 0);  // 自动多线程av_dict_set(&decoder_opts, "low_delay", "1", 0);   // 低延迟模式av_dict_set(&decoder_opts, "error_concealment", "1", 0);  // 错误隐藏// 打开解码器ret = avcodec_open2(codec_context_, codec, &decoder_opts);av_dict_free(&decoder_opts);if (ret < 0) {char errbuf[AV_ERROR_MAX_STRING_SIZE];av_strerror(ret, errbuf, AV_ERROR_MAX_STRING_SIZE);std::cerr << "无法打开解码器: " << errbuf << std::endl;return false;}// 初始化帧if (frame_) av_frame_free(&frame_);frame_ = av_frame_alloc();if (frame_rgb_) av_frame_free(&frame_rgb_);frame_rgb_ = av_frame_alloc();// 分配RGB帧缓冲区int num_bytes = av_image_get_buffer_size(AV_PIX_FMT_BGR24, target_width_, target_height_, 1);if (buffer_) av_free(buffer_);buffer_ = (uint8_t*)av_malloc(num_bytes * sizeof(uint8_t));av_image_fill_arrays(frame_rgb_->data, frame_rgb_->linesize, buffer_, AV_PIX_FMT_BGR24, target_width_, target_height_, 1);// 初始化图像转换上下文if (sws_context_) sws_freeContext(sws_context_);sws_context_ = sws_getContext(codec_context_->width, codec_context_->height, codec_context_->pix_fmt,target_width_, target_height_, AV_PIX_FMT_BGR24,SWS_BICUBIC, nullptr, nullptr, nullptr);if (!sws_context_) {std::cerr << "无法初始化图像转换上下文" << std::endl;return false;}is_initialized_ = true;reconnect_attempts_ = 0;std::cout << "RTSP流初始化成功" << std::endl;return true;
}bool RTSPStreamPlayer::reconnect() {if (reconnect_attempts_ >= max_reconnect_attempts_) {std::cerr << "已达到最大重连次数(" << max_reconnect_attempts_ << ")，停止尝试" << std::endl;return false;}reconnect_attempts_++;std::cout << "尝试重连(" << reconnect_attempts_ << "/" << max_reconnect_attempts_ << ")..." << std::endl;// 释放当前资源if (codec_context_) {avcodec_free_context(&codec_context_);codec_context_ = nullptr;}if (format_context_) {avformat_close_input(&format_context_);format_context_ = nullptr;}// 等待一段时间再重连std::this_thread::sleep_for(std::chrono::seconds(2));// 尝试重新初始化return init(true);
}void RTSPStreamPlayer::start() {if (!is_initialized_) {std::cerr << "请先初始化RTSP流" << std::endl;return;}is_running_ = true;std::thread processing_thread(&RTSPStreamPlayer::processStream, this);processing_thread.detach();// 显示窗口cv::namedWindow("RTSP Stream", cv::WINDOW_AUTOSIZE);// 显示循环while (is_running_) {cv::Mat frame;{std::lock_guard<std::mutex> lock(frame_mutex_);if (!current_frame_.empty()) {frame = current_frame_.clone();}}if (!frame.empty()) {cv::imshow("RTSP Stream", frame);}// 按键控制char c = (char)cv::waitKey(1);if (c == 27) {  // ESC键退出stop();break;} else if (c == 'r' || c == 'R') {  // R键开始/停止录制if (isRecording()) {stopRecording();} else {startRecording();}}}cv::destroyWindow("RTSP Stream");
}void RTSPStreamPlayer::stop() {is_running_ = false;
}void RTSPStreamPlayer::setTimeRange(int64_t start_sec, int64_t duration_sec) {std::lock_guard<std::mutex> lock(frame_mutex_);if (start_sec == -1) {start_time_ = av_gettime();} else {start_time_ = av_gettime() + start_sec * AV_TIME_BASE;}if (duration_sec != -1) {end_time_ = start_time_ + duration_sec * AV_TIME_BASE;execution_duration_sec_ = duration_sec;} else {end_time_ = -1;execution_duration_sec_ = -1;}start_time_set_ = true;
}bool RTSPStreamPlayer::saveCurrentFrame(const std::string& filename, int quality) {std::lock_guard<std::mutex> lock(frame_mutex_);if (current_frame_.empty()) {return false;}std::vector<int> compression_params = {cv::IMWRITE_JPEG_QUALITY, quality};return cv::imwrite(filename, current_frame_, compression_params);
}cv::Mat RTSPStreamPlayer::getCurrentFrame() {std::lock_guard<std::mutex> lock(frame_mutex_);return current_frame_.clone();
}void RTSPStreamPlayer::processStream() {AVPacket packet;bool done = false;last_fps_calc_time_ = std::chrono::steady_clock::now();while (is_running_ && !done) {int ret = av_read_frame(format_context_, &packet);if (ret < 0) {char errbuf[AV_ERROR_MAX_STRING_SIZE];av_strerror(ret, errbuf, AV_ERROR_MAX_STRING_SIZE);std::cerr << "读取帧失败: " << errbuf << std::endl;// 尝试重连if (!reconnect()) {done = true;}continue;}// 重置重连计数器reconnect_attempts_ = 0;if (packet.stream_index == video_stream_index_) {// 发送数据包到解码器ret = avcodec_send_packet(codec_context_, &packet);if (ret != 0) {char errbuf[AV_ERROR_MAX_STRING_SIZE];av_strerror(ret, errbuf, AV_ERROR_MAX_STRING_SIZE);std::cerr << "发送数据包到解码器失败: " << errbuf << std::endl;av_packet_unref(&packet);// 刷新解码器avcodec_flush_buffers(codec_context_);continue;}// 接收解码后的帧while (avcodec_receive_frame(codec_context_, frame_) == 0) {// 计算时间戳int64_t pts = (frame_->pts != AV_NOPTS_VALUE) ?frame_->pts * av_q2d(format_context_->streams[video_stream_index_]->time_base) * AV_TIME_BASE :(frame_->pkt_dts != AV_NOPTS_VALUE ?frame_->pkt_dts * av_q2d(format_context_->streams[video_stream_index_]->time_base) * AV_TIME_BASE :(av_gettime() - start_time_));// 设置初始时间if (!start_time_set_) {start_time_ = av_gettime();if (execution_duration_sec_ != -1) {end_time_ = start_time_ + execution_duration_sec_ * AV_TIME_BASE;}start_time_set_ = true;}// 检查是否在时间范围内if (isWithinTimeRange(pts)) {// 转换为RGB格式sws_scale(sws_context_, frame_->data, frame_->linesize, 0, codec_context_->height, frame_rgb_->data, frame_rgb_->linesize);// 帧率统计frame_count_++;auto now = std::chrono::steady_clock::now();auto elapsed = std::chrono::duration_cast<std::chrono::seconds>(now - last_fps_calc_time_).count();// 每1秒计算一次帧率if (elapsed >= 1) {current_fps_ = frame_count_ / (double)elapsed;std::cout << "实际帧率: " << std::fixed << std::setprecision(2) << current_fps_ << " FPS" << std::endl;// 重置计数器frame_count_ = 0;last_fps_calc_time_ = now;}// 转换为OpenCV的Matcv::Mat frame(target_height_, target_width_, CV_8UC3, frame_rgb_->data[0], frame_rgb_->linesize[0]);// 更新当前帧{std::lock_guard<std::mutex> lock(frame_mutex_);current_frame_ = frame.clone();}// 录制帧（如果正在录制）if (is_recording_) {AVFrame* frame_av = av_frame_alloc();frame_av->format = AV_PIX_FMT_BGR24;frame_av->width = target_width_;frame_av->height = target_height_;frame_av->data[0] = frame_rgb_->data[0];frame_av->linesize[0] = frame_rgb_->linesize[0];encodeAndWriteFrame(frame_av);av_frame_free(&frame_av);}} else if (end_time_ != -1 && pts > end_time_) {done = true;break;}}}av_packet_unref(&packet);}is_running_ = false;
}bool RTSPStreamPlayer::isWithinTimeRange(int64_t pts) {if (end_time_ == -1) {return true; // 没有结束时间限制}return (pts >= start_time_ && pts <= end_time_);
}// 初始化视频编码器
bool RTSPStreamPlayer::initVideoEncoder() {// 创建输出格式上下文avformat_alloc_output_context2(&output_format_context_, nullptr, "mp4", output_filename_.c_str());if (!output_format_context_) {std::cerr << "无法创建输出格式上下文" << std::endl;return false;}// 查找输出编码器const AVCodec* output_codec = avcodec_find_encoder(AV_CODEC_ID_H264);if (!output_codec) {std::cerr << "找不到H264编码器" << std::endl;return false;}// 创建视频流output_video_stream_ = avformat_new_stream(output_format_context_, output_codec);if (!output_video_stream_) {std::cerr << "无法创建视频流" << std::endl;return false;}// 初始化解码器上下文output_codec_context_ = avcodec_alloc_context3(output_codec);if (!output_codec_context_) {std::cerr << "无法创建编码器上下文" << std::endl;return false;}// 设置编码器参数output_codec_context_->codec_id = output_codec->id;output_codec_context_->codec_type = AVMEDIA_TYPE_VIDEO;output_codec_context_->width = target_width_;output_codec_context_->height = target_height_;output_codec_context_->time_base = {1, 25};  // 25fpsoutput_codec_context_->framerate = {25, 1};output_codec_context_->pix_fmt = AV_PIX_FMT_YUV420P;// H264特定设置if (output_codec_context_->codec_id == AV_CODEC_ID_H264) {av_opt_set(output_codec_context_->priv_data, "preset", "ultrafast", 0);av_opt_set(output_codec_context_->priv_data, "tune", "zerolatency", 0);}// 设置比特率output_codec_context_->bit_rate = 4000000;  // 4Mbps// 打开编码器if (avcodec_open2(output_codec_context_, output_codec, nullptr) < 0) {std::cerr << "无法打开编码器" << std::endl;return false;}// 将编码器参数复制到流if (avcodec_parameters_from_context(output_video_stream_->codecpar, output_codec_context_) < 0) {std::cerr << "无法复制编码器参数到流" << std::endl;return false;}// 打开输出文件if (!(output_format_context_->oformat->flags & AVFMT_NOFILE)) {if (avio_open(&output_format_context_->pb, output_filename_.c_str(), AVIO_FLAG_WRITE) < 0) {std::cerr << "无法打开输出文件: " << output_filename_ << std::endl;return false;}}// 写入文件头if (avformat_write_header(output_format_context_, nullptr) < 0) {std::cerr << "无法写入文件头" << std::endl;return false;}start_pts_ = 0;return true;
}// 编码并写入帧
bool RTSPStreamPlayer::encodeAndWriteFrame(AVFrame* frame) {if (!is_recording_ || !output_codec_context_ || !frame)return false;// 转换为YUV420P格式AVFrame* yuv_frame = av_frame_alloc();yuv_frame->format = AV_PIX_FMT_YUV420P;yuv_frame->width = target_width_;yuv_frame->height = target_height_;if (av_frame_get_buffer(yuv_frame, 0) < 0) {std::cerr << "无法分配帧缓冲区" << std::endl;av_frame_free(&yuv_frame);return false;}SwsContext* sws_ctx = sws_getContext(target_width_, target_height_, AV_PIX_FMT_BGR24,target_width_, target_height_, AV_PIX_FMT_YUV420P,SWS_BICUBIC, nullptr, nullptr, nullptr);if (!sws_ctx) {std::cerr << "无法创建SWS上下文" << std::endl;av_frame_free(&yuv_frame);return false;}// 转换颜色空间uint8_t* in_data[1] = {frame->data[0]};int in_linesize[1] = {frame->linesize[0]};sws_scale(sws_ctx, in_data, in_linesize, 0, target_height_,yuv_frame->data, yuv_frame->linesize);sws_freeContext(sws_ctx);// 设置时间戳yuv_frame->pts = start_pts_++;// 发送帧到编码器if (avcodec_send_frame(output_codec_context_, yuv_frame) < 0) {std::cerr << "发送帧到编码器失败" << std::endl;av_frame_free(&yuv_frame);return false;}// 接收编码后的数据包AVPacket pkt;av_init_packet(&pkt);pkt.data = nullptr;pkt.size = 0;bool success = false;while (avcodec_receive_packet(output_codec_context_, &pkt) == 0) {// 调整时间戳pkt.stream_index = output_video_stream_->index;av_packet_rescale_ts(&pkt, output_codec_context_->time_base, output_video_stream_->time_base);// 写入数据包if (av_interleaved_write_frame(output_format_context_, &pkt) < 0) {std::cerr << "写入数据包失败" << std::endl;break;}success = true;}av_packet_unref(&pkt);av_frame_free(&yuv_frame);return success;
}// 开始录制
bool RTSPStreamPlayer::startRecording() {std::lock_guard<std::mutex> lock(recording_mutex_);if (is_recording_) {std::cout << "已经在录制中" << std::endl;return true;}// 获取当前时间字符串auto now = std::chrono::system_clock::now();std::time_t now_time = std::chrono::system_clock::to_time_t(now);std::tm now_tm;
#ifdef _WIN32localtime_s(&now_tm, &now_time);
#elselocaltime_r(&now_time, &now_tm);
#endifstd::stringstream ss;ss << std::put_time(&now_tm, "%Y-%m-%d-%H-%M-%S");output_filename_ = "rtsp_" + ss.str() + ".mp4";// 初始化编码器if (!initVideoEncoder()) {std::cerr << "初始化编码器失败" << std::endl;return false;}is_recording_ = true;std::cout << "开始录制视频到: " << output_filename_ << std::endl;return true;
}// 停止录制
void RTSPStreamPlayer::stopRecording() {std::lock_guard<std::mutex> lock(recording_mutex_);if (!is_recording_) return;// 刷新编码器if (output_codec_context_) {avcodec_send_frame(output_codec_context_, nullptr);AVPacket pkt;av_init_packet(&pkt);pkt.data = nullptr;pkt.size = 0;while (avcodec_receive_packet(output_codec_context_, &pkt) == 0) {pkt.stream_index = output_video_stream_->index;av_packet_rescale_ts(&pkt, output_codec_context_->time_base, output_video_stream_->time_base);av_interleaved_write_frame(output_format_context_, &pkt);av_packet_unref(&pkt);}}// 写入文件尾if (output_format_context_) {av_write_trailer(output_format_context_);}// 释放资源if (output_format_context_ && !(output_format_context_->oformat->flags & AVFMT_NOFILE)) {avio_closep(&output_format_context_->pb);}if (output_codec_context_) {avcodec_free_context(&output_codec_context_);output_codec_context_ = nullptr;}if (output_format_context_) {avformat_free_context(output_format_context_);output_format_context_ = nullptr;}output_video_stream_ = nullptr;is_recording_ = false;std::cout << "停止录制，视频已保存到: " << output_filename_ << std::endl;
}// 检查是否正在录制
bool RTSPStreamPlayer::isRecording() const {std::lock_guard<std::mutex> lock(recording_mutex_);return is_recording_;
}

RTSPStreamPlayer.h

#ifndef RTSP_STREAM_PLAYER_H
#define RTSP_STREAM_PLAYER_H#include <string>
#include <mutex>
#include <opencv2/opencv.hpp>
extern "C" {
#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include <libswscale/swscale.h>
#include <libavutil/imgutils.h>
#include <libavutil/time.h>
#include <libavutil/opt.h>  // 新增：用于av_opt_set
}class RTSPStreamPlayer {
public:/*** @brief 构造函数* @param rtsp_url RTSP流地址* @param target_width 目标宽度* @param target_height 目标高度*/RTSPStreamPlayer(const std::string& rtsp_url, int target_width = 1280, int target_height = 720);/*** @brief 析构函数*/~RTSPStreamPlayer();/*** @brief 初始化RTSP流* @param use_tcp 是否使用TCP传输* @return 成功返回true，失败返回false*/bool init(bool use_tcp = true);/*** @brief 开始播放RTSP流*/void start();/*** @brief 停止播放*/void stop();/*** @brief 设置播放时间范围* @param start_sec 开始时间(秒)，-1表示立即开始* @param duration_sec 持续时间(秒)，-1表示无限期*/void setTimeRange(int64_t start_sec = -1, int64_t duration_sec = -1);/*** @brief 保存当前帧为JPEG* @param filename 文件名* @param quality 质量(0-100)* @return 成功返回true*/bool saveCurrentFrame(const std::string& filename, int quality = 95);/*** @brief 获取当前帧* @return 当前帧的拷贝*/cv::Mat getCurrentFrame();/*** @brief 设置缓冲区大小* @param buffer_size 缓冲区大小(字节)*/void setBufferSize(int buffer_size);/*** @brief 设置超时时间* @param timeout 超时时间(微秒)*/void setTimeout(int timeout);/*** @brief 开始录制视频* @return 成功返回true*/bool startRecording();/*** @brief 停止录制视频*/void stopRecording();/*** @brief 检查是否正在录制* @return 正在录制返回true*/bool isRecording() const;/*** @brief 获取帧互斥锁*/std::mutex& getFrameMutex() { return frame_mutex_; }private:std::string rtsp_url_;int target_width_;int target_height_;bool is_running_;bool is_initialized_;int buffer_size_;  // 缓冲区大小int timeout_;      // 超时时间(微秒)// 帧率统计int frame_count_;               // 帧计数器std::chrono::steady_clock::time_point last_fps_calc_time_;  // 上次计算帧率的时间double current_fps_;            // 当前帧率// FFmpeg相关变量AVFormatContext* format_context_;AVCodecContext* codec_context_;AVFrame* frame_;AVFrame* frame_rgb_;SwsContext* sws_context_;uint8_t* buffer_;int video_stream_index_;// 时间控制int64_t start_time_;int64_t end_time_;int64_t execution_duration_sec_;bool start_time_set_;// 当前帧和互斥锁cv::Mat current_frame_;std::mutex frame_mutex_;// 重连控制int reconnect_attempts_;const int max_reconnect_attempts_;// 录制相关变量bool is_recording_;std::string output_filename_;AVFormatContext* output_format_context_;AVCodecContext* output_codec_context_;AVStream* output_video_stream_;int64_t start_pts_;mutable std::mutex recording_mutex_;  // 修改：添加mutable关键字/*** @brief 处理视频流的线程函数*/void processStream();/*** @brief 判断时间戳是否在指定范围内*/bool isWithinTimeRange(int64_t pts);/*** @brief 尝试重新连接RTSP流*/bool reconnect();/*** @brief 初始化视频编码器*/bool initVideoEncoder();/*** @brief 将帧编码并写入文件*/bool encodeAndWriteFrame(AVFrame* frame);
};#endif // RTSP_STREAM_PLAYER_H

main.cpp

#include "RTSPStreamPlayer.h"
#include <iostream>
#include <fstream>
#include <iomanip>
#include <ctime>
#include <chrono>
#include <sstream>// 自定义流缓冲区，同时输出到终端和文件
class TeeBuf : public std::streambuf {
public:TeeBuf(std::streambuf* sb1, std::streambuf* sb2) : sb1_(sb1), sb2_(sb2) {}
private:int overflow(int c) override {if (c == EOF) {return !EOF;} else {return sb1_->sputc(c) == EOF || sb2_->sputc(c) == EOF ? EOF : c;}}int sync() override {return sb1_->pubsync() == 0 && sb2_->pubsync() == 0 ? 0 : -1;}
private:std::streambuf* sb1_;std::streambuf* sb2_;
};// 获取当前时间字符串
std::string getCurrentTimeString() {auto now = std::chrono::system_clock::now();std::time_t now_time = std::chrono::system_clock::to_time_t(now);std::tm now_tm;
#ifdef _WIN32localtime_s(&now_tm, &now_time);
#elselocaltime_r(&now_time, &now_tm);
#endifstd::stringstream ss;ss << std::put_time(&now_tm, "%Y-%m-%d-%H-%M-%S");return ss.str();
}// 重定向输出到日志文件
void redirectOutputToLog() {std::string timeStr = getCurrentTimeString();std::string logFileName = "rtsp_log_" + timeStr + ".txt";static std::ofstream logFile(logFileName, std::ios::app);static TeeBuf teeBuf(std::cout.rdbuf(), logFile.rdbuf());static std::ostream tee(&teeBuf);std::cout.rdbuf(tee.rdbuf());std::cerr.rdbuf(tee.rdbuf());
}int main(int argc, char* argv[]) {// 重定向输出到日志文件redirectOutputToLog();if (argc < 2) {std::cerr << "用法: " << argv[0] << " <RTSP_URL>" << std::endl;return -1;}// 创建RTSP播放器实例RTSPStreamPlayer player(argv[1], 1280, 720);// 可以根据需要调整参数// player.setBufferSize(5 * 1024 * 1024);  // 设置5MB缓冲区// player.setTimeout(10000000);  // 设置10秒超时// 尝试初始化，先尝试TCP，如果失败则尝试UDPbool init_success = player.init(true);if (!init_success) {std::cout << "TCP初始化失败，尝试UDP传输..." << std::endl;init_success = player.init(false);}if (!init_success) {std::cerr << "初始化RTSP播放器失败" << std::endl;return -1;}// 开始播放std::cout << "开始播放RTSP流: " << argv[1] << std::endl;std::cout << "按ESC键退出" << std::endl;std::cout << "按R键开始/停止录制视频" << std::endl;player.start();return 0;
}

编译

g++ main.cpp RTSPStreamPlayer.cpp -o rtsp_player `pkg-config --cflags --libs opencv4` -lavformat -lavcodec -lswscale -lavutil -lpthread

运行

./rtsp_player rtsp://10.130.209.12:8554/v

10.130.209.12是本机ip地址，可以用vlc退流进行测试：

按R开启录制。