NGIAgoraAudioTrack.h

Go to the documentation of this file.

 
// Copyright (c) 2018 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"
 
// FIXME(Ender): use this class instead of AudioSendStream as local track
namespace agora {
namespace rtc {
class IAudioTrackStateObserver;
class IAudioSinkBase;
struct AudioSinkWants {
  int samplesPerSec;
 
  size_t channels;
 
  AudioSinkWants() : samplesPerSec(0),
                     channels(0) {}
  AudioSinkWants(int sampleRate, size_t chs) : samplesPerSec(sampleRate),
                                               channels(chs) {}
};
 
class IAudioTrack : public RefCountInterface {
public:
  enum AudioFilterPosition {
    RecordingLocalPlayback,
    PostAudioProcessing,
    PcmSource,
    PcmSourceSending,
    PcmSourceLocalPlayback,
  };
 
 public:
 
  virtual int adjustPlayoutVolume(int volume) = 0;
 
  virtual int getPlayoutVolume(int* volume) = 0;
 
  virtual bool addAudioSink(agora_refptr<IAudioSinkBase> sink, const AudioSinkWants& wants) = 0;
 
  virtual bool removeAudioSink(agora_refptr<IAudioSinkBase> sink) = 0;
};
 
class ILocalAudioTrack : public IAudioTrack {
 public:
  struct LocalAudioTrackStats {
    uint32_t source_id;
    uint32_t buffered_pcm_data_list_size;
    uint32_t missed_audio_frames;
    uint32_t sent_audio_frames;
    uint32_t pushed_audio_frames;
    uint32_t dropped_audio_frames;
    uint32_t playout_audio_frames;
    uint32_t effect_type;
 
    uint32_t hw_ear_monitor;
 
    bool enabled;
    
    uint32_t audio_volume; // [0,255]
    
    LocalAudioTrackStats() : source_id(0),
                             buffered_pcm_data_list_size(0),
                             missed_audio_frames(0),
                             sent_audio_frames(0),
                             pushed_audio_frames(0),
                             dropped_audio_frames(0),
                             playout_audio_frames(0),
                             effect_type(0),
                             hw_ear_monitor(0),
                             enabled(false),
                             audio_volume(0) {}
  };
 
 public:
  virtual void setEnabled(bool enable) = 0;
 
  virtual bool isEnabled() const = 0;
 
  virtual LOCAL_AUDIO_STREAM_STATE getState() = 0;
 
  virtual LocalAudioTrackStats GetStats() = 0;
 
  virtual int adjustPublishVolume(int volume) = 0;
 
  virtual int getPublishVolume(int* volume) = 0;
 
 
  virtual int enableLocalPlayback(bool enable) = 0;
  virtual int enableEarMonitor(bool enable, int includeAudioFilters) = 0;
 protected:
   ~ILocalAudioTrack() {}
};
 
struct RemoteAudioTrackStats {
  uid_t uid;
  int quality;
  int network_transport_delay;
  uint32_t jitter_buffer_delay;
  int audio_loss_rate;
  int num_channels;
  int received_sample_rate;
  int received_bitrate;
  int total_frozen_time;
  int frozen_rate;
  int64_t received_bytes;
 
  int mean_waiting_time;
  size_t expanded_speech_samples;
  size_t expanded_noise_samples;
  uint32_t timestamps_since_last_report;
  uint16_t min_sequence_number;
  uint16_t max_sequence_number;
  int32_t audio_level;
  uint32_t downlink_process_time_ms;
 
  uint32_t target_level_base_ms;
  uint32_t target_level_prefered_ms;
 
  uint16_t frozen_count_80_ms;
  uint16_t frozen_time_80_ms;
  uint16_t frozen_count_200_ms;
  uint16_t frozen_time_200_ms;
  uint32_t delay_estimate_ms;
  uint32_t mos_value;
  uint64_t total_active_time;
  uint64_t publish_duration;
  int32_t e2e_delay_ms;
 
  RemoteAudioTrackStats() :
    uid(0),
    quality(0),
    network_transport_delay(0),
    jitter_buffer_delay(0),
    audio_loss_rate(0),
    num_channels(0),
    received_sample_rate(0),
    received_bitrate(0),
    total_frozen_time(0),
    frozen_rate(0),
    received_bytes(0),
    mean_waiting_time(0),
    expanded_speech_samples(0),
    expanded_noise_samples(0),
    timestamps_since_last_report(0),
    min_sequence_number(0xFFFF),
    max_sequence_number(0),
    audio_level(0),
    downlink_process_time_ms(0),
    frozen_count_80_ms(0),
    frozen_time_80_ms(0),
    frozen_count_200_ms(0),
    frozen_time_200_ms(0),
    delay_estimate_ms(0),
    mos_value(0),
    total_active_time(0),
    publish_duration(0),
    e2e_delay_ms(0){ }
};
 
class IRemoteAudioTrack : public IAudioTrack {
 public:
  virtual bool getStatistics(RemoteAudioTrackStats& stats) = 0;
 
  virtual REMOTE_AUDIO_STATE getState() = 0;
 
 
  virtual int enableSoundPositionIndication(bool enabled) = 0;
  
  virtual int setRemoteVoicePosition(float pan, float gain) = 0;
 
  virtual int enableSpatialAudio(bool enabled) = 0;
 
  virtual int setRemoteUserSpatialAudioParams(const agora::SpatialAudioParams& params) = 0;
};
 
}  // namespace rtc
}  // namespace agora