/*
  Kjetil Matheussen, 2005-2008.
    
    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 2 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, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/


#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sndfile.h>
#include <pthread.h>
#include <semaphore.h>
#include <math.h>
#include <stdarg.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#include <sys/time.h>
#include <sys/resource.h>



#include <jack/jack.h>
#include <jack/ringbuffer.h>

#include "atomic/lflifo.h"
#include "atomic/lffifo.h"


extern char **environ;

#define JC_MAX(a,b) (((a)>(b))?(a):(b))
#define JC_MIN(a,b) (((a)<(b))?(a):(b))

#define OPTARGS_CHECK_GET(wrong,right) lokke==argc-1?(fprintf(stderr,"Must supply argument for '%s'\n",argv[lokke]),exit(-2),wrong):right

#define OPTARGS_BEGIN(das_usage) {int lokke;const char *usage=das_usage;for(lokke=1;lokke<argc;lokke++){char *a=argv[lokke];if(!strcmp("--help",a)||!strcmp("-h",a)){fprintf(stderr,usage);return 0;
#define OPTARG(name,name2) }}else if(!strcmp(name,a)||!strcmp(name2,a)){{
#define OPTARG_GETINT() OPTARGS_CHECK_GET(0,atoi(argv[++lokke]))
//int optargs_inttemp;
//#define OPTARG_GETINT() OPTARGS_CHECK_GET(0,(optargs_inttemp=strtol(argv[++lokke],(char**)NULL,10),errno!=0?(perror("strtol"),0):optargs_inttemp))
#define OPTARG_GETFLOAT() OPTARGS_CHECK_GET(0.0f,atof(argv[++lokke]))
#define OPTARG_GETSTRING() OPTARGS_CHECK_GET("",argv[++lokke])
#define OPTARG_LAST() }}else if(lokke==argc-1 && argv[lokke][0]!='-'){lokke--;{
#define OPTARGS_ELSE() }else if(1){
#define OPTARGS_END }else{fprintf(stderr,usage);return(-1);}}}



/* Arguments and their default values */
static float buffer_time=20;
static jack_client_t *client=NULL;
#define DEFAULT_NUM_CHANNELS 2
static int channels=-1;
static int bitdepth=0;
static char *base_filename=NULL;
static char *filename=NULL;
static bool use_vu=true;
static bool use_meterbridge=false;
static bool show_bufferusage=true;
static char *meterbridge_type="vu";
static char *meterbridge_reference="0";
static int vu_len=56;
static int vu_dB=true;
static float vu_bias=1.0f;
static int leading_zeros=1;
static double recording_time=0.0;
static int disk_error_stop=0;
static int disk_errors=0;
static char *soundfile_format="wav";
static bool silent=false;
static bool write_to_stdout=false;

/* JACK data */
static jack_port_t **ports;
static jack_port_t **ports_meterbridge=NULL;
typedef jack_default_audio_sample_t sample_t;
static int jack_buffer_size;
static volatile int jack_buffer_size_is_changed_to=0;
static float jack_samplerate;
static int unreported_overruns=0;
static bool jack_has_been_shut_down=false;


/* Disk thread */
static pthread_t disk_thread={0};
static pthread_mutex_t disk_thread_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t  data_ready = PTHREAD_COND_INITIALIZER;
static bool disk_thread_has_high_priority=false;


/* Helper thread */
static pthread_t helper_thread={0};
static float *vu_vals=NULL;
static int   *vu_times=NULL;
static int *vu_peaks=NULL;
static float *vu_peakvals=NULL;
static bool disk_thread_should_boost_priority=false;
static int total_overruns=0;
static void print_error(const char *fmt, ...);

/* Synchronization between jack process thread and disk thread. */
static volatile int is_initialized=0; // This $@#$@#$ variable is needed because jack ports must be initialized _after_ (???) the client is activated. (stupid jack)
static volatile int is_running=1;

typedef struct buffer_t{
  lifocell * volatile top;
  int overruns;
  sample_t data[];
} buffer_t;

static pid_t mainpid;


/* Jack connecting thread. */
static pthread_t connect_thread={0} ;
static pthread_cond_t  connect_ready = PTHREAD_COND_INITIALIZER;






/////////////////////////////////////////////////////////////////////
//////////////////////// VARIOUS ////////////////////////////////////
/////////////////////////////////////////////////////////////////////

static void* my_calloc(size_t size1,size_t size2){
  size_t size=size1*size2;
  void* ret=malloc(size);
  if(ret==NULL){
    fprintf(stderr,"\nOut of memory. Try a smaller buffer\n");
    exit(5);
  }
  memset(ret,0,size);
  return ret;
}




/////////////////////////////////////////////////////////////////////
//////////////////////// BUFFERS ////////////////////////////////////
/////////////////////////////////////////////////////////////////////


static lifo free_buffers;
static fifo used_buffers;

static fifo das_buffers;

//static sample_t **buffers=NULL;
static sample_t *empty_buffer;

static int num_buffers;
static int buffer_size;
static int buffer_size_in_bytes;

static bool increase_buffer(float time){

  if(time<0.01f){
    print_error("Unable to allocate new buffer\n");
    return false;
  }

  buffer_size = channels*jack_buffer_size;
  buffer_size_in_bytes = sizeof(buffer_t) + buffer_size*sizeof(sample_t);

  num_buffers =   
    (1 + (time * jack_samplerate))
    / jack_buffer_size;

  {
    fifocell *das_buffer=my_calloc(1,sizeof(fifocell*) + num_buffers*buffer_size_in_bytes);
    if(das_buffer==NULL)
      return increase_buffer(time/2.0f);

    fifoput(&das_buffers,das_buffer);
    
    {
      int i;
      char *data=(char*)&(das_buffer->value[0]);
      
      for(i=0;i<num_buffers;i++){
	lifocell *free=(lifocell*) (data + (i*buffer_size_in_bytes));
	lfpush(&free_buffers,free);
      }
    }
  }

  return true;
}

