PanoRtcDevice.h

浏览该文件的文档.

 
#pragma once
#include "PanoRtcDefs.h"
 
PANORTC_NS_BEGIN
 
struct AudioFormat {
    AudioType   type;
    uint32_t    channels;
    uint32_t    sampleRate;
    uint32_t    bytesPerSample;
};
 
struct VideoFormat {
    VideoType     type;
    uint32_t      width;
    uint32_t      height;
    uint32_t      count;
    uint32_t      offset[kMaxVideoPlaneCount];
    uint32_t      stride[kMaxVideoPlaneCount];
    VideoRotation rotation;
    bool          mirror;
};
 
struct MediaFormat {
    MediaType mediaType;
    union {
        AudioFormat audioFmt;
        VideoFormat videoFmt;
    };
    uint64_t  timestamp;
};
 
class RtcRenderSink {
public:
    virtual QResult onRenderData(void *buffer, int length, MediaFormat &fmt) = 0;
    virtual QResult onRenderData(void *native, MediaFormat &fmt) = 0;
    virtual ~RtcRenderSink() {}
};
 
class RtcExternalVideoCapturer {
public:
    virtual QResult putData(void *buffer, int length, const MediaFormat &format) = 0;
    virtual QResult getDeviceID(char deviceId[panortc::kMaxDeviceIDLength]) = 0;
 
    virtual void destroy() = 0;
 
protected:
    virtual ~RtcExternalVideoCapturer() {}
};
 
class RtcExternalScreenSource {
public:
    virtual QResult setEnableStatus(bool enabled) = 0;
 
    virtual QResult putData(void *buffer, int length, const MediaFormat &format) = 0;
 
protected:
    virtual ~RtcExternalScreenSource() {}
};
 
class RtcExternalVideoProcessor {
public:
    virtual QResult onVideoFrame(void *buffer, int length, VideoFormat &fmt) = 0;
    virtual QResult onVideoFrame(void *native, VideoFormat &fmt) = 0;
    virtual ~RtcExternalVideoProcessor() {}
};
using RtcExternalVideoFilter = RtcExternalVideoProcessor;
 
class RtcExternalAudioRecorder {
public:
    virtual QResult setEnableStatus(bool enable, int32_t sampleRate, int32_t channels) = 0;
 
    virtual QResult pushData(void *buffer, int length, const MediaFormat &format) = 0;
 
protected:
    virtual ~RtcExternalAudioRecorder() {}
};
 
class RtcExternalAudioPlayer {
public:
    virtual QResult setEnableStatus(bool enable, int32_t sampleRate, int32_t channels) = 0;
 
    virtual QResult pullData(void *buffer, int length, const MediaFormat &format) = 0;
 
protected:
    virtual ~RtcExternalAudioPlayer() {}
};
 
class RtcExternalAudioProcessor {
public:
    virtual QResult onAudioFrame(void *buffer, int length, int maxBufferByteLens, AudioFormat &fmt) = 0;
 
    virtual ~RtcExternalAudioProcessor() {}
};
using RtcExternalAudioProcess = RtcExternalAudioProcessor;
 
class CameraController
{
public:
    virtual bool isCameraFocusSupported() = 0;
    virtual QResult setCameraFocusPointInPreview(float x, float y) = 0;
    virtual bool isCameraExposureSupported() = 0;
    virtual QResult setCameraExposurePointInPreview(float x, float y) = 0;
 
protected:
    virtual ~CameraController() {}
};
 
enum class VideoScalingMode {
    Fit = 0,
    FullFill,
    CropFill,
};
 
struct VideoConfig
{
    VideoProfileType    profileType = VideoProfileType::Standard;
    bool                enableSourceMirror = false;
    VideoScalingMode    scalingMode = VideoScalingMode::Fit;
    bool                enableMirror = false;
};
 
struct VideoSourceConfig
{
    VideoProfileType    profileType = VideoProfileType::Standard;
    bool                sourceMirror = false;
};
 
struct VideoRenderConfig
{
    VideoScalingMode    scalingMode = VideoScalingMode::Fit;
    bool                enableMirror = false;
};
using RenderConfig = VideoRenderConfig;
 
struct ScreenConfig
{
    VideoProfileType    profileType{ VideoProfileType::HD1080P };
    int                 frameRate{ 5 };
};
 
enum class ScreenScalingRatio {
    Fit = 0,
    Original,
};
 
