jDttSP/keyb.c

   1 /* keyb.c */
   2 /*
   3 This file is part of a program that implements a Software-Defined Radio.
   4
   5 Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20
  21 The authors can be reached by email at
  22
  23 ab2kt@arrl.net
  24 or
  25 rwmcgwier@comcast.net
  26
  27 or by paper mail at
  28
  29 The DTTS Microwave Society
  30 6 Kathleen Place
  31 Bridgewater, NJ 08807
  32 */
  33
  34 #include <fromsys.h>
  35 #include <banal.h>
  36 #include <splitfields.h>
  37 #include <datatypes.h>
  38 #include <bufvec.h>
  39 #include <cxops.h>
  40
  41 #define SAMP_RATE (48000)
  42 #define HUGE_PHASE 1256637061.43593
  43
  44 #define RING_SIZE (01 << 020)
  45
  46 pthread_t input, play;
  47 sem_t ready, reader, writer;
  48
  49 jack_client_t *client;
  50 jack_port_t *lport, *rport;
  51 jack_ringbuffer_t *lring, *rring;
  52 jack_nframes_t size;
  53
  54 BOOLEAN playing = FALSE;
  55 double wpm = 18.0, freq = 750.0, gain = -6.0;
  56
  57 COMPLEX *zout = 0;
  58
  59 // basic mapping, chars -> morse strings
  60 char *morse_table[128];
  61
  62 // CW tone segments
  63 #define ME_EOF (-1)
  64 #define ME_ZERO (0)
  65 #define ME_RAMP (1)
  66 #define ME_STDY (2)
  67
  68 struct {
  69   double wpm, rise, fall, curr, incr, rate;
  70   int type, size;
  71 } morsel;
  72
  73 int ditspacesize, dahspacesize,
  74     ditstdysize, dahstdysize,
  75     charspacesize, wordspacesize,
  76     risesize, fallsize;
  77 double riseincr, fallincr;
  78
  79 void jack_ringbuffer_clear(jack_ringbuffer_t *, int);
  80 void jack_ringbuffer_restart(jack_ringbuffer_t *, int);
  81 void send_sound(COMPLEX *, int);
  82
  83 //------------------------------------------------------------
  84
  85 // map char -> morse string
  86 char *
  87 get_morse(int c) { return morse_table[c & 0x7F]; }
  88
  89 void
  90 reader_thread(void) {
  91   BOOLEAN b = TRUE; // we're coming from silence
  92   int c, e;
  93   char *m;
  94
  95   // keep reading 1 char at a time
  96   while ((c = getchar()) != EOF) {
  97
  98     // is char mapped to morse?
  99     if (m = get_morse(c)) {
 100
 101       // yup
 102       // for each sub-element (dit/dah)
 103       while (e = *m++) {
 104         // first segment is slew in...
 105         sem_wait(&reader);
 106         morsel.type = ME_RAMP, morsel.size = risesize;
 107         morsel.curr = 0.0, morsel.incr = riseincr;
 108         sem_post(&writer);
 109
 110         // ...then steady state...
 111         sem_wait(&reader);
 112         morsel.type = ME_STDY;
 113         morsel.size = e == '.' ? ditstdysize : dahstdysize;
 114         sem_post(&writer);
 115
 116         // ...then slew out...
 117         sem_wait(&reader);
 118         morsel.type = ME_RAMP, morsel.size = fallsize;
 119         morsel.curr = 1.0, morsel.incr = fallincr;
 120         sem_post(&writer);
 121
 122         // ...finally, post-element pause
 123         sem_wait(&reader);
 124         morsel.type = ME_ZERO;
 125         morsel.size = ditspacesize;
 126         sem_post(&writer);
 127       }
 128
 129       // post-character pause
 130       sem_wait(&reader);
 131       morsel.type = ME_ZERO;
 132       // (we already emitted a dit-sized space)
 133       morsel.size = charspacesize - ditspacesize;
 134       sem_post(&writer);
 135
 136       // wherever we go next, it won't have been from silence
 137       b = FALSE;
 138
 139     } else {
 140       // anything else treated as interword space
 141       sem_wait(&reader);
 142       morsel.type = ME_ZERO;
 143       // was previous output also interword space?
 144       if (b)
 145         // yes, use full duration
 146         morsel.size = wordspacesize;
 147       else
 148         // no, part of duration already played
 149         morsel.size = wordspacesize - charspacesize;
 150       b = TRUE;
 151       sem_post(&writer);
 152     }
 153   }
 154
 155   // indicate EOF on input
 156   sem_wait(&reader);
 157   morsel.type = ME_EOF;
 158   sem_post(&writer);
 159   pthread_exit(0);
 160 }
 161
 162 void
 163 sound_thread(void) {
 164   int i, k = 0;
 165   double ofreq = freq * 2.0 * M_PI / SAMP_RATE,
 166          phase = 0.0,
 167          scale = pow(10.0, gain / 20.0);
 168   COMPLEX z, delta_z;
 169
 170   // as long as there's been no EOF on the input...
 171   for (;;) {
 172
 173     // pause for next sub-element
 174     sem_post(&reader);
 175     sem_wait(&writer);
 176
 177     // no more data?
 178     if (morsel.type == ME_EOF) break;
 179
 180     // interword space == silence?
 181     if (morsel.type != ME_ZERO) {
 182       // no, set up CORDIC tone generation
 183       if (phase > HUGE_PHASE) phase -= HUGE_PHASE;
 184       z = Cmplx(cos(phase), sin(phase));
 185       delta_z = Cmplx(cos(ofreq), sin(ofreq));
 186     }
 187
 188     // play out this sub-segment
 189     for (i = 0; i < morsel.size; i++) {
 190
 191       // make silence
 192       if (morsel.type == ME_ZERO) zout[k] = cxzero;
 193
 194       // make tone
 195       else {
 196         z = Cmul(z, delta_z);
 197         phase += ofreq;
 198         // slewing segment?
 199         if (morsel.type == ME_RAMP) {
 200           morsel.curr += morsel.incr;
 201           zout[k] = Cscl(z, scale * sin(morsel.curr * M_PI / 2.0));
 202         } else
 203           zout[k] = Cscl(z, scale);
 204       }
 205
 206       // one jack bufferful yet?
 207       if (++k >= size) {
 208         // yes, send to output
 209         send_sound(zout, k);
 210         // wait until it's been taken away
 211         sem_wait(&ready);
 212         k = 0;
 213         // reset CORDIC
 214         if (morsel.type != ME_ZERO) {
 215           if (phase > HUGE_PHASE) phase -= HUGE_PHASE;
 216           z = Cmplx(cos(phase), sin(phase));
 217           delta_z = Cmplx(cos(ofreq), sin(ofreq));
 218         }
 219       }
 220     }
 221   }
 222
 223   // anything left unsent in buffer?
 224   if (k > 0) send_sound(zout, k);
 225
 226   pthread_exit(0);
 227 }
 228
 229 //------------------------------------------------------------------------
 230
 231 void
 232 jack_ringbuffer_clear(jack_ringbuffer_t *ring, int nbytes) {
 233   int i;
 234   char zero = 0;
 235   for (i = 0; i < nbytes; i++)
 236     jack_ringbuffer_write(ring, &zero, 1);
 237 }
 238
 239 void
 240 jack_ringbuffer_restart(jack_ringbuffer_t *ring, int nbytes) {
 241   jack_ringbuffer_reset(ring);
 242   jack_ringbuffer_clear(ring, nbytes);
 243 }
 244
 245 void
 246 send_sound(COMPLEX *buff, int len) {
 247   if (jack_ringbuffer_write_space(lring) < len * sizeof(float)) {
 248     write(2, "overrun\n", 8);
 249     jack_ringbuffer_restart(lring, size * sizeof(float));
 250     jack_ringbuffer_restart(rring, size * sizeof(float));
 251   } else {
 252     int i;
 253     for (i = 0; i < len; i++) {
 254       float l = buff[i].re, r = buff[i].im;
 255       jack_ringbuffer_write(lring, (char *) &l, sizeof(float));
 256       jack_ringbuffer_write(rring, (char *) &r, sizeof(float));
 257     }
 258   }
 259 }
 260
 261 PRIVATE void
 262 jack_xrun(void *arg) {
 263   char *str = "xrun!\n";
 264   write(2, str, strlen(str));
 265 }
 266
 267 PRIVATE void
 268 jack_shutdown(void *arg) {}
 269
 270 PRIVATE void
 271 jack_callback(jack_nframes_t nframes, void *arg) {
 272   char *lp, *rp;
 273   int nwant = nframes * sizeof(float),
 274       nhave = jack_ringbuffer_read_space(lring);
 275
 276   lp = jack_port_get_buffer(lport, nframes);
 277   rp = jack_port_get_buffer(rport, nframes);
 278   if (nhave >= nwant) {
 279     jack_ringbuffer_read(lring, lp, nwant);
 280     jack_ringbuffer_read(rring, rp, nwant);
 281     sem_post(&ready);
 282   } else {
 283     memset(lp, 0, nwant);
 284     memset(rp, 0, nwant);
 285   }
 286 }
 287
 288 int
 289 main(int argc, char **argv) {
 290   int i;
 291
 292   for (i = 1; i < argc; i++)
 293     if (argv[i][0] == '-')
 294       switch (argv[i][1]) {
 295       case 'f':
 296         freq = atof(argv[++i]);
 297         break;
 298       case 'w':
 299         wpm = atof(argv[++i]);
 300         break;
 301       default:
 302         fprintf(stderr, "keyd [-w wpm] [-f freq] [infile]\n");
 303         exit(1);
 304       }
 305     else break;
 306
 307   if (i < argc) {
 308     if (!freopen(argv[i], "r", stdin))
 309       perror(argv[i]), exit(1);
 310     i++;
 311   }
 312
 313   //------------------------------------------------------------
 314
 315   morsel.wpm = wpm;
 316   morsel.rise = morsel.fall = 5.0; // ms
 317   morsel.rate = SAMP_RATE;
 318
 319   ditspacesize = SAMP_RATE * 1.2 / morsel.wpm + 0.5;
 320   dahspacesize = 3 * ditspacesize;
 321   charspacesize = dahspacesize;
 322   wordspacesize = 7 * ditspacesize;
 323
 324   risesize = SAMP_RATE * morsel.rise / 1e3 + 0.5;
 325   if (risesize > 1)
 326     riseincr = 1.0 / (risesize - 1);
 327   else
 328     riseincr = 1.0;
 329
 330   fallsize = SAMP_RATE * morsel.fall / 1e3 + 0.5;
 331   if (fallsize > 1)
 332     fallincr = -1.0 / (fallsize - 1);
 333   else
 334     fallincr = -1.0;
 335
 336   ditstdysize = ditspacesize - risesize - fallsize;
 337   dahstdysize = dahspacesize - risesize - fallsize;
 338
 339   //------------------------------------------------------------
 340
 341   if (!(client = jack_client_new("keyb")))
 342     fprintf(stderr, "can't make client -- jack not running?\n"), exit(1);
 343   jack_set_process_callback(client, (void *) jack_callback, 0);
 344   jack_on_shutdown(client, (void *) jack_shutdown, 0);
 345   jack_set_xrun_callback(client, (void *) jack_xrun, 0);
 346   size = jack_get_buffer_size(client);
 347
 348   lport = jack_port_register(client,
 349                              "ol",
 350                              JACK_DEFAULT_AUDIO_TYPE,
 351                              JackPortIsOutput,
 352                              0);
 353   rport = jack_port_register(client,
 354                              "or",
 355                              JACK_DEFAULT_AUDIO_TYPE,
 356                              JackPortIsOutput,
 357                              0);
 358   lring = jack_ringbuffer_create(RING_SIZE);
 359   rring = jack_ringbuffer_create(RING_SIZE);
 360   jack_ringbuffer_clear(lring, size * sizeof(float));
 361   jack_ringbuffer_clear(rring, size * sizeof(float));
 362
 363   //------------------------------------------------------------
 364
 365   zout = newvec_COMPLEX(size, "keyb sample buffer");
 366
 367   //------------------------------------------------------------
 368
 369   sem_init(&ready, 0, 0);
 370   sem_init(&reader, 0, 0);
 371   sem_init(&writer, 0, 0);
 372   pthread_create(&input, 0, (void *) reader_thread, 0);
 373   pthread_create(&play, 0, (void *) sound_thread, 0);
 374
 375   //------------------------------------------------------------
 376
 377   jack_activate(client);
 378   {
 379     const char **ports;
 380     if (!(ports = jack_get_ports(client, 0, 0, JackPortIsPhysical | JackPortIsInput))) {
 381       fprintf(stderr, "can't find any physical playback ports\n");
 382       exit(1);
 383     }
 384     if (jack_connect(client, jack_port_name(lport), ports[0])) {
 385       fprintf(stderr, "can't connect left output\n");
 386       exit(1);
 387     }
 388     if (jack_connect(client, jack_port_name(rport), ports[1])) {
 389       fprintf(stderr, "can't connect left output\n");
 390       exit(1);
 391     }
 392     free(ports);
 393   }
 394
 395   pthread_join(input, 0);
 396   pthread_join(play, 0);
 397   jack_client_close(client);
 398
 399   //------------------------------------------------------------
 400
 401   delvec_COMPLEX(zout);
 402
 403   //------------------------------------------------------------
 404
 405   jack_ringbuffer_free(lring);
 406   jack_ringbuffer_free(rring);
 407   sem_destroy(&ready);
 408   sem_destroy(&reader);
 409   sem_destroy(&writer);
 410
 411   //------------------------------------------------------------
 412
 413   exit(0);
 414 }
 415
 416 char *morse_table[128] = {
 417   /* 000 NUL */ 0, /* 001 SOH */ 0, /* 002 STX */ 0, /* 003 ETX */ 0,
 418   /* 004 EOT */ 0, /* 005 ENQ */ 0, /* 006 ACK */ 0, /* 007 BEL */ 0,
 419   /* 008  BS */ 0, /* 009  HT */ 0, /* 010  LF */ 0, /* 011  VT */ 0,
 420   /* 012  FF */ 0, /* 013  CR */ 0, /* 014  SO */ 0, /* 015  SI */ 0,
 421   /* 016 DLE */ 0, /* 017 DC1 */ 0, /* 018 DC2 */ 0, /* 019 DC3 */ 0,
 422   /* 020 DC4 */ 0, /* 021 NAK */ 0, /* 022 SYN */ 0, /* 023 ETB */ 0,
 423   /* 024 CAN */ 0, /* 025  EM */ 0, /* 026 SUB */ 0, /* 027 ESC */ 0,
 424   /* 028  FS */ 0, /* 029  GS */ 0, /* 030  RS */ 0, /* 031  US */ 0,
 425   /* 032  SP */ 0,
 426   /* 033   ! */ "...-.",        // [SN]
 427   /* 034   " */ 0, /* 035   # */ 0, /* 036   $ */ 0,
 428   /* 037   % */ ".-...",        // [AS]
 429   /* 038   & */ 0, /* 039   ' */ 0,
 430   /* 040   ( */ "-.--.",        // [KN]
 431   /* 041   ) */ 0,
 432   /* 042   * */ "...-.-",       // [SK]
 433   /* 043   + */ ".-.-.",        // [AR]
 434   /* 044   , */ "--..--",
 435   /* 045   - */ "-....-",
 436   /* 046   . */ ".-.-.-",
 437   /* 047   / */ "-..-.",
 438   /* 048   0 */ "-----",
 439   /* 049   1 */ ".----",
 440   /* 050   2 */ "..---",
 441   /* 051   3 */ "...--",
 442   /* 052   4 */ "....-",
 443   /* 053   5 */ ".....",
 444   /* 054   6 */ "-....",
 445   /* 055   7 */ "--...",
 446   /* 056   8 */ "---..",
 447   /* 057   9 */ "----.",
 448   /* 058   : */ 0, /* 059   ; */ 0, /* 060   < */ 0,
 449   /* 061   = */ "-...-",        // [BT]
 450   /* 062   > */ 0,
 451   /* 063   ? */ "..__..",       // [IMI]
 452   /* 064   @ */ ".--.-.",
 453   /* 065   A */ ".-",
 454   /* 066   B */ "-...",
 455   /* 067   C */ "-.-.",
 456   /* 068   D */ "-..",
 457   /* 069   E */ ".",
 458   /* 070   F */ "..-.",
 459   /* 071   G */ "--.",
 460   /* 072   H */ "....",
 461   /* 073   I */ "..",
 462   /* 074   J */ ".---",
 463   /* 075   K */ "-.-",
 464   /* 076   L */ ".-..",
 465   /* 077   M */ "--",
 466   /* 078   N */ "-.",
 467   /* 079   O */ "---",
 468   /* 080   P */ ".--.",
 469   /* 081   Q */ "--.-",
 470   /* 082   R */ ".-.",
 471   /* 083   S */ "...",
 472   /* 084   T */ "-",
 473   /* 085   U */ "..-",
 474   /* 086   V */ "...-",
 475   /* 087   W */ ".--",
 476   /* 088   X */ "-..-",
 477   /* 089   Y */ "-.--",
 478   /* 090   Z */ "--..",
 479   /* 091   [ */ 0, /* 092   \ */ 0, /* 093   ] */ 0, /* 094   ^ */ 0,
 480   /* 095   _ */ 0, /* 096   ` */ 0,
 481   /* 097   a */ ".-",
 482   /* 098   b */ "-...",
 483   /* 099   c */ "-.-.",
 484   /* 100   d */ "-..",
 485   /* 101   e */ ".",
 486   /* 102   f */ "..-.",
 487   /* 103   g */ "--.",
 488   /* 104   h */ "....",
 489   /* 105   i */ "..",
 490   /* 106   j */ ".---",
 491   /* 107   k */ "-.-",
 492   /* 108   l */ ".-..",
 493   /* 109   m */ "--",
 494   /* 110   n */ "-.",
 495   /* 111   o */ "---",
 496   /* 112   p */ ".--.",
 497   /* 113   q */ "--.-",
 498   /* 114   r */ ".-.",
 499   /* 115   s */ "...",
 500   /* 116   t */ "-",
 501   /* 117   u */ "..-",
 502   /* 118   v */ "...-",
 503   /* 119   w */ ".--",
 504   /* 120   x */ "-..-",
 505   /* 121   y */ "-.--",
 506   /* 122   z */ "--..",
 507   /* 123   { */ 0, /* 124   | */ 0, /* 125   } */ 0, /* 126   ~ */ 0,
 508   /* 127 DEL */ 0
 509 };