static void buffers_init(int jackbuffersize){

  if(jack_buffer_size!=jackbuffersize)
    if(silent==false)
      fprintf(stderr,"(Reallocating buffers to fit jack buffer size of %d)\n",jackbuffersize);

  jack_buffer_size=jackbuffersize;

  lfinit(&free_buffers);
  fifoinit(&used_buffers);
  fifoinit(&das_buffers);

  increase_buffer(buffer_time);

  empty_buffer=my_calloc(sizeof(sample_t),jack_buffer_size*channels);
  
  {
    jack_buffer_size=jackbuffersize;
    jack_buffer_size_is_changed_to=0;
  }
}


// This is called from the same thread which calls the process() function.
int buffersizecallback(size_t newsize,void *arg){  
  fprintf(stderr,"Waraning, buffersizecallback not implemented yet for this beta. Please use an older version of jack_capture.\n");
#if 0
  jack_buffer_size_is_changed_to=newsize;
  buffer_get_internal(true);
  if(pthread_mutex_trylock(&disk_thread_lock)==0){
    pthread_cond_signal(&data_ready);
    pthread_mutex_unlock(&disk_thread_lock);
  }
#endif
  return 0;
}



/////////////////////////////////////////////////////////////////////
//////////////////////// PORTNAMES //////////////////////////////////
/////////////////////////////////////////////////////////////////////
static char **cportnames=NULL;
static int num_cportnames=0;

static int findnumports(char **ports){
  int ret=0;
  while(ports && ports[ret]!=NULL)
    ret++;
  return ret;
}


static void portnames_add_defaults(void){
  if(cportnames==NULL){
    cportnames=(char **)jack_get_ports(client,NULL,NULL,JackPortIsPhysical|JackPortIsInput);
    num_cportnames=JC_MAX(DEFAULT_NUM_CHANNELS,findnumports(cportnames));
    if(num_cportnames==0){
      fprintf(stderr,"No physical output ports found in your jack setup. Exiting.\n");
      exit(0);
    }
    if(channels==-1)
      channels=DEFAULT_NUM_CHANNELS;
  }else
    if(channels==-1)
      channels=num_cportnames;

  if(channels<=0){
    fprintf(stderr,"No point recording 0 channels. Exiting.\n");
    exit(0);
  }

  // At this point, the variable "channels" has a known and valid value.
  vu_vals=my_calloc(sizeof(float),channels);
  vu_times=my_calloc(sizeof(int),channels);
  vu_peaks=my_calloc(sizeof(int),channels);
  vu_peakvals=my_calloc(sizeof(float),channels);

}

static void portnames_add(char *name){
  char **outportnames;
  int add_ch;

  if(name[strlen(name)-1]=='*'){
    char pattern[strlen(name)];

    sprintf(pattern,name);

    pattern[strlen(name)-1]=0;

    outportnames=(char**)jack_get_ports(client,pattern,"",0);
    //char **outportnames=(char**)jack_get_ports(client,"system:capture_1$","",0);
    add_ch=findnumports(outportnames);
  }else{
    outportnames=my_calloc(1,sizeof(char*));
    outportnames[0]=name;
    add_ch=1;
  }

  if(add_ch>0){
    cportnames=realloc(cportnames,(num_cportnames+add_ch)*sizeof(char*));
    
    {
      int ch=0;
      while(outportnames[ch]!=NULL){
	cportnames[num_cportnames]=outportnames[ch];
	ch++;
	num_cportnames++;
      }
    }
    
  }else{
    fprintf(stderr,"\nWarning, No port(s) with name \"%s\".\n",name);
    if(cportnames==NULL)
      if(silent==false)
	fprintf(stderr,"This could lead to using default ports instead.\n");
  }
}


static char **portnames_get_connections(int ch){
  if(ch>=num_cportnames)
    return NULL;
  else{      
    jack_port_t* port=jack_port_by_name(client,cportnames[ch]);
    char **ret;
    
    if(jack_port_flags(port) & JackPortIsInput){
      ret=(char**)jack_port_get_all_connections(client,port);
    }else{
      ret=my_calloc(2,sizeof(char*));
      ret[0]=cportnames[ch];
    }
    
    return ret;
  }
}





/////////////////////////////////////////////////////////////////////
//////////////////////// console meter //////////////////////////////
/////////////////////////////////////////////////////////////////////

// Note that only the name "vu" is used instead of "console meter".
// I know (now) it's not a vu at all. :-)


// Function iec_scale picked from meterbridge by Steve Harris.
static int iec_scale(float db) {
         float def = 0.0f; /* Meter deflection %age */
 
         if (db < -70.0f) {
                 def = 0.0f;
         } else if (db < -60.0f) {
                 def = (db + 70.0f) * 0.25f;
         } else if (db < -50.0f) {
                 def = (db + 60.0f) * 0.5f + 5.0f;
         } else if (db < -40.0f) {
                 def = (db + 50.0f) * 0.75f + 7.5;
         } else if (db < -30.0f) {
                 def = (db + 40.0f) * 1.5f + 15.0f;
         } else if (db < -20.0f) {
                 def = (db + 30.0f) * 2.0f + 30.0f;
         } else if (db < 0.0f) {
                 def = (db + 20.0f) * 2.5f + 50.0f;
         } else {
                 def = 100.0f;
         }
 
         return (int)(def * 2.0f);
}

