(Android-RTC-9)PeerConnectionFactory

news2024/10/7 12:28:57

开篇前瞎扯。很久没发技术文章了，此文一直放着草稿箱没有完成，感觉自己在家庭和工作中找到了拖延的借口，开始慢慢变得懒惰了，那是万万不行的。恰逢2023开年ChatGPT的爆火，更让我这些普通程序员危机感瞬间飙升，无限感受到自己的知识储备已经跟不上时代的节奏了。所以还是继续学习吧，活到老学到老。


还记得系列开篇的这张流程分析图嚒，不知不觉已经基本分析全了PeerConnectionFactory之上的内容。有兴趣需要补课的同学follow这个专栏。

现在把目光回归到PeerConnectionFactory这个关键节点，拆解中心环节继续向深进发。

从java层接口出发，很容易就找到源码.\sdk\android\src\jni\pc\peer_connection_factory.cc文件中的函数JNI_PeerConnectionFactory_CreatePeerConnectionFactory，最终调用CreatePeerConnectionFactoryForJava，一起看看代码内容。

// .\sdk\android\src\jni\pc\peer_connection_factory.cc文件中的
// 函数JNI_PeerConnectionFactory_CreatePeerConnectionFactory -> CreatePeerConnectionFactoryForJava
//为了节省篇幅，函数内部很多RTC_CHECK省去了。  
ScopedJavaLocalRef<jobject> CreatePeerConnectionFactoryForJava(
    JNIEnv* jni,
    const JavaParamRef<jobject>& jcontext,
    const JavaParamRef<jobject>& joptions,
	// 节省篇幅，入参列表简化如下。
	// |audio_device_module|, |jencoder_factory|, |jdecoder_factory|,
	// |audio_processor|, |fec_controller_factory|,
	// |network_state_predictor_factory|, |neteq_factory|.) {

  // 1、创建三类工作线程，
  std::unique_ptr<rtc::Thread> network_thread =
      rtc::Thread::CreateWithSocketServer();
  network_thread->SetName("network_thread", nullptr);

  std::unique_ptr<rtc::Thread> worker_thread = rtc::Thread::Create();
  worker_thread->SetName("worker_thread", nullptr);

  std::unique_ptr<rtc::Thread> signaling_thread = rtc::Thread::Create();
  signaling_thread->SetName("signaling_thread", NULL);

  const absl::optional<PeerConnectionFactoryInterface::Options> options =
      JavaToNativePeerConnectionFactoryOptions(jni, joptions);

  // 2、创建PeerConnectionFactoryDependencies 
  PeerConnectionFactoryDependencies dependencies;
  dependencies.network_thread = network_thread.get();
  dependencies.worker_thread = worker_thread.get();
  dependencies.signaling_thread = signaling_thread.get();
  dependencies.task_queue_factory = CreateDefaultTaskQueueFactory();
  dependencies.call_factory = CreateCallFactory();
  dependencies.event_log_factory = std::make_unique<RtcEventLogFactory>(
      dependencies.task_queue_factory.get());
  dependencies.fec_controller_factory = std::move(fec_controller_factory);
  dependencies.network_controller_factory =
      std::move(network_controller_factory);
  dependencies.network_state_predictor_factory =
      std::move(network_state_predictor_factory);
  dependencies.neteq_factory = std::move(neteq_factory);
  if (!(options && options->disable_network_monitor)) {
    dependencies.network_monitor_factory =
        std::make_unique<AndroidNetworkMonitorFactory>();
  }
  // 3、创建PeerConnectionFactoryDependencies所需的MediaEngineDependencies 
  cricket::MediaEngineDependencies media_dependencies;
  media_dependencies.task_queue_factory = dependencies.task_queue_factory.get();
  media_dependencies.adm = std::move(audio_device_module);
  media_dependencies.audio_encoder_factory = std::move(audio_encoder_factory);
  media_dependencies.audio_decoder_factory = std::move(audio_decoder_factory);
  media_dependencies.audio_processing = std::move(audio_processor);
  media_dependencies.video_encoder_factory =
      absl::WrapUnique(CreateVideoEncoderFactory(jni, jencoder_factory));
  media_dependencies.video_decoder_factory =
      absl::WrapUnique(CreateVideoDecoderFactory(jni, jdecoder_factory));
  dependencies.media_engine =
      cricket::CreateMediaEngine(std::move(media_dependencies));

  // 4、通过PeerConnectionFactoryDependencies创建CreateModularPeerConnectionFactory
  rtc::scoped_refptr<PeerConnectionFactoryInterface> factory =
      CreateModularPeerConnectionFactory(std::move(dependencies));

  if (options)
    factory->SetOptions(*options);

  return NativeToScopedJavaPeerConnectionFactory(
      jni, factory, std::move(network_thread), std::move(worker_thread),
      std::move(signaling_thread));
}

