GObject 设计思想

gobjec相关学习文章的list.

 

From gobject tutorial:

Ryan McDougall(2004)

 

http://wenku.baidu.com/link?url=QZYGO4DimnSAPGNRQ3tZSDfHaseTEG5tcLvWaoyjXgF4yEEE6YoTwBk7LFxxWxW-bmvLtcWB-By5xLLP-J7fhdcbfXUZLq8QQF29FOaenfC 

 

目的

本文档可用于两个目的:一是作为一篇学习Glib的GObject类型系统的教程,二是用作一篇按步骤使用GObject类型系统的入门文章。本文从如何用C语言来设计一个面向对象的类型系统着手,将GObject作为假设的解决方案。这种介绍的方式可以更好的解释这个开发库为何采用这种形式来设计,以及使用它为什么需要这些步骤。入门文章被安排在教程之后,使用了一种按步骤的、实际的、简洁的组织形式,这样对于某些更实际的程序员会更有用些。

读者

本文假想的读者是那些熟悉面向对象概念,但是刚开始接触GObject或者GTK+的开发人员。 我会认为您已经了解一门面向对象的语言,和一些C语言的基本命令。

动机

使用一种根本不支持面向对象的语言来编写一个面向的系统,这让人听上去有些疯狂。然而我们的确有一些很好的理由来做这样的事情。但在这里我不会试着去证明作者决定的正确性,并且我认为读者自己就有一些使用GLib的好理由。 这里我将指出这个系统的一些重要特性:

C是一门可移植性很强的语言
一个完全动态的系统,新的类型可以在运行时被添加上

这样系统的可扩展性要远强于一门标准的语言,所以新的特性也可以被很快的加入进来。

对面向对象语言来说,面向对象的特性和能力是用语法来定义的。然而,因为C并不支持面向对象,所以GObject系统必须手动的将面向对象的能力引入进来。一般来说,要实现这个目标需要做一些乏味的工作,甚至偶尔使用某些奇妙的手段。而我需要做的只是枚举出所有必要的步骤或“咒语”,使得程序执行起来,当然也希望能说明这些步骤对您的程序意味着什么。

1. 创建一个非继承的对象
设计

在面向对象领域,对象包含两种成员类型:数据和方法,它们处于同一个对象引用之下。有一种办法可以使用C来实现对象,那就是C的结构体(struct)。这样,普通公用成员可以是数据,方法则可以被实现为指向函数的指针。然而这样的实现却存在着一些严重的缺陷:别扭的语法,类型安全问题,缺少封装。而更实际的问题是-空间浪费严重。每个实例化后的对象需要一个4字节的指针来指向其每一个成员方法,而这些方法在同样的类封装范围里则是完全相同的,是冗余的。例如我们有一个类需要有4个成员方法,一个程序实例化了1000个这个类的对象,这样我们就浪费了接近16KB的空间。显然我们只需要保留一张包含这些指针的表,供这个类实例出的对象调用,这样就会节省下不少内存资源。

这张表就被称作虚方法表(vtable),GObject系统为每个类在内存中都保存了一份这张表。当你想调用一个虚方法时,必须先向系统请求查找这个对象所对应的虚方法表,而如上所述这张表包含了一个由函数指针组成的结构体。这样你就能复引用这个指针,通过它来调用方法了。

我们称这两种成员类型(数据和方法)为“实例结构体”和“类结构体”,并且将这两种结构体的实例分别称为“实例对象”和“类对象“。这两种结构体合并在一起形成了一个概念上的单元,我们称之为“类”,对这个“类”的实例则称作“对象”。

将这样的函数称作“虚函数”的原因是,调用它需要在运行时查找合适的函数指针,这样就能允许继承自它的类覆盖这个方法(只要更改虚函数表中的函数指针指向相应函数入口即可)。这样子类在向上转型(upcast)为父类时就会正常工作,就像我们所了解的C++里的虚方法一样。

尽管这样做可以节省内存和实现虚方法,但从语法上来看,将成员方法与对象用“点操作符”关联起来的能力就不具备了。(译者:因为点操作符关联的将是struct里的方法,而不是vtable里的)。因此我们将使用如下的命名约定来声明类的成员方法:NAMESPACE_TYPE_METHOD (OBJECT*, PARAMETERS)

非虚方法将被实现在一个普通的C函数里。虚方法其实也是实现在普通的C函数中,但不同的是这个函数实现时将调用虚函数表中某个合适的方法。私有成员将被实现为只存活在源文件中,而不被导出声明在头文件中。

注意:面向对象通常使用信息隐藏来作为封装的一部分,但在C语言中却没有简单的办法来隐藏私有成员。一种办法是将私有成员放到一个独立的结构体中,该结构体只定义在源文件中,再向你的公有对象结构体中添加一个指向这个私有类的指针。然而,在开放源代码的世界里,如果用户执意要做错误的事,这种保护也是毫无意义的。大部分开发者也只是简单的写上几句注释,标明这些成员他们应该被保护为私有的,希望用户能尊重这种封装上的区别。

现在为止我们有了两种不同的结构体,但我们没有好办法能通过一个实例化后的对象直接找到其虚方法表。但如我们在上面提到的,这应该是系统的职责,我们只要按要求向系统注册上新声明的类型,就应该能够处理这个问题。系统也要求我们去向它注册(对象的和类的)结构体初始化和销毁函数(以及其他的重要信息),这样我们的对象才能被正确的实例化出来。系统将通过枚举化所有的向它注册的类型来记录新的对象类型,要求所有实例化对象的第一个成员是一个指向它自己类的虚函数表的指针,每个虚函数表的第一个成员是它在系统中保存的枚举类型的数字表示。

注意:类型系统要求所有类型的对象结构体和类结构体的第一个成员是一个特殊结构体。在对象结构体中,该特殊结构体是一个指向其类型的对象。因为C语言保证在结构体中声明的第一个成员是在内存的最前面,因此这个类型对象可以通过将这个原对象的结构体转型而获得到。又因为类型系统要求我们将被继承的父结构体指针声明为子结构体的第一个成员,这样我们只需要在父类中声明一次这个类型对象,以后就能够通过一次转型而找到虚函数表了。

最后,我们还需要定义一些管理对象生命期的函数:创建类对象的函数,创建实例对象的函数,销毁类对象的函数,但不需要销毁实例对象的函数,因为实例对象的内存管理是一个比较复杂的问题,我们将把这个工作留给更高层的代码来做。

代码(头文件)

a. 用struct来创建实例对象和类对象,实现“C风格”的对象

注意:对结构体命名一般要在名字前添加下划线,然后使用前置类型定义typedef。这是因为C的语法不允许你在SomeObject中声明SomeObject指针(这对定义链表之类的数据结构很方便)(译者:如果非要这样用,则需要在类型前加上struct)。按上面的命名约定,我们还创建了一个命名域,叫做“Some”。

/* “实例结构体”定义所有的数据域,实例对象将是唯一的 */
 

  1. typedef struct _SomeObject SomeObject;
    struct _SomeObject
    {
    GTypeInstance gtype;

    gint m_a;
    gchar* m_b;
    gfloat m_c;
    };





/* “类结构体”定义所有的方法函数,类对象将是共享的 */
 

  1. typedef struct _SomeObjectClass SomeObjectClass;
    struct _SomeObjectClass
    {
    GTypeClass gtypeclass;

    void (*method1) (SomeObject *self, gint);
    void (*method2) (SomeObject *self, gchar*);
    };





b. 声明一个"get_type"函数,第一次调用该函数时,函数负责向系统注册上对象的类型,并返回系统返回的一个GType类型值,在此后的调用就会直接返回该GType值。该值实际上是一个系统用来区别已注册类型的整型数字。由于函数是SomeObject类型特有的,我们在它前面加上“some_object_"。

/* 该方法将返回我们新声明的对象类型所关联的GType类型 */
GType some_object_get_type (void);

c. 声明一些用来管理对象生命期的函数:初始化时创建对象的函数,结束时销毁对象的函数。

/* 类/实例的初始化/销毁函数。它们的标记在gtype.h中定义。 */
void some_object_class_init (gpointer g_class, gpointer class_data);
void some_object_class_final (gpointer g_class, gpointer class_data);
void some_object_instance_init (GTypeInstance *instance, gpointer g_class);

d. 用上面我们约定的方式来命名成员方法函数。

/* 所有这些函数都是SomeObject的方法. */
void some_object_method1 (SomeObject *self, gint); /* virtual */
void some_object_method2 (SomeObject *self, gchar*); /* virtual */
void some_object_method3 (SomeObject *self, gfloat); /* non-virtual */

e. 创建一些样板式代码(boiler-plate code),符合规则的同时也让事情更简单一些

/* 方便的宏定义 */
#define SOME_OBJECT_TYPE (some_object_get_type ())
#define SOME_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOME_OBJECT_TYPE, SomeObject))
#define SOME_OBJECT_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), SOME_OBJECT_TYPE, SomeObjectClass))
#define SOME_IS_OBJECT(obj) (G_TYPE_CHECK_TYPE ((obj), SOME_OBJECT_TYPE))
#define SOME_IS_OBJECT_CLASS(c) (G_TYPE_CHECK_CLASS_TYPE ((c), SOME_OBJECT_TYPE))
#define SOME_OBJECT_GET_CLASS(obj)(G_TYPE_INSTANCE_GET_CLASS ((obj), SOME_OBJECT_TYPE, SomeObjectClass))

代码(源程序)

现在可以实现那些刚刚声明过的函数了。

注意:由于虚函数是一些函数指针,我们还要创建一些可被寻址的普通C函数(命名以"impl"结尾,并且不被导出到头文件中),虚函数将被实现为指向这些函数。

 

  1. a. 实现虚方法。

    /* 虚函数中指向的普通函数 */
    void some_object_method1_impl (SomeObject *self, gint a)
    {
    self->m_a = a;
    g_print ("Method1: %i\n", self->m_a);
    }

    void some_object_method2_impl (SomeObject *self, gchar* b)
    {
    self->m_b = b;
    g_print ("Method2: %s\n", self->m_b);
    }





b. 实现所有公有方法。实现虚方法时,我们必须使用“GET_CLASS”宏来从类型系统中获取到类对象,用以调用虚函数表中的虚方法。非虚方法时,直接写实现代码即可。

 

  1. /* 公有方法 */
    void some_object_method1 (SomeObject *self, gint a)
    {
    SOME_OBJECT_GET_CLASS (self)->method1 (self, a);
    }

    void some_object_method2 (SomeObject *self, gchar* b)
    {
    SOME_OBJECT_GET_CLASS (self)->method2 (self, b);
    }

    void some_object_method3 (SomeObject *self, gfloat c)
    {
    self->m_c = c;
    g_print ("Method3: %f\n", self->m_c);
    }





c. 实现初始化/销毁方法。在这两个方法中,系统传入的参数是指向该对象的泛型指针(我们相信这个指针的确指向一个合适的对象),所以我们在使用它之前必须将其转型为合适的类型。

/* 该函数将在类对象创建时被调用 */
 

  1. void some_object_class_init(gpointer g_class, gpointer class_data)
    {
    SomeObjectClass *this_class = SOME_OBJECT_CLASS (g_class);

    /* 填写类结构体的方法成员 (本例只存在一个虚函数表) */
    this_class->method1 = &some_object_method1_impl;
    this_class->method2 = &some_object_method2_impl;
    }

    /* 该函数在类对象不再被使用时调用 */
    void some_object_class_final (gpointer g_class, gpointer class_data)
    {
    /* 该对象被销毁时不需要做任何动作,因为它不存在任何指向动态分配的
    资源的指针或者引用。 */
    }

    /* 该函数在实例对象被创建时调用。系统通过g_class实例的类来传递该实例的类。 */
    void some_object_instance_init (GTypeInstance *instance, gpointer g_class)
    {
    SomeObject *this_object = SOME_OBJECT (instance);

    /* 填写实例结构体中的成员变量 */
    this_object->m_a = 42;
    this_object->m_b = 3.14;
    this_object->m_c = NULL;
    }





d. 实现能够返回给调用者SomeObject的GType的函数。该函数在第一次运行时,它通过向系统注册SomeObject来获取到GType。该 GType将被保存在一个静态变量中,以后该函数再被调用时就无须注册可以直接返回该数值了。虽然可以使用一个独立的函数来注册该类型,但这样的实现可以保证类在使用前是注册过的,该函数通常在实例化第一个对象时被调用。

 

  1. /* 因为该类没有父类,所以父类函数是空的 */
    GType some_object_get_type (void)
    {
    static GType type = 0;

    if (type == 0)
    {
    /* 这是系统用来完整描述要注册的类型是如何被创建、初始化和销毁的结构体。 */
    static const GTypeInfo type_info =
    {
    sizeof (SomeObjectClass),
    NULL, /* 父类初始化函数 */
    NULL, /* 父类销毁函数 */
    some_object_class_init, /* 类对象初始化函数 */
    some_object_class_final, /* 类对象销毁函数 */
    NULL, /* 类数据 */
    sizeof (SomeObject),
    0, /* 预分配的字节数 */
    some_object_instance_init /* 实例对象初始化函数 */
    };

    /* 因为我们的类没有父类,所以它将被认为是“基础类(fundamental)”,
    因此我们必须要告诉系统,该类既是一个复合结构的类(与浮点型,整型,
    或者指针不同),而且是可以被实例化的(系统可以创建实例对象,相反如接口
    或者抽象类则不能被实例化) */
    static const GTypeFundamentalInfo fundamental_info =
    {
    G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE
    };

    type = g_type_register_fundamental

    g_type_fundamental_next (), /* 下一个可用的GType */
    "SomeObjectType", /* 类型的名称 */
    &type_info, /* 上面定义的type_info */
    &fundamental_info, /* 上面定义的fundamental_info */
    0 /* 类型不是抽象的 */
    );
    }

    return type;
    }





/* 让我们来编写一个测试用例吧! */

 

  1. int main()
    {
    SomeObject *testobj = NULL;

    /* 类型系统初始化 */
    g_type_init ();

    /* 让系统创建实例对象 */
    testobj = SOME_OBJECT (g_type_create_instance (some_object_get_type()));

    /* 调用我们定义了的方法 */
    if (testobj)
    {
    g_print ("%d\n", testobj->m_a);
    some_object_method1 (testobj, 32);
    g_print ("%s\n", testobj->m_b);
    some_object_method2 (testobj, "New string.");
    g_print ("%f\n", testobj->m_c);
    some_object_method3 (testobj, 6.9);
    }

    return 0;
    }


 

  1.  





还需要考虑的

我们已经用C实现了第一个对象,但是做了很多工作,而且这并不算是真正的面向对象,因为我们故意没有提及任何关于“继承”的方法。在下一节我们将看到如何利用别人的代码,使SomeObject继承于内建的类GObject。

尽管在下文中我们将重用上面讨论的思想和模型,但是创建一个基础类使得它能够像其它的GTK+代码一样,是一件非常困难和深入的事情。因此强烈建议您创建新的类时总是继承于GObject,它会帮您做大量背后的工作,使得您的类能符合GTK+的要求。

2.使用内建的宏定义来自动生成代码
设计

您可能已经注意到了,我们上面所做的大部分工作基本上都是机械的、模板化的工作。大多数的函数都不并是通用的,每创建一次类我们就需要重写一遍。很显然这就是为什么我们发明了计算机的原因 - 让工作自动化,让我们的生活更简单!

OK,其实我们很幸运,C的预处理器将允许我们编写宏定义,这些宏定义在编译时会展开成为合适的C代码,来生成我们需要的类型定义。其实使用宏定义还能帮助我们减少一些低级错误。

然而,自动化将使得我们失去对定义处理的灵活性。在上面描述的步骤中,我们能有许多可能的变化,但一个宏定义却只能实现一种展开。如果这个宏定义提供了轻量级的展开,但我们想要的是一个完整的类型,这样我们仍然需要手写一大堆代码。如果宏定义提供了完整的展开,但我们需要的却是一种轻量级的类型,我们将得到许多冗余的代码,花许多时间来填写这些用不上的桩代码,甚至是一些错误的代码。不幸的是C预处理器并没有设计成能够自动发现我们感兴趣的代码生成方式,它只包含了最有限的功能。

代码

创建一个新类型的代码非常简单:

G_DEFINE_TYPE_EXTENDED (TypeName, function_prefix, PARENT_TYPE, GTypeFlags, CODE)。

第一个参数是类的名称。第二个是函数名称的前缀,这使得我们的命名规则能保持一致。第三个是父类的GType。第四个是会被添加到!GTypeInfo结构体里的!GTypeFlag。第五个是在类型被注册后应该立刻被执行的代码。

看看下面的代码将被展开成为什么样将会给我们更多的启发。

G_DEFINE_TYPE_EXTENDED (SomeObject, some_object, 0, some_function())

注意:实际展开后的代码将随着系统版本不同而不同。你应该总是检查一下展开后的结果而不是凭主观臆断。

展开后的代码(清理了空格):

 

  1. static void some_object_init (SomeObject *self);
    static void some_object_class_init (SomeObjectClass *klass);
    static gpointer some_object_parent_class = ((void *)0);

    static void some_object_class_intern_init (gpointer klass)
    {
    some_object_parent_class = g_type_class_peek_parent (klass);
    some_object_class_init ((SomeObjectClass*) klass);
    }

    GType some_object_get_type (void)
    {
    static GType g_define_type_id = 0;
    if ((g_define_type_id == 0))
    {
    static const GTypeInfo g_define_type_info =
    {
    sizeof (SomeObjectClass),
    (GBaseInitFunc) ((void *)0),
    (GBaseFinalizeFunc) ((void *)0),
    (GClassInitFunc) some_object_class_intern_init,
    (GClassFinalizeFunc) ((void *)0),
    ((void *)0),
    sizeof (SomeObject),
    0,
    (GInstanceInitFunc) some_object_init,
    };

    g_define_type_id = g_type_register_static
    (
    G_TYPE_OBJECT,
    "SomeObject",
    &g_define_type_info,
    (GTypeFlags) 0
    );

    { some_function(); }

    }

    return g_define_type_id;
    }




注意:该宏定义声明了一个静态变量“_parent_class",它是一个指针,指向我们打算创建对象的父类。当我们要找到虚方法继承自哪里时它会派上用场,可以用于链式触发处理/销毁函数(译者:下面会介绍)。这些处理/销毁函数几乎总是虚函数。我们接下来的代码将不再使用这个结构,因为有其它的函数能够不使用静态变量而做到这一点。

你应该注意到了,这个宏定义没有定义父类的初始化、销毁函数以及类对象的销毁函数。那么如果你需要这些函数,就得自己动手了。

3.创建一个继承自GObject的对象


设计

 

尽管我们现在能够生成一个基本的对象,但事实上我们故意略过了本类型系统的上下文:作为一个复杂的开发库套件的基础 -那就是图形库GTK+。GTK+的设计要求所有的类应该继承自一个根类。这样就至少能允许一些公共的基础功能能够被共享:如支持信号(让消息可以很容易的从一个对象传递到另一个),使用引用计数来管理对象生命期,支持属性(针对对象的数据成员生成简单的setting和getting函数),支持构造和析构函数(用来设置信号、引用计数器、属性)。当我们让对象继承自GObject时,我们就获得了上述的一切,并且当与其它基于GObject的库交互时会很容易。然而,本章节我们不讨论信号、引用计数和属性,或者任何其它专门的特性,这里我们将详细描述类型系统中继承是如何工作的。
我们都知道,如果高档轿车继承自轿车,那么高档轿车就是轿车加上一些新的特性。那如何让系统去实现这样的功能呢?其实可以使用结构体的一个特性来实现:结构体里的第一个成员一定是在内存的最前面。只要我们要求所有的对象将它们的基类声明为它们自己结构体的第一个成员,那么我们就能迅速的将指向某个对象的指针转型为指向它基类的指针!尽管这个技巧很好用,并且语法上非常干净,但这种转型的方式只适用于指针 - 你不能这样来转型一个普通的结构体。
注意:这种转型技巧是类型不安全的。把一个对象转型为它的基类对象虽然合法但不明智。这将要求程序员自己来保障此次转型是安全的。



创建类型的实例

 

