generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Rename newapi::Transport::SendRTP()->SendRtp().

Browse Source 
Also fit rampup_tests.cc to use internal::TransportAdapter instead of
implementing its own.

BUG=
R=mflodman@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/3419004

git-svn-id: http://webrtc.googlecode.com/svn/trunk@5138 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
pbos@webrtc.org 2013-11-20 12:17:04 +00:00
parent ce90eff345
commit 27326b6a42
9 changed files with 26 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
webrtc/test/direct_transport.cc
View File

@ -57,12 +57,12 @@ void DirectTransport::SetReceiver(PacketReceiver* receiver) {
receiver_ = receiver;
}
bool DirectTransport::SendRTP(const uint8_t* data, size_t length) {
bool DirectTransport::SendRtp(const uint8_t* data, size_t length) {
QueuePacket(data, length, clock_->TimeInMilliseconds() + delay_ms_);
return true;
}
bool DirectTransport::SendRTCP(const uint8_t* data, size_t length) {
bool DirectTransport::SendRtcp(const uint8_t* data, size_t length) {
QueuePacket(data, length, clock_->TimeInMilliseconds() + delay_ms_);
return true;
}

4
webrtc/test/direct_transport.h
View File

@ -36,8 +36,8 @@ class DirectTransport : public newapi::Transport {
virtual void StopSending();
virtual void SetReceiver(PacketReceiver* receiver);
virtual bool SendRTP(const uint8_t* data, size_t length) OVERRIDE;
virtual bool SendRTCP(const uint8_t* data, size_t length) OVERRIDE;
virtual bool SendRtp(const uint8_t* data, size_t length) OVERRIDE;
virtual bool SendRtcp(const uint8_t* data, size_t length) OVERRIDE;
private:
struct Packet {

4
webrtc/test/null_transport.cc
View File

@ -12,11 +12,11 @@
namespace webrtc {
namespace test {
bool NullTransport::SendRTP(const uint8_t* packet, size_t length) {
bool NullTransport::SendRtp(const uint8_t* packet, size_t length) {
return true;
}
bool NullTransport::SendRTCP(const uint8_t* packet, size_t length) {
bool NullTransport::SendRtcp(const uint8_t* packet, size_t length) {
return true;
}

4
webrtc/test/null_transport.h
View File

@ -19,8 +19,8 @@ class PacketReceiver;
namespace test {
class NullTransport : public newapi::Transport {
public:
virtual bool SendRTP(const uint8_t* packet, size_t length) OVERRIDE;
virtual bool SendRTCP(const uint8_t* packet, size_t length) OVERRIDE;
virtual bool SendRtp(const uint8_t* packet, size_t length) OVERRIDE;
virtual bool SendRtcp(const uint8_t* packet, size_t length) OVERRIDE;
};
} // namespace test
} // namespace webrtc

8
webrtc/test/rtp_rtcp_observer.h
View File

@ -118,7 +118,7 @@ class RtpRtcpObserver {
on_rtcp_(on_rtcp) {}
private:
virtual bool SendRTP(const uint8_t* packet, size_t length) OVERRIDE {
virtual bool SendRtp(const uint8_t* packet, size_t length) OVERRIDE {
Action action;
{
CriticalSectionScoped crit_(lock_);
@ -129,12 +129,12 @@ class RtpRtcpObserver {
// Drop packet silently.
return true;
case SEND_PACKET:
return test::DirectTransport::SendRTP(packet, length);
return test::DirectTransport::SendRtp(packet, length);
}
return true; // Will never happen, makes compiler happy.
}
virtual bool SendRTCP(const uint8_t* packet, size_t length) OVERRIDE {
virtual bool SendRtcp(const uint8_t* packet, size_t length) OVERRIDE {
Action action;
{
CriticalSectionScoped crit_(lock_);
@ -145,7 +145,7 @@ class RtpRtcpObserver {
// Drop packet silently.
return true;
case SEND_PACKET:
return test::DirectTransport::SendRTCP(packet, length);
return test::DirectTransport::SendRtcp(packet, length);
}
return true; // Will never happen, makes compiler happy.
}

4
webrtc/transport.h
View File

@ -20,8 +20,8 @@ namespace newapi {
class Transport {
public:
virtual bool SendRTP(const uint8_t* packet, size_t length) = 0;
virtual bool SendRTCP(const uint8_t* packet, size_t length) = 0;
virtual bool SendRtp(const uint8_t* packet, size_t length) = 0;
virtual bool SendRtcp(const uint8_t* packet, size_t length) = 0;
protected:
virtual ~Transport() {}

8
webrtc/video/full_stack.cc
View File

@ -149,7 +149,7 @@ class VideoAnalyzer : public PacketReceiver,
input_->PutFrame(video_frame, delta_capture_ms);
}
virtual bool SendRTP(const uint8_t* packet, size_t length) OVERRIDE {
virtual bool SendRtp(const uint8_t* packet, size_t length) OVERRIDE {
scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
RTPHeader header;
parser->Parse(packet, static_cast<int>(length), &header);
@ -165,11 +165,11 @@ class VideoAnalyzer : public PacketReceiver,
Clock::GetRealTimeClock()->CurrentNtpInMilliseconds();
}
return transport_->SendRTP(packet, length);
return transport_->SendRtp(packet, length);
}
virtual bool SendRTCP(const uint8_t* packet, size_t length) OVERRIDE {
return transport_->SendRTCP(packet, length);
virtual bool SendRtcp(const uint8_t* packet, size_t length) OVERRIDE {
return transport_->SendRtcp(packet, length);
}
virtual void RenderFrame(const I420VideoFrame& video_frame,

34
webrtc/video/rampup_tests.cc
View File

@ -27,6 +27,7 @@
#include "webrtc/test/fake_encoder.h"
#include "webrtc/test/frame_generator_capturer.h"
#include "webrtc/test/generate_ssrcs.h"
#include "webrtc/video/transport_adapter.h"
namespace webrtc {
@ -43,7 +44,7 @@ class StreamObserver : public newapi::Transport, public RemoteBitrateObserver {
: critical_section_(CriticalSectionWrapper::CreateCriticalSection()),
all_ssrcs_sent_(EventWrapper::Create()),
rtp_parser_(RtpHeaderParser::Create()),
feedback_transport_(new TransportWrapper(feedback_transport)),
feedback_transport_(feedback_transport),
receive_stats_(ReceiveStatistics::Create(clock)),
clock_(clock),
num_expected_ssrcs_(num_expected_ssrcs) {
@ -53,7 +54,7 @@ class StreamObserver : public newapi::Transport, public RemoteBitrateObserver {
// be able to produce an RTCP with REMB.
RtpRtcp::Configuration config;
config.receive_statistics = receive_stats_.get();
config.outgoing_transport = feedback_transport_.get();
config.outgoing_transport = &feedback_transport_;
rtp_rtcp_.reset(RtpRtcp::CreateRtpRtcp(config));
rtp_rtcp_->SetREMBStatus(true);
rtp_rtcp_->SetRTCPStatus(kRtcpNonCompound);
@ -73,7 +74,7 @@ class StreamObserver : public newapi::Transport, public RemoteBitrateObserver {
rtp_rtcp_->Process();
}
virtual bool SendRTP(const uint8_t* packet, size_t length) OVERRIDE {
virtual bool SendRtp(const uint8_t* packet, size_t length) OVERRIDE {
CriticalSectionScoped lock(critical_section_.get());
RTPHeader header;
EXPECT_TRUE(rtp_parser_->Parse(packet, static_cast<int>(length), &header));
@ -87,43 +88,20 @@ class StreamObserver : public newapi::Transport, public RemoteBitrateObserver {
return true;
}
virtual bool SendRTCP(const uint8_t* packet, size_t length) OVERRIDE {
virtual bool SendRtcp(const uint8_t* packet, size_t length) OVERRIDE {
return true;
}
EventTypeWrapper Wait() { return all_ssrcs_sent_->Wait(120 * 1000); }
private:
class TransportWrapper : public webrtc::Transport {
public:
explicit TransportWrapper(newapi::Transport* new_transport)
: new_transport_(new_transport) {}
virtual int SendPacket(int channel, const void* data, int len) OVERRIDE {
return new_transport_->SendRTP(static_cast<const uint8_t*>(data), len)
? len
: -1;
}
virtual int SendRTCPPacket(int channel,
const void* data,
int len) OVERRIDE {
return new_transport_->SendRTCP(static_cast<const uint8_t*>(data), len)
? len
: -1;
}
private:
newapi::Transport* new_transport_;
};
static const unsigned int kExpectedBitrateBps = 1200000;
scoped_ptr<CriticalSectionWrapper> critical_section_;
scoped_ptr<EventWrapper> all_ssrcs_sent_;
scoped_ptr<RtpHeaderParser> rtp_parser_;
scoped_ptr<RtpRtcp> rtp_rtcp_;
scoped_ptr<TransportWrapper> feedback_transport_;
internal::TransportAdapter feedback_transport_;
scoped_ptr<ReceiveStatistics> receive_stats_;
scoped_ptr<RemoteBitrateEstimator> remote_bitrate_estimator_;
Clock* clock_;

4
webrtc/video/transport_adapter.cc
View File

@ -19,7 +19,7 @@ TransportAdapter::TransportAdapter(newapi::Transport* transport)
int TransportAdapter::SendPacket(int /*channel*/,
const void* packet,
int length) {
bool success = transport_->SendRTP(static_cast<const uint8_t*>(packet),
bool success = transport_->SendRtp(static_cast<const uint8_t*>(packet),
static_cast<size_t>(length));
return success ? length : -1;
}
@ -27,7 +27,7 @@ int TransportAdapter::SendPacket(int /*channel*/,
int TransportAdapter::SendRTCPPacket(int /*channel*/,
const void* packet,
int length) {
bool success = transport_->SendRTCP(static_cast<const uint8_t*>(packet),
bool success = transport_->SendRtcp(static_cast<const uint8_t*>(packet),
static_cast<size_t>(length));
return success ? length : -1;
}