# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.4.1
#
# 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
# Import the low-level C/C++ module
if getattr(globals().get("__spec__"), "parent", None) or __package__ or "." in __name__:
    from . import _openshot
else:
    import _openshot

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


class SwigPyIterator(object):
    r"""Proxy of C++ swig::SwigPyIterator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

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

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

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

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

    def copy(self, *args):
        r"""copy(SwigPyIterator self) -> SwigPyIterator"""
        return _openshot.SwigPyIterator_copy(self, *args)

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

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

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

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

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

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

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

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

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

    def __sub__(self, *args):
        r"""
        __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

# Register SwigPyIterator in _openshot:
_openshot.SwigPyIterator_swigregister(SwigPyIterator)
SHARED_PTR_DISOWN = _openshot.SHARED_PTR_DISOWN

class ClipList(object):
    r"""Proxy of C++ std::list< openshot::Clip * > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self, *args):
        r"""iterator(ClipList self) -> SwigPyIterator"""
        return _openshot.ClipList_iterator(self, *args)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self, *args):
        r"""__nonzero__(ClipList self) -> bool"""
        return _openshot.ClipList___nonzero__(self, *args)

    def __bool__(self, *args):
        r"""__bool__(ClipList self) -> bool"""
        return _openshot.ClipList___bool__(self, *args)

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

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

    def __setslice__(self, *args):
        r"""
        __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, *args):
        r"""__delslice__(ClipList self, std::list< openshot::Clip * >::difference_type i, std::list< openshot::Clip * >::difference_type j)"""
        return _openshot.ClipList___delslice__(self, *args)

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

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

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

    def pop(self, *args):
        r"""pop(ClipList self) -> Clip"""
        return _openshot.ClipList_pop(self, *args)

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

    def empty(self, *args):
        r"""empty(ClipList self) -> bool"""
        return _openshot.ClipList_empty(self, *args)

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

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

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

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

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

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

    def clear(self, *args):
        r"""clear(ClipList self)"""
        return _openshot.ClipList_clear(self, *args)

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

    def pop_back(self, *args):
        r"""pop_back(ClipList self)"""
        return _openshot.ClipList_pop_back(self, *args)

    def erase(self, *args):
        r"""
        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):
        r"""
        __init__(ClipList self) -> ClipList
        __init__(ClipList self, ClipList other) -> ClipList
        __init__(ClipList self, std::list< openshot::Clip * >::size_type size) -> ClipList
        __init__(ClipList self, std::list< openshot::Clip * >::size_type size, Clip value) -> ClipList
        """
        _openshot.ClipList_swiginit(self, _openshot.new_ClipList(*args))

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

    def front(self, *args):
        r"""front(ClipList self) -> Clip"""
        return _openshot.ClipList_front(self, *args)

    def back(self, *args):
        r"""back(ClipList self) -> Clip"""
        return _openshot.ClipList_back(self, *args)

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

    def resize(self, *args):
        r"""
        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):
        r"""
        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, *args):
        r"""pop_front(ClipList self)"""
        return _openshot.ClipList_pop_front(self, *args)

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

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

    def unique(self, *args):
        r"""unique(ClipList self)"""
        return _openshot.ClipList_unique(self, *args)

    def reverse(self, *args):
        r"""reverse(ClipList self)"""
        return _openshot.ClipList_reverse(self, *args)

    def sort(self, *args):
        r"""sort(ClipList self)"""
        return _openshot.ClipList_sort(self, *args)

    def merge(self, *args):
        r"""merge(ClipList self, ClipList x)"""
        return _openshot.ClipList_merge(self, *args)
    __swig_destroy__ = _openshot.delete_ClipList

# Register ClipList in _openshot:
_openshot.ClipList_swigregister(ClipList)
class EffectBaseList(object):
    r"""Proxy of C++ std::list< openshot::EffectBase * > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self, *args):
        r"""iterator(EffectBaseList self) -> SwigPyIterator"""
        return _openshot.EffectBaseList_iterator(self, *args)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self, *args):
        r"""__nonzero__(EffectBaseList self) -> bool"""
        return _openshot.EffectBaseList___nonzero__(self, *args)

    def __bool__(self, *args):
        r"""__bool__(EffectBaseList self) -> bool"""
        return _openshot.EffectBaseList___bool__(self, *args)

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

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

    def __setslice__(self, *args):
        r"""
        __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, *args):
        r"""__delslice__(EffectBaseList self, std::list< openshot::EffectBase * >::difference_type i, std::list< openshot::EffectBase * >::difference_type j)"""
        return _openshot.EffectBaseList___delslice__(self, *args)

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

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

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

    def pop(self, *args):
        r"""pop(EffectBaseList self) -> EffectBase"""
        return _openshot.EffectBaseList_pop(self, *args)

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

    def empty(self, *args):
        r"""empty(EffectBaseList self) -> bool"""
        return _openshot.EffectBaseList_empty(self, *args)

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

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

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

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

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

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

    def clear(self, *args):
        r"""clear(EffectBaseList self)"""
        return _openshot.EffectBaseList_clear(self, *args)

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

    def pop_back(self, *args):
        r"""pop_back(EffectBaseList self)"""
        return _openshot.EffectBaseList_pop_back(self, *args)

    def erase(self, *args):
        r"""
        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):
        r"""
        __init__(EffectBaseList self) -> EffectBaseList
        __init__(EffectBaseList self, EffectBaseList other) -> EffectBaseList
        __init__(EffectBaseList self, std::list< openshot::EffectBase * >::size_type size) -> EffectBaseList
        __init__(EffectBaseList self, std::list< openshot::EffectBase * >::size_type size, EffectBase value) -> EffectBaseList
        """
        _openshot.EffectBaseList_swiginit(self, _openshot.new_EffectBaseList(*args))

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

    def front(self, *args):
        r"""front(EffectBaseList self) -> EffectBase"""
        return _openshot.EffectBaseList_front(self, *args)

    def back(self, *args):
        r"""back(EffectBaseList self) -> EffectBase"""
        return _openshot.EffectBaseList_back(self, *args)

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

    def resize(self, *args):
        r"""
        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):
        r"""
        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, *args):
        r"""pop_front(EffectBaseList self)"""
        return _openshot.EffectBaseList_pop_front(self, *args)

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

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

    def unique(self, *args):
        r"""unique(EffectBaseList self)"""
        return _openshot.EffectBaseList_unique(self, *args)

    def reverse(self, *args):
        r"""reverse(EffectBaseList self)"""
        return _openshot.EffectBaseList_reverse(self, *args)

    def sort(self, *args):
        r"""sort(EffectBaseList self)"""
        return _openshot.EffectBaseList_sort(self, *args)

    def merge(self, *args):
        r"""merge(EffectBaseList self, EffectBaseList x)"""
        return _openshot.EffectBaseList_merge(self, *args)
    __swig_destroy__ = _openshot.delete_EffectBaseList

# Register EffectBaseList in _openshot:
_openshot.EffectBaseList_swigregister(EffectBaseList)
class CoordinateVector(object):
    r"""Proxy of C++ std::vector< openshot::Coordinate > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self, *args):
        r"""iterator(CoordinateVector self) -> SwigPyIterator"""
        return _openshot.CoordinateVector_iterator(self, *args)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self, *args):
        r"""__nonzero__(CoordinateVector self) -> bool"""
        return _openshot.CoordinateVector___nonzero__(self, *args)

    def __bool__(self, *args):
        r"""__bool__(CoordinateVector self) -> bool"""
        return _openshot.CoordinateVector___bool__(self, *args)

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

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

    def __setslice__(self, *args):
        r"""
        __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, *args):
        r"""__delslice__(CoordinateVector self, std::vector< openshot::Coordinate >::difference_type i, std::vector< openshot::Coordinate >::difference_type j)"""
        return _openshot.CoordinateVector___delslice__(self, *args)

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

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

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

    def pop(self, *args):
        r"""pop(CoordinateVector self) -> Coordinate"""
        return _openshot.CoordinateVector_pop(self, *args)

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

    def empty(self, *args):
        r"""empty(CoordinateVector self) -> bool"""
        return _openshot.CoordinateVector_empty(self, *args)

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

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

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

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

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

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

    def clear(self, *args):
        r"""clear(CoordinateVector self)"""
        return _openshot.CoordinateVector_clear(self, *args)

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

    def pop_back(self, *args):
        r"""pop_back(CoordinateVector self)"""
        return _openshot.CoordinateVector_pop_back(self, *args)

    def erase(self, *args):
        r"""
        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):
        r"""
        __init__(CoordinateVector self) -> CoordinateVector
        __init__(CoordinateVector self, CoordinateVector other) -> CoordinateVector
        __init__(CoordinateVector self, std::vector< openshot::Coordinate >::size_type size) -> CoordinateVector
        __init__(CoordinateVector self, std::vector< openshot::Coordinate >::size_type size, Coordinate value) -> CoordinateVector
        """
        _openshot.CoordinateVector_swiginit(self, _openshot.new_CoordinateVector(*args))

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

    def front(self, *args):
        r"""front(CoordinateVector self) -> Coordinate"""
        return _openshot.CoordinateVector_front(self, *args)

    def back(self, *args):
        r"""back(CoordinateVector self) -> Coordinate"""
        return _openshot.CoordinateVector_back(self, *args)

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

    def resize(self, *args):
        r"""
        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):
        r"""
        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, *args):
        r"""reserve(CoordinateVector self, std::vector< openshot::Coordinate >::size_type n)"""
        return _openshot.CoordinateVector_reserve(self, *args)

    def capacity(self, *args):
        r"""capacity(CoordinateVector self) -> std::vector< openshot::Coordinate >::size_type"""
        return _openshot.CoordinateVector_capacity(self, *args)
    __swig_destroy__ = _openshot.delete_CoordinateVector

# Register CoordinateVector in _openshot:
_openshot.CoordinateVector_swigregister(CoordinateVector)
class PointsVector(object):
    r"""Proxy of C++ std::vector< openshot::Point > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self, *args):
        r"""iterator(PointsVector self) -> SwigPyIterator"""
        return _openshot.PointsVector_iterator(self, *args)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self, *args):
        r"""__nonzero__(PointsVector self) -> bool"""
        return _openshot.PointsVector___nonzero__(self, *args)

    def __bool__(self, *args):
        r"""__bool__(PointsVector self) -> bool"""
        return _openshot.PointsVector___bool__(self, *args)

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

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

    def __setslice__(self, *args):
        r"""
        __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, *args):
        r"""__delslice__(PointsVector self, std::vector< openshot::Point >::difference_type i, std::vector< openshot::Point >::difference_type j)"""
        return _openshot.PointsVector___delslice__(self, *args)

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

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

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

    def pop(self, *args):
        r"""pop(PointsVector self) -> Point"""
        return _openshot.PointsVector_pop(self, *args)

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

    def empty(self, *args):
        r"""empty(PointsVector self) -> bool"""
        return _openshot.PointsVector_empty(self, *args)

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

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

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

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

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

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

    def clear(self, *args):
        r"""clear(PointsVector self)"""
        return _openshot.PointsVector_clear(self, *args)

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

    def pop_back(self, *args):
        r"""pop_back(PointsVector self)"""
        return _openshot.PointsVector_pop_back(self, *args)

    def erase(self, *args):
        r"""
        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):
        r"""
        __init__(PointsVector self) -> PointsVector
        __init__(PointsVector self, PointsVector other) -> PointsVector
        __init__(PointsVector self, std::vector< openshot::Point >::size_type size) -> PointsVector
        __init__(PointsVector self, std::vector< openshot::Point >::size_type size, Point value) -> PointsVector
        """
        _openshot.PointsVector_swiginit(self, _openshot.new_PointsVector(*args))

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

    def front(self, *args):
        r"""front(PointsVector self) -> Point"""
        return _openshot.PointsVector_front(self, *args)

    def back(self, *args):
        r"""back(PointsVector self) -> Point"""
        return _openshot.PointsVector_back(self, *args)

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

    def resize(self, *args):
        r"""
        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):
        r"""
        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, *args):
        r"""reserve(PointsVector self, std::vector< openshot::Point >::size_type n)"""
        return _openshot.PointsVector_reserve(self, *args)

    def capacity(self, *args):
        r"""capacity(PointsVector self) -> std::vector< openshot::Point >::size_type"""
        return _openshot.PointsVector_capacity(self, *args)
    __swig_destroy__ = _openshot.delete_PointsVector

# Register PointsVector in _openshot:
_openshot.PointsVector_swigregister(PointsVector)
class FieldVector(object):
    r"""Proxy of C++ std::vector< openshot::Field > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self, *args):
        r"""iterator(FieldVector self) -> SwigPyIterator"""
        return _openshot.FieldVector_iterator(self, *args)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self, *args):
        r"""__nonzero__(FieldVector self) -> bool"""
        return _openshot.FieldVector___nonzero__(self, *args)

    def __bool__(self, *args):
        r"""__bool__(FieldVector self) -> bool"""
        return _openshot.FieldVector___bool__(self, *args)

    def __len__(self, *args):
        r"""__len__(FieldVector self) -> std::vector< openshot::Field >::size_type"""
        return _openshot.FieldVector___len__(self, *args)

    def __getslice__(self, *args):
        r"""__getslice__(FieldVector self, std::vector< openshot::Field >::difference_type i, std::vector< openshot::Field >::difference_type j) -> FieldVector"""
        return _openshot.FieldVector___getslice__(self, *args)

    def __setslice__(self, *args):
        r"""
        __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, *args):
        r"""__delslice__(FieldVector self, std::vector< openshot::Field >::difference_type i, std::vector< openshot::Field >::difference_type j)"""
        return _openshot.FieldVector___delslice__(self, *args)

    def __delitem__(self, *args):
        r"""
        __delitem__(FieldVector self, std::vector< openshot::Field >::difference_type i)
        __delitem__(FieldVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _openshot.FieldVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(FieldVector self, SWIGPY_SLICEOBJECT * slice) -> FieldVector
        __getitem__(FieldVector self, std::vector< openshot::Field >::difference_type i) -> Field
        """
        return _openshot.FieldVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(FieldVector self, SWIGPY_SLICEOBJECT * slice, FieldVector v)
        __setitem__(FieldVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(FieldVector self, std::vector< openshot::Field >::difference_type i, Field x)
        """
        return _openshot.FieldVector___setitem__(self, *args)

    def pop(self, *args):
        r"""pop(FieldVector self) -> Field"""
        return _openshot.FieldVector_pop(self, *args)

    def append(self, *args):
        r"""append(FieldVector self, Field x)"""
        return _openshot.FieldVector_append(self, *args)

    def empty(self, *args):
        r"""empty(FieldVector self) -> bool"""
        return _openshot.FieldVector_empty(self, *args)

    def size(self, *args):
        r"""size(FieldVector self) -> std::vector< openshot::Field >::size_type"""
        return _openshot.FieldVector_size(self, *args)

    def swap(self, *args):
        r"""swap(FieldVector self, FieldVector v)"""
        return _openshot.FieldVector_swap(self, *args)

    def begin(self, *args):
        r"""begin(FieldVector self) -> std::vector< openshot::Field >::iterator"""
        return _openshot.FieldVector_begin(self, *args)

    def end(self, *args):
        r"""end(FieldVector self) -> std::vector< openshot::Field >::iterator"""
        return _openshot.FieldVector_end(self, *args)

    def rbegin(self, *args):
        r"""rbegin(FieldVector self) -> std::vector< openshot::Field >::reverse_iterator"""
        return _openshot.FieldVector_rbegin(self, *args)

    def rend(self, *args):
        r"""rend(FieldVector self) -> std::vector< openshot::Field >::reverse_iterator"""
        return _openshot.FieldVector_rend(self, *args)

    def clear(self, *args):
        r"""clear(FieldVector self)"""
        return _openshot.FieldVector_clear(self, *args)

    def get_allocator(self, *args):
        r"""get_allocator(FieldVector self) -> std::vector< openshot::Field >::allocator_type"""
        return _openshot.FieldVector_get_allocator(self, *args)

    def pop_back(self, *args):
        r"""pop_back(FieldVector self)"""
        return _openshot.FieldVector_pop_back(self, *args)

    def erase(self, *args):
        r"""
        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):
        r"""
        __init__(FieldVector self) -> FieldVector
        __init__(FieldVector self, FieldVector other) -> FieldVector
        __init__(FieldVector self, std::vector< openshot::Field >::size_type size) -> FieldVector
        __init__(FieldVector self, std::vector< openshot::Field >::size_type size, Field value) -> FieldVector
        """
        _openshot.FieldVector_swiginit(self, _openshot.new_FieldVector(*args))

    def push_back(self, *args):
        r"""push_back(FieldVector self, Field x)"""
        return _openshot.FieldVector_push_back(self, *args)

    def front(self, *args):
        r"""front(FieldVector self) -> Field"""
        return _openshot.FieldVector_front(self, *args)

    def back(self, *args):
        r"""back(FieldVector self) -> Field"""
        return _openshot.FieldVector_back(self, *args)

    def assign(self, *args):
        r"""assign(FieldVector self, std::vector< openshot::Field >::size_type n, Field x)"""
        return _openshot.FieldVector_assign(self, *args)

    def resize(self, *args):
        r"""
        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):
        r"""
        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, *args):
        r"""reserve(FieldVector self, std::vector< openshot::Field >::size_type n)"""
        return _openshot.FieldVector_reserve(self, *args)

    def capacity(self, *args):
        r"""capacity(FieldVector self) -> std::vector< openshot::Field >::size_type"""
        return _openshot.FieldVector_capacity(self, *args)
    __swig_destroy__ = _openshot.delete_FieldVector

# Register FieldVector in _openshot:
_openshot.FieldVector_swigregister(FieldVector)
class MappedFrameVector(object):
    r"""Proxy of C++ std::vector< openshot::MappedFrame > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self, *args):
        r"""iterator(MappedFrameVector self) -> SwigPyIterator"""
        return _openshot.MappedFrameVector_iterator(self, *args)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self, *args):
        r"""__nonzero__(MappedFrameVector self) -> bool"""
        return _openshot.MappedFrameVector___nonzero__(self, *args)

    def __bool__(self, *args):
        r"""__bool__(MappedFrameVector self) -> bool"""
        return _openshot.MappedFrameVector___bool__(self, *args)

    def __len__(self, *args):
        r"""__len__(MappedFrameVector self) -> std::vector< openshot::MappedFrame >::size_type"""
        return _openshot.MappedFrameVector___len__(self, *args)

    def __getslice__(self, *args):
        r"""__getslice__(MappedFrameVector self, std::vector< openshot::MappedFrame >::difference_type i, std::vector< openshot::MappedFrame >::difference_type j) -> MappedFrameVector"""
        return _openshot.MappedFrameVector___getslice__(self, *args)

    def __setslice__(self, *args):
        r"""
        __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, *args):
        r"""__delslice__(MappedFrameVector self, std::vector< openshot::MappedFrame >::difference_type i, std::vector< openshot::MappedFrame >::difference_type j)"""
        return _openshot.MappedFrameVector___delslice__(self, *args)

    def __delitem__(self, *args):
        r"""
        __delitem__(MappedFrameVector self, std::vector< openshot::MappedFrame >::difference_type i)
        __delitem__(MappedFrameVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _openshot.MappedFrameVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(MappedFrameVector self, SWIGPY_SLICEOBJECT * slice) -> MappedFrameVector
        __getitem__(MappedFrameVector self, std::vector< openshot::MappedFrame >::difference_type i) -> MappedFrame
        """
        return _openshot.MappedFrameVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(MappedFrameVector self, SWIGPY_SLICEOBJECT * slice, MappedFrameVector v)
        __setitem__(MappedFrameVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(MappedFrameVector self, std::vector< openshot::MappedFrame >::difference_type i, MappedFrame x)
        """
        return _openshot.MappedFrameVector___setitem__(self, *args)

    def pop(self, *args):
        r"""pop(MappedFrameVector self) -> MappedFrame"""
        return _openshot.MappedFrameVector_pop(self, *args)

    def append(self, *args):
        r"""append(MappedFrameVector self, MappedFrame x)"""
        return _openshot.MappedFrameVector_append(self, *args)

    def empty(self, *args):
        r"""empty(MappedFrameVector self) -> bool"""
        return _openshot.MappedFrameVector_empty(self, *args)

    def size(self, *args):
        r"""size(MappedFrameVector self) -> std::vector< openshot::MappedFrame >::size_type"""
        return _openshot.MappedFrameVector_size(self, *args)

    def swap(self, *args):
        r"""swap(MappedFrameVector self, MappedFrameVector v)"""
        return _openshot.MappedFrameVector_swap(self, *args)

    def begin(self, *args):
        r"""begin(MappedFrameVector self) -> std::vector< openshot::MappedFrame >::iterator"""
        return _openshot.MappedFrameVector_begin(self, *args)

    def end(self, *args):
        r"""end(MappedFrameVector self) -> std::vector< openshot::MappedFrame >::iterator"""
        return _openshot.MappedFrameVector_end(self, *args)

    def rbegin(self, *args):
        r"""rbegin(MappedFrameVector self) -> std::vector< openshot::MappedFrame >::reverse_iterator"""
        return _openshot.MappedFrameVector_rbegin(self, *args)

    def rend(self, *args):
        r"""rend(MappedFrameVector self) -> std::vector< openshot::MappedFrame >::reverse_iterator"""
        return _openshot.MappedFrameVector_rend(self, *args)

    def clear(self, *args):
        r"""clear(MappedFrameVector self)"""
        return _openshot.MappedFrameVector_clear(self, *args)

    def get_allocator(self, *args):
        r"""get_allocator(MappedFrameVector self) -> std::vector< openshot::MappedFrame >::allocator_type"""
        return _openshot.MappedFrameVector_get_allocator(self, *args)

    def pop_back(self, *args):
        r"""pop_back(MappedFrameVector self)"""
        return _openshot.MappedFrameVector_pop_back(self, *args)

    def erase(self, *args):
        r"""
        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):
        r"""
        __init__(MappedFrameVector self) -> MappedFrameVector
        __init__(MappedFrameVector self, MappedFrameVector other) -> MappedFrameVector
        __init__(MappedFrameVector self, std::vector< openshot::MappedFrame >::size_type size) -> MappedFrameVector
        __init__(MappedFrameVector self, std::vector< openshot::MappedFrame >::size_type size, MappedFrame value) -> MappedFrameVector
        """
        _openshot.MappedFrameVector_swiginit(self, _openshot.new_MappedFrameVector(*args))

    def push_back(self, *args):
        r"""push_back(MappedFrameVector self, MappedFrame x)"""
        return _openshot.MappedFrameVector_push_back(self, *args)

    def front(self, *args):
        r"""front(MappedFrameVector self) -> MappedFrame"""
        return _openshot.MappedFrameVector_front(self, *args)

    def back(self, *args):
        r"""back(MappedFrameVector self) -> MappedFrame"""
        return _openshot.MappedFrameVector_back(self, *args)

    def assign(self, *args):
        r"""assign(MappedFrameVector self, std::vector< openshot::MappedFrame >::size_type n, MappedFrame x)"""
        return _openshot.MappedFrameVector_assign(self, *args)

    def resize(self, *args):
        r"""
        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):
        r"""
        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, *args):
        r"""reserve(MappedFrameVector self, std::vector< openshot::MappedFrame >::size_type n)"""
        return _openshot.MappedFrameVector_reserve(self, *args)

    def capacity(self, *args):
        r"""capacity(MappedFrameVector self) -> std::vector< openshot::MappedFrame >::size_type"""
        return _openshot.MappedFrameVector_capacity(self, *args)
    __swig_destroy__ = _openshot.delete_MappedFrameVector

