第二十七章 视频推流细节

已于 2024-12-24 10:27:59 修改
阅读量812 收藏 17
点赞数 13
分类专栏： AI创业 WebRTC 文章标签： 音视频 开发语言 WebRTC gpt 人工智能 语言模型
于 2024-10-13 00:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ms44/article/details/142814452
版权

什么是推流？

推流，指的是把采集阶段封包好的内容传输到服务器的过程。其实就是将现场的视频信号传到网络的过程。“推流”对网络要求比较高，如果网络不稳定，直播效果就会很差，观众观看直播时就会发生卡顿等现象，观看体验很是糟糕。（我们的流式中，系统目前是后端做渲染，通过自定义的编码器实现视频流内容，然后交给客户端去显示。

本文中的截图或者说配图都是用微信小程序【字形绘梦】制作，谢谢该软件的免费支持。

OmniParser，微软的用于纯视觉 GUI 分析的Agent

我们尝试捕捉某个Window的界面内容)

要想用于推流还必须把音视频数据使用传输协议进行封装，变成流数据。常用的流传输协议有RTSP、RTMP、HLS等，使用RTMP传输的延时通常在1–3秒，对于手机直播这种实时性要求非常高的场景，RTMP也成为手机直播中最常用的流传输协议。最后通过一定的Qos算法将音视频流数据推送到网络断，通过CDN进行分发。

在直播场景中，网络不稳定是非常常见的，这时就需要Qos来保证网络不稳情况下的用户观看直播的体验，通常是通过主播端和播放端设置缓存，让码率均匀。另外，针对实时变化的网络状况，动态码率和帧率也是最常用的策略。

直播中使用广泛的“推流协议”一般是RTMP（Real Time Messaging Protocol——实时消息传输协议）。该协议是一个基于TCP的协议族，是一种设计用来进行实时数据通信的网络协议，主要用来在Flash/AIR平台和支持RTMP协议的流媒体/交互服务器之间进行音视频和数据通信。支持该协议的软件包括Adobe Media Server/Ultrant Media Server/red5等。

什么是拉流？

拉流是指服务器已有直播内容，根据协议类型（如RTMP、RTP、RTSP、HTTP等），与服务器建立连接并接收数据，进行拉取的过程。拉流端的核心处理在播放器端的解码和渲染，在互动直播中还需集成聊天室、点赞和礼物系统等功能。

拉流端现在支持RTMP、HLS、HDL（HTTP-FLV）三种协议，其中，在网络稳定的情况下，对于HDL协议的延时控制可达1s，完全满足互动直播的业务需求。RTMP是Adobe的专利协议，开源软件和开源库都支持的比较好，延时一般在1-3秒。HLS是苹果提出的基于HTTP的流媒体传输协议，优先是跨平台性比较好，HTML5可以直接打开播放，移动端兼容性良好，但是缺点是延迟比较高。

源代码展示

上源代码头文件部分

#pragma once
#include <string>
#include <thread>

#include "absl/memory/memory.h"
#include "absl/types/optional.h"
#include "api/audio/audio_mixer.h"
#include "api/audio_codecs/audio_decoder_factory.h"
#include "api/audio_codecs/audio_encoder_factory.h"
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "api/audio_codecs/builtin_audio_encoder_factory.h"
#include "api/audio_options.h"
#include "api/create_peerconnection_factory.h"
#include "api/rtp_sender_interface.h"
#include "api/video_codecs/builtin_video_decoder_factory.h"
#include "api/video_codecs/builtin_video_encoder_factory.h"
#include "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_encoder_factory.h"

#include "modules/audio_device/include/audio_device.h"
#include "modules/audio_processing/include/audio_processing.h"
#include "modules/video_capture/video_capture.h"
#include "modules/video_capture/video_capture_factory.h"
#include "p2p/base/port_allocator.h"
#include "pc/video_track_source.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
#include "rtc_base/ref_counted_object.h"
#include "rtc_base/rtc_certificate_generator.h"
#include "rtc_base/strings/json.h"
#include "modules/desktop_capture/desktop_capturer.h"
#include "modules/desktop_capture/desktop_frame.h"
#include "modules/desktop_capture/desktop_capture_options.h"
#include "modules/desktop_capture/cropping_window_capturer.h"
#include "media/base/adapted_video_track_source.h"
#include "api/video/i420_buffer.h"
#include "third_party/libyuv/include/libyuv.h"
#include "../CaptureInterface/BaseCaptureInterface.h"

