pstruebi/bumble_fork
1
0
Fork 0
forked from auracaster/bumble_mirror
Code Pull Requests Activity

add support for multiple concurrent broadcasts

Browse Source
This commit is contained in:
Gilles Boccon-Gibod
2025-12-05 10:54:23 -05:00
parent b4261548e8
commit 32bb7cdaf3
10 changed files with 868 additions and 512 deletions
Download Patch File Download Diff File Expand all files Collapse all files

584
apps/auracast.py
View File

@@ -23,10 +23,14 @@ import contextlib
import dataclasses
import functools
import logging
from collections.abc import AsyncGenerator, Coroutine
from typing import Any
import secrets
from collections.abc import AsyncGenerator, Awaitable, Callable, Iterable, Sequence
from typing import (
Any,
)
import click
import tomli
try:
import lc3 # type: ignore # pylint: disable=E0401
@@ -58,8 +62,11 @@ AURACAST_DEFAULT_DEVICE_ADDRESS = hci.Address('F0:F1:F2:F3:F4:F5')
AURACAST_DEFAULT_SYNC_TIMEOUT = 5.0
AURACAST_DEFAULT_ATT_MTU = 256
AURACAST_DEFAULT_FRAME_DURATION = 10000
AURACAST_DEFAULT_SAMPLE_RATE = 48000
AURACAST_DEFAULT_TRANSMIT_BITRATE = 80000
AURACAST_DEFAULT_BROADCAST_ID = 123456
AURACAST_DEFAULT_BROADCAST_NAME = 'Bumble Auracast'
AURACAST_DEFAULT_LANGUAGE = 'en'
AURACAST_DEFAULT_PROGRAM_INFO = 'Disco'
# -----------------------------------------------------------------------------
@@ -103,6 +110,95 @@ def broadcast_code_bytes(broadcast_code: str) -> bytes:
return broadcast_code_utf8 + padding
def parse_broadcast_list(filename: str) -> Sequence[Broadcast]:
broadcasts: list[Broadcast] = []
with open(filename, "rb") as config_file:
config = tomli.load(config_file)
for broadcast in config.get("broadcasts", []):
sources = []
for source in broadcast.get("sources", []):
sources.append(
BroadcastSource(
input=source["input"],
input_format=source.get("format", "auto"),
bitrate=source.get(
"bitrate", AURACAST_DEFAULT_TRANSMIT_BITRATE
),
)
)
manufacturer_data = broadcast.get("manufacturer_data")
if manufacturer_data is not None:
manufacturer_data = (
manufacturer_data.get("company_id"),
bytes.fromhex(manufacturer_data["data"]),
)
broadcasts.append(
Broadcast(
sources=sources,
public=broadcast.get("public", True),
broadcast_id=broadcast.get("id", AURACAST_DEFAULT_BROADCAST_ID),
broadcast_name=broadcast["name"],
broadcast_code=broadcast.get("code"),
manufacturer_data=broadcast.get("manufacturer_data"),
language=broadcast.get("language"),
program_info=broadcast.get("program_info"),
)
)
return broadcasts
def assign_broadcast_ids(broadcasts: Sequence[Broadcast]) -> None:
broadcast_ids = set()
for broadcast in broadcasts:
if broadcast.broadcast_id:
if broadcast.broadcast_id in broadcast_ids:
raise ValueError(f'duplicate broadcast ID {broadcast.broadcast_id}')
broadcast_ids.add(broadcast.broadcast_id)
else:
while True:
broadcast.broadcast_id = 1 + secrets.randbelow(0xFFFFFF)
if broadcast.broadcast_id not in broadcast_ids:
broadcast_ids.add(broadcast.broadcast_id)
break
@dataclasses.dataclass
class Broadcast:
sources: list[BroadcastSource]
public: bool
broadcast_id: int # 0 means unassigned
broadcast_name: str
broadcast_code: str | None
manufacturer_data: tuple[int, bytes] | None = None
language: str | None = None
program_info: str | None = None
audio_sources: list[AudioSource] = dataclasses.field(default_factory=list)
iso_queues: list[bumble.device.IsoPacketStream] = dataclasses.field(
default_factory=list
)
@dataclasses.dataclass
class BroadcastSource:
input: str
input_format: str
bitrate: int
@dataclasses.dataclass
class AudioSource:
audio_input: audio_io.AudioInput
pcm_format: audio_io.PcmFormat
pcm_bit_depth: int | None
lc3_encoder: lc3.Encoder
lc3_frame_samples: int
lc3_frame_size: int
audio_frames: AsyncGenerator
# -----------------------------------------------------------------------------
# Scan For Broadcasts
# -----------------------------------------------------------------------------
@@ -119,6 +215,7 @@ class BroadcastScanner(bumble.utils.EventEmitter):
appearance: core.Appearance | None = None
biginfo: bumble.device.BigInfoAdvertisement | None = None
manufacturer_data: tuple[str, bytes] | None = None
device_name: str | None = None
def __post_init__(self) -> None:
super().__init__()
@@ -146,6 +243,10 @@ class BroadcastScanner(bumble.utils.EventEmitter):
)
continue
self.device_name = advertisement.data.get(
core.AdvertisingData.Type.COMPLETE_LOCAL_NAME
)
self.appearance = advertisement.data.get(
core.AdvertisingData.Type.APPEARANCE
)
@@ -170,7 +271,9 @@ class BroadcastScanner(bumble.utils.EventEmitter):
color(self.sync.state.name, 'green'),
)
if self.name is not None:
print(f' {color("Name", "cyan")}: {self.name}')
print(f' {color("Broadcast Name", "cyan")}: {self.name}')
if self.device_name:
print(f' {color("Device Name", "cyan")}: {self.device_name}')
if self.appearance:
print(f' {color("Appearance", "cyan")}: {str(self.appearance)}')
print(f' {color("RSSI", "cyan")}: {self.rssi}')
@@ -193,8 +296,13 @@ class BroadcastScanner(bumble.utils.EventEmitter):
f' {color("Features", "cyan")}: '
f'{self.public_broadcast_announcement.features.name}'
)
if self.public_broadcast_announcement.metadata.entries:
print(f' {color("Metadata", "cyan")}: ')
print(self.public_broadcast_announcement.metadata.pretty_print(' '))
print(
self.public_broadcast_announcement.metadata.pretty_print(
' '
)
)
if self.basic_audio_announcement:
print(color(' Audio:', 'cyan'))
@@ -210,6 +318,7 @@ class BroadcastScanner(bumble.utils.EventEmitter):
color(' Coding Format: ', 'green'),
subgroup.codec_id.codec_id.name,
)
if subgroup.codec_id.company_id:
print(
color(' Company ID: ', 'green'),
subgroup.codec_id.company_id,
@@ -224,6 +333,7 @@ class BroadcastScanner(bumble.utils.EventEmitter):
subgroup.codec_specific_configuration, ' '
),
)
if subgroup.metadata.entries:
print(color(' Metadata: ', 'yellow'))
print(subgroup.metadata.pretty_print(' '))
@@ -292,7 +402,7 @@ class BroadcastScanner(bumble.utils.EventEmitter):
self.device = device
self.filter_duplicates = filter_duplicates
self.sync_timeout = sync_timeout
self.broadcasts = dict[hci.Address, BroadcastScanner.Broadcast]()
self.broadcasts = dict[tuple[hci.Address, int], BroadcastScanner.Broadcast]()
device.on('advertisement', self.on_advertisement)
async def start(self) -> None:
@@ -310,7 +420,7 @@ class BroadcastScanner(bumble.utils.EventEmitter):
core.AdvertisingData.Type.SERVICE_DATA_16_BIT_UUID
)
) or not (
broadcast_audio_announcement := next(
broadcast_audio_announcement_ad := next(
(
ad
for ad in ads
@@ -325,7 +435,13 @@ class BroadcastScanner(bumble.utils.EventEmitter):
core.AdvertisingData.Type.BROADCAST_NAME
)
if broadcast := self.broadcasts.get(advertisement.address):
broadcast_audio_announcement = bap.BroadcastAudioAnnouncement.from_bytes(
broadcast_audio_announcement_ad[1]
)
if broadcast := self.broadcasts.get(
(advertisement.address, broadcast_audio_announcement.broadcast_id)
):
broadcast.update(advertisement)
return
@@ -333,9 +449,7 @@ class BroadcastScanner(bumble.utils.EventEmitter):
self.on_new_broadcast(
broadcast_name[0] if broadcast_name else None,
advertisement,
bap.BroadcastAudioAnnouncement.from_bytes(
broadcast_audio_announcement[1]
).broadcast_id,
broadcast_audio_announcement.broadcast_id,
)
)
@@ -353,12 +467,12 @@ class BroadcastScanner(bumble.utils.EventEmitter):
)
broadcast = self.Broadcast(name, periodic_advertising_sync, broadcast_id)
broadcast.update(advertisement)
self.broadcasts[advertisement.address] = broadcast
self.broadcasts[(advertisement.address, broadcast_id)] = broadcast
periodic_advertising_sync.on('loss', lambda: self.on_broadcast_loss(broadcast))
self.emit('new_broadcast', broadcast)
def on_broadcast_loss(self, broadcast: Broadcast) -> None:
del self.broadcasts[broadcast.sync.advertiser_address]
def on_broadcast_loss(self, broadcast: BroadcastScanner.Broadcast) -> None:
del self.broadcasts[(broadcast.sync.advertiser_address, broadcast.broadcast_id)]
bumble.utils.AsyncRunner.spawn(broadcast.sync.terminate())
self.emit('broadcast_loss', broadcast)
@@ -462,9 +576,8 @@ async def find_broadcast_by_name(
async def run_scan(
filter_duplicates: bool, sync_timeout: float, transport: str
device: bumble.device.Device, filter_duplicates: bool, sync_timeout: float
) -> None:
async with create_device(transport) as device:
if not device.supports_le_periodic_advertising:
print(color('Periodic advertising not supported', 'red'))
return
@@ -475,13 +588,12 @@ async def run_scan(
async def run_assist(
device: bumble.device.Device,
broadcast_name: str | None,
source_id: int | None,
command: str,
transport: str,
address: str,
) -> None:
async with create_device(transport) as device:
if not device.supports_le_periodic_advertising:
print(color('Periodic advertising not supported', 'red'))
return
@@ -513,15 +625,14 @@ async def run_assist(
# Subscribe to and read the broadcast receive state characteristics
def on_broadcast_receive_state_update(
value: bass.BroadcastReceiveState, index: int
value: bass.BroadcastReceiveState | None, index: int
) -> None:
if value is not None:
print(
f"{color(f'Broadcast Receive State Update [{index}]:', 'green')} {value}"
)
for i, broadcast_receive_state in enumerate(
bass_client.broadcast_receive_states
):
for i, broadcast_receive_state in enumerate(bass_client.broadcast_receive_states):
try:
await broadcast_receive_state.subscribe(
functools.partial(on_broadcast_receive_state_update, index=i)
@@ -535,9 +646,7 @@ async def run_assist(
error,
)
value = await broadcast_receive_state.read_value()
print(
f'{color(f"Initial Broadcast Receive State [{i}]:", "green")} {value}'
)
print(f'{color(f"Initial Broadcast Receive State [{i}]:", "green")} {value}')
if command == 'monitor-state':
await peer.sustain()
@@ -645,8 +754,7 @@ async def run_assist(
print(color(f'!!! invalid command {command}'))
async def run_pair(transport: str, address: str) -> None:
async with create_device(transport) as device:
async def run_pair(device: bumble.device.Device, address: str) -> None:
# Connect to the server
print(f'=== Connecting to {address}...')
async with device.connect_as_gatt(address) as peer:
@@ -658,7 +766,7 @@ async def run_pair(transport: str, address: str) -> None:
async def run_receive(
transport: str,
device: bumble.device.Device,
broadcast_id: int | None,
output: str,
broadcast_code: str | None,
@@ -673,7 +781,6 @@ async def run_receive(
print(error)
return
async with create_device(transport) as device:
if not device.supports_le_periodic_advertising:
print(color('Periodic advertising not supported', 'red'))
return
@@ -741,9 +848,10 @@ async def run_receive(
]
packet_stats = [0, 0]
async with contextlib.AsyncExitStack() as stack:
audio_output = await audio_io.create_audio_output(output)
stack.push_async_callback(audio_output.aclose)
# This try should be replaced with contextlib.aclosing() when python 3.9 is no
# longer needed.
try:
await audio_output.open(
audio_io.PcmFormat(
audio_io.PcmFormat.Endianness.LITTLE,
@@ -791,52 +899,167 @@ async def run_receive(
terminated = asyncio.Event()
big_sync.on(big_sync.Event.TERMINATION, lambda _: terminated.set())
await terminated.wait()
finally:
await audio_output.aclose()
async def run_transmit(
transport: str,
broadcast_id: int,
broadcast_code: str | None,
broadcast_name: str,
bitrate: int,
manufacturer_data: tuple[int, bytes] | None,
input: str,
input_format: str,
device: bumble.device.Device, broadcasts: Iterable[Broadcast]
) -> None:
# Run a pre-flight check for the input.
# Run a pre-flight check for the input(s).
try:
if not audio_io.check_audio_input(input):
for broadcast in broadcasts:
for source in broadcast.sources:
if not audio_io.check_audio_input(source.input):
return
except ValueError as error:
print(error)
return
async with create_device(transport) as device:
if not device.supports_le_periodic_advertising:
print(color('Periodic advertising not supported', 'red'))
return
def on_flow():
pending = []
queued = []
completed = []
for broadcast in broadcasts:
for iso_queue in broadcast.iso_queues:
data_packet_queue = iso_queue.data_packet_queue
pending.append(str(data_packet_queue.pending))
queued.append(str(data_packet_queue.queued))
completed.append(str(data_packet_queue.completed))
print(
f'\rPACKETS: '
f'pending={",".join(pending)} | '
f'queued={",".join(queued)} | '
f'completed={",".join(completed)}',
end='',
)
audio_inputs: list[audio_io.AudioInput] = []
try:
# Setup audio sources
for broadcast_index, broadcast in enumerate(broadcasts):
channel_count = 0
max_lc3_frame_size = 0
max_sample_rate = 0
for source in broadcast.sources:
print(f'Setting up audio input: {source.input}')
# Open the audio input
audio_input = await audio_io.create_audio_input(
source.input, source.input_format
)
pcm_format = await audio_input.open()
audio_inputs.append(audio_input)
# Check that the number of channels is supported
if pcm_format.channels not in (1, 2):
print("Only 1 and 2 channels PCM configurations are supported")
return
channel_count += pcm_format.channels
# Check that the sample type is supported
if pcm_format.sample_type == audio_io.PcmFormat.SampleType.INT16:
pcm_bit_depth = 16
elif pcm_format.sample_type == audio_io.PcmFormat.SampleType.FLOAT32:
pcm_bit_depth = None
else:
print("Only INT16 and FLOAT32 sample types are supported")
return
# Check that the sample rate is supported
if pcm_format.sample_rate not in (16000, 24000, 48000):
print(f'Sample rate {pcm_format.sample_rate} not supported')
return
max_sample_rate = max(max_sample_rate, pcm_format.sample_rate)
# Compute LC3 parameters and create and encoder
encoder = lc3.Encoder(
frame_duration_us=AURACAST_DEFAULT_FRAME_DURATION,
sample_rate_hz=pcm_format.sample_rate,
num_channels=pcm_format.channels,
input_sample_rate_hz=pcm_format.sample_rate,
)
lc3_frame_samples = encoder.get_frame_samples()
lc3_frame_size = encoder.get_frame_bytes(source.bitrate)
max_lc3_frame_size = max(max_lc3_frame_size, lc3_frame_size)
print(
f'Encoding {source.input} with {lc3_frame_samples} '
f'PCM samples per {lc3_frame_size} byte frame'
)
broadcast.audio_sources.append(
AudioSource(
audio_input=audio_input,
pcm_format=pcm_format,
pcm_bit_depth=pcm_bit_depth,
lc3_encoder=encoder,
lc3_frame_samples=lc3_frame_samples,
lc3_frame_size=lc3_frame_size,
audio_frames=audio_input.frames(lc3_frame_samples),
)
)
# Setup advertising and BIGs
metadata = le_audio.Metadata()
if broadcast.language is not None:
metadata.entries.append(
le_audio.Metadata.Entry(
tag=le_audio.Metadata.Tag.LANGUAGE,
data=broadcast.language.encode('utf-8'),
)
)
if broadcast.program_info is not None:
metadata.entries.append(
le_audio.Metadata.Entry(
tag=le_audio.Metadata.Tag.PROGRAM_INFO,
data=broadcast.program_info.encode('utf-8'),
)
)
if broadcast.public:
# Infer features from sources
features = pbp.PublicBroadcastAnnouncement.Features(0)
if broadcast.broadcast_code is not None:
features |= pbp.PublicBroadcastAnnouncement.Features.ENCRYPTED
for audio_source in broadcast.audio_sources:
if audio_source.pcm_format.sample_rate == 48000:
features |= (
pbp.PublicBroadcastAnnouncement.Features.HIGH_QUALITY_CONFIGURATION
)
else:
features |= (
pbp.PublicBroadcastAnnouncement.Features.STANDARD_QUALITY_CONFIGURATION
)
public_broadcast_announcement = pbp.PublicBroadcastAnnouncement(
features=features, metadata=metadata
)
else:
public_broadcast_announcement = None
broadcast_audio_announcement = bap.BroadcastAudioAnnouncement(
broadcast.broadcast_id
)
basic_audio_announcement = bap.BasicAudioAnnouncement(
presentation_delay=40000,
subgroups=[
bap.BasicAudioAnnouncement.Subgroup(
codec_id=hci.CodingFormat(codec_id=hci.CodecID.LC3),
codec_specific_configuration=bap.CodecSpecificConfiguration(
sampling_frequency=bap.SamplingFrequency.FREQ_48000,
sampling_frequency=bap.SamplingFrequency.from_hz(
audio_source.pcm_format.sample_rate
),
frame_duration=bap.FrameDuration.DURATION_10000_US,
octets_per_codec_frame=100,
octets_per_codec_frame=audio_source.lc3_frame_size,
),
metadata=le_audio.Metadata(
metadata=le_audio.Metadata(),
bis=(
[
le_audio.Metadata.Entry(
tag=le_audio.Metadata.Tag.LANGUAGE, data=b'eng'
),
le_audio.Metadata.Entry(
tag=le_audio.Metadata.Tag.PROGRAM_INFO, data=b'Disco'
),
]
),
bis=[
bap.BasicAudioAnnouncement.BIS(
index=1,
codec_specific_configuration=bap.CodecSpecificConfiguration(
@@ -849,124 +1072,134 @@ async def run_transmit(
audio_channel_allocation=bap.AudioLocation.FRONT_RIGHT
),
),
]
if audio_source.pcm_format.channels == 2
else [
bap.BasicAudioAnnouncement.BIS(
index=1,
codec_specific_configuration=bap.CodecSpecificConfiguration(
audio_channel_allocation=bap.AudioLocation.FRONT_LEFT
),
),
]
),
)
for audio_source in broadcast.audio_sources
],
)
],
)
broadcast_audio_announcement = bap.BroadcastAudioAnnouncement(broadcast_id)
advertising_data_types: list[core.DataType] = [
data_types.BroadcastName(broadcast_name)
data_types.CompleteLocalName(AURACAST_DEFAULT_DEVICE_NAME),
data_types.Appearance(
core.Appearance.Category.AUDIO_SOURCE,
core.Appearance.AudioSourceSubcategory.BROADCASTING_DEVICE,
),
data_types.BroadcastName(broadcast.broadcast_name),
]
if manufacturer_data is not None:
if broadcast.manufacturer_data is not None:
advertising_data_types.append(
data_types.ManufacturerSpecificData(*manufacturer_data)
data_types.ManufacturerSpecificData(*broadcast.manufacturer_data)
)
advertising_data = bytes(core.AdvertisingData(advertising_data_types))
if public_broadcast_announcement:
advertising_data += bytes(
public_broadcast_announcement.get_advertising_data()
)
if broadcast_audio_announcement:
advertising_data += broadcast_audio_announcement.get_advertising_data()
print('Starting Periodic Advertising:')
print(f" Extended Advertising data size: {len(advertising_data)}")
print(
f" Periodic Advertising data size: {len(basic_audio_announcement.get_advertising_data())}"
)
advertising_set = await device.create_advertising_set(
advertising_parameters=bumble.device.AdvertisingParameters(
advertising_event_properties=bumble.device.AdvertisingEventProperties(
is_connectable=False
),
primary_advertising_interval_min=100,
primary_advertising_interval_max=200,
),
advertising_data=(
broadcast_audio_announcement.get_advertising_data()
+ bytes(core.AdvertisingData(advertising_data_types))
primary_advertising_interval_max=1000,
advertising_sid=broadcast_index,
),
advertising_data=advertising_data,
periodic_advertising_parameters=bumble.device.PeriodicAdvertisingParameters(
periodic_advertising_interval_min=80,
periodic_advertising_interval_max=160,
periodic_advertising_interval_min=100,
periodic_advertising_interval_max=1000,
),
periodic_advertising_data=basic_audio_announcement.get_advertising_data(),
auto_restart=True,
auto_start=True,
)
print('Start Periodic Advertising')
await advertising_set.start_periodic()
async with contextlib.AsyncExitStack() as stack:
audio_input = await audio_io.create_audio_input(input, input_format)
pcm_format = await audio_input.open()
stack.push_async_callback(audio_input.aclose)
if pcm_format.channels != 2:
print("Only 2 channels PCM configurations are supported")
return
if pcm_format.sample_type == audio_io.PcmFormat.SampleType.INT16:
pcm_bit_depth = 16
elif pcm_format.sample_type == audio_io.PcmFormat.SampleType.FLOAT32:
pcm_bit_depth = None
else:
print("Only INT16 and FLOAT32 sample types are supported")
return
encoder = lc3.Encoder(
frame_duration_us=AURACAST_DEFAULT_FRAME_DURATION,
sample_rate_hz=AURACAST_DEFAULT_SAMPLE_RATE,
num_channels=pcm_format.channels,
input_sample_rate_hz=pcm_format.sample_rate,
)
lc3_frame_samples = encoder.get_frame_samples()
lc3_frame_size = encoder.get_frame_bytes(bitrate)
print(
f'Encoding with {lc3_frame_samples} '
f'PCM samples per {lc3_frame_size} byte frame'
)
print('Setup BIG')
print('Setting up BIG')
big = await device.create_big(
advertising_set,
parameters=bumble.device.BigParameters(
num_bis=pcm_format.channels,
num_bis=channel_count,
sdu_interval=AURACAST_DEFAULT_FRAME_DURATION,
max_sdu=lc3_frame_size,
max_sdu=max_lc3_frame_size,
max_transport_latency=65,
rtn=4,
broadcast_code=(
broadcast_code_bytes(broadcast_code) if broadcast_code else None
broadcast_code_bytes(broadcast.broadcast_code)
if broadcast.broadcast_code
else None
),
),
)
for bis_link in big.bis_links:
for i, bis_link in enumerate(big.bis_links):
print(f'Setup ISO for BIS {bis_link.handle}')
await bis_link.setup_data_path(
direction=bis_link.Direction.HOST_TO_CONTROLLER
)
iso_queue = bumble.device.IsoPacketStream(bis_link, 64)
iso_queue.data_packet_queue.on('flow', on_flow)
broadcast.iso_queues.append(iso_queue)
iso_queues = [
bumble.device.IsoPacketStream(bis_link, 64)
for bis_link in big.bis_links
print('Transmitting audio from source(s)')
while True:
for broadcast in broadcasts:
iso_queue_index = 0
for audio_source in broadcast.audio_sources:
pcm_frame = await anext(audio_source.audio_frames)
lc3_frame = audio_source.lc3_encoder.encode(
pcm_frame,
num_bytes=audio_source.pcm_format.channels
* audio_source.lc3_frame_size,
bit_depth=audio_source.pcm_bit_depth,
)
for lc3_chunk_start in range(
0, len(lc3_frame), audio_source.lc3_frame_size
):
await broadcast.iso_queues[iso_queue_index].write(
lc3_frame[
lc3_chunk_start : lc3_chunk_start
+ audio_source.lc3_frame_size
]
def on_flow():
data_packet_queue = iso_queues[0].data_packet_queue
print(
f'\rPACKETS: pending={data_packet_queue.pending}, '
f'queued={data_packet_queue.queued}, '
f'completed={data_packet_queue.completed}',
end='',
)
iso_queues[0].data_packet_queue.on('flow', on_flow)
frame_count = 0
async for pcm_frame in audio_input.frames(lc3_frame_samples):
lc3_frame = encoder.encode(
pcm_frame, num_bytes=2 * lc3_frame_size, bit_depth=pcm_bit_depth
)
mid = len(lc3_frame) // 2
await iso_queues[0].write(lc3_frame[:mid])
await iso_queues[1].write(lc3_frame[mid:])
frame_count += 1
iso_queue_index += 1
finally:
for audio_input in audio_inputs:
await audio_input.aclose()
def run_async(async_command: Coroutine) -> None:
def run_async(
async_command: Callable[..., Awaitable[Any]],
transport: str,
*args,
) -> None:
async def run_with_transport():
async with create_device(transport) as device:
await async_command(device, *args)
try:
asyncio.run(async_command)
asyncio.run(run_with_transport())
except core.ProtocolError as error:
if error.error_namespace == 'att' and error.error_code in list(
bass.ApplicationError
@@ -1004,7 +1237,7 @@ def auracast(ctx):
@click.pass_context
def scan(ctx, filter_duplicates, sync_timeout, transport):
"""Scan for public broadcasts"""
run_async(run_scan(filter_duplicates, sync_timeout, transport))
run_async(run_scan, transport, filter_duplicates, sync_timeout)
@auracast.command('assist')
@@ -1031,7 +1264,7 @@ def scan(ctx, filter_duplicates, sync_timeout, transport):
@click.pass_context
def assist(ctx, broadcast_name, source_id, command, transport, address):
"""Scan for broadcasts on behalf of an audio server"""
run_async(run_assist(broadcast_name, source_id, command, transport, address))
run_async(run_assist, transport, broadcast_name, source_id, command, address)
@auracast.command('pair')
@@ -1040,7 +1273,7 @@ def assist(ctx, broadcast_name, source_id, command, transport, address):
@click.pass_context
def pair(ctx, transport, address):
"""Pair with an audio server"""
run_async(run_pair(transport, address))
run_async(run_pair, transport, address)
@auracast.command('receive')
@@ -1095,7 +1328,7 @@ def receive(
):
"""Receive a broadcast source"""
run_async(
run_receive(
run_receive,
transport,
broadcast_id,
output,
@@ -1103,14 +1336,21 @@ def receive(
sync_timeout,
subgroup,
)
)
@auracast.command('transmit')
@click.argument('transport')
@click.option(
'--broadcast-list',
metavar='BROADCAST_LIST',
help=(
'Filename of a TOML broadcast list with specification(s) for one or more '
'broadcast sources. When used, single-source options, including --input, '
'--input-format and others, are ignored.'
),
)
@click.option(
'--input',
required=True,
help=(
"Audio input. "
"'device' -> use the host's default sound input device, "
@@ -1139,18 +1379,18 @@ def receive(
'--broadcast-id',
metavar='BROADCAST_ID',
type=int,
default=123456,
default=AURACAST_DEFAULT_BROADCAST_ID,
help='Broadcast ID',
)
@click.option(
'--broadcast-code',
metavar='BROADCAST_CODE',
help='Broadcast encryption code in hex format',
help='Broadcast encryption code in hex format or as a string',
)
@click.option(
'--broadcast-name',
metavar='BROADCAST_NAME',
default='Bumble Auracast',
default=AURACAST_DEFAULT_BROADCAST_NAME,
help='Broadcast name',
)
@click.option(
@@ -1168,15 +1408,43 @@ def receive(
def transmit(
ctx,
transport,
broadcast_id,
broadcast_code,
manufacturer_data,
broadcast_name,
bitrate,
broadcast_list,
input,
input_format,
broadcast_id,
broadcast_code,
broadcast_name,
bitrate,
manufacturer_data,
):
"""Transmit a broadcast source"""
if broadcast_list:
broadcasts = parse_broadcast_list(broadcast_list)
if not broadcasts:
print(color('!!! Broadcast list is empty or invalid', 'red'))
return
for broadcast in broadcasts:
if not broadcast.sources:
print(
color(
f'!!! Broadcast "{broadcast.broadcast_name}" has no sources',
'red',
)
)
return
else:
if input is None and broadcast_list is None:
print(
color('!!! --input is required if --broadcast-list is not used', 'red')
)
return
if (
input == 'device' or input.startswith('device:')
) and input_format == 'auto':
# Use a default format for device inputs
input_format = 'int16le,48000,1'
if manufacturer_data:
vendor_id_str, data_hex = manufacturer_data.split(':')
vendor_id = int(vendor_id_str)
@@ -1185,22 +1453,28 @@ def transmit(
else:
manufacturer_data_tuple = None
if (input == 'device' or input.startswith('device:')) and input_format == 'auto':
# Use a default format for device inputs
input_format = 'int16le,48000,1'
run_async(
run_transmit(
transport=transport,
broadcast_id=broadcast_id,
broadcast_code=broadcast_code,
broadcast_name=broadcast_name,
bitrate=bitrate,
manufacturer_data=manufacturer_data_tuple,
broadcasts = [
Broadcast(
sources=[
BroadcastSource(
input=input,
input_format=input_format,
bitrate=bitrate,
)
],
public=True,
broadcast_id=broadcast_id,
broadcast_name=broadcast_name,
broadcast_code=broadcast_code,
manufacturer_data=manufacturer_data_tuple,
language=AURACAST_DEFAULT_LANGUAGE,
program_info=AURACAST_DEFAULT_PROGRAM_INFO,
)
]
assign_broadcast_ids(broadcasts)
run_async(run_transmit, transport, broadcasts)
def main():

17
apps/controller_info.py
View File

@@ -35,8 +35,6 @@ from bumble.hci import (
HCI_READ_BUFFER_SIZE_COMMAND,
HCI_READ_LOCAL_NAME_COMMAND,
HCI_SUCCESS,
HCI_VERSION_NAMES,
LMP_VERSION_NAMES,
CodecID,
HCI_Command,
HCI_Command_Complete_Event,
@@ -54,6 +52,7 @@ from bumble.hci import (
HCI_Read_Local_Supported_Codecs_V2_Command,
HCI_Read_Local_Version_Information_Command,
LeFeature,
SpecificationVersion,
map_null_terminated_utf8_string,
)
from bumble.host import Host
@@ -289,14 +288,20 @@ async def async_main(
)
print(
color(' HCI Version: ', 'green'),
name_or_number(HCI_VERSION_NAMES, host.local_version.hci_version),
SpecificationVersion(host.local_version.hci_version).name,
)
print(
color(' HCI Subversion:', 'green'),
f'0x{host.local_version.hci_subversion:04x}',
)
print(color(' HCI Subversion:', 'green'), host.local_version.hci_subversion)
print(
color(' LMP Version: ', 'green'),
name_or_number(LMP_VERSION_NAMES, host.local_version.lmp_version),
SpecificationVersion(host.local_version.lmp_version).name,
)
print(
color(' LMP Subversion:', 'green'),
f'0x{host.local_version.lmp_subversion:04x}',
)
print(color(' LMP Subversion:', 'green'), host.local_version.lmp_subversion)
# Get the Classic info
await get_classic_info(host)

1
bumble/audio/io.py
View File

@@ -546,5 +546,6 @@ class SoundDeviceAudioInput(ThreadedAudioInput):
return bytes(pcm_buffer)
def _close(self):
if self._stream:
self._stream.stop()
self._stream = None

4
bumble/device.py
View File

@@ -864,8 +864,8 @@ class PeriodicAdvertisingSync(utils.EventEmitter):
EVENT_STATE_CHANGE = "state_change"
EVENT_ESTABLISHMENT = "establishment"
EVENT_ESTABLISHMENT_ERROR = "establishment_error"
EVENT_CANCELLATION = "cancellation"
EVENT_ERROR = "error"
EVENT_LOSS = "loss"
EVENT_PERIODIC_ADVERTISEMENT = "periodic_advertisement"
EVENT_BIGINFO_ADVERTISEMENT = "biginfo_advertisement"
@@ -998,7 +998,7 @@ class PeriodicAdvertisingSync(utils.EventEmitter):
return
self.state = self.State.ERROR
self.emit(self.EVENT_ERROR)
self.emit(self.EVENT_ESTABLISHMENT_ERROR)
def on_loss(self):
self.state = self.State.LOST

57
bumble/hci.py
View File

@@ -207,22 +207,44 @@ def metadata(
HCI_VENDOR_OGF = 0x3F
# HCI Version
HCI_VERSION_BLUETOOTH_CORE_1_0B = 0
HCI_VERSION_BLUETOOTH_CORE_1_1 = 1
HCI_VERSION_BLUETOOTH_CORE_1_2 = 2
HCI_VERSION_BLUETOOTH_CORE_2_0_EDR = 3
HCI_VERSION_BLUETOOTH_CORE_2_1_EDR = 4
HCI_VERSION_BLUETOOTH_CORE_3_0_HS = 5
HCI_VERSION_BLUETOOTH_CORE_4_0 = 6
HCI_VERSION_BLUETOOTH_CORE_4_1 = 7
HCI_VERSION_BLUETOOTH_CORE_4_2 = 8
HCI_VERSION_BLUETOOTH_CORE_5_0 = 9
HCI_VERSION_BLUETOOTH_CORE_5_1 = 10
HCI_VERSION_BLUETOOTH_CORE_5_2 = 11
HCI_VERSION_BLUETOOTH_CORE_5_3 = 12
HCI_VERSION_BLUETOOTH_CORE_5_4 = 13
HCI_VERSION_BLUETOOTH_CORE_6_0 = 14
# Specification Version
class SpecificationVersion(utils.OpenIntEnum):
BLUETOOTH_CORE_1_0B = 0
BLUETOOTH_CORE_1_1 = 1
BLUETOOTH_CORE_1_2 = 2
BLUETOOTH_CORE_2_0_EDR = 3
BLUETOOTH_CORE_2_1_EDR = 4
BLUETOOTH_CORE_3_0_HS = 5
BLUETOOTH_CORE_4_0 = 6
BLUETOOTH_CORE_4_1 = 7
BLUETOOTH_CORE_4_2 = 8
BLUETOOTH_CORE_5_0 = 9
BLUETOOTH_CORE_5_1 = 10
BLUETOOTH_CORE_5_2 = 11
BLUETOOTH_CORE_5_3 = 12
BLUETOOTH_CORE_5_4 = 13
BLUETOOTH_CORE_6_0 = 14
BLUETOOTH_CORE_6_1 = 15
BLUETOOTH_CORE_6_2 = 16
# For backwards compatibility only
HCI_VERSION_BLUETOOTH_CORE_1_0B = SpecificationVersion.BLUETOOTH_CORE_1_0B
HCI_VERSION_BLUETOOTH_CORE_1_1 = SpecificationVersion.BLUETOOTH_CORE_1_1
HCI_VERSION_BLUETOOTH_CORE_1_2 = SpecificationVersion.BLUETOOTH_CORE_1_2
HCI_VERSION_BLUETOOTH_CORE_2_0_EDR = SpecificationVersion.BLUETOOTH_CORE_2_0_EDR
HCI_VERSION_BLUETOOTH_CORE_2_1_EDR = SpecificationVersion.BLUETOOTH_CORE_2_1_EDR
HCI_VERSION_BLUETOOTH_CORE_3_0_HS = SpecificationVersion.BLUETOOTH_CORE_3_0_HS
HCI_VERSION_BLUETOOTH_CORE_4_0 = SpecificationVersion.BLUETOOTH_CORE_4_0
HCI_VERSION_BLUETOOTH_CORE_4_1 = SpecificationVersion.BLUETOOTH_CORE_4_1
HCI_VERSION_BLUETOOTH_CORE_4_2 = SpecificationVersion.BLUETOOTH_CORE_4_2
HCI_VERSION_BLUETOOTH_CORE_5_0 = SpecificationVersion.BLUETOOTH_CORE_5_0
HCI_VERSION_BLUETOOTH_CORE_5_1 = SpecificationVersion.BLUETOOTH_CORE_5_1
HCI_VERSION_BLUETOOTH_CORE_5_2 = SpecificationVersion.BLUETOOTH_CORE_5_2
HCI_VERSION_BLUETOOTH_CORE_5_3 = SpecificationVersion.BLUETOOTH_CORE_5_3
HCI_VERSION_BLUETOOTH_CORE_5_4 = SpecificationVersion.BLUETOOTH_CORE_5_4
HCI_VERSION_BLUETOOTH_CORE_6_0 = SpecificationVersion.BLUETOOTH_CORE_6_0
HCI_VERSION_BLUETOOTH_CORE_6_1 = SpecificationVersion.BLUETOOTH_CORE_6_1
HCI_VERSION_BLUETOOTH_CORE_6_2 = SpecificationVersion.BLUETOOTH_CORE_6_2
HCI_VERSION_NAMES = {
HCI_VERSION_BLUETOOTH_CORE_1_0B: 'HCI_VERSION_BLUETOOTH_CORE_1_0B',
@@ -240,9 +262,10 @@ HCI_VERSION_NAMES = {
HCI_VERSION_BLUETOOTH_CORE_5_3: 'HCI_VERSION_BLUETOOTH_CORE_5_3',
HCI_VERSION_BLUETOOTH_CORE_5_4: 'HCI_VERSION_BLUETOOTH_CORE_5_4',
HCI_VERSION_BLUETOOTH_CORE_6_0: 'HCI_VERSION_BLUETOOTH_CORE_6_0',
HCI_VERSION_BLUETOOTH_CORE_6_1: 'HCI_VERSION_BLUETOOTH_CORE_6_1',
HCI_VERSION_BLUETOOTH_CORE_6_2: 'HCI_VERSION_BLUETOOTH_CORE_6_2',
}
# LMP Version
LMP_VERSION_NAMES = HCI_VERSION_NAMES
# HCI Packet types

7
bumble/profiles/bass.py
View File

@@ -338,7 +338,12 @@ class BroadcastAudioScanService(gatt.TemplateService):
b"12", # TEST
)
super().__init__([self.battery_level_characteristic])
super().__init__(
[
self.broadcast_audio_scan_control_point_characteristic,
self.broadcast_receive_state_characteristic,
]
)
def on_broadcast_audio_scan_control_point_write(
self, connection: device.Connection, value: bytes

16
bumble/profiles/pbp.py
View File

@@ -22,6 +22,7 @@ import enum
from typing_extensions import Self
from bumble import core, data_types, gatt
from bumble.profiles import le_audio
@@ -46,3 +47,18 @@ class PublicBroadcastAnnouncement:
return cls(
features=features, metadata=le_audio.Metadata.from_bytes(metadata_ltv)
)
def get_advertising_data(self) -> bytes:
return bytes(
core.AdvertisingData(
[
data_types.ServiceData16BitUUID(
gatt.GATT_PUBLIC_BROADCAST_ANNOUNCEMENT_SERVICE, bytes(self)
)
]
)
)
def __bytes__(self) -> bytes:
metadata_bytes = bytes(self.metadata)
return bytes([self.features, len(metadata_bytes)]) + metadata_bytes

24
docs/mkdocs/src/apps_and_tools/auracast.md
View File

@@ -104,7 +104,8 @@ The `--output` option specifies where to send the decoded audio samples.
The following outputs are supported:
### Sound Device
The `--output` argument is either `device`, to send the audio to the hosts's default sound device, or `device:<DEVICE_ID>` where `<DEVICE_ID>`
The `--output` argument is either `device`, to send the audio to the hosts's
default sound device, or `device:<DEVICE_ID>` where `<DEVICE_ID>`
is the integer ID of one of the available sound devices.
When invoked with `--output "device:?"`, a list of available devices and
their IDs is printed out.
@@ -115,17 +116,24 @@ standard output (currently always as float32 PCM samples)
### FFPlay
With `--output ffplay`, the decoded audio samples are piped to `ffplay`
in a child process. This option is only available if `ffplay` is a command that is available on the host.
in a child process. This option is only available if `ffplay` is a command
that is available on the host.
### File
With `--output <filename>` or `--output file:<filename>`, the decoded audio
samples are written to a file (currently always as float32 PCM)
## `transmit`
Broadcast an audio source as a transmitter.
Broadcast one or more audio sources as a transmitter.
The `--input` and `--input-format` options specify what audio input
source to transmit.
Optionally, you can use the `--broadcast-list` option,
specifying a TOML configuration file, as a convenient way to specify
audio source configurations for one or more audio sources.
See `examples/auracast_broadcasts.toml` for an example.
The following inputs are supported:
### Sound Device
@@ -146,7 +154,8 @@ are read from a .wav or raw PCM file.
Use the `--input-format <FORMAT>` option to specify the format of the audio
samples in raw PCM files. `<FORMAT>` is expressed as:
`<sample-type>,<sample-rate>,<channels>`
(the only supported <sample-type> currently is 'int16le' for 16 bit signed integers with little-endian byte order)
(the only supported <sample-type> currently is 'int16le' for 16 bit signed
integers with little-endian byte order)
## `scan`
Scan for public broadcasts.
@@ -164,6 +173,7 @@ be shared to allow better compatibiity with certain products.
The `receive` command has been tested to successfully receive broadcasts from
the following transmitters:
* Android's "Audio Sharing"
* JBL GO 4
* Flairmesh FlooGoo FMA120
* Eppfun AK3040Pro Max
@@ -193,10 +203,12 @@ Use the `--manufacturer-data` option of the `transmit` command in order to inclu
that will let the speaker recognize the broadcast as a compatible source.
The manufacturer ID for JBL is 87.
Using an option like `--manufacturer-data 87:00000000000000000000000000000000dffd` should work (tested on the
JBL GO 4. The `dffd` value at the end of the payload may be different on other models?).
Using an option like `--manufacturer-data 87:00000000000000000000000000000000dffd` should work
(tested on the JBL GO 4.
The `dffd` value at the end of the payload may be different on other models?).
### Others
* Android
* Nexum Audio VOCE and USB dongle

19
examples/auracast_broadcasts.toml Normal file
View File

@@ -0,0 +1,19 @@
[[broadcasts]]
name = "Broadcast 1"
id = 1234
language="en"
program_info="Jazz"
[[broadcasts.sources]]
input = "file:audio_1_48k.wav"
bitrate = 80000
[[broadcasts]]
name = "Broadcast 2"
id = 5678
language="fr"
program_info="Classical"
[[broadcasts.sources]]
input = "file:audio_2.wav"
[broadcasts.sources.manufacturer_data]
company_id = 87
data = "00000000000000000000000000000000dffd"

1
pyproject.toml
View File

@@ -32,6 +32,7 @@ dependencies = [
"pyserial-asyncio >= 0.5; platform_system!='Emscripten'",
"pyserial >= 3.5; platform_system!='Emscripten'",
"pyusb >= 1.2; platform_system!='Emscripten'",
"tomli ~= 2.2.1; platform_system!='Emscripten'",
"websockets >= 15.0.1; platform_system!='Emscripten'",
]