## StreamIndex 类型：`enum` 流属性 | 属性 | 值 | 描述 | | :-- | :-- | :-- | | STREAM_INDEX_MAIN | `0` | 主流。包括：\ |||- 由摄像头/麦克风通过内部采集机制，采集到的视频/音频; |\ |||- 通过自定义采集，采集到的视频/音频。 | | STREAM_INDEX_SCREEN | `1` | 屏幕流。屏幕共享时共享的视频流，或来自声卡的本地播放音频流。 | ## IVideoCanvas 类型：`interface` 视图信息和渲染模式 ### viewId 类型：string 组件 View id ### renderMode 类型：[RenderMode](#rendermode) | undefined 渲染模式。 ## RenderMode 类型：`enum` 图片或视频流的缩放模式。 | 属性 | 值 | 描述 | | :-- | :-- | :-- | | ByteRTCRenderModeHidden | `0` | 视窗填满优先，默认值。
视频尺寸等比缩放，直至视窗被填满。当视频尺寸与显示窗口尺寸不一致时，多出的视频将被截掉。 | | ByteRTCRenderModeFit | `1` | 视频帧内容全部显示优先。
视频尺寸等比缩放，优先保证视频内容全部显示。当视频尺寸与显示窗口尺寸不一致时，会把窗口未被填满的区域填充成背景颜色。 | | ByteRTCRenderModeFill | `2` | 视频帧自适应画布。
视频尺寸非等比例缩放，把窗口充满。在此过程中，视频帧的长宽比例可能会发生变化。 | ## IRemoteInfo 类型：`interface` 远端用户信息。 ### userId 类型：string 用户 ID。 ### streamIndex 类型：[StreamIndex](#streamindex) 流属性。 ### roomId 类型：string 房间 ID。 ## ReturnStatus 类型：`enum` 方法调用结果。 | 属性 | 值 | 描述 | | :-- | :-- | :-- | | RETURN_STATUS_SUCCESS | `0` | 成功。 | | RETURN_STATUS_FAILURE | `1` | 失败。 | | RETURN_STATUS_PARAMETER_ERR | `2` | 参数错误。 | | RETURN_STATUS_WRONG_STATE | `3` | 接口状态错误。 | | RETURN_STATUS_HAS_IN_ROOM | `4` | 失败，用户已在房间内。 | | RETURN_STATUS_HAS_IN_LOGIN | `5` | 失败，用户已登录。 | | RETURN_STATUS_HAS_IN_ECHO_TEST | `6` | 失败，用户已经在进行通话回路测试中。 | | RETURN_STATUS_NEITHER_VIDEO_NOR_AUDIO | `7` | 失败，音视频均未采集。 | | RETURN_STATUS_ROOMID_IN_USE | `8` | 失败，该 roomId 已被使用。 | | RETURN_STATUS_SCREEN_NOT_SUPPORT | `9` | 失败，屏幕流不支持。 | | RETURN_STATUS_NOT_SUPPORT | `10` | 失败，不支持该操作。 | | RETURN_STATUS_RESOURCE_OVERFLOW | `11` | 失败，资源已占用。 | | RETURN_STATUS_AUDIO_NO_FRAME | `12` | 失败，没有音频帧。 | | RETURN_STATUS_AUDIO_NOT_IMPLEMENTED | `13` | 失败，未实现。 | | RETURN_STATUS_AUDIO_NO_PERMISSION | `14` | 失败，采集设备无麦克风权限，尝试初始化设备失败。 | | RETURN_STATUS_AUDIO_DEVICE_NOT_EXISTS | `15` | 失败，设备不存在。当前没有设备或设备被移除时返回该值。 | | RETURN_STATUS_AUDIO_DEVICE_FORMAT_NOT_SUPPORT | `16` | 失败，设备音频格式不支持。 | | RETURN_STATUS_AUDIO_DEVICE_NO_DEVICE | `17` | 失败，系统无可用设备。 | | RETURN_STATUS_AUDIO_DEVICE_CAN_NOT_USE | `18` | 失败，当前设备不可用，需更换设备。 | | RETURN_STATUS_AUDIO_DEVICE_INIT_FAILED | `19` | 系统错误，设备初始化失败。 | | RETURN_STATUS_AUDIO_DEVICE_START_FAILED | `20` | 系统错误，设备开启失败。 | | RETURN_STATUS_NATIVE_IN_VALID | `21` | 失败。底层未初始化，engine 无效。 | | RETURN_STATUS_VIDEO_NOT_SUPPORT | `22` | 失败，不支持视频接口调用。 | | RETURN_STATUS_VIDEO_TIMESTAMP_WARNING | `23` | 警告。推送视频帧到 RTC SDK 时，相邻视频帧的时间戳差异应当和推帧操作的间隔相同。如果不同，会收到此警告。 | ## IJoinRoomProps 类型：`interface` 加房配置。 ### token 类型：string | undefined 动态密钥。用于对进房用户进行鉴权验证。进入房间需要携带 Token。测试时可使用控制台生成临时 Token，正式上线需要使用密钥 SDK 在你的服务端生成并下发 Token。Token 有效期及生成方式参看[使用 Token 完成鉴权](70121)。使用不同 AppID 的 App 是不能互通的。请务必保证生成 Token 使用的 AppID 和创建引擎时使用的 AppID 相同，否则会导致加入房间失败。 ### userId 类型：string 用户 ID。该字符串符合正则表达式：`[a-zA-Z0-9_@\-\.]{1,128}`。你需要自行设置或管理 uid，并保证同一房间内每个 uid 的唯一性。 ### extras 类型：Record | undefined 用户的额外信息，最大长度为 200 字节。会在 `onUserJoined` 中回调给远端用户。 ### roomConfigs 类型：

