475 lines
16 KiB
C++
475 lines
16 KiB
C++
/*
|
|
* Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
/*
|
|
* vie_channel.h
|
|
*/
|
|
|
|
#ifndef WEBRTC_VIDEO_ENGINE_MAIN_SOURCE_VIE_CHANNEL_H_
|
|
#define WEBRTC_VIDEO_ENGINE_MAIN_SOURCE_VIE_CHANNEL_H_
|
|
|
|
// Defines
|
|
#include "vie_defines.h"
|
|
|
|
#include "typedefs.h"
|
|
#include "vie_network.h"
|
|
#include "rtp_rtcp_defines.h"
|
|
#include "udp_transport.h"
|
|
#include "video_coding_defines.h"
|
|
#ifdef WEBRTC_SRTP
|
|
#include "SrtpModule.h"
|
|
#endif
|
|
#include "tick_util.h"
|
|
#include "vie_frame_provider_base.h"
|
|
#include "vie_file_recorder.h"
|
|
|
|
// Forward declarations
|
|
|
|
class SrtpModule;
|
|
class VideoRenderCallback;
|
|
|
|
namespace webrtc
|
|
{
|
|
class CriticalSectionWrapper;
|
|
class Encryption;
|
|
class ProcessThread;
|
|
class RtpRtcp;
|
|
class ThreadWrapper;
|
|
class VideoCodingModule;
|
|
class VideoDecoder;
|
|
class ViEDecoderObserver;
|
|
class ViEEffectFilter;
|
|
class ViENetworkObserver;
|
|
class ViEReceiver;
|
|
class ViERTCPObserver;
|
|
class ViERTPObserver;
|
|
class ViESender;
|
|
class ViESyncModule;
|
|
class VoEVideoSync;
|
|
|
|
class ViEChannel:
|
|
public VCMFrameTypeCallback, // VCM Module
|
|
public VCMReceiveCallback, // VCM Module
|
|
public VCMReceiveStatisticsCallback, // VCM Module
|
|
public VCMPacketRequestCallback, // VCM Module
|
|
public VCMFrameStorageCallback, // VCM Module
|
|
public RtcpFeedback, // RTP/RTCP Module
|
|
public RtpFeedback, // RTP/RTCP Module
|
|
public ViEFrameProviderBase
|
|
{
|
|
public:
|
|
ViEChannel(WebRtc_Word32 channelId, WebRtc_Word32 engineId,
|
|
WebRtc_UWord32 numberOfCores,
|
|
ProcessThread& moduleProcessThread);
|
|
~ViEChannel();
|
|
|
|
WebRtc_Word32 Init();
|
|
|
|
//-----------------------------------------------------------------
|
|
// Codecs
|
|
//-----------------------------------------------------------------
|
|
|
|
WebRtc_Word32 SetSendCodec(const VideoCodec& videoCodec,
|
|
bool newStream = true);
|
|
|
|
WebRtc_Word32 SetReceiveCodec(const VideoCodec& videoCodec);
|
|
|
|
WebRtc_Word32 GetReceiveCodec(VideoCodec& videoCodec);
|
|
|
|
WebRtc_Word32 RegisterCodecObserver(ViEDecoderObserver* observer);
|
|
|
|
WebRtc_Word32 RegisterExternalDecoder(const WebRtc_UWord8 plType,
|
|
VideoDecoder* decoder,
|
|
bool decoderRender,
|
|
WebRtc_Word32 renderDelay);
|
|
|
|
WebRtc_Word32 DeRegisterExternalDecoder(const WebRtc_UWord8 plType);
|
|
|
|
WebRtc_Word32 ReceiveCodecStatistics(WebRtc_UWord32& numKeyFrames,
|
|
WebRtc_UWord32& numDeltaFrames);
|
|
|
|
WebRtc_Word32 WaitForKeyFrame(bool wait);
|
|
|
|
WebRtc_Word32 SetSignalPacketLossStatus(bool enable, bool onlyKeyFrames);
|
|
|
|
//-----------------------------------------------------------------
|
|
// RTP/RTCP
|
|
//-----------------------------------------------------------------
|
|
WebRtc_Word32 SetRTCPMode(const RTCPMethod rtcpMode);
|
|
|
|
WebRtc_Word32 GetRTCPMode(RTCPMethod& rtcpMode);
|
|
|
|
WebRtc_Word32 SetNACKStatus(const bool enable);
|
|
|
|
WebRtc_Word32 SetFECStatus(const bool enable,
|
|
const unsigned char payloadTypeRED,
|
|
const unsigned char payloadTypeFEC);
|
|
|
|
WebRtc_Word32
|
|
SetKeyFrameRequestMethod(const KeyFrameRequestMethod method);
|
|
|
|
WebRtc_Word32 EnableTMMBR(const bool enable);
|
|
|
|
WebRtc_Word32 EnableKeyFrameRequestCallback(const bool enable);
|
|
|
|
WebRtc_Word32 SetSSRC(const WebRtc_UWord32 SSRC);
|
|
|
|
WebRtc_Word32 GetLocalSSRC(WebRtc_UWord32& SSRC);
|
|
|
|
WebRtc_Word32 GetRemoteSSRC(WebRtc_UWord32& SSRC);
|
|
|
|
WebRtc_Word32 GetRemoteCSRC(unsigned int CSRCs[kRtpCsrcSize]);
|
|
|
|
WebRtc_Word32 SetStartSequenceNumber(WebRtc_UWord16 sequenceNumber);
|
|
|
|
WebRtc_Word32 SetRTCPCName(const WebRtc_Word8 rtcpCName[]);
|
|
|
|
WebRtc_Word32 GetRTCPCName(WebRtc_Word8 rtcpCName[]);
|
|
|
|
WebRtc_Word32 GetRemoteRTCPCName(WebRtc_Word8 rtcpCName[]);
|
|
|
|
WebRtc_Word32 RegisterRtpObserver(ViERTPObserver* observer);
|
|
|
|
WebRtc_Word32 RegisterRtcpObserver(ViERTCPObserver* observer);
|
|
|
|
WebRtc_Word32 SendApplicationDefinedRTCPPacket(
|
|
const WebRtc_UWord8 subType,
|
|
WebRtc_UWord32 name,
|
|
const WebRtc_UWord8* data,
|
|
WebRtc_UWord16 dataLengthInBytes);
|
|
|
|
WebRtc_Word32 GetSendRtcpStatistics(WebRtc_UWord16& fractionLost,
|
|
WebRtc_UWord32& cumulativeLost,
|
|
WebRtc_UWord32& extendedMax,
|
|
WebRtc_UWord32& jitterSamples,
|
|
WebRtc_Word32& rttMs);
|
|
|
|
WebRtc_Word32 GetReceivedRtcpStatistics(WebRtc_UWord16& fractionLost,
|
|
WebRtc_UWord32& cumulativeLost,
|
|
WebRtc_UWord32& extendedMax,
|
|
WebRtc_UWord32& jitterSamples,
|
|
WebRtc_Word32& rttMs);
|
|
|
|
WebRtc_Word32 GetRtpStatistics(WebRtc_UWord32& bytesSent,
|
|
WebRtc_UWord32& packetsSent,
|
|
WebRtc_UWord32& bytesReceived,
|
|
WebRtc_UWord32& packetsReceived) const;
|
|
|
|
WebRtc_Word32 SetKeepAliveStatus(const bool enable,
|
|
const WebRtc_Word8 unknownPayloadType,
|
|
const WebRtc_UWord16 deltaTransmitTimeMS);
|
|
|
|
WebRtc_Word32 GetKeepAliveStatus(bool& enable,
|
|
WebRtc_Word8& unknownPayloadType,
|
|
WebRtc_UWord16& deltaTransmitTimeMS);
|
|
|
|
WebRtc_Word32 StartRTPDump(const char fileNameUTF8[1024],
|
|
RTPDirections direction);
|
|
|
|
WebRtc_Word32 StopRTPDump(RTPDirections direction);
|
|
|
|
// Implements RtcpFeedback
|
|
virtual void OnLipSyncUpdate(const WebRtc_Word32 id,
|
|
const WebRtc_Word32 audioVideoOffset);
|
|
|
|
virtual void OnApplicationDataReceived(const WebRtc_Word32 id,
|
|
const WebRtc_UWord8 subType,
|
|
const WebRtc_UWord32 name,
|
|
const WebRtc_UWord16 length,
|
|
const WebRtc_UWord8* data);
|
|
|
|
// Implements RtpFeedback
|
|
virtual WebRtc_Word32 OnInitializeDecoder(
|
|
const WebRtc_Word32 id,
|
|
const WebRtc_Word8 payloadType,
|
|
const WebRtc_Word8 payloadName[RTP_PAYLOAD_NAME_SIZE],
|
|
const WebRtc_UWord32 frequency,
|
|
const WebRtc_UWord8 channels,
|
|
const WebRtc_UWord32 rate);
|
|
|
|
virtual void OnPacketTimeout(const WebRtc_Word32 id);
|
|
|
|
virtual void OnReceivedPacket(const WebRtc_Word32 id,
|
|
const RtpRtcpPacketType packetType);
|
|
|
|
virtual void OnPeriodicDeadOrAlive(const WebRtc_Word32 id,
|
|
const RTPAliveType alive);
|
|
|
|
virtual void OnIncomingSSRCChanged(const WebRtc_Word32 id,
|
|
const WebRtc_UWord32 SSRC);
|
|
|
|
virtual void OnIncomingCSRCChanged(const WebRtc_Word32 id,
|
|
const WebRtc_UWord32 CSRC,
|
|
const bool added);
|
|
|
|
//-----------------------------------------------------------------
|
|
// Network
|
|
//-----------------------------------------------------------------
|
|
|
|
// Soure and destination
|
|
WebRtc_Word32 SetLocalReceiver(const WebRtc_UWord16 rtpPort,
|
|
const WebRtc_UWord16 rtcpPort,
|
|
const WebRtc_Word8* ipAddress);
|
|
|
|
WebRtc_Word32 GetLocalReceiver(WebRtc_UWord16& rtpPort,
|
|
WebRtc_UWord16& rtcpPort,
|
|
WebRtc_Word8* ipAddress) const;
|
|
|
|
WebRtc_Word32 SetSendDestination(const WebRtc_Word8* ipAddress,
|
|
const WebRtc_UWord16 rtpPort,
|
|
const WebRtc_UWord16 rtcpPort,
|
|
const WebRtc_UWord16 sourceRtpPort,
|
|
const WebRtc_UWord16 sourceRtcpPort);
|
|
|
|
WebRtc_Word32 GetSendDestination(WebRtc_Word8* ipAddress,
|
|
WebRtc_UWord16& rtpPort,
|
|
WebRtc_UWord16& rtcpPort,
|
|
WebRtc_UWord16& sourceRtpPort,
|
|
WebRtc_UWord16& sourceRtcpPort) const;
|
|
|
|
WebRtc_Word32 GetSourceInfo(WebRtc_UWord16& rtpPort,
|
|
WebRtc_UWord16& rtcpPort,
|
|
WebRtc_Word8* ipAddress,
|
|
WebRtc_UWord32 ipAddressLength);
|
|
|
|
// Start/Stop Send/Receive
|
|
WebRtc_Word32 StartSend();
|
|
WebRtc_Word32 StopSend();
|
|
bool Sending();
|
|
WebRtc_Word32 StartReceive();
|
|
WebRtc_Word32 StopReceive();
|
|
bool Receiving();
|
|
|
|
// External transport
|
|
WebRtc_Word32 RegisterSendTransport(Transport& transport);
|
|
|
|
WebRtc_Word32 DeregisterSendTransport();
|
|
|
|
WebRtc_Word32 ReceivedRTPPacket(const void* rtpPacket,
|
|
const WebRtc_Word32 rtpPacketLength);
|
|
|
|
WebRtc_Word32 ReceivedRTCPPacket(const void* rtcpPacket,
|
|
const WebRtc_Word32 rtcpPacketLength);
|
|
|
|
// IPv6
|
|
WebRtc_Word32 EnableIPv6();
|
|
|
|
bool IsIPv6Enabled();
|
|
|
|
// Source IP address and port filter
|
|
WebRtc_Word32 SetSourceFilter(const WebRtc_UWord16 rtpPort,
|
|
const WebRtc_UWord16 rtcpPort,
|
|
const WebRtc_Word8* ipAddress);
|
|
|
|
WebRtc_Word32 GetSourceFilter(WebRtc_UWord16& rtpPort,
|
|
WebRtc_UWord16& rtcpPort,
|
|
WebRtc_Word8* ipAddress) const;
|
|
|
|
// ToS
|
|
WebRtc_Word32 SetToS(const WebRtc_Word32 DSCP, const bool useSetSockOpt);
|
|
|
|
WebRtc_Word32 GetToS(WebRtc_Word32& DSCP, bool& useSetSockOpt) const;
|
|
|
|
// GQoS
|
|
WebRtc_Word32 SetSendGQoS(const bool enable,
|
|
const WebRtc_Word32 serviceType,
|
|
const WebRtc_UWord32 maxBitrate,
|
|
const WebRtc_Word32 overrideDSCP);
|
|
|
|
WebRtc_Word32 GetSendGQoS(bool& enabled, WebRtc_Word32& serviceType,
|
|
WebRtc_Word32& overrideDSCP) const;
|
|
|
|
// Network settings
|
|
WebRtc_Word32 SetMTU(WebRtc_UWord16 mtu);
|
|
|
|
WebRtc_UWord16 MaxDataPayloadLength() const;
|
|
|
|
WebRtc_Word32 SetMaxPacketBurstSize(WebRtc_UWord16 maxNumberOfPackets);
|
|
|
|
WebRtc_Word32 SetPacketBurstSpreadState(bool enable,
|
|
const WebRtc_UWord16 framePeriodMS);
|
|
|
|
// Packet timout notification
|
|
WebRtc_Word32 SetPacketTimeoutNotification(bool enable,
|
|
WebRtc_UWord32 timeoutSeconds);
|
|
|
|
// Periodic dead-or-alive reports
|
|
WebRtc_Word32 RegisterNetworkObserver(ViENetworkObserver* observer);
|
|
bool NetworkObserverRegistered();
|
|
|
|
WebRtc_Word32
|
|
SetPeriodicDeadOrAliveStatus(const bool enable,
|
|
const WebRtc_UWord32 sampleTimeSeconds);
|
|
|
|
WebRtc_Word32 SendUDPPacket(const WebRtc_Word8* data,
|
|
const WebRtc_UWord32 length,
|
|
WebRtc_Word32& transmittedBytes,
|
|
bool useRtcpSocket);
|
|
|
|
//-----------------------------------------------------------------
|
|
// Image processing
|
|
//-----------------------------------------------------------------
|
|
WebRtc_Word32 EnableColorEnhancement(bool enable);
|
|
|
|
//-----------------------------------------------------------------
|
|
// Register sender
|
|
//-----------------------------------------------------------------
|
|
WebRtc_Word32
|
|
RegisterSendRtpRtcpModule(RtpRtcp& sendRtpRtcpModule);
|
|
|
|
WebRtc_Word32 DeregisterSendRtpRtcpModule();
|
|
|
|
// Implements VCM::VCMReceiveCallback, getting decoded frames from
|
|
// VCM.
|
|
virtual WebRtc_Word32 FrameToRender(VideoFrame& videoFrame);
|
|
|
|
// Implements VCM::VCMReceiveCallback, getting info about decoded
|
|
// frames from VCM.
|
|
virtual WebRtc_Word32 ReceivedDecodedReferenceFrame(
|
|
const WebRtc_UWord64 pictureId);
|
|
|
|
//Implements VCM::VideoFrameStorageCallback
|
|
virtual WebRtc_Word32 StoreReceivedFrame(
|
|
const EncodedVideoData& frameToStore);
|
|
|
|
// Implements VCM::VideoReceiveStatisticsCallback
|
|
virtual WebRtc_Word32 ReceiveStatistics(const WebRtc_UWord32 bitRate,
|
|
const WebRtc_UWord32 frameRate);
|
|
|
|
// Implements VCM::VideoFrameTypeCallback
|
|
virtual WebRtc_Word32 FrameTypeRequest(const FrameType frameType);
|
|
|
|
// Implements VCM::VideoFrameTypeCallback
|
|
virtual WebRtc_Word32 SliceLossIndicationRequest(
|
|
const WebRtc_UWord64 pictureId);
|
|
|
|
// Implements VCM::VideoPacketRequestCallback
|
|
virtual WebRtc_Word32 ResendPackets(const WebRtc_UWord16* sequenceNumbers,
|
|
WebRtc_UWord16 length);
|
|
|
|
#ifdef WEBRTC_SRTP
|
|
//SRTP
|
|
WebRtc_Word32 EnableSRTPSend(
|
|
const SrtpModule::CipherTypes cipherType,
|
|
const unsigned int cipherKeyLength,
|
|
const SrtpModule::AuthenticationTypes authType,
|
|
const unsigned int authKeyLength,
|
|
const unsigned int authTagLength,
|
|
const SrtpModule::SecurityLevels level,
|
|
const WebRtc_UWord8* key,
|
|
const bool useForRTCP);
|
|
|
|
WebRtc_Word32 DisableSRTPSend();
|
|
|
|
WebRtc_Word32 EnableSRTPReceive(
|
|
const SrtpModule::CipherTypes cipherType,
|
|
const unsigned int cipherKeyLength,
|
|
const SrtpModule::AuthenticationTypes authType,
|
|
const unsigned int authKeyLength,
|
|
const unsigned int authTagLength,
|
|
const SrtpModule::SecurityLevels level,
|
|
const WebRtc_UWord8* key,
|
|
const bool useForRTCP);
|
|
WebRtc_Word32 DisableSRTPReceive();
|
|
#endif
|
|
|
|
WebRtc_Word32 RegisterExternalEncryption(Encryption* encryption);
|
|
WebRtc_Word32 DeRegisterExternalEncryption();
|
|
|
|
//Voice Engine
|
|
WebRtc_Word32 SetVoiceChannel(WebRtc_Word32 veChannelId,
|
|
VoEVideoSync* veSyncInterface);
|
|
WebRtc_Word32 VoiceChannel();
|
|
|
|
//ViEFrameProviderBase
|
|
virtual int FrameCallbackChanged(){return -1;}
|
|
|
|
// Effect filter
|
|
WebRtc_Word32 RegisterEffectFilter(ViEEffectFilter* effectFilter);
|
|
|
|
WebRtc_Word32 SetInverseH263Logic(const bool enable);
|
|
|
|
// File recording
|
|
ViEFileRecorder& GetIncomingFileRecorder();
|
|
void ReleaseIncomingFileRecorder();
|
|
|
|
protected:
|
|
// Thread function according to ThreadWrapper
|
|
static bool ChannelDecodeThreadFunction(void* obj);
|
|
bool ChannelDecodeProcess();
|
|
|
|
private:
|
|
|
|
WebRtc_Word32 StartDecodeThread();
|
|
WebRtc_Word32 StopDecodeThread();
|
|
|
|
// General members
|
|
WebRtc_Word32 _channelId;
|
|
WebRtc_Word32 _engineId;
|
|
WebRtc_UWord32 _numberOfCores;
|
|
WebRtc_UWord8 _numSocketThreads;
|
|
|
|
// Critical sections
|
|
// Used for all registered callbacks except rendering.
|
|
CriticalSectionWrapper& _callbackCritsect;
|
|
// Use the same as above instead a seperate?
|
|
CriticalSectionWrapper& _dataCritsect;
|
|
|
|
// Owned modules/classes
|
|
RtpRtcp& _rtpRtcp;
|
|
#ifndef WEBRTC_EXTERNAL_TRANSPORT
|
|
UdpTransport& _socketTransport;
|
|
#endif
|
|
VideoCodingModule& _vcm;
|
|
ViEReceiver& _vieReceiver;
|
|
ViESender& _vieSender;
|
|
ViESyncModule& _vieSync;//Lip syncronization
|
|
|
|
//Uses
|
|
ProcessThread& _moduleProcessThread;
|
|
ViEDecoderObserver* _codecObserver;
|
|
bool _doKeyFrameCallbackRequest;
|
|
ViERTPObserver* _rtpObserver;
|
|
ViERTCPObserver* _rtcpObserver;
|
|
ViENetworkObserver* _networkObserver;
|
|
bool _rtpPacketTimeout;
|
|
bool _usingPacketSpread;
|
|
|
|
// Registered members
|
|
Transport* _ptrExternalTransport;
|
|
|
|
// Codec
|
|
bool _decoderReset;
|
|
bool _waitForKeyFrame;
|
|
|
|
// Decoder
|
|
ThreadWrapper* _ptrDecodeThread;
|
|
|
|
//SRTP - using seperate pointers for encryption and decryption to support
|
|
// simultaneous operations.
|
|
SrtpModule* _ptrSrtpModuleEncryption;
|
|
SrtpModule* _ptrSrtpModuleDecryption;
|
|
Encryption* _ptrExternalEncryption;
|
|
|
|
// Effect filter and color enhancement
|
|
ViEEffectFilter* _effectFilter;
|
|
bool _colorEnhancement;
|
|
|
|
// Time when RTT time was last reported to VCM JB.
|
|
TickTime _vcmRTTReported;
|
|
|
|
//Recording
|
|
ViEFileRecorder _fileRecorder;
|
|
};
|
|
|
|
} // namespace webrtc
|
|
|
|
#endif // WEBRTC_VIDEO_ENGINE_MAIN_SOURCE_VIE_CHANNEL_H_
|