framefilter.h

Go to the documentation of this file.

#ifndef framefilter_HEADER_GUARD
#define framefilter_HEADER_GUARD
/*
 * framefilter.h : Definition of FrameFilter and derived classes for various purposes
 * 
 * Copyright 2017-2020 Valkka Security Ltd. and Sampsa Riikonen
 * 
 * Authors: Sampsa Riikonen <sampsa.riikonen@iki.fi>
 * 
 * This file is part of the Valkka library.
 * 
 * Valkka is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>
 *
 */
 
#include "frame.h"
#include "framefifo.h"
 
class FrameFilter { // <pyapi>
 
public: // <pyapi>
    FrameFilter(const char *name, FrameFilter *next = NULL); // don't include into the python api (this class is abstract)
    virtual ~FrameFilter();                                  
    
public:
    std::string name;
 
public:                // sometimes ffmpeg static functions need to access this! (in muxing at least)
    FrameFilter *next; 
 
protected: // <pyapi>
    // does the filtering
    virtual void go(Frame *frame) = 0; 
 
public: // API
    virtual void run(Frame *frame);
    void setVoid(); 
}; // <pyapi>
 
class DummyFrameFilter : public FrameFilter { // <pyapi>
 
public:                                                                                // <pyapi>
    DummyFrameFilter(const char *name, bool verbose = true, FrameFilter *next = NULL); // <pyapi>
 
protected:
    bool verbose;
 
protected:
    void go(Frame *frame);
 
}; // <pyapi>
 
class InfoFrameFilter : public FrameFilter { // <pyapi>
 
public:                                                          // <pyapi>
    InfoFrameFilter(const char *name, FrameFilter *next = NULL); // <pyapi>
 
protected:
    void go(Frame *frame);
}; // <pyapi>
 
class BriefInfoFrameFilter : public FrameFilter { // <pyapi>
 
public:                                                               // <pyapi>
    BriefInfoFrameFilter(const char *name, FrameFilter *next = NULL); // <pyapi>
 
protected:
    void go(Frame *frame);
}; // <pyapi>
 
class ThreadSafeFrameFilter : public FrameFilter { // <pyapi>
 
private:
    std::mutex mutex;
 
public:                                                                // <pyapi>
    ThreadSafeFrameFilter(const char *name, FrameFilter *next = NULL); // <pyapi>
 
protected:
    void go(Frame *frame);
 
public:
    void run(Frame *frame);
}; // <pyapi>
 
class ForkFrameFilter : public FrameFilter { // <pyapi>
 
public: // <pyapi>
    ForkFrameFilter(const char *name, FrameFilter *next = NULL, FrameFilter *next2 = NULL); // <pyapi>
 
protected:
    FrameFilter *next2;
 
protected:
    void go(Frame *frame);
 
public:
    void run(Frame *frame);
}; // <pyapi>
 
class ForkFrameFilter3 : public FrameFilter { // <pyapi>
 
public: // <pyapi>
    ForkFrameFilter3(const char *name, FrameFilter *next = NULL, FrameFilter *next2 = NULL, FrameFilter *next3 = NULL); // <pyapi>
 
protected:
    FrameFilter *next2;
    FrameFilter *next3;
 
protected:
    void go(Frame *frame);
 
public:
    void run(Frame *frame);
}; // <pyapi>
 
class ForkFrameFilterN : public FrameFilter { // <pyapi>
 
public: // <pyapi>
    ForkFrameFilterN(const char *name); // <pyapi>
    virtual ~ForkFrameFilterN(); // <pyapi>
 
protected:
    std::mutex mutex;
    std::map<std::string, FrameFilter *> framefilters; 
 
protected:
    void go(Frame *frame);
 
public:
    void run(Frame *frame); 
 
public: // <pyapi>
    bool connect(const char *tag, FrameFilter *filter); // <pyapi>
    bool disconnect(const char *tag); // <pyapi>
};                                    // <pyapi>
 
class SlotFrameFilter : public FrameFilter { // <pyapi>
 
public:                                                                             // <pyapi>
    SlotFrameFilter(const char *name, SlotNumber n_slot, FrameFilter *next = NULL); // <pyapi>
 
protected:
    unsigned n_slot;
 
protected:
    void go(Frame *frame);
 
}; // <pyapi>
 
class PassSlotFrameFilter : public FrameFilter { // <pyapi>
 
public:                                                                                 // <pyapi>
    PassSlotFrameFilter(const char *name, SlotNumber n_slot, FrameFilter *next = NULL); // <pyapi>
 
protected:
    unsigned n_slot;
 
protected:
    void go(Frame *frame);
 
public:
    void run(Frame *frame);
}; // <pyapi>
 
class DumpFrameFilter : public FrameFilter { // <pyapi>
 
public:                                                          // <pyapi>
    DumpFrameFilter(const char *name, FrameFilter *next = NULL); // <pyapi>
 
protected:
    int count;
 
protected:
    void go(Frame *frame);
}; // <pyapi>
 
class CountFrameFilter : public FrameFilter { // <pyapi>
 
public:                                                           // <pyapi>
    CountFrameFilter(const char *name, FrameFilter *next = NULL); // <pyapi>
 
protected:
    int count;
 
protected:
    void go(Frame *frame);
}; // <pyapi>
 
class TimestampFrameFilter : public FrameFilter { // <pyapi>
 
public:                                                                                                                 // <pyapi>
    TimestampFrameFilter(const char *name, FrameFilter *next = NULL, long int msdiff_max = TIMESTAMP_CORRECT_TRESHOLD); // <pyapi>
 
protected:
    long int mstime_delta;
    long int msdiff_max;
 
protected:
    void go(Frame *frame);
}; // <pyapi>
 
