From 642fed71daf4b90970bf90a9206b148412d60b2c Mon Sep 17 00:00:00 2001 From: Edward Hervey Date: Mon, 18 Oct 2010 09:36:13 +0200 Subject: [PATCH] gst: Update to latest 0.10.31 core/base API --- configure.ac | 18 ++ gst/Makefile.am | 2 + gst/audio.defs | 33 +++ gst/base.defs | 11 +- gst/gst-0.10.31.ignore | 24 ++ gst/gst-pb-0.10.31.ignore | 31 +++ gst/gst.defs | 283 +++++++++++++++++++++ gst/gstversion.override.in | 2 + gst/pbutils.defs | 497 +++++++++++++++++++++++++++++++++++++ gst/video.defs | 25 ++ 10 files changed, 925 insertions(+), 1 deletion(-) create mode 100644 gst/gst-0.10.31.ignore create mode 100644 gst/gst-pb-0.10.31.ignore diff --git a/configure.ac b/configure.ac index 0f2e6ce5b5..89bddbd06f 100644 --- a/configure.ac +++ b/configure.ac @@ -174,6 +174,13 @@ then IGNORE_GST_0_10_30="" fi + if test $GST_MINOR_VERSION -lt "31" + then + IGNORE_GST_0_10_31="gst-0.10.31.ignore" + else + IGNORE_GST_0_10_31="" + fi + dnl plugins base if test $GST_PB_MINOR_VERSION -ge "22" then @@ -217,6 +224,13 @@ then else IGNORE_GST_PB_0_10_30="" fi + + if test $GST_PB_MINOR_VERSION -lt "31" + then + IGNORE_GST_PB_0_10_31="gst-pb-0.10.31.ignore" + else + IGNORE_GST_PB_0_10_31="" + fi else IGNORE_GST_0_10_18="" IGNORE_GST_0_10_20="" @@ -228,11 +242,13 @@ else IGNORE_GST_0_10_26="" IGNORE_GST_0_10_29="" IGNORE_GST_0_10_30="" + IGNORE_GST_0_10_31="" IGNORE_GST_PB_0_10_23="" IGNORE_GST_PB_0_10_25="" IGNORE_GST_PB_0_10_26="" IGNORE_GST_PB_0_10_29="" IGNORE_GST_PB_0_10_30="" + IGNORE_GST_PB_0_10_31="" AC_DEFINE_UNQUOTED(HAVE_GST_AUDIO, 1, [We can use the gst-audio library]) AC_DEFINE_UNQUOTED(HAVE_GST_VIDEO, 1, [We can use the gst-video library]) AC_DEFINE_UNQUOTED(HAVE_GST_TAG, 1, [We can use the gst-tag library]) @@ -247,11 +263,13 @@ AC_SUBST(IGNORE_GST_0_10_25) AC_SUBST(IGNORE_GST_0_10_26) AC_SUBST(IGNORE_GST_0_10_29) AC_SUBST(IGNORE_GST_0_10_30) +AC_SUBST(IGNORE_GST_0_10_31) AC_SUBST(IGNORE_GST_PB_0_10_23) AC_SUBST(IGNORE_GST_PB_0_10_25) AC_SUBST(IGNORE_GST_PB_0_10_26) AC_SUBST(IGNORE_GST_PB_0_10_29) AC_SUBST(IGNORE_GST_PB_0_10_30) +AC_SUBST(IGNORE_GST_PB_0_10_31) AM_CONDITIONAL(HAVE_GST_AUDIO, $HAVE_GST_AUDIO) AM_CONDITIONAL(HAVE_GST_VIDEO, $HAVE_GST_VIDEO) AM_CONDITIONAL(HAVE_GST_TAG, $HAVE_GST_TAG) diff --git a/gst/Makefile.am b/gst/Makefile.am index a80a59b0d1..192ecac923 100644 --- a/gst/Makefile.am +++ b/gst/Makefile.am @@ -34,11 +34,13 @@ versioned_overrides = \ gst-0.10.26.ignore \ gst-0.10.29.ignore \ gst-0.10.30.ignore \ + gst-0.10.31.ignore \ gst-pb-0.10.23.ignore \ gst-pb-0.10.25.ignore \ gst-pb-0.10.26.ignore \ gst-pb-0.10.29.ignore \ gst-pb-0.10.30.ignore \ + gst-pb-0.10.31.ignore \ gst-disable-loadsave.ignore INCLUDES = $(PYTHON_INCLUDES) diff --git a/gst/audio.defs b/gst/audio.defs index be8e7934ad..2385ebb361 100644 --- a/gst/audio.defs +++ b/gst/audio.defs @@ -256,6 +256,17 @@ ) ) +(define-function audio_clock_new_full + (c-name "gst_audio_clock_new_full") + (return-type "GstClock*") + (parameters + '("const-gchar*" "name") + '("GstAudioClockGetTimeFunc" "func") + '("gpointer" "user_data") + '("GDestroyNotify" "destroy_notify") + ) +) + (define-method reset (of-object "GstAudioClock") (c-name "gst_audio_clock_reset") @@ -282,6 +293,13 @@ ) ) +(define-function audio_clock_invalidate + (c-name "gst_audio_clock_invalidate") + (return-type "none") + (parameters + '("GstClock*" "clock") + ) +) ;; From gstaudiofilter.h @@ -413,6 +431,21 @@ (return-type "GstBaseAudioSinkSlaveMethod") ) +(define-method set_drift_tolerance + (of-object "GstBaseAudioSink") + (c-name "gst_base_audio_sink_set_drift_tolerance") + (return-type "none") + (parameters + '("gint64" "drift_tolerance") + ) +) + +(define-method get_drift_tolerance + (of-object "GstBaseAudioSink") + (c-name "gst_base_audio_sink_get_drift_tolerance") + (return-type "gint64") +) + ;; From gstbaseaudiosrc.h diff --git a/gst/base.defs b/gst/base.defs index a1995f8de1..16aa6923a6 100644 --- a/gst/base.defs +++ b/gst/base.defs @@ -135,6 +135,15 @@ ) ) +(define-method take_list + (of-object "GstAdapter") + (c-name "gst_adapter_take_list") + (return-type "GList*") + (parameters + '("guint" "nbytes") + ) +) + (define-method available (of-object "GstAdapter") (c-name "gst_adapter_available") @@ -288,7 +297,7 @@ (c-name "gst_base_sink_set_last_buffer_enabled") (return-type "none") (parameters - '("gboolean" "enable") + '("gboolean" "enabled") ) ) diff --git a/gst/gst-0.10.31.ignore b/gst/gst-0.10.31.ignore new file mode 100644 index 0000000000..d0b44e9e01 --- /dev/null +++ b/gst/gst-0.10.31.ignore @@ -0,0 +1,24 @@ +%% +ignore + gst_is_initialized + gst_buffer_list_iterator_add_list + gst_element_class_set_documentation_uri + gst_element_class_set_icon_name + gst_element_class_get_documentation_uri + gst_element_class_get_icon_name + gst_element_factory_list_is_type + gst_element_factory_list_get_elements + gst_element_factory_list_filter + gst_plugin_Feature_rank_compare_func + gst_query_add_buffering_range + gst_query_get_n_buffering_ranges + gst_query_parse_nth_buffering_range + gst_util_fraction_compare + gst_value_set_int64_range + gst_value_get_int64_range_min + gst_value_get_int64_range_max + gst_adapter_take_list +%% +ignore-type + GstDateTime +%% \ No newline at end of file diff --git a/gst/gst-pb-0.10.31.ignore b/gst/gst-pb-0.10.31.ignore new file mode 100644 index 0000000000..2b28116851 --- /dev/null +++ b/gst/gst-pb-0.10.31.ignore @@ -0,0 +1,31 @@ +%% +ignore + gst_codec_utils_aac_get_sample_rate_from_index + gst_codec_utils_aac_get_profile + gst_codec_utils_aac_get_level + gst_codec_utils_aac_caps_set_level_and_profile + gst_codec_utils_h264_get_profile + gst_codec_utils_h264_get_level + gst_codec_utils_h264_caps_set_level_and_profile + gst_codec_utils_mpeg4video_get_profile + gst_codec_utils_mpeg4video_get_level + gst_codec_utils_mpeg4video_caps_set_level_and_profile + gst_plugins_base_version + gst_plugins_base_version_string + gst_audio_clock_invalidate + gst_base_audio_sink_set_drift_tolerance + gst_base_audio_sink_get_drift_tolerance + gst_x_overlay_set_window_handle + gst_x_overlay_got_window_handle + gst_video_convert_frame + gst_video_convert_frame_async +%% +ignore-type + GstDiscoverer + GstDiscovererResult + GstDiscovererInfo + GstDiscovererStreamInfo + GstDiscovererContainerInfo + GstDiscovererAudioInfo + GstDiscovererVideoInfo +%% \ No newline at end of file diff --git a/gst/gst.defs b/gst/gst.defs index 5ca75c3bbd..d00c4f9a49 100644 --- a/gst/gst.defs +++ b/gst/gst.defs @@ -26,6 +26,12 @@ ) ) +(define-function is_initialized + (c-name "gst_is_initialized") + (return-type "gboolean") +) + + (define-function init_get_option_group (c-name "gst_init_get_option_group") (return-type "GOptionGroup*") @@ -414,6 +420,15 @@ ) ) +(define-method add_list + (of-object "GstBufferListIterator") + (c-name "gst_buffer_list_iterator_add_list") + (return-type "none") + (parameters + '("GList*" "list") + ) +) + (define-method add_group (of-object "GstBufferListIterator") (c-name "gst_buffer_list_iterator_add_group") @@ -1199,6 +1214,122 @@ ) ) +;; From gstdatetime.h + +(define-method get_year + (of-object "GstDateTime") + (c-name "gst_date_time_get_year") + (return-type "gint") +) + +(define-method get_month + (of-object "GstDateTime") + (c-name "gst_date_time_get_month") + (return-type "gint") +) + +(define-method get_day + (of-object "GstDateTime") + (c-name "gst_date_time_get_day") + (return-type "gint") +) + +(define-method get_hour + (of-object "GstDateTime") + (c-name "gst_date_time_get_hour") + (return-type "gint") +) + +(define-method get_minute + (of-object "GstDateTime") + (c-name "gst_date_time_get_minute") + (return-type "gint") +) + +(define-method get_second + (of-object "GstDateTime") + (c-name "gst_date_time_get_second") + (return-type "gint") +) + +(define-method get_microsecond + (of-object "GstDateTime") + (c-name "gst_date_time_get_microsecond") + (return-type "gint") +) + +(define-method get_time_zone_offset + (of-object "GstDateTime") + (c-name "gst_date_time_get_time_zone_offset") + (return-type "gfloat") +) + +(define-function date_time_new_from_unix_epoch + (c-name "gst_date_time_new_from_unix_epoch") + (return-type "GstDateTime*") + (caller-owns-return #t) + (parameters + '("gint64" "secs") + ) +) + +(define-function date_time_new_local_time + (c-name "gst_date_time_new_local_time") + (return-type "GstDateTime*") + (caller-owns-return #t) + (parameters + '("gint" "year") + '("gint" "month") + '("gint" "day") + '("gint" "hour") + '("gint" "minute") + '("gdouble" "seconds") + ) +) + +(define-function date_time_new + (c-name "gst_date_time_new") + (is-constructor-of "GstDateTime") + (return-type "GstDateTime*") + (caller-owns-return #t) + (parameters + '("gfloat" "tzoffset") + '("gint" "year") + '("gint" "month") + '("gint" "day") + '("gint" "hour") + '("gint" "minute") + '("gdouble" "seconds") + ) +) + +(define-function date_time_new_now_local_time + (c-name "gst_date_time_new_now_local_time") + (return-type "GstDateTime*") + (caller-owns-return #t) +) + +(define-function date_time_new_now_utc + (c-name "gst_date_time_new_now_utc") + (return-type "GstDateTime*") + (caller-owns-return #t) +) + +(define-method ref + (of-object "GstDateTime") + (c-name "gst_date_time_ref") + (return-type "GstDateTime*") +) + +(define-method unref + (of-object "GstDateTime") + (c-name "gst_date_time_unref") + (return-type "none") +) + + + + ;; From ../gstreamer/gst/gstdebugutils.h (define-function DEBUG_BIN_TO_DOT_FILE @@ -1249,6 +1380,24 @@ (return-type "GList*") ) +(define-method set_documentation_uri + (of-object "GstElementClass") + (c-name "gst_element_class_set_documentation_uri") + (return-type "none") + (parameters + '("const-gchar*" "uri") + ) +) + +(define-method set_icon_name + (of-object "GstElementClass") + (c-name "gst_element_class_set_icon_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + (define-method set_details (of-object "GstElementClass") (c-name "gst_element_class_set_details") @@ -1744,6 +1893,18 @@ (return-type "const-gchar*") ) +(define-method get_documentation_uri + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_documentation_uri") + (return-type "const-gchar*") +) + +(define-method get_icon_name + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_icon_name") + (return-type "const-gchar*") +) + (define-method get_num_pad_templates (of-object "GstElementFactory") (c-name "gst_element_factory_get_num_pad_templates") @@ -1807,6 +1968,34 @@ '("GType" "type") ) ) +(define-method list_is_type + (of-object "GstElementFactory") + (c-name "gst_element_factory_list_is_type") + (return-type "gboolean") + (parameters + '("GstElementFactoryListType" "type") + ) +) + +(define-function element_factory_list_get_elements + (c-name "gst_element_factory_list_get_elements") + (return-type "GList*") + (parameters + '("GstElementFactoryListType" "type") + '("GstRank" "minrank") + ) +) + +(define-function element_factory_list_filter + (c-name "gst_element_factory_list_filter") + (return-type "GList*") + (parameters + '("GList*" "list") + '("const-GstCaps*" "caps") + '("GstPadDirection" "direction") + '("gboolean" "subsetonly") + ) +) ;; From ../gstreamer/gst/gstenumtypes.h @@ -4943,6 +5132,17 @@ ) ) +(define-function util_fraction_compare + (c-name "gst_util_fraction_compare") + (return-type "gint") + (parameters + '("gint" "a_n") + '("gint" "a_d") + '("gint" "b_n") + '("gint" "b_d") + ) +) + (define-function event_new_sink_message (c-name "gst_event_new_sink_message") (return-type "GstEvent*") @@ -5403,6 +5603,16 @@ ) ) +(define-function plugin_feature_rank_compare_func + (c-name "gst_plugin_feature_rank_compare_func") + (return-type "gint") + (parameters + '("gconstpointer" "p1") + '("gconstpointer" "p2") + ) +) + + ;; From gstpoll.h (define-function gst_poll_new @@ -6021,6 +6231,33 @@ ) ) +(define-method add_buffering_range + (of-object "GstQuery") + (c-name "gst_query_add_buffering_range") + (return-type "gboolean") + (parameters + '("gint64" "start") + '("gint64" "stop") + ) +) + +(define-method get_n_buffering_ranges + (of-object "GstQuery") + (c-name "gst_query_get_n_buffering_ranges") + (return-type "guint") +) + +(define-method parse_nth_buffering_range + (of-object "GstQuery") + (c-name "gst_query_parse_nth_buffering_range") + (return-type "gboolean") + (parameters + '("guint" "index") + '("gint64*" "start") + '("gint64*" "stop") + ) +) + (define-function query_new_uri (c-name "gst_query_new_uri") (caller-owns-return #t) @@ -6519,6 +6756,26 @@ ) ) +(define-method id_take_value + (of-object "GstStructure") + (c-name "gst_structure_id_take_value") + (return-type "none") + (parameters + '("GQuark" "field") + '("GValue*" "value") + ) +) + +(define-method take_value + (of-object "GstStructure") + (c-name "gst_structure_take_value") + (return-type "none") + (parameters + '("const-gchar*" "fieldname") + '("GValue*" "value") + ) +) + (define-method set (of-object "GstStructure") (c-name "gst_structure_set") @@ -8776,6 +9033,32 @@ ) ) +(define-function value_set_int64_range + (c-name "gst_value_set_int64_range") + (return-type "none") + (parameters + '("GValue*" "value") + '("gint64" "start") + '("gint64" "end") + ) +) + +(define-function value_get_int64_range_min + (c-name "gst_value_get_int64_range_min") + (return-type "gint64") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function value_get_int64_range_max + (c-name "gst_value_get_int64_range_max") + (return-type "gint64") + (parameters + '("const-GValue*" "value") + ) +) + (define-function value_set_double_range (c-name "gst_value_set_double_range") (return-type "none") diff --git a/gst/gstversion.override.in b/gst/gstversion.override.in index 7bd66cdbb4..e400a3d2e0 100644 --- a/gst/gstversion.override.in +++ b/gst/gstversion.override.in @@ -15,4 +15,6 @@ include @IGNORE_GST_PB_0_10_29@ @IGNORE_GST_0_10_30@ @IGNORE_GST_PB_0_10_30@ +@IGNORE_GST_0_10_31@ +@IGNORE_GST_PB_0_10_31@ %% diff --git a/gst/pbutils.defs b/gst/pbutils.defs index 85934dff96..8c4aac6938 100644 --- a/gst/pbutils.defs +++ b/gst/pbutils.defs @@ -27,6 +27,156 @@ ) ) +(define-object Discoverer + (in-module "Gst") + (parent "GObject") + (c-name "GstDiscoverer") + (gtype-id "GST_TYPE_DISCOVERER") +) + +(define-enum DiscovererResult + (in-module "Gst") + (c-name "GstDiscovererResult") + (gtype-id "GST_TYPE_DISCOVERER_RESULT") + (values + '("ok" "GST_DISCOVERER_OK") + '("uri-invalid" "GST_DISCOVERER_URI_INVALID") + '("error" "GST_DISCOVERER_ERROR") + '("timeout" "GST_DISCOVERER_TIMEOUT") + '("busy" "GST_DISCOVERER_BUSY") + '("missing-plugins" "GST_DISCOVERER_MISSING_PLUGINS") + ) +) + +(define-miniobject DiscovererInfo + (in-module "Gst") + (c-name "GstDiscovererInfo") + (parent "GstMiniObject") + (gtype-id "GST_TYPE_DISCOVERER_INFO") +) + +(define-miniobject DiscovererStreamInfo + (in-module "Gst") + (c-name "GstDiscovererStreamInfo") + (parent "GstMiniObject") + (gtype-id "GST_TYPE_DISCOVERER_STREAM_INFO") +) + +(define-miniobject DiscovererContainerInfo + (in-module "Gst") + (c-name "GstDiscovererContainerInfo") + (parent "GstDiscovererStreamInfo") + (gtype-id "GST_TYPE_DISCOVERER_CONTAINER_INFO") +) + +(define-miniobject DiscovererAudioInfo + (in-module "Gst") + (c-name "GstDiscovererAudioInfo") + (parent "GstDiscovererStreamInfo") + (gtype-id "GST_TYPE_DISCOVERER_AUDIO_INFO") +) + +(define-miniobject DiscovererVideoInfo + (in-module "Gst") + (c-name "GstDiscovererVideoInfo") + (parent "GstDiscovererStreamInfo") + (gtype-id "GST_TYPE_DISCOVERER_VIDEO_INFO") +) + +;; From codec-utils.h + +(define-function codec_utils_aac_get_sample_rate_from_index + (c-name "gst_codec_utils_aac_get_sample_rate_from_index") + (return-type "guint") + (parameters + '("guint" "sr_idx") + ) +) + +(define-function codec_utils_aac_get_profile + (c-name "gst_codec_utils_aac_get_profile") + (return-type "const-gchar*") + (parameters + '("const-guint8*" "audio_config") + '("guint" "len") + ) +) + +(define-function codec_utils_aac_get_level + (c-name "gst_codec_utils_aac_get_level") + (return-type "const-gchar*") + (parameters + '("const-guint8*" "audio_config") + '("guint" "len") + ) +) + +(define-method codec_utils_aac_caps_set_level_and_profile + (of-object "GstCaps") + (c-name "gst_codec_utils_aac_caps_set_level_and_profile") + (return-type "gboolean") + (parameters + '("const-guint8*" "audio_config") + '("guint" "len") + ) +) + +(define-function codec_utils_h264_get_profile + (c-name "gst_codec_utils_h264_get_profile") + (return-type "const-gchar*") + (parameters + '("const-guint8*" "sps") + '("guint" "len") + ) +) + +(define-function codec_utils_h264_get_level + (c-name "gst_codec_utils_h264_get_level") + (return-type "const-gchar*") + (parameters + '("const-guint8*" "sps") + '("guint" "len") + ) +) + +(define-method codec_utils_h264_caps_set_level_and_profile + (of-object "GstCaps") + (c-name "gst_codec_utils_h264_caps_set_level_and_profile") + (return-type "gboolean") + (parameters + '("const-guint8*" "sps") + '("guint" "len") + ) +) + +(define-function codec_utils_mpeg4video_get_profile + (c-name "gst_codec_utils_mpeg4video_get_profile") + (return-type "const-gchar*") + (parameters + '("const-guint8*" "vis_obj_seq") + '("guint" "len") + ) +) + +(define-function codec_utils_mpeg4video_get_level + (c-name "gst_codec_utils_mpeg4video_get_level") + (return-type "const-gchar*") + (parameters + '("const-guint8*" "vis_obj_seq") + '("guint" "len") + ) +) + +(define-method codec_utils_mpeg4video_caps_set_level_and_profile + (of-object "GstCaps") + (c-name "gst_codec_utils_mpeg4video_caps_set_level_and_profile") + (return-type "gboolean") + (parameters + '("const-guint8*" "vis_obj_seq") + '("guint" "len") + ) +) + ;; From descriptions.h @@ -150,6 +300,353 @@ ) +;; From gstdiscoverer.h + +(define-function gst_discoverer_stream_info_get_type + (c-name "gst_discoverer_stream_info_get_type") + (return-type "GType") +) + +(define-method get_previous + (of-object "GstDiscovererStreamInfo") + (c-name "gst_discoverer_stream_info_get_previous") + (return-type "GstDiscovererStreamInfo*") +) + +(define-method get_next + (of-object "GstDiscovererStreamInfo") + (c-name "gst_discoverer_stream_info_get_next") + (return-type "GstDiscovererStreamInfo*") +) + +(define-method get_caps + (of-object "GstDiscovererStreamInfo") + (c-name "gst_discoverer_stream_info_get_caps") + (return-type "GstCaps*") +) + +(define-method get_tags + (of-object "GstDiscovererStreamInfo") + (c-name "gst_discoverer_stream_info_get_tags") + (return-type "const-GstTagList*") +) + +(define-method get_misc + (of-object "GstDiscovererStreamInfo") + (c-name "gst_discoverer_stream_info_get_misc") + (return-type "const-GstStructure*") +) + +(define-method get_stream_type_nick + (of-object "GstDiscovererStreamInfo") + (c-name "gst_discoverer_stream_info_get_stream_type_nick") + (return-type "const-gchar*") +) + +(define-function gst_discoverer_container_info_get_type + (c-name "gst_discoverer_container_info_get_type") + (return-type "GType") +) + +(define-function gst_discoverer_container_info_get_streams + (c-name "gst_discoverer_container_info_get_streams") + (return-type "GList*") + (parameters + '("GstDiscovererStreamInfo*" "info") + ) +) + +(define-function gst_discoverer_audio_info_get_type + (c-name "gst_discoverer_audio_info_get_type") + (return-type "GType") +) + +(define-function gst_discoverer_audio_info_get_channels + (c-name "gst_discoverer_audio_info_get_channels") + (return-type "guint") + (parameters + '("GstDiscovererStreamInfo*" "info") + ) +) + +(define-function gst_discoverer_audio_info_get_sample_rate + (c-name "gst_discoverer_audio_info_get_sample_rate") + (return-type "guint") + (parameters + '("GstDiscovererStreamInfo*" "info") + ) +) + +(define-function gst_discoverer_audio_info_get_depth + (c-name "gst_discoverer_audio_info_get_depth") + (return-type "guint") + (parameters + '("GstDiscovererStreamInfo*" "info") + ) +) + +(define-function gst_discoverer_audio_info_get_bitrate + (c-name "gst_discoverer_audio_info_get_bitrate") + (return-type "guint") + (parameters + '("GstDiscovererStreamInfo*" "info") + ) +) + +(define-function gst_discoverer_audio_info_get_max_bitrate + (c-name "gst_discoverer_audio_info_get_max_bitrate") + (return-type "guint") + (parameters + '("GstDiscovererStreamInfo*" "info") + ) +) + +(define-function gst_discoverer_video_info_get_type + (c-name "gst_discoverer_video_info_get_type") + (return-type "GType") +) + +(define-function gst_discoverer_video_info_get_width + (c-name "gst_discoverer_video_info_get_width") + (return-type "guint") + (parameters + '("GstDiscovererStreamInfo*" "info") + ) +) + +(define-function gst_discoverer_video_info_get_height + (c-name "gst_discoverer_video_info_get_height") + (return-type "guint") + (parameters + '("GstDiscovererStreamInfo*" "info") + ) +) + +(define-function gst_discoverer_video_info_get_depth + (c-name "gst_discoverer_video_info_get_depth") + (return-type "guint") + (parameters + '("GstDiscovererStreamInfo*" "info") + ) +) + +(define-function gst_discoverer_video_info_get_framerate_num + (c-name "gst_discoverer_video_info_get_framerate_num") + (return-type "guint") + (parameters + '("GstDiscovererStreamInfo*" "info") + ) +) + +(define-function gst_discoverer_video_info_get_framerate_denom + (c-name "gst_discoverer_video_info_get_framerate_denom") + (return-type "guint") + (parameters + '("GstDiscovererStreamInfo*" "info") + ) +) + +(define-function gst_discoverer_video_info_get_par_num + (c-name "gst_discoverer_video_info_get_par_num") + (return-type "guint") + (parameters + '("GstDiscovererStreamInfo*" "info") + ) +) + +(define-function gst_discoverer_video_info_get_par_denom + (c-name "gst_discoverer_video_info_get_par_denom") + (return-type "guint") + (parameters + '("GstDiscovererStreamInfo*" "info") + ) +) + +(define-function gst_discoverer_video_info_get_interlaced + (c-name "gst_discoverer_video_info_get_interlaced") + (return-type "gboolean") + (parameters + '("GstDiscovererStreamInfo*" "info") + ) +) + +(define-function gst_discoverer_video_info_get_bitrate + (c-name "gst_discoverer_video_info_get_bitrate") + (return-type "guint") + (parameters + '("GstDiscovererStreamInfo*" "info") + ) +) + +(define-function gst_discoverer_video_info_get_max_bitrate + (c-name "gst_discoverer_video_info_get_max_bitrate") + (return-type "guint") + (parameters + '("GstDiscovererStreamInfo*" "info") + ) +) + +(define-function gst_discoverer_video_info_get_is_image + (c-name "gst_discoverer_video_info_get_is_image") + (return-type "gboolean") + (parameters + '("GstDiscovererStreamInfo*" "info") + ) +) + +(define-function gst_discoverer_info_get_type + (c-name "gst_discoverer_info_get_type") + (return-type "GType") +) + +(define-method copy + (of-object "GstDiscovererInfo") + (c-name "gst_discoverer_info_copy") + (return-type "GstDiscovererInfo*") +) + +(define-method get_uri + (of-object "GstDiscovererInfo") + (c-name "gst_discoverer_info_get_uri") + (return-type "const-gchar*") +) + +(define-method get_result + (of-object "GstDiscovererInfo") + (c-name "gst_discoverer_info_get_result") + (return-type "GstDiscovererResult") +) + +(define-method get_stream_info + (of-object "GstDiscovererInfo") + (c-name "gst_discoverer_info_get_stream_info") + (return-type "GstDiscovererStreamInfo*") +) + +(define-method get_stream_list + (of-object "GstDiscovererInfo") + (c-name "gst_discoverer_info_get_stream_list") + (return-type "GList*") +) + +(define-method get_duration + (of-object "GstDiscovererInfo") + (c-name "gst_discoverer_info_get_duration") + (return-type "GstClockTime") +) + +(define-method get_misc + (of-object "GstDiscovererInfo") + (c-name "gst_discoverer_info_get_misc") + (return-type "const-GstStructure*") +) + +(define-method get_tags + (of-object "GstDiscovererInfo") + (c-name "gst_discoverer_info_get_tags") + (return-type "const-GstTagList*") +) + +(define-method get_streams + (of-object "GstDiscovererInfo") + (c-name "gst_discoverer_info_get_streams") + (return-type "GList*") + (parameters + '("GType" "streamtype") + ) +) + +(define-method get_audio_streams + (of-object "GstDiscovererInfo") + (c-name "gst_discoverer_info_get_audio_streams") + (return-type "GList*") +) + +(define-method get_video_streams + (of-object "GstDiscovererInfo") + (c-name "gst_discoverer_info_get_video_streams") + (return-type "GList*") +) + +(define-method get_container_streams + (of-object "GstDiscovererInfo") + (c-name "gst_discoverer_info_get_container_streams") + (return-type "GList*") +) + +(define-function gst_discoverer_stream_info_list_free + (c-name "gst_discoverer_stream_info_list_free") + (return-type "none") + (parameters + '("GList*" "infos") + ) +) + +(define-function gst_discoverer_get_type + (c-name "gst_discoverer_get_type") + (return-type "GType") +) + +(define-function gst_discoverer_new + (c-name "gst_discoverer_new") + (is-constructor-of "GstDiscoverer") + (return-type "GstDiscoverer*") + (parameters + '("GstClockTime" "timeout") + '("GError**" "err") + ) +) + +(define-method start + (of-object "GstDiscoverer") + (c-name "gst_discoverer_start") + (return-type "none") +) + +(define-method stop + (of-object "GstDiscoverer") + (c-name "gst_discoverer_stop") + (return-type "none") +) + +(define-method discover_uri_async + (of-object "GstDiscoverer") + (c-name "gst_discoverer_discover_uri_async") + (return-type "gboolean") + (parameters + '("const-gchar*" "uri") + ) +) + +(define-method discover_uri + (of-object "GstDiscoverer") + (c-name "gst_discoverer_discover_uri") + (return-type "GstDiscovererInfo*") + (parameters + '("const-gchar*" "uri") + '("GError**" "err") + ) +) + +;; From gstpluginsbaseversion.h + +(define-function plugins_base_version + (c-name "gst_plugins_base_version") + (return-type "none") + (parameters + '("guint*" "major") + '("guint*" "minor") + '("guint*" "micro") + '("guint*" "nano") + ) +) + +(define-function plugins_base_version_string + (c-name "gst_plugins_base_version_string") + (return-type "gchar*") +) + + ;; From missing-plugins.h diff --git a/gst/video.defs b/gst/video.defs index 5177979e5b..1880d5c52d 100644 --- a/gst/video.defs +++ b/gst/video.defs @@ -55,6 +55,8 @@ '("bgr16" "GST_VIDEO_FORMAT_BGR16") '("rgb15" "GST_VIDEO_FORMAT_RGB15") '("bgr15" "GST_VIDEO_FORMAT_BGR15") + '("uyvp" "GST_VIDEO_FORMAT_UYVP") + '("a420" "GST_VIDEO_FORMAT_A420") ) ) @@ -332,3 +334,26 @@ '("gboolean*" "in_still") ) ) +(define-function video_convert_frame + (c-name "gst_video_convert_frame") + (return-type "GstBuffer*") + (parameters + '("GstBuffer*" "buf") + '("const-GstCaps*" "to_caps") + '("GstClockTime" "timeout") + '("GError**" "error") + ) +) + +(define-function video_convert_frame_async + (c-name "gst_video_convert_frame_async") + (return-type "none") + (parameters + '("GstBuffer*" "buf") + '("const-GstCaps*" "to_caps") + '("GstClockTime" "timeout") + '("GstVideoConvertFrameCallback" "callback") + '("gpointer" "user_data") + '("GDestroyNotify" "destroy_notify") + ) +)