Revert of Declare VideoCodec.codec_specific_info private

webrtc/video/vie_encoder.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 56 matching lines @@
       }
       break;
   }
 
   if (config.encoder_specific_settings)
     config.encoder_specific_settings->FillEncoderSpecificSettings(&video_codec);
 
   switch (video_codec.codecType) {
     case kVideoCodecVP8: {
       if (!config.encoder_specific_settings)
-        *video_codec.VP8() = VideoEncoder::GetDefaultVp8Settings();
-      video_codec.VP8()->numberOfTemporalLayers = static_cast<unsigned char>(
-          streams.back().temporal_layer_thresholds_bps.size() + 1);
+        video_codec.codecSpecific.VP8 = VideoEncoder::GetDefaultVp8Settings();
+      video_codec.codecSpecific.VP8.numberOfTemporalLayers =
+          static_cast<unsigned char>(
+              streams.back().temporal_layer_thresholds_bps.size() + 1);
       break;
     }
     case kVideoCodecVP9: {
       if (!config.encoder_specific_settings)
-        *video_codec.VP9() = VideoEncoder::GetDefaultVp9Settings();
+        video_codec.codecSpecific.VP9 = VideoEncoder::GetDefaultVp9Settings();
       if (video_codec.mode == kScreensharing &&
           config.encoder_specific_settings) {
-        video_codec.VP9()->flexibleMode = true;
+        video_codec.codecSpecific.VP9.flexibleMode = true;
         // For now VP9 screensharing use 1 temporal and 2 spatial layers.
-        RTC_DCHECK_EQ(1, video_codec.VP9()->numberOfTemporalLayers);
-        RTC_DCHECK_EQ(2, video_codec.VP9()->numberOfSpatialLayers);
+        RTC_DCHECK_EQ(1, video_codec.codecSpecific.VP9.numberOfTemporalLayers);
+        RTC_DCHECK_EQ(2, video_codec.codecSpecific.VP9.numberOfSpatialLayers);
       }
-      video_codec.VP9()->numberOfTemporalLayers = static_cast<unsigned char>(
-          streams.back().temporal_layer_thresholds_bps.size() + 1);
+      video_codec.codecSpecific.VP9.numberOfTemporalLayers =
+          static_cast<unsigned char>(
+              streams.back().temporal_layer_thresholds_bps.size() + 1);
       break;
     }
     case kVideoCodecH264: {
       if (!config.encoder_specific_settings)
-        *video_codec.H264() = VideoEncoder::GetDefaultH264Settings();
+        video_codec.codecSpecific.H264 = VideoEncoder::GetDefaultH264Settings();
       break;
     }
     default:
       // TODO(pbos): Support encoder_settings codec-agnostically.
       RTC_DCHECK(!config.encoder_specific_settings)
           << "Encoder-specific settings for codec type not wired up.";
       break;
   }
 
   strncpy(video_codec.plName, payload_name.c_str(), kPayloadNameSize - 1);
   video_codec.plName[kPayloadNameSize - 1] = '\0';
   video_codec.plType = payload_type;
   video_codec.numberOfSimulcastStreams =
       static_cast<unsigned char>(streams.size());
   video_codec.minBitrate = streams[0].min_bitrate_bps / 1000;
   if (video_codec.minBitrate < kEncoderMinBitrateKbps)
     video_codec.minBitrate = kEncoderMinBitrateKbps;
   RTC_DCHECK_LE(streams.size(), static_cast<size_t>(kMaxSimulcastStreams));
   if (video_codec.codecType == kVideoCodecVP9) {
     // If the vector is empty, bitrates will be configured automatically.
     RTC_DCHECK(config.spatial_layers.empty() ||
                config.spatial_layers.size() ==
-                   video_codec.VP9()->numberOfSpatialLayers);
-    RTC_DCHECK_LE(video_codec.VP9()->numberOfSpatialLayers,
+                   video_codec.codecSpecific.VP9.numberOfSpatialLayers);
+    RTC_DCHECK_LE(video_codec.codecSpecific.VP9.numberOfSpatialLayers,
                   kMaxSimulcastStreams);
     for (size_t i = 0; i < config.spatial_layers.size(); ++i)
       video_codec.spatialLayers[i] = config.spatial_layers[i];
   }
   for (size_t i = 0; i < streams.size(); ++i) {
     SimulcastStream* sim_stream = &video_codec.simulcastStream[i];
     RTC_DCHECK_GT(streams[i].width, 0u);
     RTC_DCHECK_GT(streams[i].height, 0u);
     RTC_DCHECK_GT(streams[i].max_framerate, 0);
     // Different framerates not supported per stream at the moment.
@@ skipping 521 matching lines @@
 
   TRACE_EVENT_ASYNC_STEP0("webrtc", "Video", video_frame.render_time_ms(),
                           "Encode");
 
   overuse_detector_.FrameCaptured(video_frame, time_when_posted_in_ms);
 
   if (codec_type_ == webrtc::kVideoCodecVP8) {
     webrtc::CodecSpecificInfo codec_specific_info;
     codec_specific_info.codecType = webrtc::kVideoCodecVP8;
 
-    codec_specific_info.codecSpecific.VP8.hasReceivedRPSI = has_received_rpsi_;
-    codec_specific_info.codecSpecific.VP8.hasReceivedSLI = has_received_sli_;
-    codec_specific_info.codecSpecific.VP8.pictureIdRPSI = picture_id_rpsi_;
-    codec_specific_info.codecSpecific.VP8.pictureIdSLI = picture_id_sli_;
-    has_received_sli_ = false;
-    has_received_rpsi_ = false;
+      codec_specific_info.codecSpecific.VP8.hasReceivedRPSI =
+          has_received_rpsi_;
+      codec_specific_info.codecSpecific.VP8.hasReceivedSLI =
+          has_received_sli_;
+      codec_specific_info.codecSpecific.VP8.pictureIdRPSI =
+          picture_id_rpsi_;
+      codec_specific_info.codecSpecific.VP8.pictureIdSLI  =
+          picture_id_sli_;
+      has_received_sli_ = false;
+      has_received_rpsi_ = false;
 
-    video_sender_.AddVideoFrame(video_frame, &codec_specific_info);
-    return;
+      video_sender_.AddVideoFrame(video_frame, &codec_specific_info);
+      return;
   }
   video_sender_.AddVideoFrame(video_frame, nullptr);
 }
 
 void ViEEncoder::SendKeyFrame() {
   if (!encoder_queue_.IsCurrent()) {
     encoder_queue_.PostTask([this] { SendKeyFrame(); });
     return;
   }
   RTC_DCHECK_RUN_ON(&encoder_queue_);
@@ skipping 135 matching lines @@
       current_pixel_count > *max_pixel_count_step_up_) {
     max_pixel_count_ = rtc::Optional<int>();
     max_pixel_count_step_up_ = rtc::Optional<int>(current_pixel_count);
     --cpu_restricted_counter_;
     stats_proxy_->OnCpuRestrictedResolutionChanged(cpu_restricted_counter_ > 0);
     source_proxy_->RequestHigherResolutionThan(current_pixel_count);
   }
 }
 
 }  // namespace webrtc