Mon Oct 8 12:39:08 2012

Asterisk developer's documentation


app_speech_utils.c File Reference

Speech Recognition Utility Applications. More...

#include "asterisk.h"
#include "asterisk/file.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/module.h"
#include "asterisk/lock.h"
#include "asterisk/app.h"
#include "asterisk/speech.h"

Go to the source code of this file.

Enumerations

enum  { SB_OPT_NOANSWER = (1 << 0) }

Functions

static void __reg_module (void)
static void __unreg_module (void)
 ASTERISK_FILE_VERSION (__FILE__,"$Revision: 362815 $")
static void destroy_callback (void *data)
 Helper function used by datastores to destroy the speech structure upon hangup.
static struct ast_speech_resultfind_result (struct ast_speech_result *results, char *result_num)
static struct ast_speechfind_speech (struct ast_channel *chan)
 Helper function used to find the speech structure attached to a channel.
static int load_module (void)
static int speech_activate (struct ast_channel *chan, const char *data)
 SpeechActivateGrammar(Grammar Name) Dialplan Application.
static int speech_background (struct ast_channel *chan, const char *data)
 SpeechBackground(Sound File,Timeout) Dialplan Application.
static int speech_create (struct ast_channel *chan, const char *data)
 SpeechCreate() Dialplan Application.
static int speech_deactivate (struct ast_channel *chan, const char *data)
 SpeechDeactivateGrammar(Grammar Name) Dialplan Application.
static int speech_destroy (struct ast_channel *chan, const char *data)
 SpeechDestroy() Dialplan Application.
static int speech_engine_write (struct ast_channel *chan, const char *cmd, char *data, const char *value)
 SPEECH_ENGINE() Dialplan Function.
