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;
 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 = 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;
 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 = 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
 646     pa_return_val_if_fail(pa_cvolume_compatible_with_channel_map(v, map), NULL);
 647     pa_return_val_if_fail(new_balance >= -1.0f, NULL);
 648     pa_return_val_if_fail(new_balance <= 1.0f, NULL);
 649
 650     if (!pa_channel_map_can_balance(map))
 651         return v;
 652
 653     get_avg_lr(map, v, &left, &right);
 654
 655     m = PA_MAX(left, right);
 656
 657     if (new_balance <= 0) {
 658         nright  = (new_balance + 1.0f) * m;
 659         nleft = m;
 660     } else  {
 661         nleft = (1.0f - new_balance) * m;
 662         nright = m;
 663     }
 664
 665     for (c = 0; c < map->channels; c++) {
 666         if (on_left(map->map[c])) {
 667             if (left == 0)
 668                 v->values[c] = nleft;
 669             else
 670                 v->values[c] = (pa_volume_t) (((uint64_t) v->values[c] * (uint64_t) nleft) / (uint64_t) left);
 671         } else if (on_right(map->map[c])) {
 672             if (right == 0)
 673                 v->values[c] = nright;
 674             else
 675                 v->values[c] = (pa_volume_t) (((uint64_t) v->values[c] * (uint64_t) nright) / (uint64_t) right);
 676         }
 677     }
 678
 679     return v;
 680 }
 681
 682 pa_cvolume* pa_cvolume_scale(pa_cvolume *v, pa_volume_t max) {
 683     unsigned c;
 684     pa_volume_t t = 0;
 685
 686     pa_assert(v);
 687
 688     pa_return_val_if_fail(pa_cvolume_valid(v), NULL);
 689     pa_return_val_if_fail(max != PA_VOLUME_INVALID, NULL);
 690
 691     t = pa_cvolume_max(v);
 692
 693     if (t <= PA_VOLUME_MUTED)
 694         return pa_cvolume_set(v, v->channels, max);
 695
 696     for (c = 0; c < v->channels; c++)
 697         v->values[c] = (pa_volume_t) (((uint64_t)  v->values[c] * (uint64_t) max) / (uint64_t) t);
 698
 699     return v;
 700 }
 701
 702 pa_cvolume* pa_cvolume_scale_mask(pa_cvolume *v, pa_volume_t max, pa_channel_map *cm, pa_channel_position_mask_t mask) {
 703     unsigned c;
 704     pa_volume_t t = 0;
 705
 706     pa_assert(v);
 707
 708     pa_return_val_if_fail(max != PA_VOLUME_INVALID, NULL);
 709
 710     if (!cm)
 711         return pa_cvolume_scale(v, max);
 712
 713     pa_return_val_if_fail(pa_cvolume_compatible_with_channel_map(v, cm), NULL);
 714
 715     t = pa_cvolume_max_mask(v, cm, mask);
 716
 717     if (t <= PA_VOLUME_MUTED)
 718         return pa_cvolume_set(v, v->channels, max);
 719
 720     for (c = 0; c < v->channels; c++)
 721         v->values[c] = (pa_volume_t) (((uint64_t)  v->values[c] * (uint64_t) max) / (uint64_t) t);
 722
 723     return v;
 724 }
 725
 726 static void get_avg_fr(const pa_channel_map *map, const pa_cvolume *v, pa_volume_t *f, pa_volume_t *r) {
 727     int c;
 728     pa_volume_t front = 0, rear = 0;
 729     unsigned n_front = 0, n_rear = 0;
 730
 731     pa_assert(v);
 732     pa_assert(map);
 733     pa_assert(map->channels == v->channels);
 734     pa_assert(f);
 735     pa_assert(r);
 736
 737     for (c = 0; c < map->channels; c++) {
 738         if (on_front(map->map[c])) {
 739             front += v->values[c];
 740             n_front++;
 741         } else if (on_rear(map->map[c])) {
 742             rear += v->values[c];
 743             n_rear++;
 744         }
 745     }
 746
 747     if (n_front <= 0)
 748         *f = PA_VOLUME_NORM;
 749     else
 750         *f = front / n_front;
 751
 752     if (n_rear <= 0)
 753         *r = PA_VOLUME_NORM;
 754     else
 755         *r = rear / n_rear;
 756 }
 757
 758 float pa_cvolume_get_fade(const pa_cvolume *v, const pa_channel_map *map) {
 759     pa_volume_t front, rear;
 760
 761     pa_assert(v);
 762     pa_assert(map);
 763
 764     pa_return_val_if_fail(pa_cvolume_compatible_with_channel_map(v, map), 0.0f);
 765
 766     if (!pa_channel_map_can_fade(map))
 767         return 0.0f;
 768
 769     get_avg_fr(map, v, &front, &rear);
 770
 771     if (front == rear)
 772         return 0.0f;
 773
 774     if (rear > front)
 775         return -1.0f + ((float) front / (float) rear);
 776     else
 777         return 1.0f - ((float) rear / (float) front);
 778 }
 779
 780 pa_cvolume* pa_cvolume_set_fade(pa_cvolume *v, const pa_channel_map *map, float new_fade) {
 781     pa_volume_t front, nfront, rear, nrear, m;
 782     unsigned c;
 783
 784     pa_assert(map);
 785     pa_assert(v);
 786
 787     pa_return_val_if_fail(pa_cvolume_compatible_with_channel_map(v, map), NULL);
 788     pa_return_val_if_fail(new_fade >= -1.0f, NULL);
 789     pa_return_val_if_fail(new_fade <= 1.0f, NULL);
 790
 791     if (!pa_channel_map_can_fade(map))
 792         return v;
 793
 794     get_avg_fr(map, v, &front, &rear);
 795
 796     m = PA_MAX(front, rear);
 797
 798     if (new_fade <= 0) {
 799         nfront  = (new_fade + 1.0f) * m;
 800         nrear = m;
 801     } else  {
 802         nrear = (1.0f - new_fade) * m;
 803         nfront = m;
 804     }
 805
 806     for (c = 0; c < map->channels; c++) {
 807         if (on_front(map->map[c])) {
 808             if (front == 0)
 809                 v->values[c] = nfront;
 810             else
 811                 v->values[c] = (pa_volume_t) (((uint64_t) v->values[c] * (uint64_t) nfront) / (uint64_t) front);
 812         } else if (on_rear(map->map[c])) {
 813             if (rear == 0)
 814                 v->values[c] = nrear;
 815             else
 816                 v->values[c] = (pa_volume_t) (((uint64_t) v->values[c] * (uint64_t) nrear) / (uint64_t) rear);
 817         }
 818     }
 819
 820     return v;
 821 }
 822
 823 pa_cvolume* pa_cvolume_set_position(
 824         pa_cvolume *cv,
 825         const pa_channel_map *map,
 826         pa_channel_position_t t,
 827         pa_volume_t v) {
 828
 829     unsigned c;
 830     pa_bool_t good = FALSE;
 831
 832     pa_assert(cv);
 833     pa_assert(map);
 834
 835     pa_return_val_if_fail(pa_cvolume_compatible_with_channel_map(cv, map), NULL);
 836     pa_return_val_if_fail(t < PA_CHANNEL_POSITION_MAX, NULL);
 837     pa_return_val_if_fail(v != PA_VOLUME_INVALID, NULL);
 838
 839     for (c = 0; c < map->channels; c++)
 840         if (map->map[c] == t) {
 841             cv->values[c] = v;
 842             good = TRUE;
 843         }
 844
 845     return good ? cv : NULL;
 846 }
 847
 848 pa_volume_t pa_cvolume_get_position(
 849         pa_cvolume *cv,
 850         const pa_channel_map *map,
 851         pa_channel_position_t t) {
 852
 853     unsigned c;
 854     pa_volume_t v = PA_VOLUME_MUTED;
 855
 856     pa_assert(cv);
 857     pa_assert(map);
 858
 859     pa_return_val_if_fail(pa_cvolume_compatible_with_channel_map(cv, map), PA_VOLUME_MUTED);
 860     pa_return_val_if_fail(t < PA_CHANNEL_POSITION_MAX, PA_VOLUME_MUTED);
 861
 862     for (c = 0; c < map->channels; c++)
 863         if (map->map[c] == t)
 864             if (cv->values[c] > v)
 865                 v = cv->values[c];
 866
 867     return v;
 868 }
 869
 870 pa_cvolume* pa_cvolume_merge(pa_cvolume *dest, const pa_cvolume *a, const pa_cvolume *b) {
 871     unsigned i;
 872
 873     pa_assert(dest);
 874     pa_assert(a);
 875     pa_assert(b);
 876
 877     pa_return_val_if_fail(pa_cvolume_valid(a), NULL);
 878     pa_return_val_if_fail(pa_cvolume_valid(b), NULL);
 879
 880     for (i = 0; i < a->channels && i < b->channels; i++)
 881         dest->values[i] = PA_MAX(a->values[i], b->values[i]);
 882
 883     dest->channels = (uint8_t) i;
 884
 885     return dest;
 886 }
 887
 888 pa_cvolume* pa_cvolume_inc(pa_cvolume *v, pa_volume_t inc) {
 889     pa_volume_t m;
 890
 891     pa_assert(v);
 892
 893     pa_return_val_if_fail(pa_cvolume_valid(v), NULL);
 894     pa_return_val_if_fail(inc != PA_VOLUME_INVALID, NULL);
 895
 896     m = pa_cvolume_max(v);
 897
 898     if (m >= PA_VOLUME_MAX - inc)
 899         m = PA_VOLUME_MAX;
 900     else
 901         m += inc;
 902
 903     return pa_cvolume_scale(v, m);
 904 }
 905
 906 pa_cvolume* pa_cvolume_dec(pa_cvolume *v, pa_volume_t dec) {
 907     pa_volume_t m;
 908
 909     pa_assert(v);
 910
 911     pa_return_val_if_fail(pa_cvolume_valid(v), NULL);
 912     pa_return_val_if_fail(dec != PA_VOLUME_INVALID, NULL);
 913
 914     m = pa_cvolume_max(v);
 915
 916     if (m <= PA_VOLUME_MUTED + dec)
 917         m = PA_VOLUME_MUTED;
 918     else
 919         m -= dec;
 920
 921     return pa_cvolume_scale(v, m);
 922 }