Ubuntu-fr

hasardel

[Vala] Problème avec gstreamer

Salut,

Je développe un lecteur multimédia avec gstreamer en Vala.
Le lecteur multimédia doit passer à la vidéo suivante quand le signal de EOS (fin de stream) est émis.

J'ai une erreur de segmentation à la troisième lecture.
J'aimerais savoir si il y une erreur dans mon code.

Voici le code :

using Gst;

public class TestOggDemux
{
    private Pipeline pipeline;
    private Element fileSrc;
    private Element queueVorbis;
    private Element queueTheora;
    private bool videoIndex = true;
    
    public TestOggDemux()
    {
        //création de la pipeline movie
        pipeline = new Pipeline("TestOggDemux");

        //création des éléments de la pipeline
        fileSrc = ElementFactory.make("filesrc", "TestOggDemux_FileSrc");
        var oggDemux = ElementFactory.make("oggdemux", "TestOggDemux_OggDemux");
        queueVorbis = ElementFactory.make("queue", "TestOggDemux_QueueVorbis");
        var vorbisDec = ElementFactory.make("vorbisdec", "TestOggDemux_VorbisDec");
        var autoAudioSink = ElementFactory.make("autoaudiosink", "TestOggDemux_AutoAudioSink");
        queueTheora = ElementFactory.make("queue", "TestOggDemux_QueueTheora");
        var theoraDec = ElementFactory.make("theoradec", "TestOggDemux_TheoraDec");
        var xvImageSink = ElementFactory.make("xvimagesink", "TestOggDemux_XVImageSink");
        
        //ajout des éléments à la pipeline
        pipeline.add_many(fileSrc, oggDemux, queueVorbis, vorbisDec, autoAudioSink, queueTheora, theoraDec, xvImageSink);
        
        //linkage des éléments de la pipeline
        fileSrc.link(oggDemux);
        oggDemux.pad_added.connect(on_pad_added);
        queueVorbis.link(vorbisDec);
        vorbisDec.link(autoAudioSink);
        queueTheora.link(theoraDec);
        theoraDec.link(xvImageSink);
        
        //configuration de la pipeline
        fileSrc.set("location", "1.ogg");
        
        //ajout d'un bus de message à la pipeline
        var bus = pipeline.get_bus();
        bus.add_watch(on_bus_callback);
        
        //le pipeline est ready
        pipeline.set_state(State.PLAYING);
    }
    
    private void on_pad_added(Element element, Pad pad)
    {
        string mime = pad.caps.get_structure(0).get_name();
    
        if (mime == "audio/x-vorbis")
        {
            pad.link(queueVorbis.get_static_pad("sink"));
        }

        if (mime == "video/x-theora")
        {
            pad.link(queueTheora.get_static_pad("sink"));
        }
    }
    
    private bool on_bus_callback(Bus bus, Message message)
    {
        if (message.type == MessageType.ERROR)
        {
            stdout.printf("message error\n");
        }
        else if (message.type == MessageType.EOS)
        {            
            stdout.printf("end of stream\n");
            pipeline.set_state(State.NULL);
            videoIndex = !videoIndex;
            if (videoIndex)
            {
                fileSrc.set("location", "1.ogg");
            }
            else
            {
                fileSrc.set("location", "2.ogg");
            }
            pipeline.set_state(State.PLAYING);        
        }
    
        return true;
    }
    
    public static int main(string[] args)
    {
        Gst.init(ref args);
        
        new TestOggDemux();
        
        new MainLoop().run();
        
        return 0;
    }
}

La ligne de compilation :

valac TestOggDemux.vala -o TestOggDemux --pkg gstreamer-0.10

Voici ce que me dit gdb :

Program received signal SIGSEGV, Segmentation fault.
[Switching to Thread 0x7fffe5d1f700 (LWP 2673)]
0x00007ffff4732ad9 in ?? ()
   from /usr/lib/x86_64-linux-gnu/gstreamer-0.10/libgstogg.so
(gdb) bt
#0  0x00007ffff4732ad9 in ?? ()
   from /usr/lib/x86_64-linux-gnu/gstreamer-0.10/libgstogg.so
#1  0x00007ffff4736291 in ?? ()
   from /usr/lib/x86_64-linux-gnu/gstreamer-0.10/libgstogg.so
#2  0x00007ffff473b9c8 in ?? ()
   from /usr/lib/x86_64-linux-gnu/gstreamer-0.10/libgstogg.so
