sound/core/pcm

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
snd_pcm_format_signed
snd_pcm_format_unsigned
snd_pcm_format_linear
snd_pcm_format_little_endian
snd_pcm_format_big_endian
snd_pcm_format_width
snd_pcm_format_physical_width
snd_pcm_format_size
snd_pcm_format_silence_64
snd_pcm_format_set_silence
snd_pcm_limit_hw_rates
snd_pcm_rate_to_rate_bit
snd_pcm_rate_bit_to_rate
snd_pcm_rate_mask_sanitize
snd_pcm_rate_mask_intersect
snd_pcm_rate_range_to_bits
   1 /*
   2  *  PCM Interface - misc routines
   3  *  Copyright (c) 1998 by Jaroslav Kysela <perex@perex.cz>
   4  *
   5  *
   6  *   This library is free software; you can redistribute it and/or modify
   7  *   it under the terms of the GNU Library General Public License as
   8  *   published by the Free Software Foundation; either version 2 of
   9  *   the License, or (at your option) any later version.
  10  *
  11  *   This program is distributed in the hope that it will be useful,
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *   GNU Library General Public License for more details.
  15  *
  16  *   You should have received a copy of the GNU Library General Public
  17  *   License along with this library; if not, write to the Free Software
  18  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19  *
  20  */
  21   
  22 #include <linux/time.h>
  23 #include <linux/export.h>
  24 #include <sound/core.h>
  25 #include <sound/pcm.h>
  26 
  27 #include "pcm_local.h"
  28 
  29 #define SND_PCM_FORMAT_UNKNOWN (-1)
  30 
  31 /* NOTE: "signed" prefix must be given below since the default char is
  32  *       unsigned on some architectures!
  33  */
  34 struct pcm_format_data {
  35         unsigned char width;    /* bit width */
  36         unsigned char phys;     /* physical bit width */
  37         signed char le; /* 0 = big-endian, 1 = little-endian, -1 = others */
  38         signed char signd;      /* 0 = unsigned, 1 = signed, -1 = others */
  39         unsigned char silence[8];       /* silence data to fill */
  40 };
  41 
  42 /* we do lots of calculations on snd_pcm_format_t; shut up sparse */
  43 #define INT     __force int
  44 
  45 static struct pcm_format_data pcm_formats[(INT)SNDRV_PCM_FORMAT_LAST+1] = {
  46         [SNDRV_PCM_FORMAT_S8] = {
  47                 .width = 8, .phys = 8, .le = -1, .signd = 1,
  48                 .silence = {},
  49         },
  50         [SNDRV_PCM_FORMAT_U8] = {
  51                 .width = 8, .phys = 8, .le = -1, .signd = 0,
  52                 .silence = { 0x80 },
  53         },
  54         [SNDRV_PCM_FORMAT_S16_LE] = {
  55                 .width = 16, .phys = 16, .le = 1, .signd = 1,
  56                 .silence = {},
  57         },
  58         [SNDRV_PCM_FORMAT_S16_BE] = {
  59                 .width = 16, .phys = 16, .le = 0, .signd = 1,
  60                 .silence = {},
  61         },
  62         [SNDRV_PCM_FORMAT_U16_LE] = {
  63                 .width = 16, .phys = 16, .le = 1, .signd = 0,
  64                 .silence = { 0x00, 0x80 },
  65         },
  66         [SNDRV_PCM_FORMAT_U16_BE] = {
  67                 .width = 16, .phys = 16, .le = 0, .signd = 0,
  68                 .silence = { 0x80, 0x00 },
  69         },
  70         [SNDRV_PCM_FORMAT_S24_LE] = {
  71                 .width = 24, .phys = 32, .le = 1, .signd = 1,
  72                 .silence = {},
  73         },
  74         [SNDRV_PCM_FORMAT_S24_BE] = {
  75                 .width = 24, .phys = 32, .le = 0, .signd = 1,
  76                 .silence = {},
  77         },
  78         [SNDRV_PCM_FORMAT_U24_LE] = {
  79                 .width = 24, .phys = 32, .le = 1, .signd = 0,
  80                 .silence = { 0x00, 0x00, 0x80 },
  81         },
  82         [SNDRV_PCM_FORMAT_U24_BE] = {
  83                 .width = 24, .phys = 32, .le = 0, .signd = 0,
  84                 .silence = { 0x00, 0x80, 0x00, 0x00 },
  85         },
  86         [SNDRV_PCM_FORMAT_S32_LE] = {
  87                 .width = 32, .phys = 32, .le = 1, .signd = 1,
  88                 .silence = {},
  89         },
  90         [SNDRV_PCM_FORMAT_S32_BE] = {
  91                 .width = 32, .phys = 32, .le = 0, .signd = 1,
  92                 .silence = {},
  93         },
  94         [SNDRV_PCM_FORMAT_U32_LE] = {
  95                 .width = 32, .phys = 32, .le = 1, .signd = 0,
  96                 .silence = { 0x00, 0x00, 0x00, 0x80 },
  97         },
  98         [SNDRV_PCM_FORMAT_U32_BE] = {
  99                 .width = 32, .phys = 32, .le = 0, .signd = 0,
 100                 .silence = { 0x80, 0x00, 0x00, 0x00 },
 101         },
 102         [SNDRV_PCM_FORMAT_FLOAT_LE] = {
 103                 .width = 32, .phys = 32, .le = 1, .signd = -1,
 104                 .silence = {},
 105         },
 106         [SNDRV_PCM_FORMAT_FLOAT_BE] = {
 107                 .width = 32, .phys = 32, .le = 0, .signd = -1,
 108                 .silence = {},
 109         },
 110         [SNDRV_PCM_FORMAT_FLOAT64_LE] = {
 111                 .width = 64, .phys = 64, .le = 1, .signd = -1,
 112                 .silence = {},
 113         },
 114         [SNDRV_PCM_FORMAT_FLOAT64_BE] = {
 115                 .width = 64, .phys = 64, .le = 0, .signd = -1,
 116                 .silence = {},
 117         },
 118         [SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE] = {
 119                 .width = 32, .phys = 32, .le = 1, .signd = -1,
 120                 .silence = {},
 121         },
 122         [SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE] = {
 123                 .width = 32, .phys = 32, .le = 0, .signd = -1,
 124                 .silence = {},
 125         },
 126         [SNDRV_PCM_FORMAT_MU_LAW] = {
 127                 .width = 8, .phys = 8, .le = -1, .signd = -1,
 128                 .silence = { 0x7f },
 129         },
 130         [SNDRV_PCM_FORMAT_A_LAW] = {
 131                 .width = 8, .phys = 8, .le = -1, .signd = -1,
 132                 .silence = { 0x55 },
 133         },
 134         [SNDRV_PCM_FORMAT_IMA_ADPCM] = {
 135                 .width = 4, .phys = 4, .le = -1, .signd = -1,
 136                 .silence = {},
 137         },
 138         [SNDRV_PCM_FORMAT_G723_24] = {
 139                 .width = 3, .phys = 3, .le = -1, .signd = -1,
 140                 .silence = {},
 141         },
 142         [SNDRV_PCM_FORMAT_G723_40] = {
 143                 .width = 5, .phys = 5, .le = -1, .signd = -1,
 144                 .silence = {},
 145         },
 146         [SNDRV_PCM_FORMAT_DSD_U8] = {
 147                 .width = 8, .phys = 8, .le = 1, .signd = 0,
 148                 .silence = { 0x69 },
 149         },
 150         [SNDRV_PCM_FORMAT_DSD_U16_LE] = {
 151                 .width = 16, .phys = 16, .le = 1, .signd = 0,
 152                 .silence = { 0x69, 0x69 },
 153         },
 154         [SNDRV_PCM_FORMAT_DSD_U32_LE] = {
 155                 .width = 32, .phys = 32, .le = 1, .signd = 0,
 156                 .silence = { 0x69, 0x69, 0x69, 0x69 },
 157         },
 158         [SNDRV_PCM_FORMAT_DSD_U16_BE] = {
 159                 .width = 16, .phys = 16, .le = 0, .signd = 0,
 160                 .silence = { 0x69, 0x69 },
 161         },
 162         [SNDRV_PCM_FORMAT_DSD_U32_BE] = {
 163                 .width = 32, .phys = 32, .le = 0, .signd = 0,
 164                 .silence = { 0x69, 0x69, 0x69, 0x69 },
 165         },
 166         /* FIXME: the following two formats are not defined properly yet */
 167         [SNDRV_PCM_FORMAT_MPEG] = {
 168                 .le = -1, .signd = -1,
 169         },
 170         [SNDRV_PCM_FORMAT_GSM] = {
 171                 .le = -1, .signd = -1,
 172         },
 173         [SNDRV_PCM_FORMAT_S20_LE] = {
 174                 .width = 20, .phys = 32, .le = 1, .signd = 1,
 175                 .silence = {},
 176         },
 177         [SNDRV_PCM_FORMAT_S20_BE] = {
 178                 .width = 20, .phys = 32, .le = 0, .signd = 1,
 179                 .silence = {},
 180         },
 181         [SNDRV_PCM_FORMAT_U20_LE] = {
 182                 .width = 20, .phys = 32, .le = 1, .signd = 0,
 183                 .silence = { 0x00, 0x00, 0x08, 0x00 },
 184         },
 185         [SNDRV_PCM_FORMAT_U20_BE] = {
 186                 .width = 20, .phys = 32, .le = 0, .signd = 0,
 187                 .silence = { 0x00, 0x08, 0x00, 0x00 },
 188         },
 189         /* FIXME: the following format is not defined properly yet */
 190         [SNDRV_PCM_FORMAT_SPECIAL] = {
 191                 .le = -1, .signd = -1,
 192         },
 193         [SNDRV_PCM_FORMAT_S24_3LE] = {
 194                 .width = 24, .phys = 24, .le = 1, .signd = 1,
 195                 .silence = {},
 196         },
 197         [SNDRV_PCM_FORMAT_S24_3BE] = {
 198                 .width = 24, .phys = 24, .le = 0, .signd = 1,
 199                 .silence = {},
 200         },
 201         [SNDRV_PCM_FORMAT_U24_3LE] = {
 202                 .width = 24, .phys = 24, .le = 1, .signd = 0,
 203                 .silence = { 0x00, 0x00, 0x80 },
 204         },
 205         [SNDRV_PCM_FORMAT_U24_3BE] = {
 206                 .width = 24, .phys = 24, .le = 0, .signd = 0,
 207                 .silence = { 0x80, 0x00, 0x00 },
 208         },
 209         [SNDRV_PCM_FORMAT_S20_3LE] = {
 210                 .width = 20, .phys = 24, .le = 1, .signd = 1,
 211                 .silence = {},
 212         },
 213         [SNDRV_PCM_FORMAT_S20_3BE] = {
 214                 .width = 20, .phys = 24, .le = 0, .signd = 1,
 215                 .silence = {},
 216         },
 217         [SNDRV_PCM_FORMAT_U20_3LE] = {
 218                 .width = 20, .phys = 24, .le = 1, .signd = 0,
 219                 .silence = { 0x00, 0x00, 0x08 },
 220         },
 221         [SNDRV_PCM_FORMAT_U20_3BE] = {
 222                 .width = 20, .phys = 24, .le = 0, .signd = 0,
 223                 .silence = { 0x08, 0x00, 0x00 },
 224         },
 225         [SNDRV_PCM_FORMAT_S18_3LE] = {
 226                 .width = 18, .phys = 24, .le = 1, .signd = 1,
 227                 .silence = {},
 228         },
 229         [SNDRV_PCM_FORMAT_S18_3BE] = {
 230                 .width = 18, .phys = 24, .le = 0, .signd = 1,
 231                 .silence = {},
 232         },
 233         [SNDRV_PCM_FORMAT_U18_3LE] = {
 234                 .width = 18, .phys = 24, .le = 1, .signd = 0,
 235                 .silence = { 0x00, 0x00, 0x02 },
 236         },
 237         [SNDRV_PCM_FORMAT_U18_3BE] = {
 238                 .width = 18, .phys = 24, .le = 0, .signd = 0,
 239                 .silence = { 0x02, 0x00, 0x00 },
 240         },
 241         [SNDRV_PCM_FORMAT_G723_24_1B] = {
 242                 .width = 3, .phys = 8, .le = -1, .signd = -1,
 243                 .silence = {},
 244         },
 245         [SNDRV_PCM_FORMAT_G723_40_1B] = {
 246                 .width = 5, .phys = 8, .le = -1, .signd = -1,
 247                 .silence = {},
 248         },
 249 };
 250 
 251 
 252 /**
 253  * snd_pcm_format_signed - Check the PCM format is signed linear
 254  * @format: the format to check
 255  *
 256  * Return: 1 if the given PCM format is signed linear, 0 if unsigned
 257  * linear, and a negative error code for non-linear formats.
 258  */
 259 int snd_pcm_format_signed(snd_pcm_format_t format)
 260 {
 261         int val;
 262         if ((INT)format < 0 || (INT)format > (INT)SNDRV_PCM_FORMAT_LAST)
 263                 return -EINVAL;
 264         if ((val = pcm_formats[(INT)format].signd) < 0)
 265                 return -EINVAL;
 266         return val;
 267 }
 268 EXPORT_SYMBOL(snd_pcm_format_signed);
 269 
 270 /**
 271  * snd_pcm_format_unsigned - Check the PCM format is unsigned linear
 272  * @format: the format to check
 273  *
 274  * Return: 1 if the given PCM format is unsigned linear, 0 if signed
 275  * linear, and a negative error code for non-linear formats.
 276  */
 277 int snd_pcm_format_unsigned(snd_pcm_format_t format)
 278 {
 279         int val;
 280 
 281         val = snd_pcm_format_signed(format);
 282         if (val < 0)
 283                 return val;
 284         return !val;
 285 }
 286 EXPORT_SYMBOL(snd_pcm_format_unsigned);
 287 
 288 /**
 289  * snd_pcm_format_linear - Check the PCM format is linear
 290  * @format: the format to check
 291  *
 292  * Return: 1 if the given PCM format is linear, 0 if not.
 293  */
 294 int snd_pcm_format_linear(snd_pcm_format_t format)
 295 {
 296         return snd_pcm_format_signed(format) >= 0;
 297 }
 298 EXPORT_SYMBOL(snd_pcm_format_linear);
 299 
 300 /**
 301  * snd_pcm_format_little_endian - Check the PCM format is little-endian
 302  * @format: the format to check
 303  *
 304  * Return: 1 if the given PCM format is little-endian, 0 if
 305  * big-endian, or a negative error code if endian not specified.
 306  */
 307 int snd_pcm_format_little_endian(snd_pcm_format_t format)
 308 {
 309         int val;
 310         if ((INT)format < 0 || (INT)format > (INT)SNDRV_PCM_FORMAT_LAST)
 311                 return -EINVAL;
 312         if ((val = pcm_formats[(INT)format].le) < 0)
 313                 return -EINVAL;
 314         return val;
 315 }
 316 EXPORT_SYMBOL(snd_pcm_format_little_endian);
 317 
 318 /**
 319  * snd_pcm_format_big_endian - Check the PCM format is big-endian
 320  * @format: the format to check
 321  *
 322  * Return: 1 if the given PCM format is big-endian, 0 if
 323  * little-endian, or a negative error code if endian not specified.
 324  */
 325 int snd_pcm_format_big_endian(snd_pcm_format_t format)
 326 {
 327         int val;
 328 
 329         val = snd_pcm_format_little_endian(format);
 330         if (val < 0)
 331                 return val;
 332         return !val;
 333 }
 334 EXPORT_SYMBOL(snd_pcm_format_big_endian);
 335 
 336 /**
 337  * snd_pcm_format_width - return the bit-width of the format
 338  * @format: the format to check
 339  *
 340  * Return: The bit-width of the format, or a negative error code
 341  * if unknown format.
 342  */
 343 int snd_pcm_format_width(snd_pcm_format_t format)
 344 {
 345         int val;
 346         if ((INT)format < 0 || (INT)format > (INT)SNDRV_PCM_FORMAT_LAST)
 347                 return -EINVAL;
 348         if ((val = pcm_formats[(INT)format].width) == 0)
 349                 return -EINVAL;
 350         return val;
 351 }
 352 EXPORT_SYMBOL(snd_pcm_format_width);
 353 
 354 /**
 355  * snd_pcm_format_physical_width - return the physical bit-width of the format
 356  * @format: the format to check
 357  *
 358  * Return: The physical bit-width of the format, or a negative error code
 359  * if unknown format.
 360  */
 361 int snd_pcm_format_physical_width(snd_pcm_format_t format)
 362 {
 363         int val;
 364         if ((INT)format < 0 || (INT)format > (INT)SNDRV_PCM_FORMAT_LAST)
 365                 return -EINVAL;
 366         if ((val = pcm_formats[(INT)format].phys) == 0)
 367                 return -EINVAL;
 368         return val;
 369 }
 370 EXPORT_SYMBOL(snd_pcm_format_physical_width);
 371 
 372 /**
 373  * snd_pcm_format_size - return the byte size of samples on the given format
 374  * @format: the format to check
 375  * @samples: sampling rate
 376  *
 377  * Return: The byte size of the given samples for the format, or a
 378  * negative error code if unknown format.
 379  */
 380 ssize_t snd_pcm_format_size(snd_pcm_format_t format, size_t samples)
 381 {
 382         int phys_width = snd_pcm_format_physical_width(format);
 383         if (phys_width < 0)
 384                 return -EINVAL;
 385         return samples * phys_width / 8;
 386 }
 387 EXPORT_SYMBOL(snd_pcm_format_size);
 388 
 389 /**
 390  * snd_pcm_format_silence_64 - return the silent data in 8 bytes array
 391  * @format: the format to check
 392  *
 393  * Return: The format pattern to fill or %NULL if error.
 394  */
 395 const unsigned char *snd_pcm_format_silence_64(snd_pcm_format_t format)
 396 {
 397         if ((INT)format < 0 || (INT)format > (INT)SNDRV_PCM_FORMAT_LAST)
 398                 return NULL;
 399         if (! pcm_formats[(INT)format].phys)
 400                 return NULL;
 401         return pcm_formats[(INT)format].silence;
 402 }
 403 EXPORT_SYMBOL(snd_pcm_format_silence_64);
 404 
 405 /**
 406  * snd_pcm_format_set_silence - set the silence data on the buffer
 407  * @format: the PCM format
 408  * @data: the buffer pointer
 409  * @samples: the number of samples to set silence
 410  *
 411  * Sets the silence data on the buffer for the given samples.
 412  *
 413  * Return: Zero if successful, or a negative error code on failure.
 414  */
 415 int snd_pcm_format_set_silence(snd_pcm_format_t format, void *data, unsigned int samples)
 416 {
 417         int width;
 418         unsigned char *dst, *pat;
 419 
 420         if ((INT)format < 0 || (INT)format > (INT)SNDRV_PCM_FORMAT_LAST)
 421                 return -EINVAL;
 422         if (samples == 0)
 423                 return 0;
 424         width = pcm_formats[(INT)format].phys; /* physical width */
 425         pat = pcm_formats[(INT)format].silence;
 426         if (! width)
 427                 return -EINVAL;
 428         /* signed or 1 byte data */
 429         if (pcm_formats[(INT)format].signd == 1 || width <= 8) {
 430                 unsigned int bytes = samples * width / 8;
 431                 memset(data, *pat, bytes);
 432                 return 0;
 433         }
 434         /* non-zero samples, fill using a loop */
 435         width /= 8;
 436         dst = data;
 437 #if 0
 438         while (samples--) {
 439                 memcpy(dst, pat, width);
 440                 dst += width;
 441         }
 442 #else
 443         /* a bit optimization for constant width */
 444         switch (width) {
 445         case 2:
 446                 while (samples--) {
 447                         memcpy(dst, pat, 2);
 448                         dst += 2;
 449                 }
 450                 break;
 451         case 3:
 452                 while (samples--) {
 453                         memcpy(dst, pat, 3);
 454                         dst += 3;
 455                 }
 456                 break;
 457         case 4:
 458                 while (samples--) {
 459                         memcpy(dst, pat, 4);
 460                         dst += 4;
 461                 }
 462                 break;
 463         case 8:
 464                 while (samples--) {
 465                         memcpy(dst, pat, 8);
 466                         dst += 8;
 467                 }
 468                 break;
 469         }
 470 #endif
 471         return 0;
 472 }
 473 EXPORT_SYMBOL(snd_pcm_format_set_silence);
 474 
 475 /**
 476  * snd_pcm_limit_hw_rates - determine rate_min/rate_max fields
 477  * @runtime: the runtime instance
 478  *
 479  * Determines the rate_min and rate_max fields from the rates bits of
 480  * the given runtime->hw.
 481  *
 482  * Return: Zero if successful.
 483  */
 484 int snd_pcm_limit_hw_rates(struct snd_pcm_runtime *runtime)
 485 {
 486         int i;
 487         for (i = 0; i < (int)snd_pcm_known_rates.count; i++) {
 488                 if (runtime->hw.rates & (1 << i)) {
 489                         runtime->hw.rate_min = snd_pcm_known_rates.list[i];
 490                         break;
 491                 }
 492         }
 493         for (i = (int)snd_pcm_known_rates.count - 1; i >= 0; i--) {
 494                 if (runtime->hw.rates & (1 << i)) {
 495                         runtime->hw.rate_max = snd_pcm_known_rates.list[i];
 496                         break;
 497                 }
 498         }
 499         return 0;
 500 }
 501 EXPORT_SYMBOL(snd_pcm_limit_hw_rates);
 502 
 503 /**
 504  * snd_pcm_rate_to_rate_bit - converts sample rate to SNDRV_PCM_RATE_xxx bit
 505  * @rate: the sample rate to convert
 506  *
 507  * Return: The SNDRV_PCM_RATE_xxx flag that corresponds to the given rate, or
 508  * SNDRV_PCM_RATE_KNOT for an unknown rate.
 509  */
 510 unsigned int snd_pcm_rate_to_rate_bit(unsigned int rate)
 511 {
 512         unsigned int i;
 513 
 514         for (i = 0; i < snd_pcm_known_rates.count; i++)
 515                 if (snd_pcm_known_rates.list[i] == rate)
 516                         return 1u << i;
 517         return SNDRV_PCM_RATE_KNOT;
 518 }
 519 EXPORT_SYMBOL(snd_pcm_rate_to_rate_bit);
 520 
 521 /**
 522  * snd_pcm_rate_bit_to_rate - converts SNDRV_PCM_RATE_xxx bit to sample rate
 523  * @rate_bit: the rate bit to convert
 524  *
 525  * Return: The sample rate that corresponds to the given SNDRV_PCM_RATE_xxx flag
 526  * or 0 for an unknown rate bit.
 527  */
 528 unsigned int snd_pcm_rate_bit_to_rate(unsigned int rate_bit)
 529 {
 530         unsigned int i;
 531 
 532         for (i = 0; i < snd_pcm_known_rates.count; i++)
 533                 if ((1u << i) == rate_bit)
 534                         return snd_pcm_known_rates.list[i];
 535         return 0;
 536 }
 537 EXPORT_SYMBOL(snd_pcm_rate_bit_to_rate);
 538 
 539 static unsigned int snd_pcm_rate_mask_sanitize(unsigned int rates)
 540 {
 541         if (rates & SNDRV_PCM_RATE_CONTINUOUS)
 542                 return SNDRV_PCM_RATE_CONTINUOUS;
 543         else if (rates & SNDRV_PCM_RATE_KNOT)
 544                 return SNDRV_PCM_RATE_KNOT;
 545         return rates;
 546 }
 547 
 548 /**
 549  * snd_pcm_rate_mask_intersect - computes the intersection between two rate masks
 550  * @rates_a: The first rate mask
 551  * @rates_b: The second rate mask
 552  *
 553  * This function computes the rates that are supported by both rate masks passed
 554  * to the function. It will take care of the special handling of
 555  * SNDRV_PCM_RATE_CONTINUOUS and SNDRV_PCM_RATE_KNOT.
 556  *
 557  * Return: A rate mask containing the rates that are supported by both rates_a
 558  * and rates_b.
 559  */
 560 unsigned int snd_pcm_rate_mask_intersect(unsigned int rates_a,
 561         unsigned int rates_b)
 562 {
 563         rates_a = snd_pcm_rate_mask_sanitize(rates_a);
 564         rates_b = snd_pcm_rate_mask_sanitize(rates_b);
 565 
 566         if (rates_a & SNDRV_PCM_RATE_CONTINUOUS)
 567                 return rates_b;
 568         else if (rates_b & SNDRV_PCM_RATE_CONTINUOUS)
 569                 return rates_a;
 570         else if (rates_a & SNDRV_PCM_RATE_KNOT)
 571                 return rates_b;
 572         else if (rates_b & SNDRV_PCM_RATE_KNOT)
 573                 return rates_a;
 574         return rates_a & rates_b;
 575 }
 576 EXPORT_SYMBOL_GPL(snd_pcm_rate_mask_intersect);
 577 
 578 /**
 579  * snd_pcm_rate_range_to_bits - converts rate range to SNDRV_PCM_RATE_xxx bit
 580  * @rate_min: the minimum sample rate
 581  * @rate_max: the maximum sample rate
 582  *
 583  * This function has an implicit assumption: the rates in the given range have
 584  * only the pre-defined rates like 44100 or 16000.
 585  *
 586  * Return: The SNDRV_PCM_RATE_xxx flag that corresponds to the given rate range,
 587  * or SNDRV_PCM_RATE_KNOT for an unknown range.
 588  */
 589 unsigned int snd_pcm_rate_range_to_bits(unsigned int rate_min,
 590         unsigned int rate_max)
 591 {
 592         unsigned int rates = 0;
 593         int i;
 594 
 595         for (i = 0; i < snd_pcm_known_rates.count; i++) {
 596                 if (snd_pcm_known_rates.list[i] >= rate_min
 597                         && snd_pcm_known_rates.list[i] <= rate_max)
 598                         rates |= 1 << i;
 599         }
 600 
 601         if (!rates)
 602                 rates = SNDRV_PCM_RATE_KNOT;
 603 
 604         return rates;
 605 }
 606 EXPORT_SYMBOL_GPL(snd_pcm_rate_range_to_bits);
/* [<][>][^][v][top][bottom][index][help] */
root/sound/core/pcm_misc.c

DEFINITIONS
