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.1.1.1  2008/11/27 20:04:02  elphel
*!
*!
*!  Revision 1.28  2008/11/22 05:56:40  elphel
*!  elphel_set_P_arr(), elphel_set_P_value() now return frame number parameters were written to
*!
*!  Revision 1.27  2008/11/20 07:06:04  elphel
*!  just touched to overcome dependency (or lack of its support) to make it notice updated c313a.h
*!
*!  Revision 1.26  2008/11/15 07:04:27  elphel
*!  new parameters to modify analog gains while white balancing
*!
*!  Revision 1.25  2008/11/13 05:40:45  elphel
*!  8.0.alpha16 - modified histogram storage, profiling
*!
*!  Revision 1.24  2008/11/05 02:01:25  elphel
*!  Added bit field manipulation in parameters
*!
*!  Revision 1.23  2008/11/04 17:41:43  elphel
*!  added elphel_gamma(), elphel_reverse_gamma(), elphel_histogram(), elphel_reverse_histogram() functions
*!
*!  Revision 1.22  2008/11/02 07:24:20  elphel
*!  added support for some legacy functions
*!
*!  Revision 1.21  2008/11/02 00:33:02  elphel
*!  Added TODO
*!
*!  Revision 1.20  2008/11/01 06:25:46  elphel
*!  elphel_get_circbuf_pointers() now returns framenumber too
*!
*!  Revision 1.19  2008/10/31 18:26:32  elphel
*!  Adding support for constants like SENSOR_REGS32 (defined constant plus 32 to simplify referencing sensor registers from PHP
*!
*!  Revision 1.18  2008/10/29 04:18:28  elphel
*!  v.8.0.alpha10 made a separate structure for global parameters (not related to particular frames in a frame queue)
*!
*!  Revision 1.17  2008/10/28 07:05:49  elphel
*!  touched
*!
*!  Revision 1.16  2008/10/25 19:51:06  elphel
*!  Changed word order in writes to gamma tables driver
*!
*!  Revision 1.15  2008/10/23 18:26:14  elphel
*!  Fixed percentile calculations in histograms
*!
*!  Revision 1.14  2008/10/23 08:11:38  elphel
*!  updated for histograms wait queues
*!
*!  Revision 1.13  2008/10/19 06:56:05  elphel
*!  elphel_wait_frame() now works only for compressed frames, new elphel_skip_frames() and elphel_wait_frame_abs() wait sequencer frames (all sensor frames, even those that are not compressed)
*!
*!  Revision 1.12  2008/10/15 22:28:56  elphel
*!  snapshot 8.0.alpha2
*!
*!  Revision 1.11  2008/10/13 16:56:20  elphel
*!  just touched to force recompile
*!
*!  Revision 1.10  2008/10/12 06:13:10  elphel
*!  snapshot
*!
*!  Revision 1.9  2008/10/08 21:26:25  elphel
*!  snapsot 7.2.0.pre4 - first images (actually - second)
*!
*!  Revision 1.8  2008/10/05 05:13:33  elphel
*!  snapshot003
*!
*!  Revision 1.7  2008/10/04 16:10:12  elphel
*!  snapshot
*!
*!  Revision 1.6  2008/09/25 00:58:11  elphel
*!  snapshot
*!
*!  Revision 1.5  2008/09/19 18:06:38  elphel
*!  snapshot
*!
*!  Revision 1.4  2008/09/19 04:37:24  elphel
*!  snapshot
*!
*!  Revision 1.3  2008/09/07 19:48:08  elphel
*!  snapshot
*!
*!  Revision 1.2  2008/06/04 20:07:08  elphel
*!  adding support for multiple frames
*!
*!  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(elphel_get_frame, NULL)
    PHP_FE(elphel_skip_frames, NULL)
    PHP_FE(elphel_wait_frame_abs, NULL)
    PHP_FE(elphel_framepars_get_raw, NULL)
    PHP_FE(elphel_parse_P_name, NULL)
    PHP_FE(elphel_is_global_par, NULL)
    PHP_FE(elphel_is_frame_par, 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_set_P_arr, NULL)
    PHP_FE(elphel_gamma_add, NULL)
    PHP_FE(elphel_gamma_add_custom, NULL)
    PHP_FE(elphel_gamma_get, NULL)
    PHP_FE(elphel_gamma_get_index, NULL)
    PHP_FE(elphel_gamma_get_raw, NULL)
    PHP_FE(elphel_histogram_get_raw, NULL)
    PHP_FE(elphel_histogram_get, NULL)
    PHP_FE(elphel_get_state, 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_reset_sensor, NULL)
    PHP_FE(elphel_set_fpga_time, NULL)
    PHP_FE(elphel_get_fpga_time, NULL)
    PHP_FE(elphel_wait_frame, NULL)
    PHP_FE(elphel_fpga_read, NULL)
    PHP_FE(elphel_fpga_write, NULL)
    PHP_FE(elphel_gamma, NULL)
    PHP_FE(elphel_reverse_gamma, NULL)
    PHP_FE(elphel_histogram, NULL)
    PHP_FE(elphel_reverse_histogram, NULL)
    PHP_FE(elphel_get_exif_field, NULL)
    PHP_FE(elphel_set_exif_field, NULL)
    PHP_FE(elphel_get_interframe_meta, 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() {
}
 
int splitConstantName(char * name) {
  int len= strlen(name);
  int nIndex;
  int d=0;
  int dp=1;
  int bfields;
  int success=0;
  if ((len>6) && (name[len-6]=='_') && (name[len-5]=='_')) {

    d= FRAMEPAIR_FRAME_BITS(((name[len-3] - '0') + ((name[len-4] - '0') * 10)), ((name[len-1] - '0') + ((name[len-2] - '0') * 10)));
    name[len-6]='\0';
    len-=6;
    success=1;
  }
  nIndex= len-1;
  while ((nIndex>0) && (name[nIndex]>='0') && (name[nIndex] <='9')){
    d+=dp*(name[nIndex]-'0');
    dp*=10;
    nIndex--;
    success=1;
  }
  nIndex++;
  if (success) {
    name[nIndex]='\0'; 
    return d;
  } else return -1;
}

PHP_FUNCTION(elphel_get_frame)
{
    RETURN_LONG( ELPHEL_GLOBALPARS(G_THIS_FRAME));
} 

PHP_FUNCTION(elphel_skip_frames)
{
    long skip=1;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &skip) == FAILURE) {
        RETURN_NULL();
    }
    long target_frame=lseek((int) ELPHEL_G( fd_fparmsall), 0, SEEK_CUR )+skip;
    if ((target_frame<0) || (target_frame > 0x7ffffdff)) RETURN_NULL(); 
    RETURN_LONG(lseek((int) ELPHEL_G( fd_fparmsall), target_frame + LSEEK_FRAME_WAIT_ABS, SEEK_END ));
} 

PHP_FUNCTION(elphel_wait_frame_abs)
{
    long target_frame;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &target_frame) == FAILURE) {
        RETURN_NULL();
    }
    if ((target_frame<0) || (target_frame > 0x7ffffdff)) RETURN_NULL(); 
    RETURN_LONG(lseek((int) ELPHEL_G( fd_fparmsall), target_frame + LSEEK_FRAME_WAIT_ABS, SEEK_END ));
} 

