Merge "Add pcm_params_set_min/max and update comments"
authorPaul McLean <pmclean@google.com>
Tue, 1 Apr 2014 15:45:24 +0000 (15:45 +0000)
committerAndroid (Google) Code Review <android-gerrit@google.com>
Tue, 1 Apr 2014 15:45:24 +0000 (15:45 +0000)
1  2 
include/tinyalsa/asoundlib.h
pcm.c

index 1083dbaeccec3e3075eb9c061054d486b33799e1,392e4970c52f91719c9873d3561078f1f13f2ed7..de9dde7999201e0940aaad1294ffb6b4d4ac2268
@@@ -158,27 -158,16 +158,31 @@@ struct pcm_params *pcm_params_get(unsig
  void pcm_params_free(struct pcm_params *pcm_params);
  
  struct pcm_mask *pcm_params_get_mask(struct pcm_params *pcm_params,
 -        enum pcm_param param);
 +                                     enum pcm_param param);
  unsigned int pcm_params_get_min(struct pcm_params *pcm_params,
                                  enum pcm_param param);
+ void pcm_params_set_min(struct pcm_params *pcm_params,
+                                 enum pcm_param param, unsigned int val);
  unsigned int pcm_params_get_max(struct pcm_params *pcm_params,
                                  enum pcm_param param);
+ void pcm_params_set_max(struct pcm_params *pcm_params,
+                                 enum pcm_param param, unsigned int val);
  
 +/* Converts the pcm parameters to a human readable string.
 + * The string parameter is a caller allocated buffer of size bytes,
 + * which is then filled up to size - 1 and null terminated,
 + * if size is greater than zero.
 + * The return value is the number of bytes copied to string
 + * (not including null termination) if less than size; otherwise,
 + * the number of bytes required for the buffer.
 + */
 +int pcm_params_to_string(struct pcm_params *params, char *string, unsigned int size);
 +
 +/* Returns 1 if the pcm_format is present (format bit set) in
 + * the pcm_params structure; 0 otherwise, or upon unrecognized format.
 + */
 +int pcm_params_format_test(struct pcm_params *params, enum pcm_format format);
 +
  /* Set and get config */
  int pcm_get_config(struct pcm *pcm, struct pcm_config *config);
  int pcm_set_config(struct pcm *pcm, struct pcm_config *config);
diff --cc pcm.c
index 5ec68ec1831ac3bd5f3d341c284ea4f86134f192,662e8a1d96390ef8161b692ef21fbeaf5c086fc9..6d85839107f92050fd55ec7672a0bf78569b12d9
--- 1/pcm.c
--- 2/pcm.c
+++ b/pcm.c
@@@ -689,87 -635,22 +713,103 @@@ unsigned int pcm_params_get_max(struct 
      return param_get_max(params, p);
  }
  
