# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# 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):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_mlt')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_mlt')
    _mlt = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_mlt', [dirname(__file__)])
        except ImportError:
            import _mlt
            return _mlt
        try:
            _mod = imp.load_module('_mlt', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _mlt = swig_import_helper()
    del swig_import_helper
else:
    import _mlt
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

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):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[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,)

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

class unsignedCharArray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, unsignedCharArray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, unsignedCharArray, name)
    __repr__ = _swig_repr

    def __init__(self, nelements):
        this = _mlt.new_unsignedCharArray(nelements)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _mlt.delete_unsignedCharArray
    __del__ = lambda self: None

    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)
    if _newclass:
        frompointer = staticmethod(_mlt.unsignedCharArray_frompointer)
    else:
        frompointer = _mlt.unsignedCharArray_frompointer
unsignedCharArray_swigregister = _mlt.unsignedCharArray_swigregister
unsignedCharArray_swigregister(unsignedCharArray)

def unsignedCharArray_frompointer(t):
    return _mlt.unsignedCharArray_frompointer(t)
unsignedCharArray_frompointer = _mlt.unsignedCharArray_frompointer

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_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):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, mlt_rect, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, mlt_rect, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _mlt.mlt_rect_x_set
    __swig_getmethods__["x"] = _mlt.mlt_rect_x_get
    if _newclass:
        x = _swig_property(_mlt.mlt_rect_x_get, _mlt.mlt_rect_x_set)
    __swig_setmethods__["y"] = _mlt.mlt_rect_y_set
    __swig_getmethods__["y"] = _mlt.mlt_rect_y_get
    if _newclass:
        y = _swig_property(_mlt.mlt_rect_y_get, _mlt.mlt_rect_y_set)
    __swig_setmethods__["w"] = _mlt.mlt_rect_w_set
    __swig_getmethods__["w"] = _mlt.mlt_rect_w_get
    if _newclass:
        w = _swig_property(_mlt.mlt_rect_w_get, _mlt.mlt_rect_w_set)
    __swig_setmethods__["h"] = _mlt.mlt_rect_h_set
    __swig_getmethods__["h"] = _mlt.mlt_rect_h_get
    if _newclass:
        h = _swig_property(_mlt.mlt_rect_h_get, _mlt.mlt_rect_h_set)
    __swig_setmethods__["o"] = _mlt.mlt_rect_o_set
    __swig_getmethods__["o"] = _mlt.mlt_rect_o_get
    if _newclass:
        o = _swig_property(_mlt.mlt_rect_o_get, _mlt.mlt_rect_o_set)

    def __init__(self):
        this = _mlt.new_mlt_rect()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _mlt.delete_mlt_rect
    __del__ = lambda self: None
mlt_rect_swigregister = _mlt.mlt_rect_swigregister
mlt_rect_swigregister(mlt_rect)

class mlt_color(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, mlt_color, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, mlt_color, name)
    __repr__ = _swig_repr
    __swig_setmethods__["r"] = _mlt.mlt_color_r_set
    __swig_getmethods__["r"] = _mlt.mlt_color_r_get
    if _newclass:
        r = _swig_property(_mlt.mlt_color_r_get, _mlt.mlt_color_r_set)
    __swig_setmethods__["g"] = _mlt.mlt_color_g_set
    __swig_getmethods__["g"] = _mlt.mlt_color_g_get
    if _newclass:
        g = _swig_property(_mlt.mlt_color_g_get, _mlt.mlt_color_g_set)
    __swig_setmethods__["b"] = _mlt.mlt_color_b_set
    __swig_getmethods__["b"] = _mlt.mlt_color_b_get
    if _newclass:
        b = _swig_property(_mlt.mlt_color_b_get, _mlt.mlt_color_b_set)
    __swig_setmethods__["a"] = _mlt.mlt_color_a_set
    __swig_getmethods__["a"] = _mlt.mlt_color_a_get
    if _newclass:
        a = _swig_property(_mlt.mlt_color_a_get, _mlt.mlt_color_a_set)

    def __init__(self):
        this = _mlt.new_mlt_color()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _mlt.delete_mlt_color
    __del__ = lambda self: None
