void WaveFormat::readFileVersuchen (Steinberg::String samplePath)
{
	//fstream f;
	//f.open("testNeu2.txt", ios::out);
	//f << "Dieser Text geht in die Datei" << endl;
	//f.close();
	fstream fileStream;
	fileStream.open(samplePath.text (), ios::in);  
	int byteCounter = 0;
	uint8 oneByte = 0;
	if (fileStream.is_open())
	{
		while (!fileStream.eof())
		{
			fileStream.read(&oneByte, sizeof(Steinberg::uint8)); 
			//mChunkID = oneByte & 0xFFFF;

			if (byteCounter>=0 && byteCounter <= 3)
			{
				mChunkID <<= sizeof(Steinberg::uint8);				                     
				mChunkID += oneByte;
				//char oneByteChar = oneByte;
				//stringstream allByte << oneByteChar;
				//allByte >> CString a;
			}
			else if (byteCounter>=4 && byteCounter <=7)
			{
				mChunkSize <<= sizeof(Steinberg::uint8);
				mChunkSize += oneByte;
			}
			else if (byteCounter>=8 && byteCounter <=11)
			{
				//mFormat <<= sizeof(Steinberg::uint8);
				char oneByteChar = oneByte;
				mFormat = mFormat + oneByteChar;
			}
			else if (byteCounter>=12 && byteCounter <=15)
			{
				mSubChunk1ID <<= sizeof(Steinberg::uint8);				                     
				mSubChunk1ID += oneByte;
			}				   
			else if (byteCounter>=16 && byteCounter <=19)
			{
				mSubChunk1Size <<= sizeof(Steinberg::uint8);
				mSubChunk1Size += oneByte;
			}
			else if (byteCounter>=20 && byteCounter <=21)
			{
				mAudioFormat <<= sizeof(Steinberg::uint8);				                     
				mAudioFormat += oneByte;
			}
			else if (byteCounter>=22 && byteCounter <=23)
			{
				mNumChannels <<= sizeof(Steinberg::uint8);				                     
				mNumChannels += byteCounter;
			}
			else if (byteCounter>=24 && byteCounter <=27)
			{
				mSampleRate <<= sizeof(Steinberg::uint8);				                     
				mSampleRate += oneByte;
			}
			else if (byteCounter>=28 && byteCounter <=31)
			{
				mByteRate <<= sizeof(Steinberg::uint8);				                     
				mByteRate += oneByte;
			}
			else if (byteCounter>=32 && byteCounter <=33)
			{
				mBlockAlign <<= sizeof(Steinberg::uint8);				                     
				mBlockAlign += oneByte;
			}
			else if (byteCounter>=34 && byteCounter <=35)
			{
				mBitsPerSample <<= sizeof(Steinberg::uint8);				                     
				mBitsPerSample += oneByte;
			}	
			else if (byteCounter>=36 && byteCounter <=39)
			{
				mSubChunks2ID <<= sizeof(Steinberg::uint8);				                     
				mSubChunks2ID += oneByte;
			}
			else if (byteCounter>=40 && byteCounter <=43)
			{
				mSubchunck2Size <<= sizeof(Steinberg::uint8);				                     
				mSubchunck2Size += oneByte;
			}
			else if (byteCounter >=44)
			{

			}
			byteCounter++;
		}
		fileStream.close();
	}
}

Dass das mit den ganzen If-Abfragen sicher nicht grade optimal ist ist mir klar, aber will erstmal erreichen, dass der Code funktioniert.
Will das ganze in einem Insert-Effekt in Cubase benutzen, also benutze die SKD von Steinberg, aber ich glaube das müsste auch gehen ohne die zu kennen.

AsterixderGallier schrieb:

Dass das mit den ganzen If-Abfragen sicher nicht grade optimal ist ist mir klar, aber will erstmal erreichen, dass der Code funktioniert.

Keine gute Idee, denn wenn man nicht sauber arbeitet, erreicht man gerade eben das Gegenteil und es funktioniert nicht. Siehe dein eigener Code. Abgesehen von deinem verkappten for-switch-Pattern scheinst du das Dateieinlesen in C++ nicht zu beherrschen. Das sieht bei dir nämlich so aus wie wenn jemand C nach C++ übersetzt hätte, ohne die Unterschiede zu kennen. Da musst du mal die Grundlagen nochmal lernen, besonders wie das mit der Abbruchlogik funktioniert.