static void init_vu(){
  //int channels=4;
  int ch;
  for(ch=0;ch<channels;ch++)
    printf("\n");
}

static void init_show_bufferusage(){
  printf("\n");
}


// Console colors:
// http://www.linuxjournal.com/article/8603

static void print_console(){
  //int channels=4;
  int ch;
  char vol[vu_len+5000];
  vol[2]=':';
  vol[3]='|';
  vol[4+vu_len+1]=0;

  // Values have not been updated since last time. Return.
  if(vu_vals[0]==-1.0f)
    return;

  // Move cursor up.
  printf("%c[%dA",0x1b,use_vu&&show_bufferusage?channels+1:use_vu?channels:1);

  // Set cyan color
  printf("%c[36m",0x1b);

  if(use_vu)
    for(ch=0;ch<channels;ch++){
      int i;
      float val=vu_vals[ch];
      int pos;
      vu_vals[ch]=-1.0f;
      
      if(vu_dB)
        pos=iec_scale(20.0f * log10f(val * vu_bias)) * (vu_len) / 200;
      else
        pos=val*(vu_len);
      
      if (pos > vu_peaks[ch]) {
        vu_peaks[ch] = pos;
        vu_peakvals[ch] = val;
        vu_times[ch] = 0;
      } else if (vu_times[ch]++ > 40) {
        vu_peaks[ch] = pos;
        vu_peakvals[ch] = val;
      }
      
      if(ch>9){
        vol[0]='0'+ch/10;
        vol[1]='0'+ch-(10*(ch/10));
      }else{
        vol[0]='0';
        vol[1]='0'+ch;
      }
      
      for(i=0;i<vu_len;i++)
        if(vu_peaks[ch]==i && vu_peakvals[ch]>0.0f)
          vol[4+i]='*';
        else if(i<=pos && val>0.0f)
          vol[4+i]='-';
        else
          vol[4+i]=' ';
      
      if(vu_peakvals[ch]>=1.0f){
        vol[4+vu_len]='!';
        printf("%c[31m",0x1b); //red color
        puts(vol);
        printf("%c[36m",0x1b); // back to cyan
      }else{
        vol[4+vu_len]='|';
        puts(vol);
      }
    }

  if(show_bufferusage){
    float buflen=num_buffers*jack_buffer_size/jack_samplerate;
    int   num_bufleft=lfsize(&free_buffers);
    float bufleft=num_bufleft*jack_buffer_size/jack_samplerate;
    printf("%c[32m",0x1b); // green color
    printf("Buffer: %.2fs / %.2fs. Disk high priority: [%c]. Overruns: %d\n",bufleft,buflen,disk_thread_has_high_priority?'x':' ',total_overruns);
    //100*(1+jack_ringbuffer_write_space(rb))/(num_buffers*sizeof(struct ringbuffer_block)));
  }

  printf("%c[0m",0x1b); // reset colors
}



/////////////////////////////////////////////////////////////////////
//////////////////////// Helper thread //////////////////////////////
/////////////////////////////////////////////////////////////////////

char message_string[5000]={0};

static int helper_thread_running=0;
static int init_meterbridge_ports();

static void *helper_thread_func(void *arg){
  helper_thread_running=1;

  if(use_vu)
    init_vu();

  if(show_bufferusage)
    init_show_bufferusage();

  while(is_running){
    if(use_vu || show_bufferusage)
      print_console();

    if(message_string[0]!=0){
      //fprintf(stderr,"%c[0m",0x1b); // reset colors
      fprintf(stderr,message_string);
      message_string[0]=0;
      if(use_vu)
	init_vu();
      if(show_bufferusage)
        init_show_bufferusage();
    }

    if(init_meterbridge_ports()==1 && use_vu==false && show_bufferusage==false)
      break;
    usleep(1000000/20);
  }

  message_string[0]=0;
  helper_thread_running=0;
  return NULL;
}


static pthread_mutex_t print_error_mutex = PTHREAD_MUTEX_INITIALIZER;  
static void print_error(const char *fmt, ...){
  
  pthread_mutex_lock(&print_error_mutex);{

    while(1
	  && helper_thread_running==1
	  && message_string[0]!=0
	  )
      usleep(20);

    {
      va_list argp;
      va_start(argp,fmt);
      vsprintf(message_string,fmt,argp);
      va_end(argp);
    }
    
    if(helper_thread_running==0){
      fprintf(stderr,"%c[0m",0x1b); // reset colors
      fprintf(stderr,message_string);
    }

  }pthread_mutex_unlock(&print_error_mutex);

}


void setup_helper_thread (void){
  if(0
     || use_vu
     || show_bufferusage
     || use_meterbridge)
    pthread_create(&helper_thread, NULL, helper_thread_func, NULL);
}

static void stop_helper_thread(void){
  if(0
     || use_vu
     || show_bufferusage
     || use_meterbridge)
    pthread_join(helper_thread, NULL);
}




/////////////////////////////////////////////////////////////////////
//////////////////////// DISK ///////////////////////////////////////
/////////////////////////////////////////////////////////////////////

// These four variables are used in case we break the 4GB barriere for standard wav files.
static int num_files=1;
static int64_t disksize=0;
static bool is_using_wav=true;
static int bytes_per_frame;

static SNDFILE *soundfile=NULL;
static unsigned long long overruns=0;



#include "setformat.c"


