/* * Copyright © 2019-2020 Nia Alarie * Copyright © 2020 Ka Ho Ng * Copyright © 2020 The FreeBSD Foundation * * Portions of this software were developed by Ka Ho Ng * under sponsorship from the FreeBSD Foundation. * * This program is made available under an ISC-style license. See the * accompanying file LICENSE for details. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "cubeb/cubeb.h" #include "cubeb_mixer.h" #include "cubeb_strings.h" #include "cubeb-internal.h" /* Supported well by most hardware. */ #ifndef OSS_PREFER_RATE #define OSS_PREFER_RATE (48000) #endif /* Standard acceptable minimum. */ #ifndef OSS_LATENCY_MS #define OSS_LATENCY_MS (8) #endif #ifndef OSS_NFRAGS #define OSS_NFRAGS (4) #endif #ifndef OSS_DEFAULT_DEVICE #define OSS_DEFAULT_DEVICE "/dev/dsp" #endif #ifndef OSS_DEFAULT_MIXER #define OSS_DEFAULT_MIXER "/dev/mixer" #endif #define ENV_AUDIO_DEVICE "AUDIO_DEVICE" #ifndef OSS_MAX_CHANNELS # if defined(__FreeBSD__) || defined(__DragonFly__) /* * The current maximum number of channels supported * on FreeBSD is 8. * * Reference: FreeBSD 12.1-RELEASE */ # define OSS_MAX_CHANNELS (8) # elif defined(__sun__) /* * The current maximum number of channels supported * on Illumos is 16. * * Reference: PSARC 2008/318 */ # define OSS_MAX_CHANNELS (16) # else # define OSS_MAX_CHANNELS (2) # endif #endif #if defined(__FreeBSD__) || defined(__DragonFly__) #define SNDSTAT_BEGIN_STR "Installed devices:" #define SNDSTAT_USER_BEGIN_STR "Installed devices from userspace:" #define SNDSTAT_FV_BEGIN_STR "File Versions:" #endif static struct cubeb_ops const oss_ops; struct cubeb { struct cubeb_ops const * ops; /* Our intern string store */ pthread_mutex_t mutex; /* protects devid_strs */ cubeb_strings *devid_strs; }; struct oss_stream { oss_devnode_t name; int fd; void * buf; struct stream_info { int channels; int sample_rate; int fmt; int precision; } info; unsigned int frame_size; /* precision in bytes * channels */ bool floating; }; struct cubeb_stream { struct cubeb * context; void * user_ptr; pthread_t thread; bool doorbell; /* (m) */ pthread_cond_t doorbell_cv; /* (m) */ pthread_cond_t stopped_cv; /* (m) */ pthread_mutex_t mtx; /* Members protected by this should be marked (m) */ bool thread_created; /* (m) */ bool running; /* (m) */ bool destroying; /* (m) */ cubeb_state state; /* (m) */ float volume /* (m) */; struct oss_stream play; struct oss_stream record; cubeb_data_callback data_cb; cubeb_state_callback state_cb; uint64_t frames_written /* (m) */; unsigned int nfr; /* Number of frames allocated */ unsigned int nfrags; unsigned int bufframes; }; static char const * oss_cubeb_devid_intern(cubeb *context, char const * devid) { char const *is; pthread_mutex_lock(&context->mutex); is = cubeb_strings_intern(context->devid_strs, devid); pthread_mutex_unlock(&context->mutex); return is; } int oss_init(cubeb **context, char const *context_name) { cubeb * c; (void)context_name; if ((c = calloc(1, sizeof(cubeb))) == NULL) { return CUBEB_ERROR; } if (cubeb_strings_init(&c->devid_strs) == CUBEB_ERROR) { goto fail; } if (pthread_mutex_init(&c->mutex, NULL) != 0) { goto fail; } c->ops = &oss_ops; *context = c; return CUBEB_OK; fail: cubeb_strings_destroy(c->devid_strs); free(c); return CUBEB_ERROR; } static void oss_destroy(cubeb * context) { pthread_mutex_destroy(&context->mutex); cubeb_strings_destroy(context->devid_strs); free(context); } static char const * oss_get_backend_id(cubeb * context) { return "oss"; } static int oss_get_preferred_sample_rate(cubeb * context, uint32_t * rate) { (void)context; *rate = OSS_PREFER_RATE; return CUBEB_OK; } static int oss_get_max_channel_count(cubeb * context, uint32_t * max_channels) { (void)context; *max_channels = OSS_MAX_CHANNELS; return CUBEB_OK; } static int oss_get_min_latency(cubeb * context, cubeb_stream_params params, uint32_t * latency_frames) { (void)context; *latency_frames = (OSS_LATENCY_MS * params.rate) / 1000; return CUBEB_OK; } static void oss_free_cubeb_device_info_strings(cubeb_device_info *cdi) { free((char *)cdi->device_id); free((char *)cdi->friendly_name); free((char *)cdi->group_id); cdi->device_id = NULL; cdi->friendly_name = NULL; cdi->group_id = NULL; } #if defined(__FreeBSD__) || defined(__DragonFly__) /* * Check if the specified DSP is okay for the purpose specified * in type. Here type can only specify one operation each time * this helper is called. * * Return 0 if OK, otherwise 1. */ static int oss_probe_open(const char *dsppath, cubeb_device_type type, int *fdp, oss_audioinfo *resai) { oss_audioinfo ai; int error; int oflags = (type == CUBEB_DEVICE_TYPE_INPUT) ? O_RDONLY : O_WRONLY; int dspfd = open(dsppath, oflags); if (dspfd == -1) return 1; ai.dev = -1; error = ioctl(dspfd, SNDCTL_AUDIOINFO, &ai); if (error < 0) { close(dspfd); return 1; } if (resai) *resai = ai; if (fdp) *fdp = dspfd; else close(dspfd); return 0; } struct sndstat_info { oss_devnode_t devname; const char *desc; cubeb_device_type type; int preferred; }; static int oss_sndstat_line_parse(char *line, int is_ud, struct sndstat_info *sinfo) { char *matchptr = line, *n = NULL; struct sndstat_info res; memset(&res, 0, sizeof(res)); n = strchr(matchptr, ':'); if (n == NULL) goto fail; if (is_ud == 0) { unsigned int devunit; if (sscanf(matchptr, "pcm%u: ", &devunit) < 1) goto fail; if (snprintf(res.devname, sizeof(res.devname), "/dev/dsp%u", devunit) < 1) goto fail; } else { if (n - matchptr >= (ssize_t)(sizeof(res.devname) - strlen("/dev/"))) goto fail; strlcpy(res.devname, "/dev/", sizeof(res.devname)); strncat(res.devname, matchptr, n - matchptr); } matchptr = n + 1; n = strchr(matchptr, '<'); if (n == NULL) goto fail; matchptr = n + 1; n = strrchr(matchptr, '>'); if (n == NULL) goto fail; *n = 0; res.desc = matchptr; matchptr = n + 1; n = strchr(matchptr, '('); if (n == NULL) goto fail; matchptr = n + 1; n = strrchr(matchptr, ')'); if (n == NULL) goto fail; *n = 0; if (!isdigit(matchptr[0])) { if (strstr(matchptr, "play") != NULL) res.type |= CUBEB_DEVICE_TYPE_OUTPUT; if (strstr(matchptr, "rec") != NULL) res.type |= CUBEB_DEVICE_TYPE_INPUT; } else { int p, r; if (sscanf(matchptr, "%dp:%*dv/%dr:%*dv", &p, &r) != 2) goto fail; if (p > 0) res.type |= CUBEB_DEVICE_TYPE_OUTPUT; if (r > 0) res.type |= CUBEB_DEVICE_TYPE_INPUT; } matchptr = n + 1; if (strstr(matchptr, "default") != NULL) res.preferred = 1; *sinfo = res; return 0; fail: return 1; } /* * XXX: On FreeBSD we have to rely on SNDCTL_CARDINFO to get all * the usable audio devices currently, as SNDCTL_AUDIOINFO will * never return directly usable audio device nodes. */ static int oss_enumerate_devices(cubeb * context, cubeb_device_type type, cubeb_device_collection * collection) { cubeb_device_info *devinfop = NULL; char *line = NULL; size_t linecap = 0; FILE *sndstatfp = NULL; int collection_cnt = 0; int is_ud = 0; int skipall = 0; devinfop = calloc(1, sizeof(cubeb_device_info)); if (devinfop == NULL) goto fail; sndstatfp = fopen("/dev/sndstat", "r"); if (sndstatfp == NULL) goto fail; while (getline(&line, &linecap, sndstatfp) > 0) { const char *devid = NULL; struct sndstat_info sinfo; oss_audioinfo ai; if (!strncmp(line, SNDSTAT_FV_BEGIN_STR, strlen(SNDSTAT_FV_BEGIN_STR))) { skipall = 1; continue; } if (!strncmp(line, SNDSTAT_BEGIN_STR, strlen(SNDSTAT_BEGIN_STR))) { is_ud = 0; skipall = 0; continue; } if (!strncmp(line, SNDSTAT_USER_BEGIN_STR, strlen(SNDSTAT_USER_BEGIN_STR))) { is_ud = 1; skipall = 0; continue; } if (skipall || isblank(line[0])) continue; if (oss_sndstat_line_parse(line, is_ud, &sinfo)) continue; devinfop[collection_cnt].type = 0; switch (sinfo.type) { case CUBEB_DEVICE_TYPE_INPUT: if (type & CUBEB_DEVICE_TYPE_OUTPUT) continue; break; case CUBEB_DEVICE_TYPE_OUTPUT: if (type & CUBEB_DEVICE_TYPE_INPUT) continue; break; case 0: continue; } if (oss_probe_open(sinfo.devname, type, NULL, &ai)) continue; devid = oss_cubeb_devid_intern(context, sinfo.devname); if (devid == NULL) continue; devinfop[collection_cnt].device_id = strdup(sinfo.devname); asprintf((char **)&devinfop[collection_cnt].friendly_name, "%s: %s", sinfo.devname, sinfo.desc); devinfop[collection_cnt].group_id = strdup(sinfo.devname); devinfop[collection_cnt].vendor_name = NULL; if (devinfop[collection_cnt].device_id == NULL || devinfop[collection_cnt].friendly_name == NULL || devinfop[collection_cnt].group_id == NULL) { oss_free_cubeb_device_info_strings(&devinfop[collection_cnt]); continue; } devinfop[collection_cnt].type = type; devinfop[collection_cnt].devid = devid; devinfop[collection_cnt].state = CUBEB_DEVICE_STATE_ENABLED; devinfop[collection_cnt].preferred = (sinfo.preferred) ? CUBEB_DEVICE_PREF_ALL : CUBEB_DEVICE_PREF_NONE; devinfop[collection_cnt].format = CUBEB_DEVICE_FMT_S16NE; devinfop[collection_cnt].default_format = CUBEB_DEVICE_FMT_S16NE; devinfop[collection_cnt].max_channels = ai.max_channels; devinfop[collection_cnt].default_rate = OSS_PREFER_RATE; devinfop[collection_cnt].max_rate = ai.max_rate; devinfop[collection_cnt].min_rate = ai.min_rate; devinfop[collection_cnt].latency_lo = 0; devinfop[collection_cnt].latency_hi = 0; collection_cnt++; void *newp = reallocarray(devinfop, collection_cnt + 1, sizeof(cubeb_device_info)); if (newp == NULL) goto fail; devinfop = newp; } free(line); fclose(sndstatfp); collection->count = collection_cnt; collection->device = devinfop; return CUBEB_OK; fail: free(line); if (sndstatfp) fclose(sndstatfp); free(devinfop); return CUBEB_ERROR; } #else static int oss_enumerate_devices(cubeb * context, cubeb_device_type type, cubeb_device_collection * collection) { oss_sysinfo si; int error, i; cubeb_device_info *devinfop = NULL; int collection_cnt = 0; int mixer_fd = -1; mixer_fd = open(OSS_DEFAULT_MIXER, O_RDWR); if (mixer_fd == -1) { LOG("Failed to open mixer %s. errno: %d", OSS_DEFAULT_MIXER, errno); return CUBEB_ERROR; } error = ioctl(mixer_fd, SNDCTL_SYSINFO, &si); if (error) { LOG("Failed to run SNDCTL_SYSINFO on mixer %s. errno: %d", OSS_DEFAULT_MIXER, errno); goto fail; } devinfop = calloc(si.numaudios, sizeof(cubeb_device_info)); if (devinfop == NULL) goto fail; collection->count = 0; for (i = 0; i < si.numaudios; i++) { oss_audioinfo ai; cubeb_device_info cdi = { 0 }; const char *devid = NULL; ai.dev = i; error = ioctl(mixer_fd, SNDCTL_AUDIOINFO, &ai); if (error) goto fail; assert(ai.dev < si.numaudios); if (!ai.enabled) continue; cdi.type = 0; switch (ai.caps & DSP_CAP_DUPLEX) { case DSP_CAP_INPUT: if (type & CUBEB_DEVICE_TYPE_OUTPUT) continue; break; case DSP_CAP_OUTPUT: if (type & CUBEB_DEVICE_TYPE_INPUT) continue; break; case 0: continue; } cdi.type = type; devid = oss_cubeb_devid_intern(context, ai.devnode); cdi.device_id = strdup(ai.name); cdi.friendly_name = strdup(ai.name); cdi.group_id = strdup(ai.name); if (devid == NULL || cdi.device_id == NULL || cdi.friendly_name == NULL || cdi.group_id == NULL) { oss_free_cubeb_device_info_strings(&cdi); continue; } cdi.devid = devid; cdi.vendor_name = NULL; cdi.state = CUBEB_DEVICE_STATE_ENABLED; cdi.preferred = CUBEB_DEVICE_PREF_NONE; cdi.format = CUBEB_DEVICE_FMT_S16NE; cdi.default_format = CUBEB_DEVICE_FMT_S16NE; cdi.max_channels = ai.max_channels; cdi.default_rate = OSS_PREFER_RATE; cdi.max_rate = ai.max_rate; cdi.min_rate = ai.min_rate; cdi.latency_lo = 0; cdi.latency_hi = 0; devinfop[collection_cnt++] = cdi; } collection->count = collection_cnt; collection->device = devinfop; if (mixer_fd != -1) close(mixer_fd); return CUBEB_OK; fail: if (mixer_fd != -1) close(mixer_fd); free(devinfop); return CUBEB_ERROR; } #endif static int oss_device_collection_destroy(cubeb * context, cubeb_device_collection * collection) { size_t i; for (i = 0; i < collection->count; i++) { oss_free_cubeb_device_info_strings(&collection->device[i]); } free(collection->device); collection->device = NULL; collection->count = 0; return 0; } static unsigned int oss_chn_from_cubeb(cubeb_channel chn) { switch (chn) { case CHANNEL_FRONT_LEFT: return CHID_L; case CHANNEL_FRONT_RIGHT: return CHID_R; case CHANNEL_FRONT_CENTER: return CHID_C; case CHANNEL_LOW_FREQUENCY: return CHID_LFE; case CHANNEL_BACK_LEFT: return CHID_LR; case CHANNEL_BACK_RIGHT: return CHID_RR; case CHANNEL_SIDE_LEFT: return CHID_LS; case CHANNEL_SIDE_RIGHT: return CHID_RS; default: return CHID_UNDEF; } } static unsigned long long oss_cubeb_layout_to_chnorder(cubeb_channel_layout layout) { unsigned int i, nchns = 0; unsigned long long chnorder = 0; for (i = 0; layout; i++, layout >>= 1) { unsigned long long chid = oss_chn_from_cubeb((layout & 1) << i); if (chid == CHID_UNDEF) continue; chnorder |= (chid & 0xf) << nchns * 4; nchns++; } return chnorder; } static int oss_copy_params(int fd, cubeb_stream * stream, cubeb_stream_params * params, struct stream_info * sinfo) { unsigned long long chnorder; sinfo->channels = params->channels; sinfo->sample_rate = params->rate; switch (params->format) { case CUBEB_SAMPLE_S16LE: sinfo->fmt = AFMT_S16_LE; sinfo->precision = 16; break; case CUBEB_SAMPLE_S16BE: sinfo->fmt = AFMT_S16_BE; sinfo->precision = 16; break; case CUBEB_SAMPLE_FLOAT32NE: sinfo->fmt = AFMT_S32_NE; sinfo->precision = 32; break; default: LOG("Unsupported format"); return CUBEB_ERROR_INVALID_FORMAT; } if (ioctl(fd, SNDCTL_DSP_CHANNELS, &sinfo->channels) == -1) { return CUBEB_ERROR; } if (ioctl(fd, SNDCTL_DSP_SETFMT, &sinfo->fmt) == -1) { return CUBEB_ERROR; } if (ioctl(fd, SNDCTL_DSP_SPEED, &sinfo->sample_rate) == -1) { return CUBEB_ERROR; } /* Mono layout is an exception */ if (params->layout != CUBEB_LAYOUT_UNDEFINED && params->layout != CUBEB_LAYOUT_MONO) { chnorder = oss_cubeb_layout_to_chnorder(params->layout); if (ioctl(fd, SNDCTL_DSP_SET_CHNORDER, &chnorder) == -1) LOG("Non-fatal error %d occured when setting channel order.", errno); } return CUBEB_OK; } static int oss_stream_stop(cubeb_stream * s) { pthread_mutex_lock(&s->mtx); if (s->thread_created && s->running) { s->running = false; s->doorbell = false; pthread_cond_wait(&s->stopped_cv, &s->mtx); } if (s->state != CUBEB_STATE_STOPPED) { s->state = CUBEB_STATE_STOPPED; pthread_mutex_unlock(&s->mtx); s->state_cb(s, s->user_ptr, CUBEB_STATE_STOPPED); } else { pthread_mutex_unlock(&s->mtx); } return CUBEB_OK; } static void oss_stream_destroy(cubeb_stream * s) { pthread_mutex_lock(&s->mtx); if (s->thread_created) { s->destroying = true; s->doorbell = true; pthread_cond_signal(&s->doorbell_cv); } pthread_mutex_unlock(&s->mtx); pthread_join(s->thread, NULL); pthread_cond_destroy(&s->doorbell_cv); pthread_cond_destroy(&s->stopped_cv); pthread_mutex_destroy(&s->mtx); if (s->play.fd != -1) { close(s->play.fd); } if (s->record.fd != -1) { close(s->record.fd); } free(s->play.buf); free(s->record.buf); free(s); } static void oss_float_to_linear32(void * buf, unsigned sample_count, float vol) { float * in = buf; int32_t * out = buf; int32_t * tail = out + sample_count; while (out < tail) { int64_t f = *(in++) * vol * 0x80000000LL; if (f < -INT32_MAX) f = -INT32_MAX; else if (f > INT32_MAX) f = INT32_MAX; *(out++) = f; } } static void oss_linear32_to_float(void * buf, unsigned sample_count) { int32_t * in = buf; float * out = buf; float * tail = out + sample_count; while (out < tail) { *(out++) = (1.0 / 0x80000000LL) * *(in++); } } static void oss_linear16_set_vol(int16_t * buf, unsigned sample_count, float vol) { unsigned i; int32_t multiplier = vol * 0x8000; for (i = 0; i < sample_count; ++i) { buf[i] = (buf[i] * multiplier) >> 15; } } static int oss_get_rec_frames(cubeb_stream * s, unsigned int nframes) { size_t rem = nframes * s->record.frame_size; size_t read_ofs = 0; while (rem > 0) { ssize_t n; if ((n = read(s->record.fd, (uint8_t *)s->record.buf + read_ofs, rem)) < 0) { if (errno == EINTR) continue; return CUBEB_ERROR; } read_ofs += n; rem -= n; } return 0; } static int oss_put_play_frames(cubeb_stream * s, unsigned int nframes) { size_t rem = nframes * s->play.frame_size; size_t write_ofs = 0; while (rem > 0) { ssize_t n; if ((n = write(s->play.fd, (uint8_t *)s->play.buf + write_ofs, rem)) < 0) { if (errno == EINTR) continue; return CUBEB_ERROR; } pthread_mutex_lock(&s->mtx); s->frames_written += n / s->play.frame_size; pthread_mutex_unlock(&s->mtx); write_ofs += n; rem -= n; } return 0; } /* 1 - Stopped by cubeb_stream_stop, otherwise 0 */ static int oss_audio_loop(cubeb_stream * s, cubeb_state *new_state) { cubeb_state state = CUBEB_STATE_STOPPED; int trig = 0; int drain = 0; const bool play_on = s->play.fd != -1, record_on = s->record.fd != -1; long nfr = s->bufframes; if (record_on) { if (ioctl(s->record.fd, SNDCTL_DSP_SETTRIGGER, &trig)) { LOG("Error %d occured when setting trigger on record fd", errno); state = CUBEB_STATE_ERROR; goto breakdown; } trig |= PCM_ENABLE_INPUT; if (ioctl(s->record.fd, SNDCTL_DSP_SETTRIGGER, &trig)) { LOG("Error %d occured when setting trigger on record fd", errno); state = CUBEB_STATE_ERROR; goto breakdown; } memset(s->record.buf, 0, s->bufframes * s->record.frame_size); } if (!play_on && !record_on) { /* * Stop here if the stream is not play & record stream, * play-only stream or record-only stream */ goto breakdown; } while (1) { pthread_mutex_lock(&s->mtx); if (!s->running || s->destroying) { pthread_mutex_unlock(&s->mtx); break; } pthread_mutex_unlock(&s->mtx); long got = 0; if (nfr > 0) { got = s->data_cb(s, s->user_ptr, s->record.buf, s->play.buf, nfr); if (got == CUBEB_ERROR) { state = CUBEB_STATE_ERROR; goto breakdown; } if (play_on) { float vol; pthread_mutex_lock(&s->mtx); vol = s->volume; pthread_mutex_unlock(&s->mtx); if (s->play.floating) { oss_float_to_linear32(s->play.buf, s->play.info.channels * got, vol); } else { oss_linear16_set_vol((int16_t *)s->play.buf, s->play.info.channels * got, vol); } } if (got < nfr) { if (s->play.fd != -1) { drain = 1; } else { /* * This is a record-only stream and number of frames * returned from data_cb() is smaller than number * of frames required to read. Stop here. */ state = CUBEB_STATE_STOPPED; goto breakdown; } } nfr = 0; } if (got > 0) { if (play_on && oss_put_play_frames(s, got) < 0) { state = CUBEB_STATE_ERROR; goto breakdown; } } if (drain) { state = CUBEB_STATE_DRAINED; goto breakdown; } audio_buf_info bi; if (play_on) { if (ioctl(s->play.fd, SNDCTL_DSP_GETOSPACE, &bi)) { state = CUBEB_STATE_ERROR; goto breakdown; } /* * In duplex mode, playback direction drives recording direction to * prevent building up latencies. */ nfr = bi.fragsize * bi.fragments / s->play.frame_size; if (nfr > s->bufframes) { nfr = s->bufframes; } } if (record_on) { if (nfr == 0) { nfr = s->nfr; } if (oss_get_rec_frames(s, nfr) == CUBEB_ERROR) { state = CUBEB_STATE_ERROR; goto breakdown; } if (s->record.floating) { oss_linear32_to_float(s->record.buf, s->record.info.channels * nfr); } } } return 1; breakdown: pthread_mutex_lock(&s->mtx); *new_state = s->state = state; s->running = false; pthread_mutex_unlock(&s->mtx); return 0; } static void * oss_io_routine(void *arg) { cubeb_stream *s = arg; cubeb_state new_state; int stopped; do { pthread_mutex_lock(&s->mtx); if (s->destroying) { pthread_mutex_unlock(&s->mtx); break; } pthread_mutex_unlock(&s->mtx); stopped = oss_audio_loop(s, &new_state); if (s->record.fd != -1) ioctl(s->record.fd, SNDCTL_DSP_HALT_INPUT, NULL); if (!stopped) s->state_cb(s, s->user_ptr, new_state); pthread_mutex_lock(&s->mtx); pthread_cond_signal(&s->stopped_cv); if (s->destroying) { pthread_mutex_unlock(&s->mtx); break; } while (!s->doorbell) { pthread_cond_wait(&s->doorbell_cv, &s->mtx); } s->doorbell = false; pthread_mutex_unlock(&s->mtx); } while (1); pthread_mutex_lock(&s->mtx); s->thread_created = false; pthread_mutex_unlock(&s->mtx); return NULL; } static inline int oss_calc_frag_shift(unsigned int frames, unsigned int frame_size) { int n = 4; int blksize = (frames * frame_size + OSS_NFRAGS - 1) / OSS_NFRAGS; while ((1 << n) < blksize) n++; return n; } static inline int oss_get_frag_params(unsigned int shift) { return (OSS_NFRAGS << 16) | shift; } static int oss_stream_init(cubeb * context, cubeb_stream ** stream, char const * stream_name, cubeb_devid input_device, cubeb_stream_params * input_stream_params, cubeb_devid output_device, cubeb_stream_params * output_stream_params, unsigned int latency_frames, cubeb_data_callback data_callback, cubeb_state_callback state_callback, void * user_ptr) { int ret = CUBEB_OK; unsigned int playnfr = 0, recnfr = 0; cubeb_stream *s = NULL; const char *defdsp; if (!(defdsp = getenv(ENV_AUDIO_DEVICE)) || *defdsp == '\0') defdsp = OSS_DEFAULT_DEVICE; (void)stream_name; if ((s = calloc(1, sizeof(cubeb_stream))) == NULL) { ret = CUBEB_ERROR; goto error; } s->state = CUBEB_STATE_STOPPED; s->record.fd = s->play.fd = -1; s->nfr = latency_frames; if (input_device != NULL) { strlcpy(s->record.name, input_device, sizeof(s->record.name)); } else { strlcpy(s->record.name, defdsp, sizeof(s->record.name)); } if (output_device != NULL) { strlcpy(s->play.name, output_device, sizeof(s->play.name)); } else { strlcpy(s->play.name, defdsp, sizeof(s->play.name)); } if (input_stream_params != NULL) { unsigned int nb_channels; if (input_stream_params->prefs & CUBEB_STREAM_PREF_LOOPBACK) { LOG("Loopback not supported"); ret = CUBEB_ERROR_NOT_SUPPORTED; goto error; } nb_channels = cubeb_channel_layout_nb_channels(input_stream_params->layout); if (input_stream_params->layout != CUBEB_LAYOUT_UNDEFINED && nb_channels != input_stream_params->channels) { LOG("input_stream_params->layout does not match input_stream_params->channels"); ret = CUBEB_ERROR_INVALID_PARAMETER; goto error; } if (s->record.fd == -1) { if ((s->record.fd = open(s->record.name, O_RDONLY)) == -1) { LOG("Audio device \"%s\" could not be opened as read-only", s->record.name); ret = CUBEB_ERROR_DEVICE_UNAVAILABLE; goto error; } } if ((ret = oss_copy_params(s->record.fd, s, input_stream_params, &s->record.info)) != CUBEB_OK) { LOG("Setting record params failed"); goto error; } s->record.floating = (input_stream_params->format == CUBEB_SAMPLE_FLOAT32NE); s->record.frame_size = s->record.info.channels * (s->record.info.precision / 8); recnfr = (1 << oss_calc_frag_shift(s->nfr, s->record.frame_size)) / s->record.frame_size; } if (output_stream_params != NULL) { unsigned int nb_channels; if (output_stream_params->prefs & CUBEB_STREAM_PREF_LOOPBACK) { LOG("Loopback not supported"); ret = CUBEB_ERROR_NOT_SUPPORTED; goto error; } nb_channels = cubeb_channel_layout_nb_channels(output_stream_params->layout); if (output_stream_params->layout != CUBEB_LAYOUT_UNDEFINED && nb_channels != output_stream_params->channels) { LOG("output_stream_params->layout does not match output_stream_params->channels"); ret = CUBEB_ERROR_INVALID_PARAMETER; goto error; } if (s->play.fd == -1) { if ((s->play.fd = open(s->play.name, O_WRONLY)) == -1) { LOG("Audio device \"%s\" could not be opened as write-only", s->play.name); ret = CUBEB_ERROR_DEVICE_UNAVAILABLE; goto error; } } if ((ret = oss_copy_params(s->play.fd, s, output_stream_params, &s->play.info)) != CUBEB_OK) { LOG("Setting play params failed"); goto error; } s->play.floating = (output_stream_params->format == CUBEB_SAMPLE_FLOAT32NE); s->play.frame_size = s->play.info.channels * (s->play.info.precision / 8); playnfr = (1 << oss_calc_frag_shift(s->nfr, s->play.frame_size)) / s->play.frame_size; } /* * Use the largest nframes among playing and recording streams to set OSS buffer size. * After that, use the smallest allocated nframes among both direction to allocate our * temporary buffers. */ s->nfr = (playnfr > recnfr) ? playnfr : recnfr; s->nfrags = OSS_NFRAGS; if (s->play.fd != -1) { int frag = oss_get_frag_params(oss_calc_frag_shift(s->nfr, s->play.frame_size)); if (ioctl(s->play.fd, SNDCTL_DSP_SETFRAGMENT, &frag)) LOG("Failed to set play fd with SNDCTL_DSP_SETFRAGMENT. frag: 0x%x", frag); audio_buf_info bi; if (ioctl(s->play.fd, SNDCTL_DSP_GETOSPACE, &bi)) LOG("Failed to get play fd's buffer info."); else { if (bi.fragsize / s->play.frame_size < s->nfr) s->nfr = bi.fragsize / s->play.frame_size; } } if (s->record.fd != -1) { int frag = oss_get_frag_params(oss_calc_frag_shift(s->nfr, s->record.frame_size)); if (ioctl(s->record.fd, SNDCTL_DSP_SETFRAGMENT, &frag)) LOG("Failed to set record fd with SNDCTL_DSP_SETFRAGMENT. frag: 0x%x", frag); audio_buf_info bi; if (ioctl(s->record.fd, SNDCTL_DSP_GETISPACE, &bi)) LOG("Failed to get record fd's buffer info."); else { if (bi.fragsize / s->record.frame_size < s->nfr) s->nfr = bi.fragsize / s->record.frame_size; } } s->bufframes = s->nfr * s->nfrags; s->context = context; s->volume = 1.0; s->state_cb = state_callback; s->data_cb = data_callback; s->user_ptr = user_ptr; if (pthread_mutex_init(&s->mtx, NULL) != 0) { LOG("Failed to create mutex"); goto error; } if (pthread_cond_init(&s->doorbell_cv, NULL) != 0) { LOG("Failed to create cv"); goto error; } if (pthread_cond_init(&s->stopped_cv, NULL) != 0) { LOG("Failed to create cv"); goto error; } s->doorbell = false; if (s->play.fd != -1) { if ((s->play.buf = calloc(s->bufframes, s->play.frame_size)) == NULL) { ret = CUBEB_ERROR; goto error; } } if (s->record.fd != -1) { if ((s->record.buf = calloc(s->bufframes, s->record.frame_size)) == NULL) { ret = CUBEB_ERROR; goto error; } } *stream = s; return CUBEB_OK; error: if (s != NULL) { oss_stream_destroy(s); } return ret; } static int oss_stream_thr_create(cubeb_stream * s) { if (s->thread_created) { s->doorbell = true; pthread_cond_signal(&s->doorbell_cv); return CUBEB_OK; } if (pthread_create(&s->thread, NULL, oss_io_routine, s) != 0) { LOG("Couldn't create thread"); return CUBEB_ERROR; } return CUBEB_OK; } static int oss_stream_start(cubeb_stream * s) { s->state_cb(s, s->user_ptr, CUBEB_STATE_STARTED); pthread_mutex_lock(&s->mtx); /* Disallow starting an already started stream */ assert(!s->running && s->state != CUBEB_STATE_STARTED); if (oss_stream_thr_create(s) != CUBEB_OK) { pthread_mutex_unlock(&s->mtx); s->state_cb(s, s->user_ptr, CUBEB_STATE_ERROR); return CUBEB_ERROR; } s->state = CUBEB_STATE_STARTED; s->thread_created = true; s->running = true; pthread_mutex_unlock(&s->mtx); return CUBEB_OK; } static int oss_stream_get_position(cubeb_stream * s, uint64_t * position) { pthread_mutex_lock(&s->mtx); *position = s->frames_written; pthread_mutex_unlock(&s->mtx); return CUBEB_OK; } static int oss_stream_get_latency(cubeb_stream * s, uint32_t * latency) { int delay; if (ioctl(s->play.fd, SNDCTL_DSP_GETODELAY, &delay) == -1) { return CUBEB_ERROR; } /* Return number of frames there */ *latency = delay / s->play.frame_size; return CUBEB_OK; } static int oss_stream_set_volume(cubeb_stream * stream, float volume) { if (volume < 0.0) volume = 0.0; else if (volume > 1.0) volume = 1.0; pthread_mutex_lock(&stream->mtx); stream->volume = volume; pthread_mutex_unlock(&stream->mtx); return CUBEB_OK; } static int oss_get_current_device(cubeb_stream * stream, cubeb_device ** const device) { *device = calloc(1, sizeof(cubeb_device)); if (*device == NULL) { return CUBEB_ERROR; } (*device)->input_name = stream->record.fd != -1 ? strdup(stream->record.name) : NULL; (*device)->output_name = stream->play.fd != -1 ? strdup(stream->play.name) : NULL; return CUBEB_OK; } static int oss_stream_device_destroy(cubeb_stream * stream, cubeb_device * device) { (void)stream; free(device->input_name); free(device->output_name); free(device); return CUBEB_OK; } static struct cubeb_ops const oss_ops = { .init = oss_init, .get_backend_id = oss_get_backend_id, .get_max_channel_count = oss_get_max_channel_count, .get_min_latency = oss_get_min_latency, .get_preferred_sample_rate = oss_get_preferred_sample_rate, .enumerate_devices = oss_enumerate_devices, .device_collection_destroy = oss_device_collection_destroy, .destroy = oss_destroy, .stream_init = oss_stream_init, .stream_destroy = oss_stream_destroy, .stream_start = oss_stream_start, .stream_stop = oss_stream_stop, .stream_reset_default_device = NULL, .stream_get_position = oss_stream_get_position, .stream_get_latency = oss_stream_get_latency, .stream_get_input_latency = NULL, .stream_set_volume = oss_stream_set_volume, .stream_set_name = NULL, .stream_get_current_device = oss_get_current_device, .stream_device_destroy = oss_stream_device_destroy, .stream_register_device_changed_callback = NULL, .register_device_collection_changed = NULL};