# Register MappedFrameVector in _openshot:
_openshot.MappedFrameVector_swigregister(MappedFrameVector)
class MetadataMap(object):
    r"""Proxy of C++ std::map< std::string,std::string > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self, *args):
        r"""iterator(MetadataMap self) -> SwigPyIterator"""
        return _openshot.MetadataMap_iterator(self, *args)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self, *args):
        r"""__nonzero__(MetadataMap self) -> bool"""
        return _openshot.MetadataMap___nonzero__(self, *args)

    def __bool__(self, *args):
        r"""__bool__(MetadataMap self) -> bool"""
        return _openshot.MetadataMap___bool__(self, *args)

    def __len__(self, *args):
        r"""__len__(MetadataMap self) -> std::map< std::string,std::string >::size_type"""
        return _openshot.MetadataMap___len__(self, *args)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, *args):
        r"""__getitem__(MetadataMap self, std::map< std::string,std::string >::key_type const & key) -> std::map< std::string,std::string >::mapped_type const &"""
        return _openshot.MetadataMap___getitem__(self, *args)

    def __delitem__(self, *args):
        r"""__delitem__(MetadataMap self, std::map< std::string,std::string >::key_type const & key)"""
        return _openshot.MetadataMap___delitem__(self, *args)

    def has_key(self, *args):
        r"""has_key(MetadataMap self, std::map< std::string,std::string >::key_type const & key) -> bool"""
        return _openshot.MetadataMap_has_key(self, *args)

    def keys(self, *args):
        r"""keys(MetadataMap self) -> PyObject *"""
        return _openshot.MetadataMap_keys(self, *args)

    def values(self, *args):
        r"""values(MetadataMap self) -> PyObject *"""
        return _openshot.MetadataMap_values(self, *args)

    def items(self, *args):
        r"""items(MetadataMap self) -> PyObject *"""
        return _openshot.MetadataMap_items(self, *args)

    def __contains__(self, *args):
        r"""__contains__(MetadataMap self, std::map< std::string,std::string >::key_type const & key) -> bool"""
        return _openshot.MetadataMap___contains__(self, *args)

    def key_iterator(self, *args):
        r"""key_iterator(MetadataMap self) -> SwigPyIterator"""
        return _openshot.MetadataMap_key_iterator(self, *args)

    def value_iterator(self, *args):
        r"""value_iterator(MetadataMap self) -> SwigPyIterator"""
        return _openshot.MetadataMap_value_iterator(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(MetadataMap self, std::map< std::string,std::string >::key_type const & key)
        __setitem__(MetadataMap self, std::map< std::string,std::string >::key_type const & key, std::map< std::string,std::string >::mapped_type const & x)
        """
        return _openshot.MetadataMap___setitem__(self, *args)

    def asdict(self, *args):
        r"""asdict(MetadataMap self) -> PyObject *"""
        return _openshot.MetadataMap_asdict(self, *args)

    def __init__(self, *args):
        r"""
        __init__(MetadataMap self, std::less< std::string > const & other) -> MetadataMap
        __init__(MetadataMap self) -> MetadataMap
        __init__(MetadataMap self, MetadataMap other) -> MetadataMap
        """
        _openshot.MetadataMap_swiginit(self, _openshot.new_MetadataMap(*args))

    def empty(self, *args):
        r"""empty(MetadataMap self) -> bool"""
        return _openshot.MetadataMap_empty(self, *args)

    def size(self, *args):
        r"""size(MetadataMap self) -> std::map< std::string,std::string >::size_type"""
        return _openshot.MetadataMap_size(self, *args)

    def swap(self, *args):
        r"""swap(MetadataMap self, MetadataMap v)"""
        return _openshot.MetadataMap_swap(self, *args)

    def begin(self, *args):
        r"""begin(MetadataMap self) -> std::map< std::string,std::string >::iterator"""
        return _openshot.MetadataMap_begin(self, *args)

    def end(self, *args):
        r"""end(MetadataMap self) -> std::map< std::string,std::string >::iterator"""
        return _openshot.MetadataMap_end(self, *args)

    def rbegin(self, *args):
        r"""rbegin(MetadataMap self) -> std::map< std::string,std::string >::reverse_iterator"""
        return _openshot.MetadataMap_rbegin(self, *args)

    def rend(self, *args):
        r"""rend(MetadataMap self) -> std::map< std::string,std::string >::reverse_iterator"""
        return _openshot.MetadataMap_rend(self, *args)

    def clear(self, *args):
        r"""clear(MetadataMap self)"""
        return _openshot.MetadataMap_clear(self, *args)

    def get_allocator(self, *args):
        r"""get_allocator(MetadataMap self) -> std::map< std::string,std::string >::allocator_type"""
        return _openshot.MetadataMap_get_allocator(self, *args)

    def count(self, *args):
        r"""count(MetadataMap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::size_type"""
        return _openshot.MetadataMap_count(self, *args)

    def erase(self, *args):
        r"""
        erase(MetadataMap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::size_type
        erase(MetadataMap self, std::map< std::string,std::string >::iterator position)
        erase(MetadataMap self, std::map< std::string,std::string >::iterator first, std::map< std::string,std::string >::iterator last)
        """
        return _openshot.MetadataMap_erase(self, *args)

    def find(self, *args):
        r"""find(MetadataMap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _openshot.MetadataMap_find(self, *args)

    def lower_bound(self, *args):
        r"""lower_bound(MetadataMap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _openshot.MetadataMap_lower_bound(self, *args)

    def upper_bound(self, *args):
        r"""upper_bound(MetadataMap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _openshot.MetadataMap_upper_bound(self, *args)
    __swig_destroy__ = _openshot.delete_MetadataMap

# Register MetadataMap in _openshot:
_openshot.MetadataMap_swigregister(MetadataMap)
class AudioDeviceInfoVector(object):
    r"""Proxy of C++ std::vector< openshot::AudioDeviceInfo > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self, *args):
        r"""iterator(AudioDeviceInfoVector self) -> SwigPyIterator"""
        return _openshot.AudioDeviceInfoVector_iterator(self, *args)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self, *args):
        r"""__nonzero__(AudioDeviceInfoVector self) -> bool"""
        return _openshot.AudioDeviceInfoVector___nonzero__(self, *args)

    def __bool__(self, *args):
        r"""__bool__(AudioDeviceInfoVector self) -> bool"""
        return _openshot.AudioDeviceInfoVector___bool__(self, *args)

    def __len__(self, *args):
        r"""__len__(AudioDeviceInfoVector self) -> std::vector< openshot::AudioDeviceInfo >::size_type"""
        return _openshot.AudioDeviceInfoVector___len__(self, *args)

    def __getslice__(self, *args):
        r"""__getslice__(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::difference_type i, std::vector< openshot::AudioDeviceInfo >::difference_type j) -> AudioDeviceInfoVector"""
        return _openshot.AudioDeviceInfoVector___getslice__(self, *args)

    def __setslice__(self, *args):
        r"""
        __setslice__(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::difference_type i, std::vector< openshot::AudioDeviceInfo >::difference_type j)
        __setslice__(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::difference_type i, std::vector< openshot::AudioDeviceInfo >::difference_type j, AudioDeviceInfoVector v)
        """
        return _openshot.AudioDeviceInfoVector___setslice__(self, *args)

    def __delslice__(self, *args):
        r"""__delslice__(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::difference_type i, std::vector< openshot::AudioDeviceInfo >::difference_type j)"""
        return _openshot.AudioDeviceInfoVector___delslice__(self, *args)

    def __delitem__(self, *args):
        r"""
        __delitem__(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::difference_type i)
        __delitem__(AudioDeviceInfoVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _openshot.AudioDeviceInfoVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(AudioDeviceInfoVector self, SWIGPY_SLICEOBJECT * slice) -> AudioDeviceInfoVector
        __getitem__(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::difference_type i) -> AudioDeviceInfo
        """
        return _openshot.AudioDeviceInfoVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(AudioDeviceInfoVector self, SWIGPY_SLICEOBJECT * slice, AudioDeviceInfoVector v)
        __setitem__(AudioDeviceInfoVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::difference_type i, AudioDeviceInfo x)
        """
        return _openshot.AudioDeviceInfoVector___setitem__(self, *args)

    def pop(self, *args):
        r"""pop(AudioDeviceInfoVector self) -> AudioDeviceInfo"""
        return _openshot.AudioDeviceInfoVector_pop(self, *args)

    def append(self, *args):
        r"""append(AudioDeviceInfoVector self, AudioDeviceInfo x)"""
        return _openshot.AudioDeviceInfoVector_append(self, *args)

    def empty(self, *args):
        r"""empty(AudioDeviceInfoVector self) -> bool"""
        return _openshot.AudioDeviceInfoVector_empty(self, *args)

    def size(self, *args):
        r"""size(AudioDeviceInfoVector self) -> std::vector< openshot::AudioDeviceInfo >::size_type"""
        return _openshot.AudioDeviceInfoVector_size(self, *args)

    def swap(self, *args):
        r"""swap(AudioDeviceInfoVector self, AudioDeviceInfoVector v)"""
        return _openshot.AudioDeviceInfoVector_swap(self, *args)

    def begin(self, *args):
        r"""begin(AudioDeviceInfoVector self) -> std::vector< openshot::AudioDeviceInfo >::iterator"""
        return _openshot.AudioDeviceInfoVector_begin(self, *args)

    def end(self, *args):
        r"""end(AudioDeviceInfoVector self) -> std::vector< openshot::AudioDeviceInfo >::iterator"""
        return _openshot.AudioDeviceInfoVector_end(self, *args)

    def rbegin(self, *args):
        r"""rbegin(AudioDeviceInfoVector self) -> std::vector< openshot::AudioDeviceInfo >::reverse_iterator"""
        return _openshot.AudioDeviceInfoVector_rbegin(self, *args)

    def rend(self, *args):
        r"""rend(AudioDeviceInfoVector self) -> std::vector< openshot::AudioDeviceInfo >::reverse_iterator"""
        return _openshot.AudioDeviceInfoVector_rend(self, *args)

    def clear(self, *args):
        r"""clear(AudioDeviceInfoVector self)"""
        return _openshot.AudioDeviceInfoVector_clear(self, *args)

    def get_allocator(self, *args):
        r"""get_allocator(AudioDeviceInfoVector self) -> std::vector< openshot::AudioDeviceInfo >::allocator_type"""
        return _openshot.AudioDeviceInfoVector_get_allocator(self, *args)

    def pop_back(self, *args):
        r"""pop_back(AudioDeviceInfoVector self)"""
        return _openshot.AudioDeviceInfoVector_pop_back(self, *args)

    def erase(self, *args):
        r"""
        erase(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::iterator pos) -> std::vector< openshot::AudioDeviceInfo >::iterator
        erase(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::iterator first, std::vector< openshot::AudioDeviceInfo >::iterator last) -> std::vector< openshot::AudioDeviceInfo >::iterator
        """
        return _openshot.AudioDeviceInfoVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(AudioDeviceInfoVector self) -> AudioDeviceInfoVector
        __init__(AudioDeviceInfoVector self, AudioDeviceInfoVector other) -> AudioDeviceInfoVector
        __init__(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::size_type size) -> AudioDeviceInfoVector
        __init__(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::size_type size, AudioDeviceInfo value) -> AudioDeviceInfoVector
        """
        _openshot.AudioDeviceInfoVector_swiginit(self, _openshot.new_AudioDeviceInfoVector(*args))

    def push_back(self, *args):
        r"""push_back(AudioDeviceInfoVector self, AudioDeviceInfo x)"""
        return _openshot.AudioDeviceInfoVector_push_back(self, *args)

    def front(self, *args):
        r"""front(AudioDeviceInfoVector self) -> AudioDeviceInfo"""
        return _openshot.AudioDeviceInfoVector_front(self, *args)

    def back(self, *args):
        r"""back(AudioDeviceInfoVector self) -> AudioDeviceInfo"""
        return _openshot.AudioDeviceInfoVector_back(self, *args)

    def assign(self, *args):
        r"""assign(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::size_type n, AudioDeviceInfo x)"""
        return _openshot.AudioDeviceInfoVector_assign(self, *args)

    def resize(self, *args):
        r"""
        resize(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::size_type new_size)
        resize(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::size_type new_size, AudioDeviceInfo x)
        """
        return _openshot.AudioDeviceInfoVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::iterator pos, AudioDeviceInfo x) -> std::vector< openshot::AudioDeviceInfo >::iterator
        insert(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::iterator pos, std::vector< openshot::AudioDeviceInfo >::size_type n, AudioDeviceInfo x)
        """
        return _openshot.AudioDeviceInfoVector_insert(self, *args)

    def reserve(self, *args):
        r"""reserve(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::size_type n)"""
        return _openshot.AudioDeviceInfoVector_reserve(self, *args)

    def capacity(self, *args):
        r"""capacity(AudioDeviceInfoVector self) -> std::vector< openshot::AudioDeviceInfo >::size_type"""
        return _openshot.AudioDeviceInfoVector_capacity(self, *args)
    __swig_destroy__ = _openshot.delete_AudioDeviceInfoVector

# Register AudioDeviceInfoVector in _openshot:
_openshot.AudioDeviceInfoVector_swigregister(AudioDeviceInfoVector)
OPENSHOT_VERSION_ALL = _openshot.OPENSHOT_VERSION_ALL

OPENSHOT_VERSION_FULL = _openshot.OPENSHOT_VERSION_FULL

OPENSHOT_VERSION_MAJOR_MINOR = _openshot.OPENSHOT_VERSION_MAJOR_MINOR

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

QT_VERSION_STR = _openshot.QT_VERSION_STR

AVCODEC_VERSION_STR = _openshot.AVCODEC_VERSION_STR

AVFORMAT_VERSION_STR = _openshot.AVFORMAT_VERSION_STR

AVUTIL_VERSION_STR = _openshot.AVUTIL_VERSION_STR

HAVE_BABL = _openshot.HAVE_BABL

HAVE_IMAGEMAGICK = _openshot.HAVE_IMAGEMAGICK

HAVE_RESVG = _openshot.HAVE_RESVG

HAVE_OPENCV = _openshot.HAVE_OPENCV

FFMPEG_USE_SWRESAMPLE = _openshot.FFMPEG_USE_SWRESAMPLE

APPIMAGE_BUILD = _openshot.APPIMAGE_BUILD

class OpenShotVersion(object):
    r"""Proxy of C++ openshot::OpenShotVersion class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    Major = _openshot.OpenShotVersion_Major
    
    Minor = _openshot.OpenShotVersion_Minor
    
    Build = _openshot.OpenShotVersion_Build
    
    So = _openshot.OpenShotVersion_So
    

    @staticmethod
    def ToString(*args):
        r"""ToString() -> std::string"""
        return _openshot.OpenShotVersion_ToString(*args)

    def __str__(self, *args):
        r"""__str__(OpenShotVersion self) -> std::string const"""
        return _openshot.OpenShotVersion___str__(self, *args)

    def __repr__(self, *args):
        r"""__repr__(OpenShotVersion self) -> std::string const"""
        return _openshot.OpenShotVersion___repr__(self, *args)

    def __init__(self, *args):
        r"""__init__(OpenShotVersion self) -> OpenShotVersion"""
        _openshot.OpenShotVersion_swiginit(self, _openshot.new_OpenShotVersion(*args))
    __swig_destroy__ = _openshot.delete_OpenShotVersion

# Register OpenShotVersion in _openshot:
_openshot.OpenShotVersion_swigregister(OpenShotVersion)

def GetVersion(*args):
    r"""GetVersion() -> OpenShotVersion"""
    return _openshot.GetVersion(*args)
class ReaderInfo(object):
    r"""Proxy of C++ openshot::ReaderInfo class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    has_video = property(_openshot.ReaderInfo_has_video_get, _openshot.ReaderInfo_has_video_set, doc=r"""has_video : bool""")
    has_audio = property(_openshot.ReaderInfo_has_audio_get, _openshot.ReaderInfo_has_audio_set, doc=r"""has_audio : bool""")
    has_single_image = property(_openshot.ReaderInfo_has_single_image_get, _openshot.ReaderInfo_has_single_image_set, doc=r"""has_single_image : bool""")
    duration = property(_openshot.ReaderInfo_duration_get, _openshot.ReaderInfo_duration_set, doc=r"""duration : float""")
    file_size = property(_openshot.ReaderInfo_file_size_get, _openshot.ReaderInfo_file_size_set, doc=r"""file_size : int64_t""")
    height = property(_openshot.ReaderInfo_height_get, _openshot.ReaderInfo_height_set, doc=r"""height : int""")
    width = property(_openshot.ReaderInfo_width_get, _openshot.ReaderInfo_width_set, doc=r"""width : int""")
    pixel_format = property(_openshot.ReaderInfo_pixel_format_get, _openshot.ReaderInfo_pixel_format_set, doc=r"""pixel_format : int""")
    fps = property(_openshot.ReaderInfo_fps_get, _openshot.ReaderInfo_fps_set, doc=r"""fps : openshot::Fraction""")
    video_bit_rate = property(_openshot.ReaderInfo_video_bit_rate_get, _openshot.ReaderInfo_video_bit_rate_set, doc=r"""video_bit_rate : int""")
    pixel_ratio = property(_openshot.ReaderInfo_pixel_ratio_get, _openshot.ReaderInfo_pixel_ratio_set, doc=r"""pixel_ratio : openshot::Fraction""")
    display_ratio = property(_openshot.ReaderInfo_display_ratio_get, _openshot.ReaderInfo_display_ratio_set, doc=r"""display_ratio : openshot::Fraction""")
    vcodec = property(_openshot.ReaderInfo_vcodec_get, _openshot.ReaderInfo_vcodec_set, doc=r"""vcodec : std::string""")
    video_length = property(_openshot.ReaderInfo_video_length_get, _openshot.ReaderInfo_video_length_set, doc=r"""video_length : int64_t""")
    video_stream_index = property(_openshot.ReaderInfo_video_stream_index_get, _openshot.ReaderInfo_video_stream_index_set, doc=r"""video_stream_index : int""")
    video_timebase = property(_openshot.ReaderInfo_video_timebase_get, _openshot.ReaderInfo_video_timebase_set, doc=r"""video_timebase : openshot::Fraction""")
    interlaced_frame = property(_openshot.ReaderInfo_interlaced_frame_get, _openshot.ReaderInfo_interlaced_frame_set, doc=r"""interlaced_frame : bool""")
    top_field_first = property(_openshot.ReaderInfo_top_field_first_get, _openshot.ReaderInfo_top_field_first_set, doc=r"""top_field_first : bool""")
    acodec = property(_openshot.ReaderInfo_acodec_get, _openshot.ReaderInfo_acodec_set, doc=r"""acodec : std::string""")
    audio_bit_rate = property(_openshot.ReaderInfo_audio_bit_rate_get, _openshot.ReaderInfo_audio_bit_rate_set, doc=r"""audio_bit_rate : int""")
    sample_rate = property(_openshot.ReaderInfo_sample_rate_get, _openshot.ReaderInfo_sample_rate_set, doc=r"""sample_rate : int""")
    channels = property(_openshot.ReaderInfo_channels_get, _openshot.ReaderInfo_channels_set, doc=r"""channels : int""")
    channel_layout = property(_openshot.ReaderInfo_channel_layout_get, _openshot.ReaderInfo_channel_layout_set, doc=r"""channel_layout : openshot::ChannelLayout""")
    audio_stream_index = property(_openshot.ReaderInfo_audio_stream_index_get, _openshot.ReaderInfo_audio_stream_index_set, doc=r"""audio_stream_index : int""")
    audio_timebase = property(_openshot.ReaderInfo_audio_timebase_get, _openshot.ReaderInfo_audio_timebase_set, doc=r"""audio_timebase : openshot::Fraction""")
    metadata = property(_openshot.ReaderInfo_metadata_get, _openshot.ReaderInfo_metadata_set, doc=r"""metadata : std::map<(std::string,std::string,std::less<(std::string)>,std::allocator<(std::pair<(q(const).std::string,std::string)>)>)>""")

    def __init__(self, *args):
        r"""__init__(ReaderInfo self) -> ReaderInfo"""
        _openshot.ReaderInfo_swiginit(self, _openshot.new_ReaderInfo(*args))
    __swig_destroy__ = _openshot.delete_ReaderInfo

# Register ReaderInfo in _openshot:
_openshot.ReaderInfo_swigregister(ReaderInfo)
cvar = _openshot.cvar
Version = cvar.Version

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    info = property(_openshot.ReaderBase_info_get, _openshot.ReaderBase_info_set, doc=r"""info : openshot::ReaderInfo""")

    def ParentClip(self, *args):
        r"""
        ParentClip(ReaderBase self) -> ClipBase
        ParentClip(ReaderBase self, ClipBase new_clip)
        """
        return _openshot.ReaderBase_ParentClip(self, *args)

    def SetMaxDecodeSize(self, *args):
        r"""SetMaxDecodeSize(ReaderBase self, int width, int height)"""
        return _openshot.ReaderBase_SetMaxDecodeSize(self, *args)

    def MaxDecodeWidth(self, *args):
        r"""MaxDecodeWidth(ReaderBase self) -> int"""
        return _openshot.ReaderBase_MaxDecodeWidth(self, *args)

    def MaxDecodeHeight(self, *args):
        r"""MaxDecodeHeight(ReaderBase self) -> int"""
        return _openshot.ReaderBase_MaxDecodeHeight(self, *args)

    def HasMaxDecodeSize(self, *args):
        r"""HasMaxDecodeSize(ReaderBase self) -> bool"""
        return _openshot.ReaderBase_HasMaxDecodeSize(self, *args)

    def Close(self, *args):
        r"""Close(ReaderBase self)"""
        return _openshot.ReaderBase_Close(self, *args)

    def DisplayInfo(self, *args):
        r"""DisplayInfo(ReaderBase self, std::ostream * out=&std::cout)"""
        return _openshot.ReaderBase_DisplayInfo(self, *args)

    def GetCache(self, *args):
        r"""GetCache(ReaderBase self) -> CacheBase"""
        return _openshot.ReaderBase_GetCache(self, *args)

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

    def IsOpen(self, *args):
        r"""IsOpen(ReaderBase self) -> bool"""
        return _openshot.ReaderBase_IsOpen(self, *args)

    def HardwareDecodeSuccessful(self, *args):
        r"""HardwareDecodeSuccessful(ReaderBase self) -> bool"""
        return _openshot.ReaderBase_HardwareDecodeSuccessful(self, *args)

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

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

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

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

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

    def Open(self, *args):
        r"""Open(ReaderBase self)"""
        return _openshot.ReaderBase_Open(self, *args)
    __swig_destroy__ = _openshot.delete_ReaderBase

# Register ReaderBase in _openshot:
_openshot.ReaderBase_swigregister(ReaderBase)
class WriterInfo(object):
    r"""Proxy of C++ openshot::WriterInfo class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    has_video = property(_openshot.WriterInfo_has_video_get, _openshot.WriterInfo_has_video_set, doc=r"""has_video : bool""")
    has_audio = property(_openshot.WriterInfo_has_audio_get, _openshot.WriterInfo_has_audio_set, doc=r"""has_audio : bool""")
    has_single_image = property(_openshot.WriterInfo_has_single_image_get, _openshot.WriterInfo_has_single_image_set, doc=r"""has_single_image : bool""")
    duration = property(_openshot.WriterInfo_duration_get, _openshot.WriterInfo_duration_set, doc=r"""duration : float""")
    file_size = property(_openshot.WriterInfo_file_size_get, _openshot.WriterInfo_file_size_set, doc=r"""file_size : int64_t""")
    height = property(_openshot.WriterInfo_height_get, _openshot.WriterInfo_height_set, doc=r"""height : int""")
    width = property(_openshot.WriterInfo_width_get, _openshot.WriterInfo_width_set, doc=r"""width : int""")
    pixel_format = property(_openshot.WriterInfo_pixel_format_get, _openshot.WriterInfo_pixel_format_set, doc=r"""pixel_format : int""")
    fps = property(_openshot.WriterInfo_fps_get, _openshot.WriterInfo_fps_set, doc=r"""fps : openshot::Fraction""")
    video_bit_rate = property(_openshot.WriterInfo_video_bit_rate_get, _openshot.WriterInfo_video_bit_rate_set, doc=r"""video_bit_rate : int""")
    pixel_ratio = property(_openshot.WriterInfo_pixel_ratio_get, _openshot.WriterInfo_pixel_ratio_set, doc=r"""pixel_ratio : openshot::Fraction""")
    display_ratio = property(_openshot.WriterInfo_display_ratio_get, _openshot.WriterInfo_display_ratio_set, doc=r"""display_ratio : openshot::Fraction""")
    vcodec = property(_openshot.WriterInfo_vcodec_get, _openshot.WriterInfo_vcodec_set, doc=r"""vcodec : std::string""")
    video_length = property(_openshot.WriterInfo_video_length_get, _openshot.WriterInfo_video_length_set, doc=r"""video_length : int64_t""")
    video_stream_index = property(_openshot.WriterInfo_video_stream_index_get, _openshot.WriterInfo_video_stream_index_set, doc=r"""video_stream_index : int""")
    video_timebase = property(_openshot.WriterInfo_video_timebase_get, _openshot.WriterInfo_video_timebase_set, doc=r"""video_timebase : openshot::Fraction""")
    interlaced_frame = property(_openshot.WriterInfo_interlaced_frame_get, _openshot.WriterInfo_interlaced_frame_set, doc=r"""interlaced_frame : bool""")
    top_field_first = property(_openshot.WriterInfo_top_field_first_get, _openshot.WriterInfo_top_field_first_set, doc=r"""top_field_first : bool""")
    acodec = property(_openshot.WriterInfo_acodec_get, _openshot.WriterInfo_acodec_set, doc=r"""acodec : std::string""")
    audio_bit_rate = property(_openshot.WriterInfo_audio_bit_rate_get, _openshot.WriterInfo_audio_bit_rate_set, doc=r"""audio_bit_rate : int""")
    sample_rate = property(_openshot.WriterInfo_sample_rate_get, _openshot.WriterInfo_sample_rate_set, doc=r"""sample_rate : int""")
    channels = property(_openshot.WriterInfo_channels_get, _openshot.WriterInfo_channels_set, doc=r"""channels : int""")
    channel_layout = property(_openshot.WriterInfo_channel_layout_get, _openshot.WriterInfo_channel_layout_set, doc=r"""channel_layout : openshot::ChannelLayout""")
    audio_stream_index = property(_openshot.WriterInfo_audio_stream_index_get, _openshot.WriterInfo_audio_stream_index_set, doc=r"""audio_stream_index : int""")
    audio_timebase = property(_openshot.WriterInfo_audio_timebase_get, _openshot.WriterInfo_audio_timebase_set, doc=r"""audio_timebase : openshot::Fraction""")
    metadata = property(_openshot.WriterInfo_metadata_get, _openshot.WriterInfo_metadata_set, doc=r"""metadata : std::map<(std::string,std::string,std::less<(std::string)>,std::allocator<(std::pair<(q(const).std::string,std::string)>)>)>""")

    def __init__(self, *args):
        r"""__init__(WriterInfo self) -> WriterInfo"""
        _openshot.WriterInfo_swiginit(self, _openshot.new_WriterInfo(*args))
    __swig_destroy__ = _openshot.delete_WriterInfo

