Audio codec usage statistics

webrtc/modules/audio_coding/codecs/audio_encoder.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.
  */
 
 #include "webrtc/modules/audio_coding/codecs/audio_encoder.h"
 
+#include <cstring>
+
 #include "webrtc/base/checks.h"
 #include "webrtc/base/trace_event.h"
+#include "webrtc/system_wrappers/include/metrics.h"
 
 namespace webrtc {
 
+namespace {
+
+constexpr int kAudioMax = 64;

[hlundin-webrtc, 2016/05/11 13:03:55]

The name kAudioMax is a bit too generic. Can you come up with something that
describes what it is used for. And, now that we don't have the enum any longer,
this constant is not enforced. Can you come up with some way to enforce it,
maybe using a static_assert?

[aleloi, 2016/05/11 14:05:56]

I renamed it into kMaxCodecNames.

Re static_assert for the histogram boundary: here is a (complex and ugly)
solution:

// Ensures that every element of passed array har .id field less that
// kMaxCodecNames
template<int N>
constexpr bool idSLessThanMaxCodecNames(const CodecNameIDPair (&array) [N],
size_t index) {
  return (index >= N) ||
    (array[index].id < kMaxCodecNames && idSLessThanMaxCodecNames(array, index +
1));
}

static_assert(histogram_id, idSLessThanMaxCodecNames(0),
              "Cannot guarantee that codec ID does not exceed boundary.");

I'm not sure my solution a good idea though. Code has to be refactored for it to
work: 
  * the type CodecNameIDPair must be visible to the constexpr function
  * it is a very complex way (with constexprs and templates) to make sure that
every number in a constexpr array is smaller than 64

The first point could possibly be mitigated by making idSLessThanMaxCodecNames
into a lambda-function inside of CodecNameToHistogramCodecType, but I'm not sure
if it can be constexpr then.

+
+// Translates the name of a codec returned by GetCodecName() into
+// one of the codec IDs in the table 'histogram_id' below.
+size_t CodecNameToHistogramCodecType(const char* codec_name) {
+  const std::pair<const char*, size_t> histogram_id[] = {
+    {"Opus", 1},
+    {"iSAC", 2},
+    {"g711", 3},
+    {"g722", 4},
+    {"iLBC", 5}
+  };
+  for (const auto & codec : histogram_id)

[hlundin-webrtc, 2016/05/11 13:03:55]

I think I'll prefer braces on the for loop. Omitting them on the if statement is
fine.

[aleloi, 2016/05/11 14:10:49]

Done.

+    if (codec_name != NULL && strcmp(codec.first, codec_name) == 0)

[hlundin-webrtc, 2016/05/11 13:03:55]

nullptr

[hlundin-webrtc, 2016/05/11 13:03:55]

nullptr

[aleloi, 2016/05/11 14:10:49]

Done.

+      return codec.second;
+  return 0;
+}
+
+// Adds a codec usage sample to the histogram.
+void UpdateCodecTypeHistogram(const char* codec_name) {
+  RTC_HISTOGRAM_ENUMERATION("WebRTC.Audio.Encoder.CodecType",
+                            CodecNameToHistogramCodecType(codec_name),
+                            kAudioMax);
+}
+
+}  // namespace
+
 AudioEncoder::EncodedInfo::EncodedInfo() = default;
 AudioEncoder::EncodedInfo::EncodedInfo(const EncodedInfo&) = default;
 AudioEncoder::EncodedInfo::EncodedInfo(EncodedInfo&&) = default;
 AudioEncoder::EncodedInfo::~EncodedInfo() = default;
 AudioEncoder::EncodedInfo& AudioEncoder::EncodedInfo::operator=(
     const EncodedInfo&) = default;
 AudioEncoder::EncodedInfo& AudioEncoder::EncodedInfo::operator=(EncodedInfo&&) =
     default;
 
+AudioEncoder::AudioEncoder() {
+  encoded_packets = 0;
+}
+
 int AudioEncoder::RtpTimestampRateHz() const {
   return SampleRateHz();
 }
 
 AudioEncoder::EncodedInfo AudioEncoder::Encode(
     uint32_t rtp_timestamp,
     rtc::ArrayView<const int16_t> audio,
     rtc::Buffer* encoded) {
   TRACE_EVENT0("webrtc", "AudioEncoder::Encode");
   RTC_CHECK_EQ(audio.size(),
                static_cast<size_t>(NumChannels() * SampleRateHz() / 100));
 
+  encoded_packets++;
+  if (encoded_packets % 500 == 0) {
+    encoded_packets = 0;
+    UpdateCodecTypeHistogram(GetCodecName());
+  }
+
   const size_t old_size = encoded->size();
   EncodedInfo info = EncodeImpl(rtp_timestamp, audio, encoded);
   RTC_CHECK_EQ(encoded->size() - old_size, info.encoded_bytes);
   return info;
 }
 
 bool AudioEncoder::SetFec(bool enable) {
   return !enable;
 }
 
 bool AudioEncoder::SetDtx(bool enable) {
   return !enable;
 }
 
 bool AudioEncoder::SetApplication(Application application) {
   return false;
 }
 
 void AudioEncoder::SetMaxPlaybackRate(int frequency_hz) {}
 
 void AudioEncoder::SetProjectedPacketLossRate(double fraction) {}
 
 void AudioEncoder::SetTargetBitrate(int target_bps) {}
 
+const char* AudioEncoder::GetCodecName() const {
+  return nullptr;
+}
+
 size_t AudioEncoder::MaxEncodedBytes() const {
   RTC_CHECK(false);
   return 0;
 }
-
 }  // namespace webrtc