Revert of [Cast] Software encoder support for varying video frame sizes.

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 <queue>
 
 #include "base/at_exit.h"
@@ skipping 20 matching lines @@
 #include "media/cast/logging/receiver_time_offset_estimator_impl.h"
 #include "media/cast/logging/stats_event_subscriber.h"
 #include "media/cast/net/cast_transport_defines.h"
 #include "media/cast/net/cast_transport_sender.h"
 #include "media/cast/net/udp_transport.h"
 #include "media/cast/test/fake_media_source.h"
 #include "media/cast/test/utility/default_config.h"
 #include "media/cast/test/utility/input_builder.h"
 
 namespace {
+static const int kAudioChannels = 2;
+static const int kAudioSamplingFrequency = 48000;
 
 // The max allowed size of serialized log.
 const int kMaxSerializedLogBytes = 10 * 1000 * 1000;
 
 // Flags for this program:
 //
 // --address=xx.xx.xx.xx
 //   IP address of receiver.
 //
 // --port=xxxx
 //   Port number of receiver.
 //
 // --source-file=xxx.webm
 //   WebM file as source of video frames.
 //
 // --fps=xx
 //   Override framerate of the video stream.
-//
-// --vary-frame-sizes
-//   Randomly vary the video frame sizes at random points in time.  Has no
-//   effect if --source-file is being used.
 const char kSwitchAddress[] = "address";
 const char kSwitchPort[] = "port";
 const char kSwitchSourceFile[] = "source-file";
 const char kSwitchFps[] = "fps";
-const char kSwitchVaryFrameSizes[] = "vary-frame-sizes";
+
+media::cast::AudioSenderConfig GetAudioSenderConfig() {
+  media::cast::AudioSenderConfig audio_config;
+
+  audio_config.use_external_encoder = false;
+  audio_config.frequency = kAudioSamplingFrequency;
+  audio_config.channels = kAudioChannels;
+  audio_config.bitrate = 0;  // Use Opus auto-VBR mode.
+  audio_config.codec = media::cast::CODEC_AUDIO_OPUS;
+  audio_config.ssrc = 1;
+  audio_config.receiver_ssrc = 2;
+  audio_config.rtp_payload_type = 127;
+  // TODO(miu): The default in cast_defines.h is 100.  Should this be 100, and
+  // should receiver.cc's config also be 100?
+  audio_config.max_playout_delay = base::TimeDelta::FromMilliseconds(300);
+  return audio_config;
+}
+
+media::cast::VideoSenderConfig GetVideoSenderConfig() {
+  media::cast::VideoSenderConfig video_config;
+
+  video_config.use_external_encoder = false;
+
+  // Resolution.
+  video_config.width = 1280;
+  video_config.height = 720;
+  video_config.max_frame_rate = 30;
+
+  // Bitrates.
+  video_config.max_bitrate = 2500000;
+  video_config.min_bitrate = 100000;
+  video_config.start_bitrate = video_config.min_bitrate;
+
+  // Codec.
+  video_config.codec = media::cast::CODEC_VIDEO_VP8;
+  video_config.max_number_of_video_buffers_used = 1;
+  video_config.number_of_encode_threads = 2;
+
+  // Quality options.
+  video_config.min_qp = 4;
+  video_config.max_qp = 40;
+
+  // SSRCs and payload type. Don't change them.
+  video_config.ssrc = 11;
+  video_config.receiver_ssrc = 12;
+  video_config.rtp_payload_type = 96;
+  // TODO(miu): The default in cast_defines.h is 100.  Should this be 100, and
+  // should receiver.cc's config also be 100?
+  video_config.max_playout_delay = base::TimeDelta::FromMilliseconds(300);
+  return video_config;
+}
 
 void UpdateCastTransportStatus(
     media::cast::CastTransportStatus status) {
   VLOG(1) << "Transport status: " << status;
 }
 
 void LogRawEvents(
     const scoped_refptr<media::cast::CastEnvironment>& cast_environment,
     const std::vector<media::cast::PacketEvent>& packet_events,
     const std::vector<media::cast::FrameEvent>& frame_events) {
@@ skipping 17 matching lines @@
        it != frame_events.end();
        ++it) {
     cast_environment->Logging()->InsertFrameEvent(it->timestamp,
                                                   it->type,
                                                   it->media_type,
                                                   it->rtp_timestamp,
                                                   it->frame_id);
   }
 }
 
