#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
#include <semaphore.h>
#include <pthread.h>

#include "globdef.h"
#include "uidef.h"
#include "fft1def.h"
#include "conf.h"
#include "lconf.h"
#include "txdef.h"
#include "vernr.h"
#include "screendef.h"
#include "sigdef.h"
#include "thrdef.h"
#include "sdrdef.h"
#include "ldef.h"

// allocate 16 megabytes for phonetics (float format).
#define PHONETICS_SIZE (1024*4096)
#define VOICELAB_AMPLITUDE (0.2*0x7fff)
#define LEVEL_METER_X 65

extern void make_devname(int device_no);
extern char dev_name[];
extern char *devmode_txt[3];

#if SND_DEV == 1
#define DEVNAME_SIZE 12
#else 
#define DEVNAME_SIZE 18
#endif

int lir_tx_output_samples(void)
{
if(ioctl(tx_audio_out,SNDCTL_DSP_GETOSPACE, &tx_da_info) == -1)lirerr(872313);
//err_restart_da(1109);
return tx_output_totsamp-tx_da_info.bytes/tx_output_fragsize;
}

int lir_tx_input_samples(void)
{
return 0;
if(ioctl(tx_audio_in,SNDCTL_DSP_GETISPACE, &tx_ad_info) == -1)lirerr(872314);
//err_restart_da(1109);
return tx_ad_info.bytes/tx_input_fragsize;
}

void open_tx_input(void)
{
int i, j, frag;
float t1;
make_devname(ui.tx_addev_no);
tx_audio_in=open( dev_name, O_RDONLY, 0);
if(tx_audio_in == -1)
  {
  lirerr(1260);
  return;
  }
// We want the fragment size to match tx_read_bytes.
frag=0;
i=tx_read_bytes;
while(i>1)
  {
  i>>=1;
  frag++;
  }
if(frag < 5)frag=5;
frag=frag|0x7fff0000;
if(ioctl(tx_audio_in, SNDCTL_DSP_SETFRAGMENT, &frag) == -1)
  {
  lirerr(1262);
  return;
  }
i=AFMT_S16_LE;
#ifdef AFMT_S32_LE
if(ui.tx_ad_bytes==4)i=AFMT_S32_LE;
#else
ui.tx_ad_bytes=2;
#endif
j=i;
if(ioctl(tx_audio_in, SNDCTL_DSP_SETFMT, &i) == -1)
  {
  lirerr(231013);
  return;
  }
if(i!=j)
  {
  lirerr(231014);
  return;
  }
// Set number of channels
j=ui.tx_ad_channels;
i=j;
if(ioctl(tx_audio_in, SNDCTL_DSP_CHANNELS, &i) == -1)
  {
  lirerr(231009);  
  return;
  }
if(i != j)
  {
  lirerr(231010);
  return;
  }
i=ui.tx_ad_speed;
if(ioctl(tx_audio_in, SNDCTL_DSP_SPEED, &i)==-1)
  {
  lirerr(231011);
  return;
  }
t1=(float)(i)/ui.tx_ad_speed;
if(t1 > 1.05 || t1 < 0.95)
  {
  lirerr(231012);
  return;
  }
ui.tx_ad_speed=i;
// This has to be the last ioctl call before read or write!!
ioctl(tx_audio_in, SNDCTL_DSP_GETBLKSIZE,&i);
}

void close_tx_input(void)
{
if(close(tx_audio_in)==-1)lirerr(231037);  
tx_audio_in=-1;
}

