home *** CD-ROM | disk | FTP | other *** search
/ Audio Version 4.94 / audioversion4.94knowledgemediaresourcelibraryoctober1994.iso / amiga / speech / typndtll / typndtll.c < prev   
C/C++ Source or Header  |  1991-08-16  |  20KB  |  626 lines
  1. /* TYPE and TELL 
  2.  
  3.    By: Giorgio Galeotti
  4.  
  5.    Anakin Research Inc. 
  6.    Rexdale, Ontatio, Canada.
  7.    Tel. 416-744-4246
  8.  
  9.    This program will install an input device handler before the Intuition
  10.    one, tap all keys typed by the user and spell them out in real time.
  11.  
  12.    Just run this program as a background task. To quit the program press
  13.    "CONTROL LEFT-SHIFT LEFT-ALT RIGHT-AMIGA" at the same time.
  14.  
  15.    This was the result of a couple of days work and it could be improved
  16.    by finding better sounding voices and translations for some of the 
  17.    keys. 
  18.  
  19.    You are free to modify or use this program in any way you want, as long
  20.    as this notice is left here and as long as you do not use the program
  21.    for any commercial purposes. As a matter of fact, you are encouraged to
  22.    improve TYPE & TELL since it could be of some benefit to blind
  23.    Amiga users.
  24.  
  25.    Finally, I and Anakin Research are not responsible for any losses or
  26.    damages caused by this program. After all, it has hardly been tested
  27.    and therefore you should use it at your own risk.
  28.  
  29.    P.S. Writen for Lattice 'C'.
  30. */   
  31.  
  32. #include <exec/types.h>
  33. #include <exec/tasks.h>
  34. #include <exec/nodes.h>
  35. #include <exec/lists.h>
  36. #include <exec/execbase.h>
  37. #include <exec/ports.h>
  38. #include <exec/memory.h>
  39. #include <exec/io.h>
  40. #include <exec/interrupts.h>
  41. #include <exec/devices.h>
  42. #include <exec/libraries.h>
  43. #include <devices/input.h>
  44. #include <devices/inputevent.h>
  45. #include <devices/narrator.h>
  46.  
  47. #include <libraries/translator.h>
  48.  
  49. #include <stdio.h>
  50.  
  51. #include <libraries/dos.h>
  52.  
  53.  
  54. #define INTUITION_REV   0
  55.  
  56. #define INPUT_RING_SIZE 50      /* Size of Input Event ring buffer         */
  57.  
  58. #define QUIT_CODE_1     0x8099  /* Control-shift-alt-alt's event qualifier */
  59. #define QUIT_CODE_2     0x809d  /* As above but with Caps-Lock light on    */
  60.  
  61.  
  62. /*  Globals */
  63.  
  64. struct MsgPort    *InputDevPort      = 0;
  65. struct IOStdReq   *InputRequestBlock = 0;
  66. struct Interrupt  handlerStuff;
  67.  
  68. int               InputDeviceOpen = 0; /* Just to keep track of things       */
  69.  
  70. struct MemEntry   me[10];          /* Dummy data used to keep the handler    */
  71.                                    /* happy                                  */
  72.  
  73. struct InputEvent EventRing[INPUT_RING_SIZE]; /* Raw key events buffer       */
  74. int               Filler  = 0;          /* Pointer into the EventRing Buffer */
  75. int               Emptier = 0;          /*     "            "           "    */
  76. int               Counter = 0;          /* # of entries now in buffer        */
  77.  
  78. ULONG             lastsecond = 0;       /* See myhandler() routine           */
  79. ULONG             lastmicro  = 0;
  80.  
  81. int               MainSignal;         /* Used by handler to wakeup main task */
  82. int               Waiting = 0;        /* Set by main before going to sleep   */
  83. struct Task       *MainTask;
  84.  
  85. extern struct GfxBase *GfxBase;
  86. struct Library *TranslatorBase = 0;
  87. struct Device *ConsoleDevice = 0;
  88. struct narrator_rb *WriteNarrator = 0;
  89.  
  90. extern VOID HandlerInterface();
  91.  
  92. int NarratorDeviceOpen = 0;           /* To keep track of things */
  93.  
  94. struct MsgPort *WritePort = 0;        /* Output Port for Narrator device */
  95.  
  96. UBYTE AudioChannels[4] = {3, 5, 10, 12}; /* Audio channels to recieve output */
  97.  
  98. UBYTE OutputString[100];              /* Translated output string */
  99.  
  100. /******************************************************************************/
  101.  
  102. main()
  103.  
  104. /* The initialization of all resources and a bit more. */
  105.  
  106. { 
  107.  /* For cleanup purposes */
  108.  GfxBase = 0;
  109.  
  110.  /* Open the console device. This will return the InputRequestBlock
  111.     whose field io_Device is initialized to the library pointer.
  112.     See page B-54 in the RKM V2 */
  113.  if ( OpenDevice("console.device",-1,InputRequestBlock,0) != 0 )
  114.     exit(100);
  115.     
  116.  ConsoleDevice = InputRequestBlock->io_Device;
  117.  CloseDevice(InputRequestBlock);
  118.  InputRequestBlock = 0; /* For clean up purposes */
  119.  
  120.  /* Open the Gfx library, since it's needed to do the WaitTOF()'s in the
  121.     input handler */
  122.  if ( (GfxBase = (struct GfxBase *)
  123.                  OpenLibrary("graphics.library",INTUITION_REV)) == 0 )
  124.     CleanUp_Exit(110);
  125.  
  126.  /* Get a signal bit so that our input handler can wake us up when there is 
  127.     something in the buffer */
  128.  MainSignal = AllocSignal(-1);
  129.  MainTask   = (struct Task *)FindTask(0);
  130.  
  131.  /* Get a port for the input device ... */
  132.  InputDevPort = (struct MsgPort *)CreatePort(0,0);
  133.  if ( InputDevPort == NULL )
  134.     CleanUp_Exit(120);
  135.  
  136.  /* ... and an InputRequestBlock */
  137.  InputRequestBlock = (struct IOStdReq *)CreateStdIO(InputDevPort);
  138.  if ( InputRequestBlock == 0 )
  139.     CleanUp_Exit(130);
  140.  
  141.  /* Open the input device */
  142.  if ( OpenDevice("input.device",0,InputRequestBlock,0) == 0 )
  143.     InputDeviceOpen = 1;
  144.  else CleanUp_Exit(140);
  145.  
  146.  /* Get ready to install our own device handler ... */
  147.  handlerStuff.is_Data = (APTR)&me[0];
  148.  handlerStuff.is_Code = HandlerInterface;
  149.  handlerStuff.is_Node.ln_Pri = 51;
  150.  
  151.  InputRequestBlock->io_Command = IND_ADDHANDLER;
  152.  InputRequestBlock->io_Data    = (APTR)&handlerStuff;
  153.  
  154.  /* ... and install the handler */
  155.  DoIO(InputRequestBlock);
  156.  
  157.  /* Open the translator library */
  158.  if ( (TranslatorBase = (struct Library *)
  159.                         OpenLibrary("translator.library",0)) == NULL )
  160.     CleanUp_Exit(500);
  161.  
  162.  /* Open the Narrator device for writes */
  163.  if ( (WritePort = (struct MsgPort *)CreatePort(0,0)) == NULL )
  164.     CleanUp_Exit(510);
  165.  
  166.  WriteNarrator = (struct narrator_rb *)
  167.                  CreateExtIO(WritePort,sizeof(struct narrator_rb));
  168.  if ( WriteNarrator == NULL )
  169.     CleanUp_Exit(520);
  170.  
  171.  if ( OpenDevice("narrator.device",0,WriteNarrator,0) == 0 )
  172.     NarratorDeviceOpen = 1;
  173.  else CleanUp_Exit(140);
  174.  
  175.  /* Set up part of the narrator's WritePort */
  176.  WriteNarrator->ch_masks           = (AudioChannels);
  177.  WriteNarrator->nm_masks           = sizeof(AudioChannels);
  178.  WriteNarrator->message.io_Command = CMD_WRITE;
  179.  
  180.  /* Call the main control routine and sit there until the user requests to 
  181.     quit. */
  182.  TheBigLoop();
  183. }
  184.  
  185. /****************************************************************************/
  186.  
  187. TheBigLoop()
  188.  
  189. /* This routine contains the loop that keeps checking everything the user does 
  190.    at the keyboard so that appropiate actions can be taken. */
  191.  
  192. { BYTE  buffer[30]; /* Buffer used by RawKeyConvert() to put results in. */
  193.   int   actual;     /* # of bytes returned by RawKeyConvert().          */
  194.   UWORD Qualifier;
  195.  
  196.  while ( 1 )
  197.        {
  198.         /* Anything in the buffer ? */
  199.         if ( Counter == 0 )
  200.            {
  201.             /* No ... Go to sleep, waiting for the input handler to wake
  202.                us up */
  203.             Waiting = 1;
  204.             Wait(1<<MainSignal);
  205.            }
  206.  
  207.         Qualifier = EventRing[Emptier].ie_Qualifier;
  208.  
  209.         /* User requested to quit Type&Tell ? */
  210.         if ( Qualifier == QUIT_CODE_1 || Qualifier == QUIT_CODE_2 )
  211.            CleanUp_Exit(1000);
  212.  
  213.         /* Convert raw-key event to ANSI standard. Assume default keymap. */
  214.         actual = RawKeyConvert(&EventRing[Emptier],buffer,30,0);
  215.  
  216.         if ( actual == 1 )
  217.            SpeakASCII(buffer,actual);
  218.  
  219.         else SpeakQualifier(&EventRing[Emptier]);
  220.  
  221.         /* Buffer wrap ? */
  222.         if ( Emptier == INPUT_RING_SIZE-1 )
  223.            Emptier = 0;
  224.         else ++Emptier;
  225.  
  226.         /* One less event in the buffer ... */
  227.         --Counter;
  228.        }
  229. }
  230.  
  231. /****************************************************************************/
  232.  
  233. SpeakASCII(buffer,actual)
  234.  
  235. /* Speak the ASCII character contained in buffer and whose lenght is in 
  236.    actual. */
  237.  
  238. char    *buffer;
  239. int     actual;
  240.  
  241. { 
  242.  if ( actual == 1 )
  243.     if ( (buffer[0] >= 'A' && buffer[0] <= 'Z') ||
  244.          (buffer[0] >= '0' && buffer[0] <= '9') )
  245.        {
  246.         WriteNarrator->rate     = DEFRATE+100;
  247.         WriteNarrator->pitch    = DEFPITCH;
  248.         WriteNarrator->mode     = NATURALF0;
  249.         WriteNarrator->sex      = DEFSEX;
  250.         WriteNarrator->volume   = DEFVOL;
  251.         WriteNarrator->sampfreq = DEFFREQ;
  252.  
  253.         /* Translate the character */
  254.         Translate(buffer,1,OutputString,100);
  255.  
  256.         WriteNarrator->message.io_Data = (APTR)OutputString;
  257.         WriteNarrator->message.io_Length = strlen(OutputString);
  258.  
  259.         /* And speak it */
  260.         DoIO(WriteNarrator);
  261.     
  262.         return;
  263.        }
  264.  
  265.     else if ( buffer[0] >= 'a' && buffer[0] <= 'z' )
  266.             {
  267.              WriteNarrator->rate     = DEFRATE+100;
  268.              WriteNarrator->pitch    = DEFPITCH+50;
  269.              WriteNarrator->mode     = NATURALF0;
  270.              WriteNarrator->sex      = FEMALE;
  271.              WriteNarrator->volume   = DEFVOL;
  272.              WriteNarrator->sampfreq = DEFFREQ;
  273.  
  274.              /* Translate the character */
  275.              Translate(buffer,1,OutputString,100);
  276.  
  277.              WriteNarrator->message.io_Data = (APTR)OutputString;
  278.              WriteNarrator->message.io_Length = strlen(OutputString);
  279.  
  280.              /* And speak it */
  281.              DoIO(WriteNarrator);
  282.     
  283.              return;
  284.             }
  285.     
  286.          else {
  287.                WriteNarrator->rate     = DEFRATE+100;
  288.                WriteNarrator->pitch    = DEFPITCH;
  289.                WriteNarrator->mode     = NATURALF0;
  290.                WriteNarrator->sex      = DEFSEX;
  291.                WriteNarrator->volume   = DEFVOL;
  292.                WriteNarrator->sampfreq = DEFFREQ;
  293.  
  294.                /* See if it is a control character */
  295.                if ( buffer[0] >= 0x01 && buffer[0] <= 0x1a )
  296.                   {
  297.                    buffer[8] = buffer[0] + 0x40;
  298.                    strcpy(buffer,"CONTROL");
  299.                    buffer[7] = ' ';
  300.                    Translate(buffer,9,OutputString,100);
  301.                   }
  302.  
  303.                else switch ( buffer[0] )
  304.                     {
  305.                      case 0x1b:Translate("ESCAPE",6,OutputString,100);
  306.                                break;
  307.  
  308.                      case ' ': Translate("SPACE",5,OutputString,100);
  309.                                break;
  310.  
  311.                      case '!': Translate("EXCLAMATION",11,OutputString,100);
  312.                                break;
  313.  
  314.                      case '"': Translate("DOUBLE QUOTE",12,OutputString,100);
  315.                                break;
  316.  
  317.                      case '#': Translate("SHARP",5,OutputString,100);
  318.                                break;
  319.  
  320.                      case '$': Translate("DOLLAR",6,OutputString,100);
  321.                                break;
  322.  
  323.                      case '%': Translate("PERCENT",7,OutputString,100);
  324.                                break;
  325.  
  326.                      case '&': Translate("AND",3,OutputString,100);
  327.                                break;
  328.  
  329.                      case '\'':Translate("RIGHT QUOTE",11,OutputString,100);
  330.                                break;
  331.  
  332.                      case '(': Translate("LEFT PARENTHESIS",16,OutputString,100);
  333.                                break;
  334.  
  335.                      case ')': Translate("RIGHT PARENTHESIS",17,OutputString,100);
  336.                                break;
  337.  
  338.                      case '*': Translate("STAR",4,OutputString,100);
  339.                                break;
  340.  
  341.                      case '+': Translate("PLUS",4,OutputString,100);
  342.                                break;
  343.  
  344.                      case ',': Translate("COMMA",5,OutputString,100);
  345.                                break;
  346.  
  347.                      case '-': Translate("MYNUS",5,OutputString,100);
  348.                                break;
  349.  
  350.                      case '.': Translate("DOT",3,OutputString,100);
  351.                                break;
  352.  
  353.                      case '/': Translate("SLASH",5,OutputString,100);
  354.                                break;
  355.  
  356.                      case ':': Translate("COLON",5,OutputString,100);
  357.                                break;
  358.  
  359.                      case ';': Translate("SEMI COLON",10,OutputString,100);
  360.                                break;
  361.  
  362.                      case '<': Translate("LESS THAN",9,OutputString,100);
  363.                                break;
  364.  
  365.                      case '>': Translate("GREATER THAN",12,OutputString,100);
  366.                                break;
  367.  
  368.                      case '=': Translate("EQUAL",5,OutputString,100);
  369.                                break;
  370.  
  371.                      case '?': Translate("QUESTION",8,OutputString,100);
  372.                                break;
  373.  
  374.                      case '@': Translate("AT",2,OutputString,100);
  375.                                break;
  376.  
  377.                      case '[': Translate("LEFT BRACKET",12,OutputString,100);
  378.                                break;
  379.  
  380.                      case '\\':Translate("BACKSLASH",9,OutputString,100);
  381.                                break;
  382.  
  383.                      case ']': Translate("RIGHT BRACKET",13,OutputString,100);
  384.                                break;
  385.  
  386.                      case '^': Translate("CARROT",6,OutputString,100);
  387.                                break;
  388.  
  389.                      case '_': Translate("UNDER SCORE",11,OutputString,100);
  390.                                break;
  391.  
  392.                      case '`': Translate("LEFT QUOTE",10,OutputString,100);
  393.                                break;
  394.  
  395.                      case '{': Translate("LEFT BRACE",10,OutputString,100);
  396.                                break;
  397.  
  398.                      case '|': Translate("VERTICAL BAR",12,OutputString,100);
  399.                                break;
  400.  
  401.                      case '}': Translate("RIGHT BRACE",11,OutputString,100);
  402.                                break;
  403.  
  404.                      case '~': Translate("TILDA",5,OutputString,100);
  405.                                break;
  406.  
  407.                      case 0x7f:Translate("DELETE",6,OutputString,100);
  408.                                break;
  409.  
  410.                      default: return;
  411.                     }
  412.    
  413.                WriteNarrator->message.io_Data = (APTR)OutputString;
  414.                WriteNarrator->message.io_Length = strlen(OutputString);
  415.                /* And speak it */
  416.                DoIO(WriteNarrator);
  417.      
  418.                return;
  419.               }
  420. }     
  421.  
  422. /****************************************************************************/
  423.  
  424. SpeakQualifier(Event)
  425.  
  426. /* The keystroke did not translate to any ASCII character, but nevertheless
  427.    it must be called out */
  428.  
  429. struct InputEvent *Event;
  430.  
  431. {
  432.  WriteNarrator->rate     = DEFRATE+100;
  433.  WriteNarrator->pitch    = DEFPITCH+100;
  434.  WriteNarrator->mode     = NATURALF0;
  435.  WriteNarrator->sex      = FEMALE;
  436.  WriteNarrator->volume   = DEFVOL;
  437.  WriteNarrator->sampfreq = DEFFREQ;
  438.  
  439.  switch ( Event->ie_Code )
  440.         {
  441.          case 0x50: Translate("FUNCTION 1",10,OutputString,100);
  442.                     break;
  443.  
  444.          case 0x51: Translate("FUNCTION 2",10,OutputString,100);
  445.                     break;
  446.  
  447.          case 0x52: Translate("FUNCTION 3",10,OutputString,100);
  448.                     break;
  449.  
  450.          case 0x53: Translate("FUNCTION 4",10,OutputString,100);
  451.                     break;
  452.  
  453.          case 0x54: Translate("FUNCTION 5",10,OutputString,100);
  454.                     break;
  455.  
  456.          case 0x55: Translate("FUNCTION 6",10,OutputString,100);
  457.                     break;
  458.  
  459.          case 0x56: Translate("FUNCTION 7",10,OutputString,100);
  460.                     break;
  461.  
  462.          case 0x57: Translate("FUNCTION 8",10,OutputString,100);
  463.                     break;
  464.  
  465.          case 0x58: Translate("FUNCTION 9",10,OutputString,100);
  466.                     break;
  467.  
  468.          case 0x59: Translate("FUNCTION TEN",12,OutputString,100);
  469.                     break;
  470.  
  471.          case 0x63: Translate("CONTROL",7,OutputString,100);
  472.                     break;
  473.  
  474.          case 0x60:
  475.          case 0x61: Translate("SHIFT",5,OutputString,100);
  476.                     break;
  477.  
  478.          case 0x64:
  479.          case 0x65: Translate("ALTERNATE",9,OutputString,100);
  480.                     break;
  481.  
  482.          case 0x66: Translate("LEFT AMIGA",10,OutputString,100);
  483.                     break;
  484.  
  485.          case 0x67: Translate("RIGHT AMIGA",11,OutputString,100);
  486.                     break;
  487.  
  488.          case 0x5f: Translate("HELP",4,OutputString,100);
  489.                     break;
  490.  
  491.          case 0x4c: Translate("GO UP",5,OutputString,100);
  492.                     break;
  493.  
  494.          case 0x4f: Translate("GO LEFT",7,OutputString,100);
  495.                     break;
  496.  
  497.          case 0x4e: Translate("GO RIGHT",8,OutputString,100);
  498.                     break;
  499.  
  500.          case 0x4d: Translate("GO DOWN",7,OutputString,100);
  501.                     break;
  502.  
  503.          case 0x62: Translate("CAPS LOCK ON",12,OutputString,100);
  504.                     break;
  505.  
  506.          case 0xe2: Translate("CAPS LOCK OFF",13,OutputString,100);
  507.                     break;
  508.  
  509.          default: return;
  510.         }
  511.    
  512.  WriteNarrator->message.io_Data = (APTR)OutputString;
  513.  WriteNarrator->message.io_Length = strlen(OutputString);
  514.  /* And speak it */
  515.  DoIO(WriteNarrator);
  516. }
  517.  
  518. /****************************************************************************/
  519.  
  520. CleanUp_Exit(exitlevel)
  521.  
  522. /* Clean up all allocated resources and exit */
  523.  
  524. int exitlevel;
  525.  
  526. {
  527.  /* Remove our input handler and device from the chain */ 
  528.  if ( InputRequestBlock )
  529.     {
  530.      InputRequestBlock->io_Command = IND_REMHANDLER;
  531.      InputRequestBlock->io_Data    = (APTR)&handlerStuff;
  532.      DoIO(InputRequestBlock);
  533.      
  534.      if ( InputDeviceOpen )
  535.         CloseDevice(InputRequestBlock);
  536.  
  537.      DeleteStdIO(InputRequestBlock);
  538.     }
  539.  
  540.  if ( InputDevPort )
  541.     DeletePort(InputDevPort);
  542.  
  543.  if ( NarratorDeviceOpen )
  544.     CloseDevice(WriteNarrator);
  545.  
  546.  if ( WriteNarrator )
  547.     DeleteExtIO(WriteNarrator,sizeof(struct narrator_rb));
  548.  
  549.  if ( TranslatorBase )
  550.     CloseLibrary(TranslatorBase);
  551.  
  552.  if ( WritePort )
  553.     DeletePort(WritePort);
  554.  
  555.  if ( GfxBase )
  556.     CloseLibrary(GfxBase);
  557.  
  558.  exit(exitlevel);
  559. }
  560.  
  561. /****************************************************************************/
  562.  
  563. struct InputEvent *myhandler(ev,mydata)
  564.  
  565. /* This input handler inserts itself at a higher priority than the intuition
  566.    handler. It will intercept all raw-key events and put them into the ring-
  567.    buffer so that other tasks in this program can use the data to keep track 
  568.    of what keys have been pressed by the user ... */
  569.  
  570. struct InputEvent *ev;
  571. struct MemEntry   *mydata[];
  572.  
  573. { register struct InputEvent *NextEvent;
  574.  
  575. /*  look at all events in the event-list (or whatever it's called) and
  576.     put in the buffer all raw-key events whose time stamp indicates
  577.     we haven't looked at them before. Hopefully the system links new events
  578.     at the end of the chain, so that all time stamps are in order. */
  579.  
  580.  NextEvent = ev;   /* First entry in event-list */
  581.  do {
  582.      if ( NextEvent->ie_Class == IECLASS_RAWKEY )
  583.         if ( ( NextEvent->ie_TimeStamp.tv_micro > lastmicro &&
  584.                NextEvent->ie_TimeStamp.tv_secs >= lastsecond ) ||
  585.                NextEvent->ie_TimeStamp.tv_secs >  lastsecond )
  586.            {
  587.             lastmicro  = NextEvent->ie_TimeStamp.tv_micro;
  588.             lastsecond = NextEvent->ie_TimeStamp.tv_secs;
  589.  
  590.             /* Get our own copy of the event */
  591.             movmem(NextEvent,&EventRing[Filler],sizeof(struct InputEvent));
  592.  
  593.             ++Counter;    /* One more item in the buffer */
  594.  
  595.             /* Buffer Wrap ? */
  596.             if ( Filler == INPUT_RING_SIZE-1 )
  597.                Filler = 0;
  598.             else ++Filler;
  599.  
  600.             /* Is the user of the buffer waiting ? */
  601.             if ( Waiting )
  602.                {
  603.                 Signal(MainTask,1<<MainSignal);
  604.                 Waiting = 0;
  605.                }
  606.  
  607.             /* The buffer may fill in final program. In case that
  608.                it happens, do some waits to give the other tasks the time 
  609.                to empty the buffer a bit. A completely busy loop would tie up
  610.                the system forever. */
  611.             while ( Counter >= INPUT_RING_SIZE - 2 )
  612.                   {
  613.                    WaitTOF();
  614.                    WaitTOF();
  615.                    WaitTOF();
  616.                   } 
  617.            }
  618.  
  619.      NextEvent = NextEvent->ie_NextEvent;
  620.     }
  621.     while ( NextEvent );    /* Done ? */
  622.  
  623.  return ( ev );
  624. }
  625.  
  626.