#include "modules\desktop_capture\win\window_capturer_win_gdi.h"

namespace QL
{

        //class QLWindowCaptureEXImpl :public webrtc::WindowCapturerWinGdi
        //{

        //};


        /// <summary>
        /// 封装了捕捉指定窗口名字的截屏类 , 目前只支持在主屏幕上
        /// 由于我们不是使用使用摄像头作为数据源，而是自定义的内容，因此必须实现此接口VideoTrackSourceInterface, 也就是其基类 AdaptedVideoTrackSource 也可以
        /// ICaptureBaseInterface是 我们自己的接口，为了统计数据
        /// </summary>
    class QLWindowCaptureImpl : public rtc::AdaptedVideoTrackSource, public webrtc::DesktopCapturer::Callback, ICaptureBaseInterface
        {

        public:
                // Inherited via Callback
        void OnCaptureResult (webrtc::DesktopCapturer::Result result, std::unique_ptr<webrtc::DesktopFrame> desktopframe) ;

                // 自己封装的函数，用于开始和停止捕捉数据
                void StartCapture () override;
                void StopCapture () override;

                //静态函数，创建一个本类。其实就是做了一些封装而已
                //Title和processID是个2选1的选择
                static QLWindowCaptureImpl* Create (size_t target_fps, std::string inTargetWindowTitle);

                //--RefCountedObject 这几个函数重载了AdaptedVideoTrackSource对象
                virtual void AddRef() const override;
                virtual rtc::RefCountReleaseStatus Release() const override;


        public:

                bool static WeThinkTheyAreEqual(std::string src, std::string dest);

                void SetState (SourceState new_state);

                SourceState state () const override
                {
                        return state_;
                }
                bool remote () const override
                {
                        return remote_;
                }

                bool is_screencast () const override
                {
                        return false;
                }
                absl::optional<bool> needs_denoising () const override
                {
                        return absl::nullopt;
                }

                bool GetStats (Stats* stats) override
                {
                        return false;
                }

        protected:
                explicit QLWindowCaptureImpl (std::unique_ptr<webrtc::DesktopCapturer> dc, size_t fps, std::string window_title)
                        : mDC (std::move (dc)),
                        mTargetFPS(fps),
                        mWinTitle (std::move (window_title)),
                        mIsStarted (false),
                        remote_ (false),
                        mRefCount(0)
                {
                }

        private:
                // RefCountedObject
                SourceState state_;
                const bool remote_;

                mutable webrtc::webrtc_impl::RefCounter mRefCount;

                //捕捉对象
                std::unique_ptr<webrtc::DesktopCapturer> mDC;
                //我们输出视频的FPS
                size_t mTargetFPS;
                //窗体Title
                std::string mWinTitle;
                rtc::scoped_refptr<webrtc::I420Buffer> mI420YUVBuffer;
                //开线程做捕捉行为
                std::unique_ptr<std::thread> mCaptureThread;
                //是否已经启动捕捉的标志位
                std::atomic_bool mIsStarted;

        };


}

Cpp部分

#include "QLWindowCapture.h"
#include "QLGlobalConfig.h"
#include <../microprofiler/microprofile.h>
#include "../CommonHelper/QLGlobalConfig.h"
#include "modules/desktop_capture/desktop_capture_options.h"
#include <boost/algorithm/string.hpp> 

#include "modules\desktop_capture\win\wgc_capturer_win.h"

namespace QL
{

