generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Made cpplint pass for vie_channel.* and vie_encoder.*. NOLINT is used for API changes, include guards and include files in WebRTC root.

Browse Source 
WebRTC types and webrtc:: will be removed in a follow up.

BUG=627
TEST=vie_auto_test + compiles

Review URL: https://webrtc-codereview.appspot.com/677005

git-svn-id: http://webrtc.googlecode.com/svn/trunk@2450 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
mflodman@webrtc.org 2012-06-27 09:49:37 +00:00
parent 3ddc974039
commit f5e99db10b
9 changed files with 217 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/video_engine/vie_capture_impl.cc
View File

@ -237,7 +237,7 @@ int ViECaptureImpl::ConnectCaptureDevice(const int capture_id,
} }
VideoCodec codec; VideoCodec codec;
bool use_hardware_encoder = false; bool use_hardware_encoder = false;
if (vie_encoder->GetEncoder(codec) == 0) { if (vie_encoder->GetEncoder(&codec) == 0) {
// Try to provide the encoder with pre-encoded frames if possible. // Try to provide the encoder with pre-encoded frames if possible.
if (vie_capture->PreEncodeToViEEncoder(codec, *vie_encoder, if (vie_capture->PreEncodeToViEEncoder(codec, *vie_encoder,
video_channel) == 0) { video_channel) == 0) {

201
src/video_engine/vie_channel.cc
View File

@ -356,11 +356,11 @@ WebRtc_Word32 ViEChannel::SetReceiveCodec(const VideoCodec& video_codec) {
return 0; return 0;
} }
WebRtc_Word32 ViEChannel::GetReceiveCodec(VideoCodec& video_codec) { WebRtc_Word32 ViEChannel::GetReceiveCodec(VideoCodec* video_codec) {
WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_),
"%s", __FUNCTION__); "%s", __FUNCTION__);
if (vcm_.ReceiveCodec(&video_codec) != 0) { if (vcm_.ReceiveCodec(video_codec) != 0) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_), WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_),
"%s: Could not get receive codec", __FUNCTION__); "%s: Could not get receive codec", __FUNCTION__);
return -1; return -1;
@ -429,7 +429,7 @@ WebRtc_Word32 ViEChannel::DeRegisterExternalDecoder(
} }
WebRtc_Word32 ViEChannel::ReceiveCodecStatistics( WebRtc_Word32 ViEChannel::ReceiveCodecStatistics(
WebRtc_UWord32& num_key_frames, WebRtc_UWord32& num_delta_frames) { WebRtc_UWord32* num_key_frames, WebRtc_UWord32* num_delta_frames) {
WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_),
"%s", __FUNCTION__); "%s", __FUNCTION__);
@ -439,8 +439,8 @@ WebRtc_Word32 ViEChannel::ReceiveCodecStatistics(
"%s: Could not get received frame information", __FUNCTION__); "%s: Could not get received frame information", __FUNCTION__);
return -1; return -1;
} }
num_key_frames = received_frames.numKeyFrames; *num_key_frames = received_frames.numKeyFrames;
num_delta_frames = received_frames.numDeltaFrames; *num_delta_frames = received_frames.numDeltaFrames;
return 0; return 0;
} }
@ -498,10 +498,10 @@ WebRtc_Word32 ViEChannel::SetRTCPMode(const RTCPMethod rtcp_mode) {
return rtp_rtcp_->SetRTCPStatus(rtcp_mode); return rtp_rtcp_->SetRTCPStatus(rtcp_mode);
} }
WebRtc_Word32 ViEChannel::GetRTCPMode(RTCPMethod& rtcp_mode) { WebRtc_Word32 ViEChannel::GetRTCPMode(RTCPMethod* rtcp_mode) {
WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_),
"%s", __FUNCTION__); "%s", __FUNCTION__);
rtcp_mode = rtp_rtcp_->RTCP(); *rtcp_mode = rtp_rtcp_->RTCP();
return 0; return 0;
} }
@ -711,29 +711,29 @@ WebRtc_Word32 ViEChannel::SetRemoteSSRCType(const StreamType usage,
return rtp_rtcp_->SetRTXReceiveStatus(true, SSRC); return rtp_rtcp_->SetRTXReceiveStatus(true, SSRC);
} }
WebRtc_Word32 ViEChannel::GetLocalSSRC(WebRtc_UWord32& SSRC) { WebRtc_Word32 ViEChannel::GetLocalSSRC(uint32_t* ssrc) {
WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_),
"%s", __FUNCTION__); "%s", __FUNCTION__);
SSRC = rtp_rtcp_->SSRC(); *ssrc = rtp_rtcp_->SSRC();
return 0; return 0;
} }
WebRtc_Word32 ViEChannel::GetRemoteSSRC(WebRtc_UWord32& SSRC) { WebRtc_Word32 ViEChannel::GetRemoteSSRC(uint32_t* ssrc) {
WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s", WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s",
__FUNCTION__); __FUNCTION__);
SSRC = rtp_rtcp_->RemoteSSRC(); *ssrc = rtp_rtcp_->RemoteSSRC();
return 0; return 0;
} }
WebRtc_Word32 ViEChannel::GetRemoteCSRC(unsigned int CSRCs[kRtpCsrcSize]) { WebRtc_Word32 ViEChannel::GetRemoteCSRC(uint32_t CSRCs[kRtpCsrcSize]) {
WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s", WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s",
__FUNCTION__); __FUNCTION__);
WebRtc_UWord32 arrayCSRC[kRtpCsrcSize]; uint32_t arrayCSRC[kRtpCsrcSize];
memset(arrayCSRC, 0, sizeof(arrayCSRC)); memset(arrayCSRC, 0, sizeof(arrayCSRC));
WebRtc_Word32 num_csrcs = rtp_rtcp_->RemoteCSRCs(arrayCSRC); int num_csrcs = rtp_rtcp_->RemoteCSRCs(arrayCSRC);
if (num_csrcs > 0) { if (num_csrcs > 0) {
memcpy(CSRCs, arrayCSRC, num_csrcs * sizeof(WebRtc_UWord32)); memcpy(CSRCs, arrayCSRC, num_csrcs * sizeof(WebRtc_UWord32));
for (int idx = 0; idx < num_csrcs; idx++) { for (int idx = 0; idx < num_csrcs; idx++) {
@ -871,11 +871,11 @@ WebRtc_Word32 ViEChannel::SendApplicationDefinedRTCPPacket(
return 0; return 0;
} }
WebRtc_Word32 ViEChannel::GetSendRtcpStatistics(WebRtc_UWord16& fraction_lost, WebRtc_Word32 ViEChannel::GetSendRtcpStatistics(uint16_t* fraction_lost,
WebRtc_UWord32& cumulative_lost, uint32_t* cumulative_lost,
WebRtc_UWord32& extended_max, uint32_t* extended_max,
WebRtc_UWord32& jitter_samples, uint32_t* jitter_samples,
WebRtc_Word32& rtt_ms) { int32_t* rtt_ms) {
WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s", WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s",
__FUNCTION__); __FUNCTION__);
@ -888,7 +888,7 @@ WebRtc_Word32 ViEChannel::GetSendRtcpStatistics(WebRtc_UWord16& fraction_lost,
// it++) { // it++) {
// RtpRtcp* rtp_rtcp = *it; // RtpRtcp* rtp_rtcp = *it;
// } // }
WebRtc_UWord32 remoteSSRC = rtp_rtcp_->RemoteSSRC(); uint32_t remote_ssrc = rtp_rtcp_->RemoteSSRC();
// Get all RTCP receiver report blocks that have been received on this // Get all RTCP receiver report blocks that have been received on this
// channel. If we receive RTP packets from a remote source we know the // channel. If we receive RTP packets from a remote source we know the
@ -903,7 +903,7 @@ WebRtc_Word32 ViEChannel::GetSendRtcpStatistics(WebRtc_UWord16& fraction_lost,
std::vector<RTCPReportBlock>::const_iterator statistics = std::vector<RTCPReportBlock>::const_iterator statistics =
remote_stats.begin(); remote_stats.begin();
for (; statistics != remote_stats.end(); ++statistics) { for (; statistics != remote_stats.end(); ++statistics) {
if (statistics->remoteSSRC == remoteSSRC) if (statistics->remoteSSRC == remote_ssrc)
break; break;
} }
@ -912,66 +912,64 @@ WebRtc_Word32 ViEChannel::GetSendRtcpStatistics(WebRtc_UWord16& fraction_lost,
// we have not received any RTP packets. // we have not received any RTP packets.
// Use the first received report block instead. // Use the first received report block instead.
statistics = remote_stats.begin(); statistics = remote_stats.begin();
remoteSSRC = statistics->remoteSSRC; remote_ssrc = statistics->remoteSSRC;
} }
fraction_lost = statistics->fractionLost; *fraction_lost = statistics->fractionLost;
cumulative_lost = statistics->cumulativeLost; *cumulative_lost = statistics->cumulativeLost;
extended_max = statistics->extendedHighSeqNum; *extended_max = statistics->extendedHighSeqNum;
jitter_samples = statistics->jitter; *jitter_samples = statistics->jitter;
WebRtc_UWord16 dummy; WebRtc_UWord16 dummy;
WebRtc_UWord16 rtt = 0; WebRtc_UWord16 rtt = 0;
if (rtp_rtcp_->RTT(remoteSSRC, &rtt, &dummy, &dummy, &dummy) != 0) { if (rtp_rtcp_->RTT(remote_ssrc, &rtt, &dummy, &dummy, &dummy) != 0) {
WEBRTC_TRACE(kTraceWarning, kTraceVideo, ViEId(engine_id_, channel_id_), WEBRTC_TRACE(kTraceWarning, kTraceVideo, ViEId(engine_id_, channel_id_),
"%s: Could not get RTT", __FUNCTION__); "%s: Could not get RTT", __FUNCTION__);
return -1; return -1;
} }
rtt_ms = rtt; *rtt_ms = rtt;
return 0; return 0;
} }
WebRtc_Word32 ViEChannel::GetReceivedRtcpStatistics( WebRtc_Word32 ViEChannel::GetReceivedRtcpStatistics(uint16_t* fraction_lost,
WebRtc_UWord16& fraction_lost, uint32_t* cumulative_lost,
WebRtc_UWord32& cumulative_lost, uint32_t* extended_max,
WebRtc_UWord32& extended_max, uint32_t* jitter_samples,
WebRtc_UWord32& jitter_samples, int32_t* rtt_ms) {
WebRtc_Word32& rtt_ms) {
WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_),
"%s", __FUNCTION__); "%s", __FUNCTION__);
WebRtc_UWord8 frac_lost = 0; WebRtc_UWord8 frac_lost = 0;
if (rtp_rtcp_->StatisticsRTP(&frac_lost, &cumulative_lost, &extended_max, if (rtp_rtcp_->StatisticsRTP(&frac_lost, cumulative_lost, extended_max,
&jitter_samples) != 0) { jitter_samples) != 0) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_), WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_),
"%s: Could not get received RTP statistics", __FUNCTION__); "%s: Could not get received RTP statistics", __FUNCTION__);
return -1; return -1;
} }
fraction_lost = frac_lost; *fraction_lost = frac_lost;
WebRtc_UWord32 remoteSSRC = rtp_rtcp_->RemoteSSRC(); uint32_t remote_ssrc = rtp_rtcp_->RemoteSSRC();
WebRtc_UWord16 dummy = 0; uint16_t dummy = 0;
WebRtc_UWord16 rtt = 0; uint16_t rtt = 0;
if (rtp_rtcp_->RTT(remoteSSRC, &rtt, &dummy, &dummy, &dummy) != 0) { if (rtp_rtcp_->RTT(remote_ssrc, &rtt, &dummy, &dummy, &dummy) != 0) {
WEBRTC_TRACE(kTraceStateInfo, kTraceVideo, ViEId(engine_id_, channel_id_), WEBRTC_TRACE(kTraceStateInfo, kTraceVideo, ViEId(engine_id_, channel_id_),
"%s: Could not get RTT", __FUNCTION__); "%s: Could not get RTT", __FUNCTION__);
} }
rtt_ms = rtt; *rtt_ms = rtt;
return 0; return 0;
} }
WebRtc_Word32 ViEChannel::GetRtpStatistics( WebRtc_Word32 ViEChannel::GetRtpStatistics(uint32_t* bytes_sent,
WebRtc_UWord32& bytes_sent, uint32_t* packets_sent,
WebRtc_UWord32& packets_sent, uint32_t* bytes_received,
WebRtc_UWord32& bytes_received, uint32_t* packets_received) const {
WebRtc_UWord32& packets_received) const {
WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s", WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s",
__FUNCTION__); __FUNCTION__);
if (rtp_rtcp_->DataCountersRTP(&bytes_sent, if (rtp_rtcp_->DataCountersRTP(bytes_sent,
&packets_sent, packets_sent,
&bytes_received, bytes_received,
&packets_received) != 0) { packets_received) != 0) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_), WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_),
"%s: Could not get counters", __FUNCTION__); "%s: Could not get counters", __FUNCTION__);
return -1; return -1;
@ -980,8 +978,8 @@ WebRtc_Word32 ViEChannel::GetRtpStatistics(
for (std::list<RtpRtcp*>::const_iterator it = simulcast_rtp_rtcp_.begin(); for (std::list<RtpRtcp*>::const_iterator it = simulcast_rtp_rtcp_.begin();
it != simulcast_rtp_rtcp_.end(); it != simulcast_rtp_rtcp_.end();
it++) { it++) {
WebRtc_UWord32 bytes_sent_temp = 0; uint32_t bytes_sent_temp = 0;
WebRtc_UWord32 packets_sent_temp = 0; uint32_t packets_sent_temp = 0;
RtpRtcp* rtp_rtcp = *it; RtpRtcp* rtp_rtcp = *it;
rtp_rtcp->DataCountersRTP(&bytes_sent_temp, &packets_sent_temp, NULL, NULL); rtp_rtcp->DataCountersRTP(&bytes_sent_temp, &packets_sent_temp, NULL, NULL);
bytes_sent += bytes_sent_temp; bytes_sent += bytes_sent_temp;
@ -990,34 +988,32 @@ WebRtc_Word32 ViEChannel::GetRtpStatistics(
return 0; return 0;
} }
void ViEChannel::GetBandwidthUsage(WebRtc_UWord32& total_bitrate_sent, void ViEChannel::GetBandwidthUsage(uint32_t* total_bitrate_sent,
WebRtc_UWord32& video_bitrate_sent, uint32_t* video_bitrate_sent,
WebRtc_UWord32& fec_bitrate_sent, uint32_t* fec_bitrate_sent,
WebRtc_UWord32& nackBitrateSent) const { uint32_t* nackBitrateSent) const {
WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s", WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s",
__FUNCTION__); __FUNCTION__);
rtp_rtcp_->BitrateSent(&total_bitrate_sent, rtp_rtcp_->BitrateSent(total_bitrate_sent, video_bitrate_sent,
&video_bitrate_sent, fec_bitrate_sent, nackBitrateSent);
&fec_bitrate_sent,
&nackBitrateSent);
CriticalSectionScoped cs(rtp_rtcp_cs_.get()); CriticalSectionScoped cs(rtp_rtcp_cs_.get());
for (std::list<RtpRtcp*>::const_iterator it = simulcast_rtp_rtcp_.begin(); for (std::list<RtpRtcp*>::const_iterator it = simulcast_rtp_rtcp_.begin();
it != simulcast_rtp_rtcp_.end(); it++) { it != simulcast_rtp_rtcp_.end(); it++) {
WebRtc_UWord32 stream_rate = 0; uint32_t stream_rate = 0;
WebRtc_UWord32 video_rate = 0; uint32_t video_rate = 0;
WebRtc_UWord32 fec_rate = 0; uint32_t fec_rate = 0;
WebRtc_UWord32 nackRate = 0; uint32_t nackRate = 0;
RtpRtcp* rtp_rtcp = *it; RtpRtcp* rtp_rtcp = *it;
rtp_rtcp->BitrateSent(&stream_rate, &video_rate, &fec_rate, &nackRate); rtp_rtcp->BitrateSent(&stream_rate, &video_rate, &fec_rate, &nackRate);
total_bitrate_sent += stream_rate; *total_bitrate_sent += stream_rate;
fec_bitrate_sent += fec_rate; *fec_bitrate_sent += fec_rate;
nackBitrateSent += nackRate; *nackBitrateSent += nackRate;
} }
} }
int ViEChannel::GetEstimatedReceiveBandwidth( int ViEChannel::GetEstimatedReceiveBandwidth(
WebRtc_UWord32* estimated_bandwidth) const { uint32_t* estimated_bandwidth) const {
return rtp_rtcp_->EstimatedReceiveBandwidth(estimated_bandwidth); return rtp_rtcp_->EstimatedReceiveBandwidth(estimated_bandwidth);
} }
@ -1097,8 +1093,8 @@ WebRtc_Word32 ViEChannel::SetLocalReceiver(const WebRtc_UWord16 rtp_port,
#endif #endif
} }
WebRtc_Word32 ViEChannel::GetLocalReceiver(WebRtc_UWord16& rtp_port, WebRtc_Word32 ViEChannel::GetLocalReceiver(WebRtc_UWord16* rtp_port,
WebRtc_UWord16& rtcp_port, WebRtc_UWord16* rtcp_port,
char* ip_address) const { char* ip_address) const {
WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s", WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s",
__FUNCTION__); __FUNCTION__);
@ -1120,8 +1116,8 @@ WebRtc_Word32 ViEChannel::GetLocalReceiver(WebRtc_UWord16& rtp_port,
} }
char multicast_ip_address[UdpTransport::kIpAddressVersion6Length]; char multicast_ip_address[UdpTransport::kIpAddressVersion6Length];
if (socket_transport_.ReceiveSocketInformation(ip_address, rtp_port, if (socket_transport_.ReceiveSocketInformation(ip_address, *rtp_port,
rtcp_port, *rtcp_port,
multicast_ip_address) != 0) { multicast_ip_address) != 0) {
WebRtc_Word32 socket_error = socket_transport_.LastError(); WebRtc_Word32 socket_error = socket_transport_.LastError();
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_), WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_),
@ -1258,10 +1254,10 @@ WebRtc_Word32 ViEChannel::SetSendDestination(
WebRtc_Word32 ViEChannel::GetSendDestination( WebRtc_Word32 ViEChannel::GetSendDestination(
char* ip_address, char* ip_address,
WebRtc_UWord16& rtp_port, WebRtc_UWord16* rtp_port,
WebRtc_UWord16& rtcp_port, WebRtc_UWord16* rtcp_port,
WebRtc_UWord16& source_rtp_port, WebRtc_UWord16* source_rtp_port,
WebRtc_UWord16& source_rtcp_port) const { WebRtc_UWord16* source_rtcp_port) const {
WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s", WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s",
__FUNCTION__); __FUNCTION__);
@ -1280,18 +1276,18 @@ WebRtc_Word32 ViEChannel::GetSendDestination(
"%s: send sockets not initialized", __FUNCTION__); "%s: send sockets not initialized", __FUNCTION__);
return -1; return -1;
} }
if (socket_transport_.SendSocketInformation(ip_address, rtp_port, rtcp_port) if (socket_transport_.SendSocketInformation(ip_address, *rtp_port,
!= 0) { *rtcp_port) != 0) {
WebRtc_Word32 socket_error = socket_transport_.LastError(); WebRtc_Word32 socket_error = socket_transport_.LastError();
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_), WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_),
"%s: could not get send socket information. Socket error: %d", "%s: could not get send socket information. Socket error: %d",
__FUNCTION__, socket_error); __FUNCTION__, socket_error);
return -1; return -1;
} }
source_rtp_port = 0; *source_rtp_port = 0;
source_rtcp_port = 0; *source_rtcp_port = 0;
if (socket_transport_.SourcePortsInitialized()) { if (socket_transport_.SourcePortsInitialized()) {
socket_transport_.SourcePorts(source_rtp_port, source_rtcp_port); socket_transport_.SourcePorts(*source_rtp_port, *source_rtcp_port);
} }
return 0; return 0;
#else #else
@ -1461,8 +1457,8 @@ bool ViEChannel::Receiving() {
#endif #endif
} }
WebRtc_Word32 ViEChannel::GetSourceInfo(WebRtc_UWord16& rtp_port, WebRtc_Word32 ViEChannel::GetSourceInfo(WebRtc_UWord16* rtp_port,
WebRtc_UWord16& rtcp_port, WebRtc_UWord16* rtcp_port,
char* ip_address, char* ip_address,
WebRtc_UWord32 ip_address_length) { WebRtc_UWord32 ip_address_length) {
{ {
@ -1487,8 +1483,8 @@ WebRtc_Word32 ViEChannel::GetSourceInfo(WebRtc_UWord16& rtp_port,
return -1; return -1;
} }
if (socket_transport_.RemoteSocketInformation(ip_address, rtp_port, rtcp_port) if (socket_transport_.RemoteSocketInformation(ip_address, *rtp_port,
!= 0) { *rtcp_port) != 0) {
WebRtc_Word32 socket_error = socket_transport_.LastError(); WebRtc_Word32 socket_error = socket_transport_.LastError();
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_), WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_),
"%s: Error getting source ports. Socket error: %d", "%s: Error getting source ports. Socket error: %d",
@ -1502,7 +1498,8 @@ WebRtc_Word32 ViEChannel::GetSourceInfo(WebRtc_UWord16& rtp_port,
return -1; return -1;
#endif #endif
} }
WebRtc_Word32 ViEChannel::RegisterSendTransport(Transport& transport) {
WebRtc_Word32 ViEChannel::RegisterSendTransport(Transport* transport) {
WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s", WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s",
__FUNCTION__); __FUNCTION__);
@ -1526,8 +1523,8 @@ WebRtc_Word32 ViEChannel::RegisterSendTransport(Transport& transport) {
"%s: transport already registered", __FUNCTION__); "%s: transport already registered", __FUNCTION__);
return -1; return -1;
} }
external_transport_ = &transport; external_transport_ = transport;
vie_sender_.RegisterSendTransport(&transport); vie_sender_.RegisterSendTransport(transport);
WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_),
"%s: Transport registered: 0x%p", __FUNCTION__, "%s: Transport registered: 0x%p", __FUNCTION__,
&external_transport_); &external_transport_);
@ -1665,8 +1662,8 @@ WebRtc_Word32 ViEChannel::SetSourceFilter(const WebRtc_UWord16 rtp_port,
#endif #endif
} }
WebRtc_Word32 ViEChannel::GetSourceFilter(WebRtc_UWord16& rtp_port, WebRtc_Word32 ViEChannel::GetSourceFilter(WebRtc_UWord16* rtp_port,
WebRtc_UWord16& rtcp_port, WebRtc_UWord16* rtcp_port,
char* ip_address) const { char* ip_address) const {
callback_cs_->Enter(); callback_cs_->Enter();
WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s", WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s",
@ -1685,7 +1682,7 @@ WebRtc_Word32 ViEChannel::GetSourceFilter(WebRtc_UWord16& rtp_port,
// Logging done in module. // Logging done in module.
return -1; return -1;
} }
if (socket_transport_.FilterPorts(rtp_port, rtcp_port) != 0) { if (socket_transport_.FilterPorts(*rtp_port, *rtcp_port) != 0) {
// Logging done in module. // Logging done in module.
return -1; return -1;
} }
@ -1724,8 +1721,8 @@ WebRtc_Word32 ViEChannel::SetToS(const WebRtc_Word32 DSCP,
#endif #endif
} }
WebRtc_Word32 ViEChannel::GetToS(WebRtc_Word32& DSCP, WebRtc_Word32 ViEChannel::GetToS(WebRtc_Word32* DSCP,
bool& use_set_sockOpt) const { bool* use_set_sockOpt) const {
WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s", WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s",
__FUNCTION__); __FUNCTION__);
{ {
@ -1737,7 +1734,7 @@ WebRtc_Word32 ViEChannel::GetToS(WebRtc_Word32& DSCP,
} }
} }
#ifndef WEBRTC_EXTERNAL_TRANSPORT #ifndef WEBRTC_EXTERNAL_TRANSPORT
if (socket_transport_.ToS(DSCP, use_set_sockOpt) != 0) { if (socket_transport_.ToS(*DSCP, *use_set_sockOpt) != 0) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_), WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_),
"%s: Socket error: %d", __FUNCTION__, "%s: Socket error: %d", __FUNCTION__,
socket_transport_.LastError()); socket_transport_.LastError());
@ -1781,9 +1778,9 @@ WebRtc_Word32 ViEChannel::SetSendGQoS(const bool enable,
#endif #endif
} }
WebRtc_Word32 ViEChannel::GetSendGQoS(bool& enabled, WebRtc_Word32 ViEChannel::GetSendGQoS(bool* enabled,
WebRtc_Word32& service_type, WebRtc_Word32* service_type,
WebRtc_Word32& overrideDSCP) const { WebRtc_Word32* overrideDSCP) const {
WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s", WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s",
__FUNCTION__); __FUNCTION__);
{ {
@ -1795,7 +1792,7 @@ WebRtc_Word32 ViEChannel::GetSendGQoS(bool& enabled,
} }
} }
#ifndef WEBRTC_EXTERNAL_TRANSPORT #ifndef WEBRTC_EXTERNAL_TRANSPORT
if (socket_transport_.QoS(enabled, service_type, overrideDSCP) != 0) { if (socket_transport_.QoS(*enabled, *service_type, *overrideDSCP) != 0) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_), WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_),
"%s: Socket error: %d", __FUNCTION__, "%s: Socket error: %d", __FUNCTION__,
socket_transport_.LastError()); socket_transport_.LastError());
@ -1961,7 +1958,7 @@ RtpRtcp* ViEChannel::rtp_rtcp() {
return rtp_rtcp_.get(); return rtp_rtcp_.get();
} }
WebRtc_Word32 ViEChannel::FrameToRender(VideoFrame& video_frame) { WebRtc_Word32 ViEChannel::FrameToRender(VideoFrame& video_frame) { // NOLINT
CriticalSectionScoped cs(callback_cs_.get()); CriticalSectionScoped cs(callback_cs_.get());
if (decoder_reset_) { if (decoder_reset_) {
@ -1973,8 +1970,8 @@ WebRtc_Word32 ViEChannel::FrameToRender(VideoFrame& video_frame) {
// VCM::ReceiveCodec returns the codec set by // VCM::ReceiveCodec returns the codec set by
// RegisterReceiveCodec, which might not be the size we're // RegisterReceiveCodec, which might not be the size we're
// actually decoding. // actually decoding.
decoder.width = static_cast<unsigned short>(video_frame.Width()); decoder.width = static_cast<uint16_t>(video_frame.Width());
decoder.height = static_cast<unsigned short>(video_frame.Height()); decoder.height = static_cast<uint16_t>(video_frame.Height());
codec_observer_->IncomingCodecChanged(channel_id_, decoder); codec_observer_->IncomingCodecChanged(channel_id_, decoder);
} else { } else {
assert(false); assert(false);

95
src/video_engine/vie_channel.h
View File

@ -8,10 +8,8 @@
* be found in the AUTHORS file in the root of the source tree. * be found in the AUTHORS file in the root of the source tree.
*/ */
// vie_channel.h #ifndef WEBRTC_VIDEO_ENGINE_VIE_CHANNEL_H_ // NOLINT
#define WEBRTC_VIDEO_ENGINE_VIE_CHANNEL_H_ // NOLINT
#ifndef WEBRTC_VIDEO_ENGINE_VIE_CHANNEL_H_
#define WEBRTC_VIDEO_ENGINE_VIE_CHANNEL_H_
#include <list> #include <list>
@ -21,7 +19,7 @@
#include "modules/video_coding/main/interface/video_coding_defines.h" #include "modules/video_coding/main/interface/video_coding_defines.h"
#include "system_wrappers/interface/scoped_ptr.h" #include "system_wrappers/interface/scoped_ptr.h"
#include "system_wrappers/interface/tick_util.h" #include "system_wrappers/interface/tick_util.h"
#include "typedefs.h" #include "typedefs.h" // NOLINT
#include "video_engine/include/vie_network.h" #include "video_engine/include/vie_network.h"
#include "video_engine/include/vie_rtp_rtcp.h" #include "video_engine/include/vie_rtp_rtcp.h"
#include "video_engine/vie_defines.h" #include "video_engine/vie_defines.h"
@ -75,7 +73,7 @@ class ViEChannel
WebRtc_Word32 SetSendCodec(const VideoCodec& video_codec, WebRtc_Word32 SetSendCodec(const VideoCodec& video_codec,
bool new_stream = true); bool new_stream = true);
WebRtc_Word32 SetReceiveCodec(const VideoCodec& video_codec); WebRtc_Word32 SetReceiveCodec(const VideoCodec& video_codec);
WebRtc_Word32 GetReceiveCodec(VideoCodec& video_codec); WebRtc_Word32 GetReceiveCodec(VideoCodec* video_codec);
WebRtc_Word32 RegisterCodecObserver(ViEDecoderObserver* observer); WebRtc_Word32 RegisterCodecObserver(ViEDecoderObserver* observer);
// Registers an external decoder. |decoder_render| is set to true if the // Registers an external decoder. |decoder_render| is set to true if the
// decoder will do the rendering. If |decoder_render| is set,|render_delay| // decoder will do the rendering. If |decoder_render| is set,|render_delay|
@ -85,8 +83,8 @@ class ViEChannel
bool decoder_render, bool decoder_render,
WebRtc_Word32 render_delay); WebRtc_Word32 render_delay);
WebRtc_Word32 DeRegisterExternalDecoder(const WebRtc_UWord8 pl_type); WebRtc_Word32 DeRegisterExternalDecoder(const WebRtc_UWord8 pl_type);
WebRtc_Word32 ReceiveCodecStatistics(WebRtc_UWord32& num_key_frames, WebRtc_Word32 ReceiveCodecStatistics(WebRtc_UWord32* num_key_frames,
WebRtc_UWord32& num_delta_frames); WebRtc_UWord32* num_delta_frames);
WebRtc_UWord32 DiscardedPackets() const; WebRtc_UWord32 DiscardedPackets() const;
// Only affects calls to SetReceiveCodec done after this call. // Only affects calls to SetReceiveCodec done after this call.
@ -98,7 +96,7 @@ class ViEChannel
WebRtc_Word32 SetSignalPacketLossStatus(bool enable, bool only_key_frames); WebRtc_Word32 SetSignalPacketLossStatus(bool enable, bool only_key_frames);
WebRtc_Word32 SetRTCPMode(const RTCPMethod rtcp_mode); WebRtc_Word32 SetRTCPMode(const RTCPMethod rtcp_mode);
WebRtc_Word32 GetRTCPMode(RTCPMethod& rtcp_mode); WebRtc_Word32 GetRTCPMode(RTCPMethod* rtcp_mode);
WebRtc_Word32 SetNACKStatus(const bool enable); WebRtc_Word32 SetNACKStatus(const bool enable);
WebRtc_Word32 SetFECStatus(const bool enable, WebRtc_Word32 SetFECStatus(const bool enable,
const unsigned char payload_typeRED, const unsigned char payload_typeRED,
@ -112,18 +110,18 @@ class ViEChannel
WebRtc_Word32 EnableKeyFrameRequestCallback(const bool enable); WebRtc_Word32 EnableKeyFrameRequestCallback(const bool enable);
// Sets SSRC for outgoing stream. // Sets SSRC for outgoing stream.
WebRtc_Word32 SetSSRC(const WebRtc_UWord32 SSRC, WebRtc_Word32 SetSSRC(const uint32_t SSRC,
const StreamType usage, const StreamType usage,
const unsigned char simulcast_idx); const unsigned char simulcast_idx);
// Gets SSRC for outgoing stream. // Gets SSRC for outgoing stream.
WebRtc_Word32 GetLocalSSRC(WebRtc_UWord32& SSRC); WebRtc_Word32 GetLocalSSRC(uint32_t* ssrc);
// Gets SSRC for the incoming stream. // Gets SSRC for the incoming stream.
WebRtc_Word32 GetRemoteSSRC(WebRtc_UWord32& SSRC); WebRtc_Word32 GetRemoteSSRC(uint32_t* ssrc);
// Gets the CSRC for the incoming stream. // Gets the CSRC for the incoming stream.
WebRtc_Word32 GetRemoteCSRC(unsigned int CSRCs[kRtpCsrcSize]); WebRtc_Word32 GetRemoteCSRC(uint32_t CSRCs[kRtpCsrcSize]);
// Sets the starting sequence number, must be called before StartSend. // Sets the starting sequence number, must be called before StartSend.
WebRtc_Word32 SetStartSequenceNumber(WebRtc_UWord16 sequence_number); WebRtc_Word32 SetStartSequenceNumber(WebRtc_UWord16 sequence_number);
@ -145,29 +143,29 @@ class ViEChannel
WebRtc_UWord16 data_length_in_bytes); WebRtc_UWord16 data_length_in_bytes);
// Returns statistics reported by the remote client in an RTCP packet. // Returns statistics reported by the remote client in an RTCP packet.
WebRtc_Word32 GetSendRtcpStatistics(WebRtc_UWord16& fraction_lost, WebRtc_Word32 GetSendRtcpStatistics(uint16_t* fraction_lost,
WebRtc_UWord32& cumulative_lost, uint32_t* cumulative_lost,
WebRtc_UWord32& extended_max, uint32_t* extended_max,
WebRtc_UWord32& jitter_samples, uint32_t* jitter_samples,
WebRtc_Word32& rtt_ms); int32_t* rtt_ms);
// Returns our localy created statistics of the received RTP stream. // Returns our localy created statistics of the received RTP stream.
WebRtc_Word32 GetReceivedRtcpStatistics(WebRtc_UWord16& fraction_lost, WebRtc_Word32 GetReceivedRtcpStatistics(uint16_t* fraction_lost,
WebRtc_UWord32& cumulative_lost, uint32_t* cumulative_lost,
WebRtc_UWord32& extended_max, uint32_t* extended_max,
WebRtc_UWord32& jitter_samples, uint32_t* jitter_samples,
WebRtc_Word32& rtt_ms); int32_t* rtt_ms);
// Gets sent/received packets statistics. // Gets sent/received packets statistics.
WebRtc_Word32 GetRtpStatistics(WebRtc_UWord32& bytes_sent, WebRtc_Word32 GetRtpStatistics(uint32_t* bytes_sent,
WebRtc_UWord32& packets_sent, uint32_t* packets_sent,
WebRtc_UWord32& bytes_received, uint32_t* bytes_received,
WebRtc_UWord32& packets_received) const; uint32_t* packets_received) const;
void GetBandwidthUsage(WebRtc_UWord32& total_bitrate_sent, void GetBandwidthUsage(uint32_t* total_bitrate_sent,
WebRtc_UWord32& video_bitrate_sent, uint32_t* video_bitrate_sent,
WebRtc_UWord32& fec_bitrate_sent, uint32_t* fec_bitrate_sent,
WebRtc_UWord32& nackBitrateSent) const; uint32_t* nackBitrateSent) const;
int GetEstimatedReceiveBandwidth(WebRtc_UWord32* estimated_bandwidth) const; int GetEstimatedReceiveBandwidth(uint32_t* estimated_bandwidth) const;
WebRtc_Word32 StartRTPDump(const char file_nameUTF8[1024], WebRtc_Word32 StartRTPDump(const char file_nameUTF8[1024],
RTPDirections direction); RTPDirections direction);
@ -202,8 +200,8 @@ class ViEChannel
WebRtc_Word32 SetLocalReceiver(const WebRtc_UWord16 rtp_port, WebRtc_Word32 SetLocalReceiver(const WebRtc_UWord16 rtp_port,
const WebRtc_UWord16 rtcp_port, const WebRtc_UWord16 rtcp_port,
const char* ip_address); const char* ip_address);
WebRtc_Word32 GetLocalReceiver(WebRtc_UWord16& rtp_port, WebRtc_Word32 GetLocalReceiver(WebRtc_UWord16* rtp_port,
WebRtc_UWord16& rtcp_port, WebRtc_UWord16* rtcp_port,
char* ip_address) const; char* ip_address) const;
WebRtc_Word32 SetSendDestination(const char* ip_address, WebRtc_Word32 SetSendDestination(const char* ip_address,
const WebRtc_UWord16 rtp_port, const WebRtc_UWord16 rtp_port,
@ -211,12 +209,12 @@ class ViEChannel
const WebRtc_UWord16 source_rtp_port, const WebRtc_UWord16 source_rtp_port,
const WebRtc_UWord16 source_rtcp_port); const WebRtc_UWord16 source_rtcp_port);
WebRtc_Word32 GetSendDestination(char* ip_address, WebRtc_Word32 GetSendDestination(char* ip_address,
WebRtc_UWord16& rtp_port, WebRtc_UWord16* rtp_port,
WebRtc_UWord16& rtcp_port, WebRtc_UWord16* rtcp_port,
WebRtc_UWord16& source_rtp_port, WebRtc_UWord16* source_rtp_port,
WebRtc_UWord16& source_rtcp_port) const; WebRtc_UWord16* source_rtcp_port) const;
WebRtc_Word32 GetSourceInfo(WebRtc_UWord16& rtp_port, WebRtc_Word32 GetSourceInfo(WebRtc_UWord16* rtp_port,
WebRtc_UWord16& rtcp_port, WebRtc_UWord16* rtcp_port,
char* ip_address, char* ip_address,
WebRtc_UWord32 ip_address_length); WebRtc_UWord32 ip_address_length);
@ -230,7 +228,7 @@ class ViEChannel
WebRtc_Word32 StopReceive(); WebRtc_Word32 StopReceive();
bool Receiving(); bool Receiving();
WebRtc_Word32 RegisterSendTransport(Transport& transport); WebRtc_Word32 RegisterSendTransport(Transport* transport);
WebRtc_Word32 DeregisterSendTransport(); WebRtc_Word32 DeregisterSendTransport();
// Incoming packet from external transport. // Incoming packet from external transport.
@ -246,18 +244,19 @@ class ViEChannel
WebRtc_Word32 SetSourceFilter(const WebRtc_UWord16 rtp_port, WebRtc_Word32 SetSourceFilter(const WebRtc_UWord16 rtp_port,
const WebRtc_UWord16 rtcp_port, const WebRtc_UWord16 rtcp_port,
const char* ip_address); const char* ip_address);
WebRtc_Word32 GetSourceFilter(WebRtc_UWord16& rtp_port, WebRtc_Word32 GetSourceFilter(WebRtc_UWord16* rtp_port,
WebRtc_UWord16& rtcp_port, WebRtc_UWord16* rtcp_port,
char* ip_address) const; char* ip_address) const;
WebRtc_Word32 SetToS(const WebRtc_Word32 DSCP, const bool use_set_sockOpt); 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 GetToS(WebRtc_Word32* DSCP, bool* use_set_sockOpt) const;
WebRtc_Word32 SetSendGQoS(const bool enable, WebRtc_Word32 SetSendGQoS(const bool enable,
const WebRtc_Word32 service_type, const WebRtc_Word32 service_type,
const WebRtc_UWord32 max_bitrate, const WebRtc_UWord32 max_bitrate,
const WebRtc_Word32 overrideDSCP); const WebRtc_Word32 overrideDSCP);
WebRtc_Word32 GetSendGQoS(bool& enabled, WebRtc_Word32& service_type, WebRtc_Word32 GetSendGQoS(bool* enabled,
WebRtc_Word32& overrideDSCP) const; WebRtc_Word32* service_type,
WebRtc_Word32* overrideDSCP) const;
// Sets the maximum transfer unit size for the network link, i.e. including // Sets the maximum transfer unit size for the network link, i.e. including
// IP, UDP and RTP headers. // IP, UDP and RTP headers.
@ -288,7 +287,7 @@ class ViEChannel
RtpRtcp* rtp_rtcp(); RtpRtcp* rtp_rtcp();
// Implements VCMReceiveCallback. // Implements VCMReceiveCallback.
virtual WebRtc_Word32 FrameToRender(VideoFrame& video_frame); virtual WebRtc_Word32 FrameToRender(VideoFrame& video_frame); // NOLINT
// Implements VCMReceiveCallback. // Implements VCMReceiveCallback.
virtual WebRtc_Word32 ReceivedDecodedReferenceFrame( virtual WebRtc_Word32 ReceivedDecodedReferenceFrame(
@ -398,4 +397,4 @@ class ViEChannel
} // namespace webrtc } // namespace webrtc
#endif // WEBRTC_VIDEO_ENGINE_VIE_CHANNEL_H_ #endif // WEBRTC_VIDEO_ENGINE_VIE_CHANNEL_H_ // NOLINT

4
src/video_engine/vie_channel_manager.cc
View File

@ -204,7 +204,7 @@ int ViEChannelManager::DeleteChannel(int channel_id) {
group->SetChannelRembStatus(channel_id, false, false, vie_channel, group->SetChannelRembStatus(channel_id, false, false, vie_channel,
vie_encoder); vie_encoder);
unsigned int ssrc = 0; unsigned int ssrc = 0;
vie_channel->GetRemoteSSRC(ssrc); vie_channel->GetRemoteSSRC(&ssrc);
group->RemoveChannel(channel_id, ssrc); group->RemoveChannel(channel_id, ssrc);
// Check if other channels are using the same encoder. // Check if other channels are using the same encoder.
@ -347,7 +347,7 @@ bool ViEChannelManager::CreateChannelObject(
return false; return false;
} }
VideoCodec encoder; VideoCodec encoder;
if (vie_encoder->GetEncoder(encoder) != 0 || if (vie_encoder->GetEncoder(&encoder) != 0 ||
vie_channel->SetSendCodec(encoder) != 0) { vie_channel->SetSendCodec(encoder) != 0) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id), WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id),
"%s: Could not GetEncoder or SetSendCodec.", __FUNCTION__); "%s: Could not GetEncoder or SetSendCodec.", __FUNCTION__);

10
src/video_engine/vie_codec_impl.cc
View File

@ -174,7 +174,7 @@ int ViECodecImpl::SetSendCodec(const int video_channel,
} }
VideoCodec encoder; VideoCodec encoder;
vie_encoder->GetEncoder(encoder); vie_encoder->GetEncoder(&encoder);
// Make sure to generate a new SSRC if the codec type and/or resolution has // Make sure to generate a new SSRC if the codec type and/or resolution has
// changed. This won't have any effect if the user has set an SSRC. // changed. This won't have any effect if the user has set an SSRC.
@ -271,7 +271,7 @@ int ViECodecImpl::GetSendCodec(const int video_channel,
shared_data_->SetLastError(kViECodecInvalidChannelId); shared_data_->SetLastError(kViECodecInvalidChannelId);
return -1; return -1;
} }
return vie_encoder->GetEncoder(video_codec); return vie_encoder->GetEncoder(&video_codec);
} }
int ViECodecImpl::SetReceiveCodec(const int video_channel, int ViECodecImpl::SetReceiveCodec(const int video_channel,
@ -333,7 +333,7 @@ int ViECodecImpl::GetReceiveCodec(const int video_channel,
return -1; return -1;
} }
if (vie_channel->GetReceiveCodec(video_codec) != 0) { if (vie_channel->GetReceiveCodec(&video_codec) != 0) {
shared_data_->SetLastError(kViECodecUnknownError); shared_data_->SetLastError(kViECodecUnknownError);
return -1; return -1;
} }
@ -408,7 +408,7 @@ int ViECodecImpl::GetSendCodecStastistics(const int video_channel,
return -1; return -1;
} }
if (vie_encoder->SendCodecStatistics(key_frames, delta_frames) != 0) { if (vie_encoder->SendCodecStatistics(&key_frames, &delta_frames) != 0) {
shared_data_->SetLastError(kViECodecUnknownError); shared_data_->SetLastError(kViECodecUnknownError);
return -1; return -1;
} }
@ -432,7 +432,7 @@ int ViECodecImpl::GetReceiveCodecStastistics(const int video_channel,
shared_data_->SetLastError(kViECodecInvalidChannelId); shared_data_->SetLastError(kViECodecInvalidChannelId);
return -1; return -1;
} }
if (vie_channel->ReceiveCodecStatistics(key_frames, delta_frames) != 0) { if (vie_channel->ReceiveCodecStatistics(&key_frames, &delta_frames) != 0) {
shared_data_->SetLastError(kViECodecUnknownError); shared_data_->SetLastError(kViECodecUnknownError);
return -1; return -1;
} }

