libgpac
Documentation of the core library of GPAC
Data Structures | Macros | Typedefs | Enumerations | Functions
filters.h File Reference

Filter management of GPAC. More...

#include <gpac/tools.h>
#include <gpac/list.h>
#include <gpac/events.h>
#include <gpac/user.h>
#include <gpac/constants.h>
#include <gpac/download.h>
#include <gpac/main.h>
#include <stddef.h>
+ Include dependency graph for filters.h:
+ This graph shows which files directly or indirectly include this file:

Data Structures

struct  GF_FilterStats
 
struct  GF_PropData
 
struct  GF_PropVec2i
 
struct  GF_PropVec2
 
struct  GF_PropVec3i
 
struct  GF_PropVec4i
 
struct  GF_PropStringList
 
struct  GF_PropUIntList
 
struct  GF_PropIntList
 
struct  GF_PropVec2iList
 
struct  GF_PropertyValue
 
struct  GF_BuiltInProperty
 
struct  GF_FEVT_Base
 
struct  GF_FEVT_Play
 
struct  GF_FEVT_SourceSeek
 
struct  GF_FEVT_SegmentSize
 
struct  GF_FEVT_FragmentSize
 
struct  GF_FEVT_AttachScene
 
struct  GF_FEVT_QualitySwitch
 
struct  GF_FEVT_Event
 
struct  GF_FEVT_FileDelete
 
struct  GF_FEVT_VisibilityHint
 
struct  GF_FEVT_BufferRequirement
 
struct  GF_FEVT_EncodeHints
 
struct  GF_FEVT_NTPRef
 
union  GF_FilterEvent
 
struct  GF_FilterArgs
 
struct  GF_FilterCapability
 
struct  GF_FilterSessionCaps
 
struct  GF_FilterRegister
 
struct  GF_FSEventListener
 
struct  GF_FilterPidStatistics
 
struct  _gf_filter_frame_interface
 
union  __gf_prop_val.value
 

Macros

#define GF_FILTER_NO_BO
 
#define GF_FILTER_NO_TS
 
#define GF_FS_FLAG_LOAD_META   1<<1
 
#define GF_FS_FLAG_NO_BLOCKING   1<<2
 
#define GF_FS_FLAG_NO_GRAPH_CACHE   1<<3
 
#define GF_FS_FLAG_NO_MAIN_THREAD   1<<4
 
#define GF_FS_FLAG_NO_REGULATION   1<<5
 
#define GF_FS_FLAG_NO_PROBE   (1<<6)
 
#define GF_FS_FLAG_NO_REASSIGN   (1<<7)
 
#define GF_FS_FLAG_PRINT_CONNECTIONS   (1<<8)
 
#define GF_FS_FLAG_NO_ARG_CHECK   (1<<9)
 
#define GF_FS_FLAG_NO_RESERVOIR   (1<<10)
 
#define GF_FS_FLAG_FULL_LINK   (1<<11)
 
#define GF_FS_DEFAULT_SEPS   ":=#,!@"
 
#define GF_GSF_VERSION   2
 
#define GF_PROP_DUMP_ARG_SIZE   100
 
#define GF_PROP_FLAG_PCK   1
 
#define GF_PROP_FLAG_GSF_REM   1<<1
 
#define PROP_SINT(_val)   (GF_PropertyValue){.type=GF_PROP_SINT, .value.sint = _val}
 
#define PROP_UINT(_val)   (GF_PropertyValue){.type=GF_PROP_UINT, .value.uint = _val}
 
#define PROP_ENUM(_val, _type)   (GF_PropertyValue){.type=_type, .value.uint = _val}
 
#define PROP_4CC(_val)   (GF_PropertyValue){.type=GF_PROP_4CC, .value.uint = _val}
 
#define PROP_LONGSINT(_val)   (GF_PropertyValue){.type=GF_PROP_LSINT, .value.longsint = _val}
 
#define PROP_LONGUINT(_val)   (GF_PropertyValue){.type=GF_PROP_LUINT, .value.longuint = _val}
 
#define PROP_BOOL(_val)   (GF_PropertyValue){.type=GF_PROP_BOOL, .value.boolean = _val}
 
#define PROP_FIXED(_val)   (GF_PropertyValue){.type=GF_PROP_FLOAT, .value.fnumber = _val}
 
#define PROP_FLOAT(_val)   (GF_PropertyValue){.type=GF_PROP_FLOAT, .value.fnumber = FLT2FIX(_val)}
 
#define PROP_FRAC_INT(_num, _den)   (GF_PropertyValue){.type=GF_PROP_FRACTION, .value.frac.num = _num, .value.frac.den = _den}
 
#define PROP_FRAC(_val)   (GF_PropertyValue){.type=GF_PROP_FRACTION, .value.frac = _val }
 
#define PROP_FRAC64(_val)   (GF_PropertyValue){.type=GF_PROP_FRACTION64, .value.lfrac = _val}
 
#define PROP_FRAC64_INT(_num, _den)   (GF_PropertyValue){.type=GF_PROP_FRACTION64, .value.lfrac.num = _num, .value.lfrac.den = _den}
 
#define PROP_DOUBLE(_val)   (GF_PropertyValue){.type=GF_PROP_DOUBLE, .value.number = _val}
 
#define PROP_STRING(_val)   (GF_PropertyValue){.type=GF_PROP_STRING, .value.string = (char *) _val}
 
#define PROP_STRING_NO_COPY(_val)   (GF_PropertyValue){.type=GF_PROP_STRING_NO_COPY, .value.string = _val}
 
#define PROP_NAME(_val)   (GF_PropertyValue){.type=GF_PROP_NAME, .value.string = _val}
 
#define PROP_DATA(_val, _len)   (GF_PropertyValue){.type=GF_PROP_DATA, .value.data.ptr = _val, .value.data.size=_len}
 
#define PROP_DATA_NO_COPY(_val, _len)   (GF_PropertyValue){.type=GF_PROP_DATA_NO_COPY, .value.data.ptr = _val, .value.data.size =_len}
 
#define PROP_CONST_DATA(_val, _len)   (GF_PropertyValue){.type=GF_PROP_CONST_DATA, .value.data.ptr = _val, .value.data.size = _len}
 
#define PROP_VEC2(_val)   (GF_PropertyValue){.type=GF_PROP_VEC2, .value.vec2 = _val}
 
#define PROP_VEC2I(_val)   (GF_PropertyValue){.type=GF_PROP_VEC2I, .value.vec2i = _val}
 
#define PROP_VEC2I_INT(_x, _y)   (GF_PropertyValue){.type=GF_PROP_VEC2I, .value.vec2i.x = _x, .value.vec2i.y = _y}
 
#define PROP_VEC3I(_val)   (GF_PropertyValue){.type=GF_PROP_VEC3I, .value.vec3i = _val}
 
#define PROP_VEC3I_INT(_x, _y, _z)   (GF_PropertyValue){.type=GF_PROP_VEC3I, .value.vec3i.x = _x, .value.vec3i.y = _y, .value.vec3i.z = _z}
 
#define PROP_VEC4I(_val)   (GF_PropertyValue){.type=GF_PROP_VEC4I, .value.vec4i = _val}
 
#define PROP_VEC4I_INT(_x, _y, _z, _w)   (GF_PropertyValue){.type=GF_PROP_VEC4I, .value.vec4i.x = _x, .value.vec4i.y = _y, .value.vec4i.z = _z, .value.vec4i.w = _w}
 
#define PROP_POINTER(_val)   (GF_PropertyValue){.type=GF_PROP_POINTER, .value.ptr = (void*)_val}
 
#define FILTER_EVENT_BASE
 
#define GF_FEVT_INIT(_a, _type, _on_pid)   { memset(&_a, 0, sizeof(GF_FilterEvent)); _a.base.type = _type; _a.base.on_pid = _on_pid; }
 
#define CAP_SINT(_f, _a, _b)   { .code=_a, .val={.type=GF_PROP_SINT, .value.sint = _b}, .flags=(_f) }
 
#define CAP_UINT(_f, _a, _b)   { .code=_a, .val={.type=GF_PROP_UINT, .value.uint = _b}, .flags=(_f) }
 
#define CAP_4CC(_f, _a, _b)   { .code=_a, .val={.type=GF_PROP_4CC, .value.uint = _b}, .flags=(_f) }
 
#define CAP_LSINT(_f, _a, _b)   { .code=_a, .val={.type=GF_PROP_LSINT, .value.longsint = _b}, .flags=(_f) }
 
#define CAP_LUINT(_f, _a, _b)   { .code=_a, .val={.type=GF_PROP_LUINT, .value.longuint = _b}, .flags=(_f) }
 
#define CAP_BOOL(_f, _a, _b)   { .code=_a, .val={.type=GF_PROP_BOOL, .value.boolean = _b}, .flags=(_f) }
 
#define CAP_FIXED(_f, _a, _b)   { .code=_a, .val={.type=GF_PROP_FLOAT, .value.fnumber = _b}, .flags=(_f) }
 
#define CAP_FLOAT(_f, _a, _b)   { .code=_a, .val={.type=GF_PROP_FLOAT, .value.fnumber = FLT2FIX(_b)}, .flags=(_f) }
 
#define CAP_FRAC_INT(_f, _a, _b, _c)   { .code=_a, .val={.type=GF_PROP_FRACTION, .value.frac.num = _b, .value.frac.den = _c}, .flags=(_f) }
 
#define CAP_FRAC(_f, _a, _b)   { .code=_a, .val={.type=GF_PROP_FRACTION, .value.frac = _b}, .flags=(_f) }
 
