RtpVideoSender.h

#pragma once
 
#include "mc/_HeaderOutputPredefine.h"
 
// auto generated inclusion list
#include "mc/external/webrtc/ArrayView.h"
#include "mc/external/webrtc/EncodedImageCallback.h"
#include "mc/external/webrtc/RtpSequenceNumberMap.h"
#include "mc/external/webrtc/RtpVideoSenderInterface.h"
#include "mc/external/webrtc/StreamFeedbackObserver.h"
#include "mc/external/webrtc/VCMProtectionCallback.h"
#include "mc/external/webrtc/scoped_refptr.h"
 
// auto generated forward declare list
// clang-format off
namespace webrtc { class DataRate; }
namespace webrtc { class DataSize; }
namespace webrtc { class EncodedImage; }
namespace webrtc { class Environment; }
namespace webrtc { class FecController; }
namespace webrtc { class FrameEncryptorInterface; }
namespace webrtc { class FrameTransformerInterface; }
namespace webrtc { class Frequency; }
namespace webrtc { class RateLimiter; }
namespace webrtc { class RtpRtcpInterface; }
namespace webrtc { class RtpTransportControllerSendInterface; }
namespace webrtc { class TaskQueueBase; }
namespace webrtc { class Transport; }
namespace webrtc { class VideoBitrateAllocation; }
namespace webrtc { struct BitrateAllocationUpdate; }
namespace webrtc { struct CodecSpecificInfo; }
namespace webrtc { struct CryptoOptions; }
namespace webrtc { struct FecProtectionParams; }
namespace webrtc { struct RtpConfig; }
namespace webrtc { struct RtpPayloadState; }
namespace webrtc { struct RtpSenderObservers; }
namespace webrtc { struct RtpState; }
namespace webrtc { struct VideoLayersAllocation; }
// clang-format on
 
