admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replace AudioReceiveStream::DeliverRtp with OnRtpPacket.

Browse Source 
This avoids redoing RTP header parsing already done in Call.

BUG=webrtc:7135

Review-Url: https://codereview.webrtc.org/2697833002
Cr-Commit-Position: refs/heads/master@{#16750}
This commit is contained in:
nisse 2017-02-21 06:28:10 -08:00 committed by Commit bot
parent b94491d790
commit 657bab2455
9 changed files with 60 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
webrtc/audio/audio_receive_stream.cc
View File

@ -298,14 +298,12 @@ bool AudioReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) {
return channel_proxy_->ReceivedRTCPPacket(packet, length);
}
bool AudioReceiveStream::DeliverRtp(const uint8_t* packet,
size_t length,
const PacketTime& packet_time) {
void AudioReceiveStream::OnRtpPacket(const RtpPacketReceived& packet) {
// TODO(solenberg): Tests call this function on a network thread, libjingle
// calls on the worker thread. We should move towards always using a network
// thread. Then this check can be enabled.
// RTC_DCHECK(!thread_checker_.CalledOnValidThread());
return channel_proxy_->ReceivedRTPPacket(packet, length, packet_time);
channel_proxy_->OnRtpPacket(packet);
}
const webrtc::AudioReceiveStream::Config& AudioReceiveStream::config() const {

7
webrtc/audio/audio_receive_stream.h
View File

@ -23,6 +23,7 @@
namespace webrtc {
class PacketRouter;
class RtcEventLog;
class RtpPacketReceived;
namespace voe {
class ChannelProxy;
@ -48,6 +49,9 @@ class AudioReceiveStream final : public webrtc::AudioReceiveStream,
void SetSink(std::unique_ptr<AudioSinkInterface> sink) override;
void SetGain(float gain) override;
// TODO(nisse): Intended to be part of an RtpPacketReceiver interface.
void OnRtpPacket(const RtpPacketReceived& packet);
// AudioMixer::Source
AudioFrameInfo GetAudioFrameWithInfo(int sample_rate_hz,
AudioFrame* audio_frame) override;
@ -63,9 +67,6 @@ class AudioReceiveStream final : public webrtc::AudioReceiveStream,
void AssociateSendStream(AudioSendStream* send_stream);
void SignalNetworkState(NetworkState state);
bool DeliverRtcp(const uint8_t* packet, size_t length);
bool DeliverRtp(const uint8_t* packet,
size_t length,
const PacketTime& packet_time);
const webrtc::AudioReceiveStream::Config& config() const;
private:

14
webrtc/audio/audio_receive_stream_unittest.cc
View File

@ -246,13 +246,15 @@ TEST(AudioReceiveStreamTest, ReceiveRtpPacket) {
std::vector<uint8_t> rtp_packet = CreateRtpHeaderWithOneByteExtension(
kTransportSequenceNumberId, kTransportSequenceNumberValue, 2);
PacketTime packet_time(5678000, 0);
RtpPacketReceived parsed_packet;
ASSERT_TRUE(parsed_packet.Parse(&rtp_packet[0], rtp_packet.size()));
parsed_packet.set_arrival_time_ms((packet_time.timestamp + 500) / 1000);
EXPECT_CALL(*helper.channel_proxy(),
ReceivedRTPPacket(&rtp_packet[0],
rtp_packet.size(),
_))
.WillOnce(Return(true));
EXPECT_TRUE(
recv_stream.DeliverRtp(&rtp_packet[0], rtp_packet.size(), packet_time));
OnRtpPacket(testing::Ref(parsed_packet)));
recv_stream.OnRtpPacket(parsed_packet);
}
TEST(AudioReceiveStreamTest, ReceiveRtcpPacket) {

9
webrtc/call/call.cc
View File

@ -1198,12 +1198,9 @@ PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type,
if (it != audio_receive_ssrcs_.end()) {
received_bytes_per_second_counter_.Add(static_cast<int>(length));
received_audio_bytes_per_second_counter_.Add(static_cast<int>(length));
auto status = it->second->DeliverRtp(packet, length, packet_time)
? DELIVERY_OK
: DELIVERY_PACKET_ERROR;
if (status == DELIVERY_OK)
event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length);
return status;
it->second->OnRtpPacket(*parsed_packet);
event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length);
return DELIVERY_OK;
}
}
if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {

5
webrtc/test/mock_voe_channel_proxy.h
View File

@ -15,6 +15,7 @@
#include "webrtc/test/gmock.h"
#include "webrtc/voice_engine/channel_proxy.h"
#include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h"
namespace webrtc {
namespace test {
@ -52,9 +53,7 @@ class MockVoEChannelProxy : public voe::ChannelProxy {
MOCK_METHOD1(SetInputMute, void(bool muted));
MOCK_METHOD1(RegisterExternalTransport, void(Transport* transport));
MOCK_METHOD0(DeRegisterExternalTransport, void());
MOCK_METHOD3(ReceivedRTPPacket, bool(const uint8_t* packet,
size_t length,
const PacketTime& packet_time));
MOCK_METHOD1(OnRtpPacket, void(const RtpPacketReceived& packet));
MOCK_METHOD2(ReceivedRTCPPacket, bool(const uint8_t* packet, size_t length));
MOCK_CONST_METHOD0(GetAudioDecoderFactory,
const rtc::scoped_refptr<AudioDecoderFactory>&());

43
webrtc/voice_engine/channel.cc
View File

@ -32,6 +32,7 @@
#include "webrtc/modules/rtp_rtcp/include/receive_statistics.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_payload_registry.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_receiver.h"
#include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h"
#include "webrtc/modules/rtp_rtcp/source/rtp_receiver_strategy.h"
#include "webrtc/modules/utility/include/process_thread.h"
#include "webrtc/system_wrappers/include/trace.h"
@ -1560,31 +1561,49 @@ int32_t Channel::DeRegisterExternalTransport() {
return 0;
}
// TODO(nisse): Delete this method together with ReceivedRTPPacket.
// It's a temporary hack to support both ReceivedRTPPacket and
// OnRtpPacket interfaces without too much code duplication.
bool Channel::OnRtpPacketWithHeader(const uint8_t* received_packet,
size_t length,
RTPHeader *header) {
// Store playout timestamp for the received RTP packet
UpdatePlayoutTimestamp(false);
header->payload_type_frequency =
rtp_payload_registry_->GetPayloadTypeFrequency(header->payloadType);
if (header->payload_type_frequency < 0)
return false;
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);
}
int32_t Channel::ReceivedRTPPacket(const uint8_t* received_packet,
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);
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 OnRtpPacketWithHeader(received_packet, length, &header) ? 0 : -1;
}
return ReceivePacket(received_packet, length, header, in_order) ? 0 : -1;
void Channel::OnRtpPacket(const RtpPacketReceived& packet) {
WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, _channelId),
"Channel::ReceivedRTPPacket()");
RTPHeader header;
packet.GetHeader(&header);
OnRtpPacketWithHeader(packet.data(), packet.size(), &header);
}
bool Channel::ReceivePacket(const uint8_t* packet,

6
webrtc/voice_engine/channel.h
View File

@ -53,6 +53,7 @@ class RtcEventLog;
class RTPPayloadRegistry;
class RtpReceiver;
class RTPReceiverAudio;
class RtpPacketReceived;
class RtpRtcp;
class TelephoneEventHandler;
class VoERTPObserver;
@ -204,7 +205,9 @@ class Channel
int32_t ReceivedRTPPacket(const uint8_t* received_packet,
size_t length,
const PacketTime& packet_time);
// TODO(nisse, solenberg): Delete when VoENetwork is deleted.
int32_t ReceivedRTCPPacket(const uint8_t* data, size_t length);
void OnRtpPacket(const RtpPacketReceived& packet);
// VoEFile
int StartPlayingFileLocally(const char* fileName,
@ -391,6 +394,9 @@ class Channel
void OnIncomingFractionLoss(int fraction_lost);
private:
bool OnRtpPacketWithHeader(const uint8_t* received_packet,
size_t length,
RTPHeader *header);
bool ReceivePacket(const uint8_t* packet,
size_t packet_length,
const RTPHeader& header,

6
webrtc/voice_engine/channel_proxy.cc
View File

@ -188,11 +188,9 @@ void ChannelProxy::DeRegisterExternalTransport() {
channel()->DeRegisterExternalTransport();
}
bool ChannelProxy::ReceivedRTPPacket(const uint8_t* packet,
size_t length,
const PacketTime& packet_time) {
void ChannelProxy::OnRtpPacket(const RtpPacketReceived& packet) {
// May be called on either worker thread or network thread.
return channel()->ReceivedRTPPacket(packet, length, packet_time) == 0;
channel()->OnRtpPacket(packet);
}
bool ChannelProxy::ReceivedRTCPPacket(const uint8_t* packet, size_t length) {

5
webrtc/voice_engine/channel_proxy.h
View File

@ -30,6 +30,7 @@ class RtcEventLog;
class RtcpBandwidthObserver;
class RtcpRttStats;
class RtpPacketSender;
class RtpPacketReceived;
class RtpReceiver;
class RtpRtcp;
class Transport;
@ -84,9 +85,7 @@ class ChannelProxy {
virtual void SetInputMute(bool muted);
virtual void RegisterExternalTransport(Transport* transport);
virtual void DeRegisterExternalTransport();
virtual bool ReceivedRTPPacket(const uint8_t* packet,
size_t length,
const PacketTime& packet_time);
virtual void OnRtpPacket(const RtpPacketReceived& packet);
virtual bool ReceivedRTCPPacket(const uint8_t* packet, size_t length);
virtual const rtc::scoped_refptr<AudioDecoderFactory>&
GetAudioDecoderFactory() const;