while (!fileStream.eof())

oder was meinst du?
Ich habe natürlich schon debuggt, der erste Wert ist richtig, der zweite ist aber komischerweise negativ also mChunkSize. Nur hilft mir das nicht weiter um zu erkennen warum die falsch sind ab dann..

Dann geh doch mal mit dem Debugger durch und guck wann und warum du die falschen Werte bekommst.

AsterixderGallier schrieb:

Dass das mit den ganzen If-Abfragen sicher nicht grade optimal ist ist mir klar, aber will erstmal erreichen, dass der Code funktioniert.

Keine gute Idee, denn wenn man nicht sauber arbeitet, erreicht man gerade eben das Gegenteil und es funktioniert nicht. Siehe dein eigener Code. Abgesehen von deinem verkappten for-switch-Pattern scheinst du das Dateieinlesen in C++ nicht zu beherrschen. Das sieht bei dir nämlich so aus wie wenn jemand C nach C++ übersetzt hätte, ohne die Unterschiede zu kennen. Da musst du mal die Grundlagen nochmal lernen, besonders wie das mit der Abbruchlogik funktioniert.

Ich lese doch lediglich einen Pfad ein, aber den bekomme ich auch ner anderen Klasse. Und mit dem fstream habe ich im Internet desöfteren gefunden.

Aber wie soll ich das denn ohne die If-Abfragen lösen?

Einfach hintereinander lesen?

Case-Swich geht ja nicht in dem Fall. C habe ich noch nie gemacht, nur JAVA. Ich finde die Abbruchbedingung eigentlich ok, er macht das ganze solange bis die Datei zu ende ist:

while (!fileStream.eof())

oder was meinst du?

Das heißt es eben gerade nicht. Das was du gemacht hast heißt "solange wie die letzte Leseaktion nicht am Dateiende gescheitert ist". Jetzt guck mal, wo die letzte Leseaktion vor dieser Überprüfung war und was zwischen dieser Leseaktion und der Prüfung noch so alles passiert ist.

Ich habe natürlich schon debuggt, der erste Wert ist richtig, der zweite ist aber komischerweise negativ also mChunkSize. Nur hilft mir das nicht weiter um zu erkennen warum die falsch sind ab dann..

Da brauchst du doch gar nicht weiter zu debuggen. Wenn der zweite Wert schon falsch ist, ist der Rest doch uninteressant. Guck, was du einliest, vergleiche was du erwarten würdest. Guck was bei deiner Berechnung in der if-Abfrage herauskommt, vergleiche wieder was du erwarten würdest.

Und mit dem fstream habe ich im Internet desöfteren gefunden.

Im Internet findet man so einiges...

Da brauchst du doch gar nicht weiter zu debuggen. Wenn der zweite Wert schon falsch ist, ist der Rest doch uninteressant. Guck, was du einliest, vergleiche was du erwarten würdest. Guck was bei deiner Berechnung in der if-Abfrage herauskommt, vergleiche wieder was du erwarten würdest.

Was meinst du habe ich gemacht? Ich habe doch schon am Anfang geschrieben das meine Werte nicht stimmen, genau deshalb habe ich doch hier reingeschrieben weil vielleicht jemand ne Idee hat warum sie nicht stimmen. Nur weil ich sehe, dass sie falsch sind heißt das ja nicht unbedingt, dass ich weiß warum.

Wenn in der ChunkID RIFF steht, sind die Zahlenwerte Little-Endian. Dann funktioniert deine <<=-Logik nicht, weil das niederwertigste Byte zuerst kommt.

Da hast du Recht, das guck ich mir mal eben an.

ist doch sowieso falsch, denn sizeof(uint8) wird wohl auf den meisten Systemen 1 ergeben...

P.S. Außerdem macht es wenig Sinn, die Daten byteweise zu lesen.

Zu jedem Chunk gibt es doch auch die Info, wie lang der Chunk ist. Du könntest Dich also einfach von Chunk zu Chunk hangeln.