        /// <summary>
        /// 抓取的帧数据，我们需要再次处理下
        /// 截屏后得到的数据格式是rgb，需要使用libyuv将数据从rgb转换为yuv420，然后传入编码器和进行本地渲染。
        /// 转换时注意填写正确的原始数据类型，windows下格式为webrtc::kARGB
        /// </summary>
        /// <param name="result"></param>
        /// <param name="desktopframe">回調準備好的桌面的幀數據了</param>
        void QLWindowCaptureImpl::OnCaptureResult(webrtc::DesktopCapturer::Result result, std::unique_ptr<webrtc::DesktopFrame> desktopframe)
        {
                switch (result)
                {
                case webrtc::DesktopCapturer::Result::SUCCESS:
                        //Only this is valid.
                        break;
                case webrtc::DesktopCapturer::Result::ERROR_TEMPORARY:
                        QL_ERROR("Error from capture frame source temporary.");
                        return;
                case webrtc::DesktopCapturer::Result::ERROR_PERMANENT:
                        QL_ERROR("Error from capture frame source permanent.");
                        return;
                default:
                        return;
                }

                int width = desktopframe->stride() / 4;
                int startYPosition = 0;
                int height = desktopframe->size().height();

                if (QL::QLGlobalConfig::Get().IsHideWindowTitleInAppCaptureType())
                {
                        //This is offical window title height;
                        startYPosition = 30;
                        height -= startYPosition;
                }

                if (!mI420YUVBuffer.get() || mI420YUVBuffer->width() * mI420YUVBuffer->height() < width * height)
                {
                        mI420YUVBuffer = webrtc::I420Buffer::Create(width, height);
                }

                int stride = width;
                uint8_t* yplane = mI420YUVBuffer->MutableDataY();
                uint8_t* uplane = mI420YUVBuffer->MutableDataU();
                uint8_t* vplane = mI420YUVBuffer->MutableDataV();

                libyuv::ConvertToI420(desktopframe->data(), 0, yplane, stride, uplane,
                        (stride + 1) / 2, vplane, (stride + 1) / 2, 0, startYPosition,
                        width, height, width, height, libyuv::kRotate0,
                        libyuv::FOURCC_ARGB);

                webrtc::VideoFrame frame = webrtc::VideoFrame(mI420YUVBuffer, 0, 0, webrtc::kVideoRotation_0);

                //将这个VideoFrame数据压倒流中，传出去
                this->OnFrame(frame);
        }



        /// <summary>
        /// 开始截屏
        /// </summary>
        void QLWindowCaptureImpl::StartCapture()
        {
                if (mIsStarted)
                {
                        return;
                }

                mIsStarted = true;
                // Start new thread to capture
                //We have to calc the time of capture method,  set this as timeSpan
                //if we set fps=30, then sleep time will be 1000/fps- timeSpan 
                //
                mCaptureThread.reset(new std::thread([this]()
                        {
                                //第一步開始捕捉
                                mDC->Start(this);
                                //auto ifps = 1000 / mFPS;
                                std::chrono::milliseconds ifps = std::chrono::milliseconds(1000 / mTargetFPS);

                                while (mIsStarted)
                                {
                                        auto aTime = webrtc::Clock::GetRealTimeClock()->TimeInMilliseconds();
                                        //第二步，每幀捕捉，這樣會進入OnCaptureResult
                                        mDC->CaptureFrame();


                                        auto bTime = webrtc::Clock::GetRealTimeClock()->TimeInMilliseconds();

                                        auto timeSpan = std::chrono::duration<double, std::micro>(bTime - aTime);
                                        auto fpsSpan = std::chrono::duration<double, std::micro>(ifps - timeSpan);

                                        std::this_thread::sleep_for(fpsSpan);

                                        auto cTime = webrtc::Clock::GetRealTimeClock()->TimeInMilliseconds();
                                        auto timeForRealFPS = std::chrono::duration<double, std::micro>(cTime - aTime);
#if _DEBUG        
#if TEST_FPS_TIME
                                        std::cout << "Capture Processed time (ms):" << (bTime - aTime) << std::endl;
                                        std::cout << "Sleep time (ms):" << (ifps.count() - timeSpan.count()) << std::endl;

                                        std::cout << "Real FPS:" << 1000 / timeForRealFPS.count() << std::endl;
#endif
#endif
                                        this->SetRealFPS(timeForRealFPS.count());
                                        MICROPROFILE_SCOPEI(__FUNCTION__, "FPS", 0xff3399ff);
                                        MICROPROFILE_META_CPU("FPS", timeForRealFPS.count());
                                        MicroProfileFlip();
                                }
                        }));
        }