#3  0x00007ffff473dcbb in ?? ()
   from /usr/lib/x86_64-linux-gnu/gstreamer-0.10/libgstogg.so
#4  0x00007ffff7b76dcc in ?? ()
   from /usr/lib/x86_64-linux-gnu/libgstreamer-0.10.so.0
#5  0x00007ffff7619248 in ?? () from /lib/x86_64-linux-gnu/libglib-2.0.so.0
#6  0x00007ffff76189e5 in ?? () from /lib/x86_64-linux-gnu/libglib-2.0.so.0
#7  0x00007ffff7399e9a in start_thread (arg=0x7fffe5d1f700)
    at pthread_create.c:308
#8  0x00007ffff70c74bd in clone ()
    at ../sysdeps/unix/sysv/linux/x86_64/clone.S:112
#9  0x0000000000000000 in ?? ()

Dernière modification par hasardel (Le 02/07/2012, à 08:21)

hasardel

Re : [Vala] Problème avec gstreamer

Voici le code c généré avec valac :

/* TestOggDemux.c generated by valac 0.14.2, the Vala compiler
 * generated from TestOggDemux.vala, do not modify */


#include <glib.h>
#include <glib-object.h>
#include <gst/gst.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <gobject/gvaluecollector.h>


#define TYPE_TEST_OGG_DEMUX (test_ogg_demux_get_type ())
#define TEST_OGG_DEMUX(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TEST_OGG_DEMUX, TestOggDemux))
#define TEST_OGG_DEMUX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TEST_OGG_DEMUX, TestOggDemuxClass))
#define IS_TEST_OGG_DEMUX(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TEST_OGG_DEMUX))
#define IS_TEST_OGG_DEMUX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TEST_OGG_DEMUX))
#define TEST_OGG_DEMUX_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TEST_OGG_DEMUX, TestOggDemuxClass))

typedef struct _TestOggDemux TestOggDemux;
typedef struct _TestOggDemuxClass TestOggDemuxClass;
typedef struct _TestOggDemuxPrivate TestOggDemuxPrivate;
#define _gst_object_unref0(var) ((var == NULL) ? NULL : (var = (gst_object_unref (var), NULL)))
#define _gst_caps_unref0(var) ((var == NULL) ? NULL : (var = (gst_caps_unref (var), NULL)))
#define _g_free0(var) (var = (g_free (var), NULL))
#define _test_ogg_demux_unref0(var) ((var == NULL) ? NULL : (var = (test_ogg_demux_unref (var), NULL)))
#define _g_main_loop_unref0(var) ((var == NULL) ? NULL : (var = (g_main_loop_unref (var), NULL)))
typedef struct _ParamSpecTestOggDemux ParamSpecTestOggDemux;

struct _TestOggDemux {
    GTypeInstance parent_instance;
    volatile int ref_count;
    TestOggDemuxPrivate * priv;
};

struct _TestOggDemuxClass {
    GTypeClass parent_class;
    void (*finalize) (TestOggDemux *self);
};

struct _TestOggDemuxPrivate {
    GstPipeline* pipeline;
    GstElement* fileSrc;
    GstElement* queueVorbis;
    GstElement* queueTheora;
    gboolean videoIndex;
};

struct _ParamSpecTestOggDemux {
    GParamSpec parent_instance;
};


static gpointer test_ogg_demux_parent_class = NULL;

