Go to the documentation of this file.
37 #define COMMAND_FLAG_ENTER 1
38 #define COMMAND_FLAG_LEAVE 2
39 #define COMMAND_FLAG_EXPR 4
65 static const char *
const flag_strings[] = {
"enter",
"leave",
"expr" };
105 #define OFFSET(x) offsetof(SendCmdContext, x)
106 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_VIDEO_PARAM
115 #define SPACES " \f\t\n\r"
121 *buf += strspn(*buf,
SPACES);
128 *buf += strcspn(*buf,
"\n");
134 #define COMMAND_DELIMS " \f\t\n\r,;"
137 const char **buf,
void *log_ctx)
141 memset(cmd, 0,
sizeof(
Command));
142 cmd->
index = cmd_count;
145 *buf += strspn(*buf,
SPACES);
152 int len = strcspn(*buf,
"|+]");
161 "Unknown flag '%s' in interval #%d, command #%d\n",
162 flag_buf, interval_count, cmd_count);
168 if (!strspn(*buf,
"+|")) {
170 "Invalid flags char '%c' in interval #%d, command #%d\n",
171 **buf, interval_count, cmd_count);
180 "Missing flag terminator or extraneous data found at the end of flags "
181 "in interval #%d, command #%d\n", interval_count, cmd_count);
189 *buf += strspn(*buf,
SPACES);
193 "No target specified in interval #%d, command #%d\n",
194 interval_count, cmd_count);
199 *buf += strspn(*buf,
SPACES);
203 "No command specified in interval #%d, command #%d\n",
204 interval_count, cmd_count);
209 *buf += strspn(*buf,
SPACES);
222 const char **buf,
void *log_ctx)
234 if ((
ret =
parse_command(&cmd, cmd_count, interval_count, buf, log_ctx)) < 0)
244 "Could not (re)allocate command array\n");
249 (*cmds)[(*nb_cmds)++] = cmd;
251 *buf += strspn(*buf,
SPACES);
252 if (**buf && **buf !=
';' && **buf !=
',') {
254 "Missing separator or extraneous data found at the end of "
255 "interval #%d, in command #%d\n",
256 interval_count, cmd_count);
258 "Command was parsed as: flags:[%s] target:%s command:%s arg:%s\n",
271 #define DELIMS " \f\t\n\r,;"
274 const char **buf,
void *log_ctx)
279 *buf += strspn(*buf,
SPACES);
284 memset(interval, 0,
sizeof(
Interval));
285 interval->
index = interval_count;
291 if (intervalstr && intervalstr[0]) {
298 "Invalid interval specification '%s' in interval #%d\n",
299 intervalstr, interval_count);
304 "Invalid start time specification '%s' in interval #%d\n",
305 start, interval_count);
312 "Invalid end time specification '%s' in interval #%d\n",
313 end, interval_count);
317 interval->
end_ts = INT64_MAX;
321 "Invalid end time '%s' in interval #%d: "
322 "cannot be lesser than start time '%s'\n",
323 end, interval_count, start);
329 "No interval specified for interval #%d\n", interval_count);
336 interval_count, buf, log_ctx);
344 const char *buf,
void *log_ctx)
346 int interval_count = 0;
365 buf += strspn(buf,
SPACES);
369 "Missing terminator or extraneous data found at the end of interval #%d\n",
378 if (*nb_intervals == n) {
383 "Could not (re)allocate intervals array\n");
388 (*intervals)[(*nb_intervals)++] = interval;
406 if ((!!
s->commands_filename + !!
s->commands_str) != 1) {
408 "One and only one of the filename or commands options must be specified\n");
412 if (
s->commands_filename) {
416 &file_buf, &file_bufsize, 0,
ctx);
426 memcpy(buf, file_buf, file_bufsize);
427 buf[file_bufsize] = 0;
429 s->commands_str = buf;
433 s->commands_str,
ctx)) < 0)
436 if (
s->nb_intervals == 0) {
444 for (
i = 0;
i <
s->nb_intervals;
i++) {
452 " [%s] target:%s command:%s arg:%s index:%d\n",
465 for (
i = 0;
i <
s->nb_intervals;
i++) {
478 #define TS2D(ts) ((ts) == AV_NOPTS_VALUE ? NAN : (double)(ts))
479 #define TS2T(ts, tb) ((ts) == AV_NOPTS_VALUE ? NAN : (double)(ts)*av_q2d(tb))
493 #define WITHIN_INTERVAL(ts, start_ts, end_ts) ((ts) >= (start_ts) && (ts) < (end_ts))
495 for (
i = 0;
i <
s->nb_intervals;
i++) {
513 "[%s] interval #%d start_ts:%f end_ts:%f ts:%f\n",
515 (
double)interval->
start_ts/1000000, (
double)interval->
end_ts/1000000,
520 char *cmd_arg = cmd->
arg;
533 var_values[
VAR_T] = current;
534 var_values[
VAR_TS] = start;
536 var_values[
VAR_TI] = (current - start) / (
end - start);
552 "Processing command #%d target:%s command:%s arg:%s\n",
559 "Command reply for command #%d: ret:%s res:%s\n",
578 #if CONFIG_SENDCMD_FILTER
580 #define sendcmd_options options
608 .priv_class = &sendcmd_class,
613 #if CONFIG_ASENDCMD_FILTER
615 #define asendcmd_options options
641 .
inputs = asendcmd_inputs,
643 .priv_class = &asendcmd_class,
#define AVFILTER_CMD_FLAG_ONE
Stop once a filter understood the command (for target=all for example), fast filters are favored auto...
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
#define WITHIN_INTERVAL(ts, start_ts, end_ts)
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
char * av_get_token(const char **buf, const char *term)
Unescape the given string until a non escaped terminating char, and return the token corresponding to...
static char * make_command_flags_str(AVBPrint *pbuf, int flags)
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
static int cmp_intervals(const void *a, const void *b)
static int parse_command(Command *cmd, int cmd_count, int interval_count, const char **buf, void *log_ctx)
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
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
char * av_asprintf(const char *fmt,...)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
static av_cold int end(AVCodecContext *avctx)
This structure describes decoded (raw) audio or video data.
#define AV_LOG_VERBOSE
Detailed information.
int index
unique index for these interval commands
const char * name
Filter name.
A link between two filters.
#define COMMAND_FLAG_LEAVE
int av_file_map(const char *filename, uint8_t **bufptr, size_t *size, int log_offset, void *log_ctx)
Read the file with name filename, and put its content in a newly allocated buffer or map it with mmap...
#define AV_BPRINT_SIZE_AUTOMATIC
A filter pad used for either input or output.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define COMMAND_FLAG_ENTER
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok().
static const AVFilterPad outputs[]
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
static int parse_interval(Interval *interval, int interval_count, const char **buf, void *log_ctx)
void av_file_unmap(uint8_t *bufptr, size_t size)
Unmap or free the buffer bufptr created by av_file_map().
static const AVOption options[]
#define av_realloc_f(p, o, n)
Describe the class of an AVClass context structure.
static av_cold void uninit(AVFilterContext *ctx)
int av_parse_time(int64_t *timeval, const char *timestr, int duration)
Parse timestr and return in *time a corresponding number of microseconds.
int64_t end_ts
end timestamp expressed as microseconds units
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 char *const var_names[]
static int filter_frame(AVFilterLink *inlink, AVFrame *ref)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
int av_expr_parse_and_eval(double *d, const char *s, const char *const *const_names, const double *const_values, const char *const *func1_names, double(*const *funcs1)(void *, double), const char *const *func2_names, double(*const *funcs2)(void *, double, double), void *opaque, int log_offset, void *log_ctx)
Parse and evaluate an expression.
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
#define AV_NOPTS_VALUE
Undefined timestamp value.
#define FFDIFFSIGN(x, y)
Comparator.
static av_cold int init(AVFilterContext *ctx)
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
#define AVFILTER_DEFINE_CLASS(fname)
#define i(width, name, range_min, range_max)
static int parse_commands(Command **cmds, int *nb_cmds, int interval_count, const char **buf, void *log_ctx)
const char * name
Pad name.
static void skip_comments(const char **buf)
void av_bprintf(AVBPrint *buf, const char *fmt,...)
#define FF_ARRAY_ELEMS(a)
#define COMMAND_FLAG_EXPR
static int ref[MAX_W *MAX_W]
int enabled
current time detected inside this interval
#define flags(name, subs,...)
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
int avfilter_graph_send_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, char *res, int res_len, int flags)
Send a command to one or more filter instances.
static int parse_intervals(Interval **intervals, int *nb_intervals, const char *buf, void *log_ctx)
int64_t start_ts
start timestamp expressed as microseconds units
void av_bprint_chars(AVBPrint *buf, char c, unsigned n)
Append char c n times to a print buffer.