Add an initial revision of an audio server.

services/media/audio/platform/generic/mixers/mixer_utils.h

Index: services/media/audio/platform/generic/mixers/mixer_utils.h
diff --git a/services/media/audio/platform/generic/mixers/mixer_utils.h b/services/media/audio/platform/generic/mixers/mixer_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..1d90199dd4ef4b821f40cd0b159f7f32bbedf957
--- /dev/null
+++ b/services/media/audio/platform/generic/mixers/mixer_utils.h
@@ -0,0 +1,155 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef SERVICES_MEDIA_AUDIO_PLATFORM_GENERIC_MIXERS_MIXER_UTILS_H_
+#define SERVICES_MEDIA_AUDIO_PLATFORM_GENERIC_MIXERS_MIXER_UTILS_H_
+
+namespace mojo {
+namespace media {
+namespace audio {
+namespace mixers {
+namespace utils {
+
+// mixer_utils.h is a collection of inline templated utility functions meant to
+// be used by mixer implementations and expanded/optimized at compile time in
+// order to produce efficient inner mixing loops for all of the different
+// variations of source/destination sample type/channel counts.
+
+// Template to read samples and normalize them into signed 32 bit integers.

[jeffbrown, 2015/11/04 23:43:34]

What you're not saying in this comment is that those signed 32 bit integers
actually contain 16 bit samples.  That was a little surprising to me.

[johngro, 2015/11/06 02:20:26]

because they don't  They contain either signed 16 bit samples or unsigned 8 bit
samples, normalized into signed 32 bit samples.  Someday, this can be extended
to normalize signed/unsigned 24 bit samples, unsigned 16 bit samples, and so on.

The decision for now is to SW scale and mix using 32 math for everything.  As
supported sample formats grow, more specialized mixer implementation will
probably start to show up which deal with more expensive internal
representations of audio (double precision floating point audio anyone?)

+template <typename SType, typename Enable = void> class SampleNormalizer;
+
+template <typename SType>
+class SampleNormalizer<
+      SType,
+      typename std::enable_if<
+        std::is_same<SType, uint8_t>::value,
+      void>::type> {
+ public:
+  static inline int32_t Read(const SType* src) {
+    register SType tmp = static_cast<const SType*>(src)[0];

[jeffbrown, 2015/11/04 23:43:34]

*src instead of src[0]?

I don't see why you need the static cast here given that the argument is already
of the same type.

[johngro, 2015/11/06 02:20:27]

Done.

I think that this is a leftover from an earlier form of this.

+    return (static_cast<int32_t>(tmp) << 8) - 0x8000;
+  }
+};
+
+template <typename SType>
+class SampleNormalizer<
+      SType,
+      typename std::enable_if<
+        std::is_same<SType, int16_t>::value,
+      void>::type> {
+ public:
+  static inline int32_t Read(const SType* src) {
+    return static_cast<int32_t>(static_cast<const SType*>(src)[0]);

[jeffbrown, 2015/11/04 23:43:34]

Why isn't this good enough?  (Of course even the cast is redundant here.)

return static_cast<int32_t>(*src);

[johngro, 2015/11/06 02:20:26]

Done.

it is, see above.  I think this was leftover from some ancient proto form of
this code.

+  }
+};
+
+// Template to read normalized source samples, and combine channels if required.

[jeffbrown, 2015/11/04 23:43:34]

Doesn't this need a downmix matrix in the general case?

[johngro, 2015/11/06 02:20:27]

Absolutely.  Its on the feature list, I'm not sure what form an efficient
implementation will eventually take.  Even the implementation here may be
considered to be wrong in some cases... For example, when going from 2 -> 1
channels, I average the signal.  The proper thing to do may be to add and
saturate, I'm honestly not sure.

When we give down/up-mix matrices a more formal treatment, all of this will need
to be done more rigorously (and compliance tests will need to be
defined/written)

+template <typename SType,
+          size_t   SChCount,
+          size_t   DChCount,
+          typename Enable = void>
+class SrcReader;

[jeffbrown, 2015/11/04 23:43:34]

SrcReader -> SampleReader?

[johngro, 2015/11/06 02:20:26]

its not really a generalized sampler reader, however.  SampleNormalizer is what
fills that role.  This template is specially designed to read one, or both of a
source's input channel, and either combine (downmix) them into 1 channel, or
keep them as independent channels.

IOW - its definition is dependent on the concept of the parameters of both the
source and the destination, and it specifically samples the source and puts it
into a format compatible with the destination.

+
+template <typename SType,
+          size_t   SChCount,
+          size_t   DChCount>
+class SrcReader<SType, SChCount, DChCount,
+      typename std::enable_if<
+        (SChCount == DChCount) ||
+        ((SChCount == 1) && (DChCount == 2)),
+      void>::type> {
+ public:
+  static constexpr size_t DstPerSrc = DChCount / SChCount;
+  static inline int32_t Read(const SType* src) {
+    return SampleNormalizer<SType>::Read(src);
+  }
+};
+
+template <typename SType,
+          size_t   SChCount,
+          size_t   DChCount>
+class SrcReader<SType, SChCount, DChCount,
+      typename std::enable_if<
+        (SChCount == 2) && (DChCount == 1),
+      void>::type> {
+ public:
+  static constexpr size_t DstPerSrc = 1;
+  static inline int32_t Read(const SType* src) {
+    return (SampleNormalizer<SType>::Read(src + 0) +
+            SampleNormalizer<SType>::Read(src + 1)) >> 1;
+  }
+};
+
+// Template to produce destination samples from normalized samples.
+template <typename DType, typename Enable = void> class DstConverter;

[jeffbrown, 2015/11/04 23:43:34]

DstConverter -> SampleWriter?

[johngro, 2015/11/06 02:20:27]

This is not a writer at all.  This is a template which (as the name implies)
converts from a normalized sample (signed 32 bit is what we are using here) to a
destination format (in the case of signed int16, this is a case, in the case of
unsigned 8, this is a shift and offset operation).

+
+template <typename DType>
+class DstConverter<DType,
+      typename std::enable_if<
+        std::is_same<DType, int16_t>::value,
+      void>::type> {
+ public:
+  static inline DType Convert(int32_t sample) {
+    return static_cast<DType>(sample);
+  }
+};
+
+template <typename DType>
+class DstConverter<DType,
+      typename std::enable_if<
+        std::is_same<DType, uint8_t>::value,
+      void>::type> {
+ public:
+  static inline DType Convert(int32_t sample) {
+    return static_cast<DType>((sample >> 8) + 0x80);
+  }
+};
+
+// Template to mix destination samples with normalized source samples based on
+// accumulation policy.
+template <typename DType,
+          bool     DoAccumulate,
+          typename Enable = void>
+class DstMixer;
+
+template <typename DType,
+          bool     DoAccumulate>
+class DstMixer<DType, DoAccumulate,
+      typename std::enable_if<
+        DoAccumulate == false,

[jeffbrown, 2015/11/04 23:43:34]

Instead of testing for DoAccumulate == false maybe have the caller treat
accumulation as a special case, where the initial value of "sample" is
initialized to the normalized destination sample.  Otherwise I don't see what
this particular template is buying you.

[johngro, 2015/11/06 02:20:26]

Bear in mind, the testing here is happening at compile time.  The purpose of
this template is to allow us to produce two versions of the Mix function; one
which reads from the dest, normalizes the sample, sums with the provided sample
and then clips (the next specialization), and this version which becomes a no-op
(just take the provided sample is, don't actually accumulate/mix).

The invocation ends up looking something like...

*dst = DstMixer<DoAccumulate>(dst, sample);

One version becomes the complicated read, normalize, add, threshold,
de-nomrmalize, writeback.  The other becomes de-normalize and write.

So, why the specialization?
Two main reasons.  First, it is the style I am using here.  Style consistency
uber alles!  Second, I could write the following...

if (DoAccumulate) {
  complicated;
} else {
  less_complicated;
}

Since DoAccumulate is compile time constant, any level of optimization should
produce something equivalent to what I have here.  That said, its not a
guarantee (small comfort considering how much we are depending on compiler
optimization here), and -O0 may actually be forced to keep the check
like-it-or-not.

This form removes the ambiguity.  There will be no branch based on DoAccumulate
no matter what.  Its not a huge thing, but whatever.  We are already deep in
template-meta-hell, whats a little more?  :P

+      void>::type> {
+ public:
+  static inline int32_t Mix(const DType* dst, uint32_t sample) {
+    return DstConverter<DType>::Convert(sample);
+  }
+};
+
+template <typename DType,
+          bool     DoAccumulate>
+class DstMixer<DType, DoAccumulate,
+      typename std::enable_if<
+        DoAccumulate == true,
+      void>::type> {
+ public:
+  static inline int32_t Mix(const DType* dst, int32_t sample) {

[jeffbrown, 2015/11/04 23:43:34]

I'll admit to being deeply confused by this function.  It has a parameter call
dst that we are reading from.  Then it converts the summed output into a value
of the destination type and widens it to int32_t.  So the input is normalized
but the output is in the destination space.  Kind of weird...

The clamping seems to be done on a sample-by-sample basis but we should probably
do this at the very end after looping over all samples to be accumulated.

[johngro, 2015/11/06 02:20:27]

See above.

Clamping on a sample by sample basis is not an option here; our output buffer is
of destination sample size.  We would need to have allocated an intermediate
buffer to hold the 32 bit normalized results, and we have not here.

As we start to optimize these mixer, especially to use vector instruction sets
(SSE/Neon) and intermediate buffer is almost certain.  I leave that as an
optimization for the future.

+    sample += SampleNormalizer<DType>::Read(dst);
+
+    if (sample > std::numeric_limits<int16_t>::max()) {
+      return DstConverter<DType>::Convert(std::numeric_limits<int16_t>::max());
+    } else if (sample < std::numeric_limits<int16_t>::min()) {
+      return DstConverter<DType>::Convert(std::numeric_limits<int16_t>::min());
+    } else {
+      return DstConverter<DType>::Convert(sample);
+    }
+  }
+};
+
+
+}  // namespace utils
+}  // namespace mixers
+}  // namespace audio
+}  // namespace media
+}  // namespace mojo
+
+#endif  // SERVICES_MEDIA_AUDIO_PLATFORM_GENERIC_MIXERS_MIXER_UTILS_H_