media/audio/linux: Add CrasInputStream.

media/audio/linux/cras_input_unittest.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 <unistd.h>
+
+#include <string>
+
+#include "base/time.h"
+#include "media/audio/linux/audio_manager_linux.h"
+#include "media/audio/linux/cras_input.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using testing::_;
+using testing::AtLeast;
+using testing::Ge;
+using testing::StrictMock;
+
+namespace media {
+
+class MockAudioInputCallback : public AudioInputStream::AudioInputCallback {
+ public:
+  MOCK_METHOD5(OnData, void(
+      AudioInputStream*, const uint8*, uint32, uint32, double));
+  MOCK_METHOD2(OnError, void(AudioInputStream*, int));
+  MOCK_METHOD1(OnClose, void(AudioInputStream*));
+};
+
+class MockAudioManagerLinuxInput : public AudioManagerLinux {
+ public:
+  // We need to override this function in order to skip the checking the number
+  // of active output streams. It is because the number of active streams
+  // is managed inside MakeAudioInputStream, and we don't use
+  // MakeAudioInputStream to create the stream in the tests.
+  virtual void ReleaseInputStream(AudioInputStream* stream) OVERRIDE {
+    DCHECK(stream);
+    delete stream;
+  }
+};
+
+class CrasInputStreamTest : public testing::Test {
+ protected:
+  CrasInputStreamTest() {
+    mock_manager_.reset(new StrictMock<MockAudioManagerLinuxInput>());
+  }
+
+  virtual ~CrasInputStreamTest() {
+  }
+
+  CrasInputStream* CreateStream(ChannelLayout layout) {
+    return CreateStream(layout, kTestFramesPerPacket);
+  }
+
+  CrasInputStream* CreateStream(ChannelLayout layout,
+                                int32 samples_per_packet) {
+    AudioParameters params(kTestFormat,
+                           layout,
+                           kTestSampleRate,
+                           kTestBitsPerSample,
+                           samples_per_packet);
+    return new CrasInputStream(params, mock_manager_.get());
+  }
+
+  void CaptureSomeFrames(const AudioParameters &params,
+                         unsigned int duration_ms) {
+    CrasInputStream* test_stream = new CrasInputStream(params,
+                                                       mock_manager_.get());
+
+    ASSERT_TRUE(test_stream->Open());
+
+    // Allow 8 frames variance for SRC in the callback.  Different numbers of
+    // samples can be provided when doing non-integer SRC.  For example
+    // converting from 192k to 44.1k is a ratio of 4.35 to 1.
+    MockAudioInputCallback mock_callback;
+    unsigned int expected_size = (kTestFramesPerPacket - 8) *
+                                 params.channels() *
+                                 params.bits_per_sample() / 8;
+    EXPECT_CALL(mock_callback,
+                OnData(test_stream, _, Ge(expected_size), _, _))
+        .Times(AtLeast(1));
+
+    test_stream->Start(&mock_callback);
+
+    usleep(duration_ms * base::Time::kMillisecondsPerSecond);

[scherkus (not reviewing), 2012/06/26 22:10:10]

when running on build bots if OnData() isn't called within the 250ms deadline
we'll get a gmock failure

a less flaky solution is to use a WaitableEvent that is signaled in the
expectation to OnData()

base::WaitableEvent event(false, false);
EXPECT_CALL(...)
    .WillRepeatedly(InvokeWithoutArgs(&event, &base::WaitableEvent::Signal));
EXPECT_TRUE(event.TimedWait(base::TestTimeouts::action_timeout_ms());

Check out audio_output_controller_unittest.cc:
http://code.google.com/searchframe#OAMlx_jo-ck/src/media/audio/audio_output_c...

the syntax is a little hairy so if you don't want to clutter the test code you
could alternatively have the MockAudioInputCallback class have a WaitableEvent
itself and implement OnData() to signal, and expose a WaitForOnData() method (or
similar) 

[dgreid, 2012/06/27 07:58:07]

Slick, Since being called once is sufficient, this with a WillOnce() makes the
test way faster, Thanks!

+
+    EXPECT_CALL(mock_callback, OnClose(test_stream)).Times(1);
+    test_stream->Stop();
+
+    test_stream->Close();
+  }
+
+  static const unsigned int kTestBitsPerSample;
+  static const unsigned int kTestCaptureDurationMs;
+  static const ChannelLayout kTestChannelLayout;
+  static const AudioParameters::Format kTestFormat;
+  static const uint32 kTestFramesPerPacket;
+  static const int kTestSampleRate;
+
+  scoped_ptr<StrictMock<MockAudioManagerLinuxInput> > mock_manager_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CrasInputStreamTest);
+};
+
+const unsigned int CrasInputStreamTest::kTestBitsPerSample = 16;
+const unsigned int CrasInputStreamTest::kTestCaptureDurationMs = 250;
+const ChannelLayout CrasInputStreamTest::kTestChannelLayout =
+    CHANNEL_LAYOUT_STEREO;
+const AudioParameters::Format CrasInputStreamTest::kTestFormat =
+    AudioParameters::AUDIO_PCM_LINEAR;
+const uint32 CrasInputStreamTest::kTestFramesPerPacket = 1000;
+const int CrasInputStreamTest::kTestSampleRate = 44100;
+
+TEST_F(CrasInputStreamTest, OpenMono) {
+  CrasInputStream* test_stream = CreateStream(CHANNEL_LAYOUT_MONO);
+  EXPECT_TRUE(test_stream->Open());
+  test_stream->Close();
+}
+
+TEST_F(CrasInputStreamTest, OpenStereo) {
+  CrasInputStream* test_stream = CreateStream(CHANNEL_LAYOUT_STEREO);
+  EXPECT_TRUE(test_stream->Open());
+  test_stream->Close();
+}
+
+TEST_F(CrasInputStreamTest, BadBitsPerSample) {
+  AudioParameters bad_bps_params(kTestFormat,
+                                 kTestChannelLayout,
+                                 kTestSampleRate,
+                                 kTestBitsPerSample - 1,
+                                 kTestFramesPerPacket);
+  CrasInputStream* test_stream =
+      new CrasInputStream(bad_bps_params, mock_manager_.get());
+  EXPECT_FALSE(test_stream->Open());
+  test_stream->Close();
+}
+
+TEST_F(CrasInputStreamTest, BadFormat) {
+  AudioParameters bad_format_params(AudioParameters::AUDIO_LAST_FORMAT,
+                                    kTestChannelLayout,
+                                    kTestSampleRate,
+                                    kTestBitsPerSample,
+                                    kTestFramesPerPacket);
+  CrasInputStream* test_stream =
+      new CrasInputStream(bad_format_params, mock_manager_.get());
+  EXPECT_FALSE(test_stream->Open());
+  test_stream->Close();
+}
+
+TEST_F(CrasInputStreamTest, BadSampleRate) {
+  AudioParameters bad_rate_params(kTestFormat,
+                                  kTestChannelLayout,
+                                  0,
+                                  kTestBitsPerSample,
+                                  kTestFramesPerPacket);
+  CrasInputStream* test_stream =
+      new CrasInputStream(bad_rate_params, mock_manager_.get());
+  EXPECT_FALSE(test_stream->Open());
+  test_stream->Close();
+}
+
+TEST_F(CrasInputStreamTest, DoubleStart) {
+  AudioParameters bad_rate_params(kTestFormat,
+                                  kTestChannelLayout,
+                                  kTestSampleRate,
+                                  kTestBitsPerSample,
+                                  kTestFramesPerPacket);
+  CrasInputStream* test_stream =
+      new CrasInputStream(bad_rate_params, mock_manager_.get());
+  ASSERT_TRUE(test_stream->Open());
+
+  // Start the stream with one callback.
+  MockAudioInputCallback mock_callback;
+  EXPECT_CALL(mock_callback, OnData(test_stream, _, _, _, _))
+      .Times(AtLeast(1));
+  test_stream->Start(&mock_callback);
+
+  usleep(kTestCaptureDurationMs * base::Time::kMillisecondsPerSecond);
+
+  // Then re-start the stream with a seconds callback.

[scherkus (not reviewing), 2012/06/26 22:10:10]

s/seconds/second

[dgreid, 2012/06/27 07:58:07]

removed.

+  MockAudioInputCallback mock_callback2;
+  EXPECT_CALL(mock_callback, OnClose(test_stream)).Times(1);
+  EXPECT_CALL(mock_callback2, OnData(test_stream, _, _, _, _))
+      .Times(AtLeast(1));
+  test_stream->Start(&mock_callback2);
+
+  usleep(kTestCaptureDurationMs * base::Time::kMillisecondsPerSecond);
+
+  EXPECT_CALL(mock_callback2, OnClose(test_stream)).Times(1);
+  test_stream->Stop();
+
+  test_stream->Close();
+}
+
+TEST_F(CrasInputStreamTest, CaptureFrames) {
+  const unsigned int rates[] =
+      {8000, 16000, 22050, 32000, 44100, 48000, 96000, 192000};
+
+  for (unsigned int i = 0; i < ARRAY_SIZE(rates); i++) {
+    AudioParameters params_mono(kTestFormat,
+                                CHANNEL_LAYOUT_MONO,
+                                rates[i],
+                                kTestBitsPerSample,
+                                kTestFramesPerPacket);
+    CaptureSomeFrames(params_mono, kTestCaptureDurationMs);
+
+    AudioParameters params_stereo(kTestFormat,
+                                  CHANNEL_LAYOUT_STEREO,
+                                  rates[i],
+                                  kTestBitsPerSample,
+                                  kTestFramesPerPacket);
+    CaptureSomeFrames(params_stereo, kTestCaptureDurationMs);
+  }
+}
+
+}  // namespace media