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

package mlt;
use base qw(Exporter);
use base qw(DynaLoader);
package mltc;
bootstrap mlt;
package mlt;
@EXPORT = qw();

# ---------- BASE METHODS -------------

package mlt;

sub TIEHASH {
    my ($classname,$obj) = @_;
    return bless $obj, $classname;
}

sub CLEAR { }

sub FIRSTKEY { }

sub NEXTKEY { }

sub FETCH {
    my ($self,$field) = @_;
    my $member_func = "swig_${field}_get";
    $self->$member_func();
}

sub STORE {
    my ($self,$field,$newval) = @_;
    my $member_func = "swig_${field}_set";
    $self->$member_func($newval);
}

sub this {
    my $ptr = shift;
    return tied(%$ptr);
}


# ------- FUNCTION WRAPPERS --------

package mlt;

*mlt_factory_init = *mltc::mlt_factory_init;
*mlt_factory_repository = *mltc::mlt_factory_repository;
*mlt_factory_directory = *mltc::mlt_factory_directory;
*mlt_environment = *mltc::mlt_environment;
*mlt_environment_set = *mltc::mlt_environment_set;
*mlt_factory_event_object = *mltc::mlt_factory_event_object;
*mlt_factory_producer = *mltc::mlt_factory_producer;
*mlt_factory_filter = *mltc::mlt_factory_filter;
*mlt_factory_transition = *mltc::mlt_factory_transition;
*mlt_factory_consumer = *mltc::mlt_factory_consumer;
*mlt_factory_register_for_clean_up = *mltc::mlt_factory_register_for_clean_up;
*mlt_factory_close = *mltc::mlt_factory_close;
*mlt_global_properties = *mltc::mlt_global_properties;
*mlt_version_get_int = *mltc::mlt_version_get_int;
*mlt_version_get_major = *mltc::mlt_version_get_major;
*mlt_version_get_minor = *mltc::mlt_version_get_minor;
*mlt_version_get_revision = *mltc::mlt_version_get_revision;
*mlt_version_get_string = *mltc::mlt_version_get_string;
*mlt_log_get_level = *mltc::mlt_log_get_level;
*mlt_log_set_level = *mltc::mlt_log_set_level;

############# Class : mlt::UnsignedCharArray ##############

package mlt::UnsignedCharArray;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( mlt );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mltc::new_UnsignedCharArray(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mltc::delete_UnsignedCharArray($self);
        delete $OWNER{$self};
    }
}

*getitem = *mltc::UnsignedCharArray_getitem;
*setitem = *mltc::UnsignedCharArray_setitem;
*cast = *mltc::UnsignedCharArray_cast;
*frompointer = *mltc::UnsignedCharArray_frompointer;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mlt::mlt_rect ##############

