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

media/audio/win/audio_low_latency_output_win.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.
 
 #include "media/audio/win/audio_low_latency_output_win.h"
 
 #include <Functiondiscoverykeys_devpkey.h>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "media/audio/audio_util.h"
 #include "media/audio/win/audio_manager_win.h"
 #include "media/audio/win/avrt_wrapper_win.h"
 #include "media/base/media_switches.h"
 
 using base::win::ScopedComPtr;
 using base::win::ScopedCOMInitializer;
 using base::win::ScopedCoMem;
 
 namespace media {
 
+bool ChannelUpMix(void* input,

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

I guess this will accept in/out layout parameters as well?

+                  void* output,
+                  int in_channels,
+                  int out_channels,
+                  size_t number_of_input_bytes) {
+  DCHECK(input);
+  DCHECK(output);
+  DCHECK_GT(out_channels, in_channels);
+
+  // TODO(henrika): we only support 16-bit samples currently.
+  int16* in16 = static_cast<int16*>(input);

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

reinterpret_cast

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

Done.

+  int16* out16 = static_cast<int16*>(output);
+
+  if (in_channels == 2) {

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

and here check for in_layout == STEREO?

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

see comment below

+    int number_of_input_stereo_samples = (number_of_input_bytes >> 2);
+    // 2 -> N.1 up-mixing where N=out_channels-1.
+    // See http://www.w3.org/TR/webaudio/#UpMix-sub for details.
+    for (int i = 0; i < number_of_input_stereo_samples; i++) {

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

++i

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

as discussed offline, when it comes time to do this in place (to reduce number
of memory allocations), we can process the samples in reverse order when
sizeof(out) > sizeof(in) (upmixing).

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

Done.

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

Will add a TODO() on that one for now.

+      // Copy Front Left and Front Right channels as is.

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

I know this is just a start, so if I may make a suggestion, it would be nice and
make the code simpler and easy to read if we have structs for each layout. 
Something like: 

(structs like this might possibly need to be inside a #pragma pack(1))

struct LayoutStereo_16bit {
  int16 left;
  int16 right;
};

struct Layout7_1_16bit {
  int16 front_left;
  int16 front_right;
  ...(remaining channels here)...
};

bool ChannelUpMix(...) {
  ...
  if (in_layout == STEREO && out_layout == 7_1) {
    LayoutStereo_16bit* in = reinterpret_cast<LayoutStereo_16bit*>(input);
    Layout7_1_16bit* out = reinterpret_cast<Layout7_1_16bit*>(output);
    // zero out all frames first.
    memset(out, 0, number_of_input_stereo_samples * sizeof(out[0]));
    for (int i = 0; i < number_of_input_stereo_samples; ++i) {
      out->front_left = in->left;
      out->front_right = in->right;
      ++in;
      ++out;
    }
  }
  ...
}

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

I actually did something like this initially but the thing is that we don't know
the exact channel config for 7.1 and since we will zero out all the surround
channels (and not use most parts of Layout7_1_16bit) I decided to skip it. Will
think again. Thanks for the code snippets.

OK. I used most parts of your proposal but was actually not able to come up with
a good solution to the channel-layout input since we are mixing "Chrome-style
from the renderer" for the input with "Microsoft internal" for the output. Will
add TODO.

+      out16[0] = in16[0];
+      out16[1] = in16[1];
+
+      // Set all surround channels (and LFE) to zero.
+      for (int n = 2; n < out_channels; n++) {
+        out16[n] = 0;
+      }
+
+      in16 += 2;
+      out16 += out_channels;
+    }
+  } else {
+    LOG(ERROR) << "Up-mixing is not supported.";
+    return false;
+  }
+  return true;
+}
+
 // static
 AUDCLNT_SHAREMODE WASAPIAudioOutputStream::GetShareMode() {
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
   if (cmd_line->HasSwitch(switches::kEnableExclusiveAudio))
     return AUDCLNT_SHAREMODE_EXCLUSIVE;
   return AUDCLNT_SHAREMODE_SHARED;
 }
 
 WASAPIAudioOutputStream::WASAPIAudioOutputStream(AudioManagerWin* manager,
                                                  const AudioParameters& params,
                                                  ERole device_role)
     : com_init_(ScopedCOMInitializer::kMTA),
       creating_thread_id_(base::PlatformThread::CurrentId()),
       manager_(manager),
+      client_audio_parameters_(params),

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

note: this isn't used anywhere

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

It is used in call to ChannelUpMix() to feed in the input channel count.

       render_thread_(NULL),
       opened_(false),
       started_(false),
       restart_rendering_mode_(false),
       volume_(1.0),
       endpoint_buffer_size_frames_(0),
       device_role_(device_role),
       share_mode_(GetShareMode()),
+      endpoint_channel_count_(HardwareChannelCount()),  // <=> default device

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

can't these be derived from format_?

even though I commented about the accessors ... what if we had:
int endpoint_channel_count() { return format_.Format->nChannels; }

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

I was able to remove this member by doing almost as you propose. Check new
version.

+      endpoint_channel_config_(ChannelConfig()),  // <=> default device

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

this is only used to set format_.dwChannelMask, which makes me wonder whether we
need a new member variable

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

Removed.

+      channel_factor_(0),
       num_written_frames_(0),
       source_(NULL) {
   CHECK(com_init_.succeeded());
   DCHECK(manager_);
 
   // Load the Avrt DLL if not already loaded. Required to support MMCSS.
   bool avrt_init = avrt::Initialize();
   DCHECK(avrt_init) << "Failed to load the avrt.dll";
 
   if (share_mode() == AUDCLNT_SHAREMODE_EXCLUSIVE) {
     VLOG(1) << ">> Note that EXCLUSIVE MODE is enabled <<";
   }
 
-  // Set up the desired render format specified by the client.
-  format_.nSamplesPerSec = params.sample_rate();
-  format_.wFormatTag = WAVE_FORMAT_PCM;
-  format_.wBitsPerSample = params.bits_per_sample();
-  format_.nChannels = params.channels();
-  format_.nBlockAlign = (format_.wBitsPerSample / 8) * format_.nChannels;
-  format_.nAvgBytesPerSec = format_.nSamplesPerSec * format_.nBlockAlign;
-  format_.cbSize = 0;
+  // It is possible to set the number of channels in |params| to a lower value
+  // than we use as the internal number of audio channels when the audio stream
+  // is opened. If this mode (channel_factor_ > 1) is set, the native audio
+  // layer will expect a larger number of channels in the interleaved audio
+  // stream and a channel up-mix will be performed after the OnMoreData()
+  // callback to compensate for the lower number of channels provided by the
+  // audio source.
+  // Example: params.channels() is 2 and endpoint_channel_count() is 8 =>
+  // the audio stream is opened up in 7.1 surround mode but the source only
+  // provides a stereo signal as input, i.e., a stereo up-mix (2 -> 7.1) will
+  // take place before sending the stream to the audio driver.
+  channel_factor_ = endpoint_channel_count() / params.channels();

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

hmmm if you end up keeping client_audio_parameters_ around this can become a
derived member:

int channel_factor() { return endpoint_channel_count() /
client_audio_parameters_.channels(); }

if client_audio_parameters_ goes away, then you can keep channel_factor_ :)

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

Added client_channel_count_ instead and turned channel_factor() into simple
getter.

+  DCHECK_GE(channel_factor_, 1) << "Unsupported channel count.";
+  DVLOG(1) << "client channels: " << params.channels();
+  DVLOG(1) << "channel factor: " << channel_factor_;
+
+  // Set up the desired render format specified by the client. We use the
+  // WAVE_FORMAT_EXTENSIBLE structure to ensure that multiple channel ordering
+  // and high precision data can be supported.
+
+  // Begin with the WAVEFORMATEX structure that specifies the basic format.
+  WAVEFORMATEX* format = &format_.Format;
+  format->wFormatTag = WAVE_FORMAT_EXTENSIBLE;
+  format->nChannels =  endpoint_channel_count();
+  format->nSamplesPerSec = params.sample_rate();
+  format->wBitsPerSample = params.bits_per_sample();
+  format->nBlockAlign = (format->wBitsPerSample / 8) * format->nChannels;
+  format->nAvgBytesPerSec = format->nSamplesPerSec * format->nBlockAlign;
+  format->cbSize = 22;

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

22?  use sizeof?  could also move this to the top of setting the struct since
this is the struct's header. 

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

It is actually "MSDN-standard" to hard code 22 here. We can discuss off-line.
But yes, it is possible to derive as well.

+
+  // Add the parts which are unique to WAVE_FORMAT_EXTENSIBLE.
+  format_.Samples.wValidBitsPerSample = params.bits_per_sample();
+  format_.dwChannelMask = endpoint_channel_config();
+  format_.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 
   // Size in bytes of each audio frame.
-  frame_size_ = format_.nBlockAlign;
+  frame_size_ = format->nBlockAlign;
 
   // Store size (in different units) of audio packets which we expect to
   // get from the audio endpoint device in each render event.
-  packet_size_frames_ = params.GetBytesPerBuffer() / format_.nBlockAlign;
-  packet_size_bytes_ = params.GetBytesPerBuffer();
+  packet_size_frames_ =
+      (channel_factor_ * params.GetBytesPerBuffer()) / format->nBlockAlign;
+  packet_size_bytes_ = channel_factor_ * params.GetBytesPerBuffer();
   packet_size_ms_ = (1000.0 * packet_size_frames_) / params.sample_rate();
   DVLOG(1) << "Number of bytes per audio frame  : " << frame_size_;
   DVLOG(1) << "Number of audio frames per packet: " << packet_size_frames_;
   DVLOG(1) << "Number of milliseconds per packet: " << packet_size_ms_;
 
   // All events are auto-reset events and non-signaled initially.
 
   // Create the event which the audio engine will signal each time
   // a buffer becomes ready to be processed by the client.
   audio_samples_render_event_.Set(CreateEvent(NULL, FALSE, FALSE, NULL));
@@ skipping 201 matching lines @@
   }
   volume_ = volume_float;
 }
 
 void WASAPIAudioOutputStream::GetVolume(double* volume) {
   DVLOG(1) << "GetVolume()";
   *volume = static_cast<double>(volume_);
 }
 
 // static
