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