函数内容有点多，不过总结起来其实就几个部分，

1、创建三类内部组件，network_thread/worker_thread/signaling_thread，虽然他们都是rtc::Thread，虽然命名是线程，但其实不是我们所了解的线程，反而有点类似Android Handler，包含着消息队列和内部执行循环。

2、创建PeerConnectionFactoryDependencies，其中需要关注几个关键量 call_factory（p2p链接） / fec_controller_factory（丢包纠错） / network_state_predictor_factory（网络带宽预测）/ media_dependencies（媒体相关） 以上几个都是webrtc的重点难点，都是需要开坑逐一分析学习。

3、创建PeerConnectionFactoryDependencies所依赖的MediaEngineDependencies，MediaEngineDependencies的入参就是之前分析过的几个video/audio-encoder/decoder factory

4、最后就是根据PeerConnectionFactoryDependencies，创建集大成的PeerConnectionFactory。

一图概述就是这样：

继续往下看看CreateModularPeerConnectionFactory的内容

rtc::scoped_refptr<PeerConnectionFactoryInterface>
CreateModularPeerConnectionFactory(
    PeerConnectionFactoryDependencies dependencies) {
  // The PeerConnectionFactory must be created on the signaling thread.
  if (dependencies.signaling_thread &&
      !dependencies.signaling_thread->IsCurrent()) {
    return dependencies.signaling_thread
        ->Invoke<rtc::scoped_refptr<PeerConnectionFactoryInterface>>(
            RTC_FROM_HERE, [&dependencies] {
              return CreateModularPeerConnectionFactory(
                  std::move(dependencies));
            });
  }

  auto pc_factory = PeerConnectionFactory::Create(std::move(dependencies));
  if (!pc_factory) {
    return nullptr;
  }
  // Verify that the invocation and the initialization ended up agreeing on the
  // thread.
  RTC_DCHECK_RUN_ON(pc_factory->signaling_thread());
  return PeerConnectionFactoryProxy::Create(
      pc_factory->signaling_thread(), pc_factory->worker_thread(), pc_factory);
}

// Static
rtc::scoped_refptr<PeerConnectionFactory> PeerConnectionFactory::Create(
    PeerConnectionFactoryDependencies dependencies) {
  auto context = ConnectionContext::Create(&dependencies);
  if (!context) {
    return nullptr;
  }
  return rtc::make_ref_counted<PeerConnectionFactory>(context, &dependencies);
}

其中PeerConnectionFactory::Create就是真正创建PeerConnectionFactory的地方，其中还包含了一个ConnectionContext的创建，还有一个比较难明白的地方就是CreateModularPeerConnectionFactory函数的返回，PeerConnectionFactoryProxy，为啥不直接使用PeerConnectionFactory？

而且，用普通的阅读器是跟踪不到具体的实现文件。我是用VSCode带C++插件的才能跟踪到，跟踪进去会发现这是一个完全由宏定义去生成的代理类。大家有空可以自己去观摩，我这里就不贴代码了，位置在.\api\peer_connection_factory_proxy.h。

接下来直接看看PeerConnectionFactory的头定义，先大致了解其结构组成部分。

class PeerConnectionFactory : public PeerConnectionFactoryInterface {
 public:
  void SetOptions(const Options& options) override;

  RTCErrorOr<rtc::scoped_refptr<PeerConnectionInterface>>
  CreatePeerConnectionOrError(
      const PeerConnectionInterface::RTCConfiguration& configuration,
      PeerConnectionDependencies dependencies) override;

  RtpCapabilities GetRtpSenderCapabilities(
      cricket::MediaType kind) const override;

