// Generated by gtkmmproc -- DO NOT MODIFY!


#include <gstreamermm/discovererinfo.h>
#include <gstreamermm/private/discovererinfo_p.h>

/* gstreamermm - a C++ wrapper for gstreamer
 *
 * Copyright 2011 gstreamermm Development Team
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <gst/pbutils/pbutils.h>
#include <gstreamermm/caps.h>
#include <gstreamermm/structure.h>
#include <gstreamermm/taglist.h>


namespace Gst
{

} // namespace Gst

namespace
{
} // anonymous namespace

// static
GType Glib::Value<Gst::DiscovererResult>::value_type()
{
  return gst_discoverer_result_get_type();
}


namespace Gst
{

Glib::RefPtr<Gst::DiscovererInfo> wrap(GstDiscovererInfo* object, bool take_copy)
{
  //Note that we use Gst::wrap() instead of Glib::wrap() 
  //because we are dealing with a GstMiniObject, not a GObject:
  return Glib::RefPtr<Gst::DiscovererInfo>( dynamic_cast<Gst::DiscovererInfo*> (Gst::wrap_auto ((GstMiniObject*)(object), take_copy)) );
  //We use dynamic_cast<> in case of multiple inheritance.
}

} /* namespace Gst */


namespace Gst
{


/* The *_Class implementation: */

const Glib::Class& DiscovererInfo_Class::init()
{
  if(!gtype_) // create the GType if necessary
  {
    // Glib::Class has to know the class init function to clone custom types.
    class_init_func_ = &DiscovererInfo_Class::class_init_function;

    // This is actually just optimized away, apparently with no harm.
    // Make sure that the parent type has been created.
    //CppClassParent::CppObjectType::get_type();

    // Create the wrapper type, with the same class/instance size as the base type.
    register_derived_type(gst_discoverer_info_get_type());

    // Add derived versions of interfaces, if the C type implements any interfaces:

  }

  return *this;
}


void DiscovererInfo_Class::class_init_function(void* g_class, void* class_data)
{
  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
  CppClassParent::class_init_function(klass, class_data);


}


Gst::MiniObject* DiscovererInfo_Class::wrap_new(GstMiniObject* object)
{
  return new DiscovererInfo((GstDiscovererInfo*)object);
}


/* The implementation: */

GstDiscovererInfo* DiscovererInfo::gobj_copy()
{
  // Use the mini object copying function to get a copy of the underlying
  // gobject instead of referencing and returning the underlying gobject as
  // would be done normally:
  return reinterpret_cast<GstDiscovererInfo*>(gst_mini_object_copy(reinterpret_cast<GstMiniObject*>(gobj())));
}


DiscovererInfo::DiscovererInfo(GstDiscovererInfo* castitem)
:
  MiniObject((GstMiniObject*)(castitem))
{}

DiscovererInfo::~DiscovererInfo()
{}


DiscovererInfo::CppClassType DiscovererInfo::discovererinfo_class_; // initialize static member

GType DiscovererInfo::get_type()
{
  return discovererinfo_class_.init().get_type();
}


GType DiscovererInfo::get_base_type()
{
  return gst_discoverer_info_get_type();
}


ClockTime DiscovererInfo::get_duration() const
{
  return ((ClockTime)(gst_discoverer_info_get_duration(const_cast<GstDiscovererInfo*>(gobj()))));
}

Structure DiscovererInfo::get_misc() const
{
  return Glib::wrap(const_cast<GstStructure*>(gst_discoverer_info_get_misc(const_cast<GstDiscovererInfo*>(gobj()))), true);
}

DiscovererResult DiscovererInfo::get_result() const
{
  return ((DiscovererResult)(gst_discoverer_info_get_result(const_cast<GstDiscovererInfo*>(gobj()))));
}

Glib::RefPtr<DiscovererStreamInfo> DiscovererInfo::get_stream_info()
{
  return Gst::wrap(gst_discoverer_info_get_stream_info(gobj()));
}

Glib::RefPtr<const DiscovererStreamInfo> DiscovererInfo::get_stream_info() const
{
  return const_cast<DiscovererInfo*>(this)->get_stream_info();
}

std::vector< Glib::RefPtr<DiscovererStreamInfo> > DiscovererInfo::get_stream_list()
{
  return Glib::ListHandler< Glib::RefPtr<DiscovererStreamInfo> >::list_to_vector(const_cast<GList*>(gst_discoverer_info_get_stream_list(gobj())), Glib::OWNERSHIP_DEEP);
}

std::vector< Glib::RefPtr<const DiscovererStreamInfo> > DiscovererInfo::get_stream_list() const
{
  return Glib::ListHandler< Glib::RefPtr<const DiscovererStreamInfo> >::list_to_vector(const_cast<GList*>(gst_discoverer_info_get_stream_list(const_cast<GstDiscovererInfo*>(gobj()))), Glib::OWNERSHIP_DEEP);
}

TagList DiscovererInfo::get_tags() const
{
  return Glib::wrap_taglist(const_cast<GstTagList*>(gst_discoverer_info_get_tags(const_cast<GstDiscovererInfo*>(gobj()))), true);
}

Glib::ustring DiscovererInfo::get_uri() const
{
  return Glib::convert_const_gchar_ptr_to_ustring(gst_discoverer_info_get_uri(const_cast<GstDiscovererInfo*>(gobj())));
}

bool DiscovererInfo::get_seekable() const
{
  return gst_discoverer_info_get_seekable(const_cast<GstDiscovererInfo*>(gobj()));
}

std::vector< Glib::RefPtr<DiscovererStreamInfo> > DiscovererInfo::get_audio_streams()
{
  return Glib::ListHandler< Glib::RefPtr<DiscovererStreamInfo> >::list_to_vector(const_cast<GList*>(gst_discoverer_info_get_audio_streams(gobj())), Glib::OWNERSHIP_DEEP);
}

std::vector< Glib::RefPtr<const DiscovererStreamInfo> > DiscovererInfo::get_audio_streams() const
{
  return Glib::ListHandler< Glib::RefPtr<const DiscovererStreamInfo> >::list_to_vector(const_cast<GList*>(gst_discoverer_info_get_audio_streams(const_cast<GstDiscovererInfo*>(gobj()))), Glib::OWNERSHIP_DEEP);
}

std::vector< Glib::RefPtr<DiscovererStreamInfo> > DiscovererInfo::get_container_streams()
{
  return Glib::ListHandler< Glib::RefPtr<DiscovererStreamInfo> >::list_to_vector(const_cast<GList*>(gst_discoverer_info_get_container_streams(gobj())), Glib::OWNERSHIP_DEEP);
}

std::vector< Glib::RefPtr<const DiscovererStreamInfo> > DiscovererInfo::get_container_streams() const
{
  return Glib::ListHandler< Glib::RefPtr<const DiscovererStreamInfo> >::list_to_vector(const_cast<GList*>(gst_discoverer_info_get_container_streams(const_cast<GstDiscovererInfo*>(gobj()))), Glib::OWNERSHIP_DEEP);
}

std::vector< Glib::RefPtr<DiscovererStreamInfo> > DiscovererInfo::get_streams(GType streamtype)
{
  return Glib::ListHandler< Glib::RefPtr<DiscovererStreamInfo> >::list_to_vector(const_cast<GList*>(gst_discoverer_info_get_streams(gobj(), streamtype)), Glib::OWNERSHIP_DEEP);
}

std::vector< Glib::RefPtr<const DiscovererStreamInfo> > DiscovererInfo::get_streams(GType streamtype) const
{
  return Glib::ListHandler< Glib::RefPtr<const DiscovererStreamInfo> >::list_to_vector(const_cast<GList*>(gst_discoverer_info_get_streams(const_cast<GstDiscovererInfo*>(gobj()), streamtype)), Glib::OWNERSHIP_DEEP);
}

std::vector< Glib::RefPtr<DiscovererStreamInfo> > DiscovererInfo::get_video_streams()
{
  return Glib::ListHandler< Glib::RefPtr<DiscovererStreamInfo> >::list_to_vector(const_cast<GList*>(gst_discoverer_info_get_video_streams(gobj())), Glib::OWNERSHIP_DEEP);
}

std::vector< Glib::RefPtr<const DiscovererStreamInfo> > DiscovererInfo::get_video_streams() const
{
  return Glib::ListHandler< Glib::RefPtr<const DiscovererStreamInfo> >::list_to_vector(const_cast<GList*>(gst_discoverer_info_get_video_streams(const_cast<GstDiscovererInfo*>(gobj()))), Glib::OWNERSHIP_DEEP);
}


} // namespace Gst


