apps/camogm2/camogm.c

Go to the documentation of this file.

 
/*!***************************************************************************
*! FILE NAME  : camogm.c
*! DESCRIPTION: Program to write captured video (and audio) to camera file system
*! using Ogg container.
*! Original implementation will copy package data to a buffer to use library calls?
*! Copyright (C) 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: camogm.c,v $
*!  Revision 1.8  2008/06/06 10:53:32  spectr_rain
*!  clean
*!
*!  Revision 1.7  2008/06/02 19:49:41  spectr_rain
*!  fixed QuickTime compatibility - need to cleanup
*!
*!  Revision 1.4  2008/05/23 15:54:45  spectr_rain
*!  *** empty log message ***
*!
*!  Revision 1.3  2008/05/23 15:42:10  spectr_rain
*!  *** empty log message ***
*!
*!  Revision 1.2  2008/05/23 13:09:49  spectr_rain
*!  QuickTime support
*!
*!  Revision 1.1  2008/05/02 12:45:57  spectr_rain
*!  initial revision with the sound support
*!
*!  Revision 1.9  2008/04/13 21:05:19  elphel
*!  Fixing KML generation
*!
*!  Revision 1.8  2008/04/11 23:09:33  elphel
*!  modified to handle kml generation
*!
*!  Revision 1.7  2008/04/07 09:13:34  elphel
*!  Changes related to new Exif generation/processing
*!
*!  Revision 1.6  2008/01/14 22:59:00  elphel
*!  7.1.7.4 - added timelapse mode to camogm
*!
*!  Revision 1.5  2007/12/03 08:28:45  elphel
*!  Multiple changes, mostly cleanup
*!
*!  Revision 1.4  2007/11/29 00:38:57  elphel
*!  fixed timescale bug
*!
*!  Revision 1.3  2007/11/19 05:07:19  elphel
*!  fixed 2 typos
*!
*!  Revision 1.2  2007/11/19 03:23:21  elphel
*!  7.1.5.5 Added support for *.mov files in camogm.
*!
*!  Revision 1.1  2007/11/16 08:49:56  elphel
*!  Initial release of camogm - program to record video/image to the camera hard drive (or other storage)
*!
*/ 
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <fcntl.h>
#include <sys/uio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
//#include <ctype.h>
//#include <getopt.h>
#include <time.h>
#include <string.h>
#include <sched.h>

#include <netinet/in.h> /*little <-> big endian ?*/
#include <sys/mman.h>           /* mmap */
#include <sys/ioctl.h>

#include <asm/elphel/c313a.h>
//#include <asm/elphel/exifa.h>
#include <asm/elphel/ext353.h>
#include <asm/byteorder.h>

#include <ogg/ogg.h> // has to be before ogmstreams.h
#include "ogmstreams.h" // move it to <>?

//#include "camogm_exif.h"
#include "camogm_ogm.h"
#include "camogm_jpeg.h"
#include "camogm_mov.h"
#include "camogm_kml.h"
#include "camogm.h"
#include "camogm_wav.h"

//#include <alsa/asoundlib.h>

#define TRAILER_SIZE   0x02
#define MAP_OPTIONS MAP_FILE|MAP_PRIVATE

char trailer[TRAILER_SIZE] = {0xff,0xd9};

const char ExifFileName[]="/dev/exif_exif";

const char HeadFileName[]="/dev/jpeghead";
const char SensParsFileName[]="/dev/sensorpars";
unsigned long * ccam_dma_buf;           /* mmapped array */
unsigned long * imageParamsR;
int buff_size;

#define DEFAULT_DURATION 600 
//#define DEFAULT_DURATION 60 
//#define DEFAULT_DURATION 10 
//#define DEFAULT_LENGTH 100000000 
#define DEFAULT_LENGTH (700 * 1024 * 1024) 

#define DEFAULT_FRAMES           16384 /* Maximal number of frames in file segment (each need 4* (1 + 1/frames_per_chunk) bytes for the frame index */
//#define DEFAULT_FRAMES_PER_CHUNK    10 /*second sparse index - for Quicktime fast forward */
#define DEFAULT_FRAMES_PER_CHUNK    1 /*second sparse index - for Quicktime fast forward */

//#define DEFAULT_LENGTH 100000000 /*!default segment length (B) */
#define DEFAULT_EXIF 1 /* use Exif */

#define DEFAULT_AUDIO_RATE      44100
#define DEFAULT_AUDIO_CHANNELS  2

#define AUDIO_RATE_MAX  44100
#define AUDIO_RATE_MIN  11025
#define AUDIO_CHANNELS_MAX      2
#define AUDIO_CHANNELS_MIN      1

static char cmdbuf[1024];
static int  cmdbufp=0; // current input pointer in the command buffer (read from pipe)
static int  cmdstrt=0; // start of the next partial command

camogm_state sstate;
camogm_state * state;

int   debug_level;
FILE* debug_file;


int camogm_init(void);

int camogm_start(int by_command);
int camogm_stop(int by_command);

int camogm_reset(void); 
int camogm_debug(const char * fname);
int camogm_debug_level(int d);
void  camogm_set_segment_duration(int sd);
void  camogm_set_segment_length(int sl);
void  camogm_set_save_gp(int d);
void  camogm_set_prefix (const char * p);
void  camogm_set_exif(int d);
void  camogm_set_timescale(double d); 
void  camogm_set_frames_skip(int d); 
void  camogm_set_format(int d);

void  camogm_kml_set_enable(int d);
void  camogm_kml_set_horHalfFov (double dd);
void  camogm_kml_set_vertHalfFov(double dd);
void  camogm_kml_set_height_mode(int d);
void  camogm_kml_set_height(double dd);
void  camogm_kml_set_period(int d);
void  camogm_kml_set_near(double dd); // distance to PhotoOverlay


int   parse_cmd(FILE* npipe);
char * getLineFromPipe(FILE* npipe);

int  sendImageFrame (void);

void  camogm_set_max_frames(int d);
void  camogm_set_frames_per_chunk(int d);


void camogm_set_audio_state(char *args);
void camogm_set_audio_format(char *args);
void camogm_set_sync_state(char *args);
void audio_process(void);
void audio_init(int by_command);
void audio_start(int by_command);
void audio_end(int by_command);
void audio_free(void);
void camogm_audio_initialize(void);

int time_comp(struct timeval *t1, struct timeval *t2) {
        if(t1->tv_sec > t2->tv_sec)
                return 1;
        if(t1->tv_sec == t2->tv_sec) {
                if(t1->tv_usec > t2->tv_usec)
                        return 1;
                if(t1->tv_usec == t2->tv_usec)
                        return 0;
        }
        return -1;
}

void time_normalize(struct timeval *tv) {
        while(tv->tv_usec >= 1000000) {
                tv->tv_usec -= 1000000;
                tv->tv_sec += 1;
        }
}

struct timeval time_delta(struct timeval *t1, struct timeval *t2) {
        struct timeval tv;
        tv.tv_sec = t1->tv_sec - t2->tv_sec;
        if(t1->tv_usec >= t2->tv_usec) {
                tv.tv_usec = t1->tv_usec - t2->tv_usec;
        } else {
                tv.tv_usec = 1000000 + t1->tv_usec - t2->tv_usec;
                tv.tv_sec -= 1;
        }
        return tv;
}

void put_uint16(void *buf, u_int16_t val)
{
        unsigned char  *tmp;

        tmp = (unsigned char *) buf;

        tmp[0] = val & 0xff;
        tmp[1] = (val >>= 8) & 0xff;
}

void put_uint32(void *buf, u_int32_t val)
{
        unsigned char  *tmp;

        tmp = (unsigned char *) buf;

        tmp[0] = val & 0xff;
        tmp[1] = (val >>= 8) & 0xff;
        tmp[2] = (val >>= 8) & 0xff;
        tmp[3] = (val >>= 8) & 0xff;
}

void put_uint64(void *buf, u_int64_t val)
{
        unsigned char  *tmp;

        tmp = (unsigned char *) buf;

        tmp[0] = val & 0xff;
        tmp[1] = (val >>= 8) & 0xff;
        tmp[2] = (val >>= 8) & 0xff;
        tmp[3] = (val >>= 8) & 0xff;
        tmp[4] = (val >>= 8) & 0xff;
        tmp[5] = (val >>= 8) & 0xff;
        tmp[6] = (val >>= 8) & 0xff;
        tmp[7] = (val >>= 8) & 0xff;
}

int camogm_init(void) {
   const char sserial[]="elp0";
   int * ipser= (int*) sserial;
   state->running=0; // mo
   state->starting=0; // mo
//   state->vf=NULL;
   state->vf = 0;
   camogm_set_segment_duration(DEFAULT_DURATION);
   camogm_set_segment_length(DEFAULT_LENGTH);
   camogm_set_max_frames(DEFAULT_FRAMES);
   camogm_set_frames_per_chunk(DEFAULT_FRAMES_PER_CHUNK);
   camogm_set_prefix ("\0");
//   camogm_set_prefix ("/tmp/video/c");
   camogm_set_save_gp(0);
   camogm_reset(); 
   state->serialno= ipser[0];
   state->last= 0;
   debug_file= stderr;
   camogm_debug_level(1);
   strcpy(state->debug_name,"stderr");
   camogm_set_timescale(1.0);
   camogm_set_frames_skip(0); 
   camogm_set_format(CAMOGM_FORMAT_OGM);
//   camogm_set_format(CAMOGM_FORMAT_MOV);
   camogm_set_audio_state("on");
   camogm_set_audio_format("44100/2");
   camogm_set_audio_state("off");
//   camogm_set_sync_state("on");
   camogm_set_sync_state("off");
   state->exifSize=0;
   state->exif= DEFAULT_EXIF;
//   state->frame_lengths=NULL;
   state->frameno=0;
   state->formats=0;

        camogm_audio_initialize();

   camogm_kml_set_enable(0);
   state->kml_file=NULL;
   camogm_kml_set_horHalfFov (20.0);
   camogm_kml_set_vertHalfFov(15.0);
   camogm_kml_set_height_mode(0);
   camogm_kml_set_height(10.0);
   camogm_kml_set_period(2); // 2 sec
   camogm_kml_set_near(40.0); // 40 m (distance to PhotoOverlay)
   state->kml_path[0]='\0';


/*
void  camogm_kml_set_enable(int d);
void  camogm_kml_set_horHalfFov (double dd);
void  camogm_kml_set_vertHalfFov(double dd);
void  camogm_kml_set_height_mode(int d);
void  camogm_kml_set_height(double dd);
void  camogm_kml_set_decimate(int d);

  int                   kml_enable;       //! enable KML file generation
  FILE*                 kml_file;         //! stream to write kml file
  double                kml_horHalfFov;   //! half horizontal Fov (degrees)
  double                kml_vertHalfFov;  //! half vertical Fov (degrees)
  int                   kml_height_mode;  //! 1 - actual, 0 - ground
  double                kml_height;       //! extra height to add
  int                   kml_decimate;     //! generate PhotoOverlay for each kml_decimate frame;
  int                   kml_decimate_counter; //! counter to skip kml frames
  double                kml_near;         //! Use in KML "near" parameter (<=0 - don't use it)

*/



   return 0;
}