PHP_FUNCTION(elphel_parse_P_name)
{
    char full_constant_name[256];
    char *name;
    int name_len;
    long full_addr =-1;
    zval const_value;
    long constAddNumber;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) {
      RETURN_NULL();
    }
    if (strlen(name)>(sizeof(full_constant_name)-8)) RETURN_NULL();
    sprintf (full_constant_name,"ELPHEL_%s",name);
    if (zend_get_constant(full_constant_name, strlen(full_constant_name), &const_value TSRMLS_CC)) { 
      full_addr= Z_LVAL(const_value);
    } else {
      constAddNumber=splitConstantName(full_constant_name);
      if ((constAddNumber>=0) && (zend_get_constant(full_constant_name, strlen(full_constant_name), &const_value TSRMLS_CC))) {
        full_addr= (Z_LVAL(const_value) & ~FRAMEPAIR_MASK_BYTES)+constAddNumber; 
       }
    }
    if (full_addr!=-1) {
      RETURN_LONG (full_addr);
      zval_dtor(&const_value);
    }
    RETURN_NULL();
}

PHP_FUNCTION(elphel_is_global_par)
{
    long addr;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &addr) == FAILURE) {
        RETURN_NULL();
    }
    addr &= 0xffff; 
    if ((addr >= FRAMEPAR_GLOBALS) && (addr < (FRAMEPAR_GLOBALS+P_MAX_GPAR))) RETURN_TRUE;
    RETURN_FALSE;
}

PHP_FUNCTION(elphel_is_frame_par)
{
    long addr;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &addr) == FAILURE) {
        RETURN_NULL();
    }
    addr &= 0xffff; 
    if (addr < (sizeof (struct framepars_t) >>2)) RETURN_TRUE;
    RETURN_FALSE;
}

PHP_FUNCTION(elphel_get_P_value)
{
    long addr, full_addr;
    long frame=-1;
    long frame_index=-1;
    int  frame_stored;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|l", &full_addr,&frame) == FAILURE) {
        RETURN_NULL();
    }
    if (frame <0) {
      frame=ELPHEL_GLOBALPARS(G_THIS_FRAME);
    }
    addr = full_addr & 0xffff; 

    if (addr >= FRAMEPAR_GLOBALS) { 
      if (addr >= (FRAMEPAR_GLOBALS+P_MAX_GPAR)) {
        RETURN_NULL();
      }
      if (full_addr & FRAMEPAIR_MASK_BYTES) {
        RETURN_LONG(FRAMEPAIR_FRAME_FIELD(full_addr,ELPHEL_GLOBALPARS(addr)));
      } else {
        RETURN_LONG(ELPHEL_GLOBALPARS(addr));
      }
    }
    if ((addr<0) ||(addr>= (sizeof (struct framepars_t) >>2))) {
      RETURN_NULL();
    }
    if (frame <0) {
//      frame=ELPHEL_GLOBALPARS(G_THIS_FRAME) + FRAME_DEAFAULT_AHEAD;
      frame=ELPHEL_GLOBALPARS(G_THIS_FRAME);  
    }

    frame_index = frame & PARS_FRAMES_MASK;
    frame_stored= ((struct framepars_t *) ELPHEL_G(framePars))[frame_index].pars[P_FRAME];
    if (frame_stored == frame) { 
      RETURN_LONG( ((struct framepars_t *) ELPHEL_G(framePars))[frame_index].pars[addr]);
    }
    if (frame_stored <frame) { 
      RETURN_NULL();
    }
    frame_index = frame & PASTPARS_SAVE_ENTRIES_MASK;
    frame_stored= ((struct framepars_past_t *) ELPHEL_G(pastPars))[frame_index].past_pars[P_FRAME-PARS_SAVE_FROM];
    if (frame_stored == frame) { 
      addr-=PARS_SAVE_FROM;
      if ((addr<0) ||(addr>= (sizeof (struct framepars_past_t) >>2))) {
        RETURN_NULL();
      }
      RETURN_LONG( ((struct framepars_past_t *) ELPHEL_G(pastPars))[frame_index].past_pars[addr]);
    }
    RETURN_NULL();
}

PHP_FUNCTION(elphel_get_state)
{
    long frame8=ELPHEL_GLOBALPARS(G_THIS_FRAME) & PARS_FRAMES_MASK;
    long compressor_state= ((struct framepars_t *) ELPHEL_G(framePars))[frame8].pars[P_COMPRESSOR_RUN];
    long sensor_state=     ((struct framepars_t *) ELPHEL_G(framePars))[frame8].pars[P_SENSOR_RUN];
    long result=(compressor_state==COMPRESSOR_RUN_CONT)?0x8:
                ((compressor_state==COMPRESSOR_RUN_SINGLE)?0xa:
                 ((sensor_state==SENSOR_RUN_CONT)?0x7:0));
    RETURN_LONG(result);
} 

PHP_FUNCTION(elphel_framepars_get_raw)
{
  char * packed_framepars_structure;
  long index=0;
  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &index) == FAILURE) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Wrong index");
      RETURN_NULL ();
  }
  packed_framepars_structure= (char*) emalloc (sizeof (struct framepars_t));
  if (packed_framepars_structure) {
     if (index>=0) {
       memcpy(packed_framepars_structure, &(((struct framepars_t *) ELPHEL_G(framePars))[index & PARS_FRAMES_MASK]),sizeof(struct framepars_t));
     } else if (index == -1) {
       memcpy(packed_framepars_structure,   ((struct framepars_t *) ELPHEL_G(funcs2call)),sizeof(struct framepars_t));
     } else if (index == -2) {
       memcpy(packed_framepars_structure,   ((struct framepars_t *) ELPHEL_G(globalPars)),sizeof(struct framepars_t));
     } else RETURN_NULL ();
     RETURN_STRINGL (packed_framepars_structure, sizeof(struct framepars_t), 0);
  }
  php_error_docref(NULL TSRMLS_CC, E_ERROR, "emalloc error");
  RETURN_NULL ();
}





PHP_FUNCTION(elphel_get_P_arr)
{
    long frame=-1;
    long frame_index=-1;
    int  future=1;
    int  frame_stored;
    long addr,full_addr,val;
    char full_constant_name[256];
    zval *arr, **data;
    HashTable *arr_hash;
    HashPosition pointer;
    char *key;
    int   key_len;
    long index;
    long constAddNumber; 
    zval const_value;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|l", &arr, &frame) == FAILURE) {
        RETURN_NULL();
    }
