internal.h 12 KB

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