WebRTC源码分析之配置信息-FlagList

最新推荐文章于 2023-03-09 20:51:08 发布
最新推荐文章于 2023-03-09 20:51:08 发布
阅读量308 收藏
点赞数
分类专栏： WebRTC源码分析 文章标签： webrtc c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qiuguolu1108/article/details/114796226
版权

文章目录


FlagList是一个全局链表，用于保存所有的标记，这些标记一般都是WebRTC的配置信息。标记都有两个值，一个是默认值，另一个是可变值。默认值是定义时赋给的，而可变值是通过命令行解析的。 FlagList::SetFlagsFromCommandLine用于解析命令行中与标记相关的参数，方便了命令行参数的处理。

FlagList使用示例
工程

示例工程：https://pan.baidu.com/s/1rbI2hwXpMA-Pb-i-zCdVWA 提取码：cenz

示例-定义标记
#define WEBRTC_POSIX

#include <iostream>
#include "flags.h"

using namespace std;

WEBRTC_DEFINE_string(name, "zhangsan", "this is name");
WEBRTC_DEFINE_bool(sex, true, "zhangsan is man");
WEBRTC_DEFINE_int(id, 1001, "zhangsan's id is 1001");
WEBRTC_DEFINE_float(score, 99.0, "I got a hundred in the maths examination");

int main()
{
	cout << "name  = " << FLAG_name << endl;
	cout << "sex   = " << (FLAG_sex ? "man" : "woman") << endl;
	cout << "id    = " << FLAG_id << endl;
	cout << "score = " << FLAG_score << endl;
	
    return 0;
}

在这里插入图片描述
通过定义标记，使用标记。注意标记需要定义在全局。

示例-标记的额外信息
#define WEBRTC_POSIX

#include <iostream>
#include "flags.h"

using namespace std;

WEBRTC_DEFINE_string(name, "zhangsan", "this is name");
WEBRTC_DEFINE_bool(sex, true, "zhangsan is man");
WEBRTC_DEFINE_int(id, 1001, "zhangsan's id is 1001");
WEBRTC_DEFINE_float(score, 100.0, "I got a hundred in the maths examination");

int main()
{
	cout << "name  = " << FLAG_name << endl;
	
	cout <<"current value = "<< *Flag_name.string_variable() << endl;
	cout <<"default value = "<< Flag_name.string_default() << endl;
	cout <<"comment = "<< Flag_name.comment() << endl;
	cout <<"file    = "<< Flag_name.file() << endl;
	
    return 0;
}

在这里插入图片描述
在定义FLAG_name时，同时会定义Flag_name对象。Flag_name对象中包含更多的信息，解析命令行中name参数后，会把结果放在Flag_name对象中。

示例-显示所有的标记

flag_defs.h

#ifndef __FLAG_DEFS_H__
#define __FLAG_DEFS_H__

WEBRTC_DEFINE_float(salary,10000,"zhangsan's salary is 10000");
WEBRTC_DEFINE_string(title,"teacher","zhangsan is a teacher");

#endif

main.cc

#define WEBRTC_POSIX

#include <iostream>
#include "flags.h"
#include "flag_defs.h"

using namespace std;
using namespace rtc;

WEBRTC_DEFINE_string(name, "zhangsan", "this is name");
WEBRTC_DEFINE_bool(sex, true, "zhangsan is man");
WEBRTC_DEFINE_int(id, 1001, "zhangsan's id is 1001");
WEBRTC_DEFINE_float(score, 100.0, "I got a hundred in the maths examination");

int main()
{
	FlagList::Print(nullptr,true); 
	
	return 0;
}

在这里插入图片描述
将所有文件中定义的标记全部打印出来，打印标记时，会按照文件分类打印。

示例-显示指定文件中的标记
#define WEBRTC_POSIX

#include <iostream>
#include "flags.h"
#include "flag_defs.h"

using namespace std;
using namespace rtc;

