apps/app_speech_utils.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 2006, Digium, Inc.
   5  *
   6  * Joshua Colp <jcolp@digium.com>
   7  *
   8  * See http://www.asterisk.org for more information about
   9  * the Asterisk project. Please do not directly contact
  10  * any of the maintainers of this project for assistance;
  11  * the project provides a web site, mailing lists and IRC
  12  * channels for your use.
  13  *
  14  * This program is free software, distributed under the terms of
  15  * the GNU General Public License Version 2. See the LICENSE file
  16  * at the top of the source tree.
  17  */
  18
  19 /*! \file
  20  *
  21  * \brief Speech Recognition Utility Applications
  22  *
  23  * \author Joshua Colp <jcolp@digium.com>
  24  *
  25  * \ingroup applications
  26  */
  27
  28 #include "asterisk.h"
  29
  30 ASTERISK_FILE_VERSION(__FILE__, "$Revision$");
  31
  32 #include "asterisk/file.h"
  33 #include "asterisk/channel.h"
  34 #include "asterisk/pbx.h"
  35 #include "asterisk/module.h"
  36 #include "asterisk/lock.h"
  37 #include "asterisk/app.h"
  38 #include "asterisk/speech.h"
  39
  40 /*** DOCUMENTATION
  41         <application name="SpeechCreate" language="en_US">
  42                 <synopsis>
  43                         Create a Speech Structure.
  44                 </synopsis>
  45                 <syntax>
  46                         <parameter name="engine_name" required="true" />
  47                 </syntax>
  48                 <description>
  49                         <para>This application creates information to be used by all the other applications.
  50                         It must be called before doing any speech recognition activities such as activating a grammar.
  51                         It takes the engine name to use as the argument, if not specified the default engine will be used.</para>
  52                 </description>
  53         </application>
  54         <application name="SpeechActivateGrammar" language="en_US">
  55                 <synopsis>
  56                         Activate a grammar.
  57                 </synopsis>
  58                 <syntax>
  59                         <parameter name="grammar_name" required="true" />
  60                 </syntax>
  61                 <description>
  62                         <para>This activates the specified grammar to be recognized by the engine.
  63                         A grammar tells the speech recognition engine what to recognize, and how to portray it back to you
  64                         in the dialplan. The grammar name is the only argument to this application.</para>
  65                 </description>
  66         </application>
  67         <application name="SpeechStart" language="en_US">
  68                 <synopsis>
  69                         Start recognizing voice in the audio stream.
  70                 </synopsis>
  71                 <syntax />
  72                 <description>
  73                         <para>Tell the speech recognition engine that it should start trying to get results from audio being
  74                         fed to it.</para>
  75                 </description>
  76         </application>
  77         <application name="SpeechBackground" language="en_US">
  78                 <synopsis>
  79                         Play a sound file and wait for speech to be recognized.
  80                 </synopsis>
  81                 <syntax>
  82                         <parameter name="sound_file" required="true" />
  83                         <parameter name="timeout">
  84                                 <para>Timeout integer in seconds. Note the timeout will only start
  85                                 once the sound file has stopped playing.</para>
  86                         </parameter>
  87                         <parameter name="options">
  88                                 <optionlist>
  89                                         <option name="n">
  90                                                 <para>Don't answer the channel if it has not already been answered.</para>
  91                                         </option>
  92                                 </optionlist>
  93                         </parameter>
  94                 </syntax>
  95                 <description>
  96                         <para>This application plays a sound file and waits for the person to speak. Once they start speaking playback
  97                         of the file stops, and silence is heard. Once they stop talking the processing sound is played to indicate
  98                         the speech recognition engine is working. Once results are available the application returns and results
  99                         (score and text) are available using dialplan functions.</para>
 100                         <para>The first text and score are ${SPEECH_TEXT(0)} AND ${SPEECH_SCORE(0)} while the second are ${SPEECH_TEXT(1)}
 101                         and ${SPEECH_SCORE(1)}.</para>
 102                         <para>The first argument is the sound file and the second is the timeout integer in seconds.</para>
 103
 104                 </description>
 105         </application>
 106         <application name="SpeechDeactivateGrammar" language="en_US">
 107                 <synopsis>
 108                         Deactivate a grammar.
 109                 </synopsis>
 110                 <syntax>
 111                         <parameter name="grammar_name" required="true">
 112                                 <para>The grammar name to deactivate</para>
 113                         </parameter>
 114                 </syntax>
 115                 <description>
 116                         <para>This deactivates the specified grammar so that it is no longer recognized.</para>
 117                 </description>
 118         </application>
 119         <application name="SpeechProcessingSound" language="en_US">
 120                 <synopsis>
 121                         Change background processing sound.
 122                 </synopsis>
 123                 <syntax>
 124                         <parameter name="sound_file" required="true" />
 125                 </syntax>
 126                 <description>
 127                         <para>This changes the processing sound that SpeechBackground plays back when the speech recognition engine is
 128                         processing and working to get results.</para>
 129                 </description>
 130         </application>
 131         <application name="SpeechDestroy" language="en_US">
 132                 <synopsis>
 133                         End speech recognition.
 134                 </synopsis>
 135                 <syntax />
 136                 <description>
 137                         <para>This destroys the information used by all the other speech recognition applications.
 138                         If you call this application but end up wanting to recognize more speech, you must call SpeechCreate()
 139                         again before calling any other application.</para>
 140                 </description>
 141         </application>
 142         <application name="SpeechLoadGrammar" language="en_US">
 143                 <synopsis>
 144                         Load a grammar.
 145                 </synopsis>
 146                 <syntax>
 147                         <parameter name="grammar_name" required="true" />
 148                         <parameter name="path" required="true" />
 149                 </syntax>
 150                 <description>
 151                         <para>Load a grammar only on the channel, not globally.</para>
 152                 </description>
 153         </application>
 154         <application name="SpeechUnloadGrammar" language="en_US">
 155                 <synopsis>
 156                         Unload a grammar.
 157                 </synopsis>
 158                 <syntax>
 159                         <parameter name="grammar_name" required="true" />
 160                 </syntax>
 161                 <description>
 162                         <para>Unload a grammar.</para>
 163                 </description>
 164         </application>
 165         <function name="SPEECH_SCORE" language="en_US">
 166                 <synopsis>
 167                         Gets the confidence score of a result.
 168                 </synopsis>
 169                 <syntax argsep="/">
 170                         <parameter name="nbest_number" />
 171                         <parameter name="result_number" required="true" />
 172                 </syntax>
 173                 <description>
 174                         <para>Gets the confidence score of a result.</para>
 175                 </description>
 176         </function>
 177         <function name="SPEECH_TEXT" language="en_US">
 178                 <synopsis>
 179                         Gets the recognized text of a result.
 180                 </synopsis>
 181                 <syntax argsep="/">
 182                         <parameter name="nbest_number" />
 183                         <parameter name="result_number" required="true" />
 184                 </syntax>
 185                 <description>
 186                         <para>Gets the recognized text of a result.</para>
 187                 </description>
 188         </function>
 189         <function name="SPEECH_GRAMMAR" language="en_US">
 190                 <synopsis>
 191                         Gets the matched grammar of a result if available.
 192                 </synopsis>
 193                 <syntax argsep="/">
 194                         <parameter name="nbest_number" />
 195                         <parameter name="result_number" required="true" />
 196                 </syntax>
 197                 <description>
 198                         <para>Gets the matched grammar of a result if available.</para>
 199                 </description>
 200         </function>
 201         <function name="SPEECH_ENGINE" language="en_US">
 202                 <synopsis>
 203                         Change a speech engine specific attribute.
 204                 </synopsis>
 205                 <syntax>
 206                         <parameter name="name" required="true" />
 207                 </syntax>
 208                 <description>
 209                         <para>Changes a speech engine specific attribute.</para>
 210                 </description>
 211         </function>
 212         <function name="SPEECH_RESULTS_TYPE" language="en_US">
 213                 <synopsis>
 214                         Sets the type of results that will be returned.
 215                 </synopsis>
 216                 <syntax />
 217                 <description>
 218                         <para>Sets the type of results that will be returned. Valid options are normal or nbest.</para>
 219                 </description>
 220         </function>
 221         <function name="SPEECH" language="en_US">
 222                 <synopsis>
 223                         Gets information about speech recognition results.
 224                 </synopsis>
 225                 <syntax>
 226                         <parameter name="argument" required="true">
 227                                 <enumlist>
 228                                         <enum name="status">
 229                                                 <para>Returns <literal>1</literal> upon speech object existing,
 230                                                 or <literal>0</literal> if not</para>
 231                                         </enum>
 232                                         <enum name="spoke">
 233                                                 <para>Returns <literal>1</literal> if spoker spoke,
 234                                                 or <literal>0</literal> if not</para>
 235                                         </enum>
 236                                         <enum name="results">
 237                                                 <para>Returns number of results that were recognized.</para>
 238                                         </enum>
 239                                 </enumlist>
 240                         </parameter>
 241                 </syntax>
 242                 <description>
 243                         <para>Gets information about speech recognition results.</para>
 244                 </description>
 245         </function>
 246  ***/
 247
 248 /*! \brief Helper function used by datastores to destroy the speech structure upon hangup */
 249 static void destroy_callback(void *data)
 250 {
 251         struct ast_speech *speech = (struct ast_speech*)data;
 252
 253         if (speech == NULL) {
 254                 return;
 255         }
 256
 257         /* Deallocate now */
 258         ast_speech_destroy(speech);
 259
 260         return;
 261 }
 262
 263 /*! \brief Static structure for datastore information */
 264 static const struct ast_datastore_info speech_datastore = {
 265         .type = "speech",
 266         .destroy = destroy_callback
 267 };
 268
 269 /*! \brief Helper function used to find the speech structure attached to a channel */
 270 static struct ast_speech *find_speech(struct ast_channel *chan)
 271 {
 272         struct ast_speech *speech = NULL;
 273         struct ast_datastore *datastore = NULL;
 274
 275         datastore = ast_channel_datastore_find(chan, &speech_datastore, NULL);
 276         if (datastore == NULL) {
 277                 return NULL;
 278         }
 279         speech = datastore->data;
 280
 281         return speech;
 282 }
 283
 284 /* Helper function to find a specific speech recognition result by number and nbest alternative */
 285 static struct ast_speech_result *find_result(struct ast_speech_result *results, char *result_num)
 286 {
 287         struct ast_speech_result *result = results;
 288         char *tmp = NULL;
 289         int nbest_num = 0, wanted_num = 0, i = 0;
 290
 291         if (!result) {
 292                 return NULL;
 293         }
 294
 295         if ((tmp = strchr(result_num, '/'))) {
 296                 *tmp++ = '\0';
 297                 nbest_num = atoi(result_num);
 298                 wanted_num = atoi(tmp);
 299         } else {
 300                 wanted_num = atoi(result_num);
 301         }
 302
 303         do {
 304                 if (result->nbest_num != nbest_num)
 305                         continue;
 306                 if (i == wanted_num)
 307                         break;
 308                 i++;
 309         } while ((result = AST_LIST_NEXT(result, list)));
 310
 311         return result;
 312 }
 313
 314 /*! \brief SPEECH_SCORE() Dialplan Function */
 315 static int speech_score(struct ast_channel *chan, const char *cmd, char *data,
 316                        char *buf, size_t len)
 317 {
 318         struct ast_speech_result *result = NULL;
 319         struct ast_speech *speech = find_speech(chan);
 320         char tmp[128] = "";
 321
 322         if (data == NULL || speech == NULL || !(result = find_result(speech->results, data))) {
 323                 return -1;
 324         }
 325
 326         snprintf(tmp, sizeof(tmp), "%d", result->score);
 327
 328         ast_copy_string(buf, tmp, len);
 329
 330         return 0;
 331 }
 332
 333 static struct ast_custom_function speech_score_function = {
 334         .name = "SPEECH_SCORE",
 335         .read = speech_score,
 336         .write = NULL,
 337 };
 338
 339 /*! \brief SPEECH_TEXT() Dialplan Function */
 340 static int speech_text(struct ast_channel *chan, const char *cmd, char *data,
 341                         char *buf, size_t len)
 342 {
 343         struct ast_speech_result *result = NULL;
 344         struct ast_speech *speech = find_speech(chan);
 345
 346         if (data == NULL || speech == NULL || !(result = find_result(speech->results, data))) {
 347                 return -1;
 348         }
 349
 350         if (result->text != NULL) {
 351                 ast_copy_string(buf, result->text, len);
 352         } else {
 353                 buf[0] = '\0';
 354         }
 355
 356         return 0;
 357 }
 358
 359 static struct ast_custom_function speech_text_function = {
 360         .name = "SPEECH_TEXT",
 361         .read = speech_text,
 362         .write = NULL,
 363 };
 364
 365 /*! \brief SPEECH_GRAMMAR() Dialplan Function */
 366 static int speech_grammar(struct ast_channel *chan, const char *cmd, char *data,
 367                         char *buf, size_t len)
 368 {
 369         struct ast_speech_result *result = NULL;
 370         struct ast_speech *speech = find_speech(chan);
 371
 372         if (data == NULL || speech == NULL || !(result = find_result(speech->results, data))) {
 373                 return -1;
 374         }
 375
 376         if (result->grammar != NULL) {
 377                 ast_copy_string(buf, result->grammar, len);
 378         } else {
 379                 buf[0] = '\0';
 380         }
 381
 382         return 0;
 383 }
 384
 385 static struct ast_custom_function speech_grammar_function = {
 386         .name = "SPEECH_GRAMMAR",
 387         .read = speech_grammar,
 388         .write = NULL,
 389 };
 390
 391 /*! \brief SPEECH_ENGINE() Dialplan Function */
 392 static int speech_engine_write(struct ast_channel *chan, const char *cmd, char *data, const char *value)
 393 {
 394         struct ast_speech *speech = find_speech(chan);
 395
 396         if (data == NULL || speech == NULL) {
 397                 return -1;
 398         }
 399
 400         ast_speech_change(speech, data, value);
 401
 402         return 0;
 403 }
 404
 405 static struct ast_custom_function speech_engine_function = {
 406         .name = "SPEECH_ENGINE",
 407         .read = NULL,
 408         .write = speech_engine_write,
 409 };
 410
 411 /*! \brief SPEECH_RESULTS_TYPE() Dialplan Function */
 412 static int speech_results_type_write(struct ast_channel *chan, const char *cmd, char *data, const char *value)
 413 {
 414         struct ast_speech *speech = find_speech(chan);
 415
 416         if (data == NULL || speech == NULL)
 417                 return -1;
 418
 419         if (!strcasecmp(value, "normal"))
 420                 ast_speech_change_results_type(speech, AST_SPEECH_RESULTS_TYPE_NORMAL);
 421         else if (!strcasecmp(value, "nbest"))
 422                 ast_speech_change_results_type(speech, AST_SPEECH_RESULTS_TYPE_NBEST);
 423
 424         return 0;
 425 }
 426
 427 static struct ast_custom_function speech_results_type_function = {
 428         .name = "SPEECH_RESULTS_TYPE",
 429         .read = NULL,
 430         .write = speech_results_type_write,
 431 };
 432
 433 /*! \brief SPEECH() Dialplan Function */
 434 static int speech_read(struct ast_channel *chan, const char *cmd, char *data,
 435                         char *buf, size_t len)
 436 {
 437         int results = 0;
 438         struct ast_speech_result *result = NULL;
 439         struct ast_speech *speech = find_speech(chan);
 440         char tmp[128] = "";
 441
 442         /* Now go for the various options */
 443         if (!strcasecmp(data, "status")) {
 444                 if (speech != NULL)
 445                         ast_copy_string(buf, "1", len);
 446                 else
 447                         ast_copy_string(buf, "0", len);
 448                 return 0;
 449         }
 450
 451         /* Make sure we have a speech structure for everything else */
 452         if (speech == NULL) {
 453                 return -1;
 454         }
 455
 456         /* Check to see if they are checking for silence */
 457         if (!strcasecmp(data, "spoke")) {
 458                 if (ast_test_flag(speech, AST_SPEECH_SPOKE))
 459                         ast_copy_string(buf, "1", len);
 460                 else
 461                         ast_copy_string(buf, "0", len);
 462         } else if (!strcasecmp(data, "results")) {
 463                 /* Count number of results */
 464                 for (result = speech->results; result; result = AST_LIST_NEXT(result, list))
 465                         results++;
 466                 snprintf(tmp, sizeof(tmp), "%d", results);
 467                 ast_copy_string(buf, tmp, len);
 468         } else {
 469                 buf[0] = '\0';
 470         }
 471
 472         return 0;
 473 }
 474
 475 static struct ast_custom_function speech_function = {
 476         .name = "SPEECH",
 477         .read = speech_read,
 478         .write = NULL,
 479 };
 480
 481
 482
 483 /*! \brief SpeechCreate() Dialplan Application */
 484 static int speech_create(struct ast_channel *chan, void *data)
 485 {
 486         struct ast_speech *speech = NULL;
 487         struct ast_datastore *datastore = NULL;
 488
 489         /* Request a speech object */
 490         speech = ast_speech_new(data, chan->nativeformats);
 491         if (speech == NULL) {
 492                 /* Not available */
 493                 pbx_builtin_setvar_helper(chan, "ERROR", "1");
 494                 return 0;
 495         }
 496
 497         datastore = ast_datastore_alloc(&speech_datastore, NULL);
 498         if (datastore == NULL) {
 499                 ast_speech_destroy(speech);
 500                 pbx_builtin_setvar_helper(chan, "ERROR", "1");
 501                 return 0;
 502         }
 503         pbx_builtin_setvar_helper(chan, "ERROR", NULL);
 504         datastore->data = speech;
 505         ast_channel_datastore_add(chan, datastore);
 506
 507         return 0;
 508 }
 509
 510 /*! \brief SpeechLoadGrammar(Grammar Name,Path) Dialplan Application */
 511 static int speech_load(struct ast_channel *chan, void *vdata)
 512 {
 513         int res = 0;
 514         struct ast_speech *speech = find_speech(chan);
 515         char *data;
 516         AST_DECLARE_APP_ARGS(args,
 517                 AST_APP_ARG(grammar);
 518                 AST_APP_ARG(path);
 519         );
 520
 521         data = ast_strdupa(vdata);
 522         AST_STANDARD_APP_ARGS(args, data);
 523
 524         if (speech == NULL)
 525                 return -1;
 526
 527         if (args.argc != 2)
 528                 return -1;
 529
 530         /* Load the grammar locally on the object */
 531         res = ast_speech_grammar_load(speech, args.grammar, args.path);
 532
 533         return res;
 534 }
 535
 536 /*! \brief SpeechUnloadGrammar(Grammar Name) Dialplan Application */
 537 static int speech_unload(struct ast_channel *chan, void *data)
 538 {
 539         int res = 0;
 540         struct ast_speech *speech = find_speech(chan);
 541
 542         if (speech == NULL)
 543                 return -1;
 544
 545         /* Unload the grammar */
 546         res = ast_speech_grammar_unload(speech, data);
 547
 548         return res;
 549 }
 550
 551 /*! \brief SpeechDeactivateGrammar(Grammar Name) Dialplan Application */
 552 static int speech_deactivate(struct ast_channel *chan, void *data)
 553 {
 554         int res = 0;
 555         struct ast_speech *speech = find_speech(chan);
 556
 557         if (speech == NULL)
 558                 return -1;
 559
 560         /* Deactivate the grammar on the speech object */
 561         res = ast_speech_grammar_deactivate(speech, data);
 562
 563         return res;
 564 }
 565
 566 /*! \brief SpeechActivateGrammar(Grammar Name) Dialplan Application */
 567 static int speech_activate(struct ast_channel *chan, void *data)
 568 {
 569         int res = 0;
 570         struct ast_speech *speech = find_speech(chan);
 571
 572         if (speech == NULL)
 573                 return -1;
 574
 575         /* Activate the grammar on the speech object */
 576         res = ast_speech_grammar_activate(speech, data);
 577
 578         return res;
 579 }
 580
 581 /*! \brief SpeechStart() Dialplan Application */
 582 static int speech_start(struct ast_channel *chan, void *data)
 583 {
 584         int res = 0;
 585         struct ast_speech *speech = find_speech(chan);
 586
 587         if (speech == NULL)
 588                 return -1;
 589
 590         ast_speech_start(speech);
 591
 592         return res;
 593 }
 594
 595 /*! \brief SpeechProcessingSound(Sound File) Dialplan Application */
 596 static int speech_processing_sound(struct ast_channel *chan, void *data)
 597 {
 598         int res = 0;
 599         struct ast_speech *speech = find_speech(chan);
 600
 601         if (speech == NULL)
 602                 return -1;
 603
 604         if (speech->processing_sound != NULL) {
 605                 ast_free(speech->processing_sound);
 606                 speech->processing_sound = NULL;
 607         }
 608
 609         speech->processing_sound = ast_strdup(data);
 610
 611         return res;
 612 }
 613
 614 /*! \brief Helper function used by speech_background to playback a soundfile */
 615 static int speech_streamfile(struct ast_channel *chan, const char *filename, const char *preflang)
 616 {
 617         struct ast_filestream *fs = NULL;
 618
 619         if (!(fs = ast_openstream(chan, filename, preflang)))
 620                 return -1;
 621
 622         if (ast_applystream(chan, fs))
 623                 return -1;
 624
 625         ast_playstream(fs);
 626
 627         return 0;
 628 }
 629
 630 enum {
 631         SB_OPT_NOANSWER = (1 << 0),
 632 };
 633
 634 AST_APP_OPTIONS(speech_background_options, BEGIN_OPTIONS
 635         AST_APP_OPTION('n', SB_OPT_NOANSWER),
 636 END_OPTIONS );
 637
 638 /*! \brief SpeechBackground(Sound File,Timeout) Dialplan Application */
 639 static int speech_background(struct ast_channel *chan, void *data)
 640 {
 641         unsigned int timeout = 0;
 642         int res = 0, done = 0, started = 0, quieted = 0, max_dtmf_len = 0;
 643         struct ast_speech *speech = find_speech(chan);
 644         struct ast_frame *f = NULL;
 645         int oldreadformat = AST_FORMAT_SLINEAR;
 646         char dtmf[AST_MAX_EXTENSION] = "";
 647         struct timeval start = { 0, 0 }, current;
 648         struct ast_datastore *datastore = NULL;
 649         char *parse, *filename_tmp = NULL, *filename = NULL, tmp[2] = "", dtmf_terminator = '#';
 650         const char *tmp2 = NULL;
 651         struct ast_flags options = { 0 };
 652         AST_DECLARE_APP_ARGS(args,
 653                 AST_APP_ARG(soundfile);
 654                 AST_APP_ARG(timeout);
 655                 AST_APP_ARG(options);
 656         );
 657
 658         parse = ast_strdupa(data);
 659         AST_STANDARD_APP_ARGS(args, parse);
 660
 661         if (speech == NULL)
 662                 return -1;
 663
 664         if (!ast_strlen_zero(args.options)) {
 665                 char *options_buf = ast_strdupa(args.options);
 666                 ast_app_parse_options(speech_background_options, &options, NULL, options_buf);
 667         }
 668
 669         /* If channel is not already answered, then answer it */
 670         if (chan->_state != AST_STATE_UP && !ast_test_flag(&options, SB_OPT_NOANSWER)
 671                 && ast_answer(chan)) {
 672                         return -1;
 673         }
 674
 675         /* Record old read format */
 676         oldreadformat = chan->readformat;
 677
 678         /* Change read format to be signed linear */
 679         if (ast_set_read_format(chan, speech->format))
 680                 return -1;
 681
 682         if (!ast_strlen_zero(args.soundfile)) {
 683                 /* Yay sound file */
 684                 filename_tmp = ast_strdupa(args.soundfile);
 685                 if (!ast_strlen_zero(args.timeout)) {
 686                         if ((timeout = atof(args.timeout) * 1000.0) == 0)
 687                                 timeout = -1;
 688                 } else
 689                         timeout = 0;
 690         }
 691
 692         /* See if the maximum DTMF length variable is set... we use a variable in case they want to carry it through their entire dialplan */
 693         ast_channel_lock(chan);
 694         if ((tmp2 = pbx_builtin_getvar_helper(chan, "SPEECH_DTMF_MAXLEN")) && !ast_strlen_zero(tmp2)) {
 695                 max_dtmf_len = atoi(tmp2);
 696         }
 697
 698         /* See if a terminator is specified */
 699         if ((tmp2 = pbx_builtin_getvar_helper(chan, "SPEECH_DTMF_TERMINATOR"))) {
 700                 if (ast_strlen_zero(tmp2))
 701                         dtmf_terminator = '\0';
 702                 else
 703                         dtmf_terminator = tmp2[0];
 704         }
 705         ast_channel_unlock(chan);
 706
 707         /* Before we go into waiting for stuff... make sure the structure is ready, if not - start it again */
 708         if (speech->state == AST_SPEECH_STATE_NOT_READY || speech->state == AST_SPEECH_STATE_DONE) {
 709                 ast_speech_change_state(speech, AST_SPEECH_STATE_NOT_READY);
 710                 ast_speech_start(speech);
 711         }
 712
 713         /* Ensure no streams are currently running */
 714         ast_stopstream(chan);
 715
 716         /* Okay it's streaming so go into a loop grabbing frames! */
 717         while (done == 0) {
 718                 /* If the filename is null and stream is not running, start up a new sound file */
 719                 if (!quieted && (chan->streamid == -1 && chan->timingfunc == NULL) && (filename = strsep(&filename_tmp, "&"))) {
 720                         /* Discard old stream information */
 721                         ast_stopstream(chan);
 722                         /* Start new stream */
 723                         speech_streamfile(chan, filename, chan->language);
 724                 }
 725
 726                 /* Run scheduled stuff */
 727                 ast_sched_runq(chan->sched);
 728
 729                 /* Yay scheduling */
 730                 res = ast_sched_wait(chan->sched);
 731                 if (res < 0)
 732                         res = 1000;
 733
 734                 /* If there is a frame waiting, get it - if not - oh well */
 735                 if (ast_waitfor(chan, res) > 0) {
 736                         f = ast_read(chan);
 737                         if (f == NULL) {
 738                                 /* The channel has hung up most likely */
 739                                 done = 3;
 740                                 break;
 741                         }
 742                 }
 743
 744                 /* Do timeout check (shared between audio/dtmf) */
 745                 if ((!quieted || strlen(dtmf)) && started == 1) {
 746                         current = ast_tvnow();
 747                         if ((ast_tvdiff_ms(current, start)) >= timeout) {
 748                                 done = 1;
 749                                 if (f)
 750                                         ast_frfree(f);
 751                                 break;
 752                         }
 753                 }
 754
 755                 /* Do checks on speech structure to see if it's changed */
 756                 ast_mutex_lock(&speech->lock);
 757                 if (ast_test_flag(speech, AST_SPEECH_QUIET)) {
 758                         if (chan->stream)
 759                                 ast_stopstream(chan);
 760                         ast_clear_flag(speech, AST_SPEECH_QUIET);
 761                         quieted = 1;
 762                 }
 763                 /* Check state so we can see what to do */
 764                 switch (speech->state) {
 765                 case AST_SPEECH_STATE_READY:
 766                         /* If audio playback has stopped do a check for timeout purposes */
 767                         if (chan->streamid == -1 && chan->timingfunc == NULL)
 768                                 ast_stopstream(chan);
 769                         if (!quieted && chan->stream == NULL && timeout && started == 0 && !filename_tmp) {
 770                                 if (timeout == -1) {
 771                                         done = 1;
 772                                         if (f)
 773                                                 ast_frfree(f);
 774                                         break;
 775                                 }
 776                                 start = ast_tvnow();
 777                                 started = 1;
 778                         }
 779                         /* Write audio frame out to speech engine if no DTMF has been received */
 780                         if (!strlen(dtmf) && f != NULL && f->frametype == AST_FRAME_VOICE) {
 781                                 ast_speech_write(speech, f->data.ptr, f->datalen);
 782                         }
 783                         break;
 784                 case AST_SPEECH_STATE_WAIT:
 785                         /* Cue up waiting sound if not already playing */
 786                         if (!strlen(dtmf)) {
 787                                 if (chan->stream == NULL) {
 788                                         if (speech->processing_sound != NULL) {
 789                                                 if (strlen(speech->processing_sound) > 0 && strcasecmp(speech->processing_sound, "none")) {
 790                                                         speech_streamfile(chan, speech->processing_sound, chan->language);
 791                                                 }
 792                                         }
 793                                 } else if (chan->streamid == -1 && chan->timingfunc == NULL) {
 794                                         ast_stopstream(chan);
 795                                         if (speech->processing_sound != NULL) {
 796                                                 if (strlen(speech->processing_sound) > 0 && strcasecmp(speech->processing_sound, "none")) {
 797                                                         speech_streamfile(chan, speech->processing_sound, chan->language);
 798                                                 }
 799                                         }
 800                                 }
 801                         }
 802                         break;
 803                 case AST_SPEECH_STATE_DONE:
 804                         /* Now that we are done... let's switch back to not ready state */
 805                         ast_speech_change_state(speech, AST_SPEECH_STATE_NOT_READY);
 806                         if (!strlen(dtmf)) {
 807                                 /* Copy to speech structure the results, if available */
 808                                 speech->results = ast_speech_results_get(speech);
 809                                 /* Break out of our background too */
 810                                 done = 1;
 811                                 /* Stop audio playback */
 812                                 if (chan->stream != NULL) {
 813                                         ast_stopstream(chan);
 814                                 }
 815                         }
 816                         break;
 817                 default:
 818                         break;
 819                 }
 820                 ast_mutex_unlock(&speech->lock);
 821
 822                 /* Deal with other frame types */
 823                 if (f != NULL) {
 824                         /* Free the frame we received */
 825                         switch (f->frametype) {
 826                         case AST_FRAME_DTMF:
 827                                 if (dtmf_terminator != '\0' && f->subclass == dtmf_terminator) {
 828                                         done = 1;
 829                                 } else {
 830                                         if (chan->stream != NULL) {
 831                                                 ast_stopstream(chan);
 832                                         }
 833                                         if (!started) {
 834                                                 /* Change timeout to be 5 seconds for DTMF input */
 835                                                 timeout = (chan->pbx && chan->pbx->dtimeoutms) ? chan->pbx->dtimeoutms : 5000;
 836                                                 started = 1;
 837                                         }
 838                                         start = ast_tvnow();
 839                                         snprintf(tmp, sizeof(tmp), "%c", f->subclass);
 840                                         strncat(dtmf, tmp, sizeof(dtmf) - strlen(dtmf) - 1);
 841                                         /* If the maximum length of the DTMF has been reached, stop now */
 842                                         if (max_dtmf_len && strlen(dtmf) == max_dtmf_len)
 843                                                 done = 1;
 844                                 }
 845                                 break;
 846                         case AST_FRAME_CONTROL:
 847                                 switch (f->subclass) {
 848                                 case AST_CONTROL_HANGUP:
 849                                         /* Since they hung up we should destroy the speech structure */
 850                                         done = 3;
 851                                 default:
 852                                         break;
 853                                 }
 854                         default:
 855                                 break;
 856                         }
 857                         ast_frfree(f);
 858                         f = NULL;
 859                 }
 860         }
 861
 862         if (!ast_strlen_zero(dtmf)) {
 863                 /* We sort of make a results entry */
 864                 speech->results = ast_calloc(1, sizeof(*speech->results));
 865                 if (speech->results != NULL) {
 866                         ast_speech_dtmf(speech, dtmf);
 867                         speech->results->score = 1000;
 868                         speech->results->text = ast_strdup(dtmf);
 869                         speech->results->grammar = ast_strdup("dtmf");
 870                 }
 871                 ast_speech_change_state(speech, AST_SPEECH_STATE_NOT_READY);
 872         }
 873
 874         /* See if it was because they hung up */
 875         if (done == 3) {
 876                 /* Destroy speech structure */
 877                 ast_speech_destroy(speech);
 878                 datastore = ast_channel_datastore_find(chan, &speech_datastore, NULL);
 879                 if (datastore != NULL)
 880                         ast_channel_datastore_remove(chan, datastore);
 881         } else {
 882                 /* Channel is okay so restore read format */
 883                 ast_set_read_format(chan, oldreadformat);
 884         }
 885
 886         return 0;
 887 }
 888
 889
 890 /*! \brief SpeechDestroy() Dialplan Application */
 891 static int speech_destroy(struct ast_channel *chan, void *data)
 892 {
 893         int res = 0;
 894         struct ast_speech *speech = find_speech(chan);
 895         struct ast_datastore *datastore = NULL;
 896
 897         if (speech == NULL)
 898                 return -1;
 899
 900         /* Destroy speech structure */
 901         ast_speech_destroy(speech);
 902
 903         datastore = ast_channel_datastore_find(chan, &speech_datastore, NULL);
 904         if (datastore != NULL) {
 905                 ast_channel_datastore_remove(chan, datastore);
 906         }
 907
 908         return res;
 909 }
 910
 911 static int unload_module(void)
 912 {
 913         int res = 0;
 914
 915         res = ast_unregister_application("SpeechCreate");
 916         res |= ast_unregister_application("SpeechLoadGrammar");
 917         res |= ast_unregister_application("SpeechUnloadGrammar");
 918         res |= ast_unregister_application("SpeechActivateGrammar");
 919         res |= ast_unregister_application("SpeechDeactivateGrammar");
 920         res |= ast_unregister_application("SpeechStart");
 921         res |= ast_unregister_application("SpeechBackground");
 922         res |= ast_unregister_application("SpeechDestroy");
 923         res |= ast_unregister_application("SpeechProcessingSound");
 924         res |= ast_custom_function_unregister(&speech_function);
 925         res |= ast_custom_function_unregister(&speech_score_function);
 926         res |= ast_custom_function_unregister(&speech_text_function);
 927         res |= ast_custom_function_unregister(&speech_grammar_function);
 928         res |= ast_custom_function_unregister(&speech_engine_function);
 929         res |= ast_custom_function_unregister(&speech_results_type_function);
 930
 931         return res;
 932 }
 933
 934 static int load_module(void)
 935 {
 936         int res = 0;
 937
 938         res = ast_register_application_xml("SpeechCreate", speech_create);
 939         res |= ast_register_application_xml("SpeechLoadGrammar", speech_load);
 940         res |= ast_register_application_xml("SpeechUnloadGrammar", speech_unload);
 941         res |= ast_register_application_xml("SpeechActivateGrammar", speech_activate);
 942         res |= ast_register_application_xml("SpeechDeactivateGrammar", speech_deactivate);
 943         res |= ast_register_application_xml("SpeechStart", speech_start);
 944         res |= ast_register_application_xml("SpeechBackground", speech_background);
 945         res |= ast_register_application_xml("SpeechDestroy", speech_destroy);
 946         res |= ast_register_application_xml("SpeechProcessingSound", speech_processing_sound);
 947         res |= ast_custom_function_register(&speech_function);
 948         res |= ast_custom_function_register(&speech_score_function);
 949         res |= ast_custom_function_register(&speech_text_function);
 950         res |= ast_custom_function_register(&speech_grammar_function);
 951         res |= ast_custom_function_register(&speech_engine_function);
 952         res |= ast_custom_function_register(&speech_results_type_function);
 953
 954         return res;
 955 }
 956
 957 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Dialplan Speech Applications");