A vueltas con un archivo binario

[vosk]

Pues eso, lo que te indica la descripcion: primero te saltas los 2 bytes que no tienen significado, luego lees 8, luego saltas 1, luego lees 2, etc...

Por orden, primero abres el archivo:

Código C:

FILE *arx;
if(!(arx = fopen(path, "rb"))) {
    //error de acceso
}
 

Ahora saltas 2 bytes:

Código C:

fseek(arx, 2L, SEEK_CUR);
 

Lees 8 bytes:

Código C:

//necesitas declarar el double
double julian_date;
fread(&julian_date, sizeof(double), 1, arx);
 

Saltas otro byte:

Código C:

fseek(arx, 1L, SEEK_CUR);
 

Lees la amplitud:

Código C:

//necesitas declarar el short
short int amplitude;
fread(&amplitude, sizeof(short int), 1, arx);
 

Y asi vas leyendo hasta terminar el primer record; luego haces lo mismo para el segundo. Ten en cuenta que para cada lectura tienes que hacer las comprovaciones de error necesarias, incluso por si el archivo estuviera mal escrito y terminara antes de tiempo.

Alternativamente está la forma serializada que consiste en guardar los tipos en una estructura y leer estructuras enteras, p.ej.:

Código C:

struct RECORD {
    char internal_a[2];
    double julian_time;
    char internal_b;
    short int amplitude;
    etc...
};
 

Solo te pongo los primeros pero ya ves de que va la cosa. Ahora en vez de leer campo por campo puedes leer toda la estructura:

Código C:

//necesitas declarar una estructura
struct RECORD record;
//reseteas los campos
memset(&record, 0, sizeof(struct RECORD));
//y lees el record
fread(&record, sizeof(struct RECORD), 1, arx);
 

De esta forma en una sola lectura recuperas todo un record.

Lo siguiente es saber cuantos recors contiene el archivo. Sabiendo lo que ocupan todos los tipos, es decir sabiendo lo que ocupa la estructura RECORD, solo tienes que dividir el tamaño del archivo por el tamaño del record, tienes que obtener un numero entero, de lo contrario el archivo está mal construido. Primero recuperas el tamaño:

Código C:

size_t file_size;
fseek(arx, 0L, SEEK_END);
file_size = ftell(arx);
fseek(arx, 0L, SEEK_SET);
 

Luego lo divides por el tamaño de la estructura:

Código C:

int n_records = file_size / sizeof(struct RECORD);
 

Ahora ya sabes cuantos records has de leer.

Y si quieres implementar los tipos indicados en la referencia solo tienes que redefinir los tipos que te comenté como los tipos indicados:

Código C:

typedef char BYTE;
typedef short int WORD;
typedef double REAL;
 

De esta forma puedes reescribir la estructura con los tipos redefinidos:

Código C:

struct RECORD {
    BYTE internal_a[2];
    REAL julian_time;
    BYTE internal_b;
    WORD amplitude;
    etc...
};
 

Saludos
vosk