【owt】WebrtcNode, publish-sdp offer 流程(3)

已于 2023-06-04 00:49:21 修改
阅读量494 收藏
点赞数 1
分类专栏： owt server 文章标签： publish sdp owt webrtc 音视频
于 2023-06-02 22:05:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/alex0203/article/details/130997702
版权

流程图

在这里插入图片描述

  1. 因为erizon::VideoFrameConstructor（继承于VideoFrameSource）作为视频源，从mediaStream把数据接收过来，VideoFrameSource中，然后分别存到owt_base.InternalServer的m_sourceMap（以publicTrackId = transportId + ‘-’ + track.id 为key，addon.VideoFrameSource 为value）（这里什么时候使用？？？）中和Connections中（这里是子在视频订阅的时候用，linkup的时候使用）
VideoFrameSource存放在connections中
/*{ConnectionID: {type: 'webrtc' | 'avstream' | 'recording' | 'internal',
direction: 'in' | 'out',
audioFrom: ConnectionID | undefined,
videoFrom: ConnectionID | undefined,
connnection: WebRtcConnection | InternalOut | RTSPConnectionOut
}
}
*/
connection 存放的就是VideoFrameSource

  1. mediaUpdate， 通过RpcClient.remoteCast， 消息广播给controller， ConferenceAgent

  2. trackUpdate， 通过RpcClient.remoteCast， 消息广播给controller，ConferenceAgent

1. track-added

dist/webrtc_agent/webrtc/wrtcConnection.js

const setupTransport = function (mid) {
    ...

    if (rids) {
        ...
    } else {
        // 走这里的代码
      // No simulcast
      if (!trackMap.has(mid)) {
        // 1. Connection wrtc
        trackMap.set(mid, new WrtcStream(mid, wrtc, direction, trackSettings));
        ...
        // 3. Notify new track
        on_track({
          type: 'track-added',
          track: trackMap.get(mid),
          operationId: opSettings.operationId,
          mid: mid
        });
      } else {
        log.warn(`Conflict trackId ${mid} for ${wrtcId}`);
      }
    }

    return opSettings.operationId;
  };

trackMap 属性——存放了WrtcStream

  // composedId => WrtcStream
  var trackMap = new Map();

composeId

  const composeId = function (mid, rid) {
    return mid + ':' + rid;
  };

1.1 on_track

dist/webrtc_agent/webrtc/wrtcConnection.js

module.exports = function (spec, on_status, on_track) {
...
}

1.2 on_track= function onTrack(trackInfo)

dist/webrtc_agent/webrtc/index.js

var connection = new WrtcConnection({
            connectionId: transportId,
            threadPool: threadPool,
            ioThreadPool: ioThreadPool,
            network_interfaces: global.config.webrtc.network_interfaces,
            owner,
        }, function onTransportStatus(status) {
            notifyTransportStatus(controller, transportId, status);
        }, function onTrack(trackInfo) {
            handleTrackInfo(transportId, trackInfo, controller);
        });

2. ======WebrtcNode.handleTrackInfo

dist/webrtc_agent/webrtc/index.js

