lecture/écriture d'un fichier dans un vecteur d'enregistrement

Version imprimable

1 pièce(s) jointe(s)

bonjour

j'ai un problème de lecture de fichier ci joint dans un vecteur d'enregistrement

j'ai essayer d'utiliser le code suivant mai, le premier élément se répété pour la suite de boucle, aidez moi cvp ::ptdr:

aussi: verifez cvp si la condition de boucle est juste: for(i=0;i<sizeof(struct melp_param);i++) , pour lire tout le fichier

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
#include <iostream>
#include<fstream>
#include<cstring>
 
#define CHSIZE 9
#define LPC_ORD 10          /* LPC order */
#define NUM_GAINFR 2        /* number of gains per frame */
#define NUM_BANDS 5         /* number of frequency bands */
#define NUM_HARM 10         /* number of Fourier magnitudes */
 
 
struct melp_param {         /* MELP parameters */
    float pitch;
    float lsf[LPC_ORD+1];
    float gain[NUM_GAINFR];
    float jitter;
    float bpvc[NUM_BANDS];
    int pitch_index;
    int lsf_index[LPC_ORD];
    int jit_index;
    int bpvc_index;
    int gain_index[NUM_GAINFR];
    unsigned int *chptr;
    int chbit;
    int uv_flag;
    float fs_mag[NUM_HARM];
    int *fsvq_index;
    int *msvq_index;
    int msvq_stages;
    int *msvq_bits;
    int *msvq_levels;
};
 
using namespace std;
 
int main()
{
    struct melp_param chbuf;
 
    ifstream intbal("data.bit",ios::in | ios::binary);
 
 if (!intbal)
    {
        cout<<"can't open the file."<<endl;
        return 1;
    }
 
 intbal.read((char *)&chbuf,sizeof(struct melp_param));
 
int i,j;
int packet=0;
 
    for(i=0;i<sizeof(struct melp_param);i++)
    {
 
    cout<<"pitch:"<<chbuf.pitch<<endl;
 
    for( j=0;j<LPC_ORD+1;j++)
    {
      cout<<"LSF: "<<chbuf.lsf[j]<<endl;
    }
    for(j=0;j<NUM_GAINFR;j++)
    {
        cout<<"GAIN: "<<chbuf.gain[j]<<endl;
    }
 
    cout<<"JITTER: "<<chbuf.jitter<<endl;
 
    for(j=0;j<NUM_BANDS;j++)
    {
       cout<<"bpvc: "<<chbuf.bpvc[j]<<endl;
    }
 
    cout<<"pitch_index: "<<chbuf.pitch_index<<endl;
 
    for(j=0;j<LPC_ORD;j++)
    {
       cout<<"LSF INDEX: "<<chbuf.lsf_index[j]<<endl;
    }
 
    cout<<"jit_index: $"<<chbuf.jit_index<<endl;
 
    cout<<"uv_flag: $"<<chbuf.uv_flag<<endl;
 
    cout<<"uv_flag: $"<<chbuf.bpvc_index<<endl;
 
    for(j=0;j<NUM_GAINFR;j++)
    {
       cout<<"GAIN INDEX: "<<chbuf.gain_index[j]<<endl;
    }
 
    cout<<"channel pointer: $"<<&chbuf.chptr<<endl;
    cout<<"channel pointer: $"<<chbuf.chbit<<endl;
    cout<<"channel pointer: $"<<chbuf.uv_flag<<endl;
 
    for(j=0;j<NUM_HARM;j++)
    {
       cout<<"fourier_MAG: "<<chbuf.fs_mag[j]<<endl;
    }
 
    cout<<"fsvq_index: $"<<chbuf.fsvq_index<<endl;
    cout<<"msvq_index: $"<<chbuf.msvq_index<<endl;
    cout<<"msvq_stages: $"<<chbuf.msvq_stages<<endl;
    cout<<"msvq_bits: $"<<chbuf.msvq_bits<<endl;
    cout<<"msvq_bits: $"<<chbuf.msvq_bits<<endl;
    cout<<"msvq_LEVELS: $"<<chbuf.msvq_levels<<endl;
 
    packet++;
    cout<<"frame="<<packet<<endl;
 
 
    }
    intbal.close();
 
    return 0;
}

23/11/2015, 10h07
stendhal666

Je trouve ton programme assez étrange... tu devrais mettre quelques commentaires pour qu'on comprenne ce que tu veux faire, ce serait plus simple de te donner des conseils.

Si l'idée est de prendre dans le fichier directement sous forme binaire les éléments de ta structure, pourquoi pas. S'il n'y a qu'une structure, pas besoin de boucle for; s'il y en a plusieurs il te faut effectivement un vecteur mais il n'y en a pas dans ton programme...
23/11/2015, 10h25
Iradrille
Hello,

