cras/src/server/cras_a2dp_endpoint.c - platform/external/adhd - Git at Google

 /* Copyright (c) 2013 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 <errno.h>
 #include <stdint.h>
 #include <syslog.h>

 #include "a2dp-codecs.h"
 #include "cras_a2dp_endpoint.h"
 #include "cras_a2dp_iodev.h"
 #include "cras_iodev.h"
 #include "cras_bt_constants.h"
 #include "cras_bt_endpoint.h"
 #include "cras_bt_log.h"
 #include "cras_system_state.h"
 #include "cras_util.h"

 #define A2DP_SOURCE_ENDPOINT_PATH "/org/chromium/Cras/Bluetooth/A2DPSource"
 #define A2DP_SINK_ENDPOINT_PATH "/org/chromium/Cras/Bluetooth/A2DPSink"

 /* Pointers for the only connected a2dp device. */
 static struct a2dp {
 	struct cras_iodev *iodev;
 	struct cras_bt_device *device;
 } connected_a2dp;

 static int cras_a2dp_get_capabilities(struct cras_bt_endpoint *endpoint,
 				      void *capabilities, int *len)
 {
 	a2dp_sbc_t *sbc_caps = capabilities;

 	if (*len < sizeof(*sbc_caps))
 		return -ENOSPC;

 	*len = sizeof(*sbc_caps);

 	/* Return all capabilities. */
 	sbc_caps->channel_mode =
 		SBC_CHANNEL_MODE_MONO | SBC_CHANNEL_MODE_DUAL_CHANNEL |
 		SBC_CHANNEL_MODE_STEREO | SBC_CHANNEL_MODE_JOINT_STEREO;
 	sbc_caps->frequency = SBC_SAMPLING_FREQ_16000 |
 			      SBC_SAMPLING_FREQ_32000 |
 			      SBC_SAMPLING_FREQ_44100 | SBC_SAMPLING_FREQ_48000;
 	sbc_caps->allocation_method =
 		SBC_ALLOCATION_SNR | SBC_ALLOCATION_LOUDNESS;
 	sbc_caps->subbands = SBC_SUBBANDS_4 | SBC_SUBBANDS_8;
 	sbc_caps->block_length = SBC_BLOCK_LENGTH_4 | SBC_BLOCK_LENGTH_8 |
 				 SBC_BLOCK_LENGTH_12 | SBC_BLOCK_LENGTH_16;
 	sbc_caps->min_bitpool = MIN_BITPOOL;
 	sbc_caps->max_bitpool = MAX_BITPOOL;

 	return 0;
 }

 static int cras_a2dp_select_configuration(struct cras_bt_endpoint *endpoint,
 					  void *capabilities, int len,
 					  void *configuration)
 {
 	a2dp_sbc_t *sbc_caps = capabilities;
 	a2dp_sbc_t *sbc_config = configuration;

 	/* Pick the highest configuration. */
 	if (sbc_caps->channel_mode & SBC_CHANNEL_MODE_JOINT_STEREO) {
 		sbc_config->channel_mode = SBC_CHANNEL_MODE_JOINT_STEREO;
 	} else if (sbc_caps->channel_mode & SBC_CHANNEL_MODE_STEREO) {
 		sbc_config->channel_mode = SBC_CHANNEL_MODE_STEREO;
 	} else if (sbc_caps->channel_mode & SBC_CHANNEL_MODE_DUAL_CHANNEL) {
 		sbc_config->channel_mode = SBC_CHANNEL_MODE_DUAL_CHANNEL;
 	} else if (sbc_caps->channel_mode & SBC_CHANNEL_MODE_MONO) {
 		sbc_config->channel_mode = SBC_CHANNEL_MODE_MONO;
 	} else {
 		syslog(LOG_WARNING, "No supported channel modes.");
 		return -ENOSYS;
 	}

 	if (sbc_caps->frequency & SBC_SAMPLING_FREQ_48000) {
 		sbc_config->frequency = SBC_SAMPLING_FREQ_48000;
 	} else if (sbc_caps->frequency & SBC_SAMPLING_FREQ_44100) {
 		sbc_config->frequency = SBC_SAMPLING_FREQ_44100;
 	} else if (sbc_caps->frequency & SBC_SAMPLING_FREQ_32000) {
 		sbc_config->frequency = SBC_SAMPLING_FREQ_32000;
 	} else if (sbc_caps->frequency & SBC_SAMPLING_FREQ_16000) {
 		sbc_config->frequency = SBC_SAMPLING_FREQ_16000;
 	} else {
 		syslog(LOG_WARNING, "No supported sampling frequencies.");
 		return -ENOSYS;
 	}

 	if (sbc_caps->allocation_method & SBC_ALLOCATION_LOUDNESS) {
 		sbc_config->allocation_method = SBC_ALLOCATION_LOUDNESS;
 	} else if (sbc_caps->allocation_method & SBC_ALLOCATION_SNR) {
 		sbc_config->allocation_method = SBC_ALLOCATION_SNR;
 	} else {
 		syslog(LOG_WARNING, "No supported allocation method.");
 		return -ENOSYS;
 	}

 	if (sbc_caps->subbands & SBC_SUBBANDS_8) {
 		sbc_config->subbands = SBC_SUBBANDS_8;
 	} else if (sbc_caps->subbands & SBC_SUBBANDS_4) {
 		sbc_config->subbands = SBC_SUBBANDS_4;
 	} else {
 		syslog(LOG_WARNING, "No supported subbands.");
 		return -ENOSYS;
 	}

 	if (sbc_caps->block_length & SBC_BLOCK_LENGTH_16) {
 		sbc_config->block_length = SBC_BLOCK_LENGTH_16;
 	} else if (sbc_caps->block_length & SBC_BLOCK_LENGTH_12) {
 		sbc_config->block_length = SBC_BLOCK_LENGTH_12;
 	} else if (sbc_caps->block_length & SBC_BLOCK_LENGTH_8) {
 		sbc_config->block_length = SBC_BLOCK_LENGTH_8;
 	} else if (sbc_caps->block_length & SBC_BLOCK_LENGTH_4) {
 		sbc_config->block_length = SBC_BLOCK_LENGTH_4;
 	} else {
 		syslog(LOG_WARNING, "No supported block length.");
 		return -ENOSYS;
 	}

 	sbc_config->min_bitpool =
 		(sbc_caps->min_bitpool > MIN_BITPOOL ? sbc_caps->min_bitpool :
 						       MIN_BITPOOL);
 	sbc_config->max_bitpool =
 		(sbc_caps->max_bitpool < MAX_BITPOOL ? sbc_caps->max_bitpool :
 						       MAX_BITPOOL);

 	return 0;
 }

 static void cras_a2dp_set_configuration(struct cras_bt_endpoint *endpoint,
 					struct cras_bt_transport *transport)
 {
 	struct cras_bt_device *device;

 	device = cras_bt_transport_device(transport);
 	cras_bt_device_a2dp_configured(device);
 }

 static void cras_a2dp_suspend(struct cras_bt_endpoint *endpoint,
 			      struct cras_bt_transport *transport)
 {
 	struct cras_bt_device *device = cras_bt_transport_device(transport);

 	BTLOG(btlog, BT_A2DP_SUSPENDED, 0, 0);
 	cras_a2dp_suspend_connected_device(device);
 	cras_bt_device_notify_profile_dropped(device,
 					      CRAS_BT_DEVICE_PROFILE_A2DP_SINK);
 }

 static void a2dp_transport_state_changed(struct cras_bt_endpoint *endpoint,
 					 struct cras_bt_transport *transport)
 {
 	if (connected_a2dp.iodev && transport) {
 		/* When pending message is received in bluez, try to aquire
 		 * the transport. */
 		if (cras_bt_transport_fd(transport) != -1 &&
 		    cras_bt_transport_state(transport) ==
 			    CRAS_BT_TRANSPORT_STATE_PENDING)
 			cras_bt_transport_try_acquire(transport);
 	}
 }

 static struct cras_bt_endpoint cras_a2dp_endpoint = {
 	/* BlueZ connects the device A2DP Sink to our A2DP Source endpoint,
 	 * and the device A2DP Source to our A2DP Sink. It's best if you don't
 	 * think about it too hard.
 	 */
 	.object_path = A2DP_SOURCE_ENDPOINT_PATH,
 	.uuid = A2DP_SOURCE_UUID,
 	.codec = A2DP_CODEC_SBC,

 	.get_capabilities = cras_a2dp_get_capabilities,
 	.select_configuration = cras_a2dp_select_configuration,
 	.set_configuration = cras_a2dp_set_configuration,
 	.suspend = cras_a2dp_suspend,
 	.transport_state_changed = a2dp_transport_state_changed
 };

 int cras_a2dp_endpoint_create(DBusConnection *conn)
 {
 	return cras_bt_endpoint_add(conn, &cras_a2dp_endpoint);
 }

 void cras_a2dp_start(struct cras_bt_device *device)
 {
 	struct cras_bt_transport *transport = cras_a2dp_endpoint.transport;

 	BTLOG(btlog, BT_A2DP_START, 0, 0);

 	if (!transport || device != cras_bt_transport_device(transport)) {
 		syslog(LOG_ERR, "Device and active transport not match.");
 		return;
 	}

 	if (connected_a2dp.iodev) {
 		syslog(LOG_WARNING,
 		       "Replacing existing endpoint configuration");
 		a2dp_iodev_destroy(connected_a2dp.iodev);
 	}

 	connected_a2dp.iodev = a2dp_iodev_create(transport);
 	connected_a2dp.device = cras_bt_transport_device(transport);

 	if (!connected_a2dp.iodev)
 		syslog(LOG_WARNING, "Failed to create a2dp iodev");
 }

 struct cras_bt_device *cras_a2dp_connected_device()
 {
 	return connected_a2dp.device;
 }

 void cras_a2dp_suspend_connected_device(struct cras_bt_device *device)
 {
 	if (connected_a2dp.device != device)
 		return;

 	if (connected_a2dp.iodev) {
 		syslog(LOG_INFO, "Destroying iodev for A2DP device");
 		a2dp_iodev_destroy(connected_a2dp.iodev);
 		connected_a2dp.iodev = NULL;
 		connected_a2dp.device = NULL;
 	}
 }
	/* Copyright (c) 2013 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 <errno.h>
	#include <stdint.h>
	#include <syslog.h>

	#include "a2dp-codecs.h"
	#include "cras_a2dp_endpoint.h"
	#include "cras_a2dp_iodev.h"
	#include "cras_iodev.h"
	#include "cras_bt_constants.h"
	#include "cras_bt_endpoint.h"
	#include "cras_bt_log.h"
	#include "cras_system_state.h"
	#include "cras_util.h"

	#define A2DP_SOURCE_ENDPOINT_PATH "/org/chromium/Cras/Bluetooth/A2DPSource"
	#define A2DP_SINK_ENDPOINT_PATH "/org/chromium/Cras/Bluetooth/A2DPSink"

	/* Pointers for the only connected a2dp device. */
	static struct a2dp {
	struct cras_iodev *iodev;
	struct cras_bt_device *device;
	} connected_a2dp;

	static int cras_a2dp_get_capabilities(struct cras_bt_endpoint *endpoint,
	void capabilities, int len)
	{
	a2dp_sbc_t *sbc_caps = capabilities;

	if (len < sizeof(sbc_caps))
	return -ENOSPC;

	len = sizeof(sbc_caps);

	/* Return all capabilities. */
	sbc_caps->channel_mode =
	SBC_CHANNEL_MODE_MONO \| SBC_CHANNEL_MODE_DUAL_CHANNEL \|
	SBC_CHANNEL_MODE_STEREO \| SBC_CHANNEL_MODE_JOINT_STEREO;
	sbc_caps->frequency = SBC_SAMPLING_FREQ_16000 \|
	SBC_SAMPLING_FREQ_32000 \|
	SBC_SAMPLING_FREQ_44100 \| SBC_SAMPLING_FREQ_48000;
	sbc_caps->allocation_method =
	SBC_ALLOCATION_SNR \| SBC_ALLOCATION_LOUDNESS;
	sbc_caps->subbands = SBC_SUBBANDS_4 \| SBC_SUBBANDS_8;
	sbc_caps->block_length = SBC_BLOCK_LENGTH_4 \| SBC_BLOCK_LENGTH_8 \|
	SBC_BLOCK_LENGTH_12 \| SBC_BLOCK_LENGTH_16;
	sbc_caps->min_bitpool = MIN_BITPOOL;
	sbc_caps->max_bitpool = MAX_BITPOOL;

	return 0;
	}

	static int cras_a2dp_select_configuration(struct cras_bt_endpoint *endpoint,
	void *capabilities, int len,
	void *configuration)
	{
	a2dp_sbc_t *sbc_caps = capabilities;
	a2dp_sbc_t *sbc_config = configuration;

	/* Pick the highest configuration. */
	if (sbc_caps->channel_mode & SBC_CHANNEL_MODE_JOINT_STEREO) {
	sbc_config->channel_mode = SBC_CHANNEL_MODE_JOINT_STEREO;
	} else if (sbc_caps->channel_mode & SBC_CHANNEL_MODE_STEREO) {
	sbc_config->channel_mode = SBC_CHANNEL_MODE_STEREO;
	} else if (sbc_caps->channel_mode & SBC_CHANNEL_MODE_DUAL_CHANNEL) {
	sbc_config->channel_mode = SBC_CHANNEL_MODE_DUAL_CHANNEL;
	} else if (sbc_caps->channel_mode & SBC_CHANNEL_MODE_MONO) {
	sbc_config->channel_mode = SBC_CHANNEL_MODE_MONO;
	} else {
	syslog(LOG_WARNING, "No supported channel modes.");
	return -ENOSYS;
	}

	if (sbc_caps->frequency & SBC_SAMPLING_FREQ_48000) {
	sbc_config->frequency = SBC_SAMPLING_FREQ_48000;
	} else if (sbc_caps->frequency & SBC_SAMPLING_FREQ_44100) {
	sbc_config->frequency = SBC_SAMPLING_FREQ_44100;
	} else if (sbc_caps->frequency & SBC_SAMPLING_FREQ_32000) {
	sbc_config->frequency = SBC_SAMPLING_FREQ_32000;
	} else if (sbc_caps->frequency & SBC_SAMPLING_FREQ_16000) {
	sbc_config->frequency = SBC_SAMPLING_FREQ_16000;
	} else {
	syslog(LOG_WARNING, "No supported sampling frequencies.");
	return -ENOSYS;
	}

	if (sbc_caps->allocation_method & SBC_ALLOCATION_LOUDNESS) {
	sbc_config->allocation_method = SBC_ALLOCATION_LOUDNESS;
	} else if (sbc_caps->allocation_method & SBC_ALLOCATION_SNR) {
	sbc_config->allocation_method = SBC_ALLOCATION_SNR;
	} else {
	syslog(LOG_WARNING, "No supported allocation method.");
	return -ENOSYS;
	}

	if (sbc_caps->subbands & SBC_SUBBANDS_8) {
	sbc_config->subbands = SBC_SUBBANDS_8;
	} else if (sbc_caps->subbands & SBC_SUBBANDS_4) {
	sbc_config->subbands = SBC_SUBBANDS_4;
	} else {
	syslog(LOG_WARNING, "No supported subbands.");
	return -ENOSYS;
	}

	if (sbc_caps->block_length & SBC_BLOCK_LENGTH_16) {
	sbc_config->block_length = SBC_BLOCK_LENGTH_16;
	} else if (sbc_caps->block_length & SBC_BLOCK_LENGTH_12) {
	sbc_config->block_length = SBC_BLOCK_LENGTH_12;
	} else if (sbc_caps->block_length & SBC_BLOCK_LENGTH_8) {
	sbc_config->block_length = SBC_BLOCK_LENGTH_8;
	} else if (sbc_caps->block_length & SBC_BLOCK_LENGTH_4) {
	sbc_config->block_length = SBC_BLOCK_LENGTH_4;
	} else {
	syslog(LOG_WARNING, "No supported block length.");
	return -ENOSYS;
	}

	sbc_config->min_bitpool =
	(sbc_caps->min_bitpool > MIN_BITPOOL ? sbc_caps->min_bitpool :
	MIN_BITPOOL);
	sbc_config->max_bitpool =
	(sbc_caps->max_bitpool < MAX_BITPOOL ? sbc_caps->max_bitpool :
	MAX_BITPOOL);

	return 0;
	}

	static void cras_a2dp_set_configuration(struct cras_bt_endpoint *endpoint,
	struct cras_bt_transport *transport)
	{
	struct cras_bt_device *device;

	device = cras_bt_transport_device(transport);
	cras_bt_device_a2dp_configured(device);
	}

	static void cras_a2dp_suspend(struct cras_bt_endpoint *endpoint,
	struct cras_bt_transport *transport)
	{
	struct cras_bt_device *device = cras_bt_transport_device(transport);

	BTLOG(btlog, BT_A2DP_SUSPENDED, 0, 0);
	cras_a2dp_suspend_connected_device(device);
	cras_bt_device_notify_profile_dropped(device,
	CRAS_BT_DEVICE_PROFILE_A2DP_SINK);
	}

	static void a2dp_transport_state_changed(struct cras_bt_endpoint *endpoint,
	struct cras_bt_transport *transport)
	{
	if (connected_a2dp.iodev && transport) {
	/* When pending message is received in bluez, try to aquire
	* the transport. */
	if (cras_bt_transport_fd(transport) != -1 &&
	cras_bt_transport_state(transport) ==
	CRAS_BT_TRANSPORT_STATE_PENDING)
	cras_bt_transport_try_acquire(transport);
	}
	}

	static struct cras_bt_endpoint cras_a2dp_endpoint = {
	/* BlueZ connects the device A2DP Sink to our A2DP Source endpoint,
	* and the device A2DP Source to our A2DP Sink. It's best if you don't
	* think about it too hard.
	*/
	.object_path = A2DP_SOURCE_ENDPOINT_PATH,
	.uuid = A2DP_SOURCE_UUID,
	.codec = A2DP_CODEC_SBC,

	.get_capabilities = cras_a2dp_get_capabilities,
	.select_configuration = cras_a2dp_select_configuration,
	.set_configuration = cras_a2dp_set_configuration,
	.suspend = cras_a2dp_suspend,
	.transport_state_changed = a2dp_transport_state_changed
	};

	int cras_a2dp_endpoint_create(DBusConnection *conn)
	{
	return cras_bt_endpoint_add(conn, &cras_a2dp_endpoint);
	}

	void cras_a2dp_start(struct cras_bt_device *device)
	{
	struct cras_bt_transport *transport = cras_a2dp_endpoint.transport;

	BTLOG(btlog, BT_A2DP_START, 0, 0);

	if (!transport \|\| device != cras_bt_transport_device(transport)) {
	syslog(LOG_ERR, "Device and active transport not match.");
	return;
	}

	if (connected_a2dp.iodev) {
	syslog(LOG_WARNING,
	"Replacing existing endpoint configuration");
	a2dp_iodev_destroy(connected_a2dp.iodev);
	}

	connected_a2dp.iodev = a2dp_iodev_create(transport);
	connected_a2dp.device = cras_bt_transport_device(transport);

	if (!connected_a2dp.iodev)
	syslog(LOG_WARNING, "Failed to create a2dp iodev");
	}

	struct cras_bt_device *cras_a2dp_connected_device()
	{
	return connected_a2dp.device;
	}

	void cras_a2dp_suspend_connected_device(struct cras_bt_device *device)
	{
	if (connected_a2dp.device != device)
	return;

	if (connected_a2dp.iodev) {
	syslog(LOG_INFO, "Destroying iodev for A2DP device");
	a2dp_iodev_destroy(connected_a2dp.iodev);
	connected_a2dp.iodev = NULL;
	connected_a2dp.device = NULL;
	}
	}