Added support for multiple sampling rates on Windows.

remoting/host/audio_capturer_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 <windows.h>
 #include <audioclient.h>
 #include <avrt.h>
 #include <mmdeviceapi.h>
 #include <mmreg.h>
 #include <mmsystem.h>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/timer.h"
 #include "base/win/scoped_co_mem.h"
 #include "base/win/scoped_com_initializer.h"
 #include "base/win/scoped_comptr.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/proto/audio.pb.h"
 
 namespace {
 const int kChannels = 2;
 const int kBitsPerSample = 16;
-const int kSamplesPerSecond = 44100;
 const int kBitsPerByte = 8;
 // Conversion factor from 100ns to 1ms.
 const int kHnsToMs = 10000;
 }  // namespace
 
 namespace remoting {
 
 class AudioCapturerWin : public AudioCapturer {
  public:
   AudioCapturerWin();
   virtual ~AudioCapturerWin();
 
   // AudioCapturer interface.
   virtual bool Start(const PacketCapturedCallback& callback) OVERRIDE;
   virtual void Stop() OVERRIDE;
   virtual bool IsRunning() OVERRIDE;
 
  private:
   // Receives all packets from the audio capture endpoint buffer and pushes them
   // to the network.
   void DoCapture();
 
   PacketCapturedCallback callback_;
 
+  AudioPacket::SamplingRate sampling_rate_;
+
   scoped_ptr<base::RepeatingTimer<AudioCapturerWin> > capture_timer_;
   base::TimeDelta audio_device_period_;
 
   base::win::ScopedCoMem<WAVEFORMATEX> wave_format_ex_;
   base::win::ScopedComPtr<IAudioCaptureClient> audio_capture_client_;
   base::win::ScopedComPtr<IAudioClient> audio_client_;
   base::win::ScopedComPtr<IMMDevice> mm_device_;
   scoped_ptr<base::win::ScopedCOMInitializer> com_initializer_;
 
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioCapturerWin);
 };
 