        /// <summary>
        /// 停止截屏
        /// </summary>
        void QLWindowCaptureImpl::StopCapture()
        {
                mIsStarted = false;

                if (mCaptureThread && mCaptureThread->joinable())
                {
                        mCaptureThread->join();
                }
        }

        bool QLWindowCaptureImpl::WeThinkTheyAreEqual(std::string src, std::string dest)
        {
                std::string mySrc = src;
                boost::algorithm::to_lower(mySrc);
                std::string myDest = dest;
                boost::algorithm::to_lower(myDest);

                std::string::size_type myIndex = myDest.find(mySrc);
                if (myIndex == std::string::npos)
                {
                        return false;
                }
                else
                {
                        return true;
                }
        }

        /// <summary>
        /// 创建捕捉指定窗体名字的视频流对象
        /// </summary>
        /// <param name="target_fps">目标FPS</param>
        /// <param name="inTargetWindowTitle">对应窗口名字.无视这个窗体在哪个屏幕中都可以获取到</param>
        /// <param name="processID">请注意sources[i].id中的不是ProcessID</param>
        /// <returns></returns>
        QLWindowCaptureImpl* QLWindowCaptureImpl::Create(size_t target_fps, std::string inTargetWindowTitle)
        {
                /*webrtc::DesktopCaptureOptions myOption;
                myOption.set_allow_cropping_window_capturer(true);
                myOption.set_enumerate_current_process_windows(true);
                myOption.set_use_update_notifications(true);*/
                //auto myDC = webrtc::DesktopCapturer::CreateWindowCapturer(myOption);

                auto myWindowCapturer = webrtc::DesktopCapturer::CreateWindowCapturer(webrtc::DesktopCaptureOptions::CreateDefault());

                //std::unique_ptr<webrtc::DesktopCapturer> myScreenCapturer;
                //myScreenCapturer =std::unique_ptr<webrtc::DesktopCapturer>(new webrtc::WgcCapturerWin(webrtc::DesktopCaptureOptions::CreateDefault()));


                if (!myWindowCapturer)
                {
                        return nullptr;
                }


                webrtc::DesktopCapturer::SourceList sources;
                webrtc::DesktopCapturer::Source mySelectedSource;
                //首先可以确定的是这个对象的ID 既不是进程的PID，也不是窗口句柄
                //貌似是webrtc的随机ID
                myWindowCapturer->GetSourceList(&sources);

                //Since it can be detect with == , sources[i].title property is not precise ,
                //sometimes it contain wrong content ,sometimes it is empty.
                //we don't have any other option to detect, so we have to detect it with our logic.
                for (size_t i = 0; i < sources.size(); i++)
                {
                        //if (WeThinkTheyAreEqual(inTargetWindowTitle ,""))
                        //{ 
                        //        //由于这个sources[i].id不是Processid，这里的代码永远不会走到。
                        //        if (sources[i].id == processID)
                        //        {
                        //                mySelectedSource = sources[i];
                        //                QL_LOG(std::string("Find target process id %d", processID));
                        //                break;
                        //        }
                        //}
                        //else
                        //{
                                if (WeThinkTheyAreEqual(inTargetWindowTitle, sources[i].title))
                                {
                                        mySelectedSource = sources[i];
                                        QL_LOG(std::string("Find target window name ") + inTargetWindowTitle);
                                        break;
                                }
                                else
                                {
                                        //QL_LOG(std::string("Existed window name :") + sources[i].title);
                                }
                        //}
                }
                if (mySelectedSource.title == "")
                {
                        QL_ERROR("not found target window ,name is %s", inTargetWindowTitle.c_str());
                        return NULL;
                }
                
                //這是最關鍵的。根據window title找到了window id 進行針對這個窗體的截屏
                //很奇怪的是這個ID并不是WIndow的Handle
                myWindowCapturer->SelectSource (mySelectedSource.id);

                auto targetWinTitle = mySelectedSource.title;
                auto targetFPS = target_fps;



                RTC_LOG(LS_INFO) << "Init DesktopCapture finish";
                // Start new thread to capture
                //主要是第一個參數，新建了捕捉器
                return new QLWindowCaptureImpl(std::move(myWindowCapturer), targetFPS, std::move(targetWinTitle));
        }

