Simplify passing video codec factories in media engine

webrtc/media/engine/webrtcvideoengine.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 50 matching lines @@
     bool has_internal_source;
   };
 
   virtual ~EncoderFactoryAdapter() {}
 
   virtual AllocatedEncoder CreateVideoEncoder(
       const VideoCodec& codec,
       bool is_conference_mode_screenshare) const = 0;
 
   virtual std::vector<VideoCodec> GetSupportedCodecs() const = 0;
-
-  virtual std::unique_ptr<EncoderFactoryAdapter> clone() const = 0;
 };
 
 class DecoderFactoryAdapter {
  public:
   virtual ~DecoderFactoryAdapter() {}
 
   virtual std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
       const VideoCodec& codec,
       const VideoDecoderParams& decoder_params) const = 0;
-
-  virtual std::unique_ptr<DecoderFactoryAdapter> clone() const = 0;
 };
 
 namespace {
 
+std::vector<VideoCodec> AssignPayloadTypesAndAddAssociatedRtxCodecs(
+    const std::vector<VideoCodec>& input_codecs);
+
 // Wraps cricket::WebRtcVideoEncoderFactory* into common EncoderFactoryAdapter
 // interface.
 // TODO(magjed): Add wrapper class for future webrtc::VideoEncoderFactory
 // interface, https://bugs.chromium.org/p/webrtc/issues/detail?id=7925.
 class CricketEncoderFactoryAdapter : public EncoderFactoryAdapter {
  public:
   explicit CricketEncoderFactoryAdapter(
       WebRtcVideoEncoderFactory* external_encoder_factory)
       : internal_encoder_factory_(new InternalEncoderFactory()),
         external_encoder_factory_(external_encoder_factory) {}
 
  private:
   explicit CricketEncoderFactoryAdapter(
       const CricketEncoderFactoryAdapter& other)
       : CricketEncoderFactoryAdapter(other.external_encoder_factory_) {}
 
   AllocatedEncoder CreateVideoEncoder(
       const VideoCodec& codec,
       bool is_conference_mode_screenshare) const override;
 
   std::vector<VideoCodec> GetSupportedCodecs() const override;
 
-  std::unique_ptr<EncoderFactoryAdapter> clone() const override {
-    return std::unique_ptr<EncoderFactoryAdapter>(
-        new CricketEncoderFactoryAdapter(*this));
-  }
-
   const std::unique_ptr<WebRtcVideoEncoderFactory> internal_encoder_factory_;
   WebRtcVideoEncoderFactory* const external_encoder_factory_;
 };
 
 class CricketDecoderFactoryAdapter : public DecoderFactoryAdapter {
  public:
   explicit CricketDecoderFactoryAdapter(
       WebRtcVideoDecoderFactory* external_decoder_factory)
       : internal_decoder_factory_(new InternalDecoderFactory()),
         external_decoder_factory_(external_decoder_factory) {}
 
  private:
   explicit CricketDecoderFactoryAdapter(
       const CricketDecoderFactoryAdapter& other)
       : CricketDecoderFactoryAdapter(other.external_decoder_factory_) {}
 
   std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
       const VideoCodec& codec,
       const VideoDecoderParams& decoder_params) const override;
 
-  std::unique_ptr<DecoderFactoryAdapter> clone() const override {
-    return std::unique_ptr<DecoderFactoryAdapter>(
-        new CricketDecoderFactoryAdapter(*this));
-  }
-
   const std::unique_ptr<WebRtcVideoDecoderFactory> internal_decoder_factory_;
   WebRtcVideoDecoderFactory* const external_decoder_factory_;
 };
 
 // If this field trial is enabled, we will enable sending FlexFEC and disable
 // sending ULPFEC whenever the former has been negotiated in the SDPs.
 bool IsFlexfecFieldTrialEnabled() {
   return webrtc::field_trial::IsEnabled("WebRTC-FlexFEC-03");
 }
 
@@ skipping 245 matching lines @@
     WebRtcVideoChannel* channel,
     rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
   default_sink_ = sink;
   rtc::Optional<uint32_t> default_recv_ssrc =
       channel->GetDefaultReceiveStreamSsrc();
   if (default_recv_ssrc) {
     channel->SetSink(*default_recv_ssrc, default_sink_);
   }
 }
 
