00001 #ifndef __CABCTRL_H 00002 #define __CABCTRL_H 00003 00004 00005 /************************************/ 00006 /* 1992 (c) Grupo de Voz - DAET */ 00007 /* ETSII/IT Bilbao */ 00008 /************************************/ 00009 00010 00011 /**********************************************************/ 00012 00013 #include <stdio.h> 00014 #include <string.h> 00015 00016 #include "tdef.h" 00017 #include "uti.h" 00018 #include "cabcod.h" 00019 #include "cabdef0.h" 00020 #include "cabdef1.h" 00021 00022 /**********************************************************/ 00023 00024 #ifdef __cplusplus 00025 extern "C" { 00026 #endif 00027 00028 /**********************************************************/ 00029 /* permite pasar de modo lectura a escritura y al reves */ 00030 00031 #define change_rw(f) fseek(f,0,SEEK_CUR) 00032 00033 /**********************************************************/ 00034 00035 FLOAT4 xlee_sfloat( FILE * f ); 00036 00037 /**********************************************************/ 00038 00039 void xescribe_sfloat( FILE * f, 00040 FLOAT4 sf ); 00041 00042 /**********************************************************/ 00043 /* comprueba que en la cabecera de fichero cfich existe o no 00044 la cabecera definida por la mascara mcab (solo una cabecera). 00045 cfich es de tipo struct cfich */ 00046 00047 #define hay_cab(cfich,mc) ((((cfich).mcab)&(mc))!=0) 00048 00049 /**********************************************************/ 00050 /* comprueba que en la cabecera de fichero cfich existen o no 00051 las cabeceras definidas por la mascara mcab. Devuelve 1 solo si 00052 existen TODAS las indicadas en mcab. 00053 cfich es de tipo struct cfich */ 00054 00055 #define hay_cabs(cfich,mcab) ((((cfich).mcab)&(mcab))==(mcab)) 00056 00057 /**********************************************************/ 00058 /* comprueba que en cfich esta indicado que hay cabecera de senal. 00059 cfich es de tipo struct cfich */ 00060 00061 #define hay_csenal(cfich) hay_cab(cfich,MC_SENAL) 00062 00063 /**********************************************************/ 00064 /* comprueba que en cfich esta indicado que hay cabecera de parametros. 00065 cfich es de tipo struct cfich */ 00066 00067 #define hay_cparam(cfich) hay_cab(cfich,MC_PARAM) 00068 00069 /**********************************************************/ 00070 /* posiciona el fichero fp en la mascara de cabeceras */ 00071 00072 #define vete_cmask(fp) \ 00073 xfseek(fp,sizeof(UINT4)+sizeof(UINT2)+sizeof(UCHAR1),SEEK_SET) 00074 00075 /**********************************************************/ 00076 /* devuelve la mascara de cabeceras incluidas para el fichero fp. 00077 el puntero al fichero puede estar en cualquier sitio, y al terminar 00078 queda justo despues de leer la mascara de cabeceras */ 00079 00080 UINT4 get_cmask( FILE * fp ); 00081 00082 /**********************************************************/ 00083 /* Va a la cabecera indicada en cabmask. Si cabmask=MC_NINGUNA (0) va al 00084 principio del fichero. Si cabmask=MC_TODAS ($FF...FF) va al principio 00085 de los datos. 00086 Devuelve 1 si todo va bien, 0 si no se puede ir a esa cabecera porque 00087 no existe, en cuyo caso, la posicion en el fichero vale lo que le de 00088 la REAL gana. Mejor si usas xvete_cab(). */ 00089 00090 int vete_cab( FILE * fp, UINT4 cabmask ); 00091 00092 /**********************************************************/ 00093 /* Como vete_cab pero en caso de no existir la cabecera indicada 00094 produce un error y sale al S.O */ 00095 00096 void xvete_cab( FILE * fp, UINT4 cabmask ); 00097 00098 /**********************************************************/ 00099 /* va al principio del fichero */ 00100 00101 #define vete_principio(file) xfseek((file),0,SEEK_SET) 00102 00103 /**********************************************************/ 00104 /* va a la cabecera de fichero (cfich) */ 00105 00106 #define vete_cfich(file) vete_principio(file) 00107 00108 /**********************************************************/ 00109 /* va a la cabecera de senal */ 00110 00111 #define vete_csenal(file) xvete_cab(file,MC_SENAL) 00112 00113 /**********************************************************/ 00114 /* va a la cabecera de parametros */ 00115 00116 #define vete_cparam(file) xvete_cab(file,MC_PARAM) 00117 00118 /**********************************************************/ 00119 /* va a los datos, saltando todas las cabeceras */ 00120 00121 #define vete_datos(file) xvete_cab(file,MC_TODAS) 00122 00123 /**********************************************************/ 00124 /* salta el campo longitud de cabecera, estando el fichero posicionado 00125 en este campo */ 00126 00127 #define salta_long(file) xfseek((file),sizeof(UINT4),SEEK_CUR) 00128 00129 /**********************************************************/ 00130 /* va a la cabecera general de senal: va a la cabecera de senal y 00131 salta el campo longitud de cabecera */ 00132 00133 #define vete_cgsenal(file) { \ 00134 xvete_cab(file,MC_SENAL); \ 00135 salta_long(file); } 00136 00137 /**********************************************************/ 00138 /* va a la cabecera general de parametros: va a la cabecera de 00139 parametros y salta el campo longitud de cabecera */ 00140 00141 #define vete_cgparam(file) { \ 00142 xvete_cab(file,MC_PARAM); \ 00143 salta_long(file); } 00144 00145 /**********************************************************/ 00146 /* lee la cabecera de fichero, estando posicionado el fichero en ella */ 00147 00148 void lee_cfich( FILE * fp, 00149 struct cfich * cf_ptr); 00150 00151 /**********************************************************/ 00152 /* salva la cabecera de fichero, estando posicionado el fichero en ella */ 00153 00154 void escribe_cfich( FILE * fp, 00155 struct cfich * cf_ptr); 00156 00157 /**********************************************************/ 00158 /* anade a la mascara de cabeceras, las cabeceras identificada en cabmask. 00159 El apuntador de fichero puede estar en cualquier sitio, y se vuelve 00160 a poner ah¡ al terminar */ 00161 00162 void anade_cmask( FILE * fp, UINT4 cabmask ); 00163 00164 /**********************************************************/ 00165 /* escribe la longitud indicada, en la posicion actual del fichero */ 00166 00167 void escribe_long( FILE * fp, UINT4 l ); 00168 00169 /**********************************************************/ 00170 /* modifica la longitud de la cabecera definida por cabmask, 00171 considerando que el apuntador est al final de esa cabecera. 00172 El apuntador se vuelve a dejar en el final de la cabecera. */ 00173 00174 void escribe_long_actual( FILE * fp, UINT4 cabmask ); 00175 00176 /**********************************************************/ 00177 /* devuelve la longitud de la cabecera definida por cabmask, 00178 desde el principio de ella hasta la posicion actual. */ 00179 00180 long lee_long_actual( FILE * fp, UINT4 cabmask ); 00181 00182 /**********************************************************/ 00183 /* devuelve la longitud de una cabecera general de senal */ 00184 00185 UINT4 long_cgsenal( struct cgsenal * cgs ); 00186 00187 /**********************************************************/ 00188 /* borra (con xfreemem) los campos variables de una cabecera 00189 general de senal, y pone a cero su longitud */ 00190 00191 void free_cgsenal( struct cgsenal * cgs ); 00192 00193 /**********************************************************/ 00194 /* resetea la cabecera general de senal apuntada por cgs_ptr (la pone 00195 a ceros, y punteros a campos variables apuntando a NULL */ 00196 00197 #define reset_cgsenal(cgs_ptr) memset(cgs_ptr,0,sizeof(*(cgs_ptr))) 00198 00199 /**********************************************************/ 00200 /* leo una cabecera general de senal. Devuelvo 0 si todo se ha leido, 00201 o 1 si algun campo variable no se ha leido al completo. 00202 00203 Campos variables inicializados segun prepara_cvariable(): si se rellena 00204 antes el campo variable a ceros: ptr=NULL y nelem=0, se crea un buffer 00205 adecuado y se leen todos los elementos del campo. Si nelem<>0, es el 00206 limite a leer, y si ptr<>NULL, el array se supone creado (si no, se crea), 00207 y nelem es siempre el limite de elementos a leer (en los campos de 00208 texto se anade un cero al final, por lo que DEBES crear los arrays con 00209 un char mas de lo que me dices a mi. */ 00210 00211 int lee_cgsenal( FILE * fp, struct cgsenal * cgs ); 00212 00213 /**********************************************************/ 00214 /* salva una cabecera general de senal */ 00215 00216 void escribe_cgsenal( FILE * fp, struct cgsenal * cgs ); 00217 00218 /**********************************************************/ 00219 /* salva una cabecera general de senal, pero se queda en las marcas(no 00220 llega a salvarlas */ 00221 00222 void escribe_cgsenal_marc( FILE * fp, struct cgsenal * cgs ); 00223 00224 /**********************************************************/ 00225 /* lee cabecera vieja, pero con el formato nuevo */ 00226 00227 void lee_csenal_vieja( FILE * fp, struct cgsenal * cgs ); 00228 00229 /**********************************************************/ 00230 /* escribe cabecera vieja, pero enviandosela con el formato nuevo */ 00231 00232 void escribe_csenal_vieja( FILE * fp, struct cgsenal * cgs ); 00233 00234 /**********************************************************/ 00235 /* devuelve la longitud de una cabecera general de parametros */ 00236 00237 #define long_cgparam() sizeof(struct cgparam) 00238 00239 /**********************************************************/ 00240 /* lee una cabecera general de parametros del fichero fp, estando 00241 el fichero posicionado en ella */ 00242 00243 #define lee_cgparam(fp,cgp_ptr) xfread(cgp_ptr,sizeof(*(cgp_ptr)),1,fp) 00244 00245 /**********************************************************/ 00246 /* salva la cabecera general de parametros en la posicion actual del 00247 fichero fp */ 00248 00249 #define escribe_cgparam(fp,cgp_ptr) xfwrite(cgp_ptr,sizeof(*(cgp_ptr)),1,fp) 00250 00251 /**********************************************************/ 00252 /* devuelve la longitud de una cabecera general de parametros parcor */ 00253 00254 #define long_cgp_parcor() sizeof(struct cgp_parcor) 00255 00256 /**********************************************************/ 00257 /* lee una cabecera de parcors del fichero fp a partir de la posicion 00258 actual */ 00259 00260 void lee_cgp_parcor( FILE * fp, 00261 struct cgp_parcor * cgp_pc_ptr ); 00262 00263 /**********************************************************/ 00264 /* salva una cabecera de parcors en la posicion actual del fichero fp */ 00265 00266 void escribe_cgp_parcor( FILE * fp, 00267 struct cgp_parcor * cgp_pc_ptr); 00268 00269 /**********************************************************/ 00270 /* devuelve la longitud de una cabecera general de parametros lpc*/ 00271 00272 #define long_cgp_lpc() sizeof(struct cgp_lpc) 00273 00274 /**********************************************************/ 00275 /* lee una cabecera de lpcs del fichero fp a partir de la posicion 00276 actual */ 00277 00278 void lee_cgp_lpc( FILE * fp, 00279 struct cgp_lpc * cgp_lpc_ptr); 00280 00281 /**********************************************************/ 00282 /* salva una cabecera de lpcs en la posicion actual del fichero fp */ 00283 00284 void escribe_cgp_lpc( FILE * fp, 00285 struct cgp_lpc * cgp_lpc_ptr); 00286 00287 /**********************************************************/ 00288 00289 #ifdef __cplusplus 00290 } /* extern "C" */ 00291 #endif 00292 00293 /**********************************************************/ 00294 00295 #endif
1.5.6