NGIAgoraVideoTrack.h

// Copyright (c) 2019 Agora.io. All rights reserved
 
// This program is confidential and proprietary to Agora.io.
// And may not be copied, reproduced, modified, disclosed to others, published
// or used, in whole or in part, without the express prior written permission
// of Agora.io.
 
#pragma once  // NOLINT(build/header_guard)
 
#include "AgoraBase.h"
#include <api/aosl_ref.h>
 
#ifndef OPTIONAL_OVERRIDE
#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
#define OPTIONAL_OVERRIDE override
#else
#define OPTIONAL_OVERRIDE
#endif
#endif
 
namespace agora {
namespace rtc {
class IVideoFilter;
class IVideoEncodedFrameObserver;
class IMediaPacketReceiver;
class IVideoSinkBase;
 
enum StreamLayerIndexInternal {
   STREAM_LAYER_1 = 1,
   STREAM_LAYER_2 = 2,
   STREAM_LAYER_3 = 3,
   STREAM_LAYER_4 = 4,
   STREAM_LAYER_5 = 5,
   STREAM_LAYER_6 = 6,
   STREAM_LOW = 7,
   STREAM_LAYER_COUNT_MAX = 8
  };
 
struct StreamLayerConfigInternal {
  VideoDimensions dimensions;
  int framerate;
  int bitrate_kbps;
  bool enable;
  StreamLayerConfigInternal() : dimensions(0, 0), framerate(0), bitrate_kbps(STANDARD_BITRATE), enable(false) {}
  StreamLayerConfigInternal(const StreamLayerConfigInternal& other) : dimensions(other.dimensions), framerate(other.framerate), bitrate_kbps(other.bitrate_kbps), enable(other.enable) {}
  bool operator==(const StreamLayerConfigInternal& rhs) const {
    return dimensions == rhs.dimensions && bitrate_kbps == rhs.bitrate_kbps && framerate == rhs.framerate && enable == rhs.enable;
  }
 
  StreamLayerConfigInternal& operator=(const SimulcastConfig::StreamLayerConfig& slc) {
    dimensions = slc.dimensions;
    framerate = slc.framerate;
    enable = slc.enable;
    return *this;
  }
 
  void reset() {
    dimensions.width = 0;
    dimensions.height = 0;
    framerate = 0;
    bitrate_kbps = STANDARD_BITRATE;
    enable = false;
  }
};
 
struct SimulcastConfigInternal {
   StreamLayerConfigInternal simulcastlayerConfigs[STREAM_LAYER_COUNT_MAX];
  
  bool publish_fallback_enable;
  bool publish_on_demand;
  
  void reset() {
    for (int i = STREAM_LAYER_1; i < STREAM_LAYER_COUNT_MAX; i++) {
      simulcastlayerConfigs[i].reset();
    }
  }
  
  bool operator==(const SimulcastConfigInternal& rhs) const {
    for (int i = 0; i < STREAM_LAYER_COUNT_MAX; i++) {
      if (simulcastlayerConfigs[i] == rhs.simulcastlayerConfigs[i]) {
        continue;
      }
      return false;
    }
    return publish_fallback_enable == rhs.publish_fallback_enable &&
           publish_on_demand == rhs.publish_on_demand;
  }
  
