blob: e4dc320417ca5b7e1d5c2edd21b7baa5d60e81d0 [file] [log] [blame]
/*
* 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/voice_engine/channel.h"
#include <algorithm>
#include "webrtc/base/checks.h"
#include "webrtc/base/format_macros.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/common.h"
#include "webrtc/config.h"
#include "webrtc/modules/audio_device/include/audio_device.h"
#include "webrtc/modules/audio_processing/include/audio_processing.h"
#include "webrtc/modules/interface/module_common_types.h"
#include "webrtc/modules/rtp_rtcp/interface/receive_statistics.h"
#include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h"
#include "webrtc/modules/rtp_rtcp/interface/rtp_receiver.h"
#include "webrtc/modules/rtp_rtcp/source/rtp_receiver_strategy.h"
#include "webrtc/modules/utility/interface/audio_frame_operations.h"
#include "webrtc/modules/utility/interface/process_thread.h"
#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
#include "webrtc/system_wrappers/interface/logging.h"
#include "webrtc/system_wrappers/interface/trace.h"
#include "webrtc/voice_engine/include/voe_base.h"
#include "webrtc/voice_engine/include/voe_external_media.h"
#include "webrtc/voice_engine/include/voe_rtp_rtcp.h"
#include "webrtc/voice_engine/output_mixer.h"
#include "webrtc/voice_engine/statistics.h"
#include "webrtc/voice_engine/transmit_mixer.h"
#include "webrtc/voice_engine/utility.h"
#if defined(_WIN32)
#include <Qos.h>
#endif
namespace webrtc {
namespace voe {
// Extend the default RTCP statistics struct with max_jitter, defined as the
// maximum jitter value seen in an RTCP report block.
struct ChannelStatistics : public RtcpStatistics {
ChannelStatistics() : rtcp(), max_jitter(0) {}
RtcpStatistics rtcp;
uint32_t max_jitter;
};
// Statistics callback, called at each generation of a new RTCP report block.
class StatisticsProxy : public RtcpStatisticsCallback {
public:
StatisticsProxy(uint32_t ssrc)
: stats_lock_(CriticalSectionWrapper::CreateCriticalSection()),
ssrc_(ssrc) {}
virtual ~StatisticsProxy() {}
void StatisticsUpdated(const RtcpStatistics& statistics,
uint32_t ssrc) override {
if (ssrc != ssrc_)
return;
CriticalSectionScoped cs(stats_lock_.get());
stats_.rtcp = statistics;
if (statistics.jitter > stats_.max_jitter) {
stats_.max_jitter = statistics.jitter;
}
}
void CNameChanged(const char* cname, uint32_t ssrc) override {}
ChannelStatistics GetStats() {
CriticalSectionScoped cs(stats_lock_.get());
return stats_;
}
private:
// StatisticsUpdated calls are triggered from threads in the RTP module,
// while GetStats calls can be triggered from the public voice engine API,
// hence synchronization is needed.
rtc::scoped_ptr<CriticalSectionWrapper> stats_lock_;
const uint32_t ssrc_;
ChannelStatistics stats_;
};
class VoERtcpObserver : public RtcpBandwidthObserver {
public:
explicit VoERtcpObserver(Channel* owner) : owner_(owner) {}
virtual ~VoERtcpObserver() {}
void OnReceivedEstimatedBitrate(uint32_t bitrate) override {
// Not used for Voice Engine.
}
void OnReceivedRtcpReceiverReport(const ReportBlockList& report_blocks,
int64_t rtt,
int64_t now_ms) override {
// TODO(mflodman): Do we need to aggregate reports here or can we jut send
// what we get? I.e. do we ever get multiple reports bundled into one RTCP
// report for VoiceEngine?
if (report_blocks.empty())
return;
int fraction_lost_aggregate = 0;
int total_number_of_packets = 0;
// If receiving multiple report blocks, calculate the weighted average based
// on the number of packets a report refers to.
for (ReportBlockList::const_iterator block_it = report_blocks.begin();
block_it != report_blocks.end(); ++block_it) {
// Find the previous extended high sequence number for this remote SSRC,
// to calculate the number of RTP packets this report refers to. Ignore if
// we haven't seen this SSRC before.
std::map<uint32_t, uint32_t>::iterator seq_num_it =
extended_max_sequence_number_.find(block_it->sourceSSRC);
int number_of_packets = 0;
if (seq_num_it != extended_max_sequence_number_.end()) {
number_of_packets = block_it->extendedHighSeqNum - seq_num_it->second;
}
fraction_lost_aggregate += number_of_packets * block_it->fractionLost;
total_number_of_packets += number_of_packets;
extended_max_sequence_number_[block_it->sourceSSRC] =
block_it->extendedHighSeqNum;
}
int weighted_fraction_lost = 0;
if (total_number_of_packets > 0) {
weighted_fraction_lost = (fraction_lost_aggregate +
total_number_of_packets / 2) / total_number_of_packets;
}
owner_->OnIncomingFractionLoss(weighted_fraction_lost);
}
private:
Channel* owner_;
// Maps remote side ssrc to extended highest sequence number received.
std::map<uint32_t, uint32_t> extended_max_sequence_number_;
};
int32_t
Channel::SendData(FrameType frameType,
uint8_t payloadType,
uint32_t timeStamp,
const uint8_t* payloadData,
size_t payloadSize,
const RTPFragmentationHeader* fragmentation)
{
WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::SendData(frameType=%u, payloadType=%u, timeStamp=%u,"
" payloadSize=%" PRIuS ", fragmentation=0x%x)",
frameType, payloadType, timeStamp,
payloadSize, fragmentation);
if (_includeAudioLevelIndication)
{
// Store current audio level in the RTP/RTCP module.
// The level will be used in combination with voice-activity state
// (frameType) to add an RTP header extension
_rtpRtcpModule->SetAudioLevel(rms_level_.RMS());
}
// Push data from ACM to RTP/RTCP-module to deliver audio frame for
// packetization.
// This call will trigger Transport::SendPacket() from the RTP/RTCP module.
if (_rtpRtcpModule->SendOutgoingData((FrameType&)frameType,
payloadType,
timeStamp,
// Leaving the time when this frame was
// received from the capture device as
// undefined for voice for now.
-1,
payloadData,
payloadSize,
fragmentation) == -1)
{
_engineStatisticsPtr->SetLastError(
VE_RTP_RTCP_MODULE_ERROR, kTraceWarning,
"Channel::SendData() failed to send data to RTP/RTCP module");
return -1;
}
_lastLocalTimeStamp = timeStamp;
_lastPayloadType = payloadType;
return 0;
}
int32_t
Channel::InFrameType(FrameType frame_type)
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::InFrameType(frame_type=%d)", frame_type);
CriticalSectionScoped cs(&_callbackCritSect);
_sendFrameType = (frame_type == kAudioFrameSpeech);
return 0;
}
int32_t
Channel::OnRxVadDetected(int vadDecision)
{
CriticalSectionScoped cs(&_callbackCritSect);
if (_rxVadObserverPtr)
{
_rxVadObserverPtr->OnRxVad(_channelId, vadDecision);
}
return 0;
}
bool Channel::SendRtp(const uint8_t* data,
size_t len,
const PacketOptions& options) {
WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::SendPacket(channel=%d, len=%" PRIuS ")", len);
CriticalSectionScoped cs(&_callbackCritSect);
if (_transportPtr == NULL)
{
WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::SendPacket() failed to send RTP packet due to"
" invalid transport object");
return false;
}
uint8_t* bufferToSendPtr = (uint8_t*)data;
size_t bufferLength = len;
if (!_transportPtr->SendRtp(bufferToSendPtr, bufferLength, options)) {
std::string transport_name =
_externalTransport ? "external transport" : "WebRtc sockets";
WEBRTC_TRACE(kTraceError, kTraceVoice,
VoEId(_instanceId,_channelId),
"Channel::SendPacket() RTP transmission using %s failed",
transport_name.c_str());
return false;
}
return true;
}
bool
Channel::SendRtcp(const uint8_t *data, size_t len)
{
WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::SendRtcp(len=%" PRIuS ")", len);
CriticalSectionScoped cs(&_callbackCritSect);
if (_transportPtr == NULL)
{
WEBRTC_TRACE(kTraceError, kTraceVoice,
VoEId(_instanceId,_channelId),
"Channel::SendRtcp() failed to send RTCP packet"
" due to invalid transport object");
return false;
}
uint8_t* bufferToSendPtr = (uint8_t*)data;
size_t bufferLength = len;
int n = _transportPtr->SendRtcp(bufferToSendPtr, bufferLength);
if (n < 0) {
std::string transport_name =
_externalTransport ? "external transport" : "WebRtc sockets";
WEBRTC_TRACE(kTraceInfo, kTraceVoice,
VoEId(_instanceId,_channelId),
"Channel::SendRtcp() transmission using %s failed",
transport_name.c_str());
return false;
}
return true;
}
void Channel::OnPlayTelephoneEvent(uint8_t event,
uint16_t lengthMs,
uint8_t volume) {
WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::OnPlayTelephoneEvent(event=%u, lengthMs=%u,"
" volume=%u)", event, lengthMs, volume);
if (!_playOutbandDtmfEvent || (event > 15))
{
// Ignore callback since feedback is disabled or event is not a
// Dtmf tone event.
return;
}
assert(_outputMixerPtr != NULL);
// Start playing out the Dtmf tone (if playout is enabled).
// Reduce length of tone with 80ms to the reduce risk of echo.
_outputMixerPtr->PlayDtmfTone(event, lengthMs - 80, volume);
}
void
Channel::OnIncomingSSRCChanged(uint32_t ssrc)
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::OnIncomingSSRCChanged(SSRC=%d)", ssrc);
// Update ssrc so that NTP for AV sync can be updated.
_rtpRtcpModule->SetRemoteSSRC(ssrc);
}
void Channel::OnIncomingCSRCChanged(uint32_t CSRC, bool added) {
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
"Channel::OnIncomingCSRCChanged(CSRC=%d, added=%d)", CSRC,
added);
}
int32_t Channel::OnInitializeDecoder(
int8_t payloadType,
const char payloadName[RTP_PAYLOAD_NAME_SIZE],
int frequency,
uint8_t channels,
uint32_t rate) {
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::OnInitializeDecoder(payloadType=%d, "
"payloadName=%s, frequency=%u, channels=%u, rate=%u)",
payloadType, payloadName, frequency, channels, rate);
CodecInst receiveCodec = {0};
CodecInst dummyCodec = {0};
receiveCodec.pltype = payloadType;
receiveCodec.plfreq = frequency;
receiveCodec.channels = channels;
receiveCodec.rate = rate;
strncpy(receiveCodec.plname, payloadName, RTP_PAYLOAD_NAME_SIZE - 1);
audio_coding_->Codec(payloadName, &dummyCodec, frequency, channels);
receiveCodec.pacsize = dummyCodec.pacsize;
// Register the new codec to the ACM
if (audio_coding_->RegisterReceiveCodec(receiveCodec) == -1)
{
WEBRTC_TRACE(kTraceWarning, kTraceVoice,
VoEId(_instanceId, _channelId),
"Channel::OnInitializeDecoder() invalid codec ("
"pt=%d, name=%s) received - 1", payloadType, payloadName);
_engineStatisticsPtr->SetLastError(VE_AUDIO_CODING_MODULE_ERROR);
return -1;
}
return 0;
}
int32_t
Channel::OnReceivedPayloadData(const uint8_t* payloadData,
size_t payloadSize,
const WebRtcRTPHeader* rtpHeader)
{
WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::OnReceivedPayloadData(payloadSize=%" PRIuS ","
" payloadType=%u, audioChannel=%u)",
payloadSize,
rtpHeader->header.payloadType,
rtpHeader->type.Audio.channel);
if (!channel_state_.Get().playing)
{
// Avoid inserting into NetEQ when we are not playing. Count the
// packet as discarded.
WEBRTC_TRACE(kTraceStream, kTraceVoice,
VoEId(_instanceId, _channelId),
"received packet is discarded since playing is not"
" activated");
_numberOfDiscardedPackets++;
return 0;
}
// Push the incoming payload (parsed and ready for decoding) into the ACM
if (audio_coding_->IncomingPacket(payloadData,
payloadSize,
*rtpHeader) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_AUDIO_CODING_MODULE_ERROR, kTraceWarning,
"Channel::OnReceivedPayloadData() unable to push data to the ACM");
return -1;
}
// Update the packet delay.
UpdatePacketDelay(rtpHeader->header.timestamp,
rtpHeader->header.sequenceNumber);
int64_t round_trip_time = 0;
_rtpRtcpModule->RTT(rtp_receiver_->SSRC(), &round_trip_time,
NULL, NULL, NULL);
std::vector<uint16_t> nack_list = audio_coding_->GetNackList(
round_trip_time);
if (!nack_list.empty()) {
// Can't use nack_list.data() since it's not supported by all
// compilers.
ResendPackets(&(nack_list[0]), static_cast<int>(nack_list.size()));
}
return 0;
}
bool Channel::OnRecoveredPacket(const uint8_t* rtp_packet,
size_t rtp_packet_length) {
RTPHeader header;
if (!rtp_header_parser_->Parse(rtp_packet, rtp_packet_length, &header)) {
WEBRTC_TRACE(kTraceDebug, webrtc::kTraceVoice, _channelId,
"IncomingPacket invalid RTP header");
return false;
}
header.payload_type_frequency =
rtp_payload_registry_->GetPayloadTypeFrequency(header.payloadType);
if (header.payload_type_frequency < 0)
return false;
return ReceivePacket(rtp_packet, rtp_packet_length, header, false);
}
int32_t Channel::GetAudioFrame(int32_t id, AudioFrame* audioFrame)
{
if (event_log_) {
unsigned int ssrc;
RTC_CHECK_EQ(GetLocalSSRC(ssrc), 0);
event_log_->LogAudioPlayout(ssrc);
}
// Get 10ms raw PCM data from the ACM (mixer limits output frequency)
if (audio_coding_->PlayoutData10Ms(audioFrame->sample_rate_hz_,
audioFrame) == -1)
{
WEBRTC_TRACE(kTraceError, kTraceVoice,
VoEId(_instanceId,_channelId),
"Channel::GetAudioFrame() PlayoutData10Ms() failed!");
// In all likelihood, the audio in this frame is garbage. We return an
// error so that the audio mixer module doesn't add it to the mix. As
// a result, it won't be played out and the actions skipped here are
// irrelevant.
return -1;
}
if (_RxVadDetection)
{
UpdateRxVadDetection(*audioFrame);
}
// Convert module ID to internal VoE channel ID
audioFrame->id_ = VoEChannelId(audioFrame->id_);
// Store speech type for dead-or-alive detection
_outputSpeechType = audioFrame->speech_type_;
ChannelState::State state = channel_state_.Get();
if (state.rx_apm_is_enabled) {
int err = rx_audioproc_->ProcessStream(audioFrame);
if (err) {
LOG(LS_ERROR) << "ProcessStream() error: " << err;
assert(false);
}
}
float output_gain = 1.0f;
float left_pan = 1.0f;
float right_pan = 1.0f;
{
CriticalSectionScoped cs(&volume_settings_critsect_);
output_gain = _outputGain;
left_pan = _panLeft;
right_pan= _panRight;
}
// Output volume scaling
if (output_gain < 0.99f || output_gain > 1.01f)
{
AudioFrameOperations::ScaleWithSat(output_gain, *audioFrame);
}
// Scale left and/or right channel(s) if stereo and master balance is
// active
if (left_pan != 1.0f || right_pan != 1.0f)
{
if (audioFrame->num_channels_ == 1)
{
// Emulate stereo mode since panning is active.
// The mono signal is copied to both left and right channels here.
AudioFrameOperations::MonoToStereo(audioFrame);
}
// For true stereo mode (when we are receiving a stereo signal), no
// action is needed.
// Do the panning operation (the audio frame contains stereo at this
// stage)
AudioFrameOperations::Scale(left_pan, right_pan, *audioFrame);
}
// Mix decoded PCM output with file if file mixing is enabled
if (state.output_file_playing)
{
MixAudioWithFile(*audioFrame, audioFrame->sample_rate_hz_);
}
// External media
if (_outputExternalMedia)
{
CriticalSectionScoped cs(&_callbackCritSect);
const bool isStereo = (audioFrame->num_channels_ == 2);
if (_outputExternalMediaCallbackPtr)
{
_outputExternalMediaCallbackPtr->Process(
_channelId,
kPlaybackPerChannel,
(int16_t*)audioFrame->data_,
audioFrame->samples_per_channel_,
audioFrame->sample_rate_hz_,
isStereo);
}
}
// Record playout if enabled
{
CriticalSectionScoped cs(&_fileCritSect);
if (_outputFileRecording && _outputFileRecorderPtr)
{
_outputFileRecorderPtr->RecordAudioToFile(*audioFrame);
}
}
// Measure audio level (0-9)
_outputAudioLevel.ComputeLevel(*audioFrame);
if (capture_start_rtp_time_stamp_ < 0 && audioFrame->timestamp_ != 0) {
// The first frame with a valid rtp timestamp.
capture_start_rtp_time_stamp_ = audioFrame->timestamp_;
}
if (capture_start_rtp_time_stamp_ >= 0) {
// audioFrame.timestamp_ should be valid from now on.
// Compute elapsed time.
int64_t unwrap_timestamp =
rtp_ts_wraparound_handler_->Unwrap(audioFrame->timestamp_);
audioFrame->elapsed_time_ms_ =
(unwrap_timestamp - capture_start_rtp_time_stamp_) /
(GetPlayoutFrequency() / 1000);
{
CriticalSectionScoped lock(ts_stats_lock_.get());
// Compute ntp time.
audioFrame->ntp_time_ms_ = ntp_estimator_.Estimate(
audioFrame->timestamp_);
// |ntp_time_ms_| won't be valid until at least 2 RTCP SRs are received.
if (audioFrame->ntp_time_ms_ > 0) {
// Compute |capture_start_ntp_time_ms_| so that
// |capture_start_ntp_time_ms_| + |elapsed_time_ms_| == |ntp_time_ms_|
capture_start_ntp_time_ms_ =
audioFrame->ntp_time_ms_ - audioFrame->elapsed_time_ms_;
}
}
}
return 0;
}
int32_t
Channel::NeededFrequency(int32_t id) const
{
WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::NeededFrequency(id=%d)", id);
int highestNeeded = 0;
// Determine highest needed receive frequency
int32_t receiveFrequency = audio_coding_->ReceiveFrequency();
// Return the bigger of playout and receive frequency in the ACM.
if (audio_coding_->PlayoutFrequency() > receiveFrequency)
{
highestNeeded = audio_coding_->PlayoutFrequency();
}
else
{
highestNeeded = receiveFrequency;
}
// Special case, if we're playing a file on the playout side
// we take that frequency into consideration as well
// This is not needed on sending side, since the codec will
// limit the spectrum anyway.
if (channel_state_.Get().output_file_playing)
{
CriticalSectionScoped cs(&_fileCritSect);
if (_outputFilePlayerPtr)
{
if(_outputFilePlayerPtr->Frequency()>highestNeeded)
{
highestNeeded=_outputFilePlayerPtr->Frequency();
}
}
}
return(highestNeeded);
}
int32_t Channel::CreateChannel(Channel*& channel,
int32_t channelId,
uint32_t instanceId,
RtcEventLog* const event_log,
const Config& config) {
WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(instanceId,channelId),
"Channel::CreateChannel(channelId=%d, instanceId=%d)",
channelId, instanceId);
channel = new Channel(channelId, instanceId, event_log, config);
if (channel == NULL)
{
WEBRTC_TRACE(kTraceMemory, kTraceVoice,
VoEId(instanceId,channelId),
"Channel::CreateChannel() unable to allocate memory for"
" channel");
return -1;
}
return 0;
}
void
Channel::PlayNotification(int32_t id, uint32_t durationMs)
{
WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::PlayNotification(id=%d, durationMs=%d)",
id, durationMs);
// Not implement yet
}
void
Channel::RecordNotification(int32_t id, uint32_t durationMs)
{
WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::RecordNotification(id=%d, durationMs=%d)",
id, durationMs);
// Not implement yet
}
void
Channel::PlayFileEnded(int32_t id)
{
WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::PlayFileEnded(id=%d)", id);
if (id == _inputFilePlayerId)
{
channel_state_.SetInputFilePlaying(false);
WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
VoEId(_instanceId,_channelId),
"Channel::PlayFileEnded() => input file player module is"
" shutdown");
}
else if (id == _outputFilePlayerId)
{
channel_state_.SetOutputFilePlaying(false);
WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
VoEId(_instanceId,_channelId),
"Channel::PlayFileEnded() => output file player module is"
" shutdown");
}
}
void
Channel::RecordFileEnded(int32_t id)
{
WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::RecordFileEnded(id=%d)", id);
assert(id == _outputFileRecorderId);
CriticalSectionScoped cs(&_fileCritSect);
_outputFileRecording = false;
WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
VoEId(_instanceId,_channelId),
"Channel::RecordFileEnded() => output file recorder module is"
" shutdown");
}
Channel::Channel(int32_t channelId,
uint32_t instanceId,
RtcEventLog* const event_log,
const Config& config)
: _fileCritSect(*CriticalSectionWrapper::CreateCriticalSection()),
_callbackCritSect(*CriticalSectionWrapper::CreateCriticalSection()),
volume_settings_critsect_(*CriticalSectionWrapper::CreateCriticalSection()),
_instanceId(instanceId),
_channelId(channelId),
event_log_(event_log),
rtp_header_parser_(RtpHeaderParser::Create()),
rtp_payload_registry_(
new RTPPayloadRegistry(RTPPayloadStrategy::CreateStrategy(true))),
rtp_receive_statistics_(
ReceiveStatistics::Create(Clock::GetRealTimeClock())),
rtp_receiver_(
RtpReceiver::CreateAudioReceiver(Clock::GetRealTimeClock(),
this,
this,
this,
rtp_payload_registry_.get())),
telephone_event_handler_(rtp_receiver_->GetTelephoneEventHandler()),
_outputAudioLevel(),
_externalTransport(false),
_inputFilePlayerPtr(NULL),
_outputFilePlayerPtr(NULL),
_outputFileRecorderPtr(NULL),
// Avoid conflict with other channels by adding 1024 - 1026,
// won't use as much as 1024 channels.
_inputFilePlayerId(VoEModuleId(instanceId, channelId) + 1024),
_outputFilePlayerId(VoEModuleId(instanceId, channelId) + 1025),
_outputFileRecorderId(VoEModuleId(instanceId, channelId) + 1026),
_outputFileRecording(false),
_inbandDtmfQueue(VoEModuleId(instanceId, channelId)),
_inbandDtmfGenerator(VoEModuleId(instanceId, channelId)),
_outputExternalMedia(false),
_inputExternalMediaCallbackPtr(NULL),
_outputExternalMediaCallbackPtr(NULL),
_timeStamp(0), // This is just an offset, RTP module will add it's own
// random offset
_sendTelephoneEventPayloadType(106),
ntp_estimator_(Clock::GetRealTimeClock()),
jitter_buffer_playout_timestamp_(0),
playout_timestamp_rtp_(0),
playout_timestamp_rtcp_(0),
playout_delay_ms_(0),
_numberOfDiscardedPackets(0),
send_sequence_number_(0),
ts_stats_lock_(CriticalSectionWrapper::CreateCriticalSection()),
rtp_ts_wraparound_handler_(new rtc::TimestampWrapAroundHandler()),
capture_start_rtp_time_stamp_(-1),
capture_start_ntp_time_ms_(-1),
_engineStatisticsPtr(NULL),
_outputMixerPtr(NULL),
_transmitMixerPtr(NULL),
_moduleProcessThreadPtr(NULL),
_audioDeviceModulePtr(NULL),
_voiceEngineObserverPtr(NULL),
_callbackCritSectPtr(NULL),
_transportPtr(NULL),
_rxVadObserverPtr(NULL),
_oldVadDecision(-1),
_sendFrameType(0),
_externalMixing(false),
_mixFileWithMicrophone(false),
_mute(false),
_panLeft(1.0f),
_panRight(1.0f),
_outputGain(1.0f),
_playOutbandDtmfEvent(false),
_playInbandDtmfEvent(false),
_lastLocalTimeStamp(0),
_lastPayloadType(0),
_includeAudioLevelIndication(false),
_outputSpeechType(AudioFrame::kNormalSpeech),
video_sync_lock_(CriticalSectionWrapper::CreateCriticalSection()),
_average_jitter_buffer_delay_us(0),
_previousTimestamp(0),
_recPacketDelayMs(20),
_RxVadDetection(false),
_rxAgcIsEnabled(false),
_rxNsIsEnabled(false),
restored_packet_in_use_(false),
rtcp_observer_(new VoERtcpObserver(this)),
network_predictor_(new NetworkPredictor(Clock::GetRealTimeClock())),
assoc_send_channel_lock_(CriticalSectionWrapper::CreateCriticalSection()),
associate_send_channel_(ChannelOwner(nullptr)) {
WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::Channel() - ctor");
AudioCodingModule::Config acm_config;
acm_config.id = VoEModuleId(instanceId, channelId);
if (config.Get<NetEqCapacityConfig>().enabled) {
// Clamping the buffer capacity at 20 packets. While going lower will
// probably work, it makes little sense.
acm_config.neteq_config.max_packets_in_buffer =
std::max(20, config.Get<NetEqCapacityConfig>().capacity);
}
acm_config.neteq_config.enable_fast_accelerate =
config.Get<NetEqFastAccelerate>().enabled;
audio_coding_.reset(AudioCodingModule::Create(acm_config));
_inbandDtmfQueue.ResetDtmf();
_inbandDtmfGenerator.Init();
_outputAudioLevel.Clear();
RtpRtcp::Configuration configuration;
configuration.audio = true;
configuration.outgoing_transport = this;
configuration.audio_messages = this;
configuration.receive_statistics = rtp_receive_statistics_.get();
configuration.bandwidth_callback = rtcp_observer_.get();
_rtpRtcpModule.reset(RtpRtcp::CreateRtpRtcp(configuration));
statistics_proxy_.reset(new StatisticsProxy(_rtpRtcpModule->SSRC()));
rtp_receive_statistics_->RegisterRtcpStatisticsCallback(
statistics_proxy_.get());
Config audioproc_config;
audioproc_config.Set<ExperimentalAgc>(new ExperimentalAgc(false));
rx_audioproc_.reset(AudioProcessing::Create(audioproc_config));
}
Channel::~Channel()
{
rtp_receive_statistics_->RegisterRtcpStatisticsCallback(NULL);
WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::~Channel() - dtor");
if (_outputExternalMedia)
{
DeRegisterExternalMediaProcessing(kPlaybackPerChannel);
}
if (channel_state_.Get().input_external_media)
{
DeRegisterExternalMediaProcessing(kRecordingPerChannel);
}
StopSend();
StopPlayout();
{
CriticalSectionScoped cs(&_fileCritSect);
if (_inputFilePlayerPtr)
{
_inputFilePlayerPtr->RegisterModuleFileCallback(NULL);
_inputFilePlayerPtr->StopPlayingFile();
FilePlayer::DestroyFilePlayer(_inputFilePlayerPtr);
_inputFilePlayerPtr = NULL;
}
if (_outputFilePlayerPtr)
{
_outputFilePlayerPtr->RegisterModuleFileCallback(NULL);
_outputFilePlayerPtr->StopPlayingFile();
FilePlayer::DestroyFilePlayer(_outputFilePlayerPtr);
_outputFilePlayerPtr = NULL;
}
if (_outputFileRecorderPtr)
{
_outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
_outputFileRecorderPtr->StopRecording();
FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
_outputFileRecorderPtr = NULL;
}
}
// The order to safely shutdown modules in a channel is:
// 1. De-register callbacks in modules
// 2. De-register modules in process thread
// 3. Destroy modules
if (audio_coding_->RegisterTransportCallback(NULL) == -1)
{
WEBRTC_TRACE(kTraceWarning, kTraceVoice,
VoEId(_instanceId,_channelId),
"~Channel() failed to de-register transport callback"
" (Audio coding module)");
}
if (audio_coding_->RegisterVADCallback(NULL) == -1)
{
WEBRTC_TRACE(kTraceWarning, kTraceVoice,
VoEId(_instanceId,_channelId),
"~Channel() failed to de-register VAD callback"
" (Audio coding module)");
}
// De-register modules in process thread
_moduleProcessThreadPtr->DeRegisterModule(_rtpRtcpModule.get());
// End of modules shutdown
// Delete other objects
delete &_callbackCritSect;
delete &_fileCritSect;
delete &volume_settings_critsect_;
}
int32_t
Channel::Init()
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::Init()");
channel_state_.Reset();
// --- Initial sanity
if ((_engineStatisticsPtr == NULL) ||
(_moduleProcessThreadPtr == NULL))
{
WEBRTC_TRACE(kTraceError, kTraceVoice,
VoEId(_instanceId,_channelId),
"Channel::Init() must call SetEngineInformation() first");
return -1;
}
// --- Add modules to process thread (for periodic schedulation)
_moduleProcessThreadPtr->RegisterModule(_rtpRtcpModule.get());
// --- ACM initialization
if (audio_coding_->InitializeReceiver() == -1) {
_engineStatisticsPtr->SetLastError(
VE_AUDIO_CODING_MODULE_ERROR, kTraceError,
"Channel::Init() unable to initialize the ACM - 1");
return -1;
}
// --- RTP/RTCP module initialization
// Ensure that RTCP is enabled by default for the created channel.
// Note that, the module will keep generating RTCP until it is explicitly
// disabled by the user.
// After StopListen (when no sockets exists), RTCP packets will no longer
// be transmitted since the Transport object will then be invalid.
telephone_event_handler_->SetTelephoneEventForwardToDecoder(true);
// RTCP is enabled by default.
_rtpRtcpModule->SetRTCPStatus(RtcpMode::kCompound);
// --- Register all permanent callbacks
const bool fail =
(audio_coding_->RegisterTransportCallback(this) == -1) ||
(audio_coding_->RegisterVADCallback(this) == -1);
if (fail)
{
_engineStatisticsPtr->SetLastError(
VE_CANNOT_INIT_CHANNEL, kTraceError,
"Channel::Init() callbacks not registered");
return -1;
}
// --- Register all supported codecs to the receiving side of the
// RTP/RTCP module
CodecInst codec;
const uint8_t nSupportedCodecs = AudioCodingModule::NumberOfCodecs();
for (int idx = 0; idx < nSupportedCodecs; idx++)
{
// Open up the RTP/RTCP receiver for all supported codecs
if ((audio_coding_->Codec(idx, &codec) == -1) ||
(rtp_receiver_->RegisterReceivePayload(
codec.plname,
codec.pltype,
codec.plfreq,
codec.channels,
(codec.rate < 0) ? 0 : codec.rate) == -1))
{
WEBRTC_TRACE(kTraceWarning, kTraceVoice,
VoEId(_instanceId,_channelId),
"Channel::Init() unable to register %s (%d/%d/%d/%d) "
"to RTP/RTCP receiver",
codec.plname, codec.pltype, codec.plfreq,
codec.channels, codec.rate);
}
else
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice,
VoEId(_instanceId,_channelId),
"Channel::Init() %s (%d/%d/%d/%d) has been added to "
"the RTP/RTCP receiver",
codec.plname, codec.pltype, codec.plfreq,
codec.channels, codec.rate);
}
// Ensure that PCMU is used as default codec on the sending side
if (!STR_CASE_CMP(codec.plname, "PCMU") && (codec.channels == 1))
{
SetSendCodec(codec);
}
// Register default PT for outband 'telephone-event'
if (!STR_CASE_CMP(codec.plname, "telephone-event"))
{
if ((_rtpRtcpModule->RegisterSendPayload(codec) == -1) ||
(audio_coding_->RegisterReceiveCodec(codec) == -1))
{
WEBRTC_TRACE(kTraceWarning, kTraceVoice,
VoEId(_instanceId,_channelId),
"Channel::Init() failed to register outband "
"'telephone-event' (%d/%d) correctly",
codec.pltype, codec.plfreq);
}
}
if (!STR_CASE_CMP(codec.plname, "CN"))
{
if ((audio_coding_->RegisterSendCodec(codec) == -1) ||
(audio_coding_->RegisterReceiveCodec(codec) == -1) ||
(_rtpRtcpModule->RegisterSendPayload(codec) == -1))
{
WEBRTC_TRACE(kTraceWarning, kTraceVoice,
VoEId(_instanceId,_channelId),
"Channel::Init() failed to register CN (%d/%d) "
"correctly - 1",
codec.pltype, codec.plfreq);
}
}
#ifdef WEBRTC_CODEC_RED
// Register RED to the receiving side of the ACM.
// We will not receive an OnInitializeDecoder() callback for RED.
if (!STR_CASE_CMP(codec.plname, "RED"))
{
if (audio_coding_->RegisterReceiveCodec(codec) == -1)
{
WEBRTC_TRACE(kTraceWarning, kTraceVoice,
VoEId(_instanceId,_channelId),
"Channel::Init() failed to register RED (%d/%d) "
"correctly",
codec.pltype, codec.plfreq);
}
}
#endif
}
if (rx_audioproc_->noise_suppression()->set_level(kDefaultNsMode) != 0) {
LOG_FERR1(LS_ERROR, noise_suppression()->set_level, kDefaultNsMode);
return -1;
}
if (rx_audioproc_->gain_control()->set_mode(kDefaultRxAgcMode) != 0) {
LOG_FERR1(LS_ERROR, gain_control()->set_mode, kDefaultRxAgcMode);
return -1;
}
return 0;
}
int32_t
Channel::SetEngineInformation(Statistics& engineStatistics,
OutputMixer& outputMixer,
voe::TransmitMixer& transmitMixer,
ProcessThread& moduleProcessThread,
AudioDeviceModule& audioDeviceModule,
VoiceEngineObserver* voiceEngineObserver,
CriticalSectionWrapper* callbackCritSect)
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::SetEngineInformation()");
_engineStatisticsPtr = &engineStatistics;
_outputMixerPtr = &outputMixer;
_transmitMixerPtr = &transmitMixer,
_moduleProcessThreadPtr = &moduleProcessThread;
_audioDeviceModulePtr = &audioDeviceModule;
_voiceEngineObserverPtr = voiceEngineObserver;
_callbackCritSectPtr = callbackCritSect;
return 0;
}
int32_t
Channel::UpdateLocalTimeStamp()
{
_timeStamp += static_cast<uint32_t>(_audioFrame.samples_per_channel_);
return 0;
}
int32_t
Channel::StartPlayout()
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::StartPlayout()");
if (channel_state_.Get().playing)
{
return 0;
}
if (!_externalMixing) {
// Add participant as candidates for mixing.
if (_outputMixerPtr->SetMixabilityStatus(*this, true) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_AUDIO_CONF_MIX_MODULE_ERROR, kTraceError,
"StartPlayout() failed to add participant to mixer");
return -1;
}
}
channel_state_.SetPlaying(true);
if (RegisterFilePlayingToMixer() != 0)
return -1;
return 0;
}
int32_t
Channel::StopPlayout()
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::StopPlayout()");
if (!channel_state_.Get().playing)
{
return 0;
}
if (!_externalMixing) {
// Remove participant as candidates for mixing
if (_outputMixerPtr->SetMixabilityStatus(*this, false) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_AUDIO_CONF_MIX_MODULE_ERROR, kTraceError,
"StopPlayout() failed to remove participant from mixer");
return -1;
}
}
channel_state_.SetPlaying(false);
_outputAudioLevel.Clear();
return 0;
}
int32_t
Channel::StartSend()
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::StartSend()");
// Resume the previous sequence number which was reset by StopSend().
// This needs to be done before |sending| is set to true.
if (send_sequence_number_)
SetInitSequenceNumber(send_sequence_number_);
if (channel_state_.Get().sending)
{
return 0;
}
channel_state_.SetSending(true);
if (_rtpRtcpModule->SetSendingStatus(true) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_RTP_RTCP_MODULE_ERROR, kTraceError,
"StartSend() RTP/RTCP failed to start sending");
CriticalSectionScoped cs(&_callbackCritSect);
channel_state_.SetSending(false);
return -1;
}
return 0;
}
int32_t
Channel::StopSend()
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::StopSend()");
if (!channel_state_.Get().sending)
{
return 0;
}
channel_state_.SetSending(false);
// Store the sequence number to be able to pick up the same sequence for
// the next StartSend(). This is needed for restarting device, otherwise
// it might cause libSRTP to complain about packets being replayed.
// TODO(xians): Remove this workaround after RtpRtcpModule's refactoring
// CL is landed. See issue
// https://code.google.com/p/webrtc/issues/detail?id=2111 .
send_sequence_number_ = _rtpRtcpModule->SequenceNumber();
// Reset sending SSRC and sequence number and triggers direct transmission
// of RTCP BYE
if (_rtpRtcpModule->SetSendingStatus(false) == -1)
{
_engineStatisticsPtr->SetLastError(
VE_RTP_RTCP_MODULE_ERROR, kTraceWarning,
"StartSend() RTP/RTCP failed to stop sending");
}
return 0;
}
int32_t
Channel::StartReceiving()
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::StartReceiving()");
if (channel_state_.Get().receiving)
{
return 0;
}
channel_state_.SetReceiving(true);
_numberOfDiscardedPackets = 0;
return 0;
}
int32_t
Channel::StopReceiving()
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::StopReceiving()");
if (!channel_state_.Get().receiving)
{
return 0;
}
channel_state_.SetReceiving(false);
return 0;
}
int32_t
Channel::RegisterVoiceEngineObserver(VoiceEngineObserver& observer)
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::RegisterVoiceEngineObserver()");
CriticalSectionScoped cs(&_callbackCritSect);
if (_voiceEngineObserverPtr)
{
_engineStatisticsPtr->SetLastError(
VE_INVALID_OPERATION, kTraceError,
"RegisterVoiceEngineObserver() observer already enabled");
return -1;
}
_voiceEngineObserverPtr = &observer;
return 0;
}
int32_t
Channel::DeRegisterVoiceEngineObserver()
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::DeRegisterVoiceEngineObserver()");
CriticalSectionScoped cs(&_callbackCritSect);
if (!_voiceEngineObserverPtr)
{
_engineStatisticsPtr->SetLastError(
VE_INVALID_OPERATION, kTraceWarning,
"DeRegisterVoiceEngineObserver() observer already disabled");
return 0;
}
_voiceEngineObserverPtr = NULL;
return 0;
}
int32_t
Channel::GetSendCodec(CodecInst& codec)
{
return (audio_coding_->SendCodec(&codec));
}
int32_t
Channel::GetRecCodec(CodecInst& codec)
{
return (audio_coding_->ReceiveCodec(&codec));
}
int32_t
Channel::SetSendCodec(const CodecInst& codec)
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::SetSendCodec()");
if (audio_coding_->RegisterSendCodec(codec) != 0)
{
WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId,_channelId),
"SetSendCodec() failed to register codec to ACM");
return -1;
}
if (_rtpRtcpModule->RegisterSendPayload(codec) != 0)
{
_rtpRtcpModule->DeRegisterSendPayload(codec.pltype);
if (_rtpRtcpModule->RegisterSendPayload(codec) != 0)
{
WEBRTC_TRACE(
kTraceError, kTraceVoice, VoEId(_instanceId,_channelId),
"SetSendCodec() failed to register codec to"
" RTP/RTCP module");
return -1;
}
}
if (_rtpRtcpModule->SetAudioPacketSize(codec.pacsize) != 0)
{
WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId,_channelId),
"SetSendCodec() failed to set audio packet size");
return -1;
}
return 0;
}
void Channel::SetBitRate(int bitrate_bps) {
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
"Channel::SetBitRate(bitrate_bps=%d)", bitrate_bps);
audio_coding_->SetBitRate(bitrate_bps);
}
void Channel::OnIncomingFractionLoss(int fraction_lost) {
network_predictor_->UpdatePacketLossRate(fraction_lost);
uint8_t average_fraction_loss = network_predictor_->GetLossRate();
// Normalizes rate to 0 - 100.
if (audio_coding_->SetPacketLossRate(
100 * average_fraction_loss / 255) != 0) {
assert(false); // This should not happen.
}
}
int32_t
Channel::SetVADStatus(bool enableVAD, ACMVADMode mode, bool disableDTX)
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::SetVADStatus(mode=%d)", mode);
assert(!(disableDTX && enableVAD)); // disableDTX mode is deprecated.
// To disable VAD, DTX must be disabled too
disableDTX = ((enableVAD == false) ? true : disableDTX);
if (audio_coding_->SetVAD(!disableDTX, enableVAD, mode) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_AUDIO_CODING_MODULE_ERROR, kTraceError,
"SetVADStatus() failed to set VAD");
return -1;
}
return 0;
}
int32_t
Channel::GetVADStatus(bool& enabledVAD, ACMVADMode& mode, bool& disabledDTX)
{
if (audio_coding_->VAD(&disabledDTX, &enabledVAD, &mode) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_AUDIO_CODING_MODULE_ERROR, kTraceError,
"GetVADStatus() failed to get VAD status");
return -1;
}
disabledDTX = !disabledDTX;
return 0;
}
int32_t
Channel::SetRecPayloadType(const CodecInst& codec)
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::SetRecPayloadType()");
if (channel_state_.Get().playing)
{
_engineStatisticsPtr->SetLastError(
VE_ALREADY_PLAYING, kTraceError,
"SetRecPayloadType() unable to set PT while playing");
return -1;
}
if (channel_state_.Get().receiving)
{
_engineStatisticsPtr->SetLastError(
VE_ALREADY_LISTENING, kTraceError,
"SetRecPayloadType() unable to set PT while listening");
return -1;
}
if (codec.pltype == -1)
{
// De-register the selected codec (RTP/RTCP module and ACM)
int8_t pltype(-1);
CodecInst rxCodec = codec;
// Get payload type for the given codec
rtp_payload_registry_->ReceivePayloadType(
rxCodec.plname,
rxCodec.plfreq,
rxCodec.channels,
(rxCodec.rate < 0) ? 0 : rxCodec.rate,
&pltype);
rxCodec.pltype = pltype;
if (rtp_receiver_->DeRegisterReceivePayload(pltype) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_RTP_RTCP_MODULE_ERROR,
kTraceError,
"SetRecPayloadType() RTP/RTCP-module deregistration "
"failed");
return -1;
}
if (audio_coding_->UnregisterReceiveCodec(rxCodec.pltype) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_AUDIO_CODING_MODULE_ERROR, kTraceError,
"SetRecPayloadType() ACM deregistration failed - 1");
return -1;
}
return 0;
}
if (rtp_receiver_->RegisterReceivePayload(
codec.plname,
codec.pltype,
codec.plfreq,
codec.channels,
(codec.rate < 0) ? 0 : codec.rate) != 0)
{
// First attempt to register failed => de-register and try again
rtp_receiver_->DeRegisterReceivePayload(codec.pltype);
if (rtp_receiver_->RegisterReceivePayload(
codec.plname,
codec.pltype,
codec.plfreq,
codec.channels,
(codec.rate < 0) ? 0 : codec.rate) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_RTP_RTCP_MODULE_ERROR, kTraceError,
"SetRecPayloadType() RTP/RTCP-module registration failed");
return -1;
}
}
if (audio_coding_->RegisterReceiveCodec(codec) != 0)
{
audio_coding_->UnregisterReceiveCodec(codec.pltype);
if (audio_coding_->RegisterReceiveCodec(codec) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_AUDIO_CODING_MODULE_ERROR, kTraceError,
"SetRecPayloadType() ACM registration failed - 1");
return -1;
}
}
return 0;
}
int32_t
Channel::GetRecPayloadType(CodecInst& codec)
{
int8_t payloadType(-1);
if (rtp_payload_registry_->ReceivePayloadType(
codec.plname,
codec.plfreq,
codec.channels,
(codec.rate < 0) ? 0 : codec.rate,
&payloadType) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_RTP_RTCP_MODULE_ERROR, kTraceWarning,
"GetRecPayloadType() failed to retrieve RX payload type");
return -1;
}
codec.pltype = payloadType;
return 0;
}
int32_t
Channel::SetSendCNPayloadType(int type, PayloadFrequencies frequency)
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::SetSendCNPayloadType()");
CodecInst codec;
int32_t samplingFreqHz(-1);
const int kMono = 1;
if (frequency == kFreq32000Hz)
samplingFreqHz = 32000;
else if (frequency == kFreq16000Hz)
samplingFreqHz = 16000;
if (audio_coding_->Codec("CN", &codec, samplingFreqHz, kMono) == -1)
{
_engineStatisticsPtr->SetLastError(
VE_AUDIO_CODING_MODULE_ERROR, kTraceError,
"SetSendCNPayloadType() failed to retrieve default CN codec "
"settings");
return -1;
}
// Modify the payload type (must be set to dynamic range)
codec.pltype = type;
if (audio_coding_->RegisterSendCodec(codec) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_AUDIO_CODING_MODULE_ERROR, kTraceError,
"SetSendCNPayloadType() failed to register CN to ACM");
return -1;
}
if (_rtpRtcpModule->RegisterSendPayload(codec) != 0)
{
_rtpRtcpModule->DeRegisterSendPayload(codec.pltype);
if (_rtpRtcpModule->RegisterSendPayload(codec) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_RTP_RTCP_MODULE_ERROR, kTraceError,
"SetSendCNPayloadType() failed to register CN to RTP/RTCP "
"module");
return -1;
}
}
return 0;
}
int Channel::SetOpusMaxPlaybackRate(int frequency_hz) {
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
"Channel::SetOpusMaxPlaybackRate()");
if (audio_coding_->SetOpusMaxPlaybackRate(frequency_hz) != 0) {
_engineStatisticsPtr->SetLastError(
VE_AUDIO_CODING_MODULE_ERROR, kTraceError,
"SetOpusMaxPlaybackRate() failed to set maximum playback rate");
return -1;
}
return 0;
}
int Channel::SetOpusDtx(bool enable_dtx) {
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
"Channel::SetOpusDtx(%d)", enable_dtx);
int ret = enable_dtx ? audio_coding_->EnableOpusDtx()
: audio_coding_->DisableOpusDtx();
if (ret != 0) {
_engineStatisticsPtr->SetLastError(
VE_AUDIO_CODING_MODULE_ERROR, kTraceError, "SetOpusDtx() failed");
return -1;
}
return 0;
}
int32_t Channel::RegisterExternalTransport(Transport& transport)
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
"Channel::RegisterExternalTransport()");
CriticalSectionScoped cs(&_callbackCritSect);
if (_externalTransport)
{
_engineStatisticsPtr->SetLastError(VE_INVALID_OPERATION,
kTraceError,
"RegisterExternalTransport() external transport already enabled");
return -1;
}
_externalTransport = true;
_transportPtr = &transport;
return 0;
}
int32_t
Channel::DeRegisterExternalTransport()
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::DeRegisterExternalTransport()");
CriticalSectionScoped cs(&_callbackCritSect);
if (!_transportPtr)
{
_engineStatisticsPtr->SetLastError(
VE_INVALID_OPERATION, kTraceWarning,
"DeRegisterExternalTransport() external transport already "
"disabled");
return 0;
}
_externalTransport = false;
_transportPtr = NULL;
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"DeRegisterExternalTransport() all transport is disabled");
return 0;
}
int32_t Channel::ReceivedRTPPacket(const int8_t* data, size_t length,
const PacketTime& packet_time) {
WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::ReceivedRTPPacket()");
// Store playout timestamp for the received RTP packet
UpdatePlayoutTimestamp(false);
const uint8_t* received_packet = reinterpret_cast<const uint8_t*>(data);
RTPHeader header;
if (!rtp_header_parser_->Parse(received_packet, length, &header)) {
WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVoice, _channelId,
"Incoming packet: invalid RTP header");
return -1;
}
header.payload_type_frequency =
rtp_payload_registry_->GetPayloadTypeFrequency(header.payloadType);
if (header.payload_type_frequency < 0)
return -1;
bool in_order = IsPacketInOrder(header);
rtp_receive_statistics_->IncomingPacket(header, length,
IsPacketRetransmitted(header, in_order));
rtp_payload_registry_->SetIncomingPayloadType(header);
return ReceivePacket(received_packet, length, header, in_order) ? 0 : -1;
}
bool Channel::ReceivePacket(const uint8_t* packet,
size_t packet_length,
const RTPHeader& header,
bool in_order) {
if (rtp_payload_registry_->IsRtx(header)) {
return HandleRtxPacket(packet, packet_length, header);
}
const uint8_t* payload = packet + header.headerLength;
assert(packet_length >= header.headerLength);
size_t payload_length = packet_length - header.headerLength;
PayloadUnion payload_specific;
if (!rtp_payload_registry_->GetPayloadSpecifics(header.payloadType,
&payload_specific)) {
return false;
}
return rtp_receiver_->IncomingRtpPacket(header, payload, payload_length,
payload_specific, in_order);
}
bool Channel::HandleRtxPacket(const uint8_t* packet,
size_t packet_length,
const RTPHeader& header) {
if (!rtp_payload_registry_->IsRtx(header))
return false;
// Remove the RTX header and parse the original RTP header.
if (packet_length < header.headerLength)
return false;
if (packet_length > kVoiceEngineMaxIpPacketSizeBytes)
return false;
if (restored_packet_in_use_) {
WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVoice, _channelId,
"Multiple RTX headers detected, dropping packet");
return false;
}
uint8_t* restored_packet_ptr = restored_packet_;
if (!rtp_payload_registry_->RestoreOriginalPacket(
&restored_packet_ptr, packet, &packet_length, rtp_receiver_->SSRC(),
header)) {
WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVoice, _channelId,
"Incoming RTX packet: invalid RTP header");
return false;
}
restored_packet_in_use_ = true;
bool ret = OnRecoveredPacket(restored_packet_ptr, packet_length);
restored_packet_in_use_ = false;
return ret;
}
bool Channel::IsPacketInOrder(const RTPHeader& header) const {
StreamStatistician* statistician =
rtp_receive_statistics_->GetStatistician(header.ssrc);
if (!statistician)
return false;
return statistician->IsPacketInOrder(header.sequenceNumber);
}
bool Channel::IsPacketRetransmitted(const RTPHeader& header,
bool in_order) const {
// Retransmissions are handled separately if RTX is enabled.
if (rtp_payload_registry_->RtxEnabled())
return false;
StreamStatistician* statistician =
rtp_receive_statistics_->GetStatistician(header.ssrc);
if (!statistician)
return false;
// Check if this is a retransmission.
int64_t min_rtt = 0;
_rtpRtcpModule->RTT(rtp_receiver_->SSRC(), NULL, NULL, &min_rtt, NULL);
return !in_order &&
statistician->IsRetransmitOfOldPacket(header, min_rtt);
}
int32_t Channel::ReceivedRTCPPacket(const int8_t* data, size_t length) {
WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::ReceivedRTCPPacket()");
// Store playout timestamp for the received RTCP packet
UpdatePlayoutTimestamp(true);
// Deliver RTCP packet to RTP/RTCP module for parsing
if (_rtpRtcpModule->IncomingRtcpPacket((const uint8_t*)data, length) == -1) {
_engineStatisticsPtr->SetLastError(
VE_SOCKET_TRANSPORT_MODULE_ERROR, kTraceWarning,
"Channel::IncomingRTPPacket() RTCP packet is invalid");
}
int64_t rtt = GetRTT(true);
if (rtt == 0) {
// Waiting for valid RTT.
return 0;
}
uint32_t ntp_secs = 0;
uint32_t ntp_frac = 0;
uint32_t rtp_timestamp = 0;
if (0 != _rtpRtcpModule->RemoteNTP(&ntp_secs, &ntp_frac, NULL, NULL,
&rtp_timestamp)) {
// Waiting for RTCP.
return 0;
}
{
CriticalSectionScoped lock(ts_stats_lock_.get());
ntp_estimator_.UpdateRtcpTimestamp(rtt, ntp_secs, ntp_frac, rtp_timestamp);
}
return 0;
}
int Channel::StartPlayingFileLocally(const char* fileName,
bool loop,
FileFormats format,
int startPosition,
float volumeScaling,
int stopPosition,
const CodecInst* codecInst)
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::StartPlayingFileLocally(fileNameUTF8[]=%s, loop=%d,"
" format=%d, volumeScaling=%5.3f, startPosition=%d, "
"stopPosition=%d)", fileName, loop, format, volumeScaling,
startPosition, stopPosition);
if (channel_state_.Get().output_file_playing)
{
_engineStatisticsPtr->SetLastError(
VE_ALREADY_PLAYING, kTraceError,
"StartPlayingFileLocally() is already playing");
return -1;
}
{
CriticalSectionScoped cs(&_fileCritSect);
if (_outputFilePlayerPtr)
{
_outputFilePlayerPtr->RegisterModuleFileCallback(NULL);
FilePlayer::DestroyFilePlayer(_outputFilePlayerPtr);
_outputFilePlayerPtr = NULL;
}
_outputFilePlayerPtr = FilePlayer::CreateFilePlayer(
_outputFilePlayerId, (const FileFormats)format);
if (_outputFilePlayerPtr == NULL)
{
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartPlayingFileLocally() filePlayer format is not correct");
return -1;
}
const uint32_t notificationTime(0);
if (_outputFilePlayerPtr->StartPlayingFile(
fileName,
loop,
startPosition,
volumeScaling,
notificationTime,
stopPosition,
(const CodecInst*)codecInst) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_BAD_FILE, kTraceError,
"StartPlayingFile() failed to start file playout");
_outputFilePlayerPtr->StopPlayingFile();
FilePlayer::DestroyFilePlayer(_outputFilePlayerPtr);
_outputFilePlayerPtr = NULL;
return -1;
}
_outputFilePlayerPtr->RegisterModuleFileCallback(this);
channel_state_.SetOutputFilePlaying(true);
}
if (RegisterFilePlayingToMixer() != 0)
return -1;
return 0;
}
int Channel::StartPlayingFileLocally(InStream* stream,
FileFormats format,
int startPosition,
float volumeScaling,
int stopPosition,
const CodecInst* codecInst)
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::StartPlayingFileLocally(format=%d,"
" volumeScaling=%5.3f, startPosition=%d, stopPosition=%d)",
format, volumeScaling, startPosition, stopPosition);
if(stream == NULL)
{
_engineStatisticsPtr->SetLastError(
VE_BAD_FILE, kTraceError,
"StartPlayingFileLocally() NULL as input stream");
return -1;
}
if (channel_state_.Get().output_file_playing)
{
_engineStatisticsPtr->SetLastError(
VE_ALREADY_PLAYING, kTraceError,
"StartPlayingFileLocally() is already playing");
return -1;
}
{
CriticalSectionScoped cs(&_fileCritSect);
// Destroy the old instance
if (_outputFilePlayerPtr)
{
_outputFilePlayerPtr->RegisterModuleFileCallback(NULL);
FilePlayer::DestroyFilePlayer(_outputFilePlayerPtr);
_outputFilePlayerPtr = NULL;
}
// Create the instance
_outputFilePlayerPtr = FilePlayer::CreateFilePlayer(
_outputFilePlayerId,
(const FileFormats)format);
if (_outputFilePlayerPtr == NULL)
{
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartPlayingFileLocally() filePlayer format isnot correct");
return -1;
}
const uint32_t notificationTime(0);
if (_outputFilePlayerPtr->StartPlayingFile(*stream, startPosition,
volumeScaling,
notificationTime,
stopPosition, codecInst) != 0)
{
_engineStatisticsPtr->SetLastError(VE_BAD_FILE, kTraceError,
"StartPlayingFile() failed to "
"start file playout");
_outputFilePlayerPtr->StopPlayingFile();
FilePlayer::DestroyFilePlayer(_outputFilePlayerPtr);
_outputFilePlayerPtr = NULL;
return -1;
}
_outputFilePlayerPtr->RegisterModuleFileCallback(this);
channel_state_.SetOutputFilePlaying(true);
}
if (RegisterFilePlayingToMixer() != 0)
return -1;
return 0;
}
int Channel::StopPlayingFileLocally()
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::StopPlayingFileLocally()");
if (!channel_state_.Get().output_file_playing)
{
return 0;
}
{
CriticalSectionScoped cs(&_fileCritSect);
if (_outputFilePlayerPtr->StopPlayingFile() != 0)
{
_engineStatisticsPtr->SetLastError(
VE_STOP_RECORDING_FAILED, kTraceError,
"StopPlayingFile() could not stop playing");
return -1;
}
_outputFilePlayerPtr->RegisterModuleFileCallback(NULL);
FilePlayer::DestroyFilePlayer(_outputFilePlayerPtr);
_outputFilePlayerPtr = NULL;
channel_state_.SetOutputFilePlaying(false);
}
// _fileCritSect cannot be taken while calling
// SetAnonymousMixibilityStatus. Refer to comments in
// StartPlayingFileLocally(const char* ...) for more details.
if (_outputMixerPtr->SetAnonymousMixabilityStatus(*this, false) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_AUDIO_CONF_MIX_MODULE_ERROR, kTraceError,
"StopPlayingFile() failed to stop participant from playing as"
"file in the mixer");
return -1;
}
return 0;
}
int Channel::IsPlayingFileLocally() const
{
return channel_state_.Get().output_file_playing;
}
int Channel::RegisterFilePlayingToMixer()
{
// Return success for not registering for file playing to mixer if:
// 1. playing file before playout is started on that channel.
// 2. starting playout without file playing on that channel.
if (!channel_state_.Get().playing ||
!channel_state_.Get().output_file_playing)
{
return 0;
}
// |_fileCritSect| cannot be taken while calling
// SetAnonymousMixabilityStatus() since as soon as the participant is added
// frames can be pulled by the mixer. Since the frames are generated from
// the file, _fileCritSect will be taken. This would result in a deadlock.
if (_outputMixerPtr->SetAnonymousMixabilityStatus(*this, true) != 0)
{
channel_state_.SetOutputFilePlaying(false);
CriticalSectionScoped cs(&_fileCritSect);
_engineStatisticsPtr->SetLastError(
VE_AUDIO_CONF_MIX_MODULE_ERROR, kTraceError,
"StartPlayingFile() failed to add participant as file to mixer");
_outputFilePlayerPtr->StopPlayingFile();
FilePlayer::DestroyFilePlayer(_outputFilePlayerPtr);
_outputFilePlayerPtr = NULL;
return -1;
}
return 0;
}
int Channel::StartPlayingFileAsMicrophone(const char* fileName,
bool loop,
FileFormats format,
int startPosition,
float volumeScaling,
int stopPosition,
const CodecInst* codecInst)
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::StartPlayingFileAsMicrophone(fileNameUTF8[]=%s, "
"loop=%d, format=%d, volumeScaling=%5.3f, startPosition=%d, "
"stopPosition=%d)", fileName, loop, format, volumeScaling,
startPosition, stopPosition);
CriticalSectionScoped cs(&_fileCritSect);
if (channel_state_.Get().input_file_playing)
{
_engineStatisticsPtr->SetLastError(
VE_ALREADY_PLAYING, kTraceWarning,
"StartPlayingFileAsMicrophone() filePlayer is playing");
return 0;
}
// Destroy the old instance
if (_inputFilePlayerPtr)
{
_inputFilePlayerPtr->RegisterModuleFileCallback(NULL);
FilePlayer::DestroyFilePlayer(_inputFilePlayerPtr);
_inputFilePlayerPtr = NULL;
}
// Create the instance
_inputFilePlayerPtr = FilePlayer::CreateFilePlayer(
_inputFilePlayerId, (const FileFormats)format);
if (_inputFilePlayerPtr == NULL)
{
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartPlayingFileAsMicrophone() filePlayer format isnot correct");
return -1;
}
const uint32_t notificationTime(0);
if (_inputFilePlayerPtr->StartPlayingFile(
fileName,
loop,
startPosition,
volumeScaling,
notificationTime,
stopPosition,
(const CodecInst*)codecInst) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_BAD_FILE, kTraceError,
"StartPlayingFile() failed to start file playout");
_inputFilePlayerPtr->StopPlayingFile();
FilePlayer::DestroyFilePlayer(_inputFilePlayerPtr);
_inputFilePlayerPtr = NULL;
return -1;
}
_inputFilePlayerPtr->RegisterModuleFileCallback(this);
channel_state_.SetInputFilePlaying(true);
return 0;
}
int Channel::StartPlayingFileAsMicrophone(InStream* stream,
FileFormats format,
int startPosition,
float volumeScaling,
int stopPosition,
const CodecInst* codecInst)
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::StartPlayingFileAsMicrophone(format=%d, "
"volumeScaling=%5.3f, startPosition=%d, stopPosition=%d)",
format, volumeScaling, startPosition, stopPosition);
if(stream == NULL)
{
_engineStatisticsPtr->SetLastError(
VE_BAD_FILE, kTraceError,
"StartPlayingFileAsMicrophone NULL as input stream");
return -1;
}
CriticalSectionScoped cs(&_fileCritSect);
if (channel_state_.Get().input_file_playing)
{
_engineStatisticsPtr->SetLastError(
VE_ALREADY_PLAYING, kTraceWarning,
"StartPlayingFileAsMicrophone() is playing");
return 0;
}
// Destroy the old instance
if (_inputFilePlayerPtr)
{
_inputFilePlayerPtr->RegisterModuleFileCallback(NULL);
FilePlayer::DestroyFilePlayer(_inputFilePlayerPtr);
_inputFilePlayerPtr = NULL;
}
// Create the instance
_inputFilePlayerPtr = FilePlayer::CreateFilePlayer(
_inputFilePlayerId, (const FileFormats)format);
if (_inputFilePlayerPtr == NULL)
{
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartPlayingInputFile() filePlayer format isnot correct");
return -1;
}
const uint32_t notificationTime(0);
if (_inputFilePlayerPtr->StartPlayingFile(*stream, startPosition,
volumeScaling, notificationTime,
stopPosition, codecInst) != 0)
{
_engineStatisticsPtr->SetLastError(VE_BAD_FILE, kTraceError,
"StartPlayingFile() failed to start "
"file playout");
_inputFilePlayerPtr->StopPlayingFile();
FilePlayer::DestroyFilePlayer(_inputFilePlayerPtr);
_inputFilePlayerPtr = NULL;
return -1;
}
_inputFilePlayerPtr->RegisterModuleFileCallback(this);
channel_state_.SetInputFilePlaying(true);
return 0;
}
int Channel::StopPlayingFileAsMicrophone()
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::StopPlayingFileAsMicrophone()");
CriticalSectionScoped cs(&_fileCritSect);
if (!channel_state_.Get().input_file_playing)
{
return 0;
}
if (_inputFilePlayerPtr->StopPlayingFile() != 0)
{
_engineStatisticsPtr->SetLastError(
VE_STOP_RECORDING_FAILED, kTraceError,
"StopPlayingFile() could not stop playing");
return -1;
}
_inputFilePlayerPtr->RegisterModuleFileCallback(NULL);
FilePlayer::DestroyFilePlayer(_inputFilePlayerPtr);
_inputFilePlayerPtr = NULL;
channel_state_.SetInputFilePlaying(false);
return 0;
}
int Channel::IsPlayingFileAsMicrophone() const
{
return channel_state_.Get().input_file_playing;
}
int Channel::StartRecordingPlayout(const char* fileName,
const CodecInst* codecInst)
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::StartRecordingPlayout(fileName=%s)", fileName);
if (_outputFileRecording)
{
WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId,-1),
"StartRecordingPlayout() is already recording");
return 0;
}
FileFormats format;
const uint32_t notificationTime(0); // Not supported in VoE
CodecInst dummyCodec={100,"L16",16000,320,1,320000};
if ((codecInst != NULL) &&
((codecInst->channels < 1) || (codecInst->channels > 2)))
{
_engineStatisticsPtr->SetLastError(
VE_BAD_ARGUMENT, kTraceError,
"StartRecordingPlayout() invalid compression");
return(-1);
}
if(codecInst == NULL)
{
format = kFileFormatPcm16kHzFile;
codecInst=&dummyCodec;
}
else if((STR_CASE_CMP(codecInst->plname,"L16") == 0) ||
(STR_CASE_CMP(codecInst->plname,"PCMU") == 0) ||
(STR_CASE_CMP(codecInst->plname,"PCMA") == 0))
{
format = kFileFormatWavFile;
}
else
{
format = kFileFormatCompressedFile;
}
CriticalSectionScoped cs(&_fileCritSect);
// Destroy the old instance
if (_outputFileRecorderPtr)
{
_outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
_outputFileRecorderPtr = NULL;
}
_outputFileRecorderPtr = FileRecorder::CreateFileRecorder(
_outputFileRecorderId, (const FileFormats)format);
if (_outputFileRecorderPtr == NULL)
{
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartRecordingPlayout() fileRecorder format isnot correct");
return -1;
}
if (_outputFileRecorderPtr->StartRecordingAudioFile(
fileName, (const CodecInst&)*codecInst, notificationTime) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_BAD_FILE, kTraceError,
"StartRecordingAudioFile() failed to start file recording");
_outputFileRecorderPtr->StopRecording();
FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
_outputFileRecorderPtr = NULL;
return -1;
}
_outputFileRecorderPtr->RegisterModuleFileCallback(this);
_outputFileRecording = true;
return 0;
}
int Channel::StartRecordingPlayout(OutStream* stream,
const CodecInst* codecInst)
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::StartRecordingPlayout()");
if (_outputFileRecording)
{
WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId,-1),
"StartRecordingPlayout() is already recording");
return 0;
}
FileFormats format;
const uint32_t notificationTime(0); // Not supported in VoE
CodecInst dummyCodec={100,"L16",16000,320,1,320000};
if (codecInst != NULL && codecInst->channels != 1)
{
_engineStatisticsPtr->SetLastError(
VE_BAD_ARGUMENT, kTraceError,
"StartRecordingPlayout() invalid compression");
return(-1);
}
if(codecInst == NULL)
{
format = kFileFormatPcm16kHzFile;
codecInst=&dummyCodec;
}
else if((STR_CASE_CMP(codecInst->plname,"L16") == 0) ||
(STR_CASE_CMP(codecInst->plname,"PCMU") == 0) ||
(STR_CASE_CMP(codecInst->plname,"PCMA") == 0))
{
format = kFileFormatWavFile;
}
else
{
format = kFileFormatCompressedFile;
}
CriticalSectionScoped cs(&_fileCritSect);
// Destroy the old instance
if (_outputFileRecorderPtr)
{
_outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
_outputFileRecorderPtr = NULL;
}
_outputFileRecorderPtr = FileRecorder::CreateFileRecorder(
_outputFileRecorderId, (const FileFormats)format);
if (_outputFileRecorderPtr == NULL)
{
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartRecordingPlayout() fileRecorder format isnot correct");
return -1;
}
if (_outputFileRecorderPtr->StartRecordingAudioFile(*stream, *codecInst,
notificationTime) != 0)
{
_engineStatisticsPtr->SetLastError(VE_BAD_FILE, kTraceError,
"StartRecordingPlayout() failed to "
"start file recording");
_outputFileRecorderPtr->StopRecording();
FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
_outputFileRecorderPtr = NULL;
return -1;
}
_outputFileRecorderPtr->RegisterModuleFileCallback(this);
_outputFileRecording = true;
return 0;
}
int Channel::StopRecordingPlayout()
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,-1),
"Channel::StopRecordingPlayout()");
if (!_outputFileRecording)
{
WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId,-1),
"StopRecordingPlayout() isnot recording");
return -1;
}
CriticalSectionScoped cs(&_fileCritSect);
if (_outputFileRecorderPtr->StopRecording() != 0)
{
_engineStatisticsPtr->SetLastError(
VE_STOP_RECORDING_FAILED, kTraceError,
"StopRecording() could not stop recording");
return(-1);
}
_outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
_outputFileRecorderPtr = NULL;
_outputFileRecording = false;
return 0;
}
void
Channel::SetMixWithMicStatus(bool mix)
{
CriticalSectionScoped cs(&_fileCritSect);
_mixFileWithMicrophone=mix;
}
int
Channel::GetSpeechOutputLevel(uint32_t& level) const
{
int8_t currentLevel = _outputAudioLevel.Level();
level = static_cast<int32_t> (currentLevel);
return 0;
}
int
Channel::GetSpeechOutputLevelFullRange(uint32_t& level) const
{
int16_t currentLevel = _outputAudioLevel.LevelFullRange();
level = static_cast<int32_t> (currentLevel);
return 0;
}
int
Channel::SetMute(bool enable)
{
CriticalSectionScoped cs(&volume_settings_critsect_);
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::SetMute(enable=%d)", enable);
_mute = enable;
return 0;
}
bool
Channel::Mute() const
{
CriticalSectionScoped cs(&volume_settings_critsect_);
return _mute;
}
int
Channel::SetOutputVolumePan(float left, float right)
{
CriticalSectionScoped cs(&volume_settings_critsect_);
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::SetOutputVolumePan()");
_panLeft = left;
_panRight = right;
return 0;
}
int
Channel::GetOutputVolumePan(float& left, float& right) const
{
CriticalSectionScoped cs(&volume_settings_critsect_);
left = _panLeft;
right = _panRight;
return 0;
}
int
Channel::SetChannelOutputVolumeScaling(float scaling)
{
CriticalSectionScoped cs(&volume_settings_critsect_);
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::SetChannelOutputVolumeScaling()");
_outputGain = scaling;
return 0;
}
int
Channel::GetChannelOutputVolumeScaling(float& scaling) const
{
CriticalSectionScoped cs(&volume_settings_critsect_);
scaling = _outputGain;
return 0;
}
int Channel::SendTelephoneEventOutband(unsigned char eventCode,
int lengthMs, int attenuationDb,
bool playDtmfEvent)
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
"Channel::SendTelephoneEventOutband(..., playDtmfEvent=%d)",
playDtmfEvent);
_playOutbandDtmfEvent = playDtmfEvent;
if (_rtpRtcpModule->SendTelephoneEventOutband(eventCode, lengthMs,
attenuationDb) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_SEND_DTMF_FAILED,
kTraceWarning,
"SendTelephoneEventOutband() failed to send event");
return -1;
}
return 0;
}
int Channel::SendTelephoneEventInband(unsigned char eventCode,
int lengthMs,
int attenuationDb,
bool playDtmfEvent)
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
"Channel::SendTelephoneEventInband(..., playDtmfEvent=%d)",
playDtmfEvent);
_playInbandDtmfEvent = playDtmfEvent;
_inbandDtmfQueue.AddDtmf(eventCode, lengthMs, attenuationDb);
return 0;
}
int
Channel::SetSendTelephoneEventPayloadType(unsigned char type)
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::SetSendTelephoneEventPayloadType()");
if (type > 127)
{
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"SetSendTelephoneEventPayloadType() invalid type");
return -1;
}
CodecInst codec = {};
codec.plfreq = 8000;
codec.pltype = type;
memcpy(codec.plname, "telephone-event", 16);
if (_rtpRtcpModule->RegisterSendPayload(codec) != 0)
{
_rtpRtcpModule->DeRegisterSendPayload(codec.pltype);
if (_rtpRtcpModule->RegisterSendPayload(codec) != 0) {
_engineStatisticsPtr->SetLastError(
VE_RTP_RTCP_MODULE_ERROR, kTraceError,
"SetSendTelephoneEventPayloadType() failed to register send"
"payload type");
return -1;
}
}
_sendTelephoneEventPayloadType = type;
return 0;
}
int
Channel::GetSendTelephoneEventPayloadType(unsigned char& type)
{
type = _sendTelephoneEventPayloadType;
return 0;
}
int
Channel::UpdateRxVadDetection(AudioFrame& audioFrame)
{
WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::UpdateRxVadDetection()");
int vadDecision = 1;
vadDecision = (audioFrame.vad_activity_ == AudioFrame::kVadActive)? 1 : 0;
if ((vadDecision != _oldVadDecision) && _rxVadObserverPtr)
{
OnRxVadDetected(vadDecision);
_oldVadDecision = vadDecision;
}
WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::UpdateRxVadDetection() => vadDecision=%d",
vadDecision);
return 0;
}
int
Channel::RegisterRxVadObserver(VoERxVadCallback &observer)
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::RegisterRxVadObserver()");
CriticalSectionScoped cs(&_callbackCritSect);
if (_rxVadObserverPtr)
{
_engineStatisticsPtr->SetLastError(
VE_INVALID_OPERATION, kTraceError,
"RegisterRxVadObserver() observer already enabled");
return -1;
}
_rxVadObserverPtr = &observer;
_RxVadDetection = true;
return 0;
}
int
Channel::DeRegisterRxVadObserver()
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::DeRegisterRxVadObserver()");
CriticalSectionScoped cs(&_callbackCritSect);
if (!_rxVadObserverPtr)
{
_engineStatisticsPtr->SetLastError(
VE_INVALID_OPERATION, kTraceWarning,
"DeRegisterRxVadObserver() observer already disabled");
return 0;
}
_rxVadObserverPtr = NULL;
_RxVadDetection = false;
return 0;
}
int
Channel::VoiceActivityIndicator(int &activity)
{
activity = _sendFrameType;
return 0;
}
#ifdef WEBRTC_VOICE_ENGINE_AGC
int
Channel::SetRxAgcStatus(bool enable, AgcModes mode)
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::SetRxAgcStatus(enable=%d, mode=%d)",
(int)enable, (int)mode);
GainControl::Mode agcMode = kDefaultRxAgcMode;
switch (mode)
{
case kAgcDefault:
break;
case kAgcUnchanged:
agcMode = rx_audioproc_->gain_control()->mode();
break;
case kAgcFixedDigital:
agcMode = GainControl::kFixedDigital;
break;
case kAgcAdaptiveDigital:
agcMode =GainControl::kAdaptiveDigital;
break;
default:
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"SetRxAgcStatus() invalid Agc mode");
return -1;
}
if (rx_audioproc_->gain_control()->set_mode(agcMode) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_APM_ERROR, kTraceError,
"SetRxAgcStatus() failed to set Agc mode");
return -1;
}
if (rx_audioproc_->gain_control()->Enable(enable) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_APM_ERROR, kTraceError,
"SetRxAgcStatus() failed to set Agc state");
return -1;
}
_rxAgcIsEnabled = enable;
channel_state_.SetRxApmIsEnabled(_rxAgcIsEnabled || _rxNsIsEnabled);
return 0;
}
int
Channel::GetRxAgcStatus(bool& enabled, AgcModes& mode)
{
bool enable = rx_audioproc_->gain_control()->is_enabled();
GainControl::Mode agcMode =
rx_audioproc_->gain_control()->mode();
enabled = enable;
switch (agcMode)
{
case GainControl::kFixedDigital:
mode = kAgcFixedDigital;
break;
case GainControl::kAdaptiveDigital:
mode = kAgcAdaptiveDigital;
break;
default:
_engineStatisticsPtr->SetLastError(
VE_APM_ERROR, kTraceError,
"GetRxAgcStatus() invalid Agc mode");
return -1;
}
return 0;
}
int
Channel::SetRxAgcConfig(AgcConfig config)
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::SetRxAgcConfig()");
if (rx_audioproc_->gain_control()->set_target_level_dbfs(
config.targetLeveldBOv) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_APM_ERROR, kTraceError,
"SetRxAgcConfig() failed to set target peak |level|"
"(or envelope) of the Agc");
return -1;
}
if (rx_audioproc_->gain_control()->set_compression_gain_db(
config.digitalCompressionGaindB) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_APM_ERROR, kTraceError,
"SetRxAgcConfig() failed to set the range in |gain| the"
" digital compression stage may apply");
return -1;
}
if (rx_audioproc_->gain_control()->enable_limiter(
config.limiterEnable) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_APM_ERROR, kTraceError,
"SetRxAgcConfig() failed to set hard limiter to the signal");
return -1;
}
return 0;
}
int
Channel::GetRxAgcConfig(AgcConfig& config)
{
config.targetLeveldBOv =
rx_audioproc_->gain_control()->target_level_dbfs();
config.digitalCompressionGaindB =
rx_audioproc_->gain_control()->compression_gain_db();
config.limiterEnable =
rx_audioproc_->gain_control()->is_limiter_enabled();
return 0;
}
#endif // #ifdef WEBRTC_VOICE_ENGINE_AGC
#ifdef WEBRTC_VOICE_ENGINE_NR
int
Channel::SetRxNsStatus(bool enable, NsModes mode)
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::SetRxNsStatus(enable=%d, mode=%d)",
(int)enable, (int)mode);
NoiseSuppression::Level nsLevel = kDefaultNsMode;
switch (mode)
{
case kNsDefault:
break;
case kNsUnchanged:
nsLevel = rx_audioproc_->noise_suppression()->level();
break;
case kNsConference:
nsLevel = NoiseSuppression::kHigh;
break;
case kNsLowSuppression:
nsLevel = NoiseSuppression::kLow;
break;
case kNsModerateSuppression:
nsLevel = NoiseSuppression::kModerate;
break;
case kNsHighSuppression:
nsLevel = NoiseSuppression::kHigh;
break;
case kNsVeryHighSuppression:
nsLevel = NoiseSuppression::kVeryHigh;
break;
}
if (rx_audioproc_->noise_suppression()->set_level(nsLevel)
!= 0)
{
_engineStatisticsPtr->SetLastError(
VE_APM_ERROR, kTraceError,
"SetRxNsStatus() failed to set NS level");
return -1;
}
if (rx_audioproc_->noise_suppression()->Enable(enable) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_APM_ERROR, kTraceError,
"SetRxNsStatus() failed to set NS state");
return -1;
}
_rxNsIsEnabled = enable;
channel_state_.SetRxApmIsEnabled(_rxAgcIsEnabled || _rxNsIsEnabled);
return 0;
}
int
Channel::GetRxNsStatus(bool& enabled, NsModes& mode)
{
bool enable =
rx_audioproc_->noise_suppression()->is_enabled();
NoiseSuppression::Level ncLevel =
rx_audioproc_->noise_suppression()->level();
enabled = enable;
switch (ncLevel)
{
case NoiseSuppression::kLow:
mode = kNsLowSuppression;
break;
case NoiseSuppression::kModerate:
mode = kNsModerateSuppression;
break;
case NoiseSuppression::kHigh:
mode = kNsHighSuppression;
break;
case NoiseSuppression::kVeryHigh:
mode = kNsVeryHighSuppression;
break;
}
return 0;
}
#endif // #ifdef WEBRTC_VOICE_ENGINE_NR
int
Channel::SetLocalSSRC(unsigned int ssrc)
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
"Channel::SetLocalSSRC()");
if (channel_state_.Get().sending)
{
_engineStatisticsPtr->SetLastError(
VE_ALREADY_SENDING, kTraceError,
"SetLocalSSRC() already sending");
return -1;
}
_rtpRtcpModule->SetSSRC(ssrc);
return 0;
}
int
Channel::GetLocalSSRC(unsigned int& ssrc)
{
ssrc = _rtpRtcpModule->SSRC();
return 0;
}
int
Channel::GetRemoteSSRC(unsigned int& ssrc)
{
ssrc = rtp_receiver_->SSRC();
return 0;
}
int Channel::SetSendAudioLevelIndicationStatus(bool enable, unsigned char id) {
_includeAudioLevelIndication = enable;
return SetSendRtpHeaderExtension(enable, kRtpExtensionAudioLevel, id);
}
int Channel::SetReceiveAudioLevelIndicationStatus(bool enable,
unsigned char id) {
rtp_header_parser_->DeregisterRtpHeaderExtension(
kRtpExtensionAudioLevel);
if (enable && !rtp_header_parser_->RegisterRtpHeaderExtension(
kRtpExtensionAudioLevel, id)) {
return -1;
}
return 0;
}
int Channel::SetSendAbsoluteSenderTimeStatus(bool enable, unsigned char id) {
return SetSendRtpHeaderExtension(enable, kRtpExtensionAbsoluteSendTime, id);
}
int Channel::SetReceiveAbsoluteSenderTimeStatus(bool enable, unsigned char id) {
rtp_header_parser_->DeregisterRtpHeaderExtension(
kRtpExtensionAbsoluteSendTime);
if (enable && !rtp_header_parser_->RegisterRtpHeaderExtension(
kRtpExtensionAbsoluteSendTime, id)) {
return -1;
}
return 0;
}
void Channel::SetRTCPStatus(bool enable) {
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
"Channel::SetRTCPStatus()");
_rtpRtcpModule->SetRTCPStatus(enable ? RtcpMode::kCompound : RtcpMode::kOff);
}
int
Channel::GetRTCPStatus(bool& enabled)
{
RtcpMode method = _rtpRtcpModule->RTCP();
enabled = (method != RtcpMode::kOff);
return 0;
}
int
Channel::SetRTCP_CNAME(const char cName[256])
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
"Channel::SetRTCP_CNAME()");
if (_rtpRtcpModule