//    init_sens();
    if (frame < 0) { 
      frame=ELPHEL_GLOBALPARS(G_THIS_FRAME);
    }
    frame_index = frame & PARS_FRAMES_MASK;
    frame_stored= ((struct framepars_t *) ELPHEL_G(framePars))[frame_index].pars[P_FRAME];
    if (frame_stored <frame) { 
      future=-1 ; 
    }
    if (frame_stored > frame) { 
      frame_index = frame & PASTPARS_SAVE_ENTRIES_MASK;
      frame_stored= ((struct framepars_past_t *) ELPHEL_G(pastPars))[frame_index].past_pars[P_FRAME-PARS_SAVE_FROM];
      if (frame_stored != frame) { 
         future=-1 ;// not available - only global parameters could be retrieved 
      } else future=0; 
    }

    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) {
           if (strlen(key)>(sizeof(full_constant_name)-8)) RETURN_NULL();
           sprintf (full_constant_name,"ELPHEL_%s",key);
           full_addr =-1;
           if (zend_get_constant(full_constant_name, strlen(full_constant_name), &const_value TSRMLS_CC)) { 
              full_addr= Z_LVAL(const_value);
           } else {
              constAddNumber=splitConstantName(full_constant_name);
//              php_printf ("constAddNumber=%d, full_constant_name=%s (length=%d)\n",constAddNumber, full_constant_name,strlen(full_constant_name));
              if ((constAddNumber>=0) && (zend_get_constant(full_constant_name, strlen(full_constant_name), &const_value TSRMLS_CC))) { 
                full_addr= (Z_LVAL(const_value) & ~FRAMEPAIR_MASK_BYTES)+constAddNumber; 
              }
           }
           if (full_addr!=-1) {
              addr=full_addr & 0xffff;
              if (addr >= FRAMEPAR_GLOBALS) {
                if (addr < (FRAMEPAR_GLOBALS+P_MAX_GPAR)) {
                  if (full_addr & FRAMEPAIR_MASK_BYTES) {
                    add_assoc_long(return_value, key, FRAMEPAIR_FRAME_FIELD(full_addr,ELPHEL_GLOBALPARS(addr)));
                  } else {
                    add_assoc_long(return_value, key, ELPHEL_GLOBALPARS(addr));
                  }
                }
              } else if (future>0) {
                if ((addr >=0) && (addr < (sizeof (struct framepars_t) >>2))) {
                  if (full_addr & FRAMEPAIR_MASK_BYTES) {
                    add_assoc_long(return_value, key, FRAMEPAIR_FRAME_FIELD(full_addr,((struct framepars_t *) ELPHEL_G(framePars))[frame_index].pars[addr]));
                  } else {
                    add_assoc_long(return_value, key, ((struct framepars_t *) ELPHEL_G(framePars))[frame_index].pars[addr]);
                  }
                }
              } else if (future==0){
                addr-=PARS_SAVE_FROM;
                if ((addr >=0) && (addr <(sizeof (struct framepars_past_t) >>2))) {
                  if (full_addr & FRAMEPAIR_MASK_BYTES) {
                    add_assoc_long(return_value, key, FRAMEPAIR_FRAME_FIELD(full_addr,((struct framepars_past_t *) ELPHEL_G(pastPars))[frame_index].past_pars[addr]));
                  } else {
                    add_assoc_long(return_value, key, ((struct framepars_past_t *) ELPHEL_G(pastPars))[frame_index].past_pars[addr]);
                  }
                }
              }
              zval_dtor(&const_value);
           }
        }
    }
}

long elphel_set_P_value_common(long addr, long data, long frame, long flags) {
    unsigned long write_data[4];
    long maddr;
    maddr=addr & 0xffff;
    if (( (addr & 0xff00) != 0xff00 ) && (maddr >= FRAMEPAR_GLOBALS)) { 
      if (maddr >= (FRAMEPAR_GLOBALS+P_MAX_GPAR)) {
        return -1;
      }
      ELPHEL_GLOBALPARS(maddr)=data;
      return 0;
    }
    if (frame <0) {
      frame=ELPHEL_GLOBALPARS(G_THIS_FRAME) + FRAME_DEAFAULT_AHEAD;
    }
    flags |= (flags << 16); 
    flags &=0xffff0000;
    if ((addr<0) ||((maddr >= (sizeof (struct framepars_t) >>2)) && ( (addr & 0xff00) != 0xff00 )  )) {
      return -1;
    }
    write_data[0]=FRAMEPARS_SETFRAME;
    write_data[1]=frame;
    write_data[2]= addr | flags;
    write_data[3]= data;
    long rslt=write(ELPHEL_G(fd_fparmsall), write_data, sizeof(write_data));
//    if (rslt<0) rslt =-errno;
    if (rslt<0) return -errno;
    if (rslt == sizeof( write_data )) return frame;
    return -1;
}



PHP_FUNCTION(elphel_set_P_value)
{
    long addr;
    long data;
    long frame=-1;
    unsigned long flags=0;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll|ll", &addr,&data,&frame,&flags) == FAILURE) {
      RETURN_NULL();
    }
    if (((frame=elphel_set_P_value_common (addr, data, frame, flags))) <0) {
      RETURN_NULL();
    }
    RETURN_LONG(frame);
}

PHP_FUNCTION(elphel_compressor_reset)
{
    long frame=-1;
    unsigned long flags=-1;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ll", &frame,&flags) == FAILURE) {
      RETURN_NULL();
    }
    if (flags<0) flags=FRAMEPAIR_FORCE_NEWPROC;
    if (((frame=elphel_set_P_value_common (P_COMPRESSOR_RUN, COMPRESSOR_RUN_STOP, frame, flags)))<0) {
      RETURN_NULL();
    }
    RETURN_LONG(frame);
} 

PHP_FUNCTION(elphel_compressor_run)
{
    long frame=-1;
    unsigned long flags=-1;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ll", &frame,&flags) == FAILURE) {
      RETURN_NULL();
    }
    if (flags<0) flags=FRAMEPAIR_FORCE_NEWPROC;
    if (((frame=elphel_set_P_value_common (P_COMPRESSOR_RUN, COMPRESSOR_RUN_CONT, frame, flags)))<0) {
      RETURN_NULL();
    }
    RETURN_LONG(frame);
} 


PHP_FUNCTION(elphel_compressor_stop)
{
    long frame=-1;
    unsigned long flags=-1;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ll", &frame,&flags) == FAILURE) {
      RETURN_NULL();
    }
    if (flags<0) flags=FRAMEPAIR_FORCE_NEWPROC;
    if (((frame=elphel_set_P_value_common (P_COMPRESSOR_RUN, COMPRESSOR_RUN_STOP, frame, flags)))<0) {
      RETURN_NULL();
    }
    RETURN_LONG(frame);
}

PHP_FUNCTION(elphel_compressor_frame)
{
    long frame=-1;
    unsigned long flags=-1;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ll", &frame,&flags) == FAILURE) {
      RETURN_NULL();
    }
    if (flags<0) flags=FRAMEPAIR_JUST_THIS;
    if (((frame=elphel_set_P_value_common (P_COMPRESSOR_RUN, COMPRESSOR_RUN_SINGLE, frame, flags)))<0) {
      RETURN_NULL();
    }
    RETURN_LONG(frame);
} 
PHP_FUNCTION(elphel_reset_sensor) {
  lseek((int) ELPHEL_G(fd_fparmsall), LSEEK_FRAMEPARS_INIT, SEEK_END ); 
  elphel_set_P_value_common (P_SENSOR, 0, 0, -1);
  RETURN_NULL();
}

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 array_count;
    unsigned long * write_data=NULL;
    long frame=-1;
    long flags=0;
    int num_written=0;
    int num_mmap_written=0;
    int reg_addr, reg_data, constAddNumber;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|ll", &arr,&frame,&flags) == FAILURE) {
        RETURN_LONG(num_written);
    }
    if (frame <0) {
      frame=ELPHEL_GLOBALPARS(G_THIS_FRAME) + FRAME_DEAFAULT_AHEAD;
    }
    flags |= (flags << 16); 
    flags &=0xffff0000;
    init_sens();
    arr_hash = Z_ARRVAL_P(arr);
    array_count = zend_hash_num_elements(arr_hash);
    write_data=(unsigned long *) emalloc ((array_count+1)<<3);
    if (!write_data) RETURN_NULL(); 

    write_data[0]=FRAMEPARS_SETFRAME;
    write_data[1]=frame;
    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);
           if (strlen(key)>(sizeof(full_constant_name)-8)) RETURN_NULL();
           sprintf (full_constant_name,"ELPHEL_%s",key);

           reg_addr =-1;
           if (zend_get_constant(full_constant_name, strlen(full_constant_name), &const_value TSRMLS_CC)) { 
              reg_addr= Z_LVAL(const_value);
           } else {
              constAddNumber=splitConstantName(full_constant_name);
              if ((constAddNumber>=0) && (zend_get_constant(full_constant_name, strlen(full_constant_name), &const_value TSRMLS_CC))) { 
                reg_addr= (Z_LVAL(const_value) & ~FRAMEPAIR_MASK_BYTES)+constAddNumber; 
              }
           }

           if (reg_addr>=0) {
              zval_dtor(&const_value); 
              if (((reg_addr & 0xff00) != 0xff00 ) && ((reg_addr & 0xffff) >= FRAMEPAR_GLOBALS)) {  
                if ((reg_addr & 0xffff) < (FRAMEPAR_GLOBALS+P_MAX_GPAR)) { 
                  if ((reg_addr & FRAMEPAIR_MASK_BYTES) ==0) { 
                    ELPHEL_GLOBALPARS(reg_addr & 0xffff)=reg_data;
                    num_mmap_written++;
                  } else { 
                    write_data[(num_written<<1) + 2]= reg_addr | flags;
                    write_data[(num_written<<1) + 3]= reg_data;
                    num_written++;
                  }
                }
              } else if ((reg_addr>=0) && (((reg_addr & 0xffff) < (sizeof (struct framepars_t) >>2)) || ( (reg_addr & 0xff00) == 0xff00 )  )) {
                write_data[(num_written<<1) + 2]= reg_addr | flags;
                write_data[(num_written<<1) + 3]= reg_data;
                num_written++;
              }
           }
        }
    }
    if (num_written) {
      long rslt=write(ELPHEL_G(fd_fparmsall), write_data, (num_written+1)<<3);
      efree(write_data);
      if (rslt<0) RETURN_LONG(-errno);
      num_written=(rslt>>3) -1 ; 
    }
    RETURN_LONG(frame);
}

