Merge commit '1961e46c15c23a041f8d8614a25388a3ee9eff63'
authorMichael Niedermayer <michaelni@gmx.at>
Tue, 26 Jun 2012 22:34:36 +0000 (00:34 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Tue, 26 Jun 2012 22:34:36 +0000 (00:34 +0200)
* commit '1961e46c15c23a041f8d8614a25388a3ee9eff63':
  lavfi: remove disabled FF_API_FILTERS_PUBLIC cruft
  lavfi: remove disabled FF_API_DEFAULT_CONFIG_OUTPUT_LINK cruft
  lavfi: use proper FF_API guards for different deprecated functions
  lavfi: remove disabled FF_API_VSRC_BUFFER_ADD_FRAME cruft
  lavfi: remove disabled FF_API_SAMPLERATE64 cruft
  lavfi: remove disabled FF_API_GRAPH_AVCLASS cruft

Conflicts:
libavfilter/avfilter.c
libavfilter/avfilter.h
libavfilter/buffersrc.c
libavfilter/formats.c
libavfilter/graphparser.c
libavfilter/version.h
libavfilter/video.c
libavfilter/vsrc_buffer.h

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavfilter/Makefile
libavfilter/avfilter.c
libavfilter/avfilter.h
libavfilter/avfiltergraph.c
libavfilter/avfiltergraph.h
libavfilter/buffersrc.c
libavfilter/formats.c
libavfilter/formats.h
libavfilter/graphparser.c
libavfilter/version.h
libavfilter/video.c

Simple merge
Simple merge
@@@ -199,153 -198,6 +199,16 @@@ AVFilterBufferRef *avfilter_ref_buffer(
   */
  void avfilter_unref_buffer(AVFilterBufferRef *ref);
  
- #if FF_API_FILTERS_PUBLIC
- /**
-  * A list of supported formats for one end of a filter link. This is used
-  * during the format negotiation process to try to pick the best format to
-  * use to minimize the number of necessary conversions. Each filter gives a
-  * list of the formats supported by each input and output pad. The list
-  * given for each pad need not be distinct - they may be references to the
-  * same list of formats, as is often the case when a filter supports multiple
-  * formats, but will always output the same format as it is given in input.
-  *
-  * In this way, a list of possible input formats and a list of possible
-  * output formats are associated with each link. When a set of formats is
-  * negotiated over a link, the input and output lists are merged to form a
-  * new list containing only the common elements of each list. In the case
-  * that there were no common elements, a format conversion is necessary.
-  * Otherwise, the lists are merged, and all other links which reference
-  * either of the format lists involved in the merge are also affected.
-  *
-  * For example, consider the filter chain:
-  * filter (a) --> (b) filter (b) --> (c) filter
-  *
-  * where the letters in parenthesis indicate a list of formats supported on
-  * the input or output of the link. Suppose the lists are as follows:
-  * (a) = {A, B}
-  * (b) = {A, B, C}
-  * (c) = {B, C}
-  *
-  * First, the first link's lists are merged, yielding:
-  * filter (a) --> (a) filter (a) --> (c) filter
-  *
-  * Notice that format list (b) now refers to the same list as filter list (a).
-  * Next, the lists for the second link are merged, yielding:
-  * filter (a) --> (a) filter (a) --> (a) filter
-  *
-  * where (a) = {B}.
-  *
-  * Unfortunately, when the format lists at the two ends of a link are merged,
-  * we must ensure that all links which reference either pre-merge format list
-  * get updated as well. Therefore, we have the format list structure store a
-  * pointer to each of the pointers to itself.
-  * @addtogroup lavfi_deprecated
-  * @deprecated Those functions are only useful inside filters and
-  * user filters are not supported at this point.
-  * @{
-  */
- struct AVFilterFormats {
-     unsigned format_count;      ///< number of formats
-     int *formats;               ///< list of media formats
-     unsigned refcount;          ///< number of references to this list
-     struct AVFilterFormats ***refs; ///< references to this list
- };
- /**
-  * Create a list of supported formats. This is intended for use in
-  * AVFilter->query_formats().
-  *
-  * @param fmts list of media formats, terminated by -1. If NULL an
-  *        empty list is created.
-  * @return the format list, with no existing references
-  */
- attribute_deprecated
- AVFilterFormats *avfilter_make_format_list(const int *fmts);
- /**
-  * Add fmt to the list of media formats contained in *avff.
-  * If *avff is NULL the function allocates the filter formats struct
-  * and puts its pointer in *avff.
-  *
-  * @return a non negative value in case of success, or a negative
-  * value corresponding to an AVERROR code in case of error
-  * @deprecated Use ff_all_formats() instead.
-  */
- attribute_deprecated
- int avfilter_add_format(AVFilterFormats **avff, int64_t fmt);
- attribute_deprecated
- AVFilterFormats *avfilter_all_formats(enum AVMediaType type);
- /**
-  * Return a list of all formats supported by FFmpeg for the given media type.
-  */
- AVFilterFormats *avfilter_make_all_formats(enum AVMediaType type);
- /**
-  * A list of all channel layouts supported by libavfilter.
-  */
- extern const int64_t avfilter_all_channel_layouts[];
- /**
-  * Return a format list which contains the intersection of the formats of
-  * a and b. Also, all the references of a, all the references of b, and
-  * a and b themselves will be deallocated.
-  *
-  * If a and b do not share any common formats, neither is modified, and NULL
-  * is returned.
-  */
- attribute_deprecated
- AVFilterFormats *avfilter_merge_formats(AVFilterFormats *a, AVFilterFormats *b);
- /**
-  * Add *ref as a new reference to formats.
-  * That is the pointers will point like in the ASCII art below:
-  *   ________
-  *  |formats |<--------.
-  *  |  ____  |     ____|___________________
-  *  | |refs| |    |  __|_
-  *  | |* * | |    | |  | |  AVFilterLink
-  *  | |* *--------->|*ref|
-  *  | |____| |    | |____|
-  *  |________|    |________________________
-  */
- attribute_deprecated
- void avfilter_formats_ref(AVFilterFormats *formats, AVFilterFormats **ref);
- attribute_deprecated
- void avfilter_formats_unref(AVFilterFormats **ref);
- attribute_deprecated
- void avfilter_formats_changeref(AVFilterFormats **oldref,
-                                 AVFilterFormats **newref);
- /**
-  * Helpers for query_formats() which set all links to the same list of
-  * formats/layouts. If there are no links hooked to this filter, the list
-  * of formats is freed.
-  */
- attribute_deprecated
- void avfilter_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats);
- attribute_deprecated
- void avfilter_set_common_pixel_formats(AVFilterContext *ctx, AVFilterFormats *formats);
- attribute_deprecated
- void avfilter_set_common_sample_formats(AVFilterContext *ctx, AVFilterFormats *formats);
- attribute_deprecated
- void avfilter_set_common_channel_layouts(AVFilterContext *ctx, AVFilterFormats *formats);
- /**
-  * @}
-  */
- #endif
 +/**
 + * Remove a reference to a buffer and set the pointer to NULL.
 + * If this is the last reference to the buffer, the buffer itself
 + * is also automatically freed.
 + *
 + * @param ref pointer to the buffer reference
 + */
 +void avfilter_unref_bufferp(AVFilterBufferRef **ref);
 +
 +
  #if FF_API_AVFILTERPAD_PUBLIC
  /**
   * A filter pad used for either input or output.
@@@ -514,48 -359,6 +377,10 @@@ const char *avfilter_pad_get_name(AVFil
   */
  enum AVMediaType avfilter_pad_get_type(AVFilterPad *pads, int pad_idx);
  
- #if FF_API_FILTERS_PUBLIC
- /** default handler for start_frame() for video inputs */
- attribute_deprecated
- void avfilter_default_start_frame(AVFilterLink *link, AVFilterBufferRef *picref);
- /** default handler for draw_slice() for video inputs */
- attribute_deprecated
- void avfilter_default_draw_slice(AVFilterLink *link, int y, int h, int slice_dir);
- /** default handler for get_video_buffer() for video inputs */
- attribute_deprecated
- AVFilterBufferRef *avfilter_default_get_video_buffer(AVFilterLink *link,
-                                                      int perms, int w, int h);
- /** Default handler for query_formats() */
- attribute_deprecated
- int avfilter_default_query_formats(AVFilterContext *ctx);
- #endif
- #if FF_API_FILTERS_PUBLIC
- /** start_frame() handler for filters which simply pass video along */
- attribute_deprecated
- void avfilter_null_start_frame(AVFilterLink *link, AVFilterBufferRef *picref);
- /** draw_slice() handler for filters which simply pass video along */
- attribute_deprecated
- void avfilter_null_draw_slice(AVFilterLink *link, int y, int h, int slice_dir);
- /** end_frame() handler for filters which simply pass video along */
- attribute_deprecated
- void avfilter_null_end_frame(AVFilterLink *link);
- /** get_video_buffer() handler for filters which simply pass video along */
- attribute_deprecated
- AVFilterBufferRef *avfilter_null_get_video_buffer(AVFilterLink *link,
-                                                   int perms, int w, int h);
- #endif
 +/** default handler for end_frame() for video inputs */
 +attribute_deprecated
 +void avfilter_default_end_frame(AVFilterLink *link);
 +
  /**
   * Filter definition. This defines the pads a filter contains, and all the
   * callback functions used to interact with the filter.
@@@ -667,13 -454,10 +492,10 @@@ struct AVFilterLink 
      int w;                      ///< agreed upon image width
      int h;                      ///< agreed upon image height
      AVRational sample_aspect_ratio; ///< agreed upon sample aspect ratio
 -    /* These two parameters apply only to audio */
 +    /* These parameters apply only to audio */
      uint64_t channel_layout;    ///< channel layout of current buffer (see libavutil/audioconvert.h)
- #if FF_API_SAMPLERATE64
-     int64_t sample_rate;        ///< samples per second
- #else
      int sample_rate;            ///< samples per second
- #endif
      int format;                 ///< agreed upon media format
  
      /**
@@@ -827,44 -568,6 +643,16 @@@ AVFilterBufferRef *avfilter_get_audio_b
                                                               enum AVSampleFormat sample_fmt,
                                                               uint64_t channel_layout);
  
- #if FF_API_FILTERS_PUBLIC
- /**
-  * Request an input frame from the filter at the other end of the link.
-  *
-  * @param link the input link
-  * @return     zero on success or a negative error code; in particular:
-  *             AVERROR_EOF means that the end of frames have been reached;
-  *             AVERROR(EAGAIN) means that no frame could be immediately
-  *             produced.
-  */
- int avfilter_request_frame(AVFilterLink *link);
- attribute_deprecated
- int avfilter_poll_frame(AVFilterLink *link);
- attribute_deprecated
- void avfilter_start_frame(AVFilterLink *link, AVFilterBufferRef *picref);
- /**
-  * Notify the next filter that the current frame has finished.
-  *
-  * @param link the output link the frame was sent over
-  */
- attribute_deprecated
- void avfilter_end_frame(AVFilterLink *link);
- attribute_deprecated
- void avfilter_draw_slice(AVFilterLink *link, int y, int h, int slice_dir);
- #endif
 +
 +#define AVFILTER_CMD_FLAG_ONE   1 ///< Stop once a filter understood the command (for target=all for example), fast filters are favored automatically
 +#define AVFILTER_CMD_FLAG_FAST  2 ///< Only execute command when its fast (like a video out that supports contrast adjustment in hw)
 +
 +/**
 + * Make the filter instance process a command.
 + * It is recommended to use avfilter_graph_send_command().
 + */
 +int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags);
 +
  /** Initialize the filter system. Register all builtin filters. */
  void avfilter_register_all(void);
  