# Register WriterInfo in _openshot:
_openshot.WriterInfo_swigregister(WriterInfo)
class WriterBase(object):
    r"""Proxy of C++ openshot::WriterBase class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    info = property(_openshot.WriterBase_info_get, _openshot.WriterBase_info_set, doc=r"""info : openshot::WriterInfo""")

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

    def IsOpen(self, *args):
        r"""IsOpen(WriterBase self) -> bool"""
        return _openshot.WriterBase_IsOpen(self, *args)

    def WriteFrame(self, *args):
        r"""
        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, *args):
        r"""Json(WriterBase self) -> std::string"""
        return _openshot.WriterBase_Json(self, *args)

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

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

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

    def DisplayInfo(self, *args):
        r"""DisplayInfo(WriterBase self, std::ostream * out=&std::cout)"""
        return _openshot.WriterBase_DisplayInfo(self, *args)

    def Open(self, *args):
        r"""Open(WriterBase self)"""
        return _openshot.WriterBase_Open(self, *args)
    __swig_destroy__ = _openshot.delete_WriterBase

# Register WriterBase in _openshot:
_openshot.WriterBase_swigregister(WriterBase)
class AudioDeviceInfo(object):
    r"""Proxy of C++ openshot::AudioDeviceInfo class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    type = property(_openshot.AudioDeviceInfo_type_get, _openshot.AudioDeviceInfo_type_set, doc=r"""type : juce::String""")
    name = property(_openshot.AudioDeviceInfo_name_get, _openshot.AudioDeviceInfo_name_set, doc=r"""name : juce::String""")

    def get_type(self, *args):
        r"""get_type(AudioDeviceInfo self) -> std::string"""
        return _openshot.AudioDeviceInfo_get_type(self, *args)

    def get_name(self, *args):
        r"""get_name(AudioDeviceInfo self) -> std::string"""
        return _openshot.AudioDeviceInfo_get_name(self, *args)

    def __init__(self, *args):
        r"""__init__(AudioDeviceInfo self) -> AudioDeviceInfo"""
        _openshot.AudioDeviceInfo_swiginit(self, _openshot.new_AudioDeviceInfo(*args))
    __swig_destroy__ = _openshot.delete_AudioDeviceInfo

# Register AudioDeviceInfo in _openshot:
_openshot.AudioDeviceInfo_swigregister(AudioDeviceInfo)
class AudioDevices(object):
    r"""Proxy of C++ openshot::AudioDevices class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(AudioDevices self) -> AudioDevices"""
        _openshot.AudioDevices_swiginit(self, _openshot.new_AudioDevices(*args))

    def getNames(self, *args):
        r"""getNames(AudioDevices self) -> openshot::AudioDeviceList"""
        return _openshot.AudioDevices_getNames(self, *args)
    __swig_destroy__ = _openshot.delete_AudioDevices

# Register AudioDevices in _openshot:
_openshot.AudioDevices_swigregister(AudioDevices)
class AudioWaveformData(object):
    r"""Proxy of C++ openshot::AudioWaveformData class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    max_samples = property(_openshot.AudioWaveformData_max_samples_get, _openshot.AudioWaveformData_max_samples_set, doc=r"""max_samples : std::vector<(float,std::allocator<(float)>)>""")
    rms_samples = property(_openshot.AudioWaveformData_rms_samples_get, _openshot.AudioWaveformData_rms_samples_set, doc=r"""rms_samples : std::vector<(float,std::allocator<(float)>)>""")

    def resize(self, *args):
        r"""resize(AudioWaveformData self, int total_samples)"""
        return _openshot.AudioWaveformData_resize(self, *args)

    def zero(self, *args):
        r"""zero(AudioWaveformData self, int total_samples)"""
        return _openshot.AudioWaveformData_zero(self, *args)

    def scale(self, *args):
        r"""scale(AudioWaveformData self, int total_samples, float factor)"""
        return _openshot.AudioWaveformData_scale(self, *args)

    def clear(self, *args):
        r"""clear(AudioWaveformData self)"""
        return _openshot.AudioWaveformData_clear(self, *args)

    def vectors(self, *args):
        r"""vectors(AudioWaveformData self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _openshot.AudioWaveformData_vectors(self, *args)

    def __init__(self, *args):
        r"""__init__(AudioWaveformData self) -> AudioWaveformData"""
        _openshot.AudioWaveformData_swiginit(self, _openshot.new_AudioWaveformData(*args))
    __swig_destroy__ = _openshot.delete_AudioWaveformData

# Register AudioWaveformData in _openshot:
_openshot.AudioWaveformData_swigregister(AudioWaveformData)
class AudioWaveformer(object):
    r"""Proxy of C++ openshot::AudioWaveformer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(AudioWaveformer self, ReaderBase reader) -> AudioWaveformer"""
        _openshot.AudioWaveformer_swiginit(self, _openshot.new_AudioWaveformer(*args))

    def ApplyKeyframes(self, *args):
        r"""ApplyKeyframes(AudioWaveformer self, AudioWaveformData base, Keyframe time_keyframe, Keyframe volume_keyframe, Fraction project_fps, Fraction source_fps, int source_channels, int num_per_second, int channel, bool normalize) -> AudioWaveformData"""
        return _openshot.AudioWaveformer_ApplyKeyframes(self, *args)

    def ExtractSamples(self, *args):
        r"""
        ExtractSamples(AudioWaveformer self, int channel, int num_per_second, bool normalize) -> AudioWaveformData
        ExtractSamples(AudioWaveformer self, std::string const & path, int channel, int num_per_second, bool normalize) -> AudioWaveformData
        ExtractSamples(AudioWaveformer self, std::string const & path, Keyframe time_keyframe, Keyframe volume_keyframe, Fraction project_fps, int channel, int num_per_second, bool normalize) -> AudioWaveformData
        """
        return _openshot.AudioWaveformer_ExtractSamples(self, *args)
    __swig_destroy__ = _openshot.delete_AudioWaveformer

# Register AudioWaveformer in _openshot:
_openshot.AudioWaveformer_swigregister(AudioWaveformer)
class CacheBase(object):
    r"""Proxy of C++ openshot::CacheBase class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

    def Clear(self, *args):
        r"""Clear(CacheBase self)"""
        return _openshot.CacheBase_Clear(self, *args)

    def Contains(self, *args):
        r"""Contains(CacheBase self, int64_t frame_number) -> bool"""
        return _openshot.CacheBase_Contains(self, *args)

    def Count(self, *args):
        r"""Count(CacheBase self) -> int64_t"""
        return _openshot.CacheBase_Count(self, *args)

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

    def GetFrames(self, *args):
        r"""GetFrames(CacheBase self) -> std::vector< std::shared_ptr< openshot::Frame >,std::allocator< std::shared_ptr< openshot::Frame > > >"""
        return _openshot.CacheBase_GetFrames(self, *args)

    def GetBytes(self, *args):
        r"""GetBytes(CacheBase self) -> int64_t"""
        return _openshot.CacheBase_GetBytes(self, *args)

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

    def Remove(self, *args):
        r"""
        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 Touch(self, *args):
        r"""Touch(CacheBase self, int64_t frame_number)"""
        return _openshot.CacheBase_Touch(self, *args)

    def GetMaxBytes(self, *args):
        r"""GetMaxBytes(CacheBase self) -> int64_t"""
        return _openshot.CacheBase_GetMaxBytes(self, *args)

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

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

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

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

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

    def SetJsonValue(self, *args):
        r"""SetJsonValue(CacheBase self, Json::Value const root)"""
        return _openshot.CacheBase_SetJsonValue(self, *args)
    __swig_destroy__ = _openshot.delete_CacheBase

# Register CacheBase in _openshot:
_openshot.CacheBase_swigregister(CacheBase)
class CacheDisk(CacheBase):
    r"""Proxy of C++ openshot::CacheDisk class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(CacheDisk self, std::string cache_path, std::string format, float quality, float scale) -> CacheDisk
        __init__(CacheDisk self, std::string cache_path, std::string format, float quality, float scale, int64_t max_bytes) -> CacheDisk
        """
        _openshot.CacheDisk_swiginit(self, _openshot.new_CacheDisk(*args))
    __swig_destroy__ = _openshot.delete_CacheDisk

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

    def Clear(self, *args):
        r"""Clear(CacheDisk self)"""
        return _openshot.CacheDisk_Clear(self, *args)

    def Contains(self, *args):
        r"""Contains(CacheDisk self, int64_t frame_number) -> bool"""
        return _openshot.CacheDisk_Contains(self, *args)

    def Count(self, *args):
        r"""Count(CacheDisk self) -> int64_t"""
        return _openshot.CacheDisk_Count(self, *args)

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

    def GetFrames(self, *args):
        r"""GetFrames(CacheDisk self) -> std::vector< std::shared_ptr< openshot::Frame >,std::allocator< std::shared_ptr< openshot::Frame > > >"""
        return _openshot.CacheDisk_GetFrames(self, *args)

    def GetBytes(self, *args):
        r"""GetBytes(CacheDisk self) -> int64_t"""
        return _openshot.CacheDisk_GetBytes(self, *args)

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

    def Touch(self, *args):
        r"""Touch(CacheDisk self, int64_t frame_number)"""
        return _openshot.CacheDisk_Touch(self, *args)

    def Remove(self, *args):
        r"""
        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, *args):
        r"""Json(CacheDisk self) -> std::string"""
        return _openshot.CacheDisk_Json(self, *args)

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

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

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

# Register CacheDisk in _openshot:
_openshot.CacheDisk_swigregister(CacheDisk)
class CacheMemory(CacheBase):
    r"""Proxy of C++ openshot::CacheMemory class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(CacheMemory self) -> CacheMemory
        __init__(CacheMemory self, int64_t max_bytes) -> CacheMemory
        """
        _openshot.CacheMemory_swiginit(self, _openshot.new_CacheMemory(*args))
    __swig_destroy__ = _openshot.delete_CacheMemory

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

    def Clear(self, *args):
        r"""Clear(CacheMemory self)"""
        return _openshot.CacheMemory_Clear(self, *args)

    def Contains(self, *args):
        r"""Contains(CacheMemory self, int64_t frame_number) -> bool"""
        return _openshot.CacheMemory_Contains(self, *args)

    def Count(self, *args):
        r"""Count(CacheMemory self) -> int64_t"""
        return _openshot.CacheMemory_Count(self, *args)

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

    def GetFrames(self, *args):
        r"""GetFrames(CacheMemory self) -> std::vector< std::shared_ptr< openshot::Frame >,std::allocator< std::shared_ptr< openshot::Frame > > >"""
        return _openshot.CacheMemory_GetFrames(self, *args)

    def GetBytes(self, *args):
        r"""GetBytes(CacheMemory self) -> int64_t"""
        return _openshot.CacheMemory_GetBytes(self, *args)

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

    def Touch(self, *args):
        r"""Touch(CacheMemory self, int64_t frame_number)"""
        return _openshot.CacheMemory_Touch(self, *args)

    def Remove(self, *args):
        r"""
        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, *args):
        r"""Json(CacheMemory self) -> std::string"""
        return _openshot.CacheMemory_Json(self, *args)

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

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

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

# Register CacheMemory in _openshot:
_openshot.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):
    r"""Proxy of C++ openshot::ChunkLocation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    number = property(_openshot.ChunkLocation_number_get, _openshot.ChunkLocation_number_set, doc=r"""number : int64_t""")
    frame = property(_openshot.ChunkLocation_frame_get, _openshot.ChunkLocation_frame_set, doc=r"""frame : int64_t""")

    def __init__(self, *args):
        r"""__init__(ChunkLocation self) -> ChunkLocation"""
        _openshot.ChunkLocation_swiginit(self, _openshot.new_ChunkLocation(*args))
    __swig_destroy__ = _openshot.delete_ChunkLocation

# Register ChunkLocation in _openshot:
_openshot.ChunkLocation_swigregister(ChunkLocation)
THUMBNAIL = _openshot.THUMBNAIL

PREVIEW = _openshot.PREVIEW

FINAL = _openshot.FINAL

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(ChunkReader self, std::string path, openshot::ChunkVersion chunk_version) -> ChunkReader"""
        _openshot.ChunkReader_swiginit(self, _openshot.new_ChunkReader(*args))

    def Close(self, *args):
        r"""Close(ChunkReader self)"""
        return _openshot.ChunkReader_Close(self, *args)

    def GetChunkSize(self, *args):
        r"""GetChunkSize(ChunkReader self) -> int64_t"""
        return _openshot.ChunkReader_GetChunkSize(self, *args)

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

    def GetCache(self, *args):
        r"""GetCache(ChunkReader self) -> CacheBase"""
        return _openshot.ChunkReader_GetCache(self, *args)

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

    def IsOpen(self, *args):
        r"""IsOpen(ChunkReader self) -> bool"""
        return _openshot.ChunkReader_IsOpen(self, *args)

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

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

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

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

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

    def Open(self, *args):
        r"""Open(ChunkReader self)"""
        return _openshot.ChunkReader_Open(self, *args)
    __swig_destroy__ = _openshot.delete_ChunkReader

# Register ChunkReader in _openshot:
_openshot.ChunkReader_swigregister(ChunkReader)
class ChunkWriter(WriterBase):
    r"""Proxy of C++ openshot::ChunkWriter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(ChunkWriter self, std::string path, ReaderBase reader) -> ChunkWriter"""
        _openshot.ChunkWriter_swiginit(self, _openshot.new_ChunkWriter(*args))

    def Close(self, *args):
        r"""Close(ChunkWriter self)"""
        return _openshot.ChunkWriter_Close(self, *args)

    def GetChunkSize(self, *args):
        r"""GetChunkSize(ChunkWriter self) -> int64_t"""
        return _openshot.ChunkWriter_GetChunkSize(self, *args)

    def IsOpen(self, *args):
        r"""IsOpen(ChunkWriter self) -> bool"""
        return _openshot.ChunkWriter_IsOpen(self, *args)

    def Open(self, *args):
        r"""Open(ChunkWriter self)"""
        return _openshot.ChunkWriter_Open(self, *args)

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

    def WriteFrame(self, *args):
        r"""
        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