int gamma_calc (double gamma, double black, unsigned short * gtable) {
 int i;
 double x, black256,k;
 int ig;
 black256=black*256.0;
 if (k>=1.0) k= k/256.0 ; 
 if (k>0.99) k=0.99;
 k=1.0/(256.0-black256);
 if (!gtable) return -1;
 if (gamma < 0.13) gamma=0.13;
 if (gamma >10.0)  gamma=10.0;
 for (i=0; i<257; i++) {
   x=k*(i-black256);
   if (x < 0.0 ) x=0.0;
   ig= 0.5+65535.0*pow(x,gamma);
   if (ig > 0xffff) ig=0xffff;
   gtable[i]=ig;
 }
 return 0;
}

PHP_FUNCTION(elphel_gamma_add)
{
    unsigned short data_to_write[260];
    double gamma,black;
    int igamma, iblack, hash16;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "dd", &gamma, &black ) == FAILURE) {
       php_error_docref(NULL TSRMLS_CC, E_ERROR, "Wrong arguments");
       RETURN_NULL ();
    }
    igamma=100*gamma+0.5;
    if (igamma <   0) igamma=  0;
    if (igamma > 255) igamma=255;
    gamma=0.01*igamma;
    iblack= (black>=1.0)?black:(256*black+0.5);
    if (iblack <   0) iblack=  0;
    if (iblack > 254) iblack=254; 
    black= (1.0/256.0) * iblack;
    hash16= igamma | (iblack<<8);
    data_to_write[0]= GAMMA_SCLALE_1; 
    data_to_write[1]= hash16;
    data_to_write[2]=0;
    gamma_calc (gamma, black, &data_to_write[3]);
    long rslt=write(ELPHEL_G(fd_gamma_cache), data_to_write, sizeof(data_to_write));
    if (rslt<0) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Write to fd_gamma_cache returned errno=%d",errno);
      RETURN_LONG(-errno);
    }
    RETURN_LONG (hash16);
}

PHP_FUNCTION(elphel_gamma_add_custom)
{
    unsigned short data_to_write[260];
    long  hash16;
    int i,d;
    zval *arr,  **data;
    HashTable *arr_hash;
    long array_count;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "la", &hash16, &arr ) == FAILURE) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Wrong arguments");
      RETURN_LONG (-998);
    }
    arr_hash = Z_ARRVAL_P(arr);
    array_count = zend_hash_num_elements(arr_hash);
    if (array_count != 257) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Wrong array length (should be 257) - %d",array_count);
      RETURN_LONG (-999);
    }
    hash16 &= 0xffff;
    data_to_write[0]= GAMMA_SCLALE_1; 
    data_to_write[1]= hash16;
    data_to_write[2]=0;
    for (i=0; i<257; i++) {
      if (zend_hash_index_find(arr_hash, i, (void**)&data) == FAILURE) {
        php_error_docref(NULL TSRMLS_CC, E_ERROR, "Missing array element [%d]",i);
        RETURN_LONG(-i-1000);
      }
      switch (Z_TYPE_PP(data)) {
        case IS_DOUBLE:
            d=Z_DVAL_PP(data);
            break;
        case IS_LONG:
            d=(1.0/255)* Z_LVAL_PP(data);
        default:
          php_error_docref(NULL TSRMLS_CC, E_ERROR, "Non-numeric array element [%d]",i);
          RETURN_LONG(-i-2000);
      }
      if (d<0)   d=0.0;
      if (d>1.0) d=1.0;
      data_to_write[i+3]=d*65535.0;
    }
    long rslt=write(ELPHEL_G(fd_gamma_cache), data_to_write, sizeof(data_to_write));
    if (rslt<0) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Write to fd_gamma_cache returned errno=%d",errno);
      RETURN_LONG(-errno);
    }
    RETURN_LONG (hash16);
}

PHP_FUNCTION(elphel_gamma_get)
{
//  double scale=1.0;
  unsigned short gtable[257];
  unsigned short data_to_write[3];
  long hash16;
  long raw=0;
  zval  *zscale=NULL;
  int iscale=GAMMA_SCLALE_1;
  int gamma_cache_index;
  int i;
  double gk=1.0/65535.0;
  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|zl", &hash16, &zscale,&raw) == FAILURE) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Wrong arguments");
      RETURN_LONG (-998);
  }
  if (zscale) {
    switch (Z_TYPE_P(zscale)) {
        case IS_DOUBLE:
            iscale=(GAMMA_SCLALE_1 * Z_DVAL_P(zscale) +0.5);
            break;
        case IS_LONG:
            iscale = Z_LVAL_P(zscale);
            break;
        default:
            php_error_docref(NULL TSRMLS_CC, E_ERROR, "Wrong scale type");
    }
  }
  if (iscale < 0)      iscale=0;
  if (iscale > 0xffff) iscale=0xffff;
  data_to_write[0]= iscale; 
  data_to_write[1]= hash16;
  data_to_write[2]=0;
  long rslt=write(ELPHEL_G(fd_gamma_cache), data_to_write, sizeof(data_to_write));
  if (rslt<0) {
//      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Write to fd_gamma_cache returned errno=%d",errno);
      RETURN_LONG(-errno); 
  }
  gamma_cache_index= lseek(ELPHEL_G(fd_gamma_cache), 0, SEEK_CUR);
  if (!gamma_cache_index) {
      RETURN_LONG (-997); 
  }
  memcpy(gtable, &(((struct gamma_stuct_t *) ELPHEL_G(gamma_cache))[gamma_cache_index].direct[0]),sizeof(gtable));
  if (lseek(ELPHEL_G(fd_gamma_cache), LSEEK_GAMMA_ISCURRENT, SEEK_END)<=0) {
      RETURN_LONG (-996); 
  }
  array_init(return_value);
  if (raw) for (i=0;i<257;i++)  add_next_index_long  (return_value,    gtable[i]);
  else     for (i=0;i<257;i++)  add_next_index_double(return_value, gk*gtable[i]);
}

