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 specialization and intrinsics.

[vrk (LEFT CHROMIUM), 2012/03/12 18:40:24]

What sort of specialization? Are intrinsics really necessary?

[enal1, 2012/03/12 21:20:53]

Updated comment.

+template<class Format, class Fixed, int min_value, int max_value, int bias>
+static void MixStreams(Format* dst, Format* src, int count, float volume) {
+  if (volume == 1.0f) {
+    // 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);

[vrk (LEFT CHROMIUM), 2012/03/12 18:40:24]

why 65536/maxval of uint16?

[enal1, 2012/03/12 21:20:53]

We are replacing FP multiplication by integer one. I.e. instead of x*volume,
where volume in range 0..1, we have x*(volume * 65536) / 65536.

Standard trick used in lot of codecs. See use of fixed_volume in ScaleChannel()
and similar calculation in AdjustVOlume(), line 122.

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

OK... well, it's not code that you wrote, but it'd be nice if ScaleChannel()
took the raw float volume as a parameter, then did the "volume * 65536" in the
ScaleChannel() implementation. Up to you if you want to make that change, since
I see that FoldChannels() does something different for the center channel.

+    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);
+  switch (bytes_per_sample) {
+    case 1:
+      MixStreams<uint8, int32, -128, 127, 128>(static_cast<uint8*>(dst),

[vrk (LEFT CHROMIUM), 2012/03/12 18:40:24]

Why is the bias 128 here and 0 elsewhere?

[enal1, 2012/03/12 21:20:53]

Because we have "unsigned char" for 8 bits and "signed short/int" for 16/32
bits. I did not invent it, see similar usage through the file...

[enal1, 2012/03/12 21:20:53]

Because we have "unsigned char" for 8 bits and "signed short/int" for 16/32
bits. I did not invent it, see similar usage through the file...

+                                               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