package mlt::mlt_rect;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( mlt );
%OWNER = ();
%ITERATORS = ();
*swig_x_get = *mltc::mlt_rect_x_get;
*swig_x_set = *mltc::mlt_rect_x_set;
*swig_y_get = *mltc::mlt_rect_y_get;
*swig_y_set = *mltc::mlt_rect_y_set;
*swig_w_get = *mltc::mlt_rect_w_get;
*swig_w_set = *mltc::mlt_rect_w_set;
*swig_h_get = *mltc::mlt_rect_h_get;
*swig_h_set = *mltc::mlt_rect_h_set;
*swig_o_get = *mltc::mlt_rect_o_get;
*swig_o_set = *mltc::mlt_rect_o_set;
sub new {
    my $pkg = shift;
    my $self = mltc::new_mlt_rect(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mltc::delete_mlt_rect($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mlt::mlt_color ##############

package mlt::mlt_color;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( mlt );
%OWNER = ();
%ITERATORS = ();
*swig_r_get = *mltc::mlt_color_r_get;
*swig_r_set = *mltc::mlt_color_r_set;
*swig_g_get = *mltc::mlt_color_g_get;
*swig_g_set = *mltc::mlt_color_g_set;
*swig_b_get = *mltc::mlt_color_b_get;
*swig_b_set = *mltc::mlt_color_b_set;
*swig_a_get = *mltc::mlt_color_a_get;
*swig_a_set = *mltc::mlt_color_a_set;
sub new {
    my $pkg = shift;
    my $self = mltc::new_mlt_color(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mltc::delete_mlt_color($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mlt::Factory ##############

package mlt::Factory;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( mlt );
%OWNER = ();
%ITERATORS = ();
*init = *mltc::Factory_init;
*event_object = *mltc::Factory_event_object;
*producer = *mltc::Factory_producer;
*filter = *mltc::Factory_filter;
*transition = *mltc::Factory_transition;
*consumer = *mltc::Factory_consumer;
*close = *mltc::Factory_close;
sub new {
    my $pkg = shift;
    my $self = mltc::new_Factory(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mltc::delete_Factory($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mlt::Repository ##############

package mlt::Repository;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( mlt );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mltc::new_Repository(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mltc::delete_Repository($self);
        delete $OWNER{$self};
    }
}

*register_service = *mltc::Repository_register_service;
*create = *mltc::Repository_create;
*consumers = *mltc::Repository_consumers;
*filters = *mltc::Repository_filters;
*producers = *mltc::Repository_producers;
*transitions = *mltc::Repository_transitions;
*register_metadata = *mltc::Repository_register_metadata;
*metadata = *mltc::Repository_metadata;
*languages = *mltc::Repository_languages;
*presets = *mltc::Repository_presets;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mlt::Event ##############

package mlt::Event;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( mlt );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mltc::new_Event(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mltc::delete_Event($self);
        delete $OWNER{$self};
    }
}

*get_event = *mltc::Event_get_event;
*is_valid = *mltc::Event_is_valid;
*block = *mltc::Event_block;
*unblock = *mltc::Event_unblock;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mlt::Properties ##############

package mlt::Properties;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( mlt );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mltc::new_Properties(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mltc::delete_Properties($self);
        delete $OWNER{$self};
    }
}

*get_properties = *mltc::Properties_get_properties;
*inc_ref = *mltc::Properties_inc_ref;
*dec_ref = *mltc::Properties_dec_ref;
*ref_count = *mltc::Properties_ref_count;
*lock = *mltc::Properties_lock;
*unlock = *mltc::Properties_unlock;
*block = *mltc::Properties_block;
*unblock = *mltc::Properties_unblock;
*fire_event = *mltc::Properties_fire_event;
*is_valid = *mltc::Properties_is_valid;
*count = *mltc::Properties_count;
*get_int = *mltc::Properties_get_int;
*get_int64 = *mltc::Properties_get_int64;
*get_double = *mltc::Properties_get_double;
*pass_property = *mltc::Properties_pass_property;
*pass_values = *mltc::Properties_pass_values;
*pass_list = *mltc::Properties_pass_list;
*parse = *mltc::Properties_parse;
*get_name = *mltc::Properties_get_name;
*get = *mltc::Properties_get;
*get_data = *mltc::Properties_get_data;
*mirror = *mltc::Properties_mirror;
*inherit = *mltc::Properties_inherit;
*rename = *mltc::Properties_rename;
*dump = *mltc::Properties_dump;
*debug = *mltc::Properties_debug;
*load = *mltc::Properties_load;
*save = *mltc::Properties_save;
*listen = *mltc::Properties_listen;
*delete_event = *mltc::Properties_delete_event;
*setup_wait_for = *mltc::Properties_setup_wait_for;
*wait_for = *mltc::Properties_wait_for;
*is_sequence = *mltc::Properties_is_sequence;
*parse_yaml = *mltc::Properties_parse_yaml;
*serialise_yaml = *mltc::Properties_serialise_yaml;
*preset = *mltc::Properties_preset;
*set_lcnumeric = *mltc::Properties_set_lcnumeric;
*get_lcnumeric = *mltc::Properties_get_lcnumeric;
*clear = *mltc::Properties_clear;
*get_time = *mltc::Properties_get_time;
*frames_to_time = *mltc::Properties_frames_to_time;
*time_to_frames = *mltc::Properties_time_to_frames;
*get_color = *mltc::Properties_get_color;
*anim_get = *mltc::Properties_anim_get;
*anim_get_int = *mltc::Properties_anim_get_int;
*anim_get_double = *mltc::Properties_anim_get_double;
*set = *mltc::Properties_set;
*get_rect = *mltc::Properties_get_rect;
*anim_set = *mltc::Properties_anim_set;
*anim_get_rect = *mltc::Properties_anim_get_rect;
*get_animation = *mltc::Properties_get_animation;
*get_anim = *mltc::Properties_get_anim;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mlt::Frame ##############

package mlt::Frame;
use overload
    "=" => sub { my $class = ref($_[0]); $class->new($_[0]) },
    "fallback" => 1;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( mlt::Properties mlt );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mltc::new_Frame(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mltc::delete_Frame($self);
        delete $OWNER{$self};
    }
}

*__assign__ = *mltc::Frame___assign__;
*get_frame = *mltc::Frame_get_frame;
*get_properties = *mltc::Frame_get_properties;
*get_image = *mltc::Frame_get_image;
*fetch_image = *mltc::Frame_fetch_image;
*get_audio = *mltc::Frame_get_audio;
*get_waveform = *mltc::Frame_get_waveform;
*get_original_producer = *mltc::Frame_get_original_producer;
*get_position = *mltc::Frame_get_position;
*get_unique_properties = *mltc::Frame_get_unique_properties;
*set_image = *mltc::Frame_set_image;
*set_alpha = *mltc::Frame_set_alpha;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mlt::GeometryItem ##############

package mlt::GeometryItem;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( mlt );
%OWNER = ();
%ITERATORS = ();
*get_item = *mltc::GeometryItem_get_item;
*key = *mltc::GeometryItem_key;
*frame = *mltc::GeometryItem_frame;
*x = *mltc::GeometryItem_x;
*y = *mltc::GeometryItem_y;
*w = *mltc::GeometryItem_w;
*h = *mltc::GeometryItem_h;
*mix = *mltc::GeometryItem_mix;
sub new {
    my $pkg = shift;
    my $self = mltc::new_GeometryItem(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mltc::delete_GeometryItem($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mlt::Geometry ##############

package mlt::Geometry;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( mlt );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mltc::new_Geometry(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mltc::delete_Geometry($self);
        delete $OWNER{$self};
    }
}

*parse = *mltc::Geometry_parse;
*fetch = *mltc::Geometry_fetch;
*insert = *mltc::Geometry_insert;
*remove = *mltc::Geometry_remove;
*interpolate = *mltc::Geometry_interpolate;
*next_key = *mltc::Geometry_next_key;
*prev_key = *mltc::Geometry_prev_key;
*serialise = *mltc::Geometry_serialise;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mlt::Service ##############

package mlt::Service;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( mlt::Properties mlt );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mltc::new_Service(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mltc::delete_Service($self);
        delete $OWNER{$self};
    }
}

*get_service = *mltc::Service_get_service;
*lock = *mltc::Service_lock;
*unlock = *mltc::Service_unlock;
*get_properties = *mltc::Service_get_properties;
*connect_producer = *mltc::Service_connect_producer;
*insert_producer = *mltc::Service_insert_producer;
*disconnect_producer = *mltc::Service_disconnect_producer;
*disconnect_all_producers = *mltc::Service_disconnect_all_producers;
*consumer = *mltc::Service_consumer;
*producer = *mltc::Service_producer;
*profile = *mltc::Service_profile;
*get_profile = *mltc::Service_get_profile;
*get_frame = *mltc::Service_get_frame;
*type = *mltc::Service_type;
*attach = *mltc::Service_attach;
*detach = *mltc::Service_detach;
*filter_count = *mltc::Service_filter_count;
*move_filter = *mltc::Service_move_filter;
*filter = *mltc::Service_filter;
*set_profile = *mltc::Service_set_profile;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mlt::Producer ##############

package mlt::Producer;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( mlt::Service mlt );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mltc::new_Producer(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mltc::delete_Producer($self);
        delete $OWNER{$self};
    }
}

*get_producer = *mltc::Producer_get_producer;
*parent = *mltc::Producer_parent;
*get_parent = *mltc::Producer_get_parent;
*get_service = *mltc::Producer_get_service;
*seek = *mltc::Producer_seek;
*position = *mltc::Producer_position;
*frame = *mltc::Producer_frame;
*frame_time = *mltc::Producer_frame_time;
*set_speed = *mltc::Producer_set_speed;
*pause = *mltc::Producer_pause;
*get_speed = *mltc::Producer_get_speed;
*get_fps = *mltc::Producer_get_fps;
*set_in_and_out = *mltc::Producer_set_in_and_out;
*get_in = *mltc::Producer_get_in;
*get_out = *mltc::Producer_get_out;
*get_length = *mltc::Producer_get_length;
*get_length_time = *mltc::Producer_get_length_time;
*get_playtime = *mltc::Producer_get_playtime;
*cut = *mltc::Producer_cut;
*is_cut = *mltc::Producer_is_cut;
*is_blank = *mltc::Producer_is_blank;
*same_clip = *mltc::Producer_same_clip;
*runs_into = *mltc::Producer_runs_into;
*optimise = *mltc::Producer_optimise;
*clear = *mltc::Producer_clear;
*get_creation_time = *mltc::Producer_get_creation_time;
*set_creation_time = *mltc::Producer_set_creation_time;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mlt::Profile ##############

package mlt::Profile;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( mlt );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mltc::new_Profile(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mltc::delete_Profile($self);
        delete $OWNER{$self};
    }
}

*is_valid = *mltc::Profile_is_valid;
*get_profile = *mltc::Profile_get_profile;
*description = *mltc::Profile_description;
*frame_rate_num = *mltc::Profile_frame_rate_num;
*frame_rate_den = *mltc::Profile_frame_rate_den;
*fps = *mltc::Profile_fps;
*width = *mltc::Profile_width;
*height = *mltc::Profile_height;
*progressive = *mltc::Profile_progressive;
*sample_aspect_num = *mltc::Profile_sample_aspect_num;
*sample_aspect_den = *mltc::Profile_sample_aspect_den;
*sar = *mltc::Profile_sar;
*display_aspect_num = *mltc::Profile_display_aspect_num;
*display_aspect_den = *mltc::Profile_display_aspect_den;
*dar = *mltc::Profile_dar;
*is_explicit = *mltc::Profile_is_explicit;
*colorspace = *mltc::Profile_colorspace;
*list = *mltc::Profile_list;
*from_producer = *mltc::Profile_from_producer;
*set_width = *mltc::Profile_set_width;
*set_height = *mltc::Profile_set_height;
*set_sample_aspect = *mltc::Profile_set_sample_aspect;
*set_display_aspect = *mltc::Profile_set_display_aspect;
*set_progressive = *mltc::Profile_set_progressive;
*set_colorspace = *mltc::Profile_set_colorspace;
*set_frame_rate = *mltc::Profile_set_frame_rate;
*set_explicit = *mltc::Profile_set_explicit;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mlt::ClipInfo ##############

package mlt::ClipInfo;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( mlt );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mltc::new_ClipInfo(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mltc::delete_ClipInfo($self);
        delete $OWNER{$self};
    }
}

*update = *mltc::ClipInfo_update;
*swig_clip_get = *mltc::ClipInfo_clip_get;
*swig_clip_set = *mltc::ClipInfo_clip_set;
*swig_producer_get = *mltc::ClipInfo_producer_get;
*swig_producer_set = *mltc::ClipInfo_producer_set;
*swig_cut_get = *mltc::ClipInfo_cut_get;
*swig_cut_set = *mltc::ClipInfo_cut_set;
*swig_start_get = *mltc::ClipInfo_start_get;
*swig_start_set = *mltc::ClipInfo_start_set;
*swig_resource_get = *mltc::ClipInfo_resource_get;
*swig_resource_set = *mltc::ClipInfo_resource_set;
*swig_frame_in_get = *mltc::ClipInfo_frame_in_get;
*swig_frame_in_set = *mltc::ClipInfo_frame_in_set;
*swig_frame_out_get = *mltc::ClipInfo_frame_out_get;
*swig_frame_out_set = *mltc::ClipInfo_frame_out_set;
*swig_frame_count_get = *mltc::ClipInfo_frame_count_get;
*swig_frame_count_set = *mltc::ClipInfo_frame_count_set;
*swig_length_get = *mltc::ClipInfo_length_get;
*swig_length_set = *mltc::ClipInfo_length_set;
*swig_fps_get = *mltc::ClipInfo_fps_get;
*swig_fps_set = *mltc::ClipInfo_fps_set;
*swig_repeat_get = *mltc::ClipInfo_repeat_get;
*swig_repeat_set = *mltc::ClipInfo_repeat_set;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mlt::Playlist ##############

package mlt::Playlist;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( mlt::Producer mlt );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mltc::new_Playlist(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mltc::delete_Playlist($self);
        delete $OWNER{$self};
    }
}

*get_playlist = *mltc::Playlist_get_playlist;
*get_producer = *mltc::Playlist_get_producer;
*count = *mltc::Playlist_count;
*clear = *mltc::Playlist_clear;
*append = *mltc::Playlist_append;
*blank = *mltc::Playlist_blank;
*clip = *mltc::Playlist_clip;
*current_clip = *mltc::Playlist_current_clip;
*current = *mltc::Playlist_current;
*clip_info = *mltc::Playlist_clip_info;
*delete_clip_info = *mltc::Playlist_delete_clip_info;
*insert = *mltc::Playlist_insert;
*remove = *mltc::Playlist_remove;
*move = *mltc::Playlist_move;
*reorder = *mltc::Playlist_reorder;
*resize_clip = *mltc::Playlist_resize_clip;
*split = *mltc::Playlist_split;
*split_at = *mltc::Playlist_split_at;
*join = *mltc::Playlist_join;
*mix = *mltc::Playlist_mix;
*mix_in = *mltc::Playlist_mix_in;
*mix_out = *mltc::Playlist_mix_out;
*mix_add = *mltc::Playlist_mix_add;
*repeat = *mltc::Playlist_repeat;
*get_clip = *mltc::Playlist_get_clip;
*get_clip_at = *mltc::Playlist_get_clip_at;
*get_clip_index_at = *mltc::Playlist_get_clip_index_at;
*is_mix = *mltc::Playlist_is_mix;
*is_blank = *mltc::Playlist_is_blank;
*is_blank_at = *mltc::Playlist_is_blank_at;
*consolidate_blanks = *mltc::Playlist_consolidate_blanks;
*replace_with_blank = *mltc::Playlist_replace_with_blank;
*insert_blank = *mltc::Playlist_insert_blank;
*pad_blanks = *mltc::Playlist_pad_blanks;
*insert_at = *mltc::Playlist_insert_at;
*clip_start = *mltc::Playlist_clip_start;
*clip_length = *mltc::Playlist_clip_length;
*blanks_from = *mltc::Playlist_blanks_from;
*remove_region = *mltc::Playlist_remove_region;
*move_region = *mltc::Playlist_move_region;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mlt::Consumer ##############

package mlt::Consumer;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( mlt::Service mlt );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mltc::new_Consumer(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mltc::delete_Consumer($self);
        delete $OWNER{$self};
    }
}

*get_consumer = *mltc::Consumer_get_consumer;
*get_service = *mltc::Consumer_get_service;
*connect = *mltc::Consumer_connect;
*run = *mltc::Consumer_run;
*start = *mltc::Consumer_start;
*purge = *mltc::Consumer_purge;
*stop = *mltc::Consumer_stop;
*is_stopped = *mltc::Consumer_is_stopped;
*position = *mltc::Consumer_position;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mlt::Filter ##############

package mlt::Filter;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( mlt::Service mlt );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mltc::new_Filter(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mltc::delete_Filter($self);
        delete $OWNER{$self};
    }
}