#define CAP_DOUBLE(_f, _a, _b)   { .code=_a, .val={.type=GF_PROP_DOUBLE, .value.number = _b}, .flags=(_f) }
 
#define CAP_NAME(_f, _a, _b)   { .code=_a, .val={.type=GF_PROP_NAME, .value.string = _b}, .flags=(_f) }
 
#define CAP_STRING(_f, _a, _b)   { .code=_a, .val={.type=GF_PROP_STRING, .value.string = _b}, .flags=(_f) }
 
#define CAP_UINT_PRIORITY(_f, _a, _b, _p)   { .code=_a, .val={.type=GF_PROP_UINT, .value.uint = _b}, .flags=(_f), .priority=_p}
 
#define GF_CAPS_INPUT   (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_INPUT)
 
#define GF_CAPS_INPUT_OPT   (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_INPUT|GF_CAPFLAG_OPTIONAL)
 
#define GF_CAPS_INPUT_STATIC   (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_INPUT|GF_CAPFLAG_STATIC)
 
#define GF_CAPS_INPUT_STATIC_OPT   (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_INPUT|GF_CAPFLAG_STATIC|GF_CAPFLAG_OPTIONAL)
 
#define GF_CAPS_INPUT_EXCLUDED   (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_INPUT|GF_CAPFLAG_EXCLUDED)
 
#define GF_CAPS_INPUT_LOADED_FILTER   (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_INPUT|GF_CAPFLAG_LOADED_FILTER)
 
#define GF_CAPS_OUTPUT   (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_OUTPUT)
 
#define GF_CAPS_OUTPUT_LOADED_FILTER   (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_OUTPUT|GF_CAPFLAG_LOADED_FILTER)
 
#define GF_CAPS_OUTPUT_EXCLUDED   (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_OUTPUT|GF_CAPFLAG_EXCLUDED)
 
#define GF_CAPS_OUTPUT_STATIC   (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_OUTPUT|GF_CAPFLAG_STATIC)
 
#define GF_CAPS_OUTPUT_STATIC_EXCLUDED   (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_OUTPUT|GF_CAPFLAG_EXCLUDED|GF_CAPFLAG_STATIC)
 
#define GF_CAPS_INPUT_OUTPUT   (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_INPUT|GF_CAPFLAG_OUTPUT)
 
#define GF_CAPS_INPUT_OUTPUT_OPT   (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_INPUT|GF_CAPFLAG_OUTPUT|GF_CAPFLAG_OPTIONAL)
 
#define GF_CAPS_IN_OUT_EXCLUDED   (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_INPUT|GF_CAPFLAG_OUTPUT|GF_CAPFLAG_EXCLUDED)
 
#define SETCAPS(__struct)   .caps = __struct, .nb_caps=sizeof(__struct)/sizeof(GF_FilterCapability)
 
#define GF_FS_SET_DESCRIPTION(_desc)   .description = _desc,
 
#define GF_FS_SET_AUTHOR(_author)   .author = _author,
 
#define GF_FS_SET_HELP(_help)   .help = _help,
 
#define GF_FS_DEF_ARG(_name, _offset, _desc, _type, _default, _enum, _flags)   { _name, _offset, _desc, _type, _default, _enum, _flags }
 
#define GF_FILTER_PCK_CRYPT   1
 

Typedefs

typedef struct __gf_filter_session GF_FilterSession
 
typedef struct __gf_filter GF_Filter
 
typedef struct __gf_filter_pid GF_FilterPid
 
typedef struct __gf_filter_pck GF_FilterPacket
 
typedef void(* gf_fsess_packet_destructor) (GF_Filter *filter, GF_FilterPid *PID, GF_FilterPacket *pck)
 
typedef struct __gf_fs_task GF_FSTask
 
typedef struct __gf_prop_entry GF_PropertyEntry
 
typedef void(* gf_fs_on_filter_creation) (void *udta, GF_Filter *filter, Bool is_destroy)
 
typedef Bool(* gf_filter_prop_filter) (void *cbk, u32 prop_4cc, const char *prop_name, const GF_PropertyValue *src_prop)
 

Enumerations

enum  GF_FilterSchedulerType {
  GF_FS_SCHEDULER_LOCK_FREE =0, GF_FS_SCHEDULER_LOCK, GF_FS_SCHEDULER_LOCK_FREE_X, GF_FS_SCHEDULER_LOCK_FORCE,
  GF_FS_SCHEDULER_DIRECT
}
 
enum  GF_FSFlushType { GF_FS_FLUSH_NONE =0, GF_FS_FLUSH_ALL, GF_FS_FLUSH_FAST }
 
enum  GF_FSFilterType {
  GF_FS_STATS_FILTER_UNKNOWN, GF_FS_STATS_FILTER_RAWIN, GF_FS_STATS_FILTER_DEMUX, GF_FS_STATS_FILTER_DECODE,
  GF_FS_STATS_FILTER_ENCODE, GF_FS_STATS_FILTER_MUX, GF_FS_STATS_FILTER_RAWOUT, GF_FS_STATS_FILTER_MEDIA_SINK,
  GF_FS_STATS_FILTER_MEDIA_SOURCE
}
 
enum  GF_EventPropagateType { GF_FILTER_UPDATE_DOWNSTREAM = 1<<1, GF_FILTER_UPDATE_UPSTREAM = 1<<2 }
 
enum  GF_PropType {
  GF_PROP_FORBIDEN = 0, GF_PROP_SINT = 1, GF_PROP_UINT = 2, GF_PROP_LSINT = 3,
  GF_PROP_LUINT = 4, GF_PROP_BOOL = 5, GF_PROP_FRACTION = 6, GF_PROP_FRACTION64 = 7,
  GF_PROP_FLOAT = 8, GF_PROP_DOUBLE = 9, GF_PROP_VEC2I = 10, GF_PROP_VEC2 = 11,
  GF_PROP_VEC3I = 12, GF_PROP_VEC4I = 13, GF_PROP_STRING = 14, GF_PROP_STRING_NO_COPY = 15,
  GF_PROP_DATA = 16, GF_PROP_NAME = 17, GF_PROP_DATA_NO_COPY = 18, GF_PROP_CONST_DATA = 19,
  GF_PROP_POINTER = 20, GF_PROP_STRING_LIST = 21, GF_PROP_UINT_LIST = 22, GF_PROP_SINT_LIST = 23,
  GF_PROP_VEC2I_LIST = 24, GF_PROP_4CC = 25, GF_PROP_4CC_LIST = 26, GF_PROP_LAST_NON_ENUM,
  GF_PROP_FIRST_ENUM = 40, GF_PROP_PIXFMT = GF_PROP_FIRST_ENUM, GF_PROP_PCMFMT = GF_PROP_FIRST_ENUM+1, GF_PROP_CICP_COL_PRIM = GF_PROP_FIRST_ENUM+2,
  GF_PROP_CICP_COL_TFC = GF_PROP_FIRST_ENUM+3, GF_PROP_CICP_COL_MX = GF_PROP_FIRST_ENUM+4, GF_PROP_LAST_DEFINED
}
 
enum  GF_FilterPidPlaybackMode { GF_PLAYBACK_MODE_NONE =0, GF_PLAYBACK_MODE_SEEK, GF_PLAYBACK_MODE_FASTFORWARD, GF_PLAYBACK_MODE_REWIND }
 
