1 /* 2 * handler_interface.cpp - handler interface 3 * 4 * Copyright (c) 2014-2015 Intel Corporation 5 * 6 * Licensed under the Apache License, Version 2.0 (the "License"); 7 * you may not use this file except in compliance with the License. 8 * You may obtain a copy of the License at 9 * 10 * http://www.apache.org/licenses/LICENSE-2.0 11 * 12 * Unless required by applicable law or agreed to in writing, software 13 * distributed under the License is distributed on an "AS IS" BASIS, 14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 * See the License for the specific language governing permissions and 16 * limitations under the License. 17 * 18 * Author: Wind Yuan <feng.yuan (at) intel.com> 19 */ 20 21 #include "handler_interface.h" 22 23 namespace XCam { 24 25 AeHandler::AeHandler() 26 { 27 reset_parameters (); 28 } 29 30 void 31 AeHandler::reset_parameters () 32 { 33 // in case missing any parameters 34 xcam_mem_clear (_params); 35 36 _params.mode = XCAM_AE_MODE_AUTO; 37 _params.metering_mode = XCAM_AE_METERING_MODE_AUTO; 38 _params.flicker_mode = XCAM_AE_FLICKER_MODE_AUTO; 39 _params.speed = 1.0; 40 _params.exposure_time_min = UINT64_C(0); 41 _params.exposure_time_max = UINT64_C(0); 42 _params.max_analog_gain = 0.0; 43 _params.manual_exposure_time = UINT64_C (0); 44 _params.manual_analog_gain = 0.0; 45 _params.aperture_fn = 0.0; 46 _params.ev_shift = 0.0; 47 48 _params.window.x_start = 0; 49 _params.window.y_start = 0; 50 _params.window.x_end = 0; 51 _params.window.y_end = 0; 52 _params.window.weight = 0; 53 54 xcam_mem_clear (_params.window_list); 55 } 56 57 bool 58 AeHandler::set_mode (XCamAeMode mode) 59 { 60 AnalyzerHandler::HandlerLock lock(this); 61 _params.mode = mode; 62 63 XCAM_LOG_DEBUG ("ae set mode [%d]", mode); 64 return true; 65 } 66 67 bool 68 AeHandler::set_metering_mode (XCamAeMeteringMode mode) 69 { 70 AnalyzerHandler::HandlerLock lock(this); 71 _params.metering_mode = mode; 72 73 XCAM_LOG_DEBUG ("ae set metering mode [%d]", mode); 74 return true; 75 } 76 77 bool 78 AeHandler::set_window (XCam3AWindow *window) 79 { 80 AnalyzerHandler::HandlerLock lock(this); 81 _params.window = *window; 82 83 XCAM_LOG_DEBUG ("ae set metering mode window [x:%d, y:%d, x_end:%d, y_end:%d, weight:%d]", 84 window->x_start, 85 window->y_start, 86 window->x_end, 87 window->y_end, 88 window->weight); 89 return true; 90 } 91 92 bool 93 AeHandler::set_window (XCam3AWindow *window, uint8_t count) 94 { 95 if (0 == count) { 96 XCAM_LOG_WARNING ("invalid input parameter, window count = %d, reset to default value", count); 97 XCam3AWindow defaultWindow = {0, 0, 1000, 1000, 15}; 98 set_window(&defaultWindow); 99 _params.window_list[0] = defaultWindow; 100 return true; 101 } 102 103 if (XCAM_AE_MAX_METERING_WINDOW_COUNT < count) { 104 XCAM_LOG_WARNING ("invalid input parameter, window count = %d, reset count to maximum", count); 105 count = XCAM_AE_MAX_METERING_WINDOW_COUNT; 106 } 107 108 AnalyzerHandler::HandlerLock lock(this); 109 110 _params.window = *window; 111 112 for (int i = 0; i < count; i++) { 113 XCAM_LOG_DEBUG ("window start point(%d, %d), end point(%d, %d), weight = %d", 114 window[i].x_start, window[i].y_start, window[i].x_end, window[i].y_end, window[i].weight); 115 116 _params.window_list[i] = window[i]; 117 if (_params.window.weight < window[i].weight) { 118 _params.window.weight = window[i].weight; 119 _params.window.x_start = window[i].x_start; 120 _params.window.y_start = window[i].y_start; 121 _params.window.x_end = window[i].x_end; 122 _params.window.y_end = window[i].y_end; 123 } 124 } 125 126 XCAM_LOG_DEBUG ("ae set metering mode window [x:%d, y:%d, x_end:%d, y_end:%d, weight:%d]", 127 _params.window.x_start, 128 _params.window.y_start, 129 _params.window.x_end, 130 _params.window.y_end, 131 _params.window.weight); 132 133 return true; 134 } 135 136 bool 137 AeHandler::set_ev_shift (double ev_shift) 138 { 139 AnalyzerHandler::HandlerLock lock(this); 140 _params.ev_shift = ev_shift; 141 142 XCAM_LOG_DEBUG ("ae set ev shift:%.03f", ev_shift); 143 return true; 144 } 145 146 bool 147 AeHandler::set_speed (double speed) 148 { 149 AnalyzerHandler::HandlerLock lock(this); 150 _params.speed = speed; 151 152 XCAM_LOG_DEBUG ("ae set speed:%.03f", speed); 153 return true; 154 } 155 156 bool 157 AeHandler::set_flicker_mode (XCamFlickerMode flicker) 158 { 159 AnalyzerHandler::HandlerLock lock(this); 160 _params.flicker_mode = flicker; 161 162 XCAM_LOG_DEBUG ("ae set flicker:%d", flicker); 163 return true; 164 } 165 166 XCamFlickerMode 167 AeHandler::get_flicker_mode () 168 { 169 AnalyzerHandler::HandlerLock lock(this); 170 return _params.flicker_mode; 171 } 172 173 int64_t 174 AeHandler::get_current_exposure_time () 175 { 176 AnalyzerHandler::HandlerLock lock(this); 177 if (_params.mode == XCAM_AE_MODE_MANUAL) 178 return _params.manual_exposure_time; 179 return INT64_C(-1); 180 } 181 182 double 183 AeHandler::get_current_analog_gain () 184 { 185 AnalyzerHandler::HandlerLock lock(this); 186 if (_params.mode == XCAM_AE_MODE_MANUAL) 187 return _params.manual_analog_gain; 188 return 0.0; 189 } 190 191 bool 192 AeHandler::set_manual_exposure_time (int64_t time_in_us) 193 { 194 AnalyzerHandler::HandlerLock lock(this); 195 _params.manual_exposure_time = time_in_us; 196 197 XCAM_LOG_DEBUG ("ae set manual exposure time: %" PRId64 "us", time_in_us); 198 return true; 199 } 200 201 bool 202 AeHandler::set_manual_analog_gain (double gain) 203 { 204 AnalyzerHandler::HandlerLock lock(this); 205 _params.manual_analog_gain = gain; 206 207 XCAM_LOG_DEBUG ("ae set manual analog gain: %.03f", gain); 208 return true; 209 } 210 211 bool 212 AeHandler::set_aperture (double fn) 213 { 214 AnalyzerHandler::HandlerLock lock(this); 215 _params.aperture_fn = fn; 216 217 XCAM_LOG_DEBUG ("ae set aperture fn: %.03f", fn); 218 return true; 219 } 220 221 bool 222 AeHandler::set_max_analog_gain (double max_gain) 223 { 224 AnalyzerHandler::HandlerLock lock(this); 225 _params.max_analog_gain = max_gain; 226 227 XCAM_LOG_DEBUG ("ae set max analog_gain: %.03f", max_gain); 228 return true; 229 } 230 231 double AeHandler::get_max_analog_gain () 232 { 233 AnalyzerHandler::HandlerLock lock(this); 234 return _params.max_analog_gain; 235 } 236 237 bool AeHandler::set_exposure_time_range (int64_t min_time_in_us, int64_t max_time_in_us) 238 { 239 AnalyzerHandler::HandlerLock lock(this); 240 _params.exposure_time_min = min_time_in_us; 241 _params.exposure_time_max = max_time_in_us; 242 243 XCAM_LOG_DEBUG ("ae set exposrue range[%" PRId64 "us, %" PRId64 "us]", min_time_in_us, max_time_in_us); 244 return true; 245 } 246 247 bool 248 AeHandler::update_parameters (const XCamAeParam ¶ms) 249 { 250 { 251 AnalyzerHandler::HandlerLock lock (this); 252 _params = params; 253 } 254 XCAM_LOG_DEBUG ("ae parameters updated"); 255 return true; 256 } 257 258 bool 259 AeHandler::get_exposure_time_range (int64_t *min_time_in_us, int64_t *max_time_in_us) 260 { 261 XCAM_ASSERT (min_time_in_us && max_time_in_us); 262 263 AnalyzerHandler::HandlerLock lock(this); 264 *min_time_in_us = _params.exposure_time_min; 265 *max_time_in_us = _params.exposure_time_max; 266 267 return true; 268 } 269 270 AwbHandler::AwbHandler() 271 { 272 reset_parameters (); 273 } 274 275 void 276 AwbHandler::reset_parameters () 277 { 278 xcam_mem_clear (_params); 279 _params.mode = XCAM_AWB_MODE_AUTO; 280 _params.speed = 1.0; 281 _params.cct_min = 0; 282 _params.cct_max = 0; 283 _params.gr_gain = 0.0; 284 _params.r_gain = 0.0; 285 _params.b_gain = 0.0; 286 _params.gb_gain = 0.0; 287 288 _params.window.x_start = 0; 289 _params.window.y_start = 0; 290 _params.window.x_end = 0; 291 _params.window.y_end = 0; 292 _params.window.weight = 0; 293 } 294 295 bool 296 AwbHandler::set_mode (XCamAwbMode mode) 297 { 298 AnalyzerHandler::HandlerLock lock(this); 299 _params.mode = mode; 300 301 XCAM_LOG_DEBUG ("awb set mode [%d]", mode); 302 return true; 303 } 304 305 bool 306 AwbHandler::set_speed (double speed) 307 { 308 XCAM_FAIL_RETURN ( 309 ERROR, 310 (0.0 < speed) && (speed <= 1.0), 311 false, 312 "awb speed(%f) is out of range, suggest (0.0, 1.0]", speed); 313 314 AnalyzerHandler::HandlerLock lock(this); 315 _params.speed = speed; 316 317 XCAM_LOG_DEBUG ("awb set speed [%f]", speed); 318 return true; 319 } 320 321 bool 322 AwbHandler::set_color_temperature_range (uint32_t cct_min, uint32_t cct_max) 323 { 324 XCAM_FAIL_RETURN ( 325 ERROR, 326 (cct_min <= cct_max), 327 false, 328 "awb set wrong cct(%u, %u) parameters", cct_min, cct_max); 329 330 AnalyzerHandler::HandlerLock lock(this); 331 _params.cct_min = cct_min; 332 _params.cct_max = cct_max; 333 334 XCAM_LOG_DEBUG ("awb set cct range [%u, %u]", cct_min, cct_max); 335 return true; 336 } 337 338 bool 339 AwbHandler::set_manual_gain (double gr, double r, double b, double gb) 340 { 341 XCAM_FAIL_RETURN ( 342 ERROR, 343 gr >= 0.0 && r >= 0.0 && b >= 0.0 && gb >= 0.0, 344 false, 345 "awb manual gain value must >= 0.0"); 346 347 AnalyzerHandler::HandlerLock lock(this); 348 _params.gr_gain = gr; 349 _params.r_gain = r; 350 _params.b_gain = b; 351 _params.gb_gain = gb; 352 XCAM_LOG_DEBUG ("awb set manual gain value(gr:%.03f, r:%.03f, b:%.03f, gb:%.03f)", gr, r, b, gb); 353 return true; 354 } 355 356 bool 357 AwbHandler::update_parameters (const XCamAwbParam ¶ms) 358 { 359 { 360 AnalyzerHandler::HandlerLock lock (this); 361 _params = params; 362 } 363 XCAM_LOG_DEBUG ("awb parameters updated"); 364 return true; 365 } 366 367 uint32_t 368 AwbHandler::get_current_estimate_cct () 369 { 370 AnalyzerHandler::HandlerLock lock(this); 371 if (_params.mode == XCAM_AWB_MODE_MANUAL) 372 return (_params.cct_max + _params.cct_min) / 2; 373 return 0.0; 374 } 375 376 bool 377 AfHandler::update_parameters (const XCamAfParam ¶ms) 378 { 379 { 380 AnalyzerHandler::HandlerLock lock (this); 381 _params = params; 382 } 383 XCAM_LOG_DEBUG ("af parameters updated"); 384 return true; 385 } 386 387 CommonHandler::CommonHandler() 388 { 389 reset_parameters (); 390 } 391 392 void 393 CommonHandler::reset_parameters () 394 { 395 xcam_mem_clear (_params); 396 397 _params.is_manual_gamma = false; 398 _params.nr_level = 0.0; 399 _params.tnr_level = 0.0; 400 _params.brightness = 0.0; 401 _params.contrast = 0.0; 402 _params.hue = 0.0; 403 _params.saturation = 0.0; 404 _params.sharpness = 0.0; 405 _params.enable_dvs = false; 406 _params.enable_gbce = false; 407 _params.enable_night_mode = false; 408 } 409 410 bool CommonHandler::set_dvs (bool enable) 411 { 412 AnalyzerHandler::HandlerLock lock(this); 413 _params.enable_dvs = enable; 414 415 XCAM_LOG_DEBUG ("common 3A enable dvs:%s", XCAM_BOOL2STR(enable)); 416 return true; 417 } 418 419 bool 420 CommonHandler::set_gbce (bool enable) 421 { 422 AnalyzerHandler::HandlerLock lock(this); 423 _params.enable_gbce = enable; 424 425 XCAM_LOG_DEBUG ("common 3A enable gbce:%s", XCAM_BOOL2STR(enable)); 426 return true; 427 } 428 429 bool 430 CommonHandler::set_night_mode (bool enable) 431 { 432 AnalyzerHandler::HandlerLock lock(this); 433 _params.enable_night_mode = enable; 434 435 XCAM_LOG_DEBUG ("common 3A enable night mode:%s", XCAM_BOOL2STR(enable)); 436 return true; 437 } 438 439 /* Picture quality */ 440 bool 441 CommonHandler::set_noise_reduction_level (double level) 442 { 443 XCAM_FAIL_RETURN ( 444 ERROR, 445 level >= -1.0 && level < 1.0, 446 false, 447 "set NR levlel(%.03f) out of range[-1.0, 1.0]", level); 448 449 AnalyzerHandler::HandlerLock lock(this); 450 _params.nr_level = level; 451 452 XCAM_LOG_DEBUG ("common 3A set NR level:%.03f", level); 453 return true; 454 } 455 456 bool 457 CommonHandler::set_temporal_noise_reduction_level (double level) 458 { 459 XCAM_FAIL_RETURN ( 460 ERROR, 461 level >= -1.0 && level < 1.0, 462 false, 463 "set TNR levlel(%.03f) out of range[-1.0, 1.0]", level); 464 465 AnalyzerHandler::HandlerLock lock(this); 466 _params.tnr_level = level; 467 468 XCAM_LOG_DEBUG ("common 3A set TNR level:%.03f", level); 469 return true; 470 } 471 472 bool 473 CommonHandler::set_manual_brightness (double level) 474 { 475 XCAM_FAIL_RETURN ( 476 ERROR, 477 level >= -1.0 && level < 1.0, 478 false, 479 "set brightness levlel(%.03f) out of range[-1.0, 1.0]", level); 480 481 AnalyzerHandler::HandlerLock lock(this); 482 _params.brightness = level; 483 484 XCAM_LOG_DEBUG ("common 3A set brightness level:%.03f", level); 485 return true; 486 } 487 488 bool CommonHandler::set_manual_contrast (double level) 489 { 490 XCAM_FAIL_RETURN ( 491 ERROR, 492 level >= -1.0 && level < 1.0, 493 false, 494 "set contrast levlel(%.03f) out of range[-1.0, 1.0]", level); 495 496 AnalyzerHandler::HandlerLock lock(this); 497 _params.contrast = level; 498 499 XCAM_LOG_DEBUG ("common 3A set contrast level:%.03f", level); 500 return true; 501 } 502 503 bool CommonHandler::set_manual_hue (double level) 504 { 505 XCAM_FAIL_RETURN ( 506 ERROR, 507 level >= -1.0 && level < 1.0, 508 false, 509 "set hue levlel(%.03f) out of range[-1.0, 1.0]", level); 510 511 AnalyzerHandler::HandlerLock lock(this); 512 _params.hue = level; 513 514 XCAM_LOG_DEBUG ("common 3A set hue level:%.03f", level); 515 return true; 516 } 517 518 bool 519 CommonHandler::set_manual_saturation (double level) 520 { 521 XCAM_FAIL_RETURN ( 522 ERROR, 523 level >= -1.0 && level < 1.0, 524 false, 525 "set saturation levlel(%.03f) out of range[-1.0, 1.0]", level); 526 527 AnalyzerHandler::HandlerLock lock(this); 528 _params.saturation = level; 529 530 XCAM_LOG_DEBUG ("common 3A set saturation level:%.03f", level); 531 return true; 532 } 533 534 bool CommonHandler::set_manual_sharpness (double level) 535 { 536 XCAM_FAIL_RETURN ( 537 ERROR, 538 level >= -1.0 && level < 1.0, 539 false, 540 "set sharpness levlel(%.03f) out of range[-1.0, 1.0]", level); 541 542 AnalyzerHandler::HandlerLock lock(this); 543 _params.sharpness = level; 544 545 XCAM_LOG_DEBUG ("common 3A set sharpness level:%.03f", level); 546 return true; 547 } 548 549 bool 550 CommonHandler::set_gamma_table (double *r_table, double *g_table, double *b_table) 551 { 552 AnalyzerHandler::HandlerLock lock(this); 553 if (!r_table && ! g_table && !b_table) { 554 _params.is_manual_gamma = false; 555 XCAM_LOG_DEBUG ("common 3A disabled gamma"); 556 return true; 557 } 558 559 if (!r_table || !g_table || !b_table) { 560 XCAM_LOG_ERROR ("common 3A gamma table parameters wrong"); 561 return false; 562 } 563 564 for (uint32_t i = 0; i < XCAM_GAMMA_TABLE_SIZE; ++i) { 565 _params.r_gamma [i] = r_table [i]; 566 _params.g_gamma [i] = g_table [i]; 567 _params.b_gamma [i] = b_table [i]; 568 } 569 _params.is_manual_gamma = true; 570 571 XCAM_LOG_DEBUG ("common 3A enabled RGB gamma"); 572 return true; 573 } 574 575 bool 576 CommonHandler::set_color_effect (XCamColorEffect effect) 577 { 578 // TODO validate the input 579 580 AnalyzerHandler::HandlerLock lock(this); 581 582 _params.color_effect = effect; 583 584 XCAM_LOG_DEBUG ("common 3A set color effect"); 585 return true; 586 } 587 588 bool 589 CommonHandler::update_parameters (const XCamCommonParam ¶ms) 590 { 591 { 592 AnalyzerHandler::HandlerLock lock (this); 593 _params = params; 594 } 595 XCAM_LOG_DEBUG ("common parameters updated"); 596 return true; 597 } 598 599 }; 600