*get_filter = *mltc::Filter_get_filter;
*get_service = *mltc::Filter_get_service;
*connect = *mltc::Filter_connect;
*set_in_and_out = *mltc::Filter_set_in_and_out;
*get_in = *mltc::Filter_get_in;
*get_out = *mltc::Filter_get_out;
*get_length = *mltc::Filter_get_length;
*get_length2 = *mltc::Filter_get_length2;
*get_track = *mltc::Filter_get_track;
*get_position = *mltc::Filter_get_position;
*get_progress = *mltc::Filter_get_progress;
*process = *mltc::Filter_process;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mlt::Transition ##############

package mlt::Transition;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( mlt::Service mlt );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mltc::new_Transition(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mltc::delete_Transition($self);
        delete $OWNER{$self};
    }
}

*get_transition = *mltc::Transition_get_transition;
*get_service = *mltc::Transition_get_service;
*set_in_and_out = *mltc::Transition_set_in_and_out;
*set_tracks = *mltc::Transition_set_tracks;
*connect = *mltc::Transition_connect;
*get_a_track = *mltc::Transition_get_a_track;
*get_b_track = *mltc::Transition_get_b_track;
*get_in = *mltc::Transition_get_in;
*get_out = *mltc::Transition_get_out;
*get_length = *mltc::Transition_get_length;
*get_position = *mltc::Transition_get_position;
*get_progress = *mltc::Transition_get_progress;
*get_progress_delta = *mltc::Transition_get_progress_delta;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mlt::Multitrack ##############