static int open_soundfile(void){
  int subformat;

  SF_INFO sf_info={0};

  if(write_to_stdout==true)
    return 1;

  sf_info.samplerate = jack_get_sample_rate (client);
  sf_info.channels = channels;
  
  setformat(&sf_info,soundfile_format);

  if(sf_info.format==SF_FORMAT_WAV)
    is_using_wav=true;
  else
    is_using_wav=false;

  bytes_per_frame=bitdepth/8;

  switch (bitdepth) {
  case 8: subformat = SF_FORMAT_PCM_U8;
    break;
  case 16: subformat = SF_FORMAT_PCM_16;
    break;
  case 24: subformat = SF_FORMAT_PCM_24;
    break;
  case 32: subformat = SF_FORMAT_PCM_32;
    break;
  default:
    if(!strcasecmp("flac",soundfile_format)){
      subformat=SF_FORMAT_PCM_24;
      bytes_per_frame=3; // wav is still being used in case flac is not available.
    }else{
      subformat = SF_FORMAT_FLOAT;
      bytes_per_frame=4;
    }
    break;
  }

  sf_info.format |= subformat;

  if(filename==NULL)
    filename=strdup(base_filename);

  if(write_to_stdout==true)
    soundfile=sf_open_fd(fileno(stdout),SFM_WRITE,&sf_info,false);
  else
    soundfile=sf_open(filename,SFM_WRITE,&sf_info);
  // debugging lines below.
  //static int ai=0;
  //ai++;
  if(soundfile==NULL){ // || ai==10){
    fprintf (stderr, "\nCan not open sndfile \"%s\" for output (%s)\n", filename,sf_strerror(NULL));
    return 0;
  }
  return 1;
}


static void close_soundfile(void){
  if(soundfile!=NULL && write_to_stdout==false)
    sf_close (soundfile);

  if (overruns > 0) {
    print_error("\njack_capture failed with a total of %llu overruns.\n", overruns);
    print_error(" try a bigger buffer than -B %f\n",buffer_time);
  }
  if (disk_errors > 0)
    print_error("\nWarning: jack_capture failed with a total of %d disk errors.\n",disk_errors);
}


// To test filelimit handler, uncomment two next lines.
//#undef UINT32_MAX
//#define UINT32_MAX 100000+(1024*1024)

static int handle_filelimit(size_t frames){
  int new_bytes=frames*bytes_per_frame*channels;

  if(is_using_wav && (disksize + ((int64_t)new_bytes) >= UINT32_MAX-(1024*1024))){ // (1024*1024) should be enough for the header.

    sf_close(soundfile);{

      char *filename_new;
      filename_new=my_calloc(1,strlen(base_filename)+500);      
      sprintf(filename_new,"%s.%0*d.wav",base_filename,2,num_files);
      print_error("Warning. 4GB limit on wav file almost reached. Closing %s, and continue writing to %s.\n",filename,filename_new);
      num_files++;
      free(filename);
      filename=filename_new;
      disksize=0;
    }

    if(!open_soundfile())
      return 0;

  }

  disksize+=new_bytes;
  return 1;
}


// stdout_write made by looking at http://mir.dnsalias.com/oss/jackstdout/start
// made by Robin Gareus.
static int stdout_write(float *buffer,size_t frames){
  static char *tobuffer=NULL;
  static int bufferlen=0;
  int bytes_to_write=frames*channels*2;

  if(bufferlen<bytes_to_write){
    free(tobuffer);
    tobuffer=my_calloc(1,bytes_to_write);
    bufferlen=bytes_to_write;
  }

  {
    int i;
    int writeplace=0;
    for(i=0;i<frames*channels;i++){
      int d = (int) rint(buffer[i]*32767.0);
      tobuffer[writeplace++] = (unsigned char) (d&0xff);
      tobuffer[writeplace++] = (unsigned char) (((d&0xff00)>>8)&0xff);
    }
  }

  {
    int fd=fileno(stdout);
    while(bytes_to_write > 0){
      int written=write(fd,tobuffer,bytes_to_write);
      if(written==-1){
	fprintf(stderr,"Error writing to stdout.\n");
	break;
      }
      bytes_to_write -= written;
    }
  }

  return 1;
}

static int disk_write(void *data,size_t frames){

  if(write_to_stdout==true)
    return stdout_write(data,frames);

  if(soundfile==NULL)
    return 0;

  if(!handle_filelimit(frames))
    return 0;
  
  if(sf_writef_float(soundfile,data,frames) != frames){
    print_error("Error. Can not write sndfile (%s)\n",
		sf_strerror(soundfile)
		);
    disk_errors++;
    return 0;
  }
  return 1;
}


static int disk_write_overruns(int num_overruns){
  int lokke;

  print_error(
	      "\nWarning. jack_capture failed with %d overrun%s. Some parts of the recording will contain silence.\n"
	      "Try a bigger buffer than -B %f\n%s",
	      num_overruns,num_overruns==1 ? "" : "s",
	      buffer_time,
	      is_running != 0 ? "Continue recording...\n" : ""
              );

  overruns+=num_overruns;
  for(lokke=0;lokke<num_overruns;lokke++)
    if( ! disk_write(empty_buffer,jack_buffer_size))
      return 0;
  return 1;
}


static void disk_thread_control_priority(void){
  if(1
     && disk_thread_has_high_priority==false
     && disk_thread_should_boost_priority==true
     ){
    if(setpriority(PRIO_PROCESS,0,-20)!=-1){
      disk_thread_has_high_priority=true;
    //fprintf(stderr,"Less than half of the buffer used. Setting higher priority for the disk thread\n");
      print_error("Less than half of the buffer used. Setting higher priority for the disk thread.\n");
    }else{
      static bool message_sent=false;
      if(message_sent)
        print_error("Could not set higher priority for disk thread.\n");
      message_sent=true;
    }       
  }
}

