Stopped using the NetEqDecoder enum internally in NetEq.

webrtc/modules/audio_coding/neteq/decoder_database.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 23 matching lines @@
     kCodecNotSupported = -2,
     kInvalidSampleRate = -3,
     kDecoderExists = -4,
     kDecoderNotFound = -5,
     kInvalidPointer = -6
   };
 
   // Class that stores decoder info in the database.
   class DecoderInfo {
    public:
-    DecoderInfo(
-        NetEqDecoder ct,
-        const std::string& nm,
-        AudioDecoderFactory* factory = nullptr);
-    DecoderInfo(NetEqDecoder ct,
-                const std::string& nm,
-                AudioDecoder* ext_dec);
+    explicit DecoderInfo(const SdpAudioFormat& audio_format,
+                         AudioDecoderFactory* factory = nullptr);
+    explicit DecoderInfo(NetEqDecoder ct,
+                         AudioDecoderFactory* factory = nullptr);
+    DecoderInfo(const SdpAudioFormat& audio_format, AudioDecoder* ext_dec);
     DecoderInfo(DecoderInfo&&);
     ~DecoderInfo();
 
     // Get the AudioDecoder object, creating it first if necessary.
     AudioDecoder* GetDecoder() const;
 
     // Delete the AudioDecoder object, unless it's external. (This means we can
     // always recreate it later if we need it.)
     void DropDecoder() const { decoder_.reset(); }
 
     int SampleRateHz() const {
       const AudioDecoder* decoder = GetDecoder();
       RTC_DCHECK_EQ(1, !!decoder + !!cng_decoder_);
       return decoder ? decoder->SampleRateHz() : cng_decoder_->sample_rate_hz;
     }
 
-    const SdpAudioFormat* GetFormat() const {
-      return audio_format_ ? &*audio_format_ : nullptr;
-    }
+    const SdpAudioFormat& GetFormat() const { return audio_format_; }
 
-    // Returns true if |codec_type| is comfort noise.
+    // Returns true if the decoder's format is comfort noise.
     bool IsComfortNoise() const;
 
-    // Returns true if |codec_type| is DTMF.
+    // Returns true if the decoder's format is DTMF.
     bool IsDtmf() const;
 
-    // Returns true if |codec_type| is RED.
+    // Returns true if the decoder's format is RED.
     bool IsRed() const;
 
-    const NetEqDecoder codec_type;
-    const std::string name;
+    // Returns true if the decoder's format is named |name|.
+    bool IsType(const char* name) const;
+    // Returns true if the decoder's format is named |name|.
+    bool IsType(const std::string& name) const;
+
+    // TODO(ossu): |name| is kept here while we retain the old external decoder
+    //             interface. Remove this once using an AudioDecoderFactory has
+    //             supplanted the old functionality.
+    std::string name;
 
    private:
-    const rtc::Optional<SdpAudioFormat> audio_format_;
-    AudioDecoderFactory* factory_;
+    const SdpAudioFormat audio_format_;
+    AudioDecoderFactory* const factory_;
     mutable std::unique_ptr<AudioDecoder> decoder_;
 
     // Set iff this is an external decoder.
     AudioDecoder* const external_decoder_;
 
     // Set iff this is a comfort noise decoder.
     struct CngDecoder {
-      static rtc::Optional<CngDecoder> Create(NetEqDecoder ct);
+      static rtc::Optional<CngDecoder> Create(const SdpAudioFormat& format);
       int sample_rate_hz;
     };
     const rtc::Optional<CngDecoder> cng_decoder_;
   };
 
   // Maximum value for 8 bits, and an invalid RTP payload type (since it is
   // only 7 bits).
   static const uint8_t kRtpPayloadTypeError = 0xFF;
 
   DecoderDatabase(
@@ skipping 31 matching lines @@
   // Returns kDecoderNotFound or kOK depending on the outcome of the operation.
   virtual int Remove(uint8_t rtp_payload_type);
 
   // Remove all entries.
   virtual void RemoveAll();
 
   // Returns a pointer to the DecoderInfo struct for |rtp_payload_type|. If
   // no decoder is registered with that |rtp_payload_type|, NULL is returned.
   virtual const DecoderInfo* GetDecoderInfo(uint8_t rtp_payload_type) const;
 
-  // Returns one RTP payload type associated with |codec_type|, or
-  // kDecoderNotFound if no entry exists for that value. Note that one
-  // |codec_type| may be registered with several RTP payload types, and the
-  // method may return any of them.
-  virtual uint8_t GetRtpPayloadType(NetEqDecoder codec_type) const;
-
   // Sets the active decoder to be |rtp_payload_type|. If this call results in a
   // change of active decoder, |new_decoder| is set to true. The previous active
   // decoder's AudioDecoder object is deleted.
   virtual int SetActiveDecoder(uint8_t rtp_payload_type, bool* new_decoder);
 
   // Returns the current active decoder, or NULL if no active decoder exists.
   virtual AudioDecoder* GetActiveDecoder() const;
 
   // Sets the active comfort noise decoder to be |rtp_payload_type|. If this
   // call results in a change of active comfort noise decoder, the previous
   // active decoder's AudioDecoder object is deleted.
   virtual int SetActiveCngDecoder(uint8_t rtp_payload_type);
 
   // Returns the current active comfort noise decoder, or NULL if no active
   // comfort noise decoder exists.
   virtual ComfortNoiseDecoder* GetActiveCngDecoder() const;
 
   // The following are utility methods: they will look up DecoderInfo through
   // GetDecoderInfo and call the respective method on that info object, if it
   // exists.
 
   // Returns a pointer to the AudioDecoder object associated with
   // |rtp_payload_type|, or NULL if none is registered. If the AudioDecoder
   // object does not exist for that decoder, the object is created.
   AudioDecoder* GetDecoder(uint8_t rtp_payload_type) const;
 
-  // Returns true if |rtp_payload_type| is registered as a |codec_type|.
-  bool IsType(uint8_t rtp_payload_type, NetEqDecoder codec_type) const;
+  // Returns if |rtp_payload_type| is registered with a format named |name|.
+  bool IsType(uint8_t rtp_payload_type, const char* name) const;
+
+  // Returns if |rtp_payload_type| is registered with a format named |name|.
+  bool IsType(uint8_t rtp_payload_type, const std::string& name) const;
 
   // Returns true if |rtp_payload_type| is registered as comfort noise.
   bool IsComfortNoise(uint8_t rtp_payload_type) const;
 
   // Returns true if |rtp_payload_type| is registered as DTMF.
   bool IsDtmf(uint8_t rtp_payload_type) const;
 
   // Returns true if |rtp_payload_type| is registered as RED.
   bool IsRed(uint8_t rtp_payload_type) const;
 
   // Returns kOK if all packets in |packet_list| carry payload types that are
   // registered in the database. Otherwise, returns kDecoderNotFound.
   int CheckPayloadTypes(const PacketList& packet_list) const;
 
  private:
   typedef std::map<uint8_t, DecoderInfo> DecoderMap;
 
   DecoderMap decoders_;
   int active_decoder_type_;
   int active_cng_decoder_type_;
   mutable std::unique_ptr<ComfortNoiseDecoder> active_cng_decoder_;
   rtc::scoped_refptr<AudioDecoderFactory> decoder_factory_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(DecoderDatabase);
 };
 
 }  // namespace webrtc
 #endif  // WEBRTC_MODULES_AUDIO_CODING_NETEQ_DECODER_DATABASE_H_