Refactoring: Hide VideoCodec.codecSpecific as "private"

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

 /*
  *  Copyright (c) 2012 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 271 matching lines @@
 
     unsigned int target_bitrate = stream_bitrates[stream_idx];
     unsigned int max_bitrate = codec_.maxBitrate;
     int framerate = new_framerate;
     // 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)) {
       int tl0_bitrate = std::min(codec_.targetBitrate, target_bitrate);
       max_bitrate = std::min(codec_.maxBitrate, target_bitrate);
       target_bitrate = tl0_bitrate;
     }
     configurations_[i].rc_target_bitrate = target_bitrate;
     temporal_layers_[stream_idx]->ConfigureBitrates(
         target_bitrate, max_bitrate, framerate, &configurations_[i]);
     if (vpx_codec_enc_config_set(&encoders_[i], &configurations_[i])) {
       return WEBRTC_VIDEO_CODEC_ERROR;
@@ skipping 13 matching lines @@
     // Need a key frame if we have not sent this stream before.
     key_frame_request_[stream_idx] = true;
   }
   send_stream_[stream_idx] = send_stream;
 }
 
 void VP8EncoderImpl::SetupTemporalLayers(int num_streams,
                                          int num_temporal_layers,
                                          const VideoCodec& codec) {
   TemporalLayersFactory default_factory;
-  const TemporalLayersFactory* tl_factory = codec.codecSpecific.VP8.tl_factory;
+  const TemporalLayersFactory* tl_factory = codec.VP8().tl_factory;
   if (!tl_factory)
     tl_factory = &default_factory;
   if (num_streams == 1) {
     if (codec.mode == kScreensharing) {
       // Special mode when screensharing on a single stream.
       temporal_layers_.push_back(new ScreenshareLayers(
           num_temporal_layers, rand(), webrtc::Clock::GetRealTimeClock()));
     } else {
       temporal_layers_.push_back(
           tl_factory->Create(num_temporal_layers, rand()));
@@ skipping 21 matching lines @@
   // 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 (number_of_cores < 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;
   }
   int retVal = Release();
   if (retVal < 0) {
     return retVal;
   }
 
   int number_of_streams = NumberOfStreams(*inst);
   bool doing_simulcast = (number_of_streams > 1);
 
   if (doing_simulcast && !ValidSimulcastResolutions(*inst, number_of_streams)) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
 
   int num_temporal_layers =
       doing_simulcast ? inst->simulcastStream[0].numberOfTemporalLayers
-                      : inst->codecSpecific.VP8.numberOfTemporalLayers;
+                      : inst->VP8().numberOfTemporalLayers;
 
   // TODO(andresp): crash if num temporal layers is bananas.
   if (num_temporal_layers < 1)
     num_temporal_layers = 1;
   SetupTemporalLayers(number_of_streams, num_temporal_layers, *inst);
 
-  feedback_mode_ = inst->codecSpecific.VP8.feedbackModeOn;
+  feedback_mode_ = inst->VP8().feedbackModeOn;
 
   timestamp_ = 0;
   codec_ = *inst;
 
   // Code expects simulcastStream resolutions to be correct, make sure they are
   // filled even when there are no simulcast layers.
   if (codec_.numberOfSimulcastStreams == 0) {
     codec_.simulcastStream[0].width = codec_.width;
     codec_.simulcastStream[0].height = codec_.height;
   }
@@ skipping 40 matching lines @@
   if (vpx_codec_enc_config_default(vpx_codec_vp8_cx(), &configurations_[0],
                                    0)) {
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   // setting the time base of the codec
   configurations_[0].g_timebase.num = 1;
   configurations_[0].g_timebase.den = 90000;
   configurations_[0].g_lag_in_frames = 0;  // 0- no frame lagging
 
   // Set the error resilience mode according to user settings.
-  switch (inst->codecSpecific.VP8.resilience) {
+  switch (inst->VP8().resilience) {
     case kResilienceOff:
       // TODO(marpan): We should set keep error resilience off for this mode,
       // independent of temporal layer settings, and make sure we set
       // |codecSpecific.VP8.resilience| = |kResilientStream| at higher level
       // code if we want to get error resilience on.
       configurations_[0].g_error_resilient = 1;
       break;
     case kResilientStream:
       configurations_[0].g_error_resilient = 1;  // TODO(holmer): Replace with
       // VPX_ERROR_RESILIENT_DEFAULT when we
       // drop support for libvpx 9.6.0.
       break;
     case kResilientFrames:
 #ifdef INDEPENDENT_PARTITIONS
       configurations_[0] - g_error_resilient =
           VPX_ERROR_RESILIENT_DEFAULT | VPX_ERROR_RESILIENT_PARTITIONS;
       break;
 #else
       return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;  // Not supported
 #endif
   }
 
   // rate control settings
-  configurations_[0].rc_dropframe_thresh =
-      inst->codecSpecific.VP8.frameDroppingOn ? 30 : 0;
+  configurations_[0].rc_dropframe_thresh = inst->VP8().frameDroppingOn ? 30 : 0;
   configurations_[0].rc_end_usage = VPX_CBR;
   configurations_[0].g_pass = VPX_RC_ONE_PASS;
   // TODO(hellner): investigate why the following two lines produce
   // automaticResizeOn value of 3 when running
   // WebRtcVideoMediaChannelTest.GetStatsMultipleSendStreams inside the talk
   // framework.
   // configurations_[0].rc_resize_allowed =
   //    inst->codecSpecific.VP8.automaticResizeOn ? 1 : 0;
   configurations_[0].rc_resize_allowed = 0;
   // Handle resizing outside of libvpx when doing single-stream.
-  if (inst->codecSpecific.VP8.automaticResizeOn && number_of_streams > 1) {
+  if (inst->VP8().automaticResizeOn && number_of_streams > 1) {
     configurations_[0].rc_resize_allowed = 1;
   }
   configurations_[0].rc_min_quantizer = 2;
   if (inst->qpMax >= configurations_[0].rc_min_quantizer) {
     qp_max_ = inst->qpMax;
   }
   configurations_[0].rc_max_quantizer = qp_max_;
   configurations_[0].rc_undershoot_pct = 100;
   configurations_[0].rc_overshoot_pct = 15;
   configurations_[0].rc_buf_initial_sz = 500;
   configurations_[0].rc_buf_optimal_sz = 600;
   configurations_[0].rc_buf_sz = 1000;
 
   // Set the maximum target size of any key-frame.
   rc_max_intra_target_ = MaxIntraTarget(configurations_[0].rc_buf_optimal_sz);
 
   if (feedback_mode_) {
     // Disable periodic key frames if we get feedback from the decoder
     // through SLI and RPSI.
     configurations_[0].kf_mode = VPX_KF_DISABLED;
-  } else if (inst->codecSpecific.VP8.keyFrameInterval > 0) {
+  } else if (inst->VP8().keyFrameInterval > 0) {
     configurations_[0].kf_mode = VPX_KF_AUTO;
-    configurations_[0].kf_max_dist = inst->codecSpecific.VP8.keyFrameInterval;
+    configurations_[0].kf_max_dist = inst->VP8().keyFrameInterval;
   } else {
     configurations_[0].kf_mode = VPX_KF_DISABLED;
   }
 
   // Allow the user to set the complexity for the base stream.
-  switch (inst->codecSpecific.VP8.complexity) {
+  switch (inst->VP8().complexity) {
     case kComplexityHigh:
       cpu_speed_[0] = -5;
       break;
     case kComplexityHigher:
       cpu_speed_[0] = -4;
       break;
     case kComplexityMax:
       cpu_speed_[0] = -3;
       break;
     default:
@@ skipping 65 matching lines @@
 
   rps_.Init();
   quality_scaler_.Init(QualityScaler::kLowVp8QpThreshold,
                        QualityScaler::kBadVp8QpThreshold, codec_.startBitrate,
                        codec_.width, codec_.height, codec_.maxFramerate);
 
   // Only apply scaling to improve for single-layer streams. The scaling metrics
   // use frame drops as a signal and is only applicable when we drop frames.
   quality_scaler_enabled_ = encoders_.size() == 1 &&
                             configurations_[0].rc_dropframe_thresh > 0 &&
-                            codec_.codecSpecific.VP8.automaticResizeOn;
+                            codec_.VP8()->automaticResizeOn;
 
   return InitAndSetControlSettings();
 }
 
 int VP8EncoderImpl::SetCpuSpeed(int width, int height) {
 #if defined(WEBRTC_ARCH_ARM) || defined(WEBRTC_ARCH_ARM64) || defined(ANDROID)
   // On mobile platform, always set to -12 to leverage between cpu usage
   // and video quality.
   return -12;
 #else
   // For non-ARM, increase encoding complexity (i.e., use lower speed setting)
   // if resolution is below CIF. Otherwise, keep the default/user setting
-  // (|cpu_speed_default_|) set on InitEncode via codecSpecific.VP8.complexity.
+  // (|cpu_speed_default_|) set on InitEncode via VP8().complexity.
   if (width * height < 352 * 288)
     return (cpu_speed_default_ < -4) ? -4 : cpu_speed_default_;
   else
     return cpu_speed_default_;
 #endif
 }
 
 int VP8EncoderImpl::NumberOfThreads(int width, int height, int cpus) {
   if (width * height >= 1920 * 1080 && cpus > 8) {
     return 8;  // 8 threads for 1080p on high perf machines.
@@ skipping 32 matching lines @@
   // TODO(holmer): Investigate possibility of adding a libvpx API
   // for getting the denoised frame from the encoder and using that
   // when encoding lower resolution streams. Would it work with the
   // multi-res encoding feature?
   denoiserState denoiser_state = kDenoiserOnYOnly;
 #if defined(WEBRTC_ARCH_ARM) || defined(WEBRTC_ARCH_ARM64) || defined(ANDROID)
   denoiser_state = kDenoiserOnYOnly;
 #else
   denoiser_state = kDenoiserOnAdaptive;
 #endif
-  vpx_codec_control(
-      &encoders_[0], VP8E_SET_NOISE_SENSITIVITY,
-      codec_.codecSpecific.VP8.denoisingOn ? denoiser_state : kDenoiserOff);
+  vpx_codec_control(&encoders_[0], VP8E_SET_NOISE_SENSITIVITY,
+                    codec_.VP8()->denoisingOn ? denoiser_state : kDenoiserOff);
   if (encoders_.size() > 2) {
     vpx_codec_control(
         &encoders_[1], VP8E_SET_NOISE_SENSITIVITY,
-        codec_.codecSpecific.VP8.denoisingOn ? denoiser_state : kDenoiserOff);
+        codec_.VP8()->denoisingOn ? denoiser_state : kDenoiserOff);
   }
   for (size_t i = 0; i < encoders_.size(); ++i) {
     // Allow more screen content to be detected as static.
     vpx_codec_control(&(encoders_[i]), VP8E_SET_STATIC_THRESHOLD,
                       codec_.mode == kScreensharing ? 300 : 1);
     vpx_codec_control(&(encoders_[i]), VP8E_SET_CPUUSED, cpu_speed_[i]);
     vpx_codec_control(&(encoders_[i]), VP8E_SET_TOKEN_PARTITIONS,
                       static_cast<vp8e_token_partitions>(token_partitions_));
     vpx_codec_control(&(encoders_[i]), VP8E_SET_MAX_INTRA_BITRATE_PCT,
                       rc_max_intra_target_);
@@ skipping 109 matching lines @@
     }
   }
   // The flag modification below (due to forced key frame, RPS, etc.,) for now
   // will be the same for all encoders/spatial layers.
   // TODO(marpan/holmer): Allow for key frame request to be set per encoder.
   bool only_predict_from_key_frame = false;
   if (send_key_frame) {
     // Adapt the size of the key frame when in screenshare with 1 temporal
     // layer.
     if (encoders_.size() == 1 && codec_.mode == kScreensharing &&
-        codec_.codecSpecific.VP8.numberOfTemporalLayers <= 1) {
+        codec_.VP8()->numberOfTemporalLayers <= 1) {
       const uint32_t forceKeyFrameIntraTh = 100;
       vpx_codec_control(&(encoders_[0]), VP8E_SET_MAX_INTRA_BITRATE_PCT,
                         forceKeyFrameIntraTh);
     }
     // Key frame request from caller.
     // Will update both golden and alt-ref.
     for (size_t i = 0; i < encoders_.size(); ++i) {
       flags[i] = VPX_EFLAG_FORCE_KF;
     }
     std::fill(key_frame_request_.begin(), key_frame_request_.end(), false);
@@ skipping 271 matching lines @@
 
 int VP8DecoderImpl::InitDecode(const VideoCodec* inst, int number_of_cores) {
   int ret_val = Release();
   if (ret_val < 0) {
     return ret_val;
   }
   if (decoder_ == NULL) {
     decoder_ = new vpx_codec_ctx_t;
   }
   if (inst && inst->codecType == kVideoCodecVP8) {
-    feedback_mode_ = inst->codecSpecific.VP8.feedbackModeOn;
+    feedback_mode_ = inst->VP8().feedbackModeOn;
   }
   vpx_codec_dec_cfg_t cfg;
   // Setting number of threads to a constant value (1)
   cfg.threads = 1;
   cfg.h = cfg.w = 0;  // set after decode
 
   vpx_codec_flags_t flags = 0;
 #if !defined(WEBRTC_ARCH_ARM) && !defined(WEBRTC_ARCH_ARM64) && \
   !defined(ANDROID)
   flags = VPX_CODEC_USE_POSTPROC;
@@ skipping 297 matching lines @@
     return -1;
   }
   if (vpx_codec_control(copy->decoder_, VP8_SET_REFERENCE, ref_frame_) !=
       VPX_CODEC_OK) {
     return -1;
   }
   return 0;
 }
 
 }  // namespace webrtc