// trackInfo 就是on__track 回调回来
var handleTrackInfo = function (transportId, trackInfo, controller) {
        var publicTrackId;
        var updateInfo;
        if (trackInfo.type === 'track-added') {
            // Generate public track ID
            const track = trackInfo.track; // track是WrtcStream
            // track.id 就是mid
            publicTrackId = transportId + '-' + track.id;
            if (mediaTracks.has(publicTrackId)) {
                log.error('Conflict public track id:', publicTrackId, transportId, track.id);
                return;
            }
            mediaTracks.set(publicTrackId, track);
            mappingPublicId.get(transportId).set(track.id, publicTrackId);
            if (track.direction === 'in') {
                // 1. source， 返回的是addon.Source
                // WrtcStream.sender()
                // WrtcStream 就是在小结4中创建
                const trackSource = track.sender();
                // 2. add source
                 // InternalConnectionRouter router
                router.addLocalSource(publicTrackId, 'webrtc', trackSource)
                .catch(e => log.warn('Unexpected error during track add:', e));
            } else {
                router.addLocalDestination(publicTrackId, 'webrtc', track)
                .catch(e => log.warn('Unexpected error during track add:', e));
            }

            // 3. Bind media-update handler
            track.on('media-update', (jsonUpdate) => {
                log.debug('notifyMediaUpdate:', publicTrackId, jsonUpdate);
                notifyMediaUpdate(controller, publicTrackId, track.direction, JSON.parse(jsonUpdate));
            });
            // 4. Notify controller
            const mediaType = track.format('audio') ? 'audio' : 'video';
            updateInfo = {
                type: 'track-added',
                trackId: publicTrackId,
                mediaType: track.format('audio') ? 'audio' : 'video',
                mediaFormat: track.format(mediaType),
                direction: track.direction,
                operationId: trackInfo.operationId,
                mid: trackInfo.mid,
                rid: trackInfo.rid,
                active: true,
            };
            log.debug('notifyTrackUpdate', controller, publicTrackId, updateInfo);
            notifyTrackUpdate(controller, transportId, updateInfo);

        } else if (trackInfo.type === 'track-removed') {
            ...
        } else if (trackInfo.type === 'tracks-complete') {
            updateInfo = {
                type: 'tracks-complete',
                operationId: trackInfo.operationId
            };
            notifyTrackUpdate(controller, transportId, updateInfo);
        }
    };
track==WrtcStream
publicTrackId = transportId + ‘-’ + track.id;
track.id, （rids不空，composedId=mid:rids）
track.id, （rids为空，composedId=mid）
mediaTracks——{ publicTrackId => WrtcTrack }
 // Map { publicTrackId => WrtcTrack }
 var mediaTracks = new Map();
 mediaTracks.set(publicTrackId, track);
mappingPublicId——{ transportId => Map { trackId => publicTrackId } }
// Map { transportId => Map { trackId => publicTrackId } }
var mappingPublicId = new Map();
mappingPublicId.get(transportId).set(track.id, publicTrackId);
??? var router = new InternalConnectionRouter(global.config.internal);

2.1 ==========WrtcStream.sender——获取source,VideoFrameSource

dist-debug/webrtc_agent/webrtc/wrtcConnection.js

sender(track) {
    let sender = null;
    if (track === 'audio' && this.audioFrameConstructor) {
...
    } else if (track === 'video' && this.videoFrameConstructor) {
...
    // track = null
    } else if (!track) {
    // 走这里的流程
      let parent = (this.audioFrameConstructor || this.videoFrameConstructor);
        // parent.source() 返回addon.VideoFrameSource， 调用native
        // addon.VideoFrameSource sender，子类FrameSource    
      sender = parent.source();
       //
      // 这里赋值了parent
      sender.parent = parent;
    } else {
      log.error('sender error');
    }
    if (sender) {   
      
       //  定义两个函数        
      sender.addDestination = (track, dest) => {
        // parent 就是VideoFrameConstructor
        sender.parent.addDestination(dest);
      };
      sender.removeDestination = (track, dest) => {
        sender.parent.removeDestination(dest);
      };
      ///
    }
    return sender;
  }
