circbuf compiles

src/drivers/elphel/Makefile

@@ -6,3 +6,8 @@ obj-$(CONFIG_ELPHEL393)           += elphel393-pwr.o
 obj-$(CONFIG_ELPHEL393)           += elphel393-mem.o  
 obj-$(CONFIG_ELPHELDRVONMICROZED) += elphel393-mem.o
 obj-$(CONFIG_ELPHEL393_INIT)      += elphel393-init.o   
+
+obj-$(CONFIG_ELPHEL393)           += framepars.o
+obj-$(CONFIG_ELPHEL393)           += sensor_common.o
+obj-$(CONFIG_ELPHEL393)           += quantization_tables.o
+obj-$(CONFIG_ELPHEL393)           += circbuf.o jpeghead.o
\ No newline at end of file

src/drivers/elphel/circbuf.h

+// FILE NAME  : cxsdma.h
+// read/write image and FPN buffers from SDRAM
+
+#ifndef _CIRCBUF_H
+#define _CIRCBUF_H
+
+#include <linux/poll.h>
+
+int          circbuf_all_open  (struct inode *inode,  struct file *filp); // set filesize
+int          circbuf_all_release(struct inode *inode, struct file *filp);
+loff_t       circbuf_all_lseek (struct file * file,   loff_t offset, int orig);
+ssize_t      circbuf_all_write (struct file * file,   const char * buf, size_t count, loff_t *off);
+ssize_t      circbuf_all_read  (struct file * file,   char * buf, size_t count, loff_t *off);
+int          circbuf_all_mmap  (struct file *file,    struct vm_area_struct *vma);
+unsigned int circbuf_all_poll  (struct file *file,    poll_table *wait);
+//!just to notify it is not implemented
+int          circbuf_all_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg);
+
+
+
+int          circbuf_open  (struct inode *inode, struct file *filp); // set filesize
+loff_t       circbuf_lseek (struct file * file, loff_t offset, int orig);
+ssize_t      circbuf_write (struct file * file, const char * buf, size_t count, loff_t *off);
+ssize_t      circbuf_read  (struct file * file, char * buf, size_t count, loff_t *off);
+int          circbuf_mmap  (struct file *file, struct vm_area_struct *vma);
+unsigned int circbuf_poll  (struct file *file,    poll_table *wait);
+
+void init_ccam_dma_buf_ptr(void);
+/*!======================================================================================
+ *! Wait queue for the processes waiting for a new frame to appear in the circular buffer
+ *!======================================================================================*/
+extern wait_queue_head_t circbuf_wait_queue;
+
+#endif /* _CIRCBUF_H */

src/drivers/elphel/exif.h

+#ifndef __F_EXIF__H_
+#define __F_EXIF__H_
+
+extern unsigned char exif_header[];
+int exif_header_length(void);
+
+#define EXIF_OFFSET	4
+
+#define EXIF_FIRMWARE		0xC4
+#define EXIF_FIRMWARE_LEN	27
+
+//#define EXIF_DATE_TIME		0x7A
+#define EXIF_DATE_TIME		0xE0
+#define EXIF_DATE_TIME_LEN	20
+
+//#define EXIF_ARTIST		0x8E
+#define EXIF_ARTIST		0xF4
+#define EXIF_ARTIST_LEN	18
+
+//#define EXIF_DATE_TIME_OR		0xCA
+#define EXIF_DATE_TIME_OR		0x0138
+#define EXIF_DATE_TIME_OR_LEN	20
+
+//#define EXIF_SUBSEC_OR		0xDE
+#define EXIF_SUBSEC_OR		0x014C
+#define EXIF_SUBSEC_OR_LEN	7
+
+//#define EXIF_EXP		0xE6
+#define EXIF_EXP		0x0130
+#define EXIF_EXP_LEN	8
+
+#define EXIF_IMAGE_ID		0x6E
+#define EXIF_IMAGE_ID_LEN	64
+
+struct exif_desc_t {
+	unsigned char date_time[EXIF_DATE_TIME_LEN];
+	unsigned char date_time_or[EXIF_DATE_TIME_OR_LEN];
+	unsigned char subsec[EXIF_SUBSEC_OR_LEN];
+	unsigned char artist[EXIF_ARTIST_LEN];
+	unsigned char firmware[EXIF_FIRMWARE_LEN];
+	unsigned long exp[2];
+};
+extern struct exif_desc_t exif_desc;
+
+#endif //__F_EXIF__H_

