apps/php-5.2.1/ext/elphel/elphel_php.c

Go to the documentation of this file.

/*!***************************************************************************
*! FILE NAME  : elphel_php.c
*! DESCRIPTION: Implementation of elphel extension module for PHP
*! Copyright (C) 2002-2007 Elphel, Inc.
*! -----------------------------------------------------------------------------**
*!  This program is free software: you can redistribute it and/or modify
*!  it under the terms of the GNU General Public License as published by
*!  the Free Software Foundation, either version 3 of the License, or
*!  (at your option) any later version.
*!
*!  This program is distributed in the hope that it will be useful,
*!  but WITHOUT ANY WARRANTY; without even the implied warranty of
*!  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*!  GNU General Public License for more details.
*!
*!  You should have received a copy of the GNU General Public License
*!  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*! -----------------------------------------------------------------------------**
*!  $Log: elphel_php.c,v $
*!  Revision 1.21  2008/05/02 15:12:09  elphel
*!  minor comment edit
*!
*!  Revision 1.20  2008/05/01 01:32:04  elphel
*!  support for the frame number - combining hardware frame counter used by i2c (3-bit) and software one
*!
*!  Revision 1.19  2008/04/25 21:31:35  elphel
*!  Added Exif_Photo_ExposureTime to be returned by elphel_get_exif_elphel()
*!
*!  Revision 1.18  2008/04/24 18:16:40  elphel
*!  New function to retrieve circbuf structure (frame pointers and Exif pointers)
*!
*!  Revision 1.17  2008/04/22 22:14:08  elphel
*!  Added functions related to Exif data
*!
*!  Revision 1.16  2008/04/20 06:49:04  elphel
*!  Added histogram related functions
*!
*!  Revision 1.15  2008/04/17 22:36:07  elphel
*!  Bug fix, new function added - elphel_is_compressor_idle()
*!
*!  Revision 1.14  2008/03/20 22:25:09  elphel
*!  elphel_trigger - programming synchronization parameters
*!
*!  Revision 1.13  2008/03/15 23:04:21  elphel
*!  added FPGA registers R/W
*!
*!  Revision 1.12  2008/01/27 06:23:17  elphel
*!  New function - elphel_wait_frame (wait fro the next frame to be compressed)
*!
*!  Revision 1.11  2008/01/12 06:53:23  elphel
*!  7.1.7.2 - added elphel_autoexposure_get() function to elphel php extension
*!
*!  Revision 1.10  2008/01/11 07:47:44  elphel
*!  added elphel_autoexposure_set() function
*!
*!  Revision 1.9  2008/01/10 02:43:37  elphel
*!  Added balance of 2 greens in Bayer mosaic
*!
*!  Revision 1.8  2008/01/09 10:22:02  elphel
*!  Implemented elphel_white_balance() function
*!
*!  Revision 1.7  2007/12/14 22:38:53  elphel
*!  cleaned up after fixing cache bug
*!
*!  Revision 1.6  2007/12/06 19:05:33  elphel
*!  2 new functions - arbitrary compressor command (elphel_compressor_cmd) and elphel_compressor_reset
*!
*!  Revision 1.5  2007/12/05 23:41:04  elphel
*!  Fixing minor in bugs in the sensor reset code
*!
*!  Revision 1.4  2007/12/05 22:01:19  elphel
*!  added handling etrax fs mmap cach problem when communicating between PHP extension and the driver
*!
*!  Revision 1.3  2007/12/04 06:41:11  elphel
*!  Implementation of 2 additional functions:    elphel_get_P_arr, elphel_set_P_arr
*!
*/

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <sys/mman.h>           /* mmap */
#include <sys/ioctl.h>
#include <fcntl.h>     /* (O_RDWR) */
#include <asm/byteorder.h>
#include <errno.h>

#include "php.h"
#include "php_ini.h"  /* for php.ini processing */
#include "elphel_php.h"


ZEND_DECLARE_MODULE_GLOBALS(elphel)
static function_entry elphel_functions[] = {
    PHP_FE(elph_hello, NULL)
    PHP_FE(elphel_get_P_value, NULL)
    PHP_FE(elphel_set_P_value, NULL)
    PHP_FE(elphel_get_P_arr, NULL)
    PHP_FE(elphel_get_P_warr, NULL)
    PHP_FE(elphel_set_P_arr, NULL)
    PHP_FE(elphel_get_state, NULL)
    PHP_FE(elphel_program_sensor, NULL)
    PHP_FE(elphel_compressor_cmd, NULL)
    PHP_FE(elphel_compressor_reset, NULL)
    PHP_FE(elphel_compressor_run, NULL)
    PHP_FE(elphel_compressor_stop, NULL)
    PHP_FE(elphel_compressor_frame, NULL)
    PHP_FE(elphel_is_compressor_idle, NULL)
    PHP_FE(elphel_reset_sensor, NULL)
    PHP_FE(elphel_set_fpga_time, NULL)
    PHP_FE(elphel_get_fpga_time, NULL)
    PHP_FE(elphel_white_balance, NULL)
    PHP_FE(elphel_autoexposure_set, NULL)
    PHP_FE(elphel_autoexposure_get, NULL)
    PHP_FE(elphel_wait_frame, NULL)
    PHP_FE(elphel_fpga_read, NULL)
    PHP_FE(elphel_fpga_write, NULL)
    PHP_FE(elphel_trigger, NULL)
    PHP_FE(elphel_flush_cache, NULL)
    PHP_FE(elphel_gamma, NULL)
    PHP_FE(elphel_histogram, NULL)
    PHP_FE(elphel_get_gamma, NULL)
    PHP_FE(elphel_get_histogram, NULL)
    PHP_FE(elphel_get_exif_field, NULL)
    PHP_FE(elphel_set_exif_field, NULL)
    PHP_FE(elphel_get_exif_elphel, NULL)
    PHP_FE(elphel_update_exif, NULL)
    PHP_FE(elphel_get_circbuf_pointers, NULL)
    {NULL, NULL, NULL}
};

zend_module_entry elphel_module_entry = {
#if ZEND_MODULE_API_NO >= 20010901
    STANDARD_MODULE_HEADER,
#endif
    PHP_ELPHEL_EXTNAME,
    elphel_functions,
    PHP_MINIT(elphel),
    PHP_MSHUTDOWN(elphel),
    PHP_RINIT(elphel),
    NULL,
    PHP_MINFO(elphel),
#if ZEND_MODULE_API_NO >= 20010901
    PHP_ELPHEL_VERSION,
#endif
    STANDARD_MODULE_PROPERTIES
};

#ifdef COMPILE_DL_ELPHEL
ZEND_GET_MODULE(elphel)
#endif


PHP_INI_BEGIN()
PHP_INI_END()


static void init_sens() {
  if ((((long *) ELPHEL_G(imageParamsR)) [P_SENSOR])==0)  lseek((int) ELPHEL_G( fd_sens), LSEEK_INIT_SENSOR , SEEK_END );
}

