python-mlt3 0.7.6+git20120204-2 / usr / share / pyshared / mlt.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.4
#
# 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
if 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
        if fp is not None:
            try:
                _mod = imp.load_module('_mlt', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _mlt = swig_import_helper()
    del swig_import_helper
else:
    import _mlt
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
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):
        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(name)

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

try:
    _object = object
    _newclass = 1
except AttributeError:
    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, *args): 
        this = _mlt.new_unsignedCharArray(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mlt.delete_unsignedCharArray
    __del__ = lambda self : None;
    def __getitem__(self, *args): return _mlt.unsignedCharArray___getitem__(self, *args)
    def __setitem__(self, *args): return _mlt.unsignedCharArray___setitem__(self, *args)
    def cast(self): return _mlt.unsignedCharArray_cast(self)
    __swig_getmethods__["frompointer"] = lambda x: _mlt.unsignedCharArray_frompointer
    if _newclass:frompointer = staticmethod(_mlt.unsignedCharArray_frompointer)
unsignedCharArray_swigregister = _mlt.unsignedCharArray_swigregister
unsignedCharArray_swigregister(unsignedCharArray)

def unsignedCharArray_frompointer(*args):
  return _mlt.unsignedCharArray_frompointer(*args)
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_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_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

def mlt_factory_init(*args):
  return _mlt.mlt_factory_init(*args)
mlt_factory_init = _mlt.mlt_factory_init

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

def mlt_environment(*args):
  return _mlt.mlt_environment(*args)
mlt_environment = _mlt.mlt_environment

def mlt_environment_set(*args):
  return _mlt.mlt_environment_set(*args)
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(*args):
  return _mlt.mlt_factory_producer(*args)
mlt_factory_producer = _mlt.mlt_factory_producer

def mlt_factory_filter(*args):
  return _mlt.mlt_factory_filter(*args)
mlt_factory_filter = _mlt.mlt_factory_filter

def mlt_factory_transition(*args):
  return _mlt.mlt_factory_transition(*args)
mlt_factory_transition = _mlt.mlt_factory_transition

def mlt_factory_consumer(*args):
  return _mlt.mlt_factory_consumer(*args)
mlt_factory_consumer = _mlt.mlt_factory_consumer

def mlt_factory_register_for_clean_up(*args):
  return _mlt.mlt_factory_register_for_clean_up(*args)
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(*args):
  return _mlt.mlt_log_set_level(*args)
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
    __swig_getmethods__["init"] = lambda x: _mlt.Factory_init
    if _newclass:init = staticmethod(_mlt.Factory_init)
    __swig_getmethods__["event_object"] = lambda x: _mlt.Factory_event_object
    if _newclass:event_object = staticmethod(_mlt.Factory_event_object)
    __swig_getmethods__["producer"] = lambda x: _mlt.Factory_producer
    if _newclass:producer = staticmethod(_mlt.Factory_producer)
    __swig_getmethods__["filter"] = lambda x: _mlt.Factory_filter
    if _newclass:filter = staticmethod(_mlt.Factory_filter)
    __swig_getmethods__["transition"] = lambda x: _mlt.Factory_transition
    if _newclass:transition = staticmethod(_mlt.Factory_transition)
    __swig_getmethods__["consumer"] = lambda x: _mlt.Factory_consumer
    if _newclass:consumer = staticmethod(_mlt.Factory_consumer)
    __swig_getmethods__["close"] = lambda x: _mlt.Factory_close
    if _newclass:close = staticmethod(_mlt.Factory_close)
    def __init__(self): 
        this = _mlt.new_Factory()
        try: self.this.append(this)
        except: 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(*args):
  return _mlt.Factory_producer(*args)
Factory_producer = _mlt.Factory_producer

def Factory_filter(*args):
  return _mlt.Factory_filter(*args)
Factory_filter = _mlt.Factory_filter

def Factory_transition(*args):
  return _mlt.Factory_transition(*args)
Factory_transition = _mlt.Factory_transition

def Factory_consumer(*args):
  return _mlt.Factory_consumer(*args)
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: self.this = this
    __swig_destroy__ = _mlt.delete_Repository
    __del__ = lambda self : None;
    def register_service(self, *args): return _mlt.Repository_register_service(self, *args)
    def create(self, *args): return _mlt.Repository_create(self, *args)
    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, *args): return _mlt.Repository_register_metadata(self, *args)
    def metadata(self, *args): return _mlt.Repository_metadata(self, *args)
    def languages(self): return _mlt.Repository_languages(self)
    __swig_getmethods__["presets"] = lambda x: _mlt.Repository_presets
    if _newclass:presets = staticmethod(_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: 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: 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, *args): return _mlt.Properties_fire_event(self, *args)
    def is_valid(self): return _mlt.Properties_is_valid(self)
    def count(self): return _mlt.Properties_count(self)
    def get_int(self, *args): return _mlt.Properties_get_int(self, *args)
    def get_int64(self, *args): return _mlt.Properties_get_int64(self, *args)
    def get_double(self, *args): return _mlt.Properties_get_double(self, *args)
    def set(self, *args): return _mlt.Properties_set(self, *args)
    def pass_property(self, *args): return _mlt.Properties_pass_property(self, *args)
    def pass_values(self, *args): return _mlt.Properties_pass_values(self, *args)
    def pass_list(self, *args): return _mlt.Properties_pass_list(self, *args)
    def parse(self, *args): return _mlt.Properties_parse(self, *args)
    def get_name(self, *args): return _mlt.Properties_get_name(self, *args)
    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, *args): return _mlt.Properties_mirror(self, *args)
    def inherit(self, *args): return _mlt.Properties_inherit(self, *args)
    def rename(self, *args): return _mlt.Properties_rename(self, *args)
    def dump(self, *args): return _mlt.Properties_dump(self, *args)
    def debug(self, *args): return _mlt.Properties_debug(self, *args)
    def load(self, *args): return _mlt.Properties_load(self, *args)
    def save(self, *args): return _mlt.Properties_save(self, *args)
    def listen(self, *args): return _mlt.Properties_listen(self, *args)
    __swig_getmethods__["delete_event"] = lambda x: _mlt.Properties_delete_event
    if _newclass:delete_event = staticmethod(_mlt.Properties_delete_event)
    def setup_wait_for(self, *args): return _mlt.Properties_setup_wait_for(self, *args)
    def wait_for(self, *args): return _mlt.Properties_wait_for(self, *args)
    def is_sequence(self): return _mlt.Properties_is_sequence(self)
    __swig_getmethods__["parse_yaml"] = lambda x: _mlt.Properties_parse_yaml
    if _newclass:parse_yaml = staticmethod(_mlt.Properties_parse_yaml)
    def serialise_yaml(self): return _mlt.Properties_serialise_yaml(self)
    def preset(self, *args): return _mlt.Properties_preset(self, *args)
    def set_lcnumeric(self, *args): return _mlt.Properties_set_lcnumeric(self, *args)
    def get_lcnumeric(self): return _mlt.Properties_get_lcnumeric(self)