package mlt::Multitrack;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( mlt::Producer mlt );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mltc::new_Multitrack(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mltc::delete_Multitrack($self);
        delete $OWNER{$self};
    }
}

*get_multitrack = *mltc::Multitrack_get_multitrack;
*get_producer = *mltc::Multitrack_get_producer;
*connect = *mltc::Multitrack_connect;
*insert = *mltc::Multitrack_insert;
*disconnect = *mltc::Multitrack_disconnect;
*clip = *mltc::Multitrack_clip;
*count = *mltc::Multitrack_count;
*track = *mltc::Multitrack_track;
*refresh = *mltc::Multitrack_refresh;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mlt::Field ##############

package mlt::Field;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( mlt::Service mlt );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mltc::new_Field(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mltc::delete_Field($self);
        delete $OWNER{$self};
    }
}

*get_field = *mltc::Field_get_field;
*get_service = *mltc::Field_get_service;
*plant_filter = *mltc::Field_plant_filter;
*plant_transition = *mltc::Field_plant_transition;
*disconnect_service = *mltc::Field_disconnect_service;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mlt::Tractor ##############

package mlt::Tractor;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( mlt::Producer mlt );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mltc::new_Tractor(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mltc::delete_Tractor($self);
        delete $OWNER{$self};
    }
}

