← Back to branch summary

~ubuntu-branches/ubuntu/wily/sflphone/wily

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject-2.1.0/pjsip-apps/src/samples/auddemo.c

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2015-01-07 14:51:16 UTC
  • mfrom: (4.3.5 sid)
  • Revision ID: package-import@ubuntu.com-20150107145116-yxnafinf4lrdvrmx
Tags: 1.4.1-0.1ubuntu1
* Merge with Debian, remaining changes:
 - Drop soprano, nepomuk build-dep
* Drop ubuntu patches, now upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
daemon/libs/pjproject-2.1.0/pjsip-apps/src/samples/auddemo.c
1
 
/* $Id: auddemo.c 3664 2011-07-19 03:42:28Z nanang $ */
2
 
/* 
3
 
 * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
4
 
 * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
5
 
 *
6
 
 * This program is free software; you can redistribute it and/or modify
7
 
 * it under the terms of the GNU General Public License as published by
8
 
 * the Free Software Foundation; either version 2 of the License, or
9
 
 * (at your option) any later version.
10
 
 *
11
 
 * This program is distributed in the hope that it will be useful,
12
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
 * GNU General Public License for more details.
15
 
 *
16
 
 * You should have received a copy of the GNU General Public License
17
 
 * along with this program; if not, write to the Free Software
18
 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
19
 
 */
20
 
#include <pjmedia-audiodev/audiodev.h>
21
 
#include <pjmedia-audiodev/audiotest.h>
22
 
#include <pjmedia.h>
23
 
#include <pjlib.h>
24
 
#include <pjlib-util.h>
25
 
 
26
 
#define THIS_FILE       "auddemo.c"
27
 
#define MAX_DEVICES     64
28
 
#define WAV_FILE        "auddemo.wav"
29
 
 
30
 
 
31
 
static unsigned dev_count;
32
 
static unsigned playback_lat = PJMEDIA_SND_DEFAULT_PLAY_LATENCY;
33
 
static unsigned capture_lat = PJMEDIA_SND_DEFAULT_REC_LATENCY;
34
 
 
35
 
static void app_perror(const char *title, pj_status_t status)
36
 
{
37
 
    char errmsg[PJ_ERR_MSG_SIZE];
38
 
 
39
 
    pj_strerror(status, errmsg, sizeof(errmsg));        
40
 
    printf( "%s: %s (err=%d)\n",
41
 
            title, errmsg, status);
42
 
}
43
 
 
44
 
static void list_devices(void)
45
 
{
46
 
    unsigned i;
47
 
    pj_status_t status;
48
 
    
49
 
    dev_count = pjmedia_aud_dev_count();
50
 
    if (dev_count == 0) {
51
 
        PJ_LOG(3,(THIS_FILE, "No devices found"));
52
 
        return;
53
 
    }
54
 
 
55
 
    PJ_LOG(3,(THIS_FILE, "Found %d devices:", dev_count));
56
 
 
57
 
    for (i=0; i<dev_count; ++i) {
58
 
        pjmedia_aud_dev_info info;
59
 
 
60
 
        status = pjmedia_aud_dev_get_info(i, &info);
61
 
        if (status != PJ_SUCCESS)
62
 
            continue;
63
 
 
64
 
        PJ_LOG(3,(THIS_FILE," %2d: %s [%s] (%d/%d)",
65
 
                  i, info.driver, info.name, info.input_count, info.output_count));
66
 
    }
67
 
}
68
 
 
69
 
static const char *decode_caps(unsigned caps)
70
 
{
71
 
    static char text[200];
72
 
    unsigned i;
73
 
 
74
 
    text[0] = '\0';
75
 
 
76
 
    for (i=0; i<31; ++i) {
77
 
        if ((1 << i) & caps) {
78
 
            const char *capname;
79
 
            capname = pjmedia_aud_dev_cap_name((pjmedia_aud_dev_cap)(1 << i), 
80
 
                                               NULL);
81
 
            strcat(text, capname);
82
 
            strcat(text, " ");
83
 
        }
84
 
    }
85
 
 
86
 
    return text;
87
 
}
88
 
 
89
 
static void show_dev_info(unsigned index)
90
 
