libcamera/vivid.git - libcamera pipeline handler for VIVID

diff options

author	Laurent Pinchart <laurent.pinchart@ideasonboard.com>	2020-03-07 19:28:24 +0200
committer	Laurent Pinchart <laurent.pinchart@ideasonboard.com>	2020-03-08 19:33:59 +0200
commit	00804512c6c091b3062beced6085b1b65badb8b8 (patch)
tree	6f280bf6c508ce154da169c11aa2017ca7b99e2d /test/threads.cpp
parent	34396936f7a46f21422ef64769fd807876716304 (diff)

include: libcamera: Improve automation of libcamera.h generation

The gen-header.sh script that generates libcamera.h takes all .h files in the include/libcamera/ directory, and manually adds the generated control_ids.h and version.h. This is fragile, as shown by the failure to add property_ids.h to the list in commit f870591a9bf5 ("libcamera: properties: Add location property"). To avoid future omissions, take all the .h.in files into account to generate libcamera.h. This also fixes the missing property_ids.h. Fixes: f870591a9bf5 ("libcamera: properties: Add location property") Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Reviewed-by: Kieran Bingham <kieran.bingham@ideasonboard.com> Reviewed-by: Niklas Söderlund <niklas.soderlund@ragnatech.se>

Diffstat (limited to 'test/threads.cpp')

0 files changed, 0 insertions, 0 deletions

