From 25fabe41b99abceb9c95d847c8cb36a03e2067f1 Mon Sep 17 00:00:00 2001 From: meh Date: Fri, 15 May 2015 18:51:33 +0200 Subject: [PATCH] avfilter: add bindings --- sys/Cargo.toml | 3 +- sys/src/avfilter/buffersink.rs | 33 ++++ sys/src/avfilter/buffersrc.rs | 17 +++ sys/src/avfilter/filter.rs | 271 +++++++++++++++++++++++++++++++++ sys/src/avfilter/mod.rs | 8 + sys/src/lib.rs | 5 + 6 files changed, 336 insertions(+), 1 deletion(-) create mode 100644 sys/src/avfilter/buffersink.rs create mode 100644 sys/src/avfilter/buffersrc.rs create mode 100644 sys/src/avfilter/filter.rs create mode 100644 sys/src/avfilter/mod.rs diff --git a/sys/Cargo.toml b/sys/Cargo.toml index 2ea7d27..bff6918 100644 --- a/sys/Cargo.toml +++ b/sys/Cargo.toml @@ -9,10 +9,11 @@ description = "FFI bindings to FFmpeg" repository = "https://github.com/meh/rust-ffmpeg-sys" [features] -default = ["avcodec", "avdevice", "avformat", "postproc", "swscale"] +default = ["avcodec", "avdevice", "avfilter", "avformat", "postproc", "swscale"] avcodec = [] avdevice = ["avformat"] +avfilter = [] avformat = ["avcodec"] postproc = [] swscale = [] diff --git a/sys/src/avfilter/buffersink.rs b/sys/src/avfilter/buffersink.rs new file mode 100644 index 0000000..034685b --- /dev/null +++ b/sys/src/avfilter/buffersink.rs @@ -0,0 +1,33 @@ +use libc::{c_int, c_uint, int64_t}; +use ::avfilter::filter::AVFilterContext; +use ::avutil::{AVFrame, AVPixelFormat, AVSampleFormat, AVRational}; + +pub const AV_BUFFERSINK_FLAG_PEEK: c_int = 1; +pub const AV_BUFFERSINK_FLAG_NO_REQUEST: c_int = 2; + +#[repr(C)] +pub struct AVBufferSinkParams { + pub pixel_fmts: *const AVPixelFormat, +} + +#[repr(C)] +pub struct AVABufferSinkParams { + pub sample_fmts: *const AVSampleFormat, + pub channel_layouts: *const int64_t, + pub channel_counts: *const c_int, + pub all_channel_counts: c_int, + pub sample_rates: *mut c_int, +} + +#[link(name = "avfilter")] +extern { + pub fn av_buffersink_get_frame_flags(ctx: *mut AVFilterContext, frame: *mut AVFrame, flags: c_int) -> c_int; + + pub fn av_buffersink_params_alloc() -> *mut AVBufferSinkParams; + pub fn av_abuffersink_params_alloc() -> *mut AVABufferSinkParams; + + pub fn av_buffersink_set_frame_size(ctx: *mut AVFilterContext, frame_size: c_uint); + pub fn av_buffersink_get_frame_rate(ctx: *mut AVFilterContext) -> AVRational; + pub fn av_buffersink_get_frame(ctx: *mut AVFilterContext, frame: *mut AVFrame) -> c_int; + pub fn av_buffersink_get_samples(ctx: *mut AVFilterContext, frame: *mut AVFrame, nb_samples: c_int) -> c_int; +} diff --git a/sys/src/avfilter/buffersrc.rs b/sys/src/avfilter/buffersrc.rs new file mode 100644 index 0000000..3020c5f --- /dev/null +++ b/sys/src/avfilter/buffersrc.rs @@ -0,0 +1,17 @@ +use libc::{c_int, c_uint}; +use ::avfilter::filter::{AVFilterContext, AVFilterBufferRef}; +use ::avutil::AVFrame; + +pub const AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT: c_int = 1; +pub const AV_BUFFERSRC_FLAG_NO_COPY: c_int = 2; +pub const AV_BUFFERSRC_FLAG_PUSH: c_int = 4; +pub const AV_BUFFERSRC_FLAG_KEEP_REF: c_int = 8; + +#[link(name = "avfilter")] +extern { + pub fn av_buffersrc_add_ref(buffer_src: *mut AVFilterContext, picref: *mut AVFilterBufferRef, flags: c_int) -> c_int; + pub fn av_buffersrc_get_nb_failed_requests(buffer_src: *mut AVFilterContext) -> c_uint; + pub fn av_buffersrc_write_frame(ctx: *mut AVFilterContext, frame: *const AVFrame) -> c_int; + pub fn av_buffersrc_add_frame(ctx: *mut AVFilterContext, frame: *mut AVFrame) -> c_int; + pub fn av_buffersrc_add_frame_flags(buffer_src: *mut AVFilterContext, frame: *mut AVFrame, flags: c_int) -> c_int; +} diff --git a/sys/src/avfilter/filter.rs b/sys/src/avfilter/filter.rs new file mode 100644 index 0000000..9901b4d --- /dev/null +++ b/sys/src/avfilter/filter.rs @@ -0,0 +1,271 @@ +use libc::{c_void, c_char, c_int, c_uint, c_double, int8_t, uint8_t, int64_t, uint64_t}; +use ::avutil::{AVClass, AVRational, AVPictureType, AVMediaType, AVDictionary, AVFrame}; + +#[repr(C)] +pub struct AVFilterBuffer { + pub data: [*mut uint8_t; 8], + pub extended_data: *mut *mut uint8_t, + pub linesize: [c_int; 8], + pub private: *mut c_void, + pub free: extern fn(*mut AVFilterBuffer), + pub format: c_int, + pub w: c_int, + pub h: c_int, + pub refcount: c_uint, +} + +pub const AV_PERM_READ: c_int = 0x01; +pub const AV_PERM_WRITE: c_int = 0x02; +pub const AV_PERM_PRESERVE: c_int = 0x04; +pub const AV_PERM_REUSE: c_int = 0x08; +pub const AV_PERM_REUSE2: c_int = 0x10; +pub const AV_PERM_NEG_LINESIZES: c_int = 0x20; +pub const AV_PERM_ALIGN: c_int = 0x40; + +pub const AVFILTER_ALIGN: c_int = 16; + +#[repr(C)] +pub struct AVFilterBufferRefAudioProps { + pub channel_layout: uint64_t, + pub nb_samples: c_int, + pub sample_rate: c_int, + pub channels: c_int, +} + +#[repr(C)] +pub struct AVFilterBufferRefVideoProps { + pub w: c_int, + pub h: c_int, + pub sample_aspect_ratio: AVRational, + pub interlaced: c_int, + pub top_field_first: c_int, + pub pict_type: AVPictureType, + pub key_frame: c_int, + pub qp_table_linesize: c_int, + pub qp_table_size: c_int, + pub qp_table: *mut int8_t, +} + +#[repr(C)] +pub struct AVFilterBufferRef { + pub buf: *mut AVFilterBuffer, + pub data: [*mut uint8_t; 8], + pub extended_data: *mut *mut uint8_t, + pub linesize: [c_int; 8], + pub video: *mut AVFilterBufferRefVideoProps, + pub audio: *mut AVFilterBufferRefAudioProps, + pub pts: int64_t, + pub pos: int64_t, + pub format: c_int, + pub perms: c_int, + pub kind: AVMediaType, + pub metadata: *mut AVDictionary, +} + +#[repr(C)] +pub struct AVFilterPad { + pub name: *const c_char, + pub kind: AVMediaType, + pub min_perms: c_int, + pub rej_perms: c_int, + pub start_frame: extern fn(*mut AVFilterLink, *mut AVFilterBufferRef) -> c_int, + pub get_video_buffer: extern fn(*mut AVFilterLink, c_int, c_int) -> *mut AVFrame, + pub get_audio_buffer: extern fn(*mut AVFilterLink, c_int) -> *mut AVFrame, + pub end_frame: extern fn(*mut AVFilterLink) -> c_int, + pub draw_slice: extern fn(*mut AVFilterLink, c_int, c_int, c_int) -> c_int, + pub filter_frame: extern fn(*mut AVFilterLink, *mut AVFrame) -> c_int, + pub poll_frame: extern fn(*mut AVFilterLink) -> c_int, + pub request_frame: extern fn(*mut AVFilterLink) -> c_int, + pub config_props: extern fn(*mut AVFilterLink) -> c_int, + pub needs_fifo: c_int, + pub needs_writable: c_int, +} + +pub const AVFILTER_FLAG_DYNAMIC_INPUTS: c_int = 1 << 0; +pub const AVFILTER_FLAG_DYNAMIC_OUTPUTS: c_int = 1 << 1; +pub const AVFILTER_FLAG_SLICE_THREADS: c_int = 1 << 2; +pub const AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC: c_int = 1 << 16; +pub const AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL: c_int = 1 << 17; +pub const AVFILTER_FLAG_SUPPORT_TIMELINE: c_int = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL; + +#[repr(C)] +pub struct AVFilter { + pub name: *const c_char, + pub description: *const c_char, + pub inputs: *const AVFilterPad, + pub outputs: *const AVFilterPad, + pub priv_class: *const AVClass, + pub flags: c_int, + + pub init: extern fn(*mut AVFilterContext) -> c_int, + pub init_dict: extern fn(*mut AVFilterContext, *mut *mut AVDictionary) -> c_int, + pub uninit: extern fn(*mut AVFilterContext), + pub query_formats: extern fn(*mut AVFilterContext) -> c_int, + pub priv_size: c_int, + pub next: *mut AVFilter, + pub process_command: extern fn(*mut AVFilterContext, cmd: *const c_char, arg: *const c_char, *mut c_char, c_int, c_int) -> c_int, + pub init_opaque: extern fn(*mut AVFilterContext, *mut c_void) -> c_int, +} + +pub const AVFILTER_THREAD_SLICE: c_int = 1 << 0; + +pub type AVFilterInternal = c_void; + +#[repr(C)] +pub struct AVFilterContext { + pub av_class: *const AVClass, + pub filter: *const AVFilter, + pub name: *mut c_char, + pub input_pads: *mut AVFilterPad, + pub inputs: *mut *mut AVFilterLink, + pub input_count: c_uint, + pub nb_inputs: c_uint, + pub output_pads: *mut AVFilterPad, + pub outputs: *mut *mut AVFilterLink, + pub output_count: c_uint, + pub nb_outputs: c_uint, + pub private: *mut c_void, + pub graph: *mut AVFilterGraph, + pub thread_type: c_int, + pub internal: *mut AVFilterInternal, + pub command_queue: *mut AVFilterCommand, + pub enable_str: *mut c_char, + pub enable: *mut c_void, + pub var_values: *mut c_double, + pub is_disabled: c_int, +} + +pub const AVLINK_UNINIT: c_int = 0; +pub const AVLINK_STARTINIT: c_int = 1; +pub const AVLINK_INIT: c_int = 2; + +#[repr(C)] +pub struct AVFilterLink { + pub src: *mut AVFilterContext, + pub srcpad: *mut AVFilterPad, + pub dst: *mut AVFilterContext, + pub dstpad: *mut AVFilterPad, + pub kind: AVMediaType, + pub w: c_int, + pub h: c_int, + pub sample_aspect_ratio: AVRational, + pub channel_layout: uint64_t, + pub sample_rate: c_int, + pub format: c_int, + pub time_base: AVRational, + + pub in_formats: *mut AVFilterFormats, + pub out_formats: *mut AVFilterFormats, + pub in_channel_layouts: *mut AVFilterChannelLayouts, + pub out_channel_layouts: *mut AVFilterChannelLayouts, + pub request_samples: c_int, + pub pool: *mut AVFilterPool, + pub graph: *mut AVFilterGraph, + pub current_pts: int64_t, + pub age_index: c_int, + pub frame_rate: AVRational, + pub partial_buf: *mut AVFrame, + pub partial_buf_size: c_int, + pub min_samples: c_int, + pub max_samples: c_int, + pub cur_buf_copy: *mut AVFilterBufferRef, + pub closed: c_int, + pub channels: c_int, + pub frame_requested: c_uint, + pub flags: c_uint, + pub frame_count: int64_t, +} + +pub const AVFILTER_CMD_FLAG_ONE: c_int = 1; +pub const AVFILTER_CMD_FLAG_FAST: c_int = 2; + +pub type AVFilterGraphInternal = c_void; + +pub type avfilter_action_func = extern fn(*mut AVFilterContext, *mut c_void, c_int, c_int) -> c_int; +pub type avfilter_execute_func = extern fn(*mut AVFilterContext, avfilter_action_func, *mut c_void, *mut c_int, c_int) -> c_int; + +#[repr(C)] +pub struct AVFilterGraph { + pub av_class: *const AVClass, + pub filter_count_unused: c_uint, + pub filters: *mut *mut AVFilterContext, + pub scale_sws_opts: *mut c_char, + pub resample_lavr_opts: *mut c_char, + pub nb_filters: c_uint, + pub thread_type: c_int, + pub nb_threads: c_int, + pub internal: *mut AVFilterGraphInternal, + pub opaque: *mut c_void, + pub execute: avfilter_execute_func, + pub aresample_swr_opts: *mut c_char, + pub sink_links: *mut *mut AVFilterLink, + pub sink_links_count: c_int, + pub disable_auto_convert: c_uint, +} + +pub const AVFILTER_AUTO_CONVERT_ALL: c_int = 0; +pub const AVFILTER_AUTO_CONVERT_NONE: c_int = -1; + +pub type AVFilterCommand = c_void; +pub type AVFilterChannelLayouts = c_void; +pub type AVFilterPool = c_void; +pub type AVFilterFormats = c_void; + +#[repr(C)] +pub struct AVFilterInOut { + pub name: *mut c_char, + pub filter_ctx: *mut AVFilterContext, + pub pad_idx: c_int, + pub next: *mut AVFilterInOut, +} + +#[link(name = "avfilter")] +extern { + pub fn avfilter_version() -> c_uint; + pub fn avfilter_configuration() -> *const c_char; + pub fn avfilter_license() -> *const c_char; + + pub fn avfilter_pad_count(pads: *const AVFilterPad) -> c_int; + pub fn avfilter_pad_get_name(pads: *const AVFilterPad, pad_idx: c_int) -> *const c_char; + pub fn avfilter_pad_get_type(pads: *const AVFilterPad, pad_idx: c_int) -> AVMediaType; + + pub fn avfilter_link(src: *mut AVFilterContext, srcpad: c_uint, dst: *mut AVFilterContext, dstpad: c_uint) -> c_int; + pub fn avfilter_link_free(link: *mut *mut AVFilterLink); + pub fn avfilter_link_get_channels(link: *mut AVFilterLink) -> c_int; + pub fn avfilter_link_set_closed(link: *mut AVFilterLink, closed: c_int); + pub fn avfilter_config_links(filter: *mut AVFilterContext) -> c_int; + + pub fn avfilter_process_command(filter: *mut AVFilterContext, cmd: *const c_char, arg: *const c_char, res: *const c_char, res_len: c_int, flags: c_int) -> c_int; + + pub fn avfilter_register_all(); + pub fn avfilter_register(filter: *mut AVFilter) -> c_int; + + pub fn avfilter_get_by_name(name: *const c_char) -> *mut AVFilter; + pub fn avfilter_next(prev: *const AVFilter) -> *const AVFilter; + + pub fn avfilter_init_str(ctx: *mut AVFilterContext, args: *const c_char) -> c_int; + pub fn avfilter_init_dict(ctx: *mut AVFilterContext, options: *mut *mut AVDictionary) -> c_int; + pub fn avfilter_free(filter: *mut AVFilterContext); + pub fn avfilter_insert_filter(link: *mut AVFilterLink, filt: *mut AVFilterContext, filt_srcpad_idx: c_uint, filt_dstpad_idx: c_uint) -> c_int; + + pub fn avfilter_get_class() -> *const AVClass; + + pub fn avfilter_graph_alloc() -> *mut AVFilterGraph; + pub fn avfilter_graph_alloc_filter(graph: *mut AVFilterGraph, filter: *const AVFilter, name: *const c_char) -> *mut AVFilterContext; + pub fn avfilter_graph_get_filter(graph: *mut AVFilterGraph, name: *const c_char) -> *mut AVFilterContext; + pub fn avfilter_graph_create_filter(filt_ctx: *mut *mut AVFilterContext, filt: *const AVFilter, name: *const c_char, args: *const c_char, opaque: *mut c_void, graph_ctx: *mut AVFilterGraph) -> c_int; + pub fn avfilter_graph_set_auto_convert(graph: *mut AVFilterGraph, flags: c_uint); + pub fn avfilter_graph_config(graphctx: *mut AVFilterGraph, log_ctx: *mut c_void) -> c_int; + pub fn avfilter_graph_free(graph: *mut *mut AVFilterGraph); + + pub fn avfilter_inout_alloc() -> *mut AVFilterInOut; + pub fn avfilter_inout_free(inout: *mut *mut AVFilterInOut); + + pub fn avfilter_graph_parse(graph: *mut AVFilterGraph, filters: *const c_char, inputs: *mut AVFilterInOut, outputs: *mut AVFilterInOut, log_ctx: *mut c_void) -> c_int; + pub fn avfilter_graph_parse_ptr(graph: *mut AVFilterGraph, filters: *const c_char, inputs: *mut *mut AVFilterInOut, outputs: *mut *mut AVFilterInOut, log_ctx: *mut c_void) -> c_int; + pub fn avfilter_graph_parse2(graph: *mut AVFilterGraph, filters: *const c_char, inputs: *mut *mut AVFilterInOut, outputs: *mut *mut AVFilterInOut) -> c_int; + pub fn avfilter_graph_send_command(graph: *mut AVFilterGraph, target: *const c_char, cmd: *const c_char, arg: *const c_char, res: *mut c_char, res_len: c_int, flags: c_int) -> c_int; + pub fn avfilter_graph_queue_command(graph: *mut AVFilterGraph, target: *const c_char, cmd: *const c_char, arg: *const c_char, flags: c_int, ts: c_double) -> c_int; + pub fn avfilter_graph_dump(graph: *mut AVFilterGraph, options: *const c_char) -> *mut c_char; + pub fn avfilter_graph_request_oldest(graph: *mut AVFilterGraph) -> c_int; +} diff --git a/sys/src/avfilter/mod.rs b/sys/src/avfilter/mod.rs new file mode 100644 index 0000000..d65160f --- /dev/null +++ b/sys/src/avfilter/mod.rs @@ -0,0 +1,8 @@ +mod filter; +pub use self::filter::*; + +mod buffersink; +pub use self::buffersink::*; + +mod buffersrc; +pub use self::buffersrc::*; diff --git a/sys/src/lib.rs b/sys/src/lib.rs index e65bd5a..0ef205b 100644 --- a/sys/src/lib.rs +++ b/sys/src/lib.rs @@ -22,6 +22,11 @@ mod avformat; #[cfg(feature = "avformat")] pub use avformat::*; +#[cfg(feature = "avfilter")] +mod avfilter; +#[cfg(feature = "avfilter")] +pub use avfilter::*; + #[cfg(feature = "swscale")] mod swscale; #[cfg(feature = "swscale")]