多人视频互动如何轻松实现？一看就懂的示例代码

前端

2023-09-15 01:17:25

互动直播和实时通话的差异

多人视频互动分为两种类型：互动直播和实时通话。互动直播和实时通话的区别就在于，直播频道的用户有角色之分，包括主播和观众，主播可以进行直播，观众可以观看和评论直播；而实时通话的用户则没有角色之分，所有人都可以进行通话。

基于Agora SDK实现Windows端的多人视频互动

Agora SDK 是一个功能强大的音视频互动解决方案，可以帮助开发者轻松实现各种音视频互动应用。Agora SDK 提供了多种功能，包括视频通话、直播、录制、屏幕共享等。

要使用 Agora SDK 实现 Windows 端的多人视频互动，您需要先注册一个 Agora 账号并创建一个项目。然后，您可以下载 Agora SDK 并将其集成到您的项目中。

集成 Agora SDK 后，您就可以开始编写代码来实现多人视频互动功能了。Agora SDK 提供了详细的文档和示例代码，可以帮助您快速上手。

下面是一个简单的示例代码，演示如何使用 Agora SDK 实现多人视频互动：

#include <agora/media/base/agora_media_base.h>
#include <agora/media/base/agora_media_types.h>
#include <agora/media/engine/agora_media_engine.h>
#include <agora/media/rtc/agora_media_rtc.h>

using namespace agora::media::base;
using namespace agora::media::engine;
using namespace agora::media::rtc;

class AgoraMediaRtcEngine : public AgoraMediaEngine {
public:
  AgoraMediaRtcEngine() {
    CreateAgoraRtcEngine(&m_rtcEngine);
  }

  ~AgoraMediaRtcEngine() {
    DestroyAgoraRtcEngine(m_rtcEngine);
  }

  void JoinChannel(const char* appId, const char* channelId, const char* token) {
    m_rtcEngine->joinChannel(appId, channelId, token, 0, NULL);
  }

  void LeaveChannel() {
    m_rtcEngine->leaveChannel();
  }

  void SetVideoProfile(const VideoProfile& profile) {
    m_rtcEngine->setVideoProfile(profile);
  }

  void EnableAudioVolumeIndication(int interval, int smooth, bool report_vad) {
    m_rtcEngine->enableAudioVolumeIndication(interval, smooth, report_vad);
  }

  void EnableVideo() {
    m_rtcEngine->enableVideo();
  }

  void DisableVideo() {
    m_rtcEngine->disableVideo();
  }

  void MuteLocalAudioStream(bool mute) {
    m_rtcEngine->muteLocalAudioStream(mute);
  }

  void MuteLocalVideoStream(bool mute) {
    m_rtcEngine->muteLocalVideoStream(mute);
  }

  void SetRemoteVideoStreamType(const char* userId, int streamType) {
    m_rtcEngine->setRemoteVideoStreamType(userId, streamType);
  }

  void SubscribeRemoteVideoStream(const char* userId, bool subscribe) {
    m_rtcEngine->subscribeRemoteVideoStream(userId, subscribe);
  }

  void SetRemoteDefaultVideoStreamType(int streamType) {
    m_rtcEngine->setRemoteDefaultVideoStreamType(streamType);
  }

  void SubscribeRemoteDefaultVideoStream(bool subscribe) {
    m_rtcEngine->subscribeRemoteDefaultVideoStream(subscribe);
  }

  void SetRemoteAudioStreamType(const char* userId, int streamType) {
    m_rtcEngine->setRemoteAudioStreamType(userId, streamType);
  }

  void SubscribeRemoteAudioStream(const char* userId, bool subscribe) {
    m_rtcEngine->subscribeRemoteAudioStream(userId, subscribe);
  }

  void SetRemoteDefaultAudioStreamType(int streamType) {
    m_rtcEngine->setRemoteDefaultAudioStreamType(streamType);
  }

  void SubscribeRemoteDefaultAudioStream(bool subscribe) {
    m_rtcEngine->subscribeRemoteDefaultAudioStream(subscribe);
  }

  void SetClientRole(int role) {
    m_rtcEngine->setClientRole(role);
  }

  void SetRemoteUserPriority(const char* userId, int priority) {
    m_rtcEngine->setRemoteUserPriority(userId, priority);
  }

  void SetLocalUserPriority(int priority) {
    m_rtcEngine->setLocalUserPriority(priority);
  }

  void EnableDualStreamMode(bool enabled) {
    m_rtcEngine->enableDualStreamMode(enabled);
  }

  void SetRemoteVideoProfile(const char* userId, const VideoProfile& profile) {
    m_rtcEngine->setRemoteVideoProfile(userId, profile);
  }

  void SetRemoteAudioProfile(const char* userId, const AudioProfile& profile) {
    m_rtcEngine->setRemoteAudioProfile(userId, profile);
  }

  void SetMixedAudioLevel(int level) {
    m_rtcEngine->setMixedAudioLevel(level);
  }

  void AdjustUserPlaybackSignalVolume(const char* userId, int volume) {
    m_rtcEngine->adjustUserPlaybackSignalVolume(userId, volume);
  }

  void AdjustAudioMixingVolume(int volume) {
    m_rtcEngine->adjustAudioMixingVolume(volume);
  }

  void StartAudioMixing(const char* filePath, bool loopback, bool replace, int cycle) {
    m_rtcEngine->startAudioMixing(filePath, loopback, replace, cycle);
  }

  void StopAudioMixing() {
    m_rtcEngine->stopAudioMixing();
  }

  void PauseAudioMixing() {
    m_rtcEngine->pauseAudioMixing();
  }

  void ResumeAudioMixing() {
    m_rtcEngine->resumeAudioMixing();
  }

  void SetAudioMixingPosition(int pos) {
    m_rtcEngine->setAudioMixingPosition(pos);
  }

  void GetAudioMixingDuration(int& duration) {
    m_rtcEngine->getAudioMixingDuration(duration);
  }

  void SetAudioMixingPitch(int pitch) {
    m_rtcEngine->setAudioMixingPitch(pitch);
  }

  void SetAudioMixingVolume(int volume) {
    m_rtcEngine->setAudioMixingVolume(volume);
  }

  void EnableInEarMonitoring(bool enabled) {
    m_rtcEngine->enableInEarMonitoring(enabled);
  }

  void SetInEarMonitoringVolume(int volume) {
    m_rtcEngine->setInEarMonitoringVolume(volume);
  }

  void RegisterEventHandler(IAgoraRtcEngineEventHandler* handler) {
    m_rtcEngine->registerEventHandler(handler);
  }

  void UnregisterEventHandler(IAgoraRtcEngineEventHandler* handler) {
    m_rtcEngine->unregisterEventHandler(handler);
  }

private:
  IAgoraRtcEngine* m_rtcEngine;
};