namespace Gst
{

Glib::RefPtr<Gst::DiscovererStreamInfo> wrap(GstDiscovererStreamInfo* object, bool take_copy)
{
  //Note that we use Gst::wrap() instead of Glib::wrap() 
  //because we are dealing with a GstMiniObject, not a GObject:
  return Glib::RefPtr<Gst::DiscovererStreamInfo>( dynamic_cast<Gst::DiscovererStreamInfo*> (Gst::wrap_auto ((GstMiniObject*)(object), take_copy)) );
  //We use dynamic_cast<> in case of multiple inheritance.
}

} /* namespace Gst */


namespace Gst
{


/* The *_Class implementation: */

const Glib::Class& DiscovererStreamInfo_Class::init()
{
  if(!gtype_) // create the GType if necessary
  {
    // Glib::Class has to know the class init function to clone custom types.
    class_init_func_ = &DiscovererStreamInfo_Class::class_init_function;

    // This is actually just optimized away, apparently with no harm.
    // Make sure that the parent type has been created.
    //CppClassParent::CppObjectType::get_type();

    // Create the wrapper type, with the same class/instance size as the base type.
    register_derived_type(gst_discoverer_stream_info_get_type());

    // Add derived versions of interfaces, if the C type implements any interfaces:

  }

  return *this;
}


void DiscovererStreamInfo_Class::class_init_function(void* g_class, void* class_data)
{
  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
  CppClassParent::class_init_function(klass, class_data);


}


Gst::MiniObject* DiscovererStreamInfo_Class::wrap_new(GstMiniObject* object)
{
  return new DiscovererStreamInfo((GstDiscovererStreamInfo*)object);
}


/* The implementation: */

GstDiscovererStreamInfo* DiscovererStreamInfo::gobj_copy()
{
  // Use the mini object copying function to get a copy of the underlying
  // gobject instead of referencing and returning the underlying gobject as
  // would be done normally:
  return reinterpret_cast<GstDiscovererStreamInfo*>(gst_mini_object_copy(reinterpret_cast<GstMiniObject*>(gobj())));
}


DiscovererStreamInfo::DiscovererStreamInfo(GstDiscovererStreamInfo* castitem)
:
  MiniObject((GstMiniObject*)(castitem))
{}

DiscovererStreamInfo::~DiscovererStreamInfo()
{}


DiscovererStreamInfo::CppClassType DiscovererStreamInfo::discovererstreaminfo_class_; // initialize static member

GType DiscovererStreamInfo::get_type()
{
  return discovererstreaminfo_class_.init().get_type();
}


GType DiscovererStreamInfo::get_base_type()
{
  return gst_discoverer_stream_info_get_type();
}

Glib::RefPtr<Gst::Caps> DiscovererStreamInfo::get_caps()
{
  return Glib::wrap(gst_discoverer_stream_info_get_caps(gobj()));
}

Glib::RefPtr<const Gst::Caps> DiscovererStreamInfo::get_caps() const
{
  return const_cast<DiscovererStreamInfo*>(this)->get_caps();
}

Structure DiscovererStreamInfo::get_misc() const
{
  return Glib::wrap(const_cast<GstStructure*>(gst_discoverer_stream_info_get_misc(const_cast<GstDiscovererStreamInfo*>(gobj()))), true);
}

Glib::RefPtr<DiscovererStreamInfo> DiscovererStreamInfo::get_next()
{
  return Gst::wrap(gst_discoverer_stream_info_get_next(gobj()));
}

Glib::RefPtr<const DiscovererStreamInfo> DiscovererStreamInfo::get_next() const
{
  return const_cast<DiscovererStreamInfo*>(this)->get_next();
}

Glib::RefPtr<DiscovererStreamInfo> DiscovererStreamInfo::get_previous()
{
  return Gst::wrap(gst_discoverer_stream_info_get_previous(gobj()));
}

Glib::RefPtr<DiscovererStreamInfo> DiscovererStreamInfo::get_previous() const
{
  return const_cast<DiscovererStreamInfo*>(this)->get_previous();
}

TagList DiscovererStreamInfo::get_tags() const
{
  return Glib::wrap_taglist(const_cast<GstTagList*>(gst_discoverer_stream_info_get_tags(const_cast<GstDiscovererStreamInfo*>(gobj()))), true);
}

Glib::ustring DiscovererStreamInfo::get_stream_type_nick() const
{
  return Glib::convert_const_gchar_ptr_to_ustring(gst_discoverer_stream_info_get_stream_type_nick(const_cast<GstDiscovererStreamInfo*>(gobj())));
}


} // namespace Gst


