mirror of
git://nv-tegra.nvidia.com/tegra/v4l2-src/v4l2_libs.git
synced 2025-12-22 17:39:13 +03:00
Updating prebuilts and/or headers
22fd03618c218ae14ba59a5aab5f30b0acd2b6ea - libv4lconvert/Makefile 66dd7958319442bd52ba40ede28fbfe31bb4e074 - libv4lconvert/cpia1.c 3271d74d02e2f33c16e3e50aeb1268eb9c440782 - libv4lconvert/rgbyuv.c db3c69c666e451c5d4ef6d1b5a3117f4b128baa4 - libv4lconvert/libv4lconvert-priv.h 1f1d1e05443c4b824cd697c0ce5efa9ea1277964 - libv4lconvert/ov518-decomp.c b694b6348e035b3da880824c2c2768145c9b5199 - libv4lconvert/jpeg_memsrcdest.c 22a502c238e48f4b939c81de41feccfc7c366766 - libv4lconvert/Makefile.dGPU 60e29f95ea52df4407d771330897813cdb38340f - libv4lconvert/libv4lsyscall-priv.h cc3f3e94a21795990610e63887c30528bde7b42e - libv4lconvert/bayer.c 72953a5a3a56b0188d35f49246356b9c8c35756c - libv4lconvert/helper.c d6c1aba89bbcb6fef46a6f22b7ea01025435c44d - libv4lconvert/Makefile.am ddd39b2fe0e2a86a6c64031ccc0d36edfd9b0f1a - libv4lconvert/sn9c10x.c 07f8e7c84abfbbe76d49d8bfd1f4eae6ea39a90b - libv4lconvert/jpgl.c 84c9c3812d4b5f237c8cd616d37fc1161a212acc - libv4lconvert/se401.c fbbffd8182b4fe2e85289b6e784f70cba7ea7b1d - libv4lconvert/sq905c.c fa751ff0f78845f3b4591396710df3b165bc8d11 - libv4lconvert/mr97310a.c 6ad4947dca51a7e67e056561cdb445d6c354d23c - libv4lconvert/libv4lconvert.c 4eff5c1a5e0b99ce4d6e9aa63645d9628467fdc3 - libv4lconvert/sn9c2028-decomp.c 5430e46abb1ac7039ed0309ca338237533ff29c9 - libv4lconvert/sn9c20x.c 3c49d99b9753208a9c1c2a9c738a1e7ad291ca22 - libv4lconvert/jpeg_memsrcdest.h fb3344cfa8df97688332ee4fd3b17968437e8ad5 - libv4lconvert/helper-funcs.h 8b7644ac3d5c4161cfb6dcc2a34013f4c379c665 - libv4lconvert/libv4lconvert.export be9e3bf3d7d1086b6eed0c1bf2f574c2b1737c00 - libv4lconvert/tinyjpeg.c f08c902ecd48c2739956606b502fc0b8e4007703 - libv4lconvert/crop.c f4d73412805f12fa08dd79a43798a7f8d7acece9 - libv4lconvert/pac207.c 25130d299463897a09e8b9adf72389dac2e89fa4 - libv4lconvert/tinyjpeg-internal.h 463725aa4dd3fecaf89c0b8bbf4747f8f7577935 - libv4lconvert/jpeg.c 725c9b8d0bfadba566cf200921e602961cb12705 - libv4lconvert/spca561-decompress.c ff7444c48a8da88f8a466cfb138e30e585828cb3 - libv4lconvert/jl2005bcd.c 803c4d0b9364050eda163452b8792e62e221ab6d - libv4lconvert/tinyjpeg.h cc8982bb6f753249181c715fe6430ffefc78c23b - libv4lconvert/stv0680.c 3e8e6c1fb85e3c4b58c4e9b2b0a223ddc793edcb - libv4lconvert/libv4lconvert.pc.in 033894511bd7e8a374a52486889658faa17918c4 - libv4lconvert/flip.c f061a4e0e45ca8e0dbab630dd477e19a6c915fda - libv4lconvert/spca501.c b2c19c2eac71d39d3fb883cdc159a69c2afa8fd6 - libv4lconvert/ov511-decomp.c 1d9c446cd8a232da87bd79acebc93e018ec72499 - libv4lconvert/jidctflt.c 1949e23fe99ccd0a05dcd084848f6d38b0af7ab6 - libv4lconvert/hm12.c 7da402829dbff238ca6ac829c037a85476185db6 - libv4lconvert/processing/autogain.c a54c2cb0439e606af01d0b4f02704f411819d98c - libv4lconvert/processing/libv4lprocessing.c dae9c69b7f019d7d4494cd56e2cf757e8510824a - libv4lconvert/processing/whitebalance.c ebf12bcf99f35fb9c400b04a1439e68598268249 - libv4lconvert/processing/gamma.c 0390d660eb130f0e580832bcf8ad5069010d2696 - libv4lconvert/processing/libv4lprocessing.h 33ab91b54108e8c24cbb80c5c335d96391d440b2 - libv4lconvert/processing/libv4lprocessing-priv.h 19a7fd04cdeba61172f281806d030472dee79fcd - libv4lconvert/control/libv4lcontrol.c 1e08fb01a598d71e3fc69656c4f2291f7dc13105 - libv4lconvert/control/libv4lcontrol.h 70f4992835e964b2698473971904375333e3659b - libv4lconvert/control/libv4lcontrol-priv.h 6feb5b2b8c99c99712dd1ea7fe9ab674d58bf86b - include/libv4l1.h bc44111fd6b2f0374a9fc67b1b23666c5c498b2c - include/libv4l2rds.h f751b481c4a9203345cdbb6459d0f2882f7cdbd9 - include/libv4lconvert.h 1edc439e6c0fc98513fa4a69557eb6221d043be0 - include/libv4l2.h f2b73fa5ab10ea7038e58bd9a4461d8e16316249 - include/libv4l1-videodev.h 94434b9692371b7d5f54ddef2141d22d90079ce9 - include/libv4l-plugin.h c84a9a115a21d1fd20da0f6ca3df7b46dd23cd2a - include/config.h 1ba874a7cad36ff31e4af3bfb37b98c05063d6b2 - include/libdvbv5/desc_event_extended.h 6bd2ed0beaf6aa4838e239198564fd8e1d20a3a1 - include/libdvbv5/desc_t2_delivery.h 92d4c28148d0b537c8afc289e1a76de68435cba0 - include/libdvbv5/dvb-scan.h 22c83d133e5c1d2648efb3028e0d89c970d0aad4 - include/libdvbv5/desc_partial_reception.h 98365b48442b9e3abb58101983b5da8c14f78289 - include/libdvbv5/dvb-v5-std.h 2f55ba765c689500401111747bb381b5aca77b30 - include/libdvbv5/desc_ca.h 100c02ce3bc364ddff895c75f4fb1f928a748d2d - include/libdvbv5/desc_cable_delivery.h 96db22ef84892a36d5df3cffa0b30d5bad01939c - include/libdvbv5/desc_logical_channel.h 7645dda247bcd45628afbb74ec2707a47050992e - include/libdvbv5/nit.h 30e9a7240938943de2725f2b335b19ad320179a5 - include/libdvbv5/header.h c1212a9308d96730de547648d3cda2fc144d0e29 - include/libdvbv5/desc_atsc_service_location.h 5b4a5e7fb30a7f28118be012837e73a7151d2619 - include/libdvbv5/cat.h 2560f18846a535a2c02e1ae449511e731f11c011 - include/libdvbv5/desc_ca_identifier.h 450fab787e61210c0c5f527df92c31c90b44a113 - include/libdvbv5/desc_service.h cabecc6d7c9fdf1c437273bd6a746bf83c156f72 - include/libdvbv5/desc_frequency_list.h 7a6093b13354d054cac78ea118a96e813cac3395 - include/libdvbv5/atsc_eit.h 9a2b20076d6728b5799096e4149e33a73119e1ef - include/libdvbv5/desc_sat.h 146f4f53fc49c66b59905249c0142efffd72fc54 - include/libdvbv5/desc_network_name.h efa3a711499f68ae370d49d98dc1963bf6bafcd8 - include/libdvbv5/desc_extension.h 44ab16a8d4eae09690c71a6301927c1da55dda6d - include/libdvbv5/descriptors.h c18291ff9009bfe71a2c7c6f0fce75331dc95e30 - include/libdvbv5/sdt.h 5e2dfc1d9a71805389e9a7932812695d0309050c - include/libdvbv5/dvb-frontend.h e81b7f75c11f175cf365fc7fb535e80828f10e24 - include/libdvbv5/dvb-file.h d7a096d51e3050c8f52e0e2111d88b71a5313da1 - include/libdvbv5/dvb-demux.h bdf514383ca0afe981cf4fd6af86440db2dc6667 - include/libdvbv5/pat.h b72b6d1ffcdd81e3e631c7c20bb30e5c287dc7ff - include/libdvbv5/vct.h 9b5cfad4a5f41cbf886507da6e79b07314827b32 - include/libdvbv5/desc_language.h 6e6fd4c61c1f61006c63214cbe4868d49428ddb9 - include/libdvbv5/mpeg_pes.h 188fc2cbec97288787a7f66554a4b6288224f980 - include/libdvbv5/desc_isdbt_delivery.h 73b7b0cf684de0e8a4eae49a8521f81b411d7b72 - include/libdvbv5/desc_ts_info.h 7544b5fb8f621a9c637c40d8f7a2a71f6ab4bd63 - include/libdvbv5/desc_hierarchy.h 9d523ee179af955a687662996050ee3cfaacf2ab - include/libdvbv5/crc32.h 7fb0966c6a1ccdf1a8844aed4a94d4ae1d02fcd7 - include/libdvbv5/dvb-fe.h c8b4fc511833f0993fa740a529e1f61e0f5a216f - include/libdvbv5/mpeg_es.h ac87e3306569dae329809f27ef227c5d50f0b60e - include/libdvbv5/desc_event_short.h 40a06b5375dbc0de88a15d26cc6c1e9a505119bc - include/libdvbv5/eit.h ef979f3276cc3cad6e947865a42643fbba860c69 - include/libdvbv5/mgt.h b867a2e7941d718aa64b2f6a1402322b616cb2da - include/libdvbv5/pmt.h fb8d640da36b6a156cbe0ef12dc25468de89a2a1 - include/libdvbv5/dvb-sat.h 4c412880f0c49cd00cb16e56eed082c4744211a5 - include/libdvbv5/countries.h ad13bfa0b1642fc72cca387e62bc193974c8d5ee - include/libdvbv5/atsc_header.h 02168c58e3c772f116f075085579ac4a8422e819 - include/libdvbv5/desc_terrestrial_delivery.h 4fe7def34ff640fc5e327b3596298169fdfe2f1c - include/libdvbv5/mpeg_ts.h d562371bb8a3b961c4d63a0f5618453bdff4bcd3 - include/libdvbv5/dvb-log.h 2542aabb7fbff4b1a09faaadec6006c4410a6d10 - libv4l2/libv4l2-priv.h 4ba98a607592ed0b8327b387af354544c65c9b67 - libv4l2/v4l2-plugin-android.c 752cb342c44989a8c172e3280e220a6fa2ec86b5 - libv4l2/Makefile ffecae84262f548deac1da0fa51f1aba6b6f96a0 - libv4l2/Makefile.dGPU 766aaca553b0166eb736557e44ad42b69464aa53 - libv4l2/libv4l2.export e6516370c43e4869e05a540d2e4ef584ac64890a - libv4l2/v4l2-plugin.c 8e335567bf404eeb3d180dd384309f687f2ab944 - libv4l2/Makefile.am d1f2b6f016cfb90c616d848418feb915e3737fa7 - libv4l2/libv4l2.c 7fa618184ff89737d13164be0b79e227d81f398c - libv4l2/log.c cbcee4426c19c168c6f49d04af3a0b2e30c0b681 - libv4l2/libv4l2.pc.in 9d456d1772885d900865a8958c0291e13d509de5 - libv4l2/v4l2convert.c Change-Id: Ib9c2be8c51af3ac26ffd9f230946bf7bff65a02b
This commit is contained in:
svcmobrel-release
217
libv4lconvert/processing/autogain.c
Normal file
217
libv4lconvert/processing/autogain.c
Normal file
@@ -0,0 +1,217 @@
|
||||
/*
|
||||
# (C) 2008-2009 Hans de Goede <hdegoede@redhat.com>
|
||||
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU Lesser General Public License, version 2.1,
|
||||
# as published by the Free Software Foundation.
|
||||
#
|
||||
# This program 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 Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA
|
||||
*/
|
||||
|
||||
#include <errno.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "libv4lprocessing.h"
|
||||
#include "libv4lprocessing-priv.h"
|
||||
#include "../libv4lconvert-priv.h" /* for PIX_FMT defines */
|
||||
#include "../libv4lsyscall-priv.h"
|
||||
|
||||
static int autogain_active(struct v4lprocessing_data *data)
|
||||
{
|
||||
int autogain;
|
||||
|
||||
autogain = v4lcontrol_get_ctrl(data->control, V4LCONTROL_AUTOGAIN);
|
||||
if (!autogain) {
|
||||
/* Reset last_correction val */
|
||||
data->last_gain_correction = 0;
|
||||
}
|
||||
|
||||
return autogain;
|
||||
}
|
||||
|
||||
/* Adjust ctrl value with steps steps, while not crossing limit */
|
||||
static void autogain_adjust(struct v4l2_queryctrl *ctrl, int *value,
|
||||
int steps, int limit, int accel)
|
||||
{
|
||||
int ctrl_range = (ctrl->maximum - ctrl->minimum) / ctrl->step;
|
||||
|
||||
/* If we are of 3 * deadzone or more, and we have a fine grained
|
||||
control, take larger steps, otherwise we take ages to get to the
|
||||
right setting point. We use 256 as tripping point for determining
|
||||
fine grained controls here, as avg_lum has a range of 0 - 255. */
|
||||
if (accel && abs(steps) >= 3 && ctrl_range > 256)
|
||||
*value += steps * ctrl->step * (ctrl_range / 256);
|
||||
/* If we are of by less then 3, but have a very finegrained control
|
||||
still speed things up a bit */
|
||||
else if (accel && ctrl_range > 1024)
|
||||
*value += steps * ctrl->step * (ctrl_range / 1024);
|
||||
else
|
||||
*value += steps * ctrl->step;
|
||||
|
||||
if (steps > 0) {
|
||||
if (*value > limit)
|
||||
*value = limit;
|
||||
} else {
|
||||
if (*value < limit)
|
||||
*value = limit;
|
||||
}
|
||||
}
|
||||
|
||||
/* auto gain and exposure algorithm based on the knee algorithm described here:
|
||||
http://ytse.tricolour.net/docs/LowLightOptimization.html */
|
||||
static int autogain_calculate_lookup_tables(
|
||||
struct v4lprocessing_data *data,
|
||||
unsigned char *buf, const struct v4l2_format *fmt)
|
||||
{
|
||||
int x, y, target, steps, avg_lum = 0;
|
||||
int gain, exposure, orig_gain, orig_exposure, exposure_low;
|
||||
struct v4l2_control ctrl;
|
||||
struct v4l2_queryctrl gainctrl, expoctrl;
|
||||
const int deadzone = 6;
|
||||
|
||||
ctrl.id = V4L2_CID_EXPOSURE;
|
||||
expoctrl.id = V4L2_CID_EXPOSURE;
|
||||
if (SYS_IOCTL(data->fd, VIDIOC_QUERYCTRL, &expoctrl) ||
|
||||
SYS_IOCTL(data->fd, VIDIOC_G_CTRL, &ctrl))
|
||||
return 0;
|
||||
|
||||
exposure = orig_exposure = ctrl.value;
|
||||
/* Determine a value below which we try to not lower the exposure,
|
||||
as most exposure controls tend to jump with big steps in the low
|
||||
range, causing oscilation, so we prefer to use gain when exposure
|
||||
has hit this value */
|
||||
exposure_low = (expoctrl.maximum - expoctrl.minimum) / 10;
|
||||
/* If we have a fine grained exposure control only avoid the last 10 steps */
|
||||
steps = exposure_low / expoctrl.step;
|
||||
if (steps > 10)
|
||||
steps = 10;
|
||||
exposure_low = steps * expoctrl.step + expoctrl.minimum;
|
||||
|
||||
ctrl.id = V4L2_CID_GAIN;
|
||||
gainctrl.id = V4L2_CID_GAIN;
|
||||
if (SYS_IOCTL(data->fd, VIDIOC_QUERYCTRL, &gainctrl) ||
|
||||
SYS_IOCTL(data->fd, VIDIOC_G_CTRL, &ctrl))
|
||||
return 0;
|
||||
gain = orig_gain = ctrl.value;
|
||||
|
||||
switch (fmt->fmt.pix.pixelformat) {
|
||||
case V4L2_PIX_FMT_SGBRG8:
|
||||
case V4L2_PIX_FMT_SGRBG8:
|
||||
case V4L2_PIX_FMT_SBGGR8:
|
||||
case V4L2_PIX_FMT_SRGGB8:
|
||||
buf += fmt->fmt.pix.height * fmt->fmt.pix.bytesperline / 4 +
|
||||
fmt->fmt.pix.width / 4;
|
||||
|
||||
for (y = 0; (unsigned)y < fmt->fmt.pix.height / 2; y++) {
|
||||
for (x = 0; (unsigned)x < fmt->fmt.pix.width / 2; x++)
|
||||
avg_lum += *buf++;
|
||||
buf += fmt->fmt.pix.bytesperline - fmt->fmt.pix.width / 2;
|
||||
}
|
||||
avg_lum /= fmt->fmt.pix.height * fmt->fmt.pix.width / 4;
|
||||
break;
|
||||
|
||||
case V4L2_PIX_FMT_RGB24:
|
||||
case V4L2_PIX_FMT_BGR24:
|
||||
buf += fmt->fmt.pix.height * fmt->fmt.pix.bytesperline / 4 +
|
||||
fmt->fmt.pix.width * 3 / 4;
|
||||
|
||||
for (y = 0; (unsigned)y < fmt->fmt.pix.height / 2; y++) {
|
||||
for (x = 0; (unsigned)x < fmt->fmt.pix.width / 2; x++) {
|
||||
avg_lum += *buf++;
|
||||
avg_lum += *buf++;
|
||||
avg_lum += *buf++;
|
||||
}
|
||||
buf += fmt->fmt.pix.bytesperline - fmt->fmt.pix.width * 3 / 2;
|
||||
}
|
||||
avg_lum /= fmt->fmt.pix.height * fmt->fmt.pix.width * 3 / 4;
|
||||
break;
|
||||
}
|
||||
|
||||
/* If we are off a multiple of deadzone, do multiple steps to reach the
|
||||
desired lumination fast (with the risc of a slight overshoot) */
|
||||
target = v4lcontrol_get_ctrl(data->control, V4LCONTROL_AUTOGAIN_TARGET);
|
||||
steps = (target - avg_lum) / deadzone;
|
||||
|
||||
/* If we were decreasing and are now increasing, or vica versa, half the
|
||||
number of steps to avoid overshooting and oscilating */
|
||||
if ((steps > 0 && data->last_gain_correction < 0) ||
|
||||
(steps < 0 && data->last_gain_correction > 0))
|
||||
steps /= 2;
|
||||
|
||||
if (steps == 0)
|
||||
return 0; /* Nothing to do */
|
||||
|
||||
if (steps < 0) {
|
||||
if (exposure > expoctrl.default_value)
|
||||
autogain_adjust(&expoctrl, &exposure, steps,
|
||||
expoctrl.default_value, 1);
|
||||
else if (gain > gainctrl.default_value)
|
||||
autogain_adjust(&gainctrl, &gain, steps,
|
||||
gainctrl.default_value, 1);
|
||||
else if (exposure > exposure_low)
|
||||
autogain_adjust(&expoctrl, &exposure, steps,
|
||||
exposure_low, 1);
|
||||
else if (gain > gainctrl.minimum)
|
||||
autogain_adjust(&gainctrl, &gain, steps,
|
||||
gainctrl.minimum, 1);
|
||||
else if (exposure > expoctrl.minimum)
|
||||
autogain_adjust(&expoctrl, &exposure, steps,
|
||||
expoctrl.minimum, 0);
|
||||
else
|
||||
steps = 0;
|
||||
} else {
|
||||
if (exposure < exposure_low)
|
||||
autogain_adjust(&expoctrl, &exposure, steps,
|
||||
exposure_low, 0);
|
||||
else if (gain < gainctrl.default_value)
|
||||
autogain_adjust(&gainctrl, &gain, steps,
|
||||
gainctrl.default_value, 1);
|
||||
else if (exposure < expoctrl.default_value)
|
||||
autogain_adjust(&expoctrl, &exposure, steps,
|
||||
expoctrl.default_value, 1);
|
||||
else if (gain < gainctrl.maximum)
|
||||
autogain_adjust(&gainctrl, &gain, steps,
|
||||
gainctrl.maximum, 1);
|
||||
else if (exposure < expoctrl.maximum)
|
||||
autogain_adjust(&expoctrl, &exposure, steps,
|
||||
expoctrl.maximum, 1);
|
||||
else
|
||||
steps = 0;
|
||||
}
|
||||
|
||||
if (steps) {
|
||||
data->last_gain_correction = steps;
|
||||
/* We are still settling down, force the next update sooner. Note we
|
||||
skip the next frame as that is still captured with the old settings,
|
||||
and another one just to be sure (because if we re-adjust based
|
||||
on the old settings we might overshoot). */
|
||||
data->lookup_table_update_counter = V4L2PROCESSING_UPDATE_RATE - 2;
|
||||
}
|
||||
|
||||
if (gain != orig_gain) {
|
||||
ctrl.id = V4L2_CID_GAIN;
|
||||
ctrl.value = gain;
|
||||
SYS_IOCTL(data->fd, VIDIOC_S_CTRL, &ctrl);
|
||||
}
|
||||
if (exposure != orig_exposure) {
|
||||
ctrl.id = V4L2_CID_EXPOSURE;
|
||||
ctrl.value = exposure;
|
||||
SYS_IOCTL(data->fd, VIDIOC_S_CTRL, &ctrl);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct v4lprocessing_filter autogain_filter = {
|
||||
autogain_active, autogain_calculate_lookup_tables
|
||||
};
|
||||
61
libv4lconvert/processing/gamma.c
Normal file
61
libv4lconvert/processing/gamma.c
Normal file
@@ -0,0 +1,61 @@
|
||||
/*
|
||||
# (C) 2008-2009 Hans de Goede <hdegoede@redhat.com>
|
||||
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU Lesser General Public License, version 2.1,
|
||||
# as published by the Free Software Foundation.
|
||||
#
|
||||
# This program 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 Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA
|
||||
*/
|
||||
|
||||
#include <math.h>
|
||||
#include "libv4lprocessing.h"
|
||||
#include "libv4lprocessing-priv.h"
|
||||
|
||||
#define CLIP(color) (unsigned char)(((color) > 0xff) ? 0xff : (((color) < 0) ? 0 : (color)))
|
||||
|
||||
static int gamma_active(struct v4lprocessing_data *data)
|
||||
{
|
||||
int gamma = v4lcontrol_get_ctrl(data->control, V4LCONTROL_GAMMA);
|
||||
|
||||
return gamma && gamma != 1000;
|
||||
}
|
||||
|
||||
static int gamma_calculate_lookup_tables(
|
||||
struct v4lprocessing_data *data,
|
||||
unsigned char *buf, const struct v4l2_format *fmt)
|
||||
{
|
||||
int i, x, gamma;
|
||||
|
||||
gamma = v4lcontrol_get_ctrl(data->control, V4LCONTROL_GAMMA);
|
||||
|
||||
if (gamma == 0)
|
||||
return 0;
|
||||
|
||||
if (gamma != data->last_gamma) {
|
||||
for (i = 0; i < 256; i++) {
|
||||
x = powf(i / 255.0, 1000.0 / gamma) * 255;
|
||||
data->gamma_table[i] = CLIP(x);
|
||||
}
|
||||
data->last_gamma = gamma;
|
||||
}
|
||||
|
||||
for (i = 0; i < 256; i++) {
|
||||
data->comp1[i] = data->gamma_table[data->comp1[i]];
|
||||
data->green[i] = data->gamma_table[data->green[i]];
|
||||
data->comp2[i] = data->gamma_table[data->comp2[i]];
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
struct v4lprocessing_filter gamma_filter = {
|
||||
gamma_active, gamma_calculate_lookup_tables
|
||||
};
|
||||
67
libv4lconvert/processing/libv4lprocessing-priv.h
Normal file
67
libv4lconvert/processing/libv4lprocessing-priv.h
Normal file
@@ -0,0 +1,67 @@
|
||||
/*
|
||||
# (C) 2008-2009 Elmar Kleijn <elmar_kleijn@hotmail.com>
|
||||
# (C) 2008-2009 Sjoerd Piepenbrink <need4weed@gmail.com>
|
||||
# (C) 2008-2009 Hans de Goede <hdegoede@redhat.com>
|
||||
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU Lesser General Public License, version 2.1,
|
||||
# as published by the Free Software Foundation.
|
||||
#
|
||||
# This program 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 Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA
|
||||
*/
|
||||
|
||||
#ifndef __LIBV4LPROCESSING_PRIV_H
|
||||
#define __LIBV4LPROCESSING_PRIV_H
|
||||
|
||||
#include "../control/libv4lcontrol.h"
|
||||
#include "../libv4lsyscall-priv.h"
|
||||
|
||||
#define V4L2PROCESSING_UPDATE_RATE 10
|
||||
|
||||
struct v4lprocessing_data {
|
||||
struct v4lcontrol_data *control;
|
||||
int fd;
|
||||
int do_process;
|
||||
int controls_changed;
|
||||
/* True if any of the lookup tables does not contain
|
||||
linear 0-255 */
|
||||
int lookup_table_active;
|
||||
/* Counts the number of processed frames until a
|
||||
V4L2PROCESSING_UPDATE_RATE overflow happens */
|
||||
int lookup_table_update_counter;
|
||||
/* RGB/BGR lookup tables */
|
||||
unsigned char comp1[256];
|
||||
unsigned char green[256];
|
||||
unsigned char comp2[256];
|
||||
/* Filter private data for filters which need it */
|
||||
/* whitebalance.c data */
|
||||
int green_avg;
|
||||
int comp1_avg;
|
||||
int comp2_avg;
|
||||
/* gamma.c data */
|
||||
int last_gamma;
|
||||
unsigned char gamma_table[256];
|
||||
/* autogain.c data */
|
||||
int last_gain_correction;
|
||||
};
|
||||
|
||||
struct v4lprocessing_filter {
|
||||
/* Returns 1 if the filter is active */
|
||||
int (*active)(struct v4lprocessing_data *data);
|
||||
/* Returns 1 if any of the lookup tables was changed */
|
||||
int (*calculate_lookup_tables)(struct v4lprocessing_data *data,
|
||||
unsigned char *buf, const struct v4l2_format *fmt);
|
||||
};
|
||||
|
||||
extern struct v4lprocessing_filter whitebalance_filter;
|
||||
extern struct v4lprocessing_filter autogain_filter;
|
||||
extern struct v4lprocessing_filter gamma_filter;
|
||||
|
||||
#endif
|
||||
187
libv4lconvert/processing/libv4lprocessing.c
Normal file
187
libv4lconvert/processing/libv4lprocessing.c
Normal file
@@ -0,0 +1,187 @@
|
||||
/*
|
||||
# (C) 2008-2009 Elmar Kleijn <elmar_kleijn@hotmail.com>
|
||||
# (C) 2008-2009 Sjoerd Piepenbrink <need4weed@gmail.com>
|
||||
# (C) 2008-2009 Hans de Goede <hdegoede@redhat.com>
|
||||
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU Lesser General Public License, version 2.1,
|
||||
# as published by the Free Software Foundation.
|
||||
#
|
||||
# This program 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 Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA
|
||||
*/
|
||||
|
||||
#include <errno.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
#include "libv4lprocessing.h"
|
||||
#include "libv4lprocessing-priv.h"
|
||||
#include "../libv4lconvert-priv.h" /* for PIX_FMT defines */
|
||||
|
||||
static struct v4lprocessing_filter *filters[] = {
|
||||
&whitebalance_filter,
|
||||
&autogain_filter,
|
||||
&gamma_filter,
|
||||
};
|
||||
|
||||
struct v4lprocessing_data *v4lprocessing_create(int fd, struct v4lcontrol_data *control)
|
||||
{
|
||||
struct v4lprocessing_data *data =
|
||||
calloc(1, sizeof(struct v4lprocessing_data));
|
||||
|
||||
if (!data) {
|
||||
fprintf(stderr, "libv4lprocessing: error: out of memory!\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
data->fd = fd;
|
||||
data->control = control;
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
void v4lprocessing_destroy(struct v4lprocessing_data *data)
|
||||
{
|
||||
free(data);
|
||||
}
|
||||
|
||||
int v4lprocessing_pre_processing(struct v4lprocessing_data *data)
|
||||
{
|
||||
int i;
|
||||
|
||||
data->do_process = 0;
|
||||
for (i = 0; i < ARRAY_SIZE(filters); i++) {
|
||||
if (filters[i]->active(data))
|
||||
data->do_process = 1;
|
||||
}
|
||||
|
||||
data->controls_changed |= v4lcontrol_controls_changed(data->control);
|
||||
|
||||
return data->do_process;
|
||||
}
|
||||
|
||||
static void v4lprocessing_update_lookup_tables(struct v4lprocessing_data *data,
|
||||
unsigned char *buf, const struct v4l2_format *fmt)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 256; i++) {
|
||||
data->comp1[i] = i;
|
||||
data->green[i] = i;
|
||||
data->comp2[i] = i;
|
||||
}
|
||||
|
||||
data->lookup_table_active = 0;
|
||||
for (i = 0; i < ARRAY_SIZE(filters); i++) {
|
||||
if (filters[i]->active(data)) {
|
||||
if (filters[i]->calculate_lookup_tables(data, buf, fmt))
|
||||
data->lookup_table_active = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void v4lprocessing_do_processing(struct v4lprocessing_data *data,
|
||||
unsigned char *buf, const struct v4l2_format *fmt)
|
||||
{
|
||||
int x, y;
|
||||
|
||||
switch (fmt->fmt.pix.pixelformat) {
|
||||
case V4L2_PIX_FMT_SGBRG8:
|
||||
case V4L2_PIX_FMT_SGRBG8: /* Bayer patterns starting with green */
|
||||
for (y = 0; (unsigned)y < fmt->fmt.pix.height / 2; y++) {
|
||||
for (x = 0; (unsigned)x < fmt->fmt.pix.width / 2; x++) {
|
||||
*buf = data->green[*buf];
|
||||
buf++;
|
||||
*buf = data->comp1[*buf];
|
||||
buf++;
|
||||
}
|
||||
buf += fmt->fmt.pix.bytesperline - fmt->fmt.pix.width;
|
||||
for (x = 0; (unsigned)x < fmt->fmt.pix.width / 2; x++) {
|
||||
*buf = data->comp2[*buf];
|
||||
buf++;
|
||||
*buf = data->green[*buf];
|
||||
buf++;
|
||||
}
|
||||
buf += fmt->fmt.pix.bytesperline - fmt->fmt.pix.width;
|
||||
}
|
||||
break;
|
||||
|
||||
case V4L2_PIX_FMT_SBGGR8:
|
||||
case V4L2_PIX_FMT_SRGGB8: /* Bayer patterns *NOT* starting with green */
|
||||
for (y = 0; (unsigned)y < fmt->fmt.pix.height / 2; y++) {
|
||||
for (x = 0; (unsigned)x < fmt->fmt.pix.width / 2; x++) {
|
||||
*buf = data->comp1[*buf];
|
||||
buf++;
|
||||
*buf = data->green[*buf];
|
||||
buf++;
|
||||
}
|
||||
buf += fmt->fmt.pix.bytesperline - fmt->fmt.pix.width;
|
||||
for (x = 0; (unsigned)x < fmt->fmt.pix.width / 2; x++) {
|
||||
*buf = data->green[*buf];
|
||||
buf++;
|
||||
*buf = data->comp2[*buf];
|
||||
buf++;
|
||||
}
|
||||
buf += fmt->fmt.pix.bytesperline - fmt->fmt.pix.width;
|
||||
}
|
||||
break;
|
||||
|
||||
case V4L2_PIX_FMT_RGB24:
|
||||
case V4L2_PIX_FMT_BGR24:
|
||||
for (y = 0; (unsigned)y < fmt->fmt.pix.height; y++) {
|
||||
for (x = 0; (unsigned)x < fmt->fmt.pix.width; x++) {
|
||||
*buf = data->comp1[*buf];
|
||||
buf++;
|
||||
*buf = data->green[*buf];
|
||||
buf++;
|
||||
*buf = data->comp2[*buf];
|
||||
buf++;
|
||||
}
|
||||
buf += fmt->fmt.pix.bytesperline - 3 * fmt->fmt.pix.width;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void v4lprocessing_processing(struct v4lprocessing_data *data,
|
||||
unsigned char *buf, const struct v4l2_format *fmt)
|
||||
{
|
||||
if (!data->do_process)
|
||||
return;
|
||||
|
||||
/* Do we support the current pixformat? */
|
||||
switch (fmt->fmt.pix.pixelformat) {
|
||||
case V4L2_PIX_FMT_SGBRG8:
|
||||
case V4L2_PIX_FMT_SGRBG8:
|
||||
case V4L2_PIX_FMT_SBGGR8:
|
||||
case V4L2_PIX_FMT_SRGGB8:
|
||||
case V4L2_PIX_FMT_RGB24:
|
||||
case V4L2_PIX_FMT_BGR24:
|
||||
break;
|
||||
default:
|
||||
return; /* Non supported pix format */
|
||||
}
|
||||
|
||||
if (data->controls_changed ||
|
||||
data->lookup_table_update_counter == V4L2PROCESSING_UPDATE_RATE) {
|
||||
data->controls_changed = 0;
|
||||
data->lookup_table_update_counter = 0;
|
||||
/* Do this after resetting lookup_table_update_counter so that filters can
|
||||
force the next update to be sooner when they changed camera settings */
|
||||
v4lprocessing_update_lookup_tables(data, buf, fmt);
|
||||
} else
|
||||
data->lookup_table_update_counter++;
|
||||
|
||||
if (data->lookup_table_active)
|
||||
v4lprocessing_do_processing(data, buf, fmt);
|
||||
|
||||
data->do_process = 0;
|
||||
}
|
||||
42
libv4lconvert/processing/libv4lprocessing.h
Normal file
42
libv4lconvert/processing/libv4lprocessing.h
Normal file
@@ -0,0 +1,42 @@
|
||||
/*
|
||||
# (C) 2008-2009 Elmar Kleijn <elmar_kleijn@hotmail.com>
|
||||
# (C) 2008-2009 Sjoerd Piepenbrink <need4weed@gmail.com>
|
||||
# (C) 2008-2009 Hans de Goede <hdegoede@redhat.com>
|
||||
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU Lesser General Public License, version 2.1,
|
||||
# as published by the Free Software Foundation.
|
||||
#
|
||||
# This program 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 Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA
|
||||
*/
|
||||
|
||||
#ifndef __LIBV4LPROCESSING_H
|
||||
#define __LIBV4LPROCESSING_H
|
||||
|
||||
#include "../libv4lsyscall-priv.h"
|
||||
#include <linux/videodev2.h>
|
||||
|
||||
struct v4lprocessing_data;
|
||||
struct v4lcontrol_data;
|
||||
|
||||
struct v4lprocessing_data *v4lprocessing_create(int fd, struct v4lcontrol_data *data);
|
||||
void v4lprocessing_destroy(struct v4lprocessing_data *data);
|
||||
|
||||
/* Prepare to process 1 frame, returns 1 if processing is necesary,
|
||||
return 0 if no processing will be done */
|
||||
int v4lprocessing_pre_processing(struct v4lprocessing_data *data);
|
||||
|
||||
/* Do the actual processing, this is a nop if v4lprocessing_pre_processing()
|
||||
returned 0, or if called more then 1 time after a single
|
||||
v4lprocessing_pre_processing() call. */
|
||||
void v4lprocessing_processing(struct v4lprocessing_data *data,
|
||||
unsigned char *buf, const struct v4l2_format *fmt);
|
||||
|
||||
#endif
|
||||
209
libv4lconvert/processing/whitebalance.c
Normal file
209
libv4lconvert/processing/whitebalance.c
Normal file
@@ -0,0 +1,209 @@
|
||||
/*
|
||||
# (C) 2008-2009 Elmar Kleijn <elmar_kleijn@hotmail.com>
|
||||
# (C) 2008-2009 Sjoerd Piepenbrink <need4weed@gmail.com>
|
||||
# (C) 2008-2009 Hans de Goede <hdegoede@redhat.com>
|
||||
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU Lesser General Public License, version 2.1,
|
||||
# as published by the Free Software Foundation.
|
||||
#
|
||||
# This program 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 Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA
|
||||
*/
|
||||
|
||||
#include <errno.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
#include "libv4lprocessing.h"
|
||||
#include "libv4lprocessing-priv.h"
|
||||
#include "../libv4lconvert-priv.h" /* for PIX_FMT defines */
|
||||
|
||||
#define CLIP256(color) (((color) > 0xff) ? 0xff : (((color) < 0) ? 0 : (color)))
|
||||
#define CLIP(color, min, max) (((color) > (max)) ? (max) : (((color) < (min)) ? (min) : (color)))
|
||||
|
||||
static int whitebalance_active(struct v4lprocessing_data *data)
|
||||
{
|
||||
int wb;
|
||||
|
||||
wb = v4lcontrol_get_ctrl(data->control, V4LCONTROL_WHITEBALANCE);
|
||||
if (!wb) {
|
||||
/* Reset cached color averages */
|
||||
data->green_avg = 0;
|
||||
}
|
||||
|
||||
return wb;
|
||||
}
|
||||
|
||||
static int whitebalance_calculate_lookup_tables_generic(
|
||||
struct v4lprocessing_data *data, int green_avg, int comp1_avg, int comp2_avg)
|
||||
{
|
||||
int i, avg_avg;
|
||||
const int threshold = 64;
|
||||
const int max_step = 128;
|
||||
|
||||
/* Clip averages (restricts maximum white balance correction) */
|
||||
green_avg = CLIP(green_avg, 512, 3072);
|
||||
comp1_avg = CLIP(comp1_avg, 512, 3072);
|
||||
comp2_avg = CLIP(comp2_avg, 512, 3072);
|
||||
|
||||
/* First frame ? */
|
||||
if (data->green_avg == 0) {
|
||||
data->green_avg = green_avg;
|
||||
data->comp1_avg = comp1_avg;
|
||||
data->comp2_avg = comp2_avg;
|
||||
} else {
|
||||
/* Slowly adjust the averages used for the correction, so that
|
||||
we do not get a sudden change in colors */
|
||||
int throttling = 0;
|
||||
|
||||
if (abs(data->green_avg - green_avg) > max_step) {
|
||||
if (data->green_avg < green_avg)
|
||||
data->green_avg += max_step;
|
||||
else
|
||||
data->green_avg -= max_step;
|
||||
throttling = 1;
|
||||
} else
|
||||
data->green_avg = green_avg;
|
||||
|
||||
if (abs(data->comp1_avg - comp1_avg) > max_step) {
|
||||
if (data->comp1_avg < comp1_avg)
|
||||
data->comp1_avg += max_step;
|
||||
else
|
||||
data->comp1_avg -= max_step;
|
||||
throttling = 1;
|
||||
} else
|
||||
data->comp1_avg = comp1_avg;
|
||||
|
||||
if (abs(data->comp2_avg - comp2_avg) > max_step) {
|
||||
if (data->comp2_avg < comp2_avg)
|
||||
data->comp2_avg += max_step;
|
||||
else
|
||||
data->comp2_avg -= max_step;
|
||||
throttling = 1;
|
||||
} else
|
||||
data->comp2_avg = comp2_avg;
|
||||
|
||||
/*
|
||||
* If we are still converging to a stable update situation,
|
||||
* re-calc the lookup tables next frame, but only if no
|
||||
* other processing plugin has already asked for a shorter
|
||||
* update cycle, as asking for an update each frame while
|
||||
* some other pluging is trying to adjust hw settings is bad.
|
||||
*/
|
||||
if (throttling && data->lookup_table_update_counter == 0)
|
||||
data->lookup_table_update_counter =
|
||||
V4L2PROCESSING_UPDATE_RATE;
|
||||
}
|
||||
|
||||
if (abs(data->green_avg - data->comp1_avg) < threshold &&
|
||||
abs(data->green_avg - data->comp2_avg) < threshold &&
|
||||
abs(data->comp1_avg - data->comp2_avg) < threshold)
|
||||
return 0;
|
||||
|
||||
avg_avg = (data->green_avg + data->comp1_avg + data->comp2_avg) / 3;
|
||||
|
||||
for (i = 0; i < 256; i++) {
|
||||
data->comp1[i] = CLIP256(data->comp1[i] * avg_avg / data->comp1_avg);
|
||||
data->green[i] = CLIP256(data->green[i] * avg_avg / data->green_avg);
|
||||
data->comp2[i] = CLIP256(data->comp2[i] * avg_avg / data->comp2_avg);
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int whitebalance_calculate_lookup_tables_bayer(
|
||||
struct v4lprocessing_data *data, unsigned char *buf,
|
||||
const struct v4l2_format *fmt, int starts_with_green)
|
||||
{
|
||||
int x, y, a1 = 0, a2 = 0, b1 = 0, b2 = 0;
|
||||
int green_avg, comp1_avg, comp2_avg;
|
||||
|
||||
for (y = 0; (unsigned)y < fmt->fmt.pix.height; y += 2) {
|
||||
for (x = 0; (unsigned)x < fmt->fmt.pix.width; x += 2) {
|
||||
a1 += *buf++;
|
||||
a2 += *buf++;
|
||||
}
|
||||
buf += fmt->fmt.pix.bytesperline - fmt->fmt.pix.width;
|
||||
for (x = 0; (unsigned)x < fmt->fmt.pix.width; x += 2) {
|
||||
b1 += *buf++;
|
||||
b2 += *buf++;
|
||||
}
|
||||
buf += fmt->fmt.pix.bytesperline - fmt->fmt.pix.width;
|
||||
}
|
||||
|
||||
if (starts_with_green) {
|
||||
green_avg = a1 / 2 + b2 / 2;
|
||||
comp1_avg = a2;
|
||||
comp2_avg = b1;
|
||||
} else {
|
||||
green_avg = a2 / 2 + b1 / 2;
|
||||
comp1_avg = a1;
|
||||
comp2_avg = b2;
|
||||
}
|
||||
|
||||
/* Norm avg to ~ 0 - 4095 */
|
||||
green_avg /= fmt->fmt.pix.width * fmt->fmt.pix.height / 64;
|
||||
comp1_avg /= fmt->fmt.pix.width * fmt->fmt.pix.height / 64;
|
||||
comp2_avg /= fmt->fmt.pix.width * fmt->fmt.pix.height / 64;
|
||||
|
||||
return whitebalance_calculate_lookup_tables_generic(data, green_avg,
|
||||
comp1_avg, comp2_avg);
|
||||
}
|
||||
|
||||
static int whitebalance_calculate_lookup_tables_rgb(
|
||||
struct v4lprocessing_data *data, unsigned char *buf,
|
||||
const struct v4l2_format *fmt)
|
||||
{
|
||||
int x, y, green_avg = 0, comp1_avg = 0, comp2_avg = 0;
|
||||
|
||||
for (y = 0; (unsigned)y < fmt->fmt.pix.height; y++) {
|
||||
for (x = 0; (unsigned)x < fmt->fmt.pix.width; x++) {
|
||||
comp1_avg += *buf++;
|
||||
green_avg += *buf++;
|
||||
comp2_avg += *buf++;
|
||||
}
|
||||
buf += fmt->fmt.pix.bytesperline - fmt->fmt.pix.width * 3;
|
||||
}
|
||||
|
||||
/* Norm avg to ~ 0 - 4095 */
|
||||
green_avg /= fmt->fmt.pix.width * fmt->fmt.pix.height / 16;
|
||||
comp1_avg /= fmt->fmt.pix.width * fmt->fmt.pix.height / 16;
|
||||
comp2_avg /= fmt->fmt.pix.width * fmt->fmt.pix.height / 16;
|
||||
|
||||
return whitebalance_calculate_lookup_tables_generic(data, green_avg,
|
||||
comp1_avg, comp2_avg);
|
||||
}
|
||||
|
||||
|
||||
static int whitebalance_calculate_lookup_tables(
|
||||
struct v4lprocessing_data *data,
|
||||
unsigned char *buf, const struct v4l2_format *fmt)
|
||||
{
|
||||
switch (fmt->fmt.pix.pixelformat) {
|
||||
case V4L2_PIX_FMT_SGBRG8:
|
||||
case V4L2_PIX_FMT_SGRBG8: /* Bayer patterns starting with green */
|
||||
return whitebalance_calculate_lookup_tables_bayer(data, buf, fmt, 1);
|
||||
|
||||
case V4L2_PIX_FMT_SBGGR8:
|
||||
case V4L2_PIX_FMT_SRGGB8: /* Bayer patterns *NOT* starting with green */
|
||||
return whitebalance_calculate_lookup_tables_bayer(data, buf, fmt, 0);
|
||||
|
||||
case V4L2_PIX_FMT_RGB24:
|
||||
case V4L2_PIX_FMT_BGR24:
|
||||
return whitebalance_calculate_lookup_tables_rgb(data, buf, fmt);
|
||||
}
|
||||
|
||||
return 0; /* Should never happen */
|
||||
}
|
||||
|
||||
struct v4lprocessing_filter whitebalance_filter = {
|
||||
whitebalance_active, whitebalance_calculate_lookup_tables
|
||||
};
|
||||
Reference in New Issue
Block a user