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"
 
#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 IVideoEncodedImageReceiver;
class IVideoSinkBase;
 
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) = 0;
  virtual bool removeRenderer(agora_refptr<IVideoSinkBase> videoRenderer, media::base::VIDEO_MODULE_POSITION position = media::base::POSITION_POST_FILTERS) = 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) = 0;
 
  virtual int setVideoEncoderConfiguration(const VideoEncoderConfiguration& config) = 0;
 
  virtual int enableSimulcastStream(bool enabled, const SimulcastStreamConfig& config) = 0;
 
  virtual int setSimulcastStreamMode(SIMULCAST_STREAM_MODE mode, const SimulcastStreamConfig& config) = 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 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) = 0;
  virtual int unregisterVideoEncodedImageReceiver(IVideoEncodedImageReceiver* videoReceiver) = 0;
  virtual VideoTrackType getType() OPTIONAL_OVERRIDE { return REMOTE_VIDEO_TRACK; }
 protected:
  ~IRemoteVideoTrack() {}
};
 
}  // namespace rtc
}  // namespace agora