namespace Gst
{

Glib::RefPtr<Gst::DiscovererContainerInfo> wrap(GstDiscovererContainerInfo* object, bool take_copy)
{
  //Note that we use Gst::wrap() instead of Glib::wrap() 
  //because we are dealing with a GstMiniObject, not a GObject:
  return Glib::RefPtr<Gst::DiscovererContainerInfo>( dynamic_cast<Gst::DiscovererContainerInfo*> (Gst::wrap_auto ((GstMiniObject*)(object), take_copy)) );
  //We use dynamic_cast<> in case of multiple inheritance.
}

} /* namespace Gst */


namespace Gst
{


/* The *_Class implementation: */

const Glib::Class& DiscovererContainerInfo_Class::init()
{
  if(!gtype_) // create the GType if necessary
  {
    // Glib::Class has to know the class init function to clone custom types.
    class_init_func_ = &DiscovererContainerInfo_Class::class_init_function;

    // This is actually just optimized away, apparently with no harm.
    // Make sure that the parent type has been created.
    //CppClassParent::CppObjectType::get_type();

    // Create the wrapper type, with the same class/instance size as the base type.
    register_derived_type(gst_discoverer_container_info_get_type());

    // Add derived versions of interfaces, if the C type implements any interfaces:

  }

  return *this;
}


void DiscovererContainerInfo_Class::class_init_function(void* g_class, void* class_data)
{
  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
  CppClassParent::class_init_function(klass, class_data);


}


Gst::MiniObject* DiscovererContainerInfo_Class::wrap_new(GstMiniObject* object)
{
  return new DiscovererContainerInfo((GstDiscovererContainerInfo*)object);
}


/* The implementation: */

GstDiscovererContainerInfo* DiscovererContainerInfo::gobj_copy()
{
  // Use the mini object copying function to get a copy of the underlying
  // gobject instead of referencing and returning the underlying gobject as
  // would be done normally:
  return reinterpret_cast<GstDiscovererContainerInfo*>(gst_mini_object_copy(reinterpret_cast<GstMiniObject*>(gobj())));
}


DiscovererContainerInfo::DiscovererContainerInfo(GstDiscovererContainerInfo* castitem)
:
  DiscovererStreamInfo((GstDiscovererStreamInfo*)(castitem))
{}

DiscovererContainerInfo::~DiscovererContainerInfo()
{}


DiscovererContainerInfo::CppClassType DiscovererContainerInfo::discoverercontainerinfo_class_; // initialize static member

GType DiscovererContainerInfo::get_type()
{
  return discoverercontainerinfo_class_.init().get_type();
}


GType DiscovererContainerInfo::get_base_type()
{
  return gst_discoverer_container_info_get_type();
}

std::vector< Glib::RefPtr<DiscovererStreamInfo> > DiscovererContainerInfo::get_streams()
{
  return Glib::ListHandler< Glib::RefPtr<DiscovererStreamInfo> >::list_to_vector(const_cast<GList*>(gst_discoverer_container_info_get_streams(gobj())), Glib::OWNERSHIP_DEEP);
}

std::vector< Glib::RefPtr<const DiscovererStreamInfo> > DiscovererContainerInfo::get_streams() const
{
  return Glib::ListHandler< Glib::RefPtr<const DiscovererStreamInfo> >::list_to_vector(const_cast<GList*>(gst_discoverer_container_info_get_streams(const_cast<GstDiscovererContainerInfo*>(gobj()))), Glib::OWNERSHIP_DEEP);
}


} // namespace Gst


