893a5dec0a897a0320c48456b60a965ebe487eda
[asterisk/asterisk.git] / apps / app_jack.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2007 - 2008, Russell Bryant
5  *
6  * Russell Bryant <russell@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 /*!
20  * \file
21  * \brief Jack Application
22  *
23  * \author Russell Bryant <russell@digium.com>
24  *
25  * This is an application to connect an Asterisk channel to an input
26  * and output jack port so that the audio can be processed through
27  * another application, or to play audio from another application.
28  *
29  * \extref http://www.jackaudio.org/
30  *
31  * \note To install libresample, check it out of the following repository:
32  * <code>$ svn co http://svn.digium.com/svn/thirdparty/libresample/trunk</code>
33  *
34  * \ingroup applications
35  */
36
37 /*** MODULEINFO
38         <depend>jack</depend>
39         <depend>resample</depend>
40         <support_level>extended</support_level>
41  ***/
42
43 #include "asterisk.h"
44
45 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
46
47 #include <limits.h>
48
49 #include <jack/jack.h>
50 #include <jack/ringbuffer.h>
51
52 #include <libresample.h>
53
54 #include "asterisk/module.h"
55 #include "asterisk/channel.h"
56 #include "asterisk/strings.h"
57 #include "asterisk/lock.h"
58 #include "asterisk/app.h"
59 #include "asterisk/pbx.h"
60 #include "asterisk/audiohook.h"
61
62 #define RESAMPLE_QUALITY 1
63
64 #define RINGBUFFER_SIZE 16384
65
66 /*! \brief Common options between the Jack() app and JACK_HOOK() function */
67 #define COMMON_OPTIONS \
68 "    s(<name>) - Connect to the specified jack server name.\n" \
69 "    i(<name>) - Connect the output port that gets created to the specified\n" \
70 "                jack input port.\n" \
71 "    o(<name>) - Connect the input port that gets created to the specified\n" \
72 "                jack output port.\n" \
73 "    n         - Do not automatically start the JACK server if it is not already\n" \
74 "                running.\n" \
75 "    c(<name>) - By default, Asterisk will use the channel name for the jack client\n" \
76 "                name.  Use this option to specify a custom client name.\n"
77 /*** DOCUMENTATION
78         <application name="JACK" language="en_US">
79                 <synopsis>
80                         Jack Audio Connection Kit
81                 </synopsis>
82                 <syntax>
83                         <parameter name="options" required="false">
84                                 <optionlist>
85                                         <option name="s">
86                                                 <argument name="name" required="true">
87                                                         <para>Connect to the specified jack server name</para>
88                                                 </argument>
89                                         </option>
90                                         <option name="i">
91                                                 <argument name="name" required="true">
92                                                         <para>Connect the output port that gets created to the specified jack input port</para>
93                                                 </argument>
94                                         </option>
95                                         <option name="o">
96                                                 <argument name="name" required="true">
97                                                         <para>Connect the input port that gets created to the specified jack output port</para>
98                                                 </argument>
99                                         </option>
100                                         <option name="c">
101                                                 <argument name="name" required="true">
102                                                         <para>By default, Asterisk will use the channel name for the jack client name.</para>
103                                                         <para>Use this option to specify a custom client name.</para>
104                                                 </argument>
105                                         </option>
106                                 </optionlist>
107                         </parameter>
108                 </syntax>
109                 <description>
110                         <para>When executing this application, two jack ports will be created;
111                         one input and one output. Other applications can be hooked up to
112                         these ports to access audio coming from, or being send to the channel.</para>
113                 </description>
114         </application>
115  ***/
116
117 static const char jack_app[] = "JACK";
118
119 struct jack_data {
120         AST_DECLARE_STRING_FIELDS(
121                 AST_STRING_FIELD(server_name);
122                 AST_STRING_FIELD(client_name);
123                 AST_STRING_FIELD(connect_input_port);
124                 AST_STRING_FIELD(connect_output_port);
125         );
126         jack_client_t *client;
127         jack_port_t *input_port;
128         jack_port_t *output_port;
129         jack_ringbuffer_t *input_rb;
130         jack_ringbuffer_t *output_rb;
131         void *output_resampler;
132         double output_resample_factor;
133         void *input_resampler;
134         double input_resample_factor;
135         unsigned int stop:1;
136         unsigned int has_audiohook:1;
137         unsigned int no_start_server:1;
138         /*! Only used with JACK_HOOK */
139         struct ast_audiohook audiohook;
140 };
141
142 static const struct {
143         jack_status_t status;
144         const char *str;
145 } jack_status_table[] = {
146         { JackFailure,        "Failure" },
147         { JackInvalidOption,  "Invalid Option" },
148         { JackNameNotUnique,  "Name Not Unique" },
149         { JackServerStarted,  "Server Started" },
150         { JackServerFailed,   "Server Failed" },
151         { JackServerError,    "Server Error" },
152         { JackNoSuchClient,   "No Such Client" },
153         { JackLoadFailure,    "Load Failure" },
154         { JackInitFailure,    "Init Failure" },
155         { JackShmFailure,     "Shared Memory Access Failure" },
156         { JackVersionError,   "Version Mismatch" },
157 };
158
159 static const char *jack_status_to_str(jack_status_t status)
160 {
161         int i;
162
163         for (i = 0; i < ARRAY_LEN(jack_status_table); i++) {
164                 if (jack_status_table[i].status == status)
165                         return jack_status_table[i].str;
166         }
167
168         return "Unknown Error";
169 }
170
171 static void log_jack_status(const char *prefix, jack_status_t status)
172 {
173         struct ast_str *str = ast_str_alloca(512);
174         int i, first = 0;
175
176         for (i = 0; i < (sizeof(status) * 8); i++) {
177                 if (!(status & (1 << i)))
178                         continue;
179
180                 if (!first) {
181                         ast_str_set(&str, 0, "%s", jack_status_to_str((1 << i)));
182                         first = 1;
183                 } else
184                         ast_str_append(&str, 0, ", %s", jack_status_to_str((1 << i)));
185         }
186
187         ast_log(LOG_NOTICE, "%s: %s\n", prefix, ast_str_buffer(str));
188 }
189
190 static int alloc_resampler(struct jack_data *jack_data, int input)
191 {
192         double from_srate, to_srate, jack_srate;
193         void **resampler;
194         double *resample_factor;
195
196         if (input && jack_data->input_resampler)
197                 return 0;
198
199         if (!input && jack_data->output_resampler)
200                 return 0;
201
202         jack_srate = jack_get_sample_rate(jack_data->client);
203
204         /* XXX Hard coded 8 kHz */
205
206         to_srate = input ? 8000.0 : jack_srate;
207         from_srate = input ? jack_srate : 8000.0;
208
209         resample_factor = input ? &jack_data->input_resample_factor :
210                 &jack_data->output_resample_factor;
211
212         if (from_srate == to_srate) {
213                 /* Awesome!  The jack sample rate is the same as ours.
214                  * Resampling isn't needed. */
215                 *resample_factor = 1.0;
216                 return 0;
217         }
218
219         *resample_factor = to_srate / from_srate;
220
221         resampler = input ? &jack_data->input_resampler :
222                 &jack_data->output_resampler;
223
224         if (!(*resampler = resample_open(RESAMPLE_QUALITY,
225                 *resample_factor, *resample_factor))) {
226                 ast_log(LOG_ERROR, "Failed to open %s resampler\n",
227                         input ? "input" : "output");
228                 return -1;
229         }
230
231         return 0;
232 }
233
234 /*!
235  * \brief Handle jack input port
236  *
237  * Read nframes number of samples from the input buffer, resample it
238  * if necessary, and write it into the appropriate ringbuffer.
239  */
240 static void handle_input(void *buf, jack_nframes_t nframes,
241         struct jack_data *jack_data)
242 {
243         short s_buf[nframes];
244         float *in_buf = buf;
245         size_t res;
246         int i;
247         size_t write_len = sizeof(s_buf);
248
249         if (jack_data->input_resampler) {
250                 int total_in_buf_used = 0;
251                 int total_out_buf_used = 0;
252                 float f_buf[nframes + 1];
253
254                 memset(f_buf, 0, sizeof(f_buf));
255
256                 while (total_in_buf_used < nframes) {
257                         int in_buf_used;
258                         int out_buf_used;
259
260                         out_buf_used = resample_process(jack_data->input_resampler,
261                                 jack_data->input_resample_factor,
262                                 &in_buf[total_in_buf_used], nframes - total_in_buf_used,
263                                 0, &in_buf_used,
264                                 &f_buf[total_out_buf_used], ARRAY_LEN(f_buf) - total_out_buf_used);
265
266                         if (out_buf_used < 0)
267                                 break;
268
269                         total_out_buf_used += out_buf_used;
270                         total_in_buf_used += in_buf_used;
271
272                         if (total_out_buf_used == ARRAY_LEN(f_buf)) {
273                                 ast_log(LOG_ERROR, "Output buffer filled ... need to increase its size, "
274                                         "nframes '%d', total_out_buf_used '%d'\n", nframes, total_out_buf_used);
275                                 break;
276                         }
277                 }
278
279                 for (i = 0; i < total_out_buf_used; i++)
280                         s_buf[i] = f_buf[i] * (SHRT_MAX / 1.0);
281
282                 write_len = total_out_buf_used * sizeof(int16_t);
283         } else {
284                 /* No resampling needed */
285
286                 for (i = 0; i < nframes; i++)
287                         s_buf[i] = in_buf[i] * (SHRT_MAX / 1.0);
288         }
289
290         res = jack_ringbuffer_write(jack_data->input_rb, (const char *) s_buf, write_len);
291         if (res != write_len) {
292                 ast_debug(2, "Tried to write %d bytes to the ringbuffer, but only wrote %d\n",
293                         (int) sizeof(s_buf), (int) res);
294         }
295 }
296
297 /*!
298  * \brief Handle jack output port
299  *
300  * Read nframes number of samples from the ringbuffer and write it out to the
301  * output port buffer.
302  */
303 static void handle_output(void *buf, jack_nframes_t nframes,
304         struct jack_data *jack_data)
305 {
306         size_t res, len;
307
308         len = nframes * sizeof(float);
309
310         res = jack_ringbuffer_read(jack_data->output_rb, buf, len);
311
312         if (len != res) {
313                 ast_debug(2, "Wanted %d bytes to send to the output port, "
314                         "but only got %d\n", (int) len, (int) res);
315         }
316 }
317
318 static int jack_process(jack_nframes_t nframes, void *arg)
319 {
320         struct jack_data *jack_data = arg;
321         void *input_port_buf, *output_port_buf;
322
323         if (!jack_data->input_resample_factor)
324                 alloc_resampler(jack_data, 1);
325
326         input_port_buf = jack_port_get_buffer(jack_data->input_port, nframes);
327         handle_input(input_port_buf, nframes, jack_data);
328
329         output_port_buf = jack_port_get_buffer(jack_data->output_port, nframes);
330         handle_output(output_port_buf, nframes, jack_data);
331
332         return 0;
333 }
334
335 static void jack_shutdown(void *arg)
336 {
337         struct jack_data *jack_data = arg;
338
339         jack_data->stop = 1;
340 }
341
342 static struct jack_data *destroy_jack_data(struct jack_data *jack_data)
343 {
344         if (jack_data->input_port) {
345                 jack_port_unregister(jack_data->client, jack_data->input_port);
346                 jack_data->input_port = NULL;
347         }
348
349         if (jack_data->output_port) {
350                 jack_port_unregister(jack_data->client, jack_data->output_port);
351                 jack_data->output_port = NULL;
352         }
353
354         if (jack_data->client) {
355                 jack_client_close(jack_data->client);
356                 jack_data->client = NULL;
357         }
358
359         if (jack_data->input_rb) {
360                 jack_ringbuffer_free(jack_data->input_rb);
361                 jack_data->input_rb = NULL;
362         }
363
364         if (jack_data->output_rb) {
365                 jack_ringbuffer_free(jack_data->output_rb);
366                 jack_data->output_rb = NULL;
367         }
368
369         if (jack_data->output_resampler) {
370                 resample_close(jack_data->output_resampler);
371                 jack_data->output_resampler = NULL;
372         }
373
374         if (jack_data->input_resampler) {
375                 resample_close(jack_data->input_resampler);
376                 jack_data->input_resampler = NULL;
377         }
378
379         if (jack_data->has_audiohook)
380                 ast_audiohook_destroy(&jack_data->audiohook);
381
382         ast_string_field_free_memory(jack_data);
383
384         ast_free(jack_data);
385
386         return NULL;
387 }
388
389 static int init_jack_data(struct ast_channel *chan, struct jack_data *jack_data)
390 {
391         const char *client_name;
392         jack_status_t status = 0;
393         jack_options_t jack_options = JackNullOption;
394
395         if (!ast_strlen_zero(jack_data->client_name)) {
396                 client_name = jack_data->client_name;
397         } else {
398                 ast_channel_lock(chan);
399                 client_name = ast_strdupa(chan->name);
400                 ast_channel_unlock(chan);
401         }
402
403         if (!(jack_data->output_rb = jack_ringbuffer_create(RINGBUFFER_SIZE)))
404                 return -1;
405
406         if (!(jack_data->input_rb = jack_ringbuffer_create(RINGBUFFER_SIZE)))
407                 return -1;
408
409         if (jack_data->no_start_server)
410                 jack_options |= JackNoStartServer;
411
412         if (!ast_strlen_zero(jack_data->server_name)) {
413                 jack_options |= JackServerName;
414                 jack_data->client = jack_client_open(client_name, jack_options, &status,
415                         jack_data->server_name);
416         } else {
417                 jack_data->client = jack_client_open(client_name, jack_options, &status);
418         }
419
420         if (status)
421                 log_jack_status("Client Open Status", status);
422
423         if (!jack_data->client)
424                 return -1;
425
426         jack_data->input_port = jack_port_register(jack_data->client, "input",
427                 JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput | JackPortIsTerminal, 0);
428         if (!jack_data->input_port) {
429                 ast_log(LOG_ERROR, "Failed to create input port for jack port\n");
430                 return -1;
431         }
432
433         jack_data->output_port = jack_port_register(jack_data->client, "output",
434                 JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput | JackPortIsTerminal, 0);
435         if (!jack_data->output_port) {
436                 ast_log(LOG_ERROR, "Failed to create output port for jack port\n");
437                 return -1;
438         }
439
440         if (jack_set_process_callback(jack_data->client, jack_process, jack_data)) {
441                 ast_log(LOG_ERROR, "Failed to register process callback with jack client\n");
442                 return -1;
443         }
444
445         jack_on_shutdown(jack_data->client, jack_shutdown, jack_data);
446
447         if (jack_activate(jack_data->client)) {
448                 ast_log(LOG_ERROR, "Unable to activate jack client\n");
449                 return -1;
450         }
451
452         while (!ast_strlen_zero(jack_data->connect_input_port)) {
453                 const char **ports;
454                 int i;
455
456                 ports = jack_get_ports(jack_data->client, jack_data->connect_input_port,
457                         NULL, JackPortIsInput);
458
459                 if (!ports) {
460                         ast_log(LOG_ERROR, "No input port matching '%s' was found\n",
461                                 jack_data->connect_input_port);
462                         break;
463                 }
464
465                 for (i = 0; ports[i]; i++) {
466                         ast_debug(1, "Found port '%s' that matched specified input port '%s'\n",
467                                 ports[i], jack_data->connect_input_port);
468                 }
469
470                 if (jack_connect(jack_data->client, jack_port_name(jack_data->output_port), ports[0])) {
471                         ast_log(LOG_ERROR, "Failed to connect '%s' to '%s'\n", ports[0],
472                                 jack_port_name(jack_data->output_port));
473                 } else {
474                         ast_debug(1, "Connected '%s' to '%s'\n", ports[0],
475                                 jack_port_name(jack_data->output_port));
476                 }
477
478                 free((void *) ports);
479
480                 break;
481         }
482
483         while (!ast_strlen_zero(jack_data->connect_output_port)) {
484                 const char **ports;
485                 int i;
486
487                 ports = jack_get_ports(jack_data->client, jack_data->connect_output_port,
488                         NULL, JackPortIsOutput);
489
490                 if (!ports) {
491                         ast_log(LOG_ERROR, "No output port matching '%s' was found\n",
492                                 jack_data->connect_output_port);
493                         break;
494                 }
495
496                 for (i = 0; ports[i]; i++) {
497                         ast_debug(1, "Found port '%s' that matched specified output port '%s'\n",
498                                 ports[i], jack_data->connect_output_port);
499                 }
500
501                 if (jack_connect(jack_data->client, ports[0], jack_port_name(jack_data->input_port))) {
502                         ast_log(LOG_ERROR, "Failed to connect '%s' to '%s'\n", ports[0],
503                                 jack_port_name(jack_data->input_port));
504                 } else {
505                         ast_debug(1, "Connected '%s' to '%s'\n", ports[0],
506                                 jack_port_name(jack_data->input_port));
507                 }
508
509                 free((void *) ports);
510
511                 break;
512         }
513
514         return 0;
515 }
516
517 static int queue_voice_frame(struct jack_data *jack_data, struct ast_frame *f)
518 {
519         float f_buf[f->samples * 8];
520         size_t f_buf_used = 0;
521         int i;
522         int16_t *s_buf = f->data.ptr;
523         size_t res;
524
525         memset(f_buf, 0, sizeof(f_buf));
526
527         if (!jack_data->output_resample_factor)
528                 alloc_resampler(jack_data, 0);
529
530         if (jack_data->output_resampler) {
531                 float in_buf[f->samples];
532                 int total_in_buf_used = 0;
533                 int total_out_buf_used = 0;
534
535                 memset(in_buf, 0, sizeof(in_buf));
536
537                 for (i = 0; i < f->samples; i++)
538                         in_buf[i] = s_buf[i] * (1.0 / SHRT_MAX);
539
540                 while (total_in_buf_used < ARRAY_LEN(in_buf)) {
541                         int in_buf_used;
542                         int out_buf_used;
543
544                         out_buf_used = resample_process(jack_data->output_resampler,
545                                 jack_data->output_resample_factor,
546                                 &in_buf[total_in_buf_used], ARRAY_LEN(in_buf) - total_in_buf_used,
547                                 0, &in_buf_used,
548                                 &f_buf[total_out_buf_used], ARRAY_LEN(f_buf) - total_out_buf_used);
549
550                         if (out_buf_used < 0)
551                                 break;
552
553                         total_out_buf_used += out_buf_used;
554                         total_in_buf_used += in_buf_used;
555
556                         if (total_out_buf_used == ARRAY_LEN(f_buf)) {
557                                 ast_log(LOG_ERROR, "Output buffer filled ... need to increase its size\n");
558                                 break;
559                         }
560                 }
561
562                 f_buf_used = total_out_buf_used;
563                 if (f_buf_used > ARRAY_LEN(f_buf))
564                         f_buf_used = ARRAY_LEN(f_buf);
565         } else {
566                 /* No resampling needed */
567
568                 for (i = 0; i < f->samples; i++)
569                         f_buf[i] = s_buf[i] * (1.0 / SHRT_MAX);
570
571                 f_buf_used = f->samples;
572         }
573
574         res = jack_ringbuffer_write(jack_data->output_rb, (const char *) f_buf, f_buf_used * sizeof(float));
575         if (res != (f_buf_used * sizeof(float))) {
576                 ast_debug(2, "Tried to write %d bytes to the ringbuffer, but only wrote %d\n",
577                         (int) (f_buf_used * sizeof(float)), (int) res);
578         }
579
580         return 0;
581 }
582
583 /*!
584  * \brief handle jack audio
585  *
586  * \param[in]  chan The Asterisk channel to write the frames to if no output frame
587  *             is provided.
588  * \param[in]  jack_data This is the jack_data struct that contains the input
589  *             ringbuffer that audio will be read from.
590  * \param[out] out_frame If this argument is non-NULL, then assuming there is
591  *             enough data avilable in the ringbuffer, the audio in this frame
592  *             will get replaced with audio from the input buffer.  If there is
593  *             not enough data available to read at this time, then the frame
594  *             data gets zeroed out.
595  *
596  * Read data from the input ringbuffer, which is the properly resampled audio
597  * that was read from the jack input port.  Write it to the channel in 20 ms frames,
598  * or fill up an output frame instead if one is provided.
599  *
600  * \return Nothing.
601  */
602 static void handle_jack_audio(struct ast_channel *chan, struct jack_data *jack_data,
603         struct ast_frame *out_frame)
604 {
605         short buf[160];
606         struct ast_frame f = {
607                 .frametype = AST_FRAME_VOICE,
608                 .src = "JACK",
609                 .data.ptr = buf,
610                 .datalen = sizeof(buf),
611                 .samples = ARRAY_LEN(buf),
612         };
613         ast_format_set(&f.subclass.format, AST_FORMAT_SLINEAR, 0);
614
615         for (;;) {
616                 size_t res, read_len;
617                 char *read_buf;
618
619                 read_len = out_frame ? out_frame->datalen : sizeof(buf);
620                 read_buf = out_frame ? out_frame->data.ptr : buf;
621
622                 res = jack_ringbuffer_read_space(jack_data->input_rb);
623
624                 if (res < read_len) {
625                         /* Not enough data ready for another frame, move on ... */
626                         if (out_frame) {
627                                 ast_debug(1, "Sending an empty frame for the JACK_HOOK\n");
628                                 memset(out_frame->data.ptr, 0, out_frame->datalen);
629                         }
630                         break;
631                 }
632
633                 res = jack_ringbuffer_read(jack_data->input_rb, (char *) read_buf, read_len);
634
635                 if (res < read_len) {
636                         ast_log(LOG_ERROR, "Error reading from ringbuffer, even though it said there was enough data\n");
637                         break;
638                 }
639
640                 if (out_frame) {
641                         /* If an output frame was provided, then we just want to fill up the
642                          * buffer in that frame and return. */
643                         break;
644                 }
645
646                 ast_write(chan, &f);
647         }
648 }
649
650 enum {
651         OPT_SERVER_NAME =    (1 << 0),
652         OPT_INPUT_PORT =     (1 << 1),
653         OPT_OUTPUT_PORT =    (1 << 2),
654         OPT_NOSTART_SERVER = (1 << 3),
655         OPT_CLIENT_NAME =    (1 << 4),
656 };
657
658 enum {
659         OPT_ARG_SERVER_NAME,
660         OPT_ARG_INPUT_PORT,
661         OPT_ARG_OUTPUT_PORT,
662         OPT_ARG_CLIENT_NAME,
663
664         /* Must be the last element */
665         OPT_ARG_ARRAY_SIZE,
666 };
667
668 AST_APP_OPTIONS(jack_exec_options, BEGIN_OPTIONS
669         AST_APP_OPTION_ARG('s', OPT_SERVER_NAME, OPT_ARG_SERVER_NAME),
670         AST_APP_OPTION_ARG('i', OPT_INPUT_PORT, OPT_ARG_INPUT_PORT),
671         AST_APP_OPTION_ARG('o', OPT_OUTPUT_PORT, OPT_ARG_OUTPUT_PORT),
672         AST_APP_OPTION('n', OPT_NOSTART_SERVER),
673         AST_APP_OPTION_ARG('c', OPT_CLIENT_NAME, OPT_ARG_CLIENT_NAME),
674 END_OPTIONS );
675
676 static struct jack_data *jack_data_alloc(void)
677 {
678         struct jack_data *jack_data;
679
680         if (!(jack_data = ast_calloc_with_stringfields(1, struct jack_data, 32))) {
681                 return NULL;
682         }
683
684         return jack_data;
685 }
686
687 /*!
688  * \note This must be done before calling init_jack_data().
689  */
690 static int handle_options(struct jack_data *jack_data, const char *__options_str)
691 {
692         struct ast_flags options = { 0, };
693         char *option_args[OPT_ARG_ARRAY_SIZE];
694         char *options_str;
695
696         options_str = ast_strdupa(__options_str);
697
698         ast_app_parse_options(jack_exec_options, &options, option_args, options_str);
699
700         if (ast_test_flag(&options, OPT_SERVER_NAME)) {
701                 if (!ast_strlen_zero(option_args[OPT_ARG_SERVER_NAME]))
702                         ast_string_field_set(jack_data, server_name, option_args[OPT_ARG_SERVER_NAME]);
703                 else {
704                         ast_log(LOG_ERROR, "A server name must be provided with the s() option\n");
705                         return -1;
706                 }
707         }
708
709         if (ast_test_flag(&options, OPT_CLIENT_NAME)) {
710                 if (!ast_strlen_zero(option_args[OPT_ARG_CLIENT_NAME]))
711                         ast_string_field_set(jack_data, client_name, option_args[OPT_ARG_CLIENT_NAME]);
712                 else {
713                         ast_log(LOG_ERROR, "A client name must be provided with the c() option\n");
714                         return -1;
715                 }
716         }
717
718         if (ast_test_flag(&options, OPT_INPUT_PORT)) {
719                 if (!ast_strlen_zero(option_args[OPT_ARG_INPUT_PORT]))
720                         ast_string_field_set(jack_data, connect_input_port, option_args[OPT_ARG_INPUT_PORT]);
721                 else {
722                         ast_log(LOG_ERROR, "A name must be provided with the i() option\n");
723                         return -1;
724                 }
725         }
726
727         if (ast_test_flag(&options, OPT_OUTPUT_PORT)) {
728                 if (!ast_strlen_zero(option_args[OPT_ARG_OUTPUT_PORT]))
729                         ast_string_field_set(jack_data, connect_output_port, option_args[OPT_ARG_OUTPUT_PORT]);
730                 else {
731                         ast_log(LOG_ERROR, "A name must be provided with the o() option\n");
732                         return -1;
733                 }
734         }
735
736         jack_data->no_start_server = ast_test_flag(&options, OPT_NOSTART_SERVER) ? 1 : 0;
737
738         return 0;
739 }
740
741 static int jack_exec(struct ast_channel *chan, const char *data)
742 {
743         struct jack_data *jack_data;
744
745         if (!(jack_data = jack_data_alloc()))
746                 return -1;
747
748         if (!ast_strlen_zero(data) && handle_options(jack_data, data)) {
749                 destroy_jack_data(jack_data);
750                 return -1;
751         }
752
753         if (init_jack_data(chan, jack_data)) {
754                 destroy_jack_data(jack_data);
755                 return -1;
756         }
757
758         if (ast_set_read_format_by_id(chan, AST_FORMAT_SLINEAR)) {
759                 destroy_jack_data(jack_data);
760                 return -1;
761         }
762
763         if (ast_set_write_format_by_id(chan, AST_FORMAT_SLINEAR)) {
764                 destroy_jack_data(jack_data);
765                 return -1;
766         }
767
768         while (!jack_data->stop) {
769                 struct ast_frame *f;
770
771                 ast_waitfor(chan, -1);
772
773                 f = ast_read(chan);
774                 if (!f) {
775                         jack_data->stop = 1;
776                         continue;
777                 }
778
779                 switch (f->frametype) {
780                 case AST_FRAME_CONTROL:
781                         if (f->subclass.integer == AST_CONTROL_HANGUP)
782                                 jack_data->stop = 1;
783                         break;
784                 case AST_FRAME_VOICE:
785                         queue_voice_frame(jack_data, f);
786                 default:
787                         break;
788                 }
789
790                 ast_frfree(f);
791
792                 handle_jack_audio(chan, jack_data, NULL);
793         }
794
795         jack_data = destroy_jack_data(jack_data);
796
797         return 0;
798 }
799
800 static void jack_hook_ds_destroy(void *data)
801 {
802         struct jack_data *jack_data = data;
803
804         destroy_jack_data(jack_data);
805 }
806
807 static const struct ast_datastore_info jack_hook_ds_info = {
808         .type = "JACK_HOOK",
809         .destroy = jack_hook_ds_destroy,
810 };
811
812 static int jack_hook_callback(struct ast_audiohook *audiohook, struct ast_channel *chan,
813         struct ast_frame *frame, enum ast_audiohook_direction direction)
814 {
815         struct ast_datastore *datastore;
816         struct jack_data *jack_data;
817
818         if (audiohook->status == AST_AUDIOHOOK_STATUS_DONE)
819                 return 0;
820
821         if (direction != AST_AUDIOHOOK_DIRECTION_READ)
822                 return 0;
823
824         if (frame->frametype != AST_FRAME_VOICE)
825                 return 0;
826
827         if (frame->subclass.format.id != AST_FORMAT_SLINEAR) {
828                 ast_log(LOG_WARNING, "Expected frame in SLINEAR for the audiohook, but got format %s\n",
829                         ast_getformatname(&frame->subclass.format));
830                 return 0;
831         }
832
833         ast_channel_lock(chan);
834
835         if (!(datastore = ast_channel_datastore_find(chan, &jack_hook_ds_info, NULL))) {
836                 ast_log(LOG_ERROR, "JACK_HOOK datastore not found for '%s'\n", chan->name);
837                 ast_channel_unlock(chan);
838                 return -1;
839         }
840
841         jack_data = datastore->data;
842
843         queue_voice_frame(jack_data, frame);
844
845         handle_jack_audio(chan, jack_data, frame);
846
847         ast_channel_unlock(chan);
848
849         return 0;
850 }
851
852 static int enable_jack_hook(struct ast_channel *chan, char *data)
853 {
854         struct ast_datastore *datastore;
855         struct jack_data *jack_data = NULL;
856         AST_DECLARE_APP_ARGS(args,
857                 AST_APP_ARG(mode);
858                 AST_APP_ARG(options);
859         );
860
861         AST_STANDARD_APP_ARGS(args, data);
862
863         ast_channel_lock(chan);
864
865         if ((datastore = ast_channel_datastore_find(chan, &jack_hook_ds_info, NULL))) {
866                 ast_log(LOG_ERROR, "JACK_HOOK already enabled for '%s'\n", chan->name);
867                 goto return_error;
868         }
869
870         if (ast_strlen_zero(args.mode) || strcasecmp(args.mode, "manipulate")) {
871                 ast_log(LOG_ERROR, "'%s' is not a supported mode.  Only manipulate is supported.\n",
872                         S_OR(args.mode, "<none>"));
873                 goto return_error;
874         }
875
876         if (!(jack_data = jack_data_alloc()))
877                 goto return_error;
878
879         if (!ast_strlen_zero(args.options) && handle_options(jack_data, args.options))
880                 goto return_error;
881
882         if (init_jack_data(chan, jack_data))
883                 goto return_error;
884
885         if (!(datastore = ast_datastore_alloc(&jack_hook_ds_info, NULL)))
886                 goto return_error;
887
888         jack_data->has_audiohook = 1;
889         ast_audiohook_init(&jack_data->audiohook, AST_AUDIOHOOK_TYPE_MANIPULATE, "JACK_HOOK", 0);
890         jack_data->audiohook.manipulate_callback = jack_hook_callback;
891
892         datastore->data = jack_data;
893
894         if (ast_audiohook_attach(chan, &jack_data->audiohook))
895                 goto return_error;
896
897         if (ast_channel_datastore_add(chan, datastore))
898                 goto return_error;
899
900         ast_channel_unlock(chan);
901
902         return 0;
903
904 return_error:
905         ast_channel_unlock(chan);
906
907         if (jack_data)
908                 destroy_jack_data(jack_data);
909
910         return -1;
911 }
912
913 static int disable_jack_hook(struct ast_channel *chan)
914 {
915         struct ast_datastore *datastore;
916         struct jack_data *jack_data;
917
918         ast_channel_lock(chan);
919
920         if (!(datastore = ast_channel_datastore_find(chan, &jack_hook_ds_info, NULL))) {
921                 ast_channel_unlock(chan);
922                 ast_log(LOG_WARNING, "No JACK_HOOK found to disable\n");
923                 return -1;
924         }
925
926         ast_channel_datastore_remove(chan, datastore);
927
928         jack_data = datastore->data;
929         ast_audiohook_detach(&jack_data->audiohook);
930
931         /* Keep the channel locked while we destroy the datastore, so that we can
932          * ensure that all of the jack stuff is stopped just in case another frame
933          * tries to come through the audiohook callback. */
934         ast_datastore_free(datastore);
935
936         ast_channel_unlock(chan);
937
938         return 0;
939 }
940
941 static int jack_hook_write(struct ast_channel *chan, const char *cmd, char *data,
942         const char *value)
943 {
944         int res;
945
946         if (!strcasecmp(value, "on"))
947                 res = enable_jack_hook(chan, data);
948         else if (!strcasecmp(value, "off"))
949                 res = disable_jack_hook(chan);
950         else {
951                 ast_log(LOG_ERROR, "'%s' is not a valid value for JACK_HOOK()\n", value);
952                 res = -1;
953         }
954
955         return res;
956 }
957
958 static struct ast_custom_function jack_hook_function = {
959         .name = "JACK_HOOK",
960         .synopsis = "Enable a jack hook on a channel",
961         .syntax = "JACK_HOOK(<mode>,[options])",
962         .desc =
963         "   The JACK_HOOK allows turning on or off jack connectivity to this channel.\n"
964         "When the JACK_HOOK is turned on, jack ports will get created that allow\n"
965         "access to the audio stream for this channel.  The mode specifies which mode\n"
966         "this hook should run in.  A mode must be specified when turning the JACK_HOOK.\n"
967         "on.  However, all arguments are optional when turning it off.\n"
968         "\n"
969         "   Valid modes are:\n"
970 #if 0
971         /* XXX TODO */
972         "    spy -        Create a read-only audio hook.  Only an output jack port will\n"
973         "                 get created.\n"
974         "    whisper -    Create a write-only audio hook.  Only an input jack port will\n"
975         "                 get created.\n"
976 #endif
977         "    manipulate - Create a read/write audio hook.  Both an input and an output\n"
978         "                 jack port will get created.  Audio from the channel will be\n"
979         "                 sent out the output port and will be replaced by the audio\n"
980         "                 coming in on the input port as it gets passed on.\n"
981         "\n"
982         "   Valid options are:\n"
983         COMMON_OPTIONS
984         "\n"
985         " Examples:\n"
986         "   To turn on the JACK_HOOK,\n"
987         "     Set(JACK_HOOK(manipulate,i(pure_data_0:input0)o(pure_data_0:output0))=on)\n"
988         "   To turn off the JACK_HOOK,\n"
989         "     Set(JACK_HOOK()=off)\n"
990         "",
991         .write = jack_hook_write,
992 };
993
994 static int unload_module(void)
995 {
996         int res;
997
998         res = ast_unregister_application(jack_app);
999         res |= ast_custom_function_unregister(&jack_hook_function);
1000
1001         return res;
1002 }
1003
1004 static int load_module(void)
1005 {
1006         if (ast_register_application_xml(jack_app, jack_exec)) {
1007                 return AST_MODULE_LOAD_DECLINE;
1008         }
1009
1010         if (ast_custom_function_register(&jack_hook_function)) {
1011                 ast_unregister_application(jack_app);
1012                 return AST_MODULE_LOAD_DECLINE;
1013         }
1014
1015         return AST_MODULE_LOAD_SUCCESS;
1016 }
1017
1018 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "JACK Interface");