Implement Linux audio capturer.

remoting/host/audio_capturer_linux.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 "remoting/host/audio_capturer_linux.h"
+
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "base/command_line.h"
+#include "base/eintr_wrapper.h"
+#include "base/file_path.h"
 #include "base/logging.h"
-#include "remoting/host/audio_capturer.h"
+#include "base/stl_util.h"
+#include "remoting/proto/audio.pb.h"
 
 namespace remoting {
 
+namespace {
+
+const char kAudioPipeOptionName[] = "audio-pipe-name";
+
+// PulseAudio's module-pipe-sink must be configured to use the following
+// parameters for the sink we read from.
+const AudioPacket_SamplingRate kSamplingRate = AudioPacket::SAMPLING_RATE_44100;
+const int kChannels = 2;
+const int kBytesPerSample = 2;
+
+// Read data from the pipe every 20ms.
+const int kCapturingPeriodMs = 20;
+
+}  // namespace
+
+AudioCapturerLinux::AudioCapturerLinux(const FilePath& pipe_name) {
+  pipe_fd_ = HANDLE_EINTR(open(
+      pipe_name.value().c_str(), O_RDONLY | O_NONBLOCK));
+  if (pipe_fd_ < 0) {
+    LOG(ERROR) << "Failed to open " << pipe_name.value();
+    return;
+  }
+
+  // Set buffer size for the pipe to the double of what's required for samples
+  // of each capturing period.
+  int pipe_buffer_size = 2 * kCapturingPeriodMs * kSamplingRate * kChannels *
+     kBytesPerSample / base::Time::kMillisecondsPerSecond;
+  int result = HANDLE_EINTR(fcntl(pipe_fd_, F_SETPIPE_SZ, pipe_buffer_size));
+  if (result < 0) {
+    PLOG(ERROR) << "fcntl";
+  }
+
+  Sleep();
+}
+
+AudioCapturerLinux::~AudioCapturerLinux() {
+}
+
+bool AudioCapturerLinux::Start(const PacketCapturedCallback& callback) {
+  if (pipe_fd_ < 0)
+    return false;
+
+  callback_ = callback;
+
+  return true;
+}
+
+void AudioCapturerLinux::Stop() {
+  callback_.Reset();
+}
+
+bool AudioCapturerLinux::IsRunning() {
+  return !callback_.is_null();
+}
+
+void AudioCapturerLinux::OnFileCanReadWithoutBlocking(int fd) {
+  DCHECK_EQ(fd, pipe_fd_);
+  StartTimer();
+}
+
+void AudioCapturerLinux::OnFileCanWriteWithoutBlocking(int fd) {

[Wez, 2012/09/04 21:41:45]

nit: NOTREACHED()?

[Sergey Ulanov, 2012/09/05 01:35:49]

Done.

+}
+
+void AudioCapturerLinux::StartTimer() {
+  started_time_ = base::TimeTicks::Now();
+  last_capture_time_samples_ = 0;
+  timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(kCapturingPeriodMs),
+               this, &AudioCapturerLinux::DoCapture);
+}
+
+void AudioCapturerLinux::DoCapture() {
+  DCHECK_GT(pipe_fd_, 0);
+
+  base::TimeDelta stream_position = base::TimeTicks::Now() - started_time_;
+  int64 stream_position_samples = stream_position.InMilliseconds() *
+      kSamplingRate / base::Time::kMillisecondsPerSecond;
+  int64 samples_to_capture =
+      stream_position_samples - last_capture_time_samples_;

[Wez, 2012/09/04 21:41:46]

Do you need these calculations, and timers going off? Can't you just wait for
the pipe to be readable and then read until EWOULDBLOCK to keep in sync with
PulseAudio?

[Sergey Ulanov, 2012/09/05 01:35:49]

No. PulseAudio's pipe sink plugin doesn't control rate with which it pushes data
to the pipe, so we have to do it here. If we read all available data then pulse
will keep pushing it, which means we will be receiving much more than 44100
samples per second.

+  last_capture_time_samples_ = stream_position_samples;
+  int64 read_size =
+      samples_to_capture * kChannels * kBytesPerSample;
+
+  std::string data;
+  data.resize(read_size);
+  int pos = 0;
+  while (pos < read_size) {
+    int read_result = HANDLE_EINTR(
+       read(pipe_fd_, string_as_array(&data) + pos, read_size - pos));
+    if (read_result >= 0) {
+      pos += read_result;
+    } else {
+      if (read_result != EWOULDBLOCK && read_result != EAGAIN)
+        PLOG(ERROR) << "read";
+      break;
+    }
+  }
+
+  if (pos == 0) {
+    Sleep();
+    return;
+  }
+
+  if (!callback_.is_null()) {
+    data.resize(pos);
+
+    scoped_ptr<AudioPacket> packet(new AudioPacket());
+    packet->add_data(data);
+    packet->set_encoding(AudioPacket::ENCODING_RAW);
+    packet->set_sampling_rate(kSamplingRate);
+    packet->set_bytes_per_sample(AudioPacket::BYTES_PER_SAMPLE_2);
+    packet->set_channels(AudioPacket::CHANNELS_STEREO);
+    callback_.Run(packet.Pass());
+  }
+}
+
+void AudioCapturerLinux::Sleep() {
+  timer_.Stop();
+  MessageLoopForIO::current()->WatchFileDescriptor(
+      pipe_fd_, false, MessageLoopForIO::WATCH_READ,
+      &file_descriptor_watcher_, this);
+}
+
 scoped_ptr<AudioCapturer> AudioCapturer::Create() {
-  NOTIMPLEMENTED();
-  return scoped_ptr<AudioCapturer>(NULL);
+  CommandLine* cl = CommandLine::ForCurrentProcess();
+  FilePath path = cl->GetSwitchValuePath(kAudioPipeOptionName);
+  if (path.empty())
+    return scoped_ptr<AudioCapturer>();
+  return scoped_ptr<AudioCapturer>(new AudioCapturerLinux(path));
 }
 
 }  // namespace remoting