AgoraMediaBase.h

Go to the documentation of this file.

//
//  Agora Engine SDK
//
//  Created by Sting Feng in 2017-11.
//  Copyright (c) 2017 Agora.io. All rights reserved.
 
#pragma once  // NOLINT(build/header_guard)
 
#include <cstring>
#include <stdint.h>
#include <limits>
#include <stddef.h>
 
#ifndef OPTIONAL_ENUM_SIZE_T
#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
#define OPTIONAL_ENUM_SIZE_T enum : size_t
#else
#define OPTIONAL_ENUM_SIZE_T enum
#endif
#endif
 
#if !defined(__APPLE__)
#define __deprecated
#endif
 
namespace agora {
namespace rtc {
 
typedef unsigned int uid_t;
typedef unsigned int track_id_t;
typedef unsigned int conn_id_t;
typedef unsigned int video_track_id_t;
 
static const unsigned int INVALID_TRACK_ID = 0xffffffff;
static const unsigned int DEFAULT_CONNECTION_ID = 0;
static const unsigned int DUMMY_CONNECTION_ID = (std::numeric_limits<unsigned int>::max)();
 
static const int kAdmMaxDeviceNameSize = 128;
static const int kAdmMaxGuidSize = 128;
 
 
struct EncodedVideoFrameInfo;
 
 
enum VIDEO_SOURCE_TYPE {
  VIDEO_SOURCE_CAMERA_PRIMARY = 0,
  VIDEO_SOURCE_CAMERA = VIDEO_SOURCE_CAMERA_PRIMARY,
  VIDEO_SOURCE_CAMERA_SECONDARY = 1,
  VIDEO_SOURCE_SCREEN_PRIMARY = 2,
  VIDEO_SOURCE_SCREEN = VIDEO_SOURCE_SCREEN_PRIMARY,
  VIDEO_SOURCE_SCREEN_SECONDARY = 3,
  VIDEO_SOURCE_CUSTOM = 4,
  VIDEO_SOURCE_MEDIA_PLAYER = 5,
  VIDEO_SOURCE_RTC_IMAGE_PNG = 6,
  VIDEO_SOURCE_RTC_IMAGE_JPEG = 7,
  VIDEO_SOURCE_RTC_IMAGE_GIF = 8,
  VIDEO_SOURCE_REMOTE = 9,
  VIDEO_SOURCE_TRANSCODED = 10,
 
  VIDEO_SOURCE_CAMERA_THIRD = 11,
  VIDEO_SOURCE_CAMERA_FOURTH = 12,
  VIDEO_SOURCE_SCREEN_THIRD = 13,
  VIDEO_SOURCE_SCREEN_FOURTH = 14,
  VIDEO_SOURCE_SPEECH_DRIVEN = 15,
 
  VIDEO_SOURCE_UNKNOWN = 100
};
 
enum AudioRoute
{
  ROUTE_DEFAULT = -1,
  ROUTE_HEADSET = 0,
  ROUTE_EARPIECE = 1,
  ROUTE_HEADSETNOMIC = 2,
  ROUTE_SPEAKERPHONE = 3,
  ROUTE_LOUDSPEAKER = 4,
  ROUTE_HEADSETBLUETOOTH = 5,
  ROUTE_USB = 6,
  ROUTE_HDMI = 7,
  ROUTE_DISPLAYPORT = 8,
  ROUTE_AIRPLAY = 9,
  ROUTE_VIRTUAL = 10,
  ROUTE_CONTINUITY = 11,
};
 
enum BYTES_PER_SAMPLE {
  TWO_BYTES_PER_SAMPLE = 2,
};
 
struct AudioParameters {
  int sample_rate;
  size_t channels;
  size_t frames_per_buffer;
 
  AudioParameters()
      : sample_rate(0),
        channels(0),
        frames_per_buffer(0) {}
};
 
enum RAW_AUDIO_FRAME_OP_MODE_TYPE {
  RAW_AUDIO_FRAME_OP_MODE_READ_ONLY = 0,
 
