GstBin和sink组件的状态转换代码分析和相关逻辑

1. 每个element/bin都有current，next，pending三个成员变量表示状态。current和next很好理解，pending一般就是我们给该element设置的最终的状态，比如调用gst_element_set_state函数设置PLAYING state，则这个pending一般就是PLAYING。代码中还看到有一个宏GST_STATE_TARGET，这个TARGET一般也和pending一样，表示最终要设置的state（final state） 

2. gst_element_set_state_func函数（gst_element_set_state的缺省实现）会调用gst_element_change_state，change_state又会调用gst_element_continue_state。对于这里state的转变，关键问题在sink element和bin上。对于sink element来说，只要到达PAUSED状态，就需要preroll，同时返回ASYNC，此时sink的状态不会commit，就是说还是READY和PLAYING状态，next state是PAUSED，pending状态是我们给他设置的最终状态。而且_set_state/change_state在看到返回了ASYNC之后，就直接返回了，也就是说，set_state函数调用到PAUSED之后就结束了。下面的工作就是gstbin完成的。这就又牵扯到gstbasesink.c和gstbin.c了。 

basesink中，在状态变成PAUSED的时候，会发出ASYNC_START的消息，这个消息会被gstbin捕获（一般element都需要加到bin中，或是加到pipeline中）并记录，而且如果这个bin不是toplevel的话（所谓toplevel指的是这个bin的parent是NULL），还会将ASYNC_START消息继续往上发送，如果是toplevel就不会发了。此外，bin会修改自己的state, next, pending这些变量，注意只是修改这些变量，并不会去调用每个element的change_state函数。设置这些变量显示bin当前是PAUSED状态。 
OK，basesink中，如果preroll完成（第一个非event的buffer到达，由函数gst_base_sink_preroll_object完成），就会调用gst_base_sink_commit_state函数，这个函数会直接将该sink的state设置成最终的那个state，也就是保存在pending中的state，同时将next和pending state都设成VOID，这表示sink现在preroll完成了，对于状态转换已经没有其他特别的东西了，然后发送ASYNC_DONE消息。gstbin在收到ASYNC_DONE消息后，首先查看是不是bin中所有发送过ASYNC_START的element都已经发送了DONE了，如果是，则调用关键函数bin_handle_async_done，这个函数会将bin的状态修改过来，然后会向gThreadPool中push一个task，这个task就会负责去调用bin的change_state函数，这个函数就会去调用每个element的change_state函数修改状态了。有关gthreadpool请参考glib中的内容。 

所以，综合上面来看，在我们对一个sink element设置PLAYING状态时，最终是由bin来负责PAUSED->PLAYING的，因为sink element有一个preroll的过程，sink通过ASYNC_START和ASYNC_DONE来和bin进行通信。 

为了验证上面的一点，我写了一个程序，这个程序在timeout callback函数中创建了一个fakesrc和一个udpsink，link他们，但是不把他们加入pipeline，最后设置他们的状态为PLAYING。同时，我在gstpipeline.c的change_state函数和gstbasesink.c的change_state函数中，在PAUSED->PLAYING状态时加入了一条打印语句，来监视这些代码是否会被触发。结果是，这两个element的状态变成了PLAYING，但是pipeline的change_state函数和basesink的change_state函数都没有被触发，这说明preroll完成后，只是修改了element的state的三个变量，真正的change_state函数需要由bin来负责调用。一旦将他们加入pipeline，就能发现change_state函数被调用了（指的是change_state中PAUSED->PLAYING部分的代码）。附件1中是测试的代码。 

最后说一下，这次研究上面这些东西，是因为发现我加在rtspsrc中的代码会被反复调用。我在gst_rtspsrc_play中加入了一段代码，这段代码每次会创建四个element，2个fakesrc和2个udpsink。gst_rtspsrc_play会在rtspsrc由PAUSED转向PLAYING时被调用。结果发现我的代码被执行了很多次，导致创建出来了一大堆的element。原因就是上面的原理： 

我每次创建的2个udpsink，设置成PLAYING后，发送ASYNC_START, ASYNC_DONE的消息，rtspsrc作为bin收到这些消息，在DONE消息处理的时候，会去调用change_state的PAUSED->PLAYING部分的代码，一调用这部分代码，我的代码又被执行，如此循环，导致创建出了很多的element。所以，关键就是： 

a. 给创建的udpsink设置async属性为FALSE，这样就取消了preroll，就不会有ASYNC_START, ASYNC_DONE消息产生了。 
或者 
b. 检测是否已经创建了element，不要每次都创建element，如果已创建过，则无需再创建。 

其他更严谨一些，创建element，尤其是sink element，根本就不应该放在转向PLAYING状态的时候，而是应该在PAUSED状态的时候就完成。 

 

 #include <gst/gst.h>

GstElement *pipeline, *fakesrc1, *udpsink1, *fakesrc2, *udpsink2;

static gboolean on_timeout(gpointer data)
{
    g_message("ENTERING TIMEOUT PART  START...");

    fakesrc2 = gst_element_factory_make("fakesrc", NULL);
    g_object_set (G_OBJECT(fakesrc2), "filltype", 3, NULL);
    g_object_set (G_OBJECT(fakesrc2), "num-buffers", 5, NULL);
    
    gchar *rtpuri = g_strdup_printf ("udp://202.119.24.12:5000");
    udpsink2 = gst_element_make_from_uri (GST_URI_SINK, rtpuri, NULL);
    g_free (rtpuri);

    // Add and link
    // gst_bin_add_many(GST_BIN(pipeline), fakesrc2, udpsink2, NULL);
    gst_element_link(fakesrc2, udpsink2);

    gst_element_set_state(fakesrc2, GST_STATE_PLAYING);
    gst_element_set_state(udpsink2, GST_STATE_PLAYING);
    
    GstState cur, pending;
    gst_element_get_state(fakesrc2, &cur, &pending, GST_CLOCK_TIME_NONE);
    g_message("fakesrc2 cur state is %d, pending state is %d", cur, pending);
    gst_element_get_state(udpsink2, &cur, &pending, GST_CLOCK_TIME_NONE);
    g_message("udpsink2 cur state is %d, pending state is %d", cur, pending);

    g_message("ENTERING TIMEOUT PART  END...");
    return FALSE;
}

static gboolean bus_call(GstBus *bus, GstMessage *msg, gpointer data)
{
    GMainLoop *loop = (GMainLoop *)data;
    
    switch(GST_MESSAGE_TYPE(msg)) {
        case GST_MESSAGE_EOS:
            g_print("End-of-stream\n");
            g_print("The message's owner is: %s\n", GST_OBJECT_NAME(GST_MESSAGE_SRC(msg)));
            // g_main_loop_quit(loop);
            break;
        case GST_MESSAGE_ERROR: {
            gchar *debug;
            GError *err;

            gst_message_parse_error(msg, &err, &debug);
            g_print("Error debug info: %s\n", debug);
            g_free(debug);

            g_print("Error: %s\n", err->message);
            g_error_free(err);

            g_main_loop_quit(loop);
            break;
        }
        case GST_MESSAGE_NEW_CLOCK: {
            GstClock *newclock;
            gst_message_parse_new_clock(msg, &newclock);
            g_message("Got new clock, clock name is %s", GST_OBJECT_NAME(GST_OBJECT(newclock)));
            break;
        }
        case GST_MESSAGE_ASYNC_START: {
            g_message("Got ASYNC_START message.");
            break;
        }
        case GST_MESSAGE_ASYNC_DONE: {
            g_message("Got ASYNC_DONE message.");
            break;
        }
        default:
            break;
    }

    return TRUE;
}

int main(int argc, char *argv[])
{
    GMainLoop *loop;
    GstBus *bus;

    gst_init(&argc, &argv);
    loop = g_main_loop_new(NULL, FALSE);

    // create elements
    pipeline = gst_element_factory_make("pipeline", "pipeline");
    fakesrc1 = gst_element_factory_make("fakesrc", NULL);
    g_object_set (G_OBJECT(fakesrc1), "filltype", 3, NULL);
    g_object_set (G_OBJECT(fakesrc1), "num-buffers", 5, NULL);
    
    gchar *rtpuri = g_strdup_printf ("udp://202.119.24.12:5000");
    udpsink1 = gst_element_make_from_uri (GST_URI_SINK, rtpuri, NULL);
    g_free (rtpuri);

    if (!pipeline || !fakesrc1 || !udpsink1) {
        g_print("Elements could not be created!\n");
        return -1;
    }

    bus = gst_pipeline_get_bus(GST_PIPELINE(pipeline));
    gst_bus_add_watch(bus, bus_call, loop);
    gst_object_unref(bus);

    // Add and link
    gst_bin_add_many(GST_BIN(pipeline), fakesrc1, udpsink1, NULL);
    gst_element_link(fakesrc1, udpsink1);

    // now play
    g_print("Setting to PLAYING\n");
    gst_element_set_state(pipeline, GST_STATE_PLAYING);
    g_print("Running\n");

    // add timeout callback
    g_timeout_add(4000, (GSourceFunc)on_timeout, NULL);

    g_main_loop_run(loop);

    // clean up
    g_print("Returned, stopping playback\n");
    gst_element_set_state(pipeline, GST_STATE_NULL);
    g_print("Deleting pipeline\n");

    gst_object_unref(GST_OBJECT(pipeline));

    return 0;
}