658bc8a84918e5e01148bdaebb3d52125307a401
[platform/upstream/gstreamer.git] / gst / colorspace / gstcolorspace.c
1 /* GStreamer
2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
3  * This file:
4  * Copyright (C) 2003 Ronald Bultje <rbultje@ronald.bitfreak.net>
5  * Copyright (C) 2010 David Schleef <ds@schleef.org>
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public
18  * License along with this library; if not, write to the
19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20  * Boston, MA 02111-1307, USA.
21  */
22
23 /**
24  * SECTION:element-colorspace
25  *
26  * Convert video frames between a great variety of colorspace formats.
27  *
28  * <refsect2>
29  * <title>Example launch line</title>
30  * |[
31  * gst-launch -v videotestsrc ! video/x-raw-yuv,format=\(fourcc\)YUY2 ! colorspace ! ximagesink
32  * ]|
33  * </refsect2>
34  */
35
36 #ifdef HAVE_CONFIG_H
37 #  include "config.h"
38 #endif
39
40 #include "gstcolorspace.h"
41 #include <gst/video/video.h>
42
43 #include <string.h>
44
45 GST_DEBUG_CATEGORY (colorspace_debug);
46 #define GST_CAT_DEFAULT colorspace_debug
47 GST_DEBUG_CATEGORY (colorspace_performance);
48
49 enum
50 {
51   PROP_0,
52   PROP_DITHER
53 };
54
55 #define CSP_VIDEO_CAPS                                          \
56   "video/x-raw-yuv, width = "GST_VIDEO_SIZE_RANGE" , "                  \
57   "height="GST_VIDEO_SIZE_RANGE",framerate="GST_VIDEO_FPS_RANGE","      \
58   "format= (fourcc) { I420 , NV12 , NV21 , YV12 , YUY2 , Y42B , Y444 , YUV9 , YVU9 , Y41B , Y800 , Y8 , GREY , Y16 , UYVY , YVYU , IYU1 , v308 , AYUV, v210, v216, A420, AY64 } ;" \
59   GST_VIDEO_CAPS_RGB";"                                                 \
60   GST_VIDEO_CAPS_BGR";"                                                 \
61   GST_VIDEO_CAPS_RGBx";"                                                \
62   GST_VIDEO_CAPS_xRGB";"                                                \
63   GST_VIDEO_CAPS_BGRx";"                                                \
64   GST_VIDEO_CAPS_xBGR";"                                                \
65   GST_VIDEO_CAPS_RGBA";"                                                \
66   GST_VIDEO_CAPS_ARGB";"                                                \
67   GST_VIDEO_CAPS_BGRA";"                                                \
68   GST_VIDEO_CAPS_ABGR";"                                                \
69   GST_VIDEO_CAPS_RGB_16";"                                              \
70   GST_VIDEO_CAPS_BGR_16";"                                              \
71   GST_VIDEO_CAPS_RGB_15";"                                              \
72   GST_VIDEO_CAPS_BGR_15";"                                              \
73   GST_VIDEO_CAPS_RGB8_PALETTED "; "                                     \
74   GST_VIDEO_CAPS_GRAY8";"                                               \
75   GST_VIDEO_CAPS_GRAY16("BIG_ENDIAN")";"                                \
76   GST_VIDEO_CAPS_GRAY16("LITTLE_ENDIAN")";"                             \
77   GST_VIDEO_CAPS_ARGB_64
78
79 static GstStaticPadTemplate gst_csp_src_template =
80 GST_STATIC_PAD_TEMPLATE ("src",
81     GST_PAD_SRC,
82     GST_PAD_ALWAYS,
83     GST_STATIC_CAPS (CSP_VIDEO_CAPS)
84     );
85
86 static GstStaticPadTemplate gst_csp_sink_template =
87 GST_STATIC_PAD_TEMPLATE ("sink",
88     GST_PAD_SINK,
89     GST_PAD_ALWAYS,
90     GST_STATIC_CAPS (CSP_VIDEO_CAPS)
91     );
92
93 GType gst_csp_get_type (void);
94
95 static void gst_csp_set_property (GObject * object,
96     guint property_id, const GValue * value, GParamSpec * pspec);
97 static void gst_csp_get_property (GObject * object,
98     guint property_id, GValue * value, GParamSpec * pspec);
99 static void gst_csp_dispose (GObject * object);
100
101 static gboolean gst_csp_set_caps (GstBaseTransform * btrans,
102     GstCaps * incaps, GstCaps * outcaps);
103 static gboolean gst_csp_get_unit_size (GstBaseTransform * btrans,
104     GstCaps * caps, guint * size);
105 static GstFlowReturn gst_csp_transform (GstBaseTransform * btrans,
106     GstBuffer * inbuf, GstBuffer * outbuf);
107
108 static GQuark _QRAWRGB;         /* "video/x-raw-rgb" */
109 static GQuark _QRAWYUV;         /* "video/x-raw-yuv" */
110 static GQuark _QALPHAMASK;      /* "alpha_mask" */
111
112
113 static GType
114 dither_method_get_type (void)
115 {
116   static GType gtype = 0;
117
118   if (gtype == 0) {
119     static const GEnumValue values[] = {
120       {DITHER_NONE, "No dithering (default)", "none"},
121       {DITHER_VERTERR, "Vertical error propogation", "verterr"},
122       {DITHER_HALFTONE, "Half-tone", "halftone"},
123       {0, NULL, NULL}
124     };
125
126     gtype = g_enum_register_static ("GstColorspaceDitherMethod", values);
127   }
128   return gtype;
129 }
130
131 /* copies the given caps */
132 static GstCaps *
133 gst_csp_caps_remove_format_info (GstCaps * caps)
134 {
135   GstStructure *yuvst, *rgbst, *grayst;
136
137   /* We know there's only one structure since we're given simple caps */
138   caps = gst_caps_copy (caps);
139
140   yuvst = gst_caps_get_structure (caps, 0);
141
142   gst_structure_set_name (yuvst, "video/x-raw-yuv");
143   gst_structure_remove_fields (yuvst, "format", "endianness", "depth",
144       "bpp", "red_mask", "green_mask", "blue_mask", "alpha_mask",
145       "palette_data", "color-matrix", NULL);
146
147   rgbst = gst_structure_copy (yuvst);
148   gst_structure_set_name (rgbst, "video/x-raw-rgb");
149   gst_structure_remove_fields (rgbst, "color-matrix", "chroma-site", NULL);
150
151   grayst = gst_structure_copy (rgbst);
152   gst_structure_set_name (grayst, "video/x-raw-gray");
153
154   gst_caps_append_structure (caps, rgbst);
155   gst_caps_append_structure (caps, grayst);
156
157   return caps;
158 }
159
160
161 static gboolean
162 gst_csp_structure_is_alpha (GstStructure * s)
163 {
164   GQuark name;
165
166   name = gst_structure_get_name_id (s);
167
168   if (name == _QRAWRGB) {
169     return gst_structure_id_has_field (s, _QALPHAMASK);
170   } else if (name == _QRAWYUV) {
171     guint32 fourcc;
172
173     if (!gst_structure_get_fourcc (s, "format", &fourcc))
174       return FALSE;
175
176     return (fourcc == GST_MAKE_FOURCC ('A', 'Y', 'U', 'V'));
177   }
178
179   return FALSE;
180 }
181
182 /* The caps can be transformed into any other caps with format info removed.
183  * However, we should prefer passthrough, so if passthrough is possible,
184  * put it first in the list. */
185 static GstCaps *
186 gst_csp_transform_caps (GstBaseTransform * btrans,
187     GstPadDirection direction, GstCaps * caps)
188 {
189   GstCaps *template;
190   GstCaps *tmp, *tmp2;
191   GstCaps *result;
192   GstStructure *s;
193   GstCaps *alpha, *non_alpha;
194
195   template = gst_static_pad_template_get_caps (&gst_csp_src_template);
196   result = gst_caps_copy (caps);
197
198   /* Get all possible caps that we can transform to */
199   tmp = gst_csp_caps_remove_format_info (caps);
200   tmp2 = gst_caps_intersect (tmp, template);
201   gst_caps_unref (tmp);
202   tmp = tmp2;
203
204   /* Now move alpha formats to the beginning if caps is an alpha format
205    * or at the end if caps is no alpha format */
206   alpha = gst_caps_new_empty ();
207   non_alpha = gst_caps_new_empty ();
208
209   while ((s = gst_caps_steal_structure (tmp, 0))) {
210     if (gst_csp_structure_is_alpha (s))
211       gst_caps_append_structure (alpha, s);
212     else
213       gst_caps_append_structure (non_alpha, s);
214   }
215
216   s = gst_caps_get_structure (caps, 0);
217   gst_caps_unref (tmp);
218
219   if (gst_csp_structure_is_alpha (s)) {
220     gst_caps_append (alpha, non_alpha);
221     tmp = alpha;
222   } else {
223     gst_caps_append (non_alpha, alpha);
224     tmp = non_alpha;
225   }
226
227   gst_caps_append (result, tmp);
228
229   GST_DEBUG_OBJECT (btrans, "transformed %" GST_PTR_FORMAT " into %"
230       GST_PTR_FORMAT, caps, result);
231
232   return result;
233 }
234
235 static gboolean
236 gst_csp_set_caps (GstBaseTransform * btrans, GstCaps * incaps,
237     GstCaps * outcaps)
238 {
239   GstCsp *space;
240   GstVideoFormat in_format;
241   GstVideoFormat out_format;
242   gint in_height, in_width;
243   gint out_height, out_width;
244   gint in_fps_n, in_fps_d, in_par_n, in_par_d;
245   gint out_fps_n, out_fps_d, out_par_n, out_par_d;
246   gboolean have_in_par, have_out_par;
247   gboolean have_in_interlaced, have_out_interlaced;
248   gboolean in_interlaced, out_interlaced;
249   gboolean ret;
250   ColorSpaceColorSpec in_spec, out_spec;
251
252   space = GST_CSP (btrans);
253
254   if (space->convert) {
255     colorspace_convert_free (space->convert);
256   }
257
258   /* input caps */
259
260   ret = gst_video_format_parse_caps (incaps, &in_format, &in_width, &in_height);
261   if (!ret)
262     goto no_width_height;
263
264   ret = gst_video_parse_caps_framerate (incaps, &in_fps_n, &in_fps_d);
265   if (!ret)
266     goto no_framerate;
267
268   have_in_par = gst_video_parse_caps_pixel_aspect_ratio (incaps,
269       &in_par_n, &in_par_d);
270   have_in_interlaced = gst_video_format_parse_caps_interlaced (incaps,
271       &in_interlaced);
272
273   if (gst_video_format_is_rgb (in_format)) {
274     in_spec = COLOR_SPEC_RGB;
275   } else if (gst_video_format_is_yuv (in_format)) {
276     const gchar *matrix = gst_video_parse_caps_color_matrix (incaps);
277
278     if (matrix && g_str_equal (matrix, "hdtv"))
279       in_spec = COLOR_SPEC_YUV_BT709;
280     else
281       in_spec = COLOR_SPEC_YUV_BT470_6;
282   } else {
283     in_spec = COLOR_SPEC_GRAY;
284   }
285
286   /* output caps */
287
288   ret =
289       gst_video_format_parse_caps (outcaps, &out_format, &out_width,
290       &out_height);
291   if (!ret)
292     goto no_width_height;
293
294   ret = gst_video_parse_caps_framerate (outcaps, &out_fps_n, &out_fps_d);
295   if (!ret)
296     goto no_framerate;
297
298   have_out_par = gst_video_parse_caps_pixel_aspect_ratio (outcaps,
299       &out_par_n, &out_par_d);
300   have_out_interlaced = gst_video_format_parse_caps_interlaced (incaps,
301       &out_interlaced);
302
303   if (gst_video_format_is_rgb (out_format)) {
304     out_spec = COLOR_SPEC_RGB;
305   } else if (gst_video_format_is_yuv (out_format)) {
306     const gchar *matrix = gst_video_parse_caps_color_matrix (outcaps);
307
308     if (matrix && g_str_equal (matrix, "hdtv"))
309       out_spec = COLOR_SPEC_YUV_BT709;
310     else
311       out_spec = COLOR_SPEC_YUV_BT470_6;
312   } else {
313     out_spec = COLOR_SPEC_GRAY;
314   }
315
316   /* these must match */
317   if (in_width != out_width || in_height != out_height ||
318       in_fps_n != out_fps_n || in_fps_d != out_fps_d)
319     goto format_mismatch;
320
321   /* if present, these must match too */
322   if (have_in_par && have_out_par &&
323       (in_par_n != out_par_n || in_par_d != out_par_d))
324     goto format_mismatch;
325
326   /* if present, these must match too */
327   if (have_in_interlaced && have_out_interlaced &&
328       in_interlaced != out_interlaced)
329     goto format_mismatch;
330
331   space->from_format = in_format;
332   space->from_spec = in_spec;
333   space->to_format = out_format;
334   space->to_spec = out_spec;
335   space->width = in_width;
336   space->height = in_height;
337   space->interlaced = in_interlaced;
338
339   space->convert = colorspace_convert_new (out_format, out_spec, in_format,
340       in_spec, in_width, in_height);
341   if (space->convert) {
342     colorspace_convert_set_interlaced (space->convert, in_interlaced);
343   }
344   /* palette, only for from data */
345   if (space->from_format == GST_VIDEO_FORMAT_RGB8_PALETTED &&
346       space->to_format == GST_VIDEO_FORMAT_RGB8_PALETTED) {
347     goto format_mismatch;
348   } else if (space->from_format == GST_VIDEO_FORMAT_RGB8_PALETTED) {
349     GstBuffer *palette;
350
351     palette = gst_video_parse_caps_palette (incaps);
352
353     if (!palette || GST_BUFFER_SIZE (palette) < 256 * 4) {
354       if (palette)
355         gst_buffer_unref (palette);
356       goto invalid_palette;
357     }
358     colorspace_convert_set_palette (space->convert,
359         (const guint32 *) GST_BUFFER_DATA (palette));
360     gst_buffer_unref (palette);
361   } else if (space->to_format == GST_VIDEO_FORMAT_RGB8_PALETTED) {
362     const guint32 *palette;
363     GstBuffer *p_buf;
364
365     palette = colorspace_convert_get_palette (space->convert);
366     p_buf = gst_buffer_new_and_alloc (256 * 4);
367     memcpy (GST_BUFFER_DATA (p_buf), palette, 256 * 4);
368     gst_caps_set_simple (outcaps, "palette_data", GST_TYPE_BUFFER, p_buf, NULL);
369     gst_buffer_unref (p_buf);
370   }
371
372   GST_DEBUG ("reconfigured %d %d", space->from_format, space->to_format);
373
374   return TRUE;
375
376   /* ERRORS */
377 no_width_height:
378   {
379     GST_ERROR_OBJECT (space, "did not specify width or height");
380     space->from_format = GST_VIDEO_FORMAT_UNKNOWN;
381     space->to_format = GST_VIDEO_FORMAT_UNKNOWN;
382     return FALSE;
383   }
384 no_framerate:
385   {
386     GST_ERROR_OBJECT (space, "did not specify framerate");
387     space->from_format = GST_VIDEO_FORMAT_UNKNOWN;
388     space->to_format = GST_VIDEO_FORMAT_UNKNOWN;
389     return FALSE;
390   }
391 format_mismatch:
392   {
393     GST_ERROR_OBJECT (space, "input and output formats do not match");
394     space->from_format = GST_VIDEO_FORMAT_UNKNOWN;
395     space->to_format = GST_VIDEO_FORMAT_UNKNOWN;
396     return FALSE;
397   }
398 invalid_palette:
399   {
400     GST_ERROR_OBJECT (space, "invalid palette");
401     space->from_format = GST_VIDEO_FORMAT_UNKNOWN;
402     space->to_format = GST_VIDEO_FORMAT_UNKNOWN;
403     return FALSE;
404   }
405 }
406
407 GST_BOILERPLATE (GstCsp, gst_csp, GstVideoFilter, GST_TYPE_VIDEO_FILTER);
408
409 static void
410 gst_csp_base_init (gpointer klass)
411 {
412   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
413
414   gst_element_class_add_pad_template (element_class,
415       gst_static_pad_template_get (&gst_csp_src_template));
416   gst_element_class_add_pad_template (element_class,
417       gst_static_pad_template_get (&gst_csp_sink_template));
418
419   gst_element_class_set_details_simple (element_class,
420       " Colorspace converter", "Filter/Converter/Video",
421       "Converts video from one colorspace to another",
422       "GStreamer maintainers <gstreamer-devel@lists.sourceforge.net>");
423
424   _QRAWRGB = g_quark_from_string ("video/x-raw-rgb");
425   _QRAWYUV = g_quark_from_string ("video/x-raw-yuv");
426   _QALPHAMASK = g_quark_from_string ("alpha_mask");
427 }
428
429 void
430 gst_csp_dispose (GObject * object)
431 {
432   GstCsp *csp;
433
434   g_return_if_fail (GST_IS_CSP (object));
435   csp = GST_CSP (object);
436
437   /* clean up as possible.  may be called multiple times */
438
439   G_OBJECT_CLASS (parent_class)->dispose (object);
440 }
441
442 static void
443 gst_csp_finalize (GObject * obj)
444 {
445   GstCsp *space = GST_CSP (obj);
446
447   if (space->convert) {
448     colorspace_convert_free (space->convert);
449   }
450
451   G_OBJECT_CLASS (parent_class)->finalize (obj);
452
453 }
454
455 static void
456 gst_csp_class_init (GstCspClass * klass)
457 {
458   GObjectClass *gobject_class = (GObjectClass *) klass;
459   GstBaseTransformClass *gstbasetransform_class =
460       (GstBaseTransformClass *) klass;
461
462   gobject_class->set_property = gst_csp_set_property;
463   gobject_class->get_property = gst_csp_get_property;
464   gobject_class->dispose = gst_csp_dispose;
465   gobject_class->finalize = gst_csp_finalize;
466
467   gstbasetransform_class->transform_caps =
468       GST_DEBUG_FUNCPTR (gst_csp_transform_caps);
469   gstbasetransform_class->set_caps = GST_DEBUG_FUNCPTR (gst_csp_set_caps);
470   gstbasetransform_class->get_unit_size =
471       GST_DEBUG_FUNCPTR (gst_csp_get_unit_size);
472   gstbasetransform_class->transform = GST_DEBUG_FUNCPTR (gst_csp_transform);
473
474   gstbasetransform_class->passthrough_on_same_caps = TRUE;
475
476   g_object_class_install_property (gobject_class, PROP_DITHER,
477       g_param_spec_enum ("dither", "Dither", "Apply dithering while converting",
478           dither_method_get_type (), DITHER_NONE,
479           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
480
481 }
482
483 static void
484 gst_csp_init (GstCsp * space, GstCspClass * klass)
485 {
486   space->from_format = GST_VIDEO_FORMAT_UNKNOWN;
487   space->to_format = GST_VIDEO_FORMAT_UNKNOWN;
488 }
489
490 void
491 gst_csp_set_property (GObject * object, guint property_id,
492     const GValue * value, GParamSpec * pspec)
493 {
494   GstCsp *csp;
495
496   g_return_if_fail (GST_IS_CSP (object));
497   csp = GST_CSP (object);
498
499   switch (property_id) {
500     case PROP_DITHER:
501       csp->dither = g_value_get_enum (value);
502       break;
503     default:
504       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
505       break;
506   }
507 }
508
509 void
510 gst_csp_get_property (GObject * object, guint property_id,
511     GValue * value, GParamSpec * pspec)
512 {
513   GstCsp *csp;
514
515   g_return_if_fail (GST_IS_CSP (object));
516   csp = GST_CSP (object);
517
518   switch (property_id) {
519     case PROP_DITHER:
520       g_value_set_enum (value, csp->dither);
521       break;
522     default:
523       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
524       break;
525   }
526 }
527
528 static gboolean
529 gst_csp_get_unit_size (GstBaseTransform * btrans, GstCaps * caps, guint * size)
530 {
531   gboolean ret = TRUE;
532   GstVideoFormat format;
533   gint width, height;
534
535   g_assert (size);
536
537   ret = gst_video_format_parse_caps (caps, &format, &width, &height);
538   if (ret) {
539     *size = gst_video_format_get_size (format, width, height);
540   }
541
542   return ret;
543 }
544
545 static GstFlowReturn
546 gst_csp_transform (GstBaseTransform * btrans, GstBuffer * inbuf,
547     GstBuffer * outbuf)
548 {
549   GstCsp *space;
550
551   space = GST_CSP (btrans);
552
553   GST_DEBUG ("from %d -> to %d", space->from_format, space->to_format);
554
555   if (G_UNLIKELY (space->from_format == GST_VIDEO_FORMAT_UNKNOWN ||
556           space->to_format == GST_VIDEO_FORMAT_UNKNOWN))
557     goto unknown_format;
558
559   if (space->dither) {
560     colorspace_convert_set_dither (space->convert, 1);
561   } else {
562     colorspace_convert_set_dither (space->convert, 0);
563   }
564
565   colorspace_convert_convert (space->convert, GST_BUFFER_DATA (outbuf),
566       GST_BUFFER_DATA (inbuf));
567
568   /* baseclass copies timestamps */
569   GST_DEBUG ("from %d -> to %d done", space->from_format, space->to_format);
570
571   return GST_FLOW_OK;
572
573   /* ERRORS */
574 unknown_format:
575   {
576     GST_ELEMENT_ERROR (space, CORE, NOT_IMPLEMENTED, (NULL),
577         ("attempting to convert colorspaces between unknown formats"));
578     return GST_FLOW_NOT_NEGOTIATED;
579   }
580 #if 0
581 not_supported:
582   {
583     GST_ELEMENT_ERROR (space, CORE, NOT_IMPLEMENTED, (NULL),
584         ("cannot convert between formats"));
585     return GST_FLOW_NOT_SUPPORTED;
586   }
587 #endif
588 }
589
590 static gboolean
591 plugin_init (GstPlugin * plugin)
592 {
593   GST_DEBUG_CATEGORY_INIT (colorspace_debug, "colorspace", 0,
594       "Colorspace Converter");
595   GST_DEBUG_CATEGORY_GET (colorspace_performance, "GST_PERFORMANCE");
596
597   return gst_element_register (plugin, "colorspace",
598       GST_RANK_NONE, GST_TYPE_CSP);
599 }
600
601 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
602     GST_VERSION_MINOR,
603     "colorspace", "Colorspace conversion", plugin_init, VERSION, "LGPL", "", "")