home *** CD-ROM | disk | FTP | other *** search
/ ftp.whtech.com / ftp.whtech.com.7z / ftp.whtech.com / emulators / v9t9 / linux / sources / V9t9 / source / speech.c < prev    next >
Encoding:
C/C++ Source or Header  |  2006-10-19  |  19.0 KB  |  925 lines
  1.  
  2. /*
  3.         SPEECH.C
  4.         =======
  5.  
  6. */
  7.  
  8. #define __SPEECH__
  9.  
  10. #include <unistd.h>
  11. #include "v9t9_common.h"
  12. #include "v9t9.h"
  13. #include "sound.h"
  14. #include "memory.h"
  15. #include "speech.h"
  16. #include "timer.h"
  17. #include "roms.h"
  18.  
  19. #define _L     LOG_SPEECH | LOG_INFO
  20. #include "tms5220r.c"
  21.  
  22. char    speechromfilename[64]="spchrom.bin";
  23.  
  24. static struct tms5200 sp;
  25. static struct LPC lpc;        /* LPC info */
  26.  
  27. u8         speechrom[65536];
  28.  
  29. static int speech_hertz = 8000;
  30. static int speech_length = 200;
  31. static s8 *speech_data;
  32.  
  33.  
  34. /****************************************************/
  35.  
  36. static int  speech_event_tag;
  37. static int  in_speech_intr = 0;    // mutex on speech_intr
  38.  
  39. #define SPEECH_TIMEOUT (25+9)
  40.  
  41. /****************************************************/
  42.  
  43.  
  44. static u8   swapped_nybbles[16] = 
  45. { 
  46.     0x0, 0x8, 0x4, 0xc,
  47.     0x2, 0xa, 0x6, 0xe,
  48.     0x1, 0x9, 0x5, 0xd,
  49.     0x3, 0xb, 0x7, 0xf
  50. };
  51.  
  52. static      u8
  53. swapbits(u8 in)
  54. {
  55.     return (swapped_nybbles[in & 0xf] << 4) |
  56.         (swapped_nybbles[(in & 0xf0) >> 4]);
  57. }
  58.  
  59. /*
  60. static u8
  61. swapbits(u8 in)
  62. {
  63.     in = ((in >> 1) & 0x55) | ((in << 1) & 0xaa);
  64.     in = ((in >> 2) & 0x33) | ((in << 2) & 0xcc);
  65.     in = ((in >> 4) & 0x0f) | ((in << 4) & 0xf0);
  66.     return in;
  67. }
  68. */
  69.  
  70. /******************************************************/
  71.  
  72. static void 
  73. tms5200purgeFIFO(void)
  74. {
  75.     sp.bit = sp.bits = sp.out = sp.in = sp.len = 0;
  76. }
  77.  
  78. static void
  79. LPCinit(void)
  80. {
  81.     memset((void *) &lpc, 0, sizeof(lpc));
  82.     lpc.decode |= FL_first;
  83.     /*  Reset excitation filters  */
  84.     lpc.ns1 = 0xaaaaaaaa;
  85.     lpc.ns2 = 0x1;
  86. }
  87.  
  88. static void
  89. SpeechOn(void)
  90. {
  91.     if (!speech_event_tag)
  92.         speech_event_tag = TM_UniqueTag();
  93.  
  94.     TM_SetEvent(speech_event_tag, TM_HZ * 100 / 40, 0,
  95.                 TM_REPEAT | TM_FUNC, speech_intr);
  96. }
  97.  
  98. static void
  99. SpeechOff(void)
  100. {
  101.     TM_ResetEvent(speech_event_tag);
  102. }
  103.  
  104. static void
  105. tms5200reset(void)
  106. {
  107.     logger(_L | L_1, "Speech reset");
  108.     sp.status = SS_BE | SS_BL;
  109.     tms5200purgeFIFO();
  110.     sp.command = 0x70;
  111.     sp.data = 0;
  112.     sp.addr = 0; sp.addr_pos = 0;
  113.     sp.gate = GT_RSTAT | GT_WCMD;
  114.     SpeechOff();
  115.     sp.status &= ~SS_SPEAKING;
  116.     sp.timeout = SPEECH_TIMEOUT;
  117.     LPCinit();
  118.     in_speech_intr = 0;
  119. }
  120.  
  121. static      u8
  122. tms5200read(void)
  123. {
  124.     sp.addr_pos = 0;
  125.     if (sp.addr >= 32768)
  126.         sp.data = 0;
  127.     else
  128.         sp.data = speechrom[sp.addr];
  129.     sp.addr++;
  130.     sp.gate = (sp.gate & ~GT_RSTAT) | GT_RDAT;
  131.     logger(_L | L_2, "Speech read: %02X\n\n", sp.data);
  132.     return sp.data;
  133. }
  134.  
  135. static      u8
  136. tms5200peek(void)
  137. {
  138.     sp.addr_pos = 0;
  139.     if (sp.addr >= 32768)
  140.         sp.data = 0;
  141.     else
  142.         sp.data = speechrom[sp.addr];
  143.     sp.gate = (sp.gate & ~GT_RSTAT) | GT_RDAT;
  144.     return sp.data;
  145. }
  146.  
  147. static void
  148. tms5200loadAddress(u32 nybble)
  149. {
  150.     sp.addr_pos = (sp.addr_pos + 1) % 5;
  151.     sp.addr = (sp.addr >> 4) | (nybble << 16);
  152.     logger(_L | L_2, "Speech addr = %04X\n", sp.addr);
  153. }
  154.  
  155. static void
  156. tms5200readAndBranch(void)
  157. {
  158.     u32         addr;
  159.  
  160.     sp.addr_pos = 0;
  161.     addr = (tms5200read() << 8) + tms5200read();
  162.     sp.addr = (sp.addr & 0xc000) | (addr & 0x3fff);
  163.     sp.gate = (sp.gate & ~GT_RDAT) | GT_RSTAT;
  164. }
  165.  
  166. static void
  167. tms5200speak(void)
  168. {
  169.     logger(_L | L_1, "Speaking phrase at %04X\n", sp.addr);
  170.     sp.status |= SS_TS;
  171.     sp.gate = (sp.gate & ~GT_WDAT) | GT_WCMD;    /* just in case */
  172.     sp.bit = 0;                    /* start on byte boundary */
  173.     // flush existing sample
  174.     SPEECHPLAY(vms_Speech, NULL, 0L, speech_hertz);
  175.     sp.status |= SS_SPEAKING;
  176.     while (sp.status & SS_SPEAKING)
  177.         speech_intr();            // not scheduled
  178.     LPCinit();
  179. }
  180.  
  181. static void
  182. tms5200speakExternal(void)
  183. {
  184.     logger(_L | L_1, "Speaking external data");
  185.     sp.gate = (sp.gate & ~GT_WCMD) | GT_WDAT;    /* accept data from I/O */
  186.     tms5200purgeFIFO();
  187.     SpeechOn();                    /* call speech_intr every 25 ms */
  188.     sp.status |= SS_SPEAKING;
  189.     sp.timeout = SPEECH_TIMEOUT;
  190. }
  191.  
  192. /*    Undocumented and unknown function... */
  193. static void
  194. tms5200loadFrameRate(u8 val)
  195. {
  196.     if (val & 0x4) {
  197.         /* variable */
  198.     } else {
  199.         /* frameRate = val & 0x3; */
  200.     }
  201. }
  202.  
  203. static void
  204. tms5200command(u8 cmd)
  205. {
  206.     sp.command = cmd & 0x70;
  207.     logger(_L | L_3, "Cmd=%02X  Status: %02X\n\n", cmd, sp.status);
  208.     switch (sp.command) {
  209.     case 0x00:
  210.     case 0x20:
  211.         tms5200loadFrameRate(cmd & 0x7);
  212.         break;
  213.     case 0x10:
  214.         tms5200read();
  215.         break;
  216.     case 0x30:
  217.         tms5200readAndBranch();
  218.         break;
  219.     case 0x40:
  220.         tms5200loadAddress(cmd & 0xf);
  221.         break;
  222.     case 0x50:
  223.         tms5200speak();
  224.         break;
  225.     case 0x60:
  226.         tms5200speakExternal();
  227.         break;
  228.     case 0x70:
  229.         tms5200reset();
  230.         break;
  231.         /* default: ignore */
  232.     }
  233. }
  234.  
  235. static void
  236. tms5200writeFIFO(u8 val)
  237. {
  238.     sp.fifo[sp.in] = swapbits(val);
  239.     sp.in = (sp.in + 1) & 15;
  240.     logger(_L | L_3, "FIFO write: %02X  len=%d\n", val, sp.len);
  241.     if (sp.len < 16)
  242.         sp.len++;
  243.     sp.timeout = SPEECH_TIMEOUT;
  244.     sp.status &= ~SS_BE;
  245.     if (sp.len > 8) {
  246.         sp.status &= ~SS_BL;
  247.         speech_intr();
  248.     }
  249. }
  250.  
  251. static      u8
  252. tms5200readFIFO(void)
  253. {
  254.     u8          ret = sp.fifo[sp.out];
  255.  
  256.     logger(_L | L_3, "FIFO read: %02X  len=%d\n", ret, sp.len);
  257.  
  258.     if (sp.len == 0) {
  259.         sp.status |= SS_BE;
  260.         tms5200reset();
  261.         SpeechOff();
  262.         logger(_L | L_1, "Speech timed out\n");
  263.     }
  264.  
  265.     if (sp.len > 0) {
  266.         sp.out = (sp.out + 1) & 15;
  267.         sp.len--;
  268.     }
  269.     if (sp.len < 8)
  270.         sp.status |= SS_BL;
  271.     if (sp.len == 0) {
  272.         sp.status |= SS_BE;
  273.     }
  274.     return ret;
  275. }
  276.  
  277. static      u8
  278. tms5200peekFIFO(void)
  279. {
  280.     return sp.fifo[sp.out];
  281. }
  282.  
  283.  
  284. /*
  285.     Fetch so many bits.
  286.     
  287.     This differs if we're reading from vocabulary or FIFO, in terms
  288.     of where a byte comes from, but that's all.
  289.     
  290.     When reading from the FIFO, we only execute ...readFIFO when we
  291.     are finished with the byte.
  292. */
  293. static      u32
  294. LPCfetch(int bits)
  295. {
  296.     u32         cur;
  297.  
  298.     if (sp.gate & GT_WDAT) {    /* from FIFO */
  299.         if (sp.bit + bits >= 8) {    /* we will cross into the next byte */
  300.             cur = tms5200readFIFO() << 8;
  301.             cur |= tms5200peekFIFO();    /* we can't read more than 6 bits,
  302.                                            so no poss of crossing TWO bytes */
  303.         } else
  304.             cur = tms5200peekFIFO() << 8;
  305.     } else {                    /* from vocab */
  306.  
  307.         if (sp.bit + bits >= 8) {
  308.             cur = tms5200read() << 8;
  309.             cur |= tms5200peek();
  310.         } else
  311.             cur = tms5200peek() << 8;
  312.     }
  313.  
  314.     /*  Get the bits we want.  */
  315.     cur = (cur << (sp.bit + 16)) >> (32 - bits);
  316.  
  317.     /*  Adjust bit ptr  */
  318.     sp.bit = (sp.bit + bits) & 7;
  319.  
  320.     sp.bits += bits;
  321.     return cur;
  322. }
  323.  
  324.  
  325. /***************************************************************
  326.     This section handles decoding one LPC equation into the 'lpc'
  327.     structure.
  328. ****************************************************************/
  329.  
  330. #define SHIFT 4
  331. #define KTRANS(x) (x)
  332.  
  333. static void
  334. LPCclearToSilence(void)
  335. {
  336.     lpc.pnv = 12;
  337.     lpc.env = 0;
  338.     memset(lpc.knv, 0, sizeof(lpc.knv));
  339.  
  340.     lpc.knv[0] = KTRANS(k1table[0]);
  341.     lpc.knv[1] = KTRANS(k2table[0]);
  342.     lpc.knv[2] = KTRANS(k3table[0]);
  343.     lpc.knv[3] = KTRANS(k4table[0]);
  344.     lpc.knv[4] = KTRANS(k5table[0]);
  345.     lpc.knv[5] = KTRANS(k6table[0]);
  346.     lpc.knv[6] = KTRANS(k7table[0]);
  347.     lpc.knv[7] = KTRANS(k8table[0]);
  348.     lpc.knv[8] = KTRANS(k9table[0]);
  349.     lpc.knv[9] = KTRANS(k10table[0]);
  350.     
  351.     // if the previous frame was unvoiced,
  352.     // it would sound bad to interpolate.
  353.     // just clear it all out.
  354.     if (lpc.decode & FL_unvoiced) {
  355.         lpc.pbf = 12;
  356.         lpc.ebf = 0;
  357.         memset(lpc.kbf, 0, sizeof(lpc.kbf));
  358.  
  359.         lpc.kbf[0] = KTRANS(k1table[0]);
  360.         lpc.kbf[1] = KTRANS(k2table[0]);
  361.         lpc.kbf[2] = KTRANS(k3table[0]);
  362.         lpc.kbf[3] = KTRANS(k4table[0]);
  363.         lpc.kbf[4] = KTRANS(k5table[0]);
  364.         lpc.kbf[5] = KTRANS(k6table[0]);
  365.         lpc.kbf[6] = KTRANS(k7table[0]);
  366.         lpc.kbf[7] = KTRANS(k8table[0]);
  367.         lpc.kbf[8] = KTRANS(k9table[0]);
  368.         lpc.kbf[9] = KTRANS(k10table[0]);
  369.     }
  370. }
  371.  
  372.  
  373. static void
  374. LPCreadEquation(void)
  375. {
  376.     char        txt[256], *tptr = txt;
  377.  
  378.     sp.bits = 0;
  379.  
  380.     /*     Copy now-old 'new' values into 'buffer' values */
  381.     lpc.ebf = lpc.env;
  382.     lpc.pbf = lpc.pnv;
  383.     memcpy(lpc.kbf, lpc.knv, sizeof(lpc.kbf));
  384.  
  385.     /*  Read energy  */
  386.     lpc.env = LPCfetch(4);
  387.     tptr += sprintf(tptr, "E: %d ", lpc.env);
  388.     if (lpc.env == 15) {
  389.         lpc.decode |= FL_last;
  390.         sp.status &= ~SS_TS;    /* we will go one more frame to 
  391.                                    interpolate to silence, then speech_event
  392.                                    will be reset */
  393.     } else if (lpc.env == 0) {    /* silent frame */
  394.         LPCclearToSilence();    /* clear params */
  395.         lpc.decode |= FL_nointerp;
  396.     } else {
  397.         /*  Repeat bit  */
  398.         lpc.rpt = LPCfetch(1);
  399.         tptr += sprintf(tptr, "R: %d ", lpc.rpt);
  400.  
  401.         /*  Pitch code  */
  402.         lpc.pnv = LPCfetch(6);
  403.         tptr += sprintf(tptr, "P: %d ", lpc.pnv);
  404.  
  405.         if (lpc.pnv == 0) {        /* unvoiced */
  406.             if (lpc.decode & FL_unvoiced)    /* voiced before? */
  407.                 lpc.decode |= FL_nointerp;    /* don't interpolate */
  408.             else
  409.                 lpc.decode &= ~FL_nointerp;
  410.             lpc.decode |= FL_unvoiced;
  411.             lpc.pnv = 12;        /* set some pitch */
  412.  
  413.             if (lpc.ebf == 0)    /* previous frame silent? */
  414.                 lpc.decode |= FL_nointerp;
  415.         } else {                /* voiced */
  416.  
  417.             lpc.pnv = pitchtable[lpc.pnv] >> 8;
  418.  
  419.             if (lpc.decode & FL_unvoiced)    /* unvoiced before? */
  420.                 lpc.decode |= FL_nointerp;    /* don't interpolate */
  421.             else
  422.                 lpc.decode &= ~FL_nointerp;
  423.  
  424.             lpc.decode &= ~FL_unvoiced;
  425.         }
  426.  
  427.         /* translate energy */
  428.         lpc.env = energytable[lpc.env];
  429.  
  430.         /*  Get K parameters  */
  431.  
  432.         if (!lpc.rpt) {            /* don't repeat previous frame? */
  433.             u32         tmp;
  434.  
  435.             tmp = LPCfetch(5);
  436.             lpc.knv[0] = KTRANS(k1table[tmp]);
  437.             tptr += sprintf(tptr, "K0: %d ", tmp);
  438.  
  439.             tmp = LPCfetch(5);
  440.             lpc.knv[1] = KTRANS(k2table[tmp]);
  441.             tptr += sprintf(tptr, "K1: %d ", tmp);
  442.  
  443.             tmp = LPCfetch(4);
  444.             lpc.knv[2] = KTRANS(k3table[tmp]);
  445.             tptr += sprintf(tptr, "K2: %d ", tmp);
  446.  
  447.             tmp = LPCfetch(4);
  448.             lpc.knv[3] = KTRANS(k4table[tmp]);
  449.             tptr += sprintf(tptr, "K3: %d ", tmp);
  450.  
  451.             if (!(lpc.decode & FL_unvoiced)) {    /* unvoiced? */
  452.                 tmp = LPCfetch(4);
  453.                 lpc.knv[4] = KTRANS(k5table[tmp]);
  454.                 tptr += sprintf(tptr, "K4: %d ", tmp);
  455.  
  456.                 tmp = LPCfetch(4);
  457.                 lpc.knv[5] = KTRANS(k6table[tmp]);
  458.                 tptr += sprintf(tptr, "K5: %d ", tmp);
  459.  
  460.                 tmp = LPCfetch(4);
  461.                 lpc.knv[6] = KTRANS(k7table[tmp]);
  462.                 tptr += sprintf(tptr, "K6: %d ", tmp);
  463.  
  464.                 tmp = LPCfetch(3);
  465.                 lpc.knv[7] = KTRANS(k8table[tmp]);
  466.                 tptr += sprintf(tptr, "K7: %d ", tmp);
  467.  
  468.                 tmp = LPCfetch(3);
  469.                 lpc.knv[8] = KTRANS(k9table[tmp]);
  470.  
  471.                 tptr += sprintf(tptr, "K8: %d ", tmp);
  472.  
  473.                 tmp = LPCfetch(3);
  474.                 lpc.knv[9] = KTRANS(k10table[tmp]);
  475.                 tptr += sprintf(tptr, "K9: %d ", tmp);
  476.             } else {
  477.                 lpc.knv[4] = KTRANS(k5table[0]);
  478.                 lpc.knv[5] = KTRANS(k6table[0]);
  479.                 lpc.knv[6] = KTRANS(k7table[0]);
  480.                 lpc.knv[7] = KTRANS(k8table[0]);
  481.                 lpc.knv[8] = KTRANS(k9table[0]);
  482.                 lpc.knv[9] = KTRANS(k10table[0]);
  483.             }
  484.         }
  485.     }
  486.     logger(_L | L_1, "Equation: %s\n", txt);
  487.  
  488.     logger(_L | L_1, "ebf=%d, pbf=%d, env=%d, pnv=%d\n",
  489.            lpc.ebf, lpc.pbf, lpc.env, lpc.pnv);
  490. }
  491.  
  492. /*******************************************************************
  493.     This section handles the 'execution' of an LPC equation.
  494. ********************************************************************/
  495.  
  496. /*
  497.     Interpolate "new" values and "buffer" values.
  498. */
  499. static void
  500. LPCinterpolate(int period)
  501. {
  502.     int         x;
  503.  
  504.     if (!(lpc.decode & FL_nointerp)) {
  505.         lpc.ebf += (lpc.env - lpc.ebf) / interp_coeff[period];
  506.         lpc.pbf += (lpc.pnv - lpc.pbf) / interp_coeff[period];
  507.         for (x = 0; x < 11; x++)
  508.             lpc.kbf[x] += (lpc.knv[x] - lpc.kbf[x]) / interp_coeff[period];
  509.     }
  510. /*    logger(_L|LOG_USER, "[%d]\n", lpc.kbf[0]);
  511.     if (period == 7) logger(_L|LOG_USER,"\n");*/
  512.  
  513.     logger(_L|L_1, "[%d] ebf=%d, pbf=%d\n", period, lpc.ebf, lpc.pbf);
  514. }
  515.  
  516. #define ONE 32768
  517.  
  518. // this is safe since our values are ~14 bits
  519. #define MD(a,b) (((a)*(b))/ONE)
  520. #define B(i) lpc.b[i]
  521. #define Y(i) lpc.y[i]
  522. #define K(i) lpc.kbf[i]
  523. #define U Y(10)
  524.  
  525. static void
  526. LPCcalc(void)
  527. {
  528.     int         frames, bytes, stage;
  529.     s8         *ptr;
  530.  
  531.     ptr = speech_data;
  532.     if (!ptr) 
  533.         return;
  534.  
  535.     frames = 8;
  536.     while (frames--) {
  537.         bytes = speech_length / 8;
  538.  
  539.         while (bytes--) {
  540.             s32         samp;
  541.  
  542.             /*  Get excitation data in U */
  543.             if ((lpc.decode & FL_unvoiced)) {
  544.                 U = (lpc.ns1 & 1) ? lpc.ebf / 4 : -lpc.ebf / 4;
  545.  
  546.                 /* noise generator */
  547.                 lpc.ns1 = (lpc.ns1 << 1) | (lpc.ns1 >> 31);
  548.                 lpc.ns1 ^= lpc.ns2;
  549.                 if ((lpc.ns2 += lpc.ns1) == 0)
  550.                     lpc.ns2++;
  551.             } else {
  552.                 U =
  553.                     lpc.ppctr <    41 
  554.                     ? chirptable[lpc.ppctr] * lpc.ebf / 256 
  555.                     : 0;
  556.                 if (lpc.pbf)
  557.                     lpc.ppctr = (lpc.ppctr + 1) % lpc.pbf;
  558.                 else
  559.                     lpc.ppctr = 0;
  560.             }
  561.  
  562.             /*  -----------------------------------------
  563.                10-stage lattice filter.
  564.  
  565.                range 1..10 here, 0..9 in our arrays
  566.  
  567.                Y10(i) = U(i) - K10*B10(i-1) U(i)=excitation
  568.                ----
  569.                Y9(i) = Y10(i) - K9*B9(i-1)
  570.                B10(i)= B9(i-1) + K9*Y9(i)
  571.                ----
  572.                ...
  573.                Y1(i) = Y2(i) - K1*B1(i-1)
  574.                B2(i) = B1(i-1) + K1*Y1(i)
  575.                ----
  576.                B1(i) = Y1(i)
  577.                ----------------------------------------- */
  578.  
  579.             /*  Stage 10 is different than the others.
  580.                Instead of calculating B11, we scale the excitation by
  581.                the energy.
  582.  
  583.              */
  584.  
  585.             for (stage = 9; stage >= 0; stage--) {
  586.                 Y(stage) = Y(stage + 1) - MD(K(stage), B(stage));
  587.                 B(stage + 1) = B(stage) + MD(K(stage), Y(stage));
  588.             }
  589.  
  590.             samp = Y(0);
  591.             B(0) = samp;
  592.  
  593.             *ptr++ = (samp > 511 ? 127 : samp < -512 ? -128 : samp >> 2);
  594.         }
  595.  
  596.         /* Interpolate values from *nv to *bf */
  597.         LPCinterpolate(7 - frames);
  598.     }
  599. }
  600.  
  601.  
  602. /*
  603.     Interpolation here is from the previous LPC equation.
  604.     Another 8 rounds of parameter interpolation occur inside
  605.     the calculation.
  606. */
  607. static void
  608. LPCexec(void)
  609. {
  610.     if (lpc.decode & (FL_nointerp | FL_first))
  611.         lpc.decode &= ~FL_first;
  612.  
  613.     lpc.ppctr = 0;
  614.  
  615.     memset(lpc.y, 0, sizeof(lpc.y));
  616.     memset(lpc.b, 0, sizeof(lpc.b));
  617.  
  618.     LPCcalc();
  619.  
  620.         /* spit it out */
  621.     if (speech_data)
  622.         SPEECHPLAY(vms_Speech, speech_data, speech_length, speech_hertz);    
  623.  
  624.     if (lpc.decode & FL_last) {    /* last frame */
  625.         logger(_L | L_1, "Done with speech phrase\n");
  626.         SpeechOff();            /* stop interrupting */
  627.         sp.status &= ~SS_SPEAKING;    /* stop interrupting */
  628.         sp.gate = (sp.gate & ~GT_WDAT) | GT_WCMD;
  629.     }
  630. }
  631.  
  632. /*    
  633.     One LPC frame consists of decoding one equation (or repeating,
  634.     or stopping), and calculating a speech waveform and outputting it.
  635.     
  636.     This happens during an interrupt.
  637.     
  638.     If we're here, we have enough data to form any one equation.
  639. */
  640. static void
  641. LPCframe(void)
  642. {
  643.     LPCreadEquation();
  644.     if (sp.status & SS_SPEAKING)    /* didn't get empty condition */
  645.         LPCexec();
  646. }
  647.  
  648.  
  649.  
  650. void
  651. speech_intr(void)
  652. {
  653.     if (in_speech_intr)
  654.         return;
  655.     in_speech_intr = 1;
  656.  
  657.     logger(_L | L_2, "In speech Interrupt\n");
  658.     if (sp.gate & GT_WDAT) {    /* direct data */
  659.         if (!(sp.status & SS_TS))    /* not talking yet... we're waiting for */
  660.             if (sp.status & SS_BL)    /* enough data in the buffer */
  661.                 goto out;        /* ... not yet */
  662.             else
  663.                 sp.status |= SS_TS;    /* whee!  Start talking */
  664.         else if (sp.status & SS_BL) {
  665.             if (sp.timeout-- <= 0)
  666.                 tms5200reset();
  667.             goto out;
  668.         }
  669.     }
  670.     LPCframe();                    /* execute a frame */
  671.   out:
  672.     logger(_L | L_2, "Out of speech interrupt\n");
  673.     in_speech_intr = 0;
  674. }
  675.  
  676.  
  677. /********************/
  678.  
  679. u16
  680. speech_mmio_get_addr(void)
  681. {
  682.     return sp.addr;
  683. }
  684.  
  685. void
  686. speech_mmio_set_addr(u16 addr)
  687. {
  688.     sp.addr = addr;
  689. }
  690.  
  691. bool
  692. speech_mmio_addr_is_complete(void)
  693. {
  694.     return sp.addr_pos == 0 || sp.addr_pos == 5;
  695. }
  696.  
  697. void
  698. speech_mmio_write(u8 val)
  699. {
  700.     if (sp.gate & GT_WCMD)
  701.         tms5200command(val);
  702.     else
  703.         tms5200writeFIFO(val);
  704. }
  705.  
  706. s8 speech_mmio_read(void)
  707. {
  708.     if (sp.gate & GT_RSTAT) {
  709.         logger(_L | L_2, "Status: %02X\n\n", sp.status);
  710.         return sp.status & (SS_TS | SS_BE | SS_BL);
  711.     } else {
  712.         sp.gate = (sp.gate & ~GT_RDAT) | GT_RSTAT;
  713.         return sp.data;
  714.     }
  715. }
  716.  
  717. mrstruct speech_handler =
  718. {
  719.     speechrom, speechrom, 0L,        // cannot write
  720.     NULL, NULL,
  721.     NULL, NULL
  722. };
  723.  
  724. void
  725. speech_memory_init(void)
  726. {
  727.     memory_insert_new_entry(MEMENT_SPEECH, 0x0000, 0x10000, 
  728.                            "Speech ROM",
  729.                             //    0L /*filename*/, 0L /*fileoffs*/, 
  730.                             speechromfilename, 0 /*fileoffs*/,
  731.                             &speech_handler);
  732.  
  733. }
  734.  
  735. /************************/
  736.  
  737. static void
  738. speech_initLPC(void)
  739. {
  740.     if (!(features & FE_SPEECH)) {
  741.         features &= ~(FE_PLAYSPEECH | FE_SPEECH);
  742.         logger(_L | LOG_USER, "Sound module cannot play speech, speech disabled.\n\n");
  743.     } else
  744.         logger(_L | L_0, "Setting up LPC speech...\n\n");
  745. }
  746.  
  747.  
  748. /***********************************************/
  749.  
  750. static
  751. DECL_SYMBOL_ACTION(speech_set_sample_length)
  752. {
  753.     if (task == csa_WRITE) {
  754.         xfree(speech_data);
  755.         if (speech_length <= 0) speech_length = 1;
  756.         speech_data = (s8*) xmalloc(speech_length);
  757.     }
  758.     return 1;
  759. }
  760.  
  761. static
  762. DECL_SYMBOL_ACTION(speech_define_speech_rom)
  763. {
  764.     char cmdbuf[1024];
  765.     char *fname;
  766.  
  767.     if (task == csa_READ) {
  768.         command_arg_get_string(SYM_ARG_1st, &fname);
  769.         if (!fname || !*fname)
  770.             return 0;
  771.         else 
  772.             return (iter == 0);
  773.     }
  774.  
  775.     command_arg_get_string(SYM_ARG_1st, &fname);
  776.     if (!*fname)
  777.         fname = "spchrom.bin";
  778.     sprintf(cmdbuf, "DefineMemory \"RS\" 0x0000 -0x10000 \"%s\" 0x0 \"Speech ROM\"\n", fname);
  779.     return command_parse_text(cmdbuf);
  780. }
  781.  
  782. int
  783. speech_preconfiginit(void)
  784. {
  785.     command_symbol_table *speechcommands =
  786.         command_symbol_table_new("Speech Options",
  787.                                  "These are commands for controlling speech synthesis",
  788.  
  789.          command_symbol_new("PlaySpeech",
  790.                             "Control whether speech is played",
  791.                             c_STATIC,
  792.                             NULL /*action*/,
  793.                             RET_FIRST_ARG,
  794.                             command_arg_new_toggle
  795.                             ("on|off",
  796.                              "toggle speech on or off",
  797.                              NULL /* action */ ,
  798.                              ARG_NUM(features),
  799.                              FE_PLAYSPEECH,
  800.                              NULL /* next */ )
  801.                             ,
  802.  
  803.          command_symbol_new("SpeechROMFileName",
  804.                             "Name of speech ROM",
  805.                             c_DYNAMIC,
  806.                             speech_define_speech_rom /* action */ ,
  807.                             RET_FIRST_ARG,
  808.                             command_arg_new_string
  809.                             ("file",
  810.                              "name of binary image",
  811.                              NULL /* action */,
  812.                              NEW_ARG_NEW_STRBUF,
  813.                              NULL /* next */ )
  814.                             ,
  815.  
  816.          command_symbol_new("SpeechHertz",
  817.                             "Set sample rate for speech",
  818.                             c_STATIC,
  819.                             NULL /*action*/,
  820.                             RET_FIRST_ARG,
  821.                             command_arg_new_num
  822.                             ("hertz",
  823.                              "normal value is 8000",
  824.                              NULL /* action */ ,
  825.                              ARG_NUM(speech_hertz),
  826.                              NULL /* next */ )
  827.                             ,
  828.  
  829.          command_symbol_new("SpeechSampleLength",
  830.                             "Set sample length for a unit of speech",
  831.                             c_STATIC,
  832.                             speech_set_sample_length,
  833.                             RET_FIRST_ARG,
  834.                             command_arg_new_num
  835.                             ("length",
  836.                              "in bytes, normal value is 200",
  837.                              NULL /* action */ ,
  838.                              ARG_NUM(speech_length),
  839.                              NULL /* next */ )
  840.                             ,
  841.  
  842.         NULL /*next*/)))),
  843.         NULL /*sub*/,
  844.         NULL /*next*/
  845.     );                                 
  846.  
  847.     command_symbol_table_add_subtable(universe, speechcommands);
  848.     speech_length = 200;
  849.     speech_data = (s8*) xmalloc(speech_length);
  850.     LPCinit();
  851.     features |= FE_SPEECH|FE_PLAYSPEECH;
  852.     return 1;
  853. }
  854.  
  855. int
  856. speech_postconfiginit(void)
  857. {
  858. /*    if (!loadspeech(romspath, systemromspath, 
  859.                     speechromfilename, speechrom)) {
  860.           features &= ~FE_PLAYSPEECH;
  861.     }
  862. */
  863.     speech_memory_init();
  864.     speech_initLPC();
  865.     tms5200reset();
  866.     return 1;
  867. }
  868.  
  869. int
  870. speech_restart(void)
  871. {
  872.     return 1;
  873. }
  874.  
  875. void
  876. speech_restop(void)
  877. {
  878. }
  879.  
  880. void
  881. speech_shutdown(void)
  882. {
  883.     xfree(speech_data);
  884. }
  885.  
  886. /*
  887.  *    The least possible work we can do to enable
  888.  *    saving and loading speech -- hardcoded binary data!
  889.  */
  890. DECL_SYMBOL_ACTION(speech_machine_state)
  891. {
  892.     char *str;
  893.     if (task == csa_READ) {
  894.         char tmp[2*(sizeof(sp)+sizeof(lpc))+1];
  895.         if (iter)
  896.             return 0;
  897.         emulate_bin2hex((u8 *)&sp, tmp, sizeof(sp));
  898.         command_arg_set_string(SYM_ARG_1st, tmp);
  899.         emulate_bin2hex((u8 *)&lpc, tmp, sizeof(lpc));
  900.         command_arg_set_string(SYM_ARG_2nd, tmp);
  901.         return 1;
  902.  
  903.     }
  904.  
  905.     if (command_arg_get_string(SYM_ARG_1st, &str))
  906.         emulate_hex2bin(str, (u8 *)&sp, sizeof(sp));
  907.  
  908.     if (command_arg_get_string(SYM_ARG_2nd, &str))
  909.         emulate_hex2bin(str, (u8 *)&lpc, sizeof(lpc));
  910.  
  911.     // we have to restart speech if necessary,
  912.     // since it's nearly impossible to reset the speech
  913.     // synthesizer if it was in direct mode without
  914.     // setting the timeout function.
  915.     in_speech_intr = 0;
  916.     if (sp.timeout && (sp.gate & GT_WDAT)) {
  917.         SpeechOn();
  918.     } else {
  919.         sp.timeout = 0;
  920.     }
  921.     return 1;
  922. }
  923.  
  924. /*************************************/
  925.