  SimulcastConfigInternal(): publish_fallback_enable(false), publish_on_demand(true) {}
};
 
enum VideoTrackType {
  LOCAL_VIDEO_TRACK,
  REMOTE_VIDEO_TRACK,
  REMOTE_VIDEO_IMAGE_TRACK,
};
 
class IVideoTrack : public RefCountInterface {
 public:
  virtual bool addVideoFilter(
      agora_refptr<IVideoFilter> filter, media::base::VIDEO_MODULE_POSITION position = media::base::POSITION_POST_CAPTURER,
      const char* id = NULL, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual bool removeVideoFilter(
      agora_refptr<IVideoFilter> filter, media::base::VIDEO_MODULE_POSITION position = media::base::POSITION_POST_CAPTURER,
      const char* id = NULL, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual bool hasVideoFilter(const char* id, media::base::VIDEO_MODULE_POSITION position = media::base::POSITION_POST_CAPTURER) = 0;
 
  virtual bool addRenderer(agora_refptr<IVideoSinkBase> videoRenderer, media::base::VIDEO_MODULE_POSITION position, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
  virtual bool removeRenderer(agora_refptr<IVideoSinkBase> videoRenderer, media::base::VIDEO_MODULE_POSITION position, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
  virtual VideoTrackType getType() = 0;
 
  virtual int enableVideoFilter(const char* id, bool enable, aosl_ref_t ares = AOSL_REF_INVALID) { return -1; }
 
  virtual int setFilterProperty(const char* id, const char* key, const char* json_value, aosl_ref_t ares = AOSL_REF_INVALID) { return -1; }
 
  virtual int getFilterProperty(const char* id, const char* key, char* json_value, size_t buf_size, aosl_ref_t ares = AOSL_REF_INVALID) { return -1; }
 
  virtual int registerVideoEncodedFrameObserver(agora::media::IVideoEncodedFrameObserver* encodedObserver, aosl_ref_t ares = AOSL_REF_INVALID) {return -1;};
  virtual int unregisterVideoEncodedFrameObserver(agora::media::IVideoEncodedFrameObserver* encodedObserver) {return -1;};
 
 protected:
  ~IVideoTrack() {}
};
 
struct SimulcastStreamProfile {
  int width;
  int height;
  int framerate;
  int bitrate;
};
struct LocalVideoTrackStats {
  uint64_t number_of_streams;
  uint64_t bytes_major_stream;
  uint64_t bytes_minor_stream;
  uint32_t frames_encoded;
  uint32_t ssrc_major_stream;
  uint32_t ssrc_minor_stream;
  int capture_frame_rate;
  int regulated_capture_frame_rate;
  int input_frame_rate;
  int encode_frame_rate;
  int render_frame_rate;
  int target_media_bitrate_bps;
  int media_bitrate_bps;
  int total_bitrate_bps;  // Include FEC
  int capture_width;
  int capture_height;
  int regulated_capture_width;
  int regulated_capture_height;
  int width;
  int height;
  uint32_t encoder_type;
  uint32_t hw_encoder_accelerating;
  uint32_t encoder_frame_depth;
  /*
   * encoder vender id, VideoCodecVenderId
  */
  uint32_t encoder_vender_id;
  uint32_t uplink_cost_time_ms;
  QUALITY_ADAPT_INDICATION quality_adapt_indication;
  unsigned short txPacketLossRate;
 
  CAPTURE_BRIGHTNESS_LEVEL_TYPE capture_brightness_level;
  
  SimulcastStreamProfile simulcast_stream_profile[STREAM_LAYER_COUNT_MAX];
 
  LocalVideoTrackStats() : number_of_streams(0),
                           bytes_major_stream(0),
                           bytes_minor_stream(0),
                           frames_encoded(0),
                           ssrc_major_stream(0),
                           ssrc_minor_stream(0),
                           capture_frame_rate(0),
                           regulated_capture_frame_rate(0),
                           input_frame_rate(0),
                           encode_frame_rate(0),
                           render_frame_rate(0),
                           target_media_bitrate_bps(0),
                           media_bitrate_bps(0),
                           total_bitrate_bps(0),
                           capture_width(0),
                           capture_height(0),
                           regulated_capture_width(0),
                           regulated_capture_height(0),
                           width(0),
                           height(0),
                           encoder_type(0),
                           hw_encoder_accelerating(0),
                           encoder_frame_depth(8),
                           encoder_vender_id(0),
                           uplink_cost_time_ms(0),
                           quality_adapt_indication(ADAPT_NONE),
                           txPacketLossRate(0),
                           capture_brightness_level(CAPTURE_BRIGHTNESS_LEVEL_INVALID) {}
};
 
class ILocalVideoTrack : public IVideoTrack {
 public:
  virtual int setEnabled(bool enable, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual int setVideoEncoderConfiguration(const VideoEncoderConfiguration& config, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual int setSimulcastStreamMode(SIMULCAST_STREAM_MODE mode, const SimulcastConfigInternal& config, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual LOCAL_VIDEO_STREAM_STATE getState() = 0;
 
  virtual bool getStatistics(LocalVideoTrackStats& stats) = 0;
 
  virtual VideoTrackType getType() OPTIONAL_OVERRIDE { return LOCAL_VIDEO_TRACK; }
 
 protected:
  ~ILocalVideoTrack() {}
};
struct RemoteVideoTrackStats {
  uid_t uid;
  int delay;
  int e2eDelay;
  int width;
  int height;
  int receivedBitrate;
  int decoderInputFrameRate;
  int decoderOutputFrameRate;
  int rendererOutputFrameRate;
  int frameLossRate;
  int packetLossRate;
  VIDEO_STREAM_TYPE rxStreamType;
  int totalFrozenTime;
  int frozenRate;
  uint32_t received_bytes;
  uint32_t totalDecodedFrames;
  int avSyncTimeMs;
  uint32_t downlink_process_time_ms;
  uint32_t frame_render_delay_ms;
  uint64_t totalActiveTime;
  uint64_t publishDuration;
  int vqa_mos;
  int vqa_avg_cost_ms;
  uint32_t decoder_vender_id;
  uint32_t decoder_type;
 
  RemoteVideoTrackStats() : uid(0), delay(0), width(0), height(0),
                            receivedBitrate(0), decoderInputFrameRate(0), decoderOutputFrameRate(0), rendererOutputFrameRate(0),
                            frameLossRate(0), packetLossRate(0), rxStreamType(VIDEO_STREAM_HIGH),
                            totalFrozenTime(0), frozenRate(0), received_bytes(0), totalDecodedFrames(0), avSyncTimeMs(0),
                            downlink_process_time_ms(0), frame_render_delay_ms(0), totalActiveTime(0),
                            publishDuration(0), vqa_mos(0), vqa_avg_cost_ms(0), decoder_vender_id(0), decoder_type(0) {}
};
 
class IRemoteVideoTrack : public IVideoTrack {
 public:
  virtual bool getStatistics(RemoteVideoTrackStats& stats) = 0;
  virtual REMOTE_VIDEO_STATE getState() = 0;
  virtual bool getTrackInfo(VideoTrackInfo& info) = 0;
 
  virtual int registerMediaPacketReceiver(IMediaPacketReceiver* videoReceiver, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
  virtual int unregisterMediaPacketReceiver(IMediaPacketReceiver* videoReceiver) = 0;
 
  virtual VideoTrackType getType() OPTIONAL_OVERRIDE { return REMOTE_VIDEO_TRACK; }
 
 protected:
  ~IRemoteVideoTrack() {}
};
 
}  // namespace rtc
}  // namespace agora