static gboolean gst_fake_src_event_handler (GstBaseSrc * basesrc, GstEvent * event) { GstFakeSrc *src; src = GST_FAKE_SRC (basesrc); if (!src->silent) { const GstStructure *s; gchar *sstr; GST_OBJECT_LOCK (src); g_free (src->last_message); if ((s = gst_event_get_structure (event))) sstr = gst_structure_to_string (s); else sstr = g_strdup (""); src->last_message = g_strdup_printf ("event ******* E (type: %d, %s) %p", GST_EVENT_TYPE (event), sstr, event); g_free (sstr); GST_OBJECT_UNLOCK (src); g_object_notify (G_OBJECT (src), "last_message"); } return GST_BASE_SRC_CLASS (parent_class)->event (basesrc, event); }
/** * gst_navigation_event_get_type: * @event: A #GstEvent to inspect. * * Inspect a #GstEvent and return the #GstNavigationEventType of the event, or * #GST_NAVIGATION_EVENT_INVALID if the event is not a #GstNavigation event. */ GstNavigationEventType gst_navigation_event_get_type (GstEvent * event) { const GstStructure *s; const gchar *e_type; if (event == NULL || GST_EVENT_TYPE (event) != GST_EVENT_NAVIGATION) return GST_NAVIGATION_EVENT_INVALID; s = gst_event_get_structure (event); if (s == NULL || !gst_structure_has_name (s, GST_NAVIGATION_EVENT_NAME)) return GST_NAVIGATION_EVENT_INVALID; e_type = gst_structure_get_string (s, "event"); if (e_type == NULL) return GST_NAVIGATION_EVENT_INVALID; if (g_str_equal (e_type, "mouse-button-press")) return GST_NAVIGATION_EVENT_MOUSE_BUTTON_PRESS; else if (g_str_equal (e_type, "mouse-button-release")) return GST_NAVIGATION_EVENT_MOUSE_BUTTON_RELEASE; else if (g_str_equal (e_type, "mouse-move")) return GST_NAVIGATION_EVENT_MOUSE_MOVE; else if (g_str_equal (e_type, "key-press")) return GST_NAVIGATION_EVENT_KEY_PRESS; else if (g_str_equal (e_type, "key-release")) return GST_NAVIGATION_EVENT_KEY_RELEASE; else if (g_str_equal (e_type, "command")) return GST_NAVIGATION_EVENT_COMMAND; return GST_NAVIGATION_EVENT_INVALID; }
static GstPadProbeReturn depay_event_probe_cb (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) { rtp_pipeline *p = (rtp_pipeline *) user_data; GstEvent *event = GST_PAD_PROBE_INFO_DATA (info); if (GST_EVENT_TYPE (event) == GST_EVENT_CUSTOM_DOWNSTREAM) { const GstStructure *s0 = gst_event_get_structure (p->custom_event); const GstStructure *s1 = gst_event_get_structure (event); if (gst_structure_is_equal (s0, s1)) { gst_event_unref (p->custom_event); p->custom_event = NULL; } } return GST_PAD_PROBE_OK; }
static gboolean webkitMediaPlayReadyDecryptSinkEventHandler(GstBaseTransform* trans, GstEvent* event) { gboolean result = FALSE; WebKitMediaPlayReadyDecrypt* self = WEBKIT_MEDIA_PLAYREADY_DECRYPT(trans); switch (GST_EVENT_TYPE(event)) { case GST_EVENT_PROTECTION: { const gchar* systemId; const gchar* origin; GstBuffer* initdatabuffer; GST_INFO_OBJECT(self, "received protection event"); gst_event_parse_protection(event, &systemId, &initdatabuffer, &origin); GST_DEBUG_OBJECT(self, "systemId: %s", systemId); // Ignore protection events about content we cannot handle. if (!g_str_equal(systemId, PLAYREADY_PROTECTION_SYSTEM_ID)) { gst_event_unref(event); result = TRUE; break; } // Keep the event ref around so that the parsed event data // remains valid until the drm-key-need message has been sent. self->protectionEvent = event; self->initDataBuffer = initdatabuffer; g_timeout_add(0, requestKey, self); result = TRUE; break; } case GST_EVENT_CUSTOM_DOWNSTREAM_OOB: { GST_INFO_OBJECT(self, "received OOB event"); g_mutex_lock(&self->mutex); const GstStructure* structure = gst_event_get_structure(event); if (gst_structure_has_name(structure, "dxdrm-session")) { GST_INFO_OBJECT(self, "received dxdrm session"); const GValue* value = gst_structure_get_value(structure, "session"); self->sessionMetaData = reinterpret_cast<WebCore::DiscretixSession*>(g_value_get_pointer(value)); self->streamReceived = TRUE; g_cond_signal(&self->condition); } g_mutex_unlock(&self->mutex); gst_event_unref(event); result = TRUE; break; } default: result = GST_BASE_TRANSFORM_CLASS(parent_class)->sink_event(trans, event); break; } return result; }
/** * gst_video_event_parse_downstream_force_key_unit: * @event: A #GstEvent to parse * @timestamp: (out): A pointer to the timestamp in the event * @stream_time: (out): A pointer to the stream-time in the event * @running_time: (out): A pointer to the running-time in the event * @all_headers: (out): A pointer to the all_headers flag in the event * @count: (out): A pointer to the count field of the event * * Get timestamp, stream-time, running-time, all-headers and count in the force * key unit event. See gst_video_event_new_downstream_force_key_unit() for a * full description of the downstream force key unit event. * * @running_time will be adjusted for any pad offsets of pads it was passing through. * * Returns: %TRUE if the event is a valid downstream force key unit event. */ gboolean gst_video_event_parse_downstream_force_key_unit (GstEvent * event, GstClockTime * timestamp, GstClockTime * stream_time, GstClockTime * running_time, gboolean * all_headers, guint * count) { const GstStructure *s; GstClockTime ev_timestamp, ev_stream_time, ev_running_time; gboolean ev_all_headers; guint ev_count; g_return_val_if_fail (event != NULL, FALSE); if (GST_EVENT_TYPE (event) != GST_EVENT_CUSTOM_DOWNSTREAM) return FALSE; /* Not a force key unit event */ s = gst_event_get_structure (event); if (s == NULL || !gst_structure_has_name (s, GST_VIDEO_EVENT_FORCE_KEY_UNIT_NAME)) return FALSE; if (!gst_structure_get_clock_time (s, "timestamp", &ev_timestamp)) ev_timestamp = GST_CLOCK_TIME_NONE; if (!gst_structure_get_clock_time (s, "stream-time", &ev_stream_time)) ev_stream_time = GST_CLOCK_TIME_NONE; if (!gst_structure_get_clock_time (s, "running-time", &ev_running_time)) ev_running_time = GST_CLOCK_TIME_NONE; if (!gst_structure_get_boolean (s, "all-headers", &ev_all_headers)) ev_all_headers = FALSE; if (!gst_structure_get_uint (s, "count", &ev_count)) ev_count = 0; if (timestamp) *timestamp = ev_timestamp; if (stream_time) *stream_time = ev_stream_time; if (running_time) { gint64 offset = gst_event_get_running_time_offset (event); *running_time = ev_running_time; /* Catch underflows */ if (*running_time > -offset) *running_time += offset; else *running_time = 0; } if (all_headers) *all_headers = ev_all_headers; if (count) *count = ev_count; return TRUE; }
/** * Helper function to determine if a received event is a reverse-eol event. */ gboolean gst_goo_event_is_reverse_eos (GstEvent *evt) { const GstStructure *structure = gst_event_get_structure (evt); if (structure) { return strcmp (gst_structure_get_name (structure), "GstGooReverseEosEvent") == 0; } return FALSE; }
// callbacks static gboolean events_cb(GstPad *pad, GstEvent *event, gpointer user_data) { GstHaarAdjust *filter; const GstStructure *structure; filter = GST_HAARADJUST(user_data); // sanity checks g_return_val_if_fail(pad != NULL, FALSE); g_return_val_if_fail(event != NULL, FALSE); g_return_val_if_fail(filter != NULL, FALSE); structure = gst_event_get_structure(event); if ((structure != NULL) && (strcmp(gst_structure_get_name(structure), "haar-detect-roi") == 0)) { CvRect rect; GstClockTime timestamp; gst_structure_get((GstStructure*) structure, "x", G_TYPE_UINT, &rect.x, "y", G_TYPE_UINT, &rect.y, "width", G_TYPE_UINT, &rect.width, "height", G_TYPE_UINT, &rect.height, "timestamp", G_TYPE_UINT64, ×tamp, NULL); if (timestamp > filter->rect_timestamp) { filter->rect_timestamp = timestamp; g_array_free(filter->rect_array, TRUE); filter->rect_array = g_array_sized_new(FALSE, FALSE, sizeof(CvRect), 1); } g_array_append_val(filter->rect_array, rect); } if ((structure != NULL) && (strcmp(gst_structure_get_name(structure), "bgfg-roi") == 0)) { CvRect rect; GstClockTime timestamp; gst_structure_get((GstStructure*) structure, "x", G_TYPE_UINT, &rect.x, "y", G_TYPE_UINT, &rect.y, "width", G_TYPE_UINT, &rect.width, "height", G_TYPE_UINT, &rect.height, "timestamp", G_TYPE_UINT64, ×tamp, NULL); if (timestamp > filter->rect_bg_timestamp) { filter->rect_bg_timestamp = timestamp; g_array_free(filter->rect_bg_array, TRUE); filter->rect_bg_array = g_array_sized_new(FALSE, FALSE, sizeof(CvRect), 1); } g_array_append_val(filter->rect_bg_array, rect); } return TRUE; }
static void calculate_latency (GstElement * parent, GstPad * pad, guint64 ts) { if (parent && (!GST_IS_BIN (parent)) && GST_OBJECT_FLAG_IS_SET (parent, GST_ELEMENT_FLAG_SINK)) { GstEvent *ev = g_object_get_qdata ((GObject *) pad, latency_probe_id); log_latency (gst_event_get_structure (ev), pad, ts); gst_event_unref (ev); } }
static gboolean gst_imx_blitter_video_transform_src_event(GstBaseTransform *transform, GstEvent *event) { gdouble a; GstStructure *structure; GstImxBlitterVideoTransform *blitter_video_transform = GST_IMX_BLITTER_VIDEO_TRANSFORM(transform); GST_DEBUG_OBJECT(transform, "handling %s event", GST_EVENT_TYPE_NAME(event)); switch (GST_EVENT_TYPE(event)) { case GST_EVENT_NAVIGATION: { /* scale pointer_x/y values in the event if in- and output have different width/height */ gint in_w = GST_VIDEO_INFO_WIDTH(&(blitter_video_transform->input_video_info)); gint in_h = GST_VIDEO_INFO_HEIGHT(&(blitter_video_transform->input_video_info)); gint out_w = GST_VIDEO_INFO_WIDTH(&(blitter_video_transform->output_video_info)); gint out_h = GST_VIDEO_INFO_HEIGHT(&(blitter_video_transform->output_video_info)); if ((in_w != out_w) || (in_h != out_h)) { event = GST_EVENT(gst_mini_object_make_writable(GST_MINI_OBJECT(event))); structure = (GstStructure *)gst_event_get_structure(event); if (gst_structure_get_double(structure, "pointer_x", &a)) { gst_structure_set( structure, "pointer_x", G_TYPE_DOUBLE, a * in_w / out_w, NULL ); } if (gst_structure_get_double(structure, "pointer_y", &a)) { gst_structure_set( structure, "pointer_y", G_TYPE_DOUBLE, a * in_h / out_h, NULL ); } } break; } default: break; } return GST_BASE_TRANSFORM_CLASS(gst_imx_blitter_video_transform_parent_class)->src_event(transform, event); }
static gboolean gst_rtp_dtmf_mux_src_event (GstRTPMux * rtp_mux, GstEvent * event) { if (GST_EVENT_TYPE (event) == GST_EVENT_CUSTOM_UPSTREAM) { const GstStructure *s = gst_event_get_structure (event); if (s && gst_structure_has_name (s, "dtmf-event")) { GST_OBJECT_LOCK (rtp_mux); if (GST_CLOCK_TIME_IS_VALID (rtp_mux->last_stop)) { event = (GstEvent *) gst_mini_object_make_writable (GST_MINI_OBJECT_CAST (event)); s = gst_event_get_structure (event); gst_structure_set ((GstStructure *) s, "last-stop", G_TYPE_UINT64, rtp_mux->last_stop, NULL); } GST_OBJECT_UNLOCK (rtp_mux); } } return GST_RTP_MUX_CLASS (parent_class)->src_event (rtp_mux, event); }
void gst_3d_scene_send_eos_on_esc (GstElement * element, GstEvent * event) { GstStructure *structure = (GstStructure *) gst_event_get_structure (event); const gchar *event_name = gst_structure_get_string (structure, "event"); if (g_strcmp0 (event_name, "key-press") == 0) { const gchar *key = gst_structure_get_string (structure, "key"); if (key != NULL) if (g_strcmp0 (key, "Escape") == 0) _send_eos (element); } }
static gboolean webKitMediaClearKeyDecryptorHandleKeyResponse(WebKitMediaCommonEncryptionDecrypt* self, GstEvent* event) { WebKitMediaClearKeyDecryptPrivate* priv = WEBKIT_MEDIA_CK_DECRYPT_GET_PRIVATE(WEBKIT_MEDIA_CK_DECRYPT(self)); const GstStructure* structure = gst_event_get_structure(event); if (!gst_structure_has_name(structure, "drm-cipher")) return FALSE; const GValue* value = gst_structure_get_value(structure, "key"); priv->key.clear(); priv->key = adoptGRef(gst_buffer_copy(gst_value_get_buffer(value))); return TRUE; }
/** * gst_event_parse_sink_message: * @event: The event to query * @msg: A pointer to store the #GstMessage in. * * Parse the sink-message event. Unref @msg after usage. * * Since: 0.10.26 */ void gst_event_parse_sink_message (GstEvent * event, GstMessage ** msg) { const GstStructure *structure; g_return_if_fail (GST_IS_EVENT (event)); g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_SINK_MESSAGE); structure = gst_event_get_structure (event); if (msg) *msg = GST_MESSAGE (gst_value_dup_mini_object (gst_structure_id_get_value (structure, GST_QUARK (MESSAGE)))); }
static gboolean gst_rtp_mux_src_event_real (GstRTPMux * rtp_mux, GstEvent * event) { switch (GST_EVENT_TYPE (event)) { case GST_EVENT_CUSTOM_UPSTREAM: { const GstStructure *s = gst_event_get_structure (event); if (gst_structure_has_name (s, "GstRTPCollision")) { guint ssrc = 0; if (!gst_structure_get_uint (s, "ssrc", &ssrc)) ssrc = -1; GST_DEBUG_OBJECT (rtp_mux, "collided ssrc: %" G_GUINT32_FORMAT, ssrc); /* choose another ssrc for our stream */ GST_OBJECT_LOCK (rtp_mux); if (ssrc == rtp_mux->current_ssrc) { GstCaps *caps; guint suggested_ssrc = 0; guint32 new_ssrc; if (gst_structure_get_uint (s, "suggested-ssrc", &suggested_ssrc)) rtp_mux->current_ssrc = suggested_ssrc; while (ssrc == rtp_mux->current_ssrc) rtp_mux->current_ssrc = g_random_int (); new_ssrc = rtp_mux->current_ssrc; GST_OBJECT_UNLOCK (rtp_mux); caps = gst_pad_get_current_caps (rtp_mux->srcpad); caps = gst_caps_make_writable (caps); gst_caps_set_simple (caps, "ssrc", G_TYPE_UINT, new_ssrc, NULL); gst_pad_set_caps (rtp_mux->srcpad, caps); gst_caps_unref (caps); } else { GST_OBJECT_UNLOCK (rtp_mux); } } break; } default: break; } return gst_pad_event_default (rtp_mux->srcpad, GST_OBJECT (rtp_mux), event); }
/** * gst_event_parse_latency: * @event: The event to query * @latency: A pointer to store the latency in. * * Get the latency in the latency event. * * Since: 0.10.12 */ void gst_event_parse_latency (GstEvent * event, GstClockTime * latency) { const GstStructure *structure; g_return_if_fail (GST_IS_EVENT (event)); g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_LATENCY); structure = gst_event_get_structure (event); if (latency) *latency = g_value_get_uint64 (gst_structure_id_get_value (structure, GST_QUARK (LATENCY))); }
static gboolean rsn_dec_sink_event (GstPad * pad, GstObject * parent, GstEvent * event) { RsnDec *self = RSN_DEC (parent); gboolean ret = TRUE; const GstStructure *s = gst_event_get_structure (event); const gchar *name = (s ? gst_structure_get_name (s) : NULL); if (name && g_str_equal (name, "application/x-gst-dvd")) ret = gst_pad_push_event (GST_PAD_CAST (self->srcpad), event); else ret = self->sink_event_func (pad, parent, event); return ret; }
/** * gst_event_parse_toc: * @event: a TOC event. * @toc: (out) (transfer full): pointer to #GstToc structure. * @updated: (out): pointer to store TOC updated flag. * * Parse a TOC @event and store the results in the given @toc and @updated locations. */ void gst_event_parse_toc (GstEvent * event, GstToc ** toc, gboolean * updated) { const GstStructure *structure; g_return_if_fail (event != NULL); g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_TOC); g_return_if_fail (toc != NULL); structure = gst_event_get_structure (event); gst_structure_id_get (structure, GST_QUARK (TOC), GST_TYPE_TOC, toc, GST_QUARK (UPDATED), G_TYPE_BOOLEAN, updated, NULL); }
/** * gst_event_parse_stream_start: * @event: a stream-start event. * @stream_id: (out) (transfer none): pointer to store the stream-id * * Parse a stream-id @event and store the result in the given @stream_id * location. The string stored in @stream_id must not be modified and will * remain valid only until @event gets freed. Make a copy if you want to * modify it or store it for later use. */ void gst_event_parse_stream_start (GstEvent * event, const gchar ** stream_id) { const GstStructure *structure; const GValue *val; g_return_if_fail (event != NULL); g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_STREAM_START); structure = gst_event_get_structure (event); val = gst_structure_id_get_value (structure, GST_QUARK (STREAM_ID)); if (stream_id) *stream_id = g_value_get_string (val); }
static gboolean is_remb_event (GstEvent * event) { const GstStructure *s; g_return_val_if_fail (event != NULL, FALSE); if (GST_EVENT_TYPE (event) != GST_EVENT_CUSTOM_UPSTREAM) { return FALSE; } s = gst_event_get_structure (event); g_return_val_if_fail (s != NULL, FALSE); return gst_structure_has_name (s, KMS_REMB_EVENT_NAME); }
/** * gst_event_parse_toc_select: * @event: a TOC select event. * @uid: (out): storage for the selection UID. * * Parse a TOC select @event and store the results in the given @uid location. */ void gst_event_parse_toc_select (GstEvent * event, gchar ** uid) { const GstStructure *structure; const GValue *val; g_return_if_fail (event != NULL); g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_TOC_SELECT); structure = gst_event_get_structure (event); val = gst_structure_id_get_value (structure, GST_QUARK (UID)); if (uid != NULL) *uid = g_strdup (g_value_get_string (val)); }
static gboolean gst_fake_sink_event (GstBaseSink * bsink, GstEvent * event) { GstFakeSink *sink = GST_FAKE_SINK (bsink); if (!sink->silent) { const GstStructure *s; const gchar *tstr; gchar *sstr; GST_OBJECT_LOCK (sink); g_free (sink->last_message); if (GST_EVENT_TYPE (event) == GST_EVENT_SINK_MESSAGE) { GstMessage *msg; const GstStructure *structure; gst_event_parse_sink_message (event, &msg); structure = gst_message_get_structure (msg); sstr = gst_structure_to_string (structure); sink->last_message = g_strdup_printf ("message ******* (%s:%s) M (type: %d, %s) %p", GST_DEBUG_PAD_NAME (GST_BASE_SINK_CAST (sink)->sinkpad), GST_MESSAGE_TYPE (msg), sstr, msg); gst_message_unref (msg); } else { tstr = gst_event_type_get_name (GST_EVENT_TYPE (event)); if ((s = gst_event_get_structure (event))) { sstr = gst_structure_to_string (s); } else { sstr = g_strdup (""); } sink->last_message = g_strdup_printf ("event ******* (%s:%s) E (type: %s (%d), %s) %p", GST_DEBUG_PAD_NAME (GST_BASE_SINK_CAST (sink)->sinkpad), tstr, GST_EVENT_TYPE (event), sstr, event); } g_free (sstr); GST_OBJECT_UNLOCK (sink); gst_fake_sink_notify_last_message (sink); } return GST_BASE_SINK_CLASS (parent_class)->event (bsink, event); }
static gboolean gst_uri_downloader_sink_event (GstPad * pad, GstObject * parent, GstEvent * event) { gboolean ret = FALSE; GstUriDownloader *downloader; downloader = GST_URI_DOWNLOADER (gst_pad_get_element_private (pad)); switch (event->type) { case GST_EVENT_EOS:{ GST_OBJECT_LOCK (downloader); GST_DEBUG_OBJECT (downloader, "Got EOS on the fetcher pad"); if (downloader->priv->download != NULL) { /* signal we have fetched the URI */ downloader->priv->download->completed = TRUE; downloader->priv->download->download_stop_time = gst_util_get_timestamp (); GST_DEBUG_OBJECT (downloader, "Signaling chain funtion"); g_cond_signal (&downloader->priv->cond); } GST_OBJECT_UNLOCK (downloader); gst_event_unref (event); break; } case GST_EVENT_CUSTOM_DOWNSTREAM_STICKY:{ const GstStructure *str; str = gst_event_get_structure (event); if (gst_structure_has_name (str, "http-headers")) { GST_OBJECT_LOCK (downloader); if (downloader->priv->download != NULL) { if (downloader->priv->download->headers) gst_structure_free (downloader->priv->download->headers); downloader->priv->download->headers = gst_structure_copy (str); } GST_OBJECT_UNLOCK (downloader); } } /* falls through */ default: ret = gst_pad_event_default (pad, parent, event); break; } return ret; }
static gboolean gst_video_crop_src_event (GstBaseTransform * trans, GstEvent * event) { GstEvent *new_event; GstStructure *new_structure; const GstStructure *structure; const gchar *event_name; double pointer_x; double pointer_y; GstVideoCrop *vcrop = GST_VIDEO_CROP (trans); new_event = NULL; GST_OBJECT_LOCK (vcrop); if (GST_EVENT_TYPE (event) == GST_EVENT_NAVIGATION && (vcrop->crop_left != 0 || vcrop->crop_top != 0)) { structure = gst_event_get_structure (event); event_name = gst_structure_get_string (structure, "event"); if (event_name && (strcmp (event_name, "mouse-move") == 0 || strcmp (event_name, "mouse-button-press") == 0 || strcmp (event_name, "mouse-button-release") == 0)) { if (gst_structure_get_double (structure, "pointer_x", &pointer_x) && gst_structure_get_double (structure, "pointer_y", &pointer_y)) { new_structure = gst_structure_copy (structure); gst_structure_set (new_structure, "pointer_x", G_TYPE_DOUBLE, (double) (pointer_x + vcrop->crop_left), "pointer_y", G_TYPE_DOUBLE, (double) (pointer_y + vcrop->crop_top), NULL); new_event = gst_event_new_navigation (new_structure); gst_event_unref (event); } else { GST_WARNING_OBJECT (vcrop, "Failed to read navigation event"); } } } GST_OBJECT_UNLOCK (vcrop); return GST_BASE_TRANSFORM_CLASS (parent_class)->src_event (trans, (new_event ? new_event : event)); }
/** * gst_navigation_event_parse_command: * @event: A #GstEvent to inspect. * @command: Pointer to GstNavigationCommand to receive the type of the * navigation event. * * Inspect a #GstNavigation command event and retrieve the enum value of the * associated command. * * Returns: TRUE if the navigation command could be extracted, otherwise FALSE. * * Since: 0.10.23 */ gboolean gst_navigation_event_parse_command (GstEvent * event, GstNavigationCommand * command) { const GstStructure *s; gboolean ret = TRUE; g_return_val_if_fail (GST_NAVIGATION_EVENT_HAS_TYPE (event, COMMAND), FALSE); if (command) { s = gst_event_get_structure (event); ret = gst_structure_get_uint (s, "command-code", (guint *) command); WARN_IF_FAIL (ret, "Couldn't extract command code from command event"); } return ret; }
static gboolean gst_rtp_pt_demux_sink_event (GstPad * pad, GstObject * parent, GstEvent * event) { GstRtpPtDemux *rtpdemux; gboolean res = FALSE; rtpdemux = GST_RTP_PT_DEMUX (parent); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_CAPS: { gst_rtp_pt_demux_clear_pt_map (rtpdemux); /* don't forward the event, we cleared the ptmap and on the next buffer we * will add the pt to the caps and push a new caps event */ gst_event_unref (event); res = TRUE; break; } case GST_EVENT_CUSTOM_DOWNSTREAM: { const GstStructure *s; s = gst_event_get_structure (event); if (gst_structure_has_name (s, "GstRTPPacketLost")) { GstPad *srcpad = find_pad_for_pt (rtpdemux, rtpdemux->last_pt); if (srcpad) { res = gst_pad_push_event (srcpad, event); gst_object_unref (srcpad); } else { gst_event_unref (event); } } else { res = gst_pad_event_default (pad, parent, event); } break; } default: res = gst_pad_event_default (pad, parent, event); break; } return res; }
EXPORT_C #endif gboolean gst_navigation_event_parse_command (GstEvent * event, GstNavigationCommand * command) { const GstStructure *s; g_return_val_if_fail (GST_NAVIGATION_EVENT_HAS_TYPE (event, COMMAND), FALSE); if (command) { s = gst_event_get_structure (event); g_return_val_if_fail (gst_structure_get_uint (s, "command-code", (guint*)command), FALSE); } return TRUE; }
/** * gst_video_event_is_force_key_unit: * @event: A #GstEvent to check * * Checks if an event is a force key unit event. Returns true for both upstream * and downstream force key unit events. * * Returns: %TRUE if the event is a valid force key unit event */ gboolean gst_video_event_is_force_key_unit (GstEvent * event) { const GstStructure *s; g_return_val_if_fail (event != NULL, FALSE); if (GST_EVENT_TYPE (event) != GST_EVENT_CUSTOM_DOWNSTREAM && GST_EVENT_TYPE (event) != GST_EVENT_CUSTOM_UPSTREAM) return FALSE; /* Not a force key unit event */ s = gst_event_get_structure (event); if (s == NULL || !gst_structure_has_name (s, GST_VIDEO_EVENT_FORCE_KEY_UNIT_NAME)) return FALSE; return TRUE; }
void gst_3d_scene_navigation_event (Gst3DScene * self, GstEvent * event) { gst_3d_camera_navigation_event (self->camera, event); GstNavigationEventType event_type = gst_navigation_event_get_type (event); switch (event_type) { case GST_NAVIGATION_EVENT_KEY_PRESS:{ GstStructure *structure = (GstStructure *) gst_event_get_structure (event); const gchar *key = gst_structure_get_string (structure, "key"); if (key != NULL && g_strcmp0 (key, "Tab") == 0) gst_3d_scene_toggle_wireframe_mode (self); break; } default: break; } }
/** * gst_navigation_event_parse_key_event: * @event: A #GstEvent to inspect. * @key: A pointer to a location to receive the string identifying the key * press. The returned string is owned by the event, and valid only until the * event is unreffed. * * Since: 0.10.23 */ gboolean gst_navigation_event_parse_key_event (GstEvent * event, const gchar ** key) { GstNavigationEventType e_type; const GstStructure *s; e_type = gst_navigation_event_get_type (event); g_return_val_if_fail (e_type == GST_NAVIGATION_EVENT_KEY_PRESS || e_type == GST_NAVIGATION_EVENT_KEY_RELEASE, FALSE); if (key) { s = gst_event_get_structure (event); *key = gst_structure_get_string (s, "key"); if (*key == NULL) return FALSE; } return TRUE; }
static gboolean gst_base_video_encoder_src_event (GstPad * pad, GstEvent * event) { GstBaseVideoEncoder *base_video_encoder; GstBaseVideoEncoderClass *base_video_encoder_class; gboolean ret = FALSE; base_video_encoder = GST_BASE_VIDEO_ENCODER (gst_pad_get_parent (pad)); base_video_encoder_class = GST_BASE_VIDEO_ENCODER_GET_CLASS (base_video_encoder); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_CUSTOM_UPSTREAM: { const GstStructure *s; s = gst_event_get_structure (event); if (gst_structure_has_name (s, "GstForceKeyUnit")) { GST_OBJECT_LOCK (base_video_encoder); base_video_encoder->force_keyframe = TRUE; GST_OBJECT_UNLOCK (base_video_encoder); gst_event_unref (event); ret = TRUE; } else { ret = gst_pad_push_event (GST_BASE_VIDEO_CODEC_SINK_PAD (base_video_encoder), event); } break; } default: ret = gst_pad_push_event (GST_BASE_VIDEO_CODEC_SINK_PAD (base_video_encoder), event); break; } gst_object_unref (base_video_encoder); return ret; }