PHP_FUNCTION(elphel_gamma_get_index)
{
  unsigned short data_to_write[3];
  long hash16;
  zval  *zscale=NULL;
  int iscale=GAMMA_SCLALE_1;
  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|z", &hash16, &zscale) == FAILURE) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Wrong arguments");
      RETURN_LONG (-998);
  }
  if (zscale) {
    switch (Z_TYPE_P(zscale)) {
        case IS_DOUBLE:
            iscale=(GAMMA_SCLALE_1 * Z_DVAL_P(zscale) +0.5);
            break;
        case IS_LONG:
            iscale = Z_LVAL_P(zscale);
            break;
        default:
            php_error_docref(NULL TSRMLS_CC, E_ERROR, "Wrong scale type");
    }
  }
  if (iscale < 0)      iscale=0;
  if (iscale > 0xffff) iscale=0xffff;
  data_to_write[0]= iscale; 
  data_to_write[1]= hash16;
  data_to_write[2]=0;
  long rslt=write(ELPHEL_G(fd_gamma_cache), data_to_write, sizeof(data_to_write));
  if (rslt<0) {
//      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Write to fd_gamma_cache returned errno=%d",errno);
      RETURN_LONG(-errno); 
  }
  RETURN_LONG (lseek(ELPHEL_G(fd_gamma_cache), 0, SEEK_CUR));
}




PHP_FUNCTION(elphel_gamma_get_raw)
{
  char * packed_gamma_structure;
  long index;
  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &index) == FAILURE) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Wrong index");
      RETURN_NULL ();
  }
  if (index >= GAMMA_CACHE_NUMBER) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Wrong index (%d >= %d)",index, (int) GAMMA_CACHE_NUMBER);
      RETURN_NULL ();
  }
  packed_gamma_structure= (char*) emalloc (sizeof(struct gamma_stuct_t));
  if (packed_gamma_structure) {
     memcpy(packed_gamma_structure, &(((struct gamma_stuct_t *) ELPHEL_G(gamma_cache))[index]),sizeof(struct gamma_stuct_t));
     if (index==0) { 
        packed_gamma_structure[sizeof(struct gamma_stuct_t)-1]=0xff;
     }
     RETURN_STRINGL (packed_gamma_structure, sizeof(struct gamma_stuct_t), 0);
  }
  php_error_docref(NULL TSRMLS_CC, E_ERROR, "emalloc error");
  RETURN_NULL ();
}
//     memcpy(packed_framepars_structure, &(((struct framepars_t *) ELPHEL_G(framePars))[index]),sizeof(struct framepars_t));

PHP_FUNCTION(elphel_histogram_get_raw)
{
  char * packed_histogram_structure;
  long frame=-1;
  long needed=0xfff;
  long index;
  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ll", &needed,&frame) == FAILURE) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Wrong index");
      RETURN_NULL ();
  }
  if (frame<0) frame=lseek((int) ELPHEL_G( fd_fparmsall), 0, SEEK_CUR );
  needed &= 0xfff;
  lseek(ELPHEL_G(fd_histogram_cache), LSEEK_HIST_WAIT_C, SEEK_END); 
  lseek(ELPHEL_G(fd_histogram_cache), LSEEK_HIST_NEEDED + (needed & 0xff0), SEEK_END); 
  index=lseek(ELPHEL_G(fd_histogram_cache), frame, SEEK_SET);    
  if (index <0) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Requested histograms are not available (frame=%d, needed=0x%x)",frame,needed);
      RETURN_NULL ();
  }
  if (index >= HISTOGRAM_CACHE_NUMBER) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Internal error: frame=%d, index=%d",frame, index);
      RETURN_NULL ();
  }
//  index &= (HISTOGRAM_CACHE_NUMBER -1);
  packed_histogram_structure= (char*) emalloc (sizeof(struct histogram_stuct_t));
  if (!packed_histogram_structure) {
    php_error_docref(NULL TSRMLS_CC, E_ERROR, "emalloc error");
    RETURN_NULL ();
  }
  memcpy(packed_histogram_structure, &(((struct histogram_stuct_t *) ELPHEL_G(histogram_cache))[index]),sizeof(struct histogram_stuct_t));
  RETURN_STRINGL (packed_histogram_structure, sizeof(struct histogram_stuct_t), 0);
}

PHP_FUNCTION(elphel_histogram_get)
{
  struct histogram_stuct_t * frame_histogram_structure;
  long frame=-1;
  long needed=0xfff;
  long index;
  int i;
  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ll", &needed, &frame) == FAILURE) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Wrong index");
      RETURN_NULL ();
  }
  needed &= 0xfff;
  lseek(ELPHEL_G(fd_histogram_cache), LSEEK_HIST_WAIT_C, SEEK_END); 
  lseek(ELPHEL_G(fd_histogram_cache), LSEEK_HIST_NEEDED + (needed & 0xff0), SEEK_END); 
  index=lseek(ELPHEL_G(fd_histogram_cache), frame, SEEK_SET);    
  if (index <0) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Requested histograms are not available (frame=%d, needed=0x%x)",frame,needed);
      RETURN_NULL ();
  }
  if (index >= HISTOGRAM_CACHE_NUMBER) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Internal error: frame=%d, index=%d",frame, index);
      RETURN_NULL ();
  }

  frame_histogram_structure= (struct histogram_stuct_t *) emalloc (sizeof(struct histogram_stuct_t));
  if (!frame_histogram_structure) {
    php_error_docref(NULL TSRMLS_CC, E_ERROR, "emalloc error");
    RETURN_NULL ();
  }
  memcpy((void *) frame_histogram_structure, &(((struct histogram_stuct_t *) ELPHEL_G(histogram_cache))[index]),sizeof(struct histogram_stuct_t));
  if (frame != ((struct histogram_stuct_t *) ELPHEL_G(histogram_cache))[index].frame ) {
    php_error_docref(NULL TSRMLS_CC, E_ERROR, "Frame changed while retrieving histograms (frame requested=%d, current=%d)",
                                              frame, (int)((struct histogram_stuct_t *) ELPHEL_G(histogram_cache))[index].frame);
    RETURN_NULL ();
    efree (frame_histogram_structure);
  }
  if ((needed & frame_histogram_structure->valid ) != needed) {
    php_error_docref(NULL TSRMLS_CC, E_ERROR, "Not all the requested tables are available (frame=%d needed=0x%x, valid=0x%x)",
                                              frame, needed, frame_histogram_structure->valid);
    RETURN_NULL ();
    efree (frame_histogram_structure);
  }

  array_init(return_value);
  if (needed & 0x001)  for (i=0;i<256;i++)  add_next_index_long  (return_value,   frame_histogram_structure->hist_r[i]);
  if (needed & 0x002)  for (i=0;i<256;i++)  add_next_index_long  (return_value,   frame_histogram_structure->hist_g[i]);
  if (needed & 0x004)  for (i=0;i<256;i++)  add_next_index_long  (return_value,   frame_histogram_structure->hist_gb[i]);
  if (needed & 0x008)  for (i=0;i<256;i++)  add_next_index_long  (return_value,   frame_histogram_structure->hist_b[i]);

  if (needed & 0x010)  for (i=0;i<256;i++)  add_next_index_long  (return_value,   frame_histogram_structure->cumul_hist_r[i]);
  if (needed & 0x020)  for (i=0;i<256;i++)  add_next_index_long  (return_value,   frame_histogram_structure->cumul_hist_g[i]);
  if (needed & 0x040)  for (i=0;i<256;i++)  add_next_index_long  (return_value,   frame_histogram_structure->cumul_hist_gb[i]);
  if (needed & 0x080)  for (i=0;i<256;i++)  add_next_index_long  (return_value,   frame_histogram_structure->cumul_hist_b[i]);

  if (needed & 0x100)  for (i=0;i<256;i++)  add_next_index_long  (return_value,   frame_histogram_structure->percentile_r[i]);
  if (needed & 0x200)  for (i=0;i<256;i++)  add_next_index_long  (return_value,   frame_histogram_structure->percentile_g[i]);
  if (needed & 0x400)  for (i=0;i<256;i++)  add_next_index_long  (return_value,   frame_histogram_structure->percentile_gb[i]);
  if (needed & 0x800)  for (i=0;i<256;i++)  add_next_index_long  (return_value,   frame_histogram_structure->percentile_b[i]);

  efree (frame_histogram_structure);
}


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;
}


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
    long meta_index,displacementInPage,exifPageStart,frame_be;

    zval *image_pointers;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &second) == FAILURE) {
        RETURN_NULL();
    }
    createExifDirectory(0); 
    if (ELPHEL_G(exif_dir)[Exif_Image_FrameNumber_Index].ltag==Exif_Image_FrameNumber) 
      displacementInPage=ELPHEL_G(exif_dir)[Exif_Image_FrameNumber_Index].dst;
    else
      displacementInPage=-1; 
    p=lseek((int) ELPHEL_G( fd_circ), second? LSEEK_CIRC_SCND: LSEEK_CIRC_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 interframe_params_t *) &ccam_dma_buf_char[frameParamPointer])->meta_index);
      meta_index=((struct interframe_params_t *) &ccam_dma_buf_char[frameParamPointer])->meta_index;
      add_assoc_long(image_pointers, "exif_pointer", meta_index);
      if (displacementInPage>=0){
        exifPageStart=lseek ((int) ELPHEL_G(fd_exif), meta_index, SEEK_END); 
        lseek (ELPHEL_G(fd_exif), exifPageStart+displacementInPage, SEEK_SET);
        read(ELPHEL_G(fd_exif), &frame_be, 4);
        add_assoc_long(image_pointers, "frame", (long) __cpu_to_be32(frame_be));
      }
      add_next_index_zval(return_value, image_pointers);
      p=lseek((int) ELPHEL_G( fd_circ), LSEEK_CIRC_NEXT, SEEK_END );
      p=lseek((int) ELPHEL_G( fd_circ), LSEEK_CIRC_READY, SEEK_END );

    }
}