了解了这个技术后,那么究竟类型系统是如何实例化出对象的呢?第一次我们使用g_type_create_instance让系统创建一个*实例对象时,它必须要先创建一个*类对象供实例来使用。如果该类结构体继承自其它类,系统则需要先创建和初始化这些父类。系统依靠我们指定的结构体(*_get_type函数中的!GTypeInfo结构体)来完成这个工作,这个结构体描述了每个对象的实例对象大小,类对象大小,初始化函数和销毁函数。- 要用g_type_create_instance来实例化一个对象
如果它没有相关联的类对象
创建类对象并且将其加入到类的层次中
创建实例对象并且返回指向它的指针
当系统创建一个新的类对象时,它先会分配足够的内存来放置这个最终的类对象(译者:“最终的”意指这个新的类对象,相对于其继承的父类们)。然后在继承链上从最顶端的父类开始到最末端的子类对象,用父类的成员域覆写掉这个最终类对象的成员域。这就是子类如何继承自父类的。当把父类的数据复制完后,系统将会在当前状态的类对象中执行父类的“base_init“函数。这个覆写和执行“base_init”的工作将循环多次,直到这个继承链上的每个父类都被处理过后才结束。接下来系统将在这个最终的类对象上执行最终子类的“base_init”和“class_init”函数。函数“class_init”有一个参数,即上文所提到的“class_data”,该参数会是构造函数的参数。
细心的读者可能会问,为什么我们已经有了一个完整的父类对象的拷贝还需要它的base_init函数?因为当完整拷贝无法为每个类重新创建出某些数据时,我们就需要base_init函数。例如,某个类对象成员指向了另外一个对象,拷贝后我们希望每个类对象的成员都指向它自己的对象,而不是只拷贝对象的指针(内存的拷贝只是“浅拷贝”,这时我们需要一次“深拷贝”)。但事实上有经验的GObject程序员告诉我base_init函数会很少用到。
当系统创建一个新的实例对象时,它会先分配足够的内存来将这个实例对象放进去。从继承链的最顶端的父类开始调用它的“instance_init”函数,直到最终的子类。最后,系统在最终类对象上调用最终子类的“instance_init”函数。
我来总结一下上面所描述到的算法:- 实例化一个类对象
为最终对象分配内存
从父类到子类开始循环
复制对象内容以覆盖掉最终对象的内容
在最终对象上运行对象自己的base_init函数
在最终对象上运行最终对象的base_init函数
在最终对象上运行最终对象的class_init(附带上类数据)


- 实例化一个实例对象
为最终对象分配内存
从父类到子类开始循环
在最终对象上运行instance_init函数
在最终对象上运行最终对象的instance_init函数此时创建的类对象和实例对象都已经被初始化,系统将实例对象的类指针指向到类对象,这样实例对象就能找到类对象所包含的虚函数表。这就是系统实例化已注册类型的过程,其实GObject实现的构造函数和析构函数语义与上述的方法也是相同的。



创建GObject实例

 

前面我们使用g_type_create_instance来创建一个实例对象。然而事实上GObject给我们提供了一个新的API来创建gobjects,可以完成我们上述所有的工作。这个API调用三个新的方法来创建和销毁新的GObject对象:构造函数(constructor),部署函数(dispose)以及析构函数(finalize)。
因为C语言缺少真正面向对象的语言所具备的多态特性,特别是认出多个构造函数的能力,所以GObject的构造函数需要一些更复杂的实现:
我们怎样才能灵活的传递不同种类的初始化信息到对象中,使得构造对象更容易呢?也许我们会想到限制只使用拷贝构造函数,然后用初始化数据填充一个静态的”初始化对象“,再将这个”初始化对象“传递到这个拷贝构造函数中。方法虽然简单,但是不太灵活。
事实上GObject的作者们提供了一种更加通用的解决方案,同时还提供了方便的getting和setting方法来操作对象成员数据,这种机制被称作”属性“。在系统中我们的属性用字符串来命名,并对它进行边界和类型检查。属性还可以被声明为仅构造时可写,就像C++中的const变量一样。
属性使用了一种多态的类型(GValue),这种类型允许程序员在不了解它实际类型的前提下安全的复制一个值。GValue会记录下它的值所持有的GType,使用类型系统来保证它总是具有一个虚函数,该函数可以处理将其自身复制到另一个GValue或转换为另一种GType。我们将在下一章详细讨论GValues和属性。
要为一个GObject创建一个新的属性,我们要定义它的类型、名字,以及默认值,然后创建一个封装这些信息的“属性规格”对象。在GObject的类初始化函数中,我们可以通过g_object_class_install_property来将属性规格绑定到GObject的类对象上。
注意:任何子对象要添加一个新的属性必须覆盖它从GObject继承下来的set_property和get_property虚方法。将在下一节中介绍这两个方法。
使用属性我们可以向构造函数传递一组属性规格,附上我们希望的初始值,然后简单调用GObject的set_property,这样就能获得属性带给我们的神奇功效。但是事实上,构造函数是不会被我们直接调用的。
GObject构造函数另一个不是那么明显的特性是,每个构造函数需要接受一个GType作为其参数之一,并且当它向上转型为其父类时,需要将这个GType传递给它父类的构造函数。这是因为GObject的构造函数使用子类的GType来调用g_type_create_instance,这样GObject的构造函数必须要知道它的最终子类对象的GType。
注意:如果我们自己定义构造函数,我们则必须覆盖继承自父类的构造函数。自定义的构造函数必须得沿着“继承链”向上,在做任何其他的工作前,先调用完父类的构造函数。然而,因为我们使用了属性,所以事实上我们从来不用覆盖掉默认的构造函数。
我要为上面的离题而道歉,但是这是为了理解系统是如何工作的所必须要克服的困难。如上所述,我们现在能理解GObject的构造函数了-g_object_new。这个函数接受一个子类的GType类型,一系列属性名(字符串)和GValue对作为参数。
这一系列属性对被转换为键值对列表和相关的属性规格,这些属性规格将被在类初始化函数里被安装到系统中。调用类对象的构造函数时系统传入GType和构造属性。从最底端的子类构造函数到最顶端的基类构造函数,这条链会一直被触发直到GObject的构造函数被执行 - 这实际上才是第一个真正执行的初始化程序。GObject的构造函数现调用g_type_create_instance,并传下我们通过g_object_new一路带上的GType,这样我们上面所描述的细节将会发生,最终创建出实例。然后它将获得最终对象的类,并对传入所有构造属性调用set_property方法。这就是为什么我们加入一个新属性时必须要覆盖get_/set_property方法的原因。当这一串构造函数返回后,包含在其中的代码将从基类执行到子类。
当父类构造函数返回后,就轮到子类来执行它自己的初始化代码了。这样执行代码的顺序就成为:
  • 从GObject到ChildObject运行实例初始化函数
  • 从GObject到ChildObject运行构造函数
最后任何剩余的没有传递到构造函数的属性将使用set_property方法一次设置完毕。
读者也许会考虑在什么情况下需要覆盖默认构造函数,将自己的代码放到他们自己的构造函数里。因为我们所有的属性都可以使用虚方法set_property来设置,所以基本上没有覆盖GObject的默认构造函数的必要。
我仍尝试使用伪码的方式来总结一下GObject的构造函数过程:- 使用属性键值对列表创建合适的GObject对象:
在键值对列表中查找对应的属性规格
调用最终对象的构造函数并传入规格列表和类型
递归的向下调用直到GObject的构造函数
对传入的类型调用g_type_create_instance
对属性规格列表调用虚方法set_property
对剩下的属性,调用set_property注意:GObject将属性区分为两类,构造属性和“常规”属性。



销毁GObject实例

 

该做的工作完成后,我们可以看看要清理这个对象时会发生些什么。GObject实现面向对象中的析构时,将其分解成了两步:处理(dispose)和销毁(finalize)。
"处理"方法在对象知道自己将要被销毁时调用。实现该方法时,应该将指向资源的引用释放掉,这样可以避免循环引用或资源稀缺。“处理”方法应该允许被调用多次。要实现这一点,一般的做法是使用一个静态变量来保护”处理“方法。在“处理”方法调用后,对象本身应该依然能够使用,除非产生了不可恢复的错误(如段错误)。因此,“处理”方法不能释放或者改动某些对象成员。对于可恢复的错误,例如返回错误码或者空指针,则不应该受影响。
“销毁”方法会在从内存中清理掉对象之前被调用,用于释放剩余的资源引用。因此它只能被调用一次。析构过程被分成两个步骤降低了引用计数策略中循环引用发生的可能。
注意:如果我们自定义“处理”和“销毁”方法,就必须要覆盖掉继承自父类的相同方法。这两个方法从子类开始调用,沿着继承链向上直到最顶端的父类。
与构造函数不同的是,只要新的对象分配了资源,我们就需要覆盖掉继承自父类的相同方法,自己实现“处理”和“销毁”方法。
判断销毁代码放置到哪个函数不是件容易的事。一般来说,当与实现了引用计数的库(如GTK+)打交道时,我们应该在“处理”方法中解除对其它资源对象的引用,而在“销毁”方法中释放掉所有的内存或者关闭所有的文件描述字。
上面我们讨论过g_object_new,但是我们什么时候来销毁这些对象呢?其实上面也有提示过,GObject使用了引用计数的技术,它保存了一个整型的数据,该数据描述了有多少个对象或函数现在正在使用或者引用这个对象。当你在使用GObject时,如果你希望新创建的对象不在使用时被销毁掉,你就必须及早调用g_object_ref,将对象作为参数传递给它,这样就为引用计数器增加了1。如果你没有做这件事就意味着对象允许被自动销毁,这也许会导致你的程序崩溃。
同样的,当对象完成了它的任务后,你必须要调用g_object_unref。这样会使引用计数器减1,并且系统会检查它是否为0.当计数器为0时,对象将被先调用“处理”方法,最终被“销毁”掉。如果你没有解除到该对象的引用,则会导致内存泄漏,因为计数器永远不会回到0。
现在我们已经准备好了来写一些代码了!不要让上面冗长复杂的描述吓到您。如果你没有完全理解上面所提到的,别紧张 - GObject的确是很复杂的!继续读下去,你会看到许多细节,试试一些例子程序,或者去睡觉吧,明天再来接着读。
下面的程序与第一个例子很相似,事实上我去掉了更多的不合逻辑的、冗余的代码。



代码(头文件)

 

a. 我们仍然按照上面的方式继续,但是这次将把父类对象放到结构体的第一个成员位置上。事实上就是GObject。/* “实例结构体”定义所有的数据域,实例对象将是唯一的 */
typedef struct _SomeObject SomeObject;
struct _SomeObject
{
GObject parent_obj;

/* 下面是一些数据 */
};

/* “类结构体”定义所有的方法函数,类对象将是共享的 */
typedef struct _SomeObjectClass SomeObjectClass;
struct _SomeObjectClass
{
GTypeClass parent_class;

/* 下面是一些方法 */
};b. 头文件剩下的部分与第一个例子相同。



代码(源文件)

 

注意:我们需要增加一些对被覆盖的GObject方法的声明。/* 这些是GObject的构造和析构方法,它们的用法说明在gobject.h中 */
void some_object_constructor(GType this_type,
guint n_properties,
GObjectConstructParam *properties)
{
/* 如果有子类要继承我们的对象,那么this_type将不是SOME_OBJECT_TYPE,
g_type_peek_parent再是SOME_OBJECT_TYPE的话,将会造成无穷循环 */

GObjectClass *parent_class = g_type_class_peek (g_type_peek_parent (SOME_OBJECT_TYPE()));

parent_class-> constructor (self_type, n_properties, properties);

/* 很少需要再做其它工作 */
}

void some_object_dispose (GObject *self)
{
GObjectClass *parent_class = g_type_class_peek (g_type_peek_parent(SOME_OBJECT_TYPE()));
static gboolean first_run = TRUE;

if (first_run)
{
first_run = FALSE;

/* 对引用的所有GObject调用g_object_unref,但是不要破坏这个对象 */

parent_class-> dispose (self);
}
}

void some_object_finalize (GObject *self)
{
GObjectClass *parent_class = g_type_class_peek (g_type_peek_parent(SOME_OBJECT_TYPE()));

/* 释放内存和关闭文件 */

parent_class-> finalize (self);
}
注意:GObjectConstructParam是一个有两个成员的结构体,一个是一组!GParamSpec类型,用来描述参数定义,另一个是一组GValue类型,是对应参数的值。/* 这是GObject的Get和Set方法,它们的用法说明在gobject.h中 */
void some_object_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
}

void some_object_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
}

/* 这里是我们覆盖函数的地方,因为我们没有定义属性或者任何域,下面都是不需要的 */
void some_object_class_init (gpointer g_class,
gpointer class_data)
{
GObjectClass*this_class = G_OBJECT_CLASS (g_class);

this_class-> constructor = &some_object_constructor;
this_class-> dispose = &some_object_dispose;
this_class-> finalize = &some_object_finalize;

this_class-> set_property = &some_object_set_property;
this_class-> get_property = &some_object_get_property;
}要想讨论关于创建和销毁GObject,我们就必须要了解属性和其它特性。我将把操作属性的示例放到下一节来叙述。以避免过于复杂而使得你灰心丧气。在你对这些概念有些实作经验后,它们将开始显现出来存在的意义。如上面所言,我们现在只是将自己限制在创建一个基础的GObject类,在下一节我们将真正的编写一些函数。 重要的是我们获得了让下面的学习更轻松的工具。



4.属性

 

上面已经提到属性是个很奇妙的东西,也简单介绍了如何使用它。在进一步深入介绍属性之前,我们又得先离一会儿题。



GValues

 

C是一门强类型语言,也就是说变量声明的类型必须和它被使用的方式保持一致,否则编译器就会报错。这是一件好事,它使得程序编写起来更迅速,帮助我们发现可能会导致系统崩溃或者不安全的因素。但这又是件坏事,因为实际上程序员活在一个很难什么事都保持严格的世界上,而且我们也希望声明的类型能够具备多态的能力 -也就是说类型能够根据上下文来改变它们自己的特性。通过C语言的转型我们可以获得一些多态的能力,如上面所讨论过的继承。然而,当使用无类型指针作为参数传递给函数时,可能问题会比较多。幸运的是,类型系统给了我们另外一个C语言没有的工具:GType。
让我们更清楚的描述一下问题吧。我需要一种数据类型,可以实现一个可以容纳多类型元素的链表,我想为这个链表编写一些接口,可以不依赖于任何特定的类型,并且不需要我为每种数据类型声明一个多余的函数。这种接口必然能涵盖多种类型,所以我们称它为GValue(Generic Value,泛型)。该如何实现这样一个类型呢?
我们创建了封装这种类型的结构体,它具有两个成员域:所有基础类型的联合(union),和表示保存在这个union中的值的GType。这样我们就可以将值的类型隐藏在GValue中,并且通过检查对GValue的操作来保证类型是安全的。这样还减少了多余的以类型为基础的操作接口(如get_int,set_float,...),统一换成了g_value_*的形式。
细心的读者会发现每个GValue都占据了最大的基础类型的内存大小(通常是8字节),再加上GType自己的大小。是的,GValues在空间上不是最优的,包含了不小的浪费,因此不应该被大量的使用它。它最常被用在定义一些泛型的API上。
属性是如何工作的这一点稍稍超出了我们要讨论的范围,但是这对于理解属性本身还是很有帮助的。/* 让我们使用GValue来复制整型数据! */
#define g_value_new(type) g_value_init (g_new (GValue, 1), type)

GValue *a = g_value_new (G_TYPE_UCHAR);
GValue *b = g_value_new (G_TYPE_INT);
int c = 0;

g_value_set_uchar (a, ''a'');
g_value_copy (a, b);

c = g_value_get (b);
g_print ("w00t: %d\n", c);

g_free (a);
g_free (b);



设计

 

我们已经在上面接触过属性了,对它们有了初步的认识,现在我们将继续来了解一下设计它们的最初动机。要编写一个泛型的属性设置机制,我们需要一个将其参数化的方法,以及与实例结构体中的成员变量名查重的机制。从外部上看,我们希望使用C字符串来区分属性和公有API,但是内部上来说,这样做会严重的影响效率。因此我们枚举化了属性,使用索引来标识它们。
上面提过属性规格,在Glib中被称作!GParamSpec,它保存了对象的gtype,对象的属性名称,属性枚举ID,属性默认值,边界值等,类型系统用!GParamSpec来将属性的字符串名转换为枚举的属性ID,GParamSpec也是一个能把所有东西都粘在一起的大胶水。
当我们需要设置或者获取一个属性的值时,传入属性的名字,并且带上GValue用来保存我们要设置的值,调用g_object_set/get_property。g_object_set_property函数将在GParamSpec中查找我们要设置的属性名称,查找我们对象的类,并且调用对象的set_property方法。这意味着如果我们要增加一个新的属性,就必须要覆盖默认的set/get_property方法。而且基类包含的属性将被它自己的set/get_property方法所正常处理,因为!GParamSpec就是从基类传递下来的。最后,应该记住,我们必须事先通过对象的class_init方法来传入GParamSpec参数,用于安装上属性!
假设我们已经有了如上一节所描述的那样一个可用的框架,那么现在让我们来为SomeObject加入处理属性的代码吧!



代码(头文件)

 

a. 除了我们增加了两个属性外,其余同上面的一样。/* “实例结构体”定义所有的数据域,实例对象将是唯一的 */
typedef struct _SomeObject SomeObject;
struct _SomeObject
{
GObject parent_obj;

/* 新增加的属性 */
int a;
float b;

/* 下面是一些数据 */
};



代码(源文件)

 

a. 创建一个枚举类型用来内部记录属性。enum
{
OBJECT_PROPERTY_A = 1 << 1;
OBJECT_PROPERTY_B = 1 << 2;
};b. 实现新增的处理属性的函数。void some_object_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec)
{
SomeObject *self = SOME_OBJECT (object);

switch (property_id)
{
case OBJECT_PROPERTY_A:
g_value_set_int (value, self-> a);
break;

case OBJECT_PROPERTY_B:
g_value_set_float (value, self-> b);
break;

default: /* 没有属性用到这个ID!! */
}
}

void some_object_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec)
{
SomeObject *self = SOME_OBJECT (object);

switch (property_id)
{
case OBJECT_PROPERTY_A:
self-> a = g_value_get_int (value);
break;

case OBJECT_PROPERTY_B:
self-> b = g_value_get_float (value);
break;

default: /* 没有属性用到这个ID!! */
}
}
c. 覆盖继承自基类的set/get_property方法,并且传入GParamSpecs。/* 这里是我们覆盖函数的地方 */
void some_object_class_init (gpointer g_class, gpointer class_data)
{
GObjectClass *this_class = G_OBJECT_CLASS (g_class);
GParamSpec *spec;

this_class-> constructor = &some_object_constructor;
this_class-> dispose = &some_object_dispose;
this_class-> finalize = &some_object_finalize;

this_class-> set_property= &some_object_set_property;
this_class-> get_property = &some_object_get_property;

spec = g_param_spec_int
(
"property-a", /* 属性名称 */
"a", /* 属性昵称 */
"Mysterty value 1", /* 属性描述 */
5, /* 属性最大值 */
10, /* 属性最小值 */
5, /* 属性默认值 */
G_PARAM_READABLE |G_PARAM_WRITABLE /* GParamSpecFlags */
);
g_object_class_install_property(this_class,OBJECT_PROPERTY_A, spec);

spec = g_param_spec_float
(
"property-b", /* 属性名称 */
"b", /* 属性昵称 */
"Mysterty value 2" /* 属性描述 */
0.0, /* 属性最大值 */
1.0, /* 属性最小值 */
0.5, /* 属性默认值 */
G_PARAM_READABLE |G_PARAM_WRITABLE /* GParamSpecFlags */
);
g_object_class_install_property (this_class, OBJECT_PROPERTY_B, spec);
}

C++ VS Gobject

gobjec相关学习文章的list.

面向对象是一种游戏规则,它不是游戏。C++只是面向对象的一种开发语言。

 

很多人在学校里面

1. 学习了C语言,知道这是写“面向结构的”

2. 学习了C++,知道这是面向对象的;

 

如果这个时候再接触GObject, 就会觉得很怪异,为啥用C语言去实现一个面向对象的机制呢。

老是拿C++ VS GObject,老是觉得GObject浑身是刺,不好用,复杂的很!

 

如果你学过C语言之后,学校教面向对象,之后叫GObject, 你就不会觉得GObject是个异类了。

 

 

C++中用了一个struct, 里面包含了:成员变量,成员函数

GObject用了2个struct, 一个包含成员变量,另外一个包含成员函数;

 

 


http://tigersoldier.is-programmer.com/categories/4800/posts

C vs C++

C和面向对象,这不就是C++么?为什么要搞出另一套东西,而不直接使用C++呢?关于C与C++之争是一个大坑。Linux之父Linus就是力挺C而批判C++的。讨厌C++的人似乎认为C++过于复杂,内部机制陷阱过多等等。自己的经历不多,用C++也很少,达不到大牛们的境界,如果让我给个非要用C而不用C++的理由,我也给不出一个有说服力的。

为什么研究GObject

最原始的动力是,我在使用GTK+进行开发,而GObject是GTK+的基石。如果基础不牢,上层一定不会稳,因此很有必要把GObject给过一遍。知道了它的内部,才知道该如何使用它,明白它的机制与原理,做到心中有数。

但是研究GObject能带来更多。由于C里没有任何面向对象机制,因此GObject把这些机制全部实现了一遍。从中可以看到一些机制的实现原理,从而对面向对象有更多的理性了解。

第一步:封装

面向对象的最基本需求就是封装。所谓封装,按我的理解,就是将一系列相关数据,及对这些数据有关的操作,有序的组织在一个结构中。一个圆形有x坐标、y坐标、半径三个参数,我们可以用这三个变量表示一个圆:

?
1
double x, y, radius;

这没什么问题。现在多了一个圆,我们又要用三个变量:

?
1
double x1, y1, radius1;

当我们有很多个圆的时候,可能要用到数组:

?
1
double x[100], y[100], radius[100];

问题在哪?x、y和radius是相互独立的。我完全可以定义100个x,200个y,150个radius。如果不只有圆,还有矩形,那么矩形的坐标叫什么呢?xx、yy?等你写了一堆代码之后回来看,到底x和y是圆的坐标,还是xx和yy是圆的坐标?

