NGIAgoraVideoTrack.h

Go to the documentation of this file.

 
// 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 "AgoraMediaBase.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];
 
  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;
      } else {
        return false;
      }
    }
    return true;
  }
};
 
enum VideoTrackType {
  LOCAL_VIDEO_TRACK,
  REMOTE_VIDEO_TRACK,
  REMOTE_VIDEO_IMAGE_TRACK,
};
 
class IVideoTrack : public RefCountInterface {
 public:
  virtual bool addRenderer(agora_refptr<IVideoSinkBase> videoRenderer, media::base::VIDEO_MODULE_POSITION position = media::base::POSITION_POST_FILTERS, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
  virtual bool removeRenderer(agora_refptr<IVideoSinkBase> videoRenderer, media::base::VIDEO_MODULE_POSITION position = media::base::POSITION_POST_FILTERS, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
  virtual VideoTrackType getType() = 0;
 
 protected:
  ~IVideoTrack() {}
};
 
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 uplink_cost_time_ms;
 
  QUALITY_ADAPT_INDICATION quality_adapt_indication;
 
  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),
                           uplink_cost_time_ms(0),
                           quality_adapt_indication(ADAPT_NONE) {}
};
 
class ILocalVideoTrack : public IVideoTrack {
 public:
  virtual void 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; }
 
  virtual int registerVideoMetadataObserver(IMetadataObserver* metadataObserver, aosl_ref_t ares = AOSL_REF_INVALID) {
    return 0;
  }
  virtual int unregisterVideoMetadataObserver(IMetadataObserver* metadataObserver) {
    return 0;
  }
 
 protected:
  ~ILocalVideoTrack() {}
};
struct RemoteVideoTrackStats {
  uid_t uid;
  int delay;
  int width;
  int height;
  int receivedBitrate;
  int decoderOutputFrameRate;
  int rendererOutputFrameRate;
  int frameLossRate;
  int packetLossRate;
  VIDEO_STREAM_TYPE rxStreamType;
  int totalFrozenTime;
  int frozenRate;
  uint32_t totalDecodedFrames;
  int avSyncTimeMs;
  uint32_t downlink_process_time_ms;
  uint32_t frame_render_delay_ms;
  uint64_t totalActiveTime;
  uint64_t publishDuration;
 
  RemoteVideoTrackStats() : uid(0), delay(0), width(0), height(0),
                            receivedBitrate(0), decoderOutputFrameRate(0), rendererOutputFrameRate(0),
                            frameLossRate(0), packetLossRate(0), rxStreamType(VIDEO_STREAM_HIGH),
                            totalFrozenTime(0), frozenRate(0), totalDecodedFrames(0), avSyncTimeMs(0),
                            downlink_process_time_ms(0), frame_render_delay_ms(0), totalActiveTime(0), publishDuration(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 registerVideoEncodedImageReceiver(IVideoEncodedImageReceiver* videoReceiver, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
  virtual int unregisterVideoEncodedImageReceiver(IVideoEncodedImageReceiver* videoReceiver) = 0;
  virtual VideoTrackType getType() OPTIONAL_OVERRIDE { return REMOTE_VIDEO_TRACK; }
 protected:
  ~IRemoteVideoTrack() {}
};
 
}  // namespace rtc
}  // namespace agora