[Cast] VideoFrameFactory interface to vend frames with encoder affinity.

media/cast/sender/video_sender.cc

 // Copyright 2014 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/sender/video_sender.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/net/cast_transport_config.h"
 #include "media/cast/sender/external_video_encoder.h"
 #include "media/cast/sender/video_encoder_impl.h"
+#include "media/cast/sender/video_frame_factory_pool_impl.h"
 
 namespace media {
 namespace cast {
 
 namespace {
 
 // The following two constants are used to adjust the target
 // playout delay (when allowed). They were calculated using
 // a combination of cast_benchmark runs and manual testing.
 //
@@ skipping 12 matching lines @@
 // See details: crbug.com/392086.
 VideoSender::VideoSender(
     scoped_refptr<CastEnvironment> cast_environment,
     const VideoSenderConfig& video_config,
     const CastInitializationCallback& initialization_cb,
     const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
     const CreateVideoEncodeMemoryCallback& create_video_encode_mem_cb,
     CastTransportSender* const transport_sender,
     const PlayoutDelayChangeCB& playout_delay_change_cb)
     : FrameSender(
-        cast_environment,
-        false,
-        transport_sender,
-        base::TimeDelta::FromMilliseconds(video_config.rtcp_interval),
-        kVideoFrequency,
-        video_config.ssrc,
-        video_config.max_frame_rate,
-        video_config.min_playout_delay,
-        video_config.max_playout_delay,
-        video_config.use_external_encoder ?
-            NewFixedCongestionControl(
-                (video_config.min_bitrate + video_config.max_bitrate) / 2) :
-            NewAdaptiveCongestionControl(cast_environment->Clock(),
-                                         video_config.max_bitrate,
-                                         video_config.min_bitrate,
-                                         video_config.max_frame_rate)),
+          cast_environment,
+          false,
+          transport_sender,
+          base::TimeDelta::FromMilliseconds(video_config.rtcp_interval),
+          kVideoFrequency,
+          video_config.ssrc,
+          video_config.max_frame_rate,
+          video_config.min_playout_delay,
+          video_config.max_playout_delay,
+          video_config.use_external_encoder
+              ? NewFixedCongestionControl(
+                    (video_config.min_bitrate + video_config.max_bitrate) / 2)
+              : NewAdaptiveCongestionControl(cast_environment->Clock(),
+                                             video_config.max_bitrate,
+                                             video_config.min_bitrate,
+                                             video_config.max_frame_rate)),
+      video_frame_factory_(new VideoFrameFactoryPoolImpl(video_config)),
       frames_in_encoder_(0),
       last_bitrate_(0),
       playout_delay_change_cb_(playout_delay_change_cb),
       weak_factory_(this) {
   cast_initialization_status_ = STATUS_VIDEO_UNINITIALIZED;
 
   if (video_config.use_external_encoder) {
     video_encoder_.reset(new ExternalVideoEncoder(
         cast_environment,
         video_config,
         base::Bind(&VideoSender::OnEncoderInitialized,
                    weak_factory_.GetWeakPtr(), initialization_cb),
         create_vea_cb,
         create_video_encode_mem_cb));
   } else {
     // Software encoder is initialized immediately.
     video_encoder_.reset(new VideoEncoderImpl(cast_environment, video_config));
-    cast_initialization_status_ = STATUS_VIDEO_INITIALIZED;
-  }
-
-  if (cast_initialization_status_ == STATUS_VIDEO_INITIALIZED) {
-    cast_environment->PostTask(
-        CastEnvironment::MAIN,
-        FROM_HERE,
-        base::Bind(initialization_cb, cast_initialization_status_));
+    cast_environment->PostTask(CastEnvironment::MAIN,
+                               FROM_HERE,
+                               base::Bind(&VideoSender::OnEncoderInitialized,
+                                          weak_factory_.GetWeakPtr(),
+                                          initialization_cb,
+                                          STATUS_VIDEO_INITIALIZED));
   }
 
   media::cast::CastTransportRtpConfig transport_config;
   transport_config.ssrc = video_config.ssrc;
   transport_config.feedback_ssrc = video_config.incoming_feedback_ssrc;
   transport_config.rtp_payload_type = video_config.rtp_payload_type;
   transport_config.aes_key = video_config.aes_key;
   transport_config.aes_iv_mask = video_config.aes_iv_mask;
 
   transport_sender->InitializeVideo(
@@ skipping 107 matching lines @@
 }
 
 void VideoSender::OnAck(uint32 frame_id) {
   video_encoder_->LatestFrameIdToReference(frame_id);
 }
 
 void VideoSender::OnEncoderInitialized(
     const CastInitializationCallback& initialization_cb,
     CastInitializationStatus status) {
   cast_initialization_status_ = status;
+  if (status == STATUS_VIDEO_INITIALIZED) {
+    DCHECK(video_encoder_.get()) << "Invalid state";
+    auto video_frame_factory = video_encoder_->GetVideoFrameFactory();
+    if (video_frame_factory.get()) {
+      video_frame_factory_ = video_frame_factory;
+    }
+  }
   initialization_cb.Run(status);
 }
 
 void VideoSender::OnEncodedVideoFrame(
     int encoder_bitrate,
     scoped_ptr<EncodedFrame> encoded_frame) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   frames_in_encoder_--;
   DCHECK_GE(frames_in_encoder_, 0);
 
   duration_in_encoder_ =
       last_enqueued_frame_reference_time_ - encoded_frame->reference_time;
 
   SendEncodedFrame(encoder_bitrate, encoded_frame.Pass());
 }
 
 }  // namespace cast
 }  // namespace media