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(G_OBJECT(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(G_OBJECT(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(G_OBJECT(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(G_OBJECT(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     ASSERT(!g_object_is_floating(G_OBJECT(ptr)));
 128     return GRefPtr<GstTask>(ptr, GRefPtrAdopt);
 129 }
 130
 131 template <> GstTask* refGPtr<GstTask>(GstTask* ptr)
 132 {
 133     if (ptr)
 134         gst_object_ref_sink(GST_OBJECT(ptr));
 135
 136     return ptr;
 137 }
 138
 139 template <> void derefGPtr<GstTask>(GstTask* ptr)
 140 {
 141     if (ptr)
 142         gst_object_unref(ptr);
 143 }
 144
 145 template <> GRefPtr<GstBus> adoptGRef(GstBus* ptr)
 146 {
 147     ASSERT(!g_object_is_floating(G_OBJECT(ptr)));
 148     return GRefPtr<GstBus>(ptr, GRefPtrAdopt);
 149 }
 150
 151 template <> GstBus* refGPtr<GstBus>(GstBus* ptr)
 152 {
 153     if (ptr)
 154         gst_object_ref_sink(GST_OBJECT(ptr));
 155
 156     return ptr;
 157 }
 158
 159 template <> void derefGPtr<GstBus>(GstBus* ptr)
 160 {
 161     if (ptr)
 162         gst_object_unref(ptr);
 163 }
 164
 165 template <> GRefPtr<GstElementFactory> adoptGRef(GstElementFactory* ptr)
 166 {
 167     ASSERT(!g_object_is_floating(G_OBJECT(ptr)));
 168     return GRefPtr<GstElementFactory>(ptr, GRefPtrAdopt);
 169 }
 170
 171 template <> GstElementFactory* refGPtr<GstElementFactory>(GstElementFactory* ptr)
 172 {
 173     if (ptr)
 174         gst_object_ref_sink(GST_OBJECT(ptr));
 175
 176     return ptr;
 177 }
 178
 179 template <> void derefGPtr<GstElementFactory>(GstElementFactory* ptr)
 180 {
 181     if (ptr)
 182         gst_object_unref(ptr);
 183 }
 184
 185 template<> GRefPtr<GstBuffer> adoptGRef(GstBuffer* ptr)
 186 {
 187     return GRefPtr<GstBuffer>(ptr, GRefPtrAdopt);
 188 }
 189
 190 template<> GstBuffer* refGPtr<GstBuffer>(GstBuffer* ptr)
 191 {
 192     if (ptr)
 193         gst_buffer_ref(ptr);
 194
 195     return ptr;
 196 }
 197
 198 template<> void derefGPtr<GstBuffer>(GstBuffer* ptr)
 199 {
 200     if (ptr)
 201         gst_buffer_unref(ptr);
 202 }
 203
 204 template<> GRefPtr<GstBufferList> adoptGRef(GstBufferList* ptr)
 205 {
 206     return GRefPtr<GstBufferList>(ptr, GRefPtrAdopt);
 207 }
 208
 209 template<> GstBufferList* refGPtr<GstBufferList>(GstBufferList* ptr)
 210 {
 211     if (ptr)
 212         gst_buffer_list_ref(ptr);
 213
 214     return ptr;
 215 }
 216
 217 template<> void derefGPtr<GstBufferList>(GstBufferList* ptr)
 218 {
 219     if (ptr)
 220         gst_buffer_list_unref(ptr);
 221 }
 222
 223 template<> GRefPtr<GstSample> adoptGRef(GstSample* ptr)
 224 {
 225     return GRefPtr<GstSample>(ptr, GRefPtrAdopt);
 226 }
 227
 228 template<> GstSample* refGPtr<GstSample>(GstSample* ptr)
 229 {
 230     if (ptr)
 231         gst_sample_ref(ptr);
 232
 233     return ptr;
 234 }
 235
 236 template<> void derefGPtr<GstSample>(GstSample* ptr)
 237 {
 238     if (ptr)
 239         gst_sample_unref(ptr);
 240 }
 241
 242 template<> GRefPtr<GstTagList> adoptGRef(GstTagList* ptr)
 243 {
 244     return GRefPtr<GstTagList>(ptr, GRefPtrAdopt);
 245 }
 246
 247 template<> GstTagList* refGPtr<GstTagList>(GstTagList* ptr)
 248 {
 249     if (ptr)
 250         gst_tag_list_ref(ptr);
 251
 252     return ptr;
 253 }
 254
 255 template<> void derefGPtr<GstTagList>(GstTagList* ptr)
 256 {
 257     if (ptr)
 258         gst_tag_list_unref(ptr);
 259 }
 260
 261 template<> GRefPtr<GstEvent> adoptGRef(GstEvent* ptr)
 262 {
 263     return GRefPtr<GstEvent>(ptr, GRefPtrAdopt);
 264 }
 265
 266 template<> GstEvent* refGPtr<GstEvent>(GstEvent* ptr)
 267 {
 268     if (ptr)
 269         gst_event_ref(ptr);
 270
 271     return ptr;
 272 }
 273
 274 template<> void derefGPtr<GstEvent>(GstEvent* ptr)
 275 {
 276     if (ptr)
 277         gst_event_unref(ptr);
 278 }
 279
 280 template<> GRefPtr<GstToc> adoptGRef(GstToc* ptr)
 281 {
 282     return GRefPtr<GstToc>(ptr, GRefPtrAdopt);
 283 }
 284
 285 template<> GstToc* refGPtr<GstToc>(GstToc* ptr)
 286 {
 287     if (ptr)
 288         return gst_toc_ref(ptr);
 289
 290     return ptr;
 291 }
 292
 293 template<> void derefGPtr<GstToc>(GstToc* ptr)
 294 {
 295     if (ptr)
 296         gst_toc_unref(ptr);
 297 }
 298
 299 template<> GRefPtr<GstMessage> adoptGRef(GstMessage* ptr)
 300 {
 301     return GRefPtr<GstMessage>(ptr, GRefPtrAdopt);
 302 }
 303
 304 template<> GstMessage* refGPtr<GstMessage>(GstMessage* ptr)
 305 {
 306     if (ptr)
 307         return gst_message_ref(ptr);
 308
 309     return ptr;
 310 }
 311
 312 template<> void derefGPtr<GstMessage>(GstMessage* ptr)
 313 {
 314     if (ptr)
 315         gst_message_unref(ptr);
 316 }
 317
 318 template <> GRefPtr<WebKitVideoSink> adoptGRef(WebKitVideoSink* ptr)
 319 {
 320     ASSERT(!ptr || !g_object_is_floating(G_OBJECT(ptr)));
 321     return GRefPtr<WebKitVideoSink>(ptr, GRefPtrAdopt);
 322 }
 323
 324 template <> WebKitVideoSink* refGPtr<WebKitVideoSink>(WebKitVideoSink* ptr)
 325 {
 326     if (ptr)
 327         gst_object_ref_sink(GST_OBJECT(ptr));
 328
 329     return ptr;
 330 }
 331
 332 template <> void derefGPtr<WebKitVideoSink>(WebKitVideoSink* ptr)
 333 {
 334     if (ptr)
 335         gst_object_unref(GST_OBJECT(ptr));
 336 }
 337
 338 template <> GRefPtr<WebKitWebSrc> adoptGRef(WebKitWebSrc* ptr)
 339 {
 340     ASSERT(!ptr || !g_object_is_floating(G_OBJECT(ptr)));
 341     return GRefPtr<WebKitWebSrc>(ptr, GRefPtrAdopt);
 342 }
 343
 344 template <> WebKitWebSrc* refGPtr<WebKitWebSrc>(WebKitWebSrc* ptr)
 345 {
 346     if (ptr)
 347         gst_object_ref_sink(GST_OBJECT(ptr));
 348
 349     return ptr;
 350 }
 351
 352 template <> void derefGPtr<WebKitWebSrc>(WebKitWebSrc* ptr)
 353 {
 354     if (ptr)
 355         gst_object_unref(GST_OBJECT(ptr));
 356 }
 357
 358 } // namespace WTF
 359
 360 #endif // USE(GSTREAMER)