Initial Commit4
This commit is contained in:
MandySingh3
41
libshims/Android.mk
Normal file
41
libshims/Android.mk
Normal file
@@ -0,0 +1,41 @@
|
||||
#
|
||||
# Copyright (C) 2016 The CyanogenMod Project
|
||||
# Copyright (C) 2017 The LineageOS Project
|
||||
#
|
||||
# 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.
|
||||
|
||||
LOCAL_PATH := $(call my-dir)
|
||||
|
||||
# ADSP
|
||||
include $(CLEAR_VARS)
|
||||
LOCAL_C_INCLUDES := external/tinyalsa/include
|
||||
LOCAL_SRC_FILES := mixer.c
|
||||
LOCAL_MODULE := libshim_adsp
|
||||
LOCAL_MODULE_TAGS := optional
|
||||
include $(BUILD_SHARED_LIBRARY)
|
||||
|
||||
# Camera
|
||||
include $(CLEAR_VARS)
|
||||
LOCAL_SRC_FILES := GraphicBuffer.cpp
|
||||
LOCAL_SHARED_LIBRARIES := libui
|
||||
LOCAL_MODULE := libshim_camera
|
||||
LOCAL_MODULE_TAGS := optional
|
||||
include $(BUILD_SHARED_LIBRARY)
|
||||
|
||||
# IMS
|
||||
include $(CLEAR_VARS)
|
||||
LOCAL_SRC_FILES := MediaBuffer.c
|
||||
LOCAL_SHARED_LIBRARIES := libstagefright_foundation
|
||||
LOCAL_MODULE := libshim_ims
|
||||
LOCAL_MODULE_TAGS := optional
|
||||
include $(BUILD_SHARED_LIBRARY)
|
||||
31
libshims/GraphicBuffer.cpp
Normal file
31
libshims/GraphicBuffer.cpp
Normal file
@@ -0,0 +1,31 @@
|
||||
/*
|
||||
* Copyright (C) 2016 The CyanogenMod Project
|
||||
*
|
||||
* 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 <string>
|
||||
|
||||
// GraphicBuffer(uint32_t inWidth, uint32_t inHeight, PixelFormat inFormat,
|
||||
// uint32_t inUsage, std::string requestorName = "<Unknown>");
|
||||
extern "C" void _ZN7android13GraphicBufferC1EjjijNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE(
|
||||
uint32_t inWidth, uint32_t inHeight, int inFormat, uint32_t inUsage,
|
||||
std::string requestorName);
|
||||
|
||||
//libmot_gpu_mapper.so
|
||||
extern "C" void _ZN7android13GraphicBufferC1Ejjij(
|
||||
uint32_t inWidth, uint32_t inHeight, int inFormat, uint32_t inUsage) {
|
||||
std::string requestorName = "<Unknown>";
|
||||
_ZN7android13GraphicBufferC1EjjijNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE(
|
||||
inWidth, inHeight, inFormat, inUsage, requestorName);
|
||||
}
|
||||
19
libshims/MediaBuffer.c
Normal file
19
libshims/MediaBuffer.c
Normal file
@@ -0,0 +1,19 @@
|
||||
/*
|
||||
* Copyright (C) 2016 The CyanogenMod Project
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/* TODO: Actually provide implementations for these function! */
|
||||
|
||||
void _ZNK7android11MediaBuffer8refcountEv() {}
|
||||
620
libshims/mixer.c
Normal file
620
libshims/mixer.c
Normal file
@@ -0,0 +1,620 @@
|
||||
/* mixer.c
|
||||
**
|
||||
** Copyright 2011, The Android Open Source Project
|
||||
**
|
||||
** Redistribution and use in source and binary forms, with or without
|
||||
** modification, are permitted provided that the following conditions are met:
|
||||
** * Redistributions of source code must retain the above copyright
|
||||
** notice, this list of conditions and the following disclaimer.
|
||||
** * Redistributions in binary form must reproduce the above copyright
|
||||
** notice, this list of conditions and the following disclaimer in the
|
||||
** documentation and/or other materials provided with the distribution.
|
||||
** * Neither the name of The Android Open Source Project nor the names of
|
||||
** its contributors may be used to endorse or promote products derived
|
||||
** from this software without specific prior written permission.
|
||||
**
|
||||
** THIS SOFTWARE IS PROVIDED BY The Android Open Source Project ``AS IS'' AND
|
||||
** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
** ARE DISCLAIMED. IN NO EVENT SHALL The Android Open Source Project BE LIABLE
|
||||
** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
** CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
|
||||
** DAMAGE.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <fcntl.h>
|
||||
#include <errno.h>
|
||||
#include <ctype.h>
|
||||
|
||||
#include <sys/ioctl.h>
|
||||
|
||||
#include <linux/ioctl.h>
|
||||
#define __force
|
||||
#define __bitwise
|
||||
#define __user
|
||||
#include <sound/asound.h>
|
||||
|
||||
#include <tinyalsa/asoundlib.h>
|
||||
|
||||
struct mixer_ctl {
|
||||
struct mixer *mixer;
|
||||
struct snd_ctl_elem_info info;
|
||||
char **ename;
|
||||
};
|
||||
|
||||
struct mixer {
|
||||
int fd;
|
||||
struct snd_ctl_card_info card_info;
|
||||
struct mixer_ctl *ctl;
|
||||
unsigned int count;
|
||||
};
|
||||
|
||||
static void mixer_cleanup_control(struct mixer_ctl *ctl)
|
||||
{
|
||||
unsigned int m;
|
||||
|
||||
if (ctl->ename) {
|
||||
unsigned int max = ctl->info.value.enumerated.items;
|
||||
for (m = 0; m < max; m++)
|
||||
free(ctl->ename[m]);
|
||||
free(ctl->ename);
|
||||
}
|
||||
}
|
||||
|
||||
void mixer_close(struct mixer *mixer)
|
||||
{
|
||||
unsigned int n;
|
||||
|
||||
if (!mixer)
|
||||
return;
|
||||
|
||||
if (mixer->fd >= 0)
|
||||
close(mixer->fd);
|
||||
|
||||
if (mixer->ctl) {
|
||||
for (n = 0; n < mixer->count; n++)
|
||||
mixer_cleanup_control(&mixer->ctl[n]);
|
||||
free(mixer->ctl);
|
||||
}
|
||||
|
||||
free(mixer);
|
||||
|
||||
/* TODO: verify frees */
|
||||
}
|
||||
|
||||
static void *mixer_realloc_z(void *ptr, size_t curnum, size_t newnum, size_t size)
|
||||
{
|
||||
int8_t *newp;
|
||||
|
||||
newp = realloc(ptr, size * newnum);
|
||||
if (!newp)
|
||||
return NULL;
|
||||
|
||||
memset(newp + (curnum * size), 0, (newnum-curnum) * size);
|
||||
return newp;
|
||||
}
|
||||
|
||||
static int add_controls(struct mixer *mixer)
|
||||
{
|
||||
struct snd_ctl_elem_list elist;
|
||||
struct snd_ctl_elem_info tmp;
|
||||
struct snd_ctl_elem_id *eid = NULL;
|
||||
struct snd_ctl_elem_info *info;
|
||||
struct mixer_ctl *ctl;
|
||||
int fd = mixer->fd;
|
||||
const unsigned int old_count = mixer->count;
|
||||
unsigned int extra_count;
|
||||
unsigned int n, m;
|
||||
|
||||
memset(&elist, 0, sizeof(elist));
|
||||
if (ioctl(fd, SNDRV_CTL_IOCTL_ELEM_LIST, &elist) < 0)
|
||||
goto fail;
|
||||
|
||||
if (old_count == elist.count)
|
||||
return 0; /* no new controls return unchanged */
|
||||
|
||||
ctl = mixer_realloc_z(mixer->ctl, old_count, elist.count,
|
||||
sizeof(struct mixer_ctl));
|
||||
if (!ctl)
|
||||
goto fail;
|
||||
mixer->ctl = ctl;
|
||||
|
||||
extra_count = elist.count - old_count; /* controls we haven't seen before */
|
||||
eid = calloc(extra_count, sizeof(struct snd_ctl_elem_id));
|
||||
if (!eid)
|
||||
goto fail;
|
||||
|
||||
/* Add all controls we haven't seen before
|
||||
* ALSA drivers are not allowed to remove or re-order controls that
|
||||
* have already been created so we know that any new controls must
|
||||
* be after the ones we have already collected
|
||||
*/
|
||||
elist.offset = old_count; /* first control we haven't seen yet */
|
||||
elist.space = extra_count;
|
||||
elist.pids = eid;
|
||||
if (ioctl(fd, SNDRV_CTL_IOCTL_ELEM_LIST, &elist) < 0)
|
||||
goto fail;
|
||||
|
||||
for (n = old_count; n < old_count + extra_count; n++) {
|
||||
struct snd_ctl_elem_info *ei = &mixer->ctl[n].info;
|
||||
ei->id.numid = eid[n - old_count].numid;
|
||||
if (ioctl(fd, SNDRV_CTL_IOCTL_ELEM_INFO, ei) < 0)
|
||||
goto fail_extend;
|
||||
ctl[n].mixer = mixer;
|
||||
if (ei->type == SNDRV_CTL_ELEM_TYPE_ENUMERATED) {
|
||||
char **enames = calloc(ei->value.enumerated.items, sizeof(char*));
|
||||
if (!enames)
|
||||
goto fail_extend;
|
||||
ctl[n].ename = enames;
|
||||
for (m = 0; m < ei->value.enumerated.items; m++) {
|
||||
memset(&tmp, 0, sizeof(tmp));
|
||||
tmp.id.numid = ei->id.numid;
|
||||
tmp.value.enumerated.item = m;
|
||||
if (ioctl(fd, SNDRV_CTL_IOCTL_ELEM_INFO, &tmp) < 0)
|
||||
goto fail_extend;
|
||||
enames[m] = strdup(tmp.value.enumerated.name);
|
||||
if (!enames[m])
|
||||
goto fail_extend;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
mixer->count = old_count + extra_count;
|
||||
free(eid);
|
||||
return 0;
|
||||
|
||||
fail_extend:
|
||||
/* cleanup the control we failed on but leave the ones that were already
|
||||
* added. Also no advantage to shrinking the resized memory block, we
|
||||
* might want to extend the controls again later
|
||||
*/
|
||||
mixer_cleanup_control(&ctl[n]);
|
||||
|
||||
mixer->count = n; /* keep controls we successfully added */
|
||||
/* fall through... */
|
||||
fail:
|
||||
free(eid);
|
||||
return -1;
|
||||
}
|
||||
|
||||
struct mixer *mixer_open(unsigned int card)
|
||||
{
|
||||
struct mixer *mixer = NULL;
|
||||
int fd;
|
||||
char fn[256];
|
||||
|
||||
snprintf(fn, sizeof(fn), "/dev/snd/controlC%u", card);
|
||||
fd = open(fn, O_RDWR);
|
||||
if (fd < 0)
|
||||
return 0;
|
||||
|
||||
mixer = calloc(1, sizeof(*mixer));
|
||||
if (!mixer)
|
||||
goto fail;
|
||||
|
||||
if (ioctl(fd, SNDRV_CTL_IOCTL_CARD_INFO, &mixer->card_info) < 0)
|
||||
goto fail;
|
||||
|
||||
mixer->fd = fd;
|
||||
|
||||
if (add_controls(mixer) != 0)
|
||||
goto fail;
|
||||
|
||||
return mixer;
|
||||
|
||||
fail:
|
||||
if (mixer)
|
||||
mixer_close(mixer);
|
||||
else if (fd >= 0)
|
||||
close(fd);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int mixer_update_ctls(struct mixer *mixer)
|
||||
{
|
||||
if (!mixer)
|
||||
return 0;
|
||||
|
||||
return add_controls(mixer);
|
||||
}
|
||||
|
||||
const char *mixer_get_name(struct mixer *mixer)
|
||||
{
|
||||
return (const char *)mixer->card_info.name;
|
||||
}
|
||||
|
||||
unsigned int mixer_get_num_ctls(struct mixer *mixer)
|
||||
{
|
||||
if (!mixer)
|
||||
return 0;
|
||||
|
||||
return mixer->count;
|
||||
}
|
||||
|
||||
struct mixer_ctl *mixer_get_ctl(struct mixer *mixer, unsigned int id)
|
||||
{
|
||||
if (mixer && (id < mixer->count))
|
||||
return mixer->ctl + id;
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
struct mixer_ctl *mixer_get_ctl_by_name(struct mixer *mixer, const char *name)
|
||||
{
|
||||
unsigned int n;
|
||||
struct mixer_ctl *ctl = mixer->ctl;
|
||||
|
||||
if (!mixer)
|
||||
return NULL;
|
||||
|
||||
for (n = 0; n < mixer->count; n++)
|
||||
if (!strcmp(name, (char*) ctl[n].info.id.name))
|
||||
return &ctl[n];
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void mixer_ctl_update(struct mixer_ctl *ctl)
|
||||
{
|
||||
ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_INFO, ctl->info);
|
||||
}
|
||||
|
||||
const char *mixer_ctl_get_name(struct mixer_ctl *ctl)
|
||||
{
|
||||
if (!ctl)
|
||||
return NULL;
|
||||
|
||||
return (const char *)ctl->info.id.name;
|
||||
}
|
||||
|
||||
enum mixer_ctl_type mixer_ctl_get_type(struct mixer_ctl *ctl)
|
||||
{
|
||||
if (!ctl)
|
||||
return MIXER_CTL_TYPE_UNKNOWN;
|
||||
|
||||
switch (ctl->info.type) {
|
||||
case SNDRV_CTL_ELEM_TYPE_BOOLEAN: return MIXER_CTL_TYPE_BOOL;
|
||||
case SNDRV_CTL_ELEM_TYPE_INTEGER: return MIXER_CTL_TYPE_INT;
|
||||
case SNDRV_CTL_ELEM_TYPE_ENUMERATED: return MIXER_CTL_TYPE_ENUM;
|
||||
case SNDRV_CTL_ELEM_TYPE_BYTES: return MIXER_CTL_TYPE_BYTE;
|
||||
case SNDRV_CTL_ELEM_TYPE_IEC958: return MIXER_CTL_TYPE_IEC958;
|
||||
case SNDRV_CTL_ELEM_TYPE_INTEGER64: return MIXER_CTL_TYPE_INT64;
|
||||
default: return MIXER_CTL_TYPE_UNKNOWN;
|
||||
};
|
||||
}
|
||||
|
||||
const char *mixer_ctl_get_type_string(struct mixer_ctl *ctl)
|
||||
{
|
||||
if (!ctl)
|
||||
return "";
|
||||
|
||||
switch (ctl->info.type) {
|
||||
case SNDRV_CTL_ELEM_TYPE_BOOLEAN: return "BOOL";
|
||||
case SNDRV_CTL_ELEM_TYPE_INTEGER: return "INT";
|
||||
case SNDRV_CTL_ELEM_TYPE_ENUMERATED: return "ENUM";
|
||||
case SNDRV_CTL_ELEM_TYPE_BYTES: return "BYTE";
|
||||
case SNDRV_CTL_ELEM_TYPE_IEC958: return "IEC958";
|
||||
case SNDRV_CTL_ELEM_TYPE_INTEGER64: return "INT64";
|
||||
default: return "Unknown";
|
||||
};
|
||||
}
|
||||
|
||||
unsigned int mixer_ctl_get_num_values(struct mixer_ctl *ctl)
|
||||
{
|
||||
if (!ctl)
|
||||
return 0;
|
||||
|
||||
return ctl->info.count;
|
||||
}
|
||||
|
||||
static int percent_to_int(struct snd_ctl_elem_info *ei, int percent)
|
||||
{
|
||||
int range;
|
||||
|
||||
if (percent > 100)
|
||||
percent = 100;
|
||||
else if (percent < 0)
|
||||
percent = 0;
|
||||
|
||||
range = (ei->value.integer.max - ei->value.integer.min);
|
||||
|
||||
return ei->value.integer.min + (range * percent) / 100;
|
||||
}
|
||||
|
||||
static int int_to_percent(struct snd_ctl_elem_info *ei, int value)
|
||||
{
|
||||
int range = (ei->value.integer.max - ei->value.integer.min);
|
||||
|
||||
if (range == 0)
|
||||
return 0;
|
||||
|
||||
return ((value - ei->value.integer.min) / range) * 100;
|
||||
}
|
||||
|
||||
int mixer_ctl_get_percent(struct mixer_ctl *ctl, unsigned int id)
|
||||
{
|
||||
if (!ctl || (ctl->info.type != SNDRV_CTL_ELEM_TYPE_INTEGER))
|
||||
return -EINVAL;
|
||||
|
||||
return int_to_percent(&ctl->info, mixer_ctl_get_value(ctl, id));
|
||||
}
|
||||
|
||||
int mixer_ctl_set_percent(struct mixer_ctl *ctl, unsigned int id, int percent)
|
||||
{
|
||||
if (!ctl || (ctl->info.type != SNDRV_CTL_ELEM_TYPE_INTEGER))
|
||||
return -EINVAL;
|
||||
|
||||
return mixer_ctl_set_value(ctl, id, percent_to_int(&ctl->info, percent));
|
||||
}
|
||||
|
||||
int mixer_ctl_get_value(struct mixer_ctl *ctl, unsigned int id)
|
||||
{
|
||||
struct snd_ctl_elem_value ev;
|
||||
int ret;
|
||||
|
||||
if (!ctl || (id >= ctl->info.count))
|
||||
return -EINVAL;
|
||||
|
||||
memset(&ev, 0, sizeof(ev));
|
||||
ev.id.numid = ctl->info.id.numid;
|
||||
ret = ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_READ, &ev);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
switch (ctl->info.type) {
|
||||
case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
|
||||
return !!ev.value.integer.value[id];
|
||||
|
||||
case SNDRV_CTL_ELEM_TYPE_INTEGER:
|
||||
return ev.value.integer.value[id];
|
||||
|
||||
case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
|
||||
return ev.value.enumerated.item[id];
|
||||
|
||||
case SNDRV_CTL_ELEM_TYPE_BYTES:
|
||||
return ev.value.bytes.data[id];
|
||||
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mixer_ctl_get_array(struct mixer_ctl *ctl, void *array, size_t count)
|
||||
{
|
||||
struct snd_ctl_elem_value ev;
|
||||
int ret = 0;
|
||||
size_t size;
|
||||
void *source;
|
||||
|
||||
if (!ctl || (count > ctl->info.count) || !count || !array)
|
||||
return -EINVAL;
|
||||
|
||||
memset(&ev, 0, sizeof(ev));
|
||||
ev.id.numid = ctl->info.id.numid;
|
||||
|
||||
switch (ctl->info.type) {
|
||||
case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
|
||||
case SNDRV_CTL_ELEM_TYPE_INTEGER:
|
||||
ret = ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_READ, &ev);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
size = sizeof(ev.value.integer.value[0]);
|
||||
source = ev.value.integer.value;
|
||||
break;
|
||||
|
||||
case SNDRV_CTL_ELEM_TYPE_BYTES:
|
||||
/* check if this is new bytes TLV */
|
||||
if (ctl->info.access & SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE) {
|
||||
struct snd_ctl_tlv *tlv;
|
||||
int ret;
|
||||
|
||||
if (count > SIZE_MAX - sizeof(*tlv))
|
||||
return -EINVAL;
|
||||
tlv = calloc(1, sizeof(*tlv) + count);
|
||||
if (!tlv)
|
||||
return -ENOMEM;
|
||||
tlv->numid = ctl->info.id.numid;
|
||||
tlv->length = count;
|
||||
ret = ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_TLV_READ, tlv);
|
||||
|
||||
source = tlv->tlv;
|
||||
memcpy(array, source, count);
|
||||
|
||||
free(tlv);
|
||||
|
||||
return ret;
|
||||
} else {
|
||||
ret = ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_READ, &ev);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
size = sizeof(ev.value.bytes.data[0]);
|
||||
source = ev.value.bytes.data;
|
||||
break;
|
||||
}
|
||||
|
||||
case SNDRV_CTL_ELEM_TYPE_IEC958:
|
||||
size = sizeof(ev.value.iec958);
|
||||
source = &ev.value.iec958;
|
||||
break;
|
||||
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
memcpy(array, source, size * count);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mixer_ctl_set_value(struct mixer_ctl *ctl, unsigned int id, int value)
|
||||
{
|
||||
struct snd_ctl_elem_value ev;
|
||||
int ret;
|
||||
|
||||
if (!ctl || (id >= ctl->info.count))
|
||||
return -EINVAL;
|
||||
|
||||
memset(&ev, 0, sizeof(ev));
|
||||
ev.id.numid = ctl->info.id.numid;
|
||||
ret = ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_READ, &ev);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
switch (ctl->info.type) {
|
||||
case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
|
||||
ev.value.integer.value[id] = !!value;
|
||||
break;
|
||||
|
||||
case SNDRV_CTL_ELEM_TYPE_INTEGER: {
|
||||
int min = mixer_ctl_get_range_min(ctl);
|
||||
int max = mixer_ctl_get_range_max(ctl);
|
||||
if (min < max && (value < min || value > max))
|
||||
return -EINVAL;
|
||||
ev.value.integer.value[id] = value;
|
||||
break;
|
||||
}
|
||||
|
||||
case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
|
||||
if (value < 0 || (value >= 0 && (unsigned int)value >= mixer_ctl_get_num_enums(ctl)))
|
||||
return -EINVAL;
|
||||
ev.value.enumerated.item[id] = value;
|
||||
break;
|
||||
|
||||
case SNDRV_CTL_ELEM_TYPE_BYTES:
|
||||
ev.value.bytes.data[id] = value;
|
||||
break;
|
||||
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
return ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_WRITE, &ev);
|
||||
}
|
||||
|
||||
int mixer_ctl_set_array(struct mixer_ctl *ctl, const void *array, size_t count)
|
||||
{
|
||||
struct snd_ctl_elem_value ev;
|
||||
size_t size;
|
||||
void *dest;
|
||||
|
||||
if (!ctl || (count > ctl->info.count) || !count || !array)
|
||||
return -EINVAL;
|
||||
|
||||
memset(&ev, 0, sizeof(ev));
|
||||
ev.id.numid = ctl->info.id.numid;
|
||||
|
||||
switch (ctl->info.type) {
|
||||
case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
|
||||
case SNDRV_CTL_ELEM_TYPE_INTEGER:
|
||||
size = sizeof(ev.value.integer.value[0]);
|
||||
dest = ev.value.integer.value;
|
||||
break;
|
||||
|
||||
case SNDRV_CTL_ELEM_TYPE_BYTES:
|
||||
/* check if this is new bytes TLV */
|
||||
if (ctl->info.access & SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE) {
|
||||
struct snd_ctl_tlv *tlv;
|
||||
int ret = 0;
|
||||
if (count > SIZE_MAX - sizeof(*tlv))
|
||||
return -EINVAL;
|
||||
tlv = calloc(1, sizeof(*tlv) + count);
|
||||
if (!tlv)
|
||||
return -ENOMEM;
|
||||
tlv->numid = ctl->info.id.numid;
|
||||
tlv->length = count;
|
||||
memcpy(tlv->tlv, array, count);
|
||||
|
||||
ret = ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_TLV_WRITE, tlv);
|
||||
free(tlv);
|
||||
|
||||
return ret;
|
||||
} else {
|
||||
size = sizeof(ev.value.bytes.data[0]);
|
||||
dest = ev.value.bytes.data;
|
||||
}
|
||||
break;
|
||||
|
||||
case SNDRV_CTL_ELEM_TYPE_IEC958:
|
||||
size = sizeof(ev.value.iec958);
|
||||
dest = &ev.value.iec958;
|
||||
break;
|
||||
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
memcpy(dest, array, size * count);
|
||||
|
||||
return ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_WRITE, &ev);
|
||||
}
|
||||
|
||||
int mixer_ctl_get_range_min(struct mixer_ctl *ctl)
|
||||
{
|
||||
if (!ctl || (ctl->info.type != SNDRV_CTL_ELEM_TYPE_INTEGER))
|
||||
return -EINVAL;
|
||||
|
||||
return ctl->info.value.integer.min;
|
||||
}
|
||||
|
||||
int mixer_ctl_get_range_max(struct mixer_ctl *ctl)
|
||||
{
|
||||
if (!ctl || (ctl->info.type != SNDRV_CTL_ELEM_TYPE_INTEGER))
|
||||
return -EINVAL;
|
||||
|
||||
return ctl->info.value.integer.max;
|
||||
}
|
||||
|
||||
unsigned int mixer_ctl_get_num_enums(struct mixer_ctl *ctl)
|
||||
{
|
||||
if (!ctl)
|
||||
return 0;
|
||||
|
||||
return ctl->info.value.enumerated.items;
|
||||
}
|
||||
|
||||
const char *mixer_ctl_get_enum_string(struct mixer_ctl *ctl,
|
||||
unsigned int enum_id)
|
||||
{
|
||||
if (!ctl || (ctl->info.type != SNDRV_CTL_ELEM_TYPE_ENUMERATED) ||
|
||||
(enum_id >= ctl->info.value.enumerated.items))
|
||||
return NULL;
|
||||
|
||||
return (const char *)ctl->ename[enum_id];
|
||||
}
|
||||
|
||||
int mixer_ctl_set_enum_by_string(struct mixer_ctl *ctl, const char *string)
|
||||
{
|
||||
unsigned int i, num_enums;
|
||||
struct snd_ctl_elem_value ev;
|
||||
int ret;
|
||||
|
||||
if (!ctl || (ctl->info.type != SNDRV_CTL_ELEM_TYPE_ENUMERATED))
|
||||
return -EINVAL;
|
||||
|
||||
num_enums = ctl->info.value.enumerated.items;
|
||||
for (i = 0; i < num_enums; i++) {
|
||||
if (!strcmp(string, ctl->ename[i])) {
|
||||
memset(&ev, 0, sizeof(ev));
|
||||
ev.value.enumerated.item[0] = i;
|
||||
ev.id.numid = ctl->info.id.numid;
|
||||
ret = ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_WRITE, &ev);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user