/* SPDX-License-Identifier: BSD-2-Clause */ /* * Based on the code from http://jgt.akpeters.com/papers/McGuire08/ * * Efficient, High-Quality Bayer Demosaic Filtering on GPUs * * Morgan McGuire * * This paper appears in issue Volume 13, Number 4. * --------------------------------------------------------- * Copyright (c) 2008, Morgan McGuire. All rights reserved. * * * Modified by Linaro Ltd for 10/12-bit packed vs 8-bit raw Bayer format, * and for simpler demosaic algorithm. * Copyright (C) 2020, Linaro * * bayer_1x_packed.frag - Fragment shader code for raw Bayer 10-bit and 12-bit * packed formats */ #ifdef GL_ES precision mediump float; #endif /* * These constants are used to select the bytes containing the HS part of * the pixel value: * BPP - bytes per pixel, * THRESHOLD_L = fract(BPP) * 0.5 + 0.02 * THRESHOLD_H = 1.0 - fract(BPP) * 1.5 + 0.02 * Let X is the x coordinate in the texture measured in bytes (so that the * range is from 0 to (stride_-1)) aligned on the nearest pixel. * E.g. for RAW10P: * -------------+-------------------+-------------------+-- * pixel No | 0 1 2 3 | 4 5 6 7 | ... * -------------+-------------------+-------------------+-- * byte offset | 0 1 2 3 4 | 5 6 7 8 9 | ... * -------------+-------------------+-------------------+-- * X | 0.0 1.25 2.5 3.75 | 5.0 6.25 7.5 8.75 | ... * -------------+-------------------+-------------------+-- * If fract(X) < THRESHOLD_L then the previous byte contains the LS * bits of the pixel values and needs to be skipped. * If fract(X) > THRESHOLD_H then the next byte contains the LS bits * of the pixel values and needs to be skipped. */ #if defined(RAW10P) #define BPP 1.25 #define THRESHOLD_L 0.14 #define THRESHOLD_H 0.64 #elif defined(RAW12P) #define BPP 1.5 #define THRESHOLD_L 0.27 #define THRESHOLD_H 0.27 #else #error Invalid raw format #endif varying vec2 textureOut; /* the texture size in pixels */ uniform vec2 tex_size; uniform vec2 tex_step; uniform vec2 tex_bayer_first_red; uniform sampler2D tex_y; void main(void) { vec3 rgb; /* * center_bytes holds the coordinates of the MS byte of the pixel * being sampled on the [0, stride-1/height-1] range. * center_pixel holds the coordinates of the pixel being sampled * on the [0, width/height-1] range. */ vec2 center_bytes; vec2 center_pixel; /* * x- and y-positions of the adjacent pixels on the [0, 1] range. */ vec2 xcoords; vec2 ycoords; /* * The coordinates passed to the shader in textureOut may point * to a place in between the pixels if the texture format doesn't * match the image format. In particular, MIPI packed raw Bayer * formats don't have a matching texture format. * In this case align the coordinates to the left nearest pixel * by hand. */ center_pixel = floor(textureOut * tex_size); center_bytes.y = center_pixel.y; /* * Add a small number (a few mantissa's LSBs) to avoid float * representation issues. Maybe paranoic. */ center_bytes.x = BPP * center_pixel.x + 0.02; float fract_x = fract(center_bytes.x); /* * The below floor() call ensures that center_bytes.x points * at one of the bytes representing the 8 higher bits of * the pixel value, not at the byte containing the LS bits * of the group of the pixels. */ center_bytes.x = floor(center_bytes.x); center_bytes *= tex_step; xcoords = center_bytes.x + vec2(-tex_step.x, tex_step.x); ycoords = center_bytes.y + vec2(-tex_step.y, tex_step.y); /* * If xcoords[0] points at the byte containing the LS bits * of the previous group of the pixels, move xcoords[0] one * byte back. */ xcoords[0] += (fract_x < THRESHOLD_L) ? -tex_step.x : 0.0; /* * If xcoords[1] points at the byte containing the LS bits * of the current group of the pixels, move xcoords[1] one * byte forward. */ xcoords[1] += (fract_x > THRESHOLD_H) ? tex_step.x : 0.0; vec2 alternate = mod(center_pixel.xy + tex_bayer_first_red, 2.0); bool even_col = alternate.x < 1.0; bool even_row = alternate.y < 1.0; /* * We need to sample the central pixel and the ones with offset * of -1 to +1 pixel in both X and Y directions. Let's name these * pixels as below, where C is the central pixel: * * +----+----+----+----+ * | \ x| | | | * |y \ | -1 | 0 | +1 | * +----+----+----+----+ * | +1 | D2 | A1 | D3 | * +----+----+----+----+ * | 0 | B0 | C | B1 | * +----+----+----+----+ * | -1 | D0 | A0 | D1 | * +----+----+----+----+ * * In the below equations (0,-1).r means "r component of the texel * shifted by -tex_step.y from the center_bytes one" etc. * * In the even row / even column (EE) case the colour values are: * R = C = (0,0).r, * G = (A0 + A1 + B0 + B1) / 4.0 = * ( (0,-1).r + (0,1).r + (-1,0).r + (1,0).r ) / 4.0, * B = (D0 + D1 + D2 + D3) / 4.0 = * ( (-1,-1).r + (1,-1).r + (-1,1).r + (1,1).r ) / 4.0 * * For even row / odd column (EO): * R = (B0 + B1) / 2.0 = ( (-1,0).r + (1,0).r ) / 2.0, * G = C = (0,0).r, * B = (A0 + A1) / 2.0 = ( (0,-1).r + (0,1).r ) / 2.0 * * For odd row / even column (OE): * R = (A0 + A1) / 2.0 = ( (0,-1).r + (0,1).r ) / 2.0, * G = C = (0,0).r, * B = (B0 + B1) / 2.0 = ( (-1,0).r + (1,0).r ) / 2.0 * * For odd row / odd column (OO): * R = (D0 + D1 + D2 + D3) / 4.0 = * ( (-1,-1).r + (1,-1).r + (-1,1).r + (1,1).r ) / 4.0, * G = (A0 + A1 + B0 + B1) / 4.0 = * ( (0,-1).r + (0,1).r + (-1,0).r + (1,0).r ) / 4.0, * B = C = (0,0).r */ /* * Fetch the values and precalculate the terms: * patterns.x = (A0 + A1) / 2.0 * patterns.y = (B0 + B1) / 2.0 * patterns.z = (A0 + A1 + B0 + B1) / 4.0 * patterns.w = (D0 + D1 + D2 + D3) / 4.0 */ #define fetch(x, y) texture2D(tex_y, vec2(x, y)).r float C = texture2D(tex_y, center_bytes).r; vec4 patterns = vec4( fetch(center_bytes.x, ycoords[0]), /* A0: (0,-1) */ fetch(xcoords[0], center_bytes.y), /* B0: (-1,0) */ fetch(xcoords[0], ycoords[0]), /* D0: (-1,-1) */ fetch(xcoords[1], ycoords[0])); /* D1: (1,-1) */ vec4 temp = vec4( fetch(center_bytes.x, ycoords[1]), /* A1: (0,1) */ fetch(xcoords[1], center_bytes.y), /* B1: (1,0) */


context:
space:
mode: