/* * AlsaUseCase -- provide low level interface with ALSA lib (extracted from alsa-json-gateway code) * Copyright (C) 2015,2016,2017, Fulup Ar Foll fulup@iot.bzh * * 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. * * References: * https://kernel.readthedocs.io/en/sphinx-samples/writing-an-alsa-driver.html#control-names * https://01.org/linuxgraphics/gfx-docs/drm/sound/designs/control-names.html */ #define _GNU_SOURCE // needed for vasprintf #include #include #include "Alsa-ApiHat.h" #include typedef struct _snd_ctl_ops { int (*close)(snd_ctl_t *handle); int (*nonblock)(snd_ctl_t *handle, int nonblock); int (*async)(snd_ctl_t *handle, int sig, pid_t pid); int (*subscribe_events)(snd_ctl_t *handle, int subscribe); int (*card_info)(snd_ctl_t *handle, snd_ctl_card_info_t *info); int (*element_list)(snd_ctl_t *handle, snd_ctl_elem_list_t *list); int (*element_info)(snd_ctl_t *handle, snd_ctl_elem_info_t *info); int (*element_add)(snd_ctl_t *handle, snd_ctl_elem_info_t *info); int (*element_replace)(snd_ctl_t *handle, snd_ctl_elem_info_t *info); int (*element_remove)(snd_ctl_t *handle, snd_ctl_elem_id_t *id); int (*element_read)(snd_ctl_t *handle, snd_ctl_elem_value_t *control); int (*element_write)(snd_ctl_t *handle, snd_ctl_elem_value_t *control); int (*element_lock)(snd_ctl_t *handle, snd_ctl_elem_id_t *lock); int (*element_unlock)(snd_ctl_t *handle, snd_ctl_elem_id_t *unlock); int (*element_tlv)(snd_ctl_t *handle, int op_flag, unsigned int numid, unsigned int *tlv, unsigned int tlv_size); int (*hwdep_next_device)(snd_ctl_t *handle, int *device); int (*hwdep_info)(snd_ctl_t *handle, snd_hwdep_info_t * info); int (*pcm_next_device)(snd_ctl_t *handle, int *device); int (*pcm_info)(snd_ctl_t *handle, snd_pcm_info_t * info); int (*pcm_prefer_subdevice)(snd_ctl_t *handle, int subdev); int (*rawmidi_next_device)(snd_ctl_t *handle, int *device); int (*rawmidi_info)(snd_ctl_t *handle, snd_rawmidi_info_t * info); int (*rawmidi_prefer_subdevice)(snd_ctl_t *handle, int subdev); int (*set_power_state)(snd_ctl_t *handle, unsigned int state); int (*get_power_state)(snd_ctl_t *handle, unsigned int *state); int (*read)(snd_ctl_t *handle, snd_ctl_event_t *event); int (*poll_descriptors_count)(snd_ctl_t *handle); int (*poll_descriptors)(snd_ctl_t *handle, struct pollfd *pfds, unsigned int space); int (*poll_revents)(snd_ctl_t *handle, struct pollfd *pfds, unsigned int nfds, unsigned short *revents); } snd_ctl_ops_t; typedef struct private_snd_ctl { void *open_func; char *name; snd_ctl_type_t type; const snd_ctl_ops_t *ops; void *private_data; int nonblock; int poll_fd; void *async_handlers; } private_snd_ctl_t; typedef struct { int card; int fd; unsigned int protocol; } snd_ctl_hw_t; static int snd_ctl_hw_elem_replace(snd_ctl_t *ctlDev, snd_ctl_elem_info_t *info, snd_ctl_elem_id_t *elemId) { size_t len=snd_ctl_elem_info_sizeof(); private_snd_ctl_t *handle= (private_snd_ctl_t*) ctlDev; snd_ctl_hw_t *hw = handle->private_data; NOTICE ("count=%d ITEMNAME=%s writable=%d owner=%d", snd_ctl_elem_info_get_count(info), snd_ctl_elem_info_get_name(info) , snd_ctl_elem_info_is_writable(info), snd_ctl_elem_info_get_owner(info)); snd_ctl_elem_lock(ctlDev, elemId); int err= handle->ops->element_replace (ctlDev, info); NOTICE ("count=%d ITEMNAME=%s writable=%d isowner=%d islocked=%d innactiv=%d", snd_ctl_elem_info_get_count(info), snd_ctl_elem_info_get_name(info) , snd_ctl_elem_info_is_writable(info), snd_ctl_elem_info_is_owner(info), snd_ctl_elem_info_is_locked(info), snd_ctl_elem_info_is_inactive(info)); return err; } STATIC int addOneSndCtl(afb_req request, snd_ctl_t *ctlDev, json_object *ctlJ) { int err, ctlExist; json_object *jTmp; const char *ctlName; int ctlNumid, ctlMax, ctlMin, ctlStep, ctlCount, ctlSubDev, ctlSndDev; snd_ctl_elem_type_t ctlType; snd_ctl_elem_id_t *elemId; snd_ctl_elem_info_t *elemInfo; snd_ctl_elem_value_t *elemValue; // parse json ctl object json_object_object_get_ex (ctlJ, "name" , &jTmp); if (!jTmp) { afb_req_fail_f (request, "ctl-invalid", "crl=%s name missing", json_object_get_string(ctlJ)); goto OnErrorExit; } ctlName = json_object_get_string(jTmp); // default value when not present => 0 json_object_object_get_ex (ctlJ, "numid" , &jTmp); ctlNumid = json_object_get_int(jTmp); // default for json_object_get_int is zero json_object_object_get_ex (ctlJ, "min" , &jTmp); ctlMin = json_object_get_int(jTmp); json_object_object_get_ex (ctlJ, "max" , &jTmp); if (!jTmp) ctlMax=1; else ctlMax = json_object_get_int(jTmp); json_object_object_get_ex (ctlJ, "step" , &jTmp); if (!jTmp) ctlStep=1; else ctlStep = json_object_get_int(jTmp); json_object_object_get_ex (ctlJ, "count" , &jTmp); if (!jTmp) ctlCount=2; else ctlCount = json_object_get_int(jTmp); json_object_object_get_ex (ctlJ, "snddev" , &jTmp); ctlSndDev = json_object_get_int(jTmp); json_object_object_get_ex (ctlJ, "subdev" , &jTmp); ctlSubDev = json_object_get_int(jTmp); json_object_object_get_ex (ctlJ, "type" , &jTmp); if (!jTmp) ctlType=SND_CTL_ELEM_TYPE_BOOLEAN; else ctlType = json_object_get_int(jTmp); // Add requested ID into elemInfo snd_ctl_elem_info_alloca(&elemInfo); snd_ctl_elem_id_alloca(&elemId); snd_ctl_elem_id_set_numid (elemId, ctlNumid); snd_ctl_elem_id_set_name (elemId, ctlName); snd_ctl_elem_id_set_interface(elemId, SND_CTL_ELEM_IFACE_HWDEP); snd_ctl_elem_id_set_device(elemId, ctlSndDev); snd_ctl_elem_id_set_subdevice(elemId, ctlSubDev); // Assert that this ctls is not used snd_ctl_elem_info_set_id (elemInfo, elemId); ctlExist= !snd_ctl_elem_info(ctlDev, elemInfo); if (ctlExist) { NOTICE ("1:ctl exist ctlName=%s NUMID=%d NAME=%s", ctlName, snd_ctl_elem_info_get_numid(elemInfo), snd_ctl_elem_info_get_name(elemInfo)); snd_ctl_elem_id_set_name (elemId, ctlName); snd_ctl_elem_info_set_name (elemInfo, ctlName); err= snd_ctl_hw_elem_replace (ctlDev, elemInfo, elemId); if (err) { NOTICE ("Fail changing ctlname error=%s", snd_strerror(err)); } NOTICE ("2:ctl exist ctlName=%s NUMID=%d NAME=%s", ctlName, snd_ctl_elem_info_get_numid(elemInfo), snd_ctl_elem_info_get_name(elemInfo)); } // try to normalise ctl name snd_ctl_elem_value_alloca(&elemValue); snd_ctl_elem_id_set_name (elemId, ctlName); snd_ctl_elem_value_set_id(elemValue, elemId); if (!ctlExist) switch (ctlType) { case SND_CTL_ELEM_TYPE_BOOLEAN: err = snd_ctl_add_boolean_elem_set(ctlDev, elemInfo, 1, ctlCount); if (err) { afb_req_fail_f (request, "ctl-invalid-bool", "devid=%s crl=%s invalid boolean data", snd_ctl_name(ctlDev), json_object_get_string(ctlJ)); goto OnErrorExit; } // Provide FALSE as default value for (int idx=0; idx < ctlCount; idx ++) { snd_ctl_elem_value_set_boolean (elemValue, idx, 0); } break; case SND_CTL_ELEM_TYPE_INTEGER: break; case SND_CTL_ELEM_TYPE_INTEGER64: break; case SND_CTL_ELEM_TYPE_ENUMERATED: break; case SND_CTL_ELEM_TYPE_BYTES: break; default: afb_req_fail_f (request, "ctl-invalid-type", "crl=%s invalid/unknown type", json_object_get_string(ctlJ)); goto OnErrorExit; } err = snd_ctl_elem_write (ctlDev, elemValue); if (err < 0) { afb_req_fail_f (request, "ctl-write-fail", "crl=%s fail to write data data", json_object_get_string(ctlJ)); goto OnErrorExit; } return 0; OnErrorExit: return -1; } PUBLIC void alsaAddCustomCtls(afb_req request) { int err; json_object *ctlsJ; enum json_type; snd_ctl_t *ctlDev=NULL; const char *devid; devid = afb_req_value(request, "devid"); if (devid == NULL) { afb_req_fail_f (request, "devid-missing", "devid MUST be defined for alsaAddCustomCtls"); goto OnErrorExit; } // open control interface for devid err = snd_ctl_open(&ctlDev, devid, 0); if (err < 0) { afb_req_fail_f (request, "devid-unknown", "SndCard devid=[%s] Not Found err=%s", devid, snd_strerror(err)); goto OnErrorExit; } // extract sound controls and parse json ctlsJ = json_tokener_parse (afb_req_value(request, "ctls")); if (!ctlsJ) { afb_req_fail_f (request, "ctls-missing", "ctls MUST be defined as a JSON array for alsaAddCustomCtls"); goto OnErrorExit; } switch (json_object_get_type(ctlsJ)) { case json_type_object: addOneSndCtl(request, ctlDev, ctlsJ); break; case json_type_array: for (int idx= 0; idx < json_object_array_length (ctlsJ); idx++) { json_object *ctlJ = json_object_array_get_idx (ctlsJ, idx); addOneSndCtl(request, ctlDev, ctlJ) ; } break; default: afb_req_fail_f (request, "ctls-invalid","ctls=%s not valid JSON array", json_object_get_string(ctlsJ)); goto OnErrorExit; } OnErrorExit: if (ctlDev) snd_ctl_close(ctlDev); return; }