+int WASAPIAudioOutputStream::HardwareChannelCount() {
+  // Use a WAVEFORMATEXTENSIBLE structure since it can specify both the
+  // number of channels and the mapping of channels to speakers for
+  // multichannel devices.
+  base::win::ScopedCoMem<WAVEFORMATPCMEX> format_ex;
+  HRESULT hr = GetMixFormat(
+      eConsole, reinterpret_cast<WAVEFORMATEX**>(&format_ex));

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

the reinterpret_cast shouldn't be needed.  operator& returns T**.

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

Tell that to the compiler ;-)

error C2664: 'media::GetMixFormat' : cannot convert parameter 2 from
'WAVEFORMATPCMEX **' to 'WAVEFORMATEX **'

Note that WAVEFORMATEX != WAVEFORMATPCMEX

+  if (FAILED(hr))
+    return 0;
+
+  // Number of channels in the stream. Corresponds to the number of bits
+  // set in the dwChannelMask.
+  DVLOG(2) << "endpoint channels: " << format_ex->Format.nChannels;
+
+  return static_cast<int>(format_ex->Format.nChannels);
+}
+
+// static
+ChannelLayout WASAPIAudioOutputStream::HardwareChannelLayout() {
+  return ChannelConfigToChromeChannelLayout(ChannelConfig());
+}
+
+// static
+uint32 WASAPIAudioOutputStream::ChannelConfig() {
+  // Use a WAVEFORMATEXTENSIBLE structure since it can specify both the
+  // number of channels and the mapping of channels to speakers for
+  // multichannel devices.
+  base::win::ScopedCoMem<WAVEFORMATPCMEX> format_ex;
+  HRESULT hr = GetMixFormat(
+      eConsole, reinterpret_cast<WAVEFORMATEX**>(&format_ex));

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

same here

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

see above

+  if (FAILED(hr))
+    return 0;
+
+  // The dwChannelMask member specifies which channels are present in the
+  // multichannel stream. The least significant bit corresponds to the
+  // front left speaker, the next least significant bit corresponds to the
+  // front right speaker, and so on.
+  // See http://msdn.microsoft.com/en-us/library/windows/desktop/dd757714(v=vs.85).aspx
+  // for more details on the channel mapping.
+  DVLOG(2) << "dwChannelMask: 0x" << std::hex << format_ex->dwChannelMask;
+
+  // See http://en.wikipedia.org/wiki/Surround_sound for more details on
+  // how to name various speaker configurations. The list below is not complete.
+  std::string speaker_config("Undefined");

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

move this into an #ifndef NDEBUG?
also, you don't need std::string.  const char* is enough.

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

Done.

+  if (format_ex->dwChannelMask == KSAUDIO_SPEAKER_MONO)

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

switch()?

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

Done.

+    speaker_config = "Mono";
+  else if (format_ex->dwChannelMask == KSAUDIO_SPEAKER_STEREO)
+    speaker_config = "Stereo";
+  else if (format_ex->dwChannelMask == KSAUDIO_SPEAKER_5POINT1_SURROUND)
+    speaker_config = "5.1 surround";
+  else if (format_ex->dwChannelMask == KSAUDIO_SPEAKER_5POINT1)
+    speaker_config = "5.1";
+  if (format_ex->dwChannelMask == KSAUDIO_SPEAKER_7POINT1_SURROUND)
+    speaker_config = "7.1 surround";
+  else if (format_ex->dwChannelMask == KSAUDIO_SPEAKER_7POINT1)
+    speaker_config = "7.1";
+  DVLOG(2) << "speaker configuration: " << speaker_config;
+
+  return static_cast<uint32>(format_ex->dwChannelMask);
+}
+
+// static
+ChannelLayout WASAPIAudioOutputStream::ChannelConfigToChromeChannelLayout(
+    uint32 config) {
+  switch (config) {
+    case KSAUDIO_SPEAKER_DIRECTOUT:
+      return CHANNEL_LAYOUT_NONE;
+    case KSAUDIO_SPEAKER_MONO:
+      return CHANNEL_LAYOUT_MONO;
+    case KSAUDIO_SPEAKER_STEREO:
+      return CHANNEL_LAYOUT_STEREO;
+    case KSAUDIO_SPEAKER_QUAD:
+      return CHANNEL_LAYOUT_QUAD;
+    case KSAUDIO_SPEAKER_SURROUND:
+      return CHANNEL_LAYOUT_4_0;
+    case KSAUDIO_SPEAKER_5POINT1:
+      return CHANNEL_LAYOUT_5_1_BACK;
+    case KSAUDIO_SPEAKER_5POINT1_SURROUND:
+      return CHANNEL_LAYOUT_5_1;
+    case KSAUDIO_SPEAKER_7POINT1:
+      return CHANNEL_LAYOUT_7_1_WIDE;
+    case KSAUDIO_SPEAKER_7POINT1_SURROUND:
+      return CHANNEL_LAYOUT_7_1;
+    default:
+      DVLOG(1) << "Unsupported channel layout: " << config;

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

add break;

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

Done.

+  }
+  return CHANNEL_LAYOUT_UNSUPPORTED;
+}
+
+// static
 int WASAPIAudioOutputStream::HardwareSampleRate(ERole device_role) {
+  base::win::ScopedCoMem<WAVEFORMATEX> format;
+  HRESULT hr = GetMixFormat(device_role, &format);
+  if (FAILED(hr))
+    return 0;
+
+  DVLOG(2) << "nSamplesPerSec: " << format->nSamplesPerSec;
+  return static_cast<int>(format->nSamplesPerSec);
+}
+
+// static
+HRESULT WASAPIAudioOutputStream::GetMixFormat(ERole device_role,
+                                              WAVEFORMATEX** device_format) {
+  // Note that we are using the IAudioClient::GetMixFormat() API to get the
+  // device format in this function. It is in fact possible to be "more native",
+  // and ask the endpoint device directly for its properties. Given a reference
+  // to the IMMDevice interface of an endpoint object, a client can obtain a
+  // reference to the endpoint object's property store by calling the
+  // IMMDevice::OpenPropertyStore() method. However, I have not been able to
+  // access any valuable information using this method on my HP Z600 desktop,
+  // hence it feels more appropriate to use the IAudioClient::GetMixFormat()
+  // approach instead.
+
   // Calling this function only makes sense for shared mode streams, since
   // if the device will be opened in exclusive mode, then the application
   // specified format is used instead. However, the result of this method can
   // be useful for testing purposes so we don't DCHECK here.
   DLOG_IF(WARNING, GetShareMode() == AUDCLNT_SHAREMODE_EXCLUSIVE) <<
       "The mixing sample rate will be ignored for exclusive-mode streams.";
 
   // It is assumed that this static method is called from a COM thread, i.e.,
   // CoInitializeEx() is not called here again to avoid STA/MTA conflicts.
   ScopedComPtr<IMMDeviceEnumerator> enumerator;
@@ skipping 17 matching lines @@
     // "not found" when no speaker is plugged into the output jack).
     LOG(WARNING) << "No audio end point: " << std::hex << hr;
     return 0.0;
   }
 
   ScopedComPtr<IAudioClient> audio_client;
   hr = endpoint_device->Activate(__uuidof(IAudioClient),
                                  CLSCTX_INPROC_SERVER,
                                  NULL,
                                  audio_client.ReceiveVoid());