src/drivers/elphel/framepars.h

+#ifndef _FRAMEPARS_H
+#define _FRAMEPARS_H
+
+//extern struct framepars_t (*framepars)[PARS_FRAMES];
+extern struct framepars_t      *framepars;
+extern struct framepars_past_t *pastpars;
+extern unsigned long           *globalPars;
+extern unsigned long           *multiSensIndex;
+extern unsigned long           *multiSensRvrsIndex;
+
+extern wait_queue_head_t framepars_wait_queue;
+///TODO: init framepars (zero parameters) before initscripts (not when detecting the sensors) - then initscript will be able to overwrite some
+void init_framepars_ptr(void);
+void initSequencers(void);         ///Move to sensorcommon? currently it is used through frameparsall file (lseek)
+void initGlobalPars(void);   /// resets all global parameters but debug mask (if ELPHEL_DEBUG)
+int  initMultiPars(void);  /// initialize structures for individual per-sensor parameters. Now only works for sensor registers using G_MULTI_REGSM. Should be called aftre/during sensor detection
+void initFramePars(void);    ///initialize all parameters, set thisFrameNumber to frame8 (read from hardware, usually 0 after resetting i2c and cmd_seq)
+void resetFrameNumber(void); /// reset this frame number (called from initFramePars(), also can be used to avoid frame number integer overflow)
+
+unsigned long get_imageParamsThis (int n);
+unsigned long get_imageParamsPrev (int n);
+
+void          set_imageParamsThis (int n,unsigned long d);
+unsigned long get_globalParam     (int n);
+
+void          set_globalParam   (int n, unsigned long d);
+void          set_imageParamsR_all(int n, unsigned long d);
+void updateFramePars(int frame8, struct interframe_params_t * frame_pars); /// called from ISR - advance thisFrameNumber to match hardware frame8, copy parameters as needed.
+                                   /// frame8 usually is just next after thisFrameNumber
+                                   /// frame_pars - pointer to structure (between frames in the frame buffer) to save a pointer to past parameters
+int setFrameParsStatic(int numPars, struct frameparspair_t * pars);
+
+unsigned long getThisFrameNumber(void); /// just return current thisFrameNumber
+/// set parameters for the frame number frameno, knowing that they should be set not less than maxLatency ahead (may be sensor - dependent)
+/// Parameters (numPars of them) will be updated all at once, with interrupts disabled
+/// Return - 0 if OK, -ERR_FRAMEPARS_TOOEARLY or -ERR_FRAMEPARS_TOOLATE if it is too early or too late to set parameters (numPars may be 0 to just test)
+///
+/// NOTE: When writing parameter to P_SENSOR_RUN or P_COMPRESSOR_RUN "*_RUN_SINGLE", first write "*SENSOR_RUN_STOP" (it will propagate to all next frames) and then
+/// write "*_RUN_SINGLE", to (P_*_RUN | FRAMEPAIR_JUST_THIS) - then this *_RUN_SINGLE will not propagate to the next frames (they will stay stopped)
+
+
+/// TODO: Make (an "unlimited") future commands que based on lists and a tree frame index
+
+int setFrameParsAtomic(unsigned long frameno, int maxLatency, int numPars, struct frameparspair_t * pars);
+
+/// set output/calculated parameter and propogate changes - will not trigger any actions
+int setFramePar(struct framepars_t * this_framepars, unsigned long mindex, unsigned long val);
+///same for several pars at once
+int setFramePars(struct framepars_t * this_framepars, int numPars, struct frameparspair_t * pars);
+/// schedule pgm_func to be executed for selected frame
+void schedule_pgm_func(int frame8, int func_num);
+/// schedule pgm_func to be executed for the current frame
+void schedule_this_pgm_func(struct framepars_t * this_framepars, int func_num);
+  
+/// program acquisition, according to the parameters changed.
+/// maxahead - how many frames ahead of time (start with most urgent, then 1 ahead, ...)
+/// make maxahead - P_* parameter?
+inline void processParsASAP (struct sensorproc_t * sensorproc, int frame8);
+inline void processParsSeq (struct sensorproc_t * sensorproc, int frame8, int maxahead);
+
+void processPars (struct sensorproc_t * sensorproc, int frame8, int maxahead);
+///*** TODO: Add option (flag?) to write "single" (like single compress, single sensor) so it will not make all the next frames "single"
+#endif