PHP_FUNCTION(elphel_flush_cache)
{
  lseek((int)ELPHEL_G(fd_sens),LSEEK_FLUSH_CACHE, SEEK_END);
  RETURN_NULL();
}

long createExifDirectory (int rebuild) { 
     int indx;
     long numfields=0;
     struct exif_dir_table_t dir_table_entry;
     int exif_this_size=lseek((int) ELPHEL_G(fd_exifdir),1,SEEK_END); // at the beginning of page 1 - position == page length

     if ((ELPHEL_G(exif_size) == exif_this_size) && !rebuild) return 0; // no need to rebuild
     ELPHEL_G(exif_size) = exif_this_size;

     for (indx=0; indx<ExifKmlNumber; indx++) ELPHEL_G(exif_dir)[indx].ltag=0;
     while (read((int) ELPHEL_G(fd_exifdir), &dir_table_entry, sizeof(dir_table_entry))>0) {
       switch (dir_table_entry.ltag) {
         case Exif_Image_ImageDescription:      indx= Exif_Image_ImageDescription_Index; break;
         case Exif_Image_FrameNumber:           indx= Exif_Image_FrameNumber_Index; break;
         case Exif_Photo_DateTimeOriginal:      indx= Exif_Photo_DateTimeOriginal_Index; break;
         case Exif_Photo_SubSecTimeOriginal:    indx= Exif_Photo_SubSecTimeOriginal_Index; break;
         case Exif_Photo_ExposureTime:          indx= Exif_Photo_ExposureTime_Index; break;
         case Exif_GPSInfo_GPSLatitudeRef:      indx= Exif_GPSInfo_GPSLatitudeRef_Index; break;
         case Exif_GPSInfo_GPSLatitude:         indx= Exif_GPSInfo_GPSLatitude_Index ; break;
         case Exif_GPSInfo_GPSLongitudeRef:     indx= Exif_GPSInfo_GPSLongitudeRef_Index ; break;
         case Exif_GPSInfo_GPSLongitude:        indx= Exif_GPSInfo_GPSLongitude_Index; break;
         case Exif_GPSInfo_GPSAltitudeRef:      indx= Exif_GPSInfo_GPSAltitudeRef_Index; break;
         case Exif_GPSInfo_GPSAltitude:         indx= Exif_GPSInfo_GPSAltitude_Index; break;
         case Exif_GPSInfo_GPSTimeStamp:        indx= Exif_GPSInfo_GPSTimeStamp_Index; break;
         case Exif_GPSInfo_GPSDateStamp:        indx= Exif_GPSInfo_GPSDateStamp_Index; break;
         case Exif_GPSInfo_GPSMeasureMode:      indx= Exif_GPSInfo_GPSMeasureMode_Index; break;
         case Exif_GPSInfo_CompassDirectionRef: indx= Exif_GPSInfo_CompassDirectionRef_Index; break;
         case Exif_GPSInfo_CompassDirection:    indx= Exif_GPSInfo_CompassDirection_Index; break;
         case Exif_GPSInfo_CompassPitchRef:     indx= Exif_GPSInfo_CompassPitchRef_Index; break;
         case Exif_GPSInfo_CompassPitch:        indx= Exif_GPSInfo_CompassPitch_Index; break;
         case Exif_GPSInfo_CompassRollRef:      indx= Exif_GPSInfo_CompassRollRef_Index; break;
         case Exif_GPSInfo_CompassRoll:         indx= Exif_GPSInfo_CompassRoll_Index; break;
         default: indx=-1;
       }
       if (indx>=0) {
           memcpy(&(ELPHEL_G(exif_dir)[indx]),&dir_table_entry,sizeof(dir_table_entry));
           numfields++;
       }
     }
  return numfields;
}


//  add_assoc_long(return_value, key, ((long *) ELPHEL_G(imageParamsR))[ Z_LVAL(const_value)]);


PHP_FUNCTION(elphel_get_circbuf_pointers) {
    char * ccam_dma_buf_char= (char *) ELPHEL_G( ccam_dma_buf);
    long second=0;
    long p,frameParamPointer;
    long buff_size=lseek(ELPHEL_G( fd_circ),0,SEEK_END); //size of circbuf

    zval *image_pointers;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &second) == FAILURE) {
        RETURN_NULL();
    }
    p=lseek((int) ELPHEL_G( fd_circ), second? CIRCLSEEK_SCND: CIRCLSEEK_FIRST, SEEK_END );
    if (p<0) RETURN_NULL();
    array_init(return_value);
    while (p>=0) {
      frameParamPointer=p-32;
      if (frameParamPointer<0) frameParamPointer+=buff_size;
      ALLOC_INIT_ZVAL(image_pointers);
      array_init(image_pointers);
      add_assoc_long(image_pointers, "circbuf_pointer", p);
      add_assoc_long(image_pointers, "exif_pointer", ((struct frame_params_t *) &ccam_dma_buf_char[frameParamPointer])->meta_index);
      add_next_index_zval(return_value, image_pointers);
      p=lseek((int) ELPHEL_G( fd_circ), CIRCLSEEK_NEXT, SEEK_END );
      p=lseek((int) ELPHEL_G( fd_circ), CIRCLSEEK_READY, SEEK_END );

    }
}


