Esempio n. 1
0
static void
send_5app_1el_1err_2app_messages (guint interval_usecs)
{
  GstMessage *m;
  GstStructure *s;
  gint i;

  for (i = 0; i < 5; i++) {
    s = gst_structure_new ("test_message", "msg_id", G_TYPE_INT, i, NULL);
    m = gst_message_new_application (NULL, s);
    GST_LOG ("posting application message");
    gst_bus_post (test_bus, m);
    g_usleep (interval_usecs);
  }
  for (i = 0; i < 1; i++) {
    s = gst_structure_new ("test_message", "msg_id", G_TYPE_INT, i, NULL);
    m = gst_message_new_element (NULL, s);
    GST_LOG ("posting element message");
    gst_bus_post (test_bus, m);
    g_usleep (interval_usecs);
  }
  for (i = 0; i < 1; i++) {
    m = gst_message_new_error (NULL, NULL, "debug string");
    GST_LOG ("posting error message");
    gst_bus_post (test_bus, m);
    g_usleep (interval_usecs);
  }
  for (i = 0; i < 2; i++) {
    s = gst_structure_new ("test_message", "msg_id", G_TYPE_INT, i, NULL);
    m = gst_message_new_application (NULL, s);
    GST_LOG ("posting application message");
    gst_bus_post (test_bus, m);
    g_usleep (interval_usecs);
  }
}
Esempio n. 2
0
static VALUE
application_initialize(VALUE self, VALUE src, VALUE structure)
{
    G_INITIALIZE(self, gst_message_new_application(RVAL2GST_OBJ(src),
                                                   RVAL2GST_STRUCT(structure)));
    return Qnil;
}
/* This function is called when new metadata is discovered in the stream */
static void tags_cb (GstElement *playbin, gint stream, CustomData *data) {
  /* We are possibly in a GStreamer working thread, so we notify the main
   * thread of this event through a message in the bus */
  gst_element_post_message (playbin,
    gst_message_new_application (GST_OBJECT (playbin),
      gst_structure_new_empty ("tags-changed")));
}
Esempio n. 4
0
static gboolean buffer_probe_callback(
		GstElement *image_sink,
		GstBuffer *buffer, GstPad *pad)
{
	GstMessage *message;
	gchar *message_name;

	unsigned char *data_photo = (unsigned char *) GST_BUFFER_DATA(buffer);

	if(!create_jpeg(data_photo)) {
		message_name = "photo-failed";
		hildon_banner_show_information(GTK_WIDGET(cappdata->window),
				NULL, "Unable To Take Photo");
	} else {
		message_name = "photo-taken";
	}

	g_signal_handler_disconnect(G_OBJECT(image_sink),
			cappdata->buffer_cb_id);

	message = gst_message_new_application(GST_OBJECT(cappdata->pipeline),
			gst_structure_new(message_name, NULL));
	gst_element_post_message(cappdata->pipeline, message);

	return TRUE;
}
Esempio n. 5
0
/**
 * send_underrun_message
 *
 * Sends UNDERRUN message to the bus.
 */
