code.delx.au - pulseaudio/blob - src/pulse/volume.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2004-2006 Lennart Poettering
   5
   6   PulseAudio is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU Lesser General Public License as published
   8   by the Free Software Foundation; either version 2.1 of the License,
   9   or (at your option) any later version.
  10
  11   PulseAudio is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with PulseAudio; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <stdio.h>
  27 #include <string.h>
  28
  29 #include <pulse/i18n.h>
  30
  31 #include <pulsecore/core-util.h>
  32 #include <pulsecore/macro.h>
  33 #include <pulsecore/sample-util.h>
  34
  35 #include "volume.h"
  36
  37 int pa_cvolume_equal(const pa_cvolume *a, const pa_cvolume *b) {
  38     int i;
  39     pa_assert(a);
  40     pa_assert(b);
  41
  42     pa_return_val_if_fail(pa_cvolume_valid(a), 0);
  43
  44     if (PA_UNLIKELY(a == b))
  45         return 1;
  46
  47     pa_return_val_if_fail(pa_cvolume_valid(b), 0);
  48
  49     if (a->channels != b->channels)
  50         return 0;
  51
  52     for (i = 0; i < a->channels; i++)
  53         if (a->values[i] != b->values[i])
  54             return 0;
  55
  56     return 1;
  57 }
  58
  59 pa_cvolume* pa_cvolume_init(pa_cvolume *a) {
  60     unsigned c;
  61
  62     pa_assert(a);
  63
  64     a->channels = 0;
  65
  66     for (c = 0; c < PA_CHANNELS_MAX; c++)
  67         a->values[c] = (pa_volume_t) -1;
  68
  69     return a;
  70 }
  71
  72 pa_cvolume* pa_cvolume_set(pa_cvolume *a, unsigned channels, pa_volume_t v) {
  73     int i;
  74
  75     pa_assert(a);
  76     pa_assert(channels > 0);
  77     pa_assert(channels <= PA_CHANNELS_MAX);
  78
  79     a->channels = (uint8_t) channels;
  80
  81     for (i = 0; i < a->channels; i++)
  82         a->values[i] = v;
  83
  84     return a;
  85 }
  86
  87 pa_volume_t pa_cvolume_avg(const pa_cvolume *a) {
  88     uint64_t sum = 0;
  89     unsigned c;
  90
  91     pa_assert(a);
  92     pa_return_val_if_fail(pa_cvolume_valid(a), PA_VOLUME_MUTED);
  93
  94     for (c = 0; c < a->channels; c++)
  95         sum += a->values[c];
  96
  97     sum /= a->channels;
  98
  99     return (pa_volume_t) sum;
 100 }
 101
 102 pa_volume_t pa_cvolume_avg_mask(const pa_cvolume *a, const pa_channel_map *cm, pa_channel_position_mask_t mask) {
 103     uint64_t sum = 0;
 104     unsigned c, n;
 105
 106     pa_assert(a);
 107
 108     if (!cm)
 109         return pa_cvolume_avg(a);
 110
 111     pa_return_val_if_fail(pa_cvolume_compatible_with_channel_map(a, cm), PA_VOLUME_MUTED);
 112
 113     for (c = n = 0; c < a->channels; c++) {
 114
 115         if (!(PA_CHANNEL_POSITION_MASK(cm->map[c]) & mask))
 116             continue;
 117
 118         sum += a->values[c];
 119         n ++;
 120     }
 121
 122     if (n > 0)
 123         sum /= n;
 124
 125     return (pa_volume_t) sum;
 126 }
 127
 128 pa_volume_t pa_cvolume_max(const pa_cvolume *a) {
 129     pa_volume_t m = PA_VOLUME_MUTED;
 130     unsigned c;
 131
 132     pa_assert(a);
 133     pa_return_val_if_fail(pa_cvolume_valid(a), PA_VOLUME_MUTED);
 134
 135     for (c = 0; c < a->channels; c++)
 136         if (a->values[c] > m)
 137             m = a->values[c];
 138
 139     return m;
 140 }
 141
 142 pa_volume_t pa_cvolume_min(const pa_cvolume *a) {
 143     pa_volume_t m = PA_VOLUME_MAX;
 144     unsigned c;
 145
 146     pa_assert(a);
 147     pa_return_val_if_fail(pa_cvolume_valid(a), PA_VOLUME_MUTED);
 148
 149     for (c = 0; c < a->channels; c++)
 150         if (a->values[c] < m)
 151             m = a->values[c];
 152
 153     return m;
 154 }
 155
 156 pa_volume_t pa_cvolume_max_mask(const pa_cvolume *a, const pa_channel_map *cm, pa_channel_position_mask_t mask) {
 157     pa_volume_t m = PA_VOLUME_MUTED;
 158     unsigned c, n;
 159
 160     pa_assert(a);
 161
 162     if (!cm)
 163         return pa_cvolume_max(a);
 164
 165     pa_return_val_if_fail(pa_cvolume_compatible_with_channel_map(a, cm), PA_VOLUME_MUTED);
 166
 167     for (c = n = 0; c < a->channels; c++) {
 168
 169         if (!(PA_CHANNEL_POSITION_MASK(cm->map[c]) & mask))
 170             continue;
 171
 172         if (a->values[c] > m)
 173             m = a->values[c];
 174     }
 175
 176     return m;
 177 }
 178
 179 pa_volume_t pa_cvolume_min_mask(const pa_cvolume *a, const pa_channel_map *cm, pa_channel_position_mask_t mask) {
 180     pa_volume_t m = PA_VOLUME_MAX;
 181     unsigned c, n;
 182
 183     pa_assert(a);
 184
 185     if (!cm)
 186         return pa_cvolume_min(a);
 187
 188     pa_return_val_if_fail(pa_cvolume_compatible_with_channel_map(a, cm), PA_VOLUME_MUTED);
 189
 190     for (c = n = 0; c < a->channels; c++) {
 191
 192         if (!(PA_CHANNEL_POSITION_MASK(cm->map[c]) & mask))
 193             continue;
 194
 195         if (a->values[c] < m)
 196             m = a->values[c];
 197     }
 198
 199     return m;
 200 }
 201
 202 pa_volume_t pa_sw_volume_multiply(pa_volume_t a, pa_volume_t b) {
 203
 204     /* cbrt((a/PA_VOLUME_NORM)^3*(b/PA_VOLUME_NORM)^3)*PA_VOLUME_NORM = a*b/PA_VOLUME_NORM */
 205
 206     return (pa_volume_t) (((uint64_t) a * (uint64_t) b + (uint64_t) PA_VOLUME_NORM / 2ULL) / (uint64_t) PA_VOLUME_NORM);
 207 }
 208
 209 pa_volume_t pa_sw_volume_divide(pa_volume_t a, pa_volume_t b) {
 210
 211     if (b <= PA_VOLUME_MUTED)
 212         return 0;
 213
 214     return (pa_volume_t) (((uint64_t) a * (uint64_t) PA_VOLUME_NORM + (uint64_t) b / 2ULL) / (uint64_t) b);
 215 }
 216
 217 /* Amplitude, not power */
 218 static double linear_to_dB(double v) {
 219     return 20.0 * log10(v);
 220 }
 221
 222 static double dB_to_linear(double v) {
 223     return pow(10.0, v / 20.0);
 224 }
 225
 226 pa_volume_t pa_sw_volume_from_dB(double dB) {
 227     if (isinf(dB) < 0 || dB <= PA_DECIBEL_MININFTY)
 228         return PA_VOLUME_MUTED;
 229
 230     return pa_sw_volume_from_linear(dB_to_linear(dB));
 231 }
 232
 233 double pa_sw_volume_to_dB(pa_volume_t v) {
 234
 235     if (v <= PA_VOLUME_MUTED)
 236         return PA_DECIBEL_MININFTY;
 237
 238     return linear_to_dB(pa_sw_volume_to_linear(v));
 239 }
 240
 241 pa_volume_t pa_sw_volume_from_linear(double v) {
 242
 243     if (v <= 0.0)
 244         return PA_VOLUME_MUTED;
 245
 246     /*
 247      * We use a cubic mapping here, as suggested and discussed here:
 248      *
 249      * http://www.robotplanet.dk/audio/audio_gui_design/
 250      * http://lists.linuxaudio.org/pipermail/linux-audio-dev/2009-May/thread.html#23151
 251      *
 252      * We make sure that the conversion to linear and back yields the
 253      * same volume value! That's why we need the lround() below!
 254      */
 255
 256     return (pa_volume_t) lround(cbrt(v) * PA_VOLUME_NORM);
 257 }
 258
 259 double pa_sw_volume_to_linear(pa_volume_t v) {
 260     double f;
 261
 262     if (v <= PA_VOLUME_MUTED)
 263         return 0.0;
 264
 265     if (v == PA_VOLUME_NORM)
 266         return 1.0;
 267
 268     f = ((double) v / PA_VOLUME_NORM);
 269
 270     return f*f*f;
 271 }
 272
 273 char *pa_cvolume_snprint(char *s, size_t l, const pa_cvolume *c) {
 274     unsigned channel;
 275     pa_bool_t first = TRUE;
 276     char *e;
 277
 278     pa_assert(s);
 279     pa_assert(l > 0);
 280     pa_assert(c);
 281
 282     pa_init_i18n();
 283
 284     if (!pa_cvolume_valid(c)) {
 285         pa_snprintf(s, l, _("(invalid)"));
 286         return s;
 287     }
 288
 289     *(e = s) = 0;
 290
 291     for (channel = 0; channel < c->channels && l > 1; channel++) {
 292         l -= pa_snprintf(e, l, "%s%u: %3u%%",
 293                       first ? "" : " ",
 294                       channel,
 295                       (c->values[channel]*100+PA_VOLUME_NORM/2)/PA_VOLUME_NORM);
 296
 297         e = strchr(e, 0);
 298         first = FALSE;
 299     }
 300
 301     return s;
 302 }
 303
 304 char *pa_volume_snprint(char *s, size_t l, pa_volume_t v) {
 305     pa_assert(s);
 306     pa_assert(l > 0);
 307
 308     pa_init_i18n();
 309
 310     if (v == (pa_volume_t) -1) {
 311         pa_snprintf(s, l, _("(invalid)"));
 312         return s;
 313     }
 314
 315     pa_snprintf(s, l, "%3u%%", (v*100+PA_VOLUME_NORM/2)/PA_VOLUME_NORM);
 316     return s;
 317 }
 318
 319 char *pa_sw_cvolume_snprint_dB(char *s, size_t l, const pa_cvolume *c) {
 320     unsigned channel;
 321     pa_bool_t first = TRUE;
 322     char *e;
 323
 324     pa_assert(s);
 325     pa_assert(l > 0);
 326     pa_assert(c);
 327
 328     pa_init_i18n();
 329
 330     if (!pa_cvolume_valid(c)) {
 331         pa_snprintf(s, l, _("(invalid)"));
 332         return s;
 333     }
 334
 335     *(e = s) = 0;
 336
 337     for (channel = 0; channel < c->channels && l > 1; channel++) {
 338         double f = pa_sw_volume_to_dB(c->values[channel]);
 339
 340         l -= pa_snprintf(e, l, "%s%u: %0.2f dB",
 341                          first ? "" : " ",
 342                          channel,
 343                          isinf(f) < 0 || f <= PA_DECIBEL_MININFTY ? -INFINITY : f);
 344
 345         e = strchr(e, 0);
 346         first = FALSE;
 347     }
 348
 349     return s;
 350 }
 351
 352 char *pa_sw_volume_snprint_dB(char *s, size_t l, pa_volume_t v) {
 353     double f;
 354
 355     pa_assert(s);
 356     pa_assert(l > 0);
 357
 358     pa_init_i18n();
 359
 360     if (v == (pa_volume_t) -1) {
 361         pa_snprintf(s, l, _("(invalid)"));
 362         return s;
 363     }
 364
 365     f = pa_sw_volume_to_dB(v);
 366     pa_snprintf(s, l, "%0.2f dB",
 367                 isinf(f) < 0 || f <= PA_DECIBEL_MININFTY ?  -INFINITY : f);
 368
 369     return s;
 370 }
 371
 372 int pa_cvolume_channels_equal_to(const pa_cvolume *a, pa_volume_t v) {
 373     unsigned c;
 374     pa_assert(a);
 375
 376     pa_return_val_if_fail(pa_cvolume_valid(a), 0);
 377
 378     for (c = 0; c < a->channels; c++)
 379         if (a->values[c] != v)
 380             return 0;
 381
 382     return 1;
 383 }
 384
 385 pa_cvolume *pa_sw_cvolume_multiply(pa_cvolume *dest, const pa_cvolume *a, const pa_cvolume *b) {
 386     unsigned i;
 387
 388     pa_assert(dest);
 389     pa_assert(a);
 390     pa_assert(b);
 391
 392     pa_return_val_if_fail(pa_cvolume_valid(a), NULL);
 393     pa_return_val_if_fail(pa_cvolume_valid(b), NULL);
 394
 395     for (i = 0; i < a->channels && i < b->channels; i++)
 396         dest->values[i] = pa_sw_volume_multiply(a->values[i], b->values[i]);
 397
 398     dest->channels = (uint8_t) i;
 399
 400     return dest;
 401 }
 402
 403 pa_cvolume *pa_sw_cvolume_multiply_scalar(pa_cvolume *dest, const pa_cvolume *a, pa_volume_t b) {
 404     unsigned i;
 405
 406     pa_assert(dest);
 407     pa_assert(a);
 408
 409     pa_return_val_if_fail(pa_cvolume_valid(a), NULL);
 410
 411     for (i = 0; i < a->channels; i++)
 412         dest->values[i] = pa_sw_volume_multiply(a->values[i], b);
 413
 414     dest->channels = (uint8_t) i;
 415
 416     return dest;
 417 }
 418
 419 pa_cvolume *pa_sw_cvolume_divide(pa_cvolume *dest, const pa_cvolume *a, const pa_cvolume *b) {
 420     unsigned i;
 421
 422     pa_assert(dest);
 423     pa_assert(a);
 424     pa_assert(b);
 425
 426     pa_return_val_if_fail(pa_cvolume_valid(a), NULL);
 427     pa_return_val_if_fail(pa_cvolume_valid(b), NULL);
 428
 429     for (i = 0; i < a->channels && i < b->channels; i++)
 430         dest->values[i] = pa_sw_volume_divide(a->values[i], b->values[i]);
 431
 432     dest->channels = (uint8_t) i;
 433
 434     return dest;
 435 }
 436
 437 pa_cvolume *pa_sw_cvolume_divide_scalar(pa_cvolume *dest, const pa_cvolume *a, pa_volume_t b) {
 438     unsigned i;
 439
 440     pa_assert(dest);
 441     pa_assert(a);
 442
 443     pa_return_val_if_fail(pa_cvolume_valid(a), NULL);
 444
 445     for (i = 0; i < a->channels; i++)
 446         dest->values[i] = pa_sw_volume_divide(a->values[i], b);
 447
 448     dest->channels = (uint8_t) i;
 449
 450     return dest;
 451 }
 452
 453 int pa_cvolume_valid(const pa_cvolume *v) {
 454     unsigned c;
 455
 456     pa_assert(v);
 457
 458     if (v->channels <= 0 || v->channels > PA_CHANNELS_MAX)
 459         return 0;
 460
 461     for (c = 0; c < v->channels; c++)
 462         if (v->values[c] == (pa_volume_t) -1)
 463             return 0;
 464
 465     return 1;
 466 }
 467
 468 static pa_bool_t on_left(pa_channel_position_t p) {
 469     return !!(PA_CHANNEL_POSITION_MASK(p) & PA_CHANNEL_POSITION_MASK_LEFT);
 470 }
 471
 472 static pa_bool_t on_right(pa_channel_position_t p) {
 473     return !!(PA_CHANNEL_POSITION_MASK(p) & PA_CHANNEL_POSITION_MASK_RIGHT);
 474 }
 475
 476 static pa_bool_t on_center(pa_channel_position_t p) {
 477     return !!(PA_CHANNEL_POSITION_MASK(p) & PA_CHANNEL_POSITION_MASK_CENTER);
 478 }
 479
 480 static pa_bool_t on_lfe(pa_channel_position_t p) {
 481     return p == PA_CHANNEL_POSITION_LFE;
 482 }
 483
 484 static pa_bool_t on_front(pa_channel_position_t p) {
 485     return !!(PA_CHANNEL_POSITION_MASK(p) & PA_CHANNEL_POSITION_MASK_FRONT);
 486 }
 487
 488 static pa_bool_t on_rear(pa_channel_position_t p) {
 489     return !!(PA_CHANNEL_POSITION_MASK(p) & PA_CHANNEL_POSITION_MASK_REAR);
 490 }
 491
 492 pa_cvolume *pa_cvolume_remap(pa_cvolume *v, const pa_channel_map *from, const pa_channel_map *to) {
 493     int a, b;
 494     pa_cvolume result;
 495
 496     pa_assert(v);
 497     pa_assert(from);
 498     pa_assert(to);
 499
 500     pa_return_val_if_fail(pa_cvolume_valid(v), NULL);
 501     pa_return_val_if_fail(pa_channel_map_valid(from), NULL);
 502     pa_return_val_if_fail(pa_channel_map_valid(to), NULL);
 503     pa_return_val_if_fail(pa_cvolume_compatible_with_channel_map(v, from), NULL);
 504
 505     if (pa_channel_map_equal(from, to))
 506         return v;
 507
 508     result.channels = to->channels;
 509
 510     for (b = 0; b < to->channels; b++) {
 511         pa_volume_t k = 0;
 512         int n = 0;
 513
 514         for (a = 0; a < from->channels; a++)
 515             if (from->map[a] == to->map[b]) {
 516                 k += v->values[a];
 517                 n ++;
 518             }
 519
 520         if (n <= 0) {
 521             for (a = 0; a < from->channels; a++)
 522                 if ((on_left(from->map[a]) && on_left(to->map[b])) ||
 523                     (on_right(from->map[a]) && on_right(to->map[b])) ||
 524                     (on_center(from->map[a]) && on_center(to->map[b])) ||
 525                     (on_lfe(from->map[a]) && on_lfe(to->map[b]))) {
 526
 527                     k += v->values[a];
 528                     n ++;
 529                 }
 530         }
 531
 532         if (n <= 0)
 533             k = pa_cvolume_avg(v);
 534         else
 535             k /= n;
 536
 537         result.values[b] = k;
 538     }
 539
 540     *v = result;
 541     return v;
 542 }
 543
 544 int pa_cvolume_compatible(const pa_cvolume *v, const pa_sample_spec *ss) {
 545
 546     pa_assert(v);
 547     pa_assert(ss);
 548
 549     pa_return_val_if_fail(pa_cvolume_valid(v), 0);
 550     pa_return_val_if_fail(pa_sample_spec_valid(ss), 0);
 551
 552     return v->channels == ss->channels;
 553 }
 554
 555 int pa_cvolume_compatible_with_channel_map(const pa_cvolume *v, const pa_channel_map *cm) {
 556     pa_assert(v);
 557     pa_assert(cm);
 558
 559     pa_return_val_if_fail(pa_cvolume_valid(v), 0);
 560     pa_return_val_if_fail(pa_channel_map_valid(cm), 0);
 561
 562     return v->channels == cm->channels;
 563 }
 564
 565 static void get_avg_lr(const pa_channel_map *map, const pa_cvolume *v, pa_volume_t *l, pa_volume_t *r) {
 566     int c;
 567     pa_volume_t left = 0, right = 0;
 568     unsigned n_left = 0, n_right = 0;
 569
 570     pa_assert(v);
 571     pa_assert(map);
 572     pa_assert(map->channels == v->channels);
 573     pa_assert(l);
 574     pa_assert(r);
 575
 576     for (c = 0; c < map->channels; c++) {
 577         if (on_left(map->map[c])) {
 578             left += v->values[c];
 579             n_left++;
 580         } else if (on_right(map->map[c])) {
 581             right += v->values[c];
 582             n_right++;
 583         }
 584     }
 585
 586     if (n_left <= 0)
 587         *l = PA_VOLUME_NORM;
 588     else
 589         *l = left / n_left;
 590
 591     if (n_right <= 0)
 592         *r = PA_VOLUME_NORM;
 593     else
 594         *r = right / n_right;
 595 }
 596
 597 float pa_cvolume_get_balance(const pa_cvolume *v, const pa_channel_map *map) {
 598     pa_volume_t left, right;
 599
 600     pa_assert(v);
 601     pa_assert(map);
 602
 603     pa_return_val_if_fail(pa_cvolume_valid(v), 0.0f);
 604     pa_return_val_if_fail(pa_channel_map_valid(map), 0.0f);
 605     pa_return_val_if_fail(pa_cvolume_compatible_with_channel_map(v, map), 0.0f);
 606
 607     if (!pa_channel_map_can_balance(map))
 608         return 0.0f;
 609
 610     get_avg_lr(map, v, &left, &right);
 611
 612     if (left == right)
 613         return 0.0f;
 614
 615     /*   1.0,  0.0  =>  -1.0
 616          0.0,  1.0  =>   1.0
 617          0.0,  0.0  =>   0.0
 618          0.5,  0.5  =>   0.0
 619          1.0,  0.5  =>  -0.5
 620          1.0,  0.25 => -0.75
 621          0.75, 0.25 => -0.66
 622          0.5,  0.25 => -0.5   */
 623
 624     if (left > right)
 625         return -1.0f + ((float) right / (float) left);
 626     else
 627         return 1.0f - ((float) left / (float) right);
 628 }
 629
 630 pa_cvolume* pa_cvolume_set_balance(pa_cvolume *v, const pa_channel_map *map, float new_balance) {
 631     pa_volume_t left, nleft, right, nright, m;
 632     unsigned c;
 633
 634     pa_assert(map);
 635     pa_assert(v);
 636     pa_assert(new_balance >= -1.0f);
 637     pa_assert(new_balance <= 1.0f);
 638
 639     pa_return_val_if_fail(pa_cvolume_valid(v), NULL);
 640     pa_return_val_if_fail(pa_channel_map_valid(map), NULL);
 641     pa_return_val_if_fail(pa_cvolume_compatible_with_channel_map(v, map), NULL);
 642
 643     if (!pa_channel_map_can_balance(map))
 644         return v;
 645
 646     get_avg_lr(map, v, &left, &right);
 647
 648     m = PA_MAX(left, right);
 649
 650     if (new_balance <= 0) {
 651         nright  = (new_balance + 1.0f) * m;
 652         nleft = m;
 653     } else  {
 654         nleft = (1.0f - new_balance) * m;
 655         nright = m;
 656     }
 657
 658     for (c = 0; c < map->channels; c++) {
 659         if (on_left(map->map[c])) {
 660             if (left == 0)
 661                 v->values[c] = nleft;
 662             else
 663                 v->values[c] = (pa_volume_t) (((uint64_t) v->values[c] * (uint64_t) nleft) / (uint64_t) left);
 664         } else if (on_right(map->map[c])) {
 665             if (right == 0)
 666                 v->values[c] = nright;
 667             else
 668                 v->values[c] = (pa_volume_t) (((uint64_t) v->values[c] * (uint64_t) nright) / (uint64_t) right);
 669         }
 670     }
 671
 672     return v;
 673 }
 674
 675 pa_cvolume* pa_cvolume_scale(pa_cvolume *v, pa_volume_t max) {
 676     unsigned c;
 677     pa_volume_t t = 0;
 678
 679     pa_assert(v);
 680
 681     pa_return_val_if_fail(pa_cvolume_valid(v), NULL);
 682     pa_return_val_if_fail(max != (pa_volume_t) -1, NULL);
 683
 684     t = pa_cvolume_max(v);
 685
 686     if (t <= PA_VOLUME_MUTED)
 687         return pa_cvolume_set(v, v->channels, max);
 688
 689     for (c = 0; c < v->channels; c++)
 690         v->values[c] = (pa_volume_t) (((uint64_t)  v->values[c] * (uint64_t) max) / (uint64_t) t);
 691
 692     return v;
 693 }
 694
 695 pa_cvolume* pa_cvolume_scale_mask(pa_cvolume *v, pa_volume_t max, pa_channel_map *cm, pa_channel_position_mask_t mask) {
 696     unsigned c;
 697     pa_volume_t t = 0;
 698
 699     pa_assert(v);
 700
 701     pa_return_val_if_fail(pa_cvolume_valid(v), NULL);
 702     pa_return_val_if_fail(max != (pa_volume_t) -1, NULL);
 703
 704     t = pa_cvolume_max_mask(v, cm, mask);
 705
 706     if (t <= PA_VOLUME_MUTED)
 707         return pa_cvolume_set(v, v->channels, max);
 708
 709     for (c = 0; c < v->channels; c++)
 710         v->values[c] = (pa_volume_t) (((uint64_t)  v->values[c] * (uint64_t) max) / (uint64_t) t);
 711
 712     return v;
 713 }
 714
 715 static void get_avg_fr(const pa_channel_map *map, const pa_cvolume *v, pa_volume_t *f, pa_volume_t *r) {
 716     int c;
 717     pa_volume_t front = 0, rear = 0;
 718     unsigned n_front = 0, n_rear = 0;
 719
 720     pa_assert(v);
 721     pa_assert(map);
 722     pa_assert(map->channels == v->channels);
 723     pa_assert(f);
 724     pa_assert(r);
 725
 726     for (c = 0; c < map->channels; c++) {
 727         if (on_front(map->map[c])) {
 728             front += v->values[c];
 729             n_front++;
 730         } else if (on_rear(map->map[c])) {
 731             rear += v->values[c];
 732             n_rear++;
 733         }
 734     }
 735
 736     if (n_front <= 0)
 737         *f = PA_VOLUME_NORM;
 738     else
 739         *f = front / n_front;
 740
 741     if (n_rear <= 0)
 742         *r = PA_VOLUME_NORM;
 743     else
 744         *r = rear / n_rear;
 745 }
 746
 747 float pa_cvolume_get_fade(const pa_cvolume *v, const pa_channel_map *map) {
 748     pa_volume_t front, rear;
 749
 750     pa_assert(v);
 751     pa_assert(map);
 752
 753     pa_return_val_if_fail(pa_cvolume_valid(v), 0.0f);
 754     pa_return_val_if_fail(pa_channel_map_valid(map), 0.0f);
 755     pa_return_val_if_fail(pa_cvolume_compatible_with_channel_map(v, map), 0.0f);
 756
 757     if (!pa_channel_map_can_fade(map))
 758         return 0.0f;
 759
 760     get_avg_fr(map, v, &front, &rear);
 761
 762     if (front == rear)
 763         return 0.0f;
 764
 765     if (rear > front)
 766         return -1.0f + ((float) front / (float) rear);
 767     else
 768         return 1.0f - ((float) rear / (float) front);
 769 }
 770
 771 pa_cvolume* pa_cvolume_set_fade(pa_cvolume *v, const pa_channel_map *map, float new_fade) {
 772     pa_volume_t front, nfront, rear, nrear, m;
 773     unsigned c;
 774
 775     pa_assert(map);
 776     pa_assert(v);
 777     pa_assert(new_fade >= -1.0f);
 778     pa_assert(new_fade <= 1.0f);
 779
 780     pa_return_val_if_fail(pa_cvolume_valid(v), NULL);
 781     pa_return_val_if_fail(pa_channel_map_valid(map), NULL);
 782     pa_return_val_if_fail(pa_cvolume_compatible_with_channel_map(v, map), NULL);
 783
 784     if (!pa_channel_map_can_fade(map))
 785         return v;
 786
 787     get_avg_fr(map, v, &front, &rear);
 788
 789     m = PA_MAX(front, rear);
 790
 791     if (new_fade <= 0) {
 792         nfront  = (new_fade + 1.0f) * m;
 793         nrear = m;
 794     } else  {
 795         nrear = (1.0f - new_fade) * m;
 796         nfront = m;
 797     }
 798
 799     for (c = 0; c < map->channels; c++) {
 800         if (on_front(map->map[c])) {
 801             if (front == 0)
 802                 v->values[c] = nfront;
 803             else
 804                 v->values[c] = (pa_volume_t) (((uint64_t) v->values[c] * (uint64_t) nfront) / (uint64_t) front);
 805         } else if (on_rear(map->map[c])) {
 806             if (rear == 0)
 807                 v->values[c] = nrear;
 808             else
 809                 v->values[c] = (pa_volume_t) (((uint64_t) v->values[c] * (uint64_t) nrear) / (uint64_t) rear);
 810         }
 811     }
 812
 813     return v;
 814 }
 815
 816 pa_cvolume* pa_cvolume_set_position(
 817         pa_cvolume *cv,
 818         const pa_channel_map *map,
 819         pa_channel_position_t t,
 820         pa_volume_t v) {
 821
 822     unsigned c;
 823     pa_bool_t good = FALSE;
 824
 825     pa_assert(cv);
 826     pa_assert(map);
 827
 828     pa_return_val_if_fail(pa_cvolume_compatible_with_channel_map(cv, map), NULL);
 829     pa_return_val_if_fail(t < PA_CHANNEL_POSITION_MAX, NULL);
 830
 831     for (c = 0; c < map->channels; c++)
 832         if (map->map[c] == t) {
 833             cv->values[c] = v;
 834             good = TRUE;
 835         }
 836
 837     return good ? cv : NULL;
 838 }
 839
 840 pa_volume_t pa_cvolume_get_position(
 841         pa_cvolume *cv,
 842         const pa_channel_map *map,
 843         pa_channel_position_t t) {
 844
 845     unsigned c;
 846     pa_volume_t v = PA_VOLUME_MUTED;
 847
 848     pa_assert(cv);
 849     pa_assert(map);
 850
 851     pa_return_val_if_fail(pa_cvolume_compatible_with_channel_map(cv, map), PA_VOLUME_MUTED);
 852     pa_return_val_if_fail(t < PA_CHANNEL_POSITION_MAX, PA_VOLUME_MUTED);
 853
 854     for (c = 0; c < map->channels; c++)
 855         if (map->map[c] == t)
 856             if (cv->values[c] > v)
 857                 v = cv->values[c];
 858
 859     return v;
 860 }
 861
 862 pa_cvolume* pa_cvolume_merge(pa_cvolume *dest, const pa_cvolume *a, const pa_cvolume *b) {
 863     unsigned i;
 864
 865     pa_assert(dest);
 866     pa_assert(a);
 867     pa_assert(b);
 868
 869     pa_return_val_if_fail(pa_cvolume_valid(a), NULL);
 870     pa_return_val_if_fail(pa_cvolume_valid(b), NULL);
 871
 872     for (i = 0; i < a->channels && i < b->channels; i++)
 873         dest->values[i] = PA_MAX(a->values[i], b->values[i]);
 874
 875     dest->channels = (uint8_t) i;
 876
 877     return dest;
 878 }
 879
 880 pa_cvolume* pa_cvolume_inc(pa_cvolume *v, pa_volume_t inc) {
 881     pa_volume_t m;
 882
 883     pa_assert(v);
 884
 885     pa_return_val_if_fail(pa_cvolume_valid(v), NULL);
 886
 887     m = pa_cvolume_max(v);
 888
 889     if (m >= PA_VOLUME_MAX - inc)
 890         m = PA_VOLUME_MAX;
 891     else
 892         m += inc;
 893
 894     return pa_cvolume_scale(v, m);
 895 }
 896
 897 pa_cvolume* pa_cvolume_dec(pa_cvolume *v, pa_volume_t dec) {
 898     pa_volume_t m;
 899
 900     pa_assert(v);
 901
 902     pa_return_val_if_fail(pa_cvolume_valid(v), NULL);
 903
 904     m = pa_cvolume_max(v);
 905
 906     if (m <= PA_VOLUME_MUTED + dec)
 907         m = PA_VOLUME_MUTED;
 908     else
 909         m -= dec;
 910
 911     return pa_cvolume_scale(v, m);
 912 }