WEBRTC_DEFINE_string(name, "zhangsan", "this is name");
WEBRTC_DEFINE_bool(sex, true, "zhangsan is man");
WEBRTC_DEFINE_int(id, 1001, "zhangsan's id is 1001");
WEBRTC_DEFINE_float(score, 100.0, "I got a hundred in the maths examination");

int main()
{
	FlagList::Print("flag_defs.h",false); 
	
	return 0;
}

在这里插入图片描述
打印指定文件中的标记，传入false表示只打印标记的默认值。

示例-解析命令行参数
#define WEBRTC_POSIX

#include <iostream>
#include "flags.h"

using namespace std;
using namespace rtc;

WEBRTC_DEFINE_string(name, "zhangsan", "this is name");
WEBRTC_DEFINE_bool(sex, true, "zhangsan is man");
WEBRTC_DEFINE_int(id, 1001, "zhangsan's id is 1001");
WEBRTC_DEFINE_float(score, 100.0, "I got a hundred in the maths examination");

int main(int argc,char ** argv)
{
	/*解析命令行*/
	FlagList::SetFlagsFromCommandLine(&argc,argv,true);	
	
	FlagList::Print(nullptr,true);
    
    /*获取命令行中的值*/
    FLAG_name = *Flag_name.string_variable();
		
	cout<<endl<<"name = "<<FLAG_name<<endl;
		
	return 0;
}

在这里插入图片描述
解析命令行参数，更新标记的值。

示例-解析命令行参数并删除命令行中的标记
#define WEBRTC_POSIX

#include <iostream>
#include "flags.h"

using namespace std;
using namespace rtc;

WEBRTC_DEFINE_string(name, "zhangsan", "this is name");
WEBRTC_DEFINE_bool(sex, true, "zhangsan is man");
WEBRTC_DEFINE_int(id, 1001, "zhangsan's id is 1001");
WEBRTC_DEFINE_float(score, 100.0, "I got a hundred in the maths examination");

int main(int argc,char ** argv)
{
	int i = 0;

    /*打印命令行参数*/
	while(i<argc)
    {		
    	cout<<"argv["<<i<<"] = "<<argv[i]<<endl;
		i++;
    }

	cout<<endl;

	/*true:表示删除命令行中已解析的参数*/
	FlagList::SetFlagsFromCommandLine(&argc,argv,true);	
	
	FlagList::Print(nullptr,true);
   
	cout<<endl;
 
	i = 0;
    
     /*打印命令行参数*/
	while(i<argc)
    {		
    	cout<<"argv["<<i<<"] = "<<argv[i]<<endl;
		i++;
    }

	return 0;
}

在这里插入图片描述

SetFlagsFromCommandLine()函数传入true，表示删除命令行中已经解析的参数。

FlagList源码分析

所有的源码都在：src\rtc_base\flags.h flags.cc

没定义一个标记，都会生成一个Flag对象，其值存储在内部的FlagValue内，所有的Flag对象由一个全局的链表FlagList管理。

FlagValue类
union FlagValue 
{
  /*静态的用于生成存储bool类型的对象*/
  static FlagValue New_BOOL(int b) 
  {
    FlagValue v;
    v.b = (b != 0);
    return v;
  }
  static FlagValue New_INT(int i) 
  {
    FlagValue v;
    v.i = i;
    return v;
  }
  static FlagValue New_FLOAT(float f) 
  {
    FlagValue v;
    v.f = f;
    return v;
  }
  static FlagValue New_STRING(const char* s) 
  {
    FlagValue v;
    v.s = s;
    return v;
  }

  bool b;
  int i;
  double f;
  const char* s;
};

FlagValue是个联合体，只能存放bool、int、float、char*类型，这也决定了标记也只能定义成这四种类型。每种类型都提供了对应的静态成员函数，用于生成对应类型的联合体。

Flag类
const char* file_;       /*标记所在的文件名*/
const char* name_;       /*标记的文件名*/
const char* comment_;    /*标记的注释*/

