VideoToolbox encoder for cast senders.

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"
 
+#if defined(OS_MACOSX)
+#include "media/cast/sender/h264_vt_encoder.h"
+#endif
+
 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.
 //
 // This is how many round trips we think we need on the network.
@@ skipping 33 matching lines @@
       last_bitrate_(0),
       playout_delay_change_cb_(playout_delay_change_cb),
       weak_factory_(this) {
   cast_initialization_status_ = STATUS_VIDEO_UNINITIALIZED;
   VLOG(1) << "max_unacked_frames is " << max_unacked_frames_
           << " for target_playout_delay="
           << target_playout_delay_.InMilliseconds() << " ms"
           << " and max_frame_rate=" << video_config.max_frame_rate;
   DCHECK_GT(max_unacked_frames_, 0);
 
+#if defined(OS_MACOSX)
+  // On Apple platforms, use the hardware H.264 encoder if possible. It is the
+  // only reasonable option for iOS.
+  if (!video_config.use_external_encoder &&
+      video_config.codec == CODEC_VIDEO_H264) {
+    video_encoder_.reset(new H264VideoToolboxEncoder(
+        cast_environment,
+        video_config,
+        base::Bind(&VideoSender::OnEncoderInitialized,
+                   weak_factory_.GetWeakPtr(),
+                   initialization_cb)));
+  }
+#endif  // defined(OS_MACOSX)
+#if !defined(OS_IOS)
   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 {
+  } else if (!video_encoder_) {
     // Software encoder is initialized immediately.
     congestion_control_.reset(
         NewAdaptiveCongestionControl(cast_environment->Clock(),
                                      video_config.max_bitrate,
                                      video_config.min_bitrate,
                                      max_unacked_frames_));
     video_encoder_.reset(new VideoEncoderImpl(
         cast_environment, video_config, max_unacked_frames_));
     cast_initialization_status_ = STATUS_VIDEO_INITIALIZED;
   }
+#endif  // !defined(OS_IOS)
 
   if (cast_initialization_status_ == STATUS_VIDEO_INITIALIZED) {
     cast_environment->PostTask(
         CastEnvironment::MAIN,
         FROM_HERE,
         base::Bind(initialization_cb, cast_initialization_status_));
   }
 
   media::cast::CastTransportRtpConfig transport_config;
   transport_config.ssrc = video_config.ssrc;
@@ skipping 126 matching lines @@
   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