/* automatically generated by rust-bindgen */

pub const MLT_POSITION_FMT: &'static [u8; 3usize] = b"%d\0";
pub const MLT_DIRLIST_DELIMITER: &'static [u8; 2usize] = b":\0";
pub const MLT_LOG_QUIET: i32 = -8;
pub const MLT_LOG_PANIC: u32 = 0;
pub const MLT_LOG_FATAL: u32 = 8;
pub const MLT_LOG_ERROR: u32 = 16;
pub const MLT_LOG_WARNING: u32 = 24;
pub const MLT_LOG_INFO: u32 = 32;
pub const MLT_LOG_VERBOSE: u32 = 40;
pub const MLT_LOG_TIMINGS: u32 = 44;
pub const MLT_LOG_DEBUG: u32 = 48;
pub type __uint8_t = ::std::os::raw::c_uchar;
pub type __int32_t = ::std::os::raw::c_int;
pub type __int64_t = ::std::os::raw::c_long;
pub type __off_t = ::std::os::raw::c_long;
pub type __off64_t = ::std::os::raw::c_long;
pub type FILE = _IO_FILE;
pub type va_list = __builtin_va_list;
pub type _IO_lock_t = ::std::os::raw::c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_marker {
    pub _next: *mut _IO_marker,
    pub _sbuf: *mut _IO_FILE,
    pub _pos: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__IO_marker() {
    assert_eq!(
        ::std::mem::size_of::<_IO_marker>(),
        24usize,
        concat!("Size of: ", stringify!(_IO_marker))
    );
    assert_eq!(
        ::std::mem::align_of::<_IO_marker>(),
        8usize,
        concat!("Alignment of ", stringify!(_IO_marker))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_marker>()))._next as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_marker),
            "::",
            stringify!(_next)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_marker>()))._sbuf as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_marker),
            "::",
            stringify!(_sbuf)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_marker>()))._pos as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_marker),
            "::",
            stringify!(_pos)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_FILE {
    pub _flags: ::std::os::raw::c_int,
    pub _IO_read_ptr: *mut ::std::os::raw::c_char,
    pub _IO_read_end: *mut ::std::os::raw::c_char,
    pub _IO_read_base: *mut ::std::os::raw::c_char,
    pub _IO_write_base: *mut ::std::os::raw::c_char,
    pub _IO_write_ptr: *mut ::std::os::raw::c_char,
    pub _IO_write_end: *mut ::std::os::raw::c_char,
    pub _IO_buf_base: *mut ::std::os::raw::c_char,
    pub _IO_buf_end: *mut ::std::os::raw::c_char,
    pub _IO_save_base: *mut ::std::os::raw::c_char,
    pub _IO_backup_base: *mut ::std::os::raw::c_char,
    pub _IO_save_end: *mut ::std::os::raw::c_char,
    pub _markers: *mut _IO_marker,
    pub _chain: *mut _IO_FILE,
    pub _fileno: ::std::os::raw::c_int,
    pub _flags2: ::std::os::raw::c_int,
    pub _old_offset: __off_t,
    pub _cur_column: ::std::os::raw::c_ushort,
    pub _vtable_offset: ::std::os::raw::c_schar,
    pub _shortbuf: [::std::os::raw::c_char; 1usize],
    pub _lock: *mut _IO_lock_t,
    pub _offset: __off64_t,
    pub __pad1: *mut ::std::os::raw::c_void,
    pub __pad2: *mut ::std::os::raw::c_void,
    pub __pad3: *mut ::std::os::raw::c_void,
    pub __pad4: *mut ::std::os::raw::c_void,
    pub __pad5: usize,
    pub _mode: ::std::os::raw::c_int,
    pub _unused2: [::std::os::raw::c_char; 20usize],
}
#[test]
fn bindgen_test_layout__IO_FILE() {
    assert_eq!(
        ::std::mem::size_of::<_IO_FILE>(),
        216usize,
        concat!("Size of: ", stringify!(_IO_FILE))
    );
    assert_eq!(
        ::std::mem::align_of::<_IO_FILE>(),
        8usize,
        concat!("Alignment of ", stringify!(_IO_FILE))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._flags as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_ptr as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_read_ptr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_end as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_read_end)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_base as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_read_base)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_base as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_write_base)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_ptr as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_write_ptr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_end as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_write_end)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_buf_base as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_buf_base)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_buf_end as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_buf_end)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_save_base as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_save_base)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_backup_base as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_backup_base)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_save_end as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_save_end)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._markers as *const _ as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_markers)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._chain as *const _ as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_chain)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._fileno as *const _ as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_fileno)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._flags2 as *const _ as usize },
        116usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_flags2)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._old_offset as *const _ as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_old_offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._cur_column as *const _ as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_cur_column)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._vtable_offset as *const _ as usize },
        130usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_vtable_offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._shortbuf as *const _ as usize },
        131usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_shortbuf)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._lock as *const _ as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_lock)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._offset as *const _ as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad1 as *const _ as usize },
        152usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(__pad1)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad2 as *const _ as usize },
        160usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(__pad2)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad3 as *const _ as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(__pad3)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad4 as *const _ as usize },
        176usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(__pad4)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad5 as *const _ as usize },
        184usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(__pad5)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._mode as *const _ as usize },
        192usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_mode)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._unused2 as *const _ as usize },
        196usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_unused2)
        )
    );
}
extern "C" {
    pub fn mlt_pool_init();
    pub fn mlt_pool_alloc(size: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void;
    pub fn mlt_pool_realloc(
        ptr: *mut ::std::os::raw::c_void,
        size: ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_void;
    pub fn mlt_pool_release(release: *mut ::std::os::raw::c_void);
    pub fn mlt_pool_purge();
    pub fn mlt_pool_close();
    pub fn mlt_pool_stat();
}
/// < image not available
pub const mlt_image_format_mlt_image_none: mlt_image_format = 0;
/// < 8-bit RGB
pub const mlt_image_format_mlt_image_rgb24: mlt_image_format = 1;
/// < 8-bit RGB with alpha channel
pub const mlt_image_format_mlt_image_rgb24a: mlt_image_format = 2;
/// < 8-bit YUV 4:2:2 packed
pub const mlt_image_format_mlt_image_yuv422: mlt_image_format = 3;
/// < 8-bit YUV 4:2:0 planar
pub const mlt_image_format_mlt_image_yuv420p: mlt_image_format = 4;
/// < (deprecated) suitable for OpenGL texture
pub const mlt_image_format_mlt_image_opengl: mlt_image_format = 5;
/// < for opengl module internal use only
pub const mlt_image_format_mlt_image_glsl: mlt_image_format = 6;
/// < an OpenGL texture name
pub const mlt_image_format_mlt_image_glsl_texture: mlt_image_format = 7;
/// < planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
pub const mlt_image_format_mlt_image_yuv422p16: mlt_image_format = 8;
pub const mlt_image_format_mlt_image_invalid: mlt_image_format = 9;
/// The set of supported image formats
pub type mlt_image_format = u32;
/// < audio not available
pub const mlt_audio_format_mlt_audio_none: mlt_audio_format = 0;
/// < \deprecated signed 16-bit interleaved PCM
pub const mlt_audio_format_mlt_audio_pcm: mlt_audio_format = 1;
/// < signed 16-bit interleaved PCM
pub const mlt_audio_format_mlt_audio_s16: mlt_audio_format = 1;
/// < signed 32-bit non-interleaved PCM
pub const mlt_audio_format_mlt_audio_s32: mlt_audio_format = 2;
/// < 32-bit non-interleaved floating point
pub const mlt_audio_format_mlt_audio_float: mlt_audio_format = 3;
/// < signed 32-bit interleaved PCM
pub const mlt_audio_format_mlt_audio_s32le: mlt_audio_format = 4;
/// < 32-bit interleaved floating point
pub const mlt_audio_format_mlt_audio_f32le: mlt_audio_format = 5;
/// < unsigned 8-bit interleaved PCM
pub const mlt_audio_format_mlt_audio_u8: mlt_audio_format = 6;
/// The set of supported audio formats
pub type mlt_audio_format = u32;
/// < MLT will determine the default configuration based on channel number
pub const mlt_channel_layout_mlt_channel_auto: mlt_channel_layout = 0;
/// < channels are not related
pub const mlt_channel_layout_mlt_channel_independent: mlt_channel_layout = 1;
pub const mlt_channel_layout_mlt_channel_mono: mlt_channel_layout = 2;
pub const mlt_channel_layout_mlt_channel_stereo: mlt_channel_layout = 3;
pub const mlt_channel_layout_mlt_channel_2p1: mlt_channel_layout = 4;
pub const mlt_channel_layout_mlt_channel_3p0: mlt_channel_layout = 5;
pub const mlt_channel_layout_mlt_channel_3p0_back: mlt_channel_layout = 6;
pub const mlt_channel_layout_mlt_channel_4p0: mlt_channel_layout = 7;
pub const mlt_channel_layout_mlt_channel_quad_back: mlt_channel_layout = 8;
pub const mlt_channel_layout_mlt_channel_quad_side: mlt_channel_layout = 9;
pub const mlt_channel_layout_mlt_channel_3p1: mlt_channel_layout = 10;
pub const mlt_channel_layout_mlt_channel_5p0_back: mlt_channel_layout = 11;
pub const mlt_channel_layout_mlt_channel_5p0: mlt_channel_layout = 12;
pub const mlt_channel_layout_mlt_channel_4p1: mlt_channel_layout = 13;
pub const mlt_channel_layout_mlt_channel_5p1_back: mlt_channel_layout = 14;
pub const mlt_channel_layout_mlt_channel_5p1: mlt_channel_layout = 15;
pub const mlt_channel_layout_mlt_channel_6p0: mlt_channel_layout = 16;
pub const mlt_channel_layout_mlt_channel_6p0_front: mlt_channel_layout = 17;
pub const mlt_channel_layout_mlt_channel_hexagonal: mlt_channel_layout = 18;
pub const mlt_channel_layout_mlt_channel_6p1: mlt_channel_layout = 19;
pub const mlt_channel_layout_mlt_channel_6p1_back: mlt_channel_layout = 20;
pub const mlt_channel_layout_mlt_channel_6p1_front: mlt_channel_layout = 21;
pub const mlt_channel_layout_mlt_channel_7p0: mlt_channel_layout = 22;
pub const mlt_channel_layout_mlt_channel_7p0_front: mlt_channel_layout = 23;
pub const mlt_channel_layout_mlt_channel_7p1: mlt_channel_layout = 24;
pub const mlt_channel_layout_mlt_channel_7p1_wide_side: mlt_channel_layout = 25;
pub const mlt_channel_layout_mlt_channel_7p1_wide_back: mlt_channel_layout = 26;
pub type mlt_channel_layout = u32;
/// < frame count
pub const mlt_time_format_mlt_time_frames: mlt_time_format = 0;
/// < SMIL clock-value as [[hh:]mm:]ss[.fraction]
pub const mlt_time_format_mlt_time_clock: mlt_time_format = 1;
/// < SMPTE timecode as [[[hh:]mm:]ss{:|;}]frames
pub const mlt_time_format_mlt_time_smpte_df: mlt_time_format = 2;
/// < Deprecated
pub const mlt_time_format_mlt_time_smpte: mlt_time_format = 2;
/// < SMPTE NDF timecode as [[[hh:]mm:]ss:]frames
pub const mlt_time_format_mlt_time_smpte_ndf: mlt_time_format = 3;
/// The time string formats
pub type mlt_time_format = u32;
/// < non-interpolated; value changes instantaneously at the key frame
pub const mlt_keyframe_type_mlt_keyframe_discrete: mlt_keyframe_type = 0;
/// < simple, constant pace from this key frame to the next
pub const mlt_keyframe_type_mlt_keyframe_linear: mlt_keyframe_type = 1;
/// < eased pacing from this keyframe to the next using a Catmull-Rom spline
pub const mlt_keyframe_type_mlt_keyframe_smooth: mlt_keyframe_type = 2;
/// Interpolation methods for animation keyframes
pub type mlt_keyframe_type = u32;
/// < relative to the beginning
pub const mlt_whence_mlt_whence_relative_start: mlt_whence = 0;
/// < relative to the current position
pub const mlt_whence_mlt_whence_relative_current: mlt_whence = 1;
/// < relative to the end
pub const mlt_whence_mlt_whence_relative_end: mlt_whence = 2;
/// The relative time qualifiers
pub type mlt_whence = u32;
/// < invalid service
pub const mlt_service_type_invalid_type: mlt_service_type = 0;
/// < unknown class
pub const mlt_service_type_unknown_type: mlt_service_type = 1;
/// < Producer class
pub const mlt_service_type_producer_type: mlt_service_type = 2;
/// < Tractor class
pub const mlt_service_type_tractor_type: mlt_service_type = 3;
/// < Playlist class
pub const mlt_service_type_playlist_type: mlt_service_type = 4;
/// < Multitrack class
pub const mlt_service_type_multitrack_type: mlt_service_type = 5;
/// < Filter class
pub const mlt_service_type_filter_type: mlt_service_type = 6;
/// < Transition class
pub const mlt_service_type_transition_type: mlt_service_type = 7;
/// < Consumer class
pub const mlt_service_type_consumer_type: mlt_service_type = 8;
/// < Field class
pub const mlt_service_type_field_type: mlt_service_type = 9;
/// The recognized subclasses of mlt_service
pub type mlt_service_type = u32;
pub type mlt_position = i32;
/// A rectangle type with coordinates, size, and opacity
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_rect {
    /// < X coordinate
    pub x: f64,
    /// < Y coordinate
    pub y: f64,
    /// < width
    pub w: f64,
    /// < height
    pub h: f64,
    /// < opacity / mix-level
    pub o: f64,
}
#[test]
fn bindgen_test_layout_mlt_rect() {
    assert_eq!(
        ::std::mem::size_of::<mlt_rect>(),
        40usize,
        concat!("Size of: ", stringify!(mlt_rect))
    );
    assert_eq!(
        ::std::mem::align_of::<mlt_rect>(),
        8usize,
        concat!("Alignment of ", stringify!(mlt_rect))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_rect>())).x as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_rect),
            "::",
            stringify!(x)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_rect>())).y as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_rect),
            "::",
            stringify!(y)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_rect>())).w as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_rect),
            "::",
            stringify!(w)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_rect>())).h as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_rect),
            "::",
            stringify!(h)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_rect>())).o as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_rect),
            "::",
            stringify!(o)
        )
    );
}
/// A tuple of color components
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_color {
    /// < red
    pub r: u8,
    /// < green
    pub g: u8,
    /// < blue
    pub b: u8,
    /// < alpha
    pub a: u8,
}
#[test]
fn bindgen_test_layout_mlt_color() {
    assert_eq!(
        ::std::mem::size_of::<mlt_color>(),
        4usize,
        concat!("Size of: ", stringify!(mlt_color))
    );
    assert_eq!(
        ::std::mem::align_of::<mlt_color>(),
        1usize,
        concat!("Alignment of ", stringify!(mlt_color))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_color>())).r as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_color),
            "::",
            stringify!(r)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_color>())).g as *const _ as usize },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_color),
            "::",
            stringify!(g)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_color>())).b as *const _ as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_color),
            "::",
            stringify!(b)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_color>())).a as *const _ as usize },
        3usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_color),
            "::",
            stringify!(a)
        )
    );
}
pub type mlt_frame = *mut mlt_frame_s;
pub type mlt_frame_ptr = *mut *mut mlt_frame_s;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_property_s {
    _unused: [u8; 0],
}
pub type mlt_property = *mut mlt_property_s;
pub type mlt_properties = *mut mlt_properties_s;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_event_struct {
    _unused: [u8; 0],
}
pub type mlt_event = *mut mlt_event_struct;
pub type mlt_service = *mut mlt_service_s;
pub type mlt_producer = *mut mlt_producer_s;
pub type mlt_playlist = *mut mlt_playlist_s;
pub type mlt_multitrack = *mut mlt_multitrack_s;
pub type mlt_filter = *mut mlt_filter_s;
pub type mlt_transition = *mut mlt_transition_s;
pub type mlt_tractor = *mut mlt_tractor_s;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_field_s {
    _unused: [u8; 0],
}
pub type mlt_field = *mut mlt_field_s;
pub type mlt_consumer = *mut mlt_consumer_s;
pub type mlt_parser = *mut mlt_parser_s;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_deque_s {
    _unused: [u8; 0],
}
pub type mlt_deque = *mut mlt_deque_s;
pub type mlt_geometry = *mut mlt_geometry_s;
pub type mlt_geometry_item = *mut mlt_geometry_item_s;
pub type mlt_profile = *mut mlt_profile_s;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_repository_s {
    _unused: [u8; 0],
}
pub type mlt_repository = *mut mlt_repository_s;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_cache_s {
    _unused: [u8; 0],
}
pub type mlt_cache = *mut mlt_cache_s;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_cache_item_s {
    _unused: [u8; 0],
}
pub type mlt_cache_item = *mut mlt_cache_item_s;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_animation_s {
    _unused: [u8; 0],
}
pub type mlt_animation = *mut mlt_animation_s;
/// \envvar \em MLT_SLICES_COUNT Set the number of slices to use, which
/// defaults to number of CPUs found.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_slices_s {
    _unused: [u8; 0],
}
pub type mlt_slices = *mut mlt_slices_s;
pub type mlt_destructor =
    ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>;