namespace Gst
{

Glib::RefPtr<Gst::DiscovererAudioInfo> wrap(GstDiscovererAudioInfo* object, bool take_copy)
{
  //Note that we use Gst::wrap() instead of Glib::wrap() 
  //because we are dealing with a GstMiniObject, not a GObject:
  return Glib::RefPtr<Gst::DiscovererAudioInfo>( dynamic_cast<Gst::DiscovererAudioInfo*> (Gst::wrap_auto ((GstMiniObject*)(object), take_copy)) );
  //We use dynamic_cast<> in case of multiple inheritance.
}

} /* namespace Gst */


namespace Gst
{


/* The *_Class implementation: */

const Glib::Class& DiscovererAudioInfo_Class::init()
{
  if(!gtype_) // create the GType if necessary
  {
    // Glib::Class has to know the class init function to clone custom types.
    class_init_func_ = &DiscovererAudioInfo_Class::class_init_function;

    // This is actually just optimized away, apparently with no harm.
    // Make sure that the parent type has been created.
    //CppClassParent::CppObjectType::get_type();

    // Create the wrapper type, with the same class/instance size as the base type.
    register_derived_type(gst_discoverer_audio_info_get_type());

    // Add derived versions of interfaces, if the C type implements any interfaces:

  }

  return *this;
}


void DiscovererAudioInfo_Class::class_init_function(void* g_class, void* class_data)
{
  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
  CppClassParent::class_init_function(klass, class_data);


}


Gst::MiniObject* DiscovererAudioInfo_Class::wrap_new(GstMiniObject* object)
{
  return new DiscovererAudioInfo((GstDiscovererAudioInfo*)object);
}


/* The implementation: */

GstDiscovererAudioInfo* DiscovererAudioInfo::gobj_copy()
{
  // Use the mini object copying function to get a copy of the underlying
  // gobject instead of referencing and returning the underlying gobject as
  // would be done normally:
  return reinterpret_cast<GstDiscovererAudioInfo*>(gst_mini_object_copy(reinterpret_cast<GstMiniObject*>(gobj())));
}


DiscovererAudioInfo::DiscovererAudioInfo(GstDiscovererAudioInfo* castitem)
:
  DiscovererStreamInfo((GstDiscovererStreamInfo*)(castitem))
{}

DiscovererAudioInfo::~DiscovererAudioInfo()
{}


DiscovererAudioInfo::CppClassType DiscovererAudioInfo::discovereraudioinfo_class_; // initialize static member

GType DiscovererAudioInfo::get_type()
{
  return discovereraudioinfo_class_.init().get_type();
}


GType DiscovererAudioInfo::get_base_type()
{
  return gst_discoverer_audio_info_get_type();
}

guint DiscovererAudioInfo::get_bitrate() const
{
  return gst_discoverer_audio_info_get_bitrate(const_cast<GstDiscovererAudioInfo*>(gobj()));
}

guint DiscovererAudioInfo::get_channels() const
{
  return gst_discoverer_audio_info_get_channels(const_cast<GstDiscovererAudioInfo*>(gobj()));
}

guint DiscovererAudioInfo::get_depth() const
{
  return gst_discoverer_audio_info_get_depth(const_cast<GstDiscovererAudioInfo*>(gobj()));
}

guint DiscovererAudioInfo::get_max_bitrate() const
{
  return gst_discoverer_audio_info_get_max_bitrate(const_cast<GstDiscovererAudioInfo*>(gobj()));
}

guint DiscovererAudioInfo::get_sample_rate() const
{
  return gst_discoverer_audio_info_get_sample_rate(const_cast<GstDiscovererAudioInfo*>(gobj()));
}


} // namespace Gst