40
src/video_engine/vie_encoder.cc
View File

@ -8,21 +8,21 @@
* be found in the AUTHORS file in the root of the source tree. * be found in the AUTHORS file in the root of the source tree.
*/ */
#include "vie_encoder.h" #include "video_engine/vie_encoder.h"
#include <cassert> #include <cassert>
#include "critical_section_wrapper.h" #include "modules/rtp_rtcp/interface/rtp_rtcp.h"
#include "process_thread.h" #include "modules/utility/interface/process_thread.h"
#include "rtp_rtcp.h" #include "modules/video_coding/codecs/interface/video_codec_interface.h"
#include "tick_util.h" #include "modules/video_coding/main/interface/video_coding.h"
#include "trace.h" #include "modules/video_coding/main/interface/video_coding_defines.h"
#include "video_codec_interface.h" #include "system_wrappers/interface/critical_section_wrapper.h"
#include "video_coding.h" #include "system_wrappers/interface/tick_util.h"
#include "video_coding_defines.h" #include "system_wrappers/interface/trace.h"
#include "vie_codec.h" #include "video_engine/include/vie_codec.h"
#include "vie_defines.h" #include "video_engine/include/vie_image_process.h"
#include "vie_image_process.h" #include "video_engine/vie_defines.h"
namespace webrtc { namespace webrtc {
@ -42,7 +42,7 @@ class QMVideoSettingsCallback : public VCMQMSettingsCallback {
class ViEBitrateObserver : public BitrateObserver { class ViEBitrateObserver : public BitrateObserver {
public: public:
ViEBitrateObserver(ViEEncoder* owner) explicit ViEBitrateObserver(ViEEncoder* owner)
: owner_(owner) { : owner_(owner) {
} }
// Implements BitrateObserver. // Implements BitrateObserver.
@ -240,8 +240,8 @@ WebRtc_UWord8 ViEEncoder::NumberOfCodecs() {
} }
WebRtc_Word32 ViEEncoder::GetCodec(WebRtc_UWord8 list_index, WebRtc_Word32 ViEEncoder::GetCodec(WebRtc_UWord8 list_index,
webrtc::VideoCodec& video_codec) { VideoCodec* video_codec) {
if (vcm_.Codec(list_index, &video_codec) != 0) { if (vcm_.Codec(list_index, video_codec) != 0) {
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo,
ViEId(engine_id_, channel_id_), "%s: Could not get codec", ViEId(engine_id_, channel_id_), "%s: Could not get codec",
__FUNCTION__); __FUNCTION__);
@ -358,11 +358,11 @@ WebRtc_Word32 ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec) {
return 0; return 0;
} }
WebRtc_Word32 ViEEncoder::GetEncoder(webrtc::VideoCodec& video_codec) { WebRtc_Word32 ViEEncoder::GetEncoder(VideoCodec* video_codec) {
WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo, WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo,
ViEId(engine_id_, channel_id_), "%s", __FUNCTION__); ViEId(engine_id_, channel_id_), "%s", __FUNCTION__);
if (vcm_.SendCodec(&video_codec) != 0) { if (vcm_.SendCodec(video_codec) != 0) {
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo,
ViEId(engine_id_, channel_id_), ViEId(engine_id_, channel_id_),
"Could not get VCM send codec"); "Could not get VCM send codec");
@ -582,7 +582,7 @@ int ViEEncoder::SendKeyFrame() {
} }
WebRtc_Word32 ViEEncoder::SendCodecStatistics( WebRtc_Word32 ViEEncoder::SendCodecStatistics(
WebRtc_UWord32& num_key_frames, WebRtc_UWord32& num_delta_frames) { WebRtc_UWord32* num_key_frames, WebRtc_UWord32* num_delta_frames) {
WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo, WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo,
ViEId(engine_id_, channel_id_), "%s", __FUNCTION__); ViEId(engine_id_, channel_id_), "%s", __FUNCTION__);
@ -593,8 +593,8 @@ WebRtc_Word32 ViEEncoder::SendCodecStatistics(
"%s: Could not get sent frame information", __FUNCTION__); "%s: Could not get sent frame information", __FUNCTION__);
return -1; return -1;
} }
num_key_frames = sent_frames.numKeyFrames; *num_key_frames = sent_frames.numKeyFrames;
num_delta_frames = sent_frames.numDeltaFrames; *num_delta_frames = sent_frames.numDeltaFrames;
return 0; return 0;
} }

