1 /*****************************************************************************\
5 **---------------------------------------------------------------------------**
6 ** Copyright: Andreas Eversberg **
8 ** opening and reading tone **
10 \*****************************************************************************/
17 CODEC_OFF is a none accepted value
18 CODEC_LAW is 8 bit (1 byte) data 8khz
19 other codecs are 16 bit (2 bytes) data 8khz
20 the read_tone() will return law or 16bit mono. the read_tone will convert all other formats to 16bit mono.
26 * open the tone (don't increase fhuse, since it is done after calling this function)
27 * NOTE: length and left will be set to the number of samples, NOT bytes
30 unsigned short stereo; /* 1 = pcm, 2 = adpcm */
31 unsigned short channels; /* number of channels */
32 unsigned int sample_rate; /* sample rate */
33 unsigned int data_rate; /* data rate */
34 unsigned short bytes_sample; /* bytes per sample (all channels) */
35 unsigned short bits_sample; /* bits per sample (one channel) */
37 int open_tone(char *file, int *codec, signed int *length, signed int *left)
42 unsigned char buffer[256];
44 int channels = 0, bytes = 0;
45 unsigned int size, chunk;
54 /* try to open the law file */
55 SPRINT(filename, "%s.isdn", file);
56 if ((fh = open(filename, O_RDONLY)) >= 0) {
62 PERROR("Link chain too deep: '%s'\n", filename);
65 if (lstat(filename, &_stat) == -1) {
67 PERROR("Cannot stat file: '%s'\n", filename);
70 if (!S_ISLNK(_stat.st_mode)) {
73 if ((linksize=readlink(filename, linkname, sizeof(linkname))) > 0) {
74 linkname[linksize] = '\0';
77 PERROR("Cannot read link information: '%s'\n", filename);
80 if (linkname[0] == '/') /* absolute link */
81 SCPY(filename, linkname);
82 else { /* relative link */
85 while(strchr(p, '/')) {
90 SCAT(filename, linkname);
92 //printf("follow link: %s\n", filename);
96 *length = _stat.st_size;
98 *left = _stat.st_size;
104 /* try to open the wave file */
105 SPRINT(filename, "%s.wav", file);
106 if ((fh = open(filename, O_RDONLY)) >= 0) {
107 /* get wave header */
108 ret = read(fh, buffer, 8);
109 size=(buffer[4]) + (buffer[5]<<8) + (buffer[6]<<16) + (buffer[7]<<24);
110 if (!!strncmp((char *)buffer, "RIFF", 4)) {
113 PERROR("%s is no riff file!\n", filename);
116 // printf("%c%c%c%c size=%ld\n",buffer[0],buffer[1],buffer[2],buffer[3],size);
117 ret = read(fh, buffer, 4);
119 if (!!strncmp((char *)buffer, "WAVE", 4)) {
122 PERROR("%s is no wave file!\n", filename);
126 if (size>0 && size<8) {
129 PERROR("Remaining file size %ld not large enough for next chunk.\n",size);
132 ret = read(fh, buffer, 8);
133 chunk=(buffer[4]) + (buffer[5]<<8) + (buffer[6]<<16) + (buffer[7]<<24);
135 // printf("%c%c%c%c length=%d\n",buffer[0],buffer[1],buffer[2],buffer[3],chunk);
139 PERROR("Chunk '%c%c%c%c' is larger than remainig file size (length=%ld)\n",buffer[0],buffer[1],buffer[2],buffer[3], chunk);
142 if (!strncmp((char *)buffer, "fmt ", 4)) {
146 PERROR("File %s Fmt chunk illegal size.\n", filename);
149 ret = read(fh, buffer, chunk);
150 fmt = (struct fmt *)buffer;
151 if (fmt->channels<1 || fmt->channels>2) {
154 PERROR("File %s Only support one or two channels file.\n", filename);
157 channels = fmt->channels;
158 // printf("Channels: %d\n", channels);
159 if (fmt->sample_rate != 8000) {
160 PERROR("Warning: File %s has sample rate of %ld.\n", filename, fmt->sample_rate);
162 // printf("Sample Rate: %ld\n", fmt->sample_rate);
163 if (fmt->bits_sample!=8 && fmt->bits_sample!=16) {
166 PERROR("File %s has neigher 8 nor 16 bit samples.\n", filename);
169 bytes = (fmt->bits_sample==16)?2:1;
170 // printf("Bit-Resolution: %d\n", bytes*16-16);
173 if (!strncmp((char *)buffer, "data", 4)) {
177 PERROR("File %s No fmt chunk found before data chunk.\n", filename);
180 // printf("Length: %ld samples (%ld.%03ld seconds)\n", chunk/bytes/channels, chunk/bytes/channels/8000, ((chunk/bytes/channels)%8000)*1000/8000);
181 if (bytes==2 && channels==1) {
185 *length = ((signed int)chunk)>>1;
187 *left = ((signed int)chunk)>>1;
188 // printf("left=%d\n",*left);
190 if (bytes==2 && channels==2) {
192 *codec = CODEC_STEREO;
194 *length = ((signed int)chunk)>>2;
196 *left = ((signed int)chunk)>>2;
198 if (bytes==1 && channels==1) {
202 *length = (signed int)chunk;
204 *left = (signed int)chunk;
208 PERROR("File %s Is not MONO8, MONO16 nor STEREO16.\n", filename);
213 // PDEBUG(DEBUG_PORT, "Unknown chunk '%c%c%c%c'\n",buffer[0],buffer[1],buffer[2],buffer[3]);
214 while(chunk > sizeof(buffer)) {
215 ret = read(fh, buffer, sizeof(buffer));
216 chunk -= sizeof(buffer);
219 ret = read(fh, buffer, chunk);
226 PERROR("File %s No fmt chunk found in file.\n", filename);
231 PERROR("File %s No data chunk found in file.\n", filename);
240 * read from tone, check size
241 * the len must be the number of samples, NOT for the bytes to read!!
242 * the data returned is law-code
244 int read_tone(int fh, unsigned char *buffer, int codec, int len, signed int size, signed int *left, int speed)
248 signed short buffer16[len], *buf16 = buffer16;
249 signed short buffer32[len<<1], *buf32 = buffer32;
250 unsigned char buffer8[len], *buf8 = buffer8;
253 //printf("left=%ld\n",*left);
255 /* if no *left is given (law has unknown length) */
260 offset = ((len&(~4)) * (speed-1));
261 lseek(fh, offset, SEEK_CUR); /* step fowards, backwards (len must be round to 4 bytes, to be sure, that 16bit stereo will not drift out of sync)*/
262 *left -= offset; /* correct the current bytes left */
283 l = read(fh, buffer, len); /* as is */
287 l = read(fh, buf16, len<<1);
296 *buffer++ = audio_s16_to_law[sample & 0xffff];
303 l = read(fh, buf32, len<<2);
308 sample += (*buf32++);
313 *buffer++ = audio_s16_to_law[sample & 0xffff];
320 l = read(fh, buf8, len);
323 *buffer++ = audio_s16_to_law[(((*buf8++)<<8)-0x8000) & 0xffff];
330 FATAL("codec %d is not supported.\n", codec);
339 struct toneset *toneset_first = NULL;
344 void free_tones(void)
346 struct toneset *toneset_temp;
347 struct tonesettone *tonesettone_temp;
350 toneset_temp = toneset_first;
351 while(toneset_temp) {
352 tonesettone_temp = toneset_temp->first;
353 while(tonesettone_temp) {
354 temp = tonesettone_temp;
355 tonesettone_temp = tonesettone_temp->next;
356 FREE(temp, sizeof(struct tonesettone));
360 toneset_temp = toneset_temp->next;
361 FREE(temp, sizeof(struct toneset));
364 toneset_first = NULL;
368 * fetch tones as specified in options.conf
370 int fetch_tones(void)
373 struct dirent *dirent;
374 struct toneset **toneset_nextpointer;
375 struct tonesettone **tonesettone_nextpointer;
378 char filename[256], name[256];
381 signed int tone_size, tone_left;
382 unsigned int memory = 0;
386 if (!options.fetch_tones)
389 toneset_nextpointer = &toneset_first;
390 p = options.fetch_tones;
397 if (*p_next == ',') {
405 /* remove trailing / */
406 if (*p) if (p[strlen(p)-1] == '/')
407 p[strlen(p)-1] = '\0';
409 printf("PBX: Fetching tones '%s'\n", p);
410 PDEBUG(DEBUG_PORT, "fetching tones directory '%s'\n", p);
412 *toneset_nextpointer = (struct toneset *)MALLOC(sizeof(struct toneset));
414 memory += sizeof(struct toneset);
415 SCPY((*toneset_nextpointer)->directory, p);
416 tonesettone_nextpointer = &(*toneset_nextpointer)->first;
418 SPRINT(path, "%s/%s", SHARE_DATA, p);
421 PERROR("Tone set not found: '%s'\n", path);
425 while((dirent=readdir(dir))) {
426 SPRINT(name, "%s", dirent->d_name);
428 /* remove .isdn and .wave */
429 if (strlen(name) >= 4) {
430 if (!strcmp(name+strlen(name)-4, ".wav"))
431 name[strlen(name)-4] = '\0';
433 if (strlen(name) >= 5) {
434 if (!strcmp(name+strlen(name)-5, ".isdn"))
435 name[strlen(name)-5] = '\0';
438 SPRINT(filename, "%s/%s", path, name);
441 if (!strcmp(dirent->d_name, "."))
443 if (!strcmp(dirent->d_name, ".."))
447 fh = open_tone(filename, &tone_codec, &tone_size, &tone_left);
449 PERROR("Cannot open file: '%s'\n", filename);
455 PERROR("File has 0-length: '%s'\n", filename);
462 *tonesettone_nextpointer = (struct tonesettone *)MALLOC(sizeof(struct tonesettone)+tone_size);
464 //printf("tone:%s, %ld bytes\n", name, tone_size);
465 memory += sizeof(struct tonesettone)+tone_size;
469 read_tone(fh, (*tonesettone_nextpointer)->data, tone_codec, tone_size, tone_size, &tone_left, 1);
470 (*tonesettone_nextpointer)->size = tone_size;
471 (*tonesettone_nextpointer)->codec = (tone_codec==CODEC_LAW)?CODEC_LAW:CODEC_MONO;
472 SCPY((*tonesettone_nextpointer)->name, name);
477 tonesettone_nextpointer = &((*tonesettone_nextpointer)->next);
480 toneset_nextpointer = &((*toneset_nextpointer)->next);
484 printf("PBX: Memory used for tones: %d bytes (%d samples)\n", memory, samples);
485 PDEBUG(DEBUG_PORT, "Memory used for tones: %ld bytes (%d samples)\n", memory, samples);
492 * opens the fetched tone (if available)
494 void *open_tone_fetched(char *dir, char *file, int *codec, signed int *length, signed int *left)
496 struct toneset *toneset;
497 struct tonesettone *tonesettone;
499 /* if anything fetched */
504 toneset = toneset_first;
506 //printf("1. comparing '%s' with '%s'\n", toneset->directory, dir);
507 if (!strcmp(toneset->directory, dir))
509 toneset = toneset->next;
515 tonesettone = toneset->first;
517 //printf("2. comparing '%s' with '%s'\n", tonesettone->name, file);
518 if (!strcmp(tonesettone->name, file))
520 tonesettone = tonesettone->next;
525 /* return information */
527 *length = tonesettone->size;
529 *left = tonesettone->size;
531 *codec = tonesettone->codec;
532 //printf("size=%ld, data=%08x\n", tonesettone->size, tonesettone->data);
533 return(tonesettone->data);
538 * read from fetched tone, check size
539 * the len must be the number of samples, NOT for the bytes to read!!
541 int read_tone_fetched(void **fetched, void *buffer, int len, signed int size, signed int *left, int speed)
544 //printf("left=%ld\n",*left);
546 /* if no *left is given (law has unknown length) */
556 memcpy(buffer, *fetched, len);
557 *((char **)fetched) += len;