## LicenseConfig 类型：`interface` ### AppID 类型：string App ID，必填，从控制台应用管理获取。 ### AppName 类型：string 必填， App 英文名，从控制台应用管理获取。 ### AppVersion 类型：string App 版本号。 ### AppChannel 类型：string 必填，渠道号；业务自定义，如：小米应用商店 (xiaomi)、华为应用市场 (huawei) 等。 ### LicenseUri 类型：{ android: string; ios: string; } 必填，License 路径。 **成员** | 名称 | 类型 | 说明 | | :-- | :-- | :-- | | android | `string` | Android App 的 license 路径。 | | ios | `string` | iOS App 的 license 路径。 | ### openLog 类型：boolean | undefined 是否开启日志上报。 ### UserUniqueID 类型：string | undefined 用户唯一 ID。 ### PackageName 类型：string | undefined Android 应用唯一标识。 ### BundleID 类型：string | undefined iOS 应用唯一标识。 ## VeLiveVideoEncoderConfiguration 类型：`class` 推流视频编码参数。 ### getResolution() 获取推流视频分辨率。 **类型** ```ts () => VeLiveVideoResolution ``` **返回值** [VeLiveVideoResolution](#velivevideoresolution) 推流视频分辨率 [VeLiveVideoResolution](#velivevideoresolution-VeLiveVideoResolution)。 ### setResolution() 设置推流视频分辨率。 **类型** ```ts (resolution: VeLiveVideoResolution) => VeLiveVideoEncoderConfiguration ``` **参数** ```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":"resolution","Type":"VeLiveVideoResolution","Required":"是","Default":"无","Description":"推流视频分辨率，默认值为 VeLiveVideoResolution720P，详情请参见 VeLiveVideoResolution\n","children":[],"key":"resolution"}]
      return ();
