[Cast] Separate frame size from VideoSenderConfig in H264VideoToolboxEncoder.

media/cast/sender/h264_vt_encoder.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/h264_vt_encoder.h"
 
 #include <string>
 #include <vector>
 
 #include "base/big_endian.h"
@@ skipping 206 matching lines @@
 
  private:
   base::ScopedCFTypeRef<CVPixelBufferPoolRef> pool_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameFactoryCVPixelBufferPoolImpl);
 };
 
 }  // namespace
 
 H264VideoToolboxEncoder::H264VideoToolboxEncoder(
-    scoped_refptr<CastEnvironment> cast_environment,
+    const scoped_refptr<CastEnvironment>& cast_environment,
     const VideoSenderConfig& video_config,
+    const gfx::Size& frame_size,
     const CastInitializationCallback& initialization_cb)
     : cast_environment_(cast_environment),
+
       videotoolbox_glue_(VideoToolboxGlue::Get()),
       frame_id_(kStartFrameId),
       encode_next_frame_as_keyframe_(false) {
-  DCHECK(!initialization_cb.is_null());
+  DCHECK(!frame_size.IsEmpty());
+
   CastInitializationStatus initialization_status;
   if (videotoolbox_glue_) {
-    initialization_status = (Initialize(video_config))
+    initialization_status = (Initialize(video_config, frame_size))
                                 ? STATUS_VIDEO_INITIALIZED
                                 : STATUS_INVALID_VIDEO_CONFIGURATION;
   } else {
     LOG(ERROR) << " VideoToolbox is not available";
     initialization_status = STATUS_HW_VIDEO_ENCODER_NOT_SUPPORTED;
   }
-  cast_environment_->PostTask(
-      CastEnvironment::MAIN, FROM_HERE,
-      base::Bind(initialization_cb, initialization_status));
+  if (!initialization_cb.is_null()) {
+    cast_environment_->PostTask(
+        CastEnvironment::MAIN,
+        FROM_HERE,
+        base::Bind(initialization_cb, initialization_status));
+  }
 }
 
 H264VideoToolboxEncoder::~H264VideoToolboxEncoder() {
   Teardown();
 }
 
 bool H264VideoToolboxEncoder::Initialize(
-    const VideoSenderConfig& video_config) {
+    const VideoSenderConfig& video_config,
+    const gfx::Size& frame_size) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!compression_session_);
 
   // Note that the encoder object is given to the compression session as the
   // callback context using a raw pointer. The C API does not allow us to use
   // a smart pointer, nor is this encoder ref counted. However, this is still
   // safe, because we 1) we own the compression session and 2) we tear it down
   // safely. When destructing the encoder, the compression session is flushed
   // and invalidated. Internally, VideoToolbox will join all of its threads
   // before returning to the client. Therefore, when control returns to us, we
@@ skipping 14 matching lines @@
   const int formats[] = {
       kCVPixelFormatType_420YpCbCr8Planar,
       CoreVideoGlue::kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange};
   base::ScopedCFTypeRef<CFArrayRef> formats_array = ArrayWithIntegers(
       std::vector<int>(formats, formats + arraysize(formats)));
   base::ScopedCFTypeRef<CFDictionaryRef> buffer_attributes =
       DictionaryWithKeyValue(kCVPixelBufferPixelFormatTypeKey, formats_array);
 
   VTCompressionSessionRef session;
   OSStatus status = videotoolbox_glue_->VTCompressionSessionCreate(
-      kCFAllocatorDefault, video_config.width, video_config.height,
+      kCFAllocatorDefault, frame_size.width(), frame_size.height(),
       CoreMediaGlue::kCMVideoCodecType_H264, encoder_spec, buffer_attributes,
       nullptr /* compressedDataAllocator */,
       &H264VideoToolboxEncoder::CompressionCallback,
       reinterpret_cast<void*>(this), &session);
   if (status != noErr) {
     DLOG(ERROR) << " VTCompressionSessionCreate failed: " << status;
     return false;
   }
   compression_session_.reset(session);
 
@@ skipping 47 matching lines @@
     videotoolbox_glue_->VTCompressionSessionInvalidate(compression_session_);
     compression_session_.reset();
   }
 }
 
 bool H264VideoToolboxEncoder::EncodeVideoFrame(
     const scoped_refptr<media::VideoFrame>& video_frame,
     const base::TimeTicks& reference_time,
     const FrameEncodedCallback& frame_encoded_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(!reference_time.is_null());
+  DCHECK(!video_frame->visible_rect().IsEmpty());
+  DCHECK(!frame_encoded_callback.is_null());
 
   if (!compression_session_) {
     DLOG(ERROR) << " compression session is null";
     return false;
   }
 
   // Wrap the VideoFrame in a CVPixelBuffer. In all cases, no data will be
   // copied. If the VideoFrame was created by this encoder's video frame
   // factory, then the returned CVPixelBuffer will have been obtained from the
   // compression session's pixel buffer pool. This will eliminate a copy of the
@@ skipping 137 matching lines @@
   CopySampleBufferToAnnexBBuffer(sbuf, &encoded_frame->data, keyframe);
 
   encoder->cast_environment_->PostTask(
       CastEnvironment::MAIN, FROM_HERE,
       base::Bind(request->frame_encoded_callback,
                  base::Passed(&encoded_frame)));
 }
 
 }  // namespace cast
 }  // namespace media