tsiry-sandratraina.com
A modern Music Player Daemon based on Rockbox open source high quality audio player
libadwaita
audio
rust
zig
deno
mpris
rockbox
mpd
1/***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id: $
9 *
10 * Copyright (C) 2010 by Amaury Pouly
11 *
12 * All files in this archive are subject to the GNU General Public License.
13 * See the file COPYING in the source tree root for full license agreement.
14 *
15 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
16 * KIND, either express or implied.
17 *
18 ****************************************************************************/
19
20/* NOTE
21 *
22 * This is USBAudio 1.0. USBAudio 2.0 is notably _not backwards compatible!_
23 * USBAudio 1.0 over _USB_ 2.0 is perfectly valid!
24 *
25 * Relevant specifications are USB 2.0 and USB Audio Class 1.0.
26 */
27
28#include "string.h"
29#include "system.h"
30#include "usb_core.h"
31#include "usb_drv.h"
32#include "kernel.h"
33#include "sound.h"
34#include "usb_class_driver.h"
35#include "usb_audio_def.h"
36#include "pcm_sampr.h"
37#include "audio.h"
38#include "sound.h"
39#include "stdlib.h"
40#include "fixedpoint.h"
41#include "misc.h"
42#include "settings.h"
43#include "core_alloc.h"
44#include "pcm_mixer.h"
45#include "dsp_core.h"
46
47#define LOGF_ENABLE
48#include "logf.h"
49
50// is there a "best practices" for converting between floats and fixed point?
51// NOTE: SIGNED
52#define TO_16DOT16_FIXEDPT(val) ((int32_t)(val) * (1<<16))
53#define TO_DOUBLE(val) ((double)(val) / (1<<16))
54
55/* Audio Control Interface */
56static struct usb_interface_descriptor
57 ac_interface =
58{
59 .bLength = sizeof(struct usb_interface_descriptor),
60 .bDescriptorType = USB_DT_INTERFACE,
61 .bInterfaceNumber = 0,
62 .bAlternateSetting = 0,
63 .bNumEndpoints = 0,
64 .bInterfaceClass = USB_CLASS_AUDIO,
65 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL,
66 .bInterfaceProtocol = 0,
67 .iInterface = 0
68};
69
70/* Audio Control Terminals/Units*/
71static struct usb_ac_header ac_header =
72{
73 .bLength = USB_AC_SIZEOF_HEADER(1), /* one interface */
74 .bDescriptorType = USB_DT_CS_INTERFACE,
75 .bDescriptorSubType = USB_AC_HEADER,
76 .bcdADC = 0x0100, /* Identifies this as usb audio class 1.0 */
77 .wTotalLength = 0, /* fill later */
78 .bInCollection = 1, /* one interface */
79 .baInterfaceNr = {0}, /* fill later */
80};
81
82enum
83{
84 AC_PLAYBACK_INPUT_TERMINAL_ID = 1,
85 AC_PLAYBACK_FEATURE_ID,
86 AC_PLAYBACK_OUTPUT_TERMINAL_ID,
87};
88
89static struct usb_ac_input_terminal ac_playback_input =
90{
91 .bLength = sizeof(struct usb_ac_input_terminal),
92 .bDescriptorType = USB_DT_CS_INTERFACE,
93 .bDescriptorSubType = USB_AC_INPUT_TERMINAL,
94 .bTerminalId = AC_PLAYBACK_INPUT_TERMINAL_ID,
95 .wTerminalType = USB_AC_TERMINAL_STREAMING,
96 .bAssocTerminal = 0,
97 .bNrChannels = 2,
98 .wChannelConfig = USB_AC_CHANNELS_LEFT_RIGHT_FRONT,
99 .iChannelNames = 0,
100 .iTerminal = 0,
101};
102
103static struct usb_ac_output_terminal ac_playback_output =
104{
105 .bLength = sizeof(struct usb_ac_output_terminal),
106 .bDescriptorType = USB_DT_CS_INTERFACE,
107 .bDescriptorSubType = USB_AC_OUTPUT_TERMINAL,
108 .bTerminalId = AC_PLAYBACK_OUTPUT_TERMINAL_ID,
109 .wTerminalType = USB_AC_OUTPUT_TERMINAL_HEADPHONES,
110 .bAssocTerminal = 0,
111 .bSourceId = AC_PLAYBACK_FEATURE_ID,
112 .iTerminal = 0,
113};
114
115/* Feature Unit with 2 logical channels and 1 byte(8 bits) per control */
116DEFINE_USB_AC_FEATURE_UNIT(8, 2)
117
118static struct usb_ac_feature_unit_8_2 ac_playback_feature =
119{
120 .bLength = sizeof(struct usb_ac_feature_unit_8_2),
121 .bDescriptorType = USB_DT_CS_INTERFACE,
122 .bDescriptorSubType = USB_AC_FEATURE_UNIT,
123 .bUnitId = AC_PLAYBACK_FEATURE_ID,
124 .bSourceId = AC_PLAYBACK_INPUT_TERMINAL_ID,
125 .bControlSize = 1, /* by definition */
126 .bmaControls = {
127 [0] = USB_AC_FU_MUTE | USB_AC_FU_VOLUME,
128 [1] = 0,
129 [2] = 0
130 },
131 .iFeature = 0
132};
133
134/* Audio Streaming Interface */
135/* Alternative: no streaming */
136static struct usb_interface_descriptor
137 as_interface_alt_idle_playback =
138{
139 .bLength = sizeof(struct usb_interface_descriptor),
140 .bDescriptorType = USB_DT_INTERFACE,
141 .bInterfaceNumber = 0,
142 .bAlternateSetting = 0,
143 .bNumEndpoints = 0,
144 .bInterfaceClass = USB_CLASS_AUDIO,
145 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_STREAMING,
146 .bInterfaceProtocol = 0,
147 .iInterface = 0
148};
149
150/* Alternative: output streaming */
151static struct usb_interface_descriptor
152 as_interface_alt_playback =
153{
154 .bLength = sizeof(struct usb_interface_descriptor),
155 .bDescriptorType = USB_DT_INTERFACE,
156 .bInterfaceNumber = 0,
157 .bAlternateSetting = 1,
158 .bNumEndpoints = 2, // iso audio, iso feedback
159 .bInterfaceClass = USB_CLASS_AUDIO,
160 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_STREAMING,
161 .bInterfaceProtocol = 0,
162 .iInterface = 0
163};
164
165/* Class Specific Audio Streaming Interface */
166static struct usb_as_interface
167 as_playback_cs_interface =
168{
169 .bLength = sizeof(struct usb_as_interface),
170 .bDescriptorType = USB_DT_CS_INTERFACE,
171 .bDescriptorSubType = USB_AS_GENERAL,
172 .bTerminalLink = AC_PLAYBACK_INPUT_TERMINAL_ID,
173 .bDelay = 1,
174 .wFormatTag = USB_AS_FORMAT_TYPE_I_PCM
175};
176
177static struct usb_as_format_type_i_discrete
178 as_playback_format_type_i =
179{
180 .bLength = USB_AS_SIZEOF_FORMAT_TYPE_I_DISCRETE((HW_FREQ_44+1)),
181 .bDescriptorType = USB_DT_CS_INTERFACE,
182 .bDescriptorSubType = USB_AS_FORMAT_TYPE,
183 .bFormatType = USB_AS_FORMAT_TYPE_I,
184 .bNrChannels = 2, /* Stereo */
185 .bSubframeSize = 2, /* 2 bytes per sample */
186 .bBitResolution = 16, /* all 16-bits are used */
187 .bSamFreqType = (HW_FREQ_44+1),
188 .tSamFreq = {
189 // only values 44.1k and higher (array is in descending order)
190 [0 ... HW_FREQ_44 ] = {0}, /* filled later */
191 }
192};
193
194static struct usb_as_iso_audio_endpoint
195 as_iso_audio_out_ep =
196{
197 .bLength = sizeof(struct usb_as_iso_audio_endpoint),
198 .bDescriptorType = USB_DT_ENDPOINT,
199 .bEndpointAddress = USB_DIR_OUT, /* filled later */
200 .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC | USB_ENDPOINT_USAGE_DATA,
201 .wMaxPacketSize = 0, /* filled later */
202 .bInterval = 0, /* filled later - 1 for full speed, 4 for high-speed */
203 .bRefresh = 0,
204 .bSynchAddress = 0 /* filled later to the address of as_iso_synch_in_ep */
205};
206
207/*
208 * Updaing the desired sample frequency:
209 *
210 * The iso OUT ep is inextricably linked to the feedback iso IN ep
211 * when using Asynchronous mode. It periodically describes to the host
212 * how fast to send the data.
213 *
214 * Some notes from the usbaudio 1.0 documentation:
215 * - bSyncAddress of the iso OUT ep must be set to the address of the iso IN feedback ep
216 * - bSyncAddress of the iso IN feedback ep must be zero
217 * - F_f (desired sampling frequency) describes directly the number of samples the endpoint
218 * wants to receive per frame to match the actual sampling frequency F_s
219 * - There is a value, (2^(10-P)), which is how often (in 1mS frames) the F_f value will be sent
220 * - P appears to be somewhat arbitrary, though the spec wants it to relate the real sample rate
221 * F_s to the master clock rate F_m by the relationship (F_m = F_s * (2^(P-1)))
222 * - The above description of P is somewhat moot because of how much buffering we have. I suspect it
223 * was written for devices with essentially zero buffering.
224 * - bRefresh of the feedback endpoint descriptor should be set to (10-P). This can range from 1 to 9.
225 * A value of 1 would mean refreshing every 2^1 mS = 2 mS, a value of 9 would mean refreshing every
226 * 2^9 mS = 512 mS.
227 * - The F_f value should be encoded in "10.10" format, but justified to the leftmost 24 bits,
228 * so it ends up looking like "10.14" format. This format is 3 bytes long. On USB 2.0, it seems that
229 * the USB spec overrides the UAC 1.0 spec here, so high-speed bus operation needs "16.16" format,
230 * in a 4 byte packet.
231 */
232#define FEEDBACK_UPDATE_RATE_P 5
233#define FEEDBACK_UPDATE_RATE_REFRESH (10-FEEDBACK_UPDATE_RATE_P)
234#define FEEDBACK_UPDATE_RATE_FRAMES (0x1<<FEEDBACK_UPDATE_RATE_REFRESH)
235static struct usb_as_iso_synch_endpoint
236 as_iso_synch_in_ep =
237{
238 .bLength = sizeof(struct usb_as_iso_synch_endpoint),
239 .bDescriptorType = USB_DT_ENDPOINT,
240 .bEndpointAddress = USB_DIR_IN, /* filled later */
241 .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_NONE | USB_ENDPOINT_USAGE_FEEDBACK,
242 .wMaxPacketSize = 4,
243 .bInterval = 0, /* filled later - 1 or 4 depending on bus speed */
244 .bRefresh = FEEDBACK_UPDATE_RATE_REFRESH, /* This describes how often this ep will update F_f (see above) */
245 .bSynchAddress = 0 /* MUST be zero! */
246};
247
248static struct usb_as_iso_ctrldata_endpoint
249 as_iso_ctrldata_samfreq =
250{
251 .bLength = sizeof(struct usb_as_iso_ctrldata_endpoint),
252 .bDescriptorType = USB_DT_CS_ENDPOINT,
253 .bDescriptorSubType = USB_AS_EP_GENERAL,
254 .bmAttributes = USB_AS_EP_CS_SAMPLING_FREQ_CTL,
255 .bLockDelayUnits = 0, /* undefined */
256 .wLockDelay = 0 /* undefined */
257};
258
259static const struct usb_descriptor_header* const ac_cs_descriptors_list[] =
260{
261 (struct usb_descriptor_header *) &ac_header,
262 (struct usb_descriptor_header *) &ac_playback_input,
263 (struct usb_descriptor_header *) &ac_playback_feature,
264 (struct usb_descriptor_header *) &ac_playback_output,
265};
266
267#define AC_CS_DESCRIPTORS_LIST_SIZE (sizeof(ac_cs_descriptors_list)/sizeof(ac_cs_descriptors_list[0]))
268
269// TODO: AudioControl Interrupt endpoint to inform the host that changes were made on-device!
270// The most immediately useful of this capability is volume and mute changes.
271static const struct usb_descriptor_header* const usb_descriptors_list[] =
272{
273 /* Audio Control */
274 (struct usb_descriptor_header *) &ac_interface,
275 (struct usb_descriptor_header *) &ac_header,
276 (struct usb_descriptor_header *) &ac_playback_input,
277 (struct usb_descriptor_header *) &ac_playback_feature,
278 (struct usb_descriptor_header *) &ac_playback_output,
279 /* Audio Streaming */
280 /* Idle Playback */
281 (struct usb_descriptor_header *) &as_interface_alt_idle_playback,
282 /* Playback */
283 (struct usb_descriptor_header *) &as_interface_alt_playback,
284 (struct usb_descriptor_header *) &as_playback_cs_interface,
285 (struct usb_descriptor_header *) &as_playback_format_type_i,
286 /* NOTE: the order of these three is important for maximum compatibility.
287 * Synch ep should follow iso out ep, with ctrldata descriptor coming first. */
288 (struct usb_descriptor_header *) &as_iso_ctrldata_samfreq,
289 (struct usb_descriptor_header *) &as_iso_audio_out_ep,
290 (struct usb_descriptor_header *) &as_iso_synch_in_ep,
291};
292
293#define USB_DESCRIPTORS_LIST_SIZE (sizeof(usb_descriptors_list)/sizeof(usb_descriptors_list[0]))
294
295static int usb_interface; /* first interface */
296static int usb_as_playback_intf_alt; /* playback streaming interface alternate setting */
297
298static int as_playback_freq_idx; /* audio playback streaming frequency index (in hw_freq_sampr) */
299
300static int out_iso_ep_adr; /* output isochronous endpoint */
301static int in_iso_feedback_ep_adr; /* input feedback isochronous endpoint */
302
303/* small buffer used for control transfers */
304static unsigned char usb_buffer[128] USB_DEVBSS_ATTR;
305
306/* number of buffers: 2 is double-buffering (one for usb, one for playback),
307 * 3 is triple-buffering (one for usb, one for playback, one for queuing), ... */
308
309/* Samples come in (maximum) 1023 byte chunks. Samples are also 16 bits per channel per sample.
310 *
311 * One buffer holds (1023 / (2Bx2ch)) = 255 (rounded down) samples
312 * So the _maximum_ play time per buffer is (255 / sps).
313 * For 44100 Hz: 5.7 mS
314 * For 48000 Hz: 5.3 mS
315 * For 192000 Hz: 1.3 mS
316 *
317 * From testing on MacOS (likely to be the toughest customer...) on Designware driver
318 * we get data every Frame (so, every millisecond).
319 *
320 * If we get data every millisecond, we need 1mS to transfer 1.3mS of playback
321 * in order to sustain 192 kHz playback!
322 * At 44.1 kHz, the requirements are much less - 1mS of data transfer for 5.7mS of playback
323 * At 48 kHz, 1mS can transfer 5.3mS of playback.
324 *
325 * It appears that this is "maximum", but we more likely get "enough for 1mS" every millisecond.
326 *
327 * Working backwards:
328 * 44100 Hz: 45 samples transferred every frame (*2ch * 2bytes) = 180 bytes every frame
329 * 48000 Hz: 48 samples transferred every frame (*2ch * 2bytes) = 192 bytes every frame
330 * 192000 Hz: *2ch *2bytes = 768 bytes every frame
331 *
332 * We appear to be more limited by our PCM system's need to gobble up data at startup.
333 * This may actually, contrary to intuition, make us need a higher number of buffers
334 * for _lower_ sample rates, as we will need more buffers' worth of data up-front due to
335 * lower amounts of data in each USB frame (assuming the mixer wants the same amount of data upfront
336 * regardless of sample rate).
337 *
338 * Making the executive decision to only export frequencies 44.1k+.
339 */
340#define NR_BUFFERS 32
341#define MINIMUM_BUFFERS_QUEUED 16
342/* size of each buffer: must be smaller than 1023 (max isochronous packet size) */
343#define BUFFER_SIZE 1023
344/* make sure each buffer size is actually a multiple of 32 bytes to avoid any
345 * issue with strange alignements */
346#define REAL_BUF_SIZE ALIGN_UP(BUFFER_SIZE, 32)
347
348bool alloc_failed = false;
349bool usb_audio_playing = false;
350int tmp_saved_vol;
351
352/* buffers used for usb, queuing and playback */
353static unsigned char *rx_buffer;
354int rx_buffer_handle;
355/* buffer size */
356static int rx_buf_size[NR_BUFFERS]; // only used for debug screen counter now
357/* index of the next buffer to play */
358static int rx_play_idx;
359/* index of the next buffer to fill */
360static int rx_usb_idx;
361/* playback underflowed ? */
362bool playback_audio_underflow;
363/* usb overflow ? */
364bool usb_rx_overflow;
365
366/* dsp processing buffers */
367#define DSP_BUF_SIZE (BUFFER_SIZE*4) // arbitrarily x4
368#define REAL_DSP_BUF_SIZE ALIGN_UP(DSP_BUF_SIZE, 32)
369static uint16_t *dsp_buf;
370int dsp_buf_handle;
371static int dsp_buf_size[NR_BUFFERS];
372struct dsp_config *dsp = NULL;
373
374/* feedback variables */
375#define USB_FRAME_MAX 0x7FF
376#define NR_SAMPLES_HISTORY 32
377int32_t samples_fb;
378int32_t buffers_filled_old;
379long buffers_filled_accumulator;
380long buffers_filled_accumulator_old;
381int buffers_filled_avgcount;
382int buffers_filled_avgcount_old;
383static uint8_t sendFf[4] USB_DEVBSS_ATTR;
384static bool sent_fb_this_frame = false;
385int fb_startframe = 0;
386bool send_fb = false;
387
388/* debug screen sample count display variables */
389static unsigned long samples_received;
390static unsigned long samples_received_last;
391int32_t samples_received_report;
392int buffers_filled_min;
393int buffers_filled_min_last;
394int buffers_filled_max;
395int buffers_filled_max_last;
396
397/* frame drop recording variables */
398static int last_frame = 0;
399static int frames_dropped = 0;
400
401/* for blocking normal playback */
402static bool usbaudio_active = false;
403
404/* Schematic view of the RX situation:
405 * (in case NR_BUFFERS = 4)
406 *
407 * +--------+ +--------+ +--------+ +--------+
408 * | | | | | | | |
409 * | buf[0] | ---> | buf[1] | ---> | buf[2] | ---> | buf[3] | ---> (back to buf[0])
410 * | | | | | | | |
411 * +--------+ +--------+ +--------+ +--------+
412 * ^ ^ ^ ^
413 * | | | |
414 * rx_play_idx (buffer rx_usb_idx (empty buffer)
415 * (buffer being filled) (buffer being
416 * played) filled)
417 *
418 * Error handling:
419 * in the RX situation, there are two possible errors
420 * - playback underflow: playback wants more data but we don't have any to
421 * provide, so we have to stop audio and wait for some prebuffering before
422 * starting again
423 * - usb overflow: usb wants to send more data but don't have any more free buffers,
424 * so we have to pause usb reception and wait for some playback buffer to become
425 * free again
426 */
427
428/* USB Audio encodes frequencies with 3 bytes... */
429static void encode3(uint8_t arr[3], unsigned long freq)
430{
431 /* ugly */
432 arr[0] = freq & 0xff;
433 arr[1] = (freq >> 8) & 0xff;
434 arr[2] = (freq >> 16) & 0xff;
435}
436
437static unsigned long decode3(uint8_t arr[3])
438{
439 return arr[0] | (arr[1] << 8) | (arr[2] << 16);
440}
441
442// size is samples per frame!
443static void encodeFBfixedpt(uint8_t arr[4], int32_t value, bool portspeed)
444{
445 uint32_t fixedpt;
446 // high-speed
447 if (portspeed)
448 {
449 // Q16.16
450 fixedpt = value;
451
452 arr[0] = (fixedpt & 0xFF);
453 arr[1] = (fixedpt>>8) & 0xFF;
454 arr[2] = (fixedpt>>16) & 0xFF;
455 arr[3] = (fixedpt>>24) & 0xFF;
456 }
457 else // full-speed
458 {
459 // Q16.16 --> Q10.10 --> Q10.14
460 fixedpt = value / (1<<2); // convert from Q16.16 to Q10.14
461
462 // then aligned so it's more like Q10.14
463 // NOTE: this line left for posterity
464 // fixedpt = fixedpt << (4);
465
466 arr[0] = (fixedpt & 0xFF);
467 arr[1] = (fixedpt>>8) & 0xFF;
468 arr[2] = (fixedpt>>16) & 0xFF;
469 }
470
471}
472
473static void set_playback_sampling_frequency(unsigned long f)
474{
475 // only values 44.1k and higher (array is in descending order)
476 for(int i = 0; i <= HW_FREQ_44; i++)
477 {
478 /* compare errors */
479 int err = abs((long)hw_freq_sampr[i] - (long)f);
480 int best_err = abs((long)hw_freq_sampr[as_playback_freq_idx] - (long)f);
481 if(err < best_err)
482 as_playback_freq_idx = i;
483 }
484
485 logf("usbaudio: set playback sampling frequency to %lu Hz for a requested %lu Hz",
486 hw_freq_sampr[as_playback_freq_idx], f);
487
488 mixer_set_frequency(hw_freq_sampr[as_playback_freq_idx]);
489 pcm_apply_settings();
490}
491
492unsigned long usb_audio_get_playback_sampling_frequency(void)
493{
494 // logf("usbaudio: get playback sampl freq %lu Hz", hw_freq_sampr[as_playback_freq_idx]);
495 return hw_freq_sampr[as_playback_freq_idx];
496}
497
498void usb_audio_init(void)
499{
500 unsigned int i;
501 /* initialized tSamFreq array */
502 logf("usbaudio: (init) supported frequencies");
503 // only values 44.1k and higher (array is in descending order)
504 for(i = 0; i <= HW_FREQ_44; i++)
505 {
506 logf("usbaudio: %lu Hz", hw_freq_sampr[i]);
507 encode3(as_playback_format_type_i.tSamFreq[i], hw_freq_sampr[i]);
508 }
509}
510
511int usb_audio_request_buf(void)
512{
513 // stop playback first thing
514 audio_stop();
515
516 // attempt to allocate the receive buffers
517 rx_buffer_handle = core_alloc(REAL_BUF_SIZE);
518 if (rx_buffer_handle < 0)
519 {
520 alloc_failed = true;
521 return -1;
522 }
523 else
524 {
525 alloc_failed = false;
526
527 // "pin" the allocation so that the core does not move it in memory
528 core_pin(rx_buffer_handle);
529
530 // get the pointer to the actual buffer location
531 rx_buffer = core_get_data(rx_buffer_handle);
532 }
533
534 dsp_buf_handle = core_alloc(NR_BUFFERS * REAL_DSP_BUF_SIZE);
535 if (dsp_buf_handle < 0)
536 {
537 alloc_failed = true;
538 rx_buffer_handle = core_free(rx_buffer_handle);
539 rx_buffer = NULL;
540 return -1;
541 }
542 else
543 {
544 alloc_failed = false;
545
546 core_pin(dsp_buf_handle);
547
548 dsp_buf = core_get_data(dsp_buf_handle);
549 }
550 // logf("usbaudio: got buffer");
551 return 0;
552}
553
554void usb_audio_free_buf(void)
555{
556 // logf("usbaudio: free buffer");
557 rx_buffer_handle = core_free(rx_buffer_handle);
558 rx_buffer = NULL;
559
560 dsp_buf_handle = core_free(dsp_buf_handle);
561 dsp_buf = NULL;
562}
563
564int usb_audio_request_endpoints(struct usb_class_driver *drv)
565{
566 // make sure we can get the buffers first...
567 // return -1 if the allocation _failed_
568 if (usb_audio_request_buf())
569 return -1;
570
571 out_iso_ep_adr = usb_core_request_endpoint(USB_ENDPOINT_XFER_ISOC, USB_DIR_OUT, drv);
572 if(out_iso_ep_adr < 0)
573 {
574 logf("usbaudio: cannot get an out iso endpoint");
575 return -1;
576 }
577
578 in_iso_feedback_ep_adr = usb_core_request_endpoint(USB_ENDPOINT_XFER_ISOC, USB_DIR_IN, drv);
579 if(in_iso_feedback_ep_adr < 0)
580 {
581 usb_core_release_endpoint(out_iso_ep_adr);
582 logf("usbaudio: cannot get an in iso endpoint");
583 return -1;
584 }
585
586 logf("usbaudio: iso out ep is 0x%x, in ep is 0x%x", out_iso_ep_adr, in_iso_feedback_ep_adr);
587
588 as_iso_audio_out_ep.bEndpointAddress = out_iso_ep_adr;
589 as_iso_audio_out_ep.bSynchAddress = in_iso_feedback_ep_adr;
590
591 as_iso_synch_in_ep.bEndpointAddress = in_iso_feedback_ep_adr;
592 as_iso_synch_in_ep.bSynchAddress = 0;
593
594 return 0;
595}
596
597unsigned int usb_audio_get_out_ep(void)
598{
599 return out_iso_ep_adr;
600}
601
602unsigned int usb_audio_get_in_ep(void)
603{
604 return in_iso_feedback_ep_adr;
605}
606
607int usb_audio_set_first_interface(int interface)
608{
609 usb_interface = interface;
610 logf("usbaudio: usb_interface=%d", usb_interface);
611 return interface + 2; /* Audio Control and Audio Streaming */
612}
613
614int usb_audio_get_config_descriptor(unsigned char *dest, int max_packet_size)
615{
616 (void)max_packet_size;
617 unsigned int i;
618 unsigned char *orig_dest = dest;
619
620 logf("get config descriptors");
621
622 /** Configuration */
623
624 /* header */
625 ac_header.baInterfaceNr[0] = usb_interface + 1;
626
627 /* audio control interface */
628 ac_interface.bInterfaceNumber = usb_interface;
629
630 /* compute total size of AC headers*/
631 ac_header.wTotalLength = 0;
632 for(i = 0; i < AC_CS_DESCRIPTORS_LIST_SIZE; i++)
633 ac_header.wTotalLength += ac_cs_descriptors_list[i]->bLength;
634
635 /* audio streaming */
636 as_interface_alt_idle_playback.bInterfaceNumber = usb_interface + 1;
637 as_interface_alt_playback.bInterfaceNumber = usb_interface + 1;
638
639 /* endpoints */
640 as_iso_audio_out_ep.wMaxPacketSize = 1023;
641
642 /** Endpoint Interval calculation:
643 * typically sampling frequency is 44100 Hz and top is 192000 Hz, which
644 * account for typical 44100*2(stereo)*2(16-bit) ~= 180 kB/s
645 * and top 770 kB/s. Since there are ~1000 frames per seconds and maximum
646 * packet size is set to 1023, one transaction per frame is good enough
647 * for over 1 MB/s.
648 * Recall that actual is 2^(bInterval - 1) */
649
650 /* In simpler language, This is intended to emulate full-speed's
651 * one-packet-per-frame rate on high-speed, where we have multiple microframes per millisecond.
652 */
653 as_iso_audio_out_ep.bInterval = usb_drv_port_speed() ? 4 : 1;
654 as_iso_synch_in_ep.bInterval = usb_drv_port_speed() ? 4 : 1; // per spec
655
656 logf("usbaudio: port_speed=%s", usb_drv_port_speed()?"hs":"fs");
657
658 /** Packing */
659 for(i = 0; i < USB_DESCRIPTORS_LIST_SIZE; i++)
660 {
661 memcpy(dest, usb_descriptors_list[i], usb_descriptors_list[i]->bLength);
662 dest += usb_descriptors_list[i]->bLength;
663 }
664
665 return dest - orig_dest;
666}
667
668static void playback_audio_get_more(const void **start, size_t *size)
669{
670 /* if there are no more filled buffers, playback has just underflowed */
671 if(rx_play_idx == rx_usb_idx)
672 {
673 logf("usbaudio: playback underflow");
674 playback_audio_underflow = true;
675 *start = NULL;
676 *size = 0;
677 return;
678 }
679
680 /* give buffer and advance */
681 logf("usbaudio: buf adv");
682 *start = dsp_buf + (rx_play_idx * REAL_DSP_BUF_SIZE/sizeof(*dsp_buf));
683 *size = dsp_buf_size[rx_play_idx];
684 rx_play_idx = (rx_play_idx + 1) % NR_BUFFERS;
685
686 /* if usb RX buffers had overflowed, we can start to receive again
687 * guard against IRQ to avoid race with completion usb completion (although
688 * this function is probably running in IRQ context anyway) */
689 int oldlevel = disable_irq_save();
690 if(usb_rx_overflow)
691 {
692 logf("usbaudio: recover usb rx overflow");
693 usb_rx_overflow = false;
694 usb_drv_recv_nonblocking(out_iso_ep_adr, rx_buffer, BUFFER_SIZE);
695 }
696 restore_irq(oldlevel);
697}
698
699static void usb_audio_start_playback(void)
700{
701 usb_audio_playing = true;
702 usb_rx_overflow = false;
703 playback_audio_underflow = true;
704 rx_play_idx = 0;
705 rx_usb_idx = 0;
706
707 // feedback initialization
708 fb_startframe = usb_drv_get_frame_number();
709 samples_fb = 0;
710 samples_received_report = 0;
711
712 // debug screen info - frame drop counter
713 frames_dropped = 0;
714 last_frame = -1;
715 buffers_filled_min = -1;
716 buffers_filled_min_last = -1;
717 buffers_filled_max = -1;
718 buffers_filled_max_last = -1;
719
720 // debug screen info - sample counters
721 samples_received = 0;
722 samples_received_last = 0;
723
724 // TODO: implement recording from the USB stream
725#if (INPUT_SRC_CAPS != 0)
726 audio_set_input_source(AUDIO_SRC_PLAYBACK, SRCF_PLAYBACK);
727 audio_set_output_source(AUDIO_SRC_PLAYBACK);
728#endif
729 logf("usbaudio: start playback at %lu Hz", hw_freq_sampr[as_playback_freq_idx]);
730 mixer_set_frequency(hw_freq_sampr[as_playback_freq_idx]);
731 pcm_apply_settings();
732 mixer_channel_set_amplitude(PCM_MIXER_CHAN_USBAUDIO, MIX_AMP_UNITY);
733
734 usb_drv_recv_nonblocking(out_iso_ep_adr, rx_buffer, BUFFER_SIZE);
735}
736
737static void usb_audio_stop_playback(void)
738{
739 logf("usbaudio: stop playback");
740 if(usb_audio_playing)
741 {
742 mixer_channel_stop(PCM_MIXER_CHAN_USBAUDIO);
743 usb_audio_playing = false;
744 }
745 send_fb = false;
746}
747
748int usb_audio_set_interface(int intf, int alt)
749{
750 if(intf == usb_interface)
751 {
752 if(alt != 0)
753 {
754 logf("usbaudio: control interface has no alternate %d", alt);
755 return -1;
756 }
757
758 return 0;
759 }
760 if(intf == (usb_interface + 1))
761 {
762 if(alt < 0 || alt > 1)
763 {
764 logf("usbaudio: playback interface has no alternate %d", alt);
765 return -1;
766 }
767 usb_as_playback_intf_alt = alt;
768
769 if(usb_as_playback_intf_alt == 1)
770 usb_audio_start_playback();
771 else
772 usb_audio_stop_playback();
773 logf("usbaudio: use playback alternate %d", alt);
774
775 return 0;
776 }
777 else
778 {
779 logf("usbaudio: interface %d has no alternate", intf);
780 return -1;
781 }
782}
783
784int usb_audio_get_interface(int intf)
785{
786 if(intf == usb_interface)
787 {
788 logf("usbaudio: control interface alternate is 0");
789 return 0;
790 }
791 else if(intf == (usb_interface + 1))
792 {
793 logf("usbaudio: playback interface alternate is %d", usb_as_playback_intf_alt);
794 return usb_as_playback_intf_alt;
795 }
796 else
797 {
798 logf("usbaudio: unknown interface %d", intf);
799 return -1;
800 }
801}
802
803int usb_audio_get_main_intf(void)
804{
805 return usb_interface;
806}
807
808int usb_audio_get_alt_intf(void)
809{
810 return usb_as_playback_intf_alt;
811}
812
813int32_t usb_audio_get_samplesperframe(void)
814{
815 return samples_fb;
816}
817
818int32_t usb_audio_get_samples_rx_perframe(void)
819{
820 return samples_received_report;
821}
822
823static bool usb_audio_as_ctrldata_endpoint_request(struct usb_ctrlrequest* req, void *reqdata)
824{
825 /* only support sampling frequency */
826 if(req->wValue != (USB_AS_EP_CS_SAMPLING_FREQ_CTL << 8))
827 {
828 logf("usbaudio: endpoint only handles sampling frequency control");
829 return false;
830 }
831
832 switch(req->bRequest)
833 {
834 case USB_AC_SET_CUR:
835 if(req->wLength != 3)
836 {
837 logf("usbaudio: bad length for SET_CUR");
838 usb_drv_control_response(USB_CONTROL_STALL, NULL, 0);
839 return true;
840 }
841 logf("usbaudio: SET_CUR sampling freq");
842
843 if (reqdata) { /* control write, second pass */
844 set_playback_sampling_frequency(decode3(reqdata));
845 usb_drv_control_response(USB_CONTROL_ACK, NULL, 0);
846 return true;
847 } else { /* control write, first pass */
848 bool error = false;
849
850 if (req->wLength != 3)
851 error = true;
852 /* ... other validation? */
853
854 if (error)
855 usb_drv_control_response(USB_CONTROL_STALL, NULL, 0);
856 else
857 usb_drv_control_response(USB_CONTROL_RECEIVE, usb_buffer, 3);
858
859 return true;
860 }
861
862 case USB_AC_GET_CUR:
863 if(req->wLength != 3)
864 {
865 logf("usbaudio: bad length for GET_CUR");
866 usb_drv_control_response(USB_CONTROL_STALL, NULL, 0);
867 return true;
868 }
869 logf("usbaudio: GET_CUR sampling freq");
870 encode3(usb_buffer, usb_audio_get_playback_sampling_frequency());
871 usb_drv_control_response(USB_CONTROL_ACK, usb_buffer, req->wLength);
872
873 return true;
874
875 default:
876 logf("usbaudio: unhandled ep req 0x%x", req->bRequest);
877 }
878
879 return true;
880}
881
882static bool usb_audio_endpoint_request(struct usb_ctrlrequest* req, void *reqdata)
883{
884 int ep = req->wIndex & 0xff;
885
886 if(ep == out_iso_ep_adr)
887 return usb_audio_as_ctrldata_endpoint_request(req, reqdata);
888 else
889 {
890 logf("usbaudio: unhandled ep req (ep=%d)", ep);
891 return false;
892 }
893}
894
895static bool feature_unit_set_mute(int value, uint8_t cmd)
896{
897 if(cmd != USB_AC_CUR_REQ)
898 {
899 logf("usbaudio: feature unit MUTE control only has a CUR setting");
900 return false;
901 }
902
903 if(value == 1)
904 {
905 logf("usbaudio: mute !");
906 tmp_saved_vol = sound_current(SOUND_VOLUME);
907
908 // setvol does range checking for us!
909 global_status.volume = sound_min(SOUND_VOLUME);
910 setvol();
911 return true;
912 }
913 else if(value == 0)
914 {
915 logf("usbaudio: not muted !");
916
917 // setvol does range checking for us!
918 global_status.volume = tmp_saved_vol;
919 setvol();
920 return true;
921 }
922 else
923 {
924 logf("usbaudio: invalid value for CUR setting of feature unit (%d)", value);
925 return false;
926 }
927}
928
929static bool feature_unit_get_mute(int *value, uint8_t cmd)
930{
931 if(cmd != USB_AC_CUR_REQ)
932 {
933 logf("usbaudio: feature unit MUTE control only has a CUR setting");
934 return false;
935 }
936
937 *value = (sound_current(SOUND_VOLUME) == sound_min(SOUND_VOLUME));
938 return true;
939}
940
941/*
942* USB volume is a signed 16-bit value, -127.9961 dB (0x8001) to +127.9961 dB (0x7FFF)
943* in steps of 1/256 dB (0.00390625 dB)
944*
945* We need to account for different devices having different numbers of decimals
946*/
947// TODO: do we need to explicitly round these? Will we have a "walking" round conversion issue?
948// Step values of 1 dB (and multiples), and 0.5 dB should be able to be met exactly,
949// presuming that it starts on an even number.
950static int usb_audio_volume_to_db(int vol, int numdecimals)
951{
952 int tmp = (signed long)((signed short)vol * ipow(10, numdecimals)) / 256;
953 // logf("vol=0x%04X, numdecimals=%d, tmp=%d", vol, numdecimals, tmp);
954 return tmp;
955}
956static int db_to_usb_audio_volume(int db, int numdecimals)
957{
958 int tmp = (signed long)(db * 256) / ipow(10, numdecimals);
959 // logf("db=%d, numdecimals=%d, tmpTodB=%d", db, numdecimals, usb_audio_volume_to_db(tmp, numdecimals));
960 return tmp;
961}
962
963#if defined(LOGF_ENABLE) && defined(ROCKBOX_HAS_LOGF)
964static const char *usb_audio_ac_ctl_req_str(uint8_t cmd)
965{
966 switch(cmd)
967 {
968 case USB_AC_CUR_REQ: return "CUR";
969 case USB_AC_MIN_REQ: return "MIN";
970 case USB_AC_MAX_REQ: return "MAX";
971 case USB_AC_RES_REQ: return "RES";
972 case USB_AC_MEM_REQ: return "MEM";
973 default: return "<unknown>";
974 }
975}
976#endif
977
978static bool feature_unit_set_volume(int value, uint8_t cmd)
979{
980 if(cmd != USB_AC_CUR_REQ)
981 {
982 logf("usbaudio: feature unit VOLUME doesn't support %s setting", usb_audio_ac_ctl_req_str(cmd));
983 return false;
984 }
985
986 logf("usbaudio: set volume=%d dB", usb_audio_volume_to_db(value, sound_numdecimals(SOUND_VOLUME)));
987
988 // setvol does range checking for us!
989 // we cannot guarantee the host will send us a volume within our range
990 global_status.volume = usb_audio_volume_to_db(value, sound_numdecimals(SOUND_VOLUME));
991 setvol();
992 return true;
993}
994
995static bool feature_unit_get_volume(int *value, uint8_t cmd)
996{
997 switch(cmd)
998 {
999 case USB_AC_CUR_REQ: *value = db_to_usb_audio_volume(sound_current(SOUND_VOLUME), sound_numdecimals(SOUND_VOLUME)); break;
1000 case USB_AC_MIN_REQ: *value = db_to_usb_audio_volume(sound_min(SOUND_VOLUME), sound_numdecimals(SOUND_VOLUME)); break;
1001 case USB_AC_MAX_REQ: *value = db_to_usb_audio_volume(sound_max(SOUND_VOLUME), sound_numdecimals(SOUND_VOLUME)); break;
1002 case USB_AC_RES_REQ: *value = db_to_usb_audio_volume(sound_steps(SOUND_VOLUME), sound_numdecimals(SOUND_VOLUME)); break;
1003 default:
1004 logf("usbaudio: feature unit VOLUME doesn't support %s setting", usb_audio_ac_ctl_req_str(cmd));
1005 return false;
1006 }
1007
1008 // logf("usbaudio: get %s volume=%d dB", usb_audio_ac_ctl_req_str(cmd), usb_audio_volume_to_db(*value, sound_numdecimals(SOUND_VOLUME)));
1009 return true;
1010}
1011
1012int usb_audio_get_cur_volume(void)
1013{
1014 int vol;
1015 feature_unit_get_volume(&vol, USB_AC_CUR_REQ);
1016 return usb_audio_volume_to_db(vol, sound_numdecimals(SOUND_VOLUME));
1017}
1018
1019static bool usb_audio_set_get_feature_unit(struct usb_ctrlrequest* req, void *reqdata)
1020{
1021 int channel = req->wValue & 0xff;
1022 int selector = req->wValue >> 8;
1023 uint8_t cmd = (req->bRequest & ~USB_AC_GET_REQ);
1024 int value = 0;
1025 int i;
1026 bool handled;
1027
1028 /* master channel only */
1029 if(channel != 0)
1030 {
1031 logf("usbaudio: set/get on feature unit only apply to master channel (%d)", channel);
1032 return false;
1033 }
1034 /* selectors */
1035 /* all send/received values are integers already - read data if necessary and store in it in an integer */
1036 if(req->bRequest & USB_AC_GET_REQ)
1037 {
1038 /* get */
1039 switch(selector)
1040 {
1041 case USB_AC_FU_MUTE:
1042 handled = (req->wLength == 1) && feature_unit_get_mute(&value, cmd);
1043 break;
1044 case USB_AC_VOLUME_CONTROL:
1045 handled = (req->wLength == 2) && feature_unit_get_volume(&value, cmd);
1046 break;
1047 default:
1048 handled = false;
1049 logf("usbaudio: unhandled control selector of feature unit (0x%x)", selector);
1050 break;
1051 }
1052
1053 if(!handled)
1054 {
1055 logf("usbaudio: unhandled get control 0x%x selector 0x%x of feature unit", cmd, selector);
1056 usb_drv_control_response(USB_CONTROL_STALL, NULL, 0);
1057 return true;
1058 }
1059
1060 if(req->wLength == 0 || req->wLength > 4)
1061 {
1062 logf("usbaudio: get data payload size is invalid (%d)", req->wLength);
1063 return false;
1064 }
1065
1066 for(i = 0; i < req->wLength; i++)
1067 usb_buffer[i] = (value >> (8 * i)) & 0xff;
1068
1069 usb_drv_control_response(USB_CONTROL_ACK, usb_buffer, req->wLength);
1070 return true;
1071 }
1072 else
1073 {
1074 /* set */
1075 if(req->wLength == 0 || req->wLength > 4)
1076 {
1077 logf("usbaudio: set data payload size is invalid (%d)", req->wLength);
1078 return false;
1079 }
1080
1081 if (reqdata) {
1082
1083 for(i = 0; i < req->wLength; i++)
1084 value = value | (usb_buffer[i] << (i * 8));
1085
1086 switch(selector)
1087 {
1088 case USB_AC_FU_MUTE:
1089 handled = (req->wLength == 1) && feature_unit_set_mute(value, cmd);
1090 break;
1091 case USB_AC_VOLUME_CONTROL:
1092 handled = (req->wLength == 2) && feature_unit_set_volume(value, cmd);
1093 break;
1094 default:
1095 handled = false;
1096 logf("usbaudio: unhandled control selector of feature unit (0x%x)", selector);
1097 break;
1098 }
1099
1100 if(!handled)
1101 {
1102 logf("usbaudio: unhandled set control 0x%x selector 0x%x of feature unit", cmd, selector);
1103 usb_drv_control_response(USB_CONTROL_STALL, NULL, 0);
1104 return true;
1105 }
1106
1107 usb_drv_control_response(USB_CONTROL_ACK, NULL, 0);
1108 return true;
1109 } else {
1110 /*
1111 * should handle the following (req->wValue >> 8):
1112 * USB_AC_FU_MUTE
1113 * USB_AC_VOLUME_CONTROL
1114 */
1115
1116 bool error = false;
1117
1118 if (error)
1119 usb_drv_control_response(USB_CONTROL_STALL, NULL, 0);
1120 else
1121 usb_drv_control_response(USB_CONTROL_RECEIVE, usb_buffer, 3);
1122
1123 return true;
1124 }
1125
1126 return true;
1127 }
1128}
1129
1130static bool usb_audio_ac_set_get_request(struct usb_ctrlrequest* req, void *reqdata)
1131{
1132 switch(req->wIndex >> 8)
1133 {
1134 case AC_PLAYBACK_FEATURE_ID:
1135 return usb_audio_set_get_feature_unit(req, reqdata);
1136 default:
1137 logf("usbaudio: unhandled set/get on entity %d", req->wIndex >> 8);
1138 return false;
1139 }
1140}
1141
1142static bool usb_audio_interface_request(struct usb_ctrlrequest* req, void *reqdata)
1143{
1144 int intf = req->wIndex & 0xff;
1145
1146 if(intf == usb_interface)
1147 {
1148 switch(req->bRequest)
1149 {
1150 case USB_AC_SET_CUR: case USB_AC_SET_MIN: case USB_AC_SET_MAX: case USB_AC_SET_RES:
1151 case USB_AC_SET_MEM: case USB_AC_GET_CUR: case USB_AC_GET_MIN: case USB_AC_GET_MAX:
1152 case USB_AC_GET_RES: case USB_AC_GET_MEM:
1153 return usb_audio_ac_set_get_request(req, reqdata);
1154 default:
1155 logf("usbaudio: unhandled ac intf req 0x%x", req->bRequest);
1156 return false;
1157 }
1158 }
1159 else
1160 {
1161 logf("usbaudio: unhandled intf req (intf=%d)", intf);
1162 return false;
1163 }
1164}
1165
1166bool usb_audio_control_request(struct usb_ctrlrequest* req, void *reqdata, unsigned char* dest)
1167{
1168 (void) reqdata;
1169 (void) dest;
1170
1171 switch(req->bRequestType & USB_RECIP_MASK)
1172 {
1173 case USB_RECIP_ENDPOINT:
1174 return usb_audio_endpoint_request(req, reqdata);
1175 case USB_RECIP_INTERFACE:
1176 return usb_audio_interface_request(req, reqdata);
1177 default:
1178 logf("usbaudio: unhandled req type 0x%x", req->bRequestType);
1179 return false;
1180 }
1181}
1182
1183void usb_audio_init_connection(void)
1184{
1185 logf("usbaudio: init connection");
1186
1187 usbaudio_active = true;
1188 dsp = dsp_get_config(CODEC_IDX_AUDIO);
1189 dsp_configure(dsp, DSP_RESET, 0);
1190 dsp_configure(dsp, DSP_SET_STEREO_MODE, STEREO_INTERLEAVED);
1191 dsp_configure(dsp, DSP_SET_SAMPLE_DEPTH, 16);
1192#ifdef HAVE_PITCHCONTROL
1193 sound_set_pitch(PITCH_SPEED_100);
1194 dsp_set_timestretch(PITCH_SPEED_100);
1195#endif
1196
1197 usb_as_playback_intf_alt = 0;
1198 set_playback_sampling_frequency(HW_SAMPR_DEFAULT);
1199 tmp_saved_vol = sound_current(SOUND_VOLUME);
1200 usb_audio_playing = false;
1201}
1202
1203void usb_audio_disconnect(void)
1204{
1205 logf("usbaudio: disconnect");
1206
1207 usb_audio_stop_playback();
1208 usb_audio_free_buf();
1209 usbaudio_active = false;
1210}
1211
1212bool usb_audio_get_active(void)
1213{
1214 return usbaudio_active;
1215}
1216
1217bool usb_audio_get_alloc_failed(void)
1218{
1219 return alloc_failed;
1220}
1221
1222bool usb_audio_get_playing(void)
1223{
1224 return usb_audio_playing;
1225}
1226
1227/* determine if enough prebuffering has been done to restart audio */
1228bool prebuffering_done(void)
1229{
1230 /* restart audio if at least MINIMUM_BUFFERS_QUEUED buffers are filled */
1231 int diff = (rx_usb_idx - rx_play_idx + NR_BUFFERS) % NR_BUFFERS;
1232 return diff >= MINIMUM_BUFFERS_QUEUED;
1233}
1234
1235int usb_audio_get_prebuffering(void)
1236{
1237 return (rx_usb_idx - rx_play_idx + NR_BUFFERS) % NR_BUFFERS;
1238}
1239
1240int32_t usb_audio_get_prebuffering_avg(void)
1241{
1242 if (buffers_filled_avgcount == 0)
1243 {
1244 return TO_16DOT16_FIXEDPT(usb_audio_get_prebuffering());
1245 } else {
1246 return (TO_16DOT16_FIXEDPT(buffers_filled_accumulator)/buffers_filled_avgcount) + TO_16DOT16_FIXEDPT(MINIMUM_BUFFERS_QUEUED);
1247 }
1248}
1249
1250int usb_audio_get_prebuffering_maxmin(bool max)
1251{
1252 if (max)
1253 {
1254 return buffers_filled_max == -1 ? buffers_filled_max_last : buffers_filled_max;
1255 }
1256 else
1257 {
1258 return buffers_filled_min == -1 ? buffers_filled_min_last : buffers_filled_min;
1259 }
1260}
1261
1262bool usb_audio_get_underflow(void)
1263{
1264 return playback_audio_underflow;
1265}
1266
1267bool usb_audio_get_overflow(void)
1268{
1269 return usb_rx_overflow;
1270}
1271
1272int usb_audio_get_frames_dropped(void)
1273{
1274 return frames_dropped;
1275}
1276
1277void usb_audio_transfer_complete(int ep, int dir, int status, int length)
1278{
1279 /* normal handler is too slow to handle the completion rate, because
1280 * of the low thread schedule rate */
1281 (void) ep;
1282 (void) dir;
1283 (void) status;
1284 (void) length;
1285}
1286
1287bool usb_audio_fast_transfer_complete(int ep, int dir, int status, int length)
1288{
1289 (void) dir;
1290 bool retval = false;
1291
1292 if(ep == out_iso_ep_adr && usb_as_playback_intf_alt == 1)
1293 {
1294 // check for dropped frames
1295 if (last_frame != usb_drv_get_frame_number())
1296 {
1297 if ((((last_frame + 1) % (USB_FRAME_MAX + 1)) != usb_drv_get_frame_number()) && (last_frame != -1))
1298 {
1299 frames_dropped++;
1300 }
1301 last_frame = usb_drv_get_frame_number();
1302 }
1303
1304 // If audio and feedback EPs happen to have the same base number (with opposite directions, of course),
1305 // we will get replies to the feedback here, don't want that to be interpreted as data.
1306 if (length <= 4)
1307 {
1308 return true;
1309 }
1310
1311 logf("usbaudio: frame: %d bytes: %d", usb_drv_get_frame_number(), length);
1312 if(status != 0)
1313 return true; /* FIXME how to handle error here ? */
1314
1315 /* store length, queue buffer */
1316 rx_buf_size[rx_usb_idx] = length;
1317
1318 // debug screen counter
1319 samples_received = samples_received + length;
1320
1321 // process through DSP right away!
1322 struct dsp_buffer src;
1323 src.remcount = length/4; // in samples
1324 src.pin[0] = rx_buffer;
1325 src.proc_mask = 0;
1326
1327 struct dsp_buffer dst;
1328 dst.remcount = 0;
1329 dst.bufcount = DSP_BUF_SIZE/4; // in samples
1330 dst.p16out = dsp_buf + (rx_usb_idx * REAL_DSP_BUF_SIZE/sizeof(*dsp_buf)); // array index
1331
1332 dsp_process(dsp, &src, &dst, false);
1333 dsp_buf_size[rx_usb_idx] = dst.remcount * 2 * sizeof(*dsp_buf); // need value in bytes
1334
1335 rx_usb_idx = (rx_usb_idx + 1) % NR_BUFFERS;
1336
1337 /* guard against IRQ to avoid race with completion audio completion */
1338 int oldlevel = disable_irq_save();
1339 /* setup a new transaction except if we ran out of buffers */
1340 if(rx_usb_idx != rx_play_idx)
1341 {
1342 logf("usbaudio: new transaction");
1343 usb_drv_recv_nonblocking(out_iso_ep_adr, rx_buffer, BUFFER_SIZE);
1344 }
1345 else
1346 {
1347 logf("usbaudio: rx overflow");
1348 usb_rx_overflow = true;
1349 }
1350 /* if audio underflowed and prebuffering is done, restart audio */
1351 if(playback_audio_underflow && prebuffering_done())
1352 {
1353 logf("usbaudio: prebuffering done");
1354 playback_audio_underflow = false;
1355 usb_rx_overflow = false;
1356 mixer_channel_play_data(PCM_MIXER_CHAN_USBAUDIO, playback_audio_get_more, NULL, 0);
1357 }
1358 restore_irq(oldlevel);
1359 retval = true;
1360 }
1361 else
1362 {
1363 retval = false;
1364 }
1365
1366 // send feedback value every N frames!
1367 // NOTE: important that we need to queue this up _the frame before_ it's needed - on MacOS especially!
1368 if ((usb_drv_get_frame_number()+1) % FEEDBACK_UPDATE_RATE_FRAMES == 0 && send_fb)
1369 {
1370 if (!sent_fb_this_frame)
1371 {
1372 /* NOTE: the division of frequency must be staged to avoid overflow of 16-bit signed int
1373 * as well as truncating the result to ones place!
1374 * Must avoid values > 32,768 (2^15)
1375 * Largest value: 192,000 --> /10: 19,200 --> /100: 192
1376 * Smallest value: 44,100 --> /10: 4,410 --> /100: 44.1
1377 */
1378 int32_t samples_base = TO_16DOT16_FIXEDPT(hw_freq_sampr[as_playback_freq_idx]/10)/100;
1379 int32_t buffers_filled = 0;
1380
1381 if (buffers_filled_avgcount != 0)
1382 {
1383 buffers_filled = TO_16DOT16_FIXEDPT((int32_t)buffers_filled_accumulator) / buffers_filled_avgcount;
1384 }
1385 buffers_filled_accumulator = buffers_filled_accumulator - buffers_filled_accumulator_old;
1386 buffers_filled_avgcount = buffers_filled_avgcount - buffers_filled_avgcount_old;
1387 buffers_filled_accumulator_old = buffers_filled_accumulator;
1388 buffers_filled_avgcount_old = buffers_filled_avgcount;
1389
1390 // someone who has implemented actual PID before might be able to do this correctly,
1391 // but this seems to work good enough?
1392 // Coefficients were 1, 0.25, 0.025 in float math --> 1, /4, /40 in fixed-point math
1393 samples_fb = samples_base - (buffers_filled/4) + ((buffers_filled_old - buffers_filled)/40);
1394 buffers_filled_old = buffers_filled;
1395
1396 // must limit to +/- 1 sample from nominal
1397 samples_fb = samples_fb > (samples_base + TO_16DOT16_FIXEDPT(1)) ? samples_base + TO_16DOT16_FIXEDPT(1) : samples_fb;
1398 samples_fb = samples_fb < (samples_base - TO_16DOT16_FIXEDPT(1)) ? samples_base - TO_16DOT16_FIXEDPT(1) : samples_fb;
1399
1400 encodeFBfixedpt(sendFf, samples_fb, usb_drv_port_speed());
1401 logf("usbaudio: frame %d fbval 0x%02X%02X%02X%02X", usb_drv_get_frame_number(), sendFf[3], sendFf[2], sendFf[1], sendFf[0]);
1402 usb_drv_send_nonblocking(in_iso_feedback_ep_adr, sendFf, usb_drv_port_speed()?4:3);
1403
1404 // debug screen counters
1405 //
1406 // samples_received NOTE: need some "division staging" to not overflow signed 16-bit value
1407 // samples / (feedback frames * 2) --> samples/2
1408 // samples_report / (2ch * 2bytes per sample) --> samples/4
1409 // total: samples/8
1410 samples_received_report = TO_16DOT16_FIXEDPT(samples_received/8) / FEEDBACK_UPDATE_RATE_FRAMES;
1411 samples_received = samples_received - samples_received_last;
1412 samples_received_last = samples_received;
1413 buffers_filled_max_last = buffers_filled_max;
1414 buffers_filled_max = -1;
1415 buffers_filled_min_last = buffers_filled_min;
1416 buffers_filled_min = -1;
1417 }
1418 sent_fb_this_frame = true;
1419 }
1420 else
1421 {
1422 sent_fb_this_frame = false;
1423 if (!send_fb)
1424 {
1425 // arbitrary wait during startup
1426 if (usb_drv_get_frame_number() == (fb_startframe + (FEEDBACK_UPDATE_RATE_FRAMES*2))%(USB_FRAME_MAX+1))
1427 {
1428 send_fb = true;
1429 }
1430 }
1431 buffers_filled_accumulator = buffers_filled_accumulator + (usb_audio_get_prebuffering() - MINIMUM_BUFFERS_QUEUED);
1432 buffers_filled_avgcount++;
1433 if (usb_audio_get_prebuffering() < buffers_filled_min || buffers_filled_min == -1)
1434 {
1435 buffers_filled_min = usb_audio_get_prebuffering();
1436 } else if (usb_audio_get_prebuffering() > buffers_filled_max)
1437 {
1438 buffers_filled_max = usb_audio_get_prebuffering();
1439 }
1440 }
1441
1442 return retval;
1443}