        void QLWindowCaptureImpl::AddRef() const
        {
                mRefCount.IncRef();
        }

        rtc::RefCountReleaseStatus QLWindowCaptureImpl::Release() const
        {
                rtc::RefCountReleaseStatus status = mRefCount.DecRef();
                return status;
        }

}

核心函数讲解

我们主要介绍下细节内容：

  1. 首先我们需要将视频轨道的具体实现添加进入P2P的连接后。然后在具体的视频捕获器中实现具体的几个重要节点函数。
  2. 第一个重要函数是：视频处理类的初始化，并且在尽可能早的时候调用StartCapture 函数。整个函数不是必须，但是一般我们建议这么设计。好处在于，初始化视频捕捉类后，可能不一定适合立即处理视频流内容，我们还需要延迟一段时间进行正式处理，避免短暂的有黑屏的情况发生。并且有了StartCapture函数，就会有StopCapture，保证逻辑上完整。开始和结束对应。
  3. 在Capture视频流内容的函数中，我们需要开启一个线程专门处理这个业务。避免影响其余的主要业务。同时，我们通过外部设置的FPS来控制调用这个捕捉视频源数据函数的频率。从而实现外部要求的FPS，也就是帧率。一般的，如果是视频数据，我们只需要保证>24FPS即可。但是考虑到很多实际的场合应用30FPS是比较好的设置。但是也考虑到视频捕获的耗时，这方面可能需要具体根据需求来进行控制。
  4. 视频捕捉的具体逻辑中，我们将原始的数据转换成RGBA的图像，有时候也可能是Gray的这中灰度图，但不管如何都是二进制的数据，无非就是组成这个二进制数据的数据格式，描述这些数据的RGBA4个通道还是RGB的三个通道，每个通道一般是8bit，但是也有10bit的图形数据，这种特殊的情况，我们后续再议。有了这个图像元数据，我们一般调用YUV420，或者444等视频格式的数据，因为最终推送到webrtc中的是一个Frame对象，它一般需要视频格式。至于什么是YUV420，444，等格式区别，本文不扩展。

核心代码结构

总体来看，这个主要的函数非常有意义

        void FakeVideoCapturer::CaptureOurImage()
        {
                MicroProfileFlip();
                webrtc::VideoFrame myYUVFrame = QLTestImageQuality::Get().DoImageQualityChecking(this->GetStatusObserver());

                MICROPROFILE_SCOPEI(__FUNCTION__, "OnFrame ", 0xeeee00);
                this->OnFrame(myYUVFrame);
                MICROPROFILE_SCOPEI(__FUNCTION__, "OnFrame(End)", 0xeedd44);
        }

上述核心代码中MicroProfile是我们度量性能消耗的一个衡量宏。可以帮助我们分析每一步的时间消耗。除此之外就只有2个主要的行为，

  1. 获取webrtc::VideoFrame 这个对象
  2. 调用OnFrame函数推送出去这个YUV 的Frame数据。

这个OnFrame是接口中的定义函数。我们的实现中只要具体实现，webrtc的工作流就会自动推送出去。 见webrtc中源代码

namespace rtc {

template <typename VideoFrameT>
class VideoSinkInterface {
 public:
  virtual ~VideoSinkInterface() = default;

  virtual void OnFrame(const VideoFrameT& frame) = 0;

  // Should be called by the source when it discards the frame due to rate
  // limiting.
  virtual void OnDiscardedFrame() {}

  // Called on the network thread when video constraints change.
  // TODO(crbug/1255737): make pure virtual once downstream project adapts.
  virtual void OnConstraintsChanged(
      const webrtc::VideoTrackSourceConstraints& constraints) {}
};

}  // namespace rtc

