format_wav_gsm.c

Go to the documentation of this file.
00001 /*
00002  * Asterisk -- An open source telephony toolkit.
00003  *
00004  * Copyright (C) 1999 - 2005, Digium, Inc.
00005  *
00006  * Mark Spencer <markster@digium.com>
00007  *
00008  * See http://www.asterisk.org for more information about
00009  * the Asterisk project. Please do not directly contact
00010  * any of the maintainers of this project for assistance;
00011  * the project provides a web site, mailing lists and IRC
00012  * channels for your use.
00013  *
00014  * This program is free software, distributed under the terms of
00015  * the GNU General Public License Version 2. See the LICENSE file
00016  * at the top of the source tree.
00017  */
00018 
00019 /*! \file
00020  *
00021  * \brief Save GSM in the proprietary Microsoft format.
00022  * 
00023  * Microsoft WAV format (Proprietary GSM)
00024  * \arg File name extension: WAV,wav49  (Upper case WAV, lower case is another format)
00025  * This format can be played on Windows systems, used for
00026  * e-mail attachments mainly.
00027  * \ingroup formats
00028  */
00029 
00030 /*** MODULEINFO
00031    <support_level>core</support_level>
00032  ***/
00033  
00034 #include "asterisk.h"
00035 
00036 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 433692 $")
00037 
00038 #include "asterisk/mod_format.h"
00039 #include "asterisk/module.h"
00040 #include "asterisk/endian.h"
00041 #include "asterisk/format_cache.h"
00042 
00043 #include "msgsm.h"
00044 
00045 /* Some Ideas for this code came from makewave.c by Jeffrey Chilton */
00046 
00047 /* Portions of the conversion code are by guido@sienanet.it */
00048 
00049 #define  GSM_FRAME_SIZE 33
00050 #define  MSGSM_FRAME_SIZE  65
00051 #define  MSGSM_DATA_OFFSET    60 /* offset of data bytes */
00052 #define  GSM_SAMPLES    160   /* samples in a GSM block */
00053 #define  MSGSM_SAMPLES     (2*GSM_SAMPLES)   /* samples in an MSGSM block */
00054 
00055 /* begin binary data: */
00056 static char msgsm_silence[] = /* 65 */
00057 {0x48,0x17,0xD6,0x84,0x02,0x80,0x24,0x49,0x92,0x24,0x89,0x02,0x80,0x24,0x49
00058 ,0x92,0x24,0x89,0x02,0x80,0x24,0x49,0x92,0x24,0x89,0x02,0x80,0x24,0x49,0x92
00059 ,0x24,0x09,0x82,0x74,0x61,0x4D,0x28,0x00,0x48,0x92,0x24,0x49,0x92,0x28,0x00
00060 ,0x48,0x92,0x24,0x49,0x92,0x28,0x00,0x48,0x92,0x24,0x49,0x92,0x28,0x00,0x48
00061 ,0x92,0x24,0x49,0x92,0x00};
00062 /* end binary data. size = 65 bytes */
00063 
00064 struct wavg_desc {
00065    /* Believe it or not, we must decode/recode to account for the
00066       weird MS format */
00067    int secondhalf;                  /* Are we on the second half */
00068 };
00069 
00070 #if __BYTE_ORDER == __LITTLE_ENDIAN
00071 #define htoll(b) (b)
00072 #define htols(b) (b)
00073 #define ltohl(b) (b)
00074 #define ltohs(b) (b)
00075 #else
00076 #if __BYTE_ORDER == __BIG_ENDIAN
00077 #define htoll(b) \
00078    (((((b)      ) & 0xFF) << 24) | \
00079    ((( (b) >>  8) & 0xFF) << 16) | \
00080    ((( (b) >> 16) & 0xFF) <<  8) | \
00081    ((( (b) >> 24) & 0xFF)      ))
00082 #define htols(b) \
00083    (((((b)      ) & 0xFF) <<  8) | \
00084    ((( (b) >>  8) & 0xFF)      ))
00085 #define ltohl(b) htoll(b)
00086 #define ltohs(b) htols(b)
00087 #else
00088 #error "Endianess not defined"
00089 #endif
00090 #endif
00091 
00092 
00093 static int check_header(FILE *f)
00094 {
00095    int type, size, formtype;
00096    int fmt, hsize, fact;
00097    short format, chans;
00098    int freq;
00099    int data;
00100    if (fread(&type, 1, 4, f) != 4) {
00101       ast_log(LOG_WARNING, "Read failed (type)\n");
00102       return -1;
00103    }
00104    if (fread(&size, 1, 4, f) != 4) {
00105       ast_log(LOG_WARNING, "Read failed (size)\n");
00106       return -1;
00107    }
00108 #if __BYTE_ORDER == __BIG_ENDIAN
00109    size = ltohl(size);
00110 #endif
00111    if (fread(&formtype, 1, 4, f) != 4) {
00112       ast_log(LOG_WARNING, "Read failed (formtype)\n");
00113       return -1;
00114    }
00115    if (memcmp(&type, "RIFF", 4)) {
00116       ast_log(LOG_WARNING, "Does not begin with RIFF\n");
00117       return -1;
00118    }
00119    if (memcmp(&formtype, "WAVE", 4)) {
00120       ast_log(LOG_WARNING, "Does not contain WAVE\n");
00121       return -1;
00122    }
00123    if (fread(&fmt, 1, 4, f) != 4) {
00124       ast_log(LOG_WARNING, "Read failed (fmt)\n");
00125       return -1;
00126    }
00127    if (memcmp(&fmt, "fmt ", 4)) {
00128       ast_log(LOG_WARNING, "Does not say fmt\n");
00129       return -1;
00130    }
00131    if (fread(&hsize, 1, 4, f) != 4) {
00132       ast_log(LOG_WARNING, "Read failed (formtype)\n");
00133       return -1;
00134    }
00135    if (ltohl(hsize) != 20) {
00136       ast_log(LOG_WARNING, "Unexpected header size %d\n", ltohl(hsize));
00137       return -1;
00138    }
00139    if (fread(&format, 1, 2, f) != 2) {
00140       ast_log(LOG_WARNING, "Read failed (format)\n");
00141       return -1;
00142    }
00143    if (ltohs(format) != 49) {
00144       ast_log(LOG_WARNING, "Not a GSM file %d\n", ltohs(format));
00145       return -1;
00146    }
00147    if (fread(&chans, 1, 2, f) != 2) {
00148       ast_log(LOG_WARNING, "Read failed (format)\n");
00149       return -1;
00150    }
00151    if (ltohs(chans) != 1) {
00152       ast_log(LOG_WARNING, "Not in mono %d\n", ltohs(chans));
00153       return -1;
00154    }
00155    if (fread(&freq, 1, 4, f) != 4) {
00156       ast_log(LOG_WARNING, "Read failed (freq)\n");
00157       return -1;
00158    }
00159    if (ltohl(freq) != DEFAULT_SAMPLE_RATE) {
00160       ast_log(LOG_WARNING, "Unexpected frequency %d\n", ltohl(freq));
00161       return -1;
00162    }
00163    /* Ignore the byte frequency */
00164    if (fread(&freq, 1, 4, f) != 4) {
00165       ast_log(LOG_WARNING, "Read failed (X_1)\n");
00166       return -1;
00167    }
00168    /* Ignore the two weird fields */
00169    if (fread(&freq, 1, 4, f) != 4) {
00170       ast_log(LOG_WARNING, "Read failed (X_2/X_3)\n");
00171       return -1;
00172    }
00173    /* Ignore the byte frequency */
00174    if (fread(&freq, 1, 4, f) != 4) {
00175       ast_log(LOG_WARNING, "Read failed (Y_1)\n");
00176       return -1;
00177    }
00178    /* Check for the word fact */
00179    if (fread(&fact, 1, 4, f) != 4) {
00180       ast_log(LOG_WARNING, "Read failed (fact)\n");
00181       return -1;
00182    }
00183    if (memcmp(&fact, "fact", 4)) {
00184       ast_log(LOG_WARNING, "Does not say fact\n");
00185       return -1;
00186    }
00187    /* Ignore the "fact value" */
00188    if (fread(&fact, 1, 4, f) != 4) {
00189       ast_log(LOG_WARNING, "Read failed (fact header)\n");
00190       return -1;
00191    }
00192    if (fread(&fact, 1, 4, f) != 4) {
00193       ast_log(LOG_WARNING, "Read failed (fact value)\n");
00194       return -1;
00195    }
00196    /* Check for the word data */
00197    if (fread(&data, 1, 4, f) != 4) {
00198       ast_log(LOG_WARNING, "Read failed (data)\n");
00199       return -1;
00200    }
00201    if (memcmp(&data, "data", 4)) {
00202       ast_log(LOG_WARNING, "Does not say data\n");
00203       return -1;
00204    }
00205    /* Ignore the data length */
00206    if (fread(&data, 1, 4, f) != 4) {
00207       ast_log(LOG_WARNING, "Read failed (data)\n");
00208       return -1;
00209    }
00210    return 0;
00211 }
00212 
00213 static int update_header(FILE *f)
00214 {
00215    off_t cur,end,bytes;
00216    int datalen, filelen, samples;
00217 
00218    cur = ftello(f);
00219    fseek(f, 0, SEEK_END);
00220    end = ftello(f);
00221    /* in a gsm WAV, data starts 60 bytes in */
00222    bytes = end - MSGSM_DATA_OFFSET;
00223    samples = htoll(bytes / MSGSM_FRAME_SIZE * MSGSM_SAMPLES);
00224    datalen = htoll(bytes);
00225    filelen = htoll(MSGSM_DATA_OFFSET - 8 + bytes);
00226    if (cur < 0) {
00227       ast_log(LOG_WARNING, "Unable to find our position\n");
00228       return -1;
00229    }
00230    if (fseek(f, 4, SEEK_SET)) {
00231       ast_log(LOG_WARNING, "Unable to set our position\n");
00232       return -1;
00233    }
00234    if (fwrite(&filelen, 1, 4, f) != 4) {
00235       ast_log(LOG_WARNING, "Unable to write file size\n");
00236       return -1;
00237    }
00238    if (fseek(f, 48, SEEK_SET)) {
00239       ast_log(LOG_WARNING, "Unable to set our position\n");
00240       return -1;
00241    }
00242    if (fwrite(&samples, 1, 4, f) != 4) {
00243       ast_log(LOG_WARNING, "Unable to write samples\n");
00244       return -1;
00245    }
00246    if (fseek(f, 56, SEEK_SET)) {
00247       ast_log(LOG_WARNING, "Unable to set our position\n");
00248       return -1;
00249    }
00250    if (fwrite(&datalen, 1, 4, f) != 4) {
00251       ast_log(LOG_WARNING, "Unable to write datalen\n");
00252       return -1;
00253    }
00254    if (fseeko(f, cur, SEEK_SET)) {
00255       ast_log(LOG_WARNING, "Unable to return to position\n");
00256       return -1;
00257    }
00258    return 0;
00259 }
00260 
00261 static int write_header(FILE *f)
00262 {
00263    /* Samples per second (always 8000 for this format). */
00264    unsigned int sample_rate = htoll(8000);
00265    /* Bytes per second (always 1625 for this format). */
00266    unsigned int byte_sample_rate = htoll(1625);
00267    /* This is the size of the "fmt " subchunk */
00268    unsigned int fmtsize = htoll(20);
00269    /* WAV #49 */
00270    unsigned short fmt = htols(49);
00271    /* Mono = 1 channel */
00272    unsigned short chans = htols(1);
00273    /* Each block of data is exactly 65 bytes in size. */
00274    unsigned int block_align = htoll(MSGSM_FRAME_SIZE);
00275    /* Not actually 2, but rounded up to the nearest bit */
00276    unsigned short bits_per_sample = htols(2);
00277    /* Needed for compressed formats */
00278    unsigned short extra_format = htols(MSGSM_SAMPLES);
00279    /* This is the size of the "fact" subchunk */
00280    unsigned int factsize = htoll(4);
00281    /* Number of samples in the data chunk */
00282    unsigned int num_samples = htoll(0);
00283    /* Number of bytes in the data chunk */
00284    unsigned int size = htoll(0);
00285    /* Write a GSM header, ignoring sizes which will be filled in later */
00286 
00287    /*  0: Chunk ID */
00288    if (fwrite("RIFF", 1, 4, f) != 4) {
00289       ast_log(LOG_WARNING, "Unable to write header\n");
00290       return -1;
00291    }
00292    /*  4: Chunk Size */
00293    if (fwrite(&size, 1, 4, f) != 4) {
00294       ast_log(LOG_WARNING, "Unable to write header\n");
00295       return -1;
00296    }
00297    /*  8: Chunk Format */
00298    if (fwrite("WAVE", 1, 4, f) != 4) {
00299       ast_log(LOG_WARNING, "Unable to write header\n");
00300       return -1;
00301    }
00302    /* 12: Subchunk 1: ID */
00303    if (fwrite("fmt ", 1, 4, f) != 4) {
00304       ast_log(LOG_WARNING, "Unable to write header\n");
00305       return -1;
00306    }
00307    /* 16: Subchunk 1: Size (minus 8) */
00308    if (fwrite(&fmtsize, 1, 4, f) != 4) {
00309       ast_log(LOG_WARNING, "Unable to write header\n");
00310       return -1;
00311    }
00312    /* 20: Subchunk 1: Audio format (49) */
00313    if (fwrite(&fmt, 1, 2, f) != 2) {
00314       ast_log(LOG_WARNING, "Unable to write header\n");
00315       return -1;
00316    }
00317    /* 22: Subchunk 1: Number of channels */
00318    if (fwrite(&chans, 1, 2, f) != 2) {
00319       ast_log(LOG_WARNING, "Unable to write header\n");
00320       return -1;
00321    }
00322    /* 24: Subchunk 1: Sample rate */
00323    if (fwrite(&sample_rate, 1, 4, f) != 4) {
00324       ast_log(LOG_WARNING, "Unable to write header\n");
00325       return -1;
00326    }
00327    /* 28: Subchunk 1: Byte rate */
00328    if (fwrite(&byte_sample_rate, 1, 4, f) != 4) {
00329       ast_log(LOG_WARNING, "Unable to write header\n");
00330       return -1;
00331    }
00332    /* 32: Subchunk 1: Block align */
00333    if (fwrite(&block_align, 1, 4, f) != 4) {
00334       ast_log(LOG_WARNING, "Unable to write header\n");
00335       return -1;
00336    }
00337    /* 36: Subchunk 1: Bits per sample */
00338    if (fwrite(&bits_per_sample, 1, 2, f) != 2) {
00339       ast_log(LOG_WARNING, "Unable to write header\n");
00340       return -1;
00341    }
00342    /* 38: Subchunk 1: Extra format bytes */
00343    if (fwrite(&extra_format, 1, 2, f) != 2) {
00344       ast_log(LOG_WARNING, "Unable to write header\n");
00345       return -1;
00346    }
00347    /* 40: Subchunk 2: ID */
00348    if (fwrite("fact", 1, 4, f) != 4) {
00349       ast_log(LOG_WARNING, "Unable to write header\n");
00350       return -1;
00351    }
00352    /* 44: Subchunk 2: Size (minus 8) */
00353    if (fwrite(&factsize, 1, 4, f) != 4) {
00354       ast_log(LOG_WARNING, "Unable to write header\n");
00355       return -1;
00356    }
00357    /* 48: Subchunk 2: Number of samples */
00358    if (fwrite(&num_samples, 1, 4, f) != 4) {
00359       ast_log(LOG_WARNING, "Unable to write header\n");
00360       return -1;
00361    }
00362    /* 52: Subchunk 3: ID */
00363    if (fwrite("data", 1, 4, f) != 4) {
00364       ast_log(LOG_WARNING, "Unable to write header\n");
00365       return -1;
00366    }
00367    /* 56: Subchunk 3: Size */
00368    if (fwrite(&size, 1, 4, f) != 4) {
00369       ast_log(LOG_WARNING, "Unable to write header\n");
00370       return -1;
00371    }
00372    return 0;
00373 }
00374 
00375 static int wav_open(struct ast_filestream *s)
00376 {
00377    /* We don't have any header to read or anything really, but
00378       if we did, it would go here.  We also might want to check
00379       and be sure it's a valid file.  */
00380    struct wavg_desc *fs = (struct wavg_desc *)s->_private;
00381 
00382    if (check_header(s->f))
00383       return -1;
00384    fs->secondhalf = 0;  /* not strictly necessary */
00385    return 0;
00386 }
00387 
00388 static int wav_rewrite(struct ast_filestream *s, const char *comment)
00389 {
00390    /* We don't have any header to read or anything really, but
00391       if we did, it would go here.  We also might want to check
00392       and be sure it's a valid file.  */
00393 
00394    if (write_header(s->f))
00395       return -1;
00396    return 0;
00397 }
00398 
00399 static void wav_close(struct ast_filestream *s)
00400 {
00401    if (s->mode == O_RDONLY) {
00402       return;
00403    }
00404 
00405    if (s->filename) {
00406       update_header(s->f);
00407    }
00408 }
00409 
00410 static struct ast_frame *wav_read(struct ast_filestream *s, int *whennext)
00411 {
00412    /* Send a frame from the file to the appropriate channel */
00413    struct wavg_desc *fs = (struct wavg_desc *)s->_private;
00414 
00415    s->fr.samples = GSM_SAMPLES;
00416    AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, GSM_FRAME_SIZE);
00417    if (fs->secondhalf) {
00418       /* Just return a frame based on the second GSM frame */
00419       s->fr.data.ptr = (char *)s->fr.data.ptr + GSM_FRAME_SIZE;
00420       s->fr.offset += GSM_FRAME_SIZE;
00421    } else {
00422       /* read and convert */
00423       unsigned char msdata[MSGSM_FRAME_SIZE];
00424       int res;
00425       
00426       if ((res = fread(msdata, 1, MSGSM_FRAME_SIZE, s->f)) != MSGSM_FRAME_SIZE) {
00427          if (res && (res != 1))
00428             ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
00429          return NULL;
00430       }
00431       /* Convert from MS format to two real GSM frames */
00432       conv65(msdata, s->fr.data.ptr);
00433    }
00434    fs->secondhalf = !fs->secondhalf;
00435    *whennext = GSM_SAMPLES;
00436    return &s->fr;
00437 }
00438 
00439 static int wav_write(struct ast_filestream *s, struct ast_frame *f)
00440 {
00441    int len;
00442    int size;
00443    struct wavg_desc *fs = (struct wavg_desc *)s->_private;
00444 
00445    /* XXX this might fail... if the input is a multiple of MSGSM_FRAME_SIZE
00446     * we assume it is already in the correct format.
00447     */
00448    if (!(f->datalen % MSGSM_FRAME_SIZE)) {
00449       size = MSGSM_FRAME_SIZE;
00450       fs->secondhalf = 0;
00451    } else {
00452       size = GSM_FRAME_SIZE;
00453    }
00454    for (len = 0; len < f->datalen ; len += size) {
00455       int res;
00456       unsigned char *src, msdata[MSGSM_FRAME_SIZE];
00457       if (fs->secondhalf) {   /* second half of raw gsm to be converted */
00458          memcpy(s->buf + GSM_FRAME_SIZE, f->data.ptr + len, GSM_FRAME_SIZE);
00459          conv66((unsigned char *) s->buf, msdata);
00460          src = msdata;
00461          fs->secondhalf = 0;
00462       } else if (size == GSM_FRAME_SIZE) {   /* first half of raw gsm */
00463          memcpy(s->buf, f->data.ptr + len, GSM_FRAME_SIZE);
00464          src = NULL; /* nothing to write */
00465          fs->secondhalf = 1;
00466       } else { /* raw msgsm data */
00467          src = f->data.ptr + len;
00468       }
00469       if (src && (res = fwrite(src, 1, MSGSM_FRAME_SIZE, s->f)) != MSGSM_FRAME_SIZE) {
00470          ast_log(LOG_WARNING, "Bad write (%d/65): %s\n", res, strerror(errno));
00471          return -1;
00472       }
00473    }
00474    return 0;
00475 }
00476 
00477 static int wav_seek(struct ast_filestream *fs, off_t sample_offset, int whence)
00478 {
00479    off_t offset = 0, min = MSGSM_DATA_OFFSET, distance, max, cur;
00480    struct wavg_desc *s = (struct wavg_desc *)fs->_private;
00481 
00482    if ((cur = ftello(fs->f)) < 0) {
00483       ast_log(AST_LOG_WARNING, "Unable to determine current position in WAV filestream %p: %s\n", fs, strerror(errno));
00484       return -1;
00485    }
00486 
00487    if (fseeko(fs->f, 0, SEEK_END) < 0) {
00488       ast_log(AST_LOG_WARNING, "Unable to seek to end of WAV filestream %p: %s\n", fs, strerror(errno));
00489       return -1;
00490    }
00491 
00492    /* XXX ideally, should round correctly */
00493    if ((max = ftello(fs->f)) < 0) {
00494       ast_log(AST_LOG_WARNING, "Unable to determine max position in WAV filestream %p: %s\n", fs, strerror(errno));
00495       return -1;
00496    }
00497 
00498    /* Compute the distance in bytes, rounded to the block size */
00499    distance = (sample_offset/MSGSM_SAMPLES) * MSGSM_FRAME_SIZE;
00500    if (whence == SEEK_SET)
00501       offset = distance + min;
00502    else if (whence == SEEK_CUR || whence == SEEK_FORCECUR)
00503       offset = distance + cur;
00504    else if (whence == SEEK_END)
00505       offset = max - distance;
00506    /* always protect against seeking past end of header */
00507    if (offset < min)
00508       offset = min;
00509    if (whence != SEEK_FORCECUR) {
00510       if (offset > max)
00511          offset = max;
00512    } else if (offset > max) {
00513       int i;
00514       fseek(fs->f, 0, SEEK_END);
00515       for (i=0; i< (offset - max) / MSGSM_FRAME_SIZE; i++) {
00516          if (!fwrite(msgsm_silence, 1, MSGSM_FRAME_SIZE, fs->f)) {
00517             ast_log(LOG_WARNING, "fwrite() failed: %s\n", strerror(errno));
00518          }
00519       }
00520    }
00521    s->secondhalf = 0;
00522    return fseeko(fs->f, offset, SEEK_SET);
00523 }
00524 
00525 static int wav_trunc(struct ast_filestream *fs)
00526 {
00527    int fd;
00528    off_t cur;
00529 
00530    if ((fd = fileno(fs->f)) < 0) {
00531       ast_log(AST_LOG_WARNING, "Unable to determine file descriptor for WAV filestream %p: %s\n", fs, strerror(errno));
00532       return -1;
00533    }
00534    if ((cur = ftello(fs->f)) < 0) {
00535       ast_log(AST_LOG_WARNING, "Unable to determine current position in WAV filestream %p: %s\n", fs, strerror(errno));
00536       return -1;
00537    }
00538    /* Truncate file to current length */
00539    if (ftruncate(fd, cur)) {
00540       return -1;
00541    }
00542    return update_header(fs->f);
00543 }
00544 
00545 static off_t wav_tell(struct ast_filestream *fs)
00546 {
00547    off_t offset;
00548    offset = ftello(fs->f);
00549    /* since this will most likely be used later in play or record, lets stick
00550     * to that level of resolution, just even frames boundaries */
00551    return (offset - MSGSM_DATA_OFFSET)/MSGSM_FRAME_SIZE*MSGSM_SAMPLES;
00552 }
00553 
00554 static struct ast_format_def wav49_f = {
00555    .name = "wav49",
00556    .exts = "WAV|wav49",
00557    .open =  wav_open,
00558    .rewrite = wav_rewrite,
00559    .write = wav_write,
00560    .seek = wav_seek,
00561    .trunc = wav_trunc,
00562    .tell = wav_tell,
00563    .read = wav_read,
00564    .close = wav_close,
00565    .buf_size = 2*GSM_FRAME_SIZE + AST_FRIENDLY_OFFSET,
00566    .desc_size = sizeof(struct wavg_desc),
00567 };
00568 
00569 static int load_module(void)
00570 {
00571    wav49_f.format = ast_format_gsm;
00572    if (ast_format_def_register(&wav49_f))
00573       return AST_MODULE_LOAD_FAILURE;
00574    return AST_MODULE_LOAD_SUCCESS;
00575 }
00576 
00577 static int unload_module(void)
00578 {
00579    return ast_format_def_unregister(wav49_f.name);
00580 }
00581 
00582 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "Microsoft WAV format (Proprietary GSM)",
00583    .support_level = AST_MODULE_SUPPORT_CORE,
00584    .load = load_module,
00585    .unload = unload_module,
00586    .load_pri = AST_MODPRI_APP_DEPEND
00587 );

Generated on Thu Apr 16 06:27:35 2015 for Asterisk - The Open Source Telephony Project by  doxygen 1.5.6