gstreamplayer.h

Go to the documentation of this file.

 
#pragma once
 
#include <config.h>
 
#include <string>
#include <memory>
#include <mutex>
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdocumentation"
#pragma GCC diagnostic ignored "-Wshadow"
#include <gst/gst.h>
#pragma GCC diagnostic pop
 
#include "mediaplayer.h"
#include "audio/audiooutput.h"
#include "fundamentals.h"
 
namespace Audio {
    class GstreamerAudioException : public AudioException {
    public:
        GstreamerAudioException (const char *func, const char *error,
                                 const char *what = nullptr, const char *what2 = nullptr);
        GstreamerAudioException (const char *func, GError *error, const char *what = nullptr);
 
//        GstreamerAudioException (const std::string &func, const Glib::ustring &error);
    };
 
 
 
    class GstreamerSimplePipeline {
    protected:
        GstElement *pipeline;         
        GstElement *chain_start = nullptr;   
        GstElement *pipeline_last = nullptr; 
 
        void add (GstElement *element);
 
    protected:
        mutable std::recursive_mutex state_mutex;
        mutable std::unique_ptr<GstreamerAudioException> pipeline_exception; 
        void throwDeferredException (const GstreamerAudioException &exception,
                                     bool asynchronously = false) const;
        inline void throwAsyncException (const GstreamerAudioException &exception) {
            throwDeferredException (exception, true);
        }
 
        void push (GstElement *item);
        GstElement *createElement (const char *name,
                                   const std::string &overrides = "");
        GstState currentPipelineState () const;
        void setPipelineState (GstState state);        
 
    public:
        GstreamerSimplePipeline ();
        virtual ~GstreamerSimplePipeline ();
    };
 
    class GstreamerDoublePipeline : public GstreamerSimplePipeline {
        GstElement *input_pipeline_last = nullptr; 
        gulong signal_handler_id = 0;
 
        static void on_pad_added (GstElement *,
                                  GstPad *pad,
                                  gpointer instance);
        void connectOutput(GstPad *pad);
 
    protected:
        void push (GstElement *item);
        void pushSource (GstElement *item);
 
    public:
        GstreamerDoublePipeline () = default;
        virtual ~GstreamerDoublePipeline () = default;
    };
 
 
    class GstreamerMediaReader : public GstreamerDoublePipeline {
    protected:
        const bool is_network = false;              
        const std::string url;                      
 
    private:
        GstElement *media_source = nullptr;    
        GstElement *decoder = nullptr;         
 
    public:
        GstreamerMediaReader (const std::string &media_url, int timeout = 15);
    };
 
 
 
    class GstreamerReaderWithBus : public GstreamerMediaReader {
    private:
        static gboolean on_bus_message (GstBus *bus, GstMessage *message, gpointer instance);
        bool notificationReceived (GstMessage *message);
 
    protected:
        virtual bool notification (GstMessage *message);
 
    public:
        GstreamerReaderWithBus (const std::string &media_url,
                                int timeout);
        virtual ~GstreamerReaderWithBus ();
    };
 
 
 
 
 
 
    class GstreamerPlayer : public GstreamerReaderWithBus, public Media::Player {
    private:
        AudioSettings audio; 
 
        GstElement *replay_gainer = nullptr;       
        GstElement *volume_filter = nullptr;       
        GstElement *format_converter = nullptr;    
        GstElement *output_device = nullptr;       
 
        // Regulate playback
        virtual void pause (void) override;
        virtual void abort (void) override;
        virtual void cue (void) override;
        virtual void play (void) override;
        virtual RESPONSE_CODE completionStatus (void) override;
 
        // Implement MediaPlayer API
        virtual void setVolume (float volume) override;
        virtual State currentState (void) const override;
        virtual float trackDuration (void) const override;
        virtual float playPoint (void) const override;
 
    public:
        GstreamerPlayer (const AudioSettings &audio_settings,
                         const std::string &media_url,
                         float initial_audio_gain);
        virtual ~GstreamerPlayer ();
    };
 
 
    
    class GstreamerOutput : public Output, public GstreamerSimplePipeline {
    private:
        AudioSettings audio; 
 
        GstElement *application_source = nullptr;  
        GstElement *format_converter = nullptr;    
        GstElement *output_device = nullptr;       
 
    public:
        GstreamerOutput (const AudioSettings &settings,
                         const AudioFormat &format);
        virtual bool play (void *buffer, unsigned numberOfBytes) override;
    };
 
 
}