2.1.1 NAN_METHOD(VideoFrameConstructor::source）

source/agent/webrtc/rtcFrame/VideoFrameConstructorWrapper.cc

NAN_METHOD(VideoFrameConstructor::source) {
  const int argc = 1;
  v8::Local<v8::Value> argv[argc] = {info.Holder()};
  v8::Local<v8::Function> cons = Nan::New(VideoFrameSource::constructor);
  // 创建 VideoFrameSource对象
  info.GetReturnValue().Set(Nan::NewInstance(cons, 1, argv).ToLocalChecked());
}
2.1.2 =====NAN_METHOD(VideoFrameSource::New)

source/agent/webrtc/rtcFrame/VideoFrameConstructorWrapper.cc

NAN_METHOD(VideoFrameSource::New) {
  if (info.Length() == 1) {
    VideoFrameConstructor* parent = Nan::ObjectWrap::Unwrap<VideoFrameConstructor>(
      Nan::To<v8::Object>(info[0]).ToLocalChecked());
    VideoFrameSource* obj = new VideoFrameSource();
    // VideoFrameConstructor* parent 的 me 就是owt_base::VideoFrameConstructor
    // VideoFrameSource* obj  me 就是owt_base::VideoFrameConstructor
    obj->me = parent->me;
    // obj->src 就是owt_base::FrameSource        
    // owt_base::VideoFrameConstructor 继承了owt_base::FrameSource 
    obj->src = obj->me;
    obj->Wrap(info.This());
    info.GetReturnValue().Set(info.This());
  }
}
2.1.3 addon.VideoFrameSource

source/agent/webrtc/rtcFrame/VideoFrameConstructorWrapper.h

class VideoFrameSource : public FrameSource {
 public:
  static NAN_MODULE_INIT(Init);
  owt_base::VideoFrameConstructor* me;

 private:
  VideoFrameSource() {};
  ~VideoFrameSource() {};

  static NAN_METHOD(New);

  static Nan::Persistent<v8::Function> constructor;

  friend class VideoFrameConstructor;
};
2.1.4 addon.FrameSource

source/agent/addons/common/MediaFramePipelineWrapper.h

/*
 * Wrapper class of owt_base::FrameSource
 */
class FrameSource : public node::ObjectWrap{
public:

  owt_base::FrameSource* src;
};
2.1.5 owt_base::FrameSource
======sender.parent = parent;

sender 就是VideoFrameSource

parent 就是VideoFrameConstructor

2.2 InternalConnectionRouter.addLocalSource

dist-debug/webrtc_agent/webrtc/internalConnectionRouter.js

/*
   * @param {string} id ID for source connection (stream),publicTrackId
   * @param {string} type Type description for connection
   * @param {FrameSource} source Wrapper class for FrameSource
   */
    // id = publicTrackId = transportId + '-' + track.id;
    // type = 'webrtc', 
    // trackSource 就是2.1 创建的VideoFrameSource
  addLocalSource(id, type, source) {
    const isNativeSource = (type === 'quic' || type === 'mediabridge');
    // addon.InternalServer internalServer
    // 1. 
    this.internalServer.addSource(id, source, isNativeSource);
    // 2. Connections connnections 
    return this.connections.addConnection(id, type, '', source, 'in');
  }
2.2.1 internalServer 赋值const {InternalServer, InternalClient} = internalIO;

dist-debug/webrtc_agent/webrtc/internalConnectionRouter.js

source/agent/addons/internalIO/InternalServerWrapper.h

source/agent/addons/internalIO/InternalClientWrapper.h

2.2.2 NAN_METHOD(addSource)

source/agent/addons/internalIO/InternalServerWrapper.cc

NAN_METHOD(InternalServer::addSource) {
  InternalServer* obj = ObjectWrap::Unwrap<InternalServer>(info.Holder());
  owt_base::InternalServer* me = obj->me;

  Nan::Utf8String param0(Nan::To<v8::String>(info[0]).ToLocalChecked());
  // streamId = publicTrackId
  std::string streamId = std::string(*param0);

  bool isNanSource(false);
  if (info.Length() >= 3) {
      isNanSource = Nan::To<bool>(info[2]).FromJust();
  }

  owt_base::FrameSource* src(nullptr);
  if (isNanSource) {
      NanFrameNode* param = Nan::ObjectWrap::Unwrap<NanFrameNode>(
          Nan::To<v8::Object>(info[1]).ToLocalChecked());
      src = param->FrameSource();
  } else {
        // 走了这里流程，FrameSource 就是 2.1 创建的VideoFrameSource
      FrameSource* param = ObjectWrap::Unwrap<FrameSource>(
          Nan::To<v8::Object>(info[1]).ToLocalChecked());
      // 从FrameSource中获取owt_base::FrameSource  src
      src = param->src;
  }

  // owt_base::InternalServer::addSource
  me->addSource(streamId, src);
}
2.2.3 owt_base::InternalServer::addSource

source/core/owt_base/internal/InternalServer.cpp

// streamdId = publicTrackId
// source owt_base::FrameSource， 就是owt_base::VideoFrameConstructor
bool InternalServer::addSource(const std::string& streamId, FrameSource* src)
{
    ELOG_DEBUG("addSource %s, %p", streamId.c_str(), src);
    if (m_sourceMap.count(streamId)) {
        ELOG_WARN("Source for stream:%s already added", streamId.c_str());
        return false;
    }
    m_sourceMap[streamId] = src;
    return true;
}

owt.InternalServer - addSource 99649f7149c44673ad7c8338e1494c4f-0, 0x61c3d68
？？？？？ InternalServer::onSessionData

source/core/owt_base/internal/InternalServer.cpp

2.3.4 Connections.addConnection

dist-debug/webrtc_agent/webrtc/connections.js

// addConnection(id, type, '', source, 'in');

    // connectionId = id = publicTrackId
    // connectionType = type = 'webrtc'
    // connectionController = ''
    // conn = VideoFrameSource
    // direction = 'in'
that.addConnection =  function (connectionId, connectionType, connectionController, conn, direction) {
        log.debug('Add connection:', connectionId, connectionType, connectionController);
        if (connections[connectionId]) {
            log.error('Connection already exists:'+connectionId);
            return Promise.reject({type: 'failed', reason: 'Connection already exists:'+connectionId});
        }

        connections[connectionId] = {
            type: connectionType,
            direction: direction,
            audioFrom: undefined,
            videoFrom: undefined,
            connection: conn,
            controller: connectionController
        };

        return Promise.resolve('ok');
    };

这里存放在connections的数据包括VideoFrameSource，在linkupConnection 的时候调用

connections
/*{ConnectionID: {type: 'webrtc' | 'avstream' | 'recording' | 'internal',
                          direction: 'in' | 'out',
                          audioFrom: ConnectionID | undefined,
                          videoFrom: ConnectionID | undefined,
                          connnection: WebRtcConnection | InternalOut | RTSPConnectionOut
                         }
          }
        */
        connections = {};
log
2023-04-05T17:31:30.615  - DEBUG: Connections - Add connection: 99649f7149c44673ad7c8338e1494c4f-0 webrtc
log——conn
2023-04-26T21:23:41.396  - DEBUG: Connections - AudioFrameSource {
  parent: AudioFrameConstructor {},
  addDestination: [Function (anonymous)],
  removeDestination: [Function (anonymous)]
}

2023-04-26T21:23:41.399  - DEBUG: Connections - VideoFrameSource {
  parent: VideoFrameConstructor {},
  addDestination: [Function (anonymous)],
  removeDestination: [Function (anonymous)]
}

2.3 WebrtcNode.notifyMediaUpdate

从WrtcStream 注册回调到C++，然后C++回调到WrtcStream， 通过EventEmitter.emit 转发到WebrtcNode。

var notifyMediaUpdate = function (controller, publicTrackId, direction, mediaUpdate) {
        rpcClient.remoteCast(controller, 'onMediaUpdate', [publicTrackId, direction, mediaUpdate]);
       ...
    };
log
2023-04-26 21:54:07,908  - DEBUG: owt.VideoFrameConstructor - onVideoInfo {"video": {"parameters": {"resolution": {"width":0, "height":0}}}} 0x57708f0
2023-04-26T21:54:07.908  - INFO: WrtcConnection - _onMediaUpdate:{"video": {"parameters": {"resolution": {"width":0, "height":0}}}}
WrtcStream._onMediaUpdate

dist/webrtc_agent/webrtc/index.js

  _onMediaUpdate(jsonUpdate) {
    log.info('_onMediaUpdate:' + jsonUpdate);
    this.emit('media-update', jsonUpdate);
  }

dist/webrtc_agent/webrtc/wrtcConnection.js

WrtcStream
{
        this.videoFrameConstructor = new VideoFrameConstructor(
          this._onMediaUpdate.bind(this), video.transportcc, wrtc.callBase);
          ...
          }

source/agent/webrtc/rtcFrame/VideoFrameConstructorWrapper.cc

NAN_METHOD(VideoFrameConstructor::New) {
    .......
    // 第一个参数就是 this._onMediaUpdate.bind(this)， 
     obj->Callback_ = new Nan::Callback(info[0].As<Function>());
 ...
 }
NAUV_WORK_CB(VideoFrameConstructor::Callback)

source/agent/webrtc/rtcFrame/VideoFrameConstructorWrapper.cc

NAUV_WORK_CB(VideoFrameConstructor::Callback) {
  Nan::HandleScope scope;
  VideoFrameConstructor* obj = reinterpret_cast<VideoFrameConstructor*>(async->data);
  if (!obj || obj->me == NULL)
    return;
  boost::mutex::scoped_lock lock(obj->mutex);
  // for循环，从queue中读取消息，调用Callback_，回调到js的_onMediaUpdate
  while (!obj->videoInfoMsgs.empty()) {
    Local<Value> args[] = {Nan::New(obj->videoInfoMsgs.front().c_str()).ToLocalChecked()};
    obj->asyncResource_->runInAsyncScope(Nan::GetCurrentContext()->Global(), obj->Callback_->GetFunction(), 1, args);
    obj->videoInfoMsgs.pop();
  }
}
VideoFrameConstructor::onVideoInfo

source/agent/webrtc/rtcFrame/VideoFrameConstructorWrapper.cc

void VideoFrameConstructor::onVideoInfo(const std::string& message) {
  boost::mutex::scoped_lock lock(mutex);
  // std::queue<std::string> videoInfoMsgs;
  // 把回调的消息放到queue中，
  this->videoInfoMsgs.push(message);
  async_.data = this;
  uv_async_send(&async_);
}

2.4 WebrtcNode.notifyTrackUpdate

dist/webrtc_agent/webrtc/index.js

 /* updateInfo = {
     *  event: ('track-added' | 'track-removed' | 'track-updated'),
     *  trackId, mediaType, mediaFormat, active }
     */
        // controller 就是WebrtcNode.publish的时候options传递的controller
    var notifyTrackUpdate = function (controller, transportId, updateInfo) {
          // 广播消息
        rpcClient.remoteCast(controller, 'onTrackUpdate', [transportId, updateInfo]);
           ...
    };
log
WebrtcNode - notifyTrackUpdate conference-9534c64ba3c0a7727a84@192.168.221.62_0 99649f7149c44673ad7c8338e1494c4f-0 {
  type: 'track-added',
  trackId: '99649f7149c44673ad7c8338e1494c4f-0',
  mediaType: 'audio',
  mediaFormat: { codec: 'opus', sampleRate: 48000, channelNum: 2 },
  direction: 'in',
  operationId: '99649f7149c44673ad7c8338e1494c4f',
  mid: '0',
  rid: undefined,
  active: true

WebrtcNode - notifyTrackUpdate conference-9534c64ba3c0a7727a84@192.168.221.62_0 99649f7149c44673ad7c8338e1494c4f-1 {
  type: 'track-added',
  trackId: '99649f7149c44673ad7c8338e1494c4f-1',
  mediaType: 'video',
  mediaFormat: { codec: 'av1' },
  direction: 'in',
  operationId: '99649f7149c44673ad7c8338e1494c4f',
  mid: '1',
  rid: undefined,
  active: true
}
RpcClient.remoteCast

dist/webrtc_agent/amqpClient.js

  remoteCast(to, method, args) {
    const channel = this.bus.channel;
    if (this.ready && channel) {
      const content = JSON.stringify({
        method,
        args,
      });
      try {
        channel.publish(RPC_EXC.name, to, Buffer.from(content));
      } catch (e) {
        log.warn('Failed to publish:', e);
      }
    } else {
      this.ready = false;
    }
  }
Fisher3Star
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【sdp】例子：订阅者产生sdp offer和 被订阅者应答的answer
突围
06-17 86
sdp
owt-client-rtc:OWT-Client是基于Electron和OWT JavaScript SDK开发的视频会议客户端
05-05
OWT Client服务器程序使用的OWT-Server OWT-Client 是基于OWT、Electron开发的视频会议客户端，支持Windows、Linux、MacOS系统。特性PC多平台支持（Windows、Linux、MacOS）视频聊天文字聊天多摄像头支持桌面分享...
SDP的offer/answer模型
08-12
转载网络上的，由于http://blog.csdn.net/liaoxinmeng/article/details/6949351 无图不方便，找齐图片版的（但仍然感谢）。还有 http://blog.sina.com.cn/s/blog_6b10255301012kqs.html 感谢以上博客，还有其他相关博客。在此借花献佛了。
翻译-pjsip开发者指南（十一）SDP协商框架
chrycoder的博客
07-31 1444
Chapter 11:SDP Offer/Answer Framework SDP offer/answer框架是基于 RFC 3264 “An Offer/Answer Model with the Session Descriptor Protocol (SDP)”。主要的作用是加速本地和远端的媒体协商，并且在一方的邀请会话中协商一组媒体。 注意尽管这个通常用于邀请会话，这个框架本省是基于...
基于SDP的提议/应答（offer/answer）模型简介
学习是为了探索这个世界的本质
08-29 1518
1、引入 在松耦合会议中，会话参数完全由会议创建者来确定，参与者能做的仅仅是根据这些会话参数来加入会议（当然也可以选择不加入）。这种情况下，主要要做的就是会话描述，在这里SDP本身就足够了。 但是在更为普遍的两方会话的情况下，由于用户终端能力的差异，任何一方不能假设对方一定支持某种会话参数，所以必须双方协商来最终就会话的参数达成一致。显然，SDP能做到准确的描述会话的参数，但是它缺少双发如何根
pjsip如何发送媒体声音_完整SIP/SDP媒体协商概论-SDP协商模式详解-offer初始化流程...
weixin_39886469的博客
11-22 569
​当我们讨论SIP或者SDP的一些技术话题时，SDP的协商是一个绕不过的话题。具体的协商机制涉及了多个方面的内容。在我们的讨论中，笔者将会针对两个比较重要的话题进行讨论，一个是SDP offer/answer 模式，另外一个是在NAT场景中的SDP offer/answer交互模式拓展-ICE。在本章节中，我们将首先讨论SDP offer/answer交互模式，具体内容包括：offer/answe...
SIP中的SDP offer/answer交换初探
phymat.nico的专栏
12-14 3260
1.引言 SDP的offer/answer模型本身独立与于使用它的高层协议。SIP是使用offer/answer模型的应用之一。RFC 3264 [3] 定义了offer/answer模型，但没有规定使用那个SIP消息来携带一个offer或answer。这些被定义在SIP基本部分（RFC3261）及其扩展RFCs中。 理论上，任何SIP消息的正文中都可以包含会话描述部分。但是，一个SIP中的会
【owt】WebrtcNode, subscribe-sdp offer 流程(1)
06-04 720
sdp offer 的消息。
WebRTC SDP 详解和剖析
阿里云视频云的博客
11-24 1557
WebRTC 是 Web Real-Time Communication，即网页实时通信的缩写，是 RTC 协议的一种 Web 实现，项目由 Google 开源，并和 IETF 和 W3C 制定了行业标准。在国内 WebRTC 已经获得了越来越多厂商的支持，应用前景变得更加广阔，所以我们也开设专栏，分享阿里云内部的 WebRTC 研究工作。 本篇是阿里云视频云 WebRTC 技术专栏系列文章的第一篇，作者将从 WebRTC SDP 例子和关键属性的角度为大家深度剖析解读，其中也分享了阿里云技术专家的一些实践
SDP offer-answer协商原则
wangsiman的专栏
04-20 2667
规则1：初始Offer必须在INVITE消息或者第一个可靠的非失败型响应中。（理解：初始的Offer不能在Prack/Ack/Update中）规则2：如果初始Offer在INVITE消息中，Answer必须出现在一个可靠的非失败型响应中（补充：当可靠的1**响应和2**响应都携带了SDP，那么两者的SDP内容必须一致，且2**中的SDP被忽略）规则3：如果初始Offer出现在第一个可靠的非失败型响...
owt-client-[removed]打开WebRTC工具包JavaScript SDK
05-11
打开WebRTC工具包JavaScript SDK Open WebRTC Toolkit JavaScript SDK在W3C标准WebRTC API的基础上构建，以加快Web应用程序的实时通信（RTC）的开发，包括对等通信，广播和会议模式通信。如何构建发行包运行npm ...
owt-4.2-ubuntu-18.04.3.zip
12-24
OWT 4.2 ubuntu 18.04 预编译程序。
owt-server-master.zip
11-19
open-webrtc-toolkit /owt-server
owt-server-p2p:OWT的P2P服务器。 （又名PeerServer）
05-15
打开WebRTC Toolkit P2P服务器概述Open WebRTC Toolkit P2P服务器是Open WebRTC Toolkit的默认信令服务器。 它提供了在不同客户端之间通过Socket.IO交换WebRTC信令消息的功能。运行P2P服务器安装依赖项通过在P2P...
WebRTC音视频通话-WebRTC视频自定义RTCVideoCapturer相机
一名开发者
08-15 6525
WebRTC音视频通话-WebRTC视频自定义RTCVideoCapturer相机。主要获得相机采集的画面CVPixelBufferRef，将处理后的CVPixelBufferRef生成RTCVideoFrame，通过调用WebRTC的localVideoSource中实现的didCaptureVideoFrame方法
批量视频剪辑新选择：一键式按照指定秒数分割视频并轻松提取视频中的音频，让视频处理更高效！
最新发布
hlyling的博客
05-03 172
第二步，进入操作页面之后，先设置分割方式，有两种方式，第一种按每个视频随机或者平均进行分割成几段，第二种是按指定第几秒到第几秒来切，小编选择的是第二种方式，秒数按自己的需求进行设置。第三步，再去设置好音频的保留方式，同样有两种方法，第一种是保留视频片段里的音频，第二种是提取视频中的音频进行单独保存。第四步，设置完毕之后，就可以点击添加视频，将要进行分割的视频进行一一导入，支持批量导入多个视频来进行剪辑。第五步，记得设置好新视频的保存位置，点击浏览，在弹出来的文件夹里选择好一个新位置进行保存即可。
js 下载音频的实现方式
sinat_33255495的博客
04-28 333
通常下载文件我们会用到<a>标签，但是 a 标签在下载音频的时候会跳转到一个新页面进行播放，不会直接下载，这与我们的需求南辕北辙。这里我通过查询资料，找到了两种方式（原理想通，也可以理解为一种）：将文件转化为blob对象的二进制数据流下载。前提：这里我的音频文件是上传到腾讯云的，这里基于 腾讯云 的url进行下载。
关于逐帧读取视频，并且读取视频帧图片标注
xtpyc的博客
05-03 250
import cv2else:# 启动键盘监听器breakif points:breakmain()
数据处理——avi视频数据转png图片格式代码，mat转png图片格式代码，图片裁剪成固定大小代码。
Philo的博客
04-28 427
数据处理代码
owt-client-javascript
11-20
owt-client-javascript是一个基于WebRTC技术的JavaScript客户端库，用于实现实时音视频通讯功能。该库提供了一系列的API，使得开发者可以轻松地集成音视频通讯功能到他们的Web应用程序中。 owt-client-javascript...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值