Delete AudioOutputMixer.

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 52 matching lines @@
 template<class Format, class Fixed, int bias>
 static void AdjustVolume(Format* buf_out,
                          int sample_count,
                          int fixed_volume) {
   for (int i = 0; i < sample_count; ++i) {
     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 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);
-}
-
 // AdjustVolume() does an in place audio sample change.
 bool AdjustVolume(void* buf,
                   size_t buflen,
                   int channels,
                   int bytes_per_sample,
                   float volume) {
   DCHECK(buf);
   if (volume < 0.0f || volume > 1.0f)
     return false;
   if (volume == 1.0f) {
@@ skipping 18 matching lines @@
     } else if (bytes_per_sample == 4) {
       AdjustVolume<int32, int64, 0>(reinterpret_cast<int32*>(buf),
                                     sample_count,
                                     fixed_volume);
       return true;
     }
   }
   return false;
 }
 
-// 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) {
-  if (volume == 0.0f)
-    return;
-  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);
-    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_GE(volume, 0.0f);
-  DCHECK_LE(volume, 1.0f);
-  switch (bytes_per_sample) {
-    case 1:
-      MixStreams<uint8, int32, kint8min, kint8max, 128>(
-          static_cast<uint8*>(dst),
-          static_cast<uint8*>(src),
-          buflen,
-          volume);
-      break;
-    case 2:
-      DCHECK_EQ(0u, buflen % 2);
-      MixStreams<int16, int32, kint16min, kint16max, 0>(
-          static_cast<int16*>(dst),
-          static_cast<int16*>(src),
-          buflen / 2,
-          volume);
-      break;
-    case 4:
-      DCHECK_EQ(0u, buflen % 4);
-      MixStreams<int32, int64, kint32min, kint32max, 0>(
-          static_cast<int32*>(dst),
-          static_cast<int32*>(src),
-          buflen / 4,
-          volume);
-      break;
-    default:
-      NOTREACHED() << "Illegal bytes per sample";
-      break;
-  }
-}
-
 int 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 (!CoreAudioUtil::IsSupported()) {
     // Fall back to Windows Wave implementation on Windows XP or lower
     // and use 48kHz as default input sample rate.
     return 48000;
   }
@@ skipping 175 matching lines @@
   //    out performance was degraded compared to XP.
   //  - The regression was fixed in Windows 7 and most configurations will work
   //    with 2, but some (e.g., some Sound Blasters) still need 3.
   //  - Some XP configurations (even multi-processor ones) also need 3.
   return (base::win::GetVersion() == base::win::VERSION_VISTA) ? 4 : 3;
 }
 
 #endif
 
 }  // namespace media