mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-07-03 21:25:54 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/subprojects/gst-plugins-bad/gst/bayer/gstbayer2rgb.c
Marek Vasut 9d1a750117 bayer2rgb: Add comments explaining gst_bayer2rgb_process() 
Add comments regarding which LINE()s point to which data in the
temporary buffer and a large comment explaining how the buffer
is processed. This will hopefully be useful to someone, as the
code is not obvious. No functional change.

Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/4686>
2023-06-15 08:26:12 +00:00

621 lines
22 KiB
C
Raw Blame History

/*
* GStreamer
* Copyright (C) 2007 David Schleef <ds@schleef.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*
* March 2008
* Logic enhanced by William Brack <wbrack@mmm.com.hk>
*/
/**
* SECTION:element-bayer2rgb
* @title: bayer2rgb
*
* Decodes raw camera bayer (fourcc BA81) to RGB.
*/
/*
* In order to guard against my advancing maturity, some extra detailed
* information about the logic of the decode is included here. Much of
* this was inspired by a technical paper from siliconimaging.com, which
* in turn was based upon an article from IEEE,
* T. Sakamoto, C. Nakanishi and T. Hase,
* “Software pixel interpolation for digital still cameras suitable for
* a 32-bit MCU,”
* IEEE Trans. Consumer Electronics, vol. 44, no. 4, November 1998.
*
* The code assumes a Bayer matrix of the type produced by the fourcc
* BA81 (v4l2 format SBGGR8) of width w and height h which looks like:
* 0 1 2 3 w-2 w-1
*
* 0 B G B G ....B G
* 1 G R G R ....G R
* 2 B G B G ....B G
* ...............
* h-2 B G B G ....B G
* h-1 G R G R ....G R
*
* We expand this matrix, producing a separate {r, g, b} triple for each
* of the individual elements. The algorithm for doing this expansion is
* as follows.
*
* We are designing for speed of transformation, at a slight expense of code.
* First, we calculate the appropriate triples for the four corners, the
* remainder of the top and bottom rows, and the left and right columns.
* The reason for this is that those elements are transformed slightly
* differently than all of the remainder of the matrix. Finally, we transform
* all of the remainder.
*
* The transformation into the "appropriate triples" is based upon the
* "nearest neighbor" principal, with some additional complexity for the
* calculation of the "green" element, where an "adaptive" pairing is used.
*
* For purposes of documentation and identification, each element of the
* original array can be put into one of four classes:
* R A red element
* B A blue element
* GR A green element which is followed by a red one
* GB A green element which is followed by a blue one
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <gst/gst.h>
#include <gst/base/gstbasetransform.h>
#include <gst/video/video.h>
#include <string.h>
#include <stdlib.h>
#ifdef HAVE_STDINT_H
#include <stdint.h>
#endif
#include "gstbayerelements.h"
#include "gstbayerorc.h"
#define GST_CAT_DEFAULT gst_bayer2rgb_debug
GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
enum
{
GST_BAYER_2_RGB_FORMAT_BGGR = 0,
GST_BAYER_2_RGB_FORMAT_GBRG,
GST_BAYER_2_RGB_FORMAT_GRBG,
GST_BAYER_2_RGB_FORMAT_RGGB
};
#define GST_TYPE_BAYER2RGB (gst_bayer2rgb_get_type())
#define GST_BAYER2RGB(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_BAYER2RGB,GstBayer2RGB))
#define GST_IS_BAYER2RGB(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_BAYER2RGB))
#define GST_BAYER2RGB_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass) ,GST_TYPE_BAYER2RGB,GstBayer2RGBClass))
#define GST_IS_BAYER2RGB_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass) ,GST_TYPE_BAYER2RGB))
#define GST_BAYER2RGB_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj) ,GST_TYPE_BAYER2RGB,GstBayer2RGBClass))
typedef struct _GstBayer2RGB GstBayer2RGB;
typedef struct _GstBayer2RGBClass GstBayer2RGBClass;
typedef void (*GstBayer2RGBProcessFunc) (GstBayer2RGB *, guint8 *, guint);
struct _GstBayer2RGB
{
GstBaseTransform basetransform;
/* < private > */
GstVideoInfo info;
int width;
int height;
int r_off; /* offset for red */
int g_off; /* offset for green */
int b_off; /* offset for blue */
int format;
};
struct _GstBayer2RGBClass
{
GstBaseTransformClass parent;
};
#define SRC_CAPS \
GST_VIDEO_CAPS_MAKE ("{ RGBx, xRGB, BGRx, xBGR, RGBA, ARGB, BGRA, ABGR }")
#define SINK_CAPS "video/x-bayer,format=(string){bggr,grbg,gbrg,rggb}," \
"width=(int)[1,MAX],height=(int)[1,MAX],framerate=(fraction)[0/1,MAX]"
enum
{
PROP_0
};
GType gst_bayer2rgb_get_type (void);
#define gst_bayer2rgb_parent_class parent_class
G_DEFINE_TYPE (GstBayer2RGB, gst_bayer2rgb, GST_TYPE_BASE_TRANSFORM);
GST_ELEMENT_REGISTER_DEFINE (bayer2rgb, "bayer2rgb", GST_RANK_NONE,
gst_bayer2rgb_get_type ());
static void gst_bayer2rgb_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
static void gst_bayer2rgb_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static gboolean gst_bayer2rgb_set_caps (GstBaseTransform * filter,
GstCaps * incaps, GstCaps * outcaps);
static GstFlowReturn gst_bayer2rgb_transform (GstBaseTransform * base,
GstBuffer * inbuf, GstBuffer * outbuf);
static void gst_bayer2rgb_reset (GstBayer2RGB * filter);
static GstCaps *gst_bayer2rgb_transform_caps (GstBaseTransform * base,
GstPadDirection direction, GstCaps * caps, GstCaps * filter);
static gboolean gst_bayer2rgb_get_unit_size (GstBaseTransform * base,
GstCaps * caps, gsize * size);
static void
gst_bayer2rgb_class_init (GstBayer2RGBClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *gstelement_class;
gobject_class = (GObjectClass *) klass;
gstelement_class = (GstElementClass *) klass;
gobject_class->set_property = gst_bayer2rgb_set_property;
gobject_class->get_property = gst_bayer2rgb_get_property;
gst_element_class_set_static_metadata (gstelement_class,
"Bayer to RGB decoder for cameras", "Filter/Converter/Video",
"Converts video/x-bayer to video/x-raw",
"William Brack <wbrack@mmm.com.hk>");
gst_element_class_add_pad_template (gstelement_class,
gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
gst_caps_from_string (SRC_CAPS)));
gst_element_class_add_pad_template (gstelement_class,
gst_pad_template_new ("sink", GST_PAD_SINK, GST_PAD_ALWAYS,
gst_caps_from_string (SINK_CAPS)));
GST_BASE_TRANSFORM_CLASS (klass)->transform_caps =
GST_DEBUG_FUNCPTR (gst_bayer2rgb_transform_caps);
GST_BASE_TRANSFORM_CLASS (klass)->get_unit_size =
GST_DEBUG_FUNCPTR (gst_bayer2rgb_get_unit_size);
GST_BASE_TRANSFORM_CLASS (klass)->set_caps =
GST_DEBUG_FUNCPTR (gst_bayer2rgb_set_caps);
GST_BASE_TRANSFORM_CLASS (klass)->transform =
GST_DEBUG_FUNCPTR (gst_bayer2rgb_transform);
GST_DEBUG_CATEGORY_INIT (gst_bayer2rgb_debug, "bayer2rgb", 0,
"bayer2rgb element");
}
static void
gst_bayer2rgb_init (GstBayer2RGB * filter)
{
gst_bayer2rgb_reset (filter);
gst_base_transform_set_in_place (GST_BASE_TRANSFORM (filter), FALSE);
}
/* No properties are implemented, so only a warning is produced */
static void
gst_bayer2rgb_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
switch (prop_id) {
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_bayer2rgb_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
switch (prop_id) {
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gboolean
gst_bayer2rgb_set_caps (GstBaseTransform * base, GstCaps * incaps,
GstCaps * outcaps)
{
GstBayer2RGB *bayer2rgb = GST_BAYER2RGB (base);
GstStructure *structure;
const char *format;
GstVideoInfo info;
GST_DEBUG ("in caps %" GST_PTR_FORMAT " out caps %" GST_PTR_FORMAT, incaps,
outcaps);
structure = gst_caps_get_structure (incaps, 0);
gst_structure_get_int (structure, "width", &bayer2rgb->width);
gst_structure_get_int (structure, "height", &bayer2rgb->height);
format = gst_structure_get_string (structure, "format");
if (g_str_equal (format, "bggr")) {
bayer2rgb->format = GST_BAYER_2_RGB_FORMAT_BGGR;
} else if (g_str_equal (format, "gbrg")) {
bayer2rgb->format = GST_BAYER_2_RGB_FORMAT_GBRG;
} else if (g_str_equal (format, "grbg")) {
bayer2rgb->format = GST_BAYER_2_RGB_FORMAT_GRBG;
} else if (g_str_equal (format, "rggb")) {
bayer2rgb->format = GST_BAYER_2_RGB_FORMAT_RGGB;
} else {
return FALSE;
}
/* To cater for different RGB formats, we need to set params for later */
gst_video_info_from_caps (&info, outcaps);
bayer2rgb->r_off = GST_VIDEO_INFO_COMP_OFFSET (&info, 0);
bayer2rgb->g_off = GST_VIDEO_INFO_COMP_OFFSET (&info, 1);
bayer2rgb->b_off = GST_VIDEO_INFO_COMP_OFFSET (&info, 2);
bayer2rgb->info = info;
return TRUE;
}
static void
gst_bayer2rgb_reset (GstBayer2RGB * filter)
{
filter->width = 0;
filter->height = 0;
filter->r_off = 0;
filter->g_off = 0;
filter->b_off = 0;
gst_video_info_init (&filter->info);
}
static GstCaps *
gst_bayer2rgb_transform_caps (GstBaseTransform * base,
GstPadDirection direction, GstCaps * caps, GstCaps * filter)
{
GstBayer2RGB *bayer2rgb;
GstCaps *res_caps, *tmp_caps;
GstStructure *structure;
guint i, caps_size;
bayer2rgb = GST_BAYER2RGB (base);
res_caps = gst_caps_copy (caps);
caps_size = gst_caps_get_size (res_caps);
for (i = 0; i < caps_size; i++) {
structure = gst_caps_get_structure (res_caps, i);
if (direction == GST_PAD_SINK) {
gst_structure_set_name (structure, "video/x-raw");
gst_structure_remove_field (structure, "format");
} else {
gst_structure_set_name (structure, "video/x-bayer");
gst_structure_remove_fields (structure, "format", "colorimetry",
"chroma-site", NULL);
}
}
if (filter) {
tmp_caps = res_caps;
res_caps =
gst_caps_intersect_full (filter, tmp_caps, GST_CAPS_INTERSECT_FIRST);
gst_caps_unref (tmp_caps);
}
GST_DEBUG_OBJECT (bayer2rgb, "transformed %" GST_PTR_FORMAT " into %"
GST_PTR_FORMAT, caps, res_caps);
return res_caps;
}
static gboolean
gst_bayer2rgb_get_unit_size (GstBaseTransform * base, GstCaps * caps,
gsize * size)
{
GstStructure *structure;
int width;
int height;
const char *name;
structure = gst_caps_get_structure (caps, 0);
if (gst_structure_get_int (structure, "width", &width) &&
gst_structure_get_int (structure, "height", &height)) {
name = gst_structure_get_name (structure);
/* Our name must be either video/x-bayer video/x-raw */
if (strcmp (name, "video/x-raw")) {
*size = GST_ROUND_UP_4 (width) * height;
return TRUE;
} else {
/* For output, calculate according to format (always 32 bits) */
*size = width * height * 4;
return TRUE;
}
}
GST_ELEMENT_ERROR (base, CORE, NEGOTIATION, (NULL),
("Incomplete caps, some required field missing"));
return FALSE;
}
static void
gst_bayer2rgb_split_and_upsample_horiz (guint8 * dest0, guint8 * dest1,
const guint8 * src, GstBayer2RGB * bayer2rgb)
{
int n = bayer2rgb->width;
int i;
/*
* Pre-process line of source data in 'src' into two neighboring
* lines of temporary data 'dest0' and 'dest1' as follows. Note
* that first two pixels of both 'dest0' and 'dest1' are special,
* and so are the last two pixels of both 'dest0' and 'dest1' .
*
* The gist of this transformation is this:
* - Assume the source data contain this BG bayer pattern on input
* data line 0 (this is the same as src[0, 1, 2, 3, 4, 5 ...]):
* src 0 : B0 G0 B1 G1 B2 G2
* - This gets transformed into two lines:
* line 0: B0 avg(B0, B1) B1 avg(B1, B2) B2 avg(B2, B3)...
* line 1: G0 G0 avg(G0, G1) G1 avg(G1, G2) G2...
* - Notice ^^ ^^ ^^^^^^^^^^^ ^^ ^^^^^^^^^^^
* These are interpolated BG pairs, one for each input bayer pixel.
*
* The immediatelly following call to this function operates on the next
* input data line 1 as follows:
* - Assume the source data contain this GR bayer pattern on line 1:
* src 0 : G0 R0 G1 R1 G2 R2
* - This gets transformed into two lines:
* line 2: G0 avg(G0, G1) G1 avg(G1, G2) G2 avg(G2, G3)...
* line 3: R0 R0 avg(R0, R1) R1 avg(R1, R2) R2...
* - Notice ^^ ^^ ^^^^^^^^^^^ ^^ ^^^^^^^^^^^
* These are interpolated GR pairs, one for each input bayer pixel.
*
* First two pixels are special, two more pixels as an example of the rest:
* || 0 | 1 || 2 | 3 ::
* ------||--------+----------------++----------------+----------------+:
* DEST0 || src[0] | avg(src[0, 2]) || src[2] | avg(src[2, 4]) ::
* ------||--------+----------------++----------------+----------------+:
* DEST1 || src[1] | src[1] || avg(src[1, 3]) | src[3] ::
* ------||--------+----------------++----------------+----------------+:
*
* Inner block of pixels:
* : | n | n+1 :
* :-------+--------------------+------------------:
* : DEST0 | src[n] | avg(src[n, n+2]) :
* :-------+--------------------+------------------:
* : DEST1 | avg(src[n-1, n+1]) | src[n+1] :
* :-------+--------------------+------------------:
*
* Last two pixels:
* w is EVEN w is ODD
* : | w-2 | w-1 || : | w-2 | w-1 ||
* :-------+----------+----------|| :-------+----------+----------||
* : DEST0 | src[w-2] | src[w-2] || : DEST0 | src[w-3] | src[w-1] ||
* :-------+----------+----------|| :-------+----------+----------||
* : DEST1 | src[w-3] | src[w-1] || : DEST1 | src[w-2] | src[w-2] ||
* :-------+----------+----------|| :-------+----------+----------||
*/
dest0[0] = src[0];
dest1[0] = src[1];
dest0[1] = (src[0] + src[2] + 1) >> 1;
dest1[1] = src[1];
#if defined(__i386__) || defined(__amd64__)
bayer_orc_horiz_upsample_unaligned (dest0 + 2, dest1 + 2, src + 1,
(n - 4) >> 1);
#else
bayer_orc_horiz_upsample (dest0 + 2, dest1 + 2, src + 2, (n - 4) >> 1);
#endif
for (i = n - 2; i < n; i++) {
if ((i & 1) == 0) {
dest0[i] = src[i];
dest1[i] = src[i - 1];
} else {
dest0[i] = src[i - 1];
dest1[i] = src[i];
}
}
}
typedef void (*process_func) (guint8 * d0, const guint8 * s0, const guint8 * s1,
const guint8 * s2, const guint8 * s3, const guint8 * s4, const guint8 * s5,
int n);
static void
gst_bayer2rgb_process (GstBayer2RGB * bayer2rgb, uint8_t * dest,
int dest_stride, uint8_t * src)
{
const int src_stride = GST_ROUND_UP_4 (bayer2rgb->width);
int j;
guint8 *tmp;
process_func merge[2] = { NULL, NULL };
int r_off, g_off, b_off;
/* We exploit some symmetry in the functions here. The base functions
* are all named for the BGGR arrangement. For RGGB, we swap the
* red offset and blue offset in the output. For GRBG, we swap the
* order of the merge functions. For GBRG, do both. */
r_off = bayer2rgb->r_off;
g_off = bayer2rgb->g_off;
b_off = bayer2rgb->b_off;
if (bayer2rgb->format == GST_BAYER_2_RGB_FORMAT_RGGB ||
bayer2rgb->format == GST_BAYER_2_RGB_FORMAT_GBRG) {
r_off = bayer2rgb->b_off;
b_off = bayer2rgb->r_off;
}
if (r_off == 2 && g_off == 1 && b_off == 0) {
merge[0] = bayer_orc_merge_bg_bgra;
merge[1] = bayer_orc_merge_gr_bgra;
} else if (r_off == 3 && g_off == 2 && b_off == 1) {
merge[0] = bayer_orc_merge_bg_abgr;
merge[1] = bayer_orc_merge_gr_abgr;
} else if (r_off == 1 && g_off == 2 && b_off == 3) {
merge[0] = bayer_orc_merge_bg_argb;
merge[1] = bayer_orc_merge_gr_argb;
} else if (r_off == 0 && g_off == 1 && b_off == 2) {
merge[0] = bayer_orc_merge_bg_rgba;
merge[1] = bayer_orc_merge_gr_rgba;
}
if (bayer2rgb->format == GST_BAYER_2_RGB_FORMAT_GRBG ||
bayer2rgb->format == GST_BAYER_2_RGB_FORMAT_GBRG) {
process_func tmp = merge[0];
merge[0] = merge[1];
merge[1] = tmp;
}
tmp = g_malloc (2 * 4 * bayer2rgb->width);
#define LINE(t, x, b) ((t) + (((x) & 7) * ((b)->width)))
/* Pre-process source line 1 into bottom two lines 6 and 7 as PREVIOUS line */
gst_bayer2rgb_split_and_upsample_horiz ( /* src line 1 */
LINE (tmp, 3 * 2 + 0, bayer2rgb), /* tmp buffer line 6 */
LINE (tmp, 3 * 2 + 1, bayer2rgb), /* tmp buffer line 7 */
src + 1 * src_stride, bayer2rgb);
/* Pre-process source line 0 into top two lines 0 and 1 as CURRENT line */
gst_bayer2rgb_split_and_upsample_horiz ( /* src line 0 */
LINE (tmp, 0 * 2 + 0, bayer2rgb), /* tmp buffer line 0 */
LINE (tmp, 0 * 2 + 1, bayer2rgb), /* tmp buffer line 1 */
src + 0 * src_stride, bayer2rgb);
for (j = 0; j < bayer2rgb->height; j++) {
if (j < bayer2rgb->height - 1) {
/*
* Pre-process NEXT source line (j + 1) into two consecutive lines
* (2 * (j + 1) + 0) % 8
* and
* (2 * (j + 1) + 1) % 8
*
* This cycle here starts with j=0, and therefore
* - reads source line 1
* - writes tmp buffer lines 2,3
* The cycle continues with source line 2 and tmp buffer lines 4,5 etc.
*/
gst_bayer2rgb_split_and_upsample_horiz ( /* src line (j + 1) */
LINE (tmp, (j + 1) * 2 + 0, bayer2rgb), /* tmp buffer line 2/4/6/0 */
LINE (tmp, (j + 1) * 2 + 1, bayer2rgb), /* tmp buffer line 3/5/7/1 */
src + (j + 1) * src_stride, bayer2rgb);
}
/*
* Use the pre-processed tmp buffer lines and construct resulting frame.
* Assume j=0, the tmp buffer content looks as follows:
* line 0: B0 avg(B0, B1) B1 avg(B1, B2) B2 avg(B2, B3)...
* line 1: G0 G0 avg(G0, G1) G1 avg(G1, G2) G2...
* line 2: G0 avg(G0, G1) G1 avg(G1, G2) G2 avg(G2, G3)...
* line 3: R0 R0 avg(R0, R1) R1 avg(R1, R2) R2...
* line 4: empty
* line 5: empty
* line 6: G0 avg(G0, G1) G1 avg(G1, G2) G2 avg(G2, G3)...
* line 7: R0 R0 avg(R0, R1) R1 avg(R1, R2) R2...
* Line 0,1 and 6,7 were populated in pre-process step outside of this loop.
* Line 2,3 was populated just above this comment.
* The code is currently processing source line 0 (not tmp buffer line 0)
* and uses the following tmp buffer lines in the process as inputs to the
* merge function:
* - tmp buffer line -2 => tmp buffer line 6 => orc g0 values
* - tmp buffer line -1 => tmp buffer line 7 => orc r0 values
* - tmp buffer line +0 => tmp buffer line 0 => orc b1 values
* - tmp buffer line +1 => tmp buffer line 1 => orc g1 values
* - tmp buffer line +2 => tmp buffer line 2 => orc g2 values
* - tmp buffer line +3 => tmp buffer line 3 => orc r2 values
* With j=0, the merge function used is one of bayer_orc_merge_bg_*
*
* A good material regarding the ORC functions below is
* https://www.siliconimaging.com/RGB%20Bayer.htm
* chapter
* "Interpolating the green component"
*
* The bayer_orc_merge_bg_* performs BG interpolation.
* # average R from PREVIOUS line and NEXT line
* r = [ avg(r0[0], r2[0]) , avg(r0[1], r2[1]) ]
* # average G from PREVIOUS line and NEXT line
* g = [ avg(g0[0], g2[0]) , avg(g0[1], g2[1]) ]
* # copy CURRENT line G into variable t
* t = [ g1[0] , g1[1] ]
* # average G from PREVIOUS, CURRENT, NEXT line
* g = [ avg(g[0], g1[0]) , avg(g[1], g1[1]) ]
* # reorder the content of g and t variables using bit operations
* # (the "g first, t second" order is here because the B pixel we
* # are now processing does not have its own G value, it only has
* # G value extrapolated from surrouding G pixels. The following
* # G pixel has its own G value, so we use it as-is, without any
* # extrapolation)
* g = [ g, 0 ]
* t = [ 0, t ]
* g = [ g, t ]
* # generate resulting (e.g. BGRx) data
* bg = [ b1[0] , g , b1[1] , t ]
* ra = [ r[0] , 255 , r[1] , 255 ]
* d = [ b1[0] , g , r[0] , 255 , b1[1] , t , r[1] , 255 ]
*
* In the next cycle, j=1, line 4,5 would be populated with BG values
* calculated from source line 2, merge function would use tmp buffer
* inputs from lines 0,1,2,3,4,5 i.e. b0,g0,g1,r1,b2,g2 and the merge
* function would be bayer_orc_merge_gr_* .
*/
merge[j & 1] (dest + j * dest_stride, /* output line j */
LINE (tmp, j * 2 - 2, bayer2rgb), /* PREVIOUS: even: BG g0 , odd: GR b0 */
LINE (tmp, j * 2 - 1, bayer2rgb), /* PREVIOUS: even: BG r0 , odd: GR g0 */
LINE (tmp, j * 2 + 0, bayer2rgb), /* CURRENT: even: BG b1 , odd: GR g1 */
LINE (tmp, j * 2 + 1, bayer2rgb), /* CURRENT: even: BG g1 , odd: GR r1 */
LINE (tmp, j * 2 + 2, bayer2rgb), /* NEXT: even: BG g2 , odd: GR b2 */
LINE (tmp, j * 2 + 3, bayer2rgb), /* NEXT: even: BG r2 , odd: GR g2 */
bayer2rgb->width >> 1);
}
g_free (tmp);
}
static GstFlowReturn
gst_bayer2rgb_transform (GstBaseTransform * base, GstBuffer * inbuf,
GstBuffer * outbuf)
{
GstBayer2RGB *filter = GST_BAYER2RGB (base);
GstMapInfo map;
uint8_t *output;
GstVideoFrame frame;
GST_DEBUG ("transforming buffer");
if (!gst_buffer_map (inbuf, &map, GST_MAP_READ))
goto map_failed;
if (!gst_video_frame_map (&frame, &filter->info, outbuf, GST_MAP_WRITE)) {
gst_buffer_unmap (inbuf, &map);
goto map_failed;
}
output = GST_VIDEO_FRAME_PLANE_DATA (&frame, 0);
gst_bayer2rgb_process (filter, output, frame.info.stride[0], map.data);
gst_video_frame_unmap (&frame);
gst_buffer_unmap (inbuf, &map);
return GST_FLOW_OK;
map_failed:
GST_WARNING_OBJECT (base, "Could not map buffer, skipping");
return GST_FLOW_OK;
}
Reference in a new issue View git blame Copy permalink