mirrors/pulseaudio
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pulseaudio/pulseaudio.git synced 2025-11-04 13:29:59 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

bluetooth: use consistent profile names

Browse source 
The PA_BLUETOOTH_PROFILE names should mirror the PA_BLUETOOTH_UUID
names using profile_function instead of randomly made up names.  Fix
this with the transformation:

PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT -> PA_BLUETOOTH_PROFILE_HSP_HS
PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY -> PA_BLUETOOTH_PROFILE_HFP_AG

Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>

---

v4: update for PA 11.0

Part-of: <https://gitlab.freedesktop.org/pulseaudio/pulseaudio/-/merge_requests/491>
This commit is contained in:
James Bottomley 2016-08-20 10:39:30 -07:00 • committed by Igor Kovalenko
parent bca4c22832
commit 709909a1fc
5 changed files with 50 additions and 50 deletions
Download patch file Download diff file Expand all files Collapse all files

28
src/modules/bluetooth/backend-native.c
View file

@ -445,7 +445,7 @@ static void set_speaker_gain(pa_bluetooth_transport *t, uint16_t gain) {
/* If we are in the AG role, we send a command to the head set to change /* If we are in the AG role, we send a command to the head set to change
* the speaker gain. In the HS role, source and sink are swapped, so * the speaker gain. In the HS role, source and sink are swapped, so
* in this case we notify the AG that the microphone gain has changed */ * in this case we notify the AG that the microphone gain has changed */
if (t->profile == PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT) { if (t->profile == PA_BLUETOOTH_PROFILE_HSP_HS) {
len = sprintf(buf, "\r\n+VGS=%d\r\n", gain); len = sprintf(buf, "\r\n+VGS=%d\r\n", gain);
pa_log_debug("RFCOMM >> +VGS=%d", gain); pa_log_debug("RFCOMM >> +VGS=%d", gain);
} else { } else {
@ -472,7 +472,7 @@ static void set_microphone_gain(pa_bluetooth_transport *t, uint16_t gain) {
/* If we are in the AG role, we send a command to the head set to change /* If we are in the AG role, we send a command to the head set to change
* the microphone gain. In the HS role, source and sink are swapped, so * the microphone gain. In the HS role, source and sink are swapped, so
* in this case we notify the AG that the speaker gain has changed */ * in this case we notify the AG that the speaker gain has changed */
if (t->profile == PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT) { if (t->profile == PA_BLUETOOTH_PROFILE_HSP_HS) {
len = sprintf(buf, "\r\n+VGM=%d\r\n", gain); len = sprintf(buf, "\r\n+VGM=%d\r\n", gain);
pa_log_debug("RFCOMM >> +VGM=%d", gain); pa_log_debug("RFCOMM >> +VGM=%d", gain);
} else { } else {
@ -505,9 +505,9 @@ static DBusMessage *profile_new_connection(DBusConnection *conn, DBusMessage *m,
handler = dbus_message_get_path(m); handler = dbus_message_get_path(m);
if (pa_streq(handler, HSP_AG_PROFILE)) { if (pa_streq(handler, HSP_AG_PROFILE)) {
p = PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT; p = PA_BLUETOOTH_PROFILE_HSP_HS;
} else if (pa_streq(handler, HSP_HS_PROFILE)) { } else if (pa_streq(handler, HSP_HS_PROFILE)) {
p = PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY; p = PA_BLUETOOTH_PROFILE_HFP_AG;
} else { } else {
pa_log_error("Invalid handler"); pa_log_error("Invalid handler");
goto fail; goto fail;
@ -622,11 +622,11 @@ static void profile_init(pa_bluetooth_backend *b, pa_bluetooth_profile_t profile
pa_assert(b); pa_assert(b);
switch (profile) { switch (profile) {
case PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT: case PA_BLUETOOTH_PROFILE_HSP_HS:
object_name = HSP_AG_PROFILE; object_name = HSP_AG_PROFILE;
uuid = PA_BLUETOOTH_UUID_HSP_AG; uuid = PA_BLUETOOTH_UUID_HSP_AG;
break; break;
case PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY: case PA_BLUETOOTH_PROFILE_HFP_AG:
object_name = HSP_HS_PROFILE; object_name = HSP_HS_PROFILE;
uuid = PA_BLUETOOTH_UUID_HSP_HS; uuid = PA_BLUETOOTH_UUID_HSP_HS;
break; break;
@ -643,10 +643,10 @@ static void profile_done(pa_bluetooth_backend *b, pa_bluetooth_profile_t profile
pa_assert(b); pa_assert(b);
switch (profile) { switch (profile) {
case PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT: case PA_BLUETOOTH_PROFILE_HSP_HS:
dbus_connection_unregister_object_path(pa_dbus_connection_get(b->connection), HSP_AG_PROFILE); dbus_connection_unregister_object_path(pa_dbus_connection_get(b->connection), HSP_AG_PROFILE);
break; break;
case PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY: case PA_BLUETOOTH_PROFILE_HFP_AG:
dbus_connection_unregister_object_path(pa_dbus_connection_get(b->connection), HSP_HS_PROFILE); dbus_connection_unregister_object_path(pa_dbus_connection_get(b->connection), HSP_HS_PROFILE);
break; break;
default: default:
@ -661,9 +661,9 @@ void pa_bluetooth_native_backend_enable_hs_role(pa_bluetooth_backend *native_bac
return; return;
if (enable_hs_role) if (enable_hs_role)
profile_init(native_backend, PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY); profile_init(native_backend, PA_BLUETOOTH_PROFILE_HFP_AG);
else else
profile_done(native_backend, PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY); profile_done(native_backend, PA_BLUETOOTH_PROFILE_HFP_AG);
native_backend->enable_hs_role = enable_hs_role; native_backend->enable_hs_role = enable_hs_role;
} }
@ -689,8 +689,8 @@ pa_bluetooth_backend *pa_bluetooth_native_backend_new(pa_core *c, pa_bluetooth_d
backend->enable_hs_role = enable_hs_role; backend->enable_hs_role = enable_hs_role;
if (enable_hs_role) if (enable_hs_role)
profile_init(backend, PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY); profile_init(backend, PA_BLUETOOTH_PROFILE_HFP_AG);
profile_init(backend, PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT); profile_init(backend, PA_BLUETOOTH_PROFILE_HSP_HS);
return backend; return backend;
} }
@ -701,8 +701,8 @@ void pa_bluetooth_native_backend_free(pa_bluetooth_backend *backend) {
pa_dbus_free_pending_list(&backend->pending); pa_dbus_free_pending_list(&backend->pending);
if (backend->enable_hs_role) if (backend->enable_hs_role)
profile_done(backend, PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY); profile_done(backend, PA_BLUETOOTH_PROFILE_HFP_AG);
profile_done(backend, PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT); profile_done(backend, PA_BLUETOOTH_PROFILE_HSP_HS);
pa_dbus_connection_unref(backend->connection); pa_dbus_connection_unref(backend->connection);

4
src/modules/bluetooth/backend-ofono.c
View file

@ -303,7 +303,7 @@ static void hf_audio_agent_card_found(pa_bluetooth_backend *backend, const char
const char *key, *value; const char *key, *value;
struct hf_audio_card *card; struct hf_audio_card *card;
pa_bluetooth_device *d; pa_bluetooth_device *d;
pa_bluetooth_profile_t p = PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY; pa_bluetooth_profile_t p = PA_BLUETOOTH_PROFILE_HFP_AG;
pa_assert(backend); pa_assert(backend);
pa_assert(path); pa_assert(path);
@ -337,7 +337,7 @@ static void hf_audio_agent_card_found(pa_bluetooth_backend *backend, const char
card->local_address = pa_xstrdup(value); card->local_address = pa_xstrdup(value);
} else if (pa_streq(key, "Type")) { } else if (pa_streq(key, "Type")) {
if (pa_streq(value, "gateway")) if (pa_streq(value, "gateway"))
p = PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT; p = PA_BLUETOOTH_PROFILE_HSP_HS;
} }
pa_log_debug("%s: %s", key, value); pa_log_debug("%s: %s", key, value);

10
src/modules/bluetooth/bluez5-util.c
View file

@ -196,11 +196,11 @@ static bool device_supports_profile(pa_bluetooth_device *device, pa_bluetooth_pr
return !!pa_hashmap_get(device->uuids, PA_BLUETOOTH_UUID_A2DP_SINK); return !!pa_hashmap_get(device->uuids, PA_BLUETOOTH_UUID_A2DP_SINK);
case PA_BLUETOOTH_PROFILE_A2DP_SOURCE: case PA_BLUETOOTH_PROFILE_A2DP_SOURCE:
return !!pa_hashmap_get(device->uuids, PA_BLUETOOTH_UUID_A2DP_SOURCE); return !!pa_hashmap_get(device->uuids, PA_BLUETOOTH_UUID_A2DP_SOURCE);
case PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT: case PA_BLUETOOTH_PROFILE_HSP_HS:
return !!pa_hashmap_get(device->uuids, PA_BLUETOOTH_UUID_HSP_HS) return !!pa_hashmap_get(device->uuids, PA_BLUETOOTH_UUID_HSP_HS)
|| !!pa_hashmap_get(device->uuids, PA_BLUETOOTH_UUID_HSP_HS_ALT) || !!pa_hashmap_get(device->uuids, PA_BLUETOOTH_UUID_HSP_HS_ALT)
|| !!pa_hashmap_get(device->uuids, PA_BLUETOOTH_UUID_HFP_HF); || !!pa_hashmap_get(device->uuids, PA_BLUETOOTH_UUID_HFP_HF);
case PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY: case PA_BLUETOOTH_PROFILE_HFP_AG:
return !!pa_hashmap_get(device->uuids, PA_BLUETOOTH_UUID_HSP_AG) return !!pa_hashmap_get(device->uuids, PA_BLUETOOTH_UUID_HSP_AG)
|| !!pa_hashmap_get(device->uuids, PA_BLUETOOTH_UUID_HFP_AG); || !!pa_hashmap_get(device->uuids, PA_BLUETOOTH_UUID_HFP_AG);
case PA_BLUETOOTH_PROFILE_OFF: case PA_BLUETOOTH_PROFILE_OFF:
@ -1447,7 +1447,7 @@ void pa_bluetooth_discovery_set_ofono_running(pa_bluetooth_discovery *y, bool is
pa_bluetooth_device *d; pa_bluetooth_device *d;
PA_HASHMAP_FOREACH(d, y->devices, state) { PA_HASHMAP_FOREACH(d, y->devices, state) {
if (device_supports_profile(d, PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY)) { if (device_supports_profile(d, PA_BLUETOOTH_PROFILE_HFP_AG)) {
DBusMessage *m; DBusMessage *m;
pa_assert_se(m = dbus_message_new_method_call(BLUEZ_SERVICE, d->path, BLUEZ_DEVICE_INTERFACE, "Disconnect")); pa_assert_se(m = dbus_message_new_method_call(BLUEZ_SERVICE, d->path, BLUEZ_DEVICE_INTERFACE, "Disconnect"));
@ -1697,9 +1697,9 @@ const char *pa_bluetooth_profile_to_string(pa_bluetooth_profile_t profile) {
return "a2dp_sink"; return "a2dp_sink";
case PA_BLUETOOTH_PROFILE_A2DP_SOURCE: case PA_BLUETOOTH_PROFILE_A2DP_SOURCE:
return "a2dp_source"; return "a2dp_source";
case PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT: case PA_BLUETOOTH_PROFILE_HSP_HS:
return "headset_head_unit"; return "headset_head_unit";
case PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY: case PA_BLUETOOTH_PROFILE_HFP_AG:
return "headset_audio_gateway"; return "headset_audio_gateway";
case PA_BLUETOOTH_PROFILE_OFF: case PA_BLUETOOTH_PROFILE_OFF:
return "off"; return "off";

4
src/modules/bluetooth/bluez5-util.h
View file

@ -70,8 +70,8 @@ typedef enum pa_bluetooth_hook {
typedef enum profile { typedef enum profile {
PA_BLUETOOTH_PROFILE_A2DP_SINK, PA_BLUETOOTH_PROFILE_A2DP_SINK,
PA_BLUETOOTH_PROFILE_A2DP_SOURCE, PA_BLUETOOTH_PROFILE_A2DP_SOURCE,
PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT, PA_BLUETOOTH_PROFILE_HSP_HS,
PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY, PA_BLUETOOTH_PROFILE_HFP_AG,
PA_BLUETOOTH_PROFILE_OFF PA_BLUETOOTH_PROFILE_OFF
} pa_bluetooth_profile_t; } pa_bluetooth_profile_t;
#define PA_BLUETOOTH_PROFILE_COUNT PA_BLUETOOTH_PROFILE_OFF #define PA_BLUETOOTH_PROFILE_COUNT PA_BLUETOOTH_PROFILE_OFF

54
src/modules/bluetooth/module-bluez5-device.c
View file

@ -261,8 +261,8 @@ static int sco_process_render(struct userdata *u) {
int saved_errno; int saved_errno;
pa_assert(u); pa_assert(u);
pa_assert(u->profile == PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT || pa_assert(u->profile == PA_BLUETOOTH_PROFILE_HSP_HS ||
u->profile == PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY); u->profile == PA_BLUETOOTH_PROFILE_HFP_AG);
pa_assert(u->sink); pa_assert(u->sink);
pa_sink_render_full(u->sink, u->write_block_size, &memchunk); pa_sink_render_full(u->sink, u->write_block_size, &memchunk);
@ -327,8 +327,8 @@ static int sco_process_push(struct userdata *u) {
pa_usec_t tstamp = 0; pa_usec_t tstamp = 0;
pa_assert(u); pa_assert(u);
pa_assert(u->profile == PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT || pa_assert(u->profile == PA_BLUETOOTH_PROFILE_HSP_HS ||
u->profile == PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY); u->profile == PA_BLUETOOTH_PROFILE_HFP_AG);
pa_assert(u->source); pa_assert(u->source);
pa_assert(u->read_smoother); pa_assert(u->read_smoother);
@ -767,7 +767,7 @@ static void handle_sink_block_size_change(struct userdata *u) {
/* Run from I/O thread */ /* Run from I/O thread */
static void transport_config_mtu(struct userdata *u) { static void transport_config_mtu(struct userdata *u) {
if (u->profile == PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT || u->profile == PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY) { if (u->profile == PA_BLUETOOTH_PROFILE_HSP_HS || u->profile == PA_BLUETOOTH_PROFILE_HFP_AG) {
u->read_block_size = u->read_link_mtu; u->read_block_size = u->read_link_mtu;
u->write_block_size = u->write_link_mtu; u->write_block_size = u->write_link_mtu;
@ -984,7 +984,7 @@ static void source_set_volume_cb(pa_source *s) {
pa_cvolume_set(&s->real_volume, u->decoder_sample_spec.channels, volume); pa_cvolume_set(&s->real_volume, u->decoder_sample_spec.channels, volume);
/* Set soft volume when in headset role */ /* Set soft volume when in headset role */
if (u->profile == PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY) if (u->profile == PA_BLUETOOTH_PROFILE_HFP_AG)
pa_cvolume_set(&s->soft_volume, u->decoder_sample_spec.channels, volume); pa_cvolume_set(&s->soft_volume, u->decoder_sample_spec.channels, volume);
/* If we are in the AG role, we send a command to the head set to change /* If we are in the AG role, we send a command to the head set to change
@ -1009,7 +1009,7 @@ static int add_source(struct userdata *u) {
if (u->a2dp_codec) if (u->a2dp_codec)
pa_proplist_sets(data.proplist, PA_PROP_BLUETOOTH_CODEC, u->a2dp_codec->name); pa_proplist_sets(data.proplist, PA_PROP_BLUETOOTH_CODEC, u->a2dp_codec->name);
pa_source_new_data_set_sample_spec(&data, &u->decoder_sample_spec); pa_source_new_data_set_sample_spec(&data, &u->decoder_sample_spec);
if (u->profile == PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT) if (u->profile == PA_BLUETOOTH_PROFILE_HSP_HS)
pa_proplist_sets(data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone"); pa_proplist_sets(data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
connect_ports(u, &data, PA_DIRECTION_INPUT); connect_ports(u, &data, PA_DIRECTION_INPUT);
@ -1017,10 +1017,10 @@ static int add_source(struct userdata *u) {
if (!u->transport_acquired) if (!u->transport_acquired)
switch (u->profile) { switch (u->profile) {
case PA_BLUETOOTH_PROFILE_A2DP_SOURCE: case PA_BLUETOOTH_PROFILE_A2DP_SOURCE:
case PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY: case PA_BLUETOOTH_PROFILE_HFP_AG:
data.suspend_cause = PA_SUSPEND_USER; data.suspend_cause = PA_SUSPEND_USER;
break; break;
case PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT: case PA_BLUETOOTH_PROFILE_HSP_HS:
/* u->stream_fd contains the error returned by the last transport_acquire() /* u->stream_fd contains the error returned by the last transport_acquire()
* EAGAIN means we are waiting for a NewConnection signal */ * EAGAIN means we are waiting for a NewConnection signal */
if (u->stream_fd == -EAGAIN) if (u->stream_fd == -EAGAIN)
@ -1045,7 +1045,7 @@ static int add_source(struct userdata *u) {
u->source->parent.process_msg = source_process_msg; u->source->parent.process_msg = source_process_msg;
u->source->set_state_in_io_thread = source_set_state_in_io_thread_cb; u->source->set_state_in_io_thread = source_set_state_in_io_thread_cb;
if (u->profile == PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT || u->profile == PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY) { if (u->profile == PA_BLUETOOTH_PROFILE_HSP_HS || u->profile == PA_BLUETOOTH_PROFILE_HFP_AG) {
pa_source_set_set_volume_callback(u->source, source_set_volume_cb); pa_source_set_set_volume_callback(u->source, source_set_volume_cb);
u->source->n_volume_steps = 16; u->source->n_volume_steps = 16;
} }
@ -1170,7 +1170,7 @@ static void sink_set_volume_cb(pa_sink *s) {
pa_cvolume_set(&s->real_volume, u->encoder_sample_spec.channels, volume); pa_cvolume_set(&s->real_volume, u->encoder_sample_spec.channels, volume);
/* Set soft volume when in headset role */ /* Set soft volume when in headset role */
if (u->profile == PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY) if (u->profile == PA_BLUETOOTH_PROFILE_HFP_AG)
pa_cvolume_set(&s->soft_volume, u->encoder_sample_spec.channels, volume); pa_cvolume_set(&s->soft_volume, u->encoder_sample_spec.channels, volume);
/* If we are in the AG role, we send a command to the head set to change /* If we are in the AG role, we send a command to the head set to change
@ -1195,17 +1195,17 @@ static int add_sink(struct userdata *u) {
if (u->a2dp_codec) if (u->a2dp_codec)
pa_proplist_sets(data.proplist, PA_PROP_BLUETOOTH_CODEC, u->a2dp_codec->name); pa_proplist_sets(data.proplist, PA_PROP_BLUETOOTH_CODEC, u->a2dp_codec->name);
pa_sink_new_data_set_sample_spec(&data, &u->encoder_sample_spec); pa_sink_new_data_set_sample_spec(&data, &u->encoder_sample_spec);
if (u->profile == PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT) if (u->profile == PA_BLUETOOTH_PROFILE_HSP_HS)
pa_proplist_sets(data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone"); pa_proplist_sets(data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
connect_ports(u, &data, PA_DIRECTION_OUTPUT); connect_ports(u, &data, PA_DIRECTION_OUTPUT);
if (!u->transport_acquired) if (!u->transport_acquired)
switch (u->profile) { switch (u->profile) {
case PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY: case PA_BLUETOOTH_PROFILE_HFP_AG:
data.suspend_cause = PA_SUSPEND_USER; data.suspend_cause = PA_SUSPEND_USER;
break; break;
case PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT: case PA_BLUETOOTH_PROFILE_HSP_HS:
/* u->stream_fd contains the error returned by the last transport_acquire() /* u->stream_fd contains the error returned by the last transport_acquire()
* EAGAIN means we are waiting for a NewConnection signal */ * EAGAIN means we are waiting for a NewConnection signal */
if (u->stream_fd == -EAGAIN) if (u->stream_fd == -EAGAIN)
@ -1232,7 +1232,7 @@ static int add_sink(struct userdata *u) {
u->sink->parent.process_msg = sink_process_msg; u->sink->parent.process_msg = sink_process_msg;
u->sink->set_state_in_io_thread = sink_set_state_in_io_thread_cb; u->sink->set_state_in_io_thread = sink_set_state_in_io_thread_cb;
if (u->profile == PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT || u->profile == PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY) { if (u->profile == PA_BLUETOOTH_PROFILE_HSP_HS || u->profile == PA_BLUETOOTH_PROFILE_HFP_AG) {
pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb); pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb);
u->sink->n_volume_steps = 16; u->sink->n_volume_steps = 16;
} }
@ -1241,7 +1241,7 @@ static int add_sink(struct userdata *u) {
/* Run from main thread */ /* Run from main thread */
static int transport_config(struct userdata *u) { static int transport_config(struct userdata *u) {
if (u->profile == PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT || u->profile == PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY) { if (u->profile == PA_BLUETOOTH_PROFILE_HSP_HS || u->profile == PA_BLUETOOTH_PROFILE_HFP_AG) {
u->encoder_sample_spec.format = PA_SAMPLE_S16LE; u->encoder_sample_spec.format = PA_SAMPLE_S16LE;
u->encoder_sample_spec.channels = 1; u->encoder_sample_spec.channels = 1;
u->encoder_sample_spec.rate = 8000; u->encoder_sample_spec.rate = 8000;
@ -1292,7 +1292,7 @@ static int setup_transport(struct userdata *u) {
u->transport = t; u->transport = t;
if (u->profile == PA_BLUETOOTH_PROFILE_A2DP_SOURCE || u->profile == PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY) if (u->profile == PA_BLUETOOTH_PROFILE_A2DP_SOURCE || u->profile == PA_BLUETOOTH_PROFILE_HFP_AG)
transport_acquire(u, true); /* In case of error, the sink/sources will be created suspended */ transport_acquire(u, true); /* In case of error, the sink/sources will be created suspended */
else { else {
int transport_error; int transport_error;
@ -1310,8 +1310,8 @@ static pa_direction_t get_profile_direction(pa_bluetooth_profile_t p) {
static const pa_direction_t profile_direction[] = { static const pa_direction_t profile_direction[] = {
[PA_BLUETOOTH_PROFILE_A2DP_SINK] = PA_DIRECTION_OUTPUT, [PA_BLUETOOTH_PROFILE_A2DP_SINK] = PA_DIRECTION_OUTPUT,
[PA_BLUETOOTH_PROFILE_A2DP_SOURCE] = PA_DIRECTION_INPUT, [PA_BLUETOOTH_PROFILE_A2DP_SOURCE] = PA_DIRECTION_INPUT,
[PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT] = PA_DIRECTION_INPUT | PA_DIRECTION_OUTPUT, [PA_BLUETOOTH_PROFILE_HSP_HS] = PA_DIRECTION_INPUT | PA_DIRECTION_OUTPUT,
[PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY] = PA_DIRECTION_INPUT | PA_DIRECTION_OUTPUT, [PA_BLUETOOTH_PROFILE_HFP_AG] = PA_DIRECTION_INPUT | PA_DIRECTION_OUTPUT,
[PA_BLUETOOTH_PROFILE_OFF] = 0 [PA_BLUETOOTH_PROFILE_OFF] = 0
}; };
@ -1645,7 +1645,7 @@ static int start_thread(struct userdata *u) {
/* If we are in the headset role, the sink should not become default /* If we are in the headset role, the sink should not become default
* unless there is no other sound device available. */ * unless there is no other sound device available. */
if (u->profile == PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY) if (u->profile == PA_BLUETOOTH_PROFILE_HFP_AG)
u->sink->priority = 1500; u->sink->priority = 1500;
pa_sink_put(u->sink); pa_sink_put(u->sink);
@ -1661,7 +1661,7 @@ static int start_thread(struct userdata *u) {
/* If we are in the headset role or the device is an a2dp source, /* If we are in the headset role or the device is an a2dp source,
* the source should not become default unless there is no other * the source should not become default unless there is no other
* sound device available. */ * sound device available. */
if (u->profile == PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY || u->profile == PA_BLUETOOTH_PROFILE_A2DP_SOURCE) if (u->profile == PA_BLUETOOTH_PROFILE_HFP_AG || u->profile == PA_BLUETOOTH_PROFILE_A2DP_SOURCE)
u->source->priority = 1500; u->source->priority = 1500;
pa_source_put(u->source); pa_source_put(u->source);
@ -1929,7 +1929,7 @@ static pa_card_profile *create_card_profile(struct userdata *u, pa_bluetooth_pro
p = PA_CARD_PROFILE_DATA(cp); p = PA_CARD_PROFILE_DATA(cp);
break; break;
case PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT: case PA_BLUETOOTH_PROFILE_HSP_HS:
cp = pa_card_profile_new(name, _("Headset Head Unit (HSP/HFP)"), sizeof(pa_bluetooth_profile_t)); cp = pa_card_profile_new(name, _("Headset Head Unit (HSP/HFP)"), sizeof(pa_bluetooth_profile_t));
cp->priority = 30; cp->priority = 30;
cp->n_sinks = 1; cp->n_sinks = 1;
@ -1942,7 +1942,7 @@ static pa_card_profile *create_card_profile(struct userdata *u, pa_bluetooth_pro
p = PA_CARD_PROFILE_DATA(cp); p = PA_CARD_PROFILE_DATA(cp);
break; break;
case PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY: case PA_BLUETOOTH_PROFILE_HFP_AG:
cp = pa_card_profile_new(name, _("Headset Audio Gateway (HSP/HFP)"), sizeof(pa_bluetooth_profile_t)); cp = pa_card_profile_new(name, _("Headset Audio Gateway (HSP/HFP)"), sizeof(pa_bluetooth_profile_t));
cp->priority = 10; cp->priority = 10;
cp->n_sinks = 1; cp->n_sinks = 1;
@ -2017,9 +2017,9 @@ static int uuid_to_profile(const char *uuid, pa_bluetooth_profile_t *_r) {
else if (pa_streq(uuid, PA_BLUETOOTH_UUID_A2DP_SOURCE)) else if (pa_streq(uuid, PA_BLUETOOTH_UUID_A2DP_SOURCE))
*_r = PA_BLUETOOTH_PROFILE_A2DP_SOURCE; *_r = PA_BLUETOOTH_PROFILE_A2DP_SOURCE;
else if (pa_bluetooth_uuid_is_hsp_hs(uuid) || pa_streq(uuid, PA_BLUETOOTH_UUID_HFP_HF)) else if (pa_bluetooth_uuid_is_hsp_hs(uuid) || pa_streq(uuid, PA_BLUETOOTH_UUID_HFP_HF))
*_r = PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT; *_r = PA_BLUETOOTH_PROFILE_HSP_HS;
else if (pa_streq(uuid, PA_BLUETOOTH_UUID_HSP_AG) || pa_streq(uuid, PA_BLUETOOTH_UUID_HFP_AG)) else if (pa_streq(uuid, PA_BLUETOOTH_UUID_HSP_AG) || pa_streq(uuid, PA_BLUETOOTH_UUID_HFP_AG))
*_r = PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY; *_r = PA_BLUETOOTH_PROFILE_HFP_AG;
else else
return -PA_ERR_INVALID; return -PA_ERR_INVALID;
@ -2235,7 +2235,7 @@ static pa_hook_result_t transport_speaker_gain_changed_cb(pa_bluetooth_discovery
volume++; volume++;
pa_cvolume_set(&v, u->encoder_sample_spec.channels, volume); pa_cvolume_set(&v, u->encoder_sample_spec.channels, volume);
if (t->profile == PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT) if (t->profile == PA_BLUETOOTH_PROFILE_HSP_HS)
pa_sink_volume_changed(u->sink, &v); pa_sink_volume_changed(u->sink, &v);
else else
pa_sink_set_volume(u->sink, &v, true, true); pa_sink_set_volume(u->sink, &v, true, true);
@ -2263,7 +2263,7 @@ static pa_hook_result_t transport_microphone_gain_changed_cb(pa_bluetooth_discov
pa_cvolume_set(&v, u->decoder_sample_spec.channels, volume); pa_cvolume_set(&v, u->decoder_sample_spec.channels, volume);
if (t->profile == PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT) if (t->profile == PA_BLUETOOTH_PROFILE_HSP_HS)
pa_source_volume_changed(u->source, &v); pa_source_volume_changed(u->source, &v);
else else
pa_source_set_volume(u->source, &v, true, true); pa_source_set_volume(u->source, &v, true, true);