apps/app_milliwatt.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 1999 - 2005, Digium, Inc.
   5  *
   6  * Mark Spencer <markster@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 Digital Milliwatt Test
  22  *
  23  * \author Mark Spencer <markster@digium.com>
  24  *
  25  * \ingroup applications
  26  */
  27
  28 /*** MODULEINFO
  29         <depend>res_indications</depend>
  30  ***/
  31
  32 #include "asterisk.h"
  33
  34 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  35
  36 #include "asterisk/module.h"
  37 #include "asterisk/channel.h"
  38 #include "asterisk/pbx.h"
  39
  40 static char *app = "Milliwatt";
  41
  42 static char *synopsis = "Generate a Constant 1004Hz tone at 0dbm (mu-law)";
  43
  44 static char *descrip =
  45 "   Milliwatt([options]): Generate a Constant 1004Hz tone at 0dbm.\n"
  46 "Previous versions of this application generated the tone at 1000Hz.  If for\n"
  47 "some reason you would prefer that behavior, supply the 'o' option to get the\n"
  48 "old behavior.\n"
  49 "";
  50
  51 static char digital_milliwatt[] = {0x1e,0x0b,0x0b,0x1e,0x9e,0x8b,0x8b,0x9e} ;
  52
  53 static void *milliwatt_alloc(struct ast_channel *chan, void *params)
  54 {
  55         return ast_calloc(1, sizeof(int));
  56 }
  57
  58 static void milliwatt_release(struct ast_channel *chan, void *data)
  59 {
  60         ast_free(data);
  61         return;
  62 }
  63
  64 static int milliwatt_generate(struct ast_channel *chan, void *data, int len, int samples)
  65 {
  66         unsigned char buf[AST_FRIENDLY_OFFSET + 640];
  67         const int maxsamples = ARRAY_LEN(buf);
  68         int i, *indexp = (int *) data;
  69         struct ast_frame wf = {
  70                 .frametype = AST_FRAME_VOICE,
  71                 .subclass = AST_FORMAT_ULAW,
  72                 .offset = AST_FRIENDLY_OFFSET,
  73                 .src = __FUNCTION__,
  74         };
  75         wf.data.ptr = buf + AST_FRIENDLY_OFFSET;
  76
  77         /* Instead of len, use samples, because channel.c generator_force
  78         * generate(chan, tmp, 0, 160) ignores len. In any case, len is
  79         * a multiple of samples, given by number of samples times bytes per
  80         * sample. In the case of ulaw, len = samples. for signed linear
  81         * len = 2 * samples */
  82         if (samples > maxsamples) {
  83                 ast_log(LOG_WARNING, "Only doing %d samples (%d requested)\n", maxsamples, samples);
  84                 samples = maxsamples;
  85         }
  86
  87         len = samples * sizeof (buf[0]);
  88         wf.datalen = len;
  89         wf.samples = samples;
  90
  91         /* create a buffer containing the digital milliwatt pattern */
  92         for (i = 0; i < len; i++) {
  93                 buf[AST_FRIENDLY_OFFSET + i] = digital_milliwatt[(*indexp)++];
  94                 *indexp &= 7;
  95         }
  96
  97         if (ast_write(chan,&wf) < 0) {
  98                 ast_log(LOG_WARNING,"Failed to write frame to '%s': %s\n",chan->name,strerror(errno));
  99                 return -1;
 100         }
 101
 102         return 0;
 103 }
 104
 105 static struct ast_generator milliwattgen = {
 106         alloc: milliwatt_alloc,
 107         release: milliwatt_release,
 108         generate: milliwatt_generate,
 109 };
 110
 111 static int old_milliwatt_exec(struct ast_channel *chan)
 112 {
 113         ast_set_write_format(chan, AST_FORMAT_ULAW);
 114         ast_set_read_format(chan, AST_FORMAT_ULAW);
 115
 116         if (chan->_state != AST_STATE_UP) {
 117                 ast_answer(chan);
 118         }
 119
 120         if (ast_activate_generator(chan,&milliwattgen,"milliwatt") < 0) {
 121                 ast_log(LOG_WARNING,"Failed to activate generator on '%s'\n",chan->name);
 122                 return -1;
 123         }
 124
 125         while (!ast_safe_sleep(chan, 10000))
 126                 ;
 127
 128         ast_deactivate_generator(chan);
 129
 130         return -1;
 131 }
 132
 133 static int milliwatt_exec(struct ast_channel *chan, void *data)
 134 {
 135         const char *options = data;
 136         struct ast_app *playtones_app;
 137         int res = -1;
 138
 139         if (!ast_strlen_zero(options) && strchr(options, 'o')) {
 140                 return old_milliwatt_exec(chan);
 141         }
 142
 143         if (!(playtones_app = pbx_findapp("Playtones"))) {
 144                 ast_log(LOG_ERROR, "The Playtones application is required to run Milliwatt()\n");
 145                 return -1;
 146         }
 147
 148         res = pbx_exec(chan, playtones_app, "1004/1000");
 149
 150         while (!res) {
 151                 res = ast_safe_sleep(chan, 10000);
 152         }
 153
 154         return res;
 155 }
 156
 157 static int unload_module(void)
 158 {
 159         return ast_unregister_application(app);
 160 }
 161
 162 static int load_module(void)
 163 {
 164         return ast_register_application(app, milliwatt_exec, synopsis, descrip);
 165 }
 166
 167 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Digital Milliwatt (mu-law) Test Application");