aec/loopback.c

   1 /*
   2 * Copyright (c) 2021 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17 #include <stdio.h>
  18 #include <string.h>
  19 #include <stdbool.h>
  20 #include <assert.h>
  21 #include <pthread.h>
  22 #include <alsa/asoundlib.h>
  23 #include <dlog.h>
  24
  25 #include "loopback.h"
  26 #include "static_queue.h"
  27
  28 #define FIXME_FORMAT_SIZE 2
  29 #define CTL_LOOPBACK_DEVICE "hw:Loopback"
  30 #define PCM_MASTER_ACTIVE "PCM Master Active"
  31 #define PCM_SLAVE_ACTIVE "PCM Slave Active"
  32
  33 enum {
  34         CAPTURE = 0,
  35         PLAYBACK,
  36         DEV_MAX
  37 };
  38
  39 enum {
  40         POLL_WAKEUP = 0,
  41         POLL_CTRL,
  42         POLL_CAPTURE,
  43         POLL_PLAYBACK,
  44         POLL_MAX
  45 };
  46
  47 enum {
  48         STATE_STOPPED,
  49         STATE_RUNNING,
  50 };
  51
  52 struct loopback_dev {
  53         snd_pcm_t *handle;
  54         char *name;
  55         int mode;
  56         int rate;
  57         int channels;
  58         int format;
  59         unsigned int buffer_size;
  60         unsigned int buffer_time;
  61         unsigned int period_size;
  62         unsigned int buffer_frame;
  63         unsigned int period_time;
  64 };
  65
  66 struct loopback {
  67         char *name;
  68         struct loopback_dev *dev[DEV_MAX];
  69         struct pollfd pfds[POLL_MAX];
  70         int poll_cnt;
  71         int wakeup[2];
  72         pthread_t t;
  73         volatile int state;
  74         volatile bool quit;
  75
  76         char *empty_buf;
  77         int ec_frame;
  78         int rate;
  79         int channels;
  80
  81         /* loopback ctl */
  82         snd_ctl_t *ctl;
  83         int ctl_id;
  84         int ctl_subid;
  85         snd_ctl_elem_value_t *elm_active;
  86
  87         /* related to reference */
  88         ec_operation_t *op;
  89
  90         sq *q;
  91
  92         /* reference queue */
  93         loopback_t *master;
  94         sq *refq; /* recording consumption */
  95         sq *master_refq; /* playback feeding */
  96
  97         int logcnt;
  98 };
  99
 100 static int __open_loopback_controls(loopback_t *loopback, const char *dev, const char *elm);
 101 static int __check_ctl_active_event(loopback_t *loopback, int *status);
 102 static int __handle_revents(loopback_t *loopback, int mode, unsigned short revents);
 103 static void *__loop_thread(void *userdata);
 104
 105 static void  __close_dev(loopback_t *loopback);
 106 static int __open_dev(loopback_t *loopback, int index, struct pollfd *pfd);
 107 static int __xrun_recovery(loopback_dev_t *dev, int err);
 108 static int __print_buffer(loopback_t *loopback);
 109
 110 loopback_dev_t *loopback_alloc_device(const char *name, int mode, int rate,
 111                                         int channels, int format, int buffer_frame)
 112 {
 113         loopback_dev_t *dev = (loopback_dev_t *)calloc(1, sizeof(struct loopback_dev));
 114         if (!dev) {
 115                 LOGE("Failed to alloc memory");
 116                 return NULL;
 117         }
 118
 119         dev->name = strdup(name);
 120         dev->mode = mode;
 121         dev->rate = rate;
 122         dev->channels = channels;
 123         dev->format = format;
 124         dev->buffer_frame = buffer_frame;
 125
 126         return dev;
 127 }
 128
 129 int loopback_free_device(loopback_dev_t *dev)
 130 {
 131         if (!dev)
 132                 return -1;
 133
 134         if (dev->name) {
 135                 free(dev->name);
 136                 dev->name = NULL;
 137         }
 138
 139         return 0;
 140 }
 141
 142 static int __open_loopback_controls(loopback_t *loopback, const char *dev, const char *elm)
 143 {
 144         int k, err;
 145         char ctl_name[64];
 146         const char *elm_name = elm;
 147
 148         loopback->ctl_id = dev[12] - '0';
 149         loopback->ctl_subid = dev[14] - '0';
 150
 151         for (k = 0; *dev != ',' && *dev != '\0'; dev++)
 152                 ctl_name[k++] = *dev;
 153         ctl_name[k] = '\0';
 154
 155         err = snd_ctl_open(&loopback->ctl, ctl_name, SND_CTL_NONBLOCK);
 156         if (err < 0) {
 157                 LOGE("Failed to open capture control. name(%s)", ctl_name);
 158                 goto fail;
 159         }
 160
 161         err = snd_ctl_subscribe_events(loopback->ctl, 1);
 162         if (err < 0) {
 163                 LOGE("Failed to subscribe ctrl event");
 164                 goto fail;
 165         }
 166
 167         if (snd_ctl_elem_value_malloc(&loopback->elm_active) < 0) {
 168                 LOGE("Failed to alloc elem");
 169                 goto fail;
 170         }
 171
 172         snd_ctl_elem_value_set_interface(loopback->elm_active, SND_CTL_ELEM_IFACE_PCM);
 173         snd_ctl_elem_value_set_device(loopback->elm_active, loopback->ctl_id);
 174         snd_ctl_elem_value_set_subdevice(loopback->elm_active, loopback->ctl_subid);
 175         snd_ctl_elem_value_set_name(loopback->elm_active, elm_name);
 176
 177         LOGD("loopback ctrl opened. name(%s) id(%d) subid(%d) elm_name(%s)",
 178                         ctl_name, loopback->ctl_id, loopback->ctl_subid, elm_name);
 179
 180         return 0;
 181
 182 fail:
 183         if (loopback->ctl)
 184                 snd_ctl_close(loopback->ctl);
 185         if (loopback->elm_active)
 186                 snd_ctl_elem_value_free(loopback->elm_active);
 187
 188         return -1;
 189 }
 190
 191 loopback_t *loopback_create(const char *name,
 192                                 loopback_dev_t *capture,
 193                                 loopback_dev_t *playback,
 194                                 int process_frame, int nbuffer)
 195 {
 196         const char *elm_name;
 197         char *dev_loopback;
 198         loopback_t *loopback;
 199         int bytes, len;
 200
 201         if (capture->rate != playback->rate ||
 202                 capture->channels != playback->channels ||
 203                 capture->format != playback->format) {
 204                 /* TODO: support resample or remap */
 205                 LOGE("capture and playback info is not matched."
 206                                 "rate(%d:%d), channels(%d:%d), format(%d:%d)",
 207                                 capture->rate, playback->rate,
 208                                 capture->channels, playback->channels,
 209                                 capture->format, playback->format);
 210                 return NULL;
 211         }
 212
 213         len = strlen(CTL_LOOPBACK_DEVICE);
 214         if (!strncmp(capture->name, CTL_LOOPBACK_DEVICE, len))
 215                 dev_loopback = capture->name;
 216         else if (!strncmp(playback->name, CTL_LOOPBACK_DEVICE, len))
 217                 dev_loopback = playback->name;
 218         else {
 219                 LOGE("not support");
 220                 return NULL;
 221         }
 222
 223         loopback = (loopback_t *)calloc(1, sizeof(struct loopback));
 224         if (!loopback) {
 225                 LOGE("Failed to alloc memory");
 226                 return NULL;
 227         }
 228         loopback->name = name ? strdup(name) : strdup("noname");
 229         loopback->dev[CAPTURE] = capture;
 230         loopback->dev[PLAYBACK] = playback;
 231         loopback->state = STATE_STOPPED;
 232
 233         /* TODO: Support resample */
 234         loopback->channels = capture->channels;
 235         loopback->rate = capture->rate;
 236
 237         elm_name = dev_loopback == capture->name ? PCM_SLAVE_ACTIVE : PCM_MASTER_ACTIVE;
 238         if (__open_loopback_controls(loopback, dev_loopback, elm_name)) {
 239                 LOGE("Failed to open loopback control. name(%s)", elm_name);
 240                 goto exit;
 241         }
 242
 243         loopback->ec_frame = process_frame;
 244         bytes = loopback->ec_frame * capture->channels * FIXME_FORMAT_SIZE;
 245
 246         // TEMP: padding for speex
 247         bytes += bytes >> 1;
 248
 249         loopback->q = create_static_queue(bytes, nbuffer);
 250         if (!loopback->q) {
 251                 LOGE("Failed to create sq");
 252                 goto exit;
 253         }
 254         LOGI("created static-queue bytes(%d), n(%d)", bytes, nbuffer);
 255
 256         loopback->empty_buf = (char *)calloc(1, bytes);
 257         if (!loopback->empty_buf) {
 258                 LOGE("Failed to alloc empty_buf\n");
 259                 goto exit;
 260         }
 261
 262         if (pipe(loopback->wakeup)) {
 263                 LOGE("Failed to create pipe");
 264                 goto exit;
 265         }
 266
 267         return loopback;
 268
 269 exit:
 270         if (loopback->ctl)
 271                 snd_ctl_close(loopback->ctl);
 272         if (loopback->elm_active)
 273                 snd_ctl_elem_value_free(loopback->elm_active);
 274         if (loopback->q)
 275                 destory_static_queue(loopback->q);
 276         if (loopback->empty_buf)
 277                 free(loopback->empty_buf);
 278         if (loopback)
 279                 free(loopback);
 280
 281         return NULL;
 282 }
 283
 284 int loopback_start(loopback_t *loopback)
 285 {
 286         if (!loopback->q) {
 287                 LOGE("loopback is not ready\n");
 288                 return -1;
 289         }
 290
 291         loopback->pfds[POLL_WAKEUP].fd = loopback->wakeup[0];
 292         loopback->pfds[POLL_WAKEUP].events = POLLIN;
 293
 294         /* poll fds */
 295         if (snd_ctl_poll_descriptors(loopback->ctl, &(loopback->pfds[POLL_CTRL]), 1) <= 0) {
 296                 LOGE("cannot get ctrl descriptor\n");
 297                 return -1;
 298         }
 299
 300         loopback->poll_cnt = POLL_CTRL + 1;
 301
 302         if (loopback->op) {
 303                 if (loopback->op->init(loopback->ec_frame, loopback->rate, loopback->channels)) {
 304                         LOGE("ec init failed\n");
 305                         return -1;
 306                 }
 307         }
 308
 309         if (pthread_create(&loopback->t, NULL, __loop_thread, (void *)loopback) < 0) {
 310                 LOGE("failed to create thread\nn");
 311                 return -1;
 312         }
 313
 314         return 0;
 315 }
 316
 317 int loopback_stop(loopback_t *loopback)
 318 {
 319         ssize_t n;
 320         int status;
 321         char dummy = 'c';
 322
 323         if (!loopback)
 324                 return -1;
 325
 326         loopback->quit = 1;
 327         n = write(loopback->wakeup[1], &dummy, 1);
 328         if (n <= 0) {
 329                 LOGE("Failed to wake up thread");
 330                 return -1;
 331         }
 332
 333         if (pthread_join(loopback->t, (void **)&status)) {
 334                 LOGE("thread join failed\nn");
 335                 return -1;
 336         }
 337
 338         loopback->quit = 0;
 339
 340         return 0;
 341 }
 342
 343 int loopback_destroy(loopback_t *loopback)
 344 {
 345         if (!loopback)
 346                 return -1;
 347
 348         if (loopback->state == STATE_RUNNING) {
 349                 LOGE("Failed to destroy loopback. state running");
 350                 return -1;
 351         }
 352
 353         if (loopback->q)
 354                 destory_static_queue(loopback->q);
 355
 356         if (loopback->refq)
 357                 destory_static_queue(loopback->refq);
 358
 359         if (loopback->name) {
 360                 free(loopback->name);
 361                 loopback->name = NULL;
 362         }
 363
 364         if (loopback->empty_buf) {
 365                 free(loopback->empty_buf);
 366                 loopback->empty_buf = NULL;
 367         }
 368
 369         if (loopback->elm_active) {
 370                 snd_ctl_elem_value_free(loopback->elm_active);
 371                 loopback->elm_active = NULL;
 372         }
 373
 374         if (loopback->ctl) {
 375                 snd_ctl_close(loopback->ctl);
 376                 loopback->ctl = NULL;
 377         }
 378
 379         __close_dev(loopback);
 380
 381         free(loopback);
 382
 383         return 0;
 384 }
 385
 386 int loopback_bind_reference(loopback_t *loopback, loopback_t *ref, ec_operation_t *op)
 387 {
 388         if (loopback->state == STATE_RUNNING) {
 389                 LOGE("Failed to bind. state(%d)", loopback->state);
 390                 return -1;
 391         }
 392
 393         if (loopback->refq) {
 394                 LOGE("Failed to bind. already bound.");
 395                 return -1;
 396         }
 397
 398         loopback->op = op;
 399         loopback->refq = create_static_queue(0, 0);
 400
 401         ref->master = loopback;
 402         ref->master_refq = loopback->refq;
 403
 404         LOGI("bind loopback master(%s), refernece(%s)", loopback->name, ref->name);
 405
 406         return 0;
 407 }
 408
 409 static int __handle_revents(struct loopback *loopback, int mode, unsigned short revents)
 410 {
 411         int err;
 412         struct loopback_dev *dev = loopback->dev[mode];
 413         snd_pcm_sframes_t frames = loopback->ec_frame;
 414         snd_pcm_sframes_t avail;
 415
 416         if (revents & POLLIN) {
 417                 unsigned char *recbuf;
 418                 sqbuffer *rec;
 419
 420                 avail = snd_pcm_avail_update(dev->handle);
 421                 if (avail < 0) {
 422                         LOGW("%s: Can't get avail: %s", dev->name, snd_strerror(avail));
 423
 424                         if (__xrun_recovery(dev, avail)) {
 425                                 LOGE("%s: AEC will be stopped.", dev->name);
 426                                 return 0;
 427                         }
 428
 429                 } else if (avail < frames) {
 430                         LOGW("%s: not enough avail(%ld) < frames(%ld)\n", dev->name, avail, frames);
 431                         return 0;
 432                 }
 433
 434                 rec = sq_get_node_lock(loopback->q);
 435                 if (!rec) {
 436                         LOGE("%s: Failed to get valid sq node. maybe overflow", dev->name);
 437                         return 0;
 438                 }
 439
 440                 recbuf = sq_get_buffer(rec);
 441                 if ((err = snd_pcm_readi(dev->handle, recbuf, frames)) < 0) {
 442                         LOGE("%s: Failed to read: %s(%d)", dev->name, snd_strerror(err), err);
 443
 444                         sq_put_node_lock(rec);
 445                         __xrun_recovery(dev, err);
 446
 447                         return 0;
 448                 }
 449
 450                 sq_enqueue_node(loopback->q, rec);
 451
 452         } else if (revents & POLLOUT) {
 453                 unsigned char *playbuf;
 454                 sqbuffer *play;
 455
 456                 avail = snd_pcm_avail_update(dev->handle);
 457                 if (avail < 0) {
 458                         LOGW("%s: Can't get avail. Try to recover: %s", dev->name, snd_strerror(avail));
 459
 460                         if (__xrun_recovery(dev, avail))
 461                                 LOGE("%s: Failed to recover. AEC will be stopped.", dev->name);
 462
 463                         return 0;
 464
 465                 } else if (avail < frames) {
 466                         LOGW("%s: not enough avail(%ld) < frames(%ld)\n", dev->name, avail, frames);
 467                         return 0;
 468                 }
 469
 470                 play = sq_dequeue_node(loopback->q);
 471                 if (!play) {
 472                         if ((err = snd_pcm_writei(dev->handle, loopback->empty_buf, frames)) < 0)
 473                                 LOGE("%s: Failed to write. frame(%ld): %s(%d)",
 474                                         dev->name, frames, snd_strerror(err), err);
 475                         return 0;
 476                 }
 477
 478                 playbuf = sq_get_buffer(play);
 479
 480                 /* only recording thread */
 481                 if (loopback->refq && !sq_is_empty_lock(loopback->refq)) {
 482                         sqbuffer *ref = sq_dequeue_node_lock(loopback->refq);
 483                         sqbuffer *out = sq_get_node_lock(loopback->q);
 484                         unsigned char *refbuf = sq_get_buffer(ref);
 485                         unsigned char *outbuf = sq_get_buffer(out);
 486
 487                         loopback->op->process(playbuf, refbuf, outbuf);
 488
 489                         sq_put_node_lock(play);
 490                         sq_put_node_lock(ref);
 491
 492                         play = out;
 493                         playbuf = outbuf;
 494                 }
 495
 496
 497                 if ((err = snd_pcm_writei(dev->handle, playbuf, frames)) < 0) {
 498                         LOGE("%s: Failed to write: %s", dev->name, snd_strerror(err));
 499                         if (__xrun_recovery(dev, err))
 500                                 sq_put_node_lock(play);
 501                         return 0;
 502                 }
 503
 504                 /* only reference thread */
 505                 if (loopback->master && loopback->master->state == STATE_RUNNING) {
 506                         sq_enqueue_node_lock(loopback->master_refq, play);
 507                         return 0;
 508                 }
 509
 510                 sq_put_node_lock(play);
 511         } else
 512                 LOGD("unknown event %x\n", revents);
 513
 514         return 0;
 515 }
 516
 517 static int __check_ctl_active_event(loopback_t *loopback, int *status)
 518 {
 519         int err;
 520         unsigned int event_mask;
 521         snd_ctl_event_t *ev;
 522         snd_ctl_elem_id_t *id1, *id2;
 523
 524         snd_ctl_event_alloca(&ev);
 525         snd_ctl_elem_id_alloca(&id1);
 526         snd_ctl_elem_id_alloca(&id2);
 527
 528         while ((err = snd_ctl_read(loopback->ctl, ev)) != 0 && err != -EAGAIN);
 529
 530         snd_ctl_elem_value_get_id(loopback->elm_active, id1);
 531         snd_ctl_event_elem_get_id(ev, id2);
 532
 533         event_mask = snd_ctl_event_elem_get_mask(ev);
 534
 535         if (event_mask == SND_CTL_EVENT_MASK_REMOVE || !(event_mask & SND_CTL_EVENT_MASK_VALUE))
 536                 return 0;
 537
 538         /*
 539         LOGD("intf(%d:%d) id(%d:%d) subid(%d:%d) elem(%s:%s) index(%d:%d)\n",
 540                         snd_ctl_elem_id_get_interface(id1), snd_ctl_elem_id_get_interface(id2),
 541                         snd_ctl_elem_id_get_device(id1), snd_ctl_elem_id_get_device(id2),
 542                         snd_ctl_elem_id_get_subdevice(id1), snd_ctl_elem_id_get_subdevice(id2),
 543                         snd_ctl_elem_id_get_name(id1), snd_ctl_elem_id_get_name(id2),
 544                         snd_ctl_elem_id_get_index(id1), snd_ctl_elem_id_get_index(id2));
 545         */
 546
 547         if (snd_ctl_elem_id_get_interface(id1) != snd_ctl_elem_id_get_interface(id2))
 548                 return 0;
 549
 550         if (snd_ctl_elem_id_get_device(id1) != snd_ctl_elem_id_get_device(id2))
 551                 return 0;
 552
 553         if (snd_ctl_elem_id_get_subdevice(id1) != snd_ctl_elem_id_get_subdevice(id2))
 554                 return 0;
 555
 556         if (strcmp(snd_ctl_elem_id_get_name(id1), snd_ctl_elem_id_get_name(id2)) != 0)
 557                 return 0;
 558
 559         if (snd_ctl_elem_id_get_index(id1) != snd_ctl_elem_id_get_index(id2))
 560                 return 0;
 561
 562         err = snd_ctl_elem_read(loopback->ctl, loopback->elm_active);
 563         if (err < 0) {
 564                 LOGE("Failed to read ctl elem\n");
 565                 return 0;
 566         }
 567
 568         err = snd_ctl_elem_value_get_boolean(loopback->elm_active, 0);
 569
 570         *status = err;
 571
 572         LOGE("dev:subid:elm(%d:%d:%s) is changed to (%d)\n",
 573                         snd_ctl_elem_id_get_device(id2), snd_ctl_elem_id_get_subdevice(id2),
 574                         snd_ctl_elem_id_get_name(id2), *status);
 575
 576         return 1;
 577 }
 578
 579 static void *__loop_thread(void *userdata)
 580 {
 581         int err;
 582         unsigned short revents;
 583         struct loopback *loopback = (struct loopback *)userdata;
 584         struct loopback_dev **dev = loopback->dev;
 585
 586         LOGI("start thread. name(%s), capture(%s) playback(%s), frame(%d), poll_cnt(%d)\n",
 587                 loopback->name, dev[CAPTURE]->name, dev[PLAYBACK]->name,
 588                 loopback->ec_frame, loopback->poll_cnt);
 589
 590         while (1) {
 591                 if (poll(loopback->pfds, loopback->poll_cnt, -1) < 0) {
 592                         LOGE("poll err %s\n", strerror(errno));
 593                         continue;
 594                 }
 595
 596                 if (loopback->quit) {
 597                         if (loopback->op)
 598                                 loopback->op->deinit();
 599
 600                         __close_dev(loopback);
 601                         loopback->state = STATE_STOPPED;
 602
 603                         LOGE("thread(%s) exit\n", loopback->name);
 604
 605                         pthread_exit(0);
 606                 }
 607
 608                 revents = 0;
 609                 if (!snd_ctl_poll_descriptors_revents(loopback->ctl, &loopback->pfds[POLL_CTRL], 1, &revents)) {
 610                         int onoff;
 611
 612                         if (__check_ctl_active_event(loopback, &onoff)) {
 613                                 if (onoff) { /* Turn on */
 614                                         if (__open_dev(loopback, PLAYBACK, loopback->pfds+POLL_PLAYBACK)) {
 615                                                 LOGE("failed to open playback dev\n");
 616                                                 pthread_exit(0);
 617                                         }
 618
 619                                         if (__open_dev(loopback, CAPTURE, loopback->pfds+POLL_CAPTURE)) {
 620                                                 LOGE("failed to open capture dev\n");
 621                                                 pthread_exit(0);
 622                                         }
 623
 624                                         if ((err = snd_pcm_start(dev[CAPTURE]->handle)) < 0)
 625                                                 LOGE("capture dev start failed. %s\n", snd_strerror(err));
 626
 627                                         loopback->state = STATE_RUNNING;
 628
 629                                 } else { /* Turn off */
 630                                         loopback->state = STATE_STOPPED;
 631
 632                                         __close_dev(loopback);
 633
 634                                         sq_flush(loopback->q);
 635                                         sq_flush_lock(loopback->refq);
 636
 637                                         LOGI("sleep...\n");
 638
 639                                         continue;
 640                                 }
 641                         }
 642                 }
 643
 644                 if (loopback->state != STATE_RUNNING)
 645                         continue;
 646
 647                 revents = 0;
 648                 if (!snd_pcm_poll_descriptors_revents(dev[CAPTURE]->handle,
 649                                                         &loopback->pfds[POLL_CAPTURE], 1, &revents)) {
 650                         if (revents != 0)
 651                                 __handle_revents(loopback, CAPTURE, revents);
 652                 }
 653                 revents = 0;
 654                 if (!snd_pcm_poll_descriptors_revents(dev[PLAYBACK]->handle,
 655                                                         &loopback->pfds[POLL_PLAYBACK], 1, &revents)) {
 656                         if (revents != 0)
 657                                 __handle_revents(loopback, PLAYBACK, revents);
 658                 }
 659
 660                 if (loopback->logcnt++ > 100) {
 661                         loopback->logcnt = 0;
 662                         __print_buffer(loopback);
 663                 }
 664         }
 665 }
 666
 667 static void  __close_dev(loopback_t *loopback)
 668 {
 669         if (loopback->dev[PLAYBACK]->handle) {
 670                 snd_pcm_close(loopback->dev[PLAYBACK]->handle);
 671                 loopback->dev[PLAYBACK]->handle = NULL;
 672         }
 673         loopback->poll_cnt--;
 674
 675         if (loopback->dev[CAPTURE]->handle) {
 676                 snd_pcm_close(loopback->dev[CAPTURE]->handle);
 677                 loopback->dev[CAPTURE]->handle = NULL;
 678         }
 679         loopback->poll_cnt--;
 680 }
 681
 682 static int __xrun_recovery(struct loopback_dev *dev, int err)
 683 {
 684         snd_pcm_state_t state;
 685
 686         state = snd_pcm_state(dev->handle);
 687
 688         if (state != SND_PCM_STATE_XRUN) {
 689                 LOGW("Invalid state(%d)", state);
 690                 return -1;
 691         }
 692
 693         LOGE("%s: Try to recover. state(%d)\n", dev->name, state);
 694
 695         if (err == -EPIPE) { /* underrun or overrun */
 696                 err = snd_pcm_prepare(dev->handle);
 697                 if (err < 0) {
 698                         LOGE("XRUN: Failed to prepare pcm\n");
 699                         return -1;
 700                 }
 701         } else if (err == -ESTRPIPE) { /* suspended */
 702                 while ((err = snd_pcm_resume(dev->handle)) == -EAGAIN)
 703                         usleep(50000);
 704
 705                 if (err) {
 706                         LOGE("XRUN: Failed to resume pcm\n");
 707                         return -1;
 708                 }
 709
 710                 err = snd_pcm_prepare(dev->handle);
 711                 if (err < 0) {
 712                         LOGE("XRUN: Failed to prepare pcm\n");
 713                         return -1;
 714                 }
 715         } else {
 716                 LOGE("XRUN: Unknown error\n");
 717                 return -1;
 718         }
 719
 720         // TODO: add device close open
 721         LOGE("XRUN: recovered");
 722
 723         return 0;
 724 }
 725
 726 static int __open_dev(loopback_t *loopback, int index, struct pollfd *pfd)
 727 {
 728         int err;
 729         int flags = SND_PCM_NONBLOCK | SND_PCM_NO_AUTO_RESAMPLE | SND_PCM_NO_AUTO_FORMAT;
 730         unsigned int buffer_time;
 731
 732         const char *name = loopback->dev[index]->name;
 733         int mode = loopback->dev[index]->mode;
 734         unsigned int rate = loopback->dev[index]->rate;
 735         unsigned int _rate = rate;
 736         int channels = loopback->dev[index]->channels;
 737         //int format = dev->format;
 738         snd_pcm_uframes_t buffer_frame = loopback->dev[index]->buffer_frame;
 739         struct loopback_dev *dev = loopback->dev[index];
 740
 741         snd_pcm_stream_t _mode = (mode == CAPTURE) ? SND_PCM_STREAM_CAPTURE : SND_PCM_STREAM_PLAYBACK;
 742         snd_pcm_sw_params_t *sw_params = NULL;
 743         snd_pcm_hw_params_t *hw_params = NULL;
 744         snd_pcm_uframes_t buffer_size, period_size;
 745
 746         if ((err = snd_pcm_open(&dev->handle, name, _mode, flags)) < 0) {
 747                 LOGE("%s: cannot open audio device (%s)\n", name, snd_strerror(err));
 748                 goto fail;
 749         }
 750
 751         if ((err = snd_pcm_hw_params_malloc(&hw_params)) < 0) {
 752                 LOGE("%s: cannot allocate hardware parameter structure(%s)\n", name, snd_strerror(err));
 753                 goto fail;
 754         }
 755
 756         if ((err = snd_pcm_hw_params_any(dev->handle, hw_params)) < 0) {
 757                 LOGE("%s: cannot initialize hardware parameter structure(%s)\n", name, snd_strerror(err));
 758                 goto fail;
 759         }
 760
 761         if ((err = snd_pcm_hw_params_set_rate_resample(dev->handle, hw_params, 0)) < 0) {
 762                 LOGE("%s: cannot set sample SAMPLE_RATE(%s)\n", name, snd_strerror(err));
 763                 goto fail;
 764         }
 765
 766         if ((err = snd_pcm_hw_params_set_access(dev->handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
 767                 LOGE("%s: cannot set access type(%s)\n", name, snd_strerror(err));
 768                 goto fail;
 769         }
 770
 771         if ((err = snd_pcm_hw_params_set_format(dev->handle, hw_params, SND_PCM_FORMAT_S16_LE)) < 0) {
 772                 LOGE("%s: cannot set sample format(%s)\n", name, snd_strerror(err));
 773                 goto fail;
 774         }
 775
 776         if ((err = snd_pcm_hw_params_set_channels(dev->handle, hw_params, channels)) < 0) {
 777                 unsigned int ch;
 778
 779                 LOGE("%s: cannot set channel. try near. channels(%d). %s\n",
 780                                 name, channels, snd_strerror(err));
 781
 782                 if ((err = snd_pcm_hw_params_set_channels_near(dev->handle, hw_params, &ch)) < 0) {
 783                         LOGE("%s: cannot set channel. %s\n", name, snd_strerror(err));
 784                         goto fail;
 785                 }
 786                 dev->channels = ch;
 787         }
 788
 789         if ((err = snd_pcm_hw_params_set_rate_near(dev->handle, hw_params, &_rate, NULL)) < 0) {
 790                 LOGE("%s: cannot set sample SAMPLE_RATE(%s)\n", name, snd_strerror(err));
 791                 goto fail;
 792         }
 793
 794         if (_rate != rate) {
 795                 LOGE("%s: rate doesn't matched rate(%d) _rate(%d)\n", name, rate, _rate);
 796                 return -1;
 797         }
 798
 799         if ((err = snd_pcm_hw_params_set_buffer_size_near(dev->handle, hw_params, &buffer_frame)) < 0) {
 800                 LOGE("%s: snd_pcm_hw_params_set_buffer_size_near(%s)\n", name, snd_strerror(err));
 801                 goto fail;
 802         }
 803
 804         snd_pcm_hw_params_get_buffer_size(hw_params, &buffer_size);
 805         snd_pcm_hw_params_get_buffer_time(hw_params, &buffer_time, NULL);
 806
 807         unsigned int period_time = buffer_time / 4;
 808         if ((err = snd_pcm_hw_params_set_period_time_near(dev->handle, hw_params, &period_time, NULL))) {
 809                 LOGE("%s: hw set period time near %d)\n", name, period_time);
 810                 goto fail;
 811         }
 812
 813         if ((err = snd_pcm_hw_params_get_period_size(hw_params, &period_size, NULL))) {
 814                 LOGE("%s: hw set period time near %d)\n", name, period_time);
 815                 goto fail;
 816         }
 817
 818         if ((err = snd_pcm_hw_params(dev->handle, hw_params)) < 0) {
 819                 LOGE("%s: cannot set parameters(%s)\n", name, snd_strerror(err));
 820                 goto fail;
 821         }
 822
 823         snd_pcm_hw_params_free(hw_params);
 824
 825         /* sw params */
 826         if ((err = snd_pcm_sw_params_malloc(&sw_params)) < 0) {
 827                 LOGE("%s: cannot allocate software parameters structure(%s)\n", name, snd_strerror(err));
 828                 goto fail;
 829         }
 830
 831         err = snd_pcm_sw_params_current(dev->handle, sw_params);
 832         if (err < 0) {
 833                 LOGE("%s: cannot initialize software parameters structure(%s)\n", name, snd_strerror(err));
 834                 goto fail;
 835         }
 836
 837         err = snd_pcm_sw_params_set_start_threshold(dev->handle, sw_params, period_size);
 838         if (err < 0) {
 839                 LOGE("Unable to set start threshold mode for %s", snd_strerror(err));
 840                 goto fail;
 841         }
 842
 843         if ((err = snd_pcm_sw_params_set_avail_min(dev->handle, sw_params, period_size)) < 0) {
 844                 LOGE("%s: cannot set minimum available count(%s)\n", name, snd_strerror(err));
 845                 goto fail;
 846         }
 847
 848         err = snd_pcm_sw_params(dev->handle, sw_params);
 849         if (err < 0) {
 850                 LOGE("Unable to set sw params for %s", snd_strerror(err));
 851                 goto fail;
 852         }
 853
 854         snd_pcm_sw_params_free(sw_params);
 855
 856         dev->period_size = period_size;
 857         dev->period_time = period_time;
 858         dev->buffer_size = buffer_size;
 859         dev->buffer_time = buffer_time;
 860
 861         if (pfd) {
 862                 if (snd_pcm_poll_descriptors(dev->handle, pfd, 1) <= 0) {
 863                         LOGE("cannot get capture descriptor\n");
 864                         goto fail;
 865                 }
 866         }
 867
 868         loopback->poll_cnt++;
 869
 870         LOGI("%s dev(%s) opened successfully. rate(%d), ch(%d), request buffer_frame(%d)\n",
 871                         mode ? "playback" : "capture", name, dev->rate, dev->channels, dev->buffer_frame);
 872         LOGI("\tbuffer size : %ld frames, %d usec\n", buffer_size, buffer_time);
 873         LOGI("\tperiod size : %ld frames, %d usec\n", period_size, period_time);
 874         LOGI("\tthread_hold : %ld, avail_min %ld\n", period_size, period_size);
 875         LOGI("\tloopback process frame %d", loopback->ec_frame);
 876
 877         return 0;
 878
 879 fail:
 880         if (dev->handle)
 881                 snd_pcm_close(dev->handle);
 882         if (hw_params)
 883                 snd_pcm_hw_params_free(hw_params);
 884         if (sw_params)
 885                 snd_pcm_sw_params_free(sw_params);
 886
 887         return -1;
 888 }
 889
 890 static int __print_buffer(loopback_t *loopback)
 891 {
 892         struct loopback_dev **dev = loopback->dev;
 893         snd_pcm_sframes_t c_avail, c_delay;
 894         snd_pcm_sframes_t p_avail, p_delay;
 895         float capture;
 896         float playback;
 897
 898         snd_pcm_avail_delay(dev[CAPTURE]->handle, &c_avail, &c_delay);
 899         snd_pcm_avail_delay(dev[PLAYBACK]->handle, &p_avail, &p_delay);
 900
 901         capture = (float)c_avail / (float)(dev[CAPTURE]->buffer_size) * 100;
 902         playback = (float)p_avail / (float)(dev[PLAYBACK]->buffer_size) * 100;
 903
 904         LOGD("name(%s) capture avail(%.2f%%), playback avail(%.2f%%) buffer delay(%d)",
 905                         loopback->name, capture, playback, sq_get_work_node_count(loopback->q));
 906
 907         if (loopback->refq)
 908                 LOGE("refq delay(%d)", sq_get_work_node_count(loopback->refq));
 909
 910         return 0;
 911 }
 912