{ profile: [ChannelProfile](#channelprofile); isAutoPublish: boolean; isAutoSubscribeAudio: boolean; isAutoSubscribeVideo: boolean; } | undefined

房间参数配置，设置房间模式以及是否自动发布或订阅流 **成员** | 名称 | 类型 | 描述 | | :-- | :-- | :-- | | profile | `ChannelProfile` |

房间模式，参看 ChannelProfile，默认为 CHANNEL_PROFILE_COMMUNICATION，进房后不可更改。

| | isAutoPublish | `boolean` |

是否自动发布音视频流，默认为自动发布。
创建和加入多房间时，只能将其中一个房间设置为自动发布。若每个房间均不做设置，则默认在第一个加入的房间内自动发布流。
若调用 setUserVisibility 将自身可见性设为 false，无论是默认的自动发布流还是手动设置的自动发布流都不会进行发布，你需要将自身可见性设为 true 后方可发布。

| | isAutoSubscribeAudio | `boolean` |

是否自动订阅音频流，默认为自动订阅, 包含主流和屏幕流。

| | isAutoSubscribeVideo | `boolean` |

是否自动订阅视频流，默认为自动订阅, 包含主流和屏幕流。

| ## ChannelProfile 类型：`enum` 房间模式根据所需场景，选择合适的房间模式，应用不同的音视频算法、视频参数和网络配置调用 `setAudioProfile` 改变音频参数配置 | 属性 | 值 | 描述 | | :-- | :-- | :-- | | CHANNEL_PROFILE_COMMUNICATION | `0` | 普通音频通话，默认模式
与 `CHANNEL_PROFIEL_MEETING(16)` 配置相同。
你可以联系技术支持更换默认配置参数。 | | CHANNEL_PROFILE_GAME | `1` | 游戏语音模式，低功耗、低流量消耗。
低端机在此模式下运行时，进行了额外的性能优化：
- 部分低端机型配置编码帧长 40/60
- 部分低端机型关闭软件 3A 音频处理
增强对 iOS 其他屏幕录制进行的兼容性，避免音频录制被 RTC 打断。 | | CHANNEL_PROFILE_CLOUD_GAME | `2` | 云游戏模式。
如果你的游戏场景需要低延迟的配置，使用此设置。
此设置下，弱网抗性较差。 | | CHANNEL_PROFILE_LOW_LATENCY | `3` | 云渲染模式。超低延时配置。
如果你的应用并非游戏但又对延时要求较高时，选用此模式
该模式下，音视频通话延时会明显降低，但同时弱网抗性、通话音质等均会受到一定影响。 | | CHANNEL_PROFILE_CHAT | `4` | 适用于 1 vs 1 音视频通话 | | CHANNEL_PROFILE_CHAT_ROOM | `5` | 适用于 3 人及以上纯语音通话。
通话中，闭麦时为是媒体模式，上麦后切换为通话模式。 | | CHANNEL_PROFILE_LW_TOGETHER | `6` | 实现多端同步播放音视频，适用于 “一起看” 或 “一起听” 场景。
该场景中，使用 RTC 信令同步播放进度，共享的音频内容不通过 RTC 进行传输。 | | CHANNEL_PROFILE_GAME_HD | `7` | 适用于对音质要求较高的游戏场景，优化音频 3A 策略，只通过媒体模式播放音频 | | CHANNEL_PROFILE_CO_HOST | `8` | 适用于直播中主播之间连麦的业务场景。
该场景中，直播时通过 CDN，发起连麦 PK 时使用 RTC。 | | CHANNEL_PROFILE_KTV | `9` | 线上 KTV 场景，音乐音质，低延迟
使用 RTC 传输伴奏音乐，混音后的歌声，适合独唱或单通合唱 | | CHANNEL_PROFILE_CHORUS | `10` | 适合在线实时合唱场景，高音质，超低延迟。使用本配置前请联系技术支持进行协助完成其他配置。 | | CHANNEL_PROFILE_GAME_STREAMING | `11` | 适用于 1 vs 1 游戏串流，支持公网或局域网。 | | CHANNEL_PROFILE_LAN_LIVE_STREAMING | `12` | 适用于局域网的 1 对多视频直播，最高支持 8K， 60 帧/秒， 100 Mbps 码率
需要在局域网配置私有化部署媒体服务器。 | | CHANNEL_PROFILE_MEETING_ROOM | `13` | 适用于云端会议中的会议室终端设备，例如 Rooms，投屏盒子等。 | | CHANNEL_PROFILE_CLASSROOM | `14` | 适用于课堂互动，房间内所有成员都可以进行音视频互动
当你的场景中需要同时互动的成员超过 10 人时使用此模式 | | CHANNEL_PROFILE_INTERACTIVE_PODCAST | `15` | 适用于单主播和观众进行音视频互动的直播。通话模式，上下麦不会有模式切换，避免音量突变现象 | | CHANNEL_PROFIEL_VR_CHAT | `16` | 适用于 VR 场景。支持最高 192 KHz 音频采样率，可开启球形立体声。 | | CHANNEL_PROFIEL_MEETING | `17` | 适用于云端会议中的个人设备。 | | CHANNEL_PROFILE_LIVE_BROADCASTING | `18` | 直播模式。
当你对音视频通话的音质和画质要求较高时，应使用此设置。
此设置下，当用户使用蓝牙耳机收听时，蓝牙耳机使用媒体模式。 | ## IRemoteVideoConfig 类型：`interface` 远端视频帧信息。 ### width 类型：number 视频宽度，单位：px ### height 类型：number 视频高度，单位：px ### framerate 类型：number 期望订阅的最高帧率，单位：fps，默认值为 0 即满帧订阅，设为大于 0 的值时开始生效。如果发布端发布帧率 > 订阅端订阅的帧率，下行媒体服务器 SVC 丢帧，订阅端收到通过此接口设置的帧率；如果发布端发布帧率 < 订阅端订阅的帧率，则订阅端只能收到发布的帧率。仅码流支持 SVC 分级编码特性时方可生效。 ## IAudioEffectPlayerConfig 类型：`interface` 音效播放器配置。 ### type 类型：[AudioMixingType](#audiomixingtype) 混音播放类型 ### playCount 类型：number 混音播放次数 - play_count <= 0: 无限循环 - play_count == 1: 播放一次（默认） - play_count > 1: 播放 play_count 次 ### startPos 类型：number 混音起始位置。默认值为 0，单位为毫秒。 ### pitch 类型：number 与音乐文件原始音调相比的升高/降低值，取值范围为 `[-12，12]`，默认值为 0。每相邻两个值的音高距离相差半音，正值表示升调，负值表示降调。 ## AudioMixingType 类型：`enum` 混音播放类型 | 属性 | 值 | 描述 | | :-- | :-- | :-- | | AUDIO_MIXING_TYPE_PLAYOUT | `0` | 仅本地播放 | | AUDIO_MIXING_TYPE_PUBLISH | `1` | 仅远端播放 | | AUDIO_MIXING_TYPE_PLAYOUT_AND_PUBLISH | `2` | 本地和远端同时播放 | ## IMediaPlayerConfig 类型：`interface` 音乐播放器配置。 ### type 类型：[AudioMixingType](#audiomixingtype) 音乐播放类型 ### playCount 类型：number 音乐播放次数 - play_count <= 0: 无限循环 - play_count == 1: 播放一次（默认） - play_count > 1: 播放 play_count 次 ### startPos 类型：number 音乐起始位置。默认值为 0，单位为毫秒。 ### autoPlay 类型：boolean 是否自动播放。如果不自动播放，调用 start 播放音乐文件。 ### progressInterval 类型：number 设置音频文件时，收到 onMediaPlayerPlayingProgress 的间隔。单位毫秒。 - interval > 0 时，触发回调。实际间隔为 10 的倍数。如果输入数值不能被 10 整除，将自动向上取整。例如传入 `52`，实际间隔为 60 ms。 - interval <= 0 时，不会触发回调。 ### syncProgressToRecordFrame 类型：boolean 在采集音频数据时，附带本地混音文件播放进度的时间戳。启用此功能会提升远端人声和音频文件混音播放时的同步效果。 - 仅在单个音频文件混音时使用有效。 - `true` 时开启此功能，`false` 时关闭此功能，默认为关闭。 ## IEnhanceMentConfig 类型：`interface` 蜂窝网络辅助增强应用的媒体模式。 ### enhanceSignaling 类型：boolean 对信令消息，是否启用蜂窝网络辅助增强。默认不启用。 ### enhanceAudio 类型：boolean 对屏幕共享以外的其他音频，是否启用蜂窝网络辅助增强。默认不启用。 ### enhanceVideo 类型：boolean 对屏幕共享视频以外的其他视频，是否启用蜂窝网络辅助增强。默认不启用。 ### enhanceScreenAudio 类型：boolean 对屏幕共享音频，是否启用蜂窝网络辅助增强。默认不启用。 ### enhanceScreenVideo 类型：boolean 对屏幕共享视频，是否启用蜂窝网络辅助增强。默认不启用。 ## IAudioPropertiesConfig 类型：`interface` 音频属性信息提示的相关配置。 ### interval 类型：number 信息提示间隔，单位：ms - `<= 0`: 关闭信息提示 - `(0,100]`: 开启信息提示，不合法的 interval 值，SDK 自动设置为 100ms - `> 100`: 开启信息提示，并将信息提示间隔设置为此值 ### enableSpectrum 类型：boolean 是否开启音频频谱检测 ### enableVad 类型：boolean 是否开启人声检测 (VAD) ### localMainReportMode 类型：[AudioReportMode](#audioreportmode) 音量回调模式。详见 [AudioReportMode](#audioreportmode)。 ### audioReportMode 类型：[AudioPropertiesMode](#audiopropertiesmode) onLocalAudioPropertiesReport 中包含音频数据的范围。参看 [AudioPropertiesMode](#audiopropertiesmode)。默认仅包含本地麦克风采集的音频数据和本地屏幕音频采集数据，不包含本地混音音频数据。 ### smooth 类型：number 适用于音频属性信息提示的平滑系数。取值范围是 `(0.0, 1.0]`。默认值为 `1.0`，不开启平滑效果；值越小，提示音量平滑效果越明显。如果要开启平滑效果，可以设置为 `0.3`。 ### enableVoicePitch 类型：boolean 是否回调本地用户的人声基频。 ## AudioReportMode 类型：`enum` 音量回调模式。 | 属性 | 值 | 描述 | | :-- | :-- | :-- | | AUDIO_REPORT_MODE_NORMAL | `0` | 默认始终开启音量回调。 | | AUDIO_REPORT_MODE_DISCONNECT | `1` | 可见用户进房并停止推流后，关闭音量回调。 | | AUDIO_REPORT_MODE_RESET | `2` | 可见用户进房并停止推流后，开启音量回调，回调值重置为 0。 | ## AudioPropertiesMode 类型：`enum` onLocalAudioPropertiesReport 中包含的音频信息的范围。 | 属性 | 值 | 描述 | | :-- | :-- | :-- | | AUDIO_PROPERTIES_MODE_MICROPHONE | `0` | 仅包含本地麦克风采集的音频数据和本地屏幕音频采集数据。 | | AUDIO_PROPERTIES_MODE_AUDIOMIXING | `1` | 包含以下信息：\ |||- 本地麦克风采集的音频数据和本地屏幕音频采集数据； |\ |||- 本地混音的音频数据。 | ## IRemoteStreamInfo 类型：`interface` 远端流信息。 ### roomId 类型：string 远端用户所在的房间 ID。 ### userId 类型：string 远端用户的 ID。 ### streamIndex 类型：[StreamIndex](#streamindex) 流属性 ## IScreenSolution 类型：`interface` 屏幕流编码配置。 ### width 类型：number 视频最大宽度，单位：像素。 ### height 类型：number 视频最大高度，单位：像素。 ### frameRate 类型：number 视频采集和编码帧率，单位：fps。 ### maxBitrate 类型：number 最大编码码率，使用 SDK 内部采集时可选设置，自定义采集时必须设置，单位：kbps。设为 -1 即适配码率模式，系统将根据输入的分辨率和帧率自动计算适用的码率。设为 0 则不对视频流进行编码发送。 3.44 及以上版本，内部采集时默认值为 -1，3.44 以前版本无默认值，需手动设置。 ### minBitrate 类型：number 最小编码码率，使用 SDK 内部采集时可选设置，自定义采集时必须设置，单位：kbps。最小编码码率必须小于或等于最大编码，否则不对视频流进行编码发送。 ### encodePrefer 类型：[RTCScreenVideoEncoderPreference](#rtcscreenvideoencoderpreference) 屏幕流编码模式。默认为流畅模式。参看 [RTCScreenVideoEncoderPreference](#rtcscreenvideoencoderpreference)。 ## RTCScreenVideoEncoderPreference 类型：`enum` 编码策略偏好。 | 属性 | 值 | 描述 | | :-- | :-- | :-- | | MAINTAIN_FRAMERATE | `0` | （默认值）帧率优先。分辨率不变。 | | MAINTAIN_QUALITY | `1` | 分辨率优先。 | | DISABLED | `2` | 无偏好。不降低帧率和分辨率。 | | BALANCE | `3` | 平衡帧率与分辨率。 | ## ScreenMediaType 类型：`enum` 屏幕采集媒体类型 | 属性 | 值 | 描述 | | :-- | :-- | :-- | | SCREEN_MEDIA_TYPE_VIDEO_ONLY | `0` | 仅采集视频 | | SCREEN_MEDIA_TYPE_AUDIO_ONLY | `1` | 仅采集音频 | | SCREEN_MEDIA_TYPE_VIDEO_AND_AUDIO | `2` | 采集音频和视频 | ## ICreateRTCEngineOptions 类型：`interface` 引擎初始化参数 ### appID 类型：string 必填，每个应用的唯一标识符，由 RTC 控制台随机生成的。不同的 AppId 生成的实例在 RTC 中进行音视频通话完全独立，无法互通。 ### parameters 类型：Record | undefined 选填，私有参数。如需使用请联系技术支持人员。 ## ILogConfigs 类型：`interface` SDK 日志配置。 ### logLevel 类型：[LocalLogLevel](#localloglevel) 日志输出等级，参看 [LocalLogLevel](#localloglevel)，默认为警告级别，选填。 ### logPath 类型：string 日志存储路径，必填。 ### logFileSize 类型：number 设置日志文件总大小上限（即所有日志文件大小之和），选填。单位为 MB，取值范围为 1～100 MB。系统处理机制如下： - 默认值：10 MB（即调用了 [setLogConfig](1390575#setlogconfig)，且没有设置 `logFileSize` 的情况）。 - 超出取值范围：若 `logFileSize` < 1，则按 1 MB 处理；若 `logFileSize` \> 100，则按 100 MB 处理。 - 其中，单个日志文件最大为 2 MB： - 若 1 ≤ `logFileSize` ≤ 2，则会生成一个日志文件。 - 若 `logFileSize` \> 2，系统会将日志分割成多个文件，每个文件最大 2 MB。当所有日志文件的总大小达到 `logFileSize` 设置的上限时，系统会自动删除最旧的日志文件。例如，`logFileSize` 设置为 10 MB，系统最多会保留 5 个 2 MB 大小的日志文件。当需要写入新日志且总大小即将超过 10 MB 时，最旧的那个文件会被删除，以此类推。 ### logFilenamePrefix 类型：string 日志文件名前缀，选填。该字符串必须符合正则表达式：[a-zA-Z0-9_@\-\.]{1,128}。最终的日志文件名为`前缀 + "_" + 文件创建时间 + "_rtclog".log`，如 `logPrefix_2023-05-25_172324_rtclog.log`。 ## LocalLogLevel 类型：`enum` 日志输出等级。 | 属性 | 值 | 描述 | | :-- | :-- | :-- | | INFO | `0` | 输出 `INFO`、`WARNING`、`ERROR` 级别的日志。 | | WARNING | `1` | （默认值）仅输出 `WARNING`、`ERROR` 级别的日志。 | | ERROR | `2` | 仅输出 `ERROR` 级别的日志。 | | NONE | `3` | 不输出日志。 | ## IStreamSyncInfoConfig 类型：`interface` 流同步配置。 ### streamIndex 类型：[StreamIndex](#streamindex) 流属性。 ### repeatCount 类型：number 重复次数。 ### streamType 类型：SyncInfoStreamType 值：`0` 媒体流信息同步的流类型 ## EncryptTypes 类型：`enum` 加密类型。 | 属性 | 值 | 描述 | | :-- | :-- | :-- | | NONE | `0` | 不设置。 | | AES128CBC | `1` | AES128CBC。 | | AES256CBC | `2` | AES256CBC。 | | AES128ECB | `3` | AES128ECB。 | | AES256ECB | `4` | AES256ECB。 | ## IFeedbackProblemInfo 类型：`interface` 通话质量反馈信息。 ### desc 类型：string 文字描述。 ### roomId 类型：string 房间 ID。 ### userId 类型：string 用户 ID。 ## PositionInfo 类型：`class` 用户在空间音频坐标系里的位置信息。 ### new PositionInfo() **类型** ```ts constructor(...args: any[]) ``` **参数** ```mixin-react const columns = [{ title: '名称', dataIndex: 'Name', width: 240, },{ title: '类型', dataIndex: 'Type', width: 240, render: (col, item, index) => { if(col.includes('')){ const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi; const new1 = regex.exec(col); return {new1?.[1]}{new1?.[4]}{new1?.[5]} } return col; } },{ title: '必选', dataIndex: 'Required', width: 120, },{ title: '默认值', dataIndex: 'Default', width: 120, render: (col, item, index) => { if(col.includes('')){ const regex = /(.*)

(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return ();
```
  

### position  

类型：Position

用户在空间音频坐标系里的位置，需自行建立空间直角坐标系。参看 [Position](#position)。

### orientation  

类型：HumanOrientation

用户在空间音频坐标系里的三维朝向信息。三个向量需要两两垂直。参看 [HumanOrientation](#humanorientation)。


## AudioTrackType 

类型：`enum`

原唱伴唱类型。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | ORIGINAL | `0` | 播放原唱。 |
  | ACCOMPANY | `1` | 播放伴唱。 |
  | ByteRTCAudioTrackTypeAccompy | `2` | 播放伴唱。 |


## AudioPlayType 

类型：`enum`

音乐播放类型。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | LOCAL | `0` | 仅本地播放。 |
  | REMOTE | `1` | 仅远端播放。 |
  | LOCAL_AND_REMOTE | `2` | 本地、远端同时播放。 |


## VirtualBackgroundSource 

类型：`class`

背景贴纸对象。

### sourceType  

类型：VirtualBackgroundSourceType

虚拟背景类型，详见 [VirtualBackgroundSourceType](#virtualbackgroundsourcetype) 。

### sourceColor  

类型：number

纯色背景使用的颜色。
格式为 0xAARRGGBB 。

### sourcePath  

类型：string

自定义背景图片的绝对路径。
- 支持本地文件绝对路径 (file://xxx) 和 Asset 资源路径 (asset://xxx)。
- 支持的格式为 jpg、jpeg、png。
- 图片分辨率超过 1080P 时，图片会被等比缩放至和视频一致。
- 图片和视频宽高比一致时，图片会被直接缩放至和视频一致。
- 图片和视频长宽比不一致时，为保证图片内容不变形，图片按短边缩放至与视频帧一致，使图片填满视频帧，对多出的高或宽进行剪裁。
- 自定义图片带有局部透明效果时，透明部分由黑色代替。


## FaceDetectionResult 

类型：`class`

人脸检测结果

### detectResult  

类型：number

人脸检测结果
- 0：检测成功
- !0：检测失败。详见[CV 错误码](https://www.volcengine.com/docs/6705/102042)。

### imageWidth  

类型：number

原始图片宽度(px)

### imageHeight  

类型：number

原始图片高度(px)

### android_frameTimestampUs  

类型：number

进行人脸识别的视频帧的时间戳。

### ios_frameTimestamp  

类型：number

进行人脸识别的视频帧的时间戳。

### faces()  

识别到人脸的矩形框。数组的长度和检测到的人脸数量一致。参看 [Rectangle](#rectangle)。

**类型**

  ```ts
  ($item: $p_a.Rectangle) => Rectangle
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"$item","Type":"$p_a.Rectangle","Required":"是","Default":"无","Description":"-","children":[],"key":"$item"}]
      return (
);
```
  


## SysStats 

类型：`class`

CPU 和内存统计信息

### new SysStats()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### cpuCores  

类型：number

设备的 CPU 核数

### cpuAppUsage  

类型：number

应用的 CPU 使用率，取值范围为 [0, 1]。

### android_cpuTotalUsage  

类型：number

系统的 CPU 使用率，取值范围为 [0, 1]。

### memoryUsage  

类型：number

应用的内存占用大小（单位 MB）

### fullMemory  

类型：number

设备的内存大小 单位：MB

### totalMemoryUsage  

类型：number

系统已使用内存 MB

### freeMemory  

类型：number

系统当前空闲内存（MB）

### memoryRatio  

类型：number

当前应用的内存使用率（单位 \%）

### totalMemoryRatio  

类型：number

系统内存使用率（单位 \%）


## RTCNetworkType 

类型：`enum`

网络连接类型。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | UNKNOWN | `0` | - |
  | LAN | `1` | - |
  | MOBILE_2G | `2` | - |
  | MOBILE_3G | `3` | - |
  | WIFI | `4` | - |
  | MOBILE_4G | `5` | - |
  | MOBILE_5G | `6` | - |
  | NONE | `7` | - |
  | ByteRTCNetworkTypeDisconnected | `8` | 网络连接已断开。 |


## LocalAudioStreamState 

类型：`enum`

本地音频流状态。
SDK 通过 onLocalAudioStateChanged 回调该状态。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | LOCAL_AUDIO_STREAM_STATE_STOPPED | `0` | 本地音频默认初始状态。
麦克风停止工作时回调该状态，对应错误码 [LocalAudioStreamError](#localaudiostreamerror) 中的 kLocalAudioStreamErrorOk 。 |
  | LOCAL_AUDIO_STREAM_STATE_RECORDING | `1` | 本地音频录制设备启动成功。
采集到音频首帧时回调该状态，对应错误码 [LocalAudioStreamError](#localaudiostreamerror) 中的 kLocalAudioStreamErrorOk 。 |
  | LOCAL_AUDIO_STREAM_STATE_ENCODING | `2` | 本地音频首帧编码成功。
音频首帧编码成功时回调该状态，对应错误码 [LocalAudioStreamError](#localaudiostreamerror) 中的 kLocalAudioStreamErrorOk 。 |
  | LOCAL_AUDIO_STREAM_STATE_FAILED | `3` | 本地音频启动失败，在以下时机回调该状态：\
                |||- 本地录音设备启动失败，对应错误码 [LocalAudioStreamError](#localaudiostreamerror) 中的 kLocalAudioStreamErrorRecordFailure 。 |\
                |||- 检测到没有录音设备权限，对应错误码 [LocalAudioStreamError](#localaudiostreamerror) 中的 kLocalAudioStreamErrorDeviceNoPermission。 |\
                |||- 音频编码失败，对应错误码 [LocalAudioStreamError](#localaudiostreamerror) 中的 kLocalAudioStreamErrorEncodeFailure。 |


## LocalAudioStreamError 

类型：`enum`

本地音频流状态改变时的错误码。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | LOCAL_AUDIO_STREAM_ERROR_OK | `0` | 本地音频状态正常 |
  | LOCAL_AUDIO_STREAM_ERROR_FAILURE | `1` | 本地音频出错原因未知 |
  | LOCAL_AUDIO_STREAM_ERROR_DEVICE_NO_PERMISSION | `2` | 没有权限启动本地音频录制设备 |
  | LOCAL_AUDIO_STREAM_ERROR_RECORD_FAILURE | `3` | 本地音频录制失败，建议你检查录制设备是否正常工作 |
  | LOCAL_AUDIO_STREAM_ERROR_ENCODE_FAILURE | `4` | 本地音频编码失败 |
  | LOCAL_AUDIO_STREAM_ERROR_NO_RECORDING_DEVICE | `5` | brief 没有可用的音频录制设备 |


## RemoteStreamKey 

类型：`class`

远端流信息

### new RemoteStreamKey()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### roomId  

类型：string

房间 ID

### userId  

类型：string

用户 ID

### streamIndex  

类型：StreamIndex

流属性，包括主流、屏幕流。参看 [StreamIndex](1390578#streamindex)

### android_getRoomId()  

获取房间 ID

**类型**

  ```ts
  () => string
  ```

**返回值**

  string

### android_getUserId()  

获取用户 ID

**类型**

  ```ts
  () => string
  ```

**返回值**

  string

### android_getStreamIndex()  

获取流属性，包括主流、屏幕流。参看 [StreamIndex](#streamindex-2)

**类型**

  ```ts
  () => $p_a.StreamIndex
  ```

**返回值**

  $p_a.[StreamIndex](#streamindex)

### android_hasNullProperty()  

检查当前类中是否有为空的字段

**类型**

  ```ts
  () => boolean
  ```

**返回值**

  boolean


## RemoteAudioState 

类型：`enum`

用户订阅的远端音频流状态。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | REMOTE_AUDIO_STATE_STOPPED | `0` | 远端音频流默认初始状态，在以下时机回调该状态：\
                |||- 本地用户停止接收远端音频流，对应原因是 [RemoteAudioStateChangeReason](#remoteaudiostatechangereason) 中的 `kRemoteAudioReasonLocalMuted` |\
                |||- 远端用户停止发送音频流，对应原因是 [RemoteAudioStateChangeReason](#remoteaudiostatechangereason) 中的 `kRemoteAudioReasonRemoteMuted` |\
                |||- 远端用户离开房间，对应原因是 [RemoteAudioStateChangeReason](#remoteaudiostatechangereason) 中的 `kRemoteAudioReasonRemoteOffline` |
  | REMOTE_AUDIO_STATE_STARTING | `1` | 开始接收远端音频流首包。 |
  | REMOTE_AUDIO_STATE_DECODING | `2` | 远端音频流正在解码，正常播放，在以下时机回调该状态：\
                |||- 成功解码远端音频首帧，对应原因是 [RemoteAudioStateChangeReason](#remoteaudiostatechangereason) 中的 `kRemoteAudioReasonLocalUnmuted` |\
                |||- 网络由阻塞恢复正常，对应原因是 [RemoteAudioStateChangeReason](#remoteaudiostatechangereason) 中的 `kRemoteAudioReasonNetworkRecovery` |\
                |||- 本地用户恢复接收远端音频流，对应原因是 [RemoteAudioStateChangeReason](#remoteaudiostatechangereason) 中的 `kRemoteAudioReasonLocalUnmuted` |\
                |||- 远端用户恢复发送音频流，对应原因是 [RemoteAudioStateChangeReason](#remoteaudiostatechangereason) 中的 `kRemoteAudioReasonRemoteUnmuted` |
  | REMOTE_AUDIO_STATE_FROZEN | `3` | 远端音频流卡顿。
网络阻塞导致丢包率大于 40\% 时回调该状态，对应原因是
[RemoteAudioStateChangeReason](#remoteaudiostatechangereason) 中的 `kRemoteAudioReasonNetworkCongestion` |


## RemoteAudioStateChangeReason 

类型：`enum`

远端音频流状态改变的原因。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | REMOTE_AUDIO_STATE_CHANGE_REASON_NETWORK_CONGESTION | `0` | 网络阻塞 |
  | REMOTE_AUDIO_STATE_CHANGE_REASON_NETWORK_RECOVERY | `1` | 网络恢复正常 |
  | REMOTE_AUDIO_STATE_CHANGE_REASON_LOCAL_MUTED | `2` | 本地用户停止接收远端音频流 |
  | REMOTE_AUDIO_STATE_CHANGE_REASON_LOCAL_UNMUTED | `3` | 本地用户恢复接收远端音频流 |
  | REMOTE_AUDIO_STATE_CHANGE_REASON_REMOTE_MUTED | `4` | 远端用户停止发送音频流 |
  | REMOTE_AUDIO_STATE_CHANGE_REASON_REMOTE_UNMUTED | `5` | 远端用户恢复发送音频流 |
  | REMOTE_AUDIO_STATE_CHANGE_REASON_REMOTE_OFFLINE | `6` | 远端用户离开房间 |
  | REMOTE_AUDIO_STATE_CHANGE_REASON_INTERNAL | `7` | 内部原因 |
  | ByteRTCRemoteAudioStateChangeReasonInternal | `8` | 内部原因 |


## LocalVideoStreamState 

类型：`enum`

本地视频流状态

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | LOCAL_VIDEO_STREAM_STATE_STOPPED | `0` | 本地视频采集停止状态（默认初始状态）
本地视频采集关闭时回调该状态，对应错误码 [LocalVideoStreamError](#localvideostreamerror) 中的 `LOCAL_VIDEO_STREAM_ERROR_OK` |
  | LOCAL_VIDEO_STREAM_STATE_RECORDING | `1` | 本地视频采集设备启动成功
本地视频采集开启时回调该状态，对应错误码 [LocalVideoStreamError](#localvideostreamerror) 中的 `LOCAL_VIDEO_STREAM_ERROR_OK` |
  | LOCAL_VIDEO_STREAM_STATE_ENCODING | `2` | 本地视频采集后，首帧编码成功
本地视频首帧编码成功时回调该状态，对应错误码 [LocalVideoStreamError](#localvideostreamerror) 中的 `LOCAL_VIDEO_STREAM_ERROR_OK` |
  | LOCAL_VIDEO_STREAM_STATE_FAILED | `3` | 本地视频启动失败\
                |||- 本地视频采集设备启动失败，对应错误码 [LocalVideoStreamError](#localvideostreamerror) 中的 `LOCAL_VIDEO_STREAM_ERROR_FAILURE` |\
                |||- 检测到没有视频采集设备权限，对应错误码 [LocalVideoStreamError](#localvideostreamerror) 中的 `LOCAL_VIDEO_STREAM_ERROR_DEVICE_NO_PERMISSION` |\
                |||- 视频编码失败，对应错误码 [LocalVideoStreamError](#localvideostreamerror) 中的 `LOCAL_VIDEO_STREAM_ERROR_ENCODE_FAILURE` |


## LocalVideoStreamError 

类型：`enum`

本地视频状态改变时的错误码

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | LOCAL_VIDEO_STREAM_ERROR_OK | `0` | 状态正常（本地视频状态改变正常时默认返回值） |
  | LOCAL_VIDEO_STREAM_ERROR_FAILURE | `1` | 本地视频流发布失败 |
  | LOCAL_VIDEO_STREAM_ERROR_DEVICE_NO_PERMISSION | `2` | 没有权限启动本地视频采集设备 |
  | LOCAL_VIDEO_STREAM_ERROR_DEVICE_BUSY | `3` | 本地视频采集设备已被占用 |
  | LOCAL_VIDEO_STREAM_ERROR_DEVICE_NOT_FOUND | `4` | 本地视频采集设备不存在或已移除 |
  | LOCAL_VIDEO_STREAM_ERROR_CAPTURE_FAILURE | `5` | 本地视频采集失败，建议检查采集设备是否正常工作 |
  | LOCAL_VIDEO_STREAM_ERROR_ENCODE_FAILURE | `6` | 本地视频编码失败 |
  | LOCAL_VIDEO_STREAM_ERROR_DEVICE_DISCONNECTED | `7` | 通话过程中本地视频采集设备被其他程序抢占，导致设备连接中断 |


## RemoteVideoState 

类型：`enum`

远端视频流状态。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | REMOTE_VIDEO_STATE_STOPPED | `0` | 远端视频流默认初始状态
在以下时机回调该状态：\
                |||- 本地用户停止接收远端视频流，对应错误码 [RemoteVideoStateChangeReason](#remotevideostatechangereason) 中的 REMOTE_VIDEO_STATE_CHANGE_REASON_LOCAL_MUTED。 |\
                |||- 远端用户停止发送视频流，对应错误码 [RemoteVideoStateChangeReason](#remotevideostatechangereason) 中的 REMOTE_VIDEO_STATE_CHANGE_REASON_REMOTE_MUTED。 |\
                |||- 远端用户离开房间，对应错误码 [RemoteVideoStateChangeReason](#remotevideostatechangereason) 中的 REMOTE_VIDEO_STATE_CHANGE_REASON_REMOTE_OFFLINE。 |
  | REMOTE_VIDEO_STATE_STARTING | `1` | 本地用户已接收远端视频首包
收到远端视频首包时回调该状态，对应错误码 [RemoteVideoStateChangeReason](#remotevideostatechangereason) 中的 REMOTE_VIDEO_STATE_CHANGE_REASON_LOCAL_UNMUTED。 |
  | REMOTE_VIDEO_STATE_DECODING | `2` | 远端视频流正在解码，正常播放
在以下时机回调该状态：\
                |||- 成功解码远端视频首帧，对应错误码 [RemoteVideoStateChangeReason](#remotevideostatechangereason) 中的 REMOTE_VIDEO_STATE_CHANGE_REASON_LOCAL_UNMUTED。 |\
                |||- 网络由阻塞恢复正常，对应错误码 [RemoteVideoStateChangeReason](#remotevideostatechangereason) 中的 REMOTE_VIDEO_STATE_CHANGE_REASON_NETWORK_RECOVERY。 |\
                |||- 本地用户恢复接收远端视频流，对应错误码 [RemoteVideoStateChangeReason](#remotevideostatechangereason) 中的 REMOTE_VIDEO_STATE_CHANGE_REASON_LOCAL_UNMUTED。 |\
                |||- 远端用户恢复发送视频流，对应错误码 [RemoteVideoStateChangeReason](#remotevideostatechangereason) 中的 REMOTE_VIDEO_STATE_CHANGE_REASON_NETWORK_CONGESTION。 |
  | REMOTE_VIDEO_STATE_FROZEN | `3` | 远端视频流卡顿
网络阻塞、丢包率大于 40\%时回调该状态，对应错误码 [RemoteVideoStateChangeReason](#remotevideostatechangereason) 中的 REMOTE_VIDEO_REASON_NETWORK_CONGESTION 。 |
  | ByteRTCRemoteVideoStateFailed | `4` | 远端视频流播放失败
如果内部处理远端视频流失败，则会回调该方法， 对应错误码 ByteRTCRemoteVideoStateChangeReason 中的 ByteRTCRemoteVideoStateChangeReasonInternal |


## RemoteVideoStateChangeReason 

类型：`enum`

远端视频流状态改变的原因

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | REMOTE_VIDEO_STATE_CHANGE_REASON_NETWORK_CONGESTION | `0` | 网络阻塞 |
  | REMOTE_VIDEO_STATE_CHANGE_REASON_NETWORK_RECOVERY | `1` | 网络恢复正常 |
  | REMOTE_VIDEO_STATE_CHANGE_REASON_LOCAL_MUTED | `2` | 本地用户停止接收远端视频流或本地用户禁用视频模块 |
  | REMOTE_VIDEO_STATE_CHANGE_REASON_LOCAL_UNMUTED | `3` | 本地用户恢复接收远端视频流或本地用户启用视频模块 |
  | REMOTE_VIDEO_STATE_CHANGE_REASON_REMOTE_MUTED | `4` | 远端用户停止发送视频流或远端用户禁用视频模块 |
  | REMOTE_VIDEO_STATE_CHANGE_REASON_REMOTE_UNMUTED | `5` | 远端用户恢复发送视频流或远端用户启用视频模块 |
  | REMOTE_VIDEO_STATE_CHANGE_REASON_REMOTE_OFFLINE | `6` | 远端用户离开房间
状态转换参看 onUserUnpublishStream/onUserUnpublishScreen onUserUnpublishScreen。 |
  | REMOTE_VIDEO_STATE_CHANGE_REASON_INTERNAL | `7` | 内部原因 |
  | ByteRTCRemoteVideoStateChangeReasonInternal | `8` | 内部原因 |


## VideoFrameInfo 

类型：`class`

视频帧信息

### new VideoFrameInfo()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### width  

类型：number

宽（像素）

### height  

类型：number

高（像素）

### rotation  

类型：VideoRotation

视频帧顺时针旋转角度。参看 [VideoRotation](#videorotation)。


## ConnectionState 

类型：`enum`

SDK 与 RTC 服务器连接状态。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | CONNECTION_STATE_DISCONNECTED | `0` | 连接断开超过 12s，此时 SDK 会尝试自动重连。 |
  | CONNECTION_STATE_CONNECTING | `1` | 首次请求建立连接，正在连接中。 |
  | CONNECTION_STATE_CONNECTED | `2` | 首次连接成功。 |
  | CONNECTION_STATE_RECONNECTING | `3` | 涵盖了以下情况：\
                |||- 首次连接时，10 秒内未连接成功; |\
                |||- 连接成功后，断连 10 秒。自动重连中。 |
  | CONNECTION_STATE_RECONNECTED | `4` | 连接断开后，重连成功。 |
  | CONNECTION_STATE_LOST | `5` | 处于 `CONNECTION_STATE_DISCONNECTED` 状态超过 10 秒，且期间重连未成功。SDK 仍将继续尝试重连。 |
  | CONNECTION_STATE_FAILED | `6` | 连接失败，服务端状态异常。SDK 不会自动重连，请重新进房，或联系技术支持。 |


## AudioRoute 

类型：`enum`

音频播放路由

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | AUDIO_ROUTE_DEFAULT | `0` | 默认设备。通过 `setDefaultAudioRoute` 设置的音频路由。 |
  | AUDIO_ROUTE_HEADSET | `1` | 有线耳机 |
  | AUDIO_ROUTE_EARPIECE | `2` | 听筒。设备自带的，一般用于通话的播放硬件。 |
  | AUDIO_ROUTE_SPEAKERPHONE | `3` | 扬声器。设备自带的，一般用于免提播放的硬件。 |
  | AUDIO_ROUTE_HEADSET_BLUETOOTH | `4` | 蓝牙耳机 |
  | AUDIO_ROUTE_HEADSET_USB | `5` | USB 设备 |


## SEIStreamUpdateEventType 

类型：`enum`

黑帧视频流状态

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | STREAM_ADD | `0` | 远端用户发布黑帧视频流。
纯语音通话场景下，远端用户调用 sendSEIMessage 发送 SEI 数据时，SDK 会自动发布一路黑帧视频流，并触发该回调。 |
  | STREAM_REMOVE | `1` | 远端黑帧视频流移除。该回调的触发时机包括：\
                |||- 远端用户开启摄像头采集，由语音通话切换至视频通话，黑帧视频流停止发布； |\
                |||- 远端用户调用 sendSEIMessage 后 1min 内未有 SEI 数据发送，黑帧视频流停止发布； |\
                |||- 远端用户调用 setVideoSourceType 切换至自定义视频采集时，黑帧视频流停止发布。 |
  | ByteRTCSEIStreamEventTypeStreamAdd | `2` | 远端用户发布黑帧视频流。
纯语音通话场景下，远端用户调用 sendSEIMessage 发送 SEI 数据时，SDK 会自动发布一路黑帧视频流，并触发该回调。 |
  | ByteRTCSEIStreamEventTypeStreamRemove | `3` | 远端黑帧视频流移除。该回调的触发时机包括：\
                |||- 远端用户开启摄像头采集，由语音通话切换至视频通话，黑帧视频流停止发布； |\
                |||- 远端用户调用 sendSEIMessage 后 1min 内未有 SEI 数据发送，黑帧视频流停止发布； |\
                |||- 远端用户调用 setVideoSourceType 切换至自定义视频采集时，黑帧视频流停止发布。 |


## LogoutReason 

类型：`enum`

用户登出的原因

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | LOGOUT_REASON_LOGOUT | `0` | 用户主动退出
用户调用 `logout` 接口登出，或者销毁引擎登出。 |
  | LOGOUT_REASON_DUPLICATE_LOGIN | `1` | 用户被动退出
另一个用户以相同 UserId 进行了 `login`，导致本端用户被踢出。 |
  | ByteRTCLogoutReasonLogout | `2` | 用户主动退出
用户调用 `logout` 接口登出，或者销毁引擎登出。 |
  | ByteRTCLogoutReasonDuplicateLogin | `3` | 用户被动退出
另一个用户以相同 UserId 进行了 `login`，导致本端用户被踢出。 |


## UserOnlineStatus 

类型：`enum`

用户在线状态

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | USER_ONLINE_STATUS_OFFLINE | `0` | 对端用户离线
对端用户已经调用 `logout`，或者没有调用 `login` 进行登录 |
  | USER_ONLINE_STATUS_ONLINE | `1` | 对端用户在线
对端用户调用 `login` 登录，并且连接状态正常。 |
  | USER_ONLINE_STATUS_UNREACHABLE | `2` | 无法获取对端用户在线状态
发生级联错误、对端用户在线状态异常时返回 |
  | ByteRTCUserOnlineStatusOffline | `3` | 对端用户离线
对端用户已经调用 `logout`，或者没有调用 `login:uid:` 进行登录 |
  | ByteRTCUserOnlineStatusOnline | `4` | 对端用户在线
对端用户调用 `login:uid:` 登录，并且连接状态正常 |
  | ByteRTCUserOnlineStatusUnreachable | `5` | 无法获取对端用户在线状态
发生级联错误、对端用户在线状态异常时返回 |


## NetworkDetectionLinkType 

类型：`enum`

通话前探测链接的类型。
`onNetworkDetectionResult` 回调的参数类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | UP | `0` | 上行网络探测 |
  | DOWN | `1` | 下行网络探测 |


## NetworkQuality 

类型：`enum`

所属用户的媒体流网络质量。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | NETWORK_QUALITY_UNKNOWN | `0` | 媒体流网络质量未知。 |
  | NETWORK_QUALITY_EXCELLENT | `1` | 媒体流网络质量极好。 |
  | NETWORK_QUALITY_GOOD | `2` | 媒体流网络质量好。 |
  | NETWORK_QUALITY_POOR | `3` | 媒体流网络质量较差但不影响沟通。 |
  | NETWORK_QUALITY_BAD | `4` | 媒体流网络质量差沟通不顺畅。 |
  | NETWORK_QUALITY_VERY_BAD | `5` | 媒体流网络质量非常差。 |
  | NETWORK_QUALITY_DOWN | `6` | 网络连接断开，无法通话。网络可能由于 12s 内无应答、开启飞行模式、拔掉网线等原因断开。
更多网络状态信息参见 [连接状态提示](https://www.volcengine.com/docs/6348/95376)。 |


## NetworkDetectionStopReason 

类型：`enum`

通话前探测的停止原因。
`onNetworkDetectionStopped` 回调的参数类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | USER | `0` | 用户主动停止 |
  | TIMEOUT | `1` | 探测超过三分钟 |
  | CONNECTION_LOST | `2` | 探测网络连接断开。
当超过 12s 没有收到回复，SDK 将断开网络连接，并且不再尝试重连。 |
  | STREAMING | `3` | 本地开始推拉流，停止探测 |
  | INNER_ERR | `4` | 网络探测失败，内部异常 |
  | ByteRTCNetworkDetectionStopReasonInnerErr | `5` | 网络探测失败，内部异常 |


## RemoteStreamSwitchEvent 

类型：`class`

流切换信息。本地用户订阅的远端流触发回退策略时的流切换信息。

### new RemoteStreamSwitchEvent()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### uid  

类型：string

订阅的音视频流的发布者的用户 ID

### isScreen  

类型：boolean

是否是屏幕共享流

### beforeVideoIndex  

类型：number

流切换前订阅视频流的分辨率对应的索引

### afterVideoIndex  

类型：number

流切换后订阅视频流的分辨率对应的索引

### android_beforeEnable  

类型：boolean

流切换前是否有视频流

### android_afterEnable  

类型：boolean

流切换后是否有视频流

### reason  

类型：FallbackOrRecoverReason

流切换原因，详见类型 [FallbackOrRecoverReason](#fallbackorrecoverreason) 。

### ios_beforeVideoEnabled  

类型：boolean

流切换前是否有视频流

### ios_afterVideoEnabled  

类型：boolean

流切换后是否有视频流


## PerformanceAlarmMode 

类型：`enum`

性能回退的模式

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | NORMAL | `0` | 未开启发布性能回退 |
  | SIMULCAST | `1` | 已开启发布性能回退 |


## PerformanceAlarmReason 

类型：`enum`

性能相关告警的原因

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | BANDWIDTH_RESUMED | `0` | 网络性能恢复，发送性能回退恢复。仅在开启发送性能回退时，会收到此原因。 |
  | BANDWIDTH_FALLBACKED | `1` | 网络原因差，造成了发送性能回退。仅在开启发送性能回退时，会收到此原因。 |
  | PERFORMANCE_FALLBACKED | `2` | 如果未开启发送性能回退，收到此告警时，意味着性能不足；
如果开启了发送性能回退，收到此告警时，意味着性能不足，且已发生发送性能回退。 |
  | PERFORMANCE_RESUMED | `3` | 如果未开启发送性能回退，收到此告警时，意味着性能不足已恢复；
如果开启了发送性能回退，收到此告警时，意味着性能不足已恢复，且已发生发送性能回退恢复。 |
  | ByteRTCPerformanceAlarmReasonBandwidthFallback | `4` | 网络原因差，造成了发送性能回退。仅在开启发送性能回退时，会收到此原因。 |
  | ByteRTCPerformanceAlarmReasonFallback | `5` | 如果未开启发送性能回退，收到此告警时，意味着性能不足；
如果开启了发送性能回退，收到此告警时，意味着性能不足，且已发生发送性能回退。 |
  | ByteRTCPerformanceAlarmReasonResumed | `6` | 如果未开启发送性能回退，收到此告警时，意味着性能不足已恢复；
如果开启了发送性能回退，收到此告警时，意味着性能不足已恢复，且已发生发送性能回退恢复。 |


## SourceWantedData 

类型：`class`

性能回退相关数据

### new SourceWantedData()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### width  

类型：number

如果未开启发送性能回退，此值表示推荐的视频输入宽度；
如果开启了发送性能回退，此值表示当前推流的最大宽度。

### height  

类型：number

如果未开启发送性能回退，此值表示推荐的视频输入高度；
如果开启了发送性能回退，此值表示当前推流的最大高度。

### frameRate  

类型：number

如果未开启发送性能回退，此值表示推荐的视频输入帧率，单位 fps；
如果开启了发送性能回退，此值表示当前推流的最大帧率，单位 fps。


## RTCUser 

类型：`class`

用户信息

### new RTCUser()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### userId  

类型：string

用户 id

### metaData  

类型：string

元数据


## FirstFrameSendState 

类型：`enum`

首帧发送状态

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | FIRST_FRAME_SEND_STATE_SENDING | `0` | 发送中 |
  | FIRST_FRAME_SEND_STATE_SENT | `1` | 发送成功 |
  | FIRST_FRAME_SEND_STAT_END | `2` | 发送失败 |


## FirstFramePlayState 

类型：`enum`

首帧播放状态

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | FIRST_FRAME_PLAY_STATE_PLAYING | `0` | 播放中 |
  | FIRST_FRAME_PLAY_STATE_END | `1` | 播放失败 |
  | FIRST_FRAME_PLAY_STATE_PLAYED | `2` | 播放成功 |
  | ByteRTCFirstFramePlayStatePlay | `3` | 播放成功 |


## AudioDeviceType 

类型：`enum`

音频设备类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | AUDIO_DEVICE_TYPE_UNKNOWN | `0` | 未知设备 |
  | AUDIO_DEVICE_TYPE_RENDER_DEVICE | `1` | 音频渲染设备 |
  | AUDIO_DEVICE_TYPE_CAPTURE_DEVICE | `2` | 音频采集设备类型 |
  | AUDIO_DEVICE_TYPE_SCREEN_CAPTURE_DEVICE | `3` | 屏幕流音频设备 |


## MediaDeviceState 

类型：`enum`

媒体设备状态
通过 `onAudioDeviceStateChanged`/`onVideoDeviceStateChanged` 回调设备状态。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | MEDIA_DEVICE_STATE_STARTED | `0` | 设备开启采集 |
  | MEDIA_DEVICE_STATE_STOPPED | `1` | 设备停止采集 |
  | MEDIA_DEVICE_STATE_RUNTIMEERROR | `2` | 设备运行时错误
例如，当媒体设备的预期行为是正常采集，但没有收到采集数据时，将回调该状态。 |
  | MEDIA_DEVICE_STATE_ADDED | `3` | 设备已插入 |
  | MEDIA_DEVICE_STATE_REMOVED | `4` | 设备被移除 |
  | MEDIA_DEVICE_STATE_INTERRUPTION_BEGAN | `5` | 系统通话打断了音视频通话。将在通话结束后自动恢复。 |
  | MEDIA_DEVICE_STATE_INTERRUPTION_ENDED | `6` | 音视频通话已从系统电话中恢复 |
  | ByteRTCMediaDeviceStateStarted | `7` | 设备已开启 |
  | ByteRTCMediaDeviceStateStopped | `8` | 设备已停止 |
  | ByteRTCMediaDeviceStateRuntimeError | `9` | 设备运行时错误
例如，当媒体设备的预期行为是正常采集，但没有收到采集数据时，将回调该状态。 |
  | ByteRTCMediaDeviceStateAdded | `10` | 设备已插入
你可以调用获取设备接口更新设备列表。 |
  | ByteRTCMediaDeviceStateRemoved | `11` | 设备被移除
你可以调用获取设备接口更新设备列表。 |
  | ByteRTCMediaDeviceStateInterruptionBegan | `12` | 系统通话，锁屏或第三方应用打断了音视频通话。将在通话结束或第三方应用结束占用后自动恢复。 |
  | ByteRTCMediaDeviceStateInterruptionEnded | `13` | 音视频通话已从系统电话或第三方应用打断中恢复 |


## MediaDeviceError 

类型：`enum`

媒体设备错误类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | MEDIA_DEVICE_ERROR_OK | `0` | - |
  | MEDIA_DEVICE_ERROR_NOPERMISSION | `1` | - |
  | MEDIA_DEVICE_ERROR_DEVICEBUSY | `2` | - |
  | MEDIA_DEVICE_ERROR_DEVICEFAILURE | `3` | - |
  | MEDIA_DEVICE_ERROR_DEVICENOTFOUND | `4` | - |
  | MEDIA_DEVICE_ERROR_DEVICEDISCONNECTED | `5` | - |
  | MEDIA_DEVICE_ERROR_DEVICENOCALLBACK | `6` | 无采集数据。当媒体设备的预期行为是正常采集，但没有收到采集数据时，将收到该错误。 |
  | MEDIA_DEVICE_ERROR_UNSUPPORTFORMAT | `7` | 设备采样率不支持 |
  | ByteRTCMediaDeviceErrorOK | `8` | - |
  | ByteRTCMediaDeviceErrorDeviceNoPermission | `9` | - |
  | ByteRTCMediaDeviceErrorDeviceBusy | `10` | - |
  | ByteRTCMediaDeviceErrorDeviceFailure | `11` | - |
  | ByteRTCMediaDeviceErrorDeviceNotFound | `12` | - |
  | ByteRTCMediaDeviceErrorDeviceDisconnected | `13` | - |
  | ByteRTCMediaDeviceErrorDeviceNoCallback | `14` | 无采集数据。当媒体设备的预期行为是正常采集，但没有收到采集数据时，将收到该错误。 |
  | ByteRTCMediaDeviceErrorUNSupportFormat | `15` | 设备采样率不支持 |


## VideoDeviceType 

类型：`enum`

当前视频设备类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | VIDEO_DEVICE_TYPE_UNKNOWN | `0` | 未知设备类型 |
  | VIDEO_DEVICE_TYPE_RENDER_DEVICE | `1` | 视频渲染设备类型 |
  | VIDEO_DEVICE_TYPE_CAPTURE_DEVICE | `2` | 视频采集设备类型 |
  | VIDEO_DEVICE_TYPE_SCREEN_CAPTURE_DEVICE | `3` | 屏幕流视频设备 |


## MediaDeviceWarning 

类型：`enum`

媒体设备警告

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | MEDIA_DEVICE_WARNING_OK | `0` | 无警告 |
  | MEDIA_DEVICE_WARNING_OPERATION_DENIED | `1` | 非法设备操作。在使用外部设备时，调用了 SDK 内部设备 API。 |
  | MEDIA_DEVICE_WARNING_CAPTURE_SILENCE | `2` | 采集到的数据为静音帧。 |
  | MEDIA_DEVICE_WARNING_ANDROID_SYS_SILENCE | `3` | Android 特有的静音，系统层面的静音上报 |
  | MEDIA_DEVICE_WARNING_ANDROID_SYS_SILENCE_DISAPPEAR | `4` | Android 特有的静音消失 |
  | MEDIA_DEVICE_WARNING_DETECT_LEAK_ECHO | `6` | 通话中出现回声现象。
当 [ChannelProfile](#channelprofile) 为 `CHANNEL_PROFIEL_MEETING` 和 `CHANNEL_PROFILE_MEETING_ROOM`，且 AEC 关闭时，SDK 自动启动回声检测，如果检测到回声问题，将通过 `onAudioDeviceWarning` 返回本枚举值。 |
  | MEDIA_DEVICE_WARNING_CAPTURE_DETECT_HOWLING | `11` | 啸叫。触发该回调的情况如下：1）不支持啸叫抑制的房间模式下，检测到啸叫；2）支持啸叫抑制的房间模式下，检测到未被抑制的啸叫。
仅 CHANNEL_PROFILE_COMMUNICATION(0)、CHANNEL_PROFIEL_MEETING(16)、CHANNEL_PROFILE_MEETING_ROOM(17) 三种房间模式支持啸叫抑制。
建议提醒用户检查客户端的距离或将麦克风和扬声器调至静音。 |
  | MEDIA_DEVICE_WARNING_SET_AUDIO_ROUTE_INVALID_SCENARIO | `12` | 当前 AudioScenario 不支持更改音频路由，设置音频路由失败 |
  | MEDIA_DEVICE_WARNING_SET_AUDIO_ROUTE_NOT_EXISTS | `13` | 音频设备不存在，设置音频路由失败 |
  | MEDIA_DEVICE_WARNING_SET_AUDIO_ROUTE_FAILED_BY_PRIORITY | `14` | 音频路由被系统或其他应用占用，设置音频路由失败 |
  | MEDIA_DEVICE_WARNING_SET_AUDIO_ROUTE_NOT_VOIP_MODE | `15` | 当前非通话模式 AUDIO_SCENARIO_COMMUNICATION(2)，不支持设置音频路由 |
  | MEDIA_DEVICE_WARNING_SET_AUDIO_ROUTE_DEVICE_NOT_START | `16` | 音频设备未启动，设置音频路由失败 |
  | ByteRTCMediaDeviceWarningOK | `17` | 无警告 |
  | ByteRTCMediaDeviceWarningOperationDenied | `18` | 非法设备操作。在使用外部设备时，调用了 SDK 内部设备 API。 |
  | ByteRTCMediaDeviceWarningCaptureSilence | `19` | 采集到的数据为静音帧。 |
  | ByteRTCMediaDeviceWarningDetectLeakEcho | `21` | 通话中出现回声现象。
当 ByteRTCRoomProfile 为 `ByteRTCRoomProfileMeeting` 和 `ByteRTCRoomProfileMeetingRoom` ，且 AEC 关闭时，SDK 自动启动回声检测，如果检测到回声问题，将通过 `rtcEngine:onAudioDeviceWarning:deviceType:deviceWarning:` 返回本枚举值。 |
  | ByteRTCMediaDeviceWarningCaptureDetectHowling | `26` | 啸叫。触发该回调的情况如下：1）不支持啸叫抑制的房间模式下，检测到啸叫；2）支持啸叫抑制的房间模式下，检测到未被抑制的啸叫。
仅 ByteRTCRoomProfileCommunication、ByteRTCRoomProfileMeeting、ByteRTCRoomProfileMeetingRoom 三种房间模式支持啸叫抑制。
建议提醒用户检查客户端的距离或将麦克风和扬声器调至静音。 |


## RecordingState 

类型：`enum`

本地录制的状态

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | RECORDING_STATE_PROCESSING | `0` | 录制进行中 |
  | RECORDING_STATE_SUCCESS | `1` | 录制文件保存成功，调用 `stopFileRecording` 结束录制之后才会收到该状态码。 |
  | RECORDING_STATE_ERROE | `2` | 录制异常 |
  | ByteRTCRecordingStateError | `3` | 录制异常 |


## RecordingErrorCode 

类型：`enum`

本地录制的错误码

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | RECORDING_ERROR_CODE_OK | `0` | 录制正常 |
  | RECORDING_ERROR_CODE_NO_PERMISSION | `1` | 没有文件写权限 |
  | RECORDING_ERROR_CODE_NOT_SUPPORT | `2` | 当前版本 SDK 不支持本地录制功能，请联系技术支持人员 |
  | RECORDING_ERROR_CODE_NO_OTHER | `3` | 其他异常 |
  | ByteRTCRecordingErrorCodeOk | `4` | 录制正常 |
  | ByteRTCRecordingErrorCodeNoPermission | `5` | 没有文件写权限 |
  | ByteRTCRecordingErrorCodeNotSupport | `6` | 当前版本 SDK 不支持本地录制功能，请联系技术支持人员 |
  | ByteRTCRecordingErrorCodeOther | `7` | 其他异常 |


## RecordingInfo 

类型：`class`

本地录制的详细信息

### filePath  

类型：string

录制文件的绝对路径，包含文件名和文件后缀

### width  

类型：number

录制视频的宽，单位：像素。纯音频录制请忽略该字段

### height  

类型：number

录制视频的高，单位：像素。纯音频录制请忽略该字段

### ios_codecType  

类型：$p_i.ByteRTCVideoCodecType

录制文件的视频编码类型，参看 ByteRTCVideoCodecType


## RecordingProgress 

类型：`class`

本地录制进度

### new RecordingProgress()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### duration  

类型：number

当前文件的累计录制时长，单位：毫秒

### fileSize  

类型：number

当前录制文件的大小，单位：byte


## AudioRecordingState 

类型：`enum`

录音配置

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | AUDIO_RECORDING_STATE_ERROR | `0` | 录制异常 |
  | AUDIO_RECORDING_STATE_PROCESSING | `1` | 录制进行中 |
  | AUDIO_RECORDING_STATE_SUCCESS | `2` | 已结束录制，并且录制文件保存成功。 |


## LocalAudioPropertiesInfo 

类型：`class`

本地音频属性信息

### new LocalAudioPropertiesInfo()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### streamIndex  

类型：StreamIndex

流属性，主流或屏幕流。参看 [StreamIndex](#streamindex-2)

### audioPropertiesInfo  

类型：AudioPropertiesInfo

音频属性信息，详见 [AudioPropertiesInfo](#audiopropertiesinfo)。


## RemoteAudioPropertiesInfo 

类型：`class`

远端音频属性信息

### new RemoteAudioPropertiesInfo()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### streamKey  

类型：RemoteStreamKey

远端流信息，详见 [RemoteStreamKey](#remotestreamkey)

### audioPropertiesInfo  

类型：AudioPropertiesInfo

音频属性信息，详见 [AudioPropertiesInfo](#audiopropertiesinfo)


## DataMessageSourceType 

类型：`enum`

数据消息来源

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | DATA_MESSAGE_SOURCE_TYPE_DEFAULT | `0` | 通过客户端或服务端的插入的自定义消息。 |
  | DATA_MESSAGE_SOURCE_TYPE_SYSTEM | `1` | 系统数据，包含音量指示信息。 |


## EchoTestResult 

类型：`enum`

音视频回路测试结果

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | ECHO_TEST_SUCCESS | `0` | 接收到采集的音视频的回放，通话回路检测成功 |
  | ECHO_TEST_TIMEOUT | `1` | 测试超过 60s 仍未完成，已自动停止 |
  | ECHO_TEST_INTERVAL_SHORT | `2` | 上一次测试结束和下一次测试开始之间的时间间隔少于 5s |
  | ECHO_TEST_AUDIO_DEVICE_ERROR | `3` | 音频采集异常 |
  | ECHO_TEST_VIDEO_DEVICE_ERROR | `4` | 视频采集异常 |
  | ECHO_TEST_AUDIO_RECEIVE_ERROR | `5` | 音频接收异常 |
  | ECHO_TEST_VIDEO_RECEIVE_ERROR | `6` | 视频接收异常 |
  | ECHO_TEST_INTERNAL_ERROR | `7` | 内部错误，不可恢复 |
  | ByteRTCEchoTestResultSuccess | `8` | 接收到采集的音视频的回放，通话回路检测成功 |
  | ByteRTCEchoTestResultTimeout | `9` | 测试超过 60s 仍未完成，已自动停止 |
  | ByteRTCEchoTestResultIntervalShort | `10` | 上一次测试结束和下一次测试开始之间的时间间隔少于 5s |
  | ByteRTCEchoTestResultAudioDeviceError | `11` | 音频采集异常 |
  | ByteRTCEchoTestResultVideoDeviceError | `12` | 视频采集异常 |
  | ByteRTCEchoTestResultAudioReceiveError | `13` | 音频接收异常 |
  | ByteRTCEchoTestResultVideoReceiveError | `14` | 视频接收异常 |
  | ByteRTCEchoTestResultInternalError | `15` | 内部错误，不可恢复 |


## HardwareEchoDetectionResult 

类型：`enum`

通话前回声检测结果

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | HARDWARE_ECHO_RESULT_CANCELED | `0` | 主动调用 `stopHardwareEchoDetection` 结束流程时，未有回声检测结果。 |
  | HARDWARE_ECHO_RESULT_UNKNOWN | `1` | 未检测出结果。建议重试，如果仍然失败请联系技术支持协助排查。 |
  | HARDWARE_ECHO_RESULT_NORMAL | `2` | 无回声 |
  | HARDWARE_ECHO_RESULT_POOR | `3` | 有回声。可通过 UI 建议用户使用耳机设备入会。 |
  | ByteRTCHardwareEchoDetectionCanceled | `4` | 主动调用 `stopHardwareEchoDetection` 结束流程时，未有回声检测结果。 |
  | ByteRTCHardwareEchoDetectionUnknown | `5` | 未检测出结果。建议重试，如果仍然失败请联系技术支持协助排查。 |
  | ByteRTCHardwareEchoDetectionNormal | `6` | 无回声 |
  | ByteRTCHardwareEchoDetectionPoor | `7` | 有回声。可通过 UI 建议用户使用耳机设备入会。 |


## LocalProxyType 

类型：`enum`

本地代理的类型。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | SOCKS5 | `0` | Socks5 代理。选用此代理服务器，需满足 Socks5 协议标准文档的要求。 |
  | HTTP_TUNNEL | `1` | Http 隧道代理。 |


## LocalProxyState 

类型：`enum`

本地代理连接状态。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | CONNECTED | `0` | 本地代理连接成功。 |
  | ERROR | `1` | 本地代理连接出现错误。 |
  | INITED | `2` | TCP 代理服务器连接成功。 |
  | ByteRTCLocalProxyStateInited | `3` | TCP 代理服务器连接成功。 |


## LocalProxyError 

类型：`enum`

本地代理错误。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | OK | `0` | 本地代理服务器无错误。 |
  | SOCKS5_VERSION_ERROR | `1` | 代理服务器回复的版本号不符合 Socks5 协议标准文档的规定，导致 Socks5 代理连接失败。请检查代理服务器是否存在异常。 |
  | SOCKS5_FORMAT_ERROR | `2` | 代理服务器回复的格式错误不符合 Socks5 协议标准文档的规定，导致 Socks5 代理连接失败。请检查代理服务器是否存在异常。 |
  | SOCKS5_INVALID_VALUE | `3` | 代理服务器回复的字段值不符合 Socks5 协议标准文档的规定，导致 Socks5 代理连接失败。请检查代理服务器是否存在异常。 |
  | SOCKS5_USER_PASS_NOT_GIVEN | `4` | 未提供代理服务器的用户名及密码，导致 Socks5 代理连接失败。请重新调用 `setLocalProxy`，在设置本地代理时填入用户名和密码。 |
  | SOCKS5_TCP_CLOSED | `5` | TCP 关闭，导致 Socks5 代理连接失败。请检查网络或者代理服务器是否存在异常。 |
  | HTTP_TUNNEL_FAILED | `6` | Http 隧道代理错误。请检查 Http 隧道代理服务器或者网络是否存在异常。 |


## MuteState 

类型：`enum`

音视频流的发送/播放状态

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | MUTE_STATE_OFF | `0` | 发送 |
  | MUTE_STATE_ON | `1` | 停止发送 |


## AudioPlaybackDevice 

类型：`enum`

音频播放设备
音频设备变化时 SDK 通过 `onAudioPlaybackDeviceChanged` 回调当前音频播放设备。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | AUDIO_PLAYBACK_DEVICE_HEADSET | `0` | 有线耳机 |
  | AUDIO_PLAYBACK_DEVICE_EARPIECE | `1` | 听筒 |
  | AUDIO_PLAYBACK_DEVICE_SPEAKERPHONE | `2` | 扬声器 |
  | AUDIO_PLAYBACK_DEVICE_HEADSET_BLUETOOTH | `3` | 蓝牙耳机 |
  | AUDIO_PLAYBACK_DEVICE_HEADSET_USB | `4` | USB 设备 |


## MediaDeviceType 

类型：`enum`

媒体设备类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | MEDIA_DEVICE_TYPE_AUDIO_UNKNOWN | `0` | 未知设备 |
  | MEDIA_DEVICE_TYPE_AUDIO_RENDER_DEVICE | `1` | 音频渲染设备 |
  | MEDIA_DEVICE_TYPE_AUDIO_CAPTURE_DEVICE | `2` | 音频采集设备 |
  | MEDIA_DEVICE_TYPE_VIDEO_CAPTURE_DEVICE | `4` | 视频采集设备 |
  | MEDIA_DEVICE_TYPE_SCREEN_VIDEO_CAPTURE_DEVICE | `5` | 屏幕视频设备 |
  | MEDIA_DEVICE_TYPE_SCREEN_AUDIO_CAPTURE_DEVICE | `6` | 屏幕音频设备 |
  | ByteRTCMediaDeviceTypeAudioUnknown | `7` | 未知音频设备 |
  | ByteRTCMediaDeviceTypeAudioRenderDevice | `8` | 音频渲染设备类型 |
  | ByteRTCMediaDeviceTypeAudioCaptureDevice | `9` | 音频采集设备类型 |
  | ByteRTCMediaDeviceTypeVideoCaptureDevice | `11` | - |
  | ByteRTCMediaDeviceTypeScreenVideoCaptureDevice | `12` | 屏幕流视频设备 |
  | ByteRTCMediaDeviceTypeScreenAudioCaptureDevice | `13` | 屏幕流音频设备 |


## AudioMixingState 

类型：`enum`

音频混音文件播放状态。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | AUDIO_MIXING_STATE_PRELOADED | `0` | 混音已加载 |
  | AUDIO_MIXING_STATE_PLAYING | `1` | 混音正在播放 |
  | AUDIO_MIXING_STATE_PAUSED | `2` | 混音暂停 |
  | AUDIO_MIXING_STATE_STOPPED | `3` | 混音停止 |
  | AUDIO_MIXING_STATE_FAILED | `4` | 混音播放失败 |
  | AUDIO_MIXING_STATE_FINISHED | `5` | 混音播放结束 |
  | AUDIO_MIXING_STATE_PCM_ENABLED | `6` | 准备 PCM 混音 |
  | AUDIO_MIXING_STATE_PCM_DISABLED | `7` | PCM 混音播放结束 |


## AudioMixingError 

类型：`enum`

混音错误码。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | AUDIO_MIXING_ERROR_OK | `0` | 正常 |
  | AUDIO_MIXING_ERROR_PRELOAD_FAILED | `1` | 预加载失败。找不到混音文件或者文件长度超出 20s |
  | AUDIO_MIXING_ERROR_START_FAILED | `2` | 混音开启失败。找不到混音文件或者混音文件打开失败 |
  | AUDIO_MIXING_ERROR_SET_POSITION_FAILED | `3` | 设置混音文件的播放位置出错 |
  | AUDIO_MIXING_ERROR_LOAD_CONFLICT | `4` | 播放的文件与预加载的文件不一致。请先使用 unloadAudioMixing 卸载此前的文件。 |
  | AUDIO_MIXING_ERROR_ID_NOT_FOUND | `5` | 混音 ID 异常 |
  | AUDIO_MIXING_ERROR_INVALID_VOLUME | `6` | 音量参数不合法，仅支持设置的音量值为[0, 400] |
  | AUDIO_MIXING_ERROR_ID_TYPE_NOT_MATCH | `7` | 不支持此混音类型。 |
  | AUDIO_MIXING_ERROR_ID_TYPE_INVALID_PITCH | `8` | 设置混音文件的音调不合法 |
  | AUDIO_MIXING_ERROR_INVALID_AUDIO_TRACK | `9` | 设置混音文件的音轨不合法 |
  | AUDIO_MIXING_ERROR_IS_STARTING | `10` | 混音文件正在启动中 |
  | AUDIO_MIXING_ERROR_INVALID_PLAYBACK_SPEED | `11` | 设置混音文件的播放速度不合法 |
  | ByteRTCAudioMixingErrorIdNotFound | `12` | 混音 ID 异常 |
  | ByteRTCAudioMixingErrorInValidVolume | `13` | 音量参数不合法，仅支持设置的音量值为[0, 400] |
  | ByteRTCAudioMixingErrorIdTypeNotMatch | `14` | 不支持此混音类型。 |
  | ByteRTCAudioMixingErrorInValidPitch | `15` | 设置混音文件的音调不合法 |
  | ByteRTCAudioMixingErrorInValidAudioTrack | `16` | 设置混音文件的音轨不合法 |
  | ByteRTCAudioMixingErrorIsStarting | `17` | 混音文件正在启动中 |
  | ByteRTCAudioMixingErrorInValidPlaybackSpeed | `18` | 设置混音文件的播放速度不合法 |


## AudioScenarioType 

类型：`enum`

音频场景类型。
选择音频场景后，SDK 会根据操作系统和开麦、闭麦状态，应用通话音量或媒体音量。参看[通话音量与媒体音量](https://www.volcengine.com/docs/6348/651068)了解更多相关信息。
你可以调用 `setAudioScenario` 设置音频场景。
如果以下音频场景类型无法满足你的业务需要，请联系技术支持人员。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | AUDIO_SCENARIO_MUSIC | `0` | （默认）音乐场景。
此场景适用于对音乐表现力有要求的场景，如音乐直播等。
注意：在此场景下，使用蓝牙耳麦时，会通过手机自带麦克风采集音频。因此，不适用“通话时手机放在包里”等类似场景。使用 `AUDIO_SCENARIO_HIGHQUALITY_COMMUNICATION` 可以不受此限制。
此外，使用扬声器时，开关麦可能发生音量突变。
不同音频设备，开麦和闭麦状态下的使用的音量类型：






闭麦 开麦
内置扬声器 媒体音量 通话音量
内置听筒 通话音量 通话音量
有线耳机/ USB 耳机/ 外置声卡 媒体音量 媒体音量
蓝牙耳机 媒体音量 媒体音量
 |
  | AUDIO_SCENARIO_HIGHQUALITY_COMMUNICATION | `1` | 高质量通话场景。兼顾外放/蓝牙耳机时的音频体验。
此场景适用于对音乐表现力有要求，但又希望能够使用蓝牙耳麦进行音频采集的场景。
注意：在此场景下，使用内置扬声器/听筒时，开关麦可能发生音量突变。使用 `AUDIO_SCENARIO_HIGHQUALITY_CHAT` 可以避免此种情况。
不同音频设备，开麦和闭麦状态下的使用的音量类型：






闭麦 开麦
内置扬声器 媒体音量 通话音量
内置听筒 通话音量 通话音量
有线耳机/ USB 耳机/ 外置声卡 媒体音量 媒体音量
蓝牙耳机 通话音量 通话音量 |
  | AUDIO_SCENARIO_COMMUNICATION | `2` | 纯通话音量场景。
可以最大程度地消除回声，使通话清晰度达到最优。此场景下，无论客户端音频采集播放设备和采集播放状态，全程使用通话音量，不会有音量突变的听感。
适用于需要频繁上下麦的通话或会议场景。
但是，此场景会压低使用媒体音量进行播放的其他音频的音量，且音质会变差。 |
  | AUDIO_SCENARIO_MEDIA | `3` | 媒体场景。
当设备是内置听筒时，使用通话音量。其余情况使用媒体音量。
注意：在此场景下，使用蓝牙耳麦时，会通过手机自带麦克风采集音频。因此，不适用“通话时手机放在包里”等类似场景。
外放通话时，可能出现回声和啸叫，请联系技术支持人员。 |
  | AUDIO_SCENARIO_GAME_STREAMING | `4` | 游戏媒体场景。
若外放通话且无游戏音效消除优化时音质不理想，请联系技术支持人员。
不同音频设备，开麦和闭麦状态下的使用的音量类型：






闭麦 开麦
内置扬声器 媒体音量 媒体音量
听筒 通话音量 通话音量
有线耳机/ USB 耳机/ 外置声卡 媒体音量 媒体音量
蓝牙耳机 通话音量 通话音量 |
  | AUDIO_SCENARIO_HIGHQUALITY_CHAT | `5` | 高质量畅聊场景。
此场景和 `AUDIO_SCENARIO_HIGHQUALITY_COMMUNICATION` 高度类似，唯一的差异在于：此场景下，在使用设备自带的麦克风和扬声器进行通话时，开关麦始终采用通话音量，不会引起音量类型突变。
不同音频设备，开麦和闭麦状态下的使用的音量类型：






闭麦 开麦
内置扬声器 通话音量 通话音量
听筒 通话音量 通话音量
有线耳机/ USB 耳机/ 外置声卡 媒体音量 媒体音量
蓝牙耳机 通话音量 通话音量 |


## AudioProfileType 

类型：`enum`

音质档位

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | AUDIO_PROFILE_DEFAULT | `0` | 默认音质
服务器下发或客户端已设置的 [ChannelProfile](#channelprofile) 的音质配置 |
  | AUDIO_PROFILE_FLUENT | `1` | 流畅。
单声道，采样率为 16 kHz，编码码率为 32 Kbps。
流畅优先、低功耗、低流量消耗，适用于大部分游戏场景，如小队语音、组队语音、国战语音等。 |
  | AUDIO_PROFILE_STANDARD | `2` | 单声道标准音质。
采样率为 24 kHz，编码码率为 48 Kbps。
适用于对音质有一定要求的场景，同时延时、功耗和流量消耗相对适中，适合教育场景和狼人杀等游戏。 |
  | AUDIO_PROFILE_HD | `3` | 双声道音乐音质
采样率为 48 kHz，编码码率为 128 kbps。
超高音质，同时延时、功耗和流量消耗相对较大，适用于连麦 PK 等音乐场景。
游戏场景不建议使用。 |
  | AUDIO_PROFILE_STANDARD_STEREO | `4` | 双声道标准音质。采样率为 48 KHz，编码码率最大值为 80 Kbps |
  | AUDIO_PROFILE_HD_MONO | `5` | 单声道音乐音质。采样率为 48 kHz，编码码率最大值为 64 Kbps |


## AnsMode 

类型：`enum`

降噪模式。降噪算法受调用 joinRoom 时设置的房间模式影响。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | ANS_MODE_DISABLE | `0` | 关闭所有音频降噪能力。 |
  | ANS_MODE_LOW | `1` | 适用于微弱降噪。 |
  | ANS_MODE_MEDIUM | `2` | 适用于抑制中度平稳噪声，如空调声和风扇声。 |
  | ANS_MODE_HIGH | `3` | 适用于抑制嘈杂非平稳噪声，如键盘声、敲击声、碰撞声、动物叫声。 |
  | ANS_MODE_AUTOMATIC | `4` | 启用音频降噪能力。具体的降噪算法由 RTC 智能决策。 |


## VoiceChangerType 

类型：`enum`

变声特效类型。如需更多变声特效类型，联系技术支持。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | VOICE_CHANGER_ORIGINAL | `0` | 原声，不含特效 |
  | VOICE_CHANGER_GIANT | `1` | 巨人 |
  | VOICE_CHANGER_CHIPMUNK | `2` | 花栗鼠 |
  | VOICE_CHANGER_MINIONST | `3` | 小黄人 |
  | VOICE_CHANGER_VIBRATO | `4` | 颤音 |
  | VOICE_CHANGER_ROBOT | `5` | 机器人 |


## VoiceReverbType 

类型：`enum`

混响特效类型。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | VOICE_REVERB_ORIGINAL | `0` | 原声，不含特效 |
  | VOICE_REVERB_ECHO | `1` | 回声 |
  | VOICE_REVERB_CONCERT | `2` | 演唱会 |
  | VOICE_REVERB_ETHEREAL | `3` | 空灵 |
  | VOICE_REVERB_KTV | `4` | KTV |
  | VOICE_REVERB_STUDIO | `5` | 录音棚 |
  | VOICE_REVERB_VIRTUAL_STEREO | `6` | 虚拟立体声 |
  | VOICE_REVERB_SPACIOUS | `7` | 空旷 |
  | VOICE_REVERB_3D | `8` | 3D 人声 |


## VoiceEqualizationConfig 

类型：`class`

语音均衡效果。

### new VoiceEqualizationConfig()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return ();
```
  

### frequency  

类型：BandFrequency

频带。参看 VoiceEqualizationBandFrequency。

### gain  

类型：number

频带增益（dB）。取值范围是 `[-15, 15]`。


## VoiceReverbConfig 

类型：`class`

音频混响效果。

### new VoiceReverbConfig()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### roomSize  

类型：number

混响模拟的房间大小，取值范围 `[0.0, 100.0]`。默认值为 `50.0f`。房间越大，混响越强。

### decayTime  

类型：number

混响的拖尾长度，取值范围 `[0.0, 100.0]`。默认值为 `50.0f`。

### damping  

类型：number

混响的衰减阻尼大小，取值范围 `[0.0, 100.0]`。默认值为 `50.0f`。

### wetGain  

类型：number

早期反射信号强度。取值范围 `[-20.0, 10.0]`，单位为 dB。默认值为 `0.0f`。

### dryGain  

类型：number

原始信号强度。取值范围 `[-20.0, 10.0]`，单位为 dB。默认值为 `0.0f`。

### preDelay  

类型：number

早期反射信号的延迟。取值范围 `[0.0, 200.0]`，单位为 ms。默认值为 `0.0f`。


## VideoCanvas 

类型：`class`

视频帧渲染设置

### new VideoCanvas()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### android_renderView  

类型：unknown

本地视图句柄。
渲染 View 对象时，使用此字段，并将 `renderSurface` 设置为 `null`。

### android_renderSurface  

类型：unknown

本地 surface 句柄。
渲染 Surface 对象时，使用此字段，并将 `renderView` 设置为 `null`。

### renderMode  

类型：RenderMode

渲染模式，可选 `RENDER_MODE_HIDDEN(1)`, `RENDER_MODE_FIT(2)` 和 `RENDER_MODE_FILL(3)`。默认值为 `RENDER_MODE_HIDDEN(1)`。

### backgroundColor  

类型：number

用于填充画布空白部分的背景颜色。取值范围是 `[0x00000000, 0xFFFFFFFF]`。默认值是 `0x00000000`。其中，透明度设置无效。

### renderRotation  

类型：VideoRotation

视频帧旋转角度。参看 [VideoRotation](#videorotation)。默认为 0 度，即不做旋转处理。
该设置仅对远端视频有效，对本地视频设置不生效。

### ios_view  

类型：$p_i.ByteRTCView

本地视图句柄


## RemoteVideoRenderConfig 

类型：`class`

远端视频帧渲染设置

### new RemoteVideoRenderConfig()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### renderMode  

类型：RenderMode

渲染模式。
- 1（`RENDER_MODE_HIDDEN`）：视窗填满优先，默认值。视频帧等比缩放，直至视窗被视频填满。如果视频帧长宽比例与视窗不同，视频帧的多出部分将无法显示。缩放完成后，视频帧的一边长和视窗的对应边长一致，另一边长大于等于视窗对应边长。
- 2（`RENDER_MODE_FIT`）：视频帧内容全部显示优先。视频帧等比缩放，直至视频帧能够在视窗上全部显示。如果视频帧长宽比例与视窗不同，视窗上未被视频帧填满区域将填充 `backgroundColor`。缩放完成后，视频帧的一边长和视窗的对应边长一致，另一边长小于等于视窗对应边长。
- 3（`RENDER_MODE_FILL`）：视频帧自适应画布。视频帧非等比缩放，直至画布被填满。在此过程中，视频帧的长宽比例可能会发生变化。

### backgroundColor  

类型：number

用于填充画布空白部分的背景颜色。取值范围是 `[0x00000000, 0xFFFFFFFF]`。默认值是 `0x00000000`。其中，透明度设置无效。

### renderRotation  

类型：VideoRotation

视频帧旋转角度。参看 [VideoRotation](#videorotation)。默认为 0 度，即不做旋转处理。


## VideoSuperResolutionMode 

类型：`enum`

超分模式。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | VIDEO_SUPER_RESOLUTION_MODE_OFF | `0` | 关闭超分。 |
  | VIDEO_SUPER_RESOLUTION_MODE_ON | `1` | 开启超分。 |


## MirrorType 

类型：`enum`

镜像类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | MIRROR_TYPE_NONE | `0` | 本地预览和编码传输时均无镜像效果 |
  | MIRROR_TYPE_RENDER | `1` | 本地预览时有镜像效果，编码传输时无镜像效果 |
  | MIRROR_TYPE_RENDER_AND_ENCODER | `2` | 本地预览和编码传输时均有镜像效果 |


## RemoteMirrorType 

类型：`enum`

远端流的镜像类型。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | NONE | `0` | （默认值）远端视频渲染无镜像效果。 |
  | RENDER | `1` | 远端视频渲染有镜像效果。 |


## VideoRotationMode 

类型：`enum`

视频旋转模式

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | FOLLOW_APP | `0` | App 方向 |
  | FOLLOW_GSENSOR | `1` | 重力方向 |


## CameraId 

类型：`enum`

摄像头类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | CAMERA_ID_FRONT | `0` | 前置摄像头 |
  | CAMERA_ID_BACK | `1` | 后置摄像头（默认设置） |
  | CAMERA_ID_INVALID | `2` | 无效值 |


## MessageConfig 

类型：`enum`

发送消息的可靠有序性

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | RELIABLE_ORDERED | `0` | 低延时可靠有序消息 |
  | UNRELIABLE_ORDERED | `1` | 超低延时有序消息 |
  | UNRELIABLE_UNORDERED | `2` | 超低延时无序消息 |


## AudioFrameCallbackMethod 

类型：`enum`

音频回调方法

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | AUDIO_FRAME_CALLBACK_RECORD | `0` | 本地麦克风录制的音频数据回调 |
  | AUDIO_FRAME_CALLBACK_PLAYBACK | `1` | 订阅的远端所有用户混音后的音频数据回调 |
  | AUDIO_FRAME_CALLBACK_MIXED | `2` | 本地麦克风录制和订阅的远端所有用户混音后的音频数据回调 |
  | AUDIO_FRAME_CALLBACK_REMOTE_USER | `3` | 订阅的远端每个用户混音前的音频数据回调 |


## AudioFormat 

类型：`class`

音频参数格式

### new AudioFormat()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### sampleRate  

类型：AudioSampleRate

音频采样率，参看 [AudioSampleRate](#audiosamplerate)。

### channel  

类型：AudioChannel

音频声道，参看 [AudioChannel](#audiochannel)。

### samplesPerCall  

类型：number

单次回调的音频帧中包含的采样点数。默认值为 `0`，此时，采样点数取最小值。
最小值为回调间隔是 0.01s 时的值，即 `sampleRate * channel * 0.01s`。
最大值是 `2048`。超出取值范围时，采样点数取默认值。
该参数仅在设置读写回调时生效，调用 enableAudioFrameCallback 开启只读模式回调时设置该参数不生效。


## IAudioFrame 

类型：`class`

音频数据

### ios_buffer  

类型：ArrayBuffer

PCM 数据

### ios_samples  

类型：number

采样点个数

### ios_sampleRate  

类型：$p_i.ByteRTCAudioSampleRate

采样率，参看 ByteRTCAudioSampleRate。

### android_timestamp_us()  

获取音频帧时间戳。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number  音频帧时间戳，单位：微秒。

### android_sample_rate()  

获取音频采样率，参看 [AudioSampleRate](#audiosamplerate)。

**类型**

  ```ts
  () => $p_a.AudioSampleRate
  ```

**返回值**

  $p_a.AudioSampleRate  音频采样率

### channel()  

获取音频声道，参看 [AudioChannel](#audiochannel)。

**类型**

  ```ts
  () => AudioChannel
  ```

**返回值**

  [AudioChannel](#audiochannel)  音频声道

### android_getDataBuffer()  

获取音频帧内存块地址

**类型**

  ```ts
  () => $p_a.ByteBuffer
  ```

**返回值**

  $p_a.ByteBuffer  音频帧的 ByteBuffer

### android_data_size()  

获取音频帧数据大小。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number  音频帧数据大小，单位：字节。

### android_frame_type()  

获取音频帧类型，目前只支持 PCM，参看 AudioFrameType。

**类型**

  ```ts
  () => $p_a.AudioFrameType
  ```

**返回值**

  $p_a.AudioFrameType  音频帧类型

### android_release()  

释放音频帧。

**类型**

  ```ts
  () => void
  ```


## AudioChannel 

类型：`enum`

音频声道。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | AUDIO_CHANNEL_AUTO | `0` | 默认设置。双声道。 |
  | AUDIO_CHANNEL_MONO | `1` | 单声道 |
  | AUDIO_CHANNEL_STEREO | `2` | 双声道 |


## ZoomConfigType 

类型：`enum`

数码变焦参数类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | ZOOM_FOCUS_OFFSET | `0` | 设置缩放系数 |
  | ZOOM_MOVE_OFFSET | `1` | 设置移动步长 |
  | ByteRTCZoomConfigTypeFocusOffset | `2` | 设置缩放系数 |
  | ByteRTCZoomConfigTypeMoveOffset | `3` | 设置移动步长 |


## ZoomDirectionType 

类型：`enum`

数码变焦操作类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | CAMERA_MOVE_LEFT | `0` | 相机向左移动 |
  | CAMERA_MOVE_RIGHT | `1` | 相机向右移动 |
  | CAMERA_MOVE_UP | `2` | 相机向上移动 |
  | CAMERA_MOVE_DOWN | `3` | 相机向下移动 |
  | CAMERA_ZOOM_OUT | `4` | 相机缩小焦距 |
  | CAMERA_ZOOM_IN | `5` | 相机放大焦距 |
  | CAMERA_RESET | `6` | 恢复到原始大小 |
  | ByteRTCZoomDirectionTypeMoveLeft | `7` | 相机向左移动 |
  | ByteRTCZoomDirectionTypeMoveRight | `8` | 相机向右移动 |
  | ByteRTCZoomDirectionTypeMoveUp | `9` | 相机向上移动 |
  | ByteRTCZoomDirectionTypeMoveDown | `10` | 相机向下移动 |
  | ByteRTCZoomDirectionTypeZoomOut | `11` | 相机缩小焦距 |
  | ByteRTCZoomDirectionTypeZoomIn | `12` | 相机放大焦距 |
  | ByteRTCZoomDirectionTypeReset | `13` | 恢复到原始画面 |


## RTCEncodedVideoFrame 

类型：`class`

视频帧信息

### android_buffer  

类型：ArrayBuffer

视频帧数据指针地址
buffer 为 Direct 类型且 size 需和 capacity 相等

### timestampUs  

类型：number

视频采集时间戳，单位：微秒

### timestampDtsUs  

类型：number

视频编码时间戳，单位：微秒

### width  

类型：number

视频分辨率的宽度，单位：px

### height  

类型：number

视频分辨率的高度，单位：px

### android_videoPictureType  

类型：$p_a.VideoPictureType

视频帧类型。参看 [VideoPictureType](#videopicturetype)

### android_videoRotation  

类型：$p_a.VideoRotation

视频帧旋转角度，默认旋转 0 度。参看 [VideoRotation](#videorotation)

### ios_codecType  

类型：$p_i.ByteRTCVideoCodecType

视频编码类型。参看 ByteRTCVideoCodecType

### ios_pictureType  

类型：$p_i.ByteRTCVideoPictureType

视频帧类型。参看 ByteRTCVideoPictureType

### ios_rotation  

类型：$p_i.ByteRTCVideoRotation

视频帧旋转角度。参看 ByteRTCVideoRotation

### ios_data  

类型：ArrayBuffer

视频帧数据指针地址


## VideoSourceType 

类型：`enum`

视频输入源类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | VIDEO_SOURCE_TYPE_EXTERNAL | `0` | 自定义采集视频源 |
  | VIDEO_SOURCE_TYPE_INTERNAL | `1` | 内部采集视频源 |
  | VIDEO_SOURCE_TYPE_ENCODED_WITH_SIMULCAST | `2` | 自定义编码视频源。
你仅需推送分辨率最大的一路编码后视频流，SDK 将自动转码生成多路小流 |
  | VIDEO_SOURCE_TYPE_ENCODED_WITHOUT_SIMULCAST | `3` | 自定义编码视频源。
SDK 不会自动生成多路流，你需要自行生成并推送多路流 |


## MixedStreamConfig 

类型：`class`

转推直播配置参数。

### ios_expectedMixingType  

类型：$p_i.ByteRTCMixedStreamType

合流类型，详见 ByteRTCMixedStreamType 数据类型。建议设置。

### ios_layoutConfig  

类型：$p_i.ByteRTCMixedStreamLayoutConfig

视频流合流整体布局信息。建议设置。
开启转推直播功能后，你可以设置参与合流的每路视频流的预设布局信息和合流背景信息等。详见 ByteRTCMixedStreamLayoutConfig 数据类型。

### ios_videoConfig  

类型：$p_i.ByteRTCMixedStreamVideoConfig

视频转码配置参数。详见 ByteRTCMixedStreamVideoConfig 数据类型。建议设置。

### ios_audioConfig  

类型：$p_i.ByteRTCMixedStreamAudioConfig

音频合流配置参数，参看 ByteRTCMixedStreamAudioConfig。建议设置。

### ios_clientMixConfig  

类型：$p_i.ByteRTCMixedStreamClientMixConfig

客户端合流配置。详见 ByteRTCMixedStreamClientMixConfig 。建议设置。

### ios_serverControlConfig  

类型：$p_i.ByteRTCMixedStreamServerControlConfig

服务端合流控制参数。详见 ByteRTCMixedStreamServerControlConfig 。

### ios_pushURL  

类型：string

推流 CDN 地址。仅支持 RTMP 协议，Url 必须满足正则 `/^rtmps?:\\/\\//`。建议设置。
本参数不支持过程中更新。

### ios_roomID  

类型：string

推流房间 ID。`roomID` 和 `userID` 长度相加不得超过 126 字节。建议设置。
本参数不支持过程中更新。

### ios_userID  

类型：string

推流用户 ID。`roomID` 和 `userID` 长度相加不得超过 126 字节。建议设置。
本参数不支持过程中更新。

### android_setUserID()  

设置推流用户 ID。本参数不支持过程中更新。建议设置。

**类型**

  ```ts
  (userID: string) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"userID","Type":"string","Required":"是","Default":"无","Description":"推流用户 ID。roomId 和 userId 长度相加不得超过 126 字节。\n","children":[],"key":"userID"}]
      return (
);
```
  

**返回值**

  this

### android_getUserID()  

获取推流用户 ID。

**类型**

  ```ts
  () => string
  ```

**返回值**

  string

### android_setRoomID()  

设置推流用户所在的房间 ID。本参数不支持过程中更新。建议设置。

**类型**

  ```ts
  (roomID: string) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"roomID","Type":"string","Required":"是","Default":"无","Description":"推流用户所在的房间 ID。roomId 和 userId 长度相加不得超过 126 字节。\n","children":[],"key":"roomID"}]
      return (
);
```
  

**返回值**

  this

### android_getRoomID()  

获取推流用户所在的房间 ID。

**类型**

  ```ts
  () => string
  ```

**返回值**

  string

### android_setPushURL()  

设置推流 CDN 地址。仅支持 RTMP 协议，Url 必须满足正则 `/^rtmps?:\\/\\//`。建议设置。
本参数不支持过程中更新。

**类型**

  ```ts
  (pushURL: string) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"pushURL","Type":"string","Required":"是","Default":"无","Description":"推流 CDN 地址。\n","children":[],"key":"pushURL"}]
      return (
);
```
  

**返回值**

  this

### android_getPushURL()  

获取推流 CDN 地址。

**类型**

  ```ts
  () => string
  ```

**返回值**

  string

### android_setExpectedMixingType()  

设置合流类型。建议设置。

**类型**

  ```ts
  (expectedMixingType: $p_a.ByteRTCStreamMixingType) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"expectedMixingType","Type":"$p_a.ByteRTCStreamMixingType","Required":"是","Default":"无","Description":"合流类型，参看 ByteRTCStreamMixingType。\n","children":[],"key":"expectedMixingType"}]
      return (
);
```
  

**返回值**

  this

### android_getExpectedMixingType()  

获取合流类型。

**类型**

  ```ts
  () => $p_a.ByteRTCStreamMixingType
  ```

**返回值**

  $p_a.ByteRTCStreamMixingType

### android_setAudioConfig()  

设置音频转码配置参数。建议设置。

**类型**

  ```ts
  (audioConfig: $p_a.MixedStreamAudioConfig) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"audioConfig","Type":"$p_a.MixedStreamAudioConfig","Required":"是","Default":"无","Description":"音频转码配置参数，参看 MixedStreamAudioConfig。\n","children":[],"key":"audioConfig"}]
      return (
);
```
  

**返回值**

  this

### android_getAudioConfig()  

获取音频转码配置参数。

**类型**

  ```ts
  () => $p_a.MixedStreamAudioConfig
  ```

**返回值**

  $p_a.MixedStreamAudioConfig

### android_setServerControlConfig()  

设置服务端合流控制参数。

**类型**

  ```ts
  (serverControlConfig: $p_a.MixedStreamServerControlConfig) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"serverControlConfig","Type":"$p_a.MixedStreamServerControlConfig","Required":"是","Default":"无","Description":"服务端合流控制参数，参看 MixedStreamServerControlConfig。\n","children":[],"key":"serverControlConfig"}]
      return (
);
```
  

**返回值**

  this

### android_getServerControlConfig()  

获取服务端合流控制参数的设置。

**类型**

  ```ts
  () => $p_a.MixedStreamServerControlConfig
  ```

**返回值**

  $p_a.MixedStreamServerControlConfig

### android_setVideoConfig()  

设置视频转码配置参数。建议设置。

**类型**

  ```ts
  (videoConfig: $p_a.MixedStreamVideoConfig) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"videoConfig","Type":"$p_a.MixedStreamVideoConfig","Required":"是","Default":"无","Description":"视频转码配置参数。详见 MixedStreamVideoConfig 数据类型。\n","children":[],"key":"videoConfig"}]
      return (
);
```
  

**返回值**

  this

### android_getVideoConfig()  

获取视频转码配置参数。

**类型**

  ```ts
  () => $p_a.MixedStreamVideoConfig
  ```

**返回值**

  $p_a.MixedStreamVideoConfig

### android_setClientMixConfig()  

设置客户端合流配置参数。建议设置。

**类型**

  ```ts
  (clientMixConfig: $p_a.MixedStreamClientMixConfig) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"clientMixConfig","Type":"$p_a.MixedStreamClientMixConfig","Required":"是","Default":"无","Description":"客户端合流配置参数。详见 MixedStreamClientMixConfig 数据类型。\n","children":[],"key":"clientMixConfig"}]
      return (
);
```
  

**返回值**

  this

### android_setSpatialConfig()  

设置推流 CDN 的空间音频参数。

**类型**

  ```ts
  (spatialConfig: $p_a.MixedStreamSpatialConfig) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"spatialConfig","Type":"$p_a.MixedStreamSpatialConfig","Required":"是","Default":"无","Description":"空间音频参数。详见 MixedStreamSpatialConfig 数据类型。\n","children":[],"key":"spatialConfig"}]
      return (
);
```
  

**返回值**

  this

### android_getSpatialConfig()  

获取推流 CDN 的空间音频参数。

**类型**

  ```ts
  () => $p_a.MixedStreamSpatialConfig
  ```

**返回值**

  $p_a.MixedStreamSpatialConfig

### android_setLayout()  

设置视频流合流整体布局信息。建议设置。

**类型**

  ```ts
  (layout: $p_a.MixedStreamLayoutConfig) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"layout","Type":"$p_a.MixedStreamLayoutConfig","Required":"是","Default":"无","Description":"视频流合流整体布局参数，参看 MixedStreamLayoutConfig。\n","children":[],"key":"layout"}]
      return (
);
```
  

**返回值**

  this

### android_getLayout()  

获取视频流合流整体布局信息。

**类型**

  ```ts
  () => $p_a.MixedStreamLayoutConfig
  ```

**返回值**

  $p_a.MixedStreamLayoutConfig

### android_getMixedStreamVideoConfigBFrame()  

**类型**

  ```ts
  () => boolean
  ```

**返回值**

  boolean

### `static` defaultMixedStreamConfig()  

获取默认的转推直播配置参数。

**类型**

  ```ts
  () => MixedStreamConfig
  ```

**返回值**

  [MixedStreamConfig](#mixedstreamconfig)  默认的转推直播配置参数。参看 [MixedStreamConfig](#mixedstreamconfig)。


## ByteRTCStreamMixingEvent 

类型：`enum`

转推直播任务状态

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | STREAM_MIXING_START | `0` | 请求发起转推直播任务 |
  | STREAM_MIXING_START_SUCCESS | `1` | 发起转推直播任务成功 |
  | STREAM_MIXING_START_FAILED | `2` | 发起转推直播任务失败 |
  | STREAM_MIXING_UPDATE | `3` | 请求更新转推直播任务配置 |
  | STREAM_MIXING_UPDATE_SUCCESS | `4` | 成功更新转推直播任务配置 |
  | STREAM_MIXING_UPDATE_FAILED | `5` | 更新转推直播任务配置失败 |
  | STREAM_MIXING_STOP | `6` | 请求结束转推直播任务 |
  | STREAM_MIXING_STOP_SUCCESS | `7` | 结束转推直播任务成功 |
  | STREAM_MIXING_STOP_FAILED | `8` | 结束转推直播任务失败 |
  | STREAM_MIXING_CHANGE_MIX_TYPE | `9` | 更新转推直播任务配置的请求超时 |
  | STREAM_MIXING_FIRST_AUDIO_FRAME_BY_CLIENT_MIX | `10` | 得到客户端合流音频首帧 |
  | STREAM_MIXING_FIRST_VIDEO_FRAME_BY_CLIENT_MIX | `11` | 收到客户端合流视频首帧 |
  | STREAM_MIXING_UPDATE_TIMEOUT | `12` | 更新转推直播任务配置超时 |
  | STREAM_MIXING_START_TIMEOUT | `13` | 发起转推直播任务配置超时 |
  | STREAM_MIXING_REQUEST_PARAM_ERROR | `14` | 合流布局参数错误 |
  | STREAM_MIXING_MIX_IMAGE_EVENT | `15` | 合流加图片 |
  | ByteRTCStreamMixingEventStart | `17` | 请求发起转推直播任务 |
  | ByteRTCStreamMixingEventStartSuccess | `18` | 发起转推直播任务成功 |
  | ByteRTCStreamMixingEventStartFailed | `19` | 发起转推直播任务失败 |
  | ByteRTCStreamMixingEventUpdate | `20` | 请求更新转推直播任务配置 |
  | ByteRTCStreamMixingEventUpdateSuccess | `21` | 成功更新转推直播任务配置 |
  | ByteRTCStreamMixingEventUpdateFailed | `22` | 更新转推直播任务配置失败 |
  | ByteRTCStreamMixingEventStop | `23` | 请求结束转推直播任务 |
  | ByteRTCStreamMixingEventStopSuccess | `24` | 结束转推直播任务成功 |
  | ByteRTCStreamMixingEventStopFailed | `25` | 结束转推直播任务失败 |
  | ByteRTCStreamMixingEventChangeMixType | `26` | 更新转推直播任务配置的请求超时 |
  | ByteRTCStreamMixingEventFirstAudioFrameByClientMixer | `27` | 得到客户端合流音频首帧 |
  | ByteRTCStreamMixingEventFirstVideoFrameByClientMixer | `28` | 收到客户端合流视频首帧 |
  | ByteRTCStreamMixingEventUpdateTimeout | `29` | 更新转推直播任务配置超时 |
  | ByteRTCStreamMixingEventStartTimeout | `30` | 发起转推直播任务配置超时 |
  | ByteRTCStreamMixingEventRequestParamError | `31` | 合流布局参数错误 |
  | ByteRTCStreamMixingEventMixImage | `32` | 合流加图片 |


## MixedStreamType 

类型：`enum`

合流类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | MIXED_STREAM_TYPE_BY_SERVER | `0` | 服务端合流。 |
  | MIXED_STREAM_TYPE_BY_CLIENT | `1` | 保留字段，无意义 |
  | ByteRTCMixedStreamByServer | `2` | 通过服务端合流 |
  | ByteRTCMixedStreamByClient | `3` | 保留字段，无意义 |


## PushSingleStreamParam 

类型：`class`

单流转推直播配置参数。

### new PushSingleStreamParam()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### roomId  

类型：string

媒体流所在的房间 ID

### userId  

类型：string

媒体流所属的用户 ID

### url  

类型：string

推流 CDN 地址。仅支持 RTMP 协议，Url 必须满足正则 `/^rtmps?:\\/\\//`。
本参数不支持过程中更新。

### isScreen  

类型：boolean

媒体流是否为屏幕流。


## VideoCaptureConfig 

类型：`class`

视频采集配置

### new VideoCaptureConfig()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### android_capturePreference  

类型：$p_a.CapturePreference

视频采集模式，参看 CapturePreference。

### android_width  

类型：number

视频采集分辨率的宽度，单位：px。

### android_height  

类型：number

视频采集分辨率的高度，单位：px。

### frameRate  

类型：number

视频采集帧率，单位：fps。

### ios_preference  

类型：$p_i.ByteRTCVideoCapturePreference

视频采集模式，参看 ByteRTCVideoCapturePreference

### ios_videoSize  

类型：any

视频采集分辨率


## VideoEncoderConfig 

类型：`class`

视频流参数描述

### new VideoEncoderConfig()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### width  

类型：number

视频宽度，单位：px

### height  

类型：number

视频高度，单位：px

### frameRate  

类型：number

视频帧率，单位：fps

### maxBitrate  

类型：number

最大编码码率，使用 SDK 内部采集时可选设置，自定义采集时必须设置，单位：kbps。
设为 `-1` 即适配码率模式，系统将根据输入的分辨率和帧率自动计算适用的码率。
设为 `0` 则不对视频流进行编码发送。
3.44.1 及以上版本，内部采集时默认值为 `-1`，3.44.1 以前版本无默认值，需手动设置。

### minBitrate  

类型：number

视频最小编码码率, 单位 kbps。编码码率不会低于 `minBitrate`。
默认值为 `0`。
范围：[0, maxBitrate)，当 `maxBitrate` < `minBitrate` 时，为适配码率模式。
以下情况，设置本参数无效：
- 当 `maxBitrate` 为 `0` 时，不对视频流进行编码发送。
- 当 `maxBitrate` < `0` 时，适配码率模式。

### android_encodePreference  

类型：$p_a.EncoderPreference

编码策略偏好，默认为帧率优先。参看 EncoderPreference。

### ios_encoderPreference  

类型：$p_i.ByteRTCVideoEncoderPreference

编码策略偏好，默认为帧率优先。参看 ByteRTCVideoEncoderPreference。


## ScreenVideoEncoderConfig 

类型：`class`

屏幕流编码配置。
推荐配置参数参看 [屏幕共享](https://www.volcengine.com/docs/6348/124176)。

### new ScreenVideoEncoderConfig()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### encodePreference  

类型：RTCScreenVideoEncoderPreference

屏幕流编码模式。默认为流畅模式。参看 EncoderPreference。

### width  

类型：number

视频最大宽度，单位：像素。

### height  

类型：number

视频最大高度，单位：像素。

### frameRate  

类型：number

视频采集和编码帧率，单位：fps。

### maxBitrate  

类型：number

最大编码码率，使用 SDK 内部采集时可选设置，自定义采集时必须设置，单位：kbps。
设为 -1 即适配码率模式，系统将根据输入的分辨率和帧率自动计算适用的码率。
设为 0 则不对视频流进行编码发送。
3.44 及以上版本，内部采集时默认值为 -1，3.44 以前版本无默认值，需手动设置。

### minBitrate  

类型：number

最小编码码率，使用 SDK 内部采集时可选设置，自定义采集时必须设置，单位：kbps。
最小编码码率必须小于或等于最大编码，否则不对视频流进行编码发送。


## AudioSourceType 

类型：`enum`

音频输入源类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | AUDIO_SOURCE_TYPE_EXTERNAL | `0` | 自定义采集音频源 |
  | AUDIO_SOURCE_TYPE_INTERNAL | `1` | RTC SDK 内部采集音频源 |


## AudioRenderType 

类型：`enum`

音频输出源类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | AUDIO_RENDER_TYPE_EXTERNAL | `0` | 自定义渲染 |
  | AUDIO_RENDER_TYPE_INTERNAL | `1` | 内部渲染 |
  | ByteRTCAudioRenderTypeInternal | `2` | RTC SDK 内部渲染音频 |


## AudioFrame 

类型：`class`

PCM 音频帧

### new AudioFrame()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### buffer  

类型：ArrayBuffer

PCM 数据

### samples  

类型：number

采样点个数

### sampleRate  

类型：AudioSampleRate

采样率，参看 [AudioSampleRate](#audiosamplerate)。

### channel  

类型：AudioChannel

音频声道，参看 [AudioChannel](#audiochannel)。


## RTCRoomStats 

类型：`class`

通话相关的统计信息

### new RTCRoomStats()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### txKBitRate  

类型：number

发送码率（kbps），获取该数据时的瞬时值

### rxKBitRate  

类型：number

接收码率（kbps），获取该数据时的瞬时值

### txAudioKBitRate  

类型：number

音频包的发送码率（kbps），获取该数据时的瞬时值

### rxAudioKBitRate  

类型：number

音频接收码率（kbps），获取该数据时的瞬时值

### txVideoKBitRate  

类型：number

视频发送码率（kbps），获取该数据时的瞬时值

### rxVideoKBitRate  

类型：number

视频接收码率（kbps），获取该数据时的瞬时值

### txScreenKBitRate  

类型：number

屏幕发送码率（kbps），获取该数据时的瞬时值

### rxScreenKBitRate  

类型：number

屏幕接收码率（kbps），获取该数据时的瞬时值

### android_totalDuration  

类型：number

进房到退房之间累计时长，单位为 s

### txBytes  

类型：number

本地用户的总发送字节数 (bytes)，累计值

### rxBytes  

类型：number

本地用户的总接收字节数 (bytes)，累计值

### android_users  

类型：number

当前房间内的可见用户人数。

### android_cpuTotalUsage  

类型：number

当前系统的 CPU 使用率 (\%)

### android_cpuAppUsage  

类型：number

当前应用的 CPU 使用率 (\%)

### txLostrate  

类型：number

当前应用的上行丢包率，取值范围为 [0, 1]

### rxLostrate  

类型：number

当前应用的下行丢包率，取值范围为 [0, 1]

### rtt  

类型：number

客户端到服务端数据传输的往返时延（单位 ms）

### txCellularKBitrate  

类型：number

蜂窝路径发送的码率 (kbps)，为获取该数据时的瞬时值

### rxCellularKBitrate  

类型：number

蜂窝路径接收码率 (kbps)，为获取该数据时的瞬时值

### ios_duration  

类型：number

用户进房开始通话后的总时长，单位为 s ，累计值

### ios_userCount  

类型：number

当前房间内的可见用户人数，包括本地用户自身

### android_reset()  

重置所有的 [RTCRoomStats](#rtcroomstats) 成员变量的值，重新开始统计。

**类型**

  ```ts
  () => void
  ```


## AVSyncState 

类型：`enum`

音视频同步状态

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | AV_SYNC_STATE_AUDIO_STREAM_REMOVE | `0` | 音视频同步过程中音频移除，但不影响当前的同步关系 |
  | AV_SYNC_STATE_VIDEO_STREAM_REMOVE | `1` | 音视频同步过程中视频移除，但不影响当前的同步关系 |
  | AV_SYNC_STATE_STREAM_SYNC_BEGIN | `2` | 音视频开始同步 |


## UserInfo 

类型：`class`

用户信息

### new UserInfo()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### userId  

类型：string

用户 ID。该字符串符合正则表达式：`[a-zA-Z0-9_\@\\-\\.]{1,128}`。
你需要自行设置或管理 uid，并保证同一房间内每个 uid 的唯一性。

### extraInfo  

类型：string

用户的额外信息，最大长度为 200 字节。会在 `onUserJoined` 中回调给远端用户。


## MediaStreamType 

类型：`enum`

媒体流类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | RTC_MEDIA_STREAM_TYPE_AUDIO | `0` | 只控制音频 |
  | RTC_MEDIA_STREAM_TYPE_VIDEO | `1` | 只控制视频 |
  | RTC_MEDIA_STREAM_TYPE_BOTH | `2` | 同时控制音频和视频 |


## StreamRemoveReason 

类型：`enum`

房间内远端流移除原因。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | STREAM_REMOVE_REASON_UNPUBLISH | `0` | 远端用户停止发布流。 |
  | STREAM_REMOVE_REASON_PUBLISH_FAILED | `1` | 远端用户发布流失败。 |
  | STREAM_REMOVE_REASON_KEEP_LIVE_FAILED | `2` | 媒体服务器 10s 没收到客户端的媒体数据。 |
  | STREAM_REMOVE_REASON_CLIENT_DISCONNECTED | `3` | 远端用户断网。 |
  | STREAM_REMOVE_REASON_REPUBLISH | `4` | 远端用户重新发布流。 |
  | STREAM_REMOVE_REASON_OTHER | `5` | 其他原因。 |
  | STREAM_REMOVE_REASON_PUBLISH_PRIVILEGE_TOKEN_EXPIRED | `6` | 远端用户 Token 发布权限过期。 |
  | ByteRTCStreamRemoveReasonPublishPrivilegeExpired | `7` | 远端用户 Token 发布权限过期。 |


## LocalStreamStats 

类型：`class`

本地音/视频流统计信息，统计周期为 2s 。
本地用户发布音/视频流成功后，SDK 会周期性地通过 `onLocalStreamStats` 通知本地用户发布的音/视频流在此次统计周期内的发送状况。此数据结构即为回调给用户的参数类型。

### new LocalStreamStats()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### audioStats  

类型：LocalAudioStats

本地设备发送音频流的统计信息，详见 [LocalAudioStats](#localaudiostats) 。

### videoStats  

类型：LocalVideoStats

本地设备发送视频流的统计信息，详见 [LocalVideoStats](#localvideostats) 。

### isScreen  

类型：boolean

所属用户的媒体流是否为屏幕流。你可以知道当前统计数据来自主流还是屏幕流。

### txQuality  

类型：NetworkQuality

本地媒体上行网络质量，详见 [NetworkQuality](#networkquality) 。

:::warning 已弃用 
   since 3.36 and will be deleted in 3.51, use onNetworkQuality instead.
:::

### rxQuality  

类型：NetworkQuality

本地媒体下行网络质量，详见 [NetworkQuality](#networkquality) 。

:::warning 已弃用 
   since 3.36 and will be deleted in 3.51, use onNetworkQuality instead.
:::


## RemoteStreamStats 

类型：`class`

用户订阅的远端音/视频流统计信息以及网络状况，统计周期为 2s 。
订阅远端用户发布音/视频流成功后，SDK 会周期性地通过 `onRemoteStreamStats` 通知本地用户订阅的远端音/视频流在此次统计周期内的接收状况。此数据结构即为回调给本地用户的参数类型。

### new RemoteStreamStats()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### uid  

类型：string

用户 ID 。音/视频来源的远端用户 ID 。

### audioStats  

类型：RemoteAudioStats

远端音频流的统计信息，详见 [RemoteAudioStats](#remoteaudiostats)

### videoStats  

类型：RemoteVideoStats

远端视频流的统计信息，详见 [RemoteVideoStats](#remotevideostats)

### isScreen  

类型：boolean

所属用户的媒体流是否为屏幕流。你可以知道当前统计数据来自主流还是屏幕流。

### txQuality  

类型：NetworkQuality

所属用户的媒体流上行网络质量，详见 [NetworkQuality](#networkquality) 。

:::warning 已弃用 
   since 3.36 and will be deleted in 3.51, use onNetworkQuality instead.
:::

### rxQuality  

类型：NetworkQuality

所属用户的媒体流下行网络质量，详见 [NetworkQuality](#networkquality) 。

:::warning 已弃用 
   since 3.36 and will be deleted in 3.51, use onNetworkQuality instead.
:::


## SubscribeState 

类型：`enum`

订阅媒体流状态

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | SUBSCRIBE_STATE_SUCCESS | `0` | 订阅/取消订阅流成功 |
  | SUBSCRIBE_STATE_FAILED_NOT_IN_ROOM | `1` | 订阅/取消订阅流失败，本地用户未在房间中 |
  | SUBSCRIBE_STATE_FAILED_STREAM_NOT_FOUND | `2` | 订阅/取消订阅流失败，房间内未找到指定的音视频流 |
  | SUBSCRIBE_STATE_FAILED_SIGNAL | `3` | 订阅/取消订阅流失败，信令错误，请重试 |
  | ByteRTCSubscribeStateFailedOverLimit | `4` | 超过订阅流数上限 |


## SubscribeConfig 

类型：`class`

选择订阅配置

### new SubscribeConfig()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### isScreen  

类型：boolean

是否是屏幕流

### android_subVideo  

类型：boolean

是否订阅视频

### android_subAudio  

类型：boolean

是否订阅音频

### videoIndex  

类型：number

订阅的视频流分辨率下标。
用户可以在一路流中发布多个不同分辨率的视频。因此订阅流时，需要指定订阅的具体分辨率。此参数即用于指定需订阅的分辨率的下标，默认值为 0 。

### android_subWidth  

类型：number

视频宽度，单位：px

### android_subHeight  

类型：number

视频高度，单位：px

### framerate  

类型：number

期望订阅的最高帧率，单位：fps，默认值为 0，设为大于 0 的值时开始生效。
如果发布端发布帧率 > 订阅端订阅的帧率，下行媒体服务器 SVC 丢帧，订阅端收到通过此接口设置的帧率；如果发布端发布帧率 < 订阅端订阅的帧率，则订阅端只能收到发布的帧率。
仅码流支持 SVC 分级编码特性时方可生效。

### ios_subscribeVideo  

类型：boolean

是否订阅视频。
用户通过设置此参数，选择是否订阅远端流中的视频。 YES 为订阅视频，NO 为不订阅视频，默认值为 YES 。

### ios_subscribeAudio  

类型：boolean

是否订阅音频。
用户通过设置此参数，选择是否订阅远端流中的音频。YES 为订阅音频，NO 为不订阅音频，默认值为 YES 。

### ios_svcLayer  

类型：number

订阅的视频流时域分层，默认值为 0。

### ios_width  

类型：number

订阅的宽度信息，单位：px，默认值为 0。

### ios_height  

类型：number

订阅的高度信息，单位：px， 默认值为 0。


## ForwardStreamStateInfo 

类型：`class`

跨房间转发媒体流过程中的不同目标房间的状态和错误信息

### new ForwardStreamStateInfo()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### roomId  

类型：string

跨房间转发媒体流过程中目标房间 ID
空字符串代表所有目标房间

### state  

类型：ForwardStreamState

跨房间转发媒体流过程中该目标房间的状态，参看 [ForwardStreamState](#forwardstreamstate)

### error  

类型：ForwardStreamError

跨房间转发媒体流过程中该目标房间抛出的错误码，参看 [ForwardStreamError](#forwardstreamerror)


## ForwardStreamEventInfo 

类型：`class`

跨房间转发媒体流过程中的不同目标房间发生的事件

### new ForwardStreamEventInfo()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### roomId  

类型：string

跨房间转发媒体流过程中的发生该事件的目标房间 ID
空字符串代表所有目标房间

### event  

类型：ForwardStreamEvent

跨房间转发媒体流过程中该目标房间发生的事件，参看 [ForwardStreamEvent](#forwardstreamevent)。


## NetworkQualityStats 

类型：`class`

上行/下行网络质量

### new NetworkQualityStats()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### uid  

类型：string

用户 id

### android_fractionLost  

类型：number

本端的上行/下行的丢包率，范围 [0.0,1.0]
当 `uid` 为本地用户时，代表发布流的上行丢包率。
当 `uid` 为远端用户时，代表接收所有订阅流的下行丢包率。

### rtt  

类型：number

当 `uid` 为本地用户时有效，客户端到服务端的往返延时（RTT），单位：ms

### totalBandwidth  

类型：number

本端的音视频 RTP 包 2 秒内的平均传输速率，单位：bps
当 `uid` 为本地用户时，代表发送速率。
当 `uid` 为远端用户时，代表所有订阅流的接收速率。

### txQuality  

类型：NetworkQuality

上行网络质量分。分数越高网络质量越差，详见 [NetworkQuality](#networkquality)。

### rxQuality  

类型：NetworkQuality

下行网络质量分。分数越高网络质量越差，详见 [NetworkQuality](#networkquality)。

### ios_lossRatio  

类型：number

本端的上行/下行的丢包率，范围 [0.0,1.0]
当 `uid` 为本地用户时，代表发布流的上行丢包率。
当 `uid` 为远端用户时，代表接收所有订阅流的下行丢包率。


## SetRoomExtraInfoResult 

类型：`enum`

设置房间附加消息结果。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | SUCCESS | `0` | 设置房间附加信息成功 |
  | NOT_JOIN_ROOM | `1` | 设置失败，尚未加入房间 |
  | KEY_IS_NULL | `2` | 设置失败，key 指针为空 |
  | VALUE_IS_NULL | `3` | 设置失败，value 指针为空 |
  | UNKNOW | `4` | 设置失败，未知错误 |
  | KEY_IS_EMPTY | `5` | 设置失败，key 长度为 0 |
  | TOO_OFTEN | `6` | 调用 `setRoomExtraInfo` 过于频繁，建议不超过 10 次/秒。 |
  | SILENT_USER | `7` | 设置失败，用户已调用 `setUserVisibility` 将自身设为隐身状态。 |
  | KEY_TOO_LONG | `8` | 设置失败，Key 长度超过 10 字节 |
  | VALUE_TOO_LONG | `9` | 设置失败，value 长度超过 128 字节 |
  | SERVER_ERROR | `10` | 设置失败，服务器错误 |


## UserVisibilityChangeError 

类型：`enum`

用户可见性状态改变错误码。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | OK | `0` | 成功。 |
  | UNKNOWN | `1` | 未知错误。 |
  | TOO_MANY_VISIBLE_USER | `2` | 房间内可见用户达到上限。 |


## SubtitleState 

类型：`enum`

字幕任务状态。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | SUBTITLE_STATE_STARTED | `0` | 开启字幕。 |
  | SUBTITLE_STATE_STOPED | `1` | 关闭字幕。 |
  | SUBTITLE_STATE_ERROR | `2` | 字幕任务出现错误。 |


## SubtitleMessage 

类型：`class`

字幕具体内容。

### new SubtitleMessage()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### userId  

类型：string

说话者的用户 ID。

### text  

类型：string

字幕文本, 采用 UTF-8 编码。

### language  

类型：string

字幕语种，根据字幕模式为原文或译文对应的语种。

### mode  

类型：SubtitleMode

字幕模式，参看 [SubtitleMode](#subtitlemode)。

### sequence  

类型：number

字幕文本序列号，同一发言人的完整发言和不完整发言会按递增顺序单独分别编号。

### definite  

类型：boolean

语音识别出的文本是否为一段完整的一句话。 True 代表是, False 代表不是。

### `static` android_create()  

**类型**

  ```ts
  (userId: string, text: string, language: string, mode: number, sequence: number, definite: boolean) => $p_a.SubtitleMessage
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"userId","Type":"string","Required":"是","Default":"无","Description":"-","children":[],"key":"userId"},{"Name":"text","Type":"string","Required":"是","Default":"无","Description":"-","children":[],"key":"text"},{"Name":"language","Type":"string","Required":"是","Default":"无","Description":"-","children":[],"key":"language"},{"Name":"mode","Type":"number","Required":"是","Default":"无","Description":"-","children":[],"key":"mode"},{"Name":"sequence","Type":"number","Required":"是","Default":"无","Description":"-","children":[],"key":"sequence"},{"Name":"definite","Type":"boolean","Required":"是","Default":"无","Description":"-","children":[],"key":"definite"}]
      return (
);
```
  

**返回值**

  $p_a.[SubtitleMessage](#subtitlemessage)


## RTCStream 

类型：`class`

流属性。

### userId  

类型：string

`只读`, 发布此流的用户 ID 。

### isScreen  

类型：boolean

`只读`, 此流是否为共享屏幕流。

### hasVideo  

类型：boolean

`只读`, 此流是否包括视频流。

### hasAudio  

类型：boolean

`只读`, 流是否包括音频流。

### videoStreamDescriptions  

类型：$p_a.List<$p_a.VideoStreamDescription\> | $p_i.NSArray<$p_i.ByteRTCVideoSolution\>

`只读`, 视频流的属性。
当远端用户调用 setVideoEncoderConfig 方法发布多个配置的视频流时，此处会包含该用户发布的所有视频流的属性信息。
参看 VideoStreamDescription。

### ios_maxVideoStreamDescription  

类型：$p_i.ByteRTCVideoSolution

`只读`, 视频流最大分辨率，在开启多分辨率发布订阅时，回调发布端能支持的最大发布分辨率。

### ios_index  

类型：$p_i.ByteRTCStreamIndex

`只读`, 
## RTCRoomConfig 

类型：`class`

房间参数配置

### new RTCRoomConfig()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### profile  

类型：ChannelProfile

房间模式，参看 [ChannelProfile](#channelprofile)，默认为 `CHANNEL_PROFILE_COMMUNICATION`，进房后不可更改。

### isAutoPublish  

类型：boolean

是否自动发布音视频流，默认为自动发布。
创建和加入多房间时，只能将其中一个房间设置为自动发布。若每个房间均不做设置，则默认在第一个加入的房间内自动发布流。
若调用 setUserVisibility 将自身可见性设为 false，无论是默认的自动发布流还是手动设置的自动发布流都不会进行发布，你需要将自身可见性设为 true 后方可发布。

### isAutoSubscribeAudio  

类型：boolean

是否自动订阅音频流，默认为自动订阅。
包含主流和屏幕流。

### isAutoSubscribeVideo  

类型：boolean

是否自动订阅视频流，默认为自动订阅。
包含主流和屏幕流。

### remoteVideoConfig  

类型：RemoteVideoConfig

远端视频流参数，参看 [RemoteVideoConfig](1390578#remotevideoconfig)。


## RemoteVideoConfig 

类型：`class`

远端视频帧信息

### new RemoteVideoConfig()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### width  

类型：number

视频宽度，单位：px

### height  

类型：number

视频高度，单位：px

### framerate  

类型：number

期望订阅的最高帧率，单位：fps，默认值为 0 即满帧订阅，设为大于 0 的值时开始生效。
如果发布端发布帧率 > 订阅端订阅的帧率，下行媒体服务器 SVC 丢帧，订阅端收到通过此接口设置的帧率；如果发布端发布帧率 < 订阅端订阅的帧率，则订阅端只能收到发布的帧率。
仅码流支持 SVC 分级编码特性时方可生效。


## PauseResumeControlMediaType 

类型：`enum`

暂停/恢复接收远端的媒体流类型。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | AUDIO | `0` | 只控制音频，不影响视频 |
  | VIDEO | `1` | 只控制视频，不影响音频 |
  | AUDIO_AND_VIDEO | `2` | 同时控制音频和视频 |


## Position 

类型：`class`

本地用户在房间内的位置坐标，需自行建立空间直角坐标系

### new Position()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### x  

类型：number

x 坐标

### y  

类型：number

y 坐标

### z  

类型：number

z 坐标


## ReceiveRange 

类型：`class`

本地用户能收听到、且具有衰减效果的音频接收范围

### new ReceiveRange()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### min  

类型：number

能够接收语音、并且具有衰减效果的最小距离值，该值须 ≥ 0，但 ≤ max。
小于该值的范围内没有范围语音效果，即收听到的音频音量相同。

### max  

类型：number

能够收听语音的最大距离值，该值须 > 0 且 ≥ min。
当收听者和声源距离处于 [min, max) 之间时，收听到的音量根据距离呈衰减效果。
超出该值范围的音频将无法收听到。


## AttenuationType 

类型：`enum`

空间音频音量随距离衰减模式

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | ATTENUATION_TYPE_NONE | `0` | 不随距离衰减 |
  | ATTENUATION_TYPE_LINEAR | `1` | 线性衰减，音量随距离增大而线性减小 |
  | ATTENUATION_TYPE_EXPONENTIAL | `2` | 指数型衰减，音量随距离增大进行指数衰减 |


## AudioSelectionPriority 

类型：`enum`

音频选路优先级设置

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | AUDIO_SELECTION_PRIORITY_NORMAL | `0` | 正常，参加音频选路 |
  | AUDIO_SELECTION_PRIORITY_HIGH | `1` | 高优先级，跳过音频选路 |


## SubtitleConfig 

类型：`class`

字幕配置信息。

### new SubtitleConfig()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### mode  

类型：SubtitleMode

字幕模式。可以根据需要选择识别和翻译两种模式。开启识别模式，会将识别后的用户语音转化成文字；开启翻译模式，会在语音识别后进行翻译。参看 [SubtitleMode](#subtitlemode)。

### targetLanguage  

类型：string

目标翻译语言。可点击 [语言支持](https://www.volcengine.com/docs/4640/35107) 查看翻译服务最新支持的语种信息。


## PublishFallbackOption 

类型：`enum`

发布端音视频流回退选项

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | DISABLE | `0` | 上行网络不佳或设备性能不足时，不对音视频流作回退处理。默认设置。 |
  | SIMULCAST_SMALL_VIDEO_ONLY | `1` | 上行网络不佳或设备性能不足时，发布的视频流会从大流到小流依次降级，直到与当前网络性能匹配，具体降级规则参看[性能回退](https://www.volcengine.com/docs/6348/70137)文档。 |
  | ByteRTCPublishFallbackOptionDisabled | `2` | 上行网络不佳或设备性能不足时，不对音视频流作回退处理。默认设置。 |
  | ByteRTCPublishFallbackOptionSimulcast | `3` | 上行网络不佳或设备性能不足时，发布的视频流会从大流到小流依次降级，直到与当前网络性能匹配，具体降级规则参看[性能回退](https://www.volcengine.com/docs/6348/70137)文档。 |


## RemoteUserPriority 

类型：`enum`

远端用户优先级，在性能不足需要回退时，会优先回退优先级低的用户的音视频流。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | REMOTE_USER_PRIORITY_LOW | `0` | 用户优先级为低，默认值。 |
  | REMOTE_USER_PRIORITY_MEDIUM | `1` | 用户优先级为正常。 |
  | REMOTE_USER_PRIORITY_HIGH | `2` | 用户优先级为高。 |


## SEICountPerFrame 

类型：`enum`

SEI 发送模式。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | SEI_COUNT_PER_FRAME_SINGLE | `0` | 单发模式。即在 1 帧间隔内多次发送 SEI 数据时，多个 SEI 按队列逐帧发送。 |
  | SEI_COUNT_PER_FRAME_MULTI | `1` | 多发模式。即在 1 帧间隔内多次发送 SEI 数据时，多个 SEI 随下个视频帧同时发送。 |


## EffectBeautyMode 

类型：`enum`

基础美颜模式。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | WHITE | `0` | 美白。 |
  | SMOOTH | `1` | 磨皮。 |
  | SHARPEN | `2` | 锐化。 |
  | CLEAR | `3` | 清晰，需集成 v4.4.2+ 版本的特效 SDK。 |


## VideoOrientation 

类型：`enum`

视频帧朝向

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | ADAPTIVE | `0` | （默认）使用相机输出的原始视频帧的角度，不对视频帧进行额外旋转。 |
  | PORTRAIT | `1` | 固定为竖屏，将相机采集到的视频帧转换为竖屏，在整个 RTC 链路中传递竖屏帧。 |
  | LANDSCAPE | `2` | 固定为横屏，将相机采集到的视频帧转换为横屏，在整个 RTC 链路中传递横屏帧。 |


## RecordingConfig 

类型：`class`

本地录制参数配置

### new RecordingConfig()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### dirPath  

类型：string

录制文件保存的绝对路径，需精确到文件夹，文件名由 RTC 自动生成。你需要确保对该路径具有读写权限。

### recordingFileType  

类型：RecordingFileType

录制存储文件格式，参看 [RecordingFileType](#recordingfiletype)


## RecordingType 

类型：`enum`

本地录制的媒体类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | RECORD_AUDIO_ONLY | `0` | 只录制音频 |
  | RECORD_VIDEO_ONLY | `1` | 只录制视频 |
  | RECORD_VIDEO_AND_AUDIO | `2` | 同时录制音频和视频 |
  | ByteRTCRecordingTypeAudioOnly | `3` | 只录制音频 |
  | ByteRTCRecordingTypeVideoOnly | `4` | 只录制视频 |
  | ByteRTCRecordingTypeVideoAndAudio | `5` | 同时录制音频和视频 |


## AudioRecordingConfig 

类型：`class`

音频录制配置

### new AudioRecordingConfig()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### absoluteFileName  

类型：string

录制文件路径。一个有读写权限的绝对路径，包含文件名和文件后缀。
录制文件的格式仅支持 .aac 和 .wav。

### sampleRate  

类型：AudioSampleRate

录音采样率。参看 [AudioSampleRate](#audiosamplerate)。

### channel  

类型：AudioChannel

录音音频声道。参看 [AudioChannel](#audiochannel)。
如果录制时设置的的音频声道数与采集时的音频声道数不同：
- 如果采集的声道数为 1，录制的声道数为 2，那么，录制的音频为经过单声道数据拷贝后的双声道数据，而不是立体声。
- 如果采集的声道数为 2，录制的声道数为 1，那么，录制的音频为经过双声道数据混合后的单声道数据。

### frameSource  

类型：AudioFrameSource

录音内容来源，参看 [AudioFrameSource](#audioframesource)。
默认为 AUDIO_FRAME_SOURCE_MIXED(2)。

### quality  

类型：AudioQuality

录音音质。仅在录制文件格式为 .aac 时可以设置。参看 [AudioQuality](#audioquality)。
采样率为 32kHz 时，不同音质录制文件（时长为 10min）的大小分别是：
- 低音质：1.2MB；
- 【默认】中音质：2MB；
- 高音质：3.75MB；
- 超高音质：7.5MB。


## AudioEffectPlayerConfig 

类型：`class`

混音配置

### new AudioEffectPlayerConfig()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### type  

类型：AudioMixingType

混音播放类型，详见 [AudioMixingType](#audiomixingtype)

### playCount  

类型：number

混音播放次数
- play_count <= 0: 无限循环
- play_count == 1: 播放一次（默认）
- play_count > 1: 播放 play_count 次

### startPos  

类型：number

混音起始位置。默认值为 0，单位为毫秒。

### pitch  

类型：number

与音乐文件原始音调相比的升高/降低值，取值范围为 `[-12，12]`，默认值为 0。每相邻两个值的音高距离相差半音，正值表示升调，负值表示降调。


## PlayerState 

类型：`enum`

播放状态。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | PRELOADED | `0` | 已加载 |
  | OPENED | `1` | 已打开 |
  | PLAYING | `2` | 正在播放 |
  | PAUSED | `3` | 播放已暂停 |
  | STOPPED | `4` | 播放已停止 |
  | FAILED | `5` | 播放失败 |
  | FINISHED | `6` | 播放已结束 |
  | IDLE | `7` | 播放未启动 |
  | ByteRTCPlayerStateIdle | `8` | 播放未启动 |


## PlayerError 

类型：`enum`

播放错误码。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | OK | `0` | 正常 |
  | FORMAT_NOT_SUPPORT | `1` | 不支持此类型 |
  | INVALID_PATH | `2` | 无效的播放路径 |
  | INVALID_STATE | `3` | 未满足前序接口调用的要求。请查看具体接口文档。 |
  | INVALID_POSITION | `4` | 设置播放位置出错。 |
  | INVALID_VOLUME | `5` | 音量参数不合法。 |
  | INVALID_PITCH | `6` | 音调参数设置不合法。 |
  | INVALID_AUDIO_TRACK_INDEX | `7` | 音轨参数设置不合法。 |
  | INVALID_PLAYBACK_SPEED | `8` | 播放速度参数设置不合法 |
  | INVALID_EFFECT_ID | `9` | 音效 ID 异常。还未加载或播放文件，就调用其他 API。 |
  | ByteRTCPlayerErrorInvalidPath | `10` | 无效的播放路径 |
  | ByteRTCPlayerErrorInvalidState | `11` | 未满足前序接口调用的要求。请查看具体接口文档。 |
  | ByteRTCPlayerErrorInvalidPosition | `12` | 设置播放位置出错。 |
  | ByteRTCPlayerErrorInvalidVolume | `13` | 音量参数不合法。 |
  | ByteRTCPlayerErrorInvalidPitch | `14` | 音调参数设置不合法。 |
  | ByteRTCPlayerErrorInvalidAudioTrackIndex | `15` | 音轨参数设置不合法。 |
  | ByteRTCPlayerErrorInvalidPlaybackSpeed | `16` | 播放速度参数设置不合法 |
  | ByteRTCPlayerErrorInvalidEffectId | `17` | 音效 ID 异常。还未加载或播放文件，就调用其他 API。 |


## MediaPlayerConfig 

类型：`class`

混音配置

### new MediaPlayerConfig()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### type  

类型：AudioMixingType

混音播放类型，详见 [AudioMixingType](#audiomixingtype)

### playCount  

类型：number

混音播放次数
- play_count <= 0: 无限循环
- play_count == 1: 播放一次（默认）
- play_count > 1: 播放 play_count 次

### startPos  

类型：number

混音起始位置。默认值为 0，单位为毫秒。

### callbackOnProgressInterval  

类型：number

设置音频文件混音时，收到 onMediaPlayerPlayingProgress 的间隔。单位毫秒。
- interval > 0 时，触发回调。实际间隔为 10 的倍数。如果输入数值不能被 10 整除，将自动向上取整。例如传入 `52`，实际间隔为 60 ms。
- interval <= 0 时，不会触发回调。

### syncProgressToRecordFrame  

类型：boolean

在采集音频数据时，附带本地混音文件播放进度的时间戳。启用此功能会提升远端人声和音频文件混音播放时的同步效果。
- 仅在单个音频文件混音时使用有效。
- `true` 时开启此功能，`false` 时关闭此功能，默认为关闭。

### autoPlay  

类型：boolean

是否自动播放。如果不自动播放，调用 start 播放音乐文件。


## MediaPlayerCustomSource 

类型：`class`

音频源

### new MediaPlayerCustomSource()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### mode  

类型：MediaPlayerCustomSourceMode

数据源模式，详见 [MediaPlayerCustomSourceMode](#mediaplayercustomsourcemode)。

### type  

类型：MediaPlayerCustomSourceStreamType

数据源类型，详见 [MediaPlayerCustomSourceStreamType](#mediaplayercustomsourcestreamtype)

### ios_provider  

类型：$p_i.ByteRTCMediaPlayerCustomSourceProvider

仅使用内存播放时，传入对应的 ByteRTCMediaPlayerCustomSourceProvider 实例。


## AudioMixingDualMonoMode 

类型：`enum`

混音播放声道类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | AUDIO_MIXING_DUAL_MONO_MODE_AUTO | `0` | 和音频文件一致 |
  | AUDIO_MIXING_DUAL_MONO_MODE_L | `1` | 只能听到音频文件中左声道的音频 |
  | AUDIO_MIXING_DUAL_MONO_MODE_R | `2` | 只能听到音频文件中右声道的音频 |
  | AUDIO_MIXING_DUAL_MONO_MODE_MIX | `3` | 能同时听到音频文件中左右声道的音频 |


## VideoDecoderConfig 

类型：`enum`

视频解码方式

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | VIDEO_DECODER_CONFIG_RAW | `0` | 开启 SDK 内部解码，只回调解码后的数据。回调为 onFrame。 |
  | VIDEO_DECODER_CONFIG_ENCODE | `1` | 开启自定义解码，只回调解码前数据。回调为 onRemoteEncodedVideoFrame。 |
  | VIDEO_DECODER_CONFIG_BOTH | `2` | 开启 SDK 内部解码 和 onRemoteEncodedVideoFrame。 |


## EarMonitorMode 

类型：`enum`

是否开启耳返功能。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | EAR_MONITOR_MODE_OFF | `0` | 关闭（默认设置） |
  | EAR_MONITOR_MODE_ON | `1` | 开启 |


## AudioPropertiesConfig 

类型：`class`

音频属性信息提示的相关配置

### new AudioPropertiesConfig()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### interval  

类型：number

信息提示间隔，单位：ms
- `<= 0`: 关闭信息提示
- `(0,100]`: 开启信息提示，不合法的 interval 值，SDK 自动设置为 100ms
- `> 100`: 开启信息提示，并将信息提示间隔设置为此值

### enableSpectrum  

类型：boolean

是否开启音频频谱检测

### enableVad  

类型：boolean

是否开启人声检测 (VAD)

### localMainReportMode  

类型：AudioReportMode

音量回调模式。详见 [AudioReportMode](#audioreportmode)。

### audioReportMode  

类型：AudioPropertiesMode

onLocalAudioPropertiesReport 中包含音频数据的范围。参看 [AudioPropertiesMode](#audiopropertiesmode)。
默认仅包含本地麦克风采集的音频数据和本地屏幕音频采集数据，不包含本地混音音频数据。

### smooth  

类型：number

适用于音频属性信息提示的平滑系数。取值范围是 `(0.0, 1.0]`。
默认值为 `1.0`，不开启平滑效果；值越小，提示音量平滑效果越明显。如果要开启平滑效果，可以设置为 `0.3`。

### enableVoicePitch  

类型：boolean

是否回调本地用户的人声基频。


## StreamSycnInfoConfig 

类型：`class`

媒体流信息同步的相关配置

### new StreamSycnInfoConfig()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### streamIndex  

类型：StreamIndex

流属性，主流或屏幕流。见枚举类 [StreamIndex](#streamindex-2)
- `STREAM_INDEX_MAIN(0)`: 主流
- `STREAM_INDEX_SCREEN(1)`: 屏幕流

### repeatCount  

类型：number

信息发送的重复次数。取值范围是 [0,25]，建议设置为 [3,5]

### streamType  

类型：SyncInfoStreamType

值：`0`

媒体流信息同步的流类型，见 [SyncInfoStreamType](#syncinfostreamtype)


## TorchState 

类型：`enum`

相机闪光灯状态

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | TORCH_STATE_OFF | `0` | 关闭 |
  | TORCH_STATE_ON | `1` | 打开 |


## PublicStreaming 

类型：`class`

 WTN 流参数。

### ios_layout  

类型：$p_i.ByteRTCPublicStreamLayout

视频流 WTN 流整体布局参数，必填。详见 ByteRTCPublicStreamLayout

### ios_video  

类型：$p_i.ByteRTCPublicStreamVideoConfig

 WTN 流视频编码参数。详见 ByteRTCPublicStreamVideoConfig。

### android_setRoomId()  

设置 roomId。

**类型**

  ```ts
  (roomId: string) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"roomId","Type":"string","Required":"是","Default":"无","Description":"房间 ID\n","children":[],"key":"roomId"}]
      return (
);
```
  

### android_setAction()  

设置 WTN 流发布动作参数。

**类型**

  ```ts
  (action: string) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"action","Type":"string","Required":"是","Default":"无","Description":" WTN 流发布动作。可选取值如下：
\nACTION_START: 开启发布
\nACTION_CHANGED: 更新 WTN 流布局
\nACTION_STOPPED: 停止发布\n\n","children":[],"key":"action"}]
      return (
);
```
  

### android_setLayout()  

设置 WTN 流整体布局信息。

**类型**

  ```ts
  (layout: $p_a.Layout) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"layout","Type":"$p_a.Layout","Required":"是","Default":"无","Description":" WTN 流整体布局参数，必填。详见 Layout 数据类型。\n","children":[],"key":"layout"}]
      return (
);
```
  

### android_getLayout()  

获取 WTN 流整体布局信息。

**类型**

  ```ts
  () => $p_a.Layout
  ```

**返回值**

  $p_a.Layout  当前 WTN 流整体布局。详见 Layout 数据类型。

### `static` android_getDefualtPublicStreaming()  

获取默认的 WTN 流配置属性。

**类型**

  ```ts
  () => $p_a.PublicStreaming
  ```

**返回值**

  $p_a.[PublicStreaming](#publicstreaming)  默认的推 WTN 流转码配置属性。详见 [PublicStreaming](#publicstreaming) 数据类型。

### `static` ios_defaultPublicStreaming()  

获取默认的 WTN 流转码配置属性。

**类型**

  ```ts
  () => PublicStreaming
  ```

**返回值**

  [PublicStreaming](#publicstreaming)  包含默认配置的 ByteRTCPublicStreaming 结构体


## EchoTestConfig 

类型：`class`

音视频回路测试参数

### new EchoTestConfig()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### userId  

类型：string

进行音视频通话回路测试的用户 ID

### roomId  

类型：string

测试用户加入的房间 ID

### token  

类型：string

对用户进房时进行鉴权验证的动态密钥，用于保证音视频通话回路测试的安全性。

### enableAudio  

类型：boolean

是否检测音频。检测设备为系统默认音频设备。
- true：是
    - 若使用 SDK 内部采集，此时设备麦克风会自动开启，并在 audioReportInterval 值大于 0 时触发 `onLocalAudioPropertiesReport` 回调，你可以根据该回调判断麦克风的工作状态
    - 若使用自定义采集，此时你需调用 pushExternalAudioFrame 将采集到的音频推送给 SDK
- false：否

### enableVideo  

类型：boolean

是否检测视频。PC 端默认检测列表中第一个视频设备。
- true：是
    - 若使用 SDK 内部采集，此时设备摄像头会自动开启
    - 若使用自定义采集，此时你需调用 pushExternalVideoFrame 将采集到的视频推送给 SDK
- false：否

### audioReportInterval  

类型：number

音量信息提示间隔，单位：ms，默认为 100ms
- `<= 0`: 关闭信息提示
- `(0,100]`: 开启信息提示，不合法的 interval 值，SDK 自动设置为 100ms
- `> 100`: 开启信息提示，并将信息提示间隔设置为此值

### android_getEchoRenderView()  

**类型**

  ```ts
  () => $p_a.View
  ```

**返回值**

  $p_a.View

### android_getEchoUid()  

**类型**

  ```ts
  () => string
  ```

**返回值**

  string

### android_getEchoRoomId()  

**类型**

  ```ts
  () => string
  ```

**返回值**

  string

### android_getEchoToken()  

**类型**

  ```ts
  () => string
  ```

**返回值**

  string

### android_getEchoEnabledAudio()  

**类型**

  ```ts
  () => boolean
  ```

**返回值**

  boolean

### android_getEchoEnabledVideo()  

**类型**

  ```ts
  () => boolean
  ```

**返回值**

  boolean

### android_getAudioReportInterval()  

**类型**

  ```ts
  () => number
  ```

**返回值**

  number


## CloudProxyInfo 

类型：`class`

云代理信息

### new CloudProxyInfo()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### cloudProxyIp  

类型：string

云代理服务器 IP

### cloudProxyPort  

类型：number

云代理服务器端口

## NetworkTimeInfo 

类型：`class`

网络时间信息

### timestamp  

类型：number

网络时间，单位：ms


## DownloadLyricType 

类型：`enum`

歌词文件类型。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | KRC | `0` | KRC 歌词文件。 |
  | LRC | `1` | LRC 歌词文件。 |


## MediaTypeEnhancementConfig 

类型：`class`

蜂窝网络辅助增强应用的媒体模式

### new MediaTypeEnhancementConfig()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### enhanceSignaling  

类型：boolean

对信令消息，是否启用蜂窝网络辅助增强。默认不启用。

### enhanceAudio  

类型：boolean

对屏幕共享以外的其他音频，是否启用蜂窝网络辅助增强。默认不启用。

### enhanceVideo  

类型：boolean

对屏幕共享视频以外的其他视频，是否启用蜂窝网络辅助增强。默认不启用。

### enhanceScreenAudio  

类型：boolean

对屏幕共享音频，是否启用蜂窝网络辅助增强。默认不启用。

### enhanceScreenVideo  

类型：boolean

对屏幕共享视频，是否启用蜂窝网络辅助增强。默认不启用。


## VideoRotation 

类型：`enum`

视频帧旋转角度

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | VIDEO_ROTATION_0 | `0` | 顺时针旋转 0 度 |
  | VIDEO_ROTATION_90 | `1` | 顺时针旋转 90 度 |
  | VIDEO_ROTATION_180 | `2` | 顺时针旋转 180 度 |
  | VIDEO_ROTATION_270 | `3` | 顺时针旋转 270 度 |


## RTCLogConfig 

类型：`class`

SDK 日志配置。

### new RTCLogConfig()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### logPath  

类型：string

日志存储路径，必填。

### logFileSize  

类型：number

设置日志文件总大小上限（即所有日志文件大小之和），选填。单位为 MB，取值范围为 1～100 MB。系统处理机制如下：

- 默认值：10 MB（即调用了 [setLogConfig](1390575#setlogconfig)，且没有设置 `logFileSize` 的情况）。  
- 超出取值范围：若 `logFileSize` < 1，则按 1 MB 处理；若 `logFileSize` \> 100，则按 100 MB 处理。
- 其中，单个日志文件最大为 2 MB：
  - 若 1 ≤ `logFileSize` ≤ 2，则会生成一个日志文件。
  - 若 `logFileSize` \> 2，系统会将日志分割成多个文件，每个文件最大 2 MB。当所有日志文件的总大小达到 `logFileSize` 设置的上限时，系统会自动删除最旧的日志文件。
  例如，`logFileSize` 设置为 10 MB，系统最多会保留 5 个 2 MB 大小的日志文件。当需要写入新日志且总大小即将超过 10 MB 时，最旧的那个文件会被删除，以此类推。

### logLevel  

类型：LocalLogLevel

日志输出等级，参看 [LocalLogLevel](#localloglevel)，默认为警告级别，选填。

### logFilenamePrefix  

类型：string

日志文件名前缀，选填。该字符串必须符合正则表达式：[a-zA-Z0-9_\@\\-\\.]{1,128}。
最终的日志文件名为`前缀 + "_" + 文件创建时间 + "_rtclog".log`，如 `logPrefix_2023-05-25_172324_rtclog.log`。


## RTCVideoEncoderPreference 

类型：`enum`

编码策略偏好。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | DISABLED | `0` | 无偏好。不降低帧率和分辨率。 |
  | MAINTAIN_FRAMERATE | `1` | （默认值）帧率优先。分辨率不变。 |
  | MAINTAIN_QUALITY | `2` | 分辨率优先。 |
  | BALANCE | `3` | 平衡帧率与分辨率。 |


## MixedStreamAlternateImageFillMode 

类型：`enum`

服务端合流占位图填充模式。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | FIT | `0` | 占位图跟随用户原始视频帧相同的比例缩放。默认设置。 |
  | FILL | `1` | 占位图不跟随用户原始视频帧相同的比例缩放，保持图片原有比例。 |


## ProblemFeedbackInfo 

类型：`class`

通话质量反馈信息

### new ProblemFeedbackInfo()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### problemDesc  

类型：string

文字描述

### roomInfo  

类型：ProblemFeedbackRoomInfo[]

房间信息，参看 [ProblemFeedbackRoomInfo](#problemfeedbackroominfo)。


## ForwardStreamEvent 

类型：`enum`

跨房间转发媒体流过程中该目标房间发生的事件

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | FORWARD_STREAM_EVENT_DISCONNECTED | `0` | 本端与服务器网络连接断开，暂停转发。 |
  | FORWARD_STREAM_EVENT_CONNECTED | `1` | 本端与服务器网络连接恢复，转发服务连接成功。 |
  | FORWARD_STREAM_EVENT_DST_ROOM_UPDATED | `2` | 目标房间已更新，由 `updateForwardStreamToRooms` 触发。 |
  | FORWARD_STREAM_EVENT_UN_EXPECT_API_CALL | `3` | API 调用时序错误。例如，在调用 `startForwardStreamToRooms` 之前调用 `updateForwardStreamToRooms`。 |
  | FORWARD_STREAM_EVENT_INTERRUPT | `4` | 转发中断。转发过程中，如果相同 user_id 的用户进入目标房间，转发中断。 |
  | ByteRTCForwardStreamEventInterrupt | `5` | 转发中断。转发过程中，如果相同 user_id 的用户进入目标房间，转发中断。 |


## SubscribeMediaType 

类型：`enum`

订阅的媒体类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | NONE | `0` | 既不订阅音频，也不订阅视频 |
  | AUDIO_ONLY | `1` | 只订阅音频，不订阅视频 |
  | VIDEO_ONLY | `2` | 只订阅视频，不订阅音频 |
  | AUDIO_AND_VIDEO | `3` | 同时订阅音频和视频 |


## BandFrequency 

类型：`enum`

音频均衡效果。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | VOICE_EQUALIZATION_BAND_FREQUENCY_31 | `0` | 中心频率为 31Hz 的频带。 |
  | VOICE_EQUALIZATION_BAND_FREQUENCY_62 | `1` | 中心频率为 62Hz 的频带。 |
  | VOICE_EQUALIZATION_BAND_FREQUENCY_125 | `2` | 中心频率为 125Hz 的频带。 |
  | VOICE_EQUALIZATION_BAND_FREQUENCY_250 | `3` | 中心频率为 250Hz 的频带。 |
  | VOICE_EQUALIZATION_BAND_FREQUENCY_500 | `4` | 中心频率为 500Hz 的频带。 |
  | VOICE_EQUALIZATION_BAND_FREQUENCY_1K | `5` | 中心频率为 1kHz 的频带。 |
  | VOICE_EQUALIZATION_BAND_FREQUENCY_2K | `6` | 中心频率为 2kHz 的频带。 |
  | VOICE_EQUALIZATION_BAND_FREQUENCY_4K | `7` | 中心频率为 4kHz 的频带。 |
  | VOICE_EQUALIZATION_BAND_FREQUENCY_8K | `8` | 中心频率为 8kHz 的频带。 |
  | VOICE_EQUALIZATION_BAND_FREQUENCY_16K | `9` | 中心频率为 16kHz 的频带。 |
  | ByteRTCBandFrequency31 | `10` | 中心频率为 31Hz 的频带。 |
  | ByteRTCBandFrequency62 | `11` | 中心频率为 62Hz 的频带。 |
  | ByteRTCBandFrequency125 | `12` | 中心频率为 125Hz 的频带。 |
  | ByteRTCBandFrequency250 | `13` | 中心频率为 250Hz 的频带。 |
  | ByteRTCBandFrequency500 | `14` | 中心频率为 500Hz 的频带。 |
  | ByteRTCBandFrequency1k | `15` | 中心频率为 1kHz 的频带。 |
  | ByteRTCBandFrequency2k | `16` | 中心频率为 2kHz 的频带。 |
  | ByteRTCBandFrequency4k | `17` | 中心频率为 4kHz 的频带。 |
  | ByteRTCBandFrequency8k | `18` | 中心频率为 8kHz 的频带。 |
  | ByteRTCBandFrequency16k | `19` | 中心频率为 16kHz 的频带。 |


## MixedStreamPushMode 

类型：`enum`

服务端合流转推发起模式。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | ON_STREAM | `0` | 无用户发布媒体流时，发起合流任务无效。默认设置。
当有用户发布媒体流时，才能发起合流任务。 |
  | ON_START_REQUEST | `1` | 无用户发布媒体流时，可以使用占位图发起合流任务。
占位图设置参看 setAlternateImageURL 和 setAlternateImageFillMode。 |


## MixedStreamMediaType 

类型：`enum`

合流输出内容类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | MIXED_STREAM_MEDIA_TYPE_AUDIO_AND_VIDEO | `0` | 输出的混流包含音频和视频 |
  | MIXED_STREAM_MEDIA_TYPE_AUDIO_ONLY | `1` | 输出的混流只包含音频 |
  | MIXED_STREAM_MEDIA_TYPE_VIDEO_ONLY | `2` | 输出的混流只包含视频 |


## SubtitleMode 

类型：`enum`

字幕模式。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | SUBTITLE_MODE_TRANSLATION | `0` | 翻译模式。在此模式下，房间内用户语音会先被转为文字，再被翻译为目标语言。 |
  | SUBTITLE_MODE_RECOGINTE | `1` | 识别模式。在此模式下，房间内用户语音会被转为文字。 |
  | ByteRTCSubtitleModeRecognition | `2` | 识别模式。在此模式下，房间内用户语音会被转为文字。 |


## Orientation 

类型：`class`

方向朝向信息

### new Orientation()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### x  

类型：number

x 坐标

### y  

类型：number

y 坐标

### z  

类型：number

z 坐标


## MusicHotType 

类型：`enum`

热榜类别。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | CONTENT_CENTER | `0` | 火山内容中心热歌榜。 |
  | PROJECT | `1` | 项目热歌榜。 |


## MixedStreamAudioCodecType 

类型：`enum`

音频编码格式。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | MIXED_STREAM_AUDIO_CODEC_TYPE_AAC | `0` | AAC 格式。 |


## ForwardStreamState 

类型：`enum`

媒体流跨房间转发状态

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | FORWARD_STREAM_STATE_SUCCESS | `0` | 开始转发\
                |||- 调用 `startForwardStreamToRooms` 成功向所有房间开始转发媒体流后，返回此状态。 |\
                |||- 调用 `updateForwardStreamToRooms` 后，成功向新增目标房间开始转发媒体流后，返回此状态。 |
  | FORWARD_STREAM_STATE_FAILURE | `1` | 转发失败，失败详情参考 [forwardStreamError](#forwardstreamerror)调用 `startForwardStreamToRooms` 或 `updateForwardStreamToRooms` 后，如遇转发失败，返回此状态。 |
  | FORWARD_STREAM_STATE_IDLE | `2` | 空闲状态\
                |||- 成功调用 `stopForwardStreamToRooms` 后，所有目标房间为空闲状态。 |\
                |||- 成功调用 `updateForwardStreamToRooms` 减少目标房间后，本次减少的目标房间为空闲状态。 |
  | ByteRTCForwardStreamStateIdle | `3` | 空闲状态\
                |||- 成功调用 `stopForwardStreamToRooms` 后，所有目标房间为空闲状态。 |\
                |||- 成功调用 `updateForwardStreamToRooms` 减少目标房间后，本次减少的目标房间为空闲状态。 |


## VideoCodecType 

类型：`enum`

视频编码格式。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | VIDEO_CODEC_TYPE_H264 | `0` | H.264 格式，默认值。 |
  | VIDEO_CODEC_TYPE_BYTEVC1 | `1` | ByteVC1 格式。 |
  | ByteRTCVideoCodecTypeUnknown | `2` | 未知类型 |


## RTCASRConfig 

类型：`class`

使用自动语音识别服务所需校验信息

### new RTCASRConfig()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### userId  

类型：string

用户 ID

### accessToken  

类型：string

访问令牌

### secretKey  

类型：string

私钥。Signature 鉴权模式下不能为空，token 鉴权模式下为空。参看[关于鉴权](https://www.volcengine.com/docs/6561/107789)

### authorizationType  

类型：ASRAuthorizationType

鉴权方式

### cluster  

类型：string

场景信息，参看[业务集群](https://www.volcengine.com/docs/6561/80818#_3-2-2-发送-full-client-request)

### appId  

类型：string

应用 ID


## RTCASRErrorCode 

类型：`enum`

语音识别服务错误码。
除网络原因导致的错误，语音识别服务内部会自行重试之外，其他错误都会停止服务，此时建议再次调用 `startASR` 重启语音识别功能。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | NETWORK_INTERRUPTED | `0` | 网络连接中断，服务不可用，内部会进行重连 |
  | ALREADY_STARTED | `1` | 重复调用 `startASR`。开启语音识别服务后，你需要先调用 `stopASR` 停止语音识别服务，才能二次调用 `startASR` 再次开启服务。 |
  | TOKEN_EMPTY | `2` | 语音识别服务所需 token 为空 |
  | SIGNATURE_KEY_EMPTY | `3` | Signature 鉴权模式下 secretKey 为空 |
  | USERID_NULL | `4` | 用户 ID 为空 |
  | APPID_NULL | `5` | 应用 ID 为空 |
  | CLUSTER_NULL | `6` | 语音识别服务 cluster 为空 |
  | OPERATION_DENIED | `7` | 语音识别服务连接失败，该版本没有语音识别功能，请联系 RTC 技术支持。 |
  | ByteRTCASRErrorNetworkInterrupted | `8` | 网络连接中断，服务不可用，内部会进行重连 |
  | ByteRTCASRErrorAlreadyStarted | `9` | 用户已经调用过 `startASR:handler:`。
开启语音识别服务后，你需要先调用 `stopASR` 停止语音识别服务，才能二次调用 `startASR:handler:` 再次开启服务。 |
  | ByteRTCASRErrorTokenEmpty | `10` | 语音识别服务所需 token 为空 |
  | ByteRTCErrorSignatureKeyEmpty | `11` | Signature 鉴权模式下 secretKey 为空 |
  | ByteRTCASRErrorUserIdNull | `12` | 用户 ID 为空 |
  | ByteRTCASRErrorAPPIDNull | `13` | 应用 ID 为空 |
  | ByteRTCASRErrorClusterNull | `14` | 语音识别服务 cluster 为空 |
  | ByteRTCASRErrorOperationDenied | `15` | 语音识别服务连接失败，该版本没有语音识别功能，请联系 RTC 技术支持。 |


## HumanOrientation 

类型：`class`

三维朝向信息，三个向量需要两两垂直。参看 [Orientation](#orientation)。

### new HumanOrientation()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### forward  

类型：Orientation

正前方朝向，默认值为 `{1,0,0}`，即正前方朝向 x 轴正方向

### right  

类型：Orientation

正右方朝向，默认值为 `{0,1,0}`，即右手朝向 y 轴正方向

### up  

类型：Orientation

正上方朝向，默认值为 `{0,0,1}`，即头顶朝向 z 轴正方向


## AudioAlignmentMode 

类型：`enum`

远端音频流精准对齐模式

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | AUDIO_ALIGNMENT_MODE_OFF | `0` | 不对齐 |
  | AUDIO_ALIGNMENT_MODE_AUDIOMIXING | `1` | 远端音频流都对齐伴奏进度同步播放 |


## FallbackOrRecoverReason 

类型：`enum`

远端订阅流发生回退或恢复的原因

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | FALLBACK_OR_RECOVER_REASON_UNKNOWN | `0` | 其他原因，非带宽和性能原因引起的回退或恢复。默认值 |
  | FALLBACK_OR_RECOVER_REASON_SUBSCRIBE_FALLBACK_BY_BANDWIDTH | `1` | 由带宽不足导致的订阅端音视频流回退。 |
  | FALLBACK_OR_RECOVER_REASON_SUBSCRIBE_FALLBACK_BY_PERFORMANCE | `2` | 由性能不足导致的订阅端音视频流回退。 |
  | FALLBACK_OR_RECOVER_REASON_SUBSCRIBE_RECOVER_BY_BANDWIDTH | `3` | 由带宽恢复导致的订阅端音视频流恢复。 |
  | FALLBACK_OR_RECOVER_REASON_SUBSCRIBE_RECOVER_BY_PERFORMANCE | `4` | 由性能恢复导致的订阅端音视频流恢复。 |
  | FALLBACK_OR_RECOVER_REASON_PUBLISH_FALLBACK_BY_BANDWIDTH | `5` | 由带宽不足导致的发布端音视频流回退。 |
  | FALLBACK_OR_RECOVER_REASON_PUBLISH_FALLBACK_BY_PERFORMANCE | `6` | 由性能不足导致的发布端音视频流回退。 |
  | FALLBACK_OR_RECOVER_REASON_PUBLISH_RECOVER_BY_BANDWIDTH | `7` | 由带宽恢复导致的发布端音视频流恢复。 |
  | FALLBACK_OR_RECOVER_REASON_PUBLISH_RECOVER_BY_PERFORMANCE | `8` | 由性能恢复导致的发布端音视频流恢复。 |



## RemoteVideoRenderPosition 

类型：`enum`

远端视频帧回调位置。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | AFTER_DECODER | `0` | 解码后。 |
  | AFTER_POST_PROCESS | `1` | （默认值）后处理后。 |


## TranscoderLayoutRegionType 

类型：`enum`

合流布局区域类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | LAYOUT_REGION_TYPE_VIDEO_STREAM | `0` | 合流布局区域类型为视频。 |
  | LAYOUT_REGION_TYPE_IMAGE | `1` | 合流布局区域类型为图片。 |
  | ByteRTCTranscoderLayoutRegionTypeVideoStream | `2` | 合流布局区域类型为视频。 |
  | ByteRTCTranscoderLayoutRegionTypeImage | `3` | 合流布局区域类型为图片。 |


## MixedStreamLayoutRegionImageWaterMarkConfig 

类型：`class`

图片合流相关参数。

### new MixedStreamLayoutRegionImageWaterMarkConfig()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### ios_imageWidth  

类型：number

原始图片的宽度，单位为 px。

### ios_imageHeight  

类型：number

原始图片的高度，单位为 px。

### android_setImageHeight()  

设置原始图片的高度。

**类型**

  ```ts
  (imageHeight: number) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"imageHeight","Type":"number","Required":"是","Default":"无","Description":"原始图片高度，单位为 px。\n","children":[],"key":"imageHeight"}]
      return (
);
```
  

**返回值**

  this

### android_getImageHeight()  

获取原始图片的高度。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number

### android_setImageWidth()  

设置原始图片的宽度。

**类型**

  ```ts
  (imageWidth: number) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"imageWidth","Type":"number","Required":"是","Default":"无","Description":"原始图片宽度，单位为 px。\n","children":[],"key":"imageWidth"}]
      return (
);
```
  

**返回值**

  this

### android_getImageWidth()  

获取原始图片的宽度。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number


## AudioMixingConfig 

类型：`class`

混音配置

### new AudioMixingConfig()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### type  

类型：AudioMixingType

混音播放类型，详见 [AudioMixingType](#audiomixingtype)

### playCount  

类型：number

混音播放次数
- play_count <= 0: 无限循环
- play_count == 1: 播放一次（默认）
- play_count > 1: 播放 play_count 次

### position  

类型：number

混音时音频文件播放进度条位置，参数为整数，单位为毫秒

### callbackOnProgressInterval  

类型：number

设置音频文件播放进度回调的时间间隔，参数为大于 0 的 10 的倍数，单位为毫秒，设置后 SDK 将按照设置的值触发 `onAudioMixingPlayingProgress` 回调，默认不回调。
- 当传入的值不能被 10 整除时，则默认向上取整 10，如设为 52ms 时会默认调整为 60ms。
- 当传入的值小于等于 0 时，不会触发进度回调。

### syncProgressToRecordFrame  

类型：boolean

在采集音频数据时，附带本地混音文件播放进度的时间戳。启用此功能会提升远端人声和音频文件混音播放时的同步效果。
- 仅在单个音频文件混音时使用有效。
- `true` 时开启此功能，`false` 时关闭此功能，默认为关闭。


## SyncInfoStreamType 

类型：`enum`

媒体流信息同步的流类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | SYNC_INFO_STREAM_TYPE_AUDIO | `0` | 音频流 |


## MixedStreamAudioProfile 

类型：`enum`

AAC 编码规格。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | MIXED_STREAM_AUDIO_PROFILE_LC | `0` | AAC-LC 规格，默认值。 |
  | MIXED_STREAM_AUDIO_PROFILE_HEV1 | `1` | HE-AAC v1 规格。 |
  | MIXED_STREAM_AUDIO_PROFILE_HEV2 | `2` | HE-AAC v2 规格。 |


## ProblemFeedbackRoomInfo 

类型：`class`

通话质量反馈中的房间信息

### new ProblemFeedbackRoomInfo()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### roomId  

类型：string

房间 ID

### userId  

类型：string

用户 ID


## MixedStreamClientMixConfig 

类型：`class`

客户端合流参数。

### ios_useAudioMixer  

类型：boolean

客户端合流是否使用混音，默认为 true。

### ios_videoFormat  

类型：$p_i.ByteRTCMixedStreamClientMixVideoFormat

客户端合流回调视频格式，参看 ByteRTCMixedStreamClientMixVideoFormat。

### android_setVideoFormat()  

设置客户端合流回调视频格式。设置为系统不支持的格式时，自动回调系统默认格式。

**类型**

  ```ts
  (videoFormat: $p_a.MixedStreamClientMixVideoFormat) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"videoFormat","Type":"$p_a.MixedStreamClientMixVideoFormat","Required":"是","Default":"无","Description":"客户端合流回调视频格式，参看 MixedStreamClientMixVideoFormat。\n","children":[],"key":"videoFormat"}]
      return (
);
```
  

**返回值**

  this

### android_getVideoFormat()  

获取客户端合流回调视频格式。

**类型**

  ```ts
  () => $p_a.MixedStreamClientMixVideoFormat
  ```

**返回值**

  $p_a.MixedStreamClientMixVideoFormat

### android_setUseAudioMixer()  

设置客户端合流是否使用混音。

**类型**

  ```ts
  (useAudioMixer: boolean) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"useAudioMixer","Type":"boolean","Required":"是","Default":"无","Description":"是否使用混音，默认为 true。\n","children":[],"key":"useAudioMixer"}]
      return (
);
```
  

**返回值**

  this  参看 [MixedStreamClientMixConfig](#mixedstreamclientmixconfig)。

### android_getUseAudioMixer()  

获取客户端合流是否使用混音的设置。

**类型**

  ```ts
  () => boolean
  ```

**返回值**

  boolean


## VideoPictureType 

类型：`enum`

编码帧类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | VIDEO_PICTURE_TYPE_UNKNOWN | `0` | 未知类型 |
  | VIDEO_PICTURE_TYPE_I | `1` | I 帧，关键帧，编解码不需要参考其他视频帧 |
  | VIDEO_PICTURE_TYPE_P | `2` | P 帧，向前参考帧，编解码需要参考前一帧视频帧 |
  | VIDEO_PICTURE_TYPE_B | `3` | B 帧，前后参考帧，编解码需要参考前后两帧视频帧 |


## ColorSpace 

类型：`enum`

视频帧色彩空间

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | UNKNOWN | `0` | 色彩空间未知 |
  | BT601_LIMITED_RANGE | `1` | BT.601 数字编码标准，色彩空间[16-235] |
  | BT601_FULL_RANGE | `2` | BT.601 数字编码标准，颜色空间[0-255] |
  | BT709_LIMITED_RANGE | `3` | BT.7091 数字编码标准，颜色空间[16-235] |
  | BT709_FULL_RANGE | `4` | BT.7091 数字编码标准，颜色空间[0-255] |
  | ByteRTCColorSpaceYCbCrBT601LimitedRange | `5` | BT.601 数字编码标准，颜色空间[16-235] |
  | ByteRTCColorSpaceYCbCrBT601FullRange | `6` | BT.601 数字编码标准，颜色空间[0-255] |
  | ByteRTCColorSpaceYCbCrBT709LimitedRange | `7` | BT.7091 数字编码标准，颜色空间[16-235] |
  | ByteRTCColorSpaceYCbCrBT709FullRange | `8` | BT.7091 数字编码标准，颜色空间[0-255] |


## AudioPropertiesInfo 

类型：`class`

音频属性信息

### new AudioPropertiesInfo()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### linearVolume  

类型：number

线性音量，与原始音量呈线性关系，数值越大，音量越大。取值范围是：[0,255]。
- [0, 25]: 近似无声
- [26, 75]: 低音量
- [76, 204]: 中音量
- [205, 255]: 高音量

### nonlinearVolume  

类型：number

非线性音量。由原始音量的对数值转化而来，因此在中低音量时更灵敏，可以用作 Active Speaker（房间内最活跃用户）的识别。取值范围是：[-127，0]，单位 dB。
- [-127, -60]: 近似无声
- [-59, -40]: 低音量
- [-39, -20]: 中音量
- [-19, 0]: 高音量

### vad  

类型：number

人声检测（VAD）结果
- 1: 检测到人声。
- 0: 未检测到人声。
- -1: 未开启 VAD。

### voicePitch  

类型：number

本地用户的人声基频，单位为赫兹。
同时满足以下两个条件时，返回的值为本地用户的人声基频：
- 调用 enableAudioPropertiesReport，并设置参数 enableVoicePitch 的值为 `true`。
- 本地采集的音频中包含本地用户的人声。
其他情况下返回 `0`。

### spectrum()  

频谱数组

**类型**

  ```ts
  ($item: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"$item","Type":"number","Required":"是","Default":"无","Description":"-","children":[],"key":"$item"}]
      return (
);
```
  


## SubscribeVideoConfig 

类型：`class`

视频订阅配置信息

### new SubscribeVideoConfig()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### ios_videoIndex  

类型：number

订阅的视频流分辨率下标。
当远端用户通过调用 enableSimulcastMode 方法启动发布多路不同分辨率的视频流时，本地用户需通过此参数指定希望订阅的流。
默认值为 0，即订阅第一路流。
如果不想更改之前的设置，可以输入 -1。

### ios_priority  

类型：number

远端用户优先级，参看 ByteRTCRemoteUserPriority，默认值为 0。


## VideoDenoiseModeChangedReason 

类型：`enum`

视频降噪模式状态改变原因。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | VIDEO_DENOISE_MODE_CHANGED_REASON_NULL | `0` | 未知原因导致视频降噪状态改变。 |
  | VIDEO_DENOISE_MODE_CHANGED_REASON_API_OFF | `1` | 通过调用 setVideoDenoiser 成功关闭视频降噪。 |
  | VIDEO_DENOISE_MODE_CHANGED_REASON_API_ON | `2` | 通过调用 setVideoDenoiser 成功开启视频降噪。 |
  | VIDEO_DENOISE_MODE_CHANGED_REASON_CONFIG_DISABLED | `3` | 后台未配置视频降噪，视频降噪开启失败，请联系技术人员解决。 |
  | VIDEO_DENOISE_MODE_CHANGED_REASON_CONFIG_ENABLED | `4` | 后台配置开启了视频降噪。 |
  | VIDEO_DENOISE_MODE_CHANGED_REASON_DYNAMIC_CLOSE | `5` | 当前设备性能过载，已动态关闭视频降噪模式。 |
  | VIDEO_DENOISE_MODE_CHANGED_REASON_DYNAMIC_OPEN | `6` | 当前设备性能裕量充足，已动态开启视频降噪模式。 |
  | VIDEO_DENOISE_MODE_CHANGED_REASON_RESOLUTION | `7` | 分辨率导致视频降噪状态发生改变。分辨率过高会导致性能消耗过大，从而导致视频降噪模式关闭。若希望继续使用视频降噪，可选择降低分辨率。 |
  | VIDEO_DENOISE_MODE_CHANGED_REASON_INTERNAL_EXCEPTION | `8` | 由于内部发生了异常，视频降噪关闭。 |
  | ByteRTCVideoDenoiseModeChangedReasonInternalException | `9` | 由于内部发生了异常，视频降噪关闭。 |


## Rectangle 

类型：`class`

矩形区域

### new Rectangle()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### x  

类型：number

矩形区域左上角的 x 坐标

### y  

类型：number

矩形区域左上角的 y 坐标

### width  

类型：number

矩形宽度(px)

### height  

类型：number

矩形高度(px)


## MixedStreamClientMixVideoFormat 

类型：`enum`

客户端合流回调视频格式。设置为系统不支持的格式时，自动回调系统默认格式。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | MIXED_STREAM_CLIENT_MIX_VIDEO_FORMAT_TEXTURE_2D | `0` | OpenGL GL_TEXTURE_2D 格式纹理。支持系统：安卓。 |
  | MIXED_STREAM_CLIENT_MIX_VIDEO_FORMAT_CVPIXEL_BUFFER_BGRA | `1` | CVPixelBuffer BGRA。iOS 默认回调格式。支持系统: iOS。 |
  | MIXED_STREAM_CLIENT_MIX_VIDEO_FORMAT_YUV_I420 | `2` | YUV I420。Android、Windows 默认回调格式。支持系统：Android、Windows。 |
  | MIXED_STREAM_CLIENT_MIX_VIDEO_FORMAT_YUV_NV12 | `3` | YUV NV12。macOS 默认回调格式。支持系统: macOS。 |
  | ByteRTCMixedStreamClientMixVideoFormatI420 | `4` | YUV I420。Android、Windows 默认回调格式。支持系统：Android、Windows。 |
  | ByteRTCMixedStreamClientMixVideoFormatNV12 | `5` | YUV NV12。macOS 默认回调格式。支持系统: macOS。 |


## MixedStreamVideoType 

类型：`enum`

region 中流的类型属性

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | MIXED_STREAM_VIDEO_TYPE_MAIN | `0` | 主流。包括：\
                |||- 由摄像头/麦克风通过内部采集机制，采集到的流 |\
                |||- 通过自定义采集，采集到的流。 |
  | MIXED_STREAM_VIDEO_TYPE_SCREEN | `1` | 屏幕流。 |


## ASRAuthorizationType 

类型：`enum`

语音识别服务鉴权方式，详情请咨询语音识别服务相关人员

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | ASR_AUTHORIZATION_TYPE_TOKEN | `0` | Token 鉴权 |
  | ASR_AUTHORIZATION_TYPE_SIGNATURE | `1` | Signature 鉴权 |


## VideoContentType 

类型：`enum`

视频内容类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | NORMAL_FRAME | `0` | 普通视频 |
  | BLACK_FRAME | `1` | 黑帧视频 |


## AudioSampleRate 

类型：`enum`

音频采样率，单位为 Hz。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | AUDIO_SAMPLE_RATE_AUTO | `0` | 默认设置。48000Hz。 |
  | AUDIO_SAMPLE_RATE_8000 | `1` | 8000Hz |
  | AUDIO_SAMPLE_RATE_16000 | `2` | 16000Hz |
  | AUDIO_SAMPLE_RATE_32000 | `3` | 32000Hz |
  | AUDIO_SAMPLE_RATE_44100 | `4` | 44100Hz |
  | AUDIO_SAMPLE_RATE_48000 | `5` | 48000Hz |



## MixedStreamVideoCodecType 

类型：`enum`

视频编码格式。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | MIXED_STREAM_VIDEO_CODEC_TYPE_H264 | `0` | H.264 格式，默认值。 |
  | MIXED_STREAM_VIDEO_CODEC_TYPE_BYTEVC1 | `1` | ByteVC1 格式。 |


## ByteRTCStreamMixingType 

类型：`enum`

合流类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | STREAM_MIXING_BY_SERVER | `0` | 服务端合流。 |
  | STREAM_MIXING_BY_CLIENT | `1` | 保留字段，无意义 |
  | ByteRTCStreamMixingTypeByServer | `2` | 服务端合流 |
  | ByteRTCStreamMixingTypeByClient | `3` | 保留字段，无意义 |


## AudioFrameSource 

类型：`enum`

音频文件录制内容来源。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | AUDIO_FRAME_SOURCE_MIC | `0` | 本地麦克风采集的音频数据。 |
  | AUDIO_FRAME_SOURCE_PLAYBACK | `1` | 远端所有用户混音后的数据 |
  | AUDIO_FRAME_SOURCE_MIXED | `2` | 本地麦克风和所有远端用户音频流的混音后的数据 |
  | ByteRTCAudioFrameSourceTypeMic | `3` | 本地麦克风采集的音频数据。 |
  | ByteRTCAudioFrameSourceTypePlayback | `4` | 远端所有用户混音后的数据 |
  | ByteRTCAudioFrameSourceTypeMixed | `5` | 本地麦克风和所有远端用户音频流的混音后的数据 |


## ForwardStreamError 

类型：`enum`

媒体流跨房间转发过程中抛出的错误码

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | FORWARD_STREAM_ERROR_OK | `0` | 正常 |
  | FORWARD_STREAM_ERROR_RESPONSE | `1` | 服务端异常 |
  | FORWARD_STREAM_ERROR_REMOTE_KICKED | `2` | 目标房间有相同 user id 的用户加入，转发中断 |
  | FORWARD_STREAM_ERROR_NOT_SUPPORT | `3` | 服务端不支持转发功能 |
  | FORWARD_STREAM_ERROR_INVALID_ARGUMENT | `4` | 参数异常 |
  | FORWARD_STREAM_ERROR_INVALID_TOKEN | `5` | token 错误 |
  | ByteRTCForwardStreamErrorInvalidArgument | `6` | 参数异常 |
  | ByteRTCForwardStreamErrorInvalidToken | `7` | Token 错误 |


## LocalVideoStats 

类型：`class`

本地视频流统计信息，统计周期为 2s 。
本地用户发布视频流成功后，SDK 会周期性地通过 `onLocalStreamStats`
通知用户发布的视频流在此次统计周期内的发送状况。此数据结构即为回调给用户的参数类型。

### new LocalVideoStats()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### sentKBitrate  

类型：number

发送码率。此次统计周期内实际发送的分辨率最大的视频流的发送码率，单位为 Kbps

### inputFrameRate  

类型：number

采集帧率。此次统计周期内的视频采集帧率，单位为 fps 。

### sentFrameRate  

类型：number

发送帧率。此次统计周期内实际发送的分辨率最大的视频流的视频发送帧率，单位为 fps 。

### encoderOutputFrameRate  

类型：number

编码器输出帧率。当前编码器在此次统计周期内实际发送的分辨率最大的视频流的输出帧率，单位为 fps 。

### rendererOutputFrameRate  

类型：number

本地渲染帧率。此次统计周期内的本地视频渲染帧率，单位为 fps 。

### statsInterval  

类型：number

统计间隔，单位为 ms 。
此字段用于设置回调的统计周期，默认设置为 2s 。

### videoLossRate  

类型：number

视频丢包率。此次统计周期内的视频上行丢包率，取值范围： [0，1] 。

### rtt  

类型：number

往返时延，单位为 ms 。

### encodedBitrate  

类型：number

视频编码码率。此次统计周期内的实际发送的分辨率最大的视频流视频编码码率，单位为 Kbps 。

### encodedFrameWidth  

类型：number

实际发送的分辨率最大的视频流的视频编码宽度，单位为 px 。

### encodedFrameHeight  

类型：number

实际发送的分辨率最大的视频流的视频编码高度，单位为 px 。

### encodedFrameCount  

类型：number

此次统计周期内实际发送的分辨率最大的视频流的发送的视频帧总数。

### codecType  

类型：VideoCodecType

视频的编码类型，具体参考 [VideoCodecType](#videocodectype) 。

### isScreen  

类型：boolean

所属用户的媒体流是否为屏幕流。你可以知道当前统计数据来自主流还是屏幕流。

### jitter  

类型：number

视频上行网络抖动，单位为 ms 。

### videoDenoiseMode  

类型：VideoDenoiseMode

上行视频当前降噪模式所处的状态 (0: 关/1: 开)。


## VideoPreprocessorConfig 

类型：`class`

视频处理配置参数。

### requiredPixelFormat  

类型：VideoPixelFormat

设置请求的像素格式，参看 [VideoPixelFormat](#videopixelformat)。
当前仅支持 `I420`、`TEXTURE_2D` 和 `UNKNOWN` 格式。




## ProblemFeedbackOption 

类型：`enum`

音视频质量反馈问题类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | NONE | `0` | 没有问题 |
  | OTHER_MESSAGE | `1` | 其他问题 |
  | DISCONNECTED | `2` | 连接失败 |
  | EAR_BACK_DELAY | `3` | 耳返延迟大 |
  | LOCAL_NOISE | `4` | 本端有杂音 |
  | LOCAL_AUDIO_LAGGING | `5` | 本端声音卡顿 |
  | LOCAL_NO_AUDIO | `6` | 本端无声音 |
  | LOCAL_AUDIO_STRENGTH | `7` | 本端声音大/小 |
  | LOCAL_ECHO | `8` | 本端有回声 |
  | LOCAL_VIDEO_FUZZY | `9` | 本端视频模糊 |
  | LOCAL_NOT_SYNC | `10` | 本端音视频不同步 |
  | LOCAL_VIDEO_LAGGING | `11` | 本端视频卡顿 |
  | LOCAL_NO_VIDEO | `12` | 本端无画面 |
  | REMOTE_NOISE | `13` | 远端有杂音 |
  | REMOTE_AUDIO_LAGGING | `14` | 远端声音卡顿 |
  | REMOTE_NO_AUDIO | `15` | 远端无声音 |
  | REMOTE_AUDIO_STRENGTH | `16` | 远端声音大/小 |
  | REMOTE_ECHO | `17` | 远端有回声 |
  | REMOTE_VIDEO_FUZZY | `18` | 远端视频模糊 |
  | REMOTE_NOT_SYNC | `19` | 远端音视频不同步 |
  | REMOTE_VIDEO_LAGGING | `20` | 远端视频卡顿 |
  | REMOTE_NO_VIDEO | `21` | 远端无画面 |


## VideoFrameType 

类型：`enum`

视频帧的类型，用于标识视频帧是 CPUBuffer 还是 TextureBuffer

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | RAW_MEMORY | `0` | CPU Buffer |
  | GL_TEXTURE | `1` | GL Texture |
  | ByteRTCVideoFrameTypePixelBuffer | `2` | 视频帧类型：CVPixelBuffer |


## TranscoderContentControlType 

类型：`enum`

合流输出内容类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | HAS_AUDIO_AND_VIDEO | `0` | 输出的混流包含音频和视频 |
  | HAS_AUDIO_ONLY | `1` | 输出的混流只包含音频 |
  | HAS_VIDEO_ONLY | `2` | 输出的混流只包含视频 |


## RemoteAudioStats 

类型：`class`

远端音频流统计信息，统计周期为 2s。
本地用户订阅远端音频流成功后，SDK 会周期性地通过 `onRemoteStreamStats` 通知本地用户订阅的音频流在此次统计周期内的接收状况。此数据结构即为回调给本地用户的参数类型。

### new RemoteAudioStats()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### audioLossRate  

类型：number

音频丢包率。统计周期内的音频下行丢包率，取值范围为 [0, 1] 。

### receivedKBitrate  

类型：number

接收码率。统计周期内的音频接收码率，单位为 kbps 。

### stallCount  

类型：number

音频卡顿次数。统计周期内的卡顿次数。

### stallDuration  

类型：number

音频卡顿时长。统计周期内的卡顿时长，单位为 ms 。

### e2eDelay  

类型：number

用户体验级别的端到端延时。从发送端采集完成编码开始到接收端解码完成渲染开始的延时，单位为 ms 。

### playoutSampleRate  

类型：number

播放采样率。统计周期内的音频播放采样率信息，单位为 Hz 。

### statsInterval  

类型：number

统计间隔。此次统计周期的间隔，单位为 ms 。

### rtt  

类型：number

客户端到服务端数据传输的往返时延，单位为 ms 。

### totalRtt  

类型：number

发送端——服务端——接收端全链路数据传输往返时延。单位为 ms 。

### quality  

类型：number

远端用户发送的音频流质量。值含义参考 [NetworkQuality](#networkquality) 。

### jitterBufferDelay  

类型：number

因引入 jitter buffer 机制导致的延时。单位为 ms 。

### numChannels  

类型：number

音频声道数。

### receivedSampleRate  

类型：number

音频接收采样率。统计周期内接收到的远端音频采样率信息，单位为 Hz 。

### frozenRate  

类型：number

远端用户在加入房间后发生音频卡顿的累计时长占音频总有效时长的百分比。音频有效时长是指远端用户进房发布音频流后，除停止发送音频流和禁用音频模块之外的音频时长。

### concealedSamples  

类型：number

音频丢包补偿(PLC) 样点总个数。

### concealmentEvent  

类型：number

音频丢包补偿(PLC) 累计次数。

### decSampleRate  

类型：number

音频解码采样率。统计周期内的音频解码采样率信息，单位为 Hz 。

### decDuration  

类型：number

此次订阅中，对远端音频流进行解码的累计耗时。单位为 s。

### jitter  

类型：number

音频下行网络抖动，单位为 ms 。


## DownloadFileType 

类型：`enum`

下载文件类型。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | MUSIC | `0` | 音频文件。 |
  | KRC | `1` | KRC 歌词文件。 |
  | LRC | `2` | LRC 歌词文件。 |
  | MIDI | `3` | MIDI 文件。 |


## MediaPlayerCustomSourceSeekWhence 

类型：`enum`

音频数据的起始读取位置。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | SET | `0` | 从音频数据的头开始读取，读取的实际偏移量为参数 offset 的值。 |
  | CUR | `1` | 从音频数据的某一位置开始读取，读取的实际偏移量为音频数据当前的读取位置位置加上参数 offset 的值。 |
  | END | `2` | 从音频数据的尾开始读取，读取的实际数据偏移量为用户传入的音频数据大小加上参数 offset 的值。 |
  | SIZE | `3` | 返回音频数据的大小。 |


## LyricStatus 

类型：`enum`

歌词格式类型。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | NONE | `0` | 无歌词。 |
  | KRC | `1` | KRC 歌词。 |
  | LRC | `2` | LRC 歌词。 |
  | KRC_AND_LRC | `3` | KRC 歌词和 LRC 歌词均有。 |


## AudioQuality 

类型：`enum`

音频质量。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | AUDIO_QUALITY_LOW | `0` | 低音质 |
  | AUDIO_QUALITY_MEDIUM | `1` | 中音质 |
  | AUDIO_QUALITY_HIGH | `2` | 高音质 |
  | AUDIO_QUALITY_ULTRA_HIGH | `3` | 超高音质 |


## MixedStreamLayoutRegionType 

类型：`enum`

合流布局区域类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | MIXED_STREAM_LAYOUT_REGION_TYPE_VIDEO_STREAM | `0` | 合流布局区域类型为视频。 |
  | MIXED_STREAM_LAYOUT_REGION_TYPE_IMAGE | `1` | 合流布局区域类型为图片。 |
  | ByteRTCMixedStreamLayoutRegionTypeImage | `2` | 合流布局区域类型为图片。 |


## VideoRenderMirrorType 

类型：`enum`

是否将视频帧镜像。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | ON | `0` | 开启镜像。 |
  | OFF | `1` | （默认值）不开启镜像。 |


## LiveTranscoding 

类型：`class`

转推直播配置参数。(新)

### ios_expectedMixingType  

类型：$p_i.ByteRTCStreamMixingType

合流类型，详见 [ByteRTCStreamMixingType](#bytertcstreammixingtype) 数据类型。
本参数不支持过程中更新。

### ios_layout  

类型：$p_i.ByteRTCVideoCompositingLayout

视频流合流整体布局信息。
开启转推直播功能后，你可以设置参与合流的每路视频流的预设布局信息和合流背景信息等。详见 ByteRTCVideoCompositingLayout 数据类型。

### ios_video  

类型：$p_i.ByteRTCTranscodingVideoConfig

视频转码配置参数。详见 ByteRTCTranscodingVideoConfig 数据类型。

### ios_audio  

类型：$p_i.ByteRTCTranscodingAudioConfig

音频转码配置参数，参看 ByteRTCTranscodingAudioConfig。

### ios_clientMixParam  

类型：$p_i.ByteRTCTranscodingClientMixParam

客户端合流配置。详见 ByteRTCTranscodingClientMixParam 。

### ios_url  

类型：string

推流 CDN 地址。仅支持 RTMP 协议，Url 必须满足正则 `/^rtmps?:\\/\\//`。
本参数不支持过程中更新。

### ios_roomId  

类型：string

推流房间 ID。`roomId` 和 `userId` 长度相加不得超过 126 字节。
本参数不支持过程中更新。

### ios_userId  

类型：string

推流用户 ID。`roomId` 和 `userId` 长度相加不得超过 126 字节。
本参数不支持过程中更新。

### android_getFieldVideoConfigBFrame()  

**类型**

  ```ts
  () => boolean
  ```

**返回值**

  boolean

### android_setUrl()  

设置推流 CDN 地址。仅支持 RTMP 协议，Url 必须满足正则 `/^rtmps?:\\/\\//`。
本参数不支持过程中更新。

**类型**

  ```ts
  (url: string) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"url","Type":"string","Required":"是","Default":"无","Description":"推流地址\n","children":[],"key":"url"}]
      return (
);
```
  

### android_setRoomId()  

设置推流房间 ID。`roomId` 和 `userId` 长度相加不得超过 126 字节。
本参数不支持过程中更新。

**类型**

  ```ts
  (roomId: string) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"roomId","Type":"string","Required":"是","Default":"无","Description":"推流房间 ID。\n","children":[],"key":"roomId"}]
      return (
);
```
  

### android_setUserId()  

设置推流用户 ID。`roomId` 和 `userId` 长度相加不得超过 126 字节。
本参数不支持过程中更新。

**类型**

  ```ts
  (userId: string) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"userId","Type":"string","Required":"是","Default":"无","Description":"推流用户 ID。\n","children":[],"key":"userId"}]
      return (
);
```
  

### android_setVideo()  

设置视频转码配置参数。

**类型**

  ```ts
  (video: $p_a.VideoConfig) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"video","Type":"$p_a.VideoConfig","Required":"是","Default":"无","Description":"视频转码配置参数。详见 VideoConfig 数据类型。\n","children":[],"key":"video"}]
      return (
);
```
  

### android_setAudio()  

设置音频转码配置参数。

**类型**

  ```ts
  (audio: $p_a.AudioConfig) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"audio","Type":"$p_a.AudioConfig","Required":"是","Default":"无","Description":"音频转码配置参数，参看 AudioConfig。\n","children":[],"key":"audio"}]
      return (
);
```
  

### android_setSpatialConfig()  

设置推流 CDN 的空间音频参数。

**类型**

  ```ts
  (spatialConfig: $p_a.SpatialConfig) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"spatialConfig","Type":"$p_a.SpatialConfig","Required":"是","Default":"无","Description":"空间音频参数。详见 SpatialConfig 数据类型。\n","children":[],"key":"spatialConfig"}]
      return (
);
```
  

### android_setClientMixParam()  

设置客户端合流配置参数。

**类型**

  ```ts
  (param: $p_a.ClientMixParam) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"param","Type":"$p_a.ClientMixParam","Required":"是","Default":"无","Description":"客户端合流配置参数。详见 ClientMixParam 数据类型。\n","children":[],"key":"param"}]
      return (
);
```
  

### android_setLayout()  

设置视频流合流整体布局信息。

**类型**

  ```ts
  (layout: $p_a.Layout) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"layout","Type":"$p_a.Layout","Required":"是","Default":"无","Description":"视频流合流整体布局参数，参看 Layout。\n","children":[],"key":"layout"}]
      return (
);
```
  

### android_getMixType()  

获取合流类型。

**类型**

  ```ts
  () => $p_a.ByteRTCStreamMixingType
  ```

**返回值**

  $p_a.[ByteRTCStreamMixingType](#bytertcstreammixingtype)  合流类型，参看 [ByteRTCStreamMixingType](#bytertcstreammixingtype)。

### android_setMixType()  

设置合流类型。

**类型**

  ```ts
  (mixType: $p_a.ByteRTCStreamMixingType) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"mixType","Type":"$p_a.ByteRTCStreamMixingType","Required":"是","Default":"无","Description":"合流类型，参看 ByteRTCStreamMixingType。\n","children":[],"key":"mixType"}]
      return (
);
```
  

### android_getUrl()  

获取推流的 CDN 地址。

**类型**

  ```ts
  () => string
  ```

**返回值**

  string  CDN 的 URL 地址。

### android_getVideo()  

获取视频转码配置参数。

**类型**

  ```ts
  () => $p_a.VideoConfig
  ```

**返回值**

  $p_a.VideoConfig  当前视频转码配置参数。详见 VideoConfig 数据类型。

### android_getAudio()  

获取音频转码配置参数。

**类型**

  ```ts
  () => $p_a.AudioConfig
  ```

**返回值**

  $p_a.AudioConfig  当前音频转码配置参数，参看 AudioConfig。

### android_getSpatialConfig()  

获取空间音频配置参数。

**类型**

  ```ts
  () => $p_a.SpatialConfig
  ```

**返回值**

  $p_a.SpatialConfig  当前空间音频配置参数。详见 SpatialConfig 数据类型。

### android_getClientMixParam()  

获取客户端合流配置参数。

**类型**

  ```ts
  () => $p_a.ClientMixParam
  ```

**返回值**

  $p_a.ClientMixParam  当前客户端合流配置参数。详见 ClientMixParam 数据类型。

### android_getLayout()  

获取视频流合流整体布局信息。

**类型**

  ```ts
  () => $p_a.Layout
  ```

**返回值**

  $p_a.Layout  当前视频流合流整体布局，参看 Layout。

### `static` android_getDefualtLiveTranscode()  

获取默认的转推直播配置参数。

**类型**

  ```ts
  () => $p_a.LiveTranscoding
  ```

**返回值**

  $p_a.[LiveTranscoding](#livetranscoding)  默认的转推直播配置参数。参看 [LiveTranscoding](#livetranscoding)。

### `static` ios_defaultTranscoding()  

获取默认转推直播配置参数。

**类型**

  ```ts
  () => LiveTranscoding
  ```

**返回值**

  [LiveTranscoding](#livetranscoding)  转推直播配置参数，参看 ByteRTCLiveTranscoding。


## VideoDenoiseMode 

类型：`enum`

视频降噪模式。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | VIDEO_DENOISE_MODE_OFF | `0` | 视频降噪关闭。 |
  | VIDEO_DENOISE_MODE_AUTO | `1` | 视频降噪开启，由 ByteRTC 后台配置视频降噪算法。 |


## MixedStreamSEIContentMode 

类型：`enum`

服务端合流转推 SEI 内容。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | MIXED_STREAM_SEI_CONTENT_MODE_DEFAULT | `0` | 视频流中包含全部的 SEI 信息。默认设置。 |
  | MIXED_STREAM_SEI_CONTENT_MODE_ENABLE_VOLUME_INDICATION | `1` | 随非关键帧传输的 SEI 数据中仅包含音量信息。
当设置 setEnableVolumeIndication 为 true 时，此参数设置生效。 |


## AACProfile 

类型：`enum`

AAC 编码规格。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | AAC_PROFILE_LC | `0` | AAC-LC 规格，默认值。 |
  | AAC_PROFILE_HEV1 | `1` | HE-AAC v1 规格。 |
  | AAC_PROFILE_HEV2 | `2` | HE-AAC v2 规格。 |


## VideoFrame 

类型：`class`

视频帧

### new VideoFrame()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### ios_format  

类型：number

视频帧格式，参考 ByteRTCVideoPixelFormat #ByteRTCVideoPixelFormat

### ios_contentType  

类型：$p_i.ByteRTCVideoContentType

获取视频内容类型，参看 ByteRTCVideoContentType

### ios_time  

类型：number

当前帧的时间戳信息

### ios_strideInPixels  

类型：number

每一行像素占用的字节数

### ios_width  

类型：number

视频帧宽度

### ios_height  

类型：number

视频帧高度

### ios_textureBuf  

类型：any

CVPixelBufferRef 类型的数据，当 format 为 kPixelFormatCVPixelBuffer 时有效

### ios_dataBuf  

类型：ArrayBuffer

视频帧内存块首地址

### ios_rotation  

类型：$p_i.ByteRTCVideoRotation

视频帧旋转角度：0, 90, 180, 270

### ios_colorSpace  

类型：$p_i.ByteRTCColorSpace

颜色空间

### ios_cameraId  

类型：$p_i.ByteRTCCameraID

视频帧的摄像头信息，参考 ByteRTCCameraID

### ios_extendedData  

类型：ArrayBuffer

视频帧附加的 sei 数据

### ios_supplementaryInfo  

类型：ArrayBuffer

视频帧附加的 roi 数据

### ios_numberOfPlanes  

类型：number

视频帧颜色 plane 数量; 当 textureBuf 有值时, 该值无意义。
yuv 数据存储格式分为打包（packed）存储格式和平面（planar）存储格式，planar 格式中 Y、U、V 分平面存储，packed 格式中 Y、U、V 交叉存储

### ios_planeDatas  

类型：$p_i.NSArray

获取 plane 数据指针, 数组长度与 numberOfPlanes 一致, 元素类型为 NSData*; 当 textureBuf 有值时, 该值无意义

### ios_planeStrides  

类型：$p_i.NSArray

获取 plane 中数据行的长度,  数组长度与 numberOfPlanes 一致, 元素类型为 NSNumber*; 当 textureBuf 有值时, 该值无意义

### ios_stride  

类型：number

:::warning 已弃用 
   since 3.45 and will be deleted in 3.51, use strideInPixels instead.
:::

### android_setReleaseCallback()  

设置视频帧释放回调，当视频帧的引用计数归 0 时，会执行 releaseCallback

**类型**

  ```ts
  (releaseCallback: $p_a.Runnable) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"releaseCallback","Type":"unknown","Required":"是","Default":"无","Description":"视频帧释放回调\n","children":[],"key":"releaseCallback"}]
      return (
);
```
  

### android_hasReleaseCallback()  

用于检查当前的视频帧是否已设置 releaseCallback

**类型**

  ```ts
  () => boolean
  ```

**返回值**

  boolean
  - true：是
  - false：否

### android_getFrameType()  

获取视频帧类型，参看 [VideoFrameType](#videoframetype)

**类型**

  ```ts
  () => $p_a.VideoFrameType
  ```

**返回值**

  $p_a.[VideoFrameType](#videoframetype)

### android_getPixelFormat()  

获取视频帧格式，参看 [VideoPixelFormat](#videopixelformat)

**类型**

  ```ts
  () => $p_a.VideoPixelFormat
  ```

**返回值**

  $p_a.VideoPixelFormat

### android_getContentType()  

获取视频内容类型

**类型**

  ```ts
  () => $p_a.VideoContentType
  ```

**返回值**

  $p_a.[VideoContentType](#videocontenttype)  视频内容类型，参看 [VideoContentType](#videocontenttype)。

### android_getTimeStampUs()  

获取视频帧时间戳，单位：微秒

**类型**

  ```ts
  () => number
  ```

**返回值**

  number

### android_getWidth()  

获取视频帧宽度，单位：px

**类型**

  ```ts
  () => number
  ```

**返回值**

  number

### android_getHeight()  

获取视频帧高度，单位：px

**类型**

  ```ts
  () => number
  ```

**返回值**

  number

### android_getRotation()  

获取视频帧旋转角度

**类型**

  ```ts
  () => $p_a.VideoRotation
  ```

**返回值**

  $p_a.[VideoRotation](#videorotation)

### android_getColorSpace()  

获取视频帧色彩空间，参看 [ColorSpace](#colorspace)

**类型**

  ```ts
  () => $p_a.ColorSpace
  ```

**返回值**

  $p_a.[ColorSpace](#colorspace)

### android_getCameraId()  

获取视频帧的摄像头信息，参看 [CameraId](#cameraid)

**类型**

  ```ts
  () => $p_a.CameraId
  ```

**返回值**

  $p_a.[CameraId](#cameraid)

### android_getNumberOfPlanes()  

获取视频帧像素平面数量

**类型**

  ```ts
  () => number
  ```

**返回值**

  number

### android_getPlaneData()  

获取 plane 数据

**类型**

  ```ts
  (planeIndex: number) => $p_a.ByteBuffer
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"planeIndex","Type":"number","Required":"是","Default":"无","Description":"plane 数据索引\n","children":[],"key":"planeIndex"}]
      return (
);
```
  

**返回值**

  $p_a.ByteBuffer

### android_getPlaneStride()  

获取指定 plane 中数据行的长度

**类型**

  ```ts
  (planeIndex: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"planeIndex","Type":"number","Required":"是","Default":"无","Description":"plane 数据索引\n","children":[],"key":"planeIndex"}]
      return (
);
```
  

**返回值**

  number

### android_getExternalDataInfo()  

获取 SEI 数据

**类型**

  ```ts
  () => $p_a.ByteBuffer
  ```

**返回值**

  $p_a.ByteBuffer

### android_getSupplementaryInfo()  

获取补充数据指针

**类型**

  ```ts
  () => $p_a.ByteBuffer
  ```

**返回值**

  $p_a.ByteBuffer

### android_getTextureID()  

获取纹理 ID

**类型**

  ```ts
  () => number
  ```

**返回值**

  number

### android_getTextureMatrix()  

获取纹理矩阵

**类型**

  ```ts
  () => Array<$p_a.float>
  ```

**返回值**

  Array<$p_a.float\>

### android_getEGLContext()  

获取纹理使用的 EGLContext

**类型**

  ```ts
  () => $p_a.EGLContext
  ```

**返回值**

  $p_a.EGLContext

### android_retain()  

对当前的视频帧进行一次引用计数

**类型**

  ```ts
  () => void
  ```

### android_release()  

对当前的视频帧减少一次引用计数

**类型**

  ```ts
  () => void
  ```


## MediaPlayerCustomSourceMode 

类型：`enum`

自定义音频源模式

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | PUSH | `0` | 当播放来自本地的 PCM 数据时，使用此选项。 |
  | PULL | `1` | 当播放来自内存的音频数据时，使用此选项。 |


## KTVPlayerErrorCode 

类型：`enum`

KTV 播放器错误码。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | OK | `0` | 成功。 |
  | FILE_NOT_EXIST | `1` | 播放错误，请下载后播放。 |
  | FILE_ERROR | `2` | 播放错误，请确认文件播放格式。 |
  | NOT_JOIN_ROOM | `3` | 播放错误，未进入房间。 |
  | PARAM | `4` | 参数错误。 |
  | START_ERROR | `5` | 播放失败，找不到文件或文件打开失败。 |
  | MIX_ID_ERROR | `6` | 混音 ID 异常。 |
  | POSITION_ERROR | `7` | 设置播放位置出错。 |
  | AUDIO_VOLUME_ERROR | `8` | 音量参数不合法，可设置的取值范围为 [0,400]。 |
  | TYPE_ERROR | `9` | 不支持此混音类型。 |
  | PITCH_ERROR | `10` | 音调文件不合法。 |
  | AUDIO_TRACK_ERROR | `11` | 音轨不合法。 |
  | STARTING_ERROR | `12` | 混音启动中。 |
  | ByteRTCKTVPlayerErrorCodeOK | `13` | 成功。 |
  | ByteRTCKTVPlayerErrorCodeFileNotExist | `14` | 播放错误，请下载后播放。 |
  | ByteRTCKTVPlayerErrorCodeFileError | `15` | 播放错误，请确认文件播放格式。 |
  | ByteRTCKTVPlayerErrorCodeNotJoinRoom | `16` | 播放错误，未进入房间。 |
  | ByteRTCKTVPlayerErrorCodeParam | `17` | 参数错误。 |
  | ByteRTCKTVPlayerErrorCodeStartError | `18` | 播放失败，找不到文件或文件打开失败。 |
  | ByteRTCKTVPlayerErrorCodeMixIdError | `19` | 混音 ID 异常。 |
  | ByteRTCKTVPlayerErrorCodePositionError | `20` | 设置播放位置出错。 |
  | ByteRTCKTVPlayerErrorCodeAudioVolumeError | `21` | 音量参数不合法，可设置的取值范围为 [0,400]。 |
  | ByteRTCKTVPlayerErrorCodeTypeError | `22` | 不支持此混音类型。 |
  | ByteRTCKTVPlayerErrorCodePitchError | `23` | 音调文件不合法。 |
  | ByteRTCKTVPlayerErrorCodeAudioTrackError | `24` | 音轨不合法。 |
  | ByteRTCKTVPlayerErrorCodeStartingError | `25` | 混音启动中。 |



## MixedStreamServerControlConfig 

类型：`class`

服务端合流控制参数。

### ios_enableVolumeIndication  

类型：boolean

是否开启单独发送声音提示 SEI 的功能：
- True：开启；
- False：关闭。（默认值）
开启后，你可以通过 `ByteRTCMixedStreamServerControlConfig.seiContentMode` 控制 SEI 的内容是否只携带声音信息。

### ios_volumeIndicationInterval  

类型：number

声音提示间隔，单位为秒，取值范围为 [0.3,+∞)，默认值为 2。
此值仅取整百毫秒。若传入两位及以上小数，则四舍五入取第一位小数的值。例如，若传入 0.36，则取 0.4。

### ios_talkVolume  

类型：number

有效音量大小，取值范围为 [0, 255]，默认值为 0。
超出取值范围则自动调整为默认值，即 0。

### ios_isAddVolumeValue  

类型：boolean

声音信息 SEI 是否包含音量值：
- True：是；
- False：否，默认值。

### ios_seiContentMode  

类型：$p_i.ByteRTCMixedStreamSEIContentMode

设置 SEI 内容。参看 ByteRTCMixedStreamSEIContentMode。

### ios_seiPayloadType  

类型：number

SEI 信息的 payload type。
默认值为 `100`，只支持设置 `5` 和 `100`。
在转推直播的过程中，该参数不支持变更。

### ios_seiPayloadUUID  

类型：string

SEI 信息的 payload UUID。

### ios_mediaType  

类型：$p_i.ByteRTCMixedStreamMediaType

设置合流推到 CDN 时输出的媒体流类型。参看 ByteRTCMixedStreamMediaType。
默认输出音视频流。支持输出纯音频流，但暂不支持输出纯视频流。

### ios_pushStreamMode  

类型：$p_i.ByteRTCMixedStreamPushMode

设置是否在没有用户发布流的情况下发起转推直播。具体参看 ByteRTCMixedStreamPushMode。
该参数在发起合流任务后的转推直播过程中不支持动态变更。

### android_setSeiPayloadType()  

设置合流转推 SEI 信息的 payload type。

**类型**

  ```ts
  (seiPayloadType: number) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"seiPayloadType","Type":"number","Required":"是","Default":"无","Description":"默认值为 100，只支持设置 5 和 100。\n","children":[],"key":"seiPayloadType"}]
      return (
);
```
  

**返回值**

  this  MixedStreamServerControlConfig，参看 MixedStreamServerControlConfig# MixedStreamServerControlConfig。

### android_getSeiPayloadType()  

获取合流转推 SEI 信息的 payload type。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number

### android_setSeiPayloadUuid()  

设置合流转推 SEI 信息的 Payload UUID。

**类型**

  ```ts
  (seiPayloadUuid: string) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"seiPayloadUuid","Type":"string","Required":"是","Default":"无","Description":"该参数长度需为 32 位，否则会收到错误码为 1091 的回调。该参数每个字符的范围需为 [0, 9] [a, f] [A, F]。
该参数不应带有-字符，如系统自动生成的 UUID 中带有-，则应删去。\n","children":[],"key":"seiPayloadUuid"}]
      return (
);
```
  

**返回值**

  this  MixedStreamServerControlConfig，参看 MixedStreamServerControlConfig# MixedStreamServerControlConfig。

### android_getSeiPayloadUuid()  

获取合流转推 SEI 信息的 Payload UUID。

**类型**

  ```ts
  () => string
  ```

**返回值**

  string

### android_setVolumeIndicationInterval()  

设置声音信息提示间隔。

**类型**

  ```ts
  (volumeIndicationInterval: number) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"volumeIndicationInterval","Type":"number","Required":"是","Default":"无","Description":"提示间隔，单位为秒，取值范围为 [0.3,+∞)，默认值为 2。
此值仅取整百毫秒。若传入两位及以上小数，则四舍五入取第一位小数的值。例如，若传入 0.36，则取 0.4。\n","children":[],"key":"volumeIndicationInterval"}]
      return (
);
```
  

**返回值**

  this

### android_getVolumeIndicationInterval()  

获取音量提示间隔。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number

### android_setEnableVolumeIndication()  

设置是否开启单独发送声音提示 SEI 的功能。

**类型**

  ```ts
  (enableVolumeIndication: boolean) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"enableVolumeIndication","Type":"boolean","Required":"是","Default":"无","Description":"是否开启单独发送声音提示 SEI：
\ntrue：开启；
\nfalse：关闭。（默认值）\n\n","children":[],"key":"enableVolumeIndication"}]
      return (
);
```
  

**返回值**

  this

### android_getEnableVolumeIndication()  

获取是否开启单独发送声音提示 SEI 功能的设置。

**类型**

  ```ts
  () => boolean
  ```

**返回值**

  boolean

### android_setIsAddVolumeValue()  

设置声音信息 SEI 是否包含音量值。

**类型**

  ```ts
  (addVolumeValue: boolean) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"addVolumeValue","Type":"boolean","Required":"是","Default":"无","Description":"是否包含音量值：
\ntrue：包含；
\nfalse：不包含。默认值。\n\n","children":[],"key":"addVolumeValue"}]
      return (
);
```
  

**返回值**

  this

### android_getIsAddVolumeValue()  

获取声音信息 SEI 是否包含音量值的设置。

**类型**

  ```ts
  () => boolean
  ```

**返回值**

  boolean

### android_setSeiContentMode()  

设置 SEI 内容。

**类型**

  ```ts
  (seiContentMode: $p_a.MixedStreamSEIContentMode) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"seiContentMode","Type":"$p_a.MixedStreamSEIContentMode","Required":"是","Default":"无","Description":"SEI 内容，参看 MixedStreamSEIContentMode。\n","children":[],"key":"seiContentMode"}]
      return (
);
```
  

**返回值**

  this

### android_getSeiContentMode()  

获取 SEI 内容设置。

**类型**

  ```ts
  () => $p_a.MixedStreamSEIContentMode
  ```

**返回值**

  $p_a.[MixedStreamSEIContentMode](#mixedstreamseicontentmode)

### android_setTalkVolume()  

设置有效音量大小。

**类型**

  ```ts
  (talkVolume: number) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"talkVolume","Type":"number","Required":"是","Default":"无","Description":"有效音量大小，取值范围为 [0, 255]，默认值为 0。
超出取值范围则自动调整为默认值，即 0。\n","children":[],"key":"talkVolume"}]
      return (
);
```
  

**返回值**

  this

### android_getTalkVolume()  

获取有效音量大小。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number

### android_setPushStreamMode()  

设置是否在没有用户发布流的情况下发起转推直播。

**类型**

  ```ts
  (pushStreamMode: $p_a.MixedStreamPushMode) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"pushStreamMode","Type":"$p_a.MixedStreamPushMode","Required":"是","Default":"无","Description":"合流任务发起模式。具体参看 MixedStreamPushMode。
该参数在发起合流任务后的转推直播过程中不支持动态变更。\n","children":[],"key":"pushStreamMode"}]
      return (
);
```
  

**返回值**

  this

### android_getPushStreamMode()  

获取合流任务发起模式的设置。

**类型**

  ```ts
  () => $p_a.MixedStreamPushMode
  ```

**返回值**

  $p_a.[MixedStreamPushMode](#mixedstreampushmode)

### android_setMediaType()  

设置合流推到 CDN 时输出的媒体流类型。

**类型**

  ```ts
  (mediaType: $p_a.MixedStreamMediaType) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"mediaType","Type":"$p_a.MixedStreamMediaType","Required":"是","Default":"无","Description":"输出的媒体流类型。参看 MixedStreamMediaType。
默认输出音视频流。支持输出纯音频流，但暂不支持输出纯视频流。\n","children":[],"key":"mediaType"}]
      return (
);
```
  

**返回值**

  this

### android_getMediaType()  

获取合流推到 CDN 时输出的媒体流类型设置。

**类型**

  ```ts
  () => $p_a.MixedStreamMediaType
  ```

**返回值**

  $p_a.[MixedStreamMediaType](#mixedstreammediatype)


## LocalAudioStats 

类型：`class`

本地音频流统计信息，统计周期为 2s 。
本地用户发布音频流成功后，SDK 会周期性地通过 `onLocalStreamStats` 通知用户发布的音频流在此次统计周期内的发送状况。此数据结构即为回调给用户的参数类型。

### new LocalAudioStats()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### audioLossRate  

类型：number

音频丢包率。此次统计周期内的音频上行丢包率，取值范围为 [0, 1] 。

### android_sendKBitrate  

类型：number

发送码率。此次统计周期内的音频发送码率，单位为 kbps 。

### recordSampleRate  

类型：number

采集采样率。此次统计周期内的音频采集采样率信息，单位为 Hz 。

### statsInterval  

类型：number

统计间隔。此次统计周期的间隔，单位为 ms 。
此字段用于设置回调的统计周期，默认设置为 2s 。

### rtt  

类型：number

往返时延。单位为 ms 。

### numChannels  

类型：number

音频声道数。

### sentSampleRate  

类型：number

音频发送采样率。此次统计周期内的音频发送采样率信息，单位为 Hz 。

### jitter  

类型：number

音频上行网络抖动，单位为 ms 。

### ios_sentKBitrate  

类型：number

发送的码率。此次统计周期内的音频发送码率，单位为 kbps 。


## MixedStreamVideoConfig 

类型：`class`

视频转码配置参数。值不合法或未设置时，自动使用默认值。

### ios_videoCodec  

类型：$p_i.ByteRTCMixedStreamVideoCodecType

视频编码格式，参看 ByteRTCMixedStreamVideoCodecType。默认值为 `0`。建议设置。
本参数不支持过程中更新。

### ios_width  

类型：number

合流视频宽度。单位为 px，范围为 [2, 1920]，必须是偶数。默认值为 640 px。建议设置。
设置值为非偶数时，自动向上取偶数。

### ios_height  

类型：number

合流视频高度。单位为 px，范围为 [2, 1920]，必须是偶数。默认值为 360 px。建议设置。
设置值为非偶数时，自动向上取偶数。

### ios_fps  

类型：number

合流视频帧率。单位为 FPS，取值范围为 [1,60]，默认值为 15 FPS。建议设置。

### ios_gop  

类型：number

视频 I 帧时间间隔。单位为秒，取值范围为 [1, 5]，默认值为 2 秒。建议设置。
本参数不支持过程中更新。

### ios_bitrate  

类型：number

合流视频码率。单位为 Kbps，取值范围为 [1,10000]，默认值为自适应模式。建议设置。

### ios_enableBFrame  

类型：boolean

是否在合流中开启 B 帧，仅服务端合流支持.

### android_setFps()  

设置合流视频帧率。建议设置。

**类型**

  ```ts
  (fps: number) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"fps","Type":"number","Required":"是","Default":"无","Description":"合流视频帧率。单位为 FPS，取值范围为 [1,60]， 默认值为 15 FPS。\n","children":[],"key":"fps"}]
      return (
);
```
  

**返回值**

  this

### android_getFps()  

获取合流视频帧率。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number

### android_setGop()  

设置视频 I 帧时间间隔。建议设置。
本参数不支持过程中更新。

**类型**

  ```ts
  (gop: number) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"gop","Type":"number","Required":"是","Default":"无","Description":"视频 I 帧时间间隔。单位为秒，取值范围为 [1, 5]，默认值为 2 秒。\n","children":[],"key":"gop"}]
      return (
);
```
  

**返回值**

  this

### android_getGop()  

获取视频 I 帧时间间隔。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number

### android_setBitrate()  

设置合流视频码率。建议设置。

**类型**

  ```ts
  (bitrate: number) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"bitrate","Type":"number","Required":"是","Default":"无","Description":"合流视频码率。单位为 Kbps，取值范围为 [1,10000]，默认值为自适应模式。\n","children":[],"key":"bitrate"}]
      return (
);
```
  

**返回值**

  this

### android_getBitrate()  

获取合流视频码率。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number

### android_setWidth()  

设置合流视频宽度。建议设置。

**类型**

  ```ts
  (width: number) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"width","Type":"number","Required":"是","Default":"无","Description":"合流视频宽度。单位为 px，范围为 [2, 1920]，必须是偶数。默认值为 640 px。
设置值为非偶数时，自动向上取偶数。\n","children":[],"key":"width"}]
      return (
);
```
  

**返回值**

  this

### android_getWidth()  

获取合流视频宽度。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number

### android_setHeight()  

设置合流视频高度。建议设置。

**类型**

  ```ts
  (height: number) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"height","Type":"number","Required":"是","Default":"无","Description":"合流视频高度。单位为 px，范围为 [2, 1920]，必须是偶数。默认值为 360 px。
设置值为非偶数时，自动向上取偶数。\n","children":[],"key":"height"}]
      return (
);
```
  

**返回值**

  this

### android_getHeight()  

获取合流视频高度。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number

### android_setEnableBframe()  

设置是否使用 B 帧（仅在服务端合流生效）。

**类型**

  ```ts
  (enableBframe: boolean) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"enableBframe","Type":"boolean","Required":"是","Default":"无","Description":"是否使用 B 帧。取值含义如下:
\ntrue: 使用 B 帧
\nfalse: 不使用 B 帧\n\n","children":[],"key":"enableBframe"}]
      return (
);
```
  

**返回值**

  this

### android_getEnableBframe()  

获取是否使用 B 帧（仅在服务端合流生效）的设置。

**类型**

  ```ts
  () => boolean
  ```

**返回值**

  boolean

### android_setVideoCodec()  

设置视频编码格式。建议设置。
本参数不支持过程中更新。

**类型**

  ```ts
  (videoCodec: $p_a.MixedStreamVideoCodecType) => this
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"videoCodec","Type":"$p_a.MixedStreamVideoCodecType","Required":"是","Default":"无","Description":"视频编码格式，参看 MixedStreamVideoCodecType。默认值为 MIXED_STREAM_VIDEO_CODEC_TYPE_H264(\"H264\")。\n","children":[],"key":"videoCodec"}]
      return (
);
```
  

**返回值**

  this

### android_getVideoCodec()  

获取视频编码格式。

**类型**

  ```ts
  () => $p_a.MixedStreamVideoCodecType
  ```

**返回值**

  $p_a.[MixedStreamVideoCodecType](#mixedstreamvideocodectype)




## LocalVideoRenderPosition 

类型：`enum`

本地视频帧回调位置。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | AFTER_CAPTURE | `0` | 采集后。 |
  | AFTER_PREPROCESS | `1` | （默认值）前处理后。 |


## RemoteVideoSinkConfig 

类型：`class`

远端视频帧回调配置。

### position  

类型：RemoteVideoRenderPosition

远端视频帧回调位置，参看 [RemoteVideoRenderPosition](#remotevideorenderposition)，默认回调后处理后的视频帧。

### android_pixelFormat  

类型：number

远端视频帧回调格式，参看 [VideoPixelFormat](#videopixelformat)，默认值为 0。

### applyRotation  

类型：VideoApplyRotation

是否将视频帧自动转正，参看 [VideoApplyRotation](#videoapplyrotation)，默认为不旋转。

### mirrorType  

类型：VideoRenderMirrorType

是否将视频帧镜像。参看 [VideoRenderMirrorType](#videorendermirrortype)，默认为不镜像。
本设置与 setRemoteVideoMirrorType （适用于内部渲染）相互独立。

### ios_requiredPixelFormat  

类型：$p_i.ByteRTCVideoSinkPixelFormat

远端视频帧回调格式，参看 ByteRTCVideoSinkPixelFormat，默认值为 0。


## VideoSuperResolutionModeChangedReason 

类型：`enum`

超分状态改变原因。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | VIDEO_SUPER_RESOLUTION_MODE_CHANGED_REASON_API_OFF | `0` | 调用 setRemoteVideoSuperResolution 成功关闭超分。 |
  | VIDEO_SUPER_RESOLUTION_MODE_CHANGED_REASON_API_ON | `1` | 调用 setRemoteVideoSuperResolution 成功开启超分。 |
  | VIDEO_SUPER_RESOLUTION_MODE_CHANGED_REASON_RESOLUTION_EXCEED | `2` | 开启超分失败，远端视频流的原始视频分辨率超过 640 × 360 px。 |
  | VIDEO_SUPER_RESOLUTION_MODE_CHANGED_REASON_OVER_USE | `3` | 开启超分失败，已对一路远端流开启超分。 |
  | VIDEO_SUPER_RESOLUTION_MODE_CHANGED_REASON_DEVICE_NOT_SUPPORT | `4` | 设备不支持使用超分辨率。 |
  | VIDEO_SUPER_RESOLUTION_MODE_CHANGED_REASON_DYNAMIC_CLOSE | `5` | 当前设备性能存在风险，已动态关闭超分。 |
  | VIDEO_SUPER_RESOLUTION_MODE_CHANGED_REASON_OTHER_SETTING_DISABLED | `6` | 超分因其他原因关闭。 |
  | VIDEO_SUPER_RESOLUTION_MODE_CHANGED_REASON_OTHER_SETTING_ENABLED | `7` | 超分因其他原因开启。 |
  | VIDEO_SUPER_RESOLUTION_MODE_CHANGED_REASON_NO_COMPONENT | `8` | SDK 没有编译超分组件。 |
  | VIDEO_SUPER_RESOLUTION_MODE_CHANGED_REASON_STREAM_NOT_EXIST | `9` | 远端流不存在。房间 ID 或用户 ID 无效，或对方没有发布流。 |


## RemoteVideoStats 

类型：`class`

远端视频流统计信息，统计周期为 2s 。
本地用户订阅远端视频流成功后，SDK 会周期性地通过 `onRemoteStreamStats`
通知本地用户订阅的远端视频流在此次统计周期内的接收状况。此数据结构即为回调给本地用户的参数类型。

### new RemoteVideoStats()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### width  

类型：number

远端视频流宽度

### height  

类型：number

远端视频流高度

### videoLossRate  

类型：number

视频丢包率。统计周期内的视频下行丢包率，取值范围为 [0，1] 。

### receivedKBitrate  

类型：number

接收码率。统计周期内的视频接收码率，单位为 kbps 。

### decoderOutputFrameRate  

类型：number

解码器输出帧率。统计周期内的视频解码器输出帧率，单位 fps 。

### android_rendererOutputFrameRate  

类型：number

渲染帧率。统计周期内的视频渲染帧率，单位 fps 。

### stallCount  

类型：number

卡顿次数。统计周期内的卡顿次数。

### stallDuration  

类型：number

卡顿时长。统计周期内的视频卡顿总时长。单位 ms 。

### e2eDelay  

类型：number

用户体验级别的端到端延时，从发送端采集完成编码开始到接收端解码完成渲染开始的延时，单位为毫秒

### isScreen  

类型：boolean

所属用户的媒体流是否为屏幕流。你可以知道当前统计数据来自主流还是屏幕流。

### statsInterval  

类型：number

统计间隔，此次统计周期的间隔，单位为 ms 。
此字段用于设置回调的统计周期，目前设置为 2s 。

### rtt  

类型：number

往返时延，单位为 ms 。

### frozenRate  

类型：number

远端用户在进房后发生视频卡顿的累计时长占视频总有效时长的百分比（\%）。视频有效时长是指远端用户进房发布视频流后，除停止发送视频流和禁用视频模块之外的视频时长。

### codecType  

类型：VideoCodecType

视频的编码类型，具体参考 [VideoCodecType](#videocodectype) 。

### videoIndex  

类型：number

对应多种分辨率的流的下标。

### jitter  

类型：number

视频下行网络抖动，单位为 ms。

### superResolutionMode  

类型：VideoSuperResolutionMode

远端视频超分模式，参看 [VideoSuperResolutionMode](#videosuperresolutionmode)。

### ios_receivedFrameRate  

类型：number

远端视频接收帧率。

### ios_renderOutputFrameRate  

类型：number

远端视频渲染输出帧率。


## VideoApplyRotation 

类型：`enum`

是否将视频帧自动转正。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | DEFAULT | `0` | （默认值）不旋转。 |
  | DEGREE_0 | `1` | 自动转正视频，即根据视频帧的旋转角信息将视频帧旋转到 0 度。 |
  | ByteRTCVideoApplyRotation0 | `2` | 自动转正视频，即根据视频帧的旋转角信息将视频帧旋转到 0 度。 |


## LocalVideoSinkConfig 

类型：`class`

本地视频帧回调配置。

### position  

类型：LocalVideoRenderPosition

本地视频帧回调位置，参看 [LocalVideoRenderPosition](#localvideorenderposition)，默认回调前处理后的视频帧。

### android_pixelFormat  

类型：number

本地视频帧回调格式，参看 [VideoPixelFormat](#videopixelformat)，默认值为 0。

### ios_requiredPixelFormat  

类型：$p_i.ByteRTCVideoSinkPixelFormat

本地视频帧回调格式，参看 ByteRTCVideoSinkPixelFormat，默认值为 0。


## VideoPixelFormat 

类型：`enum`

视频帧的数据格式

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | UNKNOWN | `0` | 未知格式 |
  | I420 | `1` | I420 格式 |
  | NV21 | `2` | NV21 格式 |
  | RGBA | `3` | RGBA 格式 |
  | NV12 | `4` | NV12 格式 |
  | TEXTURE_2D | `5` | Texture2D 格式 |
  | TEXTURE_OES | `6` | TextureOES 格式 |
  | ByteRTCVideoPixelFormatBGRA | `7` | BGRA |
  | ByteRTCVideoPixelFormatIMC2 | `8` | IMC2 |
  | ByteRTCVideoPixelFormatARGB | `9` | ARGB |
  | ByteRTCVideoPixelFormatGLTexture2D | `10` | Opengl Texture2D 纹理 |
  | ByteRTCVideoPixelFormatGLTextureOES | `11` | Opengl OES 纹理 |
  | ByteRTCVideoPixelFormatCVPixelBuffer | `12` | CVPixelBuffer |


## PlayState 

类型：`enum`

音乐播放状态。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | PLAYING | `0` | 播放中。 |
  | PAUSED | `1` | 暂停中。 |
  | FAILED | `2` | 播放失败。 |
  | FINISHED | `3` | 播放结束。 |
  | STOPPED | `4` | 已停止。 |
  | ByteRTCPlayStateStoped | `5` | 已停止。 |


## RecordingFileType 

类型：`enum`

本地录制文件的存储格式

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | AAC | `0` | aac 格式文件 |
  | MP4 | `1` | mp4 格式文件 |


## MixedStreamRenderMode 

类型：`enum`

图片或视频流的缩放模式。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | MIXED_STREAM_RENDER_MODE_HIDDEN | `0` | 视窗填满优先，默认值。
视频尺寸等比缩放，直至视窗被填满。当视频尺寸与显示窗口尺寸不一致时，多出的视频将被截掉。 |
  | MIXED_STREAM_RENDER_MODE_FIT | `1` | 视频帧内容全部显示优先。
视频尺寸等比缩放，优先保证视频内容全部显示。当视频尺寸与显示窗口尺寸不一致时，会把窗口未被填满的区域填充成背景颜色。 |
  | MIXED_STREAM_RENDER_MODE_ADAPTIVE | `2` | 视频帧自适应画布。
视频尺寸非等比例缩放，把窗口充满。在此过程中，视频帧的长宽比例可能会发生变化。 |


## VirtualBackgroundSourceType 

类型：`enum`

虚拟背景类型。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | COLOR | `0` | 使用纯色背景替换视频原有背景。 |
  | IMAGE | `1` | 使用自定义图片背景替换视频原有背景。 |
  | ByteRTCVirtualBackgroundSourceTypeImage | `2` | 使用自定义图片替换视频原有背景。 |


## StandardPitchInfo 

类型：`class`

标准音高数据数组。

### new StandardPitchInfo()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### startTime  

类型：number

开始时间，单位 ms。

### duration  

类型：number

持续时间，单位 ms。

### pitch  

类型：number

音高。


## MediaPlayerCustomSourceStreamType 

类型：`enum`

自定义音频流类型

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | RAW | `0` | 当播放来自本地的 PCM 数据时，使用此选项。 |
  | ENCODED | `1` | 当播放来自内存的音频数据时，使用此选项。 |


## AlphaLayout 

类型：`enum`

Alpha 通道相对于 RGB 通道数据的排列位置。

  | 属性 | 值 | 描述 |
  | :-- | :-- | :-- |
  | TOP | `0` | Alpha 数据置于 RGB 数据上方。 |

	闭麦	开麦
内置扬声器	媒体音量	通话音量
内置听筒	通话音量	通话音量
有线耳机/ USB 耳机/ 外置声卡	媒体音量	媒体音量
蓝牙耳机	媒体音量	媒体音量

实时音视频