1 /* Copyright (c) 2013 The Chromium OS Authors. All rights reserved.
2 * Use of this source code is governed by a BSD-style license that can be
3 * found in the LICENSE file.
4 */
5
6 #include <stdint.h>
7 #include <sys/ioctl.h>
8 #include <sys/param.h>
9 #include <linux/sockios.h>
10 #include <sys/socket.h>
11 #include <sys/time.h>
12 #include <syslog.h>
13 #include <time.h>
14
15 #include "audio_thread.h"
16 #include "audio_thread_log.h"
17 #include "byte_buffer.h"
18 #include "cras_iodev_list.h"
19 #include "cras_a2dp_endpoint.h"
20 #include "cras_a2dp_info.h"
21 #include "cras_a2dp_iodev.h"
22 #include "cras_audio_area.h"
23 #include "cras_bt_device.h"
24 #include "cras_iodev.h"
25 #include "cras_util.h"
26 #include "sfh.h"
27 #include "rtp.h"
28 #include "utlist.h"
29
30 #define PCM_BUF_MAX_SIZE_FRAMES (4096*4)
31 #define PCM_BUF_MAX_SIZE_BYTES (PCM_BUF_MAX_SIZE_FRAMES * 4)
32
33 /* Child of cras_iodev to handle bluetooth A2DP streaming.
34 * Members:
35 * base - The cras_iodev structure "base class"
36 * a2dp - The codec and encoded state of a2dp_io.
37 * transport - The transport object for bluez media API.
38 * sock_depth_frames - Socket depth in frames of the a2dp socket.
39 * pcm_buf - Buffer to hold pcm samples before encode.
40 * destroyed - Flag to note if this a2dp_io is about to destroy.
41 * pre_fill_complete - Flag to note if socket pre-fill is completed.
42 * bt_written_frames - Accumulated frames written to a2dp socket. Used
43 * together with the device open timestamp to estimate how many virtual
44 * buffer is queued there.
45 * dev_open_time - The last time a2dp_ios is opened.
46 */
47 struct a2dp_io {
48 struct cras_iodev base;
49 struct a2dp_info a2dp;
50 struct cras_bt_transport *transport;
51 unsigned sock_depth_frames;
52 struct byte_buffer *pcm_buf;
53 int destroyed;
54 int pre_fill_complete;
55 uint64_t bt_written_frames;
56 struct timespec dev_open_time;
57 };
58
59 static int flush_data(void *arg);
60
update_supported_formats(struct cras_iodev * iodev)61 static int update_supported_formats(struct cras_iodev *iodev)
62 {
63 struct a2dp_io *a2dpio = (struct a2dp_io *)iodev;
64 size_t rate = 0;
65 size_t channel;
66 a2dp_sbc_t a2dp;
67
68 cras_bt_transport_configuration(a2dpio->transport, &a2dp,
69 sizeof(a2dp));
70
71 iodev->format->format = SND_PCM_FORMAT_S16_LE;
72 channel = (a2dp.channel_mode == SBC_CHANNEL_MODE_MONO) ? 1 : 2;
73
74 if (a2dp.frequency & SBC_SAMPLING_FREQ_48000)
75 rate = 48000;
76 else if (a2dp.frequency & SBC_SAMPLING_FREQ_44100)
77 rate = 44100;
78 else if (a2dp.frequency & SBC_SAMPLING_FREQ_32000)
79 rate = 32000;
80 else if (a2dp.frequency & SBC_SAMPLING_FREQ_16000)
81 rate = 16000;
82
83 free(iodev->supported_rates);
84 iodev->supported_rates = (size_t *)malloc(2 * sizeof(rate));
85 iodev->supported_rates[0] = rate;
86 iodev->supported_rates[1] = 0;
87
88 free(iodev->supported_channel_counts);
89 iodev->supported_channel_counts = (size_t *)malloc(2 * sizeof(channel));
90 iodev->supported_channel_counts[0] = channel;
91 iodev->supported_channel_counts[1] = 0;
92
93 free(iodev->supported_formats);
94 iodev->supported_formats =
95 (snd_pcm_format_t *)malloc(2 * sizeof(snd_pcm_format_t));
96 iodev->supported_formats[0] = SND_PCM_FORMAT_S16_LE;
97 iodev->supported_formats[1] = 0;
98
99 return 0;
100 }
101
102 /* Calculates the number of virtual buffer in frames. Assuming all written
103 * buffer is consumed in a constant frame rate at bluetooth device side.
104 * Args:
105 * iodev: The a2dp iodev to estimate the queued frames for.
106 * fr: The amount of frames just transmitted.
107 */
bt_queued_frames(const struct cras_iodev * iodev,int fr)108 static int bt_queued_frames(const struct cras_iodev *iodev, int fr)
109 {
110 uint64_t consumed;
111 struct a2dp_io *a2dpio = (struct a2dp_io *)iodev;
112
113 /* Calculate consumed frames since device has opened */
114 a2dpio->bt_written_frames += fr;
115 consumed = cras_frames_since_time(&a2dpio->dev_open_time,
116 iodev->format->frame_rate);
117
118 if (a2dpio->bt_written_frames > consumed)
119 return a2dpio->bt_written_frames - consumed;
120 else
121 return 0;
122 }
123
124
frames_queued(const struct cras_iodev * iodev,struct timespec * tstamp)125 static int frames_queued(const struct cras_iodev *iodev,
126 struct timespec *tstamp)
127 {
128 struct a2dp_io *a2dpio = (struct a2dp_io *)iodev;
129 int estimate_queued_frames = bt_queued_frames(iodev, 0);
130 int local_queued_frames =
131 a2dp_queued_frames(&a2dpio->a2dp) +
132 buf_queued(a2dpio->pcm_buf) /
133 cras_get_format_bytes(iodev->format);
134 clock_gettime(CLOCK_MONOTONIC_RAW, tstamp);
135 return MIN(iodev->buffer_size,
136 MAX(estimate_queued_frames, local_queued_frames));
137 }
138
configure_dev(struct cras_iodev * iodev)139 static int configure_dev(struct cras_iodev *iodev)
140 {
141 struct a2dp_io *a2dpio = (struct a2dp_io *)iodev;
142 int sock_depth;
143 int err;
144
145 err = cras_bt_transport_acquire(a2dpio->transport);
146 if (err < 0) {
147 syslog(LOG_ERR, "transport_acquire failed");
148 return err;
149 }
150
151 /* Apply the node's volume after transport is acquired. Doing this
152 * is necessary because the volume can not sync to hardware until
153 * it is opened. */
154 iodev->set_volume(iodev);
155
156 /* Assert format is set before opening device. */
157 if (iodev->format == NULL)
158 return -EINVAL;
159 iodev->format->format = SND_PCM_FORMAT_S16_LE;
160 cras_iodev_init_audio_area(iodev, iodev->format->num_channels);
161
162 a2dpio->pcm_buf = byte_buffer_create(PCM_BUF_MAX_SIZE_BYTES);
163 if (!a2dpio->pcm_buf)
164 return -ENOMEM;
165
166 iodev->buffer_size = PCM_BUF_MAX_SIZE_FRAMES;
167
168 /* Set up the socket to hold two MTUs full of data before returning
169 * EAGAIN. This will allow the write to be throttled when a reasonable
170 * amount of data is queued. */
171 sock_depth = 2 * cras_bt_transport_write_mtu(a2dpio->transport);
172 setsockopt(cras_bt_transport_fd(a2dpio->transport),
173 SOL_SOCKET, SO_SNDBUF, &sock_depth, sizeof(sock_depth));
174
175 a2dpio->sock_depth_frames =
176 a2dp_block_size(&a2dpio->a2dp,
177 cras_bt_transport_write_mtu(a2dpio->transport))
178 / cras_get_format_bytes(iodev->format) * 2;
179 iodev->min_buffer_level = a2dpio->sock_depth_frames;
180
181 a2dpio->pre_fill_complete = 0;
182
183 /* Initialize variables for bt_queued_frames() */
184 a2dpio->bt_written_frames = 0;
185 clock_gettime(CLOCK_MONOTONIC_RAW, &a2dpio->dev_open_time);
186
187 audio_thread_add_write_callback(cras_bt_transport_fd(a2dpio->transport),
188 flush_data, iodev);
189 audio_thread_enable_callback(cras_bt_transport_fd(a2dpio->transport),
190 0);
191 return 0;
192 }
193
close_dev(struct cras_iodev * iodev)194 static int close_dev(struct cras_iodev *iodev)
195 {
196 int err;
197 struct a2dp_io *a2dpio = (struct a2dp_io *)iodev;
198 struct cras_bt_device *device;
199
200 if (!a2dpio->transport)
201 return 0;
202
203 /* Remove audio thread callback and sync before releasing
204 * the transport. */
205 audio_thread_rm_callback_sync(
206 cras_iodev_list_get_audio_thread(),
207 cras_bt_transport_fd(a2dpio->transport));
208
209 err = cras_bt_transport_release(a2dpio->transport,
210 !a2dpio->destroyed);
211 if (err < 0)
212 syslog(LOG_ERR, "transport_release failed");
213
214 device = cras_bt_transport_device(a2dpio->transport);
215 if (device)
216 cras_bt_device_cancel_suspend(device);
217 a2dp_drain(&a2dpio->a2dp);
218 byte_buffer_destroy(&a2dpio->pcm_buf);
219 cras_iodev_free_format(iodev);
220 cras_iodev_free_audio_area(iodev);
221 return 0;
222 }
223
pre_fill_socket(struct a2dp_io * a2dpio)224 static int pre_fill_socket(struct a2dp_io *a2dpio)
225 {
226 static const uint16_t zero_buffer[1024 * 2];
227 int processed;
228 int written = 0;
229
230 while (1) {
231 processed = a2dp_encode(
232 &a2dpio->a2dp,
233 zero_buffer,
234 sizeof(zero_buffer),
235 cras_get_format_bytes(a2dpio->base.format),
236 cras_bt_transport_write_mtu(a2dpio->transport));
237 if (processed < 0)
238 return processed;
239 if (processed == 0)
240 break;
241
242 written = a2dp_write(
243 &a2dpio->a2dp,
244 cras_bt_transport_fd(a2dpio->transport),
245 cras_bt_transport_write_mtu(a2dpio->transport));
246 /* Full when EAGAIN is returned. */
247 if (written == -EAGAIN)
248 break;
249 else if (written < 0)
250 return written;
251 else if (written == 0)
252 break;
253 };
254
255 a2dp_drain(&a2dpio->a2dp);
256 return 0;
257 }
258
259 /* Flushes queued buffer, including pcm and a2dp buffer.
260 * Returns:
261 * 0 when the flush succeeded, -1 when error occurred.
262 */
flush_data(void * arg)263 static int flush_data(void *arg)
264 {
265 struct cras_iodev *iodev = (struct cras_iodev *)arg;
266 int processed;
267 size_t format_bytes;
268 int written = 0;
269 int queued_frames;
270 struct a2dp_io *a2dpio;
271 struct cras_bt_device *device;
272
273 a2dpio = (struct a2dp_io *)iodev;
274 format_bytes = cras_get_format_bytes(iodev->format);
275 device = cras_bt_transport_device(a2dpio->transport);
276
277 /* If bt device has been destroyed, this a2dp iodev will soon be
278 * destroyed as well. */
279 if (device == NULL)
280 return -EINVAL;
281
282 encode_more:
283 while (buf_queued(a2dpio->pcm_buf)) {
284 processed = a2dp_encode(
285 &a2dpio->a2dp,
286 buf_read_pointer(a2dpio->pcm_buf),
287 buf_readable(a2dpio->pcm_buf),
288 format_bytes,
289 cras_bt_transport_write_mtu(a2dpio->transport));
290 ATLOG(atlog, AUDIO_THREAD_A2DP_ENCODE,
291 processed,
292 buf_queued(a2dpio->pcm_buf),
293 buf_readable(a2dpio->pcm_buf)
294 );
295 if (processed == -ENOSPC || processed == 0)
296 break;
297 if (processed < 0)
298 return 0;
299
300 buf_increment_read(a2dpio->pcm_buf, processed);
301 }
302
303 written = a2dp_write(&a2dpio->a2dp,
304 cras_bt_transport_fd(a2dpio->transport),
305 cras_bt_transport_write_mtu(a2dpio->transport));
306 ATLOG(atlog, AUDIO_THREAD_A2DP_WRITE,
307 written,
308 a2dp_queued_frames(&a2dpio->a2dp), 0);
309 if (written == -EAGAIN) {
310 /* If EAGAIN error lasts longer than 5 seconds, suspend the
311 * a2dp connection. */
312 cras_bt_device_schedule_suspend(device, 5000);
313 audio_thread_enable_callback(
314 cras_bt_transport_fd(a2dpio->transport), 1);
315 return 0;
316 } else if (written < 0) {
317 /* Suspend a2dp immediately when receives error other than
318 * EAGAIN. */
319 cras_bt_device_cancel_suspend(device);
320 cras_bt_device_schedule_suspend(device, 0);
321 return written;
322 }
323
324 /* Data succcessfully written to a2dp socket, cancel any scheduled
325 * suspend timer. */
326 cras_bt_device_cancel_suspend(device);
327
328 /* If it looks okay to write more and we do have queued data, try
329 * encode more. But avoid the case when PCM buffer level is too close
330 * to min_buffer_level so that another A2DP write could causes underrun.
331 */
332 queued_frames = buf_queued(a2dpio->pcm_buf) / format_bytes;
333 if (written && (iodev->min_buffer_level + written < queued_frames))
334 goto encode_more;
335
336 /* everything written. */
337 audio_thread_enable_callback(
338 cras_bt_transport_fd(a2dpio->transport), 0);
339
340 return 0;
341 }
342
delay_frames(const struct cras_iodev * iodev)343 static int delay_frames(const struct cras_iodev *iodev)
344 {
345 const struct a2dp_io *a2dpio = (struct a2dp_io *)iodev;
346 struct timespec tstamp;
347
348 /* The number of frames in the pcm buffer plus two mtu packets */
349 return frames_queued(iodev, &tstamp) + a2dpio->sock_depth_frames;
350 }
351
get_buffer(struct cras_iodev * iodev,struct cras_audio_area ** area,unsigned * frames)352 static int get_buffer(struct cras_iodev *iodev,
353 struct cras_audio_area **area,
354 unsigned *frames)
355 {
356 size_t format_bytes;
357 struct a2dp_io *a2dpio;
358
359 a2dpio = (struct a2dp_io *)iodev;
360
361 format_bytes = cras_get_format_bytes(iodev->format);
362
363 if (iodev->direction != CRAS_STREAM_OUTPUT)
364 return 0;
365
366 *frames = MIN(*frames, buf_writable(a2dpio->pcm_buf) /
367 format_bytes);
368 iodev->area->frames = *frames;
369 cras_audio_area_config_buf_pointers(
370 iodev->area, iodev->format,
371 buf_write_pointer(a2dpio->pcm_buf));
372 *area = iodev->area;
373 return 0;
374 }
375
put_buffer(struct cras_iodev * iodev,unsigned nwritten)376 static int put_buffer(struct cras_iodev *iodev, unsigned nwritten)
377 {
378 size_t written_bytes;
379 size_t format_bytes;
380 struct a2dp_io *a2dpio = (struct a2dp_io *)iodev;
381
382 format_bytes = cras_get_format_bytes(iodev->format);
383 written_bytes = nwritten * format_bytes;
384
385 if (written_bytes > buf_writable(a2dpio->pcm_buf))
386 return -EINVAL;
387
388 buf_increment_write(a2dpio->pcm_buf, written_bytes);
389
390 bt_queued_frames(iodev, nwritten);
391
392 /* Until the minimum number of frames have been queued, don't send
393 * anything. */
394 if (!a2dpio->pre_fill_complete) {
395 pre_fill_socket(a2dpio);
396 a2dpio->pre_fill_complete = 1;
397 /* Start measuring frames_consumed from now. */
398 clock_gettime(CLOCK_MONOTONIC_RAW, &a2dpio->dev_open_time);
399 }
400
401 return flush_data(iodev);
402 }
403
flush_buffer(struct cras_iodev * iodev)404 static int flush_buffer(struct cras_iodev *iodev)
405 {
406 return 0;
407 }
408
set_volume(struct cras_iodev * iodev)409 static void set_volume(struct cras_iodev *iodev)
410 {
411 size_t volume;
412 struct a2dp_io *a2dpio = (struct a2dp_io *)iodev;
413 struct cras_bt_device *device =
414 cras_bt_transport_device(a2dpio->transport);
415
416 if (!cras_bt_device_get_use_hardware_volume(device))
417 return;
418
419 volume = iodev->active_node->volume * 127 / 100;
420
421 if (a2dpio->transport)
422 cras_bt_transport_set_volume(a2dpio->transport, volume);
423 }
424
update_active_node(struct cras_iodev * iodev,unsigned node_idx,unsigned dev_enabled)425 static void update_active_node(struct cras_iodev *iodev, unsigned node_idx,
426 unsigned dev_enabled)
427 {
428 }
429
free_resources(struct a2dp_io * a2dpio)430 void free_resources(struct a2dp_io *a2dpio)
431 {
432 struct cras_ionode *node;
433
434 node = a2dpio->base.active_node;
435 if (node) {
436 cras_iodev_rm_node(&a2dpio->base, node);
437 free(node);
438 }
439 free(a2dpio->base.supported_channel_counts);
440 free(a2dpio->base.supported_rates);
441 free(a2dpio->base.supported_formats);
442 destroy_a2dp(&a2dpio->a2dp);
443 }
444
a2dp_iodev_create(struct cras_bt_transport * transport)445 struct cras_iodev *a2dp_iodev_create(struct cras_bt_transport *transport)
446 {
447 int err;
448 struct a2dp_io *a2dpio;
449 struct cras_iodev *iodev;
450 struct cras_ionode *node;
451 a2dp_sbc_t a2dp;
452 struct cras_bt_device *device;
453 const char *name;
454
455 a2dpio = (struct a2dp_io *)calloc(1, sizeof(*a2dpio));
456 if (!a2dpio)
457 goto error;
458
459 a2dpio->transport = transport;
460 cras_bt_transport_configuration(a2dpio->transport, &a2dp,
461 sizeof(a2dp));
462 err = init_a2dp(&a2dpio->a2dp, &a2dp);
463 if (err) {
464 syslog(LOG_ERR, "Fail to init a2dp");
465 goto error;
466 }
467
468 iodev = &a2dpio->base;
469
470 /* A2DP only does output now */
471 iodev->direction = CRAS_STREAM_OUTPUT;
472
473 /* Set iodev's name by bluetooth device's readable name, if
474 * the readable name is not available, use address instead.
475 */
476 device = cras_bt_transport_device(transport);
477 name = cras_bt_device_name(device);
478 if (!name)
479 name = cras_bt_transport_object_path(a2dpio->transport);
480
481 snprintf(iodev->info.name, sizeof(iodev->info.name), "%s", name);
482 iodev->info.name[ARRAY_SIZE(iodev->info.name) - 1] = '\0';
483 iodev->info.stable_id = SuperFastHash(
484 cras_bt_device_object_path(device),
485 strlen(cras_bt_device_object_path(device)),
486 strlen(cras_bt_device_object_path(device)));
487 iodev->info.stable_id_new = iodev->info.stable_id;
488
489 iodev->configure_dev = configure_dev;
490 iodev->frames_queued = frames_queued;
491 iodev->delay_frames = delay_frames;
492 iodev->get_buffer = get_buffer;
493 iodev->put_buffer = put_buffer;
494 iodev->flush_buffer = flush_buffer;
495 iodev->close_dev = close_dev;
496 iodev->update_supported_formats = update_supported_formats;
497 iodev->update_active_node = update_active_node;
498 iodev->set_volume = set_volume;
499
500 /* Create a dummy ionode */
501 node = (struct cras_ionode *)calloc(1, sizeof(*node));
502 node->dev = iodev;
503 strcpy(node->name, iodev->info.name);
504 node->plugged = 1;
505 node->type = CRAS_NODE_TYPE_BLUETOOTH;
506 node->volume = 100;
507 gettimeofday(&node->plugged_time, NULL);
508
509 /* A2DP does output only */
510 cras_bt_device_append_iodev(device, iodev,
511 cras_bt_transport_profile(a2dpio->transport));
512 cras_iodev_add_node(iodev, node);
513 cras_iodev_set_active_node(iodev, node);
514
515 return iodev;
516 error:
517 if (a2dpio) {
518 free_resources(a2dpio);
519 free(a2dpio);
520 }
521 return NULL;
522 }
523
a2dp_iodev_destroy(struct cras_iodev * iodev)524 void a2dp_iodev_destroy(struct cras_iodev *iodev)
525 {
526 struct a2dp_io *a2dpio = (struct a2dp_io *)iodev;
527 struct cras_bt_device *device;
528
529 a2dpio->destroyed = 1;
530 device = cras_bt_transport_device(a2dpio->transport);
531
532 /* A2DP does output only */
533 cras_bt_device_rm_iodev(device, iodev);
534
535 /* Free resources when device successfully removed. */
536 free_resources(a2dpio);
537 cras_iodev_free_resources(iodev);
538 free(a2dpio);
539 }
540