精华内容
下载资源
问答
  • 视频流传输
    千次阅读
    2022-03-08 18:35:26

    秋风阁——北溪入江流:https://focus-wind.com/
    秋风阁——视频流传输协议

    常见视频传输协议

    协议httpflvrtmprtsphlsdash
    传输方式http流tcp流tcp流httphttp
    视频封装格式flvflv tagts mp4Ts文件Mp4 3gp webm
    延时
    数据分段连续流连续流连续流切片文件切片文件
    Html5播放可通过html5解封包播放(flv.js)不支持不支持可通过html5解封包播放(hls.js)如果dash文件列表是mp4webm文件,可直接播放

    监控行业常见的视频传输协议:RTSP,RTMP(以RTSP流为主)

    RTSP与RTMP比较

    • RTSP:低时延,实现难度大,适合视频聊天和视频监控
    • RTMP:浏览器支持好,加载flash插件后能直接播放(高版本浏览器目前已禁止flash插件)

    直播常见协议:RTMP,HTTP

    • RTMP:只支持flashplayer,目前已被淘汰
    • HTTP:flv,m3u8,ts
    • flv:flash video,需要flash支持,使用flv.js可支持播放(B站视频)
    • m3u8:切片文件,有延迟,实时性不如RTSP协议,如果压缩过小,可能导致客户端网络原因变卡,如果压缩过大,可能导致视频延迟过高
    • ts:切片文件,同m3u8
    更多相关内容
  • 但是有时,大家又希望能够随时随地观看视频直播。 大多数人会选择使用IP摄像机(Internet协议摄像机)而不是CCTV(闭路电视),因为它们具有更高的分辨率并降低了布线成本。在本文中,我们将重点介绍IP摄像机。IP...
  • 3DTV编解码技术及其立体视频流的...以及运动补偿预测与视差补偿预测技术的分析,在基于DSP平台TMS320DM642上进行AVS标清立体视频编解码及视频流优化传输,得出将互补的流媒体内容分发技术加以融合的立体视频流传输方法。
  • 3DTV编解码技术及其立体视频流...以及运动补偿预测与视差补偿预测技术的分析,在基于DSP平台TMS320DM642上进行AVS标清立体视频编解码及视频流优化传输,得出将互补的流媒体内容分发技术加以融合的立体视频流传输方法。
  • 目的基于缓存的自适应视频流传输策略无需估测实时带宽,直接通过缓存变化量与码率的映射函数选.取符合当前网络状况的最佳质量码流传输。传统基于缓存的自适应视频传输不考虑内容特征,在码率选择上为不 同运动级别...
  • 然而,由于5G无线异构网络具有信道带宽波动大、不同网络间差异明显等特点,多终端协同的自适应视频流传输面临着巨大挑战。提出了一种基于深度强化学习的自适应视频流传输控制方法。首先,建立了视频流动态规划模型,...
  • 针对多视频流共享传输链路时存在的编码数据包不匹配问题,提出一种用于无线多跳网络视频流传输的优先级机会网络编码方法。该方法对各传输流中优先等级不同的数据包执行不同的编码操作,在源端对视频流分段进行流内编码...
  • 在NS2平台上仿真实现了多媒体传感器网络的视频流传输,并在NS2-myEvalvid模型的基础上通过比较PSRN值分析了压缩量化参数、GOP类型、封包长度和封包错误率对视频流传输质量的影响。仿真实验表明,压缩量化参数、GOP...
  • howToStream:简单的前端+后端演示如何将视频流传输到Firefox,Chrome和Safari
  • 文章目录前言原理代码服务端...RTSP 协议更适合公网上的视频流传输(如直播),本题的环境要求是局域网,使用 UDP 传输足够达到要求,而且 UDP 相对于 RTSP 来说要简单很多。 原理 代码 代码在原作者的基础上做

    前言

    2021年电赛的测量题(如下)需要实现局域网视频传输,我们的方案是使用gst-rtsp-server 搭建 RTSP 服务器 进行视频推流。电赛后偶然看到了b站UP主「柒上夏OPO」的基于Opencv的无线视频传输,发现了一种更简单的传输方式 – UDP。

    RTSP 协议更适合公网上的视频流传输(如直播),本题的环境要求是局域网,使用 UDP 传输足够达到要求,而且 UDP 相对于 RTSP 来说要简单很多。

    请添加图片描述

    原理

    代码

    代码在原作者的基础上做了改进,包括:

    • 支持任意尺寸的视频传输
    • 改为非阻塞传输模式,即使客户端不发送数据,服务端的程序也可正常运行
    • 取消了线程,程序更加简洁

    服务端

    '''
    Author: 柒上夏OPO
    Date: 2022-01-10 12:31:24
    LastEditTime: 2022-01-14 14:52:54
    LastEditors: CloudSir
    Description: 
    '''
    
    import numpy as np
    import cv2
    from socket import *
    
    
    s = socket(AF_INET, SOCK_DGRAM) # 创建UDP套接字
    addr = ('0.0.0.0', 8081)  # 0.0.0.0表示本机
    s.bind(addr)
    
    s.setblocking(0) # 设置为非阻塞模式
    
    while True:
        data = None
        try:
            data, _ = s.recvfrom(921600)
            receive_data = np.frombuffer(data, dtype='uint8')
            r_img = cv2.imdecode(receive_data, 1)
    
            cv2.putText(r_img, "server", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2)
            cv2.imshow('server', r_img)
        except BlockingIOError as e:
            pass
    
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    
    cv2.destroyAllWindows()
    
    

    客户端

    '''
    Author: 柒上夏OPO
    Date: 2022-01-10 12:31:28
    LastEditTime: 2022-01-14 14:51:00
    LastEditors: CloudSir
    Description: 
    '''
    
    import numpy as np
    import cv2
    from socket import *
    
    # 127.0.0.1表示本机的IP,用于测试,使用时需要改为服务端的ip
    addr = ('127.0.0.1', 8081) 
    
    cap = cv2.VideoCapture(0)
    
    # 设置镜头分辨率,默认是640x480
    cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
    cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
    
    s = socket(AF_INET, SOCK_DGRAM) # 创建UDP套接字
    
    while True:
        _, img = cap.read()
    
        img = cv2.flip(img, 1)
    
        # 压缩图片
        _, send_data = cv2.imencode('.jpg', img, [cv2.IMWRITE_JPEG_QUALITY, 50])
    
        s.sendto(send_data, addr)
        print(f'正在发送数据,大小:{img.size} Byte')
    
        cv2.putText(img, "client", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2)
        cv2.imshow('client', img)
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    
    s.close()
    cv2.destroyAllWindows()
    
    

    运行效果

    请添加图片描述

    • client:客户端显示的图像
    • server:服务端显示的图像

    参考资料

    [1]GStreamer. gst-rtsp-server[EB/OL](N/A). https://github.com/GStreamer/gst-rtsp-server

    [2]柒上夏OPO. 基于Opencv的无线视频传输[EB/OL](2021–12–25). https://www.bilibili.com/video/BV1VL4y1n7nC

    展开全文
  • import socket import cv2 import numpy from time import sleep # socket.AF_INET 用于服务器与服务器之间的网络通信 # socket.SOCK_STREAM 代表基于TCP的流式socket通信 sock = socket.socket(socket.AF_INET, ...
    import socket
    import cv2
    import numpy
    from time import sleep
    
    # socket.AF_INET 用于服务器与服务器之间的网络通信
    # socket.SOCK_STREAM 代表基于TCP的流式socket通信
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 连接服务端
    address_server = ('172.17.76.32', 8888)
    sock.connect(address_server)
    
    # 从摄像头采集图像
    # 参数是0,表示打开笔记本的内置摄像头,参数是视频文件路径则打开视频
    capture = cv2.VideoCapture(0)
    # capture.read() 按帧读取视频
    # ret,frame 是capture.read()方法的返回值q
    # 其中ret是布尔值,如果读取帧正确,返回True;如果文件读到末尾,返回False。
    # frame 就是每一帧图像,是个三维矩阵
    ret, frame = capture.read()
    encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 50]
    while ret:
        # 首先对图片进行编码,因为socket不支持直接发送图片
        # '.jpg'表示把当前图片frame按照jpg格式编码
        # result, img_encode = cv2.imencode('.jpg', frame)
        img_encode = cv2.imencode('.jpg', frame, encode_param)[1]
        # result, img_encode = cv2.imencode('.jpg', frame)
        data = numpy.array(img_encode)
        stringData = data.tostring()
        # stringData = img_encode.tobytes()
        # 首先发送图片编码后的长度
        sock.send(str(len(stringData)).ljust(16).encode())
        # 然后一个字节一个字节发送编码的内容
        # 如果是python对python那么可以一次性发送,如果发给c++的server则必须分开发因为编码里面有字符串结束标志位,c++会截断
        # for i in range(0, len(stringData)):
        #     sock.send(stringData[i])
        sock.send(stringData)
        # sleep(1)
        print(str(len(stringData)).ljust(16).encode() + (stringData))
        ret, frame = capture.read()
        cv2.resize(frame, (640, 480))
    sock.close()
    cv2.destroyAllWindows()

    展开全文
  • 流视频 演示视频流传输方法的模板
  • Android车载娱乐系统实时视频流传输策略的研究.pdf
  • 基于A3C的无线异构网络自适应视频流传输控制方法.docx
  • Flask视频流传输

    千次阅读 2021-10-14 11:30:19
    使用 Flask 进行视频流传输 重新审视 Flask 视频流 目录流媒体Flask实现流传输multipart Response构建实时视频流服务器从相机中获取帧有线程时才运行照相机相机基类BaseCamera上一个版本存在的问题 流媒体 流式传输...

    参考资料
    在 Flask 里产生流式响应
    使用 multipart/x-mixed-replace 实现 http 实时视频流
    使用 Flask 进行视频流传输
    重新审视 Flask 视频流

    流媒体

    流式传输是一种技术,其中服务器以块的形式提供对请求的响应。流媒体有两大特点:
    1、large response(即数据量大) :对于非常大的响应,只需要在内存中组装响应才能将其返回给客户端可能效率低下。另一种方法是将响应写入磁盘,然后使用 返回文件flask.send_file(),但这会增加 I/O。假设数据可以分块生成,提供小部分响应是一个更好的解决方案。
    2、实时数据 :对于某些应用程序,请求可能需要返回来自实时源的数据。一个很好的例子是实时视频或音频馈送。许多安全摄像头使用这种技术将视频流式传输到网络浏览器。

    Flask实现流传输

    流式传输的实现是采用 生成器函数(yeild关键字) ,那么 HTTP 客户端将会得到这个迭代器每次迭代的结果一部分,迭代器产生多少客户端收到多少,就像流一样 。将一个生成器包装在Response类中返回。下面就展示了一个简单的流式输出,当输入http://localhost:5000/foo地址时,页面会分别输出两个字符串。

    返回流式响应的路由需要返回一个Response用生成器函数初始化的对象。然后 Flask 负责调用生成器并将所有部分结果作为块发送给客户端。

    @app.route('/foo')
    def foo():
        def generate():
            yield 'first part'
            sleep(3)
            yield 'second part'
        return Response(generate(), direct_passthrough=True)
    

    这样,当从数据库中查询大量的数据并返回时,我们不需要消耗大量的内存来存储数据并返回,而是生成一个迭代器来流式传输,这样Python 进程中的内存消耗将不会因为必须组装一个大的响应字符串而变得越来越大。

    multipart Response

    上面的示例生成一小部分的传统页面,所有部分连接到最终文档中。这是如何生成大量响应的一个很好的例子,但更令人兴奋的是使用实时数据。

    流式传输的一个有趣用途是让每个块替换页面中的前一个块,因为这使流能够在浏览器窗口中“播放”或动画。 使用这种技术,您可以让流中的每个块都成为一个图像 ,从而为您提供在浏览器中运行的酷炫视频源!

    有了视频帧之后,接下来的问题就是如何传输到客户端,这里有很多成熟的传输技术,包括: HLS、RTSP、RTMP等。这些技术有一定的复杂性,各自有其适用场景,如果业务场景对实时性、性能没有太高要求,那显得有点牛刀杀鸡了。有一个更简单,对前端更友好的方案: http 的 multipart 类型。

    multipart 通过 content-type 头定义。这里稍微解释一下,content-type 用于声明资源的媒体类型,浏览器会根据媒体类型的值做出不同动作。 比如,通常来说,chrome 遇到application/zip会下载资源;遇到application/pdf会启动预览,正是通过判断这个头部做出的分支选择。

    而 multipart 类型值声明服务器会将 多份数据 合并成当个请求。比较常见的例子是 form 表单提交,浏览器默认的 form 表单提交行为就是通过指定 content-type: multipart/form-data; boundary=xxx 头,服务器接收到后会根据 boundary 分割内容,提取多个字段。 规范文档 rfc1341 指定了四种子类型:multipart/mixed、multipart/alternative、multipart/digest、multipart/parallel,主流浏览器则扩展了一种新的类型: multipart/x-mixed-replace (不过由于很少用到这个特性,而且实现上容易出安全问题,MDN 已经标志为过期特性),该类型声明 body 内容由多份 XML 文档按序组合组合而成,每次到来的文档都会被用于创建新的 dom 文档对象,并触发文档对象 onload 事件。

    下面是一个multipart的响应实例:

    HTTP/1.0 200 OK
    Content-Type: multipart/x-mixed-replace; boundary=gc0p4Jq0M2Yt08jU534c0p
    X-Request-ID: bcd9f083-af7a-4419-94bd-0e47851a542d
    Date: Tue, 12 Mar 2019 05:04:39 GMT
    
    --gc0p4Jq0M2Yt08jU534c0p
    Content-Type: text/html
    
    <html><body>0</body></html>
    
    --gc0p4Jq0M2Yt08jU534c0p
    Content-Type: text/html
    
    <html><body>1</body></html>
    
    ...
    

    与常见的 http 响应相比,上例有两个特点。第一,在 header 中并没有指明 content-length 头,客户端无法预知资源大小 ,按规范,在这条 TCP 连接中断之前所传输过来的数据都是本次响应的内容,这个特性可以用于构建一个持久、可扩展的响应流,非常契合实时视频传输场景 。第二点是,response 的 body 部分由多份资源按序排列 而成,并使用 boundary 字符串标志资源的分割点 ,客户端可以使用 boundary 字符串抽取、解析出每一份资源的内容。

    简单的HTTP响应传输视频帧,存在一些问题

    • OpenCV 编解码效率并不高,替代方案是 FFMPEG
    • multipart/x-mixed-replace 是单次 http 请求-响应模型,如果网络中断,会导致视频流异常终止,必须重新连接
    • 无法同时输出音频
    • 针对专业、高性能要求的场景,建议还是使用专用协议,如 HLS、RTSP 等

    浏览器处理multipart/x-mixed-replace请求时,会使用当前的块数据替换之前的块数据。这刚好就是我们想要的流媒体的效果。我们可以把媒体的一帧数据打包为一个数据块,每块数据有自己的Content-Type和可选的Content-Length。浏览器逐帧替换,就实现了视频的播放功能。

    构建实时视频流服务器

    将视频流式传输到浏览器的方法有很多,每种方法都存在其优缺点。与Flask的流式传输功能配合良好的方法是流式传输一系列独立的JPEG图片,这种成为Motion JPEG ,被许多 IP 安全摄像机使用。这种方法延迟低,但质量不是最好的,因为 JPEG 压缩对于运动视频不是很有效。

    下面就是一个非常简单完整的web推流服务器,它可以提供Motion JPEG流:

    from flask import Flask, render_template, Response
    from camera import Camera
    
    app = Flask(__name__)
    
    @app.route('/')
    def index():
        return render_template('index.html')
    
    def gen(camera):
        while True:
            frame = camera.get_frame()
            yield (b'--frame\r\n'
                   b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n')
    
    @app.route('/video_feed')
    def video_feed():
        return Response(gen(Camera()),
                        mimetype='multipart/x-mixed-replace; boundary=frame')
    
    if __name__ == '__main__':
        app.run(host='0.0.0.0', debug=True)
    

    此应用程序导入一个Camera负责提供帧序列的类。在这种情况下,将相机控制部分放在一个单独的模块中是一个好主意,这样 Web 应用程序保持干净、简单和通用。

    该应用程序有两条路线。该 / 路由服务于index.html模板中定义的主页。它的代码如下:

    <html>
      <head>
        <title>Video Streaming Demonstration</title>
      </head>
      <body>
        <h1>Video Streaming Demonstration</h1>
        <img src="{{ url_for('video_feed') }}">
      </body>
    </html>
    

    这是一个简单的 HTML 页面,只有一个标题和一个图像标签。请注意,图像标签的src属性指向此应用程序的第二条路径,这就是魔术发生的地方。

    该/video_feed路线返回流响应。由于此流返回要在网页中显示的图像,因此此路由的 URLsrc位于图像标记的属性中。浏览器将通过在其中显示 JPEG 图像流来自动更新图像元素,因为大多数/所有浏览器都支持multipart response。

    /video_feed路由中使用的生成器函数称为gen(),并将Camera类的实例作为参数。在mimetype如上述所示,用参数设定multipart/x-mixed-replace的内容类型和边界设置为字符串"frame"。

    该gen()函数进入一个循环,在该循环中它不断从相机返回帧作为响应块。该函数通过调用该camera.get_frame()方法来要求相机提供一个帧,然后它会将该帧格式化为内容类型为 的响应块image/jpeg,如上所示。

    从相机中获取帧

    有线程时才运行照相机

    当第一个客户端连接到流时,从摄像头捕获视频帧的后台线程就开始了,但它永远不会停止。处理此后台线程的更有效方法是仅在有线程时运行它,以便在没有人连接时关闭相机。

    具体做法是:这个想法是每次客户端访问帧时,都会记录该访问的当前时间。相机线程检查这个时间戳,如果它发现它超过十秒就退出。通过此更改,当服务器在没有任何客户端的情况下运行十秒钟时,它将关闭其摄像头并停止所有后台活动。一旦客户端再次连接,线程就会重新启动。

    下面是程序部分实现:

    class Camera(object):
        # ...
        last_access = 0  # time of last client access to the camera
    
        # ...
    
        def get_frame(self):
            Camera.last_access = time.time()
            # ...
    
        @classmethod
        def _thread(cls):
            with picamera.PiCamera() as camera:
                # ...
                for foo in camera.capture_continuous(stream, 'jpeg', use_video_port=True):
                    # ...
                    # if there hasn't been any clients asking for frames in
                    # the last 10 seconds stop the thread
                    if time.time() - cls.last_access > 10:
                        break
            cls.thread = None
    

    相机基类BaseCamera

    我们需要使这个流服务器能够适用于不同的流(图片,视频,相机,树莓派等),可以将执行所有帧后台处理的通用功能移至基类,只留下从相机获取帧的任务以在子类中实现 ,下面是该基类的实现:

    class BaseCamera(object):
        thread = None  # background thread that reads frames from camera
        frame = None  # current frame is stored here by background thread
        last_access = 0  # time of last client access to the camera
        # ...
    
        @staticmethod
        def frames():
            """Generator that returns frames from the camera."""
            raise RuntimeError('Must be implemented by subclasses.')
            
    	def get_frame(self):
            """Return the current camera frame."""
            BaseCamera.last_access = time.time()
    
            # wait for a signal from the camera thread
            BaseCamera.event.wait()
            BaseCamera.event.clear()
    
            return BaseCamera.frame
            
        @classmethod
        def _thread(cls):
            """Camera background thread."""
            print('Starting camera thread.')
            frames_iterator = cls.frames()
            for frame in frames_iterator:
                BaseCamera.frame = frame
    
                # if there hasn't been any clients asking for frames in
                # the last 10 seconds then stop the thread
                if time.time() - BaseCamera.last_access > 10:
                    frames_iterator.close()
                    print('Stopping camera thread due to inactivity.')
                    break
            BaseCamera.thread = None
    

    这样 我们可以在不同子类中实现具体的获取帧的方法frames(),该方法就是一个生成器,里面含有yield关键字,将获取的帧数据转化为byte进行返回,如果需要进行图片的检测,也是在这一方法中进行

    例如从笔记本自带摄像头获取帧

    import cv2
    from base_camera import BaseCamera
    
    class Camera(BaseCamera):
        @staticmethod
        def frames():
            camera = cv2.VideoCapture(0)
            if not camera.isOpened():
                raise RuntimeError('Could not start camera.')
    
            while True:
                # read current frame
                _, img = camera.read()
    
                # encode as a jpeg image and return it
                yield cv2.imencode('.jpg', img)[1].tobytes()
    

    其中cv2.VideoCapture(0)中的0就表示从本地摄像头获取cap。

    上一个版本存在的问题

    多次观察到的另一个观察结果是服务器消耗大量 CPU。原因是后台线程捕获帧和生成器将这些帧提供给客户端之间没有同步。两者都尽可能快地跑,而不考虑对方的速度。

    通常,后台线程尽可能快地运行是有意义的,因为您希望每个客户端的帧速率尽可能高。但是您绝对不希望向客户端传送帧的生成器以比相机生成帧更快的速度运行,因为这意味着将向客户端发送重复的帧。(因为从上面BaseCamera的get_frame()函数可以看出,每次get_frame都是从一个类变量frame中获取的,而该frame的生成是在生成器中,如果客户端那边调用get_frame的速度大于生成器的生成速度,就会返回重复的图片) 虽然这些重复不会造成任何问题,但它们会增加 CPU 和网络使用率而没有任何好处。

    所以需要有一种机制,生成器只将原始帧传递给客户端,如果生成器内部的传递循环比相机线程的帧速率快,那么生成器应该等待新帧可用,以便它自己调整速度以匹配相机速率。另一方面,如果传递循环的运行速度比相机线程慢,那么它在处理帧时永远不会落后,而是应该跳过帧以始终传递最新的帧。

    我想要的解决方案是让相机线程在新帧可用时向正在运行的生成器发出信号。然后,生成器可以在等待信号时阻塞,然后再传送下一帧。在查看同步原语时,我发现threading.Event是与这种行为相匹配的。所以基本上,每个生成器都应该有一个事件对象,然后相机线程应该向所有活动的事件对象发出信号,以在新帧可用时通知所有正在运行的生成器。生成器传递帧并重置它们的事件对象,然后返回以再次等待下一帧。

    为了避免在生成器中添加事件处理逻辑,我决定实现一个定制的事件类,它使用调用者的线程 id 为每个客户端线程自动创建和管理一个单独的事件。老实说,这有点复杂,但这个想法来自 Flask 的上下文局部变量是如何实现的。新的事件类叫做CameraEvent,并拥有wait(),set()和clear()方法。有了这个类的支持,可以在BaseCamera类中加入速率控制机制:

    class CameraEvent(object):
        # ...
    
    class BaseCamera(object):
        # ...
        event = CameraEvent()
    
        # ...
    
        def get_frame(self):
            """Return the current camera frame."""
            BaseCamera.last_access = time.time()
    
            # wait for a signal from the camera thread
            BaseCamera.event.wait()
            BaseCamera.event.clear()
    
            return BaseCamera.frame
    
        @classmethod
        def _thread(cls):
            # ...
            for frame in frames_iterator:
                BaseCamera.frame = frame
                BaseCamera.event.set()  # send signal to clients
    
                # ...
    

    在CameraEvent类中完成的函数使多个客户端能够单独等待新帧。该wait()方法使用当前线程 id 为每个客户端分配一个单独的事件对象并等待它。该clear()方法将重置与调用者线程 id 关联的event,以便每个生成器线程可以以自己的速度运行。set()相机线程调用的方法向为所有客户端分配的事件对象发送一个信号,并且还将删除其所有者未提供服务的任何event,因为这意味着与这些event关联的客户端已关闭连接并且消失了。

    在BaseCamera的_thread()函数中,当执行一次BaseCamera.frame = frame后,说明出现了一张新的帧,这时调用set()方法发送信号,此时在get_frame()函数中的wait()阻塞的线程继续执行,将该新的帧return回去,这样就能将保证在get_frame()快的时候,先让他等待知道有新的帧出现。如果是_thread中相机线程更快,那么每次get_frame()都是最新的帧,而不必担心重复问题。而在get_frame()方法中的clear()表示将信号清除,这样每次在event.set()时判断是否event有信号isset()来判断客户端连接是否断开,如果没有信号,说明get_frame()中执行了wait()和clear(),表示客户端正在等待新的帧出现;如果是有信号isset()的状态,说明要么是客户端那边处理上一张帧的速度慢还没有执行get_frame(),要么是该客户端已经断开连接,如果这个时间超过了阈值5秒,那么就remove掉这个event。

    为了让您了解性能改进的幅度,请考虑模拟相机驱动程序在此更改之前消耗了大约 96% 的 CPU,因为它不断以远高于每秒生成一帧的速率发送重复帧。经过这些改动后,同样的流消耗了大约 3% 的 CPU。在这两种情况下,都有一个客户端查看流。对于单个客户端,OpenCV 驱动程序的 CPU 使用率从大约 45% 下降到 12%,每个新客户端增加了大约 3%。

    展开全文
  • 0.前言 1.视频流传输思想 2.摄像头部分 3.TCP client部分 4.TCP server部分 5.web server部分 6.验收 7.思考
  • 一个简单的Node.js模块,允许将视频流传输到任何Fire TV设备。 随时通过Paypal 花我一杯啤酒,谢谢! 如何使用FireTv Streamer: 包括库: var FireTv = require('./FireTv.js').server; 创建一个新实例 var ...
  • 通过分段线包络近似推断P2P视频流传输的回放速率和速率重置
  • 在NS2一MyEvalvid模型基础上分析了...通过改变编码的量化因子,得到了在多速率无线局域网环境(802.11b/e)下视频流传输的图像平均延迟和平均PSNR值。分析表明,802.11e在视频流传输性能上比802.11b具有更好的表现。
  • 针对家庭应用的增强型5GWi-Fi视频流传输芯片.pdf
  • 我需要能够立即从视频中的特定指定位置开始在网页上的Windows Media Player组件中播放.wmv视频。我可以嵌入该组件并播放视频。 问题是,即使我使用PARAM“ currentPosition”指定位置,...
  • 基于DM3730和W5300的嵌入式视频流传输系统的设计与实现.pdf
  • #资源达人分享计划#
  • 问题遇到的现象和发生背景 最近在实习,公司项目有一个视频流传输的需求,自己这段时间自学了一些FFmpeg的一些内容,但是很浅薄,虽然过程很坎坷但是还是成功的将视频流传输到unity中并且显示出来了,在桌面端的话...
  • ipfs-video-streaming:展示通过行星际文件系统进行视频流传输的网站
  • 深入分析网络编码的工作原理及其对于无线网络性能的提升, 在简要介绍视频传输特点的基础上探讨机会网络编码支持视频传输的要点, 通过仿真的方法研究无线网络中基于机会网络编码的实时视频传输性能, 并比较分析传输后...
  • QoE驱动的集中式调度,用于无线网络上的HTTP自适应视频流传输
  • 文章目录国标GB28181流传输几种模式UDPTCP主动TCP被动技术交流 国标GB28181流传输几种模式 UDP 流媒体服务端监听单个UDP端口,然后通过SIP信令(INVITE)告诉设备端口,设备主动向当前流媒体服务端发送视频流。 TCP...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,551
精华内容 3,020
关键字:

视频流传输

友情链接: zoded-processs.rar