—————————————————————————————————————————————-

一分钟快速搭建 rtmpd 服务器: https://blog.csdn.net/freeabc/article/details/102880984

软件下载地址: https://www.qiyicc.com/download/rtmpd.rar

github 地址：https://github.com/superconvert/smart_rtmpd

—————————————————————————————————————————————–

PeerConnectionFactory 的初始化流程分析

//——————————————————————————————–
// PeerConnectionFactory 的初始化流程分析
//——————————————————————————————–
1. 

 void CallActivity::onCreate(Bundle savedInstanceState) {     peerConnectionClient = new PeerConnectionClient(         getApplicationContext(),         eglBase,         roomUri.toString(),         peerConnectionParameters,         CallActivity.this);              peerConnectionClient.createPeerConnectionFactory(options); }

2.

 PeerConnectionClient::PeerConnectionClient(Context appContext, EglBase eglBase,     String roomServerUrl, PeerConnectionParameters peerConnectionParameters, PeerConnectionEvents events)     PeerConnectionFactory.initialize(         PeerConnectionFactory.InitializationOptions.builder(appContext)         .setFieldTrials(fieldTrials)         .setEnableInternalTracer(true)         .createInitializationOptions());                   void PeerConnectionFactory::initialize(InitializationOptions options) {     // 这个是加载 JNI 库，具体代码就不帖了     NativeLibrary.initialize(options.nativeLibraryLoader, options.nativeLibraryName);     nativeInitializeAndroidGlobals();     nativeInitializeFieldTrials(options.fieldTrials);     if (options.enableInternalTracer && !internalTracerInitialized) {         initializeInternalTracer();     }     if (options.loggable != null) {         Logging.injectLoggable(options.loggable, options.loggableSeverity);         nativeInjectLoggable(new JNILogging(options.loggable), options.loggableSeverity.ordinal());     } }

3.

 void PeerConnectionClient::createPeerConnectionFactory(PeerConnectionFactory.Options options) {     if (factory != null) {         throw new IllegalStateException("PeerConnectionFactory has already been constructed");     }     executor.execute(() -> createPeerConnectionFactoryInternal(options)); }  void PeerConnectionClient::createPeerConnectionFactoryInternal(PeerConnectionFactory.Options options) {     final VideoEncoderFactory encoderFactory;     final VideoDecoderFactory decoderFactory;      if (peerConnectionParameters.videoCodecHwAcceleration) {       encoderFactory = new DefaultVideoEncoderFactory(           rootEglBase.getEglBaseContext(), true /* enableIntelVp8Encoder */, enableH264HighProfile);       decoderFactory = new DefaultVideoDecoderFactory(rootEglBase.getEglBaseContext());     } else {       encoderFactory = new SoftwareVideoEncoderFactory();       decoderFactory = new SoftwareVideoDecoderFactory();     }     factory = PeerConnectionFactory.builder()         .setOptions(options)         .setAudioDeviceModule(adm)         .setVideoEncoderFactory(encoderFactory)         .setVideoDecoderFactory(decoderFactory)         .createPeerConnectionFactory(); }  PeerConnectionFactory PeerConnectionFactory::createPeerConnectionFactory() {     return nativeCreatePeerConnectionFactory(ContextUtils.getApplicationContext(), options,         audioDeviceModule.getNativeAudioDeviceModulePointer(),         audioEncoderFactoryFactory.createNativeAudioEncoderFactory(),         audioDecoderFactoryFactory.createNativeAudioDecoderFactory(), videoEncoderFactory,         videoDecoderFactory,         audioProcessingFactory == null ? 0 : audioProcessingFactory.createNative(),         fecControllerFactoryFactory == null ? 0 : fecControllerFactoryFactory.createNative(),         networkControllerFactoryFactory == null             ? 0 : networkControllerFactoryFactory.createNativeNetworkControllerFactory(),         networkStatePredictorFactoryFactory == null             ? 0 : networkStatePredictorFactoryFactory.createNativeNetworkStatePredictorFactory(),         mediaTransportFactoryFactory == null             ? 0 : mediaTransportFactoryFactory.createNativeMediaTransportFactory(),         neteqFactoryFactory == null ? 0 : neteqFactoryFactory.createNativeNetEqFactory()); }

 JNI_GENERATOR_EXPORT jobject     Java_org_webrtc_PeerConnectionFactory_nativeCreatePeerConnectionFactory(     JNIEnv* env,     jclass jcaller,     jobject context,     jobject options,     jlong nativeAudioDeviceModule,     jlong audioEncoderFactory,     jlong audioDecoderFactory,     jobject encoderFactory,     jobject decoderFactory,     jlong nativeAudioProcessor,     jlong nativeFecControllerFactory,     jlong nativeNetworkControllerFactory,     jlong nativeNetworkStatePredictorFactory,     jlong mediaTransportFactory,     jlong neteqFactory) {   return JNI_PeerConnectionFactory_CreatePeerConnectionFactory(env,       base::android::JavaParamRef<jobject>(env, context), base::android::JavaParamRef<jobject>(env,       options), nativeAudioDeviceModule, audioEncoderFactory, audioDecoderFactory,       base::android::JavaParamRef<jobject>(env, encoderFactory),       base::android::JavaParamRef<jobject>(env, decoderFactory), nativeAudioProcessor,       nativeFecControllerFactory, nativeNetworkControllerFactory,       nativeNetworkStatePredictorFactory, mediaTransportFactory, neteqFactory).Release(); }

./sdk/android/src/jni/pc/peer_connection_factory.cc

 static ScopedJavaLocalRef<jobject> JNI_PeerConnectionFactory_CreatePeerConnectionFactory(     JNIEnv* jni,     const JavaParamRef<jobject>& jcontext,     const JavaParamRef<jobject>& joptions,     jlong native_audio_device_module,     jlong native_audio_encoder_factory,     jlong native_audio_decoder_factory,     const JavaParamRef<jobject>& jencoder_factory,     const JavaParamRef<jobject>& jdecoder_factory,     jlong native_audio_processor,     jlong native_fec_controller_factory,     jlong native_network_controller_factory,     jlong native_network_state_predictor_factory,     jlong native_media_transport_factory,     jlong native_neteq_factory) {   rtc::scoped_refptr<AudioProcessing> audio_processor =       reinterpret_cast<AudioProcessing*>(native_audio_processor);   return CreatePeerConnectionFactoryForJava(       jni, jcontext, joptions,       reinterpret_cast<AudioDeviceModule*>(native_audio_device_module),       TakeOwnershipOfRefPtr<AudioEncoderFactory>(native_audio_encoder_factory),       TakeOwnershipOfRefPtr<AudioDecoderFactory>(native_audio_decoder_factory),       jencoder_factory, jdecoder_factory,       audio_processor ? audio_processor : CreateAudioProcessing(),       TakeOwnershipOfUniquePtr<FecControllerFactoryInterface>(           native_fec_controller_factory),       TakeOwnershipOfUniquePtr<NetworkControllerFactoryInterface>(           native_network_controller_factory),       TakeOwnershipOfUniquePtr<NetworkStatePredictorFactoryInterface>(           native_network_state_predictor_factory),       TakeOwnershipOfUniquePtr<MediaTransportFactory>(           native_media_transport_factory),       TakeOwnershipOfUniquePtr<NetEqFactory>(native_neteq_factory)); }

//———————————————————————————-
// 这个流程里，初始化很多有用的东西，有 socket server, 音视频编解码，fec 工厂，
// 任务队列等
//———————————————————————————-
./sdk/android/src/jni/pc/peer_connection_factory.cc

 ScopedJavaLocalRef<jobject> CreatePeerConnectionFactoryForJava(     JNIEnv* jni,     const JavaParamRef<jobject>& jcontext,     const JavaParamRef<jobject>& joptions,     rtc::scoped_refptr<AudioDeviceModule> audio_device_module,     rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,     rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory,     const JavaParamRef<jobject>& jencoder_factory,     const JavaParamRef<jobject>& jdecoder_factory,     rtc::scoped_refptr<AudioProcessing> audio_processor,     std::unique_ptr<FecControllerFactoryInterface> fec_controller_factory,     std::unique_ptr<NetworkControllerFactoryInterface>         network_controller_factory,     std::unique_ptr<NetworkStatePredictorFactoryInterface>         network_state_predictor_factory,     std::unique_ptr<MediaTransportFactory> media_transport_factory,     std::unique_ptr<NetEqFactory> neteq_factory) {   // talk/ assumes pretty widely that the current Thread is ThreadManager'd, but   // ThreadManager only WrapCurrentThread()s the thread where it is first   // created.  Since the semantics around when auto-wrapping happens in   // webrtc/rtc_base/ are convoluted, we simply wrap here to avoid having to   // think about ramifications of auto-wrapping there.   rtc::ThreadManager::Instance()->WrapCurrentThread();    //------------------------------------------   // 这个就是我们的 socket server 对象   //------------------------------------------   std::unique_ptr<rtc::Thread> network_thread = rtc::Thread::CreateWithSocketServer();   network_thread->SetName("network_thread", nullptr);   RTC_CHECK(network_thread->Start()) << "Failed to start thread";    std::unique_ptr<rtc::Thread> worker_thread = rtc::Thread::Create();   worker_thread->SetName("worker_thread", nullptr);   RTC_CHECK(worker_thread->Start()) << "Failed to start thread";    std::unique_ptr<rtc::Thread> signaling_thread = rtc::Thread::Create();   signaling_thread->SetName("signaling_thread", NULL);   RTC_CHECK(signaling_thread->Start()) << "Failed to start thread";    rtc::NetworkMonitorFactory* network_monitor_factory = nullptr;    //------------------------------------------   // 这个待分析。。。   //------------------------------------------   const absl::optional<PeerConnectionFactoryInterface::Options> options =       JavaToNativePeerConnectionFactoryOptions(jni, joptions);    // Do not create network_monitor_factory only if the options are   // provided and disable_network_monitor therein is set to true.   if (!(options && options->disable_network_monitor)) {     network_monitor_factory = new AndroidNetworkMonitorFactory();     rtc::NetworkMonitorFactory::SetFactory(network_monitor_factory);   }    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();   //------------------------------------------   // call 对象工厂   //------------------------------------------   dependencies.call_factory = CreateCallFactory();   dependencies.event_log_factory = std::make_unique<RtcEventLogFactory>(       dependencies.task_queue_factory.get());   //------------------------------------------   // fec 对象工厂   //------------------------------------------   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.media_transport_factory = std::move(media_transport_factory);   dependencies.neteq_factory = std::move(neteq_factory);    cricket::MediaEngineDependencies media_dependencies;   media_dependencies.task_queue_factory = dependencies.task_queue_factory.get();   media_dependencies.adm = std::move(audio_device_module);   //------------------------------------------   // Java 层已经创建过了音频编码工厂   //------------------------------------------   media_dependencies.audio_encoder_factory = std::move(audio_encoder_factory);   //------------------------------------------   // Java 层已经创建过了音频解码工厂   //------------------------------------------   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));    //------------------------------------------       // 创建 PeerConnectionFactory   //------------------------------------------   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory =       CreateModularPeerConnectionFactory(std::move(dependencies));    RTC_CHECK(factory) << "Failed to create the peer connection factory; "                      << "WebRTC/libjingle init likely failed on this device";   // TODO(honghaiz): Maybe put the options as the argument of   // CreatePeerConnectionFactory.   if (options)     factory->SetOptions(*options);    return NativeToScopedJavaPeerConnectionFactory(       jni, factory, std::move(network_thread), std::move(worker_thread),       std::move(signaling_thread), network_monitor_factory); }

上面的流程中，就有关相关的变量我们具体讲解一下

3.1 

network_thread  就是我们的 socket 类厂，并自带线程驱动机制，具体运作机制参考博文里的分析

https://blog.csdn.net/freeabc/article/details/106000923

3.2

CreateDefaultTaskQueueFactory 就是创建一个任务队列工厂， 这个根据操作系统类型，分为好几种

我们就以 std 的为例吧，其中我们的 pacer 发送队列用到的就是这个

./api/task_queue/default_task_queue_factory_stdlib.cc

 std::unique_ptr<TaskQueueFactory> CreateDefaultTaskQueueFactory() {   return CreateTaskQueueStdlibFactory(); }

./rtc_base/task_queue_stdlib.cc

 std::unique_ptr<TaskQueueFactory> CreateTaskQueueStdlibFactory() {   return std::make_unique<TaskQueueStdlibFactory>(); }

./rtc_base/task_queue_stdlib.cc

 class TaskQueueStdlibFactory final : public TaskQueueFactory {  public:   std::unique_ptr<TaskQueueBase, TaskQueueDeleter> CreateTaskQueue(       absl::string_view name,       Priority priority) const override {     return std::unique_ptr<TaskQueueBase, TaskQueueDeleter>(         new TaskQueueStdlib(name, TaskQueuePriorityToThreadPriority(priority)));   } };

3.3

CreateCallFactory 呼叫对象类厂分析

./call/call_factory.cc

 std::unique_ptr<CallFactoryInterface> CreateCallFactory() {   return std::unique_ptr<CallFactoryInterface>(new CallFactory()); }

后续具体创建一个 call 对象，其实就是调用的  Call::Create(config);

 Call* CallFactory::CreateCall(const Call::Config& config) {   absl::optional<webrtc::BuiltInNetworkBehaviorConfig> send_degradation_config =       ParseDegradationConfig(true);   absl::optional<webrtc::BuiltInNetworkBehaviorConfig>       receive_degradation_config = ParseDegradationConfig(false);    if (send_degradation_config || receive_degradation_config) {     return new DegradedCall(std::unique_ptr<Call>(Call::Create(config)),                             send_degradation_config, receive_degradation_config,                             config.task_queue_factory);   }    return Call::Create(config); }

3.4 创建视频编码器类厂 CreateVideoEncoderFactory

./sdk/android/src/jni/pc/video.cc

 VideoEncoderFactory* CreateVideoEncoderFactory(     JNIEnv* jni,     const JavaRef<jobject>& j_encoder_factory) {   return IsNull(jni, j_encoder_factory)              ? nullptr              : new VideoEncoderFactoryWrapper(jni, j_encoder_factory); }

./sdk/android/src/jni/video_encoder_factory_wrapper.cc

 VideoEncoderFactoryWrapper::VideoEncoderFactoryWrapper(     JNIEnv* jni,     const JavaRef<jobject>& encoder_factory)     : encoder_factory_(jni, encoder_factory) {   const ScopedJavaLocalRef<jobjectArray> j_supported_codecs =       Java_VideoEncoderFactory_getSupportedCodecs(jni, encoder_factory);   supported_formats_ = JavaToNativeVector<SdpVideoFormat>(       jni, j_supported_codecs, &VideoCodecInfoToSdpVideoFormat);   const ScopedJavaLocalRef<jobjectArray> j_implementations =       Java_VideoEncoderFactory_getImplementations(jni, encoder_factory);   implementations_ = JavaToNativeVector<SdpVideoFormat>(       jni, j_implementations, &VideoCodecInfoToSdpVideoFormat); }

创建视频编码器接口

 std::unique_ptr<VideoEncoder> VideoEncoderFactoryWrapper::CreateVideoEncoder(     const SdpVideoFormat& format) {   JNIEnv* jni = AttachCurrentThreadIfNeeded();   ScopedJavaLocalRef<jobject> j_codec_info =       SdpVideoFormatToVideoCodecInfo(jni, format);   ScopedJavaLocalRef<jobject> encoder = Java_VideoEncoderFactory_createEncoder(       jni, encoder_factory_, j_codec_info);   if (!encoder.obj())     return nullptr;   return JavaToNativeVideoEncoder(jni, encoder); }

3.5 创建解码器类厂  CreateVideoDecoderFactory

./sdk/android/src/jni/pc/video.cc

 VideoDecoderFactory* CreateVideoDecoderFactory(     JNIEnv* jni,     const JavaRef<jobject>& j_decoder_factory) {   return IsNull(jni, j_decoder_factory)              ? nullptr              : new VideoDecoderFactoryWrapper(jni, j_decoder_factory); }

./sdk/android/src/jni/video_decoder_factory_wrapper.cc

 VideoDecoderFactoryWrapper::VideoDecoderFactoryWrapper(     JNIEnv* jni,     const JavaRef<jobject>& decoder_factory)     : decoder_factory_(jni, decoder_factory) {}

创建解码器接口

 std::unique_ptr<VideoDecoder> VideoDecoderFactoryWrapper::CreateVideoDecoder(     const SdpVideoFormat& format) {   JNIEnv* jni = AttachCurrentThreadIfNeeded();   ScopedJavaLocalRef<jobject> j_codec_info =       SdpVideoFormatToVideoCodecInfo(jni, format);   ScopedJavaLocalRef<jobject> decoder = Java_VideoDecoderFactory_createDecoder(       jni, decoder_factory_, j_codec_info);   if (!decoder.obj())     return nullptr;     return JavaToNativeVideoDecoder(jni, decoder); }

3.6 媒体引擎类厂的创建 CreateMediaEngine

./media/engine/webrtc_media_engine.cc

 std::unique_ptr<MediaEngineInterface> CreateMediaEngine(     MediaEngineDependencies dependencies) {   auto audio_engine = std::make_unique<WebRtcVoiceEngine>(       dependencies.task_queue_factory, std::move(dependencies.adm),       std::move(dependencies.audio_encoder_factory),       std::move(dependencies.audio_decoder_factory),       std::move(dependencies.audio_mixer),       std::move(dependencies.audio_processing)); #ifdef HAVE_WEBRTC_VIDEO   auto video_engine = std::make_unique<WebRtcVideoEngine>(       std::move(dependencies.video_encoder_factory),       std::move(dependencies.video_decoder_factory)); #else   auto video_engine = std::make_unique<NullWebRtcVideoEngine>(); #endif   return std::make_unique<CompositeMediaEngine>(std::move(audio_engine),                                                 std::move(video_engine)); }

我们看到 media_engine 是 CompositeMediaEngine 对象， 主要包含 audio_engine 和 video_engine

audio_engine 包含音频的编码类厂，解码类厂，混音处理，声音处理

video_engine 包含视频的编码类厂，解码类厂

我们后续的代码中经常出现的 media_engine() 其实就是 CompositeMediaEngine 对象

media_engine()->voice() 和 media_engine()->video() 分别代表上面的 WebRtcVoiceEngine 和 WebRtcVideoEngine

4. 产生 PeerConnectionFactory 对象 CreateModularPeerConnectionFactory

 rtc::scoped_refptr<PeerConnectionFactoryInterface> CreateModularPeerConnectionFactory(     PeerConnectionFactoryDependencies dependencies) {   rtc::scoped_refptr<PeerConnectionFactory> pc_factory(       new rtc::RefCountedObject<PeerConnectionFactory>(           std::move(dependencies)));   // Call Initialize synchronously but make sure it is executed on   // |signaling_thread|.   MethodCall<PeerConnectionFactory, bool> call(       pc_factory.get(), &PeerConnectionFactory::Initialize);   bool result = call.Marshal(RTC_FROM_HERE, pc_factory->signaling_thread());    if (!result) {     return nullptr;   }   return PeerConnectionFactoryProxy::Create(pc_factory->signaling_thread(),                                             pc_factory); }

其实这个里面做了两件事， PeerConnectionFactory 构造与初始化

 PeerConnectionFactory::PeerConnectionFactory(     PeerConnectionFactoryDependencies dependencies)     : wraps_current_thread_(false),       network_thread_(dependencies.network_thread),       worker_thread_(dependencies.worker_thread),       signaling_thread_(dependencies.signaling_thread),       task_queue_factory_(std::move(dependencies.task_queue_factory)),       media_engine_(std::move(dependencies.media_engine)),       call_factory_(std::move(dependencies.call_factory)),       event_log_factory_(std::move(dependencies.event_log_factory)),       fec_controller_factory_(std::move(dependencies.fec_controller_factory)),       network_state_predictor_factory_(           std::move(dependencies.network_state_predictor_factory)),       injected_network_controller_factory_(           std::move(dependencies.network_controller_factory)),       media_transport_factory_(std::move(dependencies.media_transport_factory)),       neteq_factory_(std::move(dependencies.neteq_factory)),       trials_(dependencies.trials ? std::move(dependencies.trials)                                   : std::make_unique<FieldTrialBasedConfig>()) {   if (!network_thread_) {     owned_network_thread_ = rtc::Thread::CreateWithSocketServer();     owned_network_thread_->SetName("pc_network_thread", nullptr);     owned_network_thread_->Start();     network_thread_ = owned_network_thread_.get();   }    if (!worker_thread_) {     owned_worker_thread_ = rtc::Thread::Create();     owned_worker_thread_->SetName("pc_worker_thread", nullptr);     owned_worker_thread_->Start();     worker_thread_ = owned_worker_thread_.get();   }    if (!signaling_thread_) {     signaling_thread_ = rtc::Thread::Current();     if (!signaling_thread_) {       // If this thread isn't already wrapped by an rtc::Thread, create a       // wrapper and own it in this class.       signaling_thread_ = rtc::ThreadManager::Instance()->WrapCurrentThread();       wraps_current_thread_ = true;     }   } }

 bool PeerConnectionFactory::Initialize() {   RTC_DCHECK(signaling_thread_->IsCurrent());   rtc::InitRandom(rtc::Time32());    default_network_manager_.reset(new rtc::BasicNetworkManager());   if (!default_network_manager_) {     return false;   }    default_socket_factory_.reset(       new rtc::BasicPacketSocketFactory(network_thread_));   if (!default_socket_factory_) {     return false;   }    channel_manager_ = std::make_unique<cricket::ChannelManager>(       std::move(media_engine_), std::make_unique<cricket::RtpDataEngine>(),       worker_thread_, network_thread_);    channel_manager_->SetVideoRtxEnabled(true);   if (!channel_manager_->Init()) {     return false;   }    return true; }

初始化接口里很重要，这里面产生 default_network_manager_( 网络管理 )， default_socket_factory_（socket 类厂 ), 

channel_manager_（通道管理）

default_network_manager_ : 主要是网络类型，网络地址等信息的管理

default_socket_factory_ ： 我们用到的 socket 的通讯都是通过它进行创建的

channel_manager_ :  呼叫通道管理，包含媒体引擎 media_engine 和 data_engine

./pc/channel_manager.cc

 ChannelManager::ChannelManager(     std::unique_ptr<MediaEngineInterface> media_engine,     std::unique_ptr<DataEngineInterface> data_engine,     rtc::Thread* worker_thread,     rtc::Thread* network_thread)     : media_engine_(std::move(media_engine)),       data_engine_(std::move(data_engine)),       main_thread_(rtc::Thread::Current()),       worker_thread_(worker_thread),       network_thread_(network_thread) {   RTC_DCHECK(data_engine_);   RTC_DCHECK(worker_thread_);   RTC_DCHECK(network_thread_); }

通道管理最重要的作用是为一路呼叫创建 VoiceChannel (同时创建 VoiceMediaChannel) 和 

VideoChannel (同时创建 VideoMediaChannel）。

下面以 VideoChannel 为例，讲一下，这个里面包含什么对象：

VideoChannel 包含发送参数，接收参数，VideoMediaChannel ( WebRtcVideoChannel ), 带宽估算信息，

本地流参数，远端流参数，以及 rtp_transport_ ( P2PTransportChannel 传输相关的处理 )

VideoMediaChannel 其实就是 WebRtcVideoChannel 对象，这个里面包含了，发送流对象，接收流对象，编码类厂，

解码类厂， 码率分配类厂， 发送 rtp 扩展，接收 rtp 扩展， 发送状态统计，接收状态统计，带宽估算统计，发送和接收的

编码信息统计等诸多信息，  是个需要关注的重点类！！！！！！

./media/engine/webrtc_video_engine.h

 WebRtcVideoChannel::WebRtcVideoChannel(     webrtc::Call* call,     const MediaConfig& config,     const VideoOptions& options,     const webrtc::CryptoOptions& crypto_options,     webrtc::VideoEncoderFactory* encoder_factory,     webrtc::VideoDecoderFactory* decoder_factory,     webrtc::VideoBitrateAllocatorFactory* bitrate_allocator_factory)     : VideoMediaChannel(config),       worker_thread_(rtc::Thread::Current()),       call_(call),       unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),       video_config_(config.video),       encoder_factory_(encoder_factory),       decoder_factory_(decoder_factory),       bitrate_allocator_factory_(bitrate_allocator_factory),       default_send_options_(options),       last_stats_log_ms_(-1),       discard_unknown_ssrc_packets_(webrtc::field_trial::IsEnabled(           "WebRTC-Video-DiscardPacketsWithUnknownSsrc")),       crypto_options_(crypto_options),       unknown_ssrc_packet_buffer_(           webrtc::field_trial::IsEnabled(               "WebRTC-Video-BufferPacketsWithUnknownSsrc")               ? new UnhandledPacketsBuffer()               : nullptr) {   RTC_DCHECK(thread_checker_.IsCurrent());    rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;   sending_ = false;   recv_codecs_ =       MapCodecs(AssignPayloadTypesAndDefaultCodecs(encoder_factory_));   recv_flexfec_payload_type_ = recv_codecs_.front().flexfec_payload_type; }

一个  WebRtcVideoChannel 包含多个发送对象 （ WebRtcVideoSendStream ） 和接收对象 （ WebRtcVideoReceiveStream ）

这两个对象也非常关键，需要重点分析这些类，才能更好的理解 webrtc 的运作机制， 其实就是封装了整个视频的

发送 pipeline ( capture —> encoder —-> pacer —-> socket )

 WebRtcVideoChannel::WebRtcVideoSendStream::WebRtcVideoSendStream(     webrtc::Call* call,     const StreamParams& sp,     webrtc::VideoSendStream::Config config,     const VideoOptions& options,     bool enable_cpu_overuse_detection,     int max_bitrate_bps,     const absl::optional<VideoCodecSettings>& codec_settings,     const absl::optional<std::vector<webrtc::RtpExtension>>& rtp_extensions,     // TODO(deadbeef): Don't duplicate information between send_params,     // rtp_extensions, options, etc.     const VideoSendParameters& send_params)     : worker_thread_(rtc::Thread::Current()),       ssrcs_(sp.ssrcs),       ssrc_groups_(sp.ssrc_groups),       call_(call),       enable_cpu_overuse_detection_(enable_cpu_overuse_detection),       source_(nullptr),       stream_(nullptr),       encoder_sink_(nullptr),       parameters_(std::move(config), options, max_bitrate_bps, codec_settings),       rtp_parameters_(CreateRtpParametersWithEncodings(sp)),       sending_(false) {   // Maximum packet size may come in RtpConfig from external transport, for   // example from QuicTransportInterface implementation, so do not exceed   // given max_packet_size.   parameters_.config.rtp.max_packet_size =       std::min<size_t>(parameters_.config.rtp.max_packet_size, kVideoMtu);   parameters_.conference_mode = send_params.conference_mode;    sp.GetPrimarySsrcs(&parameters_.config.rtp.ssrcs);    // ValidateStreamParams should prevent this from happening.   RTC_CHECK(!parameters_.config.rtp.ssrcs.empty());   rtp_parameters_.encodings[0].ssrc = parameters_.config.rtp.ssrcs[0];    // RTX.   sp.GetFidSsrcs(parameters_.config.rtp.ssrcs,                  &parameters_.config.rtp.rtx.ssrcs);    // FlexFEC SSRCs.   // TODO(brandtr): This code needs to be generalized when we add support for   // multistream protection.   if (IsFlexfecFieldTrialEnabled()) {     uint32_t flexfec_ssrc;     bool flexfec_enabled = false;     for (uint32_t primary_ssrc : parameters_.config.rtp.ssrcs) {       if (sp.GetFecFrSsrc(primary_ssrc, &flexfec_ssrc)) {         if (flexfec_enabled) {           RTC_LOG(LS_INFO)               << "Multiple FlexFEC streams in local SDP, but "                  "our implementation only supports a single FlexFEC "                  "stream. Will not enable FlexFEC for proposed "                  "stream with SSRC: "               << flexfec_ssrc << ".";           continue;         }          flexfec_enabled = true;         parameters_.config.rtp.flexfec.ssrc = flexfec_ssrc;         parameters_.config.rtp.flexfec.protected_media_ssrcs = {primary_ssrc};       }     }   }    parameters_.config.rtp.c_name = sp.cname;   if (rtp_extensions) {     parameters_.config.rtp.extensions = *rtp_extensions;     rtp_parameters_.header_extensions = *rtp_extensions;   }   parameters_.config.rtp.rtcp_mode = send_params.rtcp.reduced_size                                          ? webrtc::RtcpMode::kReducedSize                                          : webrtc::RtcpMode::kCompound;   parameters_.config.rtp.mid = send_params.mid;   rtp_parameters_.rtcp.reduced_size = send_params.rtcp.reduced_size;    if (codec_settings) {     SetCodec(*codec_settings);   } }

接收 pipeline ( socket —> jitterbuffer —> decoder —> render )

 WebRtcVideoChannel::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(     WebRtcVideoChannel* channel,     webrtc::Call* call,     const StreamParams& sp,     webrtc::VideoReceiveStream::Config config,     webrtc::VideoDecoderFactory* decoder_factory,     bool default_stream,     const std::vector<VideoCodecSettings>& recv_codecs,     const webrtc::FlexfecReceiveStream::Config& flexfec_config)     : channel_(channel),       call_(call),       stream_params_(sp),       stream_(NULL),       default_stream_(default_stream),       config_(std::move(config)),       flexfec_config_(flexfec_config),       flexfec_stream_(nullptr),       decoder_factory_(decoder_factory),       sink_(NULL),       first_frame_timestamp_(-1),       estimated_remote_start_ntp_time_ms_(0) {   config_.renderer = this;   ConfigureCodecs(recv_codecs);   ConfigureFlexfecCodec(flexfec_config.payload_type);   MaybeRecreateWebRtcFlexfecStream();   RecreateWebRtcVideoStream(); }

有关 WebRTC 的更多知识可以参考我的其它的博客