mlt_color_swigregister = _mlt.mlt_color_swigregister
mlt_color_swigregister(mlt_color)

MLT_DIRLIST_DELIMITER = _mlt.MLT_DIRLIST_DELIMITER

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

def mlt_factory_repository():
    return _mlt.mlt_factory_repository()
mlt_factory_repository = _mlt.mlt_factory_repository

def mlt_factory_directory():
    return _mlt.mlt_factory_directory()
mlt_factory_directory = _mlt.mlt_factory_directory

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

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

def mlt_factory_event_object():
    return _mlt.mlt_factory_event_object()
mlt_factory_event_object = _mlt.mlt_factory_event_object

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

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

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

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

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

def mlt_factory_close():
    return _mlt.mlt_factory_close()
mlt_factory_close = _mlt.mlt_factory_close

def mlt_global_properties():
    return _mlt.mlt_global_properties()
mlt_global_properties = _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()
mlt_version_get_int = _mlt.mlt_version_get_int

def mlt_version_get_major():
    return _mlt.mlt_version_get_major()
mlt_version_get_major = _mlt.mlt_version_get_major

def mlt_version_get_minor():
    return _mlt.mlt_version_get_minor()
mlt_version_get_minor = _mlt.mlt_version_get_minor

def mlt_version_get_revision():
    return _mlt.mlt_version_get_revision()
mlt_version_get_revision = _mlt.mlt_version_get_revision

def mlt_version_get_string():
    return _mlt.mlt_version_get_string()
mlt_version_get_string = _mlt.mlt_version_get_string

def mlt_log_get_level():
    return _mlt.mlt_log_get_level()
mlt_log_get_level = _mlt.mlt_log_get_level

def mlt_log_set_level(arg1):
    return _mlt.mlt_log_set_level(arg1)
mlt_log_set_level = _mlt.mlt_log_set_level
class Factory(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Factory, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Factory, name)
    __repr__ = _swig_repr
    if _newclass:
        init = staticmethod(_mlt.Factory_init)
    else:
        init = _mlt.Factory_init
    if _newclass:
        event_object = staticmethod(_mlt.Factory_event_object)
    else:
        event_object = _mlt.Factory_event_object
    if _newclass:
        producer = staticmethod(_mlt.Factory_producer)
    else:
        producer = _mlt.Factory_producer
    if _newclass:
        filter = staticmethod(_mlt.Factory_filter)
    else:
        filter = _mlt.Factory_filter
    if _newclass:
        transition = staticmethod(_mlt.Factory_transition)
    else:
        transition = _mlt.Factory_transition
    if _newclass:
        consumer = staticmethod(_mlt.Factory_consumer)
    else:
        consumer = _mlt.Factory_consumer
    if _newclass:
        close = staticmethod(_mlt.Factory_close)
    else:
        close = _mlt.Factory_close

    def __init__(self):
        this = _mlt.new_Factory()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _mlt.delete_Factory
    __del__ = lambda self: None
Factory_swigregister = _mlt.Factory_swigregister
Factory_swigregister(Factory)

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

def Factory_event_object():
    return _mlt.Factory_event_object()
Factory_event_object = _mlt.Factory_event_object

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

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

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

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

def Factory_close():
    return _mlt.Factory_close()
Factory_close = _mlt.Factory_close

class Repository(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Repository, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Repository, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mlt.new_Repository(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _mlt.delete_Repository
    __del__ = lambda self: None

    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)
    if _newclass:
        presets = staticmethod(_mlt.Repository_presets)
    else:
        presets = _mlt.Repository_presets
Repository_swigregister = _mlt.Repository_swigregister
Repository_swigregister(Repository)

def Repository_presets():
    return _mlt.Repository_presets()
Repository_presets = _mlt.Repository_presets

class Event(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Event, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Event, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mlt.new_Event(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _mlt.delete_Event
    __del__ = lambda self: None

    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)
Event_swigregister = _mlt.Event_swigregister
Event_swigregister(Event)

class Properties(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Properties, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Properties, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mlt.new_Properties(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _mlt.delete_Properties
    __del__ = lambda self: None

    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 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)
    if _newclass:
        delete_event = staticmethod(_mlt.Properties_delete_event)
    else:
        delete_event = _mlt.Properties_delete_event

    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)
    if _newclass:
        parse_yaml = staticmethod(_mlt.Properties_parse_yaml)
    else:
        parse_yaml = _mlt.Properties_parse_yaml

    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 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)
Properties_swigregister = _mlt.Properties_swigregister
Properties_swigregister(Properties)

def Properties_delete_event(arg2):
    return _mlt.Properties_delete_event(arg2)
Properties_delete_event = _mlt.Properties_delete_event

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

class Frame(Properties):
    __swig_setmethods__ = {}
    for _s in [Properties]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Frame, name, value)
    __swig_getmethods__ = {}
    for _s in [Properties]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Frame, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mlt.new_Frame(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _mlt.delete_Frame
    __del__ = lambda self: None

    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)
