如何使用OpenCV+MMPEAG打开摄像头，显示的同时推送RTMP流。

最新推荐文章于 2024-04-29 11:13:58 发布
最新推荐文章于 2024-04-29 11:13:58 发布
阅读量58 收藏
点赞数
文章标签： opencv 人工智能 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jsxyhelu2015/article/details/133108059
版权
注意，设置中：
代码详解： 
1、    char* outUrl = "rtmp://localhost/live/livestream";
这个地址，是AMS(Adeobe Media Server)的默认地址。
2、
    //注册所有的编解码器
    avcodec_register_all();
    //注册所有的封装器
    av_register_all();
    //注册所有网络协议
    avformat_network_init();
    //打开摄像头
    VideoCapture cam;
    namedWindow("video");
    Mat frame;
 
    //像素格式转换上下文
    SwsContext*  vsc = NULL;
    //输出的数据结构
    AVFrame* yuv = NULL;
    //编码器上下文
    AVCodecContext* vc = NULL;
    //rtmp flv 封装器
    AVFormatContext* ic = NULL;   
声明好多变量，是OpenCV & MMPEAG 正常运行所需要的。
3、
    try {
        /// 1. Open Cam
        //  这里默认打开的是摄像头0，并获得摄像头参数
        cam.open(0);
        if (!cam.isOpened()) {
            throw exception("cam open failed");
        }
        cout << "cam open sucess"<< endl;
 
        int inWidth = cam.get(CAP_PROP_FRAME_WIDTH);
        int inHeight = cam.get(CAP_PROP_FRAME_HEIGHT);
        int fps = cam.get(CAP_PROP_FPS);
        if (fps == 0) {
            fps = 25;
        }
        cout << fps<< endl;
 
        /// 2. 初始化 SwsContext(转换格式上下文)
        vsc = sws_getCachedContext(vsc,
            inWidth, inHeight, AV_PIX_FMT_BGR24, 
            inWidth, inHeight, AV_PIX_FMT_YUV420P, 
            SWS_BICUBIC, 
            0, 0, 0
            );
        if (!vsc) {
            throw exception("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 exception(buf);
        }
 
        ///4. 初始化编码器上下文
        //a. 找到编码器,这里全部基于MMPEAG
        AVCodec* codec = avcodec_find_encoder(AV_CODEC_ID_H264);
        if (!codec) {
            throw exception("Can't find H.264 encoder");
        }
        //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; //video size(bits) per second: 50kByte
        vc->width = inWidth;
        vc->height = inHeight;
        
        vc->time_base = { 1,fps };//used to calculate pts: pts*time_base = second
        vc->framerate = { fps,1 };
 
        vc->gop_size = 50;// for how many frames there is a I frame(关键帧)
        vc->max_b_frames = 0;//if these is no B frames, the orders of both decoding and presentation will be the same
        vc->pix_fmt = AV_PIX_FMT_YUV420P;
        
        //d. 打开编码器上下文(Open encodder context)
        ret = avcodec_open2(vc, 0, 0);
        if (ret != 0) {
            char buf[1024] = { 0 };
            av_strerror(ret, buf, sizeof(buf) - 1);
            throw exception(buf);
        }
        cout << "avcodec_open2 successed!"<< endl;
        
        ///5. 输出封装器和频流配置
        //a. Create context for MUX
        ret = avformat_alloc_output_context2(&ic, 0, "flv", outUrl);
        if (ret != 0) {
            char buf[1024] = { 0 };
            av_strerror(ret, buf, sizeof(buf) - 1);
            throw exception(buf);
        }
        //b. Add video stream
        AVStream* vs = avformat_new_stream(ic, NULL);
        if (!vs) {
            throw exception("avformat_new_stream failed");
        }
        vs->codecpar->codec_tag = 0;
        // copy  parameter from Encoder to MUX
        avcodec_parameters_from_context(vs->codecpar, vc);
        av_dump_format(ic, 0, outUrl, 1);
 
        ///6. Open rtmp output IO(打开输出IO)
        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);
        }
        //write mux header
        ret = avformat_write_header(ic, NULL); // after this operation the stream's time_base will also be changed, not vc->time_base anymore
        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;
 
        //住循环，读入->显示->转码
        for (;;) {
            ///从cam中读取书
            if (!cam.grab()) {
                continue;
            }
            if (!cam.retrieve(frame)) {
                continue;
            }
            imshow("video", frame);
            waitKey(1);
 
            /// convert RGB to YUV 
            // Input data structure--RGB
            uint8_t* indata[AV_NUM_DATA_POINTERS] = { 0 };//srcStride
            indata[0] = frame.data;
            int inlinesize[AV_NUM_DATA_POINTERS] = { 0 };//srcSlice
            //一行(宽)数据的字节数
            inlinesize[0] = frame.cols * frame.elemSize();
 
            int h = sws_scale(vsc, indata, inlinesize, 0, frame.rows,
                yuv->data, yuv->linesize);
            if (h <= 0) {
                continue;
            }
 
            ///Mux YUV to flv h.264
            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);
            ret = av_interleaved_write_frame(ic, &pack);
            if (ret == 0) {
                cout << '#'<< flush;
            }
 
        }
    }
    catch (exception &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();
在一段代码中解决所有问题，可能不是一个很好的习惯，我需要做一些改变。
这里对代码进行了封装，使得可以简化成目前情况： 
#include <opencv2/core.hpp>
#include <opencv2/imgcodecs.hpp>
#include <opencv2/highgui.hpp>
#include <iostream>
#include "XMediaEncode.h"
#include "XRtmp.h"
extern "C"
{
#include <libswscale/swscale.h>
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
}
using namespace cv;
using namespace std;
 
 
 
//初始化像素格式上下文
void test004()
{
    //相机的rtsp url
    char *inUrl = "rtsp://admin:@192.168.10.30:554/ch0_0.264";
    VideoCapture cam;
    namedWindow("video");
 
    //像素格式转换上下文
    SwsContext *vsc = NULL;
 
    try
    {
        ////
        /// 1 使用opencv打开rtsp相机
        cam.open(inUrl);
        if (!cam.isOpened())
        {
            throw exception("cam open failed!");
        }
        cout << inUrl << " cam open success" << endl;
        int inWidth = (int)cam.get(CAP_PROP_FRAME_WIDTH);
        int inHeight = (int)cam.get(CAP_PROP_FRAME_HEIGHT);
        int fps = (int)cam.get(CAP_PROP_FPS);
 
        ///2 初始化格式转换上下文
        vsc = sws_getCachedContext(vsc,
            inWidth, inHeight, AV_PIX_FMT_BGR24,     //源宽、高、像素格式
            inWidth, inHeight, AV_PIX_FMT_YUV420P,//目标宽、高、像素格式
            SWS_BICUBIC,  // 尺寸变化使用算法
            0, 0, 0
        );
        if (!vsc)
        {
            throw exception("sws_getCachedContext failed!");
        }
        Mat frame;
        for (;;)
        {
            ///读取rtsp视频帧，解码视频帧
            if (!cam.grab())
            {
                continue;
            }
            ///yuv转换为rgb
            if (!cam.retrieve(frame))
            {
                continue;
            }
            imshow("video", frame);
            waitKey(1);
        }
    }
    catch (exception &ex)
    {
        if (cam.isOpened())
            cam.release();
        if (vsc)
        {
            sws_freeContext(vsc);
            vsc = NULL;
        }
        cerr << ex.what() << endl;
    }
    getchar();
}
 
//rtsp数据源到rtmp推流      要重点复习 
void test005()
{
    cout << "void test005()!" << endl;
    //相机的rtsp url
    char *inUrl = "rtsp://admin:@192.168.10.30:554/ch0_0.264";
    //nginx-rtmp 直播服务器rtmp推流URL
    char *outUrl = "rtmp://192.168.10.181/live";
 
    //注册所有的编解码器
    avcodec_register_all();
 
    //注册所有的封装器
    av_register_all();
 
    //注册所有网络协议
    avformat_network_init();
 
 
    VideoCapture cam;
    Mat frame;
    namedWindow("video");
 
    //像素格式转换上下文
    SwsContext *vsc = NULL;
 
    //输出的数据结构
    AVFrame *yuv = NULL;
 
    //编码器上下文
    AVCodecContext *vc = NULL;
 
    //rtmp flv 封装器
    AVFormatContext *ic = NULL;
 
 
    try
    {    ////
        /// 1 使用opencv打开rtsp相机
        cam.open(inUrl);
        if (!cam.isOpened())
        {
            throw exception("cam open failed!");
        }
        cout << inUrl << " cam open success" << endl;
        int inWidth = (int)cam.get(CAP_PROP_FRAME_WIDTH);
        int inHeight = (int)cam.get(CAP_PROP_FRAME_HEIGHT);
        int fps = (int)cam.get(CAP_PROP_FPS);
 
        ///2 初始化格式转换上下文
        vsc = sws_getCachedContext(vsc,
            inWidth, inHeight, AV_PIX_FMT_BGR24,     //源宽、高、像素格式
            inWidth, inHeight, AV_PIX_FMT_YUV420P,//目标宽、高、像素格式
            SWS_BICUBIC,  // 尺寸变化使用算法
            0, 0, 0
        );
        if (!vsc)
        {
            throw exception("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 exception(buf);
        }
 
        ///4 初始化编码上下文，分为以下三步
        //a 找到编码器
        AVCodec *codec = avcodec_find_encoder(AV_CODEC_ID_H264);
        if (!codec)
        {
            throw exception("Can`t find h264 encoder!");
        }
        //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;
        //d 打开编码器上下文
        ret = avcodec_open2(vc, 0, 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, 0, "flv", outUrl);
        if (ret != 0)
        {
            char buf[1024] = { 0 };
            av_strerror(ret, buf, sizeof(buf) - 1);
            throw exception(buf);
        }
 
        //b 添加视频流 
        AVStream *vs = avformat_new_stream(ic, NULL);
        if (!vs)
        {
            throw exception("avformat_new_stream failed");
        }
        vs->codecpar->codec_tag = 0;
        //从编码器复制参数
        avcodec_parameters_from_context(vs->codecpar, vc);
        av_dump_format(ic, 0, outUrl, 1);
 
 
        ///打开rtmp 的网络输出IO
        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;
        
        //死循环
        for (;;)
        {
            ///读取rtsp视频帧，解码视频帧
            if (!cam.grab())
            {
                continue;
            }
            ///yuv转换为rgb
            if (!cam.retrieve(frame))
            {
                continue;
            }
            imshow("video", frame);
            waitKey(1);
 
 
            ///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;
            }
            //推流
            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;
            }
        }
 
    }
    catch (exception &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();
}
 
//opencv_rtsp_to_rtmp_class封装重构代码    要重点复习
void test006()
{
    cout << "void test006()!" << endl;
    //相机的rtsp url
    char *inUrl = "rtsp://admin:@192.168.10.30:554/ch0_0.264";
    //nginx-rtmp 直播服务器rtmp推流URL
    char *outUrl = "rtmp://192.168.10.181/live";
 
 
    //编码器和像素格式转换
    XMediaEncode *me = XMediaEncode::Get(0);
 
    //封装和推流对象
    XRtmp *xr = XRtmp::Get(0);
 
    VideoCapture cam;
    Mat frame;
    namedWindow("video");
 
    int ret = 0;
    try
    {    ////
        /// 1 使用opencv打开rtsp相机
        cam.open(inUrl);
        if (!cam.isOpened())
        {
            throw exception("cam open failed!");
        }
        cout << inUrl << " cam open success" << endl;
        int inWidth = (int)cam.get(CAP_PROP_FRAME_WIDTH);
        int inHeight = (int)cam.get(CAP_PROP_FRAME_HEIGHT);
        int fps = (int)cam.get(CAP_PROP_FPS);
 
        ///2 初始化格式转换上下文
        ///3 初始化输出的数据结构
        me->inWidth = inWidth;
        me->inHeight = inHeight;
        me->outWidth = inWidth;
        me->outHeight = inHeight;
        me->InitScale();
 
        ///4 初始化编码上下文
        //a 找到编码器
        if (!me->InitVideoCodec())
        {
            throw exception("InitVideoCodec failed!");
        }
 
        ///5 输出封装器和视频流配置
        xr->Init(outUrl);
 
        //添加视频流 
        xr->AddStream(me->vc);
        xr->SendHead();
 
        for (;;)
        {
            ///读取rtsp视频帧，解码视频帧
            if (!cam.grab())
            {
                continue;
            }
            ///yuv转换为rgb
            if (!cam.retrieve(frame))
            {
                continue;
            }
            //imshow("video", frame);
            //waitKey(1);
 
 
            ///rgb to yuv
            me->inPixSize = frame.elemSize();
            AVFrame *yuv = me->RGBToYUV((char*)frame.data);
            if (!yuv) continue;
 
            ///h264编码
            AVPacket *pack = me->EncodeVideo(yuv);
            if (!pack) continue;
 
            xr->SendFrame(pack);
 
 
        }
 
    }
    catch (exception &ex)
    {
        if (cam.isOpened())
            cam.release();
        cerr << ex.what() << endl;
    }
    getchar();
}
 
int main(int argc, char *argv[])
{
    //test000();
    //test001();
    //test002();
    //test003();
    //test004();
    //test005();
    test006();
    return 0;
}
具体操作：
——————————————————————————————————————
选择摄像头并且打开摄像头；
 
vlc打开网络串流
输入：
rtmp://localhost/live/livestream
串流摄像头内容：
参考资料《利用ffmpeg和opencv进行视频的解码播放》
 文中代码：

https://files.cnblogs.com/files/blogs/758212/opencv_rtsp2rtmp-master.rar
https://files.cnblogs.com/files/blogs/758212/main.js

jsxyhelu2015
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
利用Opencv+Qt打开摄像头
xiaobeibei2的博客
02-22 3535
利用Opencv+Qt添加摄像头 1、opencv包 添加链接描述 2、安装Qt 3、代码 #pragma once #include <QWidget> #include "ui_camera.h" #include <QCameraInfo> #include <opencv2/objdetect/objdetect.hpp> #include <opencv2/highgui/highgui.hpp> #include "opencv2/ope
opencvdakaishexiangtou.rar_OpenCV 摄像头_opencv+摄像头_opencv摄像头_打开摄像头
09-20
opencv学习之——打开摄像头程序，通过此程序轻松学习如何用opencv打开电脑摄像头
使用JavaCV实现海康rtsp转rtmp实现无插件web端直播（无需转码，低资源消耗）
热门推荐
banmajio的博客
04-29 2万+
FFmpeg转封装rtsp到rtmp（无需转码，低资源消耗）目录结构添加依赖，编写配置文件创建Bean创建缓存Cache修改启动类拉流、推流、转封装定时任务Timer线程池管理编写controller1.开启视频流接口（POST）2.关闭视频流接口（DELETE）3.获取视频流（GET）4.视频流保活（PUT）5.获取服务信息（GET）6.video.js 参考：javaCV开发详解之8：转封装...
opencv打开摄像头ffmpeg推流到nginx-rtmp
虾球
11-15 2986
基于opencv采集推流 1.opencv采集rtsp解码 //可以基于usb 摄像机(调用系统驱动)和rtsp(调用ffmpeg 接口 转yuv加解码) 摄像机 2.ffmpeg缩放转换像素格式 3.ffmpeg编码H264 4.ffmpeg推流rtmp sws_getCachedContext (像素格式转换 会清理之前的数据) 1.struct SwsContext *context, 2.int srcW,int srcH,enum AVPixelFormat srcFormat, 3.int
跨平台低延迟RTSP转RTMP推送技术方案探讨
乐学吧
07-11 1618
选择一个稳定可靠的第三方库或服务，以确保转换的质量和可靠性；了解和掌握相关的技术和协议，例如RTSP和RTMP，以及如何使用相关的库和工具进行转换和处理；考虑性能和资源的问题，特别是在处理大量视频流或高并发的场景下。需要确保系统具有足够的处理能力和带宽，以避免延迟或丢帧等问题。Windows平台上的RTSP转RTMP推送需要一些技术准备和规划，以及对相关协议和工具的理解和使用经验，做个基础的demo，用FFmpeg就可以，但是如果产品话，需要考虑的点实在太多了。
监控直播流rtsp协议转rtmp、hls、httpflv协议返回浏览器
p2p音视频传输
10-27 1263
Java 监控直播流rtsp协议转rtmp、hls、httpflv协议返回浏览器目录一：了解音视频流协议：二：方案一 rtsp 转rtmp1、下载nginx + nginx-rtmp-module3、cmd 到nginx根目录启动nginx8、查摄像头的rtsp协议格式10、测试rtmp是否转换成功12、为什么放弃了用rtmp四：方案三rtsp 转httpflv(采用)1、安装nginx-flv-module4.1 采用java代码去执行ffmepg命令。
FFMPEG+OPENCV获取摄像头视频流并显示
06-12
1.开发环境：vs2015； 2.FFMPEG获取本地摄像头视频流，OPENCV嵌入MFC对话框中显示； 3.程序包中包括FFMPEG和OPENCV资源包； 4.环境已配置好，拿到代码修改查找摄像头名称即可编译运行；
Qt+opencv 显示摄像头至QLabel（通过定时器实现）
08-25
Qt+opencv 显示摄像头至QLabel（通过定时器实现），讲解见博客 https://blog.csdn.net/wang_chao118/article/details/126027849?spm=1001.2014.3001.5502
Qt+opencv实现打开图片、打开摄像头、关闭摄像头
09-16
Qt+opencv实现打开图片、打开摄像头、关闭摄像头
树莓派4B+opencv4+python 打开摄像头的实现方法
09-18
主要介绍了树莓派4B+opencv4+python 打开摄像头的实现方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Qt+Opencv+Ffmpeg实时摄像头数据推流，并在WEB端显示
千里小马哥的博客
10-02 3704
此部分有大体两个方案：Ⅰ.nginx+rtmp模块，最终会依赖浏览器的flash，现在浏览器基本都放弃了flash，所以我也放弃了这个方案；Ⅱ.nodejs的npm模块，即node-meida-server，不依赖flash，我选择了它。整体方案如第二部分所示，主要由四部分组成：硬件视频采集设备、视频捕捉模块、流媒体服务、流媒体播放器。涉及的功能技术点有三块：a.实时视频采集与推送；本文主要介绍下利用Opencv获取摄像头视频数据，并结合ffmpeg推流到流服务器，并在前端页面中显示的整个思路与实现。
java 使用opencv 打开摄像头或rtmp视频流进行播放或截图
qq_42528520的博客
09-29 4154
1、安装opencv 先引用包和资源，自行安装opencv 官网下载地址: link. 代码中先加载资源 /* * @Description //加载opencv资源 * @Param null * @Date 2021/9/15 * @Author zxq * @return **/ static { //判断运行系统 String osName = System.getProperties().getProperty("os.name").toLowerCase();
javaCV开发详解之8：转封装在rtsp转rtmp流中的应用（无须转码，更低的资源消耗）
eguid音视频技术分享（JavaCV教程、FFmpeg教程、openCV图像处理教程、音视频教程）
10-12 2万+
javaCV系列文章： javacv开发详解之1：调用本机摄像头视频 javaCV开发详解之2：推流器实现，推本地摄像头视频到流媒体服务器以及摄像头录制视频功能实现(基于javaCV-FFMPEG、javaCV-openCV) javaCV开发详解之3：收流器实现，录制流媒体服务器的rtsp/rtmp视频文件(基于javaCV-FFMPEG) javaCV开发详解之4：转流器实现（也可作...
OpenCV添加文字和水印------c++
mankeywang的博客
04-25 223
图片添加文字水印
opencv 采样照片
weixin_46290197的博客
04-27 321
#1、动态采集人脸。# 加载人脸特径数据。
Python|OpenCV-边缘检测算法之Canny算法(15)
Python进阶专栏《爬虫实战进阶》，《数据分析入门与实战》原创作者
04-27 358
本文是该专栏的第16篇，后面将持续分享OpenCV计算机视觉的干货知识。Canny边缘检测算法是由John Canny于1986年提出的，它是一种多阶段的算法，其主要目的是在于提取图像中有用的结构信息，同时尽可能降低它的错误率。而Canny算法的高效性，主要体现在以下三个标准上：低误差率：标志着边缘检测必须尽可能精确地捕获图像中的边缘；高定位性：检测到的边缘点必须尽可能接近真实边缘的中心；最小响应：图像中的边缘只能被标记一次，并且可能存在的噪声不应产生误检。边缘检测，它是计算机视觉中的一项基础而重要的处理技
opencv_23_高斯模糊
最新发布
EveryDayOneHour的博客
04-29 1162
imshow("图像模糊2", dst);
opencv_19_图像直方图
EveryDayOneHour的博客
04-29 929
Mat b_hist;Mat g_hist;Mat r_hist;i++)直方图：
python-opencv实现最近邻插值和双线性插值对图片上采样
weixin_50233398的博客
04-26 638
python-opencv实现最近邻插值和双线性插值对图片上采样
c++ 实现opencv解码编码+ffmpeg给nginx推送rtmp流
06-06
你需要使用FFmpeg的API来打开一个RTMP流，并使用avcodec_encode_video2()函数将OpenCV编码后的视频帧推送到流中。 3. 将RTMP流推送到Nginx服务器。你可以使用RTMP协议将视频流推送到Nginx服务器。在Nginx服务器上，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

jsxyhelu2015

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值