Linux下C++实现ffmpeg图片推RTSP流到流媒体服务器

最新推荐文章于 2025-03-05 14:58:16 发布

weixin_45807901

最新推荐文章于 2025-03-05 14:58:16 发布

阅读量4.6k

点赞数 4

文章标签： ubuntu c++

原文链接：https://blog.csdn.net/m0_37400316/article/details/127632441

版权

自用

ffmpeg下载安装

1.官网下载ffmpegDownload FFmpeg

2.解压

3.进入ffmpeg目录下，打开终端输入：

./configure --enable-shared --enable-static --enable-network --disable-demuxers --enable-demuxer=rtsp --enable-demuxer=sdp --enable-libx264 --enable-gpl --prefix=/home/nano/ffmpeg-3x64

4.编译：make

5.安装：sudo make install

环境变量配置

将ffmpeg目录下生成的库放到系统目录下

sudo cp /lib/* /usr/lib/aarch64-linux-gnu

C++代码部分

#include <opencv2/highgui.hpp>
#include <stdexcept>
#include <iostream>
extern "C"
{
#include <libswscale/swscale.h>
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
}
#pragma comment(lib, "swscale.lib")
#pragma comment(lib, "avcodec.lib")
#pragma comment(lib, "avutil.lib")
#pragma comment(lib, "avformat.lib")
// #pragma comment(lib,"opencv_world300.lib")
using namespace std;
using namespace cv;
int main(int argc, char *argv[])
{
    // 海康相机的rtsp url
    //VideoCapture cap(0);
    // char *inUrl = "rtsp://test:test123456@192.168.1.64";
    // nginx-rtmp 直播服务器rtmp退流URL
    char *outUrl = "rtsp://172.16.19.192:8554/test";

    // 注册所有的解编码器
    avcodec_register_all();

    // 注册所有的封装器
    av_register_all();

    // 注册所有的网络协议
    avformat_network_init();

    // VideoCapture cam;
    Mat frame = imread("1.jpg");
    // namedWindow("video");

    // 像素转换上下文
    SwsContext *vsc = NULL;

    // 输出的数据结构
    AVFrame *yuv = NULL;

    // 编码器上下文
    AVCodecContext *vc = NULL;

    // rtmp flv 封装器
    AVFormatContext *ic = NULL;

    try
    { 
        /// 1使用opencv打开rtsp相机
        // cam.open(inUrl);
        // cam.open(0); // 本地相机
        // if (!cam.isOpened())
        {
            // throw logic_error("cam open failed!");
        }
        // cout << inUrl << " cam open success" << endl;
        // int inWidth = cam.get(CAP_PROP_FRAME_WIDTH);
        // int inHeight = cam.get(CAP_PROP_FRAME_HEIGHT);
        // int fps = cam.get(CAP_PROP_FPS);
        int inWidth = frame.cols;
        // int inWidth = 1920;
        int inHeight = frame.rows;
        // int inHeight = 1080;
        int fps = 25;

        /// 2 初始化格式转换上下文
        vsc = sws_getCachedContext(vsc,
                                   inWidth, inHeight, AV_PIX_FMT_GRAY8,   // 源宽、高、像素格式
                                   inWidth, inHeight, AV_PIX_FMT_YUV420P, // 目标宽、高、像素格式
                                   SWS_BICUBIC,                           // 尺寸变化使用算法
                                   0, 0, 0);
        if (!vsc)
        {
            throw logic_error("sws_getCachedContext failed!"); // 转换失败
        }
        /// 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);
            throw logic_error(buf);
        }

        /// 4 初始化编码上下文
        // a 找到编码器
        AVCodec *codec = avcodec_find_encoder(AV_CODEC_ID_H264);
        if (!codec)
        {
            throw logic_error("Can`t find h264 encoder!"); // 找不到264编码器
        }
        // b 创建编码器上下文
        vc = avcodec_alloc_context3(codec);
        if (!vc)
        {
            throw logic_error("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;
        // d 打开编码器上下文
        ret = avcodec_open2(vc, 0, 0);
        if (ret != 0)
        {
            char buf[1024] = {0};
            av_strerror(ret, buf, sizeof(buf) - 1);
            throw logic_error(buf);
        }
        cout << "avcodec_open2 success!" << endl;

        /// 5 输出封装器和视频流配置
        // a 创建输出封装器上下文
        ret = avformat_alloc_output_context2(&ic, 0, "rtsp", outUrl);
        if (ret != 0)
        {
            char buf[1024] = {0};
            av_strerror(ret, buf, sizeof(buf) - 1);
            throw logic_error(buf);
        }
        // b 添加视频流
        AVStream *vs = avformat_new_stream(ic, codec);
        if (!vs)
        {
            throw logic_error("avformat_new_stream failed");
        }
        vs->codecpar->codec_tag = 0;
        // 从编码器复制参数
        avcodec_parameters_from_context(vs->codecpar, vc);
        av_dump_format(ic, 0, outUrl, 1);

        // AVOutputFormat *ofmt = NULL;
        /// 打开rtmp的网络输出IO
        // if(!(ofmt->flags & AVFMT_NOFILE))
        {
            // ret = avio_open(&ic->pb, outUrl, AVIO_FLAG_WRITE);
            // if (ret != 0)
            {
                // cout << "ret:" << ret << endl;
                // char buf[1024] = {0};
                // av_strerror(ret, buf, sizeof(buf) - 1);
                // throw logic_error(buf);
            }
        }

        // 写入封装头
        ret = avformat_write_header(ic, NULL);
        if (ret != 0)
        {
            cout << "ret:" << ret << endl;
            char buf[1024] = {0};
            av_strerror(ret, buf, sizeof(buf) - 1);
            throw logic_error(buf);
        }

        AVPacket pack;
        memset(&pack, 0, sizeof(pack));
        int vpts = 0;
        // for (;;)
        while (1)
        {
            /// 读取rtsp视频帧
            // if (!cam.grab())
            //{
            // continue;
            //}
            /// yuv转换为rgb
            // if (!cam.retrieve(frame))
            //{
            // continue;
            //}
            // imshow("video", frame);
            // waitKey(20);

            /// rgb to yuv
            // 输入的数据结构
            uint8_t *indata[AV_NUM_DATA_POINTERS] = {0};
            // indata[0] bgrbgrbgr
            // plane indata[0] bbbbb indata[1]ggggg indata[2]rrrrr
            indata[0] = frame.data;
            int insize[AV_NUM_DATA_POINTERS] = {0};
            // 一行（宽）数据的字节数
            insize[0] = frame.cols * frame.elemSize();
            int h = sws_scale(vsc, indata, insize, 0, frame.rows, // 源数据
                              yuv->data, yuv->linesize);
            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;
            }

            int firstFrame = 0;
            if (pack.dts < 0 || pack.pts < 0 || pack.dts > pack.pts || firstFrame)
            {
                firstFrame = 0;
                pack.dts = pack.pts = pack.duration = 0;
            }

            // 推流
            pack.pts = av_rescale_q(pack.pts, vc->time_base, vs->time_base); // 显示时间
            //cout << "pts:" << pack.pts << endl;
            pack.dts = av_rescale_q(pack.dts, vc->time_base, vs->time_base); // 解码时间
            //cout << "dts:" << pack.dts << endl;
            pack.duration = av_rescale_q(pack.duration, vc->time_base, vs->time_base); // 数据时长
            //cout << "duration:" << pack.duration << endl;
            ret = av_interleaved_write_frame(ic, &pack);
            if (ret == 0)
            {
                // cout << "#" << flush;
            }
        }
    }
    catch (logic_error &ex)
    {
        // if (cam.isOpened())
        // cam.release();
        if (vsc)
        {
            sws_freeContext(vsc);
            vsc = NULL;
        }

        if (vc)
        {
            avio_closep(&ic->pb);
            avcodec_free_context(&vc);
        }

        cerr << ex.what() << endl;
    }
    getchar();
    return 0;
}

CMakeLists.txt编码

cmake_minimum_required(VERSION 3.10.2)
project(w)
find_package( OpenCV REQUIRED )
include_directories(${OpenCV_INCLUDE_DIRS})

set(ffmpeg_libs_DIR /usr/lib/aarch64-linux-gnu)
set(ffmpeg_headers_DIR /usr/include/aarch64-linux-gnu)

add_library( avcodec SHARED IMPORTED)
add_library( avfilter SHARED IMPORTED )
add_library( swresample SHARED IMPORTED )
add_library( swscale SHARED IMPORTED )
add_library( avformat SHARED IMPORTED )
add_library( avutil SHARED IMPORTED )

set_target_properties( avcodec PROPERTIES IMPORTED_LOCATION ${ffmpeg_libs_DIR}/libavcodec.so )
set_target_properties( avfilter PROPERTIES IMPORTED_LOCATION ${ffmpeg_libs_DIR}/libavfilter.so )
set_target_properties( swresample PROPERTIES IMPORTED_LOCATION ${ffmpeg_libs_DIR}/libswresample.so )
set_target_properties( swscale PROPERTIES IMPORTED_LOCATION ${ffmpeg_libs_DIR}/libswscale.so )
set_target_properties( avformat PROPERTIES IMPORTED_LOCATION ${ffmpeg_libs_DIR}/libavformat.so )
set_target_properties( avutil PROPERTIES IMPORTED_LOCATION ${ffmpeg_libs_DIR}/libavutil.so )

include_directories( ${ffmpeg_headers_DIR} )
link_directories(${ffmpeg_libs_DIR} )

set(CMAKE_CXX_STANDARD 14)
add_executable(w main.cpp)
target_link_libraries(${PROJECT_NAME} ${OpenCV_LIBS} avcodec avformat avutil swresample swscale swscale avfilter )