static void send_underrun_message(ProgressBuffer* element)
{
    GstStructure *s = gst_structure_new_empty(PB_MESSAGE_UNDERRUN);
    GstMessage *msg = gst_message_new_application(GST_OBJECT(element), s);

    gst_element_post_message(GST_ELEMENT(element), msg);
}
Esempio n. 6
0
static void
send_10_app_messages (void)
{
  GstMessage *m;
  GstStructure *s;
  gint i;

  for (i = 0; i < 10; i++) {
    s = gst_structure_new ("test_message", "msg_id", G_TYPE_INT, i, NULL);
    m = gst_message_new_application (NULL, s);
    gst_bus_post (test_bus, m);
  }
}
Esempio n. 7
0
GstPadProbeReturn
eos_event_cb (GstPad *pad, GstPadProbeInfo *info, gpointer data)
{
  if (GST_EVENT_TYPE (GST_PAD_PROBE_INFO_DATA (info)) == GST_EVENT_EOS)
  {
    GstElement *bin = NULL;
    GstMessage *message = NULL;
    GstStructure *msg_struct = NULL;
    MbMedia *media;
    gchar *uri = NULL;
    int pads = 0;

    media = (MbMedia *) data;

    bin = gst_bin_get_by_name (GST_BIN(_mb_global_data.pipeline), media->name);
    g_assert(bin);

    g_mutex_lock (&(media->mutex));
    pads = --media->valid_pads;
    g_mutex_unlock (&(media->mutex));

    g_object_get (media->decoder, "uri", &uri, NULL);
    g_debug ("EOS received (%s): %s.\n", media->name, uri);
    g_debug ("%s still has %d valid pad(s).\n", media->name, pads);

    if (pads == 0)
    {
      MbEvent *event = create_state_change_event (MB_END, media->name);
      notify_handler (event);
      free (event);
      
      g_hash_table_remove (_mb_global_data.media_table, media->name);
      
      msg_struct = gst_structure_new ("end-media", "event_type", G_TYPE_INT,
          APP_EVT_MEDIA_END, "data", G_TYPE_POINTER,
          media,
          /* FILL ME IF NECESSARY */
          NULL);

      message = gst_message_new_application (GST_OBJECT(bin), msg_struct);
      g_debug ("Posting event\n");
      gst_bus_post (_mb_global_data.bus, message);
    }
    g_free (uri);
  }
  return GST_PAD_PROBE_OK;
}
Esempio n. 8
0
static gpointer
pound_bus_with_messages (gpointer data)
{
  gint thread_id = GPOINTER_TO_INT (data);
  gint i;

  for (i = 0; i < NUM_MESSAGES; i++) {
    GstMessage *m;
    GstStructure *s;

    s = gst_structure_new ("test_message",
        "thread_id", G_TYPE_INT, thread_id, "msg_id", G_TYPE_INT, i, NULL);
    m = gst_message_new_application (NULL, s);
    gst_bus_post (test_bus, m);
  }
  return NULL;
}
Esempio n. 9
0
static gboolean
send_messages (gpointer data)
{
  GstMessage *m;
  GstStructure *s;
  gint i;

  for (i = 0; i < 10; i++) {
    s = gst_structure_new ("test_message", "msg_id", G_TYPE_INT, i, NULL);
    m = gst_message_new_application (NULL, s);
    gst_bus_post (test_bus, m);
    s = gst_structure_new ("test_message", "msg_id", G_TYPE_INT, i, NULL);
    m = gst_message_new_custom (GST_MESSAGE_EOS, NULL, s);
    gst_bus_post (test_bus, m);
  }

  return FALSE;
}
Esempio n. 10
0
static GstFlowReturn
gst_nekobus_show_frame (GstBaseSink * sink, GstBuffer * buf)
{
  GstNekoBus *element;
  element = GST_NEKOBUS (sink);
	
	GstStructure *msg = gst_structure_new("nekobus::data",
		"element", G_TYPE_STRING, gst_element_get_name( GST_ELEMENT(element) ),
		"buffer", GST_TYPE_BUFFER, buf,
		NULL );
	gst_bus_post( gst_element_get_bus(GST_ELEMENT(sink)),
		gst_message_new_application( GST_OBJECT(sink), msg ) );

	/* we're leaving the buffer unref'ing to the bus receiver :/ 
	 -- what if noone receives the msg? FIXME */
	
  return GST_FLOW_OK;
}
Esempio n. 11
0
/* is called every 50 milliseconds (20 times a second), the interrupt handler
 * will set a flag for us. We react to this by posting a message. */
static gboolean
check_intr (GstElement * pipeline)
{
  if (!caught_intr) {
    return TRUE;
  } else {
    caught_intr = FALSE;
    g_print ("handling interrupt.\n");

    /* post an application specific message */
    gst_element_post_message (GST_ELEMENT (pipeline),
        gst_message_new_application (GST_OBJECT (pipeline),
            gst_structure_new ("GstLaunchInterrupt",
                "message", G_TYPE_STRING, "Pipeline interrupted", NULL)));

    /* remove timeout handler */
    return FALSE;
  }
}
Esempio n. 12
0
static void
dec_counter (GstPlayRegion *PlayRegion)
{

  if (PlayRegion->prerolled)
    return;

  if (g_atomic_int_dec_and_test (&PlayRegion->counter)) {
    /* all probes blocked and no-more-pads signaled, post
     * message on the bus. */
	PlayRegion->prerolled = TRUE;

	g_print ("fire application message\n");

    gst_bus_post (PlayRegion->bus, gst_message_new_application (
          GST_OBJECT_CAST (PlayRegion->pipeline),
          gst_structure_new_empty ("ExPrerolled")));
  }
}
Esempio n. 13
0
/**
 * send_position_message
 * Sends application message on the BUS with the following parameters:
 *  - structure name is the constant defined as PB_MESSAGE_BUFFERING
 *  - "start" as gint64 is the start position of the current buffer
 *  - "position" as gint64 is current position up to which data has been read from the source
 *  - "stop" as gint64 is the duration of the current segment, usually equals to the whole duration
 *
 * gboolean "mandatory" flag desribes whether the message must be sent anyways.
 * If it's TRUE message is aways sent, otherwise if it's FALSE the function tries to
 * avoid sending messages every time - it sends messages every percent of the whole size.
 */
