gstreamer/tests/examples/scaletempo/demo-player.c
2012-01-02 15:52:23 +01:00

756 lines
21 KiB
C

/* demo-player.c
* Copyright (C) 2008 Rov Juvano <rovjuvano@users.sourceforge.net>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "demo-player.h"
#include "gst/gst.h"
#undef G_LOG_DOMAIN
#define G_LOG_DOMAIN "demo-player"
enum
{
SIGNAL_ERROR,
SIGNAL_RATE_CHANGE,
SIGNAL_PLAYING_STARTED,
SIGNAL_PLAYING_PAUSED,
SIGNAL_PLAYING_ENDED,
LAST_SIGNAL
};
static guint demo_player_signals[LAST_SIGNAL] = { 0 };
enum
{
PROP_0,
PROP_RATE,
PROP_STRIDE,
PROP_OVERLAP,
PROP_SEARCH,
PROP_DISABLED
};
typedef struct _DemoPlayerPrivate
{
gdouble rate;
GstElement *scaletempo;
GstElement *pipeline;
gboolean is_disabled;
GstElement *scaletempo_line;
GstElement *scalerate_line;
gboolean ignore_state_change;
} DemoPlayerPrivate;
#define DEMO_PLAYER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), DEMO_TYPE_PLAYER, DemoPlayerPrivate))
static gboolean
no_pipeline (DemoPlayer * player)
{
DemoPlayerPrivate *priv = DEMO_PLAYER_GET_PRIVATE (player);
if (!priv->pipeline) {
g_signal_emit (player, demo_player_signals[SIGNAL_ERROR], 0,
"No media loaded");
return TRUE;
}
return FALSE;
}
static GstPadProbeReturn
demo_player_event_listener (GstPad * pad, GstPadProbeInfo * info, gpointer data)
{
GstEvent *event = GST_PAD_PROBE_INFO_EVENT (info);
DemoPlayer *player = DEMO_PLAYER (data);
DemoPlayerPrivate *priv = DEMO_PLAYER_GET_PRIVATE (player);
if (GST_EVENT_TYPE (event) == GST_EVENT_SEGMENT) {
const GstSegment *segment;
gdouble new_rate;
gst_event_parse_segment (event, &segment);
new_rate = segment->rate * segment->applied_rate;
if (priv->rate != new_rate) {
priv->rate = new_rate;
g_signal_emit (player, demo_player_signals[SIGNAL_RATE_CHANGE], 0,
new_rate);
}
}
return GST_PAD_PROBE_OK;
}
static void
demo_player_state_changed_cb (GstBus * bus, GstMessage * message, gpointer data)
{
DemoPlayer *player = DEMO_PLAYER (data);
DemoPlayerPrivate *priv = DEMO_PLAYER_GET_PRIVATE (player);
GstState old, new, pending;
if (GST_ELEMENT (GST_MESSAGE_SRC (message)) != priv->pipeline)
return;
gst_message_parse_state_changed (message, &old, &new, &pending);
if (pending == GST_STATE_VOID_PENDING) {
if (priv->ignore_state_change) {
priv->ignore_state_change = FALSE;
} else if (new == GST_STATE_PAUSED) {
g_signal_emit (player, demo_player_signals[SIGNAL_PLAYING_PAUSED], 0);
} else if (new == GST_STATE_PLAYING) {
g_signal_emit (player, demo_player_signals[SIGNAL_PLAYING_STARTED], 0);
}
}
}
static void
demo_player_eos_cb (GstBus * bus, GstMessage * message, gpointer data)
{
DemoPlayer *player = DEMO_PLAYER (data);
g_signal_emit (player, demo_player_signals[SIGNAL_PLAYING_ENDED], 0);
}
#define MAKE_ELEMENT(line, var, type, name) \
if ( !(var = gst_element_factory_make (type, name) ) ) { \
g_print ("element could not be created: %s/%s\n", type, name); \
return; \
} \
if (line) gst_bin_add (GST_BIN (line), var);
#define LINK_ELEMENTS(src, sink) \
if (!gst_element_link (src, sink)) { \
g_warning ("Failed to link elements: %s -> %s", \
GST_ELEMENT_NAME (src), GST_ELEMENT_NAME (sink) ); \
return; \
}
static void
demo_player_build_pipeline (DemoPlayer * player)
{
DemoPlayerPrivate *priv = DEMO_PLAYER_GET_PRIVATE (player);
GstElement *filter, *playbin, *vsink, *audioline, *format, *resample, *asink;
GstPlugin *gconf;
GstBus *bus;
gboolean has_gconf;
const gchar *audiosink_name;
GstPad *ghostpad;
priv->pipeline = NULL;
if (!priv->scaletempo) {
return;
}
filter = priv->scaletempo;
MAKE_ELEMENT (NULL, playbin, "playbin", "playbin");
gconf = gst_registry_find_plugin (gst_registry_get (), "gconfelements");
has_gconf = (gconf != NULL);
gst_object_unref (gconf);
if (has_gconf) {
MAKE_ELEMENT (NULL, vsink, "gconfvideosink", "vsink");
g_object_set (G_OBJECT (playbin), "video_sink", vsink, NULL);
}
audiosink_name = has_gconf ? "gconfaudiosink" : "autoaudiosink";
audioline = gst_bin_new ("audioline");
gst_bin_add (GST_BIN (audioline), filter);
MAKE_ELEMENT (audioline, format, "audioconvert", "format");
MAKE_ELEMENT (audioline, resample, "audioresample", "resample");
MAKE_ELEMENT (audioline, asink, audiosink_name, "audio_sink");
LINK_ELEMENTS (filter, format);
LINK_ELEMENTS (format, resample);
LINK_ELEMENTS (resample, asink);
gst_pad_add_probe (gst_element_get_static_pad (asink, "sink"),
GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM,
demo_player_event_listener, player, NULL);
ghostpad = gst_element_get_static_pad (filter, "sink");
gst_element_add_pad (audioline, gst_ghost_pad_new ("sink", ghostpad));
gst_object_unref (ghostpad);
g_object_set (G_OBJECT (playbin), "audio-sink", audioline, NULL);
bus = gst_pipeline_get_bus (GST_PIPELINE (playbin));
gst_bus_add_signal_watch (bus);
g_signal_connect (bus, "message::state-changed",
G_CALLBACK (demo_player_state_changed_cb), player);
g_signal_connect (bus, "message::eos", G_CALLBACK (demo_player_eos_cb),
player);
gst_object_unref (bus);
priv->scaletempo = filter;
priv->pipeline = playbin;
priv->scaletempo_line = audioline;
MAKE_ELEMENT (NULL, priv->scalerate_line, audiosink_name,
"scaling_audio_sink");
gst_pad_add_probe (gst_element_get_static_pad (priv->scalerate_line,
"sink"), GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM,
demo_player_event_listener, player, NULL);
g_object_ref (priv->scaletempo_line);
g_object_ref (priv->scalerate_line);
}
/* method implementations */
static void
_set_rate (DemoPlayer * player, gdouble new_rate, gint second)
{
DemoPlayerPrivate *priv;
gint64 pos;
GstSeekType seek_type;
if (new_rate == 0) {
g_signal_emit (player, demo_player_signals[SIGNAL_ERROR], 0,
"Cannot set playback to zero. Pausing instead.");
demo_player_pause (player);
}
priv = DEMO_PLAYER_GET_PRIVATE (player);
if (second < 0) {
seek_type = GST_SEEK_TYPE_SET;
if (!gst_element_query_position (priv->pipeline, GST_FORMAT_TIME, &pos)) {
// This should be the default but too many upstream elements seek anyway
pos = GST_CLOCK_TIME_NONE;
seek_type = GST_SEEK_TYPE_NONE;
}
} else {
seek_type = GST_SEEK_TYPE_SET;
pos = second * GST_SECOND;
}
if (!gst_element_seek (priv->pipeline, new_rate,
GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE,
seek_type, pos, GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE)) {
g_signal_emit (player, demo_player_signals[SIGNAL_ERROR], 0,
"Unable to change playback rate");
} else {
priv->ignore_state_change = TRUE;
}
}
static void
demo_player_scale_rate_func (DemoPlayer * player, gdouble scale)
{
DemoPlayerPrivate *priv;
if (no_pipeline (player))
return;
priv = DEMO_PLAYER_GET_PRIVATE (player);
if (scale != 1.0) {
g_message ("Scaling Rate by: %3.2f", scale);
_set_rate (player, priv->rate * scale, -1);
}
}
static void
demo_player_set_rate_func (DemoPlayer * player, gdouble new_rate)
{
DemoPlayerPrivate *priv;
if (no_pipeline (player))
return;
priv = DEMO_PLAYER_GET_PRIVATE (player);
if (priv->rate != new_rate) {
g_message ("Setting Rate to: %3.2f", new_rate);
_set_rate (player, new_rate, -1);
}
}
static gboolean
_set_state_and_wait (DemoPlayer * player,
GstState new_state, GstClockTime timeout, const gchar * error_msg)
{
DemoPlayerPrivate *priv = DEMO_PLAYER_GET_PRIVATE (player);
GstStateChangeReturn ret = gst_element_set_state (priv->pipeline, new_state);
if (ret == GST_STATE_CHANGE_ASYNC) {
ret = gst_element_get_state (priv->pipeline, NULL, NULL, timeout);
}
if (ret != GST_STATE_CHANGE_SUCCESS) {
g_signal_emit (player, demo_player_signals[SIGNAL_ERROR], 0, error_msg);
return FALSE;
}
return TRUE;
}
static void
demo_player_load_uri_func (DemoPlayer * player, gchar * uri)
{
DemoPlayerPrivate *priv = DEMO_PLAYER_GET_PRIVATE (player);
GstState end_state;
gdouble rate;
if (!priv->pipeline) {
demo_player_build_pipeline (player);
if (!priv->pipeline) {
g_signal_emit (player, demo_player_signals[SIGNAL_ERROR], 0,
"Could not build player");
return;
}
}
if (!g_str_has_prefix (uri, "file:///")) {
GError *err = NULL;
if (g_path_is_absolute (uri)) {
uri = g_filename_to_uri (uri, NULL, &err);
} else {
gchar *curdir = g_get_current_dir ();
gchar *absolute_path = g_strconcat (curdir, G_DIR_SEPARATOR_S, uri, NULL);
uri = g_filename_to_uri (absolute_path, NULL, &err);
g_free (absolute_path);
g_free (curdir);
}
if (err) {
gchar *msg = g_strconcat ("Could not load uri: ", err->message, NULL);
g_signal_emit (player, demo_player_signals[SIGNAL_ERROR], 0, msg);
return;
}
}
g_message ("Loading URI: %s", uri);
end_state =
(GST_STATE (priv->pipeline) ==
GST_STATE_PLAYING) ? GST_STATE_PLAYING : GST_STATE_PAUSED;
if (!_set_state_and_wait (player, GST_STATE_NULL, 10 * GST_SECOND,
"Unable to load uri"))
return;
g_object_set (G_OBJECT (priv->pipeline), "uri", uri, NULL);
rate = priv->rate;
if (rate && rate != 1.0) {
_set_state_and_wait (player, GST_STATE_PAUSED, 10 * GST_SECOND,
"Unable to keep playback rate");
_set_rate (player, rate, -1);
}
gst_element_set_state (priv->pipeline, end_state);
}
static void
demo_player_play_func (DemoPlayer * player)
{
DemoPlayerPrivate *priv;
GstStateChangeReturn ret;
if (no_pipeline (player))
return;
priv = DEMO_PLAYER_GET_PRIVATE (player);
if (GST_STATE (priv->pipeline) == GST_STATE_PLAYING) {
g_signal_emit (player, demo_player_signals[SIGNAL_ERROR], 0,
"Already playing");
return;
}
g_debug ("Starting to Play");
ret = gst_element_set_state (priv->pipeline, GST_STATE_PLAYING);
if (ret == GST_STATE_CHANGE_FAILURE) {
g_signal_emit (player, demo_player_signals[SIGNAL_ERROR], 0,
"Unable to start playback");
return;
}
}
static void
demo_player_pause_func (DemoPlayer * player)
{
DemoPlayerPrivate *priv;
GstStateChangeReturn ret;
if (no_pipeline (player))
return;
priv = DEMO_PLAYER_GET_PRIVATE (player);
if (GST_STATE (priv->pipeline) == GST_STATE_PAUSED) {
g_signal_emit (player, demo_player_signals[SIGNAL_ERROR], 0,
"Already paused");
return;
}
g_debug ("Starting to Pause");
ret = gst_element_set_state (priv->pipeline, GST_STATE_PAUSED);
if (ret == GST_STATE_CHANGE_FAILURE) {
g_signal_emit (player, demo_player_signals[SIGNAL_ERROR], 0,
"Unable to pause playback");
return;
}
}
static void
_seek_to (DemoPlayer * player, gint new_second)
{
DemoPlayerPrivate *priv = DEMO_PLAYER_GET_PRIVATE (player);
if (!gst_element_seek (priv->pipeline, priv->rate,
GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH,
GST_SEEK_TYPE_SET, new_second * GST_SECOND,
GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE)) {
g_signal_emit (player, demo_player_signals[SIGNAL_ERROR], 0, "Seek failed");
return;
}
priv->ignore_state_change = TRUE;
}
static void
demo_player_seek_by_func (DemoPlayer * player, gint seconds)
{
gint pos;
if (no_pipeline (player))
return;
g_debug ("Seeking by: %i", seconds);
pos = demo_player_get_position (player);
if (pos < 0) {
g_signal_emit (player, demo_player_signals[SIGNAL_ERROR], 0,
"Seek-by failed: could not determine position");
return;
}
_seek_to (player, MAX (0, pos + seconds));
}
static void
demo_player_seek_to_func (DemoPlayer * player, gint second)
{
gint new_second;
if (no_pipeline (player))
return;
g_debug ("Seeking to: %i", second);
if (second < 0) {
gint dur = demo_player_get_duration (player);
if (dur < 0) {
g_signal_emit (player, demo_player_signals[SIGNAL_ERROR], 0,
"Seek-to failed: could not determine duration");
return;
}
new_second = MAX (0, dur + second);
} else {
new_second = second;
}
_seek_to (player, new_second);
}
static gint
demo_player_get_position_func (DemoPlayer * player)
{
DemoPlayerPrivate *priv = DEMO_PLAYER_GET_PRIVATE (player);
gint64 pos;
if (!priv->pipeline)
return -1;
if (!gst_element_query_position (priv->pipeline, GST_FORMAT_TIME, &pos)
|| pos < 0) {
return -1;
}
return (gint) (pos / GST_SECOND);
}
static gint
demo_player_get_duration_func (DemoPlayer * player)
{
DemoPlayerPrivate *priv = DEMO_PLAYER_GET_PRIVATE (player);
gint64 dur;
if (!priv->pipeline)
return -1;
if (!gst_element_query_duration (priv->pipeline, GST_FORMAT_TIME, &dur)
|| dur < 0) {
return -1;
}
return (gint) (dur / GST_SECOND);
}
/* Method wrappers */
void
demo_player_scale_rate (DemoPlayer * player, gdouble scale)
{
g_return_if_fail (DEMO_IS_PLAYER (player));
DEMO_PLAYER_GET_CLASS (player)->scale_rate (player, scale);
}
void
demo_player_set_rate (DemoPlayer * player, gdouble new_rate)
{
g_return_if_fail (DEMO_IS_PLAYER (player));
DEMO_PLAYER_GET_CLASS (player)->set_rate (player, new_rate);
}
void
demo_player_load_uri (DemoPlayer * player, gchar * uri)
{
g_return_if_fail (DEMO_IS_PLAYER (player));
DEMO_PLAYER_GET_CLASS (player)->load_uri (player, uri);
}
void
demo_player_play (DemoPlayer * player)
{
g_return_if_fail (DEMO_IS_PLAYER (player));
DEMO_PLAYER_GET_CLASS (player)->play (player);
}
void
demo_player_pause (DemoPlayer * player)
{
g_return_if_fail (DEMO_IS_PLAYER (player));
DEMO_PLAYER_GET_CLASS (player)->pause (player);
}
void
demo_player_seek_by (DemoPlayer * player, gint seconds)
{
g_return_if_fail (DEMO_IS_PLAYER (player));
DEMO_PLAYER_GET_CLASS (player)->seek_by (player, seconds);
}
void
demo_player_seek_to (DemoPlayer * player, gint second)
{
g_return_if_fail (DEMO_IS_PLAYER (player));
DEMO_PLAYER_GET_CLASS (player)->seek_to (player, second);
}
gint
demo_player_get_position (DemoPlayer * player)
{
g_return_val_if_fail (DEMO_IS_PLAYER (player), -1);
return DEMO_PLAYER_GET_CLASS (player)->get_position (player);
}
gint
demo_player_get_duration (DemoPlayer * player)
{
g_return_val_if_fail (DEMO_IS_PLAYER (player), -1);
return DEMO_PLAYER_GET_CLASS (player)->get_duration (player);
}
/* GObject overrides */
static void
demo_player_get_property (GObject * object,
guint property_id, GValue * value, GParamSpec * pspec)
{
DemoPlayer *player = DEMO_PLAYER (object);
DemoPlayerPrivate *priv = DEMO_PLAYER_GET_PRIVATE (player);
switch (property_id) {
case PROP_RATE:
g_value_set_double (value, priv->rate);
break;
case PROP_STRIDE:
g_object_get_property (G_OBJECT (priv->scaletempo), "stride", value);
break;
case PROP_OVERLAP:
g_object_get_property (G_OBJECT (priv->scaletempo), "overlap", value);
break;
case PROP_SEARCH:
g_object_get_property (G_OBJECT (priv->scaletempo), "search", value);
break;
case PROP_DISABLED:
g_value_set_boolean (value, priv->is_disabled);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
demo_player_set_property (GObject * object,
guint property_id, const GValue * value, GParamSpec * pspec)
{
DemoPlayer *player = DEMO_PLAYER (object);
DemoPlayerPrivate *priv = DEMO_PLAYER_GET_PRIVATE (player);
switch (property_id) {
case PROP_STRIDE:
g_object_set_property (G_OBJECT (priv->scaletempo), "stride", value);
break;
case PROP_OVERLAP:
g_object_set_property (G_OBJECT (priv->scaletempo), "overlap", value);
break;
case PROP_SEARCH:
g_object_set_property (G_OBJECT (priv->scaletempo), "search", value);
break;
case PROP_DISABLED:{
gdouble rate = priv->rate;
gint pos = demo_player_get_position (player);
GstState end_state;
GstElement *new_sink;
priv->is_disabled = g_value_get_boolean (value);
g_debug ("Scaletempo: %s", priv->is_disabled ? "disabled" : "enabled");
end_state =
(GST_STATE (priv->pipeline) ==
GST_STATE_PLAYING) ? GST_STATE_PLAYING : GST_STATE_PAUSED;
if (!_set_state_and_wait (player, GST_STATE_NULL, 10 * GST_SECOND,
"Unable to disable"))
break;
new_sink =
(priv->is_disabled) ? priv->scalerate_line : priv->scaletempo_line;
g_object_set (G_OBJECT (priv->pipeline), "audio-sink", new_sink, NULL);
if (pos > 0 || (rate && rate != 1.0)) {
_set_state_and_wait (player, GST_STATE_PAUSED, 10 * GST_SECOND,
"Unable to keep playback position and rate");
_set_rate (player, rate, pos);
}
gst_element_set_state (priv->pipeline, end_state);
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
/* GTypeInfo functions */
static void
demo_player_init (GTypeInstance * instance, gpointer klass)
{
DemoPlayer *player = (DemoPlayer *) instance;
DemoPlayerPrivate *priv = DEMO_PLAYER_GET_PRIVATE (player);
priv->scaletempo = gst_element_factory_make ("scaletempo", "scaletempo");
if (!priv->scaletempo) {
g_error ("Unable to make scaletempo element.");
}
priv->rate = 1.0;
priv->pipeline = NULL;
priv->ignore_state_change = FALSE;
priv->is_disabled = FALSE;
}
static void
demo_player_class_init (gpointer klass, gpointer class_data)
{
DemoPlayerClass *player_class = (DemoPlayerClass *) klass;
GObjectClass *as_object_class = G_OBJECT_CLASS (klass);
GType type;
g_type_class_add_private (klass, sizeof (DemoPlayerPrivate));
/* DemoPlayer */
player_class->scale_rate = demo_player_scale_rate_func;
player_class->set_rate = demo_player_set_rate_func;
player_class->load_uri = demo_player_load_uri_func;
player_class->play = demo_player_play_func;
player_class->pause = demo_player_pause_func;
player_class->seek_by = demo_player_seek_by_func;
player_class->seek_to = demo_player_seek_to_func;
player_class->get_position = demo_player_get_position_func;
player_class->get_duration = demo_player_get_duration_func;
/* GObject */
as_object_class->get_property = demo_player_get_property;
as_object_class->set_property = demo_player_set_property;
/* Properties */
g_object_class_install_property (as_object_class, PROP_RATE,
g_param_spec_double ("rate", "Rate", "Current playback rate",
-128, 128, 1.0, G_PARAM_READABLE));
g_object_class_install_property (as_object_class, PROP_STRIDE,
g_param_spec_uint ("stride", "Stride Length",
"Length in milliseconds to output each stride", 1, 10000, 60,
G_PARAM_READWRITE));
g_object_class_install_property (as_object_class, PROP_OVERLAP,
g_param_spec_double ("overlap", "Overlap Length",
"Percentage of stride to overlap", 0, 1, .2, G_PARAM_READWRITE));
g_object_class_install_property (as_object_class, PROP_SEARCH,
g_param_spec_uint ("search", "Search Length",
"Length in milliseconds to search for best overlap position", 0,
10000, 14, G_PARAM_READWRITE));
g_object_class_install_property (as_object_class, PROP_DISABLED,
g_param_spec_boolean ("disabled", "disable scaletempo",
"Disable scaletempo and scale bothe tempo and pitch", FALSE,
G_PARAM_READWRITE));
/* Signals */
type = G_TYPE_FROM_CLASS (klass);
demo_player_signals[SIGNAL_ERROR] = g_signal_new ("error", type,
G_SIGNAL_RUN_FIRST, 0, NULL, NULL,
g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
demo_player_signals[SIGNAL_RATE_CHANGE] = g_signal_new ("rate-changed", type,
G_SIGNAL_RUN_FIRST, 0, NULL, NULL,
g_cclosure_marshal_VOID__DOUBLE, G_TYPE_NONE, 1, G_TYPE_DOUBLE);
demo_player_signals[SIGNAL_PLAYING_STARTED] =
g_signal_new ("playing-started", type, G_SIGNAL_RUN_FIRST, 0, NULL, NULL,
g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
demo_player_signals[SIGNAL_PLAYING_PAUSED] =
g_signal_new ("playing-paused", type, G_SIGNAL_RUN_FIRST, 0, NULL, NULL,
g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
demo_player_signals[SIGNAL_PLAYING_ENDED] =
g_signal_new ("playing-ended", type, G_SIGNAL_RUN_FIRST, 0, NULL, NULL,
g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
}
GType
demo_player_get_type (void)
{
static GType type = 0;
if (G_UNLIKELY (type == 0)) {
static const GTypeInfo info = {
sizeof /* Class */ (DemoPlayerClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) demo_player_class_init,
(GClassFinalizeFunc) NULL,
(gconstpointer) NULL, /* class_data */
sizeof /* Instance */ (DemoPlayer),
/* n_preallocs */ 0,
(GInstanceInitFunc) demo_player_init,
(const GTypeValueTable *) NULL
};
type = g_type_register_static (G_TYPE_OBJECT, "DemoPlayer", &info, 0);
}
return type;
}