/* * * BlueZ - Bluetooth protocol stack for Linux * * Copyright (C) 2006-2009 Nokia Corporation * Copyright (C) 2004-2009 Marcel Holtmann * Copyright (C) 2009 Lennart Poettering * Copyright (C) 2008 Joao Paulo Rechi Vita * * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifdef HAVE_CONFIG_H #include #endif #include #include #include #include #include #include #include #include #include #include #include "ipc.h" #include "sbc.h" #define DBG(fmt, arg...) \ printf("debug %s: " fmt "\n" , __FUNCTION__ , ## arg) #define ERR(fmt, arg...) \ fprintf(stderr, "ERROR %s: " fmt "\n" , __FUNCTION__ , ## arg) #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0])) #ifndef MIN # define MIN(x, y) ((x) < (y) ? (x) : (y)) #endif #ifndef MAX # define MAX(x, y) ((x) > (y) ? (x) : (y)) #endif #ifndef TRUE # define TRUE (1) #endif #ifndef FALSE # define FALSE (0) #endif #define YES_NO(t) ((t) ? "yes" : "no") #define BUFFER_SIZE 2048 #define MAX_BITPOOL 64 #define MIN_BITPOOL 2 struct a2dp_info { sbc_capabilities_t sbc_capabilities; sbc_t sbc; /* Codec data */ int sbc_initialized; /* Keep track if the encoder is initialized */ size_t codesize; /* SBC codesize */ void* buffer; /* Codec transfer buffer */ size_t buffer_size; /* Size of the buffer */ uint16_t seq_num; /* Cumulative packet sequence */ }; struct hsp_info { pcm_capabilities_t pcm_capabilities; }; struct userdata { int service_fd; int stream_fd; GIOChannel *stream_channel; guint stream_watch; GIOChannel *gin; /* dude, I am thirsty now */ guint gin_watch; int transport; uint32_t rate; int channels; char *address; struct a2dp_info a2dp; struct hsp_info hsp; size_t link_mtu; size_t block_size; gboolean debug_stream_read : 1; gboolean debug_stream_write : 1; }; static struct userdata data = { .service_fd = -1, .stream_fd = -1, .transport = BT_CAPABILITIES_TRANSPORT_A2DP, .rate = 48000, .channels = 2, .address = NULL }; static int start_stream(struct userdata *u); static int stop_stream(struct userdata *u); static gboolean input_cb(GIOChannel *gin, GIOCondition condition, gpointer data); static GMainLoop *main_loop; static int service_send(struct userdata *u, const bt_audio_msg_header_t *msg) { int err; uint16_t length; assert(u); length = msg->length ? msg->length : BT_SUGGESTED_BUFFER_SIZE; DBG("sending %s:%s", bt_audio_strtype(msg->type), bt_audio_strname(msg->name)); if (send(u->service_fd, msg, length, 0) > 0) err = 0; else { err = -errno; ERR("Error sending data to audio service: %s(%d)", strerror(errno), errno); } return err; } static int service_recv(struct userdata *u, bt_audio_msg_header_t *rsp) { int err; const char *type, *name; uint16_t length; assert(u); length = rsp->length ? : BT_SUGGESTED_BUFFER_SIZE; DBG("trying to receive msg from audio service..."); if (recv(u->service_fd, rsp, length, 0) > 0) { type = bt_audio_strtype(rsp->type); name = bt_audio_strname(rsp->name); if (type && name) { DBG("Received %s - %s", type, name); err = 0; } else { err = -EINVAL; ERR("Bogus message type %d - name %d" "received from audio service", rsp->type, rsp->name); } } else { err = -errno; ERR("Error receiving data from audio service: %s(%d)", strerror(errno), errno); } return err; } static ssize_t service_expect(struct userdata *u, bt_audio_msg_header_t *rsp, uint8_t expected_name) { int r; assert(u); assert(u->service_fd >= 0); assert(rsp); if ((r = service_recv(u, rsp)) < 0) return r; if ((rsp->type != BT_INDICATION && rsp->type != BT_RESPONSE) || (rsp->name != expected_name)) { if (rsp->type == BT_ERROR && rsp->length == sizeof(bt_audio_error_t)) ERR("Received error condition: %s", strerror(((bt_audio_error_t*) rsp)->posix_errno)); else ERR("Bogus message %s received while %s was expected", bt_audio_strname(rsp->name), bt_audio_strname(expected_name)); return -1; } return 0; } static int init_bt(struct userdata *u) { assert(u); if (u->service_fd != -1) return 0; DBG("bt_audio_service_open"); u->service_fd = bt_audio_service_open(); if (u->service_fd <= 0) { perror(strerror(errno)); return errno; } return 0; } static int parse_caps(struct userdata *u, const struct bt_get_capabilities_rsp *rsp) { unsigned char *ptr; uint16_t bytes_left; codec_capabilities_t codec; assert(u); assert(rsp); bytes_left = rsp->h.length - sizeof(*rsp); if (bytes_left < sizeof(codec_capabilities_t)) { ERR("Packet too small to store codec information."); return -1; } ptr = ((void *) rsp) + sizeof(*rsp); memcpy(&codec, ptr, sizeof(codec)); /** ALIGNMENT? **/ DBG("Payload size is %lu %lu", (unsigned long) bytes_left, (unsigned long) sizeof(codec)); if (u->transport != codec.transport) { ERR("Got capabilities for wrong codec."); return -1; } if (u->transport == BT_CAPABILITIES_TRANSPORT_SCO) { if (bytes_left <= 0 || codec.length != sizeof(u->hsp.pcm_capabilities)) return -1; assert(codec.type == BT_HFP_CODEC_PCM); memcpy(&u->hsp.pcm_capabilities, &codec, sizeof(u->hsp.pcm_capabilities)); DBG("Has NREC: %s", YES_NO(u->hsp.pcm_capabilities.flags & BT_PCM_FLAG_NREC)); } else if (u->transport == BT_CAPABILITIES_TRANSPORT_A2DP) { while (bytes_left > 0) { if (codec.type == BT_A2DP_SBC_SINK && !(codec.lock & BT_WRITE_LOCK)) break; bytes_left -= codec.length; ptr += codec.length; memcpy(&codec, ptr, sizeof(codec)); } DBG("bytes_left = %d, codec.length = %d", bytes_left, codec.length); if (bytes_left <= 0 || codec.length != sizeof(u->a2dp.sbc_capabilities)) return -1; assert(codec.type == BT_A2DP_SBC_SINK); memcpy(&u->a2dp.sbc_capabilities, &codec, sizeof(u->a2dp.sbc_capabilities)); } else { assert(0); } return 0; } static int get_caps(struct userdata *u) { union { struct bt_get_capabilities_req getcaps_req; struct bt_get_capabilities_rsp getcaps_rsp; bt_audio_error_t error; uint8_t buf[BT_SUGGESTED_BUFFER_SIZE]; } msg; assert(u); memset(&msg, 0, sizeof(msg)); msg.getcaps_req.h.type = BT_REQUEST; msg.getcaps_req.h.name = BT_GET_CAPABILITIES; msg.getcaps_req.h.length = sizeof(msg.getcaps_req); strncpy(msg.getcaps_req.destination, u->address, sizeof(msg.getcaps_req.destination)); msg.getcaps_req.transport = u->transport; msg.getcaps_req.flags = BT_FLAG_AUTOCONNECT; if (service_send(u, &msg.getcaps_req.h) < 0) return -1; msg.getcaps_rsp.h.length = 0; if (service_expect(u, &msg.getcaps_rsp.h, BT_GET_CAPABILITIES) < 0) return -1; return parse_caps(u, &msg.getcaps_rsp); } static uint8_t a2dp_default_bitpool(uint8_t freq, uint8_t mode) { switch (freq) { case BT_SBC_SAMPLING_FREQ_16000: case BT_SBC_SAMPLING_FREQ_32000: return 53; case BT_SBC_SAMPLING_FREQ_44100: switch (mode) { case BT_A2DP_CHANNEL_MODE_MONO: case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL: return 31; case BT_A2DP_CHANNEL_MODE_STEREO: case BT_A2DP_CHANNEL_MODE_JOINT_STEREO: return 53; default: DBG("Invalid channel mode %u", mode); return 53; } case BT_SBC_SAMPLING_FREQ_48000: switch (mode) { case BT_A2DP_CHANNEL_MODE_MONO: case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL: return 29; case BT_A2DP_CHANNEL_MODE_STEREO: case BT_A2DP_CHANNEL_MODE_JOINT_STEREO: return 51; default: DBG("Invalid channel mode %u", mode); return 51; } default: DBG("Invalid sampling freq %u", freq); return 53; } } static int setup_a2dp(struct userdata *u) { sbc_capabilities_t *cap; int i; static const struct { uint32_t rate; uint8_t cap; } freq_table[] = { { 16000U, BT_SBC_SAMPLING_FREQ_16000 }, { 32000U, BT_SBC_SAMPLING_FREQ_32000 }, { 44100U, BT_SBC_SAMPLING_FREQ_44100 }, { 48000U, BT_SBC_SAMPLING_FREQ_48000 } }; assert(u); assert(u->transport == BT_CAPABILITIES_TRANSPORT_A2DP); cap = &u->a2dp.sbc_capabilities; /* Find the lowest freq that is at least as high as the requested * sampling rate */ for (i = 0; (unsigned) i < ARRAY_SIZE(freq_table); i++) if (freq_table[i].rate >= u->rate && (cap->frequency & freq_table[i].cap)) { u->rate = freq_table[i].rate; cap->frequency = freq_table[i].cap; break; } if ((unsigned) i >= ARRAY_SIZE(freq_table)) { for (; i >= 0; i--) { if (cap->frequency & freq_table[i].cap) { u->rate = freq_table[i].rate; cap->frequency = freq_table[i].cap; break; } } if (i < 0) { DBG("Not suitable sample rate"); return -1; } } if (u->channels <= 1) { if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_MONO) { cap->channel_mode = BT_A2DP_CHANNEL_MODE_MONO; u->channels = 1; } else u->channels = 2; } if (u->channels >= 2) { u->channels = 2; if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_JOINT_STEREO) cap->channel_mode = BT_A2DP_CHANNEL_MODE_JOINT_STEREO; else if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_STEREO) cap->channel_mode = BT_A2DP_CHANNEL_MODE_STEREO; else if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL) cap->channel_mode = BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL; else if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_MONO) { cap->channel_mode = BT_A2DP_CHANNEL_MODE_MONO; u->channels = 1; } else { DBG("No supported channel modes"); return -1; } } if (cap->block_length & BT_A2DP_BLOCK_LENGTH_16) cap->block_length = BT_A2DP_BLOCK_LENGTH_16; else if (cap->block_length & BT_A2DP_BLOCK_LENGTH_12) cap->block_length = BT_A2DP_BLOCK_LENGTH_12; else if (cap->block_length & BT_A2DP_BLOCK_LENGTH_8) cap->block_length = BT_A2DP_BLOCK_LENGTH_8; else if (cap->block_length & BT_A2DP_BLOCK_LENGTH_4) cap->block_length = BT_A2DP_BLOCK_LENGTH_4; else { DBG("No supported block lengths"); return -1; } if (cap->subbands & BT_A2DP_SUBBANDS_8) cap->subbands = BT_A2DP_SUBBANDS_8; else if (cap->subbands & BT_A2DP_SUBBANDS_4) cap->subbands = BT_A2DP_SUBBANDS_4; else { DBG("No supported subbands"); return -1; } if (cap->allocation_method & BT_A2DP_ALLOCATION_LOUDNESS) cap->allocation_method = BT_A2DP_ALLOCATION_LOUDNESS; else if (cap->allocation_method & BT_A2DP_ALLOCATION_SNR) cap->allocation_method = BT_A2DP_ALLOCATION_SNR; cap->min_bitpool = (uint8_t) MAX(MIN_BITPOOL, cap->min_bitpool); cap->max_bitpool = (uint8_t) MIN( a2dp_default_bitpool(cap->frequency, cap->channel_mode), cap->max_bitpool); return 0; } static void setup_sbc(struct a2dp_info *a2dp) { sbc_capabilities_t *active_capabilities; assert(a2dp); active_capabilities = &a2dp->sbc_capabilities; if (a2dp->sbc_initialized) sbc_reinit(&a2dp->sbc, 0); else sbc_init(&a2dp->sbc, 0); a2dp->sbc_initialized = TRUE; switch (active_capabilities->frequency) { case BT_SBC_SAMPLING_FREQ_16000: a2dp->sbc.frequency = SBC_FREQ_16000; break; case BT_SBC_SAMPLING_FREQ_32000: a2dp->sbc.frequency = SBC_FREQ_32000; break; case BT_SBC_SAMPLING_FREQ_44100: a2dp->sbc.frequency = SBC_FREQ_44100; break; case BT_SBC_SAMPLING_FREQ_48000: a2dp->sbc.frequency = SBC_FREQ_48000; break; default: assert(0); } switch (active_capabilities->channel_mode) { case BT_A2DP_CHANNEL_MODE_MONO: a2dp->sbc.mode = SBC_MODE_MONO; break; case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL: a2dp->sbc.mode = SBC_MODE_DUAL_CHANNEL; break; case BT_A2DP_CHANNEL_MODE_STEREO: a2dp->sbc.mode = SBC_MODE_STEREO; break; case BT_A2DP_CHANNEL_MODE_JOINT_STEREO: a2dp->sbc.mode = SBC_MODE_JOINT_STEREO; break; default: assert(0); } switch (active_capabilities->allocation_method) { case BT_A2DP_ALLOCATION_SNR: a2dp->sbc.allocation = SBC_AM_SNR; break; case BT_A2DP_ALLOCATION_LOUDNESS: a2dp->sbc.allocation = SBC_AM_LOUDNESS; break; default: assert(0); } switch (active_capabilities->subbands) { case BT_A2DP_SUBBANDS_4: a2dp->sbc.subbands = SBC_SB_4; break; case BT_A2DP_SUBBANDS_8: a2dp->sbc.subbands = SBC_SB_8; break; default: assert(0); } switch (active_capabilities->block_length) { case BT_A2DP_BLOCK_LENGTH_4: a2dp->sbc.blocks = SBC_BLK_4; break; case BT_A2DP_BLOCK_LENGTH_8: a2dp->sbc.blocks = SBC_BLK_8; break; case BT_A2DP_BLOCK_LENGTH_12: a2dp->sbc.blocks = SBC_BLK_12; break; case BT_A2DP_BLOCK_LENGTH_16: a2dp->sbc.blocks = SBC_BLK_16; break; default: assert(0); } a2dp->sbc.bitpool = active_capabilities->max_bitpool; a2dp->codesize = (uint16_t) sbc_get_codesize(&a2dp->sbc); } static int bt_open(struct userdata *u) { union { struct bt_open_req open_req; struct bt_open_rsp open_rsp; bt_audio_error_t error; uint8_t buf[BT_SUGGESTED_BUFFER_SIZE]; } msg; memset(&msg, 0, sizeof(msg)); msg.open_req.h.type = BT_REQUEST; msg.open_req.h.name = BT_OPEN; msg.open_req.h.length = sizeof(msg.open_req); strncpy(msg.open_req.destination, u->address, sizeof(msg.open_req.destination)); msg.open_req.seid = u->transport == BT_CAPABILITIES_TRANSPORT_A2DP ? u->a2dp.sbc_capabilities.capability.seid : BT_A2DP_SEID_RANGE + 1; msg.open_req.lock = u->transport == BT_CAPABILITIES_TRANSPORT_A2DP ? BT_WRITE_LOCK : BT_READ_LOCK | BT_WRITE_LOCK; if (service_send(u, &msg.open_req.h) < 0) return -1; msg.open_rsp.h.length = sizeof(msg.open_rsp); if (service_expect(u, &msg.open_rsp.h, BT_OPEN) < 0) return -1; return 0; } static int set_conf(struct userdata *u) { union { struct bt_set_configuration_req setconf_req; struct bt_set_configuration_rsp setconf_rsp; bt_audio_error_t error; uint8_t buf[BT_SUGGESTED_BUFFER_SIZE]; } msg; if (u->transport == BT_CAPABILITIES_TRANSPORT_A2DP) { if (setup_a2dp(u) < 0) return -1; } memset(&msg, 0, sizeof(msg)); msg.setconf_req.h.type = BT_REQUEST; msg.setconf_req.h.name = BT_SET_CONFIGURATION; msg.setconf_req.h.length = sizeof(msg.setconf_req); if (u->transport == BT_CAPABILITIES_TRANSPORT_A2DP) { memcpy(&msg.setconf_req.codec, &u->a2dp.sbc_capabilities, sizeof(u->a2dp.sbc_capabilities)); msg.setconf_req.h.length += msg.setconf_req.codec.length - sizeof(msg.setconf_req.codec); } else { msg.setconf_req.codec.transport = BT_CAPABILITIES_TRANSPORT_SCO; msg.setconf_req.codec.seid = BT_A2DP_SEID_RANGE + 1; msg.setconf_req.codec.length = sizeof(pcm_capabilities_t); } if (service_send(u, &msg.setconf_req.h) < 0) return -1; msg.setconf_rsp.h.length = sizeof(msg.setconf_rsp); if (service_expect(u, &msg.setconf_rsp.h, BT_SET_CONFIGURATION) < 0) return -1; u->link_mtu = msg.setconf_rsp.link_mtu; /* setup SBC encoder now we agree on parameters */ if (u->transport == BT_CAPABILITIES_TRANSPORT_A2DP) { setup_sbc(&u->a2dp); u->block_size = u->a2dp.codesize; DBG("SBC parameters:\n\tallocation=%u\n" "\tsubbands=%u\n\tblocks=%u\n\tbitpool=%u\n", u->a2dp.sbc.allocation, u->a2dp.sbc.subbands, u->a2dp.sbc.blocks, u->a2dp.sbc.bitpool); } else u->block_size = u->link_mtu; return 0; } static int setup_bt(struct userdata *u) { assert(u); if (get_caps(u) < 0) return -1; DBG("Got device caps"); if (bt_open(u) < 0) return -1; if (set_conf(u) < 0) return -1; return 0; } static int init_profile(struct userdata *u) { assert(u); return setup_bt(u); } static void shutdown_bt(struct userdata *u) { assert(u); if (u->stream_fd != -1) { stop_stream(u); DBG("close(stream_fd)"); close(u->stream_fd); u->stream_fd = -1; } if (u->service_fd != -1) { DBG("bt_audio_service_close"); bt_audio_service_close(u->service_fd); u->service_fd = -1; } } static void make_fd_nonblock(int fd) { int v; assert(fd >= 0); assert((v = fcntl(fd, F_GETFL)) >= 0); if (!(v & O_NONBLOCK)) assert(fcntl(fd, F_SETFL, v|O_NONBLOCK) >= 0); } static void make_socket_low_delay(int fd) { /* FIXME: is this widely supported? */ #ifdef SO_PRIORITY int priority; assert(fd >= 0); priority = 6; if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, (void*)&priority, sizeof(priority)) < 0) ERR("SO_PRIORITY failed: %s", strerror(errno)); #endif } static int read_stream(struct userdata *u) { int ret = 0; ssize_t l; char *buf; assert(u); assert(u->stream_fd >= 0); buf = alloca(u->link_mtu); for (;;) { l = read(u->stream_fd, buf, u->link_mtu); if (u->debug_stream_read) DBG("read from socket: %lli bytes", (long long) l); if (l <= 0) { if (l < 0 && errno == EINTR) continue; else { ERR("Failed to read date from stream_fd: %s", ret < 0 ? strerror(errno) : "EOF"); return -1; } } else { break; } } return ret; } /* It's what PulseAudio is doing, not sure it's necessary for this * test */ static ssize_t pa_write(int fd, const void *buf, size_t count) { ssize_t r; if ((r = send(fd, buf, count, MSG_NOSIGNAL)) >= 0) return r; if (errno != ENOTSOCK) return r; return write(fd, buf, count); } static int write_stream(struct userdata *u) { int ret = 0; ssize_t l; char *buf; assert(u); assert(u->stream_fd >= 0); buf = alloca(u->link_mtu); for (;;) { l = pa_write(u->stream_fd, buf, u->link_mtu); if (u->debug_stream_write) DBG("written to socket: %lli bytes", (long long) l); assert(l != 0); if (l < 0) { if (errno == EINTR) continue; else { ERR("Failed to write data: %s", strerror(errno)); ret = -1; break; } } else { assert((size_t)l <= u->link_mtu); break; } } return ret; } static gboolean stream_cb(GIOChannel *gin, GIOCondition condition, gpointer data) { struct userdata *u; assert(u = data); if (condition & G_IO_IN) { if (read_stream(u) < 0) goto fail; } else if (condition & G_IO_OUT) { if (write_stream(u) < 0) goto fail; } else { DBG("Got %d", condition); g_main_loop_quit(main_loop); return FALSE; } return TRUE; fail: stop_stream(u); return FALSE; } static int start_stream(struct userdata *u) { union { bt_audio_msg_header_t rsp; struct bt_start_stream_req start_req; struct bt_start_stream_rsp start_rsp; struct bt_new_stream_ind streamfd_ind; bt_audio_error_t error; uint8_t buf[BT_SUGGESTED_BUFFER_SIZE]; } msg; assert(u); if (u->stream_fd >= 0) return 0; if (u->stream_watch != 0) { g_source_remove(u->stream_watch); u->stream_watch = 0; } if (u->stream_channel != 0) { g_io_channel_unref(u->stream_channel); u->stream_channel = NULL; } memset(msg.buf, 0, BT_SUGGESTED_BUFFER_SIZE); msg.start_req.h.type = BT_REQUEST; msg.start_req.h.name = BT_START_STREAM; msg.start_req.h.length = sizeof(msg.start_req); if (service_send(u, &msg.start_req.h) < 0) return -1; msg.rsp.length = sizeof(msg.start_rsp); if (service_expect(u, &msg.rsp, BT_START_STREAM) < 0) return -1; msg.rsp.length = sizeof(msg.streamfd_ind); if (service_expect(u, &msg.rsp, BT_NEW_STREAM) < 0) return -1; if ((u->stream_fd = bt_audio_service_get_data_fd(u->service_fd)) < 0) { DBG("Failed to get stream fd from audio service."); return -1; } make_fd_nonblock(u->stream_fd); make_socket_low_delay(u->stream_fd); assert(u->stream_channel = g_io_channel_unix_new(u->stream_fd)); u->stream_watch = g_io_add_watch(u->stream_channel, G_IO_IN|G_IO_OUT|G_IO_ERR|G_IO_HUP|G_IO_NVAL, stream_cb, u); return 0; } static int stop_stream(struct userdata *u) { union { bt_audio_msg_header_t rsp; struct bt_stop_stream_req stop_req; struct bt_stop_stream_rsp stop_rsp; bt_audio_error_t error; uint8_t buf[BT_SUGGESTED_BUFFER_SIZE]; } msg; int r = 0; if (u->stream_fd < 0) return 0; assert(u); assert(u->stream_channel); g_source_remove(u->stream_watch); u->stream_watch = 0; g_io_channel_unref(u->stream_channel); u->stream_channel = NULL; memset(msg.buf, 0, BT_SUGGESTED_BUFFER_SIZE); msg.stop_req.h.type = BT_REQUEST; msg.stop_req.h.name = BT_STOP_STREAM; msg.stop_req.h.length = sizeof(msg.stop_req); if (service_send(u, &msg.stop_req.h) < 0) { r = -1; goto done; } msg.rsp.length = sizeof(msg.stop_rsp); if (service_expect(u, &msg.rsp, BT_STOP_STREAM) < 0) r = -1; done: close(u->stream_fd); u->stream_fd = -1; return r; } static gboolean sleep_cb(gpointer data) { struct userdata *u; assert(u = data); u->gin_watch = g_io_add_watch(u->gin, G_IO_IN|G_IO_ERR|G_IO_HUP|G_IO_NVAL, input_cb, data); printf(">>> "); fflush(stdout); return FALSE; } static gboolean input_cb(GIOChannel *gin, GIOCondition condition, gpointer data) { char *line, *tmp; gsize term_pos; GError *error = NULL; struct userdata *u; int success; assert(u = data); if (!(condition & G_IO_IN)) { DBG("Got %d", condition); g_main_loop_quit(main_loop); return FALSE; } if (g_io_channel_read_line(gin, &line, NULL, &term_pos, &error) != G_IO_STATUS_NORMAL) return FALSE; line[term_pos] = '\0'; g_strstrip(line); if ((tmp = strchr(line, '#'))) *tmp = '\0'; success = FALSE; #define IF_CMD(cmd) \ if (!success && (success = (strncmp(line, #cmd, strlen(#cmd)) == 0))) IF_CMD(quit) { g_main_loop_quit(main_loop); return FALSE; } IF_CMD(sleep) { unsigned int seconds; if (sscanf(line, "%*s %d", &seconds) != 1) DBG("sleep SECONDS"); else { g_source_remove(u->gin_watch); g_timeout_add_seconds(seconds, sleep_cb, u); return FALSE; } } IF_CMD(debug) { char *what = NULL; int enable; if (sscanf(line, "%*s %as %d", &what, &enable) != 1) DBG("debug [stream_read|stream_write] [0|1]"); if (strncmp(what, "stream_read", 12) == 0) { u->debug_stream_read = enable; } else if (strncmp(what, "stream_write", 13) == 0) { u->debug_stream_write = enable; } else { DBG("debug [stream_read|stream_write] [0|1]"); } } IF_CMD(init_bt) { DBG("%d", init_bt(u)); } IF_CMD(init_profile) { DBG("%d", init_profile(u)); } IF_CMD(start_stream) { DBG("%d", start_stream(u)); } IF_CMD(stop_stream) { DBG("%d", stop_stream(u)); } IF_CMD(shutdown_bt) { shutdown_bt(u); } IF_CMD(rate) { if (sscanf(line, "%*s %d", &u->rate) != 1) DBG("set with rate RATE"); DBG("rate %d", u->rate); } IF_CMD(bdaddr) { char *address; if (sscanf(line, "%*s %as", &address) != 1) DBG("set with bdaddr BDADDR"); if (u->address) free(u->address); u->address = address; DBG("bdaddr %s", u->address); } IF_CMD(profile) { char *profile = NULL; if (sscanf(line, "%*s %as", &profile) != 1) DBG("set with profile [hsp|a2dp]"); if (strncmp(profile, "hsp", 4) == 0) { u->transport = BT_CAPABILITIES_TRANSPORT_SCO; } else if (strncmp(profile, "a2dp", 5) == 0) { u->transport = BT_CAPABILITIES_TRANSPORT_A2DP; } else { DBG("set with profile [hsp|a2dp]"); } if (profile) free(profile); DBG("profile %s", u->transport == BT_CAPABILITIES_TRANSPORT_SCO ? "hsp" : "a2dp"); } if (!success && strlen(line) != 0) { DBG("%s, unknown command", line); } printf(">>> "); fflush(stdout); return TRUE; } static void show_usage(char* prgname) { printf("%s: ipctest [--interactive] BDADDR\n", basename(prgname)); } static void sig_term(int sig) { g_main_loop_quit(main_loop); } int main(int argc, char *argv[]) { if (argc < 2) { show_usage(argv[0]); exit(EXIT_FAILURE); } assert(main_loop = g_main_loop_new(NULL, FALSE)); if (strncmp("--interactive", argv[1], 14) == 0) { if (argc < 3) { show_usage(argv[0]); exit(EXIT_FAILURE); } data.address = strdup(argv[2]); signal(SIGTERM, sig_term); signal(SIGINT, sig_term); assert(data.gin = g_io_channel_unix_new(fileno(stdin))); data.gin_watch = g_io_add_watch(data.gin, G_IO_IN|G_IO_ERR|G_IO_HUP|G_IO_NVAL, input_cb, &data); printf(">>> "); fflush(stdout); g_main_loop_run(main_loop); } else { data.address = strdup(argv[1]); assert(init_bt(&data) == 0); assert(init_profile(&data) == 0); assert(start_stream(&data) == 0); g_main_loop_run(main_loop); assert(stop_stream(&data) == 0); shutdown_bt(&data); } g_main_loop_unref(main_loop); printf("\nExiting\n"); exit(EXIT_SUCCESS); return 0; }