python3-openshot 0.1.9+dfsg1-3build1 / usr / lib / python3 / dist-packages / openshot.py

# 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, '_openshot')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_openshot')
    _openshot = 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('_openshot', [dirname(__file__)])
        except ImportError:
            import _openshot
            return _openshot
        try:
            _mod = imp.load_module('_openshot', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _openshot = swig_import_helper()
    del swig_import_helper
else:
    import _openshot
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 SwigPyIterator(_object):
    """Proxy of C++ swig::SwigPyIterator class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _openshot.delete_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        """value(SwigPyIterator self) -> PyObject *"""
        return _openshot.SwigPyIterator_value(self)


    def incr(self, n=1):
        """
        incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        incr(SwigPyIterator self) -> SwigPyIterator
        """
        return _openshot.SwigPyIterator_incr(self, n)


    def decr(self, n=1):
        """
        decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        decr(SwigPyIterator self) -> SwigPyIterator
        """
        return _openshot.SwigPyIterator_decr(self, n)


    def distance(self, x):
        """distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
        return _openshot.SwigPyIterator_distance(self, x)


    def equal(self, x):
        """equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _openshot.SwigPyIterator_equal(self, x)


    def copy(self):
        """copy(SwigPyIterator self) -> SwigPyIterator"""
        return _openshot.SwigPyIterator_copy(self)


    def next(self):
        """next(SwigPyIterator self) -> PyObject *"""
        return _openshot.SwigPyIterator_next(self)


    def __next__(self):
        """__next__(SwigPyIterator self) -> PyObject *"""
        return _openshot.SwigPyIterator___next__(self)


    def previous(self):
        """previous(SwigPyIterator self) -> PyObject *"""
        return _openshot.SwigPyIterator_previous(self)


    def advance(self, n):
        """advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _openshot.SwigPyIterator_advance(self, n)


    def __eq__(self, x):
        """__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _openshot.SwigPyIterator___eq__(self, x)


    def __ne__(self, x):
        """__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _openshot.SwigPyIterator___ne__(self, x)


    def __iadd__(self, n):
        """__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _openshot.SwigPyIterator___iadd__(self, n)


    def __isub__(self, n):
        """__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _openshot.SwigPyIterator___isub__(self, n)


    def __add__(self, n):
        """__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _openshot.SwigPyIterator___add__(self, n)


    def __sub__(self, *args):
        """
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
        """
        return _openshot.SwigPyIterator___sub__(self, *args)

    def __iter__(self):
        return self
SwigPyIterator_swigregister = _openshot.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

SHARED_PTR_DISOWN = _openshot.SHARED_PTR_DISOWN
OPENSHOT_VERSION_MAJOR = _openshot.OPENSHOT_VERSION_MAJOR
OPENSHOT_VERSION_MINOR = _openshot.OPENSHOT_VERSION_MINOR
OPENSHOT_VERSION_BUILD = _openshot.OPENSHOT_VERSION_BUILD
OPENSHOT_VERSION_SO = _openshot.OPENSHOT_VERSION_SO
OPENSHOT_VERSION_MAJOR_MINOR = _openshot.OPENSHOT_VERSION_MAJOR_MINOR
OPENSHOT_VERSION_ALL = _openshot.OPENSHOT_VERSION_ALL
class OpenShotVersion(_object):
    """Proxy of C++ openshot::OpenShotVersion class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, OpenShotVersion, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, OpenShotVersion, name)
    __repr__ = _swig_repr
    __swig_setmethods__["major"] = _openshot.OpenShotVersion_major_set
    __swig_getmethods__["major"] = _openshot.OpenShotVersion_major_get
    if _newclass:
        major = _swig_property(_openshot.OpenShotVersion_major_get, _openshot.OpenShotVersion_major_set)
    __swig_setmethods__["minor"] = _openshot.OpenShotVersion_minor_set
    __swig_getmethods__["minor"] = _openshot.OpenShotVersion_minor_get
    if _newclass:
        minor = _swig_property(_openshot.OpenShotVersion_minor_get, _openshot.OpenShotVersion_minor_set)
    __swig_setmethods__["build"] = _openshot.OpenShotVersion_build_set
    __swig_getmethods__["build"] = _openshot.OpenShotVersion_build_get
    if _newclass:
        build = _swig_property(_openshot.OpenShotVersion_build_get, _openshot.OpenShotVersion_build_set)
    __swig_setmethods__["so"] = _openshot.OpenShotVersion_so_set
    __swig_getmethods__["so"] = _openshot.OpenShotVersion_so_get
    if _newclass:
        so = _swig_property(_openshot.OpenShotVersion_so_get, _openshot.OpenShotVersion_so_set)

    def ToString(self):
        """ToString(OpenShotVersion self) -> std::string"""
        return _openshot.OpenShotVersion_ToString(self)


    def __init__(self):
        """__init__(openshot::OpenShotVersion self) -> OpenShotVersion"""
        this = _openshot.new_OpenShotVersion()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_OpenShotVersion
    __del__ = lambda self: None
OpenShotVersion_swigregister = _openshot.OpenShotVersion_swigregister
OpenShotVersion_swigregister(OpenShotVersion)


def GetVersion():
    """GetVersion() -> OpenShotVersion"""
    return _openshot.GetVersion()
class ReaderInfo(_object):
    """Proxy of C++ openshot::ReaderInfo class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ReaderInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ReaderInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["has_video"] = _openshot.ReaderInfo_has_video_set
    __swig_getmethods__["has_video"] = _openshot.ReaderInfo_has_video_get
    if _newclass:
        has_video = _swig_property(_openshot.ReaderInfo_has_video_get, _openshot.ReaderInfo_has_video_set)
    __swig_setmethods__["has_audio"] = _openshot.ReaderInfo_has_audio_set
    __swig_getmethods__["has_audio"] = _openshot.ReaderInfo_has_audio_get
    if _newclass:
        has_audio = _swig_property(_openshot.ReaderInfo_has_audio_get, _openshot.ReaderInfo_has_audio_set)
    __swig_setmethods__["has_single_image"] = _openshot.ReaderInfo_has_single_image_set
    __swig_getmethods__["has_single_image"] = _openshot.ReaderInfo_has_single_image_get
    if _newclass:
        has_single_image = _swig_property(_openshot.ReaderInfo_has_single_image_get, _openshot.ReaderInfo_has_single_image_set)
    __swig_setmethods__["duration"] = _openshot.ReaderInfo_duration_set
    __swig_getmethods__["duration"] = _openshot.ReaderInfo_duration_get
    if _newclass:
        duration = _swig_property(_openshot.ReaderInfo_duration_get, _openshot.ReaderInfo_duration_set)
    __swig_setmethods__["file_size"] = _openshot.ReaderInfo_file_size_set
    __swig_getmethods__["file_size"] = _openshot.ReaderInfo_file_size_get
    if _newclass:
        file_size = _swig_property(_openshot.ReaderInfo_file_size_get, _openshot.ReaderInfo_file_size_set)
    __swig_setmethods__["height"] = _openshot.ReaderInfo_height_set
    __swig_getmethods__["height"] = _openshot.ReaderInfo_height_get
    if _newclass:
        height = _swig_property(_openshot.ReaderInfo_height_get, _openshot.ReaderInfo_height_set)
    __swig_setmethods__["width"] = _openshot.ReaderInfo_width_set
    __swig_getmethods__["width"] = _openshot.ReaderInfo_width_get
    if _newclass:
        width = _swig_property(_openshot.ReaderInfo_width_get, _openshot.ReaderInfo_width_set)
    __swig_setmethods__["pixel_format"] = _openshot.ReaderInfo_pixel_format_set
    __swig_getmethods__["pixel_format"] = _openshot.ReaderInfo_pixel_format_get
    if _newclass:
        pixel_format = _swig_property(_openshot.ReaderInfo_pixel_format_get, _openshot.ReaderInfo_pixel_format_set)
    __swig_setmethods__["fps"] = _openshot.ReaderInfo_fps_set
    __swig_getmethods__["fps"] = _openshot.ReaderInfo_fps_get
    if _newclass:
        fps = _swig_property(_openshot.ReaderInfo_fps_get, _openshot.ReaderInfo_fps_set)
    __swig_setmethods__["video_bit_rate"] = _openshot.ReaderInfo_video_bit_rate_set
    __swig_getmethods__["video_bit_rate"] = _openshot.ReaderInfo_video_bit_rate_get
    if _newclass:
        video_bit_rate = _swig_property(_openshot.ReaderInfo_video_bit_rate_get, _openshot.ReaderInfo_video_bit_rate_set)
    __swig_setmethods__["pixel_ratio"] = _openshot.ReaderInfo_pixel_ratio_set
    __swig_getmethods__["pixel_ratio"] = _openshot.ReaderInfo_pixel_ratio_get
    if _newclass:
        pixel_ratio = _swig_property(_openshot.ReaderInfo_pixel_ratio_get, _openshot.ReaderInfo_pixel_ratio_set)
    __swig_setmethods__["display_ratio"] = _openshot.ReaderInfo_display_ratio_set
    __swig_getmethods__["display_ratio"] = _openshot.ReaderInfo_display_ratio_get
    if _newclass:
        display_ratio = _swig_property(_openshot.ReaderInfo_display_ratio_get, _openshot.ReaderInfo_display_ratio_set)
    __swig_setmethods__["vcodec"] = _openshot.ReaderInfo_vcodec_set
    __swig_getmethods__["vcodec"] = _openshot.ReaderInfo_vcodec_get
    if _newclass:
        vcodec = _swig_property(_openshot.ReaderInfo_vcodec_get, _openshot.ReaderInfo_vcodec_set)
    __swig_setmethods__["video_length"] = _openshot.ReaderInfo_video_length_set
    __swig_getmethods__["video_length"] = _openshot.ReaderInfo_video_length_get
    if _newclass:
        video_length = _swig_property(_openshot.ReaderInfo_video_length_get, _openshot.ReaderInfo_video_length_set)
    __swig_setmethods__["video_stream_index"] = _openshot.ReaderInfo_video_stream_index_set
    __swig_getmethods__["video_stream_index"] = _openshot.ReaderInfo_video_stream_index_get
    if _newclass:
        video_stream_index = _swig_property(_openshot.ReaderInfo_video_stream_index_get, _openshot.ReaderInfo_video_stream_index_set)
    __swig_setmethods__["video_timebase"] = _openshot.ReaderInfo_video_timebase_set
    __swig_getmethods__["video_timebase"] = _openshot.ReaderInfo_video_timebase_get
    if _newclass:
        video_timebase = _swig_property(_openshot.ReaderInfo_video_timebase_get, _openshot.ReaderInfo_video_timebase_set)
    __swig_setmethods__["interlaced_frame"] = _openshot.ReaderInfo_interlaced_frame_set
    __swig_getmethods__["interlaced_frame"] = _openshot.ReaderInfo_interlaced_frame_get
    if _newclass:
        interlaced_frame = _swig_property(_openshot.ReaderInfo_interlaced_frame_get, _openshot.ReaderInfo_interlaced_frame_set)
    __swig_setmethods__["top_field_first"] = _openshot.ReaderInfo_top_field_first_set
    __swig_getmethods__["top_field_first"] = _openshot.ReaderInfo_top_field_first_get
    if _newclass:
        top_field_first = _swig_property(_openshot.ReaderInfo_top_field_first_get, _openshot.ReaderInfo_top_field_first_set)
    __swig_setmethods__["acodec"] = _openshot.ReaderInfo_acodec_set
    __swig_getmethods__["acodec"] = _openshot.ReaderInfo_acodec_get
    if _newclass:
        acodec = _swig_property(_openshot.ReaderInfo_acodec_get, _openshot.ReaderInfo_acodec_set)
    __swig_setmethods__["audio_bit_rate"] = _openshot.ReaderInfo_audio_bit_rate_set
    __swig_getmethods__["audio_bit_rate"] = _openshot.ReaderInfo_audio_bit_rate_get
    if _newclass:
        audio_bit_rate = _swig_property(_openshot.ReaderInfo_audio_bit_rate_get, _openshot.ReaderInfo_audio_bit_rate_set)
    __swig_setmethods__["sample_rate"] = _openshot.ReaderInfo_sample_rate_set
    __swig_getmethods__["sample_rate"] = _openshot.ReaderInfo_sample_rate_get
    if _newclass:
        sample_rate = _swig_property(_openshot.ReaderInfo_sample_rate_get, _openshot.ReaderInfo_sample_rate_set)
    __swig_setmethods__["channels"] = _openshot.ReaderInfo_channels_set
    __swig_getmethods__["channels"] = _openshot.ReaderInfo_channels_get
    if _newclass:
        channels = _swig_property(_openshot.ReaderInfo_channels_get, _openshot.ReaderInfo_channels_set)
    __swig_setmethods__["channel_layout"] = _openshot.ReaderInfo_channel_layout_set
    __swig_getmethods__["channel_layout"] = _openshot.ReaderInfo_channel_layout_get
    if _newclass:
        channel_layout = _swig_property(_openshot.ReaderInfo_channel_layout_get, _openshot.ReaderInfo_channel_layout_set)
    __swig_setmethods__["audio_stream_index"] = _openshot.ReaderInfo_audio_stream_index_set
    __swig_getmethods__["audio_stream_index"] = _openshot.ReaderInfo_audio_stream_index_get
    if _newclass:
        audio_stream_index = _swig_property(_openshot.ReaderInfo_audio_stream_index_get, _openshot.ReaderInfo_audio_stream_index_set)
    __swig_setmethods__["audio_timebase"] = _openshot.ReaderInfo_audio_timebase_set
    __swig_getmethods__["audio_timebase"] = _openshot.ReaderInfo_audio_timebase_get
    if _newclass:
        audio_timebase = _swig_property(_openshot.ReaderInfo_audio_timebase_get, _openshot.ReaderInfo_audio_timebase_set)

    def __init__(self):
        """__init__(openshot::ReaderInfo self) -> ReaderInfo"""
        this = _openshot.new_ReaderInfo()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_ReaderInfo
    __del__ = lambda self: None
ReaderInfo_swigregister = _openshot.ReaderInfo_swigregister
ReaderInfo_swigregister(ReaderInfo)

class ReaderBase(_object):
    """Proxy of C++ openshot::ReaderBase class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ReaderBase, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ReaderBase, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_setmethods__["info"] = _openshot.ReaderBase_info_set
    __swig_getmethods__["info"] = _openshot.ReaderBase_info_get
    if _newclass:
        info = _swig_property(_openshot.ReaderBase_info_get, _openshot.ReaderBase_info_set)

    def Close(self):
        """Close(ReaderBase self)"""
        return _openshot.ReaderBase_Close(self)


    def DisplayInfo(self):
        """DisplayInfo(ReaderBase self)"""
        return _openshot.ReaderBase_DisplayInfo(self)


    def GetCache(self):
        """GetCache(ReaderBase self) -> CacheBase"""
        return _openshot.ReaderBase_GetCache(self)


    def GetFrame(self, number):
        """GetFrame(ReaderBase self, int64_t number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.ReaderBase_GetFrame(self, number)


    def IsOpen(self):
        """IsOpen(ReaderBase self) -> bool"""
        return _openshot.ReaderBase_IsOpen(self)


    def Name(self):
        """Name(ReaderBase self) -> std::string"""
        return _openshot.ReaderBase_Name(self)


    def Json(self):
        """Json(ReaderBase self) -> std::string"""
        return _openshot.ReaderBase_Json(self)


    def SetJson(self, value):
        """SetJson(ReaderBase self, std::string value)"""
        return _openshot.ReaderBase_SetJson(self, value)


    def JsonValue(self):
        """JsonValue(ReaderBase self) -> Json::Value"""
        return _openshot.ReaderBase_JsonValue(self)


    def SetJsonValue(self, root):
        """SetJsonValue(ReaderBase self, Json::Value root)"""
        return _openshot.ReaderBase_SetJsonValue(self, root)


    def SetMaxSize(self, width, height):
        """SetMaxSize(ReaderBase self, int width, int height)"""
        return _openshot.ReaderBase_SetMaxSize(self, width, height)


    def Open(self):
        """Open(ReaderBase self)"""
        return _openshot.ReaderBase_Open(self)

    __swig_destroy__ = _openshot.delete_ReaderBase
    __del__ = lambda self: None
ReaderBase_swigregister = _openshot.ReaderBase_swigregister
ReaderBase_swigregister(ReaderBase)

class WriterInfo(_object):
    """Proxy of C++ openshot::WriterInfo class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WriterInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WriterInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["has_video"] = _openshot.WriterInfo_has_video_set
    __swig_getmethods__["has_video"] = _openshot.WriterInfo_has_video_get
    if _newclass:
        has_video = _swig_property(_openshot.WriterInfo_has_video_get, _openshot.WriterInfo_has_video_set)
    __swig_setmethods__["has_audio"] = _openshot.WriterInfo_has_audio_set
    __swig_getmethods__["has_audio"] = _openshot.WriterInfo_has_audio_get
    if _newclass:
        has_audio = _swig_property(_openshot.WriterInfo_has_audio_get, _openshot.WriterInfo_has_audio_set)
    __swig_setmethods__["has_single_image"] = _openshot.WriterInfo_has_single_image_set
    __swig_getmethods__["has_single_image"] = _openshot.WriterInfo_has_single_image_get
    if _newclass:
        has_single_image = _swig_property(_openshot.WriterInfo_has_single_image_get, _openshot.WriterInfo_has_single_image_set)
    __swig_setmethods__["duration"] = _openshot.WriterInfo_duration_set
    __swig_getmethods__["duration"] = _openshot.WriterInfo_duration_get
    if _newclass:
        duration = _swig_property(_openshot.WriterInfo_duration_get, _openshot.WriterInfo_duration_set)
    __swig_setmethods__["file_size"] = _openshot.WriterInfo_file_size_set
    __swig_getmethods__["file_size"] = _openshot.WriterInfo_file_size_get
    if _newclass:
        file_size = _swig_property(_openshot.WriterInfo_file_size_get, _openshot.WriterInfo_file_size_set)
    __swig_setmethods__["height"] = _openshot.WriterInfo_height_set
    __swig_getmethods__["height"] = _openshot.WriterInfo_height_get
    if _newclass:
        height = _swig_property(_openshot.WriterInfo_height_get, _openshot.WriterInfo_height_set)
    __swig_setmethods__["width"] = _openshot.WriterInfo_width_set
    __swig_getmethods__["width"] = _openshot.WriterInfo_width_get
    if _newclass:
        width = _swig_property(_openshot.WriterInfo_width_get, _openshot.WriterInfo_width_set)
    __swig_setmethods__["pixel_format"] = _openshot.WriterInfo_pixel_format_set
    __swig_getmethods__["pixel_format"] = _openshot.WriterInfo_pixel_format_get
    if _newclass:
        pixel_format = _swig_property(_openshot.WriterInfo_pixel_format_get, _openshot.WriterInfo_pixel_format_set)
    __swig_setmethods__["fps"] = _openshot.WriterInfo_fps_set
    __swig_getmethods__["fps"] = _openshot.WriterInfo_fps_get
    if _newclass:
        fps = _swig_property(_openshot.WriterInfo_fps_get, _openshot.WriterInfo_fps_set)
    __swig_setmethods__["video_bit_rate"] = _openshot.WriterInfo_video_bit_rate_set
    __swig_getmethods__["video_bit_rate"] = _openshot.WriterInfo_video_bit_rate_get
    if _newclass:
        video_bit_rate = _swig_property(_openshot.WriterInfo_video_bit_rate_get, _openshot.WriterInfo_video_bit_rate_set)
    __swig_setmethods__["pixel_ratio"] = _openshot.WriterInfo_pixel_ratio_set
    __swig_getmethods__["pixel_ratio"] = _openshot.WriterInfo_pixel_ratio_get
    if _newclass:
        pixel_ratio = _swig_property(_openshot.WriterInfo_pixel_ratio_get, _openshot.WriterInfo_pixel_ratio_set)
    __swig_setmethods__["display_ratio"] = _openshot.WriterInfo_display_ratio_set
    __swig_getmethods__["display_ratio"] = _openshot.WriterInfo_display_ratio_get
    if _newclass:
        display_ratio = _swig_property(_openshot.WriterInfo_display_ratio_get, _openshot.WriterInfo_display_ratio_set)
    __swig_setmethods__["vcodec"] = _openshot.WriterInfo_vcodec_set
    __swig_getmethods__["vcodec"] = _openshot.WriterInfo_vcodec_get
    if _newclass:
        vcodec = _swig_property(_openshot.WriterInfo_vcodec_get, _openshot.WriterInfo_vcodec_set)
    __swig_setmethods__["video_length"] = _openshot.WriterInfo_video_length_set
    __swig_getmethods__["video_length"] = _openshot.WriterInfo_video_length_get
    if _newclass:
        video_length = _swig_property(_openshot.WriterInfo_video_length_get, _openshot.WriterInfo_video_length_set)
    __swig_setmethods__["video_stream_index"] = _openshot.WriterInfo_video_stream_index_set
    __swig_getmethods__["video_stream_index"] = _openshot.WriterInfo_video_stream_index_get
    if _newclass:
        video_stream_index = _swig_property(_openshot.WriterInfo_video_stream_index_get, _openshot.WriterInfo_video_stream_index_set)
    __swig_setmethods__["video_timebase"] = _openshot.WriterInfo_video_timebase_set
    __swig_getmethods__["video_timebase"] = _openshot.WriterInfo_video_timebase_get
    if _newclass:
        video_timebase = _swig_property(_openshot.WriterInfo_video_timebase_get, _openshot.WriterInfo_video_timebase_set)
    __swig_setmethods__["interlaced_frame"] = _openshot.WriterInfo_interlaced_frame_set
    __swig_getmethods__["interlaced_frame"] = _openshot.WriterInfo_interlaced_frame_get
    if _newclass:
        interlaced_frame = _swig_property(_openshot.WriterInfo_interlaced_frame_get, _openshot.WriterInfo_interlaced_frame_set)
    __swig_setmethods__["top_field_first"] = _openshot.WriterInfo_top_field_first_set
    __swig_getmethods__["top_field_first"] = _openshot.WriterInfo_top_field_first_get
    if _newclass:
        top_field_first = _swig_property(_openshot.WriterInfo_top_field_first_get, _openshot.WriterInfo_top_field_first_set)
    __swig_setmethods__["acodec"] = _openshot.WriterInfo_acodec_set
    __swig_getmethods__["acodec"] = _openshot.WriterInfo_acodec_get
    if _newclass:
        acodec = _swig_property(_openshot.WriterInfo_acodec_get, _openshot.WriterInfo_acodec_set)
    __swig_setmethods__["audio_bit_rate"] = _openshot.WriterInfo_audio_bit_rate_set
    __swig_getmethods__["audio_bit_rate"] = _openshot.WriterInfo_audio_bit_rate_get
    if _newclass:
        audio_bit_rate = _swig_property(_openshot.WriterInfo_audio_bit_rate_get, _openshot.WriterInfo_audio_bit_rate_set)
    __swig_setmethods__["sample_rate"] = _openshot.WriterInfo_sample_rate_set
    __swig_getmethods__["sample_rate"] = _openshot.WriterInfo_sample_rate_get
    if _newclass:
        sample_rate = _swig_property(_openshot.WriterInfo_sample_rate_get, _openshot.WriterInfo_sample_rate_set)
    __swig_setmethods__["channels"] = _openshot.WriterInfo_channels_set
    __swig_getmethods__["channels"] = _openshot.WriterInfo_channels_get
    if _newclass:
        channels = _swig_property(_openshot.WriterInfo_channels_get, _openshot.WriterInfo_channels_set)
    __swig_setmethods__["channel_layout"] = _openshot.WriterInfo_channel_layout_set
    __swig_getmethods__["channel_layout"] = _openshot.WriterInfo_channel_layout_get
    if _newclass:
        channel_layout = _swig_property(_openshot.WriterInfo_channel_layout_get, _openshot.WriterInfo_channel_layout_set)
    __swig_setmethods__["audio_stream_index"] = _openshot.WriterInfo_audio_stream_index_set
    __swig_getmethods__["audio_stream_index"] = _openshot.WriterInfo_audio_stream_index_get
    if _newclass:
        audio_stream_index = _swig_property(_openshot.WriterInfo_audio_stream_index_get, _openshot.WriterInfo_audio_stream_index_set)
    __swig_setmethods__["audio_timebase"] = _openshot.WriterInfo_audio_timebase_set
    __swig_getmethods__["audio_timebase"] = _openshot.WriterInfo_audio_timebase_get
    if _newclass:
        audio_timebase = _swig_property(_openshot.WriterInfo_audio_timebase_get, _openshot.WriterInfo_audio_timebase_set)

    def __init__(self):
        """__init__(openshot::WriterInfo self) -> WriterInfo"""
        this = _openshot.new_WriterInfo()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_WriterInfo
    __del__ = lambda self: None
WriterInfo_swigregister = _openshot.WriterInfo_swigregister
WriterInfo_swigregister(WriterInfo)