#define saferead255(f,d,l) read(f,d,((l)<256)?(l):255)
PHP_FUNCTION(elphel_get_exif_elphel)
{
    long rational3[6];
    long exif_page_start;
    char *key;
    long indx;
    char val[256];
    long exif_page=0;
    int hours=0, minutes=0;
    double seconds=0.0;
    double  longitude=0.0, latitude=0.0,  altitude=0.0,  heading=0.0,  roll=0.0, pitch=0.0, exposure=0.0;
    val[255]='\0';
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &exif_page) == FAILURE) {
        RETURN_NULL();
    }

    createExifDirectory(0); 
    if (exif_page) exif_page_start=lseek ((int) ELPHEL_G(fd_exif), exif_page, SEEK_END); 
    else           exif_page_start=lseek ((int) ELPHEL_G(fd_exif), 0, SEEK_SET); 
    if (exif_page_start<0) RETURN_NULL(); //exif_page may be out of range
    array_init(return_value);



     if (ELPHEL_G(exif_dir)[Exif_Image_ImageDescription_Index].ltag==Exif_Image_ImageDescription) { // Exif_Image_ImageDescription is present in template
       lseek (ELPHEL_G(fd_exif),
              exif_page_start+ELPHEL_G(exif_dir)[Exif_Image_ImageDescription_Index].dst,
              SEEK_SET);
       saferead255(ELPHEL_G(fd_exif), val, ELPHEL_G(exif_dir)[Exif_Image_ImageDescription_Index].len);
       add_assoc_string(return_value, "ImageDescription", val,  1);
     }
     if (ELPHEL_G(exif_dir)[Exif_Image_FrameNumber_Index].ltag==Exif_Image_FrameNumber) { // Exif_Image_FrameNumber_Index is present in template
       lseek (ELPHEL_G(fd_exif),
              exif_page_start+ELPHEL_G(exif_dir)[Exif_Image_FrameNumber_Index].dst,
              SEEK_SET);
       read(ELPHEL_G(fd_exif), rational3, 4);
       sprintf (val,"%ld", (long) __cpu_to_be32( rational3[0]));
       add_assoc_string(return_value, "FrameNumber", val,  1);
     }

     if (ELPHEL_G(exif_dir)[Exif_Photo_DateTimeOriginal_Index].ltag==Exif_Photo_DateTimeOriginal) {
       lseek (ELPHEL_G(fd_exif),
              exif_page_start+ELPHEL_G(exif_dir)[Exif_Photo_DateTimeOriginal_Index].dst,
              SEEK_SET);
       read(ELPHEL_G(fd_exif), val, 19);
       val[19]='\0';
       if (ELPHEL_G(exif_dir)[Exif_Photo_SubSecTimeOriginal_Index].ltag==Exif_Photo_SubSecTimeOriginal) {
         val[19]='.';
         lseek (ELPHEL_G(fd_exif),
                exif_page_start+ELPHEL_G(exif_dir)[Exif_Photo_SubSecTimeOriginal_Index].dst,
                SEEK_SET);
         read(ELPHEL_G(fd_exif), &val[20], 7);
         val[27]='\0';
       }
       add_assoc_string(return_value, "DateTimeOriginal", val,  1);
     }

     if (ELPHEL_G(exif_dir)[Exif_Photo_ExposureTime_Index].ltag==Exif_Photo_ExposureTime) { // Exif_Photo_ExposureTime is present in template
       lseek (ELPHEL_G(fd_exif),
              exif_page_start+ELPHEL_G(exif_dir)[Exif_Photo_ExposureTime_Index].dst,
              SEEK_SET);
       read(ELPHEL_G(fd_exif), rational3, 8);
       exposure=(1.0*__cpu_to_be32( rational3[0]))/__cpu_to_be32( rational3[1]);
       sprintf (val,"%f",exposure);
       add_assoc_string(return_value, "ExposureTime", val,  1);
     }


     if (ELPHEL_G(exif_dir)[Exif_GPSInfo_GPSMeasureMode_Index].ltag==Exif_GPSInfo_GPSMeasureMode) {
       lseek (ELPHEL_G(fd_exif),
              exif_page_start+ELPHEL_G(exif_dir)[Exif_GPSInfo_GPSMeasureMode_Index].dst,
              SEEK_SET);
       read(ELPHEL_G(fd_exif), val, 1);
       add_assoc_stringl(return_value, "GPSMeasureMode", val, 1,  1);
     }

     if (ELPHEL_G(exif_dir)[Exif_GPSInfo_GPSDateStamp_Index].ltag==Exif_GPSInfo_GPSDateStamp) {
       lseek (ELPHEL_G(fd_exif),
              exif_page_start+ELPHEL_G(exif_dir)[Exif_GPSInfo_GPSDateStamp_Index].dst,
              SEEK_SET);
       read(ELPHEL_G(fd_exif), val, 10);
       val[10]='\0';
       if (ELPHEL_G(exif_dir)[Exif_GPSInfo_GPSTimeStamp_Index].ltag==Exif_GPSInfo_GPSTimeStamp) {
         lseek (ELPHEL_G(fd_exif),
                exif_page_start+ELPHEL_G(exif_dir)[Exif_GPSInfo_GPSTimeStamp_Index].dst,
                SEEK_SET);
         read(ELPHEL_G(fd_exif), rational3, 24);
         hours=   __cpu_to_be32( rational3[0]);
         minutes= __cpu_to_be32( rational3[2]);
         seconds= (1.0*(__cpu_to_be32( rational3[4])+1))/__cpu_to_be32( rational3[5]); 
         sprintf (&val[10]," %02d:%02d:%05.2f",hours,minutes,seconds);
       }
       add_assoc_string(return_value, "GPSDateTime", val,  1);
     }

     if (ELPHEL_G(exif_dir)[Exif_GPSInfo_GPSLongitude_Index].ltag==Exif_GPSInfo_GPSLongitude) { // Exif_GPSInfo_GPSLongitude is present in template
       lseek (ELPHEL_G(fd_exif),
              exif_page_start+ELPHEL_G(exif_dir)[Exif_GPSInfo_GPSLongitude_Index].dst,
              SEEK_SET);
       read(ELPHEL_G(fd_exif), rational3, 24);
       longitude=__cpu_to_be32( rational3[0])/(1.0*__cpu_to_be32( rational3[1])) + __cpu_to_be32( rational3[2])/(60.0*__cpu_to_be32( rational3[3]));
       if (ELPHEL_G(exif_dir)[Exif_GPSInfo_GPSLongitudeRef_Index].ltag==Exif_GPSInfo_GPSLongitudeRef) {
         lseek (ELPHEL_G(fd_exif),
            exif_page_start+ELPHEL_G(exif_dir)[Exif_GPSInfo_GPSLongitudeRef_Index].dst,
            SEEK_SET);
         read(ELPHEL_G(fd_exif), val, 1);
         if (val[0]!= 'E') longitude=-longitude;
       }
       sprintf (val,"%f",longitude);
       add_assoc_string(return_value, "GPSLongitude", val,  1);
     }
     if (ELPHEL_G(exif_dir)[Exif_GPSInfo_GPSLatitude_Index].ltag==Exif_GPSInfo_GPSLatitude) { // Exif_GPSInfo_GPSLatitude is present in template
       lseek (ELPHEL_G(fd_exif),
              exif_page_start+ELPHEL_G(exif_dir)[Exif_GPSInfo_GPSLatitude_Index].dst,
              SEEK_SET);
       read(ELPHEL_G(fd_exif), rational3, 24);
       latitude=__cpu_to_be32( rational3[0])/(1.0*__cpu_to_be32( rational3[1])) + __cpu_to_be32( rational3[2])/(60.0*__cpu_to_be32( rational3[3]));
       if (ELPHEL_G(exif_dir)[Exif_GPSInfo_GPSLatitudeRef_Index].ltag==Exif_GPSInfo_GPSLatitudeRef) {
         lseek (ELPHEL_G(fd_exif),
            exif_page_start+ELPHEL_G(exif_dir)[Exif_GPSInfo_GPSLatitudeRef_Index].dst,
            SEEK_SET);
         read(ELPHEL_G(fd_exif), val, 1);
         if (val[0] != 'N') latitude=-latitude;
        }
       sprintf (val,"%f",latitude);
       add_assoc_string(return_value, "GPSLatitude", val,  1);
     }
     if (ELPHEL_G(exif_dir)[Exif_GPSInfo_GPSAltitude_Index].ltag==Exif_GPSInfo_GPSAltitude) { // Exif_GPSInfo_GPSAltitude is present in template
       lseek (ELPHEL_G(fd_exif),
              exif_page_start+ELPHEL_G(exif_dir)[Exif_GPSInfo_GPSAltitude_Index].dst,
              SEEK_SET);
       read(ELPHEL_G(fd_exif), rational3, 8);
       altitude=(1.0*__cpu_to_be32( rational3[0]))/__cpu_to_be32( rational3[1]);

       if (ELPHEL_G(exif_dir)[Exif_GPSInfo_GPSAltitudeRef_Index].ltag==Exif_GPSInfo_GPSAltitudeRef) {
         lseek (ELPHEL_G(fd_exif),
            exif_page_start+ELPHEL_G(exif_dir)[Exif_GPSInfo_GPSAltitudeRef_Index].dst,
            SEEK_SET);
         read(ELPHEL_G(fd_exif), val, 1);
         if (val[0] != '\0') altitude=-altitude;
        }
       sprintf (val,"%f",altitude);
       add_assoc_string(return_value, "GPSAltitude", val,  1);
     }
     if (ELPHEL_G(exif_dir)[Exif_GPSInfo_CompassDirection_Index].ltag==Exif_GPSInfo_CompassDirection) { // Exif_GPSInfo_CompassDirection is present in template
       lseek (ELPHEL_G(fd_exif),
              exif_page_start+ELPHEL_G(exif_dir)[Exif_GPSInfo_CompassDirection_Index].dst,
              SEEK_SET);
       read(ELPHEL_G(fd_exif), rational3, 8);
       heading=(1.0*__cpu_to_be32( rational3[0]))/__cpu_to_be32( rational3[1]);
       sprintf (val,"%f",heading);
       add_assoc_string(return_value, "CompassDirection", val,  1);
     }
     if (ELPHEL_G(exif_dir)[Exif_GPSInfo_CompassRoll_Index].ltag==Exif_GPSInfo_CompassRoll) { // Exif_GPSInfo_CompassRoll is present in template
       lseek (ELPHEL_G(fd_exif),
              exif_page_start+ELPHEL_G(exif_dir)[Exif_GPSInfo_CompassRoll_Index].dst,
              SEEK_SET);
       read(ELPHEL_G(fd_exif), rational3, 8);
       roll=(1.0*__cpu_to_be32( rational3[0]))/__cpu_to_be32( rational3[1]);

       if (ELPHEL_G(exif_dir)[Exif_GPSInfo_CompassRollRef_Index].ltag==Exif_GPSInfo_CompassRollRef) {
         lseek (ELPHEL_G(fd_exif),
            exif_page_start+ELPHEL_G(exif_dir)[Exif_GPSInfo_CompassRollRef_Index].dst,
            SEEK_SET);
         read(ELPHEL_G(fd_exif), val, 1);
         if (val[0] != EXIF_COMPASS_ROLL_ASCII[0]) roll=-roll;
        }
       sprintf (val,"%f",roll);
       add_assoc_string(return_value, "CompassRoll", val,  1);
     }

     if (ELPHEL_G(exif_dir)[Exif_GPSInfo_CompassPitch_Index].ltag==Exif_GPSInfo_CompassPitch) { // Exif_GPSInfo_CompassPitch is present in template
       lseek (ELPHEL_G(fd_exif),
              exif_page_start+ELPHEL_G(exif_dir)[Exif_GPSInfo_CompassPitch_Index].dst,
              SEEK_SET);
       read(ELPHEL_G(fd_exif), rational3, 8);
       pitch=(1.0*__cpu_to_be32( rational3[0]))/__cpu_to_be32( rational3[1]);

       if (ELPHEL_G(exif_dir)[Exif_GPSInfo_CompassPitchRef_Index].ltag==Exif_GPSInfo_CompassPitchRef) {
         lseek (ELPHEL_G(fd_exif),
            exif_page_start+ELPHEL_G(exif_dir)[Exif_GPSInfo_CompassPitchRef_Index].dst,
            SEEK_SET);
         read(ELPHEL_G(fd_exif), val, 1);
         if (val[0] != EXIF_COMPASS_PITCH_ASCII[0]) pitch=-pitch;
        }
       sprintf (val,"%f",pitch);
       add_assoc_string(return_value, "CompassPitch", val,  1);
     }

}