PHP_FUNCTION(elphel_get_interframe_meta)
{
   char * ccam_dma_buf_char= (char *) ELPHEL_G( ccam_dma_buf);
   struct interframe_params_t frame_params;
   long circbuf_pointer=-1;
   long frameParamPointer,jpeg_len,timestamp_start;
//   long circbuf_size=ELPHEL_GLOBALPARS(G_CIRCBUFSIZE);
   long circbuf_size=ELPHEL_G(ccam_dma_buf_len);
   if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &circbuf_pointer) == FAILURE) {
       RETURN_NULL();
   }
   frameParamPointer=circbuf_pointer-32;
   if (frameParamPointer < 0) frameParamPointer+=circbuf_size;
   memcpy (&frame_params, &ccam_dma_buf_char[frameParamPointer],32);
   jpeg_len=frame_params.frame_length;
   timestamp_start=circbuf_pointer+((jpeg_len+CCAM_MMAP_META+3) & (~0x1f)) + 32 - CCAM_MMAP_META_SEC; 
   if (timestamp_start >= circbuf_size) timestamp_start-=circbuf_size;
   memcpy (&(frame_params.timestamp_sec), &ccam_dma_buf_char[timestamp_start],8);
   if (frame_params.signffff !=0xffff) {
     RETURN_NULL();
   }
   array_init(return_value);
   add_assoc_long(return_value, "hash32_r",      frame_params.hash32_r); 
   add_assoc_long(return_value, "hash32_g",      frame_params.hash32_g);
   add_assoc_long(return_value, "hash32_gb",     frame_params.hash32_gb);
   add_assoc_long(return_value, "hash32_b",      frame_params.hash32_b);
   add_assoc_long(return_value, "quality2",      frame_params.quality2);
   add_assoc_long(return_value, "color",         frame_params.color);      
   add_assoc_long(return_value, "byrshift",      frame_params.byrshift);   
   add_assoc_long(return_value, "width",         frame_params.width);      
   add_assoc_long(return_value, "height",        frame_params.height);     
   add_assoc_long(return_value, "meta_index",    frame_params.meta_index); 
   add_assoc_long(return_value, "timestamp_sec", frame_params.timestamp_sec);  
   add_assoc_long(return_value, "timestamp_usec",frame_params.timestamp_usec); 
}


#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(elphel_wait_frame)
{
    lseek((int) ELPHEL_G( fd_circ), LSEEK_CIRC_TOWP, SEEK_END );
    lseek((int) ELPHEL_G( fd_circ), LSEEK_CIRC_WAIT, SEEK_END );
    RETURN_NULL();
}

PHP_FUNCTION(elphel_gamma)
{
    long   color;
    long frame =-1;
    double sensorLevel;
    int indx,gamma_index;
    unsigned long hash32; 
    unsigned long  write_data[2];
    int rslt;
    unsigned short * gamma_direct;
    long lsensorLevel;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ld|l", &color, &sensorLevel, &frame ) == FAILURE) {
        RETURN_LONG (-1);
    }
    if ((color <0) || (color > 3)) RETURN_LONG (-1); 
    if (frame <0) {
      frame=ELPHEL_GLOBALPARS(G_THIS_FRAME)-1;
    }
//  php_printf ("frame=0x%lx, color=0x%lx\n",frame, color);
    hash32=get_imageParamsThat (P_GTAB_R+color, frame);
//  php_printf ("hash32=0x%lx\n",hash32);
    if (hash32 == 0xffffffff) RETURN_LONG (-1);
    write_data[0]=hash32;
    write_data[1]=0; 
    rslt=write(ELPHEL_G(fd_gamma_cache), write_data, 6);
//  php_printf ("frame=0x%lx, write_data[0]=0x%lx, write_data[1]=0x%lx,rslt=0x%x\n",frame, write_data[0], write_data[1],rslt);

    if (rslt<= 0) {
      RETURN_LONG (-1);
    }
   gamma_index=lseek(ELPHEL_G(fd_gamma_cache), 0, SEEK_CUR);
//  php_printf ("gamma_index=0x%x\n",gamma_index);

    if (gamma_index <= 0) {
      RETURN_LONG (-2); 
    }
    gamma_direct= &(((struct gamma_stuct_t *) ELPHEL_G(gamma_cache))[gamma_index].direct[0]);

    lsensorLevel=0x10000*sensorLevel;
//  php_printf ("lsensorLevel=0x%lx\n",lsensorLevel);

    if (lsensorLevel <0) RETURN_LONG (-1);
    if (lsensorLevel >0xffff) lsensorLevel=0xffff;
