Refactoring: Hide VideoCodec.codecSpecific as "private"

webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.cc

 /*
  *  Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 56 matching lines @@
   if (inst->maxFramerate < 1) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   // allow zero to represent an unspecified maxBitRate
   if (inst->maxBitrate > 0 && inst->startBitrate > inst->maxBitrate) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   if (inst->width <= 1 || inst->height <= 1) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
-  if (inst->codecSpecific.VP8.feedbackModeOn &&
-      inst->numberOfSimulcastStreams > 1) {
+  if (inst->VP8().feedbackModeOn && inst->numberOfSimulcastStreams > 1) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
-  if (inst->codecSpecific.VP8.automaticResizeOn &&
-      inst->numberOfSimulcastStreams > 1) {
+  if (inst->VP8().automaticResizeOn && inst->numberOfSimulcastStreams > 1) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 struct ScreenshareTemporalLayersFactory : webrtc::TemporalLayersFactory {
   ScreenshareTemporalLayersFactory() {}
   virtual ~ScreenshareTemporalLayersFactory() {}
 
   virtual webrtc::TemporalLayers* Create(int num_temporal_layers,
@@ skipping 82 matching lines @@
   }
 
   codec_ = *inst;
   rate_allocator_.reset(new SimulcastRateAllocator(codec_));
   std::vector<uint32_t> start_bitrates =
       rate_allocator_->GetAllocation(codec_.startBitrate);
 
   // Special mode when screensharing on a single stream.
   if (number_of_streams == 1 && inst->mode == kScreensharing) {
     screensharing_tl_factory_.reset(new ScreenshareTemporalLayersFactory());
-    codec_.codecSpecific.VP8.tl_factory = screensharing_tl_factory_.get();
+    codec_.VP8()->tl_factory = screensharing_tl_factory_.get();
   }
 
   std::string implementation_name;
   // Create |number_of_streams| of encoder instances and init them.
   for (int i = 0; i < number_of_streams; ++i) {
     VideoCodec stream_codec;
     uint32_t start_bitrate_kbps = start_bitrates[i];
     if (!doing_simulcast) {
       stream_codec = codec_;
       stream_codec.numberOfSimulcastStreams = 1;
@@ skipping 183 matching lines @@
       streaminfos_[stream_idx].key_frame_request = true;
     }
     streaminfos_[stream_idx].send_stream = stream_bitrate_kbps > 0;
 
     // TODO(holmer): This is a temporary hack for screensharing, where we
     // interpret the startBitrate as the encoder target bitrate. This is
     // to allow for a different max bitrate, so if the codec can't meet
     // the target we still allow it to overshoot up to the max before dropping
     // frames. This hack should be improved.
     if (codec_.targetBitrate > 0 &&
-        (codec_.codecSpecific.VP8.numberOfTemporalLayers == 2 ||
+        (codec_.VP8()->numberOfTemporalLayers == 2 ||
          codec_.simulcastStream[0].numberOfTemporalLayers == 2)) {
       stream_bitrate_kbps = std::min(codec_.maxBitrate, stream_bitrate_kbps);
       // TODO(ronghuawu): Can't change max bitrate via the VideoEncoder
       // interface. And VP8EncoderImpl doesn't take negative framerate.
       // max_bitrate = std::min(codec_.maxBitrate, stream_bitrate_kbps);
       // new_framerate = -1;
     }
 
     streaminfos_[stream_idx].encoder->SetRates(stream_bitrate_kbps,
                                                new_framerate);
@@ skipping 18 matching lines @@
 
 void SimulcastEncoderAdapter::PopulateStreamCodec(
     const webrtc::VideoCodec* inst,
     int stream_index,
     uint32_t start_bitrate_kbps,
     bool highest_resolution_stream,
     webrtc::VideoCodec* stream_codec) {
   *stream_codec = *inst;
 
   // Stream specific settings.
-  stream_codec->codecSpecific.VP8.numberOfTemporalLayers =
+  stream_codec->VP8()->numberOfTemporalLayers =
       inst->simulcastStream[stream_index].numberOfTemporalLayers;
   stream_codec->numberOfSimulcastStreams = 0;
   stream_codec->width = inst->simulcastStream[stream_index].width;
   stream_codec->height = inst->simulcastStream[stream_index].height;
   stream_codec->maxBitrate = inst->simulcastStream[stream_index].maxBitrate;
   stream_codec->minBitrate = inst->simulcastStream[stream_index].minBitrate;
   stream_codec->qpMax = inst->simulcastStream[stream_index].qpMax;
   // Settings that are based on stream/resolution.
   if (stream_index == 0) {
     // Settings for lowest spatial resolutions.
     stream_codec->qpMax = kLowestResMaxQp;
   }
   if (!highest_resolution_stream) {
     // For resolutions below CIF, set the codec |complexity| parameter to
     // kComplexityHigher, which maps to cpu_used = -4.
     int pixels_per_frame = stream_codec->width * stream_codec->height;
     if (pixels_per_frame < 352 * 288) {
-      stream_codec->codecSpecific.VP8.complexity = webrtc::kComplexityHigher;
+      stream_codec->VP8()->complexity = webrtc::kComplexityHigher;
     }
     // Turn off denoising for all streams but the highest resolution.
-    stream_codec->codecSpecific.VP8.denoisingOn = false;
+    stream_codec->VP8()->denoisingOn = false;
   }
   // TODO(ronghuawu): what to do with targetBitrate.
 
   stream_codec->startBitrate = start_bitrate_kbps;
 }
 
 bool SimulcastEncoderAdapter::Initialized() const {
   return !streaminfos_.empty();
 }
 
 void SimulcastEncoderAdapter::OnDroppedFrame() {
   streaminfos_[0].encoder->OnDroppedFrame();
 }
 
 bool SimulcastEncoderAdapter::SupportsNativeHandle() const {
   // We should not be calling this method before streaminfos_ are configured.
   RTC_DCHECK(!streaminfos_.empty());
   for (const auto& streaminfo : streaminfos_) {
     if (!streaminfo.encoder->SupportsNativeHandle())
       return false;
   }
   return true;
 }
 
 const char* SimulcastEncoderAdapter::ImplementationName() const {
   return implementation_name_.c_str();
 }
 
 }  // namespace webrtc