class TimestampFrameFilter2 : public FrameFilter { // <pyapi>
 
public:                                                                                                                  // <pyapi>
    TimestampFrameFilter2(const char *name, FrameFilter *next = NULL, long int msdiff_max = TIMESTAMP_CORRECT_TRESHOLD); // <pyapi>
 
protected:
    long int mstime_delta;
    long int msdiff_max;
    long int savedtimestamp;
 
protected:
    void go(Frame *frame);
}; // <pyapi>
 
class DummyTimestampFrameFilter : public FrameFilter { // <pyapi>
 
public:                                                                    // <pyapi>
    DummyTimestampFrameFilter(const char *name, FrameFilter *next = NULL); // <pyapi>
 
protected:
    void go(Frame *frame);
}; // <pyapi>
 
class RepeatH264ParsFrameFilter : public FrameFilter { // <pyapi>
 
public:                                                                    // <pyapi>
    RepeatH264ParsFrameFilter(const char *name, FrameFilter *next = NULL); // <pyapi>
 
protected:
    BasicFrame sps, pps;
    int phase;
 
protected:
    void go(Frame *frame);
 
public:
    void run(Frame *frame);
 
}; // <pyapi>
 
class GateFrameFilter : public FrameFilter { // <pyapi>
 
public:                                                          // <pyapi>
    GateFrameFilter(const char *name, FrameFilter *next = NULL); // <pyapi>
 
protected:
    bool on;
    bool config_frames;
    std::mutex mutex;
 
protected:
    void go(Frame *frame);
 
public:
    void run(Frame *frame);
 
public:                      // <pyapi>
    void set();              // <pyapi>
    void unSet();            // <pyapi>
    void passConfigFrames(); // <pyapi>
    void noConfigFrames();   // <pyapi>
};                           // <pyapi>
 
class SwitchFrameFilter : public FrameFilter { // <pyapi>
 
public:                                                                                        // <pyapi>
    SwitchFrameFilter(const char *name, FrameFilter *next1 = NULL, FrameFilter *next2 = NULL); // <pyapi>
 
protected:
    FrameFilter *next1;
    FrameFilter *next2;
 
protected:
    int index;
    std::mutex mutex;
 
protected:
    void go(Frame *frame);
 
public:
    void run(Frame *frame);
 
public:
    void set1(); // <pyapi>
    void set2(); // <pyapi>
};               // <pyapi>
 
class TypeFrameFilter : public FrameFilter
{
 
public:
    TypeFrameFilter(const char *name, FrameClass frameclass, FrameFilter *next = NULL);
 
protected:
    FrameClass frameclass;
 
protected:
    void go(Frame *frame);
    void run(Frame *frame);
};
 
class CachingGateFrameFilter : public FrameFilter { // <pyapi>
 
public:                                                                 // <pyapi>
    CachingGateFrameFilter(const char *name, FrameFilter *next = NULL); // <pyapi>
 
protected:
    bool on;
    std::mutex mutex;
    SetupFrame setupframe; // TODO: shouldn't we have array of setupframes here?
    bool got_setup;
 
protected:
    void go(Frame *frame);
 
public:
    void run(Frame *frame);
 
public:           // <pyapi>
    void set();   // <pyapi>
    void unSet(); // <pyapi>
};                // <pyapi>
 
class SetSlotFrameFilter : public FrameFilter { // <pyapi>
 
public:                                                             // <pyapi>
    SetSlotFrameFilter(const char *name, FrameFilter *next = NULL); // <pyapi>
 
protected:
    SlotNumber n_slot;
    std::mutex mutex;
 
protected:
    void go(Frame *frame);
 
public:                             // <pyapi>
    void setSlot(SlotNumber n = 0); // <pyapi>
 
}; // <pyapi>
 
class TimeIntervalFrameFilter : public FrameFilter { // <pyapi>
 
public:                                                                                        // <pyapi>
    TimeIntervalFrameFilter(const char *name, long int mstimedelta, FrameFilter *next = NULL); // <pyapi>
 
protected:
    long int mstimedelta;
    long int prevmstimestamp;
 
protected:
    void go(Frame *frame);
 
public:
    void run(Frame *frame);
 
}; // <pyapi>
 
class FifoFrameFilter : public FrameFilter { // <pyapi>
 
public: // <pyapi>
    FifoFrameFilter(const char *name, FrameFifo *framefifo); 
 
protected:
    FrameFifo *framefifo;
 
protected:
    void go(Frame *frame);
}; // <pyapi>
 
class BlockingFifoFrameFilter : public FrameFilter { // <pyapi>
 
public:                                                              // <pyapi>
    BlockingFifoFrameFilter(const char *name, FrameFifo *framefifo); 
 
protected:
    FrameFifo *framefifo;
 
protected:
    void go(Frame *frame);
}; // <pyapi>
 
class SwScaleFrameFilter : public FrameFilter { // <pyapi>
 
public:                                                                                                  // <pyapi>
    SwScaleFrameFilter(const char *name, int target_width, int target_height, FrameFilter *next = NULL); 
    ~SwScaleFrameFilter();                                                                               
 
protected:             // initialized at constructor
    int target_width;  
    int target_height; 
    int width;
    int height;
    AVRGBFrame outputframe;
    SwsContext *sws_ctx; 
 
protected:
    void go(Frame *frame);
 
public:
    void run(Frame *frame);
}; // <pyapi>
 
#endif