libgstreamermm-1.0-dev 1.10.0+dfsg-1 / usr / include / gstreamermm-1.0 / gstreamermm / videosink.h

// Generated by gmmproc 2.50.1 -- DO NOT MODIFY!
#ifndef _GSTREAMERMM_VIDEOSINK_H
#define _GSTREAMERMM_VIDEOSINK_H


#include <glibmm/ustring.h>
#include <sigc++/sigc++.h>

/* gstreamermm - a C++ wrapper for gstreamer
 *
 * Copyright 2008 The 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 <gstreamermm/basesink.h>


#ifndef DOXYGEN_SHOULD_SKIP_THIS
using GstVideoSink = struct _GstVideoSink;
using GstVideoSinkClass = struct _GstVideoSinkClass;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Gst
{ class VideoSink_Class; } // namespace Gst
#endif //DOXYGEN_SHOULD_SKIP_THIS

namespace Gst
{

/** A helper structure for the Gst::VideoSink class representing a rectangular
 * area.
 */
struct VideoRectangle
{
  /// The X coordinate of the rectangle's top-left point.
  int x;

  /// The Y coordinate of rectangle's top-left point.
  int y;

  /// The width of the rectangle.
  int w;

  /// The height of the rectangle.
  int h;
};

/** A base class for video sinks.
 * Gst::VideoSink provides useful functions and a base class for video sinks.
 *
 * Gst::VideoSink will configure the default base sink to drop frames that
 * arrive later than 20ms as this is considered the default threshold for
 * observing out-of-sync frames. 
 *
 * @ingroup GstBaseClasses
 */

class VideoSink : public Gst::BaseSink
{
  
#ifndef DOXYGEN_SHOULD_SKIP_THIS

public:
  using CppObjectType = VideoSink;
  using CppClassType = VideoSink_Class;
  using BaseObjectType = GstVideoSink;
  using BaseClassType = GstVideoSinkClass;

  // noncopyable
  VideoSink(const VideoSink&) = delete;
  VideoSink& operator=(const VideoSink&) = delete;

private:  friend class VideoSink_Class;
  static CppClassType videosink_class_;

protected:
  explicit VideoSink(const Glib::ConstructParams& construct_params);
  explicit VideoSink(GstVideoSink* castitem);

#endif /* DOXYGEN_SHOULD_SKIP_THIS */

public:

  VideoSink(VideoSink&& src) noexcept;
  VideoSink& operator=(VideoSink&& src) noexcept;

  ~VideoSink() noexcept override;

  /** Get the GType for this class, for use with the underlying GObject type system.
   */
  static GType get_type()      G_GNUC_CONST;

#ifndef DOXYGEN_SHOULD_SKIP_THIS


  static GType get_base_type() G_GNUC_CONST;
#endif

  ///Provides access to the underlying C GObject.
  GstVideoSink*       gobj()       { return reinterpret_cast<GstVideoSink*>(gobject_); }

  ///Provides access to the underlying C GObject.
  const GstVideoSink* gobj() const { return reinterpret_cast<GstVideoSink*>(gobject_); }

  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
  GstVideoSink* gobj_copy();

private:


public:
  /** Get height of Gst::VideoSink.
   */
  int get_height() const;

  /** Get width of Gst::VideoSink.
   */
  int get_width() const;

 
  /** Takes @a src rectangle and position it at the center of @a dst rectangle with or
   * without @a scaling. It handles clipping if the @a src rectangle is bigger than
   * the @a dst one and @a scaling is set to <tt>false</tt>.
   * 
   * @param src The Gst::VideoRectangle describing the source area.
   * @param dst The Gst::VideoRectangle describing the destination area.
   * @param result A pointer to a Gst::VideoRectangle which will receive the result area.
   * @param scaling A <tt>bool</tt> indicating if scaling should be applied or not.
   */
  static void center_rect(const Gst::VideoRectangle& src, const Gst::VideoRectangle& dst, Gst::VideoRectangle& result, bool scaling =  false);

  /** Whether to render video frames during preroll.
   *
   * @return A PropertyProxy that allows you to get or set the value of the property,
   * or receive notification when the value of the property changes.
   */
  Glib::PropertyProxy< bool > property_show_preroll_frame() ;

/** Whether to render video frames during preroll.
   *
   * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
   * or receive notification when the value of the property changes.
   */
  Glib::PropertyProxy_ReadOnly< bool > property_show_preroll_frame() const;


public:

public:
  //C++ methods used to invoke GTK+ virtual functions:

protected:
  //GTK+ Virtual Functions (override these to change behaviour):

  //Default Signal Handlers::


};

} // namespace Gst


namespace Glib
{
  /** A Glib::wrap() method for this object.
   *
   * @param object The C instance.
   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
   * @result A C++ instance that wraps this C instance.
   *
   * @relates Gst::VideoSink
   */
  Glib::RefPtr<Gst::VideoSink> wrap(GstVideoSink* object, bool take_copy = false);
}


#endif /* _GSTREAMERMM_VIDEOSINK_H */