所以有了struct。一个struct对数据进行了很自然的封装:

?
1
2
3
struct Circle {
double x, y, radius;
};

好了,现在我们有了Circle这个类型。这个类型将圆的三个参数封装到了一起,从现在开始它们就是一个整体了。我可以很自然的声明一个圆,而不是它的三个参数:

?
1
struct Circle c;

我们也不用担心x、y、z的数量不等了,更不用担心坐标和矩形坐标命名冲突——它们定义在Rectangle这个struct里呢:)。

事情还没有完。有了圆这个类型,那么对圆的操作呢?假设一个圆的操作之一为移动(move)。我们可以定义如下函数:

?
1
2
3
4
void circle_move (struct Circle *self, double x, double y) {
self->x = x;
self->y = y;
}

我们输入一个圆的指针,以及新的x、y坐标,移动操作帮助我们把指定的圆移动到新的坐标上。注意第一个参数self,是不是有点眼熟?它就是C++里的this。记得学C++时很多同学对this理解相当困难,如果看这个self就不难理解了:self就是我们要操作的那个变量,它是一个指针。C++在对象方法调用时省略了这个参数,它可以被编译器自动设置。在C里面,这个工作要我们自己做。因此移动一个圆要这么调用:

?
1
2
struct Circle cir;
circle_move (&cir, 10.0, 5.0);

注意self是个指针,因为C里没有引用,所以我们只能使用指针来达到传递一个对象,而不是传递它的复制品的效果。

这个方法……不就是普通的函数调用嘛,根本就没把操作给封装呀。好,现给一个看起来像C++中的方法:

?
1
2
3
4
5
6
7
8
struct Circle {
double x, y, radius;
void (*move) (struct Circle *self, double x, double y);
};
...
struct Circle cir;
cir.move = circle_move;
cir.move (&cir, 10.0, 5.0);

通过函数指针,可以让move调用看起来更像C++了。但是,有两个不爽的地方。其一,要显式地将circlemove函数赋值给move函数指针,如果有5个圆,那就要5行指定的代码(除非用数组+循环)。更为严重的是我们可以为不同的变量指定不同move操作。其二,调用时依然要显示地指定self,这带来的一个后果是,我们完全可以调用cir1的move,但是传入的是cir2的指针。

对于第一点,可以使用类结构+初始化函数来解决。对于第二点,C语言是没法避免显示的传入self指针(如果可以的话请告诉我)。因此这种写法只是“像”C++而已,没啥实际的好处。不过在之后我们会看到,GObject会在类结构中使用函数指针来表示对象的操作。

小结

  • 研究C下的面向对象实现,可以让我们更深入地了解面向对象的机理;
  • 要将数据封装,可以使用struct;
  • 要表示对某种对象的操作,定义一组函数,其第一个参数为要操作对象的指针。

 

struct  _GObject
{
  GTypeInstance  g_type_instance;
  
  /*< private >*/
  volatile guint ref_count;
  GData         *qdata;
};
struct  _GObjectClass
{
  GTypeClass   g_type_class;

  /*< private >*/
  GSList      *construct_properties;

  /*< public >*/
  /* seldomly overidden */
  GObject*   (*constructor)     (GType                  type,
                                 guint                  n_construct_properties,
                                 GObjectConstructParam *construct_properties);
  /* overridable methods */
  void       (*set_property)		(GObject        *object,
                                         guint           property_id,
                                         const GValue   *value,
                                         GParamSpec     *pspec);
  void       (*get_property)		(GObject        *object,
                                         guint           property_id,
                                         GValue         *value,
                                         GParamSpec     *pspec);
  void       (*dispose)			(GObject        *object);
  void       (*finalize)		(GObject        *object);
  /* seldomly overidden */
  void       (*dispatch_properties_changed) (GObject      *object,
					     guint	   n_pspecs,
					     GParamSpec  **pspecs);
  /* signals */
  void	     (*notify)			(GObject	*object,
					 GParamSpec	*pspec);

  /* called when done constructing */
  void	     (*constructed)		(GObject	*object);

  /*< private >*/
  gsize		flags;

  /* padding */
  gpointer	pdummy[6];
};

http://zh.wikipedia.org/wiki/GObject

類別實作[编辑]

每個 GObject 類別必須包含至少兩個結構:類別結構與實體結構。

類別結構
類別結構相當於 C++ 類別的 vtable。第一個元素必須是父類別的類別結構。裡面包含一組函式指標,也就是類別的虛擬方法。放在這裡的變數,就像是 C++ 類別裡的 const 或類別層級的成員。
實體結構
每個物件實體都將會是這個實體結構的副本,同樣地,第一個元素,必須是實體結構的父類別(這可以確保每個實體都有個指標可以指向類別結構,所有的基礎類別也同樣如此),在歸入父類別之後,可以在結構內放其他的變數,這就相當於 C++ 的成員變數。

C 結構沒有像 "public", "protected" 或 "private" 等的存取層級修飾,一般的方法是藉著在實體結構裡提供一個指向私有資料的指標,照慣例稱作 _priv。私有的結構可以宣告在公有的表頭檔案裡,然後把實體的定義寫在實作的檔案中,這樣作,對使用者來說,他並不知道私有資料是什麼,但對於實作者來說,卻可以很清楚的知道。如果私有結構也註冊在 GType 裡,那麼物件系統將會自動幫它配置空間。

GObject 框架最主要的不利點在於太過於冗長。像是手動定義的類型轉換巨集和難解的型別註冊咒語等的大量模板代碼都是建立新類別所必要的。GObject Builder 或 GOB2 這些工具試圖以提供樣板語法來解決這個問題。以 GOB2 寫的代碼必須事先處理過才能編譯。另外,Vala 可以將 c# 的語法轉換成 C,並編譯出獨立的二進制檔。

 

 

http://blog.csai.cn/user1/265/archives/2006/3301.html

注:此文只许被引用,非经作者同意不得擅自转载


一、概述

gtk是一套跨多种平台的图形工具包,虽然它是采用c语言来编写的,但是gtk显然具有很好的面向对象特性。为了今后自己能更好的使用gtk或扩展gtk系统,在这里俺对gtk对象系统与c++对象系统展开一个综合的比较。

二、支持面向对象的核心引擎

面向对象是一种思想!众所周知,诸如C++、java等语言,我们称它为面向对象的编程语言!那么究竟何谓“面向对象的编程语言”呢?简言之,能够从语言级别上较好的支持“面向对象”特性的,都可以称其为面向对象的编程语言。也即在编译器内部对这种语言予以了面向对象特性的直接支持,如抽象(反映一般和特殊的关系)和继承,聚合(反映局部和整体的关系)和封装等。

但是请注意,对面向对象编程方法的运用,不一定非要求我们必须采用支持“面向对象”的编程语言。因为面向对象编程是一种思想和方法,它本身与某种编程语言并无直接映射关系,它也更不会去依赖某种编程语言。或者换句话说,如果你选择了某种很好地支持了面向对象特性的编程语言,那么你也许能够更轻松地运用到一些面向对象的编程方法,去很好的解决你的业务问题。

因此,gtk虽然是采用了不支持面向对象特性的c语言所编写,但这并不影响gtk也具有了很好的面向对象特性。当然,与C++对象系统相比较,为了使gtk系统具有面向对象的特性,它就必须自己来实现那些由“c++编译器”所实现的对面向对象的支持。总结为一句话:C++对“面向对象”的支持是在“c++编译器”那里给实现的;而gtk系统中对“面向对象”的支持则必须由它自己来亲自实现,也即gtk面向对象的引擎是在gtk的运行库中,例如“类型”的创建、继承关系、“类型”的映射等!

总之,我们需要铭记一点:在gtk系统中,它在运行时刻,会维护一个全局的、大型的、能够反映所有继承关系的“类型关联表”。


三、共同的基类

gtk对象系统中所有的对象都有一个共同的基类,这一点很容易做到;而c++则没有;但java语言中有。

四、如何实现继承,扩展出子类

1、gtk系统的继承是利用struct关键字,它与c++中的class含义如出一辙!下面对重要的几点逐一说明一下:

2、c++中定义一个“类型”时,“成员变量”和“成员函数”都放在class数据结构之中,c++编译器会知道分别该怎么处理它。而gtk对象系统中,定义一个“类型”时,它的“成员变量”和“成员函数”应该显式将它们分开的,原因是“成员变量”的聚合才代表真正的“对象”,它可能是需要被实例化出很多的对象实例;而“对象类”则是“成员函数”的聚合,它表示对该类“对象”中成员变量的处理操作的统一封装,而且“对象类”只需要被实例化一次。示例如下:

//gtkcalendar.h文件中
struct _GtkCalendar
{
//第一个字段表示基类
GtkWidget widget;

//下面是其它数据字段("成员变量"的聚合)
...
}


struct _GtkCalendarClass
{
//第一个字段表示基类
GtkWidgetClass parent_class;

//下面是其它数据字段("成员函数"的聚合)
...
}


3、与c++中不同,由于gtk对象系统中必须自己维护所有继承关系的“类型关联表”,因此除了上面在.h文件中定义了类接口以外,它还必须在.c文件中来显式地实现这种关联。如下示例:

GType
gtk_calendar_get_type (void)
{
static GType calendar_type = 0;

if (!calendar_type)
{
static const GTypeInfo calendar_info =
{
sizeof (GtkCalendarClass),
NULL, /* base_init */
NULL, /* base_finalize */
//指定类型的初始化函数,每种“类型”只被实例化一次。
//在某种“类型”第一次被使用到时,它被实例化,这个函数同时也被调用
(GClassInitFunc) gtk_calendar_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GtkCalendar),
0, /* n_preallocs */
(GInstanceInitFunc) gtk_calendar_init,//注意,这里指定对象的构造函数
};

// 注意!下面这条语句非常关键,尤其是第一个参数的指定,实际上它才代表“类型”的真正继承关系。
// GTK_TYPE_WIDGET代表一个"类型id",每种类型都有唯一对应的一个id,实际上,只有通过这个id才
// 可以访问到gtk系统中"类型”数据结构;而只有访问到了"类型”数据结构,gtk核心才知道该怎么去
// 创建实例化对象(如对象的尺寸大小等信息)
calendar_type = g_type_register_static (GTK_TYPE_WIDGET, "GtkCalendar",
&calendar_info, 0);
}

return calendar_type;
}

3、鉴于习惯的原因,在下文中,我们对gtk系统中相当于c++中“对象”的数据结构称为“构件”,如上面的_GtkCalendar;而相当于c++中“对象类”的gtk数据结构称为“构件类”,如上面的_GtkCalendarClass。


五、“成员变量”的可见性

1、在c++中,“成员变量”的可见性有public、protected、private三种。其实public属性的成员变量基本上不采用,因为我们坚决要杜绝这样做。

2、那么在gtk系统中,“成员变量”的可见性应该怎样控制呢?这里建议你按照如下规则:
(1)public的gtk不支持
(2)protected的,可以直接放在“构件”的数据字段中,它表示可以允许子类访问它
(3)对于需要private属性的,我们应该在“构件”的数据字段中定义一个特殊的字段,如_GtkCalendar构件中的gpointer private_data;再在这个构件的实现文件中定义这个只能被这个构件自己所访问并操作的“私有数据结构”体,如_GtkCalendar构件中的_GtkCalendarPrivateData。
(4)我们可以核对一下现在的gtk系统中每个gtk构件是不是都遵循以上的规则。

六、“成员函数”的可见性

1、同样,在c++中,“成员函数”的可见性也是有public、protected、private三种。public表示外部可见;protected表示子类可见;private表示只有自己可见。

2、在gtk系统中,“成员函数”的可见性又该如何来控制呢?有如下规则或建议:

(1)public属性的表示gtk的外部访问接口。注意!它虽然在.h文件中做声明,但是它并不是(也不能)在“构件类”中进行声明的字段,所以与c++中public属性的“成员函数”相对比,gtk中的这类的外部访问接口函数,它不能被子类所覆盖或重载。也正因为如此,才导致gtk系统的外部访问接口函数简直是忒多忒多了,个人认为这是gtk对象系统中所不可避免的最大缺陷,因为使用者要花很多的精力来学习它和熟悉它。另外,gtk中的这类的外部访问接口函数在声明时,第1个参数都会是“构件”自身,这相当与c++系统中隐式的this指针。示例如下:
//gtkcalendar.h文件中
//gtk_calendar_select_month相当于c++中public属性的“成员函数”,而GtkCalendar *calendar则相当于c++函数中隐式的this指针
gboolean gtk_calendar_select_month (GtkCalendar *calendar,
guint month,
guint year);

(2)请问,c++中protected属性的“成员函数”在gtk系统中如何来体现呢?其实不难理解,那就是那些直接在“构件类”中所声明的数据字段,它们才是来扮演protected属性“成员函数”这个重要角色的功能。当然值得注意的是,这类函数在声明时,都是一个个指向函数的指针(gtk系统中,把它们习惯称为“信号处理函数”,Signal handlers),而不是声明函数本身。其原因就是因为这类函数需要或允许我们能够在子类覆盖或重载它,有时甚至要求某些函数具有“多态性”,而在c++中,语言自身(如virtual所声明的虚函数)就具备了多态性,但在c语言所实现的gtk系统中,我们则可以通过“函数指针”来实现这种“多态性”,在后面的有关内容中,会进一步讨论它。示例如下:
//gtkcalendar.h文件中
struct _GtkCalendarClass
{
GtkWidgetClass parent_class;

/* Signal handlers */
void (* month_changed) (GtkCalendar *calendar);//相当于c++中protected属性的“成员函数”,同样第一个函数参数也是构件自身
void (* day_selected) (GtkCalendar *calendar);
...
};

(3)private属性的成员函数,好象在gtk系统中没有相对应的(似乎也感觉这类函数没多大必要)!其实不然,那些没在.h文件中所声明的,而仅在.c文件中所声明并使用的static函数,我们便可以把它们理解为c++中private属性的“成员函数”,个人认为它们扮演的角色差不多。

七、“成员函数”怎样实现覆盖和多态

1、这里所讨论的“成员函数”都是指在“构件类”中所声明的那些函数指针(从作用和角色上来考量,它相当于c++中protected属性的“成员函数”)

2、gtk系统中的这类函数,我们可以认为它都是多态的虚函数(相当于c++中用virtual关键字所声明的虚函数)

3、gtk系统中,我们如何实现这类函数的覆盖呢?(c++中对成员函数如何实现覆盖,在这里就不浪费笔墨了)

(1)首先在.c文件中声明并实现一个相应的static类型的信号回调函数,如gtkcalendar.c文件中所定义的gtk_calendar_realize函数

(2)接着在我们就可以在“构件类”的初始化函数(如GtkCalendarClass“构件类”中的gtk_calendar_class_init函数,这个在前面提到过,它在gtk_calendar_get_type函数中被指定)内做文章了。也即如果我们想覆盖某个函数,只需简单的给某个“构件类”中的相应“函数指针”进行赋值即可。在gtk系统中,我们把这样的操作通常称为对某类事件信号进行了响应处理,其结果就是对父类的事件响应函数进行了覆盖。

(3)从上面可以看出,对一个所谓的“成员函数”实现覆盖是很容易做到的,但问题是?子类在覆盖父类某个函数之后,子类有时又想调用父类的一些函数!对于这样的要求,在c++中,我们可以用域作用符(“::”)来实现函数的静态绑定;那么请问gtk系统中,这又如何实现呢?其实不难,有如下的步骤:

a. 首先在.c文件中声明一个static类型的父类指针,如GtkCalendar“构件”有如下声明:
//gtkcalendar.c文件中
static GtkWidgetClass *parent_class = NULL;

b. 接着在“构件类”的初始化函数中(gtk_calendar_class_init函数),对上述parent_class进行赋值,如下:
//gtkcalendar.c文件中
static void gtk_calendar_class_init (GtkCalendarClass *class)
{
...
parent_class = g_type_class_peek_parent (class); //获得了父类的“构件类”
...
}

c. 最后,就可以在你自己的“成员函数”中,任意使用父类作用域内的“成员函数”了,示例如下:
//gtkcalendar.c文件中
static void gtk_calendar_finalize (GObject *object)
{
GtkCalendarPrivateData *private_data;
private_data = GTK_CALENDAR_PRIVATE_DATA (object);

g_free (private_data);

//释放自己构件的资源之后,接着调用父类的finalize函数,以便父类构件能释放它曾经所申请并获得的资源
(* G_OBJECT_CLASS (parent_class)->finalize) (object);
}


八、构造函数和析构函数

1、c++面向对象编程一个特出的优点就是每个对象都有相应的构造函数和析构函数。这为我们有效管理“资源”带来了极大的便利,我们通常可以在构造函数中申请资源,而在析构函数中释放资源。

2、在gtk系统中,当然也有构造函数,如_GtkCalendar“构件”的构造函数便是gtk_calendar_init函数,它是在gtk_calendar_get_type函数内定义的GTypeInfo数据结构中被指定。

3、在gtk系统中,析构函数同样也是存在的,但是它不是在GTypeInfo数据结构中被指定的,想想这是为什么?个人分析,其原因有二:首先是没有必要必须在GTypeInfo数据结构中来指定它;其二,就是因为析构函数一般都应该是虚函数,这样系统会更健壮些,也很严谨,且简单。所以gtk系统中,析构函数被声明为“构件类”中的finalize事件信号,请参阅gobject.h文件中的_GObjectClass数据结构的定义


九、对象类型的转换

1、在c++中,对象类型的转换有2种。一种是子类向父类的转换,这是隐式的,也即可以自动完成;还有一类就是父类向子类的转换,这不是隐式的,而必须是显式的,也即它需要RTTI信息,当然你也可以不借助RTTI,而野蛮地进行类型间的强制转换,但这绝对是C++中不提倡的。

2、在gtk对象系统中,“构件”之间类型的转换当然也会有子类向父类的转换,以及父类向子类的转换等2种,但是与c++对象系统不同的是,gtk构件之间类型的转换都必须是显式的,无论是子类向父类的转换,还是父类向子类的转换。这是因为gtk系统中对面向对象的支持都是靠自身来实现的,而没有编译器语言级别上的面向对象的支持。所以它的这种转换都必须借助于gtk运行库中RTTI的支持。

3、每个gtk构件的.h文件中一开始的所声明的几个宏,它们都是用来支持RTTI类型转换的,示例如下:
#define GTK_TYPE_CALENDAR (gtk_calendar_get_type ())
//用的最多的就是下面的这个宏了,它实现构件的类型转换,返回一个指针
#define GTK_CALENDAR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CALENDAR, GtkCalendar))
#define GTK_CALENDAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CALENDAR, GtkCalendarClass))
#define GTK_IS_CALENDAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CALENDAR))
#define GTK_IS_CALENDAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CALENDAR))
#define GTK_CALENDAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CALENDAR, GtkCalendarClass))

十、最后简单讨论一下对gtk构件的使用:构件的创建和构件的销毁

1、在c++中,实例化一个对象时,可以用new关键字来从堆上动态地创建出,也可以在栈上创建一个临时的对象实例(局部变量);而在gtk系统中,所有的构件都会是在堆上被创建出的,并且对于每一个构件的创建,它都会声明有一个专门的外部接口函数,如gtk_calendar_new()则用于创建一个_GtkCalendar“构件”

2、在c++中,对象实例如果在栈上,那么被自动销毁;如果在堆上,那么则必须通过delete关键字来显式地销毁某一个对象实例。在对象实例被销毁时,编译器会隐式地插入一个对相应析构函数的调用,来释放该对象所拥有的系统资源。

3、而在gtk系统中,用户一般无需考虑构件的销毁,以及构件资源的释放等,这些琐碎工作会由gtk系统内部来自动地、智能地完成它。它的原理(或者说处理流程)是这个样子的:外部用户调用构件的某个外部接口,如gtk_widget_destroy(...)函数,这会导致构件触发destroy信号事件,这个信号的缺省处理函数会引发gtk系统内部来销毁这个构件,并触发finalize信号事件,之后gtk系统会释放构件在堆上的内存资源;当然gtk_widget_destroy函数也会触发它所有的子构件的销毁,所以说gtk构件的销毁有一定的“自治”能力。最后需要强调的是,gtk1.2版本和gtk2.0版本对构件销毁的原理和流程可能会有比较大的差别,但它们的设计思想是基本保持一致的,上述的流程是针对gtk1.2版本而言的,而gtk2.0以上版本的对构件销毁的流程俺没有深入去研究过它,估计大体差不多,只不过gtk2.0引入了“引用计数”的管理机制,所以对构件销毁的触发过程可能略有不同。


十一、个人总结

C语言是面向过程的编程语言,但是gtk的设计者们却能够用C语言写出如此精妙的gtk对象系统,令俺甚是折服!敬仰之情更是油然而生!深刻体会到什么才是真正的软件系统设计师!同时也告诫自己:语言不是软件的灵魂,它仅仅只是一个工具罢了!俺坚信:一个优秀的程序员用C写出来的东西,将可能会比一个蹩脚的程序员用C++写出来的东西好n多倍。

