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
26namespace WTF {
27
28template <> GRefPtr<GstElement> adoptGRef(GstElement* ptr)
29{
30 ASSERT(!ptr || !g_object_is_floating(ptr));
31 return GRefPtr<GstElement>(ptr, GRefPtrAdopt);
32}
33
34template <> GstElement* refGPtr<GstElement>(GstElement* ptr)
35{
36 if (ptr)
37 gst_object_ref_sink(GST_OBJECT(ptr));
38
39 return ptr;
40}
41
42template <> void derefGPtr<GstElement>(GstElement* ptr)
43{
44 if (ptr)
45 gst_object_unref(ptr);
46}
47
48template <> GRefPtr<GstPad> adoptGRef(GstPad* ptr)
49{
50 ASSERT(!ptr || !g_object_is_floating(ptr));
51 return GRefPtr<GstPad>(ptr, GRefPtrAdopt);
52}
53
54template <> GstPad* refGPtr<GstPad>(GstPad* ptr)
55{
56 if (ptr)
57 gst_object_ref_sink(GST_OBJECT(ptr));
58
59 return ptr;
60}
61
62template <> void derefGPtr<GstPad>(GstPad* ptr)
63{
64 if (ptr)
65 gst_object_unref(GST_OBJECT(ptr));
66}
67
68template <> GRefPtr<GstPadTemplate> adoptGRef(GstPadTemplate* ptr)
69{
70 ASSERT(!ptr || !g_object_is_floating(ptr));
71 return GRefPtr<GstPadTemplate>(ptr, GRefPtrAdopt);
72}
73
74template <> GstPadTemplate* refGPtr<GstPadTemplate>(GstPadTemplate* ptr)
75{
76 if (ptr)
77 gst_object_ref_sink(GST_OBJECT(ptr));
78
79 return ptr;
80}
81
82template <> void derefGPtr<GstPadTemplate>(GstPadTemplate* ptr)
83{
84 if (ptr)
85 gst_object_unref(GST_OBJECT(ptr));
86}
87
88template <> GRefPtr<GstCaps> adoptGRef(GstCaps* ptr)
89{
90 return GRefPtr<GstCaps>(ptr, GRefPtrAdopt);
91}
92
93template <> GstCaps* refGPtr<GstCaps>(GstCaps* ptr)
94{
95 if (ptr)
96 gst_caps_ref(ptr);
97 return ptr;
98}
99
100template <> void derefGPtr<GstCaps>(GstCaps* ptr)
101{
102 if (ptr)
103 gst_caps_unref(ptr);
104}
105
106template <> GRefPtr<GstContext> adoptGRef(GstContext* ptr)
107{
108 return GRefPtr<GstContext>(ptr, GRefPtrAdopt);
109}
110
111template <> GstContext* refGPtr<GstContext>(GstContext* ptr)
112{
113 if (ptr)
114 gst_context_ref(ptr);
115 return ptr;
116}
117
118template <> void derefGPtr<GstContext>(GstContext* ptr)
119{
120 if (ptr)
121 gst_context_unref(ptr);
122}
123
124template <> GRefPtr<GstTask> adoptGRef(GstTask* ptr)
125{
126 // There is no need to check the object reference is floating here because
127 // gst_task_init() always sinks it.
128 return GRefPtr<GstTask>(ptr, GRefPtrAdopt);
129}
130
131template <> GstTask* refGPtr<GstTask>(GstTask* ptr)
132{
133 if (ptr)
134 gst_object_ref_sink(GST_OBJECT(ptr));
135
136 return ptr;
137}
138
139template <> void derefGPtr<GstTask>(GstTask* ptr)
140{
141 if (ptr)
142 gst_object_unref(ptr);
143}
144
145template <> GRefPtr<GstBus> adoptGRef(GstBus* ptr)
146{
147 ASSERT(!ptr || !g_object_is_floating(ptr));
148 return GRefPtr<GstBus>(ptr, GRefPtrAdopt);
149}
150
151template <> GstBus* refGPtr<GstBus>(GstBus* ptr)
152{
153 if (ptr)
154 gst_object_ref_sink(GST_OBJECT(ptr));
155
156 return ptr;
157}
158
159template <> void derefGPtr<GstBus>(GstBus* ptr)
160{
161 if (ptr)
162 gst_object_unref(ptr);
163}
164
165template <> GRefPtr<GstElementFactory> adoptGRef(GstElementFactory* ptr)
166{
167 ASSERT(!ptr || !g_object_is_floating(ptr));
168 return GRefPtr<GstElementFactory>(ptr, GRefPtrAdopt);
169}
170
171template <> GstElementFactory* refGPtr<GstElementFactory>(GstElementFactory* ptr)
172{
173 if (ptr)
174 gst_object_ref_sink(GST_OBJECT(ptr));
175
176 return ptr;
177}
178
179template <> void derefGPtr<GstElementFactory>(GstElementFactory* ptr)
180{
181 if (ptr)
182 gst_object_unref(ptr);
183}
184
185template<> GRefPtr<GstBuffer> adoptGRef(GstBuffer* ptr)
186{
187 return GRefPtr<GstBuffer>(ptr, GRefPtrAdopt);
188}
189
190template<> GstBuffer* refGPtr<GstBuffer>(GstBuffer* ptr)
191{
192 if (ptr)
193 gst_buffer_ref(ptr);
194
195 return ptr;
196}
197
198template<> void derefGPtr<GstBuffer>(GstBuffer* ptr)
199{
200 if (ptr)
201 gst_buffer_unref(ptr);
202}
203
204template<> GRefPtr<GstBufferList> adoptGRef(GstBufferList* ptr)
205{
206 return GRefPtr<GstBufferList>(ptr, GRefPtrAdopt);
207}
208
209template<> GstBufferList* refGPtr<GstBufferList>(GstBufferList* ptr)
210{
211 if (ptr)
212 gst_buffer_list_ref(ptr);
213
214 return ptr;
215}
216
217template<> void derefGPtr<GstBufferList>(GstBufferList* ptr)
218{
219 if (ptr)
220 gst_buffer_list_unref(ptr);
221}
222
223template<> GRefPtr<GstBufferPool> adoptGRef(GstBufferPool* ptr)
224{
225 ASSERT(!ptr || !g_object_is_floating(ptr));
226 return GRefPtr<GstBufferPool>(ptr, GRefPtrAdopt);
227}
228
229template<> GstBufferPool* refGPtr<GstBufferPool>(GstBufferPool* ptr)
230{
231 if (ptr)
232 gst_object_ref_sink(GST_OBJECT(ptr));
233
234 return ptr;
235}
236
237template<> void derefGPtr<GstBufferPool>(GstBufferPool* ptr)
238{
239 if (ptr)
240 gst_object_unref(ptr);
241}
242
243template<> GRefPtr<GstSample> adoptGRef(GstSample* ptr)
244{
245 return GRefPtr<GstSample>(ptr, GRefPtrAdopt);
246}
247
248template<> GstSample* refGPtr<GstSample>(GstSample* ptr)
249{
250 if (ptr)
251 gst_sample_ref(ptr);
252
253 return ptr;
254}
255
256template<> void derefGPtr<GstSample>(GstSample* ptr)
257{
258 if (ptr)
259 gst_sample_unref(ptr);
260}
261
262template<> GRefPtr<GstTagList> adoptGRef(GstTagList* ptr)
263{
264 return GRefPtr<GstTagList>(ptr, GRefPtrAdopt);
265}
266
267template<> GstTagList* refGPtr<GstTagList>(GstTagList* ptr)
268{
269 if (ptr)
270 gst_tag_list_ref(ptr);
271
272 return ptr;
273}
274
275template<> void derefGPtr<GstTagList>(GstTagList* ptr)
276{
277 if (ptr)
278 gst_tag_list_unref(ptr);
279}
280
281template<> GRefPtr<GstEvent> adoptGRef(GstEvent* ptr)
282{
283 return GRefPtr<GstEvent>(ptr, GRefPtrAdopt);
284}
285
286template<> GstEvent* refGPtr<GstEvent>(GstEvent* ptr)
287{
288 if (ptr)
289 gst_event_ref(ptr);
290
291 return ptr;
292}
293
294template<> void derefGPtr<GstEvent>(GstEvent* ptr)
295{
296 if (ptr)
297 gst_event_unref(ptr);
298}
299
300template<> GRefPtr<GstToc> adoptGRef(GstToc* ptr)
301{
302 return GRefPtr<GstToc>(ptr, GRefPtrAdopt);
303}
304
305template<> GstToc* refGPtr<GstToc>(GstToc* ptr)
306{
307 if (ptr)
308 return gst_toc_ref(ptr);
309
310 return ptr;
311}
312
313template<> void derefGPtr<GstToc>(GstToc* ptr)
314{
315 if (ptr)
316 gst_toc_unref(ptr);
317}
318
319template<> GRefPtr<GstMessage> adoptGRef(GstMessage* ptr)
320{
321 return GRefPtr<GstMessage>(ptr, GRefPtrAdopt);
322}
323
324template<> GstMessage* refGPtr<GstMessage>(GstMessage* ptr)
325{
326 if (ptr)
327 return gst_message_ref(ptr);
328
329 return ptr;
330}
331
332template<> void derefGPtr<GstMessage>(GstMessage* ptr)
333{
334 if (ptr)
335 gst_message_unref(ptr);
336}
337
338template <> GRefPtr<GstQuery> adoptGRef(GstQuery* ptr)
339{
340 return GRefPtr<GstQuery>(ptr, GRefPtrAdopt);
341}
342
343template <> GstQuery* refGPtr<GstQuery>(GstQuery* ptr)
344{
345 if (ptr)
346 gst_query_ref(ptr);
347 return ptr;
348}
349
350template <> void derefGPtr<GstQuery>(GstQuery* ptr)
351{
352 if (ptr)
353 gst_query_unref(ptr);
354}
355
356#if GST_CHECK_VERSION(1, 10, 0)
357template <> GRefPtr<GstStream> adoptGRef(GstStream* ptr)
358{
359 return GRefPtr<GstStream>(ptr, GRefPtrAdopt);
360}
361
362template <> GstStream* refGPtr<GstStream>(GstStream* ptr)
363{
364 if (ptr)
365 gst_object_ref(GST_OBJECT_CAST(ptr));
366
367 return ptr;
368}
369
370template <> void derefGPtr<GstStream>(GstStream* ptr)
371{
372 if (ptr)
373 gst_object_unref(ptr);
374}
375
376template <> GRefPtr<GstStreamCollection> adoptGRef(GstStreamCollection* ptr)
377{
378 return GRefPtr<GstStreamCollection>(ptr, GRefPtrAdopt);
379}
380
381template <> GstStreamCollection* refGPtr<GstStreamCollection>(GstStreamCollection* ptr)
382{
383 if (ptr)
384 gst_object_ref(GST_OBJECT_CAST(ptr));
385
386 return ptr;
387}
388
389template <> void derefGPtr<GstStreamCollection>(GstStreamCollection* ptr)
390{
391 if (ptr)
392 gst_object_unref(ptr);
393}
394#endif
395
396template <> GRefPtr<WebKitVideoSink> adoptGRef(WebKitVideoSink* ptr)
397{
398 ASSERT(!ptr || !g_object_is_floating(ptr));
399 return GRefPtr<WebKitVideoSink>(ptr, GRefPtrAdopt);
400}
401
402template <> WebKitVideoSink* refGPtr<WebKitVideoSink>(WebKitVideoSink* ptr)
403{
404 if (ptr)
405 gst_object_ref_sink(GST_OBJECT(ptr));
406
407 return ptr;
408}
409
410template <> void derefGPtr<WebKitVideoSink>(WebKitVideoSink* ptr)
411{
412 if (ptr)
413 gst_object_unref(GST_OBJECT(ptr));
414}
415
416template <> GRefPtr<WebKitWebSrc> adoptGRef(WebKitWebSrc* ptr)
417{
418 ASSERT(!ptr || !g_object_is_floating(ptr));
419 return GRefPtr<WebKitWebSrc>(ptr, GRefPtrAdopt);
420}
421
422// This method is only available for WebKitWebSrc and should not be used for any other type.
423// This is only to work around a bug in GST where the URI downloader is not taking the ownership of WebKitWebSrc.
424// See https://bugs.webkit.org/show_bug.cgi?id=144040.
425GRefPtr<WebKitWebSrc> ensureGRef(WebKitWebSrc* ptr)
426{
427 if (ptr && g_object_is_floating(ptr))
428 gst_object_ref_sink(GST_OBJECT(ptr));
429 return GRefPtr<WebKitWebSrc>(ptr);
430}
431
432template <> WebKitWebSrc* refGPtr<WebKitWebSrc>(WebKitWebSrc* ptr)
433{
434 if (ptr)
435 gst_object_ref_sink(GST_OBJECT(ptr));
436
437 return ptr;
438}
439
440template <> void derefGPtr<WebKitWebSrc>(WebKitWebSrc* ptr)
441{
442 if (ptr)
443 gst_object_unref(GST_OBJECT(ptr));
444}
445
446#if USE(GSTREAMER_GL)
447
448template<> GRefPtr<GstGLDisplay> adoptGRef(GstGLDisplay* ptr)
449{
450 ASSERT(!ptr || !g_object_is_floating(ptr));
451 return GRefPtr<GstGLDisplay>(ptr, GRefPtrAdopt);
452}
453
454template<> GstGLDisplay* refGPtr<GstGLDisplay>(GstGLDisplay* ptr)
455{
456 if (ptr)
457 gst_object_ref_sink(GST_OBJECT(ptr));
458
459 return ptr;
460}
461
462template<> void derefGPtr<GstGLDisplay>(GstGLDisplay* ptr)
463{
464 if (ptr)
465 gst_object_unref(GST_OBJECT(ptr));
466}
467
468template<> GRefPtr<GstGLContext> adoptGRef(GstGLContext* ptr)
469{
470 ASSERT(!ptr || !g_object_is_floating(ptr));
471 return GRefPtr<GstGLContext>(ptr, GRefPtrAdopt);
472}
473
474template<> GstGLContext* refGPtr<GstGLContext>(GstGLContext* ptr)
475{
476 if (ptr)
477 gst_object_ref_sink(GST_OBJECT(ptr));
478
479 return ptr;
480}
481
482template<> void derefGPtr<GstGLContext>(GstGLContext* ptr)
483{
484 if (ptr)
485 gst_object_unref(GST_OBJECT(ptr));
486}
487
488#endif // USE(GSTREAMER_GL)
489
490} // namespace WTF
491
492#endif // USE(GSTREAMER)
493