  RAW_AUDIO_FRAME_OP_MODE_READ_WRITE = 2,
};
 
enum TRACK_AUDIO_MIXED_POLICY_TYPE {
  TRACK_AUDIO_MIXED_LOCAL = 1 << 0,
  TRACK_AUDIO_MIXED_REMOTE = 1 << 1,
};
 
struct AudioDeviceInfo {
  char deviceName[kAdmMaxDeviceNameSize];
  char deviceId[kAdmMaxGuidSize];
  bool isCurrentSelected;
  bool isPlayoutDevice;
 
  AudioRoute routing;
 
  AudioDeviceInfo() : isCurrentSelected(false),
                      isPlayoutDevice(true),
                      routing(ROUTE_DEFAULT){
    memset(deviceName, 0, sizeof(deviceName));
    memset(deviceId, 0, sizeof(deviceId));
  }
 
  AudioDeviceInfo(const AudioDeviceInfo& other) : isCurrentSelected(other.isCurrentSelected),
                      isPlayoutDevice(other.isPlayoutDevice),
                      routing(other.routing){
    memcpy(deviceName, other.deviceName, sizeof(deviceName));
    memcpy(deviceId, other.deviceId, sizeof(deviceId));
  }
 
  AudioDeviceInfo& operator=(const AudioDeviceInfo& other) {
    isCurrentSelected = other.isCurrentSelected;
    isPlayoutDevice = other.isPlayoutDevice;
    routing = other.routing;
    memcpy(deviceName, other.deviceName, sizeof(deviceName));
    memcpy(deviceId, other.deviceId, sizeof(deviceId));
    return *this;
  }
};
 
}  // namespace rtc
 
namespace media {
enum MEDIA_SOURCE_TYPE {
  AUDIO_PLAYOUT_SOURCE = 0,
  AUDIO_RECORDING_SOURCE = 1,
  PRIMARY_CAMERA_SOURCE = 2,
  SECONDARY_CAMERA_SOURCE = 3,
  PRIMARY_SCREEN_SOURCE = 4,
  SECONDARY_SCREEN_SOURCE = 5,
  CUSTOM_VIDEO_SOURCE = 6,
  MEDIA_PLAYER_SOURCE = 7,
  RTC_IMAGE_PNG_SOURCE = 8,
  RTC_IMAGE_JPEG_SOURCE = 9,
  RTC_IMAGE_GIF_SOURCE = 10,
  REMOTE_VIDEO_SOURCE = 11,
  TRANSCODED_VIDEO_SOURCE = 12,
  SPEECH_DRIVEN_VIDEO_SOURCE = 13,
  UNKNOWN_MEDIA_SOURCE = 100
};
#define MAX_CONTENT_INSPECT_MODULE_COUNT 32
enum CONTENT_INSPECT_RESULT {
  CONTENT_INSPECT_NEUTRAL = 1,
  CONTENT_INSPECT_SEXY = 2,
  CONTENT_INSPECT_PORN = 3,
};
 
enum CONTENT_INSPECT_TYPE {
CONTENT_INSPECT_INVALID = 0,
CONTENT_INSPECT_MODERATION __deprecated = 1,
CONTENT_INSPECT_SUPERVISION = 2,
CONTENT_INSPECT_IMAGE_MODERATION = 3
};
 
struct ContentInspectModule {
  CONTENT_INSPECT_TYPE type;
  unsigned int interval;
  ContentInspectModule() {
    type = CONTENT_INSPECT_INVALID;
    interval = 0;
  }
};
struct ContentInspectConfig {
  const char* extraInfo;
  const char* serverConfig;
  ContentInspectModule modules[MAX_CONTENT_INSPECT_MODULE_COUNT];
  int moduleCount;
   ContentInspectConfig& operator=(const ContentInspectConfig& rth)
    {
        extraInfo = rth.extraInfo;
        serverConfig = rth.serverConfig;
        moduleCount = rth.moduleCount;
        memcpy(&modules, &rth.modules,  MAX_CONTENT_INSPECT_MODULE_COUNT * sizeof(ContentInspectModule));
        return *this;
    }
  ContentInspectConfig() :extraInfo(NULL), serverConfig(NULL), moduleCount(0){}
};
 
namespace base {
 
typedef void* view_t;
 
typedef const char* user_id_t;
 
static const uint8_t kMaxCodecNameLength = 50;
 
struct PacketOptions {
  uint32_t timestamp;
  // Audio level indication.
  uint8_t audioLevelIndication;
  PacketOptions()
      : timestamp(0),
        audioLevelIndication(127) {}
};
 
struct AudioEncodedFrameInfo {
  uint64_t sendTs;
  uint8_t codec;
  AudioEncodedFrameInfo()
      : sendTs(0),
        codec(0) {}
};
 
struct AudioPcmFrame {
  OPTIONAL_ENUM_SIZE_T {
    // Stereo, 32 kHz, 60 ms (2 * 32 * 60)
    kMaxDataSizeSamples = 3840,
    kMaxDataSizeBytes = kMaxDataSizeSamples * sizeof(int16_t),
  };
 