【2025跑通的AI变现玩法之二十七】【 数字人24小时直播矩阵：重构流量获取与软件营销的商业范式】
再见孙悟空的专栏
04-21 435
人力成本下降90%传统直播：需配置主播（1-3万/月）+运营（8千/月）+场控（6千/月），单账号月成本≥2.4万元数字人直播：单数字人初始成本5-10万元（可复用3年以上），后续月维护成本<2千元（算力+内容更新），10账号矩阵月成本≤2.2万元案例：某CRM软件公司停用30人主播团队，改用数字人矩阵后，年直播成本从720万元降至85万元，降幅达88%时间效率提升500%传统直播：单日有效直播时长≤6小时（主播精力限制），月均开播15天，覆盖时长90小时。
【AD2426/7/8_A2B收发器技术参考手册】第三章 操作和配置
专注音频，高效工作，快乐生活！
09-28 2105
2，使用远程从设备 I2C 寄存器访问写操作，将所需的从收发器的 A2B_CHIP 寄存器编程为连接到从设备的外设的 I2C 设备地址。3，使用直接 I2C 寄存器访问写操作设置主收发器的 A2B_NODEADR.PERI 位（同时保持 A2B_NODEADR.NODE 字段的内容），确保后续的 BUS_ADDR 访问可以发送到所需的从节点 I2C 外设。
ffmpeg视频推流
02-23
ffmpeg视频推流，里面用map封装好了，只需要填相应的视频流地址以及需要ffmpeg名字就可以用
视频流推送
qq_43168299的博客
03-24 408
降低延迟、内存溢出。 import cv2 import queue import time import threading q = queue.Queue() def img_resize(image): height, width = image.shape[0], image.shape[1] # 设置新的图片分辨率框架 640x369 1280×720 1920×1080 width_new = 1920 height_new = 1080 # 判断图
webrtc推流和拉流的最佳实践
最新发布
liveweb视频汇聚平台
03-03 490
WebRTC（Web Real-Time Communication）是一种实时通讯技术，允许网络应用或站点在不借助中间媒介的情况下，建立浏览器之间的点对点（Peer-to-Peer）连接，实现视频流、音频流或其他任意数据的传输。通过遵循以上最佳实践，可以确保WebRTC推流和拉流功能的高效、稳定和可靠运行，为用户提供优质的实时通讯体验‌。
RTMP直播推流（一）视频推流
weixin_58308529的博客
10-08 4051
RTMP直播推流（一）视频推流
nginx-rtmp之直播视频流的推送
weixin_30828379的博客
09-24 948
　　一、RTMP是Real Time Messaging Protocol（实时消息传输协议）的首字母缩写。该协议基于TCP，是一个协议族，包括RTMP基本协议及RTMPT/RTMPS/RTMPE等多种变种。RTMP是一种设计用来进行实时数据通信的网络协议，主要用来在Flash/AIR平台和支持RTMP协议的流媒体/交互服务器之间进行音视频和数据通信。支持该协议的软件包括Adobe Me...
最新技术整理3款开源免费直播推流工具，实现实时视频推流、视频拉流，目标端可以是服务器、云平台、移动设备等（附源码）
代码讲故事
12-22 6648
最新技术整理3款开源免费直播推流工具，实现实时视频推流、视频拉流，目标端可以是服务器、云平台、移动设备等（附源码）。
个性化视频推荐系统的设计与实现(python实现)
lazycatlove的博客
05-21 2048
PyCharm 是 JetBrains 公司开发的一款商业的 Python 集成开发环境，如图 2.1,编写代码会给出提示，不同的语法颜色不同，例如关键字，字符串等字体颜色不一样，并且集成版本控制管理工具，对开发人员的操作提供便利，最主要的是有调式功能，对每一个开发人员，调式是开发人员必备技能，很快能定位到错误的位置或者能深入的了解程序运行的过程。我们的系统是基于 Web 的，该编辑器还支持 Web 开发。图 2.1 PyCharm 工作平台。
【实时视频流处理实战】：直播流地址.txt在数据分析中的应用
![【实时视频流处理实战】：直播流地址.txt在数据分析中的应用]...本文深入探讨了实时视频流处理的基础理论、技术实践和高级应用，并分析了直播流地址.txt的解析与应用在数据采集、实时分析及高级应用集
计算机网络知识点汇总（谢希仁 第七版）_谢希仁计算机网络第七版知识点
2401_84281712的博客
04-30 864
运输层用来解决进程之间的通信问题，属于面向通信部分的最高层运输层向用户屏蔽了下面网络核心的细节；为了能够满足同一主机的不同进程间的通信要求，运输层需要一个很重要的功能——分用与复用（分用指发送方不同进程可以使用同一运输协议进行发送数据报。分用指接收方的运输层可以将接收到的数据报正确交付给不同的进程）运输层还要对从网络层收到的数据报进行差错检测，（IP数据包中的首部中的检验和字段只是对首部进行检查，并不对数据部分进行检查）运输层的两个主要协议：　用户数据报协议UDP——无连接。
live555主动推送视频流给darwin
09-12
获取rtsp 视频流推送给darwin，支持多路，支持断线反馈给上层，vs2010编译通过，因为injector 不是很好修改成单线程多对象，目前采用一路一线程实现，线程退出稍微有点点问题，有修改好的同学，可以反馈给我
OBS-Studio直播视频，推流拉流软件
12-19
OBS 直播视频，推流拉流软件，软件开源，说明文档百度OBS即可，挺好的软件，还可以做远程监控
音视频流推送测试工具
01-15
可用于测试流媒体测试，支持RTMP等流媒体协议。用于类似视频通话，直播等流媒体服务器的测试
通过视频流实现视频的播放
09-08
通过视频流实现视频的播放
RTSP应用：实现视频流的实时推送
karl2000的专栏
03-28 1480
在实现实时视频流推送的项目中，RTSP（Real Time Streaming Protocol）协议扮演着核心角色。本文将指导你通过安装FFmpeg软件，下载并编译live555，以及配置ffmpeg进行视频流推送，来实现一个基本的RTSP流媒体服务。
摄像头视频推流
weixin_42068948的博客
01-29 855
安装SYS Step 1：get SRS 　　git clone https://github.com/ossrs/srs 　　 cd srs/trunk Step 2：build SRS, Requires Centos6.x/Ubuntu12 32/64bits, others see Build(CN,EN). 　　 ./configure && make Step 3: start SRS 　　　./objs/srs -c conf/srs.conf 推流 f.
视频推流、拉流相关技术
weixin_42151869的博客
12-15 3534
这里写自定义目录标题视频的推流与拉流webrtc 视频的推流与拉流 拉流是指服务器已有直播内容，用指定地址进行拉取的过程。 推流指的是把采集阶段封包好的内容传输到服务器的过程，其实就是将现场的视频信号传到网络的过程。推流对网络要求比较高，如果网络不稳定，直播效果就会很差，观众观看直播时就会发生卡顿等现象。 拉流是指服务器已有直播内容，根据协议类型（如RTMP、RTP、RTSP、HTTP等），与服务器建立连接并接收数据，进行拉取的过程。拉流端的核心处理在播放器端的解码和渲染，在互动直播中还需集成聊天室、点赞和
什么是视频推流和视频拉流？
o67f2wpkvdf3bpe8的博客
06-10 7660
随着互联网的迅猛发展，视频成为了人们日常生活中不可或缺的一部分。而在视频的传输过程中，视频推流和视频拉流技术扮演了重要的角色。本文将详细介绍视频推流和视频拉流的概念、原理、应用领域以及涉及的技术。
Sanjit K Mitra数字信号处理课后答案解析第二至十章
本次提供的课后答案覆盖了书籍的第二章到第十章，其中第二章到第四章一般介绍信号与系统的基本概念、时域和频域分析方法，第五章到第七章可能涉及Z变换、离散傅里叶变换（DFT）和快速傅里叶变换（FFT）的理论与应用...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

拉达曼迪斯II

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

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

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

打赏作者

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

抵扣说明：

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

余额充值