class AudioDeviceManager
{
public:
    using EnumDeviceCallback = bool(*) (void *context, const char deviceName[kMaxDeviceNameLength], const char deviceId[kMaxDeviceIDLength]);
 
    virtual void enumerateRecordDevices(EnumDeviceCallback cb, void *context) const = 0;
    virtual void enumeratePlayoutDevices(EnumDeviceCallback cb, void *context) const = 0;
 
    virtual QResult setRecordDevice(const char deviceId[kMaxDeviceIDLength]) = 0;
    virtual QResult setDefaultRecordDevice() = 0;
    virtual bool isDefaultRecordDevice() const = 0;
    virtual QResult getRecordDevice(char deviceId[kMaxDeviceIDLength]) const = 0;
 
    virtual QResult setPlayoutDevice(const char deviceId[kMaxDeviceIDLength]) = 0;
    virtual QResult setDefaultPlayoutDevice() = 0;
    virtual bool isDefaultPlayoutDevice() const = 0;
    virtual QResult getPlayoutDevice(char deviceId[kMaxDeviceIDLength]) const = 0;
 
    virtual QResult setRecordDeviceVolume(uint32_t volume) = 0;
    virtual QResult getRecordDeviceVolume(uint32_t *volume) const = 0;
 
    virtual QResult setPlayoutDeviceVolume(uint32_t volume) = 0;
    virtual QResult getPlayoutDeviceVolume(uint32_t *volume) const = 0;
 
    virtual QResult getPlayoutLevel(int16_t &level) const = 0;
 
    virtual QResult getRecordingLevel(int16_t &level) const = 0;
 
    virtual QResult setMicrophoneMuteStatus(bool muted) = 0;
    virtual QResult setLoudspeakerStatus(bool enable) = 0;
    virtual QResult getLoudspeakerStatus(bool *enabled) const = 0;
 
    virtual QResult startDeviceTest(
        const char recordDeviceId[panortc::kMaxDeviceIDLength],
        const char playoutDeviceId[panortc::kMaxDeviceIDLength]) = 0;
    virtual QResult stopDeviceTest() = 0;
 
    virtual QResult startPlayoutDeviceTest(
        const char playoutDeviceId[panortc::kMaxDeviceIDLength],
        const char* filename) = 0;
    virtual QResult stopPlayoutDeviceTest() = 0;
 
    virtual QResult startRecordDeviceTest(
        const char recordDeviceId[panortc::kMaxDeviceIDLength]) = 0;
    virtual QResult stopRecordDeviceTest() = 0;
 
    virtual QResult getTestPlayoutLevel(int16_t &level) = 0;
 
    virtual QResult getTestRecordingLevel(int16_t &level) = 0;
 
    virtual RtcExternalAudioRecorder* getExternalRecorder() = 0;
    virtual RtcExternalAudioPlayer* getExternalPlayer() = 0;
    virtual QResult startAudioRecording() = 0;
    virtual QResult stopAudioRecording() = 0;
    virtual QResult startAudioPlayback() = 0;
    virtual QResult stopAudioPlayback() = 0;
 
    virtual QResult setPlayoutDataMuteStatus(bool muted) = 0;
 
protected:
    virtual ~AudioDeviceManager() {}
};
 
 
class VideoDeviceManager
{
public:
    using EnumDeviceCallback = bool(*) (void* context, const char deviceName[kMaxDeviceNameLength], const char deviceId[kMaxDeviceIDLength]);
    virtual void enumerateCaptureDevices(EnumDeviceCallback cb, void *context) const = 0;
    virtual QResult setDevice(const char deviceId[kMaxDeviceIDLength]) = 0;
    virtual QResult getDevice(char deviceId[kMaxDeviceIDLength]) const = 0;
 
    virtual QResult startPreview(const char deviceId[kMaxDeviceIDLength],
        void *window,
        const VideoConfig &config) = 0;
    virtual QResult startPreview(const char deviceId[kMaxDeviceIDLength],
        RtcRenderSink *sink,
        VideoProfileType profileType) = 0;
 
    virtual QResult stopPreview(const char deviceId[kMaxDeviceIDLength]) = 0;
 
    virtual QResult switchDevice() = 0;
    virtual QResult getDevicePosition(VideoDevicePosition &position) const = 0;
    virtual VideoDevicePosition getDevicePosition(const char deviceId[kMaxDeviceIDLength]) const = 0;
 
