Newsgroup: it.comp.lang.c
Titolo: [help] fread smette di leggere!?

ancora ciao a tutti;
scusate se ultimamente sto intasando il ng in cerca di aiuti: confido
che questa sia la mia ultima richiesta di aiuto.
Il mio problema è questo: cerco di leggere un file wav con fread(...)
per costruire un altro file, ma riesco a leggere solo l'inizio del
file! inspiegabilmente, mentre leggo il file arrivo a fine file.
il file di input è il semplicissimo ding.wav di windows ed è di circa
80kB; se guardo al file con altri programmi mi accorgo che riesco a
leggere correttamente i primi 600-700 kB del file, dopodichè, sempre
allo stesso punto, non riesco a leggere più niente. Incappo infatti
nell'errore feof( in) anche se devo ancora leggere ~ 79kb di dati. Non
riesco a spiegarmi il perché.
Questa è la parte rilevante del codice:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int
main (int argc, char *argv[] )
{
	signed short int ** samples;
	signed long		w;
	...
	//alloca la memoria per samples
	samples = (signed short int **)calloc( num_canali_in, sizeof(signed
short int *) );
	if( samples == NULL ) {
		printf("calloc ha fallito!\n");
		free(samples);
		exit(2);
	}
	for(j=0 ; j < num_canali_in ; j++) {
		samples[j] = calloc( w, sizeof(short int));
		if( samples == NULL ) {
			printf("?alloc ha fallito al tentativo %d-esimo\n", j);
			free(samples[0]);
			free(samples);
			exit(2);
		}
	}
	//finché posso leggere una finestra intera:
	//leggi w istanti del file audio, e salva l'output ricodificato
	while( data_size_in > w*num_canali_in )	{
		//leggi una finestra di dati
		for( i=0; i<w; i++)	{             //...ad ogni istante...
			for( j=0; j<num_canali_in; j++) { //...e per ogni canale
				num_letti = fread( &(samples[j][i]), sizeof(short int), 1, in);
				if (num_letti != 1) {
					if ( feof(in) ) {
						printf("ERRORE: raggiunta la fine del file, anche se\n");
						printf("mi aspetto ancora %d bytes di dati.\n", data_size_in);
						exit(3);
					} else if ( ferror(in) ) {
						printf("ERRORE: in letturadel file\n");
						exit(3);
					} else {
						printf("ERRORE: incomprensibile.\n");
						exit(3);
					}
				}
			}
		}
		//blablabla...
		... ... ...
		... ... ...
		data_size_in -= ( w * sizeof(short int) * num_canali_in );
	}
	fclose(in);
	fclose(out);
	fclose(debug);
	return 0 ;
}

num_letti = fread( &(samples[j][i]), sizeof(short int), 1, in);
mostra in che modo chiami la fopen()...
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 file! inspiegabilmente, mentre leggo il file arrivo a fine file.
hai aperto il file in modo testo? (mancano le fopen() sul listato)
(se si', incontri probabilmente un carattere EOF... apri il file con 
fopen("ding.wav", "rb"))
ciao
-- 
Cybertoldo
Per rispondermi via email, sostituisci moc.liamg con 
gmail.com


il problema era proprio questo: infatti aprendo il file in modalità
"rb" il problema non si presenta.
grazie!

 mostra in che modo chiami la fopen()...
usavo in = fopen( dile_input, "r") .
usando in = fopen( dile_input, "rb") il problema è scomparso.
grazie!
-- 
andrea

usando in = fopen( dile_input, "rb") il problema è scomparso.
Infatti era proprio quello che volevo verificare...

 Scusa, ma perché all'indietro ?
...penso che abbia ottimizzato. Con un:
for(i = 0; i < j; i++)
	free(samples[i]);
il confronto (i < j) e' piu' oneroso di (i >= 0). E con uno 8088 
potresti pure vedere la differenza :)
p.s. a parte scherzi: personalmente non vedo nulla di sbagliato in 
questo metodo... anzi.
Ciao


...penso che abbia ottimizzato. Con un:
"Premature optimization is the root of all evil (or at least most of
it) in programming" [Donald Knuth]
Almeno un paio di compilatori che conosco sono in grado di tradurre un
ciclo, in cui l'indice sia solo di scorrimento, in un loop
all'indietro, che unisce in un'unica istruzione di jump il controllo
della condizione d'uscita e il salto alla nuova istruzione.
Questo tipo di ottimizzazioni sono in grado di farle già i
compilatori.  Lasciamole fare a loro.  

 Scusa, ma perché all'indietro ?
Perché "mi piaceva di più".
Scherzi a parte, non avevo nessuna ragione per preferire il ciclo
all'indietro piuttosto che in avanti; in quel momento la mia
concentrazione era tutta sull'indice 'j-1' e quindi sono partito da li,
per poi andare a ritroso.
Ancora non ho le conoscenze necessarie per andare a fare ottimizzazioni
così puntuali!
Molto più semplicemente: reputavo i due cicli for (i = j-1, i>=0, i--)
e for(i = 0, i<=j-1, i--) equivalenti, ed ho usato il primo che mi è
venuto in mente...
Ancora grazie per le risposte!