class WriterBase(_object):
    """Proxy of C++ openshot::WriterBase class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WriterBase, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WriterBase, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_setmethods__["info"] = _openshot.WriterBase_info_set
    __swig_getmethods__["info"] = _openshot.WriterBase_info_get
    if _newclass:
        info = _swig_property(_openshot.WriterBase_info_get, _openshot.WriterBase_info_set)

    def CopyReaderInfo(self, reader):
        """CopyReaderInfo(WriterBase self, ReaderBase reader)"""
        return _openshot.WriterBase_CopyReaderInfo(self, reader)


    def IsOpen(self):
        """IsOpen(WriterBase self) -> bool"""
        return _openshot.WriterBase_IsOpen(self)


    def WriteFrame(self, *args):
        """
        WriteFrame(WriterBase self, std::shared_ptr< openshot::Frame > frame)
        WriteFrame(WriterBase self, ReaderBase reader, int64_t start, int64_t length)
        """
        return _openshot.WriterBase_WriteFrame(self, *args)


    def Json(self):
        """Json(WriterBase self) -> std::string"""
        return _openshot.WriterBase_Json(self)


    def JsonValue(self):
        """JsonValue(WriterBase self) -> Json::Value"""
        return _openshot.WriterBase_JsonValue(self)


    def SetJson(self, value):
        """SetJson(WriterBase self, std::string value)"""
        return _openshot.WriterBase_SetJson(self, value)


    def SetJsonValue(self, root):
        """SetJsonValue(WriterBase self, Json::Value root)"""
        return _openshot.WriterBase_SetJsonValue(self, root)


    def DisplayInfo(self):
        """DisplayInfo(WriterBase self)"""
        return _openshot.WriterBase_DisplayInfo(self)


    def Open(self):
        """Open(WriterBase self)"""
        return _openshot.WriterBase_Open(self)

    __swig_destroy__ = _openshot.delete_WriterBase
    __del__ = lambda self: None
WriterBase_swigregister = _openshot.WriterBase_swigregister
WriterBase_swigregister(WriterBase)

class CacheBase(_object):
    """Proxy of C++ openshot::CacheBase class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CacheBase, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CacheBase, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def Add(self, frame):
        """Add(CacheBase self, std::shared_ptr< openshot::Frame > frame)"""
        return _openshot.CacheBase_Add(self, frame)


    def Clear(self):
        """Clear(CacheBase self)"""
        return _openshot.CacheBase_Clear(self)


    def Count(self):
        """Count(CacheBase self) -> int64_t"""
        return _openshot.CacheBase_Count(self)


    def GetFrame(self, frame_number):
        """GetFrame(CacheBase self, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.CacheBase_GetFrame(self, frame_number)


    def GetBytes(self):
        """GetBytes(CacheBase self) -> int64_t"""
        return _openshot.CacheBase_GetBytes(self)


    def GetSmallestFrame(self):
        """GetSmallestFrame(CacheBase self) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.CacheBase_GetSmallestFrame(self)


    def Remove(self, *args):
        """
        Remove(CacheBase self, int64_t frame_number)
        Remove(CacheBase self, int64_t start_frame_number, int64_t end_frame_number)
        """
        return _openshot.CacheBase_Remove(self, *args)


    def GetMaxBytes(self):
        """GetMaxBytes(CacheBase self) -> int64_t"""
        return _openshot.CacheBase_GetMaxBytes(self)


    def SetMaxBytes(self, number_of_bytes):
        """SetMaxBytes(CacheBase self, int64_t number_of_bytes)"""
        return _openshot.CacheBase_SetMaxBytes(self, number_of_bytes)


    def SetMaxBytesFromInfo(self, number_of_frames, width, height, sample_rate, channels):
        """SetMaxBytesFromInfo(CacheBase self, int64_t number_of_frames, int width, int height, int sample_rate, int channels)"""
        return _openshot.CacheBase_SetMaxBytesFromInfo(self, number_of_frames, width, height, sample_rate, channels)


    def Json(self):
        """Json(CacheBase self) -> std::string"""
        return _openshot.CacheBase_Json(self)


    def SetJson(self, value):
        """SetJson(CacheBase self, std::string value)"""
        return _openshot.CacheBase_SetJson(self, value)


    def JsonValue(self):
        """JsonValue(CacheBase self) -> Json::Value"""
        return _openshot.CacheBase_JsonValue(self)


    def SetJsonValue(self, root):
        """SetJsonValue(CacheBase self, Json::Value root)"""
        return _openshot.CacheBase_SetJsonValue(self, root)

    __swig_destroy__ = _openshot.delete_CacheBase
    __del__ = lambda self: None
CacheBase_swigregister = _openshot.CacheBase_swigregister
CacheBase_swigregister(CacheBase)

