return AVERROR(ENOSYS);
}
-static AVFilter *first_filter;
-static AVFilter **last_filter = &first_filter;
-
-const AVFilter *avfilter_get_by_name(const char *name)
-{
- const AVFilter *f = NULL;
-
- if (!name)
- return NULL;
-
- while ((f = avfilter_next(f)))
- if (!strcmp(f->name, name))
- return (AVFilter *)f;
-
- return NULL;
-}
-
-static AVMutex filter_register_mutex = AV_MUTEX_INITIALIZER;
-
-int avfilter_register(AVFilter *filter)
-{
- AVFilter **f;
-
- /* the filter must select generic or internal exclusively */
- av_assert0((filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE) != AVFILTER_FLAG_SUPPORT_TIMELINE);
-
- ff_mutex_lock(&filter_register_mutex);
- f = last_filter;
-
- while (*f)
- f = &(*f)->next;
- *f = filter;
- filter->next = NULL;
- last_filter = &filter->next;
-
- ff_mutex_unlock(&filter_register_mutex);
-
- return 0;
-}
-
-const AVFilter *avfilter_next(const AVFilter *prev)
-{
- return prev ? prev->next : first_filter;
-}
-
int avfilter_pad_count(const AVFilterPad *pads)
{
int count;
static const AVClass *filter_child_class_next(const AVClass *prev)
{
+ void *opaque = NULL;
const AVFilter *f = NULL;
/* find the filter that corresponds to prev */
- while (prev && (f = avfilter_next(f)))
+ while (prev && (f = av_filter_iterate(&opaque)))
if (f->priv_class == prev)
break;
return NULL;
/* find next filter with specific options */
- while ((f = avfilter_next(f)))
+ while ((f = av_filter_iterate(&opaque)))
if (f->priv_class)
return f->priv_class;
static const AVOption avfilter_options[] = {
{ "thread_type", "Allowed thread types", OFFSET(thread_type), AV_OPT_TYPE_FLAGS,
{ .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, FLAGS, "thread_type" },
- { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .unit = "thread_type" },
+ { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .flags = FLAGS, .unit = "thread_type" },
{ "enable", "set enable expression", OFFSET(enable_str), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = FLAGS },
{ "threads", "Allowed number of threads", OFFSET(nb_threads), AV_OPT_TYPE_INT,
{ .i64 = 0 }, 0, INT_MAX, FLAGS },
and request_frame() to acknowledge status changes), to run once more
and check if enough input was present for several frames.
- Exemples of scenarios to consider:
+ Examples of scenarios to consider:
- buffersrc: activate if frame_wanted_out to notify the application;
activate when the application adds a frame to push it immediately.
- If an input has frames in fifo and frame_wanted_out == 0, dequeue a
frame and call filter_frame().
- Ratinale: filter frames as soon as possible instead of leaving them
+ Rationale: filter frames as soon as possible instead of leaving them
queued; frame_wanted_out < 0 is not possible since the old API does not
set it nor provides any similar feedback; frame_wanted_out > 0 happens
when min_samples > 0 and there are not enough samples queued.
return 1;
}
+size_t ff_inlink_queued_frames(AVFilterLink *link)
+{
+ return ff_framequeue_queued_frames(&link->fifo);
+}
+
int ff_inlink_check_available_frame(AVFilterLink *link)
{
return ff_framequeue_queued_frames(&link->fifo) > 0;
}
+int ff_inlink_queued_samples(AVFilterLink *link)
+{
+ return ff_framequeue_queued_samples(&link->fifo);
+}
+
int ff_inlink_check_available_samples(AVFilterLink *link, unsigned min)
{
uint64_t samples = ff_framequeue_queued_samples(&link->fifo);
return 1;
}
+AVFrame *ff_inlink_peek_frame(AVFilterLink *link, size_t idx)
+{
+ return ff_framequeue_peek(&link->fifo, idx);
+}
+
int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
{
AVFrame *frame = *rframe;