Adds support for multi-channel output audio for the low-latency path in Windows.

media/audio/win/audio_low_latency_output_win.h

 // 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.
 //
 // Implementation of AudioOutputStream for Windows using Windows Core Audio
 // WASAPI for low latency rendering.
 //
 // Overview of operation and performance:
 //
 // - An object of WASAPIAudioOutputStream is created by the AudioManager
@@ skipping 164 matching lines @@
   virtual ~WASAPIAudioOutputStream();
 
   // Implementation of AudioOutputStream.
   virtual bool Open() OVERRIDE;
   virtual void Start(AudioSourceCallback* callback) OVERRIDE;
   virtual void Stop() OVERRIDE;
   virtual void Close() OVERRIDE;
   virtual void SetVolume(double volume) OVERRIDE;
   virtual void GetVolume(double* volume) OVERRIDE;
 
-  // Retrieves the stream format that the audio engine uses for its internal
-  // processing/mixing of shared-mode streams.
-  // This method should not be used in combination with exclusive-mode streams.
+  // Retrieves the number of channels the audio engine uses for its internal
+  // processing/mixing of shared-mode streams for the default endpoint device.
+  static int HardwareChannelCount();
+
+  // Retrieves the channel layout the audio engine uses for its internal
+  // processing/mixing of shared-mode streams for the default endpoint device.
+  // Note that we convert an internal channel layout mask (see ChannelMask())
+  // into a Chrome-specific channel layout enumerator in this method, hence
+  // the match might not be perfect.
+  static ChannelLayout HardwareChannelLayout();
+
+  // Retrieves the sample rate the audio engine uses for its internal
+  // processing/mixing of shared-mode streams for the default endpoint device.
   static int HardwareSampleRate(ERole device_role);
 
   // Returns AUDCLNT_SHAREMODE_EXCLUSIVE if --enable-exclusive-mode is used
   // as command-line flag and AUDCLNT_SHAREMODE_SHARED otherwise (default).
   static AUDCLNT_SHAREMODE GetShareMode();
 
   bool started() const { return started_; }
 
  private:
   // Implementation of IUnknown (trivial in this case). See
@@ skipping 32 matching lines @@
 
   // Issues the OnError() callback to the |sink_|.
   void HandleError(HRESULT err);
 
   // The Open() method is divided into these sub methods.
   HRESULT SetRenderDevice();
   HRESULT ActivateRenderDevice();
   bool DesiredFormatIsSupported();
   HRESULT InitializeAudioEngine();
 
+  // Retrieves the stream format that the audio engine uses for its internal
+  // processing/mixing of shared-mode streams.
+  static HRESULT GetMixFormat(ERole device_role, WAVEFORMATEX** device_format);

[scherkus (not reviewing), 2012/08/01 00:14:05]

any reason static private methods need to be here?

if they don't need to access private/protected members of this class then they
should all be moved into the .cc

sames goes w/ ChannelConfig() and ChannelConfigToChromeChannelLayout()

[henrika (OOO until Aug 14), 2012/08/01 16:11:09]

Great input, thanks. I actually did use private members here before but no
longer. Will fix.

Question: comments; do they go above the function definition or "inside" (first
line below def.)?

[scherkus (not reviewing), 2012/08/02 00:41:57]

Above the function.

+
   // Called when the device will be opened in shared mode and use the
   // internal audio engine's mix format.
   HRESULT SharedModeInitialization();
 
   // Called when the device will be opened in exclusive mode and use the
   // application specified format.
   HRESULT ExclusiveModeInitialization();
 
   // Converts unique endpoint ID to user-friendly device name.
   std::string GetDeviceName(LPCWSTR device_id) const;
 
   // Called on the audio render thread when the current audio stream must
   // be re-initialized because the default audio device has changed. This
   // method: stops the current renderer, releases and re-creates all WASAPI
   // interfaces, creates a new IMMDevice and re-starts rendering using the
   // new default audio device.
   bool RestartRenderingUsingNewDefaultDevice();
 
+  // Retrieves an integer mask which corresponds to the channel layout the
+  // audio engine uses for its internal processing/mixing of shared-mode
+  // streams. This mask indicates which channels are present in the multi-
+  // channel stream. The least significant bit corresponds with the Front Left
+  // speaker, the next least significant bit corresponds to the Front Right
+  // speaker, and so on, continuing in the order defined in KsMedia.h.
+  // See http://msdn.microsoft.com/en-us/library/windows/hardware/ff537083(v=vs.85).aspx
+  // for more details.
+  static uint32 ChannelConfig();

[tommi (sloooow) - chröme, 2012/07/31 21:39:30]

Maybe we could define our own type for channel config to avoid mixing it up with
other ints.  e.g.
typedef uint32 ChannelConfig;
Down the line, we could then upgrade that typedef to a class that takes care of
all the bit manipulation code as it starts to spread.

[henrika (OOO until Aug 14), 2012/08/01 16:11:09]

Added typedef ChannelConfigMask in media. Got conflict if I used ChannelConfig
(same as ChannelConfig()).