PHP_FUNCTION(elphel_update_exif) {
    RETURN_LONG(createExifDirectory(1)); // force rebuild
}


PHP_FUNCTION(elphel_get_exif_field)
{
    long exif_page=0;
    long ltag;
    struct exif_dir_table_t dir_table_entry;
    char * rslt;
    int found=0;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|l", &ltag, &exif_page) == FAILURE) {
        RETURN_NULL();
    }
// find the ltag in the directory (may need to scan all the directory)
    lseek ((int) ELPHEL_G(fd_exifdir), 0, SEEK_SET);
    while (read((int) ELPHEL_G(fd_exifdir), &dir_table_entry, sizeof(dir_table_entry))>0) {
      if (dir_table_entry.ltag==ltag) {
        found=1;
        break;
      }
    }
    if (!found) RETURN_NULL();
//    lseek (fd_exifdir, 0, SEEK_SET);
    if (exif_page) found= lseek ((int) ELPHEL_G(fd_exif), exif_page, SEEK_END); 
    else           found= lseek ((int) ELPHEL_G(fd_exif), 0, SEEK_SET); 
    if (found<0) RETURN_NULL(); //exif_page may be out of range

    lseek ((int) ELPHEL_G(fd_exif), dir_table_entry.dst, SEEK_CUR);
    rslt=emalloc(dir_table_entry.len);
    read((int) ELPHEL_G(fd_exif), rslt, dir_table_entry.len);
    RETURN_STRINGL(rslt,dir_table_entry.len,0);
}



PHP_FUNCTION(elphel_set_exif_field)
{
    
    long ltag;
    struct exif_dir_table_t dir_table_entry;
    char * value;
    int value_length;
    int found=0;
    
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ls", &ltag, &value,&value_length) == FAILURE) {
        RETURN_NULL();
    }
// find the ltag in the directory (may need to scan all the directory)
    lseek ((int) ELPHEL_G(fd_exifdir), 0, SEEK_SET);
    while (read((int) ELPHEL_G(fd_exifdir), &dir_table_entry, sizeof(dir_table_entry))>0) {
      if (dir_table_entry.ltag==ltag) {
        found=1;
        break;
      }
    }
    if (!found) RETURN_NULL();
    lseek ((int) ELPHEL_G(fd_exifmeta), dir_table_entry.src, SEEK_SET);
    if (value_length>dir_table_entry.len) value_length = dir_table_entry.len;
// php_printf ("value=%s, value_length=%d\n",value, value_length);
    long rslt=write(ELPHEL_G(fd_exifmeta), value, value_length);
    if (rslt<0) rslt =-errno;
    RETURN_LONG(rslt);
}


PHP_FUNCTION(elph_hello)
{
    DEFINE_P_NAMES(pname_arr);
    int i;
//    init_sens(); // to see w/o sensor initialization
    array_init(return_value);
    for (i=0;i< (sizeof(pname_arr)/sizeof(pname_arr[0])); i++) {
//      add_assoc_long(return_value, pname_arr[i].name, pname_arr[i].value);
      add_assoc_long(return_value, pname_arr[i].name, ((long *) ELPHEL_G(imageParamsR))[pname_arr[i].value]);
    }
}
PHP_FUNCTION(elphel_wait_frame)
{
    lseek((int) ELPHEL_G( fd_circ), CIRCLSEEK_TOWP, SEEK_END );
    lseek((int) ELPHEL_G( fd_circ), CIRCLSEEK_WAIT, SEEK_END );
    RETURN_NULL();
}

