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