gpointer test_ogg_demux_ref (gpointer instance);
void test_ogg_demux_unref (gpointer instance);
GParamSpec* param_spec_test_ogg_demux (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void value_set_test_ogg_demux (GValue* value, gpointer v_object);
void value_take_test_ogg_demux (GValue* value, gpointer v_object);
gpointer value_get_test_ogg_demux (const GValue* value);
GType test_ogg_demux_get_type (void) G_GNUC_CONST;
#define TEST_OGG_DEMUX_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_TEST_OGG_DEMUX, TestOggDemuxPrivate))
enum  {
    TEST_OGG_DEMUX_DUMMY_PROPERTY
};
TestOggDemux* test_ogg_demux_new (void);
TestOggDemux* test_ogg_demux_construct (GType object_type);
static void test_ogg_demux_on_pad_added (TestOggDemux* self, GstElement* element, GstPad* pad);
static void _test_ogg_demux_on_pad_added_gst_element_pad_added (GstElement* _sender, GstPad* pad, gpointer self);
static gboolean test_ogg_demux_on_bus_callback (TestOggDemux* self, GstBus* bus, GstMessage* message);
static gboolean _test_ogg_demux_on_bus_callback_gst_bus_func (GstBus* bus, GstMessage* message, gpointer self);
gint test_ogg_demux_main (gchar** args, int args_length1);
static void test_ogg_demux_finalize (TestOggDemux* obj);


static void _test_ogg_demux_on_pad_added_gst_element_pad_added (GstElement* _sender, GstPad* pad, gpointer self) {
    test_ogg_demux_on_pad_added (self, _sender, pad);
}


static gboolean _test_ogg_demux_on_bus_callback_gst_bus_func (GstBus* bus, GstMessage* message, gpointer self) {
    gboolean result;
    result = test_ogg_demux_on_bus_callback (self, bus, message);
    return result;
}


TestOggDemux* test_ogg_demux_construct (GType object_type) {
    TestOggDemux* self = NULL;
    GstPipeline* _tmp0_;
    GstElement* _tmp1_ = NULL;
    GstElement* _tmp2_ = NULL;
    GstElement* oggDemux;
    GstElement* _tmp3_ = NULL;
    GstElement* _tmp4_ = NULL;
    GstElement* vorbisDec;
    GstElement* _tmp5_ = NULL;
    GstElement* autoAudioSink;
    GstElement* _tmp6_ = NULL;
    GstElement* _tmp7_ = NULL;
    GstElement* theoraDec;
    GstElement* _tmp8_ = NULL;
    GstElement* xvImageSink;
    GstPipeline* _tmp9_;
    GstElement* _tmp10_;
    GstElement* _tmp11_;
    GstElement* _tmp12_;
    GstElement* _tmp13_;
    GstElement* _tmp14_;
    GstElement* _tmp15_;
    GstElement* _tmp16_;
    GstPipeline* _tmp17_;
    GstBus* _tmp18_ = NULL;
    GstBus* bus;
    GstPipeline* _tmp19_;
    self = (TestOggDemux*) g_type_create_instance (object_type);
    _tmp0_ = (GstPipeline*) gst_pipeline_new ("TestOggDemux");
    gst_object_ref_sink (_tmp0_);
    _gst_object_unref0 (self->priv->pipeline);
    self->priv->pipeline = _tmp0_;
    _tmp1_ = gst_element_factory_make ("filesrc", "TestOggDemux_FileSrc");
    gst_object_ref_sink (_tmp1_);
    _gst_object_unref0 (self->priv->fileSrc);
    self->priv->fileSrc = _tmp1_;
    _tmp2_ = gst_element_factory_make ("oggdemux", "TestOggDemux_OggDemux");
    gst_object_ref_sink (_tmp2_);
    oggDemux = _tmp2_;
    _tmp3_ = gst_element_factory_make ("queue", "TestOggDemux_QueueVorbis");
    gst_object_ref_sink (_tmp3_);
    _gst_object_unref0 (self->priv->queueVorbis);
    self->priv->queueVorbis = _tmp3_;
    _tmp4_ = gst_element_factory_make ("vorbisdec", "TestOggDemux_VorbisDec");
    gst_object_ref_sink (_tmp4_);
    vorbisDec = _tmp4_;
    _tmp5_ = gst_element_factory_make ("autoaudiosink", "TestOggDemux_AutoAudioSink");
    gst_object_ref_sink (_tmp5_);
    autoAudioSink = _tmp5_;
    _tmp6_ = gst_element_factory_make ("queue", "TestOggDemux_QueueTheora");
    gst_object_ref_sink (_tmp6_);
    _gst_object_unref0 (self->priv->queueTheora);
    self->priv->queueTheora = _tmp6_;
    _tmp7_ = gst_element_factory_make ("theoradec", "TestOggDemux_TheoraDec");
    gst_object_ref_sink (_tmp7_);
    theoraDec = _tmp7_;
    _tmp8_ = gst_element_factory_make ("xvimagesink", "TestOggDemux_XVImageSink");
    gst_object_ref_sink (_tmp8_);
    xvImageSink = _tmp8_;
    _tmp9_ = self->priv->pipeline;
    _tmp10_ = self->priv->fileSrc;
    _tmp11_ = self->priv->queueVorbis;
    _tmp12_ = self->priv->queueTheora;
    gst_bin_add_many ((GstBin*) _tmp9_, _tmp10_, oggDemux, _tmp11_, vorbisDec, autoAudioSink, _tmp12_, theoraDec, xvImageSink, NULL);
    _tmp13_ = self->priv->fileSrc;
    gst_element_link (_tmp13_, oggDemux);
    g_signal_connect (oggDemux, "pad-added", (GCallback) _test_ogg_demux_on_pad_added_gst_element_pad_added, self);
    _tmp14_ = self->priv->queueVorbis;
    gst_element_link (_tmp14_, vorbisDec);
    gst_element_link (vorbisDec, autoAudioSink);
    _tmp15_ = self->priv->queueTheora;
    gst_element_link (_tmp15_, theoraDec);
    gst_element_link (theoraDec, xvImageSink);
    _tmp16_ = self->priv->fileSrc;
    g_object_set ((GObject*) _tmp16_, "location", "1.ogg", NULL);
    _tmp17_ = self->priv->pipeline;
    _tmp18_ = gst_pipeline_get_bus (_tmp17_);
    bus = _tmp18_;
    gst_bus_add_watch_full (bus, G_PRIORITY_DEFAULT, _test_ogg_demux_on_bus_callback_gst_bus_func, test_ogg_demux_ref (self), test_ogg_demux_unref);
    _tmp19_ = self->priv->pipeline;
    gst_element_set_state ((GstElement*) _tmp19_, GST_STATE_PLAYING);
    _gst_object_unref0 (bus);
    _gst_object_unref0 (xvImageSink);
    _gst_object_unref0 (theoraDec);
    _gst_object_unref0 (autoAudioSink);
    _gst_object_unref0 (vorbisDec);
    _gst_object_unref0 (oggDemux);
    return self;
}


TestOggDemux* test_ogg_demux_new (void) {
    return test_ogg_demux_construct (TYPE_TEST_OGG_DEMUX);
}


static void test_ogg_demux_on_pad_added (TestOggDemux* self, GstElement* element, GstPad* pad) {
    GstPad* _tmp0_;
    GstCaps* _tmp1_ = NULL;
    GstCaps* _tmp2_;
    GstCaps* _tmp3_;
    const GstStructure* _tmp4_ = NULL;
    const gchar* _tmp5_ = NULL;
    gchar* _tmp6_;
    gchar* _tmp7_;
    gchar* mime;
    const gchar* _tmp8_;
    const gchar* _tmp13_;
    g_return_if_fail (self != NULL);
    g_return_if_fail (element != NULL);
    g_return_if_fail (pad != NULL);
    _tmp0_ = pad;
    g_object_get (_tmp0_, "caps", &_tmp1_, NULL);
    _tmp2_ = _tmp1_;
    _tmp3_ = _tmp2_;
    _tmp4_ = gst_caps_get_structure (_tmp3_, (guint) 0);
    _tmp5_ = gst_structure_get_name (_tmp4_);
    _tmp6_ = g_strdup (_tmp5_);
    _tmp7_ = _tmp6_;
    _gst_caps_unref0 (_tmp3_);
    mime = _tmp7_;
    _tmp8_ = mime;
    if (g_strcmp0 (_tmp8_, "audio/x-vorbis") == 0) {
        GstPad* _tmp9_;
        GstElement* _tmp10_;
        GstPad* _tmp11_ = NULL;
        GstPad* _tmp12_;
        _tmp9_ = pad;
        _tmp10_ = self->priv->queueVorbis;
        _tmp11_ = gst_element_get_static_pad (_tmp10_, "sink");
        _tmp12_ = _tmp11_;
        gst_pad_link (_tmp9_, _tmp12_);
        _gst_object_unref0 (_tmp12_);
    }
    _tmp13_ = mime;
    if (g_strcmp0 (_tmp13_, "video/x-theora") == 0) {
        GstPad* _tmp14_;
        GstElement* _tmp15_;
        GstPad* _tmp16_ = NULL;
        GstPad* _tmp17_;
        _tmp14_ = pad;
        _tmp15_ = self->priv->queueTheora;
        _tmp16_ = gst_element_get_static_pad (_tmp15_, "sink");
        _tmp17_ = _tmp16_;
        gst_pad_link (_tmp14_, _tmp17_);
        _gst_object_unref0 (_tmp17_);
    }
    _g_free0 (mime);
}


static gboolean test_ogg_demux_on_bus_callback (TestOggDemux* self, GstBus* bus, GstMessage* message) {
    gboolean result = FALSE;
    GstMessage* _tmp0_;
    GstMessageType _tmp1_;
    g_return_val_if_fail (self != NULL, FALSE);
    g_return_val_if_fail (bus != NULL, FALSE);
    g_return_val_if_fail (message != NULL, FALSE);
    _tmp0_ = message;
    _tmp1_ = _tmp0_->type;
    if (_tmp1_ == GST_MESSAGE_ERROR) {
        FILE* _tmp2_;
        _tmp2_ = stdout;
        fprintf (_tmp2_, "message error\n");
    } else {
        GstMessage* _tmp3_;
        GstMessageType _tmp4_;
        _tmp3_ = message;
        _tmp4_ = _tmp3_->type;
        if (_tmp4_ == GST_MESSAGE_EOS) {
            FILE* _tmp5_;
            GstPipeline* _tmp6_;
            gboolean _tmp7_;
            gboolean _tmp8_;
            GstPipeline* _tmp11_;
            _tmp5_ = stdout;
            fprintf (_tmp5_, "end of stream\n");
            _tmp6_ = self->priv->pipeline;
            gst_element_set_state ((GstElement*) _tmp6_, GST_STATE_NULL);
            _tmp7_ = self->priv->videoIndex;
            self->priv->videoIndex = !_tmp7_;
            _tmp8_ = self->priv->videoIndex;
            if (_tmp8_) {
                GstElement* _tmp9_;
                _tmp9_ = self->priv->fileSrc;
                g_object_set ((GObject*) _tmp9_, "location", "1.ogg", NULL);
            } else {
                GstElement* _tmp10_;
                _tmp10_ = self->priv->fileSrc;
                g_object_set ((GObject*) _tmp10_, "location", "2.ogg", NULL);
            }
            _tmp11_ = self->priv->pipeline;
            gst_element_set_state ((GstElement*) _tmp11_, GST_STATE_PLAYING);
        }
    }
    result = TRUE;
    return result;
}


gint test_ogg_demux_main (gchar** args, int args_length1) {
    gint result = 0;
    TestOggDemux* _tmp0_;
    TestOggDemux* _tmp1_;
    GMainLoop* _tmp2_;
    GMainLoop* _tmp3_;
    gst_init (&args_length1, &args);
    _tmp0_ = test_ogg_demux_new ();
    _tmp1_ = _tmp0_;
    _test_ogg_demux_unref0 (_tmp1_);
    _tmp2_ = g_main_loop_new (NULL, FALSE);
    _tmp3_ = _tmp2_;
    g_main_loop_run (_tmp3_);
    _g_main_loop_unref0 (_tmp3_);
    result = 0;
    return result;
}


int main (int argc, char ** argv) {
    g_mem_set_vtable (glib_mem_profiler_table);
    g_type_init ();
    return test_ogg_demux_main (argv, argc);
}


static void value_test_ogg_demux_init (GValue* value) {
    value->data[0].v_pointer = NULL;
}


static void value_test_ogg_demux_free_value (GValue* value) {
    if (value->data[0].v_pointer) {
        test_ogg_demux_unref (value->data[0].v_pointer);
    }
}


static void value_test_ogg_demux_copy_value (const GValue* src_value, GValue* dest_value) {
    if (src_value->data[0].v_pointer) {
        dest_value->data[0].v_pointer = test_ogg_demux_ref (src_value->data[0].v_pointer);
    } else {
        dest_value->data[0].v_pointer = NULL;
    }
}


static gpointer value_test_ogg_demux_peek_pointer (const GValue* value) {
    return value->data[0].v_pointer;
}


static gchar* value_test_ogg_demux_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
    if (collect_values[0].v_pointer) {
        TestOggDemux* object;
        object = collect_values[0].v_pointer;
        if (object->parent_instance.g_class == NULL) {
            return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
        } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
            return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
        }
        value->data[0].v_pointer = test_ogg_demux_ref (object);
    } else {
        value->data[0].v_pointer = NULL;
    }
    return NULL;
}