@@@ -942,18 -645,20 +730,4 @@@ void avfilter_free(AVFilterContext *fil
  int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt,
                             unsigned filt_srcpad_idx, unsigned filt_dstpad_idx);
  
- #if FF_API_FILTERS_PUBLIC
- attribute_deprecated
- void avfilter_insert_pad(unsigned idx, unsigned *count, size_t padidx_off,
-                          AVFilterPad **pads, AVFilterLink ***links,
-                          AVFilterPad *newpad);
 -/**
 - * Copy the frame properties of src to dst, without copying the actual
 - * image data.
 - *
 - * @return 0 on success, a negative number on error.
 - */
 -int avfilter_copy_frame_props(AVFilterBufferRef *dst, const AVFrame *src);
--
- attribute_deprecated
- void avfilter_insert_inpad(AVFilterContext *f, unsigned index,
-                            AVFilterPad *p);
- attribute_deprecated
- void avfilter_insert_outpad(AVFilterContext *f, unsigned index,
-                             AVFilterPad *p);
- #endif
 -/**
 - * Copy the frame properties and data pointers of src to dst, without copying
 - * the actual data.
 - *
 - * @return 0 on success, a negative number on error.
 - */
 -int avfilter_copy_buf_props(AVFrame *dst, const AVFilterBufferRef *src);