  RtpCapabilities GetRtpReceiverCapabilities(
      cricket::MediaType kind) const override;

  rtc::scoped_refptr<MediaStreamInterface> CreateLocalMediaStream(
      const std::string& stream_id) override;

  rtc::scoped_refptr<AudioSourceInterface> CreateAudioSource(
      const cricket::AudioOptions& options) override;

  rtc::scoped_refptr<VideoTrackInterface> CreateVideoTrack(
      const std::string& id,
      VideoTrackSourceInterface* video_source) override;

  rtc::scoped_refptr<AudioTrackInterface> CreateAudioTrack(
      const std::string& id,
      AudioSourceInterface* audio_source) override;

  bool StartAecDump(FILE* file, int64_t max_size_bytes) override;
  void StopAecDump() override;

  SctpTransportFactoryInterface* sctp_transport_factory() {
    return context_->sctp_transport_factory();
  }

  virtual cricket::ChannelManager* channel_manager();

  rtc::Thread* signaling_thread() const {
    // This method can be called on a different thread when the factory is
    // created in CreatePeerConnectionFactory().
    return context_->signaling_thread();
  }

  rtc::Thread* worker_thread() const { return context_->worker_thread(); }

  const Options& options() const {
    RTC_DCHECK_RUN_ON(signaling_thread());
    return options_;
  }

  const WebRtcKeyValueConfig& trials() const { return context_->trials(); }

 protected:
  virtual ~PeerConnectionFactory();

 private:
  rtc::Thread* network_thread() const { return context_->network_thread(); }

  bool IsTrialEnabled(absl::string_view key) const;
  const cricket::ChannelManager* channel_manager() const {
    return context_->channel_manager();
  }

  std::unique_ptr<RtcEventLog> CreateRtcEventLog_w();
  std::unique_ptr<Call> CreateCall_w(RtcEventLog* event_log);

  rtc::scoped_refptr<ConnectionContext> context_;
  PeerConnectionFactoryInterface::Options options_
      RTC_GUARDED_BY(signaling_thread());
  std::unique_ptr<TaskQueueFactory> task_queue_factory_;
  std::unique_ptr<RtcEventLogFactoryInterface> event_log_factory_;
  std::unique_ptr<FecControllerFactoryInterface> fec_controller_factory_;
  std::unique_ptr<NetworkStatePredictorFactoryInterface>
      network_state_predictor_factory_;
  std::unique_ptr<NetworkControllerFactoryInterface>
      injected_network_controller_factory_;
  std::unique_ptr<NetEqFactory> neteq_factory_;
};

功能性方法先不急着深入，先大致拆分结构性组成部分。

1、CreatePeerConnectionOrError公开方法和CreateCall_w私有方法，应该和创建PeerConnection有着密切联系。这个留着下一篇文件 创建PeerConnection分析。

2、结合CreateModularPeerConnectionFactory方法和PeerConnectionFactory的头定义文件，大致可以看出ConnectionContext也是一个很重要的组成部分。

3、ChannelManager也是一个独立的组成部分。

其他也没啥了，接着在快速看看ConeectionContext的结构组成。