static gchar* value_test_ogg_demux_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
    TestOggDemux** object_p;
    object_p = collect_values[0].v_pointer;
    if (!object_p) {
        return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
    }
    if (!value->data[0].v_pointer) {
        *object_p = NULL;
    } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
        *object_p = value->data[0].v_pointer;
    } else {
        *object_p = test_ogg_demux_ref (value->data[0].v_pointer);
    }
    return NULL;
}


GParamSpec* param_spec_test_ogg_demux (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
    ParamSpecTestOggDemux* spec;
    g_return_val_if_fail (g_type_is_a (object_type, TYPE_TEST_OGG_DEMUX), NULL);
    spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
    G_PARAM_SPEC (spec)->value_type = object_type;
    return G_PARAM_SPEC (spec);
}


gpointer value_get_test_ogg_demux (const GValue* value) {
    g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST_OGG_DEMUX), NULL);
    return value->data[0].v_pointer;
}


void value_set_test_ogg_demux (GValue* value, gpointer v_object) {
    TestOggDemux* old;
    g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST_OGG_DEMUX));
    old = value->data[0].v_pointer;
    if (v_object) {
        g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_TEST_OGG_DEMUX));
        g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
        value->data[0].v_pointer = v_object;
        test_ogg_demux_ref (value->data[0].v_pointer);
    } else {
        value->data[0].v_pointer = NULL;
    }
    if (old) {
        test_ogg_demux_unref (old);
    }
}


