volume,channelmap: reimplement a couple of calls based on channel masks

diff --git a/src/pulse/channelmap.c b/src/pulse/channelmap.c
index f663f17659383c35ae02456c69561bb0f84ac2dc..8882301276c06d2da4f0bd6a98c6af2326f679bc 100644 (file)
--- a/src/pulse/channelmap.c
+++ b/src/pulse/channelmap.c
@@ -30,9 +30,11 @@
 
 #include <pulse/xmalloc.h>
 #include <pulse/i18n.h>
+
 #include <pulsecore/core-util.h>
 #include <pulsecore/macro.h>
 #include <pulsecore/bitset.h>
+#include <pulsecore/sample-util.h>
 
 #include "channelmap.h"
 
@@ -631,8 +633,7 @@ int pa_channel_map_compatible(const pa_channel_map *map, const pa_sample_spec *s
 }
 
 int pa_channel_map_superset(const pa_channel_map *a, const pa_channel_map *b) {
-    pa_bitset_t in_a[PA_BITSET_ELEMENTS(PA_CHANNEL_POSITION_MAX)];
-    unsigned i;
+    pa_channel_position_mask_t am, bm;
 
     pa_assert(a);
     pa_assert(b);
@@ -640,98 +641,36 @@ int pa_channel_map_superset(const pa_channel_map *a, const pa_channel_map *b) {
     pa_return_val_if_fail(pa_channel_map_valid(a), 0);
     pa_return_val_if_fail(pa_channel_map_valid(b), 0);
 
-    memset(in_a, 0, sizeof(in_a));
-
-    for (i = 0; i < a->channels; i++)
-        pa_bitset_set(in_a, a->map[i], TRUE);
+    am = pa_channel_map_mask(a);
+    bm = pa_channel_map_mask(b);
 
-    for (i = 0; i < b->channels; i++)
-        if (!pa_bitset_get(in_a, b->map[i]))
-            return 0;
-
-    return 1;
+    return (bm & am) == bm;
 }
 
 int pa_channel_map_can_balance(const pa_channel_map *map) {
-    unsigned c;
-    pa_bool_t left = FALSE, right = FALSE;
+    pa_channel_position_mask_t m;
 
     pa_assert(map);
-
     pa_return_val_if_fail(pa_channel_map_valid(map), 0);
 
-    for (c = 0; c < map->channels; c++) {
-
-        switch (map->map[c]) {
-            case PA_CHANNEL_POSITION_LEFT:
-            case PA_CHANNEL_POSITION_REAR_LEFT:
-            case PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER:
-            case PA_CHANNEL_POSITION_SIDE_LEFT:
-            case PA_CHANNEL_POSITION_TOP_FRONT_LEFT:
-            case PA_CHANNEL_POSITION_TOP_REAR_LEFT:
-                left = TRUE;
-                break;
-
-            case PA_CHANNEL_POSITION_RIGHT:
-            case PA_CHANNEL_POSITION_REAR_RIGHT:
-            case PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER:
-            case PA_CHANNEL_POSITION_SIDE_RIGHT:
-            case PA_CHANNEL_POSITION_TOP_FRONT_RIGHT:
-            case PA_CHANNEL_POSITION_TOP_REAR_RIGHT:
-                right = TRUE;
-                break;
-
-            default:
-                ;
-        }
+    m = pa_channel_map_mask(map);
 
-        if (left && right)
-            return 1;
-    }
-
-    return 0;
+    return
+        (PA_CHANNEL_POSITION_MASK_LEFT & m) &&
+        (PA_CHANNEL_POSITION_MASK_RIGHT & m);
 }
 
 int pa_channel_map_can_fade(const pa_channel_map *map) {
-    unsigned c;
-    pa_bool_t front = FALSE, rear = FALSE;
+    pa_channel_position_mask_t m;
 
     pa_assert(map);
-
     pa_return_val_if_fail(pa_channel_map_valid(map), 0);
 
-    for (c = 0; c < map->channels; c++) {
-
-        switch (map->map[c]) {
-            case PA_CHANNEL_POSITION_FRONT_LEFT:
-            case PA_CHANNEL_POSITION_FRONT_RIGHT:
-            case PA_CHANNEL_POSITION_FRONT_CENTER:
-            case PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER:
-            case PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER:
-            case PA_CHANNEL_POSITION_TOP_FRONT_LEFT:
-            case PA_CHANNEL_POSITION_TOP_FRONT_RIGHT:
-            case PA_CHANNEL_POSITION_TOP_FRONT_CENTER:
-                front = TRUE;
-                break;
-
-            case PA_CHANNEL_POSITION_REAR_LEFT:
-            case PA_CHANNEL_POSITION_REAR_RIGHT:
-            case PA_CHANNEL_POSITION_REAR_CENTER:
-            case PA_CHANNEL_POSITION_TOP_REAR_LEFT:
-            case PA_CHANNEL_POSITION_TOP_REAR_RIGHT:
-            case PA_CHANNEL_POSITION_TOP_REAR_CENTER:
-                rear = TRUE;
-                break;
-
-            default:
-                ;
-        }
+    m = pa_channel_map_mask(map);
 
-        if (front && rear)
-            return 1;
-    }
-
-    return 0;
+    return
+        (PA_CHANNEL_POSITION_MASK_FRONT & m) &&
+        (PA_CHANNEL_POSITION_MASK_REAR & m);
 }
 
 const char* pa_channel_map_to_name(const pa_channel_map *map) {

diff --git a/src/pulse/volume.c b/src/pulse/volume.c
index 76ef7aa5a15a811232ba195ac3972689f58b19a3..42cde5b9676bd4d0c313854601bfda277be0c908 100644 (file)
--- a/src/pulse/volume.c
+++ b/src/pulse/volume.c
@@ -27,8 +27,10 @@
 #include <string.h>
 
 #include <pulse/i18n.h>
+
 #include <pulsecore/core-util.h>
 #include <pulsecore/macro.h>
+#include <pulsecore/sample-util.h>
 
 #include "volume.h"
 
@@ -418,65 +420,27 @@ int pa_cvolume_valid(const pa_cvolume *v) {
 }
 
 static pa_bool_t on_left(pa_channel_position_t p) {
-
-    return
-        p == PA_CHANNEL_POSITION_FRONT_LEFT ||
-        p == PA_CHANNEL_POSITION_REAR_LEFT ||
-        p == PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER ||
-        p == PA_CHANNEL_POSITION_SIDE_LEFT ||
-        p == PA_CHANNEL_POSITION_TOP_FRONT_LEFT ||
-        p == PA_CHANNEL_POSITION_TOP_REAR_LEFT;
+    return !!(PA_CHANNEL_POSITION_MASK(p) & PA_CHANNEL_POSITION_MASK_LEFT);
 }
 
 static pa_bool_t on_right(pa_channel_position_t p) {
-
-    return
-        p == PA_CHANNEL_POSITION_FRONT_RIGHT ||
-        p == PA_CHANNEL_POSITION_REAR_RIGHT ||
-        p == PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER ||
-        p == PA_CHANNEL_POSITION_SIDE_RIGHT ||
-        p == PA_CHANNEL_POSITION_TOP_FRONT_RIGHT ||
-        p == PA_CHANNEL_POSITION_TOP_REAR_RIGHT;
+    return !!(PA_CHANNEL_POSITION_MASK(p) & PA_CHANNEL_POSITION_MASK_RIGHT);
 }
 
 static pa_bool_t on_center(pa_channel_position_t p) {
-
-    return
-        p == PA_CHANNEL_POSITION_FRONT_CENTER ||
-        p == PA_CHANNEL_POSITION_REAR_CENTER ||
-        p == PA_CHANNEL_POSITION_TOP_CENTER ||
-        p == PA_CHANNEL_POSITION_TOP_FRONT_CENTER ||
-        p == PA_CHANNEL_POSITION_TOP_REAR_CENTER;
+    return !!(PA_CHANNEL_POSITION_MASK(p) & PA_CHANNEL_POSITION_MASK_CENTER);
 }
 
 static pa_bool_t on_lfe(pa_channel_position_t p) {
-
-    return
-        p == PA_CHANNEL_POSITION_LFE;
+    return p == PA_CHANNEL_POSITION_LFE;
 }
 
 static pa_bool_t on_front(pa_channel_position_t p) {
-
-    return
-        p == PA_CHANNEL_POSITION_FRONT_LEFT ||
-        p == PA_CHANNEL_POSITION_FRONT_RIGHT ||
-        p == PA_CHANNEL_POSITION_FRONT_CENTER ||
-        p == PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER ||
-        p == PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER ||
-        p == PA_CHANNEL_POSITION_TOP_FRONT_LEFT ||
-        p == PA_CHANNEL_POSITION_TOP_FRONT_RIGHT ||
-        p == PA_CHANNEL_POSITION_TOP_FRONT_CENTER;
+    return !!(PA_CHANNEL_POSITION_MASK(p) & PA_CHANNEL_POSITION_MASK_FRONT);
 }
 
 static pa_bool_t on_rear(pa_channel_position_t p) {
-
-    return
-        p == PA_CHANNEL_POSITION_REAR_LEFT ||
-        p == PA_CHANNEL_POSITION_REAR_RIGHT ||
-        p == PA_CHANNEL_POSITION_REAR_CENTER ||
-        p == PA_CHANNEL_POSITION_TOP_REAR_LEFT ||
-        p == PA_CHANNEL_POSITION_TOP_REAR_RIGHT ||
-        p == PA_CHANNEL_POSITION_TOP_REAR_CENTER;
+    return !!(PA_CHANNEL_POSITION_MASK(p) & PA_CHANNEL_POSITION_MASK_REAR);
 }
 
 pa_cvolume *pa_cvolume_remap(pa_cvolume *v, const pa_channel_map *from, const pa_channel_map *to) {