Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

lavfi: remove disabled FF_API_FILTERS_PUBLIC cruft

Browse Source
pull/59/head
Anton Khirnov 13 years ago
parent 5e88b96f37
commit 1961e46c15
6 changed files with 0 additions and 245 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 35
      libavfilter/avfilter.c
  2. 114
      libavfilter/avfilter.h
  3. 40
      libavfilter/formats.c
  4. 2
      libavfilter/formats.h
  5. 3
      libavfilter/version.h
  6. 51
      libavfilter/video.c

35
libavfilter/avfilter.c
Unescape View File

@ -442,38 +442,3 @@ enum AVMediaType avfilter_pad_get_type(AVFilterPad *pads, int pad_idx)
{
return pads[pad_idx].type;
}
#if FF_API_FILTERS_PUBLIC
void avfilter_insert_pad(unsigned idx, unsigned *count, size_t padidx_off,
AVFilterPad **pads, AVFilterLink ***links,
AVFilterPad *newpad)
{
ff_insert_pad(idx, count, padidx_off, pads, links, newpad);
}
void avfilter_insert_inpad(AVFilterContext *f, unsigned index,
AVFilterPad *p)
{
ff_insert_pad(index, &f->nb_inputs, offsetof(AVFilterLink, dstpad),
&f->input_pads, &f->inputs, p);
#if FF_API_FOO_COUNT
f->input_count = f->nb_inputs;
#endif
}
void avfilter_insert_outpad(AVFilterContext *f, unsigned index,
AVFilterPad *p)
{
ff_insert_pad(index, &f->nb_outputs, offsetof(AVFilterLink, srcpad),
&f->output_pads, &f->outputs, p);
#if FF_API_FOO_COUNT
f->output_count = f->nb_outputs;
#endif
}
int avfilter_poll_frame(AVFilterLink *link)
{
return ff_poll_frame(link);
}
int avfilter_request_frame(AVFilterLink *link)
{
return ff_request_frame(link);
}
#endif

114
libavfilter/avfilter.h
Unescape View File

@ -198,43 +198,6 @@ AVFilterBufferRef *avfilter_ref_buffer(AVFilterBufferRef *ref, int pmask);
*/
void avfilter_unref_buffer(AVFilterBufferRef *ref);
#if FF_API_FILTERS_PUBLIC
/**
* @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
};
attribute_deprecated
AVFilterFormats *avfilter_make_format_list(const int *fmts);
attribute_deprecated
int avfilter_add_format(AVFilterFormats **avff, int fmt);
attribute_deprecated
AVFilterFormats *avfilter_all_formats(enum AVMediaType type);
attribute_deprecated
AVFilterFormats *avfilter_merge_formats(AVFilterFormats *a, AVFilterFormats *b);
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);
attribute_deprecated
void avfilter_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats);
/**
* @}
*/
#endif
#if FF_API_AVFILTERPAD_PUBLIC
/**
* A filter pad used for either input or output.
@ -396,48 +359,6 @@ const char *avfilter_pad_get_name(AVFilterPad *pads, int pad_idx);
*/
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 end_frame() for video inputs */
attribute_deprecated
void avfilter_default_end_frame(AVFilterLink *link);
/** 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
/**
* Filter definition. This defines the pads a filter contains, and all the
* callback functions used to interact with the filter.
@ -614,12 +535,6 @@ int avfilter_link(AVFilterContext *src, unsigned srcpad,
*/
int avfilter_config_links(AVFilterContext *filter);
#if FF_API_FILTERS_PUBLIC
attribute_deprecated
AVFilterBufferRef *avfilter_get_video_buffer(AVFilterLink *link, int perms,
int w, int h);
#endif
/**
* Create a buffer reference wrapped around an already allocated image
* buffer.
@ -653,21 +568,6 @@ AVFilterBufferRef *avfilter_get_audio_buffer_ref_from_arrays(uint8_t **data,
enum AVSampleFormat sample_fmt,
uint64_t channel_layout);
#if FF_API_FILTERS_PUBLIC
attribute_deprecated
int avfilter_request_frame(AVFilterLink *link);
attribute_deprecated
int avfilter_poll_frame(AVFilterLink *link);
attribute_deprecated
void avfilter_start_frame(AVFilterLink *link, AVFilterBufferRef *picref);
attribute_deprecated
void avfilter_end_frame(AVFilterLink *link);
attribute_deprecated
void avfilter_draw_slice(AVFilterLink *link, int y, int h, int slice_dir);
#endif
/** Initialize the filter system. Register all builtin filters. */
void avfilter_register_all(void);
@ -745,20 +645,6 @@ void avfilter_free(AVFilterContext *filter);
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);
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 of src to dst, without copying the actual
* image data.

40
libavfilter/formats.c
Unescape View File

@ -389,43 +389,3 @@ int ff_default_query_formats(AVFilterContext *ctx)
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, int 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

2
libavfilter/formats.h
Unescape View File

@ -61,7 +61,6 @@
* get updated as well. Therefore, we have the format list structure store a
* pointer to each of the pointers to itself.
*/
#if !FF_API_FILTERS_PUBLIC
struct AVFilterFormats {
unsigned format_count; ///< number of formats
int *formats; ///< list of media formats
@ -69,7 +68,6 @@ struct AVFilterFormats {
unsigned refcount; ///< number of references to this list
struct AVFilterFormats ***refs; ///< references to this list
};
#endif
typedef struct AVFilterChannelLayouts {
uint64_t *channel_layouts; ///< list of channel layouts

3
libavfilter/version.h
Unescape View File

@ -44,9 +44,6 @@
* Those FF_API_* defines are not part of public API.
* They may change, break or disappear at any time.
*/
#ifndef FF_API_FILTERS_PUBLIC
#define FF_API_FILTERS_PUBLIC (LIBAVFILTER_VERSION_MAJOR < 3)
#endif
#ifndef FF_API_AVFILTERPAD_PUBLIC
#define FF_API_AVFILTERPAD_PUBLIC (LIBAVFILTER_VERSION_MAJOR < 4)
#endif

51
libavfilter/video.c
Unescape View File

@ -308,54 +308,3 @@ void ff_draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
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_end_frame(AVFilterLink *inlink)
{
default_end_frame(inlink);
}
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

Write Preview
Loading…
Cancel
Save