void open_tx_output(void)
{
int i,j,frag;
float t1;
make_devname(ui.tx_dadev_no);
tx_audio_out=open( dev_name, O_WRONLY|O_NONBLOCK, 0);
if(tx_audio_out == -1)
  {
  lirerr(991260);
  return;
  }
frag=0;
i=tx_write_bytes;
while(i>1)
  {
  i>>=1;
  frag++;
  }
if(frag < 5)frag=5;
frag=frag|0x7fff0000;
if(ioctl(tx_audio_out, SNDCTL_DSP_SETFRAGMENT, &frag) == -1)
  {
  lirerr(991262);
  return;
  }
i=AFMT_S16_LE;
#ifdef AFMT_S32_LE
if(ui.tx_da_bytes==4)i=AFMT_S32_LE;
#else
ui.tx_da_bytes=2;
#endif
j=i;
if(ioctl(tx_audio_out, SNDCTL_DSP_SETFMT, &i) == -1)
  {
  lirerr(231013);
  return;
  }
if(i!=j)
  {
  lirerr(231014);
  return;
  }
// Set number of channels
j=ui.tx_da_channels;
i=j;
if(ioctl(tx_audio_out, SNDCTL_DSP_CHANNELS, &i) == -1)
  {
  lirerr(231009);  
  return;
  }
if(i != j)
  {
  lirerr(231010);
  return;
  }
i=ui.tx_da_speed;
if(ioctl(tx_audio_out, SNDCTL_DSP_SPEED, &i)==-1)
  {
  lirerr(231011);
  return;
  }
t1=(float)(i)/ui.tx_da_speed;
if(t1 > 1.05 || t1 < 0.95)
  {
  lirerr(231012);
  return;
  }
ui.tx_da_speed=i;
// This has to be the last ioctl call before read or write!!
ioctl(tx_audio_in, SNDCTL_DSP_GETBLKSIZE,&i);
}

void close_tx_output(void)
{
if(ioctl(tx_audio_out,SNDCTL_DSP_RESET,0)==-1)
  {
  lirerr(1288);
  }
if(close(tx_audio_out)==-1)lirerr(1287);  
tx_audio_out=-1;
}

