admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
webrtc_m130/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
Per 83d0910694 Move Ownership of RtpModules to VideoSendStream from VieChannel and remove use of vie_channel and vie_receiver from video_send_stream. 
The purpose of this refactoring is a first step of separating the encoder parts from the RTP transport.

BUG=webrtc:5687
R=mflodman@webrtc.org, pbos@webrtc.org, stefan@webrtc.org

Review URL: https://codereview.webrtc.org/1864313003 .

Cr-Commit-Position: refs/heads/master@{#12377}
2016-04-15 12:59:21 +00:00

269 lines
10 KiB
C++
Raw Blame History

/*
* 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.
*/
#ifndef WEBRTC_MODULES_RTP_RTCP_MOCKS_MOCK_RTP_RTCP_H_
#define WEBRTC_MODULES_RTP_RTCP_MOCKS_MOCK_RTP_RTCP_H_
#include <set>
#include <utility>
#include <vector>
#include "testing/gmock/include/gmock/gmock.h"
#include "webrtc/modules/include/module.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
namespace webrtc {
class MockRtpData : public RtpData {
public:
MOCK_METHOD3(OnReceivedPayloadData,
int32_t(const uint8_t* payloadData,
const size_t payloadSize,
const WebRtcRTPHeader* rtpHeader));
MOCK_METHOD2(OnRecoveredPacket,
bool(const uint8_t* packet, size_t packet_length));
};
class MockRtpRtcp : public RtpRtcp {
public:
MOCK_METHOD1(RegisterDefaultModule,
int32_t(RtpRtcp* module));
MOCK_METHOD0(DeRegisterDefaultModule,
int32_t());
MOCK_METHOD0(DefaultModuleRegistered,
bool());
MOCK_METHOD0(NumberChildModules,
uint32_t());
MOCK_METHOD1(RegisterSyncModule,
int32_t(RtpRtcp* module));
MOCK_METHOD0(DeRegisterSyncModule,
int32_t());
MOCK_METHOD2(IncomingRtcpPacket,
int32_t(const uint8_t* incomingPacket, size_t packetLength));
MOCK_METHOD1(SetRemoteSSRC, void(const uint32_t ssrc));
MOCK_METHOD4(IncomingAudioNTP,
int32_t(const uint32_t audioReceivedNTPsecs,
const uint32_t audioReceivedNTPfrac,
const uint32_t audioRTCPArrivalTimeSecs,
const uint32_t audioRTCPArrivalTimeFrac));
MOCK_METHOD0(InitSender,
int32_t());
MOCK_METHOD1(RegisterSendTransport,
int32_t(Transport* outgoingTransport));
MOCK_METHOD1(SetMaxTransferUnit,
int32_t(const uint16_t size));
MOCK_METHOD3(SetTransportOverhead,
int32_t(const bool TCP, const bool IPV6,
const uint8_t authenticationOverhead));
MOCK_CONST_METHOD0(MaxPayloadLength,
uint16_t());
MOCK_CONST_METHOD0(MaxDataPayloadLength,
uint16_t());
MOCK_METHOD1(RegisterSendPayload,
int32_t(const CodecInst& voiceCodec));
MOCK_METHOD1(RegisterSendPayload,
int32_t(const VideoCodec& videoCodec));
MOCK_METHOD2(RegisterVideoSendPayload,
void(int payload_type, const char* payload_name));
MOCK_METHOD1(DeRegisterSendPayload,
int32_t(const int8_t payloadType));
MOCK_METHOD2(RegisterSendRtpHeaderExtension,
int32_t(const RTPExtensionType type, const uint8_t id));
MOCK_METHOD1(DeregisterSendRtpHeaderExtension,
int32_t(const RTPExtensionType type));
MOCK_CONST_METHOD0(StartTimestamp,
uint32_t());
MOCK_METHOD1(SetStartTimestamp, void(const uint32_t timestamp));
MOCK_CONST_METHOD0(SequenceNumber, uint16_t());
MOCK_METHOD1(SetSequenceNumber, void(const uint16_t seq));
MOCK_METHOD1(SetRtpState, void(const RtpState& rtp_state));
MOCK_METHOD1(SetRtxState, void(const RtpState& rtp_state));
MOCK_CONST_METHOD0(GetRtpState, RtpState());
MOCK_CONST_METHOD0(GetRtxState, RtpState());
MOCK_CONST_METHOD0(SSRC,
uint32_t());
MOCK_METHOD1(SetSSRC,
void(const uint32_t ssrc));
MOCK_CONST_METHOD1(CSRCs,
int32_t(uint32_t arrOfCSRC[kRtpCsrcSize]));
MOCK_METHOD1(SetCsrcs, void(const std::vector<uint32_t>& csrcs));
MOCK_METHOD1(SetCSRCStatus,
int32_t(const bool include));
MOCK_METHOD1(SetRtxSendStatus, void(int modes));
MOCK_CONST_METHOD0(RtxSendStatus, int());
MOCK_METHOD1(SetRtxSsrc,
void(uint32_t));
MOCK_METHOD2(SetRtxSendPayloadType, void(int, int));
MOCK_CONST_METHOD0(RtxSendPayloadType, std::pair<int, int>());
MOCK_METHOD1(SetSendingStatus,
int32_t(const bool sending));
MOCK_CONST_METHOD0(Sending,
bool());
MOCK_METHOD1(SetSendingMediaStatus, void(const bool sending));
MOCK_CONST_METHOD0(SendingMedia,
bool());
MOCK_CONST_METHOD4(BitrateSent,
void(uint32_t* totalRate,
uint32_t* videoRate,
uint32_t* fecRate,
uint32_t* nackRate));
MOCK_METHOD1(RegisterVideoBitrateObserver, void(BitrateStatisticsObserver*));
MOCK_CONST_METHOD0(GetVideoBitrateObserver, BitrateStatisticsObserver*(void));
MOCK_CONST_METHOD1(EstimatedReceiveBandwidth,
int(uint32_t* available_bandwidth));
MOCK_METHOD8(SendOutgoingData,
int32_t(const FrameType frameType,
const int8_t payloadType,
const uint32_t timeStamp,
int64_t capture_time_ms,
const uint8_t* payloadData,
const size_t payloadSize,
const RTPFragmentationHeader* fragmentation,
const RTPVideoHeader* rtpVideoHdr));
MOCK_METHOD4(TimeToSendPacket,
bool(uint32_t ssrc, uint16_t sequence_number, int64_t capture_time_ms,
bool retransmission));
MOCK_METHOD1(TimeToSendPadding,
size_t(size_t bytes));
MOCK_METHOD2(RegisterRtcpObservers,
void(RtcpIntraFrameObserver* intraFrameCallback,
RtcpBandwidthObserver* bandwidthCallback));
MOCK_CONST_METHOD0(RTCP, RtcpMode());
MOCK_METHOD1(SetRTCPStatus, void(const RtcpMode method));
MOCK_METHOD1(SetCNAME,
int32_t(const char cName[RTCP_CNAME_SIZE]));
MOCK_CONST_METHOD2(RemoteCNAME,
int32_t(const uint32_t remoteSSRC,
char cName[RTCP_CNAME_SIZE]));
MOCK_CONST_METHOD5(RemoteNTP,
int32_t(uint32_t *ReceivedNTPsecs,
uint32_t *ReceivedNTPfrac,
uint32_t *RTCPArrivalTimeSecs,
uint32_t *RTCPArrivalTimeFrac,
uint32_t *rtcp_timestamp));
MOCK_METHOD2(AddMixedCNAME,
int32_t(const uint32_t SSRC,
const char cName[RTCP_CNAME_SIZE]));
MOCK_METHOD1(RemoveMixedCNAME,
int32_t(const uint32_t SSRC));
MOCK_CONST_METHOD5(RTT,
int32_t(const uint32_t remoteSSRC,
int64_t* RTT,
int64_t* avgRTT,
int64_t* minRTT,
int64_t* maxRTT));
MOCK_METHOD1(SendRTCP, int32_t(RTCPPacketType packetType));
MOCK_METHOD1(SendCompoundRTCP,
int32_t(const std::set<RTCPPacketType>& packetTypes));
MOCK_METHOD1(SendRTCPReferencePictureSelection,
int32_t(const uint64_t pictureID));
MOCK_METHOD1(SendRTCPSliceLossIndication,
int32_t(const uint8_t pictureID));
MOCK_CONST_METHOD2(DataCountersRTP,
int32_t(size_t *bytesSent, uint32_t *packetsSent));
MOCK_CONST_METHOD2(GetSendStreamDataCounters,
void(StreamDataCounters*, StreamDataCounters*));
MOCK_CONST_METHOD3(GetRtpPacketLossStats,
void(bool, uint32_t, struct RtpPacketLossStats*));
MOCK_METHOD1(RemoteRTCPStat,
int32_t(RTCPSenderInfo* senderInfo));
MOCK_CONST_METHOD1(RemoteRTCPStat,
int32_t(std::vector<RTCPReportBlock>* receiveBlocks));
MOCK_METHOD4(SetRTCPApplicationSpecificData,
int32_t(const uint8_t subType,
const uint32_t name,
const uint8_t* data,
const uint16_t length));
MOCK_METHOD1(SetRTCPVoIPMetrics,
int32_t(const RTCPVoIPMetric* VoIPMetric));
MOCK_METHOD1(SetRtcpXrRrtrStatus,
void(bool enable));
MOCK_CONST_METHOD0(RtcpXrRrtrStatus,
bool());
MOCK_CONST_METHOD0(REMB,
bool());
MOCK_METHOD1(SetREMBStatus, void(const bool enable));
MOCK_METHOD2(SetREMBData,
void(const uint32_t bitrate,
const std::vector<uint32_t>& ssrcs));
MOCK_CONST_METHOD0(TMMBR,
bool());
MOCK_METHOD1(SetTMMBRStatus, void(const bool enable));
MOCK_METHOD1(OnBandwidthEstimateUpdate,
void(uint16_t bandWidthKbit));
MOCK_CONST_METHOD0(NACK,
NACKMethod());
MOCK_METHOD2(SetNACKStatus,
int32_t(const NACKMethod method, int oldestSequenceNumberToNack));
MOCK_CONST_METHOD0(SelectiveRetransmissions,
int());
MOCK_METHOD1(SetSelectiveRetransmissions,
int(uint8_t settings));
MOCK_METHOD2(SendNACK,
int32_t(const uint16_t* nackList, const uint16_t size));
MOCK_METHOD1(SendNack, void(const std::vector<uint16_t>& sequence_numbers));
MOCK_METHOD2(SetStorePacketsStatus,
void(const bool enable, const uint16_t numberToStore));
MOCK_CONST_METHOD0(StorePackets, bool());
MOCK_METHOD1(RegisterRtcpStatisticsCallback, void(RtcpStatisticsCallback*));
MOCK_METHOD0(GetRtcpStatisticsCallback, RtcpStatisticsCallback*());
MOCK_METHOD1(SendFeedbackPacket, bool(const rtcp::TransportFeedback& packet));
MOCK_METHOD1(SetAudioPacketSize,
int32_t(const uint16_t packetSizeSamples));
MOCK_METHOD3(SendTelephoneEventOutband,
int32_t(const uint8_t key, const uint16_t time_ms, const uint8_t level));
MOCK_METHOD1(SetSendREDPayloadType,
int32_t(const int8_t payloadType));
MOCK_CONST_METHOD1(SendREDPayloadType, int32_t(int8_t* payloadType));
MOCK_METHOD2(SetRTPAudioLevelIndicationStatus,
int32_t(const bool enable, const uint8_t ID));
MOCK_METHOD1(SetAudioLevel,
int32_t(const uint8_t level_dBov));
MOCK_METHOD1(SetTargetSendBitrate,
void(uint32_t bitrate_bps));
MOCK_METHOD3(SetGenericFECStatus,
void(const bool enable,
const uint8_t payload_type_red,
const uint8_t payload_type_fec));
MOCK_METHOD3(GenericFECStatus,
void(bool* enable,
uint8_t* payloadTypeRED,
uint8_t* payloadTypeFEC));
MOCK_METHOD2(SetFecParameters,
int32_t(const FecProtectionParams* delta_params,
const FecProtectionParams* key_params));
MOCK_METHOD1(SetKeyFrameRequestMethod,
int32_t(const KeyFrameRequestMethod method));
MOCK_METHOD0(RequestKeyFrame,
int32_t());
MOCK_METHOD0(TimeUntilNextProcess,
int64_t());
MOCK_METHOD0(Process,
void());
MOCK_METHOD1(RegisterSendFrameCountObserver,
void(FrameCountObserver*));
MOCK_CONST_METHOD0(GetSendFrameCountObserver,
FrameCountObserver*(void));
MOCK_METHOD1(RegisterSendChannelRtpStatisticsCallback,
void(StreamDataCountersCallback*));
MOCK_CONST_METHOD0(GetSendChannelRtpStatisticsCallback,
StreamDataCountersCallback*(void));
// Members.
unsigned int remote_ssrc_;
};
} // namespace webrtc
#endif // WEBRTC_MODULES_RTP_RTCP_MOCKS_MOCK_RTP_RTCP_H_
Reference in New Issue View Git Blame Copy Permalink