*get_tractor = *mltc::Tractor_get_tractor;
*get_producer = *mltc::Tractor_get_producer;
*multitrack = *mltc::Tractor_multitrack;
*field = *mltc::Tractor_field;
*refresh = *mltc::Tractor_refresh;
*set_track = *mltc::Tractor_set_track;
*insert_track = *mltc::Tractor_insert_track;
*remove_track = *mltc::Tractor_remove_track;
*track = *mltc::Tractor_track;
*count = *mltc::Tractor_count;
*plant_transition = *mltc::Tractor_plant_transition;
*plant_filter = *mltc::Tractor_plant_filter;
*locate_cut = *mltc::Tractor_locate_cut;
*connect = *mltc::Tractor_connect;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mlt::Parser ##############

package mlt::Parser;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( mlt::Properties mlt );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mltc::new_Parser(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mltc::delete_Parser($self);
        delete $OWNER{$self};
    }
}

*start = *mltc::Parser_start;
*get_properties = *mltc::Parser_get_properties;
*on_invalid = *mltc::Parser_on_invalid;
*on_unknown = *mltc::Parser_on_unknown;
*on_start_producer = *mltc::Parser_on_start_producer;
*on_end_producer = *mltc::Parser_on_end_producer;
*on_start_playlist = *mltc::Parser_on_start_playlist;
*on_end_playlist = *mltc::Parser_on_end_playlist;
*on_start_tractor = *mltc::Parser_on_start_tractor;
*on_end_tractor = *mltc::Parser_on_end_tractor;
*on_start_multitrack = *mltc::Parser_on_start_multitrack;
*on_end_multitrack = *mltc::Parser_on_end_multitrack;
*on_start_track = *mltc::Parser_on_start_track;
*on_end_track = *mltc::Parser_on_end_track;
*on_start_filter = *mltc::Parser_on_start_filter;
*on_end_filter = *mltc::Parser_on_end_filter;
*on_start_transition = *mltc::Parser_on_start_transition;
*on_end_transition = *mltc::Parser_on_end_transition;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mlt::FilteredConsumer ##############