int camogm_debug(const char * fname) {
  int none=1;
  if (fname && strlen(fname) && strcmp(fname, "none") && strcmp(fname, "null")  && strcmp(fname, "/dev/null")) none=0;
  if (debug_file){
    if (strcmp(state->debug_name, "stdout") && strcmp(state->debug_name, "stderr")) fclose (debug_file);
    debug_file=NULL;
    state->debug_name[0]='\0';
  }
  if (!none) {
    if      (strcmp(fname, "stdout") ==0) debug_file=stdout;
    else if (strcmp(fname, "stderr") ==0) debug_file=stderr;
    else                                  debug_file=fopen(fname,"w+");
  }
  if (debug_file) {
      strncpy(state->debug_name,fname,sizeof(state->debug_name)-1);
      state->debug_name[sizeof(state->debug_name)-1]='\0';
  }
  return 0;
}

int camogm_debug_level(int d) {
  debug_level=d;
  return 0;
}




int camogm_start(int by_command) {
  int timestamp_start;
  int rslt;
  int next_metadata_start, next_jpeg_len, fp;
  D1(fprintf (debug_file,"Starting recording\n"));
  state->frameno=0;
  state->timescale=        state->set_timescale;

  int * ifp =      (int *) &(state->frame_params) ;
  int * ifp_this = (int *) &(state->this_frame_params) ;
  if (state->kml_enable) camogm_init_kml() ; // do nothing

        audio_init(by_command);
  if (state->format != state->set_format) {
     state->format=  state->set_format;
     switch (state->format) {
      case CAMOGM_FORMAT_NONE: rslt= 0; break;
      case CAMOGM_FORMAT_OGM:  rslt= camogm_init_ogm(); break;
      case CAMOGM_FORMAT_JPEG: rslt= camogm_init_jpeg();break;
      case CAMOGM_FORMAT_MOV:  rslt= camogm_init_mov(); break;
     }
     state->formats |= 1 << (state->format);
  }
  state->max_frames=       state->set_max_frames;
  state->frames_per_chunk= state->frames_per_chunk;
  state->starting=1; 

D3(fprintf (debug_file,"1: state->cirbuf_rp=0x%x\n",state->cirbuf_rp));
  if ((state->cirbuf_rp <0) || (lseek(state->fd_circ,state->cirbuf_rp,SEEK_SET) < 0) || (lseek(state->fd_circ,CIRCLSEEK_VALID,SEEK_END) < 0 )) {
D3(fprintf (debug_file,"2: state->cirbuf_rp=0x%x\n",state->cirbuf_rp));
    state->cirbuf_rp=lseek(state->fd_circ,CIRCLSEEK_LAST,SEEK_END);
    if (((fp=lseek(state->fd_circ,CIRCLSEEK_PREV,SEEK_END)))>=0) state->cirbuf_rp=fp; 
    state->buf_overruns++;
//    state->buf_min=lseek(state->fd_circ,CIRCLSEEK_FREE,SEEK_END);
//    lseek(state->fd_circ,state->cirbuf_rp,SEEK_SET); //! restore after moving (side effect)
    state->buf_min=imageParamsR[P_FREECIRCBUF];

  } else {
//      b_free=lseek(state->fd_circ,CIRCLSEEK_FREE,SEEK_END);
//      lseek(state->fd_circ,state->cirbuf_rp,SEEK_SET); //! restore after moving (side effect)
//      if (state->buf_min > b_free) state->buf_min=b_free;
      if (state->buf_min > imageParamsR[P_FREECIRCBUF]) state->buf_min=imageParamsR[P_FREECIRCBUF];

  }
D3(fprintf (debug_file,"3: state->cirbuf_rp=0x%x\n",state->cirbuf_rp));
D3(fprintf (debug_file,"4:lseek(state->fd_circ,CIRCLSEEK_READY,SEEK_END)=%d\n",(int) lseek(state->fd_circ,CIRCLSEEK_READY,SEEK_END)));

  if (lseek(state->fd_circ,CIRCLSEEK_READY,SEEK_END) <0) return -CAMOGM_FRAME_NOT_READY; 
D3(fprintf (debug_file,"5: state->cirbuf_rp=0x%x\n",state->cirbuf_rp));
  state->metadata_start=(state->cirbuf_rp)-32;
  if (state->metadata_start<0) state->metadata_start+=state->circ_buff_size;


  memcpy (&(state->frame_params), (unsigned long * ) &ccam_dma_buf[state->metadata_start>>2],32);
  state->jpeg_len=state->frame_params.frame_length; 


  if (state->frame_params.signffff !=0xffff) {
    D0(fprintf(debug_file, "%s:%d: wrong signature - %d\r\n",__FILE__,__LINE__,(int) state->frame_params.signffff));
     state->cirbuf_rp=-1;
     D1(fprintf(debug_file, "state->cirbuf_rp=0x%x\r\n",(int) state->cirbuf_rp));
     D1(fprintf(debug_file, "%08x %08x %08x %08x %08x %08x %08x %08x\r\n",ifp[0],ifp[1],ifp[2],ifp[3],ifp[4],ifp[5],ifp[6],ifp[7]));
     return -CAMOGM_FRAME_BROKEN;
  }
  timestamp_start=(state->cirbuf_rp)+((state->jpeg_len+CCAM_MMAP_META+3) & (~0x1f)) + 32 - CCAM_MMAP_META_SEC; 
  if (timestamp_start >= state->circ_buff_size) timestamp_start-=state->circ_buff_size;
  memcpy (&(state->frame_params.timestamp_sec), (unsigned long * ) &ccam_dma_buf[timestamp_start>>2],8);

  if ((lseek(state->fd_circ,CIRCLSEEK_NEXT,SEEK_END) < 0 ) ||
      (((fp=lseek(state->fd_circ,CIRCLSEEK_READY,SEEK_END))) < 0)) {
        lseek(state->fd_circ,state->cirbuf_rp,SEEK_SET); 
        return -CAMOGM_FRAME_NOT_READY; 
  }
  next_metadata_start=fp-32;
  if (next_metadata_start<0) next_metadata_start+= state->circ_buff_size;
  memcpy (&(state->this_frame_params), (unsigned long * ) &ccam_dma_buf[next_metadata_start>>2],32);
  next_jpeg_len=state->this_frame_params.frame_length; 
  if (state->this_frame_params.signffff !=0xffff) { 
     D0(fprintf(debug_file, "%s:%d: wrong signature - %d\r\n",__FILE__,__LINE__,(int) state->this_frame_params.signffff));
     D1(fprintf(debug_file, "fp=0x%x\r\n",(int) fp));
     D1(fprintf(debug_file, "%08x %08x %08x %08x %08x %08x %08x %08x\r\n",ifp_this[0],ifp_this[1],ifp_this[2],ifp_this[3],ifp_this[4],ifp_this[5],ifp_this[6],ifp_this[7]));
//  int * ifp =      (int *) &(state->this_frame_params) ;
//  int * ifp_this = (int *) &(state->this_frame_params) ;

     state->cirbuf_rp=-1;
     return -CAMOGM_FRAME_BROKEN;
  }
  timestamp_start=fp+((next_jpeg_len+CCAM_MMAP_META+3) & (~0x1f)) + 32 - CCAM_MMAP_META_SEC; 
  if (timestamp_start >= state->circ_buff_size) timestamp_start-=state->circ_buff_size;
  memcpy (&(state->this_frame_params.timestamp_sec), (unsigned long * ) &ccam_dma_buf[timestamp_start>>2],8);
  if ((state->frame_params.width  != state->this_frame_params.width) ||
      (state->frame_params.height != state->this_frame_params.height)) {
     state->cirbuf_rp=fp;
     return -CAMOGM_FRAME_CHANGED; // no yet checking for the FPS
  }
   state->frame_period=(state->this_frame_params.timestamp_usec - state->frame_params.timestamp_usec)+
               1000000*(state->this_frame_params.timestamp_sec  - state->frame_params.timestamp_sec);

  state->frames_skip=      state->set_frames_skip;
  if (state->frames_skip > 0) {
    state->frames_skip_left=0;
    state->frame_period *= (state->frames_skip+1);
//    state->frames_skip_left= state->set_frames_skip;
  } else if (state->frames_skip < 0) {
    state->frame_period=-(state->frames_skip) ; 
    state->frames_skip_left=state->frame_params.timestamp_sec;
  }
   state->time_unit= (ogg_int64_t) (((double) state-> frame_period) * ((double) 10) / ((double) state-> timescale));
   state->width=state->frame_params.width;
   state->height=state->frame_params.height;

   lseek(state->fd_head,state->cirbuf_rp+1,SEEK_END); 

   lseek(state->fd_head,0,0);
   read (state->fd_head,state->jpegHeader,state->head_size);
   lseek(state->fd_circ,state->cirbuf_rp,SEEK_SET);
        audio_start(by_command);
   switch (state->format) {
    case CAMOGM_FORMAT_NONE: rslt= 0;  break;
    case CAMOGM_FORMAT_OGM:  rslt= camogm_start_ogm();  break;
    case CAMOGM_FORMAT_JPEG: rslt= camogm_start_jpeg(); break;
    case CAMOGM_FORMAT_MOV:  rslt= camogm_start_mov();  break;
    default: rslt=0; // do nothing
   }
   if (rslt) return rslt;
   if (state->kml_enable) rslt=camogm_start_kml() ; // will turn on state->kml_used if it can
   if (rslt) return rslt;
   state->running=1;
   state->starting=0;
   D1(fprintf (debug_file,"Started OK\n"));
   return 0;
}

struct timeval v_ts;

