Merge branch 'master' into 0.11
[platform/upstream/gstreamer.git] / sys / ximage / ximagepool.c
1 /* GStreamer
2  * Copyright (C) <2005> Julien Moutte <julien@moutte.net>
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Library 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  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public
15  * License along with this library; if not, write to the
16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17  * Boston, MA 02111-1307, USA.
18  */
19
20 #ifdef HAVE_CONFIG_H
21 #include "config.h"
22 #endif
23
24 /* Object header */
25 #include "ximagesink.h"
26
27 /* Debugging category */
28 #include <gst/gstinfo.h>
29
30 /* Helper functions */
31 #include <gst/video/video.h>
32 #include <gst/video/gstmetavideo.h>
33 #include <gst/video/gstvideopool.h>
34
35 GST_DEBUG_CATEGORY_EXTERN (gst_debug_ximagepool);
36 #define GST_CAT_DEFAULT gst_debug_ximagepool
37
38 struct _GstXImageBufferPoolPrivate
39 {
40   GstCaps *caps;
41   GstVideoInfo info;
42   GstVideoAlignment align;
43   guint padded_width;
44   guint padded_height;
45   gboolean add_metavideo;
46   gboolean need_alignment;
47 };
48
49 static void gst_meta_ximage_free (GstMetaXImage * meta, GstBuffer * buffer);
50
51 /* ximage metadata */
52 const GstMetaInfo *
53 gst_meta_ximage_get_info (void)
54 {
55   static const GstMetaInfo *meta_ximage_info = NULL;
56
57   if (meta_ximage_info == NULL) {
58     meta_ximage_info = gst_meta_register ("GstMetaXImage", "GstMetaXImage",
59         sizeof (GstMetaXImage),
60         (GstMetaInitFunction) NULL,
61         (GstMetaFreeFunction) gst_meta_ximage_free,
62         (GstMetaCopyFunction) NULL, (GstMetaTransformFunction) NULL);
63   }
64   return meta_ximage_info;
65 }
66
67 /* X11 stuff */
68 static gboolean error_caught = FALSE;
69
70 static int
71 gst_ximagesink_handle_xerror (Display * display, XErrorEvent * xevent)
72 {
73   char error_msg[1024];
74
75   XGetErrorText (display, xevent->error_code, error_msg, 1024);
76   GST_DEBUG ("ximagesink triggered an XError. error: %s", error_msg);
77   error_caught = TRUE;
78   return 0;
79 }
80
81 static GstMetaXImage *
82 gst_buffer_add_meta_ximage (GstBuffer * buffer, GstXImageBufferPool * xpool)
83 {
84   GstXImageSink *ximagesink;
85   int (*handler) (Display *, XErrorEvent *);
86   gboolean success = FALSE;
87   GstXContext *xcontext;
88   GstMetaXImage *meta;
89   gint width, height;
90   GstXImageBufferPoolPrivate *priv;
91
92   priv = xpool->priv;
93   ximagesink = xpool->sink;
94   xcontext = ximagesink->xcontext;
95
96   width = priv->padded_width;
97   height = priv->padded_height;
98
99   meta =
100       (GstMetaXImage *) gst_buffer_add_meta (buffer, GST_META_INFO_XIMAGE,
101       NULL);
102 #ifdef HAVE_XSHM
103   meta->SHMInfo.shmaddr = ((void *) -1);
104   meta->SHMInfo.shmid = -1;
105 #endif
106   meta->x = priv->align.padding_left;
107   meta->y = priv->align.padding_top;
108   meta->width = GST_VIDEO_INFO_WIDTH (&priv->info);
109   meta->height = GST_VIDEO_INFO_HEIGHT (&priv->info);
110   meta->sink = gst_object_ref (ximagesink);
111
112   GST_DEBUG_OBJECT (ximagesink, "creating image %p (%dx%d)", buffer,
113       width, height);
114
115   g_mutex_lock (ximagesink->x_lock);
116
117   /* Setting an error handler to catch failure */
118   error_caught = FALSE;
119   handler = XSetErrorHandler (gst_ximagesink_handle_xerror);
120
121 #ifdef HAVE_XSHM
122   if (xcontext->use_xshm) {
123     meta->ximage = XShmCreateImage (xcontext->disp,
124         xcontext->visual,
125         xcontext->depth, ZPixmap, NULL, &meta->SHMInfo, width, height);
126     if (!meta->ximage || error_caught) {
127       g_mutex_unlock (ximagesink->x_lock);
128
129       /* Reset error flag */
130       error_caught = FALSE;
131
132       /* Push a warning */
133       GST_ELEMENT_WARNING (ximagesink, RESOURCE, WRITE,
134           ("Failed to create output image buffer of %dx%d pixels",
135               width, height),
136           ("could not XShmCreateImage a %dx%d image", width, height));
137
138       /* Retry without XShm */
139       ximagesink->xcontext->use_xshm = FALSE;
140
141       /* Hold X mutex again to try without XShm */
142       g_mutex_lock (ximagesink->x_lock);
143
144       goto no_xshm;
145     }
146
147     /* we have to use the returned bytes_per_line for our shm size */
148     meta->size = meta->ximage->bytes_per_line * meta->ximage->height;
149     GST_LOG_OBJECT (ximagesink,
150         "XShm image size is %" G_GSIZE_FORMAT ", width %d, stride %d",
151         meta->size, width, meta->ximage->bytes_per_line);
152
153     /* get shared memory */
154     meta->SHMInfo.shmid = shmget (IPC_PRIVATE, meta->size, IPC_CREAT | 0777);
155     if (meta->SHMInfo.shmid == -1)
156       goto shmget_failed;
157
158     /* attach */
159     meta->SHMInfo.shmaddr = shmat (meta->SHMInfo.shmid, NULL, 0);
160     if (meta->SHMInfo.shmaddr == ((void *) -1))
161       goto shmat_failed;
162
163     /* now we can set up the image data */
164     meta->ximage->data = meta->SHMInfo.shmaddr;
165     meta->SHMInfo.readOnly = FALSE;
166
167     if (XShmAttach (xcontext->disp, &meta->SHMInfo) == 0)
168       goto xattach_failed;
169
170     XSync (xcontext->disp, FALSE);
171
172     /* Now that everyone has attached, we can delete the shared memory segment.
173      * This way, it will be deleted as soon as we detach later, and not
174      * leaked if we crash. */
175     shmctl (meta->SHMInfo.shmid, IPC_RMID, NULL);
176
177     GST_DEBUG_OBJECT (ximagesink, "XServer ShmAttached to 0x%x, id 0x%lx",
178         meta->SHMInfo.shmid, meta->SHMInfo.shmseg);
179   } else
180   no_xshm:
181 #endif /* HAVE_XSHM */
182   {
183     guint allocsize;
184
185     meta->ximage = XCreateImage (xcontext->disp,
186         xcontext->visual,
187         xcontext->depth, ZPixmap, 0, NULL, width, height, xcontext->bpp, 0);
188     if (!meta->ximage || error_caught)
189       goto create_failed;
190
191     /* upstream will assume that rowstrides are multiples of 4, but this
192      * doesn't always seem to be the case with XCreateImage() */
193     if ((meta->ximage->bytes_per_line % 4) != 0) {
194       GST_WARNING_OBJECT (ximagesink, "returned stride not a multiple of 4 as "
195           "usually assumed");
196     }
197
198     /* we have to use the returned bytes_per_line for our image size */
199     meta->size = meta->ximage->bytes_per_line * meta->ximage->height;
200
201     /* alloc a bit more for unexpected strides to avoid crashes upstream.
202      * FIXME: if we get an unrounded stride, the image will be displayed
203      * distorted, since all upstream elements assume a rounded stride */
204     allocsize =
205         GST_ROUND_UP_4 (meta->ximage->bytes_per_line) * meta->ximage->height;
206
207     meta->ximage->data = g_malloc (allocsize);
208     GST_LOG_OBJECT (ximagesink,
209         "non-XShm image size is %" G_GSIZE_FORMAT " (alloced: %u), width %d, "
210         "stride %d", meta->size, allocsize, width,
211         meta->ximage->bytes_per_line);
212
213     XSync (xcontext->disp, FALSE);
214   }
215
216   /* Reset error handler */
217   error_caught = FALSE;
218   XSetErrorHandler (handler);
219
220   gst_buffer_take_memory (buffer, -1,
221       gst_memory_new_wrapped (GST_MEMORY_FLAG_NO_SHARE, meta->ximage->data,
222           NULL, meta->size, 0, meta->size));
223
224   g_mutex_unlock (ximagesink->x_lock);
225
226   success = TRUE;
227
228 beach:
229   if (!success)
230     meta = NULL;
231
232   return meta;
233
234   /* ERRORS */
235 create_failed:
236   {
237     g_mutex_unlock (ximagesink->x_lock);
238     /* Reset error handler */
239     error_caught = FALSE;
240     XSetErrorHandler (handler);
241     /* Push an error */
242     GST_ELEMENT_ERROR (ximagesink, RESOURCE, WRITE,
243         ("Failed to create output image buffer of %dx%d pixels",
244             width, height),
245         ("could not XShmCreateImage a %dx%d image", width, height));
246     goto beach;
247   }
248 shmget_failed:
249   {
250     g_mutex_unlock (ximagesink->x_lock);
251     GST_ELEMENT_ERROR (ximagesink, RESOURCE, WRITE,
252         ("Failed to create output image buffer of %dx%d pixels",
253             width, height),
254         ("could not get shared memory of %" G_GSIZE_FORMAT " bytes",
255             meta->size));
256     goto beach;
257   }
258 shmat_failed:
259   {
260     g_mutex_unlock (ximagesink->x_lock);
261     GST_ELEMENT_ERROR (ximagesink, RESOURCE, WRITE,
262         ("Failed to create output image buffer of %dx%d pixels",
263             width, height), ("Failed to shmat: %s", g_strerror (errno)));
264     /* Clean up the shared memory segment */
265     shmctl (meta->SHMInfo.shmid, IPC_RMID, NULL);
266     goto beach;
267   }
268 xattach_failed:
269   {
270     /* Clean up the shared memory segment */
271     shmctl (meta->SHMInfo.shmid, IPC_RMID, NULL);
272     g_mutex_unlock (ximagesink->x_lock);
273
274     GST_ELEMENT_ERROR (ximagesink, RESOURCE, WRITE,
275         ("Failed to create output image buffer of %dx%d pixels",
276             width, height), ("Failed to XShmAttach"));
277     goto beach;
278   }
279 }
280
281 static void
282 gst_meta_ximage_free (GstMetaXImage * meta, GstBuffer * buffer)
283 {
284   GstXImageSink *ximagesink;
285
286   ximagesink = meta->sink;
287
288   GST_DEBUG_OBJECT (ximagesink, "free meta on buffer %p", buffer);
289
290   /* Hold the object lock to ensure the XContext doesn't disappear */
291   GST_OBJECT_LOCK (ximagesink);
292   /* We might have some buffers destroyed after changing state to NULL */
293   if (ximagesink->xcontext == NULL) {
294     GST_DEBUG_OBJECT (ximagesink, "Destroying XImage after XContext");
295 #ifdef HAVE_XSHM
296     /* Need to free the shared memory segment even if the x context
297      * was already cleaned up */
298     if (meta->SHMInfo.shmaddr != ((void *) -1)) {
299       shmdt (meta->SHMInfo.shmaddr);
300     }
301 #endif
302     goto beach;
303   }
304
305   g_mutex_lock (ximagesink->x_lock);
306
307 #ifdef HAVE_XSHM
308   if (ximagesink->xcontext->use_xshm) {
309     if (meta->SHMInfo.shmaddr != ((void *) -1)) {
310       GST_DEBUG_OBJECT (ximagesink, "XServer ShmDetaching from 0x%x id 0x%lx",
311           meta->SHMInfo.shmid, meta->SHMInfo.shmseg);
312       XShmDetach (ximagesink->xcontext->disp, &meta->SHMInfo);
313       XSync (ximagesink->xcontext->disp, FALSE);
314       shmdt (meta->SHMInfo.shmaddr);
315       meta->SHMInfo.shmaddr = (void *) -1;
316     }
317     if (meta->ximage)
318       XDestroyImage (meta->ximage);
319   } else
320 #endif /* HAVE_XSHM */
321   {
322     if (meta->ximage) {
323       XDestroyImage (meta->ximage);
324     }
325   }
326
327   XSync (ximagesink->xcontext->disp, FALSE);
328
329   g_mutex_unlock (ximagesink->x_lock);
330
331 beach:
332   GST_OBJECT_UNLOCK (ximagesink);
333
334   gst_object_unref (meta->sink);
335 }
336
337 #ifdef HAVE_XSHM
338 /* This function checks that it is actually really possible to create an image
339    using XShm */
340 gboolean
341 gst_ximagesink_check_xshm_calls (GstXImageSink * ximagesink,
342     GstXContext * xcontext)
343 {
344   XImage *ximage;
345   XShmSegmentInfo SHMInfo;
346   size_t size;
347   int (*handler) (Display *, XErrorEvent *);
348   gboolean result = FALSE;
349   gboolean did_attach = FALSE;
350
351   g_return_val_if_fail (xcontext != NULL, FALSE);
352
353   /* Sync to ensure any older errors are already processed */
354   XSync (xcontext->disp, FALSE);
355
356   /* Set defaults so we don't free these later unnecessarily */
357   SHMInfo.shmaddr = ((void *) -1);
358   SHMInfo.shmid = -1;
359
360   /* Setting an error handler to catch failure */
361   error_caught = FALSE;
362   handler = XSetErrorHandler (gst_ximagesink_handle_xerror);
363
364   /* Trying to create a 1x1 ximage */
365   GST_DEBUG ("XShmCreateImage of 1x1");
366
367   ximage = XShmCreateImage (xcontext->disp, xcontext->visual,
368       xcontext->depth, ZPixmap, NULL, &SHMInfo, 1, 1);
369
370   /* Might cause an error, sync to ensure it is noticed */
371   XSync (xcontext->disp, FALSE);
372   if (!ximage || error_caught) {
373     GST_WARNING ("could not XShmCreateImage a 1x1 image");
374     goto beach;
375   }
376   size = ximage->height * ximage->bytes_per_line;
377
378   SHMInfo.shmid = shmget (IPC_PRIVATE, size, IPC_CREAT | 0777);
379   if (SHMInfo.shmid == -1) {
380     GST_WARNING ("could not get shared memory of %" G_GSIZE_FORMAT " bytes",
381         size);
382     goto beach;
383   }
384
385   SHMInfo.shmaddr = shmat (SHMInfo.shmid, NULL, 0);
386   if (SHMInfo.shmaddr == ((void *) -1)) {
387     GST_WARNING ("Failed to shmat: %s", g_strerror (errno));
388     /* Clean up the shared memory segment */
389     shmctl (SHMInfo.shmid, IPC_RMID, NULL);
390     goto beach;
391   }
392
393   ximage->data = SHMInfo.shmaddr;
394   SHMInfo.readOnly = FALSE;
395
396   if (XShmAttach (xcontext->disp, &SHMInfo) == 0) {
397     GST_WARNING ("Failed to XShmAttach");
398     /* Clean up the shared memory segment */
399     shmctl (SHMInfo.shmid, IPC_RMID, NULL);
400     goto beach;
401   }
402
403   /* Sync to ensure we see any errors we caused */
404   XSync (xcontext->disp, FALSE);
405
406   /* Delete the shared memory segment as soon as everyone is attached.
407    * This way, it will be deleted as soon as we detach later, and not
408    * leaked if we crash. */
409   shmctl (SHMInfo.shmid, IPC_RMID, NULL);
410
411   if (!error_caught) {
412     GST_DEBUG ("XServer ShmAttached to 0x%x, id 0x%lx", SHMInfo.shmid,
413         SHMInfo.shmseg);
414
415     did_attach = TRUE;
416     /* store whether we succeeded in result */
417     result = TRUE;
418   } else {
419     GST_WARNING ("MIT-SHM extension check failed at XShmAttach. "
420         "Not using shared memory.");
421   }
422
423 beach:
424   /* Sync to ensure we swallow any errors we caused and reset error_caught */
425   XSync (xcontext->disp, FALSE);
426
427   error_caught = FALSE;
428   XSetErrorHandler (handler);
429
430   if (did_attach) {
431     GST_DEBUG ("XServer ShmDetaching from 0x%x id 0x%lx",
432         SHMInfo.shmid, SHMInfo.shmseg);
433     XShmDetach (xcontext->disp, &SHMInfo);
434     XSync (xcontext->disp, FALSE);
435   }
436   if (SHMInfo.shmaddr != ((void *) -1))
437     shmdt (SHMInfo.shmaddr);
438   if (ximage)
439     XDestroyImage (ximage);
440   return result;
441 }
442 #endif /* HAVE_XSHM */
443
444 /* bufferpool */
445 static void gst_ximage_buffer_pool_finalize (GObject * object);
446
447 #define GST_XIMAGE_BUFFER_POOL_GET_PRIVATE(obj)  \
448    (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_XIMAGE_BUFFER_POOL, GstXImageBufferPoolPrivate))
449
450 #define gst_ximage_buffer_pool_parent_class parent_class
451 G_DEFINE_TYPE (GstXImageBufferPool, gst_ximage_buffer_pool,
452     GST_TYPE_BUFFER_POOL);
453
454 static const gchar **
455 ximage_buffer_pool_get_options (GstBufferPool * pool)
456 {
457   static const gchar *options[] = { GST_BUFFER_POOL_OPTION_META_VIDEO,
458     GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT, NULL
459   };
460
461   return options;
462 }
463
464 static gboolean
465 ximage_buffer_pool_set_config (GstBufferPool * pool, GstStructure * config)
466 {
467   GstXImageBufferPool *xpool = GST_XIMAGE_BUFFER_POOL_CAST (pool);
468   GstXImageBufferPoolPrivate *priv = xpool->priv;
469   GstVideoInfo info;
470   const GstCaps *caps;
471
472   if (!gst_buffer_pool_config_get (config, &caps, NULL, NULL, NULL, NULL, NULL))
473     goto wrong_config;
474
475   if (caps == NULL)
476     goto no_caps;
477
478   /* now parse the caps from the config */
479   if (!gst_video_info_from_caps (&info, caps))
480     goto wrong_caps;
481
482   priv->info = info;
483
484   GST_LOG_OBJECT (pool, "%dx%d, caps %" GST_PTR_FORMAT, info.width, info.height,
485       caps);
486
487   /* keep track of the width and height and caps */
488   if (priv->caps)
489     gst_caps_unref (priv->caps);
490   priv->caps = gst_caps_copy (caps);
491
492   /* check for the configured metadata */
493   priv->add_metavideo =
494       gst_buffer_pool_config_has_option (config,
495       GST_BUFFER_POOL_OPTION_META_VIDEO);
496
497   /* parse extra alignment info */
498   priv->need_alignment = gst_buffer_pool_config_has_option (config,
499       GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT);
500
501   if (priv->need_alignment) {
502     gst_buffer_pool_config_get_video_alignment (config, &priv->align);
503
504     GST_LOG_OBJECT (pool, "padding %u-%ux%u-%u", priv->align.padding_top,
505         priv->align.padding_left, priv->align.padding_left,
506         priv->align.padding_bottom);
507
508     /* we need the video metadata too now */
509     priv->add_metavideo = TRUE;
510   }
511
512   /* add the padding */
513   priv->padded_width =
514       GST_VIDEO_INFO_WIDTH (&info) + priv->align.padding_left +
515       priv->align.padding_right;
516   priv->padded_height =
517       GST_VIDEO_INFO_HEIGHT (&info) + priv->align.padding_top +
518       priv->align.padding_bottom;
519
520   return GST_BUFFER_POOL_CLASS (parent_class)->set_config (pool, config);
521
522   /* ERRORS */
523 wrong_config:
524   {
525     GST_WARNING_OBJECT (pool, "invalid config");
526     return FALSE;
527   }
528 no_caps:
529   {
530     GST_WARNING_OBJECT (pool, "no caps in config");
531     return FALSE;
532   }
533 wrong_caps:
534   {
535     GST_WARNING_OBJECT (pool,
536         "failed getting geometry from caps %" GST_PTR_FORMAT, caps);
537     return FALSE;
538   }
539 }
540
541 /* This function handles GstXImageBuffer creation depending on XShm availability */
542 static GstFlowReturn
543 ximage_buffer_pool_alloc (GstBufferPool * pool, GstBuffer ** buffer,
544     GstBufferPoolParams * params)
545 {
546   GstXImageBufferPool *xpool = GST_XIMAGE_BUFFER_POOL_CAST (pool);
547   GstXImageBufferPoolPrivate *priv = xpool->priv;
548   GstVideoInfo *info;
549   GstBuffer *ximage;
550   GstMetaXImage *meta;
551
552   info = &priv->info;
553
554   ximage = gst_buffer_new ();
555   meta = gst_buffer_add_meta_ximage (ximage, xpool);
556   if (meta == NULL) {
557     gst_buffer_unref (ximage);
558     goto no_buffer;
559   }
560   if (priv->add_metavideo) {
561     GstMetaVideo *meta;
562
563     GST_DEBUG_OBJECT (pool, "adding GstMetaVideo");
564     /* these are just the defaults for now */
565     meta = gst_buffer_add_meta_video (ximage, 0, GST_VIDEO_INFO_FORMAT (info),
566         priv->padded_width, priv->padded_height);
567
568     if (priv->need_alignment) {
569       gint vpad, hpad, pstride;
570
571       vpad = priv->align.padding_left;
572       hpad = priv->align.padding_top;
573
574       meta->width = GST_VIDEO_INFO_WIDTH (&priv->info);
575       meta->height = GST_VIDEO_INFO_HEIGHT (&priv->info);
576       pstride = GST_VIDEO_INFO_COMP_PSTRIDE (&priv->info, 0);
577
578       meta->offset[0] += (vpad * meta->stride[0]) + (hpad * pstride);
579     }
580   }
581   *buffer = ximage;
582
583   return GST_FLOW_OK;
584
585   /* ERROR */
586 no_buffer:
587   {
588     GST_WARNING_OBJECT (pool, "can't create image");
589     return GST_FLOW_ERROR;
590   }
591 }
592
593 static void
594 ximage_buffer_pool_free (GstBufferPool * pool, GstBuffer * buffer)
595 {
596   gst_buffer_unref (buffer);
597 }
598
599 GstBufferPool *
600 gst_ximage_buffer_pool_new (GstXImageSink * ximagesink)
601 {
602   GstXImageBufferPool *pool;
603
604   g_return_val_if_fail (GST_IS_XIMAGESINK (ximagesink), NULL);
605
606   pool = g_object_new (GST_TYPE_XIMAGE_BUFFER_POOL, NULL);
607   pool->sink = gst_object_ref (ximagesink);
608
609   GST_LOG_OBJECT (pool, "new XImage buffer pool %p", pool);
610
611   return GST_BUFFER_POOL_CAST (pool);
612 }
613
614 static void
615 gst_ximage_buffer_pool_class_init (GstXImageBufferPoolClass * klass)
616 {
617   GObjectClass *gobject_class = (GObjectClass *) klass;
618   GstBufferPoolClass *gstbufferpool_class = (GstBufferPoolClass *) klass;
619
620   g_type_class_add_private (klass, sizeof (GstXImageBufferPoolPrivate));
621
622   gobject_class->finalize = gst_ximage_buffer_pool_finalize;
623
624   gstbufferpool_class->get_options = ximage_buffer_pool_get_options;
625   gstbufferpool_class->set_config = ximage_buffer_pool_set_config;
626   gstbufferpool_class->alloc_buffer = ximage_buffer_pool_alloc;
627   gstbufferpool_class->free_buffer = ximage_buffer_pool_free;
628 }
629
630 static void
631 gst_ximage_buffer_pool_init (GstXImageBufferPool * pool)
632 {
633   pool->priv = GST_XIMAGE_BUFFER_POOL_GET_PRIVATE (pool);
634 }
635
636 static void
637 gst_ximage_buffer_pool_finalize (GObject * object)
638 {
639   GstXImageBufferPool *pool = GST_XIMAGE_BUFFER_POOL_CAST (object);
640   GstXImageBufferPoolPrivate *priv = pool->priv;
641
642   GST_LOG_OBJECT (pool, "finalize XImage buffer pool %p", pool);
643
644   if (priv->caps)
645     gst_caps_unref (priv->caps);
646   gst_object_unref (pool->sink);
647
648   G_OBJECT_CLASS (gst_ximage_buffer_pool_parent_class)->finalize (object);
649 }