当然,由于gtk所承载的是一个图形系统,所以gtk它终究会很复杂;但一个如此复杂的系统,却用一个如此简单的C语言来实现它,所以gtk系统必然会烙印上许多不可避免的局限性。例如它的接口实在是太多了,难以学习和使用它;没有异常事件处理系统,所以健壮性很值得担忧;gtk的扩展比较难,且需要自己来实现的东西也较多,代码量大,这无疑都增加了开发新构件的成本。所以俺个人觉得,gtk终究会被淘汰并退出历史的舞台,而能够永恒的、并值得我们永远牢记在心的是,它这其中的许多设计思想和设计理念!

gobject->qdata的使用(1: property notify and getter/setter)。

gobjec相关学习文章的list.

gobject->qdata的作用很大。

可以在&gobject->data上面绑定任何数据

ID quark name 说明  
1 quark_closure_array    
2 quark_weak_refs    
3 quark_toggle_refs    
4 property_notify_context.quark_notify_queue 实现gobject property change的Notify功能  
5 用户自定义的各种其他quark data    

 

4 quark: property_notify_context.quark_notify_queue

与属性相关的几个定义:

static void
g_object_do_class_init (GObjectClass *class)
{

  pspec_pool = g_param_spec_pool_new (TRUE);
  property_notify_context.quark_notify_queue = g_quark_from_static_string ("GObject-notify-queue");
  property_notify_context.dispatcher = g_object_notify_dispatcher;

  class->set_property = g_object_do_set_property;
  class->get_property = g_object_do_get_property;

  class->dispatch_properties_changed = g_object_dispatch_properties_changed;
  class->notify = NULL;


  gobject_signals[NOTIFY] =
    g_signal_new (g_intern_static_string ("notify"),
		  G_TYPE_FROM_CLASS (class),
		  G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE | G_SIGNAL_DETAILED | G_SIGNAL_NO_HOOKS | G_SIGNAL_ACTION,
		  G_STRUCT_OFFSET (GObjectClass, notify),
		  NULL, NULL,
		  g_cclosure_marshal_VOID__PARAM,
		  G_TYPE_NONE,
		  1, G_TYPE_PARAM);


  g_type_add_interface_check (NULL, object_interface_check_properties);
}

  //这两个基本上没有东西,需要被子类override:

  class->set_property = g_object_do_set_property;
  class->get_property = g_object_do_get_property;

 

我们从GObject 内部property机制/ 用户(使用GObject Property) 的2个角度看:

用户(使用GObject Property)

1. install properties

g_object_class_install_property //用的多

g_object_class_install_properties

 

2. 提供override GObjectClass的set/get property 类成员接口

如:

  gobject_class->set_property = gst_base_audio_sink_set_property;
  gobject_class->get_property = gst_base_audio_sink_get_property;

3. 调用GObject提供的系列get/set, 修改/获取property, 并且发信号“Notify"

 

? user 关心这个"notify"信号吗?

  仅仅是get/set property的value?

 

  如果user: g_signal_connect (obj, "notify", G_CALLBACK (on_notify), &data);

  下面的APIs会激发notifiy queue去发射signal " notifiy":

   g_object_set

   g_object_notify_by_pspec

   g_object_notify

  然后去执行用户的callback

 

GObject 内部property机制

1. 提供一个全局的pspec pool, 保存用户install的properties

2. 一个quark:quark_notify_queue, 用来标识Notify queue;

   1)这个notify queue是保存pspec链表

nqueue->pspecs = g_slist_prepend (nqueue->pspecs, pspec);

 

   2)notify queue作为qdata绑定给gobject上面

g_datalist_id_set_data_full (&object->qdata, context->quark_notify_queue,
				   nqueue, g_object_notify_queue_free);

 

3. 一个dispatcher, 作用就是发射signal: "notify"

4. 与这个"notify"信号相关

   1)定义一个信号GObject::notify

         并绑定default handler:

          G_STRUCT_OFFSET (GObjectClass, notify),

          class->notify = NULL;

   2)g_object_notify_queue_thaw

context->dispatcher (object, n_pspecs, pspecs);
property_notify_context.dispatcher = g_object_notify_dispatcher;
static void
g_object_notify_dispatcher (GObject     *object,
			    guint        n_pspecs,
			    GParamSpec **pspecs)
{
  G_OBJECT_GET_CLASS (object)->dispatch_properties_changed (object, n_pspecs, pspecs);
}

 

static void
g_object_dispatch_properties_changed (GObject     *object,
				      guint        n_pspecs,
				      GParamSpec **pspecs)
{
  guint i;

  for (i = 0; i < n_pspecs; i++)
    g_signal_emit (object, gobject_signals[NOTIFY], g_quark_from_string (pspecs[i]->name), pspecs[i]);
}

如果用户user, 不用g_signal_connect(), 这样user level的c handler也是NULL

new signal时,default handler = NULL

难道没有人care 这个"notify" signal吗?那还要这个spec notifcation机制干什么?

 

5. 提供给上层user使用的几个get/set property的API:

void	    g_object_set                      (gpointer	       object,
					       const gchar    *first_property_name,
					       ...) G_GNUC_NULL_TERMINATED;
void        g_object_get                      (gpointer        object,
					       const gchar    *first_property_name,
					       ...) G_GNUC_NULL_TERMINATED;
void        g_object_set_valist               (GObject        *object,
					       const gchar    *first_property_name,
					       va_list         var_args);
void        g_object_get_valist               (GObject        *object,
					       const gchar    *first_property_name,
					       va_list         var_args);
void        g_object_set_property             (GObject        *object,
					       const gchar    *property_name,
					       const GValue   *value);
void        g_object_get_property             (GObject        *object,
					       const gchar    *property_name,
					       GValue         *value);

 上面的6个APIs, 以及g_object_new(), g_object_newv, g_object_new_vlist

都会触发g_object_notify_queue_thaw(),从而对所有的属性都发"notify" 信号?

 

gobject property的使用,参考一下:

glib/gobject/tests/properties.c:

#include <stdlib.h>
#include <gstdio.h>
#include <glib-object.h>

typedef struct _TestObject {
  GObject parent_instance;
  gint foo;
  gboolean bar;
  gchar *baz;
} TestObject;

typedef struct _TestObjectClass {
  GObjectClass parent_class;
} TestObjectClass;

enum { PROP_0, PROP_FOO, PROP_BAR, PROP_BAZ, N_PROPERTIES };

static GParamSpec *properties[N_PROPERTIES] = { NULL, };

G_DEFINE_TYPE (TestObject, test_object, G_TYPE_OBJECT);

static void
test_object_set_foo (TestObject *obj,
                     gint        foo)
{
  if (obj->foo != foo)
    {
      obj->foo = foo;

      g_assert (properties[PROP_FOO] != NULL);
      g_object_notify_by_pspec (G_OBJECT (obj), properties[PROP_FOO]);
    }
}

static void
test_object_set_bar (TestObject *obj,
                     gboolean    bar)
{
  bar = !!bar;

  if (obj->bar != bar)
    {
      obj->bar = bar;

      g_assert (properties[PROP_BAR] != NULL);
      g_object_notify_by_pspec (G_OBJECT (obj), properties[PROP_BAR]);
    }
}

static void
test_object_set_baz (TestObject  *obj,
                     const gchar *baz)
{
  if (g_strcmp0 (obj->baz, baz) != 0)
    {
      g_free (obj->baz);
      obj->baz = g_strdup (baz);

      g_assert (properties[PROP_BAZ] != NULL);
      g_object_notify_by_pspec (G_OBJECT (obj), properties[PROP_BAZ]);
    }
}

static void
test_object_finalize (GObject *gobject)
{
  g_free (((TestObject *) gobject)->baz);

  G_OBJECT_CLASS (test_object_parent_class)->finalize (gobject);
}

static void
test_object_set_property (GObject *gobject,
                          guint prop_id,
                          const GValue *value,
                          GParamSpec *pspec)
{
  TestObject *tobj = (TestObject *) gobject;

  g_assert_cmpint (prop_id, !=, 0);
  g_assert_cmpint (prop_id, !=, N_PROPERTIES);
  g_assert (pspec == properties[prop_id]);

  switch (prop_id)
    {
    case PROP_FOO:
      test_object_set_foo (tobj, g_value_get_int (value));
      break;

    case PROP_BAR:
      test_object_set_bar (tobj, g_value_get_boolean (value));
      break;

    case PROP_BAZ:
      test_object_set_baz (tobj, g_value_get_string (value));
      break;

    default:
      g_assert_not_reached ();
    }
}

static void
test_object_get_property (GObject *gobject,
                          guint prop_id,
                          GValue *value,
                          GParamSpec *pspec)
{
  TestObject *tobj = (TestObject *) gobject;

  g_assert_cmpint (prop_id, !=, 0);
  g_assert_cmpint (prop_id, !=, N_PROPERTIES);
  g_assert (pspec == properties[prop_id]);

  switch (prop_id)
    {
    case PROP_FOO:
      g_value_set_int (value, tobj->foo);
      break;

    case PROP_BAR:
      g_value_set_boolean (value, tobj->bar);
      break;

    case PROP_BAZ:
      g_value_set_string (value, tobj->baz);
      break;

    default:
      g_assert_not_reached ();
    }
}

static void
test_object_class_init (TestObjectClass *klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "Foo",
                                           -1, G_MAXINT,
                                           0,
                                           G_PARAM_READWRITE);
  properties[PROP_BAR] = g_param_spec_boolean ("bar", "Bar", "Bar",
                                               FALSE,
                                               G_PARAM_READWRITE);
  properties[PROP_BAZ] = g_param_spec_string ("baz", "Baz", "Baz",
                                              NULL,
                                              G_PARAM_READWRITE);

  gobject_class->set_property = test_object_set_property;
  gobject_class->get_property = test_object_get_property;
  gobject_class->finalize = test_object_finalize;

  g_object_class_install_properties (gobject_class, N_PROPERTIES, properties);
}

static void
test_object_init (TestObject *self)
{
  self->foo = 42;
  self->bar = TRUE;
  self->baz = g_strdup ("Hello");
}

static void
properties_install (void)
{
  TestObject *obj = g_object_new (test_object_get_type (), NULL);
  GParamSpec *pspec;

  g_assert (properties[PROP_FOO] != NULL);

  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (obj), "foo");
  g_assert (properties[PROP_FOO] == pspec);

  g_object_unref (obj);
}

typedef struct {
  const gchar *name;
  GParamSpec *pspec;
} TestNotifyClosure;

static void
on_notify (GObject           *gobject,
           GParamSpec        *pspec,
           TestNotifyClosure *clos)
{
  g_assert (clos->pspec == pspec);
  g_assert_cmpstr (clos->name, ==, pspec->name);
}

static void
properties_notify (void)
{
  TestObject *obj = g_object_new (test_object_get_type (), NULL);
  TestNotifyClosure clos;

  g_assert (properties[PROP_FOO] != NULL);

  clos.name = "foo";
  clos.pspec = properties[PROP_FOO];

  g_signal_connect (obj, "notify", G_CALLBACK (on_notify), &clos);
  g_object_set (obj, "foo", 47, NULL);

  g_object_unref (obj);
}

static void
properties_construct (void)
{
  TestObject *obj;
  gint val;

  g_test_bug ("630357");

  /* more than 16 args triggers a realloc in g_object_new_valist() */
  obj = g_object_new (test_object_get_type (),
                      "foo", 1,
                      "foo", 2,
                      "foo", 3,
                      "foo", 4,
                      "foo", 5,
                      "foo", 6,
                      "foo", 7,
                      "foo", 8,
                      "foo", 9,
                      "foo", 10,
                      "foo", 11,
                      "foo", 12,
                      "foo", 13,
                      "foo", 14,
                      "foo", 15,
                      "foo", 16,
                      "foo", 17,
                      "foo", 18,
                      NULL);

  g_object_get (obj, "foo", &val, NULL);
  g_assert (val == 18);

  g_object_unref (obj);
}

int
main (int argc, char *argv[])
{
  g_type_init ();
  g_test_init (&argc, &argv, NULL);

  g_test_bug_base ("http://bugzilla.gnome.org/");

  g_test_add_func ("/properties/install", properties_install);
  g_test_add_func ("/properties/notify", properties_notify);
  g_test_add_func ("/properties/construct", properties_construct);

  return g_test_run ();
}

 

g_object_new()的理解。

gobjec相关学习文章的list.

 

前面大致弄明白了:

Parameter, paramSpec, closure, marsharl, gsignal, quark data

以及base_class_init()/class_init()/instance_init()的过程。

 

下面开始看gobject的具体使用,涉及到property/signal等等。

 

先看g_object_new(): 

 这个函数的过程要理解透:

1. 调用g_type_class_ref()

    (1). 先递归找到最top层的,然后开始层层处理

    (2). type_class_init_Wm()

         <1>. 从Top --> Bottom 调用base_class_init()

         <2>. 调用class_init()

               class_init()里面干了不少事情,参考后面的。

2. 调用class->constructor()

    这个API, 很少被子类override(重写),就直接用

    g_object_constructor():

    (1). g_type_create_instance()

          <1>. 先调用Top-->父类的instance_init()

          <2>. 调用自己的instance_init()

    (2). 给object设置Property

           因为前面g_object_new时,可能传入了一些参数,会被赋值给class->contruct_properties

           同时在class_init()里面,g_object_install_property()也安装了一些Property

           给object设置Property的过程:

          <1>. 取得notify queue (object的quark data)

          <2>. 调用object_set_property()

                   1*: class->set_property(), 这个子类一般会override GObjectClass的set_property

                   2*: g_object_notify_queue_add(), 把property插入到单链表中

         <3>. g_object_notify_queue_thaw()

                  notify_queue->context->dispatcher() = g_object_notify_dispatcher()

                  --> class->dispatch_properties_changed() = g_object_dispatch_properties_changed()

                  对所有的pspec发射NOTIFY信号

                         

 Class_init()

再重新整理一遍:

1. override GObjectClass(最上层类)的一些API,

   主要是:

    (1). gobject_class->set_property()

    (2). gobject_class->get_property()

    (3). gobject_class->dispose()

    (4). gobject_class->finalize()

 

2. 给GObjectClass install properites

    (1). 把属性插入到全局的Hash Table: pspec_pool中

    (2). 插入到链表中:gobject_class->construct_properites (以备后用)

 

3. 给自己New一些Signal

    (1). 放入GSignal的全局数组中:g_signal_nodes[]

    (2). 放入自己定义的一个“小”的全局数组,方便自己使用

 

4. 配合3,指定自己class的私有成员APIs

 

5. override “父类”的一些APIs

    比如,GstBin中override GstElement的一些APIs

                GstPipeline中 overrde GstElement的一些APIs

   

  

 

GObject中的Override(父类和子类的方法重写).

gobjec相关学习文章的list.

 

方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现,重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数,我们说该方法被重写 (Overriding)。子类的对象使用这个方法时,将调用子类中的定义,对它而言,父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法,它们或有不同的参数个数或有不同的参数类型,则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

 

Overload是重载,它用与现有成员相同的名称来声明属性或方法,但参数列表与原始成员不同。
Override 主要用于父类和子类之间的方法重写,即指定属性或方法可以在派生类中重写,其参数列表要求相同。

 

GobjectClass定义了一些Method:

