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 = (s32)(gspca_dev->gain->maximum - gspca_dev->gain->minimum) / 125 5 * 2 + gspca_dev->gain->minimum; 126 gain_high = (s32)(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); 179