Cache the subtype of each DecoderInfo to make the Is* checks quicker.

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 79 matching lines @@
 
     // 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(const SdpAudioFormat& format);
       int sample_rate_hz;
     };
     const rtc::Optional<CngDecoder> cng_decoder_;
+
+    enum class Subtype {
+      kNormal,
+      kComfortNoise,
+      kDtmf,
+      kRed
+    };

[kwiberg-webrtc, 2016/09/30 11:28:24]

Do you have to tell the compiler to store this in an 8-bit number, or do you get
that by default? (Is the answer to that question different for enum and enum
class?)

[ossu, 2016/09/30 11:36:47]

According to a quick look-on-the-internet, enum class defaults to int. I can set
it to be 8 bits, but I'm not sure what would be gained from it. The size of
DecoderInfo (with padding) should remain the same and I'm not sure we'll be able
to access an int8_t any faster in general.

[kwiberg-webrtc, 2016/09/30 11:45:37]

Look at it this way: reading and writing 1 byte is at least as cheap as reading
or writing 4 bytes on hardware that we care about, and unless you start to
really track these things you never know when it'll be an actual space saving.

Your call.

[ossu, 2016/09/30 11:50:34]

Just the other day I was asked to change two uint8_t in Priority to int and now
we want it the other way around? The world is strange and confusing! :(

[kwiberg-webrtc, 2016/09/30 13:05:27]

The reason we prefer int for integers rather than something smaller (or
unsigned) is that less confusing things happen when the range in practice turns
out to be larger than it's supposed to be (e.g. because there's a bug).

For enums, especially enum class, you never do any arithmetic or things like
that, so the problems that we're protecting against by picking a larger type
can't happen.

Or at least that's my interpretation.

[ossu, 2016/09/30 13:45:21]

Alright. I've turned it into an int8_t and a quick comparison run shows a small
(likely statistically insignificant) improvement on my workstation.

[kwiberg-webrtc, 2016/09/30 16:55:00]

Wohoo! That's the best kind of improvement, right?

+
+    static Subtype SubtypeFromFormat(const SdpAudioFormat& format);
+
+    const Subtype subtype_;
   };
 
   // Maximum value for 8 bits, and an invalid RTP payload type (since it is
   // only 7 bits).
   static const uint8_t kRtpPayloadTypeError = 0xFF;
 
   DecoderDatabase(
       const rtc::scoped_refptr<AudioDecoderFactory>& decoder_factory);
 
   virtual ~DecoderDatabase();
@@ skipping 87 matching lines @@
   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_