enum  {
  GF_PROP_PID_ID = GF_4CC('P','I','D','I'), GF_PROP_PID_ESID = GF_4CC('E','S','I','D'), GF_PROP_PID_ITEM_ID = GF_4CC('I','T','I','D'), GF_PROP_PID_ITEM_NUM = GF_4CC('I','T','I','X'),
  GF_PROP_PID_TRACK_NUM = GF_4CC('P','I','D','X'), GF_PROP_PID_SERVICE_ID = GF_4CC('P','S','I','D'), GF_PROP_PID_CLOCK_ID = GF_4CC('C','K','I','D'), GF_PROP_PID_DEPENDENCY_ID = GF_4CC('D','P','I','D'),
  GF_PROP_PID_SUBLAYER = GF_4CC('D','P','S','L'), GF_PROP_PID_PLAYBACK_MODE = GF_4CC('P','B','K','M'), GF_PROP_PID_SCALABLE = GF_4CC('S','C','A','L'), GF_PROP_PID_TILE_BASE = GF_4CC('S','A','B','T'),
  GF_PROP_PID_TILE_ID = GF_4CC('P','T','I','D'), GF_PROP_PID_LANGUAGE = GF_4CC('L','A','N','G'), GF_PROP_PID_SERVICE_NAME = GF_4CC('S','N','A','M'), GF_PROP_PID_SERVICE_PROVIDER = GF_4CC('S','P','R','O'),
  GF_PROP_PID_STREAM_TYPE = GF_4CC('P','M','S','T'), GF_PROP_PID_SUBTYPE = GF_4CC('P','S','S','T'), GF_PROP_PID_ISOM_SUBTYPE = GF_4CC('P','I','S','T'), GF_PROP_PID_ORIG_STREAM_TYPE = GF_4CC('P','O','S','T'),
  GF_PROP_PID_CODECID = GF_4CC('P','O','T','I'), GF_PROP_PID_IN_IOD = GF_4CC('P','I','O','D'), GF_PROP_PID_UNFRAMED = GF_4CC('P','F','R','M'), GF_PROP_PID_UNFRAMED_FULL_AU = GF_4CC('P','F','R','F'),
  GF_PROP_PID_DURATION = GF_4CC('P','D','U','R'), GF_PROP_PID_NB_FRAMES = GF_4CC('N','F','R','M'), GF_PROP_PID_FRAME_OFFSET = GF_4CC('F','R','M','O'), GF_PROP_PID_FRAME_SIZE = GF_4CC('C','F','R','S'),
  GF_PROP_PID_TIMESHIFT_DEPTH = GF_4CC('P','T','S','D'), GF_PROP_PID_TIMESHIFT_TIME = GF_4CC('P','T','S','T'), GF_PROP_PID_TIMESHIFT_STATE = GF_4CC('P','T','S','S'), GF_PROP_PID_TIMESCALE = GF_4CC('T','I','M','S'),
  GF_PROP_PID_PROFILE_LEVEL = GF_4CC('P','R','P','L'), GF_PROP_PID_DECODER_CONFIG = GF_4CC('D','C','F','G'), GF_PROP_PID_DECODER_CONFIG_ENHANCEMENT = GF_4CC('E','C','F','G'), GF_PROP_PID_CONFIG_IDX = GF_4CC('I','C','F','G'),
  GF_PROP_PID_SAMPLE_RATE = GF_4CC('A','U','S','R'), GF_PROP_PID_SAMPLES_PER_FRAME = GF_4CC('F','R','M','S'), GF_PROP_PID_NUM_CHANNELS = GF_4CC('C','H','N','B'), GF_PROP_PID_AUDIO_BPS = GF_4CC('A','B','P','S'),
  GF_PROP_PID_CHANNEL_LAYOUT = GF_4CC('C','H','L','O'), GF_PROP_PID_AUDIO_FORMAT = GF_4CC('A','F','M','T'), GF_PROP_PID_AUDIO_SPEED = GF_4CC('A','S','P','D'), GF_PROP_PID_UNFRAMED_LATM = GF_4CC('L','A','T','M'),
  GF_PROP_PID_DELAY = GF_4CC('M','D','L','Y'), GF_PROP_PID_CTS_SHIFT = GF_4CC('M','D','T','S'), GF_PROP_PID_NO_PRIMING = GF_4CC('A','S','K','P'), GF_PROP_PID_WIDTH = GF_4CC('W','I','D','T'),
  GF_PROP_PID_HEIGHT = GF_4CC('H','E','I','G'), GF_PROP_PID_PIXFMT = GF_4CC('P','F','M','T'), GF_PROP_PID_PIXFMT_WRAPPED = GF_4CC('P','F','M','W'), GF_PROP_PID_STRIDE = GF_4CC('V','S','T','Y'),
  GF_PROP_PID_STRIDE_UV = GF_4CC('V','S','T','C'), GF_PROP_PID_BIT_DEPTH_Y = GF_4CC('Y','B','P','S'), GF_PROP_PID_BIT_DEPTH_UV = GF_4CC('C','B','P','S'), GF_PROP_PID_FPS = GF_4CC('V','F','P','F'),
  GF_PROP_PID_INTERLACED = GF_4CC('V','I','L','C'), GF_PROP_PID_SAR = GF_4CC('P','S','A','R'), GF_PROP_PID_PAR = GF_4CC('V','P','A','R'), GF_PROP_PID_WIDTH_MAX = GF_4CC('M', 'W','I','D'),
  GF_PROP_PID_HEIGHT_MAX = GF_4CC('M', 'H','E','I'), GF_PROP_PID_ZORDER = GF_4CC('V', 'Z','I','X'), GF_PROP_PID_TRANS_X = GF_4CC('V','T','R','X'), GF_PROP_PID_TRANS_Y = GF_4CC('V','T','R','Y'),
  GF_PROP_PID_HIDDEN = GF_4CC('H','I','D','E'), GF_PROP_PID_CROP_POS = GF_4CC('V','C','X','Y'), GF_PROP_PID_ORIG_SIZE = GF_4CC('V','O','W','H'), GF_PROP_PID_SRD = GF_4CC('S','R','D',' '),
  GF_PROP_PID_SRD_REF = GF_4CC('S','R','D','R'), GF_PROP_PID_SRD_MAP = GF_4CC('S','R','D','M'), GF_PROP_PID_ALPHA = GF_4CC('V','A','L','P'), GF_PROP_PID_MIRROR = GF_4CC('V','M','I','R'),
  GF_PROP_PID_ROTATE = GF_4CC('V','R','O','T'), GF_PROP_PID_CLAP_W = GF_4CC('C','L','P','W'), GF_PROP_PID_CLAP_H = GF_4CC('C','L','P','H'), GF_PROP_PID_CLAP_X = GF_4CC('C','L','P','X'),
  GF_PROP_PID_CLAP_Y = GF_4CC('C','L','P','Y'), GF_PROP_PID_NUM_VIEWS = GF_4CC('P','N','B','V'), GF_PROP_PID_DOLBY_VISION = GF_4CC('D','O','V','I'), GF_PROP_PID_BITRATE = GF_4CC('R','A','T','E'),
  GF_PROP_PID_MAXRATE = GF_4CC('M','R','A','T'), GF_PROP_PID_TARGET_RATE = GF_4CC('T','B','R','T'), GF_PROP_PID_DBSIZE = GF_4CC('D','B','S','Z'), GF_PROP_PID_MEDIA_DATA_SIZE = GF_4CC('M','D','S','Z'),
  GF_PROP_PID_CAN_DATAREF = GF_4CC('D','R','E','F'), GF_PROP_PID_URL = GF_4CC('F','U','R','L'), GF_PROP_PID_REMOTE_URL = GF_4CC('R','U','R','L'), GF_PROP_PID_REDIRECT_URL = GF_4CC('R','E','L','O'),
  GF_PROP_PID_FILEPATH = GF_4CC('F','S','R','C'), GF_PROP_PID_MIME = GF_4CC('M','I','M','E'), GF_PROP_PID_FILE_EXT = GF_4CC('F','E','X','T'), GF_PROP_PID_OUTPATH = GF_4CC('F','D','S','T'),
  GF_PROP_PID_FILE_CACHED = GF_4CC('C','A','C','H'), GF_PROP_PID_DOWN_RATE = GF_4CC('D','L','B','W'), GF_PROP_PID_DOWN_SIZE = GF_4CC('D','L','S','Z'), GF_PROP_PID_DOWN_BYTES = GF_4CC('D','L','B','D'),
  GF_PROP_PID_FILE_RANGE = GF_4CC('F','B','R','A'), GF_PROP_PID_DISABLE_PROGRESSIVE = GF_4CC('N','P','R','G'), GF_PROP_PID_ISOM_BRANDS = GF_4CC('A','B','R','D'), GF_PROP_PID_ISOM_MBRAND = GF_4CC('M','B','R','D'),
  GF_PROP_PID_ISOM_MOVIE_TIME = GF_4CC('M','H','T','S'), GF_PROP_PID_HAS_SYNC = GF_4CC('P','S','Y','N'), GF_PROP_SERVICE_WIDTH = GF_4CC('D','W','D','T'), GF_PROP_SERVICE_HEIGHT = GF_4CC('D','H','G','T'),
  GF_PROP_PID_CAROUSEL_RATE = GF_4CC('C','A','R','A'), GF_PROP_PID_UTC_TIME = GF_4CC('U','T','C','D'), GF_PROP_PID_UTC_TIMESTAMP = GF_4CC('U','T','C','T'), GF_PROP_PID_AUDIO_VOLUME = GF_4CC('A','V','O','L'),
  GF_PROP_PID_AUDIO_PAN = GF_4CC('A','P','A','N'), GF_PROP_PID_AUDIO_PRIORITY = GF_4CC('A','P','R','I'), GF_PROP_PID_PROTECTION_SCHEME_TYPE = GF_4CC('S','C','H','T'), GF_PROP_PID_PROTECTION_SCHEME_VERSION = GF_4CC('S','C','H','V'),
  GF_PROP_PID_PROTECTION_SCHEME_URI = GF_4CC('S','C','H','U'), GF_PROP_PID_PROTECTION_KMS_URI = GF_4CC('K','M','S','U'), GF_PROP_PID_ISMA_SELECTIVE_ENC = GF_4CC('I','S','S','E'), GF_PROP_PID_ISMA_IV_LENGTH = GF_4CC('I','S','I','V'),
  GF_PROP_PID_ISMA_KI_LENGTH = GF_4CC('I','S','K','I'), GF_PROP_PID_ISMA_KI = GF_4CC('I','K','E','Y'), GF_PROP_PID_OMA_CRYPT_TYPE = GF_4CC('O','M','C','T'), GF_PROP_PID_OMA_CID = GF_4CC('O','M','I','D'),
  GF_PROP_PID_OMA_TXT_HDR = GF_4CC('O','M','T','H'), GF_PROP_PID_OMA_CLEAR_LEN = GF_4CC('O','M','P','T'), GF_PROP_PID_CRYPT_INFO = GF_4CC('E','C','R','I'), GF_PROP_PID_DECRYPT_INFO = GF_4CC('E','D','R','I'),
  GF_PROP_PCK_SENDER_NTP = GF_4CC('N','T','P','S'), GF_PROP_PCK_RECEIVER_NTP = GF_4CC('N','T','P','R'), GF_PROP_PID_ADOBE_CRYPT_META = GF_4CC('A','M','E','T'), GF_PROP_PID_ENCRYPTED = GF_4CC('E','P','C','K'),
  GF_PROP_PID_OMA_PREVIEW_RANGE = GF_4CC('O','D','P','R'), GF_PROP_PID_CENC_PSSH = GF_4CC('P','S','S','H'), GF_PROP_PCK_CENC_SAI = GF_4CC('S','A','I','S'), GF_PROP_PID_CENC_KEY_INFO = GF_4CC('C','B','I','V'),
  GF_PROP_PID_CENC_PATTERN = GF_4CC('C','P','T','R'), GF_PROP_PID_CENC_STORE = GF_4CC('C','S','T','R'), GF_PROP_PID_CENC_STSD_MODE = GF_4CC('C','S','T','M'), GF_PROP_PID_AMR_MODE_SET = GF_4CC('A','M','S','T'),
  GF_PROP_PCK_SUBS = GF_4CC('S','U','B','S'), GF_PROP_PID_MAX_NALU_SIZE = GF_4CC('N','A','L','S'), GF_PROP_PCK_FILENUM = GF_4CC('F','N','U','M'), GF_PROP_PCK_FILENAME = GF_4CC('F','N','A','M'),
  GF_PROP_PCK_IDXFILENAME = GF_4CC('I','N','A','M'), GF_PROP_PCK_FILESUF = GF_4CC('F','S','U','F'), GF_PROP_PCK_EODS = GF_4CC('E','O','D','S'), GF_PROP_PCK_CUE_START = GF_4CC('P','C','U','S'),
  GF_PROP_PID_MAX_FRAME_SIZE = GF_4CC('M','F','R','S'), GF_PROP_PID_AVG_FRAME_SIZE = GF_4CC('A','F','R','S'), GF_PROP_PID_MAX_TS_DELTA = GF_4CC('M','T','S','D'), GF_PROP_PID_MAX_CTS_OFFSET = GF_4CC('M','C','T','O'),
  GF_PROP_PID_CONSTANT_DURATION = GF_4CC('S','C','T','D'), GF_PROP_PID_ISOM_TRACK_TEMPLATE = GF_4CC('I','T','K','T'), GF_PROP_PID_ISOM_TREX_TEMPLATE = GF_4CC('I','T','X','T'), GF_PROP_PID_ISOM_STSD_TEMPLATE = GF_4CC('I','S','T','D'),
  GF_PROP_PID_ISOM_UDTA = GF_4CC('I','M','U','D'), GF_PROP_PID_ISOM_HANDLER = GF_4CC('I','H','D','L'), GF_PROP_PID_ISOM_TRACK_FLAGS = GF_4CC('I','T','K','F'), GF_PROP_PID_ISOM_TRACK_MATRIX = GF_4CC('I','T','K','M'),
  GF_PROP_PID_ISOM_ALT_GROUP = GF_4CC('I','A','L','G'), GF_PROP_PID_DISABLED = GF_4CC('I','T','K','D'), GF_PROP_PID_PERIOD_ID = GF_4CC('P','E','I','D'), GF_PROP_PID_PERIOD_START = GF_4CC('P','E','S','T'),
  GF_PROP_PID_PERIOD_DUR = GF_4CC('P','E','D','U'), GF_PROP_PID_REP_ID = GF_4CC('D','R','I','D'), GF_PROP_PID_AS_ID = GF_4CC('D','A','I','D'), GF_PROP_PID_MUX_SRC = GF_4CC('M','S','R','C'),
  GF_PROP_PID_DASH_MODE = GF_4CC('D','M','O','D'), GF_PROP_PID_DASH_DUR = GF_4CC('D','D','U','R'), GF_PROP_PID_DASH_MULTI_PID = GF_4CC('D','M','S','D'), GF_PROP_PID_DASH_MULTI_PID_IDX = GF_4CC('D','M','S','I'),
  GF_PROP_PID_DASH_MULTI_TRACK = GF_4CC('D','M','T','K'), GF_PROP_PID_ROLE = GF_4CC('R','O','L','E'), GF_PROP_PID_PERIOD_DESC = GF_4CC('P','D','E','S'), GF_PROP_PID_AS_COND_DESC = GF_4CC('A','C','D','S'),
  GF_PROP_PID_AS_ANY_DESC = GF_4CC('A','A','D','S'), GF_PROP_PID_REP_DESC = GF_4CC('R','D','E','S'), GF_PROP_PID_BASE_URL = GF_4CC('B','U','R','L'), GF_PROP_PID_TEMPLATE = GF_4CC('D','T','P','L'),
  GF_PROP_PID_START_NUMBER = GF_4CC('D','R','S','N'), GF_PROP_PID_XLINK = GF_4CC('X','L','N','K'), GF_PROP_PID_CLAMP_DUR = GF_4CC('D','C','M','D'), GF_PROP_PID_HLS_PLAYLIST = GF_4CC('H','L','V','P'),
  GF_PROP_PID_HLS_GROUPID = GF_4CC('H','L','G','I'), GF_PROP_PID_DASH_CUE = GF_4CC('D','C','U','E'), GF_PROP_PID_DASH_SEGMENTS = GF_4CC('D','C','N','S'), GF_PROP_PID_CODEC = GF_4CC('C','O','D','S'),
  GF_PROP_PID_SINGLE_SCALE = GF_4CC('D','S','T','S'), GF_PROP_PID_UDP = GF_4CC('P','U','D','P'), GF_PROP_PID_PRIMARY_ITEM = GF_4CC('P','I','T','M'), GF_PROP_PID_PLAY_BUFFER = GF_4CC('P','B','P','L'),
  GF_PROP_PID_MAX_BUFFER = GF_4CC('P','B','M','X'), GF_PROP_PID_RE_BUFFER = GF_4CC('P','B','R','E'), GF_PROP_PID_VIEW_IDX = GF_4CC('V','I','D','X'), GF_PROP_PID_COLR_PRIMARIES = GF_4CC('C','P','R','M'),
  GF_PROP_PID_COLR_TRANSFER = GF_4CC('C','T','R','C'), GF_PROP_PID_COLR_MX = GF_4CC('C','M','X','C'), GF_PROP_PID_COLR_RANGE = GF_4CC('C','F','R','A'), GF_PROP_PID_COLR_CHROMALOC = GF_4CC('C','L','O','C'),
  GF_PROP_PID_COLR_SPACE = GF_4CC('C','S','P','C'), GF_PROP_PID_SRC_MAGIC = GF_4CC('P','S','M','G'), GF_PROP_PID_MUX_INDEX = GF_4CC('T','I','D','X'), GF_PROP_NO_TS_LOOP = GF_4CC('N','T','S','L'),
  GF_PROP_PID_MHA_COMPATIBLE_PROFILES = GF_4CC('M','H','C','P'), GF_PROP_PCK_FRAG_START = GF_4CC('P','F','R','B'), GF_PROP_PCK_FRAG_RANGE = GF_4CC('P','F','R','R'), GF_PROP_PCK_SIDX_RANGE = GF_4CC('P','F','S','R'),
  GF_PROP_PCK_MOOF_TEMPLATE = GF_4CC('M','F','T','P'), GF_PROP_PCK_INIT = GF_4CC('P','C','K','I'), GF_PROP_PID_RAWGRAB = GF_4CC('P','G','R','B'), GF_PROP_PID_KEEP_AFTER_EOS = GF_4CC('P','K','A','E'),
  GF_PROP_PID_COVER_ART = GF_4CC('P','C','O','V'), GF_PROP_PID_ORIG_FRAG_URL = GF_4CC('O','F','R','A'), GF_PROP_PID_ROUTE_IP = GF_4CC('R','S','I','P'), GF_PROP_PID_ROUTE_PORT = GF_4CC('R','S','P','N'),
  GF_PROP_PID_ROUTE_NAME = GF_4CC('R','S','F','N'), GF_PROP_PID_ROUTE_CAROUSEL = GF_4CC('R','S','C','R'), GF_PROP_PID_ROUTE_SENDTIME = GF_4CC('R','S','S','T'), GF_PROP_PID_STEREO_TYPE = GF_4CC('P','S','T','T'),
  GF_PROP_PID_PROJECTION_TYPE = GF_4CC('P','P','J','T'), GF_PROP_PID_VR_POSE = GF_4CC('P','P','O','S'), GF_PROP_PID_CUBE_MAP_PAD = GF_4CC('P','C','M','P'), GF_PROP_PID_EQR_CLAMP = GF_4CC('P','E','Q','C'),
  GF_PROP_PID_SCENE_NODE = GF_4CC('P','S','N','D'), GF_PROP_PID_ORIG_CRYPT_SCHEME = GF_4CC('P','O','C','S'), GF_PROP_PCK_HLS_REF = GF_4CC('H','P','L','R'), GF_PROP_PID_LLHLS = GF_4CC('H','L','S','L'),
  GF_PROP_PCK_HLS_FRAG_NUM = GF_4CC('H','L','S','N'), GF_PROP_PCK_SKIP_BEGIN = GF_4CC('P','C','K','S'), GF_PROP_PCK_SKIP_PRES = GF_4CC('P','C','K','D'), GF_PROP_PID_DASH_FWD = GF_4CC('D','F','W','D'),
  GF_PROP_PCK_DASH_MANIFEST = GF_4CC('D','M','P','D'), GF_PROP_PCK_HLS_VARIANT = GF_4CC('D','H','L','V'), GF_PROP_PID_DASH_PERIOD_START = GF_4CC('D','P','S','T'), GF_PROP_PCK_HLS_VARIANT_NAME = GF_4CC('D','H','L','N'),
  GF_PROP_PID_HLS_KMS = GF_4CC('H','L','S','K'), GF_PROP_PID_HLS_IV = GF_4CC('H','L','S','I'), GF_PROP_PID_DOWNLOAD_SESSION = GF_4CC('G','H','T','T'), GF_PROP_PID_HAS_TEMI = GF_4CC('P','T','E','M'),
  GF_PROP_PCK_XPS_MASK = GF_4CC('P','X','P','M'), GF_PROP_PCK_END_RANGE = GF_4CC('P','C','E','R')
}
 