  int64_t capture_timestamp;
  size_t samples_per_channel_;
  int sample_rate_hz_;
  size_t num_channels_;
  rtc::BYTES_PER_SAMPLE bytes_per_sample;
  int16_t data_[kMaxDataSizeSamples];
 
  AudioPcmFrame& operator=(const AudioPcmFrame& src) {
    if(this == &src) {
      return *this;
    }
 
    this->capture_timestamp = src.capture_timestamp;
    this->samples_per_channel_ = src.samples_per_channel_;
    this->sample_rate_hz_ = src.sample_rate_hz_;
    this->bytes_per_sample = src.bytes_per_sample;
    this->num_channels_ = src.num_channels_;
 
    size_t length = src.samples_per_channel_ * src.num_channels_;
    if (length > kMaxDataSizeSamples) {
      length = kMaxDataSizeSamples;
    }
 
    memcpy(this->data_, src.data_, length * sizeof(int16_t));
 
    return *this;
  }
 
  AudioPcmFrame()
      : capture_timestamp(0),
        samples_per_channel_(0),
        sample_rate_hz_(0),
        num_channels_(0),
        bytes_per_sample(rtc::TWO_BYTES_PER_SAMPLE) {
    memset(data_, 0, sizeof(data_));
  }
 
  AudioPcmFrame(const AudioPcmFrame& src)
      : capture_timestamp(src.capture_timestamp),
        samples_per_channel_(src.samples_per_channel_),
        sample_rate_hz_(src.sample_rate_hz_),
        num_channels_(src.num_channels_),
        bytes_per_sample(src.bytes_per_sample) {
    size_t length = src.samples_per_channel_ * src.num_channels_;
    if (length > kMaxDataSizeSamples) {
      length = kMaxDataSizeSamples;
    }
 
    memcpy(this->data_, src.data_, length * sizeof(int16_t));
  }
};
 
enum AUDIO_DUAL_MONO_MODE {
  AUDIO_DUAL_MONO_STEREO = 0,
  AUDIO_DUAL_MONO_L = 1,
  AUDIO_DUAL_MONO_R = 2,
  AUDIO_DUAL_MONO_MIX = 3
};
 
enum VIDEO_PIXEL_FORMAT {
  VIDEO_PIXEL_DEFAULT = 0,
  VIDEO_PIXEL_I420 = 1,
  VIDEO_PIXEL_BGRA = 2,
  VIDEO_PIXEL_NV21 = 3,
  VIDEO_PIXEL_RGBA = 4,
  VIDEO_PIXEL_NV12 = 8,
  VIDEO_TEXTURE_2D = 10,
  VIDEO_TEXTURE_OES = 11,
  /*
  12: pixel format for iOS CVPixelBuffer NV12
  */
  VIDEO_CVPIXEL_NV12 = 12,
  /*
  13: pixel format for iOS CVPixelBuffer I420
  */
  VIDEO_CVPIXEL_I420 = 13,
  /*
  14: pixel format for iOS CVPixelBuffer BGRA
  */
  VIDEO_CVPIXEL_BGRA = 14,
  VIDEO_PIXEL_I422 = 16,
  VIDEO_TEXTURE_ID3D11TEXTURE2D = 17,
  VIDEO_PIXEL_I010 = 18,
};
 
enum RENDER_MODE_TYPE {
  RENDER_MODE_HIDDEN = 1,
  RENDER_MODE_FIT = 2,
  RENDER_MODE_ADAPTIVE __deprecated = 3,
};
 
enum CAMERA_VIDEO_SOURCE_TYPE {
  CAMERA_SOURCE_FRONT = 0,
  CAMERA_SOURCE_BACK = 1,
  VIDEO_SOURCE_UNSPECIFIED = 2,
};
 
class IVideoFrameMetaInfo {
  public:
    enum META_INFO_KEY {
      KEY_FACE_CAPTURE = 0,
    };
    virtual ~IVideoFrameMetaInfo() {};
    virtual const char* getMetaInfoStr(META_INFO_KEY key) const = 0;
};
 
struct ExternalVideoFrame {
  ExternalVideoFrame()
      : type(VIDEO_BUFFER_RAW_DATA),
        format(VIDEO_PIXEL_DEFAULT),
        buffer(NULL),
        stride(0),
        height(0),
        cropLeft(0),
        cropTop(0),
        cropRight(0),
        cropBottom(0),
        rotation(0),
        timestamp(0),
        eglContext(NULL),
        eglType(EGL_CONTEXT10),
        textureId(0),
        metadata_buffer(NULL),
        metadata_size(0),
        alphaBuffer(NULL),
        fillAlphaBuffer(false),
        d3d11_texture_2d(NULL),
        texture_slice_index(0){}
 
