Cast: Fix two video freezing problems

media/cast/video_sender/video_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.
 
 #include "media/cast/video_sender/video_sender.h"
 
 #include <cstring>
 #include <list>
 
 #include "base/bind.h"
@@ skipping 43 matching lines @@
     : rtp_max_delay_(base::TimeDelta::FromMilliseconds(
           video_config.rtp_config.max_delay_ms)),
       max_frame_rate_(video_config.max_frame_rate),
       cast_environment_(cast_environment),
       transport_sender_(transport_sender),
       event_subscriber_(kMaxEventSubscriberEntries),
       rtp_stats_(kVideoFrequency),
       rtcp_feedback_(new LocalRtcpVideoSenderFeedback(this)),
       last_acked_frame_id_(-1),
       last_sent_frame_id_(-1),
+      frames_in_encoder_(0),
       duplicate_ack_(0),
       last_skip_count_(0),
       current_requested_bitrate_(video_config.start_bitrate),
       congestion_control_(cast_environment->Clock(),
                           video_config.congestion_control_back_off,
                           video_config.max_bitrate,
                           video_config.min_bitrate,
                           video_config.start_bitrate),
       initialized_(false),
       active_session_(false),
       weak_factory_(this) {
   max_unacked_frames_ =
       1 + static_cast<uint8>(video_config.rtp_config.max_delay_ms *
                              max_frame_rate_ / 1000);
   VLOG(1) << "max_unacked_frames " << static_cast<int>(max_unacked_frames_);
   DCHECK_GT(max_unacked_frames_, 0) << "Invalid argument";
 
   if (video_config.use_external_encoder) {
     video_encoder_.reset(new ExternalVideoEncoder(cast_environment,
                                                   video_config,
                                                   create_vea_cb,
                                                   create_video_encode_mem_cb));
   } else {
     video_encoder_.reset(new VideoEncoderImpl(
         cast_environment, video_config, max_unacked_frames_));
   }
 
+
+  media::cast::transport::CastTransportVideoConfig transport_config;
+  transport_config.codec = video_config.codec;
+  transport_config.rtp.config = video_config.rtp_config;
+  transport_config.rtp.max_outstanding_frames = max_unacked_frames_ + 1;
+  transport_sender_->InitializeVideo(transport_config);
+
   rtcp_.reset(
       new Rtcp(cast_environment_,
                rtcp_feedback_.get(),
                transport_sender_,
                NULL,  // paced sender.
                NULL,
                video_config.rtcp_mode,
                base::TimeDelta::FromMilliseconds(video_config.rtcp_interval),
-               video_config.sender_ssrc,
+               video_config.rtp_config.ssrc,
                video_config.incoming_feedback_ssrc,
                video_config.rtcp_c_name));
   rtcp_->SetCastReceiverEventHistorySize(kReceiverRtcpEventHistorySize);
 
   // TODO(pwestin): pass cast_initialization_cb to |video_encoder_|
   // and remove this call.
   cast_environment_->PostTask(
       CastEnvironment::MAIN,
       FROM_HERE,
       base::Bind(cast_initialization_cb, STATUS_VIDEO_INITIALIZED));
@@ skipping 33 matching lines @@
       rtp_timestamp,
       kFrameIdUnknown);
 
   // Used by chrome/browser/extension/api/cast_streaming/performance_test.cc
   TRACE_EVENT_INSTANT2(
       "cast_perf_test", "InsertRawVideoFrame",
       TRACE_EVENT_SCOPE_THREAD,
       "timestamp", capture_time.ToInternalValue(),
       "rtp_timestamp", GetVideoRtpTimestamp(capture_time));
 