-WebRtcVideoEngine::WebRtcVideoEngine()
-    : initialized_(false),
-      decoder_factory_(new CricketDecoderFactoryAdapter(
-          nullptr /* external_decoder_factory */)),
-      encoder_factory_(new CricketEncoderFactoryAdapter(
-          nullptr /* external_encoder_factory */)) {
+WebRtcVideoEngine::WebRtcVideoEngine(
+    WebRtcVideoEncoderFactory* external_video_encoder_factory,
+    WebRtcVideoDecoderFactory* external_video_decoder_factory)
+    : decoder_factory_(
+          new CricketDecoderFactoryAdapter(external_video_decoder_factory)),
+      encoder_factory_(
+          new CricketEncoderFactoryAdapter(external_video_encoder_factory)) {
   LOG(LS_INFO) << "WebRtcVideoEngine::WebRtcVideoEngine()";
 }
 
 WebRtcVideoEngine::~WebRtcVideoEngine() {
   LOG(LS_INFO) << "WebRtcVideoEngine::~WebRtcVideoEngine";
 }
 
-void WebRtcVideoEngine::Init() {
-  LOG(LS_INFO) << "WebRtcVideoEngine::Init";
-  initialized_ = true;
-}
-
 WebRtcVideoChannel* WebRtcVideoEngine::CreateChannel(
     webrtc::Call* call,
     const MediaConfig& config,
     const VideoOptions& options) {
-  RTC_DCHECK(initialized_);
   LOG(LS_INFO) << "CreateChannel. Options: " << options.ToString();
-  return new WebRtcVideoChannel(call, config, options, *encoder_factory_,
-                                *decoder_factory_);
+  return new WebRtcVideoChannel(call, config, options, encoder_factory_.get(),
+                                decoder_factory_.get());
 }
 
 std::vector<VideoCodec> WebRtcVideoEngine::codecs() const {
   return encoder_factory_->GetSupportedCodecs();
 }
 
 RtpCapabilities WebRtcVideoEngine::GetCapabilities() const {
   RtpCapabilities capabilities;
   capabilities.header_extensions.push_back(
       webrtc::RtpExtension(webrtc::RtpExtension::kTimestampOffsetUri,
@@ skipping 12 matching lines @@
                            webrtc::RtpExtension::kPlayoutDelayDefaultId));
   capabilities.header_extensions.push_back(
       webrtc::RtpExtension(webrtc::RtpExtension::kVideoContentTypeUri,
                            webrtc::RtpExtension::kVideoContentTypeDefaultId));
   capabilities.header_extensions.push_back(
         webrtc::RtpExtension(webrtc::RtpExtension::kVideoTimingUri,
                              webrtc::RtpExtension::kVideoTimingDefaultId));
   return capabilities;
 }
 
-void WebRtcVideoEngine::SetExternalDecoderFactory(
-    WebRtcVideoDecoderFactory* decoder_factory) {
-  RTC_DCHECK(!initialized_);
-  decoder_factory_.reset(new CricketDecoderFactoryAdapter(decoder_factory));
-}
-
-void WebRtcVideoEngine::SetExternalEncoderFactory(
-    WebRtcVideoEncoderFactory* encoder_factory) {
-  RTC_DCHECK(!initialized_);
-  encoder_factory_.reset(new CricketEncoderFactoryAdapter(encoder_factory));
-}
-
+namespace {
 // This function will assign dynamic payload types (in the range [96, 127]) to
 // the input codecs, and also add associated RTX codecs for recognized codecs
 // (VP8, VP9, H264, and RED). It will also add default feedback params to the
 // codecs.
-static std::vector<VideoCodec> AssignPayloadTypesAndAddAssociatedRtxCodecs(
+std::vector<VideoCodec> AssignPayloadTypesAndAddAssociatedRtxCodecs(
     const std::vector<VideoCodec>& input_codecs) {
   static const int kFirstDynamicPayloadType = 96;
   static const int kLastDynamicPayloadType = 127;
   int payload_type = kFirstDynamicPayloadType;
   std::vector<VideoCodec> output_codecs;
   for (VideoCodec codec : input_codecs) {
     codec.id = payload_type;
     if (codec.name != kRedCodecName && codec.name != kUlpfecCodecName &&
         codec.name != kFlexfecCodecName) {
       AddDefaultFeedbackParams(&codec);
@@ skipping 16 matching lines @@
           VideoCodec::CreateRtxCodec(payload_type, codec.id));
 
       // Increment payload type.
       ++payload_type;
       if (payload_type > kLastDynamicPayloadType)
         break;
     }
   }
   return output_codecs;
 }
+}  // namespace
 
 std::vector<VideoCodec> CricketEncoderFactoryAdapter::GetSupportedCodecs()
     const {
   std::vector<VideoCodec> codecs = InternalEncoderFactory().supported_codecs();
   LOG(LS_INFO) << "Internally supported codecs: "
                << CodecVectorToString(codecs);
 
   // Add external codecs.
   if (external_encoder_factory_ != nullptr) {
     const std::vector<VideoCodec>& external_codecs =
         external_encoder_factory_->supported_codecs();
     for (const VideoCodec& codec : external_codecs) {
       // Don't add same codec twice.
       if (!FindMatchingCodec(codecs, codec))
         codecs.push_back(codec);
     }
     LOG(LS_INFO) << "Codecs supported by the external encoder factory: "
                  << CodecVectorToString(external_codecs);
   }
 
   return AssignPayloadTypesAndAddAssociatedRtxCodecs(codecs);
 }
 
 WebRtcVideoChannel::WebRtcVideoChannel(
     webrtc::Call* call,
     const MediaConfig& config,
     const VideoOptions& options,
-    const EncoderFactoryAdapter& encoder_factory,
-    const DecoderFactoryAdapter& decoder_factory)
+    const EncoderFactoryAdapter* encoder_factory,
+    const DecoderFactoryAdapter* decoder_factory)
     : VideoMediaChannel(config),
       call_(call),
       unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
       video_config_(config.video),