enum  { GF_PID_FILE_PATCH_NONE = 0, GF_PID_FILE_PATCH_REPLACE = 1, GF_PID_FILE_PATCH_INSERT = 2 }
 
enum  GF_PropDumDataMode { GF_PROP_DUMP_DATA_NONE =0, GF_PROP_DUMP_DATA_INFO, GF_PROP_DUMP_DATA_PTR }
 
enum  GF_FEventType {
  GF_FEVT_PLAY = 1, GF_FEVT_SET_SPEED, GF_FEVT_STOP, GF_FEVT_PAUSE,
  GF_FEVT_RESUME, GF_FEVT_SOURCE_SEEK, GF_FEVT_SOURCE_SWITCH, GF_FEVT_SEGMENT_SIZE,
  GF_FEVT_ATTACH_SCENE, GF_FEVT_RESET_SCENE, GF_FEVT_QUALITY_SWITCH, GF_FEVT_VISIBILITY_HINT,
  GF_FEVT_INFO_UPDATE, GF_FEVT_BUFFER_REQ, GF_FEVT_CAPS_CHANGE, GF_FEVT_CONNECT_FAIL,
  GF_FEVT_USER, GF_FEVT_PLAY_HINT, GF_FEVT_FILE_DELETE, GF_FEVT_FRAGMENT_SIZE,
  GF_FEVT_ENCODE_HINTS, GF_FEVT_NTP_REF
}
 