Frame_swigregister = _mlt.Frame_swigregister
Frame_swigregister(Frame)

class GeometryItem(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GeometryItem, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GeometryItem, name)
    __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):
        this = _mlt.new_GeometryItem()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _mlt.delete_GeometryItem
    __del__ = lambda self: None
GeometryItem_swigregister = _mlt.GeometryItem_swigregister
GeometryItem_swigregister(GeometryItem)

class Geometry(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Geometry, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Geometry, name)
    __repr__ = _swig_repr

    def __init__(self, data=None, length=0, nw=-1, nh=-1):
        this = _mlt.new_Geometry(data, length, nw, nh)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _mlt.delete_Geometry
    __del__ = lambda self: None

    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)
Geometry_swigregister = _mlt.Geometry_swigregister
Geometry_swigregister(Geometry)

class Service(Properties):
    __swig_setmethods__ = {}
    for _s in [Properties]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Service, name, value)
    __swig_getmethods__ = {}
    for _s in [Properties]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Service, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mlt.new_Service(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _mlt.delete_Service
    __del__ = lambda self: None

    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, arg2, to):
        return _mlt.Service_move_filter(self, arg2, to)

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

    def set_profile(self, profile):
        return _mlt.Service_set_profile(self, profile)
Service_swigregister = _mlt.Service_swigregister
Service_swigregister(Service)

class Producer(Service):
    __swig_setmethods__ = {}
    for _s in [Service]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Producer, name, value)
    __swig_getmethods__ = {}
    for _s in [Service]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Producer, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mlt.new_Producer(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _mlt.delete_Producer
    __del__ = lambda self: None

    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, arg2, out):
        return _mlt.Producer_set_in_and_out(self, arg2, 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, arg2=0, out=-1):
        return _mlt.Producer_cut(self, arg2, 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)
Producer_swigregister = _mlt.Producer_swigregister
Producer_swigregister(Producer)

class Profile(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Profile, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Profile, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mlt.new_Profile(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _mlt.delete_Profile
    __del__ = lambda self: None

    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)
    if _newclass:
        list = staticmethod(_mlt.Profile_list)
    else:
        list = _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)
Profile_swigregister = _mlt.Profile_swigregister
Profile_swigregister(Profile)

def Profile_list():
    return _mlt.Profile_list()
Profile_list = _mlt.Profile_list

class ClipInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ClipInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ClipInfo, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mlt.new_ClipInfo(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _mlt.delete_ClipInfo
    __del__ = lambda self: None

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

class Playlist(Producer):
    __swig_setmethods__ = {}
    for _s in [Producer]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Playlist, name, value)
    __swig_getmethods__ = {}
    for _s in [Producer]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Playlist, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mlt.new_Playlist(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _mlt.delete_Playlist
    __del__ = lambda self: None

    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, arg3=-1, out=-1):
        return _mlt.Playlist_append(self, producer, arg3, 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)
    if _newclass:
        delete_clip_info = staticmethod(_mlt.Playlist_delete_clip_info)
    else:
        delete_clip_info = _mlt.Playlist_delete_clip_info

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

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

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

    def resize_clip(self, clip, arg3, out):
        return _mlt.Playlist_resize_clip(self, clip, arg3, 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)
Playlist_swigregister = _mlt.Playlist_swigregister
Playlist_swigregister(Playlist)

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

