| /* |
| * 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(_engineStatistics); |
| 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(_engineStatistics); |
| 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(_engineStatistics); |
| 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 |