pub type mlt_serialiser = ::std::option::Option<
    unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void, length: ::std::os::raw::c_int)
        -> *mut ::std::os::raw::c_char,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __locale_struct {
    pub __locales: [*mut __locale_data; 13usize],
    pub __ctype_b: *const ::std::os::raw::c_ushort,
    pub __ctype_tolower: *const ::std::os::raw::c_int,
    pub __ctype_toupper: *const ::std::os::raw::c_int,
    pub __names: [*const ::std::os::raw::c_char; 13usize],
}
#[test]
fn bindgen_test_layout___locale_struct() {
    assert_eq!(
        ::std::mem::size_of::<__locale_struct>(),
        232usize,
        concat!("Size of: ", stringify!(__locale_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<__locale_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(__locale_struct))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<__locale_struct>())).__locales as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__locale_struct),
            "::",
            stringify!(__locales)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<__locale_struct>())).__ctype_b as *const _ as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(__locale_struct),
            "::",
            stringify!(__ctype_b)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<__locale_struct>())).__ctype_tolower as *const _ as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(__locale_struct),
            "::",
            stringify!(__ctype_tolower)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<__locale_struct>())).__ctype_toupper as *const _ as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(__locale_struct),
            "::",
            stringify!(__ctype_toupper)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<__locale_struct>())).__names as *const _ as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(__locale_struct),
            "::",
            stringify!(__names)
        )
    );
}
pub type __locale_t = *mut __locale_struct;
pub type locale_t = __locale_t;
extern "C" {
    pub fn mlt_property_init() -> mlt_property;
    pub fn mlt_property_clear(self_: mlt_property);
    pub fn mlt_property_set_int(
    self_: mlt_property,
    value: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_property_set_double(self_: mlt_property, value: f64) -> ::std::os::raw::c_int;
    pub fn mlt_property_set_position(
        self_: mlt_property,
        value: mlt_position,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_property_set_int64(self_: mlt_property, value: i64) -> ::std::os::raw::c_int;
    pub fn mlt_property_set_string(
        self_: mlt_property,
        value: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_property_set_data(
        self_: mlt_property,
        value: *mut ::std::os::raw::c_void,
        length: ::std::os::raw::c_int,
        destructor: mlt_destructor,
        serialiser: mlt_serialiser,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_property_get_int(
        self_: mlt_property,
        fps: f64,
        arg1: locale_t,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_property_get_double(self_: mlt_property, fps: f64, arg1: locale_t) -> f64;
    pub fn mlt_property_get_position(self_: mlt_property, fps: f64, arg1: locale_t)
        -> mlt_position;
    pub fn mlt_property_get_int64(self_: mlt_property) -> i64;
    pub fn mlt_property_get_string_tf(
        self_: mlt_property,
        arg1: mlt_time_format,
    ) -> *mut ::std::os::raw::c_char;
    pub fn mlt_property_get_string(self_: mlt_property) -> *mut ::std::os::raw::c_char;
    pub fn mlt_property_get_string_l_tf(
        self_: mlt_property,
        arg1: locale_t,
        arg2: mlt_time_format,
    ) -> *mut ::std::os::raw::c_char;
    pub fn mlt_property_get_string_l(
        self_: mlt_property,
        arg1: locale_t,
    ) -> *mut ::std::os::raw::c_char;
    pub fn mlt_property_get_data(
        self_: mlt_property,
        length: *mut ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_void;
    pub fn mlt_property_close(self_: mlt_property);
    pub fn mlt_property_pass(self_: mlt_property, that: mlt_property);
    pub fn mlt_property_get_time(
        self_: mlt_property,
        arg1: mlt_time_format,
        fps: f64,
        arg2: locale_t,
    ) -> *mut ::std::os::raw::c_char;
    pub fn mlt_property_interpolate(
        self_: mlt_property,
        points: *mut mlt_property,
        progress: f64,
        fps: f64,
        locale: locale_t,
        interp: mlt_keyframe_type,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_property_anim_get_double(
        self_: mlt_property,
        fps: f64,
        locale: locale_t,
        position: ::std::os::raw::c_int,
        length: ::std::os::raw::c_int,
    ) -> f64;
    pub fn mlt_property_anim_get_int(
        self_: mlt_property,
        fps: f64,
        locale: locale_t,
        position: ::std::os::raw::c_int,
        length: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_property_anim_get_string(
        self_: mlt_property,
        fps: f64,
        locale: locale_t,
        position: ::std::os::raw::c_int,
        length: ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_char;
    pub fn mlt_property_anim_set_double(
        self_: mlt_property,
        value: f64,
        fps: f64,
        locale: locale_t,
        position: ::std::os::raw::c_int,
        length: ::std::os::raw::c_int,
        keyframe_type: mlt_keyframe_type,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_property_anim_set_int(
        self_: mlt_property,
        value: ::std::os::raw::c_int,
        fps: f64,
        locale: locale_t,
        position: ::std::os::raw::c_int,
        length: ::std::os::raw::c_int,
        keyframe_type: mlt_keyframe_type,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_property_anim_set_string(
        self_: mlt_property,
        value: *const ::std::os::raw::c_char,
        fps: f64,
        locale: locale_t,
        position: ::std::os::raw::c_int,
        length: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_property_get_animation(self_: mlt_property) -> mlt_animation;
    pub fn mlt_property_set_rect(self_: mlt_property, value: mlt_rect) -> ::std::os::raw::c_int;
    pub fn mlt_property_get_rect(self_: mlt_property, locale: locale_t) -> mlt_rect;
    pub fn mlt_property_anim_set_rect(
        self_: mlt_property,
        value: mlt_rect,
        fps: f64,
        locale: locale_t,
        position: ::std::os::raw::c_int,
        length: ::std::os::raw::c_int,
        keyframe_type: mlt_keyframe_type,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_property_anim_get_rect(
        self_: mlt_property,
        fps: f64,
        locale: locale_t,
        position: ::std::os::raw::c_int,
        length: ::std::os::raw::c_int,
    ) -> mlt_rect;
}
/// An animation item that represents a keyframe-property combination.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_animation_item_s {
    /// < a boolean of whether this is a key frame or an interpolated item
    pub is_key: ::std::os::raw::c_int,
    /// < the frame number for this instance of the property
    pub frame: ::std::os::raw::c_int,
    /// < the property for this point in time
    pub property: mlt_property,
    /// < the method of interpolation for this key frame
    pub keyframe_type: mlt_keyframe_type,
}
#[test]
fn bindgen_test_layout_mlt_animation_item_s() {
    assert_eq!(
        ::std::mem::size_of::<mlt_animation_item_s>(),
        24usize,
        concat!("Size of: ", stringify!(mlt_animation_item_s))
    );
    assert_eq!(
        ::std::mem::align_of::<mlt_animation_item_s>(),
        8usize,
        concat!("Alignment of ", stringify!(mlt_animation_item_s))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_animation_item_s>())).is_key as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_animation_item_s),
            "::",
            stringify!(is_key)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_animation_item_s>())).frame as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_animation_item_s),
            "::",
            stringify!(frame)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_animation_item_s>())).property as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_animation_item_s),
            "::",
            stringify!(property)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<mlt_animation_item_s>())).keyframe_type as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_animation_item_s),
            "::",
            stringify!(keyframe_type)
        )
    );
}
pub type mlt_animation_item = *mut mlt_animation_item_s;
extern "C" {
    pub fn mlt_animation_new() -> mlt_animation;
    pub fn mlt_animation_parse(
        self_: mlt_animation,
        data: *const ::std::os::raw::c_char,
        length: ::std::os::raw::c_int,
        fps: f64,
        locale: locale_t,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_animation_refresh(
        self_: mlt_animation,
        data: *const ::std::os::raw::c_char,
        length: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_animation_get_length(self_: mlt_animation) -> ::std::os::raw::c_int;
    pub fn mlt_animation_set_length(self_: mlt_animation, length: ::std::os::raw::c_int);
    pub fn mlt_animation_parse_item(
        self_: mlt_animation,
        item: mlt_animation_item,
        data: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_animation_get_item(
        self_: mlt_animation,
        item: mlt_animation_item,
        position: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_animation_insert(
        self_: mlt_animation,
        item: mlt_animation_item,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_animation_remove(
        self_: mlt_animation,
        position: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_animation_interpolate(self_: mlt_animation);
    pub fn mlt_animation_next_key(
        self_: mlt_animation,
        item: mlt_animation_item,
        position: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_animation_prev_key(
        self_: mlt_animation,
        item: mlt_animation_item,
        position: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_animation_serialize_cut_tf(
        self_: mlt_animation,
        in_: ::std::os::raw::c_int,
        out: ::std::os::raw::c_int,
        arg1: mlt_time_format,
    ) -> *mut ::std::os::raw::c_char;
    pub fn mlt_animation_serialize_cut(
        self_: mlt_animation,
        in_: ::std::os::raw::c_int,
        out: ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_char;
    pub fn mlt_animation_serialize_tf(
        self_: mlt_animation,
        arg1: mlt_time_format,
    ) -> *mut ::std::os::raw::c_char;
    pub fn mlt_animation_serialize(self_: mlt_animation) -> *mut ::std::os::raw::c_char;
    pub fn mlt_animation_key_count(self_: mlt_animation) -> ::std::os::raw::c_int;
    pub fn mlt_animation_key_get(
        self_: mlt_animation,
        item: mlt_animation_item,
        index: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_animation_close(self_: mlt_animation);
    pub fn mlt_animation_key_set_type(
        self_: mlt_animation,
        index: ::std::os::raw::c_int,
        type_: mlt_keyframe_type,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_animation_key_set_frame(
        self_: mlt_animation,
        index: ::std::os::raw::c_int,
        frame: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
/// \brief Profile class
///
/// \envvar \em MLT_PROFILES_PATH overrides the default full path to the profile preset files, defaults to \p MLT_DATA/profiles
/// \envvar \em MLT_PROFILE the profile preset to use, defaults to "dv_pal"
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_profile_s {
    /// < a brief description suitable as a label in UI menu
    pub description: *mut ::std::os::raw::c_char,
    /// < the numerator of the video frame rate
    pub frame_rate_num: ::std::os::raw::c_int,
    /// < the denominator of the video frame rate
    pub frame_rate_den: ::std::os::raw::c_int,
    /// < the horizontal resolution of the video
    pub width: ::std::os::raw::c_int,
    /// < the vertical resolution of the video
    pub height: ::std::os::raw::c_int,
    /// < a flag to indicate if the video is progressive scan, interlace if not set
    pub progressive: ::std::os::raw::c_int,
    /// < the numerator of the pixel aspect ratio
    pub sample_aspect_num: ::std::os::raw::c_int,
    /// < the denominator of the pixel aspect ratio
    pub sample_aspect_den: ::std::os::raw::c_int,
    /// < the numerator of the image aspect ratio in case it can not be simply derived (e.g. ITU-R 601)
    pub display_aspect_num: ::std::os::raw::c_int,
    /// < the denominator of the image aspect ratio in case it can not be simply derived (e.g. ITU-R 601)
    pub display_aspect_den: ::std::os::raw::c_int,
    /// < the Y'CbCr colorspace standard: =601 for ITU-R 601, =709 for ITU-R 709, or =240 for SMPTE240M
    pub colorspace: ::std::os::raw::c_int,
    /// < used internally to indicate if the profile was requested explicitly or computed or defaulted
    pub is_explicit: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_mlt_profile_s() {
    assert_eq!(
        ::std::mem::size_of::<mlt_profile_s>(),
        56usize,
        concat!("Size of: ", stringify!(mlt_profile_s))
    );
    assert_eq!(
        ::std::mem::align_of::<mlt_profile_s>(),
        8usize,
        concat!("Alignment of ", stringify!(mlt_profile_s))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_profile_s>())).description as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_profile_s),
            "::",
            stringify!(description)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_profile_s>())).frame_rate_num as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_profile_s),
            "::",
            stringify!(frame_rate_num)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_profile_s>())).frame_rate_den as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_profile_s),
            "::",
            stringify!(frame_rate_den)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_profile_s>())).width as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_profile_s),
            "::",
            stringify!(width)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_profile_s>())).height as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_profile_s),
            "::",
            stringify!(height)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_profile_s>())).progressive as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_profile_s),
            "::",
            stringify!(progressive)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_profile_s>())).sample_aspect_num as *const _ as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_profile_s),
            "::",
            stringify!(sample_aspect_num)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_profile_s>())).sample_aspect_den as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_profile_s),
            "::",
            stringify!(sample_aspect_den)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<mlt_profile_s>())).display_aspect_num as *const _ as usize
        },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_profile_s),
            "::",
            stringify!(display_aspect_num)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<mlt_profile_s>())).display_aspect_den as *const _ as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_profile_s),
            "::",
            stringify!(display_aspect_den)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_profile_s>())).colorspace as *const _ as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_profile_s),
            "::",
            stringify!(colorspace)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_profile_s>())).is_explicit as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_profile_s),
            "::",
            stringify!(is_explicit)
        )
    );
}
extern "C" {
    pub fn mlt_profile_init(name: *const ::std::os::raw::c_char) -> mlt_profile;
    pub fn mlt_profile_load_file(file: *const ::std::os::raw::c_char) -> mlt_profile;
    pub fn mlt_profile_load_properties(properties: mlt_properties) -> mlt_profile;
    pub fn mlt_profile_load_string(string: *const ::std::os::raw::c_char) -> mlt_profile;
    pub fn mlt_profile_fps(profile: mlt_profile) -> f64;
    pub fn mlt_profile_sar(profile: mlt_profile) -> f64;
    pub fn mlt_profile_dar(profile: mlt_profile) -> f64;
    pub fn mlt_profile_close(profile: mlt_profile);
    pub fn mlt_profile_clone(profile: mlt_profile) -> mlt_profile;
    pub fn mlt_profile_list() -> mlt_properties;
    pub fn mlt_profile_from_producer(profile: mlt_profile, producer: mlt_producer);
}
/// The callback function that modules implement to construct a service.
pub type mlt_register_callback = ::std::option::Option<
    unsafe extern "C" fn(
        arg1: mlt_profile,
        arg2: mlt_service_type,
        arg3: *const ::std::os::raw::c_char,
        arg4: *const ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void,
>;
/// The callback function that modules implement to supply metadata as a properties list.
pub type mlt_metadata_callback = ::std::option::Option<
    unsafe extern "C" fn(
        arg1: mlt_service_type,
        arg2: *const ::std::os::raw::c_char,
        arg3: *mut ::std::os::raw::c_void,
    ) -> mlt_properties,
>;
extern "C" {
    pub fn mlt_repository_init(directory: *const ::std::os::raw::c_char) -> mlt_repository;
    pub fn mlt_repository_register(
        self_: mlt_repository,
        service_type: mlt_service_type,
        service: *const ::std::os::raw::c_char,
        arg1: mlt_register_callback,
    );
    pub fn mlt_repository_create(
        self_: mlt_repository,
        profile: mlt_profile,
        type_: mlt_service_type,
        service: *const ::std::os::raw::c_char,
        arg: *const ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void;
    pub fn mlt_repository_close(self_: mlt_repository);
    pub fn mlt_repository_consumers(self_: mlt_repository) -> mlt_properties;
    pub fn mlt_repository_filters(self_: mlt_repository) -> mlt_properties;
    pub fn mlt_repository_producers(self_: mlt_repository) -> mlt_properties;
    pub fn mlt_repository_transitions(self_: mlt_repository) -> mlt_properties;
    pub fn mlt_repository_register_metadata(
        self_: mlt_repository,
        type_: mlt_service_type,
        service: *const ::std::os::raw::c_char,
        arg1: mlt_metadata_callback,
        callback_data: *mut ::std::os::raw::c_void,
    );
    pub fn mlt_repository_metadata(
        self_: mlt_repository,
        type_: mlt_service_type,
        service: *const ::std::os::raw::c_char,
    ) -> mlt_properties;
    pub fn mlt_repository_languages(self_: mlt_repository) -> mlt_properties;
    pub fn mlt_repository_presets() -> mlt_properties;
}

extern "C" {
    /// \envvar \em MLT_PRODUCER the name of a default producer often used by other services, defaults to "loader"
    /// \envvar \em MLT_CONSUMER the name of a default consumer, defaults to "sdl2" followed by "sdl"
    /// \envvar \em MLT_TEST_CARD the name of a producer or file to be played when nothing is available (all tracks blank)
    /// \envvar \em MLT_DATA overrides the default full path to the MLT and module supplemental data files, defaults to \p PREFIX_DATA
    /// \envvar \em MLT_PROFILE selects the default mlt_profile_s, defaults to "dv_pal"
    /// \envvar \em MLT_REPOSITORY overrides the default location of the plugin modules, defaults to \p PREFIX_LIB.
    /// MLT_REPOSITORY is ignored on Windows and OS X relocatable builds.
    /// \envvar \em MLT_PRESETS_PATH overrides the default full path to the properties preset files, defaults to \p MLT_DATA/presets
    /// \event \em producer-create-request fired when mlt_factory_producer is called
    /// \event \em producer-create-done fired when a producer registers itself
    /// \event \em filter-create-request fired when mlt_factory_filter is called
    /// \event \em filter-create-done fired when a filter registers itself
    /// \event \em transition-create-request fired when mlt_factory_transition is called
    /// \event \em transition-create-done fired when a transition registers itself
    /// \event \em consumer-create-request fired when mlt_factory_consumer is called
    /// \event \em consumer-create-done fired when a consumer registers itself
    pub fn mlt_factory_init(directory: *const ::std::os::raw::c_char) -> mlt_repository;
    pub fn mlt_factory_repository() -> mlt_repository;
    pub fn mlt_factory_directory() -> *const ::std::os::raw::c_char;
    pub fn mlt_environment(name: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
    pub fn mlt_environment_set(
        name: *const ::std::os::raw::c_char,
        value: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_factory_event_object() -> mlt_properties;
    pub fn mlt_factory_producer(
        profile: mlt_profile,
        service: *const ::std::os::raw::c_char,
        resource: *const ::std::os::raw::c_void,
    ) -> mlt_producer;
    pub fn mlt_factory_filter(
        profile: mlt_profile,
        name: *const ::std::os::raw::c_char,
        input: *const ::std::os::raw::c_void,
    ) -> mlt_filter;
    pub fn mlt_factory_transition(
        profile: mlt_profile,
        name: *const ::std::os::raw::c_char,
        input: *const ::std::os::raw::c_void,
    ) -> mlt_transition;
    pub fn mlt_factory_consumer(
        profile: mlt_profile,
        name: *const ::std::os::raw::c_char,
        input: *const ::std::os::raw::c_void,
    ) -> mlt_consumer;
    pub fn mlt_factory_register_for_clean_up(
        ptr: *mut ::std::os::raw::c_void,
        destructor: mlt_destructor,
    );
    pub fn mlt_factory_close();
    pub fn mlt_global_properties() -> mlt_properties;
}

pub type mlt_transmitter =
    ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void, ...)>;
pub type mlt_listener =
    ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void, ...)>;

extern "C" {
    pub fn mlt_events_init(self_: mlt_properties);
    pub fn mlt_events_register(
        self_: mlt_properties,
        id: *const ::std::os::raw::c_char,
        transmitter: mlt_transmitter,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_events_fire(
        self_: mlt_properties,
        id: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
    pub fn mlt_events_listen(
        self_: mlt_properties,
        service: *mut ::std::os::raw::c_void,
        id: *const ::std::os::raw::c_char,
        listener: mlt_listener,
    ) -> mlt_event;
    pub fn mlt_events_block(self_: mlt_properties, service: *mut ::std::os::raw::c_void);
    pub fn mlt_events_unblock(self_: mlt_properties, service: *mut ::std::os::raw::c_void);
    pub fn mlt_events_disconnect(self_: mlt_properties, service: *mut ::std::os::raw::c_void);
    pub fn mlt_events_setup_wait_for(
        self_: mlt_properties,
        id: *const ::std::os::raw::c_char,
    ) -> mlt_event;
    pub fn mlt_events_wait_for(self_: mlt_properties, event: mlt_event);
    pub fn mlt_events_close_wait_for(self_: mlt_properties, event: mlt_event);
    pub fn mlt_event_inc_ref(self_: mlt_event);
    pub fn mlt_event_block(self_: mlt_event);
    pub fn mlt_event_unblock(self_: mlt_event);
    pub fn mlt_event_close(self_: mlt_event);
}

/// \brief Properties class
///
/// Properties is a combination list/dictionary of name/::mlt_property pairs.
/// It is also a base class for many of the other MLT classes.

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_properties_s {
    /// < \private the object of a subclass
    pub child: *mut ::std::os::raw::c_void,
    /// < \private instance object
    pub local: *mut ::std::os::raw::c_void,
    /// the destructor virtual function
    pub close: mlt_destructor,
    /// < the object supplied to the close virtual function
    pub close_object: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_mlt_properties_s() {
    assert_eq!(
        ::std::mem::size_of::<mlt_properties_s>(),
        32usize,
        concat!("Size of: ", stringify!(mlt_properties_s))
    );
    assert_eq!(
        ::std::mem::align_of::<mlt_properties_s>(),
        8usize,
        concat!("Alignment of ", stringify!(mlt_properties_s))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_properties_s>())).child as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_properties_s),
            "::",
            stringify!(child)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_properties_s>())).local as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_properties_s),
            "::",
            stringify!(local)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_properties_s>())).close as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_properties_s),
            "::",
            stringify!(close)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_properties_s>())).close_object as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_properties_s),
            "::",
            stringify!(close_object)
        )
    );
}
extern "C" {
    pub fn mlt_properties_init(
        arg1: mlt_properties,
        child: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_properties_new() -> mlt_properties;
    pub fn mlt_properties_set_lcnumeric(
        arg1: mlt_properties,
        locale: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_properties_get_lcnumeric(self_: mlt_properties) -> *const ::std::os::raw::c_char;
    pub fn mlt_properties_load(file: *const ::std::os::raw::c_char) -> mlt_properties;
    pub fn mlt_properties_preset(
        self_: mlt_properties,
        name: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_properties_inc_ref(self_: mlt_properties) -> ::std::os::raw::c_int;
    pub fn mlt_properties_dec_ref(self_: mlt_properties) -> ::std::os::raw::c_int;
    pub fn mlt_properties_ref_count(self_: mlt_properties) -> ::std::os::raw::c_int;
    pub fn mlt_properties_mirror(self_: mlt_properties, that: mlt_properties);
    pub fn mlt_properties_inherit(
        self_: mlt_properties,
        that: mlt_properties,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_properties_pass(
        self_: mlt_properties,
        that: mlt_properties,
        prefix: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_properties_pass_property(
        self_: mlt_properties,
        that: mlt_properties,
        name: *const ::std::os::raw::c_char,
    );
    pub fn mlt_properties_pass_list(
        self_: mlt_properties,
        that: mlt_properties,
        list: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_properties_set(
        self_: mlt_properties,
        name: *const ::std::os::raw::c_char,
        value: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_properties_set_or_default(
        self_: mlt_properties,
        name: *const ::std::os::raw::c_char,
        value: *const ::std::os::raw::c_char,
        def: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_properties_parse(
        self_: mlt_properties,
        namevalue: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_properties_get(
        self_: mlt_properties,
        name: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
    pub fn mlt_properties_get_name(
        self_: mlt_properties,
        index: ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_char;
    pub fn mlt_properties_get_value_tf(
        self_: mlt_properties,
        index: ::std::os::raw::c_int,
        arg1: mlt_time_format,
    ) -> *mut ::std::os::raw::c_char;
    pub fn mlt_properties_get_value(
        self_: mlt_properties,
        index: ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_char;
    pub fn mlt_properties_get_data_at(
        self_: mlt_properties,
        index: ::std::os::raw::c_int,
        size: *mut ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_void;
    pub fn mlt_properties_get_int(
        self_: mlt_properties,
        name: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_properties_set_int(
        self_: mlt_properties,
        name: *const ::std::os::raw::c_char,
        value: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
    pub fn mlt_properties_get_int64(
        self_: mlt_properties,
        name: *const ::std::os::raw::c_char,
    ) -> i64;
}
extern "C" {
    pub fn mlt_properties_set_int64(
        self_: mlt_properties,
        name: *const ::std::os::raw::c_char,
        value: i64,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_properties_get_double(
        self_: mlt_properties,
        name: *const ::std::os::raw::c_char,
    ) -> f64;
}
extern "C" {
    pub fn mlt_properties_set_double(
        self_: mlt_properties,
        name: *const ::std::os::raw::c_char,
        value: f64,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_properties_get_position(
        self_: mlt_properties,
        name: *const ::std::os::raw::c_char,
    ) -> mlt_position;
}
extern "C" {
    pub fn mlt_properties_set_position(
        self_: mlt_properties,
        name: *const ::std::os::raw::c_char,
        value: mlt_position,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_properties_set_data(
        self_: mlt_properties,
        name: *const ::std::os::raw::c_char,
        value: *mut ::std::os::raw::c_void,
        length: ::std::os::raw::c_int,
        arg1: mlt_destructor,
        arg2: mlt_serialiser,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_properties_get_data(
        self_: mlt_properties,
        name: *const ::std::os::raw::c_char,
        length: *mut ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn mlt_properties_rename(
        self_: mlt_properties,
        source: *const ::std::os::raw::c_char,
        dest: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_properties_count(self_: mlt_properties) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_properties_dump(self_: mlt_properties, output: *mut FILE);
}
extern "C" {
    pub fn mlt_properties_debug(
        self_: mlt_properties,
        title: *const ::std::os::raw::c_char,
        output: *mut FILE,
    );
}
extern "C" {
    pub fn mlt_properties_save(
        arg1: mlt_properties,
        arg2: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_properties_dir_list(
        arg1: mlt_properties,
        arg2: *const ::std::os::raw::c_char,
        arg3: *const ::std::os::raw::c_char,
        arg4: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_properties_close(self_: mlt_properties);
}
extern "C" {
    pub fn mlt_properties_is_sequence(self_: mlt_properties) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_properties_parse_yaml(file: *const ::std::os::raw::c_char) -> mlt_properties;
}
extern "C" {
    pub fn mlt_properties_serialise_yaml(self_: mlt_properties) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn mlt_properties_lock(self_: mlt_properties);
}
extern "C" {
    pub fn mlt_properties_unlock(self_: mlt_properties);
}
extern "C" {
    pub fn mlt_properties_clear(self_: mlt_properties, name: *const ::std::os::raw::c_char);
}
extern "C" {
    pub fn mlt_properties_get_time(
        arg1: mlt_properties,
        name: *const ::std::os::raw::c_char,
        arg2: mlt_time_format,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn mlt_properties_frames_to_time(
        arg1: mlt_properties,
        arg2: mlt_position,
        arg3: mlt_time_format,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn mlt_properties_time_to_frames(
        arg1: mlt_properties,
        time: *const ::std::os::raw::c_char,
    ) -> mlt_position;
}
extern "C" {
    pub fn mlt_properties_get_color(
        arg1: mlt_properties,
        name: *const ::std::os::raw::c_char,
    ) -> mlt_color;
}
extern "C" {
    pub fn mlt_properties_set_color(
        arg1: mlt_properties,
        name: *const ::std::os::raw::c_char,
        value: mlt_color,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_properties_anim_get(
        self_: mlt_properties,
        name: *const ::std::os::raw::c_char,
        position: ::std::os::raw::c_int,
        length: ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn mlt_properties_anim_set(
        self_: mlt_properties,
        name: *const ::std::os::raw::c_char,
        value: *const ::std::os::raw::c_char,
        position: ::std::os::raw::c_int,
        length: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_properties_anim_get_int(
        self_: mlt_properties,
        name: *const ::std::os::raw::c_char,
        position: ::std::os::raw::c_int,
        length: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_properties_anim_set_int(
        self_: mlt_properties,
        name: *const ::std::os::raw::c_char,
        value: ::std::os::raw::c_int,
        position: ::std::os::raw::c_int,
        length: ::std::os::raw::c_int,
        keyframe_type: mlt_keyframe_type,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_properties_anim_get_double(
        self_: mlt_properties,
        name: *const ::std::os::raw::c_char,
        position: ::std::os::raw::c_int,
        length: ::std::os::raw::c_int,
    ) -> f64;
}
extern "C" {
    pub fn mlt_properties_anim_set_double(
        self_: mlt_properties,
        name: *const ::std::os::raw::c_char,
        value: f64,
        position: ::std::os::raw::c_int,
        length: ::std::os::raw::c_int,
        keyframe_type: mlt_keyframe_type,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_properties_get_animation(
        self_: mlt_properties,
        name: *const ::std::os::raw::c_char,
    ) -> mlt_animation;
}
extern "C" {
    pub fn mlt_properties_set_rect(
        self_: mlt_properties,
        name: *const ::std::os::raw::c_char,
        value: mlt_rect,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_properties_get_rect(
        self_: mlt_properties,
        name: *const ::std::os::raw::c_char,
    ) -> mlt_rect;
}
extern "C" {
    pub fn mlt_properties_anim_set_rect(
        self_: mlt_properties,
        name: *const ::std::os::raw::c_char,
        value: mlt_rect,
        position: ::std::os::raw::c_int,
        length: ::std::os::raw::c_int,
        keyframe_type: mlt_keyframe_type,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_properties_anim_get_rect(
        self_: mlt_properties,
        name: *const ::std::os::raw::c_char,
        position: ::std::os::raw::c_int,
        length: ::std::os::raw::c_int,
    ) -> mlt_rect;
}
extern "C" {
    pub fn mlt_properties_from_utf8(
        properties: mlt_properties,
        name_from: *const ::std::os::raw::c_char,
        name_to: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_properties_to_utf8(
        properties: mlt_properties,
        name_from: *const ::std::os::raw::c_char,
        name_to: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
/// The callback function used to compare items for insert sort.
///
/// \public \memberof mlt_deque_s
/// \param a the first object
/// \param b the second object
/// \returns 0 if equal, < 0 if a < b, or > 0 if a > b
pub type mlt_deque_compare = ::std::option::Option<
    unsafe extern "C" fn(a: *mut ::std::os::raw::c_void, b: *mut ::std::os::raw::c_void)
        -> ::std::os::raw::c_int,
>;
extern "C" {
    pub fn mlt_deque_init() -> mlt_deque;
}
extern "C" {
    pub fn mlt_deque_count(self_: mlt_deque) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_deque_push_back(
        self_: mlt_deque,
        item: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_deque_pop_back(self_: mlt_deque) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn mlt_deque_push_front(
        self_: mlt_deque,
        item: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_deque_pop_front(self_: mlt_deque) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn mlt_deque_peek_back(self_: mlt_deque) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn mlt_deque_peek_front(self_: mlt_deque) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn mlt_deque_peek(
        self_: mlt_deque,
        index: ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn mlt_deque_insert(
        self_: mlt_deque,
        item: *mut ::std::os::raw::c_void,
        arg1: mlt_deque_compare,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_deque_push_back_int(
        self_: mlt_deque,
        item: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_deque_pop_back_int(self_: mlt_deque) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_deque_push_front_int(
        self_: mlt_deque,
        item: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_deque_pop_front_int(self_: mlt_deque) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_deque_peek_back_int(self_: mlt_deque) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_deque_peek_front_int(self_: mlt_deque) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_deque_push_back_double(self_: mlt_deque, item: f64) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_deque_pop_back_double(self_: mlt_deque) -> f64;
}
extern "C" {
    pub fn mlt_deque_push_front_double(self_: mlt_deque, item: f64) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_deque_pop_front_double(self_: mlt_deque) -> f64;
}
extern "C" {
    pub fn mlt_deque_peek_back_double(self_: mlt_deque) -> f64;
}
extern "C" {
    pub fn mlt_deque_peek_front_double(self_: mlt_deque) -> f64;
}
extern "C" {
    pub fn mlt_deque_close(self_: mlt_deque);
}
/// \brief Service abstract base class
///
/// \extends mlt_properties
/// The service is the base class for all of the interesting classes and
/// plugins for MLT. A service can have multiple inputs connections to
/// other services called its "producers" but only a single output to another
/// service called its "consumer." A service that has both producer and
/// consumer connections is called a filter. Any service can have zero or more
/// filters "attached" to it. We call any collection of services and their
/// connections a "service network," which is similar to what DirectShow calls
/// a filter graph or what gstreamer calls an element pipeline.
///
/// \event \em service-changed a filter was attached or detached or a transition was connected or disconnected
/// \event \em property-changed
/// \properties \em mlt_type identifies the subclass
/// \properties \em _mlt_service_hidden a flag that indicates whether to hide the mlt_service
/// \properties \em mlt_service is the name of the implementation of the service
/// \properties \em resource is either the stream identifier or grandchild-class
/// \properties \em in when to start, what is started is service-specific
/// \properties \em out when to stop
/// \properties \em _filter_private Set this on a service to ensure that attached filters are handled privately.
/// See modules/core/filter_region.c and modules/core/filter_watermark.c for examples.
/// \properties \em _profile stores the mlt_profile for a service
/// \properties \em _unique_id is a unique identifier
/// \properties \em _need_previous_next boolean that instructs producers to get
/// preceding and following frames inside of \p mlt_service_get_frame
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_service_s {
    /// < \private A service extends properties.
    pub parent: mlt_properties_s,
    /// Get a frame of data (virtual function).
    ///
    /// \param mlt_producer a producer
    /// \param mlt_frame_ptr a frame pointer by reference
    /// \param int an index
    /// \return true if there was an error
    pub get_frame: ::std::option::Option<
        unsafe extern "C" fn(
            self_: mlt_service,
            frame: mlt_frame_ptr,
            index: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    /// the destructor virtual function
    pub close: mlt_destructor,
    /// < the object supplied to the close virtual function
    pub close_object: *mut ::std::os::raw::c_void,
    /// < \private instance object
    pub local: *mut ::std::os::raw::c_void,
    /// < \private the object of a subclass
    pub child: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_mlt_service_s() {
    assert_eq!(
        ::std::mem::size_of::<mlt_service_s>(),
        72usize,
        concat!("Size of: ", stringify!(mlt_service_s))
    );
    assert_eq!(
        ::std::mem::align_of::<mlt_service_s>(),
        8usize,
        concat!("Alignment of ", stringify!(mlt_service_s))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_service_s>())).parent as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_service_s),
            "::",
            stringify!(parent)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_service_s>())).get_frame as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_service_s),
            "::",
            stringify!(get_frame)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_service_s>())).close as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_service_s),
            "::",
            stringify!(close)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_service_s>())).close_object as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_service_s),
            "::",
            stringify!(close_object)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_service_s>())).local as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_service_s),
            "::",
            stringify!(local)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_service_s>())).child as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_service_s),
            "::",
            stringify!(child)
        )
    );
}
extern "C" {
    pub fn mlt_service_init(
        self_: mlt_service,
        child: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_service_lock(self_: mlt_service);
}
extern "C" {
    pub fn mlt_service_unlock(self_: mlt_service);
}
extern "C" {
    pub fn mlt_service_identify(self_: mlt_service) -> mlt_service_type;
}
extern "C" {
    pub fn mlt_service_connect_producer(
        self_: mlt_service,
        producer: mlt_service,
        index: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_service_insert_producer(
        self_: mlt_service,
        producer: mlt_service,
        index: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_service_disconnect_producer(
        self_: mlt_service,
        index: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_service_disconnect_all_producers(self_: mlt_service) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_service_get_producer(self_: mlt_service) -> mlt_service;
}
extern "C" {
    pub fn mlt_service_get_frame(
        self_: mlt_service,
        frame: mlt_frame_ptr,
        index: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_service_properties(self_: mlt_service) -> mlt_properties;
}
extern "C" {
    pub fn mlt_service_consumer(self_: mlt_service) -> mlt_service;
}
extern "C" {
    pub fn mlt_service_producer(self_: mlt_service) -> mlt_service;
}
extern "C" {
    pub fn mlt_service_attach(self_: mlt_service, filter: mlt_filter) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_service_detach(self_: mlt_service, filter: mlt_filter) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_service_apply_filters(
        self_: mlt_service,
        frame: mlt_frame,
        index: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn mlt_service_filter_count(self_: mlt_service) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_service_move_filter(
        self_: mlt_service,
        from: ::std::os::raw::c_int,
        to: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_service_filter(self_: mlt_service, index: ::std::os::raw::c_int) -> mlt_filter;
}
extern "C" {
    pub fn mlt_service_profile(self_: mlt_service) -> mlt_profile;
}
extern "C" {
    pub fn mlt_service_set_profile(self_: mlt_service, profile: mlt_profile);
}
extern "C" {
    pub fn mlt_service_close(self_: mlt_service);
}
extern "C" {
    pub fn mlt_service_cache_put(
        self_: mlt_service,
        name: *const ::std::os::raw::c_char,
        data: *mut ::std::os::raw::c_void,
        size: ::std::os::raw::c_int,
        destructor: mlt_destructor,
    );
}
extern "C" {
    pub fn mlt_service_cache_get(
        self_: mlt_service,
        name: *const ::std::os::raw::c_char,
    ) -> mlt_cache_item;
}
extern "C" {
    pub fn mlt_service_cache_set_size(
        self_: mlt_service,
        name: *const ::std::os::raw::c_char,
        size: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn mlt_service_cache_get_size(
        self_: mlt_service,
        name: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_service_cache_purge(self_: mlt_service);
}
/// Callback function to get video data.
///
pub type mlt_get_image = ::std::option::Option<
    unsafe extern "C" fn(
        self_: mlt_frame,
        buffer: *mut *mut u8,
        format: *mut mlt_image_format,
        width: *mut ::std::os::raw::c_int,
        height: *mut ::std::os::raw::c_int,
        writable: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int,
>;
/// \brief Frame class
///
/// The frame is the primary data object that gets passed around to and through services.
///
/// \extends mlt_properties
/// \properties \em test_image set if the frame holds a "test card" image
/// \properties \em test_audio set if the frame holds "test card" audio
/// \properties \em _producer holds a reference to the frame's end producer
/// \properties \em _speed the current speed of the producer that generated the frame
/// \properties \em _position the position of the frame
/// \properties \em meta.* holds metadata
/// \properties \em hide set to 1 to hide the video, 2 to mute the audio
/// \properties \em last_track a flag to indicate an end-of-tracks frame
/// \properties \em previous \em frame a reference to the unfiltered preceding frame
/// (no speed factor applied, only available when \em _need_previous_next is set on the producer)
/// \properties \em next \em frame a reference to the unfiltered following frame
/// (no speed factor applied, only available when \em _need_previous_next is set on the producer)
/// \properties \em colorspace the standard for the YUV coefficients
/// \properties \em force_full_luma luma range handling, set to -1 for pass-through, 1 for full range, 0 for scaling
/// \properties \em color_trc the color transfer characteristic (gamma)
/// \properties \em audio_frequency the sample rate of the audio
/// \properties \em audio_channels the number of audio channels
/// \properties \em audio_samples the number of audio samples
/// \properties \em audio_format the mlt_audio_format for the audio on this frame
/// \properties \em format the mlt_image_format of the image on this frame
/// \properties \em width the horizontal resolution of the image
/// \properties \em height the vertical resolution of the image
/// \properties \em aspect_ratio the sample aspect ratio of the image
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_frame_s {
    /// < \private A frame extends properties.
    pub parent: mlt_properties_s,
    /// Get the alpha channel (callback function).
    /// \param self a frame
    /// \return the 8-bit alpha channel
    pub get_alpha_mask: ::std::option::Option<unsafe extern "C" fn(self_: mlt_frame) -> *mut u8>,
    /// Convert the image format (callback function).
    /// \param self a frame
    /// \param[in,out] image a buffer of image data
    /// \param[in,out] input the image format of supplied image data
    /// \param output the image format to which to convert
    /// \return true if error
    pub convert_image: ::std::option::Option<
        unsafe extern "C" fn(
            self_: mlt_frame,
            image: *mut *mut u8,
            input: *mut mlt_image_format,
            output: mlt_image_format,
        ) -> ::std::os::raw::c_int,
    >,
    /// Convert the audio format (callback function).
    /// \param self a frame
    /// \param[in,out] audio a buffer of audio data
    /// \param[in,out] input the audio format of supplied data
    /// \param output the audio format to which to convert
    /// \return true if error
    pub convert_audio: ::std::option::Option<
        unsafe extern "C" fn(
            self_: mlt_frame,
            audio: *mut *mut ::std::os::raw::c_void,
            input: *mut mlt_audio_format,
            output: mlt_audio_format,
        ) -> ::std::os::raw::c_int,
    >,
    /// < \private the image processing stack of operations and data
    pub stack_image: mlt_deque,
    /// < \private the audio processing stack of operations and data
    pub stack_audio: mlt_deque,
    /// < \private a general purpose data stack
    pub stack_service: mlt_deque,
    /// < \private indicates if a frame is or was processed by the parallel consumer
    pub is_processing: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_mlt_frame_s() {
    assert_eq!(
        ::std::mem::size_of::<mlt_frame_s>(),
        88usize,
        concat!("Size of: ", stringify!(mlt_frame_s))
    );
    assert_eq!(
        ::std::mem::align_of::<mlt_frame_s>(),
        8usize,
        concat!("Alignment of ", stringify!(mlt_frame_s))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_frame_s>())).parent as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_frame_s),
            "::",
            stringify!(parent)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_frame_s>())).get_alpha_mask as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_frame_s),
            "::",
            stringify!(get_alpha_mask)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_frame_s>())).convert_image as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_frame_s),
            "::",
            stringify!(convert_image)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_frame_s>())).convert_audio as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_frame_s),
            "::",
            stringify!(convert_audio)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_frame_s>())).stack_image as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_frame_s),
            "::",
            stringify!(stack_image)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_frame_s>())).stack_audio as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_frame_s),
            "::",
            stringify!(stack_audio)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_frame_s>())).stack_service as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_frame_s),
            "::",
            stringify!(stack_service)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_frame_s>())).is_processing as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_frame_s),
            "::",
            stringify!(is_processing)
        )
    );
}
extern "C" {
    pub fn mlt_frame_init(service: mlt_service) -> mlt_frame;
}
extern "C" {
    pub fn mlt_frame_properties(self_: mlt_frame) -> mlt_properties;
}
extern "C" {
    pub fn mlt_frame_is_test_card(self_: mlt_frame) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_frame_is_test_audio(self_: mlt_frame) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_frame_get_aspect_ratio(self_: mlt_frame) -> f64;
}
extern "C" {
    pub fn mlt_frame_set_aspect_ratio(self_: mlt_frame, value: f64) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_frame_get_position(self_: mlt_frame) -> mlt_position;
}
extern "C" {
    pub fn mlt_frame_original_position(self_: mlt_frame) -> mlt_position;
}
extern "C" {
    pub fn mlt_frame_set_position(self_: mlt_frame, value: mlt_position) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_frame_set_image(
        self_: mlt_frame,
        image: *mut u8,
        size: ::std::os::raw::c_int,
        destroy: mlt_destructor,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_frame_set_alpha(
        self_: mlt_frame,
        alpha: *mut u8,
        size: ::std::os::raw::c_int,
        destroy: mlt_destructor,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_frame_replace_image(
        self_: mlt_frame,
        image: *mut u8,
        format: mlt_image_format,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn mlt_frame_get_image(
        self_: mlt_frame,
        buffer: *mut *mut u8,
        format: *mut mlt_image_format,
        width: *mut ::std::os::raw::c_int,
        height: *mut ::std::os::raw::c_int,
        writable: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_frame_get_alpha_mask(self_: mlt_frame) -> *mut u8;
}
extern "C" {
    pub fn mlt_frame_get_alpha(self_: mlt_frame) -> *mut u8;
}
extern "C" {
    pub fn mlt_frame_get_audio(
        self_: mlt_frame,
        buffer: *mut *mut ::std::os::raw::c_void,
        format: *mut mlt_audio_format,
        frequency: *mut ::std::os::raw::c_int,
        channels: *mut ::std::os::raw::c_int,
        samples: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_frame_set_audio(
        self_: mlt_frame,
        buffer: *mut ::std::os::raw::c_void,
        arg1: mlt_audio_format,
        size: ::std::os::raw::c_int,
        arg2: mlt_destructor,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_frame_get_waveform(
        self_: mlt_frame,
        w: ::std::os::raw::c_int,
        h: ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_uchar;
}
extern "C" {
    pub fn mlt_frame_push_get_image(
        self_: mlt_frame,
        get_image: mlt_get_image,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_frame_pop_get_image(self_: mlt_frame) -> mlt_get_image;
}
extern "C" {
    pub fn mlt_frame_push_frame(self_: mlt_frame, that: mlt_frame) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_frame_pop_frame(self_: mlt_frame) -> mlt_frame;
}
extern "C" {
    pub fn mlt_frame_push_service(
        self_: mlt_frame,
        that: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_frame_pop_service(self_: mlt_frame) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn mlt_frame_push_service_int(
        self_: mlt_frame,
        that: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_frame_pop_service_int(self_: mlt_frame) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_frame_push_audio(
        self_: mlt_frame,
        that: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_frame_pop_audio(self_: mlt_frame) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn mlt_frame_service_stack(self_: mlt_frame) -> mlt_deque;
}
extern "C" {
    pub fn mlt_frame_get_original_producer(self_: mlt_frame) -> mlt_producer;
}
extern "C" {
    pub fn mlt_frame_close(self_: mlt_frame);
}
extern "C" {
    pub fn mlt_frame_unique_properties(self_: mlt_frame, service: mlt_service) -> mlt_properties;
}
extern "C" {
    pub fn mlt_frame_clone(self_: mlt_frame, is_deep: ::std::os::raw::c_int) -> mlt_frame;
}
extern "C" {
    pub fn mlt_sample_calculator(
        fps: f32,
        frequency: ::std::os::raw::c_int,
        position: i64,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_sample_calculator_to_now(
        fps: f32,
        frequency: ::std::os::raw::c_int,
        position: i64,
    ) -> i64;
}
extern "C" {
    pub fn mlt_image_format_name(format: mlt_image_format) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn mlt_image_format_size(
        format: mlt_image_format,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        bpp: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_audio_format_name(format: mlt_audio_format) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn mlt_audio_format_size(
        format: mlt_audio_format,
        samples: ::std::os::raw::c_int,
        channels: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_frame_write_ppm(frame: mlt_frame);
}
extern "C" {
    pub fn mlt_image_format_planes(
        format: mlt_image_format,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        data: *mut ::std::os::raw::c_void,
        planes: *mut *mut ::std::os::raw::c_uchar,
        strides: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_image_format_id(name: *const ::std::os::raw::c_char) -> mlt_image_format;
}
extern "C" {
    pub fn mlt_channel_layout_name(layout: mlt_channel_layout) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn mlt_channel_layout_id(name: *const ::std::os::raw::c_char) -> mlt_channel_layout;
}
extern "C" {
    pub fn mlt_channel_layout_channels(layout: mlt_channel_layout) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_channel_layout_default(channels: ::std::os::raw::c_int) -> mlt_channel_layout;
}
/// \brief Filter abstract service class
///
/// A filter is a service that may modify the output of a single producer.
///
/// \extends mlt_service_s
/// \properties \em track the index of the track of a multitrack on which the filter is applied
/// \properties \em service a reference to the service to which this filter is attached.
/// \properties \em disable Set this to disable the filter while keeping it in the object model.
/// Currently this is not cleared when the filter is detached.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_filter_s {
    /// We're implementing service here
    pub parent: mlt_service_s,
    /// public virtual
    pub close: ::std::option::Option<unsafe extern "C" fn(arg1: mlt_filter)>,
    /// protected filter method
    pub process:
        ::std::option::Option<unsafe extern "C" fn(arg1: mlt_filter, arg2: mlt_frame) -> mlt_frame>,
    /// Protected
    pub child: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_mlt_filter_s() {
    assert_eq!(
        ::std::mem::size_of::<mlt_filter_s>(),
        96usize,
        concat!("Size of: ", stringify!(mlt_filter_s))
    );
    assert_eq!(
        ::std::mem::align_of::<mlt_filter_s>(),
        8usize,
        concat!("Alignment of ", stringify!(mlt_filter_s))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_filter_s>())).parent as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_filter_s),
            "::",
            stringify!(parent)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_filter_s>())).close as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_filter_s),
            "::",
            stringify!(close)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_filter_s>())).process as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_filter_s),
            "::",
            stringify!(process)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_filter_s>())).child as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_filter_s),
            "::",
            stringify!(child)
        )
    );
}
extern "C" {
    pub fn mlt_filter_init(
        self_: mlt_filter,
        child: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_filter_new() -> mlt_filter;
}
extern "C" {
    pub fn mlt_filter_service(self_: mlt_filter) -> mlt_service;
}
extern "C" {
    pub fn mlt_filter_properties(self_: mlt_filter) -> mlt_properties;
}
extern "C" {
    pub fn mlt_filter_process(self_: mlt_filter, that: mlt_frame) -> mlt_frame;
}
extern "C" {
    pub fn mlt_filter_connect(
        self_: mlt_filter,
        producer: mlt_service,
        index: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_filter_set_in_and_out(self_: mlt_filter, in_: mlt_position, out: mlt_position);
}
extern "C" {
    pub fn mlt_filter_get_track(self_: mlt_filter) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_filter_get_in(self_: mlt_filter) -> mlt_position;
}
extern "C" {
    pub fn mlt_filter_get_out(self_: mlt_filter) -> mlt_position;
}
extern "C" {
    pub fn mlt_filter_get_length(self_: mlt_filter) -> mlt_position;
}
extern "C" {
    pub fn mlt_filter_get_length2(self_: mlt_filter, frame: mlt_frame) -> mlt_position;
}
extern "C" {
    pub fn mlt_filter_get_position(self_: mlt_filter, frame: mlt_frame) -> mlt_position;
}
extern "C" {
    pub fn mlt_filter_get_progress(self_: mlt_filter, frame: mlt_frame) -> f64;
}
extern "C" {
    pub fn mlt_filter_close(arg1: mlt_filter);
}
/// \brief Producer abstract service class
///
/// A producer is a service that generates audio, video, and metadata.
/// Some day it may also generate text (subtitles). This is not to say
/// a producer "synthesizes," rather that is an origin of data within the
/// service network - that could be through synthesis or reading a stream.
///
/// \extends mlt_service
/// \event \em producer-changed either service-changed was fired or the timing of the producer changed
/// \properties \em mlt_type the name of the service subclass, e.g. mlt_producer
/// \properties \em mlt_service the name of a producer subclass
/// \properties \em _position the current position of the play head, relative to the in point
/// \properties \em _frame the current position of the play head, relative to the beginning of the resource
/// \properties \em _speed the current speed factor, where 1.0 is normal
/// \properties \em aspect_ratio sample aspect ratio
/// \properties \em length the duration of the cut in frames
/// \properties \em eof the end-of-file behavior, one of: pause, continue, loop
/// \properties \em resource the file name, stream address, or the class name in angle brackets
/// \properties \em _cut set if this producer is a "cut" producer
/// \properties \em mlt_mix stores the data for a "mix" producer
/// \properties \em _cut_parent holds a reference to the cut's parent producer
/// \properties \em ignore_points Set this to temporarily disable the in and out points.
/// \properties \em use_clone holds a reference to a clone's producer, as created by mlt_producer_optimise
/// \properties \em _clone is the index of the clone in the list of clones stored on the clone's producer
/// \properties \em _clones is the number of clones of the producer, as created by mlt_producer_optimise
/// \properties \em _clone.{N} holds a reference to the N'th clone of the producer, as created by mlt_producer_optimise
/// \properties \em meta.* holds metadata - there is a loose taxonomy to be defined
/// \properties \em set.* holds properties to set on a frame produced
/// \envvar \em MLT_DEFAULT_PRODUCER_LENGTH - the default duration of the producer in frames, defaults to 15000.
/// Most producers will set the producer length to something appropriate
/// like the real duration of an audio or video clip. However, some other things
/// like still images and generators do not have an intrinsic length besides one
/// or infinity. Those producers tend to not override the default length and one
/// expect the app or user to set the length. The default value of 15000 was chosen
/// to provide something useful - not too long or short and convenient to simply
/// set an out point without necessarily nedding to extend the length.
/// \todo define the media metadata taxonomy
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_producer_s {
    /// A producer is a service.
    pub parent: mlt_service_s,
    /// Get a frame of data (virtual function).
    ///
    /// \param mlt_producer a producer
    /// \param mlt_frame_ptr a frame pointer by reference
    /// \param int an index
    /// \return true if there was an error
    pub get_frame: ::std::option::Option<
        unsafe extern "C" fn(arg1: mlt_producer, arg2: mlt_frame_ptr, arg3: ::std::os::raw::c_int)
            -> ::std::os::raw::c_int,
    >,
    /// the destructor virtual function
    pub close: mlt_destructor,
    /// < the object supplied to the close virtual function
    pub close_object: *mut ::std::os::raw::c_void,
    /// < \private instance object
    pub local: *mut ::std::os::raw::c_void,
    /// < \private the object of a subclass
    pub child: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_mlt_producer_s() {
    assert_eq!(
        ::std::mem::size_of::<mlt_producer_s>(),
        112usize,
        concat!("Size of: ", stringify!(mlt_producer_s))
    );
    assert_eq!(
        ::std::mem::align_of::<mlt_producer_s>(),
        8usize,
        concat!("Alignment of ", stringify!(mlt_producer_s))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_producer_s>())).parent as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_producer_s),
            "::",
            stringify!(parent)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_producer_s>())).get_frame as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_producer_s),
            "::",
            stringify!(get_frame)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_producer_s>())).close as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_producer_s),
            "::",
            stringify!(close)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_producer_s>())).close_object as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_producer_s),
            "::",
            stringify!(close_object)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_producer_s>())).local as *const _ as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_producer_s),
            "::",
            stringify!(local)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_producer_s>())).child as *const _ as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_producer_s),
            "::",
            stringify!(child)
        )
    );
}
extern "C" {
    pub fn mlt_producer_init(
        self_: mlt_producer,
        child: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_producer_new(arg1: mlt_profile) -> mlt_producer;
}
extern "C" {
    pub fn mlt_producer_service(self_: mlt_producer) -> mlt_service;
}
extern "C" {
    pub fn mlt_producer_properties(self_: mlt_producer) -> mlt_properties;
}
extern "C" {
    pub fn mlt_producer_seek(self_: mlt_producer, position: mlt_position) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_producer_seek_time(
        self_: mlt_producer,
        time: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_producer_position(self_: mlt_producer) -> mlt_position;
}
extern "C" {
    pub fn mlt_producer_frame(self_: mlt_producer) -> mlt_position;
}
extern "C" {
    pub fn mlt_producer_frame_time(
        self_: mlt_producer,
        arg1: mlt_time_format,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn mlt_producer_set_speed(self_: mlt_producer, speed: f64) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_producer_get_speed(self_: mlt_producer) -> f64;
}
extern "C" {
    pub fn mlt_producer_get_fps(self_: mlt_producer) -> f64;
}
extern "C" {
    pub fn mlt_producer_set_in_and_out(
        self_: mlt_producer,
        in_: mlt_position,
        out: mlt_position,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_producer_clear(self_: mlt_producer) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_producer_get_in(self_: mlt_producer) -> mlt_position;
}
extern "C" {
    pub fn mlt_producer_get_out(self_: mlt_producer) -> mlt_position;
}
extern "C" {
    pub fn mlt_producer_get_playtime(self_: mlt_producer) -> mlt_position;
}
extern "C" {
    pub fn mlt_producer_get_length(self_: mlt_producer) -> mlt_position;
}
extern "C" {
    pub fn mlt_producer_get_length_time(
        self_: mlt_producer,
        arg1: mlt_time_format,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn mlt_producer_prepare_next(self_: mlt_producer);
}
extern "C" {
    pub fn mlt_producer_attach(self_: mlt_producer, filter: mlt_filter) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_producer_detach(self_: mlt_producer, filter: mlt_filter) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_producer_filter(self_: mlt_producer, index: ::std::os::raw::c_int) -> mlt_filter;
}
extern "C" {
    pub fn mlt_producer_cut(
        self_: mlt_producer,
        in_: ::std::os::raw::c_int,
        out: ::std::os::raw::c_int,
    ) -> mlt_producer;
}
extern "C" {
    pub fn mlt_producer_is_cut(self_: mlt_producer) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_producer_is_mix(self_: mlt_producer) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_producer_is_blank(self_: mlt_producer) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_producer_cut_parent(self_: mlt_producer) -> mlt_producer;
}
extern "C" {
    pub fn mlt_producer_optimise(self_: mlt_producer) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_producer_close(self_: mlt_producer);
}
/// \brief Track class used by mlt_multitrack_s
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_track_s {
    pub producer: mlt_producer,
    pub event: mlt_event,
}
#[test]
fn bindgen_test_layout_mlt_track_s() {
    assert_eq!(
        ::std::mem::size_of::<mlt_track_s>(),
        16usize,
        concat!("Size of: ", stringify!(mlt_track_s))
    );
    assert_eq!(
        ::std::mem::align_of::<mlt_track_s>(),
        8usize,
        concat!("Alignment of ", stringify!(mlt_track_s))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_track_s>())).producer as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_track_s),
            "::",
            stringify!(producer)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_track_s>())).event as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_track_s),
            "::",
            stringify!(event)
        )
    );
}
pub type mlt_track = *mut mlt_track_s;
/// \brief Multitrack class
///
/// A multitrack is a parallel container of producers that acts a single producer.
///
/// \extends mlt_producer_s
/// \properties \em log_id not currently used, but sets it to "mulitrack"
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_multitrack_s {
    /// We're extending producer here
    pub parent: mlt_producer_s,
    pub list: *mut mlt_track,
    pub size: ::std::os::raw::c_int,
    pub count: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_mlt_multitrack_s() {
    assert_eq!(
        ::std::mem::size_of::<mlt_multitrack_s>(),
        128usize,
        concat!("Size of: ", stringify!(mlt_multitrack_s))
    );
    assert_eq!(
        ::std::mem::align_of::<mlt_multitrack_s>(),
        8usize,
        concat!("Alignment of ", stringify!(mlt_multitrack_s))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_multitrack_s>())).parent as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_multitrack_s),
            "::",
            stringify!(parent)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_multitrack_s>())).list as *const _ as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_multitrack_s),
            "::",
            stringify!(list)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_multitrack_s>())).size as *const _ as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_multitrack_s),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_multitrack_s>())).count as *const _ as usize },
        124usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_multitrack_s),
            "::",
            stringify!(count)
        )
    );
}
extern "C" {
    pub fn mlt_multitrack_init() -> mlt_multitrack;
}
extern "C" {
    pub fn mlt_multitrack_producer(self_: mlt_multitrack) -> mlt_producer;
}
extern "C" {
    pub fn mlt_multitrack_service(self_: mlt_multitrack) -> mlt_service;
}
extern "C" {
    pub fn mlt_multitrack_properties(self_: mlt_multitrack) -> mlt_properties;
}
extern "C" {
    pub fn mlt_multitrack_connect(
        self_: mlt_multitrack,
        producer: mlt_producer,
        track: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_multitrack_insert(
        self_: mlt_multitrack,
        producer: mlt_producer,
        track: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_multitrack_disconnect(
        self_: mlt_multitrack,
        track: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_multitrack_clip(
        self_: mlt_multitrack,
        whence: mlt_whence,
        index: ::std::os::raw::c_int,
    ) -> mlt_position;
}
extern "C" {
    pub fn mlt_multitrack_close(self_: mlt_multitrack);
}
extern "C" {
    pub fn mlt_multitrack_count(self_: mlt_multitrack) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_multitrack_refresh(self_: mlt_multitrack);
}
extern "C" {
    pub fn mlt_multitrack_track(
        self_: mlt_multitrack,
        track: ::std::os::raw::c_int,
    ) -> mlt_producer;
}
/// \brief Transition abstract service class
///
/// A transition may modify the output of a producer based on the output of a second producer.
///
/// \extends mlt_service_s
/// \properties \em a_track the track index (0-based) of a multitrack of the first producer
/// \properties \em b_track the track index (0-based) of a multitrack of the second producer
/// \properties \em accepts_blanks a flag to indicate if the transition should accept blank frames
/// \properties \em always_active a flag to indicate that the in and out points do not apply
/// \properties \em _transition_type 1 for video, 2 for audio, 3 for both audio and video
/// \properties \em disable Set this to disable the transition while keeping it in the object model.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_transition_s {
    /// We're implementing service here
    pub parent: mlt_service_s,
    /// public virtual
    pub close: ::std::option::Option<unsafe extern "C" fn(arg1: mlt_transition)>,
    /// protected transition method
    pub process: ::std::option::Option<
        unsafe extern "C" fn(arg1: mlt_transition, arg2: mlt_frame, arg3: mlt_frame) -> mlt_frame,
    >,
    /// Protected
    pub child: *mut ::std::os::raw::c_void,
    /// track and in/out points
    pub producer: mlt_service,
    /// Private
    pub frames: *mut mlt_frame,
    pub held: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_mlt_transition_s() {
    assert_eq!(
        ::std::mem::size_of::<mlt_transition_s>(),
        120usize,
        concat!("Size of: ", stringify!(mlt_transition_s))
    );
    assert_eq!(
        ::std::mem::align_of::<mlt_transition_s>(),
        8usize,
        concat!("Alignment of ", stringify!(mlt_transition_s))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_transition_s>())).parent as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_transition_s),
            "::",
            stringify!(parent)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_transition_s>())).close as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_transition_s),
            "::",
            stringify!(close)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_transition_s>())).process as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_transition_s),
            "::",
            stringify!(process)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_transition_s>())).child as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_transition_s),
            "::",
            stringify!(child)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_transition_s>())).producer as *const _ as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_transition_s),
            "::",
            stringify!(producer)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_transition_s>())).frames as *const _ as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_transition_s),
            "::",
            stringify!(frames)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_transition_s>())).held as *const _ as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_transition_s),
            "::",
            stringify!(held)
        )
    );
}
extern "C" {
    pub fn mlt_transition_init(
        self_: mlt_transition,
        child: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_transition_new() -> mlt_transition;
}
extern "C" {
    pub fn mlt_transition_service(self_: mlt_transition) -> mlt_service;
}
extern "C" {
    pub fn mlt_transition_properties(self_: mlt_transition) -> mlt_properties;
}
extern "C" {
    pub fn mlt_transition_connect(
        self_: mlt_transition,
        producer: mlt_service,
        a_track: ::std::os::raw::c_int,
        b_track: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_transition_set_in_and_out(
        self_: mlt_transition,
        in_: mlt_position,
        out: mlt_position,
    );
}
extern "C" {
    pub fn mlt_transition_set_tracks(
        self_: mlt_transition,
        a_track: ::std::os::raw::c_int,
        b_track: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn mlt_transition_get_a_track(self_: mlt_transition) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_transition_get_b_track(self_: mlt_transition) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_transition_get_in(self_: mlt_transition) -> mlt_position;
}
extern "C" {
    pub fn mlt_transition_get_out(self_: mlt_transition) -> mlt_position;
}
extern "C" {
    pub fn mlt_transition_get_length(self_: mlt_transition) -> mlt_position;
}
extern "C" {
    pub fn mlt_transition_get_position(self_: mlt_transition, frame: mlt_frame) -> mlt_position;
}
extern "C" {
    pub fn mlt_transition_get_progress(self_: mlt_transition, frame: mlt_frame) -> f64;
}
extern "C" {
    pub fn mlt_transition_get_progress_delta(self_: mlt_transition, frame: mlt_frame) -> f64;
}
extern "C" {
    pub fn mlt_transition_process(
        self_: mlt_transition,
        a_frame: mlt_frame,
        b_frame: mlt_frame,
    ) -> mlt_frame;
}
extern "C" {
    pub fn mlt_transition_close(self_: mlt_transition);
}
/// \brief Consumer abstract service class
///
/// A consumer is a service that pulls audio and video from the connected
/// producers, filters, and transitions. Typically a consumer is used to
/// output audio and/or video to a device, file, or socket.
///
/// \extends mlt_service_s
/// \properties \em rescale the scaling algorithm to pass on to all scaling
/// filters, defaults to "bilinear"
/// \properties \em buffer the number of frames to use in the asynchronous
/// render thread, defaults to 25
/// \properties \em prefill the number of frames to render before commencing
/// output when real_time <> 0, defaults to the size of buffer
/// \properties \em drop_max the maximum number of consecutively dropped frames, defaults to 5
/// \properties \em frequency the audio sample rate to use in Hertz, defaults to 48000
/// \properties \em channels the number of audio channels to use, defaults to 2
/// \properties \em channel_layout the layout of the audio channels, defaults to auto.
/// other options include: mono, stereo, 5.1, 7.1, etc.
/// \properties \em real_time the asynchronous behavior: 1 (default) for asynchronous
/// with frame dropping, -1 for asynchronous without frame dropping, 0 to disable (synchronous)
/// \properties \em test_card the name of a resource to use as the test card, defaults to
/// environment variable MLT_TEST_CARD. If undefined, the hard-coded default test card is
/// white silence. A test card is what appears when nothing is produced.
/// \event \em consumer-frame-show Subclass implementations fire this immediately after showing a frame
/// or when a frame should be shown (if audio-only consumer).
/// \event \em consumer-frame-render The base class fires this immediately before rendering a frame.
/// \event \em consumer-thread-create Override the implementation of creating and
/// starting a thread by listening and responding to this (real_time 1 or -1 only).
/// \event \em consumer-thread-join Override the implementation of waiting and
/// joining a terminated thread  by listening and responding to this (real_time 1 or -1 only).
/// \event \em consumer-thread-started The base class fires when beginning execution of a rendering thread.
/// \event \em consumer-thread-stopped The base class fires when a rendering thread has ended.
/// \event \em consumer-stopping This is fired when stop was requested, but before render threads are joined.
/// \event \em consumer-stopped This is fired when the subclass implementation calls mlt_consumer_stopped().
/// \properties \em fps video frames per second as floating point (read only)
/// \properties \em frame_rate_num the numerator of the video frame rate, overrides \p mlt_profile_s
/// \properties \em frame_rate_den the denominator of the video frame rate, overrides \p mlt_profile_s
/// \properties \em width the horizontal video resolution, overrides \p mlt_profile_s
/// \properties \em height the vertical video resolution, overrides \p mlt_profile_s
/// \properties \em progressive a flag that indicates if the video is interlaced
/// or progressive, overrides \p mlt_profile_s
/// \properties \em aspect_ratio the video sample (pixel) aspect ratio as floating point (read only)
/// \properties \em sample_aspect_num the numerator of the sample aspect ratio, overrides \p mlt_profile_s
/// \properties \em sample_aspect_den the denominator of the sample aspect ratio, overrides \p mlt_profile_s
/// \properties \em display_ratio the video frame aspect ratio as floating point (read only)
/// \properties \em display_aspect_num the numerator of the video frame aspect ratio, overrides \p mlt_profile_s
/// \properties \em display_aspect_den the denominator of the video frame aspect ratio, overrides \p mlt_profile_s
/// \properties \em priority the OS scheduling priority for the render threads when real_time is not 0.
/// \properties \em top_field_first when not progressive, whether interlace field order is top-field-first, defaults to 0.
/// Set this to -1 if the consumer does not care about the field order.
/// \properties \em mlt_image_format the image format to request in rendering threads, defaults to yuv422
/// \properties \em mlt_audio_format the audio format to request in rendering threads, defaults to S16
/// \properties \em audio_off set non-zero to disable audio processing
/// \properties \em video_off set non-zero to disable video processing
/// \properties \em drop_count the number of video frames not rendered since starting consumer
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_consumer_s {
    /// A consumer is a service.
    pub parent: mlt_service_s,
    /// Start the consumer to pull frames (virtual function).
    ///
    /// \param mlt_consumer a consumer
    /// \return true if there was an error
    pub start:
        ::std::option::Option<unsafe extern "C" fn(arg1: mlt_consumer) -> ::std::os::raw::c_int>,
    /// Stop the consumer (virtual function).
    ///
    /// \param mlt_consumer a consumer
    /// \return true if there was an error
    pub stop:
        ::std::option::Option<unsafe extern "C" fn(arg1: mlt_consumer) -> ::std::os::raw::c_int>,
    /// Get whether the consumer is running or stopped (virtual function).
    ///
    /// \param mlt_consumer a consumer
    /// \return true if the consumer is stopped
    pub is_stopped:
        ::std::option::Option<unsafe extern "C" fn(arg1: mlt_consumer) -> ::std::os::raw::c_int>,
    /// Purge the consumer of buffered data (virtual function).
    ///
    /// \param mlt_consumer a consumer
    pub purge: ::std::option::Option<unsafe extern "C" fn(arg1: mlt_consumer)>,
    /// The destructor virtual function
    ///
    /// \param mlt_consumer a consumer
    pub close: ::std::option::Option<unsafe extern "C" fn(arg1: mlt_consumer)>,
    /// < \private instance object
    pub local: *mut ::std::os::raw::c_void,
    /// < \private the object of a subclass
    pub child: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_mlt_consumer_s() {
    assert_eq!(
        ::std::mem::size_of::<mlt_consumer_s>(),
        128usize,
        concat!("Size of: ", stringify!(mlt_consumer_s))
    );
    assert_eq!(
        ::std::mem::align_of::<mlt_consumer_s>(),
        8usize,
        concat!("Alignment of ", stringify!(mlt_consumer_s))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_consumer_s>())).parent as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_consumer_s),
            "::",
            stringify!(parent)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_consumer_s>())).start as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_consumer_s),
            "::",
            stringify!(start)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_consumer_s>())).stop as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_consumer_s),
            "::",
            stringify!(stop)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_consumer_s>())).is_stopped as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_consumer_s),
            "::",
            stringify!(is_stopped)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_consumer_s>())).purge as *const _ as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_consumer_s),
            "::",
            stringify!(purge)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_consumer_s>())).close as *const _ as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_consumer_s),
            "::",
            stringify!(close)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_consumer_s>())).local as *const _ as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_consumer_s),
            "::",
            stringify!(local)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_consumer_s>())).child as *const _ as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_consumer_s),
            "::",
            stringify!(child)
        )
    );
}
extern "C" {
    pub fn mlt_consumer_init(
        self_: mlt_consumer,
        child: *mut ::std::os::raw::c_void,
        profile: mlt_profile,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_consumer_new(profile: mlt_profile) -> mlt_consumer;
}
extern "C" {
    pub fn mlt_consumer_service(self_: mlt_consumer) -> mlt_service;
}
extern "C" {
    pub fn mlt_consumer_properties(self_: mlt_consumer) -> mlt_properties;
}
extern "C" {
    pub fn mlt_consumer_connect(
        self_: mlt_consumer,
        producer: mlt_service,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_consumer_start(self_: mlt_consumer) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_consumer_purge(self_: mlt_consumer);
}
extern "C" {
    pub fn mlt_consumer_put_frame(self_: mlt_consumer, frame: mlt_frame) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_consumer_get_frame(self_: mlt_consumer) -> mlt_frame;
}
extern "C" {
    pub fn mlt_consumer_rt_frame(self_: mlt_consumer) -> mlt_frame;
}
extern "C" {
    pub fn mlt_consumer_stop(self_: mlt_consumer) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_consumer_is_stopped(self_: mlt_consumer) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_consumer_stopped(self_: mlt_consumer);
}
extern "C" {
    pub fn mlt_consumer_close(arg1: mlt_consumer);
}
extern "C" {
    pub fn mlt_consumer_position(arg1: mlt_consumer) -> mlt_position;
}
/// \brief structure for returning clip information from a playlist entry
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_playlist_clip_info {
    /// < the index of the clip within the playlist
    pub clip: ::std::os::raw::c_int,
    /// < the clip's producer (or parent producer of a cut)
    pub producer: mlt_producer,
    /// < the clips' cut producer
    pub cut: mlt_producer,
    /// < the time this begins relative to the beginning of the playlist
    pub start: mlt_position,
    /// < the file name or address of the clip
    pub resource: *mut ::std::os::raw::c_char,
    /// < the clip's in point
    pub frame_in: mlt_position,
    /// < the clip's out point
    pub frame_out: mlt_position,
    /// < the duration of the clip
    pub frame_count: mlt_position,
    /// < the unedited duration of the clip
    pub length: mlt_position,
    /// < the frame rate of the clip
    pub fps: f32,
    /// < the number of times the clip is repeated
    pub repeat: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_mlt_playlist_clip_info() {
    assert_eq!(
        ::std::mem::size_of::<mlt_playlist_clip_info>(),
        64usize,
        concat!("Size of: ", stringify!(mlt_playlist_clip_info))
    );
    assert_eq!(
        ::std::mem::align_of::<mlt_playlist_clip_info>(),
        8usize,
        concat!("Alignment of ", stringify!(mlt_playlist_clip_info))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_playlist_clip_info>())).clip as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_playlist_clip_info),
            "::",
            stringify!(clip)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_playlist_clip_info>())).producer as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_playlist_clip_info),
            "::",
            stringify!(producer)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_playlist_clip_info>())).cut as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_playlist_clip_info),
            "::",
            stringify!(cut)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_playlist_clip_info>())).start as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_playlist_clip_info),
            "::",
            stringify!(start)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_playlist_clip_info>())).resource as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_playlist_clip_info),
            "::",
            stringify!(resource)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_playlist_clip_info>())).frame_in as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_playlist_clip_info),
            "::",
            stringify!(frame_in)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<mlt_playlist_clip_info>())).frame_out as *const _ as usize
        },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_playlist_clip_info),
            "::",
            stringify!(frame_out)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<mlt_playlist_clip_info>())).frame_count as *const _ as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_playlist_clip_info),
            "::",
            stringify!(frame_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_playlist_clip_info>())).length as *const _ as usize },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_playlist_clip_info),
            "::",
            stringify!(length)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_playlist_clip_info>())).fps as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_playlist_clip_info),
            "::",
            stringify!(fps)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_playlist_clip_info>())).repeat as *const _ as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_playlist_clip_info),
            "::",
            stringify!(repeat)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct playlist_entry_s {
    _unused: [u8; 0],
}
/// Playlist Entry
pub type playlist_entry = playlist_entry_s;
/// \brief Playlist class
///
/// A playlist is a sequential container of producers and blank spaces. The class provides all
/// sorts of playlist assembly and manipulation routines. A playlist is also a producer within
/// the framework.
///
/// \extends mlt_producer_s
/// \properties \em autoclose Set this true if you are doing sequential processing and want to
/// automatically close producers as they are finished being used to free resources.
/// \properties \em meta.fx_cut Set true on a producer to indicate that it is a "fx_cut,"
/// which is a way to add filters as a playlist entry - useful only in a multitrack. See FxCut on the wiki.
/// \properties \em mix_in
/// \properties \em mix_out
/// \properties \em hide Set to 1 to hide the video (make it an audio-only track),
/// 2 to hide the audio (make it a video-only track), or 3 to hide audio and video (hidden track).
/// This property only applies when using a multitrack or transition.
/// \event \em playlist-next The playlist fires this when it moves to the next item in the list.
/// The listener receives one argument that is the index of the entry that just completed.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_playlist_s {
    pub parent: mlt_producer_s,
    pub blank: mlt_producer_s,
    pub size: ::std::os::raw::c_int,
    pub count: ::std::os::raw::c_int,
    pub list: *mut *mut playlist_entry,
}
#[test]
fn bindgen_test_layout_mlt_playlist_s() {
    assert_eq!(
        ::std::mem::size_of::<mlt_playlist_s>(),
        240usize,
        concat!("Size of: ", stringify!(mlt_playlist_s))
    );
    assert_eq!(
        ::std::mem::align_of::<mlt_playlist_s>(),
        8usize,
        concat!("Alignment of ", stringify!(mlt_playlist_s))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_playlist_s>())).parent as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_playlist_s),
            "::",
            stringify!(parent)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_playlist_s>())).blank as *const _ as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_playlist_s),
            "::",
            stringify!(blank)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_playlist_s>())).size as *const _ as usize },
        224usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_playlist_s),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_playlist_s>())).count as *const _ as usize },
        228usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_playlist_s),
            "::",
            stringify!(count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_playlist_s>())).list as *const _ as usize },
        232usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_playlist_s),
            "::",
            stringify!(list)
        )
    );
}
extern "C" {
    pub fn mlt_playlist_init() -> mlt_playlist;
}
extern "C" {
    pub fn mlt_playlist_new(profile: mlt_profile) -> mlt_playlist;
}
extern "C" {
    pub fn mlt_playlist_producer(self_: mlt_playlist) -> mlt_producer;
}
extern "C" {
    pub fn mlt_playlist_service(self_: mlt_playlist) -> mlt_service;
}
extern "C" {
    pub fn mlt_playlist_properties(self_: mlt_playlist) -> mlt_properties;
}
extern "C" {
    pub fn mlt_playlist_count(self_: mlt_playlist) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_clear(self_: mlt_playlist) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_append(
        self_: mlt_playlist,
        producer: mlt_producer,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_append_io(
        self_: mlt_playlist,
        producer: mlt_producer,
        in_: mlt_position,
        out: mlt_position,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_blank(self_: mlt_playlist, out: mlt_position) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_blank_time(
        self_: mlt_playlist,
        length: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_clip(
        self_: mlt_playlist,
        whence: mlt_whence,
        index: ::std::os::raw::c_int,
    ) -> mlt_position;
}
extern "C" {
    pub fn mlt_playlist_current_clip(self_: mlt_playlist) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_current(self_: mlt_playlist) -> mlt_producer;
}
extern "C" {
    pub fn mlt_playlist_get_clip_info(
        self_: mlt_playlist,
        info: *mut mlt_playlist_clip_info,
        index: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_insert(
        self_: mlt_playlist,
        producer: mlt_producer,
        where_: ::std::os::raw::c_int,
        in_: mlt_position,
        out: mlt_position,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_remove(
        self_: mlt_playlist,
        where_: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_move(
        self_: mlt_playlist,
        from: ::std::os::raw::c_int,
        to: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_resize_clip(
        self_: mlt_playlist,
        clip: ::std::os::raw::c_int,
        in_: mlt_position,
        out: mlt_position,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_repeat_clip(
        self_: mlt_playlist,
        clip: ::std::os::raw::c_int,
        repeat: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_split(
        self_: mlt_playlist,
        clip: ::std::os::raw::c_int,
        position: mlt_position,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_split_at(
        self_: mlt_playlist,
        position: mlt_position,
        left: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_join(
        self_: mlt_playlist,
        clip: ::std::os::raw::c_int,
        count: ::std::os::raw::c_int,
        merge: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_mix(
        self_: mlt_playlist,
        clip: ::std::os::raw::c_int,
        length: ::std::os::raw::c_int,
        transition: mlt_transition,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_mix_in(
        self_: mlt_playlist,
        clip: ::std::os::raw::c_int,
        length: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_mix_out(
        self_: mlt_playlist,
        clip: ::std::os::raw::c_int,
        length: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_mix_add(
        self_: mlt_playlist,
        clip: ::std::os::raw::c_int,
        transition: mlt_transition,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_get_clip(self_: mlt_playlist, clip: ::std::os::raw::c_int) -> mlt_producer;
}
extern "C" {
    pub fn mlt_playlist_get_clip_at(self_: mlt_playlist, position: mlt_position) -> mlt_producer;
}
extern "C" {
    pub fn mlt_playlist_get_clip_index_at(
        self_: mlt_playlist,
        position: mlt_position,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_clip_is_mix(
        self_: mlt_playlist,
        clip: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_consolidate_blanks(self_: mlt_playlist, keep_length: ::std::os::raw::c_int);
}
extern "C" {
    pub fn mlt_playlist_is_blank(
        self_: mlt_playlist,
        clip: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_is_blank_at(
        self_: mlt_playlist,
        position: mlt_position,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_insert_blank(
        self_: mlt_playlist,
        clip: ::std::os::raw::c_int,
        out: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn mlt_playlist_pad_blanks(
        self_: mlt_playlist,
        position: mlt_position,
        length: ::std::os::raw::c_int,
        find: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn mlt_playlist_replace_with_blank(
        self_: mlt_playlist,
        clip: ::std::os::raw::c_int,
    ) -> mlt_producer;
}
extern "C" {
    pub fn mlt_playlist_insert_at(
        self_: mlt_playlist,
        position: mlt_position,
        producer: mlt_producer,
        mode: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_clip_start(
        self_: mlt_playlist,
        clip: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_clip_length(
        self_: mlt_playlist,
        clip: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_blanks_from(
        self_: mlt_playlist,
        clip: ::std::os::raw::c_int,
        bounded: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_remove_region(
        self_: mlt_playlist,
        position: mlt_position,
        length: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_move_region(
        self_: mlt_playlist,
        position: mlt_position,
        length: ::std::os::raw::c_int,
        new_position: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_playlist_close(self_: mlt_playlist);
}
extern "C" {
    pub fn mlt_field_init() -> mlt_field;
}
extern "C" {
    pub fn mlt_field_new(multitrack: mlt_multitrack, tractor: mlt_tractor) -> mlt_field;
}
extern "C" {
    pub fn mlt_field_service(self_: mlt_field) -> mlt_service;
}
extern "C" {
    pub fn mlt_field_tractor(self_: mlt_field) -> mlt_tractor;
}
extern "C" {
    pub fn mlt_field_multitrack(self_: mlt_field) -> mlt_multitrack;
}
extern "C" {
    pub fn mlt_field_properties(self_: mlt_field) -> mlt_properties;
}
extern "C" {
    pub fn mlt_field_plant_filter(
        self_: mlt_field,
        that: mlt_filter,
        track: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_field_plant_transition(
        self_: mlt_field,
        that: mlt_transition,
        a_track: ::std::os::raw::c_int,
        b_track: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_field_close(self_: mlt_field);
}
extern "C" {
    pub fn mlt_field_disconnect_service(self_: mlt_field, service: mlt_service);
}
/// \brief Tractor class
///
/// The tractor is a convenience class that works with the field class
/// to manage a multitrack, track filters, and transitions.
///
/// \extends mlt_producer_s
/// \properties \em multitrack holds a reference to the mulitrack object that a tractor manages
/// \properties \em field holds a reference to the field object that a tractor manages
/// \properties \em producer holds a reference to an encapsulated producer
/// \properties \em global_feed a flag to indicate whether this tractor feeds to the consumer or stops here
/// \properties \em global_queue is something for the data_feed functionality in the core module
/// \properties \em data_queue is something for the data_feed functionality in the core module
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_tractor_s {
    pub parent: mlt_producer_s,
    pub producer: mlt_service,
}
#[test]
fn bindgen_test_layout_mlt_tractor_s() {
    assert_eq!(
        ::std::mem::size_of::<mlt_tractor_s>(),
        120usize,
        concat!("Size of: ", stringify!(mlt_tractor_s))
    );
    assert_eq!(
        ::std::mem::align_of::<mlt_tractor_s>(),
        8usize,
        concat!("Alignment of ", stringify!(mlt_tractor_s))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_tractor_s>())).parent as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_tractor_s),
            "::",
            stringify!(parent)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_tractor_s>())).producer as *const _ as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_tractor_s),
            "::",
            stringify!(producer)
        )
    );
}
extern "C" {
    pub fn mlt_tractor_init() -> mlt_tractor;
}
extern "C" {
    pub fn mlt_tractor_new() -> mlt_tractor;
}
extern "C" {
    pub fn mlt_tractor_service(self_: mlt_tractor) -> mlt_service;
}
extern "C" {
    pub fn mlt_tractor_producer(self_: mlt_tractor) -> mlt_producer;
}
extern "C" {
    pub fn mlt_tractor_properties(self_: mlt_tractor) -> mlt_properties;
}
extern "C" {
    pub fn mlt_tractor_field(self_: mlt_tractor) -> mlt_field;
}
extern "C" {
    pub fn mlt_tractor_multitrack(self_: mlt_tractor) -> mlt_multitrack;
}
extern "C" {
    pub fn mlt_tractor_connect(self_: mlt_tractor, service: mlt_service) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_tractor_refresh(self_: mlt_tractor);
}
extern "C" {
    pub fn mlt_tractor_set_track(
        self_: mlt_tractor,
        producer: mlt_producer,
        index: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_tractor_insert_track(
        self_: mlt_tractor,
        producer: mlt_producer,
        index: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_tractor_remove_track(
        self_: mlt_tractor,
        index: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_tractor_get_track(self_: mlt_tractor, index: ::std::os::raw::c_int) -> mlt_producer;
}
extern "C" {
    pub fn mlt_tractor_close(self_: mlt_tractor);
}
/// \brief Tokeniser class
///
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_tokeniser_t {
    pub input: *mut ::std::os::raw::c_char,
    pub tokens: *mut *mut ::std::os::raw::c_char,
    pub count: ::std::os::raw::c_int,
    pub size: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_mlt_tokeniser_t() {
    assert_eq!(
        ::std::mem::size_of::<mlt_tokeniser_t>(),
        24usize,
        concat!("Size of: ", stringify!(mlt_tokeniser_t))
    );
    assert_eq!(
        ::std::mem::align_of::<mlt_tokeniser_t>(),
        8usize,
        concat!("Alignment of ", stringify!(mlt_tokeniser_t))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_tokeniser_t>())).input as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_tokeniser_t),
            "::",
            stringify!(input)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_tokeniser_t>())).tokens as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_tokeniser_t),
            "::",
            stringify!(tokens)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_tokeniser_t>())).count as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_tokeniser_t),
            "::",
            stringify!(count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_tokeniser_t>())).size as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_tokeniser_t),
            "::",
            stringify!(size)
        )
    );
}
pub type mlt_tokeniser = *mut mlt_tokeniser_t;
extern "C" {
    pub fn mlt_tokeniser_init() -> mlt_tokeniser;
}
extern "C" {
    pub fn mlt_tokeniser_parse_new(
        tokeniser: mlt_tokeniser,
        text: *mut ::std::os::raw::c_char,
        delimiter: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_tokeniser_get_input(tokeniser: mlt_tokeniser) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn mlt_tokeniser_count(tokeniser: mlt_tokeniser) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_tokeniser_get_string(
        tokeniser: mlt_tokeniser,
        index: ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn mlt_tokeniser_close(tokeniser: mlt_tokeniser);
}
/// \brief Parser class
///
/// \extends mlt_properties_s
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_parser_s {
    pub parent: mlt_properties_s,
    pub on_invalid: ::std::option::Option<
        unsafe extern "C" fn(self_: mlt_parser, object: mlt_service) -> ::std::os::raw::c_int,
    >,
    pub on_unknown: ::std::option::Option<
        unsafe extern "C" fn(self_: mlt_parser, object: mlt_service) -> ::std::os::raw::c_int,
    >,
    pub on_start_producer: ::std::option::Option<
        unsafe extern "C" fn(self_: mlt_parser, object: mlt_producer) -> ::std::os::raw::c_int,
    >,
    pub on_end_producer: ::std::option::Option<
        unsafe extern "C" fn(self_: mlt_parser, object: mlt_producer) -> ::std::os::raw::c_int,
    >,
    pub on_start_playlist: ::std::option::Option<
        unsafe extern "C" fn(self_: mlt_parser, object: mlt_playlist) -> ::std::os::raw::c_int,
    >,
    pub on_end_playlist: ::std::option::Option<
        unsafe extern "C" fn(self_: mlt_parser, object: mlt_playlist) -> ::std::os::raw::c_int,
    >,
    pub on_start_tractor: ::std::option::Option<
        unsafe extern "C" fn(self_: mlt_parser, object: mlt_tractor) -> ::std::os::raw::c_int,
    >,
    pub on_end_tractor: ::std::option::Option<
        unsafe extern "C" fn(self_: mlt_parser, object: mlt_tractor) -> ::std::os::raw::c_int,
    >,
    pub on_start_multitrack: ::std::option::Option<
        unsafe extern "C" fn(self_: mlt_parser, object: mlt_multitrack) -> ::std::os::raw::c_int,
    >,
    pub on_end_multitrack: ::std::option::Option<
        unsafe extern "C" fn(self_: mlt_parser, object: mlt_multitrack) -> ::std::os::raw::c_int,
    >,
    pub on_start_track:
        ::std::option::Option<unsafe extern "C" fn(self_: mlt_parser) -> ::std::os::raw::c_int>,
    pub on_end_track:
        ::std::option::Option<unsafe extern "C" fn(self_: mlt_parser) -> ::std::os::raw::c_int>,
    pub on_start_filter: ::std::option::Option<
        unsafe extern "C" fn(self_: mlt_parser, object: mlt_filter) -> ::std::os::raw::c_int,
    >,
    pub on_end_filter: ::std::option::Option<
        unsafe extern "C" fn(self_: mlt_parser, object: mlt_filter) -> ::std::os::raw::c_int,
    >,
    pub on_start_transition: ::std::option::Option<
        unsafe extern "C" fn(self_: mlt_parser, object: mlt_transition) -> ::std::os::raw::c_int,
    >,
    pub on_end_transition: ::std::option::Option<
        unsafe extern "C" fn(self_: mlt_parser, object: mlt_transition) -> ::std::os::raw::c_int,
    >,
}
#[test]
fn bindgen_test_layout_mlt_parser_s() {
    assert_eq!(
        ::std::mem::size_of::<mlt_parser_s>(),
        160usize,
        concat!("Size of: ", stringify!(mlt_parser_s))
    );
    assert_eq!(
        ::std::mem::align_of::<mlt_parser_s>(),
        8usize,
        concat!("Alignment of ", stringify!(mlt_parser_s))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_parser_s>())).parent as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_parser_s),
            "::",
            stringify!(parent)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_parser_s>())).on_invalid as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_parser_s),
            "::",
            stringify!(on_invalid)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_parser_s>())).on_unknown as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_parser_s),
            "::",
            stringify!(on_unknown)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_parser_s>())).on_start_producer as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_parser_s),
            "::",
            stringify!(on_start_producer)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_parser_s>())).on_end_producer as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_parser_s),
            "::",
            stringify!(on_end_producer)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_parser_s>())).on_start_playlist as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_parser_s),
            "::",
            stringify!(on_start_playlist)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_parser_s>())).on_end_playlist as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_parser_s),
            "::",
            stringify!(on_end_playlist)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_parser_s>())).on_start_tractor as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_parser_s),
            "::",
            stringify!(on_start_tractor)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_parser_s>())).on_end_tractor as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_parser_s),
            "::",
            stringify!(on_end_tractor)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<mlt_parser_s>())).on_start_multitrack as *const _ as usize
        },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_parser_s),
            "::",
            stringify!(on_start_multitrack)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_parser_s>())).on_end_multitrack as *const _ as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_parser_s),
            "::",
            stringify!(on_end_multitrack)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_parser_s>())).on_start_track as *const _ as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_parser_s),
            "::",
            stringify!(on_start_track)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_parser_s>())).on_end_track as *const _ as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_parser_s),
            "::",
            stringify!(on_end_track)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_parser_s>())).on_start_filter as *const _ as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_parser_s),
            "::",
            stringify!(on_start_filter)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_parser_s>())).on_end_filter as *const _ as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_parser_s),
            "::",
            stringify!(on_end_filter)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<mlt_parser_s>())).on_start_transition as *const _ as usize
        },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_parser_s),
            "::",
            stringify!(on_start_transition)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_parser_s>())).on_end_transition as *const _ as usize },
        152usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_parser_s),
            "::",
            stringify!(on_end_transition)
        )
    );
}
extern "C" {
    pub fn mlt_parser_new() -> mlt_parser;
}
extern "C" {
    pub fn mlt_parser_properties(self_: mlt_parser) -> mlt_properties;
}
extern "C" {
    pub fn mlt_parser_start(self_: mlt_parser, object: mlt_service) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_parser_close(self_: mlt_parser);
}
/// geometry animation item (deprecated)
/// \deprecated use mlt_animation_s instead
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_geometry_item_s {
    pub key: ::std::os::raw::c_int,
    pub frame: ::std::os::raw::c_int,
    pub distort: ::std::os::raw::c_int,
    pub x: f32,
    pub y: f32,
    pub w: f32,
    pub h: f32,
    pub mix: f32,
    pub f: [::std::os::raw::c_int; 5usize],
}
#[test]
fn bindgen_test_layout_mlt_geometry_item_s() {
    assert_eq!(
        ::std::mem::size_of::<mlt_geometry_item_s>(),
        52usize,
        concat!("Size of: ", stringify!(mlt_geometry_item_s))
    );
    assert_eq!(
        ::std::mem::align_of::<mlt_geometry_item_s>(),
        4usize,
        concat!("Alignment of ", stringify!(mlt_geometry_item_s))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_geometry_item_s>())).key as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_geometry_item_s),
            "::",
            stringify!(key)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_geometry_item_s>())).frame as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_geometry_item_s),
            "::",
            stringify!(frame)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_geometry_item_s>())).distort as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_geometry_item_s),
            "::",
            stringify!(distort)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_geometry_item_s>())).x as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_geometry_item_s),
            "::",
            stringify!(x)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_geometry_item_s>())).y as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_geometry_item_s),
            "::",
            stringify!(y)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_geometry_item_s>())).w as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_geometry_item_s),
            "::",
            stringify!(w)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_geometry_item_s>())).h as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_geometry_item_s),
            "::",
            stringify!(h)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_geometry_item_s>())).mix as *const _ as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_geometry_item_s),
            "::",
            stringify!(mix)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_geometry_item_s>())).f as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_geometry_item_s),
            "::",
            stringify!(f)
        )
    );
}
/// geometry object (deprecated)
/// \deprecated use mlt_animation_s instead
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mlt_geometry_s {
    pub local: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_mlt_geometry_s() {
    assert_eq!(
        ::std::mem::size_of::<mlt_geometry_s>(),
        8usize,
        concat!("Size of: ", stringify!(mlt_geometry_s))
    );
    assert_eq!(
        ::std::mem::align_of::<mlt_geometry_s>(),
        8usize,
        concat!("Alignment of ", stringify!(mlt_geometry_s))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<mlt_geometry_s>())).local as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mlt_geometry_s),
            "::",
            stringify!(local)
        )
    );
}
extern "C" {
    pub fn mlt_geometry_init() -> mlt_geometry;
}
extern "C" {
    pub fn mlt_geometry_parse(
        self_: mlt_geometry,
        data: *mut ::std::os::raw::c_char,
        length: ::std::os::raw::c_int,
        nw: ::std::os::raw::c_int,
        nh: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_geometry_refresh(
        self_: mlt_geometry,
        data: *mut ::std::os::raw::c_char,
        length: ::std::os::raw::c_int,
        nw: ::std::os::raw::c_int,
        nh: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_geometry_get_length(self_: mlt_geometry) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_geometry_set_length(self_: mlt_geometry, length: ::std::os::raw::c_int);
}
extern "C" {
    pub fn mlt_geometry_parse_item(
        self_: mlt_geometry,
        item: mlt_geometry_item,
        data: *mut ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_geometry_fetch(
        self_: mlt_geometry,
        item: mlt_geometry_item,
        position: f32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_geometry_insert(
        self_: mlt_geometry,
        item: mlt_geometry_item,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_geometry_remove(
        self_: mlt_geometry,
        position: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_geometry_interpolate(self_: mlt_geometry);
}
extern "C" {
    pub fn mlt_geometry_next_key(
        self_: mlt_geometry,
        item: mlt_geometry_item,
        position: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_geometry_prev_key(
        self_: mlt_geometry,
        item: mlt_geometry_item,
        position: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_geometry_serialise_cut(
        self_: mlt_geometry,
        in_: ::std::os::raw::c_int,
        out: ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn mlt_geometry_serialise(self_: mlt_geometry) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn mlt_geometry_close(self_: mlt_geometry);
}
extern "C" {
    pub fn mlt_log(
        service: *mut ::std::os::raw::c_void,
        level: ::std::os::raw::c_int,
        fmt: *const ::std::os::raw::c_char,
        ...
    );
}
extern "C" {
    pub fn mlt_vlog(
        service: *mut ::std::os::raw::c_void,
        level: ::std::os::raw::c_int,
        fmt: *const ::std::os::raw::c_char,
        arg1: *mut __va_list_tag,
    );
}
extern "C" {
    pub fn mlt_log_get_level() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_log_set_level(arg1: ::std::os::raw::c_int);
}
extern "C" {
    pub fn mlt_log_set_callback(
        arg1: ::std::option::Option<
            unsafe extern "C" fn(
                arg1: *mut ::std::os::raw::c_void,
                arg2: ::std::os::raw::c_int,
                arg3: *const ::std::os::raw::c_char,
                arg4: *mut __va_list_tag,
            ),
        >,
    );
}
extern "C" {
    pub fn mlt_log_timings_now() -> i64;
}
extern "C" {
    pub fn mlt_cache_item_data(
        item: mlt_cache_item,
        size: *mut ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn mlt_cache_item_close(item: mlt_cache_item);
}
extern "C" {
    pub fn mlt_cache_init() -> mlt_cache;
}
extern "C" {
    pub fn mlt_cache_set_size(cache: mlt_cache, size: ::std::os::raw::c_int);
}
extern "C" {
    pub fn mlt_cache_get_size(cache: mlt_cache) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_cache_close(cache: mlt_cache);
}
extern "C" {
    pub fn mlt_cache_purge(cache: mlt_cache, object: *mut ::std::os::raw::c_void);
}
extern "C" {
    pub fn mlt_cache_put(
        cache: mlt_cache,
        object: *mut ::std::os::raw::c_void,
        data: *mut ::std::os::raw::c_void,
        size: ::std::os::raw::c_int,
        destructor: mlt_destructor,
    );
}
extern "C" {
    pub fn mlt_cache_get(cache: mlt_cache, object: *mut ::std::os::raw::c_void) -> mlt_cache_item;
}
extern "C" {
    pub fn mlt_cache_put_frame(cache: mlt_cache, frame: mlt_frame);
}
extern "C" {
    pub fn mlt_cache_get_frame(cache: mlt_cache, position: mlt_position) -> mlt_frame;
}
extern "C" {
    pub fn mlt_version_get_int() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_version_get_major() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_version_get_minor() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_version_get_revision() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_version_get_string() -> *mut ::std::os::raw::c_char;
}
pub type mlt_slices_proc = ::std::option::Option<
    unsafe extern "C" fn(
        id: ::std::os::raw::c_int,
        idx: ::std::os::raw::c_int,
        jobs: ::std::os::raw::c_int,
        cookie: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int,
>;
extern "C" {
    pub fn mlt_slices_init(
        threads: ::std::os::raw::c_int,
        policy: ::std::os::raw::c_int,
        priority: ::std::os::raw::c_int,
    ) -> mlt_slices;
}
extern "C" {
    pub fn mlt_slices_close(ctx: mlt_slices);
}
extern "C" {
    pub fn mlt_slices_run(
        ctx: mlt_slices,
        jobs: ::std::os::raw::c_int,
        proc_: mlt_slices_proc,
        cookie: *mut ::std::os::raw::c_void,
    );
}
extern "C" {
    pub fn mlt_slices_count_normal() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_slices_count_rr() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_slices_count_fifo() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mlt_slices_run_normal(
        jobs: ::std::os::raw::c_int,
        proc_: mlt_slices_proc,
        cookie: *mut ::std::os::raw::c_void,
    );
}
extern "C" {
    pub fn mlt_slices_run_rr(
        jobs: ::std::os::raw::c_int,
        proc_: mlt_slices_proc,
        cookie: *mut ::std::os::raw::c_void,
    );
}
extern "C" {
    pub fn mlt_slices_run_fifo(
        jobs: ::std::os::raw::c_int,
        proc_: mlt_slices_proc,
        cookie: *mut ::std::os::raw::c_void,
    );
}
pub type __builtin_va_list = [__va_list_tag; 1usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __va_list_tag {
    pub gp_offset: ::std::os::raw::c_uint,
    pub fp_offset: ::std::os::raw::c_uint,
    pub overflow_arg_area: *mut ::std::os::raw::c_void,
    pub reg_save_area: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout___va_list_tag() {
    assert_eq!(
        ::std::mem::size_of::<__va_list_tag>(),
        24usize,
        concat!("Size of: ", stringify!(__va_list_tag))
    );
    assert_eq!(
        ::std::mem::align_of::<__va_list_tag>(),
        8usize,
        concat!("Alignment of ", stringify!(__va_list_tag))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__va_list_tag),
            "::",
            stringify!(gp_offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(__va_list_tag),
            "::",
            stringify!(fp_offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(__va_list_tag),
            "::",
            stringify!(overflow_arg_area)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(__va_list_tag),
            "::",
            stringify!(reg_save_area)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __locale_data {
    pub _address: u8,
}