Cast: Refactoring Cast API's

media/cast/test/sender.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Test application that simulates a cast sender - Data can be either generated
 // or read from a file.
 
 #include "base/at_exit.h"
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 187 matching lines @@
   video_config.max_number_of_video_buffers_used = 1;
   video_config.number_of_cores = 1;
   return video_config;
 }
 
 class SendProcess {
  public:
   SendProcess(scoped_refptr<base::SingleThreadTaskRunner> thread_proxy,
               base::TickClock* clock,
               const VideoSenderConfig& video_config,
-              FrameInput* frame_input)
+              scoped_refptr<AudioFrameInput> audio_frame_input,
+              scoped_refptr<VideoFrameInput> video_frame_input)
       : test_app_thread_proxy_(thread_proxy),
         video_config_(video_config),
         audio_diff_(kFrameTimerMs),
-        frame_input_(frame_input),
+        audio_frame_input_(audio_frame_input),
+        video_frame_input_(video_frame_input),
         synthetic_count_(0),
         clock_(clock),
         start_time_(),
         send_time_(),
         weak_factory_(this) {
     audio_bus_factory_.reset(new TestAudioBusFactory(kAudioChannels,
                                                      kAudioSamplingFrequency,
                                                      kSoundFrequency,
                                                      kSoundVolume));
     if (ReadFromFile()) {
@@ skipping 15 matching lines @@
 
   void SendFrame() {
     // Make sure that we don't drift.
     int num_10ms_blocks = audio_diff_ / 10;
     // Avoid drift.
     audio_diff_ += kFrameTimerMs - num_10ms_blocks * 10;
 
     scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
         base::TimeDelta::FromMilliseconds(10) * num_10ms_blocks));
     AudioBus* const audio_bus_ptr = audio_bus.get();
-    frame_input_->InsertAudio(
+    audio_frame_input_->InsertAudio(
         audio_bus_ptr,
         clock_->NowTicks(),
         base::Bind(&OwnThatAudioBus, base::Passed(&audio_bus)));
 
     gfx::Size size(video_config_.width, video_config_.height);
     // TODO(mikhal): Use the provided timestamp.
     if (start_time_.is_null())
       start_time_ = clock_->NowTicks();
     base::TimeDelta time_diff = clock_->NowTicks() - start_time_;
     scoped_refptr<media::VideoFrame> video_frame =
@@ skipping 11 matching lines @@
     // Sleep if that time has yet to elapse.
     base::TimeTicks now = clock_->NowTicks();
     base::TimeDelta video_frame_time =
         base::TimeDelta::FromMilliseconds(kFrameTimerMs);
     base::TimeDelta elapsed_time = now - send_time_;
     if (elapsed_time < video_frame_time) {
       VLOG(1) << "Wait" << (video_frame_time - elapsed_time).InMilliseconds();
       test_app_thread_proxy_->PostDelayedTask(
           FROM_HERE,
           base::Bind(&SendProcess::SendVideoFrameOnTime,
-                     base::Unretained(this),
+                     weak_factory_.GetWeakPtr(),
                      video_frame),
           video_frame_time - elapsed_time);
     } else {
       test_app_thread_proxy_->PostTask(
           FROM_HERE,
           base::Bind(&SendProcess::SendVideoFrameOnTime,
-                     base::Unretained(this),
+                     weak_factory_.GetWeakPtr(),
                      video_frame));
     }
   }
 
   void SendVideoFrameOnTime(scoped_refptr<media::VideoFrame> video_frame) {
     send_time_ = clock_->NowTicks();
-    frame_input_->InsertRawVideoFrame(video_frame, send_time_);
+    video_frame_input_->InsertRawVideoFrame(video_frame, send_time_);
     test_app_thread_proxy_->PostTask(
         FROM_HERE, base::Bind(&SendProcess::SendFrame, base::Unretained(this)));
   }
 
  private:
   scoped_refptr<base::SingleThreadTaskRunner> test_app_thread_proxy_;
   const VideoSenderConfig video_config_;
   int audio_diff_;
-  const scoped_refptr<FrameInput> frame_input_;
+  const scoped_refptr<AudioFrameInput> audio_frame_input_;
+  const scoped_refptr<VideoFrameInput> video_frame_input_;
   FILE* video_file_;
   uint8 synthetic_count_;
   base::TickClock* const clock_;  // Not owned by this class.
   base::TimeTicks start_time_;
   base::TimeTicks send_time_;
   scoped_ptr<TestAudioBusFactory> audio_bus_factory_;
   base::WeakPtrFactory<SendProcess> weak_factory_;
 };
 
 }  // namespace cast
 }  // namespace media
 
 namespace {
 void UpdateCastTransportStatus(
     media::cast::transport::CastTransportStatus status) {}
 
 void InitializationResult(media::cast::CastInitializationStatus result) {
-  CHECK_EQ(result, media::cast::STATUS_INITIALIZED);
-  VLOG(1) << "Cast Sender initialized";
+  bool end_result = result == media::cast::STATUS_AUDIO_INITIALIZED ||
+                    result == media::cast::STATUS_VIDEO_INITIALIZED;
+  CHECK(end_result);

[Alpha Left Google, 2014/03/06 23:10:04]

This should give a log message if !end_result is true.

[mikhal1, 2014/03/06 23:38:53]

Done.

 }
 
 net::IPEndPoint CreateUDPAddress(std::string ip_str, int port) {
   net::IPAddressNumber ip_number;
   CHECK(net::ParseIPLiteralToNumber(ip_str, &ip_number));
   return net::IPEndPoint(ip_number, port);
 }
 
 void WriteLogsToFileAndStopSubscribing(
     const scoped_refptr<media::cast::CastEnvironment>& cast_environment,
     scoped_ptr<media::cast::EncodingEventSubscriber> video_event_subscriber,
     scoped_ptr<media::cast::EncodingEventSubscriber> audio_event_subscriber,
     file_util::ScopedFILE log_file) {
   media::cast::LogSerializer serializer(media::cast::kMaxSerializedLogBytes);
 
   // Serialize video events.
   cast_environment->Logging()->RemoveRawEventSubscriber(
       video_event_subscriber.get());
   media::cast::FrameEventMap frame_events;
   media::cast::PacketEventMap packet_events;
   media::cast::RtpTimestamp first_rtp_timestamp;
-  video_event_subscriber->GetEventsAndReset(&frame_events, &packet_events,
-                                            &first_rtp_timestamp);
+  video_event_subscriber->GetEventsAndReset(
+      &frame_events, &packet_events, &first_rtp_timestamp);
 
   VLOG(0) << "Video frame map size: " << frame_events.size();
   VLOG(0) << "Video packet map size: " << packet_events.size();
 
-  if (!serializer.SerializeEventsForStream(false, frame_events, packet_events,
-                                           first_rtp_timestamp)) {
+  if (!serializer.SerializeEventsForStream(
+          false, frame_events, packet_events, first_rtp_timestamp)) {
     VLOG(1) << "Failed to serialize video events.";
     return;
   }
 
   int length_so_far = serializer.GetSerializedLength();
   VLOG(0) << "Video events serialized length: " << length_so_far;
 
   // Serialize audio events.
   cast_environment->Logging()->RemoveRawEventSubscriber(
       audio_event_subscriber.get());
-  audio_event_subscriber->GetEventsAndReset(&frame_events, &packet_events,
-                                            &first_rtp_timestamp);
+  audio_event_subscriber->GetEventsAndReset(
+      &frame_events, &packet_events, &first_rtp_timestamp);
 
   VLOG(0) << "Audio frame map size: " << frame_events.size();
   VLOG(0) << "Audio packet map size: " << packet_events.size();
 
-  if (!serializer.SerializeEventsForStream(true, frame_events, packet_events,
-                                           first_rtp_timestamp)) {
+  if (!serializer.SerializeEventsForStream(
+          true, frame_events, packet_events, first_rtp_timestamp)) {
     VLOG(1) << "Failed to serialize audio events.";
     return;
   }
 
   VLOG(0) << "Audio events serialized length: "
           << serializer.GetSerializedLength() - length_so_far;
 
   scoped_ptr<std::string> serialized_string =
       serializer.GetSerializedLogAndReset();
   VLOG(0) << "Serialized string size: " << serialized_string->size();
 
   size_t ret = fwrite(
       &(*serialized_string)[0], 1, serialized_string->size(), log_file.get());
   if (ret != serialized_string->size())
     VLOG(1) << "Failed to write logs to file.";
 }
 
 }  // namespace
 
 int main(int argc, char** argv) {
   base::AtExitManager at_exit;
-  VLOG(1) << "Cast Sender";
   base::Thread test_thread("Cast sender test app thread");
   base::Thread audio_thread("Cast audio encoder thread");
   base::Thread video_thread("Cast video encoder thread");
   test_thread.Start();
   audio_thread.Start();
   video_thread.Start();
 
   scoped_ptr<base::TickClock> clock(new base::DefaultTickClock());
   base::MessageLoopForIO io_message_loop;
 
@@ skipping 37 matching lines @@
       new media::cast::CastEnvironment(
           clock.Pass(),
           io_message_loop.message_loop_proxy(),
           audio_thread.message_loop_proxy(),
           NULL,
           video_thread.message_loop_proxy(),
           NULL,
           io_message_loop.message_loop_proxy(),
           media::cast::GetLoggingConfigWithRawEventsAndStatsEnabled()));
 
-  scoped_ptr<media::cast::CastSender> cast_sender(
-      media::cast::CastSender::CreateCastSender(
-          cast_environment,
-          &audio_config,
-          &video_config,
-          NULL,  // gpu_factories.
-          base::Bind(&InitializationResult),
-          transport_sender.get()));
+  scoped_ptr<media::cast::CastSender> cast_sender =
+      media::cast::CastSender::Create(cast_environment, transport_sender.get());
+
+  cast_sender->InitializeVideo(
+      video_config, base::Bind(&InitializationResult), NULL);
+  cast_sender->InitializeAudio(audio_config, base::Bind(&InitializationResult));
 
   transport_sender->SetPacketReceiver(cast_sender->packet_receiver());
 
-  media::cast::FrameInput* frame_input = cast_sender->frame_input();
+  scoped_refptr<media::cast::AudioFrameInput> audio_frame_input =
+      cast_sender->audio_frame_input();
+  scoped_refptr<media::cast::VideoFrameInput> video_frame_input =
+      cast_sender->video_frame_input();
   scoped_ptr<media::cast::SendProcess> send_process(
       new media::cast::SendProcess(test_thread.message_loop_proxy(),
                                    cast_environment->Clock(),
                                    video_config,
-                                   frame_input));
+                                   audio_frame_input,
+                                   video_frame_input));
 
   // Set up event subscribers.
   // TODO(imcheng): Set up separate subscribers for audio / video / other.
   int logging_duration = media::cast::GetLoggingDuration();
   scoped_ptr<media::cast::EncodingEventSubscriber> video_event_subscriber;
   scoped_ptr<media::cast::EncodingEventSubscriber> audio_event_subscriber;
   if (logging_duration > 0) {
     std::string log_file_name(media::cast::GetLogFileDestination());
     video_event_subscriber.reset(new media::cast::EncodingEventSubscriber(
         media::cast::VIDEO_EVENT, 10000));
@@ skipping 21 matching lines @@
 
   test_thread.message_loop_proxy()->PostTask(
       FROM_HERE,
       base::Bind(&media::cast::SendProcess::SendFrame,
                  base::Unretained(send_process.get())));
 
   io_message_loop.Run();
 
   return 0;
 }