streamplayer.h

/*
 * This file is part of Copiste.
 *
 * Copiste 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.
 *
 *  Copiste 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 Copiste.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef INCLUDEDSTREAMPLAYERH
#define INCLUDEDSTREAMPLAYERH

#include <vlc/vlc.h>

#include <QMutex>

#include <boost/thread.hpp>
#include <boost/date_time.hpp>
#include <cstdio>
#include <cstdlib>
#include <sstream>
#include <string>

#include "features/spectrum.h"

const int DEFAULT_AUDIO_CHUNK_SIZE = 1024; 
const int VLC_DEFAULT_VOLUME = 80;

using namespace std;

class StreamPlayer;

// Callbacks audio
void handleStream(void* p_audio_data, uint8_t* p_pcm_buffer, unsigned int channels, unsigned int rate,
                  unsigned int nb_samples, unsigned int bits_per_sample, unsigned int size, int64_t pts);
void prepareRender(void* p_audio_data, uint8_t** pp_pcm_buffer , unsigned int size);

class StreamPlayer
{
    public:
        // Set up functions

        StreamPlayer(bool live = false, bool verbose = true);
        ~StreamPlayer();
        string url() { return mUrl; }
        void setUrl(string url) { mUrl = url; }
        void setOverlapping(float factor);
        void setChunkSize(int size);
        int chunkSize() { return mChunkSize; }

        void play();
        libvlc_time_t playingTime();
        libvlc_time_t totalTime();
        void stop();
        bool isLive() { return mLive; }
        void setVolume(int vol);
        int volume();

        // Computing functions : designed to be overloaded by the user

        virtual void sequenceStarts() { ; }
        virtual void useBuffer() { ; }
        virtual void sequenceEnds() { ; }

        // Handling functions

        static uint16_t* convert8to16(const uint8_t* source, int size);
        static uint16_t* average(uint16_t* source, int size, int passes, int scale= 1);
        static void reduce(uint16_t* source, uint16_t* dest, int size, int passes, int scale=1);
        static void addOffset(uint16_t* source, uint16_t* dest, int size, int offset);
        static int pow2(int n);

        void watch();

        inline uint16_t buffer(int i);
        inline int bufferSize();
        inline void fillBuffer(uint16_t value);
        inline void flushBuffer();

        std::deque<uint16_t> mBuffer;
        QMutex mLock;

        // Prerender callback
        char* mAudioData;
        unsigned int mAudioDataSize;
        unsigned int mFrequency; // detected from VLC

    protected:
        bool mVerbose;

    private:
        // Parameters
        string mUrl;
        bool mPlaying;
        bool mLive;
        float mOverlapping;
        
        int mChunkSize;
        int mFramesOverlap;

        // VLC
        libvlc_instance_t *mVlcInstance;
        libvlc_media_player_t *mMp;
        libvlc_media_t *mMedia;

        boost::thread mWatchThread;
        boost::mutex mPlayingLock;
};

#endif