void value_take_test_ogg_demux (GValue* value, gpointer v_object) {
    TestOggDemux* old;
    g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST_OGG_DEMUX));
    old = value->data[0].v_pointer;
    if (v_object) {
        g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_TEST_OGG_DEMUX));
        g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
        value->data[0].v_pointer = v_object;
    } else {
        value->data[0].v_pointer = NULL;
    }
    if (old) {
        test_ogg_demux_unref (old);
    }
}


static void test_ogg_demux_class_init (TestOggDemuxClass * klass) {
    test_ogg_demux_parent_class = g_type_class_peek_parent (klass);
    TEST_OGG_DEMUX_CLASS (klass)->finalize = test_ogg_demux_finalize;
    g_type_class_add_private (klass, sizeof (TestOggDemuxPrivate));
}


static void test_ogg_demux_instance_init (TestOggDemux * self) {
    self->priv = TEST_OGG_DEMUX_GET_PRIVATE (self);
    self->priv->videoIndex = TRUE;
    self->ref_count = 1;
}


static void test_ogg_demux_finalize (TestOggDemux* obj) {
    TestOggDemux * self;
    self = TEST_OGG_DEMUX (obj);
    _gst_object_unref0 (self->priv->pipeline);
    _gst_object_unref0 (self->priv->fileSrc);
    _gst_object_unref0 (self->priv->queueVorbis);
    _gst_object_unref0 (self->priv->queueTheora);
}