{
91
 
#define H   "%-20s"
92
 
    pjmedia_aud_dev_info info;
93
 
    char formats[200];
94
 
    pj_status_t status;
95
 
 
96
 
    if (index >= dev_count) {
97
 
        PJ_LOG(1,(THIS_FILE, "Error: invalid index %u", index));
98
 
        return;
99
 
    }
100
 
 
101
 
    status = pjmedia_aud_dev_get_info(index, &info);
102
 
    if (status != PJ_SUCCESS) {
103
 
        app_perror("pjmedia_aud_dev_get_info() error", status);
104
 
        return;
105
 
    }
106
 
 
107
 
    PJ_LOG(3, (THIS_FILE, "Device at index %u:", index));
108
 
    PJ_LOG(3, (THIS_FILE, "-------------------------"));
109
 
 
110
 
    PJ_LOG(3, (THIS_FILE, H": %u (0x%x)", "ID", index, index));
111
 
    PJ_LOG(3, (THIS_FILE, H": %s", "Name", info.name));
112
 
    PJ_LOG(3, (THIS_FILE, H": %s", "Driver", info.driver));
113
 
    PJ_LOG(3, (THIS_FILE, H": %u", "Input channels", info.input_count));
114
 
    PJ_LOG(3, (THIS_FILE, H": %u", "Output channels", info.output_count));
115
 
    PJ_LOG(3, (THIS_FILE, H": %s", "Capabilities", decode_caps(info.caps)));
116
 
 
117
 
    formats[0] = '\0';
118
 
    if (info.caps & PJMEDIA_AUD_DEV_CAP_EXT_FORMAT) {
119
 
        unsigned i;
120
 
 
121
 
        for (i=0; i<info.ext_fmt_cnt; ++i) {
122
 
            char bitrate[32];
123
 
 
124
 
            switch (info.ext_fmt[i].id) {
125
 
            case PJMEDIA_FORMAT_L16:
126
 
                strcat(formats, "L16/");
127
 
                break;
128
 
            case PJMEDIA_FORMAT_PCMA:
129
 
                strcat(formats, "PCMA/");
130
 
                break;
131
 
            case PJMEDIA_FORMAT_PCMU:
132
 
                strcat(formats, "PCMU/");
133
 
                break;
134
 
            case PJMEDIA_FORMAT_AMR:
135
 
                strcat(formats, "AMR/");
136
 
                break;
137
 
            case PJMEDIA_FORMAT_G729:
138
 
                strcat(formats, "G729/");
139
 
                break;
140
 
            case PJMEDIA_FORMAT_ILBC:
141
 
                strcat(formats, "ILBC/");
142
 
                break;
143
 
            default:
144
 
                strcat(formats, "unknown/");
145
 
                break;
146
 
            }
147
 
            sprintf(bitrate, "%u", info.ext_fmt[i].det.aud.avg_bps);
148
 
            strcat(formats, bitrate);
149
 
            strcat(formats, " ");
150
 
        }
151
 
    }
152
 
    PJ_LOG(3, (THIS_FILE, H": %s", "Extended formats", formats));
153
 
 
154
 
#undef H
155
 
}
156
 
 
157
 
static void test_device(pjmedia_dir dir, unsigned rec_id, unsigned play_id, 
158
 
                        unsigned clock_rate, unsigned ptime, 
159
 
                        unsigned chnum)
160
 
{
161
 
    pjmedia_aud_param param;
162
 
    pjmedia_aud_test_results result;
163
 
    pj_status_t status;
164
 
 
165
 
    if (dir & PJMEDIA_DIR_CAPTURE) {
166
 
        status = pjmedia_aud_dev_default_param(rec_id, &param);
167
 
    } else {
168
 
        status = pjmedia_aud_dev_default_param(play_id, &param);
169
 
    }
170
 
 
171
 
    if (status != PJ_SUCCESS) {
172
 
        app_perror("pjmedia_aud_dev_default_param()", status);
173
 
        return;
174
 
    }
175
 
 
176
 
    param.dir = dir;
177
 
    param.rec_id = rec_id;
178
 
    param.play_id = play_id;
179
 
    param.clock_rate = clock_rate;
180
 
    param.channel_count = chnum;
181
 
    param.samples_per_frame = clock_rate * chnum * ptime / 1000;
182
 
 
183
 
    /* Latency settings */
184
 
    param.flags |= (PJMEDIA_AUD_DEV_CAP_INPUT_LATENCY | 
185
 
                    PJMEDIA_AUD_DEV_CAP_OUTPUT_LATENCY);
186
 
    param.input_latency_ms = capture_lat;
187
 
    param.output_latency_ms = playback_lat;
188
 
 
189
 
    PJ_LOG(3,(THIS_FILE, "Performing test.."));
190
 
 
191
 
    status = pjmedia_aud_test(&param, &result);
192
 
    if (status != PJ_SUCCESS) {
193
 
        app_perror("Test has completed with error", status);
194
 
        return;
195
 
    }
196
 
 
197
 
    PJ_LOG(3,(THIS_FILE, "Done. Result:"));
198
 
 
199
 
    if (dir & PJMEDIA_DIR_CAPTURE) {
200
 
        if (result.rec.frame_cnt==0) {
201
 
            PJ_LOG(1,(THIS_FILE, "Error: no frames captured!"));
202
 
        } else {
203
 
            PJ_LOG(3,(THIS_FILE, "  %-20s: interval (min/max/avg/dev)=%u/%u/%u/%u, burst=%u",
204
 
                      "Recording result",
205
 
                      result.rec.min_interval,
206
 
                      result.rec.max_interval,
207
 
                      result.rec.avg_interval,
208
 
                      result.rec.dev_interval,
209
 
                      result.rec.max_burst));
210
 
        }
211
 
    }
212
 
 
213
 
    if (dir & PJMEDIA_DIR_PLAYBACK) {
214
 
        if (result.play.frame_cnt==0) {
215
 
            PJ_LOG(1,(THIS_FILE, "Error: no playback!"));
216
 
        } else {
217
 
            PJ_LOG(3,(THIS_FILE, "  %-20s: interval (min/max/avg/dev)=%u/%u/%u/%u, burst=%u",
218
 
                      "Playback result",
219
 
                      result.play.min_interval,
220
 
                      result.play.max_interval,
221
 
                      result.play.avg_interval,
222
 
                      result.play.dev_interval,
223
 
                      result.play.max_burst));
224
 
        }
225
 
    }
226
 
 
227
 
    if (dir==PJMEDIA_DIR_CAPTURE_PLAYBACK) {
228
 
        if (result.rec_drift_per_sec == 0) {
229
 
            PJ_LOG(3,(THIS_FILE, " No clock drift detected"));
230
 
        } else {
231
 
            const char *which = result.rec_drift_per_sec>=0 ? "faster" : "slower";
232
 
            unsigned drift = result.rec_drift_per_sec>=0 ? 
233
 
                                result.rec_drift_per_sec :
234
 
                                -result.rec_drift_per_sec;
235
 
 
236
 
            PJ_LOG(3,(THIS_FILE, " Clock drifts detected. Capture device "
237
 
                                 "is running %d samples per second %s "
238
 
                                 "than the playback device",
239
 
                                 drift, which));
240
 
        }
241
 
    }
242
 
}
243
 
 
244
 
 
245
 
static pj_status_t wav_rec_cb(void *user_data, pjmedia_frame *frame)
246
 
{
247
 
    return pjmedia_port_put_frame((pjmedia_port*)user_data, frame);
248
 
}
249
 
 
250
 
static void record(unsigned rec_index, const char *filename)
251
 
