LCOV - code coverage report
Current view: top level - libavfilter - internal.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 4 11 36.4 %
Date: 2017-12-10 21:22:29 Functions: 2 3 66.7 %

          Line data    Source code
       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 "formats.h"
      30             : #include "framepool.h"
      31             : #include "framequeue.h"
      32             : #include "thread.h"
      33             : #include "version.h"
      34             : #include "video.h"
      35             : #include "libavcodec/avcodec.h"
      36             : #include "libavcodec/internal.h"
      37             : 
      38             : typedef struct AVFilterCommand {
      39             :     double time;                ///< time expressed in seconds
      40             :     char *command;              ///< command
      41             :     char *arg;                  ///< optional argument for the command
      42             :     int flags;
      43             :     struct AVFilterCommand *next;
      44             : } AVFilterCommand;
      45             : 
      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             : 
      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             :     /**
      63             :      * AVFilterPad type.
      64             :      */
      65             :     enum AVMediaType type;
      66             : 
      67             :     /**
      68             :      * Callback function to get a video buffer. If NULL, the filter system will
      69             :      * use ff_default_get_video_buffer().
      70             :      *
      71             :      * Input video pads only.
      72             :      */
      73             :     AVFrame *(*get_video_buffer)(AVFilterLink *link, int w, int h);
      74             : 
      75             :     /**
      76             :      * Callback function to get an audio buffer. If NULL, the filter system will
      77             :      * use ff_default_get_audio_buffer().
      78             :      *
      79             :      * Input audio pads only.
      80             :      */
      81             :     AVFrame *(*get_audio_buffer)(AVFilterLink *link, int nb_samples);
      82             : 
      83             :     /**
      84             :      * Filtering callback. This is where a filter receives a frame with
      85             :      * audio/video data and should do its processing.
      86             :      *
      87             :      * Input pads only.
      88             :      *
      89             :      * @return >= 0 on success, a negative AVERROR on error. This function
      90             :      * must ensure that frame is properly unreferenced on error if it
      91             :      * hasn't been passed on to another filter.
      92             :      */
      93             :     int (*filter_frame)(AVFilterLink *link, AVFrame *frame);
      94             : 
      95             :     /**
      96             :      * Frame poll callback. This returns the number of immediately available
      97             :      * samples. It should return a positive value if the next request_frame()
      98             :      * is guaranteed to return one frame (with no delay).
      99             :      *
     100             :      * Defaults to just calling the source poll_frame() method.
     101             :      *
     102             :      * Output pads only.
     103             :      */
     104             :     int (*poll_frame)(AVFilterLink *link);
     105             : 
     106             :     /**
     107             :      * Frame request callback. A call to this should result in some progress
     108             :      * towards producing output over the given link. This should return zero
     109             :      * on success, and another value on error.
     110             :      *
     111             :      * Output pads only.
     112             :      */
     113             :     int (*request_frame)(AVFilterLink *link);
     114             : 
     115             :     /**
     116             :      * Link configuration callback.
     117             :      *
     118             :      * For output pads, this should set the link properties such as
     119             :      * width/height. This should NOT set the format property - that is
     120             :      * negotiated between filters by the filter system using the
     121             :      * query_formats() callback before this function is called.
     122             :      *
     123             :      * For input pads, this should check the properties of the link, and update
     124             :      * the filter's internal state as necessary.
     125             :      *
     126             :      * For both input and output filters, this should return zero on success,
     127             :      * and another value on error.
     128             :      */
     129             :     int (*config_props)(AVFilterLink *link);
     130             : 
     131             :     /**
     132             :      * The filter expects a fifo to be inserted on its input link,
     133             :      * typically because it has a delay.
     134             :      *
     135             :      * input pads only.
     136             :      */
     137             :     int needs_fifo;
     138             : 
     139             :     /**
     140             :      * The filter expects writable frames from its input link,
     141             :      * duplicating data buffers if needed.
     142             :      *
     143             :      * input pads only.
     144             :      */
     145             :     int needs_writable;
     146             : };
     147             : 
     148             : struct AVFilterGraphInternal {
     149             :     void *thread;
     150             :     avfilter_execute_func *thread_execute;
     151             :     FFFrameQueueGlobal frame_queues;
     152             : };
     153             : 
     154             : struct AVFilterInternal {
     155             :     avfilter_execute_func *execute;
     156             : };
     157             : 
     158             : /**
     159             :  * Tell if an integer is contained in the provided -1-terminated list of integers.
     160             :  * This is useful for determining (for instance) if an AVPixelFormat is in an
     161             :  * array of supported formats.
     162             :  *
     163             :  * @param fmt provided format
     164             :  * @param fmts -1-terminated list of formats
     165             :  * @return 1 if present, 0 if absent
     166             :  */
     167             : int ff_fmt_is_in(int fmt, const int *fmts);
     168             : 
     169             : /* Functions to parse audio format arguments */
     170             : 
     171             : /**
     172             :  * Parse a pixel format.
     173             :  *
     174             :  * @param ret pixel format 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             : av_warn_unused_result
     180             : int ff_parse_pixel_format(enum AVPixelFormat *ret, const char *arg, void *log_ctx);
     181             : 
     182             : /**
     183             :  * Parse a sample rate.
     184             :  *
     185             :  * @param ret unsigned integer pointer to where the value should be written
     186             :  * @param arg string to parse
     187             :  * @param log_ctx log context
     188             :  * @return >= 0 in case of success, a negative AVERROR code on error
     189             :  */
     190             : av_warn_unused_result
     191             : int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx);
     192             : 
     193             : /**
     194             :  * Parse a time base.
     195             :  *
     196             :  * @param ret unsigned AVRational pointer to where the value should be written
     197             :  * @param arg string to parse
     198             :  * @param log_ctx log context
     199             :  * @return >= 0 in case of success, a negative AVERROR code on error
     200             :  */
     201             : av_warn_unused_result
     202             : int ff_parse_time_base(AVRational *ret, const char *arg, void *log_ctx);
     203             : 
     204             : /**
     205             :  * Parse a sample format name or a corresponding integer representation.
     206             :  *
     207             :  * @param ret integer pointer to where the value should be written
     208             :  * @param arg string to parse
     209             :  * @param log_ctx log context
     210             :  * @return >= 0 in case of success, a negative AVERROR code on error
     211             :  */
     212             : av_warn_unused_result
     213             : int ff_parse_sample_format(int *ret, const char *arg, void *log_ctx);
     214             : 
     215             : /**
     216             :  * Parse a channel layout or a corresponding integer representation.
     217             :  *
     218             :  * @param ret 64bit integer pointer to where the value should be written.
     219             :  * @param nret integer pointer to the number of channels;
     220             :  *             if not NULL, then unknown channel layouts are accepted
     221             :  * @param arg string to parse
     222             :  * @param log_ctx log context
     223             :  * @return >= 0 in case of success, a negative AVERROR code on error
     224             :  */
     225             : av_warn_unused_result
     226             : int ff_parse_channel_layout(int64_t *ret, int *nret, const char *arg,
     227             :                             void *log_ctx);
     228             : 
     229             : void ff_update_link_current_pts(AVFilterLink *link, int64_t pts);
     230             : 
     231             : /**
     232             :  * Set the status field of a link from the source filter.
     233             :  * The pts should reflect the timestamp of the status change,
     234             :  * in link time base and relative to the frames timeline.
     235             :  * In particular, for AVERROR_EOF, it should reflect the
     236             :  * end time of the last frame.
     237             :  */
     238             : void ff_avfilter_link_set_in_status(AVFilterLink *link, int status, int64_t pts);
     239             : 
     240             : /**
     241             :  * Set the status field of a link from the destination filter.
     242             :  * The pts should probably be left unset (AV_NOPTS_VALUE).
     243             :  */
     244             : void ff_avfilter_link_set_out_status(AVFilterLink *link, int status, int64_t pts);
     245             : 
     246             : void ff_command_queue_pop(AVFilterContext *filter);
     247             : 
     248             : /* misc trace functions */
     249             : 
     250             : #define FF_TPRINTF_START(ctx, func) ff_tlog(NULL, "%-16s: ", #func)
     251             : 
     252             : char *ff_get_ref_perms_string(char *buf, size_t buf_size, int perms);
     253             : 
     254             : void ff_tlog_ref(void *ctx, AVFrame *ref, int end);
     255             : 
     256             : void ff_tlog_link(void *ctx, AVFilterLink *link, int end);
     257             : 
     258             : /**
     259             :  * Insert a new pad.
     260             :  *
     261             :  * @param idx Insertion point. Pad is inserted at the end if this point
     262             :  *            is beyond the end of the list of pads.
     263             :  * @param count Pointer to the number of pads in the list
     264             :  * @param padidx_off Offset within an AVFilterLink structure to the element
     265             :  *                   to increment when inserting a new pad causes link
     266             :  *                   numbering to change
     267             :  * @param pads Pointer to the pointer to the beginning of the list of pads
     268             :  * @param links Pointer to the pointer to the beginning of the list of links
     269             :  * @param newpad The new pad to add. A copy is made when adding.
     270             :  * @return >= 0 in case of success, a negative AVERROR code on error
     271             :  */
     272             : int ff_insert_pad(unsigned idx, unsigned *count, size_t padidx_off,
     273             :                    AVFilterPad **pads, AVFilterLink ***links,
     274             :                    AVFilterPad *newpad);
     275             : 
     276             : /** Insert a new input pad for the filter. */
     277          52 : static inline int ff_insert_inpad(AVFilterContext *f, unsigned index,
     278             :                                    AVFilterPad *p)
     279             : {
     280          52 :     return ff_insert_pad(index, &f->nb_inputs, offsetof(AVFilterLink, dstpad),
     281             :                   &f->input_pads, &f->inputs, p);
     282             : }
     283             : 
     284             : /** Insert a new output pad for the filter. */
     285          87 : static inline int ff_insert_outpad(AVFilterContext *f, unsigned index,
     286             :                                     AVFilterPad *p)
     287             : {
     288          87 :     return ff_insert_pad(index, &f->nb_outputs, offsetof(AVFilterLink, srcpad),
     289             :                   &f->output_pads, &f->outputs, p);
     290             : }
     291             : 
     292             : /**
     293             :  * Poll a frame from the filter chain.
     294             :  *
     295             :  * @param  link the input link
     296             :  * @return the number of immediately available frames, a negative
     297             :  * number in case of error
     298             :  */
     299             : int ff_poll_frame(AVFilterLink *link);
     300             : 
     301             : /**
     302             :  * Request an input frame from the filter at the other end of the link.
     303             :  *
     304             :  * This function must not be used by filters using the activate callback,
     305             :  * use ff_link_set_frame_wanted() instead.
     306             :  *
     307             :  * The input filter may pass the request on to its inputs, fulfill the
     308             :  * request from an internal buffer or any other means specific to its function.
     309             :  *
     310             :  * When the end of a stream is reached AVERROR_EOF is returned and no further
     311             :  * frames are returned after that.
     312             :  *
     313             :  * When a filter is unable to output a frame for example due to its sources
     314             :  * being unable to do so or because it depends on external means pushing data
     315             :  * into it then AVERROR(EAGAIN) is returned.
     316             :  * It is important that a AVERROR(EAGAIN) return is returned all the way to the
     317             :  * caller (generally eventually a user application) as this step may (but does
     318             :  * not have to be) necessary to provide the input with the next frame.
     319             :  *
     320             :  * If a request is successful then some progress has been made towards
     321             :  * providing a frame on the link (through ff_filter_frame()). A filter that
     322             :  * needs several frames to produce one is allowed to return success if one
     323             :  * more frame has been processed but no output has been produced yet. A
     324             :  * filter is also allowed to simply forward a success return value.
     325             :  *
     326             :  * @param link the input link
     327             :  * @return     zero on success
     328             :  *             AVERROR_EOF on end of file
     329             :  *             AVERROR(EAGAIN) if the previous filter cannot output a frame
     330             :  *             currently and can neither guarantee that EOF has been reached.
     331             :  */
     332             : int ff_request_frame(AVFilterLink *link);
     333             : 
     334             : #define AVFILTER_DEFINE_CLASS(fname)            \
     335             :     static const AVClass fname##_class = {      \
     336             :         .class_name = #fname,                   \
     337             :         .item_name  = av_default_item_name,     \
     338             :         .option     = fname##_options,          \
     339             :         .version    = LIBAVUTIL_VERSION_INT,    \
     340             :         .category   = AV_CLASS_CATEGORY_FILTER, \
     341             :     }
     342             : 
     343             : /**
     344             :  * Find the index of a link.
     345             :  *
     346             :  * I.e. find i such that link == ctx->(in|out)puts[i]
     347             :  */
     348             : #define FF_INLINK_IDX(link)  ((int)((link)->dstpad - (link)->dst->input_pads))
     349             : #define FF_OUTLINK_IDX(link) ((int)((link)->srcpad - (link)->src->output_pads))
     350             : 
     351             : /**
     352             :  * Send a frame of data to the next filter.
     353             :  *
     354             :  * @param link   the output link over which the data is being sent
     355             :  * @param frame a reference to the buffer of data being sent. The
     356             :  *              receiving filter will free this reference when it no longer
     357             :  *              needs it or pass it on to the next filter.
     358             :  *
     359             :  * @return >= 0 on success, a negative AVERROR on error. The receiving filter
     360             :  * is responsible for unreferencing frame in case of error.
     361             :  */
     362             : int ff_filter_frame(AVFilterLink *link, AVFrame *frame);
     363             : 
     364             : /**
     365             :  * Allocate a new filter context and return it.
     366             :  *
     367             :  * @param filter what filter to create an instance of
     368             :  * @param inst_name name to give to the new filter context
     369             :  *
     370             :  * @return newly created filter context or NULL on failure
     371             :  */
     372             : AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name);
     373             : 
     374             : int ff_filter_activate(AVFilterContext *filter);
     375             : 
     376             : /**
     377             :  * Remove a filter from a graph;
     378             :  */
     379             : void ff_filter_graph_remove_filter(AVFilterGraph *graph, AVFilterContext *filter);
     380             : 
     381             : /**
     382             :  * The filter is aware of hardware frames, and any hardware frame context
     383             :  * should not be automatically propagated through it.
     384             :  */
     385             : #define FF_FILTER_FLAG_HWFRAME_AWARE (1 << 0)
     386             : 
     387             : /**
     388             :  * Run one round of processing on a filter graph.
     389             :  */
     390             : int ff_filter_graph_run_once(AVFilterGraph *graph);
     391             : 
     392             : /**
     393             :  * Normalize the qscale factor
     394             :  * FIXME the H264 qscale is a log based scale, mpeg1/2 is not, the code below
     395             :  *       cannot be optimal
     396             :  */
     397           0 : static inline int ff_norm_qscale(int qscale, int type)
     398             : {
     399           0 :     switch (type) {
     400           0 :     case FF_QSCALE_TYPE_MPEG1: return qscale;
     401           0 :     case FF_QSCALE_TYPE_MPEG2: return qscale >> 1;
     402           0 :     case FF_QSCALE_TYPE_H264:  return qscale >> 2;
     403           0 :     case FF_QSCALE_TYPE_VP56:  return (63 - qscale + 2) >> 2;
     404             :     }
     405           0 :     return qscale;
     406             : }
     407             : 
     408             : /**
     409             :  * Get number of threads for current filter instance.
     410             :  * This number is always same or less than graph->nb_threads.
     411             :  */
     412             : int ff_filter_get_nb_threads(AVFilterContext *ctx);
     413             : 
     414             : #endif /* AVFILTER_INTERNAL_H */

Generated by: LCOV version 1.13