+ void pcm_params_set_max(struct pcm_params *pcm_params,
+                                 enum pcm_param param, unsigned int val)
+ {
+     struct snd_pcm_hw_params *params = (struct snd_pcm_hw_params *)pcm_params;
+     int p;
+     if (!params)
+         return;
+     p = pcm_param_to_alsa(param);
+     if (p < 0)
+         return;
+     param_set_max(params, p, val);
+ }
 +static int pcm_mask_test(struct pcm_mask *m, unsigned int index)
 +{
 +    const unsigned int bitshift = 5; /* for 32 bit integer */
 +    const unsigned int bitmask = (1 << bitshift) - 1;
 +    unsigned int element;
 +
 +    element = index >> bitshift;
 +    if (element >= ARRAY_SIZE(m->bits))
 +        return 0; /* for safety, but should never occur */
 +    return (m->bits[element] >> (index & bitmask)) & 1;
 +}
 +
 +static int pcm_mask_to_string(struct pcm_mask *m, char *string, unsigned int size,
 +                              char *mask_name,
 +                              const char * const *bit_array_name, size_t bit_array_size)
 +{
 +    unsigned int i;
 +    unsigned int offset = 0;
 +
 +    if (m == NULL)
 +        return 0;
 +    if (bit_array_size < 32) {
 +        STRLOG(string, offset, size, "%12s:\t%#08x\n", mask_name, m->bits[0]);
 +    } else { /* spans two or more bitfields, print with an array index */
 +        for (i = 0; i < (bit_array_size + 31) >> 5; ++i) {
 +            STRLOG(string, offset, size, "%9s[%d]:\t%#08x\n",
 +                   mask_name, i, m->bits[i]);
 +        }
 +    }
 +    for (i = 0; i < bit_array_size; ++i) {
 +        if (pcm_mask_test(m, i)) {
 +            STRLOG(string, offset, size, "%12s \t%s\n", "", bit_array_name[i]);
 +        }
 +    }
 +    return offset;
 +}
 +
 +int pcm_params_to_string(struct pcm_params *params, char *string, unsigned int size)
 +{
 +    struct pcm_mask *m;
 +    unsigned int min, max;
 +    unsigned int clipoffset, offset;
 +
 +    m = pcm_params_get_mask(params, PCM_PARAM_ACCESS);
 +    offset = pcm_mask_to_string(m, string, size,
 +                                 "Access", access_lookup, ARRAY_SIZE(access_lookup));
 +    m = pcm_params_get_mask(params, PCM_PARAM_FORMAT);
 +    clipoffset = offset > size ? size : offset;
 +    offset += pcm_mask_to_string(m, string + clipoffset, size - clipoffset,
 +                                 "Format", format_lookup, ARRAY_SIZE(format_lookup));
 +    m = pcm_params_get_mask(params, PCM_PARAM_SUBFORMAT);
 +    clipoffset = offset > size ? size : offset;
 +    offset += pcm_mask_to_string(m, string + clipoffset, size - clipoffset,
 +                                 "Subformat", subformat_lookup, ARRAY_SIZE(subformat_lookup));
 +    min = pcm_params_get_min(params, PCM_PARAM_RATE);
 +    max = pcm_params_get_max(params, PCM_PARAM_RATE);
 +    STRLOG(string, offset, size, "        Rate:\tmin=%uHz\tmax=%uHz\n", min, max);
 +    min = pcm_params_get_min(params, PCM_PARAM_CHANNELS);
 +    max = pcm_params_get_max(params, PCM_PARAM_CHANNELS);
 +    STRLOG(string, offset, size, "    Channels:\tmin=%u\t\tmax=%u\n", min, max);
 +    min = pcm_params_get_min(params, PCM_PARAM_SAMPLE_BITS);
 +    max = pcm_params_get_max(params, PCM_PARAM_SAMPLE_BITS);
 +    STRLOG(string, offset, size, " Sample bits:\tmin=%u\t\tmax=%u\n", min, max);
 +    min = pcm_params_get_min(params, PCM_PARAM_PERIOD_SIZE);
 +    max = pcm_params_get_max(params, PCM_PARAM_PERIOD_SIZE);
 +    STRLOG(string, offset, size, " Period size:\tmin=%u\t\tmax=%u\n", min, max);
 +    min = pcm_params_get_min(params, PCM_PARAM_PERIODS);
 +    max = pcm_params_get_max(params, PCM_PARAM_PERIODS);
 +    STRLOG(string, offset, size, "Period count:\tmin=%u\t\tmax=%u\n", min, max);
 +    return offset;
 +}
 +
 +int pcm_params_format_test(struct pcm_params *params, enum pcm_format format)
 +{
 +    unsigned int alsa_format = pcm_format_to_alsa(format);
 +
 +    if (alsa_format == SNDRV_PCM_FORMAT_S16_LE && format != PCM_FORMAT_S16_LE)
 +        return 0; /* caution: format not recognized is equivalent to S16_LE */
 +    return pcm_mask_test(pcm_params_get_mask(params, PCM_PARAM_FORMAT), alsa_format);
 +}
 +
  int pcm_close(struct pcm *pcm)
  {
      if (pcm == &bad_pcm)