int sendImageFrame(void) {
        int rslt;
//      struct frame_params_t this_frame_params;
//      elph_packet_chunk packetchunks[7];
        unsigned char frame_packet_type = PACKET_IS_SYNCPOINT;
//      int chunk_index=0;
//      int i;
//      unsigned long * tts= (unsigned long *) &(state->granulepos); //to word-swap timestamt to granule
        int timestamp_start;
// debugging:
//      int * ifp =      (int *) &(state->frame_params) ;
        int * ifp_this = (int *) &(state->this_frame_params) ;

        struct timeval ts;

        // This is probably needed only for Quicktime (not to exceed already allocated frame index)
        if(state->frameno >= (state->max_frames)) {
fprintf(stderr, "--------------------> there is not enough frames...");
                return -CAMOGM_FRAME_CHANGED;
        }
        // Format changed?
//      D3(fprintf (debug_file,"sendImageFrame: format=%d, set_format=%d\n", state->format, state->set_format));

        if(state->format != state->set_format)
                return -CAMOGM_FRAME_CHANGED;
        // check if file size is exceeded (assuming fopen),-CAMOGM_FRAME_CHANGED will trigger a new segment
//      if((state->vf) && (state->segment_length >= 0) && (ftell(state->vf) > state->segment_length))
        if((state->vf) && (state->segment_length >= 0) && (lseek(state->vf, 0, SEEK_CUR) > state->segment_length))
                return -CAMOGM_FRAME_CHANGED;
        // same for open
        if(((state->ivf) >= 0) && (state->segment_length >= 0) && (lseek(state->ivf, 0, SEEK_CUR) > state->segment_length))
                return -CAMOGM_FRAME_CHANGED;
        // check the frame pointer is valid
        if(lseek(state->fd_circ, state->cirbuf_rp, SEEK_SET) < 0)
                return -CAMOGM_FRAME_INVALID; 
        // is the frame ready?
        if(lseek(state->fd_circ, CIRCLSEEK_READY, SEEK_END) < 0)
                return -CAMOGM_FRAME_NOT_READY; 

        // process skipping frames. TODO: add - skipping time between frames (or better -  actual time period - use the nearest frame) instead of the frame number
        if((state->frames_skip > 0) && (state->frames_skip_left > 0)) { 
                state->cirbuf_rp = lseek(state->fd_circ, CIRCLSEEK_NEXT, SEEK_END);
                // optionally save it to global read pointer (i.e. for debugging with imgsrv "/pointers")
                if(state->save_gp)
                        lseek(state->fd_circ, CIRCLSEEK_SETP, SEEK_END);
                state->frames_skip_left--;
                return -CAMOGM_FRAME_NOT_READY; 
        }

        // Get metadata
//      D3(fprintf (debug_file,"_1_"));
        state->metadata_start = state->cirbuf_rp - 32;
        if(state->metadata_start < 0)
                state->metadata_start += state->circ_buff_size;
        memcpy(&(state->this_frame_params), (unsigned long *)&ccam_dma_buf[state->metadata_start >> 2], 32);
        state->jpeg_len = state->this_frame_params.frame_length; 
        if(state->this_frame_params.signffff != 0xffff) {
                D0(fprintf(debug_file, "%s:%d: wrong signature - %d\r\n",__FILE__,__LINE__,(int) state->this_frame_params.signffff));
                D1(fprintf(debug_file, "state->cirbuf_rp=0x%x\r\n",(int) state->cirbuf_rp));
                D1(fprintf(debug_file, "%08x %08x %08x %08x %08x %08x %08x %08x\r\n",ifp_this[0],ifp_this[1],ifp_this[2],ifp_this[3],ifp_this[4],ifp_this[5],ifp_this[6],ifp_this[7]));
                return -CAMOGM_FRAME_BROKEN;
        }
//      D3(fprintf (debug_file,"_2_"));
        // find location of the timestamp and copy it to the frame_params structure
        timestamp_start = state->cirbuf_rp + ((state->jpeg_len + CCAM_MMAP_META + 3) & (~0x1f)) + 32 - CCAM_MMAP_META_SEC; 
        if(timestamp_start >= state->circ_buff_size)
                timestamp_start -= state->circ_buff_size;
//      D3(fprintf (debug_file,"_3_"));
        memcpy(&(state->this_frame_params.timestamp_sec), (unsigned long *)&ccam_dma_buf[timestamp_start >> 2], 8);

        ts.tv_sec = state->this_frame_params.timestamp_sec;
        ts.tv_usec = state->this_frame_params.timestamp_usec;

        // verify that the essential current frame params did not change, if they did - return an error (need new file header) 
        if((state->frame_params.width != state->this_frame_params.width) || (state->frame_params.height != state->this_frame_params.height))
                return -CAMOGM_FRAME_CHANGED; 
        // check if file duration (in seconds) exceeded ,-CAMOGM_FRAME_CHANGED will trigger a new segment
        if((state->segment_duration > 0) && ((state->this_frame_params.timestamp_sec - state->frame_params.timestamp_sec) > state->segment_duration)) {
fprintf(stderr, "!!! close file !!! \n");
                return -CAMOGM_FRAME_CHANGED;
        }
        // check if (in timelapse mode)  it is too early for the frame to be stored
        if((state->frames_skip < 0) && (state->frames_skip_left > state->this_frame_params.timestamp_sec)) {
                state->cirbuf_rp = lseek(state->fd_circ, CIRCLSEEK_NEXT, SEEK_END);
                // optionally save it to global read pointer (i.e. for debugging with imgsrv "/pointers")
                if(state->save_gp)
                        lseek(state->fd_circ, CIRCLSEEK_SETP, SEEK_END);
                return -CAMOGM_FRAME_NOT_READY; 
        }


//      D3(fprintf (debug_file,"_4_"));
        if(state->exif) {
                D3(fprintf(debug_file,"_5_"));
                // update the Exif header with the current frame metadata
//              updateExif(ep, state->ed, &(state->frame_params));
                state->exifSize = lseek(state->fd_exif, 1, SEEK_END); // at the beginning of page 1 - position == page length
//              if(state->exifSize < 0) state->exifSize = 0; // error from lseek;
                if(state->exifSize > 0) {
//                      state->this_frame_params.meta_index
                        lseek(state->fd_exif, state->this_frame_params.meta_index, SEEK_END); 
                        rslt = read(state->fd_exif, state->ed, state->exifSize);
                        if(rslt < 0)
                                rslt = 0;
                        state->exifSize = rslt;
                } else {
                        state->exifSize = 0;
                }
        } else {
                state->exifSize = 0;
        }

//      D3(fprintf (debug_file,"_6_"));

        // prepare a packet to be sent (a lst of memory chunks)
        state->chunk_index=0;
        state->packetchunks[state->chunk_index  ].bytes=1;
        state->packetchunks[state->chunk_index++].chunk=&frame_packet_type;
        if(state->exif > 0) {
//              D3(fprintf (debug_file,"_7_"));
                state->packetchunks[state->chunk_index  ].bytes = 2;
                state->packetchunks[state->chunk_index++].chunk = state->jpegHeader;
                state->packetchunks[state->chunk_index  ].bytes = state->exifSize;
                state->packetchunks[state->chunk_index++].chunk = state->ed;
                state->packetchunks[state->chunk_index  ].bytes = state->head_size - 2;
                state->packetchunks[state->chunk_index++].chunk = &(state->jpegHeader[2]);
        } else {
//              D3(fprintf (debug_file,"_8_"));
                state->packetchunks[state->chunk_index  ].bytes = state->head_size;
                state->packetchunks[state->chunk_index++].chunk = state->jpegHeader;
        }
//      D3(fprintf (debug_file,"_9_"));

        // JPEG image data may be split in two segments (rolled over buffer end) - process both variants
//      if((jpeg_start + jpeg_len) > state->circ_buff_size) { // two segments
        if((state->cirbuf_rp + state->jpeg_len) > state->circ_buff_size) { 
                // copy from the beginning of the frame to the end of the buffer
//              D3(fprintf (debug_file,"_10_"));
//              sendBuffer((void *) &ccam_dma_buf[jpeg_start>>2], state->circ_buff_size-state->cirbuf_rp);
                state->packetchunks[state->chunk_index  ].bytes = state->circ_buff_size-state->cirbuf_rp;
                state->packetchunks[state->chunk_index++].chunk = (unsigned char*) &ccam_dma_buf[state->cirbuf_rp >> 2];
                // copy from the beginning of the buffer to the end of the frame
//              sendBuffer((void *) &ccam_dma_buf[0], jpeg_len-(state->circ_buff_size-state->cirbuf_rp));
                state->packetchunks[state->chunk_index  ].bytes = state->jpeg_len - (state->circ_buff_size - state->cirbuf_rp);
                state->packetchunks[state->chunk_index++].chunk = (unsigned char*) &ccam_dma_buf[0];
        } else { // single segment
//              D3(fprintf (debug_file,"_11_"));
                // copy from the beginning of the frame to the end of the frame (no buffer rollovers)
//              sendBuffer((void *) &ccam_dma_buf[state->cirbuf_rp>>2], state->jpeg_len);
                state->packetchunks[state->chunk_index  ].bytes = state->jpeg_len;
                state->packetchunks[state->chunk_index++].chunk = (unsigned char*)  &ccam_dma_buf[state->cirbuf_rp >> 2];
        }
//      D3(fprintf (debug_file,"_12_"));
        state->packetchunks[state->chunk_index  ].bytes = 2;
        state->packetchunks[state->chunk_index++].chunk = (unsigned char*) trailer;

        // synchronize audio and video here - skip video if needed...
        // analyze frame timestamp...
        long delta = ts.tv_sec - v_ts.tv_sec;
        delta *= 1000000;
        delta += ts.tv_usec;
        delta -= v_ts.tv_usec;
//      fprintf(stderr, "timestamp: %d:%06d; delta == %06d\n", ts.tv_sec, ts.tv_usec, delta);
        v_ts = ts;
        state->ts_video = ts;

        int flag = 1;
        if(ctx_a.begin_of_stream_with_audio) {
                if(ctx_a.begin_of_stream_with_audio_trigger) {
                        state->ts_video_start = state->ts_audio;
                        state->ts_video_start.tv_usec += state->frame_period / 2;
                        time_normalize(&state->ts_video_start);
                        ctx_a.begin_of_stream_with_audio_trigger = 0;
                        // compute how many audio samples we need to skip here
                        long audio_to_skip = 0;
                        struct timeval tv = state->ts_video;
                        while(time_comp(&tv, &state->ts_video_start) < 0) {
                                tv.tv_usec += state->frame_period;
                                time_normalize(&tv);
                        }
                        tv.tv_sec -= 1;
                        tv.tv_usec += 1000000;
                        tv.tv_usec -= state->frame_period / 2;
                        time_normalize(&tv);
                        if(tv.tv_sec != state->ts_audio.tv_sec) {
                                audio_to_skip = tv.tv_sec - state->ts_audio.tv_sec;
                                audio_to_skip *= 1000000;
                        }
                        audio_to_skip += tv.tv_usec;
                        audio_to_skip -= state->ts_audio.tv_usec;
                        double s = state->audio_rate;
                        s /= 1000.0;
                        s *= audio_to_skip;
                        s /= 1000.0;
                        ctx_a.audio_skip_samples = (long)s;
                        ctx_a.movie_start = tv;
DA(                     fprintf(stderr, "____ AUDIO started from: %d:%06d; we need to record it from: %d:%06d; audio_to_skip_us == %d; audio samples to skip == %d\n", state->ts_audio.tv_sec, state->ts_audio.tv_usec, tv.tv_sec, tv.tv_usec, audio_to_skip, ctx_a.audio_skip_samples););
                }
DA(             fprintf(stderr, "AUDIO (start): %d:%06d; VIDEO (current): %d:%06d; frame period is: %d\n", state->ts_audio.tv_sec, state->ts_audio.tv_usec, state->ts_video.tv_sec, state->ts_video.tv_usec, state->frame_period););
                if(time_comp(&state->ts_video_start, &state->ts_video) > 0) {
DA(                     fprintf(stderr, "skip the video frame\n"););
                        flag = 0;
                } else {
DA(                     fprintf(stderr, "save the VIDEO frame with time: %d:%06d\n", state->ts_video.tv_sec, state->ts_video.tv_usec););
                        ctx_a.begin_of_stream_with_audio = 0;
                }
        }
        if(flag) {
                switch (state->format) {
                        case CAMOGM_FORMAT_NONE: rslt=0; break;
                        case CAMOGM_FORMAT_OGM:  rslt = camogm_frame_ogm(); break;
                        case CAMOGM_FORMAT_JPEG: rslt = camogm_frame_jpeg(); break;
                        case CAMOGM_FORMAT_MOV:  rslt = camogm_frame_mov(); break;
                        default: rslt = 0; // do nothing
                }
        } else {
                rslt = 0;
        }

        if(rslt)
                return rslt;
        if(state->kml_used)
                rslt = camogm_frame_kml() ; // will turn on state->kml_used if it can
        if(rslt)
                return rslt;

//      D3(fprintf (debug_file,"_14_"));
        // advance frame pointer
        if(flag)
                state->frameno++;
        state->cirbuf_rp = lseek(state->fd_circ, CIRCLSEEK_NEXT, SEEK_END);
        // optionally save it to global read pointer (i.e. for debugging with imgsrv "/pointers")
        if(state->save_gp)
                lseek(state->fd_circ, CIRCLSEEK_SETP, SEEK_END);
//      D3(fprintf (debug_file,"_15_\n"));
//      D3(fprintf (debug_file,"state->cirbuf_rp=0x%08x granulepos=0x%x 0x%x (%d.%06d)\n", state->cirbuf_rp, (int) ((state->granulepos)>>32), (int) (state->granulepos),
//                                                                (int) state->this_frame_params.timestamp_sec, (int)state->this_frame_params.timestamp_usec));
        if(state->frames_skip > 0) {
                state->frames_skip_left = state->frames_skip;
        } else {
                if(state->frames_skip < 0) {
                        state->frames_skip_left += -(state->frames_skip);
                }
        }
        return 0;
}

