Alex: Added the new sources for terminatorX 3.5
[terminatorX.git] / src / wav_read.c
1 /*
2     wav_read.c - taken from wav-tools 1.1
3     Copyright (C) by Colin Ligertwood
4
5     This program is free software; you can redistribute it and/or modify
6     it under the terms of the GNU General Public License as published by
7     the Free Software Foundation; either version 2 of the License, or
8     (at your option) any later version.
9
10     This program is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13     GNU General Public License for more details.
14
15     You should have received a copy of the GNU General Public License
16     along with this program; if not, write to the Free Software
17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18     
19     Changes:
20     
21     11 Mar 1999: added license hint
22     
23     20 Mar 1999: using types in sys/types for interplatform
24                  compability.
25                  
26     20 Mar 1999: support for big endian machines
27     
28     07 Apr 1999: had to change the macros ... i wish I hadn't switched to C ..
29     
30     29 Apr 1999: hacked to work with FILE* instead of file descriptors
31                  and support for sox and mpg123
32 */
33
34 /* operations for verifying and reading wav files. */
35
36 #include <stdio.h>
37 #include <fcntl.h>
38 #include <sys/stat.h>
39 #include "wav_file.h"
40 #ifndef WIN32
41 #include <unistd.h>
42 #endif
43 #include <string.h>
44 #include "endian.h"
45 #include "tX_types.h"
46
47 /* Read little endian 16bit values little endian
48 */
49 #ifdef BIG_ENDIAN_MACHINE
50
51 #define read16(x); \
52         p = (int8_t *) &tmp; \
53         p[0] = info->head[x]; \
54         p[1] = info->head[x+1]; \
55         swap16(&tmp); \
56         return(tmp);
57
58 #else
59
60 #define read16(x); \
61         p = (int8_t *) &tmp; \
62         p[0] = info->head[x]; \
63         p[1] = info->head[x+1]; \
64         return(tmp);
65
66 #endif  
67         
68
69 /* Read little endian 32bit values little endian
70 */
71 #ifdef BIG_ENDIAN_MACHINE
72
73 #define read32(x); \
74         p = (int8_t *) &tmp; \
75         p[0] = info->head[x]; \
76         p[1] = info->head[x+1]; \
77         p[2] = info->head[x+2]; \
78         p[3] = info->head[x+3]; \
79         swap32(&tmp); \
80         return (tmp);
81
82 #else
83
84 #define read32(x); \
85         p = (int8_t *) &tmp; \
86         p[0] = info->head[x]; \
87         p[1] = info->head[x+1]; \
88         p[2] = info->head[x+2]; \
89         p[3] = info->head[x+3]; \
90         return (tmp);
91
92 #endif
93
94         /* wav header is 44 bytes long */
95 FILE* open_wav(char *header, char file_name[], int *mode){
96         FILE* handle;
97 #ifdef USE_SOX_INPUT
98         char buffer[PATH_MAX*2];
99 #ifdef USE_MPG123_INPUT
100         char *end;
101         
102         end=(char *) strrchr(file_name, (int) '.');
103
104         *mode=0;
105         
106         if (end)
107         {
108                 if (strlen(end)>3)
109                 {
110                         if (((end[1]=='m') || (end[1]=='M')) && ((end[2]=='p') || (end[2]=='P')))
111                         {
112                                 sprintf(buffer, MPG123_STR, file_name); 
113 #ifdef USE_MPG123_FAST                                                          
114                                 *mode=1;
115 #endif                          
116                         }
117                         else
118                         {
119                                 sprintf(buffer, SOX_STR, file_name);                            
120                         }                       
121                 }
122                 else
123                 {
124                                 sprintf(buffer, SOX_STR, file_name);                            
125                 }
126         }       
127                 
128 #else   
129         sprintf(buffer, SOX_STR, file_name);    
130 #endif
131         handle = popen(buffer, "r");
132 #else   
133         handle = fopen(file_name, "r");
134         if(handle)
135         fread((char *) header, 1, 44, handle);
136 #endif  
137         return(handle);
138 }
139
140 int16_t get_wav_format(wav_sig *info){
141         int16_t tmp; 
142         int8_t *p; 
143
144         read16(20);
145 }
146
147         /* mono or stereo */
148 int8_t get_wav_channels(wav_sig *info){
149         return(info->head[22]);
150 //      read16(22);
151 }
152
153         /* sample rate */
154 int32_t get_wav_srate(wav_sig *info){
155         int32_t tmp; 
156         int8_t *p; 
157         
158         read32(24);
159 }
160
161 int32_t get_wav_bps(wav_sig *info){
162         int32_t tmp; 
163         int8_t *p; 
164
165         read32(28);
166 }
167
168 int8_t get_wav_blkalign(wav_sig *info){
169         return(info->head[32]);
170 //      read16(32);
171 }
172
173         /* sample depth (8bit or 16bit) */
174 int8_t get_wav_depth(wav_sig *info){
175         return(info->head[34]);
176 //      read16(34);
177 }
178
179         /* data section only  ==  totalfile - 44 */
180 int32_t get_wav_len(wav_sig *info){
181         int32_t tmp; 
182         int8_t *p; 
183
184         read32(40);
185 }
186
187
188 FILE *init_wav_read(char file_name[], wav_sig *info){
189         int mode=0;
190         
191         info->handle = open_wav(info->head, file_name, &mode);
192 #ifdef USE_SOX_INPUT
193         info->has_host_order=mode;
194 #endif  
195         strcpy(info->name,file_name);
196         info->chans = get_wav_channels(info);
197         info->srate = get_wav_srate(info);
198         info->bps   = get_wav_bps(info);
199         info->blkalign = get_wav_blkalign(info);
200         info->depth = get_wav_depth(info);
201         info->len   = get_wav_len(info);
202         return(info->handle);   
203 }
204
205 void wav_close(FILE* wav)
206 {
207         if (wav)
208         {
209 #ifdef USE_SOX_INPUT
210         pclose(wav);
211 #else
212         fclose(wav);
213 #endif
214         }
215 }