[GStreamer] clean-up various leaks
[WebKit-https.git] / Source / WebCore / platform / graphics / gstreamer / GRefPtrGStreamer.cpp
1 /*
2  *  Copyright (C) 2011 Igalia S.L
3  *
4  *  This library is free software; you can redistribute it and/or
5  *  modify it under the terms of the GNU Lesser General Public
6  *  License as published by the Free Software Foundation; either
7  *  version 2 of the License, or (at your option) any later version.
8  *
9  *  This library is distributed in the hope that it will be useful,
10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  *  Lesser General Public License for more details.
13  *
14  *  You should have received a copy of the GNU Lesser General Public
15  *  License along with this library; if not, write to the Free Software
16  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
17  */
18
19
20 #include "config.h"
21 #include "GRefPtrGStreamer.h"
22
23 #if USE(GSTREAMER)
24 #include <gst/gst.h>
25
26 namespace WTF {
27
28 template <> GRefPtr<GstElement> adoptGRef(GstElement* ptr)
29 {
30     ASSERT(!ptr || !g_object_is_floating(ptr));
31     return GRefPtr<GstElement>(ptr, GRefPtrAdopt);
32 }
33
34 template <> GstElement* refGPtr<GstElement>(GstElement* ptr)
35 {
36     if (ptr)
37         gst_object_ref_sink(GST_OBJECT(ptr));
38
39     return ptr;
40 }
41
42 template <> void derefGPtr<GstElement>(GstElement* ptr)
43 {
44     if (ptr)
45         gst_object_unref(ptr);
46 }
47
48 template <> GRefPtr<GstPad> adoptGRef(GstPad* ptr)
49 {
50     ASSERT(!ptr || !g_object_is_floating(ptr));
51     return GRefPtr<GstPad>(ptr, GRefPtrAdopt);
52 }
53
54 template <> GstPad* refGPtr<GstPad>(GstPad* ptr)
55 {
56     if (ptr)
57         gst_object_ref_sink(GST_OBJECT(ptr));
58
59     return ptr;
60 }
61
62 template <> void derefGPtr<GstPad>(GstPad* ptr)
63 {
64     if (ptr)
65         gst_object_unref(GST_OBJECT(ptr));
66 }
67
68 template <> GRefPtr<GstPadTemplate> adoptGRef(GstPadTemplate* ptr)
69 {
70     ASSERT(!ptr || !g_object_is_floating(ptr));
71     return GRefPtr<GstPadTemplate>(ptr, GRefPtrAdopt);
72 }
73
74 template <> GstPadTemplate* refGPtr<GstPadTemplate>(GstPadTemplate* ptr)
75 {
76     if (ptr)
77         gst_object_ref_sink(GST_OBJECT(ptr));
78
79     return ptr;
80 }
81
82 template <> void derefGPtr<GstPadTemplate>(GstPadTemplate* ptr)
83 {
84     if (ptr)
85         gst_object_unref(GST_OBJECT(ptr));
86 }
87
88 template <> GRefPtr<GstCaps> adoptGRef(GstCaps* ptr)
89 {
90     return GRefPtr<GstCaps>(ptr, GRefPtrAdopt);
91 }
92
93 template <> GstCaps* refGPtr<GstCaps>(GstCaps* ptr)
94 {
95     if (ptr)
96         gst_caps_ref(ptr);
97     return ptr;
98 }
99
100 template <> void derefGPtr<GstCaps>(GstCaps* ptr)
101 {
102     if (ptr)
103         gst_caps_unref(ptr);
104 }
105
106 template <> GRefPtr<GstContext> adoptGRef(GstContext* ptr)
107 {
108     ASSERT(!g_object_is_floating(ptr));
109     return GRefPtr<GstContext>(ptr, GRefPtrAdopt);
110 }
111
112 template <> GstContext* refGPtr<GstContext>(GstContext* ptr)
113 {
114     if (ptr)
115         gst_context_ref(ptr);
116     return ptr;
117 }
118
119 template <> void derefGPtr<GstContext>(GstContext* ptr)
120 {
121     if (ptr)
122         gst_context_unref(ptr);
123 }
124
125 template <> GRefPtr<GstTask> adoptGRef(GstTask* ptr)
126 {
127     // There is no need to check the object reference is floating here because
128     // gst_task_init() always sinks it.
129     return GRefPtr<GstTask>(ptr, GRefPtrAdopt);
130 }
131
132 template <> GstTask* refGPtr<GstTask>(GstTask* ptr)
133 {
134     if (ptr)
135         gst_object_ref_sink(GST_OBJECT(ptr));
136
137     return ptr;
138 }
139
140 template <> void derefGPtr<GstTask>(GstTask* ptr)
141 {
142     if (ptr)
143         gst_object_unref(ptr);
144 }
145
146 template <> GRefPtr<GstBus> adoptGRef(GstBus* ptr)
147 {
148     ASSERT(!ptr || !g_object_is_floating(ptr));
149     return GRefPtr<GstBus>(ptr, GRefPtrAdopt);
150 }
151
152 template <> GstBus* refGPtr<GstBus>(GstBus* ptr)
153 {
154     if (ptr)
155         gst_object_ref_sink(GST_OBJECT(ptr));
156
157     return ptr;
158 }
159
160 template <> void derefGPtr<GstBus>(GstBus* ptr)
161 {
162     if (ptr)
163         gst_object_unref(ptr);
164 }
165
166 template <> GRefPtr<GstElementFactory> adoptGRef(GstElementFactory* ptr)
167 {
168     ASSERT(!ptr || !g_object_is_floating(ptr));
169     return GRefPtr<GstElementFactory>(ptr, GRefPtrAdopt);
170 }
171
172 template <> GstElementFactory* refGPtr<GstElementFactory>(GstElementFactory* ptr)
173 {
174     if (ptr)
175         gst_object_ref_sink(GST_OBJECT(ptr));
176
177     return ptr;
178 }
179
180 template <> void derefGPtr<GstElementFactory>(GstElementFactory* ptr)
181 {
182     if (ptr)
183         gst_object_unref(ptr);
184 }
185
186 template<> GRefPtr<GstBuffer> adoptGRef(GstBuffer* ptr)
187 {
188     return GRefPtr<GstBuffer>(ptr, GRefPtrAdopt);
189 }
190
191 template<> GstBuffer* refGPtr<GstBuffer>(GstBuffer* ptr)
192 {
193     if (ptr)
194         gst_buffer_ref(ptr);
195
196     return ptr;
197 }
198
199 template<> void derefGPtr<GstBuffer>(GstBuffer* ptr)
200 {
201     if (ptr)
202         gst_buffer_unref(ptr);
203 }
204
205 template<> GRefPtr<GstBufferList> adoptGRef(GstBufferList* ptr)
206 {
207     return GRefPtr<GstBufferList>(ptr, GRefPtrAdopt);
208 }
209
210 template<> GstBufferList* refGPtr<GstBufferList>(GstBufferList* ptr)
211 {
212     if (ptr)
213         gst_buffer_list_ref(ptr);
214
215     return ptr;
216 }
217
218 template<> void derefGPtr<GstBufferList>(GstBufferList* ptr)
219 {
220     if (ptr)
221         gst_buffer_list_unref(ptr);
222 }
223
224 template<> GRefPtr<GstSample> adoptGRef(GstSample* ptr)
225 {
226     return GRefPtr<GstSample>(ptr, GRefPtrAdopt);
227 }
228
229 template<> GstSample* refGPtr<GstSample>(GstSample* ptr)
230 {
231     if (ptr)
232         gst_sample_ref(ptr);
233
234     return ptr;
235 }
236
237 template<> void derefGPtr<GstSample>(GstSample* ptr)
238 {
239     if (ptr)
240         gst_sample_unref(ptr);
241 }
242
243 template<> GRefPtr<GstTagList> adoptGRef(GstTagList* ptr)
244 {
245     return GRefPtr<GstTagList>(ptr, GRefPtrAdopt);
246 }
247
248 template<> GstTagList* refGPtr<GstTagList>(GstTagList* ptr)
249 {
250     if (ptr)
251         gst_tag_list_ref(ptr);
252
253     return ptr;
254 }
255
256 template<> void derefGPtr<GstTagList>(GstTagList* ptr)
257 {
258     if (ptr)
259         gst_tag_list_unref(ptr);
260 }
261
262 template<> GRefPtr<GstEvent> adoptGRef(GstEvent* ptr)
263 {
264     return GRefPtr<GstEvent>(ptr, GRefPtrAdopt);
265 }
266
267 template<> GstEvent* refGPtr<GstEvent>(GstEvent* ptr)
268 {
269     if (ptr)
270         gst_event_ref(ptr);
271
272     return ptr;
273 }
274
275 template<> void derefGPtr<GstEvent>(GstEvent* ptr)
276 {
277     if (ptr)
278         gst_event_unref(ptr);
279 }
280
281 template<> GRefPtr<GstToc> adoptGRef(GstToc* ptr)
282 {
283     return GRefPtr<GstToc>(ptr, GRefPtrAdopt);
284 }
285
286 template<> GstToc* refGPtr<GstToc>(GstToc* ptr)
287 {
288     if (ptr)
289         return gst_toc_ref(ptr);
290
291     return ptr;
292 }
293
294 template<> void derefGPtr<GstToc>(GstToc* ptr)
295 {
296     if (ptr)
297         gst_toc_unref(ptr);
298 }
299
300 template<> GRefPtr<GstMessage> adoptGRef(GstMessage* ptr)
301 {
302     return GRefPtr<GstMessage>(ptr, GRefPtrAdopt);
303 }
304
305 template<> GstMessage* refGPtr<GstMessage>(GstMessage* ptr)
306 {
307     if (ptr)
308         return gst_message_ref(ptr);
309
310     return ptr;
311 }
312
313 template<> void derefGPtr<GstMessage>(GstMessage* ptr)
314 {
315     if (ptr)
316         gst_message_unref(ptr);
317 }
318
319 template <> GRefPtr<WebKitVideoSink> adoptGRef(WebKitVideoSink* ptr)
320 {
321     ASSERT(!ptr || !g_object_is_floating(ptr));
322     return GRefPtr<WebKitVideoSink>(ptr, GRefPtrAdopt);
323 }
324
325 template <> WebKitVideoSink* refGPtr<WebKitVideoSink>(WebKitVideoSink* ptr)
326 {
327     if (ptr)
328         gst_object_ref_sink(GST_OBJECT(ptr));
329
330     return ptr;
331 }
332
333 template <> void derefGPtr<WebKitVideoSink>(WebKitVideoSink* ptr)
334 {
335     if (ptr)
336         gst_object_unref(GST_OBJECT(ptr));
337 }
338
339 template <> GRefPtr<WebKitWebSrc> adoptGRef(WebKitWebSrc* ptr)
340 {
341     ASSERT(!ptr || !g_object_is_floating(ptr));
342     return GRefPtr<WebKitWebSrc>(ptr, GRefPtrAdopt);
343 }
344
345 template <> WebKitWebSrc* refGPtr<WebKitWebSrc>(WebKitWebSrc* ptr)
346 {
347     if (ptr)
348         gst_object_ref_sink(GST_OBJECT(ptr));
349
350     return ptr;
351 }
352
353 template <> void derefGPtr<WebKitWebSrc>(WebKitWebSrc* ptr)
354 {
355     if (ptr)
356         gst_object_unref(GST_OBJECT(ptr));
357 }
358
359 } // namespace WTF
360
361 #endif // USE(GSTREAMER)