static void *disk_thread_func (void *arg){

	// Main disk loop
	{
	  for(;;){

            int read_space=fifosize(&used_buffers);

	    while(is_initialized && (read_space > 0)){
	      buffer_t *buffer=(buffer_t*)fifoget(&used_buffers);
	      
	      if( buffer->overruns > 0 
		  && ( ! disk_write_overruns(buffer->overruns))
		  && disk_error_stop)
		goto done;
	      
	      if( (! disk_write(buffer->data,jack_buffer_size) )
		  && disk_error_stop)
		goto done;
	      
	      lfpush(&free_buffers,(lifocell*)buffer);
	      
              read_space=fifosize(&used_buffers);

              if( read_space >= (num_buffers/2))
                disk_thread_should_boost_priority=true;

              disk_thread_control_priority();
	    }
	      
	    if(is_running==0)
	      goto done;
	    
	    if(jack_buffer_size_is_changed_to>0)
	      buffers_init(jack_buffer_size_is_changed_to);
	    
	    /* wait until process() signals more data */
	    pthread_cond_wait(&data_ready, &disk_thread_lock);

            // Can't check this here. It's just finished reading.
            //fprintf(stderr,"printit: %d %d %d\n",read_space,(jack_ringbuffer_write_space(rb)/sizeof(struct ringbuffer_block)),(num_buffers/2));

            // Check if priority needs to be boosted.
            disk_thread_control_priority();
	  }
	}


 done:

	if(unreported_overruns>0)
	  disk_write_overruns(unreported_overruns);

	close_soundfile();

	{
	  pthread_mutex_unlock(&disk_thread_lock);
	  if(silent==false)
	    fprintf(stderr,"disk thread finished\n");
	}

	return 0;
}

void setup_disk_thread (void){
  pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
  pthread_mutex_lock(&disk_thread_lock);
  pthread_create(&disk_thread, NULL, disk_thread_func, NULL);
}


void stop_disk_thread(void){
 /* Wake up disk thread. (no trylock) (isrunning==0)*/
  pthread_cond_signal(&data_ready);
  pthread_join(disk_thread, NULL);
}





/////////////////////////////////////////////////////////////////////
//////////////////////// JACK PROCESS ///////////////////////////////
/////////////////////////////////////////////////////////////////////	
void put_jack_buffers_into_buffer(buffer_t *buffer){
  sample_t *data=buffer->data;
  jack_default_audio_sample_t *in[channels];
  int ch;
  int i,pos=0;

  for(ch=0;ch<channels;ch++)
    in[ch]=jack_port_get_buffer(ports[ch],jack_buffer_size);
      
  for(i=0;i<jack_buffer_size;i++)
    for(ch=0;ch<channels;ch++){
      float val=in[ch][i];
      data[pos++]=val;
      val=fabsf(val);
      if(val>vu_vals[ch])
	vu_vals[ch]=val;
    }

#if 0
  if(use_vu)
    for(ch=0;ch<channels;ch++){
      float *inch=in[ch];
      for(i=0;i<jack_buffer_size;i++){
	float new=inch[i];
	if(new>vu_vals[ch])
	  vu_vals[ch]=new;
      }
      for(i=0;i<jack_buffer_size;i++){
	float new=inch[i];
	if(-new>vu_vals[ch])
	  vu_vals[ch]=-new;
      }
    }
#endif
}

void send_buffer_to_disk_thread(buffer_t *buffer){

  buffer->overruns=unreported_overruns;
  fifoput(&used_buffers,(fifocell*)buffer);
  unreported_overruns=0;
  
  if (pthread_mutex_trylock (&disk_thread_lock) == 0) {
    pthread_cond_signal (&data_ready);
    pthread_mutex_unlock (&disk_thread_lock);
  }
}

int process (jack_nframes_t nframes, void *arg){

  if(is_initialized==0)
    return 0;

  if(is_running==0)
    return 0;

  {
    int num_free_buffers=lfsize(&free_buffers);

    if(num_free_buffers < (num_buffers/2))
      disk_thread_should_boost_priority=true;
	
    if((  jack_buffer_size_is_changed_to != 0)  // The inserted silence will have the wrong size, but at least the user will get a report that something was not recorded.
       || num_free_buffers==0
       ){
      unreported_overruns++;
      total_overruns++;
    }else{
      buffer_t *buffer=(buffer_t*)lfpop(&free_buffers);
      put_jack_buffers_into_buffer(buffer);
      send_buffer_to_disk_thread(buffer);
    }
  }
  
  return 0;
}






/////////////////////////////////////////////////////////////////////
/////////////////// METERBRIDGE /////////////////////////////////////
/////////////////////////////////////////////////////////////////////


static char* meterbridge_jackname;
pid_t meterbridge_pid;
pid_t jack_capture_pid;
int meterbridge_started=0;

static void start_meterbridge(int num_channels){
  meterbridge_jackname=my_calloc(1,5000);

  sprintf(meterbridge_jackname,"%s_meterbridge",jack_get_client_name(client));
  //meterbridge -t vu -n meterbri xmms-jack_12250_000:out_0 xmms-jack_12250_000:out_1
  
  jack_capture_pid=getpid();
  meterbridge_pid=fork();
  if(meterbridge_pid==0){
    char *argv[100+num_channels];
    argv[0]=WHICH_METERBRIDGE;
    argv[1]="-t";
    argv[2]=meterbridge_type;
    argv[3]="-n";
    argv[4]=meterbridge_jackname;
    argv[5]="-r";
    argv[6]=meterbridge_reference;
    {
      int ch;
      for(ch=0;ch<num_channels;ch++){
	argv[7+ch]="x";
      }
      argv[7+ch]=NULL;
    }

    
    {
      int fd;
      if((fd = open("/dev/null", O_RDWR | O_CREAT))==-1){
	perror("open");
      }else{    
	dup2(fd,STDOUT_FILENO);
	dup2(fd,STDERR_FILENO);
	close(fd); 
      }
    }

    execve(WHICH_METERBRIDGE,argv,environ);
    exit(0);
  }

  meterbridge_started=1;
}