{
252
 
    pj_pool_t *pool = NULL;
253
 
    pjmedia_port *wav = NULL;
254
 
    pjmedia_aud_param param;
255
 
    pjmedia_aud_stream *strm = NULL;
256
 
    char line[10], *dummy;
257
 
    pj_status_t status;
258
 
 
259
 
    if (filename == NULL)
260
 
        filename = WAV_FILE;
261
 
 
262
 
    pool = pj_pool_create(pjmedia_aud_subsys_get_pool_factory(), "wav",
263
 
                          1000, 1000, NULL);
264
 
 
265
 
    status = pjmedia_wav_writer_port_create(pool, filename, 16000, 
266
 
                                            1, 320, 16, 0, 0, &wav);
267
 
    if (status != PJ_SUCCESS) {
268
 
        app_perror("Error creating WAV file", status);
269
 
        goto on_return;
270
 
    }
271
 
 
272
 
    status = pjmedia_aud_dev_default_param(rec_index, &param);
273
 
    if (status != PJ_SUCCESS) {
274
 
        app_perror("pjmedia_aud_dev_default_param()", status);
275
 
        goto on_return;
276
 
    }
277
 
 
278
 
    param.dir = PJMEDIA_DIR_CAPTURE;
279
 
    param.clock_rate = PJMEDIA_PIA_SRATE(&wav->info);
280
 
    param.samples_per_frame = PJMEDIA_PIA_SPF(&wav->info);
281
 
    param.channel_count = PJMEDIA_PIA_CCNT(&wav->info);
282
 
    param.bits_per_sample = PJMEDIA_PIA_BITS(&wav->info);
283
 
 
284
 
    status = pjmedia_aud_stream_create(&param, &wav_rec_cb, NULL, wav,
285
 
                                       &strm);
286
 
    if (status != PJ_SUCCESS) {
287
 
        app_perror("Error opening the sound device", status);
288
 
        goto on_return;
289
 
    }
290
 
 
291
 
    status = pjmedia_aud_stream_start(strm);
292
 
    if (status != PJ_SUCCESS) {
293
 
        app_perror("Error starting the sound device", status);
294
 
        goto on_return;
295
 
    }
296
 
 
297
 
    PJ_LOG(3,(THIS_FILE, "Recording started, press ENTER to stop"));
298
 
    dummy = fgets(line, sizeof(line), stdin);
299
 
 
300
 
on_return:
301
 
    if (strm) {
302
 
        pjmedia_aud_stream_stop(strm);
303
 
        pjmedia_aud_stream_destroy(strm);
304
 
    }
305
 
    if (wav)
306
 
        pjmedia_port_destroy(wav);
307
 
    if (pool)
308
 
        pj_pool_release(pool);
309
 
}
310
 
 
311
 
 
312
 
static pj_status_t wav_play_cb(void *user_data, pjmedia_frame *frame)
313
 
{
314
 
    return pjmedia_port_get_frame((pjmedia_port*)user_data, frame);
315
 
}
316
 
 
317
 
 
318
 
static void play_file(unsigned play_index, const char *filename)
319
 
{
320
 
    pj_pool_t *pool = NULL;
321
 
    pjmedia_port *wav = NULL;
322
 
    pjmedia_aud_param param;
323
 
    pjmedia_aud_stream *strm = NULL;
324
 
    char line[10], *dummy;
325
 
    pj_status_t status;
326
 
 
327
 
    if (filename == NULL)
328
 
        filename = WAV_FILE;
329
 
 
330
 
    pool = pj_pool_create(pjmedia_aud_subsys_get_pool_factory(), "wav",
331
 
                          1000, 1000, NULL);
332
 
 
333
 
    status = pjmedia_wav_player_port_create(pool, filename, 20, 0, 0, &wav);
334
 
    if (status != PJ_SUCCESS) {
335
 
        app_perror("Error opening WAV file", status);
336
 
        goto on_return;
337
 
    }
338
 
 
339
 
    status = pjmedia_aud_dev_default_param(play_index, &param);
340
 
    if (status != PJ_SUCCESS) {
341
 
        app_perror("pjmedia_aud_dev_default_param()", status);
342
 
        goto on_return;
343
 
    }
344
 
 
345
 
    param.dir = PJMEDIA_DIR_PLAYBACK;
346
 
    param.clock_rate = PJMEDIA_PIA_SRATE(&wav->info);
347
 
    param.samples_per_frame = PJMEDIA_PIA_SPF(&wav->info);
348
 
    param.channel_count = PJMEDIA_PIA_CCNT(&wav->info);
349
 
    param.bits_per_sample = PJMEDIA_PIA_BITS(&wav->info);
350
 
 
351
 
    status = pjmedia_aud_stream_create(&param, NULL, &wav_play_cb, wav,
352
 
                                       &strm);
353
 
    if (status != PJ_SUCCESS) {
354
 
        app_perror("Error opening the sound device", status);
355
 
        goto on_return;
356
 
    }
357
 
 
358
 
    status = pjmedia_aud_stream_start(strm);
359
 
    if (status != PJ_SUCCESS) {
360
 
        app_perror("Error starting the sound device", status);
361
 
        goto on_return;
362
 
    }
363
 
 
364
 
    PJ_LOG(3,(THIS_FILE, "Playback started, press ENTER to stop"));
365
 
    dummy = fgets(line, sizeof(line), stdin);
366
 
 
367
 
on_return:
368
 
    if (strm) {
369
 
        pjmedia_aud_stream_stop(strm);
370
 
        pjmedia_aud_stream_destroy(strm);
371
 
    }
372
 
    if (wav)
373
 
        pjmedia_port_destroy(wav);
374
 
    if (pool)
375
 
        pj_pool_release(pool);
376
 
}
377
 
 
378
 
 
379
 
static void print_menu(void)
380
 
{
381
 
    puts("");
382
 
    puts("Audio demo menu:");
383
 
    puts("-------------------------------");
384
 
    puts("  l                        List devices");
385
 
    puts("  R                        Refresh devices");
386
 
    puts("  i ID                     Show device info for device ID");
387
 
    puts("  t RID PID CR PTIM [CH]   Perform test on the device:");
388
 
    puts("                             RID:  record device ID (-1 for no)");
389
 
    puts("                             PID:  playback device ID (-1 for no)");
390
 
    puts("                             CR:   clock rate");
391
 
    puts("                             PTIM: ptime in ms");
392
 
    puts("                             CH:   # of channels");
393
 
    puts("  r RID [FILE]             Record capture device RID to WAV file");
394
 
    puts("  p PID [FILE]             Playback WAV file to device ID PID");
395
 
    puts("  d [RLAT PLAT]            Get/set sound device latencies (in ms):");
396
 
    puts("                             Specify no param to get current latencies setting");
397
 
    puts("                             RLAT: record latency (-1 for default)");
398
 
    puts("                             PLAT: playback latency (-1 for default)");
399
 
    puts("  v                        Toggle log verbosity");
400
 
    puts("  q                        Quit");
401
 
    puts("");
402
 
    printf("Enter selection: ");
403
 
    fflush(stdout);
404
 
}
405
 
 
406
 
int main()
407
 