//  php_printf ("(long) gamma_direct[%lx]=0x%lx\n",lsensorLevel>>8, (long) gamma_direct[lsensorLevel>>8]);
//  php_printf ("(long) gamma_direct[%lx]=0x%lx\n",(lsensorLevel>>8)+1, (long) gamma_direct[(lsensorLevel>>8)+1]);

    RETURN_DOUBLE ((1.0/(1<<24))* ((((long) gamma_direct[lsensorLevel>>8])<<8) +
                                 (((long) gamma_direct[(lsensorLevel>>8)+1] - ((long) gamma_direct[lsensorLevel>>8]))*(lsensorLevel & 0xff))));
}

PHP_FUNCTION(elphel_reverse_gamma)
{
    long   color;
    long   frame=-1;
    double gammaLevel;
    int indx,gamma_index;
    unsigned long hash32; 
    unsigned long  write_data[2];
    int rslt;
    unsigned short * gamma_direct;
    unsigned char * gamma_reverse;
    long lgammaLevel, sensor_high8,delta, sensor_full;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ld|l", &color, &gammaLevel, &frame ) == FAILURE) {
        RETURN_LONG (-1);
    }
    if ((color <0) || (color > 3)) RETURN_LONG (-1); 
    if (frame <0) {
      frame=ELPHEL_GLOBALPARS(G_THIS_FRAME)-1;
    }
    hash32=get_imageParamsThat (P_GTAB_R+color, frame);
    if (hash32 == 0xffffffff) RETURN_LONG (-1);
    write_data[0]=hash32;
    write_data[1]= GAMMA_MODE_NEED_REVERSE;
    rslt=write(ELPHEL_G(fd_gamma_cache), write_data, 6);
    if (rslt<= 0) {
      RETURN_LONG (-1);
    }
    gamma_index=lseek(ELPHEL_G(fd_gamma_cache), 0, SEEK_CUR);
    if (gamma_index <= 0) {
      RETURN_LONG (-2); 
    }
    gamma_direct= &(((struct gamma_stuct_t *) ELPHEL_G(gamma_cache))[gamma_index].direct[0]); 

    gamma_reverse=&(((struct gamma_stuct_t *) ELPHEL_G(gamma_cache))[gamma_index].reverse[0]);

    lgammaLevel=0x10000*gammaLevel;
    if (lgammaLevel <0) RETURN_LONG (-1);
    if (lgammaLevel >0xffff) lgammaLevel=0xffff;
    sensor_high8=gamma_reverse[lgammaLevel >> 8]; 
    if (sensor_high8>0) sensor_high8--;                                                     
    while ((sensor_high8>0) &&  (gamma_direct[sensor_high8] > lgammaLevel)) sensor_high8--;    
    sensor_high8++;
    while ((sensor_high8<255) &&  (gamma_direct[sensor_high8] <= lgammaLevel)) sensor_high8++; 
    sensor_high8--;
    delta=gamma_direct[sensor_high8+1] - gamma_direct[sensor_high8];
    if (delta) {
      sensor_full=((lgammaLevel-gamma_direct[sensor_high8]) << 8)/delta;
    } else sensor_full=0;
    sensor_full += sensor_high8 << 8;
    if      (sensor_full <      0) sensor_full=0;
    else if (sensor_full > 0xffff) sensor_full=0xffff;
    RETURN_DOUBLE ((1.0/(1<<16))* sensor_full);
}

int get_histogram_index (long color,long frame, long needreverse) { 
     long hist_index;
     if ((color<0) || (color>4))  return -1; 
     if (color == COLOR_Y_NUMBER) lseek(ELPHEL_G(fd_histogram_cache), LSEEK_HIST_WAIT_Y, SEEK_END); 
     else                         lseek(ELPHEL_G(fd_histogram_cache), LSEEK_HIST_WAIT_C, SEEK_END); 
     lseek(ELPHEL_G(fd_histogram_cache), LSEEK_HIST_NEEDED + ((1 << color) << (needreverse? 8:4)), SEEK_END); 
     return lseek(ELPHEL_G(fd_histogram_cache), frame, SEEK_SET);                                                       
}

unsigned long get_imageParamsThat     (int indx, unsigned long frame) {
   int frame_index=  frame & PARS_FRAMES_MASK;
   int past_index=   frame & PASTPARS_SAVE_ENTRIES_MASK;
   unsigned long value;
   if (((struct framepars_t *) ELPHEL_G(framePars))[frame_index].pars[P_FRAME] != frame) {
     if ((indx < PARS_SAVE_FROM) || (indx >= (PARS_SAVE_FROM+PARS_SAVE_NUM))) return 0xffffffff ; 
     value=((struct framepars_past_t *) ELPHEL_G(pastPars))[past_index].past_pars[indx-PARS_SAVE_FROM]; 
     if (((struct framepars_past_t *) ELPHEL_G(pastPars))[frame_index].past_pars[P_FRAME-PARS_SAVE_FROM] != frame) { 
       return 0xffffffff;
     }
   } else {
     value=((struct framepars_t *) ELPHEL_G(framePars))[frame_index].pars[indx];
   }
   return value;
}

PHP_FUNCTION(elphel_histogram)
{
    long frame=-1;
    long hist_index;
    double dlevel;
    long   llevel,total_pixels;
    unsigned long * hist_cumul;      
    long  hist,color;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ld|l", &color, &dlevel, &frame ) == FAILURE) {
        RETURN_LONG (-1);
    }
    if ((color <0) || (color > 3)) RETURN_LONG (-1); 
    if (frame <0) {
      frame=ELPHEL_GLOBALPARS(G_THIS_FRAME)-1;
    }
    if (((hist_index=get_histogram_index (color, frame, 0)))<0) RETURN_LONG (-1);
    llevel=0x10000*dlevel;
    if      (llevel< -0.5) RETURN_LONG(-1) ; 
    if      (llevel<0) llevel=0;
    else if (llevel>0xffff) llevel=0xffff;
    hist_cumul= &(((struct histogram_stuct_t *) ELPHEL_G(histogram_cache))[hist_index].cumul_hist[color<<8]);
    total_pixels=  hist_cumul[255];
    hist=  (llevel>>8)?hist_cumul[(llevel>>8)-1]:0;
    hist +=((hist_cumul[llevel>>8]-hist)*(llevel & 0xff))>>8;
    RETURN_DOUBLE(((double) hist)/total_pixels);
}