// This class contains resources needed by PeerConnection and associated
// objects. A reference to this object is passed to each PeerConnection. The
// methods on this object are assumed not to change the state in any way that
// interferes with the operation of other PeerConnections.
//
// This class must be created and destroyed on the signaling thread.
class ConnectionContext final
    : public rtc::RefCountedNonVirtual<ConnectionContext> {
 public:
  // Creates a ConnectionContext. May return null if initialization fails.
  // The Dependencies class allows simple management of all new dependencies
  // being added to the ConnectionContext.
  static rtc::scoped_refptr<ConnectionContext> Create(
      PeerConnectionFactoryDependencies* dependencies);

  // This class is not copyable or movable.
  ConnectionContext(const ConnectionContext&) = delete;
  ConnectionContext& operator=(const ConnectionContext&) = delete;

  // Functions called from PeerConnection and friends
  SctpTransportFactoryInterface* sctp_transport_factory() const {
    return sctp_factory_.get();
  }

  cricket::ChannelManager* channel_manager() const;

  rtc::Thread* signaling_thread() { return signaling_thread_; }
  const rtc::Thread* signaling_thread() const { return signaling_thread_; }
  rtc::Thread* worker_thread() { return worker_thread_; }
  const rtc::Thread* worker_thread() const { return worker_thread_; }
  rtc::Thread* network_thread() { return network_thread_; }
  const rtc::Thread* network_thread() const { return network_thread_; }

  const WebRtcKeyValueConfig& trials() const { return *trials_.get(); }

  // Accessors only used from the PeerConnectionFactory class
  rtc::BasicNetworkManager* default_network_manager() {
    RTC_DCHECK_RUN_ON(signaling_thread_);
    return default_network_manager_.get();
  }
  rtc::BasicPacketSocketFactory* default_socket_factory() {
    RTC_DCHECK_RUN_ON(signaling_thread_);
    return default_socket_factory_.get();
  }
  CallFactoryInterface* call_factory() {
    RTC_DCHECK_RUN_ON(worker_thread_);
    return call_factory_.get();
  }

 private:

  rtc::Thread* const network_thread_;
  rtc::Thread* const worker_thread_;
  rtc::Thread* const signaling_thread_;
  // channel_manager is accessed both on signaling thread and worker thread.
  std::unique_ptr<cricket::ChannelManager> channel_manager_;
  std::unique_ptr<rtc::NetworkMonitorFactory> const network_monitor_factory_
      RTC_GUARDED_BY(signaling_thread_);
  std::unique_ptr<rtc::BasicNetworkManager> default_network_manager_
      RTC_GUARDED_BY(signaling_thread_);
  std::unique_ptr<webrtc::CallFactoryInterface> const call_factory_
      RTC_GUARDED_BY(worker_thread_);

  std::unique_ptr<rtc::BasicPacketSocketFactory> default_socket_factory_
      RTC_GUARDED_BY(signaling_thread_);
  std::unique_ptr<SctpTransportFactoryInterface> const sctp_factory_;
  // Accessed both on signaling thread and worker thread.
  std::unique_ptr<WebRtcKeyValueConfig> const trials_;
};

有备注看备注，翻译过来的意思：ConnectionContext此类包含PeerConnection和关联对象所需的资源。该对象的引用将传递给每个PeerConnection。且ConnectionContext此对象上的方法不会干扰其他操作的方式 去更改其PeerConnection对象的任何状态。

看方法可以知道PeerConnectionFactory很多方法是直接引用ConnectionContext的，甚至channel_manager / sctp_transport_factory / call_factory 也是直接引用ConnectionContext对象。

重要组成部分：ChannelManager、SctpTransportFactory、BasicNetworkManager、BasicPacketSocketFactory、CallFactory。一图总结概述（和上图的总结不冲突哈，其他更应该把这两图结合一起看。）

本篇主要介绍了PeerConnectionFactory的整体结构组成，简单揭开了其真正的面纱和其背后隐藏起来的关键部分（ConnectionContext）。之后会通过CreatePeerConnection-PeerConnection功能去继续分析WebRTC的整体脉络，力求全面、清晰、深入浅出。

That is all.

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/390668.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

安全规约第一章

安全规约第一章

文章目录传统密码和现代密码的区别古典密码近代密码现代密码定义模型证明现代密码学CryptographyCryptanalysisCryptosystemScheme如何定义算法步骤第一步&#xff0c;搞清楚安全服务目标第二步&#xff0c;计算过程中需要几方的参与需要几个算法描述它算法命名谁来运行哪一个算…
阅读更多...
03_Apache Pulsar的Local与分布式集群构建、Pulsar的分布式集群模式、Pulsar的分布式集群模式构建\启动\测试

03_Apache Pulsar的Local与分布式集群构建、Pulsar的分布式集群模式、Pulsar的分布式集群模式构建\启动\测试

1.3.Apache Pulsar的Local与分布式集群构建 1.3.1 Apache Pulsar的Local模式构建 1.3.1.1.Apache Pulsar的Local模式基本使用 1.3.2.Apache Pulsar的分布式集群模式 1.3.2.1.安装zookeeper集群 1.3.3.Apache Pulsar的分布式集群模式构建 1.3.4.Apache Pulsar的分布式集群模式启…
阅读更多...
Sparx Systems Pro Cloud Server crack

