Refactoring: Merge VideoSenderConfig and AudioSenderConfig.

media/cast/sender/external_video_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/external_video_encoder.h"
 
 #include <cmath>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 69 matching lines @@
 // methods must be called on the thread associated with the given
 // SingleThreadTaskRunner, except for the task_runner() accessor.
 class ExternalVideoEncoder::VEAClientImpl
     : public VideoEncodeAccelerator::Client,
       public base::RefCountedThreadSafe<VEAClientImpl> {
  public:
   VEAClientImpl(
       const scoped_refptr<CastEnvironment>& cast_environment,
       const scoped_refptr<base::SingleThreadTaskRunner>& encoder_task_runner,
       std::unique_ptr<media::VideoEncodeAccelerator> vea,
-      int max_frame_rate,
+      double max_frame_rate,
       const StatusChangeCallback& status_change_cb,
       const CreateVideoEncodeMemoryCallback& create_video_encode_memory_cb)
       : cast_environment_(cast_environment),
         task_runner_(encoder_task_runner),
         max_frame_rate_(max_frame_rate),
         status_change_cb_(status_change_cb),
         create_video_encode_memory_cb_(create_video_encode_memory_cb),
         video_encode_accelerator_(std::move(vea)),
         encoder_active_(false),
         next_frame_id_(FrameId::first()),
@@ skipping 30 matching lines @@
         FROM_HERE,
         base::Bind(status_change_cb_,
                    encoder_active_ ? STATUS_INITIALIZED :
                        STATUS_CODEC_INIT_FAILED));
   }
 
   void SetBitRate(int bit_rate) {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
     requested_bit_rate_ = bit_rate;
-    video_encode_accelerator_->RequestEncodingParametersChange(bit_rate,
-                                                               max_frame_rate_);
+    video_encode_accelerator_->RequestEncodingParametersChange(
+        bit_rate, static_cast<uint32_t>(max_frame_rate_ + 0.5));
   }
 
   // The destruction call back of the copied video frame to free its use of
   // the input buffer.
   void ReturnInputBufferToPool(int index) {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
     DCHECK_GE(index, 0);
     DCHECK_LT(index, static_cast<int>(input_buffers_.size()));
     free_input_buffer_index_.push_back(index);
   }
@@ skipping 376 matching lines @@
         default:
           // Skip other NALUs.
           break;
       }
     }
     return (num_slices == 0) ? -1 : (total_quantizer / num_slices);
   }
 
   const scoped_refptr<CastEnvironment> cast_environment_;
   const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
-  const int max_frame_rate_;
+  const double max_frame_rate_;
   const StatusChangeCallback status_change_cb_;  // Must be run on MAIN thread.
   const CreateVideoEncodeMemoryCallback create_video_encode_memory_cb_;
   std::unique_ptr<media::VideoEncodeAccelerator> video_encode_accelerator_;
   bool encoder_active_;
   FrameId next_frame_id_;
   bool key_frame_encountered_;
   std::string stream_header_;
   VideoCodecProfile codec_profile_;
   bool key_frame_quantizer_parsable_;
   H264Parser h264_parser_;
@@ skipping 33 matching lines @@
   size_t max_allowed_input_buffers_;
 
   // Set to true when the allocation of an input buffer is in progress, and
   // reset to false after the allocated buffer is received.
   bool allocate_input_buffer_in_progress_;
 
   DISALLOW_COPY_AND_ASSIGN(VEAClientImpl);
 };
 
 // static
-bool ExternalVideoEncoder::IsSupported(const VideoSenderConfig& video_config) {
+bool ExternalVideoEncoder::IsSupported(const FrameSenderConfig& video_config) {
   if (video_config.codec != CODEC_VIDEO_VP8 &&
       video_config.codec != CODEC_VIDEO_H264)
     return false;
 
   // TODO(miu): "Layering hooks" are needed to be able to query outside of
   // libmedia, to determine whether the system provides a hardware encoder.  For
   // now, assume that this was already checked by this point.
   // http://crbug.com/454029
   return video_config.use_external_encoder;
 }
 
 ExternalVideoEncoder::ExternalVideoEncoder(
     const scoped_refptr<CastEnvironment>& cast_environment,
-    const VideoSenderConfig& video_config,
+    const FrameSenderConfig& video_config,
     const gfx::Size& frame_size,
     FrameId first_frame_id,
     const StatusChangeCallback& status_change_cb,
     const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
     const CreateVideoEncodeMemoryCallback& create_video_encode_memory_cb)
     : cast_environment_(cast_environment),
       create_video_encode_memory_cb_(create_video_encode_memory_cb),
       frame_size_(frame_size),
-      bit_rate_(video_config.start_bitrate),
+      bit_rate_(video_config.codec_specific_params.start_bitrate),
       key_frame_requested_(false),
       weak_factory_(this) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK_GT(video_config.max_frame_rate, 0);
   DCHECK(!frame_size_.IsEmpty());
   DCHECK(!status_change_cb.is_null());
   DCHECK(!create_vea_cb.is_null());
   DCHECK(!create_video_encode_memory_cb_.is_null());
   DCHECK_GT(bit_rate_, 0);
 
@@ skipping 39 matching lines @@
   client_->task_runner()->PostTask(
       FROM_HERE, base::Bind(&VEAClientImpl::SetBitRate, client_, bit_rate_));
 }
 
 void ExternalVideoEncoder::GenerateKeyFrame() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   key_frame_requested_ = true;
 }
 
 void ExternalVideoEncoder::OnCreateVideoEncodeAccelerator(
-    const VideoSenderConfig& video_config,
+    const FrameSenderConfig& video_config,
     FrameId first_frame_id,
     const StatusChangeCallback& status_change_cb,
     scoped_refptr<base::SingleThreadTaskRunner> encoder_task_runner,
     std::unique_ptr<media::VideoEncodeAccelerator> vea) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   // The callback will be invoked with null pointers in the case where the
   // system does not support or lacks the resources to provide GPU-accelerated
   // video encoding.
   if (!encoder_task_runner || !vea) {
@@ skipping 31 matching lines @@
                                    base::Bind(&VEAClientImpl::Initialize,
                                               client_,
                                               frame_size_,
                                               codec_profile,
                                               bit_rate_,
                                               first_frame_id));
 }
 
 SizeAdaptableExternalVideoEncoder::SizeAdaptableExternalVideoEncoder(
     const scoped_refptr<CastEnvironment>& cast_environment,
-    const VideoSenderConfig& video_config,
+    const FrameSenderConfig& video_config,
     const StatusChangeCallback& status_change_cb,
     const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
     const CreateVideoEncodeMemoryCallback& create_video_encode_memory_cb)
     : SizeAdaptableVideoEncoderBase(cast_environment,
                                     video_config,
                                     status_change_cb),
       create_vea_cb_(create_vea_cb),
       create_video_encode_memory_cb_(create_video_encode_memory_cb) {}
 
 SizeAdaptableExternalVideoEncoder::~SizeAdaptableExternalVideoEncoder() {}
@@ skipping 155 matching lines @@
   const double kEntropyAtMaxQuantizer = 7.5;
   const double slope =
       (MAX_VP8_QUANTIZER - MIN_VP8_QUANTIZER) / kEntropyAtMaxQuantizer;
   const double quantizer = std::min<double>(
       MAX_VP8_QUANTIZER, MIN_VP8_QUANTIZER + slope * shannon_entropy);
   return quantizer;
 }
 
 }  //  namespace cast
 }  //  namespace media