cras/src/tests/loopback_iodev_unittest.cc - platform/external/adhd - Git at Google

 // Copyright (c) 2013 The Chromium OS 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 <gtest/gtest.h>
 #include <stdio.h>
 #include <stdlib.h>

 extern "C" {
 // For audio_thread_log.h use.
 struct audio_thread_event_log* atlog;
 int atlog_rw_shm_fd;
 int atlog_ro_shm_fd;
 #include "audio_thread_log.h"
 #include "cras_audio_area.h"
 #include "cras_iodev.h"
 #include "cras_iodev_list.h"
 #include "cras_loopback_iodev.h"
 #include "cras_shm.h"
 #include "cras_types.h"
 #include "dev_stream.h"
 #include "utlist.h"
 }

 namespace {

 static const unsigned int kBufferFrames = 16384;
 static const unsigned int kFrameBytes = 4;
 static const unsigned int kBufferSize = kBufferFrames * kFrameBytes;

 static struct timespec time_now;
 static cras_audio_area* mock_audio_area;
 static loopback_hook_data_t loop_hook;
 static struct cras_iodev* enabled_dev;
 static unsigned int cras_iodev_list_add_input_called;
 static unsigned int cras_iodev_list_rm_input_called;
 static unsigned int cras_iodev_list_set_device_enabled_callback_called;
 static device_enabled_callback_t device_enabled_callback_cb;
 static device_disabled_callback_t device_disabled_callback_cb;
 static void* device_enabled_callback_cb_data;
 static int cras_iodev_list_register_loopback_called;
 static int cras_iodev_list_unregister_loopback_called;

 static char* atlog_name;

 class LoopBackTestSuite : public testing::Test {
  protected:
   virtual void SetUp() {
     mock_audio_area = (cras_audio_area*)calloc(
         1, sizeof(*mock_audio_area) + sizeof(cras_channel_area) * 2);
     for (unsigned int i = 0; i < kBufferSize; i++) {
       buf_[i] = rand();
     }
     fmt_.frame_rate = 48000;
     fmt_.num_channels = 2;
     fmt_.format = SND_PCM_FORMAT_S16_LE;

     loop_in_ = loopback_iodev_create(LOOPBACK_POST_MIX_PRE_DSP);
     EXPECT_EQ(1, cras_iodev_list_add_input_called);
     loop_in_->format = &fmt_;

     loop_hook = NULL;
     cras_iodev_list_add_input_called = 0;
     cras_iodev_list_rm_input_called = 0;
     cras_iodev_list_set_device_enabled_callback_called = 0;
     cras_iodev_list_register_loopback_called = 0;
     cras_iodev_list_unregister_loopback_called = 0;

     ASSERT_FALSE(asprintf(&atlog_name, "/ATlog-%d", getpid()) < 0);
     /* To avoid un-used variable warning. */
     atlog_rw_shm_fd = atlog_ro_shm_fd = -1;
     atlog = audio_thread_event_log_init(atlog_name);
   }

   virtual void TearDown() {
     loopback_iodev_destroy(loop_in_);
     EXPECT_EQ(1, cras_iodev_list_rm_input_called);
     EXPECT_EQ(NULL, device_enabled_callback_cb);
     EXPECT_EQ(NULL, device_disabled_callback_cb);
     free(mock_audio_area);
     audio_thread_event_log_deinit(atlog, atlog_name);
     free(atlog_name);
   }

   uint8_t buf_[kBufferSize];
   struct cras_audio_format fmt_;
   struct cras_iodev* loop_in_;
 };

 TEST_F(LoopBackTestSuite, InstallLoopHook) {
   struct cras_iodev iodev;
   struct timespec tstamp;

   iodev.direction = CRAS_STREAM_OUTPUT;
   iodev.format = &fmt_;
   iodev.streams = NULL;
   iodev.info.idx = 123;
   enabled_dev = &iodev;

   // Open loopback devices.
   EXPECT_EQ(0, loop_in_->configure_dev(loop_in_));
   EXPECT_EQ(1, cras_iodev_list_set_device_enabled_callback_called);
   EXPECT_EQ(1, cras_iodev_list_register_loopback_called);

   // Signal an output device is enabled.
   device_enabled_callback_cb(&iodev, device_enabled_callback_cb_data);

   // Expect that a hook was added to the iodev
   EXPECT_EQ(2, cras_iodev_list_register_loopback_called);
   ASSERT_NE(reinterpret_cast<loopback_hook_data_t>(NULL), loop_hook);

   // Check zero frames queued.
   EXPECT_EQ(0, loop_in_->frames_queued(loop_in_, &tstamp));

   device_disabled_callback_cb(&iodev, device_enabled_callback_cb_data);
   EXPECT_EQ(1, cras_iodev_list_unregister_loopback_called);
   EXPECT_EQ(3, cras_iodev_list_register_loopback_called);

   enabled_dev->info.idx = 456;
   device_enabled_callback_cb(&iodev, device_enabled_callback_cb_data);
   EXPECT_EQ(4, cras_iodev_list_register_loopback_called);

   // Close loopback devices.
   EXPECT_EQ(0, loop_in_->close_dev(loop_in_));
   EXPECT_EQ(2, cras_iodev_list_unregister_loopback_called);
   EXPECT_EQ(2, cras_iodev_list_set_device_enabled_callback_called);
 }

 TEST_F(LoopBackTestSuite, SelectDevFromAToB) {
   struct cras_iodev iodev1, iodev2;

   iodev1.direction = CRAS_STREAM_OUTPUT;
   iodev2.direction = CRAS_STREAM_OUTPUT;
   enabled_dev = &iodev1;

   enabled_dev->info.idx = 111;
   EXPECT_EQ(0, loop_in_->configure_dev(loop_in_));
   EXPECT_EQ(1, cras_iodev_list_set_device_enabled_callback_called);
   EXPECT_EQ(1, cras_iodev_list_register_loopback_called);

   /* Not the current sender being disabled, assert unregister not called. */
   iodev2.info.idx = 222;
   device_disabled_callback_cb(&iodev2, device_enabled_callback_cb_data);
   EXPECT_EQ(0, cras_iodev_list_unregister_loopback_called);
   EXPECT_EQ(1, cras_iodev_list_register_loopback_called);

   enabled_dev = &iodev2;
   device_disabled_callback_cb(&iodev1, device_enabled_callback_cb_data);
   EXPECT_EQ(1, cras_iodev_list_unregister_loopback_called);
   EXPECT_EQ(2, cras_iodev_list_register_loopback_called);

   EXPECT_EQ(0, loop_in_->close_dev(loop_in_));
 }

 // Test how loopback works if there isn't any output devices open.
 TEST_F(LoopBackTestSuite, OpenIdleSystem) {
   cras_audio_area* area;
   unsigned int nread = 1024;
   struct timespec tstamp;
   int rc;

   // No active output device.
   enabled_dev = NULL;
   time_now.tv_sec = 100;
   time_now.tv_nsec = 0;

   EXPECT_EQ(0, loop_in_->configure_dev(loop_in_));
   EXPECT_EQ(1, cras_iodev_list_set_device_enabled_callback_called);

   // Should be 480 samples after 480/frame rate seconds
   time_now.tv_nsec += 480 * 1e9 / 48000;
   EXPECT_EQ(480, loop_in_->frames_queued(loop_in_, &tstamp));

   // Verify frames from loopback record.
   loop_in_->get_buffer(loop_in_, &area, &nread);
   EXPECT_EQ(480, nread);
   memset(buf_, 0, nread * kFrameBytes);
   rc = memcmp(area->channels[0].buf, buf_, nread * kFrameBytes);
   EXPECT_EQ(0, rc);
   loop_in_->put_buffer(loop_in_, nread);

   // Check zero frames queued.
   EXPECT_EQ(0, loop_in_->frames_queued(loop_in_, &tstamp));

   EXPECT_EQ(0, loop_in_->close_dev(loop_in_));
 }

 TEST_F(LoopBackTestSuite, SimpleLoopback) {
   cras_audio_area* area;
   unsigned int nframes = 1024;
   unsigned int nread = 1024;
   int rc;
   struct cras_iodev iodev;
   struct dev_stream stream;
   struct timespec tstamp;

   iodev.streams = &stream;
   enabled_dev = &iodev;

   loop_in_->configure_dev(loop_in_);
   ASSERT_NE(reinterpret_cast<void*>(NULL), loop_hook);

   // Loopback callback for the hook.
   loop_hook(buf_, nframes, &fmt_, loop_in_);

   // Verify frames from loopback record.
   loop_in_->get_buffer(loop_in_, &area, &nread);
   EXPECT_EQ(nframes, nread);
   rc = memcmp(area->channels[0].buf, buf_, nframes * kFrameBytes);
   EXPECT_EQ(0, rc);
   loop_in_->put_buffer(loop_in_, nread);

   // Check zero frames queued.
   EXPECT_EQ(0, loop_in_->frames_queued(loop_in_, &tstamp));

   EXPECT_EQ(0, loop_in_->close_dev(loop_in_));
 }

 // TODO(chinyue): Test closing last iodev while streaming loopback data.

 /* Stubs */
 extern "C" {

 void cras_audio_area_config_buf_pointers(struct cras_audio_area* area,
                                          const struct cras_audio_format* fmt,
                                          uint8_t* base_buffer) {
   mock_audio_area->channels[0].buf = base_buffer;
 }

 void cras_iodev_free_audio_area(struct cras_iodev* iodev) {}

 void cras_iodev_free_format(struct cras_iodev* iodev) {}

 void cras_iodev_init_audio_area(struct cras_iodev* iodev, int num_channels) {
   iodev->area = mock_audio_area;
 }

 void cras_iodev_add_node(struct cras_iodev* iodev, struct cras_ionode* node) {
   DL_APPEND(iodev->nodes, node);
 }

 void cras_iodev_set_active_node(struct cras_iodev* iodev,
                                 struct cras_ionode* node) {}
 void cras_iodev_list_register_loopback(enum CRAS_LOOPBACK_TYPE loopback_type,
                                        unsigned int output_dev_idx,
                                        loopback_hook_data_t hook_data,
                                        loopback_hook_control_t hook_start,
                                        unsigned int loopback_dev_idx) {
   cras_iodev_list_register_loopback_called++;
   loop_hook = hook_data;
 }

 void cras_iodev_list_unregister_loopback(enum CRAS_LOOPBACK_TYPE loopback_type,
                                          unsigned int output_dev_idx,
                                          unsigned int loopback_dev_idx) {
   cras_iodev_list_unregister_loopback_called++;
 }

 int cras_iodev_list_add_input(struct cras_iodev* input) {
   cras_iodev_list_add_input_called++;
   return 0;
 }

 int cras_iodev_list_rm_input(struct cras_iodev* input) {
   cras_iodev_list_rm_input_called++;
   return 0;
 }

 int cras_iodev_list_set_device_enabled_callback(
     device_enabled_callback_t enabled_cb,
     device_disabled_callback_t disabled_cb,
     void* cb_data) {
   cras_iodev_list_set_device_enabled_callback_called++;
   device_enabled_callback_cb = enabled_cb;
   device_disabled_callback_cb = disabled_cb;
   device_enabled_callback_cb_data = cb_data;
   return 0;
 }

 int clock_gettime(clockid_t clk_id, struct timespec* tp) {
   *tp = time_now;
   return 0;
 }

 struct cras_iodev* cras_iodev_list_get_first_enabled_iodev(
     enum CRAS_STREAM_DIRECTION direction) {
   return enabled_dev;
 }

 }  // extern "C"

 }  //  namespace

 int main(int argc, char** argv) {
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }
	// Copyright (c) 2013 The Chromium OS 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 <gtest/gtest.h>
	#include <stdio.h>
	#include <stdlib.h>

	extern "C" {
	// For audio_thread_log.h use.
	struct audio_thread_event_log* atlog;
	int atlog_rw_shm_fd;
	int atlog_ro_shm_fd;
	#include "audio_thread_log.h"
	#include "cras_audio_area.h"
	#include "cras_iodev.h"
	#include "cras_iodev_list.h"
	#include "cras_loopback_iodev.h"
	#include "cras_shm.h"
	#include "cras_types.h"
	#include "dev_stream.h"
	#include "utlist.h"
	}

	namespace {

	static const unsigned int kBufferFrames = 16384;
	static const unsigned int kFrameBytes = 4;
	static const unsigned int kBufferSize = kBufferFrames * kFrameBytes;

	static struct timespec time_now;
	static cras_audio_area* mock_audio_area;
	static loopback_hook_data_t loop_hook;
	static struct cras_iodev* enabled_dev;
	static unsigned int cras_iodev_list_add_input_called;
	static unsigned int cras_iodev_list_rm_input_called;
	static unsigned int cras_iodev_list_set_device_enabled_callback_called;
	static device_enabled_callback_t device_enabled_callback_cb;
	static device_disabled_callback_t device_disabled_callback_cb;
	static void* device_enabled_callback_cb_data;
	static int cras_iodev_list_register_loopback_called;
	static int cras_iodev_list_unregister_loopback_called;

	static char* atlog_name;

	class LoopBackTestSuite : public testing::Test {
	protected:
	virtual void SetUp() {
	mock_audio_area = (cras_audio_area*)calloc(
	1, sizeof(mock_audio_area) + sizeof(cras_channel_area) 2);
	for (unsigned int i = 0; i < kBufferSize; i++) {
	buf_[i] = rand();
	}
	fmt_.frame_rate = 48000;
	fmt_.num_channels = 2;
	fmt_.format = SND_PCM_FORMAT_S16_LE;

	loop_in_ = loopback_iodev_create(LOOPBACK_POST_MIX_PRE_DSP);
	EXPECT_EQ(1, cras_iodev_list_add_input_called);
	loop_in_->format = &fmt_;

	loop_hook = NULL;
	cras_iodev_list_add_input_called = 0;
	cras_iodev_list_rm_input_called = 0;
	cras_iodev_list_set_device_enabled_callback_called = 0;
	cras_iodev_list_register_loopback_called = 0;
	cras_iodev_list_unregister_loopback_called = 0;

	ASSERT_FALSE(asprintf(&atlog_name, "/ATlog-%d", getpid()) < 0);
	/* To avoid un-used variable warning. */
	atlog_rw_shm_fd = atlog_ro_shm_fd = -1;
	atlog = audio_thread_event_log_init(atlog_name);
	}

	virtual void TearDown() {
	loopback_iodev_destroy(loop_in_);
	EXPECT_EQ(1, cras_iodev_list_rm_input_called);
	EXPECT_EQ(NULL, device_enabled_callback_cb);
	EXPECT_EQ(NULL, device_disabled_callback_cb);
	free(mock_audio_area);
	audio_thread_event_log_deinit(atlog, atlog_name);
	free(atlog_name);
	}

	uint8_t buf_[kBufferSize];
	struct cras_audio_format fmt_;
	struct cras_iodev* loop_in_;
	};

	TEST_F(LoopBackTestSuite, InstallLoopHook) {
	struct cras_iodev iodev;
	struct timespec tstamp;

	iodev.direction = CRAS_STREAM_OUTPUT;
	iodev.format = &fmt_;
	iodev.streams = NULL;
	iodev.info.idx = 123;
	enabled_dev = &iodev;

	// Open loopback devices.
	EXPECT_EQ(0, loop_in_->configure_dev(loop_in_));
	EXPECT_EQ(1, cras_iodev_list_set_device_enabled_callback_called);
	EXPECT_EQ(1, cras_iodev_list_register_loopback_called);

	// Signal an output device is enabled.
	device_enabled_callback_cb(&iodev, device_enabled_callback_cb_data);

	// Expect that a hook was added to the iodev
	EXPECT_EQ(2, cras_iodev_list_register_loopback_called);
	ASSERT_NE(reinterpret_cast<loopback_hook_data_t>(NULL), loop_hook);

	// Check zero frames queued.
	EXPECT_EQ(0, loop_in_->frames_queued(loop_in_, &tstamp));

	device_disabled_callback_cb(&iodev, device_enabled_callback_cb_data);
	EXPECT_EQ(1, cras_iodev_list_unregister_loopback_called);
	EXPECT_EQ(3, cras_iodev_list_register_loopback_called);

	enabled_dev->info.idx = 456;
	device_enabled_callback_cb(&iodev, device_enabled_callback_cb_data);
	EXPECT_EQ(4, cras_iodev_list_register_loopback_called);

	// Close loopback devices.
	EXPECT_EQ(0, loop_in_->close_dev(loop_in_));
	EXPECT_EQ(2, cras_iodev_list_unregister_loopback_called);
	EXPECT_EQ(2, cras_iodev_list_set_device_enabled_callback_called);
	}

	TEST_F(LoopBackTestSuite, SelectDevFromAToB) {
	struct cras_iodev iodev1, iodev2;

	iodev1.direction = CRAS_STREAM_OUTPUT;
	iodev2.direction = CRAS_STREAM_OUTPUT;
	enabled_dev = &iodev1;

	enabled_dev->info.idx = 111;
	EXPECT_EQ(0, loop_in_->configure_dev(loop_in_));
	EXPECT_EQ(1, cras_iodev_list_set_device_enabled_callback_called);
	EXPECT_EQ(1, cras_iodev_list_register_loopback_called);

	/* Not the current sender being disabled, assert unregister not called. */
	iodev2.info.idx = 222;
	device_disabled_callback_cb(&iodev2, device_enabled_callback_cb_data);
	EXPECT_EQ(0, cras_iodev_list_unregister_loopback_called);
	EXPECT_EQ(1, cras_iodev_list_register_loopback_called);

	enabled_dev = &iodev2;
	device_disabled_callback_cb(&iodev1, device_enabled_callback_cb_data);
	EXPECT_EQ(1, cras_iodev_list_unregister_loopback_called);
	EXPECT_EQ(2, cras_iodev_list_register_loopback_called);

	EXPECT_EQ(0, loop_in_->close_dev(loop_in_));
	}

	// Test how loopback works if there isn't any output devices open.
	TEST_F(LoopBackTestSuite, OpenIdleSystem) {
	cras_audio_area* area;
	unsigned int nread = 1024;
	struct timespec tstamp;
	int rc;

	// No active output device.
	enabled_dev = NULL;
	time_now.tv_sec = 100;
	time_now.tv_nsec = 0;

	EXPECT_EQ(0, loop_in_->configure_dev(loop_in_));
	EXPECT_EQ(1, cras_iodev_list_set_device_enabled_callback_called);

	// Should be 480 samples after 480/frame rate seconds
	time_now.tv_nsec += 480 * 1e9 / 48000;
	EXPECT_EQ(480, loop_in_->frames_queued(loop_in_, &tstamp));

	// Verify frames from loopback record.
	loop_in_->get_buffer(loop_in_, &area, &nread);
	EXPECT_EQ(480, nread);
	memset(buf_, 0, nread * kFrameBytes);
	rc = memcmp(area->channels[0].buf, buf_, nread * kFrameBytes);
	EXPECT_EQ(0, rc);
	loop_in_->put_buffer(loop_in_, nread);

	// Check zero frames queued.
	EXPECT_EQ(0, loop_in_->frames_queued(loop_in_, &tstamp));

	EXPECT_EQ(0, loop_in_->close_dev(loop_in_));
	}

	TEST_F(LoopBackTestSuite, SimpleLoopback) {
	cras_audio_area* area;
	unsigned int nframes = 1024;
	unsigned int nread = 1024;
	int rc;
	struct cras_iodev iodev;
	struct dev_stream stream;
	struct timespec tstamp;

	iodev.streams = &stream;
	enabled_dev = &iodev;

	loop_in_->configure_dev(loop_in_);
	ASSERT_NE(reinterpret_cast<void*>(NULL), loop_hook);

	// Loopback callback for the hook.
	loop_hook(buf_, nframes, &fmt_, loop_in_);

	// Verify frames from loopback record.
	loop_in_->get_buffer(loop_in_, &area, &nread);
	EXPECT_EQ(nframes, nread);
	rc = memcmp(area->channels[0].buf, buf_, nframes * kFrameBytes);
	EXPECT_EQ(0, rc);
	loop_in_->put_buffer(loop_in_, nread);

	// Check zero frames queued.
	EXPECT_EQ(0, loop_in_->frames_queued(loop_in_, &tstamp));

	EXPECT_EQ(0, loop_in_->close_dev(loop_in_));
	}

	// TODO(chinyue): Test closing last iodev while streaming loopback data.

	/* Stubs */
	extern "C" {

	void cras_audio_area_config_buf_pointers(struct cras_audio_area* area,
	const struct cras_audio_format* fmt,
	uint8_t* base_buffer) {
	mock_audio_area->channels[0].buf = base_buffer;
	}

	void cras_iodev_free_audio_area(struct cras_iodev* iodev) {}

	void cras_iodev_free_format(struct cras_iodev* iodev) {}

	void cras_iodev_init_audio_area(struct cras_iodev* iodev, int num_channels) {
	iodev->area = mock_audio_area;
	}

	void cras_iodev_add_node(struct cras_iodev* iodev, struct cras_ionode* node) {
	DL_APPEND(iodev->nodes, node);
	}

	void cras_iodev_set_active_node(struct cras_iodev* iodev,
	struct cras_ionode* node) {}
	void cras_iodev_list_register_loopback(enum CRAS_LOOPBACK_TYPE loopback_type,
	unsigned int output_dev_idx,
	loopback_hook_data_t hook_data,
	loopback_hook_control_t hook_start,
	unsigned int loopback_dev_idx) {
	cras_iodev_list_register_loopback_called++;
	loop_hook = hook_data;
	}

	void cras_iodev_list_unregister_loopback(enum CRAS_LOOPBACK_TYPE loopback_type,
	unsigned int output_dev_idx,
	unsigned int loopback_dev_idx) {
	cras_iodev_list_unregister_loopback_called++;
	}

	int cras_iodev_list_add_input(struct cras_iodev* input) {
	cras_iodev_list_add_input_called++;
	return 0;
	}

	int cras_iodev_list_rm_input(struct cras_iodev* input) {
	cras_iodev_list_rm_input_called++;
	return 0;
	}

	int cras_iodev_list_set_device_enabled_callback(
	device_enabled_callback_t enabled_cb,
	device_disabled_callback_t disabled_cb,
	void* cb_data) {
	cras_iodev_list_set_device_enabled_callback_called++;
	device_enabled_callback_cb = enabled_cb;
	device_disabled_callback_cb = disabled_cb;
	device_enabled_callback_cb_data = cb_data;
	return 0;
	}

	int clock_gettime(clockid_t clk_id, struct timespec* tp) {
	*tp = time_now;
	return 0;
	}

	struct cras_iodev* cras_iodev_list_get_first_enabled_iodev(
	enum CRAS_STREAM_DIRECTION direction) {
	return enabled_dev;
	}

	} // extern "C"

	} // namespace

	int main(int argc, char** argv) {
	::testing::InitGoogleTest(&argc, argv);
	return RUN_ALL_TESTS();
	}