static void mpegts_base_class_init (MpegTSBaseClass * klass) { GObjectClass *gobject_class; GstElementClass *element_class; element_class = GST_ELEMENT_CLASS (klass); element_class->change_state = mpegts_base_change_state; gst_element_class_add_pad_template (element_class, gst_static_pad_template_get (&sink_template)); gobject_class = G_OBJECT_CLASS (klass); gobject_class->dispose = mpegts_base_dispose; gobject_class->finalize = mpegts_base_finalize; gobject_class->set_property = mpegts_base_set_property; gobject_class->get_property = mpegts_base_get_property; g_object_class_install_property (gobject_class, PROP_PARSE_PRIVATE_SECTIONS, g_param_spec_boolean ("parse-private-sections", "Parse private sections", "Parse private sections", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); }
static void gst_omx_mpeg2_video_dec_class_init (GstOMXMPEG2VideoDecClass * klass) { GstOMXVideoDecClass *videodec_class = GST_OMX_VIDEO_DEC_CLASS (klass); GstElementClass *element_class = GST_ELEMENT_CLASS (klass); videodec_class->is_format_change = GST_DEBUG_FUNCPTR (gst_omx_mpeg2_video_dec_is_format_change); videodec_class->set_format = GST_DEBUG_FUNCPTR (gst_omx_mpeg2_video_dec_set_format); videodec_class->cdata.default_sink_template_caps = "video/mpeg, " "mpegversion=(int) [1, 2], " "systemstream=(boolean) false, " "parsed=(boolean) true, " "width=(int) [1,MAX], " "height=(int) [1,MAX]"; gst_element_class_set_static_metadata (element_class, "OpenMAX MPEG2 Video Decoder", "Codec/Decoder/Video", "Decode MPEG2 video streams", "Sebastian Dröge <*****@*****.**>"); gst_omx_set_default_role (&videodec_class->cdata, "video_decoder.mpeg2"); }
static void gst_amc_audio_dec_base_init (gpointer g_class) { GstElementClass *element_class = GST_ELEMENT_CLASS (g_class); GstAmcAudioDecClass *amcaudiodec_class = GST_AMC_AUDIO_DEC_CLASS (g_class); const GstAmcCodecInfo *codec_info; GstPadTemplate *templ; GstCaps *sink_caps, *src_caps; gchar *longname; codec_info = g_type_get_qdata (G_TYPE_FROM_CLASS (g_class), gst_amc_codec_info_quark); /* This happens for the base class and abstract subclasses */ if (!codec_info) return; amcaudiodec_class->codec_info = codec_info; gst_amc_codec_info_to_caps (codec_info, &sink_caps, &src_caps); /* Add pad templates */ templ = gst_pad_template_new ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, sink_caps); gst_element_class_add_pad_template (element_class, templ); gst_caps_unref (sink_caps); templ = gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS, src_caps); gst_element_class_add_pad_template (element_class, templ); gst_caps_unref (src_caps); longname = g_strdup_printf ("Android MediaCodec %s", codec_info->name); gst_element_class_set_metadata (element_class, codec_info->name, "Codec/Decoder/Audio", longname, "Sebastian Dröge <*****@*****.**>"); g_free (longname); }
static void gst_rsvg_dec_class_init (GstRsvgDecClass * klass) { GstVideoDecoderClass *video_decoder_class = GST_VIDEO_DECODER_CLASS (klass); GObjectClass *gobject_class = (GObjectClass *) klass; GstElementClass *element_class = GST_ELEMENT_CLASS (klass); GST_DEBUG_CATEGORY_INIT (rsvgdec_debug, "rsvgdec", 0, "RSVG decoder"); gst_element_class_set_static_metadata (element_class, "SVG image decoder", "Codec/Decoder/Image", "Uses librsvg to decode SVG images", "Sebastian Dröge <*****@*****.**>"); gst_element_class_add_static_pad_template (element_class, &sink_factory); gst_element_class_add_static_pad_template (element_class, &src_factory); gobject_class->finalize = gst_rsvg_dec_finalize; video_decoder_class->stop = GST_DEBUG_FUNCPTR (gst_rsvg_dec_stop); video_decoder_class->set_format = GST_DEBUG_FUNCPTR (gst_rsvg_dec_set_format); video_decoder_class->parse = GST_DEBUG_FUNCPTR (gst_rsvg_dec_parse); video_decoder_class->handle_frame = GST_DEBUG_FUNCPTR (gst_rsvg_dec_handle_frame); }
static void gst_wrapper_camera_bin_src_class_init (GstWrapperCameraBinSrcClass * klass) { GObjectClass *gobject_class; GstElementClass *gstelement_class; GstBaseCameraBinSrcClass *gstbasecamerasrc_class; gobject_class = G_OBJECT_CLASS (klass); gstelement_class = GST_ELEMENT_CLASS (klass); gstbasecamerasrc_class = GST_BASE_CAMERA_SRC_CLASS (klass); gobject_class->dispose = gst_wrapper_camera_bin_src_dispose; gobject_class->finalize = (GObjectFinalizeFunc) gst_wrapper_camera_bin_src_finalize; gobject_class->set_property = gst_wrapper_camera_bin_src_set_property; gobject_class->get_property = gst_wrapper_camera_bin_src_get_property; /* g_object_class_install_property .... */ g_object_class_install_property (gobject_class, PROP_VIDEO_SRC, g_param_spec_object ("video-src", "Video source", "The video source element to be used", GST_TYPE_ELEMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); gstelement_class->change_state = gst_wrapper_camera_bin_src_change_state; gstbasecamerasrc_class->construct_pipeline = gst_wrapper_camera_bin_src_construct_pipeline; gstbasecamerasrc_class->set_zoom = gst_wrapper_camera_bin_src_set_zoom; gstbasecamerasrc_class->set_mode = gst_wrapper_camera_bin_src_set_mode; gstbasecamerasrc_class->get_allowed_input_caps = gst_wrapper_camera_bin_src_get_allowed_input_caps; gstbasecamerasrc_class->start_capture = gst_wrapper_camera_bin_src_start_capture; gstbasecamerasrc_class->stop_capture = gst_wrapper_camera_bin_src_stop_capture; }
static void gst_rtp_opus_depay_class_init (GstRTPOpusDepayClass * klass) { GstRTPBaseDepayloadClass *gstbasertpdepayload_class; GstElementClass *element_class; element_class = GST_ELEMENT_CLASS (klass); gstbasertpdepayload_class = (GstRTPBaseDepayloadClass *) klass; gst_element_class_add_static_pad_template (element_class, &gst_rtp_opus_depay_src_template); gst_element_class_add_static_pad_template (element_class, &gst_rtp_opus_depay_sink_template); gst_element_class_set_static_metadata (element_class, "RTP Opus packet depayloader", "Codec/Depayloader/Network/RTP", "Extracts Opus audio from RTP packets", "Danilo Cesar Lemes de Paula <*****@*****.**>"); gstbasertpdepayload_class->process = gst_rtp_opus_depay_process; gstbasertpdepayload_class->set_caps = gst_rtp_opus_depay_setcaps; GST_DEBUG_CATEGORY_INIT (rtpopusdepay_debug, "rtpopusdepay", 0, "Opus RTP Depayloader"); }
/****************************************************************************** * gst_tiaudenc1_change_state * Manage state changes for the audio stream. The gStreamer documentation * states that state changes must be handled in this manner: * 1) Handle ramp-up states * 2) Pass state change to base class * 3) Handle ramp-down states ******************************************************************************/ static GstStateChangeReturn gst_tiaudenc1_change_state(GstElement *element, GstStateChange transition) { GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS; GstTIAudenc1 *audenc1 = GST_TIAUDENC1(element); GST_LOG("begin change_state (%d)\n", transition); /* Handle ramp-up state changes */ switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: break; default: break; } /* Pass state changes to base class */ ret = GST_ELEMENT_CLASS(parent_class)->change_state(element, transition); if (ret == GST_STATE_CHANGE_FAILURE) return ret; /* Handle ramp-down state changes */ switch (transition) { case GST_STATE_CHANGE_READY_TO_NULL: /* Shut down any running audio encoder */ if (!gst_tiaudenc1_exit_audio(audenc1)) { return GST_STATE_CHANGE_FAILURE; } break; default: break; } GST_LOG("end change_state\n"); return ret; }
/** * hls_progress_buffer_init() * * Initializer. Automatically declared in the GST_BOILERPLATE macro above. Should be * only called by GStreamer. */ static void hls_progress_buffer_init(HLSProgressBuffer *element, HLSProgressBufferClass *element_klass) { GstElementClass *klass = GST_ELEMENT_CLASS (element_klass); int i = 0; element->sinkpad = gst_pad_new_from_template (gst_element_class_get_pad_template (klass, "sink"), "sink"); gst_pad_set_chain_function(element->sinkpad, hls_progress_buffer_chain); gst_pad_set_event_function(element->sinkpad, hls_progress_buffer_sink_event); gst_element_add_pad (GST_ELEMENT (element), element->sinkpad); element->srcpad = gst_pad_new_from_template (gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS(element), "src"), "src"); gst_pad_set_activatepush_function(element->srcpad, hls_progress_buffer_activatepush_src); gst_pad_set_event_function(element->srcpad, hls_progress_buffer_src_event); gst_element_add_pad (GST_ELEMENT (element), element->srcpad); element->lock = g_mutex_new(); element->add_cond = g_cond_new(); element->del_cond = g_cond_new(); for (i = 0; i < NUM_OF_CACHED_SEGMENTS; i++) { element->cache[i] = create_cache(); element->cache_size[i] = 0; element->cache_write_ready[i] = TRUE; } element->cache_write_index = -1; element->cache_read_index = 0; element->send_new_segment = TRUE; element->is_flushing = FALSE; element->is_eos = FALSE; element->srcresult = GST_FLOW_OK; }
static GstStateChangeReturn gst_amrmux_change_state (GstElement * element, GstStateChange transition) { GstStateChangeReturn ret; GstAmrMux *amrmux = GST_AMRMUX (element); ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); if (G_UNLIKELY (ret == GST_STATE_CHANGE_FAILURE)) return ret; switch (transition) { case GST_STATE_CHANGE_READY_TO_NULL: { amrmux->writeheader = TRUE; break; } default: break; } return ret; }
static void gst_sdlvideosink_base_init (gpointer g_class) { GstElementClass *element_class = GST_ELEMENT_CLASS (g_class); GstCaps *capslist; gint i; guint32 formats[] = { GST_MAKE_FOURCC ('I', '4', '2', '0'), GST_MAKE_FOURCC ('Y', 'V', '1', '2'), GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'), GST_MAKE_FOURCC ('Y', 'V', 'Y', 'U'), GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y') }; /* make a list of all available caps */ capslist = gst_caps_new_empty (); for (i = 0; i < G_N_ELEMENTS (formats); i++) { gst_caps_append_structure (capslist, gst_structure_new ("video/x-raw-yuv", "format", GST_TYPE_FOURCC, formats[i], "width", GST_TYPE_INT_RANGE, 1, G_MAXINT, "height", GST_TYPE_INT_RANGE, 1, G_MAXINT, "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, 100, 1, NULL)); } sink_template = gst_pad_template_new ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, capslist); gst_element_class_add_pad_template (element_class, sink_template); gst_object_unref (sink_template); gst_element_class_set_details_simple (element_class, "SDL video sink", "Sink/Video", "An SDL-based videosink", "Ronald Bultje <*****@*****.**>, " "Edgard Lima <*****@*****.**>, " "Jan Schmidt <*****@*****.**>"); }
static GstStateChangeReturn gst_egueb_demux_change_state (GstElement * element, GstStateChange transition) { GstEguebDemux *thiz; GstStateChangeReturn ret; thiz = GST_EGUEB_DEMUX (element); switch (transition) { default: break; } ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); if (ret == GST_STATE_CHANGE_FAILURE) return ret; switch (transition) { default: break; } return ret; }
static GstStateChangeReturn gst_wavpack_enc_change_state (GstElement * element, GstStateChange transition) { GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS; GstWavpackEnc *enc = GST_WAVPACK_ENC (element); switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: /* set the last returned GstFlowReturns of the two pads to GST_FLOW_OK * as they're only set to something else in WavpackPackSamples() or more * specific gst_wavpack_enc_push_block() and nothing happened there yet */ enc->srcpad_last_return = enc->wvcsrcpad_last_return = GST_FLOW_OK; break; case GST_STATE_CHANGE_READY_TO_PAUSED: break; case GST_STATE_CHANGE_PAUSED_TO_PLAYING: default: break; } ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); switch (transition) { case GST_STATE_CHANGE_PLAYING_TO_PAUSED: break; case GST_STATE_CHANGE_PAUSED_TO_READY: gst_wavpack_enc_reset (enc); break; case GST_STATE_CHANGE_READY_TO_NULL: break; default: break; } return ret; }
static GstStateChangeReturn gst_a2dp_sink_change_state(GstElement *element, GstStateChange transition) { GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS; GstA2dpSink *self = GST_A2DP_SINK(element); switch (transition) { case GST_STATE_CHANGE_READY_TO_PAUSED: self->taglist = gst_tag_list_new(); gst_a2dp_sink_init_fakesink(self); break; case GST_STATE_CHANGE_NULL_TO_READY: self->sink_is_in_bin = FALSE; self->sink = GST_AVDTP_SINK(gst_element_factory_make( "avdtpsink", "avdtpsink")); if (self->sink == NULL) { GST_WARNING_OBJECT(self, "failed to create avdtpsink"); return GST_STATE_CHANGE_FAILURE; } if (self->device != NULL) gst_avdtp_sink_set_device(self->sink, self->device); g_object_set(G_OBJECT(self->sink), "auto-connect", self->autoconnect, NULL); ret = gst_element_set_state(GST_ELEMENT(self->sink), GST_STATE_READY); break; default: break; } if (ret == GST_STATE_CHANGE_FAILURE) return ret; ret = GST_ELEMENT_CLASS(parent_class)->change_state(element, transition); switch (transition) { case GST_STATE_CHANGE_PAUSED_TO_READY: if (self->taglist) { gst_tag_list_free(self->taglist); self->taglist = NULL; } if (self->newseg_event != NULL) { gst_event_unref(self->newseg_event); self->newseg_event = NULL; } gst_a2dp_sink_remove_fakesink(self); break; case GST_STATE_CHANGE_READY_TO_NULL: if (self->sink_is_in_bin) { if (!gst_bin_remove(GST_BIN(self), GST_ELEMENT(self->sink))) GST_WARNING_OBJECT(self, "Failed to remove " "avdtpsink from bin"); } else if (self->sink != NULL) { gst_element_set_state(GST_ELEMENT(self->sink), GST_STATE_NULL); g_object_unref(G_OBJECT(self->sink)); } self->sink = NULL; gst_a2dp_sink_remove_dynamic_elements(self); break; default: break; } return ret; }
static void gst_tee_class_init (GstTeeClass * klass) { GObjectClass *gobject_class; GstElementClass *gstelement_class; gobject_class = G_OBJECT_CLASS (klass); gstelement_class = GST_ELEMENT_CLASS (klass); gobject_class->finalize = gst_tee_finalize; gobject_class->set_property = gst_tee_set_property; gobject_class->get_property = gst_tee_get_property; gobject_class->dispose = gst_tee_dispose; g_object_class_install_property (gobject_class, PROP_NUM_SRC_PADS, g_param_spec_int ("num-src-pads", "Num Src Pads", "The number of source pads", 0, G_MAXINT, DEFAULT_PROP_NUM_SRC_PADS, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_HAS_CHAIN, g_param_spec_boolean ("has-chain", "Has Chain", "If the element can operate in push mode", DEFAULT_PROP_HAS_CHAIN, G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_SILENT, g_param_spec_boolean ("silent", "Silent", "Don't produce last_message events", DEFAULT_PROP_SILENT, G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); pspec_last_message = g_param_spec_string ("last-message", "Last Message", "The message describing current status", DEFAULT_PROP_LAST_MESSAGE, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); g_object_class_install_property (gobject_class, PROP_LAST_MESSAGE, pspec_last_message); g_object_class_install_property (gobject_class, PROP_PULL_MODE, g_param_spec_enum ("pull-mode", "Pull mode", "Behavior of tee in pull mode", GST_TYPE_TEE_PULL_MODE, DEFAULT_PULL_MODE, G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); pspec_alloc_pad = g_param_spec_object ("alloc-pad", "Allocation Src Pad", "The pad ALLOCATION queries will be proxied to (unused)", GST_TYPE_PAD, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); g_object_class_install_property (gobject_class, PROP_ALLOC_PAD, pspec_alloc_pad); /** * GstTee:allow-not-linked * * This property makes sink pad return GST_FLOW_OK even if there are no * source pads or any of them is linked. * * This is useful to avoid errors when you have a dynamic pipeline and during * a reconnection you can have all the pads unlinked or removed. * * Since: 1.6 */ g_object_class_install_property (gobject_class, PROP_ALLOW_NOT_LINKED, g_param_spec_boolean ("allow-not-linked", "Allow not linked", "Return GTS_FLOW_OK even if there are not source pads or all are " "unlinked", DEFAULT_PROP_ALLOW_NOT_LINKED, G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); gst_element_class_set_static_metadata (gstelement_class, "Tee pipe fitting", "Generic", "1-to-N pipe fitting", "Erik Walthinsen <*****@*****.**>, " "Wim Taymans <*****@*****.**>"); gst_element_class_add_pad_template (gstelement_class, gst_static_pad_template_get (&sinktemplate)); gst_element_class_add_pad_template (gstelement_class, gst_static_pad_template_get (&tee_src_template)); gstelement_class->request_new_pad = GST_DEBUG_FUNCPTR (gst_tee_request_new_pad); gstelement_class->release_pad = GST_DEBUG_FUNCPTR (gst_tee_release_pad); }
static void gst_cd_paranoia_src_class_init (GstCdParanoiaSrcClass * klass) { GstAudioCdSrcClass *audiocdsrc_class = GST_AUDIO_CD_SRC_CLASS (klass); GstElementClass *element_class = GST_ELEMENT_CLASS (klass); GObjectClass *gobject_class = G_OBJECT_CLASS (klass); gobject_class->set_property = gst_cd_paranoia_src_set_property; gobject_class->get_property = gst_cd_paranoia_src_get_property; gobject_class->finalize = gst_cd_paranoia_src_finalize; gst_element_class_set_static_metadata (element_class, "CD Audio (cdda) Source, Paranoia IV", "Source/File", "Read audio from CD in paranoid mode", "Erik Walthinsen <*****@*****.**>, Wim Taymans <*****@*****.**>"); audiocdsrc_class->open = gst_cd_paranoia_src_open; audiocdsrc_class->close = gst_cd_paranoia_src_close; audiocdsrc_class->read_sector = gst_cd_paranoia_src_read_sector; g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_GENERIC_DEVICE, g_param_spec_string ("generic-device", "Generic device", "Use specified generic scsi device", DEFAULT_GENERIC_DEVICE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_READ_SPEED, g_param_spec_int ("read-speed", "Read speed", "Read from device at specified speed (-1 and 0 = full speed)", -1, G_MAXINT, DEFAULT_READ_SPEED, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_PARANOIA_MODE, g_param_spec_flags ("paranoia-mode", "Paranoia mode", "Type of checking to perform", GST_TYPE_CD_PARANOIA_MODE, DEFAULT_PARANOIA_MODE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_SEARCH_OVERLAP, g_param_spec_int ("search-overlap", "Search overlap", "Force minimum overlap search during verification to n sectors", -1, 75, DEFAULT_SEARCH_OVERLAP, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); /** * GstCdParanoiaSrc:cache-size: * * Set CD cache size to n sectors (-1 = auto) */ g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_CACHE_SIZE, g_param_spec_int ("cache-size", "Cache size", "Set CD cache size to n sectors (-1 = auto)", -1, G_MAXINT, DEFAULT_CACHE_SIZE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); /* FIXME: we don't really want signals for this, but messages on the bus, * but then we can't check any longer whether anyone is interested in them */ /** * GstCdParanoiaSrc::transport-error: * @cdparanoia: The CdParanoia instance * @sector: The sector number at which the error was encountered. * * This signal is emitted whenever an error occurs while reading. * CdParanoia will attempt to recover the data. */ cdpsrc_signals[TRANSPORT_ERROR] = g_signal_new ("transport-error", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstCdParanoiaSrcClass, transport_error), NULL, NULL, g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT); /** * GstCdParanoiaSrc::uncorrected-error: * @cdparanoia: The CdParanoia instance * @sector: The sector number at which the error was encountered. * * This signal is emitted whenever an uncorrectable error occurs while * reading. The data could not be read. */ cdpsrc_signals[UNCORRECTED_ERROR] = g_signal_new ("uncorrected-error", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstCdParanoiaSrcClass, uncorrected_error), NULL, NULL, g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT); }
static void gst_theora_enc_class_init (GstTheoraEncClass * klass) { GObjectClass *gobject_class = (GObjectClass *) klass; GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass); gobject_class->set_property = theora_enc_set_property; gobject_class->get_property = theora_enc_get_property; gobject_class->finalize = theora_enc_finalize; g_object_class_install_property (gobject_class, ARG_CENTER, g_param_spec_boolean ("center", "Center", "Center image when sizes not multiple of 16", THEORA_DEF_CENTER, (GParamFlags) G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, ARG_BORDER, g_param_spec_enum ("border", "Border", "Border color to add when sizes not multiple of 16", GST_TYPE_BORDER_MODE, THEORA_DEF_BORDER, (GParamFlags) G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); /* general encoding stream options */ g_object_class_install_property (gobject_class, ARG_BITRATE, g_param_spec_int ("bitrate", "Bitrate", "Compressed video bitrate (kbps)", 0, (1 << 24) - 1, THEORA_DEF_BITRATE, (GParamFlags) G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, ARG_QUALITY, g_param_spec_int ("quality", "Quality", "Video quality", 0, 63, THEORA_DEF_QUALITY, (GParamFlags) G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, ARG_QUICK, g_param_spec_boolean ("quick", "Quick", "Quick encoding", THEORA_DEF_QUICK, (GParamFlags) G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, ARG_KEYFRAME_AUTO, g_param_spec_boolean ("keyframe-auto", "Keyframe Auto", "Automatic keyframe detection", THEORA_DEF_KEYFRAME_AUTO, (GParamFlags) G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, ARG_KEYFRAME_FREQ, g_param_spec_int ("keyframe-freq", "Keyframe frequency", "Keyframe frequency", 1, 32768, THEORA_DEF_KEYFRAME_FREQ, (GParamFlags) G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, ARG_KEYFRAME_FREQ_FORCE, g_param_spec_int ("keyframe-force", "Keyframe force", "Force keyframe every N frames", 1, 32768, THEORA_DEF_KEYFRAME_FREQ_FORCE, (GParamFlags) G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, ARG_KEYFRAME_THRESHOLD, g_param_spec_int ("keyframe-threshold", "Keyframe threshold", "Keyframe threshold", 0, 32768, THEORA_DEF_KEYFRAME_THRESHOLD, (GParamFlags) G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, ARG_KEYFRAME_MINDISTANCE, g_param_spec_int ("keyframe-mindistance", "Keyframe mindistance", "Keyframe mindistance", 1, 32768, THEORA_DEF_KEYFRAME_MINDISTANCE, (GParamFlags) G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, ARG_NOISE_SENSITIVITY, g_param_spec_int ("noise-sensitivity", "Noise sensitivity", "Noise sensitivity", 0, 32768, THEORA_DEF_NOISE_SENSITIVITY, (GParamFlags) G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, ARG_SHARPNESS, g_param_spec_int ("sharpness", "Sharpness", "Sharpness", 0, 2, THEORA_DEF_SHARPNESS, (GParamFlags) G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); gstelement_class->change_state = theora_enc_change_state; GST_DEBUG_CATEGORY_INIT (theoraenc_debug, "theoraenc", 0, "Theora encoder"); use_old_granulepos = (theora_version_number () <= 0x00030200); }
static void gst_hls_sink2_class_init (GstHlsSink2Class * klass) { GObjectClass *gobject_class; GstElementClass *element_class; GstBinClass *bin_class; gobject_class = (GObjectClass *) klass; element_class = GST_ELEMENT_CLASS (klass); bin_class = GST_BIN_CLASS (klass); gst_element_class_add_static_pad_template (element_class, &video_template); gst_element_class_add_static_pad_template (element_class, &audio_template); gst_element_class_set_static_metadata (element_class, "HTTP Live Streaming sink", "Sink", "HTTP Live Streaming sink", "Alessandro Decina <*****@*****.**>, " "Sebastian Dröge <*****@*****.**>"); element_class->change_state = GST_DEBUG_FUNCPTR (gst_hls_sink2_change_state); element_class->request_new_pad = GST_DEBUG_FUNCPTR (gst_hls_sink2_request_new_pad); element_class->release_pad = GST_DEBUG_FUNCPTR (gst_hls_sink2_release_pad); bin_class->handle_message = gst_hls_sink2_handle_message; gobject_class->dispose = gst_hls_sink2_dispose; gobject_class->finalize = gst_hls_sink2_finalize; gobject_class->set_property = gst_hls_sink2_set_property; gobject_class->get_property = gst_hls_sink2_get_property; g_object_class_install_property (gobject_class, PROP_LOCATION, g_param_spec_string ("location", "File Location", "Location of the file to write", DEFAULT_LOCATION, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_PLAYLIST_LOCATION, g_param_spec_string ("playlist-location", "Playlist Location", "Location of the playlist to write", DEFAULT_PLAYLIST_LOCATION, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_PLAYLIST_ROOT, g_param_spec_string ("playlist-root", "Playlist Root", "Location of the playlist to write", DEFAULT_PLAYLIST_ROOT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_MAX_FILES, g_param_spec_uint ("max-files", "Max files", "Maximum number of files to keep on disk. Once the maximum is reached," "old files start to be deleted to make room for new ones.", 0, G_MAXUINT, DEFAULT_MAX_FILES, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_TARGET_DURATION, g_param_spec_uint ("target-duration", "Target duration", "The target duration in seconds of a segment/file. " "(0 - disabled, useful for management of segment duration by the " "streaming server)", 0, G_MAXUINT, DEFAULT_TARGET_DURATION, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_PLAYLIST_LENGTH, g_param_spec_uint ("playlist-length", "Playlist length", "Length of HLS playlist. To allow players to conform to section 6.3.3 " "of the HLS specification, this should be at least 3. If set to 0, " "the playlist will be infinite.", 0, G_MAXUINT, DEFAULT_PLAYLIST_LENGTH, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); }
static GstStateChangeReturn gst_glimage_sink_change_state (GstElement * element, GstStateChange transition) { GstGLImageSink *glimage_sink; GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS; GST_DEBUG ("change state"); glimage_sink = GST_GLIMAGE_SINK (element); switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: break; case GST_STATE_CHANGE_READY_TO_PAUSED: g_atomic_int_set (&glimage_sink->to_quit, 0); if (!glimage_sink->display) { GstGLWindow *window; GError *error = NULL; if (!gst_gl_ensure_display (glimage_sink, &glimage_sink->display)) return GST_STATE_CHANGE_FAILURE; glimage_sink->context = gst_gl_context_new (glimage_sink->display); window = gst_gl_context_get_window (glimage_sink->context); if (!glimage_sink->window_id && !glimage_sink->new_window_id) gst_video_overlay_prepare_window_handle (GST_VIDEO_OVERLAY (glimage_sink)); if (glimage_sink->window_id != glimage_sink->new_window_id) { glimage_sink->window_id = glimage_sink->new_window_id; gst_gl_window_set_window_handle (window, glimage_sink->window_id); } if (!gst_gl_context_create (glimage_sink->context, glimage_sink->other_context, &error)) { GST_ELEMENT_ERROR (glimage_sink, RESOURCE, NOT_FOUND, ("%s", error->message), (NULL)); if (glimage_sink->display) { gst_object_unref (glimage_sink->display); glimage_sink->display = NULL; } gst_object_unref (glimage_sink->context); gst_object_unref (window); return GST_STATE_CHANGE_FAILURE; } /* setup callbacks */ gst_gl_window_set_resize_callback (window, GST_GL_WINDOW_RESIZE_CB (gst_glimage_sink_on_resize), gst_object_ref (glimage_sink), (GDestroyNotify) gst_object_unref); gst_gl_window_set_draw_callback (window, GST_GL_WINDOW_CB (gst_glimage_sink_on_draw), gst_object_ref (glimage_sink), (GDestroyNotify) gst_object_unref); gst_gl_window_set_close_callback (window, GST_GL_WINDOW_CB (gst_glimage_sink_on_close), gst_object_ref (glimage_sink), (GDestroyNotify) gst_object_unref); gst_object_unref (window); } break; case GST_STATE_CHANGE_PAUSED_TO_PLAYING: break; default: break; } ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); if (ret == GST_STATE_CHANGE_FAILURE) return ret; switch (transition) { case GST_STATE_CHANGE_PLAYING_TO_PAUSED: break; case GST_STATE_CHANGE_PAUSED_TO_READY: { /* mark the redisplay_texture as unavailable (=0) * to avoid drawing */ GST_GLIMAGE_SINK_LOCK (glimage_sink); glimage_sink->redisplay_texture = 0; GST_GLIMAGE_SINK_UNLOCK (glimage_sink); if (glimage_sink->upload) { gst_object_unref (glimage_sink->upload); glimage_sink->upload = NULL; } glimage_sink->window_id = 0; //but do not reset glimage_sink->new_window_id if (glimage_sink->pool) { gst_buffer_pool_set_active (glimage_sink->pool, FALSE); gst_object_unref (glimage_sink->pool); glimage_sink->pool = NULL; } GST_VIDEO_SINK_WIDTH (glimage_sink) = 1; GST_VIDEO_SINK_HEIGHT (glimage_sink) = 1; if (glimage_sink->context) { GstGLWindow *window = gst_gl_context_get_window (glimage_sink->context); gst_gl_window_send_message (window, GST_GL_WINDOW_CB (gst_glimage_sink_cleanup_glthread), glimage_sink); gst_gl_window_set_resize_callback (window, NULL, NULL, NULL); gst_gl_window_set_draw_callback (window, NULL, NULL, NULL); gst_gl_window_set_close_callback (window, NULL, NULL, NULL); gst_object_unref (window); gst_object_unref (glimage_sink->context); glimage_sink->context = NULL; gst_object_unref (glimage_sink->display); glimage_sink->display = NULL; } break; } case GST_STATE_CHANGE_READY_TO_NULL: break; default: break; } return ret; }
static void gst_msdkvpp_class_init (GstMsdkVPPClass * klass) { GObjectClass *gobject_class; GstElementClass *element_class; GstBaseTransformClass *trans_class; GParamSpec *obj_properties[PROP_N] = { NULL, }; gobject_class = G_OBJECT_CLASS (klass); element_class = GST_ELEMENT_CLASS (klass); trans_class = GST_BASE_TRANSFORM_CLASS (klass); gobject_class->set_property = gst_msdkvpp_set_property; gobject_class->get_property = gst_msdkvpp_get_property; gobject_class->finalize = gst_msdkvpp_finalize; element_class->set_context = gst_msdkvpp_set_context; gst_element_class_add_static_pad_template (element_class, &gst_msdkvpp_src_factory); gst_element_class_add_static_pad_template (element_class, &gst_msdkvpp_sink_factory); gst_element_class_set_static_metadata (element_class, "MSDK Video Postprocessor", "Filter/Converter/Video;Filter/Converter/Video/Scaler;" "Filter/Effect/Video;Filter/Effect/Video/Deinterlace", "A MediaSDK Video Postprocessing Filter", "Sreerenj Balachandrn <*****@*****.**>"); trans_class->start = GST_DEBUG_FUNCPTR (gst_msdkvpp_start); trans_class->stop = GST_DEBUG_FUNCPTR (gst_msdkvpp_stop); trans_class->transform_caps = GST_DEBUG_FUNCPTR (gst_msdkvpp_transform_caps); trans_class->fixate_caps = GST_DEBUG_FUNCPTR (gst_msdkvpp_fixate_caps); trans_class->set_caps = GST_DEBUG_FUNCPTR (gst_msdkvpp_set_caps); trans_class->transform = GST_DEBUG_FUNCPTR (gst_msdkvpp_transform); trans_class->propose_allocation = GST_DEBUG_FUNCPTR (gst_msdkvpp_propose_allocation); trans_class->decide_allocation = GST_DEBUG_FUNCPTR (gst_msdkvpp_decide_allocation); trans_class->prepare_output_buffer = GST_DEBUG_FUNCPTR (gst_msdkvpp_prepare_output_buffer); obj_properties[PROP_HARDWARE] = g_param_spec_boolean ("hardware", "Hardware", "Enable hardware VPP", PROP_HARDWARE_DEFAULT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); obj_properties[PROP_ASYNC_DEPTH] = g_param_spec_uint ("async-depth", "Async Depth", "Depth of asynchronous pipeline", 1, 1, PROP_ASYNC_DEPTH_DEFAULT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); obj_properties[PROP_DENOISE] = g_param_spec_uint ("denoise", "Denoising factor", "Denoising Factor", 0, 100, PROP_DENOISE_DEFAULT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); obj_properties[PROP_ROTATION] = g_param_spec_enum ("rotation", "Rotation", "Rotation Angle", gst_msdkvpp_rotation_get_type (), PROP_ROTATION_DEFAULT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); obj_properties[PROP_DEINTERLACE_MODE] = g_param_spec_enum ("deinterlace-mode", "Deinterlace Mode", "Deinterlace mode to use", gst_msdkvpp_deinterlace_mode_get_type (), PROP_DEINTERLACE_MODE_DEFAULT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); obj_properties[PROP_DEINTERLACE_METHOD] = g_param_spec_enum ("deinterlace-method", "Deinterlace Method", "Deinterlace method to use", gst_msdkvpp_deinterlace_method_get_type (), PROP_DEINTERLACE_METHOD_DEFAULT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); obj_properties[PROP_HUE] = g_param_spec_float ("hue", "Hue", "The hue of the video", -180, 180, PROP_HUE_DEFAULT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); obj_properties[PROP_SATURATION] = g_param_spec_float ("saturation", "Saturation", "The Saturation of the video", 0, 10, PROP_SATURATION_DEFAULT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); obj_properties[PROP_BRIGHTNESS] = g_param_spec_float ("brightness", "Brightness", "The Brightness of the video", -100, 100, PROP_BRIGHTNESS_DEFAULT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); obj_properties[PROP_CONTRAST] = g_param_spec_float ("contrast", "Contrast", "The Contrast of the video", 0, 10, PROP_CONTRAST_DEFAULT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); obj_properties[PROP_DETAIL] = g_param_spec_uint ("detail", "Detail", "The factor of detail/edge enhancement filter algorithm", 0, 100, PROP_DETAIL_DEFAULT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); obj_properties[PROP_MIRRORING] = g_param_spec_enum ("mirroring", "Mirroring", "The Mirroring type", gst_msdkvpp_mirroring_get_type (), PROP_MIRRORING_DEFAULT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); obj_properties[PROP_SCALING_MODE] = g_param_spec_enum ("scaling-mode", "Scaling Mode", "The Scaling mode to use", gst_msdkvpp_scaling_mode_get_type (), PROP_SCALING_MODE_DEFAULT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); obj_properties[PROP_FORCE_ASPECT_RATIO] = g_param_spec_boolean ("force-aspect-ratio", "Force Aspect Ratio", "When enabled, scaling will respect original aspect ratio", PROP_FORCE_ASPECT_RATIO_DEFAULT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); obj_properties[PROP_FRC_ALGORITHM] = g_param_spec_enum ("frc-algorithm", "FrameRateControl Algorithm", "The Framerate Control Alogorithm to use", gst_msdkvpp_frc_algorithm_get_type (), PROP_FRC_ALGORITHM_DEFAULT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); g_object_class_install_properties (gobject_class, PROP_N, obj_properties); }
static void gst_curl_smtp_sink_class_init (GstCurlSmtpSinkClass * klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GstBaseSinkClass *gstbasesink_class = (GstBaseSinkClass *) klass; GstCurlBaseSinkClass *gstcurlbasesink_class = (GstCurlBaseSinkClass *) klass; GstElementClass *element_class = GST_ELEMENT_CLASS (klass); GST_DEBUG_CATEGORY_INIT (gst_curl_smtp_sink_debug, "curlsmtpsink", 0, "curl smtp sink element"); GST_DEBUG_OBJECT (klass, "class_init"); gst_element_class_set_static_metadata (element_class, "Curl smtp sink", "Sink/Network", "Upload data over SMTP protocol using libcurl", "Patricia Muscalu <*****@*****.**>"); gstcurlbasesink_class->set_protocol_dynamic_options_unlocked = gst_curl_smtp_sink_set_payload_headers_unlocked; gstcurlbasesink_class->set_options_unlocked = gst_curl_smtp_sink_set_transfer_options_unlocked; gstcurlbasesink_class->set_mime_type = gst_curl_smtp_sink_set_mime_type; gstcurlbasesink_class->prepare_transfer = gst_curl_smtp_sink_prepare_transfer; gstcurlbasesink_class->transfer_data_buffer = gst_curl_smtp_sink_transfer_data_buffer; gstcurlbasesink_class->flush_data_unlocked = gst_curl_smtp_sink_flush_data_unlocked; gstcurlbasesink_class->has_buffered_data_unlocked = gst_curl_smtp_sink_has_buffered_data_unlocked; gstbasesink_class->event = gst_curl_smtp_sink_event; gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_curl_smtp_sink_finalize); gobject_class->set_property = gst_curl_smtp_sink_set_property; gobject_class->get_property = gst_curl_smtp_sink_get_property; g_object_class_install_property (gobject_class, PROP_MAIL_RCPT, g_param_spec_string ("mail-rcpt", "Mail recipient", "Single address that the given mail should get sent to", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_MAIL_FROM, g_param_spec_string ("mail-from", "Mail sender", "Single address that the given mail should get sent from", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_CONTENT_TYPE, g_param_spec_string ("content-type", "Content type", "The mime type of the body of the request", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_SUBJECT, g_param_spec_string ("subject", "UTF-8 encoded mail subject", "Mail subject", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_MESSAGE_BODY, g_param_spec_string ("message-body", "UTF-8 encoded message body", "Message body", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_USE_SSL, g_param_spec_boolean ("use-ssl", "Use SSL", "Use SSL/TLS for the connection", DEFAULT_USE_SSL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_NBR_ATTACHMENTS, g_param_spec_int ("nbr-attachments", "Number attachments", "Number attachments to send", G_MININT, G_MAXINT, DEFAULT_NBR_ATTACHMENTS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_POP_USER_NAME, g_param_spec_string ("pop-user", "User name", "User name to use for POP server authentication", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_POP_USER_PASSWD, g_param_spec_string ("pop-passwd", "User password", "User password to use for POP server authentication", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_POP_LOCATION, g_param_spec_string ("pop-location", "POP location", "URL POP used for authentication", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); }
static void gst_mpg123_audio_dec_class_init (GstMpg123AudioDecClass * klass) { GstAudioDecoderClass *base_class; GstElementClass *element_class; GstPadTemplate *src_template, *sink_template; int error; GST_DEBUG_CATEGORY_INIT (mpg123_debug, "mpg123", 0, "mpg123 mp3 decoder"); base_class = GST_AUDIO_DECODER_CLASS (klass); element_class = GST_ELEMENT_CLASS (klass); gst_element_class_set_static_metadata (element_class, "mpg123 mp3 decoder", "Codec/Decoder/Audio", "Decodes mp3 streams using the mpg123 library", "Carlos Rafael Giani <*****@*****.**>"); /* Not using static pad template for srccaps, since the comma-separated list * of formats needs to be created depending on whatever mpg123 supports */ { const int *format_list; const long *rates_list; size_t num, i; GString *s; GstCaps *src_template_caps; s = g_string_new ("audio/x-raw, "); mpg123_encodings (&format_list, &num); g_string_append (s, "format = { "); for (i = 0; i < num; ++i) { switch (format_list[i]) { case MPG123_ENC_SIGNED_16: g_string_append (s, (i > 0) ? ", " : ""); g_string_append (s, GST_AUDIO_NE (S16)); break; case MPG123_ENC_UNSIGNED_16: g_string_append (s, (i > 0) ? ", " : ""); g_string_append (s, GST_AUDIO_NE (U16)); break; case MPG123_ENC_SIGNED_24: g_string_append (s, (i > 0) ? ", " : ""); g_string_append (s, GST_AUDIO_NE (S24)); break; case MPG123_ENC_UNSIGNED_24: g_string_append (s, (i > 0) ? ", " : ""); g_string_append (s, GST_AUDIO_NE (U24)); break; case MPG123_ENC_SIGNED_32: g_string_append (s, (i > 0) ? ", " : ""); g_string_append (s, GST_AUDIO_NE (S32)); break; case MPG123_ENC_UNSIGNED_32: g_string_append (s, (i > 0) ? ", " : ""); g_string_append (s, GST_AUDIO_NE (U32)); break; case MPG123_ENC_FLOAT_32: g_string_append (s, (i > 0) ? ", " : ""); g_string_append (s, GST_AUDIO_NE (F32)); break; default: GST_DEBUG ("Ignoring mpg123 format %d", format_list[i]); break; } } g_string_append (s, " }, "); mpg123_rates (&rates_list, &num); g_string_append (s, "rate = (int) { "); for (i = 0; i < num; ++i) { g_string_append_printf (s, "%s%lu", (i > 0) ? ", " : "", rates_list[i]); } g_string_append (s, "}, "); g_string_append (s, "channels = (int) [ 1, 2 ], "); g_string_append (s, "layout = (string) interleaved"); src_template_caps = gst_caps_from_string (s->str); src_template = gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS, src_template_caps); g_string_free (s, TRUE); } sink_template = gst_static_pad_template_get (&static_sink_template); gst_element_class_add_pad_template (element_class, sink_template); gst_element_class_add_pad_template (element_class, src_template); base_class->start = GST_DEBUG_FUNCPTR (gst_mpg123_audio_dec_start); base_class->stop = GST_DEBUG_FUNCPTR (gst_mpg123_audio_dec_stop); base_class->handle_frame = GST_DEBUG_FUNCPTR (gst_mpg123_audio_dec_handle_frame); base_class->set_format = GST_DEBUG_FUNCPTR (gst_mpg123_audio_dec_set_format); base_class->flush = GST_DEBUG_FUNCPTR (gst_mpg123_audio_dec_flush); error = mpg123_init (); if (G_UNLIKELY (error != MPG123_OK)) GST_ERROR ("Could not initialize mpg123 library: %s", mpg123_plain_strerror (error)); else GST_INFO ("mpg123 library initialized"); }
static void gst_fake_src_class_init (GstFakeSrcClass * klass) { GObjectClass *gobject_class; GstElementClass *gstelement_class; GstBaseSrcClass *gstbase_src_class; gobject_class = G_OBJECT_CLASS (klass); gstelement_class = GST_ELEMENT_CLASS (klass); gstbase_src_class = GST_BASE_SRC_CLASS (klass); gobject_class->finalize = gst_fake_src_finalize; gobject_class->set_property = gst_fake_src_set_property; gobject_class->get_property = gst_fake_src_get_property; /* FIXME: this is not implemented; would make sense once basesrc and fakesrc support multiple pads g_object_class_install_property (gobject_class, PROP_OUTPUT, g_param_spec_enum ("output", "output", "Output method (currently unused)", GST_TYPE_FAKE_SRC_OUTPUT, DEFAULT_OUTPUT, G_PARAM_READWRITE)); */ g_object_class_install_property (gobject_class, PROP_DATA, g_param_spec_enum ("data", "data", "Data allocation method", GST_TYPE_FAKE_SRC_DATA, DEFAULT_DATA, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_SIZETYPE, g_param_spec_enum ("sizetype", "sizetype", "How to determine buffer sizes", GST_TYPE_FAKE_SRC_SIZETYPE, DEFAULT_SIZETYPE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_SIZEMIN, g_param_spec_int ("sizemin", "sizemin", "Minimum buffer size", 0, G_MAXINT, DEFAULT_SIZEMIN, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_SIZEMAX, g_param_spec_int ("sizemax", "sizemax", "Maximum buffer size", 0, G_MAXINT, DEFAULT_SIZEMAX, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_PARENTSIZE, g_param_spec_int ("parentsize", "parentsize", "Size of parent buffer for sub-buffered allocation", 0, G_MAXINT, DEFAULT_PARENTSIZE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_FILLTYPE, g_param_spec_enum ("filltype", "filltype", "How to fill the buffer, if at all", GST_TYPE_FAKE_SRC_FILLTYPE, DEFAULT_FILLTYPE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_DATARATE, g_param_spec_int ("datarate", "Datarate", "Timestamps buffers with number of bytes per second (0 = none)", 0, G_MAXINT, DEFAULT_DATARATE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_SYNC, g_param_spec_boolean ("sync", "Sync", "Sync to the clock to the datarate", DEFAULT_SYNC, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); /* FIXME 2.0: Remove unused pattern property. Not implemented */ g_object_class_install_property (gobject_class, PROP_PATTERN, g_param_spec_string ("pattern", "pattern", "Set the pattern (unused)", DEFAULT_PATTERN, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); pspec_last_message = g_param_spec_string ("last-message", "last-message", "The last status message", NULL, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); g_object_class_install_property (gobject_class, PROP_LAST_MESSAGE, pspec_last_message); g_object_class_install_property (gobject_class, PROP_SILENT, g_param_spec_boolean ("silent", "Silent", "Don't produce last_message events", DEFAULT_SILENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_SIGNAL_HANDOFFS, g_param_spec_boolean ("signal-handoffs", "Signal handoffs", "Send a signal before pushing the buffer", DEFAULT_SIGNAL_HANDOFFS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_DUMP, g_param_spec_boolean ("dump", "Dump", "Dump buffer contents to stdout", DEFAULT_DUMP, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_CAN_ACTIVATE_PUSH, g_param_spec_boolean ("can-activate-push", "Can activate push", "Can activate in push mode", DEFAULT_CAN_ACTIVATE_PUSH, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_CAN_ACTIVATE_PULL, g_param_spec_boolean ("can-activate-pull", "Can activate pull", "Can activate in pull mode", DEFAULT_CAN_ACTIVATE_PULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_IS_LIVE, g_param_spec_boolean ("is-live", "Is this a live source", "True if the element cannot produce data in PAUSED", FALSE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS)); /** * GstFakeSrc:format * * Set the format of the newsegment events to produce. */ g_object_class_install_property (gobject_class, PROP_FORMAT, g_param_spec_enum ("format", "Format", "The format of the segment events", GST_TYPE_FORMAT, DEFAULT_FORMAT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); /** * GstFakeSrc::handoff: * @fakesrc: the fakesrc instance * @buffer: the buffer that will be pushed * @pad: the pad that will sent it * * This signal gets emitted before sending the buffer. */ gst_fake_src_signals[SIGNAL_HANDOFF] = g_signal_new ("handoff", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstFakeSrcClass, handoff), NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 2, GST_TYPE_BUFFER | G_SIGNAL_TYPE_STATIC_SCOPE, GST_TYPE_PAD); gst_element_class_set_static_metadata (gstelement_class, "Fake Source", "Source", "Push empty (no data) buffers around", "Erik Walthinsen <*****@*****.**>, " "Wim Taymans <*****@*****.**>"); gst_element_class_add_pad_template (gstelement_class, gst_static_pad_template_get (&srctemplate)); gstbase_src_class->is_seekable = GST_DEBUG_FUNCPTR (gst_fake_src_is_seekable); gstbase_src_class->start = GST_DEBUG_FUNCPTR (gst_fake_src_start); gstbase_src_class->stop = GST_DEBUG_FUNCPTR (gst_fake_src_stop); gstbase_src_class->event = GST_DEBUG_FUNCPTR (gst_fake_src_event_handler); gstbase_src_class->get_times = GST_DEBUG_FUNCPTR (gst_fake_src_get_times); gstbase_src_class->create = GST_DEBUG_FUNCPTR (gst_fake_src_create); }
static void gst_video_detect_class_init (GstSimpleVideoMarkDetectClass * klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GstBaseTransformClass *base_transform_class = GST_BASE_TRANSFORM_CLASS (klass); GstVideoFilterClass *video_filter_class = GST_VIDEO_FILTER_CLASS (klass); gst_element_class_add_pad_template (GST_ELEMENT_CLASS (klass), gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS, gst_caps_from_string (VIDEO_CAPS))); gst_element_class_add_pad_template (GST_ELEMENT_CLASS (klass), gst_pad_template_new ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, gst_caps_from_string (VIDEO_CAPS))); gst_element_class_set_static_metadata (GST_ELEMENT_CLASS (klass), "Video detecter", "Filter/Effect/Video", "Detect patterns in a video signal", "Wim Taymans <*****@*****.**>"); gobject_class->set_property = gst_video_detect_set_property; gobject_class->get_property = gst_video_detect_get_property; gobject_class->dispose = gst_video_detect_dispose; gobject_class->finalize = gst_video_detect_finalize; base_transform_class->start = GST_DEBUG_FUNCPTR (gst_video_detect_start); base_transform_class->stop = GST_DEBUG_FUNCPTR (gst_video_detect_stop); video_filter_class->set_info = GST_DEBUG_FUNCPTR (gst_video_detect_set_info); video_filter_class->transform_frame_ip = GST_DEBUG_FUNCPTR (gst_video_detect_transform_frame_ip); g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_MESSAGE, g_param_spec_boolean ("message", "Message", "Post detected data as bus messages", DEFAULT_MESSAGE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_PATTERN_WIDTH, g_param_spec_int ("pattern-width", "Pattern width", "The width of the pattern markers", 1, G_MAXINT, DEFAULT_PATTERN_WIDTH, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_PATTERN_HEIGHT, g_param_spec_int ("pattern-height", "Pattern height", "The height of the pattern markers", 1, G_MAXINT, DEFAULT_PATTERN_HEIGHT, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_PATTERN_COUNT, g_param_spec_int ("pattern-count", "Pattern count", "The number of pattern markers", 0, G_MAXINT, DEFAULT_PATTERN_COUNT, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_PATTERN_DATA_COUNT, g_param_spec_int ("pattern-data-count", "Pattern data count", "The number of extra data pattern markers", 0, G_MAXINT, DEFAULT_PATTERN_DATA_COUNT, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_PATTERN_CENTER, g_param_spec_double ("pattern-center", "Pattern center", "The center of the black/white separation (0.0 = lowest, 1.0 highest)", 0.0, 1.0, DEFAULT_PATTERN_CENTER, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_PATTERN_SENSITIVITY, g_param_spec_double ("pattern-sensitivity", "Pattern sensitivity", "The sensitivity around the center for detecting the markers " "(0.0 = lowest, 1.0 highest)", 0.0, 1.0, DEFAULT_PATTERN_SENSITIVITY, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_LEFT_OFFSET, g_param_spec_int ("left-offset", "Left Offset", "The offset from the left border where the pattern starts", 0, G_MAXINT, DEFAULT_LEFT_OFFSET, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_BOTTOM_OFFSET, g_param_spec_int ("bottom-offset", "Bottom Offset", "The offset from the bottom border where the pattern starts", 0, G_MAXINT, DEFAULT_BOTTOM_OFFSET, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS)); }
static void cogl_gst_video_sink_class_init (CoglGstVideoSinkClass *klass) { GObjectClass *go_class = G_OBJECT_CLASS (klass); GstBaseSinkClass *gb_class = GST_BASE_SINK_CLASS (klass); GstElementClass *ge_class = GST_ELEMENT_CLASS (klass); GstPadTemplate *pad_template; GParamSpec *pspec; g_type_class_add_private (klass, sizeof (CoglGstVideoSinkPrivate)); go_class->set_property = cogl_gst_video_sink_set_property; go_class->get_property = cogl_gst_video_sink_get_property; go_class->dispose = cogl_gst_video_sink_dispose; go_class->finalize = cogl_gst_video_sink_finalize; pad_template = gst_static_pad_template_get (&sinktemplate_all); gst_element_class_add_pad_template (ge_class, pad_template); gst_element_class_set_metadata (ge_class, "Cogl video sink", "Sink/Video", "Sends video data from GStreamer to a " "Cogl pipeline", "Jonathan Matthew <*****@*****.**>, " "Matthew Allum <[email protected], " "Chris Lord <*****@*****.**>, " "Plamena Manolova " "<*****@*****.**>"); gb_class->render = _cogl_gst_video_sink_render; gb_class->preroll = _cogl_gst_video_sink_render; gb_class->start = cogl_gst_video_sink_start; gb_class->stop = cogl_gst_video_sink_stop; gb_class->set_caps = cogl_gst_video_sink_set_caps; gb_class->get_caps = cogl_gst_video_sink_get_caps; pspec = g_param_spec_int ("update-priority", "Update Priority", "Priority of video updates in the thread", -G_MAXINT, G_MAXINT, COGL_GST_DEFAULT_PRIORITY, COGL_GST_PARAM_READWRITE); g_object_class_install_property (go_class, PROP_UPDATE_PRIORITY, pspec); video_sink_signals[PIPELINE_READY_SIGNAL] = g_signal_new ("pipeline-ready", COGL_GST_TYPE_VIDEO_SINK, G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (CoglGstVideoSinkClass, pipeline_ready), NULL, /* accumulator */ NULL, /* accu_data */ g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0 /* n_params */); video_sink_signals[NEW_FRAME_SIGNAL] = g_signal_new ("new-frame", COGL_GST_TYPE_VIDEO_SINK, G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (CoglGstVideoSinkClass, new_frame), NULL, /* accumulator */ NULL, /* accu_data */ g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0 /* n_params */); }
static void gst_identity_class_init (GstIdentityClass * klass) { GObjectClass *gobject_class; GstElementClass *gstelement_class; GstBaseTransformClass *gstbasetrans_class; gobject_class = G_OBJECT_CLASS (klass); gstelement_class = GST_ELEMENT_CLASS (klass); gstbasetrans_class = GST_BASE_TRANSFORM_CLASS (klass); gobject_class->set_property = gst_identity_set_property; gobject_class->get_property = gst_identity_get_property; g_object_class_install_property (gobject_class, PROP_SLEEP_TIME, g_param_spec_uint ("sleep-time", "Sleep time", "Microseconds to sleep between processing", 0, G_MAXUINT, DEFAULT_SLEEP_TIME, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_ERROR_AFTER, g_param_spec_int ("error-after", "Error After", "Error after N buffers", G_MININT, G_MAXINT, DEFAULT_ERROR_AFTER, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_DROP_PROBABILITY, g_param_spec_float ("drop-probability", "Drop Probability", "The Probability a buffer is dropped", 0.0, 1.0, DEFAULT_DROP_PROBABILITY, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_DATARATE, g_param_spec_int ("datarate", "Datarate", "(Re)timestamps buffers with number of bytes per second (0 = inactive)", 0, G_MAXINT, DEFAULT_DATARATE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_SILENT, g_param_spec_boolean ("silent", "silent", "silent", DEFAULT_SILENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_SINGLE_SEGMENT, g_param_spec_boolean ("single-segment", "Single Segment", "Timestamp buffers and eat segments so as to appear as one segment", DEFAULT_SINGLE_SEGMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); pspec_last_message = g_param_spec_string ("last-message", "last-message", "last-message", NULL, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); g_object_class_install_property (gobject_class, PROP_LAST_MESSAGE, pspec_last_message); g_object_class_install_property (gobject_class, PROP_DUMP, g_param_spec_boolean ("dump", "Dump", "Dump buffer contents to stdout", DEFAULT_DUMP, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_SYNC, g_param_spec_boolean ("sync", "Synchronize", "Synchronize to pipeline clock", DEFAULT_SYNC, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_CHECK_IMPERFECT_TIMESTAMP, g_param_spec_boolean ("check-imperfect-timestamp", "Check for discontiguous timestamps", "Send element messages if timestamps and durations do not match up", DEFAULT_CHECK_IMPERFECT_TIMESTAMP, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_CHECK_IMPERFECT_OFFSET, g_param_spec_boolean ("check-imperfect-offset", "Check for discontiguous offset", "Send element messages if offset and offset_end do not match up", DEFAULT_CHECK_IMPERFECT_OFFSET, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); /** * GstIdentity:signal-handoffs * * If set to #TRUE, the identity will emit a handoff signal when handling a buffer. * When set to #FALSE, no signal will be emited, which might improve performance. */ g_object_class_install_property (gobject_class, PROP_SIGNAL_HANDOFFS, g_param_spec_boolean ("signal-handoffs", "Signal handoffs", "Send a signal before pushing the buffer", DEFAULT_SIGNAL_HANDOFFS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); /** * GstIdentity::handoff: * @identity: the identity instance * @buffer: the buffer that just has been received * @pad: the pad that received it * * This signal gets emitted before passing the buffer downstream. */ gst_identity_signals[SIGNAL_HANDOFF] = g_signal_new ("handoff", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstIdentityClass, handoff), NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 1, GST_TYPE_BUFFER | G_SIGNAL_TYPE_STATIC_SCOPE); gobject_class->finalize = gst_identity_finalize; gst_element_class_set_static_metadata (gstelement_class, "Identity", "Generic", "Pass data without modification", "Erik Walthinsen <*****@*****.**>"); gst_element_class_add_pad_template (gstelement_class, gst_static_pad_template_get (&srctemplate)); gst_element_class_add_pad_template (gstelement_class, gst_static_pad_template_get (&sinktemplate)); gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_identity_change_state); gstbasetrans_class->sink_event = GST_DEBUG_FUNCPTR (gst_identity_sink_event); gstbasetrans_class->transform_ip = GST_DEBUG_FUNCPTR (gst_identity_transform_ip); gstbasetrans_class->start = GST_DEBUG_FUNCPTR (gst_identity_start); gstbasetrans_class->stop = GST_DEBUG_FUNCPTR (gst_identity_stop); }
/****************************************************************************** * gst_tidmaivideosink_class_init ******************************************************************************/ static void gst_tidmaivideosink_class_init(GstTIDmaiVideoSinkClass * klass) { GObjectClass *gobject_class; GstElementClass *gstelement_class; GstBaseSinkClass *gstbase_sink_class; gobject_class = G_OBJECT_CLASS(klass); gstelement_class = GST_ELEMENT_CLASS(klass); gstbase_sink_class = GST_BASE_SINK_CLASS(klass); gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_tidmaivideosink_set_property); gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_tidmaivideosink_get_property); g_object_class_install_property(gobject_class, PROP_DISPLAYSTD, g_param_spec_string("displayStd", "Display Standard", "Use V4L2 or FBDev for Video Display", NULL, G_PARAM_READWRITE)); g_object_class_install_property(gobject_class, PROP_DISPLAYDEVICE, g_param_spec_string("displayDevice", "Display Device", "Video device to use (usually /dev/video0", NULL, G_PARAM_READWRITE)); g_object_class_install_property(gobject_class, PROP_VIDEOSTD, g_param_spec_string("videoStd", "Video Standard", "Video Standard used\n" "\tAUTO (if supported), CIF, SIF_NTSC, SIF_PAL, VGA, D1_NTSC\n" "\tD1_PAL, 480P, 576P, 720P_60, 720P_50, 1080I_30, 1080I_25\n" "\t1080P_30, 1080P_25, 1080P_24, PRGB\n", NULL, G_PARAM_READWRITE)); g_object_class_install_property(gobject_class, PROP_VIDEOOUTPUT, g_param_spec_string("videoOutput", "Video Output", "Output used to display video (i.e. Composite, Component, " "LCD, DVI)", NULL, G_PARAM_READWRITE)); g_object_class_install_property(gobject_class, PROP_AUTOSELECT, g_param_spec_boolean("autoselect", "Auto Select the VideoStd", "Automatically select the Video Standard to use based on " "the video input. This only works when the upstream element " "sets the video size attributes in the buffer", FALSE, G_PARAM_READWRITE)); g_object_class_install_property(gobject_class, PROP_NUMBUFS, g_param_spec_int("numBufs", "Number of Video Buffers", "Number of video buffers allocated by the driver", -1, G_MAXINT, -1, G_PARAM_READWRITE)); #if PLATFORM == omap35x g_object_class_install_property(gobject_class, PROP_ROTATION, g_param_spec_int("rotation", "Rotation angle", "Rotation angle " "(OMAP35x only)", -1, G_MAXINT, -1, G_PARAM_READWRITE)); #endif g_object_class_install_property(gobject_class, PROP_ACCEL_FRAME_COPY, g_param_spec_boolean("accelFrameCopy", "Accel frame copy", "Use hardware accelerated framecopy", TRUE, G_PARAM_READWRITE)); g_object_class_install_property(gobject_class, PROP_NOMEMCPY, g_param_spec_boolean("noCopy", "Enable support for pad-allocation (zero memcpy)", "Enable support for pad-allocation (zero memcpy)", FALSE, G_PARAM_READWRITE)); /*Positioning*/ g_object_class_install_property(gobject_class, PROP_X_POSITION, g_param_spec_int("x", "x position", "X positioning of" " frame in display", G_MININT, G_MAXINT, -1, G_PARAM_READWRITE)); g_object_class_install_property(gobject_class, PROP_Y_POSITION, g_param_spec_int("y", "y position", "Y positioning of" " frame in display", G_MININT, G_MAXINT, -1, G_PARAM_READWRITE)); gstbase_sink_class->set_caps = GST_DEBUG_FUNCPTR(gst_tidmaivideosink_set_caps); gstbase_sink_class->start = GST_DEBUG_FUNCPTR(gst_tidmaivideosink_start); gstbase_sink_class->stop = GST_DEBUG_FUNCPTR(gst_tidmaivideosink_stop); gstbase_sink_class->preroll = GST_DEBUG_FUNCPTR(gst_tidmaivideosink_preroll); gstbase_sink_class->render = GST_DEBUG_FUNCPTR(gst_tidmaivideosink_render); gstbase_sink_class->buffer_alloc = GST_DEBUG_FUNCPTR(gst_tidmaivideosink_buffer_alloc); }
static void gst_theora_dec_class_init (GstTheoraDecClass * klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GstElementClass *element_class = GST_ELEMENT_CLASS (klass); GstVideoDecoderClass *video_decoder_class = GST_VIDEO_DECODER_CLASS (klass); gobject_class->set_property = theora_dec_set_property; gobject_class->get_property = theora_dec_get_property; if (gst_theora_dec_ctl_is_supported (TH_DECCTL_SET_TELEMETRY_MV)) { g_object_class_install_property (gobject_class, PROP_TELEMETRY_MV, g_param_spec_int ("visualize-motion-vectors", "Visualize motion vectors", "Show motion vector selection overlaid on image. " "Value gives a mask for motion vector (MV) modes to show", 0, 0xffff, THEORA_DEF_TELEMETRY_MV, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); } if (gst_theora_dec_ctl_is_supported (TH_DECCTL_SET_TELEMETRY_MBMODE)) { g_object_class_install_property (gobject_class, PROP_TELEMETRY_MBMODE, g_param_spec_int ("visualize-macroblock-modes", "Visualize macroblock modes", "Show macroblock mode selection overlaid on image. " "Value gives a mask for macroblock (MB) modes to show", 0, 0xffff, THEORA_DEF_TELEMETRY_MBMODE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); } if (gst_theora_dec_ctl_is_supported (TH_DECCTL_SET_TELEMETRY_QI)) { g_object_class_install_property (gobject_class, PROP_TELEMETRY_QI, g_param_spec_int ("visualize-quantization-modes", "Visualize adaptive quantization modes", "Show adaptive quantization mode selection overlaid on image. " "Value gives a mask for quantization (QI) modes to show", 0, 0xffff, THEORA_DEF_TELEMETRY_QI, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); } if (gst_theora_dec_ctl_is_supported (TH_DECCTL_SET_TELEMETRY_BITS)) { /* FIXME: make this a boolean instead? The value scales the bars so * they're less wide. Default is to use full width, and anything else * doesn't seem particularly useful, since the smaller bars just disappear * then (they almost disappear for a value of 2 already). */ g_object_class_install_property (gobject_class, PROP_TELEMETRY_BITS, g_param_spec_int ("visualize-bit-usage", "Visualize bitstream usage breakdown", "Sets the bitstream breakdown visualization mode. " "Values influence the width of the bit usage bars to show", 0, 0xff, THEORA_DEF_TELEMETRY_BITS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); } gst_element_class_add_pad_template (element_class, gst_static_pad_template_get (&theora_dec_src_factory)); gst_element_class_add_pad_template (element_class, gst_static_pad_template_get (&theora_dec_sink_factory)); gst_element_class_set_static_metadata (element_class, "Theora video decoder", "Codec/Decoder/Video", "decode raw theora streams to raw YUV video", "Benjamin Otte <*****@*****.**>, Wim Taymans <*****@*****.**>"); video_decoder_class->start = GST_DEBUG_FUNCPTR (theora_dec_start); video_decoder_class->stop = GST_DEBUG_FUNCPTR (theora_dec_stop); video_decoder_class->reset = GST_DEBUG_FUNCPTR (theora_dec_reset); video_decoder_class->set_format = GST_DEBUG_FUNCPTR (theora_dec_set_format); video_decoder_class->parse = GST_DEBUG_FUNCPTR (theora_dec_parse); video_decoder_class->handle_frame = GST_DEBUG_FUNCPTR (theora_dec_handle_frame); video_decoder_class->decide_allocation = GST_DEBUG_FUNCPTR (theora_dec_decide_allocation); GST_DEBUG_CATEGORY_INIT (theoradec_debug, "theoradec", 0, "Theora decoder"); }
static void gst_time_overlay_base_init (gpointer g_class) { GstElementClass *element_class = GST_ELEMENT_CLASS (g_class); gst_element_class_set_details (element_class, &time_overlay_details); }
static void gst_test_camera_src_init (GstTestCameraSrc * self, GstTestCameraSrcClass * g_class) { GstElementClass *gstelement_class = GST_ELEMENT_CLASS (g_class); GstPadTemplate *template;
static void gst_glimage_sink_class_init (GstGLImageSinkClass * klass) { GObjectClass *gobject_class; GstElementClass *gstelement_class; GstBaseSinkClass *gstbasesink_class; GstElementClass *element_class; gobject_class = (GObjectClass *) klass; gstelement_class = (GstElementClass *) klass; gstbasesink_class = (GstBaseSinkClass *) klass; element_class = GST_ELEMENT_CLASS (klass); gobject_class->set_property = gst_glimage_sink_set_property; gobject_class->get_property = gst_glimage_sink_get_property; g_object_class_install_property (gobject_class, ARG_DISPLAY, g_param_spec_string ("display", "Display", "Display name", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_CLIENT_RESHAPE_CALLBACK, g_param_spec_pointer ("client-reshape-callback", "Client reshape callback", "Define a custom reshape callback in a client code", G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_CLIENT_DRAW_CALLBACK, g_param_spec_pointer ("client-draw-callback", "Client draw callback", "Define a custom draw callback in a client code", G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_CLIENT_DATA, g_param_spec_pointer ("client-data", "Client data", "Pass data to the draw and reshape callbacks", G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_FORCE_ASPECT_RATIO, g_param_spec_boolean ("force-aspect-ratio", "Force aspect ratio", "When enabled, scaling will respect original aspect ratio", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_PIXEL_ASPECT_RATIO, gst_param_spec_fraction ("pixel-aspect-ratio", "Pixel Aspect Ratio", "The pixel aspect ratio of the device", 0, 1, G_MAXINT, 1, 0, 1, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); gst_element_class_set_metadata (element_class, "OpenGL video sink", "Sink/Video", "A videosink based on OpenGL", "Julien Isorce <*****@*****.**>"); g_object_class_install_property (gobject_class, PROP_OTHER_CONTEXT, g_param_spec_object ("other-context", "External OpenGL context", "Give an external OpenGL context with which to share textures", GST_GL_TYPE_CONTEXT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); gst_element_class_add_pad_template (element_class, gst_static_pad_template_get (&gst_glimage_sink_template)); gobject_class->finalize = gst_glimage_sink_finalize; gstelement_class->change_state = gst_glimage_sink_change_state; gstelement_class->set_context = gst_glimage_sink_set_context; gstbasesink_class->query = GST_DEBUG_FUNCPTR (gst_glimage_sink_query); gstbasesink_class->set_caps = gst_glimage_sink_set_caps; gstbasesink_class->get_times = gst_glimage_sink_get_times; gstbasesink_class->preroll = gst_glimage_sink_render; gstbasesink_class->render = gst_glimage_sink_render; gstbasesink_class->propose_allocation = gst_glimage_sink_propose_allocation; gstbasesink_class->stop = gst_glimage_sink_stop; }