--
  #endif /* AVFILTER_AVFILTER_H */
Simple merge
Simple merge
@@@ -29,8 -29,6 +29,7 @@@
  #include "formats.h"
  #include "internal.h"
  #include "video.h"
- #include "vsrc_buffer.h"
 +#include "avcodec.h"
  
  #include "libavutil/audioconvert.h"
  #include "libavutil/fifo.h"
@@@ -454,131 -389,3 +454,93 @@@ int ff_default_query_formats(AVFilterCo
  
      return 0;
  }
- #if FF_API_FILTERS_PUBLIC
- int avfilter_default_query_formats(AVFilterContext *ctx)
- {
-     return ff_default_query_formats(ctx);
- }
- void avfilter_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
- {
-     ff_set_common_formats(ctx, formats);
- }
- AVFilterFormats *avfilter_make_format_list(const int *fmts)
- {
-     return ff_make_format_list(fmts);
- }
- int avfilter_add_format(AVFilterFormats **avff, int64_t fmt)
- {
-     return ff_add_format(avff, fmt);
- }
- AVFilterFormats *avfilter_all_formats(enum AVMediaType type)
- {
-     return ff_all_formats(type);
- }
- AVFilterFormats *avfilter_merge_formats(AVFilterFormats *a, AVFilterFormats *b)
- {
-     return ff_merge_formats(a, b);
- }
- void avfilter_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
- {
-     ff_formats_ref(f, ref);
- }
- void avfilter_formats_unref(AVFilterFormats **ref)
- {
-     ff_formats_unref(ref);
- }
- void avfilter_formats_changeref(AVFilterFormats **oldref,
-                                 AVFilterFormats **newref)
- {
-     ff_formats_changeref(oldref, newref);
- }
- #endif
 +
 +/* internal functions for parsing audio format arguments */
 +
 +int ff_parse_pixel_format(enum PixelFormat *ret, const char *arg, void *log_ctx)
 +{
 +    char *tail;
 +    int pix_fmt = av_get_pix_fmt(arg);
 +    if (pix_fmt == PIX_FMT_NONE) {
 +        pix_fmt = strtol(arg, &tail, 0);
 +        if (*tail || (unsigned)pix_fmt >= PIX_FMT_NB) {
 +            av_log(log_ctx, AV_LOG_ERROR, "Invalid pixel format '%s'\n", arg);
 +            return AVERROR(EINVAL);
 +        }
 +    }
 +    *ret = pix_fmt;
 +    return 0;
 +}
 +
 +int ff_parse_sample_format(int *ret, const char *arg, void *log_ctx)
 +{
 +    char *tail;
 +    int sfmt = av_get_sample_fmt(arg);
 +    if (sfmt == AV_SAMPLE_FMT_NONE) {
 +        sfmt = strtol(arg, &tail, 0);
 +        if (*tail || (unsigned)sfmt >= AV_SAMPLE_FMT_NB) {
 +            av_log(log_ctx, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
 +            return AVERROR(EINVAL);
 +        }
 +    }
 +    *ret = sfmt;
 +    return 0;
 +}
 +
 +int ff_parse_time_base(AVRational *ret, const char *arg, void *log_ctx)
 +{
 +    AVRational r;
 +    if(av_parse_ratio(&r, arg, INT_MAX, 0, log_ctx) < 0 ||r.num<=0  ||r.den<=0) {
 +        av_log(log_ctx, AV_LOG_ERROR, "Invalid time base '%s'\n", arg);
 +        return AVERROR(EINVAL);
 +    }
 +    *ret = r;
 +    return 0;
 +}
 +
 +int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx)
 +{
 +    char *tail;
 +    double srate = av_strtod(arg, &tail);
 +    if (*tail || srate < 1 || (int)srate != srate || srate > INT_MAX) {
 +        av_log(log_ctx, AV_LOG_ERROR, "Invalid sample rate '%s'\n", arg);
 +        return AVERROR(EINVAL);
 +    }
 +    *ret = srate;
 +    return 0;
 +}
 +
 +int ff_parse_channel_layout(int64_t *ret, const char *arg, void *log_ctx)
 +{
 +    char *tail;
 +    int64_t chlayout = av_get_channel_layout(arg);
 +    if (chlayout == 0) {
 +        chlayout = strtol(arg, &tail, 10);
 +        if (*tail || chlayout == 0) {
 +            av_log(log_ctx, AV_LOG_ERROR, "Invalid channel layout '%s'\n", arg);
 +            return AVERROR(EINVAL);
 +        }
 +    }
 +    *ret = chlayout;
 +    return 0;
 +}
 +
 +#ifdef TEST
 +
 +#undef printf
 +
 +int main(void)
 +{
 +    const int64_t *cl;
 +    char buf[512];
 +
 +    for (cl = avfilter_all_channel_layouts; *cl != -1; cl++) {
 +        av_get_channel_layout_string(buf, sizeof(buf), -1, *cl);
 +        printf("%s\n", buf);
 +    }
 +
 +    return 0;
 +}
 +
 +#endif