  enum EGL_CONTEXT_TYPE {
    EGL_CONTEXT10 = 0,
    EGL_CONTEXT14 = 1,
  };
 
  enum VIDEO_BUFFER_TYPE {
    VIDEO_BUFFER_RAW_DATA = 1,
    VIDEO_BUFFER_ARRAY = 2,
    VIDEO_BUFFER_TEXTURE = 3,
  };
 
  VIDEO_BUFFER_TYPE type;
  VIDEO_PIXEL_FORMAT format;
  void* buffer;
  int stride;
  int height;
  int cropLeft;
  int cropTop;
  int cropRight;
  int cropBottom;
  int rotation;
  long long timestamp;
  void *eglContext;
  EGL_CONTEXT_TYPE eglType;
  int textureId;
  float matrix[16];
  uint8_t* metadata_buffer;
  int metadata_size;
  uint8_t* alphaBuffer;
  bool fillAlphaBuffer;
 
  void *d3d11_texture_2d;
 
  int texture_slice_index;
};
 
struct VideoFrame {
  VideoFrame():
  type(VIDEO_PIXEL_DEFAULT),
  width(0),
  height(0),
  yStride(0),
  uStride(0),
  vStride(0),
  yBuffer(NULL),
  uBuffer(NULL),
  vBuffer(NULL),
  rotation(0),
  renderTimeMs(0),
  avsync_type(0),
  metadata_buffer(NULL),
  metadata_size(0),
  sharedContext(0),
  textureId(0),
  d3d11Texture2d(NULL),
  alphaBuffer(NULL),
  pixelBuffer(NULL),
  metaInfo(NULL){
    memset(matrix, 0, sizeof(matrix));
  }
  VIDEO_PIXEL_FORMAT type;
  int width;
  int height;
  int yStride;
  int uStride;
  int vStride;
  uint8_t* yBuffer;
  uint8_t* uBuffer;
  uint8_t* vBuffer;
  int rotation;
  int64_t renderTimeMs;
  int avsync_type;
  uint8_t* metadata_buffer;
  int metadata_size;
  void* sharedContext;
  int textureId;
  void* d3d11Texture2d;
  float matrix[16];
  uint8_t* alphaBuffer;
  void* pixelBuffer;
  IVideoFrameMetaInfo* metaInfo;
};
 
class IVideoFrameObserver {
 public:
  virtual void onFrame(const VideoFrame* frame) = 0;
  virtual ~IVideoFrameObserver() {}
  virtual bool isExternal() { return true; }
  virtual VIDEO_PIXEL_FORMAT getVideoFormatPreference() { return VIDEO_PIXEL_DEFAULT; }
};
 
enum MEDIA_PLAYER_SOURCE_TYPE {
  MEDIA_PLAYER_SOURCE_DEFAULT,
  MEDIA_PLAYER_SOURCE_FULL_FEATURED,
  MEDIA_PLAYER_SOURCE_SIMPLE,
};
 
enum VIDEO_MODULE_POSITION {
  POSITION_POST_CAPTURER = 1 << 0,
  POSITION_PRE_RENDERER = 1 << 1,
  POSITION_PRE_ENCODER = 1 << 2,
};
 
}  // namespace base
 
class IAudioPcmFrameSink {
 public:
  virtual void onFrame(agora::media::base::AudioPcmFrame* frame) = 0;
  virtual ~IAudioPcmFrameSink() {}
};
 
class IAudioFrameObserverBase {
 public:
  enum AUDIO_FRAME_TYPE {
    FRAME_TYPE_PCM16 = 0,
  };
  enum { MAX_HANDLE_TIME_CNT = 10 };
  struct AudioFrame {
    AUDIO_FRAME_TYPE type;
    int samplesPerChannel;
    agora::rtc::BYTES_PER_SAMPLE bytesPerSample;
    int channels;
    int samplesPerSec;
    void* buffer;
    int64_t renderTimeMs;
    int avsync_type;
    int64_t presentationMs;
    int audioTrackNumber;
    uint32_t rtpTimestamp;
 