enum  GF_FSArgumentFlags {
  GF_FS_ARG_HINT_NORMAL = 0, GF_FS_ARG_HINT_ADVANCED = 1<<1, GF_FS_ARG_HINT_EXPERT = 1<<2, GF_FS_ARG_HINT_HIDE = 1<<3,
  GF_FS_ARG_UPDATE = 1<<4, GF_FS_ARG_META = 1<<5, GF_FS_ARG_META_ALLOC = 1<<6, GF_FS_ARG_SINK_ALIAS = 1<<7,
  GF_FS_ARG_UPDATE_SYNC = 1<<8
}
 
enum  {
  GF_CAPFLAG_IN_BUNDLE = 1, GF_CAPFLAG_INPUT = 1<<1, GF_CAPFLAG_OUTPUT = 1<<2, GF_CAPFLAG_EXCLUDED = 1<<3,
  GF_CAPFLAG_LOADED_FILTER = 1<<4, GF_CAPFLAG_STATIC = 1<<5, GF_CAPFLAG_OPTIONAL = 1<<6
}
 
enum  GF_FilterProbeScore {
  GF_FPROBE_NOT_SUPPORTED = 0, GF_FPROBE_MAYBE_NOT_SUPPORTED, GF_FPROBE_MAYBE_SUPPORTED, GF_FPROBE_SUPPORTED,
  GF_FPROBE_FORCE, GF_FPROBE_EXT_MATCH
}
 
enum  GF_FSRegisterFlags {
  GF_FS_REG_MAIN_THREAD = 1<<1, GF_FS_REG_CONFIGURE_MAIN_THREAD = 1<<2, GF_FS_REG_EXPLICIT_ONLY = 1<<3, GF_FS_REG_HIDE_WEIGHT = 1<<4,
  GF_FS_REG_ACT_AS_SOURCE = 1<<5, GF_FS_REG_ALLOW_CYCLIC = 1<<6, GF_FS_REG_DYNAMIC_PIDS = 1<<7, GF_FS_REG_SCRIPT = 1<<8,
  GF_FS_REG_META = 1<<9, GF_FS_REG_DYNAMIC_REDIRECT = 1<<10, GF_FS_REG_REQUIRES_RESOLVER = 1<<11, GF_FS_REG_CUSTOM = 0x40000000
}
 
enum  GF_FilterSessionSepType {
  GF_FS_SEP_ARGS =0, GF_FS_SEP_NAME, GF_FS_SEP_FRAG, GF_FS_SEP_LIST,
  GF_FS_SEP_NEG
}
 
enum  GF_FilterPidStatsLocation {
  GF_STATS_LOCAL = 0, GF_STATS_LOCAL_INPUTS, GF_STATS_DECODER_SINK, GF_STATS_DECODER_SOURCE,
  GF_STATS_ENCODER_SINK, GF_STATS_ENCODER_SOURCE
}
 
enum  GF_FilterSAPType {
  GF_FILTER_SAP_NONE = 0, GF_FILTER_SAP_1, GF_FILTER_SAP_2, GF_FILTER_SAP_3,
  GF_FILTER_SAP_4, GF_FILTER_SAP_4_PROL
}
 
enum  GF_FilterClockType { GF_FILTER_CLOCK_NONE =0, GF_FILTER_CLOCK_PCR, GF_FILTER_CLOCK_PCR_DISC }
 
enum  { GF_FRAME_IFCE_BLOCKING = 1, GF_FRAME_IFCE_MAIN_GLFB = 1<<1 }
 

Functions

GF_FilterSession * gf_fs_new (s32 nb_threads, GF_FilterSchedulerType type, u32 flags, const char *blacklist)
 
GF_FilterSession * gf_fs_new_defaults (u32 flags)
 
void gf_fs_del (GF_FilterSession *session)
 
GF_Filter * gf_fs_load_filter (GF_FilterSession *session, const char *name, GF_Err *err_code)
 
Bool gf_fs_filter_exists (GF_FilterSession *session, const char *name)
 
GF_Err gf_fs_run (GF_FilterSession *session)
 
GF_Err gf_fs_set_separators (GF_FilterSession *session, const char *separator_set)
 
GF_Err gf_fs_set_max_resolution_chain_length (GF_FilterSession *session, u32 max_chain_length)
 
GF_Err gf_fs_set_max_sleep_time (GF_FilterSession *session, u32 max_sleep)
 
u32 gf_fs_get_max_resolution_chain_length (GF_FilterSession *session)
 
void gf_fs_run_step (GF_FilterSession *session)
 
GF_Err gf_fs_stop (GF_FilterSession *session)
 
u32 gf_fs_filters_registers_count (GF_FilterSession *session)
 
const GF_FilterRegister * gf_fs_get_filter_register (GF_FilterSession *session, u32 idx)
 
void gf_fs_register_test_filters (GF_FilterSession *session)
 
GF_Filter * gf_fs_load_source (GF_FilterSession *session, const char *url, const char *args, const char *parent_url, GF_Err *err)
 
GF_Filter * gf_fs_load_destination (GF_FilterSession *session, const char *url, const char *args, const char *parent_url, GF_Err *err)
 
GF_Err gf_fs_get_last_connect_error (GF_FilterSession *session)
 
GF_Err gf_fs_get_last_process_error (GF_FilterSession *session)
 
void gf_fs_add_filter_register (GF_FilterSession *session, const GF_FilterRegister *freg)
 
void gf_fs_remove_filter_register (GF_FilterSession *session, GF_FilterRegister *freg)
 
GF_Err gf_fs_post_user_task (GF_FilterSession *session, Bool(*task_execute)(GF_FilterSession *fsess, void *callback, u32 *reschedule_ms), void *udta_callback, const char *log_name)
 
GF_Err gf_fs_abort (GF_FilterSession *session, GF_FSFlushType flush_type)
 
Bool gf_fs_is_last_task (GF_FilterSession *session)
 
Bool gf_fs_is_supported_mime (GF_FilterSession *session, const char *mime)
 
void gf_fs_set_ui_callback (GF_FilterSession *session, Bool(*ui_event_proc)(void *opaque, GF_Event *event), void *cbk_udta)
 
void gf_fs_print_stats (GF_FilterSession *session)
 
void gf_fs_print_connections (GF_FilterSession *session)
 
void gf_fs_print_non_connected (GF_FilterSession *session)
 
void gf_fs_print_non_connected_ex (GF_FilterSession *session, Bool ignore_sinks)
 
void gf_fs_print_unused_args (GF_FilterSession *session, const char *ignore_args)
 
void gf_fs_print_all_connections (GF_FilterSession *session, char *filter_name, void(*print_fn)(FILE *output, GF_SysPrintArgFlags flags, const char *fmt,...))
 
Bool gf_fs_check_filter_register_cap (const GF_FilterRegister *filter_reg, u32 in_cap_code, GF_PropertyValue *in_cap, u32 out_cap_code, GF_PropertyValue *out_cap, Bool exact_match_only)
 
void gf_fs_enable_reporting (GF_FilterSession *session, Bool reporting_on)
 
void gf_fs_lock_filters (GF_FilterSession *session, Bool do_lock)
 
u32 gf_fs_get_filters_count (GF_FilterSession *session)
 
GF_Filter * gf_fs_get_filter (GF_FilterSession *session, u32 idx)
 
GF_Err gf_fs_get_filter_stats (GF_FilterSession *session, u32 idx, GF_FilterStats *stats)
 
Bool gf_fs_enum_unmapped_options (GF_FilterSession *session, u32 *idx, char **argname, u32 *argtype)
 
void gf_fs_send_update (GF_FilterSession *session, const char *fid, GF_Filter *filter, const char *name, const char *val, GF_EventPropagateType propagate_mask)
 
GF_Err gf_fs_load_script (GF_FilterSession *session, const char *jsfile)
 
u32 gf_fs_get_http_max_rate (GF_FilterSession *session)
 
GF_Err gf_fs_set_http_max_rate (GF_FilterSession *session, u32 rate)
 
u32 gf_fs_get_http_rate (GF_FilterSession *session)
 
Bool gf_fs_is_supported_source (GF_FilterSession *session, const char *url, const char *parent_url)
 
GF_Err gf_fs_set_filter_creation_callback (GF_FilterSession *session, gf_fs_on_filter_creation on_create_destroy, void *udta)
 
