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

[no longer working on chromium, 2012/06/25 15:59:27]

skip checking 

[dgreid, 2012/06/25 21:29:28]

Done.

+  // 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());

[no longer working on chromium, 2012/06/25 15:59:27]

I am wondering what is preventing using audio_manager->MakeAudioInputStream?

[dgreid, 2012/06/25 21:29:28]

Isn't that something that belongs in an AudioManager unit test?

[no longer working on chromium, 2012/06/26 21:42:49]

We don't have the specific AudioManager unit test, and usually we test it in the
platform specific unittest like this.
I know the Cras class in behind a flag, so if it is not easy, please ignore my
comment. Otherwise we prefer using MakeAudioInputStream. 

+  }
+
+  void CaptureSomeFrames(const AudioParameters &params,
+                         unsigned int duration_ms) {
+    CrasInputStream* test_stream = new CrasInputStream(params,

[no longer working on chromium, 2012/06/25 15:59:27]

Use CreateStream() here?

[dgreid, 2012/06/25 21:29:28]

CreateStream is used to create a stream with the default settings specified by
kTestBitsPerSample and friends.  This needs to override those defaults so
calling CreateStream doesn't work.

[no longer working on chromium, 2012/06/26 21:42:49]

The code looks much cleaner if we only use one way to create the stream.
What about passing AudioParameters to CreateStream as input for the case
overriding the defaults?

+                                                       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);
+
+    test_stream->Stop();
+
+    EXPECT_CALL(mock_callback, OnClose(test_stream)).Times(1);
+    test_stream->Close();
+  }
+
+  static const unsigned int kTestBitsPerSample;

[no longer working on chromium, 2012/06/25 15:59:27]

Isn't it easier to extend the tests if we put these variables to members, and
overwrite them for different values when creating streams.

[dgreid, 2012/06/25 21:29:28]

These are just meant as defaults, When they need to be over-ridden it is best to
create audio parameters with each value set explicitly.

+  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());

[no longer working on chromium, 2012/06/25 15:59:27]

We can use CreateStream instead.

+  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());

[no longer working on chromium, 2012/06/25 15:59:27]

ditto

+  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, 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