static void wake_up_connection_thread(void);
int connect_meterbridge=0;

static int init_meterbridge_ports(){
  if(ports_meterbridge!=NULL || meterbridge_started==0)
    return 0;

  {
    char portname[5000];
    sprintf(portname,"%s:meter_1",meterbridge_jackname);
    jack_port_t *port1=jack_port_by_name(client,portname);

    if(port1==NULL){
      return 0;
    }

    {
      jack_port_t **ports_meterbridge2 = (jack_port_t **) my_calloc (sizeof (jack_port_t *),channels);  

      ports_meterbridge2[0]=port1;
      {
	int ch;
	for(ch=1;ch<channels;ch++){
	  sprintf(portname,"%s:meter_%d",meterbridge_jackname,ch+1);
	  ports_meterbridge2[ch]=jack_port_by_name(client,portname);
	  if(ports_meterbridge2[ch]==NULL){
	    print_error("Warning! Something is very wrong with the meterbridge.\n"); // Well, maybe that port hasn't been initializied yet. Must fix some
	    free(ports_meterbridge2);
	    return 0;
	  }
	}
      }
      ports_meterbridge=ports_meterbridge2;
      connect_meterbridge=1;
      wake_up_connection_thread();
      //connect_ports(ports_meterbridge);
      return 1;
    }
  }
}


/////////////////////////////////////////////////////////////////////
/////////////////// JACK CONNECTIONS ////////////////////////////////
/////////////////////////////////////////////////////////////////////


static pthread_mutex_t connect_thread_lock = PTHREAD_MUTEX_INITIALIZER;


static int compare(const void *a, const void *b){
  return strcmp((const char*)a,(const char*)b);
}


static int reconnect_ports_questionmark(void){
  int ch;
  int ret=0;
  for(ch=0;ch<channels;ch++){
    char **connections1 = portnames_get_connections(ch);
    const char **connections2 = jack_port_get_all_connections(client,ports[ch]);
    int memb1=findnumports(connections1);
    int memb2=findnumports((char**)connections2);

    if(memb1!=memb2){
      free(connections1);
      free(connections2);
      ret=1;
      goto exit;
    }
    
    qsort(connections1,memb1,sizeof(char*),compare);
    qsort(connections2,memb1,sizeof(char*),compare);
    
    {
      int lokke = 0;
      for(lokke=0;lokke<memb1;lokke++){
	//printf("connect_ports \"%s\" \"%s\" \n",connections1[lokke],connections2[lokke]);
	if(strcmp(connections1[lokke],connections2[lokke])){
	  ret=1;
	  goto exit;
	}
      }
    }
    free(connections1);
    free(connections2);
  }

 exit:
  return ret;
}


static void disconnect_ports(jack_port_t** ports){
  int ch;

  if(ports==NULL)
    return;

  for(ch=0;ch<channels;ch++){
    int lokke = 0;
    const char **connections = jack_port_get_all_connections(client,ports[ch]);
    while(connections && connections[lokke] != NULL){
      jack_disconnect(client,connections[lokke],jack_port_name(ports[ch]));
      lokke++;
    }
    free(connections);
  }
}


static void connect_ports(jack_port_t** ports){
  int ch;

  if(ports==NULL)
    return;

  for(ch=0;ch<channels;ch++){
    int lokke = 0;
    char **connections = portnames_get_connections(ch);

    while(connections && connections[lokke] != NULL){
      int err=jack_connect(client,connections[lokke],jack_port_name(ports[ch]));
      if(err!=0)
	print_error("\nCan not connect input port %s to %s, errorcode %s\n",
		    jack_port_name (ports[ch]), connections[lokke],strerror(err));      
      lokke++;
    }
    free(connections);
  }
}

static bool connection_thread_started=false;

static void* connection_thread(void *arg){
  connection_thread_started=true;
  while(1){
    pthread_cond_wait(&connect_ready, &connect_thread_lock);
    if(is_running==0)
      goto done;
    if(connect_meterbridge==1){
      connect_ports(ports_meterbridge);
      connect_meterbridge=0;
      continue;
    }
    if(is_initialized && reconnect_ports_questionmark()){
      if(silent==false)
	print_error("(Reconnecting ports)\n");
      disconnect_ports(ports);
      connect_ports(ports);

      disconnect_ports(ports_meterbridge);
      connect_ports(ports_meterbridge);
    }
  }

 done:
  pthread_mutex_unlock(&connect_thread_lock);
  if(silent==false)
    fprintf(stderr,"connection thread finished\n");
  return NULL;
}

static void wake_up_connection_thread(void){
  //Don't want trylock here.
  while(connection_thread_started==false) usleep(10);
  pthread_cond_signal (&connect_ready);
}

static void start_connection_thread(void){
  pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
  pthread_mutex_lock (&connect_thread_lock);
  pthread_create(&connect_thread,NULL,connection_thread,NULL);
}

static void stop_connection_thread(void){
  wake_up_connection_thread();
  pthread_join(connect_thread, NULL);
}