30
src/video_engine/vie_encoder.h
View File

@ -8,20 +8,19 @@
* be found in the AUTHORS file in the root of the source tree. * be found in the AUTHORS file in the root of the source tree.
*/ */
#ifndef WEBRTC_VIDEO_ENGINE_VIE_ENCODER_H_ #ifndef WEBRTC_VIDEO_ENGINE_VIE_ENCODER_H_ // NOLINT
#define WEBRTC_VIDEO_ENGINE_VIE_ENCODER_H_ #define WEBRTC_VIDEO_ENGINE_VIE_ENCODER_H_ // NOLINT
#include "common_types.h"
#include "typedefs.h"
#include "video_coding_defines.h"
#include "video_processing.h"
#include "vie_defines.h"
#include "vie_file_recorder.h"
#include "vie_frame_provider_base.h"
#include "common_types.h" // NOLINT
#include "typedefs.h" //NOLINT
#include "modules/bitrate_controller/include/bitrate_controller.h" #include "modules/bitrate_controller/include/bitrate_controller.h"
#include "modules/rtp_rtcp/interface/rtp_rtcp_defines.h" #include "modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
#include "modules/video_coding/main/interface/video_coding_defines.h"
#include "modules/video_processing/main/interface/video_processing.h"
#include "system_wrappers/interface/scoped_ptr.h" #include "system_wrappers/interface/scoped_ptr.h"
#include "video_engine/vie_defines.h"
#include "video_engine/vie_file_recorder.h"
#include "video_engine/vie_frame_provider_base.h"
namespace webrtc { namespace webrtc {
@ -63,12 +62,12 @@ class ViEEncoder
// Codec settings. // Codec settings.
WebRtc_UWord8 NumberOfCodecs(); WebRtc_UWord8 NumberOfCodecs();
WebRtc_Word32 GetCodec(WebRtc_UWord8 list_index, VideoCodec& video_codec); WebRtc_Word32 GetCodec(WebRtc_UWord8 list_index, VideoCodec* video_codec);
WebRtc_Word32 RegisterExternalEncoder(VideoEncoder* encoder, WebRtc_Word32 RegisterExternalEncoder(VideoEncoder* encoder,
WebRtc_UWord8 pl_type); WebRtc_UWord8 pl_type);
WebRtc_Word32 DeRegisterExternalEncoder(WebRtc_UWord8 pl_type); WebRtc_Word32 DeRegisterExternalEncoder(WebRtc_UWord8 pl_type);
WebRtc_Word32 SetEncoder(const VideoCodec& video_codec); WebRtc_Word32 SetEncoder(const VideoCodec& video_codec);
WebRtc_Word32 GetEncoder(VideoCodec& video_codec); WebRtc_Word32 GetEncoder(VideoCodec* video_codec);
WebRtc_Word32 GetCodecConfigParameters( WebRtc_Word32 GetCodecConfigParameters(
unsigned char config_parameters[kConfigParameterSize], unsigned char config_parameters[kConfigParameterSize],
@ -94,10 +93,9 @@ class ViEEncoder
return; return;
} }
WebRtc_Word32 EncodeFrame(VideoFrame& video_frame);
WebRtc_Word32 SendKeyFrame(); WebRtc_Word32 SendKeyFrame();
WebRtc_Word32 SendCodecStatistics(WebRtc_UWord32& num_key_frames, WebRtc_Word32 SendCodecStatistics(WebRtc_UWord32* num_key_frames,
WebRtc_UWord32& num_delta_frames); WebRtc_UWord32* num_delta_frames);
WebRtc_Word32 EstimatedSendBandwidth( WebRtc_Word32 EstimatedSendBandwidth(
WebRtc_UWord32* available_bandwidth) const; WebRtc_UWord32* available_bandwidth) const;
@ -189,4 +187,4 @@ class ViEEncoder
} // namespace webrtc } // namespace webrtc
#endif // WEBRTC_VIDEO_ENGINE_VIE_ENCODER_H_ #endif // WEBRTC_VIDEO_ENGINE_VIE_ENCODER_H_ // NOLINT

18
src/video_engine/vie_network_impl.cc
View File

@ -126,7 +126,7 @@ int ViENetworkImpl::GetLocalReceiver(const int video_channel,
shared_data_->SetLastError(kViENetworkInvalidChannelId); shared_data_->SetLastError(kViENetworkInvalidChannelId);
return -1; return -1;
} }
if (vie_channel->GetLocalReceiver(rtp_port, rtcp_port, ip_address) != 0) { if (vie_channel->GetLocalReceiver(&rtp_port, &rtcp_port, ip_address) != 0) {
shared_data_->SetLastError(kViENetworkLocalReceiverNotSet); shared_data_->SetLastError(kViENetworkLocalReceiverNotSet);
return -1; return -1;
} }
@ -196,9 +196,9 @@ int ViENetworkImpl::GetSendDestination(const int video_channel,
shared_data_->SetLastError(kViENetworkInvalidChannelId); shared_data_->SetLastError(kViENetworkInvalidChannelId);
return -1; return -1;
} }
if (vie_channel->GetSendDestination(ip_address, rtp_port, rtcp_port, if (vie_channel->GetSendDestination(ip_address, &rtp_port, &rtcp_port,
source_rtp_port, &source_rtp_port,
source_rtcp_port) != 0) { &source_rtcp_port) != 0) {
shared_data_->SetLastError(kViENetworkDestinationNotSet); shared_data_->SetLastError(kViENetworkDestinationNotSet);
return -1; return -1;
} }
@ -233,7 +233,7 @@ int ViENetworkImpl::RegisterSendTransport(const int video_channel,
shared_data_->SetLastError(kViENetworkAlreadySending); shared_data_->SetLastError(kViENetworkAlreadySending);
return -1; return -1;
} }
if (vie_channel->RegisterSendTransport(transport) != 0) { if (vie_channel->RegisterSendTransport(&transport) != 0) {
shared_data_->SetLastError(kViENetworkUnknownError); shared_data_->SetLastError(kViENetworkUnknownError);
return -1; return -1;
} }
@ -334,7 +334,7 @@ int ViENetworkImpl::GetSourceInfo(const int video_channel,
shared_data_->SetLastError(kViENetworkInvalidChannelId); shared_data_->SetLastError(kViENetworkInvalidChannelId);
return -1; return -1;
} }
if (vie_channel->GetSourceInfo(rtp_port, rtcp_port, ip_address, if (vie_channel->GetSourceInfo(&rtp_port, &rtcp_port, ip_address,
ip_address_length) != 0) { ip_address_length) != 0) {
shared_data_->SetLastError(kViENetworkUnknownError); shared_data_->SetLastError(kViENetworkUnknownError);
return -1; return -1;
@ -498,7 +498,7 @@ int ViENetworkImpl::GetSourceFilter(const int video_channel,
shared_data_->SetLastError(kViENetworkInvalidChannelId); shared_data_->SetLastError(kViENetworkInvalidChannelId);
return -1; return -1;
} }
if (vie_channel->GetSourceFilter(rtp_port, rtcp_port, ip_address) != 0) { if (vie_channel->GetSourceFilter(&rtp_port, &rtcp_port, ip_address) != 0) {
shared_data_->SetLastError(kViENetworkUnknownError); shared_data_->SetLastError(kViENetworkUnknownError);
return -1; return -1;
} }
@ -551,7 +551,7 @@ int ViENetworkImpl::GetSendToS(const int video_channel,
shared_data_->SetLastError(kViENetworkInvalidChannelId); shared_data_->SetLastError(kViENetworkInvalidChannelId);
return -1; return -1;
} }
if (vie_channel->GetToS((WebRtc_Word32&) DSCP, use_set_sockOpt) != 0) { if (vie_channel->GetToS(&DSCP, &use_set_sockOpt) != 0) {
shared_data_->SetLastError(kViENetworkUnknownError); shared_data_->SetLastError(kViENetworkUnknownError);
return -1; return -1;
} }
@ -645,7 +645,7 @@ int ViENetworkImpl::GetSendGQoS(const int video_channel,
shared_data_->SetLastError(kViENetworkInvalidChannelId); shared_data_->SetLastError(kViENetworkInvalidChannelId);
return -1; return -1;
} }
if (vie_channel->GetSendGQoS(enabled, service_type, overrideDSCP) != 0) { if (vie_channel->GetSendGQoS(&enabled, &service_type, &overrideDSCP) != 0) {
shared_data_->SetLastError(kViENetworkUnknownError); shared_data_->SetLastError(kViENetworkUnknownError);
return -1; return -1;
} }

