a1bfcad3a3
uint8_t gets interpreted as char and printed as such, instead of being printed in decimal, casting them to int allows us to read what payload types are actually used without converting them from ASCII first. BUG=chromium:390874 R=stefan@webrtc.org Review URL: https://webrtc-codereview.appspot.com/13919004 git-svn-id: http://webrtc.googlecode.com/svn/trunk@6662 4adac7df-926f-26a2-2b94-8c16560cd09d
1079 lines
37 KiB
C++
1079 lines
37 KiB
C++
/*
|
|
* Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#include "webrtc/video_engine/vie_rtp_rtcp_impl.h"
|
|
|
|
#include "webrtc/engine_configurations.h"
|
|
#include "webrtc/system_wrappers/interface/file_wrapper.h"
|
|
#include "webrtc/system_wrappers/interface/logging.h"
|
|
#include "webrtc/video_engine/include/vie_errors.h"
|
|
#include "webrtc/video_engine/vie_channel.h"
|
|
#include "webrtc/video_engine/vie_channel_manager.h"
|
|
#include "webrtc/video_engine/vie_defines.h"
|
|
#include "webrtc/video_engine/vie_encoder.h"
|
|
#include "webrtc/video_engine/vie_impl.h"
|
|
#include "webrtc/video_engine/vie_shared_data.h"
|
|
|
|
namespace webrtc {
|
|
|
|
// Helper methods for converting between module format and ViE API format.
|
|
|
|
static RTCPMethod ViERTCPModeToRTCPMethod(ViERTCPMode api_mode) {
|
|
switch (api_mode) {
|
|
case kRtcpNone:
|
|
return kRtcpOff;
|
|
|
|
case kRtcpCompound_RFC4585:
|
|
return kRtcpCompound;
|
|
|
|
case kRtcpNonCompound_RFC5506:
|
|
return kRtcpNonCompound;
|
|
}
|
|
assert(false);
|
|
return kRtcpOff;
|
|
}
|
|
|
|
static ViERTCPMode RTCPMethodToViERTCPMode(RTCPMethod module_method) {
|
|
switch (module_method) {
|
|
case kRtcpOff:
|
|
return kRtcpNone;
|
|
|
|
case kRtcpCompound:
|
|
return kRtcpCompound_RFC4585;
|
|
|
|
case kRtcpNonCompound:
|
|
return kRtcpNonCompound_RFC5506;
|
|
}
|
|
assert(false);
|
|
return kRtcpNone;
|
|
}
|
|
|
|
static KeyFrameRequestMethod APIRequestToModuleRequest(
|
|
ViEKeyFrameRequestMethod api_method) {
|
|
switch (api_method) {
|
|
case kViEKeyFrameRequestNone:
|
|
return kKeyFrameReqFirRtp;
|
|
|
|
case kViEKeyFrameRequestPliRtcp:
|
|
return kKeyFrameReqPliRtcp;
|
|
|
|
case kViEKeyFrameRequestFirRtp:
|
|
return kKeyFrameReqFirRtp;
|
|
|
|
case kViEKeyFrameRequestFirRtcp:
|
|
return kKeyFrameReqFirRtcp;
|
|
}
|
|
assert(false);
|
|
return kKeyFrameReqFirRtp;
|
|
}
|
|
|
|
ViERTP_RTCP* ViERTP_RTCP::GetInterface(VideoEngine* video_engine) {
|
|
#ifdef WEBRTC_VIDEO_ENGINE_RTP_RTCP_API
|
|
if (!video_engine) {
|
|
return NULL;
|
|
}
|
|
VideoEngineImpl* vie_impl = static_cast<VideoEngineImpl*>(video_engine);
|
|
ViERTP_RTCPImpl* vie_rtpimpl = vie_impl;
|
|
// Increase ref count.
|
|
(*vie_rtpimpl)++;
|
|
return vie_rtpimpl;
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::Release() {
|
|
// Decrease ref count.
|
|
(*this)--;
|
|
|
|
int32_t ref_count = GetCount();
|
|
if (ref_count < 0) {
|
|
LOG(LS_ERROR) << "ViERTP_RTCP released too many times.";
|
|
shared_data_->SetLastError(kViEAPIDoesNotExist);
|
|
return -1;
|
|
}
|
|
return ref_count;
|
|
}
|
|
|
|
ViERTP_RTCPImpl::ViERTP_RTCPImpl(ViESharedData* shared_data)
|
|
: shared_data_(shared_data) {}
|
|
|
|
ViERTP_RTCPImpl::~ViERTP_RTCPImpl() {}
|
|
|
|
int ViERTP_RTCPImpl::SetLocalSSRC(const int video_channel,
|
|
const unsigned int SSRC,
|
|
const StreamType usage,
|
|
const unsigned char simulcast_idx) {
|
|
LOG_F(LS_INFO) << "channel: " << video_channel << " ssrc: " << SSRC << "";
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
if (vie_channel->SetSSRC(SSRC, usage, simulcast_idx) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::SetRemoteSSRCType(const int videoChannel,
|
|
const StreamType usage,
|
|
const unsigned int SSRC) const {
|
|
LOG_F(LS_INFO) << "channel: " << videoChannel
|
|
<< " usage: " << static_cast<int>(usage) << " ssrc: " << SSRC;
|
|
|
|
// Get the channel
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* ptrViEChannel = cs.Channel(videoChannel);
|
|
if (ptrViEChannel == NULL) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
if (ptrViEChannel->SetRemoteSSRCType(usage, SSRC) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::GetLocalSSRC(const int video_channel,
|
|
unsigned int& SSRC) const {
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
uint8_t idx = 0;
|
|
if (vie_channel->GetLocalSSRC(idx, &SSRC) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::GetRemoteSSRC(const int video_channel,
|
|
unsigned int& SSRC) const {
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
if (vie_channel->GetRemoteSSRC(&SSRC) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::GetRemoteCSRCs(const int video_channel,
|
|
unsigned int CSRCs[kRtpCsrcSize]) const {
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
if (vie_channel->GetRemoteCSRC(CSRCs) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::SetRtxSendPayloadType(const int video_channel,
|
|
const uint8_t payload_type) {
|
|
LOG_F(LS_INFO) << "channel: " << video_channel
|
|
<< " payload_type: " << static_cast<int>(payload_type);
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
if (vie_channel->SetRtxSendPayloadType(payload_type) != 0) {
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::SetPadWithRedundantPayloads(int video_channel,
|
|
bool enable) {
|
|
LOG_F(LS_INFO) << "channel: " << video_channel
|
|
<< " pad with redundant payloads: " << (enable ? "enable" :
|
|
"disable");
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
vie_channel->SetPadWithRedundantPayloads(enable);
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::SetRtxReceivePayloadType(const int video_channel,
|
|
const uint8_t payload_type) {
|
|
LOG_F(LS_INFO) << "channel: " << video_channel
|
|
<< " payload_type: " << static_cast<int>(payload_type);
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
vie_channel->SetRtxReceivePayloadType(payload_type);
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::SetStartSequenceNumber(const int video_channel,
|
|
uint16_t sequence_number) {
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
if (vie_channel->Sending()) {
|
|
LOG_F(LS_ERROR) << "channel " << video_channel << " is already sending.";
|
|
shared_data_->SetLastError(kViERtpRtcpAlreadySending);
|
|
return -1;
|
|
}
|
|
if (vie_channel->SetStartSequenceNumber(sequence_number) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void ViERTP_RTCPImpl::SetRtpStateForSsrc(int video_channel,
|
|
uint32_t ssrc,
|
|
const RtpState& rtp_state) {
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel)
|
|
return;
|
|
|
|
if (vie_channel->Sending()) {
|
|
LOG_F(LS_ERROR) << "channel " << video_channel << " is already sending.";
|
|
return;
|
|
}
|
|
vie_channel->SetRtpStateForSsrc(ssrc, rtp_state);
|
|
}
|
|
|
|
RtpState ViERTP_RTCPImpl::GetRtpStateForSsrc(int video_channel, uint32_t ssrc) {
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel)
|
|
return RtpState();
|
|
|
|
return vie_channel->GetRtpStateForSsrc(ssrc);
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::SetRTCPStatus(const int video_channel,
|
|
const ViERTCPMode rtcp_mode) {
|
|
LOG_F(LS_INFO) << "channel: " << video_channel
|
|
<< " mode: " << static_cast<int>(rtcp_mode);
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
|
|
RTCPMethod module_mode = ViERTCPModeToRTCPMethod(rtcp_mode);
|
|
if (vie_channel->SetRTCPMode(module_mode) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::GetRTCPStatus(const int video_channel,
|
|
ViERTCPMode& rtcp_mode) const {
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
RTCPMethod module_mode = kRtcpOff;
|
|
if (vie_channel->GetRTCPMode(&module_mode) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
rtcp_mode = RTCPMethodToViERTCPMode(module_mode);
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::SetRTCPCName(const int video_channel,
|
|
const char rtcp_cname[KMaxRTCPCNameLength]) {
|
|
LOG_F(LS_INFO) << "channel: " << video_channel
|
|
<< " rtcp_cname: " << rtcp_cname;
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
if (vie_channel->Sending()) {
|
|
LOG_F(LS_ERROR) << "channel " << video_channel << " is already sending.";
|
|
shared_data_->SetLastError(kViERtpRtcpAlreadySending);
|
|
return -1;
|
|
}
|
|
if (vie_channel->SetRTCPCName(rtcp_cname) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::GetRemoteRTCPCName(
|
|
const int video_channel,
|
|
char rtcp_cname[KMaxRTCPCNameLength]) const {
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
if (vie_channel->GetRemoteRTCPCName(rtcp_cname) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::SendApplicationDefinedRTCPPacket(
|
|
const int video_channel,
|
|
const unsigned char sub_type,
|
|
unsigned int name,
|
|
const char* data,
|
|
uint16_t data_length_in_bytes) {
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
if (!vie_channel->Sending()) {
|
|
shared_data_->SetLastError(kViERtpRtcpNotSending);
|
|
return -1;
|
|
}
|
|
RTCPMethod method;
|
|
if (vie_channel->GetRTCPMode(&method) != 0 || method == kRtcpOff) {
|
|
shared_data_->SetLastError(kViERtpRtcpRtcpDisabled);
|
|
return -1;
|
|
}
|
|
if (vie_channel->SendApplicationDefinedRTCPPacket(
|
|
sub_type, name, reinterpret_cast<const uint8_t*>(data),
|
|
data_length_in_bytes) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::SetNACKStatus(const int video_channel, const bool enable) {
|
|
LOG_F(LS_INFO) << "channel: " << video_channel << " "
|
|
<< (enable ? "on" : "off");
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
if (vie_channel->SetNACKStatus(enable) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
|
|
// Update the encoder
|
|
ViEEncoder* vie_encoder = cs.Encoder(video_channel);
|
|
if (!vie_encoder) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
vie_encoder->UpdateProtectionMethod(enable);
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::SetFECStatus(const int video_channel, const bool enable,
|
|
const unsigned char payload_typeRED,
|
|
const unsigned char payload_typeFEC) {
|
|
LOG_F(LS_INFO) << "channel: " << video_channel
|
|
<< " enable: " << (enable ? "on" : "off")
|
|
<< " payload_typeRED: " << static_cast<int>(payload_typeRED)
|
|
<< " payload_typeFEC: " << static_cast<int>(payload_typeFEC);
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
if (vie_channel->SetFECStatus(enable, payload_typeRED,
|
|
payload_typeFEC) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
// Update the encoder.
|
|
ViEEncoder* vie_encoder = cs.Encoder(video_channel);
|
|
if (!vie_encoder) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
vie_encoder->UpdateProtectionMethod(false);
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::SetHybridNACKFECStatus(
|
|
const int video_channel,
|
|
const bool enable,
|
|
const unsigned char payload_typeRED,
|
|
const unsigned char payload_typeFEC) {
|
|
LOG_F(LS_INFO) << "channel: " << video_channel
|
|
<< " enable: " << (enable ? "on" : "off")
|
|
<< " payload_typeRED: " << static_cast<int>(payload_typeRED)
|
|
<< " payload_typeFEC: " << static_cast<int>(payload_typeFEC);
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
|
|
// Update the channel status with hybrid NACK FEC mode.
|
|
if (vie_channel->SetHybridNACKFECStatus(enable, payload_typeRED,
|
|
payload_typeFEC) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
|
|
// Update the encoder.
|
|
ViEEncoder* vie_encoder = cs.Encoder(video_channel);
|
|
if (!vie_encoder) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
vie_encoder->UpdateProtectionMethod(enable);
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::SetSenderBufferingMode(int video_channel,
|
|
int target_delay_ms) {
|
|
LOG_F(LS_INFO) << "channel: " << video_channel
|
|
<< " target_delay_ms: " << target_delay_ms;
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
ViEEncoder* vie_encoder = cs.Encoder(video_channel);
|
|
if (!vie_encoder) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
|
|
// Update the channel with buffering mode settings.
|
|
if (vie_channel->SetSenderBufferingMode(target_delay_ms) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
|
|
// Update the encoder's buffering mode settings.
|
|
vie_encoder->SetSenderBufferingMode(target_delay_ms);
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::SetReceiverBufferingMode(int video_channel,
|
|
int target_delay_ms) {
|
|
LOG_F(LS_INFO) << "channel: " << video_channel
|
|
<< " target_delay_ms: " << target_delay_ms;
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
|
|
// Update the channel with buffering mode settings.
|
|
if (vie_channel->SetReceiverBufferingMode(target_delay_ms) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::SetKeyFrameRequestMethod(
|
|
const int video_channel,
|
|
const ViEKeyFrameRequestMethod method) {
|
|
LOG_F(LS_INFO) << "channel: " << video_channel
|
|
<< " method: " << static_cast<int>(method);
|
|
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
KeyFrameRequestMethod module_method = APIRequestToModuleRequest(method);
|
|
if (vie_channel->SetKeyFrameRequestMethod(module_method) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::SetTMMBRStatus(const int video_channel,
|
|
const bool enable) {
|
|
LOG_F(LS_INFO) << "channel: " << video_channel
|
|
<< "enable: " << (enable ? "on" : "off");
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
if (vie_channel->EnableTMMBR(enable) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::SetRembStatus(int video_channel,
|
|
bool sender,
|
|
bool receiver) {
|
|
LOG_F(LS_INFO) << "channel: " << video_channel
|
|
<< " sender: " << (sender ? "on" : "off")
|
|
<< " receiver: " << (receiver ? "on" : "off");
|
|
if (!shared_data_->channel_manager()->SetRembStatus(video_channel, sender,
|
|
receiver)) {
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::SetSendTimestampOffsetStatus(int video_channel,
|
|
bool enable,
|
|
int id) {
|
|
LOG_F(LS_INFO) << "channel: " << video_channel
|
|
<< "enable: " << (enable ? "on" : "off") << " id: " << id;
|
|
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
if (vie_channel->SetSendTimestampOffsetStatus(enable, id) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::SetReceiveTimestampOffsetStatus(int video_channel,
|
|
bool enable,
|
|
int id) {
|
|
LOG_F(LS_INFO) << "channel: " << video_channel
|
|
<< "enable: " << (enable ? "on" : "off") << " id: " << id;
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
if (vie_channel->SetReceiveTimestampOffsetStatus(enable, id) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::SetSendAbsoluteSendTimeStatus(int video_channel,
|
|
bool enable,
|
|
int id) {
|
|
LOG_F(LS_INFO) << "channel: " << video_channel
|
|
<< "enable: " << (enable ? "on" : "off") << " id: " << id;
|
|
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
if (vie_channel->SetSendAbsoluteSendTimeStatus(enable, id) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::SetReceiveAbsoluteSendTimeStatus(int video_channel,
|
|
bool enable,
|
|
int id) {
|
|
LOG_F(LS_INFO) << "channel: " << video_channel
|
|
<< "enable: " << (enable ? "on" : "off") << " id: " << id;
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
if (vie_channel->SetReceiveAbsoluteSendTimeStatus(enable, id) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::SetRtcpXrRrtrStatus(int video_channel, bool enable) {
|
|
LOG_F(LS_INFO) << "channel: " << video_channel
|
|
<< " enable: " << (enable ? "on" : "off");
|
|
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
vie_channel->SetRtcpXrRrtrStatus(enable);
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::SetTransmissionSmoothingStatus(int video_channel,
|
|
bool enable) {
|
|
LOG_F(LS_INFO) << "channel: " << video_channel
|
|
<< " enable: " << (enable ? "on" : "off");
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
vie_channel->SetTransmissionSmoothingStatus(enable);
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::SetMinTransmitBitrate(int video_channel,
|
|
int min_transmit_bitrate_kbps) {
|
|
LOG_F(LS_INFO) << "channel: " << video_channel
|
|
<< " min_transmit_bitrate_kbps: " << min_transmit_bitrate_kbps;
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEEncoder* vie_encoder = cs.Encoder(video_channel);
|
|
if (vie_encoder == NULL)
|
|
return -1;
|
|
vie_encoder->SetMinTransmitBitrate(min_transmit_bitrate_kbps);
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::SetReservedTransmitBitrate(
|
|
int video_channel, unsigned int reserved_transmit_bitrate_bps) {
|
|
LOG_F(LS_INFO) << "channel: " << video_channel
|
|
<< " reserved_transmit_bitrate_bps: "
|
|
<< reserved_transmit_bitrate_bps;
|
|
if (!shared_data_->channel_manager()->SetReservedTransmitBitrate(
|
|
video_channel, reserved_transmit_bitrate_bps)) {
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::GetReceiveChannelRtcpStatistics(
|
|
const int video_channel,
|
|
RtcpStatistics& basic_stats,
|
|
int& rtt_ms) const {
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
|
|
// TODO(sprang): Clean this up when stats struct is propagated all the way.
|
|
uint16_t frac_lost;
|
|
if (vie_channel->GetReceivedRtcpStatistics(
|
|
&frac_lost,
|
|
&basic_stats.cumulative_lost,
|
|
&basic_stats.extended_max_sequence_number,
|
|
&basic_stats.jitter,
|
|
&rtt_ms) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
basic_stats.fraction_lost = frac_lost;
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::GetSendChannelRtcpStatistics(const int video_channel,
|
|
RtcpStatistics& basic_stats,
|
|
int& rtt_ms) const {
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
|
|
// TODO(sprang): Clean this up when stats struct is propagated all the way.
|
|
uint16_t frac_lost;
|
|
if (vie_channel->GetSendRtcpStatistics(
|
|
&frac_lost,
|
|
&basic_stats.cumulative_lost,
|
|
&basic_stats.extended_max_sequence_number,
|
|
&basic_stats.jitter,
|
|
&rtt_ms) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
basic_stats.fraction_lost = frac_lost;
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::GetRtpStatistics(const int video_channel,
|
|
StreamDataCounters& sent,
|
|
StreamDataCounters& received) const {
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
if (vie_channel->GetRtpStatistics(&sent.bytes,
|
|
&sent.packets,
|
|
&received.bytes,
|
|
&received.packets) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::GetRtcpPacketTypeCounters(
|
|
int video_channel,
|
|
RtcpPacketTypeCounter* packets_sent,
|
|
RtcpPacketTypeCounter* packets_received) const {
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
vie_channel->GetRtcpPacketTypeCounters(packets_sent, packets_received);
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::GetBandwidthUsage(const int video_channel,
|
|
unsigned int& total_bitrate_sent,
|
|
unsigned int& video_bitrate_sent,
|
|
unsigned int& fec_bitrate_sent,
|
|
unsigned int& nackBitrateSent) const {
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
vie_channel->GetBandwidthUsage(&total_bitrate_sent,
|
|
&video_bitrate_sent,
|
|
&fec_bitrate_sent,
|
|
&nackBitrateSent);
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::GetEstimatedSendBandwidth(
|
|
const int video_channel,
|
|
unsigned int* estimated_bandwidth) const {
|
|
if (!shared_data_->channel_manager()->GetEstimatedSendBandwidth(
|
|
video_channel, estimated_bandwidth)) {
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::GetEstimatedReceiveBandwidth(
|
|
const int video_channel,
|
|
unsigned int* estimated_bandwidth) const {
|
|
if (!shared_data_->channel_manager()->GetEstimatedReceiveBandwidth(
|
|
video_channel, estimated_bandwidth)) {
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::GetReceiveBandwidthEstimatorStats(
|
|
const int video_channel,
|
|
ReceiveBandwidthEstimatorStats* output) const {
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
vie_channel->GetReceiveBandwidthEstimatorStats(output);
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::GetPacerQueuingDelayMs(
|
|
const int video_channel, int* delay_ms) const {
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEEncoder* vie_encoder = cs.Encoder(video_channel);
|
|
if (!vie_encoder) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
*delay_ms = vie_encoder->PacerQueuingDelayMs();
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::StartRTPDump(const int video_channel,
|
|
const char file_nameUTF8[1024],
|
|
RTPDirections direction) {
|
|
LOG_F(LS_INFO) << "channel: " << video_channel
|
|
<< " filename: " << file_nameUTF8
|
|
<< " direction: " << static_cast<int>(direction);
|
|
assert(FileWrapper::kMaxFileNameSize == 1024);
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
if (vie_channel->StartRTPDump(file_nameUTF8, direction) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::StopRTPDump(const int video_channel,
|
|
RTPDirections direction) {
|
|
LOG_F(LS_INFO) << "channel: " << video_channel
|
|
<< " direction: " << static_cast<int>(direction);
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
if (vie_channel->StopRTPDump(direction) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpUnknownError);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::RegisterRTPObserver(const int video_channel,
|
|
ViERTPObserver& observer) {
|
|
LOG_F(LS_INFO) << "channel " << video_channel;
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
if (vie_channel->RegisterRtpObserver(&observer) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpObserverAlreadyRegistered);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::DeregisterRTPObserver(const int video_channel) {
|
|
LOG_F(LS_INFO) << "channel " << video_channel;
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
if (vie_channel->RegisterRtpObserver(NULL) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpObserverNotRegistered);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::RegisterRTCPObserver(const int video_channel,
|
|
ViERTCPObserver& observer) {
|
|
LOG_F(LS_INFO) << "channel " << video_channel;
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
if (vie_channel->RegisterRtcpObserver(&observer) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpObserverAlreadyRegistered);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::DeregisterRTCPObserver(const int video_channel) {
|
|
LOG_F(LS_INFO) << "channel " << video_channel;
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
if (vie_channel->RegisterRtcpObserver(NULL) != 0) {
|
|
shared_data_->SetLastError(kViERtpRtcpObserverNotRegistered);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::RegisterSendChannelRtcpStatisticsCallback(
|
|
int video_channel, RtcpStatisticsCallback* callback) {
|
|
LOG_F(LS_INFO) << "channel " << video_channel;
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
vie_channel->RegisterSendChannelRtcpStatisticsCallback(callback);
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::DeregisterSendChannelRtcpStatisticsCallback(
|
|
int video_channel, RtcpStatisticsCallback* callback) {
|
|
LOG_F(LS_INFO) << "channel " << video_channel;
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
vie_channel->RegisterSendChannelRtcpStatisticsCallback(NULL);
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::RegisterReceiveChannelRtcpStatisticsCallback(
|
|
const int video_channel,
|
|
RtcpStatisticsCallback* callback) {
|
|
LOG_F(LS_INFO) << "channel " << video_channel;
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
assert(vie_channel != NULL);
|
|
vie_channel->RegisterReceiveChannelRtcpStatisticsCallback(callback);
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::DeregisterReceiveChannelRtcpStatisticsCallback(
|
|
const int video_channel,
|
|
RtcpStatisticsCallback* callback) {
|
|
LOG_F(LS_INFO) << "channel " << video_channel;
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
assert(vie_channel != NULL);
|
|
vie_channel->RegisterReceiveChannelRtcpStatisticsCallback(NULL);
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::RegisterSendChannelRtpStatisticsCallback(
|
|
int video_channel, StreamDataCountersCallback* callback) {
|
|
LOG_F(LS_INFO) << "channel " << video_channel;
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
assert(vie_channel != NULL);
|
|
vie_channel->RegisterSendChannelRtpStatisticsCallback(callback);
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::DeregisterSendChannelRtpStatisticsCallback(
|
|
int video_channel, StreamDataCountersCallback* callback) {
|
|
LOG_F(LS_INFO) << "channel " << video_channel;
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
assert(vie_channel != NULL);
|
|
vie_channel->RegisterSendChannelRtpStatisticsCallback(NULL);
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::RegisterReceiveChannelRtpStatisticsCallback(
|
|
const int video_channel,
|
|
StreamDataCountersCallback* callback) {
|
|
LOG_F(LS_INFO) << "channel " << video_channel;
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
assert(vie_channel != NULL);
|
|
vie_channel->RegisterReceiveChannelRtpStatisticsCallback(callback);
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::DeregisterReceiveChannelRtpStatisticsCallback(
|
|
const int video_channel,
|
|
StreamDataCountersCallback* callback) {
|
|
LOG_F(LS_INFO) << "channel " << video_channel;
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
assert(vie_channel != NULL);
|
|
vie_channel->RegisterReceiveChannelRtpStatisticsCallback(NULL);
|
|
return 0;
|
|
}
|
|
|
|
// Called whenever the send bitrate is updated.
|
|
int ViERTP_RTCPImpl::RegisterSendBitrateObserver(
|
|
const int video_channel,
|
|
BitrateStatisticsObserver* observer) {
|
|
LOG_F(LS_INFO) << "channel " << video_channel;
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
assert(vie_channel != NULL);
|
|
vie_channel->RegisterSendBitrateObserver(observer);
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::DeregisterSendBitrateObserver(
|
|
const int video_channel,
|
|
BitrateStatisticsObserver* observer) {
|
|
LOG_F(LS_INFO) << "channel " << video_channel;
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
assert(vie_channel != NULL);
|
|
vie_channel->RegisterSendBitrateObserver(NULL);
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::RegisterSendFrameCountObserver(
|
|
int video_channel, FrameCountObserver* callback) {
|
|
LOG_F(LS_INFO) << "channel " << video_channel;
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
vie_channel->RegisterSendFrameCountObserver(callback);
|
|
return 0;
|
|
}
|
|
|
|
int ViERTP_RTCPImpl::DeregisterSendFrameCountObserver(
|
|
int video_channel, FrameCountObserver* callback) {
|
|
LOG_F(LS_INFO) << "channel " << video_channel;
|
|
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
|
|
ViEChannel* vie_channel = cs.Channel(video_channel);
|
|
if (!vie_channel) {
|
|
shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
|
|
return -1;
|
|
}
|
|
vie_channel->RegisterSendFrameCountObserver(NULL);
|
|
return 0;
|
|
}
|
|
} // namespace webrtc
|