This file is indexed.

/usr/include/Qt5GStreamer/QGst/element.h is in libqt5gstreamer-dev 1.2.0-5.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  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
/*
    Copyright (C) 2010  George Kiagiadakis <kiagiadakis.george@gmail.com>

    This library is free software; you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published
    by the Free Software Foundation; either version 2.1 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef QGST_ELEMENT_H
#define QGST_ELEMENT_H

#include "object.h"
#include "caps.h"
#include "clocktime.h"

#if !QGLIB_HAVE_CXX0X
# include <boost/preprocessor.hpp>
#endif

namespace QGst {

/*! \headerfile element.h <QGst/Element>
 * \brief Wrapper class for GstElement
 */
class QTGSTREAMER_EXPORT Element : public Object
{
    QGST_WRAPPER(Element)
public:
    State currentState() const;
    State pendingState() const;
    StateChangeReturn getState(State *state, State *pending, ClockTime timeout) const;
    StateChangeReturn setState(State state);
    bool syncStateWithParent();

    bool stateIsLocked() const;
    bool setStateLocked(bool locked);

    bool addPad(const PadPtr & pad);
    bool removePad(const PadPtr & pad);

    PadPtr getStaticPad(const char *name);
    PadPtr getRequestPad(const char *name);
    void releaseRequestPad(const PadPtr & pad);

    ClockPtr clock() const;
    bool setClock(const ClockPtr & clock);

    bool link(const char *srcPadName, const ElementPtr & dest,
              const char *sinkPadName, const CapsPtr & filter = CapsPtr());
    bool link(const char *srcPadName, const ElementPtr & dest,
              const CapsPtr & filter = CapsPtr());
    bool link(const ElementPtr & dest, const char *sinkPadName,
              const CapsPtr & filter = CapsPtr());
    bool link(const ElementPtr & dest, const CapsPtr & filter = CapsPtr());

#ifndef DOXYGEN_RUN
    //FIXME-0.11 Remove the default NULL parameter from the first version
    //and remove entirely sinkPadName from the second version
    void unlink(const char *srcPadName, const ElementPtr & dest,
                const char *sinkPadName = NULL);
    void unlink(const ElementPtr & dest, const char *sinkPadName = NULL);
#else
    //documentation should show those functions as they are meant to be used.
    /*! Unlinks the pad named \a srcPadName of this element
     * from the pad named \a sinkPadName of the \a dest element. */
    void unlink(const char *srcPadName, const ElementPtr & dest, const char *sinkPadName);

    /*! Unlinks this element from the \a dest element */
    void unlink(const ElementPtr & dest);
#endif

#ifndef DOXYGEN_RUN
private:
    static inline bool linkMany(const ElementPtr & first, const ElementPtr & second)
    {
        return first->link(second);
    }

    static inline void unlinkMany(const ElementPtr & first, const ElementPtr & second)
    {
        first->unlink(second);
    }
public:
#endif

#if QGLIB_HAVE_CXX0X
    /*! Links together a series of elements in the order that they are provided.
     * \note This function makes use of C++0x features. If your compiler doesn't support
     * this, a different version will be compiled. That version supports up to
     * QGST_ELEMENT_LINK_MANY_MAX_ARGS arguments, which defaults to 10. If you need more,
     * define this to a greater value before including any QtGStreamer headers.
     */
    template <typename First, typename Second, typename Third, typename... Rest>
    static inline bool linkMany(const First & first, const Second & second,
                                const Third & third, const Rest & ... rest)
    {
        if (!first->link(second)) return false;
        return linkMany(second, third, rest...);
    }

    /*! Unlinks a chain of elements.
     * \note This function makes use of C++0x features. If your compiler doesn't support
     * this, a different version will be compiled. That version supports up to
     * QGST_ELEMENT_UNLINK_MANY_MAX_ARGS arguments, which defaults to 10. If you need more,
     * define this to a greater value before including any QtGStreamer headers.
     */
    template <typename First, typename Second, typename Third, typename... Rest>
    static inline void unlinkMany(const First & first, const Second & second,
                                  const Third & third, const Rest & ... rest)
    {
        first->unlink(second);
        unlinkMany(second, third, rest...);
    }
#else //QGLIB_HAVE_CXX0X

# ifndef QGST_ELEMENT_LINK_MANY_MAX_ARGS
#  define QGST_ELEMENT_LINK_MANY_MAX_ARGS 10
# endif

# ifndef QGST_ELEMENT_UNLINK_MANY_MAX_ARGS
#  define QGST_ELEMENT_UNLINK_MANY_MAX_ARGS 10
# endif

# define QGST_ELEMENT_LINK_MANY_DECLARATION(z, n, data) \
    static inline bool linkMany(BOOST_PP_ENUM_PARAMS(n, const ElementPtr & e)) \
    { \
        if (!e0->link(e1)) return false; \
        return linkMany(BOOST_PP_ENUM_SHIFTED_PARAMS(n, e)); \
    };

# define QGST_ELEMENT_UNLINK_MANY_DECLARATION(z, n, data) \
    static inline void unlinkMany(BOOST_PP_ENUM_PARAMS(n, const ElementPtr & e)) \
    { \
        e0->unlink(e1); \
        unlinkMany(BOOST_PP_ENUM_SHIFTED_PARAMS(n, e)); \
    };

    BOOST_PP_REPEAT_FROM_TO(3, BOOST_PP_INC(QGST_ELEMENT_LINK_MANY_MAX_ARGS),
                            QGST_ELEMENT_LINK_MANY_DECLARATION, dummy)
    BOOST_PP_REPEAT_FROM_TO(3, BOOST_PP_INC(QGST_ELEMENT_UNLINK_MANY_MAX_ARGS),
                            QGST_ELEMENT_UNLINK_MANY_DECLARATION, dummy)

# undef QGST_ELEMENT_LINK_MANY_DECLARATION
# undef QGST_ELEMENT_UNLINK_MANY_DECLARATION

#endif //QGLIB_HAVE_CXX0X

    bool query(const QueryPtr & query);
    bool sendEvent(const EventPtr & event);
    bool seek(Format format, SeekFlags flags, quint64 position);
};

}

QGST_REGISTER_TYPE(QGst::Element)

#endif // QGST_ELEMENT_H