{
408
 
    pj_caching_pool cp;
409
 
    pj_bool_t done = PJ_FALSE;
410
 
    pj_status_t status;
411
 
 
412
 
    /* Init pjlib */
413
 
    status = pj_init();
414
 
    PJ_ASSERT_RETURN(status==PJ_SUCCESS, 1);
415
 
    
416
 
    pj_log_set_decor(PJ_LOG_HAS_NEWLINE);
417
 
 
418
 
    /* Must create a pool factory before we can allocate any memory. */
419
 
    pj_caching_pool_init(&cp, &pj_pool_factory_default_policy, 0);
420
 
 
421
 
    status = pjmedia_aud_subsys_init(&cp.factory);
422
 
    if (status != PJ_SUCCESS) {
423
 
        app_perror("pjmedia_aud_subsys_init()", status);
424
 
        pj_caching_pool_destroy(&cp);
425
 
        pj_shutdown();
426
 
        return 1;
427
 
    }
428
 
 
429
 
    list_devices();
430
 
 
431
 
    while (!done) {
432
 
        char line[80];
433
 
 
434
 
        print_menu();
435
 
 
436
 
        if (fgets(line, sizeof(line), stdin)==NULL)
437
 
            break;
438
 
 
439
 
        switch (line[0]) {
440
 
        case 'l':
441
 
            list_devices();
442
 
            break;
443
 
 
444
 
        case 'R':
445
 
            pjmedia_aud_dev_refresh();
446
 
            puts("Audio device list refreshed.");
447
 
            break;
448
 
 
449
 
        case 'i':
450
 
            {
451
 
                unsigned dev_index;
452
 
                if (sscanf(line+2, "%u", &dev_index) != 1) {
453
 
                    puts("error: device ID required");
454
 
                    break;
455
 
                }
456
 
                show_dev_info(dev_index);
457
 
            }
458
 
            break;
459
 
 
460
 
        case 't':
461
 
            {
462
 
                pjmedia_dir dir;
463
 
                int rec_id, play_id;
464
 
                unsigned clock_rate, ptime, chnum;
465
 
                int cnt;
466
 
 
467
 
                cnt = sscanf(line+2, "%d %d %u %u %u", &rec_id, &play_id, 
468
 
                             &clock_rate, &ptime, &chnum);
469
 
                if (cnt < 4) {
470
 
                    puts("error: not enough parameters");
471
 
                    break;
472
 
                }
473
 
                if (clock_rate < 8000 || clock_rate > 128000) {
474
 
                    puts("error: invalid clock rate");
475
 
                    break;
476
 
                }
477
 
                if (ptime < 10 || ptime > 500) {
478
 
                    puts("error: invalid ptime");
479
 
                    break;
480
 
                }
481
 
                if (cnt==5) {
482
 
                    if (chnum < 1 || chnum > 4) {
483
 
                        puts("error: invalid number of channels");
484
 
                        break;
485
 
                    }
486
 
                } else {
487
 
                    chnum = 1;
488
 
                }
489
 
 
490
 
                if (rec_id >= 0 && rec_id < (int)dev_count) {
491
 
                    if (play_id >= 0 && play_id < (int)dev_count)
492
 
                        dir = PJMEDIA_DIR_CAPTURE_PLAYBACK;
493
 
                    else
494
 
                        dir = PJMEDIA_DIR_CAPTURE;
495
 
                } else if (play_id >= 0 && play_id < (int)dev_count) {
496
 
                    dir = PJMEDIA_DIR_PLAYBACK;
497
 
                } else {
498
 
                    puts("error: at least one valid device index required");
499
 
                    break;
500
 
                }
501
 
 
502
 
                test_device(dir, rec_id, play_id, clock_rate, ptime, chnum);
503
 
                
504
 
            }
505
 
            break;
506
 
 
507
 
        case 'r':
508
 
            /* record */
509
 
            {
510
 
                int index;
511
 
                char filename[80];
512
 
                int count;
513
 
 
514
 
                count = sscanf(line+2, "%d %s", &index, filename);
515
 
                if (count==1)
516
 
                    record(index, NULL);
517
 
                else if (count==2)
518
 
                    record(index, filename);
519
 
                else
520
 
                    puts("error: invalid command syntax");
521
 
            }
522
 
            break;
523
 
 
524
 
        case 'p':
525
 
            /* playback */
526
 
            {
527
 
                int index;
528
 
                char filename[80];
529
 
                int count;
530
 
 
531
 
                count = sscanf(line+2, "%d %s", &index, filename);
532
 
                if (count==1)
533
 
                    play_file(index, NULL);
534
 
                else if (count==2)
535
 
                    play_file(index, filename);
536
 
                else
537
 
                    puts("error: invalid command syntax");
538
 
            }
539
 
            break;
540
 
 
541
 
        case 'd':
542
 
            /* latencies */
543
 
            {
544
 
                int rec_lat, play_lat;
545
 
 
546
 
                if (sscanf(line+2, "%d %d", &rec_lat, &play_lat) == 2) {
547
 
                    capture_lat = (unsigned) 
548
 
                         (rec_lat>=0? rec_lat:PJMEDIA_SND_DEFAULT_REC_LATENCY);
549
 
                    playback_lat = (unsigned)
550
 
                         (play_lat >= 0? play_lat : PJMEDIA_SND_DEFAULT_PLAY_LATENCY);
551
 
                    printf("Recording latency=%ums, playback latency=%ums",
552
 
                           capture_lat, playback_lat);
553
 
                } else {
554
 
                    printf("Current latencies: record=%ums, playback=%ums",
555
 
                           capture_lat, playback_lat);
556
 
                }
557
 
                puts("");
558
 
            }
559
 
            break;
560
 
 
561
 
        case 'v':
562
 
            if (pj_log_get_level() <= 3) {
563
 
                pj_log_set_level(5);
564
 
                puts("Logging set to detail");
565
 
            } else {
566
 
                pj_log_set_level(3);
567
 
                puts("Logging set to quiet");
568
 
            }
569
 
            break;
570
 
 
571
 
        case 'q':
572
 
            done = PJ_TRUE;
573
 
            break;
574
 
        }
575
 
    }
576
 
 
577
 
    pj_caching_pool_destroy(&cp);
578
 
    pj_shutdown();
579
 
    return 0;
580
 
}
581
 
 
582