    AudioFrame() : type(FRAME_TYPE_PCM16),
                   samplesPerChannel(0),
                   bytesPerSample(rtc::TWO_BYTES_PER_SAMPLE),
                   channels(0),
                   samplesPerSec(0),
                   buffer(NULL),
                   renderTimeMs(0),
                   avsync_type(0),
                   presentationMs(0),
                   audioTrackNumber(0),
                   rtpTimestamp(0) {}
  };
 
  enum AUDIO_FRAME_POSITION {
    AUDIO_FRAME_POSITION_NONE = 0x0000,
    AUDIO_FRAME_POSITION_PLAYBACK = 0x0001,
    AUDIO_FRAME_POSITION_RECORD = 0x0002,
    AUDIO_FRAME_POSITION_MIXED = 0x0004,
    AUDIO_FRAME_POSITION_BEFORE_MIXING = 0x0008,
    AUDIO_FRAME_POSITION_EAR_MONITORING = 0x0010,
  };
 
  struct AudioParams {
    int sample_rate;
 
    /* The number of audio channels, which can be set as either of the following values:
 
     - `1`: Mono (Default)
     - `2`: Stereo
     */
    int channels;
 
    /* The use mode of the audio data. See AgoraAudioRawFrameOperationMode.
     */
    rtc::RAW_AUDIO_FRAME_OP_MODE_TYPE mode;
 
    int samples_per_call;
 