Type type_;              /*标记的类型*/
FlagValue* variable_;    /*标记的实际值*/
FlagValue default_;      /*标记的默认值*/

Flag* next_;     /*指向链表中下一个标记*/

所有的标记会组成一条链表，每个标记都是链表中的一个结点，所以需要有指针指向下一个结点。

Flag::Flag(const char* file,const char* name,const char* comment,Type type,void* variable,FlagValue default__)
    : file_(file),name_(name),comment_(comment),type_(type),variable_(reinterpret_cast<FlagValue*>(variable)),default_(default__) 
{
  FlagList::Register(this);   /*添加到链表上*/
}

定义标记时，会生成Flag对象，标记的很多额外的信息都被存储在这里，包括标记被定义的文件名、标记的名称、注释、实际值、默认值。

在生成Flag对象时，会将本对象添加到全局的链表上。

const char* file() const { return file_; }
const char* name() const { return name_; }
const char* comment() const { return comment_; }
Type type() const { return type_; }    /*返回标记的类型*/
Flag* next() const { return next_; }

用于返回相应的信息

bool* bool_variable() const
{
	RTC_DCHECK_EQ(BOOL, type_);
	return &variable_->b;
}
int* int_variable() const
{
	RTC_DCHECK_EQ(INT, type_);
	return &variable_->i;
}
double* float_variable() const
{
	RTC_DCHECK_EQ(FLOAT, type_);
	return &variable_->f;
}
const char** string_variable() const
{
	RTC_DCHECK_EQ(STRING, type_);
	return &variable_->s;
}

用于返回标记的实际值。返回底层对象指针的原因是，既可以获取实际值，也可以更改实际值，这一点和默认值不同。

bool bool_default() const 
{
	RTC_DCHECK_EQ(BOOL, type_);
	return default_.b;
}
int int_default() const 
{
	RTC_DCHECK_EQ(INT, type_);
	return default_.i;
}
double float_default() const 
{
	RTC_DCHECK_EQ(FLOAT, type_);
	return default_.f;
}
const char* string_default() const
{
	RTC_DCHECK_EQ(STRING, type_);
	return default_.s;
}

用于返回标记的默认值

void Flag::SetToDefault() 
{
  switch (type_) 
  {
    case Flag::BOOL:
      variable_->b = default_.b;
      return;
    case Flag::INT:
      variable_->i = default_.i;
      return;
    case Flag::FLOAT:
      variable_->f = default_.f;
      return;
    case Flag::STRING:
      variable_->s = default_.s;
      return;
  }

  FATAL() << "unreachable code";      /*断言失败，结束进行。*/
}

将标记的实际值设置成默认值

/*类型字符串化*/
static const char* Type2String(Flag::Type type) 
{
  switch (type) 
  {
    case Flag::BOOL:
      return "bool";
    case Flag::INT:
      return "int";
    case Flag::FLOAT:
      return "float";
    case Flag::STRING:
      return "string";
  }

  FATAL() << "unreachable code";
}

/*打印标记值*/
static void PrintFlagValue(Flag::Type type, FlagValue* p) 
{
  switch (type) 
  {
    case Flag::BOOL:
      printf("%s", (p->b ? "true" : "false"));
      return;
    case Flag::INT:
      printf("%d", p->i);
      return;
    case Flag::FLOAT:
      printf("%f", p->f);
      return;
    case Flag::STRING:
      printf("%s", p->s);
      return;
  }

  FATAL() << "unreachable code";
}

/*打印标记*/
void Flag::Print(bool print_current_value) 
{
  printf("  --%s (%s)  type: %s  default: ", name_, comment_,Type2String(type_));

  PrintFlagValue(type_, &default_);

  /*控制是否打印当前值*/
  if (print_current_value) 
  {
    printf("  current value: ");
    PrintFlagValue(type_, variable_);
  }

  printf("\n");
}

打印标记的值，传入的参数决定是否打印标记的实际值。