++
Simple merge
@@@ -397,18 -391,19 +391,18 @@@ int avfilter_graph_parse2(AVFilterGrap
          AVFilterContext *filter;
          filters += strspn(filters, WHITESPACES);
  
-         if ((ret = parse_inputs(&filters, &curr_inputs, &open_outputs, log_ctx)) < 0)
+         if ((ret = parse_inputs(&filters, &curr_inputs, &open_outputs, graph)) < 0)
 -            goto fail;
 -
 +            goto end;
-         if ((ret = parse_filter(&filter, &filters, graph, index, log_ctx)) < 0)
+         if ((ret = parse_filter(&filter, &filters, graph, index, graph)) < 0)
 -            goto fail;
 +            goto end;
  
-         if ((ret = link_filter_inouts(filter, &curr_inputs, &open_inputs, log_ctx)) < 0)
+         if ((ret = link_filter_inouts(filter, &curr_inputs, &open_inputs, graph)) < 0)
 -            goto fail;
 +            goto end;
  
          if ((ret = parse_outputs(&filters, &curr_inputs, &open_inputs, &open_outputs,
-                                  log_ctx)) < 0)
+                                  graph)) < 0)
 -            goto fail;
 +            goto end;
  
          filters += strspn(filters, WHITESPACES);
          chr = *filters++;
  
      return ret;
  }
