Piping for audio encoding.

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 <string>
 
 #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/base/audio_capture_data.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/proto/audio.pb.h"
 
 namespace {
 const int kChannels = 2;
 const int kBitsPerSample = 16;
 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 bool Start(const AudioSamplesCapturedCallback& 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_;
+  AudioSamplesCapturedCallback 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()
     : sampling_rate_(AudioPacket::SAMPLING_RATE_INVALID) {
       thread_checker_.DetachFromThread();
 }
 
 AudioCapturerWin::~AudioCapturerWin() {
 }
 
-bool AudioCapturerWin::Start(const PacketCapturedCallback& callback) {
+bool AudioCapturerWin::Start(const AudioSamplesCapturedCallback& callback) {
   DCHECK(!audio_capture_client_.get());
   DCHECK(!audio_client_.get());
   DCHECK(!mm_device_.get());
   DCHECK(static_cast<PWAVEFORMATEX>(wave_format_ex_) == NULL);
   DCHECK(thread_checker_.CalledOnValidThread());
 
   callback_ = callback;
 
   // Initialize the capture timer.
   capture_timer_.reset(new base::RepeatingTimer<AudioCapturerWin>());
@@ skipping 172 matching lines @@
     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_);
+    scoped_ptr<AudioCaptureData> capture_data =
+        scoped_ptr<AudioCaptureData>(new AudioCaptureData());
+    capture_data->set_data(std::string(
+        reinterpret_cast<const char*>(data),
+        frames * wave_format_ex_->nBlockAlign));
+    capture_data->set_sampling_rate(sampling_rate_);
 
-    callback_.Run(packet.Pass());
+    callback_.Run(capture_data.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