static gboolean
create_nodes (GstBin * bin, GstElement * sink, gint depth, gint children,
gint flavour)
{
GstElement *new_sink, *src;
gint i;
for (i = 0; i < children; i++) {
if (depth > 0) {
if (!create_node (bin, sink, sink_pads[flavour][ELEM_MIX], &new_sink,
children, flavour)) {
return FALSE;
}
if (!create_nodes (bin, new_sink, depth - 1, children, flavour)) {
return FALSE;
}
} else {
src = gst_element_factory_make (factories[flavour][ELEM_SRC], NULL);
if (!src) {
GST_WARNING ("need element '%s'", factories[flavour][ELEM_SRC]);
return FALSE;
}
gst_bin_add (bin, src);
if (!gst_element_link_pads_full (src, "src", sink,
sink_pads[flavour][ELEM_MIX], GST_PAD_LINK_CHECK_NOTHING)) {
GST_WARNING ("can't link elements");
return FALSE;
}
}
}
return TRUE;
}
// ---------------------------------------------------------------------------
// Common call
// ------------
void bXMapNetClean::process_network(netcleanact_prm* prm,
int* fields,
bArray& nodes,
bArray& edges){
_bTrace_("bXMapNetClean::process_network(netcleanact_prm,int*,bArray&,bArray&)",true);
if(_cfg_prm.tnod==NULL){
_te_("(_cfg_prm.tnod==NULL)");
return;
}
if( (_cfg_prm.tbdg==_cfg_prm.tnod) &&
(_cfg_prm.stbdg==_cfg_prm.stnod) ){
_cfg_prm.tbdg=NULL;
}
if( (_cfg_prm.stnod<1) ||
(_cfg_prm.stnod>_cfg_prm.tnod->fields()->count_constraints(kOBJ_SubType_)) ){
if( (_cfg_prm.tbdg) &&
(_cfg_prm.stbdg==1) ){
_te_("(_cfg_prm.tbdg)&&(_cfg_prm.stbdg==1)");
return;
}
_cfg_prm.stnod=1;
}
/*
Inval et Draw pour provoquer un reset des styles
Puis StopDraw derrière pour empécher le dessin
Ceci pour régler le cas ou on supprime un objet
dans la fonction précédente, qui va rester dans les
index des styles et qui sera effacé définitivement
par la déclaration du eventlog du nettoyage automatique
*/
_gapp->mapIntf()->inval();
_gapp->mapIntf()->draw();
_gapp->layersMgr()->StopDraw();
/**/
_gapp->layersMgr()->SetObjInvalidation(false);
if(prm->create_nodes){
(void)create_nodes(edges,nodes,fields,prm->check_nodes);
if(prm->cut_edges){
(void)cut_edges(nodes,edges,fields,prm->check_edges);
}
}
if(prm->join_on_nodes){
(void)join_on_nodes(edges,fields,prm->check_edges);
}
else if(prm->join_on_edges){
(void)join_on_edges(nodes,fields,prm->check_nodes);
}
if(prm->check_nodes){
(void)check_nodes(nodes,fields);
}
if(prm->check_edges){
(void)check_edges(edges,fields);
}
_gapp->layersMgr()->SetObjInvalidation(true);
}
int main(void)
{
/* Declare YOUR variables here ! */
BiTree mytree;
int menu_choice;
srand((unsigned int)time(NULL));
if ((mytree = BITREEinit(my_destroy)) == NULL)
{
printf("\nFatal error - bailing out...\n!");
BITREEdestroy(mytree);
exit(-1);
}
/* Don't forget to set the compare callback..! */
BITREEsetcompare(mytree, my_cmp);
/* Initialize - and add nodes to the table... */
create_nodes(mytree, NR_OF_ITEMS);
do
{
menu_choice = menu(MAIN_MENU_ROW, 0, 4);
switch (menu_choice)
{
case 1:
ins_node(mytree);
break;
case 2:
rem_node(mytree);
break;
case 3:
search_node(mytree);
break;
case 4:
my_clearscrn();
printf("--- PRINT TREE ---\n");
print_tree(mytree);
prompt_and_pause("\n\n");
break;
default:
final_status(mytree);
break;
}
}
while (menu_choice);
prompt_and_pause("\n\nLet's tidy up and destroy the tree..- Bye!");
BITREEdestroy(mytree);
return 0;
}
/*--------------------------------------------------------- */
static void
test_performance(void)
{
lub_heap_t *heap;
lub_test_seq_begin(++testseq,"Check the performance...");
heap = lub_heap_create(large_seg,sizeof(large_seg));
lub_test_check(NULL != heap,"Check creation of 400KB heap");
create_nodes(heap,1000);
lub_test_seq_log(LUB_TEST_NORMAL,"Now free every other node...");
{
test_node_t **ptr;
int i = 0;
for(ptr = &first_node;
*ptr;
i++,ptr = &(*ptr)->next)
{
if(i % 2)
{
char *tmp = (char*)*ptr;
/* remove from the linked list */
*ptr = (*ptr)->next;
/* and free the node */
lub_heap_realloc(heap,&tmp,0,LUB_HEAP_ALIGN_NATIVE);
}
}
}
lub_test_seq_log(LUB_TEST_NORMAL,"Dump the details...");
lub_heap_show(heap,BOOL_TRUE);
create_nodes(heap,500);
lub_heap_destroy(heap);
lub_test_seq_end();
}
gint
main (gint argc, gchar * argv[])
{
GstBin *bin;
GstClockTime start, end;
GstElement *sink, *new_sink;
/* default parameters */
gint depth = 4;
gint children = 3;
gint flavour = FLAVOUR_AUDIO;
const gchar *flavour_str = "audio";
gst_init (&argc, &argv);
/* check command line options */
if (argc) {
gint arg;
for (arg = 0; arg < argc; arg++) {
if (!strcmp (argv[arg], "-d")) {
arg++;
if (arg < argc)
depth = atoi (argv[arg]);
} else if (!strcmp (argv[arg], "-c")) {
arg++;
if (arg < argc)
children = atoi (argv[arg]);
} else if (!strcmp (argv[arg], "-f")) {
arg++;
if (arg < argc) {
flavour_str = argv[arg];
switch (*flavour_str) {
case 'a':
flavour = FLAVOUR_AUDIO;
break;
case 'v':
flavour = FLAVOUR_VIDEO;
break;
default:
break;
}
}
}
}
}
/* build pipeline */
g_print ("building %s pipeline with depth = %d and children = %d\n",
flavour_str, depth, children);
start = gst_util_get_timestamp ();
bin = GST_BIN (gst_pipeline_new ("pipeline"));
sink = gst_element_factory_make ("fakesink", NULL);
gst_bin_add (bin, sink);
if (!create_node (bin, sink, "sink", &new_sink, children, flavour)) {
goto Error;
}
if (!create_nodes (bin, new_sink, depth, children, flavour)) {
goto Error;
}
end = gst_util_get_timestamp ();
/* num-threads = num-sources = pow (children, depth) */
g_print ("%" GST_TIME_FORMAT " built pipeline with %d elements\n",
GST_TIME_ARGS (end - start), GST_BIN_NUMCHILDREN (bin));
/* meassure */
g_print ("starting pipeline\n");
gst_element_set_state (GST_ELEMENT (bin), GST_STATE_READY);
GST_DEBUG_BIN_TO_DOT_FILE (bin, GST_DEBUG_GRAPH_SHOW_MEDIA_TYPE, "capsnego");
start = gst_util_get_timestamp ();
gst_element_set_state (GST_ELEMENT (bin), GST_STATE_PAUSED);
event_loop (GST_ELEMENT (bin), start);
end = gst_util_get_timestamp ();
g_print ("%" GST_TIME_FORMAT " reached paused\n",
GST_TIME_ARGS (end - start));
/* clean up */
Error:
gst_element_set_state (GST_ELEMENT (bin), GST_STATE_NULL);
gst_object_unref (bin);
return 0;
}
