gst-libs/atomisphal/mfld_cam.c

   1 /* Gstreamer MFLD camera source abstract Layer API
   2  * Copyright (c) 2010 Intel Corporation
   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 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <sys/mman.h>
  22 #include <string.h>
  23 #include <sys/ioctl.h>
  24
  25 #include <unistd.h>
  26
  27 #include "atomisp.h"
  28
  29 #include "mfld_cam.h"
  30 #include "mfld_driver.h"
  31
  32 #include <glib.h>
  33 #include <pthread.h>
  34 #include <errno.h>
  35 #include <semaphore.h>
  36
  37 sem_t g_sem_3a;
  38
  39 /* Focus Status Map */
  40 static const int focus_status_map[][2] =
  41 {
  42   { CAM_FOCUS_STATUS_IDLE , advci_af_status_idle},        /* AF not running */
  43   { CAM_FOCUS_STATUS_RUNNING, advci_af_status_busy},      /* Busy focusing */
  44   { CAM_FOCUS_STATUS_SUCCESS, advci_af_status_success},   /* Successfully focussed */
  45   { CAM_FOCUS_STATUS_FAIL, advci_af_status_error},        /* Cannot focus */
  46   { CAM_FOCUS_STATUS_SUCCESS, advci_af_status_cancelled,},/* Canceled by user */
  47   { -1, -1 }
  48
  49 };
  50
  51 /* TODO */
  52 #define DIS_COMPOSITE_FRAMES    3
  53
  54
  55 /*
  56  * Return mapping for item from given table. If @reverse is FALSE, @item is
  57  * considered as a GstPhotography enumeration value and the function will
  58  * return matching atomispcam value for it. If @reverse is TRUE, @item
  59  * is considered as a atomispcam value and this function returns
  60  * corresponding GstPhotography value. If mapping is not found, mapping
  61  * for table index 0 is returned.
  62  */
  63 int
  64 cam_find_item_new (const int table[][2], const int item, int reverse)
  65 {
  66   unsigned int i = 0;
  67   int index = reverse ? 1 : 0;
  68
  69   /* Shortcut didn't work, go through the whole table to find the item */
  70   while (table[i][0] != -1) {
  71     if (table[i][index] == item) {
  72       return table[i][index ^ 1];
  73     }
  74     i++;
  75   }
  76
  77   return table[0][index ^ 1];
  78 }
  79
  80
  81 /* The ISP mode set to the driver. Driver switch the binary according to the Mode
  82  * */
  83 /*
  84  * Saving for the ISP status in the library */
  85
  86 struct mfld_driver_t
  87 {
  88   int fd;
  89   advci_isp_mode mode;
  90   int rer_enabled;
  91   int dis_enabled, dvs_enabled;
  92   int af_enabled, ae_enabled, awb_enabled;
  93   int af_result;  // 0 means fail, it will be filled when captured finished.
  94   int still_af_count, start_still_af;
  95   struct timeval af_start_time;
  96   int initflag;
  97   int mmap;
  98   int first_frame;
  99   int g_3a_started;
 100   //GThread *thread;
 101   pthread_t thread;
 102   unsigned int width, height, fourcc;
 103   struct atomisp_dis_vector dvs_vector;
 104   float frame_rate;
 105   int sensor_type;
 106   struct timeval timestamp;
 107   int focus_done;
 108   gboolean enable_torch;
 109 };
 110
 111 struct buffer
 112 {
 113   void *start;
 114   size_t length;
 115 };
 116
 117 /* TODO: Check if this is needed anymore after focus works like it should.
 118  * Hysteriss added to focus_done
 119  * in some case when old focus is still in progress and appication
 120  * ask new focus to be started  might be a case that 3A returns false "focus ready"
 121  * and status info is sent to app. -> for some reason it will crash to that.
 122 * */
 123 #define FOCUS_REALLY_DONE   2
 124
 125 /* Maximum auto focus time */
 126 static const int STILL_AF_MAX_TIME_IN_MS = 2200;
 127
 128 /* FIXME: Add lock to protec this global variable
 129  * */
 130 static struct mfld_cam_settings_t mfld_cam_settings;
 131 static struct mfld_driver_t mfld_driver;
 132 static GstV4l2MFLDAdvCI *mfldadvci;
 133
 134 static inline long
 135 calculate_timediff(struct timeval *t0, struct timeval *t1)
 136 {
 137   return ((t1->tv_sec - t0->tv_sec) * 1000000 +
 138             t1->tv_usec - t0->tv_usec) / 1000;
 139 }
 140
 141 static void
 142 clear_bit (int nr, unsigned int *addr)
 143 {
 144   unsigned int mask = (1UL << (nr) % 32);
 145   unsigned int *p = ((unsigned int *) addr) + nr / 32;
 146
 147   *p &= ~mask;
 148 }
 149
 150 static void
 151 set_bit (int nr, unsigned int *addr)
 152 {
 153   unsigned int mask = (1UL << (nr) % 32);
 154   unsigned int *p = ((unsigned int *) addr) + nr / 32;
 155
 156   *p |= mask;
 157 }
 158
 159 /* Set the white balance Mode throught the 3A library */
 160 static cam_err_t
 161 set_wb_mode (int wb_mode)
 162 {
 163
 164   switch (wb_mode) {
 165     case CAM_AWB_MODE_AUTO:
 166       mfldadvci->AwbSetMode (advci_awb_mode_auto);
 167       break;
 168     case CAM_AWB_MODE_DAYLIGHT:
 169       mfldadvci->AwbSetMode (advci_awb_mode_manual);
 170       mfldadvci->AwbSetLightSource (advci_awb_light_source_clear_sky);
 171       break;
 172     case CAM_AWB_MODE_CLOUDY:
 173       mfldadvci->AwbSetMode (advci_awb_mode_manual);
 174       mfldadvci->AwbSetLightSource (advci_awb_light_source_cloudiness);
 175       break;
 176     case CAM_AWB_MODE_SUNSET:
 177       mfldadvci->AwbSetMode (advci_awb_mode_manual);
 178       mfldadvci->AwbSetLightSource (advci_awb_light_source_shadow_area);
 179       break;
 180     case CAM_AWB_MODE_TUNGSTEN:
 181       mfldadvci->AwbSetMode (advci_awb_mode_manual);
 182       mfldadvci->AwbSetLightSource (advci_awb_light_source_filament_lamp);
 183       break;
 184     case CAM_AWB_MODE_FLUORESCENT:
 185        mfldadvci->AwbSetMode (advci_awb_mode_manual);
 186        mfldadvci->AwbSetLightSource (advci_awb_light_source_fluorlamp_w);
 187       break;
 188     default:
 189       cam_driver_dbg ("Not support awb mode\n");
 190       return CAM_ERR_UNSUPP;
 191   }
 192   mfld_cam_settings.wb_mode = wb_mode;
 193
 194   return 0;
 195 }
 196
 197 cam_err_t
 198 get_wb_mode (int *wb_mode)
 199 {
 200   advci_awb_light_source ls;
 201   advci_awb_mode mode;
 202
 203   mfldadvci->AwbGetMode (&mode);
 204
 205   if (mode == advci_awb_mode_auto) {
 206     *wb_mode = CAM_AWB_MODE_AUTO;
 207     return CAM_ERR_NONE;
 208   }
 209   //Manual Mode, check the error?
 210   mfldadvci->AwbGetLightSource (&ls);
 211   switch (ls) {
 212     case advci_awb_light_source_filament_lamp:
 213       *wb_mode = CAM_AWB_MODE_TUNGSTEN;
 214       break;
 215     case advci_awb_light_source_clear_sky:
 216       *wb_mode = CAM_AWB_MODE_DAYLIGHT;
 217       break;
 218     case advci_awb_light_source_cloudiness:
 219       *wb_mode = CAM_AWB_MODE_CLOUDY;
 220       break;
 221     case advci_awb_light_source_shadow_area:
 222       *wb_mode = CAM_AWB_MODE_SUNSET;
 223       break;
 224     case advci_awb_light_source_fluorlamp_w:
 225     case advci_awb_light_source_fluorlamp_n:
 226     case advci_awb_light_source_fluorlamp_d:
 227       *wb_mode = CAM_AWB_MODE_FLUORESCENT;
 228       break;
 229     default:
 230       //Use daylight as default
 231       *wb_mode = CAM_AWB_MODE_DAYLIGHT;
 232       break;
 233   }
 234   return CAM_ERR_NONE;
 235 }
 236
 237 static cam_err_t
 238 set_tone_mode (int fd, int mode)
 239 {
 240   cam_err_t ret = CAM_ERR_NONE;
 241   enum v4l2_colorfx colorfx = mode;
 242
 243   cam_driver_dbg ("%s  mode %d\n", __func__, mode);
 244
 245   ret = cam_driver_set_tone_mode (fd, colorfx);
 246   if (ret)
 247     mfld_cam_settings.tone_mode = mode;
 248   return ret;
 249 }
 250
 251 static cam_err_t
 252 get_tone_mode (int fd, int *mode)
 253 {
 254   cam_err_t ret = CAM_ERR_NONE;
 255   ret = cam_driver_get_tone_mode (fd, mode);
 256   return ret;
 257 }
 258
 259 static cam_err_t
 260 set_scene_mode (int mode)
 261 {
 262   advci_ae_exposure_program scene;
 263
 264   switch (mode) {
 265     case CAM_GENERAL_SCENE_MODE_PORTRAIT:
 266       scene = advci_ae_exposure_program_portrait;
 267       break;
 268     case CAM_GENERAL_SCENE_MODE_LANDSCAPE:
 269       scene = advci_ae_exposure_program_landscape;
 270       break;
 271     case CAM_GENERAL_SCENE_MODE_SPORT:
 272       scene = advci_ae_exposure_program_sports;
 273       break;
 274     case CAM_GENERAL_SCENE_MODE_NIGHT:
 275       scene = advci_ae_exposure_program_night;
 276       break;
 277     case CAM_GENERAL_SCENE_MODE_AUTO:
 278       scene = advci_ae_exposure_program_auto;
 279       break;
 280     case CAM_GENERAL_SCENE_MODE_FIREWORKS:
 281       scene = advci_ae_exposure_program_fireworks;
 282       break;
 283     default:
 284       cam_driver_dbg ("%s Not supported Scene Mode %d\n", __func__, mode);
 285       break;
 286   }
 287   mfldadvci->AeSetExposureProgram (scene);
 288
 289   mfld_cam_settings.scene_mode = mode;
 290   return CAM_ERR_NONE;
 291 }
 292
 293 static cam_err_t
 294 get_scene_mode (int *scene_mode)
 295 {
 296   *scene_mode = mfld_cam_settings.scene_mode;
 297   return CAM_ERR_NONE;
 298 }
 299
 300 static cam_err_t
 301 set_iso_speed (int iso)
 302 {
 303         cam_err_t ret;
 304         mfld_cam_settings.iso_speed = iso;
 305         ret = mfldadvci->AeSetIso(mfld_cam_settings.iso_speed);
 306         return ret;
 307 }
 308
 309 static cam_err_t
 310 get_iso_speed(int *iso)
 311 {
 312   *iso = mfld_cam_settings.iso_speed;
 313   return CAM_ERR_NONE;
 314 }
 315
 316 static cam_err_t
 317 set_flash_mode (int fd, int mode)
 318 {
 319   cam_err_t ret = CAM_ERR_NONE;
 320   mfld_cam_settings.flash_mode = mode;
 321
 322   cam_driver_dbg ("set flash mode: %d\n",mode);
 323   /* TODO check this when making auto modes etc.. */
 324   switch (mode) {
 325     case CAM_LIGHT_FLASH_MODE_AUTO:
 326     case CAM_LIGHT_FLASH_MODE_ON:
 327     case CAM_LIGHT_FLASH_MODE_FILL_IN:
 328     case CAM_LIGHT_FLASH_MODE_RED_EYE:
 329     case CAM_LIGHT_FLASH_MODE_OFF:
 330       if(!mfld_driver.enable_torch)
 331          ret = cam_driver_set_flash_mode(fd,ATOMISP_FLASH_MODE_OFF);
 332       break;
 333   }
 334   set_ae_flash_mode(fd,mode);
 335   return ret;
 336 }
 337
 338 static cam_err_t
 339 get_flash_mode (int *flash_mode)
 340 {
 341   *flash_mode = mfld_cam_settings.flash_mode;
 342   return CAM_ERR_NONE;
 343 }
 344
 345 static cam_err_t
 346 set_flicker_mode (int mode)
 347 {
 348
 349   /* Convert camera genreral flicker mode to AE flicker mode */
 350   switch (mode) {
 351     case CAM_GENERAL_FLICKER_REDUCTION_MODE_OFF:
 352       mfldadvci->AeSetFlickerMode (advci_ae_flicker_mode_off);
 353       break;
 354     case CAM_GENERAL_FLICKER_REDUCTION_MODE_50HZ:
 355       mfldadvci->AeSetFlickerMode (advci_ae_flicker_mode_50hz);
 356       break;
 357     case CAM_GENERAL_FLICKER_REDUCTION_MODE_60HZ:
 358       mfldadvci->AeSetFlickerMode (advci_ae_flicker_mode_60hz);
 359       break;
 360     case CAM_GENERAL_FLICKER_REDUCTION_MODE_AUTO:
 361       mfldadvci->AeSetFlickerMode (advci_ae_flicker_mode_auto);
 362       break;
 363     default:
 364       cam_driver_dbg ("Not supported flicker mode\n");
 365       return CAM_ERR_UNSUPP;
 366   }
 367   return CAM_ERR_NONE;
 368 }
 369
 370 static cam_err_t
 371 get_flicker_mode (int *mode)
 372 {
 373   int ret = 0;
 374   advci_ae_flicker_mode flicker_mode;
 375
 376   mfldadvci->AeGetFlickerMode (&flicker_mode);
 377
 378   /* Convert AE flicker mode to camera general flicker mode */
 379   switch (flicker_mode) {
 380     case advci_ae_flicker_mode_off:
 381       *mode = CAM_GENERAL_FLICKER_REDUCTION_MODE_OFF;
 382       break;
 383     case advci_ae_flicker_mode_50hz:
 384       *mode = CAM_GENERAL_FLICKER_REDUCTION_MODE_50HZ;
 385       break;
 386     case advci_ae_flicker_mode_60hz:
 387       *mode = CAM_GENERAL_FLICKER_REDUCTION_MODE_60HZ;
 388       break;
 389     case advci_ae_flicker_mode_auto:
 390       *mode = CAM_GENERAL_FLICKER_REDUCTION_MODE_AUTO;
 391       break;
 392     default:
 393       cam_driver_dbg ("Not supported flicker mode\n");
 394       return CAM_ERR_UNSUPP;
 395   }
 396
 397   return ret;
 398 }
 399
 400 static cam_err_t
 401 set_focus_mode (int mode)
 402 {
 403
 404   if (mfld_driver.sensor_type == SENSOR_TYPE_RAW){
 405     switch (mode) {
 406       case CAM_FOCUS_MODE_AUTO:
 407         mfldadvci->AfSetMode (advci_af_mode_auto);
 408         break;
 409       case CAM_FOCUS_MODE_MACRO:
 410         mfldadvci->AfSetMode (advci_af_mode_auto);
 411         mfldadvci->AfSetRange (advci_af_range_macro);
 412         break;
 413       case CAM_FOCUS_MODE_NORM:
 414         mfldadvci->AfSetMode (advci_af_mode_auto);
 415         mfldadvci->AfSetRange (advci_af_range_norm);
 416         break;
 417       case CAM_FOCUS_MODE_FULL:
 418         mfldadvci->AfSetMode (advci_af_mode_auto);
 419         mfldadvci->AfSetRange (advci_af_range_full);
 420         break;
 421       default:
 422         cam_driver_dbg ("Not supported mode\n");
 423         return CAM_ERR_UNSUPP;
 424     }
 425   }
 426
 427   mfld_cam_settings.focus_mode = mode;
 428   return CAM_ERR_NONE;
 429 }
 430
 431 static cam_err_t
 432 get_focus_mode (int *mode)
 433 {
 434   *mode = mfld_cam_settings.focus_mode;
 435   return CAM_ERR_NONE;
 436 }
 437
 438 /* Only update the noise that set by user */
 439 static cam_err_t
 440 set_noise_reduction (int fd, int mode)
 441 {
 442   cam_err_t ret = CAM_ERR_NONE;
 443   /* Only update the mode changed */
 444   int tmp_mode = mode ^ mfld_cam_settings.noise_reduction;
 445
 446   if (tmp_mode & (1 << CAM_NOISE_REDUCTION_EXTRA)) {
 447     if (mode & (1 << CAM_NOISE_REDUCTION_EXTRA))
 448       ret = cam_driver_set_xnr (fd, ON);
 449     else
 450       ret = cam_driver_set_xnr (fd, OFF);
 451   }
 452
 453   if (tmp_mode & (1 << CAM_NOISE_REDUCTION_BAYER)) {
 454     if (mode & (1 << CAM_NOISE_REDUCTION_BAYER))
 455       ret = cam_driver_set_bnr (fd, ON);
 456     else
 457       ret = cam_driver_set_bnr (fd, OFF);
 458   }
 459
 460   if (tmp_mode & (1 << CAM_NOISE_REDUCTION_YCC)) {
 461     if (mode & (1 << CAM_NOISE_REDUCTION_YCC))
 462       ret = cam_driver_set_ynr (fd, ON);
 463     else
 464       ret = cam_driver_set_ynr (fd, OFF);
 465   }
 466
 467   if (tmp_mode & (1 << CAM_NOISE_REDUCTION_TEMPORAL)) {
 468     if (mode & (1 << CAM_NOISE_REDUCTION_TEMPORAL))
 469       ret = cam_driver_set_tnr (fd, ON);
 470     else
 471       ret = cam_driver_set_tnr (fd, OFF);
 472   }
 473
 474   if (tmp_mode & (1 << CAM_NOISE_REDUCTION_FIXED_PATTERN)) {
 475     if (mode & (1 << CAM_NOISE_REDUCTION_FIXED_PATTERN))
 476       ret = cam_driver_set_fpn (fd, ON);
 477     else
 478       ret = cam_driver_set_fpn (fd, OFF);
 479   }
 480   //FIXME: Add false handling here
 481   mfld_cam_settings.noise_reduction = mode;
 482   return ret;
 483 }
 484
 485 static cam_err_t
 486 get_noise_reduction (int *mode)
 487 {
 488   *mode = mfld_cam_settings.noise_reduction;
 489   return CAM_ERR_NONE;
 490 }
 491
 492 /* Only update the advanced features that set by user */
 493 static cam_err_t
 494 set_capture_correction (int fd, int mode)
 495 {
 496   cam_err_t ret = 0;
 497   /* Only update the mode changed */
 498   int tmp_mode = mode ^ mfld_cam_settings.capture_correction;
 499   if (tmp_mode & (1 << CAM_CAPTURE_CORRECTION_GDC)) {
 500     if (mode & (1 << CAM_CAPTURE_CORRECTION_GDC)) {
 501       mfldadvci->load_gdc_table();
 502       ret = cam_driver_set_gdc (fd, ON);
 503     }
 504     else
 505       ret = cam_driver_set_gdc (fd, OFF);
 506   }
 507
 508   if (tmp_mode & (1 << CAM_CAPTURE_CORRECTION_RER)) {
 509     if (mode & (1 << CAM_CAPTURE_CORRECTION_RER)) {
 510       mfld_driver.rer_enabled = 1;
 511     } else {
 512       mfld_driver.rer_enabled = 0;
 513     }
 514   }
 515
 516   if (tmp_mode & (1 << CAM_CAPTURE_CORRECTION_DIS)) {
 517     if (mode & (1 << CAM_CAPTURE_CORRECTION_DIS)) {
 518       mfld_driver.dis_enabled = 1;
 519     } else {
 520       mfld_driver.dis_enabled = 0;
 521     }
 522   }
 523
 524   if (tmp_mode & (1 << CAM_CAPTURE_CORRECTION_DVS)) {
 525     if (mode & (1 << CAM_CAPTURE_CORRECTION_DVS)) {
 526       mfld_driver.dvs_enabled = 1;
 527       ret = cam_driver_set_dvs (fd, ON);
 528     } else {
 529       mfld_driver.dvs_enabled = 0;
 530       ret = cam_driver_set_dvs (fd, OFF);
 531     }
 532   }
 533
 534   if (tmp_mode & (1 << CAM_CAPTURE_CORRECTION_CAC)) {
 535     if (mode & (1 << CAM_CAPTURE_CORRECTION_CAC))
 536       ret = cam_driver_set_cac (fd, ON);
 537     else
 538       ret = cam_driver_set_cac (fd, OFF);
 539   }
 540
 541   if (tmp_mode & (1 << CAM_CAPTURE_CORRECTION_EE)) {
 542     if (mode & (1 << CAM_CAPTURE_CORRECTION_EE))
 543       ret = cam_driver_set_ee (fd, ON);
 544     else
 545       ret = cam_driver_set_ee (fd, OFF);
 546   }
 547
 548   if (tmp_mode & (1 << CAM_CAPTURE_CORRECTION_SC)) {
 549     if (mode & (1 << CAM_CAPTURE_CORRECTION_SC))
 550       ret = cam_driver_set_sc (fd, ON);
 551     else
 552       ret = cam_driver_set_sc (fd, OFF);
 553   }
 554
 555   if (tmp_mode & (1 << CAM_CAPTURE_CORRECTION_BLC)) {
 556     if (mode & (1 << CAM_CAPTURE_CORRECTION_BLC))
 557       ret = cam_driver_set_blc (fd, ON);
 558     else
 559       ret = cam_driver_set_blc (fd, OFF);
 560   }
 561
 562   if (tmp_mode & (1 << CAM_CAPTURE_CORRECTION_BPD)) {
 563     if (mode & (1 << CAM_CAPTURE_CORRECTION_BPD))
 564       ret = cam_driver_set_bpd (fd, ON);
 565     else
 566       ret = cam_driver_set_bpd (fd, OFF);
 567   }
 568
 569   mfld_cam_settings.capture_correction = mode;
 570   return 0;
 571 }
 572
 573 static cam_err_t
 574 get_capture_correction (int *mode)
 575 {
 576   *mode = mfld_cam_settings.capture_correction;
 577   return CAM_ERR_NONE;
 578 }
 579
 580 /* set_capture_fmt: Tell the driver what format we want to produce, and
 581  * driver tells us what format we should capture. This mechanism exists
 582  * because the driver may want to capture some exotic RAW format from
 583  * the sensor, process it and finally convert to desired format
 584  * (in @preprocess function).
 585  */
 586 #if 0
 587 static gboolean
 588 cam_driver_set_capture_fmt (GstCameraSrc * camerasrc,
 589     guint32 output_fourcc, guint output_outsize,
 590     guint32 * internal_fourcc, guint * internal_outsize)
 591 {
 592   gboolean ret;
 593   cam_driver_dbg ("%s\n", __func__);
 594   //Acutally, we don't plan to implement more than set format now
 595   struct v4l2_format fmt;
 596   memset (&fmt, 0, sizeof (fmt));
 597   *internal_fourcc = V4L2_PIX_FMT_YUV420;
 598   return TRUE;
 599 }
 600
 601 /* Tell the driver what resolution we want to capture.
 602  */
 603 static gboolean
 604 cam_driver_set_capture_res (GstCameraSrc * camerasrc, guint width, guint height)
 605 {
 606   gboolean ret;
 607   // Just set the capture format
 608   struct v4l2_format fmt;
 609   mfld_driver.height = height;
 610   mfld_driver.width = width;
 611   cam_driver_dbg ("%s: set res to width %u, height %u\n", __func__, width,
 612       height);
 613 #if 0
 614   memset (&fmt, 0, sizeof (fmt));
 615   fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 616   fmt.fmt.pix.width = width;
 617   fmt.fmt.pix.height = height;
 618   fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV420;
 619   ret = ioctl (mfld_driver.fd, VIDIOC_S_FMT, &fmt);
 620   if (ret < 0)
 621     return FALSE;
 622   return TRUE;
 623 #endif
 624   return TRUE;
 625 }
 626
 627 #endif
 628 /*
 629  * What is this function used for ?
 630  * TBD
 631  */
 632 cam_err_t
 633 cam_set_capture_mode (int fd, cam_capture_mode_t mode)
 634 {
 635   cam_err_t ret = CAM_ERR_NONE;
 636   cam_driver_dbg ("%s\n", __func__);
 637   mfld_driver.first_frame = 1;
 638
 639   if (mfld_driver.sensor_type == SENSOR_TYPE_RAW){
 640     switch (mode) {
 641       case CAM_CAPTURE_MODE_VIEWFINDER:
 642         mfldadvci->switch_mode (advci_isp_mode_preview, mfld_driver.frame_rate);
 643         set_flash_mode(fd, mfld_cam_settings.flash_mode);
 644         if (mfld_driver.ae_enabled)
 645           mfld_driver.first_frame = 1;
 646         cam_driver_dbg ("%s: VIEWFINDER Mode is set\n", __func__);
 647         break;
 648       case CAM_CAPTURE_MODE_VIDEO_RECORD:
 649         mfldadvci->switch_mode (advci_isp_mode_video, mfld_driver.frame_rate);
 650         if (mfld_driver.ae_enabled)
 651           mfld_driver.first_frame = 1;
 652         cam_driver_dbg ("%s: VIDEO Mode is set\n", __func__);
 653         break;
 654       case CAM_CAPTURE_MODE_STILL_CAPTURE:
 655         mfldadvci->switch_mode (advci_isp_mode_capture, mfld_driver.frame_rate);
 656         if (mfld_driver.ae_enabled)
 657           mfld_driver.first_frame = 1;
 658         cam_driver_dbg ("%s: STILL Mode is set\n", __func__);
 659         break;
 660       default:
 661         mfldadvci->switch_mode (advci_isp_mode_preview, mfld_driver.frame_rate);
 662         mfld_driver.first_frame = 1;
 663         cam_driver_dbg ("%s: NULL Mode is set\n", __func__);
 664         break;
 665     }
 666   }
 667   mfld_driver.mode = mode;
 668   return ret;
 669 }
 670
 671 cam_err_t
 672 cam_set_capture_fmt (int fd, unsigned int width, unsigned int height,
 673     unsigned int fourcc)
 674 {
 675   mfld_driver.width = width;
 676   mfld_driver.height = height;
 677   mfld_driver.fourcc = fourcc;
 678
 679   mfldadvci->mode_spec_init ();
 680
 681   return CAM_ERR_NONE;
 682 }
 683
 684 cam_err_t
 685 cam_set_zoom (int fd, float zoom)
 686 {
 687   cam_err_t ret = CAM_ERR_NONE;
 688   unsigned int zoomval;
 689
 690   /* Map 1.0 - 10.0 to 1 - 64 */
 691   zoomval = (unsigned int)((zoom - 1.0) * 63.0 / 9) + 1;
 692
 693   if (zoomval < 1 )
 694     zoomval = 1;
 695   if (zoomval > 64)
 696     zoomval = 64;
 697
 698   ret = cam_driver_set_zoom (fd, zoomval);
 699   cam_driver_dbg ("%s\n set zoom to %u, return %d\n", __func__, zoomval, ret);
 700
 701   return ret;
 702 }
 703
 704
 705 /* start: Called by v4l2camerasrc at startup (before STREAMON). Driver should
 706  * start processing the frames now.
 707  */
 708 cam_err_t
 709 cam_driver_start (int fd)
 710 {
 711   cam_err_t ret = CAM_ERR_NONE;
 712   cam_driver_dbg ("%s\n", __func__);
 713
 714   return ret;
 715 }
 716
 717 /* Called by v4l2camerasrc when stopping (before STREAMOFF). Driver
 718  * must stop processing the frames.
 719  */
 720 cam_err_t
 721 cam_driver_stop (int fd)
 722 {
 723   cam_err_t ret = CAM_ERR_NONE;
 724   cam_driver_dbg ("%s\n", __func__);
 725   return ret;
 726 }
 727
 728 cam_err_t
 729 cam_set_autoexposure (int fd, int on)
 730 {
 731   enum v4l2_exposure_auto_type expo;
 732   cam_err_t ret = CAM_ERR_NONE;
 733   if (on)
 734     expo = V4L2_EXPOSURE_AUTO;
 735   else
 736     expo = V4L2_EXPOSURE_MANUAL;
 737   cam_driver_set_autoexposure (fd, expo);
 738   return ret;
 739 }
 740
 741 /* Start or stop autofocusing.
 742  */
 743 cam_err_t
 744 cam_set_autofocus (int on)
 745 {
 746   cam_driver_dbg ("%s\n", __func__);
 747   if (on)
 748     mfld_driver.start_still_af = 1;
 749   else
 750     mfld_driver.start_still_af = 0;
 751
 752   return CAM_ERR_NONE;
 753 }
 754
 755 /* Turn on / off the flash.
 756  */
 757 cam_err_t
 758 cam_set_flash (int fd, int on)
 759 {
 760   cam_driver_dbg ("%s\n", __func__);
 761   cam_err_t ret = CAM_ERR_NONE;
 762   mfld_driver.enable_torch = on;
 763   if( cam_driver_set_torch(fd, on)== CAM_ERR_NONE)
 764     mfld_driver.enable_torch = on;
 765   else
 766     mfld_driver.enable_torch = FALSE;
 767   return ret;
 768 }
 769
 770 /* Ask the suggested flash intensity value.
 771  */
 772 cam_err_t
 773 cam_get_flash_intensity (int fd, int on)
 774 {
 775   cam_driver_dbg ("%s\n", __func__);
 776   return CAM_ERR_NONE;
 777 }
 778
 779 /* set_flash_intensity: Set flash intensity value.
 780  */
 781 cam_err_t
 782 cam_set_flash_intensity (int fd, int on)
 783 {
 784   cam_driver_dbg ("%s\n", __func__);
 785   return CAM_ERR_NONE;
 786 }
 787
 788 /* set_flash_duration: Set the flash timeout value.
 789  */
 790 cam_err_t
 791 cam_set_flash_duration (int fd, int duration)
 792 {
 793   cam_driver_dbg ("%s\n", __func__);
 794   return CAM_ERR_NONE;
 795 }
 796
 797 /* Turn on / off privacy light.
 798  */
 799 cam_err_t
 800 cam_set_privacy_light (int fd, int on)
 801 {
 802   cam_driver_dbg ("%s\n", __func__);
 803   return CAM_ERR_NONE;
 804 }
 805
 806 /* V4l2camerasrc uses this to query autofocusing status.
 807  */
 808 int
 809 cam_checkfocus_status (cam_focus_status_t * status, int force_update)
 810 {
 811   advci_af_status af_status;
 812   gboolean do_read = FALSE;
 813
 814   if (mfld_driver.focus_done >= FOCUS_REALLY_DONE) {
 815     mfld_driver.focus_done = 0;
 816     do_read = TRUE;
 817   }
 818   if ((do_read == TRUE) || (force_update == 1)) {
 819     mfldadvci->AfGetStillAfStatus (&af_status);
 820     *status = cam_find_item_new (focus_status_map, af_status, 1);
 821     cam_driver_dbg ("%s *status : %d\n ", __func__, *status);
 822     *status  = CAM_FOCUS_STATUS_RUNNING;
 823     return 1;
 824   }
 825   return 0;
 826 }
 827
 828 /* V4l2camerasrc uses this to query the risk for image shaking.
 829  */
 830 cam_err_t
 831 cam_get_shake_risk (int fd, int risk)
 832 {
 833   cam_driver_dbg ("%s\n", __func__);
 834   return CAM_ERR_NONE;
 835 }
 836
 837 /* start_capture: Called by v4l2camerasrc when the HQ-image capture process starts */
 838 cam_err_t
 839 cam_start_capture (int fd)
 840 {
 841   cam_err_t ret = CAM_ERR_NONE;
 842   cam_driver_dbg ("%s\n", __func__);
 843 #if 0
 844   if (mfld_driver.width <= 640 && mfld_driver.height <= 480)
 845     ret = ci_isp_switch_binary (fd, IspModePreview);
 846   else
 847     ret = ci_isp_switch_binary (fd, IspModePrimary);
 848   if (ret)
 849     return FALSE;
 850 #endif
 851   return ret;
 852 }
 853
 854 /* @stop_capture: Called by v4l2camerasrc when the HQ-image capture has
 855  * finished.*/
 856 cam_err_t
 857 cam_stop_capture (int fd)
 858 {
 859   cam_driver_dbg ("%s\n", __func__);
 860   return CAM_ERR_NONE;
 861 }
 862
 863 /* capture: If driver implements this vmethod, v4l2camerasrc's built-in HQ image
 864  * capture mechamism is skipped and this function is used to capture
 865  * the HQ image.
 866  * In MFLD implementation, we do the redeye reduction and DIS here
 867  */
 868 #if 0
 869 static gboolean
 870 cam_driver_capture (GstCameraSrc * camerasrc, GstBuffer ** buf,
 871     gpointer user_data)
 872 {
 873   cam_driver_dbg ("%s\n", __func__);
 874   //GstV4l2NewCamSrc *v4l2camsrc = (GstV4l2NewCamSrc *)user_data;
 875
 876   if (mfld_driver.rer_enabled == 1 || mfld_driver.dis_enabled == 1) {
 877     //mfld_capture_frames(buf, v4l2camsrc);
 878     return CAM_ERR_NONE;
 879   }
 880
 881   return FALSE;
 882 }
 883 #endif
 884
 885 /* process: Perform some image improvements for the given buffer. This
 886  * vmethod is called after @stop_capture vmethod.
 887  */
 888 cam_err_t
 889 cam_post_process (int fd)
 890 {
 891   cam_err_t ret = CAM_ERR_NONE;
 892   cam_driver_dbg ("%s\n", __func__);
 893
 894   return ret;
 895 }
 896
 897 /* get_makernote; Retrieve MakerNote data chunk from camera device.
 898  */
 899 cam_err_t
 900 cam_get_makernote (int fd, unsigned char *buf, unsigned size)
 901 {
 902   cam_driver_dbg ("%s, !!!!!!line:%d\n", __func__, __LINE__);
 903   cam_err_t ret = CAM_ERR_NONE;
 904
 905   ret = cam_driver_get_makernote (fd, buf, size);
 906
 907   return ret;
 908 }
 909
 910 cam_err_t
 911 cam_set_capture_correction (int fd, cam_capture_correction_t mode, int on)
 912 {
 913   cam_err_t ret;
 914   unsigned int capture_correction;
 915
 916   cam_feature_get (fd, CAM_CAPTURE_CORRECTION, &capture_correction);
 917
 918   if (on)
 919     set_bit (mode, &capture_correction);
 920   else
 921     clear_bit (mode, &capture_correction);
 922
 923   ret = cam_feature_set (fd, CAM_CAPTURE_CORRECTION, capture_correction);
 924   return ret;
 925 }
 926
 927 cam_err_t
 928 cam_set_tone_control (int fd, cam_tone_control_t tone,
 929     struct tone_control * value)
 930 {
 931   cam_err_t ret = CAM_ERR_NONE;
 932   switch (tone) {
 933     case CAM_GAMMA_VALUE:
 934       if (mfld_cam_settings.tone.gamma != value->gamma) {
 935         ret = cam_driver_set_gamma (fd, value->gamma);
 936         mfld_cam_settings.tone.gamma = value->gamma;
 937       }
 938       break;
 939     case CAM_BRIGHTNESS_VALUE:
 940       if (mfld_cam_settings.tone.brightness != value->brightness) {
 941         ret = cam_driver_set_contrast (fd, mfld_cam_settings.tone.contrast,
 942             value->brightness);
 943         mfld_cam_settings.tone.brightness = value->brightness;
 944       }
 945       break;
 946     case CAM_CONTRAST_VALUE:
 947       if (mfld_cam_settings.tone.contrast != value->contrast) {
 948         ret = cam_driver_set_contrast (fd, value->contrast,
 949             mfld_cam_settings.tone.brightness);
 950         mfld_cam_settings.tone.contrast = value->contrast;
 951       }
 952       break;
 953     default:
 954       cam_driver_dbg ("Unsupported tone control mode\n");
 955       return CAM_ERR_UNSUPP;
 956   }
 957   return ret;
 958 }
 959
 960 cam_err_t
 961 cam_get_tone_control (int fd, struct tone_control * tone)
 962 {
 963   *tone = mfld_cam_settings.tone;
 964   return CAM_ERR_NONE;
 965 }
 966
 967 static const char *photo_features [] =
 968 {
 969   "awb_mode",
 970   "color tone mode",
 971   "scene mode",
 972   "flash mode",
 973   "exposure",
 974   "aperture",
 975   "ev_compensation",
 976   "iso value",
 977   "focus mode",
 978   "flicker mode",
 979   "noise reduction mode",
 980   "capture correction",
 981 };
 982
 983 /* write_settings: Called when some settings in v4l2camerasrc's #GstPhotoSettings
 984  * structure has changed. Driver needs to forward the settings to device.
 985  */
 986 cam_err_t
 987 cam_feature_set (int fd, cam_photo_feature_t feature, int value)
 988 {
 989   cam_err_t ret = CAM_ERR_NONE;
 990   int bias;
 991
 992   cam_driver_dbg ("%s: feature %s, value %d\n", __func__,
 993                   photo_features[feature], value);
 994   switch (feature) {
 995     case CAM_AWB_MODE:
 996       ret = set_wb_mode (value);
 997       break;
 998     case CAM_GENERAL_EFFECT_TYPE:
 999       ret = set_tone_mode (fd, value);
1000       break;
1001     case CAM_GENERAL_SCENE_MODE:
1002       ret = set_scene_mode (value);
1003       break;
1004     case CAM_LIGHT_FLASH_MODE:
1005       ret = set_flash_mode (fd, value);
1006       break;
1007     case CAM_EXPOSURE_MANUAL_TIME:
1008       ret = cam_driver_set_exposure (fd, value);
1009       break;
1010     case CAM_EXPOSURE_MANUAL_APERTURE:
1011       ret = cam_driver_set_aperture (fd, value);
1012       break;
1013     case CAM_EXPOSURE_COMPENSATION:
1014       if (value > 20)
1015         value = 20;
1016       if (value < -20)
1017         value = -20;
1018       bias = (int) ((double) value / 10 * 65536.0);
1019       ret = mfldadvci->AeSetBias (bias);
1020       break;
1021     case CAM_EXPOSURE_ISO_VALUE:
1022           ret = set_iso_speed (value);
1023       break;
1024     case CAM_FOCUS_MODE:
1025       ret = set_focus_mode (value);
1026       break;
1027     case CAM_GENERAL_FLICKER_REDUCTION_MODE:
1028       ret = set_flicker_mode (value);
1029       break;
1030     case CAM_NOISE_REDUCTION_MODE:
1031       ret = set_noise_reduction (fd, value);
1032       break;
1033     case CAM_CAPTURE_CORRECTION:
1034       ret = set_capture_correction (fd, value);
1035       break;
1036     default:
1037       cam_driver_dbg ("Not supported photography features\n");
1038       break;
1039   }
1040
1041   if (ret)
1042     cam_err_print (ret);
1043
1044   return ret;
1045 }
1046
1047 /* read_settings: V4l2camerasrc tells the driver to retrieve settings from
1048  * device and store them into #GstPhotoSettings structure.
1049  */
1050 cam_err_t
1051 cam_feature_get (int fd, cam_photo_feature_t feature, int *value)
1052 {
1053   int bias;
1054   cam_err_t ret;
1055
1056   cam_driver_dbg ("%s: feature %s, \n", __func__,
1057                   photo_features[feature]);
1058   if (value == NULL) {
1059     cam_driver_dbg ("%s value is NULL\n", __func__);
1060     return CAM_ERR_PARAM;
1061   }
1062
1063   switch (feature) {
1064     case CAM_AWB_MODE:
1065       ret = get_wb_mode (value);
1066       break;
1067     case CAM_GENERAL_EFFECT_TYPE:
1068       ret = get_tone_mode (fd, value);
1069       break;
1070     case CAM_GENERAL_SCENE_MODE:
1071       ret = get_scene_mode(value);
1072       break;
1073     case CAM_LIGHT_FLASH_MODE:
1074       ret = get_flash_mode (value);
1075       break;
1076     case CAM_EXPOSURE_MANUAL_TIME:
1077       ret = cam_driver_get_exposure (fd, value);
1078       break;
1079     case CAM_EXPOSURE_MANUAL_APERTURE:
1080       ret = cam_driver_get_aperture (fd, value);
1081       break;
1082     case CAM_EXPOSURE_COMPENSATION:
1083       ret = mfldadvci->AeGetBias (&bias);
1084       *value = (int) (((double) bias / 65536.0) * 10);
1085       break;
1086     case CAM_EXPOSURE_ISO_VALUE:
1087           ret = get_iso_speed (value);
1088       break;
1089     case CAM_FOCUS_MODE:
1090       ret = get_focus_mode (value);
1091       break;
1092     case CAM_GENERAL_FLICKER_REDUCTION_MODE:
1093       ret = get_flicker_mode (value);
1094       break;
1095     case CAM_NOISE_REDUCTION_MODE:
1096       ret = get_noise_reduction (value);
1097       break;
1098     case CAM_CAPTURE_CORRECTION:
1099       ret = get_capture_correction (value);
1100       break;
1101     default:
1102       cam_driver_dbg ("Not supported photography features\n");
1103       ret = CAM_ERR_UNSUPP;
1104       break;
1105   }
1106   if (ret)
1107     cam_err_print (ret);
1108
1109   return ret;
1110 }
1111
1112 /* init: Initialize the driver. V4l2camerasrc calls this immediately after
1113  * the camera device has been opened and registers the device file
1114  * descriptor to the driver.
1115  */
1116
1117 /* Do the basic init here */
1118 void
1119 libmfld_cam_init (GstV4l2MFLDAdvCI * advci)
1120 {
1121   /* Initialize the driver structure */
1122   cam_driver_dbg ("%s\n", __func__);
1123
1124   if (sem_init(&g_sem_3a, 0, 0) < 0) {
1125     cam_driver_dbg("Init g_sem_3a failed\n");
1126   }
1127
1128   memset (&mfld_cam_settings, 0, sizeof (mfld_cam_settings));
1129
1130   /* These modes are on by default */
1131   mfld_cam_settings.noise_reduction =
1132       CAM_NOISE_REDUCTION_YCC | CAM_NOISE_REDUCTION_BAYER;
1133   mfld_cam_settings.capture_correction =
1134       (1 << CAM_CAPTURE_CORRECTION_EE) | (1 << CAM_CAPTURE_CORRECTION_SC) |
1135       (1 << CAM_CAPTURE_CORRECTION_BPD);
1136
1137   mfld_cam_settings.zoom = 1.0; //Zoom i in feature set 2
1138   mfld_cam_settings.ev_compensation = 0.0;
1139   mfld_cam_settings.exposure = 0;       // Auto
1140   mfld_cam_settings.aperture = 0;
1141   mfld_cam_settings.iso_speed = 0;
1142
1143   mfld_cam_settings.tone.gamma = 2.2;
1144   mfld_cam_settings.tone.brightness = 0;
1145   mfld_cam_settings.tone.contrast = 256;
1146
1147   mfld_cam_settings.wb_mode = CAM_AWB_MODE_AUTO;
1148   mfld_cam_settings.scene_mode = CAM_GENERAL_SCENE_MODE_AUTO;
1149   mfld_cam_settings.flash_mode = CAM_LIGHT_FLASH_MODE_AUTO;
1150   mfld_cam_settings.tone_mode = CAM_GENERAL_EFFECT_TYPE_NORMAL;
1151   mfld_cam_settings.flicker_mode = CAM_GENERAL_FLICKER_REDUCTION_MODE_50HZ;
1152   mfld_cam_settings.focus_mode = CAM_FOCUS_MODE_AUTO;
1153
1154   mfld_driver.ae_enabled = 0;
1155   mfld_driver.af_enabled = 0;
1156   mfld_driver.awb_enabled = 0;
1157   mfld_driver.dis_enabled = 0;
1158   mfld_driver.dvs_enabled = 0;
1159   mfld_driver.rer_enabled = 0;
1160   mfld_driver.start_still_af = 0;
1161   mfld_driver.still_af_count = 0;
1162
1163   mfld_driver.first_frame = 1;
1164
1165   mfld_driver.mmap = 1;
1166   mfld_driver.g_3a_started = 0;
1167
1168   mfld_driver.dvs_vector.x = 0;
1169   mfld_driver.dvs_vector.y = 0;
1170   mfld_driver.focus_done = 0;
1171
1172   mfld_driver.enable_torch = FALSE;
1173   mfldadvci = advci;
1174
1175   /* Initalize the 3A library */
1176   mfldadvci->init ();
1177 }
1178
1179 void
1180 libmfld_cam_dispose (void)
1181 {
1182   if (mfld_driver.g_3a_started) {
1183     pthread_cancel (mfld_driver.thread);
1184     mfld_driver.thread = 0;
1185   }
1186   mfld_driver.g_3a_started = 0;
1187   mfldadvci->uninit ();
1188   return;
1189 }
1190
1191 cam_err_t
1192 cam_driver_init (int fd, const char *sensor_id)
1193 {
1194   cam_driver_dbg ("%s\n", __func__);
1195
1196   mfld_driver.fd = fd;
1197
1198   mfld_driver.sensor_type =  mfldadvci->isp_set_fd (fd, sensor_id);
1199
1200   cam_driver_init_gamma (fd);
1201
1202   /* FixMe Need to get the ISO speed , apture when use need to read these
1203    * settings
1204    */
1205   mfld_driver.initflag = 1;     /* We are ready to call the dz_zoom */
1206   /* Do other driver related init here */
1207
1208   mfld_driver.thread = 0;
1209   mfld_driver.frame_rate = 15.0f;
1210
1211   return CAM_ERR_NONE;
1212 }
1213
1214 /* deinit: Deinitialize the driver. V4l2camerasrc tells the driver to stop
1215  * using the camera device, because after this call it is not valid anymore.
1216  */
1217 cam_err_t
1218 cam_driver_deinit (int fd)
1219 {
1220   cam_driver_dbg ("%s\n", __func__);
1221   /* Initialize the driver structure */
1222   //GstCameraSrcClass *camera_class = GST_CAMERA_SRC_GET_CLASS (camerasrc);
1223   mfld_driver.initflag = 0;
1224   if (mfld_driver.g_3a_started) {
1225     pthread_cancel (mfld_driver.thread);
1226     mfld_driver.g_3a_started = 0;
1227   }
1228   /* Do other driver related deinit here */
1229   led_flash_off(fd);
1230   return CAM_ERR_NONE;
1231 }
1232
1233 cam_err_t
1234 cam_set_frame_rate( float frame_rate)
1235 {
1236   mfld_driver.frame_rate = frame_rate;
1237   return CAM_ERR_NONE;
1238 }
1239
1240 /*
1241  * For Red Eye Reduction and Still Image Stabilization
1242  */
1243 static void
1244 cam_copy_v4l2buf_to_user (advci_frame_t *user, struct v4l2_buffer *buf)
1245 {
1246   void *addr;
1247   if (mfld_driver.mmap) {
1248     addr = mmap (NULL, buf->length, PROT_READ | PROT_WRITE, MAP_SHARED,
1249         mfld_driver.fd, buf->m.offset);
1250     if (MAP_FAILED == addr) {
1251       cam_driver_dbg ("Mapped failed\n");
1252       return;
1253     }
1254   } else {
1255     addr = (void *) buf->m.userptr;
1256   }
1257
1258   user->length = buf->length;
1259   user->addr = malloc (buf->length);
1260   if (user->addr == NULL) {
1261     cam_driver_dbg ("Malloc buf->lenth %d failed\n", buf->length);
1262     if (mfld_driver.mmap)
1263       munmap (addr, buf->length);
1264     return;
1265   }
1266   memcpy (user->addr, addr, buf->length);
1267   if (mfld_driver.mmap)
1268     munmap (addr, buf->length);
1269 }
1270
1271 static void
1272 cam_free_bufs (advci_frame_t *bufs)
1273 {
1274   int i;
1275   for (i = 0; i < DIS_COMPOSITE_FRAMES; i++) {
1276     if (bufs[i].addr != NULL)
1277       free (bufs[i].addr);
1278     bufs[i].addr = NULL;
1279     bufs[i].length = 0;
1280   }
1281 }
1282
1283 static void
1284 cam_still_compose (struct v4l2_buffer *buf, advci_frame_t bufs[],
1285     int frame_dis, struct atomisp_dis_vector vectors[])
1286 {
1287   advci_frame_t com_buf;
1288
1289   cam_driver_dbg ("Still Compose Phase 1: Begin\n");
1290   com_buf.length = buf->length;
1291
1292   if (mfld_driver.mmap)
1293     com_buf.addr = mmap (NULL, buf->length, PROT_READ | PROT_WRITE, MAP_SHARED,
1294         mfld_driver.fd, buf->m.offset);
1295   else
1296     com_buf.addr = (void *) buf->m.userptr;
1297   com_buf.width = mfld_driver.width;
1298   com_buf.height = mfld_driver.height;
1299
1300   mfldadvci->still_compose (&com_buf, bufs, frame_dis, vectors);
1301
1302   if (mfld_driver.mmap)
1303     munmap (com_buf.addr, com_buf.length);
1304 }
1305
1306 static void
1307 cam_do_redeye_removal (struct v4l2_buffer *buf)
1308 {
1309
1310
1311   advci_frame_t user_buf;
1312   user_buf.length = buf->length;
1313   if (mfld_driver.mmap)
1314     user_buf.addr = mmap (NULL, buf->length, PROT_READ | PROT_WRITE, MAP_SHARED,
1315         mfld_driver.fd, buf->m.offset);
1316   else
1317     user_buf.addr = (void *) buf->m.userptr;
1318   user_buf.width = mfld_driver.width;
1319   user_buf.height = mfld_driver.height;
1320   mfldadvci->do_redeye_removal (&user_buf);
1321
1322   if (mfld_driver.mmap)
1323     munmap (user_buf.addr, user_buf.length);
1324 }
1325
1326 static void
1327 write_image(const void *data, const int size)
1328 {
1329   char filename[50];
1330   static unsigned int count = 0;
1331   size_t bytes;
1332   FILE *fp;
1333
1334   snprintf(filename, 50, "dump_image_%d_%d_00%u.%s", mfld_driver.width, mfld_driver.height,
1335            count, "yuv");
1336
1337   fp = fopen (filename, "w+");
1338   if (fp == NULL) {
1339     cam_driver_dbg ("open file %s failed %s\n", filename, strerror (errno));
1340     exit (0);
1341   }
1342
1343   cam_driver_dbg ("Begin write image %s\n", filename);
1344   if ((bytes = fwrite (data, size, 1, fp)) < size)
1345     cam_driver_dbg ("Write less bytes to %s: %d, %d\n", filename,
1346         size, bytes);
1347   count++;
1348
1349   fclose (fp);
1350 }
1351
1352 static void
1353 dump_v4l2_buffer(struct v4l2_buffer *buffer)
1354 {
1355   void *data;
1356   static unsigned int i = 0;
1357   if (mfld_driver.mmap)
1358     data = mmap (NULL, buffer->length, PROT_READ | PROT_WRITE, MAP_SHARED,
1359         mfld_driver.fd, buffer->m.offset);
1360   else
1361     data = (void *) buffer->m.userptr;
1362
1363   write_image(data, buffer->length);
1364
1365   if (mfld_driver.mmap)
1366     munmap(data, buffer->length);
1367 }
1368
1369
1370 #define PAGE_ALIGN(x)   ((x + 0xfff) & 0xfffff000)
1371 static void
1372 dump_raw_image (int fd, struct cam_capture_settings *st)
1373 {
1374   unsigned int bytes;
1375   char *buf;
1376   char *filename;
1377   struct buffer raw_buffer;
1378   static unsigned int fn_count = 0;
1379   FILE *fp;
1380   char fn_buf[200];
1381
1382   filename = "./";
1383
1384   cam_driver_dbg ("%s, output_size %d\n", __func__, st->raw_output_size);
1385
1386   raw_buffer.length = st->raw_output_size;
1387   raw_buffer.start = mmap (NULL /* start anywhere */ ,
1388       PAGE_ALIGN (st->raw_output_size), PROT_READ | PROT_WRITE /* required */ ,
1389       MAP_SHARED /* recommended */ ,
1390       fd, 0xfffff000);
1391   if (MAP_FAILED == raw_buffer.start) {
1392     cam_driver_dbg ("mmap raw image failed");
1393     return;
1394   }
1395   cam_driver_dbg ("MMAP raw address from kernel 0x%x\n", raw_buffer.start);
1396   buf = (char *) raw_buffer.start;
1397
1398   memset (fn_buf, 0, sizeof (char) * 100);
1399   snprintf (fn_buf, 200, "%s/%d_%d_%u.%s", filename, mfld_driver.width,
1400       mfld_driver.height, fn_count++, "rawoutput.raw");
1401   fp = fopen (fn_buf, "w+");
1402   if (fp == NULL) {
1403     cam_driver_dbg ("open file %s failed %s\n", fn_buf, strerror (errno));
1404     exit (0);
1405   }
1406
1407   cam_driver_dbg ("The size of raw image %d\n", st->raw_output_size);
1408
1409   if ((bytes = fwrite (buf, st->raw_output_size, 1, fp)) < st->raw_output_size)
1410     cam_driver_dbg ("Write less bytes to %s: %d, %d\n", fn_buf,
1411         st->raw_output_size, bytes);
1412
1413   fclose (fp);
1414 }
1415
1416 static gpointer
1417 mfldcam_3a_process (gpointer data)
1418 {
1419   for (;;) {
1420     sem_wait(&g_sem_3a);
1421     /* Read 3A statistics */
1422     if ((mfld_driver.ae_enabled || mfld_driver.af_enabled
1423         || mfld_driver.awb_enabled || mfld_driver.dis_enabled
1424         || mfld_driver.dvs_enabled) && (mfld_driver.sensor_type == SENSOR_TYPE_RAW) )
1425     {
1426       mfldadvci->get_statistics ();
1427
1428       /* AE, AWB and AF Process */
1429       mfldadvci->AeAfAwb_process(&mfld_driver.timestamp);
1430
1431       /* apply Results */
1432       if (mfld_driver.awb_enabled)
1433         mfldadvci->awb_apply_results ();
1434
1435       if (mfld_driver.ae_enabled)
1436         mfldadvci->ae_apply_results ();
1437     } else
1438       return NULL;
1439   }
1440 }
1441
1442 void
1443 mfldcam_3a_start (void)
1444 {
1445   if (!mfld_driver.g_3a_started) {
1446     mfld_driver.g_3a_started = 1;
1447     if (pthread_create (&mfld_driver.thread, NULL, mfldcam_3a_process,
1448             NULL) != 0) {
1449       mfld_driver.g_3a_started = 0;
1450       cam_driver_dbg ("Create thread failed %s\n", __func__);;
1451     }
1452   }
1453 }
1454
1455 void
1456 mfldcam_3a_stop (void)
1457 {
1458   if (mfld_driver.g_3a_started)
1459     pthread_cancel (mfld_driver.thread);
1460   mfld_driver.g_3a_started = 0;
1461 }
1462
1463 static cam_err_t
1464 run_flash_sequence (int fd, struct v4l2_buffer *buffer)
1465 {
1466         // non flash
1467     led_flash_off (fd);
1468         mfldadvci->ae_calc_for_flash ();
1469         mfldadvci->ae_apply_results ();
1470     if (-1 == ioctl (fd, VIDIOC_DQBUF, buffer)) {
1471       cam_driver_dbg ("%s: Error dqbuf %d\n", __func__, 0);
1472       return CAM_ERR_SYS;
1473     }
1474         mfldadvci->get_statistics ();
1475
1476         // pre flash
1477         mfldadvci->ae_calc_without_flash ();
1478         mfldadvci->ae_apply_results ();
1479         led_flash_trigger (fd, 0, 0);
1480         mfldadvci->awb_apply_results ();
1481     if (-1 == ioctl (fd, VIDIOC_QBUF, buffer)) {
1482       cam_driver_dbg ("%s: Error qbuf %d\n", __func__, 1);
1483       return CAM_ERR_SYS;
1484     }
1485     if (-1 == ioctl (fd, VIDIOC_DQBUF, buffer)) {
1486       cam_driver_dbg ("%s: Error dqbuf %d\n", __func__, 1);
1487       return CAM_ERR_SYS;
1488     }
1489         mfldadvci->get_statistics ();
1490
1491         // main flash
1492         mfldadvci->ae_calc_with_flash ();
1493         mfldadvci->ae_apply_results ();
1494         mfldadvci->awb_calc_flash ();
1495         led_flash_trigger (fd, 0, 15);
1496         mfldadvci->awb_apply_results ();
1497     if (-1 == ioctl (fd, VIDIOC_QBUF, buffer)) {
1498       cam_driver_dbg ("%s: Error qbuf %d\n", __func__, 2);
1499       return CAM_ERR_SYS;
1500     }
1501     if (-1 == ioctl (fd, VIDIOC_DQBUF, buffer)) {
1502       cam_driver_dbg ("%s: Error dqbuf %d\n", __func__, 2);
1503       return CAM_ERR_SYS;
1504     }
1505
1506         return CAM_ERR_NONE;
1507 }
1508
1509 /* Discard the first two frames because of the first frame
1510  * from the driver is black. */
1511 static cam_err_t
1512 discard_first_frame(int fd, struct v4l2_buffer *buffer, int count)
1513 {
1514   int i;
1515   for (i = 0; i < count; i++) {
1516     if (-1 == ioctl (fd, VIDIOC_DQBUF, buffer)) {
1517       cam_driver_dbg ("%s: Error dqbuf %d\n", __func__, count);
1518       return CAM_ERR_SYS;
1519     }
1520     if (-1 == ioctl (fd, VIDIOC_QBUF, buffer)) {
1521       cam_driver_dbg ("%s: Error qbuf %d\n", __func__, count);
1522       return CAM_ERR_SYS;
1523     }
1524   }
1525   return CAM_ERR_NONE;
1526 }
1527
1528 static void
1529 cam_capture_init (int fd, struct v4l2_buffer *buffer,
1530                   struct cam_capture_settings *capture_settings)
1531 {
1532   int i;
1533
1534   mfld_driver.mmap = capture_settings->mmap;
1535   mfld_driver.ae_enabled = capture_settings->ae;
1536   mfld_driver.af_enabled = capture_settings->af;
1537   mfld_driver.awb_enabled = capture_settings->awb;
1538
1539   /* Discard the first two frames */
1540   if (mfld_driver.first_frame) {
1541     discard_first_frame(fd, buffer, 2);
1542     mfld_driver.first_frame = 0;
1543   }
1544   /* Still AF start */
1545   if (mfld_driver.start_still_af) {
1546     if (mfld_driver.af_enabled && mfld_driver.still_af_count > 0)
1547       mfldadvci->af_stop ();
1548     mfld_driver.focus_done = 0;
1549     mfld_driver.start_still_af = 0;
1550     mfld_driver.still_af_count = 1;
1551     mfld_driver.af_start_time = mfld_driver.timestamp;
1552
1553     if (mfldadvci->af_assist_light_needed()) {
1554        mfld_driver.enable_torch = TRUE;
1555        cam_driver_set_torch(fd, TRUE);
1556     }
1557     if (mfld_driver.af_enabled)
1558       mfldadvci->af_start ();
1559   }
1560 }
1561
1562 static gboolean
1563 get_flash_status(void)
1564 {
1565   int cur_flash_mode = CAM_LIGHT_FLASH_MODE_OFF;
1566   gboolean flash_en = FALSE;
1567
1568   get_flash_mode(&cur_flash_mode);
1569
1570   switch (cur_flash_mode) {
1571     case CAM_LIGHT_FLASH_MODE_ON:
1572         flash_en = TRUE;
1573         break;
1574     case CAM_LIGHT_FLASH_MODE_AUTO:
1575     case CAM_LIGHT_FLASH_MODE_RED_EYE:
1576         mfldadvci->ae_is_flash_needed(&flash_en);
1577
1578         break;
1579     default:
1580         /* other mode, turn flash off */
1581         ;
1582   }
1583   return flash_en;
1584 }
1585
1586 static void
1587 cam_dis_dvs_processing (struct atomisp_dis_vector *vectors, advci_frame_t *bufs,
1588         struct v4l2_buffer *buffer, int frame_cnt, int dis_enabled)
1589 {
1590   struct atomisp_dis_vector *dvs_vector;
1591
1592   cam_driver_dbg ("Begin cam_dis_get_statices\n");
1593   mfldadvci->dis_read_statistics ();        //read_dis_stats_from_xmem();
1594
1595   cam_driver_dbg ("Begin cam_dis_still_process\n");
1596
1597   if (mfld_driver.mode == advci_isp_mode_video)
1598     dvs_vector = &mfld_driver.dvs_vector;
1599   else
1600     dvs_vector = NULL;
1601   // TODO !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1
1602   // mfldadvci->dis_process (dvs_vector);       /* dis_vector only valid in video mode */
1603
1604   if (dis_enabled) {
1605     mfldadvci->dis_calc_still (&vectors[frame_cnt], frame_cnt);
1606     cam_copy_v4l2buf_to_user (&bufs[frame_cnt], buffer);
1607   }
1608
1609   cam_driver_dbg ("Update DIS results\n");
1610   mfldadvci->update_dis_results();
1611 }
1612
1613 static cam_err_t
1614 run_normal_sequence(int fd, struct v4l2_buffer *buffer)
1615 {
1616   int frame_cnt, frame_dis;
1617   struct atomisp_dis_vector vectors[DIS_COMPOSITE_FRAMES];
1618   advci_frame_t bufs[DIS_COMPOSITE_FRAMES];
1619
1620
1621   int dis_enabled = mfld_driver.dis_enabled &&
1622       (mfld_driver.fourcc == V4L2_PIX_FMT_YUV420);
1623
1624   for (frame_cnt = 0; frame_cnt < DIS_COMPOSITE_FRAMES; frame_cnt++) {
1625     bufs[frame_cnt].addr = NULL;
1626     bufs[frame_cnt].width = mfld_driver.width;
1627     bufs[frame_cnt].height = mfld_driver.height;
1628   }
1629
1630   if (dis_enabled)
1631     frame_dis = DIS_COMPOSITE_FRAMES;
1632   else
1633     frame_dis = 1;
1634
1635   for (frame_cnt = 0; frame_cnt < frame_dis; frame_cnt++) {
1636     if (-1 == ioctl (fd, VIDIOC_DQBUF, buffer)) {
1637       cam_driver_dbg ("%s: Error dqbuf %d\n", __func__, frame_cnt);
1638       return CAM_ERR_SYS;
1639     }
1640
1641     mfld_driver.timestamp = buffer->timestamp;
1642     sem_post(&g_sem_3a);
1643
1644     /* DIS and DVS processing */
1645     if (dis_enabled || mfld_driver.dvs_enabled)
1646       cam_dis_dvs_processing(vectors, bufs, buffer, frame_cnt, dis_enabled);
1647
1648       /* Qbuffer for the DIS */
1649     if (frame_cnt >= 1)
1650       if (-1 == ioctl (fd, VIDIOC_QBUF, buffer)) {
1651         cam_driver_dbg ("%s: Error qbuf %d\n", __func__, frame_cnt);
1652         return CAM_ERR_SYS;
1653       }
1654   }
1655
1656   if (dis_enabled) {
1657     cam_driver_dbg ("Do the still image compose\n");
1658     cam_still_compose (buffer, bufs, frame_dis, vectors);
1659   }
1660
1661   cam_free_bufs (bufs);
1662
1663   /* Still AF processing */
1664   if (mfld_driver.still_af_count) {
1665     gboolean complete = TRUE;           /* AF status */
1666
1667     if (mfld_driver.af_enabled)
1668       complete = mfldadvci->af_is_complete ();
1669
1670    if (complete ||
1671        (calculate_timediff(&mfld_driver.af_start_time, &mfld_driver.timestamp)
1672         > STILL_AF_MAX_TIME_IN_MS) ) {
1673       mfld_driver.focus_done ++;
1674       if(mfld_driver.focus_done >= FOCUS_REALLY_DONE) {
1675         mfld_driver.still_af_count = 0;
1676         if (complete == 0) {
1677           mfldadvci->af_stop();
1678           cam_driver_dbg ("AF: Focus Failed %s\n", __func__);
1679           if(mfld_driver.enable_torch) {
1680             mfld_driver.enable_torch= FALSE;
1681             cam_driver_set_torch(fd, FALSE);
1682           }
1683         }
1684       }
1685       else
1686         mfld_driver.still_af_count++;
1687     } else
1688       mfld_driver.still_af_count++;
1689   }
1690
1691   return CAM_ERR_NONE;
1692 }
1693
1694 cam_err_t
1695 cam_capture_frames (int fd, struct v4l2_buffer *buffer,
1696     struct cam_capture_settings *capture_settings)
1697 {
1698   int index;
1699   int frame_dis = 1, frame_cnt;
1700   cam_err_t ret  = 0;
1701   gboolean flash_en = FALSE;
1702
1703   cam_capture_init (fd, buffer, capture_settings);
1704
1705   if ((mfld_driver.mode == CAM_CAPTURE_MODE_STILL_CAPTURE ) &&
1706       (mfld_driver.sensor_type == SENSOR_TYPE_RAW) ) {
1707       /* check flash here not in always when capturing frames  */
1708       flash_en = get_flash_status ();
1709       // stop still AF processing if running
1710       if (mfld_driver.still_af_count) {
1711          mfldadvci->af_stop();
1712          if(mfld_driver.enable_torch) {
1713             mfld_driver.enable_torch= FALSE;
1714             cam_driver_set_torch(fd, FALSE);
1715           }
1716          mfld_driver.still_af_count = 0;
1717       }
1718       if ((flash_en == TRUE) && (mfld_driver.enable_torch == FALSE)){
1719         run_flash_sequence (fd, buffer);
1720         led_flash_off(fd);
1721       }
1722       else{
1723         //cam_driver_set_indication_intensity(fd, INDICATOR_INTENSITY);
1724         //cam_driver_set_flash_mode(fd,ATOMISP_FLASH_MODE_INDICATOR);
1725         ret = run_normal_sequence(fd, buffer);
1726         /* restore flash mode */
1727         if (mfld_driver.enable_torch == FALSE)
1728           cam_driver_set_flash_mode(fd,ATOMISP_FLASH_MODE_OFF);
1729        }
1730   } else {
1731     ret = run_normal_sequence(fd, buffer);
1732   }
1733   if (ret)
1734     return ret;
1735
1736
1737   if (mfld_driver.rer_enabled && (mfld_driver.fourcc == V4L2_PIX_FMT_YUV420))
1738     cam_do_redeye_removal (buffer);
1739
1740   if (capture_settings->dump_raw)
1741     dump_raw_image (fd, capture_settings);
1742
1743   if (capture_settings->dump_image)
1744     dump_v4l2_buffer(buffer);
1745
1746   return CAM_ERR_NONE;
1747 }
1748
1749 cam_err_t get_ae_windows_num(int fd, int * num)
1750 {
1751   if(ci_adv_Success != mfldadvci->AeGetWindowsNum(num))
1752     return CAM_ERR_3A;
1753
1754   return CAM_ERR_NONE;
1755 }
1756
1757 void get_awb_version(int fd, int * major, int * minor)
1758 {
1759   mfldadvci->AwbVersion(major, minor);
1760 }
1761
1762 void get_ae_version(int fd, int * major, int * minor)
1763 {
1764   mfldadvci->AeVersion(major, minor);
1765 }
1766
1767 void get_af_version(int fd, int * major, int * minor)
1768 {
1769   mfldadvci->AfVersion(major, minor);
1770 }
1771
1772 cam_err_t cam_get_focus_posi(int fd, unsigned * posi)
1773 {
1774   return cam_driver_get_focus_posi(fd, posi);
1775 }
1776
1777 void get_af_result(int fd, unsigned * result)
1778 {
1779   *result = mfld_driver.af_result;  // 0 means fail, it will be filled when captured finished.
1780 }
1781
1782 cam_err_t get_af_status(int fd, unsigned * status)
1783 {
1784   advci_af_status st;
1785
1786
1787   mfldadvci->AfGetStillAfStatus(&st);
1788
1789   if(advci_af_status_success == st)
1790     *status = 1;
1791   else
1792     *status = 0;
1793
1794   return CAM_ERR_NONE;
1795 }
1796
1797 cam_err_t get_exp_mode(int fd, cam_scene_mode_t *expmode)
1798 {
1799   advci_ae_exposure_program mode;
1800
1801   mfldadvci->AeGetExposureProgram(&mode);
1802
1803   /* Convert AE flicker mode to camera general flicker mode */
1804   switch (mode) {
1805     case advci_ae_exposure_program_auto:
1806       *expmode = CAM_GENERAL_SCENE_MODE_AUTO;
1807       break;
1808     case advci_ae_exposure_program_portrait:
1809       *expmode = CAM_GENERAL_SCENE_MODE_PORTRAIT;
1810       break;
1811     case advci_ae_exposure_program_sports:
1812       *expmode = CAM_GENERAL_SCENE_MODE_SPORT;
1813       break;
1814     case advci_ae_exposure_program_landscape:
1815       *expmode = CAM_GENERAL_SCENE_MODE_LANDSCAPE;
1816       break;
1817     case advci_ae_exposure_program_night:
1818       *expmode = CAM_GENERAL_SCENE_MODE_NIGHT;
1819       break;
1820     case advci_ae_exposure_program_fireworks:
1821       *expmode = CAM_GENERAL_SCENE_MODE_FIREWORKS;
1822       break;
1823     default:
1824       cam_driver_dbg ("Not supported exposure mode\n");
1825       return CAM_ERR_UNSUPP;
1826   }
1827
1828   return CAM_ERR_NONE;
1829 }
1830
1831 void get_ae_bias(int fd, int * bias)
1832 {
1833   mfldadvci->AeGetBias(bias);
1834 }
1835
1836 void get_rer_status(int fd, int * status)
1837 {
1838   *status = mfld_driver.rer_enabled;
1839 }
1840
1841 void get_rer_version(int fd, int * major, int * minor)
1842 {
1843   mfldadvci->RerVersion(major, minor);
1844 }
1845
1846 cam_err_t get_ae_manual_shutter(int fd, int * time)
1847 {
1848   if(ci_adv_Success != mfldadvci->AeGetManualShutter(time))
1849     return CAM_ERR_3A;
1850
1851   return CAM_ERR_NONE;
1852 }
1853
1854 cam_err_t get_awb_data(int fd, unsigned * num_p, unsigned * avg_r,
1855                         unsigned * avg_gr, unsigned * avg_b, unsigned * avg_gb)
1856 {
1857   mfldadvci->Awbdata(num_p, avg_r, avg_gr, avg_b, avg_gb);
1858   return CAM_ERR_NONE;
1859 }
1860
1861 cam_err_t get_ae_manual_aperture(int fd, int *aperture)
1862 {
1863
1864   mfldadvci->AeGetManualAperture(aperture);
1865
1866   return CAM_ERR_NONE;
1867 }
1868
1869 cam_err_t get_ae_flash_mode(int fd, cam_flash_mode_t *mode)
1870 {
1871   cam_flash_mode_t ci_mode;
1872
1873   mfldadvci->AeGetFlashMode(&ci_mode);
1874
1875   switch(ci_mode)
1876   {
1877     case advci_ae_flash_mode_auto:
1878       *mode = CAM_LIGHT_FLASH_MODE_AUTO;
1879       break;
1880     case advci_ae_flash_mode_off:
1881       *mode = CAM_LIGHT_FLASH_MODE_OFF;
1882       break;
1883     case advci_ae_flash_mode_on:
1884       *mode = CAM_LIGHT_FLASH_MODE_ON;
1885       break;
1886     case advci_ae_flash_mode_day_sync:
1887       *mode = CAM_LIGHT_FLASH_MODE_AUTO;
1888       break;
1889     case advci_ae_flash_mode_slow_sync:
1890       *mode = CAM_LIGHT_FLASH_MODE_AUTO;
1891       break;
1892     default:
1893       *mode = CAM_LIGHT_FLASH_MODE_AUTO;
1894       return CAM_ERR_3A;
1895   }
1896   return CAM_ERR_NONE;
1897 }
1898 cam_err_t set_ae_flash_mode(int fd, cam_flash_mode_t mode)
1899 {
1900   advci_ae_flash_mode flash_mode;
1901
1902   switch(mode)
1903   {
1904     case CAM_LIGHT_FLASH_MODE_AUTO:
1905       flash_mode = advci_ae_flash_mode_auto;
1906       break;
1907     case CAM_LIGHT_FLASH_MODE_OFF:
1908       flash_mode = advci_ae_flash_mode_off;
1909       break;
1910     case CAM_LIGHT_FLASH_MODE_ON:
1911       flash_mode = advci_ae_flash_mode_on;
1912       break;
1913     default:
1914       flash_mode = advci_ae_flash_mode_auto;
1915       break;
1916   }
1917
1918   mfldadvci->AeSetFlashMode(flash_mode);
1919
1920   return CAM_ERR_NONE;
1921 }
1922
1923
1924 cam_err_t get_awb_manual_color_temperature(int fd, int *ctemp)
1925 {
1926   mfldadvci->AwbGetManualColorTemperature(ctemp);
1927   return CAM_ERR_NONE;
1928 }
1929
1930 void get_awb_matrix(int fd, int msqWbGain[3],
1931                                     int msqCcMtrx[9], unsigned short *shift)
1932 {
1933 //int msqWbGain[3]; /* White balance Gain [0]:R [1]:G [2]:B */
1934 //int msqCcMtrx[9]; /* Color adjustment Matrix */
1935   mfldadvci->Awbmatrix(msqWbGain, msqCcMtrx, shift);
1936 }
1937
1938 struct sh_css_grid_info_maker_note {
1939         /* 3A statistics grid: */
1940         unsigned int s3a_width;
1941         unsigned int s3a_height;
1942         unsigned int s3a_bqs_per_grid_cell;
1943         /* DIS grid: */
1944         unsigned int dis_width;  /* also used for vertical projections */
1945         unsigned int dis_height; /* also used for horizontal projections */
1946         unsigned int dis_bqs_per_grid_cell;
1947         unsigned int dis_hor_coef_num;
1948         unsigned int dis_ver_coef_num;
1949 };
1950
1951 void get_grid_info(int fd, unsigned * width, unsigned * height)
1952 {
1953   struct sh_css_grid_info_maker_note grid;
1954
1955   mfldadvci->GetGridInfo(&grid);
1956   *width = grid.s3a_width;
1957   *height = grid.s3a_height;
1958 }
1959