```
  

**返回值**

  VeLiveVideoEncoderConfiguration  推流视频编码参数配置对象，详情请参见 [VeLiveVideoEncoderConfiguration](#velivevideoencoderconfiguration-VeLiveVideoEncoderConfiguration)。

### getCodec()  

获取推流视频编码格式。

**类型**

  ```ts
  () => VeLiveVideoCodec
  ```

**返回值**

  [VeLiveVideoCodec](#velivevideocodec)  推流视频编码格式，详情请参见 [VeLiveVideoCodec](#velivevideocodec-VeLiveVideoCodec)。

### setCodec()  

设置推流视频编码格式。

**类型**

  ```ts
  (codec: VeLiveVideoCodec) => VeLiveVideoEncoderConfiguration
  ```

**参数**


```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":"codec","Type":"VeLiveVideoCodec","Required":"是","Default":"无","Description":"推流视频编码格式，详情请参见 VeLiveVideoCodec。\n","children":[],"key":"codec"}]
      return (
);
```
  

**返回值**

  VeLiveVideoEncoderConfiguration  推流视频编码参数，详见 [VeLiveVideoEncoderConfiguration](1317625#velivevideoencoderconfiguration)。

### getBitrate()  

获取推流视频编码码率。

**类型**

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

**返回值**

  number  推流视频编码码率。

### setBitrate()  

设置推流视频编码码率。

**类型**

  ```ts
  (bitrate: number) => VeLiveVideoEncoderConfiguration
  ```

**参数**


```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，默认值由 resolution 参数值决定。\n","children":[],"key":"bitrate"}]
      return (
);
```
  

**返回值**

  VeLiveVideoEncoderConfiguration  推流视频编码参数配置对象，详情请参见 [VeLiveVideoEncoderConfiguration](#velivevideoencoderconfiguration-VeLiveVideoEncoderConfiguration)。

### getMinBitrate()  

获取推流视频编码最小码率。

**类型**

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

**返回值**

  number  推流视频编码最小码率。

### setMinBitrate()  

设置推流视频编码最小码率。

**类型**

  ```ts
  (minBitrate: number) => VeLiveVideoEncoderConfiguration
  ```

**参数**


```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":"minBitrate","Type":"number","Required":"是","Default":"无","Description":"推流视频编码最小码率，单位为 kbps，默认值由 resolution 参数值决定；如果开启自适应码率，推流 SDK 根据网络情况进行编码码率自适应调整的最小码率\n","children":[],"key":"minBitrate"}]
      return (
);
```
  

**返回值**

  VeLiveVideoEncoderConfiguration  推流视频编码参数配置对象，详情请参见 [VeLiveVideoEncoderConfiguration](#velivevideoencoderconfiguration-VeLiveVideoEncoderConfiguration)。

### getMaxBitrate()  

获取推流视频编码最大码率。

**类型**

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

**返回值**

  number  推流视频编码最大码率。

### setMaxBitrate()  

设置推流视频编码最大码率。

**类型**

  ```ts
  (maxBitrate: number) => VeLiveVideoEncoderConfiguration
  ```

**参数**


```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":"maxBitrate","Type":"number","Required":"是","Default":"无","Description":"推流视频编码最大码率，单位为 kbps，默认值由 resolution 参数值决定；如果开启自适应码率，推流 SDK 根据网络情况进行编码码率自适应调整的最大码率。\n","children":[],"key":"maxBitrate"}]
      return (
);
```
  

**返回值**

  VeLiveVideoEncoderConfiguration  推流视频编码参数配置对象，详情请参见 [VeLiveVideoEncoderConfiguration](#velivevideoencoderconfiguration-VeLiveVideoEncoderConfiguration)。

### getGopSize()  

获取推流视频编码 GOP。

**类型**

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

**返回值**

  number  推流视频编码 GOP。

### setGopSize()  

设置推流视频编码 GOP。

**类型**

  ```ts
  (gopSize: number) => VeLiveVideoEncoderConfiguration
  ```

**参数**


```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":"gopSize","Type":"number","Required":"是","Default":"无","Description":"视频 GOP 大小，单位为 s，默认值为 2\n","children":[],"key":"gopSize"}]
      return (
);
```
  

**返回值**

  VeLiveVideoEncoderConfiguration  推流视频编码参数配置对象，详情请参见 [VeLiveVideoEncoderConfiguration](#velivevideoencoderconfiguration-VeLiveVideoEncoderConfiguration)。

### getFps()  

获取推流视频编码帧率。

**类型**

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

**返回值**

  number  推流视频编码帧率。

### setFps()  

设置推流视频编码帧率。

**类型**

  ```ts
  (fps: number) => VeLiveVideoEncoderConfiguration
  ```

**参数**


```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，默认值为 15\n","children":[],"key":"fps"}]
      return (
);
```
  

**返回值**

  VeLiveVideoEncoderConfiguration  推流视频编码参数配置对象，详情请参见 [VeLiveVideoEncoderConfiguration](#velivevideoencoderconfiguration-VeLiveVideoEncoderConfiguration)。

### android_isEnableBFrame()  

获取是否开启 B 帧。

**类型**

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

**返回值**

  boolean  是否开启B帧。
  - true：B 帧开启；
  - false：B 帧关闭。

### setEnableBFrame()  

设置推流视频编码开启 B 帧。

**类型**

  ```ts
  (enableBFrame: boolean) => VeLiveVideoEncoderConfiguration
  ```

**参数**


```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 帧。默认为 false。\\
\ntrue：开启；
\nfalse：关闭。\n\n","children":[],"key":"enableBFrame"}]
      return (
);
```
  

**返回值**

  VeLiveVideoEncoderConfiguration  推流视频编码参数配置对象，详情请参见 [VeLiveVideoEncoderConfiguration](#velivevideoencoderconfiguration-VeLiveVideoEncoderConfiguration)。

### android_isEnableAccelerate()  

获取是否开启硬件编码。

**类型**

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

**返回值**

  boolean  是否开启硬件编码。
  - true：开启；
  - false：关闭。

### setEnableAccelerate()  

设置推流视频编码开启硬件编码。

**类型**

  ```ts
  (enableAccelerate: boolean) => VeLiveVideoEncoderConfiguration
  ```

**参数**


```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":"enableAccelerate","Type":"boolean","Required":"是","Default":"无","Description":"是否开启硬件编码。默认值为 true。\\
\ntrue：开启；
\nfalse：关闭。\n\n","children":[],"key":"enableAccelerate"}]
      return (
);
```
  

**返回值**

  VeLiveVideoEncoderConfiguration  推流视频编码参数配置对象，详情请参见 [VeLiveVideoEncoderConfiguration](#velivevideoencoderconfiguration-VeLiveVideoEncoderConfiguration)。

### initWithResolution()  

初始化方法，用于创建一个 [VeLiveVideoEncoderConfiguration](#velivevideoencoderconfiguration-VeLiveVideoEncoderConfiguration) 对象，并指定视频的分辨率。

**类型**

  ```ts
  (resolution: VeLiveVideoResolution) => 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":"resolution","Type":"VeLiveVideoResolution","Required":"是","Default":"无","Description":"视频的分辨率，详情请参见 VeLiveVideoResolution。\n","children":[],"key":"resolution"}]
      return (
);
```
  

**返回值**

  this  创建的 [VeLiveVideoEncoderConfiguration](#velivevideoencoderconfiguration-VeLiveVideoEncoderConfiguration) 对象。


## VeLiveVideoResolution 

类型：`enum`

推流视频分辨率档位枚举值。

  | 属性 | 值 | 说明 |
  | :-- | :-- | :-- |
  | VeLiveVideoResolution360P | `0` | 360P 分辨率。档位详细配置如下所示。\
                |||- 横屏分辨率：640x360 |\
                |||- 竖屏分辨率：360x640 |\
                |||- 帧率：15fps |\
                |||- 目标码率：500kbps |\
                |||- 最小码率：250kbps |\
                |||- 最大码率：800kbps |
  | VeLiveVideoResolution480P | `1` | 480P 分辨率。档位详细配置如下所示。\
                |||- 横屏分辨率：864x480 |\
                |||- 竖屏分辨率：480x864 |\
                |||- 帧率：15fps |\
                |||- 目标码率：800kbps |\
                |||- 最小码率：320kbps |\
                |||- 最大码率：1266kbps |
  | VeLiveVideoResolution540P | `2` | 540P 分辨率。档位详细配置如下所示。\
                |||- 横屏 960x540 |\
                |||- 竖屏 540x960 |\
                |||- 帧率：15fps |\
                |||- 目标码率：1000kbps |\
                |||- 最小码率：500kbps |\
                |||- 最大码率：1520kbps |
  | VeLiveVideoResolution720P | `3` | 720P 分辨率。档位详细配置如下所示。\
                |||- 横屏 1280x720 |\
                |||- 竖屏 720x1280 |\
                |||- 帧率：15fps |\
                |||- 目标码率：1200kbps |\
                |||- 最小码率：800kbps |\
                |||- 最大码率：1900kbps |
  | VeLiveVideoResolution1080P | `4` | 1080P 分辨率。档位详细配置如下所示。\
                |||- 横屏 1920x1080 |\
                |||- 竖屏 1080x1920 |\
                |||- 帧率：20 fps |\
                |||- 目标码率：2500kbps |\
                |||- 最小码率：1000kbps |\
                |||- 最大码率：3800kbps |
  | VeLiveVideoResolutionScreen | `10` | 屏幕推流分辨率。档位详细配置如下所示。\
                |||- 帧率：15fps |\
                |||- 目标码率：2500kbps |\
                |||- 最小码率：1000kbps |\
                |||- 最大码率：3800kbps |


## VeLiveVideoCodec 

类型：`enum`

视频编码格式。

  | 属性 | 值 | 说明 |
  | :-- | :-- | :-- |
  | VeLiveVideoCodecH264 | `'h264'` | 使用 H.264 视频编码。 |
  | VeLiveVideoCodecByteVC1 | `'bytevc1'` | 使用火山引擎自研 ByteVC1 视频编码。 |


## VeLiveAudioCodec 

类型：`enum`

音频编码格式。

  | 属性 | 值 | 说明 |
  | :-- | :-- | :-- |
  | VeLiveAudioCodecFdkAAC | `0` | FDKAAC 编码。 |
  | VeLiveAudioCodecMediaCodecAAC | `1` | Mediacodec AAC 编码。 |
  | VeLiveAudioCodecFFmpegAAC | `2` | FFMPEG AAC 编码。 |


## VeLivePusherStatistics 

类型：`class`

推流周期性统计信息。

### encodeWidth  

类型：number

视频编码宽度，单位为 px。

### encodeHeight  

类型：number

视频编码高度，单位为 px。

### captureWidth  

类型：number

视频采集宽度，单位为 px。

### captureHeight  

类型：number

视频采集高度，单位为 px。

### captureFps  

类型：number

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

### encodeFps  

类型：number

视频编码帧率，单位为 fps。

### transportFps  

类型：number

视频发送帧率，可用展示实时帧率，单位为 fps。

### fps  

类型：number

视频推流帧率，即您通过 [setVideoEncoderConfiguration](1317622#velivepusher-setvideoencoderconfiguration) 方法设置的帧率，单位为 fps。

### videoBitrate  

类型：number

视频推流码率，即您通过 [setVideoEncoderConfiguration](1317622#velivepusher-setvideoencoderconfiguration) 方法设置的码率，单位为 kbps。

### minVideoBitrate  

类型：number

视频推流最小码率，即您通过 [setVideoEncoderConfiguration](1317622#velivepusher-setvideoencoderconfiguration) 方法设置的最小码率，单位为 kbps。

### maxVideoBitrate  

类型：number

视频推流最大码率，即您通过 [setVideoEncoderConfiguration](1317622#velivepusher-setvideoencoderconfiguration) 方法设置的最大码率，单位为 kbps。

### encodeVideoBitrate  

类型：number

视频编码码率，单位为 kbps。

### transportVideoBitrate  

类型：number

视频发送码率，可用于展示实时码率，单位为 kbps。

### encodeAudioBitrate  

类型：number

音频编码码率，单位为 kbps。

### url  

类型：string

推流地址。

### codec  

类型：string

视频编码格式。


## VeLivePusherRenderMode 

类型：`enum`

推流渲染模式。

  | 属性 | 值 | 说明 |
  | :-- | :-- | :-- |
  | VeLivePusherRenderModeFill | `0` | 视频帧自适应画布。视频帧非等比缩放，直至画布被填满。在此过程中，视频帧的长宽比例可能会发生变化。 |
  | VeLivePusherRenderModeFit | `1` | 视频帧内容全部显示优先。视频尺寸等比缩放，优先保证视频内容全部显示。当视频尺寸与显示窗口尺寸不一致时，会把窗口未被填满的区域填充成背景颜色。 |
  | VeLivePusherRenderModeHidden | `2` | 视窗填满优先。视频帧等比缩放，直至视窗被视频填满。如果视频帧长宽比例与视窗不同，视频帧的多出部分将无法显示。 |


## VeLiveAudioBufferType 

类型：`enum`

推流音频数据类型。

  | 属性 | 值 | 说明 |
  | :-- | :-- | :-- |
  | VeLiveAudioBufferTypeUnknown | `0` | 未知的音频数据类型。 |
  | VeLiveAudioBufferTypeByteBuffer | `1` | ByteBuffer 音频数据类型。 |
  | VeLiveAudioBufferTypeSampleBuffer | `3` | 音频数据类型为 CMSampleBufferRef。 |
  | VeLiveAudioBufferTypeNSData | `2` | 音频数据类型为 NSData。 |


## VeLiveAudioChannel 

类型：`enum`

推流音频声道数，决定音频的立体感。

  | 属性 | 值 | 说明 |
  | :-- | :-- | :-- |
  | VeLiveAudioChannelMono | `1` | 单声道，适用于语音通信，节省带宽。 |
  | VeLiveAudioChannelStereo | `2` | 立体声，适用于音乐播放，提供更丰富的音频体验。 |


## VeLiveFirstFrameType 

类型：`enum`

定义了推流中首帧的类型，包括音视频的采集首帧、渲染首帧、编码完成首帧和发送首帧。

  | 属性 | 值 | 说明 |
  | :-- | :-- | :-- |
  | VeLiveFirstCaptureFrame | `0` | 视频/音频采集首帧，采集首帧是从音频设备或视频设备（如麦克风、摄像头）获取的第一帧数据。 |
  | VeLiveFirstRenderFrame | `1` | 视频渲染首帧，渲染首帧是在渲染过程中在屏幕上显示的第一帧视频数据。 |
  | VeLiveFirstEncodedFrame | `2` | 视频/音频编码完成首帧，编码完成首帧是编码为某种特定格式的第一帧数据。 |
  | VeLiveFirstSendFrame | `3` | 视频/音频发送首帧，发送首帧是在发送过程中，通过网络传输的第一帧数据。 |
  | VeLiveFirstAppAudioCaptureFrame | `4` | 录屏采集开始后，获得的第一个 app 音频帧。 |


## VeLiveVideoCaptureType 

类型：`enum`

视频采集类型。

  | 属性 | 值 | 说明 |
  | :-- | :-- | :-- |
  | VeLiveVideoCaptureFrontCamera | `0` | 使用前置摄像头进行视频采集。 |
  | VeLiveVideoCaptureBackCamera | `1` | 使用后置摄像头进行视频采集。 |
  | VeLiveVideoCaptureDualCamera | `2` | 使用设备的双摄进行视频采集。 |
  | VeLiveVideoCaptureScreen | `3` | 使用屏幕采集。 |
  | VeLiveVideoCaptureExternal | `4` | 使用外部设备或源进行视频采集。 |
  | VeLiveVideoCaptureCustomImage | `5` | 使用指定的静态图片作为视频源。 |
  | VeLiveVideoCaptureLastFrame | `6` | 使用最近采集的一帧图像重复作为视频源。 |
  | VeLiveVideoCaptureDummyFrame | `7` | 使用黑色帧作为视频源，一般用于调试或特殊需求。 |


## VeLiveVideoProfile 

类型：`enum`

相机视频配置枚举类。用于设置相机的视频配置参数，包括视频编码格式和参数等。

  | 属性 | 值 | 说明 |
  | :-- | :-- | :-- |
  | VeLiveVideoProfileUnknown | `0` | 未知的视频配置类型。 |
  | VeLiveVideoProfileH264Baseline | `1` | H.264 编码配置，使用 Baseline 级别。 |
  | VeLiveVideoProfileH264Main | `2` | H.264 编码配置，使用 Main 级别。 |
  | VeLiveVideoProfileH264High | `3` | H.264 编码配置，使用 High 级别。 |
  | VeLiveVideoProfileByteVC1Main | `4` | ByteVC1 编码配置，使用 Main 级别。 |


## VeLiveVideoRotation 

类型：`enum`

视频帧旋转角度。以 App 方向为旋转参考系。

  | 属性 | 值 | 说明 |
  | :-- | :-- | :-- |
  | VeLiveVideoRotation0 | `0` | 不旋转。 |
  | VeLiveVideoRotation90 | `1` | 顺时针旋转 90 度。 |
  | VeLiveVideoRotation180 | `2` | 顺时针旋转 180 度。 |
  | VeLiveVideoRotation270 | `3` | 顺时针旋转 270 度。 |


## VeLiveAudioProfile 

类型：`enum`

AAC 音频编码档位。

  | 属性 | 值 | 说明 |
  | :-- | :-- | :-- |
  | VeLiveAudioAACProfileLC | `0` | LC-AAC 编码方式。 |
  | VeLiveAudioAACProfileHEv1 | `1` | HEv1-AAC 编码方式。 |
  | VeLiveAudioAACProfileHEv2 | `2` | HEv2-AAC 编码方式。 |


## VeLiveAudioCaptureConfiguration 

类型：`class`

音频采集配置。

### getSampleRate()  

获取采集音频采样率。

**类型**

  ```ts
  () => VeLiveAudioSampleRate
  ```

**返回值**

  [VeLiveAudioSampleRate](#veliveaudiosamplerate)  音频采样率，详情请参见 [VeLiveAudioSampleRate](#veliveaudiosamplerate-VeLiveAudioSampleRate)。

### setSampleRate()  

设置采集音频采样率。

**类型**

  ```ts
  (sampleRate: VeLiveAudioSampleRate) => VeLiveAudioCaptureConfiguration
  ```

**参数**


```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":"sampleRate","Type":"VeLiveAudioSampleRate","Required":"是","Default":"无","Description":"音频采样率，默认值为 VeLiveAudioSampleRate44100，详情请参见 VeLiveAudioSampleRate。\n","children":[],"key":"sampleRate"}]
      return (
);
```
  

**返回值**

  VeLiveAudioCaptureConfiguration  推流音频采集参数配置对象，详情请参见 [VeLiveAudioCaptureConfiguration](#veliveaudiocaptureconfiguration)

### getChannel()  

获取采集音频声道数。

**类型**

  ```ts
  () => VeLiveAudioChannel
  ```

**返回值**

  [VeLiveAudioChannel](#veliveaudiochannel)  音频声道数，详情请参见 [VeLiveAudioChannel](#veliveaudiochannel-VeLiveAudioChannel)。

### setChannel()  

设置采集音频声道数。

**类型**

  ```ts
  (channel: VeLiveAudioChannel) => VeLiveAudioCaptureConfiguration
  ```

**参数**


```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":"channel","Type":"VeLiveAudioChannel","Required":"是","Default":"无","Description":"音频声道数，默认值为 VeLiveAudioChannelStereo，详情请参见 VeLiveAudioChannel\n","children":[],"key":"channel"}]
      return (
);
```
  

**返回值**

  VeLiveAudioCaptureConfiguration  推流音频采集参数配置对象，详情请参见 [VeLiveAudioCaptureConfiguration](#veliveaudiocaptureconfiguration)。


## VeLiveAudioSampleRate 

类型：`enum`

推流音频采样率。

  | 属性 | 值 | 说明 |
  | :-- | :-- | :-- |
  | VeLiveAudioSampleRate8000 | `8000` | 8k 采样。 |
  | VeLiveAudioSampleRate16000 | `16000` | 16k 采样。 |
  | VeLiveAudioSampleRate32000 | `32000` | 32k 采样。 |
  | VeLiveAudioSampleRate44100 | `44100` | 44.1k 采样。 |
  | VeLiveAudioSampleRate48000 | `48000` | 48k 采样。 |


## VeLiveAudioPowerLevel 

类型：`enum`

音量等级，用于评估和控制音频的响度。

  | 属性 | 值 | 说明 |
  | :-- | :-- | :-- |
  | VeLiveAudioPowerLevelSilent | `0` | 无声，音量 ≤1db。 |
  | VeLiveAudioPowerLevelQuiet | `1` | 安静，音量 15db 以下。 |
  | VeLiveAudioPowerLevelLight | `2` | 轻声，接近耳语音量，音量为 16db～30db 之间。 |
  | VeLiveAudioPowerLevelNormal | `3` | 正常，音量适宜，类似正常对话的音量，音量为 30db～60db 之间。 |
  | VeLiveAudioPowerLevelLoud | `4` | 较大，音量较高，类似咖啡馆、餐厅的环境噪音，音量为 61db～85db 之间。 |
  | VeLiveAudioPowerLevelNoise | `6` | 吵闹，音量极高，类似于繁忙的街道或者是音乐会现场，音量超过 85db。 |


## VeLiveVideoCaptureConfiguration 

类型：`class`

视频采集配置。

### getWidth()  

获取采集视频宽度。

**类型**

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

**返回值**

  number  采集视频宽度。

### setWidth()  

设置采集视频宽度。

**类型**

  ```ts
  (width: number) => VeLiveVideoCaptureConfiguration
  ```

**参数**


```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":"采集视频宽度，默认值为 720。\n","children":[],"key":"width"}]
      return (
);
```
  

**返回值**

  VeLiveVideoCaptureConfiguration  推流视频采集参数配置对象，详情请参见 [VeLiveVideoCaptureConfiguration](#velivevideocaptureconfiguration)。

### getHeight()  

获取采集视频高度。

**类型**

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

**返回值**

  number  采集视频高度。

### setHeight()  

设置采集视频高度。

**类型**

  ```ts
  (height: number) => VeLiveVideoCaptureConfiguration
  ```

**参数**


```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":"采集视频高度，默认值为 1280。\n","children":[],"key":"height"}]
      return (
);
```
  

**返回值**

  VeLiveVideoCaptureConfiguration  推流视频采集参数配置对象，详情请参见 [VeLiveVideoCaptureConfiguration](#velivevideocaptureconfiguration)。

### getFps()  

获取采集视频帧率。

**类型**

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

**返回值**

  number  采集视频帧率。

### setFps()  

设置采集视频帧率。

**类型**

  ```ts
  (fps: number) => VeLiveVideoCaptureConfiguration
  ```

**参数**


```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":"采集视频帧率，默认值为 15。\n","children":[],"key":"fps"}]
      return (
);
```
  

**返回值**

  VeLiveVideoCaptureConfiguration  推流视频采集参数配置对象，详情请参见 [VeLiveVideoCaptureConfiguration](#velivevideocaptureconfiguration)。


## VeLivePusherStatus 

类型：`enum`

推流器与服务器的连接状态。

  | 属性 | 值 | 说明 |
  | :-- | :-- | :-- |
  | VeLivePushStatusNone | `0` | 初始状态。 |
  | VeLivePushStatusConnecting | `1` | 正在连接服务器。 |
  | VeLivePushStatusConnectSuccess | `2` | 连接服务器成功。 |
  | VeLivePushStatusReconnecting | `3` | 重连服务器中。 |
  | VeLivePushStatusConnectStop | `4` | 推流连接被终止。 |
  | VeLivePushStatusConnectError | `5` | 推流连接失败。 |
  | VeLivePushStatusDisconnected | `6` | 与服务器断开连接。 |


## VeLiveNetworkQuality 

类型：`enum`

网络质量/状态。

  | 属性 | 值 | 说明 |
  | :-- | :-- | :-- |
  | VeLiveNetworkQualityUnknown | `0` | 未查询到网络状态。 |
  | VeLiveNetworkQualityBad | `1` | 网络差。 |
  | VeLiveNetworkQualityPoor | `2` | 网络一般。 |
  | VeLiveNetworkQualityGood | `3` | 网络状态佳。 |


## VeLivePusherLogLevel 

类型：`enum`

输出的日志级别。

  | 属性 | 值 | 说明 | 平台 | 
  | :-- | :-- | :-- | :-- |
  | VeLiveLogLevelVerbose | `'AVLog.VERBOSE'` | 输出 VERBOSE、DEBUG、INFO、WARNING 和 ERROR 级别的日志。 |iOS|
  | VeLiveLogLevelDebug | `'AVLog.DEBUG'` | 输出 DEBUG、INFO、WARNING 和 ERROR 级别的日志。 |iOS|
  | VeLiveLogLevelInfo | `'AVLog.INFO'` | 输出 INFO、WARNING 和 ERROR 级别的日志。 |iOS|iOS|
  | VeLiveLogLevelWarn | `'AVLog.WARN'` | 输出 WARNING 和 ERROR 级别的日志。 |iOS|
  | VeLiveLogLevelError | `'AVLog.ERROR'` | 输出 ERROR 级别的日志。 |iOS|
  | VeLiveLogLevelNone | `'AVLog.NONE'` | 关闭日志。 |iOS|
  | VeLivePusherLogLevelVerbose | `0` | 输出 VERBOSE、DEBUG、INFO、WARNING 和 ERROR 级别的日志。 |Android|
  | VeLivePusherLogLevelDebug | `1` | 输出 DEBUG、INFO、WARNING 和 ERROR 级别的日志。 |Android|
  | VeLivePusherLogLevelInfo | `2` | 输出 INFO、WARNING 和 ERROR 级别的日志。 |Android|
  | VeLivePusherLogLevelWarn | `3` | 输出 WARNING 和 ERROR 级别的日志。 |Android|
  | VeLivePusherLogLevelError | `4` | 输出 ERROR 级别的日志。 |Android|
  | VeLivePusherLogLevelNone | `5` | 关闭日志。 |Android|


## VeLiveOrientation 

类型：`enum`

推流横竖屏模式。

  | 属性 | 值 | 说明 |
  | :-- | :-- | :-- |
  | VeLiveOrientationLandscape | `0` | 横屏模式。 |
  | VeLiveOrientationPortrait | `1` | 竖屏模式。 |


## VeLiveVideoMirrorType 

类型：`enum`

视频镜像类型。

  | 属性 | 值 | 说明 |
  | :-- | :-- | :-- |
  | VeLiveVideoMirrorCapture | `0` | 对采集画面的镜像控制。开启时，预览和推流画面都会呈现为镜像状态。 |
  | VeLiveVideoMirrorPreview | `1` | 对预览画面的镜像控制。开启时，只有主播预览画面呈现镜像状态。 |
  | VeLiveVideoMirrorPushStream | `2` | 对编码前画面的镜像控制。开启时，主播推流画面呈现镜像状态。 |


## VeLiveFileRecorderConfiguration 

类型：`class`

推流本地文件录制配置。

### getWidth()  

获取录制视频宽度。

**类型**

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

**返回值**

  number  录制视频宽度。

### setWidth()  

设置录制视频宽度。

**类型**

  ```ts
  (width: number) => VeLiveFileRecorderConfiguration
  ```

**参数**


```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":"录制视频宽度，默认值为 360\n","children":[],"key":"width"}]
      return (
);
```
  

**返回值**

  VeLiveFileRecorderConfiguration  推流本地文件录制配置对象，详情请参见 [VeLiveFileRecorderConfiguration](#velivefilerecorderconfiguration)。

### getHeight()  

获取录制视频高度。

**类型**

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

**返回值**

  number  录制视频高度。

### setHeight()  

设置录制视频高度。

**类型**

  ```ts
  (height: number) => VeLiveFileRecorderConfiguration
  ```

**参数**


```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":"录制视频宽度，默认值为 640。\n","children":[],"key":"height"}]
      return (
);
```
  

**返回值**

  VeLiveFileRecorderConfiguration  推流本地文件录制配置对象，详情请参见 [VeLiveFileRecorderConfiguration](#velivefilerecorderconfiguration)。

### getFps()  

获取录制视频帧率。

**类型**

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

**返回值**

  number  录制视频帧率。

### setFps()  

设置录制视频帧率。

**类型**

  ```ts
  (fps: number) => VeLiveFileRecorderConfiguration
  ```

**参数**


```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":"录制视频帧率，默认值为 15。\n","children":[],"key":"fps"}]
      return (
);
```
  

**返回值**

  VeLiveFileRecorderConfiguration  推流本地文件录制配置对象，详情请参见 [VeLiveFileRecorderConfiguration](#velivefilerecorderconfiguration)。

### getBitrate()  

获取录制视频码率。

**类型**

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

**返回值**

  number  录制视频码率。

### setBitrate()  

设置录制视频码率。

**类型**

  ```ts
  (bitrate: number) => VeLiveFileRecorderConfiguration
  ```

**参数**


```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，默认值为 2000。\n","children":[],"key":"bitrate"}]
      return (
);
```
  

**返回值**

  VeLiveFileRecorderConfiguration  推流本地文件录制配置对象，详情请参见 [VeLiveFileRecorderConfiguration](#velivefilerecorderconfiguration)。


## VeLiveAudioEncoderConfiguration 

类型：`class`

推流音频编码参数。

### getBitrate()  

获取推流音频编码码率。

**类型**

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

**返回值**

  number  推流音频编码码率。

### setBitrate()  

设置推流音频编码码率。

**类型**

  ```ts
  (bitrate: number) => VeLiveAudioEncoderConfiguration
  ```

**参数**


```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，默认值为 64。\n","children":[],"key":"bitrate"}]
      return (
);
```
  

**返回值**

  VeLiveAudioEncoderConfiguration  推流音频编码参数配置对象，详情请参见 [VeLiveAudioEncoderConfiguration](#veliveaudioencoderconfiguration)。

### getSampleRate()  

获取推流音频采样率。

**类型**

  ```ts
  () => VeLiveAudioSampleRate
  ```

**返回值**

  [VeLiveAudioSampleRate](#veliveaudiosamplerate)  推流音频采样率。详情请参见 [VeLiveAudioSampleRate](#veliveaudiosamplerate-VeLiveAudioSampleRate)。

### setSampleRate()  

设置推流音频采样率。

**类型**

  ```ts
  (sampleRate: VeLiveAudioSampleRate) => VeLiveAudioEncoderConfiguration
  ```

**参数**


```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":"sampleRate","Type":"VeLiveAudioSampleRate","Required":"是","Default":"无","Description":"推流音频采样率，默认值为 VeLiveAudioSampleRate44100，详情请参见 VeLiveAudioSampleRate。\n","children":[],"key":"sampleRate"}]
      return (
);
```
  

**返回值**

  VeLiveAudioEncoderConfiguration  推流音频编码参数配置对象，详情请参见 [VeLiveAudioEncoderConfiguration](#veliveaudioencoderconfiguration)。

### getChannel()  

获取推流音频声道。

**类型**

  ```ts
  () => VeLiveAudioChannel
  ```

**返回值**

  [VeLiveAudioChannel](#veliveaudiochannel)  推流音频声道。详情请参见 [VeLiveAudioChannel](#veliveaudiochannel-VeLiveAudioChannel)。

### setChannel()  

设置推流音频声道。

**类型**

  ```ts
  (channel: VeLiveAudioChannel) => VeLiveAudioEncoderConfiguration
  ```

**参数**


```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":"channel","Type":"VeLiveAudioChannel","Required":"是","Default":"无","Description":"推流音频声道，默认值为 VeLiveAudioChannelStereo，详情请参见 VeLiveAudioChannel。\n","children":[],"key":"channel"}]
      return (
);
```
  

**返回值**

  VeLiveAudioEncoderConfiguration  推流音频编码参数配置对象，详情请参见 [VeLiveAudioEncoderConfiguration](#veliveaudioencoderconfiguration)。

### getProfile()  

获取推流音频编码类型。

**类型**

  ```ts
  () => VeLiveAudioProfile
  ```

**返回值**

  [VeLiveAudioProfile](#veliveaudioprofile)  推流音频编码类型。详情请参见 [VeLiveAudioProfile](#veliveaudioprofile-VeLiveAudioProfile)。

### setProfile()  

设置推流音频编码类型。

**类型**

  ```ts
  (profile: VeLiveAudioProfile) => VeLiveAudioEncoderConfiguration
  ```

**参数**


```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":"profile","Type":"VeLiveAudioProfile","Required":"是","Default":"无","Description":"推流音频编码类型，默认值为 VeLiveAudioAACProfileLC，详情请参见 VeLiveAudioProfile。\n","children":[],"key":"profile"}]
      return (
);
```
  

**返回值**

  VeLiveAudioEncoderConfiguration  推流音频编码参数配置对象，详情请参见 [VeLiveAudioEncoderConfiguration](#veliveaudioencoderconfiguration)。


## VeLiveAudioCaptureType 

类型：`enum`

音频采集类型。

  | 属性 | 值 | 说明 |
  | :-- | :-- | :-- |
  | VeLiveAudioCaptureMicrophone | `0` | 使用默认麦克风设备进行音频采集。 |
  | VeLiveAudioCaptureVoiceCommunication | `1` | 使用语音通话模式进行音频采集，此模式下会启动硬件的 3A 功能，即自动增益控制、自动频率控制和自动噪声抑制。 |
  | VeLiveAudioCaptureVoiceRecognition | `2` | 使用录屏直播无障碍音频模式进行音频采集。 |
  | VeLiveAudioCaptureExternal | `3` | 使用外部设备或源进行音频采集。 |
  | VeLiveAudioCaptureMuteFrame | `4` | 使用静音帧作为音频源。 |


## InitOptions 

类型：`interface`

### viewId  

类型：string

视图 ID

### element  

类型：unknown

视图元素，推流渲染元素的 ref

### videoConfig  

类型：{ width?: number | undefined; height?: number | undefined; fps?: number | undefined; } | undefined

视频配置

 **成员**

  | 名称 | 类型 | 说明 |
  | :-- | :-- | :-- |
  | width | `number | undefined` | 视频宽度 |
  | height | `number | undefined` | 视频高度 |
  | fps | `number | undefined` | 视频帧率 |
视频直播
