serenity/Servers/AudioServer/ASMixer.cpp

#include <AK/BufferStream.h>
#include <AudioServer/ASClientConnection.h>
#include <AudioServer/ASMixer.h>
#include <limits>
#include <pthread.h>

ASMixer::ASMixer()
    : m_device(CFile::construct("/dev/audio", this))
    , m_sound_thread(
          [this] {
              mix();
              return 0;
          },
          "AudioServer[mixer]")
{
    if (!m_device->open(CIODevice::WriteOnly)) {
        dbgprintf("Can't open audio device: %s\n", m_device->error_string());
        return;
    }

    pthread_mutex_init(&m_pending_mutex, nullptr);
    pthread_cond_init(&m_pending_cond, nullptr);

    m_zero_filled_buffer = (u8*)malloc(4096);
    bzero(m_zero_filled_buffer, 4096);
    m_sound_thread.start();
}

ASMixer::~ASMixer()
{
}

NonnullRefPtr<ASBufferQueue> ASMixer::create_queue(ASClientConnection& client)
{
    auto queue = adopt(*new ASBufferQueue(client));
    pthread_mutex_lock(&m_pending_mutex);
    m_pending_mixing.append(*queue);
    pthread_cond_signal(&m_pending_cond);
    pthread_mutex_unlock(&m_pending_mutex);
    return queue;
}

void ASMixer::mix()
{
    decltype(m_pending_mixing) active_mix_queues;

    for (;;) {
        if (active_mix_queues.is_empty()) {
            pthread_mutex_lock(&m_pending_mutex);
            pthread_cond_wait(&m_pending_cond, &m_pending_mutex);
            active_mix_queues.append(move(m_pending_mixing));
            pthread_mutex_unlock(&m_pending_mutex);
        }

        active_mix_queues.remove_all_matching([&](auto& entry) { return !entry->client(); });

        ASample mixed_buffer[1024];
        auto mixed_buffer_length = (int)(sizeof(mixed_buffer) / sizeof(ASample));

        // Mix the buffers together into the output
        for (auto& queue : active_mix_queues) {
            if (!queue->client()) {
                queue->clear();
                continue;
            }

            for (int i = 0; i < mixed_buffer_length; ++i) {
                auto& mixed_sample = mixed_buffer[i];
                ASample sample;
                if (!queue->get_next_sample(sample))
                    break;
                mixed_sample += sample;
            }
        }

        bool muted = m_muted;

        // output the mixed stuff to the device
        u8 raw_buffer[4096];
        auto buffer = ByteBuffer::wrap(muted ? m_zero_filled_buffer : raw_buffer, sizeof(raw_buffer));

        BufferStream stream(buffer);
        if (!muted) {
            for (int i = 0; i < mixed_buffer_length; ++i) {
                auto& mixed_sample = mixed_buffer[i];

                mixed_sample.scale(m_main_volume);
                mixed_sample.clip();

                i16 out_sample;
                out_sample = mixed_sample.left * std::numeric_limits<i16>::max();
                stream << out_sample;

                ASSERT(!stream.at_end()); // we should have enough space for both channels in one buffer!
                out_sample = mixed_sample.right * std::numeric_limits<i16>::max();
                stream << out_sample;
            }
        }

        if (stream.offset() != 0) {
            buffer.trim(stream.offset());
        }
        m_device->write(buffer);
    }
}

void ASMixer::set_muted(bool muted)
{
    if (m_muted == muted)
        return;
    m_muted = muted;
    ASClientConnection::for_each([muted](ASClientConnection& client) {
        client.did_change_muted_state({}, muted);
    });
}

ASBufferQueue::ASBufferQueue(ASClientConnection& client)
    : m_client(client.make_weak_ptr())
{
}

void ASBufferQueue::enqueue(NonnullRefPtr<ABuffer>&& buffer)
{
    m_remaining_samples += buffer->sample_count();
    m_queue.enqueue(move(buffer));
}