FlagList类
class FlagList 
{
 public:
	FlagList();
	static Flag* list() { return list_; }
	static void Print(const char* file, bool print_current_value);
	static Flag* Lookup(const char* name);
    
	static void SplitArgument(const char* arg,char* buffer,int buffer_size,const char** name,const char** value,bool* is_bool);
	static int SetFlagsFromCommandLine(int* argc,const char** argv,bool remove_flags);
    
	static inline int SetFlagsFromCommandLine(int* argc,char** argv,bool remove_flags) 
	{
		return SetFlagsFromCommandLine(argc, const_cast<const char**>(argv),remove_flags);   /*参数发生强转*/
	}
    
	static void Register(Flag* flag);

 private:
  static Flag* list_;
};

FlagList类的成员是静态的，相当于一个全局变量。特别是list_也是静态数据成员，相当于一个全局的链表。

void FlagList::Print(const char* file, bool print_current_value) 
{
  const char* current = nullptr;

  /*遍历链表*/
  for (Flag* f = list_; f != nullptr; f = f->next()) 
  {
    if (file == nullptr || file == f->file()) 
    {
      /*只打印一次*/
      if (current != f->file()) 
      {
        printf("Flags from %s:\n", f->file());
        current = f->file();
      }

      f->Print(print_current_value);
    }
  }
}

打印指定文件中的标记，参数file为nullptr则打印所有文件中的标记。print_current_value用于指示是否打印标记的实际值。

/*判断两个字符串是否相等*/
bool FlagEq(const char* arg, const char* flag) 
{
  /*两个字符串中，-字符和_字符是相等的。*/
  while (*arg != '\0' && (*arg == *flag || (*arg == '-' && *flag == '_'))) 
  {
    ++arg;
    ++flag;
  }

  return *arg == '\0' && *flag == '\0';
}

Flag* FlagList::Lookup(const char* name) 
{
  Flag* f = list_;
  
  /*遍历链表，查找指定节点。*/
  while (f != nullptr && !FlagEq(name, f->name()))
    f = f->next();

  return f;
}

根据标记的名称查找链表中结点。

void FlagList::Register(Flag* flag) 
{
  RTC_DCHECK(flag);
  RTC_DCHECK_GT(strlen(flag->name()), 0);

  flag->next_ = list_;   /*链表的头插法*/
  list_ = flag;
}

采用头插法，将标记结点插入到链表中。

/*分割参数*/
void FlagList::SplitArgument(const char* arg,char* buffer,int buffer_size,const char** name,const char** value,bool* is_bool) 
{
  *name = nullptr;
  *value = nullptr;
  *is_bool = false;

  if (*arg == '-')   
  {
    arg++;                    /*去掉第一个-*/
    if (*arg == '-')          /*若有第二个-，也去掉。*/
      arg++;

    /*参数以no开头，且参数在FlagList中可以查找到。*/
    if (arg[0] == 'n' && arg[1] == 'o' && Lookup(arg + 2)) 
    {
      arg += 2;  /*去掉no*/
      *is_bool = true;
    }

    *name = arg;  /*指向参数*/

    while (*arg != '\0' && *arg != '=')
      arg++;
      
    if (*arg == '=') 
    {
      int n = static_cast<int>(arg - *name);
      RTC_CHECK_LT(n, buffer_size);
      memcpy(buffer, *name, n * sizeof(char));
      buffer[n] = '\0';
      *name = buffer;
      *value = arg + 1;
    }
  }
}