namespace Gst
{

Glib::RefPtr<Gst::DiscovererVideoInfo> wrap(GstDiscovererVideoInfo* object, bool take_copy)
{
  //Note that we use Gst::wrap() instead of Glib::wrap() 
  //because we are dealing with a GstMiniObject, not a GObject:
  return Glib::RefPtr<Gst::DiscovererVideoInfo>( dynamic_cast<Gst::DiscovererVideoInfo*> (Gst::wrap_auto ((GstMiniObject*)(object), take_copy)) );
  //We use dynamic_cast<> in case of multiple inheritance.
}

} /* namespace Gst */


namespace Gst
{


/* The *_Class implementation: */

const Glib::Class& DiscovererVideoInfo_Class::init()
{
  if(!gtype_) // create the GType if necessary
  {
    // Glib::Class has to know the class init function to clone custom types.
    class_init_func_ = &DiscovererVideoInfo_Class::class_init_function;

    // This is actually just optimized away, apparently with no harm.
    // Make sure that the parent type has been created.
    //CppClassParent::CppObjectType::get_type();

    // Create the wrapper type, with the same class/instance size as the base type.
    register_derived_type(gst_discoverer_video_info_get_type());

    // Add derived versions of interfaces, if the C type implements any interfaces:

  }

  return *this;
}


void DiscovererVideoInfo_Class::class_init_function(void* g_class, void* class_data)
{
  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
  CppClassParent::class_init_function(klass, class_data);


}


Gst::MiniObject* DiscovererVideoInfo_Class::wrap_new(GstMiniObject* object)
{
  return new DiscovererVideoInfo((GstDiscovererVideoInfo*)object);
}


/* The implementation: */

GstDiscovererVideoInfo* DiscovererVideoInfo::gobj_copy()
{
  // Use the mini object copying function to get a copy of the underlying
  // gobject instead of referencing and returning the underlying gobject as
  // would be done normally:
  return reinterpret_cast<GstDiscovererVideoInfo*>(gst_mini_object_copy(reinterpret_cast<GstMiniObject*>(gobj())));
}


DiscovererVideoInfo::DiscovererVideoInfo(GstDiscovererVideoInfo* castitem)
:
  DiscovererStreamInfo((GstDiscovererStreamInfo*)(castitem))
{}

DiscovererVideoInfo::~DiscovererVideoInfo()
{}


DiscovererVideoInfo::CppClassType DiscovererVideoInfo::discoverervideoinfo_class_; // initialize static member

GType DiscovererVideoInfo::get_type()
{
  return discoverervideoinfo_class_.init().get_type();
}


GType DiscovererVideoInfo::get_base_type()
{
  return gst_discoverer_video_info_get_type();
}

guint DiscovererVideoInfo::get_bitrate() const
{
  return gst_discoverer_video_info_get_bitrate(const_cast<GstDiscovererVideoInfo*>(gobj()));
}

guint DiscovererVideoInfo::get_depth() const
{
  return gst_discoverer_video_info_get_depth(const_cast<GstDiscovererVideoInfo*>(gobj()));
}

guint DiscovererVideoInfo::get_framerate_denom() const
{
  return gst_discoverer_video_info_get_framerate_denom(const_cast<GstDiscovererVideoInfo*>(gobj()));
}

guint DiscovererVideoInfo::get_framerate_num() const
{
  return gst_discoverer_video_info_get_framerate_num(const_cast<GstDiscovererVideoInfo*>(gobj()));
}

guint DiscovererVideoInfo::get_height() const
{
  return gst_discoverer_video_info_get_height(const_cast<GstDiscovererVideoInfo*>(gobj()));
}

bool DiscovererVideoInfo::is_interlaced() const
{
  return gst_discoverer_video_info_is_interlaced(const_cast<GstDiscovererVideoInfo*>(gobj()));
}

bool DiscovererVideoInfo::is_image() const
{
  return gst_discoverer_video_info_is_image(const_cast<GstDiscovererVideoInfo*>(gobj()));
}

guint DiscovererVideoInfo::get_max_bitrate() const
{
  return gst_discoverer_video_info_get_max_bitrate(const_cast<GstDiscovererVideoInfo*>(gobj()));
}

guint DiscovererVideoInfo::get_par_denom() const
{
  return gst_discoverer_video_info_get_par_denom(const_cast<GstDiscovererVideoInfo*>(gobj()));
}

guint DiscovererVideoInfo::get_par_num() const
{
  return gst_discoverer_video_info_get_par_num(const_cast<GstDiscovererVideoInfo*>(gobj()));
}

guint DiscovererVideoInfo::get_width() const
{
  return gst_discoverer_video_info_get_width(const_cast<GstDiscovererVideoInfo*>(gobj()));
}


} // namespace Gst