src/drivers/elphel/jpeghead.h

+// FILE NAME  : jpeghead.h
+///Structure used for FPGA data - lower 16 bits - code value, next 5 - code length (1..16).
+///Actually FPGA only uses 20 bits, length 0 is interpreted as 16
+struct huffman_fpga_code_t {
+  unsigned short value;       /// code value
+  unsigned short length;      /// code length
+};
+int     qtables_create  (struct interframe_params_t * params, unsigned char * buf);
+int     jpegheader_create(struct interframe_params_t * params, unsigned char * buf);
+int     jpeghead_open   (struct inode *inode, struct file *filp); // set filesize
+loff_t  jpeghead_lseek  (struct file * file, loff_t offset, int orig);
+ssize_t jpeghead_read   (struct file * file, char * buf, size_t count, loff_t *off);
+
+int     huffman_open   (struct inode *inode, struct file *filp); // set filesize
+int     huffman_release(struct inode *inode, struct file *filp);
+loff_t  huffman_lseek  (struct file * file, loff_t offset, int orig);
+ssize_t huffman_read   (struct file * file, char * buf, size_t count, loff_t *off);
+ssize_t huffman_write  (struct file * file, const char * buf, size_t count, loff_t *off);
+
+
+extern unsigned long  * ccam_dma_buf_ptr;
+void init_ccam_dma_buf_ptr(void);
+#define JPEG_HEADER_MAXSIZE    0x300
+struct jpeghead_pd {
+    int                minor;/// should be the first, same as in circbuf_pd
+    unsigned long      size; /// JPEG header size (no Exif)
+    unsigned char      header[JPEG_HEADER_MAXSIZE];
+};
+
+struct huffman_pd {
+    int                minor;/// should be the first, same as in circbuf_pd
+};
+
+int  jpeg_htable_is_programmed(void);
+void jpeg_htable_init (void);
+int  jpeg_htable_fpga_encode (void);
+void jpeg_htable_fpga_pgm (void);
+int  jpeg_prep_htable (struct huffman_encoded_t * htable, struct huffman_fpga_code_t * hcodes);

src/drivers/elphel/quantization_tables.h

