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_t) -1;
 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 (m == (pa_volume_t) -1 || 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_t) -1;
 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 (m == (pa_volume_t) -1 || 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     return pa_sw_volume_from_linear(pa_sw_volume_to_linear(a) * pa_sw_volume_to_linear(b));
 204 }
 205
 206 pa_volume_t pa_sw_volume_divide(pa_volume_t a, pa_volume_t b) {
 207     double v = pa_sw_volume_to_linear(b);
 208
 209     if (v <= 0)
 210         return 0;
 211
 212     return pa_sw_volume_from_linear(pa_sw_volume_to_linear(a) / v);
 213 }
 214
 215 /* Amplitude, not power */
 216 static double linear_to_dB(double v) {
 217     return 20.0 * log10(v);
 218 }
 219
 220 static double dB_to_linear(double v) {
 221     return pow(10.0, v / 20.0);
 222 }
 223
 224 pa_volume_t pa_sw_volume_from_dB(double dB) {
 225     if (isinf(dB) < 0 || dB <= PA_DECIBEL_MININFTY)
 226         return PA_VOLUME_MUTED;
 227
 228     return pa_sw_volume_from_linear(dB_to_linear(dB));
 229 }
 230
 231 double pa_sw_volume_to_dB(pa_volume_t v) {
 232
 233     if (v <= PA_VOLUME_MUTED)
 234         return PA_DECIBEL_MININFTY;
 235
 236     return linear_to_dB(pa_sw_volume_to_linear(v));
 237 }
 238
 239 pa_volume_t pa_sw_volume_from_linear(double v) {
 240
 241     if (v <= 0.0)
 242         return PA_VOLUME_MUTED;
 243
 244     /*
 245      * We use a cubic mapping here, as suggested and discussed here:
 246      *
 247      * http://www.robotplanet.dk/audio/audio_gui_design/
 248      * http://lists.linuxaudio.org/pipermail/linux-audio-dev/2009-May/thread.html#23151
 249      *
 250      * We make sure that the conversion to linear and back yields the
 251      * same volume value! That's why we need the lround() below!
 252      */
 253
 254     return (pa_volume_t) lround(cbrt(v) * PA_VOLUME_NORM);
 255 }
 256
 257 double pa_sw_volume_to_linear(pa_volume_t v) {
 258     double f;
 259
 260     if (v <= PA_VOLUME_MUTED)
 261         return 0.0;
 262
 263     if (v == PA_VOLUME_NORM)
 264         return 1.0;
 265
 266     f = ((double) v / PA_VOLUME_NORM);
 267
 268     return f*f*f;
 269 }
 270
 271 char *pa_cvolume_snprint(char *s, size_t l, const pa_cvolume *c) {
 272     unsigned channel;
 273     pa_bool_t first = TRUE;
 274     char *e;
 275
 276     pa_assert(s);
 277     pa_assert(l > 0);
 278     pa_assert(c);
 279
 280     pa_init_i18n();
 281
 282     if (!pa_cvolume_valid(c)) {
 283         pa_snprintf(s, l, _("(invalid)"));
 284         return s;
 285     }
 286
 287     *(e = s) = 0;
 288
 289     for (channel = 0; channel < c->channels && l > 1; channel++) {
 290         l -= pa_snprintf(e, l, "%s%u: %3u%%",
 291                       first ? "" : " ",
 292                       channel,
 293                       (c->values[channel]*100)/PA_VOLUME_NORM);
 294
 295         e = strchr(e, 0);
 296         first = FALSE;
 297     }
 298
 299     return s;
 300 }
 301
 302 char *pa_volume_snprint(char *s, size_t l, pa_volume_t v) {
 303     pa_assert(s);
 304     pa_assert(l > 0);
 305
 306     pa_init_i18n();
 307
 308     if (v == (pa_volume_t) -1) {
 309         pa_snprintf(s, l, _("(invalid)"));
 310         return s;
 311     }
 312
 313     pa_snprintf(s, l, "%3u%%", (v*100)/PA_VOLUME_NORM);
 314     return s;
 315 }
 316
 317 char *pa_sw_cvolume_snprint_dB(char *s, size_t l, const pa_cvolume *c) {
 318     unsigned channel;
 319     pa_bool_t first = TRUE;
 320     char *e;
 321
 322     pa_assert(s);
 323     pa_assert(l > 0);
 324     pa_assert(c);
 325
 326     pa_init_i18n();
 327
 328     if (!pa_cvolume_valid(c)) {
 329         pa_snprintf(s, l, _("(invalid)"));
 330         return s;
 331     }
 332
 333     *(e = s) = 0;
 334
 335     for (channel = 0; channel < c->channels && l > 1; channel++) {
 336         double f = pa_sw_volume_to_dB(c->values[channel]);
 337
 338         l -= pa_snprintf(e, l, "%s%u: %0.2f dB",
 339                          first ? "" : " ",
 340                          channel,
 341                          isinf(f) < 0 || f <= PA_DECIBEL_MININFTY ? -INFINITY : f);
 342
 343         e = strchr(e, 0);
 344         first = FALSE;
 345     }
 346
 347     return s;
 348 }
 349
 350 char *pa_sw_volume_snprint_dB(char *s, size_t l, pa_volume_t v) {
 351     double f;
 352
 353     pa_assert(s);
 354     pa_assert(l > 0);
 355
 356     pa_init_i18n();
 357
 358     if (v == (pa_volume_t) -1) {
 359         pa_snprintf(s, l, _("(invalid)"));
 360         return s;
 361     }
 362
 363     f = pa_sw_volume_to_dB(v);
 364     pa_snprintf(s, l, "%0.2f dB",
 365                 isinf(f) < 0 || f <= PA_DECIBEL_MININFTY ?  -INFINITY : f);
 366
 367     return s;
 368 }
 369
 370 int pa_cvolume_channels_equal_to(const pa_cvolume *a, pa_volume_t v) {
 371     unsigned c;
 372     pa_assert(a);
 373
 374     pa_return_val_if_fail(pa_cvolume_valid(a), 0);
 375
 376     for (c = 0; c < a->channels; c++)
 377         if (a->values[c] != v)
 378             return 0;
 379
 380     return 1;
 381 }
 382
 383 pa_cvolume *pa_sw_cvolume_multiply(pa_cvolume *dest, const pa_cvolume *a, const pa_cvolume *b) {
 384     unsigned i;
 385
 386     pa_assert(dest);
 387     pa_assert(a);
 388     pa_assert(b);
 389
 390     pa_return_val_if_fail(pa_cvolume_valid(a), NULL);
 391     pa_return_val_if_fail(pa_cvolume_valid(b), NULL);
 392
 393     for (i = 0; i < a->channels && i < b->channels; i++)
 394         dest->values[i] = pa_sw_volume_multiply(a->values[i], b->values[i]);
 395
 396     dest->channels = (uint8_t) i;
 397
 398     return dest;
 399 }
 400
 401 pa_cvolume *pa_sw_cvolume_multiply_scalar(pa_cvolume *dest, const pa_cvolume *a, pa_volume_t b) {
 402     unsigned i;
 403
 404     pa_assert(dest);
 405     pa_assert(a);
 406
 407     pa_return_val_if_fail(pa_cvolume_valid(a), NULL);
 408
 409     for (i = 0; i < a->channels; i++)
 410         dest->values[i] = pa_sw_volume_multiply(a->values[i], b);
 411
 412     dest->channels = (uint8_t) i;
 413
 414     return dest;
 415 }
 416
 417 pa_cvolume *pa_sw_cvolume_divide(pa_cvolume *dest, const pa_cvolume *a, const pa_cvolume *b) {
 418     unsigned i;
 419
 420     pa_assert(dest);
 421     pa_assert(a);
 422     pa_assert(b);
 423
 424     pa_return_val_if_fail(pa_cvolume_valid(a), NULL);
 425     pa_return_val_if_fail(pa_cvolume_valid(b), NULL);
 426
 427     for (i = 0; i < a->channels && i < b->channels; i++)
 428         dest->values[i] = pa_sw_volume_divide(a->values[i], b->values[i]);
 429
 430     dest->channels = (uint8_t) i;
 431
 432     return dest;
 433 }
 434
 435 pa_cvolume *pa_sw_cvolume_divide_scalar(pa_cvolume *dest, const pa_cvolume *a, pa_volume_t b) {
 436     unsigned i;
 437
 438     pa_assert(dest);
 439     pa_assert(a);
 440
 441     pa_return_val_if_fail(pa_cvolume_valid(a), NULL);
 442
 443     for (i = 0; i < a->channels; i++)
 444         dest->values[i] = pa_sw_volume_divide(a->values[i], b);
 445
 446     dest->channels = (uint8_t) i;
 447
 448     return dest;
 449 }
 450
 451 int pa_cvolume_valid(const pa_cvolume *v) {
 452     unsigned c;
 453
 454     pa_assert(v);
 455
 456     if (v->channels <= 0 || v->channels > PA_CHANNELS_MAX)
 457         return 0;
 458
 459     for (c = 0; c < v->channels; c++)
 460         if (v->values[c] == (pa_volume_t) -1)
 461             return 0;
 462
 463     return 1;
 464 }
 465
 466 static pa_bool_t on_left(pa_channel_position_t p) {
 467     return !!(PA_CHANNEL_POSITION_MASK(p) & PA_CHANNEL_POSITION_MASK_LEFT);
 468 }
 469
 470 static pa_bool_t on_right(pa_channel_position_t p) {
 471     return !!(PA_CHANNEL_POSITION_MASK(p) & PA_CHANNEL_POSITION_MASK_RIGHT);
 472 }
 473
 474 static pa_bool_t on_center(pa_channel_position_t p) {
 475     return !!(PA_CHANNEL_POSITION_MASK(p) & PA_CHANNEL_POSITION_MASK_CENTER);
 476 }
 477
 478 static pa_bool_t on_lfe(pa_channel_position_t p) {
 479     return p == PA_CHANNEL_POSITION_LFE;
 480 }
 481
 482 static pa_bool_t on_front(pa_channel_position_t p) {
 483     return !!(PA_CHANNEL_POSITION_MASK(p) & PA_CHANNEL_POSITION_MASK_FRONT);
 484 }
 485
 486 static pa_bool_t on_rear(pa_channel_position_t p) {
 487     return !!(PA_CHANNEL_POSITION_MASK(p) & PA_CHANNEL_POSITION_MASK_REAR);
 488 }
 489
 490 pa_cvolume *pa_cvolume_remap(pa_cvolume *v, const pa_channel_map *from, const pa_channel_map *to) {
 491     int a, b;
 492     pa_cvolume result;
 493
 494     pa_assert(v);
 495     pa_assert(from);
 496     pa_assert(to);
 497
 498     pa_return_val_if_fail(pa_cvolume_valid(v), NULL);
 499     pa_return_val_if_fail(pa_channel_map_valid(from), NULL);
 500     pa_return_val_if_fail(pa_channel_map_valid(to), NULL);
 501     pa_return_val_if_fail(pa_cvolume_compatible_with_channel_map(v, from), NULL);
 502
 503     if (pa_channel_map_equal(from, to))
 504         return v;
 505
 506     result.channels = to->channels;
 507
 508     for (b = 0; b < to->channels; b++) {
 509         pa_volume_t k = 0;
 510         int n = 0;
 511
 512         for (a = 0; a < from->channels; a++)
 513             if (from->map[a] == to->map[b]) {
 514                 k += v->values[a];
 515                 n ++;
 516             }
 517
 518         if (n <= 0) {
 519             for (a = 0; a < from->channels; a++)
 520                 if ((on_left(from->map[a]) && on_left(to->map[b])) ||
 521                     (on_right(from->map[a]) && on_right(to->map[b])) ||
 522                     (on_center(from->map[a]) && on_center(to->map[b])) ||
 523                     (on_lfe(from->map[a]) && on_lfe(to->map[b]))) {
 524
 525                     k += v->values[a];
 526                     n ++;
 527                 }
 528         }
 529
 530         if (n <= 0)
 531             k = pa_cvolume_avg(v);
 532         else
 533             k /= n;
 534
 535         result.values[b] = k;
 536     }
 537
 538     *v = result;
 539     return v;
 540 }
 541
 542 int pa_cvolume_compatible(const pa_cvolume *v, const pa_sample_spec *ss) {
 543
 544     pa_assert(v);
 545     pa_assert(ss);
 546
 547     pa_return_val_if_fail(pa_cvolume_valid(v), 0);
 548     pa_return_val_if_fail(pa_sample_spec_valid(ss), 0);
 549
 550     return v->channels == ss->channels;
 551 }
 552
 553 int pa_cvolume_compatible_with_channel_map(const pa_cvolume *v, const pa_channel_map *cm) {
 554     pa_assert(v);
 555     pa_assert(cm);
 556
 557     pa_return_val_if_fail(pa_cvolume_valid(v), 0);
 558     pa_return_val_if_fail(pa_channel_map_valid(cm), 0);
 559
 560     return v->channels == cm->channels;
 561 }
 562
 563 static void get_avg_lr(const pa_channel_map *map, const pa_cvolume *v, pa_volume_t *l, pa_volume_t *r) {
 564     int c;
 565     pa_volume_t left = 0, right = 0;
 566     unsigned n_left = 0, n_right = 0;
 567
 568     pa_assert(v);
 569     pa_assert(map);
 570     pa_assert(map->channels == v->channels);
 571     pa_assert(l);
 572     pa_assert(r);
 573
 574     for (c = 0; c < map->channels; c++) {
 575         if (on_left(map->map[c])) {
 576             left += v->values[c];
 577             n_left++;
 578         } else if (on_right(map->map[c])) {
 579             right += v->values[c];
 580             n_right++;
 581         }
 582     }
 583
 584     if (n_left <= 0)
 585         *l = PA_VOLUME_NORM;
 586     else
 587         *l = left / n_left;
 588
 589     if (n_right <= 0)
 590         *r = PA_VOLUME_NORM;
 591     else
 592         *r = right / n_right;
 593 }
 594
 595 float pa_cvolume_get_balance(const pa_cvolume *v, const pa_channel_map *map) {
 596     pa_volume_t left, right;
 597
 598     pa_assert(v);
 599     pa_assert(map);
 600
 601     pa_return_val_if_fail(pa_cvolume_valid(v), 0.0f);
 602     pa_return_val_if_fail(pa_channel_map_valid(map), 0.0f);
 603     pa_return_val_if_fail(pa_cvolume_compatible_with_channel_map(v, map), 0.0f);
 604
 605     if (!pa_channel_map_can_balance(map))
 606         return 0.0f;
 607
 608     get_avg_lr(map, v, &left, &right);
 609
 610     if (left == right)
 611         return 0.0f;
 612
 613     /*   1.0,  0.0  =>  -1.0
 614          0.0,  1.0  =>   1.0
 615          0.0,  0.0  =>   0.0
 616          0.5,  0.5  =>   0.0
 617          1.0,  0.5  =>  -0.5
 618          1.0,  0.25 => -0.75
 619          0.75, 0.25 => -0.66
 620          0.5,  0.25 => -0.5   */
 621
 622     if (left > right)
 623         return -1.0f + ((float) right / (float) left);
 624     else
 625         return 1.0f - ((float) left / (float) right);
 626 }
 627
 628 pa_cvolume* pa_cvolume_set_balance(pa_cvolume *v, const pa_channel_map *map, float new_balance) {
 629     pa_volume_t left, nleft, right, nright, m;
 630     unsigned c;
 631
 632     pa_assert(map);
 633     pa_assert(v);
 634     pa_assert(new_balance >= -1.0f);
 635     pa_assert(new_balance <= 1.0f);
 636
 637     pa_return_val_if_fail(pa_cvolume_valid(v), NULL);
 638     pa_return_val_if_fail(pa_channel_map_valid(map), NULL);
 639     pa_return_val_if_fail(pa_cvolume_compatible_with_channel_map(v, map), NULL);
 640
 641     if (!pa_channel_map_can_balance(map))
 642         return v;
 643
 644     get_avg_lr(map, v, &left, &right);
 645
 646     m = PA_MAX(left, right);
 647
 648     if (new_balance <= 0) {
 649         nright  = (new_balance + 1.0f) * m;
 650         nleft = m;
 651     } else  {
 652         nleft = (1.0f - new_balance) * m;
 653         nright = m;
 654     }
 655
 656     for (c = 0; c < map->channels; c++) {
 657         if (on_left(map->map[c])) {
 658             if (left == 0)
 659                 v->values[c] = nleft;
 660             else
 661                 v->values[c] = (pa_volume_t) (((uint64_t) v->values[c] * (uint64_t) nleft) / (uint64_t) left);
 662         } else if (on_right(map->map[c])) {
 663             if (right == 0)
 664                 v->values[c] = nright;
 665             else
 666                 v->values[c] = (pa_volume_t) (((uint64_t) v->values[c] * (uint64_t) nright) / (uint64_t) right);
 667         }
 668     }
 669
 670     return v;
 671 }
 672
 673 pa_cvolume* pa_cvolume_scale(pa_cvolume *v, pa_volume_t max) {
 674     unsigned c;
 675     pa_volume_t t = 0;
 676
 677     pa_assert(v);
 678
 679     pa_return_val_if_fail(pa_cvolume_valid(v), NULL);
 680     pa_return_val_if_fail(max != (pa_volume_t) -1, NULL);
 681
 682     t = pa_cvolume_max(v);
 683
 684     if (t <= PA_VOLUME_MUTED)
 685         return pa_cvolume_set(v, v->channels, max);
 686
 687     for (c = 0; c < v->channels; c++)
 688         v->values[c] = (pa_volume_t) (((uint64_t)  v->values[c] * (uint64_t) max) / (uint64_t) t);
 689
 690     return v;
 691 }
 692
 693 pa_cvolume* pa_cvolume_scale_mask(pa_cvolume *v, pa_volume_t max, pa_channel_map *cm, pa_channel_position_mask_t mask) {
 694     unsigned c;
 695     pa_volume_t t = 0;
 696
 697     pa_assert(v);
 698
 699     pa_return_val_if_fail(pa_cvolume_valid(v), NULL);
 700     pa_return_val_if_fail(max != (pa_volume_t) -1, NULL);
 701
 702     t = pa_cvolume_max_mask(v, cm, mask);
 703
 704     if (t <= PA_VOLUME_MUTED)
 705         return pa_cvolume_set(v, v->channels, max);
 706
 707     for (c = 0; c < v->channels; c++)
 708         v->values[c] = (pa_volume_t) (((uint64_t)  v->values[c] * (uint64_t) max) / (uint64_t) t);
 709
 710     return v;
 711 }
 712
 713 static void get_avg_fr(const pa_channel_map *map, const pa_cvolume *v, pa_volume_t *f, pa_volume_t *r) {
 714     int c;
 715     pa_volume_t front = 0, rear = 0;
 716     unsigned n_front = 0, n_rear = 0;
 717
 718     pa_assert(v);
 719     pa_assert(map);
 720     pa_assert(map->channels == v->channels);
 721     pa_assert(f);
 722     pa_assert(r);
 723
 724     for (c = 0; c < map->channels; c++) {
 725         if (on_front(map->map[c])) {
 726             front += v->values[c];
 727             n_front++;
 728         } else if (on_rear(map->map[c])) {
 729             rear += v->values[c];
 730             n_rear++;
 731         }
 732     }
 733
 734     if (n_front <= 0)
 735         *f = PA_VOLUME_NORM;
 736     else
 737         *f = front / n_front;
 738
 739     if (n_rear <= 0)
 740         *r = PA_VOLUME_NORM;
 741     else
 742         *r = rear / n_rear;
 743 }
 744
 745 float pa_cvolume_get_fade(const pa_cvolume *v, const pa_channel_map *map) {
 746     pa_volume_t front, rear;
 747
 748     pa_assert(v);
 749     pa_assert(map);
 750
 751     pa_return_val_if_fail(pa_cvolume_valid(v), 0.0f);
 752     pa_return_val_if_fail(pa_channel_map_valid(map), 0.0f);
 753     pa_return_val_if_fail(pa_cvolume_compatible_with_channel_map(v, map), 0.0f);
 754
 755     if (!pa_channel_map_can_fade(map))
 756         return 0.0f;
 757
 758     get_avg_fr(map, v, &front, &rear);
 759
 760     if (front == rear)
 761         return 0.0f;
 762
 763     if (rear > front)
 764         return -1.0f + ((float) front / (float) rear);
 765     else
 766         return 1.0f - ((float) rear / (float) front);
 767 }
 768
 769 pa_cvolume* pa_cvolume_set_fade(pa_cvolume *v, const pa_channel_map *map, float new_fade) {
 770     pa_volume_t front, nfront, rear, nrear, m;
 771     unsigned c;
 772
 773     pa_assert(map);
 774     pa_assert(v);
 775     pa_assert(new_fade >= -1.0f);
 776     pa_assert(new_fade <= 1.0f);
 777
 778     pa_return_val_if_fail(pa_cvolume_valid(v), NULL);
 779     pa_return_val_if_fail(pa_channel_map_valid(map), NULL);
 780     pa_return_val_if_fail(pa_cvolume_compatible_with_channel_map(v, map), NULL);
 781
 782     if (!pa_channel_map_can_fade(map))
 783         return v;
 784
 785     get_avg_fr(map, v, &front, &rear);
 786
 787     m = PA_MAX(front, rear);
 788
 789     if (new_fade <= 0) {
 790         nfront  = (new_fade + 1.0f) * m;
 791         nrear = m;
 792     } else  {
 793         nrear = (1.0f - new_fade) * m;
 794         nfront = m;
 795     }
 796
 797     for (c = 0; c < map->channels; c++) {
 798         if (on_front(map->map[c])) {
 799             if (front == 0)
 800                 v->values[c] = nfront;
 801             else
 802                 v->values[c] = (pa_volume_t) (((uint64_t) v->values[c] * (uint64_t) nfront) / (uint64_t) front);
 803         } else if (on_rear(map->map[c])) {
 804             if (rear == 0)
 805                 v->values[c] = nrear;
 806             else
 807                 v->values[c] = (pa_volume_t) (((uint64_t) v->values[c] * (uint64_t) nrear) / (uint64_t) rear);
 808         }
 809     }
 810
 811     return v;
 812 }
 813
 814 pa_cvolume* pa_cvolume_set_position(
 815         pa_cvolume *cv,
 816         const pa_channel_map *map,
 817         pa_channel_position_t t,
 818         pa_volume_t v) {
 819
 820     unsigned c;
 821     pa_bool_t good = FALSE;
 822
 823     pa_assert(cv);
 824     pa_assert(map);
 825
 826     pa_return_val_if_fail(pa_cvolume_compatible_with_channel_map(cv, map), NULL);
 827     pa_return_val_if_fail(t < PA_CHANNEL_POSITION_MAX, NULL);
 828
 829     for (c = 0; c < map->channels; c++)
 830         if (map->map[c] == t) {
 831             cv->values[c] = v;
 832             good = TRUE;
 833         }
 834
 835     return good ? cv : NULL;
 836 }
 837
 838 pa_volume_t pa_cvolume_get_position(
 839         pa_cvolume *cv,
 840         const pa_channel_map *map,
 841         pa_channel_position_t t) {
 842
 843     unsigned c;
 844     pa_volume_t v = PA_VOLUME_MUTED;
 845
 846     pa_assert(cv);
 847     pa_assert(map);
 848
 849     pa_return_val_if_fail(pa_cvolume_compatible_with_channel_map(cv, map), PA_VOLUME_MUTED);
 850     pa_return_val_if_fail(t < PA_CHANNEL_POSITION_MAX, PA_VOLUME_MUTED);
 851
 852     for (c = 0; c < map->channels; c++)
 853         if (map->map[c] == t)
 854             if (cv->values[c] > v)
 855                 v = cv->values[c];
 856
 857     return v;
 858 }
 859
 860 pa_cvolume* pa_cvolume_merge(pa_cvolume *dest, const pa_cvolume *a, const pa_cvolume *b) {
 861     unsigned i;
 862
 863     pa_assert(dest);
 864     pa_assert(a);
 865     pa_assert(b);
 866
 867     pa_return_val_if_fail(pa_cvolume_valid(a), NULL);
 868     pa_return_val_if_fail(pa_cvolume_valid(b), NULL);
 869
 870     for (i = 0; i < a->channels && i < b->channels; i++)
 871         dest->values[i] = PA_MAX(a->values[i], b->values[i]);
 872
 873     dest->channels = (uint8_t) i;
 874
 875     return dest;
 876 }