Upstream version 7.36.149.0

[platform/framework/web/crosswalk.git] / src / media / cast / transport / cast_transport_sender_impl.cc

diff --git a/src/media/cast/transport/cast_transport_sender_impl.cc b/src/media/cast/transport/cast_transport_sender_impl.cc
index b27e2e9..d8ab4a4 100644 (file)
--- a/src/media/cast/transport/cast_transport_sender_impl.cc
+++ b/src/media/cast/transport/cast_transport_sender_impl.cc
@@ -4,7 +4,7 @@
 
 #include "media/cast/transport/cast_transport_sender_impl.h"
 
-#include "base/task_runner.h"
+#include "base/single_thread_task_runner.h"
 #include "media/cast/transport/cast_transport_config.h"
 #include "media/cast/transport/cast_transport_defines.h"
 
@@ -12,49 +12,105 @@ namespace media {
 namespace cast {
 namespace transport {
 
-CastTransportSender* CastTransportSender::CreateCastTransportSender(
+scoped_ptr<CastTransportSender> CastTransportSender::Create(
+    net::NetLog* net_log,
     base::TickClock* clock,
-    const CastTransportConfig& config,
+    const net::IPEndPoint& remote_end_point,
     const CastTransportStatusCallback& status_callback,
-    const scoped_refptr<base::TaskRunner>& transport_task_runner) {
-  return new CastTransportSenderImpl(clock, config, status_callback,
-                                     transport_task_runner.get());
+    const BulkRawEventsCallback& raw_events_callback,
+    base::TimeDelta raw_events_callback_interval,
+    const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner) {
+  return scoped_ptr<CastTransportSender>(
+      new CastTransportSenderImpl(net_log,
+                                  clock,
+                                  remote_end_point,
+                                  status_callback,
+                                  raw_events_callback,
+                                  raw_events_callback_interval,
+                                  transport_task_runner.get(),
+                                  NULL));
 }
 
 CastTransportSenderImpl::CastTransportSenderImpl(
+    net::NetLog* net_log,
     base::TickClock* clock,
-    const CastTransportConfig& config,
+    const net::IPEndPoint& remote_end_point,
     const CastTransportStatusCallback& status_callback,
-    const scoped_refptr<base::TaskRunner>& transport_task_runner)
-    : pacer_(clock, &config, NULL, transport_task_runner, status_callback),
+    const BulkRawEventsCallback& raw_events_callback,
+    base::TimeDelta raw_events_callback_interval,
+    const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner,
+    PacketSender* external_transport)
+    : clock_(clock),
+      status_callback_(status_callback),
+      transport_task_runner_(transport_task_runner),
+      transport_(external_transport ? NULL
+                                    : new UdpTransport(net_log,
+                                                       transport_task_runner,
+                                                       net::IPEndPoint(),
+                                                       remote_end_point,
+                                                       status_callback)),
+      logging_(),
+      pacer_(clock,
+             &logging_,
+             external_transport ? external_transport : transport_.get(),
+             transport_task_runner),
       rtcp_builder_(&pacer_),
-      audio_sender_(config, clock, &pacer_),
-      video_sender_(config, clock, &pacer_) {
-  if (audio_sender_.initialized() && video_sender_.initialized()) {
-    status_callback.Run(TRANSPORT_INITIALIZED);
-  } else {
-    status_callback.Run(TRANSPORT_UNINITIALIZED);
+      raw_events_callback_(raw_events_callback) {
+  if (!raw_events_callback_.is_null()) {
+    DCHECK(raw_events_callback_interval > base::TimeDelta());
+    event_subscriber_.reset(new SimpleEventSubscriber);
+    logging_.AddRawEventSubscriber(event_subscriber_.get());
+    raw_events_timer_.Start(FROM_HERE,
+                            raw_events_callback_interval,
+                            this,
+                            &CastTransportSenderImpl::SendRawEvents);
   }
 }
 
 CastTransportSenderImpl::~CastTransportSenderImpl() {
+  if (event_subscriber_.get())
+    logging_.RemoveRawEventSubscriber(event_subscriber_.get());
+}
+
+void CastTransportSenderImpl::InitializeAudio(
+    const CastTransportAudioConfig& config) {
+  pacer_.RegisterAudioSsrc(config.rtp.config.ssrc);
+  audio_sender_.reset(new TransportAudioSender(
+      config, clock_, transport_task_runner_, &pacer_));
+  if (audio_sender_->initialized())
+    status_callback_.Run(TRANSPORT_AUDIO_INITIALIZED);
+  else
+    status_callback_.Run(TRANSPORT_AUDIO_UNINITIALIZED);
+}
+
+void CastTransportSenderImpl::InitializeVideo(
+    const CastTransportVideoConfig& config) {
+  pacer_.RegisterVideoSsrc(config.rtp.config.ssrc);
+  video_sender_.reset(new TransportVideoSender(
+      config, clock_, transport_task_runner_, &pacer_));
+  if (video_sender_->initialized())
+    status_callback_.Run(TRANSPORT_VIDEO_INITIALIZED);
+  else
+    status_callback_.Run(TRANSPORT_VIDEO_UNINITIALIZED);
 }
 
 void CastTransportSenderImpl::SetPacketReceiver(
-    scoped_refptr<PacketReceiver> packet_receiver) {
-  pacer_.SetPacketReceiver(packet_receiver);
+    const PacketReceiverCallback& packet_receiver) {
+  transport_->StartReceiving(packet_receiver);
 }
 
 void CastTransportSenderImpl::InsertCodedAudioFrame(
     const EncodedAudioFrame* audio_frame,
     const base::TimeTicks& recorded_time) {
-  audio_sender_.InsertCodedAudioFrame(audio_frame, recorded_time);
+  DCHECK(audio_sender_) << "Audio sender uninitialized";
+  audio_sender_->InsertCodedAudioFrame(audio_frame, recorded_time);
 }
 
 void CastTransportSenderImpl::InsertCodedVideoFrame(
     const EncodedVideoFrame* video_frame,
     const base::TimeTicks& capture_time) {
-  video_sender_.InsertCodedVideoFrame(video_frame, capture_time);
+  DCHECK(video_sender_) << "Video sender uninitialized";
+  video_sender_->InsertCodedVideoFrame(video_frame, capture_time);
 }
 
 void CastTransportSenderImpl::SendRtcpFromRtpSender(
@@ -64,38 +120,40 @@ void CastTransportSenderImpl::SendRtcpFromRtpSender(
     const RtcpSenderLogMessage& sender_log,
     uint32 sending_ssrc,
     const std::string& c_name) {
-  rtcp_builder_.SendRtcpFromRtpSender(packet_type_flags,
-                                      sender_info,
-                                      dlrr,
-                                      sender_log,
-                                      sending_ssrc,
-                                      c_name);
+  rtcp_builder_.SendRtcpFromRtpSender(
+      packet_type_flags, sender_info, dlrr, sender_log, sending_ssrc, c_name);
 }
 
 void CastTransportSenderImpl::ResendPackets(
-    bool is_audio, const MissingFramesAndPacketsMap& missing_packets) {
+    bool is_audio,
+    const MissingFramesAndPacketsMap& missing_packets) {
   if (is_audio) {
-    audio_sender_.ResendPackets(missing_packets);
+    DCHECK(audio_sender_) << "Audio sender uninitialized";
+    audio_sender_->ResendPackets(missing_packets);
   } else {
-    video_sender_.ResendPackets(missing_packets);
+    DCHECK(video_sender_) << "Video sender uninitialized";
+    video_sender_->ResendPackets(missing_packets);
   }
 }
 
-void CastTransportSenderImpl::RtpAudioStatistics(
-    const base::TimeTicks& now,
-    RtcpSenderInfo* sender_info) {
-  audio_sender_.GetStatistics(now, sender_info);
+void CastTransportSenderImpl::SubscribeAudioRtpStatsCallback(
+    const CastTransportRtpStatistics& callback) {
+  DCHECK(audio_sender_) << "Audio sender uninitialized";
+  audio_sender_->SubscribeAudioRtpStatsCallback(callback);
 }
 
-void CastTransportSenderImpl::RtpVideoStatistics(
-    const base::TimeTicks& now,
-    RtcpSenderInfo* sender_info) {
-  video_sender_.GetStatistics(now, sender_info);
+void CastTransportSenderImpl::SubscribeVideoRtpStatsCallback(
+    const CastTransportRtpStatistics& callback) {
+  DCHECK(video_sender_) << "Video sender uninitialized";
+  video_sender_->SubscribeVideoRtpStatsCallback(callback);
 }
 
-void CastTransportSenderImpl::InsertFakeTransportForTesting(
-    PacketSender* fake_transport) {
-  pacer_.InsertFakeTransportForTesting(fake_transport);
+void CastTransportSenderImpl::SendRawEvents() {
+  DCHECK(event_subscriber_.get());
+  DCHECK(!raw_events_callback_.is_null());
+  std::vector<PacketEvent> packet_events;
+  event_subscriber_->GetPacketEventsAndReset(&packet_events);
+  raw_events_callback_.Run(packet_events);
 }
 
 }  // namespace transport