Pass ownership of external encoders to the ACM

webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng.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.
  */
 
 #include "webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng.h"
 
 #include <algorithm>
 #include <memory>
 #include <limits>
+#include <utility>
 
 namespace webrtc {
 
 namespace {
 
 const int kMaxFrameSizeMs = 60;
 
 std::unique_ptr<CNG_enc_inst, CngInstDeleter> CreateCngInst(
     int sample_rate_hz,
     int sid_frame_interval_ms,
     int num_cng_coefficients) {
   CNG_enc_inst* ci;
   RTC_CHECK_EQ(0, WebRtcCng_CreateEnc(&ci));
   std::unique_ptr<CNG_enc_inst, CngInstDeleter> cng_inst(ci);
   RTC_CHECK_EQ(0,
                WebRtcCng_InitEnc(cng_inst.get(), sample_rate_hz,
                                  sid_frame_interval_ms, num_cng_coefficients));
   return cng_inst;
 }
 
 }  // namespace
 
+AudioEncoderCng::Config::Config() = default;
+
+// TODO(kwiberg): =default this when Visual Studio learns to handle it.
+AudioEncoderCng::Config::Config(Config&& c)
+    : num_channels(c.num_channels),
+      payload_type(c.payload_type),
+      speech_encoder(std::move(c.speech_encoder)),
+      vad_mode(c.vad_mode),
+      sid_frame_interval_ms(c.sid_frame_interval_ms),
+      num_cng_coefficients(c.num_cng_coefficients),
+      vad(c.vad) {}
+
+AudioEncoderCng::Config::~Config() = default;
+
 bool AudioEncoderCng::Config::IsOk() const {
   if (num_channels != 1)
     return false;
   if (!speech_encoder)
     return false;
   if (num_channels != speech_encoder->NumChannels())
     return false;
   if (sid_frame_interval_ms <
       static_cast<int>(speech_encoder->Max10MsFramesInAPacket() * 10))
     return false;
   if (num_cng_coefficients > WEBRTC_CNG_MAX_LPC_ORDER ||
       num_cng_coefficients <= 0)
     return false;
   return true;
 }
 
-AudioEncoderCng::AudioEncoderCng(const Config& config)
-    : speech_encoder_(config.speech_encoder),
+AudioEncoderCng::AudioEncoderCng(Config&& config)
+    : speech_encoder_(
+          ([&] { RTC_CHECK(config.IsOk()) << "Invalid configuration."; }(),
+           std::move(config.speech_encoder))),
       cng_payload_type_(config.payload_type),
       num_cng_coefficients_(config.num_cng_coefficients),
       sid_frame_interval_ms_(config.sid_frame_interval_ms),
       last_frame_active_(true),
       vad_(config.vad ? std::unique_ptr<Vad>(config.vad)
                       : CreateVad(config.vad_mode)) {
-  RTC_CHECK(config.IsOk()) << "Invalid configuration.";
   cng_inst_ = CreateCngInst(SampleRateHz(), sid_frame_interval_ms_,
                             num_cng_coefficients_);
 }
 
 AudioEncoderCng::~AudioEncoderCng() = default;
 
 size_t AudioEncoderCng::MaxEncodedBytes() const {
   const size_t max_encoded_bytes_active = speech_encoder_->MaxEncodedBytes();
   const size_t max_encoded_bytes_passive =
       rtc::CheckedDivExact(kMaxFrameSizeMs, 10) * SamplesPer10msFrame();
@@ skipping 186 matching lines @@
     }
   }
   return info;
 }
 
 size_t AudioEncoderCng::SamplesPer10msFrame() const {
   return rtc::CheckedDivExact(10 * SampleRateHz(), 1000);
 }
 
 }  // namespace webrtc