class Consumer(Service):
    __swig_setmethods__ = {}
    for _s in [Service]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Consumer, name, value)
    __swig_getmethods__ = {}
    for _s in [Service]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Consumer, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mlt.new_Consumer(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _mlt.delete_Consumer
    __del__ = lambda self: None

    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)
Consumer_swigregister = _mlt.Consumer_swigregister
Consumer_swigregister(Consumer)

class Filter(Service):
    __swig_setmethods__ = {}
    for _s in [Service]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Filter, name, value)
    __swig_getmethods__ = {}
    for _s in [Service]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Filter, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mlt.new_Filter(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _mlt.delete_Filter
    __del__ = lambda self: None

    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, arg2, out):
        return _mlt.Filter_set_in_and_out(self, arg2, 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)
Filter_swigregister = _mlt.Filter_swigregister
Filter_swigregister(Filter)

class Transition(Service):
    __swig_setmethods__ = {}
    for _s in [Service]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Transition, name, value)
    __swig_getmethods__ = {}
    for _s in [Service]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Transition, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mlt.new_Transition(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _mlt.delete_Transition
    __del__ = lambda self: None

    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, arg2, out):
        return _mlt.Transition_set_in_and_out(self, arg2, out)

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

    def connect(self, producer, a_track, b_track):
        return _mlt.Transition_connect(self, producer, a_track, b_track)

    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)
Transition_swigregister = _mlt.Transition_swigregister
Transition_swigregister(Transition)

class Multitrack(Producer):
    __swig_setmethods__ = {}
    for _s in [Producer]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Multitrack, name, value)
    __swig_getmethods__ = {}
    for _s in [Producer]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Multitrack, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mlt.new_Multitrack(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _mlt.delete_Multitrack
    __del__ = lambda self: None

    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)
Multitrack_swigregister = _mlt.Multitrack_swigregister
Multitrack_swigregister(Multitrack)

class Field(Service):
    __swig_setmethods__ = {}
    for _s in [Service]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Field, name, value)
    __swig_getmethods__ = {}
    for _s in [Service]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Field, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mlt.new_Field(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _mlt.delete_Field
    __del__ = lambda self: None

    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)
Field_swigregister = _mlt.Field_swigregister
Field_swigregister(Field)

class Tractor(Producer):
    __swig_setmethods__ = {}
    for _s in [Producer]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Tractor, name, value)
    __swig_getmethods__ = {}
    for _s in [Producer]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Tractor, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mlt.new_Tractor(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _mlt.delete_Tractor
    __del__ = lambda self: None

    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)
Tractor_swigregister = _mlt.Tractor_swigregister
Tractor_swigregister(Tractor)

class Parser(Properties):
    __swig_setmethods__ = {}
    for _s in [Properties]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Parser, name, value)
    __swig_getmethods__ = {}
    for _s in [Properties]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Parser, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _mlt.new_Parser()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _mlt.delete_Parser
    __del__ = lambda self: None

    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)
Parser_swigregister = _mlt.Parser_swigregister
Parser_swigregister(Parser)

class FilteredConsumer(Consumer):
    __swig_setmethods__ = {}
    for _s in [Consumer]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FilteredConsumer, name, value)
    __swig_getmethods__ = {}
    for _s in [Consumer]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FilteredConsumer, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mlt.new_FilteredConsumer(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _mlt.delete_FilteredConsumer
    __del__ = lambda self: None

    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)
FilteredConsumer_swigregister = _mlt.FilteredConsumer_swigregister
FilteredConsumer_swigregister(FilteredConsumer)

class Animation(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Animation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Animation, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mlt.new_Animation(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _mlt.delete_Animation
    __del__ = lambda self: None

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

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

    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 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, arg2=-1, out=-1):
        return _mlt.Animation_serialize_cut(self, arg2, out)
Animation_swigregister = _mlt.Animation_swigregister
Animation_swigregister(Animation)


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

def frame_get_image(arg1, arg2, arg3, arg4):
    return _mlt.frame_get_image(arg1, arg2, arg3, arg4)
frame_get_image = _mlt.frame_get_image
# This file is compatible with both classic and new-style classes.