-AudioCapturerWin::AudioCapturerWin() {
+AudioCapturerWin::AudioCapturerWin()
+  : sampling_rate_(AudioPacket::SAMPLING_RATE_INVALID) {

[Sergey Ulanov, 2012/07/26 03:40:24]

nit: initializer list should be indented 4 spaces (6 spaces after the first
line).

[kxing, 2012/07/26 22:47:17]

Done.

   thread_checker_.DetachFromThread();
 }
 
 AudioCapturerWin::~AudioCapturerWin() {
 }
 
 bool AudioCapturerWin::Start(const PacketCapturedCallback& callback) {
   DCHECK(!audio_capture_client_.get());
   DCHECK(!audio_client_.get());
   DCHECK(!mm_device_.get());
@@ skipping 48 matching lines @@
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to get WAVEFORMATEX. Error " << hr;
     return false;
   }
 
   // Set the wave format
   switch (wave_format_ex_->wFormatTag) {
     case WAVE_FORMAT_IEEE_FLOAT:
       // Intentional fall-through.
     case WAVE_FORMAT_PCM:
+      if (!AudioCapturer::IsValidSampleRate(wave_format_ex_->nSamplesPerSec)) {

[Wez, 2012/07/25 09:23:48]

Rather than have a static test for validity, why not pass a set of acceptable
capture rates to the AudioCapturer when it's started - we can then still
hard-code specific rates e.g. into the AudioScheduler, but we also have the
option of feeding back supported playback rates from the connected client.

[kxing, 2012/07/26 22:47:17]

The set of valid sampling rates is the same across all platforms (since they are
the sampling rates supported by Pepper). I'm not sure if the extra flexibility
of passed-in playback rates is worth it.

[Sergey Ulanov, 2012/07/27 04:22:38]

I discussed this with Kerry. This might be useful in the future, but there is no
point in doing it in this CL - we can add it later when we need it.

+        LOG(ERROR) << "Host sampling rate is neither 44.1 kHz nor 48 kHz.";
+        return false;

[Sergey Ulanov, 2012/07/26 03:40:24]

Can we still try to request some known sampling rate?

[kxing, 2012/07/26 22:47:17]

No, Pepper only supports 44.1 kHz and 48 kHz, and Windows only allows sampling
at the current output rate. Thus, if the output rate is neither 44.1 nor 48 kHz,
we'll have to resample.

+      }
+      sampling_rate_ =
+          static_cast<AudioPacket::SamplingRate>(
+          wave_format_ex_->nSamplesPerSec);
+
       wave_format_ex_->wFormatTag = WAVE_FORMAT_PCM;
       wave_format_ex_->nChannels = kChannels;
-      wave_format_ex_->nSamplesPerSec = kSamplesPerSecond;
       wave_format_ex_->wBitsPerSample = kBitsPerSample;
       wave_format_ex_->nBlockAlign = kChannels * kBitsPerSample / kBitsPerByte;
       wave_format_ex_->nAvgBytesPerSec =
-          kSamplesPerSecond * kChannels * kBitsPerSample / kBitsPerByte;
+          sampling_rate_ * kChannels * kBitsPerSample / kBitsPerByte;
       break;
     case WAVE_FORMAT_EXTENSIBLE: {
       PWAVEFORMATEXTENSIBLE wave_format_extensible =
           reinterpret_cast<WAVEFORMATEXTENSIBLE*>(
           static_cast<WAVEFORMATEX*>(wave_format_ex_));
       if (IsEqualGUID(KSDATAFORMAT_SUBTYPE_IEEE_FLOAT,
                       wave_format_extensible->SubFormat)) {
+        if (!AudioCapturer::IsValidSampleRate(
+            wave_format_extensible->Format.nSamplesPerSec)) {

[Sergey Ulanov, 2012/07/26 03:40:24]

nit: incorrect indentation. move it four spaces to the right.

[kxing, 2012/07/26 22:47:17]

Done.

+          LOG(ERROR) << "Host sampling rate is neither 44.1 kHz nor 48 kHz.";
+          return false;
+        }
+        sampling_rate_ =
+            static_cast<AudioPacket::SamplingRate>(
+            wave_format_extensible->Format.nSamplesPerSec);

[Sergey Ulanov, 2012/07/26 03:40:24]

nit: indent 4 spaces relative to the previous line. Or you can fit this
statement in two lines.

[kxing, 2012/07/26 22:47:17]

Done.

+
         wave_format_extensible->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
         wave_format_extensible->Samples.wValidBitsPerSample = kBitsPerSample;
 
         wave_format_extensible->Format.nChannels = kChannels;
-        wave_format_extensible->Format.nSamplesPerSec = kSamplesPerSecond;
+        wave_format_extensible->Format.nSamplesPerSec = sampling_rate_;
         wave_format_extensible->Format.wBitsPerSample = kBitsPerSample;
         wave_format_extensible->Format.nBlockAlign =
             kChannels * kBitsPerSample / kBitsPerByte;
         wave_format_extensible->Format.nAvgBytesPerSec =
-            kSamplesPerSecond * kChannels * kBitsPerSample / kBitsPerByte;
+            sampling_rate_ * kChannels * kBitsPerSample / kBitsPerByte;
       } else {
         LOG(ERROR) << "Failed to force 16-bit samples";
         return false;
       }
       break;
     }
     default:
       LOG(ERROR) << "Failed to force 16-bit samples";

[Sergey Ulanov, 2012/07/26 03:40:24]

is this a correct error message?

[kxing, 2012/07/26 22:47:17]

Done.

       return false;
   }
 
   // Initialize the IAudioClient.
   hr = audio_client_->Initialize(AUDCLNT_SHAREMODE_SHARED,
                                  AUDCLNT_STREAMFLAGS_LOOPBACK,
                                  0,
                                  0,
                                  wave_format_ex_,
                                  NULL);
@@ skipping 38 matching lines @@
 
   thread_checker_.DetachFromThread();
 }
 
 bool AudioCapturerWin::IsRunning() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return capture_timer_.get() != NULL;
 }
 
 void AudioCapturerWin::DoCapture() {
+  DCHECK(AudioCapturer::IsValidSampleRate(sampling_rate_));
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsRunning());
 
   // Fetch all packets from the audio capture endpoint buffer.
   while (true) {
     UINT32 next_packet_size;
     HRESULT hr = audio_capture_client_->GetNextPacketSize(&next_packet_size);
     if (FAILED(hr)) {
       LOG(ERROR) << "Failed to GetNextPacketSize. Error " << hr;
       return;
     }
 
     if (next_packet_size <= 0) {
       return;
     }
 
     BYTE* data;
     UINT32 frames;
     DWORD flags;
     hr = audio_capture_client_->GetBuffer(
         &data, &frames, &flags, NULL, NULL);
     if (FAILED(hr)) {
       LOG(ERROR) << "Failed to GetBuffer. Error " << hr;
       return;
     }
 
     scoped_ptr<AudioPacket> packet = scoped_ptr<AudioPacket>(new AudioPacket());
     packet->set_data(data, frames * wave_format_ex_->nBlockAlign);
+    packet->set_sampling_rate(sampling_rate_);
 
     callback_.Run(packet.Pass());
 
     hr = audio_capture_client_->ReleaseBuffer(frames);
     if (FAILED(hr)) {
       LOG(ERROR) << "Failed to ReleaseBuffer. Error " << hr;
       return;
     }
   }
 }
 
 scoped_ptr<AudioCapturer> AudioCapturer::Create() {
   return scoped_ptr<AudioCapturer>(new AudioCapturerWin());
 }
 
 }  // namespace remoting