class CacheDisk(CacheBase):
    """Proxy of C++ openshot::CacheDisk class."""

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

    def __init__(self, *args):
        """
        __init__(openshot::CacheDisk self, std::string cache_path, std::string format, float quality, float scale) -> CacheDisk
        __init__(openshot::CacheDisk self, std::string cache_path, std::string format, float quality, float scale, int64_t max_bytes) -> CacheDisk
        """
        this = _openshot.new_CacheDisk(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_CacheDisk
    __del__ = lambda self: None

    def Add(self, frame):
        """Add(CacheDisk self, std::shared_ptr< openshot::Frame > frame)"""
        return _openshot.CacheDisk_Add(self, frame)


    def Clear(self):
        """Clear(CacheDisk self)"""
        return _openshot.CacheDisk_Clear(self)


    def Count(self):
        """Count(CacheDisk self) -> int64_t"""
        return _openshot.CacheDisk_Count(self)


    def GetFrame(self, frame_number):
        """GetFrame(CacheDisk self, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.CacheDisk_GetFrame(self, frame_number)


    def GetBytes(self):
        """GetBytes(CacheDisk self) -> int64_t"""
        return _openshot.CacheDisk_GetBytes(self)


    def GetSmallestFrame(self):
        """GetSmallestFrame(CacheDisk self) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.CacheDisk_GetSmallestFrame(self)


    def MoveToFront(self, frame_number):
        """MoveToFront(CacheDisk self, int64_t frame_number)"""
        return _openshot.CacheDisk_MoveToFront(self, frame_number)


    def Remove(self, *args):
        """
        Remove(CacheDisk self, int64_t frame_number)
        Remove(CacheDisk self, int64_t start_frame_number, int64_t end_frame_number)
        """
        return _openshot.CacheDisk_Remove(self, *args)


    def Json(self):
        """Json(CacheDisk self) -> std::string"""
        return _openshot.CacheDisk_Json(self)


    def SetJson(self, value):
        """SetJson(CacheDisk self, std::string value)"""
        return _openshot.CacheDisk_SetJson(self, value)


    def JsonValue(self):
        """JsonValue(CacheDisk self) -> Json::Value"""
        return _openshot.CacheDisk_JsonValue(self)


    def SetJsonValue(self, root):
        """SetJsonValue(CacheDisk self, Json::Value root)"""
        return _openshot.CacheDisk_SetJsonValue(self, root)

CacheDisk_swigregister = _openshot.CacheDisk_swigregister
CacheDisk_swigregister(CacheDisk)

class CacheMemory(CacheBase):
    """Proxy of C++ openshot::CacheMemory class."""

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

    def __init__(self, *args):
        """
        __init__(openshot::CacheMemory self) -> CacheMemory
        __init__(openshot::CacheMemory self, int64_t max_bytes) -> CacheMemory
        """
        this = _openshot.new_CacheMemory(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_CacheMemory
    __del__ = lambda self: None

    def Add(self, frame):
        """Add(CacheMemory self, std::shared_ptr< openshot::Frame > frame)"""
        return _openshot.CacheMemory_Add(self, frame)


    def Clear(self):
        """Clear(CacheMemory self)"""
        return _openshot.CacheMemory_Clear(self)


    def Count(self):
        """Count(CacheMemory self) -> int64_t"""
        return _openshot.CacheMemory_Count(self)


    def GetFrame(self, frame_number):
        """GetFrame(CacheMemory self, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.CacheMemory_GetFrame(self, frame_number)


    def GetBytes(self):
        """GetBytes(CacheMemory self) -> int64_t"""
        return _openshot.CacheMemory_GetBytes(self)


    def GetSmallestFrame(self):
        """GetSmallestFrame(CacheMemory self) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.CacheMemory_GetSmallestFrame(self)


    def MoveToFront(self, frame_number):
        """MoveToFront(CacheMemory self, int64_t frame_number)"""
        return _openshot.CacheMemory_MoveToFront(self, frame_number)


    def Remove(self, *args):
        """
        Remove(CacheMemory self, int64_t frame_number)
        Remove(CacheMemory self, int64_t start_frame_number, int64_t end_frame_number)
        """
        return _openshot.CacheMemory_Remove(self, *args)


    def Json(self):
        """Json(CacheMemory self) -> std::string"""
        return _openshot.CacheMemory_Json(self)


    def SetJson(self, value):
        """SetJson(CacheMemory self, std::string value)"""
        return _openshot.CacheMemory_SetJson(self, value)


    def JsonValue(self):
        """JsonValue(CacheMemory self) -> Json::Value"""
        return _openshot.CacheMemory_JsonValue(self)


    def SetJsonValue(self, root):
        """SetJsonValue(CacheMemory self, Json::Value root)"""
        return _openshot.CacheMemory_SetJsonValue(self, root)

CacheMemory_swigregister = _openshot.CacheMemory_swigregister
CacheMemory_swigregister(CacheMemory)

LAYOUT_MONO = _openshot.LAYOUT_MONO
LAYOUT_STEREO = _openshot.LAYOUT_STEREO
LAYOUT_2POINT1 = _openshot.LAYOUT_2POINT1
LAYOUT_2_1 = _openshot.LAYOUT_2_1
LAYOUT_SURROUND = _openshot.LAYOUT_SURROUND
LAYOUT_3POINT1 = _openshot.LAYOUT_3POINT1
LAYOUT_4POINT0 = _openshot.LAYOUT_4POINT0
LAYOUT_4POINT1 = _openshot.LAYOUT_4POINT1
LAYOUT_2_2 = _openshot.LAYOUT_2_2
LAYOUT_QUAD = _openshot.LAYOUT_QUAD
LAYOUT_5POINT0 = _openshot.LAYOUT_5POINT0
LAYOUT_5POINT1 = _openshot.LAYOUT_5POINT1
LAYOUT_5POINT0_BACK = _openshot.LAYOUT_5POINT0_BACK
LAYOUT_5POINT1_BACK = _openshot.LAYOUT_5POINT1_BACK
LAYOUT_6POINT0 = _openshot.LAYOUT_6POINT0
LAYOUT_6POINT0_FRONT = _openshot.LAYOUT_6POINT0_FRONT
LAYOUT_HEXAGONAL = _openshot.LAYOUT_HEXAGONAL
LAYOUT_6POINT1 = _openshot.LAYOUT_6POINT1
LAYOUT_6POINT1_BACK = _openshot.LAYOUT_6POINT1_BACK
LAYOUT_6POINT1_FRONT = _openshot.LAYOUT_6POINT1_FRONT
LAYOUT_7POINT0 = _openshot.LAYOUT_7POINT0
LAYOUT_7POINT0_FRONT = _openshot.LAYOUT_7POINT0_FRONT
LAYOUT_7POINT1 = _openshot.LAYOUT_7POINT1
LAYOUT_7POINT1_WIDE = _openshot.LAYOUT_7POINT1_WIDE
LAYOUT_7POINT1_WIDE_BACK = _openshot.LAYOUT_7POINT1_WIDE_BACK
LAYOUT_OCTAGONAL = _openshot.LAYOUT_OCTAGONAL
LAYOUT_STEREO_DOWNMIX = _openshot.LAYOUT_STEREO_DOWNMIX
class ChunkLocation(_object):
    """Proxy of C++ openshot::ChunkLocation class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChunkLocation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ChunkLocation, name)
    __repr__ = _swig_repr
    __swig_setmethods__["number"] = _openshot.ChunkLocation_number_set
    __swig_getmethods__["number"] = _openshot.ChunkLocation_number_get
    if _newclass:
        number = _swig_property(_openshot.ChunkLocation_number_get, _openshot.ChunkLocation_number_set)
    __swig_setmethods__["frame"] = _openshot.ChunkLocation_frame_set
    __swig_getmethods__["frame"] = _openshot.ChunkLocation_frame_get
    if _newclass:
        frame = _swig_property(_openshot.ChunkLocation_frame_get, _openshot.ChunkLocation_frame_set)

    def __init__(self):
        """__init__(openshot::ChunkLocation self) -> ChunkLocation"""
        this = _openshot.new_ChunkLocation()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_ChunkLocation
    __del__ = lambda self: None
ChunkLocation_swigregister = _openshot.ChunkLocation_swigregister
ChunkLocation_swigregister(ChunkLocation)

THUMBNAIL = _openshot.THUMBNAIL
PREVIEW = _openshot.PREVIEW
FINAL = _openshot.FINAL
class ChunkReader(ReaderBase):
    """Proxy of C++ openshot::ChunkReader class."""

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

    def __init__(self, path, chunk_version):
        """__init__(openshot::ChunkReader self, std::string path, openshot::ChunkVersion chunk_version) -> ChunkReader"""
        this = _openshot.new_ChunkReader(path, chunk_version)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def Close(self):
        """Close(ChunkReader self)"""
        return _openshot.ChunkReader_Close(self)


    def GetChunkSize(self):
        """GetChunkSize(ChunkReader self) -> int64_t"""
        return _openshot.ChunkReader_GetChunkSize(self)


    def SetChunkSize(self, new_size):
        """SetChunkSize(ChunkReader self, int64_t new_size)"""
        return _openshot.ChunkReader_SetChunkSize(self, new_size)


    def GetCache(self):
        """GetCache(ChunkReader self) -> CacheMemory"""
        return _openshot.ChunkReader_GetCache(self)


    def GetFrame(self, requested_frame):
        """GetFrame(ChunkReader self, int64_t requested_frame) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.ChunkReader_GetFrame(self, requested_frame)


    def IsOpen(self):
        """IsOpen(ChunkReader self) -> bool"""
        return _openshot.ChunkReader_IsOpen(self)


    def Name(self):
        """Name(ChunkReader self) -> std::string"""
        return _openshot.ChunkReader_Name(self)


    def Json(self):
        """Json(ChunkReader self) -> std::string"""
        return _openshot.ChunkReader_Json(self)


    def SetJson(self, value):
        """SetJson(ChunkReader self, std::string value)"""
        return _openshot.ChunkReader_SetJson(self, value)


    def JsonValue(self):
        """JsonValue(ChunkReader self) -> Json::Value"""
        return _openshot.ChunkReader_JsonValue(self)


    def SetJsonValue(self, root):
        """SetJsonValue(ChunkReader self, Json::Value root)"""
        return _openshot.ChunkReader_SetJsonValue(self, root)


    def Open(self):
        """Open(ChunkReader self)"""
        return _openshot.ChunkReader_Open(self)

    __swig_destroy__ = _openshot.delete_ChunkReader
    __del__ = lambda self: None
ChunkReader_swigregister = _openshot.ChunkReader_swigregister
ChunkReader_swigregister(ChunkReader)

class ChunkWriter(WriterBase):
    """Proxy of C++ openshot::ChunkWriter class."""

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

    def __init__(self, path, reader):
        """__init__(openshot::ChunkWriter self, std::string path, ReaderBase reader) -> ChunkWriter"""
        this = _openshot.new_ChunkWriter(path, reader)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def Close(self):
        """Close(ChunkWriter self)"""
        return _openshot.ChunkWriter_Close(self)


    def GetChunkSize(self):
        """GetChunkSize(ChunkWriter self) -> int64_t"""
        return _openshot.ChunkWriter_GetChunkSize(self)


    def IsOpen(self):
        """IsOpen(ChunkWriter self) -> bool"""
        return _openshot.ChunkWriter_IsOpen(self)


    def Open(self):
        """Open(ChunkWriter self)"""
        return _openshot.ChunkWriter_Open(self)


    def SetChunkSize(self, new_size):
        """SetChunkSize(ChunkWriter self, int64_t new_size)"""
        return _openshot.ChunkWriter_SetChunkSize(self, new_size)


    def WriteFrame(self, *args):
        """
        WriteFrame(ChunkWriter self, std::shared_ptr< openshot::Frame > frame)
        WriteFrame(ChunkWriter self, int64_t start, int64_t length)
        WriteFrame(ChunkWriter self, ReaderBase reader, int64_t start, int64_t length)
        """
        return _openshot.ChunkWriter_WriteFrame(self, *args)

    __swig_destroy__ = _openshot.delete_ChunkWriter
    __del__ = lambda self: None
ChunkWriter_swigregister = _openshot.ChunkWriter_swigregister
ChunkWriter_swigregister(ChunkWriter)

class ClipBase(_object):
    """Proxy of C++ openshot::ClipBase class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ClipBase, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ClipBase, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def __lt__(self, a):
        """__lt__(ClipBase self, ClipBase a) -> bool"""
        return _openshot.ClipBase___lt__(self, a)


    def __le__(self, a):
        """__le__(ClipBase self, ClipBase a) -> bool"""
        return _openshot.ClipBase___le__(self, a)


    def __gt__(self, a):
        """__gt__(ClipBase self, ClipBase a) -> bool"""
        return _openshot.ClipBase___gt__(self, a)


    def __ge__(self, a):
        """__ge__(ClipBase self, ClipBase a) -> bool"""
        return _openshot.ClipBase___ge__(self, a)


    def Duration(self):
        """Duration(ClipBase self) -> float"""
        return _openshot.ClipBase_Duration(self)


    def Id(self, *args):
        """
        Id(ClipBase self) -> std::string
        Id(ClipBase self, std::string value)
        """
        return _openshot.ClipBase_Id(self, *args)


    def Position(self, *args):
        """
        Position(ClipBase self) -> float
        Position(ClipBase self, float value)
        """
        return _openshot.ClipBase_Position(self, *args)


    def Layer(self, *args):
        """
        Layer(ClipBase self) -> int
        Layer(ClipBase self, int value)
        """
        return _openshot.ClipBase_Layer(self, *args)


    def Start(self, *args):
        """
        Start(ClipBase self) -> float
        Start(ClipBase self, float value)
        """
        return _openshot.ClipBase_Start(self, *args)


    def End(self, *args):
        """
        End(ClipBase self) -> float
        End(ClipBase self, float value)
        """
        return _openshot.ClipBase_End(self, *args)


    def SetMaxSize(self, width, height):
        """SetMaxSize(ClipBase self, int width, int height)"""
        return _openshot.ClipBase_SetMaxSize(self, width, height)


    def Json(self):
        """Json(ClipBase self) -> std::string"""
        return _openshot.ClipBase_Json(self)


    def SetJson(self, value):
        """SetJson(ClipBase self, std::string value)"""
        return _openshot.ClipBase_SetJson(self, value)


    def JsonValue(self):
        """JsonValue(ClipBase self) -> Json::Value"""
        return _openshot.ClipBase_JsonValue(self)


    def SetJsonValue(self, root):
        """SetJsonValue(ClipBase self, Json::Value root)"""
        return _openshot.ClipBase_SetJsonValue(self, root)


    def PropertiesJSON(self, requested_frame):
        """PropertiesJSON(ClipBase self, int64_t requested_frame) -> std::string"""
        return _openshot.ClipBase_PropertiesJSON(self, requested_frame)

    __swig_destroy__ = _openshot.delete_ClipBase
    __del__ = lambda self: None
ClipBase_swigregister = _openshot.ClipBase_swigregister
ClipBase_swigregister(ClipBase)

class CompareClipEffects(_object):
    """Proxy of C++ openshot::CompareClipEffects class."""

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

    def __call__(self, lhs, rhs):
        """__call__(CompareClipEffects self, EffectBase lhs, EffectBase rhs) -> bool"""
        return _openshot.CompareClipEffects___call__(self, lhs, rhs)


    def __init__(self):
        """__init__(openshot::CompareClipEffects self) -> CompareClipEffects"""
        this = _openshot.new_CompareClipEffects()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_CompareClipEffects
    __del__ = lambda self: None
CompareClipEffects_swigregister = _openshot.CompareClipEffects_swigregister
CompareClipEffects_swigregister(CompareClipEffects)

class Clip(ClipBase):
    """Proxy of C++ openshot::Clip class."""

    __swig_setmethods__ = {}
    for _s in [ClipBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Clip, name, value)
    __swig_getmethods__ = {}
    for _s in [ClipBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Clip, name)
    __repr__ = _swig_repr
    __swig_setmethods__["gravity"] = _openshot.Clip_gravity_set
    __swig_getmethods__["gravity"] = _openshot.Clip_gravity_get
    if _newclass:
        gravity = _swig_property(_openshot.Clip_gravity_get, _openshot.Clip_gravity_set)
    __swig_setmethods__["scale"] = _openshot.Clip_scale_set
    __swig_getmethods__["scale"] = _openshot.Clip_scale_get
    if _newclass:
        scale = _swig_property(_openshot.Clip_scale_get, _openshot.Clip_scale_set)
    __swig_setmethods__["anchor"] = _openshot.Clip_anchor_set
    __swig_getmethods__["anchor"] = _openshot.Clip_anchor_get
    if _newclass:
        anchor = _swig_property(_openshot.Clip_anchor_get, _openshot.Clip_anchor_set)
    __swig_setmethods__["display"] = _openshot.Clip_display_set
    __swig_getmethods__["display"] = _openshot.Clip_display_get
    if _newclass:
        display = _swig_property(_openshot.Clip_display_get, _openshot.Clip_display_set)

    def __init__(self, *args):
        """
        __init__(openshot::Clip self) -> Clip
        __init__(openshot::Clip self, std::string path) -> Clip
        __init__(openshot::Clip self, ReaderBase new_reader) -> Clip
        """
        this = _openshot.new_Clip(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_Clip
    __del__ = lambda self: None

    def AddEffect(self, effect):
        """AddEffect(Clip self, EffectBase effect)"""
        return _openshot.Clip_AddEffect(self, effect)


    def Close(self):
        """Close(Clip self)"""
        return _openshot.Clip_Close(self)


    def Effects(self):
        """Effects(Clip self) -> EffectBaseList"""
        return _openshot.Clip_Effects(self)


    def GetFrame(self, requested_frame):
        """GetFrame(Clip self, int64_t requested_frame) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.Clip_GetFrame(self, requested_frame)


    def Open(self):
        """Open(Clip self)"""
        return _openshot.Clip_Open(self)


    def Reader(self, *args):
        """
        Reader(Clip self, ReaderBase new_reader)
        Reader(Clip self) -> ReaderBase
        """
        return _openshot.Clip_Reader(self, *args)


    def End(self, *args):
        """
        End(Clip self) -> float
        End(Clip self, float value)
        """
        return _openshot.Clip_End(self, *args)


    def Json(self):
        """Json(Clip self) -> std::string"""
        return _openshot.Clip_Json(self)


    def SetJson(self, value):
        """SetJson(Clip self, std::string value)"""
        return _openshot.Clip_SetJson(self, value)


    def JsonValue(self):
        """JsonValue(Clip self) -> Json::Value"""
        return _openshot.Clip_JsonValue(self)


    def SetJsonValue(self, root):
        """SetJsonValue(Clip self, Json::Value root)"""
        return _openshot.Clip_SetJsonValue(self, root)


    def PropertiesJSON(self, requested_frame):
        """PropertiesJSON(Clip self, int64_t requested_frame) -> std::string"""
        return _openshot.Clip_PropertiesJSON(self, requested_frame)


    def RemoveEffect(self, effect):
        """RemoveEffect(Clip self, EffectBase effect)"""
        return _openshot.Clip_RemoveEffect(self, effect)


    def Waveform(self, *args):
        """
        Waveform(Clip self) -> bool
        Waveform(Clip self, bool value)
        """
        return _openshot.Clip_Waveform(self, *args)

    __swig_setmethods__["scale_x"] = _openshot.Clip_scale_x_set
    __swig_getmethods__["scale_x"] = _openshot.Clip_scale_x_get
    if _newclass:
        scale_x = _swig_property(_openshot.Clip_scale_x_get, _openshot.Clip_scale_x_set)
    __swig_setmethods__["scale_y"] = _openshot.Clip_scale_y_set
    __swig_getmethods__["scale_y"] = _openshot.Clip_scale_y_get
    if _newclass:
        scale_y = _swig_property(_openshot.Clip_scale_y_get, _openshot.Clip_scale_y_set)
    __swig_setmethods__["location_x"] = _openshot.Clip_location_x_set
    __swig_getmethods__["location_x"] = _openshot.Clip_location_x_get
    if _newclass:
        location_x = _swig_property(_openshot.Clip_location_x_get, _openshot.Clip_location_x_set)
    __swig_setmethods__["location_y"] = _openshot.Clip_location_y_set
    __swig_getmethods__["location_y"] = _openshot.Clip_location_y_get
    if _newclass:
        location_y = _swig_property(_openshot.Clip_location_y_get, _openshot.Clip_location_y_set)
    __swig_setmethods__["alpha"] = _openshot.Clip_alpha_set
    __swig_getmethods__["alpha"] = _openshot.Clip_alpha_get
    if _newclass:
        alpha = _swig_property(_openshot.Clip_alpha_get, _openshot.Clip_alpha_set)
    __swig_setmethods__["rotation"] = _openshot.Clip_rotation_set
    __swig_getmethods__["rotation"] = _openshot.Clip_rotation_get
    if _newclass:
        rotation = _swig_property(_openshot.Clip_rotation_get, _openshot.Clip_rotation_set)
    __swig_setmethods__["time"] = _openshot.Clip_time_set
    __swig_getmethods__["time"] = _openshot.Clip_time_get
    if _newclass:
        time = _swig_property(_openshot.Clip_time_get, _openshot.Clip_time_set)
    __swig_setmethods__["volume"] = _openshot.Clip_volume_set
    __swig_getmethods__["volume"] = _openshot.Clip_volume_get
    if _newclass:
        volume = _swig_property(_openshot.Clip_volume_get, _openshot.Clip_volume_set)
    __swig_setmethods__["wave_color"] = _openshot.Clip_wave_color_set
    __swig_getmethods__["wave_color"] = _openshot.Clip_wave_color_get
    if _newclass:
        wave_color = _swig_property(_openshot.Clip_wave_color_get, _openshot.Clip_wave_color_set)
    __swig_setmethods__["crop_gravity"] = _openshot.Clip_crop_gravity_set
    __swig_getmethods__["crop_gravity"] = _openshot.Clip_crop_gravity_get
    if _newclass:
        crop_gravity = _swig_property(_openshot.Clip_crop_gravity_get, _openshot.Clip_crop_gravity_set)
    __swig_setmethods__["crop_width"] = _openshot.Clip_crop_width_set
    __swig_getmethods__["crop_width"] = _openshot.Clip_crop_width_get
    if _newclass:
        crop_width = _swig_property(_openshot.Clip_crop_width_get, _openshot.Clip_crop_width_set)
    __swig_setmethods__["crop_height"] = _openshot.Clip_crop_height_set
    __swig_getmethods__["crop_height"] = _openshot.Clip_crop_height_get
    if _newclass:
        crop_height = _swig_property(_openshot.Clip_crop_height_get, _openshot.Clip_crop_height_set)
    __swig_setmethods__["crop_x"] = _openshot.Clip_crop_x_set
    __swig_getmethods__["crop_x"] = _openshot.Clip_crop_x_get
    if _newclass:
        crop_x = _swig_property(_openshot.Clip_crop_x_get, _openshot.Clip_crop_x_set)
    __swig_setmethods__["crop_y"] = _openshot.Clip_crop_y_set
    __swig_getmethods__["crop_y"] = _openshot.Clip_crop_y_get
    if _newclass:
        crop_y = _swig_property(_openshot.Clip_crop_y_get, _openshot.Clip_crop_y_set)
    __swig_setmethods__["shear_x"] = _openshot.Clip_shear_x_set
    __swig_getmethods__["shear_x"] = _openshot.Clip_shear_x_get
    if _newclass:
        shear_x = _swig_property(_openshot.Clip_shear_x_get, _openshot.Clip_shear_x_set)
    __swig_setmethods__["shear_y"] = _openshot.Clip_shear_y_set
    __swig_getmethods__["shear_y"] = _openshot.Clip_shear_y_get
    if _newclass:
        shear_y = _swig_property(_openshot.Clip_shear_y_get, _openshot.Clip_shear_y_set)
    __swig_setmethods__["perspective_c1_x"] = _openshot.Clip_perspective_c1_x_set
    __swig_getmethods__["perspective_c1_x"] = _openshot.Clip_perspective_c1_x_get
    if _newclass:
        perspective_c1_x = _swig_property(_openshot.Clip_perspective_c1_x_get, _openshot.Clip_perspective_c1_x_set)
    __swig_setmethods__["perspective_c1_y"] = _openshot.Clip_perspective_c1_y_set
    __swig_getmethods__["perspective_c1_y"] = _openshot.Clip_perspective_c1_y_get
    if _newclass:
        perspective_c1_y = _swig_property(_openshot.Clip_perspective_c1_y_get, _openshot.Clip_perspective_c1_y_set)
    __swig_setmethods__["perspective_c2_x"] = _openshot.Clip_perspective_c2_x_set
    __swig_getmethods__["perspective_c2_x"] = _openshot.Clip_perspective_c2_x_get
    if _newclass:
        perspective_c2_x = _swig_property(_openshot.Clip_perspective_c2_x_get, _openshot.Clip_perspective_c2_x_set)
    __swig_setmethods__["perspective_c2_y"] = _openshot.Clip_perspective_c2_y_set
    __swig_getmethods__["perspective_c2_y"] = _openshot.Clip_perspective_c2_y_get
    if _newclass:
        perspective_c2_y = _swig_property(_openshot.Clip_perspective_c2_y_get, _openshot.Clip_perspective_c2_y_set)
    __swig_setmethods__["perspective_c3_x"] = _openshot.Clip_perspective_c3_x_set
    __swig_getmethods__["perspective_c3_x"] = _openshot.Clip_perspective_c3_x_get
    if _newclass:
        perspective_c3_x = _swig_property(_openshot.Clip_perspective_c3_x_get, _openshot.Clip_perspective_c3_x_set)
    __swig_setmethods__["perspective_c3_y"] = _openshot.Clip_perspective_c3_y_set
    __swig_getmethods__["perspective_c3_y"] = _openshot.Clip_perspective_c3_y_get
    if _newclass:
        perspective_c3_y = _swig_property(_openshot.Clip_perspective_c3_y_get, _openshot.Clip_perspective_c3_y_set)
    __swig_setmethods__["perspective_c4_x"] = _openshot.Clip_perspective_c4_x_set
    __swig_getmethods__["perspective_c4_x"] = _openshot.Clip_perspective_c4_x_get
    if _newclass:
        perspective_c4_x = _swig_property(_openshot.Clip_perspective_c4_x_get, _openshot.Clip_perspective_c4_x_set)
    __swig_setmethods__["perspective_c4_y"] = _openshot.Clip_perspective_c4_y_set
    __swig_getmethods__["perspective_c4_y"] = _openshot.Clip_perspective_c4_y_get
    if _newclass:
        perspective_c4_y = _swig_property(_openshot.Clip_perspective_c4_y_get, _openshot.Clip_perspective_c4_y_set)
    __swig_setmethods__["channel_filter"] = _openshot.Clip_channel_filter_set
    __swig_getmethods__["channel_filter"] = _openshot.Clip_channel_filter_get
    if _newclass:
        channel_filter = _swig_property(_openshot.Clip_channel_filter_get, _openshot.Clip_channel_filter_set)
    __swig_setmethods__["channel_mapping"] = _openshot.Clip_channel_mapping_set
    __swig_getmethods__["channel_mapping"] = _openshot.Clip_channel_mapping_get
    if _newclass:
        channel_mapping = _swig_property(_openshot.Clip_channel_mapping_get, _openshot.Clip_channel_mapping_set)
    __swig_setmethods__["has_audio"] = _openshot.Clip_has_audio_set
    __swig_getmethods__["has_audio"] = _openshot.Clip_has_audio_get
    if _newclass:
        has_audio = _swig_property(_openshot.Clip_has_audio_get, _openshot.Clip_has_audio_set)
    __swig_setmethods__["has_video"] = _openshot.Clip_has_video_set
    __swig_getmethods__["has_video"] = _openshot.Clip_has_video_get
    if _newclass:
        has_video = _swig_property(_openshot.Clip_has_video_get, _openshot.Clip_has_video_set)
Clip_swigregister = _openshot.Clip_swigregister
Clip_swigregister(Clip)

class Coordinate(_object):
    """Proxy of C++ openshot::Coordinate class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Coordinate, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Coordinate, name)
    __repr__ = _swig_repr
    __swig_setmethods__["X"] = _openshot.Coordinate_X_set
    __swig_getmethods__["X"] = _openshot.Coordinate_X_get
    if _newclass:
        X = _swig_property(_openshot.Coordinate_X_get, _openshot.Coordinate_X_set)
    __swig_setmethods__["Y"] = _openshot.Coordinate_Y_set
    __swig_getmethods__["Y"] = _openshot.Coordinate_Y_get
    if _newclass:
        Y = _swig_property(_openshot.Coordinate_Y_get, _openshot.Coordinate_Y_set)

    def __init__(self, *args):
        """
        __init__(openshot::Coordinate self) -> Coordinate
        __init__(openshot::Coordinate self, double x, double y) -> Coordinate
        """
        this = _openshot.new_Coordinate(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def Repeat(self, *args):
        """
        Repeat(Coordinate self, Fraction is_repeated)
        Repeat(Coordinate self) -> Fraction
        """
        return _openshot.Coordinate_Repeat(self, *args)


    def IsIncreasing(self, *args):
        """
        IsIncreasing(Coordinate self, bool is_increasing)
        IsIncreasing(Coordinate self) -> bool
        """
        return _openshot.Coordinate_IsIncreasing(self, *args)


    def Delta(self, *args):
        """
        Delta(Coordinate self, double new_delta)
        Delta(Coordinate self) -> float
        """
        return _openshot.Coordinate_Delta(self, *args)


    def Json(self):
        """Json(Coordinate self) -> std::string"""
        return _openshot.Coordinate_Json(self)


    def JsonValue(self):
        """JsonValue(Coordinate self) -> Json::Value"""
        return _openshot.Coordinate_JsonValue(self)


    def SetJson(self, value):
        """SetJson(Coordinate self, std::string value)"""
        return _openshot.Coordinate_SetJson(self, value)


    def SetJsonValue(self, root):
        """SetJsonValue(Coordinate self, Json::Value root)"""
        return _openshot.Coordinate_SetJsonValue(self, root)

    __swig_destroy__ = _openshot.delete_Coordinate
    __del__ = lambda self: None
Coordinate_swigregister = _openshot.Coordinate_swigregister
Coordinate_swigregister(Coordinate)

class Color(_object):
    """Proxy of C++ openshot::Color class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Color, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Color, name)
    __repr__ = _swig_repr
    __swig_setmethods__["red"] = _openshot.Color_red_set
    __swig_getmethods__["red"] = _openshot.Color_red_get
    if _newclass:
        red = _swig_property(_openshot.Color_red_get, _openshot.Color_red_set)
    __swig_setmethods__["green"] = _openshot.Color_green_set
    __swig_getmethods__["green"] = _openshot.Color_green_get
    if _newclass:
        green = _swig_property(_openshot.Color_green_get, _openshot.Color_green_set)
    __swig_setmethods__["blue"] = _openshot.Color_blue_set
    __swig_getmethods__["blue"] = _openshot.Color_blue_get
    if _newclass:
        blue = _swig_property(_openshot.Color_blue_get, _openshot.Color_blue_set)
    __swig_setmethods__["alpha"] = _openshot.Color_alpha_set
    __swig_getmethods__["alpha"] = _openshot.Color_alpha_get
    if _newclass:
        alpha = _swig_property(_openshot.Color_alpha_get, _openshot.Color_alpha_set)

    def __init__(self, *args):
        """
        __init__(openshot::Color self) -> Color
        __init__(openshot::Color self, std::string color_hex) -> Color
        __init__(openshot::Color self, unsigned char Red, unsigned char Green, unsigned char Blue, unsigned char Alpha) -> Color
        __init__(openshot::Color self, Keyframe Red, Keyframe Green, Keyframe Blue, Keyframe Alpha) -> Color
        """
        this = _openshot.new_Color(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def GetColorHex(self, frame_number):
        """GetColorHex(Color self, int64_t frame_number) -> std::string"""
        return _openshot.Color_GetColorHex(self, frame_number)


    def GetDistance(R1, G1, B1, R2, G2, B2):
        """GetDistance(long R1, long G1, long B1, long R2, long G2, long B2) -> long"""
        return _openshot.Color_GetDistance(R1, G1, B1, R2, G2, B2)

    GetDistance = staticmethod(GetDistance)

    def Json(self):
        """Json(Color self) -> std::string"""
        return _openshot.Color_Json(self)


    def JsonValue(self):
        """JsonValue(Color self) -> Json::Value"""
        return _openshot.Color_JsonValue(self)


    def SetJson(self, value):
        """SetJson(Color self, std::string value)"""
        return _openshot.Color_SetJson(self, value)


    def SetJsonValue(self, root):
        """SetJsonValue(Color self, Json::Value root)"""
        return _openshot.Color_SetJsonValue(self, root)

    __swig_destroy__ = _openshot.delete_Color
    __del__ = lambda self: None
Color_swigregister = _openshot.Color_swigregister
Color_swigregister(Color)

def Color_GetDistance(R1, G1, B1, R2, G2, B2):
    """Color_GetDistance(long R1, long G1, long B1, long R2, long G2, long B2) -> long"""
    return _openshot.Color_GetDistance(R1, G1, B1, R2, G2, B2)

class DummyReader(ReaderBase):
    """Proxy of C++ openshot::DummyReader class."""

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

    def __init__(self, *args):
        """
        __init__(openshot::DummyReader self) -> DummyReader
        __init__(openshot::DummyReader self, Fraction fps, int width, int height, int sample_rate, int channels, float duration) -> DummyReader
        """
        this = _openshot.new_DummyReader(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def Close(self):
        """Close(DummyReader self)"""
        return _openshot.DummyReader_Close(self)


    def GetCache(self):
        """GetCache(DummyReader self) -> CacheMemory"""
        return _openshot.DummyReader_GetCache(self)


    def GetFrame(self, requested_frame):
        """GetFrame(DummyReader self, int64_t requested_frame) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.DummyReader_GetFrame(self, requested_frame)


    def IsOpen(self):
        """IsOpen(DummyReader self) -> bool"""
        return _openshot.DummyReader_IsOpen(self)


    def Name(self):
        """Name(DummyReader self) -> std::string"""
        return _openshot.DummyReader_Name(self)


    def Json(self):
        """Json(DummyReader self) -> std::string"""
        return _openshot.DummyReader_Json(self)


    def SetJson(self, value):
        """SetJson(DummyReader self, std::string value)"""
        return _openshot.DummyReader_SetJson(self, value)


    def JsonValue(self):
        """JsonValue(DummyReader self) -> Json::Value"""
        return _openshot.DummyReader_JsonValue(self)


    def SetJsonValue(self, root):
        """SetJsonValue(DummyReader self, Json::Value root)"""
        return _openshot.DummyReader_SetJsonValue(self, root)


    def Open(self):
        """Open(DummyReader self)"""
        return _openshot.DummyReader_Open(self)

    __swig_destroy__ = _openshot.delete_DummyReader
    __del__ = lambda self: None
DummyReader_swigregister = _openshot.DummyReader_swigregister
DummyReader_swigregister(DummyReader)

class EffectInfoStruct(_object):
    """Proxy of C++ openshot::EffectInfoStruct class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EffectInfoStruct, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EffectInfoStruct, name)
    __repr__ = _swig_repr
    __swig_setmethods__["class_name"] = _openshot.EffectInfoStruct_class_name_set
    __swig_getmethods__["class_name"] = _openshot.EffectInfoStruct_class_name_get
    if _newclass:
        class_name = _swig_property(_openshot.EffectInfoStruct_class_name_get, _openshot.EffectInfoStruct_class_name_set)
    __swig_setmethods__["short_name"] = _openshot.EffectInfoStruct_short_name_set
    __swig_getmethods__["short_name"] = _openshot.EffectInfoStruct_short_name_get
    if _newclass:
        short_name = _swig_property(_openshot.EffectInfoStruct_short_name_get, _openshot.EffectInfoStruct_short_name_set)
    __swig_setmethods__["name"] = _openshot.EffectInfoStruct_name_set
    __swig_getmethods__["name"] = _openshot.EffectInfoStruct_name_get
    if _newclass:
        name = _swig_property(_openshot.EffectInfoStruct_name_get, _openshot.EffectInfoStruct_name_set)
    __swig_setmethods__["description"] = _openshot.EffectInfoStruct_description_set
    __swig_getmethods__["description"] = _openshot.EffectInfoStruct_description_get
    if _newclass:
        description = _swig_property(_openshot.EffectInfoStruct_description_get, _openshot.EffectInfoStruct_description_set)
    __swig_setmethods__["has_video"] = _openshot.EffectInfoStruct_has_video_set
    __swig_getmethods__["has_video"] = _openshot.EffectInfoStruct_has_video_get
    if _newclass:
        has_video = _swig_property(_openshot.EffectInfoStruct_has_video_get, _openshot.EffectInfoStruct_has_video_set)
    __swig_setmethods__["has_audio"] = _openshot.EffectInfoStruct_has_audio_set
    __swig_getmethods__["has_audio"] = _openshot.EffectInfoStruct_has_audio_get
    if _newclass:
        has_audio = _swig_property(_openshot.EffectInfoStruct_has_audio_get, _openshot.EffectInfoStruct_has_audio_set)

    def __init__(self):
        """__init__(openshot::EffectInfoStruct self) -> EffectInfoStruct"""
        this = _openshot.new_EffectInfoStruct()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_EffectInfoStruct
    __del__ = lambda self: None
EffectInfoStruct_swigregister = _openshot.EffectInfoStruct_swigregister
EffectInfoStruct_swigregister(EffectInfoStruct)

class EffectBase(ClipBase):
    """Proxy of C++ openshot::EffectBase class."""

    __swig_setmethods__ = {}
    for _s in [ClipBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EffectBase, name, value)
    __swig_getmethods__ = {}
    for _s in [ClipBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, EffectBase, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_setmethods__["info"] = _openshot.EffectBase_info_set
    __swig_getmethods__["info"] = _openshot.EffectBase_info_get
    if _newclass:
        info = _swig_property(_openshot.EffectBase_info_get, _openshot.EffectBase_info_set)

    def DisplayInfo(self):
        """DisplayInfo(EffectBase self)"""
        return _openshot.EffectBase_DisplayInfo(self)


    def GetFrame(self, frame, frame_number):
        """GetFrame(EffectBase self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.EffectBase_GetFrame(self, frame, frame_number)


    def InitEffectInfo(self):
        """InitEffectInfo(EffectBase self)"""
        return _openshot.EffectBase_InitEffectInfo(self)


    def Json(self):
        """Json(EffectBase self) -> std::string"""
        return _openshot.EffectBase_Json(self)


    def SetJson(self, value):
        """SetJson(EffectBase self, std::string value)"""
        return _openshot.EffectBase_SetJson(self, value)


    def JsonValue(self):
        """JsonValue(EffectBase self) -> Json::Value"""
        return _openshot.EffectBase_JsonValue(self)


    def SetJsonValue(self, root):
        """SetJsonValue(EffectBase self, Json::Value root)"""
        return _openshot.EffectBase_SetJsonValue(self, root)


    def JsonInfo(self):
        """JsonInfo(EffectBase self) -> Json::Value"""
        return _openshot.EffectBase_JsonInfo(self)


    def Order(self, *args):
        """
        Order(EffectBase self) -> int
        Order(EffectBase self, int new_order)
        """
        return _openshot.EffectBase_Order(self, *args)

    __swig_destroy__ = _openshot.delete_EffectBase
    __del__ = lambda self: None
EffectBase_swigregister = _openshot.EffectBase_swigregister
EffectBase_swigregister(EffectBase)

class EffectInfo(_object):
    """Proxy of C++ openshot::EffectInfo class."""

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

    def CreateEffect(self, effect_type):
        """CreateEffect(EffectInfo self, std::string effect_type) -> EffectBase"""
        return _openshot.EffectInfo_CreateEffect(self, effect_type)


    def Json():
        """Json() -> std::string"""
        return _openshot.EffectInfo_Json()

    Json = staticmethod(Json)

    def JsonValue():
        """JsonValue() -> Json::Value"""
        return _openshot.EffectInfo_JsonValue()

    JsonValue = staticmethod(JsonValue)

    def __init__(self):
        """__init__(openshot::EffectInfo self) -> EffectInfo"""
        this = _openshot.new_EffectInfo()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_EffectInfo
    __del__ = lambda self: None
EffectInfo_swigregister = _openshot.EffectInfo_swigregister
EffectInfo_swigregister(EffectInfo)

def EffectInfo_Json():
    """EffectInfo_Json() -> std::string"""
    return _openshot.EffectInfo_Json()

def EffectInfo_JsonValue():
    """EffectInfo_JsonValue() -> Json::Value"""
    return _openshot.EffectInfo_JsonValue()

GRAVITY_TOP_LEFT = _openshot.GRAVITY_TOP_LEFT
GRAVITY_TOP = _openshot.GRAVITY_TOP
GRAVITY_TOP_RIGHT = _openshot.GRAVITY_TOP_RIGHT
GRAVITY_LEFT = _openshot.GRAVITY_LEFT
GRAVITY_CENTER = _openshot.GRAVITY_CENTER
GRAVITY_RIGHT = _openshot.GRAVITY_RIGHT
GRAVITY_BOTTOM_LEFT = _openshot.GRAVITY_BOTTOM_LEFT
GRAVITY_BOTTOM = _openshot.GRAVITY_BOTTOM
GRAVITY_BOTTOM_RIGHT = _openshot.GRAVITY_BOTTOM_RIGHT
SCALE_CROP = _openshot.SCALE_CROP
SCALE_FIT = _openshot.SCALE_FIT
SCALE_STRETCH = _openshot.SCALE_STRETCH
SCALE_NONE = _openshot.SCALE_NONE
ANCHOR_CANVAS = _openshot.ANCHOR_CANVAS
ANCHOR_VIEWPORT = _openshot.ANCHOR_VIEWPORT
FRAME_DISPLAY_NONE = _openshot.FRAME_DISPLAY_NONE
FRAME_DISPLAY_CLIP = _openshot.FRAME_DISPLAY_CLIP
FRAME_DISPLAY_TIMELINE = _openshot.FRAME_DISPLAY_TIMELINE
FRAME_DISPLAY_BOTH = _openshot.FRAME_DISPLAY_BOTH
class BaseException(_object):
    """Proxy of C++ openshot::BaseException class."""

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

    def __init__(self, message):
        """__init__(openshot::BaseException self, std::string message) -> BaseException"""
        this = _openshot.new_BaseException(message)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_BaseException
    __del__ = lambda self: None

    def what(self):
        """what(BaseException self) -> char const *"""
        return _openshot.BaseException_what(self)

BaseException_swigregister = _openshot.BaseException_swigregister
BaseException_swigregister(BaseException)

class ChunkNotFound(BaseException):
    """Proxy of C++ openshot::ChunkNotFound class."""

    __swig_setmethods__ = {}
    for _s in [BaseException]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChunkNotFound, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseException]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ChunkNotFound, name)
    __repr__ = _swig_repr
    __swig_setmethods__["file_path"] = _openshot.ChunkNotFound_file_path_set
    __swig_getmethods__["file_path"] = _openshot.ChunkNotFound_file_path_get
    if _newclass:
        file_path = _swig_property(_openshot.ChunkNotFound_file_path_get, _openshot.ChunkNotFound_file_path_set)
    __swig_setmethods__["frame_number"] = _openshot.ChunkNotFound_frame_number_set
    __swig_getmethods__["frame_number"] = _openshot.ChunkNotFound_frame_number_get
    if _newclass:
        frame_number = _swig_property(_openshot.ChunkNotFound_frame_number_get, _openshot.ChunkNotFound_frame_number_set)
    __swig_setmethods__["chunk_number"] = _openshot.ChunkNotFound_chunk_number_set
    __swig_getmethods__["chunk_number"] = _openshot.ChunkNotFound_chunk_number_get
    if _newclass:
        chunk_number = _swig_property(_openshot.ChunkNotFound_chunk_number_get, _openshot.ChunkNotFound_chunk_number_set)
    __swig_setmethods__["chunk_frame"] = _openshot.ChunkNotFound_chunk_frame_set
    __swig_getmethods__["chunk_frame"] = _openshot.ChunkNotFound_chunk_frame_get
    if _newclass:
        chunk_frame = _swig_property(_openshot.ChunkNotFound_chunk_frame_get, _openshot.ChunkNotFound_chunk_frame_set)

    def __init__(self, message, frame_number, chunk_number, chunk_frame):
        """__init__(openshot::ChunkNotFound self, std::string message, int64_t frame_number, int64_t chunk_number, int64_t chunk_frame) -> ChunkNotFound"""
        this = _openshot.new_ChunkNotFound(message, frame_number, chunk_number, chunk_frame)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_ChunkNotFound
    __del__ = lambda self: None
ChunkNotFound_swigregister = _openshot.ChunkNotFound_swigregister
ChunkNotFound_swigregister(ChunkNotFound)

class DecklinkError(BaseException):
    """Proxy of C++ openshot::DecklinkError class."""

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

    def __init__(self, message):
        """__init__(openshot::DecklinkError self, std::string message) -> DecklinkError"""
        this = _openshot.new_DecklinkError(message)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_DecklinkError
    __del__ = lambda self: None
DecklinkError_swigregister = _openshot.DecklinkError_swigregister
DecklinkError_swigregister(DecklinkError)

class ErrorDecodingAudio(BaseException):
    """Proxy of C++ openshot::ErrorDecodingAudio class."""

    __swig_setmethods__ = {}
    for _s in [BaseException]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ErrorDecodingAudio, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseException]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ErrorDecodingAudio, name)
    __repr__ = _swig_repr
    __swig_setmethods__["file_path"] = _openshot.ErrorDecodingAudio_file_path_set
    __swig_getmethods__["file_path"] = _openshot.ErrorDecodingAudio_file_path_get
    if _newclass:
        file_path = _swig_property(_openshot.ErrorDecodingAudio_file_path_get, _openshot.ErrorDecodingAudio_file_path_set)
    __swig_setmethods__["frame_number"] = _openshot.ErrorDecodingAudio_frame_number_set
    __swig_getmethods__["frame_number"] = _openshot.ErrorDecodingAudio_frame_number_get
    if _newclass:
        frame_number = _swig_property(_openshot.ErrorDecodingAudio_frame_number_get, _openshot.ErrorDecodingAudio_frame_number_set)

    def __init__(self, message, frame_number):
        """__init__(openshot::ErrorDecodingAudio self, std::string message, int64_t frame_number) -> ErrorDecodingAudio"""
        this = _openshot.new_ErrorDecodingAudio(message, frame_number)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_ErrorDecodingAudio
    __del__ = lambda self: None
ErrorDecodingAudio_swigregister = _openshot.ErrorDecodingAudio_swigregister
ErrorDecodingAudio_swigregister(ErrorDecodingAudio)

class ErrorEncodingAudio(BaseException):
    """Proxy of C++ openshot::ErrorEncodingAudio class."""

    __swig_setmethods__ = {}
    for _s in [BaseException]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ErrorEncodingAudio, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseException]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ErrorEncodingAudio, name)
    __repr__ = _swig_repr
    __swig_setmethods__["file_path"] = _openshot.ErrorEncodingAudio_file_path_set
    __swig_getmethods__["file_path"] = _openshot.ErrorEncodingAudio_file_path_get
    if _newclass:
        file_path = _swig_property(_openshot.ErrorEncodingAudio_file_path_get, _openshot.ErrorEncodingAudio_file_path_set)
    __swig_setmethods__["frame_number"] = _openshot.ErrorEncodingAudio_frame_number_set
    __swig_getmethods__["frame_number"] = _openshot.ErrorEncodingAudio_frame_number_get
    if _newclass:
        frame_number = _swig_property(_openshot.ErrorEncodingAudio_frame_number_get, _openshot.ErrorEncodingAudio_frame_number_set)

    def __init__(self, message, frame_number):
        """__init__(openshot::ErrorEncodingAudio self, std::string message, int64_t frame_number) -> ErrorEncodingAudio"""
        this = _openshot.new_ErrorEncodingAudio(message, frame_number)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_ErrorEncodingAudio
    __del__ = lambda self: None
ErrorEncodingAudio_swigregister = _openshot.ErrorEncodingAudio_swigregister
ErrorEncodingAudio_swigregister(ErrorEncodingAudio)

class ErrorEncodingVideo(BaseException):
    """Proxy of C++ openshot::ErrorEncodingVideo class."""

    __swig_setmethods__ = {}
    for _s in [BaseException]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ErrorEncodingVideo, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseException]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ErrorEncodingVideo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["file_path"] = _openshot.ErrorEncodingVideo_file_path_set
    __swig_getmethods__["file_path"] = _openshot.ErrorEncodingVideo_file_path_get
    if _newclass:
        file_path = _swig_property(_openshot.ErrorEncodingVideo_file_path_get, _openshot.ErrorEncodingVideo_file_path_set)
    __swig_setmethods__["frame_number"] = _openshot.ErrorEncodingVideo_frame_number_set
    __swig_getmethods__["frame_number"] = _openshot.ErrorEncodingVideo_frame_number_get
    if _newclass:
        frame_number = _swig_property(_openshot.ErrorEncodingVideo_frame_number_get, _openshot.ErrorEncodingVideo_frame_number_set)

    def __init__(self, message, frame_number):
        """__init__(openshot::ErrorEncodingVideo self, std::string message, int64_t frame_number) -> ErrorEncodingVideo"""
        this = _openshot.new_ErrorEncodingVideo(message, frame_number)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_ErrorEncodingVideo
    __del__ = lambda self: None
ErrorEncodingVideo_swigregister = _openshot.ErrorEncodingVideo_swigregister
ErrorEncodingVideo_swigregister(ErrorEncodingVideo)

class InvalidChannels(BaseException):
    """Proxy of C++ openshot::InvalidChannels class."""

    __swig_setmethods__ = {}
    for _s in [BaseException]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InvalidChannels, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseException]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, InvalidChannels, name)
    __repr__ = _swig_repr
    __swig_setmethods__["file_path"] = _openshot.InvalidChannels_file_path_set
    __swig_getmethods__["file_path"] = _openshot.InvalidChannels_file_path_get
    if _newclass:
        file_path = _swig_property(_openshot.InvalidChannels_file_path_get, _openshot.InvalidChannels_file_path_set)

    def __init__(self, message, file_path):
        """__init__(openshot::InvalidChannels self, std::string message, std::string file_path) -> InvalidChannels"""
        this = _openshot.new_InvalidChannels(message, file_path)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_InvalidChannels
    __del__ = lambda self: None
InvalidChannels_swigregister = _openshot.InvalidChannels_swigregister
InvalidChannels_swigregister(InvalidChannels)

class InvalidCodec(BaseException):
    """Proxy of C++ openshot::InvalidCodec class."""

    __swig_setmethods__ = {}
    for _s in [BaseException]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InvalidCodec, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseException]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, InvalidCodec, name)
    __repr__ = _swig_repr
    __swig_setmethods__["file_path"] = _openshot.InvalidCodec_file_path_set
    __swig_getmethods__["file_path"] = _openshot.InvalidCodec_file_path_get
    if _newclass:
        file_path = _swig_property(_openshot.InvalidCodec_file_path_get, _openshot.InvalidCodec_file_path_set)

    def __init__(self, message, file_path):
        """__init__(openshot::InvalidCodec self, std::string message, std::string file_path) -> InvalidCodec"""
        this = _openshot.new_InvalidCodec(message, file_path)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_InvalidCodec
    __del__ = lambda self: None
InvalidCodec_swigregister = _openshot.InvalidCodec_swigregister
InvalidCodec_swigregister(InvalidCodec)

class InvalidFile(BaseException):
    """Proxy of C++ openshot::InvalidFile class."""

    __swig_setmethods__ = {}
    for _s in [BaseException]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InvalidFile, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseException]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, InvalidFile, name)
    __repr__ = _swig_repr
    __swig_setmethods__["file_path"] = _openshot.InvalidFile_file_path_set
    __swig_getmethods__["file_path"] = _openshot.InvalidFile_file_path_get
    if _newclass:
        file_path = _swig_property(_openshot.InvalidFile_file_path_get, _openshot.InvalidFile_file_path_set)

    def __init__(self, message, file_path):
        """__init__(openshot::InvalidFile self, std::string message, std::string file_path) -> InvalidFile"""
        this = _openshot.new_InvalidFile(message, file_path)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_InvalidFile
    __del__ = lambda self: None
InvalidFile_swigregister = _openshot.InvalidFile_swigregister
InvalidFile_swigregister(InvalidFile)

class InvalidFormat(BaseException):
    """Proxy of C++ openshot::InvalidFormat class."""

    __swig_setmethods__ = {}
    for _s in [BaseException]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InvalidFormat, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseException]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, InvalidFormat, name)
    __repr__ = _swig_repr
    __swig_setmethods__["file_path"] = _openshot.InvalidFormat_file_path_set
    __swig_getmethods__["file_path"] = _openshot.InvalidFormat_file_path_get
    if _newclass:
        file_path = _swig_property(_openshot.InvalidFormat_file_path_get, _openshot.InvalidFormat_file_path_set)

    def __init__(self, message, file_path):
        """__init__(openshot::InvalidFormat self, std::string message, std::string file_path) -> InvalidFormat"""
        this = _openshot.new_InvalidFormat(message, file_path)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_InvalidFormat
    __del__ = lambda self: None
InvalidFormat_swigregister = _openshot.InvalidFormat_swigregister
InvalidFormat_swigregister(InvalidFormat)

class InvalidJSON(BaseException):
    """Proxy of C++ openshot::InvalidJSON class."""

    __swig_setmethods__ = {}
    for _s in [BaseException]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InvalidJSON, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseException]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, InvalidJSON, name)
    __repr__ = _swig_repr
    __swig_setmethods__["file_path"] = _openshot.InvalidJSON_file_path_set
    __swig_getmethods__["file_path"] = _openshot.InvalidJSON_file_path_get
    if _newclass:
        file_path = _swig_property(_openshot.InvalidJSON_file_path_get, _openshot.InvalidJSON_file_path_set)

    def __init__(self, message, file_path):
        """__init__(openshot::InvalidJSON self, std::string message, std::string file_path) -> InvalidJSON"""
        this = _openshot.new_InvalidJSON(message, file_path)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_InvalidJSON
    __del__ = lambda self: None
InvalidJSON_swigregister = _openshot.InvalidJSON_swigregister
InvalidJSON_swigregister(InvalidJSON)

class InvalidOptions(BaseException):
    """Proxy of C++ openshot::InvalidOptions class."""

    __swig_setmethods__ = {}
    for _s in [BaseException]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InvalidOptions, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseException]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, InvalidOptions, name)
    __repr__ = _swig_repr
    __swig_setmethods__["file_path"] = _openshot.InvalidOptions_file_path_set
    __swig_getmethods__["file_path"] = _openshot.InvalidOptions_file_path_get
    if _newclass:
        file_path = _swig_property(_openshot.InvalidOptions_file_path_get, _openshot.InvalidOptions_file_path_set)

    def __init__(self, message, file_path):
        """__init__(openshot::InvalidOptions self, std::string message, std::string file_path) -> InvalidOptions"""
        this = _openshot.new_InvalidOptions(message, file_path)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_InvalidOptions
    __del__ = lambda self: None
InvalidOptions_swigregister = _openshot.InvalidOptions_swigregister
InvalidOptions_swigregister(InvalidOptions)

class InvalidSampleRate(BaseException):
    """Proxy of C++ openshot::InvalidSampleRate class."""

    __swig_setmethods__ = {}
    for _s in [BaseException]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InvalidSampleRate, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseException]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, InvalidSampleRate, name)
    __repr__ = _swig_repr
    __swig_setmethods__["file_path"] = _openshot.InvalidSampleRate_file_path_set
    __swig_getmethods__["file_path"] = _openshot.InvalidSampleRate_file_path_get
    if _newclass:
        file_path = _swig_property(_openshot.InvalidSampleRate_file_path_get, _openshot.InvalidSampleRate_file_path_set)

    def __init__(self, message, file_path):
        """__init__(openshot::InvalidSampleRate self, std::string message, std::string file_path) -> InvalidSampleRate"""
        this = _openshot.new_InvalidSampleRate(message, file_path)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_InvalidSampleRate
    __del__ = lambda self: None
InvalidSampleRate_swigregister = _openshot.InvalidSampleRate_swigregister
InvalidSampleRate_swigregister(InvalidSampleRate)

class InvalidJSONKey(BaseException):
    """Proxy of C++ openshot::InvalidJSONKey class."""

    __swig_setmethods__ = {}
    for _s in [BaseException]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InvalidJSONKey, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseException]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, InvalidJSONKey, name)
    __repr__ = _swig_repr
    __swig_setmethods__["json"] = _openshot.InvalidJSONKey_json_set
    __swig_getmethods__["json"] = _openshot.InvalidJSONKey_json_get
    if _newclass:
        json = _swig_property(_openshot.InvalidJSONKey_json_get, _openshot.InvalidJSONKey_json_set)

    def __init__(self, message, json):
        """__init__(openshot::InvalidJSONKey self, std::string message, std::string json) -> InvalidJSONKey"""
        this = _openshot.new_InvalidJSONKey(message, json)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_InvalidJSONKey
    __del__ = lambda self: None
InvalidJSONKey_swigregister = _openshot.InvalidJSONKey_swigregister
InvalidJSONKey_swigregister(InvalidJSONKey)

class NoStreamsFound(BaseException):
    """Proxy of C++ openshot::NoStreamsFound class."""

    __swig_setmethods__ = {}
    for _s in [BaseException]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NoStreamsFound, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseException]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, NoStreamsFound, name)
    __repr__ = _swig_repr
    __swig_setmethods__["file_path"] = _openshot.NoStreamsFound_file_path_set
    __swig_getmethods__["file_path"] = _openshot.NoStreamsFound_file_path_get
    if _newclass:
        file_path = _swig_property(_openshot.NoStreamsFound_file_path_get, _openshot.NoStreamsFound_file_path_set)

    def __init__(self, message, file_path):
        """__init__(openshot::NoStreamsFound self, std::string message, std::string file_path) -> NoStreamsFound"""
        this = _openshot.new_NoStreamsFound(message, file_path)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_NoStreamsFound
    __del__ = lambda self: None
NoStreamsFound_swigregister = _openshot.NoStreamsFound_swigregister
NoStreamsFound_swigregister(NoStreamsFound)

class OutOfBoundsFrame(BaseException):
    """Proxy of C++ openshot::OutOfBoundsFrame class."""

    __swig_setmethods__ = {}
    for _s in [BaseException]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OutOfBoundsFrame, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseException]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, OutOfBoundsFrame, name)
    __repr__ = _swig_repr
    __swig_setmethods__["FrameRequested"] = _openshot.OutOfBoundsFrame_FrameRequested_set
    __swig_getmethods__["FrameRequested"] = _openshot.OutOfBoundsFrame_FrameRequested_get
    if _newclass:
        FrameRequested = _swig_property(_openshot.OutOfBoundsFrame_FrameRequested_get, _openshot.OutOfBoundsFrame_FrameRequested_set)
    __swig_setmethods__["MaxFrames"] = _openshot.OutOfBoundsFrame_MaxFrames_set
    __swig_getmethods__["MaxFrames"] = _openshot.OutOfBoundsFrame_MaxFrames_get
    if _newclass:
        MaxFrames = _swig_property(_openshot.OutOfBoundsFrame_MaxFrames_get, _openshot.OutOfBoundsFrame_MaxFrames_set)

    def __init__(self, message, frame_requested, max_frames):
        """__init__(openshot::OutOfBoundsFrame self, std::string message, int64_t frame_requested, int64_t max_frames) -> OutOfBoundsFrame"""
        this = _openshot.new_OutOfBoundsFrame(message, frame_requested, max_frames)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_OutOfBoundsFrame
    __del__ = lambda self: None
OutOfBoundsFrame_swigregister = _openshot.OutOfBoundsFrame_swigregister
OutOfBoundsFrame_swigregister(OutOfBoundsFrame)

class OutOfBoundsPoint(BaseException):
    """Proxy of C++ openshot::OutOfBoundsPoint class."""

    __swig_setmethods__ = {}
    for _s in [BaseException]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OutOfBoundsPoint, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseException]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, OutOfBoundsPoint, name)
    __repr__ = _swig_repr
    __swig_setmethods__["PointRequested"] = _openshot.OutOfBoundsPoint_PointRequested_set
    __swig_getmethods__["PointRequested"] = _openshot.OutOfBoundsPoint_PointRequested_get
    if _newclass:
        PointRequested = _swig_property(_openshot.OutOfBoundsPoint_PointRequested_get, _openshot.OutOfBoundsPoint_PointRequested_set)
    __swig_setmethods__["MaxPoints"] = _openshot.OutOfBoundsPoint_MaxPoints_set
    __swig_getmethods__["MaxPoints"] = _openshot.OutOfBoundsPoint_MaxPoints_get
    if _newclass:
        MaxPoints = _swig_property(_openshot.OutOfBoundsPoint_MaxPoints_get, _openshot.OutOfBoundsPoint_MaxPoints_set)

    def __init__(self, message, point_requested, max_points):
        """__init__(openshot::OutOfBoundsPoint self, std::string message, int point_requested, int max_points) -> OutOfBoundsPoint"""
        this = _openshot.new_OutOfBoundsPoint(message, point_requested, max_points)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_OutOfBoundsPoint
    __del__ = lambda self: None
OutOfBoundsPoint_swigregister = _openshot.OutOfBoundsPoint_swigregister
OutOfBoundsPoint_swigregister(OutOfBoundsPoint)

class OutOfMemory(BaseException):
    """Proxy of C++ openshot::OutOfMemory class."""

    __swig_setmethods__ = {}
    for _s in [BaseException]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OutOfMemory, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseException]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, OutOfMemory, name)
    __repr__ = _swig_repr
    __swig_setmethods__["file_path"] = _openshot.OutOfMemory_file_path_set
    __swig_getmethods__["file_path"] = _openshot.OutOfMemory_file_path_get
    if _newclass:
        file_path = _swig_property(_openshot.OutOfMemory_file_path_get, _openshot.OutOfMemory_file_path_set)

    def __init__(self, message, file_path):
        """__init__(openshot::OutOfMemory self, std::string message, std::string file_path) -> OutOfMemory"""
        this = _openshot.new_OutOfMemory(message, file_path)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_OutOfMemory
    __del__ = lambda self: None
OutOfMemory_swigregister = _openshot.OutOfMemory_swigregister
OutOfMemory_swigregister(OutOfMemory)

class ReaderClosed(BaseException):
    """Proxy of C++ openshot::ReaderClosed class."""

    __swig_setmethods__ = {}
    for _s in [BaseException]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ReaderClosed, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseException]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ReaderClosed, name)
    __repr__ = _swig_repr
    __swig_setmethods__["file_path"] = _openshot.ReaderClosed_file_path_set
    __swig_getmethods__["file_path"] = _openshot.ReaderClosed_file_path_get
    if _newclass:
        file_path = _swig_property(_openshot.ReaderClosed_file_path_get, _openshot.ReaderClosed_file_path_set)

    def __init__(self, message, file_path):
        """__init__(openshot::ReaderClosed self, std::string message, std::string file_path) -> ReaderClosed"""
        this = _openshot.new_ReaderClosed(message, file_path)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_ReaderClosed
    __del__ = lambda self: None
ReaderClosed_swigregister = _openshot.ReaderClosed_swigregister
ReaderClosed_swigregister(ReaderClosed)

class ResampleError(BaseException):
    """Proxy of C++ openshot::ResampleError class."""

    __swig_setmethods__ = {}
    for _s in [BaseException]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ResampleError, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseException]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ResampleError, name)
    __repr__ = _swig_repr
    __swig_setmethods__["file_path"] = _openshot.ResampleError_file_path_set
    __swig_getmethods__["file_path"] = _openshot.ResampleError_file_path_get
    if _newclass:
        file_path = _swig_property(_openshot.ResampleError_file_path_get, _openshot.ResampleError_file_path_set)

    def __init__(self, message, file_path):
        """__init__(openshot::ResampleError self, std::string message, std::string file_path) -> ResampleError"""
        this = _openshot.new_ResampleError(message, file_path)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_ResampleError
    __del__ = lambda self: None
ResampleError_swigregister = _openshot.ResampleError_swigregister
ResampleError_swigregister(ResampleError)

class TooManySeeks(BaseException):
    """Proxy of C++ openshot::TooManySeeks class."""

    __swig_setmethods__ = {}
    for _s in [BaseException]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TooManySeeks, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseException]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TooManySeeks, name)
    __repr__ = _swig_repr
    __swig_setmethods__["file_path"] = _openshot.TooManySeeks_file_path_set
    __swig_getmethods__["file_path"] = _openshot.TooManySeeks_file_path_get
    if _newclass:
        file_path = _swig_property(_openshot.TooManySeeks_file_path_get, _openshot.TooManySeeks_file_path_set)

    def __init__(self, message, file_path):
        """__init__(openshot::TooManySeeks self, std::string message, std::string file_path) -> TooManySeeks"""
        this = _openshot.new_TooManySeeks(message, file_path)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_TooManySeeks
    __del__ = lambda self: None
TooManySeeks_swigregister = _openshot.TooManySeeks_swigregister
TooManySeeks_swigregister(TooManySeeks)

class WriterClosed(BaseException):
    """Proxy of C++ openshot::WriterClosed class."""

    __swig_setmethods__ = {}
    for _s in [BaseException]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WriterClosed, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseException]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, WriterClosed, name)
    __repr__ = _swig_repr
    __swig_setmethods__["file_path"] = _openshot.WriterClosed_file_path_set
    __swig_getmethods__["file_path"] = _openshot.WriterClosed_file_path_get
    if _newclass:
        file_path = _swig_property(_openshot.WriterClosed_file_path_get, _openshot.WriterClosed_file_path_set)

    def __init__(self, message, file_path):
        """__init__(openshot::WriterClosed self, std::string message, std::string file_path) -> WriterClosed"""
        this = _openshot.new_WriterClosed(message, file_path)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_WriterClosed
    __del__ = lambda self: None
WriterClosed_swigregister = _openshot.WriterClosed_swigregister
WriterClosed_swigregister(WriterClosed)

class AudioLocation(_object):
    """Proxy of C++ openshot::AudioLocation class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AudioLocation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AudioLocation, name)
    __repr__ = _swig_repr
    __swig_setmethods__["frame"] = _openshot.AudioLocation_frame_set
    __swig_getmethods__["frame"] = _openshot.AudioLocation_frame_get
    if _newclass:
        frame = _swig_property(_openshot.AudioLocation_frame_get, _openshot.AudioLocation_frame_set)
    __swig_setmethods__["sample_start"] = _openshot.AudioLocation_sample_start_set
    __swig_getmethods__["sample_start"] = _openshot.AudioLocation_sample_start_get
    if _newclass:
        sample_start = _swig_property(_openshot.AudioLocation_sample_start_get, _openshot.AudioLocation_sample_start_set)

    def is_near(self, location, samples_per_frame, amount):
        """is_near(AudioLocation self, AudioLocation location, int samples_per_frame, int64_t amount) -> bool"""
        return _openshot.AudioLocation_is_near(self, location, samples_per_frame, amount)


    def __init__(self):
        """__init__(openshot::AudioLocation self) -> AudioLocation"""
        this = _openshot.new_AudioLocation()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_AudioLocation
    __del__ = lambda self: None
AudioLocation_swigregister = _openshot.AudioLocation_swigregister
AudioLocation_swigregister(AudioLocation)

class FFmpegReader(ReaderBase):
    """Proxy of C++ openshot::FFmpegReader class."""

    __swig_setmethods__ = {}
    for _s in [ReaderBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FFmpegReader, name, value)
    __swig_getmethods__ = {}
    for _s in [ReaderBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FFmpegReader, name)
    __repr__ = _swig_repr
    __swig_setmethods__["final_cache"] = _openshot.FFmpegReader_final_cache_set
    __swig_getmethods__["final_cache"] = _openshot.FFmpegReader_final_cache_get
    if _newclass:
        final_cache = _swig_property(_openshot.FFmpegReader_final_cache_get, _openshot.FFmpegReader_final_cache_set)
    __swig_setmethods__["enable_seek"] = _openshot.FFmpegReader_enable_seek_set
    __swig_getmethods__["enable_seek"] = _openshot.FFmpegReader_enable_seek_get
    if _newclass:
        enable_seek = _swig_property(_openshot.FFmpegReader_enable_seek_get, _openshot.FFmpegReader_enable_seek_set)

    def __init__(self, *args):
        """
        __init__(openshot::FFmpegReader self, std::string path) -> FFmpegReader
        __init__(openshot::FFmpegReader self, std::string path, bool inspect_reader) -> FFmpegReader
        """
        this = _openshot.new_FFmpegReader(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_FFmpegReader
    __del__ = lambda self: None

    def Close(self):
        """Close(FFmpegReader self)"""
        return _openshot.FFmpegReader_Close(self)


    def GetCache(self):
        """GetCache(FFmpegReader self) -> CacheMemory"""
        return _openshot.FFmpegReader_GetCache(self)


    def GetFrame(self, requested_frame):
        """GetFrame(FFmpegReader self, int64_t requested_frame) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.FFmpegReader_GetFrame(self, requested_frame)


    def IsOpen(self):
        """IsOpen(FFmpegReader self) -> bool"""
        return _openshot.FFmpegReader_IsOpen(self)


    def Name(self):
        """Name(FFmpegReader self) -> std::string"""
        return _openshot.FFmpegReader_Name(self)


    def Json(self):
        """Json(FFmpegReader self) -> std::string"""
        return _openshot.FFmpegReader_Json(self)


    def SetJson(self, value):
        """SetJson(FFmpegReader self, std::string value)"""
        return _openshot.FFmpegReader_SetJson(self, value)


    def JsonValue(self):
        """JsonValue(FFmpegReader self) -> Json::Value"""
        return _openshot.FFmpegReader_JsonValue(self)


    def SetJsonValue(self, root):
        """SetJsonValue(FFmpegReader self, Json::Value root)"""
        return _openshot.FFmpegReader_SetJsonValue(self, root)


    def Open(self):
        """Open(FFmpegReader self)"""
        return _openshot.FFmpegReader_Open(self)

FFmpegReader_swigregister = _openshot.FFmpegReader_swigregister
FFmpegReader_swigregister(FFmpegReader)

VIDEO_STREAM = _openshot.VIDEO_STREAM
AUDIO_STREAM = _openshot.AUDIO_STREAM
class FFmpegWriter(WriterBase):
    """Proxy of C++ openshot::FFmpegWriter class."""

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

    def __init__(self, path):
        """__init__(openshot::FFmpegWriter self, std::string path) -> FFmpegWriter"""
        this = _openshot.new_FFmpegWriter(path)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def Close(self):
        """Close(FFmpegWriter self)"""
        return _openshot.FFmpegWriter_Close(self)


    def GetCacheSize(self):
        """GetCacheSize(FFmpegWriter self) -> int"""
        return _openshot.FFmpegWriter_GetCacheSize(self)


    def IsOpen(self):
        """IsOpen(FFmpegWriter self) -> bool"""
        return _openshot.FFmpegWriter_IsOpen(self)


    def Open(self):
        """Open(FFmpegWriter self)"""
        return _openshot.FFmpegWriter_Open(self)


    def OutputStreamInfo(self):
        """OutputStreamInfo(FFmpegWriter self)"""
        return _openshot.FFmpegWriter_OutputStreamInfo(self)


    def PrepareStreams(self):
        """PrepareStreams(FFmpegWriter self)"""
        return _openshot.FFmpegWriter_PrepareStreams(self)


    def RemoveScalers(self):
        """RemoveScalers(FFmpegWriter self)"""
        return _openshot.FFmpegWriter_RemoveScalers(self)


    def ResampleAudio(self, sample_rate, channels):
        """ResampleAudio(FFmpegWriter self, int sample_rate, int channels)"""
        return _openshot.FFmpegWriter_ResampleAudio(self, sample_rate, channels)


    def SetAudioOptions(self, has_audio, codec, sample_rate, channels, channel_layout, bit_rate):
        """SetAudioOptions(FFmpegWriter self, bool has_audio, std::string codec, int sample_rate, int channels, openshot::ChannelLayout channel_layout, int bit_rate)"""
        return _openshot.FFmpegWriter_SetAudioOptions(self, has_audio, codec, sample_rate, channels, channel_layout, bit_rate)


    def SetCacheSize(self, new_size):
        """SetCacheSize(FFmpegWriter self, int new_size)"""
        return _openshot.FFmpegWriter_SetCacheSize(self, new_size)


    def SetVideoOptions(self, has_video, codec, fps, width, height, pixel_ratio, interlaced, top_field_first, bit_rate):
        """SetVideoOptions(FFmpegWriter self, bool has_video, std::string codec, Fraction fps, int width, int height, Fraction pixel_ratio, bool interlaced, bool top_field_first, int bit_rate)"""
        return _openshot.FFmpegWriter_SetVideoOptions(self, has_video, codec, fps, width, height, pixel_ratio, interlaced, top_field_first, bit_rate)


    def SetOption(self, stream, name, value):
        """SetOption(FFmpegWriter self, openshot::StreamType stream, std::string name, std::string value)"""
        return _openshot.FFmpegWriter_SetOption(self, stream, name, value)


    def WriteHeader(self):
        """WriteHeader(FFmpegWriter self)"""
        return _openshot.FFmpegWriter_WriteHeader(self)


    def WriteFrame(self, *args):
        """
        WriteFrame(FFmpegWriter self, std::shared_ptr< openshot::Frame > frame)
        WriteFrame(FFmpegWriter self, ReaderBase reader, int64_t start, int64_t length)
        """
        return _openshot.FFmpegWriter_WriteFrame(self, *args)


    def WriteTrailer(self):
        """WriteTrailer(FFmpegWriter self)"""
        return _openshot.FFmpegWriter_WriteTrailer(self)

    __swig_destroy__ = _openshot.delete_FFmpegWriter
    __del__ = lambda self: None
FFmpegWriter_swigregister = _openshot.FFmpegWriter_swigregister
FFmpegWriter_swigregister(FFmpegWriter)

class Fraction(_object):
    """Proxy of C++ openshot::Fraction class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Fraction, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Fraction, name)
    __repr__ = _swig_repr
    __swig_setmethods__["num"] = _openshot.Fraction_num_set
    __swig_getmethods__["num"] = _openshot.Fraction_num_get
    if _newclass:
        num = _swig_property(_openshot.Fraction_num_get, _openshot.Fraction_num_set)
    __swig_setmethods__["den"] = _openshot.Fraction_den_set
    __swig_getmethods__["den"] = _openshot.Fraction_den_get
    if _newclass:
        den = _swig_property(_openshot.Fraction_den_get, _openshot.Fraction_den_set)

    def __init__(self, *args):
        """
        __init__(openshot::Fraction self) -> Fraction
        __init__(openshot::Fraction self, int num, int den) -> Fraction
        """
        this = _openshot.new_Fraction(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def GreatestCommonDenominator(self):
        """GreatestCommonDenominator(Fraction self) -> int"""
        return _openshot.Fraction_GreatestCommonDenominator(self)


    def Reduce(self):
        """Reduce(Fraction self)"""
        return _openshot.Fraction_Reduce(self)


    def ToFloat(self):
        """ToFloat(Fraction self) -> float"""
        return _openshot.Fraction_ToFloat(self)


    def ToDouble(self):
        """ToDouble(Fraction self) -> double"""
        return _openshot.Fraction_ToDouble(self)


    def ToInt(self):
        """ToInt(Fraction self) -> int"""
        return _openshot.Fraction_ToInt(self)


    def Reciprocal(self):
        """Reciprocal(Fraction self) -> Fraction"""
        return _openshot.Fraction_Reciprocal(self)

    __swig_destroy__ = _openshot.delete_Fraction
    __del__ = lambda self: None
Fraction_swigregister = _openshot.Fraction_swigregister
Fraction_swigregister(Fraction)

class Frame(_object):
    """Proxy of C++ openshot::Frame class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Frame, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Frame, name)
    __repr__ = _swig_repr
    __swig_setmethods__["number"] = _openshot.Frame_number_set
    __swig_getmethods__["number"] = _openshot.Frame_number_get
    if _newclass:
        number = _swig_property(_openshot.Frame_number_get, _openshot.Frame_number_set)
    __swig_setmethods__["has_audio_data"] = _openshot.Frame_has_audio_data_set
    __swig_getmethods__["has_audio_data"] = _openshot.Frame_has_audio_data_get
    if _newclass:
        has_audio_data = _swig_property(_openshot.Frame_has_audio_data_get, _openshot.Frame_has_audio_data_set)
    __swig_setmethods__["has_image_data"] = _openshot.Frame_has_image_data_set
    __swig_getmethods__["has_image_data"] = _openshot.Frame_has_image_data_get
    if _newclass:
        has_image_data = _swig_property(_openshot.Frame_has_image_data_get, _openshot.Frame_has_image_data_set)

    def __init__(self, *args):
        """
        __init__(openshot::Frame self) -> Frame
        __init__(openshot::Frame self, int64_t number, int width, int height, std::string color) -> Frame
        __init__(openshot::Frame self, int64_t number, int samples, int channels) -> Frame
        __init__(openshot::Frame self, int64_t number, int width, int height, std::string color, int samples, int channels) -> Frame
        __init__(openshot::Frame self, Frame other) -> Frame
        """
        this = _openshot.new_Frame(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_Frame
    __del__ = lambda self: None

    def AddColor(self, new_width, new_height, color):
        """AddColor(Frame self, int new_width, int new_height, std::string color)"""
        return _openshot.Frame_AddColor(self, new_width, new_height, color)


    def AddImage(self, *args):
        """
        AddImage(Frame self, int new_width, int new_height, int bytes_per_pixel, QImage::Format type, unsigned char const * pixels_)
        AddImage(Frame self, std::shared_ptr< QImage > new_image)
        AddImage(Frame self, std::shared_ptr< QImage > new_image, bool only_odd_lines)
        """
        return _openshot.Frame_AddImage(self, *args)


    def AddAudio(self, replaceSamples, destChannel, destStartSample, source, numSamples, gainToApplyToSource):
        """AddAudio(Frame self, bool replaceSamples, int destChannel, int destStartSample, float const * source, int numSamples, float gainToApplyToSource)"""
        return _openshot.Frame_AddAudio(self, replaceSamples, destChannel, destStartSample, source, numSamples, gainToApplyToSource)


    def AddAudioSilence(self, numSamples):
        """AddAudioSilence(Frame self, int numSamples)"""
        return _openshot.Frame_AddAudioSilence(self, numSamples)


    def ApplyGainRamp(self, destChannel, destStartSample, numSamples, initial_gain, final_gain):
        """ApplyGainRamp(Frame self, int destChannel, int destStartSample, int numSamples, float initial_gain, float final_gain)"""
        return _openshot.Frame_ApplyGainRamp(self, destChannel, destStartSample, numSamples, initial_gain, final_gain)


    def ChannelsLayout(self, *args):
        """
        ChannelsLayout(Frame self) -> openshot::ChannelLayout
        ChannelsLayout(Frame self, openshot::ChannelLayout new_channel_layout)
        """
        return _openshot.Frame_ChannelsLayout(self, *args)


    def cleanUpBuffer(info):
        """cleanUpBuffer(void * info)"""
        return _openshot.Frame_cleanUpBuffer(info)

    cleanUpBuffer = staticmethod(cleanUpBuffer)

    def ClearWaveform(self):
        """ClearWaveform(Frame self)"""
        return _openshot.Frame_ClearWaveform(self)


    def DeepCopy(self, other):
        """DeepCopy(Frame self, Frame other)"""
        return _openshot.Frame_DeepCopy(self, other)


    def Display(self):
        """Display(Frame self)"""
        return _openshot.Frame_Display(self)


    def DisplayWaveform(self):
        """DisplayWaveform(Frame self)"""
        return _openshot.Frame_DisplayWaveform(self)


    def GetAudioSample(self, channel, sample, magnitude_range):
        """GetAudioSample(Frame self, int channel, int sample, int magnitude_range) -> float"""
        return _openshot.Frame_GetAudioSample(self, channel, sample, magnitude_range)


    def GetAudioSamples(self, channel):
        """GetAudioSamples(Frame self, int channel) -> float *"""
        return _openshot.Frame_GetAudioSamples(self, channel)


    def GetInterleavedAudioSamples(self, new_sample_rate, resampler, sample_count):
        """GetInterleavedAudioSamples(Frame self, int new_sample_rate, AudioResampler * resampler, int * sample_count) -> float *"""
        return _openshot.Frame_GetInterleavedAudioSamples(self, new_sample_rate, resampler, sample_count)


    def GetPlanarAudioSamples(self, new_sample_rate, resampler, sample_count):
        """GetPlanarAudioSamples(Frame self, int new_sample_rate, AudioResampler * resampler, int * sample_count) -> float *"""
        return _openshot.Frame_GetPlanarAudioSamples(self, new_sample_rate, resampler, sample_count)


    def GetAudioChannelsCount(self):
        """GetAudioChannelsCount(Frame self) -> int"""
        return _openshot.Frame_GetAudioChannelsCount(self)


    def GetAudioSamplesCount(self):
        """GetAudioSamplesCount(Frame self) -> int"""
        return _openshot.Frame_GetAudioSamplesCount(self)


    def GetAudioSampleBuffer(self):
        """GetAudioSampleBuffer(Frame self) -> juce::AudioSampleBuffer *"""
        return _openshot.Frame_GetAudioSampleBuffer(self)


    def GetBytes(self):
        """GetBytes(Frame self) -> int64_t"""
        return _openshot.Frame_GetBytes(self)


    def GetImage(self):
        """GetImage(Frame self) -> std::shared_ptr< QImage >"""
        return _openshot.Frame_GetImage(self)


    def GetPixelRatio(self):
        """GetPixelRatio(Frame self) -> Fraction"""
        return _openshot.Frame_GetPixelRatio(self)


    def GetPixels(self, *args):
        """
        GetPixels(Frame self) -> unsigned char const
        GetPixels(Frame self, int row) -> unsigned char const *
        """
        return _openshot.Frame_GetPixels(self, *args)


    def GetHeight(self):
        """GetHeight(Frame self) -> int"""
        return _openshot.Frame_GetHeight(self)


    def GetSamplesPerFrame(*args):
        """
        GetSamplesPerFrame(Fraction fps, int sample_rate, int channels) -> int
        GetSamplesPerFrame(int64_t frame_number, Fraction fps, int sample_rate, int channels) -> int
        """
        return _openshot.Frame_GetSamplesPerFrame(*args)

    GetSamplesPerFrame = staticmethod(GetSamplesPerFrame)

    def GetWaveform(self, width, height, Red, Green, Blue, Alpha):
        """GetWaveform(Frame self, int width, int height, int Red, int Green, int Blue, int Alpha) -> std::shared_ptr< QImage >"""
        return _openshot.Frame_GetWaveform(self, width, height, Red, Green, Blue, Alpha)


    def GetWaveformPixels(self, width, height, Red, Green, Blue, Alpha):
        """GetWaveformPixels(Frame self, int width, int height, int Red, int Green, int Blue, int Alpha) -> unsigned char const *"""
        return _openshot.Frame_GetWaveformPixels(self, width, height, Red, Green, Blue, Alpha)


    def GetWidth(self):
        """GetWidth(Frame self) -> int"""
        return _openshot.Frame_GetWidth(self)


    def ResizeAudio(self, channels, length, sample_rate, channel_layout):
        """ResizeAudio(Frame self, int channels, int length, int sample_rate, openshot::ChannelLayout channel_layout)"""
        return _openshot.Frame_ResizeAudio(self, channels, length, sample_rate, channel_layout)


    def SampleRate(self, *args):
        """
        SampleRate(Frame self) -> int
        SampleRate(Frame self, int orig_sample_rate)
        """
        return _openshot.Frame_SampleRate(self, *args)


    def Save(self, *args):
        """
        Save(Frame self, std::string path, float scale, std::string format, int quality=100)
        Save(Frame self, std::string path, float scale, std::string format)
        Save(Frame self, std::string path, float scale)
        """
        return _openshot.Frame_Save(self, *args)


    def SetFrameNumber(self, number):
        """SetFrameNumber(Frame self, int64_t number)"""
        return _openshot.Frame_SetFrameNumber(self, number)


    def SetPixelRatio(self, num, den):
        """SetPixelRatio(Frame self, int num, int den)"""
        return _openshot.Frame_SetPixelRatio(self, num, den)


    def Thumbnail(self, *args):
        """
        Thumbnail(Frame self, std::string path, int new_width, int new_height, std::string mask_path, std::string overlay_path, std::string background_color, bool ignore_aspect, std::string format, int quality=100)
        Thumbnail(Frame self, std::string path, int new_width, int new_height, std::string mask_path, std::string overlay_path, std::string background_color, bool ignore_aspect, std::string format)
        Thumbnail(Frame self, std::string path, int new_width, int new_height, std::string mask_path, std::string overlay_path, std::string background_color, bool ignore_aspect)
        """
        return _openshot.Frame_Thumbnail(self, *args)


    def Play(self):
        """Play(Frame self)"""
        return _openshot.Frame_Play(self)

Frame_swigregister = _openshot.Frame_swigregister
Frame_swigregister(Frame)

def Frame_cleanUpBuffer(info):
    """Frame_cleanUpBuffer(void * info)"""
    return _openshot.Frame_cleanUpBuffer(info)

def Frame_GetSamplesPerFrame(*args):
    """
    GetSamplesPerFrame(Fraction fps, int sample_rate, int channels) -> int
    Frame_GetSamplesPerFrame(int64_t frame_number, Fraction fps, int sample_rate, int channels) -> int
    """
    return _openshot.Frame_GetSamplesPerFrame(*args)

PULLDOWN_CLASSIC = _openshot.PULLDOWN_CLASSIC
PULLDOWN_ADVANCED = _openshot.PULLDOWN_ADVANCED
PULLDOWN_NONE = _openshot.PULLDOWN_NONE
class Field(_object):
    """Proxy of C++ openshot::Field class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Field, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Field, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Frame"] = _openshot.Field_Frame_set
    __swig_getmethods__["Frame"] = _openshot.Field_Frame_get
    if _newclass:
        Frame = _swig_property(_openshot.Field_Frame_get, _openshot.Field_Frame_set)
    __swig_setmethods__["isOdd"] = _openshot.Field_isOdd_set
    __swig_getmethods__["isOdd"] = _openshot.Field_isOdd_get
    if _newclass:
        isOdd = _swig_property(_openshot.Field_isOdd_get, _openshot.Field_isOdd_set)

    def __init__(self, *args):
        """
        __init__(openshot::Field self) -> Field
        __init__(openshot::Field self, int64_t frame, bool isodd) -> Field
        """
        this = _openshot.new_Field(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_Field
    __del__ = lambda self: None
Field_swigregister = _openshot.Field_swigregister
Field_swigregister(Field)

class SampleRange(_object):
    """Proxy of C++ openshot::SampleRange class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SampleRange, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SampleRange, name)
    __repr__ = _swig_repr
    __swig_setmethods__["frame_start"] = _openshot.SampleRange_frame_start_set
    __swig_getmethods__["frame_start"] = _openshot.SampleRange_frame_start_get
    if _newclass:
        frame_start = _swig_property(_openshot.SampleRange_frame_start_get, _openshot.SampleRange_frame_start_set)
    __swig_setmethods__["sample_start"] = _openshot.SampleRange_sample_start_set
    __swig_getmethods__["sample_start"] = _openshot.SampleRange_sample_start_get
    if _newclass:
        sample_start = _swig_property(_openshot.SampleRange_sample_start_get, _openshot.SampleRange_sample_start_set)
    __swig_setmethods__["frame_end"] = _openshot.SampleRange_frame_end_set
    __swig_getmethods__["frame_end"] = _openshot.SampleRange_frame_end_get
    if _newclass:
        frame_end = _swig_property(_openshot.SampleRange_frame_end_get, _openshot.SampleRange_frame_end_set)
    __swig_setmethods__["sample_end"] = _openshot.SampleRange_sample_end_set
    __swig_getmethods__["sample_end"] = _openshot.SampleRange_sample_end_get
    if _newclass:
        sample_end = _swig_property(_openshot.SampleRange_sample_end_get, _openshot.SampleRange_sample_end_set)
    __swig_setmethods__["total"] = _openshot.SampleRange_total_set
    __swig_getmethods__["total"] = _openshot.SampleRange_total_get
    if _newclass:
        total = _swig_property(_openshot.SampleRange_total_get, _openshot.SampleRange_total_set)

    def __init__(self):
        """__init__(openshot::SampleRange self) -> SampleRange"""
        this = _openshot.new_SampleRange()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_SampleRange
    __del__ = lambda self: None
SampleRange_swigregister = _openshot.SampleRange_swigregister
SampleRange_swigregister(SampleRange)

class MappedFrame(_object):
    """Proxy of C++ openshot::MappedFrame class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MappedFrame, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MappedFrame, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Odd"] = _openshot.MappedFrame_Odd_set
    __swig_getmethods__["Odd"] = _openshot.MappedFrame_Odd_get
    if _newclass:
        Odd = _swig_property(_openshot.MappedFrame_Odd_get, _openshot.MappedFrame_Odd_set)
    __swig_setmethods__["Even"] = _openshot.MappedFrame_Even_set
    __swig_getmethods__["Even"] = _openshot.MappedFrame_Even_get
    if _newclass:
        Even = _swig_property(_openshot.MappedFrame_Even_get, _openshot.MappedFrame_Even_set)
    __swig_setmethods__["Samples"] = _openshot.MappedFrame_Samples_set
    __swig_getmethods__["Samples"] = _openshot.MappedFrame_Samples_get
    if _newclass:
        Samples = _swig_property(_openshot.MappedFrame_Samples_get, _openshot.MappedFrame_Samples_set)

    def __init__(self):
        """__init__(openshot::MappedFrame self) -> MappedFrame"""
        this = _openshot.new_MappedFrame()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_MappedFrame
    __del__ = lambda self: None
MappedFrame_swigregister = _openshot.MappedFrame_swigregister
MappedFrame_swigregister(MappedFrame)

class FrameMapper(ReaderBase):
    """Proxy of C++ openshot::FrameMapper class."""

    __swig_setmethods__ = {}
    for _s in [ReaderBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FrameMapper, name, value)
    __swig_getmethods__ = {}
    for _s in [ReaderBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FrameMapper, name)
    __repr__ = _swig_repr
    __swig_setmethods__["fields"] = _openshot.FrameMapper_fields_set
    __swig_getmethods__["fields"] = _openshot.FrameMapper_fields_get
    if _newclass:
        fields = _swig_property(_openshot.FrameMapper_fields_get, _openshot.FrameMapper_fields_set)
    __swig_setmethods__["frames"] = _openshot.FrameMapper_frames_set
    __swig_getmethods__["frames"] = _openshot.FrameMapper_frames_get
    if _newclass:
        frames = _swig_property(_openshot.FrameMapper_frames_get, _openshot.FrameMapper_frames_set)

    def __init__(self, reader, target_fps, target_pulldown, target_sample_rate, target_channels, target_channel_layout):
        """__init__(openshot::FrameMapper self, ReaderBase reader, Fraction target_fps, openshot::PulldownType target_pulldown, int target_sample_rate, int target_channels, openshot::ChannelLayout target_channel_layout) -> FrameMapper"""
        this = _openshot.new_FrameMapper(reader, target_fps, target_pulldown, target_sample_rate, target_channels, target_channel_layout)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_FrameMapper
    __del__ = lambda self: None

    def ChangeMapping(self, target_fps, pulldown, target_sample_rate, target_channels, target_channel_layout):
        """ChangeMapping(FrameMapper self, Fraction target_fps, openshot::PulldownType pulldown, int target_sample_rate, int target_channels, openshot::ChannelLayout target_channel_layout)"""
        return _openshot.FrameMapper_ChangeMapping(self, target_fps, pulldown, target_sample_rate, target_channels, target_channel_layout)


    def SetTimelineFrameOffset(self, offset):
        """SetTimelineFrameOffset(FrameMapper self, int64_t offset)"""
        return _openshot.FrameMapper_SetTimelineFrameOffset(self, offset)


    def Close(self):
        """Close(FrameMapper self)"""
        return _openshot.FrameMapper_Close(self)


    def GetMappedFrame(self, TargetFrameNumber):
        """GetMappedFrame(FrameMapper self, int64_t TargetFrameNumber) -> MappedFrame"""
        return _openshot.FrameMapper_GetMappedFrame(self, TargetFrameNumber)


    def GetCache(self):
        """GetCache(FrameMapper self) -> CacheMemory"""
        return _openshot.FrameMapper_GetCache(self)


    def GetFrame(self, requested_frame):
        """GetFrame(FrameMapper self, int64_t requested_frame) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.FrameMapper_GetFrame(self, requested_frame)


    def IsOpen(self):
        """IsOpen(FrameMapper self) -> bool"""
        return _openshot.FrameMapper_IsOpen(self)


    def Name(self):
        """Name(FrameMapper self) -> std::string"""
        return _openshot.FrameMapper_Name(self)


    def Json(self):
        """Json(FrameMapper self) -> std::string"""
        return _openshot.FrameMapper_Json(self)


    def SetJson(self, value):
        """SetJson(FrameMapper self, std::string value)"""
        return _openshot.FrameMapper_SetJson(self, value)


    def JsonValue(self):
        """JsonValue(FrameMapper self) -> Json::Value"""
        return _openshot.FrameMapper_JsonValue(self)


    def SetJsonValue(self, root):
        """SetJsonValue(FrameMapper self, Json::Value root)"""
        return _openshot.FrameMapper_SetJsonValue(self, root)


    def Open(self):
        """Open(FrameMapper self)"""
        return _openshot.FrameMapper_Open(self)


    def PrintMapping(self):
        """PrintMapping(FrameMapper self)"""
        return _openshot.FrameMapper_PrintMapping(self)


    def Reader(self):
        """Reader(FrameMapper self) -> ReaderBase"""
        return _openshot.FrameMapper_Reader(self)


    def ResampleMappedAudio(self, frame, original_frame_number):
        """ResampleMappedAudio(FrameMapper self, std::shared_ptr< openshot::Frame > frame, int64_t original_frame_number)"""
        return _openshot.FrameMapper_ResampleMappedAudio(self, frame, original_frame_number)

FrameMapper_swigregister = _openshot.FrameMapper_swigregister
FrameMapper_swigregister(FrameMapper)

PLAYBACK_PLAY = _openshot.PLAYBACK_PLAY
PLAYBACK_PAUSED = _openshot.PLAYBACK_PAUSED
PLAYBACK_LOADING = _openshot.PLAYBACK_LOADING
PLAYBACK_STOPPED = _openshot.PLAYBACK_STOPPED
class PlayerBase(_object):
    """Proxy of C++ openshot::PlayerBase class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PlayerBase, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PlayerBase, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def Loading(self):
        """Loading(PlayerBase self)"""
        return _openshot.PlayerBase_Loading(self)


    def Mode(self):
        """Mode(PlayerBase self) -> openshot::PlaybackMode"""
        return _openshot.PlayerBase_Mode(self)


    def Play(self):
        """Play(PlayerBase self)"""
        return _openshot.PlayerBase_Play(self)


    def Pause(self):
        """Pause(PlayerBase self)"""
        return _openshot.PlayerBase_Pause(self)


    def Position(self):
        """Position(PlayerBase self) -> int"""
        return _openshot.PlayerBase_Position(self)


    def Seek(self, new_frame):
        """Seek(PlayerBase self, int64_t new_frame)"""
        return _openshot.PlayerBase_Seek(self, new_frame)


    def Speed(self, *args):
        """
        Speed(PlayerBase self) -> float
        Speed(PlayerBase self, float new_speed)
        """
        return _openshot.PlayerBase_Speed(self, *args)


    def Stop(self):
        """Stop(PlayerBase self)"""
        return _openshot.PlayerBase_Stop(self)


    def Reader(self, *args):
        """
        Reader(PlayerBase self) -> ReaderBase
        Reader(PlayerBase self, ReaderBase new_reader)
        """
        return _openshot.PlayerBase_Reader(self, *args)


    def Volume(self, *args):
        """
        Volume(PlayerBase self) -> float
        Volume(PlayerBase self, float new_volume)
        """
        return _openshot.PlayerBase_Volume(self, *args)

    __swig_destroy__ = _openshot.delete_PlayerBase
    __del__ = lambda self: None
PlayerBase_swigregister = _openshot.PlayerBase_swigregister
PlayerBase_swigregister(PlayerBase)

BEZIER = _openshot.BEZIER
LINEAR = _openshot.LINEAR
CONSTANT = _openshot.CONSTANT
AUTO = _openshot.AUTO
MANUAL = _openshot.MANUAL
class Point(_object):
    """Proxy of C++ openshot::Point class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Point, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Point, name)
    __repr__ = _swig_repr
    __swig_setmethods__["co"] = _openshot.Point_co_set
    __swig_getmethods__["co"] = _openshot.Point_co_get
    if _newclass:
        co = _swig_property(_openshot.Point_co_get, _openshot.Point_co_set)
    __swig_setmethods__["handle_left"] = _openshot.Point_handle_left_set
    __swig_getmethods__["handle_left"] = _openshot.Point_handle_left_get
    if _newclass:
        handle_left = _swig_property(_openshot.Point_handle_left_get, _openshot.Point_handle_left_set)
    __swig_setmethods__["handle_right"] = _openshot.Point_handle_right_set
    __swig_getmethods__["handle_right"] = _openshot.Point_handle_right_get
    if _newclass:
        handle_right = _swig_property(_openshot.Point_handle_right_get, _openshot.Point_handle_right_set)
    __swig_setmethods__["interpolation"] = _openshot.Point_interpolation_set
    __swig_getmethods__["interpolation"] = _openshot.Point_interpolation_get
    if _newclass:
        interpolation = _swig_property(_openshot.Point_interpolation_get, _openshot.Point_interpolation_set)
    __swig_setmethods__["handle_type"] = _openshot.Point_handle_type_set
    __swig_getmethods__["handle_type"] = _openshot.Point_handle_type_get
    if _newclass:
        handle_type = _swig_property(_openshot.Point_handle_type_get, _openshot.Point_handle_type_set)

    def __init__(self, *args):
        """
        __init__(openshot::Point self) -> Point
        __init__(openshot::Point self, float y) -> Point
        __init__(openshot::Point self, float x, float y) -> Point
        __init__(openshot::Point self, float x, float y, openshot::InterpolationType interpolation) -> Point
        __init__(openshot::Point self, Coordinate co) -> Point
        __init__(openshot::Point self, Coordinate co, openshot::InterpolationType interpolation) -> Point
        __init__(openshot::Point self, Coordinate co, openshot::InterpolationType interpolation, openshot::HandleType handle_type) -> Point
        """
        this = _openshot.new_Point(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def Initialize_Handles(self):
        """Initialize_Handles(Point self)"""
        return _openshot.Point_Initialize_Handles(self)


    def Initialize_LeftHandle(self, x, y):
        """Initialize_LeftHandle(Point self, float x, float y)"""
        return _openshot.Point_Initialize_LeftHandle(self, x, y)


    def Initialize_RightHandle(self, x, y):
        """Initialize_RightHandle(Point self, float x, float y)"""
        return _openshot.Point_Initialize_RightHandle(self, x, y)


    def Json(self):
        """Json(Point self) -> std::string"""
        return _openshot.Point_Json(self)


    def JsonValue(self):
        """JsonValue(Point self) -> Json::Value"""
        return _openshot.Point_JsonValue(self)


    def SetJson(self, value):
        """SetJson(Point self, std::string value)"""
        return _openshot.Point_SetJson(self, value)


    def SetJsonValue(self, root):
        """SetJsonValue(Point self, Json::Value root)"""
        return _openshot.Point_SetJsonValue(self, root)

    __swig_destroy__ = _openshot.delete_Point
    __del__ = lambda self: None
Point_swigregister = _openshot.Point_swigregister
Point_swigregister(Point)

class ProfileInfo(_object):
    """Proxy of C++ openshot::ProfileInfo class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProfileInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ProfileInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["description"] = _openshot.ProfileInfo_description_set
    __swig_getmethods__["description"] = _openshot.ProfileInfo_description_get
    if _newclass:
        description = _swig_property(_openshot.ProfileInfo_description_get, _openshot.ProfileInfo_description_set)
    __swig_setmethods__["height"] = _openshot.ProfileInfo_height_set
    __swig_getmethods__["height"] = _openshot.ProfileInfo_height_get
    if _newclass:
        height = _swig_property(_openshot.ProfileInfo_height_get, _openshot.ProfileInfo_height_set)
    __swig_setmethods__["width"] = _openshot.ProfileInfo_width_set
    __swig_getmethods__["width"] = _openshot.ProfileInfo_width_get
    if _newclass:
        width = _swig_property(_openshot.ProfileInfo_width_get, _openshot.ProfileInfo_width_set)
    __swig_setmethods__["pixel_format"] = _openshot.ProfileInfo_pixel_format_set
    __swig_getmethods__["pixel_format"] = _openshot.ProfileInfo_pixel_format_get
    if _newclass:
        pixel_format = _swig_property(_openshot.ProfileInfo_pixel_format_get, _openshot.ProfileInfo_pixel_format_set)
    __swig_setmethods__["fps"] = _openshot.ProfileInfo_fps_set
    __swig_getmethods__["fps"] = _openshot.ProfileInfo_fps_get
    if _newclass:
        fps = _swig_property(_openshot.ProfileInfo_fps_get, _openshot.ProfileInfo_fps_set)
    __swig_setmethods__["pixel_ratio"] = _openshot.ProfileInfo_pixel_ratio_set
    __swig_getmethods__["pixel_ratio"] = _openshot.ProfileInfo_pixel_ratio_get
    if _newclass:
        pixel_ratio = _swig_property(_openshot.ProfileInfo_pixel_ratio_get, _openshot.ProfileInfo_pixel_ratio_set)
    __swig_setmethods__["display_ratio"] = _openshot.ProfileInfo_display_ratio_set
    __swig_getmethods__["display_ratio"] = _openshot.ProfileInfo_display_ratio_get
    if _newclass:
        display_ratio = _swig_property(_openshot.ProfileInfo_display_ratio_get, _openshot.ProfileInfo_display_ratio_set)
    __swig_setmethods__["interlaced_frame"] = _openshot.ProfileInfo_interlaced_frame_set
    __swig_getmethods__["interlaced_frame"] = _openshot.ProfileInfo_interlaced_frame_get
    if _newclass:
        interlaced_frame = _swig_property(_openshot.ProfileInfo_interlaced_frame_get, _openshot.ProfileInfo_interlaced_frame_set)

    def __init__(self):
        """__init__(openshot::ProfileInfo self) -> ProfileInfo"""
        this = _openshot.new_ProfileInfo()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_ProfileInfo
    __del__ = lambda self: None
ProfileInfo_swigregister = _openshot.ProfileInfo_swigregister
ProfileInfo_swigregister(ProfileInfo)

class Profile(_object):
    """Proxy of C++ openshot::Profile class."""

    __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
    __swig_setmethods__["info"] = _openshot.Profile_info_set
    __swig_getmethods__["info"] = _openshot.Profile_info_get
    if _newclass:
        info = _swig_property(_openshot.Profile_info_get, _openshot.Profile_info_set)

    def __init__(self, path):
        """__init__(openshot::Profile self, std::string path) -> Profile"""
        this = _openshot.new_Profile(path)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def Json(self):
        """Json(Profile self) -> std::string"""
        return _openshot.Profile_Json(self)


    def JsonValue(self):
        """JsonValue(Profile self) -> Json::Value"""
        return _openshot.Profile_JsonValue(self)


    def SetJson(self, value):
        """SetJson(Profile self, std::string value)"""
        return _openshot.Profile_SetJson(self, value)


    def SetJsonValue(self, root):
        """SetJsonValue(Profile self, Json::Value root)"""
        return _openshot.Profile_SetJsonValue(self, root)

    __swig_destroy__ = _openshot.delete_Profile
    __del__ = lambda self: None
Profile_swigregister = _openshot.Profile_swigregister
Profile_swigregister(Profile)

class QtImageReader(ReaderBase):
    """Proxy of C++ openshot::QtImageReader class."""

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

    def __init__(self, *args):
        """
        __init__(openshot::QtImageReader self, std::string path) -> QtImageReader
        __init__(openshot::QtImageReader self, std::string path, bool inspect_reader) -> QtImageReader
        """
        this = _openshot.new_QtImageReader(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def Close(self):
        """Close(QtImageReader self)"""
        return _openshot.QtImageReader_Close(self)


    def GetCache(self):
        """GetCache(QtImageReader self) -> CacheMemory"""
        return _openshot.QtImageReader_GetCache(self)


    def GetFrame(self, requested_frame):
        """GetFrame(QtImageReader self, int64_t requested_frame) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.QtImageReader_GetFrame(self, requested_frame)


    def IsOpen(self):
        """IsOpen(QtImageReader self) -> bool"""
        return _openshot.QtImageReader_IsOpen(self)


    def Name(self):
        """Name(QtImageReader self) -> std::string"""
        return _openshot.QtImageReader_Name(self)


    def Json(self):
        """Json(QtImageReader self) -> std::string"""
        return _openshot.QtImageReader_Json(self)


    def SetJson(self, value):
        """SetJson(QtImageReader self, std::string value)"""
        return _openshot.QtImageReader_SetJson(self, value)


    def JsonValue(self):
        """JsonValue(QtImageReader self) -> Json::Value"""
        return _openshot.QtImageReader_JsonValue(self)


    def SetJsonValue(self, root):
        """SetJsonValue(QtImageReader self, Json::Value root)"""
        return _openshot.QtImageReader_SetJsonValue(self, root)


    def SetMaxSize(self, width, height):
        """SetMaxSize(QtImageReader self, int width, int height)"""
        return _openshot.QtImageReader_SetMaxSize(self, width, height)


    def Open(self):
        """Open(QtImageReader self)"""
        return _openshot.QtImageReader_Open(self)

    __swig_destroy__ = _openshot.delete_QtImageReader
    __del__ = lambda self: None
QtImageReader_swigregister = _openshot.QtImageReader_swigregister
QtImageReader_swigregister(QtImageReader)

class QtPlayer(PlayerBase):
    """Proxy of C++ openshot::QtPlayer class."""

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

    def __init__(self, *args):
        """
        __init__(openshot::QtPlayer self) -> QtPlayer
        __init__(openshot::QtPlayer self, RendererBase rb) -> QtPlayer
        """
        this = _openshot.new_QtPlayer(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_QtPlayer
    __del__ = lambda self: None

    def CloseAudioDevice(self):
        """CloseAudioDevice(QtPlayer self)"""
        return _openshot.QtPlayer_CloseAudioDevice(self)


    def Play(self):
        """Play(QtPlayer self)"""
        return _openshot.QtPlayer_Play(self)


    def Loading(self):
        """Loading(QtPlayer self)"""
        return _openshot.QtPlayer_Loading(self)


    def Mode(self):
        """Mode(QtPlayer self) -> openshot::PlaybackMode"""
        return _openshot.QtPlayer_Mode(self)


    def Pause(self):
        """Pause(QtPlayer self)"""
        return _openshot.QtPlayer_Pause(self)


    def Position(self):
        """Position(QtPlayer self) -> int"""
        return _openshot.QtPlayer_Position(self)


    def Seek(self, new_frame):
        """Seek(QtPlayer self, int64_t new_frame)"""
        return _openshot.QtPlayer_Seek(self, new_frame)


    def SetSource(self, source):
        """SetSource(QtPlayer self, std::string const & source)"""
        return _openshot.QtPlayer_SetSource(self, source)


    def SetQWidget(self, qwidget_address):
        """SetQWidget(QtPlayer self, int64_t qwidget_address)"""
        return _openshot.QtPlayer_SetQWidget(self, qwidget_address)


    def GetRendererQObject(self):
        """GetRendererQObject(QtPlayer self) -> int64_t"""
        return _openshot.QtPlayer_GetRendererQObject(self)


    def Speed(self, *args):
        """
        Speed(QtPlayer self) -> float
        Speed(QtPlayer self, float new_speed)
        """
        return _openshot.QtPlayer_Speed(self, *args)


    def Stop(self):
        """Stop(QtPlayer self)"""
        return _openshot.QtPlayer_Stop(self)


    def Reader(self, *args):
        """
        Reader(QtPlayer self, ReaderBase new_reader)
        Reader(QtPlayer self) -> ReaderBase
        """
        return _openshot.QtPlayer_Reader(self, *args)


    def Volume(self, *args):
        """
        Volume(QtPlayer self) -> float
        Volume(QtPlayer self, float new_volume)
        """
        return _openshot.QtPlayer_Volume(self, *args)

QtPlayer_swigregister = _openshot.QtPlayer_swigregister
QtPlayer_swigregister(QtPlayer)

class Keyframe(_object):
    """Proxy of C++ openshot::Keyframe class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Keyframe, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Keyframe, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Points"] = _openshot.Keyframe_Points_set
    __swig_getmethods__["Points"] = _openshot.Keyframe_Points_get
    if _newclass:
        Points = _swig_property(_openshot.Keyframe_Points_get, _openshot.Keyframe_Points_set)
    __swig_setmethods__["Values"] = _openshot.Keyframe_Values_set
    __swig_getmethods__["Values"] = _openshot.Keyframe_Values_get
    if _newclass:
        Values = _swig_property(_openshot.Keyframe_Values_get, _openshot.Keyframe_Values_set)

    def __init__(self, *args):
        """
        __init__(openshot::Keyframe self) -> Keyframe
        __init__(openshot::Keyframe self, double value) -> Keyframe
        """
        this = _openshot.new_Keyframe(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def AddPoint(self, *args):
        """
        AddPoint(Keyframe self, Point p)
        AddPoint(Keyframe self, double x, double y)
        AddPoint(Keyframe self, double x, double y, openshot::InterpolationType interpolate)
        """
        return _openshot.Keyframe_AddPoint(self, *args)


    def Contains(self, p):
        """Contains(Keyframe self, Point p) -> bool"""
        return _openshot.Keyframe_Contains(self, p)


    def FlipPoints(self):
        """FlipPoints(Keyframe self)"""
        return _openshot.Keyframe_FlipPoints(self)


    def FindIndex(self, p):
        """FindIndex(Keyframe self, Point p) -> int64_t"""
        return _openshot.Keyframe_FindIndex(self, p)


    def GetValue(self, index):
        """GetValue(Keyframe self, int64_t index) -> double"""
        return _openshot.Keyframe_GetValue(self, index)


    def GetInt(self, index):
        """GetInt(Keyframe self, int64_t index) -> int"""
        return _openshot.Keyframe_GetInt(self, index)


    def GetLong(self, index):
        """GetLong(Keyframe self, int64_t index) -> int64_t"""
        return _openshot.Keyframe_GetLong(self, index)


    def GetRepeatFraction(self, index):
        """GetRepeatFraction(Keyframe self, int64_t index) -> Fraction"""
        return _openshot.Keyframe_GetRepeatFraction(self, index)


    def GetDelta(self, index):
        """GetDelta(Keyframe self, int64_t index) -> double"""
        return _openshot.Keyframe_GetDelta(self, index)


    def GetPoint(self, index):
        """GetPoint(Keyframe self, int64_t index) -> Point"""
        return _openshot.Keyframe_GetPoint(self, index)


    def GetClosestPoint(self, *args):
        """
        GetClosestPoint(Keyframe self, Point p) -> Point
        GetClosestPoint(Keyframe self, Point p, bool useLeft) -> Point
        """
        return _openshot.Keyframe_GetClosestPoint(self, *args)


    def GetPreviousPoint(self, p):
        """GetPreviousPoint(Keyframe self, Point p) -> Point"""
        return _openshot.Keyframe_GetPreviousPoint(self, p)


    def GetMaxPoint(self):
        """GetMaxPoint(Keyframe self) -> Point"""
        return _openshot.Keyframe_GetMaxPoint(self)


    def GetLength(self):
        """GetLength(Keyframe self) -> int64_t"""
        return _openshot.Keyframe_GetLength(self)


    def GetCount(self):
        """GetCount(Keyframe self) -> int64_t"""
        return _openshot.Keyframe_GetCount(self)


    def IsIncreasing(self, index):
        """IsIncreasing(Keyframe self, int index) -> bool"""
        return _openshot.Keyframe_IsIncreasing(self, index)


    def Json(self):
        """Json(Keyframe self) -> std::string"""
        return _openshot.Keyframe_Json(self)


    def JsonValue(self):
        """JsonValue(Keyframe self) -> Json::Value"""
        return _openshot.Keyframe_JsonValue(self)


    def SetJson(self, value):
        """SetJson(Keyframe self, std::string value)"""
        return _openshot.Keyframe_SetJson(self, value)


    def SetJsonValue(self, root):
        """SetJsonValue(Keyframe self, Json::Value root)"""
        return _openshot.Keyframe_SetJsonValue(self, root)


    def Process(self):
        """Process(Keyframe self)"""
        return _openshot.Keyframe_Process(self)


    def RemovePoint(self, *args):
        """
        RemovePoint(Keyframe self, Point p)
        RemovePoint(Keyframe self, int64_t index)
        """
        return _openshot.Keyframe_RemovePoint(self, *args)


    def ScalePoints(self, scale):
        """ScalePoints(Keyframe self, double scale)"""
        return _openshot.Keyframe_ScalePoints(self, scale)


    def UpdatePoint(self, index, p):
        """UpdatePoint(Keyframe self, int64_t index, Point p)"""
        return _openshot.Keyframe_UpdatePoint(self, index, p)


    def PrintPoints(self):
        """PrintPoints(Keyframe self)"""
        return _openshot.Keyframe_PrintPoints(self)


    def PrintValues(self):
        """PrintValues(Keyframe self)"""
        return _openshot.Keyframe_PrintValues(self)

    __swig_destroy__ = _openshot.delete_Keyframe
    __del__ = lambda self: None
Keyframe_swigregister = _openshot.Keyframe_swigregister
Keyframe_swigregister(Keyframe)

class RendererBase(_object):
    """Proxy of C++ openshot::RendererBase class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RendererBase, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RendererBase, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def paint(self, frame):
        """paint(RendererBase self, std::shared_ptr< openshot::Frame > const & frame)"""
        return _openshot.RendererBase_paint(self, frame)


    def OverrideWidget(self, qwidget_address):
        """OverrideWidget(RendererBase self, int64_t qwidget_address)"""
        return _openshot.RendererBase_OverrideWidget(self, qwidget_address)

RendererBase_swigregister = _openshot.RendererBase_swigregister
RendererBase_swigregister(RendererBase)

class CompareClips(_object):
    """Proxy of C++ openshot::CompareClips class."""

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

    def __call__(self, lhs, rhs):
        """__call__(CompareClips self, Clip lhs, Clip rhs) -> bool"""
        return _openshot.CompareClips___call__(self, lhs, rhs)


    def __init__(self):
        """__init__(openshot::CompareClips self) -> CompareClips"""
        this = _openshot.new_CompareClips()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_CompareClips
    __del__ = lambda self: None
CompareClips_swigregister = _openshot.CompareClips_swigregister
CompareClips_swigregister(CompareClips)

class CompareEffects(_object):
    """Proxy of C++ openshot::CompareEffects class."""

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

    def __call__(self, lhs, rhs):
        """__call__(CompareEffects self, EffectBase lhs, EffectBase rhs) -> bool"""
        return _openshot.CompareEffects___call__(self, lhs, rhs)


    def __init__(self):
        """__init__(openshot::CompareEffects self) -> CompareEffects"""
        this = _openshot.new_CompareEffects()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _openshot.delete_CompareEffects
    __del__ = lambda self: None
CompareEffects_swigregister = _openshot.CompareEffects_swigregister
CompareEffects_swigregister(CompareEffects)

class Timeline(ReaderBase):
    """Proxy of C++ openshot::Timeline class."""

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

    def __init__(self, width, height, fps, sample_rate, channels, channel_layout):
        """__init__(openshot::Timeline self, int width, int height, Fraction fps, int sample_rate, int channels, openshot::ChannelLayout channel_layout) -> Timeline"""
        this = _openshot.new_Timeline(width, height, fps, sample_rate, channels, channel_layout)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def AddClip(self, clip):
        """AddClip(Timeline self, Clip clip)"""
        return _openshot.Timeline_AddClip(self, clip)


    def AddEffect(self, effect):
        """AddEffect(Timeline self, EffectBase effect)"""
        return _openshot.Timeline_AddEffect(self, effect)


    def ApplyMapperToClips(self):
        """ApplyMapperToClips(Timeline self)"""
        return _openshot.Timeline_ApplyMapperToClips(self)


    def AutoMapClips(self, *args):
        """
        AutoMapClips(Timeline self) -> bool
        AutoMapClips(Timeline self, bool auto_map)
        """
        return _openshot.Timeline_AutoMapClips(self, *args)


    def ClearAllCache(self):
        """ClearAllCache(Timeline self)"""
        return _openshot.Timeline_ClearAllCache(self)


    def Clips(self):
        """Clips(Timeline self) -> ClipList"""
        return _openshot.Timeline_Clips(self)


    def Close(self):
        """Close(Timeline self)"""
        return _openshot.Timeline_Close(self)


    def Effects(self):
        """Effects(Timeline self) -> EffectBaseList"""
        return _openshot.Timeline_Effects(self)


    def GetCache(self):
        """GetCache(Timeline self) -> CacheBase"""
        return _openshot.Timeline_GetCache(self)


    def SetCache(self, new_cache):
        """SetCache(Timeline self, CacheBase new_cache)"""
        return _openshot.Timeline_SetCache(self, new_cache)


    def GetFrame(self, requested_frame):
        """GetFrame(Timeline self, int64_t requested_frame) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.Timeline_GetFrame(self, requested_frame)

    __swig_setmethods__["viewport_scale"] = _openshot.Timeline_viewport_scale_set
    __swig_getmethods__["viewport_scale"] = _openshot.Timeline_viewport_scale_get
    if _newclass:
        viewport_scale = _swig_property(_openshot.Timeline_viewport_scale_get, _openshot.Timeline_viewport_scale_set)
    __swig_setmethods__["viewport_x"] = _openshot.Timeline_viewport_x_set
    __swig_getmethods__["viewport_x"] = _openshot.Timeline_viewport_x_get
    if _newclass:
        viewport_x = _swig_property(_openshot.Timeline_viewport_x_get, _openshot.Timeline_viewport_x_set)
    __swig_setmethods__["viewport_y"] = _openshot.Timeline_viewport_y_set
    __swig_getmethods__["viewport_y"] = _openshot.Timeline_viewport_y_get
    if _newclass:
        viewport_y = _swig_property(_openshot.Timeline_viewport_y_get, _openshot.Timeline_viewport_y_set)
    __swig_setmethods__["color"] = _openshot.Timeline_color_set
    __swig_getmethods__["color"] = _openshot.Timeline_color_get
    if _newclass:
        color = _swig_property(_openshot.Timeline_color_get, _openshot.Timeline_color_set)

    def IsOpen(self):
        """IsOpen(Timeline self) -> bool"""
        return _openshot.Timeline_IsOpen(self)


    def Name(self):
        """Name(Timeline self) -> std::string"""
        return _openshot.Timeline_Name(self)


    def Json(self):
        """Json(Timeline self) -> std::string"""
        return _openshot.Timeline_Json(self)


    def SetJson(self, value):
        """SetJson(Timeline self, std::string value)"""
        return _openshot.Timeline_SetJson(self, value)


    def JsonValue(self):
        """JsonValue(Timeline self) -> Json::Value"""
        return _openshot.Timeline_JsonValue(self)


    def SetJsonValue(self, root):
        """SetJsonValue(Timeline self, Json::Value root)"""
        return _openshot.Timeline_SetJsonValue(self, root)


    def ApplyJsonDiff(self, value):
        """ApplyJsonDiff(Timeline self, std::string value)"""
        return _openshot.Timeline_ApplyJsonDiff(self, value)


    def Open(self):
        """Open(Timeline self)"""
        return _openshot.Timeline_Open(self)


    def RemoveClip(self, clip):
        """RemoveClip(Timeline self, Clip clip)"""
        return _openshot.Timeline_RemoveClip(self, clip)


    def RemoveEffect(self, effect):
        """RemoveEffect(Timeline self, EffectBase effect)"""
        return _openshot.Timeline_RemoveEffect(self, effect)

    __swig_destroy__ = _openshot.delete_Timeline
    __del__ = lambda self: None
Timeline_swigregister = _openshot.Timeline_swigregister
Timeline_swigregister(Timeline)

class ZmqLogger(_object):
    """Proxy of C++ openshot::ZmqLogger class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ZmqLogger, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ZmqLogger, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def Instance():
        """Instance() -> ZmqLogger"""
        return _openshot.ZmqLogger_Instance()

    Instance = staticmethod(Instance)

    def AppendDebugMethod(self, method_name, arg1_name, arg1_value, arg2_name, arg2_value, arg3_name, arg3_value, arg4_name, arg4_value, arg5_name, arg5_value, arg6_name, arg6_value):
        """AppendDebugMethod(ZmqLogger self, std::string method_name, std::string arg1_name, float arg1_value, std::string arg2_name, float arg2_value, std::string arg3_name, float arg3_value, std::string arg4_name, float arg4_value, std::string arg5_name, float arg5_value, std::string arg6_name, float arg6_value)"""
        return _openshot.ZmqLogger_AppendDebugMethod(self, method_name, arg1_name, arg1_value, arg2_name, arg2_value, arg3_name, arg3_value, arg4_name, arg4_value, arg5_name, arg5_value, arg6_name, arg6_value)


    def Close(self):
        """Close(ZmqLogger self)"""
        return _openshot.ZmqLogger_Close(self)


    def Connection(self, new_connection):
        """Connection(ZmqLogger self, std::string new_connection)"""
        return _openshot.ZmqLogger_Connection(self, new_connection)


    def Enable(self, is_enabled):
        """Enable(ZmqLogger self, bool is_enabled)"""
        return _openshot.ZmqLogger_Enable(self, is_enabled)


    def Path(self, new_path):
        """Path(ZmqLogger self, std::string new_path)"""
        return _openshot.ZmqLogger_Path(self, new_path)


    def Log(self, message):
        """Log(ZmqLogger self, std::string message)"""
        return _openshot.ZmqLogger_Log(self, message)


    def LogToFile(self, message):
        """LogToFile(ZmqLogger self, std::string message)"""
        return _openshot.ZmqLogger_LogToFile(self, message)

    __swig_destroy__ = _openshot.delete_ZmqLogger
    __del__ = lambda self: None
ZmqLogger_swigregister = _openshot.ZmqLogger_swigregister
ZmqLogger_swigregister(ZmqLogger)

def ZmqLogger_Instance():
    """ZmqLogger_Instance() -> ZmqLogger"""
    return _openshot.ZmqLogger_Instance()

class Blur(EffectBase):
    """Proxy of C++ openshot::Blur class."""

    __swig_setmethods__ = {}
    for _s in [EffectBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Blur, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Blur, name)
    __repr__ = _swig_repr
    __swig_setmethods__["horizontal_radius"] = _openshot.Blur_horizontal_radius_set
    __swig_getmethods__["horizontal_radius"] = _openshot.Blur_horizontal_radius_get
    if _newclass:
        horizontal_radius = _swig_property(_openshot.Blur_horizontal_radius_get, _openshot.Blur_horizontal_radius_set)
    __swig_setmethods__["vertical_radius"] = _openshot.Blur_vertical_radius_set
    __swig_getmethods__["vertical_radius"] = _openshot.Blur_vertical_radius_get
    if _newclass:
        vertical_radius = _swig_property(_openshot.Blur_vertical_radius_get, _openshot.Blur_vertical_radius_set)
    __swig_setmethods__["sigma"] = _openshot.Blur_sigma_set
    __swig_getmethods__["sigma"] = _openshot.Blur_sigma_get
    if _newclass:
        sigma = _swig_property(_openshot.Blur_sigma_get, _openshot.Blur_sigma_set)
    __swig_setmethods__["iterations"] = _openshot.Blur_iterations_set
    __swig_getmethods__["iterations"] = _openshot.Blur_iterations_get
    if _newclass:
        iterations = _swig_property(_openshot.Blur_iterations_get, _openshot.Blur_iterations_set)

    def __init__(self, *args):
        """
        __init__(openshot::Blur self) -> Blur
        __init__(openshot::Blur self, Keyframe new_horizontal_radius, Keyframe new_vertical_radius, Keyframe new_sigma, Keyframe new_iterations) -> Blur
        """
        this = _openshot.new_Blur(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def GetFrame(self, frame, frame_number):
        """GetFrame(Blur self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.Blur_GetFrame(self, frame, frame_number)


    def Json(self):
        """Json(Blur self) -> std::string"""
        return _openshot.Blur_Json(self)


    def SetJson(self, value):
        """SetJson(Blur self, std::string value)"""
        return _openshot.Blur_SetJson(self, value)


    def JsonValue(self):
        """JsonValue(Blur self) -> Json::Value"""
        return _openshot.Blur_JsonValue(self)


    def SetJsonValue(self, root):
        """SetJsonValue(Blur self, Json::Value root)"""
        return _openshot.Blur_SetJsonValue(self, root)


    def PropertiesJSON(self, requested_frame):
        """PropertiesJSON(Blur self, int64_t requested_frame) -> std::string"""
        return _openshot.Blur_PropertiesJSON(self, requested_frame)

    __swig_destroy__ = _openshot.delete_Blur
    __del__ = lambda self: None
Blur_swigregister = _openshot.Blur_swigregister
Blur_swigregister(Blur)

class Brightness(EffectBase):
    """Proxy of C++ openshot::Brightness class."""

    __swig_setmethods__ = {}
    for _s in [EffectBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Brightness, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Brightness, name)
    __repr__ = _swig_repr
    __swig_setmethods__["brightness"] = _openshot.Brightness_brightness_set
    __swig_getmethods__["brightness"] = _openshot.Brightness_brightness_get
    if _newclass:
        brightness = _swig_property(_openshot.Brightness_brightness_get, _openshot.Brightness_brightness_set)
    __swig_setmethods__["contrast"] = _openshot.Brightness_contrast_set
    __swig_getmethods__["contrast"] = _openshot.Brightness_contrast_get
    if _newclass:
        contrast = _swig_property(_openshot.Brightness_contrast_get, _openshot.Brightness_contrast_set)

    def __init__(self, *args):
        """
        __init__(openshot::Brightness self) -> Brightness
        __init__(openshot::Brightness self, Keyframe new_brightness, Keyframe new_contrast) -> Brightness
        """
        this = _openshot.new_Brightness(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def GetFrame(self, frame, frame_number):
        """GetFrame(Brightness self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.Brightness_GetFrame(self, frame, frame_number)


    def Json(self):
        """Json(Brightness self) -> std::string"""
        return _openshot.Brightness_Json(self)


    def SetJson(self, value):
        """SetJson(Brightness self, std::string value)"""
        return _openshot.Brightness_SetJson(self, value)


    def JsonValue(self):
        """JsonValue(Brightness self) -> Json::Value"""
        return _openshot.Brightness_JsonValue(self)


    def SetJsonValue(self, root):
        """SetJsonValue(Brightness self, Json::Value root)"""
        return _openshot.Brightness_SetJsonValue(self, root)


    def PropertiesJSON(self, requested_frame):
        """PropertiesJSON(Brightness self, int64_t requested_frame) -> std::string"""
        return _openshot.Brightness_PropertiesJSON(self, requested_frame)

    __swig_destroy__ = _openshot.delete_Brightness
    __del__ = lambda self: None
Brightness_swigregister = _openshot.Brightness_swigregister
Brightness_swigregister(Brightness)

class ChromaKey(EffectBase):
    """Proxy of C++ openshot::ChromaKey class."""

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

    def __init__(self, *args):
        """
        __init__(openshot::ChromaKey self) -> ChromaKey
        __init__(openshot::ChromaKey self, Color color, Keyframe fuzz) -> ChromaKey
        """
        this = _openshot.new_ChromaKey(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def GetFrame(self, frame, frame_number):
        """GetFrame(ChromaKey self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.ChromaKey_GetFrame(self, frame, frame_number)


    def Json(self):
        """Json(ChromaKey self) -> std::string"""
        return _openshot.ChromaKey_Json(self)


    def SetJson(self, value):
        """SetJson(ChromaKey self, std::string value)"""
        return _openshot.ChromaKey_SetJson(self, value)


    def JsonValue(self):
        """JsonValue(ChromaKey self) -> Json::Value"""
        return _openshot.ChromaKey_JsonValue(self)


    def SetJsonValue(self, root):
        """SetJsonValue(ChromaKey self, Json::Value root)"""
        return _openshot.ChromaKey_SetJsonValue(self, root)


    def PropertiesJSON(self, requested_frame):
        """PropertiesJSON(ChromaKey self, int64_t requested_frame) -> std::string"""
        return _openshot.ChromaKey_PropertiesJSON(self, requested_frame)

    __swig_destroy__ = _openshot.delete_ChromaKey
    __del__ = lambda self: None
ChromaKey_swigregister = _openshot.ChromaKey_swigregister
ChromaKey_swigregister(ChromaKey)

class Deinterlace(EffectBase):
    """Proxy of C++ openshot::Deinterlace class."""

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

    def __init__(self, *args):
        """
        __init__(openshot::Deinterlace self) -> Deinterlace
        __init__(openshot::Deinterlace self, bool isOdd) -> Deinterlace
        """
        this = _openshot.new_Deinterlace(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def GetFrame(self, frame, frame_number):
        """GetFrame(Deinterlace self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.Deinterlace_GetFrame(self, frame, frame_number)


    def Json(self):
        """Json(Deinterlace self) -> std::string"""
        return _openshot.Deinterlace_Json(self)


    def SetJson(self, value):
        """SetJson(Deinterlace self, std::string value)"""
        return _openshot.Deinterlace_SetJson(self, value)


    def JsonValue(self):
        """JsonValue(Deinterlace self) -> Json::Value"""
        return _openshot.Deinterlace_JsonValue(self)


    def SetJsonValue(self, root):
        """SetJsonValue(Deinterlace self, Json::Value root)"""
        return _openshot.Deinterlace_SetJsonValue(self, root)


    def PropertiesJSON(self, requested_frame):
        """PropertiesJSON(Deinterlace self, int64_t requested_frame) -> std::string"""
        return _openshot.Deinterlace_PropertiesJSON(self, requested_frame)

    __swig_destroy__ = _openshot.delete_Deinterlace
    __del__ = lambda self: None
Deinterlace_swigregister = _openshot.Deinterlace_swigregister
Deinterlace_swigregister(Deinterlace)

class Mask(EffectBase):
    """Proxy of C++ openshot::Mask class."""

    __swig_setmethods__ = {}
    for _s in [EffectBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Mask, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Mask, name)
    __repr__ = _swig_repr
    __swig_setmethods__["replace_image"] = _openshot.Mask_replace_image_set
    __swig_getmethods__["replace_image"] = _openshot.Mask_replace_image_get
    if _newclass:
        replace_image = _swig_property(_openshot.Mask_replace_image_get, _openshot.Mask_replace_image_set)
    __swig_setmethods__["brightness"] = _openshot.Mask_brightness_set
    __swig_getmethods__["brightness"] = _openshot.Mask_brightness_get
    if _newclass:
        brightness = _swig_property(_openshot.Mask_brightness_get, _openshot.Mask_brightness_set)
    __swig_setmethods__["contrast"] = _openshot.Mask_contrast_set
    __swig_getmethods__["contrast"] = _openshot.Mask_contrast_get
    if _newclass:
        contrast = _swig_property(_openshot.Mask_contrast_get, _openshot.Mask_contrast_set)

    def __init__(self, *args):
        """
        __init__(openshot::Mask self) -> Mask
        __init__(openshot::Mask self, ReaderBase mask_reader, Keyframe mask_brightness, Keyframe mask_contrast) -> Mask
        """
        this = _openshot.new_Mask(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def GetFrame(self, frame, frame_number):
        """GetFrame(Mask self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.Mask_GetFrame(self, frame, frame_number)


    def Json(self):
        """Json(Mask self) -> std::string"""
        return _openshot.Mask_Json(self)


    def SetJson(self, value):
        """SetJson(Mask self, std::string value)"""
        return _openshot.Mask_SetJson(self, value)


    def JsonValue(self):
        """JsonValue(Mask self) -> Json::Value"""
        return _openshot.Mask_JsonValue(self)


    def SetJsonValue(self, root):
        """SetJsonValue(Mask self, Json::Value root)"""
        return _openshot.Mask_SetJsonValue(self, root)


    def PropertiesJSON(self, requested_frame):
        """PropertiesJSON(Mask self, int64_t requested_frame) -> std::string"""
        return _openshot.Mask_PropertiesJSON(self, requested_frame)


    def Reader(self, *args):
        """
        Reader(Mask self) -> ReaderBase
        Reader(Mask self, ReaderBase new_reader)
        """
        return _openshot.Mask_Reader(self, *args)

    __swig_destroy__ = _openshot.delete_Mask
    __del__ = lambda self: None
Mask_swigregister = _openshot.Mask_swigregister
Mask_swigregister(Mask)

class Negate(EffectBase):
    """Proxy of C++ openshot::Negate class."""

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

    def __init__(self):
        """__init__(openshot::Negate self) -> Negate"""
        this = _openshot.new_Negate()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def GetFrame(self, frame, frame_number):
        """GetFrame(Negate self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.Negate_GetFrame(self, frame, frame_number)


    def Json(self):
        """Json(Negate self) -> std::string"""
        return _openshot.Negate_Json(self)


    def SetJson(self, value):
        """SetJson(Negate self, std::string value)"""
        return _openshot.Negate_SetJson(self, value)


    def JsonValue(self):
        """JsonValue(Negate self) -> Json::Value"""
        return _openshot.Negate_JsonValue(self)


    def SetJsonValue(self, root):
        """SetJsonValue(Negate self, Json::Value root)"""
        return _openshot.Negate_SetJsonValue(self, root)


    def PropertiesJSON(self, requested_frame):
        """PropertiesJSON(Negate self, int64_t requested_frame) -> std::string"""
        return _openshot.Negate_PropertiesJSON(self, requested_frame)

    __swig_destroy__ = _openshot.delete_Negate
    __del__ = lambda self: None
Negate_swigregister = _openshot.Negate_swigregister
Negate_swigregister(Negate)

class Saturation(EffectBase):
    """Proxy of C++ openshot::Saturation class."""

    __swig_setmethods__ = {}
    for _s in [EffectBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Saturation, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Saturation, name)
    __repr__ = _swig_repr
    __swig_setmethods__["saturation"] = _openshot.Saturation_saturation_set
    __swig_getmethods__["saturation"] = _openshot.Saturation_saturation_get
    if _newclass:
        saturation = _swig_property(_openshot.Saturation_saturation_get, _openshot.Saturation_saturation_set)

    def __init__(self, *args):
        """
        __init__(openshot::Saturation self) -> Saturation
        __init__(openshot::Saturation self, Keyframe new_saturation) -> Saturation
        """
        this = _openshot.new_Saturation(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def GetFrame(self, frame, frame_number):
        """GetFrame(Saturation self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.Saturation_GetFrame(self, frame, frame_number)


    def Json(self):
        """Json(Saturation self) -> std::string"""
        return _openshot.Saturation_Json(self)


    def SetJson(self, value):
        """SetJson(Saturation self, std::string value)"""
        return _openshot.Saturation_SetJson(self, value)


    def JsonValue(self):
        """JsonValue(Saturation self) -> Json::Value"""
        return _openshot.Saturation_JsonValue(self)


    def SetJsonValue(self, root):
        """SetJsonValue(Saturation self, Json::Value root)"""
        return _openshot.Saturation_SetJsonValue(self, root)


    def PropertiesJSON(self, requested_frame):
        """PropertiesJSON(Saturation self, int64_t requested_frame) -> std::string"""
        return _openshot.Saturation_PropertiesJSON(self, requested_frame)

    __swig_destroy__ = _openshot.delete_Saturation
    __del__ = lambda self: None
Saturation_swigregister = _openshot.Saturation_swigregister
Saturation_swigregister(Saturation)

class ClipList(_object):
    """Proxy of C++ std::list<(p.openshot::Clip)> class."""

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

    def iterator(self):
        """iterator(ClipList self) -> SwigPyIterator"""
        return _openshot.ClipList_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(ClipList self) -> bool"""
        return _openshot.ClipList___nonzero__(self)


    def __bool__(self):
        """__bool__(ClipList self) -> bool"""
        return _openshot.ClipList___bool__(self)


    def __len__(self):
        """__len__(ClipList self) -> std::list< openshot::Clip * >::size_type"""
        return _openshot.ClipList___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(ClipList self, std::list< openshot::Clip * >::difference_type i, std::list< openshot::Clip * >::difference_type j) -> ClipList"""
        return _openshot.ClipList___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(ClipList self, std::list< openshot::Clip * >::difference_type i, std::list< openshot::Clip * >::difference_type j)
        __setslice__(ClipList self, std::list< openshot::Clip * >::difference_type i, std::list< openshot::Clip * >::difference_type j, ClipList v)
        """
        return _openshot.ClipList___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(ClipList self, std::list< openshot::Clip * >::difference_type i, std::list< openshot::Clip * >::difference_type j)"""
        return _openshot.ClipList___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(ClipList self, std::list< openshot::Clip * >::difference_type i)
        __delitem__(ClipList self, PySliceObject * slice)
        """
        return _openshot.ClipList___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(ClipList self, PySliceObject * slice) -> ClipList
        __getitem__(ClipList self, std::list< openshot::Clip * >::difference_type i) -> Clip
        """
        return _openshot.ClipList___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(ClipList self, PySliceObject * slice, ClipList v)
        __setitem__(ClipList self, PySliceObject * slice)
        __setitem__(ClipList self, std::list< openshot::Clip * >::difference_type i, Clip x)
        """
        return _openshot.ClipList___setitem__(self, *args)


    def pop(self):
        """pop(ClipList self) -> Clip"""
        return _openshot.ClipList_pop(self)


    def append(self, x):
        """append(ClipList self, Clip x)"""
        return _openshot.ClipList_append(self, x)


    def empty(self):
        """empty(ClipList self) -> bool"""
        return _openshot.ClipList_empty(self)


    def size(self):
        """size(ClipList self) -> std::list< openshot::Clip * >::size_type"""
        return _openshot.ClipList_size(self)


    def swap(self, v):
        """swap(ClipList self, ClipList v)"""
        return _openshot.ClipList_swap(self, v)


    def begin(self):
        """begin(ClipList self) -> std::list< openshot::Clip * >::iterator"""
        return _openshot.ClipList_begin(self)


    def end(self):
        """end(ClipList self) -> std::list< openshot::Clip * >::iterator"""
        return _openshot.ClipList_end(self)


    def rbegin(self):
        """rbegin(ClipList self) -> std::list< openshot::Clip * >::reverse_iterator"""
        return _openshot.ClipList_rbegin(self)


    def rend(self):
        """rend(ClipList self) -> std::list< openshot::Clip * >::reverse_iterator"""
        return _openshot.ClipList_rend(self)


    def clear(self):
        """clear(ClipList self)"""
        return _openshot.ClipList_clear(self)


    def get_allocator(self):
        """get_allocator(ClipList self) -> std::list< openshot::Clip * >::allocator_type"""
        return _openshot.ClipList_get_allocator(self)


    def pop_back(self):
        """pop_back(ClipList self)"""
        return _openshot.ClipList_pop_back(self)


    def erase(self, *args):
        """
        erase(ClipList self, std::list< openshot::Clip * >::iterator pos) -> std::list< openshot::Clip * >::iterator
        erase(ClipList self, std::list< openshot::Clip * >::iterator first, std::list< openshot::Clip * >::iterator last) -> std::list< openshot::Clip * >::iterator
        """
        return _openshot.ClipList_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::list<(p.openshot::Clip)> self) -> ClipList
        __init__(std::list<(p.openshot::Clip)> self, ClipList arg2) -> ClipList
        __init__(std::list<(p.openshot::Clip)> self, std::list< openshot::Clip * >::size_type size) -> ClipList
        __init__(std::list<(p.openshot::Clip)> self, std::list< openshot::Clip * >::size_type size, Clip value) -> ClipList
        """
        this = _openshot.new_ClipList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(ClipList self, Clip x)"""
        return _openshot.ClipList_push_back(self, x)


    def front(self):
        """front(ClipList self) -> Clip"""
        return _openshot.ClipList_front(self)


    def back(self):
        """back(ClipList self) -> Clip"""
        return _openshot.ClipList_back(self)


    def assign(self, n, x):
        """assign(ClipList self, std::list< openshot::Clip * >::size_type n, Clip x)"""
        return _openshot.ClipList_assign(self, n, x)


    def resize(self, *args):
        """
        resize(ClipList self, std::list< openshot::Clip * >::size_type new_size)
        resize(ClipList self, std::list< openshot::Clip * >::size_type new_size, Clip x)
        """
        return _openshot.ClipList_resize(self, *args)


    def insert(self, *args):
        """
        insert(ClipList self, std::list< openshot::Clip * >::iterator pos, Clip x) -> std::list< openshot::Clip * >::iterator
        insert(ClipList self, std::list< openshot::Clip * >::iterator pos, std::list< openshot::Clip * >::size_type n, Clip x)
        """
        return _openshot.ClipList_insert(self, *args)


    def pop_front(self):
        """pop_front(ClipList self)"""
        return _openshot.ClipList_pop_front(self)


    def push_front(self, x):
        """push_front(ClipList self, Clip x)"""
        return _openshot.ClipList_push_front(self, x)


    def remove(self, x):
        """remove(ClipList self, Clip x)"""
        return _openshot.ClipList_remove(self, x)


    def unique(self):
        """unique(ClipList self)"""
        return _openshot.ClipList_unique(self)


    def reverse(self):
        """reverse(ClipList self)"""
        return _openshot.ClipList_reverse(self)


    def sort(self):
        """sort(ClipList self)"""
        return _openshot.ClipList_sort(self)


    def merge(self, x):
        """merge(ClipList self, ClipList x)"""
        return _openshot.ClipList_merge(self, x)

    __swig_destroy__ = _openshot.delete_ClipList
    __del__ = lambda self: None
ClipList_swigregister = _openshot.ClipList_swigregister
ClipList_swigregister(ClipList)

class EffectBaseList(_object):
    """Proxy of C++ std::list<(p.openshot::EffectBase)> class."""

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

    def iterator(self):
        """iterator(EffectBaseList self) -> SwigPyIterator"""
        return _openshot.EffectBaseList_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(EffectBaseList self) -> bool"""
        return _openshot.EffectBaseList___nonzero__(self)


    def __bool__(self):
        """__bool__(EffectBaseList self) -> bool"""
        return _openshot.EffectBaseList___bool__(self)


    def __len__(self):
        """__len__(EffectBaseList self) -> std::list< openshot::EffectBase * >::size_type"""
        return _openshot.EffectBaseList___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(EffectBaseList self, std::list< openshot::EffectBase * >::difference_type i, std::list< openshot::EffectBase * >::difference_type j) -> EffectBaseList"""
        return _openshot.EffectBaseList___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(EffectBaseList self, std::list< openshot::EffectBase * >::difference_type i, std::list< openshot::EffectBase * >::difference_type j)
        __setslice__(EffectBaseList self, std::list< openshot::EffectBase * >::difference_type i, std::list< openshot::EffectBase * >::difference_type j, EffectBaseList v)
        """
        return _openshot.EffectBaseList___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(EffectBaseList self, std::list< openshot::EffectBase * >::difference_type i, std::list< openshot::EffectBase * >::difference_type j)"""
        return _openshot.EffectBaseList___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(EffectBaseList self, std::list< openshot::EffectBase * >::difference_type i)
        __delitem__(EffectBaseList self, PySliceObject * slice)
        """
        return _openshot.EffectBaseList___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(EffectBaseList self, PySliceObject * slice) -> EffectBaseList
        __getitem__(EffectBaseList self, std::list< openshot::EffectBase * >::difference_type i) -> EffectBase
        """
        return _openshot.EffectBaseList___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(EffectBaseList self, PySliceObject * slice, EffectBaseList v)
        __setitem__(EffectBaseList self, PySliceObject * slice)
        __setitem__(EffectBaseList self, std::list< openshot::EffectBase * >::difference_type i, EffectBase x)
        """
        return _openshot.EffectBaseList___setitem__(self, *args)


    def pop(self):
        """pop(EffectBaseList self) -> EffectBase"""
        return _openshot.EffectBaseList_pop(self)


    def append(self, x):
        """append(EffectBaseList self, EffectBase x)"""
        return _openshot.EffectBaseList_append(self, x)


    def empty(self):
        """empty(EffectBaseList self) -> bool"""
        return _openshot.EffectBaseList_empty(self)


    def size(self):
        """size(EffectBaseList self) -> std::list< openshot::EffectBase * >::size_type"""
        return _openshot.EffectBaseList_size(self)


    def swap(self, v):
        """swap(EffectBaseList self, EffectBaseList v)"""
        return _openshot.EffectBaseList_swap(self, v)


    def begin(self):
        """begin(EffectBaseList self) -> std::list< openshot::EffectBase * >::iterator"""
        return _openshot.EffectBaseList_begin(self)


    def end(self):
        """end(EffectBaseList self) -> std::list< openshot::EffectBase * >::iterator"""
        return _openshot.EffectBaseList_end(self)


    def rbegin(self):
        """rbegin(EffectBaseList self) -> std::list< openshot::EffectBase * >::reverse_iterator"""
        return _openshot.EffectBaseList_rbegin(self)


    def rend(self):
        """rend(EffectBaseList self) -> std::list< openshot::EffectBase * >::reverse_iterator"""
        return _openshot.EffectBaseList_rend(self)


    def clear(self):
        """clear(EffectBaseList self)"""
        return _openshot.EffectBaseList_clear(self)


    def get_allocator(self):
        """get_allocator(EffectBaseList self) -> std::list< openshot::EffectBase * >::allocator_type"""
        return _openshot.EffectBaseList_get_allocator(self)


    def pop_back(self):
        """pop_back(EffectBaseList self)"""
        return _openshot.EffectBaseList_pop_back(self)


    def erase(self, *args):
        """
        erase(EffectBaseList self, std::list< openshot::EffectBase * >::iterator pos) -> std::list< openshot::EffectBase * >::iterator
        erase(EffectBaseList self, std::list< openshot::EffectBase * >::iterator first, std::list< openshot::EffectBase * >::iterator last) -> std::list< openshot::EffectBase * >::iterator
        """
        return _openshot.EffectBaseList_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::list<(p.openshot::EffectBase)> self) -> EffectBaseList
        __init__(std::list<(p.openshot::EffectBase)> self, EffectBaseList arg2) -> EffectBaseList
        __init__(std::list<(p.openshot::EffectBase)> self, std::list< openshot::EffectBase * >::size_type size) -> EffectBaseList
        __init__(std::list<(p.openshot::EffectBase)> self, std::list< openshot::EffectBase * >::size_type size, EffectBase value) -> EffectBaseList
        """
        this = _openshot.new_EffectBaseList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(EffectBaseList self, EffectBase x)"""
        return _openshot.EffectBaseList_push_back(self, x)


    def front(self):
        """front(EffectBaseList self) -> EffectBase"""
        return _openshot.EffectBaseList_front(self)


    def back(self):
        """back(EffectBaseList self) -> EffectBase"""
        return _openshot.EffectBaseList_back(self)


    def assign(self, n, x):
        """assign(EffectBaseList self, std::list< openshot::EffectBase * >::size_type n, EffectBase x)"""
        return _openshot.EffectBaseList_assign(self, n, x)


    def resize(self, *args):
        """
        resize(EffectBaseList self, std::list< openshot::EffectBase * >::size_type new_size)
        resize(EffectBaseList self, std::list< openshot::EffectBase * >::size_type new_size, EffectBase x)
        """
        return _openshot.EffectBaseList_resize(self, *args)


    def insert(self, *args):
        """
        insert(EffectBaseList self, std::list< openshot::EffectBase * >::iterator pos, EffectBase x) -> std::list< openshot::EffectBase * >::iterator
        insert(EffectBaseList self, std::list< openshot::EffectBase * >::iterator pos, std::list< openshot::EffectBase * >::size_type n, EffectBase x)
        """
        return _openshot.EffectBaseList_insert(self, *args)


    def pop_front(self):
        """pop_front(EffectBaseList self)"""
        return _openshot.EffectBaseList_pop_front(self)


    def push_front(self, x):
        """push_front(EffectBaseList self, EffectBase x)"""
        return _openshot.EffectBaseList_push_front(self, x)


    def remove(self, x):
        """remove(EffectBaseList self, EffectBase x)"""
        return _openshot.EffectBaseList_remove(self, x)


    def unique(self):
        """unique(EffectBaseList self)"""
        return _openshot.EffectBaseList_unique(self)


    def reverse(self):
        """reverse(EffectBaseList self)"""
        return _openshot.EffectBaseList_reverse(self)


    def sort(self):
        """sort(EffectBaseList self)"""
        return _openshot.EffectBaseList_sort(self)


    def merge(self, x):
        """merge(EffectBaseList self, EffectBaseList x)"""
        return _openshot.EffectBaseList_merge(self, x)

    __swig_destroy__ = _openshot.delete_EffectBaseList
    __del__ = lambda self: None
EffectBaseList_swigregister = _openshot.EffectBaseList_swigregister
EffectBaseList_swigregister(EffectBaseList)

class CoordinateVector(_object):
    """Proxy of C++ std::vector<(openshot::Coordinate)> class."""

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

    def iterator(self):
        """iterator(CoordinateVector self) -> SwigPyIterator"""
        return _openshot.CoordinateVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(CoordinateVector self) -> bool"""
        return _openshot.CoordinateVector___nonzero__(self)


    def __bool__(self):
        """__bool__(CoordinateVector self) -> bool"""
        return _openshot.CoordinateVector___bool__(self)


    def __len__(self):
        """__len__(CoordinateVector self) -> std::vector< openshot::Coordinate >::size_type"""
        return _openshot.CoordinateVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(CoordinateVector self, std::vector< openshot::Coordinate >::difference_type i, std::vector< openshot::Coordinate >::difference_type j) -> CoordinateVector"""
        return _openshot.CoordinateVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(CoordinateVector self, std::vector< openshot::Coordinate >::difference_type i, std::vector< openshot::Coordinate >::difference_type j)
        __setslice__(CoordinateVector self, std::vector< openshot::Coordinate >::difference_type i, std::vector< openshot::Coordinate >::difference_type j, CoordinateVector v)
        """
        return _openshot.CoordinateVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(CoordinateVector self, std::vector< openshot::Coordinate >::difference_type i, std::vector< openshot::Coordinate >::difference_type j)"""
        return _openshot.CoordinateVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(CoordinateVector self, std::vector< openshot::Coordinate >::difference_type i)
        __delitem__(CoordinateVector self, PySliceObject * slice)
        """
        return _openshot.CoordinateVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(CoordinateVector self, PySliceObject * slice) -> CoordinateVector
        __getitem__(CoordinateVector self, std::vector< openshot::Coordinate >::difference_type i) -> Coordinate
        """
        return _openshot.CoordinateVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(CoordinateVector self, PySliceObject * slice, CoordinateVector v)
        __setitem__(CoordinateVector self, PySliceObject * slice)
        __setitem__(CoordinateVector self, std::vector< openshot::Coordinate >::difference_type i, Coordinate x)
        """
        return _openshot.CoordinateVector___setitem__(self, *args)


    def pop(self):
        """pop(CoordinateVector self) -> Coordinate"""
        return _openshot.CoordinateVector_pop(self)


    def append(self, x):
        """append(CoordinateVector self, Coordinate x)"""
        return _openshot.CoordinateVector_append(self, x)


    def empty(self):
        """empty(CoordinateVector self) -> bool"""
        return _openshot.CoordinateVector_empty(self)


    def size(self):
        """size(CoordinateVector self) -> std::vector< openshot::Coordinate >::size_type"""
        return _openshot.CoordinateVector_size(self)


    def swap(self, v):
        """swap(CoordinateVector self, CoordinateVector v)"""
        return _openshot.CoordinateVector_swap(self, v)


    def begin(self):
        """begin(CoordinateVector self) -> std::vector< openshot::Coordinate >::iterator"""
        return _openshot.CoordinateVector_begin(self)


    def end(self):
        """end(CoordinateVector self) -> std::vector< openshot::Coordinate >::iterator"""
        return _openshot.CoordinateVector_end(self)


    def rbegin(self):
        """rbegin(CoordinateVector self) -> std::vector< openshot::Coordinate >::reverse_iterator"""
        return _openshot.CoordinateVector_rbegin(self)


    def rend(self):
        """rend(CoordinateVector self) -> std::vector< openshot::Coordinate >::reverse_iterator"""
        return _openshot.CoordinateVector_rend(self)


    def clear(self):
        """clear(CoordinateVector self)"""
        return _openshot.CoordinateVector_clear(self)


    def get_allocator(self):
        """get_allocator(CoordinateVector self) -> std::vector< openshot::Coordinate >::allocator_type"""
        return _openshot.CoordinateVector_get_allocator(self)


    def pop_back(self):
        """pop_back(CoordinateVector self)"""
        return _openshot.CoordinateVector_pop_back(self)


    def erase(self, *args):
        """
        erase(CoordinateVector self, std::vector< openshot::Coordinate >::iterator pos) -> std::vector< openshot::Coordinate >::iterator
        erase(CoordinateVector self, std::vector< openshot::Coordinate >::iterator first, std::vector< openshot::Coordinate >::iterator last) -> std::vector< openshot::Coordinate >::iterator
        """
        return _openshot.CoordinateVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(openshot::Coordinate)> self) -> CoordinateVector
        __init__(std::vector<(openshot::Coordinate)> self, CoordinateVector arg2) -> CoordinateVector
        __init__(std::vector<(openshot::Coordinate)> self, std::vector< openshot::Coordinate >::size_type size) -> CoordinateVector
        __init__(std::vector<(openshot::Coordinate)> self, std::vector< openshot::Coordinate >::size_type size, Coordinate value) -> CoordinateVector
        """
        this = _openshot.new_CoordinateVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(CoordinateVector self, Coordinate x)"""
        return _openshot.CoordinateVector_push_back(self, x)


    def front(self):
        """front(CoordinateVector self) -> Coordinate"""
        return _openshot.CoordinateVector_front(self)


    def back(self):
        """back(CoordinateVector self) -> Coordinate"""
        return _openshot.CoordinateVector_back(self)


    def assign(self, n, x):
        """assign(CoordinateVector self, std::vector< openshot::Coordinate >::size_type n, Coordinate x)"""
        return _openshot.CoordinateVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(CoordinateVector self, std::vector< openshot::Coordinate >::size_type new_size)
        resize(CoordinateVector self, std::vector< openshot::Coordinate >::size_type new_size, Coordinate x)
        """
        return _openshot.CoordinateVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(CoordinateVector self, std::vector< openshot::Coordinate >::iterator pos, Coordinate x) -> std::vector< openshot::Coordinate >::iterator
        insert(CoordinateVector self, std::vector< openshot::Coordinate >::iterator pos, std::vector< openshot::Coordinate >::size_type n, Coordinate x)
        """
        return _openshot.CoordinateVector_insert(self, *args)


    def reserve(self, n):
        """reserve(CoordinateVector self, std::vector< openshot::Coordinate >::size_type n)"""
        return _openshot.CoordinateVector_reserve(self, n)


    def capacity(self):
        """capacity(CoordinateVector self) -> std::vector< openshot::Coordinate >::size_type"""
        return _openshot.CoordinateVector_capacity(self)

    __swig_destroy__ = _openshot.delete_CoordinateVector
    __del__ = lambda self: None
CoordinateVector_swigregister = _openshot.CoordinateVector_swigregister
CoordinateVector_swigregister(CoordinateVector)

class PointsVector(_object):
    """Proxy of C++ std::vector<(openshot::Point)> class."""

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

    def iterator(self):
        """iterator(PointsVector self) -> SwigPyIterator"""
        return _openshot.PointsVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(PointsVector self) -> bool"""
        return _openshot.PointsVector___nonzero__(self)


    def __bool__(self):
        """__bool__(PointsVector self) -> bool"""
        return _openshot.PointsVector___bool__(self)


    def __len__(self):
        """__len__(PointsVector self) -> std::vector< openshot::Point >::size_type"""
        return _openshot.PointsVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(PointsVector self, std::vector< openshot::Point >::difference_type i, std::vector< openshot::Point >::difference_type j) -> PointsVector"""
        return _openshot.PointsVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(PointsVector self, std::vector< openshot::Point >::difference_type i, std::vector< openshot::Point >::difference_type j)
        __setslice__(PointsVector self, std::vector< openshot::Point >::difference_type i, std::vector< openshot::Point >::difference_type j, PointsVector v)
        """
        return _openshot.PointsVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(PointsVector self, std::vector< openshot::Point >::difference_type i, std::vector< openshot::Point >::difference_type j)"""
        return _openshot.PointsVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(PointsVector self, std::vector< openshot::Point >::difference_type i)
        __delitem__(PointsVector self, PySliceObject * slice)
        """
        return _openshot.PointsVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(PointsVector self, PySliceObject * slice) -> PointsVector
        __getitem__(PointsVector self, std::vector< openshot::Point >::difference_type i) -> Point
        """
        return _openshot.PointsVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(PointsVector self, PySliceObject * slice, PointsVector v)
        __setitem__(PointsVector self, PySliceObject * slice)
        __setitem__(PointsVector self, std::vector< openshot::Point >::difference_type i, Point x)
        """
        return _openshot.PointsVector___setitem__(self, *args)


    def pop(self):
        """pop(PointsVector self) -> Point"""
        return _openshot.PointsVector_pop(self)


    def append(self, x):
        """append(PointsVector self, Point x)"""
        return _openshot.PointsVector_append(self, x)


    def empty(self):
        """empty(PointsVector self) -> bool"""
        return _openshot.PointsVector_empty(self)


    def size(self):
        """size(PointsVector self) -> std::vector< openshot::Point >::size_type"""
        return _openshot.PointsVector_size(self)


    def swap(self, v):
        """swap(PointsVector self, PointsVector v)"""
        return _openshot.PointsVector_swap(self, v)


    def begin(self):
        """begin(PointsVector self) -> std::vector< openshot::Point >::iterator"""
        return _openshot.PointsVector_begin(self)


    def end(self):
        """end(PointsVector self) -> std::vector< openshot::Point >::iterator"""
        return _openshot.PointsVector_end(self)


    def rbegin(self):
        """rbegin(PointsVector self) -> std::vector< openshot::Point >::reverse_iterator"""
        return _openshot.PointsVector_rbegin(self)


    def rend(self):
        """rend(PointsVector self) -> std::vector< openshot::Point >::reverse_iterator"""
        return _openshot.PointsVector_rend(self)


    def clear(self):
        """clear(PointsVector self)"""
        return _openshot.PointsVector_clear(self)


    def get_allocator(self):
        """get_allocator(PointsVector self) -> std::vector< openshot::Point >::allocator_type"""
        return _openshot.PointsVector_get_allocator(self)


    def pop_back(self):
        """pop_back(PointsVector self)"""
        return _openshot.PointsVector_pop_back(self)


    def erase(self, *args):
        """
        erase(PointsVector self, std::vector< openshot::Point >::iterator pos) -> std::vector< openshot::Point >::iterator
        erase(PointsVector self, std::vector< openshot::Point >::iterator first, std::vector< openshot::Point >::iterator last) -> std::vector< openshot::Point >::iterator
        """
        return _openshot.PointsVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(openshot::Point)> self) -> PointsVector
        __init__(std::vector<(openshot::Point)> self, PointsVector arg2) -> PointsVector
        __init__(std::vector<(openshot::Point)> self, std::vector< openshot::Point >::size_type size) -> PointsVector
        __init__(std::vector<(openshot::Point)> self, std::vector< openshot::Point >::size_type size, Point value) -> PointsVector
        """
        this = _openshot.new_PointsVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(PointsVector self, Point x)"""
        return _openshot.PointsVector_push_back(self, x)


    def front(self):
        """front(PointsVector self) -> Point"""
        return _openshot.PointsVector_front(self)


    def back(self):
        """back(PointsVector self) -> Point"""
        return _openshot.PointsVector_back(self)


    def assign(self, n, x):
        """assign(PointsVector self, std::vector< openshot::Point >::size_type n, Point x)"""
        return _openshot.PointsVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(PointsVector self, std::vector< openshot::Point >::size_type new_size)
        resize(PointsVector self, std::vector< openshot::Point >::size_type new_size, Point x)
        """
        return _openshot.PointsVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(PointsVector self, std::vector< openshot::Point >::iterator pos, Point x) -> std::vector< openshot::Point >::iterator
        insert(PointsVector self, std::vector< openshot::Point >::iterator pos, std::vector< openshot::Point >::size_type n, Point x)
        """
        return _openshot.PointsVector_insert(self, *args)


    def reserve(self, n):
        """reserve(PointsVector self, std::vector< openshot::Point >::size_type n)"""
        return _openshot.PointsVector_reserve(self, n)


    def capacity(self):
        """capacity(PointsVector self) -> std::vector< openshot::Point >::size_type"""
        return _openshot.PointsVector_capacity(self)

    __swig_destroy__ = _openshot.delete_PointsVector
    __del__ = lambda self: None
PointsVector_swigregister = _openshot.PointsVector_swigregister
PointsVector_swigregister(PointsVector)

class FieldVector(_object):
    """Proxy of C++ std::vector<(openshot::Field)> class."""

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

    def iterator(self):
        """iterator(FieldVector self) -> SwigPyIterator"""
        return _openshot.FieldVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(FieldVector self) -> bool"""
        return _openshot.FieldVector___nonzero__(self)


    def __bool__(self):
        """__bool__(FieldVector self) -> bool"""
        return _openshot.FieldVector___bool__(self)


    def __len__(self):
        """__len__(FieldVector self) -> std::vector< openshot::Field >::size_type"""
        return _openshot.FieldVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(FieldVector self, std::vector< openshot::Field >::difference_type i, std::vector< openshot::Field >::difference_type j) -> FieldVector"""
        return _openshot.FieldVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(FieldVector self, std::vector< openshot::Field >::difference_type i, std::vector< openshot::Field >::difference_type j)
        __setslice__(FieldVector self, std::vector< openshot::Field >::difference_type i, std::vector< openshot::Field >::difference_type j, FieldVector v)
        """
        return _openshot.FieldVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(FieldVector self, std::vector< openshot::Field >::difference_type i, std::vector< openshot::Field >::difference_type j)"""
        return _openshot.FieldVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(FieldVector self, std::vector< openshot::Field >::difference_type i)
        __delitem__(FieldVector self, PySliceObject * slice)
        """
        return _openshot.FieldVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(FieldVector self, PySliceObject * slice) -> FieldVector
        __getitem__(FieldVector self, std::vector< openshot::Field >::difference_type i) -> Field
        """
        return _openshot.FieldVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(FieldVector self, PySliceObject * slice, FieldVector v)
        __setitem__(FieldVector self, PySliceObject * slice)
        __setitem__(FieldVector self, std::vector< openshot::Field >::difference_type i, Field x)
        """
        return _openshot.FieldVector___setitem__(self, *args)


    def pop(self):
        """pop(FieldVector self) -> Field"""
        return _openshot.FieldVector_pop(self)


    def append(self, x):
        """append(FieldVector self, Field x)"""
        return _openshot.FieldVector_append(self, x)


    def empty(self):
        """empty(FieldVector self) -> bool"""
        return _openshot.FieldVector_empty(self)


    def size(self):
        """size(FieldVector self) -> std::vector< openshot::Field >::size_type"""
        return _openshot.FieldVector_size(self)


    def swap(self, v):
        """swap(FieldVector self, FieldVector v)"""
        return _openshot.FieldVector_swap(self, v)


    def begin(self):
        """begin(FieldVector self) -> std::vector< openshot::Field >::iterator"""
        return _openshot.FieldVector_begin(self)


    def end(self):
        """end(FieldVector self) -> std::vector< openshot::Field >::iterator"""
        return _openshot.FieldVector_end(self)


    def rbegin(self):
        """rbegin(FieldVector self) -> std::vector< openshot::Field >::reverse_iterator"""
        return _openshot.FieldVector_rbegin(self)


    def rend(self):
        """rend(FieldVector self) -> std::vector< openshot::Field >::reverse_iterator"""
        return _openshot.FieldVector_rend(self)


    def clear(self):
        """clear(FieldVector self)"""
        return _openshot.FieldVector_clear(self)


    def get_allocator(self):
        """get_allocator(FieldVector self) -> std::vector< openshot::Field >::allocator_type"""
        return _openshot.FieldVector_get_allocator(self)


    def pop_back(self):
        """pop_back(FieldVector self)"""
        return _openshot.FieldVector_pop_back(self)


    def erase(self, *args):
        """
        erase(FieldVector self, std::vector< openshot::Field >::iterator pos) -> std::vector< openshot::Field >::iterator
        erase(FieldVector self, std::vector< openshot::Field >::iterator first, std::vector< openshot::Field >::iterator last) -> std::vector< openshot::Field >::iterator
        """
        return _openshot.FieldVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(openshot::Field)> self) -> FieldVector
        __init__(std::vector<(openshot::Field)> self, FieldVector arg2) -> FieldVector
        __init__(std::vector<(openshot::Field)> self, std::vector< openshot::Field >::size_type size) -> FieldVector
        __init__(std::vector<(openshot::Field)> self, std::vector< openshot::Field >::size_type size, Field value) -> FieldVector
        """
        this = _openshot.new_FieldVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(FieldVector self, Field x)"""
        return _openshot.FieldVector_push_back(self, x)


    def front(self):
        """front(FieldVector self) -> Field"""
        return _openshot.FieldVector_front(self)


    def back(self):
        """back(FieldVector self) -> Field"""
        return _openshot.FieldVector_back(self)


    def assign(self, n, x):
        """assign(FieldVector self, std::vector< openshot::Field >::size_type n, Field x)"""
        return _openshot.FieldVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(FieldVector self, std::vector< openshot::Field >::size_type new_size)
        resize(FieldVector self, std::vector< openshot::Field >::size_type new_size, Field x)
        """
        return _openshot.FieldVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(FieldVector self, std::vector< openshot::Field >::iterator pos, Field x) -> std::vector< openshot::Field >::iterator
        insert(FieldVector self, std::vector< openshot::Field >::iterator pos, std::vector< openshot::Field >::size_type n, Field x)
        """
        return _openshot.FieldVector_insert(self, *args)


    def reserve(self, n):
        """reserve(FieldVector self, std::vector< openshot::Field >::size_type n)"""
        return _openshot.FieldVector_reserve(self, n)


    def capacity(self):
        """capacity(FieldVector self) -> std::vector< openshot::Field >::size_type"""
        return _openshot.FieldVector_capacity(self)

    __swig_destroy__ = _openshot.delete_FieldVector
    __del__ = lambda self: None
FieldVector_swigregister = _openshot.FieldVector_swigregister
FieldVector_swigregister(FieldVector)

class MappedFrameVector(_object):
    """Proxy of C++ std::vector<(openshot::MappedFrame)> class."""

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

    def iterator(self):
        """iterator(MappedFrameVector self) -> SwigPyIterator"""
        return _openshot.MappedFrameVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(MappedFrameVector self) -> bool"""
        return _openshot.MappedFrameVector___nonzero__(self)


    def __bool__(self):
        """__bool__(MappedFrameVector self) -> bool"""
        return _openshot.MappedFrameVector___bool__(self)


    def __len__(self):
        """__len__(MappedFrameVector self) -> std::vector< openshot::MappedFrame >::size_type"""
        return _openshot.MappedFrameVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(MappedFrameVector self, std::vector< openshot::MappedFrame >::difference_type i, std::vector< openshot::MappedFrame >::difference_type j) -> MappedFrameVector"""
        return _openshot.MappedFrameVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(MappedFrameVector self, std::vector< openshot::MappedFrame >::difference_type i, std::vector< openshot::MappedFrame >::difference_type j)
        __setslice__(MappedFrameVector self, std::vector< openshot::MappedFrame >::difference_type i, std::vector< openshot::MappedFrame >::difference_type j, MappedFrameVector v)
        """
        return _openshot.MappedFrameVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(MappedFrameVector self, std::vector< openshot::MappedFrame >::difference_type i, std::vector< openshot::MappedFrame >::difference_type j)"""
        return _openshot.MappedFrameVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(MappedFrameVector self, std::vector< openshot::MappedFrame >::difference_type i)
        __delitem__(MappedFrameVector self, PySliceObject * slice)
        """
        return _openshot.MappedFrameVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(MappedFrameVector self, PySliceObject * slice) -> MappedFrameVector
        __getitem__(MappedFrameVector self, std::vector< openshot::MappedFrame >::difference_type i) -> MappedFrame
        """
        return _openshot.MappedFrameVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(MappedFrameVector self, PySliceObject * slice, MappedFrameVector v)
        __setitem__(MappedFrameVector self, PySliceObject * slice)
        __setitem__(MappedFrameVector self, std::vector< openshot::MappedFrame >::difference_type i, MappedFrame x)
        """
        return _openshot.MappedFrameVector___setitem__(self, *args)


    def pop(self):
        """pop(MappedFrameVector self) -> MappedFrame"""
        return _openshot.MappedFrameVector_pop(self)


    def append(self, x):
        """append(MappedFrameVector self, MappedFrame x)"""
        return _openshot.MappedFrameVector_append(self, x)


    def empty(self):
        """empty(MappedFrameVector self) -> bool"""
        return _openshot.MappedFrameVector_empty(self)


    def size(self):
        """size(MappedFrameVector self) -> std::vector< openshot::MappedFrame >::size_type"""
        return _openshot.MappedFrameVector_size(self)


    def swap(self, v):
        """swap(MappedFrameVector self, MappedFrameVector v)"""
        return _openshot.MappedFrameVector_swap(self, v)


    def begin(self):
        """begin(MappedFrameVector self) -> std::vector< openshot::MappedFrame >::iterator"""
        return _openshot.MappedFrameVector_begin(self)


    def end(self):
        """end(MappedFrameVector self) -> std::vector< openshot::MappedFrame >::iterator"""
        return _openshot.MappedFrameVector_end(self)


    def rbegin(self):
        """rbegin(MappedFrameVector self) -> std::vector< openshot::MappedFrame >::reverse_iterator"""
        return _openshot.MappedFrameVector_rbegin(self)


    def rend(self):
        """rend(MappedFrameVector self) -> std::vector< openshot::MappedFrame >::reverse_iterator"""
        return _openshot.MappedFrameVector_rend(self)


    def clear(self):
        """clear(MappedFrameVector self)"""
        return _openshot.MappedFrameVector_clear(self)


    def get_allocator(self):
        """get_allocator(MappedFrameVector self) -> std::vector< openshot::MappedFrame >::allocator_type"""
        return _openshot.MappedFrameVector_get_allocator(self)


    def pop_back(self):
        """pop_back(MappedFrameVector self)"""
        return _openshot.MappedFrameVector_pop_back(self)


    def erase(self, *args):
        """
        erase(MappedFrameVector self, std::vector< openshot::MappedFrame >::iterator pos) -> std::vector< openshot::MappedFrame >::iterator
        erase(MappedFrameVector self, std::vector< openshot::MappedFrame >::iterator first, std::vector< openshot::MappedFrame >::iterator last) -> std::vector< openshot::MappedFrame >::iterator
        """
        return _openshot.MappedFrameVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(openshot::MappedFrame)> self) -> MappedFrameVector
        __init__(std::vector<(openshot::MappedFrame)> self, MappedFrameVector arg2) -> MappedFrameVector
        __init__(std::vector<(openshot::MappedFrame)> self, std::vector< openshot::MappedFrame >::size_type size) -> MappedFrameVector
        __init__(std::vector<(openshot::MappedFrame)> self, std::vector< openshot::MappedFrame >::size_type size, MappedFrame value) -> MappedFrameVector
        """
        this = _openshot.new_MappedFrameVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(MappedFrameVector self, MappedFrame x)"""
        return _openshot.MappedFrameVector_push_back(self, x)


    def front(self):
        """front(MappedFrameVector self) -> MappedFrame"""
        return _openshot.MappedFrameVector_front(self)


    def back(self):
        """back(MappedFrameVector self) -> MappedFrame"""
        return _openshot.MappedFrameVector_back(self)


    def assign(self, n, x):
        """assign(MappedFrameVector self, std::vector< openshot::MappedFrame >::size_type n, MappedFrame x)"""
        return _openshot.MappedFrameVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(MappedFrameVector self, std::vector< openshot::MappedFrame >::size_type new_size)
        resize(MappedFrameVector self, std::vector< openshot::MappedFrame >::size_type new_size, MappedFrame x)
        """
        return _openshot.MappedFrameVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(MappedFrameVector self, std::vector< openshot::MappedFrame >::iterator pos, MappedFrame x) -> std::vector< openshot::MappedFrame >::iterator
        insert(MappedFrameVector self, std::vector< openshot::MappedFrame >::iterator pos, std::vector< openshot::MappedFrame >::size_type n, MappedFrame x)
        """
        return _openshot.MappedFrameVector_insert(self, *args)


    def reserve(self, n):
        """reserve(MappedFrameVector self, std::vector< openshot::MappedFrame >::size_type n)"""
        return _openshot.MappedFrameVector_reserve(self, n)


    def capacity(self):
        """capacity(MappedFrameVector self) -> std::vector< openshot::MappedFrame >::size_type"""
        return _openshot.MappedFrameVector_capacity(self)

    __swig_destroy__ = _openshot.delete_MappedFrameVector
    __del__ = lambda self: None
MappedFrameVector_swigregister = _openshot.MappedFrameVector_swigregister
MappedFrameVector_swigregister(MappedFrameVector)

# This file is compatible with both classic and new-style classes.