const char * gf_props_4cc_get_name (u32 prop_4cc)
 
u32 gf_props_4cc_get_type (u32 prop_4cc)
 
Bool gf_props_equal (const GF_PropertyValue *p1, const GF_PropertyValue *p2)
 
Bool gf_props_equal_strict (const GF_PropertyValue *p1, const GF_PropertyValue *p2)
 
const char * gf_props_get_type_name (GF_PropType type)
 
const char * gf_props_get_type_desc (GF_PropType type)
 
GF_PropType gf_props_parse_type (const char *name)
 
Bool gf_props_type_is_enum (GF_PropType type)
 
u32 gf_props_parse_enum (u32 type, const char *value)
 
const char * gf_props_enum_name (u32 type, u32 value)
 
const char * gf_props_enum_all_names (u32 type)
 
GF_PropertyValue gf_props_parse_value (u32 type, const char *name, const char *value, const char *enum_values, char list_sep_char)
 
const char * gf_props_dump_val (const GF_PropertyValue *att, char dump[GF_PROP_DUMP_ARG_SIZE], GF_PropDumDataMode dump_data_mode, const char *min_max_enum)
 
const char * gf_props_dump (u32 p4cc, const GF_PropertyValue *att, char dump[GF_PROP_DUMP_ARG_SIZE], GF_PropDumDataMode dump_data_mode)
 
void gf_props_reset_single (GF_PropertyValue *prop)
 
const GF_BuiltInProperty * gf_props_get_description (u32 prop_idx)
 
u32 gf_props_get_id (const char *name)
 
u8 gf_props_4cc_get_flags (u32 prop_4cc)
 
const char * gf_filter_event_name (GF_FEventType type)
 
void gf_filter_get_session_caps (GF_Filter *filter, GF_FilterSessionCaps *caps)
 
void gf_filter_set_session_caps (GF_Filter *filter, GF_FilterSessionCaps *caps)
 
Bool gf_filter_is_instance_of (GF_Filter *filter, const GF_FilterRegister *freg)
 
void gf_filter_abort (GF_Filter *filter)
 
void gf_filter_lock (GF_Filter *filter, Bool do_lock)
 
void gf_filter_lock_all (GF_Filter *filter, Bool do_lock)
 
void gf_filter_require_source_id (GF_Filter *filter)
 
void * gf_filter_get_udta (GF_Filter *filter)
 
void gf_filter_set_name (GF_Filter *filter, const char *name)
 
const char * gf_filter_get_name (GF_Filter *filter)
 
void gf_filter_make_sticky (GF_Filter *filter)
 
u32 gf_filter_get_num_events_queued (GF_Filter *filter)
 
GF_DownloadManager * gf_filter_get_download_manager (GF_Filter *filter)
 
struct _gf_ft_mgr * gf_filter_get_font_manager (GF_Filter *filter)
 
void gf_filter_ask_rt_reschedule (GF_Filter *filter, u32 us_until_next)
 
void gf_filter_post_process_task (GF_Filter *filter)
 
GF_Err gf_filter_post_task (GF_Filter *filter, Bool(*task_execute)(GF_Filter *filter, void *callback, u32 *reschedule_ms), void *udta, const char *task_name)
 
void gf_filter_set_setup_failure_callback (GF_Filter *filter, GF_Filter *source_filter, void(*on_setup_error)(GF_Filter *f, void *on_setup_error_udta, GF_Err e), void *udta)
 
void gf_filter_setup_failure (GF_Filter *filter, GF_Err reason)
 
void gf_filter_notification_failure (GF_Filter *filter, GF_Err reason, Bool force_disconnect)
 
void gf_filter_remove_src (GF_Filter *filter, GF_Filter *src_filter)
 
void gf_filter_remove (GF_Filter *filter)
 
void gf_filter_set_max_extra_input_pids (GF_Filter *filter, u32 max_extra_pids)
 
u32 gf_filter_get_max_extra_input_pids (GF_Filter *filter)
 
Bool gf_filter_block_enabled (GF_Filter *filter)
 
void gf_filter_block_eos (GF_Filter *filter, Bool do_block)
 
GF_Filter * gf_filter_connect_source (GF_Filter *filter, const char *url, const char *parent_url, Bool inherit_args, GF_Err *err)
 
GF_Filter * gf_filter_connect_destination (GF_Filter *filter, const char *url, GF_Err *err)
 
GF_Filter * gf_filter_load_filter (GF_Filter *filter, const char *name, GF_Err *err_code)
 
Bool gf_filter_is_supported_source (GF_Filter *filter, const char *url, const char *parent_url)
 
u32 gf_filter_get_ipid_count (GF_Filter *filter)
 
GF_FilterPid * gf_filter_get_ipid (GF_Filter *filter, u32 idx)
 
u32 gf_filter_get_opid_count (GF_Filter *filter)
 
GF_FilterPid * gf_filter_get_opid (GF_Filter *filter, u32 idx)
 
void gf_filter_get_output_buffer_max (GF_Filter *filter, u32 *max_buf, u32 *max_playout_buf)
 
void gf_filter_hint_single_clock (GF_Filter *filter, u64 time_in_us, GF_Fraction64 media_timestamp)
 
void gf_filter_get_clock_hint (GF_Filter *filter, u64 *time_in_us, GF_Fraction64 *media_timestamp)
 
GF_Err gf_filter_set_source (GF_Filter *filter, GF_Filter *link_from, const char *link_ext)
 
GF_Err gf_filter_set_source_restricted (GF_Filter *filter, GF_Filter *link_from, const char *link_ext)
 
void gf_filter_reset_source (GF_Filter *filter)
 
GF_Err gf_filter_assign_id (GF_Filter *filter, const char *filter_id)
 
const char * gf_filter_get_id (GF_Filter *filter)
 
void gf_filter_set_blocking (GF_Filter *filter, Bool is_blocking)
 
GF_Err gf_filter_override_caps (GF_Filter *filter, const GF_FilterCapability *caps, u32 nb_caps)
 
GF_Err gf_filter_act_as_sink (GF_Filter *filter)
 
u8 gf_filter_get_sep (GF_Filter *filter, GF_FilterSessionSepType sep_type)
 
const char * gf_filter_get_dst_args (GF_Filter *filter)
 
char * gf_filter_get_dst_name (GF_Filter *filter)
 
const char * gf_filter_get_src_args (GF_Filter *filter)
 
void gf_filter_send_event (GF_Filter *filter, GF_FilterEvent *evt, Bool upstream)
 
GF_Err gf_filter_reconnect_output (GF_Filter *filter)
 
GF_Err gf_filter_set_event_target (GF_Filter *filter, Bool enable_events)
 
const GF_PropertyValue * gf_filter_get_info (GF_Filter *filter, u32 prop_4cc, GF_PropertyEntry **propentry)
 
const GF_PropertyValue * gf_filter_get_info_str (GF_Filter *filter, const char *prop_name, GF_PropertyEntry **propentry)
 
void gf_filter_release_property (GF_PropertyEntry *propentry)
 
void gf_filter_send_update (GF_Filter *filter, const char *target_filter_id, const char *arg_name, const char *arg_val, GF_EventPropagateType propagate_mask)
 
GF_Err gf_filter_add_event_listener (GF_Filter *filter, GF_FSEventListener *el)
 
GF_Err gf_filter_remove_event_listener (GF_Filter *filter, GF_FSEventListener *el)
 
Bool gf_filter_forward_gf_event (GF_Filter *filter, GF_Event *evt, Bool consumed, Bool skip_user)
 
Bool gf_filter_send_gf_event (GF_Filter *filter, GF_Event *evt)
 
Bool gf_filter_all_sinks_done (GF_Filter *filter)
 
const char * gf_filter_get_arg_str (GF_Filter *filter, const char *arg_name, char dump[GF_PROP_DUMP_ARG_SIZE])
 
Bool gf_filter_get_arg (GF_Filter *filter, const char *arg_name, GF_PropertyValue *prop)
 
Bool gf_filter_is_supported_mime (GF_Filter *filter, const char *mime)
 
Bool gf_filter_ui_event (GF_Filter *filter, GF_Event *uievt)
 
void gf_filter_register_opengl_provider (GF_Filter *filter, Bool do_register)
 
GF_Err gf_filter_request_opengl (GF_Filter *filter)
 
GF_Err gf_filter_set_active_opengl_context (GF_Filter *filter)
 
u32 gf_filter_count_source_by_protocol (GF_Filter *filter, const char *protocol_scheme, Bool expand_proto, GF_FilterPid *(*enum_pids)(void *udta, u32 *idx), void *udta)
 
void gf_filter_disable_probe (GF_Filter *filter)
 
void gf_filter_disable_inputs (GF_Filter *filter)
 
Bool gf_filter_has_pid_connection_pending (GF_Filter *filter, GF_Filter *stop_at_filter)
 
Bool gf_filter_connections_pending (GF_Filter *filter)
 
GF_Err gf_filter_prevent_blocking (GF_Filter *filter, Bool prevent_blocking_enabled)
 
Bool gf_filter_is_dynamic (GF_Filter *filter)
 
Bool gf_filter_reporting_enabled (GF_Filter *filter)
 
GF_Err gf_filter_update_status (GF_Filter *filter, u32 percent, char *szStatus)
 
Bool gf_filter_end_of_session (GF_Filter *filter)
 
void gf_filter_report_meta_option (GF_Filter *filter, const char *arg, Bool was_found)
 
GF_Err gf_filter_set_description (GF_Filter *filter, const char *new_desc)
 
const char * gf_filter_get_description (GF_Filter *filter)
 
GF_Err gf_filter_set_version (GF_Filter *filter, const char *new_version)
 