+/// @file quantization_tables.h
+#ifndef _QUANTIZATION_TABLES_H
+#define _QUANTIZATION_TABLES_H
+/**
+ * @brief initialization of quantization tables (direct - JPEG header ones) cache
+ * \n TODO: add \b init_qtable_head_cache to module initialization
+ */
+void init_qtable_head_cache(void);
+/**
+ * @brief calculates a pair of direct (JPEG header) tables for the specified quality (2-bytes )
+ * @param quality2 single byte (standard) or a pair of bytes (see file header description)
+ * @param y_tab caller-provided pointer to a 64-byte Y (intensity) quantization table (NULL - don't copy)
+ * @param c_tab caller-provided pointer to a 64-byte C (color) quantization table (NULL - don't copy)
+ * @return 0 - cache hit, 1 - cache miss (recalculated), -1 - invalid quality
+ */
+int get_qtable(int quality2, unsigned char *y_tab, unsigned char *c_tab);
+/**
+ * @brief initialization of quantization tables (reverse, for the FPGA) cache
+ * \n TODO: add \b init_qtable_fpga to module initialization
+ */
+void init_qtable_fpga(void);
+/**
+ * @brief Finds an already programmed FPGA page or calculates (an programms FPGA with) a new one
+ * @param quality2 single byte (standard) or a pair of bytes (see file header description)
+ * @return table page number used (0..7) or -1 - invalid q
+ */
+int set_qtable_fpga(int quality2);
+
+/**
+ * @brief Temporary function to directly set one of the coring LUTs (currently 100 0.0 to 9.9 with 0.1 step)
+ *        to one of 16 FPGA tables (even - for Y,odd - for C)
+ * @param coring_number 0..99 - function number
+ * @param fpga_number 0.. 15 - fpga table number
+ * @return table page number used (0..7) or -1 - invalid q
+ */
+void set_coring_fpga(int coring_number, int fpga_number);
+
+
+
+void reset_qtables(void); 
+#endif

src/drivers/elphel/sensor_common.h

+#ifndef _SENSOR_COMMON_H
+#define _SENSOR_COMMON_H
+
+//extern struct sensor_t sensor; // current sensor (will be copied to by sensor driver), made external for the cc353.c to read/write i2c
+extern struct sensorproc_t * sensorproc;
+/// IRQ-safe "nice" FPGA table write and histogram read functions - they split the data in chunks of fixed size,
+/// disable IRQ, transfer a chunk, then reenable interrupt before proceedg to the next chunk
+#define FPGA_TABLE_CHUNK 64 // up to 64 words to send to the table/from histogram on a single IRQ-off transfer
+//void fpga_table_write_nice (int addr, int len, unsigned long * data);
+//void fpga_hist_read_nice (int addr, int len, unsigned long * data);
+#ifdef CONFIG_ETRAX_ELPHEL_MT9X001
+  #include "mt9x001.h"
+#endif
+//#include "multisensor.h"
+int  camSeqGetJPEG_wp(void);
+int  camSeqGetJPEG_rp(void);
+void camSeqSetJPEG_rp(int p);
+///CIRCBUF macros
+extern unsigned long  * ccam_dma_buf_ptr;
+#define X313_LENGTH_MASK      0xff000000
+#define X313_PADDED_FRAME(x)((((x)+67+CCAM_MMAP_META ) >>2) & 0xfffffff8)
+#define X313_BUFFSUB(x,y) (((x)>=(y))? ((x)-(y)) : ((x)+ (CCAM_DMA_SIZE-(y))))
+#define X313_BUFFADD(x,y) ((((x) + (y))<=CCAM_DMA_SIZE)? ((x) + (y)) : ((x) - (CCAM_DMA_SIZE-(y))))
+
+//int init_FPGA(void); /// can be initialized only after FPGA is configured, not at module init (NOTE was static??)
+///can be verified with if (!X313_IS_SDRAM_ON)
+void reset_compressor(void);
+void camera_interrupts (int on);
+struct sensorproc_t * copy_sensorproc (struct sensorproc_t * copy);
+
+///NOTE: If profiling is enabled (TASKLET_CTL_ENPROF is set in G_TASKLET_CTL) - save current time in 2 of the 32-bit locations that can be read as pastpars (i.e. from PHP)
+#ifdef TEST_DISABLE_CODE
+	#define PROFILE_NOW(x) if (get_globalParam(G_TASKLET_CTL) & (1 << TASKLET_CTL_ENPROF)) \
+							   X313_GET_FPGA_TIME((pastpars[getThisFrameNumber() & PASTPARS_SAVE_ENTRIES_MASK].past_pars[(PP_PROFILE_START + 0) + ((x)<<1)]),\
+												  (pastpars[getThisFrameNumber() & PASTPARS_SAVE_ENTRIES_MASK].past_pars[(PP_PROFILE_START + 1) + ((x)<<1)]))
+	///Put this to the next frame's data (before thisFrameNumber was incremented)
+	#define PROFILE_NEXT(x) if (get_globalParam(G_TASKLET_CTL) & (1 << TASKLET_CTL_ENPROF)) \
+							   X313_GET_FPGA_TIME((pastpars[(getThisFrameNumber()+1) & PASTPARS_SAVE_ENTRIES_MASK].past_pars[(PP_PROFILE_START + 0) + ((x)<<1)]),\
+												  (pastpars[(getThisFrameNumber()+1) & PASTPARS_SAVE_ENTRIES_MASK].past_pars[(PP_PROFILE_START + 1) + ((x)<<1)]))
+#else
+	#define PROFILE_NOW(x) {}
+	#define PROFILE_NEXT(x) {}
+#endif
+
+#endif