+
+  // Converts Microsoft's channel configuration to Chrome's ChannelLayout.
+  // This mapping is not perfect but the best we can do given the current
+  // ChannelLayout enumerator and the Windows-specific speaker configurations
+  // defined in ksmedia.h. Don't assume that the channel ordering in
+  // ChannelLayout is exactly the same as the Windows specific configuration.
+  // As an example: KSAUDIO_SPEAKER_7POINT1_SURROUND is mapped to
+  // CHANNEL_LAYOUT_7_1 but the positions of Back L, Back R and Side L, Side R
+  // speakers are different in these two definitions.
+  static ChannelLayout ChannelConfigToChromeChannelLayout(uint32 layout);
+
   AUDCLNT_SHAREMODE share_mode() const { return share_mode_; }
+  int endpoint_channel_count() const { return endpoint_channel_count_; }

[scherkus (not reviewing), 2012/08/01 00:14:05]

huh? these are all private methods -- why the accessors instead of accessing the
variables directly?

also I think we can compute these values as opposed to storing additional data
-- see my notes in the .cc

[henrika (OOO until Aug 14), 2012/08/01 16:11:09]

Got it. Will clean up.

+  uint32 endpoint_channel_config() const { return endpoint_channel_config_; }
+  int client_channel_count() const { 
+    return client_audio_parameters_.channels();
+  }
 
   // Initializes the COM library for use by the calling thread and sets the
   // thread's concurrency model to multi-threaded.
   base::win::ScopedCOMInitializer com_init_;
 
   // Contains the thread ID of the creating thread.
   base::PlatformThreadId creating_thread_id_;
 
   // Our creator, the audio manager needs to be notified when we close.
   AudioManagerWin* manager_;
 
+  AudioParameters client_audio_parameters_;

[tommi (sloooow) - chröme, 2012/07/31 21:39:30]

are there any other audio parameters that this class needs to worry about? 
(just wondering about the 'client_' qualifier)

[henrika (OOO until Aug 14), 2012/08/01 16:11:09]

I store this one to keep track of the parameters set by the user at
construction. It helps me detect if there is any difference between the #input
channels and the #native channels. Might be overkill to store the complete
class.

+
   // Rendering is driven by this thread (which has no message loop).
   // All OnMoreData() callbacks will be called from this thread.
   base::DelegateSimpleThread* render_thread_;
 
   // Contains the desired audio format which is set up at construction.
-  WAVEFORMATEX format_;
+  // Extended PCM waveform format structure based on WAVEFORMATEXTENSIBLE.
+  // Use this for multiple channel and hi-resolution PCM data.
+  WAVEFORMATPCMEX format_;
 
   // Copy of the audio format which we know the audio engine supports.
   // It is recommended to ensure that the sample rate in |format_| is identical
   // to the sample rate in |audio_engine_mix_format_|.
-  base::win::ScopedCoMem<WAVEFORMATEX> audio_engine_mix_format_;
+  base::win::ScopedCoMem<WAVEFORMATPCMEX> audio_engine_mix_format_;
 
   bool opened_;
   bool started_;
 
   // Set to true as soon as a new default device is detected, and cleared when
   // the streaming has switched from using the old device to the new device.
   // All additional device detections during an active state are ignored to
   // ensure that the ongoing switch can finalize without disruptions.
   bool restart_rendering_mode_;
 
@@ skipping 18 matching lines @@
   size_t endpoint_buffer_size_frames_;
 
   // Defines the role that the system has assigned to an audio endpoint device.
   ERole device_role_;
 
   // The sharing mode for the connection.
   // Valid values are AUDCLNT_SHAREMODE_SHARED and AUDCLNT_SHAREMODE_EXCLUSIVE
   // where AUDCLNT_SHAREMODE_SHARED is the default.
   AUDCLNT_SHAREMODE share_mode_;
 
+  // Contains the number of channels the audio engine uses for its internal
+  // processing/mixing of shared-mode streams for the default endpoint device.
+  const int endpoint_channel_count_;
+
+  // Contains the channel configuration the audio engine uses for its internal
+  // processing/mixing of shared-mode streams for the default endpoint
+  // device.
+  const uint32 endpoint_channel_config_;
+
+  // TODO(henrika): add comments....
+  int channel_factor_;
+
   // Counts the number of audio frames written to the endpoint buffer.
   UINT64 num_written_frames_;
 
   // Pointer to the client that will deliver audio samples to be played out.
   AudioSourceCallback* source_;
 
   // An IMMDeviceEnumerator interface which represents a device enumerator.
   base::win::ScopedComPtr<IMMDeviceEnumerator> device_enumerator_;
 
   // An IMMDevice interface which represents an audio endpoint device.
@@ skipping 16 matching lines @@
 
   // This event will be signaled when stream switching shall take place.
   base::win::ScopedHandle stream_switch_event_;
 
   DISALLOW_COPY_AND_ASSIGN(WASAPIAudioOutputStream);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_AUDIO_WIN_AUDIO_LOW_LATENCY_OUTPUT_WIN_H_