void test_make_writable() { GstBuffer *buffer; GstMiniObject *mobj, *mobj2, *mobj3; xmlfile = "gstminiobject_test_make_writable"; std_log(LOG_FILENAME_LINE, "Test Started test_make_writable"); buffer = gst_buffer_new_and_alloc (4); mobj = GST_MINI_OBJECT (buffer); mobj2 = gst_mini_object_make_writable (mobj); fail_unless (GST_IS_BUFFER (mobj2), "make_writable did not return a buffer"); fail_unless (mobj == mobj2, "make_writable returned a copy for a buffer with refcount 1"); mobj2 = gst_mini_object_ref (mobj); mobj3 = gst_mini_object_make_writable (mobj); fail_unless (GST_IS_BUFFER (mobj3), "make_writable did not return a buffer"); fail_if (mobj == mobj3, "make_writable returned same object for a buffer with refcount > 1"); fail_unless (GST_MINI_OBJECT_REFCOUNT_VALUE (mobj) == 1, "refcount of original mobj object should be back to 1"); mobj2 = gst_mini_object_make_writable (mobj); fail_unless (GST_IS_BUFFER (mobj2), "make_writable did not return a buffer"); fail_unless (mobj == mobj2, "make_writable returned a copy for a buffer with refcount 1"); std_log(LOG_FILENAME_LINE, "Test Successful"); create_xml(0); }
static gboolean gst_video_scale_src_event (GstBaseTransform * trans, GstEvent * event) { GstVideoScale *videoscale = GST_VIDEO_SCALE (trans); gboolean ret; gdouble a; GstStructure *structure; GST_DEBUG_OBJECT (videoscale, "handling %s event", GST_EVENT_TYPE_NAME (event)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_NAVIGATION: 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 * videoscale->from_width / videoscale->to_width, NULL); } if (gst_structure_get_double (structure, "pointer_y", &a)) { gst_structure_set (structure, "pointer_y", G_TYPE_DOUBLE, a * videoscale->from_height / videoscale->to_height, NULL); } break; default: break; } ret = GST_BASE_TRANSFORM_CLASS (parent_class)->src_event (trans, event); return ret; }
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_vr_compositor_src_event (GstBaseTransform * trans, GstEvent * event) { GstVRCompositor *self = GST_VR_COMPOSITOR (trans); GST_DEBUG_OBJECT (trans, "handling %s event", GST_EVENT_TYPE_NAME (event)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_NAVIGATION: event = GST_EVENT (gst_mini_object_make_writable (GST_MINI_OBJECT (event))); gst_3d_scene_send_eos_on_esc (GST_ELEMENT (self), event); gst_3d_scene_navigation_event (self->scene, event); break; default: break; } return GST_BASE_TRANSFORM_CLASS (parent_class)->src_event (trans, 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); }
static gboolean gst_ffmpegscale_handle_src_event(GstPad* pad, GstEvent* event) { GstFFMpegScale* scale; GstStructure* structure; gdouble pointer; gboolean res; scale = GST_FFMPEGSCALE(gst_pad_get_parent(pad)); switch (GST_EVENT_TYPE(event)) { case GST_EVENT_NAVIGATION: 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", &pointer)) { gst_structure_set(structure, "pointer_x", G_TYPE_DOUBLE, pointer * scale->in_width / scale->out_width, NULL); } if (gst_structure_get_double(structure, "pointer_y", &pointer)) { gst_structure_set(structure, "pointer_y", G_TYPE_DOUBLE, pointer * scale->in_height / scale->out_height, NULL); } break; default: break; } res = gst_pad_event_default(pad, event); gst_object_unref(scale); return res; }
static gboolean gst_rtp_pt_demux_src_event (GstPad * pad, GstObject * parent, GstEvent * event) { GstRtpPtDemux *demux; const GstStructure *s; demux = GST_RTP_PT_DEMUX (parent); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_CUSTOM_UPSTREAM: case GST_EVENT_CUSTOM_BOTH: case GST_EVENT_CUSTOM_BOTH_OOB: s = gst_event_get_structure (event); if (s && !gst_structure_has_field (s, "payload")) { GSList *walk; GST_OBJECT_LOCK (demux); for (walk = demux->srcpads; walk; walk = g_slist_next (walk)) { GstRtpPtDemuxPad *dpad = (GstRtpPtDemuxPad *) walk->data; if (dpad->pad == pad) { GstStructure *ws; event = GST_EVENT_CAST (gst_mini_object_make_writable (GST_MINI_OBJECT_CAST (event))); ws = gst_event_writable_structure (event); gst_structure_set (ws, "payload", G_TYPE_UINT, dpad->pt, NULL); break; } } GST_OBJECT_UNLOCK (demux); } break; default: break; } return gst_pad_event_default (pad, parent, event); }
static gboolean gst_rtp_ssrc_demux_src_event (GstPad * pad, GstEvent * event) { GstRtpSsrcDemux *demux; const GstStructure *s; demux = GST_RTP_SSRC_DEMUX (gst_pad_get_parent (pad)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_CUSTOM_UPSTREAM: case GST_EVENT_CUSTOM_BOTH: case GST_EVENT_CUSTOM_BOTH_OOB: s = gst_event_get_structure (event); if (s && !gst_structure_has_field (s, "ssrc")) { GSList *walk; for (walk = demux->srcpads; walk; walk = g_slist_next (walk)) { GstRtpSsrcDemuxPad *dpad = (GstRtpSsrcDemuxPad *) walk->data; if (dpad->rtp_pad == pad || dpad->rtcp_pad == pad) { event = GST_EVENT_CAST (gst_mini_object_make_writable (GST_MINI_OBJECT_CAST (event))); gst_structure_set (event->structure, "ssrc", G_TYPE_UINT, dpad->ssrc, NULL); break; } } } break; default: break; } gst_object_unref (demux); return gst_pad_event_default (pad, event); }
static gboolean gst_video_flip_src_event (GstBaseTransform * trans, GstEvent * event) { GstVideoFlip *vf = GST_VIDEO_FLIP (trans); gdouble new_x, new_y, x, y; GstStructure *structure; GST_DEBUG_OBJECT (vf, "handling %s event", GST_EVENT_TYPE_NAME (event)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_NAVIGATION: 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", &x) && gst_structure_get_double (structure, "pointer_y", &y)) { GST_DEBUG_OBJECT (vf, "converting %fx%f", x, y); switch (vf->method) { case GST_VIDEO_FLIP_METHOD_90R: new_x = y; new_y = vf->to_width - x; break; case GST_VIDEO_FLIP_METHOD_90L: new_x = vf->to_height - y; new_y = x; break; case GST_VIDEO_FLIP_METHOD_OTHER: new_x = vf->to_height - y; new_y = vf->to_width - x; break; case GST_VIDEO_FLIP_METHOD_TRANS: new_x = y; new_y = x; break; case GST_VIDEO_FLIP_METHOD_180: new_x = vf->to_width - x; new_y = vf->to_height - y; break; case GST_VIDEO_FLIP_METHOD_HORIZ: new_x = vf->to_width - x; new_y = y; break; case GST_VIDEO_FLIP_METHOD_VERT: new_x = x; new_y = vf->to_height - y; break; default: new_x = x; new_y = y; break; } GST_DEBUG_OBJECT (vf, "to %fx%f", new_x, new_y); gst_structure_set (structure, "pointer_x", G_TYPE_DOUBLE, new_x, "pointer_y", G_TYPE_DOUBLE, new_y, NULL); } break; default: break; } return TRUE; }
static GstEvent * gst_rg_volume_tag_event (GstRgVolume * self, GstEvent * event) { GstTagList *tag_list; gboolean has_track_gain, has_track_peak, has_album_gain, has_album_peak; gboolean has_ref_level; g_return_val_if_fail (event != NULL, NULL); g_return_val_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_TAG, event); gst_event_parse_tag (event, &tag_list); if (gst_tag_list_is_empty (tag_list)) return event; has_track_gain = gst_tag_list_get_double (tag_list, GST_TAG_TRACK_GAIN, &self->track_gain); has_track_peak = gst_tag_list_get_double (tag_list, GST_TAG_TRACK_PEAK, &self->track_peak); has_album_gain = gst_tag_list_get_double (tag_list, GST_TAG_ALBUM_GAIN, &self->album_gain); has_album_peak = gst_tag_list_get_double (tag_list, GST_TAG_ALBUM_PEAK, &self->album_peak); has_ref_level = gst_tag_list_get_double (tag_list, GST_TAG_REFERENCE_LEVEL, &self->reference_level); if (!has_track_gain && !has_track_peak && !has_album_gain && !has_album_peak) return event; if (has_ref_level && (has_track_gain || has_album_gain) && (ABS (self->reference_level - RG_REFERENCE_LEVEL) > 1.e-6)) { /* Log a message stating the amount of adjustment that is applied below. */ GST_DEBUG_OBJECT (self, "compensating for reference level difference by %" GAIN_FORMAT, RG_REFERENCE_LEVEL - self->reference_level); } if (has_track_gain) { self->track_gain += RG_REFERENCE_LEVEL - self->reference_level; } if (has_album_gain) { self->album_gain += RG_REFERENCE_LEVEL - self->reference_level; } /* Ignore values that are obviously invalid. */ if (G_UNLIKELY (has_track_gain && !VALID_GAIN (self->track_gain))) { GST_DEBUG_OBJECT (self, "ignoring bogus track gain value %" GAIN_FORMAT, self->track_gain); has_track_gain = FALSE; } if (G_UNLIKELY (has_track_peak && !VALID_PEAK (self->track_peak))) { GST_DEBUG_OBJECT (self, "ignoring bogus track peak value %" PEAK_FORMAT, self->track_peak); has_track_peak = FALSE; } if (G_UNLIKELY (has_album_gain && !VALID_GAIN (self->album_gain))) { GST_DEBUG_OBJECT (self, "ignoring bogus album gain value %" GAIN_FORMAT, self->album_gain); has_album_gain = FALSE; } if (G_UNLIKELY (has_album_peak && !VALID_PEAK (self->album_peak))) { GST_DEBUG_OBJECT (self, "ignoring bogus album peak value %" PEAK_FORMAT, self->album_peak); has_album_peak = FALSE; } /* Clamp peaks >1.0. Float based decoders can produce spurious samples >1.0, * cutting these files back to 1.0 should not cause any audible distortion. * This is most often seen with Vorbis files. */ if (has_track_peak && self->track_peak > 1.) { GST_DEBUG_OBJECT (self, "clamping track peak %" PEAK_FORMAT " to 1.0", self->track_peak); self->track_peak = 1.0; } if (has_album_peak && self->album_peak > 1.) { GST_DEBUG_OBJECT (self, "clamping album peak %" PEAK_FORMAT " to 1.0", self->album_peak); self->album_peak = 1.0; } self->has_track_gain |= has_track_gain; self->has_track_peak |= has_track_peak; self->has_album_gain |= has_album_gain; self->has_album_peak |= has_album_peak; event = (GstEvent *) gst_mini_object_make_writable (GST_MINI_OBJECT (event)); gst_event_parse_tag (event, &tag_list); gst_tag_list_remove_tag (tag_list, GST_TAG_TRACK_GAIN); gst_tag_list_remove_tag (tag_list, GST_TAG_TRACK_PEAK); gst_tag_list_remove_tag (tag_list, GST_TAG_ALBUM_GAIN); gst_tag_list_remove_tag (tag_list, GST_TAG_ALBUM_PEAK); gst_tag_list_remove_tag (tag_list, GST_TAG_REFERENCE_LEVEL); gst_rg_volume_update_gain (self); if (gst_tag_list_is_empty (tag_list)) { gst_event_unref (event); event = NULL; } return event; }