| /* |
| * Copyright (c) 2012 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_VIE_CHANNEL_H_ |
| #define WEBRTC_VIDEO_ENGINE_VIE_CHANNEL_H_ |
| |
| #include <list> |
| |
| #include "modules/rtp_rtcp/interface/rtp_rtcp_defines.h" |
| #include "modules/udp_transport/interface/udp_transport.h" |
| #include "modules/video_coding/main/interface/video_coding_defines.h" |
| #include "system_wrappers/interface/scoped_ptr.h" |
| #include "system_wrappers/interface/tick_util.h" |
| #include "typedefs.h" |
| #include "video_engine/include/vie_network.h" |
| #include "video_engine/include/vie_rtp_rtcp.h" |
| #include "video_engine/vie_defines.h" |
| #include "video_engine/vie_file_recorder.h" |
| #include "video_engine/vie_frame_provider_base.h" |
| |
| namespace webrtc { |
| |
| class CriticalSectionWrapper; |
| class Encryption; |
| class ProcessThread; |
| class RtpRtcp; |
| class ThreadWrapper; |
| class VideoCodingModule; |
| class VideoDecoder; |
| class VideoRenderCallback; |
| class ViEDecoderObserver; |
| class ViEEffectFilter; |
| class ViENetworkObserver; |
| class ViEReceiver; |
| class ViERTCPObserver; |
| class ViERTPObserver; |
| class ViESender; |
| class ViESyncModule; |
| class VoEVideoSync; |
| |
| class ViEChannel |
| : public VCMFrameTypeCallback, |
| public VCMReceiveCallback, |
| public VCMReceiveStatisticsCallback, |
| public VCMPacketRequestCallback, |
| public VCMFrameStorageCallback, |
| public RtcpFeedback, |
| public RtpFeedback, |
| public ViEFrameProviderBase { |
| public: |
| ViEChannel(WebRtc_Word32 channel_id, |
| WebRtc_Word32 engine_id, |
| WebRtc_UWord32 number_of_cores, |
| ProcessThread& module_process_thread); |
| ~ViEChannel(); |
| |
| WebRtc_Word32 Init(); |
| |
| // Sets the encoder to use for the channel. |new_stream| indicates the encoder |
| // type has changed and we should start a new RTP stream. |
| WebRtc_Word32 SetSendCodec(const VideoCodec& video_codec, |
| bool new_stream = true); |
| WebRtc_Word32 SetReceiveCodec(const VideoCodec& video_codec); |
| WebRtc_Word32 GetReceiveCodec(VideoCodec& video_codec); |
| WebRtc_Word32 RegisterCodecObserver(ViEDecoderObserver* observer); |
| // Registers an external decoder. |decoder_render| is set to true if the |
| // decoder will do the rendering. If |decoder_render| is set,|render_delay| |
| // indicates the time needed to decode and render a frame. |
| WebRtc_Word32 RegisterExternalDecoder(const WebRtc_UWord8 pl_type, |
| VideoDecoder* decoder, |
| bool decoder_render, |
| WebRtc_Word32 render_delay); |
| WebRtc_Word32 DeRegisterExternalDecoder(const WebRtc_UWord8 pl_type); |
| WebRtc_Word32 ReceiveCodecStatistics(WebRtc_UWord32& num_key_frames, |
| WebRtc_UWord32& num_delta_frames); |
| WebRtc_UWord32 DiscardedPackets() const; |
| |
| // Only affects calls to SetReceiveCodec done after this call. |
| WebRtc_Word32 WaitForKeyFrame(bool wait); |
| |
| // If enabled, a key frame request will be sent as soon as there are lost |
| // packets. If |only_key_frames| are set, requests are only sent for loss in |
| // key frames. |
| WebRtc_Word32 SetSignalPacketLossStatus(bool enable, bool only_key_frames); |
| |
| WebRtc_Word32 SetRTCPMode(const RTCPMethod rtcp_mode); |
| WebRtc_Word32 GetRTCPMode(RTCPMethod& rtcp_mode); |
| WebRtc_Word32 SetNACKStatus(const bool enable); |
| WebRtc_Word32 SetFECStatus(const bool enable, |
| const unsigned char payload_typeRED, |
| const unsigned char payload_typeFEC); |
| WebRtc_Word32 SetHybridNACKFECStatus(const bool enable, |
| const unsigned char payload_typeRED, |
| const unsigned char payload_typeFEC); |
| WebRtc_Word32 SetKeyFrameRequestMethod(const KeyFrameRequestMethod method); |
| bool EnableRemb(bool enable); |
| WebRtc_Word32 EnableTMMBR(const bool enable); |
| WebRtc_Word32 EnableKeyFrameRequestCallback(const bool enable); |
| |
| // Sets SSRC for outgoing stream. |
| WebRtc_Word32 SetSSRC(const WebRtc_UWord32 SSRC, |
| const StreamType usage, |
| const unsigned char simulcast_idx); |
| |
| // Gets SSRC for outgoing stream. |
| WebRtc_Word32 GetLocalSSRC(WebRtc_UWord32& SSRC); |
| |
| // Gets SSRC for the incoming stream. |
| WebRtc_Word32 GetRemoteSSRC(WebRtc_UWord32& SSRC); |
| |
| // Gets the CSRC for the incoming stream. |
| WebRtc_Word32 GetRemoteCSRC(unsigned int CSRCs[kRtpCsrcSize]); |
| |
| // Sets the starting sequence number, must be called before StartSend. |
| WebRtc_Word32 SetStartSequenceNumber(WebRtc_UWord16 sequence_number); |
| |
| // Sets the CName for the outgoing stream on the channel. |
| WebRtc_Word32 SetRTCPCName(const WebRtc_Word8 rtcp_cname[]); |
| |
| // Gets the CName for the outgoing stream on the channel. |
| WebRtc_Word32 GetRTCPCName(WebRtc_Word8 rtcp_cname[]); |
| |
| // Gets the CName of the incoming stream. |
| WebRtc_Word32 GetRemoteRTCPCName(WebRtc_Word8 rtcp_cname[]); |
| WebRtc_Word32 RegisterRtpObserver(ViERTPObserver* observer); |
| WebRtc_Word32 RegisterRtcpObserver(ViERTCPObserver* observer); |
| WebRtc_Word32 SendApplicationDefinedRTCPPacket( |
| const WebRtc_UWord8 sub_type, |
| WebRtc_UWord32 name, |
| const WebRtc_UWord8* data, |
| WebRtc_UWord16 data_length_in_bytes); |
| |
| // Returns statistics reported by the remote client in an RTCP packet. |
| WebRtc_Word32 GetSendRtcpStatistics(WebRtc_UWord16& fraction_lost, |
| WebRtc_UWord32& cumulative_lost, |
| WebRtc_UWord32& extended_max, |
| WebRtc_UWord32& jitter_samples, |
| WebRtc_Word32& rtt_ms); |
| |
| // Returns our localy created statistics of the received RTP stream. |
| WebRtc_Word32 GetReceivedRtcpStatistics(WebRtc_UWord16& fraction_lost, |
| WebRtc_UWord32& cumulative_lost, |
| WebRtc_UWord32& extended_max, |
| WebRtc_UWord32& jitter_samples, |
| WebRtc_Word32& rtt_ms); |
| |
| // Gets sent/received packets statistics. |
| WebRtc_Word32 GetRtpStatistics(WebRtc_UWord32& bytes_sent, |
| WebRtc_UWord32& packets_sent, |
| WebRtc_UWord32& bytes_received, |
| WebRtc_UWord32& packets_received) const; |
| void GetBandwidthUsage(WebRtc_UWord32& total_bitrate_sent, |
| WebRtc_UWord32& video_bitrate_sent, |
| WebRtc_UWord32& fec_bitrate_sent, |
| WebRtc_UWord32& nackBitrateSent) const; |
| int GetEstimatedReceiveBandwidth(WebRtc_UWord32* estimated_bandwidth) const; |
| WebRtc_Word32 SetKeepAliveStatus(const bool enable, |
| const WebRtc_Word8 unknown_payload_type, |
| const WebRtc_UWord16 delta_transmit_timeMS); |
| WebRtc_Word32 GetKeepAliveStatus(bool& enable, |
| WebRtc_Word8& unknown_payload_type, |
| WebRtc_UWord16& delta_transmit_timeMS); |
| WebRtc_Word32 StartRTPDump(const char file_nameUTF8[1024], |
| RTPDirections direction); |
| WebRtc_Word32 StopRTPDump(RTPDirections direction); |
| |
| // Implements RtcpFeedback. |
| virtual void OnLipSyncUpdate(const WebRtc_Word32 id, |
| const WebRtc_Word32 audio_video_offset); |
| virtual void OnApplicationDataReceived(const WebRtc_Word32 id, |
| const WebRtc_UWord8 sub_type, |
| 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 payload_type, |
| const WebRtc_Word8 payload_name[RTP_PAYLOAD_NAME_SIZE], |
| const int 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 packet_type); |
| 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); |
| |
| WebRtc_Word32 SetLocalReceiver(const WebRtc_UWord16 rtp_port, |
| const WebRtc_UWord16 rtcp_port, |
| const WebRtc_Word8* ip_address); |
| WebRtc_Word32 GetLocalReceiver(WebRtc_UWord16& rtp_port, |
| WebRtc_UWord16& rtcp_port, |
| WebRtc_Word8* ip_address) const; |
| WebRtc_Word32 SetSendDestination(const WebRtc_Word8* ip_address, |
| const WebRtc_UWord16 rtp_port, |
| const WebRtc_UWord16 rtcp_port, |
| const WebRtc_UWord16 source_rtp_port, |
| const WebRtc_UWord16 source_rtcp_port); |
| WebRtc_Word32 GetSendDestination(WebRtc_Word8* ip_address, |
| WebRtc_UWord16& rtp_port, |
| WebRtc_UWord16& rtcp_port, |
| WebRtc_UWord16& source_rtp_port, |
| WebRtc_UWord16& source_rtcp_port) const; |
| WebRtc_Word32 GetSourceInfo(WebRtc_UWord16& rtp_port, |
| WebRtc_UWord16& rtcp_port, |
| WebRtc_Word8* ip_address, |
| WebRtc_UWord32 ip_address_length); |
| |
| WebRtc_Word32 SetRemoteSSRCType(const StreamType usage, |
| const uint32_t SSRC) const; |
| |
| WebRtc_Word32 StartSend(); |
| WebRtc_Word32 StopSend(); |
| bool Sending(); |
| WebRtc_Word32 StartReceive(); |
| WebRtc_Word32 StopReceive(); |
| bool Receiving(); |
| |
| WebRtc_Word32 RegisterSendTransport(Transport& transport); |
| WebRtc_Word32 DeregisterSendTransport(); |
| |
| // Incoming packet from external transport. |
| WebRtc_Word32 ReceivedRTPPacket(const void* rtp_packet, |
| const WebRtc_Word32 rtp_packet_length); |
| |
| // Incoming packet from external transport. |
| WebRtc_Word32 ReceivedRTCPPacket(const void* rtcp_packet, |
| const WebRtc_Word32 rtcp_packet_length); |
| |
| WebRtc_Word32 EnableIPv6(); |
| bool IsIPv6Enabled(); |
| WebRtc_Word32 SetSourceFilter(const WebRtc_UWord16 rtp_port, |
| const WebRtc_UWord16 rtcp_port, |
| const WebRtc_Word8* ip_address); |
| WebRtc_Word32 GetSourceFilter(WebRtc_UWord16& rtp_port, |
| WebRtc_UWord16& rtcp_port, |
| WebRtc_Word8* ip_address) const; |
| |
| WebRtc_Word32 SetToS(const WebRtc_Word32 DSCP, const bool use_set_sockOpt); |
| WebRtc_Word32 GetToS(WebRtc_Word32& DSCP, bool& use_set_sockOpt) const; |
| WebRtc_Word32 SetSendGQoS(const bool enable, |
| const WebRtc_Word32 service_type, |
| const WebRtc_UWord32 max_bitrate, |
| const WebRtc_Word32 overrideDSCP); |
| WebRtc_Word32 GetSendGQoS(bool& enabled, WebRtc_Word32& service_type, |
| WebRtc_Word32& overrideDSCP) const; |
| |
| // Sets the maximum transfer unit size for the network link, i.e. including |
| // IP, UDP and RTP headers. |
| WebRtc_Word32 SetMTU(WebRtc_UWord16 mtu); |
| |
| // Returns maximum allowed payload size, i.e. the maximum allowed size of |
| // encoded data in each packet. |
| WebRtc_UWord16 MaxDataPayloadLength() const; |
| WebRtc_Word32 SetMaxPacketBurstSize(WebRtc_UWord16 max_number_of_packets); |
| WebRtc_Word32 SetPacketBurstSpreadState(bool enable, |
| const WebRtc_UWord16 frame_periodMS); |
| |
| WebRtc_Word32 SetPacketTimeoutNotification(bool enable, |
| WebRtc_UWord32 timeout_seconds); |
| WebRtc_Word32 RegisterNetworkObserver(ViENetworkObserver* observer); |
| bool NetworkObserverRegistered(); |
| WebRtc_Word32 SetPeriodicDeadOrAliveStatus( |
| const bool enable, const WebRtc_UWord32 sample_time_seconds); |
| |
| WebRtc_Word32 SendUDPPacket(const WebRtc_Word8* data, |
| const WebRtc_UWord32 length, |
| WebRtc_Word32& transmitted_bytes, |
| bool use_rtcp_socket); |
| |
| WebRtc_Word32 EnableColorEnhancement(bool enable); |
| |
| // Register send RTP RTCP module, which will deliver encoded frames to the |
| // to the channel RTP module. |
| WebRtc_Word32 RegisterSendRtpRtcpModule(RtpRtcp& send_rtp_rtcp_module); |
| |
| // Deregisters the send RTP RTCP module, which will stop the encoder input to |
| // the channel. |
| WebRtc_Word32 DeregisterSendRtpRtcpModule(); |
| |
| // Gets the modules used by the channel. |
| RtpRtcp* rtp_rtcp(); |
| |
| // Implements VCMReceiveCallback. |
| virtual WebRtc_Word32 FrameToRender(VideoFrame& video_frame); |
| |
| // Implements VCMReceiveCallback. |
| virtual WebRtc_Word32 ReceivedDecodedReferenceFrame( |
| const WebRtc_UWord64 picture_id); |
| |
| // Implements VCM. |
| virtual WebRtc_Word32 StoreReceivedFrame( |
| const EncodedVideoData& frame_to_store); |
| |
| // Implements VideoReceiveStatisticsCallback. |
| virtual WebRtc_Word32 ReceiveStatistics(const WebRtc_UWord32 bit_rate, |
| const WebRtc_UWord32 frame_rate); |
| |
| // Implements VideoFrameTypeCallback. |
| virtual WebRtc_Word32 RequestKeyFrame(); |
| |
| // Implements VideoFrameTypeCallback. |
| virtual WebRtc_Word32 SliceLossIndicationRequest( |
| const WebRtc_UWord64 picture_id); |
| |
| // Implements VideoPacketRequestCallback. |
| virtual WebRtc_Word32 ResendPackets(const WebRtc_UWord16* sequence_numbers, |
| WebRtc_UWord16 length); |
| |
| WebRtc_Word32 RegisterExternalEncryption(Encryption* encryption); |
| WebRtc_Word32 DeRegisterExternalEncryption(); |
| |
| WebRtc_Word32 SetVoiceChannel(WebRtc_Word32 ve_channel_id, |
| VoEVideoSync* ve_sync_interface); |
| WebRtc_Word32 VoiceChannel(); |
| |
| // Implements ViEFrameProviderBase. |
| virtual int FrameCallbackChanged() {return -1;} |
| |
| WebRtc_Word32 RegisterEffectFilter(ViEEffectFilter* effect_filter); |
| |
| ViEFileRecorder& GetIncomingFileRecorder(); |
| void ReleaseIncomingFileRecorder(); |
| |
| protected: |
| static bool ChannelDecodeThreadFunction(void* obj); |
| bool ChannelDecodeProcess(); |
| |
| private: |
| // Assumed to be protected. |
| WebRtc_Word32 StartDecodeThread(); |
| WebRtc_Word32 StopDecodeThread(); |
| |
| WebRtc_Word32 ProcessNACKRequest(const bool enable); |
| WebRtc_Word32 ProcessFECRequest(const bool enable, |
| const unsigned char payload_typeRED, |
| const unsigned char payload_typeFEC); |
| |
| WebRtc_Word32 channel_id_; |
| WebRtc_Word32 engine_id_; |
| WebRtc_UWord32 number_of_cores_; |
| WebRtc_UWord8 num_socket_threads_; |
| |
| // Used for all registered callbacks except rendering. |
| scoped_ptr<CriticalSectionWrapper> callback_cs_; |
| |
| // Owned modules/classes. |
| RtpRtcp& rtp_rtcp_; |
| RtpRtcp* default_rtp_rtcp_; |
| std::list<RtpRtcp*> simulcast_rtp_rtcp_; |
| #ifndef WEBRTC_EXTERNAL_TRANSPORT |
| UdpTransport& socket_transport_; |
| #endif |
| VideoCodingModule& vcm_; |
| ViEReceiver& vie_receiver_; |
| ViESender& vie_sender_; |
| ViESyncModule& vie_sync_; |
| |
| // Not owned. |
| ProcessThread& module_process_thread_; |
| ViEDecoderObserver* codec_observer_; |
| bool do_key_frame_callbackRequest_; |
| ViERTPObserver* rtp_observer_; |
| ViERTCPObserver* rtcp_observer_; |
| ViENetworkObserver* networkObserver_; |
| bool rtp_packet_timeout_; |
| bool using_packet_spread_; |
| |
| Transport* external_transport_; |
| |
| bool decoder_reset_; |
| bool wait_for_key_frame_; |
| ThreadWrapper* decode_thread_; |
| |
| Encryption* external_encryption_; |
| |
| ViEEffectFilter* effect_filter_; |
| bool color_enhancement_; |
| |
| // Time when RTT time was last reported to VCM JB. |
| TickTime vcm_rttreported_; |
| |
| ViEFileRecorder file_recorder_; |
| }; |
| |
| } // namespace webrtc |
| |
| #endif // WEBRTC_VIDEO_ENGINE_VIE_CHANNEL_H_ |