Sparx Systems Pro Cloud Server crack

Sparx Systems Pro Cloud Server crack 云服务器 添加了新的“OSLC会话超时”设置&#xff0c;以配置OSLC用户将注销的最长非活动时间。 改进了对重复SQL列名的处理。 FLS&#xff1a;为“组”添加了对其他Microsoft Active Directory名称格式的支持。 云配置客户端 在扩展服务…
阅读更多...
香橙派5使用NPU加速yolov5的实时视频推理（二）

香橙派5使用NPU加速yolov5的实时视频推理（二）

三、将best.onnx转为RKNN格式 这一步就需要我们进入到Ubuntu20.04系统中了&#xff0c;我的Ubuntu系统中已经下载好了anaconda&#xff0c;使用anaconda的好处就是可以方便的安装一些库&#xff0c;而且还可以利用conda来配置虚拟环境&#xff0c;做到环境与环境之间相互独立。…
阅读更多...
SpringCloud Alibaba入门

SpringCloud Alibaba入门

作为微服务刚入门的小白&#xff0c;不足之处请多多指教 1. Cloud Alibaba简介2.Nacos简介和下载3.Nacos安装4.Nacos之服务提供者注册5.Nacos之服务消费者注册和负载6.Nacos服务注册中心对比提升7.Nacos之服务配置中心8.Nacos之命名空间分组和DataID三者关系9.Nacos之DataID配…
阅读更多...
如何写好单测

如何写好单测

1、为什么要写单测&#xff1f; 单测即单元测试&#xff08;Unit Test&#xff09;&#xff0c;是对软件的基本组成单元进行的测试&#xff0c;比如函数、过程或者类的方法。其意义是&#xff1a; 功能自测&#xff0c;发现功能缺陷自我Code Review测试驱动开发促进代码重构并…
阅读更多...
File、递归、IO流(一)、IO流（二）

File、递归、IO流(一)、IO流（二）

目录 ​File类概述 File类的常用API 判断文件类型、获取文件信息 创建文件、删除文件功能 遍历文件夹 方法递归 递归的形式和特点 递归的算法流程、核心要素 递归常见案例 递归的经典问题 非规律化递归案例-文件搜索 非规律化递归案例-啤酒问题 字符集 常见字符集…
阅读更多...
美团二面经历——如何设计一个百万人抽奖系统？

美团二面经历——如何设计一个百万人抽奖系统？

文章目录 导图V0——单体架构V1——负载均衡V2——服务限流防止用户重复抽奖拦截无效流量服务降级和服务熔断V3 同步状态V4线程优化V5业务逻辑V6流量削峰通用思路单一职责URL动态加密静态资源——CDN服务限流数据预热削峰填谷导图 导图按照由浅入深的方式进行讲解，架构从来不是…
阅读更多...
西电计算机组成原理（计组）核心考点汇总（期末真题+核心考点）

西电计算机组成原理（计组）核心考点汇总（期末真题+核心考点）

文章目录前言一、真题概览1.1 计组1历年真题1.2 计组2历年真题二、知识点说明2.1 计组12.1.1 冯诺依曼计算机组成和特点2.1.2 复杂指令系统计算机和特点2.1.3 精简指令系统计算机的特点2.1.4 指令长度的影响因素2.1.5 控制器2.1.6 微指令特性2.2 计组22.2.1 SMP特点与优点2.2.2…
阅读更多...
QML动态对象管理

QML动态对象管理

QML中有多种方式来动态创建和管理QML对象&#xff1a; Loader &#xff08;加载器&#xff09;Repeater&#xff08;复制器&#xff09;ListView&#xff0c;GridWiew&#xff0c;PethView&#xff08;视图&#xff09; &#xff08;之后会介绍&#xff09;使用加载器&#xff…
阅读更多...
剖析G1 垃圾回收器

剖析G1 垃圾回收器

简单回顾 在Java当中&#xff0c;程序员在编写代码的时候只需要创建对象&#xff0c;从来不需要考虑将对象进行释放&#xff0c;这是因为Java中对象的垃圾回收全部由JVM替你完成了(所有的岁月静好都不过是有人替你负重前行)。 而JVM的垃圾回收由垃圾回收器来负责&#xff0c;在…
阅读更多...
刷题记录:牛客NC200179Colorful Tree 奇奇怪怪的dfs序

