wangjiyu
/
rtc_plugins
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
rtc_plugins/include/MRTCEngineDefine.hpp

2357 lines
91 KiB
C++
Raw Normal View History

repo init
2025-04-09 10:34:51 +08:00
#ifndef __RTC_ENGINE_DEFINE_HPP___
#define __RTC_ENGINE_DEFINE_HPP___
#include <memory>
#include <vector>
#ifdef WIN32
#include "MRTCEnginePlatForm.hpp"
#endif
#include <string>
#include <stdarg.h>
#include <math.h>
// namespace
//////////////////////////////////////////////////////////////////////////
#define RTCENGINE_NAMESPACE_BEGIN namespace mrtc {
#define RTCENGINE_NAMESPACE mrtc
#define RTCENGINE_NAMESPACE_END }
// macro WIN32
//////////////////////////////////////////////////////////////////////////
#ifdef WIN32
#ifdef RTCENGINE_DLL
#ifdef RTCENGINE_EXPORTS
#define RTCENGINE_API __declspec(dllexport)
#define RTCENGINE_API_CPP
#else
#define RTCENGINE_API __declspec(dllimport)
#define RTCENGINE_API_CPP
#endif
#else
#define RTCENGINE_API
#define RTCENGINE_API_CPP
#endif
#elif defined(__ANDROID__)
#define RTCENGINE_API
#define RTCENGINE_API_CPP __attribute__ ((visibility ("default")))
#else
#define RTCENGINE_API
#define RTCENGINE_API_CPP
#endif
// Macos Or IOS.
//////////////////////////////////////////////////////////////////////////
#ifdef __APPLE__
#include <TargetConditionals.h>
#include <CoreVideo/CoreVideo.h>
#if TARGET_OS_OSX
/// 单元测试现在仅mac可用
#define MRTC_TEST_ABILITY_AVAILABLE 1
#endif
#ifdef __OBJC__
using PixelBufferRef = CVPixelBufferRef;
#else
using PixelBufferRef = void*;
#endif
#endif //__APPLE__
// Disable copy funciton.
#ifndef DELETE_CTOR_COPY
#define DELETE_CTOR_COPY(className) \
className(const className &) = delete; \
className &operator=(const className &) = delete
#endif
// Disable constructor and copy function.
#ifndef DELETE_COPY
#define DELETE_COPY(className) \
className() = default; \
DELETE_CTOR_COPY(className)
#endif
#ifdef WIN32
#define INLINE __forceinline
#else
#define INLINE inline
#endif
#if defined(__ANDROID__)
#include "jni.h"
#endif
RTCENGINE_NAMESPACE_BEGIN
// 回调基函数
class RTCENGINE_API RTCENGINE_API_CPP IMRTCBaseCallBack
{
public:
virtual ~IMRTCBaseCallBack() = default;
};
struct MRTCCustomDataObject final
{
std::string peerId;
uint8_t* data = nullptr;
size_t data_length = 0;
uint64_t delay_time = 0;
};
// 消息回调 引擎异步消息通知
class RTCENGINE_API RTCENGINE_API_CPP IMRTCMessageCallBack : virtual public IMRTCBaseCallBack
{
public:
DELETE_COPY(IMRTCMessageCallBack);
virtual ~IMRTCMessageCallBack() override = default;
virtual void onCallBackMessage(uint32_t msgId, const char* msg) = 0;
virtual void onCallBackCustomData(MRTCCustomDataObject object) = 0;
};
class RTCENGINE_API RTCENGINE_API_CPP IMRTCCallBackMessageNULL final : public IMRTCMessageCallBack
{
public:
DELETE_COPY(IMRTCCallBackMessageNULL);
virtual void onCallBackMessage(uint32_t msgId, const char* mssg) override
{
}
virtual void onCallBackCustomData(MRTCCustomDataObject object) override {
}
};
// 监听类型
enum MRTCListenerType
{
TYPE_LISTENER_ROOM = 0x00, // 房间状态
TYPE_LISTENER_PRODUCER = 0x01, // 生产者状态
TYPE_LISTENER_CONSUMER = 0x02, // 消费者状态
TYPE_LISTENER_DATA_PRODUCER = 0x03, // 数据生产者状态
TYPE_LISTENER_DATA_CONSUMER = 0x04, // 数据消费者状态
TYPE_LISTENER_REPORT_MONITOR = 0x05, // 报告监控回调消息
TYPE_LISTENER_DEVICE_MONITOR = 0x06, // 设备变动回调消息
TYPE_LISTENER_REPORT_STATISTICS = 0x07, // 回调音视频质量数据
TYPE_LISTENER_RTM_ROOM = 0x08, // RTM 房间状态
TYPE_LISTENER_REPORT_NETWORKING_STATUS = 0x09, // 回调网络状态
};
// 视频回调类型
enum MRTCVideoListenerType
{
TYPE_CAMERA_PRODUCER = 0x00, // 摄像头生产者
TYPE_SCREEN_PRODUCER, // 屏幕分享生产者
TYPE_CAMERA_CONSUMER, // 摄像头消费者
TYPE_SCREEN_CONSUMER, // 屏幕分享消费者
TYPE_FILE_VIDEO_PRODUCER, // 视频分享的视频生产者
TYPE_FILE_VIDEO_CONSUMER, // 视频分享的视频消费者
TYPE_CUSTOM_VIDEO_PRODUCER, // 自定义视频生产者
TYPE_CUSTOM_VIDEO_CONSUMER, // 自定义视频消费者
TYPE_CUSTOM_SECOND_VIDEO_PRODUCER, // 自定义第二路视频生产者
TYPE_CUSTOM_SECOND_VIDEO_CONSUMER, // 自定义第二路视频消费者
TYPE_CUSTOM_RAW_VIDEO_CONSUMER, // 自定义编码后视频消费者
};
// 视频数据格式
enum MRTCVideoDataType
{
TYPE_VIDEO_I420,
TYPE_VIDEO_ARGB,
};
enum MRTCVideoEncodedCodecType
{
TYPE_VIDEO_H264,
TYPE_VIDEO_H265
};
// 视频裸数据格式
enum MRTCVideoRawDataType
{
TYPE_VIDEO_RAW_H264,
TYPE_VIDEO_RAW_H265,
};
enum MRTCVideoEncodedFrameType
{
TYPE_VIDEO_FRAME_I,
TYPE_VIDEO_FRAME_P,
TYPE_VIDEO_FRAME_B
};
// 视频类型
enum MRTCVideoSourceType
{
TYPE_VIDEO_SOURCE_NONE = 0x00,
TYPE_VIDEO_SOURCE_CAMERA = 0x01, // 摄像头
TYPE_VIDEO_SOURCE_SCREEN = 0x02, // 屏幕分享
TYPE_VIDEO_SOURCE_VIDEO = 0x03, // 视频文件
TYPE_VIDEO_SOURCE_CUSTOM = 0x04, // 外部传入视频
TYPE_VIDEO_SOURCE_CUSTOM_SECOND = 0x05, // 外部传入第二路视频
TYPE_VIDEO_SOURCE_RAW = 0x06, // 外部传入裸视频流
};
// 音频类型
enum MRTCAudioSourceType
{
TYPE_AUDIO_SOURCE_NONE = 0x00,
TYPE_AUDIO_SOURCE_MIC = 0x01, // 麦克风
TYPE_AUDIO_SOURCE_DESKTOP = 0x02, // 桌面音频
TYPE_AUDIO_SOURCE_MUSIC = 0x03, // 背景音乐
TYPE_AUDIO_SOURCE_VIDEO = 0x04, // 视频分享
TYPE_AUDIO_SOURCE_EFFECT = 0x05, // 音频特效
TYPE_AUDIO_SOURCE_CUSTOM = 0x06, // 外部传入音频
TYPE_AUDIO_SOURCE_CUSTOM_DATA = 0x07, // dataChannel通道传入音频数据
};
// 自定义视频通道id
enum MRTCPublishChannel {
MRTCPublishChannelOne = 0x00,
MRTCPublishChannelTwo = 0x01,
};
// 视频流类型
enum MRTCVideoStreamType
{
TYPE_VIDEO_STREAM_DEFAULT = 0x00, // 默认自适应
TYPE_VIDEO_STREAM_SMALL = 0x01, // 小流
TYPE_VIDEO_STREAM_BIG = 0x02, // 大流
};
struct MRTCRoomStatus final
{
DELETE_COPY(MRTCRoomStatus);
char reason[256] = { 0 };
};
// 房间回调类型
enum MRTCRoomStatusType
{
TYPE_STATUS_ROOM_JOIN = 0x00, // 进入房间
TYPE_STATUS_ROOM_LEAVE = 0x01, // 离开房间
TYPE_STATUS_ROOM_RECONNECT_BEGIN = 0x02,// 重连开始
TYPE_STATUS_ROOM_RECONNECT_END = 0x03, // 重连结束
TYPE_STATUS_ROOM_RECONNECT_FAILED = 0x04,// 重连失败
TYPE_STATUS_ROOM_CLEAR_USER_LIST = 0x05,// 清理房间用户列表 和 视频窗口
TYPE_EVENT_ROOM_JOIN_FAILED = 0x06, // 加入房间失败
TYPE_STATUS_ROOM_REJOIN_CONNECT_BEGIN = 0x07,// ReJoin重连开始
TYPE_STATUS_ROOM_REJOIN_CONNECT_END = 0x08, // ReJoin重连结束
TYPE_STATUS_ROOM_REJOIN_CONNECT_FAILED = 0x09,// ReJoin重连失败
TYPE_STATUS_ROOM_CLOSE_CONFIRM = 0x0A, // 房间关闭
TYPE_STATUS_ROOM_USER_KICKED_OUT = 0x0B, // 用户被踢
TYPE_STATUS_ROOM_PEER_LIST = 0x0C, // 加入房间时，房间内已有有用户列表
};
// 房间回调类型
enum MRTMRoomStatusType
{
TYPE_STATUS_RTM_ROOM_JOIN = 0x00, // 进入房间
TYPE_STATUS_RTM_ROOM_LEAVE = 0x01, // 离开房间
TYPE_STATUS_RTM_ROOM_RECONNECT_BEGIN = 0x02,// 重连开始
TYPE_STATUS_RTM_ROOM_RECONNECT_END = 0x03, // 重连结束
TYPE_STATUS_RTM_ROOM_RECONNECT_FAILED = 0x04,// 重连失败
TYPE_STATUS_RTM_ROOM_CLEAR_USER_LIST = 0x05,// 清理房间用户列表 和 视频窗口
TYPE_EVENT_RTM_ROOM_JOIN_FAILED = 0x06, // 加入房间失败
TYPE_STATUS_RTM_ROOM_REJOIN_CONNECT_BEGIN = 0x07,// ReJoin重连开始
TYPE_STATUS_RTM_ROOM_REJOIN_CONNECT_END = 0x08, // ReJoin重连结束
TYPE_STATUS_RTM_ROOM_REJOIN_CONNECT_FAILED = 0x09,// ReJoin重连失败
TYPE_STATUS_RTM_ROOM_CLOSE_CONFIRM = 0x0A, // 房间关闭
TYPE_ROOM_USER_LIST_RESULT = 0x0B, // 用户列表
};
// 消费者回调类型
enum MRTCConsumerStatusType
{
// Consumer Start Or Stop
TYPE_STATUS_CONSUMER_START = 0x00, // 消费者开始 若是视频Consumer此处需注册视频显示回调窗口
TYPE_STATUS_CONSUMER_STOP, // 消费者停止
TYPE_STATUS_CONSUMER_PAUSE, // 消费者暂停状态
TYPE_STATUS_CONSUMER_RESUME, // 消费者继续状态
TYPE_STATUS_CONSUMER_LAYERS_CHANGE, // 消费者分层信息改变
TYPE_STATUS_CONSUMER_SCORE, // 消费者视频得分
TYPE_STATUS_CONSUMER_ACTIVE_SPEAKER, // 消费者麦克强度信息
// Data Consumer Start Or Stop
TYPE_STATUS_DATA_CONSUMER_START, // 数据消费者开启
TYPE_STATUS_DATA_CONSUEMR_STOP, // 数据消费者关闭
// User Join Or Leave
TYPE_STATUS_USER_JOIN, // 用户加入房间
TYPE_STATUS_USER_LEAVE, // 用户离开房间
TYPE_STATUS_USER_DISPLAYNAME_CHAGE, // DisplayName改变
};
// 生产者回调类型
enum MRTCProducerStatusType
{
TYPE_PRODUCER_STATUS_SCORE, // 生产者视频得分
TYPE_PRODUCER_STATUS_SUCCESS, // 生产者开启成功
TYPE_PRODUCER_STATUS_FAILURE, // 生产者开启失败
TYPE_PRODUCER_STATUS_FORBIDDEN, // 生产者被禁止
TYPE_PRODUCER_STATUS_RESUMED, // 生产者被回复
};
// 设备监控类型
enum MRTCDeviceMonitorType
{
TYPE_DEVICE_AUDIO_CAPTURE_CHANGED, // 音频采集设备状态改变
TYPE_DEVICE_AUDIO_RENDER_CHANGED, // 音频播放设备状态改变
TYPE_DEVICE_AUDIO_CAPTURE_ADD, // 音频采集设备新增
TYPE_DEVICE_AUDIO_CAPTURE_REMOVE, // 音频采集设备移除
TYPE_DEVICE_AUDIO_RENDER_ADD, // 音频播放设备新增
TYPE_DEVICE_AUDIO_RENDER_REMOVE, // 音频播放设备移除
TYPE_DEVICE_VIDEO_CAPTURE_CHANGED, // 视频设备状态改变
TYPE_DEVICE_VIDEO_CAPTURE_ADD, // 视频采集设备新增
TYPE_DEVICE_VIDEO_CAPTURE_REMOVE, // 视频采集设备移除
};
// 房间用户回调信息
struct MRTCRoomUserInfo final
{
//DELETE_COPY(MRTCRoomUserInfo);
char deviceFlag[256] = { 0 };
char deviceName[256] = { 0 };
char deviceVersion[256] = { 0 };
char displayName[256] = { 0 };
char userId[256] = { 0 };
char roomId[256] = { 0 };
};
struct MRTCRoomInfo final {
char roomId[256] = { 0 };
char displayName[256] = { 0 };
char userId[256] = { 0 };
// 加入类型会有此参数值
std::vector<MRTCRoomUserInfo> userInfo;
// 部分接口可能会有值
char message[256] = { 0 };
};
// 房间用户回调信息
struct MRTMRoomUserInfo final
{
//DELETE_COPY(MRTCRoomUserInfo);
char displayName[256] = { 0 };
char userId[256] = { 0 };
};
struct MRTMRoomInfo final {
char roomId[256] = { 0 };
// 部分接口可能会有值
char reason[256] = { 0 };
char displayName[256] = { 0 };
char userId[256] = { 0 };
};
// 用户角色
enum MRTCClientRole
{
TYPE_CLIENT_ROLE_ANCHOR, // 主播
TYPE_CLIENT_ROLE_AUDIENCE, // 观众
};
// 房间状态
class RTCENGINE_API RTCENGINE_API_CPP IMRTCRoomCallBack : virtual public IMRTCBaseCallBack
{
public:
DELETE_COPY(IMRTCRoomCallBack);
virtual ~IMRTCRoomCallBack() override = default;
virtual void onRoom(uint32_t typeId, MRTCRoomInfo& roomInfo) = 0;
};
class RTCENGINE_API RTCENGINE_API_CPP MRTCRoomNULLCallBack final : public IMRTCRoomCallBack
{
public:
DELETE_COPY(MRTCRoomNULLCallBack);
void onRoom(uint32_t typeId, MRTCRoomInfo& roomInfo) override
{
}
};
// RTM 房间状态
class RTCENGINE_API RTCENGINE_API_CPP IMRTMRoomCallBack : virtual public IMRTCBaseCallBack
{
public:
DELETE_COPY(IMRTMRoomCallBack);
virtual ~IMRTMRoomCallBack() override = default;
virtual void onRTMRoom(uint32_t typeId, MRTMRoomInfo& roomInfo) = 0;
};
class RTCENGINE_API RTCENGINE_API_CPP MRTMRoomNULLCallBack final : public IMRTMRoomCallBack
{
public:
DELETE_COPY(MRTMRoomNULLCallBack);
void onRTMRoom(uint32_t typeId, MRTMRoomInfo& roomInfo) override
{
}
};
// Producer Score
struct MRTCScoreData final
{
// DELETE_COPY(MRTCScoreData);
char rId[20] = { 0 };
int8_t score = 0;
int32_t ssrc = 0;
};
// TYPE_PRODUCER_STATUS_SCORE
struct MRTCProducerScore final
{
// DELETE_COPY(MRTCProducerScore);
size_t arrayLen = 0;
std::unique_ptr<MRTCScoreData[]> scoreData{ nullptr };
};
// Producer回调数据结构
//TYPE_STATUS_PRODUCER_INFO
struct MRTCProducerInfo final
{
// DELETE_COPY(MRTCProducerInfo);
char producerId[256] = { 0 };
char kind[50] = { 0 };
char peerId[256] = { 0 };
MRTCAudioSourceType audioSourceType = TYPE_AUDIO_SOURCE_NONE;
MRTCVideoSourceType videoSourceType = TYPE_VIDEO_SOURCE_NONE;
// 某个生产者视频得分
MRTCProducerScore score;
uint8_t channelIndex = 0;
char roomId[256] = { 0 };
char streamId[256] = { 0 };
};
// 生产者状态回调
class RTCENGINE_API RTCENGINE_API_CPP IMRTCProduerCallBack : virtual public IMRTCBaseCallBack
{
public:
DELETE_COPY(IMRTCProduerCallBack);
virtual ~IMRTCProduerCallBack() override = default;
virtual void onProducer(uint32_t msgId, MRTCProducerInfo& info) = 0;
};
class RTCENGINE_API RTCENGINE_API_CPP MRTCProduerNULLCallBack final : public IMRTCProduerCallBack
{
public:
DELETE_COPY(MRTCProduerNULLCallBack);
void onProducer(uint32_t msgId, MRTCProducerInfo& info) override
{
}
};
// 消费者媒体类型
enum MRTCConsumerMediaType
{
TYPE_CONSUMER_MEDIA_AUDIO = 0x00, // 音频
TYPE_CONSUMER_MEDIA_VIDEO = 0x01, // 视频
};
// Consumer 回调数据结构
//TYPE_STATUS_CONSUMER_INFO
struct MRTCConsumerInfo final
{
// DELETE_COPY(MRTCConsumerInfo);
char producerId[256] = { 0 };
char kind[50] = { 0 };
char type[50] = { 0 };
bool producerPaused;
char consumerId[256] = { 0 };
char roomId[256] = { 0 };
const char* m_customDataParam = nullptr;
const char* m_streamID = nullptr;
char displayName[256] = { 0 };
// 需要默认值，否则部分情况下解析有异常
MRTCConsumerMediaType mediaType = TYPE_CONSUMER_MEDIA_AUDIO;
MRTCAudioSourceType audioSourceType = TYPE_AUDIO_SOURCE_NONE;
MRTCVideoSourceType videoSourceType = TYPE_VIDEO_SOURCE_NONE;
// 某个消费者分层信息改变
int spatiaLayer;
int temporalLayer;
// 某个消费者视频得分
int8_t producerScore;
int8_t score;
uint8_t channelIndex = 0;
char m_extraParam[521] = { 0 };
};
// 消费者状态回调
class RTCENGINE_API RTCENGINE_API_CPP IMRTCConsumerCallBack : virtual public IMRTCBaseCallBack
{
public:
DELETE_COPY(IMRTCConsumerCallBack);
virtual ~IMRTCConsumerCallBack() override = default;
virtual void onConsumer(uint32_t msgId, const char* roomId, const char* peerId, MRTCConsumerInfo& consumerInfo) = 0;
};
class RTCENGINE_API RTCENGINE_API_CPP MRTCConsumerNULLCallBack final : public IMRTCConsumerCallBack
{
public:
DELETE_COPY(MRTCConsumerNULLCallBack);
void onConsumer(uint32_t msgId, const char* roomId, const char* peerId, MRTCConsumerInfo& consumerInfo) override
{
}
};
// 数据生产者回调
class RTCENGINE_API RTCENGINE_API_CPP IMRTCDataProduerCallBack : virtual public IMRTCBaseCallBack
{
public:
DELETE_COPY(IMRTCDataProduerCallBack);
virtual ~IMRTCDataProduerCallBack() override = default;
virtual void onDataProducer(uint32_t msgId, void* param) = 0;
};
class RTCENGINE_API RTCENGINE_API_CPP MRTCDataProduerNULLCallBack final : public IMRTCDataProduerCallBack
{
public:
DELETE_COPY(MRTCDataProduerNULLCallBack);
void onDataProducer(uint32_t msgId, void* param) override
{
}
};
// 数据消费者回调
class RTCENGINE_API RTCENGINE_API_CPP IMRTCDataConsumerCallBack : virtual public IMRTCBaseCallBack
{
public:
DELETE_COPY(IMRTCDataConsumerCallBack);
virtual ~IMRTCDataConsumerCallBack() override = default;
virtual void onDataConsumer(uint32_t msgId, const char* userId, void* param) = 0;
};
class RTCENGINE_API RTCENGINE_API_CPP MRTCDataConsumerNULLCallBack final : public IMRTCDataConsumerCallBack
{
public:
DELETE_COPY(MRTCDataConsumerNULLCallBack);
void onDataConsumer(uint32_t msgId, const char* userId, void* param) override
{
}
};
// 权限请求回调
class RTCENGINE_API RTCENGINE_API_CPP IMRTCRequestCallBack : virtual public IMRTCBaseCallBack
{
public:
DELETE_COPY(IMRTCRequestCallBack);
virtual ~IMRTCRequestCallBack() override = default;
virtual void onRequest() = 0;
};
class RTCENGINE_API RTCENGINE_API_CPP IMRTCRequestCallBackNULL final : public IMRTCRequestCallBack
{
public:
DELETE_COPY(IMRTCRequestCallBackNULL);
void onRequest() override
{
}
};
// 音频数据帧
struct MRTCAudioFrame final
{
// DELETE_COPY(MRTCAudioFrame);
int16_t* data = nullptr;
int dataCount = 0;
int sampleRate = 48000;
int numChannels = 1;
int channelIndex = 0;
};
// 视频帧数据
struct MRTCVideoFrame final
{
// DELETE_COPY(MRTCVideoFrame);
MRTCVideoDataType dataType;
uint8_t* data = nullptr;
uint8_t* datau = nullptr;
uint8_t* datav = nullptr;
int width = 0;
int height = 0;
int rotation = 0;
void* extra = nullptr;
int64_t timestampus = 0;
char szInternalSeiInfo[2048] = {0};
char szExternalSeiInfo[2048] = { 0 };
uint8_t channelIndex = 0;
#ifdef __APPLE__
PixelBufferRef pixelBufferRef;
#endif
#ifdef __ANDROID__
jobject androidVideoFrameBuffer;
#endif
#ifdef __LINUX__
#endif
};
struct MRTCVideoEncodedFrame final
{
DELETE_COPY(MRTCVideoEncodedFrame);
MRTCVideoEncodedCodecType codecType;
uint8_t* data = nullptr; //回调返回后, data会被释放,避免指向此内存
uint32_t size = 0;
int width = 0;
int height = 0;
bool isKeyFrame = false;
int64_t timestampus = 0;
uint8_t channelIndex = 0;
};
// 视频帧数据
struct MRTCRawVideoFrame final
{
DELETE_COPY(MRTCRawVideoFrame);
MRTCVideoRawDataType dataType;
uint8_t* data = nullptr;
int len = 0;
int width = 0;
int height = 0;
int64_t timestampus = 0;
uint8_t channelIndex = 0;
};
// 渲染模式
enum MRTCRenderModeType
{
TYPE_RENDER_MODE_SCALE_ASPECTFIT = 0x00, ///< 等比缩放，可能有黑边
TYPE_RENDER_MODE_SCALE_ASPECTFILL = 0x01, ///< 等比缩放填充整View，可能有部分被裁减
TYPE_RENDER_MODE_SCALE_TO_FILL = 0x02, ///< 填充整个View
};
// 视频窗口View
struct MRTCVideoView final
{
void* hWnd = nullptr; // windows窗口句柄
uint8_t channelIndex = 0;
char roomId[256] = { 0 };
MRTCRenderModeType eRenderMode = TYPE_RENDER_MODE_SCALE_ASPECTFIT; //渲染模式
};
// Video Render数据回调
class RTCENGINE_API RTCENGINE_API_CPP IMRTCVideoRenderCallBack : virtual public IMRTCBaseCallBack
{
public:
DELETE_COPY(IMRTCVideoRenderCallBack);
virtual ~IMRTCVideoRenderCallBack() override = default;
virtual void onRender(const char* roomId, const char* peerId, MRTCVideoSourceType sourceType, const MRTCVideoFrame& videoFrame) = 0;
};
class RTCENGINE_API RTCENGINE_API_CPP MRTCVideoRenderNULLCallBack final : public IMRTCVideoRenderCallBack
{
public:
DELETE_COPY(MRTCVideoRenderNULLCallBack);
void onRender(const char* roomId, const char* peerId, MRTCVideoSourceType sourceType, const MRTCVideoFrame& videoFrame) override
{
}
};
// 远端视频编码数据回调
class RTCENGINE_API IMRTCRemoteEncodedVideoCallBack : virtual public IMRTCBaseCallBack
{
public:
DELETE_COPY(IMRTCRemoteEncodedVideoCallBack);
virtual ~IMRTCRemoteEncodedVideoCallBack() override = default;
virtual void onRemoteVideoEncodedData(const char* roomId, const char* userId, MRTCVideoSourceType sourceType, const MRTCVideoEncodedFrame& videoEncodedFrame) = 0;
};
// 报告监控信息回调
class RTCENGINE_API RTCENGINE_API_CPP IMRTCReportMonitorCallBack : virtual public IMRTCBaseCallBack
{
public:
DELETE_COPY(IMRTCReportMonitorCallBack);
virtual ~IMRTCReportMonitorCallBack() override = default;
virtual void onReportMonitorData(const char* key, const char* value) = 0;
};
class RTCENGINE_API RTCENGINE_API_CPP MRTCReportMonitoNULLCallBack final : public IMRTCReportMonitorCallBack
{
public:
DELETE_COPY(MRTCReportMonitoNULLCallBack);
void onReportMonitorData(const char* key, const char* value) override
{
}
};
// 设备监控信息回调
class RTCENGINE_API RTCENGINE_API_CPP IMRTCDeviceMonitorCallBack : virtual public IMRTCBaseCallBack
{
public:
DELETE_COPY(IMRTCDeviceMonitorCallBack);
virtual ~IMRTCDeviceMonitorCallBack() override = default;
virtual void onDeviceMonitorData(MRTCDeviceMonitorType type, void* param) = 0;
};
class RTCENGINE_API RTCENGINE_API_CPP MRTCDeviceMonitorNULLCallBack final : public IMRTCDeviceMonitorCallBack
{
public:
DELETE_COPY(MRTCDeviceMonitorNULLCallBack);
virtual void onDeviceMonitorData(MRTCDeviceMonitorType type, void* param) override
{
}
};
// 音量声浪值回调
class RTCENGINE_API IMRTCReceivedAudioInfoCallBack : virtual public IMRTCBaseCallBack
{
public:
DELETE_COPY(IMRTCReceivedAudioInfoCallBack);
virtual ~IMRTCReceivedAudioInfoCallBack() override = default;
virtual void onSoundLevelUpdate(const char* roomId, const char* peerId, uint16_t audioSourceType,uint8_t channelIndex, uint16_t volume, int32_t vad) = 0;
virtual void onAudioProcess(const char* roomId, const char* peerId, MRTCAudioFrame& audioFrame, MRTCAudioSourceType audioSourceType) = 0;
};
class MRTCAudioReceiveNULLCallBack final : public IMRTCReceivedAudioInfoCallBack
{
public:
DELETE_COPY(MRTCAudioReceiveNULLCallBack);
virtual void onSoundLevelUpdate(const char* roomId, const char* peerId, uint16_t audioSourceType,uint8_t channelIndex, uint16_t volume, int32_t vad) override
{
}
virtual void onAudioProcess(const char* roomId, const char* peerId, MRTCAudioFrame& audioFrame, MRTCAudioSourceType audioSourceType) override
{
}
};
// 背景音乐进度回调
class RTCENGINE_API RTCENGINE_API_CPP IMRTCMusicProcessCallBack : virtual public IMRTCBaseCallBack
{
public:
DELETE_COPY(IMRTCMusicProcessCallBack);
virtual ~IMRTCMusicProcessCallBack() override = default;
virtual void onMusicProcess(uint64_t pos, uint64_t totalTime) = 0;
};
class RTCENGINE_API RTCENGINE_API_CPP IMRTCMusicProcessNULLCallBack final : public IMRTCMusicProcessCallBack
{
public:
DELETE_COPY(IMRTCMusicProcessNULLCallBack);
void onMusicProcess(uint64_t pos, uint64_t totalTime) override
{
}
};
// 视频分享进度回调
class RTCENGINE_API RTCENGINE_API_CPP IMRTCVideoProcessCallBack : virtual public IMRTCBaseCallBack
{
public:
DELETE_COPY(IMRTCVideoProcessCallBack);
virtual ~IMRTCVideoProcessCallBack() override = default;
virtual void onVideoProcess(uint64_t pos, uint64_t totalTime) = 0;
};
class RTCENGINE_API RTCENGINE_API_CPP IMRTCVideoProcessNULLCallBack final : public IMRTCVideoProcessCallBack
{
public:
DELETE_COPY(IMRTCVideoProcessNULLCallBack);
void onVideoProcess(uint64_t pos, uint64_t totalTime) override
{
}
};
// 音效播放器回调
class RTCENGINE_API RTCENGINE_API_CPP IMRTCAudioEffectCallBack : virtual public IMRTCBaseCallBack
{
public:
DELETE_COPY(IMRTCAudioEffectCallBack);
virtual ~IMRTCAudioEffectCallBack() override = default;
virtual void onAudioEffectProcess(int32_t audioEffectID, uint64_t pos, uint64_t totalTime) = 0;
};
class RTCENGINE_API RTCENGINE_API_CPP IMRTCAudioEffectNULLCallBack : public IMRTCAudioEffectCallBack
{
public:
DELETE_COPY(IMRTCAudioEffectNULLCallBack);
virtual ~IMRTCAudioEffectNULLCallBack() override = default;
virtual void onAudioEffectProcess(int32_t audioEffectID, uint64_t pos, uint64_t totalTime) override
{
}
};
// 音效播放器加载资源回调
class RTCENGINE_API RTCENGINE_API_CPP IMRTCAudioEffectLoadResourceCallBack : virtual public IMRTCBaseCallBack
{
public:
DELETE_COPY(IMRTCAudioEffectLoadResourceCallBack);
virtual ~IMRTCAudioEffectLoadResourceCallBack() override = default;
virtual void onLoadResourceProcess(int32_t audioEffectID, uint32_t process, int32_t errorCode) = 0;
};
class RTCENGINE_API RTCENGINE_API_CPP IMRTCAudioEffectLoadResourceNULLCallBack : public IMRTCAudioEffectLoadResourceCallBack
{
public:
DELETE_COPY(IMRTCAudioEffectLoadResourceNULLCallBack);
virtual ~IMRTCAudioEffectLoadResourceNULLCallBack() override = default;
virtual void onLoadResourceProcess(int32_t audioEffectID, uint32_t process, int32_t errorCode) override
{
}
};
// 数据结构
//////////////////////////////////////////////////////////////////////////
// 音效播放器配置
struct MRTCAudioEffectPlayConfig final
{
};
// 引擎配置
struct MRTCEngineConfig final
{
char applicationId[256] = { 0 };
char appSecrectKey[256] = { 0 };
char domain[256] = { 0 };
unsigned short port;
int nMaxTries = -1;
int nFactor = 2;
int nMinTimeout = 1000;
int nMaxTimeout = 8 * 1000;
};
// 登录授权
struct MRTCJoinAuthority final
{
//DELETE_COPY(MRTCJoinAuthority);
char applicationId[256] = { 0 };
char appSecretKey[256] = { 0 };
char token[256] = { 0 };
long long startTime = 0 ;
long expiredTime = 0;
// V2鉴权参数
char invokeRoomId[256] = "null";
long invokeStartTs = 0;
int invokeExpireTime = 10;
};
// 协议类型
enum MRTCProtocolType
{
TYPE_PROTOCOL_INVALID = 0x00,
TYPE_PROTOCOL_WEBSOCKET = 0x01,
TYPE_PROTOCOL_SOCKETIO = 0x02,
TYPE_PROTOCOL_DATACHANNEL = 0x03,
};
// RTC場景类型
enum MRTCSceneType
{
SCENE_MEETING = 0x00, // 会议场景
SCENE_LIVESTREAM = 0x01, // 直播场景
};
// 强制视频类型
enum MRTCForceVideoType
{
TYPE_FORCE_DEFAULT = 0x00,
TYPE_FORCE_H264 = 0x01,
};
// 登录参数配置
constexpr auto STREAM_LEVEL_DEFAULT_VALUE = 3;
struct MRTCJoinConfig final
{
int streamLeavel = STREAM_LEVEL_DEFAULT_VALUE;
MRTCForceVideoType forceType = TYPE_FORCE_DEFAULT; //废弃
MRTCProtocolType protocolType = TYPE_PROTOCOL_INVALID;
MRTCSceneType rtcScene = MRTCSceneType::SCENE_MEETING;
MRTCClientRole clientRole = MRTCClientRole::TYPE_CLIENT_ROLE_ANCHOR;
bool audioChannelsStereo = false;
bool enablePlayout = true;
char m_nUrlConnectTs[50] = { 0 };
bool enableFec = false; // 是否开启fec，默认开启后，会关闭大小流，目前两路流不支持同时fec
bool enableRobot = false; // 是否为机器人，默认为false。机器人加入房间不会被其他用户看到，用于拨测、审核等特殊场景
#if defined(__APPLE__) && TARGET_OS_IPHONE
bool useMediaVolume = false; // 使用媒体音量 (默认false 使用通话音量) 【如果设置过-setAlwaysDisableMediaVolum:为true，此功能失效】
bool reduceOthersVolume = false; // 是否压低其它音量 (默认true)
#endif
};
struct MRTMJoinConfig final
{
MRTCProtocolType protocolType = TYPE_PROTOCOL_INVALID;
char m_nUrlConnectTs[50] = {0};
};
enum AecFilterLength {
kNormal, //(Default) 48ms for normal environment.
kLong, //200ms for reverberant environment.
kLongest //480ms for highly reverberant environment.
};
enum AnsSuppressionMode {
kMild, //(Default) Low suppression level with only statistical ns enabled.
kModerate, //Moderate suppression level with both statistical and ai ns enabled.
kAggressive //High suppression level with both statistical and ai ns enabled.
};
enum MRTCAudioEncodeType
{
MRTCAudioEncodeAac = 0x00,
MRTCAudioEncodeOpus = 0x01,
};
// 音频参数
struct MRTCAudioOption
{
uint32_t sampleRate = 48000;
uint8_t channel = 2;
bool echoCancellation = true;
bool autoGain = true;
bool highPass = true;
bool noiseSuppression = true;
bool experAgc = true;
bool experNS = true;
bool bReconnectRecoverSharedAudio = false;
char streamID[256] = { 0 };
MRTCAudioSourceType sourceType = TYPE_AUDIO_SOURCE_NONE;
// 通道号，pugc linux 在使用时channelIndex从1开始，0预留给类前端外部采集封装接口
uint8_t channelIndex = 0;
// 推流房间号
char dstRoomId[256] = { 0 };
bool externalProcess = false; //使用独立的3A处理
// bool enableAudioDump = false; //打开音频文件pcm存储
// char dumpPath[512] = { 0 }; //音频文件存储路径
AecFilterLength aecOption = kNormal; //独立3A处理的回声消除参数
AnsSuppressionMode ansOption = kMild; //独立3A处理的智能降噪参数
MRTCAudioEncodeType audioEncodeType = MRTCAudioEncodeOpus;
char extraParam[256] = { 0 }; // 额外参数
};
struct MRTCSuperResolutionOption
{
char peerId[256] = { 0 };
bool enable = false;
MRTCVideoSourceType sourceType = TYPE_VIDEO_SOURCE_NONE;
};
// 硬件设备类型
enum MRTCMediaDeviceType
{
TYPE_HW_AUDIO_MICROPHONE = 0x00, // 麦克风
TYPE_HW_AUDIO_SPEAKER = 0x01, // 扬声器
TYPE_HW_VIDEO_CAMERA = 0x02, // 摄像头
};
// 屏幕分享类型
enum MRTCScreenShareType
{
TYPE_SHARE_SCREEN = 0x01, // 屏幕分享
TYPE_SHARE_WINDOW = 0x02, // 分享窗口
};
// 编码画质等级
enum MRTCVideoEncodeQuality
{
DEFAULT_VIDEO_ENCODE_QUALITY = 0x00,
LOW_VIDEO_ENCODE_QUALITY = 0x01,
MEDIUM_VIDEO_ENCODE_QUALITY = 0x02,
HIGH_VIDEO_ENCODE_QUALITY = 0x03,
};
enum MRTCSafeMode {
LIMIT_IP_FREQUENCY = 0x00,// 控制IP请求频次,一分钟两次,原来2s一次，可能会降低网络监测敏感度
};
enum MRTCNetworkState
{
MRTCNetworkStateGood = 0,
MRTCNetworkStateNormal,
MRTCNetworkStateBad,
MRTCNetworkStateTerrible,
MRTCNetworkStateInvalid,
};
// 视频参数基类
struct RTCENGINE_API MRTCVideoOption
{
MRTCVideoOption(MRTCVideoSourceType type = TYPE_VIDEO_SOURCE_NONE) { sourceType = type; }
MRTCVideoSourceType sourceType = TYPE_VIDEO_SOURCE_NONE;
int16_t width = 0;
int16_t height = 0;
int16_t fps = 15;
int32_t maxVideoBW = 0;
int32_t minVideoBW = 0;
bool mirror = false;
int32_t startVideoBW = 0;
int32_t noLayersBW = 0;
mutable int16_t numSpatialLayers = 2;
// 控制自适应网络带宽变化引起的分辨率降低至的最小宽高值
int limitMinAdaptResolutionWidth = 0;
int limitMinAdaptResolutionHeight = 0;
// 编码画质等级
MRTCVideoEncodeQuality videoEncodeQuality = MEDIUM_VIDEO_ENCODE_QUALITY;
char streamID[256] = { 0 }; // 推流流ID标识
uint8_t channelIndex = 0; // 通道号
char dstRoomId[256] = { 0 }; // 推流房间号
char extraParam[256] = { 0 }; // 额外参数
int gop = -1; // GOP,单位：s
int nVideoType = 0; //0 H264 1 H265
bool isAbsoluteRatio = false;
};
// 打开摄像头推流参数
struct RTCENGINE_API MRTCPublishOption : public MRTCVideoOption
{
MRTCPublishOption() : MRTCVideoOption(TYPE_VIDEO_SOURCE_CAMERA) {}
};
// 打开摄像头预览参数
struct RTCENGINE_API MRTCCameraOption : public MRTCVideoOption
{
MRTCCameraOption() : MRTCVideoOption(TYPE_VIDEO_SOURCE_CAMERA) {}
intptr_t cameraId = -1;
#if defined(__ANDROID__)
jobject pAndroidCameraProxyObj = nullptr; // android业务层代理
#endif
};
// 打开屏幕分享参数
struct RTCENGINE_API MRTCScreenOption final : public MRTCVideoOption
{
MRTCScreenOption() : MRTCVideoOption(TYPE_VIDEO_SOURCE_SCREEN) {}
intptr_t screenOrWindowId = -1;
MRTCScreenShareType type = TYPE_SHARE_SCREEN;
bool bReconnectRecoverSharedScreen = false;
bool enableHighPrecisionCapture = false;//是否开启高精度捕获
bool enableCroppingWindow = false;
bool enableBorder = false;
bool enableCursor = true;
#if defined(__ANDROID__)
jobject pAndroidCameraProxyObj = nullptr; // android业务层代理
#endif
};
// 打开视频文件分享参数
struct RTCENGINE_API MRTCVideoFileOption final : public MRTCVideoOption
{
MRTCVideoFileOption() : MRTCVideoOption(TYPE_VIDEO_SOURCE_VIDEO) {}
};
// 打开自定义视频流参数
struct RTCENGINE_API MRTCCustomVideoOption : public MRTCVideoOption
{
MRTCCustomVideoOption() : MRTCVideoOption(TYPE_VIDEO_SOURCE_CUSTOM) {}
};
// 打开自定义视频流参数
struct RTCENGINE_API MRTCCustomRawVideoOption : public MRTCVideoOption
{
MRTCCustomRawVideoOption() : MRTCVideoOption(TYPE_VIDEO_SOURCE_RAW){}
//int nVideoType = 1; //0 H264 1 V264 2 v265 3 H265
};
// 视频编码参数
struct RTCENGINE_API MRTCVideoEncodeOption : public MRTCVideoOption {
};
struct RTCENGINE_API MRTCMultiRoomOption final
{
char roomId[256] = { 0 };
char authDays[256] = { 0 };
char authCurTime[256] = { 0 };
char sign[256] = { 0 };
bool reconnect = false;
};
//
// To String 方法，使用
//
inline std::string formatString(const char* format, ...) {
va_list args;
va_start(args, format);
int iLen = vsnprintf(nullptr, 0, format, args);
va_end(args);
char* pLogBuffer;
pLogBuffer = reinterpret_cast<char *>(malloc(iLen * 4 + 4));
if (!pLogBuffer) {
return "";
}
pLogBuffer[0] = '\0';
va_start(args, format);
vsnprintf(pLogBuffer, iLen + 1, format, args);
va_end(args);
std::string result = std::string(pLogBuffer);
free(pLogBuffer);
return result;
}
// 音视频质量数据
//////////////////////////////////////////////////////////////////////////
// 本地音频质量数据
struct MRTCLocalAudioStats final
{
char userId[256] = { 0 };
char roomId[256] = { 0 };
char srcRoomId[256] = { 0 };
int audioRtt = 0;
int audioLostRate = 0;
int audioTotalLostRate = 0;
uint8_t channelIndex = 0;
int64_t audioSendbytes = 0;
int64_t audioSendBitrate = 0;
MRTCAudioSourceType audioSourceType = TYPE_AUDIO_SOURCE_NONE;
MRTCNetworkState networkState = MRTCNetworkStateInvalid;
// 20241121 视讯要求新增
double sysCpuUsage = 0;
double appCpuUsage = 0;
int32_t appMemUsage = 0;
int32_t sysMemUsage = 0;
char streamId[256] = { 0 };
std::string ToString(){
return formatString("userId:%s, roomId:%s, srcRoomId:%s, audioRtt:%d, audioLostRate:%d, audioTotalLostRate:%d, channelIndex:%d, audioSendbytes:%lld, audioSendBitrate:%lld, audioSourceType:%d",
userId, roomId, srcRoomId, audioRtt, audioLostRate, audioTotalLostRate, channelIndex, audioSendbytes, audioSendBitrate, audioSourceType);
}
};
// 本地视频质量数据
struct MRTCLocalVideoStats final
{
char userId[256] = { 0 };
char roomId[256] = { 0 };
char srcRoomId[256] = { 0 };
int frameWidth = 0;
int frameHeight = 0;
int videoInputFrameRate = 0;
int videoSendFrameRate = 0;
int videoRtt = 0;
int videoLostRate = 0;
int videoTotalLostRate = 0;
uint8_t channelIndex = 0;
int64_t videoSendbytes = 0;
int64_t videoSendBitrate = 0;
int layerIndex = 0;
MRTCVideoSourceType videoSourceType = TYPE_VIDEO_SOURCE_NONE;
MRTCNetworkState networkState = MRTCNetworkStateInvalid;
// 20241121 视讯要求新增
double_t sysCpuUsage = 0;
double_t appCpuUsage = 0;
int32_t sysMemUsage = 0;
int32_t appMemUsage = 0;
char streamId[256] = { 0 };
std::string ToString() {
return formatString(
"userId:%s, roomId:%s, srcRoomId:%s, videoRtt:%d, videoLostRate:%d, audioTotalLostRate:%d, channelIndex:%d, videoSendbytes:%lld, videoSendBitrate:%lld, videoSourceType:%d, frameWidth:%d, frameHeight:%d, videoInputFrameRate:%d, videoSendFrameRate:%d, layerIndex:%d",
userId, roomId, srcRoomId, videoRtt, videoLostRate, videoTotalLostRate, channelIndex, videoSendbytes, videoSendBitrate, videoSourceType, frameWidth, frameHeight, videoInputFrameRate,
videoSendFrameRate, layerIndex);
}
};
// 远端音频质量数据
struct MRTCRemoteAudioStats final
{
char localUserId[256] = { 0 };
char userId[256] = { 0 };
char roomId[256] = { 0 };
char srcRoomId[256] = { 0 };
int audioRtt = 0;
int audioLostRate = 0;
int audioTotalLostRate = 0;
uint8_t channelIndex = 0;
int64_t audioRecvbytes = 0;
int64_t audioRecvBitrate = 0;
MRTCAudioSourceType audioSourceType = TYPE_AUDIO_SOURCE_NONE;
MRTCNetworkState networkState = MRTCNetworkStateInvalid;
// 20241121 视讯要求新增
double sysCpuUsage = 0;
double appCpuUsage = 0;
int32_t sysMemUsage = 0;
int32_t appMemUsage = 0;
char streamId[256] = { 0 };
std::string ToString(){
return formatString("userId:%s, roomId:%s, srcRoomId:%s, audioRtt:%d, audioLostRate:%d, audioTotalLostRate:%d, channelIndex:%d, audioRecvbytes:%lld, audioRecvBitrate:%lld, audioSourceType:%d",
userId, roomId, srcRoomId, audioRtt, audioLostRate, audioTotalLostRate, channelIndex, audioRecvbytes, audioRecvBitrate, audioSourceType);
}
};
// 远端视频质量数据
struct MRTCRemoteVideoStats final
{
char localUserId[256] = { 0 };
char userId[256] = { 0 };
char roomId[256] = { 0 };
char srcRoomId[256] = { 0 };
int frameWidth = 0;
int frameHeight = 0;
int videoRecvFrameRate = 0;
int videoRtt = 0;
int videoLostRate = 0;
int videoTotalLostRate = 0;
uint8_t channelIndex = 0;
int64_t videoRecvbytes = 0;
int64_t videoRecvBitrate = 0;
long videoReceiveDelayMs = 0;
MRTCVideoSourceType videoSourceType = TYPE_VIDEO_SOURCE_NONE;
MRTCNetworkState networkState = MRTCNetworkStateInvalid;
// 20241121 视讯要求新增
double sysCpuUsage = 0;
double appCpuUsage = 0;
int32_t appMemUsage = 0;
int32_t sysMemUsage = 0;
char streamId[256] = { 0 };
std::string ToString(){
return formatString(
"userId:%s, roomId:%s, srcRoomId:%s, videoRtt:%d, videoLostRate:%d, audioTotalLostRate:%d, channelIndex:%d, videoRecvbytes:%lld, videoRecvBitrate:%lld, videoSourceType:%d, frameWidth:%d, frameHeight:%d, videoRecvFrameRate:%d, videoReceiveDelayMs:%ld",
userId, roomId, srcRoomId, videoRtt, videoLostRate, videoTotalLostRate, channelIndex, videoRecvbytes, videoRecvBitrate, videoSourceType, frameWidth, frameHeight, videoRecvFrameRate,
videoReceiveDelayMs);
}
};
// 音视频质量数据回调
class RTCENGINE_API RTCENGINE_API_CPP IMRTCStatisticsCallBack : virtual public IMRTCBaseCallBack
{
public:
DELETE_COPY(IMRTCStatisticsCallBack);
virtual ~IMRTCStatisticsCallBack() override = default;
// 本地音频质量回调
virtual void onLocalAudioStats(MRTCLocalAudioStats& stats) = 0;
// 本地视频质量回调
virtual void onLocalVideoStats(MRTCLocalVideoStats& stats) = 0;
// 远端音频质量回调
virtual void onRemoteAudioStats(MRTCRemoteAudioStats& stats) = 0;
// 远端视频质量回调
virtual void onRemoteVideoStats(MRTCRemoteVideoStats& stats) = 0;
};
class RTCENGINE_API RTCENGINE_API_CPP MRTCStatisticsNULLCallBack final : public IMRTCStatisticsCallBack
{
public:
DELETE_COPY(MRTCStatisticsNULLCallBack);
void onLocalAudioStats(MRTCLocalAudioStats& stats) override
{
}
void onLocalVideoStats(MRTCLocalVideoStats& stats) override
{
}
void onRemoteAudioStats(MRTCRemoteAudioStats& stats) override
{
}
void onRemoteVideoStats(MRTCRemoteVideoStats& stats) override
{
}
};
// 混流
//////////////////////////////////////////////////////////////////////////
enum MRTCLiveStreamTransferType
{
TYPE_RTMP = 0x01,
};
enum MRTCLiveStreamVideoEncoding {
TYPE_H264 = 0x00,
};
enum MRTCLiveStreamAudioEncoding {
TYPE_AAC = 0x00,
};
enum MRTCLiveStreamMode {
TYPE_PARTITIONING_MODE = 0x00, // 均分模式，即两宫格、四宫格、九宫格等，不传和userList为空时0为默认值
TYPE_SUSPENSION_MODE = 0x01, //悬浮模式，主画面全屏，小画面则横排或竖排悬浮在主画面上，横排或竖排是由输出背景的宽高关系决定的，
// 若宽大于高，为竖排，反之则为横排
TYPE_CUSTOM_MODE = 0x02, //自定义布局根据下面的UserList内容进行布局，不传和userList为非空时2为默认值
};
enum MRTCLiveStreamMixType {
TYPE_MIX_ALL = 0x01, // 混所有摄像头和所有麦克风，不传时的默认值
TYPE_MIX_DESKTOP_AND_ALL_MIC = 0x02, // 混一个共享桌面，和所有麦克风
TYPE_MIX_DESKTOP_ONECAM_AND_ALL_MIC =0x03, //混一个共享桌面、一个共享者的摄像头，和所有麦克风，
// 共享桌面画面会在渲染摄影头画面之后渲染，可以制作画中画的效果。
};
enum MRTCLiveStreamLayoutScale {
TYPE_KEEP_ORIGINAL = 0x00, // 保持原长宽比例
TYPE_DO_NOT_ZOOM_EXTRA = 0x01, // 不缩放剧中剪切多出来的部分
};
enum MRTCLiveStreamRole {
INTERACTIVE_AUDIENCE = 0x00, // 互动观众
HOST = 0x01, // 主播
HOST_SHARED_SCREEN = 0x02, // 主播共享的画面
};
struct MRTCPublishAndMixEncoding final
{
int16_t transfer_type = TYPE_RTMP; //推流方式，目前支持：1：RTMP
int16_t video = TYPE_H264; //video - 视频编码类型，整型，目前支持：0：H264
int16_t audio = TYPE_AAC; //音频编码类型，整型，目前支持：0：AAC
int16_t videoBitrate = 1500; //视频编码码率，默认1500，最小400，最大12000
int16_t videoFramerate = 15; //视频编码帧率，默认30，只能设置：15、20、25、30这几个帧率。
int16_t videoGop = 30; //视频编码gop长度，默认和帧率一样，最小10，最大120。
int32_t audioSampleRate = 48000; //音频编码采样率，默认48000，只能设置48000、44100、32000、16000这几个采样率
int16_t audioChannels = 2; //音频编码声道数，默认2，只能设置1、2这两种声道数
int16_t audioBirate = 128; //音频编码码率，默认128，最小16，最大256
};
struct MRTCPublishAndMixUserList final
{
char userId[256] = { 0 };
int8_t role;
int8_t layout_scale; //缩放模式，目前支持：0：保持原长宽比例 1：不缩放剧中剪切多出来的部分(2.0新增)
int16_t canvas_left;
int16_t canvas_top;
int16_t canvas_width;
int16_t canvas_height;
char canvas_color[256] = { 0 };
};
struct MRTCConsumerStatus final
{
char peerId[256] = { 0 };
MRTCVideoSourceType videoKind =TYPE_VIDEO_SOURCE_NONE;
MRTCAudioSourceType audioKind = TYPE_AUDIO_SOURCE_NONE;
int8_t videoMuteKind;
int8_t audioMuteKind;
bool isAudioMute = true;
bool isTopNSelected = true;
uint64_t topNSelectedChangeTs = 0;
bool isVideoMute = true;
int videoTotalData = 0;
int audioTotalData = 0;
bool isMe = false;
};
struct MRTCLiveStreamingInfo final
{
int16_t mixType = TYPE_MIX_ALL;
int16_t mode = TYPE_PARTITIONING_MODE;
int16_t outputWidth = 720; // 指定混流输出流的宽，不传时的默认值为720
int16_t outputHeight = 1080; // 指定混流输出流的高，不传时的默认值为1080
char streamUrl[256] = {0};
};
enum MRTCContentHint
{
kFluid = 0x00, // 流畅模式
kDetailed = 0x01, // 清晰模式
};
//////////////////////////////////////////////////////////////////////////
// 屏幕分享
//////////////////////////////////////////////////////////////////////////
struct MRTCShareSource final
{
DELETE_COPY(MRTCShareSource);
intptr_t sourceId = 0;
char title[256] = { 0 };
};
//////////////////////////////////////////////////////////////////////////
// 视频设备类型
enum MRTCAudioDeviceType
{
#ifdef WIN32 // Windows
TYPE_DEFAULT_CONNUNICATION_DEVICE = -1,
TYPE_DEFAULT_DEVICE = -2
#else
TYPE_DEFAULT_DEVICE = 0,
#endif
};
// 音频设备设置
struct MRTCAudioDeviceOption final
{
uint32_t deviceIndex; //speaker or playout device index
MRTCAudioDeviceType deviceType = TYPE_DEFAULT_DEVICE;
};
constexpr int MAX_DEVICE_NAME_SIZE = 128;
constexpr int MAX_DEVICE_GUID_SIZE = 256;
constexpr int MAX_CAP_INFO_SIZE = 20;
struct MRTCCapFormatInfo
{
uint32_t width; ///< width in pixels
uint32_t height; ///< height in pixels
uint32_t fps; ///< frames per second
};
// 摄像头能力
struct MRTCCameraCapabilities final
{
uint16_t index;
char name[MAX_DEVICE_NAME_SIZE];
char deviceUniqueId[MAX_DEVICE_GUID_SIZE];
char productUniqueId[MAX_DEVICE_GUID_SIZE];
uint16_t iFormatCount;
MRTCCapFormatInfo formatInfo[MAX_CAP_INFO_SIZE];
};
// 模式类型
enum MRTCModeType
{
TYPE_MODE_INVALID = 0x00,
TYPE_MODE_CAMERA_PREVIEW_MIRROR = 0x01, // 摄像头预览镜像
TYPE_MODE_CAMERA_PREVIEW_NORMAL = 0x02, // 摄像头预览不镜像
TYPE_MODE_CAMERA_PUBLISH_MIRROR = 0x03, // 摄像头推流镜像
TYPE_MODE_CAMERA_PUBLISH_NORMAL = 0x04, // 摄像头推流不镜像
TYPE_MODE_CAMERA_FRONT = 0x05, // 前置摄像头
TYPE_MODE_CAMERA_BACK = 0x06, // 后置摄像头
TYPE_MODE_SPEAKER_OPEN = 0x07, // 扬声器开
TYPE_MODE_SPEAKER_CLOSE = 0x08, // 扬声器关
TYPE_MODE_RESET_PLAYOUT = 0x09, // 重置播放设备
TYPE_MODE_RESET_MICROPHONE = 0x0A, // 重置麦克风
TYPE_MODE_MUTE_ALL_CONSUMER_AUDIO = 0x0B, // 静音所有音频对象
TYPE_MODE_UNMUTE_ALL_CONSUMER_AUDIO = 0x0C, // 取消静音所有对象
};
// 插件类型
enum MRTCPluginType
{
TYPE_PLUGIN_NONE = 0x00,
TYPE_PLUGIN_AUDIO_RECORD_EFFECT_RAW_BEFORE = 0x11, // 音频采集设备采集到的原始音频数据，没有分帧, 不是10毫秒为单位的数据
TYPE_PLUGIN_AUDIO_RECORD_EFFECT_BEFORE = 0x12, // 插件音效在默认音效之前处理
TYPE_PLUGIN_AUDIO_RECORD_EFFECT_AFTER = 0x13, // 插件音效在默认音效之后处理
TYPE_PLUGIN_AUDIO_PLAYOUT_EFFECT_RAW_DATA = 0x14, // 插件音效在扬声器端混音多路裸数据处理 ---- 仅支持一个注册，其他支持多个注册
TYPE_PLUGIN_AUDIO_PLAYOUT_EFFECT_BEFORE = 0x15, // 插件音效在扬声器端播放之前的数据处理
TYPE_PLUGIN_CAMERA_ENCODE_BEFORE = 0x20, // 视频特效在摄像头编码之前预处理
TYPE_PLUGIN_CAMERA_DECODE_RENDER = 0x21, // 视频特效在摄像头解码之后渲染之前
TYPE_PLUGIN_SCREEN_ENCODE_BEFORE = 0x22, // 视频特效在屏幕分享编码之前预处理
TYPE_PLUGIN_SCREEN_ENCODE_RENDER = 0x23, // 视频特效在屏幕分享编码之渲染之前
TYPE_PLUGIN_VIDEO_FRAME_SEI_MODIFIER = 0x24, // 视频帧的sei修改器类型
};
// 插件回调基函数
class RTCENGINE_API RTCENGINE_API_CPP IMRTCEffectPlugin
{
public:
DELETE_CTOR_COPY(IMRTCEffectPlugin);
IMRTCEffectPlugin() {}
virtual ~IMRTCEffectPlugin() {}
virtual int16_t onInit(void* param) = 0; // 插件初始化
virtual int16_t onDestroy() = 0; // 插件卸载
virtual int16_t onStart() = 0; // 插件开始
virtual int16_t onStop() = 0; // 插件停止
virtual int16_t onUpdate() = 0; // 插件状态变化
virtual int16_t onGetPluginInfo(const char* pName) = 0; // 插件信息 名称等
};
// sei插件
class RTCENGINE_API RTCENGINE_API_CPP IMRTCSeiPlugin : public IMRTCEffectPlugin
{
public:
IMRTCSeiPlugin() :IMRTCEffectPlugin() {}
virtual ~IMRTCSeiPlugin() override {}
//
// Audio Effect Process.
//
virtual void onSEIProcess(const char *roomId, const char *peerId, MRTCVideoSourceType sourceType,MRTCVideoFrame& videoFrame) = 0;
};
// 音频插件
class RTCENGINE_API RTCENGINE_API_CPP IMRTCAudioEffectPlugin : public IMRTCEffectPlugin
{
public:
IMRTCAudioEffectPlugin() :IMRTCEffectPlugin() {}
virtual ~IMRTCAudioEffectPlugin() override {}
//
// Audio Effect Process.
//
virtual int16_t onProcess(MRTCAudioFrame& audioFrame) = 0;
};
// 音频原始数据插件
class RTCENGINE_API RTCENGINE_API_CPP IMRTCRawAudioEffectPlugin : public IMRTCEffectPlugin
{
public:
//
// Audio Effect Process.
//
virtual int16_t onProcess(const int16_t** const srcData, const int* ssrc, int numberOfStream, int numChannels, int samplesPerChannel, int16_t* dstData, int dstNumChannels) = 0;
};
// 摄像头特效插件
class RTCENGINE_API RTCENGINE_API_CPP IMRTCCameraEffectPlugin : public IMRTCEffectPlugin
{
public:
//
// Camera Effect Process Before.
//
virtual int16_t onCameraProcessBefore(const char *roomId, const char *peerId, MRTCVideoSourceType sourceType, MRTCVideoFrame& videoFrame) = 0;
//
// Camera Effect Process Render.
//
virtual int16_t onCameraProcessRender(const char *roomId, const char *peerId, MRTCVideoSourceType sourceType, MRTCVideoFrame& videoFrame) = 0;
};
// 屏幕分享特效插件
class RTCENGINE_API RTCENGINE_API_CPP IMRTCScreenEffectPlugin : public IMRTCEffectPlugin
{
public:
//
// Screen Effect Process Before.
//
virtual int16_t onScreenProcessBefore(const char *roomId, const char *peerId, MRTCVideoSourceType sourceType, MRTCVideoFrame& videoFrame) = 0;
//
// Screen Effect Process Render.
//
virtual int16_t onScreenProcessRender(const char *roomId, const char *peerId, MRTCVideoSourceType sourceType, MRTCVideoFrame& videoFrame) = 0;
};
// Return Code.
//////////////////////////////////////////////////////////////////////////
enum RetCode : int16_t
{
ERR_NOERR = 0x00, // 没有错误
ERR_DATA_EXISTS = 0x01, // 数据已经存在
ERR_VARIABLE_EMPTY = 0x02, // 变量为空
ERR_MSG_TYPE_WRONG = 0x03, // 消息类型错误
ERR_MODULE_ID_ERROR = 0x04, // 模块ID错误
ERR_MODULE_NOT_EXISTS = 0x05, // 模块不存在
ERR_MSG_NOT_CURMODULE = 0x06, // 收到不是当前模块消息
ERR_EVENT_NOT_CURMODULE = 0x07, // 收到不是当前模块事件
ERR_ENGINE_STATUS_ERR = 0x08, // 引擎状态错误
ERR_LISTENER_TYPE_ERROR = 0x09, // 监听函数类型错误
ERR_LOAD_DEVICE_FAILED = 0x0A, // 加载设备失败
ERR_GET_CAPABILITY_FAILED = 0x0B, // 获取能力失败
ERR_WS_CREATE_SEND_TRANSPORT = 0x0C, // Websocket创建Send Transport失败。
ERR_CREATE_SENDTRANSPORT_FAILED = 0x0D, // Device 创建SendTransport失败
ERR_WS_CREATE_RECV_TRANSPORT = 0x0E, // Websocket创建Recv Transport失败。
ERR_CREATE_RECVTRANSPORT_FAILED = 0x0F, // Device 创建RecvTransport失败
ERR_GET_JOIN_ROOM_FAILED = 0x10, // 获取加入房间失败
ERR_GET_SENDTRANSPORT_PRODUCE_FAILED = 0x11, // Produce获取数据失败
ERR_GET_SENDTRANSPORT_PRODUCE_DATA_FAILED = 0x12, // ProduceData获取数据失败
ERR_GET_FROM_CONSUMERID_TO_USERID_FAILED = 0x13, // ComsumerId换换UserId失败
ERR_GET_FROM_USERID_TO_CONSUMERID_FAILD = 0x14, // UserId转换ConsumerId失败
ERR_ENGINE_REPEAT_JOIN_ROOM = 0x15, // 已经加入房间，重复加入
ERR_REPEAT_START_PREVIEW_LOCAL_CAMERA = 0x16, // 重复打开预览摄像头
ERR_REPEAT_STOP_PREVIEW_LOCAL_CAMERA = 0x17, // 重复关闭摄像头
ERR_REPEAT_OPEN_MICRO = 0x18, // 重复打开麦克风
ERR_REPEAT_CLOSE_MICRO = 0x19, // 重复关闭麦克风
ERR_CAPABILITY_CONTENT_ERROR = 0x1A, // 能力内容错误
ERR_CREATE_SENDTRANSPORT_RESPONSE_ERR = 0x1B, // 创建send transport 返回数据错误
ERR_CREATE_RECVTRANSPORT_RESPONSE_ERR = 0x1C, // 创建Recv transport 返回数据错误
ERR_NEW_CONSUMER_RESPONSE_DATA_ERR = 0x1D, // newConsumer 返回数据错误
ERR_CREATE_WEBSOCKET_FAILED = 0x1E, // websocket创建失败
ERR_RECONNECT_ROOM_DURING = 0x1F, // 重连过程中，不能进行操作
ERR_OPEN_CAMERA_FAILED = 0x20, // 打开摄像头失败
ERR_GET_CAMERA_INFO_FAILED = 0x21, // 获取摄像头信息失败
ERR_VOLUME_OUT_OF_RANGE = 0x22, // 音量范围0-1.0
ERR_CREATE_MIC_PRODUCER_FAILED = 0x23, // Mic生产者对象创建失败
ERR_CREATE_CAMERA_TRACK_FAILED = 0x24, // 摄像头VideoTrack创建失败
ERR_VARIABLE_VIDEOTRACK_INVALID = 0x25, // VideoTrack变量无效
ERR_CREATE_VIDEO_PRODUCER_FAILED = 0x26, // Video生产者创建失败
ERR_CREATE_NEW_CONSUMER_FAILED = 0x27, // Consumer创建失败
ERR_RESPONSE_SWITCH_MEDIA = 0x28, // SwitchMedia请求返回失败
ERR_RESPONSE_SET_VIDEO_LAYERS = 0x29, // SetVideoLayer请求返回失败
ERR_RESPONSE_ENABLE_CONSUMER_AUDIO = 0x2A, // EnableConsumerAudio请求返回失败
ERR_RESPONSE_ENABLE_CONSUMER_VIDEO = 0x2B, // EnableConsumerVIdeo请求返回失败
ERR_RESPONSE_ENABLE_CONSUMER_AUDIO2 = 0x2C, // EnableConsumerAudio2请求返回失败
ERR_RESPONSE_ENABLE_CONSUMER_VIDEO2 = 0x2D, // EnableConsumerVIdeo2请求返回失败
ERR_RESPONSE_CLOSE_ROOM = 0x2E, // CloseRooom请求返回失败
ERR_RESPONSE_SEND_TRANSPORT_CONNECT = 0x2F, // SendTransportConnect请求返回失败
ERR_RESPONSE_RECV_TRANSPORT_CONNECT = 0x30, // RecvTransportConnect请求返回失败
ERR_EXCEED_STREAM_LEVEL_LIMIT = 0x31, // 采集的视频尺寸超过了StreamLeave的限制
ERR_WEBSOCKET_WAS_CLOSED = 0x32, // websocket已经关闭
ERR_DEVICE_TYPE_WRONG = 0x33, // 设备类型错误
ERR_EFFECT_REGISTER_FAILED = 0x34, // 特效注册失败
ERR_AUDIO_DEVICE_IS_IN_USE = 0x35, // 音频设备正在使用
ERR_REPEAT_OPEN_SCREEN = 0x36, // 重复打开屏幕分享
ERR_REPEAT_CLOSE_SCREEN = 0x37, // 重复关闭屏幕分享
ERR_CONNECT_SERVER_FAILED = 0x38, // 连接服务器错误
ERR_DO_FAILED_FOR_WILL_LEAVE = 0x39, // 将要离开房间，操作失败
ERR_LOAD_AUDIO_MONITOR_FAILED = 0x3A, // 加载音频设备监控失败
ERR_UNLOAD_AUDIO_MONITOR_FAILED = 0x3B, // 卸载音频设备监控失败
ERR_REGISTER_AUDIO_MONITOR_FAILED = 0x3C, // 注册音频设备监控失败
ERR_REGISTER_WINDOWS_CLASS_FAILED = 0x3D, // 注册Windows窗口类失败
ERR_CREATE_WINDOWS_WINDOW_FAILED = 0x3E, // 创建windows窗口失败
ERR_REGISTER_DEVICE_NOTIFY_FAILED = 0x3F, // 注册设备Notify失败
ERR_REPEAT_START_PUBLISHING = 0x40, // 重复开始预览
ERR_REPEAT_STOP_PUBLISHING = 0x41, // 重复停止预览
ERR_REPEAT_OPEN_SCREEN_SHAREING = 0x42, // 重复打开屏幕分享
ERR_REPEAT_STOP_SCREEN_SHAREING = 0x43, // 重复关闭屏幕分享
ERR_BACKGROUND_MUSIC_NOT_PLAYING = 0x44, // 背景音乐没有在播放
ERR_BACKGROUND_MUSIC_NOT_PAUSED = 0x45, // 背景音乐不是pause状态
ERR_MUSIC_PLAYER_ALREADY_INIT = 0x46, // 背景音乐播放器已经初始化
ERR_MUSIC_PLAYER_ALREADY_UNINIT = 0x47, // 背景音乐播放器已经释放
ERR_MUSIC_PLAYER_DO_NOT_INIT = 0x48, // 背景音乐播放器还没有初始化
ERR_MUSIC_PLAYER_HAVE_STOPED = 0x49, // 背景音乐播放器已经停止
ERR_MUSIC_PLAYER_IS_PLAYING = 0x4A, // 背景音乐播放器正在播放状态
ERR_MUSIC_PLAYER_IS_PAUSED = 0x4B, // 背景音乐播放器正在暂停状态
ERR_MUSIC_PLAYER_IS_STOPED = 0x4C, // 背景音乐播放器正在停止状态
ERR_MUSIC_PLAYER_FILE_PATH_EMPTY = 0x4D, // 背景音乐播放路径不能为空
ERR_MUSIC_PLAYER_FILE_READ_FAILED = 0x4E, // 背景音乐文件不存在或者不可读
ERR_MUSIC_PLAYER_DO_NOT_PLAYING = 0x4F, // 背景音乐播放器不在播放状态
ERR_MUSIC_PLAYER_DO_NOT_PAUSED = 0x50, // 背景音乐播放器不在暂停状态
ERR_FIND_AUDIO_STREAM_FAILED = 0x51, // 查找音频流失败!
ERR_FIND_DECODE_CODEC_FAILED = 0x52, // 查找解码器失败!
ERR_FAILED_ALLOC_DECODE_CTX = 0x53, // 申请Decoder Context失败!
ERR_FAILED_COPY_PARAM_TO_DEC = 0x54, // 拷贝Decoder Param失败!
ERR_FAILED_OPEN_DECODEC = 0x55, // 打开解码器失败!
ERR_RETURN_FAILED_FIND_VIDEO_STREAM = 0x56, // 获取视频流失败!
ERR_RETURN_FAILED_FIND_AUDIO_STREAM = 0x57, // 获取音频流失败!
ERR_RETURN_FILE_CANNOT_OPEN = 0x58, // 打开媒体文件失败!
ERR_RETURN_NOT_FIND_STREAM = 0x59, // 没有发现媒体流!
ERR_RETURN_NOT_AVAILABLE = 0x5A, // 媒体文件没有获取到需要的信息.
ERR_MEDIA_FILE_CANNOT_OPEN = 0x5B, // 媒体文件无法打开
ERR_CANNOT_FIND_STREAM = 0x5C, // 查找不到媒体文件流信息
ERR_INVALID_PARAMETER = 0x5D, // 参数错误
ERR_UPLOAD_LOG_FILE_FAILED = 0x5E, // 上传日志文件失败
ERR_OPEN_ZIP_FILE_FAILED = 0x5F, // 打开Zip文件错误
ERR_OPEN_SCREEN_FAILED = 0x60, // 打开屏幕分享失败
ERR_OPEN_SHARE_AUDIO_FAILED = 0x61, // 打开音频分享失败
ERR_REPEAT_CLOSE_SHARE_AUDIO = 0x62, // 重复关闭音频分享
ERR_VIDEO_FILE_NOT_PLAYING = 0x63, // 视频文件没有在播放
ERR_VIDEO_FILE_NOT_PAUSED = 0x64, // 视频文件不是pause状态
ERR_VIDEO_PLAYER_ALREADY_INIT = 0x65, // 视频播放器已经初始化
ERR_VIDEO_PLAYER_ALREADY_UNINIT = 0x66, // 视频播放器已经释放
ERR_VIDEO_PLAYER_DO_NOT_INIT = 0x67, // 视频播放器还没有初始化
ERR_VIDEO_PLAYER_HAVE_STOPED = 0x68, // 视频播放器已经停止
ERR_VIDEO_PLAYER_IS_PLAYING = 0x69, // 视频播放器正在播放状态
ERR_VIDEO_PLAYER_IS_PAUSED = 0x6A, // 视频播放器正在暂停状态
ERR_VIDEO_PLAYER_IS_STOPED = 0x6B, // 视频播放器正在停止状态
ERR_VIDEO_PLAYER_FILE_PATH_EMPTY = 0x6C, // 视频播放路径不能为空
ERR_VIDEO_PLAYER_FILE_READ_FAILED = 0x6D, // 视频文件不存在或者不可读
ERR_VIDEO_PLAYER_DO_NOT_PLAYING = 0x6E, // 视频播放器不在播放状态
ERR_VIDEO_PLAYER_DO_NOT_PAUSED = 0x6F, // 视频播放器不在暂停状态
ERR_EXCEED_ROOM_MEMBER_LIMIT = 0x70, // 加入房间人数超过服务端最大限制
ERR_EXCEED_VIDEO_PRODUCE_NUMBER_LIMIT = 0x71, // 开启视频人数超过服务端最大限制
EER_AUDIO_DATA_REACHED_END = 0x72, // 音频数据已经到末尾
ERR_AUDIO_DATA_NOT_ENOUGH = 0x73, // 没有足够长度的音频数据
ERR_OPEN_DESKTOP_FAILED = 0x74, // 打开桌面声音分享失败
ERR_OPEN_BGMUSIC_FAILED = 0x75, // 打开背景音乐失败
ERR_REPEAT_OPEN_BGMUSIC = 0x76, // 重复打开背景音乐
ERR_REPEAT_CLOSE_BGMUSIC = 0x77, // 重复关闭背景音乐
ERR_OPEN_FILE_AUDIO_FAILED = 0x78, // 打开视频分享音频失败
ERR_OPEN_AUDIO_EFFECT_FAILED = 0x79, // 打开音效音频失败
ERR_CREATE_SCREEN_TRACK_FAILED = 0x7A, // 屏幕分享VideoTrack创建失败
ERR_CREATE_SHARE_AUDIO_PRODUCER_FAILED = 0x7B, // 创建屏幕声音分享生产者失败
ERR_CREATE_MUSIC_PRODUCER_FAILED = 0x7C, // 创建背景音乐生产者失败
ERR_CREATE_FILE_AUDIO_PRODUCER_FAILED = 0x7D, // 创建视频分享音频生产者失败
ERR_CREATE_AUDIO_EFFECT_PRODUCER_FAILED = 0x7E, // 创建音效音频生产者失败
ERR_REPEAT_OPEN_FILE_AUDIO = 0x7F, // 重复打开视频分享文件音频
ERR_REPEAT_OPEN_AUDIO_EFFECT = 0x80, // 重复打开音效文件音频
ERR_REPEAT_CLOSE_FILE_AUDIO = 0x81, // 重复关闭视频分享文件音频
ERR_REPEAT_CLOSE_AUDIO_EFFECT = 0x82, // 重复关闭音频文件音频
ERR_REPEAT_OPEN_DESKTOP = 0x83, // 重复打开桌面声音分享
ERR_REPEAT_CLOSE_DESKTOP = 0x84, // 重复关闭桌面声音分享
ERR_OPERATION_FAILED = 0x85, // 操作失败
ERR_OPEN_CUSTOM_AUDIO_FAILED = 0x86, // 打开自定义音频失败
ERR_CREATE_FILE_VIDEO_TRACK_FAILED = 0x87, // 视频分享VideoTrack创建失败
ERR_REPEAT_CLOSE_FILE_VIDEO = 0x88, // 重复关闭视频分享文件视频
ERR_CREATE_CUSTOM_VIDEO_TRACK_FAILED = 0x89, // 自定义视频VideoTrack创建失败
ERR_OPEN_CUSTOM_VIDEO_FAILED = 0x8A, // 打开自定义视频失败
ERR_OPEN_FILE_VIDEO_FAILED = 0x8B, // 打开视频分享文件视频失败
ERR_REPEAT_OPEN_CUSTOM_AUDIO = 0x8C, // 重复打开自定义音频
ERR_REPEAT_CLOSE_CUSTOM_AUDIO = 0x8D, // 重复关闭自定义音频
ERR_PRE_INSTANCE_NOT_DESTROY = 0x8E, // MRTCEngine 前一个实例没有调用destroy销毁，不能同时运行多份实例！
ERR_EXCEED_MIC_PRODUCE_NUMBER_LIMIT = 0x8F, // 麦克风人数超过限制
ERR_GET_RESTART_ICE_PARAMETERS_FAILED = 0x90, // 获取ReStartICE参数错误
ERR_RESTARTICE_PARAM_INVALID = 0x91, // ReStartICE参数错误
ERR_DOMAIN_CURL_REQUEST_FAILED = 0x92, // 就近接入请求CURL失败
ERR_DOMAIN_REQUEST_CODE_FAILED = 0x93, // 就近接入获取CODE错误
DOMAIN_REQUEST_CODE_READY = 0x94, // 就近接入准备就绪
DOMAIN_REQUEST_EMPTY = 0x95, // 就近接入传入地址为空
DOMAIN_REQUEST_DATA_EMPTY = 0x96, // 就近接入获取环境为空
UPLOAD_REQUEST_READY = 0x97, // 日志上传请求就绪
UPLOAD_CURL_CONNECT_FAILED = 0x98, // 日志上传CURL连接失败
UPLOAD_CURL_REQUEST_FAILED = 0x99, // 日志上传CURL请求失败
UPLOAD_CURL_REQUEST_DATA_FAILED = 0x9A, // 日志上传CURL请求数据错误
DOMAIN_REQUEST_CURL_FAILED = 0x9B, // 就近接入CURL初始化失败
DOMAIN_GET_RESPONSE_FAILED = 0x9C, // 就近接入解析response错误
ERR_AUDIO_DEVICE_START_EXCEPTION = 0x9D, // 音频设备启动异常
ERR_VIDEO_DEVICE_START_EXCEPTION = 0x9E, // 视频设备启动异常
TOKEN_REQUEST_CODE_READY = 0x9F, // 获取token准备就绪
REQUEST_TOKEN_FAILED = 0xA0, // 获取token获取失败
LIVE_STREAMING_REQUEST_CODE_READY = 0xA1, // 拉流混流准备就绪
REQUEST_LIVE_STREAMING_FAILED = 0xA2, // 请求拉流混流失败失败
LIVE_STREAMING_UPDATE_CODE_READY = 0xA3, // 更新拉流混流准备就绪
UPDATE_LIVE_STREAMING_FAILED = 0xA4, // 更新拉流混流失败失败
LIVE_STREAMING_STOP_CODE_READY = 0xA5, // 停止拉流混流准备就绪
STOP_LIVE_STREAMING_FAILED = 0xA6, // 停止拉流混流失败失败
ERR_CONNECT_SERVER_TO_FAILED = 0xA7, // 停止拉流混流失败失败
RECEIVE_CUSTOM_MESSAGE = 0xA8, // 接收到自定义信令
RECEIVE_KICKOUT_MESSAGE = 0xA9, // 接收到服务端踢人信令
RECEIVE_FORBID_RTC_PUSH = 0xAA, // 接收到禁止推流信令
RECEIVE_RESUME_RTC_PUSH = 0xAB, // 接收到恢复推流信令
RECEIVE_FORBID_RTC_PULL = 0xAD, // 接收到禁止拉流信令
RECEIVE_RESUME_RTC_PULL = 0xAE, // 接收到恢复拉流信令
MEDIA_PUBLISH_SUCCESS = 0xAF, // 音视频推流成功
MEDIA_PUBLISH_FAILED = 0xB0, // 音视频推流失败
WINDOW_CAPTURE_FAILED_MINIATURIZED = 0xB1, // 窗口缩小引起采集失败
WINDOW_CAPTURE_FAILED_CLOSED = 0xB2, // 窗口关闭引起采集失败
ERR_REPEAT_OPEN_DATACHANNEL = 0xB3, // 重复打开dataChannel
ERR_CREATE_NEW_DATA_CONSUMER_FAILED = 0xB4, // customData 能力创建失败
DATA_CHANNEL_PRODUCE_OPEN = 0xB5, // customData produce 通道开启
DATA_CHANNEL_PRODUCE_CLOSEED = 0xB6, // customData produce 通道关闭
DATA_CHANNEL_CONSUMER_OPEN = 0xB7, // customData consuemr 通道开启
DATA_CHANNEL_CONSUMER_CLOSEED = 0xB8, // customData consuemr 通道关闭
ERR_CREATE_DATA_CHANNEL_PRODUCER_FAILED = 0xB9, // 创建customData生产者失败
ERR_SATRT_SUPER_RESOLUTION_REPEAT = 0xBA, // 已经设置过此peerid对应类型的超分，重复设置
ERR_STOP_SUPER_RESOLUTION_INVALID = 0xBB, // 未设置过此peerId对应类型的超分，取消超分无效
RECEIVE_REPEAT_KICKOUT_MESSAGE = 0xBC, // 接收到自己在不同设备重复入会，被自己踢掉信令
ERR_CREATE_SEND_TRANSPORT_ERROR_ADD_TRACK = 0xBD, // createWebRtcTransport 信令失败，导致添加音视频Track失败
ERR_REPEAT_STOP_DATACHANNEL = 0xBE, // 重复停止DataChannel
ERR_CONNECT_RTM_SERVER_TO_FAILED = 0xC0, // RTM 返回 605错误，重试之后关闭
ERR_CONNECT_RTM_SERVER_FAILED = 0xC1, // 连接RTM服务器出错
ERR_EXCEED_RTM_ROOM_MEMBER_LIMIT = 0xC2, // RTM 超出上限
JOIN_MULTI_ROOM_SUCCESS = 0xC3, // 加入多房间成功
ERR_JOIN_MULTI_ROOM = 0xC4, // 加入多房间失败
LEAVE_MULTI_ROOM_SUCCESS = 0xC5, // 离开多房间成功
ERR_LEAVE_MULTI_ROOM = 0xC6, // 离开多房间失败
RECONNECT_JOIN_MULTI_ROOM_SUCCESS = 0xC7, // 重连加入多房间成功
ERR_RECONNECT_JOIN_MULTI_ROOM = 0xC8, // 重连加入多房间失败
ERR_REPEAT_JOIN_MULTI_ROOM = 0xC9, // 重复加入多房间
ERR_JOIN_MULTI_HOST_ROOM = 0xCA, // 使用主房间Id调用加入多房间接口
ERR_LEAVE_MULTI_HOST_ROOM = 0xCB, // 使用主房间Id调用离开多房间接口
ERR_REQUEST_ROOM_USER_LIST_TOO_FREQUENCY = 0xCC, // 过于频繁的调用房间人员列表接口
ERR_GET_ROOM_USERS_TOO_OFTEN = 0xCD, // 调用获取房间成员列表太频繁
ERR_ROOM_MODE_MISMATCH = 0xCE, // 房间mode不匹配
ERR_INVALID_ROOM_MODE = 0xCF, // 无效的房间mode
ERR_REQUEST_RS_BEYOND_MAX = 0xD0, // 请求RS超时
ERR_RS_EXCEPTION = 0xD1, // RS服务内部错误
ERR_JOIN_ROOM_BEYOND_MAX = 0xD2, // 加多房间超出加入房间限制
ERR_ROOM_CLOSED = 0xD3, // 房间已被关闭，90s内用户无法加入
ERR_EXCESSIVE_REQUESTS = 0xD4, // 请求房间用户或房间用户数过于频繁
ERR_UNKNOWN_ROLE = 0xD5, // 无效的用户role
ERR_TRANSPORT_ERROR = 0xD6, // transport异常
ERR_REPEAT_USER = 0xD7, // 用户重复登录
ERR_REPEAT_START_CUSTOM_AUDIO = 0xD8, // 重复打开自定义音频
ERR_REPEAT_STOP_CUSTOM_AUDIO = 0xD9, // 重复关闭自定义音频
// RAW video 相关
ERR_REPEAT_OPEN_RAW_VIDEO = 0xDA, // 重复打开自定义裸视频
ERR_REPEAT_CLOSE_RAW_VIDEO = 0xDB, // 重复关闭自定义裸视频
ERR_CREATE_CUSTOM_RAW_VIDEO_TRACK_FAILED = 0xDC, // 创建视频裸流VideoTrackProduct失败
ERR_VIDEO_CHANNEL = 0xDD, // 发送视频流的通道不存在
ERR_AUDIO_CHNNAEL = 0xDE, // 发送视音流的通道不存在
ERR_VIDEO_CHNNAEL_INDEX = 0xDF, // 视频多路流通道数不在0-100区间
ERR_AUDIO_CHNNAEL_INDEX = 0xE0, // 音频多路流通道数不在0-100区间
ERR_CREATE_CUSTOM_SECOND_VIDEO_TRACK_FAILED = 0xE1, // 自定义第二路视频VideoTrack创建失败
ERR_CREATE_CUSTOM_AUDIO_PRODUCER_FAILED = 0xE2, // 创建视频自定义音频生产者失败
ERR_PUSH_MEDIA_TIMEOUT = 0xE3, // 推流超时
ERR_AUTO_UPLOAD_ENABLED_CANT_USE_API = 0xE4, // 自动上传开启，上传日志API无效化
AUTO_UPLOAD_SUCCEED = 0xE5, // 自动上传成功
ERR_OPERATION_TOO_FREQUENT = 0xE6, // 操作过于频繁
CAMERA_OPEN_SUCCESS = 0xE7, // 摄像头打开成功
MIC_OPEN_SUCCESS = 0xE8, // 麦克风打开成功
ERR_ENGINE_STATUS_ERR_NOT_INITED = 0xE9, // 引擎状态错误，子码，未初始化
ERR_ENGINE_STATUS_ERR_NOT_IN_ROOM= 0xEA, // 引擎状态错误，子码，未加入房间
ERR_TRANSPORT_AUDIO_MIXER_ADD = 0xEB, // transport未创建，添加混音能力失败
ERR_REPEAT_AUDIO_MIXER_ADD = 0xEC, // 重复添加混音能力
ERR_TRANSPORT_AUDIO_MIXER_DELETE = 0xED, // transport未创建，删除混音能力失败
ERR_REPEAT_AUDIO_MIXER_DELETE = 0xEE, // 重复删除混音能力
ERR_VIDEO_H265_HARDWARE_ENCODE_FAILED_AND_SWITCH_TO_SOFTWARE = 0xED, // H265硬编码失败切换软编
ERR_VIDEO_H264_HARDWARE_ENCODE_FAILED_AND_SWITCH_TO_SOFTWARE = 0xEE, // H264硬编码失败切换软编
ERR_AUDIO_PUSH_AAC_ERROR = 0xEF, // 推送AAC音频失败
};
static constexpr const char* GetErrorDescription(RetCode e)
{
const char* pDescription = nullptr;
switch (e)
{
case ERR_NOERR:
pDescription = "success";
break;
case ERR_DATA_EXISTS:
pDescription = "Data already exists.";
break;
case ERR_VARIABLE_EMPTY:
pDescription = "Variable is empty.";
break;
case ERR_MSG_TYPE_WRONG:
pDescription = "Wrong message type.";
break;
case ERR_MODULE_ID_ERROR:
pDescription = "Module ID error.";
break;
case ERR_MODULE_NOT_EXISTS:
pDescription = "Module does not exist.";
break;
case ERR_MSG_NOT_CURMODULE:
pDescription = "Received a message that is not the current module";
break;
case ERR_EVENT_NOT_CURMODULE:
pDescription = "Received a event that is not the current module";
break;
case ERR_ENGINE_STATUS_ERR:
pDescription = "Engine status error.";
break;
case ERR_LISTENER_TYPE_ERROR:
pDescription = "Wrong monitoring function type.";
break;
case ERR_LOAD_DEVICE_FAILED:
pDescription = "Failed to load device.";
break;
case ERR_OPERATION_TOO_FREQUENT:
pDescription = "Operation is too frequent, please try again later.";
break;
case ERR_GET_CAPABILITY_FAILED:
pDescription = "Failed to acquire ability.";
break;
case ERR_WS_CREATE_SEND_TRANSPORT:
pDescription = "WebSocket failed to create Send Transport.";
break;
case ERR_CREATE_SENDTRANSPORT_FAILED:
pDescription = "Device failed to create SendTransport.";
break;
case ERR_WS_CREATE_RECV_TRANSPORT:
pDescription = "WebSocket failed to create Recv Transport.";
break;
case ERR_CREATE_RECVTRANSPORT_FAILED:
pDescription = "Device failed to create RecvTransport.";
break;
case ERR_GET_JOIN_ROOM_FAILED:
pDescription = "Failed to get join room.";
break;
case ERR_GET_SENDTRANSPORT_PRODUCE_FAILED:
pDescription = "SendTransport produce failed to get data.";
break;
case ERR_GET_SENDTRANSPORT_PRODUCE_DATA_FAILED:
pDescription = "SendTransport producedata failed to get data.";
break;
case ERR_GET_FROM_CONSUMERID_TO_USERID_FAILED:
pDescription = "ComsumerId change to UserId failed";
break;
case ERR_GET_FROM_USERID_TO_CONSUMERID_FAILD:
pDescription = "UserId change to ConsumerId failed";
break;
case ERR_ENGINE_REPEAT_JOIN_ROOM:
pDescription = "Already joined the room, repeat to join the room";
break;
case ERR_REPEAT_START_PREVIEW_LOCAL_CAMERA:
pDescription = "Start the camera preview repeatedly";
break;
case ERR_REPEAT_STOP_PREVIEW_LOCAL_CAMERA:
pDescription = "Stop the camera preview repeatedly";
break;
case ERR_REPEAT_START_PUBLISHING:
pDescription = "Start the camera publishing repeatedly";
break;
case ERR_REPEAT_STOP_PUBLISHING:
pDescription = "Stop the camera publishing repeatedly";
break;
case ERR_REPEAT_OPEN_MICRO:
pDescription = "Repeat to turn on the microphone";
break;
case ERR_REPEAT_CLOSE_MICRO:
pDescription = "Repeatedly turn off the microphone";
break;
case ERR_CAPABILITY_CONTENT_ERROR:
pDescription = "Ability to obtain content error";
break;
case ERR_CREATE_SENDTRANSPORT_RESPONSE_ERR:
pDescription = "create sendtransport returns data errorr";
break;
case ERR_CREATE_RECVTRANSPORT_RESPONSE_ERR:
pDescription = "create recvtransport returns data errorr";
break;
case ERR_NEW_CONSUMER_RESPONSE_DATA_ERR:
pDescription = "newConsumer returns data errorr";
break;
case ERR_CREATE_WEBSOCKET_FAILED:
pDescription = "websocket creation failed.";
break;
case ERR_RECONNECT_ROOM_DURING:
pDescription = "Cannot operate during reconnection.";
break;
case ERR_OPEN_CAMERA_FAILED:
pDescription = "Failed to open camera.";
break;
case ERR_GET_CAMERA_INFO_FAILED:
pDescription = "Failed to get camera information.";
break;
case ERR_VOLUME_OUT_OF_RANGE:
pDescription = "The volume range is out of range 0-1.0.";
break;
case ERR_CREATE_MIC_PRODUCER_FAILED:
pDescription = "Mic producer object creation failed.";
break;
case ERR_CREATE_CAMERA_TRACK_FAILED:
pDescription = "Camera videotrack creation failed.";
break;
case ERR_VARIABLE_VIDEOTRACK_INVALID:
pDescription = "The variable videotrack is not valid.";
break;
case ERR_CREATE_VIDEO_PRODUCER_FAILED:
pDescription = "Video producer object creation failed.";
break;
case ERR_CREATE_NEW_CONSUMER_FAILED:
pDescription = "Consumer creation failed.";
break;
case ERR_RESPONSE_SWITCH_MEDIA:
pDescription = "SwitchMedia request failed.";
break;
case ERR_RESPONSE_SET_VIDEO_LAYERS:
pDescription = "SetVideoLayer request failed to return.";
break;
case ERR_RESPONSE_ENABLE_CONSUMER_AUDIO:
pDescription = "EnableConsumerAudio request failed to return.";
break;
case ERR_RESPONSE_ENABLE_CONSUMER_VIDEO:
pDescription = "EnableConsumerVideo request failed to return.";
break;
case ERR_RESPONSE_ENABLE_CONSUMER_AUDIO2:
pDescription = "EnableConsumerAudio2 request failed to return.";
break;
case ERR_RESPONSE_ENABLE_CONSUMER_VIDEO2:
pDescription = "EnableConsumerVideo2 request failed to return.";
break;
case ERR_RESPONSE_CLOSE_ROOM:
pDescription = "CloseRoom request failed to return.";
break;
case ERR_RESPONSE_SEND_TRANSPORT_CONNECT:
pDescription = "SendTransportConnect request failed to return.";
break;
case ERR_RESPONSE_RECV_TRANSPORT_CONNECT:
pDescription = "RecvTransportConnect request failed to return.";
break;
case ERR_EXCEED_STREAM_LEVEL_LIMIT:
pDescription = "The size of the captured video exceeds the limit of StreamLeave";
break;
case ERR_WEBSOCKET_WAS_CLOSED:
pDescription = "WebSocket was closed.";
break;
case ERR_DEVICE_TYPE_WRONG:
pDescription = "Wrong device type.";
break;
case ERR_EFFECT_REGISTER_FAILED:
pDescription = "Special effects registration failed.";
break;
case ERR_AUDIO_DEVICE_IS_IN_USE:
pDescription = "Audio device is in use.";
break;
case ERR_REPEAT_OPEN_SCREEN:
pDescription = "Turn on the share screen repeatedly.";
break;
case ERR_REPEAT_CLOSE_SCREEN:
pDescription = "Close the share screen repeatedly.";
break;
case ERR_CONNECT_SERVER_FAILED:
pDescription = "Connect To Server Failed.";
break;
case ERR_DO_FAILED_FOR_WILL_LEAVE:
pDescription = "About to leave the room, the operation failed.";
break;
case ERR_LOAD_AUDIO_MONITOR_FAILED:
pDescription = "Failed to load audio device monitoring.";
break;
case ERR_UNLOAD_AUDIO_MONITOR_FAILED:
pDescription = "Failed to uninstall audio device monitor.";
break;
case ERR_REGISTER_AUDIO_MONITOR_FAILED:
pDescription = "Failed to register audio device monitor.";
break;
case ERR_REGISTER_WINDOWS_CLASS_FAILED:
pDescription = "Failed to register windows window class.";
break;
case ERR_CREATE_WINDOWS_WINDOW_FAILED:
pDescription = "Failed to create Windows window.";
break;
case ERR_REGISTER_DEVICE_NOTIFY_FAILED:
pDescription = "Failed to register device notification.";
break;
case ERR_REPEAT_OPEN_SCREEN_SHAREING:
pDescription = "Open the screen sharing repeatedly.";
break;
case ERR_REPEAT_STOP_SCREEN_SHAREING:
pDescription = "Stop the screen sharing repeatedly.";
break;
case ERR_BACKGROUND_MUSIC_NOT_PLAYING:
pDescription = "Background music is not playing.";
break;
case ERR_BACKGROUND_MUSIC_NOT_PAUSED:
pDescription = "The background music is not paused.";
break;
case ERR_MUSIC_PLAYER_ALREADY_INIT:
pDescription = "The background music player has been initialized.";
break;
case ERR_MUSIC_PLAYER_ALREADY_UNINIT:
pDescription = "The background music player has been released.";
break;
case ERR_MUSIC_PLAYER_DO_NOT_INIT:
pDescription = "The background music player has not been initialized.";
break;
case ERR_MUSIC_PLAYER_IS_PLAYING:
pDescription = "Background music player is playing.";
break;
case ERR_MUSIC_PLAYER_IS_PAUSED:
pDescription = "The background music player is paused.";
break;
case ERR_MUSIC_PLAYER_FILE_PATH_EMPTY:
pDescription = "The background music playback path cannot be empty.";
break;
case ERR_MUSIC_PLAYER_FILE_READ_FAILED:
pDescription = "The background music file does not exist or is unreadable.";
break;
case ERR_MUSIC_PLAYER_DO_NOT_PLAYING:
pDescription = "The background music player is not playing.";
break;
case ERR_MUSIC_PLAYER_DO_NOT_PAUSED:
pDescription = "The background music player is not paused.";
break;
case ERR_FIND_AUDIO_STREAM_FAILED:
pDescription = "Find Audio Stream Failed.";
break;
case ERR_FIND_DECODE_CODEC_FAILED:
pDescription = "Find Decode Codec Failed.";
break;
case ERR_FAILED_ALLOC_DECODE_CTX:
pDescription = "Failed to allocate the decoder context.";
break;
case ERR_FAILED_COPY_PARAM_TO_DEC:
pDescription = "Failed to copy decoder parameters to input decoder context";
break;
case ERR_FAILED_OPEN_DECODEC:
pDescription = "Failed to open decoder";
break;
case ERR_RETURN_FAILED_FIND_VIDEO_STREAM:
pDescription = "Could not find video stream.";
break;
case ERR_RETURN_FAILED_FIND_AUDIO_STREAM:
pDescription = "Could not find audio stream.";
break;
case ERR_RETURN_FILE_CANNOT_OPEN:
pDescription = "Cannot open media file.";
break;
case ERR_RETURN_NOT_FIND_STREAM:
pDescription = "Cannot find stream information.";
break;
case ERR_RETURN_NOT_AVAILABLE:
pDescription = "The current media file does not get the required information.";
break;
case ERR_MEDIA_FILE_CANNOT_OPEN:
pDescription = "Cannot open input media file.";
break;
case ERR_CANNOT_FIND_STREAM:
pDescription = "Cannot find stream information.";
break;
case ERR_INVALID_PARAMETER:
pDescription = "Parameter error.";
break;
case ERR_UPLOAD_LOG_FILE_FAILED:
pDescription = "Failed to upload log file.";
break;
case ERR_OPEN_ZIP_FILE_FAILED:
pDescription = "Failed to open zip file.";
break;
case ERR_OPEN_SCREEN_FAILED:
pDescription = "Failed to open screen sharing.";
break;
case ERR_VIDEO_FILE_NOT_PLAYING:
pDescription = "Video file is not playing.";
break;
case ERR_VIDEO_FILE_NOT_PAUSED:
pDescription = "The video player is not paused.";
break;
case ERR_VIDEO_PLAYER_ALREADY_INIT:
pDescription = "The video player has been initialized.";
break;
case ERR_VIDEO_PLAYER_ALREADY_UNINIT:
pDescription = "The video player has been released.";
break;
case ERR_VIDEO_PLAYER_DO_NOT_INIT:
pDescription = "The video player has not been initialized.";
break;
case ERR_MUSIC_PLAYER_HAVE_STOPED:
pDescription = "The background music player has stopped.";
break;
case ERR_VIDEO_PLAYER_HAVE_STOPED:
pDescription = "The video player has stopped.";
break;
case ERR_VIDEO_PLAYER_IS_PLAYING:
pDescription = "The video player is playing.";
break;
case ERR_VIDEO_PLAYER_IS_PAUSED:
pDescription = "The video player is paused.";
break;
case ERR_VIDEO_PLAYER_FILE_PATH_EMPTY:
pDescription = "The video playback path cannot be empty.";
break;
case ERR_MUSIC_PLAYER_IS_STOPED:
pDescription = "The background music player is stoped.";
break;
case ERR_VIDEO_PLAYER_IS_STOPED:
pDescription = "The video player is stoped.";
break;
case ERR_VIDEO_PLAYER_FILE_READ_FAILED:
pDescription = "The video file does not exist or is unreadable.";
break;
case ERR_VIDEO_PLAYER_DO_NOT_PLAYING:
pDescription = "The video player is not playing.";
break;
case ERR_VIDEO_PLAYER_DO_NOT_PAUSED:
pDescription = "The video player is not paused.";
break;
case ERR_EXCEED_ROOM_MEMBER_LIMIT:
pDescription = "The number of people joining the room exceeds the maximum limit of the server.";
break;
case ERR_EXCEED_VIDEO_PRODUCE_NUMBER_LIMIT:
pDescription = "The number of people who have opened the video exceeds the maximum limit of the server.";
break;
case EER_AUDIO_DATA_REACHED_END:
pDescription = "Audio data has reached the end.";
break;
case ERR_AUDIO_DATA_NOT_ENOUGH:
pDescription = "Not enough audio data.";
break;
case ERR_OPEN_DESKTOP_FAILED:
pDescription = "Failed to open desktop sound sharing.";
break;
case ERR_OPEN_BGMUSIC_FAILED:
pDescription = "Failed to open background music.";
break;
case ERR_REPEAT_OPEN_BGMUSIC:
pDescription = "Repeat to open the BGMusic";
break;
case ERR_REPEAT_CLOSE_BGMUSIC:
pDescription = "Repeat to close the BGMusic";
break;
case ERR_OPEN_FILE_AUDIO_FAILED:
pDescription = "Failed to open video sharing audio";
break;
case ERR_OPEN_AUDIO_EFFECT_FAILED:
pDescription = "Failed to open sound effect audio";
break;
case ERR_CREATE_SCREEN_TRACK_FAILED:
pDescription = "Screen sharing VideoTrack creation failed";
break;
case ERR_CREATE_FILE_VIDEO_TRACK_FAILED:
pDescription = "Video file sharing VideoTrack creation failed";
break;
case ERR_CREATE_CUSTOM_VIDEO_TRACK_FAILED:
pDescription = "Custom video sharing VideoTrack creation failed";
break;
case ERR_CREATE_CUSTOM_SECOND_VIDEO_TRACK_FAILED:
pDescription = "Custom second video sharing VideoTrack creation failed";
break;
case ERR_CREATE_SHARE_AUDIO_PRODUCER_FAILED:
pDescription = "Failed to create screen sound sharing producer";
break;
case ERR_CREATE_MUSIC_PRODUCER_FAILED:
pDescription = "Failed to create background music producer";
break;
case ERR_CREATE_FILE_AUDIO_PRODUCER_FAILED:
pDescription = "Failed to create video sharing audio producer";
break;
case ERR_CREATE_CUSTOM_AUDIO_PRODUCER_FAILED:
pDescription = "Failed to create custom audio producer";
break;
case ERR_CREATE_AUDIO_EFFECT_PRODUCER_FAILED:
pDescription = "Failed to create sound effect audio producer";
break;
case ERR_REPEAT_OPEN_FILE_AUDIO:
pDescription = "Open the video repeatedly to share the file audio";
break;
case ERR_REPEAT_OPEN_AUDIO_EFFECT:
pDescription = "Repeatedly open the sound effect file audio";
break;
case ERR_REPEAT_CLOSE_FILE_VIDEO:
pDescription = "Repeatedly open the sound effect file video";
break;
case ERR_REPEAT_CLOSE_FILE_AUDIO:
pDescription = "Close the video file audio repeatedly";
break;
case ERR_REPEAT_CLOSE_AUDIO_EFFECT:
pDescription = "Close the video file video repeatedly";
break;
case ERR_REPEAT_OPEN_DESKTOP:
pDescription = "Repeatedly open desktop sound sharing.";
break;
case ERR_REPEAT_CLOSE_DESKTOP:
pDescription = "Repeatedly close desktop sound sharing.";
break;
case ERR_OPERATION_FAILED:
pDescription = "operation failed.";
break;
case ERR_OPEN_CUSTOM_AUDIO_FAILED:
pDescription = "Failed to open custom audio.";
break;
case ERR_OPEN_CUSTOM_VIDEO_FAILED:
pDescription = "Failed to open custom video.";
break;
case ERR_OPEN_FILE_VIDEO_FAILED:
pDescription = "Failed to open video sharing file video.";
break;
case ERR_REPEAT_OPEN_CUSTOM_AUDIO:
pDescription = "Repeat to open custom audio.";
break;
case ERR_REPEAT_CLOSE_CUSTOM_AUDIO:
pDescription = "Repeat to close custom audio.";
break;
case ERR_PRE_INSTANCE_NOT_DESTROY:
pDescription = "The previous instance of MRTCEngine did not call destroy, and multiple instances cannot be run at the same time!";
break;
case ERR_GET_RESTART_ICE_PARAMETERS_FAILED:
pDescription = "Get ReStartICE parameter error.";
break;
case ERR_RESTARTICE_PARAM_INVALID:
pDescription = "ReStartICE parameter error.";
break;
case ERR_DOMAIN_REQUEST_CODE_FAILED:
pDescription = "Request signal url failed.";
break;
case DOMAIN_REQUEST_CURL_FAILED:
pDescription = "curl init failed!!";
break;
case ERR_DOMAIN_CURL_REQUEST_FAILED:
pDescription = "The nearest access request CURL failed.";
break;
case DOMAIN_REQUEST_DATA_EMPTY:
pDescription = "vec is empty in response";
break;
case DOMAIN_GET_RESPONSE_FAILED:
pDescription = "Parse response error.";
break;
case ERR_CREATE_SEND_TRANSPORT_ERROR_ADD_TRACK:
pDescription = "Add track failed, because of create send transport error.";
break;
case JOIN_MULTI_ROOM_SUCCESS:
pDescription = "join Multi Room success";
break;
case ERR_JOIN_MULTI_ROOM:
pDescription = "join Multi Room failed";
break;
case LEAVE_MULTI_ROOM_SUCCESS:
pDescription = "leave Multi Room success";
break;
case ERR_LEAVE_MULTI_ROOM:
pDescription = "leave Multi Room failed";
break;
case ERR_REPEAT_JOIN_MULTI_ROOM:
pDescription = "repeat join Multi Room";
break;
case RECONNECT_JOIN_MULTI_ROOM_SUCCESS:
pDescription = "reconnect join Multi Room success";
break;
case ERR_RECONNECT_JOIN_MULTI_ROOM:
pDescription = "reconnect join Multi Room failed";
break;
case ERR_JOIN_MULTI_HOST_ROOM:
pDescription = "join Multi Room can not used host roomId";
break;
case ERR_LEAVE_MULTI_HOST_ROOM:
pDescription = "leave Multi Room can not used host roomId";
break;
case ERR_REPEAT_OPEN_RAW_VIDEO:
pDescription = "Repeat to open custom raw video.";
break;
case ERR_REPEAT_CLOSE_RAW_VIDEO:
pDescription = "Repeat to close custom raw video.";
break;
case ERR_CREATE_CUSTOM_RAW_VIDEO_TRACK_FAILED:
pDescription = "Custom naked video VideoTrack creation failed.";
break;
case ERR_REQUEST_ROOM_USER_LIST_TOO_FREQUENCY:
pDescription = "Get Room Member List too frequent";
break;
case ERR_GET_ROOM_USERS_TOO_OFTEN:
pDescription = "Get Room Member List too frequent";
break;
case ERR_ROOM_MODE_MISMATCH:
pDescription = "Room mode mismatch";
break;
case ERR_INVALID_ROOM_MODE:
pDescription = "Invalid room mode";
break;
case ERR_REQUEST_RS_BEYOND_MAX:
pDescription = "request RS beyond max time";
break;
case ERR_RS_EXCEPTION:
pDescription = "RS exception";
break;
case ERR_JOIN_ROOM_BEYOND_MAX:
pDescription = "Join multiroom beyond max room number";
break;
case ERR_ROOM_CLOSED:
pDescription = "Room closed";
break;
case ERR_EXCESSIVE_REQUESTS:
pDescription = "Request peers or peer number too frequent";
break;
case ERR_UNKNOWN_ROLE:
pDescription = "Unknow role";
break;
case ERR_TRANSPORT_ERROR:
pDescription = "transport error";
break;
case ERR_REPEAT_USER:
pDescription = "Join multiroom Repeat";
break;
case ERR_PUSH_MEDIA_TIMEOUT:
pDescription = "push stream timeout";
break;
case ERR_AUTO_UPLOAD_ENABLED_CANT_USE_API:
pDescription = "Enable auto upload log, forbbiden to call uploadLog api";
break;
case AUTO_UPLOAD_SUCCEED:
pDescription = "Auto upload log success";
break;
case ERR_ENGINE_STATUS_ERR_NOT_INITED:
pDescription = "Engine status error: Not INITED";
break;
case ERR_ENGINE_STATUS_ERR_NOT_IN_ROOM:
pDescription = "Engine status error: Not IN ROOM";
break;
case ERR_VIDEO_H264_HARDWARE_ENCODE_FAILED_AND_SWITCH_TO_SOFTWARE:
pDescription = "h264 hard encoder fallback to soft encoder";
break;
case ERR_VIDEO_H265_HARDWARE_ENCODE_FAILED_AND_SWITCH_TO_SOFTWARE:
pDescription = "h265 hard encoder fallback to soft encoder";
break;
default:
pDescription = "Error: Error Return Code.";
break;
}
return pDescription;
}
enum EngineStatus
{
ENGINE_STATUS_IDL = -0x01, // 初始状态
ENGINE_STATUS_INIT = 0x00, // 初始化状态
ENGINE_STATUS_JOINROOMING = 0x01, // 正在加入房间
ENGINE_STATUS_JOINROOM = 0x02, // 加入房间
ENGINE_STATUS_LEAVEROOM = 0x03, // 离开房间
ENGINE_STATUS_UNINIT = 0x04, // 卸载状态
};
RTCENGINE_NAMESPACE_END
#endif // __RTC_ENGINE_DEFINE_HPP___