Audio codec usage statistics

webrtc/modules/audio_coding/codecs/g711/audio_encoder_pcm.h

 /*
  *  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 37 matching lines @@
   EncodedInfo EncodeImpl(uint32_t rtp_timestamp,
                          rtc::ArrayView<const int16_t> audio,
                          rtc::Buffer* encoded) override;
 
   virtual size_t EncodeCall(const int16_t* audio,
                             size_t input_len,
                             uint8_t* encoded) = 0;
 
   virtual size_t BytesPerSample() const = 0;
 
+  // The default implementation returns kOther, which means no name,
+  // other or unknown codec. Used to set EncodedInfoLeaf::encoder_type
+  // in AudioEncoderPcm::EncodeImpl
+  virtual AudioEncoder::CodecType GetCodecType() const;

[kwiberg-webrtc, 2016/05/12 23:30:21]

Again, it's probably much simpler to =0 here and just force all three subclasses
to define the method.

[aleloi, 2016/05/13 09:02:27]

To clarify: you suggest changing this to =0, make pcmA return kPcmA, pcmB return
kPcmB and pcm16b return kOther? 

Why do you think is it much simpler? (It doesn't matter for me, but I'd like to
follow your reasoning).

[kwiberg-webrtc, 2016/05/15 02:06:13]

Exactly.
Because then the value used by each class is specified with that class. It means
you'll have to look in fewer places when reading the code.

Also because overriding an =0 method is a simpler concept than overriding a
method with a default value; instead of "each codec has to say what value it
wants", you get "each codec may optionally say what value it wants, and if it
doesn't, it gets this default value instead".

IOW, I'm lazy, and I don't want to have to think more than necessary when
reading code. (This is a surprisingly useful design principle.)

[aleloi, 2016/05/16 08:02:23]

Done.

+
  private:
   const int sample_rate_hz_;
   const size_t num_channels_;
   const int payload_type_;
   const size_t num_10ms_frames_per_packet_;
   const size_t full_frame_samples_;
   std::vector<int16_t> speech_buffer_;
   uint32_t first_timestamp_in_buffer_;
 };
 
 struct CodecInst;
 
 class AudioEncoderPcmA final : public AudioEncoderPcm {
  public:
   struct Config : public AudioEncoderPcm::Config {
     Config() : AudioEncoderPcm::Config(8) {}
   };
 
   explicit AudioEncoderPcmA(const Config& config)
       : AudioEncoderPcm(config, kSampleRateHz) {}
   explicit AudioEncoderPcmA(const CodecInst& codec_inst);
 
  protected:
   size_t EncodeCall(const int16_t* audio,
                     size_t input_len,
                     uint8_t* encoded) override;
 
   size_t BytesPerSample() const override;
 
+  AudioEncoder::CodecType GetCodecType() const override;
+
  private:
   static const int kSampleRateHz = 8000;
   RTC_DISALLOW_COPY_AND_ASSIGN(AudioEncoderPcmA);
 };
 
 class AudioEncoderPcmU final : public AudioEncoderPcm {
  public:
   struct Config : public AudioEncoderPcm::Config {
     Config() : AudioEncoderPcm::Config(0) {}
   };
 
   explicit AudioEncoderPcmU(const Config& config)
       : AudioEncoderPcm(config, kSampleRateHz) {}
   explicit AudioEncoderPcmU(const CodecInst& codec_inst);
 
  protected:
   size_t EncodeCall(const int16_t* audio,
                     size_t input_len,
                     uint8_t* encoded) override;
 
   size_t BytesPerSample() const override;
 
+  AudioEncoder::CodecType GetCodecType() const override;
+
  private:
   static const int kSampleRateHz = 8000;
   RTC_DISALLOW_COPY_AND_ASSIGN(AudioEncoderPcmU);
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_AUDIO_CODING_CODECS_G711_AUDIO_ENCODER_PCM_H_