ja ich weiß, das versuche ich ja auch. Mit den If-Abfragen schaue ich ja wo grade der byteCounter ist. Und jenachdem wie lang der jeweilige Chunk gerade ist, frage ich in dem If verschieden ab. Aber es haut einfach nicht hin. Habe auch schon << mal umgedreht trotzdem falsche Werte. Habe jetzt gerade versucht

mChunkSize += oneByte;

mal durch

mChunkSize |= oneByte & 0xFF;

zu ersetzen, weil ich dachte vielleicht klappt da irgendwie das shiften nicht. Aber bringt nichts.

mChunkID <<= sizeof(Steinberg::uint8);

ist doch sowieso falsch, denn sizeof(uint8) wird wohl auf den meisten Systemen 1 ergeben...

P.S. Außerdem macht es wenig Sinn, die Daten byteweise zu lesen.

Es soll doch auch 1 ergeben?
Warum nicht bitweise, wie dann?

Es soll doch auch 1 ergeben?

Nein. Damit verschiebst du um 1 Bit.

AsterixderGallier schrieb:

Warum nicht bitweise, wie dann?

Du liest nicht bitweise, du liest byteweise.

Daten mit fester Größe liest man üblicherweise am Stück in eine entsprechende Struktur.

Hier steht es beschrieben: How to Load a Wave File

Bäh - oben steht ganz groß C++ und unten ist reiner C-Code drin. Dann geht auch das: http://www.codeproject.com/Articles/1325/Wave-Class-for-Playing-and-Recording-Wave-Files oder im Code-Project nach 'WAVE' suchen.

Th69 schrieb:

Hier steht es beschrieben: How to Load a Wave File

Bäh - oben steht ganz groß C++ und unten ist reiner C-Code drin. Dann geht auch das: http://www.codeproject.com/Articles/1325/Wave-Class-for-Playing-and-Recording-Wave-Files oder im Code-Project nach 'WAVE' suchen.

Ich hatte mir die Seite auch angesehen, aber diesen Link: http://www.codeproject.com/Articles/29676/CWave-A-Simple-C-Class-to-Manipulate-WAV-Files

