FFmpeg
Main Page
Related Pages
Modules
Namespaces
Data Structures
Files
Examples
File List
Globals
•
All
Data Structures
Namespaces
Files
Functions
Variables
Typedefs
Enumerations
Enumerator
Macros
Groups
Pages
libavfilter
internal.h
Go to the documentation of this file.
1
/*
2
* This file is part of FFmpeg.
3
*
4
* FFmpeg is free software; you can redistribute it and/or
5
* modify it under the terms of the GNU Lesser General Public
6
* License as published by the Free Software Foundation; either
7
* version 2.1 of the License, or (at your option) any later version.
8
*
9
* FFmpeg is distributed in the hope that it will be useful,
10
* but WITHOUT ANY WARRANTY; without even the implied warranty of
11
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12
* Lesser General Public License for more details.
13
*
14
* You should have received a copy of the GNU Lesser General Public
15
* License along with FFmpeg; if not, write to the Free Software
16
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
*/
18
19
#ifndef AVFILTER_INTERNAL_H
20
#define AVFILTER_INTERNAL_H
21
22
/**
23
* @file
24
* internal API functions
25
*/
26
27
#include "
libavutil/internal.h
"
28
#include "
avfilter.h
"
29
#include "
avfiltergraph.h
"
30
#include "
formats.h
"
31
#include "
thread.h
"
32
#include "
version.h
"
33
#include "
video.h
"
34
35
#define POOL_SIZE 32
36
typedef
struct
AVFilterPool
{
37
AVFilterBufferRef *
pic
[
POOL_SIZE
];
38
int
count
;
39
int
refcount
;
40
int
draining
;
41
}
AVFilterPool
;
42
43
typedef
struct
AVFilterCommand
{
44
double
time
;
///< time expressed in seconds
45
char
*
command
;
///< command
46
char
*
arg
;
///< optional argument for the command
47
int
flags
;
48
struct
AVFilterCommand
*
next
;
49
}
AVFilterCommand
;
50
51
/**
52
* Update the position of a link in the age heap.
53
*/
54
void
ff_avfilter_graph_update_heap
(
AVFilterGraph
*graph,
AVFilterLink
*link);
55
56
#if !FF_API_AVFILTERPAD_PUBLIC
57
/**
58
* A filter pad used for either input or output.
59
*/
60
struct
AVFilterPad
{
61
/**
62
* Pad name. The name is unique among inputs and among outputs, but an
63
* input may have the same name as an output. This may be NULL if this
64
* pad has no need to ever be referenced by name.
65
*/
66
const
char
*
name
;
67
68
/**
69
* AVFilterPad type.
70
*/
71
enum
AVMediaType
type
;
72
73
/**
74
* Callback function to get a video buffer. If NULL, the filter system will
75
* use ff_default_get_video_buffer().
76
*
77
* Input video pads only.
78
*/
79
AVFrame
*(*get_video_buffer)(
AVFilterLink
*link,
int
w,
int
h);
80
81
/**
82
* Callback function to get an audio buffer. If NULL, the filter system will
83
* use ff_default_get_audio_buffer().
84
*
85
* Input audio pads only.
86
*/
87
AVFrame
*(*get_audio_buffer)(
AVFilterLink
*link,
int
nb_samples);
88
89
/**
90
* Filtering callback. This is where a filter receives a frame with
91
* audio/video data and should do its processing.
92
*
93
* Input pads only.
94
*
95
* @return >= 0 on success, a negative AVERROR on error. This function
96
* must ensure that samplesref is properly unreferenced on error if it
97
* hasn't been passed on to another filter.
98
*/
99
int (*
filter_frame
)(
AVFilterLink
*link,
AVFrame
*
frame
);
100
101
/**
102
* Frame poll callback. This returns the number of immediately available
103
* samples. It should return a positive value if the next request_frame()
104
* is guaranteed to return one frame (with no delay).
105
*
106
* Defaults to just calling the source poll_frame() method.
107
*
108
* Output pads only.
109
*/
110
int (*
poll_frame
)(
AVFilterLink
*link);
111
112
/**
113
* Frame request callback. A call to this should result in at least one
114
* frame being output over the given link. This should return zero on
115
* success, and another value on error.
116
*
117
* Output pads only.
118
*/
119
int (*
request_frame
)(
AVFilterLink
*link);
120
121
/**
122
* Link configuration callback.
123
*
124
* For output pads, this should set the link properties such as
125
* width/height. This should NOT set the format property - that is
126
* negotiated between filters by the filter system using the
127
* query_formats() callback before this function is called.
128
*
129
* For input pads, this should check the properties of the link, and update
130
* the filter's internal state as necessary.
131
*
132
* For both input and output filters, this should return zero on success,
133
* and another value on error.
134
*/
135
int (*
config_props
)(
AVFilterLink
*link);
136
137
/**
138
* The filter expects a fifo to be inserted on its input link,
139
* typically because it has a delay.
140
*
141
* input pads only.
142
*/
143
int
needs_fifo
;
144
};
145
#endif
146
147
struct
AVFilterGraphInternal
{
148
void
*
thread
;
149
avfilter_execute_func
*
thread_execute
;
150
};
151
152
struct
AVFilterInternal
{
153
avfilter_execute_func
*
execute
;
154
};
155
156
#if FF_API_AVFILTERBUFFER
157
/** default handler for freeing audio/video buffer when there are no references left */
158
void
ff_avfilter_default_free_buffer(AVFilterBuffer *
buf
);
159
#endif
160
161
/** Tell is a format is contained in the provided list terminated by -1. */
162
int
ff_fmt_is_in
(
int
fmt
,
const
int
*fmts);
163
164
/* Functions to parse audio format arguments */
165
166
/**
167
* Parse a pixel format.
168
*
169
* @param ret pixel format pointer to where the value should be written
170
* @param arg string to parse
171
* @param log_ctx log context
172
* @return >= 0 in case of success, a negative AVERROR code on error
173
*/
174
int
ff_parse_pixel_format
(
enum
AVPixelFormat
*
ret
,
const
char
*
arg
,
void
*log_ctx);
175
176
/**
177
* Parse a sample rate.
178
*
179
* @param ret unsigned integer pointer to where the value should be written
180
* @param arg string to parse
181
* @param log_ctx log context
182
* @return >= 0 in case of success, a negative AVERROR code on error
183
*/
184
int
ff_parse_sample_rate
(
int
*
ret
,
const
char
*
arg
,
void
*log_ctx);
185
186
/**
187
* Parse a time base.
188
*
189
* @param ret unsigned AVRational pointer to where the value should be written
190
* @param arg string to parse
191
* @param log_ctx log context
192
* @return >= 0 in case of success, a negative AVERROR code on error
193
*/
194
int
ff_parse_time_base
(
AVRational
*
ret
,
const
char
*
arg
,
void
*log_ctx);
195
196
/**
197
* Parse a sample format name or a corresponding integer representation.
198
*
199
* @param ret integer pointer to where the value should be written
200
* @param arg string to parse
201
* @param log_ctx log context
202
* @return >= 0 in case of success, a negative AVERROR code on error
203
*/
204
int
ff_parse_sample_format
(
int
*
ret
,
const
char
*
arg
,
void
*log_ctx);
205
206
/**
207
* Parse a channel layout or a corresponding integer representation.
208
*
209
* @param ret 64bit integer pointer to where the value should be written.
210
* @param nret integer pointer to the number of channels;
211
* if not NULL, then unknown channel layouts are accepted
212
* @param arg string to parse
213
* @param log_ctx log context
214
* @return >= 0 in case of success, a negative AVERROR code on error
215
*/
216
int
ff_parse_channel_layout
(int64_t *
ret
,
int
*nret,
const
char
*
arg
,
217
void
*log_ctx);
218
219
void
ff_update_link_current_pts
(
AVFilterLink
*link, int64_t pts);
220
221
void
ff_command_queue_pop
(
AVFilterContext
*
filter
);
222
223
/* misc trace functions */
224
225
/* #define FF_AVFILTER_TRACE */
226
227
#ifdef FF_AVFILTER_TRACE
228
# define ff_tlog(pctx, ...) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__)
229
#else
230
# define ff_tlog(pctx, ...) do { if (0) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__); } while (0)
231
#endif
232
233
#define FF_TPRINTF_START(ctx, func) ff_tlog(NULL, "%-16s: ", #func)
234
235
char
*
ff_get_ref_perms_string
(
char
*
buf
,
size_t
buf_size,
int
perms);
236
237
void
ff_tlog_ref
(
void
*ctx,
AVFrame
*ref,
int
end
);
238
239
void
ff_tlog_link
(
void
*ctx,
AVFilterLink
*link,
int
end
);
240
241
/**
242
* Insert a new pad.
243
*
244
* @param idx Insertion point. Pad is inserted at the end if this point
245
* is beyond the end of the list of pads.
246
* @param count Pointer to the number of pads in the list
247
* @param padidx_off Offset within an AVFilterLink structure to the element
248
* to increment when inserting a new pad causes link
249
* numbering to change
250
* @param pads Pointer to the pointer to the beginning of the list of pads
251
* @param links Pointer to the pointer to the beginning of the list of links
252
* @param newpad The new pad to add. A copy is made when adding.
253
* @return >= 0 in case of success, a negative AVERROR code on error
254
*/
255
int
ff_insert_pad
(
unsigned
idx,
unsigned
*
count
,
size_t
padidx_off,
256
AVFilterPad
**pads,
AVFilterLink
***links,
257
AVFilterPad
*newpad);
258
259
/** Insert a new input pad for the filter. */
260
static
inline
int
ff_insert_inpad
(
AVFilterContext
*f,
unsigned
index
,
261
AVFilterPad
*p)
262
{
263
int
ret
=
ff_insert_pad
(index, &f->
nb_inputs
, offsetof(
AVFilterLink
, dstpad),
264
&f->
input_pads
, &f->
inputs
, p);
265
#if FF_API_FOO_COUNT
266
FF_DISABLE_DEPRECATION_WARNINGS
267
f->input_count = f->
nb_inputs
;
268
FF_ENABLE_DEPRECATION_WARNINGS
269
#endif
270
return
ret
;
271
}
272
273
/** Insert a new output pad for the filter. */
274
static
inline
int
ff_insert_outpad
(
AVFilterContext
*f,
unsigned
index
,
275
AVFilterPad
*p)
276
{
277
int
ret
=
ff_insert_pad
(index, &f->
nb_outputs
, offsetof(
AVFilterLink
, srcpad),
278
&f->
output_pads
, &f->
outputs
, p);
279
#if FF_API_FOO_COUNT
280
FF_DISABLE_DEPRECATION_WARNINGS
281
f->output_count = f->
nb_outputs
;
282
FF_ENABLE_DEPRECATION_WARNINGS
283
#endif
284
return
ret
;
285
}
286
287
/**
288
* Poll a frame from the filter chain.
289
*
290
* @param link the input link
291
* @return the number of immediately available frames, a negative
292
* number in case of error
293
*/
294
int
ff_poll_frame
(
AVFilterLink
*link);
295
296
/**
297
* Request an input frame from the filter at the other end of the link.
298
*
299
* @param link the input link
300
* @return zero on success
301
*/
302
int
ff_request_frame
(
AVFilterLink
*link);
303
304
#define AVFILTER_DEFINE_CLASS(fname) \
305
static const AVClass fname##_class = { \
306
.class_name = #fname, \
307
.item_name = av_default_item_name, \
308
.option = fname##_options, \
309
.version = LIBAVUTIL_VERSION_INT, \
310
.category = AV_CLASS_CATEGORY_FILTER, \
311
}
312
313
AVFilterBufferRef *
ff_copy_buffer_ref
(
AVFilterLink
*outlink,
314
AVFilterBufferRef *ref);
315
316
/**
317
* Find the index of a link.
318
*
319
* I.e. find i such that link == ctx->(in|out)puts[i]
320
*/
321
#define FF_INLINK_IDX(link) ((int)((link)->dstpad - (link)->dst->input_pads))
322
#define FF_OUTLINK_IDX(link) ((int)((link)->srcpad - (link)->src->output_pads))
323
324
int
ff_buffersink_read_compat
(
AVFilterContext
*ctx, AVFilterBufferRef **
buf
);
325
int
ff_buffersink_read_samples_compat
(
AVFilterContext
*ctx, AVFilterBufferRef **pbuf,
326
int
nb_samples);
327
/**
328
* Send a frame of data to the next filter.
329
*
330
* @param link the output link over which the data is being sent
331
* @param frame a reference to the buffer of data being sent. The
332
* receiving filter will free this reference when it no longer
333
* needs it or pass it on to the next filter.
334
*
335
* @return >= 0 on success, a negative AVERROR on error. The receiving filter
336
* is responsible for unreferencing frame in case of error.
337
*/
338
int
ff_filter_frame
(
AVFilterLink
*link,
AVFrame
*
frame
);
339
340
/**
341
* Flags for AVFilterLink.flags.
342
*/
343
enum
{
344
345
/**
346
* Frame requests may need to loop in order to be fulfilled.
347
* A filter must set this flags on an output link if it may return 0 in
348
* request_frame() without filtering a frame.
349
*/
350
FF_LINK_FLAG_REQUEST_LOOP
= 1,
351
352
};
353
354
/**
355
* Allocate a new filter context and return it.
356
*
357
* @param filter what filter to create an instance of
358
* @param inst_name name to give to the new filter context
359
*
360
* @return newly created filter context or NULL on failure
361
*/
362
AVFilterContext
*
ff_filter_alloc
(
const
AVFilter
*
filter
,
const
char
*inst_name);
363
364
/**
365
* Remove a filter from a graph;
366
*/
367
void
ff_filter_graph_remove_filter
(
AVFilterGraph
*graph,
AVFilterContext
*
filter
);
368
369
#endif
/* AVFILTER_INTERNAL_H */
Generated on Sat Jan 25 2014 19:51:49 for FFmpeg by
1.8.2