# Register ChunkWriter in _openshot:
_openshot.ChunkWriter_swigregister(ChunkWriter)
class ClipBase(object):
    r"""Proxy of C++ openshot::ClipBase class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

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

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

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

    def GetFrame(self, *args):
        r"""
        GetFrame(ClipBase self, int64_t frame_number) -> std::shared_ptr< openshot::Frame >
        GetFrame(ClipBase self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >
        """
        return _openshot.ClipBase_GetFrame(self, *args)

    def Duration(self, *args):
        r"""Duration(ClipBase self) -> float"""
        return _openshot.ClipBase_Duration(self, *args)

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

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

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

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

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

    def ParentTimeline(self, *args):
        r"""
        ParentTimeline(ClipBase self) -> TimelineBase
        ParentTimeline(ClipBase self, TimelineBase new_timeline)
        """
        return _openshot.ClipBase_ParentTimeline(self, *args)

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

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

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

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

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(ClipBase self, int64_t requested_frame) -> std::string"""
        return _openshot.ClipBase_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_ClipBase

# Register ClipBase in _openshot:
_openshot.ClipBase_swigregister(ClipBase)
class CompareClipEffects(object):
    r"""Proxy of C++ openshot::CompareClipEffects class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

    def __init__(self, *args):
        r"""__init__(CompareClipEffects self) -> CompareClipEffects"""
        _openshot.CompareClipEffects_swiginit(self, _openshot.new_CompareClipEffects(*args))
    __swig_destroy__ = _openshot.delete_CompareClipEffects

# Register CompareClipEffects in _openshot:
_openshot.CompareClipEffects_swigregister(CompareClipEffects)
class Clip(ClipBase, ReaderBase):
    r"""Proxy of C++ openshot::Clip class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    gravity = property(_openshot.Clip_gravity_get, _openshot.Clip_gravity_set, doc=r"""gravity : openshot::GravityType""")
    scale = property(_openshot.Clip_scale_get, _openshot.Clip_scale_set, doc=r"""scale : openshot::ScaleType""")
    anchor = property(_openshot.Clip_anchor_get, _openshot.Clip_anchor_set, doc=r"""anchor : openshot::AnchorType""")
    display = property(_openshot.Clip_display_get, _openshot.Clip_display_set, doc=r"""display : openshot::FrameDisplayType""")
    mixing = property(_openshot.Clip_mixing_get, _openshot.Clip_mixing_set, doc=r"""mixing : openshot::VolumeMixType""")
    composite = property(_openshot.Clip_composite_get, _openshot.Clip_composite_set, doc=r"""composite : openshot::CompositeType""")
    COMPILED_WITH_CV = property(_openshot.Clip_COMPILED_WITH_CV_get, _openshot.Clip_COMPILED_WITH_CV_set, doc=r"""COMPILED_WITH_CV : bool""")

    @staticmethod
    def CreateReader(*args):
        r"""CreateReader(std::string path, bool inspect_reader=True) -> ReaderBase"""
        return _openshot.Clip_CreateReader(*args)

    def __init__(self, *args):
        r"""
        __init__(Clip self) -> Clip
        __init__(Clip self, std::string path) -> Clip
        __init__(Clip self, ReaderBase new_reader) -> Clip
        """
        _openshot.Clip_swiginit(self, _openshot.new_Clip(*args))
    __swig_destroy__ = _openshot.delete_Clip

    def GetCache(self, *args):
        r"""GetCache(Clip self) -> CacheMemory"""
        return _openshot.Clip_GetCache(self, *args)

    def IsOpen(self, *args):
        r"""IsOpen(Clip self) -> bool"""
        return _openshot.Clip_IsOpen(self, *args)

    def GetAttachedId(self, *args):
        r"""GetAttachedId(Clip self) -> std::string"""
        return _openshot.Clip_GetAttachedId(self, *args)

    def SetAttachedId(self, *args):
        r"""SetAttachedId(Clip self, std::string value)"""
        return _openshot.Clip_SetAttachedId(self, *args)

    def AttachToObject(self, *args):
        r"""AttachToObject(Clip self, std::string object_id)"""
        return _openshot.Clip_AttachToObject(self, *args)

    def SetAttachedObject(self, *args):
        r"""SetAttachedObject(Clip self, std::shared_ptr< openshot::TrackedObjectBase > trackedObject)"""
        return _openshot.Clip_SetAttachedObject(self, *args)

    def SetAttachedClip(self, *args):
        r"""SetAttachedClip(Clip self, Clip clipObject)"""
        return _openshot.Clip_SetAttachedClip(self, *args)

    def GetAttachedObject(self, *args):
        r"""GetAttachedObject(Clip self) -> std::shared_ptr< openshot::TrackedObjectBase >"""
        return _openshot.Clip_GetAttachedObject(self, *args)

    def GetAttachedClip(self, *args):
        r"""GetAttachedClip(Clip self) -> Clip"""
        return _openshot.Clip_GetAttachedClip(self, *args)

    def Name(self, *args):
        r"""Name(Clip self) -> std::string"""
        return _openshot.Clip_Name(self, *args)

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

    def Close(self, *args):
        r"""Close(Clip self)"""
        return _openshot.Clip_Close(self, *args)

    def GetParentClip(self, *args):
        r"""GetParentClip(Clip self) -> Clip"""
        return _openshot.Clip_GetParentClip(self, *args)

    def GetParentTrackedObject(self, *args):
        r"""GetParentTrackedObject(Clip self) -> std::shared_ptr< openshot::TrackedObjectBase >"""
        return _openshot.Clip_GetParentTrackedObject(self, *args)

    def Effects(self, *args):
        r"""Effects(Clip self) -> EffectBaseList"""
        return _openshot.Clip_Effects(self, *args)

    def GetEffect(self, *args):
        r"""GetEffect(Clip self, std::string const & id) -> EffectBase"""
        return _openshot.Clip_GetEffect(self, *args)

    def GetFrame(self, *args):
        r"""
        GetFrame(Clip self, int64_t clip_frame_number) -> std::shared_ptr< openshot::Frame >
        GetFrame(Clip self, std::shared_ptr< openshot::Frame > background_frame, int64_t clip_frame_number) -> std::shared_ptr< openshot::Frame >
        GetFrame(Clip self, std::shared_ptr< openshot::Frame > background_frame, int64_t clip_frame_number, TimelineInfoStruct options) -> std::shared_ptr< openshot::Frame >
        """
        return _openshot.Clip_GetFrame(self, *args)

    def Open(self, *args):
        r"""Open(Clip self)"""
        return _openshot.Clip_Open(self, *args)

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

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

    def ParentTimeline(self, *args):
        r"""
        ParentTimeline(Clip self) -> TimelineBase
        ParentTimeline(Clip self, TimelineBase new_timeline)
        """
        return _openshot.Clip_ParentTimeline(self, *args)

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

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

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

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

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

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

    def Waveform(self, *args):
        r"""
        Waveform(Clip self) -> bool
        Waveform(Clip self, bool value)
        """
        return _openshot.Clip_Waveform(self, *args)
    scale_x = property(_openshot.Clip_scale_x_get, _openshot.Clip_scale_x_set, doc=r"""scale_x : openshot::Keyframe""")
    scale_y = property(_openshot.Clip_scale_y_get, _openshot.Clip_scale_y_set, doc=r"""scale_y : openshot::Keyframe""")
    location_x = property(_openshot.Clip_location_x_get, _openshot.Clip_location_x_set, doc=r"""location_x : openshot::Keyframe""")
    location_y = property(_openshot.Clip_location_y_get, _openshot.Clip_location_y_set, doc=r"""location_y : openshot::Keyframe""")
    alpha = property(_openshot.Clip_alpha_get, _openshot.Clip_alpha_set, doc=r"""alpha : openshot::Keyframe""")
    rotation = property(_openshot.Clip_rotation_get, _openshot.Clip_rotation_set, doc=r"""rotation : openshot::Keyframe""")
    shear_x = property(_openshot.Clip_shear_x_get, _openshot.Clip_shear_x_set, doc=r"""shear_x : openshot::Keyframe""")
    shear_y = property(_openshot.Clip_shear_y_get, _openshot.Clip_shear_y_set, doc=r"""shear_y : openshot::Keyframe""")
    origin_x = property(_openshot.Clip_origin_x_get, _openshot.Clip_origin_x_set, doc=r"""origin_x : openshot::Keyframe""")
    origin_y = property(_openshot.Clip_origin_y_get, _openshot.Clip_origin_y_set, doc=r"""origin_y : openshot::Keyframe""")
    time = property(_openshot.Clip_time_get, _openshot.Clip_time_set, doc=r"""time : openshot::Keyframe""")
    volume = property(_openshot.Clip_volume_get, _openshot.Clip_volume_set, doc=r"""volume : openshot::Keyframe""")
    wave_color = property(_openshot.Clip_wave_color_get, _openshot.Clip_wave_color_set, doc=r"""wave_color : openshot::Color""")
    perspective_c1_x = property(_openshot.Clip_perspective_c1_x_get, _openshot.Clip_perspective_c1_x_set, doc=r"""perspective_c1_x : openshot::Keyframe""")
    perspective_c1_y = property(_openshot.Clip_perspective_c1_y_get, _openshot.Clip_perspective_c1_y_set, doc=r"""perspective_c1_y : openshot::Keyframe""")
    perspective_c2_x = property(_openshot.Clip_perspective_c2_x_get, _openshot.Clip_perspective_c2_x_set, doc=r"""perspective_c2_x : openshot::Keyframe""")
    perspective_c2_y = property(_openshot.Clip_perspective_c2_y_get, _openshot.Clip_perspective_c2_y_set, doc=r"""perspective_c2_y : openshot::Keyframe""")
    perspective_c3_x = property(_openshot.Clip_perspective_c3_x_get, _openshot.Clip_perspective_c3_x_set, doc=r"""perspective_c3_x : openshot::Keyframe""")
    perspective_c3_y = property(_openshot.Clip_perspective_c3_y_get, _openshot.Clip_perspective_c3_y_set, doc=r"""perspective_c3_y : openshot::Keyframe""")
    perspective_c4_x = property(_openshot.Clip_perspective_c4_x_get, _openshot.Clip_perspective_c4_x_set, doc=r"""perspective_c4_x : openshot::Keyframe""")
    perspective_c4_y = property(_openshot.Clip_perspective_c4_y_get, _openshot.Clip_perspective_c4_y_set, doc=r"""perspective_c4_y : openshot::Keyframe""")
    channel_filter = property(_openshot.Clip_channel_filter_get, _openshot.Clip_channel_filter_set, doc=r"""channel_filter : openshot::Keyframe""")
    channel_mapping = property(_openshot.Clip_channel_mapping_get, _openshot.Clip_channel_mapping_set, doc=r"""channel_mapping : openshot::Keyframe""")
    has_audio = property(_openshot.Clip_has_audio_get, _openshot.Clip_has_audio_set, doc=r"""has_audio : openshot::Keyframe""")
    has_video = property(_openshot.Clip_has_video_get, _openshot.Clip_has_video_set, doc=r"""has_video : openshot::Keyframe""")

# Register Clip in _openshot:
_openshot.Clip_swigregister(Clip)
class Coordinate(object):
    r"""Proxy of C++ openshot::Coordinate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    X = property(_openshot.Coordinate_X_get, _openshot.Coordinate_X_set, doc=r"""X : double""")
    Y = property(_openshot.Coordinate_Y_get, _openshot.Coordinate_Y_set, doc=r"""Y : double""")

    def __init__(self, *args):
        r"""
        __init__(Coordinate self) -> Coordinate
        __init__(Coordinate self, double x, double y) -> Coordinate
        __init__(Coordinate self, std::pair< double,double > const & co) -> Coordinate
        """
        _openshot.Coordinate_swiginit(self, _openshot.new_Coordinate(*args))

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

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

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

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Coordinate self, Json::Value const root)"""
        return _openshot.Coordinate_SetJsonValue(self, *args)
    __swig_destroy__ = _openshot.delete_Coordinate

# Register Coordinate in _openshot:
_openshot.Coordinate_swigregister(Coordinate)
class Color(object):
    r"""Proxy of C++ openshot::Color class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    red = property(_openshot.Color_red_get, _openshot.Color_red_set, doc=r"""red : openshot::Keyframe""")
    green = property(_openshot.Color_green_get, _openshot.Color_green_set, doc=r"""green : openshot::Keyframe""")
    blue = property(_openshot.Color_blue_get, _openshot.Color_blue_set, doc=r"""blue : openshot::Keyframe""")
    alpha = property(_openshot.Color_alpha_get, _openshot.Color_alpha_set, doc=r"""alpha : openshot::Keyframe""")

    def __init__(self, *args):
        r"""
        __init__(Color self) -> Color
        __init__(Color self, QColor arg2) -> Color
        __init__(Color self, std::string color_hex) -> Color
        __init__(Color self, char const * color_hex) -> Color
        __init__(Color self, unsigned char Red, unsigned char Green, unsigned char Blue, unsigned char Alpha) -> Color
        __init__(Color self, Keyframe Red, Keyframe Green, Keyframe Blue, Keyframe Alpha) -> Color
        """
        _openshot.Color_swiginit(self, _openshot.new_Color(*args))

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

    def GetColorRGBA(self, *args):
        r"""GetColorRGBA(Color self, int64_t frame_number) -> std::vector< int,std::allocator< int > >"""
        return _openshot.Color_GetColorRGBA(self, *args)

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

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

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

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

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Color self, Json::Value const root)"""
        return _openshot.Color_SetJsonValue(self, *args)
    __swig_destroy__ = _openshot.delete_Color

# Register Color in _openshot:
_openshot.Color_swigregister(Color)
class DummyReader(ReaderBase):
    r"""Proxy of C++ openshot::DummyReader class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(DummyReader self) -> DummyReader
        __init__(DummyReader self, Fraction fps, int width, int height, int sample_rate, int channels, float duration) -> DummyReader
        __init__(DummyReader self, Fraction fps, int width, int height, int sample_rate, int channels, float duration, CacheBase cache) -> DummyReader
        """
        _openshot.DummyReader_swiginit(self, _openshot.new_DummyReader(*args))
    __swig_destroy__ = _openshot.delete_DummyReader

    def Close(self, *args):
        r"""Close(DummyReader self)"""
        return _openshot.DummyReader_Close(self, *args)

    def GetCache(self, *args):
        r"""GetCache(DummyReader self) -> CacheMemory"""
        return _openshot.DummyReader_GetCache(self, *args)

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

    def IsOpen(self, *args):
        r"""IsOpen(DummyReader self) -> bool"""
        return _openshot.DummyReader_IsOpen(self, *args)

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

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

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

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

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

    def Open(self, *args):
        r"""Open(DummyReader self)"""
        return _openshot.DummyReader_Open(self, *args)

# Register DummyReader in _openshot:
_openshot.DummyReader_swigregister(DummyReader)
class EffectInfoStruct(object):
    r"""Proxy of C++ openshot::EffectInfoStruct class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    class_name = property(_openshot.EffectInfoStruct_class_name_get, _openshot.EffectInfoStruct_class_name_set, doc=r"""class_name : std::string""")
    name = property(_openshot.EffectInfoStruct_name_get, _openshot.EffectInfoStruct_name_set, doc=r"""name : std::string""")
    description = property(_openshot.EffectInfoStruct_description_get, _openshot.EffectInfoStruct_description_set, doc=r"""description : std::string""")
    parent_effect_id = property(_openshot.EffectInfoStruct_parent_effect_id_get, _openshot.EffectInfoStruct_parent_effect_id_set, doc=r"""parent_effect_id : std::string""")
    has_video = property(_openshot.EffectInfoStruct_has_video_get, _openshot.EffectInfoStruct_has_video_set, doc=r"""has_video : bool""")
    has_audio = property(_openshot.EffectInfoStruct_has_audio_get, _openshot.EffectInfoStruct_has_audio_set, doc=r"""has_audio : bool""")
    has_tracked_object = property(_openshot.EffectInfoStruct_has_tracked_object_get, _openshot.EffectInfoStruct_has_tracked_object_set, doc=r"""has_tracked_object : bool""")
    apply_before_clip = property(_openshot.EffectInfoStruct_apply_before_clip_get, _openshot.EffectInfoStruct_apply_before_clip_set, doc=r"""apply_before_clip : bool""")

    def __init__(self, *args):
        r"""__init__(EffectInfoStruct self) -> EffectInfoStruct"""
        _openshot.EffectInfoStruct_swiginit(self, _openshot.new_EffectInfoStruct(*args))
    __swig_destroy__ = _openshot.delete_EffectInfoStruct

# Register EffectInfoStruct in _openshot:
_openshot.EffectInfoStruct_swigregister(EffectInfoStruct)
class EffectBase(ClipBase):
    r"""Proxy of C++ openshot::EffectBase class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    parentEffect = property(_openshot.EffectBase_parentEffect_get, _openshot.EffectBase_parentEffect_set, doc=r"""parentEffect : p.openshot::EffectBase""")
    trackedObjects = property(_openshot.EffectBase_trackedObjects_get, _openshot.EffectBase_trackedObjects_set, doc=r"""trackedObjects : std::map<(int,std::shared_ptr<(openshot::TrackedObjectBase)>,std::less<(int)>,std::allocator<(std::pair<(q(const).int,std::shared_ptr<(openshot::TrackedObjectBase)>)>)>)>""")
    info = property(_openshot.EffectBase_info_get, _openshot.EffectBase_info_set, doc=r"""info : openshot::EffectInfoStruct""")
    mask_invert = property(_openshot.EffectBase_mask_invert_get, _openshot.EffectBase_mask_invert_set, doc=r"""mask_invert : bool""")
    MASK_TIME_TIMELINE = _openshot.EffectBase_MASK_TIME_TIMELINE
    
    MASK_TIME_SOURCE_FPS = _openshot.EffectBase_MASK_TIME_SOURCE_FPS
    
    MASK_LOOP_PLAY_ONCE = _openshot.EffectBase_MASK_LOOP_PLAY_ONCE
    
    MASK_LOOP_REPEAT = _openshot.EffectBase_MASK_LOOP_REPEAT
    
    MASK_LOOP_PING_PONG = _openshot.EffectBase_MASK_LOOP_PING_PONG
    
    mask_time_mode = property(_openshot.EffectBase_mask_time_mode_get, _openshot.EffectBase_mask_time_mode_set, doc=r"""mask_time_mode : int""")
    mask_loop_mode = property(_openshot.EffectBase_mask_loop_mode_get, _openshot.EffectBase_mask_loop_mode_set, doc=r"""mask_loop_mode : int""")

    def DisplayInfo(self, *args):
        r"""DisplayInfo(EffectBase self, std::ostream * out=&std::cout)"""
        return _openshot.EffectBase_DisplayInfo(self, *args)

    def constrain(self, *args):
        r"""constrain(EffectBase self, int color_value) -> int"""
        return _openshot.EffectBase_constrain(self, *args)

    def InitEffectInfo(self, *args):
        r"""InitEffectInfo(EffectBase self)"""
        return _openshot.EffectBase_InitEffectInfo(self, *args)

    def ParentClip(self, *args):
        r"""
        ParentClip(EffectBase self) -> ClipBase
        ParentClip(EffectBase self, ClipBase new_clip)
        """
        return _openshot.EffectBase_ParentClip(self, *args)

    def SetParentEffect(self, *args):
        r"""SetParentEffect(EffectBase self, std::string parentEffect_id)"""
        return _openshot.EffectBase_SetParentEffect(self, *args)

    def ParentClipId(self, *args):
        r"""ParentClipId(EffectBase self) -> std::string"""
        return _openshot.EffectBase_ParentClipId(self, *args)

    def GetVisibleObjects(self, *args):
        r"""GetVisibleObjects(EffectBase self, int64_t frame_number) -> std::string"""
        return _openshot.EffectBase_GetVisibleObjects(self, *args)

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

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

    def Json(self, *args):
        r"""
        Json(EffectBase self) -> std::string
        Json(EffectBase self, int64_t requested_frame) -> std::string
        """
        return _openshot.EffectBase_Json(self, *args)

    def SetJson(self, *args):
        r"""
        SetJson(EffectBase self, std::string const value)
        SetJson(EffectBase self, int64_t requested_frame, std::string const value)
        """
        return _openshot.EffectBase_SetJson(self, *args)

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

    def BasePropertiesJSON(self, *args):
        r"""BasePropertiesJSON(EffectBase self, int64_t requested_frame) -> Json::Value"""
        return _openshot.EffectBase_BasePropertiesJSON(self, *args)

    def ProcessFrame(self, *args):
        r"""ProcessFrame(EffectBase self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.EffectBase_ProcessFrame(self, *args)

    def MaskReader(self, *args):
        r"""
        MaskReader(EffectBase self) -> ReaderBase
        MaskReader(EffectBase self) -> ReaderBase
        MaskReader(EffectBase self, ReaderBase new_reader)
        """
        return _openshot.EffectBase_MaskReader(self, *args)

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

# Register EffectBase in _openshot:
_openshot.EffectBase_swigregister(EffectBase)
class EffectInfo(object):
    r"""Proxy of C++ openshot::EffectInfo class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

    @staticmethod
    def Json(*args):
        r"""Json() -> std::string"""
        return _openshot.EffectInfo_Json(*args)

    @staticmethod
    def JsonValue(*args):
        r"""JsonValue() -> Json::Value"""
        return _openshot.EffectInfo_JsonValue(*args)

    def __init__(self, *args):
        r"""__init__(EffectInfo self) -> EffectInfo"""
        _openshot.EffectInfo_swiginit(self, _openshot.new_EffectInfo(*args))
    __swig_destroy__ = _openshot.delete_EffectInfo

# Register EffectInfo in _openshot:
_openshot.EffectInfo_swigregister(EffectInfo)
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

DurationStrategy_LongestStream = _openshot.DurationStrategy_LongestStream

DurationStrategy_VideoPreferred = _openshot.DurationStrategy_VideoPreferred

DurationStrategy_AudioPreferred = _openshot.DurationStrategy_AudioPreferred

VOLUME_MIX_NONE = _openshot.VOLUME_MIX_NONE

VOLUME_MIX_AVERAGE = _openshot.VOLUME_MIX_AVERAGE

VOLUME_MIX_REDUCE = _openshot.VOLUME_MIX_REDUCE

COMPOSITE_SOURCE_OVER = _openshot.COMPOSITE_SOURCE_OVER

COMPOSITE_DESTINATION_OVER = _openshot.COMPOSITE_DESTINATION_OVER

COMPOSITE_CLEAR = _openshot.COMPOSITE_CLEAR

COMPOSITE_SOURCE = _openshot.COMPOSITE_SOURCE

COMPOSITE_DESTINATION = _openshot.COMPOSITE_DESTINATION

COMPOSITE_SOURCE_IN = _openshot.COMPOSITE_SOURCE_IN

COMPOSITE_DESTINATION_IN = _openshot.COMPOSITE_DESTINATION_IN

COMPOSITE_SOURCE_OUT = _openshot.COMPOSITE_SOURCE_OUT

COMPOSITE_DESTINATION_OUT = _openshot.COMPOSITE_DESTINATION_OUT

COMPOSITE_SOURCE_ATOP = _openshot.COMPOSITE_SOURCE_ATOP

COMPOSITE_DESTINATION_ATOP = _openshot.COMPOSITE_DESTINATION_ATOP

COMPOSITE_XOR = _openshot.COMPOSITE_XOR

COMPOSITE_PLUS = _openshot.COMPOSITE_PLUS

COMPOSITE_MULTIPLY = _openshot.COMPOSITE_MULTIPLY

COMPOSITE_SCREEN = _openshot.COMPOSITE_SCREEN

COMPOSITE_OVERLAY = _openshot.COMPOSITE_OVERLAY

COMPOSITE_DARKEN = _openshot.COMPOSITE_DARKEN

COMPOSITE_LIGHTEN = _openshot.COMPOSITE_LIGHTEN

COMPOSITE_COLOR_DODGE = _openshot.COMPOSITE_COLOR_DODGE

COMPOSITE_COLOR_BURN = _openshot.COMPOSITE_COLOR_BURN

COMPOSITE_HARD_LIGHT = _openshot.COMPOSITE_HARD_LIGHT

COMPOSITE_SOFT_LIGHT = _openshot.COMPOSITE_SOFT_LIGHT

COMPOSITE_DIFFERENCE = _openshot.COMPOSITE_DIFFERENCE

COMPOSITE_EXCLUSION = _openshot.COMPOSITE_EXCLUSION

COMPOSITE_LAST = _openshot.COMPOSITE_LAST

HARD_CLIPPING = _openshot.HARD_CLIPPING

SOFT_CLIPPING = _openshot.SOFT_CLIPPING

EXPONENTIAL = _openshot.EXPONENTIAL

FULL_WAVE_RECTIFIER = _openshot.FULL_WAVE_RECTIFIER

HALF_WAVE_RECTIFIER = _openshot.HALF_WAVE_RECTIFIER

LOW_PASS = _openshot.LOW_PASS

HIGH_PASS = _openshot.HIGH_PASS

LOW_SHELF = _openshot.LOW_SHELF

HIGH_SHELF = _openshot.HIGH_SHELF

BAND_PASS = _openshot.BAND_PASS

BAND_STOP = _openshot.BAND_STOP

PEAKING_NOTCH = _openshot.PEAKING_NOTCH

FFT_SIZE_32 = _openshot.FFT_SIZE_32

FFT_SIZE_64 = _openshot.FFT_SIZE_64

FFT_SIZE_128 = _openshot.FFT_SIZE_128

FFT_SIZE_256 = _openshot.FFT_SIZE_256

FFT_SIZE_512 = _openshot.FFT_SIZE_512

FFT_SIZE_1024 = _openshot.FFT_SIZE_1024

FFT_SIZE_2048 = _openshot.FFT_SIZE_2048

FFT_SIZE_4096 = _openshot.FFT_SIZE_4096

FFT_SIZE_8192 = _openshot.FFT_SIZE_8192

HOP_SIZE_2 = _openshot.HOP_SIZE_2

HOP_SIZE_4 = _openshot.HOP_SIZE_4

HOP_SIZE_8 = _openshot.HOP_SIZE_8

RECTANGULAR = _openshot.RECTANGULAR

BART_LETT = _openshot.BART_LETT

HANN = _openshot.HANN

HAMMING = _openshot.HAMMING

CHROMAKEY_BASIC = _openshot.CHROMAKEY_BASIC

CHROMAKEY_HSVL_H = _openshot.CHROMAKEY_HSVL_H

CHROMAKEY_HSV_S = _openshot.CHROMAKEY_HSV_S

CHROMAKEY_HSL_S = _openshot.CHROMAKEY_HSL_S

CHROMAKEY_HSV_V = _openshot.CHROMAKEY_HSV_V

CHROMAKEY_HSL_L = _openshot.CHROMAKEY_HSL_L

CHROMAKEY_CIE_LCH_L = _openshot.CHROMAKEY_CIE_LCH_L

CHROMAKEY_CIE_LCH_C = _openshot.CHROMAKEY_CIE_LCH_C

CHROMAKEY_CIE_LCH_H = _openshot.CHROMAKEY_CIE_LCH_H

CHROMAKEY_CIE_DISTANCE = _openshot.CHROMAKEY_CIE_DISTANCE

CHROMAKEY_YCBCR = _openshot.CHROMAKEY_YCBCR

CHROMAKEY_BASIC_SOFT = _openshot.CHROMAKEY_BASIC_SOFT

CHROMAKEY_LAST_METHOD = _openshot.CHROMAKEY_LAST_METHOD

class ExceptionBase(object):
    r"""Proxy of C++ openshot::ExceptionBase class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(ExceptionBase self, std::string message) -> ExceptionBase"""
        _openshot.ExceptionBase_swiginit(self, _openshot.new_ExceptionBase(*args))
    __swig_destroy__ = _openshot.delete_ExceptionBase

    def what(self, *args):
        r"""what(ExceptionBase self) -> char const *"""
        return _openshot.ExceptionBase_what(self, *args)

    def py_message(self, *args):
        r"""py_message(ExceptionBase self) -> std::string"""
        return _openshot.ExceptionBase_py_message(self, *args)

# Register ExceptionBase in _openshot:
_openshot.ExceptionBase_swigregister(ExceptionBase)
class FrameExceptionBase(ExceptionBase):
    r"""Proxy of C++ openshot::FrameExceptionBase class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    frame_number = property(_openshot.FrameExceptionBase_frame_number_get, _openshot.FrameExceptionBase_frame_number_set, doc=r"""frame_number : int64_t""")

    def __init__(self, *args):
        r"""__init__(FrameExceptionBase self, std::string message, int64_t frame_number=-1) -> FrameExceptionBase"""
        _openshot.FrameExceptionBase_swiginit(self, _openshot.new_FrameExceptionBase(*args))

    def py_message(self, *args):
        r"""py_message(FrameExceptionBase self) -> std::string"""
        return _openshot.FrameExceptionBase_py_message(self, *args)
    __swig_destroy__ = _openshot.delete_FrameExceptionBase

# Register FrameExceptionBase in _openshot:
_openshot.FrameExceptionBase_swigregister(FrameExceptionBase)
class FileExceptionBase(ExceptionBase):
    r"""Proxy of C++ openshot::FileExceptionBase class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    file_path = property(_openshot.FileExceptionBase_file_path_get, _openshot.FileExceptionBase_file_path_set, doc=r"""file_path : std::string""")
    full_message = property(_openshot.FileExceptionBase_full_message_get, _openshot.FileExceptionBase_full_message_set, doc=r"""full_message : std::string""")

    def __init__(self, *args):
        r"""__init__(FileExceptionBase self, std::string message, std::string file_path="") -> FileExceptionBase"""
        _openshot.FileExceptionBase_swiginit(self, _openshot.new_FileExceptionBase(*args))

    def what(self, *args):
        r"""what(FileExceptionBase self) -> char const *"""
        return _openshot.FileExceptionBase_what(self, *args)

    def py_message(self, *args):
        r"""py_message(FileExceptionBase self) -> std::string"""
        return _openshot.FileExceptionBase_py_message(self, *args)
    __swig_destroy__ = _openshot.delete_FileExceptionBase

# Register FileExceptionBase in _openshot:
_openshot.FileExceptionBase_swigregister(FileExceptionBase)
class ChunkNotFound(FrameExceptionBase):
    r"""Proxy of C++ openshot::ChunkNotFound class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    chunk_number = property(_openshot.ChunkNotFound_chunk_number_get, _openshot.ChunkNotFound_chunk_number_set, doc=r"""chunk_number : int64_t""")
    chunk_frame = property(_openshot.ChunkNotFound_chunk_frame_get, _openshot.ChunkNotFound_chunk_frame_set, doc=r"""chunk_frame : int64_t""")

    def __init__(self, *args):
        r"""__init__(ChunkNotFound self, std::string message, int64_t frame_number, int64_t chunk_number, int64_t chunk_frame) -> ChunkNotFound"""
        _openshot.ChunkNotFound_swiginit(self, _openshot.new_ChunkNotFound(*args))
    __swig_destroy__ = _openshot.delete_ChunkNotFound

# Register ChunkNotFound in _openshot:
_openshot.ChunkNotFound_swigregister(ChunkNotFound)
class DecklinkError(ExceptionBase):
    r"""Proxy of C++ openshot::DecklinkError class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(DecklinkError self, std::string message) -> DecklinkError"""
        _openshot.DecklinkError_swiginit(self, _openshot.new_DecklinkError(*args))
    __swig_destroy__ = _openshot.delete_DecklinkError

# Register DecklinkError in _openshot:
_openshot.DecklinkError_swigregister(DecklinkError)
class ErrorDecodingAudio(FrameExceptionBase):
    r"""Proxy of C++ openshot::ErrorDecodingAudio class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(ErrorDecodingAudio self, std::string message, int64_t frame_number=-1) -> ErrorDecodingAudio"""
        _openshot.ErrorDecodingAudio_swiginit(self, _openshot.new_ErrorDecodingAudio(*args))
    __swig_destroy__ = _openshot.delete_ErrorDecodingAudio

# Register ErrorDecodingAudio in _openshot:
_openshot.ErrorDecodingAudio_swigregister(ErrorDecodingAudio)
class ErrorEncodingAudio(FrameExceptionBase):
    r"""Proxy of C++ openshot::ErrorEncodingAudio class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(ErrorEncodingAudio self, std::string message, int64_t frame_number=-1) -> ErrorEncodingAudio"""
        _openshot.ErrorEncodingAudio_swiginit(self, _openshot.new_ErrorEncodingAudio(*args))
    __swig_destroy__ = _openshot.delete_ErrorEncodingAudio

# Register ErrorEncodingAudio in _openshot:
_openshot.ErrorEncodingAudio_swigregister(ErrorEncodingAudio)
class ErrorEncodingVideo(FrameExceptionBase):
    r"""Proxy of C++ openshot::ErrorEncodingVideo class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(ErrorEncodingVideo self, std::string message, int64_t frame_number=-1) -> ErrorEncodingVideo"""
        _openshot.ErrorEncodingVideo_swiginit(self, _openshot.new_ErrorEncodingVideo(*args))
    __swig_destroy__ = _openshot.delete_ErrorEncodingVideo

# Register ErrorEncodingVideo in _openshot:
_openshot.ErrorEncodingVideo_swigregister(ErrorEncodingVideo)
class InvalidChannels(FileExceptionBase):
    r"""Proxy of C++ openshot::InvalidChannels class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(InvalidChannels self, std::string message, std::string file_path="") -> InvalidChannels"""
        _openshot.InvalidChannels_swiginit(self, _openshot.new_InvalidChannels(*args))
    __swig_destroy__ = _openshot.delete_InvalidChannels

# Register InvalidChannels in _openshot:
_openshot.InvalidChannels_swigregister(InvalidChannels)
class InvalidCodec(FileExceptionBase):
    r"""Proxy of C++ openshot::InvalidCodec class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(InvalidCodec self, std::string message, std::string file_path="") -> InvalidCodec"""
        _openshot.InvalidCodec_swiginit(self, _openshot.new_InvalidCodec(*args))
    __swig_destroy__ = _openshot.delete_InvalidCodec

# Register InvalidCodec in _openshot:
_openshot.InvalidCodec_swigregister(InvalidCodec)
class InvalidFile(FileExceptionBase):
    r"""Proxy of C++ openshot::InvalidFile class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(InvalidFile self, std::string message, std::string file_path) -> InvalidFile"""
        _openshot.InvalidFile_swiginit(self, _openshot.new_InvalidFile(*args))
    __swig_destroy__ = _openshot.delete_InvalidFile

# Register InvalidFile in _openshot:
_openshot.InvalidFile_swigregister(InvalidFile)
class InvalidFormat(FileExceptionBase):
    r"""Proxy of C++ openshot::InvalidFormat class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(InvalidFormat self, std::string message, std::string file_path="") -> InvalidFormat"""
        _openshot.InvalidFormat_swiginit(self, _openshot.new_InvalidFormat(*args))
    __swig_destroy__ = _openshot.delete_InvalidFormat

# Register InvalidFormat in _openshot:
_openshot.InvalidFormat_swigregister(InvalidFormat)
class InvalidJSON(FileExceptionBase):
    r"""Proxy of C++ openshot::InvalidJSON class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(InvalidJSON self, std::string message, std::string file_path="") -> InvalidJSON"""
        _openshot.InvalidJSON_swiginit(self, _openshot.new_InvalidJSON(*args))
    __swig_destroy__ = _openshot.delete_InvalidJSON

# Register InvalidJSON in _openshot:
_openshot.InvalidJSON_swigregister(InvalidJSON)
class InvalidOptions(FileExceptionBase):
    r"""Proxy of C++ openshot::InvalidOptions class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(InvalidOptions self, std::string message, std::string file_path="") -> InvalidOptions"""
        _openshot.InvalidOptions_swiginit(self, _openshot.new_InvalidOptions(*args))
    __swig_destroy__ = _openshot.delete_InvalidOptions

# Register InvalidOptions in _openshot:
_openshot.InvalidOptions_swigregister(InvalidOptions)
class InvalidSampleRate(FileExceptionBase):
    r"""Proxy of C++ openshot::InvalidSampleRate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(InvalidSampleRate self, std::string message, std::string file_path="") -> InvalidSampleRate"""
        _openshot.InvalidSampleRate_swiginit(self, _openshot.new_InvalidSampleRate(*args))
    __swig_destroy__ = _openshot.delete_InvalidSampleRate

# Register InvalidSampleRate in _openshot:
_openshot.InvalidSampleRate_swigregister(InvalidSampleRate)
class InvalidJSONKey(ExceptionBase):
    r"""Proxy of C++ openshot::InvalidJSONKey class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    json = property(_openshot.InvalidJSONKey_json_get, _openshot.InvalidJSONKey_json_set, doc=r"""json : std::string""")

    def __init__(self, *args):
        r"""__init__(InvalidJSONKey self, std::string message, std::string json) -> InvalidJSONKey"""
        _openshot.InvalidJSONKey_swiginit(self, _openshot.new_InvalidJSONKey(*args))
    __swig_destroy__ = _openshot.delete_InvalidJSONKey

    def py_message(self, *args):
        r"""py_message(InvalidJSONKey self) -> std::string"""
        return _openshot.InvalidJSONKey_py_message(self, *args)

# Register InvalidJSONKey in _openshot:
_openshot.InvalidJSONKey_swigregister(InvalidJSONKey)
class NoStreamsFound(FileExceptionBase):
    r"""Proxy of C++ openshot::NoStreamsFound class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(NoStreamsFound self, std::string message, std::string file_path="") -> NoStreamsFound"""
        _openshot.NoStreamsFound_swiginit(self, _openshot.new_NoStreamsFound(*args))
    __swig_destroy__ = _openshot.delete_NoStreamsFound

# Register NoStreamsFound in _openshot:
_openshot.NoStreamsFound_swigregister(NoStreamsFound)
class OutOfBoundsFrame(ExceptionBase):
    r"""Proxy of C++ openshot::OutOfBoundsFrame class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    FrameRequested = property(_openshot.OutOfBoundsFrame_FrameRequested_get, _openshot.OutOfBoundsFrame_FrameRequested_set, doc=r"""FrameRequested : int64_t""")
    MaxFrames = property(_openshot.OutOfBoundsFrame_MaxFrames_get, _openshot.OutOfBoundsFrame_MaxFrames_set, doc=r"""MaxFrames : int64_t""")

    def __init__(self, *args):
        r"""__init__(OutOfBoundsFrame self, std::string message, int64_t frame_requested, int64_t max_frames) -> OutOfBoundsFrame"""
        _openshot.OutOfBoundsFrame_swiginit(self, _openshot.new_OutOfBoundsFrame(*args))
    __swig_destroy__ = _openshot.delete_OutOfBoundsFrame

    def py_message(self, *args):
        r"""py_message(OutOfBoundsFrame self) -> std::string"""
        return _openshot.OutOfBoundsFrame_py_message(self, *args)

# Register OutOfBoundsFrame in _openshot:
_openshot.OutOfBoundsFrame_swigregister(OutOfBoundsFrame)
class OutOfBoundsPoint(ExceptionBase):
    r"""Proxy of C++ openshot::OutOfBoundsPoint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    PointRequested = property(_openshot.OutOfBoundsPoint_PointRequested_get, _openshot.OutOfBoundsPoint_PointRequested_set, doc=r"""PointRequested : int""")
    MaxPoints = property(_openshot.OutOfBoundsPoint_MaxPoints_get, _openshot.OutOfBoundsPoint_MaxPoints_set, doc=r"""MaxPoints : int""")

    def __init__(self, *args):
        r"""__init__(OutOfBoundsPoint self, std::string message, int point_requested, int max_points) -> OutOfBoundsPoint"""
        _openshot.OutOfBoundsPoint_swiginit(self, _openshot.new_OutOfBoundsPoint(*args))
    __swig_destroy__ = _openshot.delete_OutOfBoundsPoint

    def py_message(self, *args):
        r"""py_message(OutOfBoundsPoint self) -> std::string"""
        return _openshot.OutOfBoundsPoint_py_message(self, *args)

# Register OutOfBoundsPoint in _openshot:
_openshot.OutOfBoundsPoint_swigregister(OutOfBoundsPoint)
class OutOfMemory(FileExceptionBase):
    r"""Proxy of C++ openshot::OutOfMemory class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(OutOfMemory self, std::string message, std::string file_path="") -> OutOfMemory"""
        _openshot.OutOfMemory_swiginit(self, _openshot.new_OutOfMemory(*args))
    __swig_destroy__ = _openshot.delete_OutOfMemory

# Register OutOfMemory in _openshot:
_openshot.OutOfMemory_swigregister(OutOfMemory)
class ReaderClosed(FileExceptionBase):
    r"""Proxy of C++ openshot::ReaderClosed class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(ReaderClosed self, std::string message, std::string file_path="") -> ReaderClosed"""
        _openshot.ReaderClosed_swiginit(self, _openshot.new_ReaderClosed(*args))
    __swig_destroy__ = _openshot.delete_ReaderClosed

# Register ReaderClosed in _openshot:
_openshot.ReaderClosed_swigregister(ReaderClosed)
class ResampleError(FileExceptionBase):
    r"""Proxy of C++ openshot::ResampleError class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(ResampleError self, std::string message, std::string file_path="") -> ResampleError"""
        _openshot.ResampleError_swiginit(self, _openshot.new_ResampleError(*args))
    __swig_destroy__ = _openshot.delete_ResampleError

# Register ResampleError in _openshot:
_openshot.ResampleError_swigregister(ResampleError)
TMS_DEP_MSG = _openshot.TMS_DEP_MSG

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(WriterClosed self, std::string message, std::string file_path="") -> WriterClosed"""
        _openshot.WriterClosed_swiginit(self, _openshot.new_WriterClosed(*args))
    __swig_destroy__ = _openshot.delete_WriterClosed

# Register WriterClosed in _openshot:
_openshot.WriterClosed_swigregister(WriterClosed)
class PacketStatus(object):
    r"""Proxy of C++ openshot::PacketStatus class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    video_read = property(_openshot.PacketStatus_video_read_get, _openshot.PacketStatus_video_read_set, doc=r"""video_read : int64_t""")
    video_decoded = property(_openshot.PacketStatus_video_decoded_get, _openshot.PacketStatus_video_decoded_set, doc=r"""video_decoded : int64_t""")
    audio_read = property(_openshot.PacketStatus_audio_read_get, _openshot.PacketStatus_audio_read_set, doc=r"""audio_read : int64_t""")
    audio_decoded = property(_openshot.PacketStatus_audio_decoded_get, _openshot.PacketStatus_audio_decoded_set, doc=r"""audio_decoded : int64_t""")
    video_eof = property(_openshot.PacketStatus_video_eof_get, _openshot.PacketStatus_video_eof_set, doc=r"""video_eof : bool""")
    audio_eof = property(_openshot.PacketStatus_audio_eof_get, _openshot.PacketStatus_audio_eof_set, doc=r"""audio_eof : bool""")
    packets_eof = property(_openshot.PacketStatus_packets_eof_get, _openshot.PacketStatus_packets_eof_set, doc=r"""packets_eof : bool""")
    end_of_file = property(_openshot.PacketStatus_end_of_file_get, _openshot.PacketStatus_end_of_file_set, doc=r"""end_of_file : bool""")

    def packets_read(self, *args):
        r"""packets_read(PacketStatus self) -> int64_t"""
        return _openshot.PacketStatus_packets_read(self, *args)

    def packets_decoded(self, *args):
        r"""packets_decoded(PacketStatus self) -> int64_t"""
        return _openshot.PacketStatus_packets_decoded(self, *args)

    def reset(self, *args):
        r"""reset(PacketStatus self, bool eof)"""
        return _openshot.PacketStatus_reset(self, *args)

    def __init__(self, *args):
        r"""__init__(PacketStatus self) -> PacketStatus"""
        _openshot.PacketStatus_swiginit(self, _openshot.new_PacketStatus(*args))
    __swig_destroy__ = _openshot.delete_PacketStatus

# Register PacketStatus in _openshot:
_openshot.PacketStatus_swigregister(PacketStatus)
class FFmpegReader(ReaderBase):
    r"""Proxy of C++ openshot::FFmpegReader class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    final_cache = property(_openshot.FFmpegReader_final_cache_get, _openshot.FFmpegReader_final_cache_set, doc=r"""final_cache : openshot::CacheMemory""")
    enable_seek = property(_openshot.FFmpegReader_enable_seek_get, _openshot.FFmpegReader_enable_seek_set, doc=r"""enable_seek : bool""")

    def __init__(self, *args):
        r"""
        __init__(FFmpegReader self, std::string const & path, bool inspect_reader=True) -> FFmpegReader
        __init__(FFmpegReader self, std::string const & path, openshot::DurationStrategy duration_strategy, bool inspect_reader=True) -> FFmpegReader
        """
        _openshot.FFmpegReader_swiginit(self, _openshot.new_FFmpegReader(*args))
    __swig_destroy__ = _openshot.delete_FFmpegReader

    def Close(self, *args):
        r"""Close(FFmpegReader self)"""
        return _openshot.FFmpegReader_Close(self, *args)

    def GetCache(self, *args):
        r"""GetCache(FFmpegReader self) -> CacheMemory"""
        return _openshot.FFmpegReader_GetCache(self, *args)

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

    def IsOpen(self, *args):
        r"""IsOpen(FFmpegReader self) -> bool"""
        return _openshot.FFmpegReader_IsOpen(self, *args)

    def HardwareDecodeSuccessful(self, *args):
        r"""HardwareDecodeSuccessful(FFmpegReader self) -> bool"""
        return _openshot.FFmpegReader_HardwareDecodeSuccessful(self, *args)

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

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

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

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

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

    def Open(self, *args):
        r"""Open(FFmpegReader self)"""
        return _openshot.FFmpegReader_Open(self, *args)

    def GetIsDurationKnown(self, *args):
        r"""GetIsDurationKnown(FFmpegReader self) -> bool"""
        return _openshot.FFmpegReader_GetIsDurationKnown(self, *args)

# Register FFmpegReader in _openshot:
_openshot.FFmpegReader_swigregister(FFmpegReader)
VIDEO_STREAM = _openshot.VIDEO_STREAM

AUDIO_STREAM = _openshot.AUDIO_STREAM

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(FFmpegWriter self, std::string const & path) -> FFmpegWriter"""
        _openshot.FFmpegWriter_swiginit(self, _openshot.new_FFmpegWriter(*args))

    def Close(self, *args):
        r"""Close(FFmpegWriter self)"""
        return _openshot.FFmpegWriter_Close(self, *args)

    def IsOpen(self, *args):
        r"""IsOpen(FFmpegWriter self) -> bool"""
        return _openshot.FFmpegWriter_IsOpen(self, *args)

    @staticmethod
    def IsValidCodec(*args):
        r"""IsValidCodec(std::string codec_name) -> bool"""
        return _openshot.FFmpegWriter_IsValidCodec(*args)

    def Open(self, *args):
        r"""Open(FFmpegWriter self)"""
        return _openshot.FFmpegWriter_Open(self, *args)

    def OutputStreamInfo(self, *args):
        r"""OutputStreamInfo(FFmpegWriter self)"""
        return _openshot.FFmpegWriter_OutputStreamInfo(self, *args)

    def PrepareStreams(self, *args):
        r"""PrepareStreams(FFmpegWriter self)"""
        return _openshot.FFmpegWriter_PrepareStreams(self, *args)

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

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

    def SetVideoOptions(self, *args):
        r"""
        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)
        SetVideoOptions(FFmpegWriter self, std::string codec, int width, int height, Fraction fps, int bit_rate)
        """
        return _openshot.FFmpegWriter_SetVideoOptions(self, *args)

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

    def WriteHeader(self, *args):
        r"""WriteHeader(FFmpegWriter self)"""
        return _openshot.FFmpegWriter_WriteHeader(self, *args)

    def WriteFrame(self, *args):
        r"""
        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, *args):
        r"""WriteTrailer(FFmpegWriter self)"""
        return _openshot.FFmpegWriter_WriteTrailer(self, *args)

    def AddSphericalMetadata(self, *args):
        r"""AddSphericalMetadata(FFmpegWriter self, std::string const & projection="equirectangular", float yaw_deg=0.0, float pitch_deg=0.0, float roll_deg=0.0)"""
        return _openshot.FFmpegWriter_AddSphericalMetadata(self, *args)
    __swig_destroy__ = _openshot.delete_FFmpegWriter

# Register FFmpegWriter in _openshot:
_openshot.FFmpegWriter_swigregister(FFmpegWriter)
class Fraction(object):
    r"""Proxy of C++ openshot::Fraction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    num = property(_openshot.Fraction_num_get, _openshot.Fraction_num_set, doc=r"""num : int""")
    den = property(_openshot.Fraction_den_get, _openshot.Fraction_den_set, doc=r"""den : int""")

    def __init__(self, *args):
        r"""
        __init__(Fraction self) -> Fraction
        __init__(Fraction self, int num, int den) -> Fraction
        __init__(Fraction self, std::pair< int,int > pair) -> Fraction
        __init__(Fraction self, std::vector< int,std::allocator< int > > vector) -> Fraction
        __init__(Fraction self, std::map< std::string,int,std::less< std::string >,std::allocator< std::pair< std::string const,int > > > mapping) -> Fraction
        """
        _openshot.Fraction_swiginit(self, _openshot.new_Fraction(*args))

    def GreatestCommonDenominator(self, *args):
        r"""GreatestCommonDenominator(Fraction self) -> int"""
        return _openshot.Fraction_GreatestCommonDenominator(self, *args)

    def Reduce(self, *args):
        r"""Reduce(Fraction self)"""
        return _openshot.Fraction_Reduce(self, *args)

    def ToFloat(self, *args):
        r"""ToFloat(Fraction self) -> float"""
        return _openshot.Fraction_ToFloat(self, *args)

    def ToDouble(self, *args):
        r"""ToDouble(Fraction self) -> double"""
        return _openshot.Fraction_ToDouble(self, *args)

    def ToInt(self, *args):
        r"""ToInt(Fraction self) -> int"""
        return _openshot.Fraction_ToInt(self, *args)

    def Reciprocal(self, *args):
        r"""Reciprocal(Fraction self) -> Fraction"""
        return _openshot.Fraction_Reciprocal(self, *args)

    def __mul__(self, *args):
        r"""__mul__(Fraction self, Fraction other) -> Fraction"""
        return _openshot.Fraction___mul__(self, *args)

    def __truediv__(self, *args):
        return _openshot.Fraction___truediv__(self, *args)
    __div__ = __truediv__



    def __float__(self, *args):
        r"""__float__(Fraction self) -> double"""
        return _openshot.Fraction___float__(self, *args)

    def __int__(self, *args):
        r"""__int__(Fraction self) -> int"""
        return _openshot.Fraction___int__(self, *args)

    def __len__(self, *args):
        r"""__len__(Fraction self) -> int"""
        return _openshot.Fraction___len__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(Fraction self, int index) -> std::string const
        __getitem__(Fraction self, std::string const & key) -> int
        """
        return _openshot.Fraction___getitem__(self, *args)

    def __contains__(self, *args):
        r"""__contains__(Fraction self, std::string const & key) -> bool"""
        return _openshot.Fraction___contains__(self, *args)

    def GetMap(self, *args):
        r"""GetMap(Fraction self) -> std::map< std::string,int,std::less< std::string >,std::allocator< std::pair< std::string const,int > > >"""
        return _openshot.Fraction_GetMap(self, *args)

    def __str__(self, *args):
        r"""__str__(Fraction self) -> std::string const"""
        return _openshot.Fraction___str__(self, *args)

    def __repr__(self, *args):
        r"""__repr__(Fraction self) -> std::string const"""
        return _openshot.Fraction___repr__(self, *args)

    def __iter__(self):
        return iter(self.GetMap())
    def keys(self):
        _items = self.GetMap()
        return _items.keys()
    def items(self):
        _items = self.GetMap()
        return _items.items()
    def values(self):
        _items = self.GetMap()
        return _items.values()
    def __mul__(self, other):
        if isinstance(other, Fraction):
            return Fraction(self.num * other.num, self.den * other.den)
        return float(self) * other
    def __rmul__(self, other):
        return other * float(self)
    def __truediv__(self, other):
        if isinstance(other, Fraction):
            return Fraction(self.num * other.den, self.den * other.num)
        return float(self) / other;
    def __rtruediv__(self, other):
        return other / float(self)
    def __format__(self, format_spec):
        integer_fmt = "bcdoxX"
        float_fmt = "eEfFgGn%"
        all_fmt = "".join(["s", integer_fmt, float_fmt])
        if not format_spec or format_spec[-1] not in all_fmt:
          value = str(self)
        elif format_spec[-1] in integer_fmt:
            value = int(self)
        elif format_spec[-1] in float_fmt:
            value = float(self)
        else:
            value = str(self)
        return "{value:{spec}}".format(value=value, spec=format_spec)

    __swig_destroy__ = _openshot.delete_Fraction

# Register Fraction in _openshot:
_openshot.Fraction_swigregister(Fraction)
class Frame(object):
    r"""Proxy of C++ openshot::Frame class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    audio = property(_openshot.Frame_audio_get, _openshot.Frame_audio_set, doc=r"""audio : std::shared_ptr<(juce::AudioBuffer<(float)>)>""")
    number = property(_openshot.Frame_number_get, _openshot.Frame_number_set, doc=r"""number : int64_t""")
    has_audio_data = property(_openshot.Frame_has_audio_data_get, _openshot.Frame_has_audio_data_set, doc=r"""has_audio_data : bool""")
    has_image_data = property(_openshot.Frame_has_image_data_get, _openshot.Frame_has_image_data_set, doc=r"""has_image_data : bool""")

    def __init__(self, *args):
        r"""
        __init__(Frame self) -> Frame
        __init__(Frame self, int64_t number, int width, int height, std::string color) -> Frame
        __init__(Frame self, int64_t number, int samples, int channels) -> Frame
        __init__(Frame self, int64_t number, int width, int height, std::string color, int samples, int channels) -> Frame
        __init__(Frame self, Frame other) -> Frame
        """
        _openshot.Frame_swiginit(self, _openshot.new_Frame(*args))
    __swig_destroy__ = _openshot.delete_Frame

    def AddColor(self, *args):
        r"""
        AddColor(Frame self, int new_width, int new_height, std::string new_color)
        AddColor(Frame self, QColor const & new_color)
        """
        return _openshot.Frame_AddColor(self, *args)

    def AddImage(self, *args):
        r"""
        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, *args):
        r"""AddAudio(Frame self, bool replaceSamples, int destChannel, int destStartSample, float const * source, int numSamples, float gainToApplyToSource)"""
        return _openshot.Frame_AddAudio(self, *args)

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

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

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

    def ClearWaveform(self, *args):
        r"""ClearWaveform(Frame self)"""
        return _openshot.Frame_ClearWaveform(self, *args)

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

    def Display(self, *args):
        r"""Display(Frame self)"""
        return _openshot.Frame_Display(self, *args)

    def DisplayWaveform(self, *args):
        r"""DisplayWaveform(Frame self)"""
        return _openshot.Frame_DisplayWaveform(self, *args)

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

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

    def GetInterleavedAudioSamples(self, *args):
        r"""GetInterleavedAudioSamples(Frame self, int * sample_count) -> float *"""
        return _openshot.Frame_GetInterleavedAudioSamples(self, *args)

    def GetAudioChannelsCount(self, *args):
        r"""GetAudioChannelsCount(Frame self) -> int"""
        return _openshot.Frame_GetAudioChannelsCount(self, *args)

    def GetAudioSamplesCount(self, *args):
        r"""GetAudioSamplesCount(Frame self) -> int"""
        return _openshot.Frame_GetAudioSamplesCount(self, *args)

    def GetAudioSampleBuffer(self, *args):
        r"""GetAudioSampleBuffer(Frame self) -> juce::AudioBuffer< float > *"""
        return _openshot.Frame_GetAudioSampleBuffer(self, *args)

    def GetBytes(self, *args):
        r"""GetBytes(Frame self) -> int64_t"""
        return _openshot.Frame_GetBytes(self, *args)

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

    def GetPixelRatio(self, *args):
        r"""GetPixelRatio(Frame self) -> Fraction"""
        return _openshot.Frame_GetPixelRatio(self, *args)

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

    def CheckPixel(self, *args):
        r"""CheckPixel(Frame self, int row, int col, int red, int green, int blue, int alpha, int threshold) -> bool"""
        return _openshot.Frame_CheckPixel(self, *args)

    def GetHeight(self, *args):
        r"""GetHeight(Frame self) -> int"""
        return _openshot.Frame_GetHeight(self, *args)

    @staticmethod
    def GetSamplesPerFrame(*args):
        r"""
        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)

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

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

    def GetWidth(self, *args):
        r"""GetWidth(Frame self) -> int"""
        return _openshot.Frame_GetWidth(self, *args)

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

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

    def SetAudioDirection(self, *args):
        r"""SetAudioDirection(Frame self, bool is_increasing)"""
        return _openshot.Frame_SetAudioDirection(self, *args)

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

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

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

    def Thumbnail(self, *args):
        r"""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="png", int quality=100, float rotate=0.0, openshot::ScaleType scale_mode=SCALE_FIT)"""
        return _openshot.Frame_Thumbnail(self, *args)

    def Play(self, *args):
        r"""Play(Frame self)"""
        return _openshot.Frame_Play(self, *args)