-  if (!video_encoder_->EncodeVideoFrame(
+  if (video_encoder_->EncodeVideoFrame(
           video_frame,
           capture_time,
           base::Bind(&VideoSender::SendEncodedVideoFrameMainThread,
                      weak_factory_.GetWeakPtr()))) {
+    frames_in_encoder_++;
+    UpdateFramesInFlight();
   }
 }
 
 void VideoSender::SendEncodedVideoFrameMainThread(
     scoped_ptr<transport::EncodedVideoFrame> encoded_frame,
     const base::TimeTicks& capture_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   last_send_time_ = cast_environment_->Clock()->NowTicks();
   if (encoded_frame->key_frame) {
     VLOG(1) << "Send encoded key frame; frame_id:"
             << static_cast<int>(encoded_frame->frame_id);
   }
 
+  DCHECK_GT(frames_in_encoder_, 0);
+  frames_in_encoder_--;
   uint32 frame_id = encoded_frame->frame_id;
   cast_environment_->Logging()->InsertEncodedFrameEvent(
       last_send_time_, kVideoFrameEncoded, encoded_frame->rtp_timestamp,
       frame_id, static_cast<int>(encoded_frame->data.size()),
       encoded_frame->key_frame, current_requested_bitrate_);
 
   // Used by chrome/browser/extension/api/cast_streaming/performance_test.cc
   TRACE_EVENT_INSTANT1(
       "cast_perf_test", "VideoFrameEncoded",
       TRACE_EVENT_SCOPE_THREAD,
@@ skipping 108 matching lines @@
   if (!last_send_time_.is_null() && last_sent_frame_id_ != -1) {
     base::TimeDelta time_since_last_send =
         cast_environment_->Clock()->NowTicks() - last_send_time_;
     if (time_since_last_send > rtp_max_delay_) {
       if (!active_session_) {
         // We have not received any acks, resend the first encoded frame (id 0),
         // which must also be a key frame.
         VLOG(1) << "ACK timeout resend first key frame";
         ResendFrame(0);
       } else {
-        DCHECK_LE(0, last_acked_frame_id_);
-        uint32 frame_id = static_cast<uint32>(last_acked_frame_id_ + 1);
-        VLOG(1) << "ACK timeout resend frame:" << static_cast<int>(frame_id);
-        ResendFrame(frame_id);
+        if (last_acked_frame_id_ == last_sent_frame_id_) {
+          // Last frame acked, no point in doing anything

[Alpha Left Google, 2014/04/29 00:55:05]

Please have a test for this case. This is a third bug fixed in this change. This
means that all frames are acked and sender is idle, make sure we don't resend
the last frame over and over.

[hubbe, 2014/04/29 17:19:58]

Actually, the problem is that without this if-statement, it tries to resend the
last_acked_frame + 1 (a frame which doesn't exist yet). When that happens new
DCHECKS are triggered in packet_storage.cc, so no test is actually required.

+        } else {
+          DCHECK_LE(0, last_acked_frame_id_);
+          uint32 frame_id = static_cast<uint32>(last_acked_frame_id_ + 1);
+          VLOG(1) << "ACK timeout resend frame:" << static_cast<int>(frame_id);
+          ResendFrame(frame_id);
+        }
       }
     }
   }
   ScheduleNextResendCheck();
 }
 
 void VideoSender::ScheduleNextSkippedFramesCheck() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   base::TimeDelta time_to_next;
   if (last_checked_skip_count_time_.is_null()) {
@@ skipping 123 matching lines @@
   if (last_sent_frame_id_ != -1) {
     DCHECK_LE(0, last_sent_frame_id_);
     uint32 frames_in_flight = 0;
     if (last_acked_frame_id_ != -1) {
       DCHECK_LE(0, last_acked_frame_id_);
       frames_in_flight = static_cast<uint32>(last_sent_frame_id_) -
                          static_cast<uint32>(last_acked_frame_id_);
     } else {
       frames_in_flight = static_cast<uint32>(last_sent_frame_id_) + 1;
     }
+    frames_in_flight += frames_in_encoder_;
     VLOG(2) << frames_in_flight
             << " Frames in flight; last sent: " << last_sent_frame_id_
-            << " last acked:" << last_acked_frame_id_;
+            << " last acked:" << last_acked_frame_id_
+            << " frames in encoder: " << frames_in_encoder_;
     if (frames_in_flight >= max_unacked_frames_) {
       video_encoder_->SkipNextFrame(true);
       return;
     }
     DCHECK(frames_in_flight <= max_unacked_frames_);
   }
   video_encoder_->SkipNextFrame(false);
 }
 
 void VideoSender::ResendFrame(uint32 resend_frame_id) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   MissingFramesAndPacketsMap missing_frames_and_packets;
   PacketIdSet missing;
   missing_frames_and_packets.insert(std::make_pair(resend_frame_id, missing));
   last_send_time_ = cast_environment_->Clock()->NowTicks();
   transport_sender_->ResendPackets(false, missing_frames_and_packets);
 }
 
 }  // namespace cast
 }  // namespace media