const char * gf_filter_get_version (GF_Filter *filter)
 
GF_Err gf_filter_set_author (GF_Filter *filter, const char *new_author)
 
const char * gf_filter_get_author (GF_Filter *filter)
 
GF_Err gf_filter_set_help (GF_Filter *filter, const char *new_help)
 
const char * gf_filter_get_help (GF_Filter *filter)
 
GF_Err gf_filter_define_args (GF_Filter *filter, GF_FilterArgs *new_args)
 
GF_FilterArgs * gf_filter_get_args (GF_Filter *filter)
 
const GF_FilterCapability * gf_filter_get_caps (GF_Filter *filter, u32 *nb_caps)
 
const char * gf_filter_probe_data (GF_Filter *filter, u8 *data, u32 size)
 
Bool gf_filter_is_alias (GF_Filter *filter)
 
Bool gf_filter_in_parent_chain (GF_Filter *parent, GF_Filter *filter)
 
GF_Err gf_filter_get_stats (GF_Filter *filter, GF_FilterStats *stats)
 
const GF_FilterArgs * gf_filter_enumerate_args (GF_Filter *filter, u32 idx)
 
Bool gf_filter_relocate_url (GF_Filter *filter, const char *service_url, const char *parent_url, char *out_relocated_url, char *out_localized_url)
 
GF_FilterPid * gf_filter_pid_new (GF_Filter *filter)
 
void gf_filter_pid_remove (GF_FilterPid *PID)
 
GF_Err gf_filter_pid_raw_new (GF_Filter *filter, const char *url, const char *local_file, const char *mime_type, const char *fext, u8 *probe_data, u32 probe_size, Bool trust_mime, GF_FilterPid **out_pid)
 
GF_Err gf_filter_pid_set_property (GF_FilterPid *PID, u32 prop_4cc, const GF_PropertyValue *value)
 
GF_Err gf_filter_pid_set_property_str (GF_FilterPid *PID, const char *name, const GF_PropertyValue *value)
 
GF_Err gf_filter_pid_set_property_dyn (GF_FilterPid *PID, char *name, const GF_PropertyValue *value)
 
GF_Err gf_filter_pid_set_info (GF_FilterPid *PID, u32 prop_4cc, const GF_PropertyValue *value)
 
GF_Err gf_filter_pid_set_info_str (GF_FilterPid *PID, const char *name, const GF_PropertyValue *value)
 
GF_Err gf_filter_pid_set_info_dyn (GF_FilterPid *PID, char *name, const GF_PropertyValue *value)
 
void gf_filter_pid_set_udta (GF_FilterPid *PID, void *udta)
 
void * gf_filter_pid_get_udta (GF_FilterPid *PID)
 
u32 gf_filter_pid_get_udta_flags (GF_FilterPid *PID)
 
GF_Err gf_filter_pid_set_udta_flags (GF_FilterPid *PID, u32 flags)
 
void gf_filter_pid_set_name (GF_FilterPid *PID, const char *name)
 
const char * gf_filter_pid_get_name (GF_FilterPid *PID)
 
const char * gf_filter_pid_get_filter_name (GF_FilterPid *PID)
 
const char * gf_filter_pid_orig_src_args (GF_FilterPid *PID, Bool for_unicity)
 
const char * gf_filter_pid_get_source_filter_name (GF_FilterPid *PID)
 
const char * gf_filter_pid_get_args (GF_FilterPid *PID)
 
void gf_filter_pid_set_max_buffer (GF_FilterPid *PID, u32 total_duration_us)
 
u32 gf_filter_pid_get_max_buffer (GF_FilterPid *PID)
 
Bool gf_filter_pid_is_filter_in_parents (GF_FilterPid *PID, GF_Filter *filter)
 
Bool gf_filter_pid_share_origin (GF_FilterPid *PID, GF_FilterPid *other_pid)
 
Bool gf_filter_pid_get_buffer_occupancy (GF_FilterPid *PID, u32 *max_units, u32 *nb_pck, u32 *max_duration, u32 *duration)
 
void gf_filter_pid_set_loose_connect (GF_FilterPid *PID)
 
GF_Err gf_filter_pid_push_properties (GF_FilterPid *PID, char *args, Bool direct_merge, Bool use_default_seps)
 
GF_Err gf_filter_pid_negociate_property (GF_FilterPid *PID, u32 prop_4cc, const GF_PropertyValue *value)
 
GF_Err gf_filter_pid_negociate_property_str (GF_FilterPid *PID, const char *name, const GF_PropertyValue *value)
 
GF_Err gf_filter_pid_negociate_property_dyn (GF_FilterPid *PID, char *name, const GF_PropertyValue *value)
 
const GF_PropertyValue * gf_filter_pid_caps_query (GF_FilterPid *PID, u32 prop_4cc)
 
const GF_PropertyValue * gf_filter_pid_caps_query_str (GF_FilterPid *PID, const char *prop_name)
 
GF_Err gf_filter_pid_get_statistics (GF_FilterPid *PID, GF_FilterPidStatistics *stats, GF_FilterPidStatsLocation location)
 
GF_Err gf_filter_pid_reset_properties (GF_FilterPid *PID)
 
GF_Err gf_filter_pid_copy_properties (GF_FilterPid *dst_pid, GF_FilterPid *src_pid)
 
GF_Err gf_filter_pid_merge_properties (GF_FilterPid *dst_pid, GF_FilterPid *src_pid, gf_filter_prop_filter filter_prop, void *cbk)
 
const GF_PropertyValue * gf_filter_pid_get_property (GF_FilterPid *PID, u32 prop_4cc)
 
const GF_PropertyValue * gf_filter_pid_get_property_str (GF_FilterPid *PID, const char *prop_name)
 
const GF_PropertyValue * gf_filter_pid_enum_properties (GF_FilterPid *PID, u32 *idx, u32 *prop_4cc, const char **prop_name)
 
const GF_PropertyValue * gf_filter_pid_enum_info (GF_FilterPid *PID, u32 *idx, u32 *prop_4cc, const char **prop_name)
 
GF_Err gf_filter_pid_set_framing_mode (GF_FilterPid *PID, Bool requires_full_blocks)
 
u64 gf_filter_pid_query_buffer_duration (GF_FilterPid *PID, Bool check_pid_full)
 
void gf_filter_pid_try_pull (GF_FilterPid *PID)
 
const GF_PropertyValue * gf_filter_pid_get_info (GF_FilterPid *PID, u32 prop_4cc, GF_PropertyEntry **propentry)
 
const GF_PropertyValue * gf_filter_pid_get_info_str (GF_FilterPid *PID, const char *prop_name, GF_PropertyEntry **propentry)
 
void gf_filter_pid_set_eos (GF_FilterPid *PID)
 
Bool gf_filter_pid_has_seen_eos (GF_FilterPid *PID)
 
Bool gf_filter_pid_eos_received (GF_FilterPid *PID)
 
Bool gf_filter_pid_is_eos (GF_FilterPid *PID)
 
Bool gf_filter_pid_first_packet_is_empty (GF_FilterPid *PID)
 
GF_FilterPacket * gf_filter_pid_get_packet (GF_FilterPid *PID)
 
Bool gf_filter_pid_get_first_packet_cts (GF_FilterPid *PID, u64 *cts)
 
void gf_filter_pid_drop_packet (GF_FilterPid *PID)
 
u32 gf_filter_pid_get_packet_count (GF_FilterPid *PID)
 
Bool gf_filter_pid_check_caps (GF_FilterPid *PID)
 
Bool gf_filter_pid_would_block (GF_FilterPid *PID)
 
u32 gf_filter_pid_get_timescale (GF_FilterPid *PID)
 
void gf_filter_pid_clear_eos (GF_FilterPid *PID, Bool all_pids)
 
void gf_filter_pid_set_clock_mode (GF_FilterPid *PID, Bool filter_in_charge)
 
GF_Err gf_filter_pid_resolve_file_template (GF_FilterPid *PID, char szTemplate[GF_MAX_PATH], char szFinalName[GF_MAX_PATH], u32 file_number, const char *file_suffix)
 
GF_Err gf_filter_pid_resolve_file_template_ex (GF_FilterPid *PID, char szTemplate[GF_MAX_PATH], char szFinalName[GF_MAX_PATH], u32 file_number, const char *file_suffix, const char *file_name)
 
GF_Err gf_filter_pid_set_discard (GF_FilterPid *PID, Bool discard_on)
 
void gf_filter_pid_discard_block (GF_FilterPid *PID)
 
char * gf_filter_pid_get_destination (GF_FilterPid *PID)
 
char * gf_filter_pid_get_source (GF_FilterPid *PID)
 
GF_Err gf_filter_pid_require_source_id (GF_FilterPid *PID)
 
void gf_filter_pid_recompute_dts (GF_FilterPid *PID, Bool do_recompute)
 
u32 gf_filter_pid_get_min_pck_duration (GF_FilterPid *PID)
 
void gf_filter_pid_send_event (GF_FilterPid *PID, GF_FilterEvent *evt)
 
void gf_filter_pid_init_play_event (GF_FilterPid *PID, GF_FilterEvent *evt, Double start, Double speed, const char *log_name)
 
Bool gf_filter_pid_is_playing (GF_FilterPid *PID)
 
GF_Err gf_filter_pid_allow_direct_dispatch (GF_FilterPid *PID)
 
void * gf_filter_pid_get_alias_udta (GF_FilterPid *PID)
 
GF_Filter * gf_filter_pid_get_source_filter (GF_FilterPid *PID)
 
GF_Filter * gf_filter_pid_enum_destinations (GF_FilterPid *PID, u32 idx)
 