# Register Frame in _openshot:
_openshot.Frame_swigregister(Frame)
PULLDOWN_CLASSIC = _openshot.PULLDOWN_CLASSIC

PULLDOWN_ADVANCED = _openshot.PULLDOWN_ADVANCED

PULLDOWN_NONE = _openshot.PULLDOWN_NONE

class Field(object):
    r"""Proxy of C++ openshot::Field class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Frame = property(_openshot.Field_Frame_get, _openshot.Field_Frame_set, doc=r"""Frame : int64_t""")
    isOdd = property(_openshot.Field_isOdd_get, _openshot.Field_isOdd_set, doc=r"""isOdd : bool""")

    def __init__(self, *args):
        r"""__init__(Field self) -> Field"""
        _openshot.Field_swiginit(self, _openshot.new_Field(*args))
    __swig_destroy__ = _openshot.delete_Field

# Register Field in _openshot:
_openshot.Field_swigregister(Field)
class SampleRange(object):
    r"""Proxy of C++ openshot::SampleRange class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    frame_start = property(_openshot.SampleRange_frame_start_get, _openshot.SampleRange_frame_start_set, doc=r"""frame_start : int64_t""")
    sample_start = property(_openshot.SampleRange_sample_start_get, _openshot.SampleRange_sample_start_set, doc=r"""sample_start : int""")
    frame_end = property(_openshot.SampleRange_frame_end_get, _openshot.SampleRange_frame_end_set, doc=r"""frame_end : int64_t""")
    sample_end = property(_openshot.SampleRange_sample_end_get, _openshot.SampleRange_sample_end_set, doc=r"""sample_end : int""")

    def Extend(self, *args):
        r"""Extend(SampleRange self, int64_t samples, Fraction fps, int sample_rate, int channels, bool right_side)"""
        return _openshot.SampleRange_Extend(self, *args)

    def Shrink(self, *args):
        r"""Shrink(SampleRange self, int64_t samples, Fraction fps, int sample_rate, int channels, bool right_side)"""
        return _openshot.SampleRange_Shrink(self, *args)

    def Shift(self, *args):
        r"""Shift(SampleRange self, int64_t samples, Fraction fps, int sample_rate, int channels, bool right_side)"""
        return _openshot.SampleRange_Shift(self, *args)
    total = property(_openshot.SampleRange_total_get, _openshot.SampleRange_total_set, doc=r"""total : int""")

    def __init__(self, *args):
        r"""__init__(SampleRange self) -> SampleRange"""
        _openshot.SampleRange_swiginit(self, _openshot.new_SampleRange(*args))
    __swig_destroy__ = _openshot.delete_SampleRange