static void
g_object_do_class_init (GObjectClass *class)
{
  /* read the comment about typedef struct CArray; on why not to change this quark */
  quark_closure_array = g_quark_from_static_string ("GObject-closure-array");

  quark_weak_refs = g_quark_from_static_string ("GObject-weak-references");
  quark_toggle_refs = g_quark_from_static_string ("GObject-toggle-references");
  pspec_pool = g_param_spec_pool_new (TRUE);
  property_notify_context.quark_notify_queue = g_quark_from_static_string ("GObject-notify-queue");
  property_notify_context.dispatcher = g_object_notify_dispatcher;

  class->constructor = g_object_constructor;
  class->constructed = g_object_constructed;
  class->set_property = g_object_do_set_property;
  class->get_property = g_object_do_get_property;
  class->dispose = g_object_real_dispose;
  class->finalize = g_object_finalize;
  class->dispatch_properties_changed = g_object_dispatch_properties_changed;
  class->notify = NULL;

 

子类可以重写(Override)父类的一些API:

比如:

GObject

    |_____GstObject

static void
gst_object_class_init (GstObjectClass * klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  //.....

  //.....

  gobject_class->set_property = gst_object_set_property;
  gobject_class->get_property = gst_object_get_property;


  //....
  /* see the comments at gst_object_dispatch_properties_changed */
  gobject_class->dispatch_properties_changed
      = GST_DEBUG_FUNCPTR (gst_object_dispatch_properties_changed);

  gobject_class->dispose = gst_object_dispose;
  gobject_class->finalize = gst_object_finalize;

这一句比较重要:GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 

然后override了5个Method:

  gobject_class->set_property = gst_object_set_property;
  gobject_class->get_property = gst_object_get_property;
  gobject_class->dispatch_properties_changed = GST_DEBUG_FUNCPTR (gst_object_dispatch_properties_changed);
  gobject_class->dispose = gst_object_dispose;
  gobject_class->finalize = gst_object_finalize;

 

再如:

GObject

     |_____GstObject

                   |______GstElement

static void
gst_element_class_init (GstElementClass * klass)
{
  GObjectClass *gobject_class = (GObjectClass *) klass;

  //.....
  //.....
  parent_class = g_type_class_peek_parent (klass);
  
  //.....
  //.....  

  gobject_class->dispose = gst_element_dispose;
  gobject_class->finalize = gst_element_finalize;


}

 

GObject

     |_____GstObject

                   |______GstElement

                                     |_____GstBin

static void
gst_bin_class_init (GstBinClass * klass)
{
  GObjectClass *gobject_class = (GObjectClass *) klass;



  gobject_class->set_property = gst_bin_set_property;
  gobject_class->get_property = gst_bin_get_property;

  gobject_class->dispose = gst_bin_dispose;

}

 

GObject

   |_____GstObject

                  |______GstElement

                                    |_____GstBin

                                                  |______GstPipeline

static void
gst_pipeline_class_init (GstPipelineClass * klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
  GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
  GstBinClass *gstbin_class = GST_BIN_CLASS (klass);

  g_type_class_add_private (klass, sizeof (GstPipelinePrivate));

  gobject_class->set_property = gst_pipeline_set_property;
  gobject_class->get_property = gst_pipeline_get_property;

  /**
   * GstPipeline:delay
   *
   * The expected delay needed for elements to spin up to the
   * PLAYING state expressed in nanoseconds.
   * see gst_pipeline_set_delay() for more information on this option.
   *
   * Since: 0.10.5
   **/
  g_object_class_install_property (gobject_class, PROP_DELAY,
      g_param_spec_uint64 ("delay", "Delay",
          "Expected delay needed for elements "
          "to spin up to PLAYING in nanoseconds", 0, G_MAXUINT64, DEFAULT_DELAY,
          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**
   * GstPipeline:auto-flush-bus:
   *
   * Whether or not to automatically flush all messages on the
   * pipeline's bus when going from READY to NULL state. Please see
   * gst_pipeline_set_auto_flush_bus() for more information on this option.
   *
   * Since: 0.10.4
   **/
  g_object_class_install_property (gobject_class, PROP_AUTO_FLUSH_BUS,
      g_param_spec_boolean ("auto-flush-bus", "Auto Flush Bus",
          "Whether to automatically flush the pipeline's bus when going "
          "from READY into NULL state", DEFAULT_AUTO_FLUSH_BUS,
          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  gobject_class->dispose = gst_pipeline_dispose;

 

 

per-object ——逐对象

g_object_new(G_TYPE_OBJECT) instance的建立。

gobjec相关学习文章的list.

 

g_type_init()

g_object_new(G_TYPE_OBJECT)

Entering type_data_make_W
GInterface:
Leaving  type_data_make_W

Entering type_data_make_W
GTypePlugin:
Leaving  type_data_make_W

Entering type_data_make_W
gchar:
Leaving  type_data_make_W

Entering type_data_make_W
guchar:
Leaving  type_data_make_W

Entering type_data_make_W
gboolean:
Leaving  type_data_make_W

Entering type_data_make_W
gint:
Leaving  type_data_make_W

Entering type_data_make_W
guint:
Leaving  type_data_make_W

Entering type_data_make_W
glong:
Leaving  type_data_make_W

Entering type_data_make_W
gulong:
Leaving  type_data_make_W

Entering type_data_make_W
gint64:
Leaving  type_data_make_W

Entering type_data_make_W
guint64:
Leaving  type_data_make_W

Entering type_data_make_W
gfloat:
Leaving  type_data_make_W

Entering type_data_make_W
gdouble:
Leaving  type_data_make_W

Entering type_data_make_W
gchararray:
Leaving  type_data_make_W

Entering type_data_make_W
gpointer:
Leaving  type_data_make_W

Entering type_data_make_W
GVariant:
Leaving  type_data_make_W

Entering type_data_make_W
GEnum:
GEnum->is_classed = 1
Leaving  type_data_make_W

Entering type_data_make_W
GFlags:
GFlags->is_classed = 1
Leaving  type_data_make_W

Entering type_data_make_W
GBoxed:
Leaving  type_data_make_W

Entering type_data_make_W
GParam:
GParam->is_instantiatable = 1
Leaving  type_data_make_W

Entering type_data_make_W
GObject:
GObject->is_instantiatable = 1
Leaving  type_data_make_W

Entering type_data_make_W
GParamChar:
GParamChar->is_instantiatable = 1
Leaving  type_data_make_W

Entering type_data_make_W
GParamUChar:
GParamUChar->is_instantiatable = 1
Leaving  type_data_make_W

Entering type_data_make_W
GParamBoolean:
GParamBoolean->is_instantiatable = 1
Leaving  type_data_make_W

Entering type_data_make_W
GParamInt:
GParamInt->is_instantiatable = 1
Leaving  type_data_make_W

Entering type_data_make_W
GParamUInt:
GParamUInt->is_instantiatable = 1
Leaving  type_data_make_W

Entering type_data_make_W
GParamLong:
GParamLong->is_instantiatable = 1
Leaving  type_data_make_W

Entering type_data_make_W
GParamULong:
GParamULong->is_instantiatable = 1
Leaving  type_data_make_W

Entering type_data_make_W
GParamInt64:
GParamInt64->is_instantiatable = 1
Leaving  type_data_make_W

Entering type_data_make_W
GParamUInt64:
GParamUInt64->is_instantiatable = 1
Leaving  type_data_make_W

Entering type_data_make_W
GParamUnichar:
GParamUnichar->is_instantiatable = 1
Leaving  type_data_make_W

Entering type_data_make_W
GParamEnum:
GParamEnum->is_instantiatable = 1
Leaving  type_data_make_W

Entering type_data_make_W
GParamFlags:
GParamFlags->is_instantiatable = 1
Leaving  type_data_make_W

Entering type_data_make_W
GParamFloat:
GParamFloat->is_instantiatable = 1
Leaving  type_data_make_W

Entering type_data_make_W
GParamDouble:
GParamDouble->is_instantiatable = 1
Leaving  type_data_make_W

Entering type_data_make_W
GParamString:
GParamString->is_instantiatable = 1
Leaving  type_data_make_W

Entering type_data_make_W
GParamParam:
GParamParam->is_instantiatable = 1
Leaving  type_data_make_W

Entering type_data_make_W
GParamBoxed:
GParamBoxed->is_instantiatable = 1
Leaving  type_data_make_W

Entering type_data_make_W
GParamPointer:
GParamPointer->is_instantiatable = 1
Leaving  type_data_make_W

Entering type_data_make_W
GValueArray:
Leaving  type_data_make_W

Entering type_data_make_W
GParamValueArray:
GParamValueArray->is_instantiatable = 1
Leaving  type_data_make_W

Entering type_data_make_W
GParamObject:
GParamObject->is_instantiatable = 1
Leaving  type_data_make_W

Entering type_data_make_W
GParamOverride:
GParamOverride->is_instantiatable = 1
Leaving  type_data_make_W

Entering type_data_make_W
GType:
Leaving  type_data_make_W

Entering type_data_make_W
GParamGType:
GParamGType->is_instantiatable = 1
Leaving  type_data_make_W

Entering type_data_make_W
GParamVariant:
GParamVariant->is_instantiatable = 1
Leaving  type_data_make_W



========================================================

Entering g_type_class_ref
Type:GObject
 
+Entering type_class_init_Wm
Call GObject.class_init_base()
Call GObject.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref

Entering g_type_class_ref
Type:GObject
Leaving  g_type_class_ref

Call GObject.instance_init()

g_new_object(GST_TYPE_PIPELINE) instance建立过程。

gobjec相关学习文章的list.

gst_init()

g_new_object(GST_TYPE_PIPELINE);

 

Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
GEnum->is_classed = 1
Leaving  type_data_make_W
Entering type_data_make_W
GFlags->is_classed = 1
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
GParam->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
GObject->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
GParamChar->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
GParamUChar->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
GParamBoolean->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
GParamInt->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
GParamUInt->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
GParamLong->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
GParamULong->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
GParamInt64->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
GParamUInt64->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
GParamUnichar->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
GParamEnum->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
GParamFlags->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
GParamFloat->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
GParamDouble->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
GParamString->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
GParamParam->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
GParamBoxed->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
GParamPointer->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
GParamValueArray->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
GParamObject->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
GParamOverride->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
GParamGType->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
GParamVariant->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
GstFormat->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstFormat
 
+Entering g_type_class_ref
Type:GEnum
++Entering type_class_init_Wm
--Leaving  type_class_init_Wm
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstFormat.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstMiniObject->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
GstQuery->is_instantiatable = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstQuery
 
+Entering g_type_class_ref
Type:GstMiniObject
++Entering type_class_init_Wm
Call GstMiniObject.class_init()
--Leaving  type_class_init_Wm
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstQuery.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstObject->is_instantiatable = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstObject
 
+Entering g_type_class_ref
Type:GObject
++Entering type_class_init_Wm
Call GObject.class_init_base()
Call GObject.class_init()
--Leaving  type_class_init_Wm
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstObject.class_init()
++Entering g_type_class_ref
Type:GParamString
+++Entering g_type_class_ref
Type:GParam
++++Entering type_class_init_Wm
Call GParam.class_init_base()
Call GParam.class_init()
----Leaving  type_class_init_Wm
---Leaving  g_type_class_ref
+++Entering type_class_init_Wm
Call GParam.class_init_base()
Call GParamString.class_init()
---Leaving  type_class_init_Wm
--Leaving  g_type_class_ref
Call GParam.instance_init()
Call GParamString.instance_init()
++Entering type_data_make_W
GstSignalObject->is_instantiatable = 1
--Leaving  type_data_make_W
++Entering g_type_class_ref
Type:GstSignalObject
+++Entering g_type_class_ref
Type:GObject
---Leaving  g_type_class_ref
+++Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstSignalObject.class_init()
---Leaving  type_class_init_Wm
--Leaving  g_type_class_ref
++Entering g_type_class_ref
Type:GstSignalObject
--Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstSignalObject.instance_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstPad->is_instantiatable = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstPad
 
+Entering g_type_class_ref
Type:GstObject
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstPad.class_init()
++Entering type_data_make_W
--Leaving  type_data_make_W
++Entering g_type_class_ref
Type:GParamBoxed
+++Entering g_type_class_ref
Type:GParam
---Leaving  g_type_class_ref
+++Entering type_class_init_Wm
Call GParam.class_init_base()
Call GParamBoxed.class_init()
---Leaving  type_class_init_Wm
--Leaving  g_type_class_ref
Call GParam.instance_init()
Call GParamBoxed.instance_init()
++Entering type_data_make_W
GstPadDirection->is_classed = 1
--Leaving  type_data_make_W
++Entering g_type_class_ref
Type:GstPadDirection
+++Entering g_type_class_ref
Type:GEnum
---Leaving  g_type_class_ref
+++Entering type_class_init_Wm
Call GstPadDirection.class_init()
---Leaving  type_class_init_Wm
--Leaving  g_type_class_ref
++Entering g_type_class_ref
Type:GParamEnum
+++Entering g_type_class_ref
Type:GParam
---Leaving  g_type_class_ref
+++Entering type_class_init_Wm
Call GParam.class_init_base()
Call GParamEnum.class_init()
---Leaving  type_class_init_Wm
--Leaving  g_type_class_ref
Call GParam.instance_init()
Call GParamEnum.instance_init()
++Entering type_data_make_W
GstPadTemplate->is_instantiatable = 1
--Leaving  type_data_make_W
++Entering g_type_class_ref
Type:GParamObject
+++Entering g_type_class_ref
Type:GParam
---Leaving  g_type_class_ref
+++Entering type_class_init_Wm
Call GParam.class_init_base()
Call GParamObject.class_init()
---Leaving  type_class_init_Wm
--Leaving  g_type_class_ref
Call GParam.instance_init()
Call GParamObject.instance_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstPluginFeature->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
GstElementFactory->is_instantiatable = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstElementFactory
 
+Entering g_type_class_ref
Type:GstPluginFeature
++Entering g_type_class_ref
Type:GstObject
--Leaving  g_type_class_ref
++Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstPluginFeature.class_init()
--Leaving  type_class_init_Wm
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstElementFactory.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstElement->is_instantiatable = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstElement
 
+Entering g_type_class_ref
Type:GstObject
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstElement.class_init_base()
Call GstElement.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstTypeFindFactory->is_instantiatable = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstTypeFindFactory
 
+Entering g_type_class_ref
Type:GstPluginFeature
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstTypeFindFactory.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstBin->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstBin
 
+Entering g_type_class_ref
Type:GstElement
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstElement.class_init_base()
Call GstBin.class_init_base()
Call GstBin.class_init()
++Entering g_type_class_ref
Type:GParamBoolean
+++Entering g_type_class_ref
Type:GParam
---Leaving  g_type_class_ref
+++Entering type_class_init_Wm
Call GParam.class_init_base()
Call GParamBoolean.class_init()
---Leaving  type_class_init_Wm
--Leaving  g_type_class_ref
Call GParam.instance_init()
++Entering g_type_class_ref
Type:GParamBoolean
--Leaving  g_type_class_ref
Call GParam.instance_init()
++Entering g_type_class_ref
Type:GstBin
+++Entering g_type_class_ref
Type:GstElement
---Leaving  g_type_class_ref
--Leaving  g_type_class_ref
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstBus->is_instantiatable = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstBus
 
+Entering g_type_class_ref
Type:GstObject
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstBus.class_init()
++Entering type_data_make_W
GstMessage->is_instantiatable = 1
--Leaving  type_data_make_W
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstTask->is_instantiatable = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstTask
 
+Entering g_type_class_ref
Type:GstObject
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstTask.class_init()
++Entering type_data_make_W
GstTaskPool->is_instantiatable = 1
--Leaving  type_data_make_W
++Entering g_type_class_ref
Type:GstTaskPool
+++Entering g_type_class_ref
Type:GstObject
---Leaving  g_type_class_ref
+++Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstTaskPool.class_init()
---Leaving  type_class_init_Wm
--Leaving  g_type_class_ref
++Entering g_type_class_ref
Type:GstTaskPool
--Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstTaskPool.instance_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstClock->is_instantiatable = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstClock
 
+Entering g_type_class_ref
Type:GstObject
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstClock.class_init()
++Entering g_type_class_ref
Type:GParamBoolean
--Leaving  g_type_class_ref
Call GParam.instance_init()
++Entering g_type_class_ref
Type:GParamInt
+++Entering g_type_class_ref
Type:GParam
---Leaving  g_type_class_ref
+++Entering type_class_init_Wm
Call GParam.class_init_base()
Call GParamInt.class_init()
---Leaving  type_class_init_Wm
--Leaving  g_type_class_ref
Call GParam.instance_init()
Call GParamInt.instance_init()
++Entering g_type_class_ref
Type:GParamInt
--Leaving  g_type_class_ref
Call GParam.instance_init()
Call GParamInt.instance_init()
++Entering g_type_class_ref
Type:GParamUInt64
+++Entering g_type_class_ref
Type:GParam
---Leaving  g_type_class_ref
+++Entering type_class_init_Wm
Call GParam.class_init_base()
Call GParamUInt64.class_init()
---Leaving  type_class_init_Wm
--Leaving  g_type_class_ref
Call GParam.instance_init()
Call GParamUInt64.instance_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstIndexFactory->is_instantiatable = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstIndexFactory
 
+Entering g_type_class_ref
Type:GstPluginFeature
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstIndexFactory.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
GstObjectFlags->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstObjectFlags
 
+Entering g_type_class_ref
Type:GFlags
++Entering type_class_init_Wm
--Leaving  type_class_init_Wm
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstObjectFlags.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstBinFlags->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstBinFlags
 
+Entering g_type_class_ref
Type:GFlags
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstBinFlags.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstBufferFlag->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstBufferFlag
 
+Entering g_type_class_ref
Type:GFlags
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstBufferFlag.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstBufferCopyFlags->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstBufferCopyFlags
 
+Entering g_type_class_ref
Type:GFlags
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstBufferCopyFlags.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstBufferListItem->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstBufferListItem
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstBufferListItem.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstBusFlags->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstBusFlags
 
+Entering g_type_class_ref
Type:GFlags
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstBusFlags.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstBusSyncReply->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstBusSyncReply
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstBusSyncReply.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstCapsFlags->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstCapsFlags
 
+Entering g_type_class_ref
Type:GFlags
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstCapsFlags.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstClockReturn->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstClockReturn
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstClockReturn.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstClockEntryType->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstClockEntryType
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstClockEntryType.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstClockFlags->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstClockFlags
 
+Entering g_type_class_ref
Type:GFlags
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstClockFlags.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstClockType->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstClockType
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstClockType.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstDebugGraphDetails->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstDebugGraphDetails
 
+Entering g_type_class_ref
Type:GFlags
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstDebugGraphDetails.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstState->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstState
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstState.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstStateChangeReturn->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstStateChangeReturn
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstStateChangeReturn.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstStateChange->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstStateChange
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstStateChange.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstElementFlags->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstElementFlags
 
+Entering g_type_class_ref
Type:GFlags
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstElementFlags.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstCoreError->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstCoreError
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstCoreError.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstLibraryError->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstLibraryError
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstLibraryError.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstResourceError->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstResourceError
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstResourceError.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstStreamError->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstStreamError
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstStreamError.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstEventTypeFlags->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstEventTypeFlags
 
+Entering g_type_class_ref
Type:GFlags
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstEventTypeFlags.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstEventType->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstEventType
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstEventType.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstSeekType->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstSeekType
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstSeekType.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstSeekFlags->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstSeekFlags
 
+Entering g_type_class_ref
Type:GFlags
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstSeekFlags.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstQOSType->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstQOSType
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstQOSType.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering g_type_class_ref
Type:GstFormat
Leaving  g_type_class_ref
Entering type_data_make_W
GstIndexCertainty->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstIndexCertainty
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstIndexCertainty.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstIndexEntryType->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstIndexEntryType
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstIndexEntryType.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstIndexLookupMethod->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstIndexLookupMethod
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstIndexLookupMethod.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstAssocFlags->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstAssocFlags
 
+Entering g_type_class_ref
Type:GFlags
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstAssocFlags.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstIndexResolverMethod->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstIndexResolverMethod
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstIndexResolverMethod.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstIndexFlags->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstIndexFlags
 
+Entering g_type_class_ref
Type:GFlags
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstIndexFlags.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstDebugLevel->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstDebugLevel
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstDebugLevel.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstDebugColorFlags->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstDebugColorFlags
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstDebugColorFlags.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstIteratorResult->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstIteratorResult
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstIteratorResult.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstIteratorItem->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstIteratorItem
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstIteratorItem.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstMessageType->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstMessageType
 
+Entering g_type_class_ref
Type:GFlags
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstMessageType.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstMiniObjectFlags->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstMiniObjectFlags
 
+Entering g_type_class_ref
Type:GFlags
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstMiniObjectFlags.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstPadLinkReturn->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstPadLinkReturn
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstPadLinkReturn.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstPadLinkCheck->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstPadLinkCheck
 
+Entering g_type_class_ref
Type:GFlags
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstPadLinkCheck.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstFlowReturn->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstFlowReturn
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstFlowReturn.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstActivateMode->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstActivateMode
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstActivateMode.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering g_type_class_ref
Type:GstPadDirection
Leaving  g_type_class_ref
Entering type_data_make_W
GstPadFlags->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstPadFlags
 
+Entering g_type_class_ref
Type:GFlags
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstPadFlags.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstPadPresence->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstPadPresence
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstPadPresence.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstPadTemplateFlags->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstPadTemplateFlags
 
+Entering g_type_class_ref
Type:GFlags
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstPadTemplateFlags.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstPipelineFlags->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstPipelineFlags
 
+Entering g_type_class_ref
Type:GFlags
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstPipelineFlags.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstPluginError->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstPluginError
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstPluginError.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstPluginFlags->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstPluginFlags
 
+Entering g_type_class_ref
Type:GFlags
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstPluginFlags.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstPluginDependencyFlags->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstPluginDependencyFlags
 
+Entering g_type_class_ref
Type:GFlags
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstPluginDependencyFlags.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstRank->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstRank
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstRank.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstQueryType->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstQueryType
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstQueryType.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstBufferingMode->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstBufferingMode
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstBufferingMode.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstStreamStatusType->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstStreamStatusType
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstStreamStatusType.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstStructureChangeType->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstStructureChangeType
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstStructureChangeType.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstTagMergeMode->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstTagMergeMode
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstTagMergeMode.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstTagFlag->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstTagFlag
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstTagFlag.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering g_type_class_ref
Type:GstTaskPool
Leaving  g_type_class_ref
Entering type_data_make_W
GstTaskState->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstTaskState
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstTaskState.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstAllocTraceFlags->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstAllocTraceFlags
 
+Entering g_type_class_ref
Type:GFlags
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstAllocTraceFlags.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstTypeFindProbability->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstTypeFindProbability
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstTypeFindProbability.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstURIType->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstURIType
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstURIType.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstParseError->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstParseError
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstParseError.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstParseFlags->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstParseFlags
 
+Entering g_type_class_ref
Type:GFlags
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstParseFlags.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstSearchMode->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstSearchMode
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstSearchMode.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstProgressType->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstProgressType
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstProgressType.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstCapsIntersectMode->is_classed = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstCapsIntersectMode
 
+Entering g_type_class_ref
Type:GEnum
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstCapsIntersectMode.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
GstBuffer->is_instantiatable = 1
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
GstParamFraction->is_instantiatable = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstParamFraction
 
+Entering g_type_class_ref
Type:GParam
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GParam.class_init_base()
Call GstParamFraction.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstEvent->is_instantiatable = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstEvent
 
+Entering g_type_class_ref
Type:GstMiniObject
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstEvent.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering g_type_class_ref
Type:GstSeekFlags
Leaving  g_type_class_ref
Entering g_type_class_ref
Type:GstSeekType
Leaving  g_type_class_ref
Entering g_type_class_ref
Type:GstBuffer
 
+Entering g_type_class_ref
Type:GstMiniObject
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstBuffer.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
GstBufferList->is_instantiatable = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstBufferList
 
+Entering g_type_class_ref
Type:GstMiniObject
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstBufferList.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstMessage
 
+Entering g_type_class_ref
Type:GstMiniObject
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstMessage.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
Leaving  type_data_make_W
Entering type_data_make_W
GstPlugin->is_instantiatable = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstPlugin
 
+Entering g_type_class_ref
Type:GstObject
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstPlugin.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering type_data_make_W
GstRegistry->is_instantiatable = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstRegistry
 
+Entering g_type_class_ref
Type:GstObject
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstRegistry.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering g_type_class_ref
Type:GstRegistry
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstRegistry.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstBin
Leaving  g_type_class_ref
Entering type_data_make_W
GstPipeline->is_instantiatable = 1
Leaving  type_data_make_W
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPipeline
 
+Entering g_type_class_ref
Type:GstBin
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstElement.class_init_base()
Call GstBin.class_init_base()
Call GstPipeline.class_init_base()
Call GstPipeline.class_init()
++Entering g_type_class_ref
Type:GParamUInt64
--Leaving  g_type_class_ref
Call GParam.instance_init()
Call GParamUInt64.instance_init()
++Entering g_type_class_ref
Type:GParamBoolean
--Leaving  g_type_class_ref
Call GParam.instance_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstTypeFindFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstTypeFindFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstIndexFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstIndexFactory.instance_init()
Entering g_type_class_ref
Type:GstIndexFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstIndexFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstPlugin
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPlugin.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()
Entering g_type_class_ref
Type:GstElementFactory
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstPluginFeature.instance_init()
Call GstElementFactory.instance_init()


========================================================

Entering g_type_class_ref
Type:GstPipeline
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstElement.instance_init()
Call GstBin.instance_init()
Entering g_type_class_ref
Type:GstBus
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstBus.instance_init()
Call GstPipeline.instance_init()
Entering g_type_class_ref
Type:GstBus
Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstObject.instance_init()
Call GstBus.instance_init()

gobject/gstobject的初始化(包括类型,类,实例等的初始化)。

gobjec相关学习文章的list.

 

Type,Class, instance 初始化,包括其中函数调用的过程总结:

阶段 相应API 作用 GObject 调用顺序 GstObject GstElement
1 xxx_yyy_get_type()

创建TypeNode, 并且赋值一些APIs:

base_class_init()

class_init()

instance_init(),

等等

     
2 g_type_class_ref()

调用base_class_init()

从父-->子,

g_object_base_class_init()

1. 父类:g_object_base_class_init()

2. 自己没有base_init()

1. 爷爷:g_object_base_class_init()

2. 父亲没有base_init()

3. gst_element_base_class_init

调用class_init(), 指定各种APIs

包括class->constructor(),

set_property()/get_property()

dispose()/finalize()

g_object_do_class_init()

gst_object_class_init()

1. 首选取得GObjectClass

2. 重载一些函数

3. 装载一些自己的signal

gst_element_class_init()

1. 首选取得GObjectClass

2. 把GObjectClass的一些函数换成自己的(重载)

3. 装载自己的信号

3 g_object_new()

调用class->constructor() --> g_type_create_instance() -->

父类的instance(), 自己的instance()

g_object_constructor()->g_type_create_instance() ->

1. g_object_init()

g_object_constructor()->g_type_create_instance() ->

1. 父亲:g_object_init()

2.自己:gst_object_init()

g_object_constructor()->g_type_create_instance() ->

1. 爷爷:g_object_init()

2.父亲:gst_object_init()

3. 自己:gst_element_init()

 

set properties      

 

下面是具体的分析:

g_object_type_init()

1. 这个API完成GObject类型的注册

2. GObject 作为一个基础类型,放入全局数组以及Hash Table中

3. 分配GObject Node的数据,并且把用户指定的一系列函数指针赋值过去

4. 此时还没有真正的GObject对象实例。

 

void
g_type_init (void)
{
  g_type_init_with_debug_flags (0);
}
  /* G_TYPE_OBJECT
   */
  g_object_type_init ();
void
g_object_type_init (void)
{
  static gboolean initialized = FALSE;
  static const GTypeFundamentalInfo finfo = {
    G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE,
  };
  static GTypeInfo info = {
    sizeof (GObjectClass),
    (GBaseInitFunc) g_object_base_class_init,
    (GBaseFinalizeFunc) g_object_base_class_finalize,
    (GClassInitFunc) g_object_do_class_init,
    NULL	/* class_destroy */,
    NULL	/* class_data */,
    sizeof (GObject),
    0		/* n_preallocs */,
    (GInstanceInitFunc) g_object_init,
    NULL,	/* value_table */
  };
  static const GTypeValueTable value_table = {
    g_value_object_init,	  /* value_init */
    g_value_object_free_value,	  /* value_free */
    g_value_object_copy_value,	  /* value_copy */
    g_value_object_peek_pointer,  /* value_peek_pointer */
    "p",			  /* collect_format */
    g_value_object_collect_value, /* collect_value */
    "p",			  /* lcopy_format */
    g_value_object_lcopy_value,	  /* lcopy_value */
  };
  GType type;
  
  g_return_if_fail (initialized == FALSE);
  initialized = TRUE;
  
  /* G_TYPE_OBJECT
   */
  info.value_table = &value_table;
  type = g_type_register_fundamental (G_TYPE_OBJECT, g_intern_static_string ("GObject"), &info, &finfo, 0);
  g_assert (type == G_TYPE_OBJECT);
  g_value_register_transform_func (G_TYPE_OBJECT, G_TYPE_OBJECT, g_value_object_transform_value);
  

}

这里注册GObject类型:

1. 指定这个类型的标记flag

  static const GTypeFundamentalInfo finfo = {
    G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE,
  };

2. 注册Class的GTypeInfo. 相关的几个函数指针

3. 注册GObject type的函数表Value Table

 

问题来了:

g_object_base_class_init、g_object_do_class_init、g_object_init 何时被调用?

有什么严格的顺序吗?

 

我们先看看GObject的内部注册过程中,干了些什么?然后再看看基于Gobject生成新的object实例时

做了些什么?

GType
g_type_register_fundamental (GType                       type_id,
			     const gchar                *type_name,
			     const GTypeInfo            *info,
			     const GTypeFundamentalInfo *finfo,
			     GTypeFlags			 flags)
{
  TypeNode *node;
 
  
  G_WRITE_LOCK (&type_rw_lock);
  node = type_node_fundamental_new_W (type_id, type_name, finfo->type_flags);
  type_add_flags_W (node, flags);
  
  if (check_type_info_I (NULL, NODE_FUNDAMENTAL_TYPE (node), type_name, info))
    type_data_make_W (node, info,
		      check_value_table_I (type_name, info->value_table) ? info->value_table : NULL);
  G_WRITE_UNLOCK (&type_rw_lock);
  
  return NODE_TYPE (node);
}

其中关系不大的代码去掉了。

因为GObject是基础类型,没有父节点,所以代码中,去掉了部分。

static TypeNode*
type_node_any_new_W (TypeNode             *pnode,
		     GType                 ftype,
		     const gchar          *name,
		     GTypePlugin          *plugin,
		     GTypeFundamentalFlags type_flags)
{
  guint n_supers;
  GType type;
  TypeNode *node;
  guint i, node_size = 0;

  n_supers = pnode ? pnode->n_supers + 1 : 0;
  
  if (!pnode)
    node_size += SIZEOF_FUNDAMENTAL_INFO;	      /* fundamental type info */
  node_size += SIZEOF_BASE_TYPE_NODE ();	      /* TypeNode structure */
  node_size += (sizeof (GType) * (1 + n_supers + 1)); /* self + ancestors + (0) for ->supers[] */
  node = g_malloc0 (node_size);
  if (!pnode)					      /* offset fundamental types */
    {
      node = G_STRUCT_MEMBER_P (node, SIZEOF_FUNDAMENTAL_INFO);
      static_fundamental_type_nodes[ftype >> G_TYPE_FUNDAMENTAL_SHIFT] = node;
      type = ftype;
    }

  
 
 
  node->n_supers = n_supers;
  if (!pnode)
    {
      node->supers[0] = type;
      node->supers[1] = 0;
      
      node->is_classed = (type_flags & G_TYPE_FLAG_CLASSED) != 0;
      node->is_instantiatable = (type_flags & G_TYPE_FLAG_INSTANTIATABLE) != 0;
      
      if (NODE_IS_IFACE (node))
	{
          IFACE_NODE_N_PREREQUISITES (node) = 0;
	  IFACE_NODE_PREREQUISITES (node) = NULL;
	}
      else
	_g_atomic_array_init (CLASSED_NODE_IFACES_ENTRIES (node));
    }
 
  TRACE(GOBJECT_TYPE_NEW(name, node->supers[1], type));

  node->plugin = plugin;
  node->n_children = 0;
  node->children = NULL;
  node->data = NULL;
  node->qname = g_quark_from_string (name);
  node->global_gdata = NULL;
  
  g_hash_table_insert (static_type_nodes_ht,
		       GUINT_TO_POINTER (node->qname),
		       (gpointer) type);
  return node;
}

上面重要的地方:

static_fundamental_type_nodes[ftype >> G_TYPE_FUNDAMENTAL_SHIFT] = node; //把G_OBJECT_TYPE放入基础类型数组。


      node->supers[0] = type; //没有父亲节点
      node->supers[1] = 0;
     
      node->is_classed = (type_flags & G_TYPE_FLAG_CLASSED) != 0; //可类化
      node->is_instantiatable = (type_flags & G_TYPE_FLAG_INSTANTIATABLE) != 0;  //可实例化
 

下面是把前面设置的GObject的标识:存入node的qdata中,用quark:static_quark_type_flags 来标识。

即:

static void
type_add_flags_W (TypeNode  *node,
		  GTypeFlags flags)
{
  guint dflags;
  
  g_return_if_fail ((flags & ~TYPE_FLAG_MASK) == 0);
  g_return_if_fail (node != NULL);
  
  if ((flags & TYPE_FLAG_MASK) && node->is_classed && node->data && node->data->class.class)
    g_warning ("tagging type `%s' as abstract after class initialization", NODE_NAME (node));
  dflags = GPOINTER_TO_UINT (type_get_qdata_L (node, static_quark_type_flags));
  dflags |= flags;
  type_set_qdata_W (node, static_quark_type_flags, GUINT_TO_POINTER (dflags));
}

 

重点是下面:

/* --- type info (type node data) --- */
static void
type_data_make_W (TypeNode              *node,
		  const GTypeInfo       *info,
		  const GTypeValueTable *value_table)
{
  TypeData *data;
  GTypeValueTable *vtable = NULL;
  guint vtable_size = 0;
  
  g_assert (node->data == NULL && info != NULL);
  
  if (!value_table)
    {
      TypeNode *pnode = lookup_type_node_I (NODE_PARENT_TYPE (node));
      
      if (pnode)
	vtable = pnode->data->common.value_table;
      else
	{
	  static const GTypeValueTable zero_vtable = { NULL, };
	  
	  value_table = &zero_vtable;
	}
    }
  if (value_table)
    {
      /* need to setup vtable_size since we have to allocate it with data in one chunk */
      vtable_size = sizeof (GTypeValueTable);
      if (value_table->collect_format)
	vtable_size += strlen (value_table->collect_format);
      if (value_table->lcopy_format)
	vtable_size += strlen (value_table->lcopy_format);
      vtable_size += 2;
    }
   
  if (node->is_instantiatable) /* carefull, is_instantiatable is also is_classed */
    {
      TypeNode *pnode = lookup_type_node_I (NODE_PARENT_TYPE (node));

      data = g_malloc0 (sizeof (InstanceData) + vtable_size);
      if (vtable_size)
	vtable = G_STRUCT_MEMBER_P (data, sizeof (InstanceData));
      data->instance.class_size = info->class_size;
      data->instance.class_init_base = info->base_init;
      data->instance.class_finalize_base = info->base_finalize;
      data->instance.class_init = info->class_init;
      data->instance.class_finalize = info->class_finalize;
      data->instance.class_data = info->class_data;
      data->instance.class = NULL;
      data->instance.init_state = UNINITIALIZED;
      data->instance.instance_size = info->instance_size;
      /* We'll set the final value for data->instance.private size
       * after the parent class has been initialized
       */
      data->instance.private_size = 0;
      data->instance.class_private_size = 0;
      if (pnode)
        data->instance.class_private_size = pnode->data->instance.class_private_size;
#ifdef	DISABLE_MEM_POOLS
      data->instance.n_preallocs = 0;
#else	/* !DISABLE_MEM_POOLS */
      data->instance.n_preallocs = MIN (info->n_preallocs, 1024);
#endif	/* !DISABLE_MEM_POOLS */
      data->instance.instance_init = info->instance_init;
    }
  else if (node->is_classed) /* only classed */
    {
      TypeNode *pnode = lookup_type_node_I (NODE_PARENT_TYPE (node));

      data = g_malloc0 (sizeof (ClassData) + vtable_size);
      if (vtable_size)
	vtable = G_STRUCT_MEMBER_P (data, sizeof (ClassData));
      data->class.class_size = info->class_size;
      data->class.class_init_base = info->base_init;
      data->class.class_finalize_base = info->base_finalize;
      data->class.class_init = info->class_init;
      data->class.class_finalize = info->class_finalize;
      data->class.class_data = info->class_data;
      data->class.class = NULL;
      data->class.class_private_size = 0;
      if (pnode)
        data->class.class_private_size = pnode->data->class.class_private_size;
      data->class.init_state = UNINITIALIZED;
    }
  else if (NODE_IS_IFACE (node))
    {
      data = g_malloc0 (sizeof (IFaceData) + vtable_size);
      if (vtable_size)
	vtable = G_STRUCT_MEMBER_P (data, sizeof (IFaceData));
      data->iface.vtable_size = info->class_size;
      data->iface.vtable_init_base = info->base_init;
      data->iface.vtable_finalize_base = info->base_finalize;
      data->iface.dflt_init = info->class_init;
      data->iface.dflt_finalize = info->class_finalize;
      data->iface.dflt_data = info->class_data;
      data->iface.dflt_vtable = NULL;
    }
  else if (NODE_IS_BOXED (node))
    {
      data = g_malloc0 (sizeof (BoxedData) + vtable_size);
      if (vtable_size)
	vtable = G_STRUCT_MEMBER_P (data, sizeof (BoxedData));
    }
  else
    {
      data = g_malloc0 (sizeof (CommonData) + vtable_size);
      if (vtable_size)
	vtable = G_STRUCT_MEMBER_P (data, sizeof (CommonData));
    }
  
  node->data = data;
  
  if (vtable_size)
    {
      gchar *p;
      
      /* we allocate the vtable and its strings together with the type data, so
       * children can take over their parent's vtable pointer, and we don't
       * need to worry freeing it or not when the child data is destroyed
       */
      *vtable = *value_table;
      p = G_STRUCT_MEMBER_P (vtable, sizeof (*vtable));
      p[0] = 0;
      vtable->collect_format = p;
      if (value_table->collect_format)
	{
	  strcat (p, value_table->collect_format);
	  p += strlen (value_table->collect_format);
	}
      p++;
      p[0] = 0;
      vtable->lcopy_format = p;
      if (value_table->lcopy_format)
	strcat  (p, value_table->lcopy_format);
    }
  node->data->common.value_table = vtable;
  node->mutatable_check_cache = (node->data->common.value_table->value_init != NULL &&
				 !((G_TYPE_FLAG_VALUE_ABSTRACT | G_TYPE_FLAG_ABSTRACT) &
				   GPOINTER_TO_UINT (type_get_qdata_L (node, static_quark_type_flags))));
  
  g_assert (node->data->common.value_table != NULL); /* paranoid */

  g_atomic_int_set ((int *) &node->ref_count, 1);
}

这里有个union的变量:node->data: 可选4个类型:BoxedData/IFaceData/ClassData/InsanceData

node->is_instantiatable = 1

所以选择InstanceData

  if (node->is_instantiatable) /* carefull, is_instantiatable is also is_classed */
    {
      TypeNode *pnode = lookup_type_node_I (NODE_PARENT_TYPE (node));

      data = g_malloc0 (sizeof (InstanceData) + vtable_size);
      if (vtable_size)
	vtable = G_STRUCT_MEMBER_P (data, sizeof (InstanceData));
      data->instance.class_size = info->class_size;
      data->instance.class_init_base = info->base_init;
      data->instance.class_finalize_base = info->base_finalize;
      data->instance.class_init = info->class_init;
      data->instance.class_finalize = info->class_finalize;
      data->instance.class_data = info->class_data;
      data->instance.class = NULL;
      data->instance.init_state = UNINITIALIZED;
      data->instance.instance_size = info->instance_size;
      /* We'll set the final value for data->instance.private size
       * after the parent class has been initialized
       */
      data->instance.private_size = 0;
      data->instance.class_private_size = 0;
      if (pnode)
        data->instance.class_private_size = pnode->data->instance.class_private_size;
#ifdef	DISABLE_MEM_POOLS
      data->instance.n_preallocs = 0;
#else	/* !DISABLE_MEM_POOLS */
      data->instance.n_preallocs = MIN (info->n_preallocs, 1024);
#endif	/* !DISABLE_MEM_POOLS */
      data->instance.instance_init = info->instance_init;
    }

node->data = data;

把前面class的base/class/instance的APIs, Value Table APIs, 赋值给node->data

 

g_type_init():

1. ....

2. g_object_type_init()

3. ...

 

用户如何用呢?

之后应该就是g_object_new?

我们找个例子看看:

GObject

`|_____ GstObject

 

在gstobject.c:

G_DEFINE_ABSTRACT_TYPE (GstObject, gst_object, G_TYPE_OBJECT);

 

先比较一下gobject.c/gstobject.c提供的一些API:

Me (当前) 儿子 孙子 重孙子
GObject GstObject GstElement GstBin GstPipeline
g_object_base_class_init()   gst_element_base_class_init gst_bin_base_init gst_pipeline_base_init
g_object_do_class_init() gst_object_class_init() gst_element_class_init gst_bin_class_init gst_pipeline_class_init
g_object_init() gst_object_init() gst_element_init gst_bin_init gst_pipeline_init

 

把宏展开,看到上面gstobject提供的两个API,绑定了:

#define _G_DEFINE_TYPE_EXTENDED_BEGIN(GstObject, gst_object, G_TYPE_OBJECT, flags) \
\
static void     gst_object_init              (GstObject       *self); \
static void     gst_object_class_init        (GstObjectClass *klass); \
static gpointer gst_object_parent_class = NULL; \
static void     gst_object_class_intern_init (gpointer klass) \
{ \
  gst_object_parent_class = g_type_class_peek_parent (klass); \
  gst_object_class_init ((GstObjectlass*) klass); \
} \
\
GType \
gst_object_get_type (void) \
{ \
  static volatile gsize g_define_type_id__volatile = 0; \
  if (g_once_init_enter (&g_define_type_id__volatile))  \
    { \
      GType g_define_type_id = \
        g_type_register_static_simple (G_TYPE_OBJECT, \
                                       g_intern_static_string ("GstObject"), \
                                       sizeof (CGstObjectClass), \
                                       (GClassInitFunc) gst_object_class_intern_init, \
                                       sizeof (GstObject), \
                                       (GInstanceInitFunc) gst_object_init, \
                                       (GTypeFlags) flags); \
      { /* custom code follows */
#define _G_DEFINE_TYPE_EXTENDED_END()	\
        /* following custom code */	\
      }					\
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id); \
    }					\
  return g_define_type_id__volatile;	\
} /* closes gst_object_get_type() */

 

首先取得父类的class数据:

gpointer
g_type_class_peek_parent (gpointer g_class)
{
  TypeNode *node;
  gpointer class = NULL;
  
  g_return_val_if_fail (g_class != NULL, NULL);
  
  node = lookup_type_node_I (G_TYPE_FROM_CLASS (g_class));
  /* We used to acquire a read lock here. That is not necessary, since 
   * parent->data->class.class is constant as long as the derived class
   * exists. 
   */
  if (node && node->is_classed && node->data && NODE_PARENT_TYPE (node))
    {
      node = lookup_type_node_I (NODE_PARENT_TYPE (node));
      class = node->data->class.class;
    }
  else if (NODE_PARENT_TYPE (node))
    g_warning (G_STRLOC ": invalid class pointer `%p'", g_class);
  
  return class;
}

class = node->data->class.class;

 

然后真正开始Init:

gst.c中:

g_type_class_ref (gst_object_get_type ());

 

首先会调用:

GType
g_type_register_static_simple (GType             parent_type,
			       const gchar      *type_name,
			       guint             class_size,
			       GClassInitFunc    class_init,
			       guint             instance_size,
			       GInstanceInitFunc instance_init,
			       GTypeFlags	 flags)
{
  GTypeInfo info;

  info.class_size = class_size;
  info.base_init = NULL;
  info.base_finalize = NULL;
  info.class_init = class_init;
  info.class_finalize = NULL;
  info.class_data = NULL;
  info.instance_size = instance_size;
  info.n_preallocs = 0;
  info.instance_init = instance_init;
  info.value_table = NULL;

  return g_type_register_static (parent_type, type_name, &info, flags);
}

然后指定自己的class_init/Instance_init函数,就开始创建这个TypeNode.

GType
g_type_register_static (GType            parent_type,
			const gchar     *type_name,
			const GTypeInfo *info,
			GTypeFlags	 flags)
{
  TypeNode *pnode, *node;
  GType type = 0;
  
  g_return_val_if_type_system_uninitialized (0);
  g_return_val_if_fail (parent_type > 0, 0);
  g_return_val_if_fail (type_name != NULL, 0);
  g_return_val_if_fail (info != NULL, 0);
  
  if (!check_type_name_I (type_name) ||
      !check_derivation_I (parent_type, type_name))
    return 0;
  if (info->class_finalize)
    {
      g_warning ("class finalizer specified for static type `%s'",
		 type_name);
      return 0;
    }
  
  pnode = lookup_type_node_I (parent_type);
  G_WRITE_LOCK (&type_rw_lock);
  type_data_ref_Wm (pnode);
  if (check_type_info_I (pnode, NODE_FUNDAMENTAL_TYPE (pnode), type_name, info))
    {
      node = type_node_new_W (pnode, type_name, NULL);
      type_add_flags_W (node, flags);
      type = NODE_TYPE (node);
      type_data_make_W (node, info,
			check_value_table_I (type_name, info->value_table) ? info->value_table : NULL);
    }
  G_WRITE_UNLOCK (&type_rw_lock);
  
  return type;
}

1. type_data_ref_Wm (pnode); //给父节点增加一个引用计数

2. node = type_node_new_W (pnode, type_name, NULL); //从父节点拷贝出一份内存,并且建立父子关系;

   并且把新创建的“子节点” 保存在父节点的数组中:pnode->children[i] = type;

3. type_data_make_W, 就是用户指定的各种APIs, Value Table APIs, 指定给这个新建的Type Node, 这里是给GstObject

 

g_type_class_ref(GstObject);


好戏都在g_type_class_ref

这个函数是个循环嵌套函数!

gpointer
g_type_class_ref (GType type)
{
  TypeNode *node;
  GType ptype;
  gboolean holds_ref;
  GTypeClass *pclass;
  /* optimize for common code path */
  node = lookup_type_node_I (type);

  /* we need an initialized parent class for initializing derived classes */
  ptype = NODE_PARENT_TYPE (node);
  pclass = ptype ? g_type_class_ref (ptype) : NULL;

它会顺藤摸瓜!找到最上面的祖先:

这里它会找到GObject (GstObject的父类),GObject已经是最顶层了。

好,接着往下:

  if (!holds_ref)
    type_data_ref_Wm (node);

  if (!node->data->class.class) /* class uninitialized */
    type_class_init_Wm (node, pclass);

最关键的地方:如果当前class并没有被初始化,则进行初始化。

先初始化GObject, 然后轮到其儿子:GstObject.

 

对某个typeclass进行下面的顺序进行初始化:

BASE_CLASS_INIT

BASE_IFACE_INIT

CLASS_INIT

IFACE_INIT

INITIALIZED

 

对GObject的初始化:

1. BASE_CLASS_INIT

  /* stack all base class initialization functions, so we
   * call them in ascending order.
   */
  for (bnode = node; bnode; bnode = lookup_type_node_I (NODE_PARENT_TYPE (bnode))) 
  {
    if (bnode->data->class.class_init_base)
      init_slist = g_slist_prepend (init_slist, (gpointer) bnode->data->class.class_init_base);
  }

  for (slist = init_slist; slist; slist = slist->next)
    {
      GBaseInitFunc class_init_base = (GBaseInitFunc) slist->data;
      class_init_base (class);
    }

 

for (bnode = node; bnode; bnode = lookup_type_nodeI (NODE_PARENT_TYPE (bnode)))

是从最底层往上层循环(孙子 --> 儿子--> 爷爷)

 

init_slist, 是反过来弄的:

爷爷->儿子-->孙子,这么一个顺序,进行class_init_base()

后面会印证。

 

2. CLASS_INIT

  g_atomic_int_set (&node->data->class.init_state, CLASS_INIT);
  
  G_WRITE_UNLOCK (&type_rw_lock);

  if (node->data->class.class_init)
    node->data->class.class_init (class, (gpointer) node->data->class.class_data);

此时执行:g_object_do_class_init()

 

父类初始化完成后,嵌套退回一层,开始自行GstObjec的初始化:

也是按照那个顺序,有的成员是NULL, 就跳过去:

3. GstObject的CLASS_INIT

  g_atomic_int_set (&node->data->class.init_state, CLASS_INIT);
  
  G_WRITE_UNLOCK (&type_rw_lock);

  if (node->data->class.class_init)
    node->data->class.class_init (class, (gpointer) node->data->class.class_data);

此时执行:gst_object_class_init()


注意,此时:gobject/gstobject的实例instance对象还没有建立!

 

g_object_base_class_init

static void
g_object_base_class_init (GObjectClass *class)
{
  GObjectClass *pclass = g_type_class_peek_parent (class);

  /* Don't inherit HAS_DERIVED_CLASS flag from parent class */
  class->flags &= ~CLASS_HAS_DERIVED_CLASS_FLAG;

  if (pclass)
    pclass->flags |= CLASS_HAS_DERIVED_CLASS_FLAG;

  /* reset instance specific fields and methods that don't get inherited */
  class->construct_properties = pclass ? g_slist_copy (pclass->construct_properties) : NULL;
  class->get_property = NULL;
  class->set_property = NULL;
}

g_object_do_class_init

static void
g_object_do_class_init (GObjectClass *class)
{
  /* read the comment about typedef struct CArray; on why not to change this quark */
  quark_closure_array = g_quark_from_static_string ("GObject-closure-array");

  quark_weak_refs = g_quark_from_static_string ("GObject-weak-references");
  quark_toggle_refs = g_quark_from_static_string ("GObject-toggle-references");
  pspec_pool = g_param_spec_pool_new (TRUE);
  property_notify_context.quark_notify_queue = g_quark_from_static_string ("GObject-notify-queue");
  property_notify_context.dispatcher = g_object_notify_dispatcher;

  class->constructor = g_object_constructor;
  class->constructed = g_object_constructed;
  class->set_property = g_object_do_set_property;
  class->get_property = g_object_do_get_property;
  class->dispose = g_object_real_dispose;
  class->finalize = g_object_finalize;
  class->dispatch_properties_changed = g_object_dispatch_properties_changed;
  class->notify = NULL;

  /**
   * GObject::notify:
   * @gobject: the object which received the signal.
   * @pspec: the #GParamSpec of the property which changed.
   *
   * The notify signal is emitted on an object when one of its
   * properties has been changed. Note that getting this signal
   * doesn't guarantee that the value of the property has actually
   * changed, it may also be emitted when the setter for the property
   * is called to reinstate the previous value.
   *
   * This signal is typically used to obtain change notification for a
   * single property, by specifying the property name as a detail in the
   * g_signal_connect() call, like this:
   * |[
   * g_signal_connect (text_view->buffer, "notify::paste-target-list",
   *                   G_CALLBACK (gtk_text_view_target_list_notify),
   *                   text_view)
   * ]|
   * It is important to note that you must use
   * <link linkend="canonical-parameter-name">canonical</link> parameter names as
   * detail strings for the notify signal.
   */
  gobject_signals[NOTIFY] =
    g_signal_new (g_intern_static_string ("notify"),
		  G_TYPE_FROM_CLASS (class),
		  G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE | G_SIGNAL_DETAILED | G_SIGNAL_NO_HOOKS | G_SIGNAL_ACTION,
		  G_STRUCT_OFFSET (GObjectClass, notify),
		  NULL, NULL,
		  g_cclosure_marshal_VOID__PARAM,
		  G_TYPE_NONE,
		  1, G_TYPE_PARAM);

  /* Install a check function that we'll use to verify that classes that
   * implement an interface implement all properties for that interface
   */
  g_type_add_interface_check (NULL, object_interface_check_properties);
}

gst_object_class_init

static void
gst_object_class_init (GstObjectClass * klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  parent_class = g_type_class_peek_parent (klass);

#ifndef GST_DISABLE_TRACE
  _gst_object_trace = gst_alloc_trace_register (g_type_name (GST_TYPE_OBJECT));
#endif

  gobject_class->set_property = gst_object_set_property;
  gobject_class->get_property = gst_object_get_property;

  g_object_class_install_property (gobject_class, ARG_NAME,
      g_param_spec_string ("name", "Name", "The name of the object",
          NULL,
          G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));

  /**
   * GstObject::parent-set:
   * @gstobject: a #GstObject
   * @parent: the new parent
   *
   * Emitted when the parent of an object is set.
   */
  gst_object_signals[PARENT_SET] =
      g_signal_new ("parent-set", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
      G_STRUCT_OFFSET (GstObjectClass, parent_set), NULL, NULL,
      g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GST_TYPE_OBJECT);

  /**
   * GstObject::parent-unset:
   * @gstobject: a #GstObject
   * @parent: the old parent
   *
   * Emitted when the parent of an object is unset.
   */
  gst_object_signals[PARENT_UNSET] =
      g_signal_new ("parent-unset", G_TYPE_FROM_CLASS (klass),
      G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstObjectClass, parent_unset), NULL,
      NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GST_TYPE_OBJECT);

#if !defined(GST_DISABLE_LOADSAVE) && !defined(GST_REMOVE_DEPRECATED)
  /**
   * GstObject::object-saved:
   * @gstobject: a #GstObject
   * @xml_node: the xmlNodePtr of the parent node
   *
   * Trigered whenever a new object is saved to XML. You can connect to this
   * signal to insert custom XML tags into the core XML.
   */
  /* FIXME This should be the GType of xmlNodePtr instead of G_TYPE_POINTER
   *       (if libxml would use GObject)
   */
  gst_object_signals[OBJECT_SAVED] =
      g_signal_new ("object-saved", G_TYPE_FROM_CLASS (klass),
      G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstObjectClass, object_saved), NULL,
      NULL, g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1, G_TYPE_POINTER);

  klass->restore_thyself =
      ((void (*)(GstObject * object,
              gpointer self)) *gst_object_real_restore_thyself);
#endif

  /**
   * GstObject::deep-notify:
   * @gstobject: a #GstObject
   * @prop_object: the object that originated the signal
   * @prop: the property that changed
   *
   * The deep notify signal is used to be notified of property changes. It is
   * typically attached to the toplevel bin to receive notifications from all
   * the elements contained in that bin.
   */
  gst_object_signals[DEEP_NOTIFY] =
      g_signal_new ("deep-notify", G_TYPE_FROM_CLASS (klass),
      G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE | G_SIGNAL_DETAILED |
      G_SIGNAL_NO_HOOKS, G_STRUCT_OFFSET (GstObjectClass, deep_notify), NULL,
      NULL, gst_marshal_VOID__OBJECT_PARAM, G_TYPE_NONE, 2, GST_TYPE_OBJECT,
      G_TYPE_PARAM);

  klass->path_string_separator = "/";
  /* FIXME 0.11: Store this directly in the class struct */
  klass->lock = g_slice_new (GStaticRecMutex);
  g_static_rec_mutex_init (klass->lock);

  klass->signal_object = g_object_newv (gst_signal_object_get_type (), 0, NULL);

  /* see the comments at gst_object_dispatch_properties_changed */
  gobject_class->dispatch_properties_changed
      = GST_DEBUG_FUNCPTR (gst_object_dispatch_properties_changed);

  gobject_class->dispose = gst_object_dispose;
  gobject_class->finalize = gst_object_finalize;
}

 

Testing:

1. g_type_class_ref(G_TYPE_OBJECT)

g_type_init();
g_type_class_ref(G_TYPE_OBJECT);

result:

Entering g_type_class_ref
Type:GObject
 
+Entering type_class_init_Wm
Call GObject.class_init_base()
Call GObject.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref

 

2. 

g_type_init();
g_type_class_ref(G_TYPE_OBJECT);
g_type_class_ref(GST_TYPE_OBJECT);
Entering g_type_class_ref
Type:GObject
 
+Entering type_class_init_Wm
Call GObject.class_init_base()
Call GObject.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering g_type_class_ref
Type:GstObject
 
+Entering g_type_class_ref
Type:GObject
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstObject.class_init()
++Entering g_type_class_ref
Type:GParamString
+++Entering g_type_class_ref
Type:GParam
++++Entering type_class_init_Wm
Call GParam.class_init_base()
Call GParam.class_init()
----Leaving  type_class_init_Wm
---Leaving  g_type_class_ref
+++Entering type_class_init_Wm
Call GParam.class_init_base()
Call GParamString.class_init()
---Leaving  type_class_init_Wm
--Leaving  g_type_class_ref
++Entering g_type_class_ref
Type:GstSignalObject
+++Entering g_type_class_ref
Type:GObject
---Leaving  g_type_class_ref
+++Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstSignalObject.class_init()
---Leaving  type_class_init_Wm
--Leaving  g_type_class_ref
++Entering g_type_class_ref
Type:GstSignalObject
--Leaving  g_type_class_ref
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref

 

 

3.

g_type_init();
g_type_class_ref(GST_TYPE_OBJECT);
Entering g_type_class_ref
Type:GstObject
 
+Entering g_type_class_ref
Type:GObject
++Entering type_class_init_Wm
Call GObject.class_init_base()
Call GObject.class_init()
--Leaving  type_class_init_Wm
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstObject.class_init()
++Entering g_type_class_ref
Type:GParamString
+++Entering g_type_class_ref
Type:GParam
++++Entering type_class_init_Wm
Call GParam.class_init_base()
Call GParam.class_init()
----Leaving  type_class_init_Wm
---Leaving  g_type_class_ref
+++Entering type_class_init_Wm
Call GParam.class_init_base()
Call GParamString.class_init()
---Leaving  type_class_init_Wm
--Leaving  g_type_class_ref
++Entering g_type_class_ref
Type:GstSignalObject
+++Entering g_type_class_ref
Type:GObject
---Leaving  g_type_class_ref
+++Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstSignalObject.class_init()
---Leaving  type_class_init_Wm
--Leaving  g_type_class_ref
++Entering g_type_class_ref
Type:GstSignalObject
--Leaving  g_type_class_ref
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref

4.

g_type_init();
g_type_class_ref(G_TYPE_OBJECT);
g_type_class_ref(GST_TYPE_OBJECT);
g_type_class_ref(GST_TYPE_ELEMENT);

 

=============================

Entering g_type_class_ref
Type:GObject
 
+Entering type_class_init_Wm
Call GObject.class_init_base()
Call GObject.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref


=============================

Entering g_type_class_ref
Type:GstObject
 
+Entering g_type_class_ref
Type:GObject
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstObject.class_init()
++Entering g_type_class_ref
Type:GParamString
+++Entering g_type_class_ref
Type:GParam
++++Entering type_class_init_Wm
Call GParam.class_init_base()
Call GParam.class_init()
----Leaving  type_class_init_Wm
---Leaving  g_type_class_ref
+++Entering type_class_init_Wm
Call GParam.class_init_base()
Call GParamString.class_init()
---Leaving  type_class_init_Wm
--Leaving  g_type_class_ref
++Entering g_type_class_ref
Type:GstSignalObject
+++Entering g_type_class_ref
Type:GObject
---Leaving  g_type_class_ref
+++Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstSignalObject.class_init()
---Leaving  type_class_init_Wm
--Leaving  g_type_class_ref
++Entering g_type_class_ref
Type:GstSignalObject
--Leaving  g_type_class_ref
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref


=============================

Entering g_type_class_ref
Type:GstElement
 
+Entering g_type_class_ref
Type:GstObject
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstElement.class_init_base()
Call GObject.class_init_base()
Call GstElement.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref

5.

g_type_init();
g_type_class_ref(GST_TYPE_ELEMENT);
Entering g_type_class_ref
Type:GstElement
 
+Entering g_type_class_ref
Type:GstObject
++Entering g_type_class_ref
Type:GObject
+++Entering type_class_init_Wm
Call GObject.class_init_base()
Call GObject.class_init()
---Leaving  type_class_init_Wm
--Leaving  g_type_class_ref
++Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstObject.class_init()
+++Entering g_type_class_ref
Type:GParamString
++++Entering g_type_class_ref
Type:GParam
+++++Entering type_class_init_Wm
Call GParam.class_init_base()
Call GParam.class_init()
-----Leaving  type_class_init_Wm
----Leaving  g_type_class_ref
++++Entering type_class_init_Wm
Call GParam.class_init_base()
Call GParamString.class_init()
----Leaving  type_class_init_Wm
---Leaving  g_type_class_ref
+++Entering g_type_class_ref
Type:GstSignalObject
++++Entering g_type_class_ref
Type:GObject
----Leaving  g_type_class_ref
++++Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstSignalObject.class_init()
----Leaving  type_class_init_Wm
---Leaving  g_type_class_ref
+++Entering g_type_class_ref
Type:GstSignalObject
---Leaving  g_type_class_ref
--Leaving  type_class_init_Wm
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstElement.class_init_base()
Call GObject.class_init_base()
Call GstElement.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref

 

6.

g_type_init();
g_type_class_ref(GST_TYPE_PIPELINE);
Entering g_type_class_ref
Type:GstPipeline
 
+Entering g_type_class_ref
Type:GstBin
++Entering g_type_class_ref
Type:GstElement
+++Entering g_type_class_ref
Type:GstObject
++++Entering g_type_class_ref
Type:GObject
+++++Entering type_class_init_Wm
Call GObject.class_init_base()
Call GObject.class_init()
-----Leaving  type_class_init_Wm
----Leaving  g_type_class_ref
++++Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstObject.class_init()
+++++Entering g_type_class_ref
Type:GParamString
++++++Entering g_type_class_ref
Type:GParam
+++++++Entering type_class_init_Wm
Call GParam.class_init_base()
Call GParam.class_init()
-------Leaving  type_class_init_Wm
------Leaving  g_type_class_ref
++++++Entering type_class_init_Wm
Call GParam.class_init_base()
Call GParamString.class_init()
------Leaving  type_class_init_Wm
-----Leaving  g_type_class_ref
+++++Entering g_type_class_ref
Type:GstSignalObject
++++++Entering g_type_class_ref
Type:GObject
------Leaving  g_type_class_ref
++++++Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstSignalObject.class_init()
------Leaving  type_class_init_Wm
-----Leaving  g_type_class_ref
+++++Entering g_type_class_ref
Type:GstSignalObject
-----Leaving  g_type_class_ref
----Leaving  type_class_init_Wm
---Leaving  g_type_class_ref
+++Entering type_class_init_Wm
Call GstElement.class_init_base()
Call GObject.class_init_base()
Call GstElement.class_init()
---Leaving  type_class_init_Wm
--Leaving  g_type_class_ref
++Entering type_class_init_Wm
Call GstBin.class_init_base()
Call GstElement.class_init_base()
Call GObject.class_init_base()
Call GstBin.class_init()
+++Entering g_type_class_ref
Type:GParamBoolean
++++Entering g_type_class_ref
Type:GParam
----Leaving  g_type_class_ref
++++Entering type_class_init_Wm
Call GParam.class_init_base()
Call GParamBoolean.class_init()
----Leaving  type_class_init_Wm
---Leaving  g_type_class_ref
+++Entering g_type_class_ref
Type:GParamBoolean
---Leaving  g_type_class_ref
+++Entering g_type_class_ref
Type:GstBin
++++Entering g_type_class_ref
Type:GstElement
----Leaving  g_type_class_ref
---Leaving  g_type_class_ref
--Leaving  type_class_init_Wm
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GstPipeline.class_init_base()
Call GstBin.class_init_base()
Call GstElement.class_init_base()
Call GObject.class_init_base()
Call GstPipeline.class_init()
++Entering g_type_class_ref
Type:GParamUInt64
+++Entering g_type_class_ref
Type:GParam
---Leaving  g_type_class_ref
+++Entering type_class_init_Wm
Call GParam.class_init_base()
Call GParamUInt64.class_init()
---Leaving  type_class_init_Wm
--Leaving  g_type_class_ref
++Entering g_type_class_ref
Type:GParamBoolean
--Leaving  g_type_class_ref
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref

 

上面的base调用打印应该是反的

Call GstPipeline.class_init_base()
Call GstBin.class_init_base()
Call GstElement.class_init_base()
Call GObject.class_init_base()
 

实际是:

GObject.class_init_base()

GstElement.class_init_base()

GstBin.class_init_base()

GstPipeline.class_init_base()

先父亲后儿子的顺序,调用base_init():

Me (当前) 儿子 孙子 重孙子
GObject GstObject GstElement GstBin GstPipeline
g_object_base_class_init()   gst_element_base_class_init gst_bin_base_init gst_pipeline_base_init
g_object_do_class_init() gst_object_class_init() gst_element_class_init gst_bin_class_init gst_pipeline_class_init
g_object_init() gst_object_init() gst_element_init gst_bin_init gst_pipeline_init

 

小结一下:

xxx_yyy_get_type(), 是创建type node, 并且,绑定自己定义的一些APIs;

g_type_class_ref(), 是调用用户的一些class: APIs,

                                先调用base_init() [老子--> 儿子-->当前],

                                在调用class_init()

 

这个时候,对象实例依然没有创建。

 

下面就要看g_object_newv的实力了!

 

examples:

1.

g_object_new(G_TYPE_OBJECT, NULL);
GEnum->is_classed = 1
GFlags->is_classed = 1
GParam->is_instantiatable = 1
GObject->is_instantiatable = 1
GParamChar->is_instantiatable = 1
GParamUChar->is_instantiatable = 1
GParamBoolean->is_instantiatable = 1
GParamInt->is_instantiatable = 1
GParamUInt->is_instantiatable = 1
GParamLong->is_instantiatable = 1
GParamULong->is_instantiatable = 1
GParamInt64->is_instantiatable = 1
GParamUInt64->is_instantiatable = 1
GParamUnichar->is_instantiatable = 1
GParamEnum->is_instantiatable = 1
GParamFlags->is_instantiatable = 1
GParamFloat->is_instantiatable = 1
GParamDouble->is_instantiatable = 1
GParamString->is_instantiatable = 1
GParamParam->is_instantiatable = 1
GParamBoxed->is_instantiatable = 1
GParamPointer->is_instantiatable = 1
GParamValueArray->is_instantiatable = 1
GParamObject->is_instantiatable = 1
GParamOverride->is_instantiatable = 1
GParamGType->is_instantiatable = 1
GParamVariant->is_instantiatable = 1


=============================

Entering g_type_class_ref
Type:GObject
 
+Entering type_class_init_Wm
Call GObject.class_init_base()
Call GObject.class_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref
Entering g_type_class_ref
Type:GObject
Leaving  g_type_class_ref
Call GObject.instance_init()

 

2.

g_object_new(GST_TYPE_OBJECT,NULL);
GEnum->is_classed = 1
GFlags->is_classed = 1
GParam->is_instantiatable = 1
GObject->is_instantiatable = 1
GParamChar->is_instantiatable = 1
GParamUChar->is_instantiatable = 1
GParamBoolean->is_instantiatable = 1
GParamInt->is_instantiatable = 1
GParamUInt->is_instantiatable = 1
GParamLong->is_instantiatable = 1
GParamULong->is_instantiatable = 1
GParamInt64->is_instantiatable = 1
GParamUInt64->is_instantiatable = 1
GParamUnichar->is_instantiatable = 1
GParamEnum->is_instantiatable = 1
GParamFlags->is_instantiatable = 1
GParamFloat->is_instantiatable = 1
GParamDouble->is_instantiatable = 1
GParamString->is_instantiatable = 1
GParamParam->is_instantiatable = 1
GParamBoxed->is_instantiatable = 1
GParamPointer->is_instantiatable = 1
GParamValueArray->is_instantiatable = 1
GParamObject->is_instantiatable = 1
GParamOverride->is_instantiatable = 1
GParamGType->is_instantiatable = 1
GParamVariant->is_instantiatable = 1


=============================

GstObject->is_instantiatable = 1
Entering g_type_class_ref
Type:GstObject
 
+Entering g_type_class_ref
Type:GObject
++Entering type_class_init_Wm
Call GObject.class_init_base()
Call GObject.class_init()
--Leaving  type_class_init_Wm
-Leaving  g_type_class_ref
 
+Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstObject.class_init()
++Entering g_type_class_ref
Type:GParamString
+++Entering g_type_class_ref
Type:GParam
++++Entering type_class_init_Wm
Call GParam.class_init_base()
Call GParam.class_init()
----Leaving  type_class_init_Wm
---Leaving  g_type_class_ref
+++Entering type_class_init_Wm
Call GParam.class_init_base()
Call GParamString.class_init()
---Leaving  type_class_init_Wm
--Leaving  g_type_class_ref
Call GParam.instance_init()
Call GParamString.instance_init()
GstSignalObject->is_instantiatable = 1
++Entering g_type_class_ref
Type:GstSignalObject
+++Entering g_type_class_ref
Type:GObject
---Leaving  g_type_class_ref
+++Entering type_class_init_Wm
Call GObject.class_init_base()
Call GstSignalObject.class_init()
---Leaving  type_class_init_Wm
--Leaving  g_type_class_ref
++Entering g_type_class_ref
Type:GstSignalObject
--Leaving  g_type_class_ref
Call GObject.instance_init()
Call GstSignalObject.instance_init()
-Leaving  type_class_init_Wm
Leaving  g_type_class_ref

GLib-GObject-WARNING **: cannot create instance of abstract (non-instantiatable) type `GstObject'
aborting...

 

小结:

 

阶段 相应API 作用 GObject 调用顺序 GstObject GstElement
1 xxx_yyy_get_type()

创建TypeNode, 并且赋值一些APIs:

base_class_init()

class_init()

instance_init(),

等等

     
2 g_type_class_ref()

调用base_class_init()

从父-->子,

g_object_base_class_init()

1. 父类:g_object_base_class_init()

2. 自己没有base_init()

1. 爷爷:g_object_base_class_init()

2. 父亲没有base_init()

3. gst_element_base_class_init

调用class_init(), 指定各种APIs

包括class->constructor(),

set_property()/get_property()

dispose()/finalize()

g_object_do_class_init()

gst_object_class_init()

1. 首选取得GObjectClass

2. 重载一些函数

3. 装载一些自己的signal

gst_element_class_init()

1. 首选取得GObjectClass

2. 把GObjectClass的一些函数换成自己的(重载)

3. 装载自己的信号

3 g_object_new()

调用class->constructor() -->   g_type_create_instance() -->

父类的instance(), 自己的instance()

g_object_constructor()->g_type_create_instance() ->

1. g_object_init()

g_object_constructor()->g_type_create_instance() ->

1. 父亲:g_object_init()

2.自己:gst_object_init()

g_object_constructor()->g_type_create_instance() ->

1. 爷爷:g_object_init()

2.父亲:gst_object_init()

3. 自己:gst_element_init()

 

set properties      

 

疑问:在同一进程内,如果同时注册N个话,如果管理?

“用时”注册,会浪费时间吗?

 

 

gobject中比较常用,但是又比较生疏的数据类型quark/dataset。

gobjec相关学习文章的list.

glib中除了提供

1. array/byte array/pointer array

2. SList/List

3. Hash Table

4. Queue

5. String

6. Tree

之外,还有quark/dataset, 这是gobject中用的非常多的。要理解它。

 

GQuark:

quark其实就是个数字,用来和字符串进行匹配。

 

只有一个gquark.h, 没有gquark.c

typedef guint32 GQuark;

实现文件在gdataset.c

static GHashTable   *g_quark_ht = NULL;
static gchar       **g_quarks = NULL;
static GQuark        g_quark_seq_id = 0;

上面定义了一个hash table:g_quark_ht和一个全局的指针数组:g_quarks。

 

从下面的new中,我们可以很清楚的看到,string如何和数字对应的:

/* HOLDS: g_quark_global_lock */
static inline GQuark
g_quark_new (gchar *string)
{
  GQuark quark;
  
  if (g_quark_seq_id % G_QUARK_BLOCK_SIZE == 0)
    g_quarks = g_renew (gchar*, g_quarks, g_quark_seq_id + G_QUARK_BLOCK_SIZE);
  if (!g_quark_ht)
    {
      g_assert (g_quark_seq_id == 0);
      g_quark_ht = g_hash_table_new (g_str_hash, g_str_equal);
      g_quarks[g_quark_seq_id++] = NULL;
    }

  quark = g_quark_seq_id++;
  g_quarks[quark] = string;
  g_hash_table_insert (g_quark_ht, string, GUINT_TO_POINTER (quark));
  
  return quark;
}

会创建一个全局的Hash Table: g_quark_ht, 用来保持string/quark

同时把string放入数组中:g_quarks[quark] = string.

如果一个进程中有很多string, 那个这个指针数组是否很大?占用的内存如何?能否优化一些不用的?

 

GData

有了gquark后,就可以有GData了,这是和

gquark关联的一个数据元链表。

struct _GData
{
  GData *next;
  GQuark id;
  gpointer data;
  GDestroyNotify destroy_func;
};

这个data list, 并没有一个明显的全局变量来保持它。

1. 用时分配内存

2. 存放在一个全局的Hash Table中

3. 用完释放掉

 

GDataset:

 

struct _GDataset
{
  gconstpointer location;
  GData        *datalist;
};

Datalist的作用主要是:

给GObject关联任意数据。

Data lists are used for associating arbitrary data with #GObjects

 

定义了一个全局的Hash Table来保存,新生成的datalist

static GHashTable   *g_dataset_location_ht = NULL;
static GDataset     *g_dataset_cached = NULL; /* should this be
						 threadspecific? */
static void
g_data_initialize (void)
{
  g_return_if_fail (g_dataset_location_ht == NULL);

  g_dataset_location_ht = g_hash_table_new (g_direct_hash, NULL);
  g_dataset_cached = NULL;
}

下面2个函数会把new的数据,放到hash table中:

void
g_dataset_id_set_data_full (gconstpointer  dataset_location,
			    GQuark         key_id,
			    gpointer       data,
			    GDestroyNotify destroy_func)
void
g_datalist_id_set_data_full (GData	  **datalist,
			     GQuark         key_id,
			     gpointer       data,
			     GDestroyNotify destroy_func)

再仔细看下这个函数:

void
g_dataset_id_set_data_full (gconstpointer  dataset_location,
			    GQuark         key_id,
			    gpointer       data,
			    GDestroyNotify destroy_func)
{
  register GDataset *dataset;
  
  g_return_if_fail (dataset_location != NULL);
  if (!data)
    g_return_if_fail (destroy_func == NULL);
  if (!key_id)
    {
      if (data)
	g_return_if_fail (key_id > 0);
      else
	return;
    }
  
  G_LOCK (g_dataset_global);
  if (!g_dataset_location_ht)
    g_data_initialize ();
 
  dataset = g_dataset_lookup (dataset_location);
  if (!dataset)
    {
      dataset = g_slice_new (GDataset);
      dataset->location = dataset_location;
      g_datalist_init (&dataset->datalist);
      g_hash_table_insert (g_dataset_location_ht, 
			   (gpointer) dataset->location,
			   dataset);
    }
  
  g_data_set_internal (&dataset->datalist, key_id, data, destroy_func, dataset);
  G_UNLOCK (g_dataset_global);
}

0. 先根据hash table的key查询一下,是否已经存在与之关联的dataset

    如果没有,则新分配;如果有,则把相关的数据(data)放到这个data_list中

1. 上面是给GDataset分配一块内存

2. 把新的dataset插入到hash table中

3. 把用户想携带的data/destroy_func放到data_list中

 

实际使用:

在实际使用中g_dataset_xxx用的并不多,

而是g_datalist_xxx用的多:

#define   g_datalist_id_set_data(dl, q, d)      \
     g_datalist_id_set_data_full ((dl), (q), (d), NULL)

实际使用中,GObject主要用了这个函数:g_datalist_id_set_data

void
g_datalist_id_set_data_full (GData	  **datalist,
			     GQuark         key_id,
			     gpointer       data,
			     GDestroyNotify destroy_func)
{
  g_return_if_fail (datalist != NULL);
  if (!data)
    g_return_if_fail (destroy_func == NULL);
  if (!key_id)
    {
      if (data)
	g_return_if_fail (key_id > 0);
      else
	return;
    }

  G_LOCK (g_dataset_global);
  if (!g_dataset_location_ht)
    g_data_initialize ();
  
  g_data_set_internal (datalist, key_id, data, destroy_func, NULL);
  G_UNLOCK (g_dataset_global);
}

 

查询一下:

Gobject.c (\glib-2.28.6\gobject):  g_datalist_id_set_data (&object->qdata, quark_closure_array, NULL);
Gobject.c (\glib-2.28.6\gobject):  g_datalist_id_set_data (&object->qdata, quark_weak_refs, NULL);
Gobject.c (\glib-2.28.6\gobject):      g_datalist_id_set_data (&object->qdata, quark_closure_array, NULL);
Gobject.c (\glib-2.28.6\gobject):      g_datalist_id_set_data (&object->qdata, quark_weak_refs, NULL);
Gobject.c (\glib-2.28.6\gobject):  g_datalist_id_set_data (&object->qdata, quark, data);
Gobject.c (\glib-2.28.6\gobject):  g_datalist_id_set_data (&object->qdata, g_quark_from_string (key), data);
Gobjectnotifyqueue.c (\glib-2.28.6\gobject):  g_datalist_id_set_data (&object->qdata, context->quark_notify_queue, NULL);
Gparam.c (\glib-2.28.6\gobject):  g_datalist_id_set_data (&pspec->qdata, quark, data);
Gstobject.c (\gstreamer-0.10.36\gst):  g_datalist_id_set_data (&object_name_counts, q, GINT_TO_POINTER (count + 1));

 

GObject中的qdata:

1. 内部使用的

2. 进一步封装,提供给调用者使用的APIs

 

在GObject自己内部用了3个quark来标识与之关联的data(任何数据) 

static GQuark	            quark_closure_array = 0;
static GQuark	            quark_weak_refs = 0;
static GQuark	            quark_toggle_refs = 0;

再复杂的data, 用这个quark/datalist, 都可以绑定/提取,这样看来datalist还是很强大滴~

Gobject.c (\glib-2.28.6\gobject):static GQuark	            quark_closure_array = 0;
Gobject.c (\glib-2.28.6\gobject):  quark_closure_array = g_quark_from_static_string ("GObject-closure-array");
Gobject.c (\glib-2.28.6\gobject):  g_datalist_id_set_data (&object->qdata, quark_closure_array, NULL);
Gobject.c (\glib-2.28.6\gobject):      g_datalist_id_set_data (&object->qdata, quark_closure_array, NULL);
Gobject.c (\glib-2.28.6\gobject):  carray = g_object_get_qdata (object, quark_closure_array);
Gobject.c (\glib-2.28.6\gobject):       * letting it fiddle with quark_closure_array which is empty anyways
Gobject.c (\glib-2.28.6\gobject):  carray = g_datalist_id_remove_no_notify (&object->qdata, quark_closure_array);
Gobject.c (\glib-2.28.6\gobject):  g_datalist_id_set_data_full (&object->qdata, quark_closure_array, carray, destroy_closure_array);
---- quark_weak_refs Matches (7 in 1 files) ----
Gobject.c (\glib-2.28.6\gobject):static GQuark	            quark_weak_refs = 0;
Gobject.c (\glib-2.28.6\gobject):  quark_weak_refs = g_quark_from_static_string ("GObject-weak-references");
Gobject.c (\glib-2.28.6\gobject):  g_datalist_id_set_data (&object->qdata, quark_weak_refs, NULL);
Gobject.c (\glib-2.28.6\gobject):  wstack = g_datalist_id_remove_no_notify (&object->qdata, quark_weak_refs);
Gobject.c (\glib-2.28.6\gobject):  g_datalist_id_set_data_full (&object->qdata, quark_weak_refs, wstack, weak_refs_notify);
Gobject.c (\glib-2.28.6\gobject):  wstack = g_datalist_id_get_data (&object->qdata, quark_weak_refs);
Gobject.c (\glib-2.28.6\gobject):      g_datalist_id_set_data (&object->qdata, quark_weak_refs, NULL);
---- quark_toggle_refs Matches (6 in 1 files) ----
Gobject.c (\glib-2.28.6\gobject):static GQuark	            quark_toggle_refs = 0;
Gobject.c (\glib-2.28.6\gobject):  quark_toggle_refs = g_quark_from_static_string ("GObject-toggle-references");
Gobject.c (\glib-2.28.6\gobject):  tstackptr = g_datalist_id_get_data (&object->qdata, quark_toggle_refs);
Gobject.c (\glib-2.28.6\gobject):  tstack = g_datalist_id_remove_no_notify (&object->qdata, quark_toggle_refs);
Gobject.c (\glib-2.28.6\gobject):  g_datalist_id_set_data_full (&object->qdata, quark_toggle_refs, tstack,
Gobject.c (\glib-2.28.6\gobject):  tstack = g_datalist_id_get_data (&object->qdata, quark_toggle_refs);

 

static void
g_object_do_class_init (GObjectClass *class)
{
  /* read the comment about typedef struct CArray; on why not to change this quark */
  quark_closure_array = g_quark_from_static_string ("GObject-closure-array");

  quark_weak_refs = g_quark_from_static_string ("GObject-weak-references");
  quark_toggle_refs = g_quark_from_static_string ("GObject-toggle-references");

上面这3个quark来标识GObject的3种重要数据:

1)GObject的Closure Array

2)  Weak Reference

3) Toggle reference

 Closure Array用quark来存取:

void
g_object_watch_closure (GObject  *object,
			GClosure *closure)
{
  CArray *carray;
  guint i;
  
  g_return_if_fail (G_IS_OBJECT (object));
  g_return_if_fail (closure != NULL);
  g_return_if_fail (closure->is_invalid == FALSE);
  g_return_if_fail (closure->in_marshal == FALSE);
  g_return_if_fail (object->ref_count > 0);	/* this doesn't work on finalizing objects */
  
  g_closure_add_invalidate_notifier (closure, object, object_remove_closure);
  g_closure_add_marshal_guards (closure,
				object, (GClosureNotify) g_object_ref,
				object, (GClosureNotify) g_object_unref);
  G_LOCK (closure_array_mutex);
  carray = g_datalist_id_remove_no_notify (&object->qdata, quark_closure_array);
  if (!carray)
    {
      carray = g_renew (CArray, NULL, 1);
      carray->object = object;
      carray->n_closures = 1;
      i = 0;
    }
  else
    {
      i = carray->n_closures++;
      carray = g_realloc (carray, sizeof (*carray) + sizeof (carray->closures[0]) * i);
    }
  carray->closures[i] = closure;
  g_datalist_id_set_data_full (&object->qdata, quark_closure_array, carray, destroy_closure_array);
  G_UNLOCK (closure_array_mutex);
}

g_datalist_id_set_data_full (&object->qdata, quark_closure_array, carray, destroy_closure_array);
这是把Closure Array用quark标识后,并且放入data list中

 

在g_object_unref()中:

      g_datalist_id_set_data (&object->qdata, quark_closure_array, NULL);
      g_datalist_id_set_data (&object->qdata, quark_weak_refs, NULL);

在dispose时也搞:

static void
g_object_real_dispose (GObject *object)
{
  g_signal_handlers_destroy (object);
  g_datalist_id_set_data (&object->qdata, quark_closure_array, NULL);
  g_datalist_id_set_data (&object->qdata, quark_weak_refs, NULL);
}

 

Weak Reference用quark来存取:

void
g_object_weak_ref (GObject    *object,
		   GWeakNotify notify,
		   gpointer    data)
{
  WeakRefStack *wstack;
  guint i;
  
  g_return_if_fail (G_IS_OBJECT (object));
  g_return_if_fail (notify != NULL);
  g_return_if_fail (object->ref_count >= 1);

  G_LOCK (weak_refs_mutex);
  wstack = g_datalist_id_remove_no_notify (&object->qdata, quark_weak_refs);
  if (wstack)
    {
      i = wstack->n_weak_refs++;
      wstack = g_realloc (wstack, sizeof (*wstack) + sizeof (wstack->weak_refs[0]) * i);
    }
  else
    {
      wstack = g_renew (WeakRefStack, NULL, 1);
      wstack->object = object;
      wstack->n_weak_refs = 1;
      i = 0;
    }
  wstack->weak_refs[i].notify = notify;
  wstack->weak_refs[i].data = data;
  g_datalist_id_set_data_full (&object->qdata, quark_weak_refs, wstack, weak_refs_notify);
  G_UNLOCK (weak_refs_mutex);
}

Toggle Reference用quark来存取:

void
g_object_add_toggle_ref (GObject       *object,
			 GToggleNotify  notify,
			 gpointer       data)
{
  ToggleRefStack *tstack;
  guint i;
  
  g_return_if_fail (G_IS_OBJECT (object));
  g_return_if_fail (notify != NULL);
  g_return_if_fail (object->ref_count >= 1);

  g_object_ref (object);

  G_LOCK (toggle_refs_mutex);
  tstack = g_datalist_id_remove_no_notify (&object->qdata, quark_toggle_refs);
  if (tstack)
    {
      i = tstack->n_toggle_refs++;
      /* allocate i = tstate->n_toggle_refs - 1 positions beyond the 1 declared
       * in tstate->toggle_refs */
      tstack = g_realloc (tstack, sizeof (*tstack) + sizeof (tstack->toggle_refs[0]) * i);
    }
  else
    {
      tstack = g_renew (ToggleRefStack, NULL, 1);
      tstack->object = object;
      tstack->n_toggle_refs = 1;
      i = 0;
    }

  /* Set a flag for fast lookup after adding the first toggle reference */
  if (tstack->n_toggle_refs == 1)
    g_datalist_set_flags (&object->qdata, OBJECT_HAS_TOGGLE_REF_FLAG);
  
  tstack->toggle_refs[i].notify = notify;
  tstack->toggle_refs[i].data = data;
  g_datalist_id_set_data_full (&object->qdata, quark_toggle_refs, tstack,
			       (GDestroyNotify)g_free);
  G_UNLOCK (toggle_refs_mutex);
}

 

Gobject除了自己内部用的3个quark外,

还封装了一组API给外部调用:调用者可以自己定义自己的quark, 并且可以给object绑定/提取自己关系的数据:

gpointer    g_object_get_qdata                (GObject        *object,
					       GQuark          quark);
void        g_object_set_qdata                (GObject        *object,
					       GQuark          quark,
					       gpointer        data);
void        g_object_set_qdata_full           (GObject        *object,
					       GQuark          quark,
					       gpointer        data,
					       GDestroyNotify  destroy);
gpointer    g_object_steal_qdata              (GObject        *object,
					       GQuark          quark);


gpointer    g_object_get_data                 (GObject        *object,
					       const gchar    *key);
void        g_object_set_data                 (GObject        *object,
					       const gchar    *key,
					       gpointer        data);
void        g_object_set_data_full            (GObject        *object,
					       const gchar    *key,
					       gpointer        data,
					       GDestroyNotify  destroy);
gpointer    g_object_steal_data               (GObject        *object,
					       const gchar    *key);

 

这一组首先是定义一个quark,

然后用quark来标识data, 并且进行绑定/提取操作:

gpointer    g_object_get_qdata                (GObject        *object,
       GQuark          quark);
void        g_object_set_qdata                (GObject        *object,
       GQuark          quark,
       gpointer        data);
void        g_object_set_qdata_full           (GObject        *object,
       GQuark          quark,
       gpointer        data,
       GDestroyNotify  destroy);
gpointer    g_object_steal_qdata              (GObject        *object,
       GQuark          quark);
 

下面这一组,不仅仅是quark, 可以用字符串来标识。

gpointer    g_object_get_data                 (GObject        *object,
       const gchar    *key);
void        g_object_set_data                 (GObject        *object,
       const gchar    *key,
       gpointer        data);
void        g_object_set_data_full            (GObject        *object,
       const gchar    *key,
       gpointer        data,
       GDestroyNotify  destroy);
gpointer    g_object_steal_data               (GObject        *object,
       const gchar    *key);

 

用的地方很多,非常多~

 

gobjec相关学习文章的list.

gobject相关学习文章的list.

Index:

 

 ID Title 简单描述
19 GObject 设计思想  Gobject Tutorial
18 C++ VS Gobject  
17 gobject->qdata的使用(1: property notify and getter/setter)。

 弄明白gobject property内部机制,

以及user如何使用它;更多的可以

参考gstreamer 如何使用它。

16 g_object_new()的理解。  
15 GObject中的Override(父类和子类的方法重写).  
14 g_new_object(GST_TYPE_PIPELINE) instance建立过程。 log
13 g_object_new(G_TYPE_OBJECT) instance的建立。 log
12 gobject/gstobject的初始化(包括类型,类,实例等的初始化)。

 基本上弄清base_class_init();class_init()

instance_init()的过程。

11 gobject中比较常用,但是又比较生疏的数据类型quark/dataset。  gobject中用的非常多的quark/qdata
10 小结一下:gsignal的new/connect/emit. 整体明白后,小结
9 从gst的have-type信号,看signal new/connect/emit. gst的例子
8 gsignal 1.new/2.connect/3.emit gtk的例子
7 gobject的调试。 主要查看继承关系
6 GTYPE类型系统分析 zz  
5 gobject运行时重要的数据结构。 分析gobject跑起来后,有哪些重要的数据结构
4 GObject Reference Manual 官方参考文档
3 type.h  type的定义等,如何保存
2 如何查看GType节点,以及父子关系。 一个调试方法
1 GObject-Glib Type, Object, Parameter and Signal 这是一个扫盲的总结

 

1. Type System : ok

2. Parameter/ParamSpec: ok

3. Closure/Marshal/Signal: ok

4. GObject

5. GModule

6. GPlugin