void audio_finish(int by_command) {
        // finalize audio stream to file here
        // TODO - check the time correctly.
DA(     fprintf(stderr, "here must be last push of the audio to the file\n"););
        struct timeval m_end;
DA(     fprintf(stderr, "  movie start at: %d:%06d\n", ctx_a.movie_start.tv_sec, ctx_a.movie_start.tv_usec););
        m_end = state->ts_video;
        m_end.tv_usec += state->frame_period / 2;
        time_normalize(&m_end);
DA(     fprintf(stderr, "    movie end at: %d:%06d\n", m_end.tv_sec, m_end.tv_usec););

        struct timeval m_len;
        if(m_len.tv_sec != ctx_a.movie_start.tv_sec) {
                m_len.tv_sec = m_end.tv_sec - 1;
                m_len.tv_usec = m_end.tv_usec + 1000000;
        }
        m_len.tv_sec -= ctx_a.movie_start.tv_sec;
        m_len.tv_usec -= ctx_a.movie_start.tv_usec;
        time_normalize(&m_len);
DA(     fprintf(stderr, "    movie length: %d:%06d\n", m_len.tv_sec, m_len.tv_usec););
        ctx_a.movie_start = m_end;
        // calculate how many samples we need to save now for the end
        int fd_stream = open("/dev/ext353", O_RDWR);
        unsigned long rtc[4];
        ioctl(fd_stream, EXT_GET_TIME_SYNC, (void *)&rtc[0]);
        close(fd_stream);
DA(     fprintf(stderr, "_________________ END ____________________\n"););
DA(     fprintf(stderr, "       sys time == %d:%06d\n", rtc[0], rtc[1]););
DA(     fprintf(stderr, "      FPGA time == %d:%06d\n", rtc[2], rtc[3]););
DA(     fprintf(stderr, "AUDIO  sys time == %d:%06d\n", ctx_a.time_last.tv_sec, ctx_a.time_last.tv_usec););
        int flag = 0;
        struct timeval audio_last;
        audio_last = ctx_a.time_last;
        if(m_len.tv_sec > audio_last.tv_sec) {
                m_len.tv_sec--;
                m_len.tv_usec += 1000000;
        }
        m_len.tv_sec -= audio_last.tv_sec;
        m_len.tv_usec -= audio_last.tv_usec;
        time_normalize(&m_len);
        long to_finish_us = m_len.tv_usec + 1000000 * m_len.tv_sec;
DA(     fprintf(stderr, "... and now we need to save audio for this time: %d:%06d - i.e. %06d usecs\n", m_len.tv_sec, m_len.tv_usec, to_finish_us););
        double s = state->audio_rate;
        s /= 1000.0;
        s *= to_finish_us;
        s /= 1000.0;
        ctx_a.to_finish_samples = (long)s;
        // from the state->tv_video_start to ctx_a.time_last (with FPGA time recalculation)
        do {
                audio_process();
                if(ctx_a.to_finish_samples > 0)
                        sched_yield();
        } while(ctx_a.to_finish_samples > 0);
        audio_end(by_command);
}

int camogm_stop(int by_command) {
        int rslt = 0;
        if(!state->running) {
                if(!state->starting) {
                        D2(fprintf (debug_file,"Recording was not running, nothing to stop\n"));
                } else {
                        state->starting = 0;
                        D1(fprintf (debug_file,"Dropping attempt to start\n"));
                }
                return 0;
        }
        D1(fprintf (debug_file,"Ending recording\n"));
        if(state->kml_used)
                camogm_end_kml() ;

        if(ctx_a.audio_present)
                audio_finish(by_command);

        switch(state->format) {
        case CAMOGM_FORMAT_NONE: rslt = 0; break;
        case CAMOGM_FORMAT_OGM:  rslt = camogm_end_ogm(); break;
        case CAMOGM_FORMAT_JPEG: rslt = camogm_end_jpeg();break;
        case CAMOGM_FORMAT_MOV:  rslt = camogm_end_mov(); break;
//      default: return 0; // do nothing
        }
        // now close video file (if it is open)
        if(state->vf)
                close(state->vf);
        state->vf = 0;
        if(rslt)
                return rslt;
        state->last = 1;
        // state->running=0 should be output after file is finished and closed
        state->running = 0;
        state->starting = 0;
        return 0;
}

void camogm_free() {
        int f;
        // free all file format handlers that were used
        // add kml when needed
        for(f = 0; f < 31; f++) {
                if(state->formats & ( 1 << (state->format))) {
                        switch(f) {
                        case CAMOGM_FORMAT_NONE: break;
                        case CAMOGM_FORMAT_OGM:  camogm_free_ogm(); break;
                        case CAMOGM_FORMAT_JPEG: camogm_free_jpeg();break;
                        case CAMOGM_FORMAT_MOV:  camogm_free_mov(); break;
                        }
                }
        }
        state->formats = 0;
}

int camogm_reset(void) { 
   state->cirbuf_rp=-1;
   state->buf_overruns=-1; 
   return 0;
}

void  camogm_kml_set_enable(int d) {
   state->kml_enable=d;
}
void  camogm_kml_set_horHalfFov (double dd) {
   state->kml_horHalfFov=dd;
}
void  camogm_kml_set_vertHalfFov(double dd) {
   state->kml_vertHalfFov=dd;
}
void  camogm_kml_set_height_mode(int d) {
   state->kml_height_mode=d;
}
void  camogm_kml_set_height(double dd) {
   state->kml_height=dd;
}
void  camogm_kml_set_period(int d) {
   state->kml_period=d;
   state->kml_last_ts=0;
   state->kml_last_uts=0;
}
void  camogm_kml_set_near(double dd) { // distance to PhotoOverlay
   state->kml_near=dd;
}


void  camogm_set_segment_duration(int sd) {
   state->segment_duration=sd;
}
void  camogm_set_segment_length(int sl) {
   state->segment_length=   sl;
}
void  camogm_set_save_gp(int d) {
   state->save_gp=   d;
}
void  camogm_set_exif(int d) {
   state->exif=   d;
}

void  camogm_set_prefix (const char * p) {
  strncpy(state->path_prefix, p, sizeof(state->path_prefix)-1);
  state->path_prefix[sizeof(state->path_prefix)-1]='\0';
}

void  camogm_set_timescale(double d) { 
   state->set_timescale=  d;
   if ((state->running==0) && (state->starting==0)) {
     state->timescale=state->set_timescale;
   }
}

void  camogm_set_frames_skip(int d) { 
   state->set_frames_skip=  d;
   if ((state->running==0) && (state->starting==0)) {
     state->frames_skip=      state->set_frames_skip;
//     state->frames_skip_left= state->set_frames_skip;
     state->frames_skip_left= 0;
   }
}

void  camogm_set_format(int d) {
   int rslt=0;
   state->set_format = d;
/* set format with the "start" command
   if ((state->running==0) && (state->starting==0)) {
     state->format=  state->set_format;
     switch (state->format) {
      case CAMOGM_FORMAT_NONE: rslt= 0; break;
      case CAMOGM_FORMAT_OGM:  rslt= camogm_init_ogm(); break;
      case CAMOGM_FORMAT_JPEG: rslt= camogm_init_jpeg();break;
      case CAMOGM_FORMAT_MOV:  rslt= camogm_init_mov(); break;
     }
     if (rslt) {
       D0(fprintf (debug_file,"%s:%d: Error setting format to=%d\n",__FILE__,__LINE__, state->format));
     }
     state->formats |= 1 << (state->format);
   }
*/
}

void  camogm_set_max_frames(int d) {
   state->set_max_frames=  d;
   if ((state->running==0) && (state->starting==0)) state->max_frames=  d;
}

void  camogm_set_frames_per_chunk(int d) {
   state->set_frames_per_chunk=  d;
   if ((state->running==0) && (state->starting==0)) state->frames_per_chunk=  d;
}