    AudioParams() : sample_rate(0), channels(0), mode(rtc::RAW_AUDIO_FRAME_OP_MODE_READ_ONLY), samples_per_call(0) {}
    AudioParams(int samplerate, int channel, rtc::RAW_AUDIO_FRAME_OP_MODE_TYPE type, int samplesPerCall) : sample_rate(samplerate), channels(channel), mode(type), samples_per_call(samplesPerCall) {}
  };
 
 public:
  virtual ~IAudioFrameObserverBase() {}
 
  virtual bool onRecordAudioFrame(const char* channelId, AudioFrame& audioFrame) = 0;
  virtual bool onPlaybackAudioFrame(const char* channelId, AudioFrame& audioFrame) = 0;
  virtual bool onMixedAudioFrame(const char* channelId, AudioFrame& audioFrame) = 0;
  virtual bool onEarMonitoringAudioFrame(AudioFrame& audioFrame) = 0;
  virtual bool onPlaybackAudioFrameBeforeMixing(const char* channelId, base::user_id_t userId, AudioFrame& audioFrame) {
    (void) channelId;
    (void) userId;
    (void) audioFrame;
    return true;
  }
 
  virtual int getObservedAudioFramePosition() = 0;
 
  virtual AudioParams getPlaybackAudioParams() = 0;
 
  virtual AudioParams getRecordAudioParams() = 0;
 
  virtual AudioParams getMixedAudioParams() = 0;
 
  virtual AudioParams getEarMonitoringAudioParams() = 0;
};
 
class IAudioFrameObserver : public IAudioFrameObserverBase {
 public:
  using IAudioFrameObserverBase::onPlaybackAudioFrameBeforeMixing;
  virtual bool onPlaybackAudioFrameBeforeMixing(const char* channelId, rtc::uid_t uid, AudioFrame& audioFrame) = 0;
};
 
struct AudioSpectrumData {
  const float *audioSpectrumData;
  int dataLength;
 
  AudioSpectrumData() : audioSpectrumData(NULL), dataLength(0) {}
  AudioSpectrumData(const float *data, int length) :
    audioSpectrumData(data), dataLength(length) {}
};
 
struct UserAudioSpectrumInfo  {
  agora::rtc::uid_t uid;
  struct AudioSpectrumData spectrumData;
 
  UserAudioSpectrumInfo () : uid(0), spectrumData() {}
  UserAudioSpectrumInfo(agora::rtc::uid_t _uid, const float *data, int length) :
    uid(_uid) { spectrumData.audioSpectrumData = data; spectrumData.dataLength = length; }
};
 
class IAudioSpectrumObserver {
public:
  virtual ~IAudioSpectrumObserver() {}
 
  virtual bool onLocalAudioSpectrum(const AudioSpectrumData& data) = 0;
 
  virtual bool onRemoteAudioSpectrum(const UserAudioSpectrumInfo * spectrums, unsigned int spectrumNumber) = 0;
};
 
class IVideoEncodedFrameObserver {
 public:
  virtual bool onEncodedVideoFrameReceived(rtc::uid_t uid, const uint8_t* imageBuffer, size_t length,
                                           const rtc::EncodedVideoFrameInfo& videoEncodedFrameInfo) = 0;
 
  virtual ~IVideoEncodedFrameObserver() {}
};
 
class IVideoFrameObserver {
 public:
  typedef media::base::VideoFrame VideoFrame;
  enum VIDEO_FRAME_PROCESS_MODE {
    PROCESS_MODE_READ_ONLY, // Observer works as a pure renderer and will not modify the original frame.
    PROCESS_MODE_READ_WRITE, // Observer works as a filter that will process the video frame and affect the following frame processing in SDK.
  };
 
 public:
  virtual ~IVideoFrameObserver() {}
 
  virtual bool onCaptureVideoFrame(agora::rtc::VIDEO_SOURCE_TYPE sourceType, VideoFrame& videoFrame) = 0;
 