PHP_FUNCTION(elphel_autoexposure_set)
{
    lseek((int) ELPHEL_G( fd_sens), LSEEK_AUTOEXP_SET, SEEK_END );
    RETURN_NULL();
} 

PHP_FUNCTION(elphel_autoexposure_get)
{
    lseek((int) ELPHEL_G( fd_sens), LSEEK_AUTOEXP_GET, SEEK_END );
    RETURN_NULL();
} 


#define HIST_LEN  256 * 4 * 4
#define GAMMA_LEN 256 * 4 * 2
//  memcpy (hists, ELPHEL_G(hist_gamma_mmap), HIST_LEN);
//  memcpy (gammas,ELPHEL_G(hist_gamma_mmap) + HIST_LEN, GAMMA_LEN);
//histogram values are 18-bit onex, gamma - unsigned short 0..0xffff

PHP_FUNCTION(elphel_get_histogram)
{
    long addr;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &addr) == FAILURE) {
        RETURN_NULL();
    }
    if ((addr > 1023) || (addr <0)) {
        RETURN_NULL();
    }
    RETURN_LONG(  ((long *) ELPHEL_G(hist_gamma_mmap))[addr]);
} 
PHP_FUNCTION(elphel_get_gamma)
{
    long addr;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &addr) == FAILURE) {
        RETURN_NULL();
    }
    if ((addr > 1023) || (addr <0)) {
        RETURN_NULL();
    }
    RETURN_LONG(  ((unsigned short *) ELPHEL_G(hist_gamma_mmap))[addr+(HIST_LEN>>1)]);
} 


PHP_FUNCTION(elphel_gamma)
{
  unsigned short gamma[256];
    long   channel;
    double indat,outdat;
    int indx;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ld", &channel, &indat ) == FAILURE) {
        RETURN_LONG (-1);
    }
    if ((channel <0) || (channel > 3)) RETURN_LONG (-1); 


    memcpy (gamma,ELPHEL_G(hist_gamma_mmap) + HIST_LEN + ((GAMMA_LEN>>2)*channel), (GAMMA_LEN>>2)); // one color only
    indat*=255.0;
    indx=indat;
    if      (indx < 0)   outdat=0.0;
    else if (indx >=255) outdat=1.0;
    else     outdat=(gamma[indx]+ (gamma[indx+1]-gamma[indx])*(indat-indx))*(1.0/65535);
    RETURN_DOUBLE (outdat);
}

PHP_FUNCTION(elphel_histogram)
{
  unsigned long histogram[256];
    long   channel;
    double indat,outdat;
    int i,d;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ld", &channel, &indat ) == FAILURE) {
        RETURN_LONG (-1);
    }
    if ((channel <0) || (channel > 3)) RETURN_LONG (-1); 

    memcpy (histogram,ELPHEL_G(hist_gamma_mmap) + ((HIST_LEN>>2)*channel), (HIST_LEN>>2)); // one color only
    if (indat <= 0.0) outdat=0.0;
    else if (indat>=1.0) outdat=1.0;
    else {
      for (i=1;i<256;i++) histogram[i]+=histogram[i-1];
      indat*=histogram[255];
      d=indat;
      for (i=0; histogram[i] <= d; i++);
      if (i==0) outdat= ((1.0/255.0)*d)/histogram[0];
      else      outdat= (1.0/255.0)*((i-1)+ (1.0*(d-histogram[i-1])/(histogram[i]-histogram[i-1])));
    }
    RETURN_DOUBLE (outdat);
}

