blob: a452f0478521823af496a52b1b0ae6b3aa260983 [file] [log] [blame]
/*
* 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 "video_engine/vie_network_impl.h"
#include <stdio.h>
#if (defined(WIN32_) || defined(WIN64_))
#include <qos.h>
#endif
#include "engine_configurations.h"
#include "system_wrappers/interface/trace.h"
#include "video_engine/include/vie_errors.h"
#include "video_engine/vie_channel.h"
#include "video_engine/vie_channel_manager.h"
#include "video_engine/vie_defines.h"
#include "video_engine/vie_encoder.h"
#include "video_engine/vie_impl.h"
namespace webrtc {
ViENetwork* ViENetwork::GetInterface(VideoEngine* video_engine) {
#ifdef WEBRTC_VIDEO_ENGINE_NETWORK_API
if (!video_engine) {
return NULL;
}
VideoEngineImpl* vie_impl = reinterpret_cast<VideoEngineImpl*>(video_engine);
ViENetworkImpl* vie_networkImpl = vie_impl;
// Increase ref count.
(*vie_networkImpl)++;
return vie_networkImpl;
#else
return NULL;
#endif
}
int ViENetworkImpl::Release() {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, instance_id_,
"ViENetwork::Release()");
// Decrease ref count.
(*this)--;
WebRtc_Word32 ref_count = GetCount();
if (ref_count < 0) {
WEBRTC_TRACE(kTraceWarning, kTraceVideo, instance_id_,
"ViENetwork release too many times");
SetLastError(kViEAPIDoesNotExist);
return -1;
}
WEBRTC_TRACE(kTraceInfo, kTraceVideo, instance_id_,
"ViENetwork reference count: %d", ref_count);
return ref_count;
}
ViENetworkImpl::ViENetworkImpl() {
WEBRTC_TRACE(kTraceMemory, kTraceVideo, instance_id_,
"ViENetworkImpl::ViENetworkImpl() Ctor");
}
ViENetworkImpl::~ViENetworkImpl() {
WEBRTC_TRACE(kTraceMemory, kTraceVideo, instance_id_,
"ViENetworkImpl::~ViENetworkImpl() Dtor");
}
int ViENetworkImpl::SetLocalReceiver(const int video_channel,
const unsigned short rtp_port,
const unsigned short rtcp_port,
const char* ip_address) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_, video_channel),
"%s(channel: %d, rtp_port: %u, rtcp_port: %u, ip_address: %s)",
__FUNCTION__, video_channel, rtp_port, rtcp_port, ip_address);
if (!Initialized()) {
SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_),
"%s - ViE instance %d not initialized", __FUNCTION__,
instance_id_);
return -1;
}
ViEChannelManagerScoped cs(channel_manager_);
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {
// The channel doesn't exists.
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"Channel doesn't exist");
SetLastError(kViENetworkInvalidChannelId);
return -1;
}
if (vie_channel->Receiving()) {
SetLastError(kViENetworkAlreadyReceiving);
return -1;
}
if (vie_channel->SetLocalReceiver(rtp_port, rtcp_port, ip_address) != 0) {
SetLastError(kViENetworkUnknownError);
return -1;
}
return 0;
}
int ViENetworkImpl::GetLocalReceiver(const int video_channel,
unsigned short& rtp_port,
unsigned short& rtcp_port,
char* ip_address) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_, video_channel),
"%s(channel: %d)", __FUNCTION__, video_channel);
ViEChannelManagerScoped cs(channel_manager_);
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"Channel doesn't exist");
SetLastError(kViENetworkInvalidChannelId);
return -1;
}
if (vie_channel->GetLocalReceiver(rtp_port, rtcp_port, ip_address) != 0) {
SetLastError(kViENetworkLocalReceiverNotSet);
return -1;
}
return 0;
}
int ViENetworkImpl::SetSendDestination(const int video_channel,
const char* ip_address,
const unsigned short rtp_port,
const unsigned short rtcp_port,
const unsigned short source_rtp_port,
const unsigned short source_rtcp_port) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_, video_channel),
"%s(channel: %d, ip_address: %s, rtp_port: %u, rtcp_port: %u, "
"sourceRtpPort: %u, source_rtcp_port: %u)",
__FUNCTION__, video_channel, ip_address, rtp_port, rtcp_port,
source_rtp_port, source_rtcp_port);
if (!Initialized()) {
SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_),
"%s - ViE instance %d not initialized", __FUNCTION__,
instance_id_);
return -1;
}
ViEChannelManagerScoped cs(channel_manager_);
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"%s Channel doesn't exist", __FUNCTION__);
SetLastError(kViENetworkInvalidChannelId);
return -1;
}
if (vie_channel->Sending()) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"%s Channel already sending.", __FUNCTION__);
SetLastError(kViENetworkAlreadySending);
return -1;
}
if (vie_channel->SetSendDestination(ip_address, rtp_port, rtcp_port,
source_rtp_port,
source_rtcp_port) != 0) {
SetLastError(kViENetworkUnknownError);
return -1;
}
return 0;
}
int ViENetworkImpl::GetSendDestination(const int video_channel,
char* ip_address,
unsigned short& rtp_port,
unsigned short& rtcp_port,
unsigned short& source_rtp_port,
unsigned short& source_rtcp_port) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_, video_channel),
"%s(channel: %d)", __FUNCTION__, video_channel);
ViEChannelManagerScoped cs(channel_manager_);
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {
WEBRTC_TRACE(kTraceError, kTraceVideo,
ViEId(instance_id_, video_channel), "Channel doesn't exist");
SetLastError(kViENetworkInvalidChannelId);
return -1;
}
if (vie_channel->GetSendDestination(ip_address, rtp_port, rtcp_port,
source_rtp_port,
source_rtcp_port) != 0) {
SetLastError(kViENetworkDestinationNotSet);
return -1;
}
return 0;
}
int ViENetworkImpl::RegisterSendTransport(const int video_channel,
Transport& transport) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_, video_channel),
"%s(channel: %d)", __FUNCTION__, video_channel);
if (!Initialized()) {
SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_),
"%s - ViE instance %d not initialized", __FUNCTION__,
instance_id_);
return -1;
}
ViEChannelManagerScoped cs(channel_manager_);
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"%s Channel doesn't exist", __FUNCTION__);
SetLastError(kViENetworkInvalidChannelId);
return -1;
}
if (vie_channel->Sending()) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"%s Channel already sending.", __FUNCTION__);
SetLastError(kViENetworkAlreadySending);
return -1;
}
if (vie_channel->RegisterSendTransport(transport) != 0) {
SetLastError(kViENetworkUnknownError);
return -1;
}
return 0;
}
int ViENetworkImpl::DeregisterSendTransport(const int video_channel) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_, video_channel),
"%s(channel: %d)", __FUNCTION__, video_channel);
ViEChannelManagerScoped cs(channel_manager_);
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"%s Channel doesn't exist", __FUNCTION__);
SetLastError(kViENetworkInvalidChannelId);
return -1;
}
if (vie_channel->Sending()) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"%s Channel already sending", __FUNCTION__);
SetLastError(kViENetworkAlreadySending);
return -1;
}
if (vie_channel->DeregisterSendTransport() != 0) {
SetLastError(kViENetworkUnknownError);
return -1;
}
return 0;
}
int ViENetworkImpl::ReceivedRTPPacket(const int video_channel, const void* data,
const int length) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_, video_channel),
"%s(channel: %d, data: -, length: %d)", __FUNCTION__,
video_channel, length);
if (!Initialized()) {
SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_),
"%s - ViE instance %d not initialized", __FUNCTION__,
instance_id_);
return -1;
}
ViEChannelManagerScoped cs(channel_manager_);
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {
// The channel doesn't exists
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"Channel doesn't exist");
SetLastError(kViENetworkInvalidChannelId);
return -1;
}
return vie_channel->ReceivedRTPPacket(data, length);
}
int ViENetworkImpl::ReceivedRTCPPacket(const int video_channel,
const void* data, const int length) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_, video_channel),
"%s(channel: %d, data: -, length: %d)", __FUNCTION__,
video_channel, length);
if (!Initialized()) {
SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_),
"%s - ViE instance %d not initialized", __FUNCTION__,
instance_id_);
return -1;
}
ViEChannelManagerScoped cs(channel_manager_);
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"Channel doesn't exist");
SetLastError(kViENetworkInvalidChannelId);
return -1;
}
return vie_channel->ReceivedRTCPPacket(data, length);
}
int ViENetworkImpl::GetSourceInfo(const int video_channel,
unsigned short& rtp_port,
unsigned short& rtcp_port, char* ip_address,
unsigned int ip_address_length) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_, video_channel),
"%s(channel: %d)", __FUNCTION__, video_channel);
ViEChannelManagerScoped cs(channel_manager_);
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"Channel doesn't exist");
SetLastError(kViENetworkInvalidChannelId);
return -1;
}
if (vie_channel->GetSourceInfo(rtp_port, rtcp_port, ip_address,
ip_address_length) != 0) {
SetLastError(kViENetworkUnknownError);
return -1;
}
return 0;
}
int ViENetworkImpl::GetLocalIP(char ip_address[64], bool ipv6) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_),
"%s( ip_address, ipV6: %d)", __FUNCTION__, ipv6);
#ifndef WEBRTC_EXTERNAL_TRANSPORT
if (!Initialized()) {
SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_),
"%s - ViE instance %d not initialized", __FUNCTION__,
instance_id_);
return -1;
}
if (!ip_address) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_),
"%s: No argument", __FUNCTION__);
SetLastError(kViENetworkInvalidArgument);
return -1;
}
WebRtc_UWord8 num_socket_threads = 1;
UdpTransport* socket_transport = UdpTransport::Create(
ViEModuleId(instance_id_, -1), num_socket_threads);
if (!socket_transport) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_),
"%s: Could not create socket module", __FUNCTION__);
SetLastError(kViENetworkUnknownError);
return -1;
}
WebRtc_Word8 local_ip_address[64];
if (ipv6) {
WebRtc_UWord8 local_ip[16];
if (socket_transport->LocalHostAddressIPV6(local_ip) != 0) {
UdpTransport::Destroy(socket_transport);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_),
"%s: Could not get local IP", __FUNCTION__);
SetLastError(kViENetworkUnknownError);
return -1;
}
// Convert 128-bit address to character string (a:b:c:d:e:f:g:h).
sprintf(local_ip_address,
"%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:"
"%.2x%.2x",
local_ip[0], local_ip[1], local_ip[2], local_ip[3], local_ip[4],
local_ip[5], local_ip[6], local_ip[7], local_ip[8], local_ip[9],
local_ip[10], local_ip[11], local_ip[12], local_ip[13],
local_ip[14], local_ip[15]);
} else {
WebRtc_UWord32 local_ip = 0;
if (socket_transport->LocalHostAddress(local_ip) != 0) {
UdpTransport::Destroy(socket_transport);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_),
"%s: Could not get local IP", __FUNCTION__);
SetLastError(kViENetworkUnknownError);
return -1;
}
// Convert 32-bit address to character string (x.y.z.w).
sprintf(local_ip_address, "%d.%d.%d.%d",
static_cast<int>((local_ip >> 24) & 0x0ff),
static_cast<int>((local_ip >> 16) & 0x0ff),
static_cast<int>((local_ip >> 8) & 0x0ff),
static_cast<int>(local_ip & 0x0ff));
}
strcpy(ip_address, local_ip_address);
UdpTransport::Destroy(socket_transport);
WEBRTC_TRACE(kTraceStateInfo, kTraceVideo, ViEId(instance_id_),
"%s: local ip = %s", __FUNCTION__, local_ip_address);
return 0;
#else
WEBRTC_TRACE(kTraceStateInfo, kTraceVideo, ViEId(instance_id_),
"%s: not available for external transport", __FUNCTION__);
return -1;
#endif
}
int ViENetworkImpl::EnableIPv6(int video_channel) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_, video_channel),
"%s(channel: %d)", __FUNCTION__, video_channel);
ViEChannelManagerScoped cs(channel_manager_);
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"Channel doesn't exist");
SetLastError(kViENetworkInvalidChannelId);
return -1;
}
if (vie_channel->EnableIPv6() != 0) {
SetLastError(kViENetworkUnknownError);
return -1;
}
return 0;
}
bool ViENetworkImpl::IsIPv6Enabled(int video_channel) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_, video_channel),
"%s(channel: %d)", __FUNCTION__, video_channel);
ViEChannelManagerScoped cs(channel_manager_);
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"Channel doesn't exist");
SetLastError(kViENetworkInvalidChannelId);
return false;
}
return vie_channel->IsIPv6Enabled();
}
int ViENetworkImpl::SetSourceFilter(const int video_channel,
const unsigned short rtp_port,
const unsigned short rtcp_port,
const char* ip_address) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_, video_channel),
"%s(channel: %d, rtp_port: %u, rtcp_port: %u, ip_address: %s)",
__FUNCTION__, video_channel, rtp_port, rtcp_port, ip_address);
ViEChannelManagerScoped cs(channel_manager_);
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"Channel doesn't exist");
SetLastError(kViENetworkInvalidChannelId);
return -1;
}
if (vie_channel->SetSourceFilter(rtp_port, rtcp_port, ip_address) != 0) {
SetLastError(kViENetworkUnknownError);
return -1;
}
return 0;
}
int ViENetworkImpl::GetSourceFilter(const int video_channel,
unsigned short& rtp_port,
unsigned short& rtcp_port,
char* ip_address) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_, video_channel),
"%s(channel: %d)", __FUNCTION__, video_channel);
ViEChannelManagerScoped cs(channel_manager_);
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"Channel doesn't exist");
SetLastError(kViENetworkInvalidChannelId);
return -1;
}
if (vie_channel->GetSourceFilter(rtp_port, rtcp_port, ip_address) != 0) {
SetLastError(kViENetworkUnknownError);
return -1;
}
return 0;
}
int ViENetworkImpl::SetSendToS(const int video_channel, const int DSCP,
const bool use_set_sockOpt = false) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_, video_channel),
"%s(channel: %d, DSCP: %d, use_set_sockOpt: %d)", __FUNCTION__,
video_channel, DSCP, use_set_sockOpt);
ViEChannelManagerScoped cs(channel_manager_);
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"Channel doesn't exist");
SetLastError(kViENetworkInvalidChannelId);
return -1;
}
#if defined(WEBRTC_LINUX) || defined(WEBRTC_MAC)
WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(instance_id_, video_channel),
" force use_set_sockopt=true since there is no alternative"
" implementation");
if (vie_channel->SetToS(DSCP, true) != 0) {
#else
if (vie_channel->SetToS(DSCP, use_set_sockOpt) != 0) {
#endif
SetLastError(kViENetworkUnknownError);
return -1;
}
return 0;
}
int ViENetworkImpl::GetSendToS(const int video_channel, int& DSCP,
bool& use_set_sockOpt) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_, video_channel),
"%s(channel: %d)", __FUNCTION__, video_channel);
ViEChannelManagerScoped cs(channel_manager_);
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"Channel doesn't exist");
SetLastError(kViENetworkInvalidChannelId);
return -1;
}
if (vie_channel->GetToS((WebRtc_Word32&) DSCP, use_set_sockOpt) != 0) {
SetLastError(kViENetworkUnknownError);
return -1;
}
return 0;
}
int ViENetworkImpl::SetSendGQoS(const int video_channel, const bool enable,
const int service_type,
const int overrideDSCP) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_, video_channel),
"%s(channel: %d, enable: %d, service_type: %d, "
"overrideDSCP: %d)", __FUNCTION__, video_channel, enable,
service_type, overrideDSCP);
if (!Initialized()) {
SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_),
"%s - ViE instance %d not initialized", __FUNCTION__,
instance_id_);
return -1;
}
#if (defined(WIN32_) || defined(WIN64_))
// Sanity check. We might crash if testing and relying on an OS socket error.
if (enable &&
(service_type != SERVICETYPE_BESTEFFORT) &&
(service_type != SERVICETYPE_CONTROLLEDLOAD) &&
(service_type != SERVICETYPE_GUARANTEED) &&
(service_type != SERVICETYPE_QUALITATIVE)) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_, video_channel),
"%s: service type %d not supported", __FUNCTION__,
video_channel, service_type);
SetLastError(kViENetworkServiceTypeNotSupported);
return -1;
}
ViEChannelManagerScoped cs(channel_manager_);
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"Channel doesn't exist");
SetLastError(kViENetworkInvalidChannelId);
return -1;
}
ViEEncoder* vie_encoder = cs.Encoder(video_channel);
if (!vie_encoder) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"Channel doesn't exist");
SetLastError(kViENetworkInvalidChannelId);
return -1;
}
VideoCodec video_codec;
if (vie_encoder->GetEncoder(video_codec) != 0) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"%s: Could not get max bitrate for the channel",
__FUNCTION__);
SetLastError(kViENetworkSendCodecNotSet);
return -1;
}
if (vie_channel->SetSendGQoS(enable, service_type, video_codec.maxBitrate,
overrideDSCP) != 0) {
SetLastError(kViENetworkUnknownError);
return -1;
}
return 0;
#else
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_, video_channel),
"%s: Not supported", __FUNCTION__);
SetLastError(kViENetworkNotSupported);
return -1;
#endif
}
int ViENetworkImpl::GetSendGQoS(const int video_channel, bool& enabled,
int& service_type, int& overrideDSCP) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_, video_channel),
"%s(channel: %d)", __FUNCTION__, video_channel);
ViEChannelManagerScoped cs(channel_manager_);
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"Channel doesn't exist");
SetLastError(kViENetworkInvalidChannelId);
return -1;
}
if (vie_channel->GetSendGQoS(enabled, service_type, overrideDSCP) != 0) {
SetLastError(kViENetworkUnknownError);
return -1;
}
return 0;
}
int ViENetworkImpl::SetMTU(int video_channel, unsigned int mtu) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_, video_channel),
"%s(channel: %d, mtu: %u)", __FUNCTION__, video_channel, mtu);
ViEChannelManagerScoped cs(channel_manager_);
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"Channel doesn't exist");
SetLastError(kViENetworkInvalidChannelId);
return -1;
}
if (vie_channel->SetMTU(mtu) != 0) {
SetLastError(kViENetworkUnknownError);
return -1;
}
return 0;
}
int ViENetworkImpl::SetPacketTimeoutNotification(const int video_channel,
bool enable,
int timeout_seconds) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_, video_channel),
"%s(channel: %d, enable: %d, timeout_seconds: %u)",
__FUNCTION__, video_channel, enable, timeout_seconds);
ViEChannelManagerScoped cs(channel_manager_);
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"Channel doesn't exist");
SetLastError(kViENetworkInvalidChannelId);
return -1;
}
if (vie_channel->SetPacketTimeoutNotification(enable,
timeout_seconds) != 0) {
SetLastError(kViENetworkUnknownError);
return -1;
}
return 0;
}
int ViENetworkImpl::RegisterObserver(const int video_channel,
ViENetworkObserver& observer) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_, video_channel),
"%s(channel: %d)", __FUNCTION__, video_channel);
ViEChannelManagerScoped cs(channel_manager_);
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"Channel doesn't exist");
SetLastError(kViENetworkInvalidChannelId);
return -1;
}
if (vie_channel->RegisterNetworkObserver(&observer) != 0) {
SetLastError(kViENetworkObserverAlreadyRegistered);
return -1;
}
return 0;
}
int ViENetworkImpl::DeregisterObserver(const int video_channel) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_, video_channel),
"%s(channel: %d)", __FUNCTION__, video_channel);
ViEChannelManagerScoped cs(channel_manager_);
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"Channel doesn't exist");
SetLastError(kViENetworkInvalidChannelId);
return -1;
}
if (!vie_channel->NetworkObserverRegistered()) {
SetLastError(kViENetworkObserverNotRegistered);
return -1;
}
return vie_channel->RegisterNetworkObserver(NULL);
}
int ViENetworkImpl::SetPeriodicDeadOrAliveStatus(
const int video_channel,
bool enable,
unsigned int sample_time_seconds) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_, video_channel),
"%s(channel: %d, enable: %d, sample_time_seconds: %ul)",
__FUNCTION__, video_channel, enable, sample_time_seconds);
ViEChannelManagerScoped cs(channel_manager_);
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"Channel doesn't exist");
SetLastError(kViENetworkInvalidChannelId);
return -1;
}
if (!vie_channel->NetworkObserverRegistered()) {
SetLastError(kViENetworkObserverNotRegistered);
return -1;
}
if (vie_channel->SetPeriodicDeadOrAliveStatus(enable, sample_time_seconds)
!= 0) {
SetLastError(kViENetworkUnknownError);
return -1;
}
return 0;
}
int ViENetworkImpl::SendUDPPacket(const int video_channel, const void* data,
const unsigned int length,
int& transmitted_bytes,
bool use_rtcp_socket = false) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_, video_channel),
"%s(channel: %d, data: -, length: %d, transmitter_bytes: -, "
"useRtcpSocket: %d)", __FUNCTION__, video_channel, length,
use_rtcp_socket);
if (!Initialized()) {
SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_),
"%s - ViE instance %d not initialized", __FUNCTION__,
instance_id_);
return -1;
}
ViEChannelManagerScoped cs(channel_manager_);
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
"Channel doesn't exist");
SetLastError(kViENetworkInvalidChannelId);
return -1;
}
if (vie_channel->SendUDPPacket((const WebRtc_Word8*) data, length,
(WebRtc_Word32&) transmitted_bytes,
use_rtcp_socket) < 0) {
SetLastError(kViENetworkUnknownError);
return -1;
}
return 0;
}
} // namespace webrtc