kttsd/kttsd/speechdata.h

   1 /*************************************************** vim:set ts=4 sw=4 sts=4:
   2   This contains the SpeechData class which is in charge of maintaining
   3   all the data on the memory.
   4   It maintains queues manages the text.
   5   We could say that this is the common repository between the KTTSD class
   6   (dcop service) and the Speaker class (speaker, loads plug ins, call plug in
   7   functions)
   8   -------------------
   9   Copyright:
  10   (C) 2002-2003 by José Pablo Ezequiel "Pupeno" Fernández <pupeno@kde.org>
  11   (C) 2003-2004 by Olaf Schmidt <ojschmidt@kde.org>
  12   (C) 2004-2005 by Gary Cramblitt <garycramblitt@comcast.net>
  13   -------------------
  14   Original author: José Pablo Ezequiel "Pupeno" Fernández
  15  ******************************************************************************/
  16
  17 /******************************************************************************
  18  *                                                                            *
  19  *    This program is free software; you can redistribute it and/or modify    *
  20  *    it under the terms of the GNU General Public License as published by    *
  21  *    the Free Software Foundation; either version 2 of the License.          *
  22  *                                                                            *
  23  ******************************************************************************/
  24
  25 #ifndef _SPEECHDATA_H_
  26 #define _SPEECHDATA_H_
  27
  28 // Qt includes.
  29 #include <QQueue>
  30 #include <QList>
  31 #include <QByteArray>
  32 #include <QHash>
  33 #include <QString>
  34 #include <QStringList>
  35 #include <QMap>
  36
  37 // KDE includes.
  38 #include <kconfig.h>
  39
  40 // KTTS includes.
  41 #include <kspeech.h>
  42 #include <talkercode.h>
  43 #include <filtermgr.h>
  44
  45 class TalkerMgr;
  46
  47 /**
  48 * Struct containing a text cell, for messages, warnings, and texts.
  49 * Contains the text itself, the associated talker,
  50 * the ID of the application that requested it be spoken, and a sequence number.
  51 */
  52 struct mlText{
  53     QString talker;              /* Requested Talker code for the sentence. */
  54     QString text;                /* Text of sentence. */
  55     QByteArray appId;             /* DCOP senderId of the application that requested the speech. */
  56     uint jobNum;                 /* Text jobNum.  Only applies to text messages; not warning and messages. */
  57     uint seq;                    /* Sequence number. */
  58 };
  59
  60 /**
  61  * Struct containing a text job.
  62  */
  63 struct mlJob {
  64     uint jobNum;                 /* Job number. */
  65     KSpeech::kttsdJobState state; /* Job state. */
  66     QByteArray appId;             /* DCOP senderId of the application that requested the speech job. */
  67     QString talker;              /* Requested Talker code in which to speak the text. */
  68     int seq;                     /* Current sentence being spoken. */
  69     QList<int> partSeqNums;      /* List containing last sequence number for each part of a job. */
  70     QStringList sentences;       /* List of sentences in the job. */
  71 };
  72
  73 /**
  74  * Struct used to keep a pool of FilterMgr objects.
  75  */
  76 struct PooledFilterMgr {
  77     FilterMgr* filterMgr;       /* The FilterMgr object. */
  78     bool busy;                  /* True if the FilterMgr is busy. */
  79     mlJob* job;                 /* The job the FilterMgr is filtering. */
  80     TalkerCode* talkerCode;     /* TalkerCode object passed to FilterMgr. */
  81 };
  82
  83 /**
  84  * Struct used to keep notification options.
  85  */
  86 struct NotifyOptions {
  87     QString eventName;
  88     int action;
  89     QString talker;
  90     QString customMsg;
  91 };
  92
  93 /**
  94  * A list of notification options for a single app, indexed by event.
  95  */
  96 typedef QMap<QString, NotifyOptions> NotifyEventMap;
  97
  98 /**
  99  * A list of notification event maps for all apps, indexed by app.
 100  */
 101 typedef QMap<QString, NotifyEventMap> NotifyAppMap;
 102
 103 /**
 104  * SpeechData class which is in charge of maintaining all the data on the memory.
 105  * It maintains queues and has methods to enque
 106  * messages and warnings and manage the text queues.
 107  * We could say that this is the common repository between the KTTSD class
 108  * (dcop service) and the Speaker class (speaker, loads plug ins, call plug in
 109  * functions)
 110  */
 111 class SpeechData : public QObject {
 112     Q_OBJECT
 113
 114     public:
 115         /**
 116         * Constructor
 117         * Sets text to be stopped and warnings and messages queues to be autodelete (thread safe)
 118         */
 119         SpeechData();
 120
 121         /**
 122         * Destructor
 123         */
 124         ~SpeechData();
 125
 126         /**
 127         * Read the configuration
 128         */
 129         bool readConfig();
 130
 131         /**
 132         * Say a message as soon as possible, interrupting any other speech in progress.
 133         * IMPORTANT: This method is reserved for use by Screen Readers and should not be used
 134         * by any other applications.
 135         * @param msg            The message to be spoken.
 136         * @param talker         Code for the talker to speak the message.  Example "en".
 137         *                       If NULL, defaults to the user's default talker.
 138         *                       If no plugin has been configured for the specified Talker code,
 139         *                       defaults to the closest matching talker.
 140         * @param appId          The DCOP senderId of the application.
 141         *
 142         * If an existing Screen Reader output is in progress, it is stopped and discarded and
 143         * replaced with this new message.
 144         */
 145         void setScreenReaderOutput(const QString &msg, const QString &talker,
 146             const QByteArray& appId);
 147
 148         /**
 149         * Given an appId, returns the last (most recently queued) Job Number with that appId,
 150         * or if no such job, the Job Number of the last (most recent) job in the queue.
 151         * @param appId          The DCOP senderId of the application.
 152         * @return               Job Number of the text job.
 153         * If no such job, returns 0.
 154         * If appId is NULL, returns the Job Number of the last job in the queue.
 155         * Does not change textJobs.current().
 156         */
 157         uint findAJobNumByAppId(const QByteArray& appId);
 158
 159         /**
 160         * Retrieves the Screen Reader Output.
 161         */
 162         mlText* getScreenReaderOutput();
 163
 164         /**
 165         * Returns true if Screen Reader Output is ready to be spoken.
 166         */
 167         bool screenReaderOutputReady();
 168
 169        /**
 170         * Add a new warning to the queue.
 171         */
 172         void enqueueWarning( const QString &, const QString &talker,
 173             const QByteArray& appId);
 174
 175         /**
 176         * Pop (get and erase) a warning from the queue.
 177         * @return                Pointer to mlText structure containing the warning.
 178         *
 179         * Caller is responsible for deleting the structure.
 180         */
 181         mlText* dequeueWarning();
 182
 183         /**
 184         * Are there any Warnings?
 185         */
 186         bool warningInQueue();
 187
 188         /**
 189         * Add a new message to the queue.
 190         */
 191         void enqueueMessage( const QString &, const QString &talker,
 192             const QByteArray&);
 193
 194         /**
 195         * Pop (get and erase) a message from the queue.
 196         * @return                Pointer to mlText structure containing the message.
 197         *
 198         * Caller is responsible for deleting the structure.
 199         */
 200         mlText* dequeueMessage();
 201
 202         /**
 203         * Are there any Messages?
 204         */
 205         bool messageInQueue();
 206
 207         /**
 208         * Sets the GREP pattern that will be used as the sentence delimiter.
 209         * @param delimiter      A valid GREP pattern.
 210         * @param appId          The DCOP senderId of the application.
 211         *
 212         * The default delimiter is
 213           @verbatim
 214              ([\\.\\?\\!\\:\\;])\\s
 215           @endverbatim
 216         *
 217         * Note that backward slashes must be escaped.
 218         *
 219         * Changing the sentence delimiter does not affect other applications.
 220         * @see sentenceparsing
 221         */
 222         void setSentenceDelimiter(const QString &delimiter, const QByteArray appId);
 223
 224         /* The following methods correspond to the methods in KSpeech interface. */
 225
 226         /**
 227         * Queue a text job.  Does not start speaking the text.
 228         * (thread safe)
 229         * @param text           The message to be spoken.
 230         * @param talker         Code for the talker to speak the text.  Example "en".
 231         *                       If NULL, defaults to the user's default talker.
 232         *                       If no plugin has been configured for the specified Talker code,
 233         *                       defaults to the closest matching talker.
 234         * @param appId          The DCOP senderId of the application.
 235         * @return               Job number.
 236         *
 237         * The text is parsed into individual sentences.  Call getTextCount to retrieve
 238         * the sentence count.  Call startText to mark the job as speakable and if the
 239         * job is the first speakable job in the queue, speaking will begin.
 240         * @see startText.
 241         */
 242         uint setText(const QString &text, const QString &talker, const QByteArray& appId);
 243
 244         /**
 245         * Adds another part to a text job.  Does not start speaking the text.
 246         * (thread safe)
 247         * @param jobNum         Job number of the text job.
 248         * @param text           The message to be spoken.
 249         * @param appId          The DCOP senderId of the application.
 250         * @return               Part number for the added part.  Parts are numbered starting at 1.
 251         *
 252         * The text is parsed into individual sentences.  Call getTextCount to retrieve
 253         * the sentence count.  Call startText to mark the job as speakable and if the
 254         * job is the first speakable job in the queue, speaking will begin.
 255         * @see setText.
 256         * @see startText.
 257         */
 258         int appendText(const QString &text, const uint jobNum, const QByteArray& appId);
 259
 260         /**
 261         * Get the number of sentences in a text job.
 262         * (thread safe)
 263         * @param jobNum         Job number of the text job.
 264         * @return               The number of sentences in the job.  -1 if no such job.
 265         *
 266         * The sentences of a job are given sequence numbers from 1 to the number returned by this
 267         * method.  The sequence numbers are emitted in the sentenceStarted and sentenceFinished signals.
 268         */
 269         int getTextCount(const uint jobNum);
 270
 271         /**
 272         * Get the number of jobs in the text job queue.
 273         * (thread safe)
 274         * @return               Number of text jobs in the queue.  0 if none.
 275         */
 276         uint getTextJobCount();
 277
 278         /**
 279         * Get a comma-separated list of text job numbers in the queue.
 280         * @return               Comma-separated list of text job numbers in the queue.
 281         */
 282         QString getTextJobNumbers();
 283
 284         /**
 285         * Get the state of a text job.
 286         * (thread safe)
 287         * @param jobNum         Job number of the text job.
 288         * @return               State of the job. -1 if invalid job number.
 289         */
 290         int getTextJobState(const uint jobNum);
 291
 292         /**
 293         * Set the state of a text job.
 294         * @param jobNum         Job Number of the job.
 295         * @param state          New state for the job.
 296         *
 297         **/
 298         void setTextJobState(const uint jobNum, const KSpeech::kttsdJobState state);
 299
 300         /**
 301         * Get information about a text job.
 302         * @param jobNum         Job number of the text job.
 303         * @return               A QDataStream containing information about the job.
 304         *                       Blank if no such job.
 305         *
 306         * The stream contains the following elements:
 307         *   - int state         Job state.
 308         *   - QByteArray appId   DCOP senderId of the application that requested the speech job.
 309         *   - QString talker    Talker code as requested by application.
 310         *   - int seq           Current sentence being spoken.  Sentences are numbered starting at 1.
 311         *   - int sentenceCount Total number of sentences in the job.
 312         *   - int partNum       Current part of the job begin spoken.  Parts are numbered starting at 1.
 313         *   - int partCount     Total number of parts in the job.
 314         *
 315         * Note that sequence numbers apply to the entire job.
 316         * They do not start from 1 at the beginning of each part.
 317         *
 318         * The following sample code will decode the stream:
 319                 @verbatim
 320                     QByteArray jobInfo = getTextJobInfo(jobNum);
 321                     QDataStream stream(jobInfo, QIODevice::ReadOnly);
 322                     int state;
 323                     QByteArray appId;
 324                     QString talker;
 325                     int seq;
 326                     int sentenceCount;
 327                     int partNum;
 328                     int partCount;
 329                     stream >> state;
 330                     stream >> appId;
 331                     stream >> talker;
 332                     stream >> seq;
 333                     stream >> sentenceCount;
 334                     stream >> partNum;
 335                     stream >> partCount;
 336                 @endverbatim
 337         */
 338         QByteArray getTextJobInfo(const uint jobNum);
 339
 340         /**
 341         * Return a sentence of a job.
 342         * @param jobNum         Job number of the text job.
 343         * @param seq            Sequence number of the sentence.
 344         * @return               The specified sentence in the specified job.  If no such
 345         *                       job or sentence, returns "".
 346         */
 347         QString getTextJobSentence(const uint jobNum, const uint seq=1);
 348
 349         /**
 350         * Remove a text job from the queue.
 351         * (thread safe)
 352         * @param jobNum         Job number of the text job.
 353         *
 354         * The job is deleted from the queue and the textRemoved signal is emitted.
 355         */
 356         void removeText(const uint jobNum);
 357
 358         /**
 359         * Change the talker for a text job.
 360         * @param jobNum         Job number of the text job.
 361         * @param talker         New code for the talker to do speaking.  Example "en".
 362         *                       If NULL, defaults to the user's default talker.
 363         *                       If no plugin has been configured for the specified Talker code,
 364         *                       defaults to the closest matching talker.
 365         */
 366         void changeTextTalker(const QString &talker, uint jobNum);
 367
 368         /**
 369         * Move a text job down in the queue so that it is spoken later.
 370         * @param jobNum         Job number of the text job.
 371         */
 372         void moveTextLater(const uint jobNum);
 373
 374         /**
 375         * Jump to the first sentence of a specified part of a text job.
 376         * @param partNum        Part number of the part to jump to.  Parts are numbered starting at 1.
 377         * @param jobNum         Job number of the text job.
 378         * @return               Part number of the part actually jumped to.
 379         *
 380         * If partNum is greater than the number of parts in the job, jumps to last part.
 381         * If partNum is 0, does nothing and returns the current part number.
 382         * If no such job, does nothing and returns 0.
 383         * Does not affect the current speaking/not-speaking state of the job.
 384         */
 385         int jumpToTextPart(const int partNum, const uint jobNum);
 386
 387         /**
 388         * Advance or rewind N sentences in a text job.
 389         * @param n              Number of sentences to advance (positive) or rewind (negative)
 390         *                       in the job.
 391         * @param jobNum         Job number of the text job.
 392         * @return               Sequence number of the sentence actually moved to.  Sequence numbers
 393         *                       are numbered starting at 1.
 394         *
 395         * If no such job, does nothing and returns 0.
 396         * If n is zero, returns the current sequence number of the job.
 397         * Does not affect the current speaking/not-speaking state of the job.
 398         */
 399         uint moveRelTextSentence(const int n, const uint jobNum);
 400
 401         /**
 402         * Given a jobNum, returns the first job with that jobNum.
 403         * @return               Pointer to the text job.
 404         * If no such job, returns 0.
 405         * Does not change textJobs.current().
 406         */
 407         mlJob* findJobByJobNum(const uint jobNum);
 408
 409         /**
 410         * Given a Job Number, returns the next speakable text job on the queue.
 411         * @param prevJobNum       Current job number (which should not be returned).
 412         * @return                 Pointer to mlJob structure of the first speakable job
 413         *                         not equal prevJobNum.  If no such job, returns null.
 414         *
 415         * Caller must not delete the job.
 416         */
 417         mlJob* getNextSpeakableJob(const uint prevJobNum);
 418
 419         /**
 420         * Given previous job number and sequence number, returns the next sentence from the
 421         * text queue.  If no such sentence is available, either because we've run out of
 422         * jobs, or because all jobs are paused, returns null.
 423         * @param prevJobNum       Previous Job Number.
 424         * @param prevSeq          Previous sequency number.
 425         * @return                 Pointer to n mlText structure containing the next sentence.  If no
 426         *                         sentence, returns null.
 427         *
 428         * Caller is responsible for deleting the returned mlText structure (if not null).
 429         */
 430         mlText* getNextSentenceText(const uint prevJobNum, const uint prevSeq);
 431
 432         /**
 433         * Given a Job Number, sets the current sequence number of the job.
 434         * @param jobNum          Job Number.
 435         * @param seq             Sequence number.
 436         * If for some reason, the job does not exist, nothing happens.
 437         */
 438         void setJobSequenceNum(const uint jobNum, const uint seq);
 439
 440         /**
 441         * Given a Job Number, returns the current sequence number of the job.
 442         * @param jobNum         Job Number.
 443         * @return               Sequence number of the job.  If no such job, returns 0.
 444         */
 445         uint getJobSequenceNum(const uint jobNum);
 446
 447         /**
 448         * Given a jobNum, returns the appId of the application that owns the job.
 449         * @param jobNum         Job number of the text job.
 450         * @return               appId of the job.
 451         * If no such job, returns "".
 452         * Does not change textJobs.current().
 453         */
 454         QByteArray getAppIdByJobNum(const uint jobNum);
 455
 456         /**
 457         * Sets pointer to the TalkerMgr object.
 458         */
 459         void setTalkerMgr(TalkerMgr* talkerMgr);
 460
 461         /* The following properties come from the configuration. */
 462
 463         /**
 464         * Text pre message
 465         */
 466         QString textPreMsg;
 467
 468         /**
 469         * Text pre message enabled ?
 470         */
 471         bool textPreMsgEnabled;
 472
 473         /**
 474         * Text pre sound
 475         */
 476         QString textPreSnd;
 477
 478         /**
 479         * Text pre sound enabled ?
 480         */
 481         bool textPreSndEnabled;
 482
 483         /**
 484         * Text post message
 485         */
 486         QString textPostMsg;
 487
 488         /**
 489         * Text post message enabled ?
 490         */
 491         bool textPostMsgEnabled;
 492
 493         /**
 494         * Text post sound
 495         */
 496         QString textPostSnd;
 497
 498         /**
 499         * Text post sound enabled ?
 500         */
 501         bool textPostSndEnabled;
 502
 503         /**
 504         * Paragraph pre message
 505         */
 506         QString parPreMsg;
 507
 508         /**
 509         * Paragraph pre message enabled ?
 510         */
 511         bool parPreMsgEnabled;
 512
 513         /**
 514         * Paragraph pre sound
 515         */
 516         QString parPreSnd;
 517
 518         /**
 519         * Paragraph pre sound enabled ?
 520         */
 521         bool parPreSndEnabled;
 522
 523         /**
 524         * Paragraph post message
 525         */
 526         QString parPostMsg;
 527
 528         /**
 529         * Paragraph post message enabled ?
 530         */
 531         bool parPostMsgEnabled;
 532
 533         /**
 534         * Paragraph post sound
 535         */
 536         QString parPostSnd;
 537
 538         /**
 539         * Paragraph post sound enabled ?
 540         */
 541         bool parPostSndEnabled;
 542
 543         /**
 544         * Keep audio files.  Do not delete generated tmp wav files.
 545         */
 546         bool keepAudio;
 547         QString keepAudioPath;
 548
 549         /**
 550         * Notification settings.
 551         */
 552         bool notify;
 553         bool notifyExcludeEventsWithSound;
 554         NotifyAppMap notifyAppMap;
 555         int notifyDefaultPresent;
 556         NotifyOptions notifyDefaultOptions;
 557
 558         /**
 559         * Automatically start KTTSMgr whenever speaking.
 560         */
 561         bool autoStartManager;
 562
 563         /**
 564         * Automatically exit auto-started KTTSMgr when speaking finishes.
 565         */
 566         bool autoExitManager;
 567
 568         /**
 569         * Configuration
 570         */
 571         KConfig *config;
 572
 573         /**
 574         * True if at least one XML Transformer plugin for html is enabled.
 575         */
 576         bool supportsHTML;
 577
 578     signals:
 579         /**
 580         * This signal is emitted whenever a new text job is added to the queue.
 581         * @param appId          The DCOP senderId of the application that created the job.
 582         * @param jobNum         Job number of the text job.
 583         */
 584         void textSet(const QByteArray& appId, const uint jobNum);
 585
 586         /**
 587         * This signal is emitted whenever a new part is appended to a text job.
 588         * @param appId          The DCOP senderId of the application that created the job.
 589         * @param jobNum         Job number of the text job.
 590         * @param partNum        Part number of the new part.  Parts are numbered starting
 591         *                       at 1.
 592         */
 593         void textAppended(const QByteArray& appId, const uint jobNum, const int partNum);
 594
 595         /**
 596         * This signal is emitted whenever a text job is deleted from the queue.
 597         * The job is no longer in the queue when this signal is emitted.
 598         * @param appId          The DCOP senderId of the application that created the job.
 599         * @param jobNum         Job number of the text job.
 600         */
 601         void textRemoved(const QByteArray& appId, const uint jobNum);
 602
 603     private:
 604         /**
 605         * Screen Reader Output.
 606         */
 607         mlText screenReaderOutput;
 608
 609         /**
 610         * Queue of warnings
 611         */
 612         QQueue<mlJob*> warnings;
 613
 614         /**
 615         * Queue of messages
 616         */
 617         QQueue<mlJob*> messages;
 618
 619         /**
 620         * Queue of text jobs.
 621         */
 622         QList<mlJob*> textJobs;
 623
 624         /**
 625         * TalkerMgr object local pointer.
 626         */
 627         TalkerMgr* m_talkerMgr;
 628
 629         /**
 630         * Pool of FilterMgrs.
 631         */
 632         QHash<int, PooledFilterMgr*> m_pooledFilterMgrs;
 633
 634         /**
 635         * Job counter.  Each new job increments this counter.
 636         */
 637         uint jobCounter;
 638
 639         /**
 640         * Talker of the text
 641         */
 642         QString textTalker;
 643
 644         /**
 645         * Map of sentence delimiters.  One per app.  If none specified for an app, uses default.
 646         */
 647         QMap<QByteArray, QString> sentenceDelimiters;
 648
 649         /**
 650         * Determines whether the given text is SSML markup.
 651         */
 652         bool isSsml(const QString &text);
 653
 654         /**
 655         * Given an appId, returns the last (most recently queued) job with that appId.
 656         * @param appId          The DCOP senderId of the application.
 657         * @return               Pointer to the text job.
 658         * If no such job, returns 0.
 659         * If appId is NULL, returns the last job in the queue.
 660         * Does not change textJobs.current().
 661         */
 662         mlJob* findLastJobByAppId(const QByteArray& appId);
 663
 664         /**
 665         * Given an appId, returns the last (most recently queued) job with that appId,
 666         * or if no such job, the last (most recent) job in the queue.
 667         * @param appId          The DCOP senderId of the application.
 668         * @return               Pointer to the text job.
 669         * If no such job, returns 0.
 670         * If appId is NULL, returns the last job in the queue.
 671         * Does not change textJobs.current().
 672         */
 673         mlJob* SpeechData::findAJobByAppId(const QByteArray& appId);
 674
 675         /**
 676         * Given a job and a sequence number, returns the part that sentence is in.
 677         * If no such job or sequence number, returns 0.
 678         * @param job            The text job.
 679         * @param seq            Sequence number of the sentence.  Sequence numbers begin with 1.
 680         * @return               Part number of the part the sentence is in.  Parts are numbered
 681         *                       beginning with 1.  If no such job or sentence, returns 0.
 682         */
 683         int getJobPartNumFromSeq(const mlJob& job, const int seq);
 684
 685         /**
 686         * Parses a block of text into sentences using the application-specified regular expression
 687         * or (if not specified), the default regular expression.
 688         * @param text           The message to be spoken.
 689         * @param appId          The DCOP senderId of the application.
 690         * @return               List of parsed sentences.
 691         */
 692
 693         QStringList SpeechData::parseText(const QString &text, const QByteArray &appId);
 694
 695         /**
 696         * Delete expired jobs.  At most, one finished job is kept on the queue.
 697         * @param finishedJobNum Job number of a job that just finished
 698         * The just finished job is not deleted, but any other finished jobs are.
 699         * Does not change the textJobs.current() pointer.
 700         */
 701         void deleteExpiredJobs(const uint finishedJobNum);
 702
 703         /**
 704         * Assigns a FilterMgr to a job and starts filtering on it.
 705         */
 706         void startJobFiltering(mlJob* job, const QString& text, bool noSBD);
 707
 708         /**
 709         * Waits for filtering to be completed on a job.
 710         * This is typically called because an app has requested job info that requires
 711         * filtering to be completed, such as getJobInfo.
 712         */
 713         void waitJobFiltering(const mlJob* job);
 714
 715         /**
 716         * Processes filters by looping across the pool of FilterMgrs.
 717         * As each FilterMgr finishes, emits appropriate signals and flags it as no longer busy.
 718         */
 719         void doFiltering();
 720
 721         /**
 722         * Loads notify events from a file.  Clearing data if clear is True.
 723         */
 724         void loadNotifyEventsFromFile( const QString& filename, bool clear);
 725
 726     private slots:
 727         void slotFilterMgrFinished();
 728         void slotFilterMgrStopped();
 729 };
 730
 731 #endif // _SPEECHDATA_H_