//#define HISTDBG y
//#define HIST_LEN      256 * 4 * 4
//#define GAMMA_LEN     256 * 4 * 2
int calcWhiteBalance(int thrsh,   // threshold (0..255) for the "brightest color"
                     int min_pixels, // minimal number of pixels above threshold for the brightest color (threshold will be lowered to satisfy min_pixels)
                     double diffGains[3], 
                     long use_green2
                     ){
  double colPercentiles[4];
  int hists[1024];
  unsigned short gammas[1024];
//  int retr=10000;
  int sum[4];
  int indx[4];
  int i,j,k,smax;
  int percFound=0;
  memcpy (hists, ELPHEL_G(hist_gamma_mmap), HIST_LEN);
  memcpy (gammas,ELPHEL_G(hist_gamma_mmap) + HIST_LEN, GAMMA_LEN);

#ifdef HISTDBG
  php_printf ("thrsh=%d, min_pixels=%d\n",thrsh, min_pixels);
  for (k=0; k<4; k++) {
    php_printf ("k=%d\n",k);
    for (j=0; j<256; j+=16) {
      php_printf ( "%03x: ",j);
      for (i=j; i<j+16; i++) {
        php_printf ( " %08x: ",hists[256*k+i]);
      }
      php_printf ("\n");
    }
  }

  for (k=0; k<4; k++) {
    php_printf ("k=%d\n",k);
    for (j=0; j<256; j+=16) {
      php_printf ( "%03x: ",j);
      for (i=j; i<j+16; i++) {
        php_printf ( " %04x: ", (int) gammas[256*k+i]);
      }
      php_printf ("\n");
    }
  }
#endif


  for (j=0;j<4;j++) {sum[j]=0;indx[j]=-1;colPercentiles[j]=-1.0;}
  for (i=255;i>=thrsh;i--) for (j=0;j<4;j++)   sum[j]+=hists[i+ (j<<8)];
#ifdef HISTDBG
 php_printf ("sum[0]=%d,  sum[1]=%d,  sum[2]=%d,  sum[3]=%d\n", sum[0], sum[1], sum[2], sum[3]);
#endif
  smax = sum[0];
  for (j=1;j<4;j++) if (sum[j]>smax) smax=sum[j];
  if (smax<min_pixels) {
    for (i=thrsh-1;(i>0) && (smax<min_pixels); i--) { 
      for (j=0;j<4;j++)   sum[j]+=hists[i+ (j<<8)];
      for (j=0;j<4;j++) {
         if (((j!=2) || use_green2) && (sum[j]>smax)) {smax=sum[j];k=j;thrsh=i;}
      }
    }
  }
#ifdef HISTDBG
  php_printf ("thrsh=%d\n",thrsh);
  php_printf ("smax=%d, sum[0]=%d, sum[1]=%d, sum[2]=%d, sum[3]=%d\n",smax, sum[0], sum[1], sum[2], sum[3]);
#endif

  if(smax < min_pixels) return -2; 
  i=0;
  smax=0;
  for (j=0;j<4;j++) if (((j!=2) || use_green2) && (sum[j]>smax)) {smax=sum[j];i=j;}
  indx[i]=thrsh; //colPercentiles[i]=thrsh;
  percFound |= (1<<i);
  for (i=thrsh-1;(i>0) && (percFound != 0xf); i--) { 
    for (j=0;j<4;j++)  if (((j!=2) || use_green2) && !(percFound & (1 <<j))) {
      sum[j] += hists[i+ (j<<8)];
      if (sum[j]>=smax) {
        percFound |= (1<<j);
        indx[j]=i;
      }
    }
  }
#ifdef HISTDBG
  php_printf ("sum[0]=%d,  sum[1]=%d,  sum[2]=%d,  sum[3]=%d\n", sum[0], sum[1], sum[2], sum[3]);
  php_printf ("indx[0]=%d, indx[1]=%d, indx[2]=%d, indx[3]=%d\n", indx[0], indx[1], indx[2], indx[3]);
#endif
  if (!use_green2) percFound |= 0x4; // as if found

  if(percFound != 0xf) return -3; 
  for (j=0;j<4;j++) if ((j!=2) || use_green2) {
    if (sum[j]==smax) colPercentiles[j]=indx[j];
    else colPercentiles[j]= indx[j]+(1.0*(sum[j]-smax))/hists[indx[j]+ (j<<8)];
  }
//TODO: use all 16 bits of gamma? Or actual 10-bit table?
  k=0; // to make gcc happy
  for (j=0;j<4;j++) if ((j!=2) || use_green2) {
    for (i=255;(i>=0) && ((k=((gammas[i+(j<<8)]>>8) & 0xff)) > indx[j]);i--);
    colPercentiles[j]=i+ (colPercentiles[j]-k)/ ( ((gammas[i+1+(j<<8)]>>8) & 0xff) -k);
  }

//  diffGains[0]=(colPercentiles[1]+colPercentiles[2])/2.0/colPercentiles[0];
//  diffGains[1]=(colPercentiles[1]+colPercentiles[2])/2.0/colPercentiles[3];

  diffGains[0]=colPercentiles[1]/colPercentiles[0];
  diffGains[1]=colPercentiles[1]/colPercentiles[3];
  if ((j!=2) || use_green2) diffGains[2]=colPercentiles[1]/colPercentiles[2];

#ifdef HISTDBG
  for (k=0; k<4; k++)  php_printf ("colPercentiles[%d]=%f\n",k,colPercentiles[k]);
  for (k=0; k<3; k++)  php_printf ("diffGains[%d]=%f\n",k,diffGains[k]);
#endif
  return 0; 
}
PHP_FUNCTION(elphel_white_balance)
{
    double thrsh=   0.98;
    double minfrac =0.01;
    double rscale=  1.0;
    double bscale=  1.0;
    double corr_factor=1.0; // correct less than calculated (to smooth scene variations)
    int ithrsh, minpix;
    double wbDiffGains[3]; 
    long   corr_green=0;
    int rslt=-1;
    int d,s;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ddddl", &thrsh, &minfrac, &rscale, &bscale, &corr_factor, &corr_green) == FAILURE) {
        RETURN_LONG (-1);
    }
    ithrsh=(255*thrsh)+0.5;
    minpix=  ((long *) ELPHEL_G(imageParamsR))[P_ACTUAL_WIDTH] *
             ((long *) ELPHEL_G(imageParamsR))[P_ACTUAL_HEIGHT] *
             minfrac; 
    rslt = calcWhiteBalance( ithrsh, 
                             minpix, 
                             wbDiffGains,
                             corr_green);
    if (rslt)  RETURN_LONG (rslt) ; 

    wbDiffGains[0]*=rscale;
    wbDiffGains[1]*=bscale;
    ((long *) ELPHEL_G(imageParamsR))[P_RSCALE+P_NUMBER]=256.0*wbDiffGains[0];
    ((long *) ELPHEL_G(imageParamsR))[P_BSCALE+P_NUMBER]=256.0*wbDiffGains[1];
    if (corr_green) ((long *) ELPHEL_G(imageParamsR))[P_GSCALE+P_NUMBER]=256.0*wbDiffGains[2]; // always full - anyway small
    if (corr_factor < 1.0) {
     d=((long *) ELPHEL_G(imageParamsR))[P_RSCALE+P_NUMBER]-((long *) ELPHEL_G(imageParamsR))[P_RSCALE];
     s=1;
     if (d<0) {d=-d;s=-s;};
     if (d) {
       d *= corr_factor;
       if (d<1) d=1;
       ((long *) ELPHEL_G(imageParamsR))[P_RSCALE+P_NUMBER]=((long *) ELPHEL_G(imageParamsR))[P_RSCALE]+s*d;
     }
     d=((long *) ELPHEL_G(imageParamsR))[P_BSCALE+P_NUMBER]-((long *) ELPHEL_G(imageParamsR))[P_BSCALE];
     s=1;
     if (d<0) {d=-d;s=-s;};
     if (d) {
       d *= corr_factor;
       if (d<1) d=1;
       ((long *) ELPHEL_G(imageParamsR))[P_BSCALE+P_NUMBER]=((long *) ELPHEL_G(imageParamsR))[P_BSCALE]+s*d;
     }
    }
    RETURN_LONG (0);
}



PHP_FUNCTION(elphel_get_P_arr)
{
    char full_constant_name[256];
    zval *arr, **data;
    HashTable *arr_hash;
    HashPosition pointer;
    char *key;
    int   key_len;
    long index;
    zval const_value;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &arr) == FAILURE) {
        RETURN_NULL();
    }
    init_sens();
    array_init(return_value);
    arr_hash = Z_ARRVAL_P(arr);
    for(zend_hash_internal_pointer_reset_ex(arr_hash, &pointer);
        zend_hash_get_current_data_ex(arr_hash, (void**) &data, &pointer) == SUCCESS;
        zend_hash_move_forward_ex(arr_hash, &pointer)) {
        if (zend_hash_get_current_key_ex(arr_hash, &key, &key_len, &index, 0, &pointer) == HASH_KEY_IS_STRING) {
           sprintf (full_constant_name,"ELPHEL_%s",key);
           if (zend_get_constant(full_constant_name, strlen(full_constant_name), &const_value TSRMLS_CC)) {
              add_assoc_long(return_value, key, ((long *) ELPHEL_G(imageParamsR))[ Z_LVAL(const_value)]);
              zval_dtor(&const_value);
           }
        }
    }
}
PHP_FUNCTION(elphel_get_P_warr)
{
    char full_constant_name[256];
    zval *arr, **data;
    HashTable *arr_hash;
    HashPosition pointer;
    char *key;
    int   key_len;
    long index;
    zval const_value;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &arr) == FAILURE) {
        RETURN_NULL();
    }
    init_sens();
    array_init(return_value);
    arr_hash = Z_ARRVAL_P(arr);
    for(zend_hash_internal_pointer_reset_ex(arr_hash, &pointer);
        zend_hash_get_current_data_ex(arr_hash, (void**) &data, &pointer) == SUCCESS;
        zend_hash_move_forward_ex(arr_hash, &pointer)) {
        if (zend_hash_get_current_key_ex(arr_hash, &key, &key_len, &index, 0, &pointer) == HASH_KEY_IS_STRING) {
           sprintf (full_constant_name,"ELPHEL_%s",key);
           if (zend_get_constant(full_constant_name, strlen(full_constant_name), &const_value TSRMLS_CC)) {
              add_assoc_long(return_value, key, ((long *) ELPHEL_G(imageParamsR))[P_NUMBER + Z_LVAL(const_value)]);
              zval_dtor(&const_value);
           }
        }
    }
}