-void QuitLoopOnInitializationResult(
-    media::cast::CastInitializationStatus result) {
-  CHECK(result == media::cast::STATUS_AUDIO_INITIALIZED ||
-        result == media::cast::STATUS_VIDEO_INITIALIZED)
-      << "Cast sender uninitialized";
-  base::MessageLoop::current()->Quit();
+void InitializationResult(media::cast::CastInitializationStatus result) {
+  bool end_result = result == media::cast::STATUS_AUDIO_INITIALIZED ||
+                    result == media::cast::STATUS_VIDEO_INITIALIZED;
+  CHECK(end_result) << "Cast sender uninitialized";
 }
 
 net::IPEndPoint CreateUDPAddress(std::string ip_str, uint16 port) {
   net::IPAddressNumber ip_number;
   CHECK(net::ParseIPLiteralToNumber(ip_str, &ip_number));
   return net::IPEndPoint(ip_number, port);
 }
 
 void DumpLoggingData(const media::cast::proto::LogMetadata& log_metadata,
                      const media::cast::FrameEventList& frame_events,
@@ skipping 109 matching lines @@
   if (remote_ip_address.empty())
     remote_ip_address = "127.0.0.1";
   int remote_port = 0;
   if (!base::StringToInt(cmd->GetSwitchValueASCII(kSwitchPort), &remote_port) ||
       remote_port < 0 || remote_port > 65535) {
     remote_port = 2344;
   }
   LOG(INFO) << "Sending to " << remote_ip_address << ":" << remote_port
             << ".";
 
-  media::cast::AudioSenderConfig audio_config =
-      media::cast::GetDefaultAudioSenderConfig();
-  media::cast::VideoSenderConfig video_config =
-      media::cast::GetDefaultVideoSenderConfig();
+  media::cast::AudioSenderConfig audio_config = GetAudioSenderConfig();
+  media::cast::VideoSenderConfig video_config = GetVideoSenderConfig();
 
   // Running transport on the main thread.
   // Setting up transport config.
   net::IPEndPoint remote_endpoint =
       CreateUDPAddress(remote_ip_address, static_cast<uint16>(remote_port));
 
   // Enable raw event and stats logging.
   // Running transport on the main thread.
   scoped_refptr<media::cast::CastEnvironment> cast_environment(
       new media::cast::CastEnvironment(
@@ skipping 11 matching lines @@
   int override_fps = 0;
   if (!base::StringToInt(cmd->GetSwitchValueASCII(kSwitchFps),
                          &override_fps)){
     override_fps = 0;
   }
   base::FilePath source_path = cmd->GetSwitchValuePath(kSwitchSourceFile);
   if (!source_path.empty()) {
     LOG(INFO) << "Source: " << source_path.value();
     fake_media_source->SetSourceFile(source_path, override_fps);
   }
-  if (cmd->HasSwitch(kSwitchVaryFrameSizes))
-    fake_media_source->SetVariableFrameSizeMode(true);
 
   // CastTransportSender initialization.
   scoped_ptr<media::cast::CastTransportSender> transport_sender =
       media::cast::CastTransportSender::Create(
           NULL,  // net log.
           cast_environment->Clock(),
           net::IPEndPoint(),
           remote_endpoint,
           make_scoped_ptr(new base::DictionaryValue),  // options
           base::Bind(&UpdateCastTransportStatus),
           base::Bind(&LogRawEvents, cast_environment),
           base::TimeDelta::FromSeconds(1),
           media::cast::PacketReceiverCallback(),
           io_message_loop.message_loop_proxy());
 
+  // CastSender initialization.
+  scoped_ptr<media::cast::CastSender> cast_sender =
+      media::cast::CastSender::Create(cast_environment, transport_sender.get());
+  cast_sender->InitializeVideo(
+      fake_media_source->get_video_config(),
+      base::Bind(&InitializationResult),
+      media::cast::CreateDefaultVideoEncodeAcceleratorCallback(),
+      media::cast::CreateDefaultVideoEncodeMemoryCallback());
+  cast_sender->InitializeAudio(audio_config, base::Bind(&InitializationResult));
+
   // Set up event subscribers.
   scoped_ptr<media::cast::EncodingEventSubscriber> video_event_subscriber;
   scoped_ptr<media::cast::EncodingEventSubscriber> audio_event_subscriber;
   std::string video_log_file_name("/tmp/video_events.log.gz");
   std::string audio_log_file_name("/tmp/audio_events.log.gz");
   LOG(INFO) << "Logging audio events to: " << audio_log_file_name;
   LOG(INFO) << "Logging video events to: " << video_log_file_name;
   video_event_subscriber.reset(new media::cast::EncodingEventSubscriber(
       media::cast::VIDEO_EVENT, 10000));
   audio_event_subscriber.reset(new media::cast::EncodingEventSubscriber(
@@ skipping 45 matching lines @@
 
   io_message_loop.message_loop_proxy()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&WriteStatsAndDestroySubscribers,
                  cast_environment,
                  base::Passed(&video_stats_subscriber),
                  base::Passed(&audio_stats_subscriber),
                  base::Passed(&offset_estimator)),
       base::TimeDelta::FromSeconds(logging_duration_seconds));
 
-  // CastSender initialization.
-  scoped_ptr<media::cast::CastSender> cast_sender =
-      media::cast::CastSender::Create(cast_environment, transport_sender.get());
-  io_message_loop.PostTask(
-      FROM_HERE,
-      base::Bind(&media::cast::CastSender::InitializeVideo,
-                 base::Unretained(cast_sender.get()),
-                 fake_media_source->get_video_config(),
-                 base::Bind(&QuitLoopOnInitializationResult),
-                 media::cast::CreateDefaultVideoEncodeAcceleratorCallback(),
-                 media::cast::CreateDefaultVideoEncodeMemoryCallback()));
-  io_message_loop.Run();  // Wait for video initialization.
-  io_message_loop.PostTask(
-      FROM_HERE,
-      base::Bind(&media::cast::CastSender::InitializeAudio,
-                 base::Unretained(cast_sender.get()),
-                 audio_config,
-                 base::Bind(&QuitLoopOnInitializationResult)));
-  io_message_loop.Run();  // Wait for audio initialization.
-
   fake_media_source->Start(cast_sender->audio_frame_input(),
                            cast_sender->video_frame_input());
+
   io_message_loop.Run();
   return 0;
 }