  virtual bool onPreEncodeVideoFrame(agora::rtc::VIDEO_SOURCE_TYPE sourceType, VideoFrame& videoFrame) = 0;
 
  virtual bool onMediaPlayerVideoFrame(VideoFrame& videoFrame, int mediaPlayerId) = 0;
 
  virtual bool onRenderVideoFrame(const char* channelId, rtc::uid_t remoteUid, VideoFrame& videoFrame) = 0;
 
  virtual bool onTranscodedVideoFrame(VideoFrame& videoFrame) = 0;
 
  virtual VIDEO_FRAME_PROCESS_MODE getVideoFrameProcessMode() {
    return PROCESS_MODE_READ_ONLY;
  }
 
  virtual base::VIDEO_PIXEL_FORMAT getVideoFormatPreference() { return base::VIDEO_PIXEL_DEFAULT; }
 
  virtual bool getRotationApplied() { return false; }
 
  virtual bool getMirrorApplied() { return false; }
 
  virtual uint32_t getObservedFramePosition() {
    return base::POSITION_POST_CAPTURER | base::POSITION_PRE_RENDERER;
  }
 
  virtual bool isExternal() { return true; }
};
 
enum EXTERNAL_VIDEO_SOURCE_TYPE {
  VIDEO_FRAME = 0,
  ENCODED_VIDEO_FRAME,
};
 
enum MediaRecorderContainerFormat {
  FORMAT_MP4 = 1,
};
enum MediaRecorderStreamType {
  STREAM_TYPE_AUDIO = 0x01,
  STREAM_TYPE_VIDEO = 0x02,
  STREAM_TYPE_BOTH = STREAM_TYPE_AUDIO | STREAM_TYPE_VIDEO,
};
enum RecorderState {
  RECORDER_STATE_ERROR = -1,
  RECORDER_STATE_START = 2,
  RECORDER_STATE_STOP = 3,
};
enum RecorderErrorCode {
  RECORDER_ERROR_NONE = 0,
  RECORDER_ERROR_WRITE_FAILED = 1,
  RECORDER_ERROR_NO_STREAM = 2,
  RECORDER_ERROR_OVER_MAX_DURATION = 3,
  RECORDER_ERROR_CONFIG_CHANGED = 4,
};
struct MediaRecorderConfiguration {
  const char* storagePath;
  MediaRecorderContainerFormat containerFormat;
  MediaRecorderStreamType streamType;
  int maxDurationMs;
  int recorderInfoUpdateInterval;
 
  MediaRecorderConfiguration() : storagePath(NULL), containerFormat(FORMAT_MP4), streamType(STREAM_TYPE_BOTH), maxDurationMs(120000), recorderInfoUpdateInterval(0) {}
  MediaRecorderConfiguration(const char* path, MediaRecorderContainerFormat format, MediaRecorderStreamType type, int duration, int interval) : storagePath(path), containerFormat(format), streamType(type), maxDurationMs(duration), recorderInfoUpdateInterval(interval) {}
};
 
class IFaceInfoObserver {
public:
   virtual bool onFaceInfo(const char* outFaceInfo) = 0;
  
   virtual ~IFaceInfoObserver() {}
};
 
struct RecorderInfo {
  const char* fileName;
  unsigned int durationMs;
  unsigned int fileSize;
 
  RecorderInfo() : fileName(NULL), durationMs(0), fileSize(0) {}
  RecorderInfo(const char* name, unsigned int dur, unsigned int size) : fileName(name), durationMs(dur), fileSize(size) {}
};
 
 
class IMediaRecorderObserver {
 public:
  virtual void onRecorderStateChanged(const char* channelId, rtc::uid_t uid, RecorderState state, RecorderErrorCode error) = 0;
  virtual void onRecorderInfoUpdated(const char* channelId, rtc::uid_t uid, const RecorderInfo& info) = 0;
  virtual ~IMediaRecorderObserver() {}
};
}  // namespace media
}  // namespace agora