namespace webrtc {
 
class RtpVideoSender : public ::webrtc::RtpVideoSenderInterface,
                       public ::webrtc::VCMProtectionCallback,
                       public ::webrtc::StreamFeedbackObserver {
public:
    // member variables
    // NOLINTBEGIN
    ::ll::UntypedStorage<8, 40>  mUnk456187;
    ::ll::UntypedStorage<1, 1>   mUnkd26cd1;
    ::ll::UntypedStorage<1, 1>   mUnkcae22e;
    ::ll::UntypedStorage<1, 1>   mUnk1089b5;
    ::ll::UntypedStorage<8, 8>   mUnk7f791d;
    ::ll::UntypedStorage<8, 40>  mUnk42e501;
    ::ll::UntypedStorage<1, 1>   mUnk922b4d;
    ::ll::UntypedStorage<8, 8>   mUnkbe54e8;
    ::ll::UntypedStorage<1, 1>   mUnk80a0fd;
    ::ll::UntypedStorage<8, 24>  mUnkbeb5ce;
    ::ll::UntypedStorage<8, 320> mUnk74c091;
    ::ll::UntypedStorage<8, 8>   mUnkff5ef2;
    ::ll::UntypedStorage<8, 24>  mUnk4509d4;
    ::ll::UntypedStorage<8, 8>   mUnk808d3a;
    ::ll::UntypedStorage<1, 1>   mUnk2f9f84;
    ::ll::UntypedStorage<8, 24>  mUnk78885d;
    ::ll::UntypedStorage<8, 8>   mUnk762d4c;
    ::ll::UntypedStorage<4, 4>   mUnk34e69a;
    ::ll::UntypedStorage<4, 4>   mUnk411a20;
    ::ll::UntypedStorage<8, 32>  mUnk1c75bd;
    ::ll::UntypedStorage<8, 24>  mUnk86c908;
    ::ll::UntypedStorage<8, 8>   mUnkc028fd;
    ::ll::UntypedStorage<8, 16>  mUnkaddf58;
    ::ll::UntypedStorage<8, 8>   mUnkaa2b41;
    // NOLINTEND
 
public:
    // prevent constructor by default
    RtpVideoSender& operator=(RtpVideoSender const&);
    RtpVideoSender(RtpVideoSender const&);
    RtpVideoSender();
 
public:
    // virtual functions
    // NOLINTBEGIN
    virtual ~RtpVideoSender() /*override*/ = default;
 
    virtual void SetSending(bool enabled) /*override*/;
 
    virtual bool IsActive() /*override*/;
 
    virtual void OnNetworkAvailability(bool network_available) /*override*/;
 
    virtual ::std::map<uint, ::webrtc::RtpState> GetRtpStates() const /*override*/;
 
    virtual ::std::map<uint, ::webrtc::RtpPayloadState> GetRtpPayloadStates() const /*override*/;
 
    virtual void DeliverRtcp(::webrtc::ArrayView<uchar const> packet) /*override*/;
 
    virtual int ProtectionRequest(
        ::webrtc::FecProtectionParams const* delta_params,
        ::webrtc::FecProtectionParams const* key_params,
        uint*                                sent_video_rate_bps,
        uint*                                sent_nack_rate_bps,
        uint*                                sent_fec_rate_bps
    ) /*override*/;
 
    virtual void SetRetransmissionMode(int retransmission_mode) /*override*/;
 
    virtual void SetFecAllowed(bool fec_allowed) /*override*/;
 
    virtual ::webrtc::EncodedImageCallback::Result OnEncodedImage(
        ::webrtc::EncodedImage const&      encoded_image,
        ::webrtc::CodecSpecificInfo const* codec_specific_info
    ) /*override*/;
 
    virtual void OnBitrateAllocationUpdated(::webrtc::VideoBitrateAllocation const& bitrate) /*override*/;
 
    virtual void OnVideoLayersAllocationUpdated(::webrtc::VideoLayersAllocation const& allocation) /*override*/;
 
    virtual void OnTransportOverheadChanged(uint64 transport_overhead_bytes_per_packet) /*override*/;
 
    virtual void OnBitrateUpdated(::webrtc::BitrateAllocationUpdate update, int framerate) /*override*/;
 
    virtual uint GetPayloadBitrateBps() const /*override*/;
 
    virtual uint GetProtectionBitrateBps() const /*override*/;
 
    virtual void SetEncodingData(uint64 width, uint64 height, uint64 num_temporal_layers) /*override*/;
 
    virtual void SetCsrcs(::webrtc::ArrayView<uint const> csrcs) /*override*/;
 
    virtual ::std::vector<::webrtc::RtpSequenceNumberMap::Info>
    GetSentRtpPacketInfos(uint ssrc, ::webrtc::ArrayView<ushort const> sequence_numbers) const /*override*/;
 
    virtual void OnPacketFeedbackVector(
        ::std::vector<::webrtc::StreamFeedbackObserver::StreamPacketInfo> packet_feedback_vector
    ) /*override*/;
    // NOLINTEND
 
public:
    // member functions
    // NOLINTBEGIN
    MCNAPI ::webrtc::DataRate CalculateOverheadRate(
        ::webrtc::DataRate  data_rate,
        ::webrtc::DataSize  packet_size,
        ::webrtc::DataSize  overhead_per_packet,
        ::webrtc::Frequency framerate
    ) const;
 
    MCNAPI void ConfigureSsrcs(::std::map<uint, ::webrtc::RtpState> const& suspended_ssrcs);
 
    MCNAPI RtpVideoSender(
        ::webrtc::Environment const&                                 env,
        ::webrtc::TaskQueueBase*                                     transport_queue,
        ::std::map<uint, ::webrtc::RtpState> const&                  suspended_ssrcs,
        ::std::map<uint, ::webrtc::RtpPayloadState> const&           states,
        ::webrtc::RtpConfig const&                                   rtp_config,
        int                                                          rtcp_report_interval_ms,
        ::webrtc::Transport*                                         send_transport,
        ::webrtc::RtpSenderObservers const&                          observers,
        ::webrtc::RtpTransportControllerSendInterface*               transport,
        ::webrtc::RateLimiter*                                       retransmission_limiter,
        ::std::unique_ptr<::webrtc::FecController>                   fec_controller,
        ::webrtc::FrameEncryptorInterface*                           frame_encryptor,
        ::webrtc::CryptoOptions const&                               crypto_options,
        ::webrtc::scoped_refptr<::webrtc::FrameTransformerInterface> frame_transformer
    );
 
    MCNAPI void SetActiveModulesLocked(bool sending);
 
    MCNAPI void SetModuleIsActive(bool sending, ::webrtc::RtpRtcpInterface& rtp_module);
    // NOLINTEND
 
public:
    // constructor thunks
    // NOLINTBEGIN
    MCNAPI void* $ctor(
        ::webrtc::Environment const&                                 env,
        ::webrtc::TaskQueueBase*                                     transport_queue,
        ::std::map<uint, ::webrtc::RtpState> const&                  suspended_ssrcs,
        ::std::map<uint, ::webrtc::RtpPayloadState> const&           states,
        ::webrtc::RtpConfig const&                                   rtp_config,
        int                                                          rtcp_report_interval_ms,
        ::webrtc::Transport*                                         send_transport,
        ::webrtc::RtpSenderObservers const&                          observers,
        ::webrtc::RtpTransportControllerSendInterface*               transport,
        ::webrtc::RateLimiter*                                       retransmission_limiter,
        ::std::unique_ptr<::webrtc::FecController>                   fec_controller,
        ::webrtc::FrameEncryptorInterface*                           frame_encryptor,
        ::webrtc::CryptoOptions const&                               crypto_options,
        ::webrtc::scoped_refptr<::webrtc::FrameTransformerInterface> frame_transformer
    );
    // NOLINTEND
 
public:
    // virtual function thunks
    // NOLINTBEGIN
    MCNAPI void $SetSending(bool enabled);
 
    MCNAPI bool $IsActive();
 
    MCNAPI void $OnNetworkAvailability(bool network_available);
 
    MCNAPI ::std::map<uint, ::webrtc::RtpState> $GetRtpStates() const;
 
    MCNAPI ::std::map<uint, ::webrtc::RtpPayloadState> $GetRtpPayloadStates() const;
 
    MCNAPI void $DeliverRtcp(::webrtc::ArrayView<uchar const> packet);
 
    MCNAPI int $ProtectionRequest(
        ::webrtc::FecProtectionParams const* delta_params,
        ::webrtc::FecProtectionParams const* key_params,
        uint*                                sent_video_rate_bps,
        uint*                                sent_nack_rate_bps,
        uint*                                sent_fec_rate_bps
    );
 
    MCNAPI void $SetRetransmissionMode(int retransmission_mode);
 
    MCNAPI void $SetFecAllowed(bool fec_allowed);
 
    MCNAPI ::webrtc::EncodedImageCallback::Result $OnEncodedImage(
        ::webrtc::EncodedImage const&      encoded_image,
        ::webrtc::CodecSpecificInfo const* codec_specific_info
    );
 
    MCNAPI void $OnBitrateAllocationUpdated(::webrtc::VideoBitrateAllocation const& bitrate);
 
    MCNAPI void $OnVideoLayersAllocationUpdated(::webrtc::VideoLayersAllocation const& allocation);
 
    MCNAPI void $OnTransportOverheadChanged(uint64 transport_overhead_bytes_per_packet);
 
    MCNAPI void $OnBitrateUpdated(::webrtc::BitrateAllocationUpdate update, int framerate);
 
    MCNAPI uint $GetPayloadBitrateBps() const;
 
    MCNAPI uint $GetProtectionBitrateBps() const;
 
    MCNAPI void $SetEncodingData(uint64 width, uint64 height, uint64 num_temporal_layers);
 
    MCNAPI void $SetCsrcs(::webrtc::ArrayView<uint const> csrcs);
 
    MCNAPI ::std::vector<::webrtc::RtpSequenceNumberMap::Info>
    $GetSentRtpPacketInfos(uint ssrc, ::webrtc::ArrayView<ushort const> sequence_numbers) const;
 
    MCNAPI void
    $OnPacketFeedbackVector(::std::vector<::webrtc::StreamFeedbackObserver::StreamPacketInfo> packet_feedback_vector);
 
 
    // NOLINTEND
 
public:
    // vftables
    // NOLINTBEGIN
    MCNAPI static void** $vftableForStreamFeedbackObserver();
 
    MCNAPI static void** $vftableForEncodedImageCallback();
 
    MCNAPI static void** $vftableForVCMProtectionCallback();
 
    MCNAPI static void** $vftableForFecControllerOverride();
    // NOLINTEND
};
 
} // namespace webrtc