# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.0
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError('Python 2.7 or later required')

# Import the low-level C/C++ module
if __package__ or '.' in __name__:
    from . import _mlt
else:
    import _mlt

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if name == "thisown":
        return self.this.own(value)
    if name == "this":
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if not static:
        object.__setattr__(self, name, value)
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr(self, class_type, name):
    if name == "thisown":
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class UnsignedCharArray(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, nelements):
        _mlt.UnsignedCharArray_swiginit(self, _mlt.new_UnsignedCharArray(nelements))
    __swig_destroy__ = _mlt.delete_UnsignedCharArray

    def __getitem__(self, index):
        return _mlt.UnsignedCharArray___getitem__(self, index)

    def __setitem__(self, index, value):
        return _mlt.UnsignedCharArray___setitem__(self, index, value)

    def cast(self):
        return _mlt.UnsignedCharArray_cast(self)

    @staticmethod
    def frompointer(t):
        return _mlt.UnsignedCharArray_frompointer(t)

# Register UnsignedCharArray in _mlt:
_mlt.UnsignedCharArray_swigregister(UnsignedCharArray)

def UnsignedCharArray_frompointer(t):
    return _mlt.UnsignedCharArray_frompointer(t)

PATH_MAX = _mlt.PATH_MAX
mlt_image_none = _mlt.mlt_image_none
mlt_image_rgb24 = _mlt.mlt_image_rgb24
mlt_image_rgb24a = _mlt.mlt_image_rgb24a
mlt_image_yuv422 = _mlt.mlt_image_yuv422
mlt_image_yuv420p = _mlt.mlt_image_yuv420p
mlt_image_opengl = _mlt.mlt_image_opengl
mlt_image_glsl = _mlt.mlt_image_glsl
mlt_image_glsl_texture = _mlt.mlt_image_glsl_texture
mlt_image_yuv422p16 = _mlt.mlt_image_yuv422p16
mlt_image_invalid = _mlt.mlt_image_invalid
mlt_audio_none = _mlt.mlt_audio_none
mlt_audio_pcm = _mlt.mlt_audio_pcm
mlt_audio_s16 = _mlt.mlt_audio_s16
mlt_audio_s32 = _mlt.mlt_audio_s32
mlt_audio_float = _mlt.mlt_audio_float
mlt_audio_s32le = _mlt.mlt_audio_s32le
mlt_audio_f32le = _mlt.mlt_audio_f32le
mlt_audio_u8 = _mlt.mlt_audio_u8
mlt_channel_auto = _mlt.mlt_channel_auto
mlt_channel_independent = _mlt.mlt_channel_independent
mlt_channel_mono = _mlt.mlt_channel_mono
mlt_channel_stereo = _mlt.mlt_channel_stereo
mlt_channel_2p1 = _mlt.mlt_channel_2p1
mlt_channel_3p0 = _mlt.mlt_channel_3p0
mlt_channel_3p0_back = _mlt.mlt_channel_3p0_back
mlt_channel_4p0 = _mlt.mlt_channel_4p0
mlt_channel_quad_back = _mlt.mlt_channel_quad_back
mlt_channel_quad_side = _mlt.mlt_channel_quad_side
mlt_channel_3p1 = _mlt.mlt_channel_3p1
mlt_channel_5p0_back = _mlt.mlt_channel_5p0_back
mlt_channel_5p0 = _mlt.mlt_channel_5p0
mlt_channel_4p1 = _mlt.mlt_channel_4p1
mlt_channel_5p1_back = _mlt.mlt_channel_5p1_back
mlt_channel_5p1 = _mlt.mlt_channel_5p1
mlt_channel_6p0 = _mlt.mlt_channel_6p0
mlt_channel_6p0_front = _mlt.mlt_channel_6p0_front
mlt_channel_hexagonal = _mlt.mlt_channel_hexagonal
mlt_channel_6p1 = _mlt.mlt_channel_6p1
mlt_channel_6p1_back = _mlt.mlt_channel_6p1_back
mlt_channel_6p1_front = _mlt.mlt_channel_6p1_front
mlt_channel_7p0 = _mlt.mlt_channel_7p0
mlt_channel_7p0_front = _mlt.mlt_channel_7p0_front
mlt_channel_7p1 = _mlt.mlt_channel_7p1
mlt_channel_7p1_wide_side = _mlt.mlt_channel_7p1_wide_side
mlt_channel_7p1_wide_back = _mlt.mlt_channel_7p1_wide_back
mlt_time_frames = _mlt.mlt_time_frames
mlt_time_clock = _mlt.mlt_time_clock
mlt_time_smpte_df = _mlt.mlt_time_smpte_df
mlt_time_smpte = _mlt.mlt_time_smpte
mlt_time_smpte_ndf = _mlt.mlt_time_smpte_ndf
mlt_keyframe_discrete = _mlt.mlt_keyframe_discrete
mlt_keyframe_linear = _mlt.mlt_keyframe_linear
mlt_keyframe_smooth = _mlt.mlt_keyframe_smooth
mlt_whence_relative_start = _mlt.mlt_whence_relative_start
mlt_whence_relative_current = _mlt.mlt_whence_relative_current
mlt_whence_relative_end = _mlt.mlt_whence_relative_end
invalid_type = _mlt.invalid_type
unknown_type = _mlt.unknown_type
producer_type = _mlt.producer_type
tractor_type = _mlt.tractor_type
playlist_type = _mlt.playlist_type
multitrack_type = _mlt.multitrack_type
filter_type = _mlt.filter_type
transition_type = _mlt.transition_type
consumer_type = _mlt.consumer_type
field_type = _mlt.field_type
MLT_POSITION_FMT = _mlt.MLT_POSITION_FMT
class mlt_rect(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = property(_mlt.mlt_rect_x_get, _mlt.mlt_rect_x_set)
    y = property(_mlt.mlt_rect_y_get, _mlt.mlt_rect_y_set)
    w = property(_mlt.mlt_rect_w_get, _mlt.mlt_rect_w_set)
    h = property(_mlt.mlt_rect_h_get, _mlt.mlt_rect_h_set)
    o = property(_mlt.mlt_rect_o_get, _mlt.mlt_rect_o_set)

    def __init__(self):
        _mlt.mlt_rect_swiginit(self, _mlt.new_mlt_rect())
    __swig_destroy__ = _mlt.delete_mlt_rect

# Register mlt_rect in _mlt:
_mlt.mlt_rect_swigregister(mlt_rect)

class mlt_color(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    r = property(_mlt.mlt_color_r_get, _mlt.mlt_color_r_set)
    g = property(_mlt.mlt_color_g_get, _mlt.mlt_color_g_set)
    b = property(_mlt.mlt_color_b_get, _mlt.mlt_color_b_set)
    a = property(_mlt.mlt_color_a_get, _mlt.mlt_color_a_set)

    def __init__(self):
        _mlt.mlt_color_swiginit(self, _mlt.new_mlt_color())
    __swig_destroy__ = _mlt.delete_mlt_color

# Register mlt_color in _mlt:
_mlt.mlt_color_swigregister(mlt_color)

MLT_DIRLIST_DELIMITER = _mlt.MLT_DIRLIST_DELIMITER

def mlt_factory_init(directory):
    return _mlt.mlt_factory_init(directory)

def mlt_factory_repository():
    return _mlt.mlt_factory_repository()

def mlt_factory_directory():
    return _mlt.mlt_factory_directory()

def mlt_environment(name):
    return _mlt.mlt_environment(name)

def mlt_environment_set(name, value):
    return _mlt.mlt_environment_set(name, value)

def mlt_factory_event_object():
    return _mlt.mlt_factory_event_object()

def mlt_factory_producer(profile, service, resource):
    return _mlt.mlt_factory_producer(profile, service, resource)

def mlt_factory_filter(profile, name, input):
    return _mlt.mlt_factory_filter(profile, name, input)

def mlt_factory_transition(profile, name, input):
    return _mlt.mlt_factory_transition(profile, name, input)

def mlt_factory_consumer(profile, name, input):
    return _mlt.mlt_factory_consumer(profile, name, input)

def mlt_factory_register_for_clean_up(ptr, destructor):
    return _mlt.mlt_factory_register_for_clean_up(ptr, destructor)

def mlt_factory_close():
    return _mlt.mlt_factory_close()

def mlt_global_properties():
    return _mlt.mlt_global_properties()
LIBMLT_VERSION_MAJOR = _mlt.LIBMLT_VERSION_MAJOR
LIBMLT_VERSION_MINOR = _mlt.LIBMLT_VERSION_MINOR
LIBMLT_VERSION_REVISION = _mlt.LIBMLT_VERSION_REVISION
LIBMLT_VERSION_INT = _mlt.LIBMLT_VERSION_INT
LIBMLT_VERSION = _mlt.LIBMLT_VERSION

def mlt_version_get_int():
    return _mlt.mlt_version_get_int()

def mlt_version_get_major():
    return _mlt.mlt_version_get_major()

def mlt_version_get_minor():
    return _mlt.mlt_version_get_minor()

def mlt_version_get_revision():
    return _mlt.mlt_version_get_revision()

def mlt_version_get_string():
    return _mlt.mlt_version_get_string()

def mlt_log_get_level():
    return _mlt.mlt_log_get_level()

def mlt_log_set_level(arg1):
    return _mlt.mlt_log_set_level(arg1)
class Factory(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    @staticmethod
    def init(directory=None):
        return _mlt.Factory_init(directory)

    @staticmethod
    def event_object():
        return _mlt.Factory_event_object()

    @staticmethod
    def producer(profile, id, arg=None):
        return _mlt.Factory_producer(profile, id, arg)

    @staticmethod
    def filter(profile, id, arg=None):
        return _mlt.Factory_filter(profile, id, arg)

    @staticmethod
    def transition(profile, id, arg=None):
        return _mlt.Factory_transition(profile, id, arg)

    @staticmethod
    def consumer(profile, id, arg=None):
        return _mlt.Factory_consumer(profile, id, arg)

    @staticmethod
    def close():
        return _mlt.Factory_close()

    def __init__(self):
        _mlt.Factory_swiginit(self, _mlt.new_Factory())
    __swig_destroy__ = _mlt.delete_Factory

# Register Factory in _mlt:
_mlt.Factory_swigregister(Factory)

def Factory_init(directory=None):
    return _mlt.Factory_init(directory)

def Factory_event_object():
    return _mlt.Factory_event_object()

def Factory_producer(profile, id, arg=None):
    return _mlt.Factory_producer(profile, id, arg)

def Factory_filter(profile, id, arg=None):
    return _mlt.Factory_filter(profile, id, arg)

def Factory_transition(profile, id, arg=None):
    return _mlt.Factory_transition(profile, id, arg)

def Factory_consumer(profile, id, arg=None):
    return _mlt.Factory_consumer(profile, id, arg)

def Factory_close():
    return _mlt.Factory_close()

class Repository(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _mlt.Repository_swiginit(self, _mlt.new_Repository(*args))
    __swig_destroy__ = _mlt.delete_Repository

    def register_service(self, service_type, service, symbol):
        return _mlt.Repository_register_service(self, service_type, service, symbol)

    def create(self, profile, type, service, arg):
        return _mlt.Repository_create(self, profile, type, service, arg)

    def consumers(self):
        return _mlt.Repository_consumers(self)

    def filters(self):
        return _mlt.Repository_filters(self)

    def producers(self):
        return _mlt.Repository_producers(self)

    def transitions(self):
        return _mlt.Repository_transitions(self)

    def register_metadata(self, type, service, arg4, callback_data):
        return _mlt.Repository_register_metadata(self, type, service, arg4, callback_data)

    def metadata(self, type, service):
        return _mlt.Repository_metadata(self, type, service)

    def languages(self):
        return _mlt.Repository_languages(self)

    @staticmethod
    def presets():
        return _mlt.Repository_presets()

# Register Repository in _mlt:
_mlt.Repository_swigregister(Repository)

def Repository_presets():
    return _mlt.Repository_presets()

class Event(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _mlt.Event_swiginit(self, _mlt.new_Event(*args))
    __swig_destroy__ = _mlt.delete_Event

    def get_event(self):
        return _mlt.Event_get_event(self)

    def is_valid(self):
        return _mlt.Event_is_valid(self)

    def block(self):
        return _mlt.Event_block(self)

    def unblock(self):
        return _mlt.Event_unblock(self)

# Register Event in _mlt:
_mlt.Event_swigregister(Event)

class Properties(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _mlt.Properties_swiginit(self, _mlt.new_Properties(*args))
    __swig_destroy__ = _mlt.delete_Properties

    def get_properties(self):
        return _mlt.Properties_get_properties(self)

    def inc_ref(self):
        return _mlt.Properties_inc_ref(self)

    def dec_ref(self):
        return _mlt.Properties_dec_ref(self)

    def ref_count(self):
        return _mlt.Properties_ref_count(self)

    def lock(self):
        return _mlt.Properties_lock(self)

    def unlock(self):
        return _mlt.Properties_unlock(self)

    def block(self, object=None):
        return _mlt.Properties_block(self, object)

    def unblock(self, object=None):
        return _mlt.Properties_unblock(self, object)

    def fire_event(self, event):
        return _mlt.Properties_fire_event(self, event)

    def is_valid(self):
        return _mlt.Properties_is_valid(self)

    def count(self):
        return _mlt.Properties_count(self)

    def get_int(self, name):
        return _mlt.Properties_get_int(self, name)

    def get_int64(self, name):
        return _mlt.Properties_get_int64(self, name)

    def get_double(self, name):
        return _mlt.Properties_get_double(self, name)

    def set_string(self, name, value):
        return _mlt.Properties_set_string(self, name, value)

    def pass_property(self, that, name):
        return _mlt.Properties_pass_property(self, that, name)

    def pass_values(self, that, prefix):
        return _mlt.Properties_pass_values(self, that, prefix)

    def pass_list(self, that, list):
        return _mlt.Properties_pass_list(self, that, list)

    def parse(self, namevalue):
        return _mlt.Properties_parse(self, namevalue)

    def get_name(self, index):
        return _mlt.Properties_get_name(self, index)

    def get(self, *args):
        return _mlt.Properties_get(self, *args)

    def get_data(self, *args):
        return _mlt.Properties_get_data(self, *args)

    def mirror(self, that):
        return _mlt.Properties_mirror(self, that)

    def inherit(self, that):
        return _mlt.Properties_inherit(self, that)

    def rename(self, source, dest):
        return _mlt.Properties_rename(self, source, dest)

    def dump(self, *args):
        return _mlt.Properties_dump(self, *args)

    def debug(self, *args):
        return _mlt.Properties_debug(self, *args)

    def load(self, file):
        return _mlt.Properties_load(self, file)

    def save(self, file):
        return _mlt.Properties_save(self, file)

    def listen(self, id, object, arg4):
        return _mlt.Properties_listen(self, id, object, arg4)

    @staticmethod
    def delete_event(arg1):
        return _mlt.Properties_delete_event(arg1)

    def setup_wait_for(self, id):
        return _mlt.Properties_setup_wait_for(self, id)

    def wait_for(self, *args):
        return _mlt.Properties_wait_for(self, *args)

    def is_sequence(self):
        return _mlt.Properties_is_sequence(self)

    @staticmethod
    def parse_yaml(file):
        return _mlt.Properties_parse_yaml(file)

    def serialise_yaml(self):
        return _mlt.Properties_serialise_yaml(self)

    def preset(self, name):
        return _mlt.Properties_preset(self, name)

    def set_lcnumeric(self, locale):
        return _mlt.Properties_set_lcnumeric(self, locale)

    def get_lcnumeric(self):
        return _mlt.Properties_get_lcnumeric(self)

    def clear(self, name):
        return _mlt.Properties_clear(self, name)

    def get_time(self, name, arg3=mlt_time_smpte_df):
        return _mlt.Properties_get_time(self, name, arg3)

    def frames_to_time(self, arg2, arg3=mlt_time_smpte_df):
        return _mlt.Properties_frames_to_time(self, arg2, arg3)

    def time_to_frames(self, time):
        return _mlt.Properties_time_to_frames(self, time)

    def get_color(self, name):
        return _mlt.Properties_get_color(self, name)

    def anim_get(self, name, position, length=0):
        return _mlt.Properties_anim_get(self, name, position, length)

    def anim_get_int(self, name, position, length=0):
        return _mlt.Properties_anim_get_int(self, name, position, length)

    def anim_get_double(self, name, position, length=0):
        return _mlt.Properties_anim_get_double(self, name, position, length)

    def set(self, *args):
        return _mlt.Properties_set(self, *args)

    def get_rect(self, name):
        return _mlt.Properties_get_rect(self, name)

    def anim_set(self, *args):
        return _mlt.Properties_anim_set(self, *args)

    def anim_get_rect(self, name, position, length=0):
        return _mlt.Properties_anim_get_rect(self, name, position, length)

    def get_animation(self, name):
        return _mlt.Properties_get_animation(self, name)

    def get_anim(self, name):
        return _mlt.Properties_get_anim(self, name)

# Register Properties in _mlt:
_mlt.Properties_swigregister(Properties)

def Properties_delete_event(arg1):
    return _mlt.Properties_delete_event(arg1)

def Properties_parse_yaml(file):
    return _mlt.Properties_parse_yaml(file)

class Frame(Properties):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _mlt.Frame_swiginit(self, _mlt.new_Frame(*args))
    __swig_destroy__ = _mlt.delete_Frame

    def __assign__(self, frame):
        return _mlt.Frame___assign__(self, frame)

    def get_frame(self):
        return _mlt.Frame_get_frame(self)

    def get_properties(self):
        return _mlt.Frame_get_properties(self)

    def get_image(*args): return _mlt.frame_get_image(*args)



    def fetch_image(self, format, w, h, writable=0):
        return _mlt.Frame_fetch_image(self, format, w, h, writable)

    def get_audio(self, format, frequency, channels, samples):
        return _mlt.Frame_get_audio(self, format, frequency, channels, samples)

    def get_waveform(*args): return _mlt.frame_get_waveform(*args)



    def get_original_producer(self):
        return _mlt.Frame_get_original_producer(self)

    def get_position(self):
        return _mlt.Frame_get_position(self)

    def get_unique_properties(self, service):
        return _mlt.Frame_get_unique_properties(self, service)

    def set_image(self, image, size, destroy):
        return _mlt.Frame_set_image(self, image, size, destroy)

    def set_alpha(self, alpha, size, destroy):
        return _mlt.Frame_set_alpha(self, alpha, size, destroy)

# Register Frame in _mlt:
_mlt.Frame_swigregister(Frame)

class GeometryItem(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def get_item(self):
        return _mlt.GeometryItem_get_item(self)

    def key(self):
        return _mlt.GeometryItem_key(self)

    def frame(self, *args):
        return _mlt.GeometryItem_frame(self, *args)

    def x(self, *args):
        return _mlt.GeometryItem_x(self, *args)

    def y(self, *args):
        return _mlt.GeometryItem_y(self, *args)

    def w(self, *args):
        return _mlt.GeometryItem_w(self, *args)

    def h(self, *args):
        return _mlt.GeometryItem_h(self, *args)

    def mix(self, *args):
        return _mlt.GeometryItem_mix(self, *args)

    def __init__(self):
        _mlt.GeometryItem_swiginit(self, _mlt.new_GeometryItem())
    __swig_destroy__ = _mlt.delete_GeometryItem

# Register GeometryItem in _mlt:
_mlt.GeometryItem_swigregister(GeometryItem)

class Geometry(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, data=None, length=0, nw=-1, nh=-1):
        _mlt.Geometry_swiginit(self, _mlt.new_Geometry(data, length, nw, nh))
    __swig_destroy__ = _mlt.delete_Geometry

    def parse(self, data, length, nw=-1, nh=-1):
        return _mlt.Geometry_parse(self, data, length, nw, nh)

    def fetch(self, *args):
        return _mlt.Geometry_fetch(self, *args)

    def insert(self, *args):
        return _mlt.Geometry_insert(self, *args)

    def remove(self, position):
        return _mlt.Geometry_remove(self, position)

    def interpolate(self):
        return _mlt.Geometry_interpolate(self)

    def next_key(self, *args):
        return _mlt.Geometry_next_key(self, *args)

    def prev_key(self, *args):
        return _mlt.Geometry_prev_key(self, *args)

    def serialise(self, *args):
        return _mlt.Geometry_serialise(self, *args)

# Register Geometry in _mlt:
_mlt.Geometry_swigregister(Geometry)

class Service(Properties):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _mlt.Service_swiginit(self, _mlt.new_Service(*args))
    __swig_destroy__ = _mlt.delete_Service

    def get_service(self):
        return _mlt.Service_get_service(self)

    def lock(self):
        return _mlt.Service_lock(self)

    def unlock(self):
        return _mlt.Service_unlock(self)

    def get_properties(self):
        return _mlt.Service_get_properties(self)

    def connect_producer(self, producer, index=0):
        return _mlt.Service_connect_producer(self, producer, index)

    def insert_producer(self, producer, index=0):
        return _mlt.Service_insert_producer(self, producer, index)

    def disconnect_producer(self, index=0):
        return _mlt.Service_disconnect_producer(self, index)

    def disconnect_all_producers(self):
        return _mlt.Service_disconnect_all_producers(self)

    def consumer(self):
        return _mlt.Service_consumer(self)

    def producer(self):
        return _mlt.Service_producer(self)

    def profile(self):
        return _mlt.Service_profile(self)

    def get_profile(self):
        return _mlt.Service_get_profile(self)

    def get_frame(self, index=0):
        return _mlt.Service_get_frame(self, index)

    def type(self):
        return _mlt.Service_type(self)

    def attach(self, filter):
        return _mlt.Service_attach(self, filter)

    def detach(self, filter):
        return _mlt.Service_detach(self, filter)

    def filter_count(self):
        return _mlt.Service_filter_count(self)

    def move_filter(self, _from, to):
        return _mlt.Service_move_filter(self, _from, to)

    def filter(self, index):
        return _mlt.Service_filter(self, index)

    def set_profile(self, *args):
        return _mlt.Service_set_profile(self, *args)

# Register Service in _mlt:
_mlt.Service_swigregister(Service)

class Producer(Service):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _mlt.Producer_swiginit(self, _mlt.new_Producer(*args))
    __swig_destroy__ = _mlt.delete_Producer

    def get_producer(self):
        return _mlt.Producer_get_producer(self)

    def parent(self):
        return _mlt.Producer_parent(self)

    def get_parent(self):
        return _mlt.Producer_get_parent(self)

    def get_service(self):
        return _mlt.Producer_get_service(self)

    def seek(self, *args):
        return _mlt.Producer_seek(self, *args)

    def position(self):
        return _mlt.Producer_position(self)

    def frame(self):
        return _mlt.Producer_frame(self)

    def frame_time(self, arg2=mlt_time_smpte_df):
        return _mlt.Producer_frame_time(self, arg2)

    def set_speed(self, speed):
        return _mlt.Producer_set_speed(self, speed)

    def pause(self):
        return _mlt.Producer_pause(self)

    def get_speed(self):
        return _mlt.Producer_get_speed(self)

    def get_fps(self):
        return _mlt.Producer_get_fps(self)

    def set_in_and_out(self, _in, out):
        return _mlt.Producer_set_in_and_out(self, _in, out)

    def get_in(self):
        return _mlt.Producer_get_in(self)

    def get_out(self):
        return _mlt.Producer_get_out(self)

    def get_length(self):
        return _mlt.Producer_get_length(self)

    def get_length_time(self, arg2=mlt_time_smpte_df):
        return _mlt.Producer_get_length_time(self, arg2)

    def get_playtime(self):
        return _mlt.Producer_get_playtime(self)

    def cut(self, _in=0, out=-1):
        return _mlt.Producer_cut(self, _in, out)

    def is_cut(self):
        return _mlt.Producer_is_cut(self)

    def is_blank(self):
        return _mlt.Producer_is_blank(self)

    def same_clip(self, that):
        return _mlt.Producer_same_clip(self, that)

    def runs_into(self, that):
        return _mlt.Producer_runs_into(self, that)

    def optimise(self):
        return _mlt.Producer_optimise(self)

    def clear(self):
        return _mlt.Producer_clear(self)

    def get_creation_time(self):
        return _mlt.Producer_get_creation_time(self)

    def set_creation_time(self, creation_time):
        return _mlt.Producer_set_creation_time(self, creation_time)

# Register Producer in _mlt:
_mlt.Producer_swigregister(Producer)

class Profile(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _mlt.Profile_swiginit(self, _mlt.new_Profile(*args))
    __swig_destroy__ = _mlt.delete_Profile

    def is_valid(self):
        return _mlt.Profile_is_valid(self)

    def get_profile(self):
        return _mlt.Profile_get_profile(self)

    def description(self):
        return _mlt.Profile_description(self)

    def frame_rate_num(self):
        return _mlt.Profile_frame_rate_num(self)

    def frame_rate_den(self):
        return _mlt.Profile_frame_rate_den(self)

    def fps(self):
        return _mlt.Profile_fps(self)

    def width(self):
        return _mlt.Profile_width(self)

    def height(self):
        return _mlt.Profile_height(self)

    def progressive(self):
        return _mlt.Profile_progressive(self)

    def sample_aspect_num(self):
        return _mlt.Profile_sample_aspect_num(self)

    def sample_aspect_den(self):
        return _mlt.Profile_sample_aspect_den(self)

    def sar(self):
        return _mlt.Profile_sar(self)

    def display_aspect_num(self):
        return _mlt.Profile_display_aspect_num(self)

    def display_aspect_den(self):
        return _mlt.Profile_display_aspect_den(self)

    def dar(self):
        return _mlt.Profile_dar(self)

    def is_explicit(self):
        return _mlt.Profile_is_explicit(self)

    def colorspace(self):
        return _mlt.Profile_colorspace(self)

    @staticmethod
    def list():
        return _mlt.Profile_list()

    def from_producer(self, producer):
        return _mlt.Profile_from_producer(self, producer)

    def set_width(self, width):
        return _mlt.Profile_set_width(self, width)

    def set_height(self, height):
        return _mlt.Profile_set_height(self, height)

    def set_sample_aspect(self, numerator, denominator):
        return _mlt.Profile_set_sample_aspect(self, numerator, denominator)

    def set_display_aspect(self, numerator, denominator):
        return _mlt.Profile_set_display_aspect(self, numerator, denominator)

    def set_progressive(self, progressive):
        return _mlt.Profile_set_progressive(self, progressive)

    def set_colorspace(self, colorspace):
        return _mlt.Profile_set_colorspace(self, colorspace)

    def set_frame_rate(self, numerator, denominator):
        return _mlt.Profile_set_frame_rate(self, numerator, denominator)

    def set_explicit(self, boolean):
        return _mlt.Profile_set_explicit(self, boolean)

    def scale_width(self, width):
        return _mlt.Profile_scale_width(self, width)

    def scale_height(self, height):
        return _mlt.Profile_scale_height(self, height)

# Register Profile in _mlt:
_mlt.Profile_swigregister(Profile)

def Profile_list():
    return _mlt.Profile_list()

class ClipInfo(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _mlt.ClipInfo_swiginit(self, _mlt.new_ClipInfo(*args))
    __swig_destroy__ = _mlt.delete_ClipInfo

    def update(self, info):
        return _mlt.ClipInfo_update(self, info)
    clip = property(_mlt.ClipInfo_clip_get, _mlt.ClipInfo_clip_set)
    producer = property(_mlt.ClipInfo_producer_get, _mlt.ClipInfo_producer_set)
    cut = property(_mlt.ClipInfo_cut_get, _mlt.ClipInfo_cut_set)
    start = property(_mlt.ClipInfo_start_get, _mlt.ClipInfo_start_set)
    resource = property(_mlt.ClipInfo_resource_get, _mlt.ClipInfo_resource_set)
    frame_in = property(_mlt.ClipInfo_frame_in_get, _mlt.ClipInfo_frame_in_set)
    frame_out = property(_mlt.ClipInfo_frame_out_get, _mlt.ClipInfo_frame_out_set)
    frame_count = property(_mlt.ClipInfo_frame_count_get, _mlt.ClipInfo_frame_count_set)
    length = property(_mlt.ClipInfo_length_get, _mlt.ClipInfo_length_set)
    fps = property(_mlt.ClipInfo_fps_get, _mlt.ClipInfo_fps_set)
    repeat = property(_mlt.ClipInfo_repeat_get, _mlt.ClipInfo_repeat_set)

# Register ClipInfo in _mlt:
_mlt.ClipInfo_swigregister(ClipInfo)

class Playlist(Producer):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _mlt.Playlist_swiginit(self, _mlt.new_Playlist(*args))
    __swig_destroy__ = _mlt.delete_Playlist

    def get_playlist(self):
        return _mlt.Playlist_get_playlist(self)

    def get_producer(self):
        return _mlt.Playlist_get_producer(self)

    def count(self):
        return _mlt.Playlist_count(self)

    def clear(self):
        return _mlt.Playlist_clear(self)

    def append(self, producer, _in=-1, out=-1):
        return _mlt.Playlist_append(self, producer, _in, out)

    def blank(self, *args):
        return _mlt.Playlist_blank(self, *args)

    def clip(self, whence, index):
        return _mlt.Playlist_clip(self, whence, index)

    def current_clip(self):
        return _mlt.Playlist_current_clip(self)

    def current(self):
        return _mlt.Playlist_current(self)

    def clip_info(self, index, info=None):
        return _mlt.Playlist_clip_info(self, index, info)

    @staticmethod
    def delete_clip_info(info):
        return _mlt.Playlist_delete_clip_info(info)

    def insert(self, producer, where, _in=-1, out=-1):
        return _mlt.Playlist_insert(self, producer, where, _in, out)

    def remove(self, where):
        return _mlt.Playlist_remove(self, where)

    def move(self, _from, to):
        return _mlt.Playlist_move(self, _from, to)

    def reorder(self, indices):
        return _mlt.Playlist_reorder(self, indices)

    def resize_clip(self, clip, _in, out):
        return _mlt.Playlist_resize_clip(self, clip, _in, out)

    def split(self, clip, position):
        return _mlt.Playlist_split(self, clip, position)

    def split_at(self, position, left=True):
        return _mlt.Playlist_split_at(self, position, left)

    def join(self, clip, count=1, merge=1):
        return _mlt.Playlist_join(self, clip, count, merge)

    def mix(self, clip, length, transition=None):
        return _mlt.Playlist_mix(self, clip, length, transition)

    def mix_in(self, clip, length):
        return _mlt.Playlist_mix_in(self, clip, length)

    def mix_out(self, clip, length):
        return _mlt.Playlist_mix_out(self, clip, length)

    def mix_add(self, clip, transition):
        return _mlt.Playlist_mix_add(self, clip, transition)

    def repeat(self, clip, count):
        return _mlt.Playlist_repeat(self, clip, count)

    def get_clip(self, clip):
        return _mlt.Playlist_get_clip(self, clip)

    def get_clip_at(self, position):
        return _mlt.Playlist_get_clip_at(self, position)

    def get_clip_index_at(self, position):
        return _mlt.Playlist_get_clip_index_at(self, position)

    def is_mix(self, clip):
        return _mlt.Playlist_is_mix(self, clip)

    def is_blank(self, clip):
        return _mlt.Playlist_is_blank(self, clip)

    def is_blank_at(self, position):
        return _mlt.Playlist_is_blank_at(self, position)

    def consolidate_blanks(self, keep_length=0):
        return _mlt.Playlist_consolidate_blanks(self, keep_length)

    def replace_with_blank(self, clip):
        return _mlt.Playlist_replace_with_blank(self, clip)

    def insert_blank(self, clip, out):
        return _mlt.Playlist_insert_blank(self, clip, out)

    def pad_blanks(self, position, length, find=0):
        return _mlt.Playlist_pad_blanks(self, position, length, find)

    def insert_at(self, *args):
        return _mlt.Playlist_insert_at(self, *args)

    def clip_start(self, clip):
        return _mlt.Playlist_clip_start(self, clip)

    def clip_length(self, clip):
        return _mlt.Playlist_clip_length(self, clip)

    def blanks_from(self, clip, bounded=0):
        return _mlt.Playlist_blanks_from(self, clip, bounded)

    def remove_region(self, position, length):
        return _mlt.Playlist_remove_region(self, position, length)

    def move_region(self, position, length, new_position):
        return _mlt.Playlist_move_region(self, position, length, new_position)

# Register Playlist in _mlt:
_mlt.Playlist_swigregister(Playlist)

def Playlist_delete_clip_info(info):
    return _mlt.Playlist_delete_clip_info(info)

class Consumer(Service):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _mlt.Consumer_swiginit(self, _mlt.new_Consumer(*args))
    __swig_destroy__ = _mlt.delete_Consumer

    def get_consumer(self):
        return _mlt.Consumer_get_consumer(self)

    def get_service(self):
        return _mlt.Consumer_get_service(self)

    def connect(self, service):
        return _mlt.Consumer_connect(self, service)

    def run(self):
        return _mlt.Consumer_run(self)

    def start(self):
        return _mlt.Consumer_start(self)

    def purge(self):
        return _mlt.Consumer_purge(self)

    def stop(self):
        return _mlt.Consumer_stop(self)

    def is_stopped(self):
        return _mlt.Consumer_is_stopped(self)

    def position(self):
        return _mlt.Consumer_position(self)

# Register Consumer in _mlt:
_mlt.Consumer_swigregister(Consumer)

class Filter(Service):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _mlt.Filter_swiginit(self, _mlt.new_Filter(*args))
    __swig_destroy__ = _mlt.delete_Filter

    def get_filter(self):
        return _mlt.Filter_get_filter(self)

    def get_service(self):
        return _mlt.Filter_get_service(self)

    def connect(self, service, index=0):
        return _mlt.Filter_connect(self, service, index)

    def set_in_and_out(self, _in, out):
        return _mlt.Filter_set_in_and_out(self, _in, out)

    def get_in(self):
        return _mlt.Filter_get_in(self)

    def get_out(self):
        return _mlt.Filter_get_out(self)

    def get_length(self):
        return _mlt.Filter_get_length(self)

    def get_length2(self, frame):
        return _mlt.Filter_get_length2(self, frame)

    def get_track(self):
        return _mlt.Filter_get_track(self)

    def get_position(self, frame):
        return _mlt.Filter_get_position(self, frame)

    def get_progress(self, frame):
        return _mlt.Filter_get_progress(self, frame)

    def process(self, frame):
        return _mlt.Filter_process(self, frame)

# Register Filter in _mlt:
_mlt.Filter_swigregister(Filter)

class Transition(Service):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _mlt.Transition_swiginit(self, _mlt.new_Transition(*args))
    __swig_destroy__ = _mlt.delete_Transition

    def get_transition(self):
        return _mlt.Transition_get_transition(self)

    def get_service(self):
        return _mlt.Transition_get_service(self)

    def set_in_and_out(self, _in, out):
        return _mlt.Transition_set_in_and_out(self, _in, out)

    def set_tracks(self, a_track, b_track):
        return _mlt.Transition_set_tracks(self, a_track, b_track)

    def connect(self, *args):
        return _mlt.Transition_connect(self, *args)

    def get_a_track(self):
        return _mlt.Transition_get_a_track(self)

    def get_b_track(self):
        return _mlt.Transition_get_b_track(self)

    def get_in(self):
        return _mlt.Transition_get_in(self)

    def get_out(self):
        return _mlt.Transition_get_out(self)

    def get_length(self):
        return _mlt.Transition_get_length(self)

    def get_position(self, frame):
        return _mlt.Transition_get_position(self, frame)

    def get_progress(self, frame):
        return _mlt.Transition_get_progress(self, frame)

    def get_progress_delta(self, frame):
        return _mlt.Transition_get_progress_delta(self, frame)

# Register Transition in _mlt:
_mlt.Transition_swigregister(Transition)

class Multitrack(Producer):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _mlt.Multitrack_swiginit(self, _mlt.new_Multitrack(*args))
    __swig_destroy__ = _mlt.delete_Multitrack

    def get_multitrack(self):
        return _mlt.Multitrack_get_multitrack(self)

    def get_producer(self):
        return _mlt.Multitrack_get_producer(self)

    def connect(self, producer, index):
        return _mlt.Multitrack_connect(self, producer, index)

    def insert(self, producer, index):
        return _mlt.Multitrack_insert(self, producer, index)

    def disconnect(self, index):
        return _mlt.Multitrack_disconnect(self, index)

    def clip(self, whence, index):
        return _mlt.Multitrack_clip(self, whence, index)

    def count(self):
        return _mlt.Multitrack_count(self)

    def track(self, index):
        return _mlt.Multitrack_track(self, index)

    def refresh(self):
        return _mlt.Multitrack_refresh(self)

# Register Multitrack in _mlt:
_mlt.Multitrack_swigregister(Multitrack)

class Field(Service):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _mlt.Field_swiginit(self, _mlt.new_Field(*args))
    __swig_destroy__ = _mlt.delete_Field

    def get_field(self):
        return _mlt.Field_get_field(self)

    def get_service(self):
        return _mlt.Field_get_service(self)

    def plant_filter(self, filter, track=0):
        return _mlt.Field_plant_filter(self, filter, track)

    def plant_transition(self, transition, a_track=0, b_track=1):
        return _mlt.Field_plant_transition(self, transition, a_track, b_track)

    def disconnect_service(self, service):
        return _mlt.Field_disconnect_service(self, service)

# Register Field in _mlt:
_mlt.Field_swigregister(Field)

class Tractor(Producer):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _mlt.Tractor_swiginit(self, _mlt.new_Tractor(*args))
    __swig_destroy__ = _mlt.delete_Tractor

    def get_tractor(self):
        return _mlt.Tractor_get_tractor(self)

    def get_producer(self):
        return _mlt.Tractor_get_producer(self)

    def multitrack(self):
        return _mlt.Tractor_multitrack(self)

    def field(self):
        return _mlt.Tractor_field(self)

    def refresh(self):
        return _mlt.Tractor_refresh(self)

    def set_track(self, producer, index):
        return _mlt.Tractor_set_track(self, producer, index)

    def insert_track(self, producer, index):
        return _mlt.Tractor_insert_track(self, producer, index)

    def remove_track(self, index):
        return _mlt.Tractor_remove_track(self, index)

    def track(self, index):
        return _mlt.Tractor_track(self, index)

    def count(self):
        return _mlt.Tractor_count(self)

    def plant_transition(self, *args):
        return _mlt.Tractor_plant_transition(self, *args)

    def plant_filter(self, *args):
        return _mlt.Tractor_plant_filter(self, *args)

    def locate_cut(self, producer, track, cut):
        return _mlt.Tractor_locate_cut(self, producer, track, cut)

    def connect(self, producer):
        return _mlt.Tractor_connect(self, producer)

# Register Tractor in _mlt:
_mlt.Tractor_swigregister(Tractor)

class Parser(Properties):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _mlt.Parser_swiginit(self, _mlt.new_Parser())
    __swig_destroy__ = _mlt.delete_Parser

    def start(self, service):
        return _mlt.Parser_start(self, service)

    def get_properties(self):
        return _mlt.Parser_get_properties(self)

    def on_invalid(self, object):
        return _mlt.Parser_on_invalid(self, object)

    def on_unknown(self, object):
        return _mlt.Parser_on_unknown(self, object)

    def on_start_producer(self, object):
        return _mlt.Parser_on_start_producer(self, object)

    def on_end_producer(self, object):
        return _mlt.Parser_on_end_producer(self, object)

    def on_start_playlist(self, object):
        return _mlt.Parser_on_start_playlist(self, object)

    def on_end_playlist(self, object):
        return _mlt.Parser_on_end_playlist(self, object)

    def on_start_tractor(self, object):
        return _mlt.Parser_on_start_tractor(self, object)

    def on_end_tractor(self, object):
        return _mlt.Parser_on_end_tractor(self, object)

    def on_start_multitrack(self, object):
        return _mlt.Parser_on_start_multitrack(self, object)

    def on_end_multitrack(self, object):
        return _mlt.Parser_on_end_multitrack(self, object)

    def on_start_track(self):
        return _mlt.Parser_on_start_track(self)

    def on_end_track(self):
        return _mlt.Parser_on_end_track(self)

    def on_start_filter(self, object):
        return _mlt.Parser_on_start_filter(self, object)

    def on_end_filter(self, object):
        return _mlt.Parser_on_end_filter(self, object)

    def on_start_transition(self, object):
        return _mlt.Parser_on_start_transition(self, object)

    def on_end_transition(self, object):
        return _mlt.Parser_on_end_transition(self, object)

# Register Parser in _mlt:
_mlt.Parser_swigregister(Parser)

class FilteredConsumer(Consumer):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _mlt.FilteredConsumer_swiginit(self, _mlt.new_FilteredConsumer(*args))
    __swig_destroy__ = _mlt.delete_FilteredConsumer

    def connect(self, service):
        return _mlt.FilteredConsumer_connect(self, service)

    def attach(self, filter):
        return _mlt.FilteredConsumer_attach(self, filter)

    def last(self, filter):
        return _mlt.FilteredConsumer_last(self, filter)

    def detach(self, filter):
        return _mlt.FilteredConsumer_detach(self, filter)

# Register FilteredConsumer in _mlt:
_mlt.FilteredConsumer_swigregister(FilteredConsumer)

class Animation(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _mlt.Animation_swiginit(self, _mlt.new_Animation(*args))
    __swig_destroy__ = _mlt.delete_Animation

    def is_valid(self):
        return _mlt.Animation_is_valid(self)

    def get_animation(self):
        return _mlt.Animation_get_animation(self)

    def __assign__(self, arg2):
        return _mlt.Animation___assign__(self, arg2)

    def length(self):
        return _mlt.Animation_length(self)

    def get_item(self, position, is_key, arg4):
        return _mlt.Animation_get_item(self, position, is_key, arg4)

    def is_key(self, position):
        return _mlt.Animation_is_key(self, position)

    def keyframe_type(self, position):
        return _mlt.Animation_keyframe_type(self, position)

    def next_key(self, position):
        return _mlt.Animation_next_key(self, position)

    def previous_key(self, position):
        return _mlt.Animation_previous_key(self, position)

    def key_count(self):
        return _mlt.Animation_key_count(self)

    def key_get(self, index, frame, arg4):
        return _mlt.Animation_key_get(self, index, frame, arg4)

    def key_get_frame(self, index):
        return _mlt.Animation_key_get_frame(self, index)

    def key_get_type(self, index):
        return _mlt.Animation_key_get_type(self, index)

    def key_set_type(self, index, type):
        return _mlt.Animation_key_set_type(self, index, type)

    def key_set_frame(self, index, frame):
        return _mlt.Animation_key_set_frame(self, index, frame)

    def set_length(self, length):
        return _mlt.Animation_set_length(self, length)

    def remove(self, position):
        return _mlt.Animation_remove(self, position)

    def interpolate(self):
        return _mlt.Animation_interpolate(self)

    def serialize_cut(self, *args):
        return _mlt.Animation_serialize_cut(self, *args)

# Register Animation in _mlt:
_mlt.Animation_swigregister(Animation)


def frame_get_waveform(arg1, arg2, arg3):
    return _mlt.frame_get_waveform(arg1, arg2, arg3)

def frame_get_image(arg1, arg2, arg3, arg4):
    return _mlt.frame_get_image(arg1, arg2, arg3, arg4)


