ffmpegplayer.h

Go to the documentation of this file.

 
#pragma once
 
#include <config.h>
 
#include <string>
#include <memory>
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdocumentation"
extern "C" {
#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include <libavfilter/avfilter.h>
#ifdef HAVE_LIBAVFILTER_AVFILTERGRAPH_H
#include <libavfilter/avfiltergraph.h>
#endif
#include <libavutil/replaygain.h>
}
#pragma GCC diagnostic pop
 
#include "mediaplayer.h"
#include "audio/audiooutput.h"
#include "fundamentals.h"
 
namespace Audio {
 
    extern void flogav (const char *func, int err);
 
    class LavAudioException : public AudioException {
    public:
        LavAudioException (const char *func, int error);
    };
 
 
    class LavAdapter {
#ifdef HAVE_AVCODECPARAMETERS
        struct CodecParameterDeleter {
            void operator() (AVCodecParameters *params) {
                avcodec_parameters_free (&params);
            }
        };
#endif
 
        struct FilterGraphDeleter {
            void operator()(AVFilterGraph *filter) {
                avfilter_graph_free (&filter);
            }
        };
 
        // Filters are freed by freeing the graph
        struct FrameDeleter {
            void operator()(AVFrame *frame) {
                av_frame_free (&frame);
            }
        };
 
 
        AVFilterContext *buffer_filter = nullptr;
        AVFilterContext *volume_filter = nullptr;
        AVFilterContext *format_filter = nullptr;
        AVFilterContext *endpoint_filter = nullptr;
        std::unique_ptr <AVFilterGraph, FilterGraphDeleter> filter_stack;
 
        // Used to retrieve data from the endpoint filter.
        // This should be local, but needs to be alloced/dealloced.
        std::unique_ptr <AVFrame, FrameDeleter> output_frame = nullptr;
        std::mutex adapter_mutex;
 
        AVFilterContext *pushFilter (AVFilterContext *prior_filter,
                                     const char *name,
                                     const char *optionformat = nullptr, ...);
 
    protected:
        LavAdapter (const AVCodecContext *codec,
                    const AVStream *stream,
                    const AVSampleFormat output_format);
        virtual bool playFrame (AVFrame *frame) = 0;
        bool playFilteredPackets (const bool eof_return_value = true);
        void flush ();
    public:
        virtual ~LavAdapter ();
        bool play (AVFrame *frame);
        void setVolume (float level);
 
        static LavAdapter *getOutput (const AudioSettings &settings,
                                      const AVCodecContext *context,
                                      const AVStream *stream);
    };
 
 
    class LavGenericAdapter : public LavAdapter {
        std::unique_ptr <Output> output;
 
    public:
        LavGenericAdapter (const AVCodecContext *codec, const AVStream *stream,
                           Output *out, const AVSampleFormat output_format);
        ~LavGenericAdapter ();
        virtual bool playFrame (AVFrame *frame) override;
    };
 
    class LibavMediaReader {
    protected:
        struct CodecDeleter {
            void operator() (AVCodecContext *coder) {
                avcodec_free_context (&coder);
            }
        };
 
        const std::string url; 
        bool is_network = false; 
        AVFormatContext *transport = nullptr;
 
        // Private functions
        int initializeStream (std::unique_ptr <AVCodecContext, CodecDeleter> &codec_context);
        void processReplayGain (AVReplayGain *gain, int size);
        virtual void setGain (float gain) = 0;
    public:
        LibavMediaReader (const std::string &media_url, int timeout = 15);
        virtual ~LibavMediaReader (void);
    };
 
 
 
    class LavPlayer: public Media::ThreadedPlayer, public LibavMediaReader {
    private:
        AudioSettings audio; 
        float gain = 0; 
 
        volatile float duration = -1; 
        volatile float playpoint = 0; 
        volatile Media::Player::State state = Initializing;
        std::unique_ptr <Audio::LavAdapter> output;
 
        // Private functions
        bool playPacket (AVFrame *frame,
                         AVCodecContext *codec,
                         AVPacket *packet);
        RESPONSE_CODE playStream (AVFormatContext *format,
                                  AVCodecContext *codec,
                                  const int audio_stream);
        virtual void setGain (float gain) 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;
        virtual RESPONSE_CODE playerThread (void) override;
        virtual void pausing (void) override;
        virtual void resuming (void) override;
    public:
        LavPlayer (const AudioSettings &AudioSettings,
                   const std::string &media_url,
                   float audio_gain = 0);
    };
 
}