PHP_FUNCTION(elphel_reverse_histogram)
{
    long frame=-1;
    long hist_index;
    double fraction;
    long   frac_pixels,total_pixels, frac_256, delta;
    unsigned long * hist_cumul;      
    unsigned char * hist_percentile; 

    long  perc,perc_frac,color;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ld|l", &color, &fraction, &frame ) == FAILURE) {
        RETURN_LONG (-1);
    }
    if ((color <0) || (color > 3)) RETURN_LONG (-1); 
    if (frame <0) {
      frame=ELPHEL_GLOBALPARS(G_THIS_FRAME)-1;
    }
    if (((hist_index=get_histogram_index (color, frame, 1)))<0) RETURN_LONG (-1);
    hist_cumul= &(((struct histogram_stuct_t *) ELPHEL_G(histogram_cache))[hist_index].cumul_hist[color<<8]);
    hist_percentile=&(((struct histogram_stuct_t *) ELPHEL_G(histogram_cache))[hist_index].percentile[color<<8]);
    total_pixels=  hist_cumul[255];
    frac_pixels=total_pixels*fraction;
    if (fraction < -0.5) RETURN_LONG(-1) ; 
    if      (frac_pixels<0) frac_pixels=0;
    else if (frac_pixels>=total_pixels) frac_pixels=total_pixels-1;
    frac_256=(1.0/256)*fraction; 
    if (frac_256 > 255) frac_256=255;
    perc=hist_percentile[frac_256];
    if (perc>0) perc--;                                              
    while ((perc>0) &&  (hist_cumul[perc] > frac_pixels)) perc--;    
    perc++;
    while ((perc<255) &&  (hist_cumul[perc] <= frac_pixels)) perc++; 
    perc--;
    delta=hist_cumul[perc+1] - hist_cumul[perc];
    if (delta) {
      perc_frac=((frac_pixels-hist_cumul[perc]) << 8)/delta;
    } else perc_frac=0;
    perc_frac += perc << 8;
    RETURN_DOUBLE((1.0/(1<<16)) * ((double) perc_frac));
}



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_set_fpga_time) {
  unsigned long write_data[8]= {FRAMEPARS_SETFRAME,     0,
                                G_SECONDS,              0,
                                G_MICROSECONDS,         0,
                                FRAMEPARS_SETFPGATIME,  0};
  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;
  write_data[3]=ltime_sec;
  write_data[5]=ltime_usec;

  long rslt=write(ELPHEL_G(fd_fparmsall), write_data, sizeof(write_data));
  if (rslt<0) RETURN_LONG(-errno);
  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_fparmsall), LSEEK_GET_FPGA_TIME, SEEK_END );
  dtime= ELPHEL_GLOBALPARS(G_MICROSECONDS);
  dtime= ELPHEL_GLOBALPARS(G_SECONDS) + 0.000001*dtime;
  RETURN_DOUBLE(dtime);
}


static void php_elphel_init_globals(zend_elphel_globals *elphel_globals)
{
    elphel_globals->frameParsAll = NULL;
    elphel_globals->framePars =    NULL;
    elphel_globals->pastPars =     NULL;
    elphel_globals->funcs2call=    NULL;
    elphel_globals->fd_fparmsall= open("/dev/frameparsall", O_RDWR);
    if (elphel_globals->fd_fparmsall <0) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Can not open file %s","/dev/frameparsall");
      return ;
    }
    elphel_globals->frameParsAll = (struct framepars_all_t *) mmap(0, sizeof (struct framepars_all_t) , PROT_READ | PROT_WRITE, MAP_SHARED, elphel_globals->fd_fparmsall, 0);
    if((int)elphel_globals->frameParsAll == -1) {
      elphel_globals->frameParsAll=NULL;
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Error in mmap /dev/frameparsall");
      close (elphel_globals->fd_fparmsall);
      elphel_globals->fd_fparmsall = -1;
      return ;
    }
    elphel_globals->framePars =   elphel_globals->frameParsAll->framePars;
    elphel_globals->pastPars =    elphel_globals->frameParsAll->pastPars;
    elphel_globals->funcs2call=   elphel_globals->frameParsAll->func2call.pars;
    elphel_globals->globalPars =  elphel_globals->frameParsAll->globalPars;



    elphel_globals->gamma_cache = NULL;
    elphel_globals->fd_gamma_cache= open("/dev/gamma_cache", O_RDWR);
    if (elphel_globals->fd_gamma_cache <0) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Can not open file %s","/dev/gamma_cache");
      return ;
    }
    elphel_globals->gamma_cache = (struct gamma_stuct_t *) mmap(0, sizeof (struct gamma_stuct_t) * GAMMA_CACHE_NUMBER , PROT_READ, MAP_SHARED, elphel_globals->fd_gamma_cache, 0);
    if((int)elphel_globals->gamma_cache == -1) {
      elphel_globals->gamma_cache=NULL;
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Error in mmap /dev/gamma_cache");
      close (elphel_globals->fd_gamma_cache);
      elphel_globals->fd_gamma_cache = -1;
      return ;
    }
    elphel_globals->histogram_cache = NULL;
    elphel_globals->fd_histogram_cache= open("/dev/histogram_cache", O_RDWR);
    if (elphel_globals->fd_histogram_cache <0) {
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Can not open file %s","/dev/histogram_cache");
      return ;
    }
    elphel_globals->histogram_cache = (struct histogram_stuct_t *) mmap(0, sizeof (struct histogram_stuct_t) * HISTOGRAM_CACHE_NUMBER , PROT_READ, MAP_SHARED, elphel_globals->fd_histogram_cache, 0);
    if((int)elphel_globals->histogram_cache == -1) {
      elphel_globals->histogram_cache=NULL;
      php_error_docref(NULL TSRMLS_CC, E_ERROR, "Error in mmap /dev/histogram_cache");
      close (elphel_globals->fd_histogram_cache);
      elphel_globals->fd_histogram_cache = -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 ;
    }


    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_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);

    DEFINE_ONCHANGE_NAMES(onchange_arr);

    DEFINE_LSEEK_NAMES(lseek_arr);

    DEFINE_CONST_NAMES(const_arr);

    int i,j;
    char full_constant_name[256];

    REGISTER_INI_ENTRIES(); // not used yet
    for (i=0;i< (sizeof(pname_arr)/sizeof(pname_arr[0])); i++) {
      if (strlen(pname_arr[i].name)>(sizeof(full_constant_name)-8)) return FAILURE;
      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);
    }

    for (i=0;i< (sizeof(onchange_arr)/sizeof(onchange_arr[0])); i++) {
      if (strlen(onchange_arr[i].name)>(sizeof(full_constant_name)-17)) return FAILURE;
      sprintf (full_constant_name,"ELPHEL_ONCHANGE_%s",onchange_arr[i].name);
      for (j=0; j<strlen(full_constant_name);j++) full_constant_name[j]=toupper(full_constant_name[j]);
      zend_register_long_constant(full_constant_name, strlen(full_constant_name)+1, onchange_arr[i].value, (CONST_CS | CONST_PERSISTENT), module_number TSRMLS_CC);
    }

    for (i=0;i< (sizeof(lseek_arr)/sizeof(lseek_arr[0])); i++) {
      if (strlen(lseek_arr[i].name)>(sizeof(full_constant_name)-14)) return FAILURE;
      sprintf (full_constant_name,"ELPHEL_LSEEK_%s",lseek_arr[i].name);
      zend_register_long_constant(full_constant_name, strlen(full_constant_name)+1, lseek_arr[i].value, (CONST_CS | CONST_PERSISTENT), module_number TSRMLS_CC);
    }
    for (i=0;i< (sizeof(const_arr)/sizeof(const_arr[0])); i++) {
      if (strlen(const_arr[i].name)>(sizeof(full_constant_name)-14)) return FAILURE;
      sprintf (full_constant_name,"ELPHEL_CONST_%s",const_arr[i].name);
      zend_register_long_constant(full_constant_name, strlen(full_constant_name)+1, const_arr[i].value, (CONST_CS | CONST_PERSISTENT), module_number TSRMLS_CC);
    }
    return SUCCESS;
}

PHP_MSHUTDOWN_FUNCTION(elphel)
{
    UNREGISTER_INI_ENTRIES();
    if (ELPHEL_G(fd_fparmsall)>=0)       close (ELPHEL_G(fd_fparmsall));
    if (ELPHEL_G(fd_gamma_cache)>=0)     close (ELPHEL_G(fd_gamma_cache));
    if (ELPHEL_G(fd_histogram_cache)>=0) close (ELPHEL_G(fd_histogram_cache));
    if (ELPHEL_G(fd_circ)>=0)            close (ELPHEL_G(fd_circ));
    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();
}

---