int tx_setup(void)
{
int dev_flag[MAX_DEVNAMES];
int dev_max_speed[MAX_DEVNAMES];
int dev_min_speed[MAX_DEVNAMES];
int i, k, nn, m;
int rdwr_channels;  
int rdwr_speed;
int rdwr_fmt;
int line, maxline, column, maxcolumn;
int device_no;
audio_buf_info ad_info;
char *testbuff;
char s[256];
testbuff = malloc(4096);
if(testbuff == NULL)
  {
  lirerr(1285);
  goto tx_errexit;
  }
rx_daout_channels=ui.rx_min_da_channels;
genparm[DA_OUTPUT_SPEED]=ui.rx_min_da_speed;
genparm[SECOND_FFT_ENABLE]=0;
fft1_size=32768;
rx_daout_block=256;
tx_daout_block=256;
timf1_sampling_speed=11025;
if(check_tx_devices() == FALSE)goto do_tx_setup;
if(read_txpar_file() == FALSE)set_default_spproc_parms();
// *******************************************************
// ***   The A/D and A/D setup is already done.
// ***   Ask the user what he wants.
// ***   The transmit functions of Linrad are in a very early stage
// ***   and there is not much to choose from yet............
// ******************************************************
clear_screen();
if(ui.tx_dadev_no == -1)goto do_tx_setup;
lir_text(5,6,"B=Soundcard setup for Tx.");
lir_text(5,7,"C=Speech processor setup.");
lir_text(5,8,"D=CW setup.");
lir_text(5,9,"X=Return to main menu");
kbd_sel:;
await_processed_keyboard();
if(kill_all_flag) goto txend;
switch (lir_inkey)
  {
  case 'B':
  goto do_tx_setup;

  case 'C':
  spproc_setup();
  goto txend;

  case 'D':
  cwproc_setup();
  goto txend;

  case 'X':
  goto txend;
  
  default:
  goto kbd_sel;
  }
do_tx_setup:;   
clear_screen();
settextcolor(15);
lir_text(25,2,"A/D and D/A set-up for TX");
rx_daout_bytes=ui.rx_max_da_bytes;
rx_daout_channels=ui.rx_max_da_channels;
if(ui.rx_addev_no < SPECIFIC_DEVICE_CODES)open_rx_sndin();
if(kill_all_flag) goto txend;
open_rx_sndout();
if(kill_all_flag) goto txend;
if(ui.rx_addev_no < SPECIFIC_DEVICE_CODES)
  {
  read(rx_audio_in, testbuff, 1024);
  if(ui.rx_addev_no > 255) read(rx_audio_in2, testbuff, 1024);
  }
for(i=0;i<1024;i++)testbuff[i]=0;
write(rx_audio_out, testbuff, 1024);
// First step through all devices and check which ones
// we can open in write mode while the rx devices are open.
maxline=screen_last_line-1;
maxcolumn=screen_last_col;
settextcolor(14);
lir_text(10,4,"Checking device drivers for tx output");
settextcolor(7);
testbuff = malloc(2048);
if(testbuff == NULL)
  {
  lirerr(1044);
  goto tx_errexit;
  }
nn=0;
line=5;
for(device_no=0; device_no<MAX_DEVNAMES; device_no++)
  {
  if(ui.rx_addev_no < SPECIFIC_DEVICE_CODES)
    {
    if(ioctl(rx_audio_in, SNDCTL_DSP_GETISPACE, &ad_info) == -1)
      {
      lirerr(211028);
      goto tx_errexit;
      }
    while(ad_info.bytes > 1024)
      {
      read(rx_audio_in, testbuff, 1024);
      if(ioctl(rx_audio_in, SNDCTL_DSP_GETISPACE, &ad_info) == -1)
        {
        lirerr(221028);
        goto tx_errexit;
        }
      }
    if(ui.rx_addev_no > 255)
      {
      if(ioctl(rx_audio_in2, SNDCTL_DSP_GETISPACE, &ad_info) == -1)
        {
        lirerr(231028);
        goto tx_errexit;
        }
      while(ad_info.bytes > 1024)  
        {
        read(rx_audio_in2, testbuff, 1024);
        if(ioctl(rx_audio_in2, SNDCTL_DSP_GETISPACE, &ad_info) == -1)
          {
          lirerr(241028);
          goto tx_errexit;
          }
        }
      }
    }
  for(i=0;i<1024;i++)testbuff[i]=0;
  if(ioctl(rx_audio_out,SNDCTL_DSP_GETOSPACE, &ad_info) == -1)
    {
    lirerr(251028);
    goto tx_errexit;
    }
  while(ad_info.bytes > 1024)
    {
    write(rx_audio_out, testbuff, 1024);
    if(ioctl(rx_audio_out,SNDCTL_DSP_GETOSPACE, &ad_info) == -1)
      {
      lirerr(261028);
      goto tx_errexit;
      }
    }
  rdwr_channels=0;
  rdwr_fmt=0;
  if(device_no != rx_audio_out)
    {
    make_devname(device_no);
      {
      sprintf(s,"Trying to open %s %s. Device defective if system hangs here.",
                                           dev_name, devmode_txt[1]);
      settextcolor(12);
      lir_text(0,line+1,s);
      settextcolor(7);
      tx_audio_out=open( dev_name, O_WRONLY|O_NONBLOCK, 0);
      if(tx_audio_out != -1)
        {
#ifdef SNDCTL_DSP_COOKEDMODE
        i=0;
        ioctl(tx_audio_out, SNDCTL_DSP_COOKEDMODE, &i);
#endif
        line++;
        if(line >= maxline)
          {
          for(column=0; column<maxcolumn; column++)s[column]=' ';
          s[maxcolumn]=0;
          lir_text(0,line,s);
          settextcolor(14);
          lir_text(10,line,"(press ENTER to continue)");
          settextcolor(7);
          await_keyboard();
          if(kill_all_flag) goto txend;
          lir_text(0,line,s);
          line=1;
          }
// Check for 16 bits
        if(ioctl(tx_audio_out, SNDCTL_DSP_GETFMTS, &m) == -1)
          {
baddev:;
          clear_lines(line,line);
          line--;
          rdwr_channels=0;
          goto cls;
          }
        rdwr_fmt=0;  
        if( (m&AFMT_S16_LE) != 0)
          {
          rdwr_fmt=16;
          }
#ifdef AFMT_S32_LE
// Check for 32 bits
        if( (m&AFMT_S32_LE) != 0)
          {
          rdwr_fmt+=32;
          }
#endif   
        if(rdwr_fmt == 0)goto cls;
// Find max no of channels.
// We never want more than 2 tx output channels!!
        k=4;
        rdwr_channels=0;
find_channels:;
        k/=2;
        m=k;
        if(ioctl(tx_audio_out, SNDCTL_DSP_CHANNELS, &m) != -1 && k == m)
          {
          rdwr_channels|=k;
          k/=2;
          }
        k/=2;
        if(k != 0)goto find_channels;
        if(rdwr_channels==0)goto baddev;
// Find maximum output speed
        rdwr_speed=ABOVE_MAX_SPEED;
        if(ioctl(tx_audio_out, SNDCTL_DSP_SPEED, &rdwr_speed)==-1)
          {
          goto baddev;
          }
        dev_max_speed[device_no]=rdwr_speed;
// Find minimum output speed
        rdwr_speed=5000;
        if(ioctl(tx_audio_out, SNDCTL_DSP_SPEED, &rdwr_speed)==-1)
          {
          goto baddev;
          }
        dev_min_speed[device_no]=rdwr_speed;
        settextcolor(7);  
        sprintf(s,"  %02d  %s     ",device_no,dev_name);
        lir_text(0,line,s);
        sprintf(s,"%s   ",devmode_txt[1]);
        if(rdwr_channels==3)
          {
          strcat(s,"1,2");
          }
        else
          {
          sprintf(testbuff,"%d",rdwr_channels);
          strcat(s,testbuff);
          }
        strcat(s," channels      "); 
        if(rdwr_fmt == 48)
          {
          strcat(s,"16,32");
          }
        else
          {
          sprintf(testbuff,"%d",rdwr_fmt);
          strcat(s,testbuff);
          }
        strcat(s," bits      "); 
        if(rdwr_speed != dev_max_speed[device_no])
          {
          sprintf(testbuff,"%d to %d",rdwr_speed,dev_max_speed[device_no]);
          strcat(s,testbuff);
          }
        else
          {
          sprintf(testbuff,"%d",rdwr_speed);
          strcat(s,testbuff);
          }
        strcat(s," Hz         ");    
        lir_text(DEVNAME_SIZE+5,line,s);
        nn++;
cls:;
        if(close(tx_audio_out)==-1)
          {
          lirerr(271037);  
          goto tx_errexit;
          }
        }
      }          
    }      
  dev_flag[device_no]=rdwr_fmt+rdwr_channels;
  }
close_rx_sndout();
close_rx_sndin();
for(i=0; i<80; i++)s[i]=' ';
s[80]=0;
line++;
lir_text(0,line,s);
line++;
if(nn == 0)
  {
  lir_text(0,line,"No device found for Tx output");
  lir_text(2,line+1,"ERROR (press any key)");
  await_keyboard();
  goto txend;
  }
settextcolor(14);
lir_text(0,line,"Select device for Tx output");
get_dadev:;
settextcolor(7);
ui.tx_dadev_no=lir_get_integer(29, line, 3, 0,MAX_DEVNAMES-1);
if(kill_all_flag) goto txend;
if( (3 & dev_flag[ui.tx_dadev_no]) == 0)
  {
  settextcolor(15);
  lir_text(29,line,"???");
  lir_text(25,line+1,"ERROR (press any key)");
  await_keyboard();
  if(kill_all_flag) goto txend;
  clear_lines(line+1,line+1);
  goto get_dadev;
  }
clear_screen();
// Select no of channels if the device can do both one and two channels.
if( (3 & dev_flag[ui.tx_dadev_no]) == 3)
  {
  lir_text(5,10,"Select tx format");
  lir_text(3,12,"1=Single channel (normal audio)");
  lir_text(3,13,"2=Two channels (I and Q, frequency shifted)");
get_dachan:;
  await_keyboard();
  if(kill_all_flag) goto txend;
  if(lir_inkey=='1')
    {
    ui.tx_da_channels=1;
    }
  else
    {  
    if(lir_inkey=='2')
      {
      ui.tx_da_channels=2;
      }
    else
      {
      goto get_dachan;
      }
    }    
  }
else
  {
  ui.tx_da_channels=3&dev_flag[ui.tx_dadev_no];
  }
clear_screen();
if( (48 & dev_flag[ui.tx_dadev_no]) == 48)
  {
  lir_text(5,10,"Select tx no of bits");
  lir_text(3,12,"1=16 bits");
  lir_text(3,13,"2=32 bits");
get_dabits:;
  await_keyboard();
  if(kill_all_flag) goto txend;
  if(lir_inkey=='1')
    {
    ui.tx_da_bytes=2;
    }
  else
    {  
    if(lir_inkey=='2')
      {
      ui.tx_da_bytes=4;
      }
    else
      {
      goto get_dabits;
      }
    }    
  }
else
  {
  ui.tx_da_bytes=(16+32)&dev_flag[ui.tx_dadev_no];
  ui.tx_da_bytes>>=3;
  }
if(dev_min_speed[ui.tx_dadev_no] != dev_max_speed[ui.tx_dadev_no])
  {
  clear_screen();
  sprintf(s,"Select Tx D/A speed %d to %d",dev_min_speed[ui.tx_dadev_no],
                                          dev_max_speed[ui.tx_dadev_no]);
  lir_text(5,11,s);
  i=0;
  while(s[i] != 0)i++;
  ui.tx_da_speed=lir_get_integer(i+7, 11, 6, dev_min_speed[ui.tx_dadev_no],
                                          dev_max_speed[ui.tx_dadev_no]);
  }
else
  {  
  ui.tx_da_speed=dev_min_speed[ui.tx_dadev_no];
  }
clear_screen();
make_devname(ui.tx_dadev_no);
sprintf(s,"Tx output: %s, %d channel(s), %d bits, %d Hz",dev_name,
                  ui.tx_da_channels,ui.tx_da_bytes<<3,ui.tx_da_speed);
settextcolor(14);
lir_text(15,0,s);
// Look for a device for microphone input.
if(ui.rx_addev_no < SPECIFIC_DEVICE_CODES)open_rx_sndin();
if(kill_all_flag) goto txend;
open_rx_sndout();
if(kill_all_flag) goto txend;
open_tx_output();
if(kill_all_flag) goto txend;
if(ui.rx_addev_no < SPECIFIC_DEVICE_CODES)
  {
  read(rx_audio_in, testbuff, 1024);
  if(ui.rx_addev_no > 255) read(rx_audio_in2, testbuff, 1024);
  }
for(i=0;i<1024;i++)testbuff[i]=0;
write(rx_audio_out, testbuff, 1024);
write(tx_audio_out, testbuff, 1024);
// First step through all devices and check which ones
// we can open in read mode while the rx devices and tx output are open.
settextcolor(14);
lir_text(10,4,"Checking device drivers for microphone input");
settextcolor(7);
nn=0;
line=5;
for(device_no=0; device_no<MAX_DEVNAMES; device_no++)
  {
  if(ui.rx_addev_no < SPECIFIC_DEVICE_CODES)
    {
    if(ioctl(rx_audio_in, SNDCTL_DSP_GETISPACE, &ad_info) == -1)
      {
      lirerr(281028);
      goto tx_errexit;
      }
    while(ad_info.bytes > 1024)
      {
      read(rx_audio_in, testbuff, 1024);
      if(ioctl(rx_audio_in, SNDCTL_DSP_GETISPACE, &ad_info) == -1)
        {
        lirerr(291028);
        goto tx_errexit;
        }
      }
    if(ui.rx_addev_no > 255)
      {
      if(ioctl(rx_audio_in2, SNDCTL_DSP_GETISPACE, &ad_info) == -1)
        {
        lirerr(311028);
        goto tx_errexit;
        }
      while(ad_info.bytes > 1024)  
        {
        read(rx_audio_in2, testbuff, 1024);
        if(ioctl(rx_audio_in2, SNDCTL_DSP_GETISPACE, &ad_info) == -1)
          {
          lirerr(321028);
          goto tx_errexit;
          }
        }
      }
    }
  for(i=0;i<1024;i++)testbuff[i]=0;
  if(ioctl(rx_audio_out,SNDCTL_DSP_GETOSPACE, &ad_info) == -1)
    {
    lirerr(331028);
    goto tx_errexit;
    }
  while(ad_info.bytes > 1024)
    {
    write(rx_audio_out, testbuff, 1024);
    if(ioctl(rx_audio_out,SNDCTL_DSP_GETOSPACE, &ad_info) == -1)
      {
      lirerr(341028);
      goto tx_errexit;
      }
    }
  if(ioctl(tx_audio_out,SNDCTL_DSP_GETOSPACE, &ad_info) == -1)
    {
    lirerr(351028);
    goto tx_errexit;
    }
  while(ad_info.bytes > 1024)
    {
    write(tx_audio_out, testbuff, 1024);
    if(ioctl(rx_audio_out,SNDCTL_DSP_GETOSPACE, &ad_info) == -1)
      {
      lirerr(361028);
      goto tx_errexit;
      }
    }
  rdwr_channels=0;
  rdwr_fmt=0;
  if(device_no != rx_audio_in)
    {
    make_devname(device_no);
      {
      sprintf(s,"Trying to open %s %s. Device defective if system hangs here.",
                                           dev_name, devmode_txt[0]);
      settextcolor(12);
      lir_text(0,line+1,s);
      settextcolor(7);
      tx_audio_in=open( dev_name, O_RDONLY|O_NONBLOCK, 0);
      if(tx_audio_in != -1)
        {
#ifdef SNDCTL_DSP_COOKEDMODE
        i=0;
        ioctl(tx_audio_in, SNDCTL_DSP_COOKEDMODE, &i);
#endif
        line++;
        if(line >= maxline)
          {
          for(column=0; column<maxcolumn; column++)s[column]=' ';
          s[maxcolumn]=0;
          lir_text(0,line,s);
          settextcolor(14);
          lir_text(10,line,"(press ENTER to continue)");
          settextcolor(7);
          await_keyboard();
          if(kill_all_flag) goto txend;
          lir_text(0,line,s);
          line=1;
          }
// Check for 16 bits
        if(ioctl(tx_audio_in, SNDCTL_DSP_GETFMTS, &m) == -1)
          {
mic_baddev:;
          line--;
          rdwr_channels=0;
          goto mic_cls;
          }
        rdwr_fmt=0;  
        if( (m&AFMT_S16_LE) != 0)
          {
          rdwr_fmt=16;
          }
#ifdef AFMT_S32_LE
// Check for 32 bits
        if( (m&AFMT_S32_LE) != 0)
          {
          rdwr_fmt+=32;
          }
#endif   
        if(rdwr_fmt == 0)goto mic_cls;
// Find max no of channels.
// We never want more than 2 tx output channels!!
        k=4;
        rdwr_channels=0;
mic_find_channels:;
        k/=2;
        m=k;
        if(ioctl(tx_audio_in, SNDCTL_DSP_CHANNELS, &m) != -1 && k == m)
          {
          rdwr_channels|=k;
          }
        if(k != 0)goto mic_find_channels;
        if(rdwr_channels == 0) goto mic_baddev;
// Find maximum output speed
        rdwr_speed=ABOVE_MAX_SPEED;
        if(ioctl(tx_audio_in, SNDCTL_DSP_SPEED, &rdwr_speed)==-1)
          {
          goto mic_baddev;
          }
        dev_max_speed[device_no]=rdwr_speed;
// Find minimum output speed
        rdwr_speed=5000;
        if(ioctl(tx_audio_in, SNDCTL_DSP_SPEED, &rdwr_speed)==-1)
          {
          goto mic_baddev;
          }
        dev_min_speed[device_no]=rdwr_speed;
        settextcolor(7);  
        sprintf(s,"  %02d  %s     ",device_no,dev_name);
        lir_text(0,line,s);
        sprintf(s,"%s   ",devmode_txt[0]);
        if(rdwr_channels==3)
          {
          strcat(s,"1,2");
          }
        else
          {
          sprintf(testbuff,"%d",rdwr_channels);
          strcat(s,testbuff);
          }
        strcat(s," channels      "); 
        if(rdwr_fmt == 48)
          {
          strcat(s,"16,32");
          }
        else
          {
          sprintf(testbuff,"%d",rdwr_fmt);
          strcat(s,testbuff);
          }
        strcat(s," bits      "); 
        if(rdwr_speed != dev_max_speed[device_no])
          {
          sprintf(testbuff,"%d to %d",rdwr_speed,dev_max_speed[device_no]);
          strcat(s,testbuff);
          }
        else
          {
          sprintf(testbuff,"%d",rdwr_speed);
          strcat(s,testbuff);
          }
        strcat(s," Hz         ");    
        lir_text(DEVNAME_SIZE+5,line,s);
        nn++;

      if(read(tx_audio_in, testbuff, 1024)== -1)goto mic_baddev;
      if(ioctl(tx_audio_in, SNDCTL_DSP_GETISPACE, &ad_info) == -1)
                                                             goto mic_baddev;
mic_cls:;
        if(close(tx_audio_in)==-1)
          {
          lirerr(371037);  
          goto tx_errexit;
          }
        }
      }          
    }      
  dev_flag[device_no]=rdwr_fmt+rdwr_channels;
  }
close_rx_sndout();
close_rx_sndin();
close_tx_output();
for(i=0; i<80; i++)s[i]=' ';
s[80]=0;
line++;
lir_text(0,line,s);
line++;
if(nn == 0)
  {
  lir_text(0,line,"No device found for microphone input.");
  lir_text(2,line+1,"ERROR (press any key)");
  await_keyboard();
  goto txend;
  }
settextcolor(14);
lir_text(0,line,"Select device for microphone input");
get_micdev:;
settextcolor(7);
ui.tx_addev_no=lir_get_integer(37, line, 3, 0,MAX_DEVNAMES-1);
if( (3 & dev_flag[ui.tx_addev_no]) == 0)
  {
  settextcolor(15);
  lir_text(29,line,"???");
  lir_text(25,line+1,"ERROR (press any key)");
  await_keyboard();
  if(kill_all_flag) goto txend;
  clear_lines(line+1,line+1);
  goto get_micdev;
  }
// Use one channel if the device can do both one and two channels.
if( (3 & dev_flag[ui.tx_addev_no]) == 3)
  {
  ui.tx_ad_channels=1;
  }
else
  {
  ui.tx_ad_channels=dev_flag[ui.tx_addev_no];
  }
clear_screen();
if( (48 & dev_flag[ui.tx_addev_no]) == 48)
  {
  lir_text(5,10,"Select microphone no of bits");
  lir_text(3,12,"1=16 bits");
  lir_text(3,13,"2=32 bits");
get_micbits:;
  await_keyboard();
  if(kill_all_flag) goto txend;
  if(lir_inkey=='1')
    {
    ui.tx_ad_bytes=2;
    }
  else
    {  
    if(lir_inkey=='2')
      {
      ui.tx_ad_bytes=4;
      }
    else
      {
      goto get_micbits;
      }
    }    
  }
else
  {
  ui.tx_ad_bytes=(16+32)&dev_flag[ui.tx_addev_no];
  ui.tx_ad_bytes>>=3;
  }
if(dev_min_speed[ui.tx_addev_no] != dev_max_speed[ui.tx_addev_no])
  {
  clear_screen();
  lir_text(2,9,"Note that sampling speed must be at least 8 times higher");
  lir_text(2,10,"than the highest voice frequency.");
  sprintf(s,"Select microphone A/D speed %d to %d",
               dev_min_speed[ui.tx_addev_no], dev_max_speed[ui.tx_addev_no]);
  lir_text(5,11,s);
  i=0;
  while(s[i] != 0)i++;
  ui.tx_ad_speed=lir_get_integer(i+7, 11, 6, dev_min_speed[ui.tx_addev_no],
                                          dev_max_speed[ui.tx_addev_no]);
  }
else
  {  
  ui.tx_ad_speed=dev_min_speed[ui.tx_addev_no];
  }
make_devname(ui.tx_addev_no);
clr_get_enable:;
clear_screen();
line=4;
get_enable:;
lir_text(4,line,"Enable Tx while running receive modes ? (Y/N)");
toupper_await_keyboard();
if(lir_inkey == 'Y')
  {
  ui.tx_enable=1;
  }
else
  {
  if(lir_inkey != 'N')
    {
    line++;
    if(line > screen_last_line)goto clr_get_enable;
    goto get_enable;  
    }
  ui.tx_enable=0;
  }  
clear_screen();
sprintf(s,"Microphone input: %s, %d channel(s), %d bits, %d Hz",dev_name,
                      ui.tx_ad_channels,ui.tx_ad_bytes<<3,ui.tx_ad_speed);
settextcolor(14);
lir_text(15,0,s);
settextcolor(15);
lir_text(5,5,remind_parsave);
settextcolor(7);
lir_text(5,7,press_any_key);
if(ui.tx_enable == 1)
  {
  lir_text(0,2,"Parameters for speech processor, keying, etc. have to");
  lir_text(0,3,"be set up and saved before Tx becomes enabled in Rx modes.");
  }
await_keyboard();
free(testbuff);
lir_inkey=0;
return TRUE;
txend:;
free(testbuff);
tx_errexit:;
lir_inkey=0;
return FALSE;
}