void WaveFormat::readFileVersuchen (Steinberg::String samplePath)
{
	//fstream f;
	//f.open("testNeu2.txt", ios::out);
	//f << "Dieser Text geht in die Datei" << endl;
	//f.close();
	fstream fileStream;
	fileStream.open(samplePath.text (), ios::in);
	int byteCounter = 0;
	bool isSignalSounded = false;   // Gibt true an, wenn fmt erreicht wurde
	int8 oneByte = 0;
	char kp[5000] = "";
	int oneByteIndex = 0;
	if (fileStream.is_open())
	{
		while (!fileStream.eof())
		{
			//int au = sizeof(Steinberg::uint8);
			fileStream.read(&oneByte, sizeof(Steinberg::uint8)); 

			if (byteCounter>=0 && byteCounter <= 3)
			{
				mChunkID <<= sizeof(Steinberg::uint8) * 8;
				mChunkID |= oneByte & 0xFF;
			}
			else if (byteCounter>=4 && byteCounter <=7)
			{
				mChunkSize <<= sizeof(Steinberg::uint8) * 8;
				mChunkSize |= oneByte & 0xFF;
			}
			else if (byteCounter>=8 && byteCounter <=11)
			{
				mFormat <<= sizeof(Steinberg::uint8) * 8;				                     
				mFormat |= oneByte & 0xFF;
			}

			else if (byteCounter>=12 && isSignalSounded == false)	  // Wird ausgeführt, wenn fmt noch nicht erreicht wurde.
			{
				char oneByteChar = oneByte;
				if (oneByte != 0)
				{
					kp[oneByteIndex] = oneByteChar;
				}
				else if (oneByte == 0)
				{					   
					kp[oneByteIndex] = ' ';
				}
				for (int i = 0; i < 4997; i++)
				{
					if (kp[i] == 'f' && kp[i+1] == 'm' && kp[i+2] == 't')	// Wenn fmt erreicht wurde..
					{
						fileStream.read(&oneByte, sizeof(Steinberg::uint8));			// Weiß nicht genau ob das nicht weg muss.
						isSignalSounded = true;
						byteCounter = 11;												// Setze den ByteCounter auf 15 zurück, damit die Schleifen unterhalb durchlaufen werden.
						ofstream ftest("C:\\Users\\Otto\\waveDaten.txt", ios::out);		// Schreibt zum Testen eine
						ftest << kp;													// Textdatei mit den Daten.
					}	
				}
				oneByteIndex++;
			}

			else if (byteCounter>=12 && byteCounter <=15 && isSignalSounded == true)
			{
				mSubChunk1ID <<= sizeof(Steinberg::uint8) * 8;				                     
				mSubChunk1ID |= oneByte & 0xFF;
			}				   
			else if (byteCounter>=16 && byteCounter <=19 && isSignalSounded == true)
			{
				mSubChunk1Size <<= sizeof(Steinberg::uint8) * 8;
				mSubChunk1Size |= oneByte & 0xFF;
			}
			else if (byteCounter>=20 && byteCounter <=21 && isSignalSounded == true)
			{
				mAudioFormat <<= sizeof(Steinberg::uint8) * 8;				                     
				mAudioFormat |= oneByte & 0xFF;
			}
			else if (byteCounter>=22 && byteCounter <=23 && isSignalSounded == true)
			{
				mNumChannels <<= sizeof(Steinberg::uint8) * 8;				                     
				mNumChannels |= oneByte & 0xFF;
			}
			else if (byteCounter>=24 && byteCounter <=27 && isSignalSounded == true)
			{
				mSampleRate <<= sizeof(Steinberg::uint8) * 8;				                     
				mSampleRate |= oneByte & 0xFF;
			}
			else if (byteCounter>=28 && byteCounter <=31 && isSignalSounded == true)
			{						   
				mByteRate <<= sizeof(Steinberg::uint8) * 8;				                     
				mByteRate |= oneByte & 0xFF;
			}
			else if (byteCounter>=32 && byteCounter <=33 && isSignalSounded == true)
			{
				mBlockAlign <<= sizeof(Steinberg::uint8) * 8;				                     
				mBlockAlign |= oneByte & 0xFF;
			}
			else if (byteCounter>=34 && byteCounter <=35 && isSignalSounded == true)
			{
				mBitsPerSample <<= sizeof(Steinberg::uint8) * 8;				                     
				mBitsPerSample |= oneByte & 0xFF;
			}	
			else if (byteCounter>=36 && byteCounter <=39 && isSignalSounded == true)
			{
				mSubChunks2ID <<= sizeof(Steinberg::uint8) * 8;				                     
				mSubChunks2ID |= oneByte & 0xFF;
			}
			else if (byteCounter>=40 && byteCounter <=43 && isSignalSounded == true)
			{
				mSubchunck2Size <<= sizeof(Steinberg::uint8) * 8;				                     
				mSubchunck2Size |= oneByte & 0xFF;
			}
			else if (byteCounter >=44)
			{

			}
			byteCounter++;
		}
		fileStream.close();
	}
}

schaue auf Zeile 23, 28, 33, usw, und auf die Bemerkung von MFK

schaue auf Zeile 8 und diesen Beitrag von Michael

schaue auf Zeile 23, 28, 33, usw, und auf die Bemerkung von MFK

Ok das mit 23, 28, 33 ist mir klar, aber trotzdem müssten ja die anderen Werte dann korrekt sein, die beeinflussen sich ja nicht. Wenn die stimmen wollte ich da weiter machen. Zeile 8 schaue ich mir jetzt mal an.

Es gibt sicher schöneres, als das was ich Dir hier vorschlage - siehe ibinstream, aber ich will das mal auf Deinem Programm aufbauen.

Also mit den drei Funktionen ...

#include <string>
#include <istream>
#include <cstdint>

void readbin( std::istream& in, std::string& str, std::size_t n )
{
    const std::size_t N = 100;
    char buf[N]; // hier mal ganz anfängermäßig!
    if( n > N )
        in.setstate( std::ios_base::failbit );
    if( in.read( buf, n ) )
        str.assign( buf, buf + n );
}
void readbin( std::istream& in, std::uint32_t& x )
{   // ACHTUNG: Dein OS muss Little Endian haben (z.B.: Windows), nur dann ist dies ok!
    in.read( (char*)&x, sizeof(x) );
}
void readbin( std::istream& in, std::uint16_t& x )
{
    in.read( (char*)&x, sizeof(x) );
}

