Add software audio mixing to the audio utils.

media/audio/audio_util.cc

 // Copyright (c) 2012 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.
 
 // Software adjust volume of samples, allows each audio stream its own
 // volume without impacting master volume for chrome and other applications.
 
 // Implemented as templates to allow 8, 16 and 32 bit implementations.
 // 8 bit is unsigned and biased by 128.
 
@@ skipping 39 matching lines @@
     buf_out[i] = static_cast<Format>(ScaleChannel<Fixed>(buf_out[i] - bias,
                                                          fixed_volume) + bias);
   }
 }
 
 static const int kChannel_L = 0;
 static const int kChannel_R = 1;
 static const int kChannel_C = 2;
 
 template<class Fixed, int min_value, int max_value>
-static int AddChannel(int val, int adder) {
+static int AddSaturated(int val, int adder) {
   Fixed sum = static_cast<Fixed>(val) + static_cast<Fixed>(adder);
   if (sum > max_value)
     return max_value;
   if (sum < min_value)
     return min_value;
   return static_cast<int>(sum);
 }
 
 // FoldChannels() downmixes multichannel (ie 5.1 Surround Sound) to Stereo.
 // Left and Right channels are preserved asis, and Center channel is
@@ skipping 15 matching lines @@
   for (int i = 0; i < sample_count; ++i) {
     int center = static_cast<int>(buf_in[kChannel_C] - bias);
     int left = static_cast<int>(buf_in[kChannel_L] - bias);
     int right = static_cast<int>(buf_in[kChannel_R] - bias);
 
     center = ScaleChannel<Fixed>(center, center_volume);
     left = ScaleChannel<Fixed>(left, fixed_volume);
     right = ScaleChannel<Fixed>(right, fixed_volume);
 
     buf_out[0] = static_cast<Format>(
-        AddChannel<Fixed, min_value, max_value>(left, center) + bias);
+        AddSaturated<Fixed, min_value, max_value>(left, center) + bias);
     buf_out[1] = static_cast<Format>(
-        AddChannel<Fixed, min_value, max_value>(right, center) + bias);
+        AddSaturated<Fixed, min_value, max_value>(right, center) + bias);
 
     buf_out += 2;
     buf_in += channels;
   }
 }
 
 // AdjustVolume() does an in place audio sample change.
 bool AdjustVolume(void* buf,
                   size_t buflen,
                   int channels,
@@ skipping 125 matching lines @@
       if (sample < -32768.0)
         sample = -32768.0;
       else if (sample > 32767.0)
         sample = 32767.0;
 
       destination[j * channels + i] = static_cast<int16>(sample);
     }
   }
 }
 
+// TODO(enal): use template specialization and size-specific intrinsics.
+//             Call is on the time-critical path, and by using SSE/AVX
+//             instructions we can speed things up by ~4-8x, more for the case
+//             when we have to adjust volume as well.
+template<class Format, class Fixed, int min_value, int max_value, int bias>
+static void MixStreams(Format* dst, Format* src, int count, float volume) {

[vrk (LEFT CHROMIUM), 2012/03/20 00:27:54]

Return early for muted src?

if (volume == 0.0f)
  return;

+  if (volume == 1.0f) {

[vrk (LEFT CHROMIUM), 2012/03/20 00:27:54]

nit: It's cleaner/more concise if you push the if into the loop instead of vice
versa, e.g.

for (int i = 0; i < count; ++i) {
  Fixed src = src[i] - bias;
  if (volume != 1.0f) {
    // General case -- have to adjust volume before mixing.
    const int fixed_volume = static_cast<int>(volume * 65536);
    src = ScaleChannel<Fixed>(src, fixed_volume);
  }
  Fixed value = AddSaturated<Fixed, min_value, max_value>(dst[i] - bias, src);
  dst[i] = static_cast<Format>(value + bias);
}

+    // Most common case -- no need to adjust volume.
+    for (int i = 0; i < count; ++i) {
+      Fixed value = AddSaturated<Fixed, min_value, max_value>(dst[i] - bias,
+                                                              src[i] - bias);
+      dst[i] = static_cast<Format>(value + bias);
+    }
+  } else {
+    // General case -- have to adjust volume before mixing.
+    const int fixed_volume = static_cast<int>(volume * 65536);
+    for (int i = 0; i < count; ++i) {
+      Fixed adjusted_src = ScaleChannel<Fixed>(src[i] - bias, fixed_volume);
+      Fixed value = AddSaturated<Fixed, min_value, max_value>(dst[i] - bias,
+                                                              adjusted_src);
+      dst[i] = static_cast<Format>(value + bias);
+    }
+  }
+}
+
+void MixStreams(void* dst,
+                void* src,
+                size_t buflen,
+                int bytes_per_sample,
+                float volume) {
+  DCHECK(dst);
+  DCHECK(src);
+  DCHECK(volume >= 0.0f && volume <= 1.0f);

[vrk (LEFT CHROMIUM), 2012/03/20 00:27:54]

nit: two separate DCHECKs, DCHECK_GE(volume, 0.0f) and DCHECK_LE(volume, 1.0f)

(code-wise, I think what you did looks nicer, but doing DCHECK_LE/GE gives more
helpful messages if things fail!)

+  switch (bytes_per_sample) {
+    case 1:
+      MixStreams<uint8, int32, -128, 127, 128>(static_cast<uint8*>(dst),
+                                               static_cast<uint8*>(src),
+                                               buflen,
+                                               volume);
+      break;
+    case 2:
+      DCHECK_EQ(0u, buflen % 2);
+      MixStreams<int16, int32, -32768, 32767, 0>(static_cast<int16*>(dst),
+                                                 static_cast<int16*>(src),
+                                                 buflen / 2,
+                                                 volume);
+      break;
+    case 4:
+      DCHECK_EQ(0u, buflen % 4);
+      MixStreams<int32, int64, 0x80000000, 0x7fffffff, 0>(
+          static_cast<int32*>(dst),
+          static_cast<int32*>(src),
+          buflen / 4,
+          volume);
+      break;
+    default:
+      NOTREACHED() << "Illegal bytes per sample";
+      break;
+  }
+}
+
 double GetAudioHardwareSampleRate() {
 #if defined(OS_MACOSX)
     // Hardware sample-rate on the Mac can be configured, so we must query.
     return AUAudioOutputStream::HardwareSampleRate();
 #elif defined(OS_WIN)
   if (!IsWASAPISupported()) {
     // Fall back to Windows Wave implementation on Windows XP or lower
     // and use 48kHz as default input sample rate.
     return 48000.0;
   }
@@ skipping 127 matching lines @@
 
 bool IsWASAPISupported() {
   // Note: that function correctly returns that Windows Server 2003 does not
   // support WASAPI.
   return base::win::GetVersion() >= base::win::VERSION_VISTA;
 }
 
 #endif
 
 }  // namespace media