modules/usbaudio/alsa_device_profile.c

   1 /*
   2  * Copyright (C) 2014 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #define LOG_TAG "alsa_device_profile"
  18 /*#define LOG_NDEBUG 0*/
  19 /*#define LOG_PCM_PARAMS 0*/
  20
  21 #include <errno.h>
  22 #include <inttypes.h>
  23 #include <stdint.h>
  24 #include <stdlib.h>
  25
  26 #include <log/log.h>
  27
  28 #include "alsa_device_profile.h"
  29 #include "format.h"
  30 #include "logging.h"
  31
  32 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
  33
  34 /*TODO - Evaluate if this value should/can be retrieved from a device-specific property */
  35 #define BUFF_DURATION_MS   5
  36
  37 #define DEFAULT_PERIOD_SIZE 1024
  38
  39 static const char * const format_string_map[] = {
  40     "AUDIO_FORMAT_PCM_16_BIT",      /* "PCM_FORMAT_S16_LE", */
  41     "AUDIO_FORMAT_PCM_32_BIT",      /* "PCM_FORMAT_S32_LE", */
  42     "AUDIO_FORMAT_PCM_8_BIT",       /* "PCM_FORMAT_S8", */
  43     "AUDIO_FORMAT_PCM_8_24_BIT",    /* "PCM_FORMAT_S24_LE", */
  44     "AUDIO_FORMAT_PCM_24_BIT_PACKED"/* "PCM_FORMAT_S24_3LE" */
  45 };
  46
  47 static const unsigned const format_byte_size_map[] = {
  48     2, /* PCM_FORMAT_S16_LE */
  49     4, /* PCM_FORMAT_S32_LE */
  50     1, /* PCM_FORMAT_S8 */
  51     4, /* PCM_FORMAT_S24_LE */
  52     3, /* PCM_FORMAT_S24_3LE */
  53 };
  54
  55 extern int8_t const pcm_format_value_map[50];
  56
  57 /* sort these highest -> lowest (to default to best quality) */
  58 static const unsigned std_sample_rates[] =
  59     {48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000};
  60
  61 void profile_init(alsa_device_profile* profile, int direction)
  62 {
  63     profile->card = profile->device = -1;
  64     profile->direction = direction;
  65
  66     /* Fill the attribute arrays with invalid values */
  67     size_t index;
  68     for (index = 0; index < ARRAY_SIZE(profile->formats); index++) {
  69         profile->formats[index] = PCM_FORMAT_INVALID;
  70     }
  71
  72     for (index = 0; index < ARRAY_SIZE(profile->sample_rates); index++) {
  73         profile->sample_rates[index] = 0;
  74     }
  75
  76     for (index = 0; index < ARRAY_SIZE(profile->channel_counts); index++) {
  77         profile->channel_counts[index] = 0;
  78     }
  79
  80     profile->min_period_size = profile->max_period_size = 0;
  81     profile->min_channel_count = profile->max_channel_count = DEFAULT_CHANNEL_COUNT;
  82
  83     profile->is_valid = false;
  84 }
  85
  86 bool profile_is_initialized(alsa_device_profile* profile)
  87 {
  88     return profile->card >= 0 && profile->device >= 0;
  89 }
  90
  91 bool profile_is_valid(alsa_device_profile* profile) {
  92     return profile->is_valid;
  93 }
  94
  95 /*
  96  * Returns the supplied value rounded up to the next even multiple of 16
  97  */
  98 static unsigned int round_to_16_mult(unsigned int size)
  99 {
 100     return (size + 15) & ~15;   // 0xFFFFFFF0;
 101 }
 102
 103 /*
 104  * Returns the system defined minimum period size based on the supplied sample rate.
 105  */
 106 unsigned profile_calc_min_period_size(alsa_device_profile* profile, unsigned sample_rate)
 107 {
 108     ALOGV("profile_calc_min_period_size(%p, rate:%d)", profile, sample_rate);
 109     if (profile == NULL) {
 110         return DEFAULT_PERIOD_SIZE;
 111     } else {
 112         unsigned num_sample_frames = (sample_rate * BUFF_DURATION_MS) / 1000;
 113         if (num_sample_frames < profile->min_period_size) {
 114             num_sample_frames = profile->min_period_size;
 115         }
 116         return round_to_16_mult(num_sample_frames) * 2;
 117     }
 118 }
 119
 120 unsigned int profile_get_period_size(alsa_device_profile* profile, unsigned sample_rate)
 121 {
 122     // return profile->default_config.period_size;
 123     unsigned int period_size = profile_calc_min_period_size(profile, sample_rate);
 124     ALOGV("profile_get_period_size(rate:%d) = %d", sample_rate, period_size);
 125     return period_size;
 126 }
 127
 128 /*
 129  * Sample Rate
 130  */
 131 unsigned profile_get_default_sample_rate(alsa_device_profile* profile)
 132 {
 133     /*
 134      * TODO this won't be right in general. we should store a preferred rate as we are scanning.
 135      * But right now it will return the highest rate, which may be correct.
 136      */
 137     return profile_is_valid(profile) ? profile->sample_rates[0] : DEFAULT_SAMPLE_RATE;
 138 }
 139
 140 bool profile_is_sample_rate_valid(alsa_device_profile* profile, unsigned rate)
 141 {
 142     if (profile_is_valid(profile)) {
 143         size_t index;
 144         for (index = 0; profile->sample_rates[index] != 0; index++) {
 145             if (profile->sample_rates[index] == rate) {
 146                 return true;
 147             }
 148         }
 149
 150         return false;
 151     } else {
 152         return rate == DEFAULT_SAMPLE_RATE;
 153     }
 154 }
 155
 156 /*
 157  * Format
 158  */
 159 enum pcm_format profile_get_default_format(alsa_device_profile* profile)
 160 {
 161     /*
 162      * TODO this won't be right in general. we should store a preferred format as we are scanning.
 163      */
 164     return profile_is_valid(profile) ? profile->formats[0] : DEFAULT_SAMPLE_FORMAT;
 165 }
 166
 167 bool profile_is_format_valid(alsa_device_profile* profile, enum pcm_format fmt) {
 168     if (profile_is_valid(profile)) {
 169         size_t index;
 170         for (index = 0; profile->formats[index] != PCM_FORMAT_INVALID; index++) {
 171             if (profile->formats[index] == fmt) {
 172                 return true;
 173             }
 174         }
 175
 176         return false;
 177     } else {
 178         return fmt == DEFAULT_SAMPLE_FORMAT;
 179     }
 180 }
 181
 182 /*
 183  * Channels
 184  */
 185 unsigned profile_get_default_channel_count(alsa_device_profile* profile)
 186 {
 187     return profile_is_valid(profile) ? profile->channel_counts[0] : DEFAULT_CHANNEL_COUNT;
 188 }
 189
 190 bool profile_is_channel_count_valid(alsa_device_profile* profile, unsigned count)
 191 {
 192     if (profile_is_initialized(profile)) {
 193         return count >= profile->min_channel_count && count <= profile->max_channel_count;
 194     } else {
 195         return count == DEFAULT_CHANNEL_COUNT;
 196     }
 197 }
 198
 199 static bool profile_test_sample_rate(alsa_device_profile* profile, unsigned rate)
 200 {
 201     struct pcm_config config = profile->default_config;
 202     config.rate = rate;
 203
 204     bool works = false; /* let's be pessimistic */
 205     struct pcm * pcm = pcm_open(profile->card, profile->device,
 206                                 profile->direction, &config);
 207
 208     if (pcm != NULL) {
 209         works = pcm_is_ready(pcm);
 210         pcm_close(pcm);
 211     }
 212
 213     return works;
 214 }
 215
 216 static unsigned profile_enum_sample_rates(alsa_device_profile* profile, unsigned min, unsigned max)
 217 {
 218     unsigned num_entries = 0;
 219     unsigned index;
 220
 221     for (index = 0; index < ARRAY_SIZE(std_sample_rates) &&
 222                     num_entries < ARRAY_SIZE(profile->sample_rates) - 1;
 223          index++) {
 224         if (std_sample_rates[index] >= min && std_sample_rates[index] <= max
 225                 && profile_test_sample_rate(profile, std_sample_rates[index])) {
 226             profile->sample_rates[num_entries++] = std_sample_rates[index];
 227         }
 228     }
 229
 230     return num_entries; /* return # of supported rates */
 231 }
 232
 233 static unsigned profile_enum_sample_formats(alsa_device_profile* profile, struct pcm_mask * mask)
 234 {
 235     const int num_slots = ARRAY_SIZE(mask->bits);
 236     const int bits_per_slot = sizeof(mask->bits[0]) * 8;
 237
 238     const int table_size = ARRAY_SIZE(pcm_format_value_map);
 239
 240     int slot_index, bit_index, table_index;
 241     table_index = 0;
 242     int num_written = 0;
 243     for (slot_index = 0; slot_index < num_slots && table_index < table_size;
 244             slot_index++) {
 245         unsigned bit_mask = 1;
 246         for (bit_index = 0;
 247                 bit_index < bits_per_slot && table_index < table_size;
 248                 bit_index++) {
 249             if ((mask->bits[slot_index] & bit_mask) != 0) {
 250                 enum pcm_format format = pcm_format_value_map[table_index];
 251                 /* Never return invalid (unrecognized) or 8-bit */
 252                 if (format != PCM_FORMAT_INVALID && format != PCM_FORMAT_S8) {
 253                     profile->formats[num_written++] = format;
 254                     if (num_written == ARRAY_SIZE(profile->formats) - 1) {
 255                         /* leave at least one PCM_FORMAT_INVALID at the end */
 256                         return num_written;
 257                     }
 258                 }
 259             }
 260             bit_mask <<= 1;
 261             table_index++;
 262         }
 263     }
 264
 265     return num_written;
 266 }
 267
 268 static unsigned profile_enum_channel_counts(alsa_device_profile* profile, unsigned min, unsigned max)
 269 {
 270     // TODO: Don't return MONO even if the device supports it. This causes problems
 271     // in AudioPolicyManager. Revisit.
 272     static const unsigned std_out_channel_counts[] = {8, 4, 2/*, 1*/};
 273     static const unsigned std_in_channel_counts[] = {8, 4, 2, 1};
 274
 275     unsigned * channel_counts =
 276         profile->direction == PCM_OUT ? std_out_channel_counts : std_in_channel_counts;
 277     unsigned num_channel_counts =
 278         profile->direction == PCM_OUT
 279             ? ARRAY_SIZE(std_out_channel_counts) : ARRAY_SIZE(std_in_channel_counts);
 280
 281     unsigned num_counts = 0;
 282     unsigned index;
 283     /* TODO write a profile_test_channel_count() */
 284     /* Ensure there is at least one invalid channel count to terminate the channel counts array */
 285     for (index = 0; index < num_channel_counts &&
 286                     num_counts < ARRAY_SIZE(profile->channel_counts) - 1;
 287          index++) {
 288         /* TODO Do we want a channel counts test? */
 289         if (channel_counts[index] >= min && channel_counts[index] <= max /* &&
 290             profile_test_channel_count(profile, channel_counts[index])*/) {
 291             profile->channel_counts[num_counts++] = channel_counts[index];
 292         }
 293     }
 294
 295     return num_counts; /* return # of supported counts */
 296 }
 297
 298 /*
 299  * Reads and decodes configuration info from the specified ALSA card/device.
 300  */
 301 static int read_alsa_device_config(alsa_device_profile * profile, struct pcm_config * config)
 302 {
 303     ALOGV("usb:audio_hw - read_alsa_device_config(c:%d d:%d t:0x%X)",
 304           profile->card, profile->device, profile->direction);
 305
 306     if (profile->card < 0 || profile->device < 0) {
 307         return -EINVAL;
 308     }
 309
 310     struct pcm_params * alsa_hw_params =
 311         pcm_params_get(profile->card, profile->device, profile->direction);
 312     if (alsa_hw_params == NULL) {
 313         return -EINVAL;
 314     }
 315
 316     profile->min_period_size = pcm_params_get_min(alsa_hw_params, PCM_PARAM_PERIOD_SIZE);
 317     profile->max_period_size = pcm_params_get_max(alsa_hw_params, PCM_PARAM_PERIOD_SIZE);
 318
 319     profile->min_channel_count = pcm_params_get_min(alsa_hw_params, PCM_PARAM_CHANNELS);
 320     profile->max_channel_count = pcm_params_get_max(alsa_hw_params, PCM_PARAM_CHANNELS);
 321
 322     int ret = 0;
 323
 324     /*
 325      * This Logging will be useful when testing new USB devices.
 326      */
 327 #ifdef LOG_PCM_PARAMS
 328     log_pcm_params(alsa_hw_params);
 329 #endif
 330
 331     config->channels = pcm_params_get_min(alsa_hw_params, PCM_PARAM_CHANNELS);
 332     config->rate = pcm_params_get_min(alsa_hw_params, PCM_PARAM_RATE);
 333     config->period_size = profile_calc_min_period_size(profile, config->rate);
 334     config->period_count = pcm_params_get_min(alsa_hw_params, PCM_PARAM_PERIODS);
 335     config->format = get_pcm_format_for_mask(pcm_params_get_mask(alsa_hw_params, PCM_PARAM_FORMAT));
 336 #ifdef LOG_PCM_PARAMS
 337     log_pcm_config(config, "read_alsa_device_config");
 338 #endif
 339     if (config->format == PCM_FORMAT_INVALID) {
 340         ret = -EINVAL;
 341     }
 342
 343     pcm_params_free(alsa_hw_params);
 344
 345     return ret;
 346 }
 347
 348 bool profile_read_device_info(alsa_device_profile* profile)
 349 {
 350     if (!profile_is_initialized(profile)) {
 351         return false;
 352     }
 353
 354     /* let's get some defaults */
 355     read_alsa_device_config(profile, &profile->default_config);
 356     ALOGV("default_config chans:%d rate:%d format:%d count:%d size:%d",
 357           profile->default_config.channels, profile->default_config.rate,
 358           profile->default_config.format, profile->default_config.period_count,
 359           profile->default_config.period_size);
 360
 361     struct pcm_params * alsa_hw_params = pcm_params_get(profile->card,
 362                                                         profile->device,
 363                                                         profile->direction);
 364     if (alsa_hw_params == NULL) {
 365         return false;
 366     }
 367
 368     /* Formats */
 369     struct pcm_mask * format_mask = pcm_params_get_mask(alsa_hw_params, PCM_PARAM_FORMAT);
 370     profile_enum_sample_formats(profile, format_mask);
 371
 372     /* Channels */
 373     profile_enum_channel_counts(
 374             profile, pcm_params_get_min(alsa_hw_params, PCM_PARAM_CHANNELS),
 375             pcm_params_get_max(alsa_hw_params, PCM_PARAM_CHANNELS));
 376
 377     /* Sample Rates */
 378     profile_enum_sample_rates(
 379             profile, pcm_params_get_min(alsa_hw_params, PCM_PARAM_RATE),
 380             pcm_params_get_max(alsa_hw_params, PCM_PARAM_RATE));
 381
 382     profile->is_valid = true;
 383
 384     return true;
 385 }
 386
 387 char * profile_get_sample_rate_strs(alsa_device_profile* profile)
 388 {
 389     char buffer[128];
 390     buffer[0] = '\0';
 391     int buffSize = ARRAY_SIZE(buffer);
 392
 393     char numBuffer[32];
 394
 395     int numEntries = 0;
 396     unsigned index;
 397     for (index = 0; profile->sample_rates[index] != 0; index++) {
 398         if (numEntries++ != 0) {
 399             strncat(buffer, "|", buffSize);
 400         }
 401         snprintf(numBuffer, sizeof(numBuffer), "%u", profile->sample_rates[index]);
 402         strncat(buffer, numBuffer, buffSize);
 403     }
 404
 405     return strdup(buffer);
 406 }
 407
 408 char * profile_get_format_strs(alsa_device_profile* profile)
 409 {
 410     /* TODO remove this hack when we have support for input in non PCM16 formats */
 411     if (profile->direction == PCM_IN) {
 412         return strdup("AUDIO_FORMAT_PCM_16_BIT");
 413     }
 414
 415     char buffer[128];
 416     buffer[0] = '\0';
 417     int buffSize = ARRAY_SIZE(buffer);
 418
 419     int numEntries = 0;
 420     unsigned index = 0;
 421     for (index = 0; profile->formats[index] != PCM_FORMAT_INVALID; index++) {
 422         if (numEntries++ != 0) {
 423             strncat(buffer, "|", buffSize);
 424         }
 425         strncat(buffer, format_string_map[profile->formats[index]], buffSize);
 426     }
 427
 428     return strdup(buffer);
 429 }
 430
 431 char * profile_get_channel_count_strs(alsa_device_profile* profile)
 432 {
 433     static const char * const out_chans_strs[] = {
 434         /* 0 */"AUDIO_CHANNEL_NONE", /* will never be taken as this is a terminator */
 435         /* 1 */"AUDIO_CHANNEL_OUT_MONO",
 436         /* 2 */"AUDIO_CHANNEL_OUT_STEREO",
 437         /* 3 */ /* "AUDIO_CHANNEL_OUT_STEREO|AUDIO_CHANNEL_OUT_FRONT_CENTER" */ NULL,
 438         /* 4 */"AUDIO_CHANNEL_OUT_QUAD",
 439         /* 5 */ /* "AUDIO_CHANNEL_OUT_QUAD|AUDIO_CHANNEL_OUT_FRONT_CENTER" */ NULL,
 440         /* 6 */"AUDIO_CHANNEL_OUT_5POINT1",
 441         /* 7 */ /* "AUDIO_CHANNEL_OUT_5POINT1|AUDIO_CHANNEL_OUT_BACK_CENTER" */ NULL,
 442         /* 8 */"AUDIO_CHANNEL_OUT_7POINT1",
 443         /* channel counts greater than this not considered */
 444     };
 445
 446     static const char * const in_chans_strs[] = {
 447         /* 0 */"AUDIO_CHANNEL_NONE", /* will never be taken as this is a terminator */
 448         /* 1 */"AUDIO_CHANNEL_IN_MONO",
 449         /* 2 */"AUDIO_CHANNEL_IN_STEREO",
 450         /* channel counts greater than this not considered */
 451     };
 452
 453     const bool isOutProfile = profile->direction == PCM_OUT;
 454     const char * const * const names_array = isOutProfile ? out_chans_strs : in_chans_strs;
 455     const size_t names_size = isOutProfile ? ARRAY_SIZE(out_chans_strs)
 456             : ARRAY_SIZE(in_chans_strs);
 457
 458     char buffer[256]; /* caution, may need to be expanded */
 459     buffer[0] = '\0';
 460     const int buffer_size = ARRAY_SIZE(buffer);
 461     int num_entries = 0;
 462     bool stereo_allowed = false;
 463     unsigned index;
 464     unsigned channel_count;
 465
 466     for (index = 0; (channel_count = profile->channel_counts[index]) != 0; index++) {
 467         stereo_allowed = stereo_allowed || channel_count == 2;
 468         if (channel_count < names_size && names_array[channel_count] != NULL) {
 469             if (num_entries++ != 0) {
 470                 strncat(buffer, "|", buffer_size);
 471             }
 472             strncat(buffer, names_array[channel_count], buffer_size);
 473         }
 474     }
 475     /* emulated modes:
 476      * always expose stereo as we can emulate it for PCM_OUT
 477      */
 478     if (!stereo_allowed && isOutProfile) {
 479         if (num_entries++ != 0) {
 480             strncat(buffer, "|", buffer_size);
 481         }
 482         strncat(buffer, names_array[2], buffer_size); /* stereo */
 483     }
 484     return strdup(buffer);
 485 }