1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use Element;
use Object;
use TagList;
use TagMergeMode;
use ffi;
use glib::object::IsA;
use glib::translate::*;
use glib_ffi;
use gobject_ffi;
use std::mem;
use std::ptr;

glib_wrapper! {
    /// Element interface that allows setting of media metadata.
    ///
    /// Elements that support changing a stream's metadata will implement this
    /// interface. Examples of such elements are 'vorbisenc', 'theoraenc' and
    /// 'id3v2mux'.
    ///
    /// If you just want to retrieve metadata in your application then all you
    /// need to do is watch for tag messages on your pipeline's bus. This
    /// interface is only for setting metadata, not for extracting it. To set tags
    /// from the application, find tagsetter elements and set tags using e.g.
    /// `TagSetter::merge_tags` or `TagSetter::add_tags`. Also consider
    /// setting the `TagMergeMode` that is used for tag events that arrive at the
    /// tagsetter element (default mode is to keep existing tags).
    /// The application should do that before the element goes to `State::Paused`.
    ///
    /// Elements implementing the `TagSetter` interface often have to merge
    /// any tags received from upstream and the tags set by the application via
    /// the interface. This can be done like this:
    ///
    ///
    /// ```C
    /// GstTagMergeMode merge_mode;
    /// const GstTagList *application_tags;
    /// const GstTagList *event_tags;
    /// GstTagSetter *tagsetter;
    /// GstTagList *result;
    ///
    /// tagsetter = GST_TAG_SETTER (element);
    ///
    /// merge_mode = gst_tag_setter_get_tag_merge_mode (tagsetter);
    /// application_tags = gst_tag_setter_get_tag_list (tagsetter);
    /// event_tags = (const GstTagList *) element->event_tags;
    ///
    /// GST_LOG_OBJECT (tagsetter, "merging tags, merge mode = %d", merge_mode);
    /// GST_LOG_OBJECT (tagsetter, "event tags: %" GST_PTR_FORMAT, event_tags);
    /// GST_LOG_OBJECT (tagsetter, "set   tags: %" GST_PTR_FORMAT, application_tags);
    ///
    /// result = gst_tag_list_merge (application_tags, event_tags, merge_mode);
    ///
    /// GST_LOG_OBJECT (tagsetter, "final tags: %" GST_PTR_FORMAT, result);
    /// ```
    ///
    /// # Implements
    ///
    /// [`TagSetterExt`](trait.TagSetterExt.html), [`ElementExt`](trait.ElementExt.html), [`GstObjectExt`](trait.GstObjectExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html)
    pub struct TagSetter(Object<ffi::GstTagSetter, ffi::GstTagSetterInterface>): Element, Object;

    match fn {
        get_type => || ffi::gst_tag_setter_get_type(),
    }
}

unsafe impl Send for TagSetter {}
unsafe impl Sync for TagSetter {}

/// Trait containing all `TagSetter` methods.
///
/// # Implementors
///
/// [`TagSetter`](struct.TagSetter.html)
pub trait TagSetterExt {
    //fn add_tag_valist(&self, mode: TagMergeMode, tag: &str, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported);

    //fn add_tag_valist_values(&self, mode: TagMergeMode, tag: &str, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported);

    //fn add_tag_value(&self, mode: TagMergeMode, tag: &str, value: /*Ignored*/&glib::Value);

    //fn add_tag_values(&self, mode: TagMergeMode, tag: &str, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs);

    //fn add_tags(&self, mode: TagMergeMode, tag: &str, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs);

    /// Returns the current list of tags the setter uses. The list should not be
    /// modified or freed.
    ///
    /// This function is not thread-safe.
    ///
    /// # Returns
    ///
    /// a current snapshot of the
    ///  taglist used in the setter or `None` if none is used.
    fn get_tag_list(&self) -> Option<TagList>;

    /// Queries the mode by which tags inside the setter are overwritten by tags
    /// from events
    ///
    /// # Returns
    ///
    /// the merge mode used inside the element.
    fn get_tag_merge_mode(&self) -> TagMergeMode;

    /// Merges the given list into the setter's list using the given mode.
    /// ## `list`
    /// a tag list to merge from
    /// ## `mode`
    /// the mode to merge with
    fn merge_tags(&self, list: &TagList, mode: TagMergeMode);

    /// Reset the internal taglist. Elements should call this from within the
    /// state-change handler.
    fn reset_tags(&self);

    /// Sets the given merge mode that is used for adding tags from events to tags
    /// specified by this interface. The default is `TagMergeMode::Keep`, which keeps
    /// the tags set with this interface and discards tags from events.
    /// ## `mode`
    /// The mode with which tags are added
    fn set_tag_merge_mode(&self, mode: TagMergeMode);
}

impl<O: IsA<TagSetter>> TagSetterExt for O {
    //fn add_tag_valist(&self, mode: TagMergeMode, tag: &str, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported) {
    //    unsafe { TODO: call ffi::gst_tag_setter_add_tag_valist() }
    //}

    //fn add_tag_valist_values(&self, mode: TagMergeMode, tag: &str, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported) {
    //    unsafe { TODO: call ffi::gst_tag_setter_add_tag_valist_values() }
    //}

    //fn add_tag_value(&self, mode: TagMergeMode, tag: &str, value: /*Ignored*/&glib::Value) {
    //    unsafe { TODO: call ffi::gst_tag_setter_add_tag_value() }
    //}

    //fn add_tag_values(&self, mode: TagMergeMode, tag: &str, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) {
    //    unsafe { TODO: call ffi::gst_tag_setter_add_tag_values() }
    //}

    //fn add_tags(&self, mode: TagMergeMode, tag: &str, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) {
    //    unsafe { TODO: call ffi::gst_tag_setter_add_tags() }
    //}

    fn get_tag_list(&self) -> Option<TagList> {
        unsafe {
            from_glib_none(ffi::gst_tag_setter_get_tag_list(self.to_glib_none().0))
        }
    }

    fn get_tag_merge_mode(&self) -> TagMergeMode {
        unsafe {
            from_glib(ffi::gst_tag_setter_get_tag_merge_mode(self.to_glib_none().0))
        }
    }

    fn merge_tags(&self, list: &TagList, mode: TagMergeMode) {
        unsafe {
            ffi::gst_tag_setter_merge_tags(self.to_glib_none().0, list.to_glib_none().0, mode.to_glib());
        }
    }

    fn reset_tags(&self) {
        unsafe {
            ffi::gst_tag_setter_reset_tags(self.to_glib_none().0);
        }
    }

    fn set_tag_merge_mode(&self, mode: TagMergeMode) {
        unsafe {
            ffi::gst_tag_setter_set_tag_merge_mode(self.to_glib_none().0, mode.to_glib());
        }
    }
}