source: buchla-68k/ram/etiosc.c@ 06f6615

Last change on this file since 06f6615 was b28a12e, checked in by Thomas Lopatic <thomas@…>, 7 years ago

Zero redundant declarations.
  • Property mode set to 100644
File size: 13.3 KB
Line 
1/*
2 =============================================================================
3 etiosc.c -- MIDAS instrument editor -- oscillator field handlers
4 Version 31 -- 1988-10-27 -- D.N. Lynx Crowe
5 =============================================================================
6*/
7
8#include "ram.h"
9
10/* initialized variables */
11
12/* C C# D D# E F F# G G# A A# B */
13int16_t notes[] = {2, 2, 3, 3, 4, 5, 5, 6, 6, 0, 0, 1};
14
15/* A B C D E F G */
16int16_t pitches[] = { 900, 1100, 0, 200, 400, 500, 700};
17
18#include "ratio.h" /* short ratio[]; */
19
20/* C C# D D# E F F# G G# A A# B */
21int16_t sharps[] = {7, 9, 7, 9, 7, 7, 9, 7, 9, 7, 9, 7};
22
23int16_t shrpflt[] = { 0, -100, 100};
24
25int8_t sfdsp[] = {' ', D_FLAT, D_SHARP};
26
27static int8_t intstr[] = "+0000";
28static int8_t ratstr[] = "1/1";
29static int8_t frqstr[] = "00.0";
30static int8_t pchstr[] = "0C 00";
31
32int16_t ndvals[10] = {0, 0, 1200, 1902, 2400, 2786, 3102, 3369, 3600, 3804};
33
34
35/*
36
37*/
38
39/*
40 =============================================================================
41 int2rat() -- convert interval to ratio
42 =============================================================================
43*/
44
45void int2rat(int16_t rat)
46{
47 register int16_t den, inum, num;
48
49 ebuf[0] = '1';
50 ebuf[1] = '/';
51 ebuf[2] = '1';
52 ebuf[3] = '\0';
53
54 for (num = 1; num < 10; num++) {
55
56 inum = 10 * num;
57
58 for (den = 1; den < 10; den++) {
59
60 if (rat EQ ratio[inum + den]) {
61
62 ebuf[0] = num + '0';
63 ebuf[2] = den + '0';
64 return;
65 }
66 }
67 }
68}
69
70/*
71
72*/
73
74/*
75 =============================================================================
76 cnvc2p() -- convert cents to pitch
77 =============================================================================
78*/
79
80void cnvc2p(int8_t *buf, int16_t cv)
81{
82 int16_t rem, tmp;
83
84 cv -= 160;
85 buf[0] = cv / 1200;
86 rem = cv - (buf[0] * 1200);
87 tmp = rem / 100;
88 rem -= (tmp * 100);
89 buf[1] = notes[tmp];
90 buf[2] = sharps[tmp];
91 buf[3] = rem / 10;
92 buf[4] = rem - (buf[3] * 10);
93}
94
95/*
96
97*/
98
99/*
100 =============================================================================
101 cnvp2c() -- convert pitch to cents
102
103 input in edit buffer:
104
105 ebuf[0] = octave 0..9
106 ebuf[1] = note A..G (0..6)
107 ebuf[2] = type natural, flat, sharp (7..9)
108 ebuf[3] = ms byte of offset 0..9
109 ebuf[4] = ls byte of offset 0..9
110
111 output in cents
112 =============================================================================
113*/
114
115int16_t cnvp2c(void)
116{
117 if (ebuf[0] EQ 9) /* high limit is C9 00 */
118 if (ebuf[1] GT 2)
119 return(FAILURE);
120 else if (ebuf[1] EQ 2)
121 if (ebuf[2] NE 7)
122 return(FAILURE);
123 else if (ebuf[3] OR ebuf[4])
124 return(FAILURE);
125
126 cents = (ebuf[0] * 1200) + pitches[ebuf[1]] + shrpflt[ebuf[2] - 7]
127 + (ebuf[3] * 10) + ebuf[4] + 160;
128
129 return(SUCCESS);
130}
131
132/*
133
134*/
135
136/*
137 =============================================================================
138 et_iosc() -- load the edit buffer
139 =============================================================================
140*/
141
142int16_t et_iosc(int16_t nn)
143{
144 register struct instdef *ip;
145 register int16_t val, ctl, fh, fl, v;
146
147 v = (nn >> 8) & 0x03;
148 ip = &vbufs[curvce];
149
150 switch (v) {
151
152 case 0:
153
154 val = ip->idhos1v;
155 ctl = ip->idhos1c;
156 break;
157
158 case 1:
159
160 val = ip->idhos2v;
161 ctl = ip->idhos2c;
162 break;
163
164 case 2:
165
166 val = ip->idhos3v;
167 ctl = ip->idhos3c;
168 break;
169
170 case 3:
171
172 val = ip->idhos4v;
173 ctl = ip->idhos4c;
174 break;
175 }
176/*
177
178*/
179 bform = ctl & OC_MOD;
180
181 switch (bform) {
182
183 case OC_INT: /* interval */
184
185 sprintf(ebuf, "%04d%c", ((val < 0 ? -val : val) >> 1),
186 (val < 0 ? '-' : '+'));
187
188 ebflag = TRUE;
189 return(SUCCESS);
190
191 case OC_RAT: /* ratio */
192
193 int2rat(val >> 1);
194 ebflag = TRUE;
195 return(SUCCESS);
196
197 case OC_FRQ: /* frequency */
198
199 fh = (val >> 1) / 10;
200 fl = (val >> 1) - (fh * 10);
201
202 sprintf(ebuf, "%02d.%d", fh, fl);
203 ebflag = TRUE;
204 return(SUCCESS);
205
206 case OC_PCH:
207
208 cnvc2p(ebuf, (val >> 1));
209 ebflag = TRUE;
210 return(SUCCESS);
211 }
212
213 return(FAILURE);
214}
215
216/*
217
218*/
219
220/*
221 =============================================================================
222 setoval() -- set oscillator mode and pitch/ratio variables
223 =============================================================================
224*/
225
226void setoval(struct instdef *ip, int16_t v, int16_t val)
227{
228 switch (v) {
229
230 case 0:
231
232 ip->idhos1v = val << 1;
233 ip->idhos1c = (ip->idhos1c & ~OC_MOD) | bform;
234 break;
235
236 case 1:
237
238 ip->idhos2v = val << 1;
239 ip->idhos2c = (ip->idhos2c & ~OC_MOD) | bform;
240 break;
241
242 case 2:
243
244 ip->idhos3v = val << 1;
245 ip->idhos3c = (ip->idhos3c & ~OC_MOD) | bform;
246 break;
247
248 case 3:
249
250 ip->idhos4v = val << 1;
251 ip->idhos4c = (ip->idhos4c & ~OC_MOD) | bform;
252 break;
253 }
254
255 ip->idhfnc[v].idftmd = (ip->idhfnc[v].idftmd & ~I_NRATIO)
256 | ((bform & 2) ? I_NRATIO : 0);
257}
258
259/*
260
261*/
262
263/*
264 =============================================================================
265 ef_iosc() -- unload (parse) edit buffer
266 =============================================================================
267*/
268
269int16_t ef_iosc(int16_t nn)
270{
271 register struct instdef *ip;
272 register int16_t v, i, tmp;
273
274 v = (nn >> 8) & 3;
275 ip = &vbufs[curvce];
276 ebflag = FALSE;
277
278 switch (bform) {
279
280 case OC_INT: /* interval */
281
282 tmp = 0;
283
284 for (i = 0; i < 4; i++)
285 tmp = (tmp * 10) + (ebuf[i] - '0');
286
287 if (ebuf[4] EQ '-')
288 tmp = -tmp;
289
290 setoval(ip, v, tmp);
291 modinst();
292 return(SUCCESS);
293
294 case OC_RAT: /* ratio */
295
296 tmp = ndvals[ebuf[0] - '0'] - ndvals[ebuf[2] - '0'];
297
298 setoval(ip, v, tmp);
299 modinst();
300 return(SUCCESS);
301/*
302
303*/
304 case OC_FRQ: /* frequency */
305
306 tmp = 0;
307
308 for (i = 0; i < 2; i++)
309 tmp = (tmp * 10) + ebuf[i] - '0';
310
311 tmp = (tmp * 10) + ebuf[3] - '0';
312
313 if (tmp GT 159)
314 return(FAILURE);
315
316 setoval(ip, v, tmp);
317 modinst();
318 return(SUCCESS);
319
320 case OC_PCH: /* pitch */
321
322 if (cnvp2c() EQ FAILURE)
323 return(FAILURE);
324
325 setoval(ip, v, cents);
326 modinst();
327 return(SUCCESS);
328 }
329
330 return(FAILURE);
331}
332
333/*
334
335*/
336
337/*
338 =============================================================================
339 rd_iosc() -- (re)display the field
340 =============================================================================
341*/
342
343int16_t rd_iosc(int16_t nn)
344{
345 register struct instdef *ip;
346 register int16_t val, ctl, fh, fl, v;
347 int16_t n;
348 int8_t ocs;
349
350 v = (nn >> 8) & 0x03;
351 n = nn & 0xFF;
352 ip = &vbufs[curvce];
353
354 switch (v) {
355
356 case 0:
357
358 val = ip->idhos1v;
359 ctl = ip->idhos1c;
360 break;
361
362 case 1:
363
364 val = ip->idhos2v;
365 ctl = ip->idhos2c;
366 break;
367
368 case 2:
369
370 val = ip->idhos3v;
371 ctl = ip->idhos3c;
372 break;
373
374 case 3:
375
376 val = ip->idhos4v;
377 ctl = ip->idhos4c;
378 break;
379 }
380/*
381
382*/
383 bform = ctl & OC_MOD;
384 ocs = ((v EQ 3) ? ' ' : (ctl & OC_SYN ? 'S' : 's'));
385
386 switch (bform) {
387
388 case OC_INT: /* interval */
389
390 sprintf(dspbuf, "Int %c%04d %c",
391 (val < 0 ? '-' : '+'),
392 ((val < 0 ? -val : val) >> 1),
393 ocs);
394 break;
395
396 case OC_RAT: /* ratio */
397
398 int2rat(val >> 1);
399 sprintf(dspbuf, "Rat %c/%c %c", ebuf[0], ebuf[2], ocs);
400 break;
401
402 case OC_FRQ: /* frequency */
403
404 fh = (val >> 1) / 10;
405 fl = (val >> 1) - (fh * 10);
406
407 sprintf(dspbuf, "Frq %02d.%d %c", fh, fl, ocs);
408 break;
409
410 case OC_PCH:
411
412 strcpy(dspbuf, "Pch ");
413 cnvc2p(&dspbuf[4], (val >> 1));
414 dspbuf[4] += '0';
415 dspbuf[5] += 'A';
416 dspbuf[6] = sfdsp[dspbuf[6] - 7];
417 dspbuf[7] += '0';
418 dspbuf[8] += '0';
419 dspbuf[9] = ' ';
420 dspbuf[10] = ocs;
421 dspbuf[11] = '\0';
422 break;
423 }
424
425 if (v_regs[5] & 0x0180)
426 vbank(0);
427
428 vcputsv(instob, 64, idbox[n][4], idbox[n][5], 18 + v , 36, dspbuf, 14);
429
430 return(SUCCESS);
431}
432
433/*
434
435*/
436
437/*
438 =============================================================================
439 setoscb() -- change oscillator data entry buffer format
440 =============================================================================
441*/
442
443void setoscb(int16_t n, int16_t v)
444{
445 register struct instdef *ip;
446 register int16_t bfm, ctl, val;
447 register int8_t ocs;
448
449 ip = &vbufs[curvce];
450
451 switch (v) {
452
453 case 0:
454
455 ctl = ip->idhos1c;
456 val = ip->idhos1v;
457 break;
458
459 case 1:
460
461 ctl = ip->idhos2c;
462 val = ip->idhos2v;
463 break;
464
465 case 2:
466
467 ctl = ip->idhos3c;
468 val = ip->idhos3v;
469 break;
470
471 case 3:
472
473 ctl = ip->idhos4c;
474 val = ip->idhos4v;
475 break;
476 }
477
478 ocs = ((v EQ 3) ? ' ' : (ctl & OC_SYN ? 'S' : 's'));
479
480 bfm = ctl & OC_MOD;
481/*
482
483*/
484 switch (bform) {
485
486 case OC_INT: /* interval */
487
488 if ((bfm EQ OC_RAT) OR (bfm EQ OC_INT)) {
489
490 sprintf(ebuf, "%04d%c", ((val < 0 ? -val : val) >> 1),
491 (val < 0 ? '-' : '+'));
492
493 sprintf(dspbuf, "Int %c%04d %c",
494 (val < 0 ? '-' : '+'),
495 ((val < 0 ? -val : val) >> 1),
496 ocs);
497
498 } else {
499
500 strcpy(ebuf, "0000+");
501 sprintf(dspbuf, "Int %s %c", intstr, ocs);
502 }
503
504 break;
505
506 case OC_RAT: /* ratio */
507
508 if (bfm EQ OC_RAT) {
509
510 int2rat(val >> 1);
511
512 sprintf(dspbuf, "Rat %c/%c %c",
513 ebuf[0], ebuf[2], ocs);
514
515 } else {
516
517 strcpy(ebuf, ratstr);
518 sprintf(dspbuf, "Rat %s %c", ratstr, ocs);
519 }
520
521 break;
522/*
523
524*/
525 case OC_FRQ: /* frequency */
526
527 strcpy(ebuf, frqstr);
528 sprintf(dspbuf, "Frq %s %c", frqstr, ocs);
529 break;
530
531 case OC_PCH: /* pitch */
532
533 ebuf[0] = 0; /* 0 */
534 ebuf[1] = 2; /* C */
535 ebuf[2] = 7; /* */
536 ebuf[3] = 0; /* 0 */
537 ebuf[4] = 0; /* 0 */
538
539 sprintf(dspbuf, "Pch %s %c", pchstr, ocs);
540 break;
541 }
542
543 ebflag = TRUE;
544
545 if (v_regs[5] & 0x0180)
546 vbank(0);
547
548 vcputsv(instob, 64, ID_ENTRY, idbox[n][5],
549 stcrow, 36, dspbuf, 14);
550}
551
552/*
553
554*/
555
556/*
557 =============================================================================
558 setosyn() -- set oscillator sync mode
559 =============================================================================
560*/
561
562void setosyn(int16_t n, int16_t v, int16_t t)
563{
564 register struct instdef *ip;
565 register int8_t *sc;
566
567 ip = &vbufs[curvce];
568
569 if (stcrow EQ 21)
570 return;
571
572 sc = t ? "S" : "s";
573
574 switch (v) {
575
576 case 0:
577
578 ip->idhos1c = (ip->idhos1c & ~OC_SYN) | (t ? OC_SYN : 0);
579 break;
580
581 case 1:
582
583 ip->idhos2c = (ip->idhos2c & ~OC_SYN) | (t ? OC_SYN : 0);
584 break;
585
586 case 2:
587
588 ip->idhos3c = (ip->idhos3c & ~OC_SYN) | (t ? OC_SYN : 0);
589 break;
590
591 case 3:
592
593 return;
594 }
595
596 dosync(curvce);
597
598 if (v_regs[5] & 0x0180)
599 vbank(0);
600
601 vcputsv(instob, 64, idbox[n][4], idbox[n][5], stcrow, stccol, sc, 14);
602 modinst();
603}
604
605/*
606
607*/
608
609/*
610 =============================================================================
611 nd_iosc() -- handle new data entry
612 =============================================================================
613*/
614
615int16_t nd_iosc(int16_t nn, int16_t k)
616{
617 register int16_t v, n;
618
619 n = nn & 0xFF;
620 v = (nn >> 8) & 3;
621
622 if (stccol LT 39) { /* mode */
623
624 if (k EQ 8) { /* - */
625
626 if (--bform LT 0)
627 bform = 3;
628
629 setoscb(n, v);
630 return(SUCCESS);
631
632 } else if (k EQ 9) { /* + */
633
634 if (++bform GT 3)
635 bform = 0;
636
637 setoscb(n, v);
638 return(SUCCESS);
639
640 } else
641 return(FAILURE);
642/*
643
644*/
645 } else if (stccol EQ 46) { /* sync */
646
647 if (stcrow EQ 21)
648 return(FAILURE);
649
650 if (k EQ 8) { /* - */
651
652 setosyn(n, v, 0); /* off */
653 return(SUCCESS);
654
655 } else if (k EQ 9) { /* + */
656
657 setosyn(n, v, 1); /* on */
658 return(SUCCESS);
659
660 } else
661 return(FAILURE);
662
663/*
664
665*/
666 } else if ((stccol GE 40) AND (stccol LE 44)) { /* value */
667
668 switch (bform) {
669
670 case OC_INT: /* interval */
671
672 if (stccol EQ 40) { /* sign */
673
674 if (k EQ 8) { /* - */
675
676 k = '-';
677 ebuf[4] = '-';
678
679 } else if (k EQ 9) { /* + */
680
681 k = '+';
682 ebuf[4] = '+';
683
684 } else
685 return(FAILURE);
686
687 } else {
688
689 ebuf[stccol - 41] = k + '0';
690 }
691
692 dspbuf[0] = (k > 9) ? k : (k + '0');
693 dspbuf[1] = '\0';
694
695 if (v_regs[5] & 0x0180)
696 vbank(0);
697
698 vcputsv(instob, 64, ID_ENTRY, idbox[n][5],
699 stcrow, stccol, dspbuf, 14);
700
701 if (stccol EQ 44)
702 return(SUCCESS);
703
704 advicur();
705 return(SUCCESS);
706/*
707
708*/
709 case OC_RAT: /* ratio */
710
711 if (stccol EQ 40) {
712
713 if (k) {
714
715 ebuf[0] = dspbuf[0] = k + '0';
716 dspbuf[1] = '\0';
717
718 if (v_regs[5] & 0x0180)
719 vbank(0);
720
721 vcputsv(instob, 64, ID_ENTRY, idbox[n][5],
722 stcrow, stccol, dspbuf, 14);
723
724 advicur();
725 advicur();
726
727 return(SUCCESS);
728
729 } else
730 return(FAILURE);
731
732 } else if (stccol EQ 42) {
733
734 if (k) {
735
736 ebuf[2] = dspbuf[0] = k + '0';
737 dspbuf[1] = '\0';
738
739 if (v_regs[5] & 0x0180)
740 vbank(0);
741
742 vcputsv(instob, 64, ID_ENTRY, idbox[n][5],
743 stcrow, stccol, dspbuf, 14);
744
745 return(SUCCESS);
746
747 } else
748 return(FAILURE);
749 } else {
750
751 return(FAILURE);
752 }
753/*
754
755*/
756 case OC_FRQ: /* frequency */
757
758 if (stccol EQ 42)
759 return(FAILURE);
760
761 ebuf[stccol - 40] = k + '0';
762 dspbuf[0] = k + '0';
763 dspbuf[1] = '\0';
764
765 if (v_regs[5] & 0x0180)
766 vbank(0);
767
768 vcputsv(instob, 64, ID_ENTRY, idbox[n][5],
769 stcrow, stccol, dspbuf, 14);
770
771 if (stccol EQ 44)
772 return(SUCCESS);
773
774 advicur();
775
776 if (stccol EQ 42)
777 advicur();
778
779 return(SUCCESS);
780/*
781
782*/
783 case OC_PCH: /* pitch */
784
785 switch (stccol) {
786
787 case 40:
788
789 ebuf[0] = k;
790 dspbuf[0] = k + '0';
791 break;
792
793 case 41:
794
795 if (k GT 6)
796 return(FAILURE);
797
798 ebuf[1] = k;
799 dspbuf[0] = k + 'A';
800 break;
801
802 case 42:
803
804 if (k EQ 7) { /* blank */
805
806 ebuf[2] = k;
807 dspbuf[0] = sfdsp[0];
808 break;
809
810 } else if (k EQ 8) { /* flat */
811
812 ebuf[2] = k;
813 dspbuf[0] = sfdsp[1];
814 break;
815
816 } else if (k EQ 9) { /* sharp */
817
818 ebuf[2] = k;
819 dspbuf[0] = sfdsp[2];
820 break;
821
822 } else
823 return(FAILURE);
824 case 43:
825 case 44:
826
827 ebuf[stccol - 40] = k;
828 dspbuf[0] = k + '0';
829 break;
830 }
831/*
832
833*/
834
835 dspbuf[1] = '\0';
836
837 if (v_regs[5] & 0x0180)
838 vbank(0);
839
840 vcputsv(instob, 64, ID_ENTRY, idbox[n][5],
841 stcrow, stccol, dspbuf, 14);
842
843 if (stccol EQ 44)
844 return(SUCCESS);
845
846 advicur();
847 return(SUCCESS);
848 }
849
850 return(FAILURE);
851
852 } else {
853
854 return(FAILURE);
855 }
856}
857
Note: See TracBrowser for help on using the repository browser.