/*解析命令行参数*/
int FlagList::SetFlagsFromCommandLine(int* argc,const char** argv,bool remove_flags) 
{
  for (int i = 1; i < *argc; /* see below */) 
  {
    int j = i; 
    const char* arg = argv[i++];

    char buffer[1024];
    const char* name;
    const char* value;
    bool is_bool;
    SplitArgument(arg, buffer, sizeof buffer, &name, &value, &is_bool);

    if (name != nullptr)     /*有参数时*/
    {
      Flag* flag = Lookup(name);   /*查找参数是否在FlagList中*/
      if (flag == nullptr) 
      {
        fprintf(stderr, "Error: unrecognized flag %s\n", arg);
        return j;   /*返回第几个参数错误*/
      }

      if (flag->type() != Flag::BOOL && value == nullptr) 
      {
        if (i < *argc)         /*后面还有一个参数*/
        {
          /*将下一个参数作为其值，在命令行中，=和空格是一样的。*/
          value = argv[i++];   
        } 
        else 
        {
          fprintf(stderr, "Error: missing value for flag %s of type %s\n", arg,Type2String(flag->type()));
          return j;
        }
      }

      char empty[] = {'\0'};
      char* endp = empty;
      switch (flag->type())     /*更新配置的值*/
      {
        case Flag::BOOL:
          /*取值正好相反，no时is_bool为true。*/
          *flag->bool_variable() = !is_bool;  
          break;
        case Flag::INT:
          *flag->int_variable() = strtol(value, &endp, 10);
          break;
        case Flag::FLOAT:
          *flag->float_variable() = strtod(value, &endp);
          break;
        case Flag::STRING:
          *flag->string_variable() = value;
          break;
      }

      /* 处理错误*/
      if ((flag->type() == Flag::BOOL && value != nullptr) || (flag->type() != Flag::BOOL && is_bool) || *endp != '\0') 
      {
        fprintf(stderr, "Error: illegal value for flag %s of type %s\n", arg,Type2String(flag->type()));
        return j;
      }

      if (remove_flags)           /*删除命令行参数*/
        while (j < i)
          argv[j++] = nullptr;    /*将处理过的参数置为NULL*/
    }
  }

  if (remove_flags) 
  {
    int j = 1;
    for (int i = 1; i < *argc; i++) 
    {
      if (argv[i] != nullptr)   /*删除为NULL的参数*/
        argv[j++] = argv[i];    /*将后面的参数前移*/
    }

    *argc = j;  /*更新参数的个数*/
  }

  return 0;
}

解析命令行参数，若参数中有和标记值相同的，则从命令行中取值更新标记。参数remove_flags为true时，命令行中解析过的参数会从命令行参数中删除。

WEBRTC_DEFINE_string宏函数
宏函数原型
#define WEBRTC_DEFINE_string(name, default, comment) \
  WEBRTC_DEFINE_FLAG(STRING, const char*, name, default, comment)

#define WEBRTC_DEFINE_FLAG(type, c_type, name, default, comment)     \
  c_type FLAG_##name = (default);                                    \
  static rtc::Flag Flag_##name(__FILE__, #name, (comment),           \
  rtc::Flag::type,&FLAG_##name,                                      \
  rtc::FlagValue::New_##type(default))
宏函数的使用
WEBRTC_DEFINE_string(title, "teacher", "zhangsan is a teacher");

将宏展开后：

const char* FLAG_title = ("teacher");
static rtc::Flag Flag_title(__FILE__,title, ("zhangsan is a teacher"),rtc::Flag::STRING,&FLAG_title,rtc::FlagValue::New_STRING("teacher"));

去掉命名空间，简化后：

const char* FLAG_title = ("teacher");
static Flag Flag_title(__FILE__,title, ("zhangsan is a teacher"),Flag::STRING,&FLAG_title,FlagValue::New_STRING("teacher"));

这个宏函数定义了两个变量，这个宏一般在全局使用，定义的变量也是全局变量，其中Flag_title是静态的，所以其作用域是文件内部。

WEBRTC_DECLARE_string宏函数
宏函数原型
#define WEBRTC_DECLARE_string(name)       \
  WEBRTC_DECLARE_FLAG(const char*, name)

#define WEBRTC_DECLARE_FLAG(c_type, name) \
  extern c_type FLAG_##name
宏函数的使用
WEBRTC_DECLARE_string(title)

将宏展开后：

extern const char* FLAG_title