GF_Err gf_filter_pid_ignore_blocking (GF_FilterPid *PID, Bool do_ignore)
 
u64 gf_filter_pid_get_next_ts (GF_FilterPid *PID)
 
GF_Err gf_filter_pck_ref (GF_FilterPacket **pck)
 
GF_FilterPacket * gf_filter_pck_ref_ex (GF_FilterPacket *pck)
 
void gf_filter_pck_unref (GF_FilterPacket *pck)
 
GF_Err gf_filter_pck_ref_props (GF_FilterPacket **pck)
 
GF_FilterPacket * gf_filter_pck_new_alloc (GF_FilterPid *PID, u32 data_size, u8 **data)
 
GF_FilterPacket * gf_filter_pck_new_shared (GF_FilterPid *PID, const u8 *data, u32 data_size, gf_fsess_packet_destructor destruct)
 
GF_FilterPacket * gf_filter_pck_new_ref (GF_FilterPid *PID, u32 data_offset, u32 data_size, GF_FilterPacket *source_packet)
 
GF_FilterPacket * gf_filter_pck_new_alloc_destructor (GF_FilterPid *PID, u32 data_size, u8 **data, gf_fsess_packet_destructor destruct)
 
GF_FilterPacket * gf_filter_pck_new_clone (GF_FilterPid *PID, GF_FilterPacket *pck_source, u8 **data)
 
GF_FilterPacket * gf_filter_pck_new_copy (GF_FilterPid *PID, GF_FilterPacket *pck_source, u8 **data)
 
GF_FilterPacket * gf_filter_pck_dangling_copy (GF_FilterPacket *pck_source, GF_FilterPacket *cached_pck)
 
GF_Err gf_filter_pck_set_readonly (GF_FilterPacket *pck)
 
GF_Err gf_filter_pck_send (GF_FilterPacket *pck)
 
void gf_filter_pck_discard (GF_FilterPacket *pck)
 
GF_Err gf_filter_pck_forward (GF_FilterPacket *reference, GF_FilterPid *PID)
 
const u8 * gf_filter_pck_get_data (GF_FilterPacket *pck, u32 *size)
 
GF_Err gf_filter_pck_set_property (GF_FilterPacket *pck, u32 prop_4cc, const GF_PropertyValue *value)
 
GF_Err gf_filter_pck_set_property_str (GF_FilterPacket *pck, const char *name, const GF_PropertyValue *value)
 
GF_Err gf_filter_pck_set_property_dyn (GF_FilterPacket *pck, char *name, const GF_PropertyValue *value)
 
GF_Err gf_filter_pck_merge_properties (GF_FilterPacket *pck_src, GF_FilterPacket *pck_dst)
 
GF_Err gf_filter_pck_merge_properties_filter (GF_FilterPacket *pck_src, GF_FilterPacket *pck_dst, gf_filter_prop_filter filter_prop, void *cbk)
 
const GF_PropertyValue * gf_filter_pck_get_property (GF_FilterPacket *pck, u32 prop_4cc)
 
const GF_PropertyValue * gf_filter_pck_get_property_str (GF_FilterPacket *pck, const char *prop_name)
 
const GF_PropertyValue * gf_filter_pck_enum_properties (GF_FilterPacket *pck, u32 *idx, u32 *prop_4cc, const char **prop_name)
 
GF_Err gf_filter_pck_set_framing (GF_FilterPacket *pck, Bool is_start, Bool is_end)
 
GF_Err gf_filter_pck_get_framing (GF_FilterPacket *pck, Bool *is_start, Bool *is_end)
 
GF_Err gf_filter_pck_set_dts (GF_FilterPacket *pck, u64 dts)
 
u64 gf_filter_pck_get_dts (GF_FilterPacket *pck)
 
GF_Err gf_filter_pck_set_cts (GF_FilterPacket *pck, u64 cts)
 
u64 gf_filter_pck_get_cts (GF_FilterPacket *pck)
 
u32 gf_filter_pck_get_timescale (GF_FilterPacket *pck)
 
GF_Err gf_filter_pck_set_duration (GF_FilterPacket *pck, u32 duration)
 
u32 gf_filter_pck_get_duration (GF_FilterPacket *pck)
 
GF_Err gf_filter_pck_expand (GF_FilterPacket *pck, u32 nb_bytes_to_add, u8 **data_start, u8 **new_range_start, u32 *new_size)
 
GF_Err gf_filter_pck_truncate (GF_FilterPacket *pck, u32 size)
 
GF_Err gf_filter_pck_set_sap (GF_FilterPacket *pck, GF_FilterSAPType sap_type)
 
GF_FilterSAPType gf_filter_pck_get_sap (GF_FilterPacket *pck)
 
GF_Err gf_filter_pck_set_interlaced (GF_FilterPacket *pck, u32 is_interlaced)
 
u32 gf_filter_pck_get_interlaced (GF_FilterPacket *pck)
 
GF_Err gf_filter_pck_set_corrupted (GF_FilterPacket *pck, Bool is_corrupted)
 
Bool gf_filter_pck_get_corrupted (GF_FilterPacket *pck)
 
GF_Err gf_filter_pck_set_seek_flag (GF_FilterPacket *pck, Bool is_seek)
 
Bool gf_filter_pck_get_seek_flag (GF_FilterPacket *pck)
 
GF_Err gf_filter_pck_set_byte_offset (GF_FilterPacket *pck, u64 byte_offset)
 
u64 gf_filter_pck_get_byte_offset (GF_FilterPacket *pck)
 
GF_Err gf_filter_pck_set_roll_info (GF_FilterPacket *pck, s16 roll_count)
 
s16 gf_filter_pck_get_roll_info (GF_FilterPacket *pck)
 
GF_Err gf_filter_pck_set_crypt_flags (GF_FilterPacket *pck, u8 crypt_flag)
 
u8 gf_filter_pck_get_crypt_flags (GF_FilterPacket *pck)
 
GF_Err gf_filter_pck_set_clock_type (GF_FilterPacket *pck, GF_FilterClockType ctype)
 
GF_FilterClockType gf_filter_pid_get_clock_info (GF_FilterPid *PID, u64 *clock_val, u32 *timescale)
 
GF_FilterClockType gf_filter_pck_get_clock_type (GF_FilterPacket *pck)
 
GF_Err gf_filter_pck_set_carousel_version (GF_FilterPacket *pck, u8 version_number)
 
u8 gf_filter_pck_get_carousel_version (GF_FilterPacket *pck)
 
GF_Err gf_filter_pck_set_dependency_flags (GF_FilterPacket *pck, u8 dep_flags)
 
u8 gf_filter_pck_get_dependency_flags (GF_FilterPacket *pck)
 
GF_Err gf_filter_pck_set_seq_num (GF_FilterPacket *pck, u32 seq_num)
 
u32 gf_filter_pck_get_seq_num (GF_FilterPacket *pck)
 
GF_FilterPacket * gf_filter_pck_new_frame_interface (GF_FilterPid *PID, GF_FilterFrameInterface *frame_ifce, gf_fsess_packet_destructor destruct)
 
GF_FilterFrameInterface * gf_filter_pck_get_frame_interface (GF_FilterPacket *pck)
 
Bool gf_filter_pck_is_blocking_ref (GF_FilterPacket *pck)
 
GF_Filter * gf_fs_new_filter (GF_FilterSession *session, const char *name, GF_Err *e)
 
GF_Err gf_filter_push_caps (GF_Filter *filter, u32 code, GF_PropertyValue *value, const char *name, u32 flags, u8 priority)
 
GF_Err gf_filter_set_process_ckb (GF_Filter *filter, GF_Err(*process_cbk)(GF_Filter *filter))
 
GF_Err gf_filter_set_configure_ckb (GF_Filter *filter, GF_Err(*configure_cbk)(GF_Filter *filter, GF_FilterPid *PID, Bool is_remove))
 
GF_Err gf_filter_set_process_event_ckb (GF_Filter *filter, Bool(*process_event_cbk)(GF_Filter *filter, const GF_FilterEvent *evt))
 
GF_Err gf_filter_set_reconfigure_output_ckb (GF_Filter *filter, GF_Err(*reconfigure_output_cbk)(GF_Filter *filter, GF_FilterPid *PID))
 
GF_Err gf_filter_set_probe_data_cbk (GF_Filter *filter, const char *(*probe_data_cbk)(const u8 *data, u32 size, GF_FilterProbeScore *score))
 

Detailed Description

This file contains all exported functions for filter management of the GPAC framework.

Macro Definition Documentation

◆ GF_FILTER_NO_BO

#define GF_FILTER_NO_BO

A packet byte offset is set to this value when not valid

◆ GF_FILTER_NO_TS

#define GF_FILTER_NO_TS

A packet timestamp (Decoding or Composition) is set to this value when not valid

Typedef Documentation

◆ GF_FilterSession

typedef struct __gf_filter_session GF_FilterSession

Filter Session object

◆ GF_Filter

typedef struct __gf_filter GF_Filter

Filter object

◆ GF_FilterPid

typedef struct __gf_filter_pid GF_FilterPid

Filter PID object

◆ GF_FilterPacket

typedef struct __gf_filter_pck GF_FilterPacket

Filter Packet object

◆ gf_fsess_packet_destructor

typedef void(* gf_fsess_packet_destructor) (GF_Filter *filter, GF_FilterPid *PID, GF_FilterPacket *pck)

Filter Packet destructor function prototype

◆ GF_FSTask

typedef struct __gf_fs_task GF_FSTask

Filter Session Task object

◆ GF_PropertyEntry

typedef struct __gf_prop_entry GF_PropertyEntry

Filter Property Reference object, used for info query only