usbaudio.c

   1 /*
   2 Calf Box, an open source musical instrument.
   3 Copyright (C) 2010-2013 Krzysztof Foltman
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation, either version 3 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19 #include <pthread.h>
  20 #include <time.h>
  21 #include "usbio_impl.h"
  22
  23 #include <assert.h>
  24 #include <errno.h>
  25 #include <stdio.h>
  26
  27 #define NUM_SYNC_PACKETS 10
  28
  29 #define MULTIMIX_EP_PLAYBACK 0x02
  30 //#define MULTIMIX_EP_CAPTURE 0x86
  31 #define MULTIMIX_EP_SYNC 0x81
  32
  33 #define NUM_CPUTIME_ENTRIES 100
  34
  35 static int register_cpu_time = 1;
  36 static float real_time_registry[NUM_CPUTIME_ENTRIES];
  37 static float cpu_time_registry[NUM_CPUTIME_ENTRIES];
  38 static int cpu_time_write_ptr = 0;
  39 static void usbio_play_buffer_adaptive(struct cbox_usb_io_impl *uii);
  40
  41 ///////////////////////////////////////////////////////////////////////////////
  42
  43 static gboolean set_endpoint_sample_rate(struct libusb_device_handle *h, int sample_rate, int ep)
  44 {
  45     uint8_t freq_data[3];
  46     freq_data[0] = sample_rate & 0xFF;
  47     freq_data[1] = (sample_rate & 0xFF00) >> 8;
  48     freq_data[2] = (sample_rate & 0xFF0000) >> 16;
  49     if (libusb_control_transfer(h, 0x22, 0x01, 256, ep, freq_data, 3, USB_DEVICE_SETUP_TIMEOUT) != 3)
  50         return FALSE;
  51     return TRUE;
  52 }
  53
  54 ///////////////////////////////////////////////////////////////////////////////
  55
  56 gboolean usbio_open_audio_interface(struct cbox_usb_io_impl *uii, struct cbox_usb_audio_info *uainf, struct libusb_device_handle *handle, GError **error)
  57 {
  58     if (uii->output_resolution != 2 && uii->output_resolution != 3)
  59     {
  60         g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Only 16-bit or 24-bit output resolution is supported.");
  61         return FALSE;
  62     }
  63     if (!configure_usb_interface(handle, uainf->udi->bus, uainf->udi->devadr, uainf->intf, uainf->alt_setting, "audio (class driver)", error))
  64         return FALSE;
  65     if (!set_endpoint_sample_rate(handle, uii->sample_rate, uainf->epdesc.bEndpointAddress))
  66     {
  67         g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Cannot set sample rate on class-compliant USB audio device.");
  68         return FALSE;
  69     }
  70     uii->play_function = usbio_play_buffer_adaptive;
  71     uii->handle_audiodev = handle;
  72     uii->audio_output_endpoint = uainf->epdesc.bEndpointAddress;
  73     uii->audio_output_pktsize = uainf->epdesc.wMaxPacketSize; // 48 * 2 * uii->output_resolution;
  74     uii->audio_sync_endpoint = 0;
  75     return TRUE;
  76 }
  77
  78 ///////////////////////////////////////////////////////////////////////////////
  79
  80 static gboolean claim_multimix_interfaces(struct cbox_usb_io_impl *uii, struct libusb_device_handle *handle, int bus, int devadr, GError **error)
  81 {
  82     for (int ifno = 0; ifno < 2; ifno++)
  83     {
  84         if (!configure_usb_interface(handle, bus, devadr, ifno, 1, "audio (MultiMix driver)", error))
  85             return FALSE;
  86     }
  87     return TRUE;
  88 }
  89
  90 gboolean usbio_open_audio_interface_multimix(struct cbox_usb_io_impl *uii, int bus, int devadr, struct libusb_device_handle *handle, GError **error)
  91 {
  92     if (uii->output_resolution != 3)
  93     {
  94         g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Only 24-bit output resolution is supported.");
  95         return FALSE;
  96     }
  97     if (!claim_multimix_interfaces(uii, handle, bus, devadr, error))
  98         return FALSE;
  99     if (!set_endpoint_sample_rate(handle, uii->sample_rate, MULTIMIX_EP_PLAYBACK))
 100     {
 101         g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Cannot set sample rate on Alesis Multimix.");
 102         return FALSE;
 103     }
 104
 105     uii->play_function = usbio_play_buffer_asynchronous;
 106     uii->handle_audiodev = handle;
 107     uii->audio_output_endpoint = MULTIMIX_EP_PLAYBACK;
 108     uii->audio_output_pktsize = 156;
 109     uii->audio_sync_endpoint = MULTIMIX_EP_SYNC;
 110     return TRUE;
 111 }
 112
 113 ///////////////////////////////////////////////////////////////////////////////
 114
 115 static void calc_output_buffer(struct cbox_usb_io_impl *uii)
 116 {
 117     struct timespec tvs1, tve1, tvs2, tve2;
 118     if (register_cpu_time)
 119     {
 120         clock_gettime(CLOCK_MONOTONIC_RAW, &tvs1);
 121         clock_gettime(CLOCK_THREAD_CPUTIME_ID, &tvs2);
 122     }
 123     struct cbox_io *io = uii->ioi.pio;
 124     uint32_t buffer_size = io->io_env.buffer_size;
 125     for (int b = 0; b < uii->output_channels; b++)
 126         memset(io->output_buffers[b], 0, buffer_size * sizeof(float));
 127     for (GList *p = uii->rt_midi_ports; p; p = p->next)
 128     {
 129         struct cbox_usb_midi_interface *umi = p->data;
 130         if (umi->input_port->hdr.enable_appsink && umi->input_port && umi->input_port->hdr.buffer.count)
 131             cbox_midi_appsink_supply(&umi->input_port->hdr.appsink, &umi->input_port->hdr.buffer);
 132     }
 133     io->cb->process(io->cb->user_data, io, buffer_size);
 134     for (GList *p = uii->rt_midi_ports; p; p = p->next)
 135     {
 136         struct cbox_usb_midi_interface *umi = p->data;
 137         if (umi->input_port)
 138             cbox_midi_buffer_clear(&umi->input_port->hdr.buffer);
 139     }
 140     for (GSList *p = io->midi_outputs; p; p = p->next)
 141     {
 142         struct cbox_usb_midi_output *umo = p->data;
 143         usbio_fill_midi_output_buffer(umo);
 144     }
 145     if (register_cpu_time)
 146     {
 147         clock_gettime(CLOCK_MONOTONIC_RAW, &tve1);
 148         clock_gettime(CLOCK_THREAD_CPUTIME_ID, &tve2);
 149         float time1 = tve1.tv_sec - tvs1.tv_sec + (tve1.tv_nsec - tvs1.tv_nsec) / 1000000000.0;
 150         float time2 = tve2.tv_sec - tvs2.tv_sec + (tve2.tv_nsec - tvs2.tv_nsec) / 1000000000.0;
 151         real_time_registry[cpu_time_write_ptr] = time1;
 152         cpu_time_registry[cpu_time_write_ptr] = time2;
 153         cpu_time_write_ptr = (cpu_time_write_ptr + 1) % NUM_CPUTIME_ENTRIES;
 154         if (time1 > 0.0008 || time2 > 0.0008)
 155             g_warning("CPU time = %f ms, real time = %f ms", time2 * 1000, time1 * 1000);
 156     }
 157 }
 158
 159 static void fill_playback_buffer(struct cbox_usb_io_impl *uii, struct libusb_transfer *transfer)
 160 {
 161     struct cbox_io *io = uii->ioi.pio;
 162     uint32_t buffer_size = io->io_env.buffer_size;
 163     uint8_t *data8 = (uint8_t*)transfer->buffer;
 164     int16_t *data = (int16_t*)transfer->buffer;
 165     int resolution = uii->output_resolution;
 166     int oc = uii->output_channels;
 167     int rptr = uii->read_ptr;
 168     int nframes = transfer->length / (resolution * oc);
 169     int i, j, b;
 170
 171     for (i = 0; i < nframes; )
 172     {
 173         if (rptr == buffer_size)
 174         {
 175             calc_output_buffer(uii);
 176             rptr = 0;
 177         }
 178         int left1 = nframes - i;
 179         int left2 = buffer_size - rptr;
 180         if (left1 > left2)
 181             left1 = left2;
 182
 183         for (b = 0; b < oc; b++)
 184         {
 185             float *obuf = io->output_buffers[b] + rptr;
 186             if (resolution == 2)
 187             {
 188                 int16_t *tbuf = data + oc * i + b;
 189                 for (j = 0; j < left1; j++)
 190                 {
 191                     float v = 32767 * obuf[j];
 192                     if (v < -32768)
 193                         v = -32768;
 194                     if (v > +32767)
 195                         v = +32767;
 196                     *tbuf = (int16_t)v;
 197                     tbuf += oc;
 198                 }
 199             }
 200             if (resolution == 3)
 201             {
 202                 uint8_t *tbuf = data8 + (oc * i + b) * 3;
 203                 for (j = 0; j < left1; j++)
 204                 {
 205                     float v = 0x7FFFFF * obuf[j];
 206                     if (v < -0x800000)
 207                         v = -0x800000;
 208                     if (v > +0x7FFFFF)
 209                         v = +0x7FFFFF;
 210                     int vi = (int)v;
 211                     tbuf[0] = vi & 255;
 212                     tbuf[1] = (vi >> 8) & 255;
 213                     tbuf[2] = (vi >> 16) & 255;
 214                     tbuf += oc * 3;
 215                 }
 216             }
 217         }
 218         i += left1;
 219         rptr += left1;
 220     }
 221     uii->read_ptr = rptr;
 222 }
 223
 224 static void play_callback_adaptive(struct libusb_transfer *transfer)
 225 {
 226     struct usbio_transfer *xf = transfer->user_data;
 227     struct cbox_usb_io_impl *uii = xf->user_data;
 228     xf->pending = FALSE;
 229     if (transfer->status == LIBUSB_TRANSFER_CANCELLED)
 230     {
 231         xf->cancel_confirm = 1;
 232         return;
 233     }
 234     if (transfer->status == LIBUSB_TRANSFER_NO_DEVICE)
 235     {
 236         uii->device_removed++;
 237         return;
 238     }
 239
 240     int resolution = uii->output_resolution;
 241     int oc = uii->output_channels;
 242     gboolean init_finished = uii->playback_counter == uii->playback_buffers;
 243     if (uii->playback_counter < uii->playback_buffers)
 244     {
 245         // send another URB for the next transfer before re-submitting
 246         // this one
 247         usbio_play_buffer_adaptive(uii);
 248     }
 249     // printf("Play Callback! %d %p status %d\n", (int)transfer->length, transfer->buffer, (int)transfer->status);
 250
 251     int tlen = 0, olen = 0;
 252     for (int i = 0; i < transfer->num_iso_packets; i++)
 253     {
 254         tlen += transfer->iso_packet_desc[i].actual_length;
 255         olen += transfer->iso_packet_desc[i].length;
 256         if (transfer->iso_packet_desc[i].status)
 257             printf("ISO error: index = %d i = %d status = %d\n", (int)xf->index, i, transfer->iso_packet_desc[i].status);
 258     }
 259     uii->samples_played += olen / (oc * resolution);
 260     int nsamps = uii->sample_rate / 1000;
 261     // If time elapsed is greater than
 262     int lag = uii->desync / (1000 * transfer->num_iso_packets);
 263     if (lag > 0 && nsamps < uii->audio_output_pktsize)
 264     {
 265         nsamps++;
 266         lag--;
 267     }
 268
 269     transfer->length = nsamps * transfer->num_iso_packets * oc * resolution;
 270     libusb_set_iso_packet_lengths(transfer, nsamps * oc * resolution);
 271
 272     if (init_finished)
 273     {
 274         fill_playback_buffer(uii, transfer);
 275     }
 276     // desync value is expressed in milli-frames, i.e. desync of 1000 means 1 frame of lag
 277     // It takes 1ms for each iso packet to be transmitted. Each transfer consists of
 278     // num_iso_packets packets. So, this transfer took uii->sample_rate milli-frames.
 279     uii->desync += transfer->num_iso_packets * uii->sample_rate;
 280     // ... but during that time, tlen/4 samples == tlen/4*1000 millisamples have been
 281     // transmitted.
 282     uii->desync -= transfer->num_iso_packets * nsamps * 1000;
 283
 284     if (uii->no_resubmit)
 285         return;
 286     int err = usbio_transfer_submit(xf);
 287     if (err)
 288     {
 289         if (err == LIBUSB_ERROR_NO_DEVICE)
 290         {
 291             uii->device_removed++;
 292             transfer->status = LIBUSB_TRANSFER_NO_DEVICE;
 293         }
 294         g_warning("Cannot resubmit isochronous transfer, error = %s", libusb_error_name(err));
 295     }
 296 }
 297
 298 void usbio_play_buffer_adaptive(struct cbox_usb_io_impl *uii)
 299 {
 300     struct usbio_transfer *t;
 301     int err;
 302     int packets = uii->iso_packets;
 303     t = usbio_transfer_new(uii->usbctx, "play", uii->playback_counter, packets, uii);
 304     int tsize = uii->sample_rate * 2 * uii->output_resolution / 1000;
 305     uint8_t *buf = (uint8_t *)calloc(packets, uii->audio_output_pktsize);
 306
 307     libusb_fill_iso_transfer(t->transfer, uii->handle_audiodev, uii->audio_output_endpoint, buf, tsize * packets, packets, play_callback_adaptive, t, 20000);
 308     libusb_set_iso_packet_lengths(t->transfer, tsize);
 309     uii->playback_transfers[uii->playback_counter++] = t;
 310
 311     err = usbio_transfer_submit(t);
 312     if (!err)
 313         return;
 314     g_warning("Cannot resubmit isochronous transfer, error = %s", libusb_error_name(err));
 315     uii->playback_counter--;
 316     free(buf);
 317     usbio_transfer_destroy(t);
 318     uii->playback_transfers[uii->playback_counter] = NULL;
 319 }
 320
 321 //////////////////////////////////////////////////////////////////////////////////////////
 322
 323 static int calc_packet_lengths(struct cbox_usb_io_impl *uii, struct libusb_transfer *t, int packets)
 324 {
 325     int tsize = 0;
 326     int i;
 327     // printf("sync_freq = %d\n", sync_freq);
 328     for (i = 0; i < packets; i++)
 329     {
 330         int nsamps = (uii->sync_freq - uii->desync) / 80;
 331         // assert(nsamps > 0);
 332         if ((uii->sync_freq - uii->desync) % 80)
 333             nsamps++;
 334         //printf("%d sfreq=%d desync=%d nsamps=%d\n", i, uii->sync_freq, uii->desync, nsamps);
 335
 336         uii->desync = (uii->desync + nsamps * 80) % uii->sync_freq;
 337         int v = (nsamps) * 2 * uii->output_resolution;
 338         t->iso_packet_desc[i].length = v;
 339         tsize += v;
 340     }
 341     return tsize;
 342 }
 343
 344 void play_callback_asynchronous(struct libusb_transfer *transfer)
 345 {
 346     struct usbio_transfer *xf = transfer->user_data;
 347     struct cbox_usb_io_impl *uii = xf->user_data;
 348     xf->pending = FALSE;
 349
 350     if (transfer->status == LIBUSB_TRANSFER_CANCELLED)
 351     {
 352         xf->cancel_confirm = TRUE;
 353         return;
 354     }
 355     if (transfer->status == LIBUSB_TRANSFER_NO_DEVICE)
 356     {
 357         xf->cancel_confirm = TRUE;
 358         uii->device_removed++;
 359         return;
 360     }
 361
 362     gboolean init_finished = uii->playback_counter == uii->playback_buffers;
 363     if (uii->playback_counter < uii->playback_buffers)
 364     {
 365         // send another URB for the next transfer before re-submitting
 366         // this one
 367         usbio_play_buffer_asynchronous(uii);
 368     }
 369
 370     /*
 371     printf("Play Callback! %d status %d\n", (int)transfer->length, (int)transfer->status);
 372     for (i = 0; i < transfer->num_iso_packets; i++) {
 373         if (transfer->iso_packet_desc[i].actual_length)
 374         {
 375             printf("%d: %d %d\n", i, transfer->iso_packet_desc[i].actual_length, transfer->iso_packet_desc[i].status);
 376         }
 377     }
 378     */
 379     transfer->length = calc_packet_lengths(uii, transfer, transfer->num_iso_packets);
 380     if (init_finished)
 381     {
 382         fill_playback_buffer(uii, transfer);
 383     }
 384     if (uii->no_resubmit)
 385         return;
 386     int err = usbio_transfer_submit(xf);
 387     if (err)
 388     {
 389         if (err == LIBUSB_ERROR_NO_DEVICE)
 390         {
 391             transfer->status = LIBUSB_TRANSFER_NO_DEVICE;
 392             uii->device_removed++;
 393         }
 394         g_warning("Cannot submit isochronous transfer, error = %s", libusb_error_name(err));
 395     }
 396 }
 397
 398 static struct usbio_transfer *sync_stuff_asynchronous(struct cbox_usb_io_impl *uii, int index);
 399
 400 void usbio_play_buffer_asynchronous(struct cbox_usb_io_impl *uii)
 401 {
 402     struct usbio_transfer *t;
 403     int err;
 404     int packets = uii->iso_packets_multimix;
 405     t = usbio_transfer_new(uii->usbctx, "play", uii->playback_counter, packets, uii);
 406     int tsize = calc_packet_lengths(uii, t->transfer, packets);
 407     int bufsize = uii->audio_output_pktsize * packets;
 408     uint8_t *buf = (uint8_t *)calloc(1, bufsize);
 409
 410     if (!uii->playback_counter)
 411     {
 412         for(uii->sync_counter = 0; uii->sync_counter < uii->sync_buffers; uii->sync_counter++)
 413             uii->sync_transfers[uii->sync_counter] = sync_stuff_asynchronous(uii, uii->sync_counter);
 414     }
 415
 416     libusb_fill_iso_transfer(t->transfer, uii->handle_audiodev, uii->audio_output_endpoint, buf, tsize, packets, play_callback_asynchronous, t, 20000);
 417     uii->playback_transfers[uii->playback_counter++] = t;
 418     err = usbio_transfer_submit(t);
 419     if (err)
 420     {
 421         g_warning("Cannot submit playback urb: %s, error = %s (index = %d, tsize = %d)", libusb_error_name(err), strerror(errno), uii->playback_counter, tsize);
 422         free(buf);
 423         usbio_transfer_destroy(t);
 424         uii->playback_transfers[--uii->playback_counter] = NULL;
 425     }
 426 }
 427
 428 //////////////////////////////////////////////////////////////////////////////////////////
 429
 430 /*
 431  * The Multimix device controls the data rate of the playback stream using a
 432  * device-to-host isochronous endpoint. The incoming packets consist of 3 bytes:
 433  * a current value of sample rate (kHz) + 2 historical values. I'm only using
 434  * the first byte, I haven't yet encountered a situation where using the
 435  * second and third byte would be necessary. This seems to work for all
 436  * sample rates supported by the Windows driver - 44100, 48000, 88200 and
 437  * 96000. It is possible to set sample rate to 64000, but it doesn't work
 438  * correctly, and isn't supported by the Windows driver either - it may
 439  * require special handling or may be a half-implemented feature in hardware.
 440  * The isochronous transfer using 10 packets seems to give acceptable resolution
 441  * and latency to avoid over/underruns with supported sample rates.
 442  *
 443  * The non-integer multiples of 1 kHz (like 44.1) are passed as a sequence of
 444  * values that average to a desired value (9 values of 44 and one value of 45).
 445  *
 446  * In order to compensate for clock rate difference
 447  * between host clock and DAC clock, the sample rate values sent by the device
 448  * are either larger (to increase data rate from the host) or smaller than
 449  * the nominal frequency value - the driver uses that to adjust the sample frame
 450  * counts of individual packets in an isochronous transfer.
 451  */
 452
 453 static void sync_callback(struct libusb_transfer *transfer)
 454 {
 455     struct usbio_transfer *xf = transfer->user_data;
 456     struct cbox_usb_io_impl *uii = xf->user_data;
 457     uint8_t *data = transfer->buffer;
 458     int i, ofs, size, pkts;
 459     xf->pending = FALSE;
 460
 461     if (transfer->status == LIBUSB_TRANSFER_CANCELLED)
 462     {
 463         xf->cancel_confirm = 1;
 464         return;
 465     }
 466     if (transfer->status == LIBUSB_TRANSFER_NO_DEVICE)
 467     {
 468         xf->cancel_confirm = 1;
 469         return;
 470     }
 471     // XXXKF handle device disconnected error
 472
 473     if (uii->debug_sync)
 474         printf("Sync callback! %p %d packets:", transfer, transfer->num_iso_packets);
 475     ofs = 0;
 476     size = 0;
 477     pkts = 0;
 478     for (i = 0; i < transfer->num_iso_packets; i++) {
 479         if (transfer->iso_packet_desc[i].status)
 480         {
 481             printf("[%02d: actual length is %4d, status is %2d] ", i, transfer->iso_packet_desc[i].actual_length, transfer->iso_packet_desc[i].status);
 482             continue;
 483         }
 484         else if (transfer->iso_packet_desc[i].actual_length)
 485         {
 486             assert(transfer->iso_packet_desc[i].actual_length == 3);
 487             size += data[ofs];
 488             if (i && transfer->iso_packet_desc[i - 1].actual_length)
 489                 assert(data[ofs + 1] == data[ofs - 64]);
 490             //printf("%d\n", (int)data[ofs]);
 491             if (uii->debug_sync)
 492                 printf("%3d ", (int)data[ofs]);
 493             pkts++;
 494         }
 495         else
 496         if (uii->debug_sync)
 497             printf("? ");
 498         ofs += transfer->iso_packet_desc[i].length;
 499     }
 500     if (uii->debug_sync)
 501         printf(" (%d of %d)", pkts, transfer->num_iso_packets);
 502     if (pkts == transfer->num_iso_packets)
 503     {
 504         if (size)
 505             uii->sync_freq = size * 10 / pkts;
 506         if (uii->debug_sync)
 507             printf(" size = %4d sync_freq = %4d", size, uii->sync_freq);
 508     }
 509     if (uii->no_resubmit)
 510         return;
 511     int err = usbio_transfer_submit(xf);
 512     if (err)
 513     {
 514         if (err == LIBUSB_ERROR_NO_DEVICE)
 515         {
 516             return;
 517         }
 518     }
 519     if (uii->debug_sync)
 520         printf("\n");
 521 }
 522
 523 struct usbio_transfer *sync_stuff_asynchronous(struct cbox_usb_io_impl *uii, int index)
 524 {
 525     struct usbio_transfer *t;
 526     int err;
 527     int syncbufsize = 64;
 528     int syncbufcount = NUM_SYNC_PACKETS;
 529     t = usbio_transfer_new(uii->usbctx, "sync", index, syncbufcount, uii);
 530     uint8_t *sync_buf = (uint8_t *)calloc(syncbufcount, syncbufsize);
 531     libusb_fill_iso_transfer(t->transfer, uii->handle_audiodev, uii->audio_sync_endpoint, sync_buf, syncbufsize * syncbufcount, syncbufcount, sync_callback, t, 20000);
 532     libusb_set_iso_packet_lengths(t->transfer, syncbufsize);
 533
 534     err = libusb_submit_transfer(t->transfer);
 535     if (err)
 536     {
 537         g_warning("Cannot submit sync urb: %s", libusb_error_name(err));
 538         free(sync_buf);
 539         usbio_transfer_destroy(t);
 540         return NULL;
 541     }
 542     return t;
 543 }
 544
 545 ///////////////////////////////////////////////////////////////////////////
 546
 547 void cbox_usb_audio_info_init(struct cbox_usb_audio_info *uai, struct cbox_usb_device_info *udi)
 548 {
 549     uai->udi = udi;
 550     uai->intf = -1;
 551     uai->alt_setting = -1;
 552     uai->epdesc.found = FALSE;
 553 }
 554
 555 void usbio_start_audio_playback(struct cbox_usb_io_impl *uii)
 556 {
 557     uii->desync = 0;
 558     uii->samples_played = 0;
 559     uii->read_ptr = uii->ioi.pio->io_env.buffer_size;
 560
 561     uii->playback_transfers = malloc(sizeof(struct libusb_transfer *) * uii->playback_buffers);
 562     uii->sync_transfers = malloc(sizeof(struct libusb_transfer *) * uii->sync_buffers);
 563
 564     uii->playback_counter = 0;
 565     uii->device_removed = 0;
 566     uii->sync_freq = uii->sample_rate / 100;
 567     uii->play_function(uii);
 568     uii->setup_error = uii->playback_counter == 0;
 569
 570     if (!uii->setup_error)
 571     {
 572         while(uii->playback_counter < uii->playback_buffers && !uii->device_removed)
 573             libusb_handle_events(uii->usbctx);
 574     }
 575 }
 576
 577 void usbio_stop_audio_playback(struct cbox_usb_io_impl *uii)
 578 {
 579     if (uii->device_removed)
 580     {
 581         // Wait until all the transfers pending are finished
 582         while(uii->device_removed < uii->playback_counter)
 583             libusb_handle_events(uii->usbctx);
 584     }
 585     if (uii->device_removed || uii->setup_error)
 586     {
 587         // Run the DSP code and send output to bit bucket until engine is stopped.
 588         // This ensures that the command queue will still be processed.
 589         // Otherwise the GUI thread would hang waiting for the command from
 590         // the queue to be completed.
 591         g_message("USB Audio output device has been disconnected - switching to null output.");
 592         usbio_run_idle_loop(uii);
 593     }
 594     else
 595     {
 596         // Cancel all transfers pending, and wait until they get cancelled
 597         for (int i = 0; i < uii->playback_counter; i++)
 598         {
 599             if (uii->playback_transfers[i])
 600                 usbio_transfer_shutdown(uii->playback_transfers[i]);
 601         }
 602     }
 603
 604     // Free the transfers for the buffers allocated so far. In case of setup
 605     // failure, some buffers transfers might not have been created yet.
 606     for (int i = 0; i < uii->playback_counter; i++)
 607     {
 608         if (uii->playback_transfers[i])
 609         {
 610             free(uii->playback_transfers[i]->transfer->buffer);
 611             usbio_transfer_destroy(uii->playback_transfers[i]);
 612             uii->playback_transfers[i] = NULL;
 613         }
 614     }
 615     if (uii->playback_counter && uii->audio_sync_endpoint)
 616     {
 617         for (int i = 0; i < uii->sync_counter; i++)
 618         {
 619             if (uii->sync_transfers[i])
 620                 usbio_transfer_shutdown(uii->sync_transfers[i]);
 621         }
 622         for (int i = 0; i < uii->sync_counter; i++)
 623         {
 624             if (uii->sync_transfers[i])
 625             {
 626                 free(uii->sync_transfers[i]->transfer->buffer);
 627                 usbio_transfer_destroy(uii->sync_transfers[i]);
 628                 uii->sync_transfers[i] = NULL;
 629             }
 630         }
 631     }
 632     free(uii->playback_transfers);
 633     free(uii->sync_transfers);
 634 }
 635