#include <map>
#include <vector>
+#include "webrtc/base/thread_annotations.h"
#include "webrtc/call.h"
#include "webrtc/common.h"
#include "webrtc/config.h"
#include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
+#include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h"
#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
#include "webrtc/system_wrappers/interface/rw_lock_wrapper.h"
#include "webrtc/system_wrappers/interface/scoped_ptr.h"
-#include "webrtc/system_wrappers/interface/thread_annotations.h"
#include "webrtc/system_wrappers/interface/trace.h"
#include "webrtc/video/video_receive_stream.h"
#include "webrtc/video/video_send_stream.h"
#include "webrtc/video_engine/include/vie_base.h"
#include "webrtc/video_engine/include/vie_codec.h"
#include "webrtc/video_engine/include/vie_rtp_rtcp.h"
+#include "webrtc/video_engine/include/vie_network.h"
+#include "webrtc/video_engine/include/vie_rtp_rtcp.h"
namespace webrtc {
const char* RtpExtension::kTOffset = "urn:ietf:params:rtp-hdrext:toffset";
const char* RtpExtension::kAbsSendTime =
"http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time";
+
+bool RtpExtension::IsSupported(const std::string& name) {
+ return name == webrtc::RtpExtension::kTOffset ||
+ name == webrtc::RtpExtension::kAbsSendTime;
+}
+
+VideoEncoder* VideoEncoder::Create(VideoEncoder::EncoderType codec_type) {
+ switch (codec_type) {
+ case kVp8:
+ return VP8Encoder::Create();
+ }
+ assert(false);
+ return NULL;
+}
+
namespace internal {
class CpuOveruseObserverProxy : public webrtc::CpuOveruseObserver {
public:
- CpuOveruseObserverProxy(OveruseCallback* overuse_callback)
+ explicit CpuOveruseObserverProxy(OveruseCallback* overuse_callback)
: crit_(CriticalSectionWrapper::CreateCriticalSection()),
overuse_callback_(overuse_callback) {
assert(overuse_callback != NULL);
virtual PacketReceiver* Receiver() OVERRIDE;
- virtual VideoSendStream::Config GetDefaultSendConfig() OVERRIDE;
-
virtual VideoSendStream* CreateVideoSendStream(
- const VideoSendStream::Config& config) OVERRIDE;
+ const VideoSendStream::Config& config,
+ const VideoEncoderConfig& encoder_config) OVERRIDE;
virtual void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream)
OVERRIDE;
- virtual VideoReceiveStream::Config GetDefaultReceiveConfig() OVERRIDE;
-
virtual VideoReceiveStream* CreateVideoReceiveStream(
const VideoReceiveStream::Config& config) OVERRIDE;
virtual uint32_t SendBitrateEstimate() OVERRIDE;
virtual uint32_t ReceiveBitrateEstimate() OVERRIDE;
- virtual bool DeliverPacket(const uint8_t* packet, size_t length) OVERRIDE;
+ virtual DeliveryStatus DeliverPacket(const uint8_t* packet,
+ size_t length) OVERRIDE;
+
+ virtual void SignalNetworkState(NetworkState state) OVERRIDE;
private:
- bool DeliverRtcp(const uint8_t* packet, size_t length);
- bool DeliverRtp(const RTPHeader& header,
- const uint8_t* packet,
- size_t length);
+ DeliveryStatus DeliverRtcp(const uint8_t* packet, size_t length);
+ DeliveryStatus DeliverRtp(const uint8_t* packet, size_t length);
Call::Config config_;
- std::map<uint32_t, VideoReceiveStream*> receive_ssrcs_
- GUARDED_BY(receive_lock_);
- scoped_ptr<RWLockWrapper> receive_lock_;
+ // Needs to be held while write-locking |receive_crit_| or |send_crit_|. This
+ // ensures that we have a consistent network state signalled to all senders
+ // and receivers.
+ scoped_ptr<CriticalSectionWrapper> network_enabled_crit_;
+ bool network_enabled_ GUARDED_BY(network_enabled_crit_);
- std::map<uint32_t, VideoSendStream*> send_ssrcs_ GUARDED_BY(send_lock_);
- scoped_ptr<RWLockWrapper> send_lock_;
+ scoped_ptr<RWLockWrapper> receive_crit_;
+ std::map<uint32_t, VideoReceiveStream*> receive_ssrcs_
+ GUARDED_BY(receive_crit_);
- scoped_ptr<RtpHeaderParser> rtp_header_parser_;
+ scoped_ptr<RWLockWrapper> send_crit_;
+ std::map<uint32_t, VideoSendStream*> send_ssrcs_ GUARDED_BY(send_crit_);
scoped_ptr<CpuOveruseObserverProxy> overuse_observer_proxy_;
+ VideoSendStream::RtpStateMap suspended_send_ssrcs_;
+
VideoEngine* video_engine_;
ViERTP_RTCP* rtp_rtcp_;
ViECodec* codec_;
namespace internal {
+const int kDefaultVideoStreamBitrateBps = 300000;
+
Call::Call(webrtc::VideoEngine* video_engine, const Call::Config& config)
: config_(config),
- receive_lock_(RWLockWrapper::CreateRWLock()),
- send_lock_(RWLockWrapper::CreateRWLock()),
- rtp_header_parser_(RtpHeaderParser::Create()),
+ network_enabled_crit_(CriticalSectionWrapper::CreateCriticalSection()),
+ network_enabled_(true),
+ receive_crit_(RWLockWrapper::CreateRWLock()),
+ send_crit_(RWLockWrapper::CreateRWLock()),
video_engine_(video_engine),
base_channel_id_(-1) {
assert(video_engine != NULL);
PacketReceiver* Call::Receiver() { return this; }
-VideoSendStream::Config Call::GetDefaultSendConfig() {
- VideoSendStream::Config config;
- return config;
-}
-
VideoSendStream* Call::CreateVideoSendStream(
- const VideoSendStream::Config& config) {
+ const VideoSendStream::Config& config,
+ const VideoEncoderConfig& encoder_config) {
assert(config.rtp.ssrcs.size() > 0);
+ // TODO(mflodman): Base the start bitrate on a current bandwidth estimate, if
+ // the call has already started.
VideoSendStream* send_stream = new VideoSendStream(
config_.send_transport,
overuse_observer_proxy_.get(),
video_engine_,
config,
- base_channel_id_);
-
- WriteLockScoped write_lock(*send_lock_);
+ encoder_config,
+ suspended_send_ssrcs_,
+ base_channel_id_,
+ config_.start_bitrate_bps != -1 ? config_.start_bitrate_bps
+ : kDefaultVideoStreamBitrateBps);
+
+ // This needs to be taken before send_crit_ as both locks need to be held
+ // while changing network state.
+ CriticalSectionScoped lock(network_enabled_crit_.get());
+ WriteLockScoped write_lock(*send_crit_);
for (size_t i = 0; i < config.rtp.ssrcs.size(); ++i) {
assert(send_ssrcs_.find(config.rtp.ssrcs[i]) == send_ssrcs_.end());
send_ssrcs_[config.rtp.ssrcs[i]] = send_stream;
}
+ if (!network_enabled_)
+ send_stream->SignalNetworkState(kNetworkDown);
return send_stream;
}
void Call::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) {
assert(send_stream != NULL);
+ send_stream->Stop();
+
VideoSendStream* send_stream_impl = NULL;
{
- WriteLockScoped write_lock(*send_lock_);
- for (std::map<uint32_t, VideoSendStream*>::iterator it =
- send_ssrcs_.begin();
- it != send_ssrcs_.end();
- ++it) {
+ WriteLockScoped write_lock(*send_crit_);
+ std::map<uint32_t, VideoSendStream*>::iterator it = send_ssrcs_.begin();
+ while (it != send_ssrcs_.end()) {
if (it->second == static_cast<VideoSendStream*>(send_stream)) {
send_stream_impl = it->second;
- send_ssrcs_.erase(it);
- break;
+ send_ssrcs_.erase(it++);
+ } else {
+ ++it;
}
}
}
+ VideoSendStream::RtpStateMap rtp_state = send_stream_impl->GetRtpStates();
+
+ for (VideoSendStream::RtpStateMap::iterator it = rtp_state.begin();
+ it != rtp_state.end();
+ ++it) {
+ suspended_send_ssrcs_[it->first] = it->second;
+ }
+
assert(send_stream_impl != NULL);
delete send_stream_impl;
}
-VideoReceiveStream::Config Call::GetDefaultReceiveConfig() {
- VideoReceiveStream::Config config;
- config.rtp.remb = true;
- return config;
-}
-
VideoReceiveStream* Call::CreateVideoReceiveStream(
const VideoReceiveStream::Config& config) {
VideoReceiveStream* receive_stream =
config_.voice_engine,
base_channel_id_);
- WriteLockScoped write_lock(*receive_lock_);
+ // This needs to be taken before receive_crit_ as both locks need to be held
+ // while changing network state.
+ CriticalSectionScoped lock(network_enabled_crit_.get());
+ WriteLockScoped write_lock(*receive_crit_);
assert(receive_ssrcs_.find(config.rtp.remote_ssrc) == receive_ssrcs_.end());
receive_ssrcs_[config.rtp.remote_ssrc] = receive_stream;
// TODO(pbos): Configure different RTX payloads per receive payload.
if (it != config.rtp.rtx.end())
receive_ssrcs_[it->second.ssrc] = receive_stream;
+ if (!network_enabled_)
+ receive_stream->SignalNetworkState(kNetworkDown);
return receive_stream;
}
VideoReceiveStream* receive_stream_impl = NULL;
{
- WriteLockScoped write_lock(*receive_lock_);
+ WriteLockScoped write_lock(*receive_crit_);
// Remove all ssrcs pointing to a receive stream. As RTX retransmits on a
// separate SSRC there can be either one or two.
std::map<uint32_t, VideoReceiveStream*>::iterator it =
return 0;
}
-bool Call::DeliverRtcp(const uint8_t* packet, size_t length) {
+void Call::SignalNetworkState(NetworkState state) {
+ // Take crit for entire function, it needs to be held while updating streams
+ // to guarantee a consistent state across streams.
+ CriticalSectionScoped lock(network_enabled_crit_.get());
+ network_enabled_ = state == kNetworkUp;
+ {
+ ReadLockScoped write_lock(*send_crit_);
+ for (std::map<uint32_t, VideoSendStream*>::iterator it =
+ send_ssrcs_.begin();
+ it != send_ssrcs_.end();
+ ++it) {
+ it->second->SignalNetworkState(state);
+ }
+ }
+ {
+ ReadLockScoped write_lock(*receive_crit_);
+ for (std::map<uint32_t, VideoReceiveStream*>::iterator it =
+ receive_ssrcs_.begin();
+ it != receive_ssrcs_.end();
+ ++it) {
+ it->second->SignalNetworkState(state);
+ }
+ }
+}
+
+PacketReceiver::DeliveryStatus Call::DeliverRtcp(const uint8_t* packet,
+ size_t length) {
// TODO(pbos): Figure out what channel needs it actually.
// Do NOT broadcast! Also make sure it's a valid packet.
+ // Return DELIVERY_UNKNOWN_SSRC if it can be determined that
+ // there's no receiver of the packet.
bool rtcp_delivered = false;
{
- ReadLockScoped read_lock(*receive_lock_);
+ ReadLockScoped read_lock(*receive_crit_);
for (std::map<uint32_t, VideoReceiveStream*>::iterator it =
receive_ssrcs_.begin();
it != receive_ssrcs_.end();
}
{
- ReadLockScoped read_lock(*send_lock_);
+ ReadLockScoped read_lock(*send_crit_);
for (std::map<uint32_t, VideoSendStream*>::iterator it =
send_ssrcs_.begin();
it != send_ssrcs_.end();
rtcp_delivered = true;
}
}
- return rtcp_delivered;
+ return rtcp_delivered ? DELIVERY_OK : DELIVERY_PACKET_ERROR;
}
-bool Call::DeliverRtp(const RTPHeader& header,
- const uint8_t* packet,
- size_t length) {
- ReadLockScoped read_lock(*receive_lock_);
+PacketReceiver::DeliveryStatus Call::DeliverRtp(const uint8_t* packet,
+ size_t length) {
+ // Minimum RTP header size.
+ if (length < 12)
+ return DELIVERY_PACKET_ERROR;
+
+ const uint8_t* ptr = &packet[8];
+ uint32_t ssrc = ptr[0] << 24 | ptr[1] << 16 | ptr[2] << 8 | ptr[3];
+
+ ReadLockScoped read_lock(*receive_crit_);
std::map<uint32_t, VideoReceiveStream*>::iterator it =
- receive_ssrcs_.find(header.ssrc);
- if (it == receive_ssrcs_.end()) {
- // TODO(pbos): Log some warning, SSRC without receiver.
- return false;
- }
- return it->second->DeliverRtp(static_cast<const uint8_t*>(packet), length);
+ receive_ssrcs_.find(ssrc);
+
+ if (it == receive_ssrcs_.end())
+ return DELIVERY_UNKNOWN_SSRC;
+
+ return it->second->DeliverRtp(packet, length) ? DELIVERY_OK
+ : DELIVERY_PACKET_ERROR;
}
-bool Call::DeliverPacket(const uint8_t* packet, size_t length) {
- // TODO(pbos): ExtensionMap if there are extensions.
- if (RtpHeaderParser::IsRtcp(packet, static_cast<int>(length)))
+PacketReceiver::DeliveryStatus Call::DeliverPacket(const uint8_t* packet,
+ size_t length) {
+ if (RtpHeaderParser::IsRtcp(packet, length))
return DeliverRtcp(packet, length);
- RTPHeader rtp_header;
- if (!rtp_header_parser_->Parse(packet, static_cast<int>(length), &rtp_header))
- return false;
-
- return DeliverRtp(rtp_header, packet, length);
+ return DeliverRtp(packet, length);
}
} // namespace internal
projects / platform / framework / web / crosswalk.git / blobdiff