Fix a small theoretical inefficiency; does not actually matter in practice, just...

[nageru] / audio_mixer.cpp

diff --git a/audio_mixer.cpp b/audio_mixer.cpp
index 8d09ad3bfa9a279f5d74af38613503ce835311e8..13eed33048fe5fcf659bf1ed762bb522ef4adfcc 100644 (file)
--- a/audio_mixer.cpp
+++ b/audio_mixer.cpp
@@ -6,6 +6,9 @@
 #include <stdio.h>
 #include <endian.h>
 #include <cmath>
+#ifdef __SSE__
+#include <immintrin.h>
+#endif
 
 #include "db.h"
 #include "flags.h"
@@ -77,7 +80,9 @@ void convert_fixed32_to_fp32(float *dst, size_t out_channel, size_t out_num_chan
        }
 }
 
-float find_peak(const float *samples, size_t num_samples)
+float find_peak_plain(const float *samples, size_t num_samples) __attribute__((unused));
+
+float find_peak_plain(const float *samples, size_t num_samples)
 {
        float m = fabs(samples[0]);
        for (size_t i = 1; i < num_samples; ++i) {
@@ -86,6 +91,54 @@ float find_peak(const float *samples, size_t num_samples)
        return m;
 }
 
+#ifdef __SSE__
+static inline float horizontal_max(__m128 m)
+{
+       __m128 tmp = _mm_shuffle_ps(m, m, _MM_SHUFFLE(1, 0, 3, 2));
+       m = _mm_max_ps(m, tmp);
+       tmp = _mm_shuffle_ps(m, m, _MM_SHUFFLE(2, 3, 0, 1));
+       m = _mm_max_ps(m, tmp);
+       return _mm_cvtss_f32(m);
+}
+
+float find_peak(const float *samples, size_t num_samples)
+{
+       const __m128 abs_mask = _mm_castsi128_ps(_mm_set1_epi32(0x7fffffffu));
+       __m128 m = _mm_setzero_ps();
+       for (size_t i = 0; i < (num_samples & ~3); i += 4) {
+               __m128 x = _mm_loadu_ps(samples + i);
+               x = _mm_and_ps(x, abs_mask);
+               m = _mm_max_ps(m, x);
+       }
+       float result = horizontal_max(m);
+
+       for (size_t i = (num_samples & ~3); i < num_samples; ++i) {
+               result = max(result, fabs(samples[i]));
+       }
+
+#if 0
+       // Self-test. We should be bit-exact the same.
+       float reference_result = find_peak_plain(samples, num_samples);
+       if (result != reference_result) {
+               fprintf(stderr, "Error: Peak is %f [%f %f %f %f]; should be %f.\n",
+                       result,
+                       _mm_cvtss_f32(_mm_shuffle_ps(m, m, _MM_SHUFFLE(0, 0, 0, 0))),
+                       _mm_cvtss_f32(_mm_shuffle_ps(m, m, _MM_SHUFFLE(1, 1, 1, 1))),
+                       _mm_cvtss_f32(_mm_shuffle_ps(m, m, _MM_SHUFFLE(2, 2, 2, 2))),
+                       _mm_cvtss_f32(_mm_shuffle_ps(m, m, _MM_SHUFFLE(3, 3, 3, 3))),
+                       reference_result);
+               abort();
+       }
+#endif
+       return result;
+}
+#else
+float find_peak(const float *samples, size_t num_samples)
+{
+       return find_peak_plain(samples, num_samples);
+}
+#endif
+
 void deinterleave_samples(const vector<float> &in, vector<float> *out_l, vector<float> *out_r)
 {
        size_t num_samples = in.size() / 2;
@@ -211,8 +264,7 @@ bool AudioMixer::add_audio(DeviceSpec device_spec, const uint8_t *data, unsigned
        assert(num_channels > 0);
 
        // Convert the audio to fp32.
-       vector<float> audio;
-       audio.resize(num_samples * num_channels);
+       unique_ptr<float[]> audio(new float[num_samples * num_channels]);
        unsigned channel_index = 0;
        for (auto channel_it = device->interesting_channels.cbegin(); channel_it != device->interesting_channels.end(); ++channel_it, ++channel_index) {
                switch (audio_format.bits_per_sample) {
@@ -220,13 +272,13 @@ bool AudioMixer::add_audio(DeviceSpec device_spec, const uint8_t *data, unsigned
                        assert(num_samples == 0);
                        break;
                case 16:
-                       convert_fixed16_to_fp32(&audio[0], channel_index, num_channels, data, *channel_it, audio_format.num_channels, num_samples);
+                       convert_fixed16_to_fp32(audio.get(), channel_index, num_channels, data, *channel_it, audio_format.num_channels, num_samples);
                        break;
                case 24:
-                       convert_fixed24_to_fp32(&audio[0], channel_index, num_channels, data, *channel_it, audio_format.num_channels, num_samples);
+                       convert_fixed24_to_fp32(audio.get(), channel_index, num_channels, data, *channel_it, audio_format.num_channels, num_samples);
                        break;
                case 32:
-                       convert_fixed32_to_fp32(&audio[0], channel_index, num_channels, data, *channel_it, audio_format.num_channels, num_samples);
+                       convert_fixed32_to_fp32(audio.get(), channel_index, num_channels, data, *channel_it, audio_format.num_channels, num_samples);
                        break;
                default:
                        fprintf(stderr, "Cannot handle audio with %u bits per sample\n", audio_format.bits_per_sample);
@@ -236,7 +288,7 @@ bool AudioMixer::add_audio(DeviceSpec device_spec, const uint8_t *data, unsigned
 
        // Now add it.
        int64_t local_pts = device->next_local_pts;
-       device->resampling_queue->add_input_samples(local_pts / double(TIMEBASE), audio.data(), num_samples);
+       device->resampling_queue->add_input_samples(local_pts / double(TIMEBASE), audio.get(), num_samples);
        device->next_local_pts = local_pts + frame_length;
        return true;
 }