945 lines
32 KiB
C++
945 lines
32 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.
|
|
*/
|
|
|
|
#include "voe_network_impl.h"
|
|
|
|
#include "channel.h"
|
|
#include "critical_section_wrapper.h"
|
|
#include "trace.h"
|
|
#include "voe_errors.h"
|
|
#include "voice_engine_impl.h"
|
|
|
|
namespace webrtc
|
|
{
|
|
|
|
VoENetwork* VoENetwork::GetInterface(VoiceEngine* voiceEngine)
|
|
{
|
|
#ifndef WEBRTC_VOICE_ENGINE_NETWORK_API
|
|
return NULL;
|
|
#else
|
|
if (NULL == voiceEngine)
|
|
{
|
|
return NULL;
|
|
}
|
|
VoiceEngineImpl* s =
|
|
reinterpret_cast<VoiceEngineImpl*> (voiceEngine);
|
|
VoENetworkImpl* d = s;
|
|
(*d)++;
|
|
return (d);
|
|
#endif
|
|
}
|
|
|
|
#ifdef WEBRTC_VOICE_ENGINE_NETWORK_API
|
|
|
|
VoENetworkImpl::VoENetworkImpl()
|
|
{
|
|
WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, -1),
|
|
"VoENetworkImpl() - ctor");
|
|
}
|
|
|
|
VoENetworkImpl::~VoENetworkImpl()
|
|
{
|
|
WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, -1),
|
|
"~VoENetworkImpl() - dtor");
|
|
}
|
|
|
|
int VoENetworkImpl::Release()
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
|
|
"VoENetworkImpl::Release()");
|
|
(*this)--;
|
|
int refCount = GetCount();
|
|
if (refCount < 0)
|
|
{
|
|
Reset();
|
|
_engineStatistics.SetLastError(VE_INTERFACE_NOT_FOUND,
|
|
kTraceWarning);
|
|
return (-1);
|
|
}
|
|
WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, -1),
|
|
"VoENetworkImpl reference counter = %d", refCount);
|
|
return (refCount);
|
|
}
|
|
|
|
int VoENetworkImpl::RegisterExternalTransport(int channel,
|
|
Transport& transport)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
|
|
"SetExternalTransport(channel=%d, transport=0x%x)",
|
|
channel, &transport);
|
|
if (!_engineStatistics.Initialized())
|
|
{
|
|
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
voe::ScopedChannel sc(_channelManager, channel);
|
|
voe::Channel* channelPtr = sc.ChannelPtr();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"SetExternalTransport() failed to locate channel");
|
|
return -1;
|
|
}
|
|
return channelPtr->RegisterExternalTransport(transport);
|
|
}
|
|
|
|
int VoENetworkImpl::DeRegisterExternalTransport(int channel)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
|
|
"DeRegisterExternalTransport(channel=%d)", channel);
|
|
if (!_engineStatistics.Initialized())
|
|
{
|
|
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
voe::ScopedChannel sc(_channelManager, channel);
|
|
voe::Channel* channelPtr = sc.ChannelPtr();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"DeRegisterExternalTransport() failed to locate channel");
|
|
return -1;
|
|
}
|
|
return channelPtr->DeRegisterExternalTransport();
|
|
}
|
|
|
|
int VoENetworkImpl::ReceivedRTPPacket(int channel,
|
|
const void* data,
|
|
unsigned int length)
|
|
{
|
|
WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1),
|
|
"ReceivedRTPPacket(channel=%d, length=%u)", channel, length);
|
|
if (!_engineStatistics.Initialized())
|
|
{
|
|
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
if ((length < 12) || (length > 807))
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_INVALID_PACKET, kTraceError,
|
|
"ReceivedRTPPacket() invalid packet length");
|
|
return -1;
|
|
}
|
|
if (NULL == data)
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_INVALID_ARGUMENT, kTraceError,
|
|
"ReceivedRTPPacket() invalid data vector");
|
|
return -1;
|
|
}
|
|
voe::ScopedChannel sc(_channelManager, channel);
|
|
voe::Channel* channelPtr = sc.ChannelPtr();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"ReceivedRTPPacket() failed to locate channel");
|
|
return -1;
|
|
}
|
|
|
|
if (!channelPtr->ExternalTransport())
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_INVALID_OPERATION, kTraceError,
|
|
"ReceivedRTPPacket() external transport is not enabled");
|
|
return -1;
|
|
}
|
|
return channelPtr->ReceivedRTPPacket((const WebRtc_Word8*) data, length);
|
|
}
|
|
|
|
int VoENetworkImpl::ReceivedRTCPPacket(int channel, const void* data,
|
|
unsigned int length)
|
|
{
|
|
WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1),
|
|
"ReceivedRTCPPacket(channel=%d, length=%u)", channel, length);
|
|
if (!_engineStatistics.Initialized())
|
|
{
|
|
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
if (length < 4)
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_INVALID_PACKET, kTraceError,
|
|
"ReceivedRTCPPacket() invalid packet length");
|
|
return -1;
|
|
}
|
|
if (NULL == data)
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_INVALID_ARGUMENT, kTraceError,
|
|
"ReceivedRTCPPacket() invalid data vector");
|
|
return -1;
|
|
}
|
|
voe::ScopedChannel sc(_channelManager, channel);
|
|
voe::Channel* channelPtr = sc.ChannelPtr();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"ReceivedRTCPPacket() failed to locate channel");
|
|
return -1;
|
|
}
|
|
if (!channelPtr->ExternalTransport())
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_INVALID_OPERATION, kTraceError,
|
|
"ReceivedRTCPPacket() external transport is not enabled");
|
|
return -1;
|
|
}
|
|
return channelPtr->ReceivedRTCPPacket((const WebRtc_Word8*) data, length);
|
|
}
|
|
|
|
int VoENetworkImpl::GetSourceInfo(int channel,
|
|
int& rtpPort,
|
|
int& rtcpPort,
|
|
char ipAddr[64])
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
|
|
"GetSourceInfo(channel=%d, rtpPort=?, rtcpPort=?, ipAddr[]=?)",
|
|
channel);
|
|
#ifndef WEBRTC_EXTERNAL_TRANSPORT
|
|
if (!_engineStatistics.Initialized())
|
|
{
|
|
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
if (NULL == ipAddr)
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_INVALID_ARGUMENT, kTraceError,
|
|
"GetSourceInfo() invalid IP-address buffer");
|
|
return -1;
|
|
}
|
|
voe::ScopedChannel sc(_channelManager, channel);
|
|
voe::Channel* channelPtr = sc.ChannelPtr();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"GetSourceInfo() failed to locate channel");
|
|
return -1;
|
|
}
|
|
if (channelPtr->ExternalTransport())
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_EXTERNAL_TRANSPORT_ENABLED, kTraceError,
|
|
"GetSourceInfo() external transport is enabled");
|
|
return -1;
|
|
}
|
|
return channelPtr->GetSourceInfo(rtpPort, rtcpPort, ipAddr);
|
|
#else
|
|
_engineStatistics.SetLastError(
|
|
VE_EXTERNAL_TRANSPORT_ENABLED, kTraceWarning,
|
|
"GetSourceInfo() VoE is built for external transport");
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
int VoENetworkImpl::GetLocalIP(char ipAddr[64], bool ipv6)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
|
|
"GetLocalIP(ipAddr[]=?, ipv6=%d)", ipv6);
|
|
IPHONE_NOT_SUPPORTED();
|
|
#ifndef WEBRTC_EXTERNAL_TRANSPORT
|
|
if (!_engineStatistics.Initialized())
|
|
{
|
|
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
if (NULL == ipAddr)
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_INVALID_ARGUMENT, kTraceError,
|
|
"GetLocalIP() invalid IP-address buffer");
|
|
return -1;
|
|
}
|
|
|
|
// Create a temporary socket module to ensure that this method can be
|
|
// called also when no channels are created.
|
|
WebRtc_UWord8 numSockThreads(1);
|
|
UdpTransport* socketPtr =
|
|
UdpTransport::Create(
|
|
-1,
|
|
numSockThreads);
|
|
if (NULL == socketPtr)
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_SOCKET_TRANSPORT_MODULE_ERROR, kTraceError,
|
|
"GetLocalIP() failed to create socket module");
|
|
return -1;
|
|
}
|
|
|
|
WebRtc_Word8 localIPAddr[64];
|
|
|
|
if (ipv6)
|
|
{
|
|
WebRtc_UWord8 localIP[16];
|
|
if (socketPtr->LocalHostAddressIPV6(localIP) != 0)
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_INVALID_IP_ADDRESS, kTraceError,
|
|
"GetLocalIP() failed to retrieve local IP - 1");
|
|
return -1;
|
|
}
|
|
// Convert 128-bit address to character string (a:b:c:d:e:f:g:h)
|
|
sprintf(localIPAddr,
|
|
"%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x"
|
|
"%.2x:%.2x%.2x",
|
|
localIP[0], localIP[1], localIP[2], localIP[3], localIP[4],
|
|
localIP[5], localIP[6], localIP[7], localIP[8], localIP[9],
|
|
localIP[10], localIP[11], localIP[12], localIP[13],
|
|
localIP[14], localIP[15]);
|
|
}
|
|
else
|
|
{
|
|
WebRtc_UWord32 localIP(0);
|
|
// Read local IP (as 32-bit address) from the socket module
|
|
if (socketPtr->LocalHostAddress(localIP) != 0)
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_INVALID_IP_ADDRESS, kTraceError,
|
|
"GetLocalIP() failed to retrieve local IP - 2");
|
|
return -1;
|
|
}
|
|
// Convert 32-bit address to character string (x.y.z.w)
|
|
sprintf(localIPAddr, "%d.%d.%d.%d", (int) ((localIP >> 24) & 0x0ff),
|
|
(int) ((localIP >> 16) & 0x0ff),
|
|
(int) ((localIP >> 8) & 0x0ff),
|
|
(int) (localIP & 0x0ff));
|
|
}
|
|
|
|
strcpy(ipAddr, localIPAddr);
|
|
|
|
UdpTransport::Destroy(socketPtr);
|
|
|
|
WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, -1),
|
|
"GetLocalIP() => ipAddr=%s", ipAddr);
|
|
return 0;
|
|
#else
|
|
_engineStatistics.SetLastError(
|
|
VE_EXTERNAL_TRANSPORT_ENABLED, kTraceWarning,
|
|
"GetLocalIP() VoE is built for external transport");
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
int VoENetworkImpl::EnableIPv6(int channel)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
|
|
"EnableIPv6(channel=%d)", channel);
|
|
ANDROID_NOT_SUPPORTED();
|
|
IPHONE_NOT_SUPPORTED();
|
|
#ifndef WEBRTC_EXTERNAL_TRANSPORT
|
|
if (!_engineStatistics.Initialized())
|
|
{
|
|
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
voe::ScopedChannel sc(_channelManager, channel);
|
|
voe::Channel* channelPtr = sc.ChannelPtr();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"EnableIPv6() failed to locate channel");
|
|
return -1;
|
|
}
|
|
if (channelPtr->ExternalTransport())
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_EXTERNAL_TRANSPORT_ENABLED, kTraceError,
|
|
"EnableIPv6() external transport is enabled");
|
|
return -1;
|
|
}
|
|
return channelPtr->EnableIPv6();
|
|
#else
|
|
_engineStatistics.SetLastError(
|
|
VE_EXTERNAL_TRANSPORT_ENABLED, kTraceWarning,
|
|
"EnableIPv6() VoE is built for external transport");
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
bool VoENetworkImpl::IPv6IsEnabled(int channel)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
|
|
"IPv6IsEnabled(channel=%d)", channel);
|
|
#ifndef WEBRTC_EXTERNAL_TRANSPORT
|
|
if (!_engineStatistics.Initialized())
|
|
{
|
|
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
|
|
return false;
|
|
}
|
|
voe::ScopedChannel sc(_channelManager, channel);
|
|
voe::Channel* channelPtr = sc.ChannelPtr();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"IPv6IsEnabled() failed to locate channel");
|
|
return false;
|
|
}
|
|
if (channelPtr->ExternalTransport())
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_EXTERNAL_TRANSPORT_ENABLED, kTraceError,
|
|
"IPv6IsEnabled() external transport is enabled");
|
|
return false;
|
|
}
|
|
return channelPtr->IPv6IsEnabled();
|
|
#else
|
|
_engineStatistics.SetLastError(
|
|
VE_EXTERNAL_TRANSPORT_ENABLED, kTraceWarning,
|
|
"IPv6IsEnabled() VoE is built for external transport");
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
int VoENetworkImpl::SetSourceFilter(int channel,
|
|
int rtpPort,
|
|
int rtcpPort,
|
|
const char ipAddr[64])
|
|
{
|
|
(ipAddr == NULL) ? WEBRTC_TRACE(kTraceApiCall, kTraceVoice,
|
|
VoEId(_instanceId, -1),
|
|
"SetSourceFilter(channel=%d, rtpPort=%d,"
|
|
" rtcpPort=%d)",
|
|
channel, rtpPort, rtcpPort)
|
|
: WEBRTC_TRACE(kTraceApiCall, kTraceVoice,
|
|
VoEId(_instanceId, -1),
|
|
"SetSourceFilter(channel=%d, rtpPort=%d,"
|
|
" rtcpPort=%d, ipAddr=%s)",
|
|
channel, rtpPort, rtcpPort, ipAddr);
|
|
#ifndef WEBRTC_EXTERNAL_TRANSPORT
|
|
if (!_engineStatistics.Initialized())
|
|
{
|
|
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
if ((rtpPort < 0) || (rtpPort > 65535))
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_INVALID_PORT_NMBR, kTraceError,
|
|
"SetSourceFilter() invalid RTP port");
|
|
return -1;
|
|
}
|
|
if ((rtcpPort < 0) || (rtcpPort > 65535))
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_INVALID_PORT_NMBR, kTraceError,
|
|
"SetSourceFilter() invalid RTCP port");
|
|
return -1;
|
|
}
|
|
voe::ScopedChannel sc(_channelManager, channel);
|
|
voe::Channel* channelPtr = sc.ChannelPtr();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"SetSourceFilter() failed to locate channel");
|
|
return -1;
|
|
}
|
|
if (channelPtr->ExternalTransport())
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_EXTERNAL_TRANSPORT_ENABLED, kTraceError,
|
|
"SetSourceFilter() external transport is enabled");
|
|
return -1;
|
|
}
|
|
return channelPtr->SetSourceFilter(rtpPort, rtcpPort, ipAddr);
|
|
#else
|
|
_engineStatistics.SetLastError(
|
|
VE_EXTERNAL_TRANSPORT_ENABLED, kTraceWarning,
|
|
"SetSourceFilter() VoE is built for external transport");
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
int VoENetworkImpl::GetSourceFilter(int channel,
|
|
int& rtpPort,
|
|
int& rtcpPort,
|
|
char ipAddr[64])
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
|
|
"GetSourceFilter(channel=%d, rtpPort=?, rtcpPort=?, "
|
|
"ipAddr[]=?)",
|
|
channel);
|
|
#ifndef WEBRTC_EXTERNAL_TRANSPORT
|
|
if (!_engineStatistics.Initialized())
|
|
{
|
|
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
if (NULL == ipAddr)
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_INVALID_ARGUMENT, kTraceError,
|
|
"GetSourceFilter() invalid IP-address buffer");
|
|
return -1;
|
|
}
|
|
voe::ScopedChannel sc(_channelManager, channel);
|
|
voe::Channel* channelPtr = sc.ChannelPtr();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"GetSourceFilter() failed to locate channel");
|
|
return -1;
|
|
}
|
|
if (channelPtr->ExternalTransport())
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_EXTERNAL_TRANSPORT_ENABLED, kTraceError,
|
|
"GetSourceFilter() external transport is enabled");
|
|
return -1;
|
|
}
|
|
return channelPtr->GetSourceFilter(rtpPort, rtcpPort, ipAddr);
|
|
#else
|
|
_engineStatistics.SetLastError(
|
|
VE_EXTERNAL_TRANSPORT_ENABLED, kTraceWarning,
|
|
"GetSourceFilter() VoE is built for external transport");
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
int VoENetworkImpl::SetSendTOS(int channel,
|
|
int DSCP,
|
|
int priority,
|
|
bool useSetSockopt)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
|
|
"SetSendTOS(channel=%d, DSCP=%d, useSetSockopt=%d)",
|
|
channel, DSCP, useSetSockopt);
|
|
|
|
#if !defined(_WIN32) && !defined(WEBRTC_LINUX) && !defined(WEBRTC_MAC)
|
|
_engineStatistics.SetLastError(
|
|
VE_FUNC_NOT_SUPPORTED, kTraceWarning,
|
|
"SetSendTOS() is not supported on this platform");
|
|
return -1;
|
|
#endif
|
|
|
|
#ifndef WEBRTC_EXTERNAL_TRANSPORT
|
|
if (!_engineStatistics.Initialized())
|
|
{
|
|
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
if ((DSCP < 0) || (DSCP > 63))
|
|
{
|
|
_engineStatistics.SetLastError(VE_INVALID_ARGUMENT, kTraceError,
|
|
"SetSendTOS() Invalid DSCP value");
|
|
return -1;
|
|
}
|
|
#if defined(_WIN32) || defined(WEBRTC_LINUX)
|
|
if ((priority < -1) || (priority > 7))
|
|
{
|
|
_engineStatistics.SetLastError(VE_INVALID_ARGUMENT, kTraceError,
|
|
"SetSendTOS() Invalid priority value");
|
|
return -1;
|
|
}
|
|
#else
|
|
if (-1 != priority)
|
|
{
|
|
_engineStatistics.SetLastError(VE_INVALID_ARGUMENT, kTraceError,
|
|
"SetSendTOS() priority not supported");
|
|
return -1;
|
|
}
|
|
#endif
|
|
#if defined(_WIN32)
|
|
if ((priority >= 0) && useSetSockopt)
|
|
{
|
|
// On Windows, priority and useSetSockopt cannot be combined
|
|
_engineStatistics.SetLastError(
|
|
VE_INVALID_ARGUMENT, kTraceError,
|
|
"SetSendTOS() priority and useSetSockopt conflict");
|
|
return -1;
|
|
}
|
|
#endif
|
|
voe::ScopedChannel sc(_channelManager, channel);
|
|
voe::Channel* channelPtr = sc.ChannelPtr();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"SetSendTOS() failed to locate channel");
|
|
return -1;
|
|
}
|
|
if (channelPtr->ExternalTransport())
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_EXTERNAL_TRANSPORT_ENABLED, kTraceError,
|
|
"SetSendTOS() external transport is enabled");
|
|
return -1;
|
|
}
|
|
#if defined(WEBRTC_LINUX) || defined(WEBRTC_MAC)
|
|
useSetSockopt = true;
|
|
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,-1),
|
|
" force useSetSockopt=true since there is no alternative"
|
|
" implementation");
|
|
#endif
|
|
|
|
return channelPtr->SetSendTOS(DSCP, priority, useSetSockopt);
|
|
#else
|
|
_engineStatistics.SetLastError(
|
|
VE_EXTERNAL_TRANSPORT_ENABLED, kTraceWarning,
|
|
"SetSendTOS() VoE is built for external transport");
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
int VoENetworkImpl::GetSendTOS(int channel,
|
|
int& DSCP,
|
|
int& priority,
|
|
bool& useSetSockopt)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
|
|
"GetSendTOS(channel=%d)", channel);
|
|
|
|
#if !defined(_WIN32) && !defined(WEBRTC_LINUX) && !defined(WEBRTC_MAC)
|
|
_engineStatistics.SetLastError(
|
|
VE_FUNC_NOT_SUPPORTED, kTraceWarning,
|
|
"GetSendTOS() is not supported on this platform");
|
|
return -1;
|
|
#endif
|
|
#ifndef WEBRTC_EXTERNAL_TRANSPORT
|
|
if (!_engineStatistics.Initialized())
|
|
{
|
|
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
voe::ScopedChannel sc(_channelManager, channel);
|
|
voe::Channel* channelPtr = sc.ChannelPtr();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"GetSendTOS() failed to locate channel");
|
|
return -1;
|
|
}
|
|
if (channelPtr->ExternalTransport())
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_EXTERNAL_TRANSPORT_ENABLED, kTraceError,
|
|
"GetSendTOS() external transport is enabled");
|
|
return -1;
|
|
}
|
|
return channelPtr->GetSendTOS(DSCP, priority, useSetSockopt);
|
|
#else
|
|
_engineStatistics.SetLastError(
|
|
VE_EXTERNAL_TRANSPORT_ENABLED, kTraceWarning,
|
|
"GetSendTOS() VoE is built for external transport");
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
int VoENetworkImpl::SetSendGQoS(int channel,
|
|
bool enable,
|
|
int serviceType,
|
|
int overrideDSCP)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
|
|
"SetSendGQOS(channel=%d, enable=%d, serviceType=%d,"
|
|
" overrideDSCP=%d)",
|
|
channel, (int) enable, serviceType, overrideDSCP);
|
|
ANDROID_NOT_SUPPORTED(); IPHONE_NOT_SUPPORTED();
|
|
#if !defined(_WIN32)
|
|
_engineStatistics.SetLastError(
|
|
VE_FUNC_NOT_SUPPORTED, kTraceWarning,
|
|
"SetSendGQOS() is not supported on this platform");
|
|
return -1;
|
|
#elif !defined(WEBRTC_EXTERNAL_TRANSPORT)
|
|
if (!_engineStatistics.Initialized())
|
|
{
|
|
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
voe::ScopedChannel sc(_channelManager, channel);
|
|
voe::Channel* channelPtr = sc.ChannelPtr();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"SetSendGQOS() failed to locate channel");
|
|
return -1;
|
|
}
|
|
if (channelPtr->ExternalTransport())
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_EXTERNAL_TRANSPORT_ENABLED, kTraceError,
|
|
"SetSendGQOS() external transport is enabled");
|
|
return -1;
|
|
}
|
|
return channelPtr->SetSendGQoS(enable, serviceType, overrideDSCP);
|
|
#else
|
|
_engineStatistics.SetLastError(
|
|
VE_EXTERNAL_TRANSPORT_ENABLED, kTraceWarning,
|
|
"SetSendGQOS() VoE is built for external transport");
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
int VoENetworkImpl::GetSendGQoS(int channel,
|
|
bool& enabled,
|
|
int& serviceType,
|
|
int& overrideDSCP)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
|
|
"GetSendGQOS(channel=%d)", channel);
|
|
ANDROID_NOT_SUPPORTED();
|
|
IPHONE_NOT_SUPPORTED();
|
|
#if !defined(_WIN32)
|
|
_engineStatistics.SetLastError(
|
|
VE_FUNC_NOT_SUPPORTED, kTraceWarning,
|
|
"GetSendGQOS() is not supported on this platform");
|
|
return -1;
|
|
#elif !defined(WEBRTC_EXTERNAL_TRANSPORT)
|
|
if (!_engineStatistics.Initialized())
|
|
{
|
|
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
voe::ScopedChannel sc(_channelManager, channel);
|
|
voe::Channel* channelPtr = sc.ChannelPtr();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"GetSendGQOS() failed to locate channel");
|
|
return -1;
|
|
}
|
|
if (channelPtr->ExternalTransport())
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_EXTERNAL_TRANSPORT_ENABLED, kTraceError,
|
|
"GetSendGQOS() external transport is enabled");
|
|
return -1;
|
|
}
|
|
return channelPtr->GetSendGQoS(enabled, serviceType, overrideDSCP);
|
|
#else
|
|
_engineStatistics.SetLastError(
|
|
VE_EXTERNAL_TRANSPORT_ENABLED, kTraceWarning,
|
|
"GetSendGQOS() VoE is built for external transport");
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
int VoENetworkImpl::SetPacketTimeoutNotification(int channel,
|
|
bool enable,
|
|
int timeoutSeconds)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
|
|
"SetPacketTimeoutNotification(channel=%d, enable=%d, "
|
|
"timeoutSeconds=%d)",
|
|
channel, (int) enable, timeoutSeconds);
|
|
if (!_engineStatistics.Initialized())
|
|
{
|
|
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
if (enable &&
|
|
((timeoutSeconds < kVoiceEngineMinPacketTimeoutSec) ||
|
|
(timeoutSeconds > kVoiceEngineMaxPacketTimeoutSec)))
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_INVALID_ARGUMENT, kTraceError,
|
|
"SetPacketTimeoutNotification() invalid timeout size");
|
|
return -1;
|
|
}
|
|
voe::ScopedChannel sc(_channelManager, channel);
|
|
voe::Channel* channelPtr = sc.ChannelPtr();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"SetPacketTimeoutNotification() failed to locate channel");
|
|
return -1;
|
|
}
|
|
return channelPtr->SetPacketTimeoutNotification(enable, timeoutSeconds);
|
|
}
|
|
|
|
int VoENetworkImpl::GetPacketTimeoutNotification(int channel,
|
|
bool& enabled,
|
|
int& timeoutSeconds)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
|
|
"GetPacketTimeoutNotification(channel=%d, enabled=?,"
|
|
" timeoutSeconds=?)", channel);
|
|
if (!_engineStatistics.Initialized())
|
|
{
|
|
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
voe::ScopedChannel sc(_channelManager, channel);
|
|
voe::Channel* channelPtr = sc.ChannelPtr();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"GetPacketTimeoutNotification() failed to locate channel");
|
|
return -1;
|
|
}
|
|
return channelPtr->GetPacketTimeoutNotification(enabled, timeoutSeconds);
|
|
}
|
|
|
|
int VoENetworkImpl::RegisterDeadOrAliveObserver(int channel,
|
|
VoEConnectionObserver&
|
|
observer)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
|
|
"RegisterDeadOrAliveObserver(channel=%d, observer=0x%x)",
|
|
channel, &observer);
|
|
if (!_engineStatistics.Initialized())
|
|
{
|
|
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
voe::ScopedChannel sc(_channelManager, channel);
|
|
voe::Channel* channelPtr = sc.ChannelPtr();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"RegisterDeadOrAliveObserver() failed to locate channel");
|
|
return -1;
|
|
}
|
|
return channelPtr->RegisterDeadOrAliveObserver(observer);
|
|
}
|
|
|
|
int VoENetworkImpl::DeRegisterDeadOrAliveObserver(int channel)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
|
|
"DeRegisterDeadOrAliveObserver(channel=%d)", channel);
|
|
if (!_engineStatistics.Initialized())
|
|
{
|
|
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
voe::ScopedChannel sc(_channelManager, channel);
|
|
voe::Channel* channelPtr = sc.ChannelPtr();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"DeRegisterDeadOrAliveObserver() failed to locate channel");
|
|
return -1;
|
|
}
|
|
return channelPtr->DeRegisterDeadOrAliveObserver();
|
|
}
|
|
|
|
int VoENetworkImpl::SetPeriodicDeadOrAliveStatus(int channel, bool enable,
|
|
int sampleTimeSeconds)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
|
|
"SetPeriodicDeadOrAliveStatus(channel=%d, enable=%d,"
|
|
" sampleTimeSeconds=%d)",
|
|
channel, enable, sampleTimeSeconds);
|
|
if (!_engineStatistics.Initialized())
|
|
{
|
|
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
if (enable &&
|
|
((sampleTimeSeconds < kVoiceEngineMinSampleTimeSec) ||
|
|
(sampleTimeSeconds > kVoiceEngineMaxSampleTimeSec)))
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_INVALID_ARGUMENT, kTraceError,
|
|
"SetPeriodicDeadOrAliveStatus() invalid sample time");
|
|
return -1;
|
|
}
|
|
voe::ScopedChannel sc(_channelManager, channel);
|
|
voe::Channel* channelPtr = sc.ChannelPtr();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"SetPeriodicDeadOrAliveStatus() failed to locate channel");
|
|
return -1;
|
|
}
|
|
return channelPtr->SetPeriodicDeadOrAliveStatus(enable, sampleTimeSeconds);
|
|
}
|
|
|
|
int VoENetworkImpl::GetPeriodicDeadOrAliveStatus(int channel,
|
|
bool& enabled,
|
|
int& sampleTimeSeconds)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
|
|
"GetPeriodicDeadOrAliveStatus(channel=%d, enabled=?,"
|
|
" sampleTimeSeconds=?)", channel);
|
|
if (!_engineStatistics.Initialized())
|
|
{
|
|
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
voe::ScopedChannel sc(_channelManager, channel);
|
|
voe::Channel* channelPtr = sc.ChannelPtr();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"GetPeriodicDeadOrAliveStatus() failed to locate channel");
|
|
return -1;
|
|
}
|
|
return channelPtr->GetPeriodicDeadOrAliveStatus(enabled,
|
|
sampleTimeSeconds);
|
|
}
|
|
|
|
int VoENetworkImpl::SendUDPPacket(int channel,
|
|
const void* data,
|
|
unsigned int length,
|
|
int& transmittedBytes,
|
|
bool useRtcpSocket)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
|
|
"SendUDPPacket(channel=%d, data=0x%x, length=%u, useRTCP=%d)",
|
|
channel, data, length, useRtcpSocket);
|
|
#ifndef WEBRTC_EXTERNAL_TRANSPORT
|
|
if (!_engineStatistics.Initialized())
|
|
{
|
|
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
if (NULL == data)
|
|
{
|
|
_engineStatistics.SetLastError(VE_INVALID_ARGUMENT, kTraceError,
|
|
"SendUDPPacket() invalid data buffer");
|
|
return -1;
|
|
}
|
|
if (0 == length)
|
|
{
|
|
_engineStatistics.SetLastError(VE_INVALID_PACKET, kTraceError,
|
|
"SendUDPPacket() invalid packet size");
|
|
return -1;
|
|
}
|
|
voe::ScopedChannel sc(_channelManager, channel);
|
|
voe::Channel* channelPtr = sc.ChannelPtr();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_engineStatistics.SetLastError(
|
|
VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"SendUDPPacket() failed to locate channel");
|
|
return -1;
|
|
}
|
|
return channelPtr->SendUDPPacket(data,
|
|
length,
|
|
transmittedBytes,
|
|
useRtcpSocket);
|
|
#else
|
|
_engineStatistics.SetLastError(
|
|
VE_EXTERNAL_TRANSPORT_ENABLED, kTraceWarning,
|
|
"SendUDPPacket() VoE is built for external transport");
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
#endif // WEBRTC_VOICE_ENGINE_NETWORK_API
|
|
|
|
} // namespace webrtc
|