GType test_ogg_demux_get_type (void) {
    static volatile gsize test_ogg_demux_type_id__volatile = 0;
    if (g_once_init_enter (&test_ogg_demux_type_id__volatile)) {
        static const GTypeValueTable g_define_type_value_table = { value_test_ogg_demux_init, value_test_ogg_demux_free_value, value_test_ogg_demux_copy_value, value_test_ogg_demux_peek_pointer, "p", value_test_ogg_demux_collect_value, "p", value_test_ogg_demux_lcopy_value };
        static const GTypeInfo g_define_type_info = { sizeof (TestOggDemuxClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) test_ogg_demux_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (TestOggDemux), 0, (GInstanceInitFunc) test_ogg_demux_instance_init, &g_define_type_value_table };
        static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
        GType test_ogg_demux_type_id;
        test_ogg_demux_type_id = g_type_register_fundamental (g_type_fundamental_next (), "TestOggDemux", &g_define_type_info, &g_define_type_fundamental_info, 0);
        g_once_init_leave (&test_ogg_demux_type_id__volatile, test_ogg_demux_type_id);
    }
    return test_ogg_demux_type_id__volatile;
}


gpointer test_ogg_demux_ref (gpointer instance) {
    TestOggDemux* self;
    self = instance;
    g_atomic_int_inc (&self->ref_count);
    return instance;
}


void test_ogg_demux_unref (gpointer instance) {
    TestOggDemux* self;
    self = instance;
    if (g_atomic_int_dec_and_test (&self->ref_count)) {
        TEST_OGG_DEMUX_GET_CLASS (self)->finalize (self);
        g_type_free_instance ((GTypeInstance *) self);
    }
}

breizhodrome

Re : [Vala] Problème avec gstreamer

Bonsoir
dans l'exemple fourni sur live gnome, le programme utilise un entier comme index, ça permet de dépasser 1

---

Marty ! ça marche à la vapeur !

hasardel

Re : [Vala] Problème avec gstreamer

Oui mais dans cette exemple je n'ai besoin que d'un boolean puisque j'ai deux vidéo mais c'est vrai un entier aurait été aussi possible.

Le problème est je pense sur les pads dynamiques de oggdemux. J'ai réalisé une autre pipeline sans oggdemux et sa marche.
Sauf que le problème est que je ne sait pas si l'erreur de mémoire vient de mon code, du code généré par vala, ou de oggdemux.