Images Diaporama dans Gstreamer

Question

Je souhaite créer une application GStreamer qui prend en charge un fichier xml dont le contenu fournit des informations telles que l'URL de l'image, son poids et la durée pendant laquelle elle va s'afficher à l'écran.

Le fichier XML peut être clairement traité en C en utilisant libxml. Mais comment pouvons-nous créer un diaporama des images en utilisant les bibliothèques GStreamer. Je souhaite utiliser GStreamer car le matériel et le SDK que j'utilise fournissent un support natif pour GStreamer.

Y a-t-il des plugins GStreamer pour faire de même? Ou comment peut-on faire autrement. Je connais les bases de GStreamer et je peux écrire du code en C pour l'application GStreamer.

Answer 1

Essayez la pièce suivante de code de C:

#include <gst/gst.h> 
#include <glib.h> 

char *strcpy(char *dest, const xmlChar *src) 
{ 
    unsigned i; 
    for (i=0; src[i] != '\0'; ++i) 
    dest[i] = src[i]; 
     dest[i] = '\0'; 
    return dest; 
} 


int main (int argc, char *argv[]) 

{ 
char *docname; 
char *image1 = malloc(1000); 
char *image2 = malloc(1000); 

docname = "input.xml"; 

//parse the document 
xmlDocPtr doc; 
xmlNodePtr cur1, cur2, cur3; 

doc = xmlParseFile(docname); 

if (doc == NULL) { 
    fprintf(stderr,"Document not parsed successfully. \n"); 
    return -1; 
} 

cur1 = xmlDocGetRootElement(doc); 

if (cur1 == NULL) { 
    fprintf(stderr,"Empty Document\n"); 
    xmlFreeDoc(doc); 
    return -1; 
} 

if (xmlStrcmp(cur1->name, (const xmlChar *) "start")) { 
    fprintf(stderr,"document of the wrong type, root node is supposed to be start"); 
    xmlFreeDoc(doc); 
    return -1; 
} 

int flag=0; 
cur2 = cur1->xmlChildrenNode; 
while (cur2 != NULL) 
{ 
    if ((!xmlStrcmp(cur2->name, (const xmlChar *)"image"))) 
    { 
     //parseVideo (doc, cur2); 
     xmlChar *key; 
     cur3 = cur2->xmlChildrenNode; 
     while (cur3 != NULL) 
     { 
      if ((!xmlStrcmp(cur3->name, (const xmlChar *)"filename"))) 
      { 
       key = xmlNodeListGetString(doc, cur3->xmlChildrenNode, 1); 
       //printf("Name of the file is: %s\n", key); 
       xmlFree(key); 
      } 

      if ((!xmlStrcmp(cur3->name, (const xmlChar *)"src"))) 
      { 
       key = xmlNodeListGetString(doc, cur3->xmlChildrenNode, 1); 
       if (flag == 1) 
       { 
         strcpy(image2, key); 
         printf("the image 2 is %s \n", image2); 
         flag = 2; 
       } 
       if(flag == 0) 
       { 
         strcpy(image1, key); 
         printf("the image 1 is %s \n", image1); 
         flag = 1; 
       } 
        //printf("SRC of the file is: %s\n", key); 
       xmlFree(key); 
      } 

      if ((!xmlStrcmp(cur3->name, (const xmlChar *)"duration"))) 
      { 
       key = xmlNodeListGetString(doc, cur3->xmlChildrenNode, 1); 
       //printf("No. of seconds the image should be displayed is: %s\n", key); 
       xmlFree(key); 
      } 

      if ((!xmlStrcmp(cur3->name, (const xmlChar *)"weight"))) 
      { 
       key = xmlNodeListGetString(doc, cur3->xmlChildrenNode, 1); 
       //printf("The weight of the image is: %s\n", key); 
       xmlFree(key); 
      } 
     cur3 = cur3->next; 
     } 
    } 
cur2 = cur2->next; 
} 

xmlFreeDoc(doc); 

GstElement *pipeline, *source, *jpg_decoder, *freeze, *colorspace, *sink; 

    /* Initialisation */ 
gst_init (&argc, &argv); 

/* Create gstreamer elements */ 
pipeline = gst_pipeline_new ("image-player"); 
if(!pipeline) 
{ 
    g_printerr ("Pipeline could not be created. Exiting.\n"); 
    return -1; 
} 

    source = gst_element_factory_make ("filesrc",  "file-source"); 
    //set the location of the file to the argv[1] 
    g_object_set (G_OBJECT (source), "location", image1, NULL); 
if(!source) 
{ 
    g_printerr ("File could not be created. Exiting.\n"); 
    return -1; 
} 

jpg_decoder = gst_element_factory_make ("jpegdec", "jpg-decoder"); 
if(!jpg_decoder) 
{ 
    g_printerr ("Jpg Decoder could not be created. Exiting.\n"); 
    return -1; 
} 

freeze = gst_element_factory_make("imagefreeze", "freeze"); 
if(!freeze) 
{ 
    g_printerr ("ImageFreeze could not be created. Exiting.\n"); 
    return -1; 
} 

colorspace = gst_element_factory_make("ffmpegcolorspace", "colorspace"); 
if(!colorspace) 
{ 
    g_printerr ("Colorspace could not be created. Exiting.\n"); 
    return -1; 
} 

sink  = gst_element_factory_make ("ximagesink", "imagesink"); 
if(!sink) 
{ 
    g_printerr ("Image sink could not be created. Exiting.\n"); 
    return -1; 
} 

/* file-source | jpg-decoder | image-freeze | colorspace | sink */ 
gst_bin_add_many (GST_BIN (pipeline), source, jpg_decoder, freeze, colorspace, sink, NULL); 
gst_element_link_many (source, jpg_decoder, freeze, colorspace, sink, NULL); 

/* Set the pipeline to "playing" state*/ 
g_print ("Now playing: %s\n", image1); 
gst_element_set_state (pipeline, GST_STATE_PLAYING); 

getchar(); 
gst_element_set_state (pipeline, GST_STATE_READY); 
g_object_set (G_OBJECT (source), "location", image2, NULL); 
gst_element_set_state (pipeline, GST_STATE_PLAYING); 
getchar(); 

/* Out of the main loop, clean up nicely */ 
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; 
} 

Answer 2

Vous devez créer un pipeline avec un élément imagefreeze et modifier l'emplacement de la source lorsque l'image doit être modifiée.

Un exemple d'application (en Python) qui montre deux images fixes du disque dur:

import pygst 
pygst.require("0.10") 
import gst 

player = gst.Pipeline("player") 
source = gst.element_factory_make("filesrc", "file-source") 
source.set_property("location", "image1.jpeg") 
jpg_decoder = gst.element_factory_make("jpegdec", "jpg-decoder") 
freeze = gst.element_factory_make("imagefreeze", "freeze") 
colorspace = gst.element_factory_make("ffmpegcolorspace", "colorspace") 
sink = gst.element_factory_make("ximagesink", "imagesink") 

player.add(source, jpg_decoder, freeze, colorspace, sink) 
gst.element_link_many(source, jpg_decoder, freeze, colorspace, sink) 
player.set_state(gst.STATE_PLAYING) 

inp = raw_input("Press enter:") 
player.set_state(gst.STATE_READY) 
source.set_property("location", "image2.jpeg") 
player.set_state(gst.STATE_PLAYING) 
inp = raw_input("Press enter again:")