Properties_swigregister = _mlt.Properties_swigregister
Properties_swigregister(Properties)

def Properties_delete_event(*args):
  return _mlt.Properties_delete_event(*args)
Properties_delete_event = _mlt.Properties_delete_event

def Properties_parse_yaml(*args):
  return _mlt.Properties_parse_yaml(*args)
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: 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, *args): return _mlt.Frame_fetch_image(self, *args)
    def get_audio(self, *args): return _mlt.Frame_get_audio(self, *args)
    def get_waveform(*args): return _mlt.frame_get_waveform(*args)


    def get_original_producer(self): return _mlt.Frame_get_original_producer(self)
    def get_unique_properties(self, *args): return _mlt.Frame_get_unique_properties(self, *args)
    def set_image(self, *args): return _mlt.Frame_set_image(self, *args)
    def set_alpha(self, *args): return _mlt.Frame_set_alpha(self, *args)
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: 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, *args): 
        this = _mlt.new_Geometry(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mlt.delete_Geometry
    __del__ = lambda self : None;
    def parse(self, *args): return _mlt.Geometry_parse(self, *args)
    def fetch(self, *args): return _mlt.Geometry_fetch(self, *args)
    def insert(self, *args): return _mlt.Geometry_insert(self, *args)
    def remove(self, *args): return _mlt.Geometry_remove(self, *args)
    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: 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, *args): return _mlt.Service_connect_producer(self, *args)
    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_frame(self, index = 0): return _mlt.Service_get_frame(self, index)
    def type(self): return _mlt.Service_type(self)
    def attach(self, *args): return _mlt.Service_attach(self, *args)
    def detach(self, *args): return _mlt.Service_detach(self, *args)
    def filter(self, *args): return _mlt.Service_filter(self, *args)
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: 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 set_speed(self, *args): return _mlt.Producer_set_speed(self, *args)
    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, *args): return _mlt.Producer_set_in_and_out(self, *args)
    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_playtime(self): return _mlt.Producer_get_playtime(self)
    def cut(self, *args): return _mlt.Producer_cut(self, *args)
    def is_cut(self): return _mlt.Producer_is_cut(self)
    def is_blank(self): return _mlt.Producer_is_blank(self)
    def same_clip(self, *args): return _mlt.Producer_same_clip(self, *args)
    def runs_into(self, *args): return _mlt.Producer_runs_into(self, *args)
    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: self.this = this
    __swig_destroy__ = _mlt.delete_Profile
    __del__ = lambda self : None;
    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)
    __swig_getmethods__["list"] = lambda x: _mlt.Profile_list
    if _newclass:list = staticmethod(_mlt.Profile_list)
    def from_producer(self, *args): return _mlt.Profile_from_producer(self, *args)
    def set_width(self, *args): return _mlt.Profile_set_width(self, *args)
    def set_height(self, *args): return _mlt.Profile_set_height(self, *args)
    def set_sample_aspect(self, *args): return _mlt.Profile_set_sample_aspect(self, *args)
    def set_progressive(self, *args): return _mlt.Profile_set_progressive(self, *args)
    def set_colorspace(self, *args): return _mlt.Profile_set_colorspace(self, *args)
    def set_frame_rate(self, *args): return _mlt.Profile_set_frame_rate(self, *args)
    def set_explicit(self, *args): return _mlt.Profile_set_explicit(self, *args)
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: self.this = this
    __swig_destroy__ = _mlt.delete_ClipInfo
    __del__ = lambda self : None;
    def update(self, *args): return _mlt.ClipInfo_update(self, *args)
    __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: 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, *args): return _mlt.Playlist_append(self, *args)
    def blank(self, *args): return _mlt.Playlist_blank(self, *args)
    def clip(self, *args): return _mlt.Playlist_clip(self, *args)
    def current_clip(self): return _mlt.Playlist_current_clip(self)
    def current(self): return _mlt.Playlist_current(self)
    def clip_info(self, *args): return _mlt.Playlist_clip_info(self, *args)
    __swig_getmethods__["delete_clip_info"] = lambda x: _mlt.Playlist_delete_clip_info
    if _newclass:delete_clip_info = staticmethod(_mlt.Playlist_delete_clip_info)
    def insert(self, *args): return _mlt.Playlist_insert(self, *args)
    def remove(self, *args): return _mlt.Playlist_remove(self, *args)
    def move(self, *args): return _mlt.Playlist_move(self, *args)
    def resize_clip(self, *args): return _mlt.Playlist_resize_clip(self, *args)
    def split(self, *args): return _mlt.Playlist_split(self, *args)
    def split_at(self, *args): return _mlt.Playlist_split_at(self, *args)
    def join(self, *args): return _mlt.Playlist_join(self, *args)
    def mix(self, *args): return _mlt.Playlist_mix(self, *args)
    def mix_add(self, *args): return _mlt.Playlist_mix_add(self, *args)
    def repeat(self, *args): return _mlt.Playlist_repeat(self, *args)
    def get_clip(self, *args): return _mlt.Playlist_get_clip(self, *args)
    def get_clip_at(self, *args): return _mlt.Playlist_get_clip_at(self, *args)
    def get_clip_index_at(self, *args): return _mlt.Playlist_get_clip_index_at(self, *args)
    def is_mix(self, *args): return _mlt.Playlist_is_mix(self, *args)
    def is_blank(self, *args): return _mlt.Playlist_is_blank(self, *args)
    def is_blank_at(self, *args): return _mlt.Playlist_is_blank_at(self, *args)
    def consolidate_blanks(self, keep_length = 0): return _mlt.Playlist_consolidate_blanks(self, keep_length)
    def replace_with_blank(self, *args): return _mlt.Playlist_replace_with_blank(self, *args)
    def insert_blank(self, *args): return _mlt.Playlist_insert_blank(self, *args)
    def pad_blanks(self, *args): return _mlt.Playlist_pad_blanks(self, *args)
    def insert_at(self, *args): return _mlt.Playlist_insert_at(self, *args)
    def clip_start(self, *args): return _mlt.Playlist_clip_start(self, *args)
    def clip_length(self, *args): return _mlt.Playlist_clip_length(self, *args)
    def blanks_from(self, *args): return _mlt.Playlist_blanks_from(self, *args)
    def remove_region(self, *args): return _mlt.Playlist_remove_region(self, *args)
    def move_region(self, *args): return _mlt.Playlist_move_region(self, *args)
