root/rat/trunk/cmd_parser.c @ 3435

Revision 3435, 9.4 KB (checked in by ucaccsp, 14 years ago)

Handle -T option

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/*
2 * FILE:    cmd_parser.c
3 * PROGRAM: RAT - controller
4 * AUTHOR:  Colin Perkins / Orion Hodson
5 *
6 * Copyright (c) 1999-2000 University College London
7 * All rights reserved.
8 */
9
10#ifndef HIDE_SOURCE_STRINGS
11static const char cvsid[] = "$Id";
12#endif /* HIDE_SOURCE_STRINGS */
13
14#include "config_unix.h"
15#include "config_win32.h"
16#include "debug.h"
17#include "mbus.h"
18#include "mbus_parser.h"
19#include "codec_compat.h"
20#include "cmd_parser.h"
21#include "version.h"
22
23void 
24usage(char *szOffending)
25{
26#ifdef WIN32
27        char win_usage[] = "\
28                      RAT is a multicast (or unicast) audio tool. It is best to start it\n\
29                      using a multicast directory tool, like sdr or multikit. If desired RAT\n\
30                      can be launched from the command line using:\n\n\
31                      rat <address>/<port>\n\n\
32                      where <address> is machine name, or a multicast IP address, and <port> is\n\
33                      the connection identifier (an even number between 1024-65536).\n\n\
34                      For more details see:\n\n\
35                      http://www-mice.cs.ucl.ac.uk/multimedia/software/rat/faq.html\
36                      ";
37
38        if (szOffending == NULL) {
39                szOffending = win_usage;
40        }
41        MessageBox(NULL, szOffending, "RAT v" RAT_VERSION " Usage", MB_ICONINFORMATION | MB_OK);
42#else
43        printf("Usage: rat [options] -t <ttl> <addr>/<port>\n");
44        if (szOffending) {
45                printf(szOffending);
46        }
47#endif
48}
49
50static int 
51cmd_logstats(struct mbus *m, char *addr, int argc, char *argv[])
52{
53        assert(argc == 0);
54        mbus_qmsgf(m, addr, TRUE, "tool.rat.logstats", "1");
55        UNUSED(argc);
56        UNUSED(argv);
57        return TRUE;
58}
59
60static int 
61cmd_layers(struct mbus *m, char *addr, int argc, char *argv[])
62{
63        int layers;
64        assert(argc == 1);
65        layers = atoi(argv[0]);
66        if (layers > 1) {
67                mbus_qmsgf(m, addr, TRUE, "tool.rat.layers", "%d", argv[0]);
68                return TRUE;
69        }
70        UNUSED(argc);
71        return FALSE;
72}
73
74static int 
75cmd_allowloop(struct mbus *m, char *addr, int argc, char *argv[])
76{
77        assert(argc == 0);
78        mbus_qmsgf(m, addr, TRUE, "tool.rat.filter.loopback", "0");
79        UNUSED(argc);
80        UNUSED(argv);
81        return TRUE;
82}
83
84static int 
85cmd_session_name(struct mbus *m, char *addr, int argc, char *argv[])
86{
87        char *enc_name;
88        assert(argc == 1);
89        enc_name = mbus_encode_str(argv[0]);
90        mbus_qmsgf(m, addr, TRUE, "session.title", enc_name);
91        xfree(enc_name);
92        UNUSED(argc);
93        return TRUE;
94}
95
96static int
97cmd_payload_map(struct mbus *m, char *addr, int argc, char *argv[])
98{
99        const char *compat;
100        char       *codec;
101        int         codec_pt;
102
103        assert(argc == 1);
104        /* Dynamic payload type mapping. Format: "-pt pt/codec" */
105        /* Codec is of the form "pcmu-8k-mono"                  */
106        codec_pt = atoi((char*)strtok(argv[0], "/"));
107        compat   = codec_get_compatible_name(strtok(NULL, "/"));
108        if (compat == NULL) {
109                usage("Usage: -pt <pt>/<codec>");
110                return FALSE;
111        }
112        codec = mbus_encode_str(compat);
113        mbus_qmsgf(m, addr, TRUE, "tool.rat.payload.set", "%s %d", codec, codec_pt);
114        xfree(codec);
115
116        UNUSED(argc);
117        return TRUE;
118}
119
120static int
121cmd_crypt(struct mbus *m, char *addr, int argc, char *argv[])
122{
123        char *key;
124
125        assert(argc == 1);
126        key = mbus_encode_str(argv[0]);
127        mbus_qmsgf(m, addr, TRUE, "security.encryption.key", key);
128        xfree(key);
129
130        UNUSED(argc);
131        return TRUE;
132}
133
134static int
135cmd_agc(struct mbus *m, char *addr, int argc, char *argv[])
136{
137        assert(argc == 1);
138        if (strcmp(argv[0], "on") == 0) {
139                mbus_qmsgf(m, addr, TRUE, "tool.rat.agc", "1");
140                return TRUE;
141        } else if (strcmp(argv[0], "off") == 0) {
142                mbus_qmsgf(m, addr, TRUE, "tool.rat.agc", "0");
143                return TRUE;
144        }
145        UNUSED(argc);
146        usage("Usage: -agc on|off\n");
147        return FALSE;
148}
149
150static int
151cmd_silence(struct mbus *m, char *addr, int argc, char *argv[])
152{
153        assert(argc == 1);
154        if (strcmp(argv[0], "on") == 0) {
155                mbus_qmsgf(m, addr, TRUE, "tool.rat.silence", "1");
156                return TRUE;
157        } else if (strcmp(argv[0], "off") == 0) {
158                mbus_qmsgf(m, addr, TRUE, "tool.rat.silence", "0");
159                return TRUE;
160        }
161        UNUSED(argc);
162        usage("Usage: -silence on|off\n");
163        return FALSE;
164}
165
166static int
167cmd_repair(struct mbus *m, char *addr, int argc, char *argv[])
168{
169        char *repair;
170        assert(argc == 1);
171        repair = mbus_encode_str(argv[0]);
172        mbus_qmsgf(m, addr, TRUE, "audio.channel.repair", repair);
173        xfree(repair);
174        UNUSED(argc);
175        return TRUE;
176}
177
178static int
179cmd_primary(struct mbus *m, char *addr, int argc, char *argv[])
180{
181        /* Set primary codec: "-f codec". You cannot set the   */
182        /* redundant codec with this option, use "-r" instead. */
183        char *firstname, *realname, *name, *freq, *chan;
184       
185        assert(argc == 1);
186        /* Break at trailing / in case user attempting old syntax */
187        firstname = (char*)strtok(argv[0], "/");
188       
189        /* The codec should be of the form "pcmu-8k-mono".     */
190        realname = xstrdup(codec_get_compatible_name(firstname));
191        name     = (char*)strtok(realname, "-");
192        freq     = (char*)strtok(NULL, "-");
193        chan     = (char*)strtok(NULL, "");
194        if (freq != NULL && chan != NULL) {
195                debug_msg("codec: %s %s %s\n", name, chan, freq);
196                name    = mbus_encode_str(name);
197                freq    = mbus_encode_str(freq);
198                chan    = mbus_encode_str(chan);
199                mbus_qmsgf(m, addr, TRUE, "tool.rat.codec", "%s %s %s", name, chan, freq);
200                xfree(name);
201                xfree(freq);
202                xfree(chan);
203        }
204        xfree(realname);
205        return TRUE;
206}
207
208static int
209cmd_redundancy(struct mbus *m, char *addr, int argc, char *argv[])
210{
211        const char *compat;
212        char       *redundancy, *codec;
213        int         offset;
214
215        assert(argc == 1);
216        /* Set channel coding to redundancy: "-r codec/offset" */
217        compat = codec_get_compatible_name((const char*)strtok(argv[0], "/"));
218        offset = atoi((char*)strtok(NULL, ""));
219
220        if (offset > 0) {
221                redundancy = mbus_encode_str("redundancy");
222                codec      = mbus_encode_str(compat);
223                mbus_qmsgf(m, addr, TRUE, "audio.channel.coding", "%s %s %d", redundancy, codec, offset);
224                xfree(redundancy);
225                xfree(codec);
226                return TRUE;
227        }
228        UNUSED(argc);
229        usage("Usage: -r <codec>/<offset>");
230        return FALSE;
231}
232
233static void
234cmd_sdes(struct mbus *m, char *addr, const char *msg_name, const char *value)
235{
236        char *sdes_value, *local_user;
237        local_user = mbus_encode_str("localuser");
238        sdes_value = mbus_encode_str(value);
239        mbus_qmsgf(m, addr, TRUE, msg_name, "%s %s", local_user, sdes_value);
240        xfree(local_user);
241        xfree(sdes_value);
242}
243
244static int
245cmd_sdes_name(struct mbus *m, char *addr, int argc, char *argv[]) {
246        assert(argc == 1);
247        UNUSED(argc);
248        cmd_sdes(m, addr, "rtp.source.name", argv[0]);
249        return TRUE;
250}
251
252static int
253cmd_sdes_email(struct mbus *m, char *addr, int argc, char *argv[]) {
254        assert(argc == 1);
255        UNUSED(argc);
256        cmd_sdes(m, addr, "rtp.source.email", argv[0]);
257        return TRUE;
258}
259
260static int
261cmd_sdes_phone(struct mbus *m, char *addr, int argc, char *argv[]) {
262        assert(argc == 1);
263        UNUSED(argc);
264        cmd_sdes(m, addr, "rtp.source.phone", argv[0]);
265        return TRUE;
266}
267
268static int
269cmd_sdes_loc(struct mbus *m, char *addr, int argc, char *argv[]) {
270        assert(argc == 1);
271        UNUSED(argc);
272        cmd_sdes(m, addr, "rtp.source.loc", argv[0]);
273        return TRUE;
274}
275
276static args_handler late_args[] = {
277        { "-logstats",       cmd_logstats,     0 },
278        { "-l",              cmd_layers,       1 },
279        { "-allowloopback",  cmd_allowloop,    0 },
280        { "-allow_loopback", cmd_allowloop,    0 },
281        { "-C",              cmd_session_name, 1 },
282        { "-E",              cmd_sdes_email,   1 },
283        { "-pt",             cmd_payload_map,  1 },
284        { "-crypt",          cmd_crypt,        1 },
285        { "-K",              cmd_crypt,        1 },
286        { "-L",              cmd_sdes_loc,     1 },
287        { "-N",              cmd_sdes_name,    1 },
288        { "-P",              cmd_sdes_phone,   1 },
289        { "-agc",            cmd_agc,          1 },
290        { "-silence",        cmd_silence,      1 },
291        { "-repair",         cmd_repair,       1 },
292        { "-f",              cmd_primary,      1 },
293        { "-r",              cmd_redundancy,   1 },
294        { "-t",              NULL,             1 }, /* handled in parse early args  */
295        { "-T",              NULL,             0 }, /* transcoder: special handling */
296};
297
298static uint32_t late_args_cnt = sizeof(late_args)/sizeof(late_args[0]);
299
300const args_handler *
301cmd_args_handler(char *cmdname)
302{
303        uint32_t j;
304        for (j = 0; j < late_args_cnt; j++) {
305                if (strcmp(cmdname, late_args[j].cmdname) == 0) {
306                        return late_args + j;
307                }
308        }
309        return NULL;
310}
311
Note: See TracBrowser for help on using the browser.