- #undef log_ctx
  
  int avfilter_graph_parse(AVFilterGraph *graph, const char *filters,
 -                         AVFilterInOut *open_inputs,
 -                         AVFilterInOut *open_outputs, void *log_ctx)
 +                         AVFilterInOut **open_inputs_ptr, AVFilterInOut **open_outputs_ptr,
 +                         void *log_ctx)
  {
 +#if 0
      int ret;
 +    AVFilterInOut *open_inputs  = open_inputs_ptr  ? *open_inputs_ptr  : NULL;
 +    AVFilterInOut *open_outputs = open_outputs_ptr ? *open_outputs_ptr : NULL;
      AVFilterInOut *cur, *match, *inputs = NULL, *outputs = NULL;
  
      if ((ret = avfilter_graph_parse2(graph, filters, &inputs, &outputs)) < 0)
   * Those FF_API_* defines are not part of public API.
   * They may change, break or disappear at any time.
   */
- #ifndef FF_API_GRAPH_AVCLASS
- #define FF_API_GRAPH_AVCLASS            (LIBAVFILTER_VERSION_MAJOR > 2)
- #endif
- #ifndef FF_API_SAMPLERATE64
- #define FF_API_SAMPLERATE64             (LIBAVFILTER_VERSION_MAJOR < 3)
- #endif
- #ifndef FF_API_VSRC_BUFFER_ADD_FRAME
- #define FF_API_VSRC_BUFFER_ADD_FRAME        (LIBAVFILTER_VERSION_MAJOR < 3)
- #endif
- #ifndef FF_API_DEFAULT_CONFIG_OUTPUT_LINK
- #define FF_API_DEFAULT_CONFIG_OUTPUT_LINK   (LIBAVFILTER_VERSION_MAJOR < 3)
- #endif
- #ifndef FF_API_FILTERS_PUBLIC
- #define FF_API_FILTERS_PUBLIC               (LIBAVFILTER_VERSION_MAJOR < 3)
- #endif
 +#ifndef FF_API_OLD_ALL_FORMATS_API
 +#define FF_API_OLD_ALL_FORMATS_API (LIBAVFILTER_VERSION_MAJOR < 3)
 +#endif
  #ifndef FF_API_AVFILTERPAD_PUBLIC
  #define FF_API_AVFILTERPAD_PUBLIC           (LIBAVFILTER_VERSION_MAJOR < 4)
  #endif
@@@ -320,55 -308,3 +320,9 @@@ void ff_draw_slice(AVFilterLink *link, 
          draw_slice = default_draw_slice;
      draw_slice(link, y, h, slice_dir);
  }
- #if FF_API_FILTERS_PUBLIC
- AVFilterBufferRef *avfilter_default_get_video_buffer(AVFilterLink *link, int perms, int w, int h)
- {
-     return ff_default_get_video_buffer(link, perms, w, h);
- }
- void avfilter_default_start_frame(AVFilterLink *inlink, AVFilterBufferRef *picref)
- {
-     default_start_frame(inlink, picref);
- }
- void avfilter_default_draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir)
- {
-     default_draw_slice(inlink, y, h, slice_dir);
- }
- AVFilterBufferRef *avfilter_null_get_video_buffer(AVFilterLink *link, int perms, int w, int h)
- {
-     return ff_null_get_video_buffer(link, perms, w, h);
- }
- void avfilter_null_start_frame(AVFilterLink *link, AVFilterBufferRef *picref)
- {
-     ff_null_start_frame(link, picref);
- }
- void avfilter_null_end_frame(AVFilterLink *link)
- {
-     ff_null_end_frame(link);
- }
- void avfilter_null_draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
- {
-     ff_null_draw_slice(link, y, h, slice_dir);
- }
- void avfilter_start_frame(AVFilterLink *link, AVFilterBufferRef *picref)
- {
-     ff_start_frame(link, picref);
- }
- void avfilter_end_frame(AVFilterLink *link)
- {
-     ff_end_frame(link);
- }
- void avfilter_draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
- {
-     ff_draw_slice(link, y, h, slice_dir);
- }
- AVFilterBufferRef *avfilter_get_video_buffer(AVFilterLink *link, int perms, int w, int h)
- {
-     return ff_get_video_buffer(link, perms, w, h);
- }
- #endif
 +
 +void avfilter_default_end_frame(AVFilterLink *inlink)
 +{
 +    default_end_frame(inlink);
 +}
 +