46
src/video_engine/vie_rtp_rtcp_impl.cc
View File

@ -183,7 +183,7 @@ int ViERTP_RTCPImpl::GetLocalSSRC(const int video_channel,
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId); shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
return -1; return -1;
} }
if (vie_channel->GetLocalSSRC((WebRtc_UWord32&) SSRC) != 0) { if (vie_channel->GetLocalSSRC(&SSRC) != 0) {
shared_data_->SetLastError(kViERtpRtcpUnknownError); shared_data_->SetLastError(kViERtpRtcpUnknownError);
return -1; return -1;
} }
@ -204,7 +204,7 @@ int ViERTP_RTCPImpl::GetRemoteSSRC(const int video_channel,
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId); shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
return -1; return -1;
} }
if (vie_channel->GetRemoteSSRC(SSRC) != 0) { if (vie_channel->GetRemoteSSRC(&SSRC) != 0) {
shared_data_->SetLastError(kViERtpRtcpUnknownError); shared_data_->SetLastError(kViERtpRtcpUnknownError);
return -1; return -1;
} }
@ -301,7 +301,7 @@ int ViERTP_RTCPImpl::GetRTCPStatus(const int video_channel,
return -1; return -1;
} }
RTCPMethod module_mode = kRtcpOff; RTCPMethod module_mode = kRtcpOff;
if (vie_channel->GetRTCPMode(module_mode) != 0) { if (vie_channel->GetRTCPMode(&module_mode) != 0) {
WEBRTC_TRACE(kTraceError, kTraceVideo, WEBRTC_TRACE(kTraceError, kTraceVideo,
ViEId(shared_data_->instance_id(), video_channel), ViEId(shared_data_->instance_id(), video_channel),
"%s: could not get current RTCP mode", __FUNCTION__); "%s: could not get current RTCP mode", __FUNCTION__);
@ -413,7 +413,7 @@ int ViERTP_RTCPImpl::SendApplicationDefinedRTCPPacket(
return -1; return -1;
} }
RTCPMethod method; RTCPMethod method;
if (vie_channel->GetRTCPMode(method) != 0 || method == kRtcpOff) { if (vie_channel->GetRTCPMode(&method) != 0 || method == kRtcpOff) {
WEBRTC_TRACE(kTraceError, kTraceVideo, WEBRTC_TRACE(kTraceError, kTraceVideo,
ViEId(shared_data_->instance_id(), video_channel), ViEId(shared_data_->instance_id(), video_channel),
"%s: RTCP disabled on channel %d.", __FUNCTION__, "%s: RTCP disabled on channel %d.", __FUNCTION__,
@ -631,12 +631,11 @@ int ViERTP_RTCPImpl::GetReceivedRTCPStatistics(const int video_channel,
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId); shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
return -1; return -1;
} }
if (vie_channel->GetReceivedRtcpStatistics( if (vie_channel->GetReceivedRtcpStatistics(&fraction_lost,
static_cast<WebRtc_UWord16&>(fraction_lost), &cumulative_lost,
static_cast<WebRtc_UWord32&>(cumulative_lost), &extended_max,
static_cast<WebRtc_UWord32&>(extended_max), &jitter,
static_cast<WebRtc_UWord32&>(jitter), &rtt_ms) != 0) {
static_cast<WebRtc_Word32&>(rtt_ms)) != 0) {
shared_data_->SetLastError(kViERtpRtcpUnknownError); shared_data_->SetLastError(kViERtpRtcpUnknownError);
return -1; return -1;
} }
@ -662,12 +661,9 @@ int ViERTP_RTCPImpl::GetSentRTCPStatistics(const int video_channel,
return -1; return -1;
} }
if (vie_channel->GetSendRtcpStatistics( if (vie_channel->GetSendRtcpStatistics(&fraction_lost, &cumulative_lost,
static_cast<WebRtc_UWord16&>(fraction_lost), &extended_max, &jitter,
static_cast<WebRtc_UWord32&>(cumulative_lost), &rtt_ms) != 0) {
static_cast<WebRtc_UWord32&>(extended_max),
static_cast<WebRtc_UWord32&>(jitter),
static_cast<WebRtc_Word32&>(rtt_ms)) != 0) {
shared_data_->SetLastError(kViERtpRtcpUnknownError); shared_data_->SetLastError(kViERtpRtcpUnknownError);
return -1; return -1;
} }
@ -691,11 +687,10 @@ int ViERTP_RTCPImpl::GetRTPStatistics(const int video_channel,
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId); shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
return -1; return -1;
} }
if (vie_channel->GetRtpStatistics( if (vie_channel->GetRtpStatistics(&bytes_sent,
static_cast<WebRtc_UWord32&>(bytes_sent), &packets_sent,
static_cast<WebRtc_UWord32&>(packets_sent), &bytes_received,
static_cast<WebRtc_UWord32&>(bytes_received), &packets_received) != 0) {
static_cast<WebRtc_UWord32&>(packets_received)) != 0) {
shared_data_->SetLastError(kViERtpRtcpUnknownError); shared_data_->SetLastError(kViERtpRtcpUnknownError);
return -1; return -1;
} }
@ -719,11 +714,10 @@ int ViERTP_RTCPImpl::GetBandwidthUsage(const int video_channel,
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId); shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
return -1; return -1;
} }
vie_channel->GetBandwidthUsage( vie_channel->GetBandwidthUsage(&total_bitrate_sent,
static_cast<WebRtc_UWord32&>(total_bitrate_sent), &video_bitrate_sent,
static_cast<WebRtc_UWord32&>(video_bitrate_sent), &fec_bitrate_sent,
static_cast<WebRtc_UWord32&>(fec_bitrate_sent), &nackBitrateSent);
static_cast<WebRtc_UWord32&>(nackBitrateSent));
return 0; return 0;
} }