tuner.h

Go to the documentation of this file.

 
#pragma once
 
#include <config.h>
 
#include <unordered_map>
#include <functional>
 
#include "callback.h"
#include "fundamentals.h"
#include "interpreter.h"
#include "musictypes.h"
#include "retainer.h"
 
 
enum class CartsVerb {
    CLEAR,
    ADD,
    REMOVE,
    TOGGLE,
    SET
};
 
extern const LookupTable <CartsVerb> CartsWord;
 
 
namespace Tuner {
 
    enum TUNERCOMMAND {
        MIXINCLUDED = CMD_RANGE_TUNING, 
        MIXEXCLUDED,     
        MIXADJUST,       
        PLAYLISTLIST,    
        AUTOTUNESETMODE, 
        AUTOTUNEGETMODE, 
        SELECTIONMETHOD, 
    };
 
    struct AutotuneSettings {
        bool login = false; 
        bool flag = false; 
        float veto_threshold = ratingAsFloat (Rating::POOR); 
        float rejection_threshold = ratingAsFloat (Rating::NEUTRAL); 
        float inclusion_threshold = ratingAsFloat (Rating::GOOD); 
        int quantity_goal = 999; 
        float quality_margin = 10; 
    };
 
    const Parsnip::Parser::Definitions &parser_definitions ();
    const PianodSchema::CommandIds &json_request_names ();
    const Parsnip::OptionParser::Definitions &autotuning_option_parser_definitions ();
 
    class Tuner : public PianodInterpreter {
        PianodService *service;
        struct MixItem {
            Retainer <PianodPlaylist *>playlist;
            bool enabled = false;
        };
        using MixMap = std::unordered_map<std::string, MixItem>;
        MixMap mix;
        bool automatic_mode = false;
        bool anyone_listening = false;
        Media::SelectionMethod random_selection_method = Media::SelectionMethod::Song;
 
        AutotuneSettings autotune;
 
    public:
        struct Callbacks {
            std::function<void ()> playlistsChanged;
            std::function<void (bool automatically, const char *explanation)> mixChanged;
        };
        CallbackManager<Tuner, Callbacks> callback;
 
        virtual const Parsnip::Parser::Definitions &getParserDefinitions () override;
    private:
        virtual bool authorizedCommand (Parsnip::Parser::CommandId command, PianodConnection &conn) override;
        virtual ResponseCollector handleCommand (Parsnip::Parser::CommandId command, const Parsnip::Data &options, PianodConnection &conn) override;
 
        void sourcesChanged (const Media::Source * const );
    protected:
        PianodPlaylist *getRandomPlaylist (const PianodPlaylist *criteria);
    public:
        Tuner (PianodService *service);
        ~Tuner();
        void updatePlaylists ();
        bool includedInMix (const PianodPlaylist *playlist);
        SongList getRandomTracks (PianodPlaylist *from, const UserList &users);
        void purge (const Media::Source * const source);
        void pushPlaylistSelections (Media::Source * const source = nullptr);
        bool recalculatePlaylists ();
        bool empty(const Media::Source * const source) const;
        bool automatic () const { return automatic_mode; };
        void automatic (bool automatic_playlists);
        static UserList getApplicableUsers (const AutotuneSettings &settings,
                                            const PianodService *service);
        UserList getAutotuneUsers () const;
        Response assembleStatus () const;
    };
}