void  camogm_status(char * fn, int xml) {
  int _len=0;
  int _dur,_udur;
//TODO:make it XML file
  FILE* f;
  char *_state, *_output_format, *_using_exif, *_using_global_pointer, *_compressor_state;
  int _b_free, _b_used; // , save_p;
  int _frames_remain=0;
  int _sec_remain=0;
  int _frames_skip=0;
  int _sec_skip=0;
  char *_kml_enable, *_kml_used, *_kml_height_mode;

  _kml_enable=      state->kml_enable?"yes":"no";
  _kml_used=        state->kml_used?"yes":"no";
  _kml_height_mode= state->kml_height_mode?"GPS altitude":"map ground level";  
  char *_audio_enable, *_allow_sync;
  _audio_enable=      state->set_audio_enable?"yes":"no";
  _allow_sync=      state->set_allow_sync?"yes":"no";


  _b_free=imageParamsR[P_FREECIRCBUF];
  _b_used=imageParamsR[P_CIRCBUFSIZE]-imageParamsR[P_FREECIRCBUF];

  if (!fn) f=stdout;
  else if (strcmp(fn, "stdout")==0) f=stdout;
  else if (strcmp(fn, "stderr")==0) f=stderr;
  else {
    if (!((f=fopen (fn,"w")))) {
       D0(fprintf (debug_file,"Error opening %s\n", fn));
      return;
    }
  }
//  if      (state->vf)       _len=ftell(state->vf); //! for ogm
  if      (state->vf)       _len=lseek(state->vf, 0, SEEK_CUR); 
  else if ((state->ivf)>=0) _len=lseek(state->ivf, 0, SEEK_CUR); 
  _dur= state->this_frame_params.timestamp_sec-state->frame_params.timestamp_sec;
  _udur=state->this_frame_params.timestamp_usec-state->frame_params.timestamp_usec;
  if (_udur<0) {
    _dur-=1;
    _udur+=1000000;
  } else if (_udur>=1000000) {
    _dur+=1;
    _udur-=1000000;
  }
  _state=         state->running? "running":(state->starting?"starting":"stopped");
  _output_format= state->format?((state->format==CAMOGM_FORMAT_OGM)?"ogm":
                                             ((state->format==CAMOGM_FORMAT_JPEG)?"jpeg":
                                             ((state->format==CAMOGM_FORMAT_MOV)?"mov":
                                              "other"))):"none";
  _using_exif=    state->exif?"yes":"no";
  _using_global_pointer=state->save_gp?"yes":"no";
  _compressor_state=(imageParamsR[P_CAMSEQSTATE]==CAMSEQ_RUN)?"running":
                     ((imageParamsR[P_CAMSEQSTATE]==CAMSEQ_SINGLE)?"acquiring":
                      ((imageParamsR[P_CAMSEQSTATE]==CAMSEQ_STOP)?"stoppping":
                       ((imageParamsR[P_CAMSEQSTATE]==CAMSEQ_JPEG)?"stopped":
                        ((imageParamsR[P_CAMSEQSTATE]==CAMSEQ_OFF)?"reset":"other"))));
    if ( state->frames_skip >0 ) {
      _frames_remain= state->frames_skip_left;
      _frames_skip=state->frames_skip;
    } else if ( state->frames_skip <0 ) {
      _sec_remain= (state->frames_skip_left - state->this_frame_params.timestamp_sec);
      _sec_skip=-(state->frames_skip);
    }


  if (xml) {
    fprintf (f,"<?xml version=\"1.0\"?>\n" \
             "<camogm_state>\n" \
             "  <state>\"%s\"</state>\n" \
             "  <compressor_state>\"%s\"</compressor_state>\n" \
             "  <file_name>\"%s\"</file_name>\n" \
             "  <frame_number>%d</frame_number>\n" \
             "  <file_duration>%d.%06d</file_duration>\n" \
             "  <file_length>%d</file_length>\n" \
             "  <frame_period>%d</frame_period>\n" \
             "  <frames_skip>%d</frames_skip>\n" \
             "  <seconds_skip>%d</seconds_skip>\n" \
             "  <frames_skip_left>%d</frames_skip_left>\n" \
             "  <seconds_skip_left>%d</seconds_skip_left>\n" \
             "  <frame_width>%d</frame_width>\n" \
             "  <frame_height>%d</frame_height>\n" \
             "  <format>\"%s\"</format>\n" \
             "  <exif>\"%s\"</exif>\n" \
             "  <prefix>\"%s\"</prefix>\n" \
             "  <max_duration>%d</max_duration>\n" \
             "  <max_length>%d</max_length>\n" \
             "  <max_frames>%d</max_frames>\n" \
             "  <timescale>%f</timescale>\n" \
             "  <frames_per_chunk>%d</frames_per_chunk>\n" \
             "  <buffer_overruns>%d</buffer_overruns>\n" \
             "  <buffer_minimal>%d</buffer_minimal>\n" \
             "  <buffer_free>%d</buffer_free>\n" \
             "  <buffer_used>%d</buffer_used>\n" \
             "  <circbuf_rp>%d</circbuf_rp>\n" \
             "  <debug_output>\"%s\"</debug_output>\n" \
             "  <debug_level>%d</debug_level>\n" \
             "  <use_global_rp>\"%s\"</use_global_rp>\n" \
             "  <kml_enable>\"%s\"</kml_enable>\n" \
             "  <kml_used>\"%s\"</kml_used>\n" \
             "  <kml_path>\"%s\"</kml_path>\n" \
             "  <kml_horHalfFov>\"%f\"</kml_horHalfFov>\n" \
             "  <kml_vertHalfFov>\"%f\"</kml_vertHalfFov>\n" \
             "  <kml_near>\"%f\"</kml_near>\n" \
             "  <kml_height_mode>\"%s\"</kml_height_mode>\n" \
             "  <kml_height>\"%f\"</kml_height>\n" \
             "  <kml_period>%d</kml_period>\n" \
             "  <kml_last_ts>%d.%06d</kml_last_ts>\n" \
             "  <audio_enable>\"%s\"</audio_enable>\n" \
             "  <audio_channels>\"%d\"</audio_channels>\n" \
             "  <audio_rate>\"%d\"</audio_rate>\n" \
             "  <allow_sync>\"%s\"</allow_sync>\n" \
             "</camogm_state>\n",
             _state,_compressor_state,state->path,state->frameno,_dur,_udur,_len,state->frame_period, \
             _frames_skip,_sec_skip,_frames_remain, _sec_remain, \
             state->width,state->height,_output_format,_using_exif, \
             state->path_prefix, state->segment_duration, state->segment_length, state->max_frames, state->timescale, \
             state->frames_per_chunk, state->buf_overruns, state->buf_min, _b_free, _b_used, state->cirbuf_rp, \
             state->debug_name, debug_level, _using_global_pointer, \
             _kml_enable,_kml_used,state->kml_path,state->kml_horHalfFov,state->kml_vertHalfFov,state->kml_near,\
             _kml_height_mode,state->kml_height,state->kml_period,state->kml_last_ts,state->kml_last_uts,\
                         _audio_enable,state->set_audio_channels,state->set_audio_rate,_allow_sync);
  } else {
    fprintf (f,"state              %s\n",        _state);
    fprintf (f,"compressor state   %s\n",        _compressor_state);
    fprintf (f,"file               %s\n",        state->path);
    fprintf (f,"frame              %d\n",        state->frameno);
    fprintf (f,"file duration      %d.%06d sec\n",_dur,_udur);
    fprintf (f,"file length        %d B\n",      _len);
    fprintf (f,"frame period       %d (0x%x)\n", state->frame_period,state->frame_period);
    if ( _frames_skip >0 ) fprintf (f,"frames to skip   %d (left %d)\n",_frames_skip, _frames_remain);
    if ( _sec_skip    <0 ) fprintf (f,"timelapse period  %d sec (remaining %d sec)\n", _sec_skip, _sec_remain);
    fprintf (f,"width              %d (0x%x)\n", state->width,state->width);
    fprintf (f,"height             %d (0x%x)\n", state->height,state->height);
    fprintf (f,"\n");
    fprintf (f,"output format      %s\n",        _output_format);
    fprintf (f,"using exif         %s\n",        _using_exif);
    fprintf (f,"path prefix:       %s\n",        state->path_prefix);
    fprintf (f,"max file duration: %d sec\n",    state->segment_duration);
    fprintf (f,"max file length:   %d B\n",      state->segment_length);
    fprintf (f,"max frames         %d\n",        state->max_frames);
    fprintf (f,"timescale          %f\n",        state->timescale);
    fprintf (f,"frames per chunk   %d\n",        state->frames_per_chunk);
    fprintf (f,"\n");
    fprintf (f,"buffer overruns    %d\n",        state->buf_overruns);
    fprintf (f,"buffer minimal     %d\n",        state->buf_min);
    fprintf (f,"buffer free        %d\n",        _b_free);
    fprintf (f,"buffer used        %d\n",        _b_used);
    fprintf (f,"circbuf_rp         %d (0x%x)\n", state->cirbuf_rp,state->cirbuf_rp);
    fprintf (f,"\n");
    fprintf (f,"debug output to    %s\n",        state->debug_name);
    fprintf (f,"debug level        %d\n",        debug_level);
    fprintf (f,"use global pointer %s\n",        _using_global_pointer);
    fprintf (f,"\n\n");
    fprintf (f,"kml_enable         %s\n",        _kml_enable);
    fprintf (f,"kml_used           %s\n",        _kml_used);
    fprintf (f,"kml_path           %s\n",        state->kml_path);
    fprintf (f,"kml_horHalfFov     %f degrees\n",state->kml_horHalfFov);
    fprintf (f,"kml_vertHalfFov    %f degrees\n",state->kml_vertHalfFov);
    fprintf (f,"kml_near           %f m\n",      state->kml_near);
    fprintf (f,"kml height mode    %s\n",        _kml_height_mode);
    fprintf (f,"kml_height (extra) %f m\n",      state->kml_height);
    fprintf (f,"kml_period         %d\n",        state->kml_period);
    fprintf (f,"kml_last_ts        %d.%06d\n",   state->kml_last_ts,state->kml_last_uts);
    fprintf (f,"audio_enable       %s\n",        _audio_enable);
    fprintf (f,"audio_channels     %d\n",        state->set_audio_channels);
    fprintf (f,"audio_rate         %d\n",        state->set_audio_rate);
    fprintf (f,"allow_sync         %s\n",        _allow_sync);
    fprintf (f,"\n\n");

  }
  if ((f!=stdout) && (f!=stderr)) fclose (f);
  if (state->buf_overruns>=0) state->buf_overruns=0; 
  state->buf_min=_b_free;
}

