[linux-2.6-block.git] / drivers / media / usb / 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.
 */
#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;

	gspca_dbg(gspca_dev, D_FRAM, "autogain: lum: %d, desired: %d, steps: %d\n",
		  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)
		gspca_dbg(gspca_dev, D_FRAM, "autogain: changed gain: %d, expo: %d\n",
			  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  = (s32)(gspca_dev->gain->maximum - gspca_dev->gain->minimum) /
		    5 * 2 + gspca_dev->gain->minimum;
	gain_high = (s32)(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;

	gspca_dbg(gspca_dev, D_FRAM, "autogain: lum: %d, desired: %d, steps: %d\n",
		  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)
		gspca_dbg(gspca_dev, D_FRAM, "autogain: changed gain: %d, expo: %d\n",
			  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.
8cd05842 HG	15	*/
	16	#include "gspca.h"
	17
	18	/* auto gain and exposure algorithm based on the knee algorithm described here:
	19	http://ytse.tricolour.net/docs/LowLightOptimization.html
	20
	21	Returns 0 if no changes were made, 1 if the gain and or exposure settings
	22	where changed. */
	23	int gspca_expo_autogain(
	24	struct gspca_dev *gspca_dev,
	25	int avg_lum,
	26	int desired_avg_lum,
	27	int deadzone,
	28	int gain_knee,
	29	int exposure_knee)
	30	{
	31	s32 gain, orig_gain, exposure, orig_exposure;
	32	int i, steps, retval = 0;
	33
	34	if (v4l2_ctrl_g_ctrl(gspca_dev->autogain) == 0)
4a3fad70	35	return 0;
8cd05842 HG	36
	37	orig_gain = gain = v4l2_ctrl_g_ctrl(gspca_dev->gain);
	38	orig_exposure = exposure = v4l2_ctrl_g_ctrl(gspca_dev->exposure);
	39
	40	/* If we are of a multiple of deadzone, do multiple steps to reach the
	41	desired lumination fast (with the risc of a slight overshoot) */
	42	steps = abs(desired_avg_lum - avg_lum) / deadzone;
	43
37d5efb0 JP	44	gspca_dbg(gspca_dev, D_FRAM, "autogain: lum: %d, desired: %d, steps: %d\n",
37d5efb0 JP	45	avg_lum, desired_avg_lum, steps);
8cd05842 HG	46
	47	for (i = 0; i < steps; i++) {
	48	if (avg_lum > desired_avg_lum) {
	49	if (gain > gain_knee)
	50	gain--;
	51	else if (exposure > exposure_knee)
	52	exposure--;
	53	else if (gain > gspca_dev->gain->default_value)
	54	gain--;
	55	else if (exposure > gspca_dev->exposure->minimum)
	56	exposure--;
	57	else if (gain > gspca_dev->gain->minimum)
	58	gain--;
	59	else
	60	break;
	61	} else {
	62	if (gain < gspca_dev->gain->default_value)
	63	gain++;
	64	else if (exposure < exposure_knee)
	65	exposure++;
	66	else if (gain < gain_knee)
	67	gain++;
	68	else if (exposure < gspca_dev->exposure->maximum)
	69	exposure++;
	70	else if (gain < gspca_dev->gain->maximum)
	71	gain++;
	72	else
	73	break;
	74	}
	75	}
	76
	77	if (gain != orig_gain) {
4a3fad70	78	v4l2_ctrl_s_ctrl(gspca_dev->gain, gain);
8cd05842 HG	79	retval = 1;
	80	}
	81	if (exposure != orig_exposure) {
4a3fad70	82	v4l2_ctrl_s_ctrl(gspca_dev->exposure, exposure);
8cd05842 HG	83	retval = 1;
	84	}
	85
	86	if (retval)
37d5efb0 JP	87	gspca_dbg(gspca_dev, D_FRAM, "autogain: changed gain: %d, expo: %d\n",
37d5efb0 JP	88	gain, exposure);
8cd05842 HG	89	return retval;
	90	}
	91	EXPORT_SYMBOL(gspca_expo_autogain);
	92
	93	/* Autogain + exposure algorithm for cameras with a coarse exposure control
	94	(usually this means we can only control the clockdiv to change exposure)
	95	As changing the clockdiv so that the fps drops from 30 to 15 fps for
	96	example, will lead to a huge exposure change (it effectively doubles),
	97	this algorithm normally tries to only adjust the gain (between 40 and
	98	80 %) and if that does not help, only then changes exposure. This leads
	99	to a much more stable image then using the knee algorithm which at
	100	certain points of the knee graph will only try to adjust exposure,
	101	which leads to oscilating as one exposure step is huge.
	102
	103	Returns 0 if no changes were made, 1 if the gain and or exposure settings
	104	where changed. */
	105	int gspca_coarse_grained_expo_autogain(
	106	struct gspca_dev *gspca_dev,
	107	int avg_lum,
	108	int desired_avg_lum,
	109	int deadzone)
	110	{
	111	s32 gain_low, gain_high, gain, orig_gain, exposure, orig_exposure;
	112	int steps, retval = 0;
	113
	114	if (v4l2_ctrl_g_ctrl(gspca_dev->autogain) == 0)
4a3fad70	115	return 0;
8cd05842 HG	116
	117	orig_gain = gain = v4l2_ctrl_g_ctrl(gspca_dev->gain);
	118	orig_exposure = exposure = v4l2_ctrl_g_ctrl(gspca_dev->exposure);
	119
0d5e8c43	120	gain_low = (s32)(gspca_dev->gain->maximum - gspca_dev->gain->minimum) /
8cd05842	121	5 * 2 + gspca_dev->gain->minimum;
0d5e8c43	122	gain_high = (s32)(gspca_dev->gain->maximum - gspca_dev->gain->minimum) /
8cd05842 HG	123	5 * 4 + gspca_dev->gain->minimum;
	124
	125	/* If we are of a multiple of deadzone, do multiple steps to reach the
	126	desired lumination fast (with the risc of a slight overshoot) */
	127	steps = (desired_avg_lum - avg_lum) / deadzone;
	128
37d5efb0 JP	129	gspca_dbg(gspca_dev, D_FRAM, "autogain: lum: %d, desired: %d, steps: %d\n",
37d5efb0 JP	130	avg_lum, desired_avg_lum, steps);
8cd05842 HG	131
	132	if ((gain + steps) > gain_high &&
	133	exposure < gspca_dev->exposure->maximum) {
	134	gain = gain_high;
	135	gspca_dev->exp_too_low_cnt++;
	136	gspca_dev->exp_too_high_cnt = 0;
	137	} else if ((gain + steps) < gain_low &&
	138	exposure > gspca_dev->exposure->minimum) {
	139	gain = gain_low;
	140	gspca_dev->exp_too_high_cnt++;
	141	gspca_dev->exp_too_low_cnt = 0;
	142	} else {
	143	gain += steps;
	144	if (gain > gspca_dev->gain->maximum)
	145	gain = gspca_dev->gain->maximum;
	146	else if (gain < gspca_dev->gain->minimum)
	147	gain = gspca_dev->gain->minimum;
	148	gspca_dev->exp_too_high_cnt = 0;
	149	gspca_dev->exp_too_low_cnt = 0;
	150	}
	151
	152	if (gspca_dev->exp_too_high_cnt > 3) {
	153	exposure--;
	154	gspca_dev->exp_too_high_cnt = 0;
	155	} else if (gspca_dev->exp_too_low_cnt > 3) {
	156	exposure++;
	157	gspca_dev->exp_too_low_cnt = 0;
	158	}
	159
	160	if (gain != orig_gain) {
4a3fad70	161	v4l2_ctrl_s_ctrl(gspca_dev->gain, gain);
8cd05842 HG	162	retval = 1;
	163	}
	164	if (exposure != orig_exposure) {
4a3fad70	165	v4l2_ctrl_s_ctrl(gspca_dev->exposure, exposure);
8cd05842 HG	166	retval = 1;
	167	}
	168
	169	if (retval)
37d5efb0 JP	170	gspca_dbg(gspca_dev, D_FRAM, "autogain: changed gain: %d, expo: %d\n",
37d5efb0 JP	171	gain, exposure);
8cd05842 HG	172	return retval;
	173	}
	174	EXPORT_SYMBOL(gspca_coarse_grained_expo_autogain);