src/include/elphel/driver_numbers.h

+/// driver_numbers.h
+/// see packages/devices/elphel/Makefile - major numbers should match
+
+//#define CMOSCAM_MAJOR    126
+#define X3X3_EXIF_MAJOR 125
+#define ELPHEL_MAJOR     126
+#define STREAM_MAJOR     127
+#define FPGA_MAJOR       129
+#define FPGA_JTAG_MAJOR  132
+#define FPGA_CLOCK_MAJOR 133
+#define X3X3_I2C_MAJOR   134
+#define CIRCBUF_MAJOR    135
+//#define FRAMEPARS_MAJOR  136
+#define FRAMEPARS_MAJOR  130
+#define GAMMAS_MAJOR     137
+#define HISTOGRAMS_MAJOR 138
+//#define IMAGERAW_MAJOR   139
+#define IMAGERAW_MAJOR   131
+#define IMAGEACQ_MAJOR   140
+#define IMU_MAJOR        141
+
+
+/// MINORS
+#define IMU_MINOR               1
+#define IMU_CTL_MINOR           2
+#define IMAGERAW_MINOR_FRAME	1
+#define IMAGERAW_MINOR_FPN	2
+#define IMAGERAW_MINOR_UNLOCK	3
+
+
+#define CMOSCAM_MINOR_RWTABLES    9
+#define CMOSCAM_MINOR_CIRCBUF    11
+#define CMOSCAM_MINOR_HISTOGRAM  12
+#define CMOSCAM_MINOR_JPEAGHEAD  13
+#define CMOSCAM_MINOR_GAMMA      14
+#define CMOSCAM_MINOR_FRAMEPARS  16
+#define CMOSCAM_MINOR_GAMMAS     17
+#define CMOSCAM_MINOR_HISTOGRAMS 18
+#define CMOSCAM_MINOR_IMAGEACQ   19
+#define CMOSCAM_MINOR_HUFFMAN    20
+
+#define FPGACONF_MINOR_IORW	 3   /* direct R/W FPGA registers */
+#define FPGACONF_MINOR_SDRAM     4   /* read/write SDRAM through PIO */
+#define FPGACONF_MINOR_TABLES    6   /// Write FPGA tables directly
+ 
+
+#define FPGA_CLOCK_MINOR    2
+#define FPGA_CLOCK_MINOR_I2C        2
+#define FPGA_CLOCK_MINOR_CLOCKS     3
+
+
+#define FPGA_JTAG_RESET_MINOR   0  // just close open files
+#define FPGA_JTAG_RAW_MINOR 0  // just close open files
+#define FPGA_JTAG_MINOR     1
+#define FPGA_SJTAG_MINOR    2
+#define FPGA_AJTAG_MINOR    3
+#define FPGA_JTAG_BOUNDARY_MINOR    5  // read/write boundary pins of the main FPGA
+#define FPGA_SJTAG_BOUNDARY_MINOR   6  // read/write boundary pins of the sensor board FPGA
+#define FPGA_AJTAG_BOUNDARY_MINOR   7  // read/write boundary pins of the aux board FPGA
+
+
+#define X3X3_EXIF_EXIF    0 // read encoded Exif data (SEEK_END,
+#define X3X3_EXIF_META    1 // write metadata, concurently opened files. All writes atomic
+// control/setup devices
+#define X3X3_EXIF_TEMPLATE 2 // write Exif template
+#define X3X3_EXIF_METADIR  3 // write metadata to Exif header translation (dir_table[MAX_EXIF_FIELDS])
+// those 2 files will disable exif_enable and exif_valid, truncate file size to file pointer on release.
+#define X3X3_EXIF_TIME     4 // write today/tomorrow date (YYYY:MM:DD) and number of seconds at today/tomorrow
+                             // midnight (00:00:00) in seconds from epoch (long, startting from LSB)