    virtual RtcExternalVideoCapturer* createExternalCapturer() = 0;
 
    virtual QResult setDeviceBoundOption(const char deviceId[kMaxDeviceIDLength],
                                         OptionType option, void * param, uint32_t size) = 0;
 
    virtual QResult setDeviceBoundMediaProcessor(const char deviceId[kMaxDeviceIDLength],
                                                 MediaProcessorType type,
                                                 void * processor,
                                                 void * param = nullptr) = 0;
 
    virtual CameraController* getCameraController(const char deviceId[kMaxDeviceIDLength]) = 0;
 
 
protected:
    virtual ~VideoDeviceManager() {}
};
 
class ScreenSourceManager
{
public:
    using EnumSourceCallback = bool(*) (void* context, ScreenSourceID ssid, const char *name);
    virtual void enumerateDisplays(EnumSourceCallback cb, void *context) = 0;
    virtual void enumerateApplications(EnumSourceCallback cb, void *context) = 0;
    virtual void enumerateWindows(EnumSourceCallback cb, void *context) = 0;
 
    virtual QResult enableFilterSelfApp(bool enabled) = 0;
    virtual QResult enableFilterWindows(bool enabled) = 0;
    virtual QResult enableSingleWindowMode(bool enabled) = 0;
    virtual QResult setScreenOptimization(bool forMotion) = 0;
    virtual QResult setScreenSource(ScreenSourceType sourceType, ScreenSourceID sourceId) = 0;
 
    // use beginConfiguration and commitConfiguration to batch multiple configuration
    // operations on a running capture engine into an atomic update
    virtual QResult beginConfiguration(bool resetConfig) = 0;
    virtual QResult commitConfiguration() = 0;
 
    virtual QResult selectSharedDisplay(ScreenSourceID displayId) = 0;
    virtual QResult addSharedScreenSource(ScreenSourceType sourceType, ScreenSourceID sourceId) = 0;
    virtual QResult removeSharedScreenSource(ScreenSourceType sourceType, ScreenSourceID sourceId) = 0;
    virtual QResult addUnsharedScreenSource(ScreenSourceType sourceType, ScreenSourceID sourceId) = 0;
    virtual QResult removeUnsharedScreenSource(ScreenSourceType sourceType, ScreenSourceID sourceId) = 0;
    virtual QResult addTransparentWindow(ScreenSourceID sourceId) = 0;
    virtual QResult removeTransparentWindow(ScreenSourceID sourceId) = 0;
    virtual QResult addTranslucentWindow(ScreenSourceID sourceId) = 0;
    virtual QResult removeTranslucentWindow(ScreenSourceID sourceId) = 0;
 
    virtual RtcExternalScreenSource* getExternalSource() = 0;
 
protected:
    virtual ~ScreenSourceManager() {}
};
 
struct AudioMixingConfig {
    bool enablePublish = true;
    int  publishVolume = 100;
    bool enableLoopback = true;
    int  loopbackVolume = 100;
    int  cycle = 1;
    bool replaceMicrophone = false;
};
 
class AudioMixingManager
{
public:
    virtual QResult createAudioMixingTask(int64_t taskId, const char * filename) = 0;
 
    virtual QResult destroyAudioMixingTask(int64_t taskId) = 0;
 
    virtual QResult start(int64_t taskId, const AudioMixingConfig &config) = 0;
 
    virtual QResult update(int64_t taskId, const AudioMixingConfig &config) = 0;
 
    virtual QResult stop(int64_t taskId) = 0;
 
    virtual QResult resume(int64_t taskId) = 0;
 
    virtual QResult pause(int64_t taskId) = 0;
 
    virtual QResult getDuration(int64_t taskId, int64_t *durationMs) = 0;
 
    virtual QResult getCurrentTimestamp(int64_t taskId, int64_t *timestampMs) = 0;
 
    virtual QResult seek(int64_t taskId, int64_t timestampMs) = 0;
 
protected:
    virtual ~AudioMixingManager() {}
};
 
class NetworkManager
{
public:
    class Callback
    {
    public:
        virtual void onNetworkTestComplete(NetworkQuality quality) {};
 
        virtual ~Callback() = default;
    };
 
 
    virtual QResult startNetworkTest(const char *token, Callback *callback) = 0;
    virtual QResult stopNetworkTest() = 0;
 
protected:
    virtual ~NetworkManager() {}
};
 
PANORTC_NS_END