.. geht alles viel einfacher.

Hier in Deine Methode eingebaut, unter Berücksichtigung dessen, was hier bereits erwähnt wurde.

void WaveFormat::readFileVersuchen (Steinberg::String samplePath)
{
    using namespace std;
    ifstream fileStream(samplePath.c_str(), ios_base::binary ); // ios_base::binary MUSS sein
    if (!fileStream.is_open())
        return;

    string tag;
    readbin( fileStream, tag, 4 );
    if( !fileStream || tag != "RIFF" ) // mChunkID
    {
        cerr << "keine RIFF-Datei" << endl;
        return;
    }
    readbin( fileStream, mChunkSize );
    readbin( fileStream, tag, 4 );
    if( !fileStream || tag != "WAVE" ) // mFormat
    {
        cerr << "keine WAVE-Datei" << endl;
        return;
    }

    for( uint32_t len; ; )
    {
        // --   Header des jeweiligen Chunks einlesen: tag + len
        readbin( fileStream, tag, 4 );
        readbin( fileStream, len );
        if( !fileStream )
            break; // EOF

        cout << "Chunk: " << tag << " Len:" << len << endl;
        if( tag == "fmt " ) // abhängig vom Chunk-Typ die Details lesen
        {
            readbin( fileStream, mAudioFormat );
            readbin( fileStream, mNumChannels );
            readbin( fileStream, mSampleRate );
            readbin( fileStream, mByteRate );
            readbin( fileStream, mBlockAlign );
            readbin( fileStream, mBitsPerSample );
            if( fileStream )
                cout << "fmt ohne Fehler gelesen" << endl; 
        }
        // else if( tag == "data" ) // hier kommt der Ton
        // {}
        else
        {
            fileStream.ignore( len ); // unbekannten Chunk überspringen
        }
    }
}

und schon sind es nur noch 50 Zeilen statt 90 und die Methode tut auch noch mehr.

Gruß
Werner

Das kann man ja gar nicht mit ansehen!
Du liest aus einer Datei mit binärem Inhalt doch nur Zeichenketten und uint23_t und uint16_t-Werte. Schreibe Dir doch zunächst mal dafür jeweils eine kleine Funktion, die das erledigt.

Es gibt sicher schöneres, als das was ich Dir hier vorschlage - siehe ibinstream, aber ich will das mal auf Deinem Programm aufbauen.

Also mit den drei Funktionen ...

#include <string>
#include <istream>
#include <cstdint>

void readbin( std::istream& in, std::string& str, std::size_t n )
{
    const std::size_t N = 100;
    char buf[N]; // hier mal ganz anfängermäßig!
    if( n > N )
        in.setstate( std::ios_base::failbit );
    if( in.read( buf, n ) )
        str.assign( buf, buf + n );
}
void readbin( std::istream& in, std::uint32_t& x )
{   // ACHTUNG: Dein OS muss Little Endian haben (z.B.: Windows), nur dann ist dies ok!
    in.read( (char*)&x, sizeof(x) );
}
void readbin( std::istream& in, std::uint16_t& x )
{
    in.read( (char*)&x, sizeof(x) );
}

.. geht alles viel einfacher.

Hier in Deine Methode eingebaut, unter Berücksichtigung dessen, was hier bereits erwähnt wurde.

void WaveFormat::readFileVersuchen (Steinberg::String samplePath)
{
    using namespace std;
    ifstream fileStream(samplePath.c_str(), ios_base::binary ); // ios_base::binary MUSS sein
    if (!fileStream.is_open())
        return;

    string tag;
    readbin( fileStream, tag, 4 );
    if( !fileStream || tag != "RIFF" ) // mChunkID
    {
        cerr << "keine RIFF-Datei" << endl;
        return;
    }
    readbin( fileStream, mChunkSize );
    readbin( fileStream, tag, 4 );
    if( !fileStream || tag != "WAVE" ) // mFormat
    {
        cerr << "keine WAVE-Datei" << endl;
        return;
    }

    for( uint32_t len; ; )
    {
        // --   Header des jeweiligen Chunks einlesen: tag + len
        readbin( fileStream, tag, 4 );
        readbin( fileStream, len );
        if( !fileStream )
            break; // EOF

        cout << "Chunk: " << tag << " Len:" << len << endl;
        if( tag == "fmt " ) // abhängig vom Chunk-Typ die Details lesen
        {
            readbin( fileStream, mAudioFormat );
            readbin( fileStream, mNumChannels );
            readbin( fileStream, mSampleRate );
            readbin( fileStream, mByteRate );
            readbin( fileStream, mBlockAlign );
            readbin( fileStream, mBitsPerSample );
            if( fileStream )
                cout << "fmt ohne Fehler gelesen" << endl; 
        }
        // else if( tag == "data" ) // hier kommt der Ton
        // {}
        else
        {
            fileStream.ignore( len ); // unbekannten Chunk überspringen
        }
    }
}

