d56253120b3d7c97a5b176ff6c39f37173cc1169
[lcr.git] / tones.c
1 /*****************************************************************************\
2 **                                                                           **
3 ** PBX4Linux                                                                 **
4 **                                                                           **
5 **---------------------------------------------------------------------------**
6 ** Copyright: Andreas Eversberg                                              **
7 **                                                                           **
8 ** opening and reading tone                                                  **
9 **                                                                           **
10 \*****************************************************************************/ 
11
12 #include "main.h"
13
14 /* 
15 notes about codecs:
16
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.
21
22 */ 
23
24
25 /*
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
28  */
29 struct fmt {
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) */
36 };
37 int open_tone(char *file, int *codec, signed int *length, signed int *left)
38 {
39         int fh;
40         char filename[256];        
41         char linkname[256];        
42         unsigned char buffer[256];
43         struct fmt *fmt;
44         int channels = 0, bytes = 0;
45         unsigned int size, chunk;
46         int gotfmt = 0;
47         struct stat _stat;
48         int linksize;
49         int l;
50         char *p;
51         int __attribute__((__unused__)) ret;
52
53
54         /* try to open the law file */
55         SPRINT(filename, "%s.isdn", file);
56         if ((fh = open(filename, O_RDONLY)) >= 0) {
57                 /* stat tone */
58                 l = 0;
59                 while(42) {
60                         if (l >= 10) {
61                                 close(fh);
62                                 PERROR("Link chain too deep: '%s'\n", filename);
63                                 return(-1);
64                         }
65                         if (lstat(filename, &_stat) == -1) {
66                                 close(fh);
67                                 PERROR("Cannot stat file: '%s'\n", filename);
68                                 return(-1);
69                         }
70                         if (!S_ISLNK(_stat.st_mode)) {
71                                 break;
72                         }
73                         if ((linksize=readlink(filename, linkname, sizeof(linkname))) > 0) {
74                                 linkname[linksize] = '\0';
75                         } else {
76                                 close(fh);
77                                 PERROR("Cannot read link information: '%s'\n", filename);
78                                 return(-1);
79                         }
80                         if (linkname[0] == '/') /* absolute link */
81                                 SCPY(filename, linkname);
82                         else { /* relative link */
83                                 /* remove filename */
84                                 p = filename;
85                                 while(strchr(p, '/')) {
86                                         p = strchr(p, '/')+1;
87                                 }
88                                 *p = 0;
89                                 /* concat the link */
90                                 SCAT(filename, linkname);
91                         }
92 //printf("follow link: %s\n", filename);
93                         l++;
94                 }
95                 if (length)
96                         *length = _stat.st_size;
97                 if (left)
98                         *left = _stat.st_size;
99                 if (codec)
100                         *codec = CODEC_LAW;
101                 return(fh);
102         }
103
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)) {
111                         close(fh);
112                         errno = 0;
113                         PERROR("%s is no riff file!\n", filename);
114                         return(-1);
115                 }
116 //              printf("%c%c%c%c size=%ld\n",buffer[0],buffer[1],buffer[2],buffer[3],size);
117                 ret = read(fh, buffer, 4);
118                 size -= 4;
119                 if (!!strncmp((char *)buffer, "WAVE", 4)) {
120                         close(fh);
121                         errno = 0;
122                         PERROR("%s is no wave file!\n", filename);
123                         return(-1);
124                 }
125                 while(size) {
126                         if (size>0 && size<8) {
127                                 close(fh);
128                                 errno = 0;
129                                 PERROR("Remaining file size %ld not large enough for next chunk.\n",size);
130                                 return(-1);
131                         }
132                         ret = read(fh, buffer, 8);
133                         chunk=(buffer[4]) + (buffer[5]<<8) + (buffer[6]<<16) + (buffer[7]<<24);
134                         size -= (8+chunk);
135 //                      printf("%c%c%c%c length=%d\n",buffer[0],buffer[1],buffer[2],buffer[3],chunk);
136                         if (size < 0) {
137                                 close(fh);
138                                 errno = 0;
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);
140                                 return(-1);
141                         }
142                         if (!strncmp((char *)buffer, "fmt ", 4)) {
143                                 if (chunk < 16) {
144                                         close(fh);
145                                         errno = 0;
146                                         PERROR("File %s Fmt chunk illegal size.\n", filename);
147                                         return(-1);
148                                 }
149                                 ret = read(fh, buffer, chunk);
150                                 fmt = (struct fmt *)buffer;
151                                 if (fmt->channels<1 || fmt->channels>2) {
152                                         close(fh);
153                                         errno = 0;
154                                         PERROR("File %s Only support one or two channels file.\n", filename);
155                                         return(-1);
156                                 }
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);
161                                 }
162 //                              printf("Sample Rate: %ld\n", fmt->sample_rate);
163                                 if (fmt->bits_sample!=8 && fmt->bits_sample!=16) {
164                                         close(fh);
165                                         errno = 0;
166                                         PERROR("File %s has neigher 8 nor 16 bit samples.\n", filename);
167                                         return(-1);
168                                 }
169                                 bytes = (fmt->bits_sample==16)?2:1;
170 //                              printf("Bit-Resolution: %d\n", bytes*16-16);
171                                 gotfmt = 1;
172                         } else
173                         if (!strncmp((char *)buffer, "data", 4)) {
174                                 if (!gotfmt) {
175                                         close(fh);
176                                         errno = 0;
177                                         PERROR("File %s No fmt chunk found before data chunk.\n", filename);
178                                         return(-1);
179                                 }
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) {
182                                         if (codec)
183                                                 *codec = CODEC_MONO;
184                                         if (length)
185                                                 *length = ((signed int)chunk)>>1;
186                                         if (left)
187                                                 *left = ((signed int)chunk)>>1;
188 //                                      printf("left=%d\n",*left);
189                                 } else
190                                 if (bytes==2 && channels==2) {
191                                         if (codec)
192                                                 *codec = CODEC_STEREO;
193                                         if (length)
194                                                 *length = ((signed int)chunk)>>2;
195                                         if (left)
196                                                 *left = ((signed int)chunk)>>2;
197                                 } else
198                                 if (bytes==1 && channels==1) {
199                                         if (codec)
200                                                 *codec = CODEC_8BIT;
201                                         if (length)
202                                                 *length = (signed int)chunk;
203                                         if (left)
204                                                 *left = (signed int)chunk;
205                                 } else {
206                                         close(fh);
207                                         errno = 0;
208                                         PERROR("File %s Is not MONO8, MONO16 nor STEREO16.\n", filename);
209                                         return(-1);
210                                 }
211                                 return(fh);
212                         } else {
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);
217                                 }
218                                 if (chunk)
219                                         ret = read(fh, buffer, chunk);
220                         }
221                         
222                 }
223                 if (!gotfmt) {
224                         close(fh);
225                         errno = 0;
226                         PERROR("File %s No fmt chunk found in file.\n", filename);
227                         return(-1);
228                 }
229                 close(fh);
230                 errno = 0;
231                 PERROR("File %s No data chunk found in file.\n", filename);
232                 return(-1);
233         }
234
235         return(-1);
236 }
237
238
239 /*
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
243  */
244 int read_tone(int fh, unsigned char *buffer, int codec, int len, signed int size, signed int *left, int speed)
245 {
246         int l = 0;
247         int offset;
248         signed short buffer16[len], *buf16 = buffer16;
249         signed short buffer32[len<<1], *buf32 = buffer32;
250         unsigned char buffer8[len], *buf8 = buffer8;
251         signed int sample;
252         int i = 0;
253 //printf("left=%ld\n",*left);
254
255         /* if no *left is given (law has unknown length) */
256         if (!left)
257                 goto unknown_length;
258
259         if (speed!=1) {
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 */
263                 if (*left < 0) {
264                         /* eof */
265                         *left = 0;
266                         return(0);
267                 }
268                 if (*left >= size) {
269                         /* eof */
270                         *left = size;
271                         return(0);
272                 }
273         }
274
275         if (*left == 0)
276                 return(0);
277
278         if (*left < len)
279                 len = *left;
280         unknown_length:
281         switch(codec) {
282                 case CODEC_LAW:
283                 l = read(fh, buffer, len); /* as is */
284                 break;
285
286                 case CODEC_MONO:
287                         l = read(fh, buf16, len<<1);
288                         if (l>0) {
289                                 l = l>>1;
290                                 while(i < l) {
291                                         sample = *buf16++;
292                                         if (sample < -32767)
293                                                 sample = -32767;
294                                         if (sample > 32767)
295                                                 sample = 32767;
296                                         *buffer++ = audio_s16_to_law[sample & 0xffff];
297                                         i++;
298                                 }
299                         }
300                 break;
301
302                 case CODEC_STEREO:
303                 l = read(fh, buf32, len<<2);
304                 if (l>0) {
305                         l = l>>2;
306                         while(i < l) {
307                                 sample = (*buf32++);
308                                 sample += (*buf32++);
309                                 if (sample < -32767)
310                                         sample = -32767;
311                                 if (sample > 32767)
312                                         sample = 32767;
313                                 *buffer++ = audio_s16_to_law[sample & 0xffff];
314                                 i++;
315                         }
316                 }
317                 break;
318
319                 case CODEC_8BIT:
320                 l = read(fh, buf8, len);
321                 if (l>0) {
322                         while(i < l) {
323                                 *buffer++ = audio_s16_to_law[(((*buf8++)<<8)-0x8000) & 0xffff];
324                                 i++;
325                         }
326                 }
327                 break;
328
329                 default:
330                 FATAL("codec %d is not supported.\n", codec);
331         }
332
333         if (l>0 && left)
334                 *left -= l;
335         return(l);
336 }
337
338
339 struct toneset *toneset_first = NULL;
340
341 /*
342  * free fetched tones
343  */
344 void free_tones(void)
345 {
346         struct toneset *toneset_temp;
347         struct tonesettone *tonesettone_temp;
348         void *temp;
349
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));
357                         memuse--;
358                 }
359                 temp = toneset_temp;
360                 toneset_temp = toneset_temp->next;
361                 FREE(temp, sizeof(struct toneset));
362                 memuse--;
363         }
364         toneset_first = NULL;
365 }
366
367 /*
368  * fetch tones as specified in options.conf
369  */
370 int fetch_tones(void)
371 {
372         DIR *dir;
373         struct dirent *dirent;
374         struct toneset **toneset_nextpointer;
375         struct tonesettone **tonesettone_nextpointer;
376         char *p, *p_next;
377         char path[256];
378         char filename[256], name[256];
379         int fh;
380         int tone_codec;
381         signed int tone_size, tone_left;
382         unsigned int memory = 0;
383         int samples = 0;
384
385         /* if disabled */
386         if (!options.fetch_tones)
387                 return(1);
388
389         toneset_nextpointer = &toneset_first;
390         p = options.fetch_tones;
391         if (*p == '\0')
392                 return(1);
393
394         while (*p) {
395                 p_next = p;
396                 while(*p_next) {
397                         if (*p_next == ',') {
398                                 *p_next = '\0';
399                                 p_next++;
400                                 break;
401                         }
402                         p_next++;
403                 }
404
405                 /* remove trailing / */
406                 if (*p) if (p[strlen(p)-1] == '/')
407                         p[strlen(p)-1] = '\0';
408
409                 printf("PBX: Fetching tones '%s'\n", p);
410                 PDEBUG(DEBUG_PORT, "fetching tones directory '%s'\n", p);
411
412                 *toneset_nextpointer = (struct toneset *)MALLOC(sizeof(struct toneset));
413                 memuse++;
414                 memory += sizeof(struct toneset);
415                 SCPY((*toneset_nextpointer)->directory, p);
416                 tonesettone_nextpointer = &(*toneset_nextpointer)->first;
417
418                 SPRINT(path, "%s/%s", SHARE_DATA, p);
419                 dir = opendir(path);
420                 if (dir == NULL) {
421                         PERROR("Tone set not found: '%s'\n", path);
422                         return(0);
423                 }
424
425                 while((dirent=readdir(dir))) {
426                         SPRINT(name, "%s", dirent->d_name);
427
428                         /* remove .isdn and .wave */
429                         if (strlen(name) >= 4) {
430                                 if (!strcmp(name+strlen(name)-4, ".wav"))
431                                         name[strlen(name)-4] = '\0';
432                         }
433                         if (strlen(name) >= 5) {
434                                 if (!strcmp(name+strlen(name)-5, ".isdn"))
435                                         name[strlen(name)-5] = '\0';
436                         }
437
438                         SPRINT(filename, "%s/%s", path, name);
439
440                         /* skip . / .. */
441                         if (!strcmp(dirent->d_name, "."))
442                                 continue;
443                         if (!strcmp(dirent->d_name, ".."))
444                                 continue;
445
446                         /* open file */
447                         fh = open_tone(filename, &tone_codec, &tone_size, &tone_left);
448                         if (fh < 0) {
449                                 PERROR("Cannot open file: '%s'\n", filename);
450                                 continue;
451                         }
452                         fduse++;
453
454                         if (tone_size < 0) {
455                                 PERROR("File has 0-length: '%s'\n", filename);
456                                 close(fh);
457                                 fduse--;
458                                 continue;
459                         }
460
461                         /* Allocate tone */
462                         *tonesettone_nextpointer = (struct tonesettone *)MALLOC(sizeof(struct tonesettone)+tone_size);
463                         memuse++;
464 //printf("tone:%s, %ld bytes\n", name, tone_size);
465                         memory += sizeof(struct tonesettone)+tone_size;
466                         samples ++;
467
468                         /* load tone */
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);
473
474                         close(fh);
475                         fduse--;
476                                  
477                         tonesettone_nextpointer = &((*tonesettone_nextpointer)->next);
478                 }
479
480                 toneset_nextpointer = &((*toneset_nextpointer)->next);
481                 p = p_next;
482         }
483
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);
486
487         return(1);
488
489
490
491 /*
492  * opens the fetched tone (if available)
493  */
494 void *open_tone_fetched(char *dir, char *file, int *codec, signed int *length, signed int *left)
495 {
496         struct toneset *toneset;
497         struct tonesettone *tonesettone;
498
499         /* if anything fetched */
500         if (!toneset_first)
501                 return(NULL);
502
503         /* find set */
504         toneset = toneset_first;
505         while(toneset) {
506 //printf("1. comparing '%s' with '%s'\n", toneset->directory, dir);
507                 if (!strcmp(toneset->directory, dir))
508                         break;
509                 toneset = toneset->next;
510         }
511         if (!toneset)
512                 return(NULL);
513
514         /* find tone */
515         tonesettone = toneset->first;
516         while(tonesettone) {
517 //printf("2. comparing '%s' with '%s'\n", tonesettone->name, file);
518                 if (!strcmp(tonesettone->name, file))
519                         break;
520                 tonesettone = tonesettone->next;
521         }
522         if (!tonesettone)
523                 return(NULL);
524
525         /* return information */
526         if (length)
527                 *length = tonesettone->size;
528         if (left)
529                 *left = tonesettone->size;
530         if (codec)
531                 *codec = tonesettone->codec;
532 //printf("size=%ld, data=%08x\n", tonesettone->size, tonesettone->data);
533         return(tonesettone->data);
534 }
535
536
537 /*
538  * read from fetched tone, check size
539  * the len must be the number of samples, NOT for the bytes to read!!
540  */
541 int read_tone_fetched(void **fetched, void *buffer, int len, signed int size, signed int *left, int speed)
542 {
543         int l;
544 //printf("left=%ld\n",*left);
545
546         /* if no *left is given (law has unknown length) */
547         if (!left)
548                 return(0);
549
550         if (*left == 0)
551                 return(0);
552
553         if (*left < len)
554                 len = *left;
555
556         memcpy(buffer, *fetched, len);
557         *((char **)fetched) += len;
558         l = len;
559
560         if (l>0 && left)
561                 *left -= l;
562         return(l);
563 }
564