text: /*
  ** Copyright 2010, The Android Open-Source Project
  ** Copyright (c) 2011-2012, Code Aurora Forum. All rights reserved.
  **
  ** 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 <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  #include <unistd.h>
  #include <stdint.h>
  #include <fcntl.h>
  #include <errno.h>
  #include <ctype.h>
  #include <math.h>
  
  #include <linux/ioctl.h>
  #define __force
  #define __bitwise
  #define __user
  #include <sound/asound.h>
  #include <sound/tlv.h>
  
  #include "alsa_audio.h"
  
  #define LOG_TAG "alsa_mixer"
  #define LOG_NDEBUG 1
  
  #ifdef ANDROID
  /* definitions for Android logging */
  #include <utils/Log.h>
  #else /* ANDROID */
  #include <math.h>
  #define ALOGI(...)      fprintf(stdout, __VA_ARGS__)
  #define ALOGE(...)      fprintf(stderr, __VA_ARGS__)
  #define ALOGV(...)      fprintf(stderr, __VA_ARGS__)
  #endif /* ANDROID */
  
  #define check_range(val, min, max) \
          (((val < min) ? (min) : (val > max) ? (max) : (val)))
  
  /* .5 for rounding before casting to non-decmal value */
  /* Should not be used if you need decmal values */
  /* or are expecting negitive indexes */
  #define percent_to_index(val, min, max) \
          ((val) * ((max) - (min)) * 0.01 + (min) + .5)
  
  #define DEFAULT_TLV_SIZE 4096
  #define SPDIF_CHANNEL_STATUS_SIZE 24
  
  enum ctl_type {
  	CTL_GLOBAL_VOLUME,
  	CTL_PLAYBACK_VOLUME,
  	CTL_CAPTURE_VOLUME,
  };
  
  static const struct suf {
          const char *suffix;
          snd_ctl_elem_iface_t type;
  } suffixes[] = {
          {" Playback Volume", CTL_PLAYBACK_VOLUME},
          {" Capture Volume", CTL_CAPTURE_VOLUME},
          {" Volume", CTL_GLOBAL_VOLUME},
          {NULL, 0}
  };
  
  static int is_volume(const char *name, enum ctl_type *type)
  {
          const struct suf *p;
          size_t nlen = strlen(name);
          p = suffixes;
          while (p->suffix) {
                  size_t slen = strnlen(p->suffix, 44);
                  size_t l;
                  if (nlen > slen) {
                          l = nlen - slen;
                          if (strncmp(name + l, p->suffix, slen) == 0 &&
                              (l < 1 || name[l-1] != '-')) {      /* 3D Control - Switch */
                                  *type = p->type;
                                  return l;
                          }
                  }
                  p++;
          }
  	return 0;
  }
  
  static const char *elem_iface_name(snd_ctl_elem_iface_t n)
  {
      switch (n) {
      case SNDRV_CTL_ELEM_IFACE_CARD: return "CARD";
      case SNDRV_CTL_ELEM_IFACE_HWDEP: return "HWDEP";
      case SNDRV_CTL_ELEM_IFACE_MIXER: return "MIXER";
      case SNDRV_CTL_ELEM_IFACE_PCM: return "PCM";
      case SNDRV_CTL_ELEM_IFACE_RAWMIDI: return "MIDI";
      case SNDRV_CTL_ELEM_IFACE_TIMER: return "TIMER";
      case SNDRV_CTL_ELEM_IFACE_SEQUENCER: return "SEQ";
      default: return "???";
      }
  }
  
  static const char *elem_type_name(snd_ctl_elem_type_t n)
  {
      switch (n) {
      case SNDRV_CTL_ELEM_TYPE_NONE: return "NONE";
      case SNDRV_CTL_ELEM_TYPE_BOOLEAN: return "BOOL";
      case SNDRV_CTL_ELEM_TYPE_INTEGER: return "INT32";
      case SNDRV_CTL_ELEM_TYPE_ENUMERATED: return "ENUM";
      case SNDRV_CTL_ELEM_TYPE_BYTES: return "BYTES";
      case SNDRV_CTL_ELEM_TYPE_IEC958: return "IEC958";
      case SNDRV_CTL_ELEM_TYPE_INTEGER64: return "INT64";
      default: return "???";
      }
  }
  
  void mixer_close(struct mixer *mixer)
  {
      unsigned n,m;
  
      if (mixer->fd >= 0)
          close(mixer->fd);
  
      if (mixer->ctl) {
          for (n = 0; n < mixer->count; n++) {
              if (mixer->ctl[n].ename) {
                  unsigned max = mixer->ctl[n].info->value.enumerated.items;
                  for (m = 0; m < max; m++)
                      free(mixer->ctl[n].ename[m]);
                  free(mixer->ctl[n].ename);
              }
          }
          free(mixer->ctl);
      }
  
      if (mixer->info)
          free(mixer->info);
  
      free(mixer);
  }
  
  struct mixer *mixer_open(const char *device)
  {
      struct snd_ctl_elem_list elist;
      struct snd_ctl_elem_info tmp;
      struct snd_ctl_elem_id *eid = NULL;
      struct mixer *mixer = NULL;
      unsigned n, m;
      int fd;
  
      fd = open(device, O_RDWR);
      if (fd < 0) {
          ALOGE("Control open failed\n");
          return 0;
      }
  
      memset(&elist, 0, sizeof(elist));
      if (ioctl(fd, SNDRV_CTL_IOCTL_ELEM_LIST, &elist) < 0) {
          ALOGE("SNDRV_CTL_IOCTL_ELEM_LIST failed\n");
          goto fail;
      }
  
      mixer = calloc(1, sizeof(*mixer));
      if (!mixer)
          goto fail;
  
      mixer->ctl = calloc(elist.count, sizeof(struct mixer_ctl));
      mixer->info = calloc(elist.count, sizeof(struct snd_ctl_elem_info));
      if (!mixer->ctl || !mixer->info)
          goto fail;
  
      eid = calloc(elist.count, sizeof(struct snd_ctl_elem_id));
      if (!eid)
          goto fail;
  
      mixer->count = elist.count;
      mixer->fd = fd;
      elist.space = mixer->count;
      elist.pids = eid;
      if (ioctl(fd, SNDRV_CTL_IOCTL_ELEM_LIST, &elist) < 0)
          goto fail;
  
      for (n = 0; n < mixer->count; n++) {
          struct snd_ctl_elem_info *ei = mixer->info + n;
          ei->id.numid = eid[n].numid;
          if (ioctl(fd, SNDRV_CTL_IOCTL_ELEM_INFO, ei) < 0)
              goto fail;
          mixer->ctl[n].info = ei;
          mixer->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;
              mixer->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;
                  enames[m] = strdup(tmp.value.enumerated.name);
                  if (!enames[m])
                      goto fail;
              }
          }
      }
  
      free(eid);
      return mixer;
  
  fail:
      if (eid)
          free(eid);
      if (mixer)
          mixer_close(mixer);
      else if (fd >= 0)
          close(fd);
      return 0;
  }
  
  void mixer_dump(struct mixer *mixer)
  {
      unsigned n, m;
  
      ALOGV("  id iface dev sub idx num perms     type   isvolume  name\n");
      for (n = 0; n < mixer->count; n++) {
  	enum ctl_type type;
          struct snd_ctl_elem_info *ei = mixer->info + n;
  
          ALOGV("%4d %5s %3d %3d %3d %3d %c%c%c%c%c%c%c%c%c %-6s %8d  %s",
                 ei->id.numid, elem_iface_name(ei->id.iface),
                 ei->id.device, ei->id.subdevice, ei->id.index,
                 ei->count,
                 (ei->access & SNDRV_CTL_ELEM_ACCESS_READ) ? 'r' : ' ',
                 (ei->access & SNDRV_CTL_ELEM_ACCESS_WRITE) ? 'w' : ' ',
                 (ei->access & SNDRV_CTL_ELEM_ACCESS_VOLATILE) ? 'V' : ' ',
                 (ei->access & SNDRV_CTL_ELEM_ACCESS_TIMESTAMP) ? 'T' : ' ',
                 (ei->access & SNDRV_CTL_ELEM_ACCESS_TLV_READ) ? 'R' : ' ',
                 (ei->access & SNDRV_CTL_ELEM_ACCESS_TLV_WRITE) ? 'W' : ' ',
                 (ei->access & SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND) ? 'C' : ' ',
                 (ei->access & SNDRV_CTL_ELEM_ACCESS_INACTIVE) ? 'I' : ' ',
                 (ei->access & SNDRV_CTL_ELEM_ACCESS_LOCK) ? 'L' : ' ',
                 elem_type_name(ei->type),
  	       (is_volume(ei->id.name, &type)) ? 1 : 0,
                 ei->id.name);
          switch (ei->type) {
          case SNDRV_CTL_ELEM_TYPE_INTEGER:
              ALOGV(ei->value.integer.step ?
                     " { %ld-%ld, %ld }\n" : " { %ld-%ld }",
                     ei->value.integer.min,
                     ei->value.integer.max,
                     ei->value.integer.step);
              break;
          case SNDRV_CTL_ELEM_TYPE_INTEGER64:
              ALOGV(ei->value.integer64.step ?
                     " { %lld-%lld, %lld }\n" : " { %lld-%lld }",
                     ei->value.integer64.min,
                     ei->value.integer64.max,
                     ei->value.integer64.step);
              break;
          case SNDRV_CTL_ELEM_TYPE_ENUMERATED: {
              unsigned m;
              ALOGV(" { %s=0", mixer->ctl[n].ename[0]);
              for (m = 1; m < ei->value.enumerated.items; m++)
                  ALOGV(", %s=%d", mixer->ctl[n].ename[m],m);
              ALOGV(" }");
              break;
          }
          }
          ALOGV("\n");
      }
  }
  
  struct mixer_ctl *mixer_get_control(struct mixer *mixer,
                                      const char *name, unsigned index)
  {
      unsigned n;
      for (n = 0; n < mixer->count; n++) {
          if (mixer->info[n].id.index == index) {
              if (!strncmp(name, (char*) mixer->info[n].id.name,
  			sizeof(mixer->info[n].id.name))) {
                  return mixer->ctl + n;
              }
          }
      }
      return 0;
  }
  
  struct mixer_ctl *mixer_get_nth_control(struct mixer *mixer, unsigned n)
  {
      if (n < mixer->count)
          return mixer->ctl + n;
      return 0;
  }
  
  static void print_dB(long dB)
  {
          ALOGV("%li.%02lidB", dB / 100, (dB < 0 ? -dB : dB) % 100);
  }
  
  int mixer_ctl_read_tlv(struct mixer_ctl *ctl,
                      unsigned int *tlv,
  		    long *min, long *max, unsigned int *tlv_type)
  {
      unsigned int tlv_size = DEFAULT_TLV_SIZE;
      unsigned int type;
      unsigned int size;
  
      if(!!(ctl->info->access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)) {
          struct snd_ctl_tlv *xtlv;
          tlv[0] = -1;
          tlv[1] = 0;
          xtlv = calloc(1, sizeof(struct snd_ctl_tlv) + tlv_size);
          if (xtlv == NULL)
                  return -ENOMEM;
          xtlv->numid = ctl->info->id.numid;
          xtlv->length = tlv_size;
          memcpy(xtlv->tlv, tlv, tlv_size);
          if (ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_TLV_READ, xtlv) < 0) {
              fprintf( stderr, "SNDRV_CTL_IOCTL_TLV_READ failed\n");
              free(xtlv);
              return -errno;
          }
          if (xtlv->tlv[1] + 2 * sizeof(unsigned int) > tlv_size) {
              free(xtlv);
              return -EFAULT;
          }
          memcpy(tlv, xtlv->tlv, xtlv->tlv[1] + 2 * sizeof(unsigned int));
          free(xtlv);
  
          type = tlv[0];
  	*tlv_type = type;
          size = tlv[1];
          switch (type) {
          case SNDRV_CTL_TLVT_DB_SCALE: {
                  int idx = 2;
                  int step;
                  ALOGV("dBscale-");
                  if (size != 2 * sizeof(unsigned int)) {
                          while (size > 0) {
                                  ALOGV("0x%08x,", tlv[idx++]);
                                  size -= sizeof(unsigned int);
                          }
                  } else {
                      ALOGV(" min=");
                      print_dB((int)tlv[2]);
                      *min = (long)tlv[2];
                      ALOGV(" step=");
                      step = (tlv[3] & 0xffff);
                      print_dB(tlv[3] & 0xffff);
                      ALOGV(" max=");
                      *max = (ctl->info->value.integer.max);
                      print_dB((long)ctl->info->value.integer.max);
                      ALOGV(" mute=%i\n", (tlv[3] >> 16) & 1);
                  }
              break;
          }
          case SNDRV_CTL_TLVT_DB_LINEAR: {
                  int idx = 2;
                  ALOGV("dBLiner-");
                  if (size != 2 * sizeof(unsigned int)) {
                          while (size > 0) {
                                  ALOGV("0x%08x,", tlv[idx++]);
                                  size -= sizeof(unsigned int);
                          }
                  } else {
                      ALOGV(" min=");
                      *min = tlv[2];
                      print_dB(tlv[2]);
                      ALOGV(" max=");
                      *max = tlv[3];
                      print_dB(tlv[3]);
                  }
              break;
          }
          default:
               break;
          }
          return 0;
      }
      return -EINVAL;
  }
  
  void mixer_ctl_get(struct mixer_ctl *ctl, unsigned *value)
  {
      struct snd_ctl_elem_value ev;
      unsigned int n;
      unsigned int *tlv = NULL;
      enum ctl_type type;
      unsigned int *tlv_type;
      long min, max;
  
      if (is_volume(ctl->info->id.name, &type)) {
         ALOGV("capability: volume\n");
         tlv = calloc(1, DEFAULT_TLV_SIZE);
         if (tlv == NULL) {
             ALOGE("failed to allocate memory\n");
         } else {
  	   mixer_ctl_read_tlv(ctl, tlv, &min, &max, &tlv_type);
             free(tlv);
         }
      }
  
      memset(&ev, 0, sizeof(ev));
      ev.id.numid = ctl->info->id.numid;
      if (ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_READ, &ev))
          return;
      ALOGV("%s:", ctl->info->id.name);
  
      switch (ctl->info->type) {
      case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
          for (n = 0; n < ctl->info->count; n++)
              ALOGV(" %s", ev.value.integer.value[n] ? "on" : "off");
          *value = ev.value.integer.value[0];
          break;
      case SNDRV_CTL_ELEM_TYPE_INTEGER: {
          for (n = 0; n < ctl->info->count; n++)
              ALOGV(" %ld", ev.value.integer.value[n]);
          *value = ev.value.integer.value[0];
          break;
      }
      case SNDRV_CTL_ELEM_TYPE_INTEGER64:
          for (n = 0; n < ctl->info->count; n++)
              ALOGV(" %lld", ev.value.integer64.value[n]);
          *value = ev.value.integer64.value[0];
          break;
      case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
          for (n = 0; n < ctl->info->count; n++) {
              unsigned v = ev.value.enumerated.item[n];
              ALOGV(" %d (%s)", v,
                     (v < ctl->info->value.enumerated.items) ? ctl->ename[v] : "???");
          *value = ev.value.enumerated.item[0];
          }
          break;
      default:
          ALOGV(" ???");
      }
      ALOGV("\n");
  }
  
  static long scale_int(struct snd_ctl_elem_info *ei, unsigned _percent)
  {
      long percent;
  
      if (_percent > 100)
          percent = 100;
      else
          percent = (long) _percent;
  
      return (long)percent_to_index(percent, ei->value.integer.min, ei->value.integer.max);
  }
  
  static long long scale_int64(struct snd_ctl_elem_info *ei, unsigned _percent)
  {
      long long percent;
  
      if (_percent > 100)
          percent = 100;
      else
          percent = (long) _percent;
  
      return (long long)percent_to_index(percent, ei->value.integer.min, ei->value.integer.max);
  }
  
  /*
   * Add support for controls taking more than one parameter as input value
   * This is useful for volume controls which take two parameters as input value.
   */
  int mixer_ctl_mulvalues(struct mixer_ctl *ctl, int count, char ** argv)
  {
      struct snd_ctl_elem_value ev;
      unsigned n;
  
      if (!ctl) {
          ALOGV("can't find control\n");
          return -1;
      }
      if (count < ctl->info->count || count > ctl->info->count)
          return -EINVAL;
  
  
      memset(&ev, 0, sizeof(ev));
      ev.id.numid = ctl->info->id.numid;
      switch (ctl->info->type) {
      case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
          for (n = 0; n < ctl->info->count; n++)
              ev.value.integer.value[n] = !!atoi(argv[n]);
          break;
      case SNDRV_CTL_ELEM_TYPE_INTEGER: {
          for (n = 0; n < ctl->info->count; n++) {
               fprintf( stderr, "Value: %d idx:%d\n", atoi(argv[n]), n);
               ev.value.integer.value[n] = atoi(argv[n]);
          }
          break;
      }
      case SNDRV_CTL_ELEM_TYPE_INTEGER64: {
          for (n = 0; n < ctl->info->count; n++) {
               long long value_ll = scale_int64(ctl->info, atoi(argv[n]));
               fprintf( stderr, "ll_value = %lld\n", value_ll);
               ev.value.integer64.value[n] = value_ll;
          }
          break;
      }
      default:
          errno = EINVAL;
          return errno;
      }
  
      return ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_WRITE, &ev);
  }
  
  int mixer_ctl_set(struct mixer_ctl *ctl, unsigned percent)
  {
      struct snd_ctl_elem_value ev;
      unsigned n;
      long min, max;
      unsigned int *tlv = NULL;
      enum ctl_type type;
      int volume = 0;
      unsigned int tlv_type;
  
      if (!ctl) {
          ALOGV("can't find control\n");
          return -1;
      }
  
      if (is_volume(ctl->info->id.name, &type)) {
          ALOGV("capability: volume\n");
          tlv = calloc(1, DEFAULT_TLV_SIZE);
          if (tlv == NULL) {
              ALOGE("failed to allocate memory\n");
          } else if (!mixer_ctl_read_tlv(ctl, tlv, &min, &max, &tlv_type)) {
              switch(tlv_type) {
              case SNDRV_CTL_TLVT_DB_LINEAR:
                  ALOGV("tlv db linear: b4 %d\n", percent);
  
  		if (min < 0) {
  			max = max - min;
  			min = 0;
  		}
                  percent = check_range(percent, min, max);
                  ALOGV("tlv db linear: %d %d %d\n", percent, min, max);
                  volume = 1;
                  break;
              default:
                  percent = (long)percent_to_index(percent, min, max);
                  percent = check_range(percent, min, max);
                  volume = 1;
                  break;
              }
          } else
              ALOGV("mixer_ctl_read_tlv failed\n");
          free(tlv);
      }
      memset(&ev, 0, sizeof(ev));
      ev.id.numid = ctl->info->id.numid;
      switch (ctl->info->type) {
      case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
          for (n = 0; n < ctl->info->count; n++)
              ev.value.integer.value[n] = !!percent;
          break;
      case SNDRV_CTL_ELEM_TYPE_INTEGER: {
          int value;
          if (!volume)
               value = scale_int(ctl->info, percent);
          else
               value = (int) percent;
          for (n = 0; n < ctl->info->count; n++)
              ev.value.integer.value[n] = value;
          break;
      }
      case SNDRV_CTL_ELEM_TYPE_INTEGER64: {
          long long value;
          if (!volume)
               value = scale_int64(ctl->info, percent);
          else
               value = (long long)percent;
          for (n = 0; n < ctl->info->count; n++)
              ev.value.integer64.value[n] = value;
          break;
      }
      case SNDRV_CTL_ELEM_TYPE_IEC958: {
          struct snd_aes_iec958 *iec958;
          iec958 = (struct snd_aes_iec958 *)percent;
          memcpy(ev.value.iec958.status,iec958->status,SPDIF_CHANNEL_STATUS_SIZE);
          break;
      }
      default:
          errno = EINVAL;
          return errno;
      }
  
      return ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_WRITE, &ev);
  }
  
  /* the api parses the mixer control input to extract
   * the value of volume in any one of the following format
   * <volume><%>
   * <volume><dB>
   * All remaining formats are currently ignored.
   */
  
  static int set_volume_simple(struct mixer_ctl *ctl,
      char **ptr, long pmin, long pmax, int count)
  {
      long val, orig;
      char *p = *ptr, *s;
      struct snd_ctl_elem_value ev;
      unsigned n;
  
      if (*p == ':')
          p++;
      if (*p == '\0' || (!isdigit(*p) && *p != '-'))
          goto skip;
  
      s = p;
      val = strtol(s, &p, 10);
      if (*p == '.') {
          p++;
          strtol(p, &p, 10);
      }
      if (*p == '%') {
          val = (long)percent_to_index(strtod(s, NULL), pmin, pmax);
          p++;
      } else if (p[0] == 'd' && p[1] == 'B') {
          val = (long)(strtod(s, NULL) * 100.0);
          p += 2;
      } else {
          if (pmin < 0) {
              pmax = pmax - pmin;
              pmin = 0;
          }
      }
      val = check_range(val, pmin, pmax);
      ALOGV("val = %x", val);
  
      if (!ctl) {
          ALOGV("can't find control\n");
          return -EPERM;
      }
      if (count < ctl->info->count || count > ctl->info->count)
          return -EINVAL;
  
      ALOGV("Value = ");
  
      memset(&ev, 0, sizeof(ev));
      ev.id.numid = ctl->info->id.numid;
      switch (ctl->info->type) {
      case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
          for (n = 0; n < ctl->info->count; n++)
              ev.value.integer.value[n] = !!val;
          print_dB(val);
          break;
      case SNDRV_CTL_ELEM_TYPE_INTEGER: {
          for (n = 0; n < ctl->info->count; n++)
               ev.value.integer.value[n] = val;
          print_dB(val);
          break;
      }
      case SNDRV_CTL_ELEM_TYPE_INTEGER64: {
          for (n = 0; n < ctl->info->count; n++) {
               long long value_ll = scale_int64(ctl->info, val);
               print_dB(value_ll);
               ev.value.integer64.value[n] = value_ll;
          }
          break;
      }
      default:
          errno = EINVAL;
          return errno;
      }
  
      ALOGV("\n");
      return ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_WRITE, &ev);
  
  skip:
          if (*p == ',')
                  p++;
          *ptr = p;
          return 0;
  }
  
  int mixer_ctl_set_value(struct mixer_ctl *ctl, int count, char ** argv)
  {
      unsigned int size;
      unsigned int *tlv = NULL;
      long min, max;
      enum ctl_type type;
      unsigned int tlv_type;
  
      if (is_volume(ctl->info->id.name, &type)) {
          ALOGV("capability: volume\n");
          tlv = calloc(1, DEFAULT_TLV_SIZE);
          if (tlv == NULL) {
              ALOGE("failed to allocate memory\n");
          } else if (!mixer_ctl_read_tlv(ctl, tlv, &min, &max, &tlv_type)) {
              ALOGV("min = %x max = %x", min, max);
              if (set_volume_simple(ctl, argv, min, max, count))
                  mixer_ctl_mulvalues(ctl, count, argv);
          } else
              ALOGV("mixer_ctl_read_tlv failed\n");
          free(tlv);
      } else {
          mixer_ctl_mulvalues(ctl, count, argv);
      }
      return 0;
  }
  
  
  int mixer_ctl_select(struct mixer_ctl *ctl, const char *value)
  {
      unsigned n, max;
      struct snd_ctl_elem_value ev;
      unsigned int  input_str_len, str_len;
  
      if (ctl->info->type != SNDRV_CTL_ELEM_TYPE_ENUMERATED) {
          errno = EINVAL;
          return -1;
      }
  
      input_str_len =  strnlen(value,64);
  
      max = ctl->info->value.enumerated.items;
      for (n = 0; n < max; n++) {
  
          str_len = strnlen(ctl->ename[n], 64);
          if (str_len < input_str_len)
              str_len = input_str_len;
  
          if (!strncmp(value, ctl->ename[n], str_len)) {
              memset(&ev, 0, sizeof(ev));
              ev.value.enumerated.item[0] = n;
              ev.id.numid = ctl->info->id.numid;
              if (ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_WRITE, &ev) < 0)
                  return -1;
              return 0;
          }
      }
  
      errno = EINVAL;
      return errno;
  }
  