# Register SampleRange in _openshot:
_openshot.SampleRange_swigregister(SampleRange)
class MappedFrame(object):
    r"""Proxy of C++ openshot::MappedFrame class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Odd = property(_openshot.MappedFrame_Odd_get, _openshot.MappedFrame_Odd_set, doc=r"""Odd : openshot::Field""")
    Even = property(_openshot.MappedFrame_Even_get, _openshot.MappedFrame_Even_set, doc=r"""Even : openshot::Field""")
    Samples = property(_openshot.MappedFrame_Samples_get, _openshot.MappedFrame_Samples_set, doc=r"""Samples : openshot::SampleRange""")

    def __init__(self, *args):
        r"""__init__(MappedFrame self) -> MappedFrame"""
        _openshot.MappedFrame_swiginit(self, _openshot.new_MappedFrame(*args))
    __swig_destroy__ = _openshot.delete_MappedFrame

# Register MappedFrame in _openshot:
_openshot.MappedFrame_swigregister(MappedFrame)
class FrameMapper(ReaderBase):
    r"""Proxy of C++ openshot::FrameMapper class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    fields = property(_openshot.FrameMapper_fields_get, _openshot.FrameMapper_fields_set, doc=r"""fields : std::vector<(openshot::Field,std::allocator<(openshot::Field)>)>""")
    frames = property(_openshot.FrameMapper_frames_get, _openshot.FrameMapper_frames_set, doc=r"""frames : std::vector<(openshot::MappedFrame,std::allocator<(openshot::MappedFrame)>)>""")

    def __init__(self, *args):
        r"""__init__(FrameMapper self, ReaderBase reader, Fraction target_fps, openshot::PulldownType target_pulldown, int target_sample_rate, int target_channels, openshot::ChannelLayout target_channel_layout) -> FrameMapper"""
        _openshot.FrameMapper_swiginit(self, _openshot.new_FrameMapper(*args))
    __swig_destroy__ = _openshot.delete_FrameMapper

    def ChangeMapping(self, *args):
        r"""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, *args)

    def Close(self, *args):
        r"""Close(FrameMapper self)"""
        return _openshot.FrameMapper_Close(self, *args)

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

    def GetCache(self, *args):
        r"""GetCache(FrameMapper self) -> CacheMemory"""
        return _openshot.FrameMapper_GetCache(self, *args)

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

    def IsOpen(self, *args):
        r"""IsOpen(FrameMapper self) -> bool"""
        return _openshot.FrameMapper_IsOpen(self, *args)

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

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

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

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

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

    def Open(self, *args):
        r"""Open(FrameMapper self)"""
        return _openshot.FrameMapper_Open(self, *args)

    def SetDirectionHint(self, *args):
        r"""SetDirectionHint(FrameMapper self, bool const increasing)"""
        return _openshot.FrameMapper_SetDirectionHint(self, *args)

    def PrintMapping(self, *args):
        r"""PrintMapping(FrameMapper self, std::ostream * out=&std::cout)"""
        return _openshot.FrameMapper_PrintMapping(self, *args)

    def Reader(self, *args):
        r"""
        Reader(FrameMapper self) -> ReaderBase
        Reader(FrameMapper self, ReaderBase new_reader)
        """
        return _openshot.FrameMapper_Reader(self, *args)

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

# Register FrameMapper in _openshot:
_openshot.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):
    r"""Proxy of C++ openshot::PlayerBase class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def Loading(self, *args):
        r"""Loading(PlayerBase self)"""
        return _openshot.PlayerBase_Loading(self, *args)

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

    def Play(self, *args):
        r"""Play(PlayerBase self)"""
        return _openshot.PlayerBase_Play(self, *args)

    def Pause(self, *args):
        r"""Pause(PlayerBase self)"""
        return _openshot.PlayerBase_Pause(self, *args)

    def Position(self, *args):
        r"""Position(PlayerBase self) -> int64_t"""
        return _openshot.PlayerBase_Position(self, *args)

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

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

    def Stop(self, *args):
        r"""Stop(PlayerBase self)"""
        return _openshot.PlayerBase_Stop(self, *args)

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

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

# Register PlayerBase in _openshot:
_openshot.PlayerBase_swigregister(PlayerBase)
BEZIER = _openshot.BEZIER

LINEAR = _openshot.LINEAR

CONSTANT = _openshot.CONSTANT

AUTO = _openshot.AUTO

MANUAL = _openshot.MANUAL

class Point(object):
    r"""Proxy of C++ openshot::Point class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    co = property(_openshot.Point_co_get, _openshot.Point_co_set, doc=r"""co : openshot::Coordinate""")
    handle_left = property(_openshot.Point_handle_left_get, _openshot.Point_handle_left_set, doc=r"""handle_left : openshot::Coordinate""")
    handle_right = property(_openshot.Point_handle_right_get, _openshot.Point_handle_right_set, doc=r"""handle_right : openshot::Coordinate""")
    interpolation = property(_openshot.Point_interpolation_get, _openshot.Point_interpolation_set, doc=r"""interpolation : openshot::InterpolationType""")
    handle_type = property(_openshot.Point_handle_type_get, _openshot.Point_handle_type_set, doc=r"""handle_type : openshot::HandleType""")

    def __init__(self, *args):
        r"""
        __init__(Point self) -> Point
        __init__(Point self, float y) -> Point
        __init__(Point self, float x, float y) -> Point
        __init__(Point self, float x, float y, openshot::InterpolationType interpolation) -> Point
        __init__(Point self, Coordinate co) -> Point
        __init__(Point self, Coordinate co, openshot::InterpolationType interpolation) -> Point
        __init__(Point self, Coordinate co, openshot::InterpolationType interpolation, openshot::HandleType handle_type) -> Point
        """
        _openshot.Point_swiginit(self, _openshot.new_Point(*args))

    def Initialize_Handles(self, *args):
        r"""Initialize_Handles(Point self)"""
        return _openshot.Point_Initialize_Handles(self, *args)

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

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

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

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

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

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Point self, Json::Value const root)"""
        return _openshot.Point_SetJsonValue(self, *args)
    __swig_destroy__ = _openshot.delete_Point

# Register Point in _openshot:
_openshot.Point_swigregister(Point)
class ProfileInfo(object):
    r"""Proxy of C++ openshot::ProfileInfo class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    description = property(_openshot.ProfileInfo_description_get, _openshot.ProfileInfo_description_set, doc=r"""description : std::string""")
    height = property(_openshot.ProfileInfo_height_get, _openshot.ProfileInfo_height_set, doc=r"""height : int""")
    width = property(_openshot.ProfileInfo_width_get, _openshot.ProfileInfo_width_set, doc=r"""width : int""")
    pixel_format = property(_openshot.ProfileInfo_pixel_format_get, _openshot.ProfileInfo_pixel_format_set, doc=r"""pixel_format : int""")
    fps = property(_openshot.ProfileInfo_fps_get, _openshot.ProfileInfo_fps_set, doc=r"""fps : openshot::Fraction""")
    pixel_ratio = property(_openshot.ProfileInfo_pixel_ratio_get, _openshot.ProfileInfo_pixel_ratio_set, doc=r"""pixel_ratio : openshot::Fraction""")
    display_ratio = property(_openshot.ProfileInfo_display_ratio_get, _openshot.ProfileInfo_display_ratio_set, doc=r"""display_ratio : openshot::Fraction""")
    interlaced_frame = property(_openshot.ProfileInfo_interlaced_frame_get, _openshot.ProfileInfo_interlaced_frame_set, doc=r"""interlaced_frame : bool""")
    spherical = property(_openshot.ProfileInfo_spherical_get, _openshot.ProfileInfo_spherical_set, doc=r"""spherical : bool""")

    def __init__(self, *args):
        r"""__init__(ProfileInfo self) -> ProfileInfo"""
        _openshot.ProfileInfo_swiginit(self, _openshot.new_ProfileInfo(*args))
    __swig_destroy__ = _openshot.delete_ProfileInfo

# Register ProfileInfo in _openshot:
_openshot.ProfileInfo_swigregister(ProfileInfo)
class Profile(object):
    r"""Proxy of C++ openshot::Profile class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    info = property(_openshot.Profile_info_get, _openshot.Profile_info_set, doc=r"""info : openshot::ProfileInfo""")

    def __init__(self, *args):
        r"""
        __init__(Profile self) -> Profile
        __init__(Profile self, std::string path) -> Profile
        """
        _openshot.Profile_swiginit(self, _openshot.new_Profile(*args))

    def Save(self, *args):
        r"""Save(Profile self, std::string const & file_path)"""
        return _openshot.Profile_Save(self, *args)

    def Key(self, *args):
        r"""Key(Profile self) -> std::string"""
        return _openshot.Profile_Key(self, *args)

    def ShortName(self, *args):
        r"""ShortName(Profile self) -> std::string"""
        return _openshot.Profile_ShortName(self, *args)

    def LongName(self, *args):
        r"""LongName(Profile self) -> std::string"""
        return _openshot.Profile_LongName(self, *args)

    def LongNameWithDesc(self, *args):
        r"""LongNameWithDesc(Profile self) -> std::string"""
        return _openshot.Profile_LongNameWithDesc(self, *args)

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

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

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

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

    def __eq__(self, *args):
        r"""__eq__(Profile self, Profile other) -> bool"""
        return _openshot.Profile___eq__(self, *args)

    def __lt__(self, *args):
        r"""__lt__(Profile self, Profile other) -> bool"""
        return _openshot.Profile___lt__(self, *args)

    def __gt__(self, *args):
        r"""__gt__(Profile self, Profile other) -> bool"""
        return _openshot.Profile___gt__(self, *args)
    __swig_destroy__ = _openshot.delete_Profile

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

def __lt__(*args):
    r"""__lt__(Profile l, Profile r) -> bool"""
    return _openshot.__lt__(*args)

def __gt__(*args):
    r"""__gt__(Profile l, Profile r) -> bool"""
    return _openshot.__gt__(*args)

def __eq__(*args):
    r"""__eq__(Profile l, Profile r) -> bool"""
    return _openshot.__eq__(*args)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(QtHtmlReader self) -> QtHtmlReader
        __init__(QtHtmlReader self, int width, int height, int x_offset, int y_offset, openshot::GravityType gravity, std::string html, std::string css, std::string background_color) -> QtHtmlReader
        """
        _openshot.QtHtmlReader_swiginit(self, _openshot.new_QtHtmlReader(*args))

    def Close(self, *args):
        r"""Close(QtHtmlReader self)"""
        return _openshot.QtHtmlReader_Close(self, *args)

    def GetCache(self, *args):
        r"""GetCache(QtHtmlReader self) -> CacheBase"""
        return _openshot.QtHtmlReader_GetCache(self, *args)

    def GetFrame(self, *args):
        r"""GetFrame(QtHtmlReader self, int64_t requested_frame) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.QtHtmlReader_GetFrame(self, *args)

    def IsOpen(self, *args):
        r"""IsOpen(QtHtmlReader self) -> bool"""
        return _openshot.QtHtmlReader_IsOpen(self, *args)

    def Name(self, *args):
        r"""Name(QtHtmlReader self) -> std::string"""
        return _openshot.QtHtmlReader_Name(self, *args)

    def Json(self, *args):
        r"""Json(QtHtmlReader self) -> std::string"""
        return _openshot.QtHtmlReader_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(QtHtmlReader self, std::string const value)"""
        return _openshot.QtHtmlReader_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(QtHtmlReader self) -> Json::Value"""
        return _openshot.QtHtmlReader_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(QtHtmlReader self, Json::Value const root)"""
        return _openshot.QtHtmlReader_SetJsonValue(self, *args)

    def Open(self, *args):
        r"""Open(QtHtmlReader self)"""
        return _openshot.QtHtmlReader_Open(self, *args)
    __swig_destroy__ = _openshot.delete_QtHtmlReader

# Register QtHtmlReader in _openshot:
_openshot.QtHtmlReader_swigregister(QtHtmlReader)
class QtImageReader(ReaderBase):
    r"""Proxy of C++ openshot::QtImageReader class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(QtImageReader self, std::string path, bool inspect_reader=True) -> QtImageReader"""
        _openshot.QtImageReader_swiginit(self, _openshot.new_QtImageReader(*args))
    __swig_destroy__ = _openshot.delete_QtImageReader

    def Close(self, *args):
        r"""Close(QtImageReader self)"""
        return _openshot.QtImageReader_Close(self, *args)

    def GetCache(self, *args):
        r"""GetCache(QtImageReader self) -> CacheBase"""
        return _openshot.QtImageReader_GetCache(self, *args)

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

    def IsOpen(self, *args):
        r"""IsOpen(QtImageReader self) -> bool"""
        return _openshot.QtImageReader_IsOpen(self, *args)

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

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

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

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

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

    def Open(self, *args):
        r"""Open(QtImageReader self)"""
        return _openshot.QtImageReader_Open(self, *args)

# Register QtImageReader in _openshot:
_openshot.QtImageReader_swigregister(QtImageReader)
class QtPlayer(PlayerBase):
    r"""Proxy of C++ openshot::QtPlayer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(QtPlayer self) -> QtPlayer
        __init__(QtPlayer self, RendererBase rb) -> QtPlayer
        """
        _openshot.QtPlayer_swiginit(self, _openshot.new_QtPlayer(*args))
    __swig_destroy__ = _openshot.delete_QtPlayer

    def CloseAudioDevice(self, *args):
        r"""CloseAudioDevice(QtPlayer self)"""
        return _openshot.QtPlayer_CloseAudioDevice(self, *args)

    def GetError(self, *args):
        r"""GetError(QtPlayer self) -> std::string"""
        return _openshot.QtPlayer_GetError(self, *args)

    def GetDefaultSampleRate(self, *args):
        r"""GetDefaultSampleRate(QtPlayer self) -> double"""
        return _openshot.QtPlayer_GetDefaultSampleRate(self, *args)

    def GetAudioDeviceNames(self, *args):
        r"""GetAudioDeviceNames(QtPlayer self) -> openshot::AudioDeviceList"""
        return _openshot.QtPlayer_GetAudioDeviceNames(self, *args)

    def GetCurrentAudioDevice(self, *args):
        r"""GetCurrentAudioDevice(QtPlayer self) -> AudioDeviceInfo"""
        return _openshot.QtPlayer_GetCurrentAudioDevice(self, *args)

    def Play(self, *args):
        r"""Play(QtPlayer self)"""
        return _openshot.QtPlayer_Play(self, *args)

    def Loading(self, *args):
        r"""Loading(QtPlayer self)"""
        return _openshot.QtPlayer_Loading(self, *args)

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

    def Pause(self, *args):
        r"""Pause(QtPlayer self)"""
        return _openshot.QtPlayer_Pause(self, *args)

    def Position(self, *args):
        r"""Position(QtPlayer self) -> int64_t"""
        return _openshot.QtPlayer_Position(self, *args)

    def Seek(self, *args):
        r"""
        Seek(QtPlayer self, int64_t new_frame)
        Seek(QtPlayer self, int64_t new_frame, bool start_preroll)
        """
        return _openshot.QtPlayer_Seek(self, *args)

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

    def SetTimelineSource(self, *args):
        r"""SetTimelineSource(QtPlayer self, std::string const & json)"""
        return _openshot.QtPlayer_SetTimelineSource(self, *args)

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

    def GetRendererQObject(self, *args):
        r"""GetRendererQObject(QtPlayer self) -> int64_t"""
        return _openshot.QtPlayer_GetRendererQObject(self, *args)

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

    def Stop(self, *args):
        r"""Stop(QtPlayer self)"""
        return _openshot.QtPlayer_Stop(self, *args)

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

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

# Register QtPlayer in _openshot:
_openshot.QtPlayer_swigregister(QtPlayer)
class QtTextReader(ReaderBase):
    r"""Proxy of C++ openshot::QtTextReader class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(QtTextReader self) -> QtTextReader
        __init__(QtTextReader self, int width, int height, int x_offset, int y_offset, openshot::GravityType gravity, std::string text, QFont font, std::string text_color, std::string background_color) -> QtTextReader
        """
        _openshot.QtTextReader_swiginit(self, _openshot.new_QtTextReader(*args))

    def SetTextBackgroundColor(self, *args):
        r"""SetTextBackgroundColor(QtTextReader self, std::string color)"""
        return _openshot.QtTextReader_SetTextBackgroundColor(self, *args)

    def Close(self, *args):
        r"""Close(QtTextReader self)"""
        return _openshot.QtTextReader_Close(self, *args)

    def GetCache(self, *args):
        r"""GetCache(QtTextReader self) -> CacheBase"""
        return _openshot.QtTextReader_GetCache(self, *args)

    def GetFrame(self, *args):
        r"""GetFrame(QtTextReader self, int64_t requested_frame) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.QtTextReader_GetFrame(self, *args)

    def IsOpen(self, *args):
        r"""IsOpen(QtTextReader self) -> bool"""
        return _openshot.QtTextReader_IsOpen(self, *args)

    def Name(self, *args):
        r"""Name(QtTextReader self) -> std::string"""
        return _openshot.QtTextReader_Name(self, *args)

    def Json(self, *args):
        r"""Json(QtTextReader self) -> std::string"""
        return _openshot.QtTextReader_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(QtTextReader self, std::string const value)"""
        return _openshot.QtTextReader_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(QtTextReader self) -> Json::Value"""
        return _openshot.QtTextReader_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(QtTextReader self, Json::Value const root)"""
        return _openshot.QtTextReader_SetJsonValue(self, *args)

    def Open(self, *args):
        r"""Open(QtTextReader self)"""
        return _openshot.QtTextReader_Open(self, *args)
    __swig_destroy__ = _openshot.delete_QtTextReader

# Register QtTextReader in _openshot:
_openshot.QtTextReader_swigregister(QtTextReader)

def IsPointBeforeX(*args):
    r"""IsPointBeforeX(Point p, double const x) -> bool"""
    return _openshot.IsPointBeforeX(*args)

def InterpolateLinearCurve(*args):
    r"""InterpolateLinearCurve(Point left, Point right, double const target) -> double"""
    return _openshot.InterpolateLinearCurve(*args)

def InterpolateBezierCurve(*args):
    r"""InterpolateBezierCurve(Point left, Point right, double const target, double const allowed_error) -> double"""
    return _openshot.InterpolateBezierCurve(*args)

def InterpolateBetween(*args):
    r"""InterpolateBetween(Point left, Point right, double target, double allowed_error) -> double"""
    return _openshot.InterpolateBetween(*args)
class Keyframe(object):
    r"""Proxy of C++ openshot::Keyframe class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(Keyframe self) -> Keyframe
        __init__(Keyframe self, double value) -> Keyframe
        __init__(Keyframe self, PointsVector points) -> Keyframe
        """
        _openshot.Keyframe_swiginit(self, _openshot.new_Keyframe(*args))
    __swig_destroy__ = _openshot.delete_Keyframe

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

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

    def FlipPoints(self, *args):
        r"""FlipPoints(Keyframe self)"""
        return _openshot.Keyframe_FlipPoints(self, *args)

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

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

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

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

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

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

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

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

    def GetMaxPoint(self, *args):
        r"""GetMaxPoint(Keyframe self) -> Point"""
        return _openshot.Keyframe_GetMaxPoint(self, *args)

    def GetLength(self, *args):
        r"""GetLength(Keyframe self) -> int64_t"""
        return _openshot.Keyframe_GetLength(self, *args)

    def GetCount(self, *args):
        r"""GetCount(Keyframe self) -> int64_t"""
        return _openshot.Keyframe_GetCount(self, *args)

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

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

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

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

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

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

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

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

    def PrintPoints(self, *args):
        r"""PrintPoints(Keyframe self, std::ostream * out=&std::cout)"""
        return _openshot.Keyframe_PrintPoints(self, *args)

    def PrintValues(self, *args):
        r"""PrintValues(Keyframe self, std::ostream * out=&std::cout)"""
        return _openshot.Keyframe_PrintValues(self, *args)

# Register Keyframe in _openshot:
_openshot.Keyframe_swigregister(Keyframe)
class RendererBase(object):
    r"""Proxy of C++ openshot::RendererBase class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

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

# Register RendererBase in _openshot:
_openshot.RendererBase_swigregister(RendererBase)
class Settings(object):
    r"""Proxy of C++ openshot::Settings class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    HARDWARE_DECODER = property(_openshot.Settings_HARDWARE_DECODER_get, _openshot.Settings_HARDWARE_DECODER_set, doc=r"""HARDWARE_DECODER : int""")
    HIGH_QUALITY_SCALING = property(_openshot.Settings_HIGH_QUALITY_SCALING_get, _openshot.Settings_HIGH_QUALITY_SCALING_set, doc=r"""HIGH_QUALITY_SCALING : bool""")
    OMP_THREADS = property(_openshot.Settings_OMP_THREADS_get, _openshot.Settings_OMP_THREADS_set, doc=r"""OMP_THREADS : int""")
    FF_THREADS = property(_openshot.Settings_FF_THREADS_get, _openshot.Settings_FF_THREADS_set, doc=r"""FF_THREADS : int""")
    CACHE_MIN_FRAMES = property(_openshot.Settings_CACHE_MIN_FRAMES_get, _openshot.Settings_CACHE_MIN_FRAMES_set, doc=r"""CACHE_MIN_FRAMES : int""")
    DE_LIMIT_HEIGHT_MAX = property(_openshot.Settings_DE_LIMIT_HEIGHT_MAX_get, _openshot.Settings_DE_LIMIT_HEIGHT_MAX_set, doc=r"""DE_LIMIT_HEIGHT_MAX : int""")
    DE_LIMIT_WIDTH_MAX = property(_openshot.Settings_DE_LIMIT_WIDTH_MAX_get, _openshot.Settings_DE_LIMIT_WIDTH_MAX_set, doc=r"""DE_LIMIT_WIDTH_MAX : int""")
    HW_DE_DEVICE_SET = property(_openshot.Settings_HW_DE_DEVICE_SET_get, _openshot.Settings_HW_DE_DEVICE_SET_set, doc=r"""HW_DE_DEVICE_SET : int""")
    HW_EN_DEVICE_SET = property(_openshot.Settings_HW_EN_DEVICE_SET_get, _openshot.Settings_HW_EN_DEVICE_SET_set, doc=r"""HW_EN_DEVICE_SET : int""")
    VIDEO_CACHE_PERCENT_AHEAD = property(_openshot.Settings_VIDEO_CACHE_PERCENT_AHEAD_get, _openshot.Settings_VIDEO_CACHE_PERCENT_AHEAD_set, doc=r"""VIDEO_CACHE_PERCENT_AHEAD : float""")
    VIDEO_CACHE_MIN_PREROLL_FRAMES = property(_openshot.Settings_VIDEO_CACHE_MIN_PREROLL_FRAMES_get, _openshot.Settings_VIDEO_CACHE_MIN_PREROLL_FRAMES_set, doc=r"""VIDEO_CACHE_MIN_PREROLL_FRAMES : int""")
    VIDEO_CACHE_MAX_PREROLL_FRAMES = property(_openshot.Settings_VIDEO_CACHE_MAX_PREROLL_FRAMES_get, _openshot.Settings_VIDEO_CACHE_MAX_PREROLL_FRAMES_set, doc=r"""VIDEO_CACHE_MAX_PREROLL_FRAMES : int""")
    VIDEO_CACHE_MAX_FRAMES = property(_openshot.Settings_VIDEO_CACHE_MAX_FRAMES_get, _openshot.Settings_VIDEO_CACHE_MAX_FRAMES_set, doc=r"""VIDEO_CACHE_MAX_FRAMES : int""")
    ENABLE_PLAYBACK_CACHING = property(_openshot.Settings_ENABLE_PLAYBACK_CACHING_get, _openshot.Settings_ENABLE_PLAYBACK_CACHING_set, doc=r"""ENABLE_PLAYBACK_CACHING : bool""")
    PLAYBACK_AUDIO_DEVICE_NAME = property(_openshot.Settings_PLAYBACK_AUDIO_DEVICE_NAME_get, _openshot.Settings_PLAYBACK_AUDIO_DEVICE_NAME_set, doc=r"""PLAYBACK_AUDIO_DEVICE_NAME : std::string""")
    PLAYBACK_AUDIO_DEVICE_TYPE = property(_openshot.Settings_PLAYBACK_AUDIO_DEVICE_TYPE_get, _openshot.Settings_PLAYBACK_AUDIO_DEVICE_TYPE_set, doc=r"""PLAYBACK_AUDIO_DEVICE_TYPE : std::string""")
    PLAYBACK_AUDIO_BUFFER_SIZE = property(_openshot.Settings_PLAYBACK_AUDIO_BUFFER_SIZE_get, _openshot.Settings_PLAYBACK_AUDIO_BUFFER_SIZE_set, doc=r"""PLAYBACK_AUDIO_BUFFER_SIZE : int""")
    PATH_OPENSHOT_INSTALL = property(_openshot.Settings_PATH_OPENSHOT_INSTALL_get, _openshot.Settings_PATH_OPENSHOT_INSTALL_set, doc=r"""PATH_OPENSHOT_INSTALL : std::string""")
    DEBUG_TO_STDERR = property(_openshot.Settings_DEBUG_TO_STDERR_get, _openshot.Settings_DEBUG_TO_STDERR_set, doc=r"""DEBUG_TO_STDERR : bool""")

    def EffectiveOMPThreads(self, *args):
        r"""EffectiveOMPThreads(Settings self) -> int"""
        return _openshot.Settings_EffectiveOMPThreads(self, *args)

    def MaxAllowedThreads(self, *args):
        r"""MaxAllowedThreads(Settings self) -> int"""
        return _openshot.Settings_MaxAllowedThreads(self, *args)

    def DefaultOMPThreads(self, *args):
        r"""DefaultOMPThreads(Settings self) -> int"""
        return _openshot.Settings_DefaultOMPThreads(self, *args)

    def DefaultFFThreads(self, *args):
        r"""DefaultFFThreads(Settings self) -> int"""
        return _openshot.Settings_DefaultFFThreads(self, *args)

    def ApplyOpenMPSettings(self, *args):
        r"""ApplyOpenMPSettings(Settings self)"""
        return _openshot.Settings_ApplyOpenMPSettings(self, *args)

    @staticmethod
    def Instance(*args):
        r"""Instance() -> Settings"""
        return _openshot.Settings_Instance(*args)
    __swig_destroy__ = _openshot.delete_Settings

# Register Settings in _openshot:
_openshot.Settings_swigregister(Settings)
class TimelineInfoStruct(object):
    r"""Proxy of C++ openshot::TimelineInfoStruct class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    is_top_clip = property(_openshot.TimelineInfoStruct_is_top_clip_get, _openshot.TimelineInfoStruct_is_top_clip_set, doc=r"""is_top_clip : bool""")
    is_before_clip_keyframes = property(_openshot.TimelineInfoStruct_is_before_clip_keyframes_get, _openshot.TimelineInfoStruct_is_before_clip_keyframes_set, doc=r"""is_before_clip_keyframes : bool""")

    def __init__(self, *args):
        r"""__init__(TimelineInfoStruct self) -> TimelineInfoStruct"""
        _openshot.TimelineInfoStruct_swiginit(self, _openshot.new_TimelineInfoStruct(*args))
    __swig_destroy__ = _openshot.delete_TimelineInfoStruct

