b8c55b15a3
RTP packets can be padded with extra data at the end of the payload. The usable payload length of the packet should then be reduced with the padding length, since the padding must be discarded. This was not the case; instead, the entire payload, including padding data, was forwarded to the audio channel and in the end to the decoder. A special case of padding is packets which are empty except for the padding. That is, they carry no usable payload. These packets are sometimes used for probing the network and were discarded in RTPReceiverAudio::ParseAudioCodecSpecific. The result is that NetEq never sees those empty packets, just the holes in the sequence number series; this can throw off the target buffer calculations. With this change, the empty (after removing the padding) packets are let through, all the way down to NetEq, to a new method called NetEq::InsertEmptyPacket. This method notifies the DelayManager that an empty packet was received. BUG=webrtc:7610, webrtc:7625 Review-Url: https://codereview.webrtc.org/2870043003 Cr-Commit-Position: refs/heads/master@{#18083}
314 lines
12 KiB
C++
314 lines
12 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/modules/rtp_rtcp/source/rtp_receiver_audio.h"
|
|
|
|
#include <assert.h> // assert
|
|
#include <math.h> // pow()
|
|
#include <string.h> // memcpy()
|
|
|
|
#include "webrtc/common_types.h"
|
|
#include "webrtc/base/logging.h"
|
|
#include "webrtc/base/trace_event.h"
|
|
|
|
namespace webrtc {
|
|
RTPReceiverStrategy* RTPReceiverStrategy::CreateAudioStrategy(
|
|
RtpData* data_callback) {
|
|
return new RTPReceiverAudio(data_callback);
|
|
}
|
|
|
|
RTPReceiverAudio::RTPReceiverAudio(RtpData* data_callback)
|
|
: RTPReceiverStrategy(data_callback),
|
|
TelephoneEventHandler(),
|
|
telephone_event_forward_to_decoder_(false),
|
|
telephone_event_payload_type_(-1),
|
|
cng_nb_payload_type_(-1),
|
|
cng_wb_payload_type_(-1),
|
|
cng_swb_payload_type_(-1),
|
|
cng_fb_payload_type_(-1),
|
|
num_energy_(0),
|
|
current_remote_energy_() {
|
|
last_payload_.Audio.channels = 1;
|
|
memset(current_remote_energy_, 0, sizeof(current_remote_energy_));
|
|
}
|
|
|
|
// Outband TelephoneEvent(DTMF) detection
|
|
void RTPReceiverAudio::SetTelephoneEventForwardToDecoder(
|
|
bool forward_to_decoder) {
|
|
rtc::CritScope lock(&crit_sect_);
|
|
telephone_event_forward_to_decoder_ = forward_to_decoder;
|
|
}
|
|
|
|
// Is forwarding of outband telephone events turned on/off?
|
|
bool RTPReceiverAudio::TelephoneEventForwardToDecoder() const {
|
|
rtc::CritScope lock(&crit_sect_);
|
|
return telephone_event_forward_to_decoder_;
|
|
}
|
|
|
|
bool RTPReceiverAudio::TelephoneEventPayloadType(
|
|
int8_t payload_type) const {
|
|
rtc::CritScope lock(&crit_sect_);
|
|
return telephone_event_payload_type_ == payload_type;
|
|
}
|
|
|
|
bool RTPReceiverAudio::CNGPayloadType(int8_t payload_type) {
|
|
rtc::CritScope lock(&crit_sect_);
|
|
return payload_type == cng_nb_payload_type_ ||
|
|
payload_type == cng_wb_payload_type_ ||
|
|
payload_type == cng_swb_payload_type_ ||
|
|
payload_type == cng_fb_payload_type_;
|
|
}
|
|
|
|
bool RTPReceiverAudio::ShouldReportCsrcChanges(uint8_t payload_type) const {
|
|
// Don't do this for DTMF packets, otherwise it's fine.
|
|
return !TelephoneEventPayloadType(payload_type);
|
|
}
|
|
|
|
// - Sample based or frame based codecs based on RFC 3551
|
|
// -
|
|
// - NOTE! There is one error in the RFC, stating G.722 uses 8 bits/samples.
|
|
// - The correct rate is 4 bits/sample.
|
|
// -
|
|
// - name of sampling default
|
|
// - encoding sample/frame bits/sample rate ms/frame ms/packet
|
|
// -
|
|
// - Sample based audio codecs
|
|
// - DVI4 sample 4 var. 20
|
|
// - G722 sample 4 16,000 20
|
|
// - G726-40 sample 5 8,000 20
|
|
// - G726-32 sample 4 8,000 20
|
|
// - G726-24 sample 3 8,000 20
|
|
// - G726-16 sample 2 8,000 20
|
|
// - L8 sample 8 var. 20
|
|
// - L16 sample 16 var. 20
|
|
// - PCMA sample 8 var. 20
|
|
// - PCMU sample 8 var. 20
|
|
// -
|
|
// - Frame based audio codecs
|
|
// - G723 frame N/A 8,000 30 30
|
|
// - G728 frame N/A 8,000 2.5 20
|
|
// - G729 frame N/A 8,000 10 20
|
|
// - G729D frame N/A 8,000 10 20
|
|
// - G729E frame N/A 8,000 10 20
|
|
// - GSM frame N/A 8,000 20 20
|
|
// - GSM-EFR frame N/A 8,000 20 20
|
|
// - LPC frame N/A 8,000 20 20
|
|
// - MPA frame N/A var. var.
|
|
// -
|
|
// - G7221 frame N/A
|
|
int32_t RTPReceiverAudio::OnNewPayloadTypeCreated(
|
|
const CodecInst& audio_codec) {
|
|
rtc::CritScope lock(&crit_sect_);
|
|
|
|
if (RtpUtility::StringCompare(audio_codec.plname, "telephone-event", 15)) {
|
|
telephone_event_payload_type_ = audio_codec.pltype;
|
|
}
|
|
if (RtpUtility::StringCompare(audio_codec.plname, "cn", 2)) {
|
|
// We support comfort noise at four different frequencies.
|
|
if (audio_codec.plfreq == 8000) {
|
|
cng_nb_payload_type_ = audio_codec.pltype;
|
|
} else if (audio_codec.plfreq == 16000) {
|
|
cng_wb_payload_type_ = audio_codec.pltype;
|
|
} else if (audio_codec.plfreq == 32000) {
|
|
cng_swb_payload_type_ = audio_codec.pltype;
|
|
} else if (audio_codec.plfreq == 48000) {
|
|
cng_fb_payload_type_ = audio_codec.pltype;
|
|
} else {
|
|
assert(false);
|
|
return -1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int32_t RTPReceiverAudio::ParseRtpPacket(WebRtcRTPHeader* rtp_header,
|
|
const PayloadUnion& specific_payload,
|
|
bool is_red,
|
|
const uint8_t* payload,
|
|
size_t payload_length,
|
|
int64_t timestamp_ms,
|
|
bool is_first_packet) {
|
|
TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "Audio::ParseRtp",
|
|
"seqnum", rtp_header->header.sequenceNumber, "timestamp",
|
|
rtp_header->header.timestamp);
|
|
rtp_header->type.Audio.numEnergy = rtp_header->header.numCSRCs;
|
|
num_energy_ = rtp_header->type.Audio.numEnergy;
|
|
if (rtp_header->type.Audio.numEnergy > 0 &&
|
|
rtp_header->type.Audio.numEnergy <= kRtpCsrcSize) {
|
|
memcpy(current_remote_energy_,
|
|
rtp_header->type.Audio.arrOfEnergy,
|
|
rtp_header->type.Audio.numEnergy);
|
|
}
|
|
|
|
if (first_packet_received_()) {
|
|
LOG(LS_INFO) << "Received first audio RTP packet";
|
|
}
|
|
|
|
return ParseAudioCodecSpecific(rtp_header,
|
|
payload,
|
|
payload_length,
|
|
specific_payload.Audio,
|
|
is_red);
|
|
}
|
|
|
|
RTPAliveType RTPReceiverAudio::ProcessDeadOrAlive(
|
|
uint16_t last_payload_length) const {
|
|
|
|
// Our CNG is 9 bytes; if it's a likely CNG the receiver needs to check
|
|
// kRtpNoRtp against NetEq speech_type kOutputPLCtoCNG.
|
|
if (last_payload_length < 10) { // our CNG is 9 bytes
|
|
return kRtpNoRtp;
|
|
} else {
|
|
return kRtpDead;
|
|
}
|
|
}
|
|
|
|
void RTPReceiverAudio::CheckPayloadChanged(int8_t payload_type,
|
|
PayloadUnion* /* specific_payload */,
|
|
bool* should_discard_changes) {
|
|
*should_discard_changes =
|
|
TelephoneEventPayloadType(payload_type) || CNGPayloadType(payload_type);
|
|
}
|
|
|
|
int RTPReceiverAudio::Energy(uint8_t array_of_energy[kRtpCsrcSize]) const {
|
|
rtc::CritScope cs(&crit_sect_);
|
|
|
|
assert(num_energy_ <= kRtpCsrcSize);
|
|
|
|
if (num_energy_ > 0) {
|
|
memcpy(array_of_energy, current_remote_energy_,
|
|
sizeof(uint8_t) * num_energy_);
|
|
}
|
|
return num_energy_;
|
|
}
|
|
|
|
int32_t RTPReceiverAudio::InvokeOnInitializeDecoder(
|
|
RtpFeedback* callback,
|
|
int8_t payload_type,
|
|
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
|
|
const PayloadUnion& specific_payload) const {
|
|
if (-1 ==
|
|
callback->OnInitializeDecoder(
|
|
payload_type, payload_name, specific_payload.Audio.frequency,
|
|
specific_payload.Audio.channels, specific_payload.Audio.rate)) {
|
|
LOG(LS_ERROR) << "Failed to create decoder for payload type: "
|
|
<< payload_name << "/" << static_cast<int>(payload_type);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// We are not allowed to have any critsects when calling data_callback.
|
|
int32_t RTPReceiverAudio::ParseAudioCodecSpecific(
|
|
WebRtcRTPHeader* rtp_header,
|
|
const uint8_t* payload_data,
|
|
size_t payload_length,
|
|
const AudioPayload& audio_specific,
|
|
bool is_red) {
|
|
RTC_DCHECK_GE(payload_length, rtp_header->header.paddingLength);
|
|
const size_t payload_data_length =
|
|
payload_length - rtp_header->header.paddingLength;
|
|
if (payload_data_length == 0) {
|
|
rtp_header->type.Audio.isCNG = false;
|
|
rtp_header->frameType = kEmptyFrame;
|
|
return data_callback_->OnReceivedPayloadData(nullptr, 0, rtp_header);
|
|
}
|
|
|
|
bool telephone_event_packet =
|
|
TelephoneEventPayloadType(rtp_header->header.payloadType);
|
|
if (telephone_event_packet) {
|
|
rtc::CritScope lock(&crit_sect_);
|
|
|
|
// RFC 4733 2.3
|
|
// 0 1 2 3
|
|
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
|
|
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
|
// | event |E|R| volume | duration |
|
|
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
|
//
|
|
if (payload_data_length % 4 != 0) {
|
|
return -1;
|
|
}
|
|
size_t number_of_events = payload_data_length / 4;
|
|
|
|
// sanity
|
|
if (number_of_events >= MAX_NUMBER_OF_PARALLEL_TELEPHONE_EVENTS) {
|
|
number_of_events = MAX_NUMBER_OF_PARALLEL_TELEPHONE_EVENTS;
|
|
}
|
|
for (size_t n = 0; n < number_of_events; ++n) {
|
|
RTC_DCHECK_GE(payload_data_length, (4 * n) + 2);
|
|
bool end = (payload_data[(4 * n) + 1] & 0x80) ? true : false;
|
|
|
|
std::set<uint8_t>::iterator event =
|
|
telephone_event_reported_.find(payload_data[4 * n]);
|
|
|
|
if (event != telephone_event_reported_.end()) {
|
|
// we have already seen this event
|
|
if (end) {
|
|
telephone_event_reported_.erase(payload_data[4 * n]);
|
|
}
|
|
} else {
|
|
if (end) {
|
|
// don't add if it's a end of a tone
|
|
} else {
|
|
telephone_event_reported_.insert(payload_data[4 * n]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// RFC 4733 2.5.1.3 & 2.5.2.3 Long-Duration Events
|
|
// should not be a problem since we don't care about the duration
|
|
|
|
// RFC 4733 See 2.5.1.5. & 2.5.2.4. Multiple Events in a Packet
|
|
}
|
|
|
|
{
|
|
rtc::CritScope lock(&crit_sect_);
|
|
|
|
// Check if this is a CNG packet, receiver might want to know
|
|
if (CNGPayloadType(rtp_header->header.payloadType)) {
|
|
rtp_header->type.Audio.isCNG = true;
|
|
rtp_header->frameType = kAudioFrameCN;
|
|
} else {
|
|
rtp_header->frameType = kAudioFrameSpeech;
|
|
rtp_header->type.Audio.isCNG = false;
|
|
}
|
|
|
|
// check if it's a DTMF event, hence something we can playout
|
|
if (telephone_event_packet) {
|
|
if (!telephone_event_forward_to_decoder_) {
|
|
// don't forward event to decoder
|
|
return 0;
|
|
}
|
|
std::set<uint8_t>::iterator first =
|
|
telephone_event_reported_.begin();
|
|
if (first != telephone_event_reported_.end() && *first > 15) {
|
|
// don't forward non DTMF events
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
// TODO(holmer): Break this out to have RED parsing handled generically.
|
|
RTC_DCHECK_GT(payload_data_length, 0);
|
|
if (is_red && !(payload_data[0] & 0x80)) {
|
|
// we recive only one frame packed in a RED packet remove the RED wrapper
|
|
rtp_header->header.payloadType = payload_data[0];
|
|
|
|
// only one frame in the RED strip the one byte to help NetEq
|
|
return data_callback_->OnReceivedPayloadData(
|
|
payload_data + 1, payload_data_length - 1, rtp_header);
|
|
}
|
|
|
|
rtp_header->type.Audio.channel = audio_specific.channels;
|
|
return data_callback_->OnReceivedPayloadData(payload_data,
|
|
payload_data_length, rtp_header);
|
|
}
|
|
} // namespace webrtc
|