char * getLineFromPipe(FILE* npipe) {
      int fl;
      char * nlp;
      if (cmdstrt > 0) {
        memmove(cmdbuf, &cmdbuf[cmdstrt], sizeof(cmdbuf)- cmdstrt);
        cmdbufp-=cmdstrt;
        cmdstrt=0;
      }
      if (!cmdbufp) cmdbuf[cmdbufp]=0; 
//      nlp= strchr(cmdbuf,'\n');
      nlp= strpbrk(cmdbuf,";\n");
      if (!nlp) { 
        fl=fread(&cmdbuf[cmdbufp], 1,sizeof(cmdbuf)-cmdbufp-1,npipe);
        cmdbuf[cmdbufp+fl]=0;
//        nlp= strchr(&cmdbuf[cmdbufp],'\n'); //! there were no new lines before cmdbufp
        nlp= strpbrk(&cmdbuf[cmdbufp],";\n"); 
        cmdbufp+=fl; 
      }
      if (nlp) {
//printf ("++nlp=%d\n", (int) (nlp-cmdbuf));
        nlp[0]=0;
        cmdstrt=nlp-cmdbuf+1;
//printf ("++cmdstrt=%d\n", cmdstrt);
//printf ("cmdbuf[0]=%d, cmdbuf[1]=%d, cmdbuf[2]=%d, cmdbuf[3]=%d, \n",cmdbuf[0],cmdbuf[1],cmdbuf[2],cmdbuf[3]);
        for (fl=0; cmdbuf[fl] && strchr(" \t",cmdbuf[fl]); fl++);
//printf ("++fl=%d\n", fl);
        return &cmdbuf[fl];
      } else {
//printf ("notready: cmdbufp=%d, cmdstrt=%d\n",cmdbufp, cmdstrt);
          return NULL;
      }
}
// command[= \t]*args[ \t]*
int parse_cmd(FILE* npipe) {
  char * cmd;
  char * args;
  char * argse;
  int d;
  double dd;
//  if (!((cmd=getLineFromPipe(npipe)))) return 0; //! nothing in the pipe
  while(((cmd=getLineFromPipe(npipe))) && !cmd[0]) ;
  if (!cmd) return 0; 
//  printf ("cmd[0]=%d:%s\n",(int) cmd[0],cmd);
  args=strpbrk(cmd,"= \t");
  if (args) {
    args[0]=0;
    args++;
    while (strchr("= \t",args[0])) args++;
    if (args[0]) {
      for (argse=strchr(args,'\0')-1; strchr("= \t",argse[0]);argse--) argse[0]='\0';
    }
    if (!args[0]) args=NULL;
  }
  if      (strcmp(cmd, "start")==0) {
     camogm_start(1);
     return 1;
  } else if (strcmp(cmd, "reset")==0) { 
     camogm_reset();
     return 2;
  } else if (strcmp(cmd, "stop")==0) {
     camogm_stop(1);
     return 3;
  } else if (strcmp(cmd, "exit")==0) { 
     camogm_stop(1);
     camogm_free();
     exit (0);
  } else if (strcmp(cmd, "duration")==0) {
     if (!(args) || (((d= strtol(args, NULL, 10)))<=0)) d=DEFAULT_DURATION;
     camogm_set_segment_duration(d);
     return 4;
  } else if (strcmp(cmd, "length")==0) {
     if (!(args) || (((d= strtol(args, NULL, 10)))<=0)) d=DEFAULT_LENGTH;
     camogm_set_segment_length(d);
     return 5;
  } else if (strcmp(cmd, "prefix")==0) {
     if (args) camogm_set_prefix (args);
     return 6;
  } else if (strcmp(cmd, "status")==0) { 
     camogm_status(args, 0);
     return 7;
  } else if (strcmp(cmd, "xstatus")==0) { 
     camogm_status(args, 1);
     return 7;
  } else if (strcmp(cmd, "save_gp")==0) {
     if ((args) && (((d= strtol(args, NULL, 10)))>=0)) camogm_set_save_gp(d);
     return 8;
  } else if (strcmp(cmd, "exif")==0) {
     if ((args) && (((d= strtol(args, NULL, 10)))>=0)) camogm_set_exif(d);
     return 8;
  } else if (strcmp(cmd, "debug")==0) {
     camogm_debug(args);
     return 9;
  } else if (strcmp(cmd, "timescale")==0) {
     dd= strtod(args,NULL);
     camogm_set_timescale(dd?dd:1.0);
     return 10;


  } else if (strcmp(cmd, "frameskip")==0) {
     d= strtol(args, NULL, 10);
     camogm_set_frames_skip(d);
     return 11;
  } else if (strcmp(cmd, "timelapse")==0) { 
     d= strtol(args, NULL, 10);
     camogm_set_frames_skip(-d);
     return 11;
  } else if (strcmp(cmd, "format")==0) {
     if (args) {
      if      (strcmp(args,  "none")==0) camogm_set_format(0);
      else if ((strcmp(args, "ogm" )==0) || (strcmp(args, "ogg")==0)) camogm_set_format(CAMOGM_FORMAT_OGM);
      else if ((strcmp(args, "jpeg")==0) || (strcmp(args, "jpg")==0)) camogm_set_format(CAMOGM_FORMAT_JPEG);
      else if (strcmp(args,  "mov" )==0)                              camogm_set_format(CAMOGM_FORMAT_MOV);
     }
     return 12;
  } else if (strcmp(cmd, "debuglev")==0) {
     d= strtol(args, NULL, 10);
     camogm_debug_level(d?d:0);
     return 13;
  } else if (strcmp(cmd, "kml")==0) {
     if ((args) && (((d= strtol(args, NULL, 10)))>=0)) camogm_kml_set_enable(d);
     return 14;
  } else if (strcmp(cmd, "kml_hhf")==0) {
     dd= strtod(args,NULL);
     camogm_kml_set_horHalfFov(dd);
     return 15;
  } else if (strcmp(cmd, "kml_vhf")==0) {
     dd= strtod(args,NULL);
     camogm_kml_set_vertHalfFov(dd);
     return 16;
  } else if (strcmp(cmd, "kml_near")==0) {
     dd= strtod(args,NULL);
     camogm_kml_set_near(dd);
     return 17;
  } else if (strcmp(cmd, "kml_alt")==0) {
     if (args) {
      if      (strcmp(args, "gps"   )==0) camogm_kml_set_height_mode(1);
      else if (strcmp(args, "ground")==0) camogm_kml_set_height_mode(0);
     }
     return 18;
  } else if (strcmp(cmd, "kml_height")==0) {
     dd= strtod(args,NULL);
     camogm_kml_set_height(dd);
     return 19;
  } else if (strcmp(cmd, "kml_period")==0) {
     d= strtol(args, NULL, 10);
     camogm_kml_set_period(d?d:1);
     return 20;
  } else if (strcmp(cmd, "audio")==0) {
     if (args) {
                camogm_set_audio_state(args);
     }
     return 21;
  } else if (strcmp(cmd, "audio_format")==0) {
     if (args) {
                camogm_set_audio_format(args);
     }
     return 22;
  } else if (strcmp(cmd, "allow_sync")==0) {
     if (args) {
                camogm_set_sync_state(args);
     }
     return 23;
  }

  return -1;
}