static int speech_grammar (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
 SPEECH_GRAMMAR() Dialplan Function.
static int speech_load (struct ast_channel *chan, const char *vdata)
 SpeechLoadGrammar(Grammar Name,Path) Dialplan Application.
static int speech_processing_sound (struct ast_channel *chan, const char *data)
 SpeechProcessingSound(Sound File) Dialplan Application.
static int speech_read (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
 SPEECH() Dialplan Function.
static int speech_results_type_write (struct ast_channel *chan, const char *cmd, char *data, const char *value)
 SPEECH_RESULTS_TYPE() Dialplan Function.
static int speech_score (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
 SPEECH_SCORE() Dialplan Function.
static int speech_start (struct ast_channel *chan, const char *data)
 SpeechStart() Dialplan Application.
static int speech_streamfile (struct ast_channel *chan, const char *filename, const char *preflang)
 Helper function used by speech_background to playback a soundfile.
static int speech_text (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
 SPEECH_TEXT() Dialplan Function.
static int speech_unload (struct ast_channel *chan, const char *data)
 SpeechUnloadGrammar(Grammar Name) Dialplan Application.
static int unload_module (void)

Variables

static struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "Dialplan Speech Applications" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "ac1f6a56484a8820659555499174e588" , .load = load_module, .unload = unload_module, .nonoptreq = "res_speech", }
static struct ast_module_infoast_module_info = &__mod_info
static struct ast_app_option speech_background_options [128] = { [ 'n' ] = { .flag = SB_OPT_NOANSWER }, }
static struct ast_datastore_info speech_datastore
 Static structure for datastore information.
static struct ast_custom_function speech_engine_function
static struct ast_custom_function speech_function
static struct ast_custom_function speech_grammar_function
static struct ast_custom_function speech_results_type_function
static struct ast_custom_function speech_score_function
static struct ast_custom_function speech_text_function


Detailed Description

Speech Recognition Utility Applications.

Author:
Joshua Colp <jcolp@digium.com>

Definition in file app_speech_utils.c.


Enumeration Type Documentation

anonymous enum

Enumerator:
SB_OPT_NOANSWER 

Definition at line 643 of file app_speech_utils.c.

00643      {
00644    SB_OPT_NOANSWER = (1 << 0),
00645 };


Function Documentation

static void __reg_module ( void   )  [static]

Definition at line 975 of file app_speech_utils.c.

static void __unreg_module ( void   )  [static]

Definition at line 975 of file app_speech_utils.c.

ASTERISK_FILE_VERSION ( __FILE__  ,
"$Revision: 362815 $"   
)

static void destroy_callback ( void *  data  )  [static]

Helper function used by datastores to destroy the speech structure upon hangup.

Definition at line 262 of file app_speech_utils.c.

References ast_speech_destroy().

00263 {
00264    struct ast_speech *speech = (struct ast_speech*)data;
00265 
00266    if (speech == NULL) {
00267       return;
00268    }
00269 
00270    /* Deallocate now */
00271    ast_speech_destroy(speech);
00272 
00273    return;
00274 }

static struct ast_speech_result* find_result ( struct ast_speech_result results,
char *  result_num 
) [static]

Definition at line 298 of file app_speech_utils.c.

References AST_LIST_NEXT, and ast_speech_result::nbest_num.

Referenced by speech_grammar(), speech_score(), and speech_text().

00299 {
00300    struct ast_speech_result *result = results;
00301    char *tmp = NULL;
00302    int nbest_num = 0, wanted_num = 0, i = 0;
00303 
00304    if (!result) {
00305       return NULL;
00306    }
00307 
00308    if ((tmp = strchr(result_num, '/'))) {
00309       *tmp++ = '\0';
00310       nbest_num = atoi(result_num);
00311       wanted_num = atoi(tmp);
00312    } else {
00313       wanted_num = atoi(result_num);
00314    }
00315 
00316    do {
00317       if (result->nbest_num != nbest_num)
00318          continue;
00319       if (i == wanted_num)
00320          break;
00321       i++;
00322    } while ((result = AST_LIST_NEXT(result, list)));
00323 
00324    return result;
00325 }

static struct ast_speech* find_speech ( struct ast_channel chan  )  [static]

Helper function used to find the speech structure attached to a channel.

Definition at line 283 of file app_speech_utils.c.

References ast_channel_datastore_find(), ast_datastore::data, and speech_datastore.

Referenced by speech_activate(), speech_background(), speech_deactivate(), speech_destroy(), speech_engine_write(), speech_grammar(), speech_load(), speech_processing_sound(), speech_read(), speech_results_type_write(), speech_score(), speech_start(), speech_text(), and speech_unload().

00284 {
00285    struct ast_speech *speech = NULL;
00286    struct ast_datastore *datastore = NULL;
00287    
00288    datastore = ast_channel_datastore_find(chan, &speech_datastore, NULL);
00289    if (datastore == NULL) {
00290       return NULL;
00291    }
00292    speech = datastore->data;
00293 
00294    return speech;
00295 }

static int load_module ( void   )  [static]

Definition at line 948 of file app_speech_utils.c.

References ast_custom_function_register, ast_register_application_xml, speech_activate(), speech_background(), speech_create(), speech_deactivate(), speech_destroy(), speech_engine_function, speech_function, speech_grammar_function, speech_load(), speech_processing_sound(), speech_results_type_function, speech_score_function, speech_start(), speech_text_function, and speech_unload().

00949 {
00950    int res = 0;
00951 
00952    res = ast_register_application_xml("SpeechCreate", speech_create);
00953    res |= ast_register_application_xml("SpeechLoadGrammar", speech_load);
00954    res |= ast_register_application_xml("SpeechUnloadGrammar", speech_unload);
00955    res |= ast_register_application_xml("SpeechActivateGrammar", speech_activate);
00956    res |= ast_register_application_xml("SpeechDeactivateGrammar", speech_deactivate);
00957    res |= ast_register_application_xml("SpeechStart", speech_start);
00958    res |= ast_register_application_xml("SpeechBackground", speech_background);
00959    res |= ast_register_application_xml("SpeechDestroy", speech_destroy);
00960    res |= ast_register_application_xml("SpeechProcessingSound", speech_processing_sound);
00961    res |= ast_custom_function_register(&speech_function);
00962    res |= ast_custom_function_register(&speech_score_function);
00963    res |= ast_custom_function_register(&speech_text_function);
00964    res |= ast_custom_function_register(&speech_grammar_function);
00965    res |= ast_custom_function_register(&speech_engine_function);
00966    res |= ast_custom_function_register(&speech_results_type_function);
00967 
00968    return res;
00969 }

static int speech_activate ( struct ast_channel chan,
const char *  data 
) [static]

SpeechActivateGrammar(Grammar Name) Dialplan Application.

Definition at line 580 of file app_speech_utils.c.

References ast_speech_grammar_activate(), and find_speech().

Referenced by load_module().

00581 {
00582    int res = 0;
00583    struct ast_speech *speech = find_speech(chan);
00584 
00585    if (speech == NULL)
00586       return -1;
00587 
00588    /* Activate the grammar on the speech object */
00589    res = ast_speech_grammar_activate(speech, data);
00590 
00591    return res;
00592 }

static int speech_background ( struct ast_channel chan,
const char *  data 
) [static]

SpeechBackground(Sound File,Timeout) Dialplan Application.

Definition at line 652 of file app_speech_utils.c.

References ast_channel::_state, args, ast_answer(), AST_APP_ARG, ast_app_parse_options(), ast_calloc, ast_channel_datastore_find(), ast_channel_datastore_remove(), ast_channel_lock, ast_channel_unlock, ast_clear_flag, AST_CONTROL_HANGUP, AST_DECLARE_APP_ARGS, AST_FORMAT_SLINEAR, AST_FRAME_CONTROL, AST_FRAME_DTMF, AST_FRAME_VOICE, ast_frfree, AST_MAX_EXTENSION, ast_mutex_lock, ast_mutex_unlock, ast_read(), ast_sched_runq(), ast_sched_wait(), ast_set_read_format(), ast_speech_change_state(), ast_speech_destroy(), ast_speech_dtmf(), AST_SPEECH_QUIET, ast_speech_results_get(), ast_speech_start(), AST_SPEECH_STATE_DONE, AST_SPEECH_STATE_NOT_READY, AST_SPEECH_STATE_READY, AST_SPEECH_STATE_WAIT, ast_speech_write(), AST_STANDARD_APP_ARGS, AST_STATE_UP, ast_stopstream(), ast_strdup, ast_strdupa, ast_strlen_zero(), ast_test_flag, ast_tvdiff_ms(), ast_tvnow(), ast_waitfor(), ast_pbx::dtimeoutms, f, find_speech(), ast_speech::format, ast_channel::language, ast_speech::lock, parse(), ast_channel::pbx, pbx_builtin_getvar_helper(), ast_speech::processing_sound, ast_channel::readformat, ast_speech::results, SB_OPT_NOANSWER, ast_channel::sched, speech_background_options, speech_datastore, speech_streamfile(), ast_speech::state, ast_channel::stream, ast_channel::streamid, strsep(), and ast_channel::timingfunc.

Referenced by load_module().

00653 {
00654    unsigned int timeout = 0;
00655    int res = 0, done = 0, started = 0, quieted = 0, max_dtmf_len = 0;
00656    struct ast_speech *speech = find_speech(chan);
00657    struct ast_frame *f = NULL;
00658    int oldreadformat = AST_FORMAT_SLINEAR;
00659    char dtmf[AST_MAX_EXTENSION] = "";
00660    struct timeval start = { 0, 0 }, current;
00661    struct ast_datastore *datastore = NULL;
00662    char *parse, *filename_tmp = NULL, *filename = NULL, tmp[2] = "", dtmf_terminator = '#';
00663    const char *tmp2 = NULL;
00664    struct ast_flags options = { 0 };
00665    AST_DECLARE_APP_ARGS(args,
00666       AST_APP_ARG(soundfile);
00667       AST_APP_ARG(timeout);
00668       AST_APP_ARG(options);
00669    );
00670 
00671    parse = ast_strdupa(data);
00672    AST_STANDARD_APP_ARGS(args, parse);
00673 
00674    if (speech == NULL)
00675       return -1;
00676 
00677    if (!ast_strlen_zero(args.options)) {
00678       char *options_buf = ast_strdupa(args.options);
00679       ast_app_parse_options(speech_background_options, &options, NULL, options_buf);
00680    }
00681 
00682    /* If channel is not already answered, then answer it */
00683    if (chan->_state != AST_STATE_UP && !ast_test_flag(&options, SB_OPT_NOANSWER)
00684       && ast_answer(chan)) {
00685          return -1;
00686    }
00687 
00688    /* Record old read format */
00689    oldreadformat = chan->readformat;
00690 
00691    /* Change read format to be signed linear */
00692    if (ast_set_read_format(chan, speech->format))
00693       return -1;
00694 
00695    if (!ast_strlen_zero(args.soundfile)) {
00696       /* Yay sound file */
00697       filename_tmp = ast_strdupa(args.soundfile);
00698       if (!ast_strlen_zero(args.timeout)) {
00699          if ((timeout = atof(args.timeout) * 1000.0) == 0)
00700             timeout = -1;
00701       } else
00702          timeout = 0;
00703    }
00704 
00705    /* See if the maximum DTMF length variable is set... we use a variable in case they want to carry it through their entire dialplan */
00706    ast_channel_lock(chan);
00707    if ((tmp2 = pbx_builtin_getvar_helper(chan, "SPEECH_DTMF_MAXLEN")) && !ast_strlen_zero(tmp2)) {
00708       max_dtmf_len = atoi(tmp2);
00709    }
00710    
00711    /* See if a terminator is specified */
00712    if ((tmp2 = pbx_builtin_getvar_helper(chan, "SPEECH_DTMF_TERMINATOR"))) {
00713       if (ast_strlen_zero(tmp2))
00714          dtmf_terminator = '\0';
00715       else
00716          dtmf_terminator = tmp2[0];
00717    }
00718    ast_channel_unlock(chan);
00719 
00720    /* Before we go into waiting for stuff... make sure the structure is ready, if not - start it again */
00721    if (speech->state == AST_SPEECH_STATE_NOT_READY || speech->state == AST_SPEECH_STATE_DONE) {
00722       ast_speech_change_state(speech, AST_SPEECH_STATE_NOT_READY);
00723       ast_speech_start(speech);
00724    }
00725 
00726    /* Ensure no streams are currently running */
00727    ast_stopstream(chan);
00728 
00729    /* Okay it's streaming so go into a loop grabbing frames! */
00730    while (done == 0) {
00731       /* If the filename is null and stream is not running, start up a new sound file */
00732       if (!quieted && (chan->streamid == -1 && chan->timingfunc == NULL) && (filename = strsep(&filename_tmp, "&"))) {
00733          /* Discard old stream information */
00734          ast_stopstream(chan);
00735          /* Start new stream */
00736          speech_streamfile(chan, filename, chan->language);
00737       }
00738 
00739       /* Run scheduled stuff */
00740       ast_sched_runq(chan->sched);
00741 
00742       /* Yay scheduling */
00743       res = ast_sched_wait(chan->sched);
00744       if (res < 0)
00745          res = 1000;
00746 
00747       /* If there is a frame waiting, get it - if not - oh well */
00748       if (ast_waitfor(chan, res) > 0) {
00749          f = ast_read(chan);
00750          if (f == NULL) {
00751             /* The channel has hung up most likely */
00752             done = 3;
00753             break;
00754          }
00755       }
00756 
00757       /* Do timeout check (shared between audio/dtmf) */
00758       if ((!quieted || strlen(dtmf)) && started == 1) {
00759          current = ast_tvnow();
00760          if ((ast_tvdiff_ms(current, start)) >= timeout) {
00761             done = 1;
00762             if (f)
00763                ast_frfree(f);
00764             break;
00765          }
00766       }
00767 
00768       /* Do checks on speech structure to see if it's changed */
00769       ast_mutex_lock(&speech->lock);
00770       if (ast_test_flag(speech, AST_SPEECH_QUIET)) {
00771          if (chan->stream)
00772             ast_stopstream(chan);
00773          ast_clear_flag(speech, AST_SPEECH_QUIET);
00774          quieted = 1;
00775       }
00776       /* Check state so we can see what to do */
00777       switch (speech->state) {
00778       case AST_SPEECH_STATE_READY:
00779          /* If audio playback has stopped do a check for timeout purposes */
00780          if (chan->streamid == -1 && chan->timingfunc == NULL)
00781             ast_stopstream(chan);
00782          if (!quieted && chan->stream == NULL && timeout && started == 0 && !filename_tmp) {
00783             if (timeout == -1) {
00784                done = 1;
00785                if (f)
00786                   ast_frfree(f);
00787                break;
00788             }
00789             start = ast_tvnow();
00790             started = 1;
00791          }
00792          /* Write audio frame out to speech engine if no DTMF has been received */
00793          if (!strlen(dtmf) && f != NULL && f->frametype == AST_FRAME_VOICE) {
00794             ast_speech_write(speech, f->data.ptr, f->datalen);
00795          }
00796          break;
00797       case AST_SPEECH_STATE_WAIT:
00798          /* Cue up waiting sound if not already playing */
00799          if (!strlen(dtmf)) {
00800             if (chan->stream == NULL) {
00801                if (speech->processing_sound != NULL) {
00802                   if (strlen(speech->processing_sound) > 0 && strcasecmp(speech->processing_sound, "none")) {
00803                      speech_streamfile(chan, speech->processing_sound, chan->language);
00804                   }
00805                }
00806             } else if (chan->streamid == -1 && chan->timingfunc == NULL) {
00807                ast_stopstream(chan);
00808                if (speech->processing_sound != NULL) {
00809                   if (strlen(speech->processing_sound) > 0 && strcasecmp(speech->processing_sound, "none")) {
00810                      speech_streamfile(chan, speech->processing_sound, chan->language);
00811                   }
00812                }
00813             }
00814          }
00815          break;
00816       case AST_SPEECH_STATE_DONE:
00817          /* Now that we are done... let's switch back to not ready state */
00818          ast_speech_change_state(speech, AST_SPEECH_STATE_NOT_READY);
00819          if (!strlen(dtmf)) {
00820             /* Copy to speech structure the results, if available */
00821             speech->results = ast_speech_results_get(speech);
00822             /* Break out of our background too */
00823             done = 1;
00824             /* Stop audio playback */
00825             if (chan->stream != NULL) {
00826                ast_stopstream(chan);
00827             }
00828          }
00829          break;
00830       default:
00831          break;
00832       }
00833       ast_mutex_unlock(&speech->lock);
00834 
00835       /* Deal with other frame types */
00836       if (f != NULL) {
00837          /* Free the frame we received */
00838          switch (f->frametype) {
00839          case AST_FRAME_DTMF:
00840             if (dtmf_terminator != '\0' && f->subclass.integer == dtmf_terminator) {
00841                done = 1;
00842             } else {
00843                quieted = 1;
00844                if (chan->stream != NULL) {
00845                   ast_stopstream(chan);
00846                }
00847                if (!started) {
00848                   /* Change timeout to be 5 seconds for DTMF input */
00849                   timeout = (chan->pbx && chan->pbx->dtimeoutms) ? chan->pbx->dtimeoutms : 5000;
00850                   started = 1;
00851                }
00852                start = ast_tvnow();
00853                snprintf(tmp, sizeof(tmp), "%c", f->subclass.integer);
00854                strncat(dtmf, tmp, sizeof(dtmf) - strlen(dtmf) - 1);
00855                /* If the maximum length of the DTMF has been reached, stop now */
00856                if (max_dtmf_len && strlen(dtmf) == max_dtmf_len)
00857                   done = 1;
00858             }
00859             break;
00860          case AST_FRAME_CONTROL:
00861             switch (f->subclass.integer) {
00862             case AST_CONTROL_HANGUP:
00863                /* Since they hung up we should destroy the speech structure */
00864                done = 3;
00865             default:
00866                break;
00867             }
00868          default:
00869             break;
00870          }
00871          ast_frfree(f);
00872          f = NULL;
00873       }
00874    }
00875 
00876    if (!ast_strlen_zero(dtmf)) {
00877       /* We sort of make a results entry */
00878       speech->results = ast_calloc(1, sizeof(*speech->results));
00879       if (speech->results != NULL) {
00880          ast_speech_dtmf(speech, dtmf);
00881          speech->results->score = 1000;
00882          speech->results->text = ast_strdup(dtmf);
00883          speech->results->grammar = ast_strdup("dtmf");
00884       }
00885       ast_speech_change_state(speech, AST_SPEECH_STATE_NOT_READY);
00886    }
00887 
00888    /* See if it was because they hung up */
00889    if (done == 3) {
00890       /* Destroy speech structure */
00891       ast_speech_destroy(speech);
00892       datastore = ast_channel_datastore_find(chan, &speech_datastore, NULL);
00893       if (datastore != NULL)
00894          ast_channel_datastore_remove(chan, datastore);
00895    } else {
00896       /* Channel is okay so restore read format */
00897       ast_set_read_format(chan, oldreadformat);
00898    }
00899 
00900    return 0;
00901 }

static int speech_create ( struct ast_channel chan,
const char *  data 
) [static]

SpeechCreate() Dialplan Application.

Definition at line 497 of file app_speech_utils.c.

References ast_channel_datastore_add(), ast_datastore_alloc, ast_speech_destroy(), ast_speech_new(), ast_datastore::data, ast_channel::nativeformats, pbx_builtin_setvar_helper(), and speech_datastore.

Referenced by load_module().

00498 {
00499    struct ast_speech *speech = NULL;
00500    struct ast_datastore *datastore = NULL;
00501 
00502    /* Request a speech object */
00503    speech = ast_speech_new(data, chan->nativeformats);
00504    if (speech == NULL) {
00505       /* Not available */
00506       pbx_builtin_setvar_helper(chan, "ERROR", "1");
00507       return 0;
00508    }
00509 
00510    datastore = ast_datastore_alloc(&speech_datastore, NULL);
00511    if (datastore == NULL) {
00512       ast_speech_destroy(speech);
00513       pbx_builtin_setvar_helper(chan, "ERROR", "1");
00514       return 0;
00515    }
00516    pbx_builtin_setvar_helper(chan, "ERROR", NULL);
00517    datastore->data = speech;
00518    ast_channel_datastore_add(chan, datastore);
00519 
00520    return 0;
00521 }

static int speech_deactivate ( struct ast_channel chan,
const char *  data 
) [static]

SpeechDeactivateGrammar(Grammar Name) Dialplan Application.

Definition at line 565 of file app_speech_utils.c.

References ast_speech_grammar_deactivate(), and find_speech().

Referenced by load_module().

00566 {
00567    int res = 0;
00568    struct ast_speech *speech = find_speech(chan);
00569 
00570    if (speech == NULL)
00571       return -1;
00572 
00573    /* Deactivate the grammar on the speech object */
00574    res = ast_speech_grammar_deactivate(speech, data);
00575 
00576    return res;
00577 }

static int speech_destroy ( struct ast_channel chan,
const char *  data 
) [static]

SpeechDestroy() Dialplan Application.

Definition at line 905 of file app_speech_utils.c.

References ast_channel_datastore_find(), ast_channel_datastore_remove(), ast_speech_destroy(), find_speech(), and speech_datastore.

Referenced by load_module().

00906 {
00907    int res = 0;
00908    struct ast_speech *speech = find_speech(chan);
00909    struct ast_datastore *datastore = NULL;
00910 
00911    if (speech == NULL)
00912       return -1;
00913 
00914    /* Destroy speech structure */
00915    ast_speech_destroy(speech);
00916 
00917    datastore = ast_channel_datastore_find(chan, &speech_datastore, NULL);
00918    if (datastore != NULL) {
00919       ast_channel_datastore_remove(chan, datastore);
00920    }
00921 
00922    return res;
00923 }

static int speech_engine_write ( struct ast_channel chan,
const char *  cmd,
char *  data,
const char *  value 
) [static]

SPEECH_ENGINE() Dialplan Function.

Definition at line 405 of file app_speech_utils.c.

References ast_speech_change(), and find_speech().

00406 {
00407    struct ast_speech *speech = find_speech(chan);
00408 
00409    if (data == NULL || speech == NULL) {
00410       return -1;
00411    }
00412 
00413    ast_speech_change(speech, data, value);
00414 
00415    return 0;
00416 }

static int speech_grammar ( struct ast_channel chan,
const char *  cmd,
char *  data,
char *  buf,
size_t  len 
) [static]

SPEECH_GRAMMAR() Dialplan Function.

Definition at line 379 of file app_speech_utils.c.

References ast_copy_string(), find_result(), find_speech(), ast_speech_result::grammar, and ast_speech::results.

00381 {
00382    struct ast_speech_result *result = NULL;
00383    struct ast_speech *speech = find_speech(chan);
00384 
00385    if (data == NULL || speech == NULL || !(result = find_result(speech->results, data))) {
00386       return -1;
00387    }
00388 
00389    if (result->grammar != NULL) {
00390       ast_copy_string(buf, result->grammar, len);
00391    } else {
00392       buf[0] = '\0';
00393    }
00394 
00395    return 0;
00396 }

static int speech_load ( struct ast_channel chan,
const char *  vdata 
) [static]

SpeechLoadGrammar(Grammar Name,Path) Dialplan Application.

Definition at line 524 of file app_speech_utils.c.

References args, AST_APP_ARG, AST_DECLARE_APP_ARGS, ast_speech_grammar_load(), AST_STANDARD_APP_ARGS, ast_strdupa, ast_speech::data, and find_speech().

Referenced by load_module().

00525 {
00526    int res = 0;
00527    struct ast_speech *speech = find_speech(chan);
00528    char *data;
00529    AST_DECLARE_APP_ARGS(args,
00530       AST_APP_ARG(grammar);
00531       AST_APP_ARG(path);
00532    );
00533 
00534    data = ast_strdupa(vdata);
00535    AST_STANDARD_APP_ARGS(args, data);
00536 
00537    if (speech == NULL)
00538       return -1;
00539 
00540    if (args.argc != 2)
00541       return -1;
00542 
00543    /* Load the grammar locally on the object */
00544    res = ast_speech_grammar_load(speech, args.grammar, args.path);
00545 
00546    return res;
00547 }

static int speech_processing_sound ( struct ast_channel chan,
const char *  data 
) [static]

SpeechProcessingSound(Sound File) Dialplan Application.

Definition at line 609 of file app_speech_utils.c.

References ast_free, ast_strdup, find_speech(), and ast_speech::processing_sound.

Referenced by load_module().

00610 {
00611    int res = 0;
00612    struct ast_speech *speech = find_speech(chan);
00613 
00614    if (speech == NULL)
00615       return -1;
00616 
00617    if (speech->processing_sound != NULL) {
00618       ast_free(speech->processing_sound);
00619       speech->processing_sound = NULL;
00620    }
00621 
00622    speech->processing_sound = ast_strdup(data);
00623 
00624    return res;
00625 }

static int speech_read ( struct ast_channel chan,
const char *  cmd,
char *  data,
char *  buf,
size_t  len 
) [static]

SPEECH() Dialplan Function.

Definition at line 447 of file app_speech_utils.c.

References ast_copy_string(), AST_LIST_NEXT, AST_SPEECH_SPOKE, ast_test_flag, find_speech(), and ast_speech::results.

00449 {
00450    int results = 0;
00451    struct ast_speech_result *result = NULL;
00452    struct ast_speech *speech = find_speech(chan);
00453    char tmp[128] = "";
00454 
00455    /* Now go for the various options */
00456    if (!strcasecmp(data, "status")) {
00457       if (speech != NULL)
00458          ast_copy_string(buf, "1", len);
00459       else
00460          ast_copy_string(buf, "0", len);
00461       return 0;
00462    }
00463 
00464    /* Make sure we have a speech structure for everything else */
00465    if (speech == NULL) {
00466       return -1;
00467    }
00468 
00469    /* Check to see if they are checking for silence */
00470    if (!strcasecmp(data, "spoke")) {
00471       if (ast_test_flag(speech, AST_SPEECH_SPOKE))
00472          ast_copy_string(buf, "1", len);
00473       else
00474          ast_copy_string(buf, "0", len);
00475    } else if (!strcasecmp(data, "results")) {
00476       /* Count number of results */
00477       for (result = speech->results; result; result = AST_LIST_NEXT(result, list))
00478          results++;
00479       snprintf(tmp, sizeof(tmp), "%d", results);
00480       ast_copy_string(buf, tmp, len);
00481    } else {
00482       buf[0] = '\0';
00483    }
00484 
00485    return 0;
00486 }

static int speech_results_type_write ( struct ast_channel chan,
const char *  cmd,
char *  data,
const char *  value 
) [static]

SPEECH_RESULTS_TYPE() Dialplan Function.

Definition at line 425 of file app_speech_utils.c.

References ast_speech_change_results_type(), AST_SPEECH_RESULTS_TYPE_NBEST, AST_SPEECH_RESULTS_TYPE_NORMAL, and find_speech().

00426 {
00427    struct ast_speech *speech = find_speech(chan);
00428 
00429    if (data == NULL || speech == NULL)
00430       return -1;
00431 
00432    if (!strcasecmp(value, "normal"))
00433       ast_speech_change_results_type(speech, AST_SPEECH_RESULTS_TYPE_NORMAL);
00434    else if (!strcasecmp(value, "nbest"))
00435       ast_speech_change_results_type(speech, AST_SPEECH_RESULTS_TYPE_NBEST);
00436 
00437    return 0;
00438 }

static int speech_score ( struct ast_channel chan,
const char *  cmd,
char *  data,
char *  buf,
size_t  len 
) [static]

SPEECH_SCORE() Dialplan Function.

Definition at line 328 of file app_speech_utils.c.

References ast_copy_string(), find_result(), find_speech(), ast_speech::results, and ast_speech_result::score.

00330 {
00331    struct ast_speech_result *result = NULL;
00332    struct ast_speech *speech = find_speech(chan);
00333    char tmp[128] = "";
00334 
00335    if (data == NULL || speech == NULL || !(result = find_result(speech->results, data))) {
00336       return -1;
00337    }
00338    
00339    snprintf(tmp, sizeof(tmp), "%d", result->score);
00340    
00341    ast_copy_string(buf, tmp, len);
00342 
00343    return 0;
00344 }

static int speech_start ( struct ast_channel chan,
const char *  data 
) [static]

SpeechStart() Dialplan Application.

Definition at line 595 of file app_speech_utils.c.

References ast_speech_start(), and find_speech().

Referenced by load_module().

00596 {
00597    int res = 0;
00598    struct ast_speech *speech = find_speech(chan);
00599 
00600    if (speech == NULL)
00601       return -1;
00602 
00603    ast_speech_start(speech);
00604 
00605    return res;
00606 }

static int speech_streamfile ( struct ast_channel chan,
const char *  filename,
const char *  preflang 
) [static]

Helper function used by speech_background to playback a soundfile.

Definition at line 628 of file app_speech_utils.c.

References ast_applystream(), ast_openstream(), and ast_playstream().

Referenced by handle_speechrecognize(), and speech_background().

00629 {
00630    struct ast_filestream *fs = NULL;
00631 
00632    if (!(fs = ast_openstream(chan, filename, preflang)))
00633       return -1;
00634    
00635    if (ast_applystream(chan, fs))
00636       return -1;
00637    
00638    ast_playstream(fs);
00639 
00640    return 0;
00641 }

static int speech_text ( struct ast_channel chan,
const char *  cmd,
char *  data,
char *  buf,
size_t  len 
) [static]

SPEECH_TEXT() Dialplan Function.

Definition at line 353 of file app_speech_utils.c.

References ast_copy_string(), find_result(), find_speech(), ast_speech::results, and ast_speech_result::text.

00355 {
00356    struct ast_speech_result *result = NULL;
00357    struct ast_speech *speech = find_speech(chan);
00358 
00359    if (data == NULL || speech == NULL || !(result = find_result(speech->results, data))) {
00360       return -1;
00361    }
00362 
00363    if (result->text != NULL) {
00364       ast_copy_string(buf, result->text, len);
00365    } else {
00366       buf[0] = '\0';
00367    }
00368 
00369    return 0;
00370 }

static int speech_unload ( struct ast_channel chan,
const char *  data 
) [static]

SpeechUnloadGrammar(Grammar Name) Dialplan Application.

Definition at line 550 of file app_speech_utils.c.

References ast_speech_grammar_unload(), and find_speech().

Referenced by load_module().

00551 {
00552    int res = 0;
00553    struct ast_speech *speech = find_speech(chan);
00554 
00555    if (speech == NULL)
00556       return -1;
00557 
00558    /* Unload the grammar */
00559    res = ast_speech_grammar_unload(speech, data);
00560 
00561    return res;
00562 }

static int unload_module ( void   )  [static]

Definition at line 925 of file app_speech_utils.c.

References ast_custom_function_unregister(), ast_unregister_application(), speech_engine_function, speech_function, speech_grammar_function, speech_results_type_function, speech_score_function, and speech_text_function.

00926 {
00927    int res = 0;
00928 
00929    res = ast_unregister_application("SpeechCreate");
00930    res |= ast_unregister_application("SpeechLoadGrammar");
00931    res |= ast_unregister_application("SpeechUnloadGrammar");
00932    res |= ast_unregister_application("SpeechActivateGrammar");
00933    res |= ast_unregister_application("SpeechDeactivateGrammar");
00934    res |= ast_unregister_application("SpeechStart");
00935    res |= ast_unregister_application("SpeechBackground");
00936    res |= ast_unregister_application("SpeechDestroy");
00937    res |= ast_unregister_application("SpeechProcessingSound");
00938    res |= ast_custom_function_unregister(&speech_function);
00939    res |= ast_custom_function_unregister(&speech_score_function);
00940    res |= ast_custom_function_unregister(&speech_text_function);
00941    res |= ast_custom_function_unregister(&speech_grammar_function);
00942    res |= ast_custom_function_unregister(&speech_engine_function);
00943    res |= ast_custom_function_unregister(&speech_results_type_function);
00944 
00945    return res; 
00946 }


Variable Documentation

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "Dialplan Speech Applications" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "ac1f6a56484a8820659555499174e588" , .load = load_module, .unload = unload_module, .nonoptreq = "res_speech", } [static]

Definition at line 975 of file app_speech_utils.c.

struct ast_module_info* ast_module_info = &__mod_info [static]

Definition at line 975 of file app_speech_utils.c.

struct ast_app_option speech_background_options[128] = { [ 'n' ] = { .flag = SB_OPT_NOANSWER }, } [static]

Definition at line 649 of file app_speech_utils.c.

Referenced by speech_background().

struct ast_datastore_info speech_datastore [static]

Initial value:

 {
   .type = "speech",
   .destroy = destroy_callback
}
Static structure for datastore information.

Definition at line 277 of file app_speech_utils.c.

Referenced by find_speech(), speech_background(), speech_create(), and speech_destroy().

struct ast_custom_function speech_engine_function [static]

Initial value:

 {
   .name = "SPEECH_ENGINE",
   .read = NULL,
   .write = speech_engine_write,
}

Definition at line 418 of file app_speech_utils.c.

Referenced by load_module(), and unload_module().

struct ast_custom_function speech_function [static]

Initial value:

 {
   .name = "SPEECH",
   .read = speech_read,
   .write = NULL,
}

Definition at line 488 of file app_speech_utils.c.

Referenced by load_module(), and unload_module().

struct ast_custom_function speech_grammar_function [static]

Initial value:

 {
   .name = "SPEECH_GRAMMAR",
   .read = speech_grammar,
   .write = NULL,
}

Definition at line 398 of file app_speech_utils.c.

Referenced by load_module(), and unload_module().

struct ast_custom_function speech_results_type_function [static]

Initial value:

 {
   .name = "SPEECH_RESULTS_TYPE",
   .read = NULL,
   .write = speech_results_type_write,
}

Definition at line 440 of file app_speech_utils.c.

Referenced by load_module(), and unload_module().

struct ast_custom_function speech_score_function [static]

Initial value:

 {
   .name = "SPEECH_SCORE",
   .read = speech_score,
   .write = NULL,
}

Definition at line 346 of file app_speech_utils.c.

Referenced by load_module(), and unload_module().

struct ast_custom_function speech_text_function [static]

Initial value:

 {
   .name = "SPEECH_TEXT",
   .read = speech_text,
   .write = NULL,
}

Definition at line 372 of file app_speech_utils.c.

Referenced by load_module(), and unload_module().


Generated on Mon Oct 8 12:39:08 2012 for Asterisk - The Open Source Telephony Project by  doxygen 1.4.7