PHP_FUNCTION(elphel_set_P_arr)
{
    char full_constant_name[256];
    zval *arr, **data;
    HashTable *arr_hash;
    HashPosition pointer;
    char *key;
    int   key_len;
    long index;
    zval const_value;
    int num_written=0;
    int reg_addr, reg_data;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &arr) == FAILURE) {
        RETURN_LONG(num_written);
    }
    init_sens();
    arr_hash = Z_ARRVAL_P(arr);
    for(zend_hash_internal_pointer_reset_ex(arr_hash, &pointer);
        zend_hash_get_current_data_ex(arr_hash, (void**) &data, &pointer) == SUCCESS;
        zend_hash_move_forward_ex(arr_hash, &pointer)) {
        if ((zend_hash_get_current_key_ex(arr_hash, &key, &key_len, &index, 0, &pointer) == HASH_KEY_IS_STRING) &&
           (Z_TYPE_PP(data) == IS_LONG)) {
           reg_data=Z_LVAL_PP(data);
           sprintf (full_constant_name,"ELPHEL_%s",key);
           if (zend_get_constant(full_constant_name, strlen(full_constant_name), &const_value TSRMLS_CC)) {
              reg_addr=Z_LVAL(const_value);
              zval_dtor(&const_value);
              if ((reg_addr>=0) && (reg_addr<P_NUMBER)) {
                ((long *) ELPHEL_G(imageParamsR))[reg_addr+P_NUMBER]=reg_data;
                num_written++;
              }
           }
        }
    }
    RETURN_LONG(num_written);
}

PHP_FUNCTION(elphel_fpga_read)
{
    long addr,data,res;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &addr) == FAILURE) {
        RETURN_NULL();
    }
    int fd=open("/dev/fpgaio", O_RDONLY);
    if (fd<0) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Can not open file %s","/dev/fpgaio");
      return ;
    }
    lseek (fd, addr,SEEK_SET) ; 
    res=read(fd,&data,4);
    close (fd);
    if (res<4) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Can not read file %s","/dev/fpgaio");
      return ;
    }
    RETURN_LONG(data);
}

PHP_FUNCTION(elphel_fpga_write)
{
    long addr,data,res;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &addr,&data) == FAILURE) {
        RETURN_NULL();
    }
    int fd=open("/dev/fpgaio", O_RDWR);
    if (fd<0) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Can not open file %s","/dev/fpgaio");
      return ;
    }
    lseek (fd, addr,SEEK_SET) ; 
    res=write(fd,&data,4);
    close (fd);
    if (res<4) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Can not write to file %s","/dev/fpgaio");
      return ;
    }
    RETURN_NULL();
}



PHP_FUNCTION(elphel_get_P_value)
{
    long addr;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &addr) == FAILURE) {
        RETURN_NULL();
    }
    if ((addr<0) ||(addr>= (P_NUMBER * 4))) {
        RETURN_NULL();
    }
    init_sens();
    RETURN_LONG(  ((long *) ELPHEL_G(imageParamsR))[addr]);
} 
PHP_FUNCTION(elphel_set_P_value)
{
    long addr;
    long data;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &addr,&data) == FAILURE) {
        RETURN_NULL();
    }
    if ((addr<0) ||(addr>= (P_NUMBER * 2))) {
        RETURN_NULL();
    }
    if (addr>=P_NUMBER) addr-=P_NUMBER;
    else                addr+=P_NUMBER;
    init_sens();
    ((long *) ELPHEL_G(imageParamsR))[addr]=data;
    RETURN_NULL();
} 

PHP_FUNCTION(elphel_get_state)
{
    RETURN_LONG(lseek((int) ELPHEL_G( fd_sens), LSEEK_CAMSEQSTATE, SEEK_END ));
} 

PHP_FUNCTION(elphel_program_sensor)
{
    long nonstop;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &nonstop) == FAILURE) {
        RETURN_NULL();
    }
    init_sens();
    if (nonstop) lseek((int) ELPHEL_G( fd_sens), PROGRAM_SENSOR_1, SEEK_END );
    else         lseek((int) ELPHEL_G( fd_sens), PROGRAM_SENSOR_0, SEEK_END );
    RETURN_NULL();
} 

PHP_FUNCTION(elphel_compressor_cmd)
{
    long cmd;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &cmd) == FAILURE) {
        RETURN_NULL();
    }
    lseek((int) ELPHEL_G( fd_sens), cmd, SEEK_END );
    RETURN_NULL();
} 
PHP_FUNCTION(elphel_compressor_reset)
{
    lseek((int) ELPHEL_G( fd_sens), JPEG_CMD_RESET0, SEEK_END );
    RETURN_NULL();
} 

PHP_FUNCTION(elphel_compressor_run)
{
    lseek((int) ELPHEL_G( fd_sens), JPEG_CMD_START, SEEK_END );
    RETURN_NULL();
} 


PHP_FUNCTION(elphel_compressor_stop)
{
    lseek((int) ELPHEL_G( fd_sens), JPEG_CMD_JUST_STOP, SEEK_END );
    RETURN_NULL();
} 
PHP_FUNCTION(elphel_compressor_frame)
{
    lseek((int) ELPHEL_G( fd_sens), JPEG_CMD_ACQUIRE, SEEK_END );
    RETURN_NULL();
} 

PHP_FUNCTION(elphel_is_compressor_idle)
{
  int state= lseek((int) ELPHEL_G( fd_sens), LSEEK_CAMSEQSTATE, SEEK_END );
  if      (state == 7) {RETURN_LONG (((((long *) ELPHEL_G(imageParamsR)) [P_COMPRESSOR_CMD])==0)?1:0);} 
  else if (state >  7) {RETURN_LONG (0);}
  else                 {RETURN_LONG (1);}
}

PHP_FUNCTION(elphel_reset_sensor) {
  lseek((int) ELPHEL_G( fd_sens), JPEG_CMD_RESET, SEEK_END );      
  lseek((int) ELPHEL_G( fd_sens), LSEEK_RESET_SENSOR , SEEK_END ); 
  init_sens();                                                     
  RETURN_NULL();
}

PHP_FUNCTION(elphel_set_fpga_time) {
  double dtime;
  long ltime_sec,ltime_usec;
  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "d", &dtime) == FAILURE) {
        RETURN_NULL();
  }
  ltime_sec=dtime;
  ltime_usec=(dtime-ltime_sec)*1000000;
  ((long *) ELPHEL_G(imageParamsR)) [P_SECONDS+P_NUMBER] =      ltime_sec;
  ((long *) ELPHEL_G(imageParamsR)) [P_MICROSECONDS+P_NUMBER] = ltime_usec;
  lseek((int) ELPHEL_G( fd_sens), LSEEK_SET_FPGA_TIME, SEEK_END );
  dtime=ltime_usec;
  dtime=ltime_sec+0.000001*dtime;
  RETURN_DOUBLE(dtime);
}