-      encoder_factory_(encoder_factory.clone()),
-      decoder_factory_(decoder_factory.clone()),
+      encoder_factory_(encoder_factory),
+      decoder_factory_(decoder_factory),
       default_send_options_(options),
       last_stats_log_ms_(-1) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
   rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
   sending_ = false;
   recv_codecs_ = MapCodecs(encoder_factory_->GetSupportedCodecs());
   recv_flexfec_payload_type_ = recv_codecs_.front().flexfec_payload_type;
 }
 
@@ skipping 484 matching lines @@
     return false;
 
   for (uint32_t used_ssrc : sp.ssrcs)
     send_ssrcs_.insert(used_ssrc);
 
   webrtc::VideoSendStream::Config config(this);
   config.suspend_below_min_bitrate = video_config_.suspend_below_min_bitrate;
   config.periodic_alr_bandwidth_probing =
       video_config_.periodic_alr_bandwidth_probing;
   WebRtcVideoSendStream* stream = new WebRtcVideoSendStream(
-      call_, sp, std::move(config), default_send_options_, *encoder_factory_,
+      call_, sp, std::move(config), default_send_options_, encoder_factory_,
       video_config_.enable_cpu_overuse_detection,
       bitrate_config_.max_bitrate_bps, send_codec_, send_rtp_extensions_,
       send_params_);
 
   uint32_t ssrc = sp.first_ssrc();
   RTC_DCHECK(ssrc != 0);
   send_streams_[ssrc] = stream;
 
   if (rtcp_receiver_report_ssrc_ == kDefaultRtcpReceiverReportSsrc) {
     rtcp_receiver_report_ssrc_ = ssrc;
@@ skipping 90 matching lines @@
 
   webrtc::VideoReceiveStream::Config config(this);
   webrtc::FlexfecReceiveStream::Config flexfec_config(this);
   ConfigureReceiverRtp(&config, &flexfec_config, sp);
 
   config.disable_prerenderer_smoothing =
       video_config_.disable_prerenderer_smoothing;
   config.sync_group = sp.sync_label;
 
   receive_streams_[ssrc] = new WebRtcVideoReceiveStream(
-      call_, sp, std::move(config), *decoder_factory_, default_stream,
+      call_, sp, std::move(config), decoder_factory_, default_stream,
       recv_codecs_, flexfec_config);
 
   return true;
 }
 
 void WebRtcVideoChannel::ConfigureReceiverRtp(
     webrtc::VideoReceiveStream::Config* config,
     webrtc::FlexfecReceiveStream::Config* flexfec_config,
     const StreamParams& sp) const {
   uint32_t ssrc = sp.first_ssrc();
@@ skipping 318 matching lines @@
     bool has_internal_source)
     : encoder(std::move(encoder)),
       is_hardware_accelerated(is_hardware_accelerated),
       has_internal_source(has_internal_source) {}
 
 WebRtcVideoChannel::WebRtcVideoSendStream::WebRtcVideoSendStream(
     webrtc::Call* call,
     const StreamParams& sp,
     webrtc::VideoSendStream::Config config,
     const VideoOptions& options,
-    const EncoderFactoryAdapter& encoder_factory,
+    const EncoderFactoryAdapter* encoder_factory,
     bool enable_cpu_overuse_detection,
     int max_bitrate_bps,
     const rtc::Optional<VideoCodecSettings>& codec_settings,
     const rtc::Optional<std::vector<webrtc::RtpExtension>>& rtp_extensions,
     // TODO(deadbeef): Don't duplicate information between send_params,
     // rtp_extensions, options, etc.
     const VideoSendParameters& send_params)
     : worker_thread_(rtc::Thread::Current()),
       ssrcs_(sp.ssrcs),
       ssrc_groups_(sp.ssrc_groups),
       call_(call),
       enable_cpu_overuse_detection_(enable_cpu_overuse_detection),
       source_(nullptr),