int main(int argc, char *argv[])
{
   const char circbufFileName[]="/dev/circbuf";
//     int fd_circ;
   FILE * cmd_file;
debug_file = stderr;
   const char usage[]=   "This program allows recording of the video/images acquired by Elphel camera to the storage media.\n" \
                         "It is designed to run in the background and accept commands through a named pipe.\n\n" \
                         "Usage:\n\n" \
                         "%s <named_pipe_name>\n\n" \
                         "i.e.:\n\n" \
                         "%s /var/state/camogm_cmd\n\n" \
                         "When the program is runninig you may send commands by writing strings to the command file\n" \
                         "(/var/state/camogm_cmd in the example above). The complete list of available commands is available\n" \
                         "on Elphel Wiki (http://wiki.elphel.com/index.php?title=Camogm), here is the example of usage\n" \
                         "from the shell prompt in the camera:\n\n" \
                         "echo \"status; exif=1; format=jpeg;status=/var/tmp/camogm.status\" > /var/state/camogm_cmd\n\n" \
                         "That will print status information on the standard output (may not be visible if the program was not\n" \
                         "started from the same session), set exif mode on (each frame will have the full Exif header including\n" \
                         "a precise time stamp), set output format to a series of individual JPEG files, and then send status\n" \
                         "information to a file /var/tmp/camogm.status in the camera file system.\n\n" \
                         "This program does not control the process of acquisition of the video/images to the camera internal\n" \
                         "buffer, it only retrieves that data from the buffer (waiting when needed), packages it to selected\n" \
                         "format and stores the result files.\n\n";
   int go=1;
   int cmd;
   int i,rslt;
   state= &sstate; //extern
   if ((argc < 2) || (argv[1][1]=='-'))  { 
     printf (usage,argv[0],argv[0]);
     return 0;
   }
   camogm_init();

   state->fd_exif = open(ExifFileName, O_RDONLY);
   if (state->fd_exif<0) { // check control OK
     D0(fprintf (debug_file,"Error opening %s\n", ExifFileName));
     return -1;
   }

   state->fd_head = open(HeadFileName, O_RDWR);
   if (state->fd_head<0) { // check control OK
     D0(fprintf (debug_file,"Error opening %s\n", HeadFileName));
     return -1;
   }
   state->head_size=lseek(state->fd_head,0,SEEK_END);
   if (state->head_size>JPEG_HEADER_SIZE) {
     D0(fprintf (debug_file,"%s:%d: Too big JPEG header (%d > %d)",__FILE__,__LINE__,state->head_size, JPEG_HEADER_SIZE ));
     return -2;
   }

   state->fd_circ = open(circbufFileName, O_RDWR);
   if (state->fd_circ<0) { // check control OK
      D0(fprintf (debug_file,"Error opening %s\n", circbufFileName));
      return -2;
   }
   state->circ_buff_size=lseek(state->fd_circ,0,SEEK_END);
   ccam_dma_buf = (unsigned long *) mmap(0, state->circ_buff_size, PROT_READ, MAP_SHARED, state->fd_circ, 0);
   if((int)ccam_dma_buf == -1) {
     D0(fprintf (debug_file,"Error in mmap of %s\n",circbufFileName));
//     close (fd_head);
     close(state->fd_circ);
     return -3;
   }


   state->fd_sens = open(SensParsFileName, O_RDWR);
   if (state->fd_sens<0) { // check control OK
      D0(fprintf (debug_file,"Error opening %s\n", SensParsFileName));
      return -2;
   }
   state->senspars_size=lseek(state->fd_sens,0,SEEK_END);
   imageParamsR = (unsigned long *) mmap(0, state->senspars_size, PROT_READ, MAP_SHARED, state->fd_sens, 0);
   if((int)imageParamsR == -1) {
     D0(fprintf (debug_file,"Error in mmap of %s\n",SensParsFileName));
     close(state->fd_sens);
     close(state->fd_circ);
     return -3;
   }



   i=unlink (argv[1]);
   if (i) {
       D1(fprintf (debug_file,"Unlink %s returned %d, errno=%d \n", argv[1], i, errno));
   }
   i=mkfifo(argv[1], 0777); //EEXIST
   if (i) {
    if (errno==EEXIST) {
       D1(fprintf (debug_file,"Named pipe %s already exists, will use it.\n", argv[1]));
    } else {
       D0(fprintf (debug_file,"Can not create a named pipe %s, errno=%d \n", argv[1], errno));
       return -4;
    }
   }

   if (!((cmd_file=fopen(argv[1],"r")))) {
     D0(fprintf (debug_file,"Can not open command file %s\n",argv[1]));
     return -5;
   }
   D1(fprintf (debug_file,"Pipe %s open for reading\n",argv[1]));

#define COMMAND_LOOP_DELAY 500000 //0.5sec
 
        while(go) {
//              D3(fprintf (debug_file,"%s:%d: format=%d, set_format=%d\n",__FILE__,__LINE__, state->format, state->set_format));
                cmd = parse_cmd(cmd_file);
                if(cmd) {
                        if(cmd < 0)
                                D0(fprintf(debug_file,"Unrecognized command\n"));
                } else {
                        if(state->running) {
                                // process audio, if needed (really, check presence at this function)
//                              audio_process();

                                // no commands in queue, started 
//                              D3(fprintf (debug_file,"%s:%d: format=%d, set_format=%d\n",__FILE__,__LINE__, state->format, state->set_format));
                                switch((rslt = -sendImageFrame())) {
                                case 0:
                                        audio_process();
/*
                                        D3(fprintf (debug_file,"%s:line %d - sendImageFrame() returned %d\n" \
                                                "state->cirbuf_rp= 0x%x\n",__FILE__,__LINE__,rslt,state->cirbuf_rp));
*/
                                        break; 
                                case CAMOGM_FRAME_NOT_READY:        
//                                      audio_process();
//     D3(fprintf (debug_file,"%s:line %d - sendImageFrame() returned -%d\n",__FILE__,__LINE__,rslt));
/*
     D3(fprintf (debug_file,"%s:line %d - sendImageFrame() returned -%d\n" \
                                  "state->cirbuf_rp= 0x%x\n",__FILE__,__LINE__,rslt,state->cirbuf_rp));
*/
                                        lseek(state->fd_circ,CIRCLSEEK_WAIT,SEEK_END);
                                        break;
                                case CAMOGM_FRAME_CHANGED:   
                                case CAMOGM_FRAME_NEXTFILE:  
                                case CAMOGM_FRAME_INVALID:   
                                case CAMOGM_FRAME_BROKEN:    

//     D3(fprintf (debug_file,"%s:line %d - sendImageFrame() returned -%d\n",__FILE__,__LINE__,rslt));
fprintf(stderr, "broken frame - restart of sequence...\n");
                                        camogm_stop(0);
                                        camogm_start(0);
                                        break;
                                case CAMOGM_FRAME_FILE_ERR:  
                                case CAMOGM_FRAME_OTHER:     
                                        D0(fprintf (debug_file,"%s:line %d - error=%d\n",__FILE__,__LINE__,rslt));
                                        break;
                                default:
                                        D0(fprintf (debug_file,"%s:line %d - should not get here (rslt=%d)\n",__FILE__,__LINE__,rslt));
                                        exit (-1);
                                } //switch
if(rslt != 0 && rslt != CAMOGM_FRAME_NOT_READY) {
fprintf(stderr, "loosed frame...\n");
}
                        } else {
                                if(state->starting) { 
//   D3(fprintf (debug_file,"%s:%d: format=%d, set_format=%d\n",__FILE__,__LINE__, state->format, state->set_format));

                                        switch ((rslt = -camogm_start(1))) {
                                        case 0:
                                                break; 
                                        case CAMOGM_FRAME_NOT_READY:        


//                lseek(state->fd_circ,CIRCLSEEK_WAIT,SEEK_END);
                                        case CAMOGM_FRAME_CHANGED:   
                                        case CAMOGM_FRAME_NEXTFILE:
                                        case CAMOGM_FRAME_INVALID:   
                                        case CAMOGM_FRAME_BROKEN:    
//     D3(fprintf (debug_file,"%s:line %d - camogm_start() returned -%d,  state->cirbuf_rp= 0x%x\n", __FILE__,__LINE__,rslt,state->cirbuf_rp));
                                                usleep( COMMAND_LOOP_DELAY) ; 
                                                break;
                                        case CAMOGM_FRAME_FILE_ERR:  
                                        case CAMOGM_FRAME_OTHER:     
                                                D0(fprintf (debug_file,"%s:line %d - error=%d\n",__FILE__,__LINE__,rslt));
                                                break;
                                        default:
                                                D0(fprintf (debug_file,"%s:line %d - should not get here (rslt=%d)\n",__FILE__,__LINE__,rslt));
                                                exit (-1);
                                        } //switch
                                } else { 
                                        usleep( COMMAND_LOOP_DELAY) ; 
                                }
                        }
                }
        }
        return 0;
}

/*******************************************************************************
 *
 * audio
 *
 */

void camogm_set_audio_state(char *args) {
        if(strcmp(args, "on") == 0 || strcmp(args, "enable") == 0) {
                state->set_audio_enable = 1;
        }
        if(strcmp(args, "off") == 0 || strcmp(args, "disable") == 0) {
                state->set_audio_enable = 0;
        }
DA(     fprintf(stderr, "request for audio state: %s\n", args););
}

void camogm_set_sync_state(char *args) {
        if(strcmp(args, "on") == 0 || strcmp(args, "enable") == 0) {
                state->set_allow_sync = 1;
        }
        if(strcmp(args, "off") == 0 || strcmp(args, "disable") == 0) {
                state->set_allow_sync = 0;
        }
}

void camogm_set_audio_format(char *args) {
        char buf[8];
        int i;
        int channels = -1;
        int rate = -1;
        char *right = strstr(args, "/");
        if(right != NULL) {
                channels = atol(&right[1]);
                if(channels < AUDIO_CHANNELS_MIN)
                        channels = AUDIO_CHANNELS_MIN;
                if(channels > AUDIO_CHANNELS_MAX)
                        channels = AUDIO_CHANNELS_MAX;
                state->set_audio_channels = channels;
        }
        for(i = 0; i < 7; i++) {
                if(args[i] != '\0' && args[i] != '/')
                        buf[i] = args[i];
                else
                        break;
        }
        buf[i] = '\0';
        if(buf[0] != '\0') {
                rate = atol(buf);
                if(rate < AUDIO_RATE_MIN)
                        rate = AUDIO_RATE_MIN;
                if(rate > AUDIO_RATE_MAX)
                        rate = AUDIO_RATE_MAX;
                state->set_audio_rate = rate;
        }

DA(     fprintf(stderr, "request for audio format: %s; after apply: rate == %d; channels == %d\n", args, state->set_audio_rate, state->set_audio_channels););
}

void camogm_audio_initialize(void) {
        ctx_a.audio_present = 0;
        ctx_a.audio_set = 0;
        ctx_a.capture_handle = NULL;
        ctx_a.sbuffer = NULL;
        ctx_a.sample_time = 200; // ms
}

void audio_process(void) {
        if(ctx_a.audio_present == 0)
                return;
        if(state->format == CAMOGM_FORMAT_JPEG)
                return;
/*
        if(state->format == CAMOGM_FORMAT_JPEG) {
                int slen;
                int _len = 0;
                while((slen = snd_pcm_readi(ctx_a.capture_handle, ctx_a.sbuffer, ctx_a.sbuffer_len)) > 0) {
                        wave_push((void *)ctx_a.sbuffer, slen * 2 * state->audio_channels);
                        _len += slen;
                }
                fprintf(stderr, "process == %d bytes, request == %d bytes\n", _len, ctx_a.sbuffer_len);
        }
*/

// !!! TODO: check here how many seconds (samples) we can send w/o desynchronization with the video stream TODO !!!

int counter = 0;
        void *_buf;
        int _buf_len;
        struct timeval tv_sys;
        if(state->format == CAMOGM_FORMAT_OGM || state->format == CAMOGM_FORMAT_MOV) {
                int slen;
                int _len = 0;
                snd_pcm_status_t *status;
                snd_pcm_status_alloca(&status);
                snd_timestamp_t ts;
                for(;;) {
                        counter++;
                        long avail = 0;
                        avail = snd_pcm_avail_update(ctx_a.capture_handle);
                        gettimeofday(&tv_sys);
                        tv_sys.tv_usec += ctx_a.sample_time;
                        time_normalize(&tv_sys);
                        snd_pcm_status(ctx_a.capture_handle, status);
                        snd_pcm_status_get_tstamp(status, &ts);
//                      avail = snd_pcm_status_get_avail_max(status);
//                      int av = snd_pcm_status_get_avail(status);
                        int to_push_flag = 0;
                        int to_read = ctx_a.sbuffer_len; // length in the samples...
                        if(ctx_a.to_finish_samples < 0)
                                ctx_a.to_finish_samples = 0;
                        if(avail >= ctx_a.sbuffer_len && ctx_a.to_finish_samples == 0)
                                to_push_flag = 1;
                        if(ctx_a.to_finish_samples > 0) {
                                if(ctx_a.to_finish_samples > ctx_a.sbuffer_len) {
                                        if(avail >= ctx_a.sbuffer_len) {
                                                to_read = ctx_a.sbuffer_len;
                                                ctx_a.to_finish_samples -= ctx_a.sbuffer_len;
                                                to_push_flag = 2;
                                        }
                                } else {
                                        if(avail >= ctx_a.to_finish_samples) {
                                                to_read = ctx_a.to_finish_samples;
                                                ctx_a.to_finish_samples = 0;
                                                to_push_flag = 2;
                                        }
                                }
                        }
                        if(to_push_flag) {
                                slen = snd_pcm_mmap_readi(ctx_a.capture_handle, (void *)(ctx_a.sbuffer + AUDIO_SBUFFER_PREFIX), to_read);
//                              snd_pcm_status(ctx_a.capture_handle, status);
//                              snd_pcm_status_get_tstamp(status, &ts);
                                if(slen > 0) {
                                        int flag = 1;
                                        long offset = 0;
                                        // check the length of the movie and sound track
                                        if(to_push_flag == 1) {
                                                struct timeval sl = ctx_a.time_last;
                                                sl.tv_usec += ctx_a.sample_time;
                                                time_normalize(&sl);
                                                struct timeval m_end;
                                                m_end = state->ts_video;
                                                m_end.tv_usec += state->frame_period / 2;
                                                time_normalize(&m_end);
                                                struct timeval m_len;
                                                if(m_len.tv_sec != ctx_a.movie_start.tv_sec) {
                                                        m_len.tv_sec = m_end.tv_sec - 1;
                                                        m_len.tv_usec = m_end.tv_usec + 1000000;
                                                }
                                                m_len.tv_sec -= ctx_a.movie_start.tv_sec;
                                                m_len.tv_usec -= ctx_a.movie_start.tv_usec;
                                                time_normalize(&m_len);
                                                if(time_comp(&sl, &m_len) > 0) {
                                                        // sound too early - skip this sequence
                                                        break;
                                                }
                                        }
                                        // we need to skip some samples in a new session
                                        // but if we just will switch the frames - we need to split new samples in the buffer for two parts - for the previous file,
                                        // and the next one...
                                        // so we can just save in the first file new data, and for the next - use "skip_samples" field
                                        if(ctx_a.audio_skip_samples != 0) {
DA(fprintf(stderr, "skip_samples == %d\n", ctx_a.audio_skip_samples, slen););
                                                if(ctx_a.audio_skip_samples >= slen) {
                                                        ctx_a.audio_skip_samples -= slen;
                                                        flag = 0;
                                                } else {
                                                        offset = ctx_a.audio_skip_samples;
                                                        ctx_a.audio_skip_samples = 0;
                                                }
                                        } 
                                        if(flag) {
                                                long samples = slen - offset;
                                                ctx_a.audio_count += samples;
                                                _buf = (void *)(ctx_a.sbuffer + AUDIO_SBUFFER_PREFIX);
                                                _buf = (void *)((char *)_buf + offset * 2 * state->audio_channels);
                                                _buf_len = samples * 2 * state->audio_channels;
                                                if(state->format == CAMOGM_FORMAT_OGM)
                                                        camogm_audio_ogm_push(_buf, _buf_len, samples, AUDIO_SBUFFER_PREFIX);
                                                if(state->format == CAMOGM_FORMAT_MOV)
                                                        camogm_audio_mov(_buf, _buf_len, samples);
                                                float tr = 1.0 / state->audio_rate;
                                                float l = tr * ctx_a.audio_count;
                                                unsigned long s = (unsigned long)l;
                                                l -= s;
                                                l *= 1000000;
                                                unsigned long us = (unsigned long)l;
                                                ctx_a.time_last.tv_sec = s;
                                                ctx_a.time_last.tv_usec = us;
DA(                                             fprintf(stderr, "%d: sound time %d:%06d, at %d:%06d; and the sound time is: %d:%06d, samples: %d\n", counter, s, us, tv_sys.tv_sec, tv_sys.tv_usec, ctx_a.time_last.tv_sec, ctx_a.time_last.tv_usec, samples););
                                        }
                                }
                        } else {
                                break;
                        }
                }
        }
}

