Remove extra_options from VideoCodec.

webrtc/common_types.h

 /*
  *  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 551 matching lines @@
   kResilienceOff,    // The stream produced by the encoder requires a
                      // recovery frame (typically a key frame) to be
                      // decodable after a packet loss.
   kResilientStream,  // A stream produced by the encoder is resilient to
                      // packet losses, but packets within a frame subsequent
                      // to a loss can't be decoded.
   kResilientFrames   // Same as kResilientStream but with added resilience
                      // within a frame.
 };
 
+class TemporalLayersFactory;
 // VP8 specific
 struct VideoCodecVP8 {
   bool                 pictureLossIndicationOn;
   bool                 feedbackModeOn;
   VideoCodecComplexity complexity;
   VP8ResilienceMode    resilience;
   unsigned char        numberOfTemporalLayers;
   bool                 denoisingOn;
   bool                 errorConcealmentOn;
   bool                 automaticResizeOn;
   bool                 frameDroppingOn;
   int                  keyFrameInterval;
-
-  bool operator==(const VideoCodecVP8& other) const {
-    return pictureLossIndicationOn == other.pictureLossIndicationOn &&
-           feedbackModeOn == other.feedbackModeOn &&
-           complexity == other.complexity &&
-           resilience == other.resilience &&
-           numberOfTemporalLayers == other.numberOfTemporalLayers &&
-           denoisingOn == other.denoisingOn &&
-           errorConcealmentOn == other.errorConcealmentOn &&
-           automaticResizeOn == other.automaticResizeOn &&
-           frameDroppingOn == other.frameDroppingOn &&
-           keyFrameInterval == other.keyFrameInterval;
-  }
-
-  bool operator!=(const VideoCodecVP8& other) const {
-    return !(*this == other);
-  }
+  const TemporalLayersFactory* tl_factory;
 };
 
 // VP9 specific.
 struct VideoCodecVP9 {
   VideoCodecComplexity complexity;
   int                  resilience;
   unsigned char        numberOfTemporalLayers;
   bool                 denoisingOn;
   bool                 frameDroppingOn;
   int                  keyFrameInterval;
@@ skipping 37 matching lines @@
 // Simulcast is when the same stream is encoded multiple times with different
 // settings such as resolution.
 struct SimulcastStream {
   unsigned short      width;
   unsigned short      height;
   unsigned char       numberOfTemporalLayers;
   unsigned int        maxBitrate;  // kilobits/sec.
   unsigned int        targetBitrate;  // kilobits/sec.
   unsigned int        minBitrate;  // kilobits/sec.
   unsigned int        qpMax; // minimum quality
-
-  bool operator==(const SimulcastStream& other) const {
-    return width == other.width &&
-           height == other.height &&
-           numberOfTemporalLayers == other.numberOfTemporalLayers &&
-           maxBitrate == other.maxBitrate &&
-           targetBitrate == other.targetBitrate &&
-           minBitrate == other.minBitrate &&
-           qpMax == other.qpMax;
-  }
-
-  bool operator!=(const SimulcastStream& other) const {
-    return !(*this == other);
-  }
 };
 
 struct SpatialLayer {
   int scaling_factor_num;
   int scaling_factor_den;
   int target_bitrate_bps;
   // TODO(ivica): Add max_quantizer and min_quantizer?
 };
 
 enum VideoCodecMode {
@@ skipping 19 matching lines @@
 
   VideoCodecUnion     codecSpecific;
 
   unsigned int        qpMax;
   unsigned char       numberOfSimulcastStreams;
   SimulcastStream     simulcastStream[kMaxSimulcastStreams];
   SpatialLayer spatialLayers[kMaxSpatialLayers];
 
   VideoCodecMode      mode;
 
-  // When using an external encoder/decoder this allows to pass
-  // extra options without requiring webrtc to be aware of them.
-  Config*  extra_options;
-
-  bool operator==(const VideoCodec& other) const {
-    bool ret = codecType == other.codecType &&
-               (STR_CASE_CMP(plName, other.plName) == 0) &&
-               plType == other.plType &&
-               width == other.width &&
-               height == other.height &&
-               startBitrate == other.startBitrate &&
-               maxBitrate == other.maxBitrate &&
-               minBitrate == other.minBitrate &&
-               targetBitrate == other.targetBitrate &&
-               maxFramerate == other.maxFramerate &&
-               qpMax == other.qpMax &&
-               numberOfSimulcastStreams == other.numberOfSimulcastStreams &&
-               mode == other.mode;
-    if (ret && codecType == kVideoCodecVP8) {
-      ret &= (codecSpecific.VP8 == other.codecSpecific.VP8);
-    }
-
-    for (unsigned char i = 0; i < other.numberOfSimulcastStreams && ret; ++i) {
-      ret &= (simulcastStream[i] == other.simulcastStream[i]);
-    }
-    return ret;
-  }
-
-  bool operator!=(const VideoCodec& other) const {
-    return !(*this == other);
-  }
+  bool operator==(const VideoCodec& other) const = delete;
+  bool operator!=(const VideoCodec& other) const = delete;
 };
 
 // Bandwidth over-use detector options.  These are used to drive
 // experimentation with bandwidth estimation parameters.
 // See modules/remote_bitrate_estimator/overuse_detector.h
 struct OverUseDetectorOptions {
   OverUseDetectorOptions()
       : initial_slope(8.0/512.0),
         initial_offset(0),
         initial_e(),
@@ skipping 144 matching lines @@
                                    uint32_t ssrc) = 0;
 };
 
 // RTCP mode to use. Compound mode is described by RFC 4585 and reduced-size
 // RTCP mode is described by RFC 5506.
 enum class RtcpMode { kOff, kCompound, kReducedSize };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_COMMON_TYPES_H_