-      encoder_factory_(encoder_factory.clone()),
+      encoder_factory_(encoder_factory),
       stream_(nullptr),
       encoder_sink_(nullptr),
       parameters_(std::move(config), options, max_bitrate_bps, codec_settings),
       rtp_parameters_(CreateRtpParametersWithOneEncoding()),
       sending_(false) {
   parameters_.config.rtp.max_packet_size = kVideoMtu;
   parameters_.conference_mode = send_params.conference_mode;
 
   sp.GetPrimarySsrcs(&parameters_.config.rtp.ssrcs);
 
@@ skipping 566 matching lines @@
   }
 
   // Call stream_->Start() if necessary conditions are met.
   UpdateSendState();
 }
 
 WebRtcVideoChannel::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
     webrtc::Call* call,
     const StreamParams& sp,
     webrtc::VideoReceiveStream::Config config,
-    const DecoderFactoryAdapter& decoder_factory,
+    const DecoderFactoryAdapter* decoder_factory,
     bool default_stream,
     const std::vector<VideoCodecSettings>& recv_codecs,
     const webrtc::FlexfecReceiveStream::Config& flexfec_config)
     : call_(call),
       stream_params_(sp),
       stream_(NULL),
       default_stream_(default_stream),
       config_(std::move(config)),
       flexfec_config_(flexfec_config),
       flexfec_stream_(nullptr),
-      decoder_factory_(decoder_factory.clone()),
+      decoder_factory_(decoder_factory),
       sink_(NULL),
       first_frame_timestamp_(-1),
       estimated_remote_start_ntp_time_ms_(0) {
   config_.renderer = this;
   DecoderMap old_decoders;
   ConfigureCodecs(recv_codecs, &old_decoders);
   ConfigureFlexfecCodec(flexfec_config.payload_type);
   MaybeRecreateWebRtcFlexfecStream();
   RecreateWebRtcVideoStream();
   RTC_DCHECK(old_decoders.empty());
@@ skipping 506 matching lines @@
     stream.temporal_layer_thresholds_bps.resize(GetDefaultVp9TemporalLayers() -
                                                 1);
   }
 
   std::vector<webrtc::VideoStream> streams;
   streams.push_back(stream);
   return streams;
 }
 
 }  // namespace cricket