-  if (FAILED(hr)) {
-    NOTREACHED() << "error code: " << std::hex << hr;
-    return 0.0;
+  DCHECK(SUCCEEDED(hr)) << "Failed to activate device: " << std::hex << hr;
+  if (SUCCEEDED(hr)) {
+    hr = audio_client->GetMixFormat(device_format);
+    DCHECK(SUCCEEDED(hr)) << "GetMixFormat: " << std::hex << hr;
   }
 
-  // Retrieve the stream format that the audio engine uses for its internal
-  // processing of shared-mode streams.
-  base::win::ScopedCoMem<WAVEFORMATEX> audio_engine_mix_format;
-  hr = audio_client->GetMixFormat(&audio_engine_mix_format);
-  if (FAILED(hr)) {
-    NOTREACHED() << "error code: " << std::hex << hr;
-    return 0.0;
-  }
-
-  return static_cast<int>(audio_engine_mix_format->nSamplesPerSec);
+  return hr;
 }
 
 void WASAPIAudioOutputStream::Run() {
   ScopedCOMInitializer com_init(ScopedCOMInitializer::kMTA);
 
   // Increase the thread priority.
   render_thread_->SetThreadPriority(base::kThreadPriority_RealtimeAudio);
 
   // Enable MMCSS to ensure that this thread receives prioritized access to
   // CPU resources.
@@ skipping 112 matching lines @@
             // a render event and the time when the first audio sample in a
             // packet is played out through the speaker. This delay value
             // can typically be utilized by an acoustic echo-control (AEC)
             // unit at the render side.
             UINT64 position = 0;
             int audio_delay_bytes = 0;
             hr = audio_clock->GetPosition(&position, NULL);
             if (SUCCEEDED(hr)) {
               // Stream position of the sample that is currently playing
               // through the speaker.
-              double pos_sample_playing_frames = format_.nSamplesPerSec *
+              double pos_sample_playing_frames = format_.Format.nSamplesPerSec *
                   (static_cast<double>(position) / device_frequency);
 
               // Stream position of the last sample written to the endpoint
               // buffer. Note that, the packet we are about to receive in
               // the upcoming callback is also included.
               size_t pos_last_sample_written_frames =
                   num_written_frames_ + packet_size_frames_;
 
               // Derive the actual delay value which will be fed to the
               // render client using the OnMoreData() callback.
               audio_delay_bytes = (pos_last_sample_written_frames -
                   pos_sample_playing_frames) *  frame_size_;
             }
 
             // Read a data packet from the registered client source and
             // deliver a delay estimate in the same callback to the client.
             // A time stamp is also stored in the AudioBuffersState. This
             // time stamp can be used at the client side to compensate for
             // the delay between the usage of the delay value and the time
             // of generation.
-            uint32 num_filled_bytes = source_->OnMoreData(
-                audio_data, packet_size_bytes_,
-                AudioBuffersState(0, audio_delay_bytes));
 
-            // Perform in-place, software-volume adjustments.
-            media::AdjustVolume(audio_data,
-                                num_filled_bytes,
-                                format_.nChannels,
-                                format_.wBitsPerSample >> 3,
-                                volume_);
+            // TODO(henrika): improve comments about possible upmixing here...
 
-            // Zero out the part of the packet which has not been filled by
-            // the client. Using silence is the least bad option in this
-            // situation.
-            if (num_filled_bytes < packet_size_bytes_) {
-              memset(&audio_data[num_filled_bytes], 0,
-                    (packet_size_bytes_ - num_filled_bytes));
+            uint32 num_filled_bytes = 0;
+
+            if (channel_factor_ == 1) {
+              // Case I: no up-mixing.
+              num_filled_bytes = source_->OnMoreData(
+                  audio_data, packet_size_bytes_,
+                  AudioBuffersState(0, audio_delay_bytes));
+
+              // Perform in-place, software-volume adjustments.
+              media::AdjustVolume(audio_data,
+                                  num_filled_bytes,
+                                  format_.Format.nChannels,
+                                  format_.Format.wBitsPerSample >> 3,
+                                  volume_);
+
+              // Zero out the part of the packet which has not been filled by
+              // the client. Using silence is the least bad option in this
+              // situation.
+              if (num_filled_bytes < packet_size_bytes_) {
+                memset(&audio_data[num_filled_bytes], 0,
+                      (packet_size_bytes_ - num_filled_bytes));

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

indent? (looks off by 1)

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

Done.

+              }
+            } else {
+              // Case II: up-mixing.
+              const int audio_source_size_bytes =
+                  packet_size_bytes_ / channel_factor_;
+              scoped_array<uint8> buffer;
+              buffer.reset(new uint8[audio_source_size_bytes]);
+
+              num_filled_bytes = source_->OnMoreData(
+                  buffer.get(), audio_source_size_bytes,
+                  AudioBuffersState(0, audio_delay_bytes));
+
+              ChannelUpMix(buffer.get(),
+                           &audio_data[0],
+                           client_channel_count(),
+                           endpoint_channel_count(),
+                           num_filled_bytes);
+
+              // TODO(henrika): take care of zero-out for this case as well.
             }
 
             // Release the buffer space acquired in the GetBuffer() call.
             DWORD flags = 0;
             audio_render_client_->ReleaseBuffer(packet_size_frames_,
                                                 flags);
 
             num_written_frames_ += packet_size_frames_;
           }
         }
