Removed IMMNotification from WASAPIAudioOutputStream.

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 14 matching lines @@
 //   latency of approximately 35 ms if the selected packet size is less than
 //   or equal to 20 ms. Using a packet size of 10 ms does not result in a
 //   lower latency but only affects the size of the data buffer in each
 //   OnMoreData() callback.
 // - A total typical delay of 35 ms contains three parts:
 //    o Audio endpoint device period (~10 ms).
 //    o Stream latency between the buffer and endpoint device (~5 ms).
 //    o Endpoint buffer (~20 ms to ensure glitch-free rendering).
 // - Note that, if the user selects a packet size of e.g. 100 ms, the total
 //   delay will be approximately 115 ms (10 + 5 + 100).
-// - Supports device events using the IMMNotificationClient Interface. If
-//   streaming has started, a so-called stream switch will take place in the
-//   following situations:
-//    o The user enables or disables an audio endpoint device from Device
-//      Manager or from the Windows multimedia control panel, Mmsys.cpl.
-//    o The user adds an audio adapter to the system or removes an audio
-//      adapter from the system.
-//    o The user plugs an audio endpoint device into an audio jack with
-//      jack-presence detection, or removes an audio endpoint device from
-//      such a jack.
-//    o The user changes the device role that is assigned to a device.
-//    o The value of a property of a device changes.
-//   Practical/typical example: A user has two audio devices A and B where
-//   A is a built-in device configured as Default Communication and B is a
-//   USB device set as Default device. Audio rendering starts and audio is
-//   played through the device B since the eConsole role is used by the audio
-//   manager in Chrome today. If the user now removes the USB device (B), it
-//   will be detected and device A will instead be defined as the new default
-//   device. Rendering will automatically stop, all resources will be released
-//   and a new session will be initialized and started using device A instead.
-//   The net effect for the user is that audio will automatically switch from
-//   device B to device A. Same thing will happen if the user now re-inserts
-//   the USB device again.
 //
 // Implementation notes:
 //
 // - The minimum supported client is Windows Vista.
 // - This implementation is single-threaded, hence:
 //    o Construction and destruction must take place from the same thread.
 //    o All APIs must be called from the creating thread as well.
 // - It is recommended to first acquire the native sample rate of the default
 //   input device and then use the same rate when creating this object. Use
 //   WASAPIAudioOutputStream::HardwareSampleRate() to retrieve the sample rate.
@@ skipping 19 matching lines @@
 // - Utilized WASAPI interfaces:
 //     o IAudioClient
 //     o IAudioRenderClient
 // - The stream is initialized in shared mode and the processing of the
 //   audio buffer is event driven.
 // - The Multimedia Class Scheduler service (MMCSS) is utilized to boost
 //   the priority of the render thread.
 // - Audio-rendering endpoint devices can have three roles:
 //   Console (eConsole), Communications (eCommunications), and Multimedia
 //   (eMultimedia). Search for "Device Roles" on MSDN for more details.
-// - The actual stream-switch is executed on the audio-render thread but it
-//   is triggered by an internal MMDevice thread using callback methods
-//   in the IMMNotificationClient interface.
 //
 // Threading details:
 //
 // - It is assumed that this class is created on the audio thread owned
 //   by the AudioManager.
 // - It is a requirement to call the following methods on the same audio
 //   thread: Open(), Start(), Stop(), and Close().
 // - Audio rendering is performed on the audio render thread, owned by this
 //   class, and the AudioSourceCallback::OnMoreData() method will be called
 //   from this thread. Stream switching also takes place on the audio-render
 //   thread.
-// - All callback methods from the IMMNotificationClient interface will be
-//   called on a Windows-internal MMDevice thread.
 //
 // Experimental exclusive mode:
 //
 // - It is possible to open up a stream in exclusive mode by using the
 //   --enable-exclusive-audio command line flag.
 // - The internal buffering scheme is less flexible for exclusive streams.
 //   Hence, some manual tuning will be required before deciding what frame
 //   size to use. See the WinAudioOutputTest unit test for more details.
 // - If an application opens a stream in exclusive mode, the application has
 //   exclusive use of the audio endpoint device that plays the stream.
 // - Exclusive-mode should only be utilized when the lowest possible latency
 //   is important.
 // - In exclusive mode, the client can choose to open the stream in any audio
 //   format that the endpoint device supports, i.e. not limited to the device's
 //   current (default) configuration.
 // - Initial measurements on Windows 7 (HP Z600 workstation) have shown that
 //   the lowest possible latencies we can achieve on this machine are:
 //     o ~3.3333ms @ 48kHz <=> 160 audio frames per buffer.
 //     o ~3.6281ms @ 44.1kHz <=> 160 audio frames per buffer.
 // - See http://msdn.microsoft.com/en-us/library/windows/desktop/dd370844(v=vs.85).aspx
 //   for more details.
 
 #ifndef MEDIA_AUDIO_WIN_AUDIO_LOW_LATENCY_OUTPUT_WIN_H_
 #define MEDIA_AUDIO_WIN_AUDIO_LOW_LATENCY_OUTPUT_WIN_H_
 
 #include <Audioclient.h>
