mainloop: Don't care about the mainloop state variable when waking up the mainloop.

[pulseaudio] / src / pulse / sample.c

diff --git a/src/pulse/sample.c b/src/pulse/sample.c
index 4b13a3370705b028f2d0ae018b28f819fd6cdc44..b6136120d28a7fdf69fda39bda773268052a63ba 100644 (file)
--- a/src/pulse/sample.c
+++ b/src/pulse/sample.c
@@ -6,7 +6,7 @@
 
   PulseAudio is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published
-  by the Free Software Foundation; either version 2 of the License,
+  by the Free Software Foundation; either version 2.1 of the License,
   or (at your option) any later version.
 
   PulseAudio is distributed in the hope that it will be useful, but
@@ -25,39 +25,37 @@
 #endif
 
 #include <stdio.h>
-#include <math.h>
 #include <string.h>
 
 #include <pulse/timeval.h>
-#include <pulse/i18n.h>
 
 #include <pulsecore/core-util.h>
+#include <pulsecore/i18n.h>
 #include <pulsecore/macro.h>
 
 #include "sample.h"
 
-size_t pa_sample_size_of_format(pa_sample_format_t f) {
-
-    static const size_t table[] = {
-        [PA_SAMPLE_U8] = 1,
-        [PA_SAMPLE_ULAW] = 1,
-        [PA_SAMPLE_ALAW] = 1,
-        [PA_SAMPLE_S16LE] = 2,
-        [PA_SAMPLE_S16BE] = 2,
-        [PA_SAMPLE_FLOAT32LE] = 4,
-        [PA_SAMPLE_FLOAT32BE] = 4,
-        [PA_SAMPLE_S32LE] = 4,
-        [PA_SAMPLE_S32BE] = 4,
-        [PA_SAMPLE_S24LE] = 3,
-        [PA_SAMPLE_S24BE] = 3,
-        [PA_SAMPLE_S24_32LE] = 4,
-        [PA_SAMPLE_S24_32BE] = 4
-    };
+static const size_t size_table[] = {
+    [PA_SAMPLE_U8] = 1,
+    [PA_SAMPLE_ULAW] = 1,
+    [PA_SAMPLE_ALAW] = 1,
+    [PA_SAMPLE_S16LE] = 2,
+    [PA_SAMPLE_S16BE] = 2,
+    [PA_SAMPLE_FLOAT32LE] = 4,
+    [PA_SAMPLE_FLOAT32BE] = 4,
+    [PA_SAMPLE_S32LE] = 4,
+    [PA_SAMPLE_S32BE] = 4,
+    [PA_SAMPLE_S24LE] = 3,
+    [PA_SAMPLE_S24BE] = 3,
+    [PA_SAMPLE_S24_32LE] = 4,
+    [PA_SAMPLE_S24_32BE] = 4
+};
 
+size_t pa_sample_size_of_format(pa_sample_format_t f) {
     pa_assert(f >= 0);
     pa_assert(f < PA_SAMPLE_MAX);
 
-    return table[f];
+    return size_table[f];
 }
 
 size_t pa_sample_size(const pa_sample_spec *spec) {
@@ -65,35 +63,35 @@ size_t pa_sample_size(const pa_sample_spec *spec) {
     pa_assert(spec);
     pa_return_val_if_fail(pa_sample_spec_valid(spec), 0);
 
-    return pa_sample_size_of_format(spec->format);
+    return size_table[spec->format];
 }
 
 size_t pa_frame_size(const pa_sample_spec *spec) {
     pa_assert(spec);
     pa_return_val_if_fail(pa_sample_spec_valid(spec), 0);
 
-    return pa_sample_size(spec) * spec->channels;
+    return size_table[spec->format] * spec->channels;
 }
 
 size_t pa_bytes_per_second(const pa_sample_spec *spec) {
     pa_assert(spec);
     pa_return_val_if_fail(pa_sample_spec_valid(spec), 0);
 
-    return spec->rate*pa_frame_size(spec);
+    return spec->rate * size_table[spec->format] * spec->channels;
 }
 
 pa_usec_t pa_bytes_to_usec(uint64_t length, const pa_sample_spec *spec) {
     pa_assert(spec);
     pa_return_val_if_fail(pa_sample_spec_valid(spec), 0);
 
-    return (((pa_usec_t) (length / pa_frame_size(spec)) * PA_USEC_PER_SEC) / spec->rate);
+    return (((pa_usec_t) (length / (size_table[spec->format] * spec->channels)) * PA_USEC_PER_SEC) / spec->rate);
 }
 
 size_t pa_usec_to_bytes(pa_usec_t t, const pa_sample_spec *spec) {
     pa_assert(spec);
     pa_return_val_if_fail(pa_sample_spec_valid(spec), 0);
 
-    return (size_t) (((t * spec->rate) / PA_USEC_PER_SEC)) * pa_frame_size(spec);
+    return (size_t) (((t * spec->rate) / PA_USEC_PER_SEC)) * (size_table[spec->format] * spec->channels);
 }
 
 pa_sample_spec* pa_sample_spec_init(pa_sample_spec *spec) {
@@ -109,12 +107,12 @@ pa_sample_spec* pa_sample_spec_init(pa_sample_spec *spec) {
 int pa_sample_spec_valid(const pa_sample_spec *spec) {
     pa_assert(spec);
 
-    if (spec->rate <= 0 ||
+    if (PA_UNLIKELY (spec->rate <= 0 ||
         spec->rate > PA_RATE_MAX ||
         spec->channels <= 0 ||
         spec->channels > PA_CHANNELS_MAX ||
         spec->format >= PA_SAMPLE_MAX ||
-        spec->format < 0)
+        spec->format < 0))
         return 0;
 
     return 1;
@@ -125,6 +123,10 @@ int pa_sample_spec_equal(const pa_sample_spec*a, const pa_sample_spec*b) {
     pa_assert(b);
 
     pa_return_val_if_fail(pa_sample_spec_valid(a), 0);
+
+    if (PA_UNLIKELY(a == b))
+        return 1;
+
     pa_return_val_if_fail(pa_sample_spec_valid(b), 0);
 
     return
@@ -231,13 +233,46 @@ pa_sample_format_t pa_parse_sample_format(const char *format) {
     else if (strcasecmp(format, "s24re") == 0)
         return PA_SAMPLE_S24RE;
     else if (strcasecmp(format, "s24-32le") == 0)
-        return PA_SAMPLE_S24LE;
+        return PA_SAMPLE_S24_32LE;
     else if (strcasecmp(format, "s24-32be") == 0)
-        return PA_SAMPLE_S24BE;
+        return PA_SAMPLE_S24_32BE;
     else if (strcasecmp(format, "s24-32ne") == 0 || strcasecmp(format, "s24-32") == 0)
-        return PA_SAMPLE_S24NE;
+        return PA_SAMPLE_S24_32NE;
     else if (strcasecmp(format, "s24-32re") == 0)
-        return PA_SAMPLE_S24RE;
+        return PA_SAMPLE_S24_32RE;
+
+    return PA_SAMPLE_INVALID;
+}
+
+int pa_sample_format_is_le(pa_sample_format_t f) {
+    pa_assert(f >= PA_SAMPLE_U8);
+    pa_assert(f < PA_SAMPLE_MAX);
+
+    switch (f) {
+        case PA_SAMPLE_S16LE:
+        case PA_SAMPLE_S24LE:
+        case PA_SAMPLE_S32LE:
+        case PA_SAMPLE_S24_32LE:
+        case PA_SAMPLE_FLOAT32LE:
+            return 1;
+
+        case PA_SAMPLE_S16BE:
+        case PA_SAMPLE_S24BE:
+        case PA_SAMPLE_S32BE:
+        case PA_SAMPLE_S24_32BE:
+        case PA_SAMPLE_FLOAT32BE:
+            return 0;
+
+        default:
+            return -1;
+    }
+}
+
+int pa_sample_format_is_be(pa_sample_format_t f) {
+    int r;
+
+    if ((r = pa_sample_format_is_le(f)) < 0)
+        return r;
 
-    return -1;
+    return !r;
 }