Playlist_swigregister = _mlt.Playlist_swigregister
Playlist_swigregister(Playlist)

def Playlist_delete_clip_info(*args):
  return _mlt.Playlist_delete_clip_info(*args)
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: 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, *args): return _mlt.Consumer_connect(self, *args)
    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: 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, *args): return _mlt.Filter_connect(self, *args)
    def set_in_and_out(self, *args): return _mlt.Filter_set_in_and_out(self, *args)
    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, *args): return _mlt.Filter_get_length2(self, *args)
    def get_track(self): return _mlt.Filter_get_track(self)
    def get_position(self, *args): return _mlt.Filter_get_position(self, *args)
    def get_progress(self, *args): return _mlt.Filter_get_progress(self, *args)
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: 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, *args): return _mlt.Transition_set_in_and_out(self, *args)
    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, *args): return _mlt.Transition_get_position(self, *args)
    def get_progress(self, *args): return _mlt.Transition_get_progress(self, *args)
    def get_progress_delta(self, *args): return _mlt.Transition_get_progress_delta(self, *args)
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: 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, *args): return _mlt.Multitrack_connect(self, *args)
    def clip(self, *args): return _mlt.Multitrack_clip(self, *args)
    def count(self): return _mlt.Multitrack_count(self)
    def track(self, *args): return _mlt.Multitrack_track(self, *args)
    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: 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, *args): return _mlt.Field_plant_filter(self, *args)
    def plant_transition(self, *args): return _mlt.Field_plant_transition(self, *args)
    def disconnect_service(self, *args): return _mlt.Field_disconnect_service(self, *args)
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: 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, *args): return _mlt.Tractor_set_track(self, *args)
    def track(self, *args): return _mlt.Tractor_track(self, *args)
    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, *args): return _mlt.Tractor_locate_cut(self, *args)
    def connect(self, *args): return _mlt.Tractor_connect(self, *args)
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: self.this = this
    __swig_destroy__ = _mlt.delete_Parser
    __del__ = lambda self : None;
    def start(self, *args): return _mlt.Parser_start(self, *args)
    def get_properties(self): return _mlt.Parser_get_properties(self)
    def on_invalid(self, *args): return _mlt.Parser_on_invalid(self, *args)
    def on_unknown(self, *args): return _mlt.Parser_on_unknown(self, *args)
    def on_start_producer(self, *args): return _mlt.Parser_on_start_producer(self, *args)
    def on_end_producer(self, *args): return _mlt.Parser_on_end_producer(self, *args)
    def on_start_playlist(self, *args): return _mlt.Parser_on_start_playlist(self, *args)
    def on_end_playlist(self, *args): return _mlt.Parser_on_end_playlist(self, *args)
    def on_start_tractor(self, *args): return _mlt.Parser_on_start_tractor(self, *args)
    def on_end_tractor(self, *args): return _mlt.Parser_on_end_tractor(self, *args)
    def on_start_multitrack(self, *args): return _mlt.Parser_on_start_multitrack(self, *args)
    def on_end_multitrack(self, *args): return _mlt.Parser_on_end_multitrack(self, *args)
    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, *args): return _mlt.Parser_on_start_filter(self, *args)
    def on_end_filter(self, *args): return _mlt.Parser_on_end_filter(self, *args)
    def on_start_transition(self, *args): return _mlt.Parser_on_start_transition(self, *args)
    def on_end_transition(self, *args): return _mlt.Parser_on_end_transition(self, *args)
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: self.this = this
    __swig_destroy__ = _mlt.delete_FilteredConsumer
    __del__ = lambda self : None;
    def connect(self, *args): return _mlt.FilteredConsumer_connect(self, *args)
    def attach(self, *args): return _mlt.FilteredConsumer_attach(self, *args)
    def last(self, *args): return _mlt.FilteredConsumer_last(self, *args)
    def detach(self, *args): return _mlt.FilteredConsumer_detach(self, *args)
FilteredConsumer_swigregister = _mlt.FilteredConsumer_swigregister
FilteredConsumer_swigregister(FilteredConsumer)


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

def frame_get_image(*args):
  return _mlt.frame_get_image(*args)
frame_get_image = _mlt.frame_get_image
# This file is compatible with both classic and new-style classes.