Revert of Cast: Fix two video freezing problems

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 82 matching lines @@
 AudioSenderConfig GetAudioSenderConfig() {
   AudioSenderConfig audio_config;
 
   audio_config.rtcp_c_name = "audio_sender@a.b.c.d";
 
   audio_config.use_external_encoder = false;
   audio_config.frequency = kAudioSamplingFrequency;
   audio_config.channels = kAudioChannels;
   audio_config.bitrate = 64000;
   audio_config.codec = transport::kOpus;
-  audio_config.rtp_config.ssrc = 1;
+  audio_config.sender_ssrc = 1;
   audio_config.incoming_feedback_ssrc = 2;
   audio_config.rtp_config.payload_type = 127;
   audio_config.rtp_config.max_delay_ms = 300;
   return audio_config;
 }
 
 VideoSenderConfig GetVideoSenderConfig() {
   VideoSenderConfig video_config;
 
   video_config.rtcp_c_name = "video_sender@a.b.c.d";
@@ skipping 12 matching lines @@
   // Codec.
   video_config.codec = transport::kVp8;
   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.rtp_config.ssrc = 11;
+  video_config.sender_ssrc = 11;
   video_config.incoming_feedback_ssrc = 12;
   video_config.rtp_config.payload_type = 96;
   video_config.rtp_config.max_delay_ms = 300;
   return video_config;
 }
 
 void AVFreeFrame(AVFrame* frame) { avcodec_free_frame(&frame); }
 
 class SendProcess {
  public:
@@ skipping 421 matching lines @@
               AVSampleFormatToSampleFormat(
                   av_audio_context()->sample_fmt),
               ChannelLayoutToChromeChannelLayout(
                   av_audio_context()->channel_layout,
                   av_audio_context()->channels),
               av_audio_context()->channels,
               av_audio_context()->sample_rate,
               frames_read,
               &avframe->data[0],
               // Note: Not all files have correct values for pkt_pts.
-              base::TimeDelta::FromMilliseconds(avframe->pkt_pts));
+              base::TimeDelta::FromMilliseconds(avframe->pkt_pts),
+              // TODO(hclam): Give accurate duration based on samples.
+              base::TimeDelta());
       audio_algo_.EnqueueBuffer(buffer);
     } while (packet_temp.size > 0);
     avcodec_free_frame(&avframe);
 
     const int frames_needed_to_scale =
         playback_rate_ * av_audio_context()->sample_rate /
         kAudioPacketsPerSecond;
     while (frames_needed_to_scale <= audio_algo_.frames_buffered()) {
       if (!audio_algo_.FillBuffer(audio_fifo_input_bus_.get(),
                                   audio_fifo_input_bus_->frames())) {
@@ skipping 148 matching lines @@
   std::queue<AudioBus*> audio_bus_queue_;
 
   DISALLOW_COPY_AND_ASSIGN(SendProcess);
 };
 
 }  // namespace cast
 }  // namespace media
 
 namespace {
 void UpdateCastTransportStatus(
-    media::cast::transport::CastTransportStatus status) {
-  VLOG(21) << "Transport status: " << status;
-}
+    media::cast::transport::CastTransportStatus status) {}
 
 void LogRawEvents(
     const scoped_refptr<media::cast::CastEnvironment>& cast_environment,
     const std::vector<media::cast::PacketEvent>& packet_events) {
   VLOG(1) << "Got packet events from transport, size: " << packet_events.size();
   for (std::vector<media::cast::PacketEvent>::const_iterator it =
            packet_events.begin();
        it != packet_events.end();
        ++it) {
     cast_environment->Logging()->InsertPacketEvent(it->timestamp,
@@ skipping 139 matching lines @@
   LOG(INFO) << "Sending to " << remote_ip_address << ":" << remote_port
             << ".";
 
   media::cast::AudioSenderConfig audio_config =
       media::cast::GetAudioSenderConfig();
   media::cast::VideoSenderConfig video_config =
       media::cast::GetVideoSenderConfig();
 
   // Running transport on the main thread.
   // Setting up transport config.
+  media::cast::transport::CastTransportAudioConfig transport_audio_config;
+  media::cast::transport::CastTransportVideoConfig transport_video_config;
   net::IPEndPoint remote_endpoint =
       CreateUDPAddress(remote_ip_address, remote_port);
+  transport_audio_config.base.ssrc = audio_config.sender_ssrc;
+  transport_audio_config.base.rtp_config = audio_config.rtp_config;
+  transport_video_config.base.ssrc = video_config.sender_ssrc;
+  transport_video_config.base.rtp_config = video_config.rtp_config;
 
   // Enable raw event and stats logging.
   // Running transport on the main thread.
   scoped_refptr<media::cast::CastEnvironment> cast_environment(
       new media::cast::CastEnvironment(
           make_scoped_ptr<base::TickClock>(new base::DefaultTickClock()),
           io_message_loop.message_loop_proxy(),
           audio_thread.message_loop_proxy(),
           video_thread.message_loop_proxy()));
 
   // SendProcess initialization.
   scoped_ptr<media::cast::SendProcess> send_process(
       new media::cast::SendProcess(test_thread.message_loop_proxy(),
                                    cast_environment->Clock(),
                                    video_config));
 
   // CastTransportSender initialization.
   scoped_ptr<media::cast::transport::CastTransportSender> transport_sender =
       media::cast::transport::CastTransportSender::Create(
           NULL,  // net log.
           cast_environment->Clock(),
           remote_endpoint,
           base::Bind(&UpdateCastTransportStatus),
           base::Bind(&LogRawEvents, cast_environment),
           base::TimeDelta::FromSeconds(1),
           io_message_loop.message_loop_proxy());
+  transport_sender->InitializeAudio(transport_audio_config);
+  transport_sender->InitializeVideo(transport_video_config);
 
   // CastSender initialization.
   scoped_ptr<media::cast::CastSender> cast_sender =
       media::cast::CastSender::Create(cast_environment, transport_sender.get());
   cast_sender->InitializeVideo(
       send_process->get_video_config(),
       base::Bind(&InitializationResult),
       media::cast::CreateDefaultVideoEncodeAcceleratorCallback(),
       media::cast::CreateDefaultVideoEncodeMemoryCallback());
   cast_sender->InitializeAudio(audio_config, base::Bind(&InitializationResult));
@@ skipping 63 matching lines @@
                  base::Passed(&audio_stats_subscriber),
                  base::Passed(&offset_estimator)),
       base::TimeDelta::FromSeconds(logging_duration_seconds));
 
   send_process->Start(cast_sender->audio_frame_input(),
                       cast_sender->video_frame_input());
 
   io_message_loop.Run();
   return 0;
 }