Citation:

Envoyé par usthbstar

aussi: verifez cvp si la condition de boucle est juste: for(i=0;i<sizeof(struct melp_param);i++) , pour lire tout le fichier

Pour répondre à ça : c'est faux.

Comme dit @stendhal666, soit tu en lis 1 (et donc pas de boucle), soit tu en lis plusieurs et tu auras surement un std::vector.
Code:

1 2 3 4 5 6 std::vector<melp_param> params; for(int i=0; i<42; ++i) { melp_param mp; //... params.push_back(mp); }
(A remplacer par un while si tu ne sais pas combien en lire.)

concerant la boucle

vous trouvez dans le code source ci dessous , le code complet pour générer et pour lire le fichier (ils sont utilisé la boucle while pour cela, mai sans utilise les vecteur et sa ce qui je n'ai pas compris. donc j'ai décidé de lire le fichier a ma façon, si pour sa j'ai vous envoie mon propre travail. mai si on arrive a trouvez l’astuce de lecture d’après le code source original c'est magnifique.

la fonction analysis permet de générer une enregistrement melp_par, et il la sauvegardée dans un fichier, moi mon but de faire un programme pour lire ce fichier

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
int main(int argc, char *argv[])
{
Longword	length;
mode = ANALYSIS;
rate = RATE2400;
chwordsize = 8;         // this is for packed bitstream



	Shortword	speech_in[BLOCK], speech_out[BLOCK];
	Shortword	bitBufSize, bitBufSize12, bitBufSize24;
                                          /* size of the bitstream buffer */
	BOOLEAN		eof_reached = FALSE;
	FILE	*fp_in, *fp_out;
	char in_name[100]="org.wav", out_name[100]="syn.wav";


	/* ====== Open input, output, and parameter files ====== */
	if ((fp_in = fopen(in_name,"rb")) == NULL){
		fprintf(stderr, "  ERROR: cannot read file %s.\n", in_name);
		exit(1);
	}
	if ((fp_out = fopen(out_name,"wb")) == NULL){
		fprintf(stderr, "  ERROR: cannot write file %s.\n", out_name);
		exit(1);
	}

	/* ====== Initialize MELP analysis and synthesis ====== */
	if (rate == RATE2400)
		frameSize = (Shortword) FRAME;
	else
		frameSize = (Shortword) BLOCK;
	/* Computing bit=Num = rate * frameSize / FSAMP.  Note that bitNum        */
	/* computes the number of bytes written to the channel and it has to be   */
	/* exact.  We first carry out the division and then have the multiplica-  */
	/* tion with rounding.                                                    */
    bitNum12 = 81;
    bitNum24 = 54;
    if( chwordsize == 8 ){
        // packing the bitstream
        bitBufSize12 = 11;
        bitBufSize24 = 7;
    }else if( chwordsize == 6 ){
        bitBufSize12 = 14;
        bitBufSize24 = 9;
    }else{
        fprintf(stderr,"Channel word size is wrong!\n");
        exit(-1);
    }

    if (rate == RATE2400){
		frameSize = FRAME;
		bitBufSize = bitBufSize24;
	} else {
		frameSize = BLOCK;
		bitBufSize = bitBufSize12;
	}

	if (mode != SYNTHESIS)
		melp_ana_init();


	/* ====== Run MELP coder on input signal ====== */

	frame_count = 0;
	eof_reached = FALSE;

	while (!eof_reached){     //  la boucle principale , le compteur c'est frame_count, elle s’arrête lorsque ( length < bitBufSize24)


		fprintf(stderr, "Frame = %ld\r", frame_count);

		
			/* Perform MELP analysis */

			if (mode != SYNTHESIS){
				/* read input speech */
				length = readbl(speech_in, fp_in, frameSize);
				if (length < frameSize){
					v_zap(&speech_in[length], (Shortword) (FRAME - length));
					eof_reached = TRUE;
				}

					analysis(speech_in, melp_par);
			
				/* ---- Write channel output if needed ---- */
                if (mode == ANALYSIS){
                    if( chwordsize == 8 ){
					    fwrite(chbuf, sizeof(unsigned char), bitBufSize, fp_out);
                    }else{
        				int i;
		        		unsigned int bitData;
				        for(i = 0; i < bitBufSize; i++){
					        bitData = (unsigned int)(chbuf[i]);
					        fwrite(&bitData, sizeof(unsigned int), 1, fp_out);
				        }
			        }
                }
			}

		}
		frame_count ++;
	}

	fclose(fp_in);
	fclose(fp_out);
	fprintf(stderr, "\n\n");

	return(0);
}