]> git.rkrishnan.org Git - dttsp.git/blob - jDttSP/keyb.c
Bug fixes to jsdr, keyer
[dttsp.git] / 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 };