static int graphordercallback(void *arg){
  //print_error("hepp\n");
  wake_up_connection_thread();
  return 0;
}



static void create_ports(void){
  ports = (jack_port_t **) my_calloc (sizeof (jack_port_t *),channels);  
  {
    int ch;
    for(ch=0;ch<channels;ch++) { // Hmm. No port where ch>=num_cportnames will ever be used...
      char name[500];
      sprintf(name,"input%d",ch+1);
      ports[ch]=jack_port_register(client,name,JACK_DEFAULT_AUDIO_TYPE,JackPortIsInput,0);
      if(ports[ch]==0){
	print_error("\nCan not register input port \"%s\"!\n", name);
	jack_client_close(client);
	exit(1);
      }
    }
  }
}






/////////////////////////////////////////////////////////////////////
/////////////////// INIT / WAIT / SHUTDOWN //////////////////////////
/////////////////////////////////////////////////////////////////////


sem_t stop_sem;

static void finish(int sig){
  sem_post(&stop_sem);
}

static void jack_shutdown(void *arg){
  fprintf(stderr,"jack_capture: JACK shutdown.\n");
  jack_has_been_shut_down=true;
  sem_post(&stop_sem);
}


static jack_client_t *new_jack_client(char *name){
  jack_status_t status;
  jack_client_t *client=jack_client_open(name,JackNoStartServer,&status,NULL);

  if(client==NULL){
    print_error("jack_client_open() failed, "
		"status = 0x%2.0x\n", status);
    exit(1);
  }

  return client;
}


static void start_jack(void){
  static bool I_am_already_called=false;
  if(I_am_already_called) // start_jack is called more than once if the --port argument has been used.
    return;

  client=new_jack_client("jack_capture");

  jack_buffer_size=jack_get_buffer_size(client);
  jack_samplerate=jack_get_sample_rate(client);
  I_am_already_called=true;
}


static pthread_t waiting_thread={0};
static void* waiting_func(void* arg){
  if(recording_time>0.0){      
    fprintf(stderr,"Recording to \"%s\". The recording is going to last %lf seconds. Press <Ctrl-C> to stop before that.\n",
            base_filename,
            recording_time);  
    // Should the recording time be accurate? Or is this good enough? (probably good enough. :-) )
    setup_helper_thread();
    sleep(recording_time);
    usleep( (recording_time-floor(recording_time)) * 1000000);
  }else{
    // Wait for <return> or SIGINT
    fprintf(stderr,"Recording to \"%s\". Press <Return> or <Ctrl-C> to stop.\n",base_filename);        
    setup_helper_thread();
    
    char gakk[64];
    fgets(gakk,49,stdin);  
  }
  sem_post(&stop_sem);
  return NULL;
}

static void start_waiting_thread(void){
  pthread_create(&waiting_thread, NULL, waiting_func, NULL);
}

