gst/bayer/gstbayer2rgb.c

   1 /*
   2  * GStreamer
   3  * Copyright (C) 2007 David Schleef <ds@schleef.org>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  18  * Boston, MA 02110-1301, USA.
  19  *
  20  * March 2008
  21  * Logic enhanced by William Brack <wbrack@mmm.com.hk>
  22  */
  23
  24 /**
  25  * SECTION:element-bayer2rgb
  26  * @title: bayer2rgb
  27  *
  28  * Decodes raw camera bayer (fourcc BA81) to RGB.
  29  */
  30
  31 /*
  32  * In order to guard against my advancing maturity, some extra detailed
  33  * information about the logic of the decode is included here.  Much of
  34  * this was inspired by a technical paper from siliconimaging.com, which
  35  * in turn was based upon an article from IEEE,
  36  * T. Sakamoto, C. Nakanishi and T. Hase,
  37  * “Software pixel interpolation for digital still cameras suitable for
  38  *  a 32-bit MCU,”
  39  * IEEE Trans. Consumer Electronics, vol. 44, no. 4, November 1998.
  40  *
  41  * The code assumes a Bayer matrix of the type produced by the fourcc
  42  * BA81 (v4l2 format SBGGR8) of width w and height h which looks like:
  43  *       0 1 2 3  w-2 w-1
  44  *
  45  *   0   B G B G ....B G
  46  *   1   G R G R ....G R
  47  *   2   B G B G ....B G
  48  *       ...............
  49  * h-2   B G B G ....B G
  50  * h-1   G R G R ....G R
  51  *
  52  * We expand this matrix, producing a separate {r, g, b} triple for each
  53  * of the individual elements.  The algorithm for doing this expansion is
  54  * as follows.
  55  *
  56  * We are designing for speed of transformation, at a slight expense of code.
  57  * First, we calculate the appropriate triples for the four corners, the
  58  * remainder of the top and bottom rows, and the left and right columns.
  59  * The reason for this is that those elements are transformed slightly
  60  * differently than all of the remainder of the matrix. Finally, we transform
  61  * all of the remainder.
  62  *
  63  * The transformation into the "appropriate triples" is based upon the
  64  * "nearest neighbor" principal, with some additional complexity for the
  65  * calculation of the "green" element, where an "adaptive" pairing is used.
  66  *
  67  * For purposes of documentation and indentification, each element of the
  68  * original array can be put into one of four classes:
  69  *   R   A red element
  70  *   B   A blue element
  71  *   GR  A green element which is followed by a red one
  72  *   GB  A green element which is followed by a blue one
  73  */
  74
  75 #ifdef HAVE_CONFIG_H
  76 #include "config.h"
  77 #endif
  78
  79 #include <gst/gst.h>
  80 #include <gst/base/gstbasetransform.h>
  81 #include <gst/video/video.h>
  82 #include <string.h>
  83 #include <stdlib.h>
  84
  85 #ifdef HAVE_STDINT_H
  86 #include <stdint.h>
  87 #endif
  88
  89 #include "gstbayerorc.h"
  90
  91 #define GST_CAT_DEFAULT gst_bayer2rgb_debug
  92 GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
  93
  94 enum
  95 {
  96   GST_BAYER_2_RGB_FORMAT_BGGR = 0,
  97   GST_BAYER_2_RGB_FORMAT_GBRG,
  98   GST_BAYER_2_RGB_FORMAT_GRBG,
  99   GST_BAYER_2_RGB_FORMAT_RGGB
 100 };
 101
 102
 103 #define GST_TYPE_BAYER2RGB            (gst_bayer2rgb_get_type())
 104 #define GST_BAYER2RGB(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_BAYER2RGB,GstBayer2RGB))
 105 #define GST_IS_BAYER2RGB(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_BAYER2RGB))
 106 #define GST_BAYER2RGB_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass) ,GST_TYPE_BAYER2RGB,GstBayer2RGBClass))
 107 #define GST_IS_BAYER2RGB_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass) ,GST_TYPE_BAYER2RGB))
 108 #define GST_BAYER2RGB_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj) ,GST_TYPE_BAYER2RGB,GstBayer2RGBClass))
 109 typedef struct _GstBayer2RGB GstBayer2RGB;
 110 typedef struct _GstBayer2RGBClass GstBayer2RGBClass;
 111
 112 typedef void (*GstBayer2RGBProcessFunc) (GstBayer2RGB *, guint8 *, guint);
 113
 114 struct _GstBayer2RGB
 115 {
 116   GstBaseTransform basetransform;
 117
 118   /* < private > */
 119   GstVideoInfo info;
 120   int width;
 121   int height;
 122   int r_off;                    /* offset for red */
 123   int g_off;                    /* offset for green */
 124   int b_off;                    /* offset for blue */
 125   int format;
 126 };
 127
 128 struct _GstBayer2RGBClass
 129 {
 130   GstBaseTransformClass parent;
 131 };
 132
 133 #define SRC_CAPS                                 \
 134   GST_VIDEO_CAPS_MAKE ("{ RGBx, xRGB, BGRx, xBGR, RGBA, ARGB, BGRA, ABGR }")
 135
 136 #define SINK_CAPS "video/x-bayer,format=(string){bggr,grbg,gbrg,rggb}," \
 137   "width=(int)[1,MAX],height=(int)[1,MAX],framerate=(fraction)[0/1,MAX]"
 138
 139 enum
 140 {
 141   PROP_0
 142 };
 143
 144 GType gst_bayer2rgb_get_type (void);
 145
 146 #define gst_bayer2rgb_parent_class parent_class
 147 G_DEFINE_TYPE (GstBayer2RGB, gst_bayer2rgb, GST_TYPE_BASE_TRANSFORM);
 148
 149 static void gst_bayer2rgb_set_property (GObject * object, guint prop_id,
 150     const GValue * value, GParamSpec * pspec);
 151 static void gst_bayer2rgb_get_property (GObject * object, guint prop_id,
 152     GValue * value, GParamSpec * pspec);
 153
 154 static gboolean gst_bayer2rgb_set_caps (GstBaseTransform * filter,
 155     GstCaps * incaps, GstCaps * outcaps);
 156 static GstFlowReturn gst_bayer2rgb_transform (GstBaseTransform * base,
 157     GstBuffer * inbuf, GstBuffer * outbuf);
 158 static void gst_bayer2rgb_reset (GstBayer2RGB * filter);
 159 static GstCaps *gst_bayer2rgb_transform_caps (GstBaseTransform * base,
 160     GstPadDirection direction, GstCaps * caps, GstCaps * filter);
 161 static gboolean gst_bayer2rgb_get_unit_size (GstBaseTransform * base,
 162     GstCaps * caps, gsize * size);
 163
 164
 165 static void
 166 gst_bayer2rgb_class_init (GstBayer2RGBClass * klass)
 167 {
 168   GObjectClass *gobject_class;
 169   GstElementClass *gstelement_class;
 170
 171   gobject_class = (GObjectClass *) klass;
 172   gstelement_class = (GstElementClass *) klass;
 173
 174   gobject_class->set_property = gst_bayer2rgb_set_property;
 175   gobject_class->get_property = gst_bayer2rgb_get_property;
 176
 177   gst_element_class_set_static_metadata (gstelement_class,
 178       "Bayer to RGB decoder for cameras", "Filter/Converter/Video",
 179       "Converts video/x-bayer to video/x-raw",
 180       "William Brack <wbrack@mmm.com.hk>");
 181
 182   gst_element_class_add_pad_template (gstelement_class,
 183       gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
 184           gst_caps_from_string (SRC_CAPS)));
 185   gst_element_class_add_pad_template (gstelement_class,
 186       gst_pad_template_new ("sink", GST_PAD_SINK, GST_PAD_ALWAYS,
 187           gst_caps_from_string (SINK_CAPS)));
 188
 189   GST_BASE_TRANSFORM_CLASS (klass)->transform_caps =
 190       GST_DEBUG_FUNCPTR (gst_bayer2rgb_transform_caps);
 191   GST_BASE_TRANSFORM_CLASS (klass)->get_unit_size =
 192       GST_DEBUG_FUNCPTR (gst_bayer2rgb_get_unit_size);
 193   GST_BASE_TRANSFORM_CLASS (klass)->set_caps =
 194       GST_DEBUG_FUNCPTR (gst_bayer2rgb_set_caps);
 195   GST_BASE_TRANSFORM_CLASS (klass)->transform =
 196       GST_DEBUG_FUNCPTR (gst_bayer2rgb_transform);
 197
 198   GST_DEBUG_CATEGORY_INIT (gst_bayer2rgb_debug, "bayer2rgb", 0,
 199       "bayer2rgb element");
 200 }
 201
 202 static void
 203 gst_bayer2rgb_init (GstBayer2RGB * filter)
 204 {
 205   gst_bayer2rgb_reset (filter);
 206   gst_base_transform_set_in_place (GST_BASE_TRANSFORM (filter), TRUE);
 207 }
 208
 209 /* No properties are implemented, so only a warning is produced */
 210 static void
 211 gst_bayer2rgb_set_property (GObject * object, guint prop_id,
 212     const GValue * value, GParamSpec * pspec)
 213 {
 214
 215   switch (prop_id) {
 216     default:
 217       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 218       break;
 219   }
 220 }
 221
 222 static void
 223 gst_bayer2rgb_get_property (GObject * object, guint prop_id,
 224     GValue * value, GParamSpec * pspec)
 225 {
 226
 227   switch (prop_id) {
 228     default:
 229       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 230       break;
 231   }
 232 }
 233
 234 static gboolean
 235 gst_bayer2rgb_set_caps (GstBaseTransform * base, GstCaps * incaps,
 236     GstCaps * outcaps)
 237 {
 238   GstBayer2RGB *bayer2rgb = GST_BAYER2RGB (base);
 239   GstStructure *structure;
 240   const char *format;
 241   GstVideoInfo info;
 242
 243   GST_DEBUG ("in caps %" GST_PTR_FORMAT " out caps %" GST_PTR_FORMAT, incaps,
 244       outcaps);
 245
 246   structure = gst_caps_get_structure (incaps, 0);
 247
 248   gst_structure_get_int (structure, "width", &bayer2rgb->width);
 249   gst_structure_get_int (structure, "height", &bayer2rgb->height);
 250
 251   format = gst_structure_get_string (structure, "format");
 252   if (g_str_equal (format, "bggr")) {
 253     bayer2rgb->format = GST_BAYER_2_RGB_FORMAT_BGGR;
 254   } else if (g_str_equal (format, "gbrg")) {
 255     bayer2rgb->format = GST_BAYER_2_RGB_FORMAT_GBRG;
 256   } else if (g_str_equal (format, "grbg")) {
 257     bayer2rgb->format = GST_BAYER_2_RGB_FORMAT_GRBG;
 258   } else if (g_str_equal (format, "rggb")) {
 259     bayer2rgb->format = GST_BAYER_2_RGB_FORMAT_RGGB;
 260   } else {
 261     return FALSE;
 262   }
 263
 264   /* To cater for different RGB formats, we need to set params for later */
 265   gst_video_info_from_caps (&info, outcaps);
 266   bayer2rgb->r_off = GST_VIDEO_INFO_COMP_OFFSET (&info, 0);
 267   bayer2rgb->g_off = GST_VIDEO_INFO_COMP_OFFSET (&info, 1);
 268   bayer2rgb->b_off = GST_VIDEO_INFO_COMP_OFFSET (&info, 2);
 269
 270   bayer2rgb->info = info;
 271
 272   return TRUE;
 273 }
 274
 275 static void
 276 gst_bayer2rgb_reset (GstBayer2RGB * filter)
 277 {
 278   filter->width = 0;
 279   filter->height = 0;
 280   filter->r_off = 0;
 281   filter->g_off = 0;
 282   filter->b_off = 0;
 283   gst_video_info_init (&filter->info);
 284 }
 285
 286 static GstCaps *
 287 gst_bayer2rgb_transform_caps (GstBaseTransform * base,
 288     GstPadDirection direction, GstCaps * caps, GstCaps * filter)
 289 {
 290   GstBayer2RGB *bayer2rgb;
 291   GstCaps *res_caps, *tmp_caps;
 292   GstStructure *structure;
 293   guint i, caps_size;
 294
 295   bayer2rgb = GST_BAYER2RGB (base);
 296
 297   res_caps = gst_caps_copy (caps);
 298   caps_size = gst_caps_get_size (res_caps);
 299   for (i = 0; i < caps_size; i++) {
 300     structure = gst_caps_get_structure (res_caps, i);
 301     if (direction == GST_PAD_SINK) {
 302       gst_structure_set_name (structure, "video/x-raw");
 303       gst_structure_remove_field (structure, "format");
 304     } else {
 305       gst_structure_set_name (structure, "video/x-bayer");
 306       gst_structure_remove_fields (structure, "format", "colorimetry",
 307           "chroma-site", NULL);
 308     }
 309   }
 310   if (filter) {
 311     tmp_caps = res_caps;
 312     res_caps =
 313         gst_caps_intersect_full (filter, tmp_caps, GST_CAPS_INTERSECT_FIRST);
 314     gst_caps_unref (tmp_caps);
 315   }
 316   GST_DEBUG_OBJECT (bayer2rgb, "transformed %" GST_PTR_FORMAT " into %"
 317       GST_PTR_FORMAT, caps, res_caps);
 318   return res_caps;
 319 }
 320
 321 static gboolean
 322 gst_bayer2rgb_get_unit_size (GstBaseTransform * base, GstCaps * caps,
 323     gsize * size)
 324 {
 325   GstStructure *structure;
 326   int width;
 327   int height;
 328   const char *name;
 329
 330   structure = gst_caps_get_structure (caps, 0);
 331
 332   if (gst_structure_get_int (structure, "width", &width) &&
 333       gst_structure_get_int (structure, "height", &height)) {
 334     name = gst_structure_get_name (structure);
 335     /* Our name must be either video/x-bayer video/x-raw */
 336     if (strcmp (name, "video/x-raw")) {
 337       *size = GST_ROUND_UP_4 (width) * height;
 338       return TRUE;
 339     } else {
 340       /* For output, calculate according to format (always 32 bits) */
 341       *size = width * height * 4;
 342       return TRUE;
 343     }
 344
 345   }
 346   GST_ELEMENT_ERROR (base, CORE, NEGOTIATION, (NULL),
 347       ("Incomplete caps, some required field missing"));
 348   return FALSE;
 349 }
 350
 351 static void
 352 gst_bayer2rgb_split_and_upsample_horiz (guint8 * dest0, guint8 * dest1,
 353     const guint8 * src, int n)
 354 {
 355   int i;
 356
 357   dest0[0] = src[0];
 358   dest1[0] = src[1];
 359   dest0[1] = (src[0] + src[2] + 1) >> 1;
 360   dest1[1] = src[1];
 361
 362 #if defined(__i386__) || defined(__amd64__)
 363   bayer_orc_horiz_upsample_unaligned (dest0 + 2, dest1 + 2, src + 1,
 364       (n - 4) >> 1);
 365 #else
 366   bayer_orc_horiz_upsample (dest0 + 2, dest1 + 2, src + 2, (n - 4) >> 1);
 367 #endif
 368
 369   for (i = n - 2; i < n; i++) {
 370     if ((i & 1) == 0) {
 371       dest0[i] = src[i];
 372       dest1[i] = src[i - 1];
 373     } else {
 374       dest0[i] = src[i - 1];
 375       dest1[i] = src[i];
 376     }
 377   }
 378 }
 379
 380 typedef void (*process_func) (guint8 * d0, const guint8 * s0, const guint8 * s1,
 381     const guint8 * s2, const guint8 * s3, const guint8 * s4, const guint8 * s5,
 382     int n);
 383
 384 static void
 385 gst_bayer2rgb_process (GstBayer2RGB * bayer2rgb, uint8_t * dest,
 386     int dest_stride, uint8_t * src, int src_stride)
 387 {
 388   int j;
 389   guint8 *tmp;
 390   process_func merge[2] = { NULL, NULL };
 391   int r_off, g_off, b_off;
 392
 393   /* We exploit some symmetry in the functions here.  The base functions
 394    * are all named for the BGGR arrangement.  For RGGB, we swap the
 395    * red offset and blue offset in the output.  For GRBG, we swap the
 396    * order of the merge functions.  For GBRG, do both. */
 397   r_off = bayer2rgb->r_off;
 398   g_off = bayer2rgb->g_off;
 399   b_off = bayer2rgb->b_off;
 400   if (bayer2rgb->format == GST_BAYER_2_RGB_FORMAT_RGGB ||
 401       bayer2rgb->format == GST_BAYER_2_RGB_FORMAT_GBRG) {
 402     r_off = bayer2rgb->b_off;
 403     b_off = bayer2rgb->r_off;
 404   }
 405
 406   if (r_off == 2 && g_off == 1 && b_off == 0) {
 407     merge[0] = bayer_orc_merge_bg_bgra;
 408     merge[1] = bayer_orc_merge_gr_bgra;
 409   } else if (r_off == 3 && g_off == 2 && b_off == 1) {
 410     merge[0] = bayer_orc_merge_bg_abgr;
 411     merge[1] = bayer_orc_merge_gr_abgr;
 412   } else if (r_off == 1 && g_off == 2 && b_off == 3) {
 413     merge[0] = bayer_orc_merge_bg_argb;
 414     merge[1] = bayer_orc_merge_gr_argb;
 415   } else if (r_off == 0 && g_off == 1 && b_off == 2) {
 416     merge[0] = bayer_orc_merge_bg_rgba;
 417     merge[1] = bayer_orc_merge_gr_rgba;
 418   }
 419   if (bayer2rgb->format == GST_BAYER_2_RGB_FORMAT_GRBG ||
 420       bayer2rgb->format == GST_BAYER_2_RGB_FORMAT_GBRG) {
 421     process_func tmp = merge[0];
 422     merge[0] = merge[1];
 423     merge[1] = tmp;
 424   }
 425
 426   tmp = g_malloc (2 * 4 * bayer2rgb->width);
 427 #define LINE(x) (tmp + ((x)&7) * bayer2rgb->width)
 428
 429   gst_bayer2rgb_split_and_upsample_horiz (LINE (3 * 2 + 0), LINE (3 * 2 + 1),
 430       src + 1 * src_stride, bayer2rgb->width);
 431   j = 0;
 432   gst_bayer2rgb_split_and_upsample_horiz (LINE (j * 2 + 0), LINE (j * 2 + 1),
 433       src + j * src_stride, bayer2rgb->width);
 434
 435   for (j = 0; j < bayer2rgb->height; j++) {
 436     if (j < bayer2rgb->height - 1) {
 437       gst_bayer2rgb_split_and_upsample_horiz (LINE ((j + 1) * 2 + 0),
 438           LINE ((j + 1) * 2 + 1), src + (j + 1) * src_stride, bayer2rgb->width);
 439     }
 440
 441     merge[j & 1] (dest + j * dest_stride,
 442         LINE (j * 2 - 2), LINE (j * 2 - 1),
 443         LINE (j * 2 + 0), LINE (j * 2 + 1),
 444         LINE (j * 2 + 2), LINE (j * 2 + 3), bayer2rgb->width >> 1);
 445   }
 446
 447   g_free (tmp);
 448 }
 449
 450
 451
 452
 453 static GstFlowReturn
 454 gst_bayer2rgb_transform (GstBaseTransform * base, GstBuffer * inbuf,
 455     GstBuffer * outbuf)
 456 {
 457   GstBayer2RGB *filter = GST_BAYER2RGB (base);
 458   GstMapInfo map;
 459   uint8_t *output;
 460   GstVideoFrame frame;
 461
 462   GST_DEBUG ("transforming buffer");
 463
 464   if (!gst_buffer_map (inbuf, &map, GST_MAP_READ))
 465     goto map_failed;
 466
 467   if (!gst_video_frame_map (&frame, &filter->info, outbuf, GST_MAP_WRITE)) {
 468     gst_buffer_unmap (inbuf, &map);
 469     goto map_failed;
 470   }
 471
 472   output = GST_VIDEO_FRAME_PLANE_DATA (&frame, 0);
 473   gst_bayer2rgb_process (filter, output, frame.info.stride[0],
 474       map.data, GST_ROUND_UP_4 (filter->width));
 475
 476   gst_video_frame_unmap (&frame);
 477   gst_buffer_unmap (inbuf, &map);
 478
 479   return GST_FLOW_OK;
 480
 481 map_failed:
 482   GST_WARNING_OBJECT (base, "Could not map buffer, skipping");
 483   return GST_FLOW_OK;
 484 }