PlayManager.h

/* PlayManager.h */

/* Copyright (C) 2011-2016  Lucio Carreras
 *
 * This file is part of sayonara player
 *
 * 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 3 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, see <http://www.gnu.org/licenses/>.
 */

#ifndef PLAY_MANAGER_H
#define PLAY_MANAGER_H

#include "Helper/globals.h"
#include "Helper/MetaData/MetaData.h"
#include "Helper/Settings/SayonaraClass.h"

template<typename T, int N_ITEMS>
class RingBuffer {

    private:
        int _cur_idx;
        int _n_items;
        T _data[N_ITEMS];

    public:
        RingBuffer(){
            clear();
        }

        void clear(){
            _cur_idx = 0;
            _n_items = 0;
        }

        void insert(const T& item){
            _data[_cur_idx] = item;
            _cur_idx = (_cur_idx + 1) % N_ITEMS;
            _n_items = std::min(N_ITEMS, _n_items + 1);
        }

        bool has_item(const T& item) const {
            for(int i=0; i<_n_items; i++){
                if(_data[i] == item){
                    return true;
                }
            }

            return false;
        }

        int count() const
        {
            return _n_items;
        }

        bool is_empty() const
        {
            return (_n_items == 0);
        }
};

class PlayManager : public QObject, protected SayonaraClass
{

    Q_OBJECT

    SINGLETON_QOBJECT(PlayManager)

    public:

        enum class PlayState : quint8 {
                       Playing=0,
                       Paused,
                       Stopped
        };


signals:

    void sig_www_track_finished(const MetaData& old_md);

    void sig_playstate_changed(PlayManager::PlayState);

    void sig_next();

    void sig_previous();

    void sig_stopped();

    void sig_seeked_rel(double percent);

    void sig_seeked_rel_ms(qint64 ms);

    void sig_seeked_abs_ms(quint64 ms);

    void sig_position_changed_ms(quint64 ms);

    void sig_track_changed(const MetaData& md);

    void sig_track_idx_changed(int idx);

    void sig_playlist_changed(int len);

    void sig_duration_changed(quint64 ms);

    void sig_playlist_finished();

    void sig_record(bool b);

    void sig_buffer(int b);

    void sig_volume_changed(int vol);


    void sig_mute_changed(bool b);

    void sig_md_changed(const MetaData& md);


    void sig_duration_changed(qint64 ms);


public slots:
    void play();

    void play_pause();

    void pause();

    void previous();

    void next();

    void stop();

    void record(bool b);

    void seek_rel(double percent);

    void seek_abs_ms(quint64 ms);

    void seek_rel_ms(qint64 ms);

    void set_position_ms(quint64 ms);

    void change_track(const MetaData& md, int playlist_idx);


    void duration_changed(quint64 duration_ms);

    void set_track_ready();

    void buffering(int progress);

    void volume_up();

    void volume_down();

    void set_volume(int vol);

    void set_mute(bool b);


    void change_metadata(const MetaData& md);



    void change_duration(qint64 ms);

public:
    PlayState   get_play_state() const;

    quint64     get_cur_position_ms() const;

    quint64     get_init_position_ms() const;

    quint64     get_duration_ms() const;

    MetaData    get_cur_track() const;

    int         get_volume() const;


    bool        get_mute() const;


private:
    RingBuffer<QString, 3>  _ring_buffer;
    quint64                 _position_ms;
    int                     _cur_idx;
    quint64                 _initial_position_ms;
    PlayState               _playstate;
    MetaData                _md;

};



#endif