und schon sind es nur noch 50 Zeilen statt 90 und die Methode tut auch noch mehr.

Gruß
Werner

vielen dank, aber habe trotzdem nochmal weiter versucht selber das hinzukiregen.
Hat auch endlich halbwegs geklappt! Ich kriege jetzt die richtigen Werte heraus, allerdings nur in hexadezimal, und manche muss man davon noch umdrehen. Bei der Samplerate steht zum Beispiel: 0080bb00. Dreht man das um steht dort bb80 und das sind 48000! Und das ist ja bekanntlich nen passender Wert für ne Samplerate. Ich denkee das liegt dann wohl an little und Big Endian. Werde jetzt mal versuchen das komplett hinzukriegen.
Code:

void WaveFormat::readFileVersuchen (Steinberg::String samplePath)
{
	bool dump = true;
	wofstream ftest("C:\\Users\\Otto\\waveDaten.txt", ios::out);
	std::string fmtMarker;
	std::string fmtString = "fmt ";
	int chunkState = kChunkDescriptor;
	fstream fileStream;
	fileStream.open(samplePath.text (), ios::in);
	int byteCounter = 0;
	bool isSignalSounded = false;			// Gibt true an, wenn fmt erreicht wurde
	int8 oneByte = 0;
	if (fileStream.is_open())
	{
		while (!fileStream.eof())
		{
			//int au = sizeof(Steinberg::uint8);
			fileStream.read(&oneByte, sizeof(Steinberg::uint8)); 
			if (dump)
			{
				ftest << oneByte << std::hex;
			}

			if (chunkState == kChunkDescriptor)
			{
				if (byteCounter>=0 && byteCounter <= 3)
				{
					mChunkID <<= sizeof(Steinberg::uint8) * 8;
					mChunkID |= oneByte & 0xFF;
				}
				else if (byteCounter>=4 && byteCounter <=7)
				{
					mChunkSize <<= sizeof(Steinberg::uint8) * 8;
					mChunkSize |= oneByte & 0xFF;
				}
				else if (byteCounter>=8 && byteCounter <=11)				
				{
					mFormat <<= sizeof(Steinberg::uint8) * 8;				                     
					mFormat |= oneByte & 0xFF;
					if (byteCounter == 11)
					{
						chunkState = kFmtSubChunk;
					}
				}
			}
			else if (chunkState == kFmtSubChunk)
			{
				static const string kFmtMarker = "";
				if (oneByte == 0)
				{
					fmtMarker.push_back (' ');
				}
				else
				{
					fmtMarker.push_back (oneByte);
 					int hmmmm = fmtMarker.find(fmtString);
					if (hmmmm > 0 && !isSignalSounded)		// && !isSignalSounded entfernen um die Sachen nach fmt in die Datei mitzuschreiben
					{
						fileStream.read(&oneByte, sizeof(Steinberg::uint8));			// ???
						isSignalSounded = true;											// Da fmt erreicht wurde, wird hier nicht mehr reingesprungen
						byteCounter = 17;												// Setze den ByteCounter auf 17 zurück, damit die Schleifen unterhalb durchlaufen werden.
						ofstream ftest("C:\\Users\\Otto\\waveDaten.txt", ios::out);		// Schreibt zum Testen eine
						ftest << fmtMarker;												// Textdatei mit den Daten. (Noch keine umgewandelten)
						//turnHex(0xccbb3344);											// Test ob das umdrehen klappt
					}
				}
/*				if (byteCounter>=12 && byteCounter <=15 && isSignalSounded == true)
				{
					mSubChunk1ID <<= sizeof(Steinberg::uint8) * 8;				                     
					mSubChunk1ID |= oneByte & 0xFF;
				}				*/   
				if (byteCounter>=16 && byteCounter <=19 && isSignalSounded == true)
				{
					mSubChunk1Size <<= sizeof(Steinberg::uint8) * 8;
					mSubChunk1Size |= oneByte & 0xFF;
				}
				else if (byteCounter>=20 && byteCounter <=21 && isSignalSounded == true)
				{
					mAudioFormat <<= sizeof(Steinberg::uint8) * 8;				                     
					mAudioFormat |= oneByte & 0xFF;
				}
				else if (byteCounter>=22 && byteCounter <=23 && isSignalSounded == true)
				{
					mNumChannels <<= sizeof(Steinberg::uint8) * 8;				                     
					mNumChannels |= oneByte & 0xFF;
				}
				else if (byteCounter>=24 && byteCounter <=27 && isSignalSounded == true)
				{
					mSampleRate <<= sizeof(Steinberg::uint8) * 8;				                     
					mSampleRate |= oneByte & 0xFF;
				}
				else if (byteCounter>=28 && byteCounter <=31 && isSignalSounded == true)
				{						   
					mByteRate <<= sizeof(Steinberg::uint8) * 8;				                     
					mByteRate |= oneByte & 0xFF;
				}
				else if (byteCounter>=32 && byteCounter <=33 && isSignalSounded == true)
				{
					mBlockAlign <<= sizeof(Steinberg::uint8) * 8;				                     
					mBlockAlign |= oneByte & 0xFF;
				}
				else if (byteCounter>=34 && byteCounter <=35 && isSignalSounded == true)
				{
					mBitsPerSample <<= sizeof(Steinberg::uint8) * 8;				                     
					mBitsPerSample |= oneByte & 0xFF;
				}	
				else if (byteCounter>=36 && byteCounter <=39 && isSignalSounded == true)
				{
					mSubChunks2ID <<= sizeof(Steinberg::uint8) * 8;				                     
					mSubChunks2ID |= oneByte & 0xFF;
				}
				else if (byteCounter>=40 && byteCounter <=43 && isSignalSounded == true)
				{
					mSubchunck2Size <<= sizeof(Steinberg::uint8) * 8;				                     
					mSubchunck2Size |= oneByte & 0xFF;
				}
				else if (byteCounter >=44)
				{

				}
			}			
			byteCounter++;
		}
	}
}