-#include <audiopolicy.h>
 #include <MMDeviceAPI.h>
 
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/simple_thread.h"
 #include "base/win/scoped_co_mem.h"
 #include "base/win/scoped_com_initializer.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_handle.h"
 #include "media/audio/audio_io.h"
 #include "media/audio/audio_parameters.h"
 #include "media/base/media_export.h"
 
 namespace media {
 
 class AudioManagerWin;
 
 // AudioOutputStream implementation using Windows Core Audio APIs.
-// TODO(henrika): Remove IMMNotificationClient implementation now that we have
-// AudioDeviceListenerWin; currently just disabled since extraction is extremely
-// advanced.
-class MEDIA_EXPORT WASAPIAudioOutputStream
-    : public IMMNotificationClient,
+class MEDIA_EXPORT WASAPIAudioOutputStream :
       public AudioOutputStream,
       public base::DelegateSimpleThread::Delegate {
  public:
   // The ctor takes all the usual parameters, plus |manager| which is the
   // the audio manager who is creating this object.
   WASAPIAudioOutputStream(AudioManagerWin* manager,
                           const AudioParameters& params,
                           ERole device_role);
+
   // The dtor is typically called by the AudioManager only and it is usually
   // triggered by calling AudioOutputStream::Close().
   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;
@@ skipping 18 matching lines @@
   // as command-line flag and AUDCLNT_SHAREMODE_SHARED otherwise (default).
   static AUDCLNT_SHAREMODE GetShareMode();
 
   bool started() const { return render_thread_.get() != NULL; }
 
   // Returns the number of channels the audio engine uses for its internal
   // processing/mixing of shared-mode streams for the default endpoint device.
   int GetEndpointChannelCountForTesting() { return format_.Format.nChannels; }
 
  private:
-  // Implementation of IUnknown (trivial in this case). See
-  // msdn.microsoft.com/en-us/library/windows/desktop/dd371403(v=vs.85).aspx
-  // for details regarding why proper implementations of AddRef(), Release()
-  // and QueryInterface() are not needed here.
-  STDMETHOD_(ULONG, AddRef)();
-  STDMETHOD_(ULONG, Release)();
-  STDMETHOD(QueryInterface)(REFIID iid, void** object);
-
-  // Implementation of the abstract interface IMMNotificationClient.
-  // Provides notifications when an audio endpoint device is added or removed,
-  // when the state or properties of a device change, or when there is a
-  // change in the default role assigned to a device. See
-  // msdn.microsoft.com/en-us/library/windows/desktop/dd371417(v=vs.85).aspx
-  // for more details about the IMMNotificationClient interface.
-
-  // The default audio endpoint device for a particular role has changed.
-  // This method is only used for diagnostic purposes.
-  STDMETHOD(OnDeviceStateChanged)(LPCWSTR device_id, DWORD new_state);
-
-  // Indicates that the state of an audio endpoint device has changed.
-  STDMETHOD(OnDefaultDeviceChanged)(EDataFlow flow, ERole role,
-                                    LPCWSTR new_default_device_id);
-
-  // These IMMNotificationClient methods are currently not utilized.
-  STDMETHOD(OnDeviceAdded)(LPCWSTR device_id) { return S_OK; }
-  STDMETHOD(OnDeviceRemoved)(LPCWSTR device_id) { return S_OK; }
-  STDMETHOD(OnPropertyValueChanged)(LPCWSTR device_id,
-                                    const PROPERTYKEY key) {
-    return S_OK;
-  }
-
   // DelegateSimpleThread::Delegate implementation.
   virtual void Run() OVERRIDE;
 
   // 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();
 
   // 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();
-
   // 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_;
 
   // Rendering is driven by this thread (which has no message loop).
   // All OnMoreData() callbacks will be called from this thread.
   scoped_ptr<base::DelegateSimpleThread> render_thread_;
 
@@ skipping 68 matching lines @@
   // data to a rendering endpoint buffer.
   base::win::ScopedComPtr<IAudioRenderClient> audio_render_client_;
 
   // The audio engine will signal this event each time a buffer becomes
   // ready to be filled by the client.
   base::win::ScopedHandle audio_samples_render_event_;
 
   // This event will be signaled when rendering shall stop.
   base::win::ScopedHandle stop_render_event_;
 
-  // This event will be signaled when stream switching shall take place.
-  base::win::ScopedHandle stream_switch_event_;
-
   // Container for retrieving data from AudioSourceCallback::OnMoreData().
   scoped_ptr<AudioBus> audio_bus_;
 
   DISALLOW_COPY_AND_ASSIGN(WASAPIAudioOutputStream);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_AUDIO_WIN_AUDIO_LOW_LATENCY_OUTPUT_WIN_H_