void audio_init(by_command) {
        // apply settings - i.e. just copy to current
        state->audio_enable = state->set_audio_enable;
        state->audio_rate = state->set_audio_rate;
        state->audio_channels = state->set_audio_channels;
        state->allow_sync = state->set_allow_sync;

//      ctx_a.audio_count = 0;
//      ctx_a.audio_skip_samples = 0;

        int slen;
        snd_timestamp_t audio_ts;
        if(state->audio_enable == 0) {
                return;
        }
        if(state->format == CAMOGM_FORMAT_JPEG)
                return;
        // set up audio device
        if(by_command && !ctx_a.audio_set) {
                snd_pcm_hw_params_t *hw_params;
                ctx_a.audio_set = 1;
//              sbuffer_len = state->audio_rate * 2 * state->audio_channels * sample_time;
//              ctx_a.sbuffer_len = state->audio_rate * state->audio_channels * ctx_a.sample_time;
                ctx_a.sbuffer_len = state->audio_rate * ctx_a.sample_time;
                ctx_a.sbuffer_len /= 1000;
                ctx_a.sbuffer_len -= ctx_a.sbuffer_len % 2;

DA(             fprintf(stderr, "sbuffer_len == %d\n", ctx_a.sbuffer_len););

//              state->audio_format = SND_PCM_FORMAT_S16_LE;
                int audio_format = SND_PCM_FORMAT_S16_LE;

                int err;
                ctx_a.sbuffer = (void *)malloc(ctx_a.sbuffer_len * 8 + AUDIO_SBUFFER_PREFIX);
                if((err = snd_pcm_open(&ctx_a.capture_handle, "default", SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK)) < 0)
                        return;
                if((err = snd_pcm_hw_params_malloc(&hw_params)) < 0)
                        return;
                if((err = snd_pcm_hw_params_any(ctx_a.capture_handle, hw_params)) < 0)
                        return;
                snd_pcm_access_mask_t *mask = alloca(snd_pcm_access_mask_sizeof());
                snd_pcm_access_mask_none(mask);
                snd_pcm_access_mask_set(mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED);
                if((err = snd_pcm_hw_params_set_access_mask(ctx_a.capture_handle, hw_params, mask)) < 0)
                        return;
//              if((err = snd_pcm_hw_params_set_format(ctx_a.capture_handle, hw_params, state->audio_format)) < 0)
                if((err = snd_pcm_hw_params_set_format(ctx_a.capture_handle, hw_params, audio_format)) < 0)
                        return;
                unsigned int t = state->audio_rate;
                if((err = snd_pcm_hw_params_set_rate_near(ctx_a.capture_handle, hw_params, &t, 0)) < 0)
                        return;
                state->audio_rate = t;
                if((err = snd_pcm_hw_params_set_channels(ctx_a.capture_handle, hw_params, state->audio_channels)) < 0)
                        return;
                if((err = snd_pcm_hw_params(ctx_a.capture_handle, hw_params)) < 0)
                        return;
                snd_pcm_uframes_t buffer_time = 2000000;
                if((err = snd_pcm_hw_params_set_buffer_time_near(ctx_a.capture_handle, hw_params, &buffer_time, 0)) < 0)
                        return;
//              fprintf(stderr, "buffer_time is == %d\n", buffer_time);

                snd_pcm_sw_params_t *sw_params;
                snd_pcm_sw_params_malloc(&sw_params);
                err = snd_pcm_sw_params_current(ctx_a.capture_handle, sw_params);
                if(err < 0)     return;
                err = snd_pcm_sw_params_set_tstamp_mode(ctx_a.capture_handle, sw_params, SND_PCM_TSTAMP_MMAP);
                if(err < 0)     return;
                err = snd_pcm_sw_params(ctx_a.capture_handle, sw_params);
                if(err < 0)     return;
                snd_pcm_sw_params_free(sw_params);
                
                snd_pcm_hw_params_free(hw_params);
                if((err = snd_pcm_prepare(ctx_a.capture_handle)) < 0)
                        return;

                ctx_a.audio_present = 1;
                ctx_a.begin_of_stream_with_audio = 1;
                ctx_a.begin_of_stream_with_audio_trigger = 1;

                ctx_a.audio_count = 0;
                ctx_a.audio_skip_samples = 0;

                int fd_stream = open("/dev/ext353", O_RDWR);
                unsigned long rtc[4];
                ioctl(fd_stream, EXT_GET_TIME_SYNC, (void *)&rtc[0]);
                close(fd_stream);
DA(             fprintf(stderr, "SYNC; sys time == %d:%06d; ", rtc[0], rtc[1]););
DA(             fprintf(stderr, "FPGA time == %d:%06d\n", rtc[2], rtc[3]););

                fprintf(stderr, "audio_init(%d)... OK\n", by_command);
                snd_pcm_status_t *status;
                snd_pcm_status_alloca(&status);
                while((slen = snd_pcm_mmap_readi(ctx_a.capture_handle, (void *)(ctx_a.sbuffer), 2)) < 0)
                        snd_pcm_prepare(ctx_a.capture_handle);
                snd_pcm_status(ctx_a.capture_handle, status);
                snd_pcm_status_get_tstamp(status, &audio_ts);
DA(             fprintf(stderr, "audio: device is open...   !!!!!!!!!!!!!!!!!!!; slen == %d\n", slen););

                struct timeval d; // SYS time - FPGA time;
                d.tv_sec = rtc[0] - 1;
                d.tv_usec = rtc[1] + 1000000;
                d.tv_sec -= rtc[2];
                d.tv_usec -= rtc[3];
                time_normalize(&d);
                struct timeval tv;
                tv = audio_ts;
                tv.tv_sec -= 1;
                tv.tv_usec += 1000000;
                tv.tv_sec -= d.tv_sec;
                tv.tv_usec -= d.tv_usec;
                time_normalize(&tv);
                state->ts_audio = tv;

                gettimeofday(&tv, NULL);
DA(             fprintf(stderr, "audio_init(%d) - at %d:%06d", by_command, tv.tv_sec, (unsigned)tv.tv_usec););
DA(             fprintf(stderr, "status at %d:%06d\n", audio_ts.tv_sec, audio_ts.tv_usec););
        }
}

void audio_start(int by_command) {
        state->audio_frameno = 0;
        state->audio_samples = 0;
        ctx_a.to_finish_samples = 0;
        ctx_a.time_last.tv_sec = 0;
        ctx_a.time_last.tv_usec = 0;
        ctx_a.audio_count = 0;
        if(state->format == CAMOGM_FORMAT_JPEG)
                return;
/*
        if(state->format == CAMOGM_FORMAT_JPEG) {
                if(ctx_a.audio_present) {
                        char fname[256];
                        sprintf(fname, "%s_01.wav", state->path_prefix);
                        // open WAV file...
                        fprintf(stderr, "open WAV file, name == \"%s\"\n", fname);
                        wave_begin(fname);
                }
        }
*/
        struct timeval tv;
        gettimeofday(&tv, NULL);
DA(     fprintf(stderr, "audio_start(%d) - at %d:%06d\n", by_command, tv.tv_sec, (unsigned)tv.tv_usec););
}

void audio_end(int by_command) {
        if(ctx_a.audio_present) {
                if(state->format == CAMOGM_FORMAT_JPEG)
                        return;
/*
                if(state->format == CAMOGM_FORMAT_JPEG) {
                        // close WAV file...
                        fprintf(stderr, "close WAV file\n");
                        wave_end();
                }
*/
        }
        // set down audio device
        if(by_command && ctx_a.audio_set) {
                ctx_a.audio_present = 0;
                ctx_a.audio_set = 0;
                snd_pcm_close(ctx_a.capture_handle);
DA(             fprintf(stderr, "audio: device is closed... !!!!!!!!!!!!!!!!!!!\n"););
                free((void *)ctx_a.sbuffer);
                ctx_a.sbuffer = NULL;
        }
//      fprintf(stderr, "audio_end(%d)\n", by_command);
        struct timeval tv;
        gettimeofday(&tv, NULL);
DA(     fprintf(stderr, "audio_end(%d) - at %d:%06d\n", by_command, tv.tv_sec, (unsigned)tv.tv_usec););
}

void audio_free(void) {
//      fprintf(stderr, "audio_free()\n");
}

---