[linux-2.6-block.git] / drivers / media / video / gspca / autogain_functions.c

/*
 * Functions for auto gain.
 *
 * Copyright (C) 2010-2012 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 General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include "gspca.h"

/* auto gain and exposure algorithm based on the knee algorithm described here:
   http://ytse.tricolour.net/docs/LowLightOptimization.html

   Returns 0 if no changes were made, 1 if the gain and or exposure settings
   where changed. */
int gspca_expo_autogain(
			struct gspca_dev *gspca_dev,
			int avg_lum,
			int desired_avg_lum,
			int deadzone,
			int gain_knee,
			int exposure_knee)
{
	s32 gain, orig_gain, exposure, orig_exposure;
	int i, steps, retval = 0;

	if (v4l2_ctrl_g_ctrl(gspca_dev->autogain) == 0)
	        return 0;

	orig_gain = gain = v4l2_ctrl_g_ctrl(gspca_dev->gain);
	orig_exposure = exposure = v4l2_ctrl_g_ctrl(gspca_dev->exposure);

	/* If we are of a multiple of deadzone, do multiple steps to reach the
	   desired lumination fast (with the risc of a slight overshoot) */
	steps = abs(desired_avg_lum - avg_lum) / deadzone;

	PDEBUG(D_FRAM, "autogain: lum: %d, desired: %d, steps: %d",
		avg_lum, desired_avg_lum, steps);

	for (i = 0; i < steps; i++) {
		if (avg_lum > desired_avg_lum) {
			if (gain > gain_knee)
				gain--;
			else if (exposure > exposure_knee)
				exposure--;
			else if (gain > gspca_dev->gain->default_value)
				gain--;
			else if (exposure > gspca_dev->exposure->minimum)
				exposure--;
			else if (gain > gspca_dev->gain->minimum)
				gain--;
			else
				break;
		} else {
			if (gain < gspca_dev->gain->default_value)
				gain++;
			else if (exposure < exposure_knee)
				exposure++;
			else if (gain < gain_knee)
				gain++;
			else if (exposure < gspca_dev->exposure->maximum)
				exposure++;
			else if (gain < gspca_dev->gain->maximum)
				gain++;
			else
				break;
		}
	}

	if (gain != orig_gain) {
	        v4l2_ctrl_s_ctrl(gspca_dev->gain, gain);
		retval = 1;
	}
	if (exposure != orig_exposure) {
	        v4l2_ctrl_s_ctrl(gspca_dev->exposure, exposure);
		retval = 1;
	}

	if (retval)
		PDEBUG(D_FRAM, "autogain: changed gain: %d, expo: %d",
			gain, exposure);
	return retval;
}
EXPORT_SYMBOL(gspca_expo_autogain);

/* Autogain + exposure algorithm for cameras with a coarse exposure control
   (usually this means we can only control the clockdiv to change exposure)
   As changing the clockdiv so that the fps drops from 30 to 15 fps for
   example, will lead to a huge exposure change (it effectively doubles),
   this algorithm normally tries to only adjust the gain (between 40 and
   80 %) and if that does not help, only then changes exposure. This leads
   to a much more stable image then using the knee algorithm which at
   certain points of the knee graph will only try to adjust exposure,
   which leads to oscilating as one exposure step is huge.

   Returns 0 if no changes were made, 1 if the gain and or exposure settings
   where changed. */