# Register TimelineInfoStruct in _openshot:
_openshot.TimelineInfoStruct_swigregister(TimelineInfoStruct)
class TimelineBase(object):
    r"""Proxy of C++ openshot::TimelineBase class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    preview_width = property(_openshot.TimelineBase_preview_width_get, _openshot.TimelineBase_preview_width_set, doc=r"""preview_width : int""")
    preview_height = property(_openshot.TimelineBase_preview_height_get, _openshot.TimelineBase_preview_height_set, doc=r"""preview_height : int""")

    def Clips(self, *args):
        r"""Clips(TimelineBase self) -> ClipList"""
        return _openshot.TimelineBase_Clips(self, *args)
    __swig_destroy__ = _openshot.delete_TimelineBase

# Register TimelineBase in _openshot:
_openshot.TimelineBase_swigregister(TimelineBase)
class VideoCacheThread(object):
    r"""Proxy of C++ openshot::VideoCacheThread class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(VideoCacheThread self) -> VideoCacheThread"""
        _openshot.VideoCacheThread_swiginit(self, _openshot.new_VideoCacheThread(*args))
    __swig_destroy__ = _openshot.delete_VideoCacheThread

    def isReady(self, *args):
        r"""isReady(VideoCacheThread self) -> bool"""
        return _openshot.VideoCacheThread_isReady(self, *args)

    def Play(self, *args):
        r"""Play(VideoCacheThread self)"""
        return _openshot.VideoCacheThread_Play(self, *args)

    def Stop(self, *args):
        r"""Stop(VideoCacheThread self)"""
        return _openshot.VideoCacheThread_Stop(self, *args)

    def setSpeed(self, *args):
        r"""setSpeed(VideoCacheThread self, int new_speed)"""
        return _openshot.VideoCacheThread_setSpeed(self, *args)

    def getSpeed(self, *args):
        r"""getSpeed(VideoCacheThread self) -> int"""
        return _openshot.VideoCacheThread_getSpeed(self, *args)

    def Seek(self, *args):
        r"""
        Seek(VideoCacheThread self, int64_t new_position)
        Seek(VideoCacheThread self, int64_t new_position, bool start_preroll)
        """
        return _openshot.VideoCacheThread_Seek(self, *args)

    def NotifyPlaybackPosition(self, *args):
        r"""NotifyPlaybackPosition(VideoCacheThread self, int64_t new_position)"""
        return _openshot.VideoCacheThread_NotifyPlaybackPosition(self, *args)

    def StartThread(self, *args):
        r"""StartThread(VideoCacheThread self) -> bool"""
        return _openshot.VideoCacheThread_StartThread(self, *args)

    def StopThread(self, *args):
        r"""StopThread(VideoCacheThread self, int timeoutMs=0) -> bool"""
        return _openshot.VideoCacheThread_StopThread(self, *args)

    def Reader(self, *args):
        r"""Reader(VideoCacheThread self, ReaderBase new_reader)"""
        return _openshot.VideoCacheThread_Reader(self, *args)

# Register VideoCacheThread in _openshot:
_openshot.VideoCacheThread_swigregister(VideoCacheThread)
class CompareClips(object):
    r"""Proxy of C++ openshot::CompareClips class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

    def __init__(self, *args):
        r"""__init__(CompareClips self) -> CompareClips"""
        _openshot.CompareClips_swiginit(self, _openshot.new_CompareClips(*args))
    __swig_destroy__ = _openshot.delete_CompareClips

# Register CompareClips in _openshot:
_openshot.CompareClips_swigregister(CompareClips)
class CompareEffects(object):
    r"""Proxy of C++ openshot::CompareEffects class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

    def __init__(self, *args):
        r"""__init__(CompareEffects self) -> CompareEffects"""
        _openshot.CompareEffects_swiginit(self, _openshot.new_CompareEffects(*args))
    __swig_destroy__ = _openshot.delete_CompareEffects

# Register CompareEffects in _openshot:
_openshot.CompareEffects_swigregister(CompareEffects)
class CompareClipEndFrames(object):
    r"""Proxy of C++ openshot::CompareClipEndFrames class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __call__(self, *args):
        r"""__call__(CompareClipEndFrames self, Clip lhs, Clip rhs) -> bool"""
        return _openshot.CompareClipEndFrames___call__(self, *args)

    def __init__(self, *args):
        r"""__init__(CompareClipEndFrames self) -> CompareClipEndFrames"""
        _openshot.CompareClipEndFrames_swiginit(self, _openshot.new_CompareClipEndFrames(*args))
    __swig_destroy__ = _openshot.delete_CompareClipEndFrames

# Register CompareClipEndFrames in _openshot:
_openshot.CompareClipEndFrames_swigregister(CompareClipEndFrames)
class CompareEffectEndFrames(object):
    r"""Proxy of C++ openshot::CompareEffectEndFrames class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __call__(self, *args):
        r"""__call__(CompareEffectEndFrames self, EffectBase lhs, EffectBase rhs) -> bool"""
        return _openshot.CompareEffectEndFrames___call__(self, *args)

    def __init__(self, *args):
        r"""__init__(CompareEffectEndFrames self) -> CompareEffectEndFrames"""
        _openshot.CompareEffectEndFrames_swiginit(self, _openshot.new_CompareEffectEndFrames(*args))
    __swig_destroy__ = _openshot.delete_CompareEffectEndFrames

# Register CompareEffectEndFrames in _openshot:
_openshot.CompareEffectEndFrames_swigregister(CompareEffectEndFrames)
class Timeline(TimelineBase, ReaderBase):
    r"""Proxy of C++ openshot::Timeline class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(Timeline self, int width, int height, Fraction fps, int sample_rate, int channels, openshot::ChannelLayout channel_layout) -> Timeline
        __init__(Timeline self, ReaderInfo info) -> Timeline
        __init__(Timeline self, std::string const & projectPath, bool convert_absolute_paths) -> Timeline
        """
        _openshot.Timeline_swiginit(self, _openshot.new_Timeline(*args))
    __swig_destroy__ = _openshot.delete_Timeline

    def AddTrackedObject(self, *args):
        r"""AddTrackedObject(Timeline self, std::shared_ptr< openshot::TrackedObjectBase > trackedObject)"""
        return _openshot.Timeline_AddTrackedObject(self, *args)

    def GetTrackedObject(self, *args):
        r"""GetTrackedObject(Timeline self, std::string id) -> std::shared_ptr< openshot::TrackedObjectBase >"""
        return _openshot.Timeline_GetTrackedObject(self, *args)

    def GetTrackedObjectsIds(self, *args):
        r"""GetTrackedObjectsIds(Timeline self) -> std::list< std::string,std::allocator< std::string > >"""
        return _openshot.Timeline_GetTrackedObjectsIds(self, *args)

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

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

    def apply_effects(self, *args):
        r"""apply_effects(Timeline self, std::shared_ptr< openshot::Frame > frame, int64_t timeline_frame_number, int layer, TimelineInfoStruct options) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.Timeline_apply_effects(self, *args)

    def ApplyMapperToClips(self, *args):
        r"""ApplyMapperToClips(Timeline self)"""
        return _openshot.Timeline_ApplyMapperToClips(self, *args)

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

    def Clear(self, *args):
        r"""Clear(Timeline self)"""
        return _openshot.Timeline_Clear(self, *args)

    def ClearAllCache(self, *args):
        r"""ClearAllCache(Timeline self, bool deep=False)"""
        return _openshot.Timeline_ClearAllCache(self, *args)

    def Clips(self, *args):
        r"""Clips(Timeline self) -> ClipList"""
        return _openshot.Timeline_Clips(self, *args)

    def GetClip(self, *args):
        r"""GetClip(Timeline self, std::string const & id) -> Clip"""
        return _openshot.Timeline_GetClip(self, *args)

    def GetClipEffect(self, *args):
        r"""GetClipEffect(Timeline self, std::string const & id) -> EffectBase"""
        return _openshot.Timeline_GetClipEffect(self, *args)

    def GetEffect(self, *args):
        r"""GetEffect(Timeline self, std::string const & id) -> EffectBase"""
        return _openshot.Timeline_GetEffect(self, *args)

    def GetMaxTime(self, *args):
        r"""GetMaxTime(Timeline self) -> double"""
        return _openshot.Timeline_GetMaxTime(self, *args)

    def GetMaxFrame(self, *args):
        r"""GetMaxFrame(Timeline self) -> int64_t"""
        return _openshot.Timeline_GetMaxFrame(self, *args)

    def GetMinTime(self, *args):
        r"""GetMinTime(Timeline self) -> double"""
        return _openshot.Timeline_GetMinTime(self, *args)

    def GetMinFrame(self, *args):
        r"""GetMinFrame(Timeline self) -> int64_t"""
        return _openshot.Timeline_GetMinFrame(self, *args)

    def Close(self, *args):
        r"""Close(Timeline self)"""
        return _openshot.Timeline_Close(self, *args)

    def Effects(self, *args):
        r"""Effects(Timeline self) -> EffectBaseList"""
        return _openshot.Timeline_Effects(self, *args)

    def ClipEffects(self, *args):
        r"""ClipEffects(Timeline self) -> EffectBaseList"""
        return _openshot.Timeline_ClipEffects(self, *args)

    def GetCache(self, *args):
        r"""GetCache(Timeline self) -> CacheBase"""
        return _openshot.Timeline_GetCache(self, *args)

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

    def CacheEpoch(self, *args):
        r"""CacheEpoch(Timeline self) -> uint64_t"""
        return _openshot.Timeline_CacheEpoch(self, *args)

    def GetFrame(self, *args):
        r"""GetFrame(Timeline self, int64_t requested_frame) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.Timeline_GetFrame(self, *args)
    viewport_scale = property(_openshot.Timeline_viewport_scale_get, _openshot.Timeline_viewport_scale_set, doc=r"""viewport_scale : openshot::Keyframe""")
    viewport_x = property(_openshot.Timeline_viewport_x_get, _openshot.Timeline_viewport_x_set, doc=r"""viewport_x : openshot::Keyframe""")
    viewport_y = property(_openshot.Timeline_viewport_y_get, _openshot.Timeline_viewport_y_set, doc=r"""viewport_y : openshot::Keyframe""")
    color = property(_openshot.Timeline_color_get, _openshot.Timeline_color_set, doc=r"""color : openshot::Color""")

    def IsOpen(self, *args):
        r"""IsOpen(Timeline self) -> bool"""
        return _openshot.Timeline_IsOpen(self, *args)

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

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

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

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

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

    def SetMaxSize(self, *args):
        r"""SetMaxSize(Timeline self, int width, int height)"""
        return _openshot.Timeline_SetMaxSize(self, *args)

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

    def Open(self, *args):
        r"""Open(Timeline self)"""
        return _openshot.Timeline_Open(self, *args)

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

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

    def SortTimeline(self, *args):
        r"""SortTimeline(Timeline self)"""
        return _openshot.Timeline_SortTimeline(self, *args)

# Register Timeline in _openshot:
_openshot.Timeline_swigregister(Timeline)
class ZmqLogger(object):
    r"""Proxy of C++ openshot::ZmqLogger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def Instance(*args):
        r"""Instance() -> ZmqLogger"""
        return _openshot.ZmqLogger_Instance(*args)

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

    def Close(self, *args):
        r"""Close(ZmqLogger self)"""
        return _openshot.ZmqLogger_Close(self, *args)

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

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

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

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

    def LogToFile(self, *args):
        r"""LogToFile(ZmqLogger self, std::string message)"""
        return _openshot.ZmqLogger_LogToFile(self, *args)
    __swig_destroy__ = _openshot.delete_ZmqLogger

# Register ZmqLogger in _openshot:
_openshot.ZmqLogger_swigregister(ZmqLogger)
class ImageReader(ReaderBase):
    r"""Proxy of C++ openshot::ImageReader class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(ImageReader self, std::string const & path, bool inspect_reader=True) -> ImageReader"""
        _openshot.ImageReader_swiginit(self, _openshot.new_ImageReader(*args))

    def Close(self, *args):
        r"""Close(ImageReader self)"""
        return _openshot.ImageReader_Close(self, *args)

    def GetCache(self, *args):
        r"""GetCache(ImageReader self) -> CacheBase"""
        return _openshot.ImageReader_GetCache(self, *args)

    def GetFrame(self, *args):
        r"""GetFrame(ImageReader self, int64_t requested_frame) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.ImageReader_GetFrame(self, *args)

    def IsOpen(self, *args):
        r"""IsOpen(ImageReader self) -> bool"""
        return _openshot.ImageReader_IsOpen(self, *args)

    def Name(self, *args):
        r"""Name(ImageReader self) -> std::string"""
        return _openshot.ImageReader_Name(self, *args)

    def Json(self, *args):
        r"""Json(ImageReader self) -> std::string"""
        return _openshot.ImageReader_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(ImageReader self, std::string const value)"""
        return _openshot.ImageReader_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(ImageReader self) -> Json::Value"""
        return _openshot.ImageReader_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(ImageReader self, Json::Value const root)"""
        return _openshot.ImageReader_SetJsonValue(self, *args)

    def Open(self, *args):
        r"""Open(ImageReader self)"""
        return _openshot.ImageReader_Open(self, *args)
    __swig_destroy__ = _openshot.delete_ImageReader

# Register ImageReader in _openshot:
_openshot.ImageReader_swigregister(ImageReader)
class ImageWriter(WriterBase):
    r"""Proxy of C++ openshot::ImageWriter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(ImageWriter self, std::string path) -> ImageWriter"""
        _openshot.ImageWriter_swiginit(self, _openshot.new_ImageWriter(*args))

    def Close(self, *args):
        r"""Close(ImageWriter self)"""
        return _openshot.ImageWriter_Close(self, *args)

    def GetCacheSize(self, *args):
        r"""GetCacheSize(ImageWriter self) -> int"""
        return _openshot.ImageWriter_GetCacheSize(self, *args)

    def IsOpen(self, *args):
        r"""IsOpen(ImageWriter self) -> bool"""
        return _openshot.ImageWriter_IsOpen(self, *args)

    def Open(self, *args):
        r"""Open(ImageWriter self)"""
        return _openshot.ImageWriter_Open(self, *args)

    def SetCacheSize(self, *args):
        r"""SetCacheSize(ImageWriter self, int new_size)"""
        return _openshot.ImageWriter_SetCacheSize(self, *args)

    def SetVideoOptions(self, *args):
        r"""SetVideoOptions(ImageWriter self, std::string format, Fraction fps, int width, int height, int quality, int loops, bool combine)"""
        return _openshot.ImageWriter_SetVideoOptions(self, *args)

    def WriteFrame(self, *args):
        r"""
        WriteFrame(ImageWriter self, std::shared_ptr< openshot::Frame > frame)
        WriteFrame(ImageWriter self, ReaderBase reader, int64_t start, int64_t length)
        """
        return _openshot.ImageWriter_WriteFrame(self, *args)
    __swig_destroy__ = _openshot.delete_ImageWriter

# Register ImageWriter in _openshot:
_openshot.ImageWriter_swigregister(ImageWriter)
class TextReader(ReaderBase):
    r"""Proxy of C++ openshot::TextReader class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(TextReader self) -> TextReader
        __init__(TextReader self, int width, int height, int x_offset, int y_offset, openshot::GravityType gravity, std::string text, std::string font, double size, std::string text_color, std::string background_color) -> TextReader
        """
        _openshot.TextReader_swiginit(self, _openshot.new_TextReader(*args))

    def SetTextBackgroundColor(self, *args):
        r"""SetTextBackgroundColor(TextReader self, std::string color)"""
        return _openshot.TextReader_SetTextBackgroundColor(self, *args)

    def Close(self, *args):
        r"""Close(TextReader self)"""
        return _openshot.TextReader_Close(self, *args)

    def GetCache(self, *args):
        r"""GetCache(TextReader self) -> CacheBase"""
        return _openshot.TextReader_GetCache(self, *args)

    def GetFrame(self, *args):
        r"""GetFrame(TextReader self, int64_t requested_frame) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.TextReader_GetFrame(self, *args)

    def IsOpen(self, *args):
        r"""IsOpen(TextReader self) -> bool"""
        return _openshot.TextReader_IsOpen(self, *args)

    def Name(self, *args):
        r"""Name(TextReader self) -> std::string"""
        return _openshot.TextReader_Name(self, *args)

    def Json(self, *args):
        r"""Json(TextReader self) -> std::string"""
        return _openshot.TextReader_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(TextReader self, std::string const value)"""
        return _openshot.TextReader_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(TextReader self) -> Json::Value"""
        return _openshot.TextReader_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(TextReader self, Json::Value const root)"""
        return _openshot.TextReader_SetJsonValue(self, *args)

    def Open(self, *args):
        r"""Open(TextReader self)"""
        return _openshot.TextReader_Open(self, *args)
    __swig_destroy__ = _openshot.delete_TextReader

# Register TextReader in _openshot:
_openshot.TextReader_swigregister(TextReader)
class Bars(EffectBase):
    r"""Proxy of C++ openshot::Bars class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    color = property(_openshot.Bars_color_get, _openshot.Bars_color_set, doc=r"""color : openshot::Color""")
    left = property(_openshot.Bars_left_get, _openshot.Bars_left_set, doc=r"""left : openshot::Keyframe""")
    top = property(_openshot.Bars_top_get, _openshot.Bars_top_set, doc=r"""top : openshot::Keyframe""")
    right = property(_openshot.Bars_right_get, _openshot.Bars_right_set, doc=r"""right : openshot::Keyframe""")
    bottom = property(_openshot.Bars_bottom_get, _openshot.Bars_bottom_set, doc=r"""bottom : openshot::Keyframe""")

    def __init__(self, *args):
        r"""
        __init__(Bars self) -> Bars
        __init__(Bars self, Color color, Keyframe left, Keyframe top, Keyframe right, Keyframe bottom) -> Bars
        """
        _openshot.Bars_swiginit(self, _openshot.new_Bars(*args))

    def GetFrame(self, *args):
        r"""
        GetFrame(Bars self, int64_t frame_number) -> std::shared_ptr< openshot::Frame >
        GetFrame(Bars self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >
        """
        return _openshot.Bars_GetFrame(self, *args)

    def Json(self, *args):
        r"""Json(Bars self) -> std::string"""
        return _openshot.Bars_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Bars self, std::string const value)"""
        return _openshot.Bars_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Bars self) -> Json::Value"""
        return _openshot.Bars_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Bars self, Json::Value const root)"""
        return _openshot.Bars_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Bars self, int64_t requested_frame) -> std::string"""
        return _openshot.Bars_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_Bars

# Register Bars in _openshot:
_openshot.Bars_swigregister(Bars)
BLUR_MASK_POST_BLEND = _openshot.BLUR_MASK_POST_BLEND

BLUR_MASK_DRIVE_AMOUNT = _openshot.BLUR_MASK_DRIVE_AMOUNT

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    horizontal_radius = property(_openshot.Blur_horizontal_radius_get, _openshot.Blur_horizontal_radius_set, doc=r"""horizontal_radius : openshot::Keyframe""")
    vertical_radius = property(_openshot.Blur_vertical_radius_get, _openshot.Blur_vertical_radius_set, doc=r"""vertical_radius : openshot::Keyframe""")
    sigma = property(_openshot.Blur_sigma_get, _openshot.Blur_sigma_set, doc=r"""sigma : openshot::Keyframe""")
    iterations = property(_openshot.Blur_iterations_get, _openshot.Blur_iterations_set, doc=r"""iterations : openshot::Keyframe""")
    mask_mode = property(_openshot.Blur_mask_mode_get, _openshot.Blur_mask_mode_set, doc=r"""mask_mode : int""")

    def __init__(self, *args):
        r"""
        __init__(Blur self) -> Blur
        __init__(Blur self, Keyframe new_horizontal_radius, Keyframe new_vertical_radius, Keyframe new_sigma, Keyframe new_iterations) -> Blur
        """
        _openshot.Blur_swiginit(self, _openshot.new_Blur(*args))

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

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

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

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

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

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Blur self, int64_t requested_frame) -> std::string"""
        return _openshot.Blur_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_Blur

# Register Blur in _openshot:
_openshot.Blur_swigregister(Blur)
BRIGHTNESS_MASK_LIMIT_TO_AREA = _openshot.BRIGHTNESS_MASK_LIMIT_TO_AREA

BRIGHTNESS_MASK_VARY_STRENGTH = _openshot.BRIGHTNESS_MASK_VARY_STRENGTH

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    brightness = property(_openshot.Brightness_brightness_get, _openshot.Brightness_brightness_set, doc=r"""brightness : openshot::Keyframe""")
    contrast = property(_openshot.Brightness_contrast_get, _openshot.Brightness_contrast_set, doc=r"""contrast : openshot::Keyframe""")
    mask_mode = property(_openshot.Brightness_mask_mode_get, _openshot.Brightness_mask_mode_set, doc=r"""mask_mode : int""")

    def __init__(self, *args):
        r"""
        __init__(Brightness self) -> Brightness
        __init__(Brightness self, Keyframe new_brightness, Keyframe new_contrast) -> Brightness
        """
        _openshot.Brightness_swiginit(self, _openshot.new_Brightness(*args))

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

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

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

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

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

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Brightness self, int64_t requested_frame) -> std::string"""
        return _openshot.Brightness_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_Brightness

# Register Brightness in _openshot:
_openshot.Brightness_swigregister(Brightness)
class Caption(EffectBase):
    r"""Proxy of C++ openshot::Caption class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    color = property(_openshot.Caption_color_get, _openshot.Caption_color_set, doc=r"""color : openshot::Color""")
    stroke = property(_openshot.Caption_stroke_get, _openshot.Caption_stroke_set, doc=r"""stroke : openshot::Color""")
    background = property(_openshot.Caption_background_get, _openshot.Caption_background_set, doc=r"""background : openshot::Color""")
    background_alpha = property(_openshot.Caption_background_alpha_get, _openshot.Caption_background_alpha_set, doc=r"""background_alpha : openshot::Keyframe""")
    background_corner = property(_openshot.Caption_background_corner_get, _openshot.Caption_background_corner_set, doc=r"""background_corner : openshot::Keyframe""")
    background_padding = property(_openshot.Caption_background_padding_get, _openshot.Caption_background_padding_set, doc=r"""background_padding : openshot::Keyframe""")
    stroke_width = property(_openshot.Caption_stroke_width_get, _openshot.Caption_stroke_width_set, doc=r"""stroke_width : openshot::Keyframe""")
    font_size = property(_openshot.Caption_font_size_get, _openshot.Caption_font_size_set, doc=r"""font_size : openshot::Keyframe""")
    font_alpha = property(_openshot.Caption_font_alpha_get, _openshot.Caption_font_alpha_set, doc=r"""font_alpha : openshot::Keyframe""")
    line_spacing = property(_openshot.Caption_line_spacing_get, _openshot.Caption_line_spacing_set, doc=r"""line_spacing : openshot::Keyframe""")
    left = property(_openshot.Caption_left_get, _openshot.Caption_left_set, doc=r"""left : openshot::Keyframe""")
    top = property(_openshot.Caption_top_get, _openshot.Caption_top_set, doc=r"""top : openshot::Keyframe""")
    right = property(_openshot.Caption_right_get, _openshot.Caption_right_set, doc=r"""right : openshot::Keyframe""")
    fade_in = property(_openshot.Caption_fade_in_get, _openshot.Caption_fade_in_set, doc=r"""fade_in : openshot::Keyframe""")
    fade_out = property(_openshot.Caption_fade_out_get, _openshot.Caption_fade_out_set, doc=r"""fade_out : openshot::Keyframe""")
    font_name = property(_openshot.Caption_font_name_get, _openshot.Caption_font_name_set, doc=r"""font_name : std::string""")

    def __init__(self, *args):
        r"""
        __init__(Caption self) -> Caption
        __init__(Caption self, std::string captions) -> Caption
        """
        _openshot.Caption_swiginit(self, _openshot.new_Caption(*args))

    def GetFrame(self, *args):
        r"""
        GetFrame(Caption self, int64_t frame_number) -> std::shared_ptr< openshot::Frame >
        GetFrame(Caption self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >
        """
        return _openshot.Caption_GetFrame(self, *args)

    def CaptionText(self, *args):
        r"""
        CaptionText(Caption self) -> std::string
        CaptionText(Caption self, std::string new_caption_text)
        """
        return _openshot.Caption_CaptionText(self, *args)

    def Json(self, *args):
        r"""Json(Caption self) -> std::string"""
        return _openshot.Caption_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Caption self, std::string const value)"""
        return _openshot.Caption_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Caption self) -> Json::Value"""
        return _openshot.Caption_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Caption self, Json::Value const root)"""
        return _openshot.Caption_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Caption self, int64_t requested_frame) -> std::string"""
        return _openshot.Caption_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_Caption

# Register Caption in _openshot:
_openshot.Caption_swigregister(Caption)
class ChromaKey(EffectBase):
    r"""Proxy of C++ openshot::ChromaKey class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(ChromaKey self) -> ChromaKey
        __init__(ChromaKey self, Color color, Keyframe fuzz, Keyframe halo=0.0, openshot::ChromaKeyMethod method=CHROMAKEY_BASIC_SOFT) -> ChromaKey
        """
        _openshot.ChromaKey_swiginit(self, _openshot.new_ChromaKey(*args))

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

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

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

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

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

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(ChromaKey self, int64_t requested_frame) -> std::string"""
        return _openshot.ChromaKey_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_ChromaKey

# Register ChromaKey in _openshot:
_openshot.ChromaKey_swigregister(ChromaKey)
class ColorMap(EffectBase):
    r"""Proxy of C++ openshot::ColorMap class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    intensity = property(_openshot.ColorMap_intensity_get, _openshot.ColorMap_intensity_set, doc=r"""intensity : openshot::Keyframe""")
    intensity_r = property(_openshot.ColorMap_intensity_r_get, _openshot.ColorMap_intensity_r_set, doc=r"""intensity_r : openshot::Keyframe""")
    intensity_g = property(_openshot.ColorMap_intensity_g_get, _openshot.ColorMap_intensity_g_set, doc=r"""intensity_g : openshot::Keyframe""")
    intensity_b = property(_openshot.ColorMap_intensity_b_get, _openshot.ColorMap_intensity_b_set, doc=r"""intensity_b : openshot::Keyframe""")

    def __init__(self, *args):
        r"""
        __init__(ColorMap self) -> ColorMap
        __init__(ColorMap self, std::string const & path, Keyframe i=openshot::Keyframe(1.0), Keyframe iR=openshot::Keyframe(1.0), Keyframe iG=openshot::Keyframe(1.0), Keyframe iB=openshot::Keyframe(1.0)) -> ColorMap
        """
        _openshot.ColorMap_swiginit(self, _openshot.new_ColorMap(*args))

    def GetFrame(self, *args):
        r"""
        GetFrame(ColorMap self, int64_t frame_number) -> std::shared_ptr< openshot::Frame >
        GetFrame(ColorMap self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >
        """
        return _openshot.ColorMap_GetFrame(self, *args)

    def Json(self, *args):
        r"""Json(ColorMap self) -> std::string"""
        return _openshot.ColorMap_Json(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(ColorMap self) -> Json::Value"""
        return _openshot.ColorMap_JsonValue(self, *args)

    def SetJson(self, *args):
        r"""SetJson(ColorMap self, std::string const value)"""
        return _openshot.ColorMap_SetJson(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(ColorMap self, Json::Value const root)"""
        return _openshot.ColorMap_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(ColorMap self, int64_t requested_frame) -> std::string"""
        return _openshot.ColorMap_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_ColorMap

# Register ColorMap in _openshot:
_openshot.ColorMap_swigregister(ColorMap)
class ColorShift(EffectBase):
    r"""Proxy of C++ openshot::ColorShift class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    red_x = property(_openshot.ColorShift_red_x_get, _openshot.ColorShift_red_x_set, doc=r"""red_x : openshot::Keyframe""")
    red_y = property(_openshot.ColorShift_red_y_get, _openshot.ColorShift_red_y_set, doc=r"""red_y : openshot::Keyframe""")
    green_x = property(_openshot.ColorShift_green_x_get, _openshot.ColorShift_green_x_set, doc=r"""green_x : openshot::Keyframe""")
    green_y = property(_openshot.ColorShift_green_y_get, _openshot.ColorShift_green_y_set, doc=r"""green_y : openshot::Keyframe""")
    blue_x = property(_openshot.ColorShift_blue_x_get, _openshot.ColorShift_blue_x_set, doc=r"""blue_x : openshot::Keyframe""")
    blue_y = property(_openshot.ColorShift_blue_y_get, _openshot.ColorShift_blue_y_set, doc=r"""blue_y : openshot::Keyframe""")
    alpha_x = property(_openshot.ColorShift_alpha_x_get, _openshot.ColorShift_alpha_x_set, doc=r"""alpha_x : openshot::Keyframe""")
    alpha_y = property(_openshot.ColorShift_alpha_y_get, _openshot.ColorShift_alpha_y_set, doc=r"""alpha_y : openshot::Keyframe""")

    def __init__(self, *args):
        r"""
        __init__(ColorShift self) -> ColorShift
        __init__(ColorShift self, Keyframe red_x, Keyframe red_y, Keyframe green_x, Keyframe green_y, Keyframe blue_x, Keyframe blue_y, Keyframe alpha_x, Keyframe alpha_y) -> ColorShift
        """
        _openshot.ColorShift_swiginit(self, _openshot.new_ColorShift(*args))

    def GetFrame(self, *args):
        r"""
        GetFrame(ColorShift self, int64_t frame_number) -> std::shared_ptr< openshot::Frame >
        GetFrame(ColorShift self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >
        """
        return _openshot.ColorShift_GetFrame(self, *args)

    def Json(self, *args):
        r"""Json(ColorShift self) -> std::string"""
        return _openshot.ColorShift_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(ColorShift self, std::string const value)"""
        return _openshot.ColorShift_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(ColorShift self) -> Json::Value"""
        return _openshot.ColorShift_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(ColorShift self, Json::Value const root)"""
        return _openshot.ColorShift_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(ColorShift self, int64_t requested_frame) -> std::string"""
        return _openshot.ColorShift_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_ColorShift

# Register ColorShift in _openshot:
_openshot.ColorShift_swigregister(ColorShift)
class Crop(EffectBase):
    r"""Proxy of C++ openshot::Crop class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    left = property(_openshot.Crop_left_get, _openshot.Crop_left_set, doc=r"""left : openshot::Keyframe""")
    top = property(_openshot.Crop_top_get, _openshot.Crop_top_set, doc=r"""top : openshot::Keyframe""")
    right = property(_openshot.Crop_right_get, _openshot.Crop_right_set, doc=r"""right : openshot::Keyframe""")
    bottom = property(_openshot.Crop_bottom_get, _openshot.Crop_bottom_set, doc=r"""bottom : openshot::Keyframe""")
    x = property(_openshot.Crop_x_get, _openshot.Crop_x_set, doc=r"""x : openshot::Keyframe""")
    y = property(_openshot.Crop_y_get, _openshot.Crop_y_set, doc=r"""y : openshot::Keyframe""")
    resize = property(_openshot.Crop_resize_get, _openshot.Crop_resize_set, doc=r"""resize : bool""")

    def __init__(self, *args):
        r"""
        __init__(Crop self) -> Crop
        __init__(Crop self, Keyframe left, Keyframe top, Keyframe right, Keyframe bottom, Keyframe x=0.0, Keyframe y=0.0) -> Crop
        """
        _openshot.Crop_swiginit(self, _openshot.new_Crop(*args))

    def GetFrame(self, *args):
        r"""
        GetFrame(Crop self, int64_t frame_number) -> std::shared_ptr< openshot::Frame >
        GetFrame(Crop self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >
        """
        return _openshot.Crop_GetFrame(self, *args)

    def Json(self, *args):
        r"""Json(Crop self) -> std::string"""
        return _openshot.Crop_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Crop self, std::string const value)"""
        return _openshot.Crop_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Crop self) -> Json::Value"""
        return _openshot.Crop_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Crop self, Json::Value const root)"""
        return _openshot.Crop_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Crop self, int64_t requested_frame) -> std::string"""
        return _openshot.Crop_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_Crop

# Register Crop in _openshot:
_openshot.Crop_swigregister(Crop)
class Deinterlace(EffectBase):
    r"""Proxy of C++ openshot::Deinterlace class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(Deinterlace self) -> Deinterlace
        __init__(Deinterlace self, bool isOdd) -> Deinterlace
        """
        _openshot.Deinterlace_swiginit(self, _openshot.new_Deinterlace(*args))

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

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

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

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

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

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Deinterlace self, int64_t requested_frame) -> std::string"""
        return _openshot.Deinterlace_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_Deinterlace

# Register Deinterlace in _openshot:
_openshot.Deinterlace_swigregister(Deinterlace)
HUE_MASK_LIMIT_TO_AREA = _openshot.HUE_MASK_LIMIT_TO_AREA

HUE_MASK_VARY_STRENGTH = _openshot.HUE_MASK_VARY_STRENGTH

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    hue = property(_openshot.Hue_hue_get, _openshot.Hue_hue_set, doc=r"""hue : openshot::Keyframe""")
    mask_mode = property(_openshot.Hue_mask_mode_get, _openshot.Hue_mask_mode_set, doc=r"""mask_mode : int""")

    def __init__(self, *args):
        r"""
        __init__(Hue self) -> Hue
        __init__(Hue self, Keyframe hue) -> Hue
        """
        _openshot.Hue_swiginit(self, _openshot.new_Hue(*args))

    def GetFrame(self, *args):
        r"""
        GetFrame(Hue self, int64_t frame_number) -> std::shared_ptr< openshot::Frame >
        GetFrame(Hue self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >
        """
        return _openshot.Hue_GetFrame(self, *args)

    def Json(self, *args):
        r"""Json(Hue self) -> std::string"""
        return _openshot.Hue_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Hue self, std::string const value)"""
        return _openshot.Hue_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Hue self) -> Json::Value"""
        return _openshot.Hue_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Hue self, Json::Value const root)"""
        return _openshot.Hue_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Hue self, int64_t requested_frame) -> std::string"""
        return _openshot.Hue_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_Hue

# Register Hue in _openshot:
_openshot.Hue_swigregister(Hue)
class LensFlare(EffectBase):
    r"""Proxy of C++ openshot::LensFlare class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    x = property(_openshot.LensFlare_x_get, _openshot.LensFlare_x_set, doc=r"""x : openshot::Keyframe""")
    y = property(_openshot.LensFlare_y_get, _openshot.LensFlare_y_set, doc=r"""y : openshot::Keyframe""")
    brightness = property(_openshot.LensFlare_brightness_get, _openshot.LensFlare_brightness_set, doc=r"""brightness : openshot::Keyframe""")
    size = property(_openshot.LensFlare_size_get, _openshot.LensFlare_size_set, doc=r"""size : openshot::Keyframe""")
    spread = property(_openshot.LensFlare_spread_get, _openshot.LensFlare_spread_set, doc=r"""spread : openshot::Keyframe""")
    color = property(_openshot.LensFlare_color_get, _openshot.LensFlare_color_set, doc=r"""color : openshot::Color""")
    __swig_destroy__ = _openshot.delete_LensFlare

    def __init__(self, *args):
        r"""
        __init__(LensFlare self) -> LensFlare
        __init__(LensFlare self, Keyframe xPos, Keyframe yPos, Keyframe intensity, Keyframe scale, Keyframe spreadVal, Keyframe bladeCount, Keyframe shapeType, Color tint=openshot::Color("#ffffff")) -> LensFlare
        """
        _openshot.LensFlare_swiginit(self, _openshot.new_LensFlare(*args))

    def GetFrame(self, *args):
        r"""
        GetFrame(LensFlare self, int64_t frame_number) -> std::shared_ptr< openshot::Frame >
        GetFrame(LensFlare self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >
        """
        return _openshot.LensFlare_GetFrame(self, *args)

    def Json(self, *args):
        r"""Json(LensFlare self) -> std::string"""
        return _openshot.LensFlare_Json(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(LensFlare self) -> Json::Value"""
        return _openshot.LensFlare_JsonValue(self, *args)

    def SetJson(self, *args):
        r"""SetJson(LensFlare self, std::string const value)"""
        return _openshot.LensFlare_SetJson(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(LensFlare self, Json::Value const root)"""
        return _openshot.LensFlare_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(LensFlare self, int64_t requested_frame) -> std::string"""
        return _openshot.LensFlare_PropertiesJSON(self, *args)

# Register LensFlare in _openshot:
_openshot.LensFlare_swigregister(LensFlare)
class Mask(EffectBase):
    r"""Proxy of C++ openshot::Mask class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    replace_image = property(_openshot.Mask_replace_image_get, _openshot.Mask_replace_image_set, doc=r"""replace_image : bool""")
    fade_audio_hint = property(_openshot.Mask_fade_audio_hint_get, _openshot.Mask_fade_audio_hint_set, doc=r"""fade_audio_hint : bool""")
    brightness = property(_openshot.Mask_brightness_get, _openshot.Mask_brightness_set, doc=r"""brightness : openshot::Keyframe""")
    contrast = property(_openshot.Mask_contrast_get, _openshot.Mask_contrast_set, doc=r"""contrast : openshot::Keyframe""")

    def __init__(self, *args):
        r"""
        __init__(Mask self) -> Mask
        __init__(Mask self, ReaderBase mask_reader, Keyframe mask_brightness, Keyframe mask_contrast) -> Mask
        """
        _openshot.Mask_swiginit(self, _openshot.new_Mask(*args))

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

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

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

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

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

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

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

# Register Mask in _openshot:
_openshot.Mask_swigregister(Mask)
class Negate(EffectBase):
    r"""Proxy of C++ openshot::Negate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(Negate self) -> Negate"""
        _openshot.Negate_swiginit(self, _openshot.new_Negate(*args))

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

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

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

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

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

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Negate self, int64_t requested_frame) -> std::string"""
        return _openshot.Negate_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_Negate

# Register Negate in _openshot:
_openshot.Negate_swigregister(Negate)
PIXELATE_MASK_LIMIT_TO_AREA = _openshot.PIXELATE_MASK_LIMIT_TO_AREA

PIXELATE_MASK_VARY_STRENGTH = _openshot.PIXELATE_MASK_VARY_STRENGTH

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    pixelization = property(_openshot.Pixelate_pixelization_get, _openshot.Pixelate_pixelization_set, doc=r"""pixelization : openshot::Keyframe""")
    left = property(_openshot.Pixelate_left_get, _openshot.Pixelate_left_set, doc=r"""left : openshot::Keyframe""")
    top = property(_openshot.Pixelate_top_get, _openshot.Pixelate_top_set, doc=r"""top : openshot::Keyframe""")
    right = property(_openshot.Pixelate_right_get, _openshot.Pixelate_right_set, doc=r"""right : openshot::Keyframe""")
    bottom = property(_openshot.Pixelate_bottom_get, _openshot.Pixelate_bottom_set, doc=r"""bottom : openshot::Keyframe""")
    mask_mode = property(_openshot.Pixelate_mask_mode_get, _openshot.Pixelate_mask_mode_set, doc=r"""mask_mode : int""")

    def __init__(self, *args):
        r"""
        __init__(Pixelate self) -> Pixelate
        __init__(Pixelate self, Keyframe pixelization, Keyframe left, Keyframe top, Keyframe right, Keyframe bottom) -> Pixelate
        """
        _openshot.Pixelate_swiginit(self, _openshot.new_Pixelate(*args))

    def GetFrame(self, *args):
        r"""
        GetFrame(Pixelate self, int64_t frame_number) -> std::shared_ptr< openshot::Frame >
        GetFrame(Pixelate self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >
        """
        return _openshot.Pixelate_GetFrame(self, *args)

    def Json(self, *args):
        r"""Json(Pixelate self) -> std::string"""
        return _openshot.Pixelate_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Pixelate self, std::string const value)"""
        return _openshot.Pixelate_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Pixelate self) -> Json::Value"""
        return _openshot.Pixelate_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Pixelate self, Json::Value const root)"""
        return _openshot.Pixelate_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Pixelate self, int64_t requested_frame) -> std::string"""
        return _openshot.Pixelate_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_Pixelate

# Register Pixelate in _openshot:
_openshot.Pixelate_swigregister(Pixelate)
SATURATION_MASK_POST_BLEND = _openshot.SATURATION_MASK_POST_BLEND

SATURATION_MASK_DRIVE_AMOUNT = _openshot.SATURATION_MASK_DRIVE_AMOUNT

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    saturation = property(_openshot.Saturation_saturation_get, _openshot.Saturation_saturation_set, doc=r"""saturation : openshot::Keyframe""")
    saturation_R = property(_openshot.Saturation_saturation_R_get, _openshot.Saturation_saturation_R_set, doc=r"""saturation_R : openshot::Keyframe""")
    saturation_G = property(_openshot.Saturation_saturation_G_get, _openshot.Saturation_saturation_G_set, doc=r"""saturation_G : openshot::Keyframe""")
    saturation_B = property(_openshot.Saturation_saturation_B_get, _openshot.Saturation_saturation_B_set, doc=r"""saturation_B : openshot::Keyframe""")
    mask_mode = property(_openshot.Saturation_mask_mode_get, _openshot.Saturation_mask_mode_set, doc=r"""mask_mode : int""")

    def __init__(self, *args):
        r"""
        __init__(Saturation self) -> Saturation
        __init__(Saturation self, Keyframe saturation, Keyframe saturation_R, Keyframe saturation_G, Keyframe saturation_B) -> Saturation
        """
        _openshot.Saturation_swiginit(self, _openshot.new_Saturation(*args))

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

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

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

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

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

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Saturation self, int64_t requested_frame) -> std::string"""
        return _openshot.Saturation_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_Saturation

# Register Saturation in _openshot:
_openshot.Saturation_swigregister(Saturation)
SHARPEN_MASK_LIMIT_TO_AREA = _openshot.SHARPEN_MASK_LIMIT_TO_AREA

SHARPEN_MASK_VARY_STRENGTH = _openshot.SHARPEN_MASK_VARY_STRENGTH

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    amount = property(_openshot.Sharpen_amount_get, _openshot.Sharpen_amount_set, doc=r"""amount : openshot::Keyframe""")
    radius = property(_openshot.Sharpen_radius_get, _openshot.Sharpen_radius_set, doc=r"""radius : openshot::Keyframe""")
    threshold = property(_openshot.Sharpen_threshold_get, _openshot.Sharpen_threshold_set, doc=r"""threshold : openshot::Keyframe""")
    mode = property(_openshot.Sharpen_mode_get, _openshot.Sharpen_mode_set, doc=r"""mode : int""")
    channel = property(_openshot.Sharpen_channel_get, _openshot.Sharpen_channel_set, doc=r"""channel : int""")
    mask_mode = property(_openshot.Sharpen_mask_mode_get, _openshot.Sharpen_mask_mode_set, doc=r"""mask_mode : int""")

    def __init__(self, *args):
        r"""
        __init__(Sharpen self) -> Sharpen
        __init__(Sharpen self, Keyframe new_amount, Keyframe new_radius, Keyframe new_threshold) -> Sharpen
        """
        _openshot.Sharpen_swiginit(self, _openshot.new_Sharpen(*args))

    def GetFrame(self, *args):
        r"""
        GetFrame(Sharpen self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >
        GetFrame(Sharpen self, int64_t n) -> std::shared_ptr< openshot::Frame >
        """
        return _openshot.Sharpen_GetFrame(self, *args)

    def Json(self, *args):
        r"""Json(Sharpen self) -> std::string"""
        return _openshot.Sharpen_Json(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Sharpen self) -> Json::Value"""
        return _openshot.Sharpen_JsonValue(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Sharpen self, std::string const value)"""
        return _openshot.Sharpen_SetJson(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Sharpen self, Json::Value const root)"""
        return _openshot.Sharpen_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Sharpen self, int64_t requested_frame) -> std::string"""
        return _openshot.Sharpen_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_Sharpen

# Register Sharpen in _openshot:
_openshot.Sharpen_swigregister(Sharpen)
class Shift(EffectBase):
    r"""Proxy of C++ openshot::Shift class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    x = property(_openshot.Shift_x_get, _openshot.Shift_x_set, doc=r"""x : openshot::Keyframe""")
    y = property(_openshot.Shift_y_get, _openshot.Shift_y_set, doc=r"""y : openshot::Keyframe""")

    def __init__(self, *args):
        r"""
        __init__(Shift self) -> Shift
        __init__(Shift self, Keyframe x, Keyframe y) -> Shift
        """
        _openshot.Shift_swiginit(self, _openshot.new_Shift(*args))

    def GetFrame(self, *args):
        r"""
        GetFrame(Shift self, int64_t frame_number) -> std::shared_ptr< openshot::Frame >
        GetFrame(Shift self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >
        """
        return _openshot.Shift_GetFrame(self, *args)

    def Json(self, *args):
        r"""Json(Shift self) -> std::string"""
        return _openshot.Shift_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Shift self, std::string const value)"""
        return _openshot.Shift_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Shift self) -> Json::Value"""
        return _openshot.Shift_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Shift self, Json::Value const root)"""
        return _openshot.Shift_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Shift self, int64_t requested_frame) -> std::string"""
        return _openshot.Shift_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_Shift

# Register Shift in _openshot:
_openshot.Shift_swigregister(Shift)
class Wave(EffectBase):
    r"""Proxy of C++ openshot::Wave class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    wavelength = property(_openshot.Wave_wavelength_get, _openshot.Wave_wavelength_set, doc=r"""wavelength : openshot::Keyframe""")
    amplitude = property(_openshot.Wave_amplitude_get, _openshot.Wave_amplitude_set, doc=r"""amplitude : openshot::Keyframe""")
    multiplier = property(_openshot.Wave_multiplier_get, _openshot.Wave_multiplier_set, doc=r"""multiplier : openshot::Keyframe""")
    shift_x = property(_openshot.Wave_shift_x_get, _openshot.Wave_shift_x_set, doc=r"""shift_x : openshot::Keyframe""")
    speed_y = property(_openshot.Wave_speed_y_get, _openshot.Wave_speed_y_set, doc=r"""speed_y : openshot::Keyframe""")

    def __init__(self, *args):
        r"""
        __init__(Wave self) -> Wave
        __init__(Wave self, Keyframe wavelength, Keyframe amplitude, Keyframe multiplier, Keyframe shift_x, Keyframe speed_y) -> Wave
        """
        _openshot.Wave_swiginit(self, _openshot.new_Wave(*args))

    def GetFrame(self, *args):
        r"""
        GetFrame(Wave self, int64_t frame_number) -> std::shared_ptr< openshot::Frame >
        GetFrame(Wave self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >
        """
        return _openshot.Wave_GetFrame(self, *args)

    def Json(self, *args):
        r"""Json(Wave self) -> std::string"""
        return _openshot.Wave_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Wave self, std::string const value)"""
        return _openshot.Wave_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Wave self) -> Json::Value"""
        return _openshot.Wave_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Wave self, Json::Value const root)"""
        return _openshot.Wave_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Wave self, int64_t requested_frame) -> std::string"""
        return _openshot.Wave_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_Wave

# Register Wave in _openshot:
_openshot.Wave_swigregister(Wave)