刷题记录:牛客NC200179Colorful Tree 奇奇怪怪的dfs序

传送门:牛客 题目描述: A tree structure with some colors associated with its vertices and a sequence of commands on it are given. A command is either an update operation or a query on the tree. Each of the update operations changes the color of a specifi…
阅读更多...
论文阅读 - End-to-End Wireframe Parsing

论文阅读 - End-to-End Wireframe Parsing

文章目录1 概述2 L-CNN2.1 整体架构2.2 backbone2.3 juction proposal module2.4 line sample module2.5 line verificatoin module3 评价指标参考资料1 概述 本文是ICCV2019的一篇论文&#xff0c;核心是提出了一种简单的end-to-end的two-stage的检测图像中线段的方法。同时&…
阅读更多...
192、【动态规划】leetcode ——64. 最小路径和：回溯法+动态规划（C++版本）

192、【动态规划】leetcode ——64. 最小路径和：回溯法+动态规划（C++版本）

题目描述 原题链接&#xff1a;64. 最小路径和 解题思路 &#xff08;1&#xff09;回溯法 分别向右或下进行探查 class Solution { public:int res INT_MAX;void backtracking(vector<vector<int>>& grid, int x, int y, int pathSum) {// 超出边界&…
阅读更多...
高可用 - 08 Keepalived集群中Master和Backup角色选举策略

高可用 - 08 Keepalived集群中Master和Backup角色选举策略

文章目录概述实例说明“weight”值为正数“weight”值为负数总结概述 在Keepalived集群中&#xff0c;其实并没有严格意义上的主、备节点&#xff0c;虽然可以在Keepalived配置文件中设置“state”选项为“MASTER”状态&#xff0c;但是这并不意味着此节点一直就是Master角色。…
阅读更多...
Python实现人脸识别，进行视频跟踪打码，羞羞的画面统统打上马赛克

Python实现人脸识别，进行视频跟踪打码，羞羞的画面统统打上马赛克

哈喽兄弟们&#xff0c;我是轻松~ 今天我们来实现用Python自动对视频打马赛克前言准备工作代码实战效果展示最后前言 事情是这样的&#xff0c;昨天去表弟家&#xff0c;用了下他的电脑&#xff0c;不小心点到了他硬盘里隐藏的秘密&#xff0c;本来我只需要用几分钟电脑的&…
阅读更多...
第一章初识Linux

第一章初识Linux

文章目录Linux简介LInux的应用领域Linux OS和各种发行版的关系Linux和Unix的关系Linux相关环境配置图解VM和Linux的关系Linux自定义分三个区VMware网络连接的三种模式桥接模式NAT模式主机模式VMware快照功能Linux的操作方式Linux的目录结构各种Linux发行版本的常见目录注意事项…
阅读更多...
GO进阶(5) 垃圾回收机制

GO进阶(5) 垃圾回收机制

一、前言 1、垃圾回收背景 编程语言通常会使用手动和自动两种方式管理内存&#xff0c;C、C 以及 Rust 等编程语言使用手动的方式管理内存&#xff0c;工程师需要主动申请或者释放内存&#xff1b;而 Python、Ruby、Java 和 Go 等语言使用自动的内存管理系统&#xff0c;一般都…
阅读更多...
Java八股——wait、sleep与park

Java八股——wait、sleep与park

sleep()、wait()、park()都可以使线程进入等待状态&#xff0c;但是3种方式在使用上和功能上都有些不同。 共同点: wait()&#xff0c;wait(long)和sleep(long)的效果都是让当前线程暂时放弃CPU的使用权&#xff0c;进入阻塞状态它们都可以被打断唤醒都是native方法执行sleep…
阅读更多...
java四种线程池（基本使用）

java四种线程池（基本使用）

标题java四种线程池及使用示例 1、线程工厂 1、我们先来写ThreadFactory&#xff0c;在创建线程池时候可以传入自定义的线程工厂&#xff0c;线程工厂说白了就是用来定制线程的一些属性&#xff1a;名字、优先级、是否为守护线程。直接看代码即可。 当然创建线程池的时候可以…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023