@@ skipping 69 matching lines @@
   // Creates and activates an IAudioClient COM object given the selected
   // render endpoint device.
   HRESULT hr = endpoint_device_->Activate(__uuidof(IAudioClient),
                                           CLSCTX_INPROC_SERVER,
                                           NULL,
                                           audio_client.ReceiveVoid());
   if (SUCCEEDED(hr)) {
     // Retrieve the stream format that the audio engine uses for its internal
     // processing/mixing of shared-mode streams.
     audio_engine_mix_format_.Reset(NULL);
-    hr = audio_client->GetMixFormat(&audio_engine_mix_format_);
+    hr = audio_client->GetMixFormat(
+        reinterpret_cast<WAVEFORMATEX**>(&audio_engine_mix_format_));

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

no cast should be necessary

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

see previous comment.

 
     if (SUCCEEDED(hr)) {
       audio_client_ = audio_client;
     }
   }
 
   return hr;
 }
 
 bool WASAPIAudioOutputStream::DesiredFormatIsSupported() {
   // Determine, before calling IAudioClient::Initialize(), whether the audio
   // engine supports a particular stream format.
   // In shared mode, the audio engine always supports the mix format,
   // which is stored in the |audio_engine_mix_format_| member and it is also
   // possible to receive a proposed (closest) format if the current format is
   // not supported.
-  base::win::ScopedCoMem<WAVEFORMATEX> closest_match;
-  HRESULT hr = audio_client_->IsFormatSupported(share_mode(),
-                                                &format_,
-                                                &closest_match);
+  base::win::ScopedCoMem<WAVEFORMATEXTENSIBLE> closest_match;
+  HRESULT hr = audio_client_->IsFormatSupported(
+    share_mode(), reinterpret_cast<WAVEFORMATEX*>(&format_),

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

don't cast format_. instead use operatorT*() and remove &

  share_mode(), format_,

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

Same comment as before. IsFormatSupported takes WAVEFORMATEX*.

+    reinterpret_cast<WAVEFORMATEX**>(&closest_match));

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

cast not needed

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

ditto

 
   // This log can only be triggered for shared mode.
   DLOG_IF(ERROR, hr == S_FALSE) << "Format is not supported "
                                 << "but a closest match exists.";
   // This log can be triggered both for shared and exclusive modes.
   DLOG_IF(ERROR, hr == AUDCLNT_E_UNSUPPORTED_FORMAT) << "Unsupported format.";
   if (hr == S_FALSE) {
-    DVLOG(1) << "wFormatTag    : " << closest_match->wFormatTag;
-    DVLOG(1) << "nChannels     : " << closest_match->nChannels;
-    DVLOG(1) << "nSamplesPerSec: " << closest_match->nSamplesPerSec;
-    DVLOG(1) << "wBitsPerSample: " << closest_match->wBitsPerSample;
+    DVLOG(1) << "wFormatTag    : " << closest_match->Format.wFormatTag;
+    DVLOG(1) << "nChannels     : " << closest_match->Format.nChannels;
+    DVLOG(1) << "nSamplesPerSec: " << closest_match->Format.nSamplesPerSec;
+    DVLOG(1) << "wBitsPerSample: " << closest_match->Format.wBitsPerSample;
   }
 
   return (hr == S_OK);
 }
 
 HRESULT WASAPIAudioOutputStream::InitializeAudioEngine() {
 #if !defined(NDEBUG)
   // The period between processing passes by the audio engine is fixed for a
   // particular audio endpoint device and represents the smallest processing
   // quantum for the audio engine. This period plus the stream latency between
@@ skipping 70 matching lines @@
   return hr;
 }
 
 HRESULT WASAPIAudioOutputStream::SharedModeInitialization() {
   DCHECK_EQ(share_mode(), AUDCLNT_SHAREMODE_SHARED);
 
   // TODO(henrika): this buffer scheme is still under development.
   // The exact details are yet to be determined based on tests with different
   // audio clients.
   int glitch_free_buffer_size_ms = static_cast<int>(packet_size_ms_ + 0.5);
-  if (audio_engine_mix_format_->nSamplesPerSec == 48000) {
+  if (audio_engine_mix_format_->Format.nSamplesPerSec == 48000) {
     // Initial tests have shown that we have to add 10 ms extra to
     // ensure that we don't run empty for any packet size.
     glitch_free_buffer_size_ms += 10;
-  } else if (audio_engine_mix_format_->nSamplesPerSec == 44100) {
+  } else if (audio_engine_mix_format_->Format.nSamplesPerSec == 44100) {
     // Initial tests have shown that we have to add 20 ms extra to
     // ensure that we don't run empty for any packet size.
     glitch_free_buffer_size_ms += 20;
   } else {
     glitch_free_buffer_size_ms += 20;
   }
   DVLOG(1) << "glitch_free_buffer_size_ms: " << glitch_free_buffer_size_ms;
   REFERENCE_TIME requested_buffer_duration =
       static_cast<REFERENCE_TIME>(glitch_free_buffer_size_ms * 10000);
 
   // Initialize the audio stream between the client and the device.
   // We connect indirectly through the audio engine by using shared mode
   // and WASAPI is initialized in an event driven mode.
   // Note that this API ensures that the buffer is never smaller than the
   // minimum buffer size needed to ensure glitch-free rendering.
   // If we requests a buffer size that is smaller than the audio engine's
   // minimum required buffer size, the method sets the buffer size to this
   // minimum buffer size rather than to the buffer size requested.
   HRESULT hr = audio_client_->Initialize(AUDCLNT_SHAREMODE_SHARED,
                                          AUDCLNT_STREAMFLAGS_EVENTCALLBACK |
                                          AUDCLNT_STREAMFLAGS_NOPERSIST,
                                          requested_buffer_duration,
                                          0,
-                                         &format_,
+                                         reinterpret_cast<WAVEFORMATEX*>(&format_),

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

use operator T*()

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

ditto

                                          NULL);
   return hr;
 }
 
 HRESULT WASAPIAudioOutputStream::ExclusiveModeInitialization() {
   DCHECK_EQ(share_mode(), AUDCLNT_SHAREMODE_EXCLUSIVE);
 
-  float f = (1000.0 * packet_size_frames_) / format_.nSamplesPerSec;
+  float f = (1000.0 * packet_size_frames_) / format_.Format.nSamplesPerSec;
   REFERENCE_TIME requested_buffer_duration =
       static_cast<REFERENCE_TIME>(f * 10000.0 + 0.5);
 
   // Initialize the audio stream between the client and the device.
   // For an exclusive-mode stream that uses event-driven buffering, the
   // caller must specify nonzero values for hnsPeriodicity and
   // hnsBufferDuration, and the values of these two parameters must be equal.
   // The Initialize method allocates two buffers for the stream. Each buffer
   // is equal in duration to the value of the hnsBufferDuration parameter.
   // Following the Initialize call for a rendering stream, the caller should
   // fill the first of the two buffers before starting the stream.
   HRESULT hr = audio_client_->Initialize(AUDCLNT_SHAREMODE_EXCLUSIVE,
                                          AUDCLNT_STREAMFLAGS_EVENTCALLBACK |
                                          AUDCLNT_STREAMFLAGS_NOPERSIST,
                                          requested_buffer_duration,
                                          requested_buffer_duration,
-                                         &format_,
+                                         reinterpret_cast<WAVEFORMATEX*>(&format_),

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

operator

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

ditto

                                          NULL);
   if (FAILED(hr)) {
     if (hr == AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED) {
       LOG(ERROR) << "AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED";
 
       UINT32 aligned_buffer_size = 0;
       audio_client_->GetBufferSize(&aligned_buffer_size);
       DVLOG(1) << "Use aligned buffer size instead: " << aligned_buffer_size;
       audio_client_.Release();
 
       // Calculate new aligned periodicity. Each unit of reference time
       // is 100 nanoseconds.
       REFERENCE_TIME aligned_buffer_duration = static_cast<REFERENCE_TIME>(
-          (10000000.0 * aligned_buffer_size / format_.nSamplesPerSec) + 0.5);
+          (10000000.0 * aligned_buffer_size / format_.Format.nSamplesPerSec)
+          + 0.5);
 
       // It is possible to re-activate and re-initialize the audio client
       // at this stage but we bail out with an error code instead and
       // combine it with a log message which informs about the suggested
       // aligned buffer size which should be used instead.
       DVLOG(1) << "aligned_buffer_duration: "
                 << static_cast<double>(aligned_buffer_duration / 10000.0)
                 << " [ms]";
     } else if (hr == AUDCLNT_E_INVALID_DEVICE_PERIOD) {
       // We will get this error if we try to use a smaller buffer size than
@@ skipping 19 matching lines @@
   NOTREACHED() << "IMMNotificationClient should not use this method.";
   if (iid == IID_IUnknown || iid == __uuidof(IMMNotificationClient)) {
     *object = static_cast < IMMNotificationClient*>(this);
   } else {
     return E_NOINTERFACE;
   }
   return S_OK;
 }
 
 STDMETHODIMP WASAPIAudioOutputStream::OnDeviceStateChanged(LPCWSTR device_id,
-                                                      DWORD new_state) {
+    DWORD new_state) {
 #ifndef NDEBUG
   std::string device_name = GetDeviceName(device_id);
   std::string device_state;
 
   switch (new_state) {
     case DEVICE_STATE_ACTIVE:
       device_state = "ACTIVE";
       break;
     case DEVICE_STATE_DISABLED:
       device_state = "DISABLED";
@@ skipping 123 matching lines @@
   // are now re-initiated and it is now possible to re-start audio rendering.
 
   // Start rendering again using the new default audio endpoint.
   hr = audio_client_->Start();
 
   restart_rendering_mode_ = false;
   return SUCCEEDED(hr);
 }
 
 }  // namespace media