src/include/elphel/exifa.h

+/*
+ exifa.h
+*/
+#ifndef _ASM_EXIF_H
+#define _ASM_EXIF_H
+
+//Major
+#define X3X3_EXIF 125
+//Minors
+#define X3X3_EXIF_EXIF    0 // read encoded Exif data (SEEK_END,
+#define X3X3_EXIF_META    1 // write metadata, concurently opened files. All writes atomic
+// control/setup devices
+#define X3X3_EXIF_TEMPLATE 2 // write Exif template
+#define X3X3_EXIF_METADIR  3 // write metadata to Exif header translation (dir_table[MAX_EXIF_FIELDS])
+// those 2 files will disable exif_enable and exif_valid, truncate file size to file pointer on release.
+#define X3X3_EXIF_TIME     4 // write today/tomorrow date (YYYY:MM:DD) and number of seconds at today/tomorrow
+                             // midnight (00:00:00) in seconds from epoch (long, startting from LSB)
+
+// commands for the overloaded lseek:
+
+//X3X3_EXIF_TIME
+#define EXIF_LSEEK_DISABLE       1 // disable Exif (storing of frame meta, generating Exif)
+#define EXIF_LSEEK_ENABLE        2 // enable Exif (build buffer if needed)
+#define EXIF_LSEEK_INVALIDATE    3 // invalidate (and disable)
+#define EXIF_LSEEK_REBUILD       4 // rebuild buffer
+
+#define EXIF_LSEEK_TOMORROW_DATE 5 // file pointer to YYYY:MM:DD (tomorrow) string
+#define EXIF_LSEEK_TOMORROW_SEC  6 // file pointer to unsigned long (little endian) tomorrow seconds from epoch
+#define EXIF_LSEEK_TODAY_DATE    7 // file pointer to YYYY:MM:DD (today) string
+#define EXIF_LSEEK_TODAY_SEC     8  // file pointer to unsigned long (little endian) today seconds from epoch
+
+
+/*
+Exif data in the images is combined from the "static" structure (template), calculated once at startup, and
+variable data stored in the buffer for individual frames in the "Exif" form - converted to ASCII strings
+or Rational or else. The generated Exif header copies that variable fileds on top of the Exif template.
+
+The compressed data buffer is stored in "meta pages", one per frame 
+*/
+struct exif_dir_table_t {
+        union {
+          unsigned long ltag;// tag group and tag combined
+          struct {
+            unsigned short tag_group; // tag group: 0 - IFD0, 1 - Exif, 2 - GPS
+            unsigned short tag;       // Exif tag as defined in the standard
+          };
+        };
+        unsigned long len; // Number of bytes to be copied from metadata to Exif
+        unsigned long src; // offset in meta data page
+        unsigned long dst; // offset in output Exif page
+};
+#define MAX_EXIF_FIELDS  256 // number of Exif tags in the header
+#define MAX_EXIF_SIZE   4096 // Exif data size 
+//#define MAX_EXIF_FRAMES  512 // number of frames in the buffer
+#define MAX_EXIF_FRAMES  2048 // number of frames in the buffer
+
+//Exif Tags - unsigned long, combining actual Exif tags with tag groups (0 - IFD0, 1 - Exif, 2 - GPS)
+#define  Exif_Image_ImageDescription   0x0010e
+#define  Exif_Image_Make               0x0010f
+#define  Exif_Image_Model              0x00110
+#define  Exif_Image_Software           0x00131
+#define  Exif_Image_DateTime           0x00132
+#define  Exif_Image_Artist             0x0013b
+#define  Exif_Image_HostComputer       0x0013c
+#define  Exif_Image_Orientation        0x00112
+// hack, reusing field to keep it protected
+#define  Exif_Image_IPTCNAA            0x083bb
+#define  Exif_Image_FrameNumber        0x083bb
+
+#define  Exif_Image_ExifTag            0x08769
+#define  Exif_Image_GPSTag             0x08825
+
+//Sub IFD
+#define  Exif_Photo_ExposureTime       0x1829a
+#define  Exif_Photo_DateTimeOriginal   0x19003
+#define  Exif_Photo_MakerNote          0x1927c
+#define  Exif_Photo_SubSecTime         0x19290
+#define  Exif_Photo_SubSecTimeOriginal 0x19291
+//GPSInfo
+#define  Exif_GPSInfo_GPSLatitudeRef   0x20001
+#define  Exif_GPSInfo_GPSLatitude      0x20002
+#define  Exif_GPSInfo_GPSLongitudeRef  0x20003
+#define  Exif_GPSInfo_GPSLongitude     0x20004
+#define  Exif_GPSInfo_GPSAltitudeRef   0x20005
+#define  Exif_GPSInfo_GPSAltitude      0x20006
+#define  Exif_GPSInfo_GPSTimeStamp     0x20007
+#define  Exif_GPSInfo_GPSMeasureMode   0x2000a
+#define  Exif_GPSInfo_GPSDateStamp     0x2001D
+
+/// used for compass module
+#define  Exif_GPSInfo_GPSImgDirectionRef  0x20010
+#define  Exif_GPSInfo_GPSImgDirection     0x20011
+#define  Exif_GPSInfo_GPSDestLatitudeRef  0x20013
+#define  Exif_GPSInfo_GPSDestLatitude     0x20014
+#define  Exif_GPSInfo_GPSDestLongitudeRef 0x20015
+#define  Exif_GPSInfo_GPSDestLongitude    0x20016
+
+#define  Exif_GPSInfo_CompassDirectionRef 0x20010
+#define  Exif_GPSInfo_CompassDirection    0x20011
+#define  Exif_GPSInfo_CompassPitchRef     0x20013
+#define  Exif_GPSInfo_CompassPitch        0x20014
+#define  Exif_GPSInfo_CompassRollRef      0x20015
+#define  Exif_GPSInfo_CompassRoll         0x20016
+
+//  array(0x9003,2,"2001:06:21 12:00:00","len"=> 20), //date/time original time created, always use 20 bytes (19 ."\0")
+//  array(0x9291,2,"0        ") //original time sub-second length=10  9 ."\0"
+///move back to interframe_params_t?
+struct frame_exif_t {
+          unsigned short meta_index;     //! index of the linked meta page
+          unsigned short signffff;       //! should be 0xffff - it will be a signature that JPEG data was not overwritten
+          unsigned long  frame_length;   //! frame length
+};
+
+struct meta_GPSInfo_t {
+   unsigned char GPSLatitudeRef; //"N"/"S"
+   unsigned long GPSLatitude_deg_nom;
+   unsigned long GPSLatitude_deg_denom;
+   unsigned long GPSLatitude_min_nom;
+   unsigned long GPSLatitude_min_denom;
+   unsigned char GPSLongitudeRef; //"E"/"W"
+   unsigned long GPSLongitude_deg_nom;
+   unsigned long GPSLongitude_deg_denom;
+   unsigned long GPSLongitude_min_nom;
+   unsigned long GPSLongitude_min_denom;
+   unsigned char GPSAltitudeRef; //byte, not ascii 0 - above sea level, 1 - below
+   unsigned long GPSAltitude_nom;   //in meters
+   unsigned long GPSAltitude_denom;
+   unsigned long GPSTimeStamp_hrs_nom;
+   unsigned long GPSTimeStamp_hrs_denom;
+   unsigned long GPSTimeStamp_min_nom;
+   unsigned long GPSTimeStamp_min_denom;
+   unsigned long GPSTimeStamp_sec_nom;
+   unsigned long GPSTimeStamp_sec_denom;
+   unsigned char GPSDateStamp[11]; //includes '\0'
+   unsigned char GPSMeasureMode;
+};
+//hack - use
+struct meta_CompassInfo_t {
+//   unsigned char GPSImgDirectionRef; //"M"/"T" //0x10
+   unsigned long CompassDirection_nom; //0x11
+   unsigned long CompassDirection_denom;
+   unsigned char CompassPitchRef; //"N"/"S"
+   unsigned long CompassPitch_nom;
+   unsigned long CompassPitch_denom;
+   unsigned char CompassRollRef; //"E"/"W"
+   unsigned long CompassRoll_nom;
+   unsigned long CompassRoll_denom;
+};
+
+
+#define EXIF_GPS_MIN_DENOM     10000
+#define EXIF_GPS_METERS_DENOM     10
+#define EXIF_GPS_TIMESEC_DENOM  1000
+#define EXIF_GPS_COMPASS_DENOM    10
+///hack!
+#define EXIF_COMPASS_PITCH_ASCII  "NS" // use for pitch +/-
+#define EXIF_COMPASS_ROLL_ASCII   "EW" // use for roll +/-
+
+/// Exif data (variable, stored with each frame) used for KML (not only)
+#define  Exif_Image_ImageDescription_Index      0x00
+#define  Exif_Photo_DateTimeOriginal_Index      0x01
+#define  Exif_Photo_SubSecTimeOriginal_Index    0x02
+#define  Exif_Photo_ExposureTime_Index          0x03
+#define  Exif_GPSInfo_GPSLatitudeRef_Index      0x04
+#define  Exif_GPSInfo_GPSLatitude_Index         0x05
+#define  Exif_GPSInfo_GPSLongitudeRef_Index     0x06
+#define  Exif_GPSInfo_GPSLongitude_Index        0x07
+#define  Exif_GPSInfo_GPSAltitudeRef_Index      0x08
+#define  Exif_GPSInfo_GPSAltitude_Index         0x09
+#define  Exif_GPSInfo_GPSTimeStamp_Index        0x0a
+#define  Exif_GPSInfo_GPSDateStamp_Index        0x0b
+#define  Exif_GPSInfo_GPSMeasureMode_Index      0x0c
+#define  Exif_GPSInfo_CompassDirectionRef_Index 0x0d
+#define  Exif_GPSInfo_CompassDirection_Index    0x0e
+#define  Exif_GPSInfo_CompassPitchRef_Index     0x0f
+#define  Exif_GPSInfo_CompassPitch_Index        0x10
+#define  Exif_GPSInfo_CompassRollRef_Index      0x11
+#define  Exif_GPSInfo_CompassRoll_Index         0x12
+#define  Exif_Image_FrameNumber_Index           0x13
+#define  Exif_Image_Orientation_Index           0x14
+#define  Exif_Photo_MakerNote_Index             0x15
+/// update ExifKmlNumber to be total number of *_Index entries
+#define  ExifKmlNumber                          Exif_Photo_MakerNote_Index+1
+
+
+#define EXIF_DEV_NAME "/dev/exif_exif"
+#define EXIFDIR_DEV_NAME "/dev/exif_metadir"
+#define EXIFMETA_DEV_NAME "/dev/exif_meta"
+
+#endif