67 #define OFFSET(x) offsetof(GraphMonitorContext, x) 68 #define VF AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM 117 for (
int j = 0; j < out->
width; j++)
129 if (y + 8 >= pic->
height ||
130 x + strlen(txt) * 8 >= pic->
width)
133 for (i = 0; txt[
i]; i++) {
137 for (char_y = 0; char_y < font_height; char_y++) {
138 for (mask = 0x80;
mask; mask >>= 1) {
139 if (font[txt[i] * font_height + char_y] & mask) {
153 for (
int j = 0; j < filter->
nb_inputs; j++) {
161 for (
int j = 0; j < filter->
nb_outputs; j++) {
178 char buffer[1024] = { 0 };
182 snprintf(buffer,
sizeof(buffer)-1,
" | format: %s",
185 snprintf(buffer,
sizeof(buffer)-1,
" | format: %s",
189 xpos += strlen(buffer) * 8;
193 snprintf(buffer,
sizeof(buffer)-1,
" | size: %dx%d", l->
w, l->
h);
198 xpos += strlen(buffer) * 8;
207 xpos += strlen(buffer) * 8;
212 xpos += strlen(buffer) * 8;
215 snprintf(buffer,
sizeof(buffer)-1,
" | queue: ");
217 xpos += strlen(buffer) * 8;
220 xpos += strlen(buffer) * 8;
225 xpos += strlen(buffer) * 8;
230 xpos += strlen(buffer) * 8;
235 xpos += strlen(buffer) * 8;
240 xpos += strlen(buffer) * 8;
243 snprintf(buffer,
sizeof(buffer)-1,
" | eof");
245 xpos += strlen(buffer) * 8;
264 char buffer[1024] = { 0 };
271 xpos += strlen(filter->
name) * 8 + 10;
274 for (
int j = 0; j < filter->
nb_inputs; j++) {
278 if (s->
mode && !frames)
282 snprintf(buffer,
sizeof(buffer)-1,
"in%d: ", j);
284 xpos += strlen(buffer) * 8;
286 xpos += strlen(l->
src->
name) * 8 + 10;
292 for (
int j = 0; j < filter->
nb_outputs; j++) {
296 if (s->
mode && !frames)
300 snprintf(buffer,
sizeof(buffer)-1,
"out%d: ", j);
302 xpos += strlen(buffer) * 8;
304 xpos += strlen(l->
dst->
name) * 8 + 10;
375 #if CONFIG_GRAPHMONITOR_FILTER 387 static const AVFilterPad graphmonitor_outputs[] = {
397 .
name =
"graphmonitor",
400 .priv_class = &graphmonitor_class,
403 .
inputs = graphmonitor_inputs,
404 .
outputs = graphmonitor_outputs,
407 #endif // CONFIG_GRAPHMONITOR_FILTER 409 #if CONFIG_AGRAPHMONITOR_FILTER 411 #define agraphmonitor_options graphmonitor_options 414 static const AVFilterPad agraphmonitor_inputs[] = {
422 static const AVFilterPad agraphmonitor_outputs[] = {
432 .
name =
"agraphmonitor",
435 .priv_class = &agraphmonitor_class,
438 .
inputs = agraphmonitor_inputs,
439 .
outputs = agraphmonitor_outputs,
441 #endif // CONFIG_AGRAPHMONITOR_FILTER AVFilterContext ** filters
int64_t frame_count_in
Number of past frames sent through the link.
int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
Take a frame from the link's FIFO and update the link's stats.
This structure describes decoded (raw) audio or video data.
Main libavfilter public API header.
int h
agreed upon image height
FF_FILTER_FORWARD_STATUS(inlink, outlink)
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
AVFilter ff_avf_agraphmonitor
if it could not because there are no more frames
struct AVFilterGraph * graph
filtergraph this filter belongs to
const char * name
Pad name.
AVFilterLink ** inputs
array of pointers to input links
char * name
name of this filter instance
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
timestamp utils, mostly useful for debugging/logging purposes
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the ff_outlink_frame_wanted() function.If this function returns true
#define FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink)
Forward the status on an output link to an input link.
A filter pad used for either input or output.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
A link between two filters.
const uint8_t avpriv_cga_font[2048]
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
AVRational frame_rate
Frame rate of the stream on the link, or 1/0 if unknown or variable; if left to 0/0, will be automatically copied from the first input of the source filter if it exists.
int sample_rate
samples per second
static const uint16_t mask[17]
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
#define av_ts2timestr(ts, tb)
Convenience macro, the return value should be used only directly in function arguments but never stan...
unsigned nb_outputs
number of output pads
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
int64_t current_pts_us
Current timestamp of the link, as defined by the most recent frame(s), in AV_TIME_BASE units...
void * priv
private data for use by the filter
AVRational time_base
Define the time base used by the PTS of the frames/samples which will pass through this link...
const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
int w
agreed upon image width
unsigned nb_inputs
number of input pads
static int config_output(AVFilterLink *outlink)
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
AVFilterContext * src
source filter
static const AVFilterPad outputs[]
int format
agreed upon media format
AVFilter ff_vf_graphmonitor
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
static const AVOption graphmonitor_options[]
Describe the class of an AVClass context structure.
int ff_outlink_get_status(AVFilterLink *link)
Get the status on an output link.
static int filter_have_queued(AVFilterContext *filter)
Rational number (pair of numerator and denominator).
offset must point to AVRational
const char * name
Filter name.
AVRational sample_aspect_ratio
agreed upon sample aspect ratio
size_t ff_inlink_queued_frames(AVFilterLink *link)
Get the number of frames available on the link.
offset must point to two consecutive integers
AVFilterLink ** outputs
array of pointers to output links
static enum AVPixelFormat pix_fmts[]
enum AVMediaType type
filter media type
static int activate(AVFilterContext *ctx)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
static void clear_image(GraphMonitorContext *s, AVFrame *out, AVFilterLink *outlink)
int channels
Number of channels.
AVFilterFormatsConfig incfg
Lists of supported formats / etc.
FF_FILTER_FORWARD_WANTED(outlink, inlink)
static int query_formats(AVFilterContext *ctx)
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
AVFilterContext * dst
dest filter
#define AVFILTER_DEFINE_CLASS(fname)
static void drawtext(AVFrame *pic, int x, int y, const char *txt, uint8_t *color)
static void draw_items(AVFilterContext *ctx, AVFrame *out, int xpos, int ypos, AVFilterLink *l, size_t frames)
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
static int create_frame(AVFilterContext *ctx, int64_t pts)
AVPixelFormat
Pixel format.
mode
Use these values in ebur128_init (or'ed).
const AVFilter * filter
the AVFilter of which this is an instance
#define AV_NOPTS_VALUE
Undefined timestamp value.
CGA/EGA/VGA ROM font data.
simple arithmetic expression evaluator