PHP_FUNCTION(elphel_get_fpga_time) {
  double dtime;
  long ltime_sec,ltime_usec;
  lseek((int) ELPHEL_G( fd_sens), LSEEK_GET_FPGA_TIME, SEEK_END );
  dtime=((long *) ELPHEL_G(imageParamsR)) [P_MICROSECONDS];
  dtime=(((long *) ELPHEL_G(imageParamsR)) [P_SECONDS]) + 0.000001*dtime;
  RETURN_DOUBLE(dtime);
}

PHP_FUNCTION(elphel_trigger)
{
    lseek((int) ELPHEL_G( fd_sens),  LSEEK_TRIGGER_PGM, SEEK_END );
    RETURN_NULL();
} 


static void php_elphel_init_globals(zend_elphel_globals *elphel_globals)
{
    elphel_globals->imageParamsR = NULL;
    elphel_globals->fd_sens= open("/dev/sensorpars", O_RDWR);
    if (elphel_globals->fd_sens <0) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Can not open file %s","/dev/sensorpars");
      return ;
    }
    elphel_globals->imageParamsR = (unsigned long *) mmap(0, P_NUMBER*4 *4 , PROT_READ | PROT_WRITE, MAP_SHARED, elphel_globals->fd_sens, 0);
    if((int)elphel_globals->imageParamsR == -1) {
      elphel_globals->imageParamsR=NULL;
//     php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Error in mmap");
//     php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error in mmap");
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Error in mmap /dev/sensorpars");
      close (elphel_globals->fd_sens);
      elphel_globals->fd_sens = -1;
      return ;
    }
    elphel_globals->ccam_dma_buf = NULL;
    elphel_globals->fd_circ= open("/dev/circbuf", O_RDWR);
    if (elphel_globals->fd_circ <0) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Can not open file %s","/dev/circbuf");
      return ;
    }
    elphel_globals->ccam_dma_buf_len=lseek(elphel_globals->fd_circ,0,SEEK_END); //size of circbuf

    elphel_globals->ccam_dma_buf = (unsigned long *) mmap(0, elphel_globals->ccam_dma_buf_len , PROT_READ | PROT_WRITE, MAP_SHARED, elphel_globals->fd_circ, 0);
    if((int)elphel_globals->ccam_dma_buf == -1) {
      elphel_globals->ccam_dma_buf=NULL;
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Error in mmap /dev/circbuf");
      close (elphel_globals->fd_circ);
      elphel_globals->fd_circ = -1;
      return ;
    }


//hist_gamma_mmap
//  while ( (((autoexp_fd = open(AUTOEXP_DEV_NAME, O_RDONLY)))<0) && (retr>0)) retr--; // maybe now not needed after this file can be opened for reading multiple times
    elphel_globals->hist_gamma_mmap = NULL;
    elphel_globals->fd_autoexp = open(AUTOEXP_DEV_NAME, O_RDONLY);
    if (elphel_globals->fd_autoexp <0) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Can not open file %s",AUTOEXP_DEV_NAME);
      return ;
    }
    elphel_globals->hist_gamma_mmap = (void *) mmap(NULL, TABLES_LEN, PROT_READ, MAP_FIXED | MAP_SHARED, elphel_globals->fd_autoexp, 0);
    if(elphel_globals->hist_gamma_mmap == MAP_FAILED) {
      elphel_globals->hist_gamma_mmap=NULL;
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Error in mmap %s",AUTOEXP_DEV_NAME);
      close (elphel_globals->fd_autoexp);
      elphel_globals->fd_autoexp = -1;
      return ;
    }
    elphel_globals->fd_exif = open(EXIF_DEV_NAME, O_RDONLY);
    if (elphel_globals->fd_exif <0) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Can not open file %s",EXIF_DEV_NAME);
      return ;
    }
    elphel_globals->fd_exifdir = open(EXIFDIR_DEV_NAME, O_RDONLY);
    if (elphel_globals->fd_exifdir <0) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Can not open file %s",EXIFDIR_DEV_NAME);
      return ;
    }
    elphel_globals->fd_exifmeta = open(EXIFMETA_DEV_NAME, O_RDWR);
    if (elphel_globals->fd_exifmeta <0) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Can not open file %s",EXIFMETA_DEV_NAME);
      return ;
    }
    elphel_globals->exif_size=0;
//    php_printf ("ccam_dma_buf=0x%lx\n",                   (long)  elphel_globals->ccam_dma_buf );
//    php_printf ("imageParamsR=0x%lx\n",                   (long)  elphel_globals->imageParamsR );
//    php_printf ("elphel_globals->hist_gamma_mmap=0x%lx\n",(long)  elphel_globals->hist_gamma_mmap ); ///NOTE: Why does it print 0 here???

}

PHP_RINIT_FUNCTION(elphel)
{
// session initialization may be here

    return SUCCESS;
}

PHP_MINIT_FUNCTION(elphel)
{
    ZEND_INIT_MODULE_GLOBALS(elphel, php_elphel_init_globals, NULL);

    DEFINE_P_NAMES(pname_arr);
    int i;
    char full_constant_name[256];
    REGISTER_INI_ENTRIES(); // not used yet
    for (i=0;i< (sizeof(pname_arr)/sizeof(pname_arr[0])); i++) {
      sprintf (full_constant_name,"ELPHEL_%s",pname_arr[i].name);
      zend_register_long_constant(full_constant_name, strlen(full_constant_name)+1, pname_arr[i].value, (CONST_CS | CONST_PERSISTENT), module_number TSRMLS_CC);
    }
    return SUCCESS;

}

PHP_MSHUTDOWN_FUNCTION(elphel)
{
    UNREGISTER_INI_ENTRIES();
    if (ELPHEL_G(imageParamsR)) ; //unmap?
    if (ELPHEL_G(fd_sens)>=0) close (ELPHEL_G(fd_sens));
    if (ELPHEL_G(ccam_dma_buf)) ; //unmap?
    if (ELPHEL_G(fd_circ)>=0) close (ELPHEL_G(fd_circ));
    if (ELPHEL_G(hist_gamma_mmap)) ; //unmap?
    if (ELPHEL_G(fd_autoexp)>=0) close (ELPHEL_G(fd_autoexp));
    if (ELPHEL_G(fd_exif)>=0) close (ELPHEL_G(fd_exif));
    if (ELPHEL_G(fd_exifdir)>=0) close (ELPHEL_G(fd_exifdir));
    if (ELPHEL_G(fd_exifmeta)>=0) close (ELPHEL_G(fd_exifmeta));
    return SUCCESS;
}

PHP_MINFO_FUNCTION(elphel)
{
        php_info_print_table_start();
        php_info_print_table_row(2, "Elphel support", "Enabled");
        php_info_print_table_row(2, "Elphel API Version", PHP_ELPHEL_VERSION);
        php_info_print_table_end();
}

---