gst-libs/atomisphal/gstv4l2mfldadvci.c

   1 /* GStreamer MFLD ADVIC API
   2  * Copyright (C) 2010 Intel Corporation <www.intel.com>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include "gstv4l2mfldadvci.h"
  21 #include <linux/videodev2.h>
  22 #include <math.h>
  23 #include <sys/ioctl.h>
  24 #include <gst/gst.h>
  25 #include "ci_adv_pub.h"
  26
  27 void cam_lib_3a_dbg(const char *format, ...);
  28
  29 int __android_log_print(int prio, const char *tag, const char *fmt, ...)
  30 {
  31  return 0;
  32 }
  33
  34 /* for debug message and error message output
  35  *
  36  */
  37 static bool use_3A_debug = FALSE;
  38
  39 void
  40 cam_lib_3a_dbg (const char *format, ...)
  41 {
  42   va_list ap;
  43   if (use_3A_debug) {
  44     va_start (ap, format);
  45     vfprintf (stdout, format, ap);
  46     va_end (ap);
  47   }
  48 }
  49
  50 static void wrapper_default_void (void)
  51 {
  52   return;
  53 }
  54
  55 static void wrapper_default_int (int a)
  56 {
  57   return;
  58 }
  59
  60 static int wrapper_default_int_void (void)
  61 {
  62   return 0;
  63 }
  64
  65 static void wrapper_default_ae (void)
  66 {
  67   return;
  68 }
  69
  70 static void wrapper_default_init(void)
  71 {
  72 }
  73
  74 static void wrapper_default_uninit(void)
  75 {
  76 }
  77
  78 static void
  79 wrapper_default_dis_process (struct atomisp_dis_statistics *stats,
  80                      struct atomisp_dis_vector *motion_vector)
  81 {
  82 }
  83
  84 static void
  85 wrapper_default_dis_calc_still (struct atomisp_dis_vector * vector, int frame_number)
  86 {
  87 }
  88
  89 static void
  90 wrapper_default_do_redeye_removal (ia_frame *ia_frame)
  91 {
  92 }
  93
  94 static void
  95 wrapper_default_still_compose (ia_frame *com_buf,
  96                      ia_frame bufs[],
  97                      int frame_dis,
  98                      struct atomisp_dis_vector vectors[])
  99 {
 100 }
 101
 102 static void
 103 wrapper_default_AeSetFlickerMode(ia_3a_ae_flicker_mode mode)
 104 {
 105 }
 106
 107 static void
 108 wrapper_default_AeGetFlickerMode(ia_3a_ae_flicker_mode *mode)
 109 {
 110 }
 111
 112 static void
 113 wrapper_default_AeSetExposureProgram(ia_3a_ae_exposure_program program)
 114 {
 115 }
 116
 117 static void
 118 wrapper_default_AeGetExposureProgram(ia_3a_ae_exposure_program *program)
 119 {
 120 }
 121
 122 static void wrapper_default_AfSetMode(ia_3a_af_mode mode)
 123 {
 124 }
 125
 126 static void wrapper_default_AfGetMode(ia_3a_af_mode *mode)
 127 {
 128 }
 129
 130 static void wrapper_default_AfSetRange(ia_3a_af_range range)
 131 {
 132 }
 133
 134 static void wrapper_default_AfGetRange(ia_3a_af_range *range)
 135 {
 136 }
 137
 138 static void wrapper_default_AwbSetMode(ia_3a_awb_mode mode)
 139 {
 140 }
 141
 142 static void wrapper_default_AwbGetMode(ia_3a_awb_mode *mode)
 143 {
 144 }
 145
 146 static void wrapper_default_AwbSetLightSource(ia_3a_awb_light_source ls)
 147 {
 148 }
 149
 150 static void
 151 wrapper_default_AwbGetLightSource(ia_3a_awb_light_source *ls)
 152 {
 153 }
 154
 155 static ci_adv_Err
 156 wrapper_default_int_int (int i)
 157 {
 158 }
 159
 160 static ci_adv_Err
 161 wrapper_default_intp (int *p)
 162 {
 163 }
 164
 165 static int
 166 wrapper_default_isp_set_fd (int fd, const char *sensor_id)
 167 {
 168   return SENSOR_TYPE_SOC;
 169 }
 170
 171 static void
 172 wrapper_default_switch_mode (ia_3a_isp_mode mode, float frame_rate)
 173 {
 174 }
 175
 176 static ci_adv_Err
 177 wrapper_default_AeGetWindowsNum(int *num)
 178 {
 179   return ci_adv_Success;
 180 }
 181
 182 static void wrapper_default_AwbVersion(int * major, int * minor)
 183 {
 184 }
 185
 186 static void wrapper_default_AeVersion(int * major, int * minor)
 187 {
 188 }
 189
 190 static void wrapper_default_AfVersion(int * major, int * minor)
 191 {
 192 }
 193
 194 static void wrapper_default_AfGetStillAfStatus(ia_3a_af_status *status)
 195 {
 196 }
 197
 198 static bool wrapper_default_af_is_complete(void)
 199 {
 200   return TRUE;
 201 }
 202
 203 static void wrapper_default_RerVersion(int * major, int * minor)
 204 {
 205   return;
 206 }
 207
 208 static ci_adv_Err wrapper_default_AeGetManualShutter(int *time)
 209 {
 210   return ci_adv_Success;
 211 }
 212
 213 static void
 214 wrapper_default_Awbdata(unsigned * num_p, unsigned * avg_r,
 215                        unsigned * avg_gr,
 216                         unsigned * avg_b, unsigned * avg_gb)
 217 {
 218   return;
 219 }
 220
 221 static void wrapper_default_AeGetManualAperture(int *aperture)
 222 {
 223 }
 224
 225 static void wrapper_default_AeGetFlashMode(ia_3a_ae_flash_mode *mode)
 226 {
 227 }
 228
 229 static void wrapper_default_AeSetFlashMode(ia_3a_ae_flash_mode mode)
 230 {
 231 }
 232
 233 static void wrapper_default_AwbGetManualColorTemperature(int *ctemp)
 234 {
 235 }
 236
 237 static void
 238 wrapper_default_Awbmatrix(int msqWbGain[3], int msqCcMtrx[9], unsigned short * shift)
 239 {
 240 }
 241
 242 static void wrapper_default_GetGridInfo(void * grid_info)
 243 {
 244 }
 245
 246 static void
 247 wrapper_default_AeSetMeteringMode(ia_3a_ae_metering_mode mode)
 248 {
 249 }
 250
 251 static void
 252 wrapper_default_AeGetMeteringMode(ia_3a_ae_metering_mode *mode)
 253 {
 254 }
 255
 256 static void
 257 wrapper_default_AfSetMeteringMode(ia_3a_af_metering_mode mode)
 258 {
 259 }
 260
 261 static void
 262 wrapper_default_AfGetMeteringMode(ia_3a_af_metering_mode *mode)
 263 {
 264 }
 265
 266 static void
 267 wrapper_default_Ae_Af_GetWindow(ia_3a_window *window)
 268 {
 269
 270 }
 271
 272 static void
 273 wrapper_default_Ae_Af_SetWindow( ia_3a_window *window)
 274 {
 275 }
 276 static void wrapper_default_af_start( )
 277 {
 278 }
 279
 280 static void wrapper_default_af_stop( )
 281 {
 282 }
 283 static void wrapper_default_ae_calc_for_flash( )
 284 {
 285 }
 286 static void wrapper_default_calc_without_flash( )
 287 {
 288 }
 289
 290 static void wrapper_default_calc_with_flash( )
 291 {
 292 }
 293
 294 static void wrapper_default_AeAfAwb_process( struct timeval *frame_timestamp)
 295 {
 296 }
 297 static void wrapper_default_get_statistics( )
 298 {
 299 }
 300
 301 static void wrapper_default_awb_apply_results( )
 302 {
 303 }
 304 static void wrapper_default_AwbSetImageEffect(ia_3a_image_effect effect)
 305 {
 306 }
 307
 308 static void
 309 wrapper_default_AwbGetImageEffect(ia_3a_image_effect *effect)
 310 {
 311 }
 312
 313 static void
 314 wrapper_default_is_flash_needed(bool *useflash)
 315 {
 316
 317 }
 318
 319 static ci_adv_Err wrapper_default_AeSetManualIso(int sensitivity)
 320 {
 321   return ci_adv_success;
 322 }
 323
 324 static ci_adv_Err wrapper_default_AeGetManualIso(int *sensitivity)
 325 {
 326   return ci_adv_success;
 327 }
 328
 329 static void
 330 wrapper_default_GetMakerNote(ia_3a_mknote_mode mknMode, ia_3a_mknote *note)
 331 {
 332 }
 333
 334 static void
 335 wrapper_default_AddMakerNoteRecord(ia_3a_mknote_field_type mkn_format_id,
 336                                    ia_3a_mknote_field_name mkn_name_id,
 337                                    const void *record,
 338                                    unsigned short record_size)
 339 {
 340
 341 }
 342
 343 static void
 344 wrapper_default_PutMakerNote(ia_3a_mknote *mknData)
 345 {
 346
 347 }
 348
 349 static void
 350 wrapper_default_ResetMakerNote(void)
 351 {
 352 }
 353
 354 /*------------------------------------------------------------------------------------------------*/
 355 #ifdef USE_STATIC_3A
 356 static void
 357 lib_3a_void (void)
 358 {
 359   return;
 360 }
 361
 362 static void
 363 lib_3a_int (int a)
 364 {
 365   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 366   return;
 367 }
 368
 369 static int
 370 lib_3a_int_void (void)
 371 {
 372   return 0;
 373 }
 374
 375 static void
 376 lib_3a_ae (void)
 377 {
 378   return;
 379 }
 380
 381 static void
 382 lib_3a_init(void)
 383 {
 384   const char *env;
 385   use_3A_debug= ((env = getenv ("LIBMFLDCAM_DEBUG")) && strstr (env, "verbose"));
 386   cam_lib_3a_dbg("%s:%d", __func__, __LINE__);
 387 }
 388
 389 static void
 390 lib_3a_uninit(void)
 391 {
 392   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 393   ci_adv_uninit();
 394 }
 395
 396 static void
 397 lib_3a_dis_process (struct atomisp_dis_statistics *stats,
 398                      struct atomisp_dis_vector *motion_vector)
 399 {
 400   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 401   return;
 402 }
 403
 404 static void
 405 lib_3a_dis_calc_still (struct atomisp_dis_vector * vector, int frame_number)
 406 {
 407   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 408   return;
 409 }
 410
 411 static void
 412 lib_3a_do_redeye_removal (ia_frame *ia_frame)
 413 {
 414   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 415 }
 416
 417 static void
 418 lib_3a_still_compose (ia_frame *com_buf,
 419                      ia_frame bufs[],
 420                      int frame_dis,
 421                      struct atomisp_dis_vector vectors[])
 422 {
 423   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 424   return;
 425 }
 426
 427 static void
 428 lib_3a_AeSetFlickerMode(ia_3a_ae_flicker_mode mode)
 429 {
 430   cam_lib_3a_dbg("%s:%d mode:%d\n", __func__, __LINE__,mode);
 431   ci_adv_ae_set_flicker_mode(mode);
 432 }
 433
 434 static void
 435 lib_3a_AeGetFlickerMode(ia_3a_ae_flicker_mode *mode)
 436 {
 437   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 438   *mode= ia_3a_ae_get_flicker_mode();
 439 }
 440
 441 static void
 442 lib_3a_AeSetExposureProgram(ia_3a_ae_exposure_program program)
 443 {
 444   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 445   ci_adv_ae_set_exposure_program(program);
 446 }
 447
 448 static void
 449 lib_3a_AeGetExposureProgram(ia_3a_ae_exposure_program *program)
 450 {
 451   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 452   ci_adv_ae_get_exposure_program(program);
 453 }
 454
 455 static void
 456 lib_3a_AfSetMode(ia_3a_af_mode mode)
 457 {
 458   cam_lib_3a_dbg("%s:%d mode:%d\n", __func__, __LINE__,mode);
 459   ci_adv_af_set_mode(mode);
 460 }
 461
 462 static void
 463 lib_3a_AfGetMode(ia_3a_af_mode *mode)
 464 {
 465   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 466   *mode = ia_3a_af_get_focus_mode();
 467 }
 468
 469 static void
 470 lib_3a_AfSetRange(ia_3a_af_range range)
 471 {
 472   cam_lib_3a_dbg ("%s:%d\n", __func__, __LINE__);
 473   ci_adv_af_set_range(range);
 474 }
 475
 476 static void
 477 lib_3a_AfGetRange(ia_3a_af_range *range)
 478 {
 479   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 480   *range = ia_3a_af_get_focus_range();
 481 }
 482
 483 static void
 484 lib_3a_AwbSetMode(ia_3a_awb_mode mode)
 485 {
 486   cam_lib_3a_dbg("%s:%d mode:%d\n" , __func__, __LINE__,mode);
 487   ci_adv_awb_set_mode(mode);
 488 }
 489
 490 static void
 491 lib_3a_AwbGetMode(ia_3a_awb_mode *mode)
 492 {
 493   *mode = ia_3a_awb_get_mode();
 494 }
 495
 496 static void
 497 lib_3a_AwbSetLightSource(ia_3a_awb_light_source ls)
 498 {
 499   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 500   ci_adv_awb_set_light_source(ls);
 501 }
 502
 503 static void
 504 lib_3a_AwbGetLightSource(ia_3a_awb_light_source *ls)
 505 {
 506   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 507   *ls = ia_3a_awb_get_light_source();
 508 }
 509
 510 static ci_adv_Err
 511 lib_3a_int_int (int i)
 512 {
 513   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 514   return ci_adv_Success;
 515 }
 516
 517 static ci_adv_Err
 518 lib_3a_intp (int *p)
 519 {
 520   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 521   return ci_adv_Success;
 522 }
 523
 524 static int
 525 lib_3a_isp_set_fd (int fd, const char *sensor_id)
 526 {
 527   int sensor_type;
 528   ia_3a_window window;
 529
 530   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 531   if (ci_adv_init(sensor_id, fd, NULL) == 0) {
 532     sensor_type = SENSOR_TYPE_RAW;
 533   } else {
 534     sensor_type = SENSOR_TYPE_SOC;
 535  }
 536
 537   if (sensor_type == SENSOR_TYPE_RAW) {
 538     cam_lib_3a_dbg("SENSOR_TYPE_RAW");
 539     ci_adv_awb_enable(TRUE);
 540     ci_adv_awb_lock(FALSE);
 541
 542     ci_adv_ae_enable(TRUE);
 543     ci_adv_ae_lock(FALSE);
 544
 545     ci_adv_af_enable(TRUE);
 546     ci_adv_af_lock(FALSE);
 547
 548     window.x_left = 0;
 549     window.x_right = 0,
 550     window.y_top = 0;
 551     window.y_bottom = 0;
 552     window.weight = 0;
 553
 554     ci_adv_ae_set_window(&window);
 555
 556     ci_adv_ae_set_exposure_program(ia_3a_ae_exposure_program_auto);
 557     ci_adv_ae_set_mode(ia_3a_ae_mode_auto);
 558     ci_adv_ae_set_metering_mode(ia_3a_ae_metering_mode_center);
 559     ci_adv_af_set_range (ia_3a_af_range_full);
 560     ci_adv_awb_set_mode(ia_3a_awb_mode_auto);
 561     ci_adv_af_set_mode(ia_3a_af_mode_auto);
 562     ci_adv_af_set_metering_mode (ia_3a_af_metering_mode_auto);
 563
 564   }
 565
 566   return sensor_type;
 567 }
 568
 569 static void
 570 lib_3a_switch_mode (ia_3a_isp_mode mode, float frame_rate)
 571 {
 572   cam_lib_3a_dbg("%s:%d mode:%d frame_rate:%f\n", __func__, __LINE__, mode,frame_rate);
 573   ci_adv_configure(mode, frame_rate);
 574 }
 575
 576 static ci_adv_Err lib_3a_AeGetWindowsNum(int *num)
 577 {
 578   cam_lib_3a_dbg ("%s:%d\n", __func__, __LINE__);
 579   return ci_adv_Success;
 580 }
 581
 582 static void lib_3a_AwbVersion(int * major, int * minor)
 583 {
 584   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 585   ci_adv_awb_version(major,minor);
 586 }
 587
 588 static void lib_3a_AeVersion(int * major, int * minor)
 589 {
 590   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 591   ci_adv_ae_version(major,minor);
 592 }
 593
 594 static void lib_3a_AfVersion(int * major, int * minor)
 595 {
 596   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 597   ci_adv_af_version(major,minor);
 598 }
 599
 600 static void lib_3a_AfGetStillAfStatus(ia_3a_af_status *status)
 601 {
 602   *status = ci_adv_af_get_status();
 603 }
 604
 605 static bool lib_3a_af_is_complete(void)
 606 {
 607
 608   ia_3a_af_status status;
 609   bool completed = FALSE;
 610
 611   lib_3a_AfGetStillAfStatus(&status);
 612
 613   if (status == ia_3a_af_status_error) {
 614     cam_lib_3a_dbg("==== still AF failed \n");
 615     completed = TRUE;
 616   }
 617    else if (status == ia_3a_af_status_success) {
 618     cam_lib_3a_dbg("==== still AF success");
 619     completed = TRUE;
 620   } else if (status == ia_3a_af_status_cancelled) {
 621     cam_lib_3a_dbg("==== still AF cancelled \n");
 622     completed = TRUE;
 623   }
 624   else {
 625     cam_lib_3a_dbg("==== still AF continue %d \n", status);
 626   }
 627
 628   return completed;
 629 }
 630
 631 static void lib_3a_RerVersion(int * major, int * minor)
 632 {
 633   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 634   return;
 635 }
 636
 637 static ci_adv_Err lib_3a_AeGetManualShutter(int *time)
 638 {
 639   /* TODO time is float */
 640   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 641   ci_adv_ae_set_manual_shutter((float)*time);
 642   return ci_adv_Success;
 643 }
 644
 645 static void lib_3a_Awbdata(unsigned * num_p, unsigned * avg_r, unsigned * avg_gr,
 646         unsigned * avg_b, unsigned * avg_gb)
 647 {
 648   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 649   return;
 650 }
 651
 652 static void lib_3a_AeGetManualAperture(int *aperture)
 653 {
 654   // TODO returns float
 655   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 656   *aperture = (int)ia_3a_ae_get_manual_aperture();
 657 }
 658
 659 static void lib_3a_AeGetFlashMode(ia_3a_ae_flash_mode *mode)
 660 {
 661   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 662   *mode= ia_3a_ae_get_flash_mode();
 663 }
 664
 665 static void lib_3a_AeSetFlashMode(ia_3a_ae_flash_mode mode)
 666 {
 667   cam_lib_3a_dbg("%s:%d mode:%d \n", __func__, __LINE__, mode);
 668   ci_adv_ae_set_flash_mode(mode);
 669 }
 670
 671 static void lib_3a_AwbGetManualColorTemperature(int *ctemp)
 672 {
 673   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 674   *ctemp = ia_3a_awb_get_manual_color_temperature();
 675 }
 676
 677 static void
 678 lib_3a_Awbmatrix(int msqWbGain[3], int msqCcMtrx[9], unsigned short * shift)
 679 {
 680   cam_lib_3a_dbg ("%s:%d\n", __func__, __LINE__);
 681 }
 682
 683 static void lib_3a_GetGridInfo(void * grid_info)
 684 {
 685   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 686 }
 687
 688 static void
 689 lib_3a_AeSetMeteringMode(ia_3a_ae_metering_mode mode)
 690 {
 691   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 692   ci_adv_ae_set_metering_mode(mode);
 693 }
 694
 695 static void
 696 lib_3a_AeGetMeteringMode(ia_3a_ae_metering_mode *mode)
 697 {
 698   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 699   *mode = ia_3a_ae_get_metering_mode();
 700 }
 701
 702 static void
 703 lib_3a_AfSetMeteringMode(ia_3a_af_metering_mode mode)
 704 {
 705   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 706   ci_adv_af_set_metering_mode(mode);
 707 }
 708
 709 static void
 710 lib_3a_AfGetMeteringMode(ia_3a_af_metering_mode *mode)
 711 {
 712   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 713   ci_adv_af_get_metering_mode(mode);
 714 }
 715
 716 static void
 717 lib_3a_Ae_Af_GetWindow(ia_3a_window *window)
 718 {
 719   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 720   ia_3a_ae_get_window(window);
 721 }
 722
 723 static void
 724 lib_3a_Ae_Af_SetWindow( ia_3a_window *window)
 725 {
 726   cam_lib_3a_dbg("%s:window....%d:%d:%d:%d:%d\n",
 727       __func__, window->x_left,window->x_right,
 728       window->y_top , window->y_bottom, window->weight);
 729
 730   ci_adv_ae_set_window(window);
 731   ci_adv_af_set_windows(1, window);
 732 }
 733
 734 static void
 735 lib_3a_af_start( )
 736 {
 737   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 738   ci_adv_af_start();
 739 }
 740
 741 static void
 742 lib_3a_af_stop( )
 743 {
 744   cam_lib_3a_dbg ("%s:%d\n", __func__, __LINE__);
 745   ci_adv_af_stop();
 746 }
 747
 748 static void
 749 lib_3a_ae_calc_for_flash( )
 750 {
 751   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 752   ci_adv_process_for_flash(ia_3a_flash_stage_none);
 753 }
 754 static void
 755 lib_3a_calc_without_flash( )
 756 {
 757   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 758   ci_adv_process_for_flash(ia_3a_flash_stage_pre);
 759 }
 760
 761 static void
 762 lib_3a_calc_with_flash( )
 763 {
 764   cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 765   ci_adv_process_for_flash(ia_3a_flash_stage_main);
 766 }
 767
 768 static void
 769 lib_3a_AeAfAwb_process( struct timeval *frame_timestamp)
 770 {
 771   int status;
 772   //cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 773   status =  ci_adv_process_frame(TRUE,frame_timestamp);
 774 }
 775 static void
 776 lib_3a_get_statistics( )
 777 {
 778  // cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
 779   ci_adv_3a_stat cur_stat;
 780   ci_adv_get_3a_stat (&cur_stat);
 781  /* cam_lib_3a_dbg("%8.3f, %8.3f, %8.3f, %8.3f, %8d, %8.3f, %8.3f, %8.3f\n",
 782                 cur_stat.bv,
 783                 cur_stat.tv,
 784                 cur_stat.sv,
 785                 cur_stat.av,
 786                 cur_stat.focus_pos,
 787                 cur_stat.wb_gain_r,
 788                 cur_stat.wb_gain_g,
 789                 cur_stat.wb_gain_b);
 790 */
 791 }
 792
 793 static void
 794 lib_3a_awb_apply_results( )
 795 {
 796 }
 797 static void
 798 lib_3a_AwbSetImageEffect(ia_3a_image_effect effect)
 799 {
 800   cam_lib_3a_dbg("%s:%d effect %d\n", __func__, __LINE__, effect);
 801
 802   ci_adv_isp_set_image_effect(effect);
 803 }
 804
 805 static void
 806 lib_3a_AwbGetImageEffect(ia_3a_image_effect *effect)
 807 {
 808   *effect = ci_adv_isp_get_image_effect();
 809   cam_lib_3a_dbg("%s:%d effect: %d\n", __func__, __LINE__, *effect);
 810
 811 }
 812
 813 static void
 814 lib_ae_is_flash_needed(bool *useflash)
 815 {
 816   ci_adv_ae_is_flash_necessary(useflash);
 817   cam_lib_3a_dbg("%s:%d useflash: %d\n", __func__, __LINE__, *useflash);
 818
 819 }
 820
 821 static ci_adv_Err
 822 lib_3a_AeSetManualIso(int sensitivity)
 823 {
 824         float sv;
 825         if (sensitivity <=0)
 826         {
 827                 cam_lib_3a_dbg("error in get log2 math computation in line %d; sensitivity: %d\n", __LINE__, sensitivity);
 828                 return ci_adv_InvalidArgument;
 829         }
 830
 831         sv = log10((float)sensitivity / 3.125) / log10(2.0);
 832         ci_adv_err ret = ci_adv_ae_set_manual_iso(sv);
 833         if(ci_adv_success != ret)
 834                 return ret;
 835
 836         cam_lib_3a_dbg(" *** manual set iso in EV: %f\n", sv);
 837
 838         return ci_adv_success;
 839 }
 840
 841 static ci_adv_Err
 842 lib_3a_AeGetManualIso(int *sensitivity)
 843 {
 844         float sv;
 845         ci_adv_err ret = ci_adv_ae_get_manual_iso(&sv);
 846         if(ci_adv_success != ret)
 847                 return ret;
 848         *sensitivity = (int)(3.125 * pow(2, sv));
 849
 850         return ci_adv_success;
 851 }
 852
 853 static void
 854 lib_3a_GetMakerNote(ia_3a_mknote_mode mknMode, ia_3a_mknote *note)
 855 {
 856     note = ci_adv_get_maker_note(mknMode);
 857 }
 858
 859 static void
 860 lib_3a_AddMakerNoteRecord(ia_3a_mknote_field_type mkn_format_id,
 861                                    ia_3a_mknote_field_name mkn_name_id,
 862                                    const void *record,
 863                                    unsigned short record_size)
 864 {
 865   ci_adv_add_maker_note_record(mkn_format_id, mkn_name_id, record, record_size);
 866 }
 867
 868 static void
 869 lib_3a_PutMakerNote(ia_3a_mknote *mknData)
 870 {
 871     if (mknData != NULL)
 872     {
 873         ci_adv_put_maker_note(mknData);
 874     }
 875 }
 876
 877 static void
 878 lib_3a_ResetMakerNote(void)
 879 {
 880     ci_adv_reset_maker_note();
 881 }
 882
 883
 884 void
 885 lib_3a_link_functions_init (GstV4l2MFLDAdvCI *mfldadvci)
 886 {
 887
 888   mfldadvci->initialized = 0;
 889   mfldadvci->init = lib_3a_init;
 890   mfldadvci->uninit = lib_3a_uninit;
 891   mfldadvci->isp_set_fd = lib_3a_isp_set_fd;
 892   mfldadvci->mode_spec_init = lib_3a_int_void; /* TODO */
 893   mfldadvci->switch_mode = lib_3a_switch_mode;
 894
 895   mfldadvci->AeAfAwb_process = lib_3a_AeAfAwb_process;
 896   mfldadvci->get_statistics = lib_3a_get_statistics; /* TODO atomisp_dis_statistics  ? */
 897
 898   mfldadvci->ae_calc_for_flash = lib_3a_ae_calc_for_flash;
 899   mfldadvci->ae_calc_without_flash = lib_3a_calc_without_flash;
 900   mfldadvci->ae_calc_with_flash = lib_3a_calc_with_flash;
 901
 902   mfldadvci->ae_is_flash_needed = lib_ae_is_flash_needed;
 903
 904   mfldadvci->ae_apply_results = lib_3a_ae;
 905
 906   mfldadvci->af_start = lib_3a_af_start;
 907   mfldadvci->af_stop = lib_3a_af_stop;
 908   mfldadvci->af_is_complete = lib_3a_af_is_complete;
 909   mfldadvci->awb_apply_results = lib_3a_awb_apply_results;
 910   mfldadvci->awb_calc_flash = lib_3a_void;
 911
 912   mfldadvci->dis_read_statistics = lib_3a_void;
 913   mfldadvci->update_dis_results = lib_3a_void;
 914   mfldadvci->dis_process = lib_3a_dis_process;
 915   mfldadvci->dis_calc_still = lib_3a_dis_calc_still;
 916
 917   mfldadvci->do_redeye_removal = lib_3a_do_redeye_removal;
 918   mfldadvci->still_compose = lib_3a_still_compose;
 919   mfldadvci->load_gdc_table = lib_3a_void;
 920
 921   mfldadvci->AeSetBias = lib_3a_int_int;
 922   mfldadvci->AeGetBias = lib_3a_intp;
 923   mfldadvci->AeSetFlickerMode = lib_3a_AeSetFlickerMode;
 924   mfldadvci->AeGetFlickerMode = lib_3a_AeGetFlickerMode;
 925   mfldadvci->AeSetExposureProgram = lib_3a_AeSetExposureProgram;
 926   mfldadvci->AeGetExposureProgram = lib_3a_AeGetExposureProgram;
 927   mfldadvci->AeSetMeteringMode = lib_3a_AeSetMeteringMode;
 928   mfldadvci->AeGetMeteringMode = lib_3a_AeGetMeteringMode;
 929   mfldadvci->AeGetWindow = lib_3a_Ae_Af_GetWindow;
 930   mfldadvci->AeSetWindow = lib_3a_Ae_Af_SetWindow;
 931   mfldadvci->AeSetIso = lib_3a_AeSetManualIso;
 932   mfldadvci->AeGetIso = lib_3a_AeGetManualIso;
 933
 934
 935   mfldadvci->AfSetMode = lib_3a_AfSetMode;
 936   mfldadvci->AfGetMode = lib_3a_AfGetMode;
 937   mfldadvci->AfSetRange = lib_3a_AfSetRange;
 938   mfldadvci->AfGetRange = lib_3a_AfGetRange;
 939   mfldadvci->AfSetMeteringMode = lib_3a_AfSetMeteringMode;
 940   mfldadvci->AfGetMeteringMode = lib_3a_AfGetMeteringMode;
 941   mfldadvci->AfGetWindow = lib_3a_Ae_Af_GetWindow;
 942   mfldadvci->AfSetWindow = lib_3a_Ae_Af_SetWindow;
 943
 944   mfldadvci->AwbSetMode = lib_3a_AwbSetMode;
 945   mfldadvci->AwbGetMode = lib_3a_AwbGetMode;
 946   mfldadvci->AwbSetLightSource = lib_3a_AwbSetLightSource;
 947   mfldadvci->AwbGetLightSource = lib_3a_AwbGetLightSource;
 948   mfldadvci->AwbSetImageEffect = lib_3a_AwbSetImageEffect;
 949   mfldadvci->AwbGetImageEffect = lib_3a_AwbGetImageEffect;
 950
 951   mfldadvci->AeGetWindowsNum = lib_3a_AeGetWindowsNum;
 952   mfldadvci->AwbVersion = lib_3a_AwbVersion;
 953   mfldadvci->AeVersion = lib_3a_AeVersion;
 954   mfldadvci->AfVersion = lib_3a_AfVersion;
 955   mfldadvci->AfGetStillAfStatus = lib_3a_AfGetStillAfStatus;
 956   mfldadvci->RerVersion = lib_3a_RerVersion;
 957   mfldadvci->AeGetManualShutter = lib_3a_AeGetManualShutter;
 958   mfldadvci->Awbdata = lib_3a_Awbdata;
 959   mfldadvci->AeGetManualAperture = lib_3a_AeGetManualAperture;
 960   mfldadvci->AeSetFlashMode = lib_3a_AeSetFlashMode;
 961   mfldadvci->AeGetFlashMode = lib_3a_AeGetFlashMode;
 962   mfldadvci->AwbGetManualColorTemperature = lib_3a_AwbGetManualColorTemperature;
 963   mfldadvci->Awbmatrix = lib_3a_Awbmatrix;
 964   mfldadvci->GetGridInfo = lib_3a_GetGridInfo;
 965   mfldadvci->GetMakerNote  = lib_3a_GetMakerNote;
 966   mfldadvci->AddMakerNoteRecord = lib_3a_AddMakerNoteRecord;
 967   mfldadvci->PutMakerNote = lib_3a_PutMakerNote;
 968   mfldadvci->ResetMakerNote = lib_3a_ResetMakerNote;
 969 }
 970 #endif /* USE_STATIC_3A */
 971 void
 972 wrapper_default_link_functions_init (GstV4l2MFLDAdvCI *mfldadvci)
 973 {
 974
 975   mfldadvci->initialized = 0;
 976   mfldadvci->init = wrapper_default_init;
 977   mfldadvci->uninit = wrapper_default_uninit;
 978   mfldadvci->isp_set_fd = wrapper_default_isp_set_fd;
 979   mfldadvci->mode_spec_init = wrapper_default_int_void; /* TODO */
 980   mfldadvci->switch_mode = wrapper_default_switch_mode;
 981
 982   mfldadvci->AeAfAwb_process = wrapper_default_AeAfAwb_process;
 983   mfldadvci->get_statistics = wrapper_default_get_statistics; /* TODO atomisp_dis_statistics  ? */
 984
 985   mfldadvci->ae_calc_for_flash = wrapper_default_ae_calc_for_flash;
 986   mfldadvci->ae_calc_without_flash = wrapper_default_calc_without_flash;
 987   mfldadvci->ae_calc_with_flash = wrapper_default_calc_with_flash;
 988
 989   mfldadvci->ae_is_flash_needed = wrapper_default_is_flash_needed;
 990
 991   mfldadvci->ae_apply_results = wrapper_default_ae;
 992
 993   mfldadvci->af_start = wrapper_default_af_start;
 994   mfldadvci->af_stop = wrapper_default_af_stop;
 995   mfldadvci->af_is_complete = wrapper_default_af_is_complete;
 996   mfldadvci->awb_apply_results = wrapper_default_awb_apply_results;
 997   mfldadvci->awb_calc_flash = wrapper_default_void;
 998
 999   mfldadvci->dis_read_statistics = wrapper_default_void;
1000   mfldadvci->update_dis_results = wrapper_default_void;
1001   mfldadvci->dis_process = wrapper_default_dis_process;
1002   mfldadvci->dis_calc_still = wrapper_default_dis_calc_still;
1003
1004   mfldadvci->do_redeye_removal = wrapper_default_do_redeye_removal;
1005   mfldadvci->still_compose = wrapper_default_still_compose;
1006   mfldadvci->load_gdc_table = wrapper_default_void;
1007
1008   mfldadvci->AeSetBias = wrapper_default_int_int;
1009   mfldadvci->AeGetBias = wrapper_default_intp;
1010   mfldadvci->AeSetFlickerMode = wrapper_default_AeSetFlickerMode;
1011   mfldadvci->AeGetFlickerMode = wrapper_default_AeGetFlickerMode;
1012   mfldadvci->AeSetExposureProgram = wrapper_default_AeSetExposureProgram;
1013   mfldadvci->AeGetExposureProgram = wrapper_default_AeGetExposureProgram;
1014   mfldadvci->AeSetMeteringMode = wrapper_default_AeSetMeteringMode;
1015   mfldadvci->AeGetMeteringMode = wrapper_default_AeGetMeteringMode;
1016   mfldadvci->AeGetWindow = wrapper_default_Ae_Af_GetWindow;
1017   mfldadvci->AeSetWindow = wrapper_default_Ae_Af_SetWindow;
1018   mfldadvci->AeSetIso = wrapper_default_AeSetManualIso;
1019   mfldadvci->AeGetIso = wrapper_default_AeGetManualIso;
1020
1021
1022   mfldadvci->AfSetMode = wrapper_default_AfSetMode;
1023   mfldadvci->AfGetMode = wrapper_default_AfGetMode;
1024   mfldadvci->AfSetRange = wrapper_default_AfSetRange;
1025   mfldadvci->AfGetRange = wrapper_default_AfGetRange;
1026   mfldadvci->AfSetMeteringMode = wrapper_default_AfSetMeteringMode;
1027   mfldadvci->AfGetMeteringMode = wrapper_default_AfGetMeteringMode;
1028   mfldadvci->AfGetWindow = wrapper_default_Ae_Af_GetWindow;
1029   mfldadvci->AfSetWindow = wrapper_default_Ae_Af_SetWindow;
1030
1031   mfldadvci->AwbSetMode = wrapper_default_AwbSetMode;
1032   mfldadvci->AwbGetMode = wrapper_default_AwbGetMode;
1033   mfldadvci->AwbSetLightSource = wrapper_default_AwbSetLightSource;
1034   mfldadvci->AwbGetLightSource = wrapper_default_AwbGetLightSource;
1035   mfldadvci->AwbSetImageEffect = wrapper_default_AwbSetImageEffect;
1036   mfldadvci->AwbGetImageEffect = wrapper_default_AwbGetImageEffect;
1037
1038   mfldadvci->AeGetWindowsNum = wrapper_default_AeGetWindowsNum;
1039   mfldadvci->AwbVersion = wrapper_default_AwbVersion;
1040   mfldadvci->AeVersion = wrapper_default_AeVersion;
1041   mfldadvci->AfVersion = wrapper_default_AfVersion;
1042   mfldadvci->AfGetStillAfStatus = wrapper_default_AfGetStillAfStatus;
1043   mfldadvci->RerVersion = wrapper_default_RerVersion;
1044   mfldadvci->AeGetManualShutter = wrapper_default_AeGetManualShutter;
1045   mfldadvci->Awbdata = wrapper_default_Awbdata;
1046   mfldadvci->AeGetManualAperture = wrapper_default_AeGetManualAperture;
1047   mfldadvci->AeSetFlashMode = wrapper_default_AeSetFlashMode;
1048   mfldadvci->AeGetFlashMode = wrapper_default_AeGetFlashMode;
1049   mfldadvci->AwbGetManualColorTemperature = wrapper_default_AwbGetManualColorTemperature;
1050   mfldadvci->Awbmatrix = wrapper_default_Awbmatrix;
1051   mfldadvci->GetGridInfo = wrapper_default_GetGridInfo;
1052   mfldadvci->GetMakerNote  = wrapper_default_GetMakerNote;
1053   mfldadvci->AddMakerNoteRecord = wrapper_default_AddMakerNoteRecord;
1054   mfldadvci->PutMakerNote = wrapper_default_PutMakerNote;
1055   mfldadvci->ResetMakerNote = wrapper_default_ResetMakerNote;
1056 }