int main (int argc, char *argv[]){

  fprintf(stderr,"WARNING! Do not use this release!\n");

  mainpid=getpid();

  // Arguments
  {
    OPTARGS_BEGIN("jack_capture  [--bitdepth n] [--bufsize seconds] [--channels n] [--port port] [filename]\n"
		  "              [ -b        n] [ -B       seconds] [ -c        n] [ -p    port]\n"
		  "\n"
		  "\"filename\" is by default auotogenerated to something like \"jack_capture_<number>.wav\"\n"
		  "\"bitdepth\" is by default FLOAT. It can be set to either 8, 16, 24 or 32.\n"
		  "\"channels\" is by default 2.\n"
		  "\"bufsize\"  is by default 20 seconds.\n"
                  "\"port\"     is by default set to the physical outputs, which means that jack_capture\n"
                  "           will be constantly connected to the ports connecting to the\n"
                  "           physical outputs. The \"port\" argument can be specified more than once.\n"
		  "\n"
		  "\n"
		  "Additional arguments:\n"
		  "[--duration s] or [-d s]         -> Recording is stopped after \"s\" seconds.\n"
		  "[--leading-zeros n] or [-z n]    -> \"n\" is the number of zeros to in the autogenerated filename.\n"
		  "                                    (-z 2 -> jack_capture_001.wav, and so on.) (default is 1)\n"
		  "[--format format] or [-f format] -> See http://www.mega-nerd.com/libsndfile/api.html#open\n"
		  "                                    (Default is wav)\n"
		  "[--print-formats] or [-pf]       -> Prints all valid sound formats to screen and then exits.\n"
		  "[--version] or [-v]              -> Prints out version.\n"
		  "[--silent] or [-s]               -> Suppress some common messages printed to the terminal.\n"
		  "[--write-to-stdout] or [-ws]     -> Write 16 bit little endian to stdout.\n"
		  "[--disable-meter] or [-dm]       -> Disable console meter\n"
                  "[--hide-buffer-usage] or [-hbu]  -> Disable buffer usage.\n"
                  "[--disable-console] or [-dc]     -> Disable console updates. Same as \"-dm -hbu\".\n"
		  "[--dB-meter] or [-dB]            -> Use dB scale for the console meter\n"
		  "[--dB-meter-reference or [-dBr]  -> Specify reference level for dB meter. (default=0)\n"
		  "[--meterbridge] or [-mb]         -> Start up meterbridge to monitor recorded sound.\n"
		  "[--meterbridge-type] or [-mt]    -> Specify type. vu (default), ppm, dpm, jf or sco.\n"
		  "[--meterbridge-reference]/[-mr]  -> Specify reference level for meterbidge.\n"
		  "[--filename] or [-fn]            -> Specify filename.\n"
                  "                                    (It's usually easier to set last argument instead)\n"
		  "\n"
		  "Examples:\n"
		  "\n"
		  "To record a stereo file of what you hear:\n"
		  "  $jack_capture\n"
		  "\n"
		  "To record a stereo file of what you hear in the flac format:\n"
		  " $jack_capture -f flac\n"
		  "\n"
		  "To record a stereo file of what you hear in the mp3 format:\n"
		  " $jack_capture -ws|lame -V2 -r -x - output.mp3\n"
		  "\n"
		  "To record a stereo file of what you hear in the ogg format:\n"
		  " $jack_capture -ws|oggenc -o output.ogg -r -\n"
		  "\n"
		  "To record a stereo file of what you hear (same as the default):\n"
		  "  $jack_capture --port system:playback_1 --port system:playback_2\n"
		  "\n"
		  "Same result as above, but using a different syntax:\n"
		  "  $jack_capture --channels 2 --port system:playback*\n"
		  "\n"
		  "To record the output from jamin:\n"
		  "  $jack_capture --port jamin:out* sound_from_jamin.wav\n"
		  "\n"
		  "To record all sound coming in to jamin:\n"
		  "  $jack_capture --port jamin:in* sound_to_jamin.wav\n"
		  "\n"
		  "To record all sound coming in and out of jamin:\n"
		  "  $jack_capture --port jamin* sound_to_and_from_jamin.wav\n"
		  "\n"
		  "To record a stereo file from the soundcard:\n"
		  "  $jack_capture -c 2 -p system:capture*\n"
		  "\n"
		  )
      {
	OPTARG("--bitdepth","-b") bitdepth = OPTARG_GETINT();
	OPTARG("--bufsize","-B") buffer_time = OPTARG_GETFLOAT();
	OPTARG("--channels","-c") channels = OPTARG_GETINT();
	OPTARG("--leading-zeros","-z") leading_zeros = OPTARG_GETINT();
	OPTARG("--recording-time","-d") recording_time = OPTARG_GETFLOAT();
	OPTARG("--port","-p") start_jack() ; portnames_add(OPTARG_GETSTRING());
	OPTARG("--format","-f") soundfile_format=OPTARG_GETSTRING();
	OPTARG("--version","-v") puts(VERSION);exit(0);
	OPTARG("--silent","-s") silent=true;
	OPTARG("--print-formats","-pf") print_all_formats();exit(0);
	OPTARG("--write-to-stdout","-ws") write_to_stdout=true;use_vu=false;show_bufferusage=false;
	OPTARG("--disable-meter","-dm") use_vu=false;
        OPTARG("--hide-buffer-usage","-hbu") show_bufferusage=false;
        OPTARG("--disable-console","-dc") use_vu=false;show_bufferusage=false;
	OPTARG("--linear-meter","-lm") vu_dB=false;
	OPTARG("--dB-meter-reference","-dBr") vu_dB=true;vu_bias=powf(10.0f,OPTARG_GETFLOAT()*-0.05f);//from meterbridge
	OPTARG("--meterbridge","-mb") use_meterbridge=true;
	OPTARG("--meterbridge-type","-mt") use_meterbridge=true;meterbridge_type=OPTARG_GETSTRING();
	OPTARG("--meterbridge-reference","-mr") use_meterbridge=true;meterbridge_reference=OPTARG_GETSTRING();
	OPTARG("--filename","-fn") base_filename=OPTARG_GETSTRING();
	OPTARG_LAST() base_filename=OPTARG_GETSTRING();
      }OPTARGS_END;
  }
  

  // Find filename
  {
    if(base_filename==NULL){
      int try=0;
      base_filename=my_calloc(1,5000);
      for(;;){
	sprintf(base_filename,"jack_capture_%0*d.%s",leading_zeros+1,++try,soundfile_format);
	if(access(base_filename,F_OK)) break;
      }
    }
  }
  
 
  // Init jack 1
  {
    start_jack();
    portnames_add_defaults();
  }


  // Init buffers
  {
    buffers_init(jack_buffer_size);
  }


  // Open soundfile and start disk thread
  {
    if(!open_soundfile()){
      jack_client_close(client);
      return 1;
    }
      
    setup_disk_thread ();
  }

  // Init jack 2
  {
    jack_set_process_callback(client, process, NULL);

    jack_on_shutdown(client, jack_shutdown, NULL);

    jack_set_graph_order_callback(client,graphordercallback,NULL);

    jack_set_buffer_size_callback(client,buffersizecallback,NULL);

    start_connection_thread();

    if (jack_activate(client)) {
      fprintf (stderr,"\nCan not activate client");
    }

    create_ports();
    connect_ports(ports);
  }


  // Everything initialized.
  //   (The threads are waiting for this variable, not the other way around, so now it just needs to be set.)
  {
    is_initialized=1;
    wake_up_connection_thread(); // Usually (?) not necessarry, but just in case.
  }


  // Start meterbridge
  {
    if(use_meterbridge)
      start_meterbridge(channels);
  }


  // Init waiting.
  {
    sem_init(&stop_sem,0,0);
    signal(SIGINT,finish);
    start_waiting_thread();
  }

  // Wait
  { 
    sem_wait(&stop_sem);
    if(silent==false)
      print_error("Please wait while writing all data to disk. (shouldn't take long)\n");
  }

  //stop recording and clean up.
  {
    is_running=0;

    stop_disk_thread();

    stop_connection_thread();

    if(jack_has_been_shut_down==false)
      jack_client_close(client);

    if(meterbridge_started)
      kill(meterbridge_pid,SIGINT);

    stop_helper_thread();
  }

  
  return 0;
}