Surround Sound handling by folding 5 channels down to stereo.

media/audio/win/waveout_output_win.cc

 // Copyright (c) 2006-2008 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.
 
 #include <windows.h>
 #include <mmsystem.h>
 #pragma comment(lib, "winmm.lib")
 
 #include "media/audio/win/waveout_output_win.h"
 
@@ skipping 11 matching lines @@
 //   thus it forces you to maintain state, which naturally is not exactly
 //   synchronized to the actual device state.
 // - Some functions, like waveOutReset cannot be called in the callback thread
 //   or called in any random state because they deadlock. This results in a
 //   non- instantaneous Stop() method. waveOutPrepareHeader seems to be in the
 //   same boat.
 // - waveOutReset() will forcefully kill the _waveThread so it is important
 //   to make sure we are not executing inside the audio source's OnMoreData()
 //   or that we take locks inside WaveCallback() or QueueNextPacket().
 
+// Enable or disable software folding
+#define FOLDING 1
+
 namespace {
 
 // We settled for a double buffering scheme. It seems to strike a good balance
 // between how fast data needs to be provided versus memory usage.
 const size_t kNumBuffers = 2;
 
 // Sixty four MB is the maximum buffer size per AudioOutputStream.
 const size_t kMaxOpenBufferSize = 1024 * 1024 * 64;
 
 // Our sound buffers are allocated once and kept in a linked list using the
 // the WAVEHDR::dwUser variable. The last buffer points to the first buffer.
 WAVEHDR* GetNextBuffer(WAVEHDR* current) {
   return reinterpret_cast<WAVEHDR*>(current->dwUser);
 }
 
 }  // namespace
 
 PCMWaveOutAudioOutputStream::PCMWaveOutAudioOutputStream(
     AudioManagerWin* manager, int channels, int sampling_rate,
     char bits_per_sample, UINT device_id)
     : state_(PCMA_BRAND_NEW),
       manager_(manager),
       device_id_(device_id),
       waveout_(NULL),
       callback_(NULL),
       buffer_(NULL),
       buffer_size_(0),
-      volume_(1) {
+      volume_(1),
+      channels_(channels) {
   format_.wFormatTag = WAVE_FORMAT_PCM;
+#ifdef FOLDING
+  format_.nChannels = channels > 2 ? 2 : channels;
+#else
   format_.nChannels = channels;
+#endif
   format_.nSamplesPerSec = sampling_rate;
   format_.wBitsPerSample = bits_per_sample;
   format_.cbSize = 0;
   // The next are computed from above.
   format_.nBlockAlign = (format_.nChannels * format_.wBitsPerSample) / 8;
   format_.nAvgBytesPerSec = format_.nBlockAlign * format_.nSamplesPerSec;
   // The event is auto-reset.
   stopped_event_.Set(::CreateEventW(NULL, FALSE, FALSE, NULL));
 }
 
@@ skipping 147 matching lines @@
   DLOG(WARNING) << "PCMWaveOutAudio error " << error;
   callback_->OnError(this, error);
 }
 
 void PCMWaveOutAudioOutputStream::QueueNextPacket(WAVEHDR *buffer) {
   // Call the source which will fill our buffer with pleasant sounds and
   // return to us how many bytes were used.
   // TODO(fbarchard): Handle used 0 by queueing more.
   size_t used = callback_->OnMoreData(this, buffer->lpData, buffer_size_);
   if (used <= buffer_size_) {
-    buffer->dwBufferLength = used;
-    media::AdjustVolume(buffer->lpData, buffer->dwBufferLength,
-                        format_.nChannels, format_.wBitsPerSample >> 3,
-                        volume_);
+    buffer->dwBufferLength = used * format_.nChannels / channels_;
+    if (channels_ > 2 && format_.nChannels == 2) {
+      media::FoldChannels(buffer->lpData, used,
+                          channels_, format_.wBitsPerSample >> 3,
+                          volume_);
+    } else {
+      media::AdjustVolume(buffer->lpData, used,
+                          format_.nChannels, format_.wBitsPerSample >> 3,
+                          volume_);
+    }
+
   } else {
     HandleError(0);
     return;
   }
   buffer->dwFlags = WHDR_PREPARED;
 }
 
 // Windows call us back in this function when some events happen. Most notably
 // when it is done playing a buffer. Since we use double buffering it is
 // convenient to think of |buffer| as free and GetNextBuffer(buffer) as in
@@ skipping 28 matching lines @@
     if (result != MMSYSERR_NOERROR)
       obj->HandleError(result);
 
   } else if (msg == WOM_CLOSE) {
     // We can be closed before calling Start, so it is possible to have a
     // null callback at this point.
     if (obj->callback_)
       obj->callback_->OnClose(obj);
   }
 }