DecoderControl.hxx

Go to the documentation of this file.

/*
 * Copyright 2003-2017 The Music Player Daemon Project
 * http://www.musicpd.org
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef MPD_DECODER_CONTROL_HXX
#define MPD_DECODER_CONTROL_HXX

#include "DecoderCommand.hxx"
#include "AudioFormat.hxx"
#include "MixRampInfo.hxx"
#include "thread/Mutex.hxx"
#include "thread/Cond.hxx"
#include "thread/Thread.hxx"
#include "Chrono.hxx"
#include "ReplayGainConfig.hxx"
#include "ReplayGainMode.hxx"

#include <exception>

#include <utility>

#include <assert.h>
#include <stdint.h>

/* damn you, windows.h! */
#ifdef ERROR
#undef ERROR
#endif

class DetachedSong;
class MusicBuffer;
class MusicPipe;

enum class DecoderState : uint8_t {
        STOP = 0,
        START,
        DECODE,

        ERROR,
};

struct DecoderControl {
        Thread thread;

        Mutex &mutex;

        Cond cond;

        Cond &client_cond;

        DecoderState state = DecoderState::STOP;
        DecoderCommand command = DecoderCommand::NONE;

        std::exception_ptr error;

        bool quit;

        bool client_is_waiting = false;

        bool seek_error;
        bool seekable;
        SongTime seek_time;

        const AudioFormat configured_audio_format;

        AudioFormat in_audio_format;

        AudioFormat out_audio_format;

        DetachedSong *song = nullptr;

        SongTime start_time;

        SongTime end_time;

        SignedSongTime total_time;

        MusicBuffer *buffer;

        MusicPipe *pipe;

        const ReplayGainConfig replay_gain_config;
        ReplayGainMode replay_gain_mode = ReplayGainMode::OFF;

        float replay_gain_db = 0;
        float replay_gain_prev_db = 0;

        MixRampInfo mix_ramp, previous_mix_ramp;

        DecoderControl(Mutex &_mutex, Cond &_client_cond,
                       const AudioFormat _configured_audio_format,
                       const ReplayGainConfig &_replay_gain_config);
        ~DecoderControl();

        void Lock() const {
                mutex.lock();
        }

        void Unlock() const {
                mutex.unlock();
        }

        void Signal() {
                cond.signal();
        }

        void Wait() {
                cond.wait(mutex);
        }

        void WaitForDecoder();

        bool IsIdle() const {
                return state == DecoderState::STOP ||
                        state == DecoderState::ERROR;
        }

        gcc_pure
        bool LockIsIdle() const noexcept {
                const std::lock_guard<Mutex> protect(mutex);
                return IsIdle();
        }

        bool IsStarting() const noexcept {
                return state == DecoderState::START;
        }

        gcc_pure
        bool LockIsStarting() const noexcept {
                const std::lock_guard<Mutex> protect(mutex);
                return IsStarting();
        }

        bool HasFailed() const noexcept {
                assert(command == DecoderCommand::NONE);

                return state == DecoderState::ERROR;
        }

        gcc_pure
        bool LockHasFailed() const noexcept {
                const std::lock_guard<Mutex> protect(mutex);
                return HasFailed();
        }

        void SetReady(const AudioFormat audio_format,
                      bool _seekable, SignedSongTime _duration);

        void CheckRethrowError() const {
                assert(command == DecoderCommand::NONE);
                assert(state != DecoderState::ERROR || error);

                if (state == DecoderState::ERROR)
                        std::rethrow_exception(error);
        }

        void LockCheckRethrowError() const {
                const std::lock_guard<Mutex> protect(mutex);
                CheckRethrowError();
        }

        void ClearError() {
                if (state == DecoderState::ERROR) {
                        error = std::exception_ptr();
                        state = DecoderState::STOP;
                }
        }

        gcc_pure
        bool IsCurrentSong(const DetachedSong &_song) const noexcept;

        gcc_pure
        bool IsSeekableCurrentSong(const DetachedSong &_song) const noexcept {
                return seekable && IsCurrentSong(_song);
        }

        gcc_pure
        bool LockIsSeeakbleCurrentSong(const DetachedSong &_song) const noexcept {
                const std::lock_guard<Mutex> protect(mutex);
                return IsSeekableCurrentSong(_song);
        }

private:
        void WaitCommandLocked() {
                while (command != DecoderCommand::NONE)
                        WaitForDecoder();
        }

        void SynchronousCommandLocked(DecoderCommand cmd) {
                command = cmd;
                Signal();
                WaitCommandLocked();
        }

        void LockSynchronousCommand(DecoderCommand cmd) {
                const std::lock_guard<Mutex> protect(mutex);
                ClearError();
                SynchronousCommandLocked(cmd);
        }

        void LockAsynchronousCommand(DecoderCommand cmd) {
                const std::lock_guard<Mutex> protect(mutex);
                command = cmd;
                Signal();
        }

public:
        void CommandFinishedLocked() {
                assert(command != DecoderCommand::NONE);

                command = DecoderCommand::NONE;
                client_cond.signal();
        }

        void Start(DetachedSong *song, SongTime start_time, SongTime end_time,
                   MusicBuffer &buffer, MusicPipe &pipe);

        void Stop();

        void Seek(SongTime t);

        void Quit();

        const char *GetMixRampStart() const {
                return mix_ramp.GetStart();
        }

        const char *GetMixRampEnd() const {
                return mix_ramp.GetEnd();
        }

        const char *GetMixRampPreviousEnd() const {
                return previous_mix_ramp.GetEnd();
        }

        void SetMixRamp(MixRampInfo &&new_value) {
                mix_ramp = std::move(new_value);
        }

        void CycleMixRamp();

private:
        void RunThread();
};

#endif