这个宏函数用于全局变量跨文件声明

小结

本文介绍了如何使用标记和如何解析命令行参数。

玩转流媒体
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
webrtc-streamer-v0.8.1-dirty-Windows-AMD64-Release.zip
01-26
webrtc-streamer-v0.8.1-dirty-Windows-AMD64-Release.zip
webrtc-streamer0.7的ubuntu18.04版本
11-08
webrtc-streamer在国内编译相当困难，这里是本人花了一周时间编译完成的webrtc-streamer最新版本，可在ubuntu18.04及以上版本中使用，如果提示libstdc++版本过低，请升级系统的libstdc++。
ubuntu 18.04 Build WebRTC
m0_59561186的博客
01-12 170
时隔两年多，现在又要搞 webrtc 了，翻出了原来写的文档按照流程操作，发现已经不能正常进行下去了，折腾了一番以后，重新记录下 Linux 下编译 webrtc 遇到的一些坑。
资讯｜WebRTC M90 更新
netease_im的博客
04-28 455
WebRTC M90目前已在Chrome测试版中发布，包含2个新特性和超过29个bug修复，以及功能增强、稳定性与性能等方面的改进。欢迎关注网易云信公众号，我们将定期翻译WebRTC相关内...
gcc编译选项-Wextra（启用额外的警告信息，提高代码质量和安全性）
Dontla的博客
02-28 2016
是 GCC 和 Clang 编译器的警告选项之一，用于启用额外的警告信息，提高代码质量和安全性。
WebRTC源码分析-线程基础之线程管理
ice_ly000的博客
11-08 2208
前言 WebRTC中的线程管理是通过ThreadManager对象来实施的，该类起着牧羊者的作用，rtc::Thread类对象就是羊群。其通过什么样的技术来实现对rtc::Thread管理的？在不同的系统平台下如何实现？下文将进行阐述。 该类的声明和定义与Thread类一样，位于rtc_base目录下的thread.h与thread.cc文件中。先看其类的声明： class Thread...
WebRTC线程介绍
椛茶的博客
02-08 1846
WebRTC 有三类线程：信令线程，网络线程，工作线程。信令线程一般工作在 PeerConnection 层，它负责与应用层交互，例如 createOffer，createAnswer 等操作，并通知工作线程和网络线程相应的信号事件。网络线程工作在网络传输层，它负责网络收发包，从网络接收包数据并发送给工作线程，工作线程也会把要发送的包数据给网络线程。工作线程工作在媒体引擎层（engine），包含视频采集线程，视频渲染线程，视频编码线程，视频解码线程等。
webrtc-streamer
04-18
vue2、vue3播放rtsp视频流
Pion WebRTC是WebRTC的纯Go实现。-Golang开发
05-26
Pion WebRTC是WebRTC的纯Go实现。 它具有零个非Go依赖关系，并且没有第3方Go依赖关系。 它旨在遵循WebRTC API，但在需要时可能会有所不同。...example-webrtc-applications包含更多功能齐全的示例，这些示例
react-native-webrtc：用于React Native的WebRTC模块
02-05
react-native-webrtc 用于React Native的WebRTC模块。 支持iOS / macOS / Android。 支持视频/音频/数据通道。 世博用户注意：除非您弹出该插件，否则它将不起作用。社区欢迎每个人加入我们的，讨论与React Native和...
ubuntu 20.4编译成功的webrtc库，m101版本
03-31
1. lib 2. include 3. VERSION -m101.4951 4. libwebrtc-linux-x64-h264.tar.xz
webrtc aec3
08-14
基于最新webrtc人工抽离出来的aec demo。 与平台抽离，可直接在Linux下编译。 mkdir build cd build cmake ../src; make -j; only aec: ./bin/demo aec + aes + cng(comfort noise generate): ./bin/echo_remover_demo 转载请注明出处: https://blog.csdn.net/ChallengerRumble
谷歌webrtc移植嵌入式平台记录
m0_46411607的博客
03-09 790
如果要使用其他环境则改 --arch= 可以使用的有’arm’, ‘arm64’, ‘i386’, ‘amd64’, ‘mips’, ‘mips64el’2、配置开发板的交叉编译工具链的位置 并写入环境变量，配置完在终端输入arm- 按TAB键有出现arm-linux-gnueabihf- 表示配置成功。rtc_include_tests=false //是否包含测试文件，默认是包含的，最好加上这个选项 = false，否则文件太大。将编译出来的.o文件收集到一个文件中，进入该文件夹中。
C 语言中的一些技巧
ZachZheng的专栏
08-26 152
文章目录指定初始化利用预处理进行编译断言宏列表 指定初始化 除了我们常用的静态初始化数组： int fibs[] = {1， 1， 2， 3， 5}； C99 标准支持一种更为直观的方式来初始化：结构体、联合体、数组； 初始化数组 当我们需要根据一组 #define 来保持某种映射关系的同步更新时，我们可以如此初始化数组： // 一组错误码的定义 #define EINVAL 1 #def...
WebRTC源码分析之锁-CriticalSection
专注音视频基础、WebRTC、ffmpeg、流媒体服务器
03-14 777
文章目录CriticalSection使用示例工程不加锁加锁-使用pthread库中的互斥锁加锁-使用CriticalSection加锁-使用CritScope加锁-使用GlobalLockCriticalSection源码分析CriticalSection类类的声明构造器和析构器CurrentThreadIsOwner函数Enter函数TryEnter函数Leave函数CritScope类类的声明构造器和析构器TryCritScope类GlobalLockPod类GlobalLock类GlobalLock
webrtc 视频编码格式及参数配置
fanhenghui的专栏
11-23 7102
https://blog.csdn.net/CrystalShaw/article/details/80372015 一、视频编码格式初始配置 webrtc\media\engine\internalencoderfactory.cc 按照Push顺序，优先选取第一个编解码格式。   二、视频分辨率初始配置 webrtc\pc\videocapturertracksource.cc 选...
webrtc编译
sun007700的专栏
09-21 387
WebRTC Android版本编译 https://www.cnblogs.com/Hi-blog/p/11311141.html webrtc编译调试 https://blog.csdn.net/zhuiyuanqingya/article/details/81449982
WebRTC源码分析之日志-RTC_LOG
专注音视频基础、WebRTC、ffmpeg、流媒体服务器
03-14 2841
文章目录RTC_LOG使用示例示例-日志输出到标准错误stderr示例-带有时间和线程信息的日志示例-日志输入到文件示例-带有错误信息的日志RTC_LOG源码分析LogMessage类数据成员构造器析构器更新最小日志级别配置数据获取数据添加、删除文件流Log函数LogCall类LogStreamer类RTC_LOG宏函数宏函数原型宏函数的使用RTC_LOG_ERRNO宏函数宏函数原型宏函数的使用LogSink类FileRotatingLogSink类CallSessionFileRotatingLogSin
WebRTC源码分析之智能指针-scoped_refptr
专注音视频基础、WebRTC、ffmpeg、流媒体服务器
03-13 2364
文章目录scoped_refptr使用示例工程示例scoped_refptr源码分析实现原理资源获取即初始化(RAII)引用计数类的关系图对托管对象的包装RefCountInterfaceRefCounterRefCountedObject宏原型展开结果小结对托管对象的管理scoped_refptr的概述构造器和析构器运算符重载函数其他成员函数小结 unique_ptr和scoped_refptr是WebRTC中使用最多的两种智能指针，unique_ptr是C++标准库中的智能指针，而scoped_refp
WebRTC源码分析
最新发布
08-02
下面是对WebRTC源码的简要分析： WebRTC源码主要分为以下几个模块： 1. 信令（Signaling）模块：负责建立和维护通信的连接。它使用WebSocket或者其他协议进行通信，包括传输SDP（Session Description Protocol）和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值