static gboolean send_position_message(ProgressBuffer *element, gboolean mandatory)
{
    gdouble percent = (double)element->sink_segment.position/element->sink_segment.stop * 100;
    mandatory |= (percent - element->last_update) > element->threshold; // Prevent sending update messages to often

    if (mandatory)
    {
        GstStructure *s = gst_structure_new(PB_MESSAGE_BUFFERING,
                                            "start", G_TYPE_INT64, element->sink_segment.start,
                                            "position", G_TYPE_INT64, element->sink_segment.position,
                                            "stop", G_TYPE_INT64, element->sink_segment.stop,
                                            "eos", G_TYPE_BOOLEAN, element->eos_status.eos,
                                            NULL);
        GstMessage *msg = gst_message_new_application(GST_OBJECT(element), s);

        gst_element_post_message(GST_ELEMENT(element), msg);
        element->last_update = percent;
    }
    return mandatory;
}
Esempio n. 14
0
ApplicationMessagePtr ApplicationMessage::create(const ObjectPtr & source, const Structure & structure)
{
    GstStructure *s = structure.isValid() ? gst_structure_copy(structure) : NULL;
    return ApplicationMessagePtr::wrap(gst_message_new_application(source, s), false);
}
Esempio n. 15
0
gpointer upload_file (gpointer data) {
    
    int err;
    void* output;
    
    // Application key and secret. To get them, create an app here:
    // https://www.dropbox.com/developers/apps
    char *c_key    = "lmg4kv8jw45nlsr";  //< consumer key
    char *c_secret = "xmq9x391l0y8nwy";  //< consumer secret
    char filename[200];
    CustomData *cdata=(CustomData*)data;
    strcpy(filename,cdata->sink_filename);
    
    // User key and secret. Leave them NULL or set them with your AccessToken.
   // char *t_key    = NULL; //< access token key
   // char *t_secret = NULL;  //< access token secret
     char *t_key    = "5j55oq1lf8h1zi2w"; //< access token key
     char *t_secret = "nvv5ps3hy4v4wy3";  //< access token secret
    
    // Global initialisation
    drbInit();
    
    // Create a Dropbox client
    drbClient* cli = drbCreateClient(c_key, c_secret, t_key, t_secret);
    
    // Request a AccessToken if undefined (NULL)
    if(!t_key || !t_secret) {
        drbOAuthToken* reqTok = drbObtainRequestToken(cli);
        
        if (reqTok) {
            char* url = drbBuildAuthorizeUrl(reqTok);
            printf("Please visit %s\nThen press Enter...\n", url);
            free(url);
            fgetc(stdin);
            
            drbOAuthToken* accTok = drbObtainAccessToken(cli);
            
            if (accTok) {
                // This key and secret can replace the NULL value in t_key and
                // t_secret for the next time.
                printf("key:    %s\nsecret: %s\n", accTok->key, accTok->secret);
            } else{
                fprintf(stderr, "Failed to obtain an AccessToken...\n");
                return NULL;
            }
        } else {
            fprintf(stderr, "Failed to obtain a RequestToken...\n");
            return NULL;
        }
    }
    
    // Set default arguments to not repeat them on each API call
    drbSetDefault(cli, DRBOPT_ROOT, DRBVAL_ROOT_AUTO, DRBOPT_END);
    

    // upload current file
   
    FILE *file = fopen(filename, "r");
    char fn[200];
    memset(fn,0,sizeof(fn));
    strcpy(fn,"/");
    strcat(fn,filename);
	output = NULL;	
        err = drbPutFile(cli, &output,
                         DRBOPT_PATH, fn,
                         DRBOPT_IO_DATA, file,
                         DRBOPT_IO_FUNC, fread,
                         DRBOPT_END);
        printf("File upload: %s\n", err ? "Failed" : "Successful");
    
   fclose(file); 
    

   output = NULL; 

    //share public link to file
	drbShare(cli, &output,
					DRBOPT_PATH, fn,
					DRBOPT_END);
	drbLink* url = (drbLink*)output;
//	strcpy(link,url->url);  We should return here!!!!
 
    drbDestroyClient(cli);
    
    // Global Cleanup
    drbCleanup();
    gst_bus_post(cdata->bus,gst_message_new_application(
        GST_OBJECT_CAST(cdata->pipeline),
        gst_structure_new_empty("UploadDone")));
    return url->url;
}
/**
 * send_hls_not_full_message
 *
 * Sends HLS NOT FULL message to the bus.
 */
static void send_hls_not_full_message(HLSProgressBuffer* element)
{
    GstStructure *s = gst_structure_empty_new(HLS_PB_MESSAGE_NOT_FULL);
    GstMessage *msg = gst_message_new_application(GST_OBJECT(element), s);
    gst_element_post_message(GST_ELEMENT(element), msg);
}