1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
#pragma once
#include "filter.h"
// Filter that computes the exact duration of video frames by buffering 1 frame,
// and taking the PTS difference. This supports video frames only, and stores
// the duration in mp_image.pkt_duration. All other frame types are passed
// through.
struct mp_filter *mp_compute_frame_duration_create(struct mp_filter *parent);
// Given the filters[0..num_filters] array, connect in with the input of the
// first filter, connect the output of the first filter to the input to the
// second filter, etc., until out. All filters are assumed to be bidirectional,
// with input on pin 0 and output on pin 1. NULL entries are skipped.
void mp_chain_filters(struct mp_pin *in, struct mp_pin *out,
struct mp_filter **filters, int num_filters);
// Helper for maintaining a sub-filter that is created or destroyed on demand,
// because it might depend on frame input formats or is otherwise dynamically
// changing. (This is overkill for more static sub filters, or entirely manual
// filtering.)
// To initialize this, zero-init all fields, and set the in/out fields.
struct mp_subfilter {
// These two fields must be set on init. The pins must have a manual
// connection to the filter whose process() function calls the
// mp_subfilter_*() functions.
struct mp_pin *in, *out;
// Temporary buffered frame, as triggered by mp_subfilter_read(). You can
// not mutate this (unless you didn't create or destroy sub->filter).
struct mp_frame frame;
// The sub-filter, set by the user. Can be NULL if disabled. If set, this
// must be a bidirectional filter, with manual connections same as
// mp_sub_filter.in/out (to get the correct process() function called).
// Set this only if it's NULL. You should not overwrite this if it's set.
// Use either mp_subfilter_drain_destroy(), mp_subfilter_destroy(), or
// mp_subfilter_reset() to unset and destroy the filter gracefully.
struct mp_filter *filter;
// Internal state.
bool draining;
};
// Make requests for a new frame.
// Returns whether sub->frame is set to anything. If true is returned, you
// must either call mp_subfilter_continue() or mp_subfilter_drain_destroy()
// once to continue data flow normally (otherwise it will stall). If you call
// mp_subfilter_drain_destroy(), and it returns true, or you call
// mp_subfilter_destroy(), you can call mp_subfilter_continue() once after it.
// If this returns true, sub->frame is never unset (MP_FRAME_NONE).
bool mp_subfilter_read(struct mp_subfilter *sub);
// Clear internal state (usually to be called by parent filter's reset(), or
// destroy()). This usually does not free sub->filter.
void mp_subfilter_reset(struct mp_subfilter *sub);
// Continue filtering sub->frame. This can happen after setting a new filter
// too.
void mp_subfilter_continue(struct mp_subfilter *sub);
// Destroy the filter immediately (if it's set). You must call
// mp_subfilter_continue() after this to propagate sub->frame.
void mp_subfilter_destroy(struct mp_subfilter *sub);
// Make sure the filter is destroyed. Returns true if the filter was destroyed.
// If this returns false, exit your process() function, so dataflow can
// continue normally. (process() is repeated until this function returns true,
// which can take a while if sub->filter has many frames buffered).
// If this returns true, call mp_subfilter_continue() to propagate sub->frame.
// The filter is destroyed with talloc_free(sub->filter).
bool mp_subfilter_drain_destroy(struct mp_subfilter *sub);
// A bidirectional filter which passes through all data.
struct mp_filter *mp_bidir_nop_filter_create(struct mp_filter *parent);
// A bidirectional filter which does not connect its pins. Instead, the user is,
// by convention, allowed to access the filter's private pins, and use them
// freely. (This is sometimes convenient, such as when you need to pass a single
// filter instance to other code, and you don't need a full "proper" filter.)
struct mp_filter *mp_bidir_dummy_filter_create(struct mp_filter *parent);
// A filter which repacks audio frame to fixed frame sizes with the given
// number of samples. On hard format changes (sample format/channels/srate),
// the frame can be shorter, unless pad_silence is true. Fails on non-aframes.
struct mp_filter *mp_fixed_aframe_size_create(struct mp_filter *parent,
int samples, bool pad_silence);
|