vielen dank, aber habe trotzdem nochmal weiter versucht selber das hinzukiregen.
Hat auch endlich halbwegs geklappt! Ich kriege jetzt die richtigen Werte heraus, allerdings nur in hexadezimal, und manche muss man davon noch umdrehen. Bei der Samplerate steht zum Beispiel: 0080bb00. Dreht man das um steht dort bb80 und das sind 48000! Und das ist ja bekanntlich nen passender Wert für ne Samplerate. Ich denkee das liegt dann wohl an little und Big Endian.

Nö - das liegt an Dir.

Ändere an Deinem Programm folgendes:
- Zeile 9 Daten BINÄR lesen

fileStream.open(samplePath.text (), ios::in | ios::binary);

wenn Du das nicht tust, wird spätestens das Lesen der Audiodaten fehlschlagen!

- Zeile 57 >= 0

if (hmmmm >= 0 && !isSignalSounded)

wird der fmt_-String gefunden, so kann ' hmmmm ' auch den Wert 0 annehmen, falls der erste Chunk bereits der 'fmt_'-Chunk ist.

- Zeile 61

byteCounter = 16;

- Zeile 89 und 90
ersetze diese beiden Zeilen bitte durch

if( byteCounter == 24 )
                        mSampleRate = 0;
                    mSampleRate |= (oneByte & 0xFF) << 8*(byteCounter - 24);

Du wirst sehen, dass hilft - auch wenn Du danach noch nicht am Ziel bist.

Gruß
Werner

kennst du schon das for-case Antipattern? Dein Code ist also ein Paradebeispiel dafür.
Auch wenn der Code von Werner dir vllt. jetzt noch etwas zu hoch vorkommt, so solltest du doch unsere Ratschläge annehmen...