int gspca_coarse_grained_expo_autogain(
			struct gspca_dev *gspca_dev,
			int avg_lum,
			int desired_avg_lum,
			int deadzone)
{
	s32 gain_low, gain_high, gain, orig_gain, exposure, orig_exposure;
	int steps, retval = 0;

	if (v4l2_ctrl_g_ctrl(gspca_dev->autogain) == 0)
	        return 0;

	orig_gain = gain = v4l2_ctrl_g_ctrl(gspca_dev->gain);
	orig_exposure = exposure = v4l2_ctrl_g_ctrl(gspca_dev->exposure);

	gain_low  = (gspca_dev->gain->maximum - gspca_dev->gain->minimum) /
		    5 * 2 + gspca_dev->gain->minimum;
	gain_high = (gspca_dev->gain->maximum - gspca_dev->gain->minimum) /
		    5 * 4 + gspca_dev->gain->minimum;

	/* If we are of a multiple of deadzone, do multiple steps to reach the
	   desired lumination fast (with the risc of a slight overshoot) */
	steps = (desired_avg_lum - avg_lum) / deadzone;

	PDEBUG(D_FRAM, "autogain: lum: %d, desired: %d, steps: %d",
		avg_lum, desired_avg_lum, steps);

	if ((gain + steps) > gain_high &&
	    exposure < gspca_dev->exposure->maximum) {
		gain = gain_high;
		gspca_dev->exp_too_low_cnt++;
		gspca_dev->exp_too_high_cnt = 0;
	} else if ((gain + steps) < gain_low &&
		   exposure > gspca_dev->exposure->minimum) {
		gain = gain_low;
		gspca_dev->exp_too_high_cnt++;
		gspca_dev->exp_too_low_cnt = 0;
	} else {
		gain += steps;
		if (gain > gspca_dev->gain->maximum)
			gain = gspca_dev->gain->maximum;
		else if (gain < gspca_dev->gain->minimum)
			gain = gspca_dev->gain->minimum;
		gspca_dev->exp_too_high_cnt = 0;
		gspca_dev->exp_too_low_cnt = 0;
	}

	if (gspca_dev->exp_too_high_cnt > 3) {
		exposure--;
		gspca_dev->exp_too_high_cnt = 0;
	} else if (gspca_dev->exp_too_low_cnt > 3) {
		exposure++;
		gspca_dev->exp_too_low_cnt = 0;
	}

	if (gain != orig_gain) {
	        v4l2_ctrl_s_ctrl(gspca_dev->gain, gain);
		retval = 1;
	}
	if (exposure != orig_exposure) {
	        v4l2_ctrl_s_ctrl(gspca_dev->exposure, exposure);
		retval = 1;
	}

	if (retval)
		PDEBUG(D_FRAM, "autogain: changed gain: %d, expo: %d",
			gain, exposure);
	return retval;
}
EXPORT_SYMBOL(gspca_coarse_grained_expo_autogain);
Commit	Line	Data
8cd05842 HG	1	/*
	2	* Functions for auto gain.
	3	*
	4	* Copyright (C) 2010-2012 Hans de Goede <hdegoede@redhat.com>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	19	*/
	20	#include "gspca.h"
	21
	22	/* auto gain and exposure algorithm based on the knee algorithm described here:
	23	http://ytse.tricolour.net/docs/LowLightOptimization.html
	24
	25	Returns 0 if no changes were made, 1 if the gain and or exposure settings
	26	where changed. */
	27	int gspca_expo_autogain(
	28	struct gspca_dev *gspca_dev,
	29	int avg_lum,
	30	int desired_avg_lum,
	31	int deadzone,
	32	int gain_knee,
	33	int exposure_knee)
	34	{
	35	s32 gain, orig_gain, exposure, orig_exposure;
	36	int i, steps, retval = 0;
	37
	38	if (v4l2_ctrl_g_ctrl(gspca_dev->autogain) == 0)
	39	return 0;
	40
	41	orig_gain = gain = v4l2_ctrl_g_ctrl(gspca_dev->gain);
	42	orig_exposure = exposure = v4l2_ctrl_g_ctrl(gspca_dev->exposure);
	43
	44	/* If we are of a multiple of deadzone, do multiple steps to reach the
	45	desired lumination fast (with the risc of a slight overshoot) */
	46	steps = abs(desired_avg_lum - avg_lum) / deadzone;
	47
	48	PDEBUG(D_FRAM, "autogain: lum: %d, desired: %d, steps: %d",
	49	avg_lum, desired_avg_lum, steps);
	50
	51	for (i = 0; i < steps; i++) {
	52	if (avg_lum > desired_avg_lum) {
	53	if (gain > gain_knee)
	54	gain--;
	55	else if (exposure > exposure_knee)
	56	exposure--;
	57	else if (gain > gspca_dev->gain->default_value)
	58	gain--;
	59	else if (exposure > gspca_dev->exposure->minimum)
	60	exposure--;
	61	else if (gain > gspca_dev->gain->minimum)
	62	gain--;
	63	else
	64	break;
65	} else {
66	if (gain < gspca_dev->gain->default_value)
67	gain++;
68	else if (exposure < exposure_knee)
69	exposure++;
70	else if (gain < gain_knee)
71	gain++;
72	else if (exposure < gspca_dev->exposure->maximum)
73	exposure++;
74	else if (gain < gspca_dev->gain->maximum)
75	gain++;
76	else
77	break;
78	}
79	}
80
81	if (gain != orig_gain) {
82	v4l2_ctrl_s_ctrl(gspca_dev->gain, gain);
83	retval = 1;
84	}
85	if (exposure != orig_exposure) {
86	v4l2_ctrl_s_ctrl(gspca_dev->exposure, exposure);
87	retval = 1;
88	}
89
90	if (retval)
91	PDEBUG(D_FRAM, "autogain: changed gain: %d, expo: %d",
92	gain, exposure);
93	return retval;
94	}
95	EXPORT_SYMBOL(gspca_expo_autogain);
96
97	/* Autogain + exposure algorithm for cameras with a coarse exposure control
98	(usually this means we can only control the clockdiv to change exposure)
99	As changing the clockdiv so that the fps drops from 30 to 15 fps for
100	example, will lead to a huge exposure change (it effectively doubles),
101	this algorithm normally tries to only adjust the gain (between 40 and
102	80 %) and if that does not help, only then changes exposure. This leads
103	to a much more stable image then using the knee algorithm which at
104	certain points of the knee graph will only try to adjust exposure,
105	which leads to oscilating as one exposure step is huge.
106
107	Returns 0 if no changes were made, 1 if the gain and or exposure settings
108	where changed. */
109	int gspca_coarse_grained_expo_autogain(
110	struct gspca_dev *gspca_dev,
111	int avg_lum,
112	int desired_avg_lum,
113	int deadzone)
114	{
115	s32 gain_low, gain_high, gain, orig_gain, exposure, orig_exposure;
116	int steps, retval = 0;
117
118	if (v4l2_ctrl_g_ctrl(gspca_dev->autogain) == 0)
119	return 0;
120
121	orig_gain = gain = v4l2_ctrl_g_ctrl(gspca_dev->gain);
122	orig_exposure = exposure = v4l2_ctrl_g_ctrl(gspca_dev->exposure);
123
124	gain_low = (gspca_dev->gain->maximum - gspca_dev->gain->minimum) /
125	5 * 2 + gspca_dev->gain->minimum;
126	gain_high = (gspca_dev->gain->maximum - gspca_dev->gain->minimum) /
127	5 * 4 + gspca_dev->gain->minimum;
128
129	/* If we are of a multiple of deadzone, do multiple steps to reach the
130	desired lumination fast (with the risc of a slight overshoot) */
131	steps = (desired_avg_lum - avg_lum) / deadzone;
132
133	PDEBUG(D_FRAM, "autogain: lum: %d, desired: %d, steps: %d",
134	avg_lum, desired_avg_lum, steps);
135
136	if ((gain + steps) > gain_high &&
137	exposure < gspca_dev->exposure->maximum) {
138	gain = gain_high;
139	gspca_dev->exp_too_low_cnt++;
140	gspca_dev->exp_too_high_cnt = 0;
141	} else if ((gain + steps) < gain_low &&
142	exposure > gspca_dev->exposure->minimum) {
143	gain = gain_low;
144	gspca_dev->exp_too_high_cnt++;
145	gspca_dev->exp_too_low_cnt = 0;
146	} else {
147	gain += steps;
148	if (gain > gspca_dev->gain->maximum)
149	gain = gspca_dev->gain->maximum;
150	else if (gain < gspca_dev->gain->minimum)
151	gain = gspca_dev->gain->minimum;
152	gspca_dev->exp_too_high_cnt = 0;
153	gspca_dev->exp_too_low_cnt = 0;
154	}
155
156	if (gspca_dev->exp_too_high_cnt > 3) {
157	exposure--;
158	gspca_dev->exp_too_high_cnt = 0;
159	} else if (gspca_dev->exp_too_low_cnt > 3) {
160	exposure++;
161	gspca_dev->exp_too_low_cnt = 0;
162	}
163
164	if (gain != orig_gain) {
165	v4l2_ctrl_s_ctrl(gspca_dev->gain, gain);
166	retval = 1;
167	}
168	if (exposure != orig_exposure) {
169	v4l2_ctrl_s_ctrl(gspca_dev->exposure, exposure);
170	retval = 1;
171	}
172
173	if (retval)
174	PDEBUG(D_FRAM, "autogain: changed gain: %d, expo: %d",
175	gain, exposure);
176	return retval;
177	}
178	EXPORT_SYMBOL(gspca_coarse_grained_expo_autogain);