package mlt::FilteredConsumer;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( mlt::Consumer mlt );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mltc::new_FilteredConsumer(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mltc::delete_FilteredConsumer($self);
        delete $OWNER{$self};
    }
}

*connect = *mltc::FilteredConsumer_connect;
*attach = *mltc::FilteredConsumer_attach;
*last = *mltc::FilteredConsumer_last;
*detach = *mltc::FilteredConsumer_detach;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mlt::Animation ##############

package mlt::Animation;
use overload
    "=" => sub { my $class = ref($_[0]); $class->new($_[0]) },
    "fallback" => 1;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( mlt );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mltc::new_Animation(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mltc::delete_Animation($self);
        delete $OWNER{$self};
    }
}

*is_valid = *mltc::Animation_is_valid;
*get_animation = *mltc::Animation_get_animation;
*__assign__ = *mltc::Animation___assign__;
*length = *mltc::Animation_length;
*get_item = *mltc::Animation_get_item;
*is_key = *mltc::Animation_is_key;
*keyframe_type = *mltc::Animation_keyframe_type;
*next_key = *mltc::Animation_next_key;
*previous_key = *mltc::Animation_previous_key;
*key_count = *mltc::Animation_key_count;
*key_get = *mltc::Animation_key_get;
*key_get_frame = *mltc::Animation_key_get_frame;
*key_get_type = *mltc::Animation_key_get_type;
*key_set_type = *mltc::Animation_key_set_type;
*key_set_frame = *mltc::Animation_key_set_frame;
*set_length = *mltc::Animation_set_length;
*remove = *mltc::Animation_remove;
*interpolate = *mltc::Animation_interpolate;
*serialize_cut = *mltc::Animation_serialize_cut;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


# ------- VARIABLE STUBS --------

package mlt;

*PATH_MAX = *mltc::PATH_MAX;
*mlt_image_none = *mltc::mlt_image_none;
*mlt_image_rgb24 = *mltc::mlt_image_rgb24;
*mlt_image_rgb24a = *mltc::mlt_image_rgb24a;
*mlt_image_yuv422 = *mltc::mlt_image_yuv422;
*mlt_image_yuv420p = *mltc::mlt_image_yuv420p;
*mlt_image_opengl = *mltc::mlt_image_opengl;
*mlt_image_glsl = *mltc::mlt_image_glsl;
*mlt_image_glsl_texture = *mltc::mlt_image_glsl_texture;
*mlt_image_yuv422p16 = *mltc::mlt_image_yuv422p16;
*mlt_image_invalid = *mltc::mlt_image_invalid;
*mlt_audio_none = *mltc::mlt_audio_none;
*mlt_audio_pcm = *mltc::mlt_audio_pcm;
*mlt_audio_s16 = *mltc::mlt_audio_s16;
*mlt_audio_s32 = *mltc::mlt_audio_s32;
*mlt_audio_float = *mltc::mlt_audio_float;
*mlt_audio_s32le = *mltc::mlt_audio_s32le;
*mlt_audio_f32le = *mltc::mlt_audio_f32le;
*mlt_audio_u8 = *mltc::mlt_audio_u8;
*mlt_channel_auto = *mltc::mlt_channel_auto;
*mlt_channel_independent = *mltc::mlt_channel_independent;
*mlt_channel_mono = *mltc::mlt_channel_mono;
*mlt_channel_stereo = *mltc::mlt_channel_stereo;
*mlt_channel_2p1 = *mltc::mlt_channel_2p1;
*mlt_channel_3p0 = *mltc::mlt_channel_3p0;
*mlt_channel_3p0_back = *mltc::mlt_channel_3p0_back;
*mlt_channel_4p0 = *mltc::mlt_channel_4p0;
*mlt_channel_quad_back = *mltc::mlt_channel_quad_back;
*mlt_channel_quad_side = *mltc::mlt_channel_quad_side;
*mlt_channel_3p1 = *mltc::mlt_channel_3p1;
*mlt_channel_5p0_back = *mltc::mlt_channel_5p0_back;
*mlt_channel_5p0 = *mltc::mlt_channel_5p0;
*mlt_channel_4p1 = *mltc::mlt_channel_4p1;
*mlt_channel_5p1_back = *mltc::mlt_channel_5p1_back;
*mlt_channel_5p1 = *mltc::mlt_channel_5p1;
*mlt_channel_6p0 = *mltc::mlt_channel_6p0;
*mlt_channel_6p0_front = *mltc::mlt_channel_6p0_front;
*mlt_channel_hexagonal = *mltc::mlt_channel_hexagonal;
*mlt_channel_6p1 = *mltc::mlt_channel_6p1;
*mlt_channel_6p1_back = *mltc::mlt_channel_6p1_back;
*mlt_channel_6p1_front = *mltc::mlt_channel_6p1_front;
*mlt_channel_7p0 = *mltc::mlt_channel_7p0;
*mlt_channel_7p0_front = *mltc::mlt_channel_7p0_front;
*mlt_channel_7p1 = *mltc::mlt_channel_7p1;
*mlt_channel_7p1_wide_side = *mltc::mlt_channel_7p1_wide_side;
*mlt_channel_7p1_wide_back = *mltc::mlt_channel_7p1_wide_back;
*mlt_time_frames = *mltc::mlt_time_frames;
*mlt_time_clock = *mltc::mlt_time_clock;
*mlt_time_smpte_df = *mltc::mlt_time_smpte_df;
*mlt_time_smpte = *mltc::mlt_time_smpte;
*mlt_time_smpte_ndf = *mltc::mlt_time_smpte_ndf;
*mlt_keyframe_discrete = *mltc::mlt_keyframe_discrete;
*mlt_keyframe_linear = *mltc::mlt_keyframe_linear;
*mlt_keyframe_smooth = *mltc::mlt_keyframe_smooth;
*mlt_whence_relative_start = *mltc::mlt_whence_relative_start;
*mlt_whence_relative_current = *mltc::mlt_whence_relative_current;
*mlt_whence_relative_end = *mltc::mlt_whence_relative_end;
*invalid_type = *mltc::invalid_type;
*unknown_type = *mltc::unknown_type;
*producer_type = *mltc::producer_type;
*tractor_type = *mltc::tractor_type;
*playlist_type = *mltc::playlist_type;
*multitrack_type = *mltc::multitrack_type;
*filter_type = *mltc::filter_type;
*transition_type = *mltc::transition_type;
*consumer_type = *mltc::consumer_type;
*field_type = *mltc::field_type;
*MLT_POSITION_FMT = *mltc::MLT_POSITION_FMT;
*MLT_DIRLIST_DELIMITER = *mltc::MLT_DIRLIST_DELIMITER;
*LIBMLT_VERSION_MAJOR = *mltc::LIBMLT_VERSION_MAJOR;
*LIBMLT_VERSION_MINOR = *mltc::LIBMLT_VERSION_MINOR;
*LIBMLT_VERSION_REVISION = *mltc::LIBMLT_VERSION_REVISION;
*LIBMLT_VERSION_INT = *mltc::LIBMLT_VERSION_INT;
*LIBMLT_VERSION = *mltc::LIBMLT_VERSION;
1;
