1 /*-
2 * Copyright (c) 2015-2019 Hans Petter Selasky
3 * Copyright (c) 2015 Nathanial Sloss <nathanialsloss@yahoo.com.au>
4 * Copyright (c) 2006 Itronix Inc
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 */
27
28 #include <sys/queue.h>
29 #include <sys/filio.h>
30 #include <sys/soundcard.h>
31
32 #include <stdio.h>
33 #include <stdint.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <fcntl.h>
37 #include <unistd.h>
38 #include <err.h>
39 #define L2CAP_SOCKET_CHECKED
40 #include <bluetooth.h>
41 #include <sdp.h>
42
43 #include "backend.h"
44 #include "int.h"
45
46 #include "avdtp_signal.h"
47 #include "bt.h"
48
49 #define DPRINTF(...) printf("backend_bt: " __VA_ARGS__)
50
51 struct l2cap_info {
52 bdaddr_t laddr;
53 bdaddr_t raddr;
54 };
55
56 static struct bt_config bt_play_cfg;
57 static struct bt_config bt_rec_cfg;
58
59 int
bt_receive(struct bt_config * cfg,void * ptr,int len,int use_delay)60 bt_receive(struct bt_config *cfg, void *ptr, int len, int use_delay)
61 {
62 struct sbc_header *phdr = (struct sbc_header *)cfg->mtu_data;
63 struct sbc_encode *sbc = cfg->handle.sbc_enc;
64 uint8_t *tmp = ptr;
65 int old_len = len;
66 int delta;
67 int err;
68
69 /* wait for service interval, if any */
70 if (use_delay)
71 virtual_oss_wait();
72
73 switch (cfg->blocks) {
74 case BLOCKS_4:
75 sbc->blocks = 4;
76 break;
77 case BLOCKS_8:
78 sbc->blocks = 8;
79 break;
80 case BLOCKS_12:
81 sbc->blocks = 12;
82 break;
83 default:
84 sbc->blocks = 16;
85 break;
86 }
87
88 switch (cfg->bands) {
89 case BANDS_4:
90 sbc->bands = 4;
91 break;
92 default:
93 sbc->bands = 8;
94 break;
95 }
96
97 if (cfg->chmode != MODE_MONO) {
98 sbc->channels = 2;
99 } else {
100 sbc->channels = 1;
101 }
102
103 while (1) {
104 delta = len & ~1;
105 if (delta > (int)(2 * sbc->rem_len))
106 delta = (2 * sbc->rem_len);
107
108 /* copy out samples, if any */
109 memcpy(tmp, (char *)sbc->music_data + sbc->rem_off, delta);
110 tmp += delta;
111 len -= delta;
112 sbc->rem_off += delta / 2;
113 sbc->rem_len -= delta / 2;
114 if (len == 0)
115 break;
116
117 if (sbc->rem_len == 0 &&
118 sbc->rem_data_frames != 0) {
119 err = sbc_decode_frame(cfg, sbc->rem_data_len * 8);
120 sbc->rem_data_frames--;
121 sbc->rem_data_ptr += err;
122 sbc->rem_data_len -= err;
123 continue;
124 }
125 /* TODO: Support fragmented SBC frames */
126 err = read(cfg->fd, cfg->mtu_data, cfg->mtu);
127
128 if (err == 0) {
129 break;
130 } else if (err < 0) {
131 if (errno == EAGAIN || errno == EWOULDBLOCK)
132 break;
133 else
134 return (-1); /* disconnected */
135 }
136
137 /* verify RTP header */
138 if (err < (int)sizeof(*phdr) || phdr->id != 0x80)
139 continue;
140
141 sbc->rem_data_frames = phdr->numFrames;
142 sbc->rem_data_ptr = (uint8_t *)(phdr + 1);
143 sbc->rem_data_len = err - sizeof(*phdr);
144 }
145 return (old_len - len);
146 }
147
148 static int
bt_set_format(int * format)149 bt_set_format(int *format)
150 {
151 int value;
152
153 value = *format & AFMT_S16_NE;
154 if (value != 0) {
155 *format = value;
156 return (0);
157 }
158 return (-1);
159 }
160
161 static void
bt_close(struct voss_backend * pbe)162 bt_close(struct voss_backend *pbe)
163 {
164 struct bt_config *cfg = pbe->arg;
165
166 if (cfg->hc > 0) {
167 avdtpAbort(cfg->hc, cfg->sep);
168 avdtpClose(cfg->hc, cfg->sep);
169 close(cfg->hc);
170 cfg->hc = -1;
171 }
172 if (cfg->fd > 0) {
173 close(cfg->fd);
174 cfg->fd = -1;
175 }
176 }
177
178 static void
bt_play_close(struct voss_backend * pbe)179 bt_play_close(struct voss_backend *pbe)
180 {
181 struct bt_config *cfg = pbe->arg;
182
183 switch (cfg->codec) {
184 case CODEC_SBC:
185 if (cfg->handle.sbc_enc == NULL)
186 break;
187 free(cfg->handle.sbc_enc);
188 cfg->handle.sbc_enc = NULL;
189 break;
190 #ifdef HAVE_LIBAV
191 case CODEC_AAC:
192 if (cfg->handle.av.context == NULL)
193 break;
194 av_free(cfg->rem_in_data);
195 av_frame_free(&cfg->handle.av.frame);
196 avcodec_close(cfg->handle.av.context);
197 avformat_free_context(cfg->handle.av.format);
198 cfg->handle.av.context = NULL;
199 break;
200 #endif
201 default:
202 break;
203 }
204 return (bt_close(pbe));
205 }
206
207 static void
bt_rec_close(struct voss_backend * pbe)208 bt_rec_close(struct voss_backend *pbe)
209 {
210 struct bt_config *cfg = pbe->arg;
211
212 switch (cfg->codec) {
213 case CODEC_SBC:
214 break;
215 #ifdef HAVE_LIBAV
216 case CODEC_AAC:
217 break;
218 #endif
219
220 default:
221 break;
222 }
223 return (bt_close(pbe));
224 }
225
226 static const uint32_t bt_attrs[] = {
227 SDP_ATTR_RANGE(SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST,
228 SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST),
229 };
230
231 #define BT_NUM_VALUES 32
232 #define BT_BUF_SIZE 32
233
234 static int
bt_find_psm(const uint8_t * start,const uint8_t * end)235 bt_find_psm(const uint8_t *start, const uint8_t *end)
236 {
237 uint32_t type;
238 uint32_t len;
239 int protover = 0;
240 int psm = -1;
241
242 if ((end - start) < 2)
243 return (-1);
244
245 SDP_GET8(type, start);
246 switch (type) {
247 case SDP_DATA_SEQ8:
248 SDP_GET8(len, start);
249 break;
250
251 case SDP_DATA_SEQ16:
252 SDP_GET16(len, start);
253 break;
254
255 case SDP_DATA_SEQ32:
256 SDP_GET32(len, start);
257 break;
258
259 default:
260 return (-1);
261 }
262
263 while (start < end) {
264 SDP_GET8(type, start);
265 switch (type) {
266 case SDP_DATA_SEQ8:
267 SDP_GET8(len, start);
268 break;
269
270 case SDP_DATA_SEQ16:
271 SDP_GET16(len, start);
272 break;
273
274 case SDP_DATA_SEQ32:
275 SDP_GET32(len, start);
276 break;
277
278 default:
279 return (-1);
280 }
281 /* check range */
282 if (len > (uint32_t)(end - start))
283 break;
284
285 if (len >= 6) {
286 const uint8_t *ptr = start;
287
288 SDP_GET8(type, ptr);
289 if (type == SDP_DATA_UUID16) {
290 uint16_t temp;
291
292 SDP_GET16(temp, ptr);
293 switch (temp) {
294 case SDP_UUID_PROTOCOL_L2CAP:
295 SDP_GET8(type, ptr);
296 SDP_GET16(psm, ptr);
297 break;
298 case SDP_UUID_PROTOCOL_AVDTP:
299 SDP_GET8(type, ptr);
300 SDP_GET16(protover, ptr);
301 break;
302 default:
303 break;
304 }
305 }
306 }
307 start += len;
308
309 if (protover >= 0x0100 && psm > -1)
310 return (htole16(psm));
311 }
312 return (-1);
313 }
314
315 static int
bt_query(struct l2cap_info * info,uint16_t service_class)316 bt_query(struct l2cap_info *info, uint16_t service_class)
317 {
318 sdp_attr_t values[BT_NUM_VALUES];
319 uint8_t buffer[BT_NUM_VALUES][BT_BUF_SIZE];
320 void *ss;
321 int psm = -1;
322 int n;
323
324 memset(buffer, 0, sizeof(buffer));
325 memset(values, 0, sizeof(values));
326
327 ss = sdp_open(&info->laddr, &info->raddr);
328 if (ss == NULL || sdp_error(ss) != 0) {
329 DPRINTF("Could not open SDP\n");
330 sdp_close(ss);
331 return (psm);
332 }
333 /* Initialize attribute values array */
334 for (n = 0; n != BT_NUM_VALUES; n++) {
335 values[n].flags = SDP_ATTR_INVALID;
336 values[n].vlen = BT_BUF_SIZE;
337 values[n].value = buffer[n];
338 }
339
340 /* Do SDP Service Search Attribute Request */
341 n = sdp_search(ss, 1, &service_class, 1, bt_attrs, BT_NUM_VALUES, values);
342 if (n != 0) {
343 DPRINTF("SDP search failed\n");
344 goto done;
345 }
346 /* Print attributes values */
347 for (n = 0; n != BT_NUM_VALUES; n++) {
348 if (values[n].flags != SDP_ATTR_OK)
349 break;
350 if (values[n].attr != SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST)
351 continue;
352 psm = bt_find_psm(values[n].value, values[n].value + values[n].vlen);
353 if (psm > -1)
354 break;
355 }
356 done:
357 sdp_close(ss);
358 return (psm);
359 }
360
361 static int
bt_open(struct voss_backend * pbe __unused,const char * devname,int samplerate,int bufsize __unused,int * pchannels,int * pformat,struct bt_config * cfg,int service_class,int isSink)362 bt_open(struct voss_backend *pbe __unused, const char *devname, int samplerate,
363 int bufsize __unused, int *pchannels, int *pformat, struct bt_config *cfg,
364 int service_class, int isSink)
365 {
366 struct sockaddr_l2cap addr;
367 struct l2cap_info info;
368 socklen_t mtusize = sizeof(uint16_t);
369 int tmpbitpool;
370 int l2cap_psm;
371 int temp;
372
373 memset(&info, 0, sizeof(info));
374
375 if (strstr(devname, "/dev/bluetooth/") != devname) {
376 printf("Invalid device name '%s'", devname);
377 goto error;
378 }
379 /* skip prefix */
380 devname += sizeof("/dev/bluetooth/") - 1;
381
382 if (!bt_aton(devname, &info.raddr)) {
383 struct hostent *he = NULL;
384
385 if ((he = bt_gethostbyname(devname)) == NULL) {
386 DPRINTF("Could not get host by name\n");
387 goto error;
388 }
389 bdaddr_copy(&info.raddr, (bdaddr_t *)he->h_addr);
390 }
391 switch (samplerate) {
392 case 8000:
393 cfg->freq = FREQ_UNDEFINED;
394 cfg->aacMode1 = 0x80;
395 cfg->aacMode2 = 0x0C;
396 break;
397 case 11025:
398 cfg->freq = FREQ_UNDEFINED;
399 cfg->aacMode1 = 0x40;
400 cfg->aacMode2 = 0x0C;
401 break;
402 case 12000:
403 cfg->freq = FREQ_UNDEFINED;
404 cfg->aacMode1 = 0x20;
405 cfg->aacMode2 = 0x0C;
406 break;
407 case 16000:
408 cfg->freq = FREQ_16K;
409 cfg->aacMode1 = 0x10;
410 cfg->aacMode2 = 0x0C;
411 break;
412 case 22050:
413 cfg->freq = FREQ_UNDEFINED;
414 cfg->aacMode1 = 0x08;
415 cfg->aacMode2 = 0x0C;
416 break;
417 case 24000:
418 cfg->freq = FREQ_UNDEFINED;
419 cfg->aacMode1 = 0x04;
420 cfg->aacMode2 = 0x0C;
421 break;
422 case 32000:
423 cfg->freq = FREQ_32K;
424 cfg->aacMode1 = 0x02;
425 cfg->aacMode2 = 0x0C;
426 break;
427 case 44100:
428 cfg->freq = FREQ_44_1K;
429 cfg->aacMode1 = 0x01;
430 cfg->aacMode2 = 0x0C;
431 break;
432 case 48000:
433 cfg->freq = FREQ_48K;
434 cfg->aacMode1 = 0;
435 cfg->aacMode2 = 0x8C;
436 break;
437 case 64000:
438 cfg->freq = FREQ_UNDEFINED;
439 cfg->aacMode1 = 0;
440 cfg->aacMode2 = 0x4C;
441 break;
442 case 88200:
443 cfg->freq = FREQ_UNDEFINED;
444 cfg->aacMode1 = 0;
445 cfg->aacMode2 = 0x2C;
446 break;
447 case 96000:
448 cfg->freq = FREQ_UNDEFINED;
449 cfg->aacMode1 = 0;
450 cfg->aacMode2 = 0x1C;
451 break;
452 default:
453 DPRINTF("Invalid samplerate %d", samplerate);
454 goto error;
455 }
456 cfg->bands = BANDS_8;
457 cfg->bitpool = 0;
458
459 switch (*pchannels) {
460 case 1:
461 cfg->aacMode2 &= 0xF8;
462 cfg->chmode = MODE_MONO;
463 break;
464 default:
465 cfg->aacMode2 &= 0xF4;
466 cfg->chmode = MODE_STEREO;
467 break;
468 }
469
470 cfg->allocm = ALLOC_LOUDNESS;
471
472 if (cfg->chmode == MODE_MONO || cfg->chmode == MODE_DUAL)
473 tmpbitpool = 16;
474 else
475 tmpbitpool = 32;
476
477 if (cfg->bands == BANDS_8)
478 tmpbitpool *= 8;
479 else
480 tmpbitpool *= 4;
481
482 if (tmpbitpool > DEFAULT_MAXBPOOL)
483 tmpbitpool = DEFAULT_MAXBPOOL;
484
485 cfg->bitpool = tmpbitpool;
486
487 if (bt_set_format(pformat)) {
488 DPRINTF("Unsupported sample format\n");
489 goto error;
490 }
491 l2cap_psm = bt_query(&info, service_class);
492 DPRINTF("PSM=0x%02x\n", l2cap_psm);
493 if (l2cap_psm < 0) {
494 DPRINTF("PSM not found\n");
495 goto error;
496 }
497 cfg->hc = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BLUETOOTH_PROTO_L2CAP);
498 if (cfg->hc < 0) {
499 DPRINTF("Could not create BT socket\n");
500 goto error;
501 }
502 memset(&addr, 0, sizeof(addr));
503 addr.l2cap_len = sizeof(addr);
504 addr.l2cap_family = AF_BLUETOOTH;
505 bdaddr_copy(&addr.l2cap_bdaddr, &info.laddr);
506
507 if (bind(cfg->hc, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
508 DPRINTF("Could not bind to HC\n");
509 goto error;
510 }
511 bdaddr_copy(&addr.l2cap_bdaddr, &info.raddr);
512 addr.l2cap_psm = l2cap_psm;
513 if (connect(cfg->hc, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
514 DPRINTF("Could not connect to HC: %d\n", errno);
515 goto error;
516 }
517 if (avdtpDiscoverAndConfig(cfg, isSink)) {
518 DPRINTF("DISCOVER FAILED\n");
519 goto error;
520 }
521 if (avdtpOpen(cfg->hc, cfg->sep)) {
522 DPRINTF("OPEN FAILED\n");
523 goto error;
524 }
525 cfg->fd = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BLUETOOTH_PROTO_L2CAP);
526 if (cfg->fd < 0) {
527 DPRINTF("Could not create BT socket\n");
528 goto error;
529 }
530 memset(&addr, 0, sizeof(addr));
531
532 addr.l2cap_len = sizeof(addr);
533 addr.l2cap_family = AF_BLUETOOTH;
534 bdaddr_copy(&addr.l2cap_bdaddr, &info.laddr);
535
536 if (bind(cfg->fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
537 DPRINTF("Could not bind\n");
538 goto error;
539 }
540 bdaddr_copy(&addr.l2cap_bdaddr, &info.raddr);
541 addr.l2cap_psm = l2cap_psm;
542 if (connect(cfg->fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
543 DPRINTF("Could not connect: %d\n", errno);
544 goto error;
545 }
546 if (isSink) {
547 if (getsockopt(cfg->fd, SOL_L2CAP, SO_L2CAP_OMTU, &cfg->mtu, &mtusize) == -1) {
548 DPRINTF("Could not get MTU\n");
549 goto error;
550 }
551 temp = cfg->mtu * 16;
552 if (setsockopt(cfg->fd, SOL_SOCKET, SO_SNDBUF, &temp, sizeof(temp)) == -1) {
553 DPRINTF("Could not set send buffer size\n");
554 goto error;
555 }
556 temp = cfg->mtu;
557 if (setsockopt(cfg->fd, SOL_SOCKET, SO_SNDLOWAT, &temp, sizeof(temp)) == -1) {
558 DPRINTF("Could not set low water mark\n");
559 goto error;
560 }
561 } else {
562 if (getsockopt(cfg->fd, SOL_L2CAP, SO_L2CAP_IMTU, &cfg->mtu, &mtusize) == -1) {
563 DPRINTF("Could not get MTU\n");
564 goto error;
565 }
566 temp = cfg->mtu * 16;
567 if (setsockopt(cfg->fd, SOL_SOCKET, SO_RCVBUF, &temp, sizeof(temp)) == -1) {
568 DPRINTF("Could not set receive buffer size\n");
569 goto error;
570 }
571 temp = 1;
572 if (setsockopt(cfg->fd, SOL_SOCKET, SO_RCVLOWAT, &temp, sizeof(temp)) == -1) {
573 DPRINTF("Could not set low water mark\n");
574 goto error;
575 }
576 temp = 1;
577 if (ioctl(cfg->fd, FIONBIO, &temp) == -1) {
578 DPRINTF("Could not set non-blocking I/O for receive direction\n");
579 goto error;
580 }
581 }
582
583 if (avdtpStart(cfg->hc, cfg->sep)) {
584 DPRINTF("START FAILED\n");
585 goto error;
586 }
587 switch (cfg->chmode) {
588 case MODE_MONO:
589 *pchannels = 1;
590 break;
591 default:
592 *pchannels = 2;
593 break;
594 }
595 return (0);
596
597 error:
598 if (cfg->hc > 0) {
599 close(cfg->hc);
600 cfg->hc = -1;
601 }
602 if (cfg->fd > 0) {
603 close(cfg->fd);
604 cfg->fd = -1;
605 }
606 return (-1);
607 }
608
609 static void
bt_init_cfg(struct bt_config * cfg)610 bt_init_cfg(struct bt_config *cfg)
611 {
612 memset(cfg, 0, sizeof(*cfg));
613 }
614
615 static int
bt_rec_open(struct voss_backend * pbe,const char * devname,int samplerate,int bufsize,int * pchannels,int * pformat)616 bt_rec_open(struct voss_backend *pbe, const char *devname, int samplerate,
617 int bufsize, int *pchannels, int *pformat)
618 {
619 struct bt_config *cfg = pbe->arg;
620 int retval;
621
622 bt_init_cfg(cfg);
623
624 retval = bt_open(pbe, devname, samplerate, bufsize, pchannels, pformat,
625 cfg, SDP_SERVICE_CLASS_AUDIO_SOURCE, 0);
626 if (retval != 0)
627 return (retval);
628 return (0);
629 }
630
631 static int
bt_play_open(struct voss_backend * pbe,const char * devname,int samplerate,int bufsize,int * pchannels,int * pformat)632 bt_play_open(struct voss_backend *pbe, const char *devname, int samplerate,
633 int bufsize, int *pchannels, int *pformat)
634 {
635 struct bt_config *cfg = pbe->arg;
636 int retval;
637
638 bt_init_cfg(cfg);
639
640 retval = bt_open(pbe, devname, samplerate, bufsize, pchannels, pformat,
641 cfg, SDP_SERVICE_CLASS_AUDIO_SINK, 1);
642 if (retval != 0)
643 return (retval);
644
645 /* setup codec */
646 switch (cfg->codec) {
647 case CODEC_SBC:
648 cfg->handle.sbc_enc =
649 malloc(sizeof(*cfg->handle.sbc_enc));
650 if (cfg->handle.sbc_enc == NULL)
651 return (-1);
652 memset(cfg->handle.sbc_enc, 0, sizeof(*cfg->handle.sbc_enc));
653 break;
654 #ifdef HAVE_LIBAV
655 case CODEC_AAC:
656 cfg->handle.av.codec = __DECONST(AVCodec *,
657 avcodec_find_encoder_by_name("aac"));
658 if (cfg->handle.av.codec == NULL) {
659 DPRINTF("Codec AAC encoder not found\n");
660 goto av_error_0;
661 }
662 cfg->handle.av.format = avformat_alloc_context();
663 if (cfg->handle.av.format == NULL) {
664 DPRINTF("Could not allocate format context\n");
665 goto av_error_0;
666 }
667 cfg->handle.av.format->oformat =
668 av_guess_format("latm", NULL, NULL);
669 if (cfg->handle.av.format->oformat == NULL) {
670 DPRINTF("Could not guess output format\n");
671 goto av_error_1;
672 }
673 cfg->handle.av.stream = avformat_new_stream(
674 cfg->handle.av.format, cfg->handle.av.codec);
675
676 if (cfg->handle.av.stream == NULL) {
677 DPRINTF("Could not create new stream\n");
678 goto av_error_1;
679 }
680 cfg->handle.av.context = avcodec_alloc_context3(cfg->handle.av.codec);
681 if (cfg->handle.av.context == NULL) {
682 DPRINTF("Could not allocate audio context\n");
683 goto av_error_1;
684 }
685 /*avcodec_get_context_defaults3(cfg->handle.av.context,*/
686 /*cfg->handle.av.codec);*/
687
688 cfg->handle.av.context->bit_rate = 128000;
689 cfg->handle.av.context->sample_fmt = AV_SAMPLE_FMT_FLTP;
690 cfg->handle.av.context->sample_rate = samplerate;
691 switch (*pchannels) {
692 case 1:
693 cfg->handle.av.context->ch_layout = *(AVChannelLayout *)AV_CH_LAYOUT_MONO;
694 break;
695 default:
696 cfg->handle.av.context->ch_layout = *(AVChannelLayout *)AV_CH_LAYOUT_STEREO;
697 break;
698 }
699
700 cfg->handle.av.context->profile = FF_PROFILE_AAC_LOW;
701 if (1) {
702 AVDictionary *opts = NULL;
703
704 av_dict_set(&opts, "strict", "-2", 0);
705 av_dict_set_int(&opts, "latm", 1, 0);
706
707 if (avcodec_open2(cfg->handle.av.context,
708 cfg->handle.av.codec, &opts) < 0) {
709 av_dict_free(&opts);
710
711 DPRINTF("Could not open codec\n");
712 goto av_error_1;
713 }
714 av_dict_free(&opts);
715 }
716 cfg->handle.av.frame = av_frame_alloc();
717 if (cfg->handle.av.frame == NULL) {
718 DPRINTF("Could not allocate audio frame\n");
719 goto av_error_2;
720 }
721 cfg->handle.av.frame->nb_samples = cfg->handle.av.context->frame_size;
722 cfg->handle.av.frame->format = cfg->handle.av.context->sample_fmt;
723 cfg->handle.av.frame->ch_layout = cfg->handle.av.context->ch_layout;
724 cfg->rem_in_size = av_samples_get_buffer_size(NULL,
725 cfg->handle.av.context->ch_layout.nb_channels,
726 cfg->handle.av.context->frame_size,
727 cfg->handle.av.context->sample_fmt, 0);
728
729 cfg->rem_in_data = av_malloc(cfg->rem_in_size);
730 if (cfg->rem_in_data == NULL) {
731 DPRINTF("Could not allocate %u bytes sample buffer\n",
732 (unsigned)cfg->rem_in_size);
733 goto av_error_3;
734 }
735 retval = avcodec_fill_audio_frame(cfg->handle.av.frame,
736 cfg->handle.av.context->ch_layout.nb_channels,
737 cfg->handle.av.context->sample_fmt,
738 cfg->rem_in_data, cfg->rem_in_size, 0);
739 if (retval < 0) {
740 DPRINTF("Could not setup audio frame\n");
741 goto av_error_4;
742 }
743 break;
744 av_error_4:
745 av_free(cfg->rem_in_data);
746 av_error_3:
747 av_frame_free(&cfg->handle.av.frame);
748 av_error_2:
749 avcodec_close(cfg->handle.av.context);
750 av_error_1:
751 avformat_free_context(cfg->handle.av.format);
752 cfg->handle.av.context = NULL;
753 av_error_0:
754 bt_close(pbe);
755 return (-1);
756 #endif
757 default:
758 bt_close(pbe);
759 return (-1);
760 }
761 return (0);
762 }
763
764 static int
bt_rec_transfer(struct voss_backend * pbe,void * ptr,int len)765 bt_rec_transfer(struct voss_backend *pbe, void *ptr, int len)
766 {
767 return (bt_receive(pbe->arg, ptr, len, 1));
768 }
769
770 static int
bt_play_sbc_transfer(struct voss_backend * pbe,void * ptr,int len)771 bt_play_sbc_transfer(struct voss_backend *pbe, void *ptr, int len)
772 {
773 struct bt_config *cfg = pbe->arg;
774 struct sbc_encode *sbc = cfg->handle.sbc_enc;
775 int rem_size = 1;
776 int old_len = len;
777 int err = 0;
778
779 switch (cfg->blocks) {
780 case BLOCKS_4:
781 sbc->blocks = 4;
782 rem_size *= 4;
783 break;
784 case BLOCKS_8:
785 sbc->blocks = 8;
786 rem_size *= 8;
787 break;
788 case BLOCKS_12:
789 sbc->blocks = 12;
790 rem_size *= 12;
791 break;
792 default:
793 sbc->blocks = 16;
794 rem_size *= 16;
795 break;
796 }
797
798 switch (cfg->bands) {
799 case BANDS_4:
800 rem_size *= 4;
801 sbc->bands = 4;
802 break;
803 default:
804 rem_size *= 8;
805 sbc->bands = 8;
806 break;
807 }
808
809 /* store number of samples per frame */
810 sbc->framesamples = rem_size;
811
812 if (cfg->chmode != MODE_MONO) {
813 rem_size *= 2;
814 sbc->channels = 2;
815 } else {
816 sbc->channels = 1;
817 }
818
819 rem_size *= 2; /* 16-bit samples */
820
821 while (len > 0) {
822 int delta = len;
823
824 if (delta > (int)(rem_size - sbc->rem_len))
825 delta = (int)(rem_size - sbc->rem_len);
826
827 /* copy in samples */
828 memcpy((char *)sbc->music_data + sbc->rem_len, ptr, delta);
829
830 ptr = (char *)ptr + delta;
831 len -= delta;
832 sbc->rem_len += delta;
833
834 /* check if buffer is full */
835 if ((int)sbc->rem_len == rem_size) {
836 struct sbc_header *phdr = (struct sbc_header *)cfg->mtu_data;
837 uint32_t pkt_len;
838 uint32_t rem;
839
840 if (cfg->chmode == MODE_MONO)
841 sbc->channels = 1;
842 else
843 sbc->channels = 2;
844
845 pkt_len = sbc_encode_frame(cfg);
846
847 retry:
848 if (cfg->mtu_offset == 0) {
849 phdr->id = 0x80; /* RTP v2 */
850 phdr->id2 = 0x60; /* payload type 96. */
851 phdr->seqnumMSB = (uint8_t)(cfg->mtu_seqnumber >> 8);
852 phdr->seqnumLSB = (uint8_t)(cfg->mtu_seqnumber);
853 phdr->ts3 = (uint8_t)(cfg->mtu_timestamp >> 24);
854 phdr->ts2 = (uint8_t)(cfg->mtu_timestamp >> 16);
855 phdr->ts1 = (uint8_t)(cfg->mtu_timestamp >> 8);
856 phdr->ts0 = (uint8_t)(cfg->mtu_timestamp);
857 phdr->reserved0 = 0x01;
858 phdr->numFrames = 0;
859
860 cfg->mtu_seqnumber++;
861 cfg->mtu_offset += sizeof(*phdr);
862 }
863 /* compute bytes left */
864 rem = cfg->mtu - cfg->mtu_offset;
865
866 if (phdr->numFrames == 255 || rem < pkt_len) {
867 int xlen;
868
869 if (phdr->numFrames == 0)
870 return (-1);
871 do {
872 xlen = write(cfg->fd, cfg->mtu_data, cfg->mtu_offset);
873 } while (xlen < 0 && errno == EAGAIN);
874
875 if (xlen < 0)
876 return (-1);
877
878 cfg->mtu_offset = 0;
879 goto retry;
880 }
881 memcpy(cfg->mtu_data + cfg->mtu_offset, sbc->data, pkt_len);
882 memset(sbc->data, 0, pkt_len);
883 cfg->mtu_offset += pkt_len;
884 cfg->mtu_timestamp += sbc->framesamples;
885 phdr->numFrames++;
886
887 sbc->rem_len = 0;
888 }
889 }
890 if (err == 0)
891 return (old_len);
892 return (err);
893 }
894
895 #ifdef HAVE_LIBAV
896 static int
bt_play_aac_transfer(struct voss_backend * pbe,void * ptr,int len)897 bt_play_aac_transfer(struct voss_backend *pbe, void *ptr, int len)
898 {
899 struct bt_config *cfg = pbe->arg;
900 struct aac_header {
901 uint8_t id;
902 uint8_t id2;
903 uint8_t seqnumMSB;
904 uint8_t seqnumLSB;
905 uint8_t ts3;
906 uint8_t ts2;
907 uint8_t ts1;
908 uint8_t ts0;
909 uint8_t sync3;
910 uint8_t sync2;
911 uint8_t sync1;
912 uint8_t sync0;
913 uint8_t fixed[8];
914 };
915 int old_len = len;
916 int err = 0;
917
918 while (len > 0) {
919 int delta = len;
920 int rem;
921
922 if (delta > (int)(cfg->rem_in_size - cfg->rem_in_len))
923 delta = (int)(cfg->rem_in_size - cfg->rem_in_len);
924
925 memcpy(cfg->rem_in_data + cfg->rem_in_len, ptr, delta);
926
927 ptr = (char *)ptr + delta;
928 len -= delta;
929 cfg->rem_in_len += delta;
930
931 /* check if buffer is full */
932 if (cfg->rem_in_len == cfg->rem_in_size) {
933 struct aac_header *phdr = (struct aac_header *)cfg->mtu_data;
934 AVPacket *pkt;
935 uint8_t *pkt_buf;
936 int pkt_len;
937
938 pkt = av_packet_alloc();
939 err = avcodec_send_frame(cfg->handle.av.context,
940 cfg->handle.av.frame);
941 if (err < 0) {
942 DPRINTF("Error encoding audio frame\n");
943 return (-1);
944 }
945 phdr->id = 0x80;/* RTP v2 */
946 phdr->id2 = 0x60; /* payload type 96. */
947 phdr->seqnumMSB = (uint8_t)(cfg->mtu_seqnumber >> 8);
948 phdr->seqnumLSB = (uint8_t)(cfg->mtu_seqnumber);
949 phdr->ts3 = (uint8_t)(cfg->mtu_timestamp >> 24);
950 phdr->ts2 = (uint8_t)(cfg->mtu_timestamp >> 16);
951 phdr->ts1 = (uint8_t)(cfg->mtu_timestamp >> 8);
952 phdr->ts0 = (uint8_t)(cfg->mtu_timestamp);
953 phdr->sync3 = 0;
954 phdr->sync2 = 0;
955 phdr->sync1 = 0;
956 phdr->sync0 = 0;
957 phdr->fixed[0] = 0xfc;
958 phdr->fixed[1] = 0x00;
959 phdr->fixed[2] = 0x00;
960 phdr->fixed[3] = 0xb0;
961 phdr->fixed[4] = 0x90;
962 phdr->fixed[5] = 0x80;
963 phdr->fixed[6] = 0x03;
964 phdr->fixed[7] = 0x00;
965
966 cfg->mtu_seqnumber++;
967 cfg->mtu_offset = sizeof(*phdr);
968
969 /* compute bytes left */
970 rem = cfg->mtu - cfg->mtu_offset;
971
972 if (avio_open_dyn_buf(&cfg->handle.av.format->pb) == 0) {
973 static int once = 0;
974
975 if (!once++)
976 (void)avformat_write_header(cfg->handle.av.format, NULL);
977 av_write_frame(cfg->handle.av.format, pkt);
978 av_packet_unref(pkt);
979 pkt_len = avio_close_dyn_buf(cfg->handle.av.format->pb, &pkt_buf);
980 if (rem < pkt_len)
981 DPRINTF("Out of buffer space\n");
982 if (pkt_len >= 3 && rem >= pkt_len) {
983 int xlen;
984
985 memcpy(cfg->mtu_data + cfg->mtu_offset, pkt_buf + 3, pkt_len - 3);
986
987 av_free(pkt_buf);
988
989 cfg->mtu_offset += pkt_len - 3;
990 if (cfg->chmode != MODE_MONO)
991 cfg->mtu_timestamp += cfg->rem_in_size / 4;
992 else
993 cfg->mtu_timestamp += cfg->rem_in_size / 2;
994 do {
995 xlen = write(cfg->fd, cfg->mtu_data, cfg->mtu_offset);
996 } while (xlen < 0 && errno == EAGAIN);
997
998 if (xlen < 0)
999 return (-1);
1000 } else {
1001 av_free(pkt_buf);
1002 }
1003 } else {
1004 av_packet_unref(pkt);
1005 }
1006 /* reset remaining length */
1007 cfg->rem_in_len = 0;
1008 }
1009 }
1010 if (err == 0)
1011 return (old_len);
1012 return (err);
1013 }
1014
1015 #endif
1016
1017 static int
bt_play_transfer(struct voss_backend * pbe,void * ptr,int len)1018 bt_play_transfer(struct voss_backend *pbe, void *ptr, int len)
1019 {
1020 struct bt_config *cfg = pbe->arg;
1021
1022 switch (cfg->codec) {
1023 case CODEC_SBC:
1024 return (bt_play_sbc_transfer(pbe, ptr, len));
1025 #ifdef HAVE_LIBAV
1026 case CODEC_AAC:
1027 return (bt_play_aac_transfer(pbe, ptr, len));
1028 #endif
1029 default:
1030 return (-1);
1031 }
1032 }
1033
1034 static void
bt_rec_delay(struct voss_backend * pbe __unused,int * pdelay)1035 bt_rec_delay(struct voss_backend *pbe __unused, int *pdelay)
1036 {
1037 *pdelay = -1;
1038 }
1039
1040 static void
bt_play_delay(struct voss_backend * pbe __unused,int * pdelay)1041 bt_play_delay(struct voss_backend *pbe __unused, int *pdelay)
1042 {
1043 /* TODO */
1044 *pdelay = -1;
1045 }
1046
1047 struct voss_backend voss_backend_bt_rec = {
1048 .open = bt_rec_open,
1049 .close = bt_rec_close,
1050 .transfer = bt_rec_transfer,
1051 .delay = bt_rec_delay,
1052 .arg = &bt_rec_cfg,
1053 };
1054
1055 struct voss_backend voss_backend_bt_play = {
1056 .open = bt_play_open,
1057 .close = bt_play_close,
1058 .transfer = bt_play_transfer,
1059 .delay = bt_play_delay,
1060 .arg = &bt_play_cfg,
1061 };
1062