From 85a4c0a1e0f666505cf2a2922c12e78b3c83c062 Mon Sep 17 00:00:00 2001 From: fulup Date: Mon, 3 Jul 2017 15:38:35 +0200 Subject: Moved to V2 --- HAL-afb/HAL-interface/hal-interface.c | 54 ++-- HAL-afb/HAL-plugin/CMakeLists.txt | 41 +++ HAL-afb/HAL-plugin/HalPlugCtl.c | 267 +++++++++++++++++ HAL-afb/HAL-plugin/HalPlugPcm.c | 430 ++++++++++++++++++++++++++++ HAL-afb/Scarlett-Focusrite/ScarlettUsbHAL.c | 12 +- 5 files changed, 774 insertions(+), 30 deletions(-) create mode 100644 HAL-afb/HAL-plugin/CMakeLists.txt create mode 100644 HAL-afb/HAL-plugin/HalPlugCtl.c create mode 100644 HAL-afb/HAL-plugin/HalPlugPcm.c (limited to 'HAL-afb') diff --git a/HAL-afb/HAL-interface/hal-interface.c b/HAL-afb/HAL-interface/hal-interface.c index 29c5e88..035278b 100644 --- a/HAL-afb/HAL-interface/hal-interface.c +++ b/HAL-afb/HAL-interface/hal-interface.c @@ -222,13 +222,13 @@ OnExit: // This receive all event this binding subscribe to PUBLIC void halServiceEvent(const char *evtname, struct json_object *object) { - AFB_NOTICE("afbBindingV1ServiceEvent evtname=%s [msg=%s]", evtname, json_object_to_json_string(object)); + AFB_NOTICE("afbBindingV1ServiceEvent evtname=%s [msg=%s]", evtname, json_object_get_string(object)); } // this is call when after all bindings are loaded PUBLIC int halServiceInit (const char *apiPrefix, alsaHalSndCardT *alsaHalSndCard) { int ok, err; - struct json_object *queryurl, *responseJ, *devidJ, *tmpJ; + struct json_object *queryurl, *responseJ, *devidJ, *ctlsJ, *tmpJ; halCtls = alsaHalSndCard->ctls; // Get sndcard specific HAL control mapping err= afb_daemon_require_api("alsacore", 1); @@ -245,38 +245,44 @@ PUBLIC int halServiceInit (const char *apiPrefix, alsaHalSndCardT *alsaHalSndCar ok= afb_service_call_sync ("alsacore", "registerHal", queryurl, &responseJ); json_object_put(queryurl); if (!ok) { - NOTICE ("Fail to register HAL to ALSA lowlevel binding Response=[%s]", json_object_to_json_string(responseJ)); + NOTICE ("Fail to register HAL to ALSA lowlevel binding Response=[%s]", json_object_get_string(responseJ)); goto OnErrorExit; } // extract sound devid from HAL registration if (!json_object_object_get_ex(responseJ, "response", &tmpJ) || !json_object_object_get_ex(tmpJ, "devid", &devidJ)) { - AFB_ERROR ("Ooops: Internal error no devid return from HAL registration Response=[%s]", json_object_to_json_string(responseJ)); + AFB_ERROR ("Ooops: Internal error no devid return from HAL registration Response=[%s]", json_object_get_string(responseJ)); goto OnErrorExit; } + + // for each Non Alsa Control callback create a custom control + ctlsJ= json_object_new_array(); for (int idx = 0; halCtls[idx].alsa.numid != 0; idx++) { - if (halCtls[idx].cb.callback != NULL) { - queryurl = json_object_new_object(); - json_object_object_add(queryurl, "devid",devidJ); - tmpJ = json_object_new_object(); - if (halCtls[idx].alsa.name) json_object_object_add(tmpJ, "name" , json_object_new_string(halCtls[idx].alsa.name)); - if (halCtls[idx].alsa.numid) json_object_object_add(tmpJ, "numid" , json_object_new_int(halCtls[idx].alsa.numid)); - if (halCtls[idx].alsa.minval) json_object_object_add(tmpJ, "minval", json_object_new_int(halCtls[idx].alsa.minval)); - if (halCtls[idx].alsa.maxval) json_object_object_add(tmpJ, "maxval", json_object_new_int(halCtls[idx].alsa.maxval)); - if (halCtls[idx].alsa.step) json_object_object_add(tmpJ, "step" , json_object_new_int(halCtls[idx].alsa.step)); - if (halCtls[idx].alsa.type) json_object_object_add(tmpJ, "type" , json_object_new_int(halCtls[idx].alsa.type)); - json_object_object_add(queryurl, "ctls",tmpJ); - - AFB_NOTICE("QUERY=%s", json_object_to_json_string(queryurl)); - - ok= afb_service_call_sync ("alsacore", "addcustomctl", queryurl, &responseJ); - if (!ok) { - AFB_ERROR ("Fail to add Customer Sound Control for ctrl=[%s] Response=[%s]", halCtls[idx].alsa.name, json_object_to_json_string(responseJ)); - goto OnErrorExit; - } - } + struct json_object *ctlJ; + if (halCtls[idx].alsa.numid != 0 || halCtls[idx].cb.callback != NULL) { + ctlJ = json_object_new_object(); + if (halCtls[idx].alsa.name) json_object_object_add(ctlJ, "name" , json_object_new_string(halCtls[idx].alsa.name)); + if (halCtls[idx].alsa.numid) json_object_object_add(ctlJ, "numid" , json_object_new_int(halCtls[idx].alsa.numid)); + if (halCtls[idx].alsa.minval) json_object_object_add(ctlJ, "minval", json_object_new_int(halCtls[idx].alsa.minval)); + if (halCtls[idx].alsa.maxval) json_object_object_add(ctlJ, "maxval", json_object_new_int(halCtls[idx].alsa.maxval)); + if (halCtls[idx].alsa.step) json_object_object_add(ctlJ, "step" , json_object_new_int(halCtls[idx].alsa.step)); + if (halCtls[idx].alsa.type) json_object_object_add(ctlJ, "type" , json_object_new_int(halCtls[idx].alsa.type)); + json_object_array_add(ctlsJ, ctlJ); + } + } + + // Build new queryJ to add HAL custom control if any + if (json_object_array_length (ctlsJ) > 0) { + queryurl = json_object_new_object(); + json_object_object_add(queryurl, "devid",devidJ); + json_object_object_add(queryurl, "ctls",ctlsJ); + ok= afb_service_call_sync ("alsacore", "addcustomctl", queryurl, &responseJ); + if (!ok) { + AFB_ERROR ("Fail creating HAL Custom ALSA ctls Response=[%s]", json_object_get_string(responseJ)); + goto OnErrorExit; + } } // finally register for alsa lowlevel event diff --git a/HAL-afb/HAL-plugin/CMakeLists.txt b/HAL-afb/HAL-plugin/CMakeLists.txt new file mode 100644 index 0000000..73390b8 --- /dev/null +++ b/HAL-afb/HAL-plugin/CMakeLists.txt @@ -0,0 +1,41 @@ +########################################################################### +# Copyright 2015, 2016, 2017 IoT.bzh +# +# author: Fulup Ar Foll +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +########################################################################### + + +# Add target to project dependency list +PROJECT_TARGET_ADD(hal-ctl-plugin) + + # Define targets + ADD_LIBRARY(hal-ctl-plugin MODULE HalPlugCtl.c) + + # Alsa Plugin properties + SET_TARGET_PROPERTIES(hal-ctl-plugin PROPERTIES + PREFIX "alsa-" + OUTPUT_NAME ${TARGET_NAME} + ) + +PROJECT_TARGET_ADD(hal-pcm-plugin) + + # Define targets + ADD_LIBRARY(hal-pcm-plugin MODULE HalPlugPcm.c) + + # Alsa Plugin properties + SET_TARGET_PROPERTIES(hal-pcm-plugin PROPERTIES + PREFIX "alsa-" + OUTPUT_NAME ${TARGET_NAME} + ) diff --git a/HAL-afb/HAL-plugin/HalPlugCtl.c b/HAL-afb/HAL-plugin/HalPlugCtl.c new file mode 100644 index 0000000..21e7cfc --- /dev/null +++ b/HAL-afb/HAL-plugin/HalPlugCtl.c @@ -0,0 +1,267 @@ +/* + * Copyright (C) 2016 "IoT.bzh" + * Author Fulup Ar Foll + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + + +#include +#include +#include +#include +#include + +typedef struct afbHalPlug { + snd_ctl_ext_t ext; + char *device; + unsigned int num_vol_ctls; + unsigned int num_rec_items; + unsigned int vol_ctl[SOUND_MIXER_NRDEVICES]; + unsigned int rec_item[SOUND_MIXER_NRDEVICES]; +} afbHalPlug_t; + +static const char *const vol_devices[SOUND_MIXER_NRDEVICES] = { + [SOUND_MIXER_VOLUME] = "Master Playback Volume", + [SOUND_MIXER_BASS] = "Tone Control - Bass", + [SOUND_MIXER_TREBLE] = "Tone Control - Treble", + [SOUND_MIXER_SYNTH] = "Synth Playback Volume", + [SOUND_MIXER_PCM] = "PCM Playback Volume", + [SOUND_MIXER_SPEAKER] = "PC Speaker Playback Volume", + [SOUND_MIXER_LINE] = "Line Playback Volume", + [SOUND_MIXER_MIC] = "Mic Playback Volume", + [SOUND_MIXER_CD] = "CD Playback Volume", + [SOUND_MIXER_IMIX] = "Monitor Mix Playback Volume", + [SOUND_MIXER_ALTPCM] = "Headphone Playback Volume", + [SOUND_MIXER_RECLEV] = "Capture Volume", + [SOUND_MIXER_IGAIN] = "Capture Volume", + [SOUND_MIXER_OGAIN] = "Playback Volume", + [SOUND_MIXER_LINE1] = "Aux Playback Volume", + [SOUND_MIXER_LINE2] = "Aux1 Playback Volume", + [SOUND_MIXER_LINE3] = "Line1 Playback Volume", + [SOUND_MIXER_DIGITAL1] = "IEC958 Playback Volume", + [SOUND_MIXER_DIGITAL2] = "Digital Playback Volume", + [SOUND_MIXER_DIGITAL3] = "Digital1 Playback Volume", + [SOUND_MIXER_PHONEIN] = "Phone Playback Volume", + [SOUND_MIXER_PHONEOUT] = "Master Mono Playback Volume", + [SOUND_MIXER_VIDEO] = "Video Playback Volume", + [SOUND_MIXER_RADIO] = "Radio Playback Volume", + [SOUND_MIXER_MONITOR] = "Monitor Playback Volume", +}; + +static const char *const rec_devices[SOUND_MIXER_NRDEVICES] = { + [SOUND_MIXER_VOLUME] = "Mix Capture Switch", + [SOUND_MIXER_SYNTH] = "Synth Capture Switch", + [SOUND_MIXER_PCM] = "PCM Capture Switch", + [SOUND_MIXER_LINE] = "Line Capture Switch", + [SOUND_MIXER_MIC] = "Mic Capture Switch", + [SOUND_MIXER_CD] = "CD Capture Switch", + [SOUND_MIXER_LINE1] = "Aux Capture Switch", + [SOUND_MIXER_LINE2] = "Aux1 Capture Switch", + [SOUND_MIXER_LINE3] = "Line1 Capture Switch", + [SOUND_MIXER_DIGITAL1] = "IEC958 Capture Switch", + [SOUND_MIXER_DIGITAL2] = "Digital Capture Switch", + [SOUND_MIXER_DIGITAL3] = "Digital1 Capture Switch", + [SOUND_MIXER_PHONEIN] = "Phone Capture Switch", + [SOUND_MIXER_VIDEO] = "Video Capture Switch", + [SOUND_MIXER_RADIO] = "Radio Capture Switch", +}; + +static const char *const rec_items[SOUND_MIXER_NRDEVICES] = { + [SOUND_MIXER_VOLUME] = "Mix", + [SOUND_MIXER_SYNTH] = "Synth", + [SOUND_MIXER_PCM] = "PCM", + [SOUND_MIXER_LINE] = "Line", + [SOUND_MIXER_MIC] = "Mic", + [SOUND_MIXER_CD] = "CD", + [SOUND_MIXER_LINE1] = "Aux", + [SOUND_MIXER_LINE2] = "Aux1", + [SOUND_MIXER_LINE3] = "Line1", + [SOUND_MIXER_DIGITAL1] = "IEC958", + [SOUND_MIXER_DIGITAL2] = "Digital", + [SOUND_MIXER_DIGITAL3] = "Digital1", + [SOUND_MIXER_PHONEIN] = "Phone", + [SOUND_MIXER_VIDEO] = "Video", + [SOUND_MIXER_RADIO] = "Radio", +}; + + + + +static snd_ctl_ext_key_t AfbHalElemFind(snd_ctl_ext_t *ext, + const snd_ctl_elem_id_t *id) { + + snd_ctl_hal_t *ctlHal = ext->private_data; + const char *name; + unsigned int i, key, numid; + + numid = snd_ctl_elem_id_get_numid(id); + if (numid > 0) { + numid--; + if (numid < afbHalPlug->num_vol_ctls) + return afbHalPlug->vol_ctl[numid]; + numid -= afbHalPlug->num_vol_ctls; + if (afbHalPlug->exclusive_input) { + if (!numid) + return OSS_KEY_CAPTURE_MUX; + } else if (numid < afbHalPlug->num_rec_items) + return afbHalPlug->rec_item[numid] | + OSS_KEY_CAPTURE_FLAG; + } + + name = snd_ctl_elem_id_get_name(id); + if (! strcmp(name, "Capture Source")) { + if (afbHalPlug->exclusive_input) + return OSS_KEY_CAPTURE_MUX; + else + return SND_CTL_EXT_KEY_NOT_FOUND; + } + for (i = 0; i < afbHalPlug->num_vol_ctls; i++) { + key = afbHalPlug->vol_ctl[i]; + if (! strcmp(name, vol_devices[key])) + return key; + } + for (i = 0; i < afbHalPlug->num_rec_items; i++) { + key = afbHalPlug->rec_item[i]; + if (! strcmp(name, rec_devices[key])) + return key | OSS_KEY_CAPTURE_FLAG; + } + return SND_CTL_EXT_KEY_NOT_FOUND; +} + +static int AfbHalGetAttrib(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key, + int *type, unsigned int *acc, unsigned int *count) { + return 0; +} + +static int AfbHalGetInfo(snd_ctl_ext_t *ext ATTRIBUTE_UNUSED, + snd_ctl_ext_key_t key ATTRIBUTE_UNUSED, + long *imin, long *imax, long *istep) { + + return 0; +} + +static int AfbHalGetEnumInfo(snd_ctl_ext_t *ext, + snd_ctl_ext_key_t key ATTRIBUTE_UNUSED, + unsigned int *items) { + + return 0; +} + +static int AfbHalGetEnumName(snd_ctl_ext_t *ext, + snd_ctl_ext_key_t key ATTRIBUTE_UNUSED, + unsigned int item, char *name, + size_t name_max_len) { + + return 0; +} + +static int AfbHalReadInt(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key, long *value) { + + return 0; +} + +static int AfbHalReadEnumerate(snd_ctl_ext_t *ext, + snd_ctl_ext_key_t key ATTRIBUTE_UNUSED, + unsigned int *items) { + + return 0; +} + +static int AfbHalWriteInt(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key, long *value) { + + return 0; +} + +static int AfbHalWriteEnum(snd_ctl_ext_t *ext, + snd_ctl_ext_key_t key ATTRIBUTE_UNUSED, + unsigned int *items) { + + return 0; +} + +static int AfbHalEventRead(snd_ctl_ext_t *ext ATTRIBUTE_UNUSED, + snd_ctl_elem_id_t *id ATTRIBUTE_UNUSED, + unsigned int *event_mask ATTRIBUTE_UNUSED) +{ + return -EAGAIN; +} + +static snd_ctl_ext_callback_t afbHalCBs = { + .close = AfbHalClose, + .elem_count = AfbHalElemCount, + .elem_list = AfbHalElemList, + .find_elem = AfbHalElemFind, + .get_attribute = AfbHalGetAttrib, + .get_integer_info = AfbHalGetInfo, + .get_enumerated_info = AfbHalGetEnumInfo, + .get_enumerated_name = AfbHalGetEnumName, + .read_integer = AfbHalReadInt, + .read_enumerated = AfbHalReadEnumerate, + .write_integer = AfbHalWriteInt, + .write_enumerated = AfbHalWriteEnum, + .read_event = AfbHalEventRead, +}; + + +SND_CTL_PLUGIN_DEFINE_FUNC(afb_hal) { + + snd_config_iterator_t it, next; + afbHalPlug_t *afbHalPlug; + int err; + + snd_config_for_each(it, next, conf) { + snd_config_t *n = snd_config_iterator_entry(it); + const char *id; + if (snd_config_get_id(n, &id) < 0) + continue; + if (strcmp(id, "comment") == 0 || strcmp(id, "type") == 0 || strcmp(id, "hint") == 0) + continue; + if (strcmp(id, "slave") == 0) { + if (snd_config_get_string(n, &device) < 0) { + SNDERR("Invalid type for %s", id); + return -EINVAL; + } + continue; + } + SNDERR("Unknown field %s", id); + return -EINVAL; + } + + // Create ALSA control plugin structure + afbHalPlug->ext.version = SND_CTL_EXT_VERSION; + afbHalPlug->ext.card_idx = 0; /* FIXME */ + strcpy(afbHalPlug->ext.id, "AFB-HAL-CTL"); + strcpy(afbHalPlug->ext.driver, "AFB-HAL"); + strcpy(afbHalPlug->ext.name, "AFB-HAL Control Plugin"); + strcpy(afbHalPlug->ext.mixername, "AFB-HAL Mixer Plugin"); + strcpy(afbHalPlug->ext.longname, "Automotive-Linux Sound Abstraction Control Plugin"); + afbHalPlug->ext.poll_fd = -1; + afbHalPlug->ext.callback = &afbHalCBs; + afbHalPlug->ext.private_data = afbHalPlug; + + + err = snd_ctl_ext_create(&afbHalPlug->ext, name, mode); + if (err < 0) goto OnErrorExit; + + // Plugin register controls update handlep before exiting + *handlep = afbHalPlug->ext.handle; + return 0; + +OnErrorExit: + free(afbHalPlug); + return -1; +} + +SND_CTL_PLUGIN_SYMBOL(afb_hal); diff --git a/HAL-afb/HAL-plugin/HalPlugPcm.c b/HAL-afb/HAL-plugin/HalPlugPcm.c new file mode 100644 index 0000000..d43b44c --- /dev/null +++ b/HAL-afb/HAL-plugin/HalPlugPcm.c @@ -0,0 +1,430 @@ +/* + * ALSA <-> OSS PCM I/O plugin + * + * Copyright (c) 2005 by Takashi Iwai + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include +#include +#include +#include +#include + +typedef struct snd_pcm_oss { + snd_pcm_ioplug_t io; + char *device; + int fd; + int fragment_set; + int caps; + int format; + unsigned int period_shift; + unsigned int periods; + unsigned int frame_bytes; +} snd_pcm_oss_t; + +static snd_pcm_sframes_t oss_write(snd_pcm_ioplug_t *io, + const snd_pcm_channel_area_t *areas, + snd_pcm_uframes_t offset, + snd_pcm_uframes_t size) +{ + snd_pcm_oss_t *oss = io->private_data; + const char *buf; + ssize_t result; + + /* we handle only an interleaved buffer */ + buf = (char *)areas->addr + (areas->first + areas->step * offset) / 8; + size *= oss->frame_bytes; + result = write(oss->fd, buf, size); + if (result <= 0) + return result; + return result / oss->frame_bytes; +} + +static snd_pcm_sframes_t oss_read(snd_pcm_ioplug_t *io, + const snd_pcm_channel_area_t *areas, + snd_pcm_uframes_t offset, + snd_pcm_uframes_t size) +{ + snd_pcm_oss_t *oss = io->private_data; + char *buf; + ssize_t result; + + /* we handle only an interleaved buffer */ + buf = (char *)areas->addr + (areas->first + areas->step * offset) / 8; + size *= oss->frame_bytes; + result = read(oss->fd, buf, size); + if (result <= 0) + return result; + return result / oss->frame_bytes; +} + +static snd_pcm_sframes_t oss_pointer(snd_pcm_ioplug_t *io) +{ + snd_pcm_oss_t *oss = io->private_data; + struct count_info info; + int ptr; + + if (ioctl(oss->fd, io->stream == SND_PCM_STREAM_PLAYBACK ? + SNDCTL_DSP_GETOPTR : SNDCTL_DSP_GETIPTR, &info) < 0) { + fprintf(stderr, "*** OSS: oss_pointer error\n"); + return 0; + } + ptr = snd_pcm_bytes_to_frames(io->pcm, info.ptr); + return ptr; +} + +static int oss_start(snd_pcm_ioplug_t *io) +{ + snd_pcm_oss_t *oss = io->private_data; + int tmp = io->stream == SND_PCM_STREAM_PLAYBACK ? + PCM_ENABLE_OUTPUT : PCM_ENABLE_INPUT; + + if (ioctl(oss->fd, SNDCTL_DSP_SETTRIGGER, &tmp) < 0) { + fprintf(stderr, "*** OSS: trigger failed\n"); + if (io->stream == SND_PCM_STREAM_CAPTURE) + /* fake read to trigger */ + read(oss->fd, &tmp, 0); + } + return 0; +} + +static int oss_stop(snd_pcm_ioplug_t *io) +{ + snd_pcm_oss_t *oss = io->private_data; + int tmp = 0; + + ioctl(oss->fd, SNDCTL_DSP_SETTRIGGER, &tmp); + return 0; +} + +static int oss_drain(snd_pcm_ioplug_t *io) +{ + snd_pcm_oss_t *oss = io->private_data; + + if (io->stream == SND_PCM_STREAM_PLAYBACK) + ioctl(oss->fd, SNDCTL_DSP_SYNC); + return 0; +} + +static int oss_prepare(snd_pcm_ioplug_t *io) +{ + snd_pcm_oss_t *oss = io->private_data; + int tmp; + + ioctl(oss->fd, SNDCTL_DSP_RESET); + + tmp = io->channels; + if (ioctl(oss->fd, SNDCTL_DSP_CHANNELS, &tmp) < 0) { + perror("SNDCTL_DSP_CHANNELS"); + return -EINVAL; + } + tmp = oss->format; + if (ioctl(oss->fd, SNDCTL_DSP_SETFMT, &tmp) < 0) { + perror("SNDCTL_DSP_SETFMT"); + return -EINVAL; + } + tmp = io->rate; + if (ioctl(oss->fd, SNDCTL_DSP_SPEED, &tmp) < 0 || + tmp > io->rate * 1.01 || tmp < io->rate * 0.99) { + perror("SNDCTL_DSP_SPEED"); + return -EINVAL; + } + return 0; +} + +static int oss_hw_params(snd_pcm_ioplug_t *io, + snd_pcm_hw_params_t *params ATTRIBUTE_UNUSED) +{ + snd_pcm_oss_t *oss = io->private_data; + int i, tmp, err; + unsigned int period_bytes; + long oflags, flags; + + oss->frame_bytes = (snd_pcm_format_physical_width(io->format) * io->channels) / 8; + switch (io->format) { + case SND_PCM_FORMAT_U8: + oss->format = AFMT_U8; + break; + case SND_PCM_FORMAT_S16_LE: + oss->format = AFMT_S16_LE; + break; + case SND_PCM_FORMAT_S16_BE: + oss->format = AFMT_S16_BE; + break; + default: + fprintf(stderr, "*** OSS: unsupported format %s\n", snd_pcm_format_name(io->format)); + return -EINVAL; + } + period_bytes = io->period_size * oss->frame_bytes; + oss->period_shift = 0; + for (i = 31; i >= 4; i--) { + if (period_bytes & (1U << i)) { + oss->period_shift = i; + break; + } + } + if (! oss->period_shift) { + fprintf(stderr, "*** OSS: invalid period size %d\n", (int)io->period_size); + return -EINVAL; + } + oss->periods = io->buffer_size / io->period_size; + + _retry: + tmp = oss->period_shift | (oss->periods << 16); + if (ioctl(oss->fd, SNDCTL_DSP_SETFRAGMENT, &tmp) < 0) { + if (! oss->fragment_set) { + perror("SNDCTL_DSP_SETFRAGMENT"); + fprintf(stderr, "*** period shift = %d, periods = %d\n", oss->period_shift, oss->periods); + return -EINVAL; + } + /* OSS has no proper way to reinitialize the fragments */ + /* try to reopen the device */ + close(oss->fd); + oss->fd = open(oss->device, io->stream == SND_PCM_STREAM_PLAYBACK ? + O_WRONLY : O_RDONLY); + if (oss->fd < 0) { + err = -errno; + SNDERR("Cannot reopen the device %s", oss->device); + return err; + } + io->poll_fd = oss->fd; + io->poll_events = io->stream == SND_PCM_STREAM_PLAYBACK ? + POLLOUT : POLLIN; + snd_pcm_ioplug_reinit_status(io); + oss->fragment_set = 0; + goto _retry; + } + oss->fragment_set = 1; + + if ((flags = fcntl(oss->fd, F_GETFL)) < 0) { + err = -errno; + perror("F_GETFL"); + } else { + oflags = flags; + if (io->nonblock) + flags |= O_NONBLOCK; + else + flags &= ~O_NONBLOCK; + if (flags != oflags && + fcntl(oss->fd, F_SETFL, flags) < 0) { + err = -errno; + perror("F_SETFL"); + } + } + + return 0; +} + +#define ARRAY_SIZE(ary) (sizeof(ary)/sizeof(ary[0])) + +static int oss_hw_constraint(snd_pcm_oss_t *oss) +{ + snd_pcm_ioplug_t *io = &oss->io; + static const snd_pcm_access_t access_list[] = { + SND_PCM_ACCESS_RW_INTERLEAVED, + SND_PCM_ACCESS_MMAP_INTERLEAVED + }; + unsigned int nformats; + unsigned int format[5]; + unsigned int nchannels; + unsigned int channel[6]; + /* period and buffer bytes must be power of two */ + static const unsigned int bytes_list[] = { + 1U<<8, 1U<<9, 1U<<10, 1U<<11, 1U<<12, 1U<<13, 1U<<14, 1U<<15, + 1U<<16, 1U<<17, 1U<<18, 1U<<19, 1U<<20, 1U<<21, 1U<<22, 1U<<23 + }; + int i, err, tmp; + + /* check trigger */ + oss->caps = 0; + if (ioctl(oss->fd, SNDCTL_DSP_GETCAPS, &oss->caps) >= 0) { + if (! (oss->caps & DSP_CAP_TRIGGER)) + fprintf(stderr, "*** OSS: trigger is not supported!\n"); + } + + /* access type - interleaved only */ + if ((err = snd_pcm_ioplug_set_param_list(io, SND_PCM_IOPLUG_HW_ACCESS, + ARRAY_SIZE(access_list), access_list)) < 0) + return err; + + /* supported formats */ + tmp = 0; + ioctl(oss->fd, SNDCTL_DSP_GETFMTS, &tmp); + nformats = 0; + if (tmp & AFMT_U8) + format[nformats++] = SND_PCM_FORMAT_U8; + if (tmp & AFMT_S16_LE) + format[nformats++] = SND_PCM_FORMAT_S16_LE; + if (tmp & AFMT_S16_BE) + format[nformats++] = SND_PCM_FORMAT_S16_BE; + if (tmp & AFMT_MU_LAW) + format[nformats++] = SND_PCM_FORMAT_MU_LAW; + if (! nformats) + format[nformats++] = SND_PCM_FORMAT_S16; + if ((err = snd_pcm_ioplug_set_param_list(io, SND_PCM_IOPLUG_HW_FORMAT, + nformats, format)) < 0) + return err; + + /* supported channels */ + nchannels = 0; + for (i = 0; i < 6; i++) { + tmp = i + 1; + if (ioctl(oss->fd, SNDCTL_DSP_CHANNELS, &tmp) >= 0) + channel[nchannels++] = tmp; + } + if (! nchannels) /* assume 2ch stereo */ + err = snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_CHANNELS, + 2, 2); + else + err = snd_pcm_ioplug_set_param_list(io, SND_PCM_IOPLUG_HW_CHANNELS, + nchannels, channel); + if (err < 0) + return err; + + /* supported rates */ + /* FIXME: should query? */ + err = snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_RATE, 8000, 480000); + if (err < 0) + return err; + + /* period size (in power of two) */ + err = snd_pcm_ioplug_set_param_list(io, SND_PCM_IOPLUG_HW_PERIOD_BYTES, + ARRAY_SIZE(bytes_list), bytes_list); + if (err < 0) + return err; + /* periods */ + err = snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_PERIODS, 2, 1024); + if (err < 0) + return err; + /* buffer size (in power of two) */ + err = snd_pcm_ioplug_set_param_list(io, SND_PCM_IOPLUG_HW_BUFFER_BYTES, + ARRAY_SIZE(bytes_list), bytes_list); + if (err < 0) + return err; + + return 0; +} + + +static int oss_close(snd_pcm_ioplug_t *io) +{ + snd_pcm_oss_t *oss = io->private_data; + + close(oss->fd); + free(oss->device); + free(oss); + return 0; +} + +static const snd_pcm_ioplug_callback_t oss_playback_callback = { + .start = oss_start, + .stop = oss_stop, + .transfer = oss_write, + .pointer = oss_pointer, + .close = oss_close, + .hw_params = oss_hw_params, + .prepare = oss_prepare, + .drain = oss_drain, +}; + +static const snd_pcm_ioplug_callback_t oss_capture_callback = { + .start = oss_start, + .stop = oss_stop, + .transfer = oss_read, + .pointer = oss_pointer, + .close = oss_close, + .hw_params = oss_hw_params, + .prepare = oss_prepare, + .drain = oss_drain, +}; + + +SND_PCM_PLUGIN_DEFINE_FUNC(oss) +{ + snd_config_iterator_t i, next; + const char *device = "/dev/dsp"; + int err; + snd_pcm_oss_t *oss; + + snd_config_for_each(i, next, conf) { + snd_config_t *n = snd_config_iterator_entry(i); + const char *id; + if (snd_config_get_id(n, &id) < 0) + continue; + if (strcmp(id, "comment") == 0 || strcmp(id, "type") == 0 || strcmp(id, "hint") == 0) + continue; + if (strcmp(id, "device") == 0) { + if (snd_config_get_string(n, &device) < 0) { + SNDERR("Invalid type for %s", id); + return -EINVAL; + } + continue; + } + SNDERR("Unknown field %s", id); + return -EINVAL; + } + + oss = calloc(1, sizeof(*oss)); + if (! oss) { + SNDERR("cannot allocate"); + return -ENOMEM; + } + + oss->device = strdup(device); + if (oss->device == NULL) { + SNDERR("cannot allocate"); + free(oss); + return -ENOMEM; + } + oss->fd = open(device, stream == SND_PCM_STREAM_PLAYBACK ? + O_WRONLY : O_RDONLY); + if (oss->fd < 0) { + err = -errno; + SNDERR("Cannot open device %s", device); + goto error; + } + + oss->io.version = SND_PCM_IOPLUG_VERSION; + oss->io.name = "ALSA <-> OSS PCM I/O Plugin"; + oss->io.poll_fd = oss->fd; + oss->io.poll_events = stream == SND_PCM_STREAM_PLAYBACK ? POLLOUT : POLLIN; + oss->io.mmap_rw = 0; + oss->io.callback = stream == SND_PCM_STREAM_PLAYBACK ? + &oss_playback_callback : &oss_capture_callback; + oss->io.private_data = oss; + + err = snd_pcm_ioplug_create(&oss->io, name, stream, mode); + if (err < 0) + goto error; + + if ((err = oss_hw_constraint(oss)) < 0) { + snd_pcm_ioplug_delete(&oss->io); + return err; + } + + *pcmp = oss->io.pcm; + return 0; + + error: + if (oss->fd >= 0) + close(oss->fd); + free(oss->device); + free(oss); + return err; +} + +SND_PCM_PLUGIN_SYMBOL(oss); diff --git a/HAL-afb/Scarlett-Focusrite/ScarlettUsbHAL.c b/HAL-afb/Scarlett-Focusrite/ScarlettUsbHAL.c index 1ff5320..3b9ee4c 100644 --- a/HAL-afb/Scarlett-Focusrite/ScarlettUsbHAL.c +++ b/HAL-afb/Scarlett-Focusrite/ScarlettUsbHAL.c @@ -18,7 +18,7 @@ * To find out which control your sound card uses * aplay -l # Check sndcard name name in between [] * amixer -D hw:xx controls # get supported controls - * amixer -D "hw:3" cget numid=xx # get control settings + * amixer -D "hw:4" cget numid=xx # get control settings * */ #define _GNU_SOURCE @@ -41,11 +41,11 @@ STATIC struct json_object* MasterOnOff (alsaHalCtlMapT *control, void* handle) { // Map HAL hight sndctl with Alsa numid and optionally with a custom callback for non Alsa supported functionalities. STATIC alsaHalMapT alsaHalMap[]= { - { .alsa={.control=Master_Playback_Volume,.numid=16, .name="Master-Vol" , .values=1,.minval=0,.maxval= 87 ,.step=0}, .info= "Master Playback Volume" }, - { .alsa={.control=PCM_Playback_Volume ,.numid=27, .name="Play-Vol" , .values=2,.minval=0,.maxval= 255,.step=0}, .info= "PCM Playback Volume" }, - { .alsa={.control=PCM_Playback_Switch ,.numid=17, .name="Play-Switch" , .values=1,.minval=0,.maxval= 1 ,.step=0}, .info= "Master Playback Switch" }, - { .alsa={.control=Capture_Volume ,.numid=12, .name="Capt-vol" , .values=2,.minval=0,.maxval= 31 ,.step=0}, .info= "Capture Volume" }, - { .alsa={.control=Master_OnOff_Switch ,.numid=99, .name="Power-Switch"}, .cb={.callback=MasterOnOff, .handle=NULL}, .info= "OnOff Global Switch"}, + { .alsa={.control=Master_Playback_Volume,.numid=04, .name="Matrix 03 Mix A Playback Volume" , .values=1,.minval=0,.maxval= 87 ,.step=0}, .info= "Master Playback Volume" }, + { .alsa={.control=PCM_Playback_Volume ,.numid=06, .name="play-vol" , .values=2,.minval=0,.maxval= 255,.step=0}, .info= "PCM Playback Volume" }, + { .alsa={.control=PCM_Playback_Switch ,.numid=05, .name="play-switch" , .values=1,.minval=0,.maxval= 1 ,.step=0}, .info= "Master Playback Switch" }, + { .alsa={.control=Capture_Volume ,.numid=12, .name="capt-vol" , .values=2,.minval=0,.maxval= 31 ,.step=0}, .info= "Capture Volume" }, + { .alsa={.control=Master_OnOff_Switch, .name="Power-Switch"}, .cb={.callback=MasterOnOff, .handle=NULL}, .info= "OnOff Global Switch"}, { .alsa={.numid=0}, .cb={.callback=NULL, .handle=NULL}} /* marker for end of the array */ } ; -- cgit 1.2.3-korg